cp2tform
Infer spatial transformation from control point pairs
Syntax
TFORM = cp2tform(input_points, base_points, transformtype)
TFORM = cp2tform(CPSTRUCT, transformtype)
[TFORM, input_points, base_points]
= cp2tform(CPSTRUCT,...)
TFORM = cp2tform(..., 'polynomial', order)
TFORM = cp2tform(..., 'lwm', N)
[TFORM, input_points, base_points,
input_points_bad, base_points_bad]= cp2tform(..., 'piecewise linear')
Description
TFORM = cp2tform(input_points, base_points, transformtype) takes
pairs of control points and uses them to infer a spatial transformation.
input_points is an m-by-2 double matrix
containing the x- and y-coordinates
of control points in the image you want to transform. base_points is
an m-by-2 double matrix containing
the x- and y-coordinates
of control points specified in the base image. transformtype specifies
the type of spatial transformation to infer. See Transformation Types for a list of the supported transform
types. cp2tform returns a TFORM structure
containing the spatial transformation.
TFORM = cp2tform(CPSTRUCT, transformtype) infers
a spatial transformation using the control point matrices for the
input and base images in the CPSTRUCT structure.
You use the Control Point Selection Tool (cpselect)
to create the CPSTRUCT.
[TFORM, input_points, base_points]
= cp2tform(CPSTRUCT,...) returns the control points that
were actually used in the return values input_points and base_points.
A CPSTRUCT can contain unmatched and predicted
points that are not used in the calculation. For more information,
see cpstruct2pairs.
Transformation Types
The following table lists all the transformation types supported
by cp2tform in order of complexity. The 'lwm' and 'polynomial' transform
types can each take an optional, additional parameter.
See the syntax descriptions that follow for details.
Note
When transformtype is 'nonreflective
similarity', 'similarity', 'affine', 'projective',
or 'polynomial', and input_points and base_points (or CPSTRUCT)
have the minimum number of control points needed for a particular
transformation, cp2tform finds the coefficients
exactly. If input_points and base_points include
more than the minimum number of points, cp2tform uses
a least squares solution. For more information, see mldivide. |
Transformation Type | Description | Minimum Control Points | Example |
|---|
'nonreflective similarity' | Use
this transformation when shapes in the input image are unchanged,
but the image is distorted by some combination of translation, rotation,
and scaling. Straight lines remain straight, and parallel lines are
still parallel. | 2 pairs |
 |
'similarity' | Same as 'nonreflective
similarity' with the addition of optional reflection. | 3 pairs |
|
'affine' | Use this transformation
when shapes in the input image exhibit shearing. Straight lines remain
straight, and parallel lines remain parallel, but rectangles become
parallelograms. | 3 pairs |
 |
'projective' | Use this transformation
when the scene appears tilted. Straight lines remain straight, but
parallel lines converge toward vanishing points that might or might
not fall within the image. | 4 pairs |
 |
'polynomial'
See Transform-specific Syntaxes | Use this transformation
when objects in the image are curved. The higher the order of the
polynomial, the better the fit, but the result can contain more curves
than the base image. | 6 pairs (order 2) 10 pairs (order 3) 15
pairs (order 4) |
 |
'piecewise linear'
See Transform-specific Syntaxes | Use this
transformation when parts of the image appear distorted differently. | 4 pairs |
 |
'lwm'
See Transform-specific Syntaxes | Use this
transformation (local weighted mean), when the distortion varies locally
and piecewise linear is not sufficient. | 6 pairs (12 pairs recommended) |
 |
Transform-specific Syntaxes
TFORM = cp2tform(..., 'polynomial', order) returns
a TFORM structure specifying a 'polynomial' transformation,
where order specifies the order of the polynomial
to use. order can be the scalar value 2, 3,
or 4. If you omit order, it
defaults to 3.
TFORM = cp2tform(..., 'lwm', N) returns
a TFORM structure specifying a 'lwm' transformation,
where N specifies the number of points used to
infer each polynomial. The radius of influence extends out to the
furthest control point used to infer that polynomial. The N closest
points are used to infer a polynomial of order 2 for each control
point pair. If you omit N, it defaults to 12. N can
be as small as 6, but making N small
risks generating ill-conditioned polynomials.
[TFORM, input_points, base_points,
input_points_bad, base_points_bad]= cp2tform(..., 'piecewise linear') returns
a TFORM structure specifying a 'piecewise
linear' transformation. Returns the control points that
were actually used in input_points and base_points,
and returns the control points that were eliminated because they were
middle vertices of degenerate fold-over triangles, in input_points_bad and base_points_bad.
Fold-over triangles occur when the control points for the input and
base image are not specified in a consistent order.
Remarks
When either input_points or base_points has
a large offset with respect to their origin (relative to range of
values that it spans), cp2tform shifts the points
to center their bounding box on the origin before fitting a TFORM structure.
This enhances numerical stability and is handled transparently by
wrapping the origin-centered TFORM within a custom TFORM that
automatically applies and undoes the coordinate shift as needed. This
means that fields(T) may give different results
for different coordinate inputs, even for the same transformation
type.
Examples
I = checkerboard;
J = imrotate(I,30);
base_points = [11 11; 41 71];
input_points = [14 44; 70 81];
cpselect(J,I,input_points,base_points);
t = cp2tform(input_points,base_points,'nonreflective similarity');
% Recover angle and scale by checking how a unit vector
% parallel to the x-axis is rotated and stretched.
u = [0 1];
v = [0 0];
[x, y] = tformfwd(t, u, v);
dx = x(2) - x(1);
dy = y(2) - y(1);
angle = (180/pi) * atan2(dy, dx)
scale = 1 / sqrt(dx^2 + dy^2)
Algorithms
cp2tform uses the following general procedure:
Use valid pairs of control points to
infer a spatial transformation or an inverse mapping from output space (x,y) to
input space (u,v) according to transformtype.
Return TFORM structure
containing spatial transformation.
The procedure varies depending on the transformtype.
Nonreflective Similarity
Nonreflective similarity ransformations can include a rotation,
a scaling, and a translation. Shapes and angles are preserved. Parallel
lines remain parallel. Straight lines remain straight.
Let
sc = scale*cos(angle)
ss = scale*sin(angle)
[u v] = [x y 1] * [ sc -ss
ss sc
tx ty]Solve for sc, ss, tx,
and ty.
Similarity
Similarity transformations can include rotation, scaling, translation,
and reflection. Shapes and angles are preserved. Parallel lines remain
parallel. Straight lines remain straight.
Let
sc = s*cos(theta)
ss = s*sin(theta)
[ sc -a*-ss
[u v] = [x y 1] * ss a*sc
tx ty]
Solve for sc, ss, tx, ty,
and a. If a=-1, reflection is
included in the transformation. If a=1, reflection
is not included in the transformation.
Affine
In an affine transformation, the x and y dimensions
can be scaled or sheared independently and there can be a translation.
Parallel lines remain parallel. Straight lines remain straight. Nonreflective
similarity transformations are a subset of affine transformations.
For an affine transformation,
[u v] = [x y 1] * Tinv
Tinv is a 3-by-2 matrix. Solve for the six
elements of Tinv.
t_affine = cp2tform(input_points,base_points,'affine');
The coefficients of the inverse mapping are stored in t_affine.tdata.Tinv.
At least three control-point pairs are needed to solve for the
six unknown coefficients.
Projective
In a projective transformation, quadrilaterals map to quadrilaterals.
Straight lines remain straight. Affine transformations are a subset
of projective transformations.
For a projective transformation
[up vp wp] = [x y w] * Tinv
where
u = up/wp
v = vp/wp
Tinv is a 3-by-3 matrix.
Assuming
Tinv = [ A D G;
B E H;
C F I ];
u = (Ax + By + C)/(Gx + Hy + I)
v = (Dx + Ey + F)/(Gx + Hy + I)Solve for the nine elements of Tinv.
t_proj = cp2tform(input_points,base_points,'projective');
The coefficients of the inverse mapping are stored in t_proj.tdata.Tinv.
At least four control-point pairs are needed to solve for the
nine unknown coefficients.
Polynomial
In a polynomial transformation, polynomial functions of x and y determine
the mapping.
Second-Order Polynomials |
|---|
For a second-order polynomial transformation, [u v] = [1 x y x*y x^2 y^2] * Tinv Both u and v are
second-order polynomials of x and y.
Each second-order polynomial has six terms. To specify all coefficients, Tinv has
size 6-by-2. t_poly_ord2 = cp2tform(input_points, base_points,'polynomial'); The
coefficients of the inverse mapping are stored in t_poly_ord2.tdata. At
least six control-point pairs are needed to solve for the 12 unknown
coefficients. |
Third-Order Polynomials |
|---|
For a third-order polynomial transformation: [u v] = [1 x y x*y x^2 y^2 y*x^2 x*y^2 x^3 y^3] * Tinv Both u and v are
third-order polynomials of x and y.
Each third-order polynomial has ten terms. To specify all coefficients, Tinv has
size 10-by-2. t_poly_ord3 = cp2tform(input_points, base_points,'polynomial',3); The
coefficients of the inverse mapping are stored in t_poly_ord3.tdata. At
least ten control-point pairs are needed to solve for the 20 unknown
coefficients. |
Fourth-Order Polynomials |
|---|
For a fourth-order polynomial transformation: [u
v] = [1 x y x*y x^2 y^2 y*x^2 x*y^2 x^3 y^3 x^3*y x^2*y^2 x*y^3 x^4
y^4] * Tinv Both u and v are
fourth-order polynomials of x and y.
Each fourth-order polynomial has 15 terms. To specify all coefficients, Tinv has
size 15-by-2. t_poly_ord4 = cp2tform(input_points, base_points,'polynomial',4); The
coefficients of the inverse mapping are stored in t_poly_ord4.tdata. At
least 15 control-point pairs are needed to solve for the 30 unknown
coefficients. |
Piecewise Linear
In a piecewise linear transformation, linear (affine) transformations
are applied separately to each triangular region of the image [1].
Find a Delaunay triangulation of the
base control points.
Using the three vertices of each triangle,
infer an affine mapping from base to input coordinates.
Note
At least four control-point pairs are needed. Four pairs result
in two triangles with distinct mappings. |
Local Weighted Mean
For each control point in base_points:
Find the N closest
control points.
Use these N points
and their corresponding points in input_points to
infer a second-order polynomial.
Calculate the radius of influence of this polynomial
as the distance from the center control point to the farthest point
used to infer the polynomial (using base_points). [2]
Note
At least six control-point pairs are needed to solve for the
second-order polynomial. Ill-conditioned polynomials might result
if too few pairs are used. |
References
[1] Goshtasby, Ardeshir, "Piecewise linear
mapping functions for image registration," Pattern Recognition,
Vol. 19, 1986, pp. 459-466.
[2] Goshtasby, Ardeshir, "Image registration
by local approximation methods," Image and Vision Computing,
Vol. 6, 1988, pp. 255-261.
See Also
cpcorr, cpselect, cpstruct2pairs, imtransform, tformfwd, tforminv