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