37 #ifndef VIGRA_COPYIMAGE_HXX 
   38 #define VIGRA_COPYIMAGE_HXX 
   41 #include "multi_shape.hxx" 
   56 template <
class SrcIterator, 
class SrcAccessor,
 
   57           class DestIterator, 
class DestAccessor>
 
   59 copyLine(SrcIterator s, 
 
   60          SrcIterator send, SrcAccessor src,
 
   61          DestIterator d, DestAccessor dest)
 
   63     for(; s != send; ++s, ++d)
 
   67 template <
class SrcIterator, 
class SrcAccessor,
 
   68           class MaskIterator, 
class MaskAccessor, 
 
   69           class DestIterator, 
class DestAccessor>
 
   71 copyLineIf(SrcIterator s, 
 
   72            SrcIterator send, SrcAccessor src,
 
   73            MaskIterator m, MaskAccessor mask,
 
   74            DestIterator d, DestAccessor dest)
 
   76     for(; s != send; ++s, ++d, ++m)
 
   81 template <
class SrcIterator, 
class SrcAccessor,
 
   82           class DestIterator, 
class DestAccessor>
 
   84 swapLine(SrcIterator s, 
 
   85          SrcIterator send, SrcAccessor src,
 
   86          DestIterator d, DestAccessor dest)
 
   88     for(; s != send; ++s, ++d)
 
   90         typename SrcAccessor::value_type t = src(s);
 
  186 template <
class SrcImageIterator, 
class SrcAccessor,
 
  187           class DestImageIterator, 
class DestAccessor>
 
  189 copyImage(SrcImageIterator src_upperleft, 
 
  190           SrcImageIterator src_lowerright, SrcAccessor sa,
 
  191           DestImageIterator dest_upperleft, DestAccessor da)
 
  193     int w = src_lowerright.x - src_upperleft.x;
 
  195     for(; src_upperleft.y<src_lowerright.y; ++src_upperleft.y, ++dest_upperleft.y)
 
  197         copyLine(src_upperleft.rowIterator(), 
 
  198                  src_upperleft.rowIterator() + w, sa, 
 
  199                  dest_upperleft.rowIterator(), da);
 
  203 template <
class SrcImageIterator, 
class SrcAccessor,
 
  204           class DestImageIterator, 
class DestAccessor>
 
  207 copyImage(triple<SrcImageIterator, SrcImageIterator, SrcAccessor> src,
 
  208           pair<DestImageIterator, DestAccessor> dest)
 
  210     copyImage(src.first, src.second, src.third, 
 
  211               dest.first, dest.second);
 
  214 template <
class T1, 
class S1,
 
  217 copyImage(MultiArrayView<2, T1, S1> 
const & src,
 
  218           MultiArrayView<2, T2, S2> dest)
 
  220     vigra_precondition(src.shape() == dest.shape(),
 
  221         "copyImage(): shape mismatch between input and output.");
 
  222     copyImage(srcImageRange(src), destImage(dest));
 
  225 template <
class SrcImageIterator, 
class SrcAccessor,
 
  226           class DestImageIterator, 
class DestAccessor>
 
  228 swapImageData(SrcImageIterator src_upperleft, 
 
  229               SrcImageIterator src_lowerright, SrcAccessor sa,
 
  230               DestImageIterator dest_upperleft, DestAccessor da)
 
  232     int w = src_lowerright.x - src_upperleft.x;
 
  234     for(; src_upperleft.y<src_lowerright.y; ++src_upperleft.y, ++dest_upperleft.y)
 
  236         swapLine(src_upperleft.rowIterator(), 
 
  237                  src_upperleft.rowIterator() + w, sa, 
 
  238                  dest_upperleft.rowIterator(), da);
 
  242 template <
class SrcImageIterator, 
class SrcAccessor,
 
  243           class DestImageIterator, 
class DestAccessor>
 
  246 swapImageData(triple<SrcImageIterator, SrcImageIterator, SrcAccessor> src,
 
  247               pair<DestImageIterator, DestAccessor> dest)
 
  249     swapImageData(src.first, src.second, src.third, 
 
  250                   dest.first, dest.second);
 
  253 template <
class T1, 
class S1,
 
  257 swapImageData(MultiArrayView<2, T1, S1> 
const & src,
 
  258               MultiArrayView<2, T2, S2> dest)
 
  260     vigra_precondition(src.shape() == dest.shape(),
 
  261         "swapImageData(): shape mismatch between input and output.");
 
  262     swapImageData(srcImageRange(src), destImage(dest));
 
  367 template <
class SrcImageIterator, 
class SrcAccessor,
 
  368           class MaskImageIterator, 
class MaskAccessor,
 
  369           class DestImageIterator, 
class DestAccessor>
 
  372             SrcImageIterator src_lowerright, SrcAccessor sa,
 
  373             MaskImageIterator mask_upperleft, MaskAccessor ma,
 
  374         DestImageIterator dest_upperleft, DestAccessor da)
 
  376     int w = src_lowerright.x - src_upperleft.x;
 
  378     for(; src_upperleft.y<src_lowerright.y; 
 
  379              ++src_upperleft.y, ++mask_upperleft.y, ++dest_upperleft.y)
 
  381         copyLineIf(src_upperleft.rowIterator(), 
 
  382                    src_upperleft.rowIterator() + w, sa, 
 
  383                    mask_upperleft.rowIterator(), ma, 
 
  384                    dest_upperleft.rowIterator(), da);
 
  388 template <
class SrcImageIterator, 
class SrcAccessor,
 
  389           class MaskImageIterator, 
class MaskAccessor,
 
  390           class DestImageIterator, 
class DestAccessor>
 
  393 copyImageIf(triple<SrcImageIterator, SrcImageIterator, SrcAccessor> src,
 
  394             pair<MaskImageIterator, MaskAccessor> mask,
 
  395             pair<DestImageIterator, DestAccessor> dest)
 
  398                 mask.first, mask.second, 
 
  399                 dest.first, dest.second);
 
  402 template <
class T1, 
class S1,
 
  407             MultiArrayView<2, TM, SM> 
const & mask,
 
  408             MultiArrayView<2, T2, S2> dest)
 
  410     vigra_precondition(src.shape() == mask.shape() && src.shape() == dest.shape(),
 
  411         "copyImageIf(): shape mismatch between input and output.");
 
  421 #endif // VIGRA_COPYIMAGE_HXX 
void copyImageIf(...)
Copy source ROI into destination image. 
doxygen_overloaded_function(template<...> void separableConvolveBlockwise) template< unsigned int N
Separated convolution on ChunkedArrays. 
void copyImage(...)
Copy source image into destination image.