[ VIGRA Homepage | Class Index | Function Index | File Index | Main Page ]
![]() |
Point operators for multi-dimensional arrays. | ![]() |
---|
Functions | |
template<...> void | initMultiArray (Iterator s, Shape const &shape, Accessor a, VALUETYPE v) |
Write a value to every pixel in a multi-dimensional array. | |
template<...> void | copyMultiArray (SrcIterator s, SrcShape const &shape, SrcAccessor src, DestIterator d, DestAccessor dest) |
Copy a multi-dimensional array. | |
template<...> void | transformMultiArray (SrcIterator s, SrcShape const &shape, SrcAccessor src, DestIterator d, DestAccessor dest, Functor const &f) |
Transform a multi-dimensional array with a unary function or functor. | |
template<...> void | combineTwoMultiArrays (SrcIterator1 s1, SrcShape const &shape, SrcAccessor1 src1, SrcIterator2 s2, SrcAccessor2 src2, DestIterator d, DestAccessor dest, Functor const &f) |
Combine two multi-dimensional arrays into one using a binary function or functor. | |
template<...> void | combineThreeMultiArrays (SrcIterator1 s1, SrcShape const &shape, SrcAccessor1 src1, SrcIterator2 s2, SrcAccessor2 src2, SrcIterator3 s3, SrcAccessor3 src3, DestIterator d, DestAccessor dest, Functor const &f) |
Combine three multi-dimensional arrays into one using a ternary function or functor. | |
template<...> void | inspectMultiArray (Iterator s, Shape const &shape, Accessor a, Functor &f) |
Call an analyzing functor at every element of a multi-dimensional array. | |
template<...> void | inspectTwoMultiArrays (Iterator1 s1, Shape const &shape, Accessor1 a1, Iterator2 s2, Accessor2 a2, Functor &f) |
Call an analyzing functor at all corresponding elements of two multi-dimensional arrays. |
Detailed Description |
#include "vigra/multi_pointoperators.hxx"
void combineThreeMultiArrays (...) |
Combine three multi-dimensional arrays into one using a ternary function or functor. Except for the fact that it operates on three input arrays, this function is identical to combineTwoMultiArrays(). Declarations: pass arguments explicitly: namespace vigra { template <class SrcIterator1, class SrcShape, class SrcAccessor1, class SrcIterator2, class SrcAccessor2, class SrcIterator3, class SrcAccessor3, class DestIterator, class DestAccessor, class Functor> void combineThreeMultiArrays(SrcIterator1 s1, SrcShape const & shape, SrcAccessor1 src1, SrcIterator2 s2, SrcAccessor2 src2, SrcIterator3 s3, SrcAccessor3 src3, DestIterator d, DestAccessor dest, Functor const & f); } use argument objects in conjunction with Argument Object Factories: namespace vigra { template <class SrcIterator1, class SrcShape, class SrcAccessor1, class SrcIterator2, class SrcAccessor2, class SrcIterator3, class SrcAccessor3, class DestIterator, class DestAccessor, class Functor> inline void combineThreeMultiArrays(triple<SrcIterator1, SrcShape, SrcAccessor1> const & src1, pair<SrcIterator2, SrcAccessor2> const & src2, pair<SrcIterator3, SrcAccessor3> const & src3, pair<DestIterator, DestAccessor> const & dest, Functor const & f); } Usage:
#include "vigra/multi_pointoperators.hxx"
#include <functional> // for plus typedef vigra::MultiArray<3, int> Array; Array src1(Array::size_type(100, 200, 50)), src2(Array::size_type(100, 200, 50)), src3(Array::size_type(100, 200, 50)), dest(Array::size_type(100, 200, 50)); ... vigra::combineThreeMultiArrays( srcMultiArrayRange(src1), srcMultiArray(src2), srcMultiArray(src3), destMultiArray(dest), SomeThreeArgumentFunctor()); |
void combineTwoMultiArrays (...) |
Combine two multi-dimensional arrays into one using a binary function or functor. This function can be applied in three modes:
The arrays must be represented by iterators compatible with vigra::MultiIterator, and the iteration range is specified by means of shape objects. If only a single source shape is given the destination array is assumed to have the same shape, and standard mode is applied. If three shapes are given, the size of corresponding dimensions must be either equal (standard copy), or the length of this dimension must be 1 in one or both source arrays (expand mode), or the destination length must be 1 (reduce mode). However, reduction and expansion cannot be executed at the same time, so the latter conditions are mutual exclusive, even if they apply to different dimensions. The function uses accessors to access the data elements. Declarations:
#include "vigra/multi_pointoperators.hxx" pass arguments explicitly: namespace vigra { template <class SrcIterator1, class SrcShape, class SrcAccessor1, class SrcIterator2, class SrcAccessor2, class DestIterator, class DestAccessor, class Functor> void combineTwoMultiArrays( SrcIterator1 s1, SrcShape const & shape, SrcAccessor1 src1, SrcIterator2 s2, SrcAccessor2 src2, DestIterator d, DestAccessor dest, Functor const & f); template <class SrcIterator1, class SrcShape1, class SrcAccessor1, class SrcIterator2, class SrcShape2, class SrcAccessor2, class DestIterator, class DestShape, class DestAccessor, class Functor> void combineTwoMultiArrays( SrcIterator1 s1, SrcShape1 const & sshape1, SrcAccessor1 src1, SrcIterator2 s2, SrcShape2 const & sshape2, SrcAccessor2 src2, DestIterator d, DestShape const & dshape, DestAccessor dest, Functor const & f); } use argument objects in conjunction with Argument Object Factories: namespace vigra { template <class SrcIterator1, class SrcShape, class SrcAccessor1, class SrcIterator2, class SrcAccessor2, class DestIterator, class DestAccessor, class Functor> void combineTwoMultiArrays( triple<SrcIterator1, SrcShape, SrcAccessor1> const & src1, pair<SrcIterator2, SrcAccessor2> const & src2, pair<DestIterator, DestAccessor> const & dest, Functor const & f); template <class SrcIterator1, class SrcShape1, class SrcAccessor1, class SrcIterator2, class SrcShape2, class SrcAccessor2, class DestIterator, class DestShape, class DestAccessor, class Functor> void combineTwoMultiArrays( triple<SrcIterator1, SrcShape1, SrcAccessor1> const & src1, triple<SrcIterator2, SrcShape2, SrcAccessor2> const & src2, triple<DestIterator, DestShape, DestAccessor> const & dest, Functor const & f); } Usage - Standard Mode: Source and destination arrays have the same size.
#include <functional> // for std::plus typedef vigra::MultiArray<3, int> Array; Array src1(Array::size_type(100, 200, 50)), src2(Array::size_type(100, 200, 50)), dest(Array::size_type(100, 200, 50)); ... vigra::combineTwoMultiArrays( srcMultiArrayRange(src1), srcMultiArray(src2), destMultiArray(dest), std::plus<int>()); Usage - Expand Mode:
One source array is only 2D (it has depth 1). This image will be added to every slice of the other source array, and the result if written into the corresponding destination slice. Note that the shapes of all arrays must be passed to the algorithm, so we use
#include <functional> // for std::plus typedef vigra::MultiArray<3, int> Array; Array src1(Array::size_type(100, 200, 1)), src2(Array::size_type(100, 200, 50)), dest(Array::size_type(100, 200, 50)); ... vigra::combineTwoMultiArrays( srcMultiArrayRange(src1), srcMultiArray(src2), destMultiArray(dest), std::plus<int>()); Usage - Reduce Mode:
The destination array is only 1D (it's width and height are 1). Thus, it will contain accumulated data for every slice of the source volumes (or for every frame, if the sources are intepreted as image sequences). In the example, we use vigra::ReduceFunctor together with a functor expression (see Functor Expressions) to calculate the total absolute difference of the gray values in every pair of source slices. Note that the shapes of all arrays must be passed to the algorithm in order for the reduction to work, so we use
#include <vigra/functorexpression.hxx> using namespace vigra::functor; typedef vigra::MultiArray<3, int> Array; Array src1(Array::size_type(100, 200, 50)), src2(Array::size_type(100, 200, 50)), dest(Array::size_type(1, 1, 50)); ... vigra::combineTwoMultiArrays( srcMultiArrayRange(src1), srcMultiArray(src2), destMultiArray(dest), reduceFunctor(Arg1() + abs(Arg2() - Arg3()), 0) ); // Arg1() is the sum accumulated so far, initialzed with 0 Required Interface:
In standard and expand mode, the functor must be a model of BinaryFunction (i.e. support function call with two arguments and a return value
MultiIterator src1_begin, src2_begin, dest_begin; SrcAccessor1 src1_accessor; SrcAccessor2 src2_accessor; DestAccessor dest_accessor; Functor functor; dest_accessor.set( functor(src1_accessor(src1_begin), src2_accessor(src2_begin)), dest_begin);
In reduce mode, it must be a model of BinaryAnalyser (i.e. support function call with two arguments and no return vakue
MultiIterator src1_begin, src2_begin, dest_begin; SrcAccessor1 src1_accessor; SrcAccessor2 src2_accessor; DestAccessor dest_accessor; FUNCTOR initial_functor, functor(initial_functor); assert(typeid(FunctorTraits<FUNCTOR>::isInitializer) == typeid(VigraTrueType)); assert(typeid(FunctorTraits<FUNCTOR>::isBinaryAnalyser) == typeid(VigraTrueType)); functor(src1_accessor(src1_begin), src2_accessor(src2_begin)); dest_accessor.set(functor(), dest_begin); |
void copyMultiArray (...) |
Copy a multi-dimensional array. This function can be applied in two modes:
The arrays must be represented by iterators compatible with vigra::MultiIterator, and the iteration range is specified by means of shape objects. If only the source shape is given the destination array is assumed to have the same shape, and standard mode is applied. If two shapes are given, the size of corresponding dimensions must be either equal (standard copy), or the source length must be 1 (expanding copy). The function uses accessors to access the data elements. Declarations:
#include "vigra/multi_pointoperators.hxx" pass arguments explicitly: namespace vigra { template <class SrcIterator, class SrcShape, class SrcAccessor, class DestIterator, class DestAccessor> void copyMultiArray(SrcIterator s, SrcShape const & shape, SrcAccessor src, DestIterator d, DestAccessor dest); template <class SrcIterator, class SrcShape, class SrcAccessor, class DestIterator, class DestShape, class DestAccessor> void copyMultiArray(SrcIterator s, SrcShape const & sshape, SrcAccessor src, DestIterator d, DestShape const & dshape, DestAccessor dest); } use argument objects in conjunction with Argument Object Factories: namespace vigra { template <class SrcIterator, class SrcShape, class SrcAccessor, class DestIterator, class DestAccessor> void copyMultiArray(triple<SrcIterator, SrcShape, SrcAccessor> const & src, pair<DestIterator, DestAccessor> const & dest); template <class SrcIterator, class SrcShape, class SrcAccessor, class DestIterator, class DestShape, class DestAccessor> void copyMultiArray(triple<SrcIterator, SrcShape, SrcAccessor> const & src, triple<DestIterator, DestShape, DestAccessor> const & dest); } Usage - Standard Mode:
typedef vigra::MultiArray<3, int> Array; Array src(Array::size_type(100, 200, 50)), dest(Array::size_type(100, 200, 50)); ... vigra::copyMultiArray(srcMultiArrayRange(src), destMultiArray(dest)); Usage - Expanding Mode:
The source array is only 2D (it has depth 1). Thus, the destination will contain 50 identical copies of this image. Note that the destination shape must be passed to the algorithm for the expansion to work, so we use
typedef vigra::MultiArray<3, int> Array; Array src(Array::size_type(100, 200, 1)), dest(Array::size_type(100, 200, 50)); ... vigra::copyMultiArray(srcMultiArrayRange(src), destMultiArrayRange(dest)); Required Interface:
MultiIterator src_begin, dest_begin; SrcAccessor src_accessor; DestAccessor dest_accessor; dest_accessor.set(src_accessor(src_begin), dest_begin); |
void initMultiArray (...) |
Write a value to every pixel in a multi-dimensional array. This function can be used to init the array which must be represented by a pair of iterators compatible to vigra::MultiIterator. It uses an accessor to access the data alements. Note that the iterator range must be specified by a shape object, because otherwise we could not control the range simultaneously in all dimensions (this is a necessary consequence of the vigra::MultiIterator design). Declarations: pass arguments explicitly: namespace vigra { template <class Iterator, class Shape, class Accessor, class VALUETYPE> void initMultiArray(Iterator s, Shape const & shape, Accessor a, VALUETYPE v); template <class Iterator, class Shape, class Accessor, class FUNCTOR> void initMultiArray(Iterator s, Shape const & shape, Accessor a, FUNCTOR const & f); } use argument objects in conjunction with Argument Object Factories: namespace vigra { template <class Iterator, class Shape, class Accessor, class VALUETYPE> void initMultiArray(triple<Iterator, Shape, Accessor> const & s, VALUETYPE v); template <class Iterator, class Shape, class Accessor, class FUNCTOR> void initMultiArray(triple<Iterator, Shape, Accessor> const & s, FUNCTOR const & f); } Usage:
#include "vigra/multi_pointoperators.hxx"
typedef vigra::MultiArray<3, int> Array; Array array(Array::size_type(100, 200, 50)); // zero the array vigra::initMultiArray(destMultiArrayRange(array), 0); Required Interface: The function accepts either a value that is copied into every destination element:
MultiIterator begin; Accessor accessor; VALUETYPE v; accessor.set(v, begin);
or a functor that is called (without argument) at every location, and the result is written into the current element. Internally, functors are recognized by the meta function
MultiIterator begin; Accessor accessor; FUNCTOR f; assert(typeid(FunctorTraits<FUNCTOR>::isInitializer) == typeid(VigraTrueType)); accessor.set(f(), begin); |
void inspectMultiArray (...) |
Call an analyzing functor at every element of a multi-dimensional array. This function can be used to collect statistics of the array etc. The results must be stored in the functor, which serves as a return value. The arrays must be represented by iterators compatible with vigra::MultiIterator. The function uses an accessor to access the pixel data. Note that the iterator range must be specified by a shape object, because otherwise we could not control the range simultaneously in all dimensions (this is a necessary consequence of the vigra::MultiIterator design). Declarations: pass arguments explicitly: namespace vigra { template <class Iterator, class Shape, class Accessor, class Functor> void inspectMultiArray(Iterator s, Shape const & shape, Accessor a, Functor & f); } use argument objects in conjunction with Argument Object Factories: namespace vigra { template <class Iterator, class Shape, class Accessor, class Functor> void inspectMultiArray(triple<Iterator, Shape, Accessor> const & s, Functor & f); } Usage:
#include "vigra/multi_pointoperators.hxx"
typedef vigra::MultiArray<3, int> Array; Array array(Array::size_type(100, 200, 50)); // init functor vigra::FindMinMax<int> minmax; vigra::inspectMultiArray(srcMultiArrayRange(array), minmax); cout << "Min: " << minmax.min << " Max: " << minmax.max; Required Interface:
MultiIterator src_begin; Accessor accessor; Functor functor; functor(accessor(src_begin)); |
void inspectTwoMultiArrays (...) |
Call an analyzing functor at all corresponding elements of two multi-dimensional arrays. This function can be used to collect statistics of the array etc. The results must be stored in the functor, which serves as a return value. The arrays must be represented by iterators compatible with vigra::MultiIterator. The function uses an accessor to access the pixel data. Note that the iterator range must be specified by a shape object, because otherwise we could not control the range simultaneously in all dimensions (this is a necessary consequence of the vigra::MultiIterator design). Declarations: pass arguments explicitly: namespace vigra { template <class Iterator1, class Shape, class Accessor1, class Iterator2, class Accessor2, class Functor> void inspectTwoMultiArrays(Iterator1 s1, Shape const & shape, Accessor1 a1, Iterator2 s2, Accessor2 a2, Functor & f); } use argument objects in conjunction with Argument Object Factories: namespace vigra { template <class Iterator1, class Shape1, class Accessor1, class Iterator2, class Accessor2, class Functor> void inspectTwoMultiArrays(triple<Iterator1, Shape1, Accessor1> const & s1, pair<Iterator2, Accessor2> const & s2, Functor & f); } Usage:
#include "vigra/multi_pointoperators.hxx"
typedef vigra::MultiArray<3, int> Array; Array array1(Array::size_type(100, 200, 50)), array2(Array::size_type(100, 200, 50)); // init functor SomeStatisticsFunctor stats(..); vigra::inspectTwoMultiArrays(srcMultiArrayRange(array1), srcMultiArray(array2), stats); Required Interface:
MultiIterator src1_begin, src2_begin; Accessor a1, a2; Functor functor; functor(a1(src1_begin), a2(src2_begin)); |
void transformMultiArray (...) |
Transform a multi-dimensional array with a unary function or functor. This function can be applied in three modes:
The arrays must be represented by iterators compatible with vigra::MultiIterator, and the iteration range is specified by means of shape objects. If only the source shape is given the destination array is assumed to have the same shape, and standard mode is applied. If two shapes are given, the size of corresponding dimensions must be either equal (standard copy), or the source length must be 1 (expand mode), or the destination length must be 1 (reduce mode). However, reduction and expansion cannot be executed at the same time, so the latter conditions are mutual exclusive, even if they apply to different dimensions. The function uses accessors to access the data elements. Declarations:
#include "vigra/multi_pointoperators.hxx" pass arguments explicitly: namespace vigra { template <class SrcIterator, class SrcShape, class SrcAccessor, class DestIterator, class DestAccessor, class Functor> void transformMultiArray(SrcIterator s, SrcShape const & shape, SrcAccessor src, DestIterator d, DestAccessor dest, Functor const & f); template <class SrcIterator, class SrcShape, class SrcAccessor, class DestIterator, class DestShape, class DestAccessor, class Functor> void transformMultiArray(SrcIterator s, SrcShape const & sshape, SrcAccessor src, DestIterator d, DestShape const & dshape, DestAccessor dest, Functor const & f); } use argument objects in conjunction with Argument Object Factories: namespace vigra { template <class SrcIterator, class SrcShape, class SrcAccessor, class DestIterator, class DestAccessor, class Functor> void transformMultiArray(triple<SrcIterator, SrcShape, SrcAccessor> const & src, pair<DestIterator, DestAccessor> const & dest, Functor const & f); template <class SrcIterator, class SrcShape, class SrcAccessor, class DestIterator, class DestShape, class DestAccessor, class Functor> void transformMultiArray(triple<SrcIterator, SrcShape, SrcAccessor> const & src, triple<DestIterator, DestShape, DestAccessor> const & dest, Functor const & f) } Usage - Standard Mode: Source and destination array have the same size.
#include <cmath> // for sqrt() typedef vigra::MultiArray<3, float> Array; Array src(Array::size_type(100, 200, 50)), dest(Array::size_type(100, 200, 50)); ... vigra::transformMultiArray(srcMultiArrayRange(src), destMultiArray(dest), (float(*)(float))&std::sqrt ); Usage - Expand Mode:
The source array is only 2D (it has depth 1). Thus, the destination will contain 50 identical copies of the transformed source array. Note that the destination shape must be passed to the algorithm for the expansion to work, so we use
#include <cmath> // for sqrt() typedef vigra::MultiArray<3, float> Array; Array src(Array::size_type(100, 200, 1)), dest(Array::size_type(100, 200, 50)); ... vigra::transformMultiArray(srcMultiArrayRange(src), destMultiArrayRange(dest), (float(*)(float))&std::sqrt ); Usage - Reduce Mode:
The destination array is only 1D (it's width and height are 1). Thus, it will contain accumulated data for every slice of the source volume (or for every frame, if the source is intepreted as an image sequence). In the example, we use the functor vigra::FindAverage to calculate the average gray value of every slice. Note that the destination shape must also be passed for the reduction to work, so we use
typedef vigra::MultiArray<3, float> Array; Array src(Array::size_type(100, 200, 50)), dest(Array::size_type(1, 1, 50)); ... vigra::transformMultiArray(srcMultiArrayRange(src), destMultiArrayRange(dest), vigra::FindAverage<float>() ); Required Interface:
In standard and expand mode, the functor must be a model of UnaryFunction (i.e. support function call with one argument and a return value
MultiIterator src_begin, src_end, dest_begin; SrcAccessor src_accessor; DestAccessor dest_accessor; Functor functor; dest_accessor.set(functor(src_accessor(src_begin)), dest_begin);
In reduce mode, it must be a model of UnaryAnalyser (i.e. support function call with one argument and no return vakue
MultiIterator src_begin, src_end, dest_begin; SrcAccessor src_accessor; DestAccessor dest_accessor; FUNCTOR initial_functor, functor(initial_functor); assert(typeid(FunctorTraits<FUNCTOR>::isInitializer) == typeid(VigraTrueType)); assert(typeid(FunctorTraits<FUNCTOR>::isUnaryAnalyser) == typeid(VigraTrueType)); functor(src_accessor(src_begin)); dest_accessor.set(functor(), dest_begin); |
© Ullrich Köthe (koethe@informatik.uni-hamburg.de) |
html generated using doxygen and Python
|