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

| Geometric Transformations |

## Functions

template<... >
void | affineWarpImage (...)
| Warp an image according to an affine transformation.
template<... >
void | reflectImage (...)
| Reflect image horizontally or vertically.
template<... >
void | resampleImage (...)
| Resample image by a given factor.
template<... >
void | resizeImageCatmullRomInterpolation (...)
| Resize image using the Catmull/Rom interpolation function.
template<... >
void | resizeImageCoscotInterpolation (...)
| Resize image using the Coscot interpolation function.
template<... >
void | resizeImageLinearInterpolation (...)
| Resize image using linear interpolation.
template<... >
void | resizeImageNoInterpolation (...)
| Resize image by repeating the nearest pixel values.
template<... >
void | resizeImageSplineInterpolation (...)
| Resize image using B-spline interpolation.
template<... >
void | resizeMultiArraySplineInterpolation (...)
| Resize MultiArray using B-spline interpolation.
template<... >
void | rotateImage (...)
| Rotate image by an arbitrary angle.
linalg::TemporaryMatrix< double > | rotationMatrix2DDegrees (double angle, TinyVector< double, 2 > const &center)
| Create homogeneous matrix representing a 2D rotation about the given point.
linalg::TemporaryMatrix< double > | rotationMatrix2DDegrees (double angle)
| Create homogeneous matrix representing a 2D rotation about the coordinate origin.
linalg::TemporaryMatrix< double > | rotationMatrix2DRadians (double angle, TinyVector< double, 2 > const &center)
| Create homogeneous matrix representing a 2D rotation about the given point.
linalg::TemporaryMatrix< double > | rotationMatrix2DRadians (double angle)
| Create homogeneous matrix representing a 2D rotation about the coordinate origin.
linalg::TemporaryMatrix< double > | scalingMatrix2D (double sx, double sy)
| Create homogeneous matrix representing a 2D non-uniform scaling about the coordinate origin.
linalg::TemporaryMatrix< double > | scalingMatrix2D (double scalingFactor)
| Create homogeneous matrix representing a 2D uniform scaling about the coordinate origin.
linalg::TemporaryMatrix< double > | shearMatrix2D (double s01, double s10)
| Create homogeneous matrix representing a 2D shearing.
linalg::TemporaryMatrix< double > | translationMatrix2D (TinyVector< double, 2 > const &shift)
| Create homogeneous matrix representing a 2D translation.
template<... >
void | transposeImage (...)
| Transpose an image over the major or minor diagonal.

## Detailed Description

Zoom up and down by repeating pixels, or using various interpolation schemes.

See also: resamplingConvolveImage(), resampleImage(), resizeMultiArraySplineInterpolation()

#include <vigra/stdimagefunctions.hxx>
or
#include <vigra/resizeimage.hxx>

## Function Documentation

linalg::TemporaryMatrix<double> vigra::translationMatrix2D | ( | TinyVector< double, 2 > const & | shift | ) |

Create homogeneous matrix representing a 2D translation.

For use with affineWarpImage().

linalg::TemporaryMatrix<double> vigra::scalingMatrix2D | ( | double | scalingFactor | ) |

Create homogeneous matrix representing a 2D uniform scaling about the coordinate origin.

For use with affineWarpImage().

linalg::TemporaryMatrix<double> vigra::scalingMatrix2D | ( | double | sx,
|  | double | sy |
| ) |  |  |

Create homogeneous matrix representing a 2D non-uniform scaling about the coordinate origin.

For use with affineWarpImage().

linalg::TemporaryMatrix<double> vigra::shearMatrix2D | ( | double | s01,
|  | double | s10 |
| ) |  |  |

Create homogeneous matrix representing a 2D shearing.

For use with affineWarpImage().

linalg::TemporaryMatrix<double> vigra::rotationMatrix2DRadians | ( | double | angle | ) |

Create homogeneous matrix representing a 2D rotation about the coordinate origin.

For use with affineWarpImage(). Angle must be in radians.

linalg::TemporaryMatrix<double> vigra::rotationMatrix2DDegrees | ( | double | angle | ) |

Create homogeneous matrix representing a 2D rotation about the coordinate origin.

For use with affineWarpImage(). Angle must be in degrees.

linalg::TemporaryMatrix<double> vigra::rotationMatrix2DRadians | ( | double | angle,
|  | TinyVector< double, 2 > const & | center |
| ) |  |  |

Create homogeneous matrix representing a 2D rotation about the given point.

For use with affineWarpImage(). Angle must be in radians.

linalg::TemporaryMatrix<double> vigra::rotationMatrix2DDegrees | ( | double | angle,
|  | TinyVector< double, 2 > const & | center |
| ) |  |  |

Create homogeneous matrix representing a 2D rotation about the given point.

For use with affineWarpImage(). Angle must be in degrees.

template<... >
void rotateImage | ( |  | ... | ) |

Rotate image by an arbitrary angle.

Rotate image by a multiple of 90 degrees.

The algorithm performs a rotation about the given center point (the image center by default) using the given SplineImageView for interpolation. The destination image must have the same size as the source SplineImageView. The rotation is counter-clockwise, and the angle must be given in degrees.

Declarations:

pass arguments explicitly:

        namespace vigra {
            // rotate about given center point
            template <int ORDER, class T,
                      class DestIterator, class DestAccessor>
            void rotateImage(SplineImageView<ORDER, T> const & src,
                             DestIterator id, DestAccessor dest,
                             double angleInDegree, TinyVector<double, 2> const & center);

            // rotate about image center
            template <int ORDER, class T,
                      class DestIterator, class DestAccessor>
            void
            rotateImage(SplineImageView<ORDER, T> const & src,
                        DestIterator id, DestAccessor dest,
                        double angleInDegree)
        }

use argument objects in conjunction with Argument Object Factories :

        namespace vigra {
            // rotate about given center point
            template <int ORDER, class T,
                      class DestIterator, class DestAccessor>
            void
            rotateImage(SplineImageView<ORDER, T> const & src,
                        pair<DestImageIterator, DestAccessor> dest,
                        double angleInDegree, TinyVector<double, 2> const & center);

            // rotate about image center
            template <int ORDER, class T,
                      class DestIterator, class DestAccessor>
            void
            rotateImage(SplineImageView<ORDER, T> const & src,
                        pair<DestImageIterator, DestAccessor> dest,
                        double angleInDegree);
        }

Usage:

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

        Image src(width, height);
        vigra::SplineImageView<3, Image::value_type> spline(srcImageRange(src));

        Image dest(width, height);

        vigra::rotateImage(spline, destImage(dest), 38.5);

Required Interface:

        DestImageIterator dest_upperleft;

        double x = ..., y = ...;

        if (spline.isInside(x,y))
            dest_accessor.set(spline(x, y), dest_upperleft);

This algorithm just copies the pixels in the appropriate new order. It expects the destination image to have the correct shape for the desired rotation.

Declarations:

pass arguments explicitly:

        namespace vigra {
            template <class SrcIterator, class SrcAccessor,
                      class DestIterator, class DestAccessor>
            void
            rotateImage(SrcIterator is, SrcIterator end, SrcAccessor as,
                        DestIterator id, DestAccessor ad, int rotation);
        }

use argument objects in conjunction with Argument Object Factories :

        namespace vigra {
            template <class SrcImageIterator, class SrcAccessor,
                  class DestImageIterator, class DestAccessor>
            inline void
            rotateImage(triple<SrcImageIterator, SrcImageIterator, SrcAccessor> src,
                        pair<DestImageIterator, DestAccessor> dest, int rotation);
        }

Usage:

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

        Image dest(src.height(), src.width()); // note that width and height are exchanged

        vigra::rotateImage(srcImageRange(src), destImage(dest), 90);

Required Interface:

        SrcImageIterator src_upperleft, src_lowerright;
        DestImageIterator dest_upperleft;

        SrcAccessor src_accessor;

        dest_accessor.set(src_accessor(src_upperleft), dest_upperleft);

Preconditions:

        src_lowerright.x - src_upperleft.x > 1
        src_lowerright.y - src_upperleft.y > 1

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

Warp an image according to an affine transformation.

Declarations:

pass arguments explicitly:

        namespace vigra {
            template <int ORDER, class T,
                    class DestIterator, class DestAccessor,
                    class C>
            void affineWarpImage(SplineImageView<ORDER, T> const & src,
                                DestIterator dul, DestIterator dlr, DestAccessor dest,
                                MultiArrayView<2, double, C> const & affineMatrix);
        }

use argument objects in conjunction with Argument Object Factories :

        namespace vigra {
            template <int ORDER, class T,
                    class DestIterator, class DestAccessor,
                    class C>
            void affineWarpImage(SplineImageView<ORDER, T> const & src,
                                triple<DestIterator, DestIterator, DestAccessor> dest,
                                MultiArrayView<2, double, C> const & affineMatrix);
        }

The algorithm applies the given affineMatrix to the destination coordinates and copies the image value from the resulting source coordinates, using the given SplineImageView src for interpolation. If the resulting coordinate is outside the source image, nothing will be writen at that destination point.

            for all dest pixels:
                currentSrcCoordinate = affineMatrix * currentDestCoordinate;
                if src.isInside(currentSrcCoordinate):
                    dest[currentDestCoordinate] = src[currentSrcCoordinate]; // copy an interpolated value

The matrix represent a 2-dimensional affine transform by means of homogeneous coordinates, i.e. it must be a 3x3 matrix whose last row is (0,0,1).

Usage:

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

        Image src(width, height);
        vigra::SplineImageView<3, Image::value_type> spline(srcImageRange(src));

        Image dest1(width, height);

        // equivalent (up to round-off errors) with
        //     rotateImage(spline, destImage(dest1), 45.0);
        TinyVector<double, 2> center((width-1.0)/2.0, (height-1.0)/2.0);
        affineWarpImage(spline, destImageRange(dest1), rotationMatrix2DDegrees(45.0, center));

        Image dest2(2*width-1, 2*height-1);

        // equivalent (up to round-off errors) with
        //     resizeImageSplineInterpolation(srcImageRange(img), destImageRange(dest2));
        // note that scaleFactor = 0.5, because we must pass the transformation from destination to source
        affineWarpImage(spline, destImageRange(dest2), scalingMatrix2D(0.5));

Required Interface:

        DestImageIterator dest_upperleft;

        double x = ..., y = ...;

        if (spline.isInside(x,y))
            dest_accessor.set(spline(x, y), dest_upperleft);

See also: Functions to specify affine transformation: translationMatrix2D(), scalingMatrix2D(), shearMatrix2D(), rotationMatrix2DRadians(), rotationMatrix2DDegrees()

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

Reflect image horizontally or vertically.

The reflection direction refers to the reflection axis, i.e. horizontal reflection turns the image upside down, vertical reflection changes left for right. The directions are selected by the enum values `vigra::horizontal` and `vigra::vertical`. The two directions can also be "or"ed together to perform both reflections simultaneously (see example below) -- this is the same as a 180 degree rotation.

Declarations:

pass arguments explicitly:

        namespace vigra {
            template <class SrcIterator, class SrcAccessor,
                      class DestIterator, class DestAccessor>
            void
            reflectImage(SrcIterator is, SrcIterator end, SrcAccessor as,
                         DestIterator id, DestAccessor ad, Reflect axis);
        }

use argument objects in conjunction with Argument Object Factories :

        namespace vigra {
            template <class SrcImageIterator, class SrcAccessor,
                  class DestImageIterator, class DestAccessor>
            inline void
            reflectImage(triple<SrcImageIterator, SrcImageIterator, SrcAccessor> src,
                         pair<DestImageIterator, DestAccessor> dest, Reflect axis);
        }

Usage:

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

        Image dest(src.width(), src.height());

        vigra::reflectImage(srcImageRange(src), destImage(dest), vigra::horizontal | vigra::vertical);

Required Interface:

        SrcImageIterator src_upperleft, src_lowerright;
        DestImageIterator dest_upperleft;

        SrcAccessor src_accessor;

        dest_accessor.set(src_accessor(src_upperleft), dest_upperleft);

Preconditions:

        src_lowerright.x - src_upperleft.x > 1
        src_lowerright.y - src_upperleft.y > 1

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

Transpose an image over the major or minor diagonal.

The transposition direction refers to the axis, i.e. major transposition turns the upper right corner into the lower left one, whereas minor transposition changes the upper left corner into the lower right one. The directions are selected by the enum values `vigra::major` and `vigra::minor`. The two directions can also be "or"ed together to perform both reflections simultaneously (see example below) -- this is the same as a 180 degree rotation.

Declarations:

pass arguments explicitly:

        namespace vigra {
            template <class SrcIterator, class SrcAccessor,
                      class DestIterator, class DestAccessor>
            void
            transposeImage(SrcIterator is, SrcIterator end, SrcAccessor as,
                           DestIterator id, DestAccessor ad, Transpose axis);
        }

use argument objects in conjunction with Argument Object Factories :

        namespace vigra {
            template <class SrcImageIterator, class SrcAccessor,
                  class DestImageIterator, class DestAccessor>
            inline void
            transposeImage(triple<SrcImageIterator, SrcImageIterator, SrcAccessor> src,
                           pair<DestImageIterator, DestAccessor> dest, Transpose axis);
        }

Usage:

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

        Image dest(src.width(), src.height());

        vigra::transposeImage(srcImageRange(src), destImage(dest), vigra::major | vigra::minor);

Required Interface:

        SrcImageIterator src_upperleft, src_lowerright;
        DestImageIterator dest_upperleft;

        SrcAccessor src_accessor;

        dest_accessor.set(src_accessor(src_upperleft), dest_upperleft);

Preconditions:

        src_lowerright.x - src_upperleft.x > 1
        src_lowerright.y - src_upperleft.y > 1

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

Resample image by a given factor.

This algorithm is very fast and does not require any arithmetic on the pixel types. The input image must have a size of at least 2x2. Destiniation pixels are directly copied from the appropriate source pixels. The size of the result image is the product of `factor` and the original size, where we round up if `factor < 1.0` and down otherwise. This size calculation is the main difference to the convention used in the similar function resizeImageNoInterpolation(): there, the result size is calculated as `n*(old_width-1)+1` and `n*(old_height-1)+1`. This is because resizeImageNoInterpolation() does not replicate the last pixel in every row/column in order to make it compatible with the other functions of the `resizeImage...` family.

It should also be noted that resampleImage() is implemented so that an enlargement followed by the corresponding shrinking reproduces the original image. The function uses accessors.

Declarations:

pass arguments explicitly:

        namespace vigra {
            template <class SrcIterator, class SrcAccessor,
                      class DestIterator, class DestAccessor>
            void
            resampleImage(SrcIterator is, SrcIterator iend, SrcAccessor sa,
                          DestIterator id, DestAccessor ad, double factor);
        }

use argument objects in conjunction with Argument Object Factories :

        namespace vigra {
            template <class SrcImageIterator, class SrcAccessor,
                  class DestImageIterator, class DestAccessor>
            inline void
            resampleImage(triple<SrcImageIterator, SrcImageIterator, SrcAccessor> src,
                          pair<DestImageIterator, DestAccessor> dest, double factor);
        }

Usage:

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

        double factor = 2.0;
        Image dest((int)(factor*src.width()), (int)(factor*src.height()));

        vigra::resampleImage(srcImageRange(src), destImage(dest), factor);

Required Interface:

        SrcImageIterator src_upperleft, src_lowerright;
        DestImageIterator dest_upperleft;

        SrcAccessor src_accessor;

        dest_accessor.set(src_accessor(src_upperleft), dest_upperleft);

Preconditions:

        src_lowerright.x - src_upperleft.x > 1
        src_lowerright.y - src_upperleft.y > 1

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

Resize MultiArray using B-spline interpolation.

Declarations:

pass arguments explicitly:

        namespace vigra {
            template <class SrcIterator, class Shape, class SrcAccessor,
                      class DestIterator, class DestAccessor,
                      class Kernel = BSpline<3, double> >
            void
            resizeMultiArraySplineInterpolation(
                                  SrcIterator si, Shape const & sshape, SrcAccessor src,
                                  DestIterator di, Shape const & dshape, DestAccessor dest,
                                  Kernel const & spline = BSpline<3, double>());
        }

use argument objects in conjunction with Argument Object Factories :

        namespace vigra {
            template <class SrcIterator, class Shape, class SrcAccessor,
                      class DestIterator, class DestAccessor,
                      class Kernel = BSpline<3, double> >
            void
            resizeMultiArraySplineInterpolation(
                                  triple<SrcIterator, Shape, SrcAccessor> src,
                                  triple<DestIterator, Shape, DestAccessor> dest,
                                  Kernel const & spline = BSpline<3, double>());
        }

The function implements separable spline interpolation algorithm described in

M. Unser, A. Aldroubi, M. Eden, "B-Spline Signal Processing" IEEE Transactions on Signal Processing, vol. 41, no. 2, pp. 821-833 (part I), pp. 834-848 (part II), 1993.

to obtain optimal interpolation quality and speed. You may pass the funcion a spline of arbitrary order (e.g. `BSpline<ORDER, double>` or `CatmullRomSpline<double>`). The default is a third order spline which gives a twice continuously differentiable interpolant. The implementation ensures that image values are interpolated rather than smoothed by first calling a recursive (sharpening) prefilter as described in the above paper. Then the actual interpolation is done using resamplingConvolveLine().

The range of both the input and output images (resp. regions) must be given. The input image must have a size of at least 4x4, the destination of at least 2x2. The scaling factors are then calculated accordingly. If the source image is larger than the destination, it is smoothed (band limited) using a recursive exponential filter. The source value_type (SrcAccessor::value_type) must be a linear algebra, i.e. it must support addition, subtraction, and multiplication (+, -, *), multiplication with a scalar real number and NumericTraits. The function uses accessors.

Usage:

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

        typedef vigra::MultiArray<3, float>::difference_type Shape;
        vigra::MultiArray<3, float> src(Shape(5, 7, 10)),
                                    dest(Shape(9, 13, 19)); // double the size

        // use default cubic spline interpolator
        vigra::resizeMultiArraySplineInterpolation(
                   srcMultiArrayRange(src),
                   destMultiArrayRange(dest));

Required Interface:

The source and destination iterators must be compatible with vigra::MultiIterator. The array value types must be models of LinearSpace.

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

Resize image by repeating the nearest pixel values.

This algorithm is very fast and does not require any arithmetic on the pixel types.

The range of both the input and output images (resp. regions) must be given. Both images must have a size of at least 2x2 pixels. The scaling factors are then calculated accordingly. Destination pixels are directly copied from the appropriate source pixels.

The function uses accessors.

Declarations:

pass arguments explicitly:

        namespace vigra {
            template <class SrcImageIterator, class SrcAccessor,
                      class DestImageIterator, class DestAccessor>
            void
            resizeImageNoInterpolation(
                  SrcImageIterator is, SrcImageIterator iend, SrcAccessor sa,
                  DestImageIterator id, DestImageIterator idend, DestAccessor da)
        }

use argument objects in conjunction with Argument Object Factories :

        namespace vigra {
            template <class SrcImageIterator, class SrcAccessor,
                      class DestImageIterator, class DestAccessor>
            void
            resizeImageNoInterpolation(
                  triple<SrcImageIterator, SrcImageIterator, SrcAccessor> src,
                  triple<DestImageIterator, DestImageIterator, DestAccessor> dest)
        }

Usage:

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

        vigra::resizeImageNoInterpolation(
                   src.upperLeft(), src.lowerRight(), src.accessor(),
                   dest.upperLeft(), dest.lowerRight(), dest.accessor());

Required Interface:

        SrcImageIterator src_upperleft, src_lowerright;
        DestImageIterator dest_upperleft, src_lowerright;

        SrcAccessor src_accessor;
        DestAccessor dest_accessor;

        dest_accessor.set(src_accessor(src_upperleft), dest_upperleft);

Preconditions:

        src_lowerright.x - src_upperleft.x > 1
        src_lowerright.y - src_upperleft.y > 1
        dest_lowerright.x - dest_upperleft.x > 1
        dest_lowerright.y - dest_upperleft.y > 1

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

Resize image using linear interpolation.

The function uses the standard separable bilinear interpolation algorithm to obtain a good compromize between quality and speed.

The range must of both the input and output images (resp. regions) must be given. Both images must have a size of at least 2x2. The scaling factors are then calculated accordingly. If the source image is larger than the destination, it is smoothed (band limited) using a recursive exponential filter. The source value_type (SrcAccessor::value_type) must be a linear space, i.e. it must support addition, multiplication with a scalar real number and NumericTraits. The function uses accessors.

Declarations:

pass arguments explicitly:

        namespace vigra {
            template <class SrcImageIterator, class SrcAccessor,
                      class DestImageIterator, class DestAccessor>
            void
            resizeImageLinearInterpolation(
                  SrcImageIterator is, SrcImageIterator iend, SrcAccessor sa,
                  DestImageIterator id, DestImageIterator idend, DestAccessor da)
        }

use argument objects in conjunction with Argument Object Factories :

        namespace vigra {
            template <class SrcImageIterator, class SrcAccessor,
                      class DestImageIterator, class DestAccessor>
            void
            resizeImageLinearInterpolation(
                  triple<SrcImageIterator, SrcImageIterator, SrcAccessor> src,
                  triple<DestImageIterator, DestImageIterator, DestAccessor> dest)
        }

Usage:

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

        vigra::resizeImageLinearInterpolation(
                   src.upperLeft(), src.lowerRight(), src.accessor(),
                   dest.upperLeft(), dest.lowerRight(), dest.accessor());

Required Interface:

        SrcImageIterator src_upperleft, src_lowerright;
        DestImageIterator dest_upperleft, src_lowerright;

        SrcAccessor src_accessor;
        DestAccessor dest_accessor;

        NumericTraits<SrcAccessor::value_type>::RealPromote
                                 u = src_accessor(src_upperleft),
                     v = src_accessor(src_upperleft, 1);
        double d;

        u = d * v;
        u = u + v;

        dest_accessor.set(
            NumericTraits<DestAccessor::value_type>::fromRealPromote(u),
        dest_upperleft);

Preconditions:

        src_lowerright.x - src_upperleft.x > 1
        src_lowerright.y - src_upperleft.y > 1
        dest_lowerright.x - dest_upperleft.x > 1
        dest_lowerright.y - dest_upperleft.y > 1

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

Resize image using B-spline interpolation.

The function implements separable spline interpolation algorithm described in

M. Unser, A. Aldroubi, M. Eden, "B-Spline Signal Processing" IEEE Transactions on Signal Processing, vol. 41, no. 2, pp. 821-833 (part I), pp. 834-848 (part II), 1993.

to obtain optimal interpolation quality and speed. You may pass the funcion a spline of arbitrary order (e.g. `BSpline<ORDER, double>` or `CatmullRomSpline<double>`). The default is a third order spline which gives a twice continuously differentiable interpolant. The implementation ensures that image values are interpolated rather than smoothed by first calling a recursive (sharpening) prefilter as described in the above paper. Then the actual interpolation is done using resamplingConvolveLine().

The range of both the input and output images (resp. regions) must be given. The input image must have a size of at least 4x4, the destination of at least 2x2. The scaling factors are then calculated accordingly. If the source image is larger than the destination, it is smoothed (band limited) using a recursive exponential filter. The source value_type (SrcAccessor::value_type) must be a linear algebra, i.e. it must support addition, subtraction, and multiplication (+, -, *), multiplication with a scalar real number and NumericTraits. The function uses accessors.

Declarations:

pass arguments explicitly:

        namespace vigra {
            template <class SrcImageIterator, class SrcAccessor,
                      class DestImageIterator, class DestAccessor,
                      class SPLINE>
            void
            resizeImageSplineInterpolation(
                  SrcImageIterator is, SrcImageIterator iend, SrcAccessor sa,
                  DestImageIterator id, DestImageIterator idend, DestAccessor da,
                  SPLINE spline = BSpline<3, double>())
        }

use argument objects in conjunction with Argument Object Factories :

        namespace vigra {
            template <class SrcImageIterator, class SrcAccessor,
                      class DestImageIterator, class DestAccessor,
                      class SPLINE>
            void
            resizeImageSplineInterpolation(
                  triple<SrcImageIterator, SrcImageIterator, SrcAccessor> src,
                  triple<DestImageIterator, DestImageIterator, DestAccessor> dest,
                  SPLINE spline = BSpline<3, double>())
        }

Usage:

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

        vigra::resizeImageSplineInterpolation(
                   src.upperLeft(), src.lowerRight(), src.accessor(),
                   dest.upperLeft(), dest.lowerRight(), dest.accessor());

Required Interface:

        SrcImageIterator src_upperleft, src_lowerright;
        DestImageIterator dest_upperleft, src_lowerright;

        SrcAccessor src_accessor;
        DestAccessor dest_accessor;

        NumericTraits<SrcAccessor::value_type>::RealPromote
                                 u = src_accessor(src_upperleft),
                     v = src_accessor(src_upperleft, 1);
        double d;

        u = d * v;
        u = u + v;
        u = u - v;
        u = u * v;
        u += v;
        u -= v;

        dest_accessor.set(
            NumericTraits<DestAccessor::value_type>::fromRealPromote(u),
        dest_upperleft);

Preconditions:

        src_lowerright.x - src_upperleft.x > 3
        src_lowerright.y - src_upperleft.y > 3
        dest_lowerright.x - dest_upperleft.x > 1
        dest_lowerright.y - dest_upperleft.y > 1

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

Resize image using the Catmull/Rom interpolation function.

The function calls like resizeImageSplineInterpolation() with vigra::CatmullRomSpline as an interpolation kernel. The interpolated function has one continuous derivative. (See resizeImageSplineInterpolation() for more documentation)

Declarations:

pass arguments explicitly:

        namespace vigra {
            template <class SrcIterator, class SrcAccessor,
                      class DestIterator, class DestAccessor>
            void
            resizeImageCatmullRomInterpolation(SrcIterator src_iter, SrcIterator src_iter_end, SrcAccessor src_acc,
                                  DestIterator dest_iter, DestIterator dest_iter_end, DestAccessor dest_acc);
        }

use argument objects in conjunction with Argument Object Factories :

        namespace vigra {
            template <class SrcIterator, class SrcAccessor,
                      class DestIterator, class DestAccessor>
            void
            resizeImageCatmullRomInterpolation(triple<SrcIterator, SrcIterator, SrcAccessor> src,
                                  triple<DestIterator, DestIterator, DestAccessor> dest);
        }

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

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

Resize image using the Coscot interpolation function.

The function calls resizeImageSplineInterpolation() with vigra::CoscotFunction as an interpolation kernel. The interpolated function has one continuous derivative. (See resizeImageSplineInterpolation() for more documentation)

Declarations:

pass arguments explicitly:

        namespace vigra {
            template <class SrcIterator, class SrcAccessor,
                      class DestIterator, class DestAccessor>
            void
            resizeImageCoscotInterpolation(SrcIterator src_iter, SrcIterator src_iter_end, SrcAccessor src_acc,
                                  DestIterator dest_iter, DestIterator dest_iter_end, DestAccessor dest_acc);
        }

use argument objects in conjunction with Argument Object Factories :

        namespace vigra {
            template <class SrcIterator, class SrcAccessor,
                      class DestIterator, class DestAccessor>
            void
            resizeImageCoscotInterpolation(triple<SrcIterator, SrcIterator, SrcAccessor> src,
                                  triple<DestIterator, DestIterator, DestAccessor> dest);
        }

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

© 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.6.0 (13 Aug 2008)