[ VIGRA Homepage | Function Index | Class Index | Namespaces | File List | 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 /*    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)
Heidelberg Collaboratory for Image Processing, University of Heidelberg, Germany

html generated using doxygen and Python
VIGRA 1.6.0 (5 Nov 2009)