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