37 #ifndef VIGRA_COMBINEIMAGES_HXX 
   38 #define VIGRA_COMBINEIMAGES_HXX 
   41 #include "numerictraits.hxx" 
   42 #include "functortraits.hxx" 
   43 #include "multi_shape.hxx" 
   62 template <
class SrcIterator1, 
class SrcAccessor1,
 
   63           class SrcIterator2, 
class SrcAccessor2,
 
   64           class DestIterator, 
class DestAccessor, 
class Functor>
 
   66 combineTwoLines(SrcIterator1 s1, 
 
   67                 SrcIterator1 s1end, SrcAccessor1 src1,
 
   68                 SrcIterator2 s2, SrcAccessor2 src2,
 
   69                 DestIterator d, DestAccessor dest,
 
   72     for(; s1 != s1end; ++s1, ++s2, ++d)
 
   73         dest.set(f(src1(s1), src2(s2)), d);
 
   76 template <
class SrcIterator1, 
class SrcAccessor1,
 
   77           class SrcIterator2, 
class SrcAccessor2,
 
   78           class MaskIterator, 
class MaskAccessor, 
 
   79           class DestIterator, 
class DestAccessor, 
class Functor>
 
   81 combineTwoLinesIf(SrcIterator1 s1, 
 
   82                   SrcIterator1 s1end, SrcAccessor1 src1,
 
   83                   SrcIterator2 s2, SrcAccessor2 src2,
 
   84                   MaskIterator m, MaskAccessor mask,
 
   85                   DestIterator d, DestAccessor dest,
 
   88     for(; s1 != s1end; ++s1, ++s2, ++m, ++d)
 
   90             dest.set(f(src1(s1), src2(s2)), d);
 
   93 template <
class SrcIterator1, 
class SrcAccessor1,
 
   94           class SrcIterator2, 
class SrcAccessor2,
 
   95           class SrcIterator3, 
class SrcAccessor3,
 
   96           class DestIterator, 
class DestAccessor, 
class Functor>
 
   98 combineThreeLines(SrcIterator1 s1, 
 
   99                   SrcIterator1 s1end, SrcAccessor1 src1,
 
  100                   SrcIterator2 s2, SrcAccessor2 src2,
 
  101                   SrcIterator3 s3, SrcAccessor3 src3,
 
  102                   DestIterator d, DestAccessor dest,
 
  105     for(; s1 != s1end; ++s1, ++s2, ++s3, ++d)
 
  106         dest.set(f(src1(s1), src2(s2), src3(s3)), d);
 
  231 template <
class SrcImageIterator1, 
class SrcAccessor1,
 
  232           class SrcImageIterator2, 
class SrcAccessor2,
 
  233           class DestImageIterator, 
class DestAccessor,
 
  237                  SrcImageIterator1 src1_lowerright, SrcAccessor1 sa1,
 
  238                  SrcImageIterator2 src2_upperleft, SrcAccessor2 sa2,
 
  239                  DestImageIterator dest_upperleft, DestAccessor da,
 
  242     int w = src1_lowerright.x - src1_upperleft.x;
 
  244     for(; src1_upperleft.y < src1_lowerright.y; 
 
  245             ++src1_upperleft.y, ++src2_upperleft.y, ++dest_upperleft.y)
 
  247         combineTwoLines(src1_upperleft.rowIterator(), 
 
  248                         src1_upperleft.rowIterator() + w, sa1, 
 
  249                         src2_upperleft.rowIterator(), sa2, 
 
  250                         dest_upperleft.rowIterator(), da, f);
 
  254 template <
class SrcImageIterator1, 
class SrcAccessor1,
 
  255           class SrcImageIterator2, 
class SrcAccessor2,
 
  256           class DestImageIterator, 
class DestAccessor,
 
  260 combineTwoImages(triple<SrcImageIterator1, SrcImageIterator1, SrcAccessor1> src1,
 
  261                  pair<SrcImageIterator2, SrcAccessor2> src2,
 
  262                  pair<DestImageIterator, DestAccessor> dest,
 
  266                      src2.first, src2.second, 
 
  267                      dest.first, dest.second, f);
 
  270 template <
class T11, 
class S11,
 
  271           class T12, 
class S12,
 
  276                  MultiArrayView<2, T12, S12> 
const & src2,
 
  277                  MultiArrayView<2, T2, S2> dest,
 
  280     vigra_precondition(src1.shape() == src2.shape() && src1.shape() == dest.shape(),
 
  281         "combineTwoImages(): shape mismatch between inputs and/or output.");
 
  420 template <
class SrcImageIterator1, 
class SrcAccessor1,
 
  421           class SrcImageIterator2, 
class SrcAccessor2,
 
  422           class MaskImageIterator, 
class MaskAccessor,
 
  423           class DestImageIterator, 
class DestAccessor,
 
  427                    SrcImageIterator1 src1_lowerright, SrcAccessor1 sa1,
 
  428                    SrcImageIterator2 src2_upperleft, SrcAccessor2 sa2,
 
  429                    MaskImageIterator mask_upperleft, MaskAccessor ma,
 
  430                    DestImageIterator dest_upperleft, DestAccessor da,
 
  433     int w = src1_lowerright.x - src1_upperleft.x;
 
  435     for(; src1_upperleft.y < src1_lowerright.y;
 
  436           ++src1_upperleft.y, ++src2_upperleft.y, 
 
  437           ++dest_upperleft.y, ++mask_upperleft.y)
 
  439         combineTwoLinesIf(src1_upperleft.rowIterator(), 
 
  440                           src1_upperleft.rowIterator() + w, sa1, 
 
  441                           src2_upperleft.rowIterator(), sa2, 
 
  442                           mask_upperleft.rowIterator(), ma, 
 
  443                           dest_upperleft.rowIterator(), da, f);
 
  447 template <
class SrcImageIterator1, 
class SrcAccessor1,
 
  448           class SrcImageIterator2, 
class SrcAccessor2,
 
  449           class MaskImageIterator, 
class MaskAccessor,
 
  450           class DestImageIterator, 
class DestAccessor,
 
  455                    pair<SrcImageIterator2, SrcAccessor2> src2,
 
  456                    pair<MaskImageIterator, MaskAccessor> mask,
 
  457                    pair<DestImageIterator, DestAccessor> dest,
 
  461                        src2.first, src2.second, 
 
  462                        mask.first, mask.second, 
 
  463                        dest.first, dest.second, f);
 
  466 template <
class T11, 
class S11,
 
  467           class T12, 
class S12,
 
  473                    MultiArrayView<2, T12, S12> 
const & src2,
 
  474                    MultiArrayView<2, TM, SM> 
const & mask,
 
  475                    MultiArrayView<2, T2, S2> dest,
 
  478     vigra_precondition(src1.shape() == src2.shape() && src1.shape() == mask.shape() && src1.shape() == dest.shape(),
 
  479         "combineTwoImagesIf(): shape mismatch between inputs and/or output.");
 
  620 template <
class SrcImageIterator1, 
class SrcAccessor1,
 
  621           class SrcImageIterator2, 
class SrcAccessor2,
 
  622           class SrcImageIterator3, 
class SrcAccessor3,
 
  623           class DestImageIterator, 
class DestAccessor,
 
  627                    SrcImageIterator1 src1_lowerright, SrcAccessor1 sa1,
 
  628                    SrcImageIterator2 src2_upperleft, SrcAccessor2 sa2,
 
  629                    SrcImageIterator3 src3_upperleft, SrcAccessor3 sa3,
 
  630                    DestImageIterator dest_upperleft, DestAccessor da,
 
  633     int w = src1_lowerright.x - src1_upperleft.x;
 
  635     for(; src1_upperleft.y < src1_lowerright.y;
 
  636         ++src1_upperleft.y, ++src2_upperleft.y, ++src3_upperleft.y, 
 
  639         combineThreeLines(src1_upperleft.rowIterator(), 
 
  640                           src1_upperleft.rowIterator() + w, sa1, 
 
  641                           src2_upperleft.rowIterator(), sa2, 
 
  642                           src3_upperleft.rowIterator(), sa3, 
 
  643                           dest_upperleft.rowIterator(), da, f);
 
  647 template <
class SrcImageIterator1, 
class SrcAccessor1,
 
  648           class SrcImageIterator2, 
class SrcAccessor2,
 
  649           class SrcImageIterator3, 
class SrcAccessor3,
 
  650           class DestImageIterator, 
class DestAccessor,
 
  655                    pair<SrcImageIterator2, SrcAccessor2> src2,
 
  656                    pair<SrcImageIterator3, SrcAccessor3> src3,
 
  657                    pair<DestImageIterator, DestAccessor> dest,
 
  661                        src2.first, src2.second, 
 
  662                        src3.first, src3.second, 
 
  663                        dest.first, dest.second, f);
 
  666 template <
class T11, 
class S11,
 
  667           class T12, 
class S12,
 
  668           class T13, 
class S13,
 
  673                    MultiArrayView<2, T12, S12> 
const & src2,
 
  674                    MultiArrayView<2, T13, S13> 
const & src3,
 
  675                    MultiArrayView<2, T2, S2> dest,
 
  678     vigra_precondition(src1.shape() == src2.shape() && src1.shape() == src3.shape() && src1.shape() == dest.shape(),
 
  679         "combineThreeImages(): shape mismatch between inputs and/or output.");
 
  711 template <
class ValueType>
 
  725     typedef typename SquareRootTraits<typename NormTraits<ValueType>::SquaredNormType>::SquareRootResult 
result_type;
 
  741 class FunctorTraits<MagnitudeFunctor<T> >
 
  742 : 
public FunctorTraitsBase<MagnitudeFunctor<T> >
 
  745     typedef VigraTrueType isBinaryFunctor;
 
  762 template <
class ValueType>
 
  776     typedef typename NumericTraits<ValueType>::RealPromote 
result_type;
 
  803 class FunctorTraits<RGBGradientMagnitudeFunctor<T> >
 
  804 : 
public FunctorTraitsBase<RGBGradientMagnitudeFunctor<T> >
 
  807     typedef VigraTrueType isBinaryFunctor;
 
  814 #endif // VIGRA_COMBINEIMAGES_HXX 
RGBValue< ValueType > second_argument_type
Definition: combineimages.hxx:772
RGBValue< ValueType > first_argument_type
Definition: combineimages.hxx:768
value_type & red()
Definition: rgbvalue.hxx:278
ValueType first_argument_type
Definition: combineimages.hxx:717
FFTWComplex< R >::SquaredNormType squaredNorm(const FFTWComplex< R > &a)
squared norm (= squared magnitude) 
Definition: fftw3.hxx:1044
ValueType value_type
Definition: combineimages.hxx:729
SquareRootTraits< typename NormTraits< ValueType >::SquaredNormType >::SquareRootResult result_type
Definition: combineimages.hxx:725
Definition: combineimages.hxx:712
value_type & blue()
Definition: rgbvalue.hxx:286
value_type & green()
Definition: rgbvalue.hxx:282
result_type operator()(first_argument_type const &gx, second_argument_type const &gy) const 
Definition: combineimages.hxx:794
void combineTwoImages(...)
Combine two source images into destination image. 
doxygen_overloaded_function(template<...> void separableConvolveBlockwise) template< unsigned int N
Separated convolution on ChunkedArrays. 
NumericTraits< ValueType >::RealPromote result_type
Definition: combineimages.hxx:776
void combineThreeImages(...)
Combine three source images into destination image. 
Definition: combineimages.hxx:763
void combineTwoImagesIf(...)
Combine ROI of two source images into destination image. 
Class for a single RGB value. 
Definition: accessor.hxx:938
ValueType value_type
Definition: combineimages.hxx:780
SquareRootTraits< FixedPoint< IntBits, FracBits > >::SquareRootResult sqrt(FixedPoint< IntBits, FracBits > v)
square root. 
Definition: fixedpoint.hxx:616
result_type operator()(first_argument_type const &v1, second_argument_type const &v2) const 
Definition: combineimages.hxx:734
ValueType second_argument_type
Definition: combineimages.hxx:721