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

MultiArray< N, T, A > Class Template Reference

Main MultiArray class containing the memory management. More...

#include <vigra/multi_array.hxx>

Inheritance diagram for MultiArray< N, T, A >:
MultiArrayView< N, vigra::detail::ResolveMultiband< T >::type, vigra::detail::ResolveMultiband< T >::Stride > Matrix< double > Matrix< int > ChunkedArrayFull< N, T, Alloc > Matrix< T, ALLOC >

Public Types

typedefallocator_type
 
typedef view_type::const_iterator const_iterator
 
typedef view_type::const_pointer const_pointer
 
typedef view_type::const_reference const_reference
 
typedef view_type::const_traverser const_traverser
 
typedef view_type::difference_type difference_type
 
typedef view_type::difference_type_1 difference_type_1
 
typedef view_type::iterator iterator
 
typedef MultiArray< N, T, A > matrix_type
 
typedef view_type::pointer pointer
 
typedef view_type::reference reference
 
typedef view_type::size_type size_type
 
typedef view_type::traverser traverser
 
typedef view_type::value_type value_type
 
typedef MultiArrayView< N, typename vigra::detail::ResolveMultiband< T >::type, typename vigra::detail::ResolveMultiband< T >::Stride > view_type
 

Public Member Functions

allocator_type constallocator () const
 
template<class U >
MultiArrayinit (const U &init)
 
 MultiArray ()
 
 MultiArray (allocator_type const &alloc)
 
 MultiArray (const difference_type &shape, allocator_type const &alloc=allocator_type())
 
 MultiArray (const difference_type &shape, const_pointer init, allocator_type const &alloc=allocator_type())
 
 MultiArray (const difference_type &shape, const_reference init, allocator_type const &alloc=allocator_type())
 
 MultiArray (const difference_type &shape, MultiArrayInitializationTag init, allocator_type const &alloc=allocator_type())
 
 MultiArray (const MultiArray &rhs)
 
template<class U , class StrideTag >
 MultiArray (const MultiArrayView< N, U, StrideTag > &rhs, allocator_type const &alloc=allocator_type())
 
 MultiArray (difference_type_1 length, allocator_type const &alloc=allocator_type())
 
 MultiArray (difference_type_1 width, difference_type_1 height, allocator_type const &alloc=allocator_type())
 
template<class Expression >
 MultiArray (multi_math::MultiMathOperand< Expression > const &rhs, allocator_type const &alloc=allocator_type())
 
template<class U , class StrideTag >
MultiArrayoperator*= (const MultiArrayView< N, U, StrideTag > &rhs)
 
MultiArrayoperator*= (const T &rhs)
 
template<class Expression >
MultiArrayoperator*= (multi_math::MultiMathOperand< Expression > const &rhs)
 
template<class U , class StrideTag >
MultiArrayoperator+= (const MultiArrayView< N, U, StrideTag > &rhs)
 
MultiArrayoperator+= (const T &rhs)
 
template<class Expression >
MultiArrayoperator+= (multi_math::MultiMathOperand< Expression > const &rhs)
 
template<class U , class StrideTag >
MultiArrayoperator-= (const MultiArrayView< N, U, StrideTag > &rhs)
 
MultiArrayoperator-= (const T &rhs)
 
template<class Expression >
MultiArrayoperator-= (multi_math::MultiMathOperand< Expression > const &rhs)
 
template<class U , class StrideTag >
MultiArrayoperator/= (const MultiArrayView< N, U, StrideTag > &rhs)
 
MultiArrayoperator/= (const T &rhs)
 
template<class Expression >
MultiArrayoperator/= (multi_math::MultiMathOperand< Expression > const &rhs)
 
MultiArrayoperator= (const MultiArray &rhs)
 
template<class U , class StrideTag >
MultiArrayoperator= (const MultiArrayView< N, U, StrideTag > &rhs)
 
template<class Expression >
MultiArrayoperator= (multi_math::MultiMathOperand< Expression > const &rhs)
 
MultiArrayoperator= (value_type const &v)
 
void reshape (const difference_type &shape)
 
void reshape (const difference_type &shape, const_reference init)
 
void swap (MultiArray &other)
 
 ~MultiArray ()
 

Protected Member Functions

void allocate (pointer &ptr, difference_type_1 s, const_reference init)
 
template<class U >
void allocate (pointer &ptr, difference_type_1 s, U const *init)
 
template<class U , class StrideTag >
void allocate (pointer &ptr, MultiArrayView< N, U, StrideTag > const &init)
 
void deallocate (pointer &ptr, difference_type_1 s)
 

Protected Attributes

allocator_type m_alloc
 

Detailed Description

template<unsigned int N, class T, class A>
class vigra::MultiArray< N, T, A >

Main MultiArray class containing the memory management.

This class inherits the interface of MultiArrayView, and implements the memory ownership. MultiArray's are always unstrided, striding them creates a MultiArrayView.

The template parameters are as follows

N: the array dimension
T: the type of the array elements
(default: std::allocator<T>)
allocator_type const & allocator() const
Definition multi_array.hxx:2912
Class for a single RGB value.
Definition rgbvalue.hxx:128

#include <vigra/multi_array.hxx>
Namespace: vigra

Examples
convert.cxx, invert.cxx, palette.cxx, resize.cxx, and subimage.cxx.

Member Typedef Documentation

◆ view_type

template<unsigned int N, class T , class A >
typedef MultiArrayView<N, typename vigra::detail::ResolveMultiband<T>::type, typename vigra::detail::ResolveMultiband<T>::Stride> view_type

the view type associated with this array.

◆ allocator_type

template<unsigned int N, class T , class A >
typedef A allocator_type

the allocator type used to allocate the memory

◆ matrix_type

template<unsigned int N, class T , class A >
typedef MultiArray<N, T, A> matrix_type

the matrix type associated with this array.

◆ value_type

the array's value type

◆ pointer

pointer type

◆ const_pointer

const pointer type

◆ reference

reference type (result of operator[])

◆ const_reference

const reference type (result of operator[] const)

◆ size_type

size type

◆ difference_type

difference type (used for multi-dimensional offsets and indices)

◆ difference_type_1

difference and index type for a single dimension

◆ traverser

traverser type

◆ const_traverser

traverser type to const data

◆ iterator

sequential (random access) iterator type

◆ const_iterator

sequential (random access) const iterator type

Constructor & Destructor Documentation

◆ MultiArray() [1/11]

template<unsigned int N, class T , class A >
MultiArray ( )

default constructor

◆ MultiArray() [2/11]

template<unsigned int N, class T , class A >
MultiArray ( allocator_type const alloc)

construct with given allocator

◆ MultiArray() [3/11]

template<unsigned int N, class T , class A >
MultiArray ( difference_type_1  length,
allocator_type const alloc = allocator_type() 
)
explicit

construct with given length

Use only for 1-dimensional arrays (N==1).

◆ MultiArray() [4/11]

template<unsigned int N, class T , class A >
MultiArray ( difference_type_1  width,
difference_type_1  height,
allocator_type const alloc = allocator_type() 
)

construct with given width and height

Use only for 2-dimensional arrays (N==2).

◆ MultiArray() [5/11]

template<unsigned int N, class T , class A >
MultiArray ( const difference_type shape,
allocator_type const alloc = allocator_type() 
)
explicit

construct with given shape

◆ MultiArray() [6/11]

template<unsigned int N, class T , class A >
MultiArray ( const difference_type shape,
const_reference  init,
allocator_type const alloc = allocator_type() 
)

construct from shape with an initial value

◆ MultiArray() [7/11]

construct from shape and initialize with a linear sequence in scan order (i.e. first pixel gets value 0, second on gets value 1 and so on).

◆ MultiArray() [8/11]

template<unsigned int N, class T , class A >
MultiArray ( const difference_type shape,
const_pointer  init,
allocator_type const alloc = allocator_type() 
)

construct from shape and copy values from the given array

◆ MultiArray() [9/11]

template<unsigned int N, class T , class A >
MultiArray ( const MultiArray< N, T, A > &  rhs)

copy constructor

◆ MultiArray() [10/11]

template<unsigned int N, class T , class A >
template<class Expression >
MultiArray ( multi_math::MultiMathOperand< Expression > const rhs,
allocator_type const alloc = allocator_type() 
)

constructor from an array expression

◆ MultiArray() [11/11]

template<unsigned int N, class T , class A >
template<class U , class StrideTag >
MultiArray ( const MultiArrayView< N, U, StrideTag > &  rhs,
allocator_type const alloc = allocator_type() 
)

construct by copying from a MultiArrayView

◆ ~MultiArray()

template<unsigned int N, class T , class A >
~MultiArray ( )

destructor

Member Function Documentation

◆ allocate() [1/3]

template<unsigned int N, class T , class A >
void allocate ( pointer ptr,
difference_type_1  s,
const_reference  init 
)
protected

allocate memory for s pixels, write its address into the given pointer and initialize the pixels with init.

◆ allocate() [2/3]

template<unsigned int N, class T , class A >
template<class U >
void allocate ( pointer ptr,
difference_type_1  s,
U const init 
)
protected

allocate memory for s pixels, write its address into the given pointer and initialize the linearized pixels to the values of init.

◆ allocate() [3/3]

template<unsigned int N, class T , class A >
template<class U , class StrideTag >
void allocate ( pointer ptr,
MultiArrayView< N, U, StrideTag > const init 
)
protected

allocate memory, write its address into the given pointer and initialize it by copying the data from the given MultiArrayView.

◆ deallocate()

template<unsigned int N, class T , class A >
void deallocate ( pointer ptr,
difference_type_1  s 
)
protected

deallocate the memory (of length s) starting at the given address.

◆ operator=() [1/4]

template<unsigned int N, class T , class A >
MultiArray & operator= ( const MultiArray< N, T, A > &  rhs)

assignment.
If the size of rhs is the same as the left-hand side arrays's old size, only the data are copied. Otherwise, new storage is allocated, which invalidates all objects (array views, iterators) depending on the lhs array.

◆ operator=() [2/4]

template<unsigned int N, class T , class A >
template<class U , class StrideTag >
MultiArray & operator= ( const MultiArrayView< N, U, StrideTag > &  rhs)

assignment from arbitrary MultiArrayView.
If the size of rhs is the same as the left-hand side arrays's old size, only the data are copied. Otherwise, new storage is allocated, which invalidates all objects (array views, iterators) depending on the lhs array.

◆ operator=() [3/4]

template<unsigned int N, class T , class A >
MultiArray & operator= ( value_type const v)

assignment from scalar.
Equivalent to MultiArray::init(v).

◆ operator+=() [1/3]

template<unsigned int N, class T , class A >
template<class U , class StrideTag >
MultiArray & operator+= ( const MultiArrayView< N, U, StrideTag > &  rhs)

Add-assignment from arbitrary MultiArrayView. Fails with PreconditionViolation exception when the shapes do not match. If the left array has no data (hasData() is false), this function is equivalent to a normal assignment (i.e. an empty array is interpreted as a zero-array of appropriate size).

◆ operator-=() [1/3]

template<unsigned int N, class T , class A >
template<class U , class StrideTag >
MultiArray & operator-= ( const MultiArrayView< N, U, StrideTag > &  rhs)

Subtract-assignment from arbitrary MultiArrayView. Fails with PreconditionViolation exception when the shapes do not match. If the left array has no data (hasData() is false), this function is equivalent to an assignment of the negated rhs (i.e. an empty array is interpreted as a zero-array of appropriate size).

◆ operator*=() [1/3]

template<unsigned int N, class T , class A >
template<class U , class StrideTag >
MultiArray & operator*= ( const MultiArrayView< N, U, StrideTag > &  rhs)

Multiply-assignment from arbitrary MultiArrayView. Fails with PreconditionViolation exception when the shapes do not match. If the left array has no data (hasData() is false), this function is equivalent to reshape(rhs.shape()) with zero initialisation (i.e. an empty array is interpreted as a zero-array of appropriate size).

◆ operator/=() [1/3]

template<unsigned int N, class T , class A >
template<class U , class StrideTag >
MultiArray & operator/= ( const MultiArrayView< N, U, StrideTag > &  rhs)

Divide-assignment from arbitrary MultiArrayView. Fails with PreconditionViolation exception when the shapes do not match. If the left array has no data (hasData() is false), this function is equivalent to reshape(rhs.shape()) with zero initialisation (i.e. an empty array is interpreted as a zero-array of appropriate size).

◆ operator+=() [2/3]

template<unsigned int N, class T , class A >
MultiArray & operator+= ( const T &  rhs)

Add-assignment of a scalar.

◆ operator-=() [2/3]

template<unsigned int N, class T , class A >
MultiArray & operator-= ( const T &  rhs)

Subtract-assignment of a scalar.

◆ operator*=() [2/3]

template<unsigned int N, class T , class A >
MultiArray & operator*= ( const T &  rhs)

Multiply-assignment of a scalar.

◆ operator/=() [2/3]

template<unsigned int N, class T , class A >
MultiArray & operator/= ( const T &  rhs)

Divide-assignment of a scalar.

◆ operator=() [4/4]

template<unsigned int N, class T , class A >
template<class Expression >
MultiArray & operator= ( multi_math::MultiMathOperand< Expression > const rhs)

Assignment of an array expression. Fails with PreconditionViolation exception when the shapes do not match.

◆ operator+=() [3/3]

template<unsigned int N, class T , class A >
template<class Expression >
MultiArray & operator+= ( multi_math::MultiMathOperand< Expression > const rhs)

Add-assignment of an array expression. Fails with PreconditionViolation exception when the shapes do not match.

◆ operator-=() [3/3]

template<unsigned int N, class T , class A >
template<class Expression >
MultiArray & operator-= ( multi_math::MultiMathOperand< Expression > const rhs)

Subtract-assignment of an array expression. Fails with PreconditionViolation exception when the shapes do not match.

◆ operator*=() [3/3]

template<unsigned int N, class T , class A >
template<class Expression >
MultiArray & operator*= ( multi_math::MultiMathOperand< Expression > const rhs)

Multiply-assignment of an array expression. Fails with PreconditionViolation exception when the shapes do not match.

◆ operator/=() [3/3]

template<unsigned int N, class T , class A >
template<class Expression >
MultiArray & operator/= ( multi_math::MultiMathOperand< Expression > const rhs)

Divide-assignment of an array expression. Fails with PreconditionViolation exception when the shapes do not match.

◆ init()

template<unsigned int N, class T , class A >
template<class U >
MultiArray & init ( const U init)

init elements with a constant

◆ reshape() [1/2]

template<unsigned int N, class T , class A >
void reshape ( const difference_type shape)

Allocate new memory with the given shape and initialize with zeros.
Note: this operation invalidates all dependent objects (array views and iterators)

◆ reshape() [2/2]

template<unsigned int N, class T , class A >
void reshape ( const difference_type shape,
const_reference  init 
)

Allocate new memory with the given shape and initialize it with the given value.
Note: this operation invalidates all dependent objects (array views and iterators)

◆ swap()

template<unsigned int N, class T , class A >
void swap ( MultiArray< N, T, A > &  other)

Swap the contents with another MultiArray. This is fast, because no data are copied, but only pointers and shapes swapped. Note: this operation invalidates all dependent objects (array views and iterators)

◆ allocator()

template<unsigned int N, class T , class A >
allocator_type const & allocator ( ) const

get the allocator.

Member Data Documentation

◆ m_alloc

template<unsigned int N, class T , class A >
allocator_type m_alloc
protected

the allocator used to allocate the memory


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.12.1