[ VIGRA Homepage | Function Index | Class Index | Namespaces | File List | Main Page ]

details MultiArrayView< N, T, StrideTag > Class Template Reference VIGRA

Base class for, and view to, vigra::MultiArray. More...

#include <vigra/multi_array.hxx>

Inherited by MultiArrayView< N, Multiband< T >, StrideTag >.

List of all members.

Public Types

enum  ActualDimension
typedef
StridedScanOrderIterator
< actual_dimension, T, T const
&, T const * > 
const_iterator
typedef const value_typeconst_pointer
typedef const value_typeconst_reference
typedef
vigra::detail::MultiIteratorChooser
< StrideTag >::template
Traverser< actual_dimension, T,
T const &, T const * >::type 
const_traverser
typedef MultiArrayShape
< actual_dimension >::type 
difference_type
typedef MultiArrayIndex difference_type_1
typedef
StridedScanOrderIterator
< actual_dimension, T, T &, T * > 
iterator
typedef MultiArray< N, T > matrix_type
typedef value_typepointer
typedef value_typereference
typedef difference_type size_type
typedef
vigra::detail::MultiIteratorChooser
< StrideTag >::template
Traverser< actual_dimension, T,
T &, T * >::type 
traverser
typedef T value_type
typedef MultiArrayView< N, T,
StrideTag > 
view_type

Public Member Functions

bool all () const
bool any () const
iterator begin ()
const_iterator begin () const
template<unsigned int M>
MultiArrayView< N-1, T,
typename
vigra::detail::MaybeStrided
< StrideTag, M >::type > 
bind (difference_type_1 d) const
MultiArrayView< N-1, T,
StridedArrayTag
bindAt (difference_type_1 m, difference_type_1 d) const
MultiArrayView< N, typename
ExpandElementResult< T >::type,
StridedArrayTag
bindElementChannel (difference_type_1 i) const
template<int M, class Index >
MultiArrayView< N-M, T,
StridedArrayTag
bindInner (const TinyVector< Index, M > &d) const
MultiArrayView< N-1, T,
StridedArrayTag
bindInner (difference_type_1 d) const
template<int M, class Index >
MultiArrayView< N-M, T, StrideTag > bindOuter (const TinyVector< Index, M > &d) const
MultiArrayView< N-1, T, StrideTag > bindOuter (difference_type_1 d) const
difference_type_1 coordinateToScanOrderIndex (const difference_type &d) const
void copy (const MultiArrayView &rhs)
template<class U , class CN >
void copy (const MultiArrayView< N, U, CN > &rhs)
pointer data () const
MultiArrayView< 1, T,
StridedArrayTag
diagonal () const
difference_type_1 elementCount () const
iterator end ()
const_iterator end () const
MultiArrayView< N+1, typename
ExpandElementResult< T >::type,
StridedArrayTag
expandElements (difference_type_1 d) const
bool hasData () const
template<class U >
MultiArrayViewinit (const U &init)
MultiArrayView< N+1, T, StrideTag > insertSingletonDimension (difference_type_1 i) const
bool isInside (difference_type const &p) const
bool isUnstrided (unsigned int dimension=N-1) const
template<class U >
void meanVariance (U *mean, U *variance) const
void minmax (T *minimum, T *maximum) const
 MultiArrayView ()
 MultiArrayView (const difference_type &shape, pointer ptr)
 MultiArrayView (const difference_type &shape, const difference_type &stride, pointer ptr)
NormTraits< MultiArrayView >
::NormType 
norm (int type=2, bool useSquaredNorm=true) const
 operator MultiArrayView< N, T, StridedArrayTag > () const
template<class U , class C1 >
bool operator!= (MultiArrayView< N, U, C1 > const &rhs) const
reference operator() (difference_type_1 x)
reference operator() (difference_type_1 x, difference_type_1 y)
reference operator() (difference_type_1 x, difference_type_1 y, difference_type_1 z)
reference operator() (difference_type_1 x, difference_type_1 y, difference_type_1 z, difference_type_1 u)
reference operator() (difference_type_1 x, difference_type_1 y, difference_type_1 z, difference_type_1 u, difference_type_1 v)
const_reference operator() (difference_type_1 x) const
const_reference operator() (difference_type_1 x, difference_type_1 y) const
const_reference operator() (difference_type_1 x, difference_type_1 y, difference_type_1 z) const
const_reference operator() (difference_type_1 x, difference_type_1 y, difference_type_1 z, difference_type_1 u) const
const_reference operator() (difference_type_1 x, difference_type_1 y, difference_type_1 z, difference_type_1 u, difference_type_1 v) const
template<class U , class C1 >
MultiArrayViewoperator*= (MultiArrayView< N, U, C1 > const &rhs)
MultiArrayViewoperator*= (T const &rhs)
template<class Expression >
MultiArrayViewoperator*= (multi_math::MultiMathOperand< Expression > const &rhs)
template<class U , class C1 >
MultiArrayViewoperator+= (MultiArrayView< N, U, C1 > const &rhs)
MultiArrayViewoperator+= (T const &rhs)
template<class Expression >
MultiArrayViewoperator+= (multi_math::MultiMathOperand< Expression > const &rhs)
template<class U , class C1 >
MultiArrayViewoperator-= (MultiArrayView< N, U, C1 > const &rhs)
MultiArrayViewoperator-= (T const &rhs)
template<class Expression >
MultiArrayViewoperator-= (multi_math::MultiMathOperand< Expression > const &rhs)
template<class U , class C1 >
MultiArrayViewoperator/= (MultiArrayView< N, U, C1 > const &rhs)
MultiArrayViewoperator/= (T const &rhs)
template<class Expression >
MultiArrayViewoperator/= (multi_math::MultiMathOperand< Expression > const &rhs)
MultiArrayViewoperator= (MultiArrayView const &rhs)
template<class U , class C1 >
MultiArrayViewoperator= (MultiArrayView< N, U, C1 > const &rhs)
MultiArrayViewoperator= (value_type const &v)
template<class Expression >
MultiArrayViewoperator= (multi_math::MultiMathOperand< Expression > const &rhs)
template<class U , class C1 >
bool operator== (MultiArrayView< N, U, C1 > const &rhs) const
reference operator[] (const difference_type &d)
const_reference operator[] (const difference_type &d) const
template<int M>
MultiArrayView< N-M, T,
StridedArrayTag
operator[] (const TinyVector< MultiArrayIndex, M > &d) const
reference operator[] (difference_type_1 d)
const_reference operator[] (difference_type_1 d) const
MultiArrayView< N, T,
StridedArrayTag
permuteDimensions (const difference_type &s) const
MultiArrayView< N, T,
StridedArrayTag
permuteStridesAscending () const
MultiArrayView< N, T,
StridedArrayTag
permuteStridesDescending () const
template<class U >
product () const
difference_type scanOrderIndexToCoordinate (difference_type_1 d) const
const difference_typeshape () const
difference_type_1 shape (difference_type_1 n) const
difference_type_1 size () const
difference_type_1 size (difference_type_1 n) const
NormTraits< MultiArrayView >
::SquaredNormType 
squaredNorm () const
const difference_typestride () const
difference_type_1 stride (int n) const
MultiArrayView< N, T,
StridedArrayTag
stridearray (const difference_type &s) const
difference_type strideOrdering () const
MultiArrayView subarray (const difference_type &p, const difference_type &q) const
template<class U >
sum () const
template<class U , class S >
void sum (MultiArrayView< N, U, S > sums) const
void swapData (MultiArrayView rhs)
template<class T2 , class C2 >
void swapData (MultiArrayView< N, T2, C2 > rhs)
MultiArrayView< N, T,
StridedArrayTag
transpose () const
traverser traverser_begin ()
const_traverser traverser_begin () const
traverser traverser_end ()
const_traverser traverser_end () const

Static Public Member Functions

static difference_type strideOrdering (difference_type strides)

Protected Attributes

pointer m_ptr
difference_type m_shape
difference_type m_stride

Detailed Description

template<unsigned int N, class T, class StrideTag>
class vigra::MultiArrayView< N, T, StrideTag >

Base class for, and view to, vigra::MultiArray.

This class implements the interface of both MultiArray and MultiArrayView. By default, MultiArrayViews are tagged as unstrided. If necessary, strided arrays are constructed automatically by calls to a variant of the bind...() function.

In addition to the member functions described here, MultiArrayView and its subclasses support arithmetic and algebraic functions via the module vigra::multi_math.

If you want to apply an algorithm requiring an image to a MultiArrayView of appropriate (2-dimensional) shape, you can create a vigra::BasicImageView that acts as a wrapper with the necessary interface -- see Wrap aref vigra::MultiArrayView in.

The template parameter are as follows

    N: the array dimension

    T: the type of the array elements

    C: a tag determining whether the array's inner dimension is strided
       or not. An array is unstrided if the array elements occupy consecutive
       memory location, strided if there is an offset in between (e.g.
       when a view is created that skips every other array element).
       The compiler can generate faster code for unstrided arrays.
       Possible values: UnstridedArrayTag (default), StridedArrayTag

#include <vigra/multi_array.hxx>

Namespace: vigra


Member Typedef Documentation

typedef T value_type
typedef const value_type& const_reference
typedef value_type* pointer
typedef const value_type* const_pointer
typedef MultiArrayShape<actual_dimension>::type difference_type
typedef StridedScanOrderIterator<actual_dimension, T, T &, T *> iterator
typedef StridedScanOrderIterator<actual_dimension, T, T const &, T const *> const_iterator
typedef vigra::detail::MultiIteratorChooser< StrideTag>::template Traverser<actual_dimension, T, T &, T *>::type traverser
typedef vigra::detail::MultiIteratorChooser< StrideTag>::template Traverser<actual_dimension, T, T const &, T const *>::type const_traverser
typedef MultiArrayView<N, T, StrideTag> view_type
typedef MultiArray<N, T> matrix_type

Member Enumeration Documentation

the array's actual dimensionality. This ensures that MultiArrayView can also be used for scalars (that is, when N == 0). Calculated as:

            actual_dimension = (N==0) ? 1 : N

Constructor & Destructor Documentation

default constructor: create an invalid view, i.e. hasData() returns false and size() is zero.

MultiArrayView ( const difference_type shape,
pointer  ptr 
)

construct from shape and pointer

MultiArrayView ( const difference_type shape,
const difference_type stride,
pointer  ptr 
)

Construct from shape, strides (offset of a sample to the next) for every dimension, and pointer. (Note that strides are not given in bytes, but in offset steps of the respective pointer type.)


Member Function Documentation

operator MultiArrayView< N, T, StridedArrayTag > ( ) const

Conversion to a strided view.

MultiArrayView< N, T, StrideTag > & operator= ( MultiArrayView< N, T, StrideTag > const &  rhs)

Assignment. There are 3 cases:

  • When this MultiArrayView does not point to valid data (e.g. after default construction), it becomes a copy of rhs.
  • When the shapes of the two arrays match, the array contents are copied.
  • Otherwise, a PreconditionViolation exception is thrown.
MultiArrayView& operator= ( MultiArrayView< N, U, C1 > const &  rhs)

Assignment of a differently typed MultiArrayView. Fails with PreconditionViolation exception when the shapes do not match.

MultiArrayView& operator= ( value_type const &  v)
MultiArrayView& operator+= ( MultiArrayView< N, U, C1 > const &  rhs)

Add-assignment of a compatible MultiArrayView. Fails with PreconditionViolation exception when the shapes do not match.

MultiArrayView& operator-= ( MultiArrayView< N, U, C1 > const &  rhs)

Subtract-assignment of a compatible MultiArrayView. Fails with PreconditionViolation exception when the shapes do not match.

MultiArrayView& operator*= ( MultiArrayView< N, U, C1 > const &  rhs)

Multiply-assignment of a compatible MultiArrayView. Fails with PreconditionViolation exception when the shapes do not match.

MultiArrayView& operator/= ( MultiArrayView< N, U, C1 > const &  rhs)

Divide-assignment of a compatible MultiArrayView. Fails with PreconditionViolation exception when the shapes do not match.

MultiArrayView& operator+= ( T const &  rhs)
MultiArrayView& operator-= ( T const &  rhs)
MultiArrayView& operator*= ( T const &  rhs)
MultiArrayView& operator/= ( T const &  rhs)
MultiArrayView& operator= ( multi_math::MultiMathOperand< Expression > const &  rhs)
MultiArrayView& operator+= ( multi_math::MultiMathOperand< Expression > const &  rhs)
MultiArrayView& operator-= ( multi_math::MultiMathOperand< Expression > const &  rhs)
MultiArrayView& operator*= ( multi_math::MultiMathOperand< Expression > const &  rhs)
MultiArrayView& operator/= ( multi_math::MultiMathOperand< Expression > const &  rhs)
reference operator[] ( const difference_type d)

array access.

const_reference operator[] ( const difference_type d) const

array access.

MultiArrayView<N-M, T, StridedArrayTag> operator[] ( const TinyVector< MultiArrayIndex, M > &  d) const

equivalent to bindInner(), when M < N.

reference operator[] ( difference_type_1  d)

Array access in scan-order sense. Mostly useful to support standard indexing for 1-dimensional multi-arrays, but works for any N. Use scanOrderIndexToCoordinate() and coordinateToScanOrderIndex() for conversion between indices and coordinates.

Note: This function should not be used in the inner loop, because the conversion of the scan order index into a memory address is expensive (it must take into account that memory may not be consecutive for subarrays and/or strided arrays). Always prefer operator() if possible.

const_reference operator[] ( difference_type_1  d) const

Array access in scan-order sense. Mostly useful to support standard indexing for 1-dimensional multi-arrays, but works for any N. Use scanOrderIndexToCoordinate() and coordinateToScanOrderIndex() for conversion between indices and coordinates.

Note: This function should not be used in the inner loop, because the conversion of the scan order index into a memory address is expensive (it must take into account that memory may not be consecutive for subarrays and/or strided arrays). Always prefer operator() if possible.

convert scan-order index to coordinate.

convert coordinate to scan-order index.

reference operator() ( difference_type_1  x)

1D array access. Use only if N == 1.

reference operator() ( difference_type_1  x,
difference_type_1  y 
)

2D array access. Use only if N == 2.

Reimplemented in Matrix< T, ALLOC >, and Matrix< T >.

3D array access. Use only if N == 3.

4D array access. Use only if N == 4.

5D array access. Use only if N == 5.

const_reference operator() ( difference_type_1  x) const

1D const array access. Use only if N == 1.

const_reference operator() ( difference_type_1  x,
difference_type_1  y 
) const

2D const array access. Use only if N == 2.

Reimplemented in Matrix< T, ALLOC >, and Matrix< T >.

3D const array access. Use only if N == 3.

4D const array access. Use only if N == 4.

5D const array access. Use only if N == 5.

MultiArrayView& init ( const U &  init)
void copy ( const MultiArrayView< N, T, StrideTag > &  rhs)

Copy the data of the right-hand array (array shapes must match).

void copy ( const MultiArrayView< N, U, CN > &  rhs)

Copy the data of the right-hand array (array shapes must match).

void swapData ( MultiArrayView< N, T, StrideTag >  rhs)

swap the data between two MultiArrayView objects.

The shapes of the two array must match.

void swapData ( MultiArrayView< N, T2, C2 >  rhs)

swap the data between two MultiArrayView objects.

The shapes of the two array must match.

bool isUnstrided ( unsigned int  dimension = N-1) const

check whether the array is unstrided (i.e. has consecutive memory) up to the given dimension.

dimension can range from 0 ... N-1. If a certain dimension is unstrided, all lower dimensions are also unstrided.

MultiArrayView< N-M, T, StrideTag > bindOuter ( const TinyVector< Index, M > &  d) const

bind the M outmost dimensions to certain indices. this reduces the dimensionality of the image to max { 1, N-M }.

Usage:

            // create a 3D array of size 40x30x20
            typedef MultiArray<3, double>::difference_type Shape;
            MultiArray<3, double> array3(Shape(40, 30, 20));

            // get a 1D array by fixing index 1 to 12, and index 2 to 10
            MultiArrayView <1, double> array1 = array3.bindOuter(TinyVector<MultiArrayIndex, 2>(12, 10));
MultiArrayView< N-M, T, StridedArrayTag > bindInner ( const TinyVector< Index, M > &  d) const

bind the M innermost dimensions to certain indices. this reduces the dimensionality of the image to max { 1, N-M }.

Usage:

            // create a 3D array of size 40x30x20
            typedef MultiArray<3, double>::difference_type Shape;
            MultiArray<3, double> array3(Shape(40, 30, 20));

            // get a 1D array by fixing index 0 to 12, and index 1 to 10
            MultiArrayView <1, double, StridedArrayTag> array1 = array3.bindInner(TinyVector<MultiArrayIndex, 2>(12, 10));
MultiArrayView< N-1, T, typename detail::MaybeStrided< StrideTag, M >::type > bind ( difference_type_1  d) const

bind dimension M to index d. this reduces the dimensionality of the image to max { 1, N-1 }.

Usage:

            // create a 3D array of size 40x30x20
            typedef MultiArray<3, double>::difference_type Shape;
            MultiArray<3, double> array3(Shape(40, 30, 20));

            // get a 2D array by fixing index 1 to 12
            MultiArrayView <2, double> array2 = array3.bind<1>(12);

            // get a 2D array by fixing index 0 to 23
            MultiArrayView <2, double, StridedArrayTag> array2a = array3.bind<0>(23);
MultiArrayView< N-1, T, StrideTag > bindOuter ( difference_type_1  d) const

bind the outmost dimension to a certain index. this reduces the dimensionality of the image to max { 1, N-1 }.

Usage:

            // create a 3D array of size 40x30x20
            typedef MultiArray<3, double>::difference_type Shape;
            MultiArray<3, double> array3(Shape(40, 30, 20));

            // get a 2D array by fixing the outermost index (i.e. index 2) to 12
            MultiArrayView <2, double> array2 = array3.bindOuter(12);

bind the innermost dimension to a certain index. this reduces the dimensionality of the image to max { 1, N-1 }.

Usage:

            // create a 3D array of size 40x30x20
            typedef MultiArray<3, double>::difference_type Shape;
            MultiArray<3, double> array3(Shape(40, 30, 20));

            // get a 2D array by fixing the innermost index (i.e. index 0) to 23
            MultiArrayView <2, double, StridedArrayTag> array2 = array3.bindInner(23);

bind dimension m to index d. this reduces the dimensionality of the image to max { 1, N-1 }.

Usage:

            // create a 3D array of size 40x30x20
            typedef MultiArray<3, double>::difference_type Shape;
            MultiArray<3, double> array3(Shape(40, 30, 20));

            // get a 2D array by fixing index 2 to 15
            MultiArrayView <2, double, StridedArrayTag> array2 = array3.bindAt(2, 15);
MultiArrayView<N, typename ExpandElementResult<T>::type, StridedArrayTag> bindElementChannel ( difference_type_1  i) const

Create a view to channel 'i' of a vector-like value type. Possible value types (of the original array) are: TinyVector, RGBValue, FFTWComplex, and std::complex. The list can be extended to any type whose memory layout is equivalent to a fixed-size C array, by specializing ExpandElementResult.

Usage:

                MultiArray<2, RGBValue<float> > rgb_image(Shape2(w, h));
                
                MultiArrayView<2, float, StridedArrayTag> red   = rgb_image.bindElementChannel(0);
                MultiArrayView<2, float, StridedArrayTag> green = rgb_image.bindElementChannel(1);
                MultiArrayView<2, float, StridedArrayTag> blue  = rgb_image.bindElementChannel(2);
MultiArrayView< N+1, typename ExpandElementResult< T >::type, StridedArrayTag > expandElements ( difference_type_1  d) const

Create a view where a vector-like element type is expanded into a new array dimension. The new dimension is inserted at index position 'd', which must be between 0 and N inclusive.

Possible value types of the original array are: TinyVector, RGBValue, FFTWComplex, std::complex, and the built-in number types (in this case, expandElements is equivalent to insertSingletonDimension). The list of supported types can be extended to any type whose memory layout is equivalent to a fixed-size C array, by specializing ExpandElementResult.

Usage:

                MultiArray<2, RGBValue<float> > rgb_image(Shape2(w, h));
                
                MultiArrayView<3, float, StridedArrayTag> multiband_image = rgb_image.expandElements(2);
MultiArrayView< N+1, T, StrideTag > insertSingletonDimension ( difference_type_1  i) const

Add a singleton dimension (dimension of length 1).

Singleton dimensions don't change the size of the data, but introduce a new index that can only take the value 0. This is mainly useful for the 'reduce mode' of transformMultiArray() and combineTwoMultiArrays(), because these functions require the source and destination arrays to have the same number of dimensions.

The range of i must be 0 <= i <= N. The new dimension will become the i'th index, and the old indices from i upwards will shift one place to the right.

Usage:

Suppose we want have a 2D array and want to create a 1D array that contains the row average of the first array.

            typedef MultiArrayShape<2>::type Shape2;
            MultiArray<2, double> original(Shape2(40, 30));

            typedef MultiArrayShape<1>::type Shape1;
            MultiArray<1, double> rowAverages(Shape1(30));

            // temporarily add a singleton dimension to the destination array
            transformMultiArray(srcMultiArrayRange(original),
                                destMultiArrayRange(rowAverages.insertSingletonDimension(0)),
                                FindAverage<double>());

Create a view to the diagonal elements of the array.

This produces a 1D array view whose size equals the size of the shortest dimension of the original array.

Usage:

            // create a 3D array of size 40x30x20
            typedef MultiArray<3, double>::difference_type Shape;
            MultiArray<3, double> array3(Shape(40, 30, 20));

            // get a view to the diagonal elements
            MultiArrayView <1, double, StridedArrayTag> diagonal = array3.diagonal();
            assert(diagonal.shape(0) == 20);
MultiArrayView subarray ( const difference_type p,
const difference_type q 
) const

create a rectangular subarray that spans between the points p and q, where p is in the subarray, q not.

Usage:

            // create a 3D array of size 40x30x20
            typedef MultiArray<3, double>::difference_type Shape;
            MultiArray<3, double> array3(Shape(40, 30, 20));

            // get a subarray set is smaller by one element at all sides
            MultiArrayView <3, double> subarray = array3.subarray(Shape(1,1,1), Shape(39, 29, 19));

apply an additional striding to the image, thereby reducing the shape of the array. for example, multiplying the stride of dimension one by three turns an appropriately laid out (interleaved) rgb image into a single band image.

Transpose an array. If N==2, this implements the usual matrix transposition. For N > 2, it reverses the order of the indices.

Usage:

            typedef MultiArray<2, double>::difference_type Shape;
            MultiArray<2, double> array(10, 20);

            MultiArray<2, double, StridedArrayTag> transposed = array.transpose();

            for(int i=0; i<array.shape(0), ++i)
                for(int j=0; j<array.shape(1); ++j)
                    assert(array(i, j) == transposed(j, i));

Reimplemented in Matrix< T, ALLOC >, and Matrix< T >.

permute the dimensions of the array. The function exchanges the meaning of the dimensions without copying the data. In case of a 2-dimensional array, this is simply array transposition. In higher dimensions, there are more possibilities.

Usage:

            typedef MultiArray<2, double>::difference_type Shape;
            MultiArray<2, double> array(10, 20);

            MultiArray<2, double, StridedArrayTag> transposed = array.permuteDimensions(Shape(1,0));

            for(int i=0; i<array.shape(0), ++i)
                for(int j=0; j<array.shape(1); ++j)
                    assert(array(i, j) == transposed(j, i));

Permute the dimensions of the array so that the strides are in ascending order. Determines the appropriate permutation and then calls permuteDimensions().

Permute the dimensions of the array so that the strides are in descending order. Determines the appropriate permutation and then calls permuteDimensions().

Compute the ordering of the strides in this array. The result is describes the current permutation of the axes relative to the standard ascending stride order.

MultiArrayView< N, T, StrideTag >::difference_type strideOrdering ( difference_type  strides) [static]

Compute the ordering of the given strides. The result is describes the current permutation of the axes relative to the standard ascending stride order.

number of the elements in the array.

Reimplemented in Matrix< T, ALLOC >, and Matrix< T >.

number of the elements in the array. Same as elementCount(). Mostly useful to support the std::vector interface.

const difference_type& shape ( ) const

return the array's shape.

return the array's size at a certain dimension.

return the array's shape at a certain dimension (same as size(n)).

const difference_type& stride ( ) const

return the array's stride for every dimension.

difference_type_1 stride ( int  n) const

return the array's stride at a certain dimension.

bool operator== ( MultiArrayView< N, U, C1 > const &  rhs) const

check whether two arrays are elementwise equal.

bool operator!= ( MultiArrayView< N, U, C1 > const &  rhs) const

check whether two arrays are not elementwise equal. Also true when the two arrays have different shapes.

bool isInside ( difference_type const &  p) const

check whether the given point is in the array range.

bool all ( ) const

Check if the array contains only non-zero elements (or if all elements are 'true' if the value type is 'bool').

bool any ( ) const

Check if the array contains a non-zero element (or an element that is 'true' if the value type is 'bool').

void minmax ( T *  minimum,
T *  maximum 
) const

Find the minimum and maximum element in this array. See Feature Accumulators for a general feature extraction framework.

void meanVariance ( U *  mean,
U *  variance 
) const

Compute the mean and variance of the values in this array. See Feature Accumulators for a general feature extraction framework.

U sum ( ) const

Compute the sum of the array elements.

You must provide the type of the result by an explicit template parameter:

            MultiArray<2, UInt8> A(width, height);
            
            double sum = A.sum<double>();

Reimplemented in Matrix< T, ALLOC >, and Matrix< T >.

void sum ( MultiArrayView< N, U, S >  sums) const

Compute the sum of the array elements over selected axes.

  • sums must have the same shape as this array, except for the axes along which the sum is to be accumulated. These axes must be singletons. Note that you must include multi_pointoperators.hxx for this function to work.

Usage:

            #include <vigra/multi_array.hxx>
            #include <vigra/multi_pointoperators.hxx>
            
            MultiArray<2, double> A(rows, cols);
            ... // fill A
            
            // make the first axis a singleton to sum over the first index
            MultiArray<2, double> rowSums(1, cols);
            A.sum(rowSums);
            
            // this is equivalent to
            transformMultiArray(srcMultiArrayRange(A),
                                destMultiArrayRange(rowSums),
                                FindSum<double>());
U product ( ) const

Compute the product of the array elements.

You must provide the type of the result by an explicit template parameter:

            MultiArray<2, UInt8> A(width, height);
            
            double prod = A.product<double>();
NormTraits<MultiArrayView>::SquaredNormType squaredNorm ( ) const

Compute the squared Euclidean norm of the array (sum of squares of the array elements).

Reimplemented in Matrix< T, ALLOC >, and Matrix< T >.

NormTraits< MultiArrayView< N, T, StrideTag > >::NormType norm ( int  type = 2,
bool  useSquaredNorm = true 
) const

Compute various norms of the array. The norm is determined by parameter type:

  • type == 0: maximum norm (L-infinity): maximum of absolute values of the array elements
  • type == 1: Manhattan norm (L1): sum of absolute values of the array elements
  • type == 2: Euclidean norm (L2): square root of squaredNorm() when useSquaredNorm is true,
    or direct algorithm that avoids underflow/overflow otherwise.

Parameter useSquaredNorm has no effect when type != 2. Defaults: compute L2 norm as square root of squaredNorm().

pointer data ( ) const

return the pointer to the image data

bool hasData ( ) const

returns true iff this view refers to valid data, i.e. data() is not a NULL pointer. (this is false after default construction.)

const_iterator begin ( ) const
const_iterator end ( ) const

returns the N-dimensional MultiIterator pointing to the first element in every dimension.

returns the N-dimensional MultiIterator pointing to the const first element in every dimension.

returns the N-dimensional MultiIterator pointing beyond the last element in dimension N, and to the first element in every other dimension.

returns the N-dimensional const MultiIterator pointing beyond the last element in dimension N, and to the first element in every other dimension.


Member Data Documentation

difference_type m_shape [protected]

the shape of the image pointed to is stored here.

the strides (offset of a sample to the next) for every dimension are stored here.

pointer m_ptr [protected]

pointer to the image.


The documentation for this class was generated from the following file:

© Ullrich Köthe (ullrich.koethe@iwr.uni-heidelberg.de)
Heidelberg Collaboratory for Image Processing, University of Heidelberg, Germany

html generated using doxygen and Python
vigra 1.9.0 (Tue Nov 6 2012)