37 #ifndef VIGRA_MULTI_POINTOPERATORS_H 
   38 #define VIGRA_MULTI_POINTOPERATORS_H 
   40 #include "initimage.hxx" 
   41 #include "copyimage.hxx" 
   42 #include "transformimage.hxx" 
   43 #include "combineimages.hxx" 
   44 #include "inspectimage.hxx" 
   45 #include "multi_array.hxx" 
   46 #include "metaprogramming.hxx" 
   47 #include "inspector_passes.hxx" 
   72 template <
class Iterator, 
class Shape, 
class Accessor, 
 
   75 initMultiArrayImpl(Iterator s, Shape 
const & shape, Accessor a,  VALUETYPE 
const & v, MetaInt<0>)
 
   77     initLine(s, s + shape[0], a, v);
 
   80 template <
class Iterator, 
class Shape, 
class Accessor, 
 
   81           class VALUETYPE, 
int N>
 
   83 initMultiArrayImpl(Iterator s, Shape 
const & shape, Accessor a,  
 
   84                    VALUETYPE 
const & v, MetaInt<N>)
 
   86     Iterator send = s + shape[N];
 
   89         initMultiArrayImpl(s.begin(), shape, a, v, MetaInt<N-1>());
 
  201 template <
class Iterator, 
class Shape, 
class Accessor, 
class VALUETYPE>
 
  203 initMultiArray(Iterator s, Shape 
const & shape, Accessor a,  VALUETYPE 
const & v)
 
  205     initMultiArrayImpl(s, shape, a, v, MetaInt<Iterator::level>());
 
  208 template <
class Iterator, 
class Shape, 
class Accessor, 
class VALUETYPE>
 
  210 initMultiArray(triple<Iterator, Shape, Accessor> 
const & s, VALUETYPE 
const & v)
 
  212      initMultiArrayImpl(s.first, s.second, s.third, v, MetaInt<Iterator::level>());
 
  215 template <
unsigned int N, 
class T, 
class S, 
class VALUETYPE>
 
  302 template <
class Iterator, 
class Diff_type, 
class Accessor, 
 
  306                      Diff_type lower_border, Diff_type upper_border, 
 
  309     for(
unsigned int dim=0; dim<shape.size(); dim++)
 
  311         lower_border[dim] = (lower_border[dim] > shape[dim]) ? shape[dim] : lower_border[dim];
 
  312         upper_border[dim] = (upper_border[dim] > shape[dim]) ? shape[dim] : upper_border[dim];
 
  315     for(
unsigned int dim=0; dim<shape.size(); dim++)
 
  319         offset[dim] = lower_border[dim];
 
  323         start[dim]  = shape[dim] - upper_border[dim];
 
  324         offset[dim] = upper_border[dim];
 
  329 template <
class Iterator, 
class Diff_type, 
class Accessor, 
 
  336                          Diff_type(border_width), Diff_type(border_width), v);
 
  339 template <
class Iterator, 
class Diff_type, 
class Accessor, 
 
  348 template <
class Iterator, 
class Diff_type, 
class Accessor, 
 
  352                       Diff_type 
const & lower_border, Diff_type 
const & upper_border, 
 
  356                          lower_border, upper_border, v);
 
  359 template <
unsigned int N, 
class T, 
class S, 
 
  368 template <
unsigned int N, 
class T, 
class S, 
 
  372                       typename MultiArrayShape<N>::type 
const & lower_border, 
 
  373                       typename MultiArrayShape<N>::type 
const & upper_border, 
 
  385 template <
class SrcIterator, 
class SrcShape, 
class SrcAccessor,
 
  386           class DestIterator, 
class DestShape, 
class DestAccessor>
 
  388 copyMultiArrayImpl(SrcIterator s, SrcShape 
const & sshape, SrcAccessor src,
 
  389                DestIterator d, DestShape 
const & dshape, DestAccessor dest, MetaInt<0>)
 
  393         initLine(d, d + dshape[0], dest, src(s));
 
  397         copyLine(s, s + sshape[0], src, d, dest);
 
  401 template <
class SrcIterator, 
class SrcShape, 
class SrcAccessor,
 
  402           class DestIterator, 
class DestShape, 
class DestAccessor, 
int N>
 
  404 copyMultiArrayImpl(SrcIterator s, SrcShape 
const & sshape, SrcAccessor src,
 
  405                    DestIterator d, DestShape 
const & dshape, DestAccessor dest, MetaInt<N>)
 
  407     DestIterator dend = d + dshape[N];
 
  412             copyMultiArrayImpl(s.begin(), sshape, src, d.begin(), dshape, dest, MetaInt<N-1>());
 
  417         for(; d < dend; ++s, ++d)
 
  419             copyMultiArrayImpl(s.begin(), sshape, src, d.begin(), dshape, dest, MetaInt<N-1>());
 
  566 template <
class SrcIterator, 
class SrcShape, 
class SrcAccessor,
 
  567           class DestIterator, 
class DestAccessor>
 
  570                SrcShape 
const & shape, SrcAccessor src,
 
  571                DestIterator d, DestAccessor dest)
 
  573     copyMultiArrayImpl(s, shape, src, d, shape, dest, MetaInt<SrcIterator::level>());
 
  576 template <
class SrcIterator, 
class SrcShape, 
class SrcAccessor,
 
  577           class DestIterator, 
class DestShape, 
class DestAccessor>
 
  579 copyMultiArray(SrcIterator s, SrcShape 
const & sshape, SrcAccessor src,
 
  580                DestIterator d, DestShape 
const & dshape, DestAccessor dest)
 
  582     vigra_precondition(sshape.size() == dshape.size(),
 
  583         "copyMultiArray(): dimensionality of source and destination array differ");
 
  584     for(
unsigned int i=0; i<sshape.size(); ++i)
 
  585         vigra_precondition(sshape[i] == 1 || sshape[i] == dshape[i],
 
  586             "copyMultiArray(): mismatch between source and destination shapes:\n" 
  587             "length of each source dimension must either be 1 or equal to the corresponding " 
  588             "destination length.");
 
  589     copyMultiArrayImpl(s, sshape, src, d, dshape, dest, MetaInt<SrcIterator::level>());
 
  592 template <
class SrcIterator, 
class SrcShape, 
class SrcAccessor,
 
  593           class DestIterator, 
class DestAccessor>
 
  595 copyMultiArray(triple<SrcIterator, SrcShape, SrcAccessor> 
const & src,
 
  596                pair<DestIterator, DestAccessor> 
const & dest)
 
  599     copyMultiArray(src.first, src.second, src.third, dest.first, dest.second);
 
  602 template <
class SrcIterator, 
class SrcShape, 
class SrcAccessor,
 
  603           class DestIterator, 
class DestShape, 
class DestAccessor>
 
  605 copyMultiArray(triple<SrcIterator, SrcShape, SrcAccessor> 
const & src,
 
  606                triple<DestIterator, DestShape, DestAccessor> 
const & dest)
 
  609     copyMultiArray(src.first, src.second, src.third, dest.first, dest.second, dest.third);
 
  612 template <
unsigned int N, 
class T1, 
class S1,
 
  616                MultiArrayView<N, T2, S2> dest)
 
  618     for(
unsigned k=0; k<N; ++k)
 
  619         vigra_precondition(source.shape(k) == dest.shape(k) || source.shape(k) == 1 || 1 == dest.shape(k),
 
  620             "copyMultiArray(): shape mismatch between input and output.");
 
  621     if(source.shape() == dest.shape())
 
  624         copyMultiArray(srcMultiArrayRange(source), destMultiArrayRange(dest));
 
  633 template <
class SrcIterator, 
class SrcShape, 
class SrcAccessor,
 
  634           class DestIterator, 
class DestShape, 
class DestAccessor, 
 
  637 transformMultiArrayReduceImpl(SrcIterator s, SrcShape 
const &, SrcAccessor src,
 
  638                DestIterator d, DestShape 
const & dshape, DestAccessor dest, 
 
  639                SrcShape 
const & reduceShape,
 
  640                Functor 
const & ff, MetaInt<0>)
 
  642     DestIterator dend = d + dshape[0];
 
  643     for(; d < dend; ++s.template dim<0>(), ++d)
 
  651 template <
class SrcIterator, 
class SrcShape, 
class SrcAccessor,
 
  652           class DestIterator, 
class DestShape, 
class DestAccessor, 
 
  653           class Functor, 
int N>
 
  655 transformMultiArrayReduceImpl(SrcIterator s, SrcShape 
const & sshape, SrcAccessor src,
 
  656                    DestIterator d, DestShape 
const & dshape, DestAccessor dest, 
 
  657                    SrcShape 
const & reduceShape,
 
  658                    Functor 
const & f, MetaInt<N>)
 
  660     DestIterator dend = d + dshape[N];
 
  661     for(; d < dend; ++s.template dim<N>(), ++d)
 
  663         transformMultiArrayReduceImpl(s, sshape, src, d.begin(), dshape, dest,
 
  664                                       reduceShape, f, MetaInt<N-1>());
 
  668 template <
class SrcIterator, 
class SrcShape, 
class SrcAccessor,
 
  669           class DestIterator, 
class DestShape, 
class DestAccessor, 
 
  672 transformMultiArrayImpl(SrcIterator s, SrcShape 
const & sshape, SrcAccessor src,
 
  673                DestIterator d, DestShape 
const & dshape, DestAccessor dest, 
 
  674                Functor 
const & f, VigraTrueType)
 
  677     SrcShape reduceShape = sshape;
 
  678     for(
unsigned int i=0; i<dshape.size(); ++i)
 
  680         vigra_precondition(dshape[i] == 1 || sshape[i] == dshape[i],
 
  681             "transformMultiArray(): mismatch between source and destination shapes:\n" 
  682             "In 'reduce'-mode, the length of each destination dimension must either be 1\n" 
  683             "or equal to the corresponding source length.");
 
  687     transformMultiArrayReduceImpl(s, sshape, src, d, dshape, dest, reduceShape,
 
  688                                   f, MetaInt<SrcIterator::level>());
 
  691 template <
class SrcIterator, 
class SrcShape, 
class SrcAccessor,
 
  692           class DestIterator, 
class DestShape, 
class DestAccessor, 
 
  695 transformMultiArrayExpandImpl(SrcIterator s, SrcShape 
const & sshape, SrcAccessor src,
 
  696                DestIterator d, DestShape 
const & dshape, DestAccessor dest, 
 
  697                Functor 
const & f, MetaInt<0>)
 
  701         initLine(d, d + dshape[0], dest, f(src(s)));
 
  705         transformLine(s, s + sshape[0], src, d, dest, f);
 
  709 template <
class SrcIterator, 
class SrcShape, 
class SrcAccessor,
 
  710           class DestIterator, 
class DestShape, 
class DestAccessor, 
 
  711           class Functor, 
int N>
 
  713 transformMultiArrayExpandImpl(SrcIterator s, SrcShape 
const & sshape, SrcAccessor src,
 
  714                    DestIterator d, DestShape 
const & dshape, DestAccessor dest, 
 
  715                    Functor 
const & f, MetaInt<N>)
 
  717     DestIterator dend = d + dshape[N];
 
  722             transformMultiArrayExpandImpl(s.begin(), sshape, src, d.begin(), dshape, dest,
 
  728         for(; d < dend; ++s, ++d)
 
  730             transformMultiArrayExpandImpl(s.begin(), sshape, src, d.begin(), dshape, dest,
 
  736 template <
class SrcIterator, 
class SrcShape, 
class SrcAccessor,
 
  737           class DestIterator, 
class DestShape, 
class DestAccessor, 
 
  740 transformMultiArrayImpl(SrcIterator s, SrcShape 
const & sshape, SrcAccessor src,
 
  741                DestIterator d, DestShape 
const & dshape, DestAccessor dest, 
 
  742                Functor 
const & f, VigraFalseType)
 
  745     for(
unsigned int i=0; i<sshape.size(); ++i)
 
  746         vigra_precondition(sshape[i] == 1 || sshape[i] == dshape[i],
 
  747             "transformMultiArray(): mismatch between source and destination shapes:\n" 
  748             "In 'expand'-mode, the length of each source dimension must either be 1\n" 
  749             "or equal to the corresponding destination length.");
 
  750     transformMultiArrayExpandImpl(s, sshape, src, d, dshape, dest, 
 
  751                                   f, MetaInt<SrcIterator::level>());
 
  944 template <
class SrcIterator, 
class SrcShape, 
class SrcAccessor,
 
  945           class DestIterator, 
class DestAccessor, 
 
  949                     DestIterator d, DestAccessor dest, Functor 
const & f)
 
  951     transformMultiArrayExpandImpl(s, shape, src, d, shape, dest, 
 
  952                                   f, MetaInt<SrcIterator::level>());
 
  955 template <
class SrcIterator, 
class SrcShape, 
class SrcAccessor,
 
  956           class DestIterator, 
class DestShape, 
class DestAccessor, 
 
  960                DestIterator d, DestShape 
const & dshape, DestAccessor dest, 
 
  963     vigra_precondition(sshape.size() == dshape.size(),
 
  964         "transformMultiArray(): dimensionality of source and destination array differ");
 
  965     typedef FunctorTraits<Functor> FT;
 
  967         And<typename FT::isInitializer, typename FT::isUnaryAnalyser>::result
 
  968         isAnalyserInitializer;
 
  969     transformMultiArrayImpl(s, sshape, src, d, dshape, dest, 
 
  970                             f, isAnalyserInitializer());
 
  973 template <
class SrcIterator, 
class SrcShape, 
class SrcAccessor,
 
  974           class DestIterator, 
class DestAccessor, 
 
  978                     pair<DestIterator, DestAccessor> 
const & dest, Functor 
const & f)
 
  982                         dest.first, dest.second, f);
 
  985 template <
class SrcIterator, 
class SrcShape, 
class SrcAccessor,
 
  986           class DestIterator, 
class DestShape, 
class DestAccessor, 
 
  990                triple<DestIterator, DestShape, DestAccessor> 
const & dest, 
 
  994                         dest.first, dest.second, dest.third, f);
 
  997 template <
unsigned int N, 
class T1, 
class S1,
 
 1001 transformMultiArrayImpl(MultiArrayView<N, T1, S1> 
const & source,
 
 1002                         MultiArrayView<N, T2, S2> dest,
 
 1003                         Functor 
const & f, VigraFalseType)
 
 1005     if(source.shape() == dest.shape())
 
 1011 template <
unsigned int N, 
class T1, 
class S1,
 
 1015 transformMultiArrayImpl(MultiArrayView<N, T1, S1> 
const & source,
 
 1016                         MultiArrayView<N, T2, S2> dest,
 
 1017                         Functor 
const & f, VigraTrueType)
 
 1022 template <
unsigned int N, 
class T1, 
class S1,
 
 1027                     MultiArrayView<N, T2, S2> dest, Functor 
const & f)
 
 1029     for(
unsigned int k=0; k<N; ++k)
 
 1030         vigra_precondition(source.shape(k) == dest.shape(k) || source.shape(k) == 1 || 1 == dest.shape(k),
 
 1031             "transformMultiArray(): shape mismatch between input and output.");
 
 1033     typedef FunctorTraits<Functor> FT;
 
 1035         And<typename FT::isInitializer, typename FT::isUnaryAnalyser>::result
 
 1036         isAnalyserInitializer;
 
 1037     transformMultiArrayImpl(source, dest, f, isAnalyserInitializer());
 
 1046 template <
class SrcIterator1, 
class SrcShape, 
class SrcAccessor1,
 
 1047           class SrcIterator2, 
class SrcAccessor2,
 
 1048           class DestIterator, 
class DestShape, 
class DestAccessor, 
 
 1051 combineTwoMultiArraysReduceImpl(
 
 1052                SrcIterator1 s1, SrcShape 
const & , SrcAccessor1 src1,
 
 1053                SrcIterator2 s2, SrcAccessor2 src2,
 
 1054                DestIterator d,  DestShape 
const & dshape, DestAccessor dest, 
 
 1055                SrcShape 
const & reduceShape,
 
 1056                Functor 
const & ff, MetaInt<0>)
 
 1058     DestIterator dend = d + dshape[0];
 
 1059     for(; d < dend; ++s1.template dim<0>(), ++s2.template dim<0>(), ++d)
 
 1067 template <
class SrcIterator1, 
class SrcShape, 
class SrcAccessor1,
 
 1068           class SrcIterator2, 
class SrcAccessor2,
 
 1069           class DestIterator, 
class DestShape, 
class DestAccessor, 
 
 1070           class Functor, 
int N>
 
 1072 combineTwoMultiArraysReduceImpl(
 
 1073                SrcIterator1 s1, SrcShape 
const & sshape, SrcAccessor1 src1,
 
 1074                SrcIterator2 s2, SrcAccessor2 src2,
 
 1075                DestIterator d,  DestShape 
const & dshape, DestAccessor dest, 
 
 1076                SrcShape 
const & reduceShape,
 
 1077                Functor 
const & f, MetaInt<N>)
 
 1079     DestIterator dend = d + dshape[N];
 
 1080     for(; d < dend; ++s1.template dim<N>(), ++s2.template dim<N>(), ++d)
 
 1082         combineTwoMultiArraysReduceImpl(s1, sshape, src1, s2, src2, 
 
 1083                                         d.begin(), dshape, dest,
 
 1084                                         reduceShape, f, MetaInt<N-1>());
 
 1088 template <
class SrcIterator1, 
class SrcShape1, 
class SrcAccessor1,
 
 1089           class SrcIterator2, 
class SrcShape2, 
class SrcAccessor2,
 
 1090           class DestIterator, 
class DestShape, 
class DestAccessor, 
 
 1093 combineTwoMultiArraysImpl(
 
 1094                SrcIterator1 s1, SrcShape1 
const & sshape1, SrcAccessor1 src1,
 
 1095                SrcIterator2 s2, SrcShape2 
const & sshape2, SrcAccessor2 src2,
 
 1096                DestIterator d, DestShape 
const & dshape, DestAccessor dest, 
 
 1097                Functor 
const & f, VigraTrueType)
 
 1100     SrcShape1 reduceShape = sshape1;
 
 1101     for(
unsigned int i=0; i<dshape.size(); ++i)
 
 1103         vigra_precondition(sshape1[i] == sshape2[i] && 
 
 1104                            (dshape[i] == 1 || sshape1[i] == dshape[i]),
 
 1105             "combineTwoMultiArrays(): mismatch between source and destination shapes:\n" 
 1106             "In 'reduce'-mode, the two source shapes must be equal, and\n" 
 1107             "the length of each destination dimension must either be 1\n" 
 1108             "or equal to the corresponding source length.");
 
 1112     combineTwoMultiArraysReduceImpl(s1, sshape1, src1, s2, src2, 
 
 1113                                     d, dshape, dest, reduceShape,
 
 1114                                     f, MetaInt<SrcIterator1::level>());
 
 1117 template <
class SrcIterator1, 
class SrcShape1, 
class SrcAccessor1,
 
 1118           class SrcIterator2, 
class SrcShape2, 
class SrcAccessor2,
 
 1119           class DestIterator, 
class DestShape, 
class DestAccessor, 
 
 1122 combineTwoMultiArraysExpandImpl(
 
 1123                SrcIterator1 s1, SrcShape1 
const & sshape1, SrcAccessor1 src1,
 
 1124                SrcIterator2 s2, SrcShape2 
const & sshape2, SrcAccessor2 src2,
 
 1125                DestIterator d, DestShape 
const & dshape, DestAccessor dest, 
 
 1126                Functor 
const & f, MetaInt<0>)
 
 1128     DestIterator dend = d + dshape[0];
 
 1129     if(sshape1[0] == 1 && sshape2[0] == 1)
 
 1131         initLine(d, dend, dest, f(src1(s1), src2(s2)));
 
 1133     else if(sshape1[0] == 1)
 
 1135         typename SrcAccessor1::value_type sv1 = src1(s1);
 
 1136         for(; d < dend; ++d, ++s2)
 
 1137             dest.set(f(sv1, src2(s2)), d);
 
 1139     else if(sshape2[0] == 1)
 
 1141         typename SrcAccessor2::value_type sv2 = src2(s2);
 
 1142         for(; d < dend; ++d, ++s1)
 
 1143             dest.set(f(src1(s1), sv2), d);
 
 1147         combineTwoLines(s1, s1 + sshape1[0], src1, s2, src2, d, dest, f);
 
 1151 template <
class SrcIterator1, 
class SrcShape1, 
class SrcAccessor1,
 
 1152           class SrcIterator2, 
class SrcShape2, 
class SrcAccessor2,
 
 1153           class DestIterator, 
class DestShape, 
class DestAccessor, 
 
 1154           class Functor, 
int N>
 
 1156 combineTwoMultiArraysExpandImpl(
 
 1157                SrcIterator1 s1, SrcShape1 
const & sshape1, SrcAccessor1 src1,
 
 1158                SrcIterator2 s2, SrcShape2 
const & sshape2, SrcAccessor2 src2,
 
 1159                DestIterator d, DestShape 
const & dshape, DestAccessor dest, 
 
 1160                Functor 
const & f, MetaInt<N>)
 
 1162     DestIterator dend = d + dshape[N];
 
 1163     int s1inc = sshape1[N] == 1
 
 1166     int s2inc = sshape2[N] == 1
 
 1169     for(; d < dend; ++d, s1 += s1inc, s2 += s2inc)
 
 1171         combineTwoMultiArraysExpandImpl(s1.begin(), sshape1, src1, 
 
 1172                                         s2.begin(), sshape2, src2, 
 
 1173                                         d.begin(), dshape, dest,
 
 1178 template <
class SrcIterator1, 
class SrcShape1, 
class SrcAccessor1,
 
 1179           class SrcIterator2, 
class SrcShape2, 
class SrcAccessor2,
 
 1180           class DestIterator, 
class DestShape, 
class DestAccessor, 
 
 1183 combineTwoMultiArraysImpl(
 
 1184                SrcIterator1 s1, SrcShape1 
const & sshape1, SrcAccessor1 src1,
 
 1185                SrcIterator2 s2, SrcShape2 
const & sshape2, SrcAccessor2 src2,
 
 1186                DestIterator d, DestShape 
const & dshape, DestAccessor dest, 
 
 1187                Functor 
const & f, VigraFalseType)
 
 1190     for(
unsigned int i=0; i<sshape1.size(); ++i)
 
 1191         vigra_precondition((sshape1[i] == 1 || sshape1[i] == dshape[i]) &&
 
 1192                            (sshape2[i] == 1 || sshape2[i] == dshape[i]),
 
 1193             "combineTwoMultiArrays(): mismatch between source and destination shapes:\n" 
 1194             "In 'expand'-mode, the length of each source dimension must either be 1\n" 
 1195             "or equal to the corresponding destination length.");
 
 1196     combineTwoMultiArraysExpandImpl(s1, sshape1, src1, s2, sshape2, src2, 
 
 1198                                     f, MetaInt<SrcIterator1::level>());
 
 1417 template <
class SrcIterator1, 
class SrcShape, 
class SrcAccessor1,
 
 1418           class SrcIterator2, 
class SrcAccessor2,
 
 1419           class DestIterator, 
class DestAccessor, 
 
 1423                SrcIterator2 s2, SrcAccessor2 src2,
 
 1424                DestIterator d, DestAccessor dest, Functor 
const & f)
 
 1426     combineTwoMultiArraysExpandImpl(s1, shape, src1, s2, shape, src2, d, shape, dest, f, 
 
 1427                                     MetaInt<SrcIterator1::level>());
 
 1430 template <
class SrcIterator1, 
class SrcShape1, 
class SrcAccessor1,
 
 1431           class SrcIterator2, 
class SrcShape2, 
class SrcAccessor2,
 
 1432           class DestIterator, 
class DestShape, 
class DestAccessor, 
 
 1436                SrcIterator1 s1, SrcShape1 
const & sshape1, SrcAccessor1 src1,
 
 1437                SrcIterator2 s2, SrcShape2 
const & sshape2, SrcAccessor2 src2,
 
 1438                DestIterator d, DestShape 
const & dshape, DestAccessor dest, 
 
 1441     vigra_precondition(sshape1.size() == dshape.size() && sshape2.size() == dshape.size(),
 
 1442         "combineTwoMultiArrays(): dimensionality of source and destination arrays differ");
 
 1444     typedef FunctorTraits<Functor> FT;
 
 1446         And<typename FT::isInitializer, typename FT::isBinaryAnalyser>::result
 
 1447         isAnalyserInitializer;
 
 1448     combineTwoMultiArraysImpl(s1, sshape1, src1, s2, sshape2, src2, d, dshape, dest, 
 
 1449                               f, isAnalyserInitializer());
 
 1452 template <
class SrcIterator1, 
class SrcShape, 
class SrcAccessor1,
 
 1453           class SrcIterator2, 
class SrcAccessor2,
 
 1454           class DestIterator, 
class DestAccessor, 
class Functor>
 
 1457                       pair<SrcIterator2, SrcAccessor2> 
const & src2,
 
 1458                       pair<DestIterator, DestAccessor> 
const & dest, 
 
 1463            src1.first, src1.second, src1.third, 
 
 1464            src2.first, src2.second, dest.first, dest.second, f);
 
 1467 template <
class SrcIterator1, 
class SrcShape1, 
class SrcAccessor1,
 
 1468           class SrcIterator2, 
class SrcShape2, 
class SrcAccessor2,
 
 1469           class DestIterator, 
class DestShape, 
class DestAccessor, 
 
 1473                       triple<SrcIterator2, SrcShape2, SrcAccessor2> 
const & src2,
 
 1474                       triple<DestIterator, DestShape, DestAccessor> 
const & dest, 
 
 1478                           src2.first, src2.second, src2.third, 
 
 1479                           dest.first, dest.second, dest.third, f);
 
 1482 template <
unsigned int N, 
class T11, 
class S11,
 
 1483                           class T12, 
class S12,
 
 1487 combineTwoMultiArraysImpl(MultiArrayView<N, T11, S11> 
const & source1,
 
 1488                           MultiArrayView<N, T12, S12> 
const & source2,
 
 1489                           MultiArrayView<N, T2, S2> dest, 
 
 1490                           Functor 
const & f, VigraFalseType)
 
 1493     if(source1.shape() == source2.shape() && source1.shape() == dest.shape())
 
 1495                               srcMultiArray(source2), destMultiArray(dest), f);
 
 1498                               srcMultiArrayRange(source2), 
 
 1499                               destMultiArrayRange(dest), f);
 
 1502 template <
unsigned int N, 
class T11, 
class S11,
 
 1503                           class T12, 
class S12,
 
 1507 combineTwoMultiArraysImpl(MultiArrayView<N, T11, S11> 
const & source1,
 
 1508                           MultiArrayView<N, T12, S12> 
const & source2,
 
 1509                           MultiArrayView<N, T2, S2> dest, 
 
 1510                           Functor 
const & f, VigraTrueType)
 
 1514                           srcMultiArrayRange(source2), 
 
 1515                           destMultiArrayRange(dest), f);
 
 1518 template <
unsigned int N, 
class T11, 
class S11,
 
 1519                           class T12, 
class S12,
 
 1524                       MultiArrayView<N, T12, S12> 
const & source2,
 
 1525                       MultiArrayView<N, T2, S2> dest, 
 
 1528     for(
unsigned int k=0; k<N; ++k)
 
 1529         vigra_precondition((source1.shape(k) == source2.shape(k) || source1.shape(k) == 1 || 1 == source2.shape(k)) &&
 
 1530                            (source1.shape(k) == dest.shape(k) || source1.shape(k) == 1 || 1 == dest.shape(k)),
 
 1531             "combineTwoMultiArrays(): shape mismatch between inputs and/or output.");
 
 1533     typedef FunctorTraits<Functor> FT;
 
 1535         And<typename FT::isInitializer, typename FT::isBinaryAnalyser>::result
 
 1536         isAnalyserInitializer;
 
 1537     combineTwoMultiArraysImpl(source1, source2, dest, f, isAnalyserInitializer());
 
 1546 template <
class SrcIterator1, 
class SrcShape, 
class SrcAccessor1,
 
 1547           class SrcIterator2, 
class SrcAccessor2,
 
 1548           class SrcIterator3, 
class SrcAccessor3,
 
 1549           class DestIterator, 
class DestAccessor, 
 
 1552 combineThreeMultiArraysImpl(SrcIterator1 s1, SrcShape 
const & shape, SrcAccessor1 src1,
 
 1553                SrcIterator2 s2, SrcAccessor2 src2,
 
 1554                SrcIterator3 s3, SrcAccessor3 src3,
 
 1555                DestIterator d, DestAccessor dest, Functor 
const & f, MetaInt<0>)
 
 1557     combineThreeLines(s1, s1 + shape[0], src1, s2, src2, s3, src3, d, dest, f);
 
 1560 template <
class SrcIterator1, 
class SrcShape, 
class SrcAccessor1,
 
 1561           class SrcIterator2, 
class SrcAccessor2,
 
 1562           class SrcIterator3, 
class SrcAccessor3,
 
 1563           class DestIterator, 
class DestAccessor, 
 
 1564           class Functor, 
int N>
 
 1566 combineThreeMultiArraysImpl(SrcIterator1 s1, SrcShape 
const & shape, SrcAccessor1 src1,
 
 1567                SrcIterator2 s2, SrcAccessor2 src2,
 
 1568                SrcIterator3 s3, SrcAccessor3 src3,
 
 1569                DestIterator d, DestAccessor dest, 
 
 1570                    Functor 
const & f, MetaInt<N>)
 
 1572     SrcIterator1 s1end = s1 + shape[N];
 
 1573     for(; s1 < s1end; ++s1, ++s2, ++s3, ++d)
 
 1575         combineThreeMultiArraysImpl(s1.begin(), shape, src1, 
 
 1576                                   s2.begin(), src2, s3.begin(), src3, d.begin(), dest, 
 
 1688 template <
class SrcIterator1, 
class SrcShape, 
class SrcAccessor1,
 
 1689           class SrcIterator2, 
class SrcAccessor2,
 
 1690           class SrcIterator3, 
class SrcAccessor3,
 
 1691           class DestIterator, 
class DestAccessor, 
 
 1695                SrcIterator2 s2, SrcAccessor2 src2,
 
 1696                SrcIterator3 s3, SrcAccessor3 src3,
 
 1697                DestIterator d, DestAccessor dest, Functor 
const & f)
 
 1699     combineThreeMultiArraysImpl(s1, shape, src1, s2, src2, s3, src3, d, dest, f, 
 
 1700                               MetaInt<SrcIterator1::level>());
 
 1703 template <
class SrcIterator1, 
class SrcShape, 
class SrcAccessor1,
 
 1704           class SrcIterator2, 
class SrcAccessor2,
 
 1705           class SrcIterator3, 
class SrcAccessor3,
 
 1706           class DestIterator, 
class DestAccessor, 
 
 1710                         pair<SrcIterator2, SrcAccessor2> 
const & src2,
 
 1711                         pair<SrcIterator3, SrcAccessor3> 
const & src3,
 
 1712                         pair<DestIterator, DestAccessor> 
const & dest, Functor 
const & f)
 
 1716            src1.first, src1.second, src1.third, 
 
 1717            src2.first, src2.second, src3.first, src3.second, dest.first, dest.second, f);
 
 1720 template <
unsigned int N, 
class T11, 
class S11,
 
 1721                           class T12, 
class S12, 
 
 1722                           class T13, 
class S13,
 
 1727                         MultiArrayView<N, T12, S12> 
const & source2,
 
 1728                         MultiArrayView<N, T13, S13> 
const & source3,
 
 1729                         MultiArrayView<N, T2, S2> dest, Functor 
const & f)
 
 1731     vigra_precondition(source1.shape() == source2.shape() && source1.shape() == source3.shape() && source1.shape() == dest.shape(),
 
 1732         "combineThreeMultiArrays(): shape mismatch between inputs and/or output.");
 
 1735            srcMultiArrayRange(source1), 
 
 1736            srcMultiArray(source2), srcMultiArray(source3), destMultiArray(dest), f);
 
 1745 template <
class Iterator, 
class Shape, 
class Accessor, 
class Functor>
 
 1747 inspectMultiArrayImpl(Iterator s, Shape 
const & shape, Accessor a,  Functor & f, MetaInt<0>)
 
 1749     inspectLine(s, s + shape[0], a, f);
 
 1752 template <
class Iterator, 
class Shape, 
class Accessor, 
class Functor, 
int N>
 
 1754 inspectMultiArrayImpl(Iterator s, Shape 
const & shape, Accessor a,  Functor & f, MetaInt<N>)
 
 1756     Iterator send = s + shape[N];
 
 1757     for(; s < send; ++s)
 
 1759         inspectMultiArrayImpl(s.begin(), shape, a, f, MetaInt<N-1>());
 
 1849 template <
class Iterator, 
class Shape, 
class Accessor>
 
 1850 struct inspectMultiArray_binder
 
 1853     const Shape & shape;
 
 1855     inspectMultiArray_binder(Iterator s_, 
const Shape & shape_, Accessor a_)
 
 1856         : s(s_), shape(shape_), a(a_) {}
 
 1857     template <
class Functor>
 
 1858     void operator()(Functor & f)
 
 1860         inspectMultiArrayImpl(s, shape, a, f, MetaInt<Iterator::level>());
 
 1864 template <
class Iterator, 
class Shape, 
class Accessor, 
class Functor>
 
 1868     inspectMultiArray_binder<Iterator, Shape, Accessor> g(s, shape, a);
 
 1869     detail::extra_passes_select(g, f);
 
 1872 template <
class Iterator, 
class Shape, 
class Accessor, 
class Functor>
 
 1879 template <
unsigned int N, 
class T, 
class S, 
class Functor>
 
 1892 template <
class Iterator1, 
class Shape, 
class Accessor1, 
 
 1893           class Iterator2, 
class Accessor2, 
 
 1896 inspectTwoMultiArraysImpl(Iterator1 s1, Shape 
const & shape, Accessor1 a1,
 
 1897                           Iterator2 s2, Accessor2 a2,
 
 1898                           Functor & f, MetaInt<0>)
 
 1900     inspectTwoLines(s1, s1 + shape[0], a1, s2, a2, f);
 
 1903 template <
class Iterator1, 
class Shape, 
class Accessor1, 
 
 1904           class Iterator2, 
class Accessor2, 
 
 1905           class Functor, 
int N>
 
 1907 inspectTwoMultiArraysImpl(Iterator1 s1, Shape 
const & shape, Accessor1 a1,
 
 1908                           Iterator2 s2, Accessor2 a2,
 
 1909                           Functor & f, MetaInt<N>)
 
 1911     Iterator1 s1end = s1 + shape[N];
 
 1912     for(; s1 < s1end; ++s1, ++s2)
 
 1914         inspectTwoMultiArraysImpl(s1.begin(), shape, a1, 
 
 1915                                   s2.begin(), a2, f, MetaInt<N-1>());
 
 2010 template <
class Iterator1, 
class Shape, 
class Accessor1,
 
 2011           class Iterator2, 
class Accessor2>
 
 2012 struct inspectTwoMultiArrays_binder
 
 2015     const Shape & shape;
 
 2019     inspectTwoMultiArrays_binder(Iterator1 s1_, 
const Shape & shape_,
 
 2020                                  Accessor1 a1_, Iterator2 s2_, Accessor2 a2_)
 
 2021         : s1(s1_), shape(shape_), a1(a1_), s2(s2_), a2(a2_) {}
 
 2022     template <
class Functor>
 
 2023     void operator()(Functor & f)
 
 2025         inspectTwoMultiArraysImpl(s1, shape, a1, s2, a2, f,
 
 2026                                   MetaInt<Iterator1::level>());
 
 2030 template <
class Iterator1, 
class Shape, 
class Accessor1,
 
 2031           class Iterator2, 
class Accessor2,
 
 2035                       Iterator2 s2, Accessor2 a2, Functor & f)
 
 2037     inspectTwoMultiArrays_binder<Iterator1, Shape, Accessor1,
 
 2038                                  Iterator2, Accessor2>
 
 2039         g(s1, shape, a1, s2, a2);
 
 2040     detail::extra_passes_select(g, f);
 
 2043 template <
class Iterator1, 
class Shape, 
class Accessor1, 
 
 2044           class Iterator2, 
class Accessor2, 
 
 2048                       pair<Iterator2, Accessor2> 
const & s2, Functor & f)
 
 2051                           s2.first, s2.second, f);
 
 2054 template <
unsigned int N, 
class T1, 
class S1, 
 
 2059                       MultiArrayView<N, T2, S2> 
const & s2, Functor & f)
 
 2061     vigra_precondition(s1.shape() == s2.shape(),
 
 2062         "inspectTwoMultiArrays(): shape mismatch between inputs.");
 
 2065                           srcMultiArray(s2), f);
 
 2073 #endif  //-- VIGRA_MULTI_POINTOPERATORS_H 
void inspectTwoMultiArrays(...)
Call an analyzing functor at all corresponding elements of two multi-dimensional arrays. 
void initMultiArrayBorder(...)
Write values to the specified border values in the array. 
void combineThreeMultiArrays(...)
Combine three multi-dimensional arrays into one using a ternary function or functor. 
std::ptrdiff_t MultiArrayIndex
Definition: multi_fwd.hxx:60
void initMultiArray(...)
Write a value to every element in a multi-dimensional array. 
vigra::GridGraph< N, DirectedTag >::vertex_descriptor source(typename vigra::GridGraph< N, DirectedTag >::edge_descriptor const &e, vigra::GridGraph< N, DirectedTag > const &g)
Get a vertex descriptor for the start vertex of edge e in graph g (API: boost). 
Definition: multi_gridgraph.hxx:2943
doxygen_overloaded_function(template<...> void separableConvolveBlockwise) template< unsigned int N
Separated convolution on ChunkedArrays. 
void copyMultiArray(...)
Copy a multi-dimensional array. 
void combineTwoMultiArrays(...)
Combine two multi-dimensional arrays into one using a binary function or functor. ...
void transformMultiArray(...)
Transform a multi-dimensional array with a unary function or functor. 
void inspectMultiArray(...)
Call an analyzing functor at every element of a multi-dimensional array.