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>
292 template <
class Iterator,
class Diff_type,
class Accessor,
298 Diff_type border(shape);
299 for(
unsigned int dim=0; dim<shape.size(); dim++)
301 border[dim] = (border_width > shape[dim]) ? shape[dim] : border_width;
304 for(
unsigned int dim=0; dim<shape.size(); dim++)
306 Diff_type start(shape),
309 offset[dim]=border[dim];
313 start[dim]=shape[dim]-border[dim];
318 template <
class Iterator,
class Diff_type,
class Accessor,
327 template <
unsigned int N,
class T,
class S,
342 template <
class SrcIterator,
class SrcShape,
class SrcAccessor,
343 class DestIterator,
class DestShape,
class DestAccessor>
345 copyMultiArrayImpl(SrcIterator s, SrcShape
const & sshape, SrcAccessor src,
346 DestIterator d, DestShape
const & dshape, DestAccessor dest, MetaInt<0>)
350 initLine(d, d + dshape[0], dest, src(s));
354 copyLine(s, s + sshape[0], src, d, dest);
358 template <
class SrcIterator,
class SrcShape,
class SrcAccessor,
359 class DestIterator,
class DestShape,
class DestAccessor,
int N>
361 copyMultiArrayImpl(SrcIterator s, SrcShape
const & sshape, SrcAccessor src,
362 DestIterator d, DestShape
const & dshape, DestAccessor dest, MetaInt<N>)
364 DestIterator dend = d + dshape[N];
369 copyMultiArrayImpl(s.begin(), sshape, src, d.begin(), dshape, dest, MetaInt<N-1>());
374 for(; d < dend; ++s, ++d)
376 copyMultiArrayImpl(s.begin(), sshape, src, d.begin(), dshape, dest, MetaInt<N-1>());
523 template <
class SrcIterator,
class SrcShape,
class SrcAccessor,
524 class DestIterator,
class DestAccessor>
527 SrcShape
const & shape, SrcAccessor src,
528 DestIterator d, DestAccessor dest)
530 copyMultiArrayImpl(s, shape, src, d, shape, dest, MetaInt<SrcIterator::level>());
533 template <
class SrcIterator,
class SrcShape,
class SrcAccessor,
534 class DestIterator,
class DestShape,
class DestAccessor>
536 copyMultiArray(SrcIterator s, SrcShape
const & sshape, SrcAccessor src,
537 DestIterator d, DestShape
const & dshape, DestAccessor dest)
539 vigra_precondition(sshape.size() == dshape.size(),
540 "copyMultiArray(): dimensionality of source and destination array differ");
541 for(
unsigned int i=0; i<sshape.size(); ++i)
542 vigra_precondition(sshape[i] == 1 || sshape[i] == dshape[i],
543 "copyMultiArray(): mismatch between source and destination shapes:\n"
544 "length of each source dimension must either be 1 or equal to the corresponding "
545 "destination length.");
546 copyMultiArrayImpl(s, sshape, src, d, dshape, dest, MetaInt<SrcIterator::level>());
549 template <
class SrcIterator,
class SrcShape,
class SrcAccessor,
550 class DestIterator,
class DestAccessor>
552 copyMultiArray(triple<SrcIterator, SrcShape, SrcAccessor>
const & src,
553 pair<DestIterator, DestAccessor>
const & dest)
556 copyMultiArray(src.first, src.second, src.third, dest.first, dest.second);
559 template <
class SrcIterator,
class SrcShape,
class SrcAccessor,
560 class DestIterator,
class DestShape,
class DestAccessor>
562 copyMultiArray(triple<SrcIterator, SrcShape, SrcAccessor>
const & src,
563 triple<DestIterator, DestShape, DestAccessor>
const & dest)
566 copyMultiArray(src.first, src.second, src.third, dest.first, dest.second, dest.third);
569 template <
unsigned int N,
class T1,
class S1,
573 MultiArrayView<N, T2, S2> dest)
575 for(
int k=0; k<N; ++k)
576 vigra_precondition(source.shape(k) == dest.shape(k) || source.shape(k) == 1 || 1 == dest.shape(k),
577 "copyMultiArray(): shape mismatch between input and output.");
578 if(source.shape() == dest.shape())
581 copyMultiArray(srcMultiArrayRange(source), destMultiArrayRange(dest));
590 template <
class SrcIterator,
class SrcShape,
class SrcAccessor,
591 class DestIterator,
class DestShape,
class DestAccessor,
594 transformMultiArrayReduceImpl(SrcIterator s, SrcShape
const &, SrcAccessor src,
595 DestIterator d, DestShape
const & dshape, DestAccessor dest,
596 SrcShape
const & reduceShape,
597 Functor
const & ff, MetaInt<0>)
599 DestIterator dend = d + dshape[0];
600 for(; d < dend; ++s.template dim<0>(), ++d)
608 template <
class SrcIterator,
class SrcShape,
class SrcAccessor,
609 class DestIterator,
class DestShape,
class DestAccessor,
610 class Functor,
int N>
612 transformMultiArrayReduceImpl(SrcIterator s, SrcShape
const & sshape, SrcAccessor src,
613 DestIterator d, DestShape
const & dshape, DestAccessor dest,
614 SrcShape
const & reduceShape,
615 Functor
const & f, MetaInt<N>)
617 DestIterator dend = d + dshape[N];
618 for(; d < dend; ++s.template dim<N>(), ++d)
620 transformMultiArrayReduceImpl(s, sshape, src, d.begin(), dshape, dest,
621 reduceShape, f, MetaInt<N-1>());
625 template <
class SrcIterator,
class SrcShape,
class SrcAccessor,
626 class DestIterator,
class DestShape,
class DestAccessor,
629 transformMultiArrayImpl(SrcIterator s, SrcShape
const & sshape, SrcAccessor src,
630 DestIterator d, DestShape
const & dshape, DestAccessor dest,
631 Functor
const & f, VigraTrueType)
634 SrcShape reduceShape = sshape;
635 for(
unsigned int i=0; i<dshape.size(); ++i)
637 vigra_precondition(dshape[i] == 1 || sshape[i] == dshape[i],
638 "transformMultiArray(): mismatch between source and destination shapes:\n"
639 "In 'reduce'-mode, the length of each destination dimension must either be 1\n"
640 "or equal to the corresponding source length.");
644 transformMultiArrayReduceImpl(s, sshape, src, d, dshape, dest, reduceShape,
645 f, MetaInt<SrcIterator::level>());
648 template <
class SrcIterator,
class SrcShape,
class SrcAccessor,
649 class DestIterator,
class DestShape,
class DestAccessor,
652 transformMultiArrayExpandImpl(SrcIterator s, SrcShape
const & sshape, SrcAccessor src,
653 DestIterator d, DestShape
const & dshape, DestAccessor dest,
654 Functor
const & f, MetaInt<0>)
658 initLine(d, d + dshape[0], dest, f(src(s)));
662 transformLine(s, s + sshape[0], src, d, dest, f);
666 template <
class SrcIterator,
class SrcShape,
class SrcAccessor,
667 class DestIterator,
class DestShape,
class DestAccessor,
668 class Functor,
int N>
670 transformMultiArrayExpandImpl(SrcIterator s, SrcShape
const & sshape, SrcAccessor src,
671 DestIterator d, DestShape
const & dshape, DestAccessor dest,
672 Functor
const & f, MetaInt<N>)
674 DestIterator dend = d + dshape[N];
679 transformMultiArrayExpandImpl(s.begin(), sshape, src, d.begin(), dshape, dest,
685 for(; d < dend; ++s, ++d)
687 transformMultiArrayExpandImpl(s.begin(), sshape, src, d.begin(), dshape, dest,
693 template <
class SrcIterator,
class SrcShape,
class SrcAccessor,
694 class DestIterator,
class DestShape,
class DestAccessor,
697 transformMultiArrayImpl(SrcIterator s, SrcShape
const & sshape, SrcAccessor src,
698 DestIterator d, DestShape
const & dshape, DestAccessor dest,
699 Functor
const & f, VigraFalseType)
702 for(
unsigned int i=0; i<sshape.size(); ++i)
703 vigra_precondition(sshape[i] == 1 || sshape[i] == dshape[i],
704 "transformMultiArray(): mismatch between source and destination shapes:\n"
705 "In 'expand'-mode, the length of each source dimension must either be 1\n"
706 "or equal to the corresponding destination length.");
707 transformMultiArrayExpandImpl(s, sshape, src, d, dshape, dest,
708 f, MetaInt<SrcIterator::level>());
901 template <
class SrcIterator,
class SrcShape,
class SrcAccessor,
902 class DestIterator,
class DestAccessor,
906 DestIterator d, DestAccessor dest, Functor
const & f)
908 transformMultiArrayExpandImpl(s, shape, src, d, shape, dest,
909 f, MetaInt<SrcIterator::level>());
912 template <
class SrcIterator,
class SrcShape,
class SrcAccessor,
913 class DestIterator,
class DestShape,
class DestAccessor,
917 DestIterator d, DestShape
const & dshape, DestAccessor dest,
920 vigra_precondition(sshape.size() == dshape.size(),
921 "transformMultiArray(): dimensionality of source and destination array differ");
922 typedef FunctorTraits<Functor> FT;
924 And<typename FT::isInitializer, typename FT::isUnaryAnalyser>::result
925 isAnalyserInitializer;
926 transformMultiArrayImpl(s, sshape, src, d, dshape, dest,
927 f, isAnalyserInitializer());
930 template <
class SrcIterator,
class SrcShape,
class SrcAccessor,
931 class DestIterator,
class DestAccessor,
935 pair<DestIterator, DestAccessor>
const & dest, Functor
const & f)
939 dest.first, dest.second, f);
942 template <
class SrcIterator,
class SrcShape,
class SrcAccessor,
943 class DestIterator,
class DestShape,
class DestAccessor,
947 triple<DestIterator, DestShape, DestAccessor>
const & dest,
951 dest.first, dest.second, dest.third, f);
954 template <
unsigned int N,
class T1,
class S1,
958 transformMultiArrayImpl(MultiArrayView<N, T1, S1>
const & source,
959 MultiArrayView<N, T2, S2> dest,
960 Functor
const & f, VigraFalseType)
962 if(source.shape() == dest.shape())
968 template <
unsigned int N,
class T1,
class S1,
972 transformMultiArrayImpl(MultiArrayView<N, T1, S1>
const & source,
973 MultiArrayView<N, T2, S2> dest,
974 Functor
const & f, VigraTrueType)
979 template <
unsigned int N,
class T1,
class S1,
984 MultiArrayView<N, T2, S2> dest, Functor
const & f)
986 for(
int k=0; k<N; ++k)
987 vigra_precondition(source.shape(k) == dest.shape(k) || source.shape(k) == 1 || 1 == dest.shape(k),
988 "transformMultiArray(): shape mismatch between input and output.");
990 typedef FunctorTraits<Functor> FT;
992 And<typename FT::isInitializer, typename FT::isUnaryAnalyser>::result
993 isAnalyserInitializer;
994 transformMultiArrayImpl(source, dest, f, isAnalyserInitializer());
1003 template <
class SrcIterator1,
class SrcShape,
class SrcAccessor1,
1004 class SrcIterator2,
class SrcAccessor2,
1005 class DestIterator,
class DestShape,
class DestAccessor,
1008 combineTwoMultiArraysReduceImpl(
1009 SrcIterator1 s1, SrcShape
const & , SrcAccessor1 src1,
1010 SrcIterator2 s2, SrcAccessor2 src2,
1011 DestIterator d, DestShape
const & dshape, DestAccessor dest,
1012 SrcShape
const & reduceShape,
1013 Functor
const & ff, MetaInt<0>)
1015 DestIterator dend = d + dshape[0];
1016 for(; d < dend; ++s1.template dim<0>(), ++s2.template dim<0>(), ++d)
1024 template <
class SrcIterator1,
class SrcShape,
class SrcAccessor1,
1025 class SrcIterator2,
class SrcAccessor2,
1026 class DestIterator,
class DestShape,
class DestAccessor,
1027 class Functor,
int N>
1029 combineTwoMultiArraysReduceImpl(
1030 SrcIterator1 s1, SrcShape
const & sshape, SrcAccessor1 src1,
1031 SrcIterator2 s2, SrcAccessor2 src2,
1032 DestIterator d, DestShape
const & dshape, DestAccessor dest,
1033 SrcShape
const & reduceShape,
1034 Functor
const & f, MetaInt<N>)
1036 DestIterator dend = d + dshape[N];
1037 for(; d < dend; ++s1.template dim<N>(), ++s2.template dim<N>(), ++d)
1039 combineTwoMultiArraysReduceImpl(s1, sshape, src1, s2, src2,
1040 d.begin(), dshape, dest,
1041 reduceShape, f, MetaInt<N-1>());
1045 template <
class SrcIterator1,
class SrcShape1,
class SrcAccessor1,
1046 class SrcIterator2,
class SrcShape2,
class SrcAccessor2,
1047 class DestIterator,
class DestShape,
class DestAccessor,
1050 combineTwoMultiArraysImpl(
1051 SrcIterator1 s1, SrcShape1
const & sshape1, SrcAccessor1 src1,
1052 SrcIterator2 s2, SrcShape2
const & sshape2, SrcAccessor2 src2,
1053 DestIterator d, DestShape
const & dshape, DestAccessor dest,
1054 Functor
const & f, VigraTrueType)
1057 SrcShape1 reduceShape = sshape1;
1058 for(
unsigned int i=0; i<dshape.size(); ++i)
1060 vigra_precondition(sshape1[i] == sshape2[i] &&
1061 (dshape[i] == 1 || sshape1[i] == dshape[i]),
1062 "combineTwoMultiArrays(): mismatch between source and destination shapes:\n"
1063 "In 'reduce'-mode, the two source shapes must be equal, and\n"
1064 "the length of each destination dimension must either be 1\n"
1065 "or equal to the corresponding source length.");
1069 combineTwoMultiArraysReduceImpl(s1, sshape1, src1, s2, src2,
1070 d, dshape, dest, reduceShape,
1071 f, MetaInt<SrcIterator1::level>());
1074 template <
class SrcIterator1,
class SrcShape1,
class SrcAccessor1,
1075 class SrcIterator2,
class SrcShape2,
class SrcAccessor2,
1076 class DestIterator,
class DestShape,
class DestAccessor,
1079 combineTwoMultiArraysExpandImpl(
1080 SrcIterator1 s1, SrcShape1
const & sshape1, SrcAccessor1 src1,
1081 SrcIterator2 s2, SrcShape2
const & sshape2, SrcAccessor2 src2,
1082 DestIterator d, DestShape
const & dshape, DestAccessor dest,
1083 Functor
const & f, MetaInt<0>)
1085 DestIterator dend = d + dshape[0];
1086 if(sshape1[0] == 1 && sshape2[0] == 1)
1088 initLine(d, dend, dest, f(src1(s1), src2(s2)));
1090 else if(sshape1[0] == 1)
1092 typename SrcAccessor1::value_type sv1 = src1(s1);
1093 for(; d < dend; ++d, ++s2)
1094 dest.set(f(sv1, src2(s2)), d);
1096 else if(sshape2[0] == 1)
1098 typename SrcAccessor2::value_type sv2 = src2(s2);
1099 for(; d < dend; ++d, ++s1)
1100 dest.set(f(src1(s1), sv2), d);
1104 combineTwoLines(s1, s1 + sshape1[0], src1, s2, src2, d, dest, f);
1108 template <
class SrcIterator1,
class SrcShape1,
class SrcAccessor1,
1109 class SrcIterator2,
class SrcShape2,
class SrcAccessor2,
1110 class DestIterator,
class DestShape,
class DestAccessor,
1111 class Functor,
int N>
1113 combineTwoMultiArraysExpandImpl(
1114 SrcIterator1 s1, SrcShape1
const & sshape1, SrcAccessor1 src1,
1115 SrcIterator2 s2, SrcShape2
const & sshape2, SrcAccessor2 src2,
1116 DestIterator d, DestShape
const & dshape, DestAccessor dest,
1117 Functor
const & f, MetaInt<N>)
1119 DestIterator dend = d + dshape[N];
1120 int s1inc = sshape1[N] == 1
1123 int s2inc = sshape2[N] == 1
1126 for(; d < dend; ++d, s1 += s1inc, s2 += s2inc)
1128 combineTwoMultiArraysExpandImpl(s1.begin(), sshape1, src1,
1129 s2.begin(), sshape2, src2,
1130 d.begin(), dshape, dest,
1135 template <
class SrcIterator1,
class SrcShape1,
class SrcAccessor1,
1136 class SrcIterator2,
class SrcShape2,
class SrcAccessor2,
1137 class DestIterator,
class DestShape,
class DestAccessor,
1140 combineTwoMultiArraysImpl(
1141 SrcIterator1 s1, SrcShape1
const & sshape1, SrcAccessor1 src1,
1142 SrcIterator2 s2, SrcShape2
const & sshape2, SrcAccessor2 src2,
1143 DestIterator d, DestShape
const & dshape, DestAccessor dest,
1144 Functor
const & f, VigraFalseType)
1147 for(
unsigned int i=0; i<sshape1.size(); ++i)
1148 vigra_precondition((sshape1[i] == 1 || sshape1[i] == dshape[i]) &&
1149 (sshape2[i] == 1 || sshape2[i] == dshape[i]),
1150 "combineTwoMultiArrays(): mismatch between source and destination shapes:\n"
1151 "In 'expand'-mode, the length of each source dimension must either be 1\n"
1152 "or equal to the corresponding destination length.");
1153 combineTwoMultiArraysExpandImpl(s1, sshape1, src1, s2, sshape2, src2,
1155 f, MetaInt<SrcIterator1::level>());
1374 template <
class SrcIterator1,
class SrcShape,
class SrcAccessor1,
1375 class SrcIterator2,
class SrcAccessor2,
1376 class DestIterator,
class DestAccessor,
1380 SrcIterator2 s2, SrcAccessor2 src2,
1381 DestIterator d, DestAccessor dest, Functor
const & f)
1383 combineTwoMultiArraysExpandImpl(s1, shape, src1, s2, shape, src2, d, shape, dest, f,
1384 MetaInt<SrcIterator1::level>());
1387 template <
class SrcIterator1,
class SrcShape1,
class SrcAccessor1,
1388 class SrcIterator2,
class SrcShape2,
class SrcAccessor2,
1389 class DestIterator,
class DestShape,
class DestAccessor,
1393 SrcIterator1 s1, SrcShape1
const & sshape1, SrcAccessor1 src1,
1394 SrcIterator2 s2, SrcShape2
const & sshape2, SrcAccessor2 src2,
1395 DestIterator d, DestShape
const & dshape, DestAccessor dest,
1398 vigra_precondition(sshape1.size() == dshape.size() && sshape2.size() == dshape.size(),
1399 "combineTwoMultiArrays(): dimensionality of source and destination arrays differ");
1401 typedef FunctorTraits<Functor> FT;
1403 And<typename FT::isInitializer, typename FT::isBinaryAnalyser>::result
1404 isAnalyserInitializer;
1405 combineTwoMultiArraysImpl(s1, sshape1, src1, s2, sshape2, src2, d, dshape, dest,
1406 f, isAnalyserInitializer());
1409 template <
class SrcIterator1,
class SrcShape,
class SrcAccessor1,
1410 class SrcIterator2,
class SrcAccessor2,
1411 class DestIterator,
class DestAccessor,
class Functor>
1414 pair<SrcIterator2, SrcAccessor2>
const & src2,
1415 pair<DestIterator, DestAccessor>
const & dest,
1420 src1.first, src1.second, src1.third,
1421 src2.first, src2.second, dest.first, dest.second, f);
1424 template <
class SrcIterator1,
class SrcShape1,
class SrcAccessor1,
1425 class SrcIterator2,
class SrcShape2,
class SrcAccessor2,
1426 class DestIterator,
class DestShape,
class DestAccessor,
1430 triple<SrcIterator2, SrcShape2, SrcAccessor2>
const & src2,
1431 triple<DestIterator, DestShape, DestAccessor>
const & dest,
1435 src2.first, src2.second, src2.third,
1436 dest.first, dest.second, dest.third, f);
1439 template <
unsigned int N,
class T11,
class S11,
1440 class T12,
class S12,
1444 combineTwoMultiArraysImpl(MultiArrayView<N, T11, S11>
const & source1,
1445 MultiArrayView<N, T12, S12>
const & source2,
1446 MultiArrayView<N, T2, S2> dest,
1447 Functor
const & f, VigraFalseType)
1450 if(source1.shape() == source2.shape() && source1.shape() == dest.shape())
1452 srcMultiArray(source2), destMultiArray(dest), f);
1455 srcMultiArrayRange(source2),
1456 destMultiArrayRange(dest), f);
1459 template <
unsigned int N,
class T11,
class S11,
1460 class T12,
class S12,
1464 combineTwoMultiArraysImpl(MultiArrayView<N, T11, S11>
const & source1,
1465 MultiArrayView<N, T12, S12>
const & source2,
1466 MultiArrayView<N, T2, S2> dest,
1467 Functor
const & f, VigraTrueType)
1471 srcMultiArrayRange(source2),
1472 destMultiArrayRange(dest), f);
1475 template <
unsigned int N,
class T11,
class S11,
1476 class T12,
class S12,
1481 MultiArrayView<N, T12, S12>
const & source2,
1482 MultiArrayView<N, T2, S2> dest,
1485 for(
int k=0; k<N; ++k)
1486 vigra_precondition((source1.shape(k) == source2.shape(k) || source1.shape(k) == 1 || 1 == source2.shape(k)) &&
1487 (source1.shape(k) == dest.shape(k) || source1.shape(k) == 1 || 1 == dest.shape(k)),
1488 "combineTwoMultiArrays(): shape mismatch between inputs and/or output.");
1490 typedef FunctorTraits<Functor> FT;
1492 And<typename FT::isInitializer, typename FT::isBinaryAnalyser>::result
1493 isAnalyserInitializer;
1494 combineTwoMultiArraysImpl(source1, source2, dest, f, isAnalyserInitializer());
1503 template <
class SrcIterator1,
class SrcShape,
class SrcAccessor1,
1504 class SrcIterator2,
class SrcAccessor2,
1505 class SrcIterator3,
class SrcAccessor3,
1506 class DestIterator,
class DestAccessor,
1509 combineThreeMultiArraysImpl(SrcIterator1 s1, SrcShape
const & shape, SrcAccessor1 src1,
1510 SrcIterator2 s2, SrcAccessor2 src2,
1511 SrcIterator3 s3, SrcAccessor3 src3,
1512 DestIterator d, DestAccessor dest, Functor
const & f, MetaInt<0>)
1514 combineThreeLines(s1, s1 + shape[0], src1, s2, src2, s3, src3, d, dest, f);
1517 template <
class SrcIterator1,
class SrcShape,
class SrcAccessor1,
1518 class SrcIterator2,
class SrcAccessor2,
1519 class SrcIterator3,
class SrcAccessor3,
1520 class DestIterator,
class DestAccessor,
1521 class Functor,
int N>
1523 combineThreeMultiArraysImpl(SrcIterator1 s1, SrcShape
const & shape, SrcAccessor1 src1,
1524 SrcIterator2 s2, SrcAccessor2 src2,
1525 SrcIterator3 s3, SrcAccessor3 src3,
1526 DestIterator d, DestAccessor dest,
1527 Functor
const & f, MetaInt<N>)
1529 SrcIterator1 s1end = s1 + shape[N];
1530 for(; s1 < s1end; ++s1, ++s2, ++s3, ++d)
1532 combineThreeMultiArraysImpl(s1.begin(), shape, src1,
1533 s2.begin(), src2, s3.begin(), src3, d.begin(), dest,
1645 template <
class SrcIterator1,
class SrcShape,
class SrcAccessor1,
1646 class SrcIterator2,
class SrcAccessor2,
1647 class SrcIterator3,
class SrcAccessor3,
1648 class DestIterator,
class DestAccessor,
1652 SrcIterator2 s2, SrcAccessor2 src2,
1653 SrcIterator3 s3, SrcAccessor3 src3,
1654 DestIterator d, DestAccessor dest, Functor
const & f)
1656 combineThreeMultiArraysImpl(s1, shape, src1, s2, src2, s3, src3, d, dest, f,
1657 MetaInt<SrcIterator1::level>());
1660 template <
class SrcIterator1,
class SrcShape,
class SrcAccessor1,
1661 class SrcIterator2,
class SrcAccessor2,
1662 class SrcIterator3,
class SrcAccessor3,
1663 class DestIterator,
class DestAccessor,
1667 pair<SrcIterator2, SrcAccessor2>
const & src2,
1668 pair<SrcIterator3, SrcAccessor3>
const & src3,
1669 pair<DestIterator, DestAccessor>
const & dest, Functor
const & f)
1673 src1.first, src1.second, src1.third,
1674 src2.first, src2.second, src3.first, src3.second, dest.first, dest.second, f);
1677 template <
unsigned int N,
class T11,
class S11,
1678 class T12,
class S12,
1679 class T13,
class S13,
1684 MultiArrayView<N, T12, S12>
const & source2,
1685 MultiArrayView<N, T13, S13>
const & source3,
1686 MultiArrayView<N, T2, S2> dest, Functor
const & f)
1688 vigra_precondition(source1.shape() == source2.shape() && source1.shape() == source3.shape() && source1.shape() == dest.shape(),
1689 "combineThreeMultiArrays(): shape mismatch between inputs and/or output.");
1692 srcMultiArrayRange(source1),
1693 srcMultiArray(source2), srcMultiArray(source3), destMultiArray(dest), f);
1702 template <
class Iterator,
class Shape,
class Accessor,
class Functor>
1704 inspectMultiArrayImpl(Iterator s, Shape
const & shape, Accessor a, Functor & f, MetaInt<0>)
1706 inspectLine(s, s + shape[0], a, f);
1709 template <
class Iterator,
class Shape,
class Accessor,
class Functor,
int N>
1711 inspectMultiArrayImpl(Iterator s, Shape
const & shape, Accessor a, Functor & f, MetaInt<N>)
1713 Iterator send = s + shape[N];
1714 for(; s < send; ++s)
1716 inspectMultiArrayImpl(s.begin(), shape, a, f, MetaInt<N-1>());
1806 template <
class Iterator,
class Shape,
class Accessor>
1807 struct inspectMultiArray_binder
1810 const Shape & shape;
1812 inspectMultiArray_binder(Iterator s_,
const Shape & shape_, Accessor a_)
1813 : s(s_), shape(shape_), a(a_) {}
1814 template <
class Functor>
1815 void operator()(Functor & f)
1817 inspectMultiArrayImpl(s, shape, a, f, MetaInt<Iterator::level>());
1821 template <
class Iterator,
class Shape,
class Accessor,
class Functor>
1825 inspectMultiArray_binder<Iterator, Shape, Accessor> g(s, shape, a);
1826 detail::extra_passes_select(g, f);
1829 template <
class Iterator,
class Shape,
class Accessor,
class Functor>
1836 template <
unsigned int N,
class T,
class S,
class Functor>
1849 template <
class Iterator1,
class Shape,
class Accessor1,
1850 class Iterator2,
class Accessor2,
1853 inspectTwoMultiArraysImpl(Iterator1 s1, Shape
const & shape, Accessor1 a1,
1854 Iterator2 s2, Accessor2 a2,
1855 Functor & f, MetaInt<0>)
1857 inspectTwoLines(s1, s1 + shape[0], a1, s2, a2, f);
1860 template <
class Iterator1,
class Shape,
class Accessor1,
1861 class Iterator2,
class Accessor2,
1862 class Functor,
int N>
1864 inspectTwoMultiArraysImpl(Iterator1 s1, Shape
const & shape, Accessor1 a1,
1865 Iterator2 s2, Accessor2 a2,
1866 Functor & f, MetaInt<N>)
1868 Iterator1 s1end = s1 + shape[N];
1869 for(; s1 < s1end; ++s1, ++s2)
1871 inspectTwoMultiArraysImpl(s1.begin(), shape, a1,
1872 s2.begin(), a2, f, MetaInt<N-1>());
1967 template <
class Iterator1,
class Shape,
class Accessor1,
1968 class Iterator2,
class Accessor2>
1969 struct inspectTwoMultiArrays_binder
1972 const Shape & shape;
1976 inspectTwoMultiArrays_binder(Iterator1 s1_,
const Shape & shape_,
1977 Accessor1 a1_, Iterator2 s2_, Accessor2 a2_)
1978 : s1(s1_), shape(shape_), a1(a1_), s2(s2_), a2(a2_) {}
1979 template <
class Functor>
1980 void operator()(Functor & f)
1982 inspectTwoMultiArraysImpl(s1, shape, a1, s2, a2, f,
1983 MetaInt<Iterator1::level>());
1987 template <
class Iterator1,
class Shape,
class Accessor1,
1988 class Iterator2,
class Accessor2,
1992 Iterator2 s2, Accessor2 a2, Functor & f)
1994 inspectTwoMultiArrays_binder<Iterator1, Shape, Accessor1,
1995 Iterator2, Accessor2>
1996 g(s1, shape, a1, s2, a2);
1997 detail::extra_passes_select(g, f);
2000 template <
class Iterator1,
class Shape,
class Accessor1,
2001 class Iterator2,
class Accessor2,
2005 pair<Iterator2, Accessor2>
const & s2, Functor & f)
2008 s2.first, s2.second, f);
2011 template <
unsigned int N,
class T1,
class S1,
2016 MultiArrayView<N, T2, S2>
const & s2, Functor & f)
2018 vigra_precondition(s1.shape() == s2.shape(),
2019 "inspectTwoMultiArrays(): shape mismatch between inputs.");
2022 srcMultiArray(s2), f);
2030 #endif //-- VIGRA_MULTI_POINTOPERATORS_H