235 #include <config_auto.h>
240 #include "allheaders.h"
242 extern l_float32 AlphaMaskBorderVals[2];
244 #ifndef NO_CONSOLE_IO
290 PROCNAME(
"pixAffineSampledPta");
293 return (
PIX *)ERROR_PTR(
"pixs not defined", procName, NULL);
295 return (
PIX *)ERROR_PTR(
"ptas not defined", procName, NULL);
297 return (
PIX *)ERROR_PTR(
"ptad not defined", procName, NULL);
299 return (
PIX *)ERROR_PTR(
"invalid incolor", procName, NULL);
301 return (
PIX *)ERROR_PTR(
"ptas count not 3", procName, NULL);
303 return (
PIX *)ERROR_PTR(
"ptad count not 3", procName, NULL);
336 l_int32 i, j, w, h, d, x, y, wpls, wpld, color, cmapindex;
338 l_uint32 *datas, *datad, *lines, *lined;
342 PROCNAME(
"pixAffineSampled");
345 return (
PIX *)ERROR_PTR(
"pixs not defined", procName, NULL);
347 return (
PIX *)ERROR_PTR(
"vc not defined", procName, NULL);
349 return (
PIX *)ERROR_PTR(
"invalid incolor", procName, NULL);
351 if (d != 1 && d != 2 && d != 4 && d != 8 && d != 32)
352 return (
PIX *)ERROR_PTR(
"depth not 1, 2, 4, 8 or 16", procName, NULL);
356 if ((cmap = pixGetColormap(pixs)) != NULL) {
374 wpls = pixGetWpl(pixs);
376 wpld = pixGetWpl(pixd);
377 for (i = 0; i < h; i++) {
378 lined = datad + i * wpld;
379 for (j = 0; j < w; j++) {
381 if (x < 0 || y < 0 || x >=w || y >= h)
383 lines = datas + y * wpls;
390 }
else if (d == 32) {
432 PIX *pixt1, *pixt2, *pixd;
434 PROCNAME(
"pixAffinePta");
437 return (
PIX *)ERROR_PTR(
"pixs not defined", procName, NULL);
439 return (
PIX *)ERROR_PTR(
"ptas not defined", procName, NULL);
441 return (
PIX *)ERROR_PTR(
"ptad not defined", procName, NULL);
443 return (
PIX *)ERROR_PTR(
"invalid incolor", procName, NULL);
445 return (
PIX *)ERROR_PTR(
"ptas count not 3", procName, NULL);
447 return (
PIX *)ERROR_PTR(
"ptad count not 3", procName, NULL);
449 if (pixGetDepth(pixs) == 1)
454 d = pixGetDepth(pixt1);
459 d = pixGetDepth(pixt2);
467 colorval = 0xffffff00;
501 PIX *pixt1, *pixt2, *pixd;
503 PROCNAME(
"pixAffine");
506 return (
PIX *)ERROR_PTR(
"pixs not defined", procName, NULL);
508 return (
PIX *)ERROR_PTR(
"vc not defined", procName, NULL);
510 if (pixGetDepth(pixs) == 1)
515 d = pixGetDepth(pixt1);
520 d = pixGetDepth(pixt2);
528 colorval = 0xffffff00;
559 PROCNAME(
"pixAffinePtaColor");
562 return (
PIX *)ERROR_PTR(
"pixs not defined", procName, NULL);
564 return (
PIX *)ERROR_PTR(
"ptas not defined", procName, NULL);
566 return (
PIX *)ERROR_PTR(
"ptad not defined", procName, NULL);
567 if (pixGetDepth(pixs) != 32)
568 return (
PIX *)ERROR_PTR(
"pixs must be 32 bpp", procName, NULL);
570 return (
PIX *)ERROR_PTR(
"ptas count not 3", procName, NULL);
572 return (
PIX *)ERROR_PTR(
"ptad count not 3", procName, NULL);
596 l_int32 i, j, w, h, d, wpls, wpld;
598 l_uint32 *datas, *datad, *lined;
600 PIX *pix1, *pix2, *pixd;
602 PROCNAME(
"pixAffineColor");
605 return (
PIX *)ERROR_PTR(
"pixs not defined", procName, NULL);
608 return (
PIX *)ERROR_PTR(
"pixs must be 32 bpp", procName, NULL);
610 return (
PIX *)ERROR_PTR(
"vc not defined", procName, NULL);
613 wpls = pixGetWpl(pixs);
617 wpld = pixGetWpl(pixd);
620 for (i = 0; i < h; i++) {
621 lined = datad + i * wpld;
622 for (j = 0; j < w; j++) {
632 if (pixGetSpp(pixs) == 4) {
662 PROCNAME(
"pixAffinePtaGray");
665 return (
PIX *)ERROR_PTR(
"pixs not defined", procName, NULL);
667 return (
PIX *)ERROR_PTR(
"ptas not defined", procName, NULL);
669 return (
PIX *)ERROR_PTR(
"ptad not defined", procName, NULL);
670 if (pixGetDepth(pixs) != 8)
671 return (
PIX *)ERROR_PTR(
"pixs must be 8 bpp", procName, NULL);
673 return (
PIX *)ERROR_PTR(
"ptas count not 3", procName, NULL);
675 return (
PIX *)ERROR_PTR(
"ptad count not 3", procName, NULL);
700 l_int32 i, j, w, h, wpls, wpld, val;
701 l_uint32 *datas, *datad, *lined;
705 PROCNAME(
"pixAffineGray");
708 return (
PIX *)ERROR_PTR(
"pixs not defined", procName, NULL);
710 if (pixGetDepth(pixs) != 8)
711 return (
PIX *)ERROR_PTR(
"pixs must be 8 bpp", procName, NULL);
713 return (
PIX *)ERROR_PTR(
"vc not defined", procName, NULL);
716 wpls = pixGetWpl(pixs);
720 wpld = pixGetWpl(pixd);
723 for (i = 0; i < h; i++) {
724 lined = datad + i * wpld;
725 for (j = 0; j < w; j++) {
792 PIX *pixd, *pixb1, *pixb2, *pixg2, *pixga;
795 PROCNAME(
"pixAffinePtaWithAlpha");
798 return (
PIX *)ERROR_PTR(
"pixs not defined", procName, NULL);
800 if (d != 32 && pixGetColormap(pixs) == NULL)
801 return (
PIX *)ERROR_PTR(
"pixs not cmapped or 32 bpp", procName, NULL);
802 if (pixg && pixGetDepth(pixg) != 8) {
803 L_WARNING(
"pixg not 8 bpp; using 'fract' transparent alpha\n",
807 if (!pixg && (fract < 0.0 || fract > 1.0)) {
808 L_WARNING(
"invalid fract; using 1.0 (fully transparent)\n", procName);
811 if (!pixg && fract == 0.0)
812 L_WARNING(
"fully opaque alpha; image will not be blended\n", procName);
814 return (
PIX *)ERROR_PTR(
"ptad not defined", procName, NULL);
816 return (
PIX *)ERROR_PTR(
"ptas not defined", procName, NULL);
836 if (ws > 10 && hs > 10) {
838 (l_int32)(255.0 * fract * AlphaMaskBorderVals[0]));
840 (l_int32)(255.0 * fract * AlphaMaskBorderVals[1]));
938 l_float32 x1, y1, x2, y2, x3, y3;
942 PROCNAME(
"getAffineXformCoeffs");
945 return ERROR_INT(
"ptas not defined", procName, 1);
947 return ERROR_INT(
"ptad not defined", procName, 1);
949 return ERROR_INT(
"&vc not defined", procName, 1);
951 b = (l_float32 *)LEPT_CALLOC(6,
sizeof(l_float32));
961 for (i = 0; i < 6; i++)
962 a[i] = (l_float32 *)LEPT_CALLOC(6,
sizeof(l_float32));
984 for (i = 0; i < 6; i++)
1029 l_float32 b[3] = {1.0, 1.0, 1.0};
1031 PROCNAME(
"affineInvertXform");
1034 return ERROR_INT(
"&vci not defined", procName, 1);
1037 return ERROR_INT(
"vc not defined", procName, 1);
1040 for (i = 0; i < 3; i++)
1041 a[i] = (l_float32 *)LEPT_CALLOC(3,
sizeof(l_float32));
1050 vci = (l_float32 *)LEPT_CALLOC(6,
sizeof(l_float32));
1058 for (i = 0; i < 3; i++)
1065 for (i = 0; i < 2; i++)
1066 a2[i] = (l_float32 *)LEPT_CALLOC(2,
sizeof(l_float32));
1074 vci = (l_float32 *)LEPT_CALLOC(6,
sizeof(l_float32));
1082 for (i = 0; i < 2; i++)
1112 PROCNAME(
"affineXformSampledPt");
1115 return ERROR_INT(
"vc not defined", procName, 1);
1117 *pxp = (l_int32)(vc[0] * x + vc[1] * y + vc[2] + 0.5);
1118 *pyp = (l_int32)(vc[3] * x + vc[4] * y + vc[5] + 0.5);
1144 PROCNAME(
"affineXformPt");
1147 return ERROR_INT(
"vc not defined", procName, 1);
1149 *pxp = vc[0] * x + vc[1] * y + vc[2];
1150 *pyp = vc[3] * x + vc[4] * y + vc[5];
1188 l_int32 valid, xpm, ypm, xp, xp2, yp, xf, yf;
1189 l_int32 rval, gval, bval;
1190 l_uint32 word00, word01, word10, word11;
1193 PROCNAME(
"linearInterpolatePixelColor");
1196 return ERROR_INT(
"&val not defined", procName, 1);
1199 return ERROR_INT(
"datas not defined", procName, 1);
1205 valid = (x >= 0.0 && y >= 0.0 && x < w && y < h);
1206 if (!valid)
return 0;
1208 xpm = (l_int32)(16.0 * x);
1209 ypm = (l_int32)(16.0 * y);
1211 xp2 = xp + 1 < w ? xp + 1 : xp;
1213 if (yp + 1 >= h) wpls = 0;
1218 if (xf < 0 || yf < 0)
1219 lept_stderr(
"xp = %d, yp = %d, xf = %d, yf = %d\n", xp, yp, xf, yf);
1223 lines = datas + yp * wpls;
1224 word00 = *(lines + xp);
1225 word10 = *(lines + xp2);
1226 word01 = *(lines + wpls + xp);
1227 word11 = *(lines + wpls + xp2);
1228 rval = ((16 - xf) * (16 - yf) * ((word00 >> L_RED_SHIFT) & 0xff) +
1229 xf * (16 - yf) * ((word10 >> L_RED_SHIFT) & 0xff) +
1230 (16 - xf) * yf * ((word01 >> L_RED_SHIFT) & 0xff) +
1231 xf * yf * ((word11 >> L_RED_SHIFT) & 0xff)) / 256;
1232 gval = ((16 - xf) * (16 - yf) * ((word00 >> L_GREEN_SHIFT) & 0xff) +
1233 xf * (16 - yf) * ((word10 >> L_GREEN_SHIFT) & 0xff) +
1234 (16 - xf) * yf * ((word01 >> L_GREEN_SHIFT) & 0xff) +
1235 xf * yf * ((word11 >> L_GREEN_SHIFT) & 0xff)) / 256;
1236 bval = ((16 - xf) * (16 - yf) * ((word00 >> L_BLUE_SHIFT) & 0xff) +
1237 xf * (16 - yf) * ((word10 >> L_BLUE_SHIFT) & 0xff) +
1238 (16 - xf) * yf * ((word01 >> L_BLUE_SHIFT) & 0xff) +
1239 xf * yf * ((word11 >> L_BLUE_SHIFT) & 0xff)) / 256;
1274 l_int32 valid, xpm, ypm, xp, xp2, yp, xf, yf, v00, v10, v01, v11;
1277 PROCNAME(
"linearInterpolatePixelGray");
1280 return ERROR_INT(
"&val not defined", procName, 1);
1283 return ERROR_INT(
"datas not defined", procName, 1);
1289 valid = (x >= 0.0 && y >= 0.0 && x < w && y < h);
1290 if (!valid)
return 0;
1292 xpm = (l_int32)(16.0 * x);
1293 ypm = (l_int32)(16.0 * y);
1295 xp2 = xp + 1 < w ? xp + 1 : xp;
1297 if (yp + 1 >= h) wpls = 0;
1302 if (xf < 0 || yf < 0)
1303 lept_stderr(
"xp = %d, yp = %d, xf = %d, yf = %d\n", xp, yp, xf, yf);
1307 lines = datas + yp * wpls;
1312 *pval = (v00 + v01 + v10 + v11) / 256;
1321 #define SWAP(a,b) {temp = (a); (a) = (b); (b) = temp;}
1348 l_int32 i, icol, irow, j, k, col, row, success;
1349 l_int32 *indexc, *indexr, *ipiv;
1350 l_float32 maxval, val, pivinv, temp;
1352 PROCNAME(
"gaussjordan");
1355 return ERROR_INT(
"a not defined", procName, 1);
1357 return ERROR_INT(
"b not defined", procName, 1);
1360 indexc = (l_int32 *)LEPT_CALLOC(n,
sizeof(l_int32));
1361 indexr = (l_int32 *)LEPT_CALLOC(n,
sizeof(l_int32));
1362 ipiv = (l_int32 *)LEPT_CALLOC(n,
sizeof(l_int32));
1363 if (!indexc || !indexr || !ipiv) {
1364 L_ERROR(
"array not made\n", procName);
1366 goto cleanup_arrays;
1370 for (i = 0; i < n; i++) {
1372 for (j = 0; j < n; j++) {
1374 for (k = 0; k < n; k++) {
1376 if (fabs(a[j][k]) >= maxval) {
1377 maxval = fabs(a[j][k]);
1381 }
else if (ipiv[k] > 1) {
1382 L_ERROR(
"singular matrix\n", procName);
1384 goto cleanup_arrays;
1392 for (col = 0; col < n; col++)
1393 SWAP(a[irow][col], a[icol][col]);
1394 SWAP(b[irow], b[icol]);
1399 if (a[icol][icol] == 0.0) {
1400 L_ERROR(
"singular matrix\n", procName);
1402 goto cleanup_arrays;
1404 pivinv = 1.0 / a[icol][icol];
1405 a[icol][icol] = 1.0;
1406 for (col = 0; col < n; col++)
1407 a[icol][col] *= pivinv;
1410 for (row = 0; row < n; row++) {
1414 for (col = 0; col < n; col++)
1415 a[row][col] -= a[icol][col] * val;
1416 b[row] -= b[icol] * val;
1421 for (col = n - 1; col >= 0; col--) {
1422 if (indexr[col] != indexc[col]) {
1423 for (k = 0; k < n; k++)
1424 SWAP(a[k][indexr[col]], a[k][indexc[col]]);
1432 return (success) ? 0 : 1;
1474 l_int32 x1, y1, x2, y2, x3, y3;
1475 l_int32 x1p, y1p, x2p, y2p, x3p, y3p;
1477 l_float32 x2s, x2sp, scalex, scaley;
1478 l_float32 th3, th3p, ph2, ph2p;
1482 PIX *pix1, *pix2, *pixd;
1484 PROCNAME(
"pixAffineSequential");
1487 return (
PIX *)ERROR_PTR(
"pixs not defined", procName, NULL);
1489 return (
PIX *)ERROR_PTR(
"ptas not defined", procName, NULL);
1491 return (
PIX *)ERROR_PTR(
"ptad not defined", procName, NULL);
1494 return (
PIX *)ERROR_PTR(
"ptas count not 3", procName, NULL);
1496 return (
PIX *)ERROR_PTR(
"ptad count not 3", procName, NULL);
1504 pix1 = pix2 = pixd = NULL;
1507 return (
PIX *)ERROR_PTR(
"y1 == y3!", procName, NULL);
1509 return (
PIX *)ERROR_PTR(
"y1p == y3p!", procName, NULL);
1511 if (bw != 0 || bh != 0) {
1527 return (
PIX *)ERROR_PTR(
"pix1 not made", procName, NULL);
1544 th3 = atan2((l_float64)(x1 - x3), (l_float64)(y1 - y3));
1545 x2s = (l_float32)(x2 - ((l_float32)(y1 - y2) * (x3 - x1)) / (y1 - y3));
1546 if (x2s == (l_float32)x1) {
1547 L_ERROR(
"x2s == x1!\n", procName);
1550 ph2 = atan2((l_float64)(y1 - y2), (l_float64)(x2s - x1));
1556 th3p = atan2((l_float64)(x1p - x3p), (l_float64)(y1p - y3p));
1557 x2sp = (l_float32)(x2p -
1558 ((l_float32)(y1p - y2p) * (x3p - x1p)) / (y1p - y3p));
1559 if (x2sp == (l_float32)x1p) {
1560 L_ERROR(
"x2sp == x1p!\n", procName);
1563 ph2p = atan2((l_float64)(y1p - y2p), (l_float64)(x2sp - x1p));
1574 scalex = (l_float32)(x2sp - x1p) / (x2s - x1);
1575 scaley = (l_float32)(y3p - y1p) / (y3 - y1);
1576 if ((pix2 =
pixScale(pix1, scalex, scaley)) == NULL) {
1577 L_ERROR(
"pix2 not made\n", procName);
1582 rad2deg = 180. / 3.1415926535;
1584 rad2deg * th3, rad2deg * ph2);
1585 lept_stderr(
"th3' = %5.1f deg, ph2' = %5.1f deg\n",
1586 rad2deg * th3p, rad2deg * ph2p);
1587 lept_stderr(
"scalex = %6.3f, scaley = %6.3f\n", scalex, scaley);
1601 x1sc = (l_int32)(scalex * x1 + 0.5);
1602 y1sc = (l_int32)(scaley * y1 + 0.5);
1610 if (bw != 0 || bh != 0) {
1612 L_ERROR(
"pixd not made\n", procName);
PIX * pixAffineColor(PIX *pixs, l_float32 *vc, l_uint32 colorval)
pixAffineColor()
l_ok affineInvertXform(l_float32 *vc, l_float32 **pvci)
affineInvertXform()
PIX * pixAffineSequential(PIX *pixs, PTA *ptad, PTA *ptas, l_int32 bw, l_int32 bh)
pixAffineSequential()
l_ok affineXformSampledPt(l_float32 *vc, l_int32 x, l_int32 y, l_int32 *pxp, l_int32 *pyp)
affineXformSampledPt()
PIX * pixAffinePta(PIX *pixs, PTA *ptad, PTA *ptas, l_int32 incolor)
pixAffinePta()
l_ok linearInterpolatePixelColor(l_uint32 *datas, l_int32 wpls, l_int32 w, l_int32 h, l_float32 x, l_float32 y, l_uint32 colorval, l_uint32 *pval)
linearInterpolatePixelColor()
l_int32 gaussjordan(l_float32 **a, l_float32 *b, l_int32 n)
gaussjordan()
PIX * pixAffineGray(PIX *pixs, l_float32 *vc, l_uint8 grayval)
pixAffineGray()
PIX * pixAffinePtaGray(PIX *pixs, PTA *ptad, PTA *ptas, l_uint8 grayval)
pixAffinePtaGray()
PIX * pixAffine(PIX *pixs, l_float32 *vc, l_int32 incolor)
pixAffine()
l_ok linearInterpolatePixelGray(l_uint32 *datas, l_int32 wpls, l_int32 w, l_int32 h, l_float32 x, l_float32 y, l_int32 grayval, l_int32 *pval)
linearInterpolatePixelGray()
PIX * pixAffineSampledPta(PIX *pixs, PTA *ptad, PTA *ptas, l_int32 incolor)
pixAffineSampledPta()
l_ok affineXformPt(l_float32 *vc, l_int32 x, l_int32 y, l_float32 *pxp, l_float32 *pyp)
affineXformPt()
PIX * pixAffineSampled(PIX *pixs, l_float32 *vc, l_int32 incolor)
pixAffineSampled()
l_ok getAffineXformCoeffs(PTA *ptas, PTA *ptad, l_float32 **pvc)
getAffineXformCoeffs()
PIX * pixAffinePtaColor(PIX *pixs, PTA *ptad, PTA *ptas, l_uint32 colorval)
pixAffinePtaColor()
PIX * pixAffinePtaWithAlpha(PIX *pixs, PTA *ptad, PTA *ptas, PIX *pixg, l_float32 fract, l_int32 border)
pixAffinePtaWithAlpha()
#define GET_DATA_QBIT(pdata, n)
#define SET_DATA_DIBIT(pdata, n, val)
#define SET_DATA_BIT_VAL(pdata, n, val)
#define GET_DATA_BYTE(pdata, n)
#define GET_DATA_DIBIT(pdata, n)
#define SET_DATA_BYTE(pdata, n, val)
#define GET_DATA_BIT(pdata, n)
#define SET_DATA_QBIT(pdata, n, val)
l_ok pixcmapAddBlackOrWhite(PIXCMAP *cmap, l_int32 color, l_int32 *pindex)
pixcmapAddBlackOrWhite()
l_uint32 * pixGetData(PIX *pix)
pixGetData()
void pixDestroy(PIX **ppix)
pixDestroy()
l_ok pixGetDimensions(const PIX *pix, l_int32 *pw, l_int32 *ph, l_int32 *pd)
pixGetDimensions()
PIX * pixCopy(PIX *pixd, const PIX *pixs)
pixCopy()
PIX * pixCreateTemplate(const PIX *pixs)
pixCreateTemplate()
PIX * pixCreate(l_int32 width, l_int32 height, l_int32 depth)
pixCreate()
PIX * pixClone(PIX *pixs)
pixClone()
l_ok pixSetBorderRingVal(PIX *pixs, l_int32 dist, l_uint32 val)
pixSetBorderRingVal()
PIX * pixGetRGBComponent(PIX *pixs, l_int32 comp)
pixGetRGBComponent()
l_ok pixClearAll(PIX *pix)
pixClearAll()
PIX * pixRemoveBorderGeneral(PIX *pixs, l_int32 left, l_int32 right, l_int32 top, l_int32 bot)
pixRemoveBorderGeneral()
PIX * pixAddBorder(PIX *pixs, l_int32 npix, l_uint32 val)
pixAddBorder()
PIX * pixAddBorderGeneral(PIX *pixs, l_int32 left, l_int32 right, l_int32 top, l_int32 bot, l_uint32 val)
pixAddBorderGeneral()
l_ok pixSetAll(PIX *pix)
pixSetAll()
l_ok composeRGBPixel(l_int32 rval, l_int32 gval, l_int32 bval, l_uint32 *ppixel)
composeRGBPixel()
l_ok pixSetRGBComponent(PIX *pixd, PIX *pixs, l_int32 comp)
pixSetRGBComponent()
l_ok pixSetAllArbitrary(PIX *pix, l_uint32 val)
pixSetAllArbitrary()
PIX * pixResizeToMatch(PIX *pixs, PIX *pixt, l_int32 w, l_int32 h)
pixResizeToMatch()
@ REMOVE_CMAP_BASED_ON_SRC
PIX * pixRemoveColormap(PIX *pixs, l_int32 type)
pixRemoveColormap()
PIX * pixConvertTo8(PIX *pixs, l_int32 cmapflag)
pixConvertTo8()
l_ok ptaGetIPt(PTA *pta, l_int32 index, l_int32 *px, l_int32 *py)
ptaGetIPt()
l_ok ptaGetPt(PTA *pta, l_int32 index, l_float32 *px, l_float32 *py)
ptaGetPt()
l_int32 ptaGetCount(PTA *pta)
ptaGetCount()
void ptaDestroy(PTA **ppta)
ptaDestroy()
PTA * ptaTransform(PTA *ptas, l_int32 shiftx, l_int32 shifty, l_float32 scalex, l_float32 scaley)
ptaTransform()
l_ok pixRasteropIP(PIX *pixd, l_int32 hshift, l_int32 vshift, l_int32 incolor)
pixRasteropIP()
PIX * pixScale(PIX *pixs, l_float32 scalex, l_float32 scaley)
pixScale()
l_ok pixHShearIP(PIX *pixs, l_int32 yloc, l_float32 radang, l_int32 incolor)
pixHShearIP()
l_ok pixVShearIP(PIX *pixs, l_int32 xloc, l_float32 radang, l_int32 incolor)
pixVShearIP()
void lept_stderr(const char *fmt,...)
lept_stderr()