| /*====================================================================* |
| - Copyright (C) 2001 Leptonica. All rights reserved. |
| - This software is distributed in the hope that it will be |
| - useful, but with NO WARRANTY OF ANY KIND. |
| - No author or distributor accepts responsibility to anyone for the |
| - consequences of using this software, or for whether it serves any |
| - particular purpose or works at all, unless he or she says so in |
| - writing. Everyone is granted permission to copy, modify and |
| - redistribute this source code, for commercial or non-commercial |
| - purposes, with the following restrictions: (1) the origin of this |
| - source code must not be misrepresented; (2) modified versions must |
| - be plainly marked as such; and (3) this notice may not be removed |
| - or altered from any source or modified source distribution. |
| *====================================================================*/ |
| |
| /* |
| * projective.c |
| * |
| * Projective (4 pt) image transformation using a sampled |
| * (to nearest integer) transform on each dest point |
| * PIX *pixProjectiveSampledPta() |
| * PIX *pixProjectiveSampled() |
| * |
| * Projective (4 pt) image transformation using interpolation |
| * (or area mapping) for anti-aliasing images that are |
| * 2, 4, or 8 bpp gray, or colormapped, or 32 bpp RGB |
| * PIX *pixProjectivePta() |
| * PIX *pixProjective() |
| * PIX *pixProjectivePtaColor() |
| * PIX *pixProjectiveColor() |
| * PIX *pixProjectivePtaGray() |
| * PIX *pixProjectiveGray() |
| * |
| * Projective coordinate transformation |
| * l_int32 getProjectiveXformCoeffs() |
| * l_int32 projectiveXformSampledPt() |
| * l_int32 projectiveXformPt() |
| * |
| * A projective transform can be specified as a specific functional |
| * mapping between 4 points in the source and 4 points in the dest. |
| * It preserves straight lines, but is less stable than a bilinear |
| * transform, because it contains a division by a quantity that |
| * can get arbitrarily small.) |
| * |
| * We give both a projective coordinate transformation and |
| * two projective image transformations. |
| * |
| * For the former, we ask for the coordinate value (x',y') |
| * in the transformed space for any point (x,y) in the original |
| * space. The coefficients of the transformation are found by |
| * solving 8 simultaneous equations for the 8 coordinates of |
| * the 4 points in src and dest. The transformation can then |
| * be used to compute the associated image transform, by |
| * computing, for each dest pixel, the relevant pixel(s) in |
| * the source. This can be done either by taking the closest |
| * src pixel to each transformed dest pixel ("sampling") or |
| * by doing an interpolation and averaging over 4 source |
| * pixels with appropriate weightings ("interpolated"). |
| * |
| * A typical application would be to remove keystoning |
| * due to a projective transform in the imaging system. |
| * |
| * The projective transform is given by specifying two equations: |
| * |
| * x' = (ax + by + c) / (gx + hy + 1) |
| * y' = (dx + ey + f) / (gx + hy + 1) |
| * |
| * where the eight coefficients have been computed from four |
| * sets of these equations, each for two corresponding data pts. |
| * In practice, for each point (x,y) in the dest image, this |
| * equation is used to compute the corresponding point (x',y') |
| * in the src. That computed point in the src is then used |
| * to determine the dest value in one of two ways: |
| * |
| * - sampling: take the value of the src pixel in which this |
| * point falls |
| * - interpolation: take appropriate linear combinations of the |
| * four src pixels that this dest pixel would |
| * overlap, with the coefficients proportional |
| * to the amount of overlap |
| * |
| * For small warp where there is little scale change, (e.g., |
| * for rotation) area mapping is nearly equivalent to interpolation. |
| * |
| * Typical relative timing of pointwise transforms (sampled = 1.0): |
| * 8 bpp: sampled 1.0 |
| * interpolated 1.5 |
| * 32 bpp: sampled 1.0 |
| * interpolated 1.6 |
| * Additionally, the computation time/pixel is nearly the same |
| * for 8 bpp and 32 bpp, for both sampled and interpolated. |
| */ |
| |
| #include <stdio.h> |
| #include <stdlib.h> |
| #include <string.h> |
| #include <math.h> |
| #include "allheaders.h" |
| |
| |
| /*-------------------------------------------------------------* |
| * Sampled projective image transformation * |
| *-------------------------------------------------------------*/ |
| /*! |
| * pixProjectiveSampledPta() |
| * |
| * Input: pixs (all depths) |
| * ptad (4 pts of final coordinate space) |
| * ptas (4 pts of initial coordinate space) |
| * incolor (L_BRING_IN_WHITE, L_BRING_IN_BLACK) |
| * Return: pixd, or null on error |
| * |
| * Notes: |
| * (1) Brings in either black or white pixels from the boundary. |
| * (2) Retains colormap, which you can do for a sampled transform.. |
| * (3) No 3 of the 4 points may be collinear. |
| * (4) For 8 and 32 bpp pix, better quality is obtained by the |
| * somewhat slower pixProjectivePta(). See that |
| * function for relative timings between sampled and interpolated. |
| */ |
| PIX * |
| pixProjectiveSampledPta(PIX *pixs, |
| PTA *ptad, |
| PTA *ptas, |
| l_int32 incolor) |
| { |
| l_float32 *vc; |
| PIX *pixd; |
| |
| PROCNAME("pixProjectiveSampledPta"); |
| |
| if (!pixs) |
| return (PIX *)ERROR_PTR("pixs not defined", procName, NULL); |
| if (!ptas) |
| return (PIX *)ERROR_PTR("ptas not defined", procName, NULL); |
| if (!ptad) |
| return (PIX *)ERROR_PTR("ptad not defined", procName, NULL); |
| if (incolor != L_BRING_IN_WHITE && incolor != L_BRING_IN_BLACK) |
| return (PIX *)ERROR_PTR("invalid incolor", procName, NULL); |
| if (ptaGetCount(ptas) != 4) |
| return (PIX *)ERROR_PTR("ptas count not 4", procName, NULL); |
| if (ptaGetCount(ptad) != 4) |
| return (PIX *)ERROR_PTR("ptad count not 4", procName, NULL); |
| |
| /* Get backwards transform from dest to src, and apply it */ |
| getProjectiveXformCoeffs(ptad, ptas, &vc); |
| pixd = pixProjectiveSampled(pixs, vc, incolor); |
| FREE(vc); |
| |
| return pixd; |
| } |
| |
| |
| /*! |
| * pixProjectiveSampled() |
| * |
| * Input: pixs (all depths) |
| * vc (vector of 8 coefficients for projective transformation) |
| * incolor (L_BRING_IN_WHITE, L_BRING_IN_BLACK) |
| * Return: pixd, or null on error |
| * |
| * Notes: |
| * (1) Brings in either black or white pixels from the boundary. |
| * (2) Retains colormap, which you can do for a sampled transform.. |
| * (3) For 8 or 32 bpp, much better quality is obtained by the |
| * somewhat slower pixProjective(). See that function |
| * for relative timings between sampled and interpolated. |
| */ |
| PIX * |
| pixProjectiveSampled(PIX *pixs, |
| l_float32 *vc, |
| l_int32 incolor) |
| { |
| l_int32 i, j, w, h, d, x, y, wpls, wpld, color, cmapindex; |
| l_uint32 val; |
| l_uint32 *datas, *datad, *lines, *lined; |
| PIX *pixd; |
| PIXCMAP *cmap; |
| |
| PROCNAME("pixProjectiveSampled"); |
| |
| if (!pixs) |
| return (PIX *)ERROR_PTR("pixs not defined", procName, NULL); |
| if (!vc) |
| return (PIX *)ERROR_PTR("vc not defined", procName, NULL); |
| if (incolor != L_BRING_IN_WHITE && incolor != L_BRING_IN_BLACK) |
| return (PIX *)ERROR_PTR("invalid incolor", procName, NULL); |
| pixGetDimensions(pixs, &w, &h, &d); |
| if (d != 1 && d != 2 && d != 4 && d != 8 && d != 32) |
| return (PIX *)ERROR_PTR("depth not 1, 2, 4, 8 or 16", procName, NULL); |
| |
| /* Init all dest pixels to color to be brought in from outside */ |
| pixd = pixCreateTemplate(pixs); |
| if ((cmap = pixGetColormap(pixs)) != NULL) { |
| if (incolor == L_BRING_IN_WHITE) |
| color = 1; |
| else |
| color = 0; |
| pixcmapAddBlackOrWhite(cmap, color, &cmapindex); |
| pixSetAllArbitrary(pixd, cmapindex); |
| } |
| else { |
| if ((d == 1 && incolor == L_BRING_IN_WHITE) || |
| (d > 1 && incolor == L_BRING_IN_BLACK)) |
| pixClearAll(pixd); |
| else |
| pixSetAll(pixd); |
| } |
| |
| /* Scan over the dest pixels */ |
| datas = pixGetData(pixs); |
| wpls = pixGetWpl(pixs); |
| datad = pixGetData(pixd); |
| wpld = pixGetWpl(pixd); |
| for (i = 0; i < h; i++) { |
| lined = datad + i * wpld; |
| for (j = 0; j < w; j++) { |
| projectiveXformSampledPt(vc, j, i, &x, &y); |
| if (x < 0 || y < 0 || x >=w || y >= h) |
| continue; |
| lines = datas + y * wpls; |
| if (d == 1) { |
| val = GET_DATA_BIT(lines, x); |
| SET_DATA_BIT_VAL(lined, j, val); |
| } |
| else if (d == 8) { |
| val = GET_DATA_BYTE(lines, x); |
| SET_DATA_BYTE(lined, j, val); |
| } |
| else if (d == 32) { |
| lined[j] = lines[x]; |
| } |
| else if (d == 2) { |
| val = GET_DATA_DIBIT(lines, x); |
| SET_DATA_DIBIT(lined, j, val); |
| } |
| else if (d == 4) { |
| val = GET_DATA_QBIT(lines, x); |
| SET_DATA_QBIT(lined, j, val); |
| } |
| } |
| } |
| |
| return pixd; |
| } |
| |
| |
| /*---------------------------------------------------------------------* |
| * Interpolated projective image transformation * |
| *---------------------------------------------------------------------*/ |
| /*! |
| * pixProjectivePta() |
| * |
| * Input: pixs (all depths; colormap ok) |
| * ptad (4 pts of final coordinate space) |
| * ptas (4 pts of initial coordinate space) |
| * incolor (L_BRING_IN_WHITE, L_BRING_IN_BLACK) |
| * Return: pixd, or null on error |
| * |
| * Notes: |
| * (1) Brings in either black or white pixels from the boundary |
| * (2) Removes any existing colormap, if necessary, before transforming |
| */ |
| PIX * |
| pixProjectivePta(PIX *pixs, |
| PTA *ptad, |
| PTA *ptas, |
| l_int32 incolor) |
| { |
| l_int32 d; |
| l_uint32 colorval; |
| PIX *pixt1, *pixt2, *pixd; |
| |
| PROCNAME("pixProjectivePta"); |
| |
| if (!pixs) |
| return (PIX *)ERROR_PTR("pixs not defined", procName, NULL); |
| if (!ptas) |
| return (PIX *)ERROR_PTR("ptas not defined", procName, NULL); |
| if (!ptad) |
| return (PIX *)ERROR_PTR("ptad not defined", procName, NULL); |
| if (incolor != L_BRING_IN_WHITE && incolor != L_BRING_IN_BLACK) |
| return (PIX *)ERROR_PTR("invalid incolor", procName, NULL); |
| if (ptaGetCount(ptas) != 4) |
| return (PIX *)ERROR_PTR("ptas count not 4", procName, NULL); |
| if (ptaGetCount(ptad) != 4) |
| return (PIX *)ERROR_PTR("ptad count not 4", procName, NULL); |
| |
| if (pixGetDepth(pixs) == 1) |
| return pixProjectiveSampledPta(pixs, ptad, ptas, incolor); |
| |
| /* Remove cmap if it exists, and unpack to 8 bpp if necessary */ |
| pixt1 = pixRemoveColormap(pixs, REMOVE_CMAP_BASED_ON_SRC); |
| d = pixGetDepth(pixt1); |
| if (d < 8) |
| pixt2 = pixConvertTo8(pixt1, FALSE); |
| else |
| pixt2 = pixClone(pixt1); |
| d = pixGetDepth(pixt2); |
| |
| /* Compute actual color to bring in from edges */ |
| colorval = 0; |
| if (incolor == L_BRING_IN_WHITE) { |
| if (d == 8) |
| colorval = 255; |
| else /* d == 32 */ |
| colorval = 0xffffff00; |
| } |
| |
| if (d == 8) |
| pixd = pixProjectivePtaGray(pixt2, ptad, ptas, colorval); |
| else /* d == 32 */ |
| pixd = pixProjectivePtaColor(pixt2, ptad, ptas, colorval); |
| pixDestroy(&pixt1); |
| pixDestroy(&pixt2); |
| return pixd; |
| } |
| |
| |
| /*! |
| * pixProjective() |
| * |
| * Input: pixs (all depths; colormap ok) |
| * vc (vector of 8 coefficients for affine transformation) |
| * incolor (L_BRING_IN_WHITE, L_BRING_IN_BLACK) |
| * Return: pixd, or null on error |
| * |
| * Notes: |
| * (1) Brings in either black or white pixels from the boundary |
| * (2) Removes any existing colormap, if necessary, before transforming |
| */ |
| PIX * |
| pixProjective(PIX *pixs, |
| l_float32 *vc, |
| l_int32 incolor) |
| { |
| l_int32 d; |
| l_uint32 colorval; |
| PIX *pixt1, *pixt2, *pixd; |
| |
| PROCNAME("pixProjective"); |
| |
| if (!pixs) |
| return (PIX *)ERROR_PTR("pixs not defined", procName, NULL); |
| if (!vc) |
| return (PIX *)ERROR_PTR("vc not defined", procName, NULL); |
| |
| if (pixGetDepth(pixs) == 1) |
| return pixProjectiveSampled(pixs, vc, incolor); |
| |
| /* Remove cmap if it exists, and unpack to 8 bpp if necessary */ |
| pixt1 = pixRemoveColormap(pixs, REMOVE_CMAP_BASED_ON_SRC); |
| d = pixGetDepth(pixt1); |
| if (d < 8) |
| pixt2 = pixConvertTo8(pixt1, FALSE); |
| else |
| pixt2 = pixClone(pixt1); |
| d = pixGetDepth(pixt2); |
| |
| /* Compute actual color to bring in from edges */ |
| colorval = 0; |
| if (incolor == L_BRING_IN_WHITE) { |
| if (d == 8) |
| colorval = 255; |
| else /* d == 32 */ |
| colorval = 0xffffff00; |
| } |
| |
| if (d == 8) |
| pixd = pixProjectiveGray(pixt2, vc, colorval); |
| else /* d == 32 */ |
| pixd = pixProjectiveColor(pixt2, vc, colorval); |
| pixDestroy(&pixt1); |
| pixDestroy(&pixt2); |
| return pixd; |
| } |
| |
| |
| /*! |
| * pixProjectivePtaColor() |
| * |
| * Input: pixs (32 bpp) |
| * ptad (4 pts of final coordinate space) |
| * ptas (4 pts of initial coordinate space) |
| * colorval (e.g., 0 to bring in BLACK, 0xffffff00 for WHITE) |
| * Return: pixd, or null on error |
| */ |
| PIX * |
| pixProjectivePtaColor(PIX *pixs, |
| PTA *ptad, |
| PTA *ptas, |
| l_uint32 colorval) |
| { |
| l_float32 *vc; |
| PIX *pixd; |
| |
| PROCNAME("pixProjectivePtaColor"); |
| |
| if (!pixs) |
| return (PIX *)ERROR_PTR("pixs not defined", procName, NULL); |
| if (!ptas) |
| return (PIX *)ERROR_PTR("ptas not defined", procName, NULL); |
| if (!ptad) |
| return (PIX *)ERROR_PTR("ptad not defined", procName, NULL); |
| if (pixGetDepth(pixs) != 32) |
| return (PIX *)ERROR_PTR("pixs must be 32 bpp", procName, NULL); |
| if (ptaGetCount(ptas) != 4) |
| return (PIX *)ERROR_PTR("ptas count not 4", procName, NULL); |
| if (ptaGetCount(ptad) != 4) |
| return (PIX *)ERROR_PTR("ptad count not 4", procName, NULL); |
| |
| /* Get backwards transform from dest to src, and apply it */ |
| getProjectiveXformCoeffs(ptad, ptas, &vc); |
| pixd = pixProjectiveColor(pixs, vc, colorval); |
| FREE(vc); |
| |
| return pixd; |
| } |
| |
| |
| /*! |
| * pixProjectiveColor() |
| * |
| * Input: pixs (32 bpp) |
| * vc (vector of 6 coefficients for affine transformation) |
| * colorval (e.g., 0 to bring in BLACK, 0xffffff00 for WHITE) |
| * Return: pixd, or null on error |
| */ |
| PIX * |
| pixProjectiveColor(PIX *pixs, |
| l_float32 *vc, |
| l_uint32 colorval) |
| { |
| l_int32 i, j, w, h, d, wpls, wpld; |
| l_uint32 val; |
| l_uint32 *datas, *datad, *lined; |
| l_float32 x, y; |
| PIX *pixd; |
| |
| PROCNAME("pixProjectiveColor"); |
| |
| if (!pixs) |
| return (PIX *)ERROR_PTR("pixs not defined", procName, NULL); |
| pixGetDimensions(pixs, &w, &h, &d); |
| if (d != 32) |
| return (PIX *)ERROR_PTR("pixs must be 32 bpp", procName, NULL); |
| if (!vc) |
| return (PIX *)ERROR_PTR("vc not defined", procName, NULL); |
| |
| datas = pixGetData(pixs); |
| wpls = pixGetWpl(pixs); |
| pixd = pixCreateTemplate(pixs); |
| pixSetAllArbitrary(pixd, colorval); |
| datad = pixGetData(pixd); |
| wpld = pixGetWpl(pixd); |
| |
| /* Iterate over destination pixels */ |
| for (i = 0; i < h; i++) { |
| lined = datad + i * wpld; |
| for (j = 0; j < w; j++) { |
| /* Compute float src pixel location corresponding to (i,j) */ |
| projectiveXformPt(vc, j, i, &x, &y); |
| linearInterpolatePixelColor(datas, wpls, w, h, x, y, colorval, |
| &val); |
| *(lined + j) = val; |
| } |
| } |
| |
| return pixd; |
| } |
| |
| |
| /*! |
| * pixProjectivePtaGray() |
| * |
| * Input: pixs (8 bpp) |
| * ptad (4 pts of final coordinate space) |
| * ptas (4 pts of initial coordinate space) |
| * grayval (0 to bring in BLACK, 255 for WHITE) |
| * Return: pixd, or null on error |
| */ |
| PIX * |
| pixProjectivePtaGray(PIX *pixs, |
| PTA *ptad, |
| PTA *ptas, |
| l_uint8 grayval) |
| { |
| l_float32 *vc; |
| PIX *pixd; |
| |
| PROCNAME("pixProjectivePtaGray"); |
| |
| if (!pixs) |
| return (PIX *)ERROR_PTR("pixs not defined", procName, NULL); |
| if (!ptas) |
| return (PIX *)ERROR_PTR("ptas not defined", procName, NULL); |
| if (!ptad) |
| return (PIX *)ERROR_PTR("ptad not defined", procName, NULL); |
| if (pixGetDepth(pixs) != 8) |
| return (PIX *)ERROR_PTR("pixs must be 8 bpp", procName, NULL); |
| if (ptaGetCount(ptas) != 4) |
| return (PIX *)ERROR_PTR("ptas count not 4", procName, NULL); |
| if (ptaGetCount(ptad) != 4) |
| return (PIX *)ERROR_PTR("ptad count not 4", procName, NULL); |
| |
| /* Get backwards transform from dest to src, and apply it */ |
| getProjectiveXformCoeffs(ptad, ptas, &vc); |
| pixd = pixProjectiveGray(pixs, vc, grayval); |
| FREE(vc); |
| |
| return pixd; |
| } |
| |
| |
| |
| /*! |
| * pixProjectiveGray() |
| * |
| * Input: pixs (8 bpp) |
| * vc (vector of 8 coefficients for affine transformation) |
| * grayval (0 to bring in BLACK, 255 for WHITE) |
| * Return: pixd, or null on error |
| */ |
| PIX * |
| pixProjectiveGray(PIX *pixs, |
| l_float32 *vc, |
| l_uint8 grayval) |
| { |
| l_int32 i, j, w, h, wpls, wpld, val; |
| l_uint32 *datas, *datad, *lined; |
| l_float32 x, y; |
| PIX *pixd; |
| |
| PROCNAME("pixProjectiveGray"); |
| |
| if (!pixs) |
| return (PIX *)ERROR_PTR("pixs not defined", procName, NULL); |
| pixGetDimensions(pixs, &w, &h, NULL); |
| if (pixGetDepth(pixs) != 8) |
| return (PIX *)ERROR_PTR("pixs must be 8 bpp", procName, NULL); |
| if (!vc) |
| return (PIX *)ERROR_PTR("vc not defined", procName, NULL); |
| |
| datas = pixGetData(pixs); |
| wpls = pixGetWpl(pixs); |
| pixd = pixCreateTemplate(pixs); |
| pixSetAllArbitrary(pixd, grayval); |
| datad = pixGetData(pixd); |
| wpld = pixGetWpl(pixd); |
| |
| /* Iterate over destination pixels */ |
| for (i = 0; i < h; i++) { |
| lined = datad + i * wpld; |
| for (j = 0; j < w; j++) { |
| /* Compute float src pixel location corresponding to (i,j) */ |
| projectiveXformPt(vc, j, i, &x, &y); |
| linearInterpolatePixelGray(datas, wpls, w, h, x, y, grayval, &val); |
| SET_DATA_BYTE(lined, j, val); |
| } |
| } |
| |
| return pixd; |
| } |
| |
| |
| /*-------------------------------------------------------------* |
| * Projective coordinate transformation * |
| *-------------------------------------------------------------*/ |
| /*! |
| * getProjectiveXformCoeffs() |
| * |
| * Input: ptas (source 4 points; unprimed) |
| * ptad (transformed 4 points; primed) |
| * &vc (<return> vector of coefficients of transform) |
| * Return: 0 if OK; 1 on error |
| * |
| * We have a set of 8 equations, describing the projective |
| * transformation that takes 4 points (ptas) into 4 other |
| * points (ptad). These equations are: |
| * |
| * x1' = (c[0]*x1 + c[1]*y1 + c[2]) / (c[6]*x1 + c[7]*y1 + 1) |
| * y1' = (c[3]*x1 + c[4]*y1 + c[5]) / (c[6]*x1 + c[7]*y1 + 1) |
| * x2' = (c[0]*x2 + c[1]*y2 + c[2]) / (c[6]*x2 + c[7]*y2 + 1) |
| * y2' = (c[3]*x2 + c[4]*y2 + c[5]) / (c[6]*x2 + c[7]*y2 + 1) |
| * x3' = (c[0]*x3 + c[1]*y3 + c[2]) / (c[6]*x3 + c[7]*y3 + 1) |
| * y3' = (c[3]*x3 + c[4]*y3 + c[5]) / (c[6]*x3 + c[7]*y3 + 1) |
| * x4' = (c[0]*x4 + c[1]*y4 + c[2]) / (c[6]*x4 + c[7]*y4 + 1) |
| * y4' = (c[3]*x4 + c[4]*y4 + c[5]) / (c[6]*x4 + c[7]*y4 + 1) |
| * |
| * Multiplying both sides of each eqn by the denominator, we get |
| * |
| * AC = B |
| * |
| * where B and C are column vectors |
| * |
| * B = [ x1' y1' x2' y2' x3' y3' x4' y4' ] |
| * C = [ c[0] c[1] c[2] c[3] c[4] c[5] c[6] c[7] ] |
| * |
| * and A is the 8x8 matrix |
| * |
| * x1 y1 1 0 0 0 -x1*x1' -y1*x1' |
| * 0 0 0 x1 y1 1 -x1*y1' -y1*y1' |
| * x2 y2 1 0 0 0 -x2*x2' -y2*x2' |
| * 0 0 0 x2 y2 1 -x2*y2' -y2*y2' |
| * x3 y3 1 0 0 0 -x3*x3' -y3*x3' |
| * 0 0 0 x3 y3 1 -x3*y3' -y3*y3' |
| * x4 y4 1 0 0 0 -x4*x4' -y4*x4' |
| * 0 0 0 x4 y4 1 -x4*y4' -y4*y4' |
| * |
| * These eight equations are solved here for the coefficients C. |
| * |
| * These eight coefficients can then be used to find the mapping |
| * (x,y) --> (x',y'): |
| * |
| * x' = (c[0]x + c[1]y + c[2]) / (c[6]x + c[7]y + 1) |
| * y' = (c[3]x + c[4]y + c[5]) / (c[6]x + c[7]y + 1) |
| * |
| * that is implemented in projectiveXformSampled() and |
| * projectiveXFormInterpolated(). |
| */ |
| l_int32 |
| getProjectiveXformCoeffs(PTA *ptas, |
| PTA *ptad, |
| l_float32 **pvc) |
| { |
| l_int32 i; |
| l_float32 x1, y1, x2, y2, x3, y3, x4, y4; |
| l_float32 *b; /* rhs vector of primed coords X'; coeffs returned in *pvc */ |
| l_float32 *a[8]; /* 8x8 matrix A */ |
| |
| PROCNAME("getProjectiveXformCoeffs"); |
| |
| if (!ptas) |
| return ERROR_INT("ptas not defined", procName, 1); |
| if (!ptad) |
| return ERROR_INT("ptad not defined", procName, 1); |
| if (!pvc) |
| return ERROR_INT("&vc not defined", procName, 1); |
| |
| if ((b = (l_float32 *)CALLOC(8, sizeof(l_float32))) == NULL) |
| return ERROR_INT("b not made", procName, 1); |
| *pvc = b; |
| |
| ptaGetPt(ptas, 0, &x1, &y1); |
| ptaGetPt(ptas, 1, &x2, &y2); |
| ptaGetPt(ptas, 2, &x3, &y3); |
| ptaGetPt(ptas, 3, &x4, &y4); |
| ptaGetPt(ptad, 0, &b[0], &b[1]); |
| ptaGetPt(ptad, 1, &b[2], &b[3]); |
| ptaGetPt(ptad, 2, &b[4], &b[5]); |
| ptaGetPt(ptad, 3, &b[6], &b[7]); |
| |
| for (i = 0; i < 8; i++) { |
| if ((a[i] = (l_float32 *)CALLOC(8, sizeof(l_float32))) == NULL) |
| return ERROR_INT("a[i] not made", procName, 1); |
| } |
| |
| a[0][0] = x1; |
| a[0][1] = y1; |
| a[0][2] = 1.; |
| a[0][6] = -x1 * b[0]; |
| a[0][7] = -y1 * b[0]; |
| a[1][3] = x1; |
| a[1][4] = y1; |
| a[1][5] = 1; |
| a[1][6] = -x1 * b[1]; |
| a[1][7] = -y1 * b[1]; |
| a[2][0] = x2; |
| a[2][1] = y2; |
| a[2][2] = 1.; |
| a[2][6] = -x2 * b[2]; |
| a[2][7] = -y2 * b[2]; |
| a[3][3] = x2; |
| a[3][4] = y2; |
| a[3][5] = 1; |
| a[3][6] = -x2 * b[3]; |
| a[3][7] = -y2 * b[3]; |
| a[4][0] = x3; |
| a[4][1] = y3; |
| a[4][2] = 1.; |
| a[4][6] = -x3 * b[4]; |
| a[4][7] = -y3 * b[4]; |
| a[5][3] = x3; |
| a[5][4] = y3; |
| a[5][5] = 1; |
| a[5][6] = -x3 * b[5]; |
| a[5][7] = -y3 * b[5]; |
| a[6][0] = x4; |
| a[6][1] = y4; |
| a[6][2] = 1.; |
| a[6][6] = -x4 * b[6]; |
| a[6][7] = -y4 * b[6]; |
| a[7][3] = x4; |
| a[7][4] = y4; |
| a[7][5] = 1; |
| a[7][6] = -x4 * b[7]; |
| a[7][7] = -y4 * b[7]; |
| |
| gaussjordan(a, b, 8); |
| |
| for (i = 0; i < 8; i++) |
| FREE(a[i]); |
| |
| return 0; |
| } |
| |
| |
| /*! |
| * projectiveXformSampledPt() |
| * |
| * Input: vc (vector of 8 coefficients) |
| * (x, y) (initial point) |
| * (&xp, &yp) (<return> transformed point) |
| * Return: 0 if OK; 1 on error |
| * |
| * Notes: |
| * (1) This finds the nearest pixel coordinates of the transformed point. |
| * (2) It does not check ptrs for returned data! |
| */ |
| l_int32 |
| projectiveXformSampledPt(l_float32 *vc, |
| l_int32 x, |
| l_int32 y, |
| l_int32 *pxp, |
| l_int32 *pyp) |
| { |
| l_float32 factor; |
| |
| PROCNAME("projectiveXformSampledPt"); |
| |
| if (!vc) |
| return ERROR_INT("vc not defined", procName, 1); |
| |
| factor = 1. / (vc[6] * x + vc[7] * y + 1.); |
| *pxp = (l_int32)(factor * (vc[0] * x + vc[1] * y + vc[2]) + 0.5); |
| *pyp = (l_int32)(factor * (vc[3] * x + vc[4] * y + vc[5]) + 0.5); |
| return 0; |
| } |
| |
| |
| /*! |
| * projectiveXformPt() |
| * |
| * Input: vc (vector of 8 coefficients) |
| * (x, y) (initial point) |
| * (&xp, &yp) (<return> transformed point) |
| * Return: 0 if OK; 1 on error |
| * |
| * Notes: |
| * (1) This computes the floating point location of the transformed point. |
| * (2) It does not check ptrs for returned data! |
| */ |
| l_int32 |
| projectiveXformPt(l_float32 *vc, |
| l_int32 x, |
| l_int32 y, |
| l_float32 *pxp, |
| l_float32 *pyp) |
| { |
| l_float32 factor; |
| |
| PROCNAME("projectiveXformPt"); |
| |
| if (!vc) |
| return ERROR_INT("vc not defined", procName, 1); |
| |
| factor = 1. / (vc[6] * x + vc[7] * y + 1.); |
| *pxp = factor * (vc[0] * x + vc[1] * y + vc[2]); |
| *pyp = factor * (vc[3] * x + vc[4] * y + vc[5]); |
| return 0; |
| } |
| |
| |
