class cv::detail::AffineWarper

Overview

Affine warper that uses rotations and translations. More…

#include <warpers.hpp>

class AffineWarper: public cv::detail::PlaneWarper
{
public:
    // construction

    AffineWarper(float scale = 1.f);

    // methods

    virtual
    Rect
    buildMaps(
        Size src_size,
        InputArray K,
        InputArray R,
        OutputArray xmap,
        OutputArray ymap
        );

    virtual
    Point
    warp(
        InputArray src,
        InputArray K,
        InputArray R,
        int interp_mode,
        int border_mode,
        OutputArray dst
        );

    virtual
    Point2f
    warpPoint(
        const Point2f& pt,
        InputArray K,
        InputArray R
        );

    virtual
    Rect
    warpRoi(
        Size src_size,
        InputArray K,
        InputArray R
        );

protected:
    // methods

    void
    getRTfromHomogeneous(
        InputArray H,
        Mat& R,
        Mat& T
        );
};

Inherited Members

public:
    // methods

    virtual
    Rect
    buildMaps(
        Size src_size,
        InputArray K,
        InputArray R,
        OutputArray xmap,
        OutputArray ymap
        ) = 0;

    virtual
    float
    getScale() const;

    virtual
    void
    setScale(float);

    virtual
    Point
    warp(
        InputArray src,
        InputArray K,
        InputArray R,
        int interp_mode,
        int border_mode,
        OutputArray dst
        ) = 0;

    virtual
    void
    warpBackward(
        InputArray src,
        InputArray K,
        InputArray R,
        int interp_mode,
        int border_mode,
        Size dst_size,
        OutputArray dst
        ) = 0;

    virtual
    Point2f
    warpPoint(
        const Point2f& pt,
        InputArray K,
        InputArray R
        ) = 0;

    virtual
    Rect
    warpRoi(
        Size src_size,
        InputArray K,
        InputArray R
        ) = 0;

    virtual
    Rect
    buildMaps(
        Size src_size,
        InputArray K,
        InputArray R,
        OutputArray xmap,
        OutputArray ymap
        );

    virtual
    float
    getScale() const;

    virtual
    void
    setScale(float val);

    virtual
    Point
    warp(
        InputArray src,
        InputArray K,
        InputArray R,
        int interp_mode,
        int border_mode,
        OutputArray dst
        );

    virtual
    void
    warpBackward(
        InputArray src,
        InputArray K,
        InputArray R,
        int interp_mode,
        int border_mode,
        Size dst_size,
        OutputArray dst
        );

    virtual
    Point2f
    warpPoint(
        const Point2f& pt,
        InputArray K,
        InputArray R
        );

    virtual
    Rect
    warpRoi(
        Size src_size,
        InputArray K,
        InputArray R
        );

    virtual
    Rect
    buildMaps(
        Size src_size,
        InputArray K,
        InputArray R,
        InputArray T,
        OutputArray xmap,
        OutputArray ymap
        );

    virtual
    Rect
    buildMaps(
        Size src_size,
        InputArray K,
        InputArray R,
        OutputArray xmap,
        OutputArray ymap
        );

    virtual
    Point
    warp(
        InputArray src,
        InputArray K,
        InputArray R,
        int interp_mode,
        int border_mode,
        OutputArray dst
        );

    virtual
    Point
    warp(
        InputArray src,
        InputArray K,
        InputArray R,
        InputArray T,
        int interp_mode,
        int border_mode,
        OutputArray dst
        );

    virtual
    Point2f
    warpPoint(
        const Point2f& pt,
        InputArray K,
        InputArray R
        );

    Point2f
    warpPoint(
        const Point2f& pt,
        InputArray K,
        InputArray R,
        InputArray T
        );

    virtual
    Rect
    warpRoi(
        Size src_size,
        InputArray K,
        InputArray R
        );

    Rect
    warpRoi(
        Size src_size,
        InputArray K,
        InputArray R,
        InputArray T
        );

protected:
    // fields

    P projector_;

    // methods

    virtual
    void
    detectResultRoi(
        Size src_size,
        Point& dst_tl,
        Point& dst_br
        );

    void
    detectResultRoiByBorder(
        Size src_size,
        Point& dst_tl,
        Point& dst_br
        );

    virtual
    void
    detectResultRoi(
        Size src_size,
        Point& dst_tl,
        Point& dst_br
        );

Detailed Documentation

Affine warper that uses rotations and translations.

Uses affine transformation in homogeneous coordinates to represent both rotation and translation in camera rotation matrix.

Construction

AffineWarper(float scale = 1.f)

Construct an instance of the affine warper class.

Parameters:

scale

Projected image scale multiplier

Methods

virtual
Rect
buildMaps(
    Size src_size,
    InputArray K,
    InputArray R,
    OutputArray xmap,
    OutputArray ymap
    )

Builds the projection maps according to the given camera data.

Parameters:

src_size	Source image size
K	Camera intrinsic parameters
R	Camera rotation matrix
xmap	Projection map for the x axis
ymap	Projection map for the y axis

Returns:

Projected image minimum bounding box

virtual
Point
warp(
    InputArray src,
    InputArray K,
    InputArray R,
    int interp_mode,
    int border_mode,
    OutputArray dst
    )

Projects the image.

Parameters:

src	Source image
K	Camera intrinsic parameters
R	Camera rotation matrix
interp_mode	Interpolation mode
border_mode	Border extrapolation mode
dst	Projected image

Returns:

Project image top-left corner

virtual
Point2f
warpPoint(
    const Point2f& pt,
    InputArray K,
    InputArray R
    )

Projects the image point.

Parameters:

pt	Source point
K	Camera intrinsic parameters
R	Camera rotation matrix

Returns:

Projected point

virtual
Rect
warpRoi(
    Size src_size,
    InputArray K,
    InputArray R
    )

Parameters:

src_size	Source image bounding box
K	Camera intrinsic parameters
R	Camera rotation matrix

Returns:

Projected image minimum bounding box

void
getRTfromHomogeneous(
    InputArray H,
    Mat& R,
    Mat& T
    )

Extracts rotation and translation matrices from matrix H representing affine transformation in homogeneous coordinates.