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

Image Registration |

## Namespaces
namespace | vigra::detail
## Functions
template<class SrcIterator, class DestIterator>
linalg::TemporaryMatrix< double > | affineMatrix2DFromCorrespondingPoints (SrcIterator s, SrcIterator send, DestIterator d)
| Create homogeneous matrix that maps corresponding points onto each other.
template<... >
void | estimateAffineTransform (...)
| Estimate the optical flow between two images according to an affine transform model (e.g. translation, rotation, non-uniform scaling, and shearing).
template<... >
void | estimateSimilarityTransform (...)
| Estimate the optical flow between two images according to a similarity transform model (e.g. translation, rotation, and uniform scaling).
template<... >
void | estimateTranslation (...)
| Estimate the optical flow between two images according to a translation model.

## Function Documentation

template<class SrcIterator, class DestIterator>
linalg::TemporaryMatrix<double> vigra::affineMatrix2DFromCorrespondingPoints | ( | SrcIterator | s,
|  | SrcIterator | send,
|  | DestIterator | d |
| ) |  |  |

Create homogeneous matrix that maps corresponding points onto each other.

For use with affineWarpImage(). Since only two corresponding points are given, the matrix will not use a full affine transform, but only a similarity transform (translation, rotation, and uniform scaling). See \

template<... >
void vigra::estimateTranslation | ( |  | ... | ) |

Estimate the optical flow between two images according to a translation model.

Sorry, no detailedDocumentation() available yet.

Declarations:

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

pass arguments explicitly:

        namespace vigra {
            template <class SrcIterator, class SrcAccessor,
                      class DestIterator, class DestAccessor,
                      int SPLINEORDER = 2>
            void
            estimateTranslation(SrcIterator sul, SrcIterator slr, SrcAccessor src,
                                DestIterator dul, DestIterator dlr, DestAccessor dest,
                                Matrix<double> & affineMatrix,
                                AffineMotionEstimationOptions<SPLINEORDER> const & options =
                                                            AffineMotionEstimationOptions<>())
        }

use argument objects in conjunction with Argument Object Factories :

        namespace vigra {
            template <class SrcIterator, class SrcAccessor,
                      class DestIterator, class DestAccessor,
                      int SPLINEORDER = 2>
            void
            estimateTranslation(triple<SrcIterator, SrcIterator, SrcAccessor> src,
                                triple<DestIterator, DestIterator, DestAccessor> dest,
                                Matrix<double> & affineMatrix,
                                AffineMotionEstimationOptions<SPLINEORDER> const & options =
                                                            AffineMotionEstimationOptions<>())
        }

template<... >
void vigra::estimateSimilarityTransform | ( |  | ... | ) |

Estimate the optical flow between two images according to a similarity transform model (e.g. translation, rotation, and uniform scaling).

Sorry, no detailedDocumentation() available yet.

Declarations:

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

pass arguments explicitly:

        namespace vigra {
            template <class SrcIterator, class SrcAccessor,
                      class DestIterator, class DestAccessor,
                      int SPLINEORDER = 2>
            void
            estimateSimilarityTransform(SrcIterator sul, SrcIterator slr, SrcAccessor src,
                                DestIterator dul, DestIterator dlr, DestAccessor dest,
                                Matrix<double> & affineMatrix,
                                AffineMotionEstimationOptions<SPLINEORDER> const & options =
                                                            AffineMotionEstimationOptions<>())
        }

use argument objects in conjunction with Argument Object Factories :

        namespace vigra {
            template <class SrcIterator, class SrcAccessor,
                      class DestIterator, class DestAccessor,
                      int SPLINEORDER = 2>
            void
            estimateSimilarityTransform(triple<SrcIterator, SrcIterator, SrcAccessor> src,
                                triple<DestIterator, DestIterator, DestAccessor> dest,
                                Matrix<double> & affineMatrix,
                                AffineMotionEstimationOptions<SPLINEORDER> const & options =
                                                            AffineMotionEstimationOptions<>())
        }

template<... >
void vigra::estimateAffineTransform | ( |  | ... | ) |

Estimate the optical flow between two images according to an affine transform model (e.g. translation, rotation, non-uniform scaling, and shearing).

Sorry, no detailedDocumentation() available yet.

Declarations:

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

pass arguments explicitly:

        namespace vigra {
            template <class SrcIterator, class SrcAccessor,
                      class DestIterator, class DestAccessor,
                      int SPLINEORDER = 2>
            void
            estimateAffineTransform(SrcIterator sul, SrcIterator slr, SrcAccessor src,
                                DestIterator dul, DestIterator dlr, DestAccessor dest,
                                Matrix<double> & affineMatrix,
                                AffineMotionEstimationOptions<SPLINEORDER> const & options =
                                                            AffineMotionEstimationOptions<>())
        }

use argument objects in conjunction with Argument Object Factories :

        namespace vigra {
            template <class SrcIterator, class SrcAccessor,
                      class DestIterator, class DestAccessor,
                      int SPLINEORDER = 2>
            void
            estimateAffineTransform(triple<SrcIterator, SrcIterator, SrcAccessor> src,
                                triple<DestIterator, DestIterator, DestAccessor> dest,
                                Matrix<double> & affineMatrix,
                                AffineMotionEstimationOptions<SPLINEORDER> const & options =
                                                            AffineMotionEstimationOptions<>())
        }

© 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.7.1 (3 Dec 2010)