affine_trans_region — Apply an arbitrary affine 2D transformation to regions.
affine_trans_region applies an arbitrary affine 2D
transformation, i.e., scaling, rotation, translation, and slant (skewing), to
the regions given in
Region and returns the transformed
RegionAffineTrans. The affine transformation is
described by the homogeneous transformation matrix given in
HomMat2D, which can be created using the operators
hom_mat2d_translate, etc., or be the result
of operators like
The components of the homogeneous transformation matrix are interpreted as follows: The row coordinate of the image corresponds to x and the column coordinate corresponds to y of the coordinate system in which the transformation matrix was defined. This is necessary to obtain a right-handed coordinate system for the image. In particular, this assures that rotations are performed in the correct direction. Note that the (x,y) order of the matrices quite naturally corresponds to the usual (row,column) order for coordinates in the image.
Interpolate determines whether the transformation is
to be done by using interpolation internally. The interpolation modes
'nearest_neighbor' and 'constant', which are
described in detail for
affine_trans_image, can be used. An
interpolation can lead to smoother region boundaries, especially if regions
are enlarged. However, the runtime increases drastically.
affine_trans_region in general is not reversible
(clipping and discretization during rotation and scaling).
affine_trans_region does not use the HALCON standard
coordinate system (with the origin in the center of the upper left
pixel), but instead uses the same coordinate system as in
affine_trans_pixel, i.e., the origin lies in the upper
left corner of the upper left pixel. Therefore,
affine_trans_region corresponds to
a chain of transformations (see
affine_trans_pixel), which is
applied to each point of the region (input and output pixels as
As an effect, you might get unexpected results when creating affine
transformations based on coordinates that are derived from the
region, e.g., by operators like
area_center. For example, if you use this operator to calculate
the center of gravity of a rotationally symmetric region and then rotate
the region around this point using
hom_mat2d_rotate, the resulting
region will not lie on the original one. In such a case, you can compensate
this effect by applying the following translations to
before using it in
hom_mat2d_translate(HomMat2D, 0.5, 0.5, HomMat2DTmp) hom_mat2d_translate_local(HomMat2DTmp, -0.5, -0.5, HomMat2DAdapted) affine_trans_region(Region, RegionAffineTrans, HomMat2DAdapted, 'nearest_neighbor')
For an explanation of the different 2D coordinate systems used in HALCON, see the introduction of chapter Transformations / 2D Transformations.
Region(s) to be rotated and scaled.
Transformed output region(s).
Number of elements: RegionAffineTrans == Region
Input transformation matrix.
Should the transformation be done using interpolation?
Default value: 'nearest_neighbor'
List of values: 'constant', 'nearest_neighbor'
If the matrix
HomMat2D represents an affine transformation
(i.e., not a projective transformation),
returns 2 (H_MSG_TRUE). The behavior in case of empty input (no regions
given) can be set via
set_system('no_object_result',<Result>), the behavior in
case of an empty input region via
set_system('empty_region_result',<Result>), and the behavior
in case of an empty result region via
necessary, an exception is raised.