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"
54 #ifdef VIGRA_CHECK_BOUNDS
55 #define VIGRA_ASSERT_INSIDE(diff) \
56 vigra_precondition(this->isInside(diff), "Index out of bounds")
58 #define VIGRA_ASSERT_INSIDE(diff)
80 template <
class Str
ideTag,
unsigned int N>
83 typedef StrideTag type;
86 template <
class Str
ideTag>
87 struct MaybeStrided <StrideTag, 0>
89 typedef StridedArrayTag type;
105 struct MultiIteratorChooser;
119 struct MultiIteratorChooser <StridedArrayTag>
121 template <
unsigned int N,
class T,
class REFERENCE,
class POINTER>
124 typedef StridedMultiIterator <N, T, REFERENCE, POINTER> type;
127 template <
unsigned int N,
class T,
class REFERENCE,
class POINTER>
130 typedef StridedScanOrderIterator <N, T, REFERENCE, POINTER> type;
133 template <
class Iter,
class View>
134 static Iter constructIterator(View * v)
152 struct MultiIteratorChooser <UnstridedArrayTag>
154 template <
unsigned int N,
class T,
class REFERENCE,
class POINTER>
157 typedef MultiIterator <N, T, REFERENCE, POINTER> type;
160 template <
unsigned int N,
class T,
class REFERENCE,
class POINTER>
163 typedef POINTER type;
166 template <
class Iter,
class View>
167 static Iter constructIterator(View * v)
179 template <
class DestIterator,
class Shape,
class T>
181 initMultiArrayData(DestIterator d, Shape
const & shape, T
const & init, MetaInt<0>)
183 DestIterator dend = d + shape[0];
190 template <
class DestIterator,
class Shape,
class T,
int N>
192 initMultiArrayData(DestIterator d, Shape
const & shape, T
const & init, MetaInt<N>)
194 DestIterator dend = d + shape[N];
197 initMultiArrayData(d.begin(), shape, init, MetaInt<N-1>());
202 #define VIGRA_COPY_MULTI_ARRAY_DATA(name, op) \
203 template <class SrcIterator, class Shape, class DestIterator> \
205 name##MultiArrayData(SrcIterator s, Shape const & shape, DestIterator d, MetaInt<0>) \
207 SrcIterator send = s + shape[0]; \
208 for(; s < send; ++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>) \
218 Ptr s = &(*si), send = s + shape[0]; \
219 for(; s < send; ++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 SrcIterator send = s + shape[N]; \
230 for(; s < send; ++s, ++d) \
232 name##MultiArrayData(s.begin(), shape, d.begin(), MetaInt<N-1>()); \
236 template <class DestIterator, class Shape, class T> \
238 name##ScalarMultiArrayData(DestIterator d, Shape const & shape, T const & init, MetaInt<0>) \
240 DestIterator dend = d + shape[0]; \
241 for(; d < dend; ++d) \
243 *d op detail::RequiresExplicitCast<typename DestIterator::value_type>::cast(init); \
247 template <class DestIterator, class Shape, class T, int N> \
249 name##ScalarMultiArrayData(DestIterator d, Shape const & shape, T const & init, MetaInt<N>) \
251 DestIterator dend = d + shape[N]; \
252 for(; d < dend; ++d) \
254 name##ScalarMultiArrayData(d.begin(), shape, init, MetaInt<N-1>()); \
258 VIGRA_COPY_MULTI_ARRAY_DATA(copy, =)
259 VIGRA_COPY_MULTI_ARRAY_DATA(copyAdd, +=)
260 VIGRA_COPY_MULTI_ARRAY_DATA(copySub, -=)
261 VIGRA_COPY_MULTI_ARRAY_DATA(copyMul, *=)
262 VIGRA_COPY_MULTI_ARRAY_DATA(copyDiv, /=)
264 #undef VIGRA_COPY_MULTI_ARRAY_DATA
266 template <
class SrcIterator,
class Shape,
class T,
class ALLOC>
268 uninitializedCopyMultiArrayData(SrcIterator s, Shape
const & shape, T * & d, ALLOC & a, MetaInt<0>)
270 SrcIterator send = s + shape[0];
271 for(; s < send; ++s, ++d)
273 a.construct(d, static_cast<T const &>(*s));
278 template <
class Ref,
class Ptr,
class Shape,
class T,
class ALLOC>
280 uninitializedCopyMultiArrayData(MultiIterator<1, UInt8, Ref, Ptr> si, Shape
const & shape, T * & d, ALLOC & a, MetaInt<0>)
282 Ptr s = &(*si), send = s + shape[0];
283 for(; s < send; ++s, ++d)
285 a.construct(d, static_cast<T const &>(*s));
289 template <
class SrcIterator,
class Shape,
class T,
class ALLOC,
int N>
291 uninitializedCopyMultiArrayData(SrcIterator s, Shape
const & shape, T * & d, ALLOC & a, MetaInt<N>)
293 SrcIterator send = s + shape[N];
296 uninitializedCopyMultiArrayData(s.begin(), shape, d, a, MetaInt<N-1>());
300 template <
class SrcIterator,
class Shape,
class T,
class Functor>
302 reduceOverMultiArray(SrcIterator s, Shape
const & shape, T & result, Functor
const & f, MetaInt<0>)
304 SrcIterator send = s + shape[0];
311 template <
class SrcIterator,
class Shape,
class T,
class Functor,
int N>
313 reduceOverMultiArray(SrcIterator s, Shape
const & shape, T & result, Functor
const & f, MetaInt<N>)
315 SrcIterator send = s + shape[N];
318 reduceOverMultiArray(s.begin(), shape, result, f, MetaInt<N-1>());
322 struct MaxNormReduceFunctor
324 template <
class T,
class U>
325 void operator()(T & result, U
const & u)
const
333 struct L1NormReduceFunctor
335 template <
class T,
class U>
336 void operator()(T & result, U
const & u)
const
342 struct SquaredL2NormReduceFunctor
344 template <
class T,
class U>
345 void operator()(T & result, U
const & u)
const
352 struct WeightedL2NormReduceFunctor
356 WeightedL2NormReduceFunctor(T s)
361 void operator()(T & result, U
const & u)
const
367 struct SumReduceFunctor
369 template <
class T,
class U>
370 void operator()(T & result, U
const & u)
const
376 struct ProdReduceFunctor
378 template <
class T,
class U>
379 void operator()(T & result, U
const & u)
const
385 struct MinmaxReduceFunctor
387 template <
class T,
class U>
388 void operator()(T & result, U
const & u)
const
392 if(result.second < u)
397 struct MeanVarianceReduceFunctor
399 template <
class T,
class U>
400 void operator()(T & result, U
const & u)
const
403 typename T::second_type t1 = u - result.second;
404 typename T::second_type t2 = t1 / result.first;
406 result.third += (result.first-1.0)*t1*t2;
410 struct AllTrueReduceFunctor
412 template <
class T,
class U>
413 void operator()(T & result, U
const & u)
const
415 result = result && (u != NumericTraits<U>::zero());
419 struct AnyTrueReduceFunctor
421 template <
class T,
class U>
422 void operator()(T & result, U
const & u)
const
424 result = result || (u != NumericTraits<U>::zero());
428 template <
class SrcIterator,
class Shape,
class DestIterator>
430 equalityOfMultiArrays(SrcIterator s, Shape
const & shape, DestIterator d, MetaInt<0>)
432 SrcIterator send = s + shape[0];
433 for(; s < send; ++s, ++d)
441 template <
class SrcIterator,
class Shape,
class DestIterator,
int N>
443 equalityOfMultiArrays(SrcIterator s, Shape
const & shape, DestIterator d, MetaInt<N>)
445 SrcIterator send = s + shape[N];
446 for(; s < send; ++s, ++d)
448 if(!equalityOfMultiArrays(s.begin(), shape, d.begin(), MetaInt<N-1>()))
455 template <
class SrcIterator,
class Shape,
class DestIterator>
457 swapDataImpl(SrcIterator s, Shape
const & shape, DestIterator d, MetaInt<0>)
459 SrcIterator send = s + shape[0];
460 for(; s < send; ++s, ++d)
464 template <
class SrcIterator,
class Shape,
class DestIterator,
int N>
466 swapDataImpl(SrcIterator s, Shape
const & shape, DestIterator d, MetaInt<N>)
468 SrcIterator send = s + shape[N];
469 for(; s < send; ++s, ++d)
470 swapDataImpl(s.begin(), shape, d.begin(), MetaInt<N-1>());
483 namespace multi_math {
486 struct MultiMathOperand;
488 namespace math_detail {
490 template <
unsigned int N,
class T,
class C,
class E>
491 void assign(MultiArrayView<N, T, C>, MultiMathOperand<E>
const &);
493 template <
unsigned int N,
class T,
class C,
class E>
494 void plusAssign(MultiArrayView<N, T, C>, MultiMathOperand<E>
const &);
496 template <
unsigned int N,
class T,
class C,
class E>
497 void minusAssign(MultiArrayView<N, T, C>, MultiMathOperand<E>
const &);
499 template <
unsigned int N,
class T,
class C,
class E>
500 void multiplyAssign(MultiArrayView<N, T, C>, MultiMathOperand<E>
const &);
502 template <
unsigned int N,
class T,
class C,
class E>
503 void divideAssign(MultiArrayView<N, T, C>, MultiMathOperand<E>
const &);
505 template <
unsigned int N,
class T,
class A,
class E>
506 void assignOrResize(MultiArray<N, T, A> &, MultiMathOperand<E>
const &);
508 template <
unsigned int N,
class T,
class A,
class E>
509 void plusAssignOrResize(MultiArray<N, T, A> &, MultiMathOperand<E>
const &);
511 template <
unsigned int N,
class T,
class A,
class E>
512 void minusAssignOrResize(MultiArray<N, T, A> &, MultiMathOperand<E>
const &);
514 template <
unsigned int N,
class T,
class A,
class E>
515 void multiplyAssignOrResize(MultiArray<N, T, A> &, MultiMathOperand<E>
const &);
517 template <
unsigned int N,
class T,
class A,
class E>
518 void divideAssignOrResize(MultiArray<N, T, A> &, MultiMathOperand<E>
const &);
524 template <
class T>
class FindSum;
526 struct UnsuitableTypeForExpandElements {};
529 struct ExpandElementResult
531 typedef UnsuitableTypeForExpandElements type;
535 struct ExpandElementResult<
std::complex<T> >
545 struct ExpandElementResult<FFTWComplex<T> >
551 template <
class T,
int SIZE>
552 struct ExpandElementResult<TinyVector<T, SIZE> >
555 enum { size = SIZE };
558 template <
class T,
unsigned int R,
unsigned int G,
unsigned int B>
559 struct ExpandElementResult<RGBValue<T, R, G, B> >
565 #define VIGRA_DEFINE_EXPAND_ELEMENT_RESULT(TYPE) \
567 struct ExpandElementResult<TYPE> \
573 VIGRA_DEFINE_EXPAND_ELEMENT_RESULT(
bool)
574 VIGRA_DEFINE_EXPAND_ELEMENT_RESULT(
char)
575 VIGRA_DEFINE_EXPAND_ELEMENT_RESULT(
signed char)
576 VIGRA_DEFINE_EXPAND_ELEMENT_RESULT(
signed short)
577 VIGRA_DEFINE_EXPAND_ELEMENT_RESULT(
signed int)
578 VIGRA_DEFINE_EXPAND_ELEMENT_RESULT(
signed long)
579 VIGRA_DEFINE_EXPAND_ELEMENT_RESULT(
signed long long)
580 VIGRA_DEFINE_EXPAND_ELEMENT_RESULT(
unsigned char)
581 VIGRA_DEFINE_EXPAND_ELEMENT_RESULT(
unsigned short)
582 VIGRA_DEFINE_EXPAND_ELEMENT_RESULT(
unsigned int)
583 VIGRA_DEFINE_EXPAND_ELEMENT_RESULT(
unsigned long)
584 VIGRA_DEFINE_EXPAND_ELEMENT_RESULT(
unsigned long long)
585 VIGRA_DEFINE_EXPAND_ELEMENT_RESULT(
float)
586 VIGRA_DEFINE_EXPAND_ELEMENT_RESULT(
double)
587 VIGRA_DEFINE_EXPAND_ELEMENT_RESULT(
long double)
589 #undef VIGRA_DEFINE_EXPAND_ELEMENT_RESULT
598 template <
unsigned int N,
class T,
class C>
599 struct NormTraits<MultiArrayView<N, T, C> >
601 typedef MultiArrayView<N, T, C> Type;
602 typedef typename NormTraits<T>::SquaredNormType SquaredNormType;
603 typedef typename SquareRootTraits<SquaredNormType>::SquareRootResult NormType;
606 template <
unsigned int N,
class T,
class A>
607 struct NormTraits<MultiArray<N, T, A> >
608 :
public NormTraits<typename MultiArray<N, T, A>::view_type>
610 typedef NormTraits<typename MultiArray<N, T, A>::view_type> BaseType;
611 typedef MultiArray<N, T, A> Type;
612 typedef typename BaseType::SquaredNormType SquaredNormType;
613 typedef typename BaseType::NormType NormType;
654 template <
unsigned int N,
class T,
class Str
ideTag>
714 typedef typename vigra::detail::MultiIteratorChooser <
715 StrideTag>::template Traverser <actual_dimension, T, T &, T *>::type
traverser;
719 typedef typename vigra::detail::MultiIteratorChooser <
720 StrideTag>::template Traverser <actual_dimension, T, T const &, T const *>::type
const_traverser;
742 typedef typename difference_type::value_type diff_zero_t;
760 template <
class U,
class CN>
763 template <
class U,
class CN>
769 template <
class U,
class CN>
781 : m_shape (diff_zero_t(0)), m_stride (diff_zero_t(0)), m_ptr (0)
788 template <
class Str
ide>
790 : m_shape (other.shape()),
791 m_stride (other.
stride()),
794 vigra_precondition(other.checkInnerStride(StrideTag()),
795 "MultiArrayView<..., UnstridedArrayTag>(MultiArrayView const &): cannot create unstrided view from strided array.");
802 m_stride (detail::defaultStride<actual_dimension>(shape)),
803 m_ptr (const_cast<pointer>(ptr))
812 const difference_type &
stride,
816 m_ptr (const_cast<pointer>(ptr))
818 vigra_precondition(checkInnerStride(StrideTag()),
819 "MultiArrayView<..., UnstridedArrayTag>::MultiArrayView(): First dimension of given array is not unstrided.");
827 template <
class ALLOC>
830 m_stride (detail::defaultStride<actual_dimension>(m_shape)),
831 m_ptr (const_cast<pointer>(image.
data()))
858 template<
class Str
ide2>
869 template<
class U,
class C1>
872 vigra_precondition(this->
shape() == rhs.
shape(),
873 "MultiArrayView::operator=(): shape mismatch.");
888 template<
class U,
class C1>
894 template<
class U,
class C1>
900 template<
class U,
class C1>
906 template<
class U,
class C1>
913 detail::copyAddScalarMultiArrayData(
traverser_begin(),
shape(), rhs, MetaInt<actual_dimension-1>());
921 detail::copySubScalarMultiArrayData(
traverser_begin(),
shape(), rhs, MetaInt<actual_dimension-1>());
929 detail::copyMulScalarMultiArrayData(
traverser_begin(),
shape(), rhs, MetaInt<actual_dimension-1>());
937 detail::copyDivScalarMultiArrayData(
traverser_begin(),
shape(), rhs, MetaInt<actual_dimension-1>());
944 template<
class Expression>
947 multi_math::math_detail::assign(*
this, rhs);
954 template<
class Expression>
957 multi_math::math_detail::plusAssign(*
this, rhs);
964 template<
class Expression>
967 multi_math::math_detail::minusAssign(*
this, rhs);
974 template<
class Expression>
977 multi_math::math_detail::multiplyAssign(*
this, rhs);
984 template<
class Expression>
987 multi_math::math_detail::divideAssign(*
this, rhs);
995 VIGRA_ASSERT_INSIDE(d);
996 return m_ptr [
dot (d, m_stride)];
1003 VIGRA_ASSERT_INSIDE(d);
1004 return m_ptr [
dot (d, m_stride)];
1028 return m_ptr [detail::ScanOrderToOffset<actual_dimension>::exec(d, m_shape, m_stride)];
1044 return m_ptr [detail::ScanOrderToOffset<actual_dimension>::exec(d, m_shape, m_stride)];
1051 difference_type result;
1052 detail::ScanOrderToCoordinate<actual_dimension>::exec(d, m_shape, result);
1060 return detail::CoordinateToScanOrder<actual_dimension>::exec(m_shape, d);
1068 return m_ptr [detail::CoordinatesToOffest<StrideTag>::exec(m_stride, x)];
1076 return m_ptr [detail::CoordinatesToOffest<StrideTag>::exec(m_stride, x, y)];
1081 reference
operator() (difference_type_1 x, difference_type_1 y, difference_type_1 z)
1084 return m_ptr [m_stride[0]*x + m_stride[1]*y + m_stride[2]*z];
1090 difference_type_1 z, difference_type_1 u)
1093 return m_ptr [m_stride[0]*x + m_stride[1]*y + m_stride[2]*z + m_stride[3]*u];
1098 reference
operator() (difference_type_1 x, difference_type_1 y, difference_type_1 z,
1099 difference_type_1 u, difference_type_1 v)
1102 return m_ptr [m_stride[0]*x + m_stride[1]*y + m_stride[2]*z + m_stride[3]*u + m_stride[4]*v];
1110 return m_ptr [detail::CoordinatesToOffest<StrideTag>::exec(m_stride, x)];
1115 const_reference
operator() (difference_type_1 x, difference_type_1 y)
const
1118 return m_ptr [detail::CoordinatesToOffest<StrideTag>::exec(m_stride, x, y)];
1123 const_reference
operator() (difference_type_1 x, difference_type_1 y, difference_type_1 z)
const
1126 return m_ptr [m_stride[0]*x + m_stride[1]*y + m_stride[2]*z];
1131 const_reference
operator() (difference_type_1 x, difference_type_1 y,
1132 difference_type_1 z, difference_type_1 u)
const
1135 return m_ptr [m_stride[0]*x + m_stride[1]*y + m_stride[2]*z + m_stride[3]*u];
1140 const_reference
operator() (difference_type_1 x, difference_type_1 y, difference_type_1 z,
1141 difference_type_1 u, difference_type_1 v)
const
1144 return m_ptr [m_stride[0]*x + m_stride[1]*y + m_stride[2]*z + m_stride[3]*u + m_stride[4]*v];
1153 detail::copyScalarMultiArrayData(
traverser_begin(),
shape(), init, MetaInt<actual_dimension-1>());
1164 this->copyImpl(rhs);
1169 template <
class U,
class CN>
1172 this->copyImpl(rhs);
1189 template <
class T2,
class C2>
1203 difference_type s = vigra::detail::defaultStride<actual_dimension>(
shape());
1204 for(
unsigned int k = 0; k <= dimension; ++k)
1224 template <
int M,
class Index>
1241 template <
int M,
class Index>
1261 template <
unsigned int M>
1262 MultiArrayView <N-1, T,
typename vigra::detail::MaybeStrided<StrideTag, M>::type >
1263 bind (difference_type_1 d)
const;
1312 bindAt (difference_type_1 m, difference_type_1 d)
const;
1333 vigra_precondition(0 <= i && i < ExpandElementResult<T>::size,
1334 "MultiArrayView::bindElementChannel(i): 'i' out of range.");
1433 detail::RelativeToAbsoluteCoordinate<actual_dimension-1>::exec(
shape(), p);
1434 detail::RelativeToAbsoluteCoordinate<actual_dimension-1>::exec(
shape(), q);
1435 const difference_type_1 offset =
dot (m_stride, p);
1448 difference_type shape =
m_shape;
1449 for (
unsigned int i = 0; i < actual_dimension; ++i)
1472 difference_type
shape(m_shape.begin(), difference_type::ReverseCopy),
1473 stride(m_stride.begin(), difference_type::ReverseCopy);
1498 return permuteDimensions(permutation);
1502 permuteDimensions (
const difference_type &s)
const;
1535 difference_type_1 ret = m_shape[0];
1536 for(
int i = 1; i < actual_dimension; ++i)
1558 difference_type_1
size (difference_type_1 n)
const
1566 difference_type_1
shape (difference_type_1 n)
const
1596 return m_stride [n];
1601 template <
class U,
class C1>
1612 template <
class U,
class C1>
1622 for(
int d=0; d<actual_dimension; ++d)
1623 if(p[d] < 0 || p[d] >=
shape(d))
1636 detail::AllTrueReduceFunctor(),
1637 MetaInt<actual_dimension-1>());
1649 detail::AnyTrueReduceFunctor(),
1650 MetaInt<actual_dimension-1>());
1660 std::pair<T, T> res(NumericTraits<T>::max(), NumericTraits<T>::min());
1663 detail::MinmaxReduceFunctor(),
1664 MetaInt<actual_dimension-1>());
1665 *minimum = res.first;
1666 *maximum = res.second;
1676 typedef typename NumericTraits<U>::RealPromote R;
1678 triple<double, R, R> res(0.0, zero, zero);
1681 detail::MeanVarianceReduceFunctor(),
1682 MetaInt<actual_dimension-1>());
1684 *variance = res.third / res.first;
1699 U res = NumericTraits<U>::zero();
1702 detail::SumReduceFunctor(),
1703 MetaInt<actual_dimension-1>());
1732 template <
class U,
class S>
1736 destMultiArrayRange(sums),
1752 U res = NumericTraits<U>::one();
1755 detail::ProdReduceFunctor(),
1756 MetaInt<actual_dimension-1>());
1762 typename NormTraits<MultiArrayView>::SquaredNormType
1765 typedef typename NormTraits<MultiArrayView>::SquaredNormType SquaredNormType;
1766 SquaredNormType res = NumericTraits<SquaredNormType>::zero();
1769 detail::SquaredL2NormReduceFunctor(),
1770 MetaInt<actual_dimension-1>());
1787 typename NormTraits<MultiArrayView>::NormType
1788 norm(
int type = 2,
bool useSquaredNorm =
true)
const;
1797 pointer & unsafePtr()
1833 return begin().getEndIterator();
1841 return begin().getEndIterator();
1849 traverser ret (m_ptr, m_stride.begin (), m_shape.begin ());
1858 const_traverser ret (m_ptr, m_stride.begin (), m_shape.begin ());
1868 traverser ret (m_ptr, m_stride.begin (), m_shape.begin ());
1869 ret += m_shape [actual_dimension-1];
1879 const_traverser ret (m_ptr, m_stride.begin (), m_shape.begin ());
1880 ret += m_shape [actual_dimension-1];
1890 template <
unsigned int N,
class T,
class Str
ide1>
1891 template <
class Str
ide2>
1893 MultiArrayView <N, T, Stride1>::assignImpl(MultiArrayView<N, T, Stride2>
const & rhs)
1897 vigra_precondition(rhs.checkInnerStride(Stride1()),
1898 "MultiArrayView<..., UnstridedArrayTag>::operator=(MultiArrayView const &): cannot create unstrided view from strided array.");
1906 vigra_precondition(this->
shape() == rhs.shape(),
1907 "MultiArrayView::operator=(MultiArrayView const &): shape mismatch.");
1908 this->copyImpl(rhs);
1912 template <
unsigned int N,
class T,
class Str
ideTag>
1915 MultiArrayView <N, T, StrideTag>::arraysOverlap(
const MultiArrayView <N, T, CN>& rhs)
const
1917 vigra_precondition (shape () == rhs.shape (),
1918 "MultiArrayView::arraysOverlap(): shape mismatch.");
1921 typename MultiArrayView <N, T, CN>::const_pointer
1922 rhs_first_element = rhs.data(),
1923 rhs_last_element = rhs_first_element +
dot(rhs.shape() -
difference_type(1), rhs.stride());
1924 return !(last_element < rhs_first_element || rhs_last_element < first_element);
1927 template <
unsigned int N,
class T,
class Str
ideTag>
1928 template <
class U,
class CN>
1930 MultiArrayView <N, T, StrideTag>::copyImpl(
const MultiArrayView <N, U, CN>& rhs)
1932 if(!arraysOverlap(rhs))
1935 detail::copyMultiArrayData(rhs.traverser_begin(),
shape(),
traverser_begin(), MetaInt<actual_dimension-1>());
1941 MultiArray<N, T> tmp(rhs);
1942 detail::copyMultiArrayData(tmp.traverser_begin(),
shape(),
traverser_begin(), MetaInt<actual_dimension-1>());
1946 #define VIGRA_MULTI_ARRAY_COMPUTED_ASSIGNMENT(name, op) \
1947 template <unsigned int N, class T, class StrideTag> \
1948 template<class U, class C1> \
1949 MultiArrayView<N, T, StrideTag> & \
1950 MultiArrayView <N, T, StrideTag>::operator op(MultiArrayView<N, U, C1> const & rhs) \
1952 vigra_precondition(this->shape() == rhs.shape(), "MultiArrayView::operator" #op "() size mismatch."); \
1953 if(!arraysOverlap(rhs)) \
1955 detail::name##MultiArrayData(rhs.traverser_begin(), shape(), traverser_begin(), MetaInt<actual_dimension-1>()); \
1959 MultiArray<N, T> tmp(rhs); \
1960 detail::name##MultiArrayData(tmp.traverser_begin(), shape(), traverser_begin(), MetaInt<actual_dimension-1>()); \
1965 VIGRA_MULTI_ARRAY_COMPUTED_ASSIGNMENT(copyAdd, +=)
1966 VIGRA_MULTI_ARRAY_COMPUTED_ASSIGNMENT(copySub, -=)
1967 VIGRA_MULTI_ARRAY_COMPUTED_ASSIGNMENT(copyMul, *=)
1968 VIGRA_MULTI_ARRAY_COMPUTED_ASSIGNMENT(copyDiv, /=)
1970 #undef VIGRA_MULTI_ARRAY_COMPUTED_ASSIGNMENT
1972 template <
unsigned int N,
class T,
class Str
ideTag>
1973 template <
class U,
class CN>
1975 MultiArrayView <N, T, StrideTag>::swapDataImpl(MultiArrayView <N, U, CN> rhs)
1977 vigra_precondition (shape () == rhs.shape (),
1978 "MultiArrayView::swapData(): shape mismatch.");
1983 typename MultiArrayView <N, U, CN>::const_pointer
1984 rhs_first_element = rhs.data(),
1985 rhs_last_element = rhs_first_element +
dot(rhs.shape() -
difference_type(1), rhs.stride());
1986 if(last_element < rhs_first_element || rhs_last_element < first_element)
1989 detail::swapDataImpl(
traverser_begin(),
shape(), rhs.traverser_begin(), MetaInt<actual_dimension-1>());
1995 MultiArray<N, T> tmp(*
this);
2001 template <
unsigned int N,
class T,
class Str
ideTag>
2002 MultiArrayView <N, T, StridedArrayTag>
2003 MultiArrayView <N, T, StrideTag>::permuteDimensions (
const difference_type &s)
const
2006 for (
unsigned int i = 0; i < actual_dimension; ++i)
2008 shape[i] = m_shape[s[i]];
2013 "MultiArrayView::transpose(): every dimension must occur exactly once.");
2017 template <
unsigned int N,
class T,
class Str
ideTag>
2018 typename MultiArrayView <N, T, StrideTag>::difference_type
2022 for(
int k=0; k<(int)N; ++k)
2024 for(
int k=0; k<(int)N-1; ++k)
2027 for(
int j=k+1; j<(int)N; ++j)
2029 if(stride[j] < stride[smallest])
2034 std::swap(stride[k], stride[smallest]);
2035 std::swap(permutation[k], permutation[smallest]);
2039 for(
unsigned int k=0; k<N; ++k)
2040 ordering[permutation[k]] = k;
2044 template <
unsigned int N,
class T,
class Str
ideTag>
2050 permutation[ordering[k]] = k;
2051 return permuteDimensions(permutation);
2054 template <
unsigned int N,
class T,
class Str
ideTag>
2060 permutation[N-1-ordering[k]] = k;
2061 return permuteDimensions(permutation);
2064 template <
unsigned int N,
class T,
class Str
ideTag>
2065 template <
int M,
class Index>
2072 static const int NNew = (N-M == 0) ? 1 : N-M;
2076 inner_shape [0] = 1;
2077 inner_stride [0] = 1;
2081 inner_shape.
init (m_shape.begin (), m_shape.end () - M);
2084 return MultiArrayView <N-M, T, StrideTag> (inner_shape, inner_stride, ptr);
2087 template <
unsigned int N,
class T,
class Str
ideTag>
2088 template <
int M,
class Index>
2095 static const int NNew = (N-M == 0) ? 1 : N-M;
2099 outer_shape [0] = 1;
2100 outer_stride [0] = 1;
2104 outer_shape.
init (m_shape.begin () + M, m_shape.end ());
2108 (outer_shape, outer_stride, ptr);
2111 template <
unsigned int N,
class T,
class Str
ideTag>
2112 template <
unsigned int M>
2113 MultiArrayView <N-1, T,
typename detail::MaybeStrided<StrideTag, M>::type >
2116 static const int NNew = (N-1 == 0) ? 1 : N-1;
2126 std::copy (m_shape.begin (), m_shape.begin () + M, shape.
begin ());
2127 std::copy (m_shape.begin () + M+1, m_shape.end (),
2128 shape.
begin () + M);
2131 stride.
begin () + M);
2133 return MultiArrayView <N-1, T,
typename detail::MaybeStrided<StrideTag, M>::type>
2137 template <
unsigned int N,
class T,
class Str
ideTag>
2141 static const int NNew = (N-1 == 0) ? 1 : N-1;
2145 inner_shape [0] = 1;
2146 inner_stride [0] = 1;
2150 inner_shape.
init (m_shape.begin (), m_shape.end () - 1);
2153 return MultiArrayView <N-1, T, StrideTag> (inner_shape, inner_stride,
2157 template <
unsigned int N,
class T,
class Str
ideTag>
2161 static const int NNew = (N-1 == 0) ? 1 : N-1;
2165 outer_shape [0] = 1;
2166 outer_stride [0] = 1;
2170 outer_shape.
init (m_shape.begin () + 1, m_shape.end ());
2177 template <
unsigned int N,
class T,
class Str
ideTag>
2181 vigra_precondition (
2182 n < static_cast <int> (N),
2183 "MultiArrayView <N, T, StrideTag>::bindAt(): dimension out of range.");
2184 static const int NNew = (N-1 == 0) ? 1 : N-1;
2194 std::copy (m_shape.begin (), m_shape.begin () + n, shape.
begin ());
2195 std::copy (m_shape.begin () + n+1, m_shape.
end (),
2196 shape.
begin () + n);
2199 stride.
begin () + n);
2206 template <
unsigned int N,
class T,
class Str
ideTag>
2210 vigra_precondition(0 <= d && d <= static_cast <difference_type_1> (N),
2211 "MultiArrayView<N, ...>::expandElements(d): 0 <= 'd' <= N required.");
2213 int elementSize = ExpandElementResult<T>::size;
2215 for(
int k=0; k<d; ++k)
2217 newShape[k] = m_shape[k];
2218 newStrides[k] =
m_stride[k]*elementSize;
2221 newShape[d] = elementSize;
2224 for(
int k=d; k<N; ++k)
2226 newShape[k+1] = m_shape[k];
2227 newStrides[k+1] =
m_stride[k]*elementSize;
2230 typedef typename ExpandElementResult<T>::type U;
2232 newShape, newStrides,
reinterpret_cast<U*
>(
m_ptr));
2235 template <
unsigned int N,
class T,
class Str
ideTag>
2239 vigra_precondition (
2240 0 <= i && i <= static_cast <difference_type_1> (N),
2241 "MultiArrayView <N, T, StrideTag>::insertSingletonDimension(): index out of range.");
2243 std::copy (m_shape.begin (), m_shape.begin () + i, shape.
begin ());
2244 std::copy (m_shape.begin () + i, m_shape.end (), shape.
begin () + i + 1);
2253 template <
unsigned int N,
class T,
class Str
ideTag>
2254 typename NormTraits<MultiArrayView <N, T, StrideTag> >::NormType
2257 typedef typename NormTraits<MultiArrayView>::NormType NormType;
2263 NormType res = NumericTraits<NormType>::zero();
2266 detail::MaxNormReduceFunctor(),
2267 MetaInt<actual_dimension-1>());
2272 NormType res = NumericTraits<NormType>::zero();
2275 detail::L1NormReduceFunctor(),
2276 MetaInt<actual_dimension-1>());
2287 NormType normMax = NumericTraits<NormType>::zero();
2290 detail::MaxNormReduceFunctor(),
2291 MetaInt<actual_dimension-1>());
2292 if(normMax == NumericTraits<NormType>::zero())
2294 NormType res = NumericTraits<NormType>::zero();
2297 detail::WeightedL2NormReduceFunctor<NormType>(1.0/normMax),
2298 MetaInt<actual_dimension-1>());
2299 return sqrt(res)*normMax;
2303 vigra_precondition(
false,
"MultiArrayView::norm(): Unknown norm type.");
2304 return NumericTraits<NormType>::zero();
2315 template <
unsigned int N,
class T,
class Str
ideTag>
2316 inline typename NormTraits<MultiArrayView <N, T, StrideTag> >::SquaredNormType
2322 template <
unsigned int N,
class T,
class Str
ideTag>
2323 inline typename NormTraits<MultiArrayView <N, T, StrideTag> >::NormType
2324 norm(MultiArrayView <N, T, StrideTag>
const & a)
2356 template <
unsigned int N,
class T,
class A >
2358 :
public MultiArrayView <N, typename vigra::detail::ResolveMultiband<T>::type,
2359 typename vigra::detail::ResolveMultiband<T>::Stride>
2369 using view_type::actual_dimension;
2439 typedef typename difference_type::value_type diff_zero_t;
2448 void allocate (pointer &ptr, difference_type_1 s, const_reference init);
2454 void allocate (pointer &ptr, difference_type_1 s, U
const * init);
2459 template <
class U,
class Str
ideTag>
2464 void deallocate (pointer &ptr, difference_type_1 s);
2466 template <
class U,
class Str
ideTag>
2472 : view_type (difference_type (diff_zero_t(0)),
2473 difference_type (diff_zero_t(0)), 0)
2479 : view_type(difference_type (diff_zero_t(0)),
2480 difference_type (diff_zero_t(0)), 0),
2488 explicit MultiArray (difference_type_1 length,
2489 allocator_type
const & alloc = allocator_type());
2497 allocator_type
const & alloc = allocator_type());
2501 explicit MultiArray (
const difference_type &shape,
2502 allocator_type
const & alloc = allocator_type());
2506 MultiArray (
const difference_type &shape, const_reference init,
2507 allocator_type
const & alloc = allocator_type());
2511 MultiArray (
const difference_type &shape, const_pointer init,
2512 allocator_type
const & alloc = allocator_type());
2517 : view_type(rhs.m_shape, rhs.
m_stride, 0),
2518 m_alloc (rhs.m_alloc)
2525 template<
class Expression>
2526 MultiArray (multi_math::MultiMathOperand<Expression>
const & rhs,
2527 allocator_type
const & alloc = allocator_type())
2528 : view_type(difference_type (diff_zero_t(0)),
2529 difference_type (diff_zero_t(0)), 0),
2532 multi_math::math_detail::assignOrResize(*
this, rhs);
2537 template <
class U,
class Str
ideTag>
2539 allocator_type
const & alloc = allocator_type());
2549 this->copyOrReshape(rhs);
2558 template <
class U,
class Str
ideTag>
2561 this->copyOrReshape(rhs);
2570 return this->
init(v);
2579 template <
class U,
class Str
ideTag>
2595 template <
class U,
class Str
ideTag>
2599 this->reshape(rhs.
shape());
2610 template <
class U,
class Str
ideTag>
2616 this->reshape(rhs.
shape());
2626 template <
class U,
class Str
ideTag>
2632 this->reshape(rhs.
shape());
2670 template<
class Expression>
2673 multi_math::math_detail::assignOrResize(*
this, rhs);
2680 template<
class Expression>
2683 multi_math::math_detail::plusAssignOrResize(*
this, rhs);
2690 template<
class Expression>
2693 multi_math::math_detail::minusAssignOrResize(*
this, rhs);
2700 template<
class Expression>
2703 multi_math::math_detail::multiplyAssignOrResize(*
this, rhs);
2710 template<
class Expression>
2713 multi_math::math_detail::divideAssignOrResize(*
this, rhs);
2748 void reshape (
const difference_type &shape, const_reference init);
2792 static difference_type defaultStride(difference_type
const & shape)
2794 return vigra::detail::ResolveMultiband<T>::defaultStride(shape);
2798 template <
unsigned int N,
class T,
class A>
2800 allocator_type
const & alloc)
2809 template <
unsigned int N,
class T,
class A>
2811 allocator_type
const & alloc)
2820 template <
unsigned int N,
class T,
class A>
2822 allocator_type
const & alloc)
2824 defaultStride(shape),
2830 this->m_shape [0] = 1;
2836 template <
unsigned int N,
class T,
class A>
2838 allocator_type
const & alloc)
2840 defaultStride(shape),
2846 this->m_shape [0] = 1;
2852 template <
unsigned int N,
class T,
class A>
2854 allocator_type
const & alloc)
2856 defaultStride(shape),
2862 this->m_shape [0] = 1;
2868 template <
unsigned int N,
class T,
class A>
2869 template <
class U,
class Str
ideTag>
2871 allocator_type
const & alloc)
2873 defaultStride(rhs.shape()),
2877 allocate (this->
m_ptr, rhs);
2880 template <
unsigned int N,
class T,
class A>
2881 template <
class U,
class Str
ideTag>
2885 if (this->
shape() == rhs.shape())
2894 template <
unsigned int N,
class T,
class A>
2896 const_reference initial)
2902 else if(new_shape == this->
shape())
2904 this->
init(initial);
2908 difference_type new_stride = defaultStride(new_shape);
2909 difference_type_1 new_size =
prod(new_shape);
2911 allocate (new_ptr, new_size, initial);
2913 this->
m_ptr = new_ptr;
2914 this->m_shape = new_shape;
2920 template <
unsigned int N,
class T,
class A>
2926 std::swap(this->m_shape, other.m_shape);
2927 std::swap(this->
m_stride, other.m_stride);
2928 std::swap(this->
m_ptr, other.m_ptr);
2929 std::swap(this->m_alloc, other.m_alloc);
2932 template <
unsigned int N,
class T,
class A>
2934 const_reference
init)
2941 ptr = m_alloc.
allocate ((
typename A::size_type)s);
2942 difference_type_1 i;
2944 for (i = 0; i < s; ++i)
2945 m_alloc.construct (ptr + i, init);
2948 for (difference_type_1 j = 0; j < i; ++j)
2949 m_alloc.destroy (ptr + j);
2950 m_alloc.deallocate (ptr, (
typename A::size_type)s);
2955 template <
unsigned int N,
class T,
class A>
2965 ptr = m_alloc.
allocate ((
typename A::size_type)s);
2966 difference_type_1 i;
2968 for (i = 0; i < s; ++i, ++
init)
2969 m_alloc.construct (ptr + i, *init);
2972 for (difference_type_1 j = 0; j < i; ++j)
2973 m_alloc.destroy (ptr + j);
2974 m_alloc.deallocate (ptr, (
typename A::size_type)s);
2979 template <
unsigned int N,
class T,
class A>
2980 template <
class U,
class Str
ideTag>
2983 difference_type_1 s = init.elementCount();
2989 ptr = m_alloc.
allocate ((
typename A::size_type)s);
2992 detail::uninitializedCopyMultiArrayData(init.traverser_begin(), init.shape(),
2993 p, m_alloc, MetaInt<actual_dimension-1>());
2996 for (pointer pp = ptr; pp < p; ++pp)
2997 m_alloc.destroy (pp);
2998 m_alloc.deallocate (ptr, (
typename A::size_type)s);
3003 template <
unsigned int N,
class T,
class A>
3008 for (difference_type_1 i = 0; i < s; ++i)
3009 m_alloc.destroy (ptr + i);
3010 m_alloc.
deallocate (ptr, (
typename A::size_type)s);
3020 template <
unsigned int N,
class T,
class Str
ideTag>
3021 inline triple<typename MultiArrayView<N,T,StrideTag>::const_traverser,
3026 return triple<typename MultiArrayView<N,T,StrideTag>::const_traverser,
3027 typename MultiArrayView<N,T,StrideTag>::difference_type,
3034 template <
unsigned int N,
class T,
class Str
ideTag,
class Accessor>
3035 inline triple<typename MultiArrayView<N,T,StrideTag>::const_traverser,
3036 typename MultiArrayView<N,T,StrideTag>::difference_type,
3038 srcMultiArrayRange( MultiArrayView<N,T,StrideTag>
const & array, Accessor a )
3040 return triple<typename MultiArrayView<N,T,StrideTag>::const_traverser,
3041 typename MultiArrayView<N,T,StrideTag>::difference_type,
3043 ( array.traverser_begin(),
3048 template <
unsigned int N,
class T,
class Str
ideTag>
3049 inline pair<typename MultiArrayView<N,T,StrideTag>::const_traverser,
3050 typename AccessorTraits<T>::default_const_accessor >
3051 srcMultiArray( MultiArrayView<N,T,StrideTag>
const & array )
3053 return pair<typename MultiArrayView<N,T,StrideTag>::const_traverser,
3054 typename AccessorTraits<T>::default_const_accessor >
3055 ( array.traverser_begin(),
3056 typename AccessorTraits<T>::default_const_accessor() );
3059 template <
unsigned int N,
class T,
class Str
ideTag,
class Accessor>
3060 inline pair<typename MultiArrayView<N,T,StrideTag>::const_traverser,
3062 srcMultiArray( MultiArrayView<N,T,StrideTag>
const & array, Accessor a )
3064 return pair<typename MultiArrayView<N,T,StrideTag>::const_traverser,
3066 ( array.traverser_begin(), a );
3069 template <
unsigned int N,
class T,
class Str
ideTag>
3070 inline triple<typename MultiArrayView<N,T,StrideTag>::traverser,
3071 typename MultiArrayView<N,T,StrideTag>::difference_type,
3072 typename AccessorTraits<T>::default_accessor >
3073 destMultiArrayRange( MultiArrayView<N,T,StrideTag> & array )
3075 return triple<typename MultiArrayView<N,T,StrideTag>::traverser,
3076 typename MultiArrayView<N,T,StrideTag>::difference_type,
3077 typename AccessorTraits<T>::default_accessor >
3078 ( array.traverser_begin(),
3080 typename AccessorTraits<T>::default_accessor() );
3083 template <
unsigned int N,
class T,
class Str
ideTag,
class Accessor>
3084 inline triple<typename MultiArrayView<N,T,StrideTag>::traverser,
3085 typename MultiArrayView<N,T,StrideTag>::difference_type,
3087 destMultiArrayRange( MultiArrayView<N,T,StrideTag> & array, Accessor a )
3089 return triple<typename MultiArrayView<N,T,StrideTag>::traverser,
3090 typename MultiArrayView<N,T,StrideTag>::difference_type,
3092 ( array.traverser_begin(),
3097 template <
unsigned int N,
class T,
class Str
ideTag>
3098 inline pair<typename MultiArrayView<N,T,StrideTag>::traverser,
3099 typename AccessorTraits<T>::default_accessor >
3100 destMultiArray( MultiArrayView<N,T,StrideTag> & array )
3102 return pair<typename MultiArrayView<N,T,StrideTag>::traverser,
3103 typename AccessorTraits<T>::default_accessor >
3104 ( array.traverser_begin(),
3105 typename AccessorTraits<T>::default_accessor() );
3108 template <
unsigned int N,
class T,
class Str
ideTag,
class Accessor>
3109 inline pair<typename MultiArrayView<N,T,StrideTag>::traverser,
3111 destMultiArray( MultiArrayView<N,T,StrideTag> & array, Accessor a )
3113 return pair<typename MultiArrayView<N,T,StrideTag>::traverser,
3115 ( array.traverser_begin(), a );
3120 template <
class PixelType,
class Accessor>
3121 inline triple<ConstStridedImageIterator<PixelType>,
3122 ConstStridedImageIterator<PixelType>, Accessor>
3123 srcImageRange(
const MultiArrayView<2, PixelType, StridedArrayTag> & img, Accessor a)
3125 ConstStridedImageIterator<PixelType>
3126 ul(img.data(), 1, img.stride(0), img.stride(1));
3127 return triple<ConstStridedImageIterator<PixelType>,
3128 ConstStridedImageIterator<PixelType>,
3130 ul, ul + Size2D(img.shape(0), img.shape(1)), a);
3133 template <
class PixelType,
class Accessor>
3134 inline pair<ConstStridedImageIterator<PixelType>, Accessor>
3135 srcImage(
const MultiArrayView<2, PixelType, StridedArrayTag> & img, Accessor a)
3137 ConstStridedImageIterator<PixelType>
3138 ul(img.data(), 1, img.stride(0), img.stride(1));
3139 return pair<ConstStridedImageIterator<PixelType>, Accessor>
3143 template <
class PixelType,
class Accessor>
3144 inline triple<StridedImageIterator<PixelType>,
3145 StridedImageIterator<PixelType>, Accessor>
3146 destImageRange(MultiArrayView<2, PixelType, StridedArrayTag> & img, Accessor a)
3148 StridedImageIterator<PixelType>
3149 ul(img.data(), 1, img.stride(0), img.stride(1));
3150 return triple<StridedImageIterator<PixelType>,
3151 StridedImageIterator<PixelType>,
3153 ul, ul + Size2D(img.shape(0), img.shape(1)), a);
3156 template <
class PixelType,
class Accessor>
3157 inline pair<StridedImageIterator<PixelType>, Accessor>
3158 destImage(MultiArrayView<2, PixelType, StridedArrayTag> & img, Accessor a)
3160 StridedImageIterator<PixelType>
3161 ul(img.data(), 1, img.stride(0), img.stride(1));
3162 return pair<StridedImageIterator<PixelType>, Accessor>
3166 template <
class PixelType,
class Accessor>
3167 inline pair<StridedImageIterator<PixelType>, Accessor>
3168 maskImage(MultiArrayView<2, PixelType, StridedArrayTag> & img, Accessor a)
3170 StridedImageIterator<PixelType>
3171 ul(img.data(), 1, img.stride(0), img.stride(1));
3172 return pair<StridedImageIterator<PixelType>, Accessor>
3178 template <
class PixelType>
3179 inline triple<ConstStridedImageIterator<PixelType>,
3180 ConstStridedImageIterator<PixelType>,
3181 typename AccessorTraits<PixelType>::default_const_accessor>
3182 srcImageRange(MultiArrayView<2, PixelType, StridedArrayTag>
const & img)
3184 ConstStridedImageIterator<PixelType>
3185 ul(img.data(), 1, img.stride(0), img.stride(1));
3186 typedef typename AccessorTraits<PixelType>::default_const_accessor Accessor;
3187 return triple<ConstStridedImageIterator<PixelType>,
3188 ConstStridedImageIterator<PixelType>,
3190 (ul, ul + Size2D(img.shape(0), img.shape(1)), Accessor());
3193 template <
class PixelType>
3194 inline triple<ConstImageIterator<PixelType>,
3195 ConstImageIterator<PixelType>,
3196 typename AccessorTraits<PixelType>::default_const_accessor>
3197 srcImageRange(MultiArrayView<2, PixelType, UnstridedArrayTag>
const & img)
3199 ConstImageIterator<PixelType>
3200 ul(img.data(), img.stride(1));
3201 typedef typename AccessorTraits<PixelType>::default_const_accessor Accessor;
3202 return triple<ConstImageIterator<PixelType>,
3203 ConstImageIterator<PixelType>,
3205 (ul, ul + Size2D(img.shape(0), img.shape(1)), Accessor());
3208 template <
class PixelType>
3209 inline pair< ConstStridedImageIterator<PixelType>,
3210 typename AccessorTraits<PixelType>::default_const_accessor>
3211 srcImage(MultiArrayView<2, PixelType, StridedArrayTag>
const & img)
3213 ConstStridedImageIterator<PixelType>
3214 ul(img.data(), 1, img.stride(0), img.stride(1));
3215 typedef typename AccessorTraits<PixelType>::default_const_accessor Accessor;
3216 return pair<ConstStridedImageIterator<PixelType>,
3221 template <
class PixelType>
3222 inline pair< ConstImageIterator<PixelType>,
3223 typename AccessorTraits<PixelType>::default_const_accessor>
3224 srcImage(MultiArrayView<2, PixelType, UnstridedArrayTag>
const & img)
3226 ConstImageIterator<PixelType>
3227 ul(img.data(), img.stride(1));
3228 typedef typename AccessorTraits<PixelType>::default_const_accessor Accessor;
3229 return pair<ConstImageIterator<PixelType>,
3234 template <
class PixelType>
3235 inline triple< StridedImageIterator<PixelType>,
3236 StridedImageIterator<PixelType>,
3237 typename AccessorTraits<PixelType>::default_accessor>
3238 destImageRange(MultiArrayView<2, PixelType, StridedArrayTag> & img)
3240 StridedImageIterator<PixelType>
3241 ul(img.data(), 1, img.stride(0), img.stride(1));
3242 typedef typename AccessorTraits<PixelType>::default_accessor Accessor;
3243 return triple<StridedImageIterator<PixelType>,
3244 StridedImageIterator<PixelType>,
3246 (ul, ul + Size2D(img.shape(0), img.shape(1)), Accessor());
3249 template <
class PixelType>
3250 inline triple< ImageIterator<PixelType>,
3251 ImageIterator<PixelType>,
3252 typename AccessorTraits<PixelType>::default_accessor>
3253 destImageRange(MultiArrayView<2, PixelType, UnstridedArrayTag> & img)
3255 ImageIterator<PixelType>
3256 ul(img.data(), img.stride(1));
3257 typedef typename AccessorTraits<PixelType>::default_accessor Accessor;
3258 return triple<ImageIterator<PixelType>,
3259 ImageIterator<PixelType>,
3261 (ul, ul + Size2D(img.shape(0), img.shape(1)), Accessor());
3264 template <
class PixelType>
3265 inline pair< StridedImageIterator<PixelType>,
3266 typename AccessorTraits<PixelType>::default_accessor>
3267 destImage(MultiArrayView<2, PixelType, StridedArrayTag> & img)
3269 StridedImageIterator<PixelType>
3270 ul(img.data(), 1, img.stride(0), img.stride(1));
3271 typedef typename AccessorTraits<PixelType>::default_accessor Accessor;
3272 return pair<StridedImageIterator<PixelType>, Accessor>
3276 template <
class PixelType>
3277 inline pair< ImageIterator<PixelType>,
3278 typename AccessorTraits<PixelType>::default_accessor>
3279 destImage(MultiArrayView<2, PixelType, UnstridedArrayTag> & img)
3281 ImageIterator<PixelType> ul(img.data(), img.stride(1));
3282 typedef typename AccessorTraits<PixelType>::default_accessor Accessor;
3283 return pair<ImageIterator<PixelType>, Accessor>(ul, Accessor());
3286 template <
class PixelType>
3287 inline pair< ConstStridedImageIterator<PixelType>,
3288 typename AccessorTraits<PixelType>::default_accessor>
3289 maskImage(MultiArrayView<2, PixelType, StridedArrayTag>
const & img)
3291 ConstStridedImageIterator<PixelType>
3292 ul(img.data(), 1, img.stride(0), img.stride(1));
3293 typedef typename AccessorTraits<PixelType>::default_accessor Accessor;
3294 return pair<ConstStridedImageIterator<PixelType>, Accessor>
3298 template <
class PixelType>
3299 inline pair< ConstImageIterator<PixelType>,
3300 typename AccessorTraits<PixelType>::default_accessor>
3301 maskImage(MultiArrayView<2, PixelType, UnstridedArrayTag>
const & img)
3303 ConstImageIterator<PixelType>
3304 ul(img.data(), img.stride(1));
3305 typedef typename AccessorTraits<PixelType>::default_accessor Accessor;
3306 return pair<ConstImageIterator<PixelType>, Accessor>
3328 template <
class T,
class Str
ide>
3333 "makeBasicImageView(array): array must be unstrided (i.e. array.isUnstrided() == true).");
3350 vigra_precondition(array.stride(1) == array.shape(0),
3351 "makeBasicImageView(): cannot join strided dimensions");
3353 array.shape (0)*array.shape (1), array.shape (2), array.stride(2));
3364 template <
class T,
class Str
ide>
3365 BasicImageView <RGBValue<T> >
3368 vigra_precondition(array.
shape (0) == 3,
3369 "makeRGBImageView(): array.shape(0) must be 3.");
3371 "makeRGBImageView(array): array must be unstrided (i.e. array.isUnstrided() == true).");
3381 #undef VIGRA_ASSERT_INSIDE
3383 #endif // VIGRA_MULTI_ARRAY_HXX
MultiArray & operator/=(multi_math::MultiMathOperand< Expression > const &rhs)
Definition: multi_array.hxx:2711
MultiArrayView< N, typename vigra::detail::ResolveMultiband< T >::type, typename vigra::detail::ResolveMultiband< T >::Stride > view_type
Definition: multi_array.hxx:2367
const value_type & const_reference
Definition: multi_array.hxx:678
MultiArrayView(const difference_type &shape, const difference_type &stride, const_pointer ptr)
Definition: multi_array.hxx:811
MultiArray & operator=(multi_math::MultiMathOperand< Expression > const &rhs)
Definition: multi_array.hxx:2671
void sum(MultiArrayView< N, U, S > sums) const
Definition: multi_array.hxx:1733
MultiArrayView & operator=(multi_math::MultiMathOperand< Expression > const &rhs)
Definition: multi_array.hxx:945
iterator end()
Definition: multi_array.hxx:1831
Sequential iterator for MultiArrayView.
Definition: multi_iterator.hxx:260
MultiArrayView & operator*=(MultiArrayView< N, U, C1 > const &rhs)
MultiArrayView & operator+=(T const &rhs)
Definition: multi_array.hxx:911
MultiArray< N, T > matrix_type
Definition: multi_array.hxx:728
MultiArray< N, T, A > matrix_type
Definition: multi_array.hxx:2377
view_type::pointer pointer
Definition: multi_array.hxx:2385
MultiArrayShape< actual_dimension >::type difference_type
Definition: multi_array.hxx:690
MultiArrayView & operator=(value_type const &v)
Definition: multi_array.hxx:880
MultiArray & operator+=(multi_math::MultiMathOperand< Expression > const &rhs)
Definition: multi_array.hxx:2681
MultiArray()
Definition: multi_array.hxx:2471
const difference_type & shape() const
Definition: multi_array.hxx:1551
ActualDimension
Definition: multi_array.hxx:666
MultiArrayView< N, T, StrideTag > view_type
Definition: multi_array.hxx:724
difference_type m_shape
Definition: multi_array.hxx:746
MultiArray(allocator_type const &alloc)
Definition: multi_array.hxx:2478
difference_type_1 width() const
Definition: multi_array.hxx:1573
MultiArray & operator=(value_type const &v)
Definition: multi_array.hxx:2568
A allocator_type
Definition: multi_array.hxx:2373
U product() const
Definition: multi_array.hxx:1750
view_type::iterator iterator
Definition: multi_array.hxx:2431
reference operator[](difference_type_1 d)
Definition: multi_array.hxx:1025
MultiArrayView & operator-=(T const &rhs)
Definition: multi_array.hxx:919
difference_type size_type
Definition: multi_array.hxx:698
MultiArrayView & operator*=(multi_math::MultiMathOperand< Expression > const &rhs)
Definition: multi_array.hxx:975
pointer data() const
Definition: multi_array.hxx:1792
void deallocate(pointer &ptr, difference_type_1 s)
Definition: multi_array.hxx:3004
Definition: array_vector.hxx:903
difference_type_1 elementCount() const
Definition: multi_array.hxx:1533
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:1815
MultiArrayView & operator/=(T const &rhs)
Definition: multi_array.hxx:935
void reshape(const difference_type &shape)
Definition: multi_array.hxx:2738
view_type::traverser traverser
Definition: multi_array.hxx:2413
reference operator()(difference_type_1 x)
Definition: multi_array.hxx:1065
BasicImageView< RGBValue< T > > makeRGBImageView(MultiArrayView< 3, T, Stride > const &array)
Definition: multi_array.hxx:3366
std::ptrdiff_t MultiArrayIndex
Definition: multi_shape.hxx:55
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:800
Definition: accessor.hxx:43
const_iterator begin() const
Definition: multi_array.hxx:1823
StridedScanOrderIterator< actual_dimension, T, T &, T * > iterator
Definition: multi_array.hxx:706
vigra::detail::MultiIteratorChooser< StrideTag >::template Traverser< actual_dimension, T, T const &, T const * >::type const_traverser
Definition: multi_array.hxx:720
MultiArrayView & operator/=(multi_math::MultiMathOperand< Expression > const &rhs)
Definition: multi_array.hxx:985
NormTraits< MultiArrayView >::NormType norm(int type=2, bool useSquaredNorm=true) const
Definition: multi_array.hxx:2255
MultiArrayView< N, T, StridedArrayTag > transpose() const
Definition: multi_array.hxx:1470
view_type::difference_type difference_type
Definition: multi_array.hxx:2405
void meanVariance(U *mean, U *variance) const
Definition: multi_array.hxx:1674
MultiArray(multi_math::MultiMathOperand< Expression > const &rhs, allocator_type const &alloc=allocator_type())
Definition: multi_array.hxx:2526
MultiArrayView< N+1, T, StrideTag > insertSingletonDimension(difference_type_1 i) const
Definition: multi_array.hxx:2237
view_type::const_traverser const_traverser
Definition: multi_array.hxx:2417
MultiArrayView< N-M, T, StridedArrayTag > bindInner(const TinyVector< Index, M > &d) const
Definition: multi_array.hxx:2090
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:715
difference_type_1 size() const
Definition: multi_array.hxx:1544
void swapData(MultiArrayView< N, T2, C2 > rhs)
Definition: multi_array.hxx:1190
NormTraits< MultiArrayView >::SquaredNormType squaredNorm() const
Definition: multi_array.hxx:1763
Definition: multi_shape.hxx:231
bool operator==(MultiArrayView< N, U, C1 > const &rhs) const
Definition: multi_array.hxx:1602
view_type::reference reference
Definition: multi_array.hxx:2393
NumericTraits< V >::Promote prod(TinyVectorBase< V, SIZE, D1, D2 > const &l)
product of the vector's elements
Definition: tinyvector.hxx:1895
MultiArrayIndex difference_type_1
Definition: multi_array.hxx:702
const difference_type & stride() const
Definition: multi_array.hxx:1587
bool any() const
Definition: multi_array.hxx:1644
bool operator!=(MultiArrayView< N, U, C1 > const &rhs) const
Definition: multi_array.hxx:1613
NumericTraits< V >::Promote sum(TinyVectorBase< V, SIZE, D1, D2 > const &l)
sum of the vector's elements
Definition: tinyvector.hxx:1871
MultiArray & operator*=(multi_math::MultiMathOperand< Expression > const &rhs)
Definition: multi_array.hxx:2701
value_type & reference
Definition: multi_array.hxx:674
MultiArrayView & operator-=(multi_math::MultiMathOperand< Expression > const &rhs)
Definition: multi_array.hxx:965
const_reference operator[](difference_type_1 d) const
Definition: multi_array.hxx:1041
difference_type_1 stride(int n) const
Definition: multi_array.hxx:1594
iterator begin()
Definition: tinyvector.hxx:835
bool isInside(difference_type const &p) const
Definition: multi_array.hxx:1620
difference_type_1 coordinateToScanOrderIndex(const difference_type &d) const
Definition: multi_array.hxx:1058
const_iterator end() const
Definition: multi_array.hxx:1839
MultiArray & init(const U &init)
Definition: multi_array.hxx:2728
MultiArrayView< 1, T, StridedArrayTag > diagonal() const
Definition: multi_array.hxx:1407
MultiArrayView< N-1, T, StridedArrayTag > bindAt(difference_type_1 m, difference_type_1 d) const
Definition: multi_array.hxx:2179
allocator_type m_alloc
Definition: multi_array.hxx:2443
void minmax(T *minimum, T *maximum) const
Definition: multi_array.hxx:1658
MultiArrayView(const MultiArrayView< N, T, Stride > &other)
Definition: multi_array.hxx:789
void copy(const MultiArrayView< N, U, CN > &rhs)
Definition: multi_array.hxx:1170
BasicImage using foreign memory.
Definition: basicimageview.hxx:74
MultiArrayView< N, T, StridedArrayTag > permuteStridesDescending() const
Definition: multi_array.hxx:2056
void copy(const MultiArrayView &rhs)
Definition: multi_array.hxx:1160
difference_type scanOrderIndexToCoordinate(difference_type_1 d) const
Definition: multi_array.hxx:1049
Definition: metaprogramming.hxx:100
allocator_type const & allocator() const
Definition: multi_array.hxx:2787
MultiArrayView< N, typename ExpandElementResult< T >::type, StridedArrayTag > bindElementChannel(difference_type_1 i) const
Definition: multi_array.hxx:1331
view_type::size_type size_type
Definition: multi_array.hxx:2401
MultiArrayView & operator/=(MultiArrayView< N, U, C1 > const &rhs)
difference_type_1 size(difference_type_1 n) const
Definition: multi_array.hxx:1558
view_type::const_pointer const_pointer
Definition: multi_array.hxx:2389
view_type::value_type value_type
Definition: multi_array.hxx:2381
Definition: metaprogramming.hxx:113
const_traverser traverser_begin() const
Definition: multi_array.hxx:1856
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:670
NormTraits< T >::SquaredNormType dot(const MultiArrayView< 2, T, C1 > &x, const MultiArrayView< 2, T, C2 > &y)
Definition: matrix.hxx:1340
MultiArrayView< N, T, StridedArrayTag > transpose(const difference_type &permutation) const
Definition: multi_array.hxx:1496
Fundamental class template for images.
Definition: basicimage.hxx:473
bool hasData() const
Definition: multi_array.hxx:1807
pointer m_ptr
Definition: multi_array.hxx:755
~MultiArray()
Definition: multi_array.hxx:2719
difference_type_1 height() const
Definition: multi_array.hxx:1580
view_type::difference_type_1 difference_type_1
Definition: multi_array.hxx:2409
MultiArrayView & operator+=(multi_math::MultiMathOperand< Expression > const &rhs)
Definition: multi_array.hxx:955
MultiArrayShape< 1 >::type Shape1
shape type for MultiArray<1, T>
Definition: multi_shape.hxx:240
MultiArrayView & operator=(MultiArrayView< N, U, C1 > const &rhs)
Definition: multi_array.hxx:870
MultiArray(const MultiArray &rhs)
Definition: multi_array.hxx:2516
Encapsulate read access to the values an iterator points to.
Definition: accessor.hxx:269
MultiArrayView(BasicImage< T, ALLOC > const &image)
Definition: multi_array.hxx:828
bool isUnstrided(unsigned int dimension=N-1) const
Definition: multi_array.hxx:1201
Base class for, and view to, vigra::MultiArray.
Definition: multi_array.hxx:655
void transformMultiArray(...)
Transform a multi-dimensional array with a unary function or functor.
MultiArrayView & init(const U &init)
Definition: multi_array.hxx:1150
MultiArray & operator-=(multi_math::MultiMathOperand< Expression > const &rhs)
Definition: multi_array.hxx:2691
BasicImageView< T > makeBasicImageView(MultiArray< 3, T > const &array)
Definition: multi_array.hxx:3348
void swapData(MultiArrayView rhs)
Definition: multi_array.hxx:1179
value_type * pointer
Definition: multi_array.hxx:682
traverser traverser_end()
Definition: multi_array.hxx:1866
MultiArrayView subarray(difference_type p, difference_type q) const
Definition: multi_array.hxx:1431
Class for a single RGB value.
Definition: accessor.hxx:938
bool all() const
Definition: multi_array.hxx:1631
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:710
reference operator[](const difference_type &d)
Definition: multi_array.hxx:993
view_type::const_iterator const_iterator
Definition: multi_array.hxx:2435
MultiArrayView< N+1, typename ExpandElementResult< T >::type, StridedArrayTag > expandElements(difference_type_1 d) const
Definition: multi_array.hxx:2208
MultiArrayView & operator=(MultiArrayView const &rhs)
Definition: multi_array.hxx:851
MultiArrayView & operator*=(T const &rhs)
Definition: multi_array.hxx:927
MultiArrayView< N, T, StridedArrayTag > permuteStridesAscending() const
Definition: multi_array.hxx:2046
difference_type m_stride
Definition: multi_array.hxx:751
void init(Iterator i, Iterator end)
Definition: tinyvector.hxx:699
U sum() const
Definition: multi_array.hxx:1697
const value_type * const_pointer
Definition: multi_array.hxx:686
difference_type_1 shape(difference_type_1 n) const
Definition: multi_array.hxx:1566
traverser traverser_begin()
Definition: multi_array.hxx:1847
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:1446
MultiArrayView()
Definition: multi_array.hxx:780
MultiArrayView< N-M, T, StrideTag > bindOuter(const TinyVector< Index, M > &d) const
Definition: multi_array.hxx:2067
difference_type key_type
Definition: multi_array.hxx:694
V const & min(TinyVectorBase< V, SIZE, D1, D2 > const &l)
minimum element
Definition: tinyvector.hxx:1959
view_type::const_reference const_reference
Definition: multi_array.hxx:2397
void allocate(pointer &ptr, difference_type_1 s, const_reference init)
Definition: multi_array.hxx:2933
MultiArrayView & operator+=(MultiArrayView< N, U, C1 > const &rhs)
const_traverser traverser_end() const
Definition: multi_array.hxx:1877
difference_type strideOrdering() const
Definition: multi_array.hxx:1520