Leptonica
1.54
|
BOXA* boxaAffineTransform | ( | BOXA * | boxas, |
l_float32 * | mat | ||
) |
Input: boxas mat (3x3 transform matrix; canonical form) Return: boxad (transformed boxas), or null on error
Input: boxas (xc, yc) (location of center of rotation) angle (rotation in radians; clockwise is positive) Return: boxad (scaled boxas), or null on error
Notes; (1) See createMatrix2dRotate() for details of transform.
Input: boxas scalex (horizontal scale factor) scaley (vertical scale factor) Return: boxad (scaled boxas), or null on error
Notes; (1) See createMatrix2dScale() for details of transform.
BOXA* boxaTranslate | ( | BOXA * | boxas, |
l_float32 | transx, | ||
l_float32 | transy | ||
) |
Input: boxas transx (x component of translation wrt. the origin) transy (y component of translation wrt. the origin) Return: boxad (translated boxas), or null on error
Notes; (1) See createMatrix2dTranslate() for details of transform.
l_float32* createMatrix2dRotate | ( | l_float32 | xc, |
l_float32 | yc, | ||
l_float32 | angle | ||
) |
Input: xc, yc (location of center of rotation) angle (rotation in radians; clockwise is positive) Return: 3x3 transform matrix, or null on error
Notes; (1) The rotation is equivalent to: v' = Av where v and v' are 1x3 column vectors in the form v = [x, y, 1]^ (^ denotes transpose) and the affine rotation matrix is A = [ cosa -sina xc*(1-cosa) + yc*sina sina cosa yc*(1-cosa) - xc*sina 0 0 1 ]
If the rotation is about the origin, (xc, yc) = (0, 0) and this simplifies to A = [ cosa -sina 0 sina cosa 0 0 0 1 ]
These relations follow from the following equations, which you can convince yourself are correct as follows. Draw a circle centered on (xc,yc) and passing through (x,y), with (x',y') on the arc at an angle 'a' clockwise from (x,y). [ Hint: cos(a + b) = cosa * cosb - sina * sinb sin(a + b) = sina * cosb + cosa * sinb ]
x' - xc = (x - xc) * cosa - (y - yc) * sina y' - yc = (x - xc) * sina + (y - yc) * cosa
l_float32* createMatrix2dScale | ( | l_float32 | scalex, |
l_float32 | scaley | ||
) |
Input: scalex (horizontal scale factor) scaley (vertical scale factor) Return: 3x3 transform matrix, or null on error
Notes; (1) The scaling is equivalent to: v' = Av where v and v' are 1x3 column vectors in the form v = [x, y, 1]^ (^ denotes transpose) and the affine scaling matrix is A = [ sx 0 0 0 sy 0 0 0 1 ]
(2) We consider scaling as with respect to a fixed origin. In other words, the origin is the only point that doesn't move in the scaling transform.
l_float32* createMatrix2dTranslate | ( | l_float32 | transx, |
l_float32 | transy | ||
) |
Input: transx (x component of translation wrt. the origin) transy (y component of translation wrt. the origin) Return: 3x3 transform matrix, or null on error
Notes; (1) The translation is equivalent to: v' = Av where v and v' are 1x3 column vectors in the form v = [x, y, 1]^ (^ denotes transpose) and the affine tranlation matrix is A = [ 1 0 tx 0 1 ty 0 0 1 ]
(2) We consider translation as with respect to a fixed origin. In a clipping operation, the origin moves and the points are fixed, and you use (-tx, -ty) where (tx, ty) is the translation vector of the origin.
Input: mat1 (square matrix, as a 1-dimensional size^2 array) mat2 (square matrix, as a 1-dimensional size^2 array) matd (square matrix; product stored here) size (of matrices) Return: 0 if OK, 1 on error
l_int32 l_productMat3 | ( | l_float32 * | mat1, |
l_float32 * | mat2, | ||
l_float32 * | mat3, | ||
l_float32 * | matd, | ||
l_int32 | size | ||
) |
Input: mat1 (square matrix, as a 1-dimensional size^2 array) mat2 (square matrix, as a 1-dimensional size^2 array) mat3 (square matrix, as a 1-dimensional size^2 array) matd (square matrix; product stored here) size (of matrices) Return: 0 if OK, 1 on error
l_int32 l_productMat4 | ( | l_float32 * | mat1, |
l_float32 * | mat2, | ||
l_float32 * | mat3, | ||
l_float32 * | mat4, | ||
l_float32 * | matd, | ||
l_int32 | size | ||
) |
Input: mat1 (square matrix, as a 1-dimensional size^2 array) mat2 (square matrix, as a 1-dimensional size^2 array) mat3 (square matrix, as a 1-dimensional size^2 array) mat4 (square matrix, as a 1-dimensional size^2 array) matd (square matrix; product stored here) size (of matrices) Return: 0 if OK, 1 on error
Input: mat (square matrix, as a 1-dimensional ^2 array) vecs (input column vector of length ) vecd (result column vector) size (matrix is x ; vectors are length ) Return: 0 if OK, 1 on error
PTA* ptaAffineTransform | ( | PTA * | ptas, |
l_float32 * | mat | ||
) |
Input: ptas (for initial points) mat (3x3 transform matrix; canonical form) Return: ptad (transformed points), or null on error
Input: ptas (for initial points) (xc, yc) (location of center of rotation) angle (rotation in radians; clockwise is positive) Return: 0 if OK; 1 on error
Notes; (1) See createMatrix2dScale() for details of transform. (2) This transform can be thought of as composed of the sum of two parts: (a) an (x,y)-dependent rotation about the origin: xr = x * cosa - y * sina yr = x * sina + y * cosa (b) an (x,y)-independent translation that depends on the rotation center and the angle: xt = xc - xc * cosa + yc * sina yt = yc - xc * sina - yc * cosa The translation part (xt,yt) is equal to the difference between the center (xc,yc) and the location of the center after it is rotated about the origin.
Input: ptas (for initial points) scalex (horizontal scale factor) scaley (vertical scale factor) Return: 0 if OK; 1 on error
Notes; (1) See createMatrix2dScale() for details of transform.
PTA* ptaTranslate | ( | PTA * | ptas, |
l_float32 | transx, | ||
l_float32 | transy | ||
) |
Input: ptas (for initial points) transx (x component of translation wrt. the origin) transy (y component of translation wrt. the origin) Return: ptad (translated points), or null on error
Notes; (1) See createMatrix2dTranslate() for details of transform.