[ VIGRA Homepage | Function Index | Class Index | Namespaces | File List | Main Page ]
00001 /************************************************************************/ 00002 /* */ 00003 /* Copyright 1998-2002 by Ullrich Koethe */ 00004 /* */ 00005 /* This file is part of the VIGRA computer vision library. */ 00006 /* The VIGRA Website is */ 00007 /* http://hci.iwr.uni-heidelberg.de/vigra/ */ 00008 /* Please direct questions, bug reports, and contributions to */ 00009 /* ullrich.koethe@iwr.uni-heidelberg.de or */ 00010 /* vigra@informatik.uni-hamburg.de */ 00011 /* */ 00012 /* Permission is hereby granted, free of charge, to any person */ 00013 /* obtaining a copy of this software and associated documentation */ 00014 /* files (the "Software"), to deal in the Software without */ 00015 /* restriction, including without limitation the rights to use, */ 00016 /* copy, modify, merge, publish, distribute, sublicense, and/or */ 00017 /* sell copies of the Software, and to permit persons to whom the */ 00018 /* Software is furnished to do so, subject to the following */ 00019 /* conditions: */ 00020 /* */ 00021 /* The above copyright notice and this permission notice shall be */ 00022 /* included in all copies or substantial portions of the */ 00023 /* Software. */ 00024 /* */ 00025 /* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND */ 00026 /* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES */ 00027 /* OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND */ 00028 /* NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT */ 00029 /* HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, */ 00030 /* WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING */ 00031 /* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR */ 00032 /* OTHER DEALINGS IN THE SOFTWARE. */ 00033 /* */ 00034 /************************************************************************/ 00035 00036 00037 #ifndef VIGRA_COMBINEIMAGES_HXX 00038 #define VIGRA_COMBINEIMAGES_HXX 00039 00040 #include "utilities.hxx" 00041 #include "numerictraits.hxx" 00042 #include "functortraits.hxx" 00043 #include <cmath> 00044 00045 namespace vigra { 00046 00047 /** \addtogroup CombineAlgo Algorithms to Combine Images 00048 00049 Apply functor to calculate a pixelwise transformation depending on multiple images. 00050 Note that the binary functors of the STL may be used with these functions. 00051 */ 00052 //@{ 00053 00054 /********************************************************/ 00055 /* */ 00056 /* combine...Lines */ 00057 /* */ 00058 /********************************************************/ 00059 00060 template <class SrcIterator1, class SrcAccessor1, 00061 class SrcIterator2, class SrcAccessor2, 00062 class DestIterator, class DestAccessor, class Functor> 00063 void 00064 combineTwoLines(SrcIterator1 s1, 00065 SrcIterator1 s1end, SrcAccessor1 src1, 00066 SrcIterator2 s2, SrcAccessor2 src2, 00067 DestIterator d, DestAccessor dest, 00068 Functor const & f) 00069 { 00070 for(; s1 != s1end; ++s1, ++s2, ++d) 00071 dest.set(f(src1(s1), src2(s2)), d); 00072 } 00073 00074 template <class SrcIterator1, class SrcAccessor1, 00075 class SrcIterator2, class SrcAccessor2, 00076 class MaskIterator, class MaskAccessor, 00077 class DestIterator, class DestAccessor, class Functor> 00078 void 00079 combineTwoLinesIf(SrcIterator1 s1, 00080 SrcIterator1 s1end, SrcAccessor1 src1, 00081 SrcIterator2 s2, SrcAccessor2 src2, 00082 MaskIterator m, MaskAccessor mask, 00083 DestIterator d, DestAccessor dest, 00084 Functor const & f) 00085 { 00086 for(; s1 != s1end; ++s1, ++s2, ++m, ++d) 00087 if(mask(m)) 00088 dest.set(f(src1(s1), src2(s2)), d); 00089 } 00090 00091 template <class SrcIterator1, class SrcAccessor1, 00092 class SrcIterator2, class SrcAccessor2, 00093 class SrcIterator3, class SrcAccessor3, 00094 class DestIterator, class DestAccessor, class Functor> 00095 void 00096 combineThreeLines(SrcIterator1 s1, 00097 SrcIterator1 s1end, SrcAccessor1 src1, 00098 SrcIterator2 s2, SrcAccessor2 src2, 00099 SrcIterator3 s3, SrcAccessor3 src3, 00100 DestIterator d, DestAccessor dest, 00101 Functor const & f) 00102 { 00103 for(; s1 != s1end; ++s1, ++s2, ++s3, ++d) 00104 dest.set(f(src1(s1), src2(s2), src3(s3)), d); 00105 } 00106 00107 /********************************************************/ 00108 /* */ 00109 /* combineTwoImages */ 00110 /* */ 00111 /********************************************************/ 00112 00113 /** \brief Combine two source images into destination image. 00114 00115 The transformation given by the functor is applied to the source 00116 pixels and the result written into the corresponding destination pixel. 00117 This is typically used for operations like add and subtract. 00118 The function uses accessors to access the pixel data. 00119 Note that the binary functors of the STL can be used in addition to 00120 the functors specifically defined in \ref CombineFunctor. 00121 Creation of new functors is easiest by using \ref FunctorExpressions. 00122 00123 <b> Declarations:</b> 00124 00125 pass arguments explicitly: 00126 \code 00127 namespace vigra { 00128 template <class SrcImageIterator1, class SrcAccessor1, 00129 class SrcImageIterator2, class SrcAccessor2, 00130 class DestImageIterator, class DestAccessor, 00131 class Functor> 00132 void 00133 combineTwoImages(SrcImageIterator1 src1_upperleft, 00134 SrcImageIterator1 src1_lowerright, SrcAccessor1 sa1, 00135 SrcImageIterator2 src2_upperleft, SrcAccessor2 sa2, 00136 DestImageIterator dest_upperleft, DestAccessor da, 00137 Functor const & f) 00138 } 00139 \endcode 00140 00141 00142 use argument objects in conjunction with \ref ArgumentObjectFactories : 00143 \code 00144 namespace vigra { 00145 template <class SrcImageIterator1, class SrcAccessor1, 00146 class SrcImageIterator2, class SrcAccessor2, 00147 class DestImageIterator, class DestAccessor, 00148 class Functor> 00149 void 00150 combineTwoImages(triple<SrcImageIterator1, SrcImageIterator1, SrcAccessor1> src1, 00151 pair<SrcImageIterator2, SrcAccessor2> src2, 00152 pair<DestImageIterator, DestAccessor> dest, 00153 Functor const & f) 00154 } 00155 \endcode 00156 00157 <b> Usage:</b> 00158 00159 <b>\#include</b> <<a href="combineimages_8hxx-source.html">vigra/combineimages.hxx</a>><br> 00160 Namespace: vigra 00161 00162 \code 00163 #include <functional> // for plus 00164 00165 vigra::combineTwoImages( 00166 srcIterRange(src1.upperLeft(), src1.lowerRight()), 00167 srcIter(src2.upperLeft()), 00168 destIter(dest.upperLeft()), 00169 std::plus<SrcValueType>()); 00170 00171 \endcode 00172 00173 Note that <TT>SrcValueType</TT> must be replaced with the appropriate type (e.g. 00174 the promote type of the input images' pixel type, see also 00175 \ref NumericPromotionTraits) 00176 00177 <b> Required Interface:</b> 00178 00179 \code 00180 SrcImageIterator1 src1_upperleft, src1_lowerright; 00181 SrcImageIterator2 src2_upperleft; 00182 DestImageIterator dest_upperleft; 00183 SrcImageIterator1::row_iterator sx1 = src1_upperleft.rowIterator(); 00184 SrcImageIterator2::row_iterator sx2 = src2_upperleft.rowIterator(); 00185 DestImageIterator::row_iterator dx = dest_upperleft.rowIterator(); 00186 00187 SrcAccessor1 src1_accessor; 00188 SrcAccessor2 src2_accessor; 00189 DestAccessor dest_accessor; 00190 00191 Functor functor; 00192 00193 dest_accessor.set( 00194 functor(src1_accessor(sx1), src2_accessor(sx2)), 00195 dx); 00196 00197 \endcode 00198 00199 00200 */ 00201 doxygen_overloaded_function(template <...> void combineTwoImages) 00202 00203 template <class SrcImageIterator1, class SrcAccessor1, 00204 class SrcImageIterator2, class SrcAccessor2, 00205 class DestImageIterator, class DestAccessor, 00206 class Functor> 00207 void 00208 combineTwoImages(SrcImageIterator1 src1_upperleft, 00209 SrcImageIterator1 src1_lowerright, SrcAccessor1 sa1, 00210 SrcImageIterator2 src2_upperleft, SrcAccessor2 sa2, 00211 DestImageIterator dest_upperleft, DestAccessor da, 00212 Functor const & f) 00213 { 00214 int w = src1_lowerright.x - src1_upperleft.x; 00215 00216 for(; src1_upperleft.y < src1_lowerright.y; 00217 ++src1_upperleft.y, ++src2_upperleft.y, ++dest_upperleft.y) 00218 { 00219 combineTwoLines(src1_upperleft.rowIterator(), 00220 src1_upperleft.rowIterator() + w, sa1, 00221 src2_upperleft.rowIterator(), sa2, 00222 dest_upperleft.rowIterator(), da, f); 00223 } 00224 } 00225 00226 template <class SrcImageIterator1, class SrcAccessor1, 00227 class SrcImageIterator2, class SrcAccessor2, 00228 class DestImageIterator, class DestAccessor, 00229 class Functor> 00230 inline 00231 void 00232 combineTwoImages(triple<SrcImageIterator1, SrcImageIterator1, SrcAccessor1> src1, 00233 pair<SrcImageIterator2, SrcAccessor2> src2, 00234 pair<DestImageIterator, DestAccessor> dest, 00235 Functor const & f) 00236 { 00237 combineTwoImages(src1.first, src1.second, src1.third, 00238 src2.first, src2.second, 00239 dest.first, dest.second, f); 00240 } 00241 00242 /********************************************************/ 00243 /* */ 00244 /* combineTwoImagesIf */ 00245 /* */ 00246 /********************************************************/ 00247 00248 /** \brief Combine ROI of two source images into destination image. 00249 00250 The transformation given by the functor is applied to all source 00251 pixels in the ROI (i.e. whenever the return value of the mask's accessor 00252 is not zero) 00253 and the result written into the corresponding destination pixel. 00254 This is typically used for operations like add and subtract. 00255 The function uses accessors to access the pixel data. 00256 Note that the binary functors of the STL can be used in addition to 00257 the functors specifically defined in \ref CombineFunctor. 00258 Creation of new functors is easiest by using \ref FunctorExpressions. 00259 00260 <b> Declarations:</b> 00261 00262 pass arguments explicitly: 00263 \code 00264 namespace vigra { 00265 template <class SrcImageIterator1, class SrcAccessor1, 00266 class SrcImageIterator2, class SrcAccessor2, 00267 class MaskImageIterator, class MaskAccessor, 00268 class DestImageIterator, clas DestAccessor, 00269 class Functor> 00270 void 00271 combineTwoImagesIf(SrcImageIterator1 src1_upperleft, 00272 SrcImageIterator1 src1_lowerright, SrcAccessor1 sa1, 00273 SrcImageIterator2 src2_upperleft, SrcAccessor2 sa2, 00274 MaskImageIterator mask_upperleft, MaskAccessor ma, 00275 DestImageIterator dest_upperleft, DestAccessor da, 00276 Functor const & f) 00277 } 00278 \endcode 00279 00280 00281 use argument objects in conjunction with \ref ArgumentObjectFactories : 00282 \code 00283 namespace vigra { 00284 template <class SrcImageIterator1, class SrcAccessor1, 00285 class SrcImageIterator2, class SrcAccessor2, 00286 class MaskImageIterator, class MaskAccessor, 00287 class DestImageIterator, clas DestAccessor, 00288 class Functor> 00289 void 00290 combineTwoImagesIf(triple<SrcImageIterator1, SrcImageIterator1, SrcAccessor1> src1, 00291 pair<SrcImageIterator2, SrcAccessor2> src2, 00292 pair<MaskImageIterator, MaskAccessor> mask, 00293 pair<DestImageIterator, DestAccessor> dest, 00294 Functor const & f) 00295 } 00296 \endcode 00297 00298 <b> Usage:</b> 00299 00300 <b>\#include</b> <<a href="combineimages_8hxx-source.html">vigra/combineimages.hxx</a>><br> 00301 Namespace: vigra 00302 00303 \code 00304 #include <functional> // for plus 00305 00306 vigra::combineTwoImagesIf( 00307 srcIterRange(src1.upperLeft(), src1.lowerRight()), 00308 srcIter(src2.upperLeft()), 00309 maskIter(mask.upperLeft()), 00310 destIter(dest.upperLeft()), 00311 std::plus<SrcValueType>()); 00312 00313 \endcode 00314 00315 Note that <TT>SrcValueType</TT> must be replaced with the appropriate type (e.g. 00316 the promote type of the input images' pixel type, see also 00317 \ref NumericPromotionTraits) 00318 00319 <b> Required Interface:</b> 00320 00321 \code 00322 SrcImageIterator1 src1_upperleft, src1_lowerright; 00323 SrcImageIterator2 src2_upperleft; 00324 MaskImageIterator mask_upperleft; 00325 DestImageIterator dest_upperleft; 00326 SrcImageIterator1::row_iterator sx1 = src1_upperleft.rowIterator(); 00327 SrcImageIterator2::row_iterator sx2 = src2_upperleft.rowIterator(); 00328 MaskImageIterator::row_iterator mx = mask_upperleft.rowIterator(); 00329 DestImageIterator::row_iterator dx = dest_upperleft.rowIterator(); 00330 00331 00332 SrcAccessor1 src1_accessor; 00333 SrcAccessor2 src2_accessor; 00334 MaskAccessor mask_accessor; 00335 DestAccessor dest_accessor; 00336 00337 Functor functor; 00338 00339 if(mask_accessor(mx)) 00340 dest_accessor.set( 00341 functor(src1_accessor(sx1), src2_accessor(sx2)), 00342 dx); 00343 00344 \endcode 00345 00346 */ 00347 doxygen_overloaded_function(template <...> void combineTwoImagesIf) 00348 00349 template <class SrcImageIterator1, class SrcAccessor1, 00350 class SrcImageIterator2, class SrcAccessor2, 00351 class MaskImageIterator, class MaskAccessor, 00352 class DestImageIterator, class DestAccessor, 00353 class Functor> 00354 void 00355 combineTwoImagesIf(SrcImageIterator1 src1_upperleft, 00356 SrcImageIterator1 src1_lowerright, SrcAccessor1 sa1, 00357 SrcImageIterator2 src2_upperleft, SrcAccessor2 sa2, 00358 MaskImageIterator mask_upperleft, MaskAccessor ma, 00359 DestImageIterator dest_upperleft, DestAccessor da, 00360 Functor const & f) 00361 { 00362 int w = src1_lowerright.x - src1_upperleft.x; 00363 00364 for(; src1_upperleft.y < src1_lowerright.y; 00365 ++src1_upperleft.y, ++src2_upperleft.y, 00366 ++dest_upperleft.y, ++mask_upperleft.y) 00367 { 00368 combineTwoLinesIf(src1_upperleft.rowIterator(), 00369 src1_upperleft.rowIterator() + w, sa1, 00370 src2_upperleft.rowIterator(), sa2, 00371 mask_upperleft.rowIterator(), ma, 00372 dest_upperleft.rowIterator(), da, f); 00373 } 00374 } 00375 00376 template <class SrcImageIterator1, class SrcAccessor1, 00377 class SrcImageIterator2, class SrcAccessor2, 00378 class MaskImageIterator, class MaskAccessor, 00379 class DestImageIterator, class DestAccessor, 00380 class Functor> 00381 inline 00382 void 00383 combineTwoImagesIf(triple<SrcImageIterator1, SrcImageIterator1, SrcAccessor1> src1, 00384 pair<SrcImageIterator2, SrcAccessor2> src2, 00385 pair<MaskImageIterator, MaskAccessor> mask, 00386 pair<DestImageIterator, DestAccessor> dest, 00387 Functor const & f) 00388 { 00389 combineTwoImagesIf(src1.first, src1.second, src1.third, 00390 src2.first, src2.second, 00391 mask.first, mask.second, 00392 dest.first, dest.second, f); 00393 } 00394 00395 /********************************************************/ 00396 /* */ 00397 /* combineThreeImages */ 00398 /* */ 00399 /********************************************************/ 00400 00401 /** \brief Combine three source images into destination image. 00402 00403 The transformation given by the functor is applied to the source 00404 pixels and the result written into the corresponding destination pixel. 00405 The function uses accessors to access the pixel data. 00406 Creation of new functors is easiest by using \ref FunctorExpressions. 00407 00408 <b> Declarations:</b> 00409 00410 pass arguments explicitly: 00411 \code 00412 namespace vigra { 00413 template <class SrcImageIterator1, class SrcAccessor1, 00414 class SrcImageIterator2, class SrcAccessor2, 00415 class SrcImageIterator3, class SrcAccessor3, 00416 class DestImageIterator, class DestAccessor, 00417 class Functor> 00418 void 00419 combineThreeImages(SrcImageIterator1 src1_upperleft, 00420 SrcImageIterator1 src1_lowerright, SrcAccessor1 sa1, 00421 SrcImageIterator2 src2_upperleft, SrcAccessor2 sa2, 00422 SrcImageIterator3 src2_upperleft, SrcAccessor3 sa3, 00423 DestImageIterator dest_upperleft, DestAccessor da, 00424 Functor const & f) 00425 } 00426 \endcode 00427 00428 00429 use argument objects in conjunction with \ref ArgumentObjectFactories : 00430 \code 00431 namespace vigra { 00432 template <class SrcImageIterator1, class SrcAccessor1, 00433 class SrcImageIterator2, class SrcAccessor2, 00434 class SrcImageIterator3, class SrcAccessor3, 00435 class DestImageIterator, class DestAccessor, 00436 class Functor> 00437 void 00438 combineThreeImages(triple<SrcImageIterator1, SrcImageIterator1, SrcAccessor1> src1, 00439 pair<SrcImageIterator2, SrcAccessor2> src2, 00440 pair<SrcImageIterator3, SrcAccessor3> src3, 00441 pair<DestImageIterator, DestAccessor> dest, 00442 Functor const & f) 00443 } 00444 \endcode 00445 00446 <b> Usage:</b> 00447 00448 <b>\#include</b> <<a href="combineimages_8hxx-source.html">vigra/combineimages.hxx</a>><br> 00449 Namespace: vigra 00450 00451 \code 00452 vigra::combineThreeImages( 00453 srcIterRange(src1.upperLeft(), src1.lowerRight()), 00454 srcIter(src2.upperLeft()), 00455 srcIter(src3.upperLeft()), 00456 destIter(dest.upperLeft()), 00457 SomeThreeArgumentFunctor()); 00458 00459 \endcode 00460 00461 <b> Required Interface:</b> 00462 00463 \code 00464 SrcImageIterator1 src1_upperleft, src1_lowerright; 00465 SrcImageIterator2 src2_upperleft; 00466 SrcImageIterator3 src3_upperleft; 00467 DestImageIterator dest_upperleft; 00468 SrcImageIterator1::row_iterator sx1 = src1_upperleft.rowIterator(); 00469 SrcImageIterator2::row_iterator sx2 = src2_upperleft.rowIterator(); 00470 SrcImageIterator3::row_iterator sx3 = src3_upperleft.rowIterator(); 00471 DestImageIterator::row_iterator dx = dest_upperleft.rowIterator(); 00472 00473 SrcAccessor1 src1_accessor; 00474 SrcAccessor2 src2_accessor; 00475 SrcAccessor3 src3_accessor; 00476 DestAccessor dest_accessor; 00477 00478 Functor functor; 00479 00480 dest_accessor.set( 00481 functor(src1_accessor(sx1), 00482 src2_accessor(sx2), 00483 src3_accessor(sx3)), 00484 dx); 00485 00486 \endcode 00487 00488 00489 */ 00490 doxygen_overloaded_function(template <...> void combineThreeImages) 00491 00492 template <class SrcImageIterator1, class SrcAccessor1, 00493 class SrcImageIterator2, class SrcAccessor2, 00494 class SrcImageIterator3, class SrcAccessor3, 00495 class DestImageIterator, class DestAccessor, 00496 class Functor> 00497 void 00498 combineThreeImages(SrcImageIterator1 src1_upperleft, 00499 SrcImageIterator1 src1_lowerright, SrcAccessor1 sa1, 00500 SrcImageIterator2 src2_upperleft, SrcAccessor2 sa2, 00501 SrcImageIterator3 src3_upperleft, SrcAccessor3 sa3, 00502 DestImageIterator dest_upperleft, DestAccessor da, 00503 Functor const & f) 00504 { 00505 int w = src1_lowerright.x - src1_upperleft.x; 00506 00507 for(; src1_upperleft.y < src1_lowerright.y; 00508 ++src1_upperleft.y, ++src2_upperleft.y, ++src3_upperleft.y, 00509 ++dest_upperleft.y) 00510 { 00511 combineThreeLines(src1_upperleft.rowIterator(), 00512 src1_upperleft.rowIterator() + w, sa1, 00513 src2_upperleft.rowIterator(), sa2, 00514 src3_upperleft.rowIterator(), sa3, 00515 dest_upperleft.rowIterator(), da, f); 00516 } 00517 } 00518 00519 template <class SrcImageIterator1, class SrcAccessor1, 00520 class SrcImageIterator2, class SrcAccessor2, 00521 class SrcImageIterator3, class SrcAccessor3, 00522 class DestImageIterator, class DestAccessor, 00523 class Functor> 00524 inline 00525 void 00526 combineThreeImages(triple<SrcImageIterator1, SrcImageIterator1, SrcAccessor1> src1, 00527 pair<SrcImageIterator2, SrcAccessor2> src2, 00528 pair<SrcImageIterator3, SrcAccessor3> src3, 00529 pair<DestImageIterator, DestAccessor> dest, 00530 Functor const & f) 00531 { 00532 combineThreeImages(src1.first, src1.second, src1.third, 00533 src2.first, src2.second, 00534 src3.first, src3.second, 00535 dest.first, dest.second, f); 00536 } 00537 00538 00539 //@} 00540 00541 /** \addtogroup CombineFunctor Functors to Combine Images 00542 00543 Common functors with several arguments 00544 */ 00545 //@{ 00546 00547 /********************************************************/ 00548 /* */ 00549 /* MagnitudeFunctor */ 00550 /* */ 00551 /********************************************************/ 00552 00553 /** Calculate the magnitude from two arguments. 00554 Can be used in conjunction with \ref gradientBasedTransform(). 00555 00556 If the gradient is represented by a vector-valued image instead of 00557 a pair of scalar images, use \ref vigra::VectorNormFunctor. 00558 00559 <b> Traits defined:</b> 00560 00561 <tt>FunctorTraits::isBinaryFunctor</tt> are true (<tt>VigraTrueType</tt>) 00562 */ 00563 template <class ValueType> 00564 class MagnitudeFunctor 00565 { 00566 public: 00567 /** the functor's first argument type 00568 */ 00569 typedef ValueType first_argument_type; 00570 00571 /** the functor's second argument type 00572 */ 00573 typedef ValueType second_argument_type; 00574 00575 /** the functor's result type 00576 */ 00577 typedef typename SquareRootTraits<typename NormTraits<ValueType>::SquaredNormType>::SquareRootResult result_type; 00578 00579 /** \deprecated use first_argument_type, second_argument_type, result_type 00580 */ 00581 typedef ValueType value_type; 00582 00583 /** calculate transform '<TT>sqrt(squaredNorm(v1) + squaredNorm(v2))</TT>'. 00584 00585 */ 00586 result_type operator()(first_argument_type const & v1, second_argument_type const & v2) const 00587 { 00588 return VIGRA_CSTD::sqrt(squaredNorm(v1) + squaredNorm(v2)); 00589 } 00590 }; 00591 00592 template <class T> 00593 class FunctorTraits<MagnitudeFunctor<T> > 00594 : public FunctorTraitsBase<MagnitudeFunctor<T> > 00595 { 00596 public: 00597 typedef VigraTrueType isBinaryFunctor; 00598 }; 00599 00600 /********************************************************/ 00601 /* */ 00602 /* RGBGradientMagnitudeFunctor */ 00603 /* */ 00604 /********************************************************/ 00605 00606 00607 /** Calculate the gradient magnitude from RGB arguments. 00608 Can be used in conjunction with \ref gradientBasedTransform(). 00609 00610 <b> Traits defined:</b> 00611 00612 <tt>FunctorTraits::isBinaryFunctor</tt> are true (<tt>VigraTrueType</tt>) 00613 */ 00614 template <class ValueType> 00615 class RGBGradientMagnitudeFunctor 00616 { 00617 public: 00618 /** the functor's first argument type 00619 */ 00620 typedef RGBValue<ValueType> first_argument_type; 00621 00622 /** the functor's second argument type 00623 */ 00624 typedef RGBValue<ValueType> second_argument_type; 00625 00626 /** the functor's result type 00627 */ 00628 typedef typename NumericTraits<ValueType>::RealPromote result_type; 00629 00630 /** \deprecated use first_argument_type, second_argument_type, result_type 00631 */ 00632 typedef ValueType value_type; 00633 00634 /** Calculate the gradient magnitude form given RGB components. 00635 The function returns 00636 00637 \f[ \sqrt{|\nabla red|^2 + |\nabla green|^2 + |\nabla blue|^2} 00638 \f] 00639 00640 where \f$|\nabla red|^2\f$ is defined by <TT>gx.red()*gx.red() + gy.red()*gy.red()</TT>. 00641 00642 <TT>ValueType</TT> (the RGB's component type) must support addition, multiplication, 00643 abd <TT>sqrt()</TT>. 00644 */ 00645 result_type 00646 operator()(first_argument_type const & gx, second_argument_type const & gy) const 00647 { 00648 return VIGRA_CSTD::sqrt(gx.red()*gx.red() + gx.green()*gx.green() + 00649 gx.blue()*gx.blue() + gy.red()*gy.red() + 00650 gy.green()*gy.green() + gy.blue()*gy.blue()); 00651 } 00652 }; 00653 00654 template <class T> 00655 class FunctorTraits<RGBGradientMagnitudeFunctor<T> > 00656 : public FunctorTraitsBase<RGBGradientMagnitudeFunctor<T> > 00657 { 00658 public: 00659 typedef VigraTrueType isBinaryFunctor; 00660 }; 00661 00662 //@} 00663 00664 } // namespace vigra 00665 00666 #endif // VIGRA_COMBINEIMAGES_HXX
© Ullrich Köthe (ullrich.koethe@iwr.uni-heidelberg.de) |
html generated using doxygen and Python
|