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 "basicimageview.hxx"
46 #include "imageiterator.hxx"
47 #include "numerictraits.hxx"
48 #include "multi_iterator.hxx"
49 #include "metaprogramming.hxx"
50 #include "mathutil.hxx"
53 #ifdef VIGRA_CHECK_BOUNDS
54 #define VIGRA_ASSERT_INSIDE(diff) \
55 vigra_precondition(this->isInside(diff), "Index out of bounds")
57 #define VIGRA_ASSERT_INSIDE(diff)
75 template <
unsigned int N>
76 inline TinyVector <MultiArrayIndex, N>
77 defaultStride(
const TinyVector <MultiArrayIndex, N> &shape)
79 TinyVector <MultiArrayIndex, N> ret;
81 for (
int i = 1; i < (int)N; ++i)
82 ret [i] = ret [i-1] * shape [i-1];
99 struct ScanOrderToOffset
104 const TinyVector <MultiArrayIndex, N> & stride)
106 return stride[N-K] * (d % shape[N-K]) +
107 ScanOrderToOffset<K-1>::exec(d / shape[N-K], shape, stride);
112 struct ScanOrderToOffset<1>
117 const TinyVector <MultiArrayIndex, N> & stride)
119 return stride[N-1] * d;
124 struct ScanOrderToCoordinate
129 TinyVector <MultiArrayIndex, N> & result)
131 result[N-K] = (d % shape[N-K]);
132 ScanOrderToCoordinate<K-1>::exec(d / shape[N-K], shape, result);
137 struct ScanOrderToCoordinate<1>
142 TinyVector <MultiArrayIndex, N> & result)
150 struct CoordinatesToOffest
154 exec(
const TinyVector <MultiArrayIndex, N> & stride,
MultiArrayIndex x)
156 return stride[0] * x;
162 return stride[0] * x + stride[1] * y;
167 struct CoordinatesToOffest<UnstridedArrayTag>
179 return x + stride[1] * y;
198 template <
class Str
ideTag,
unsigned int N>
201 typedef StrideTag type;
204 template <
class Str
ideTag>
205 struct MaybeStrided <StrideTag, 0>
207 typedef StridedArrayTag type;
225 struct MultiIteratorChooser
229 template <
unsigned int N,
class T,
class REFERENCE,
class POINTER>
250 struct MultiIteratorChooser <StridedArrayTag>
252 template <
unsigned int N,
class T,
class REFERENCE,
class POINTER>
255 typedef StridedMultiIterator <N, T, REFERENCE, POINTER> type;
273 struct MultiIteratorChooser <UnstridedArrayTag>
275 template <
unsigned int N,
class T,
class REFERENCE,
class POINTER>
278 typedef MultiIterator <N, T, REFERENCE, POINTER> type;
288 template <
class DestIterator,
class Shape,
class T>
290 initMultiArrayData(DestIterator d, Shape
const & shape, T
const & init, MetaInt<0>)
292 DestIterator dend = d + shape[0];
299 template <
class DestIterator,
class Shape,
class T,
int N>
301 initMultiArrayData(DestIterator d, Shape
const & shape, T
const & init, MetaInt<N>)
303 DestIterator dend = d + shape[N];
306 initMultiArrayData(d.begin(), shape, init, MetaInt<N-1>());
311 #define VIGRA_COPY_MULTI_ARRAY_DATA(name, op) \
312 template <class SrcIterator, class Shape, class DestIterator> \
314 name##MultiArrayData(SrcIterator s, Shape const & shape, DestIterator d, MetaInt<0>) \
316 SrcIterator send = s + shape[0]; \
317 for(; s < send; ++s, ++d) \
319 *d op detail::RequiresExplicitCast<typename DestIterator::value_type>::cast(*s); \
323 template <class Ref, class Ptr, class Shape, class DestIterator> \
325 name##MultiArrayData(MultiIterator<1, UInt8, Ref, Ptr> si, Shape const & shape, DestIterator d, MetaInt<0>) \
327 Ptr s = &(*si), send = s + shape[0]; \
328 for(; s < send; ++s, ++d) \
330 *d op detail::RequiresExplicitCast<typename DestIterator::value_type>::cast(*s); \
334 template <class SrcIterator, class Shape, class DestIterator, int N> \
336 name##MultiArrayData(SrcIterator s, Shape const & shape, DestIterator d, MetaInt<N>) \
338 SrcIterator send = s + shape[N]; \
339 for(; s < send; ++s, ++d) \
341 name##MultiArrayData(s.begin(), shape, d.begin(), MetaInt<N-1>()); \
345 template <class DestIterator, class Shape, class T> \
347 name##ScalarMultiArrayData(DestIterator d, Shape const & shape, T const & init, MetaInt<0>) \
349 DestIterator dend = d + shape[0]; \
350 for(; d < dend; ++d) \
352 *d op detail::RequiresExplicitCast<typename DestIterator::value_type>::cast(init); \
356 template <class DestIterator, class Shape, class T, int N> \
358 name##ScalarMultiArrayData(DestIterator d, Shape const & shape, T const & init, MetaInt<N>) \
360 DestIterator dend = d + shape[N]; \
361 for(; d < dend; ++d) \
363 name##ScalarMultiArrayData(d.begin(), shape, init, MetaInt<N-1>()); \
367 VIGRA_COPY_MULTI_ARRAY_DATA(copy, =)
368 VIGRA_COPY_MULTI_ARRAY_DATA(copyAdd, +=)
369 VIGRA_COPY_MULTI_ARRAY_DATA(copySub, -=)
370 VIGRA_COPY_MULTI_ARRAY_DATA(copyMul, *=)
371 VIGRA_COPY_MULTI_ARRAY_DATA(copyDiv, /=)
373 #undef VIGRA_COPY_MULTI_ARRAY_DATA
375 template <
class SrcIterator,
class Shape,
class T,
class ALLOC>
377 uninitializedCopyMultiArrayData(SrcIterator s, Shape
const & shape, T * & d, ALLOC & a, MetaInt<0>)
379 SrcIterator send = s + shape[0];
380 for(; s < send; ++s, ++d)
382 a.construct(d, static_cast<T const &>(*s));
387 template <
class Ref,
class Ptr,
class Shape,
class T,
class ALLOC>
389 uninitializedCopyMultiArrayData(MultiIterator<1, UInt8, Ref, Ptr> si, Shape
const & shape, T * & d, ALLOC & a, MetaInt<0>)
391 Ptr s = &(*si), send = s + shape[0];
392 for(; s < send; ++s, ++d)
394 a.construct(d, static_cast<T const &>(*s));
398 template <
class SrcIterator,
class Shape,
class T,
class ALLOC,
int N>
400 uninitializedCopyMultiArrayData(SrcIterator s, Shape
const & shape, T * & d, ALLOC & a, MetaInt<N>)
402 SrcIterator send = s + shape[N];
405 uninitializedCopyMultiArrayData(s.begin(), shape, d, a, MetaInt<N-1>());
409 template <
class SrcIterator,
class Shape,
class T,
class Functor>
411 reduceOverMultiArray(SrcIterator s, Shape
const & shape, T & result, Functor
const & f, MetaInt<0>)
413 SrcIterator send = s + shape[0];
420 template <
class SrcIterator,
class Shape,
class T,
class Functor,
int N>
422 reduceOverMultiArray(SrcIterator s, Shape
const & shape, T & result, Functor
const & f, MetaInt<N>)
424 SrcIterator send = s + shape[N];
427 reduceOverMultiArray(s.begin(), shape, result, f, MetaInt<N-1>());
431 struct MaxNormReduceFunctor
433 template <
class T,
class U>
434 void operator()(T & result, U
const & u)
const
442 struct L1NormReduceFunctor
444 template <
class T,
class U>
445 void operator()(T & result, U
const & u)
const
451 struct SquaredL2NormReduceFunctor
453 template <
class T,
class U>
454 void operator()(T & result, U
const & u)
const
461 struct WeightedL2NormReduceFunctor
465 WeightedL2NormReduceFunctor(T s)
470 void operator()(T & result, U
const & u)
const
476 struct SumReduceFunctor
478 template <
class T,
class U>
479 void operator()(T & result, U
const & u)
const
485 struct ProdReduceFunctor
487 template <
class T,
class U>
488 void operator()(T & result, U
const & u)
const
494 struct MinmaxReduceFunctor
496 template <
class T,
class U>
497 void operator()(T & result, U
const & u)
const
501 if(result.second < u)
506 struct MeanVarianceReduceFunctor
508 template <
class T,
class U>
509 void operator()(T & result, U
const & u)
const
512 typename T::second_type t1 = u - result.second;
513 typename T::second_type t2 = t1 / result.first;
515 result.third += (result.first-1.0)*t1*t2;
519 struct AllTrueReduceFunctor
521 template <
class T,
class U>
522 void operator()(T & result, U
const & u)
const
524 result = result && (u != NumericTraits<U>::zero());
528 struct AnyTrueReduceFunctor
530 template <
class T,
class U>
531 void operator()(T & result, U
const & u)
const
533 result = result || (u != NumericTraits<U>::zero());
537 template <
class SrcIterator,
class Shape,
class DestIterator>
539 equalityOfMultiArrays(SrcIterator s, Shape
const & shape, DestIterator d, MetaInt<0>)
541 SrcIterator send = s + shape[0];
542 for(; s < send; ++s, ++d)
550 template <
class SrcIterator,
class Shape,
class DestIterator,
int N>
552 equalityOfMultiArrays(SrcIterator s, Shape
const & shape, DestIterator d, MetaInt<N>)
554 SrcIterator send = s + shape[N];
555 for(; s < send; ++s, ++d)
557 if(!equalityOfMultiArrays(s.begin(), shape, d.begin(), MetaInt<N-1>()))
564 template <
class SrcIterator,
class Shape,
class DestIterator>
566 swapDataImpl(SrcIterator s, Shape
const & shape, DestIterator d, MetaInt<0>)
568 SrcIterator send = s + shape[0];
569 for(; s < send; ++s, ++d)
573 template <
class SrcIterator,
class Shape,
class DestIterator,
int N>
575 swapDataImpl(SrcIterator s, Shape
const & shape, DestIterator d, MetaInt<N>)
577 SrcIterator send = s + shape[N];
578 for(; s < send; ++s, ++d)
579 swapDataImpl(s.begin(), shape, d.begin(), MetaInt<N-1>());
592 template <
unsigned int N,
class T,
class C = Unstr
idedArrayTag>
594 template <
unsigned int N,
class T,
class A = std::allocator<T> >
597 namespace multi_math {
600 struct MultiMathOperand;
604 template <
unsigned int N,
class T,
class C,
class E>
607 template <
unsigned int N,
class T,
class C,
class E>
610 template <
unsigned int N,
class T,
class C,
class E>
613 template <
unsigned int N,
class T,
class C,
class E>
616 template <
unsigned int N,
class T,
class C,
class E>
619 template <
unsigned int N,
class T,
class A,
class E>
622 template <
unsigned int N,
class T,
class A,
class E>
625 template <
unsigned int N,
class T,
class A,
class E>
628 template <
unsigned int N,
class T,
class A,
class E>
631 template <
unsigned int N,
class T,
class A,
class E>
638 template <
class T>
class FindSum;
640 struct UnsuitableTypeForExpandElements {};
643 struct ExpandElementResult
645 typedef UnsuitableTypeForExpandElements type;
649 struct ExpandElementResult<std::complex<T> >
659 struct ExpandElementResult<FFTWComplex<T> >
665 template <
class T,
int SIZE>
666 struct ExpandElementResult<TinyVector<T, SIZE> >
669 enum { size = SIZE };
672 template <
class T,
unsigned int R,
unsigned int G,
unsigned int B>
673 struct ExpandElementResult<RGBValue<T, R, G, B> >
679 #define VIGRA_DEFINE_EXPAND_ELEMENT_RESULT(TYPE) \
681 struct ExpandElementResult<TYPE> \
687 VIGRA_DEFINE_EXPAND_ELEMENT_RESULT(
bool)
688 VIGRA_DEFINE_EXPAND_ELEMENT_RESULT(
char)
689 VIGRA_DEFINE_EXPAND_ELEMENT_RESULT(
signed char)
690 VIGRA_DEFINE_EXPAND_ELEMENT_RESULT(
signed short)
691 VIGRA_DEFINE_EXPAND_ELEMENT_RESULT(
signed int)
692 VIGRA_DEFINE_EXPAND_ELEMENT_RESULT(
signed long)
693 VIGRA_DEFINE_EXPAND_ELEMENT_RESULT(
signed long long)
694 VIGRA_DEFINE_EXPAND_ELEMENT_RESULT(
unsigned char)
695 VIGRA_DEFINE_EXPAND_ELEMENT_RESULT(
unsigned short)
696 VIGRA_DEFINE_EXPAND_ELEMENT_RESULT(
unsigned int)
697 VIGRA_DEFINE_EXPAND_ELEMENT_RESULT(
unsigned long)
698 VIGRA_DEFINE_EXPAND_ELEMENT_RESULT(
unsigned long long)
699 VIGRA_DEFINE_EXPAND_ELEMENT_RESULT(
float)
700 VIGRA_DEFINE_EXPAND_ELEMENT_RESULT(
double)
701 VIGRA_DEFINE_EXPAND_ELEMENT_RESULT(
long double)
703 #undef VIGRA_DEFINE_EXPAND_ELEMENT_RESULT
712 template <
unsigned int N,
class T,
class C>
713 struct NormTraits<MultiArrayView<N, T, C> >
715 typedef MultiArrayView<N, T, C> Type;
716 typedef typename NormTraits<T>::SquaredNormType SquaredNormType;
717 typedef typename SquareRootTraits<SquaredNormType>::SquareRootResult NormType;
720 template <
unsigned int N,
class T,
class A>
721 struct NormTraits<MultiArray<N, T, A> >
722 :
public NormTraits<MultiArrayView<N, T, UnstridedArrayTag> >
724 typedef NormTraits<MultiArrayView<N, T, UnstridedArrayTag> > BaseType;
725 typedef MultiArray<N, T, A> Type;
726 typedef typename BaseType::SquaredNormType SquaredNormType;
727 typedef typename BaseType::NormType NormType;
765 template <
unsigned int N,
class T,
class Str
ideTag>
821 typedef typename vigra::detail::MultiIteratorChooser <
822 StrideTag>::template Traverser <actual_dimension, T, T &, T *>::type
traverser;
826 typedef typename vigra::detail::MultiIteratorChooser <
827 StrideTag>::template Traverser <actual_dimension, T, T const &, T const *>::type
const_traverser;
839 typedef typename difference_type::value_type diff_zero_t;
854 template <
class U,
class CN>
857 template <
class U,
class CN>
863 template <
class U,
class CN>
871 return m_stride[0] <= 1;
874 bool checkInnerStride(StridedArrayTag)
885 : m_shape (diff_zero_t(0)), m_stride (diff_zero_t(0)), m_ptr (0)
892 m_stride (detail::defaultStride <
MultiArrayView<N,T>::actual_dimension> (shape)),
902 const difference_type &
stride,
908 vigra_precondition(checkInnerStride(StrideTag()),
909 "MultiArrayView<..., UnstridedArrayTag>::MultiArrayView(): First dimension of given array is not unstrided.");
933 template<
class U,
class C1>
936 vigra_precondition(this->
shape() == rhs.shape(),
937 "MultiArrayView::operator=() size mismatch.");
952 template<
class U,
class C1>
958 template<
class U,
class C1>
964 template<
class U,
class C1>
970 template<
class U,
class C1>
977 detail::copyAddScalarMultiArrayData(
traverser_begin(),
shape(), rhs, MetaInt<actual_dimension-1>());
985 detail::copySubScalarMultiArrayData(
traverser_begin(),
shape(), rhs, MetaInt<actual_dimension-1>());
993 detail::copyMulScalarMultiArrayData(
traverser_begin(),
shape(), rhs, MetaInt<actual_dimension-1>());
1001 detail::copyDivScalarMultiArrayData(
traverser_begin(),
shape(), rhs, MetaInt<actual_dimension-1>());
1008 template<
class Expression>
1011 multi_math::detail::assign(*
this, rhs);
1018 template<
class Expression>
1021 multi_math::detail::plusAssign(*
this, rhs);
1028 template<
class Expression>
1031 multi_math::detail::minusAssign(*
this, rhs);
1038 template<
class Expression>
1041 multi_math::detail::multiplyAssign(*
this, rhs);
1048 template<
class Expression>
1051 multi_math::detail::divideAssign(*
this, rhs);
1059 VIGRA_ASSERT_INSIDE(d);
1060 return m_ptr [
dot (d, m_stride)];
1067 VIGRA_ASSERT_INSIDE(d);
1068 return m_ptr [
dot (d, m_stride)];
1092 return m_ptr [detail::ScanOrderToOffset<actual_dimension>::exec(d, m_shape, m_stride)];
1108 return m_ptr [detail::ScanOrderToOffset<actual_dimension>::exec(d, m_shape, m_stride)];
1115 difference_type result;
1116 detail::ScanOrderToCoordinate<actual_dimension>::exec(d, m_shape, result);
1124 return detail::CoordinateToScanOrder<actual_dimension>::exec(m_shape, d);
1132 return m_ptr [detail::CoordinatesToOffest<StrideTag>::exec(m_stride, x)];
1140 return m_ptr [detail::CoordinatesToOffest<StrideTag>::exec(m_stride, x, y)];
1145 reference
operator() (difference_type_1 x, difference_type_1 y, difference_type_1 z)
1148 return m_ptr [m_stride[0]*x + m_stride[1]*y + m_stride[2]*z];
1154 difference_type_1 z, difference_type_1 u)
1157 return m_ptr [m_stride[0]*x + m_stride[1]*y + m_stride[2]*z + m_stride[3]*u];
1162 reference
operator() (difference_type_1 x, difference_type_1 y, difference_type_1 z,
1163 difference_type_1 u, difference_type_1 v)
1166 return m_ptr [m_stride[0]*x + m_stride[1]*y + m_stride[2]*z + m_stride[3]*u + m_stride[4]*v];
1174 return m_ptr [detail::CoordinatesToOffest<StrideTag>::exec(m_stride, x)];
1179 const_reference
operator() (difference_type_1 x, difference_type_1 y)
const
1182 return m_ptr [detail::CoordinatesToOffest<StrideTag>::exec(m_stride, x, y)];
1187 const_reference
operator() (difference_type_1 x, difference_type_1 y, difference_type_1 z)
const
1190 return m_ptr [m_stride[0]*x + m_stride[1]*y + m_stride[2]*z];
1195 const_reference
operator() (difference_type_1 x, difference_type_1 y,
1196 difference_type_1 z, difference_type_1 u)
const
1199 return m_ptr [m_stride[0]*x + m_stride[1]*y + m_stride[2]*z + m_stride[3]*u];
1204 const_reference
operator() (difference_type_1 x, difference_type_1 y, difference_type_1 z,
1205 difference_type_1 u, difference_type_1 v)
const
1208 return m_ptr [m_stride[0]*x + m_stride[1]*y + m_stride[2]*z + m_stride[3]*u + m_stride[4]*v];
1217 detail::copyScalarMultiArrayData(
traverser_begin(),
shape(), init, MetaInt<actual_dimension-1>());
1228 this->copyImpl(rhs);
1233 template <
class U,
class CN>
1236 this->copyImpl(rhs);
1253 template <
class T2,
class C2>
1267 difference_type s = vigra::detail::defaultStride<actual_dimension>(
shape());
1268 for(
unsigned int k = 0; k <= dimension; ++k)
1288 template <
int M,
class Index>
1305 template <
int M,
class Index>
1325 template <
unsigned int M>
1326 MultiArrayView <N-1, T,
typename vigra::detail::MaybeStrided<StrideTag, M>::type >
1327 bind (difference_type_1 d)
const;
1376 bindAt (difference_type_1 m, difference_type_1 d)
const;
1397 vigra_precondition(0 <= i && i < ExpandElementResult<T>::size,
1398 "MultiArrayView::bindElementChannel(i): 'i' out of range.");
1491 const difference_type &q)
const
1493 const difference_type_1 offset =
dot (m_stride, p);
1506 difference_type shape =
m_shape;
1507 for (
unsigned int i = 0; i < actual_dimension; ++i)
1530 difference_type
shape(m_shape.begin(), difference_type::ReverseCopy),
1531 stride(m_stride.begin(), difference_type::ReverseCopy);
1586 difference_type_1 ret = m_shape[0];
1587 for(
int i = 1; i < actual_dimension; ++i)
1609 difference_type_1
size (difference_type_1 n)
const
1617 difference_type_1
shape (difference_type_1 n)
const
1633 return m_stride [n];
1638 template <
class U,
class C1>
1641 if(this->
shape() != rhs.shape())
1643 return detail::equalityOfMultiArrays(
traverser_begin(),
shape(), rhs.traverser_begin(), MetaInt<actual_dimension-1>());
1649 template <
class U,
class C1>
1659 for(
int d=0; d<actual_dimension; ++d)
1660 if(p[d] < 0 || p[d] >=
shape(d))
1673 detail::AllTrueReduceFunctor(),
1674 MetaInt<actual_dimension-1>());
1686 detail::AnyTrueReduceFunctor(),
1687 MetaInt<actual_dimension-1>());
1697 std::pair<T, T> res(NumericTraits<T>::max(), NumericTraits<T>::min());
1700 detail::MinmaxReduceFunctor(),
1701 MetaInt<actual_dimension-1>());
1702 *minimum = res.first;
1703 *maximum = res.second;
1713 typedef typename NumericTraits<U>::RealPromote R;
1715 triple<double, R, R> res(0.0, zero, zero);
1718 detail::MeanVarianceReduceFunctor(),
1719 MetaInt<actual_dimension-1>());
1721 *variance = res.third / res.first;
1736 U res = NumericTraits<U>::zero();
1739 detail::SumReduceFunctor(),
1740 MetaInt<actual_dimension-1>());
1769 template <
class U,
class S>
1773 destMultiArrayRange(sums),
1789 U res = NumericTraits<U>::one();
1792 detail::ProdReduceFunctor(),
1793 MetaInt<actual_dimension-1>());
1799 typename NormTraits<MultiArrayView>::SquaredNormType
1802 typedef typename NormTraits<MultiArrayView>::SquaredNormType SquaredNormType;
1803 SquaredNormType res = NumericTraits<SquaredNormType>::zero();
1806 detail::SquaredL2NormReduceFunctor(),
1807 MetaInt<actual_dimension-1>());
1824 typename NormTraits<MultiArrayView>::NormType
1825 norm(
int type = 2,
bool useSquaredNorm =
true)
const;
1834 pointer & unsafePtr()
1854 return iterator(m_ptr, m_shape, m_stride);
1870 return begin().getEndIterator();
1878 return begin().getEndIterator();
1886 traverser ret (m_ptr, m_stride.begin (), m_shape.begin ());
1895 const_traverser ret (m_ptr, m_stride.begin (), m_shape.begin ());
1905 traverser ret (m_ptr, m_stride.begin (), m_shape.begin ());
1906 ret += m_shape [actual_dimension-1];
1916 const_traverser ret (m_ptr, m_stride.begin (), m_shape.begin ());
1917 ret += m_shape [actual_dimension-1];
1927 template <
unsigned int N,
class T,
class Str
ideTag>
1928 MultiArrayView<N, T, StrideTag> &
1933 vigra_precondition(this->
shape() == rhs.shape() ||
m_ptr == 0,
1934 "MultiArrayView::operator=(MultiArrayView const &) size mismatch.");
1942 this->copyImpl(rhs);
1946 template <
unsigned int N,
class T,
class Str
ideTag>
1951 vigra_precondition (shape () == rhs.shape (),
1952 "MultiArrayView::arraysOverlap(): shape mismatch.");
1956 rhs_first_element = rhs.data(),
1957 rhs_last_element = rhs_first_element +
dot(rhs.shape() -
difference_type(1), rhs.stride());
1958 return !(last_element < rhs_first_element || rhs_last_element < first_element);
1961 template <
unsigned int N,
class T,
class Str
ideTag>
1962 template <
class U,
class CN>
1964 MultiArrayView <N, T, StrideTag>::copyImpl(
const MultiArrayView <N, U, CN>& rhs)
1966 if(!arraysOverlap(rhs))
1969 detail::copyMultiArrayData(rhs.traverser_begin(),
shape(),
traverser_begin(), MetaInt<actual_dimension-1>());
1975 MultiArray<N, T> tmp(rhs);
1976 detail::copyMultiArrayData(tmp.traverser_begin(),
shape(),
traverser_begin(), MetaInt<actual_dimension-1>());
1980 #define VIGRA_MULTI_ARRAY_COMPUTED_ASSIGNMENT(name, op) \
1981 template <unsigned int N, class T, class StrideTag> \
1982 template<class U, class C1> \
1983 MultiArrayView<N, T, StrideTag> & \
1984 MultiArrayView <N, T, StrideTag>::operator op(MultiArrayView<N, U, C1> const & rhs) \
1986 vigra_precondition(this->shape() == rhs.shape(), "MultiArrayView::operator" #op "() size mismatch."); \
1987 if(!arraysOverlap(rhs)) \
1989 detail::name##MultiArrayData(rhs.traverser_begin(), shape(), traverser_begin(), MetaInt<actual_dimension-1>()); \
1993 MultiArray<N, T> tmp(rhs); \
1994 detail::name##MultiArrayData(tmp.traverser_begin(), shape(), traverser_begin(), MetaInt<actual_dimension-1>()); \
1999 VIGRA_MULTI_ARRAY_COMPUTED_ASSIGNMENT(copyAdd, +=)
2000 VIGRA_MULTI_ARRAY_COMPUTED_ASSIGNMENT(copySub, -=)
2001 VIGRA_MULTI_ARRAY_COMPUTED_ASSIGNMENT(copyMul, *=)
2002 VIGRA_MULTI_ARRAY_COMPUTED_ASSIGNMENT(copyDiv, /=)
2004 #undef VIGRA_MULTI_ARRAY_COMPUTED_ASSIGNMENT
2006 template <
unsigned int N,
class T,
class Str
ideTag>
2007 template <
class U,
class CN>
2009 MultiArrayView <N, T, StrideTag>::swapDataImpl(MultiArrayView <N, U, CN> rhs)
2011 vigra_precondition (shape () == rhs.shape (),
2012 "MultiArrayView::swapData(): shape mismatch.");
2017 typename MultiArrayView <N, U, CN>::const_pointer
2018 rhs_first_element = rhs.
data(),
2019 rhs_last_element = rhs_first_element +
dot(rhs.shape() -
difference_type(1), rhs.stride());
2020 if(last_element < rhs_first_element || rhs_last_element < first_element)
2023 detail::swapDataImpl(
traverser_begin(),
shape(), rhs.traverser_begin(), MetaInt<actual_dimension-1>());
2029 MultiArray<N, T> tmp(*
this);
2035 template <
unsigned int N,
class T,
class Str
ideTag>
2036 MultiArrayView <N, T, StridedArrayTag>
2040 for (
unsigned int i = 0; i < actual_dimension; ++i)
2047 "MultiArrayView::permuteDimensions(): every dimension must occur exactly once.");
2051 template <
unsigned int N,
class T,
class Str
ideTag>
2056 for(
int k=0; k<(int)N; ++k)
2058 for(
int k=0; k<(int)N-1; ++k)
2061 for(
int j=k+1; j<(int)N; ++j)
2069 std::swap(permutation[k], permutation[smallest]);
2073 for(
unsigned int k=0; k<N; ++k)
2074 ordering[permutation[k]] = k;
2078 template <
unsigned int N,
class T,
class Str
ideTag>
2084 permutation[ordering[k]] = k;
2088 template <
unsigned int N,
class T,
class Str
ideTag>
2094 permutation[N-1-ordering[k]] = k;
2098 template <
unsigned int N,
class T,
class Str
ideTag>
2099 template <
int M,
class Index>
2106 static const int NNew = (N-M == 0) ? 1 : N-M;
2110 inner_shape [0] = 1;
2111 inner_stride [0] = 0;
2118 return MultiArrayView <N-M, T, StrideTag> (inner_shape, inner_stride, ptr);
2121 template <
unsigned int N,
class T,
class Str
ideTag>
2122 template <
int M,
class Index>
2129 static const int NNew = (N-M == 0) ? 1 : N-M;
2133 outer_shape [0] = 1;
2134 outer_stride [0] = 0;
2142 (outer_shape, outer_stride, ptr);
2145 template <
unsigned int N,
class T,
class Str
ideTag>
2146 template <
unsigned int M>
2147 MultiArrayView <N-1, T,
typename detail::MaybeStrided<StrideTag, M>::type >
2150 static const int NNew = (N-1 == 0) ? 1 : N-1;
2162 shape.
begin () + M);
2165 stride.
begin () + M);
2167 return MultiArrayView <N-1, T,
typename detail::MaybeStrided<StrideTag, M>::type>
2171 template <
unsigned int N,
class T,
class Str
ideTag>
2175 static const int NNew = (N-1 == 0) ? 1 : N-1;
2179 inner_shape [0] = 1;
2180 inner_stride [0] = 0;
2187 return MultiArrayView <N-1, T, StrideTag> (inner_shape, inner_stride,
2191 template <
unsigned int N,
class T,
class Str
ideTag>
2195 static const int NNew = (N-1 == 0) ? 1 : N-1;
2199 outer_shape [0] = 1;
2200 outer_stride [0] = 0;
2211 template <
unsigned int N,
class T,
class Str
ideTag>
2215 vigra_precondition (
2216 n < static_cast <int> (N),
2217 "MultiArrayView <N, T, StrideTag>::bindAt(): dimension out of range.");
2218 static const int NNew = (N-1 == 0) ? 1 : N-1;
2230 shape.
begin () + n);
2233 stride.
begin () + n);
2240 template <
unsigned int N,
class T,
class Str
ideTag>
2244 vigra_precondition(0 <= d && d <= static_cast <difference_type_1> (N),
2245 "MultiArrayView<N, ...>::expandElements(d): 0 <= 'd' <= N required.");
2247 int elementSize = ExpandElementResult<T>::size;
2249 for(
int k=0; k<d; ++k)
2252 newStrides[k] =
m_stride[k]*elementSize;
2255 newShape[d] = elementSize;
2258 for(
int k=d; k<N; ++k)
2261 newStrides[k+1] =
m_stride[k]*elementSize;
2264 typedef typename ExpandElementResult<T>::type U;
2266 newShape, newStrides,
reinterpret_cast<U*
>(
m_ptr));
2269 template <
unsigned int N,
class T,
class Str
ideTag>
2273 vigra_precondition (
2274 0 <= i && i <= static_cast <difference_type_1> (N),
2275 "MultiArrayView <N, T, StrideTag>::insertSingletonDimension(): index out of range.");
2287 template <
unsigned int N,
class T,
class Str
ideTag>
2288 typename NormTraits<MultiArrayView <N, T, StrideTag> >::NormType
2291 typedef typename NormTraits<MultiArrayView>::NormType NormType;
2297 NormType res = NumericTraits<NormType>::zero();
2300 detail::MaxNormReduceFunctor(),
2301 MetaInt<actual_dimension-1>());
2306 NormType res = NumericTraits<NormType>::zero();
2309 detail::L1NormReduceFunctor(),
2310 MetaInt<actual_dimension-1>());
2321 NormType normMax = NumericTraits<NormType>::zero();
2324 detail::MaxNormReduceFunctor(),
2325 MetaInt<actual_dimension-1>());
2326 if(normMax == NumericTraits<NormType>::zero())
2328 NormType res = NumericTraits<NormType>::zero();
2331 detail::WeightedL2NormReduceFunctor<NormType>(1.0/normMax),
2332 MetaInt<actual_dimension-1>());
2333 return sqrt(res)*normMax;
2337 vigra_precondition(
false,
"MultiArrayView::norm(): Unknown norm type.");
2338 return NumericTraits<NormType>::zero();
2349 template <
unsigned int N,
class T,
class Str
ideTag>
2350 inline typename NormTraits<MultiArrayView <N, T, StrideTag> >::SquaredNormType
2356 template <
unsigned int N,
class T,
class Str
ideTag>
2357 inline typename NormTraits<MultiArrayView <N, T, StrideTag> >::NormType
2358 norm(MultiArrayView <N, T, StrideTag>
const & a)
2392 template <
unsigned int N,
class T,
class A >
2397 using MultiArrayView <N, T>::actual_dimension;
2445 typedef typename vigra::detail::MultiIteratorChooser <
2451 typedef typename vigra::detail::MultiIteratorChooser <
2465 typedef typename difference_type::value_type diff_zero_t;
2485 template <
class U,
class Str
ideTag>
2492 template <
class U,
class Str
ideTag>
2515 allocator_type
const & alloc = allocator_type());
2520 allocator_type
const & alloc = allocator_type());
2525 allocator_type
const & alloc = allocator_type());
2530 allocator_type
const & alloc = allocator_type());
2536 m_alloc (rhs.m_alloc)
2543 template<
class Expression>
2544 MultiArray (multi_math::MultiMathOperand<Expression>
const & rhs,
2550 multi_math::detail::assignOrResize(*
this, rhs);
2555 template <
class U,
class Str
ideTag>
2557 allocator_type
const & alloc = allocator_type());
2567 this->copyOrReshape(rhs);
2576 template <
class U,
class Str
ideTag>
2579 this->copyOrReshape(rhs);
2588 return this->
init(v);
2597 template <
class U,
class Str
ideTag>
2613 template <
class U,
class Str
ideTag>
2617 this->reshape(rhs.shape());
2628 template <
class U,
class Str
ideTag>
2634 this->reshape(rhs.shape());
2644 template <
class U,
class Str
ideTag>
2650 this->reshape(rhs.shape());
2688 template<
class Expression>
2691 multi_math::detail::assignOrResize(*
this, rhs);
2698 template<
class Expression>
2701 multi_math::detail::plusAssignOrResize(*
this, rhs);
2708 template<
class Expression>
2711 multi_math::detail::minusAssignOrResize(*
this, rhs);
2718 template<
class Expression>
2721 multi_math::detail::multiplyAssignOrResize(*
this, rhs);
2728 template<
class Expression>
2731 multi_math::detail::divideAssignOrResize(*
this, rhs);
2758 reshape (shape, T());
2779 return this->
data();
2793 return this->
data();
2811 template <
unsigned int N,
class T,
class A>
2822 template <
unsigned int N,
class T,
class A>
2838 template <
unsigned int N,
class T,
class A>
2854 template <
unsigned int N,
class T,
class A>
2870 template <
unsigned int N,
class T,
class A>
2871 template <
class U,
class Str
ideTag>
2875 detail::defaultStride <MultiArrayView<N,T>::actual_dimension>(rhs.shape()),
2879 allocate (this->
m_ptr, rhs);
2882 template <
unsigned int N,
class T,
class A>
2883 template <
class U,
class Str
ideTag>
2887 if (this->
shape() == rhs.shape())
2896 template <
unsigned int N,
class T,
class A>
2904 else if(new_shape == this->
shape())
2906 this->
init(initial);
2910 difference_type new_stride = detail::defaultStride <MultiArrayView<N,T>::actual_dimension> (new_shape);
2913 allocate (new_ptr, new_size, initial);
2915 this->
m_ptr = new_ptr;
2922 template <
unsigned int N,
class T,
class A>
2928 std::swap(this->
m_shape, other.m_shape);
2929 std::swap(this->
m_stride, other.m_stride);
2930 std::swap(this->
m_ptr, other.m_ptr);
2931 std::swap(this->m_alloc, other.m_alloc);
2934 template <
unsigned int N,
class T,
class A>
2938 ptr = m_alloc.
allocate ((
typename A::size_type)s);
2941 for (i = 0; i < s; ++i)
2942 m_alloc.construct (ptr + i, init);
2946 m_alloc.destroy (ptr + j);
2947 m_alloc.deallocate (ptr, (
typename A::size_type)s);
2952 template <
unsigned int N,
class T,
class A>
2957 ptr = m_alloc.
allocate ((
typename A::size_type)s);
2960 for (i = 0; i < s; ++i, ++
init)
2961 m_alloc.construct (ptr + i, *init);
2965 m_alloc.destroy (ptr + j);
2966 m_alloc.deallocate (ptr, (
typename A::size_type)s);
2971 template <
unsigned int N,
class T,
class A>
2972 template <
class U,
class Str
ideTag>
2976 ptr = m_alloc.allocate ((
typename A::size_type)s);
2979 detail::uninitializedCopyMultiArrayData(init.traverser_begin(), init.shape(),
2980 p, m_alloc, MetaInt<actual_dimension-1>());
2983 for (
pointer pp = ptr; pp < p; ++pp)
2984 m_alloc.destroy (pp);
2985 m_alloc.deallocate (ptr, (
typename A::size_type)s);
2990 template <
unsigned int N,
class T,
class A>
2996 m_alloc.destroy (ptr + i);
2997 m_alloc.
deallocate (ptr, (
typename A::size_type)s);
3007 template <
unsigned int N,
class T,
class Str
ideTag>
3008 inline triple<typename MultiArrayView<N,T,StrideTag>::const_traverser,
3013 return triple<typename MultiArrayView<N,T,StrideTag>::const_traverser,
3021 template <
unsigned int N,
class T,
class Str
ideTag,
class Accessor>
3022 inline triple<typename MultiArrayView<N,T,StrideTag>::const_traverser,
3023 typename MultiArrayView<N,T,StrideTag>::difference_type,
3025 srcMultiArrayRange( MultiArrayView<N,T,StrideTag>
const & array, Accessor a )
3027 return triple<typename MultiArrayView<N,T,StrideTag>::const_traverser,
3028 typename MultiArrayView<N,T,StrideTag>::difference_type,
3030 ( array.traverser_begin(),
3035 template <
unsigned int N,
class T,
class Str
ideTag>
3036 inline pair<typename MultiArrayView<N,T,StrideTag>::const_traverser,
3037 typename AccessorTraits<T>::default_const_accessor >
3038 srcMultiArray( MultiArrayView<N,T,StrideTag>
const & array )
3040 return pair<typename MultiArrayView<N,T,StrideTag>::const_traverser,
3041 typename AccessorTraits<T>::default_const_accessor >
3042 ( array.traverser_begin(),
3043 typename AccessorTraits<T>::default_const_accessor() );
3046 template <
unsigned int N,
class T,
class Str
ideTag,
class Accessor>
3047 inline pair<typename MultiArrayView<N,T,StrideTag>::const_traverser,
3049 srcMultiArray( MultiArrayView<N,T,StrideTag>
const & array, Accessor a )
3051 return pair<typename MultiArrayView<N,T,StrideTag>::const_traverser,
3053 ( array.traverser_begin(), a );
3056 template <
unsigned int N,
class T,
class Str
ideTag>
3057 inline triple<typename MultiArrayView<N,T,StrideTag>::traverser,
3058 typename MultiArrayView<N,T,StrideTag>::difference_type,
3059 typename AccessorTraits<T>::default_accessor >
3060 destMultiArrayRange( MultiArrayView<N,T,StrideTag> & array )
3062 return triple<typename MultiArrayView<N,T,StrideTag>::traverser,
3063 typename MultiArrayView<N,T,StrideTag>::difference_type,
3064 typename AccessorTraits<T>::default_accessor >
3065 ( array.traverser_begin(),
3067 typename AccessorTraits<T>::default_accessor() );
3070 template <
unsigned int N,
class T,
class Str
ideTag,
class Accessor>
3071 inline triple<typename MultiArrayView<N,T,StrideTag>::traverser,
3072 typename MultiArrayView<N,T,StrideTag>::difference_type,
3074 destMultiArrayRange( MultiArrayView<N,T,StrideTag> & array, Accessor a )
3076 return triple<typename MultiArrayView<N,T,StrideTag>::traverser,
3077 typename MultiArrayView<N,T,StrideTag>::difference_type,
3079 ( array.traverser_begin(),
3084 template <
unsigned int N,
class T,
class Str
ideTag>
3085 inline pair<typename MultiArrayView<N,T,StrideTag>::traverser,
3086 typename AccessorTraits<T>::default_accessor >
3087 destMultiArray( MultiArrayView<N,T,StrideTag> & array )
3089 return pair<typename MultiArrayView<N,T,StrideTag>::traverser,
3090 typename AccessorTraits<T>::default_accessor >
3091 ( array.traverser_begin(),
3092 typename AccessorTraits<T>::default_accessor() );
3095 template <
unsigned int N,
class T,
class Str
ideTag,
class Accessor>
3096 inline pair<typename MultiArrayView<N,T,StrideTag>::traverser,
3098 destMultiArray( MultiArrayView<N,T,StrideTag> & array, Accessor a )
3100 return pair<typename MultiArrayView<N,T,StrideTag>::traverser,
3102 ( array.traverser_begin(), a );
3107 template <
class PixelType,
class Accessor>
3108 inline triple<ConstStridedImageIterator<PixelType>,
3109 ConstStridedImageIterator<PixelType>, Accessor>
3110 srcImageRange(
const MultiArrayView<2, PixelType, StridedArrayTag> & img, Accessor a)
3112 ConstStridedImageIterator<PixelType>
3113 ul(img.data(), 1, img.stride(0), img.stride(1));
3114 return triple<ConstStridedImageIterator<PixelType>,
3115 ConstStridedImageIterator<PixelType>,
3117 ul, ul + Size2D(img.shape(0), img.shape(1)), a);
3120 template <
class PixelType,
class Accessor>
3121 inline pair<ConstStridedImageIterator<PixelType>, Accessor>
3122 srcImage(
const MultiArrayView<2, PixelType, StridedArrayTag> & img, Accessor a)
3124 ConstStridedImageIterator<PixelType>
3125 ul(img.data(), 1, img.stride(0), img.stride(1));
3126 return pair<ConstStridedImageIterator<PixelType>, Accessor>
3130 template <
class PixelType,
class Accessor>
3131 inline triple<StridedImageIterator<PixelType>,
3132 StridedImageIterator<PixelType>, Accessor>
3133 destImageRange(MultiArrayView<2, PixelType, StridedArrayTag> & img, Accessor a)
3135 StridedImageIterator<PixelType>
3136 ul(img.data(), 1, img.stride(0), img.stride(1));
3137 return triple<StridedImageIterator<PixelType>,
3138 StridedImageIterator<PixelType>,
3140 ul, ul + Size2D(img.shape(0), img.shape(1)), a);
3143 template <
class PixelType,
class Accessor>
3144 inline pair<StridedImageIterator<PixelType>, Accessor>
3145 destImage(MultiArrayView<2, PixelType, StridedArrayTag> & img, Accessor a)
3147 StridedImageIterator<PixelType>
3148 ul(img.data(), 1, img.stride(0), img.stride(1));
3149 return pair<StridedImageIterator<PixelType>, Accessor>
3153 template <
class PixelType,
class Accessor>
3154 inline pair<StridedImageIterator<PixelType>, Accessor>
3155 maskImage(MultiArrayView<2, PixelType, StridedArrayTag> & img, Accessor a)
3157 StridedImageIterator<PixelType>
3158 ul(img.data(), 1, img.stride(0), img.stride(1));
3159 return pair<StridedImageIterator<PixelType>, Accessor>
3165 template <
class PixelType>
3166 inline triple<ConstStridedImageIterator<PixelType>,
3167 ConstStridedImageIterator<PixelType>,
3168 typename AccessorTraits<PixelType>::default_const_accessor>
3169 srcImageRange(MultiArrayView<2, PixelType, StridedArrayTag>
const & img)
3171 ConstStridedImageIterator<PixelType>
3172 ul(img.data(), 1, img.stride(0), img.stride(1));
3173 typedef typename AccessorTraits<PixelType>::default_const_accessor Accessor;
3174 return triple<ConstStridedImageIterator<PixelType>,
3175 ConstStridedImageIterator<PixelType>,
3177 (ul, ul + Size2D(img.shape(0), img.shape(1)), Accessor());
3180 template <
class PixelType>
3181 inline triple<ConstImageIterator<PixelType>,
3182 ConstImageIterator<PixelType>,
3183 typename AccessorTraits<PixelType>::default_const_accessor>
3184 srcImageRange(MultiArrayView<2, PixelType, UnstridedArrayTag>
const & img)
3186 ConstImageIterator<PixelType>
3187 ul(img.data(), img.stride(1));
3188 typedef typename AccessorTraits<PixelType>::default_const_accessor Accessor;
3189 return triple<ConstImageIterator<PixelType>,
3190 ConstImageIterator<PixelType>,
3192 (ul, ul + Size2D(img.shape(0), img.shape(1)), Accessor());
3195 template <
class PixelType>
3196 inline pair< ConstStridedImageIterator<PixelType>,
3197 typename AccessorTraits<PixelType>::default_const_accessor>
3198 srcImage(MultiArrayView<2, PixelType, StridedArrayTag>
const & img)
3200 ConstStridedImageIterator<PixelType>
3201 ul(img.data(), 1, img.stride(0), img.stride(1));
3202 typedef typename AccessorTraits<PixelType>::default_const_accessor Accessor;
3203 return pair<ConstStridedImageIterator<PixelType>,
3208 template <
class PixelType>
3209 inline pair< ConstImageIterator<PixelType>,
3210 typename AccessorTraits<PixelType>::default_const_accessor>
3211 srcImage(MultiArrayView<2, PixelType, UnstridedArrayTag>
const & img)
3213 ConstImageIterator<PixelType>
3214 ul(img.data(), img.stride(1));
3215 typedef typename AccessorTraits<PixelType>::default_const_accessor Accessor;
3216 return pair<ConstImageIterator<PixelType>,
3221 template <
class PixelType>
3222 inline triple< StridedImageIterator<PixelType>,
3223 StridedImageIterator<PixelType>,
3224 typename AccessorTraits<PixelType>::default_accessor>
3225 destImageRange(MultiArrayView<2, PixelType, StridedArrayTag> & img)
3227 StridedImageIterator<PixelType>
3228 ul(img.data(), 1, img.stride(0), img.stride(1));
3229 typedef typename AccessorTraits<PixelType>::default_accessor Accessor;
3230 return triple<StridedImageIterator<PixelType>,
3231 StridedImageIterator<PixelType>,
3233 (ul, ul + Size2D(img.shape(0), img.shape(1)), Accessor());
3236 template <
class PixelType>
3237 inline triple< ImageIterator<PixelType>,
3238 ImageIterator<PixelType>,
3239 typename AccessorTraits<PixelType>::default_accessor>
3240 destImageRange(MultiArrayView<2, PixelType, UnstridedArrayTag> & img)
3242 ImageIterator<PixelType>
3243 ul(img.data(), img.stride(1));
3244 typedef typename AccessorTraits<PixelType>::default_accessor Accessor;
3245 return triple<ImageIterator<PixelType>,
3246 ImageIterator<PixelType>,
3248 (ul, ul + Size2D(img.shape(0), img.shape(1)), Accessor());
3251 template <
class PixelType>
3252 inline pair< StridedImageIterator<PixelType>,
3253 typename AccessorTraits<PixelType>::default_accessor>
3254 destImage(MultiArrayView<2, PixelType, StridedArrayTag> & img)
3256 StridedImageIterator<PixelType>
3257 ul(img.data(), 1, img.stride(0), img.stride(1));
3258 typedef typename AccessorTraits<PixelType>::default_accessor Accessor;
3259 return pair<StridedImageIterator<PixelType>, Accessor>
3263 template <
class PixelType>
3264 inline pair< ImageIterator<PixelType>,
3265 typename AccessorTraits<PixelType>::default_accessor>
3266 destImage(MultiArrayView<2, PixelType, UnstridedArrayTag> & img)
3268 ImageIterator<PixelType> ul(img.data(), img.stride(1));
3269 typedef typename AccessorTraits<PixelType>::default_accessor Accessor;
3270 return pair<ImageIterator<PixelType>, Accessor>(ul, Accessor());
3273 template <
class PixelType>
3274 inline pair< ConstStridedImageIterator<PixelType>,
3275 typename AccessorTraits<PixelType>::default_accessor>
3276 maskImage(MultiArrayView<2, PixelType, StridedArrayTag>
const & img)
3278 ConstStridedImageIterator<PixelType>
3279 ul(img.data(), 1, img.stride(0), img.stride(1));
3280 typedef typename AccessorTraits<PixelType>::default_accessor Accessor;
3281 return pair<ConstStridedImageIterator<PixelType>, Accessor>
3285 template <
class PixelType>
3286 inline pair< ConstImageIterator<PixelType>,
3287 typename AccessorTraits<PixelType>::default_accessor>
3288 maskImage(MultiArrayView<2, PixelType, UnstridedArrayTag>
const & img)
3290 ConstImageIterator<PixelType>
3291 ul(img.data(), img.stride(1));
3292 typedef typename AccessorTraits<PixelType>::default_accessor Accessor;
3293 return pair<ConstImageIterator<PixelType>, Accessor>
3346 BasicImageView <RGBValue<T> >
3349 vigra_precondition (
3350 array.shape (0) == 3,
"makeRGBImageView(): array.shape(0) must be 3.");
3353 array.shape (1), array.shape (2));
3360 #undef VIGRA_ASSERT_INSIDE
3362 #endif // VIGRA_MULTI_ARRAY_HXX
BasicImageView< RGBValue< T > > makeRGBImageView(MultiArray< 3, T > const &array)
Definition: multi_array.hxx:3347
MultiArray & operator/=(multi_math::MultiMathOperand< Expression > const &rhs)
Definition: multi_array.hxx:2729
const value_type & const_reference
Definition: multi_array.hxx:789
MultiArray & operator=(multi_math::MultiMathOperand< Expression > const &rhs)
Definition: multi_array.hxx:2689
void sum(MultiArrayView< N, U, S > sums) const
Definition: multi_array.hxx:1770
MultiArrayView & operator=(multi_math::MultiMathOperand< Expression > const &rhs)
Definition: multi_array.hxx:1009
iterator end()
Definition: multi_array.hxx:1868
Sequential iterator for MultiArrayView.
Definition: multi_iterator.hxx:2079
MultiArrayView & operator*=(MultiArrayView< N, U, C1 > const &rhs)
MultiArrayView & operator+=(T const &rhs)
Definition: multi_array.hxx:975
MultiArray< N, T > matrix_type
Definition: multi_array.hxx:835
MultiArray< N, T, A > matrix_type
Definition: multi_array.hxx:2409
PromoteTraits< V1, V2 >::Promote dot(RGBValue< V1, RIDX1, GIDX1, BIDX1 > const &r1, RGBValue< V2, RIDX2, GIDX2, BIDX2 > const &r2)
dot product
Definition: rgbvalue.hxx:894
view_type::pointer pointer
Definition: multi_array.hxx:2417
MultiArrayShape< actual_dimension >::type difference_type
Definition: multi_array.hxx:801
MultiArrayView & operator=(value_type const &v)
Definition: multi_array.hxx:944
MultiArray & operator+=(multi_math::MultiMathOperand< Expression > const &rhs)
Definition: multi_array.hxx:2699
MultiArray()
Definition: multi_array.hxx:2497
vigra::detail::MultiIteratorChooser< UnstridedArrayTag >::template Traverser< N, T, T const &, T const * >::type const_traverser
Definition: multi_array.hxx:2453
MultiArrayView< N, T > view_type
Definition: multi_array.hxx:2405
const difference_type & shape() const
Definition: multi_array.hxx:1602
ActualDimension
Definition: multi_array.hxx:777
MultiArrayView< N, T, StrideTag > view_type
Definition: multi_array.hxx:831
difference_type m_shape
Definition: multi_array.hxx:843
MultiArray(allocator_type const &alloc)
Definition: multi_array.hxx:2504
MultiArray & operator=(value_type const &v)
Definition: multi_array.hxx:2586
A allocator_type
Definition: multi_array.hxx:2401
U product() const
Definition: multi_array.hxx:1787
reference operator[](difference_type_1 d)
Definition: multi_array.hxx:1089
MultiArrayView & operator-=(T const &rhs)
Definition: multi_array.hxx:983
difference_type size_type
Definition: multi_array.hxx:805
MultiArrayView & operator*=(multi_math::MultiMathOperand< Expression > const &rhs)
Definition: multi_array.hxx:1039
pointer data() const
Definition: multi_array.hxx:1829
void deallocate(pointer &ptr, difference_type_1 s)
Definition: multi_array.hxx:2991
difference_type_1 elementCount() const
Definition: multi_array.hxx:1584
const_iterator end() const
Definition: multi_array.hxx:2798
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:1852
Main MultiArray class containing the memory management.
Definition: multi_array.hxx:595
vigra::detail::MultiIteratorChooser< UnstridedArrayTag >::template Traverser< N, T, T &, T * >::type traverser
Definition: multi_array.hxx:2447
MultiArrayView & operator/=(T const &rhs)
Definition: multi_array.hxx:999
BasicImageView< T > makeBasicImageView(MultiArrayView< 2, T, UnstridedArrayTag > const &array)
Definition: multi_array.hxx:3315
void reshape(const difference_type &shape)
Definition: multi_array.hxx:2756
reference operator()(difference_type_1 x)
Definition: multi_array.hxx:1129
std::ptrdiff_t MultiArrayIndex
Definition: multi_iterator.hxx:348
Find the sum of the pixel values in an image or ROI.
Definition: inspectimage.hxx:947
MultiArrayView subarray(const difference_type &p, const difference_type &q) const
Definition: multi_array.hxx:1490
const_iterator begin() const
Definition: multi_array.hxx:1860
StridedScanOrderIterator< actual_dimension, T, T &, T * > iterator
Definition: multi_array.hxx:813
vigra::detail::MultiIteratorChooser< StrideTag >::template Traverser< actual_dimension, T, T const &, T const * >::type const_traverser
Definition: multi_array.hxx:827
MultiArrayView & operator/=(multi_math::MultiMathOperand< Expression > const &rhs)
Definition: multi_array.hxx:1049
NormTraits< MultiArrayView >::NormType norm(int type=2, bool useSquaredNorm=true) const
Definition: multi_array.hxx:2289
MultiArrayView< N, T, StridedArrayTag > transpose() const
Definition: multi_array.hxx:1528
view_type::difference_type difference_type
Definition: multi_array.hxx:2437
void meanVariance(U *mean, U *variance) const
Definition: multi_array.hxx:1711
MultiArray(multi_math::MultiMathOperand< Expression > const &rhs, allocator_type const &alloc=allocator_type())
Definition: multi_array.hxx:2544
MultiArrayView< N+1, T, StrideTag > insertSingletonDimension(difference_type_1 i) const
Definition: multi_array.hxx:2271
MultiArrayView< N-M, T, StridedArrayTag > bindInner(const TinyVector< Index, M > &d) const
Definition: multi_array.hxx:2124
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:822
MultiArrayView & operator=(MultiArrayView const &rhs)
Definition: multi_array.hxx:1929
difference_type_1 size() const
Definition: multi_array.hxx:1595
void swapData(MultiArrayView< N, T2, C2 > rhs)
Definition: multi_array.hxx:1254
NormTraits< MultiArrayView >::SquaredNormType squaredNorm() const
Definition: multi_array.hxx:1800
Definition: multi_iterator.hxx:354
bool operator==(MultiArrayView< N, U, C1 > const &rhs) const
Definition: multi_array.hxx:1639
view_type::reference reference
Definition: multi_array.hxx:2425
MultiArrayIndex difference_type_1
Definition: multi_array.hxx:809
const difference_type & stride() const
Definition: multi_array.hxx:1624
bool any() const
Definition: multi_array.hxx:1681
T * iterator
Definition: multi_array.hxx:2457
bool operator!=(MultiArrayView< N, U, C1 > const &rhs) const
Definition: multi_array.hxx:1650
NumericTraits< V >::Promote sum(TinyVectorBase< V, SIZE, D1, D2 > const &l)
sum of the vector's elements
Definition: tinyvector.hxx:1683
MultiArray & operator*=(multi_math::MultiMathOperand< Expression > const &rhs)
Definition: multi_array.hxx:2719
value_type & reference
Definition: multi_array.hxx:785
MultiArrayView & operator-=(multi_math::MultiMathOperand< Expression > const &rhs)
Definition: multi_array.hxx:1029
const_reference operator[](difference_type_1 d) const
Definition: multi_array.hxx:1105
difference_type_1 stride(int n) const
Definition: multi_array.hxx:1631
T * const_iterator
Definition: multi_array.hxx:2461
iterator begin()
Definition: tinyvector.hxx:724
bool isInside(difference_type const &p) const
Definition: multi_array.hxx:1657
difference_type_1 coordinateToScanOrderIndex(const difference_type &d) const
Definition: multi_array.hxx:1122
const_iterator end() const
Definition: multi_array.hxx:1876
MultiArray & init(const U &init)
Definition: multi_array.hxx:2746
MultiArrayView< 1, T, StridedArrayTag > diagonal() const
Definition: multi_array.hxx:1471
MultiArrayView< N-1, T, StridedArrayTag > bindAt(difference_type_1 m, difference_type_1 d) const
Definition: multi_array.hxx:2213
allocator_type m_alloc
Definition: multi_array.hxx:2469
void minmax(T *minimum, T *maximum) const
Definition: multi_array.hxx:1695
void copy(const MultiArrayView< N, U, CN > &rhs)
Definition: multi_array.hxx:1234
BasicImage using foreign memory.
Definition: basicimageview.hxx:75
MultiArrayView< N, T, StridedArrayTag > permuteStridesDescending() const
Definition: multi_array.hxx:2090
void copy(const MultiArrayView &rhs)
Definition: multi_array.hxx:1224
difference_type scanOrderIndexToCoordinate(difference_type_1 d) const
Definition: multi_array.hxx:1113
Definition: metaprogramming.hxx:102
allocator_type const & allocator() const
Definition: multi_array.hxx:2805
const_iterator begin() const
Definition: multi_array.hxx:2791
MultiArrayView< N, typename ExpandElementResult< T >::type, StridedArrayTag > bindElementChannel(difference_type_1 i) const
Definition: multi_array.hxx:1395
view_type::size_type size_type
Definition: multi_array.hxx:2433
MultiArrayView & operator/=(MultiArrayView< N, U, C1 > const &rhs)
difference_type_1 size(difference_type_1 n) const
Definition: multi_array.hxx:1609
view_type::const_pointer const_pointer
Definition: multi_array.hxx:2421
view_type::value_type value_type
Definition: multi_array.hxx:2413
Definition: metaprogramming.hxx:117
const_traverser traverser_begin() const
Definition: multi_array.hxx:1893
Class for fixed size vectors.This class contains an array of size SIZE of the specified VALUETYPE...
Definition: accessor.hxx:939
T value_type
Definition: multi_array.hxx:781
MultiArrayView< N, T, StridedArrayTag > permuteDimensions(const difference_type &s) const
Definition: multi_array.hxx:2037
bool hasData() const
Definition: multi_array.hxx:1844
pointer m_ptr
Definition: multi_array.hxx:852
~MultiArray()
Definition: multi_array.hxx:2737
view_type::difference_type_1 difference_type_1
Definition: multi_array.hxx:2441
MultiArrayView & operator+=(multi_math::MultiMathOperand< Expression > const &rhs)
Definition: multi_array.hxx:1019
MultiArrayShape< 1 >::type Shape1
shape type for MultiArray<1, T>
Definition: multi_iterator.hxx:363
MultiArrayView & operator=(MultiArrayView< N, U, C1 > const &rhs)
Definition: multi_array.hxx:934
MultiArray(const MultiArray &rhs)
Definition: multi_array.hxx:2534
Encapsulate read access to the values an iterator points to.
Definition: accessor.hxx:268
bool isUnstrided(unsigned int dimension=N-1) const
Definition: multi_array.hxx:1265
Base class for, and view to, vigra::MultiArray.
Definition: multi_array.hxx:593
iterator end()
Definition: multi_array.hxx:2784
void transformMultiArray(...)
Transform a multi-dimensional array with a unary function or functor.
MultiArrayView & init(const U &init)
Definition: multi_array.hxx:1214
MultiArray & operator-=(multi_math::MultiMathOperand< Expression > const &rhs)
Definition: multi_array.hxx:2709
iterator begin()
Definition: multi_array.hxx:2777
MultiArrayView(const difference_type &shape, const difference_type &stride, pointer ptr)
Definition: multi_array.hxx:901
void swapData(MultiArrayView rhs)
Definition: multi_array.hxx:1243
value_type * pointer
Definition: multi_array.hxx:793
MultiArrayView(const difference_type &shape, pointer ptr)
Definition: multi_array.hxx:890
traverser traverser_end()
Definition: multi_array.hxx:1903
Class for a single RGB value.
Definition: accessor.hxx:937
bool all() const
Definition: multi_array.hxx:1668
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:817
reference operator[](const difference_type &d)
Definition: multi_array.hxx:1057
MultiArrayView< N+1, typename ExpandElementResult< T >::type, StridedArrayTag > expandElements(difference_type_1 d) const
Definition: multi_array.hxx:2242
MultiArrayView & operator*=(T const &rhs)
Definition: multi_array.hxx:991
MultiArrayView< N, T, StridedArrayTag > permuteStridesAscending() const
Definition: multi_array.hxx:2080
difference_type m_stride
Definition: multi_array.hxx:848
void init(Iterator i, Iterator end)
Definition: tinyvector.hxx:611
U sum() const
Definition: multi_array.hxx:1734
const value_type * const_pointer
Definition: multi_array.hxx:797
difference_type_1 shape(difference_type_1 n) const
Definition: multi_array.hxx:1617
traverser traverser_begin()
Definition: multi_array.hxx:1884
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:1504
MultiArrayView()
Definition: multi_array.hxx:884
MultiArrayView< N-M, T, StrideTag > bindOuter(const TinyVector< Index, M > &d) const
Definition: multi_array.hxx:2101
V const & min(TinyVectorBase< V, SIZE, D1, D2 > const &l)
minimum element
Definition: tinyvector.hxx:1771
view_type::const_reference const_reference
Definition: multi_array.hxx:2429
void allocate(pointer &ptr, difference_type_1 s, const_reference init)
Definition: multi_array.hxx:2935
MultiArrayView & operator+=(MultiArrayView< N, U, C1 > const &rhs)
const_traverser traverser_end() const
Definition: multi_array.hxx:1914
difference_type strideOrdering() const
Definition: multi_array.hxx:1571