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"
70 template <
class Iterator,
class Shape,
class Accessor,
73 initMultiArrayImpl(Iterator s, Shape
const & shape, Accessor a, VALUETYPE
const & v, MetaInt<0>)
75 initLine(s, s + shape[0], a, v);
78 template <
class Iterator,
class Shape,
class Accessor,
79 class VALUETYPE,
int N>
81 initMultiArrayImpl(Iterator s, Shape
const & shape, Accessor a,
82 VALUETYPE
const & v, MetaInt<N>)
84 Iterator send = s + shape[N];
87 initMultiArrayImpl(s.begin(), shape, a, v, MetaInt<N-1>());
183 template <
class Iterator,
class Shape,
class Accessor,
class VALUETYPE>
185 initMultiArray(Iterator s, Shape
const & shape, Accessor a, VALUETYPE
const & v)
187 initMultiArrayImpl(s, shape, a, v, MetaInt<Iterator::level>());
190 template <
class Iterator,
class Shape,
class Accessor,
class VALUETYPE>
193 initMultiArray(triple<Iterator, Shape, Accessor>
const & s, VALUETYPE
const & v)
206 template <
class Iterator,
class Diff_type,
class Accessor,
class VALUETYPE>
208 Accessor a,
int border_width, VALUETYPE v)
210 Diff_type border(shape);
211 for(
unsigned int dim=0; dim<shape.size(); dim++){
212 border[dim] = (border_width > shape[dim]) ? shape[dim] : border_width;
215 for(
unsigned int dim=0; dim<shape.size(); dim++){
216 Diff_type start(shape),
219 offset[dim]=border[dim];
223 start[dim]=shape[dim]-border[dim];
228 template <
class Iterator,
class Diff_type,
class Accessor,
class VALUETYPE>
230 int border_width, VALUETYPE v)
242 template <
class SrcIterator,
class SrcShape,
class SrcAccessor,
243 class DestIterator,
class DestShape,
class DestAccessor>
245 copyMultiArrayImpl(SrcIterator s, SrcShape
const & sshape, SrcAccessor src,
246 DestIterator d, DestShape
const & dshape, DestAccessor dest, MetaInt<0>)
250 initLine(d, d + dshape[0], dest, src(s));
254 copyLine(s, s + sshape[0], src, d, dest);
258 template <
class SrcIterator,
class SrcShape,
class SrcAccessor,
259 class DestIterator,
class DestShape,
class DestAccessor,
int N>
261 copyMultiArrayImpl(SrcIterator s, SrcShape
const & sshape, SrcAccessor src,
262 DestIterator d, DestShape
const & dshape, DestAccessor dest, MetaInt<N>)
264 DestIterator dend = d + dshape[N];
269 copyMultiArrayImpl(s.begin(), sshape, src, d.begin(), dshape, dest, MetaInt<N-1>());
274 for(; d < dend; ++s, ++d)
276 copyMultiArrayImpl(s.begin(), sshape, src, d.begin(), dshape, dest, MetaInt<N-1>());
392 template <
class SrcIterator,
class SrcShape,
class SrcAccessor,
393 class DestIterator,
class DestAccessor>
396 SrcShape
const & shape, SrcAccessor src,
397 DestIterator d, DestAccessor dest)
399 copyMultiArrayImpl(s, shape, src, d, shape, dest, MetaInt<SrcIterator::level>());
402 template <
class SrcIterator,
class SrcShape,
class SrcAccessor,
403 class DestIterator,
class DestAccessor>
405 copyMultiArray(triple<SrcIterator, SrcShape, SrcAccessor>
const & src,
406 pair<DestIterator, DestAccessor>
const & dest)
409 copyMultiArray(src.first, src.second, src.third, dest.first, dest.second);
412 template <
class SrcIterator,
class SrcShape,
class SrcAccessor,
413 class DestIterator,
class DestShape,
class DestAccessor>
415 copyMultiArray(SrcIterator s, SrcShape
const & sshape, SrcAccessor src,
416 DestIterator d, DestShape
const & dshape, DestAccessor dest)
418 vigra_precondition(sshape.size() == dshape.size(),
419 "copyMultiArray(): dimensionality of source and destination array differ");
420 for(
unsigned int i=0; i<sshape.size(); ++i)
421 vigra_precondition(sshape[i] == 1 || sshape[i] == dshape[i],
422 "copyMultiArray(): mismatch between source and destination shapes:\n"
423 "length of each source dimension must either be 1 or equal to the corresponding "
424 "destination length.");
425 copyMultiArrayImpl(s, sshape, src, d, dshape, dest, MetaInt<SrcIterator::level>());
428 template <
class SrcIterator,
class SrcShape,
class SrcAccessor,
429 class DestIterator,
class DestShape,
class DestAccessor>
431 copyMultiArray(triple<SrcIterator, SrcShape, SrcAccessor>
const & src,
432 triple<DestIterator, DestShape, DestAccessor>
const & dest)
435 copyMultiArray(src.first, src.second, src.third, dest.first, dest.second, dest.third);
444 template <
class SrcIterator,
class SrcShape,
class SrcAccessor,
445 class DestIterator,
class DestShape,
class DestAccessor,
448 transformMultiArrayReduceImpl(SrcIterator s, SrcShape
const &, SrcAccessor src,
449 DestIterator d, DestShape
const & dshape, DestAccessor dest,
450 SrcShape
const & reduceShape,
451 Functor
const & ff, MetaInt<0>)
453 DestIterator dend = d + dshape[0];
454 for(; d < dend; ++s.template dim<0>(), ++d)
462 template <
class SrcIterator,
class SrcShape,
class SrcAccessor,
463 class DestIterator,
class DestShape,
class DestAccessor,
464 class Functor,
int N>
466 transformMultiArrayReduceImpl(SrcIterator s, SrcShape
const & sshape, SrcAccessor src,
467 DestIterator d, DestShape
const & dshape, DestAccessor dest,
468 SrcShape
const & reduceShape,
469 Functor
const & f, MetaInt<N>)
471 DestIterator dend = d + dshape[N];
472 for(; d < dend; ++s.template dim<N>(), ++d)
474 transformMultiArrayReduceImpl(s, sshape, src, d.begin(), dshape, dest,
475 reduceShape, f, MetaInt<N-1>());
479 template <
class SrcIterator,
class SrcShape,
class SrcAccessor,
480 class DestIterator,
class DestShape,
class DestAccessor,
483 transformMultiArrayImpl(SrcIterator s, SrcShape
const & sshape, SrcAccessor src,
484 DestIterator d, DestShape
const & dshape, DestAccessor dest,
485 Functor
const & f, VigraTrueType)
488 SrcShape reduceShape = sshape;
489 for(
unsigned int i=0; i<dshape.size(); ++i)
491 vigra_precondition(dshape[i] == 1 || sshape[i] == dshape[i],
492 "transformMultiArray(): mismatch between source and destination shapes:\n"
493 "In 'reduce'-mode, the length of each destination dimension must either be 1\n"
494 "or equal to the corresponding source length.");
498 transformMultiArrayReduceImpl(s, sshape, src, d, dshape, dest, reduceShape,
499 f, MetaInt<SrcIterator::level>());
502 template <
class SrcIterator,
class SrcShape,
class SrcAccessor,
503 class DestIterator,
class DestShape,
class DestAccessor,
506 transformMultiArrayExpandImpl(SrcIterator s, SrcShape
const & sshape, SrcAccessor src,
507 DestIterator d, DestShape
const & dshape, DestAccessor dest,
508 Functor
const & f, MetaInt<0>)
512 initLine(d, d + dshape[0], dest, f(src(s)));
516 transformLine(s, s + sshape[0], src, d, dest, f);
520 template <
class SrcIterator,
class SrcShape,
class SrcAccessor,
521 class DestIterator,
class DestShape,
class DestAccessor,
522 class Functor,
int N>
524 transformMultiArrayExpandImpl(SrcIterator s, SrcShape
const & sshape, SrcAccessor src,
525 DestIterator d, DestShape
const & dshape, DestAccessor dest,
526 Functor
const & f, MetaInt<N>)
528 DestIterator dend = d + dshape[N];
533 transformMultiArrayExpandImpl(s.begin(), sshape, src, d.begin(), dshape, dest,
539 for(; d < dend; ++s, ++d)
541 transformMultiArrayExpandImpl(s.begin(), sshape, src, d.begin(), dshape, dest,
547 template <
class SrcIterator,
class SrcShape,
class SrcAccessor,
548 class DestIterator,
class DestShape,
class DestAccessor,
551 transformMultiArrayImpl(SrcIterator s, SrcShape
const & sshape, SrcAccessor src,
552 DestIterator d, DestShape
const & dshape, DestAccessor dest,
553 Functor
const & f, VigraFalseType)
556 for(
unsigned int i=0; i<sshape.size(); ++i)
557 vigra_precondition(sshape[i] == 1 || sshape[i] == dshape[i],
558 "transformMultiArray(): mismatch between source and destination shapes:\n"
559 "In 'expand'-mode, the length of each source dimension must either be 1\n"
560 "or equal to the corresponding destination length.");
561 transformMultiArrayExpandImpl(s, sshape, src, d, dshape, dest,
562 f, MetaInt<SrcIterator::level>());
768 template <
class SrcIterator,
class SrcShape,
class SrcAccessor,
769 class DestIterator,
class DestAccessor,
773 DestIterator d, DestAccessor dest, Functor
const & f)
775 transformMultiArrayExpandImpl(s, shape, src, d, shape, dest,
776 f, MetaInt<SrcIterator::level>());
779 template <
class SrcIterator,
class SrcShape,
class SrcAccessor,
780 class DestIterator,
class DestAccessor,
784 pair<DestIterator, DestAccessor>
const & dest, Functor
const & f)
788 dest.first, dest.second, f);
791 template <
class SrcIterator,
class SrcShape,
class SrcAccessor,
792 class DestIterator,
class DestShape,
class DestAccessor,
796 DestIterator d, DestShape
const & dshape, DestAccessor dest,
799 vigra_precondition(sshape.size() == dshape.size(),
800 "transformMultiArray(): dimensionality of source and destination array differ");
801 typedef FunctorTraits<Functor> FT;
803 And<typename FT::isInitializer, typename FT::isUnaryAnalyser>::result
804 isAnalyserInitializer;
805 transformMultiArrayImpl(s, sshape, src, d, dshape, dest,
806 f, isAnalyserInitializer());
809 template <
class SrcIterator,
class SrcShape,
class SrcAccessor,
810 class DestIterator,
class DestShape,
class DestAccessor,
814 triple<DestIterator, DestShape, DestAccessor>
const & dest,
818 dest.first, dest.second, dest.third, f);
827 template <
class SrcIterator1,
class SrcShape,
class SrcAccessor1,
828 class SrcIterator2,
class SrcAccessor2,
829 class DestIterator,
class DestShape,
class DestAccessor,
832 combineTwoMultiArraysReduceImpl(
833 SrcIterator1 s1, SrcShape
const & , SrcAccessor1 src1,
834 SrcIterator2 s2, SrcAccessor2 src2,
835 DestIterator d, DestShape
const & dshape, DestAccessor dest,
836 SrcShape
const & reduceShape,
837 Functor
const & ff, MetaInt<0>)
839 DestIterator dend = d + dshape[0];
840 for(; d < dend; ++s1.template dim<0>(), ++s2.template dim<0>(), ++d)
848 template <
class SrcIterator1,
class SrcShape,
class SrcAccessor1,
849 class SrcIterator2,
class SrcAccessor2,
850 class DestIterator,
class DestShape,
class DestAccessor,
851 class Functor,
int N>
853 combineTwoMultiArraysReduceImpl(
854 SrcIterator1 s1, SrcShape
const & sshape, SrcAccessor1 src1,
855 SrcIterator2 s2, SrcAccessor2 src2,
856 DestIterator d, DestShape
const & dshape, DestAccessor dest,
857 SrcShape
const & reduceShape,
858 Functor
const & f, MetaInt<N>)
860 DestIterator dend = d + dshape[N];
861 for(; d < dend; ++s1.template dim<N>(), ++s2.template dim<N>(), ++d)
863 combineTwoMultiArraysReduceImpl(s1, sshape, src1, s2, src2,
864 d.begin(), dshape, dest,
865 reduceShape, f, MetaInt<N-1>());
869 template <
class SrcIterator1,
class SrcShape1,
class SrcAccessor1,
870 class SrcIterator2,
class SrcShape2,
class SrcAccessor2,
871 class DestIterator,
class DestShape,
class DestAccessor,
874 combineTwoMultiArraysImpl(
875 SrcIterator1 s1, SrcShape1
const & sshape1, SrcAccessor1 src1,
876 SrcIterator2 s2, SrcShape2
const & sshape2, SrcAccessor2 src2,
877 DestIterator d, DestShape
const & dshape, DestAccessor dest,
878 Functor
const & f, VigraTrueType)
881 SrcShape1 reduceShape = sshape1;
882 for(
unsigned int i=0; i<dshape.size(); ++i)
884 vigra_precondition(sshape1[i] == sshape2[i] &&
885 (dshape[i] == 1 || sshape1[i] == dshape[i]),
886 "combineTwoMultiArrays(): mismatch between source and destination shapes:\n"
887 "In 'reduce'-mode, the two source shapes must be equal, and\n"
888 "the length of each destination dimension must either be 1\n"
889 "or equal to the corresponding source length.");
893 combineTwoMultiArraysReduceImpl(s1, sshape1, src1, s2, src2,
894 d, dshape, dest, reduceShape,
895 f, MetaInt<SrcIterator1::level>());
898 template <
class SrcIterator1,
class SrcShape1,
class SrcAccessor1,
899 class SrcIterator2,
class SrcShape2,
class SrcAccessor2,
900 class DestIterator,
class DestShape,
class DestAccessor,
903 combineTwoMultiArraysExpandImpl(
904 SrcIterator1 s1, SrcShape1
const & sshape1, SrcAccessor1 src1,
905 SrcIterator2 s2, SrcShape2
const & sshape2, SrcAccessor2 src2,
906 DestIterator d, DestShape
const & dshape, DestAccessor dest,
907 Functor
const & f, MetaInt<0>)
909 DestIterator dend = d + dshape[0];
910 if(sshape1[0] == 1 && sshape2[0] == 1)
912 initLine(d, dend, dest, f(src1(s1), src2(s2)));
914 else if(sshape1[0] == 1)
916 typename SrcAccessor1::value_type sv1 = src1(s1);
917 for(; d < dend; ++d, ++s2)
918 dest.set(f(sv1, src2(s2)), d);
920 else if(sshape2[0] == 1)
922 typename SrcAccessor2::value_type sv2 = src2(s2);
923 for(; d < dend; ++d, ++s1)
924 dest.set(f(src1(s1), sv2), d);
928 combineTwoLines(s1, s1 + sshape1[0], src1, s2, src2, d, dest, f);
932 template <
class SrcIterator1,
class SrcShape1,
class SrcAccessor1,
933 class SrcIterator2,
class SrcShape2,
class SrcAccessor2,
934 class DestIterator,
class DestShape,
class DestAccessor,
935 class Functor,
int N>
937 combineTwoMultiArraysExpandImpl(
938 SrcIterator1 s1, SrcShape1
const & sshape1, SrcAccessor1 src1,
939 SrcIterator2 s2, SrcShape2
const & sshape2, SrcAccessor2 src2,
940 DestIterator d, DestShape
const & dshape, DestAccessor dest,
941 Functor
const & f, MetaInt<N>)
943 DestIterator dend = d + dshape[N];
944 int s1inc = sshape1[N] == 1
947 int s2inc = sshape2[N] == 1
950 for(; d < dend; ++d, s1 += s1inc, s2 += s2inc)
952 combineTwoMultiArraysExpandImpl(s1.begin(), sshape1, src1,
953 s2.begin(), sshape2, src2,
954 d.begin(), dshape, dest,
959 template <
class SrcIterator1,
class SrcShape1,
class SrcAccessor1,
960 class SrcIterator2,
class SrcShape2,
class SrcAccessor2,
961 class DestIterator,
class DestShape,
class DestAccessor,
964 combineTwoMultiArraysImpl(
965 SrcIterator1 s1, SrcShape1
const & sshape1, SrcAccessor1 src1,
966 SrcIterator2 s2, SrcShape2
const & sshape2, SrcAccessor2 src2,
967 DestIterator d, DestShape
const & dshape, DestAccessor dest,
968 Functor
const & f, VigraFalseType)
971 for(
unsigned int i=0; i<sshape1.size(); ++i)
972 vigra_precondition((sshape1[i] == 1 || sshape1[i] == dshape[i]) &&
973 (sshape2[i] == 1 || sshape2[i] == dshape[i]),
974 "combineTwoMultiArrays(): mismatch between source and destination shapes:\n"
975 "In 'expand'-mode, the length of each source dimension must either be 1\n"
976 "or equal to the corresponding destination length.");
977 combineTwoMultiArraysExpandImpl(s1, sshape1, src1, s2, sshape2, src2,
979 f, MetaInt<SrcIterator1::level>());
1219 template <
class SrcIterator1,
class SrcShape,
class SrcAccessor1,
1220 class SrcIterator2,
class SrcAccessor2,
1221 class DestIterator,
class DestAccessor,
1225 SrcIterator2 s2, SrcAccessor2 src2,
1226 DestIterator d, DestAccessor dest, Functor
const & f)
1228 combineTwoMultiArraysExpandImpl(s1, shape, src1, s2, shape, src2, d, shape, dest, f,
1229 MetaInt<SrcIterator1::level>());
1232 template <
class SrcIterator1,
class SrcShape,
class SrcAccessor1,
1233 class SrcIterator2,
class SrcAccessor2,
1234 class DestIterator,
class DestAccessor,
class Functor>
1237 pair<SrcIterator2, SrcAccessor2>
const & src2,
1238 pair<DestIterator, DestAccessor>
const & dest, Functor
const & f)
1242 src1.first, src1.second, src1.third,
1243 src2.first, src2.second, dest.first, dest.second, f);
1246 template <
class SrcIterator1,
class SrcShape1,
class SrcAccessor1,
1247 class SrcIterator2,
class SrcShape2,
class SrcAccessor2,
1248 class DestIterator,
class DestShape,
class DestAccessor,
1252 SrcIterator1 s1, SrcShape1
const & sshape1, SrcAccessor1 src1,
1253 SrcIterator2 s2, SrcShape2
const & sshape2, SrcAccessor2 src2,
1254 DestIterator d, DestShape
const & dshape, DestAccessor dest,
1257 vigra_precondition(sshape1.size() == dshape.size() && sshape2.size() == dshape.size(),
1258 "combineTwoMultiArrays(): dimensionality of source and destination arrays differ");
1260 typedef FunctorTraits<Functor> FT;
1262 And<typename FT::isInitializer, typename FT::isBinaryAnalyser>::result
1263 isAnalyserInitializer;
1264 combineTwoMultiArraysImpl(s1, sshape1, src1, s2, sshape2, src2, d, dshape, dest,
1265 f, isAnalyserInitializer());
1268 template <
class SrcIterator1,
class SrcShape1,
class SrcAccessor1,
1269 class SrcIterator2,
class SrcShape2,
class SrcAccessor2,
1270 class DestIterator,
class DestShape,
class DestAccessor,
1274 triple<SrcIterator1, SrcShape1, SrcAccessor1>
const & src1,
1275 triple<SrcIterator2, SrcShape2, SrcAccessor2>
const & src2,
1276 triple<DestIterator, DestShape, DestAccessor>
const & dest,
1280 src2.first, src2.second, src2.third,
1281 dest.first, dest.second, dest.third, f);
1290 template <
class SrcIterator1,
class SrcShape,
class SrcAccessor1,
1291 class SrcIterator2,
class SrcAccessor2,
1292 class SrcIterator3,
class SrcAccessor3,
1293 class DestIterator,
class DestAccessor,
1296 combineThreeMultiArraysImpl(SrcIterator1 s1, SrcShape
const & shape, SrcAccessor1 src1,
1297 SrcIterator2 s2, SrcAccessor2 src2,
1298 SrcIterator3 s3, SrcAccessor3 src3,
1299 DestIterator d, DestAccessor dest, Functor
const & f, MetaInt<0>)
1301 combineThreeLines(s1, s1 + shape[0], src1, s2, src2, s3, src3, d, dest, f);
1304 template <
class SrcIterator1,
class SrcShape,
class SrcAccessor1,
1305 class SrcIterator2,
class SrcAccessor2,
1306 class SrcIterator3,
class SrcAccessor3,
1307 class DestIterator,
class DestAccessor,
1308 class Functor,
int N>
1310 combineThreeMultiArraysImpl(SrcIterator1 s1, SrcShape
const & shape, SrcAccessor1 src1,
1311 SrcIterator2 s2, SrcAccessor2 src2,
1312 SrcIterator3 s3, SrcAccessor3 src3,
1313 DestIterator d, DestAccessor dest,
1314 Functor
const & f, MetaInt<N>)
1316 SrcIterator1 s1end = s1 + shape[N];
1317 for(; s1 < s1end; ++s1, ++s2, ++s3, ++d)
1319 combineThreeMultiArraysImpl(s1.begin(), shape, src1,
1320 s2.begin(), src2, s3.begin(), src3, d.begin(), dest,
1393 template <
class SrcIterator1,
class SrcShape,
class SrcAccessor1,
1394 class SrcIterator2,
class SrcAccessor2,
1395 class SrcIterator3,
class SrcAccessor3,
1396 class DestIterator,
class DestAccessor,
1400 SrcIterator2 s2, SrcAccessor2 src2,
1401 SrcIterator3 s3, SrcAccessor3 src3,
1402 DestIterator d, DestAccessor dest, Functor
const & f)
1404 combineThreeMultiArraysImpl(s1, shape, src1, s2, src2, s3, src3, d, dest, f,
1405 MetaInt<SrcIterator1::level>());
1408 template <
class SrcIterator1,
class SrcShape,
class SrcAccessor1,
1409 class SrcIterator2,
class SrcAccessor2,
1410 class SrcIterator3,
class SrcAccessor3,
1411 class DestIterator,
class DestAccessor,
1415 pair<SrcIterator2, SrcAccessor2>
const & src2,
1416 pair<SrcIterator3, SrcAccessor3>
const & src3,
1417 pair<DestIterator, DestAccessor>
const & dest, Functor
const & f)
1421 src1.first, src1.second, src1.third,
1422 src2.first, src2.second, src3.first, src3.second, dest.first, dest.second, f);
1431 template <
class Iterator,
class Shape,
class Accessor,
class Functor>
1433 inspectMultiArrayImpl(Iterator s, Shape
const & shape, Accessor a, Functor & f, MetaInt<0>)
1435 inspectLine(s, s + shape[0], a, f);
1438 template <
class Iterator,
class Shape,
class Accessor,
class Functor,
int N>
1440 inspectMultiArrayImpl(Iterator s, Shape
const & shape, Accessor a, Functor & f, MetaInt<N>)
1442 Iterator send = s + shape[N];
1443 for(; s < send; ++s)
1445 inspectMultiArrayImpl(s.begin(), shape, a, f, MetaInt<N-1>());
1512 template <
class Iterator,
class Shape,
class Accessor,
class Functor>
1516 inspectMultiArrayImpl(s, shape, a, f, MetaInt<Iterator::level>());
1519 template <
class Iterator,
class Shape,
class Accessor,
class Functor>
1532 template <
class Iterator1,
class Shape,
class Accessor1,
1533 class Iterator2,
class Accessor2,
1536 inspectTwoMultiArraysImpl(Iterator1 s1, Shape
const & shape, Accessor1 a1,
1537 Iterator2 s2, Accessor2 a2,
1538 Functor & f, MetaInt<0>)
1540 inspectTwoLines(s1, s1 + shape[0], a1, s2, a2, f);
1543 template <
class Iterator1,
class Shape,
class Accessor1,
1544 class Iterator2,
class Accessor2,
1545 class Functor,
int N>
1547 inspectTwoMultiArraysImpl(Iterator1 s1, Shape
const & shape, Accessor1 a1,
1548 Iterator2 s2, Accessor2 a2,
1549 Functor & f, MetaInt<N>)
1551 Iterator1 s1end = s1 + shape[N];
1552 for(; s1 < s1end; ++s1, ++s2)
1554 inspectTwoMultiArraysImpl(s1.begin(), shape, a1,
1555 s2.begin(), a2, f, MetaInt<N-1>());
1628 template <
class Iterator1,
class Shape,
class Accessor1,
1629 class Iterator2,
class Accessor2,
1633 Iterator2 s2, Accessor2 a2, Functor & f)
1635 inspectTwoMultiArraysImpl(s1, shape, a1, s2, a2, f, MetaInt<Iterator1::level>());
1638 template <
class Iterator1,
class Shape,
class Accessor1,
1639 class Iterator2,
class Accessor2,
1644 pair<Iterator2, Accessor2>
const & s2, Functor & f)
1647 s2.first, s2.second, f);
1655 #endif //-- VIGRA_MULTI_POINTOPERATORS_H