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"
72template <
class Iterator,
class Shape,
class Accessor,
75initMultiArrayImpl(Iterator s, Shape
const & shape, Accessor a, VALUETYPE
const & v, MetaInt<0>)
77 initLine(s, s + shape[0], a, v);
80template <
class Iterator,
class Shape,
class Accessor,
81 class VALUETYPE,
int N>
83initMultiArrayImpl(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>());
201template <
class Iterator,
class Shape,
class Accessor,
class VALUETYPE>
208template <
class Iterator,
class Shape,
class Accessor,
class VALUETYPE>
210initMultiArray(triple<Iterator, Shape, Accessor>
const & s, VALUETYPE
const & v)
212 initMultiArrayImpl(s.first, s.second, s.third, v, MetaInt<Iterator::level>());
215template <
unsigned int N,
class T,
class S,
class VALUETYPE>
302template <
class Iterator,
class Diff_type,
class Accessor,
309 for(
unsigned int dim=0; dim<shape.
size(); dim++)
315 for(
unsigned int dim=0; dim<shape.
size(); dim++)
329template <
class Iterator,
class Diff_type,
class Accessor,
336 Diff_type(border_width), Diff_type(border_width), v);
339template <
class Iterator,
class Diff_type,
class Accessor,
348template <
class Iterator,
class Diff_type,
class Accessor,
352 Diff_type
const & lower_border, Diff_type
const & upper_border,
356 lower_border, upper_border, v);
359template <
unsigned int N,
class T,
class S,
368template <
unsigned int N,
class T,
class S,
385template <
class SrcIterator,
class SrcShape,
class SrcAccessor,
386 class DestIterator,
class DestShape,
class DestAccessor>
388copyMultiArrayImpl(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);
401template <
class SrcIterator,
class SrcShape,
class SrcAccessor,
402 class DestIterator,
class DestShape,
class DestAccessor,
int N>
404copyMultiArrayImpl(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>());
576template <
class SrcIterator,
class SrcShape,
class SrcAccessor,
577 class DestIterator,
class DestShape,
class DestAccessor>
579copyMultiArray(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>());
592template <
class SrcIterator,
class SrcShape,
class SrcAccessor,
593 class DestIterator,
class DestAccessor>
595copyMultiArray(triple<SrcIterator, SrcShape, SrcAccessor>
const & src,
596 pair<DestIterator, DestAccessor>
const & dest)
599 copyMultiArray(src.first, src.second, src.third, dest.first, dest.second);
602template <
class SrcIterator,
class SrcShape,
class SrcAccessor,
603 class DestIterator,
class DestShape,
class DestAccessor>
605copyMultiArray(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);
612template <
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));
633template <
class SrcIterator,
class SrcShape,
class SrcAccessor,
634 class DestIterator,
class DestShape,
class DestAccessor,
637transformMultiArrayReduceImpl(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)
651template <
class SrcIterator,
class SrcShape,
class SrcAccessor,
652 class DestIterator,
class DestShape,
class DestAccessor,
653 class Functor,
int N>
655transformMultiArrayReduceImpl(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>());
668template <
class SrcIterator,
class SrcShape,
class SrcAccessor,
669 class DestIterator,
class DestShape,
class DestAccessor,
672transformMultiArrayImpl(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>());
691template <
class SrcIterator,
class SrcShape,
class SrcAccessor,
692 class DestIterator,
class DestShape,
class DestAccessor,
695transformMultiArrayExpandImpl(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);
709template <
class SrcIterator,
class SrcShape,
class SrcAccessor,
710 class DestIterator,
class DestShape,
class DestAccessor,
711 class Functor,
int N>
713transformMultiArrayExpandImpl(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,
736template <
class SrcIterator,
class SrcShape,
class SrcAccessor,
737 class DestIterator,
class DestShape,
class DestAccessor,
740transformMultiArrayImpl(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>());
951 transformMultiArrayExpandImpl(s, shape,
src, d, shape,
dest,
955template <
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());
973template <
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);
985template <
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);
997template <
unsigned int N,
class T1,
class S1,
1001transformMultiArrayImpl(MultiArrayView<N, T1, S1>
const & source,
1002 MultiArrayView<N, T2, S2> dest,
1003 Functor
const & f, VigraFalseType)
1005 if(source.shape() == dest.shape())
1011template <
unsigned int N,
class T1,
class S1,
1015transformMultiArrayImpl(MultiArrayView<N, T1, S1>
const & source,
1016 MultiArrayView<N, T2, S2> dest,
1017 Functor
const & f, VigraTrueType)
1022template <
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());
1046template <
class SrcIterator1,
class SrcShape,
class SrcAccessor1,
1047 class SrcIterator2,
class SrcAccessor2,
1048 class DestIterator,
class DestShape,
class DestAccessor,
1051combineTwoMultiArraysReduceImpl(
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)
1067template <
class SrcIterator1,
class SrcShape,
class SrcAccessor1,
1068 class SrcIterator2,
class SrcAccessor2,
1069 class DestIterator,
class DestShape,
class DestAccessor,
1070 class Functor,
int N>
1072combineTwoMultiArraysReduceImpl(
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>());
1088template <
class SrcIterator1,
class SrcShape1,
class SrcAccessor1,
1089 class SrcIterator2,
class SrcShape2,
class SrcAccessor2,
1090 class DestIterator,
class DestShape,
class DestAccessor,
1093combineTwoMultiArraysImpl(
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>());
1117template <
class SrcIterator1,
class SrcShape1,
class SrcAccessor1,
1118 class SrcIterator2,
class SrcShape2,
class SrcAccessor2,
1119 class DestIterator,
class DestShape,
class DestAccessor,
1122combineTwoMultiArraysExpandImpl(
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);
1151template <
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>
1156combineTwoMultiArraysExpandImpl(
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,
1178template <
class SrcIterator1,
class SrcShape1,
class SrcAccessor1,
1179 class SrcIterator2,
class SrcShape2,
class SrcAccessor2,
1180 class DestIterator,
class DestShape,
class DestAccessor,
1183combineTwoMultiArraysImpl(
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>());
1426 combineTwoMultiArraysExpandImpl(s1, shape,
src1, s2, shape,
src2, d, shape,
dest, f,
1430template <
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());
1452template <
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);
1467template <
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);
1482template <
unsigned int N,
class T11,
class S11,
1483 class T12,
class S12,
1487combineTwoMultiArraysImpl(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);
1502template <
unsigned int N,
class T11,
class S11,
1503 class T12,
class S12,
1507combineTwoMultiArraysImpl(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);
1518template <
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());
1546template <
class SrcIterator1,
class SrcShape,
class SrcAccessor1,
1547 class SrcIterator2,
class SrcAccessor2,
1548 class SrcIterator3,
class SrcAccessor3,
1549 class DestIterator,
class DestAccessor,
1552combineThreeMultiArraysImpl(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);
1560template <
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>
1566combineThreeMultiArraysImpl(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,
1699 combineThreeMultiArraysImpl(s1, shape,
src1, s2,
src2,
s3,
src3, d,
dest, f,
1703template <
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);
1720template <
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);
1745template <
class Iterator,
class Shape,
class Accessor,
class Functor>
1747inspectMultiArrayImpl(Iterator s, Shape
const & shape, Accessor a, Functor & f, MetaInt<0>)
1749 inspectLine(s, s + shape[0], a, f);
1752template <
class Iterator,
class Shape,
class Accessor,
class Functor,
int N>
1754inspectMultiArrayImpl(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>());
1849template <
class Iterator,
class Shape,
class Accessor>
1850struct 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)
1864template <
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);
1872template <
class Iterator,
class Shape,
class Accessor,
class Functor>
1879template <
unsigned int N,
class T,
class S,
class Functor>
1892template <
class Iterator1,
class Shape,
class Accessor1,
1893 class Iterator2,
class Accessor2,
1896inspectTwoMultiArraysImpl(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);
1903template <
class Iterator1,
class Shape,
class Accessor1,
1904 class Iterator2,
class Accessor2,
1905 class Functor,
int N>
1907inspectTwoMultiArraysImpl(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>());
2012struct inspectTwoMultiArrays_binder
2015 const Shape & shape;
2019 inspectTwoMultiArrays_binder(
Iterator1 s1_,
const Shape & shape_,
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,
2030template <
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);
2043template <
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);
2054template <
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);
TinyVector< MultiArrayIndex, N > type
Definition multi_shape.hxx:272
Class for a single RGB value.
Definition rgbvalue.hxx:128
size_type size() const
Definition tinyvector.hxx:913
void combineThreeMultiArrays(...)
Combine three multi-dimensional arrays into one using a ternary function or functor.
void initMultiArray(...)
Write a value to every element in a multi-dimensional array.
void inspectTwoMultiArrays(...)
Call an analyzing functor at all corresponding elements of two multi-dimensional arrays.
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.
std::ptrdiff_t MultiArrayIndex
Definition multi_fwd.hxx:60
void combineTwoMultiArrays(...)
Combine two multi-dimensional arrays into one using a binary function or functor.
void copyMultiArray(...)
Copy a multi-dimensional array.
void initMultiArrayBorder(...)
Write values to the specified border values in the array.