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

| Symmetry Detection |

## Functions
template<... >
void | radialSymmetryTransform (...)
| Find centers of radial symmetry in an image.

## Detailed Description

Measure the local symmetry at each pixel.

## Function Documentation

void vigra::radialSymmetryTransform | ( |  | ... | ) |

Find centers of radial symmetry in an image.

This algorithm implements the Fast Radial Symmetry Transform according to [G. Loy, A. Zelinsky: "A Fast Radial Symmetry Transform for Detecting Points of Interest", in: A. Heyden et al. (Eds.): Proc. of 7th European Conf. on Computer Vision, Part 1, pp. 358-368, Springer LNCS 2350, 2002]. Minima of the algorithm response mark dark blobs, maxima correspond to light blobs. The "radial strictness parameter" is fixed at `alpha` = 2.0, the spatial spreading of the raw response is done by a Gaussian convolution at `0.25*scale` (these values are recommendations from the paper). Loy and Zelinsky additionally propose to add the operator response from several scales (see usage example below).

Declarations:

pass arguments explicitly:

        namespace vigra {
            template <class SrcIterator, class SrcAccessor,
                      class DestIterator, class DestAccessor>
            void
            radialSymmetryTransform(SrcIterator sul, SrcIterator slr, SrcAccessor as,
                                    DestIterator dul, DestAccessor ad,
                                    double scale)
        }

use argument objects in conjunction with Argument Object Factories :

        namespace vigra {
            template <class SrcIterator, class SrcAccessor,
                      class DestIterator, class DestAccessor>
            inline
            void radialSymmetryTransform(
                   triple<SrcIterator, SrcIterator, SrcAccessor> src,
                   pair<DestIterator, DestAccessor> dest,
                   double scale)
        }

Usage:

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

        vigra::BImage src(w,h), centers(w,h);
        vigra::FImage symmetry(w,h);

        // empty result image
        centers.init(128);
        symmetry.init(0.0);

        // input width of edge detection filter
        for(double scale = 2.0; scale <= 8.0; scale *= 2.0)
        {
            vigra::FImage tmp(w,h);

            // find centers of symmetry
            radialSymmetryTransform(srcImageRange(src), destImage(tmp), scale);

            combineTwoImages(srcImageRange(symmetry), srcImage(tmp), destImage(symmetry),
                             std::plus<float>());
        }

        localMinima(srcImageRange(symmetry), destImage(centers), 0);
        localMaxima(srcImageRange(symmetry), destImage(centers), 255);

Required Interface:

        SrcImageIterator src_upperleft, src_lowerright;
        DestImageIterator dest_upperleft;

        SrcAccessor src_accessor;
        DestAccessor dest_accessor;

        // SrcAccessor::value_type must be a built-in type
        SrcAccessor::value_type u = src_accessor(src_upperleft);

        dest_accessor.set(u, dest_upperleft);

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