37 #ifndef VIGRA_MULTI_ARRAY_HXX
38 #define VIGRA_MULTI_ARRAY_HXX
42 #include "accessor.hxx"
43 #include "tinyvector.hxx"
44 #include "rgbvalue.hxx"
45 #include "basicimage.hxx"
46 #include "imageiterator.hxx"
47 #include "numerictraits.hxx"
48 #include "multi_iterator.hxx"
49 #include "multi_pointoperators.hxx"
50 #include "metaprogramming.hxx"
51 #include "mathutil.hxx"
52 #include "algorithm.hxx"
55 #ifdef VIGRA_CHECK_BOUNDS
56 #define VIGRA_ASSERT_INSIDE(diff) \
57 vigra_precondition(this->isInside(diff), "Index out of bounds")
59 #define VIGRA_ASSERT_INSIDE(diff)
81 template <
class Str
ideTag,
unsigned int N>
84 typedef StrideTag type;
87 template <
class Str
ideTag>
88 struct MaybeStrided <StrideTag, 0>
90 typedef StridedArrayTag type;
106 struct MultiIteratorChooser;
120 struct MultiIteratorChooser <StridedArrayTag>
122 template <
unsigned int N,
class T,
class REFERENCE,
class POINTER>
125 typedef StridedMultiIterator <N, T, REFERENCE, POINTER> type;
128 template <
unsigned int N,
class T,
class REFERENCE,
class POINTER>
131 typedef StridedScanOrderIterator <N, T, REFERENCE, POINTER> type;
134 template <
class Iter,
class View>
135 static Iter constructIterator(View * v)
153 struct MultiIteratorChooser <UnstridedArrayTag>
155 template <
unsigned int N,
class T,
class REFERENCE,
class POINTER>
158 typedef MultiIterator <N, T, REFERENCE, POINTER> type;
161 template <
unsigned int N,
class T,
class REFERENCE,
class POINTER>
164 typedef POINTER type;
167 template <
class Iter,
class View>
168 static Iter constructIterator(View * v)
180 template <
class DestIterator,
class Shape,
class T>
182 initMultiArrayData(DestIterator d, Shape
const & shape, T
const & init, MetaInt<0>)
184 DestIterator dend = d + shape[0];
191 template <
class DestIterator,
class Shape,
class T,
int N>
193 initMultiArrayData(DestIterator d, Shape
const & shape, T
const & init, MetaInt<N>)
195 DestIterator dend = d + shape[N];
198 initMultiArrayData(d.begin(), shape, init, MetaInt<N-1>());
203 #define VIGRA_COPY_MULTI_ARRAY_DATA(name, op) \
204 template <class SrcIterator, class Shape, class DestIterator> \
206 name##MultiArrayData(SrcIterator s, Shape const & shape, DestIterator d, MetaInt<0>) \
208 for(MultiArrayIndex i=0; i < shape[0]; ++i, ++s, ++d) \
210 *d op detail::RequiresExplicitCast<typename DestIterator::value_type>::cast(*s); \
214 template <class Ref, class Ptr, class Shape, class DestIterator> \
216 name##MultiArrayData(MultiIterator<1, UInt8, Ref, Ptr> si, Shape const & shape, DestIterator d, MetaInt<0>) \
219 for(MultiArrayIndex i=0; i < shape[0]; ++i, ++s, ++d) \
221 *d op detail::RequiresExplicitCast<typename DestIterator::value_type>::cast(*s); \
225 template <class SrcIterator, class Shape, class DestIterator, int N> \
227 name##MultiArrayData(SrcIterator s, Shape const & shape, DestIterator d, MetaInt<N>) \
229 for(MultiArrayIndex i=0; i < shape[N]; ++i, ++s, ++d) \
231 name##MultiArrayData(s.begin(), shape, d.begin(), MetaInt<N-1>()); \
235 template <class DestIterator, class Shape, class T> \
237 name##ScalarMultiArrayData(DestIterator d, Shape const & shape, T const & init, MetaInt<0>) \
239 for(MultiArrayIndex i=0; i < shape[0]; ++i, ++d) \
241 *d op detail::RequiresExplicitCast<typename DestIterator::value_type>::cast(init); \
245 template <class DestIterator, class Shape, class T, int N> \
247 name##ScalarMultiArrayData(DestIterator d, Shape const & shape, T const & init, MetaInt<N>) \
249 for(MultiArrayIndex i=0; i < shape[N]; ++i, ++d) \
251 name##ScalarMultiArrayData(d.begin(), shape, init, MetaInt<N-1>()); \
255 VIGRA_COPY_MULTI_ARRAY_DATA(copy, =)
256 VIGRA_COPY_MULTI_ARRAY_DATA(copyAdd, +=)
257 VIGRA_COPY_MULTI_ARRAY_DATA(copySub, -=)
258 VIGRA_COPY_MULTI_ARRAY_DATA(copyMul, *=)
259 VIGRA_COPY_MULTI_ARRAY_DATA(copyDiv, /=)
261 #undef VIGRA_COPY_MULTI_ARRAY_DATA
263 template <
class SrcIterator,
class Shape,
class T,
class ALLOC>
265 uninitializedCopyMultiArrayData(SrcIterator s, Shape
const & shape, T * & d, ALLOC & a, MetaInt<0>)
267 SrcIterator send = s + shape[0];
268 for(; s < send; ++s, ++d)
270 a.construct(d, static_cast<T const &>(*s));
275 template <
class Ref,
class Ptr,
class Shape,
class T,
class ALLOC>
277 uninitializedCopyMultiArrayData(MultiIterator<1, UInt8, Ref, Ptr> si, Shape
const & shape, T * & d, ALLOC & a, MetaInt<0>)
279 Ptr s = &(*si), send = s + shape[0];
280 for(; s < send; ++s, ++d)
282 a.construct(d, static_cast<T const &>(*s));
286 template <
class SrcIterator,
class Shape,
class T,
class ALLOC,
int N>
288 uninitializedCopyMultiArrayData(SrcIterator s, Shape
const & shape, T * & d, ALLOC & a, MetaInt<N>)
290 SrcIterator send = s + shape[N];
293 uninitializedCopyMultiArrayData(s.begin(), shape, d, a, MetaInt<N-1>());
297 template <
class SrcIterator,
class Shape,
class T,
class Functor>
299 reduceOverMultiArray(SrcIterator s, Shape
const & shape, T & result, Functor
const & f, MetaInt<0>)
301 SrcIterator send = s + shape[0];
308 template <
class SrcIterator,
class Shape,
class T,
class Functor,
int N>
310 reduceOverMultiArray(SrcIterator s, Shape
const & shape, T & result, Functor
const & f, MetaInt<N>)
312 SrcIterator send = s + shape[N];
315 reduceOverMultiArray(s.begin(), shape, result, f, MetaInt<N-1>());
319 struct MaxNormReduceFunctor
321 template <
class T,
class U>
322 void operator()(T & result, U
const & u)
const
330 struct L1NormReduceFunctor
332 template <
class T,
class U>
333 void operator()(T & result, U
const & u)
const
339 struct SquaredL2NormReduceFunctor
341 template <
class T,
class U>
342 void operator()(T & result, U
const & u)
const
349 struct WeightedL2NormReduceFunctor
353 WeightedL2NormReduceFunctor(T s)
358 void operator()(T & result, U
const & u)
const
364 struct SumReduceFunctor
366 template <
class T,
class U>
367 void operator()(T & result, U
const & u)
const
373 struct ProdReduceFunctor
375 template <
class T,
class U>
376 void operator()(T & result, U
const & u)
const
382 struct MinmaxReduceFunctor
384 template <
class T,
class U>
385 void operator()(T & result, U
const & u)
const
389 if(result.second < u)
394 struct MeanVarianceReduceFunctor
396 template <
class T,
class U>
397 void operator()(T & result, U
const & u)
const
400 typename T::second_type t1 = u - result.second;
401 typename T::second_type t2 = t1 / result.first;
403 result.third += (result.first-1.0)*t1*t2;
407 struct AllTrueReduceFunctor
409 template <
class T,
class U>
410 void operator()(T & result, U
const & u)
const
412 result = result && (u != NumericTraits<U>::zero());
416 struct AnyTrueReduceFunctor
418 template <
class T,
class U>
419 void operator()(T & result, U
const & u)
const
421 result = result || (u != NumericTraits<U>::zero());
425 template <
class SrcIterator,
class Shape,
class DestIterator>
427 equalityOfMultiArrays(SrcIterator s, Shape
const & shape, DestIterator d, MetaInt<0>)
429 SrcIterator send = s + shape[0];
430 for(; s < send; ++s, ++d)
438 template <
class SrcIterator,
class Shape,
class DestIterator,
int N>
440 equalityOfMultiArrays(SrcIterator s, Shape
const & shape, DestIterator d, MetaInt<N>)
442 SrcIterator send = s + shape[N];
443 for(; s < send; ++s, ++d)
445 if(!equalityOfMultiArrays(s.begin(), shape, d.begin(), MetaInt<N-1>()))
452 template <
class SrcIterator,
class Shape,
class DestIterator>
454 swapDataImpl(SrcIterator s, Shape
const & shape, DestIterator d, MetaInt<0>)
456 SrcIterator send = s + shape[0];
457 for(; s < send; ++s, ++d)
461 template <
class SrcIterator,
class Shape,
class DestIterator,
int N>
463 swapDataImpl(SrcIterator s, Shape
const & shape, DestIterator d, MetaInt<N>)
465 SrcIterator send = s + shape[N];
466 for(; s < send; ++s, ++d)
467 swapDataImpl(s.begin(), shape, d.begin(), MetaInt<N-1>());
480 namespace multi_math {
483 struct MultiMathOperand;
485 namespace math_detail {
487 template <
unsigned int N,
class T,
class C,
class E>
488 void assign(MultiArrayView<N, T, C>, MultiMathOperand<E>
const &);
490 template <
unsigned int N,
class T,
class C,
class E>
491 void plusAssign(MultiArrayView<N, T, C>, MultiMathOperand<E>
const &);
493 template <
unsigned int N,
class T,
class C,
class E>
494 void minusAssign(MultiArrayView<N, T, C>, MultiMathOperand<E>
const &);
496 template <
unsigned int N,
class T,
class C,
class E>
497 void multiplyAssign(MultiArrayView<N, T, C>, MultiMathOperand<E>
const &);
499 template <
unsigned int N,
class T,
class C,
class E>
500 void divideAssign(MultiArrayView<N, T, C>, MultiMathOperand<E>
const &);
502 template <
unsigned int N,
class T,
class A,
class E>
503 void assignOrResize(MultiArray<N, T, A> &, MultiMathOperand<E>
const &);
505 template <
unsigned int N,
class T,
class A,
class E>
506 void plusAssignOrResize(MultiArray<N, T, A> &, MultiMathOperand<E>
const &);
508 template <
unsigned int N,
class T,
class A,
class E>
509 void minusAssignOrResize(MultiArray<N, T, A> &, MultiMathOperand<E>
const &);
511 template <
unsigned int N,
class T,
class A,
class E>
512 void multiplyAssignOrResize(MultiArray<N, T, A> &, MultiMathOperand<E>
const &);
514 template <
unsigned int N,
class T,
class A,
class E>
515 void divideAssignOrResize(MultiArray<N, T, A> &, MultiMathOperand<E>
const &);
521 template <
class T>
class FindSum;
523 struct UnsuitableTypeForExpandElements {};
526 struct ExpandElementResult
528 typedef UnsuitableTypeForExpandElements type;
532 struct ExpandElementResult<std::complex<T> >
542 struct ExpandElementResult<FFTWComplex<T> >
548 template <
class T,
int SIZE>
549 struct ExpandElementResult<TinyVector<T, SIZE> >
552 enum { size = SIZE };
555 template <
class T,
unsigned int R,
unsigned int G,
unsigned int B>
556 struct ExpandElementResult<RGBValue<T, R, G, B> >
562 #define VIGRA_DEFINE_EXPAND_ELEMENT_RESULT(TYPE) \
564 struct ExpandElementResult<TYPE> \
570 VIGRA_DEFINE_EXPAND_ELEMENT_RESULT(
bool)
571 VIGRA_DEFINE_EXPAND_ELEMENT_RESULT(
char)
572 VIGRA_DEFINE_EXPAND_ELEMENT_RESULT(
signed char)
573 VIGRA_DEFINE_EXPAND_ELEMENT_RESULT(
signed short)
574 VIGRA_DEFINE_EXPAND_ELEMENT_RESULT(
signed int)
575 VIGRA_DEFINE_EXPAND_ELEMENT_RESULT(
signed long)
576 VIGRA_DEFINE_EXPAND_ELEMENT_RESULT(
signed long long)
577 VIGRA_DEFINE_EXPAND_ELEMENT_RESULT(
unsigned char)
578 VIGRA_DEFINE_EXPAND_ELEMENT_RESULT(
unsigned short)
579 VIGRA_DEFINE_EXPAND_ELEMENT_RESULT(
unsigned int)
580 VIGRA_DEFINE_EXPAND_ELEMENT_RESULT(
unsigned long)
581 VIGRA_DEFINE_EXPAND_ELEMENT_RESULT(
unsigned long long)
582 VIGRA_DEFINE_EXPAND_ELEMENT_RESULT(
float)
583 VIGRA_DEFINE_EXPAND_ELEMENT_RESULT(
double)
584 VIGRA_DEFINE_EXPAND_ELEMENT_RESULT(
long double)
586 #undef VIGRA_DEFINE_EXPAND_ELEMENT_RESULT
595 template <
unsigned int N,
class T,
class C>
596 struct NormTraits<MultiArrayView<N, T, C> >
598 typedef MultiArrayView<N, T, C> Type;
599 typedef typename NormTraits<T>::SquaredNormType SquaredNormType;
600 typedef typename SquareRootTraits<SquaredNormType>::SquareRootResult NormType;
603 template <
unsigned int N,
class T,
class A>
604 struct NormTraits<MultiArray<N, T, A> >
605 :
public NormTraits<typename MultiArray<N, T, A>::view_type>
607 typedef NormTraits<typename MultiArray<N, T, A>::view_type> BaseType;
608 typedef MultiArray<N, T, A> Type;
609 typedef typename BaseType::SquaredNormType SquaredNormType;
610 typedef typename BaseType::NormType NormType;
649 template <
unsigned int N,
class T,
class Str
ideTag>
709 typedef typename vigra::detail::MultiIteratorChooser <
710 StrideTag>::template Traverser <actual_dimension, T, T &, T *>::type
traverser;
714 typedef typename vigra::detail::MultiIteratorChooser <
715 StrideTag>::template Traverser <actual_dimension, T, T const &, T const *>::type
const_traverser;
737 typedef typename difference_type::value_type diff_zero_t;
755 template <
class U,
class CN>
758 template <
class U,
class CN>
764 template <
class U,
class CN>
776 : m_shape (diff_zero_t(0)), m_stride (diff_zero_t(0)), m_ptr (0)
783 template <
class Str
ide>
785 : m_shape (other.shape()),
786 m_stride (other.
stride()),
789 vigra_precondition(other.checkInnerStride(StrideTag()),
790 "MultiArrayView<..., UnstridedArrayTag>(MultiArrayView const &): cannot create unstrided view from strided array.");
797 m_stride (detail::defaultStride<actual_dimension>(shape)),
798 m_ptr (const_cast<pointer>(ptr))
807 const difference_type &
stride,
811 m_ptr (const_cast<pointer>(ptr))
813 vigra_precondition(checkInnerStride(StrideTag()),
814 "MultiArrayView<..., UnstridedArrayTag>::MultiArrayView(): First dimension of given array is not unstrided.");
819 template <
class ALLOC>
822 m_stride (detail::defaultStride<actual_dimension>(m_shape)),
823 m_ptr (const_cast<pointer>(image.
data()))
837 m_shape = diff_zero_t(0);
838 m_stride = diff_zero_t(0);
860 template<
class Str
ide2>
871 template<
class U,
class C1>
874 vigra_precondition(this->
shape() == rhs.
shape(),
875 "MultiArrayView::operator=(): shape mismatch.");
890 template<
class U,
class C1>
896 template<
class U,
class C1>
902 template<
class U,
class C1>
908 template<
class U,
class C1>
915 detail::copyAddScalarMultiArrayData(
traverser_begin(),
shape(), rhs, MetaInt<actual_dimension-1>());
923 detail::copySubScalarMultiArrayData(
traverser_begin(),
shape(), rhs, MetaInt<actual_dimension-1>());
931 detail::copyMulScalarMultiArrayData(
traverser_begin(),
shape(), rhs, MetaInt<actual_dimension-1>());
939 detail::copyDivScalarMultiArrayData(
traverser_begin(),
shape(), rhs, MetaInt<actual_dimension-1>());
946 template<
class Expression>
949 multi_math::math_detail::assign(*
this, rhs);
956 template<
class Expression>
959 multi_math::math_detail::plusAssign(*
this, rhs);
966 template<
class Expression>
969 multi_math::math_detail::minusAssign(*
this, rhs);
976 template<
class Expression>
979 multi_math::math_detail::multiplyAssign(*
this, rhs);
986 template<
class Expression>
989 multi_math::math_detail::divideAssign(*
this, rhs);
997 VIGRA_ASSERT_INSIDE(d);
998 return m_ptr [
dot (d, m_stride)];
1005 VIGRA_ASSERT_INSIDE(d);
1006 return m_ptr [
dot (d, m_stride)];
1030 return m_ptr [detail::ScanOrderToOffset<actual_dimension>::exec(d, m_shape, m_stride)];
1046 return m_ptr [detail::ScanOrderToOffset<actual_dimension>::exec(d, m_shape, m_stride)];
1053 difference_type result;
1054 detail::ScanOrderToCoordinate<actual_dimension>::exec(d, m_shape, result);
1062 return detail::CoordinateToScanOrder<actual_dimension>::exec(m_shape, d);
1070 return m_ptr [detail::CoordinatesToOffest<StrideTag>::exec(m_stride, x)];
1078 return m_ptr [detail::CoordinatesToOffest<StrideTag>::exec(m_stride, x, y)];
1083 reference
operator() (difference_type_1 x, difference_type_1 y, difference_type_1 z)
1086 return m_ptr [m_stride[0]*x + m_stride[1]*y + m_stride[2]*z];
1092 difference_type_1 z, difference_type_1 u)
1095 return m_ptr [m_stride[0]*x + m_stride[1]*y + m_stride[2]*z + m_stride[3]*u];
1100 reference
operator() (difference_type_1 x, difference_type_1 y, difference_type_1 z,
1101 difference_type_1 u, difference_type_1 v)
1104 return m_ptr [m_stride[0]*x + m_stride[1]*y + m_stride[2]*z + m_stride[3]*u + m_stride[4]*v];
1112 return m_ptr [detail::CoordinatesToOffest<StrideTag>::exec(m_stride, x)];
1117 const_reference
operator() (difference_type_1 x, difference_type_1 y)
const
1120 return m_ptr [detail::CoordinatesToOffest<StrideTag>::exec(m_stride, x, y)];
1125 const_reference
operator() (difference_type_1 x, difference_type_1 y, difference_type_1 z)
const
1128 return m_ptr [m_stride[0]*x + m_stride[1]*y + m_stride[2]*z];
1133 const_reference
operator() (difference_type_1 x, difference_type_1 y,
1134 difference_type_1 z, difference_type_1 u)
const
1137 return m_ptr [m_stride[0]*x + m_stride[1]*y + m_stride[2]*z + m_stride[3]*u];
1142 const_reference
operator() (difference_type_1 x, difference_type_1 y, difference_type_1 z,
1143 difference_type_1 u, difference_type_1 v)
const
1146 return m_ptr [m_stride[0]*x + m_stride[1]*y + m_stride[2]*z + m_stride[3]*u + m_stride[4]*v];
1155 detail::copyScalarMultiArrayData(
traverser_begin(),
shape(), init, MetaInt<actual_dimension-1>());
1166 this->copyImpl(rhs);
1171 template <
class U,
class CN>
1174 this->copyImpl(rhs);
1201 std::swap(this->m_shape, other.
m_shape);
1202 std::swap(this->m_stride, other.
m_stride);
1203 std::swap(this->m_ptr, other.
m_ptr);
1220 template <
class T2,
class C2>
1234 difference_type s = vigra::detail::defaultStride<actual_dimension>(
shape());
1235 for(
unsigned int k = 0; k <= dimension; ++k)
1255 template <
int M,
class Index>
1272 template <
int M,
class Index>
1292 template <
unsigned int M>
1293 MultiArrayView <N-1, T,
typename vigra::detail::MaybeStrided<StrideTag, M>::type >
1294 bind (difference_type_1 d)
const;
1343 bindAt (difference_type_1 m, difference_type_1 d)
const;
1363 vigra_precondition(0 <= i && i < ExpandElementResult<T>::size,
1364 "MultiArrayView::bindElementChannel(i): 'i' out of range.");
1476 detail::RelativeToAbsoluteCoordinate<actual_dimension-1>::exec(
shape(), p);
1477 detail::RelativeToAbsoluteCoordinate<actual_dimension-1>::exec(
shape(), q);
1478 const difference_type_1 offset =
dot (m_stride, p);
1491 difference_type shape =
m_shape;
1492 for (
unsigned int i = 0; i < actual_dimension; ++i)
1493 shape[i] = (shape[i] + s[i] - 1) / s[i];
1515 difference_type
shape(m_shape.begin(), ReverseCopy),
1516 stride(m_stride.begin(), ReverseCopy);
1541 return permuteDimensions(permutation);
1545 permuteDimensions (
const difference_type &s)
const;
1578 difference_type_1 ret = m_shape[0];
1579 for(
int i = 1; i < actual_dimension; ++i)
1601 difference_type_1
size (difference_type_1 n)
const
1609 difference_type_1
shape (difference_type_1 n)
const
1639 return m_stride [n];
1644 template <
class U,
class C1>
1655 template <
class U,
class C1>
1665 for(
int d=0; d<actual_dimension; ++d)
1666 if(p[d] < 0 || p[d] >=
shape(d))
1674 for(
int d=0; d<actual_dimension; ++d)
1675 if(p[d] < 0 || p[d] >=
shape(d))
1688 detail::AllTrueReduceFunctor(),
1689 MetaInt<actual_dimension-1>());
1701 detail::AnyTrueReduceFunctor(),
1702 MetaInt<actual_dimension-1>());
1712 std::pair<T, T> res(NumericTraits<T>::max(), NumericTraits<T>::min());
1715 detail::MinmaxReduceFunctor(),
1716 MetaInt<actual_dimension-1>());
1717 *minimum = res.first;
1718 *maximum = res.second;
1728 typedef typename NumericTraits<U>::RealPromote R;
1730 triple<double, R, R> res(0.0, zero, zero);
1733 detail::MeanVarianceReduceFunctor(),
1734 MetaInt<actual_dimension-1>());
1736 *variance = res.third / res.first;
1751 U res = NumericTraits<U>::zero();
1754 detail::SumReduceFunctor(),
1755 MetaInt<actual_dimension-1>());
1784 template <
class U,
class S>
1788 destMultiArrayRange(sums),
1804 U res = NumericTraits<U>::one();
1807 detail::ProdReduceFunctor(),
1808 MetaInt<actual_dimension-1>());
1814 typename NormTraits<MultiArrayView>::SquaredNormType
1817 typedef typename NormTraits<MultiArrayView>::SquaredNormType SquaredNormType;
1818 SquaredNormType res = NumericTraits<SquaredNormType>::zero();
1821 detail::SquaredL2NormReduceFunctor(),
1822 MetaInt<actual_dimension-1>());
1839 typename NormTraits<MultiArrayView>::NormType
1840 norm(
int type = 2,
bool useSquaredNorm =
true)
const;
1849 pointer & unsafePtr()
1885 return begin().getEndIterator();
1893 return begin().getEndIterator();
1901 traverser ret (m_ptr, m_stride.begin (), m_shape.begin ());
1910 const_traverser ret (m_ptr, m_stride.begin (), m_shape.begin ());
1920 traverser ret (m_ptr, m_stride.begin (), m_shape.begin ());
1921 ret += m_shape [actual_dimension-1];
1931 const_traverser ret (m_ptr, m_stride.begin (), m_shape.begin ());
1932 ret += m_shape [actual_dimension-1];
1936 view_type view ()
const
1942 template <
unsigned int N,
class T,
class Str
ideTag>
1953 template <
unsigned int N,
class T,
class Str
ide1>
1954 template <
class Str
ide2>
1956 MultiArrayView <N, T, Stride1>::assignImpl(MultiArrayView<N, T, Stride2>
const & rhs)
1960 vigra_precondition(rhs.checkInnerStride(Stride1()),
1961 "MultiArrayView<..., UnstridedArrayTag>::operator=(MultiArrayView const &): cannot create unstrided view from strided array.");
1969 vigra_precondition(this->
shape() == rhs.shape(),
1970 "MultiArrayView::operator=(MultiArrayView const &): shape mismatch.");
1971 this->copyImpl(rhs);
1975 template <
unsigned int N,
class T,
class Str
ideTag>
1978 MultiArrayView <N, T, StrideTag>::arraysOverlap(
const MultiArrayView <N, T, CN>& rhs)
const
1980 vigra_precondition (shape () == rhs.shape (),
1981 "MultiArrayView::arraysOverlap(): shape mismatch.");
1984 typename MultiArrayView <N, T, CN>::const_pointer
1985 rhs_first_element = rhs.data(),
1986 rhs_last_element = rhs_first_element +
dot(rhs.shape() -
difference_type(1), rhs.stride());
1987 return !(last_element < rhs_first_element || rhs_last_element < first_element);
1990 template <
unsigned int N,
class T,
class Str
ideTag>
1991 template <
class U,
class CN>
1993 MultiArrayView <N, T, StrideTag>::copyImpl(
const MultiArrayView <N, U, CN>& rhs)
1995 if(!arraysOverlap(rhs))
1998 detail::copyMultiArrayData(rhs.traverser_begin(),
shape(),
traverser_begin(), MetaInt<actual_dimension-1>());
2004 MultiArray<N, T> tmp(rhs);
2005 detail::copyMultiArrayData(tmp.traverser_begin(),
shape(),
traverser_begin(), MetaInt<actual_dimension-1>());
2009 #define VIGRA_MULTI_ARRAY_COMPUTED_ASSIGNMENT(name, op) \
2010 template <unsigned int N, class T, class StrideTag> \
2011 template<class U, class C1> \
2012 MultiArrayView<N, T, StrideTag> & \
2013 MultiArrayView <N, T, StrideTag>::operator op(MultiArrayView<N, U, C1> const & rhs) \
2015 vigra_precondition(this->shape() == rhs.shape(), "MultiArrayView::operator" #op "() size mismatch."); \
2016 if(!arraysOverlap(rhs)) \
2018 detail::name##MultiArrayData(rhs.traverser_begin(), shape(), traverser_begin(), MetaInt<actual_dimension-1>()); \
2022 MultiArray<N, T> tmp(rhs); \
2023 detail::name##MultiArrayData(tmp.traverser_begin(), shape(), traverser_begin(), MetaInt<actual_dimension-1>()); \
2028 VIGRA_MULTI_ARRAY_COMPUTED_ASSIGNMENT(copyAdd, +=)
2029 VIGRA_MULTI_ARRAY_COMPUTED_ASSIGNMENT(copySub, -=)
2030 VIGRA_MULTI_ARRAY_COMPUTED_ASSIGNMENT(copyMul, *=)
2031 VIGRA_MULTI_ARRAY_COMPUTED_ASSIGNMENT(copyDiv, /=)
2033 #undef VIGRA_MULTI_ARRAY_COMPUTED_ASSIGNMENT
2035 template <
unsigned int N,
class T,
class Str
ideTag>
2036 template <
class U,
class CN>
2038 MultiArrayView <N, T, StrideTag>::swapDataImpl(MultiArrayView <N, U, CN> rhs)
2040 vigra_precondition (shape () == rhs.shape (),
2041 "MultiArrayView::swapData(): shape mismatch.");
2046 typename MultiArrayView <N, U, CN>::const_pointer
2047 rhs_first_element = rhs.data(),
2048 rhs_last_element = rhs_first_element +
dot(rhs.shape() -
difference_type(1), rhs.stride());
2049 if(last_element < rhs_first_element || rhs_last_element < first_element)
2052 detail::swapDataImpl(
traverser_begin(),
shape(), rhs.traverser_begin(), MetaInt<actual_dimension-1>());
2058 MultiArray<N, T> tmp(*
this);
2064 template <
unsigned int N,
class T,
class Str
ideTag>
2065 MultiArrayView <N, T, StridedArrayTag>
2066 MultiArrayView <N, T, StrideTag>::permuteDimensions (
const difference_type &s)
const
2069 for (
unsigned int i = 0; i < actual_dimension; ++i)
2071 shape[i] = m_shape[s[i]];
2076 "MultiArrayView::transpose(): every dimension must occur exactly once.");
2080 template <
unsigned int N,
class T,
class Str
ideTag>
2081 typename MultiArrayView <N, T, StrideTag>::difference_type
2085 for(
int k=0; k<(int)N; ++k)
2087 for(
int k=0; k<(int)N-1; ++k)
2090 for(
int j=k+1; j<(int)N; ++j)
2092 if(stride[j] < stride[smallest])
2097 std::swap(stride[k], stride[smallest]);
2098 std::swap(permutation[k], permutation[smallest]);
2102 for(
unsigned int k=0; k<N; ++k)
2103 ordering[permutation[k]] = k;
2107 template <
unsigned int N,
class T,
class Str
ideTag>
2113 permutation[ordering[k]] = k;
2114 return permuteDimensions(permutation);
2117 template <
unsigned int N,
class T,
class Str
ideTag>
2123 permutation[N-1-ordering[k]] = k;
2124 return permuteDimensions(permutation);
2127 template <
unsigned int N,
class T,
class Str
ideTag>
2128 template <
int M,
class Index>
2135 static const int NNew = (N-M == 0) ? 1 : N-M;
2139 inner_shape [0] = 1;
2140 inner_stride [0] = 1;
2144 inner_shape.
init (m_shape.begin (), m_shape.end () - M);
2147 return MultiArrayView <N-M, T, StrideTag> (inner_shape, inner_stride, ptr);
2150 template <
unsigned int N,
class T,
class Str
ideTag>
2151 template <
int M,
class Index>
2158 static const int NNew = (N-M == 0) ? 1 : N-M;
2162 outer_shape [0] = 1;
2163 outer_stride [0] = 1;
2167 outer_shape.
init (m_shape.begin () + M, m_shape.end ());
2171 (outer_shape, outer_stride, ptr);
2174 template <
unsigned int N,
class T,
class Str
ideTag>
2175 template <
unsigned int M>
2176 MultiArrayView <N-1, T,
typename detail::MaybeStrided<StrideTag, M>::type >
2179 static const int NNew = (N-1 == 0) ? 1 : N-1;
2189 std::copy (m_shape.begin (), m_shape.begin () + M, shape.
begin ());
2190 std::copy (m_shape.begin () + M+1, m_shape.end (),
2191 shape.
begin () + M);
2194 stride.
begin () + M);
2196 return MultiArrayView <N-1, T,
typename detail::MaybeStrided<StrideTag, M>::type>
2200 template <
unsigned int N,
class T,
class Str
ideTag>
2204 static const int NNew = (N-1 == 0) ? 1 : N-1;
2208 inner_shape [0] = 1;
2209 inner_stride [0] = 1;
2213 inner_shape.
init (m_shape.begin (), m_shape.end () - 1);
2216 return MultiArrayView <N-1, T, StrideTag> (inner_shape, inner_stride,
2220 template <
unsigned int N,
class T,
class Str
ideTag>
2224 static const int NNew = (N-1 == 0) ? 1 : N-1;
2228 outer_shape [0] = 1;
2229 outer_stride [0] = 1;
2233 outer_shape.
init (m_shape.begin () + 1, m_shape.end ());
2240 template <
unsigned int N,
class T,
class Str
ideTag>
2244 vigra_precondition (
2245 n < static_cast <int> (N),
2246 "MultiArrayView <N, T, StrideTag>::bindAt(): dimension out of range.");
2247 static const int NNew = (N-1 == 0) ? 1 : N-1;
2257 std::copy (m_shape.begin (), m_shape.begin () + n, shape.
begin ());
2258 std::copy (m_shape.begin () + n+1, m_shape.end (),
2259 shape.
begin () + n);
2262 stride.
begin () + n);
2269 template <
unsigned int N,
class T,
class Str
ideTag>
2273 vigra_precondition(0 <= d && d <= static_cast <difference_type_1> (N),
2274 "MultiArrayView<N, ...>::expandElements(d): 0 <= 'd' <= N required.");
2276 int elementSize = ExpandElementResult<T>::size;
2278 for(
int k=0; k<d; ++k)
2280 newShape[k] = m_shape[k];
2281 newStrides[k] =
m_stride[k]*elementSize;
2284 newShape[d] = elementSize;
2287 for(
unsigned k=d; k<N; ++k)
2289 newShape[k+1] = m_shape[k];
2290 newStrides[k+1] =
m_stride[k]*elementSize;
2293 typedef typename ExpandElementResult<T>::type U;
2295 newShape, newStrides,
reinterpret_cast<U*
>(
m_ptr));
2298 template <
unsigned int N,
class T,
class Str
ideTag>
2302 vigra_precondition (
2303 0 <= i && i <= static_cast <difference_type_1> (N),
2304 "MultiArrayView <N, T, StrideTag>::insertSingletonDimension(): index out of range.");
2306 std::copy (m_shape.begin (), m_shape.begin () + i, shape.
begin ());
2307 std::copy (m_shape.begin () + i, m_shape.end (), shape.
begin () + i + 1);
2316 template <
unsigned int N,
class T,
class Str
ideTag>
2317 typename NormTraits<MultiArrayView <N, T, StrideTag> >::NormType
2320 typedef typename NormTraits<MultiArrayView>::NormType NormType;
2326 NormType res = NumericTraits<NormType>::zero();
2329 detail::MaxNormReduceFunctor(),
2330 MetaInt<actual_dimension-1>());
2335 NormType res = NumericTraits<NormType>::zero();
2338 detail::L1NormReduceFunctor(),
2339 MetaInt<actual_dimension-1>());
2350 NormType normMax = NumericTraits<NormType>::zero();
2353 detail::MaxNormReduceFunctor(),
2354 MetaInt<actual_dimension-1>());
2355 if(normMax == NumericTraits<NormType>::zero())
2357 NormType res = NumericTraits<NormType>::zero();
2360 detail::WeightedL2NormReduceFunctor<NormType>(1.0/normMax),
2361 MetaInt<actual_dimension-1>());
2362 return sqrt(res)*normMax;
2366 vigra_precondition(
false,
"MultiArrayView::norm(): Unknown norm type.");
2367 return NumericTraits<NormType>::zero();
2378 template <
unsigned int N,
class T,
class Str
ideTag>
2379 inline typename NormTraits<MultiArrayView <N, T, StrideTag> >::SquaredNormType
2385 template <
unsigned int N,
class T,
class Str
ideTag>
2386 inline typename NormTraits<MultiArrayView <N, T, StrideTag> >::NormType
2387 norm(MultiArrayView <N, T, StrideTag>
const & a)
2419 template <
unsigned int N,
class T,
class A >
2421 :
public MultiArrayView <N, typename vigra::detail::ResolveMultiband<T>::type,
2422 typename vigra::detail::ResolveMultiband<T>::Stride>
2432 using view_type::actual_dimension;
2502 typedef typename difference_type::value_type diff_zero_t;
2522 template <
class U,
class Str
ideTag>
2529 template <
class U,
class Str
ideTag>
2552 allocator_type
const & alloc = allocator_type());
2560 allocator_type
const & alloc = allocator_type());
2565 allocator_type
const & alloc = allocator_type());
2570 allocator_type
const & alloc = allocator_type());
2576 allocator_type
const & alloc = allocator_type());
2581 allocator_type
const & alloc = allocator_type());
2587 m_alloc (rhs.m_alloc)
2594 template<
class Expression>
2595 MultiArray (multi_math::MultiMathOperand<Expression>
const & rhs,
2601 multi_math::math_detail::assignOrResize(*
this, rhs);
2606 template <
class U,
class Str
ideTag>
2608 allocator_type
const & alloc = allocator_type());
2618 this->copyOrReshape(rhs);
2627 template <
class U,
class Str
ideTag>
2630 this->copyOrReshape(rhs);
2639 return this->
init(v);
2648 template <
class U,
class Str
ideTag>
2664 template <
class U,
class Str
ideTag>
2668 this->reshape(rhs.shape());
2679 template <
class U,
class Str
ideTag>
2685 this->reshape(rhs.shape());
2695 template <
class U,
class Str
ideTag>
2701 this->reshape(rhs.shape());
2739 template<
class Expression>
2742 multi_math::math_detail::assignOrResize(*
this, rhs);
2749 template<
class Expression>
2752 multi_math::math_detail::plusAssignOrResize(*
this, rhs);
2759 template<
class Expression>
2762 multi_math::math_detail::minusAssignOrResize(*
this, rhs);
2769 template<
class Expression>
2772 multi_math::math_detail::multiplyAssignOrResize(*
this, rhs);
2779 template<
class Expression>
2782 multi_math::math_detail::divideAssignOrResize(*
this, rhs);
2863 return vigra::detail::ResolveMultiband<T>::defaultStride(shape);
2867 template <
unsigned int N,
class T,
class A>
2878 template <
unsigned int N,
class T,
class A>
2889 template <
unsigned int N,
class T,
class A>
2893 defaultStride(shape),
2899 this->m_shape [0] = 1;
2905 template <
unsigned int N,
class T,
class A>
2909 defaultStride(shape),
2915 this->m_shape [0] = 1;
2921 template <
unsigned int N,
class T,
class A>
2925 defaultStride(shape),
2931 this->m_shape [0] = 1;
2941 vigra_precondition(
false,
2942 "MultiArray(): invalid MultiArrayInitializationTag.");
2946 template <
unsigned int N,
class T,
class A>
2950 defaultStride(shape),
2956 this->m_shape [0] = 1;
2962 template <
unsigned int N,
class T,
class A>
2963 template <
class U,
class Str
ideTag>
2967 defaultStride(rhs.shape()),
2971 allocate (this->
m_ptr, rhs);
2974 template <
unsigned int N,
class T,
class A>
2975 template <
class U,
class Str
ideTag>
2979 if (this->
shape() == rhs.shape())
2988 template <
unsigned int N,
class T,
class A>
2996 else if(new_shape == this->
shape())
2998 this->
init(initial);
3005 allocate (new_ptr, new_size, initial);
3007 this->
m_ptr = new_ptr;
3008 this->m_shape = new_shape;
3014 template <
unsigned int N,
class T,
class A>
3021 std::swap(this->m_alloc, other.m_alloc);
3024 template <
unsigned int N,
class T,
class A>
3033 ptr = m_alloc.
allocate ((
typename A::size_type)s);
3037 m_alloc.construct (ptr + i, init);
3041 m_alloc.destroy (ptr + j);
3042 m_alloc.deallocate (ptr, (
typename A::size_type)s);
3047 template <
unsigned int N,
class T,
class A>
3057 ptr = m_alloc.
allocate ((
typename A::size_type)s);
3060 for (; i < s; ++i, ++
init)
3061 m_alloc.construct (ptr + i, *init);
3065 m_alloc.destroy (ptr + j);
3066 m_alloc.deallocate (ptr, (
typename A::size_type)s);
3071 template <
unsigned int N,
class T,
class A>
3072 template <
class U,
class Str
ideTag>
3081 ptr = m_alloc.
allocate ((
typename A::size_type)s);
3084 detail::uninitializedCopyMultiArrayData(init.traverser_begin(), init.shape(),
3085 p, m_alloc, MetaInt<actual_dimension-1>());
3088 for (
pointer pp = ptr; pp < p; ++pp)
3089 m_alloc.destroy (pp);
3090 m_alloc.deallocate (ptr, (
typename A::size_type)s);
3095 template <
unsigned int N,
class T,
class A>
3101 m_alloc.destroy (ptr + i);
3102 m_alloc.
deallocate (ptr, (
typename A::size_type)s);
3112 template <
unsigned int N,
class T,
class Str
ideTag>
3113 inline triple<typename MultiArrayView<N,T,StrideTag>::const_traverser,
3118 return triple<typename MultiArrayView<N,T,StrideTag>::const_traverser,
3121 ( array.traverser_begin(),
3126 template <
unsigned int N,
class T,
class Str
ideTag,
class Accessor>
3127 inline triple<typename MultiArrayView<N,T,StrideTag>::const_traverser,
3128 typename MultiArrayView<N,T,StrideTag>::difference_type,
3130 srcMultiArrayRange( MultiArrayView<N,T,StrideTag>
const & array, Accessor a )
3132 return triple<typename MultiArrayView<N,T,StrideTag>::const_traverser,
3133 typename MultiArrayView<N,T,StrideTag>::difference_type,
3135 ( array.traverser_begin(),
3140 template <
unsigned int N,
class T,
class Str
ideTag>
3141 inline pair<typename MultiArrayView<N,T,StrideTag>::const_traverser,
3142 typename AccessorTraits<T>::default_const_accessor >
3143 srcMultiArray( MultiArrayView<N,T,StrideTag>
const & array )
3145 return pair<typename MultiArrayView<N,T,StrideTag>::const_traverser,
3146 typename AccessorTraits<T>::default_const_accessor >
3147 ( array.traverser_begin(),
3148 typename AccessorTraits<T>::default_const_accessor() );
3151 template <
unsigned int N,
class T,
class Str
ideTag,
class Accessor>
3152 inline pair<typename MultiArrayView<N,T,StrideTag>::const_traverser,
3154 srcMultiArray( MultiArrayView<N,T,StrideTag>
const & array, Accessor a )
3156 return pair<typename MultiArrayView<N,T,StrideTag>::const_traverser,
3158 ( array.traverser_begin(), a );
3161 template <
unsigned int N,
class T,
class Str
ideTag>
3162 inline triple<typename MultiArrayView<N,T,StrideTag>::traverser,
3163 typename MultiArrayView<N,T,StrideTag>::difference_type,
3164 typename AccessorTraits<T>::default_accessor >
3165 destMultiArrayRange( MultiArrayView<N,T,StrideTag> & array )
3167 return triple<typename MultiArrayView<N,T,StrideTag>::traverser,
3168 typename MultiArrayView<N,T,StrideTag>::difference_type,
3169 typename AccessorTraits<T>::default_accessor >
3170 ( array.traverser_begin(),
3172 typename AccessorTraits<T>::default_accessor() );
3175 template <
unsigned int N,
class T,
class Str
ideTag,
class Accessor>
3176 inline triple<typename MultiArrayView<N,T,StrideTag>::traverser,
3177 typename MultiArrayView<N,T,StrideTag>::difference_type,
3179 destMultiArrayRange( MultiArrayView<N,T,StrideTag> & array, Accessor a )
3181 return triple<typename MultiArrayView<N,T,StrideTag>::traverser,
3182 typename MultiArrayView<N,T,StrideTag>::difference_type,
3184 ( array.traverser_begin(),
3189 template <
unsigned int N,
class T,
class Str
ideTag>
3190 inline pair<typename MultiArrayView<N,T,StrideTag>::traverser,
3191 typename AccessorTraits<T>::default_accessor >
3192 destMultiArray( MultiArrayView<N,T,StrideTag> & array )
3194 return pair<typename MultiArrayView<N,T,StrideTag>::traverser,
3195 typename AccessorTraits<T>::default_accessor >
3196 ( array.traverser_begin(),
3197 typename AccessorTraits<T>::default_accessor() );
3200 template <
unsigned int N,
class T,
class Str
ideTag,
class Accessor>
3201 inline pair<typename MultiArrayView<N,T,StrideTag>::traverser,
3203 destMultiArray( MultiArrayView<N,T,StrideTag> & array, Accessor a )
3205 return pair<typename MultiArrayView<N,T,StrideTag>::traverser,
3207 ( array.traverser_begin(), a );
3212 template <
class PixelType,
class Accessor>
3213 inline triple<ConstStridedImageIterator<PixelType>,
3214 ConstStridedImageIterator<PixelType>, Accessor>
3215 srcImageRange(
const MultiArrayView<2, PixelType, StridedArrayTag> & img, Accessor a)
3217 ConstStridedImageIterator<PixelType>
3218 ul(img.data(), 1, img.stride(0), img.stride(1));
3219 return triple<ConstStridedImageIterator<PixelType>,
3220 ConstStridedImageIterator<PixelType>,
3222 ul, ul + Size2D(img.shape(0), img.shape(1)), a);
3225 template <
class PixelType,
class Accessor>
3226 inline pair<ConstStridedImageIterator<PixelType>, Accessor>
3227 srcImage(
const MultiArrayView<2, PixelType, StridedArrayTag> & img, Accessor a)
3229 ConstStridedImageIterator<PixelType>
3230 ul(img.data(), 1, img.stride(0), img.stride(1));
3231 return pair<ConstStridedImageIterator<PixelType>, Accessor>
3235 template <
class PixelType,
class Accessor>
3236 inline triple<StridedImageIterator<PixelType>,
3237 StridedImageIterator<PixelType>, Accessor>
3238 destImageRange(MultiArrayView<2, PixelType, StridedArrayTag> & img, Accessor a)
3240 StridedImageIterator<PixelType>
3241 ul(img.data(), 1, img.stride(0), img.stride(1));
3242 return triple<StridedImageIterator<PixelType>,
3243 StridedImageIterator<PixelType>,
3245 ul, ul + Size2D(img.shape(0), img.shape(1)), a);
3248 template <
class PixelType,
class Accessor>
3249 inline pair<StridedImageIterator<PixelType>, Accessor>
3250 destImage(MultiArrayView<2, PixelType, StridedArrayTag> & img, Accessor a)
3252 StridedImageIterator<PixelType>
3253 ul(img.data(), 1, img.stride(0), img.stride(1));
3254 return pair<StridedImageIterator<PixelType>, Accessor>
3258 template <
class PixelType,
class Accessor>
3259 inline pair<StridedImageIterator<PixelType>, Accessor>
3260 maskImage(MultiArrayView<2, PixelType, StridedArrayTag> & img, Accessor a)
3262 StridedImageIterator<PixelType>
3263 ul(img.data(), 1, img.stride(0), img.stride(1));
3264 return pair<StridedImageIterator<PixelType>, Accessor>
3270 template <
class PixelType>
3271 inline triple<ConstStridedImageIterator<PixelType>,
3272 ConstStridedImageIterator<PixelType>,
3273 typename AccessorTraits<PixelType>::default_const_accessor>
3274 srcImageRange(MultiArrayView<2, PixelType, StridedArrayTag>
const & img)
3276 ConstStridedImageIterator<PixelType>
3277 ul(img.data(), 1, img.stride(0), img.stride(1));
3278 typedef typename AccessorTraits<PixelType>::default_const_accessor Accessor;
3279 return triple<ConstStridedImageIterator<PixelType>,
3280 ConstStridedImageIterator<PixelType>,
3282 (ul, ul + Size2D(img.shape(0), img.shape(1)), Accessor());
3285 template <
class PixelType>
3286 inline triple<ConstImageIterator<PixelType>,
3287 ConstImageIterator<PixelType>,
3288 typename AccessorTraits<PixelType>::default_const_accessor>
3289 srcImageRange(MultiArrayView<2, PixelType, UnstridedArrayTag>
const & img)
3291 ConstImageIterator<PixelType>
3292 ul(img.data(), img.stride(1));
3293 typedef typename AccessorTraits<PixelType>::default_const_accessor Accessor;
3294 return triple<ConstImageIterator<PixelType>,
3295 ConstImageIterator<PixelType>,
3297 (ul, ul + Size2D(img.shape(0), img.shape(1)), Accessor());
3300 template <
class PixelType>
3301 inline pair< ConstStridedImageIterator<PixelType>,
3302 typename AccessorTraits<PixelType>::default_const_accessor>
3303 srcImage(MultiArrayView<2, PixelType, StridedArrayTag>
const & img)
3305 ConstStridedImageIterator<PixelType>
3306 ul(img.data(), 1, img.stride(0), img.stride(1));
3307 typedef typename AccessorTraits<PixelType>::default_const_accessor Accessor;
3308 return pair<ConstStridedImageIterator<PixelType>,
3313 template <
class PixelType>
3314 inline pair< ConstImageIterator<PixelType>,
3315 typename AccessorTraits<PixelType>::default_const_accessor>
3316 srcImage(MultiArrayView<2, PixelType, UnstridedArrayTag>
const & img)
3318 ConstImageIterator<PixelType>
3319 ul(img.data(), img.stride(1));
3320 typedef typename AccessorTraits<PixelType>::default_const_accessor Accessor;
3321 return pair<ConstImageIterator<PixelType>,
3326 template <
class PixelType>
3327 inline triple< StridedImageIterator<PixelType>,
3328 StridedImageIterator<PixelType>,
3329 typename AccessorTraits<PixelType>::default_accessor>
3330 destImageRange(MultiArrayView<2, PixelType, StridedArrayTag> & img)
3332 StridedImageIterator<PixelType>
3333 ul(img.data(), 1, img.stride(0), img.stride(1));
3334 typedef typename AccessorTraits<PixelType>::default_accessor Accessor;
3335 return triple<StridedImageIterator<PixelType>,
3336 StridedImageIterator<PixelType>,
3338 (ul, ul + Size2D(img.shape(0), img.shape(1)), Accessor());
3341 template <
class PixelType>
3342 inline triple< ImageIterator<PixelType>,
3343 ImageIterator<PixelType>,
3344 typename AccessorTraits<PixelType>::default_accessor>
3345 destImageRange(MultiArrayView<2, PixelType, UnstridedArrayTag> & img)
3347 ImageIterator<PixelType>
3348 ul(img.data(), img.stride(1));
3349 typedef typename AccessorTraits<PixelType>::default_accessor Accessor;
3350 return triple<ImageIterator<PixelType>,
3351 ImageIterator<PixelType>,
3353 (ul, ul + Size2D(img.shape(0), img.shape(1)), Accessor());
3356 template <
class PixelType>
3357 inline pair< StridedImageIterator<PixelType>,
3358 typename AccessorTraits<PixelType>::default_accessor>
3359 destImage(MultiArrayView<2, PixelType, StridedArrayTag> & img)
3361 StridedImageIterator<PixelType>
3362 ul(img.data(), 1, img.stride(0), img.stride(1));
3363 typedef typename AccessorTraits<PixelType>::default_accessor Accessor;
3364 return pair<StridedImageIterator<PixelType>, Accessor>
3368 template <
class PixelType>
3369 inline pair< ImageIterator<PixelType>,
3370 typename AccessorTraits<PixelType>::default_accessor>
3371 destImage(MultiArrayView<2, PixelType, UnstridedArrayTag> & img)
3373 ImageIterator<PixelType> ul(img.data(), img.stride(1));
3374 typedef typename AccessorTraits<PixelType>::default_accessor Accessor;
3375 return pair<ImageIterator<PixelType>, Accessor>(ul, Accessor());
3378 template <
class PixelType>
3379 inline pair< ConstStridedImageIterator<PixelType>,
3380 typename AccessorTraits<PixelType>::default_accessor>
3381 maskImage(MultiArrayView<2, PixelType, StridedArrayTag>
const & img)
3383 ConstStridedImageIterator<PixelType>
3384 ul(img.data(), 1, img.stride(0), img.stride(1));
3385 typedef typename AccessorTraits<PixelType>::default_accessor Accessor;
3386 return pair<ConstStridedImageIterator<PixelType>, Accessor>
3390 template <
class PixelType>
3391 inline pair< ConstImageIterator<PixelType>,
3392 typename AccessorTraits<PixelType>::default_accessor>
3393 maskImage(MultiArrayView<2, PixelType, UnstridedArrayTag>
const & img)
3395 ConstImageIterator<PixelType>
3396 ul(img.data(), img.stride(1));
3397 typedef typename AccessorTraits<PixelType>::default_accessor Accessor;
3398 return pair<ConstImageIterator<PixelType>, Accessor>
3420 template <
class T,
class Str
ide>
3425 "makeBasicImageView(array): array must be unstrided along x (i.e. array.isUnstrided(0) == true).");
3442 vigra_precondition(array.stride(1) == array.shape(0),
3443 "makeBasicImageView(): cannot join strided dimensions");
3445 array.shape (0)*array.shape (1), array.shape (2), array.stride(2));
3456 template <
class T,
class Str
ide>
3457 BasicImageView <RGBValue<T> >
3460 vigra_precondition(array.shape (0) == 3,
3461 "makeRGBImageView(): array.shape(0) must be 3.");
3462 vigra_precondition(array.isUnstrided(),
3463 "makeRGBImageView(array): array must be unstrided (i.e. array.isUnstrided() == true).");
3466 array.shape (1), array.shape (2));
3473 #undef VIGRA_ASSERT_INSIDE
3475 #endif // VIGRA_MULTI_ARRAY_HXX
MultiArray & operator/=(multi_math::MultiMathOperand< Expression > const &rhs)
Definition: multi_array.hxx:2780
MultiArrayView< N, typename vigra::detail::ResolveMultiband< T >::type, typename vigra::detail::ResolveMultiband< T >::Stride > view_type
Definition: multi_array.hxx:2430
const value_type & const_reference
Definition: multi_array.hxx:673
MultiArrayView(const difference_type &shape, const difference_type &stride, const_pointer ptr)
Definition: multi_array.hxx:806
MultiArray & operator=(multi_math::MultiMathOperand< Expression > const &rhs)
Definition: multi_array.hxx:2740
void sum(MultiArrayView< N, U, S > sums) const
Definition: multi_array.hxx:1785
MultiArrayView & operator=(multi_math::MultiMathOperand< Expression > const &rhs)
Definition: multi_array.hxx:947
iterator end()
Definition: multi_array.hxx:1883
Sequential iterator for MultiArrayView.
Definition: multi_fwd.hxx:161
MultiArrayView & operator*=(MultiArrayView< N, U, C1 > const &rhs)
MultiArrayView & operator+=(T const &rhs)
Definition: multi_array.hxx:913
MultiArray< N, T > matrix_type
Definition: multi_array.hxx:723
MultiArray< N, T, A > matrix_type
Definition: multi_array.hxx:2440
PromoteTraits< V1, V2 >::Promote dot(RGBValue< V1, RIDX1, GIDX1, BIDX1 > const &r1, RGBValue< V2, RIDX2, GIDX2, BIDX2 > const &r2)
dot product
Definition: rgbvalue.hxx:906
view_type::pointer pointer
Definition: multi_array.hxx:2448
MultiArrayShape< actual_dimension >::type difference_type
Definition: multi_array.hxx:685
MultiArrayView & operator=(value_type const &v)
Definition: multi_array.hxx:882
MultiArray & operator+=(multi_math::MultiMathOperand< Expression > const &rhs)
Definition: multi_array.hxx:2750
MultiArray()
Definition: multi_array.hxx:2534
const difference_type & shape() const
Definition: multi_array.hxx:1594
ActualDimension
Definition: multi_array.hxx:661
MultiArrayView< N, T, StrideTag > view_type
Definition: multi_array.hxx:719
void linearSequence(Iterator first, Iterator last, Value start, Value step)
Fill an array with a sequence of numbers.
Definition: algorithm.hxx:208
MultiArrayInitializationTag
Initialize a MultiArray in a standard way.
Definition: multi_fwd.hxx:104
difference_type m_shape
Definition: multi_array.hxx:741
MultiArray(allocator_type const &alloc)
Definition: multi_array.hxx:2541
difference_type_1 width() const
Definition: multi_array.hxx:1616
MultiArray & operator=(value_type const &v)
Definition: multi_array.hxx:2637
A allocator_type
Definition: multi_array.hxx:2436
U product() const
Definition: multi_array.hxx:1802
view_type::iterator iterator
Definition: multi_array.hxx:2494
reference operator[](difference_type_1 d)
Definition: multi_array.hxx:1027
MultiArrayView & operator-=(T const &rhs)
Definition: multi_array.hxx:921
difference_type size_type
Definition: multi_array.hxx:693
MultiArrayView & operator*=(multi_math::MultiMathOperand< Expression > const &rhs)
Definition: multi_array.hxx:977
pointer data() const
Definition: multi_array.hxx:1844
void deallocate(pointer &ptr, difference_type_1 s)
Definition: multi_array.hxx:3096
difference_type_1 elementCount() const
Definition: multi_array.hxx:1576
FFTWComplex< R >::SquaredNormType squaredNorm(const FFTWComplex< R > &a)
squared norm (= squared magnitude)
Definition: fftw3.hxx:1044
MultiArrayView & operator-=(MultiArrayView< N, U, C1 > const &rhs)
iterator begin()
Definition: multi_array.hxx:1867
MultiArrayView & operator/=(T const &rhs)
Definition: multi_array.hxx:937
void reshape(const difference_type &shape)
Definition: multi_array.hxx:2807
view_type::traverser traverser
Definition: multi_array.hxx:2476
reference operator()(difference_type_1 x)
Definition: multi_array.hxx:1067
Initialize array by a linear sequence in scan order.
Definition: multi_fwd.hxx:105
void reset()
Definition: multi_array.hxx:836
BasicImageView< RGBValue< T > > makeRGBImageView(MultiArrayView< 3, T, Stride > const &array)
Definition: multi_array.hxx:3458
std::ptrdiff_t MultiArrayIndex
Definition: multi_fwd.hxx:60
Find the sum of the pixel values in an image or ROI.
Definition: inspectimage.hxx:1143
MultiArrayView(const difference_type &shape, const_pointer ptr)
Definition: multi_array.hxx:795
const_iterator begin() const
Definition: multi_array.hxx:1875
StridedScanOrderIterator< actual_dimension, T, T &, T * > iterator
Definition: multi_array.hxx:701
vigra::detail::MultiIteratorChooser< StrideTag >::template Traverser< actual_dimension, T, T const &, T const * >::type const_traverser
Definition: multi_array.hxx:715
MultiArrayView & operator/=(multi_math::MultiMathOperand< Expression > const &rhs)
Definition: multi_array.hxx:987
NormTraits< MultiArrayView >::NormType norm(int type=2, bool useSquaredNorm=true) const
Definition: multi_array.hxx:2318
MultiArrayView< N, T, StridedArrayTag > transpose() const
Definition: multi_array.hxx:1513
view_type::difference_type difference_type
Definition: multi_array.hxx:2468
void meanVariance(U *mean, U *variance) const
Definition: multi_array.hxx:1726
MultiArray(multi_math::MultiMathOperand< Expression > const &rhs, allocator_type const &alloc=allocator_type())
Definition: multi_array.hxx:2595
MultiArrayView< N+1, T, StrideTag > insertSingletonDimension(difference_type_1 i) const
Definition: multi_array.hxx:2300
view_type::const_traverser const_traverser
Definition: multi_array.hxx:2480
MultiArrayView< N-M, T, StridedArrayTag > bindInner(const TinyVector< Index, M > &d) const
Definition: multi_array.hxx:2153
FFTWComplex< R >::NormType norm(const FFTWComplex< R > &a)
norm (= magnitude)
Definition: fftw3.hxx:1037
vigra::detail::MultiIteratorChooser< StrideTag >::template Traverser< actual_dimension, T, T &, T * >::type traverser
Definition: multi_array.hxx:710
difference_type_1 size() const
Definition: multi_array.hxx:1587
void swapData(MultiArrayView< N, T2, C2 > rhs)
Definition: multi_array.hxx:1221
NormTraits< MultiArrayView >::SquaredNormType squaredNorm() const
Definition: multi_array.hxx:1815
Definition: multi_fwd.hxx:63
bool operator==(MultiArrayView< N, U, C1 > const &rhs) const
Definition: multi_array.hxx:1645
view_type::reference reference
Definition: multi_array.hxx:2456
NumericTraits< V >::Promote prod(TinyVectorBase< V, SIZE, D1, D2 > const &l)
product of the vector's elements
Definition: tinyvector.hxx:2097
BasicImageView< T > makeBasicImageView(MultiArrayView< 2, T, Stride > const &array)
Definition: multi_array.hxx:3422
MultiArrayIndex difference_type_1
Definition: multi_array.hxx:697
MultiArrayView< N, Multiband< value_type >, StrideTag > multiband() const
Definition: multi_array.hxx:1429
const difference_type & stride() const
Definition: multi_array.hxx:1630
bool any() const
Definition: multi_array.hxx:1696
bool operator!=(MultiArrayView< N, U, C1 > const &rhs) const
Definition: multi_array.hxx:1656
NumericTraits< V >::Promote sum(TinyVectorBase< V, SIZE, D1, D2 > const &l)
sum of the vector's elements
Definition: tinyvector.hxx:2073
MultiArray & operator*=(multi_math::MultiMathOperand< Expression > const &rhs)
Definition: multi_array.hxx:2770
value_type & reference
Definition: multi_array.hxx:669
MultiArrayView & operator-=(multi_math::MultiMathOperand< Expression > const &rhs)
Definition: multi_array.hxx:967
const_reference operator[](difference_type_1 d) const
Definition: multi_array.hxx:1043
difference_type_1 stride(int n) const
Definition: multi_array.hxx:1637
iterator begin()
Definition: tinyvector.hxx:861
bool isInside(difference_type const &p) const
Definition: multi_array.hxx:1663
difference_type_1 coordinateToScanOrderIndex(const difference_type &d) const
Definition: multi_array.hxx:1060
const_iterator end() const
Definition: multi_array.hxx:1891
MultiArray & init(const U &init)
Definition: multi_array.hxx:2797
MultiArrayView< 1, T, StridedArrayTag > diagonal() const
Definition: multi_array.hxx:1450
MultiArrayView< N-1, T, StridedArrayTag > bindAt(difference_type_1 m, difference_type_1 d) const
Definition: multi_array.hxx:2242
allocator_type m_alloc
Definition: multi_array.hxx:2506
void minmax(T *minimum, T *maximum) const
Definition: multi_array.hxx:1710
MultiArrayView(const MultiArrayView< N, T, Stride > &other)
Definition: multi_array.hxx:784
void copy(const MultiArrayView< N, U, CN > &rhs)
Definition: multi_array.hxx:1172
BasicImage using foreign memory.
Definition: basicimageview.hxx:76
MultiArrayView< N, T, StridedArrayTag > permuteStridesDescending() const
Definition: multi_array.hxx:2119
void copy(const MultiArrayView &rhs)
Definition: multi_array.hxx:1162
difference_type scanOrderIndexToCoordinate(difference_type_1 d) const
Definition: multi_array.hxx:1051
Definition: metaprogramming.hxx:116
allocator_type const & allocator() const
Definition: multi_array.hxx:2856
MultiArrayView< N, typename ExpandElementResult< T >::type, StridedArrayTag > bindElementChannel(difference_type_1 i) const
Definition: multi_array.hxx:1361
view_type::size_type size_type
Definition: multi_array.hxx:2464
MultiArrayView & operator/=(MultiArrayView< N, U, C1 > const &rhs)
difference_type_1 size(difference_type_1 n) const
Definition: multi_array.hxx:1601
view_type::const_pointer const_pointer
Definition: multi_array.hxx:2452
view_type::value_type value_type
Definition: multi_array.hxx:2444
Definition: metaprogramming.hxx:123
const_traverser traverser_begin() const
Definition: multi_array.hxx:1908
Class for fixed size vectors.This class contains an array of size SIZE of the specified VALUETYPE...
Definition: accessor.hxx:940
T value_type
Definition: multi_array.hxx:665
MultiArrayView< N, T, StridedArrayTag > transpose(const difference_type &permutation) const
Definition: multi_array.hxx:1539
Fundamental class template for images.
Definition: basicimage.hxx:475
bool hasData() const
Definition: multi_array.hxx:1859
pointer m_ptr
Definition: multi_array.hxx:750
~MultiArray()
Definition: multi_array.hxx:2788
difference_type_1 height() const
Definition: multi_array.hxx:1623
view_type::difference_type_1 difference_type_1
Definition: multi_array.hxx:2472
MultiArrayView & operator+=(multi_math::MultiMathOperand< Expression > const &rhs)
Definition: multi_array.hxx:957
MultiArrayView & operator=(MultiArrayView< N, U, C1 > const &rhs)
Definition: multi_array.hxx:872
MultiArray(const MultiArray &rhs)
Definition: multi_array.hxx:2585
Encapsulate read access to the values an iterator points to.
Definition: accessor.hxx:269
MultiArrayView(BasicImage< T, ALLOC > const &image)
Definition: multi_array.hxx:820
bool isUnstrided(unsigned int dimension=N-1) const
Definition: multi_array.hxx:1232
Base class for, and view to, vigra::MultiArray.
Definition: multi_array.hxx:650
void transformMultiArray(...)
Transform a multi-dimensional array with a unary function or functor.
MultiArrayView & init(const U &init)
Definition: multi_array.hxx:1152
MultiArray & operator-=(multi_math::MultiMathOperand< Expression > const &rhs)
Definition: multi_array.hxx:2760
void swap(MultiArrayView &other)
Definition: multi_array.hxx:1197
void swapData(MultiArrayView rhs)
Definition: multi_array.hxx:1210
value_type * pointer
Definition: multi_array.hxx:677
traverser traverser_end()
Definition: multi_array.hxx:1918
MultiArrayView subarray(difference_type p, difference_type q) const
Definition: multi_array.hxx:1474
Class for a single RGB value.
Definition: accessor.hxx:938
bool all() const
Definition: multi_array.hxx:1683
MultiArrayView< N-1, T, typename vigra::detail::MaybeStrided< StrideTag, M >::type > bind(difference_type_1 d) const
StridedScanOrderIterator< actual_dimension, T, T const &, T const * > const_iterator
Definition: multi_array.hxx:705
reference operator[](const difference_type &d)
Definition: multi_array.hxx:995
bool isOutside(difference_type const &p) const
Definition: multi_array.hxx:1672
view_type::const_iterator const_iterator
Definition: multi_array.hxx:2498
MultiArrayView< N+1, typename ExpandElementResult< T >::type, StridedArrayTag > expandElements(difference_type_1 d) const
Definition: multi_array.hxx:2271
MultiArrayView & operator=(MultiArrayView const &rhs)
Definition: multi_array.hxx:853
MultiArrayView & operator*=(T const &rhs)
Definition: multi_array.hxx:929
MultiArrayView< N, T, StridedArrayTag > permuteStridesAscending() const
Definition: multi_array.hxx:2109
difference_type m_stride
Definition: multi_array.hxx:746
void init(Iterator i, Iterator end)
Definition: tinyvector.hxx:708
U sum() const
Definition: multi_array.hxx:1749
const value_type * const_pointer
Definition: multi_array.hxx:681
difference_type_1 shape(difference_type_1 n) const
Definition: multi_array.hxx:1609
traverser traverser_begin()
Definition: multi_array.hxx:1899
SquareRootTraits< FixedPoint< IntBits, FracBits > >::SquareRootResult sqrt(FixedPoint< IntBits, FracBits > v)
square root.
Definition: fixedpoint.hxx:616
MultiArrayView< N, T, StridedArrayTag > stridearray(const difference_type &s) const
Definition: multi_array.hxx:1489
MultiArrayView()
Definition: multi_array.hxx:775
MultiArrayView< N-M, T, StrideTag > bindOuter(const TinyVector< Index, M > &d) const
Definition: multi_array.hxx:2130
difference_type key_type
Definition: multi_array.hxx:689
V const & min(TinyVectorBase< V, SIZE, D1, D2 > const &l)
minimum element
Definition: tinyvector.hxx:2161
view_type::const_reference const_reference
Definition: multi_array.hxx:2460
void allocate(pointer &ptr, difference_type_1 s, const_reference init)
Definition: multi_array.hxx:3025
MultiArrayView & operator+=(MultiArrayView< N, U, C1 > const &rhs)
const_traverser traverser_end() const
Definition: multi_array.hxx:1929
difference_type strideOrdering() const
Definition: multi_array.hxx:1563