vigra - Euclidean distance transform for multi-dimensional arrays.

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

| Euclidean distance transform for multi-dimensional arrays. |

## Functions
template<... >
void | separableMultiDistance (...)
| Euclidean distance on multi-dimensional arrays.
template<... >
void | separableMultiDistSquared (...)
| Euclidean distance squared on multi-dimensional arrays.

## Detailed Description

These functions perform the Euclidean distance transform an arbitrary dimensional array that is specified by iterators (compatible to Multi-dimensional Array Iterators) and shape objects. It can therefore be applied to a wide range of data structures (vigra::MultiArrayView, vigra::MultiArray etc.).

## Function Documentation

void vigra::separableMultiDistSquared | ( |  | ... | ) |

Euclidean distance squared on multi-dimensional arrays.

The algorithm is taken from Donald Bailey: "An Efficient Euclidean Distance Transform", Proc. IWCIA'04, Springer LNCS 3322, 2004.

Declarations:

pass arguments explicitly:

        namespace vigra {
            // explicitly specify pixel pitch for each coordinate
            template <class SrcIterator, class SrcShape, class SrcAccessor,
                      class DestIterator, class DestAccessor, class Array>
            void
            separableMultiDistSquared( SrcIterator s, SrcShape const & shape, SrcAccessor src,
                                       DestIterator d, DestAccessor dest,
                                       bool background,
                                       Array const & pixelPitch);

            // use default pixel pitch = 1.0 for each coordinate
            template <class SrcIterator, class SrcShape, class SrcAccessor,
                      class DestIterator, class DestAccessor>
            void
            separableMultiDistSquared(SrcIterator siter, SrcShape const & shape, SrcAccessor src,
                                      DestIterator diter, DestAccessor dest,
                                      bool background);

        }

use argument objects in conjunction with Argument Object Factories :

        namespace vigra {
            // explicitly specify pixel pitch for each coordinate
            template <class SrcIterator, class SrcShape, class SrcAccessor,
                      class DestIterator, class DestAccessor, class Array>
            void
            separableMultiDistSquared( triple<SrcIterator, SrcShape, SrcAccessor> const & source,
                                       pair<DestIterator, DestAccessor> const & dest,
                                       bool background,
                                       Array const & pixelPitch);

            // use default pixel pitch = 1.0 for each coordinate
            template <class SrcIterator, class SrcShape, class SrcAccessor,
                      class DestIterator, class DestAccessor>
            void
            separableMultiDistSquared(triple<SrcIterator, SrcShape, SrcAccessor> const & source,
                                      pair<DestIterator, DestAccessor> const & dest,
                                      bool background);

        }

This function performs a squared Euclidean squared distance transform on the given multi-dimensional array. Both source and destination arrays are represented by iterators, shape objects and accessors. The destination array is required to already have the correct size.

This function expects a mask as its source, where background pixels are marked as zero, and non-background pixels as non-zero. If the parameter background is true, then the squared distance of all background pixels to the nearest object is calculated. Otherwise, the distance of all object pixels to the nearest background pixel is calculated.

Optionally, one can pass an array that specifies the pixel pitch in each direction. This is necessary when the data have non-uniform resolution (as is common in confocal microscopy, for example).

This function may work in-place, which means that `siter == diter` is allowed. A full-sized internal array is only allocated if working on the destination array directly would cause overflow errors (i.e. if `NumericTraits<typename DestAccessor::value_type>::max() < N * M*M`, where M is the size of the largest dimension of the array.

Usage:

#include <vigra/multi_distance.hxx>

        MultiArray<3, unsigned char>::size_type shape(width, height, depth);
        MultiArray<3, unsigned char> source(shape);
        MultiArray<3, unsigned int> dest(shape);
        ...

        // Calculate Euclidean distance squared for all background pixels
        separableMultiDistSquared(srcMultiArrayRange(source), destMultiArray(dest), true);

See also:
  vigra::distanceTransform(), vigra::separableMultiDistance()

void vigra::separableMultiDistance | ( |  | ... | ) |

Euclidean distance on multi-dimensional arrays.

Declarations:

pass arguments explicitly:

        namespace vigra {
            // explicitly specify pixel pitch for each coordinate
            template <class SrcIterator, class SrcShape, class SrcAccessor,
                      class DestIterator, class DestAccessor, class Array>
            void
            separableMultiDistance( SrcIterator s, SrcShape const & shape, SrcAccessor src,
                                    DestIterator d, DestAccessor dest,
                                    bool background,
                                    Array const & pixelPitch);

            // use default pixel pitch = 1.0 for each coordinate
            template <class SrcIterator, class SrcShape, class SrcAccessor,
                      class DestIterator, class DestAccessor>
            void
            separableMultiDistance(SrcIterator siter, SrcShape const & shape, SrcAccessor src,
                                   DestIterator diter, DestAccessor dest,
                                   bool background);

        }

use argument objects in conjunction with Argument Object Factories :

        namespace vigra {
            // explicitly specify pixel pitch for each coordinate
            template <class SrcIterator, class SrcShape, class SrcAccessor,
                      class DestIterator, class DestAccessor, class Array>
            void
            separableMultiDistance( triple<SrcIterator, SrcShape, SrcAccessor> const & source,
                                    pair<DestIterator, DestAccessor> const & dest,
                                    bool background,
                                    Array const & pixelPitch);

            // use default pixel pitch = 1.0 for each coordinate
            template <class SrcIterator, class SrcShape, class SrcAccessor,
                      class DestIterator, class DestAccessor>
            void
            separableMultiDistance(triple<SrcIterator, SrcShape, SrcAccessor> const & source,
                                   pair<DestIterator, DestAccessor> const & dest,
                                   bool background);

        }

This function performs a Euclidean distance transform on the given multi-dimensional array. It simply calls separableMultiDistSquared() and takes the pixel-wise square root of the result. See separableMultiDistSquared() for more documentation.

Usage:

#include <vigra/multi_distance.hxx>

        MultiArray<3, unsigned char>::size_type shape(width, height, depth);
        MultiArray<3, unsigned char> source(shape);
        MultiArray<3, float> dest(shape);
        ...

        // Calculate Euclidean distance squared for all background pixels
        separableMultiDistance(srcMultiArrayRange(source), destMultiArray(dest), true);

See also:
  vigra::distanceTransform(), vigra::separableMultiDistSquared()

© 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)