135 #include <config_auto.h> 138 #include "allheaders.h" 157 l_int32 mindiff, l_int32 smoothx, l_int32 smoothy,
158 PIX **ppixmin,
PIX **ppixmax);
161 PIX *pixmin,
PIX *pixmax);
164 #ifndef NO_CONSOLE_IO 165 #define DEBUG_GLOBAL 0 206 PROCNAME(
"pixCleanBackgroundToWhite");
209 return (
PIX *)ERROR_PTR(
"pixs not defined", procName, NULL);
210 d = pixGetDepth(pixs);
211 if (d != 8 && d != 32)
212 return (
PIX *)ERROR_PTR(
"depth not 8 or 32", procName, NULL);
213 if (whiteval > 200) {
214 L_WARNING(
"white value %d must not exceed 200; reset to 190",
221 return (
PIX *)ERROR_PTR(
"background norm failedd", procName, NULL);
222 pixGammaTRC(pixd, pixd, gamma, blackval, whiteval);
334 PIX *pixm, *pixmi, *pixd;
335 PIX *pixmr, *pixmg, *pixmb, *pixmri, *pixmgi, *pixmbi;
337 PROCNAME(
"pixBackgroundNorm");
340 return (
PIX *)ERROR_PTR(
"pixs not defined", procName, NULL);
341 d = pixGetDepth(pixs);
342 if (d != 8 && d != 32)
343 return (
PIX *)ERROR_PTR(
"pixs not 8 or 32 bpp", procName, NULL);
344 if (sx < 4 || sy < 4)
345 return (
PIX *)ERROR_PTR(
"sx and sy must be >= 4", procName, NULL);
346 if (mincount > sx * sy) {
347 L_WARNING(
"mincount too large for tile size\n", procName);
348 mincount = (sx * sy) / 3;
357 return (
PIX *)ERROR_PTR(
"pixim all foreground", procName, NULL);
365 L_WARNING(
"map not made; return a copy of the source\n", procName);
371 L_WARNING(
"pixmi not made; return a copy of source\n", procName);
382 pixmr = pixmg = pixmb = NULL;
384 mincount, &pixmr, &pixmg, &pixmb);
385 if (!pixmr || !pixmg || !pixmb) {
389 L_WARNING(
"map not made; return a copy of the source\n", procName);
396 if (!pixmri || !pixmgi || !pixmbi) {
397 L_WARNING(
"not all pixm*i are made; return src copy\n", procName);
413 ERROR_PTR(
"pixd not made", procName, NULL);
414 pixCopyResolution(pixd, pixs);
466 PIX *pixm, *pixmi, *pixd;
467 PIX *pixmr, *pixmg, *pixmb, *pixmri, *pixmgi, *pixmbi;
469 PROCNAME(
"pixBackgroundNormMorph");
472 return (
PIX *)ERROR_PTR(
"pixs not defined", procName, NULL);
473 d = pixGetDepth(pixs);
474 if (d != 8 && d != 32)
475 return (
PIX *)ERROR_PTR(
"pixs not 8 or 32 bpp", procName, NULL);
476 if (reduction < 2 || reduction > 16)
477 return (
PIX *)ERROR_PTR(
"reduction must be between 2 and 16",
486 return (
PIX *)ERROR_PTR(
"pixim all foreground", procName, NULL);
493 return (
PIX *)ERROR_PTR(
"pixm not made", procName, NULL);
496 ERROR_PTR(
"pixmi not made", procName, NULL);
499 reduction, reduction);
504 pixmr = pixmg = pixmb = NULL;
506 &pixmr, &pixmg, &pixmb);
507 if (!pixmr || !pixmg || !pixmb) {
511 return (
PIX *)ERROR_PTR(
"not all pixm*", procName, NULL);
517 if (!pixmri || !pixmgi || !pixmbi)
518 ERROR_PTR(
"not all pixm*i are made", procName, NULL);
521 reduction, reduction);
532 ERROR_PTR(
"pixd not made", procName, NULL);
533 pixCopyResolution(pixd, pixs);
584 PROCNAME(
"pixBackgroundNormGrayArray");
587 return ERROR_INT(
"&pixd not defined", procName, 1);
589 if (!pixs || pixGetDepth(pixs) != 8)
590 return ERROR_INT(
"pixs not defined or not 8 bpp", procName, 1);
591 if (pixGetColormap(pixs))
592 return ERROR_INT(
"pixs is colormapped", procName, 1);
593 if (pixim && pixGetDepth(pixim) != 1)
594 return ERROR_INT(
"pixim not 1 bpp", procName, 1);
595 if (sx < 4 || sy < 4)
596 return ERROR_INT(
"sx and sy must be >= 4", procName, 1);
597 if (mincount > sx * sy) {
598 L_WARNING(
"mincount too large for tile size\n", procName);
599 mincount = (sx * sy) / 3;
608 return ERROR_INT(
"pixim all foreground", procName, 1);
613 return ERROR_INT(
"pixm not made", procName, 1);
615 pixCopyResolution(*ppixd, pixs);
662 PIX *pixmr, *pixmg, *pixmb;
664 PROCNAME(
"pixBackgroundNormRGBArrays");
666 if (!ppixr || !ppixg || !ppixb)
667 return ERROR_INT(
"&pixr, &pixg, &pixb not all defined", procName, 1);
668 *ppixr = *ppixg = *ppixb = NULL;
670 return ERROR_INT(
"pixs not defined", procName, 1);
671 if (pixGetDepth(pixs) != 32)
672 return ERROR_INT(
"pixs not 32 bpp", procName, 1);
673 if (pixim && pixGetDepth(pixim) != 1)
674 return ERROR_INT(
"pixim not 1 bpp", procName, 1);
675 if (sx < 4 || sy < 4)
676 return ERROR_INT(
"sx and sy must be >= 4", procName, 1);
677 if (mincount > sx * sy) {
678 L_WARNING(
"mincount too large for tile size\n", procName);
679 mincount = (sx * sy) / 3;
688 return ERROR_INT(
"pixim all foreground", procName, 1);
692 &pixmr, &pixmg, &pixmb);
693 if (!pixmr || !pixmg || !pixmb) {
697 return ERROR_INT(
"not all pixm* made", procName, 1);
740 PROCNAME(
"pixBackgroundNormGrayArrayMorph");
743 return ERROR_INT(
"&pixd not defined", procName, 1);
746 return ERROR_INT(
"pixs not defined", procName, 1);
747 if (pixGetDepth(pixs) != 8)
748 return ERROR_INT(
"pixs not 8 bpp", procName, 1);
749 if (pixim && pixGetDepth(pixim) != 1)
750 return ERROR_INT(
"pixim not 1 bpp", procName, 1);
751 if (reduction < 2 || reduction > 16)
752 return ERROR_INT(
"reduction must be between 2 and 16", procName, 1);
760 return ERROR_INT(
"pixim all foreground", procName, 1);
765 return ERROR_INT(
"pixm not made", procName, 1);
767 pixCopyResolution(*ppixd, pixs);
805 PIX *pixmr, *pixmg, *pixmb;
807 PROCNAME(
"pixBackgroundNormRGBArraysMorph");
809 if (!ppixr || !ppixg || !ppixb)
810 return ERROR_INT(
"&pixr, &pixg, &pixb not all defined", procName, 1);
811 *ppixr = *ppixg = *ppixb = NULL;
813 return ERROR_INT(
"pixs not defined", procName, 1);
814 if (pixGetDepth(pixs) != 32)
815 return ERROR_INT(
"pixs not 32 bpp", procName, 1);
816 if (pixim && pixGetDepth(pixim) != 1)
817 return ERROR_INT(
"pixim not 1 bpp", procName, 1);
818 if (reduction < 2 || reduction > 16)
819 return ERROR_INT(
"reduction must be between 2 and 16", procName, 1);
827 return ERROR_INT(
"pixim all foreground", procName, 1);
831 &pixmr, &pixmg, &pixmb);
832 if (!pixmr || !pixmg || !pixmb) {
836 return ERROR_INT(
"not all pixm* made", procName, 1);
880 l_int32 w, h, wd, hd, wim, him, wpls, wplim, wpld, wplf;
881 l_int32 xim, yim, delx, nx, ny, i, j, k, m;
882 l_int32 count, sum, val8;
883 l_int32 empty, fgpixels;
884 l_uint32 *datas, *dataim, *datad, *dataf, *lines, *lineim, *lined, *linef;
885 l_float32 scalex, scaley;
886 PIX *pixd, *piximi, *pixb, *pixf, *pixims;
888 PROCNAME(
"pixGetBackgroundGrayMap");
891 return ERROR_INT(
"&pixd not defined", procName, 1);
893 if (!pixs || pixGetDepth(pixs) != 8)
894 return ERROR_INT(
"pixs not defined or not 8 bpp", procName, 1);
895 if (pixGetColormap(pixs))
896 return ERROR_INT(
"pixs is colormapped", procName, 1);
897 if (pixim && pixGetDepth(pixim) != 1)
898 return ERROR_INT(
"pixim not 1 bpp", procName, 1);
899 if (sx < 4 || sy < 4)
900 return ERROR_INT(
"sx and sy must be >= 4", procName, 1);
901 if (mincount > sx * sy) {
902 L_WARNING(
"mincount too large for tile size\n", procName);
903 mincount = (sx * sy) / 3;
914 return ERROR_INT(
"pixim all fg; no background", procName, 1);
927 return ERROR_INT(
"pixf not made", procName, 1);
932 w = pixGetWidth(pixs);
933 h = pixGetHeight(pixs);
934 wd = (w + sx - 1) / sx;
935 hd = (h + sy - 1) / sy;
943 wpls = pixGetWpl(pixs);
945 wpld = pixGetWpl(pixd);
947 wplf = pixGetWpl(pixf);
949 for (i = 0; i < ny; i++) {
950 lines = datas + sy * i * wpls;
951 linef = dataf + sy * i * wplf;
952 lined = datad + i * wpld;
953 for (j = 0; j < nx; j++) {
957 for (k = 0; k < sy; k++) {
958 for (m = 0; m < sx; m++) {
965 if (count >= mincount) {
984 if (pixim && fgpixels) {
985 wim = pixGetWidth(pixim);
986 him = pixGetHeight(pixim);
988 wplim = pixGetWpl(pixim);
989 for (i = 0; i < ny; i++) {
990 yim = i * sy + sy / 2;
993 lineim = dataim + yim * wplim;
994 for (j = 0; j < nx; j++) {
995 xim = j * sx + sx / 2;
1007 L_WARNING(
"can't make the map\n", procName);
1016 if (pixim && fgpixels) {
1017 scalex = 1. / (l_float32)sx;
1018 scaley = 1. / (l_float32)sy;
1025 pixCopyResolution(*ppixd, pixs);
1065 l_int32 w, h, wm, hm, wim, him, wpls, wplim, wplf;
1066 l_int32 xim, yim, delx, nx, ny, i, j, k, m;
1067 l_int32 count, rsum, gsum, bsum, rval, gval, bval;
1068 l_int32 empty, fgpixels;
1070 l_uint32 *datas, *dataim, *dataf, *lines, *lineim, *linef;
1071 l_float32 scalex, scaley;
1072 PIX *piximi, *pixgc, *pixb, *pixf, *pixims;
1073 PIX *pixmr, *pixmg, *pixmb;
1075 PROCNAME(
"pixGetBackgroundRGBMap");
1077 if (!ppixmr || !ppixmg || !ppixmb)
1078 return ERROR_INT(
"&pixm* not all defined", procName, 1);
1079 *ppixmr = *ppixmg = *ppixmb = NULL;
1081 return ERROR_INT(
"pixs not defined", procName, 1);
1082 if (pixGetDepth(pixs) != 32)
1083 return ERROR_INT(
"pixs not 32 bpp", procName, 1);
1084 if (pixim && pixGetDepth(pixim) != 1)
1085 return ERROR_INT(
"pixim not 1 bpp", procName, 1);
1086 if (sx < 4 || sy < 4)
1087 return ERROR_INT(
"sx and sy must be >= 4", procName, 1);
1088 if (mincount > sx * sy) {
1089 L_WARNING(
"mincount too large for tile size\n", procName);
1090 mincount = (sx * sy) / 3;
1100 return ERROR_INT(
"pixim all fg; no background", procName, 1);
1118 w = pixGetWidth(pixs);
1119 h = pixGetHeight(pixs);
1120 wm = (w + sx - 1) / sx;
1121 hm = (h + sy - 1) / sy;
1132 wpls = pixGetWpl(pixs);
1134 wplf = pixGetWpl(pixf);
1136 for (i = 0; i < ny; i++) {
1137 lines = datas + sy * i * wpls;
1138 linef = dataf + sy * i * wplf;
1139 for (j = 0; j < nx; j++) {
1141 rsum = gsum = bsum = 0;
1143 for (k = 0; k < sy; k++) {
1144 for (m = 0; m < sx; m++) {
1146 pixel = *(lines + k * wpls + delx + m);
1147 rsum += (pixel >> 24);
1148 gsum += ((pixel >> 16) & 0xff);
1149 bsum += ((pixel >> 8) & 0xff);
1154 if (count >= mincount) {
1155 rval = rsum / count;
1156 gval = gsum / count;
1157 bval = bsum / count;
1172 wim = pixGetWidth(pixim);
1173 him = pixGetHeight(pixim);
1175 wplim = pixGetWpl(pixim);
1176 for (i = 0; i < ny; i++) {
1177 yim = i * sy + sy / 2;
1180 lineim = dataim + yim * wplim;
1181 for (j = 0; j < nx; j++) {
1182 xim = j * sx + sx / 2;
1201 L_WARNING(
"can't make the maps\n", procName);
1207 if (pixim && fgpixels) {
1208 scalex = 1. / (l_float32)sx;
1209 scaley = 1. / (l_float32)sy;
1220 pixCopyResolution(*ppixmr, pixs);
1221 pixCopyResolution(*ppixmg, pixs);
1222 pixCopyResolution(*ppixmb, pixs);
1245 l_int32 nx, ny, empty, fgpixels;
1247 PIX *pixm, *pix1, *pix2, *pix3, *pixims;
1249 PROCNAME(
"pixGetBackgroundGrayMapMorph");
1252 return ERROR_INT(
"&pixm not defined", procName, 1);
1254 if (!pixs || pixGetDepth(pixs) != 8)
1255 return ERROR_INT(
"pixs not defined or not 8 bpp", procName, 1);
1256 if (pixGetColormap(pixs))
1257 return ERROR_INT(
"pixs is colormapped", procName, 1);
1258 if (pixim && pixGetDepth(pixim) != 1)
1259 return ERROR_INT(
"pixim not 1 bpp", procName, 1);
1267 return ERROR_INT(
"pixim all fg; no background", procName, 1);
1275 scale = 1. / (l_float32)reduction;
1286 pixims =
pixScale(pixim, scale, scale);
1288 pixAnd(pixm, pixm, pix3);
1295 nx = pixGetWidth(pixs) / reduction;
1296 ny = pixGetHeight(pixs) / reduction;
1300 L_WARNING(
"can't make the map\n", procName);
1306 if (pixim && fgpixels)
1311 pixCopyResolution(*ppixm, pixs);
1338 l_int32 nx, ny, empty, fgpixels;
1340 PIX *pixm, *pixmr, *pixmg, *pixmb, *pix1, *pix2, *pix3, *pixims;
1342 PROCNAME(
"pixGetBackgroundRGBMapMorph");
1344 if (!ppixmr || !ppixmg || !ppixmb)
1345 return ERROR_INT(
"&pixm* not all defined", procName, 1);
1346 *ppixmr = *ppixmg = *ppixmb = NULL;
1348 return ERROR_INT(
"pixs not defined", procName, 1);
1349 if (pixGetDepth(pixs) != 32)
1350 return ERROR_INT(
"pixs not 32 bpp", procName, 1);
1351 if (pixim && pixGetDepth(pixim) != 1)
1352 return ERROR_INT(
"pixim not 1 bpp", procName, 1);
1360 return ERROR_INT(
"pixim all fg; no background", procName, 1);
1368 scale = 1. / (l_float32)reduction;
1372 pixims =
pixScale(pixim, scale, scale);
1383 pixmr =
pixAnd(NULL, pixm, pix3);
1394 pixmg =
pixAnd(NULL, pixm, pix3);
1405 pixmb =
pixAnd(NULL, pixm, pix3);
1414 nx = pixGetWidth(pixs) / reduction;
1415 ny = pixGetHeight(pixs) / reduction;
1423 L_WARNING(
"can't make the maps\n", procName);
1430 if (pixim && fgpixels) {
1440 pixCopyResolution(*ppixmr, pixs);
1441 pixCopyResolution(*ppixmg, pixs);
1442 pixCopyResolution(*ppixmb, pixs);
1489 l_int32 w, h, y, nmiss, goodcol, i, j, found, ival, valtest;
1490 l_uint32 val, lastval;
1493 PROCNAME(
"pixFillMapHoles");
1495 if (!pix || pixGetDepth(pix) != 8)
1496 return ERROR_INT(
"pix not defined or not 8 bpp", procName, 1);
1497 if (pixGetColormap(pix))
1498 return ERROR_INT(
"pix is colormapped", procName, 1);
1505 for (j = 0; j < nx; j++) {
1507 for (i = 0; i < ny; i++) {
1509 if (val != valtest) {
1515 if (found == FALSE) {
1521 for (i = y - 1; i >= 0; i--)
1524 for (i = 1; i < h; i++) {
1536 L_WARNING(
"no bg found; no data in any column\n", procName);
1544 for (j = 0; j < w; j++) {
1552 for (j = goodcol - 1; j >= 0; j--)
1555 for (j = goodcol + 1; j < w; j++) {
1594 PROCNAME(
"pixExtendByReplication");
1596 if (!pixs || pixGetDepth(pixs) != 8)
1597 return (
PIX *)ERROR_PTR(
"pixs undefined or not 8 bpp", procName, NULL);
1599 if (addw == 0 && addh == 0)
1603 if ((pixd =
pixCreate(w + addw, h + addh, 8)) == NULL)
1604 return (
PIX *)ERROR_PTR(
"pixd not made", procName, NULL);
1608 for (i = 0; i < h; i++) {
1610 for (j = 0; j < addw; j++)
1616 for (j = 0; j < w + addw; j++) {
1618 for (i = 0; i < addh; i++)
1623 pixCopyResolution(pixd, pixs);
1653 l_int32 empty, i, n, x, y;
1659 PROCNAME(
"pixSmoothConnectedRegions");
1661 if (!pixs || pixGetDepth(pixs) != 8)
1662 return ERROR_INT(
"pixs not defined or not 8 bpp", procName, 1);
1663 if (pixGetColormap(pixs))
1664 return ERROR_INT(
"pixs has colormap", procName, 1);
1666 L_INFO(
"pixm not defined\n", procName);
1669 if (pixGetDepth(pixm) != 1)
1670 return ERROR_INT(
"pixm not 1 bpp", procName, 1);
1673 L_INFO(
"pixm has no fg pixels; nothing to do\n", procName);
1679 for (i = 0; i < n; i++) {
1681 L_WARNING(
"missing pixmc!\n", procName);
1738 pixGetForegroundGrayMap(
PIX *pixs,
1745 l_int32 w, h, d, wd, hd;
1746 l_int32 empty, fgpixels;
1747 PIX *pixd, *piximi, *pixim2, *pixims, *pixs2, *pixb, *pixt1, *pixt2, *pixt3;
1749 PROCNAME(
"pixGetForegroundGrayMap");
1752 return ERROR_INT(
"&pixd not defined", procName, 1);
1755 return ERROR_INT(
"pixs not defined", procName, 1);
1758 return ERROR_INT(
"pixs not 8 bpp", procName, 1);
1759 if (pixim && pixGetDepth(pixim) != 1)
1760 return ERROR_INT(
"pixim not 1 bpp", procName, 1);
1761 if (sx < 2 || sy < 2)
1762 return ERROR_INT(
"sx and sy must be >= 2", procName, 1);
1765 wd = (w + sx - 1) / sx;
1766 hd = (h + sy - 1) / sy;
1786 if (pixim && fgpixels) {
1855 l_int32 w, h, wplsm, wpld, i, j;
1857 l_uint32 *datasm, *datad, *linesm, *lined;
1860 PROCNAME(
"pixGetInvBackgroundMap");
1862 if (!pixs || pixGetDepth(pixs) != 8)
1863 return (
PIX *)ERROR_PTR(
"pixs undefined or not 8 bpp", procName, NULL);
1864 if (pixGetColormap(pixs))
1865 return (
PIX *)ERROR_PTR(
"pixs has colormap", procName, NULL);
1868 return (
PIX *)ERROR_PTR(
"w and h must be >= 5", procName, NULL);
1873 wplsm = pixGetWpl(pixsm);
1878 wpld = pixGetWpl(pixd);
1879 for (i = 0; i < h; i++) {
1880 linesm = datasm + i * wplsm;
1881 lined = datad + i * wpld;
1882 for (j = 0; j < w; j++) {
1885 val16 = (256 * bgval) / val;
1887 L_WARNING(
"smoothed bg has 0 pixel!\n", procName);
1895 pixCopyResolution(pixd, pixs);
1918 l_int32 w, h, wm, hm, wpls, wpld, i, j, k, m, xoff, yoff;
1921 l_uint32 *datas, *datad, *lines, *lined, *flines, *flined;
1924 PROCNAME(
"pixApplyInvBackgroundGrayMap");
1926 if (!pixs || pixGetDepth(pixs) != 8)
1927 return (
PIX *)ERROR_PTR(
"pixs undefined or not 8 bpp", procName, NULL);
1928 if (pixGetColormap(pixs))
1929 return (
PIX *)ERROR_PTR(
"pixs has colormap", procName, NULL);
1930 if (!pixm || pixGetDepth(pixm) != 16)
1931 return (
PIX *)ERROR_PTR(
"pixm undefined or not 16 bpp", procName, NULL);
1932 if (sx == 0 || sy == 0)
1933 return (
PIX *)ERROR_PTR(
"invalid sx and/or sy", procName, NULL);
1936 wpls = pixGetWpl(pixs);
1940 return (
PIX *)ERROR_PTR(
"pixd not made", procName, NULL);
1942 wpld = pixGetWpl(pixd);
1943 for (i = 0; i < hm; i++) {
1944 lines = datas + sy * i * wpls;
1945 lined = datad + sy * i * wpld;
1947 for (j = 0; j < wm; j++) {
1950 for (k = 0; k < sy && yoff + k < h; k++) {
1951 flines = lines + k * wpls;
1952 flined = lined + k * wpld;
1953 for (m = 0; m < sx && xoff + m < w; m++) {
1955 vald = (vals * val16) / 256;
1956 vald = L_MIN(vald, 255);
1986 l_int32 w, h, wm, hm, wpls, wpld, i, j, k, m, xoff, yoff;
1987 l_int32 rvald, gvald, bvald;
1989 l_uint32 rval16, gval16, bval16;
1990 l_uint32 *datas, *datad, *lines, *lined, *flines, *flined;
1993 PROCNAME(
"pixApplyInvBackgroundRGBMap");
1996 return (
PIX *)ERROR_PTR(
"pixs not defined", procName, NULL);
1997 if (pixGetDepth(pixs) != 32)
1998 return (
PIX *)ERROR_PTR(
"pixs not 32 bpp", procName, NULL);
1999 if (!pixmr || !pixmg || !pixmb)
2000 return (
PIX *)ERROR_PTR(
"pix maps not all defined", procName, NULL);
2001 if (pixGetDepth(pixmr) != 16 || pixGetDepth(pixmg) != 16 ||
2002 pixGetDepth(pixmb) != 16)
2003 return (
PIX *)ERROR_PTR(
"pix maps not all 16 bpp", procName, NULL);
2004 if (sx == 0 || sy == 0)
2005 return (
PIX *)ERROR_PTR(
"invalid sx and/or sy", procName, NULL);
2008 wpls = pixGetWpl(pixs);
2009 w = pixGetWidth(pixs);
2010 h = pixGetHeight(pixs);
2011 wm = pixGetWidth(pixmr);
2012 hm = pixGetHeight(pixmr);
2014 return (
PIX *)ERROR_PTR(
"pixd not made", procName, NULL);
2016 wpld = pixGetWpl(pixd);
2017 for (i = 0; i < hm; i++) {
2018 lines = datas + sy * i * wpls;
2019 lined = datad + sy * i * wpld;
2021 for (j = 0; j < wm; j++) {
2026 for (k = 0; k < sy && yoff + k < h; k++) {
2027 flines = lines + k * wpls;
2028 flined = lined + k * wpld;
2029 for (m = 0; m < sx && xoff + m < w; m++) {
2030 vals = *(flines + xoff + m);
2031 rvald = ((vals >> 24) * rval16) / 256;
2032 rvald = L_MIN(rvald, 255);
2033 gvald = (((vals >> 16) & 0xff) * gval16) / 256;
2034 gvald = L_MIN(gvald, 255);
2035 bvald = (((vals >> 8) & 0xff) * bval16) / 256;
2036 bvald = L_MIN(bvald, 255);
2081 l_int32 i, j, w, h, d, wpls, wplg, wpld, vals, valg, vald;
2083 l_uint32 *datas, *datag, *datad, *lines, *lineg, *lined;
2087 PROCNAME(
"pixApplyVariableGrayMap");
2090 return (
PIX *)ERROR_PTR(
"pixs not defined", procName, NULL);
2092 return (
PIX *)ERROR_PTR(
"pixg not defined", procName, NULL);
2094 return (
PIX *)ERROR_PTR(
"pix sizes not equal", procName, NULL);
2097 return (
PIX *)ERROR_PTR(
"depth not 8 bpp", procName, NULL);
2107 if (w * h > 100000) {
2108 lut = (l_uint8 *)LEPT_CALLOC(0x10000,
sizeof(l_uint8));
2109 for (i = 0; i < 256; i++) {
2110 for (j = 0; j < 256; j++) {
2111 fval = (l_float32)(i * target) / (j + 0.5);
2112 lut[(i << 8) + j] = L_MIN(255, (l_int32)(fval + 0.5));
2117 if ((pixd =
pixCreate(w, h, 8)) == NULL) {
2119 return (
PIX *)ERROR_PTR(
"pixd not made", procName, NULL);
2121 pixCopyResolution(pixd, pixs);
2123 wpld = pixGetWpl(pixd);
2125 wpls = pixGetWpl(pixs);
2127 wplg = pixGetWpl(pixg);
2128 for (i = 0; i < h; i++) {
2129 lines = datas + i * wpls;
2130 lineg = datag + i * wplg;
2131 lined = datad + i * wpld;
2133 for (j = 0; j < w; j++) {
2136 vald = lut[(vals << 8) + valg];
2141 for (j = 0; j < w; j++) {
2144 fval = (l_float32)(vals * target) / (valg + 0.5);
2145 vald = L_MIN(255, (l_int32)(fval + 0.5));
2201 l_int32 w, h, d, i, j, ncolors, rv, gv, bv, wpl;
2202 l_int32 *rarray, *garray, *barray;
2203 l_uint32 *data, *line;
2204 NUMA *nar, *nag, *nab;
2207 PROCNAME(
"pixGlobalNormRGB");
2210 return (
PIX *)ERROR_PTR(
"pixs not defined", procName, NULL);
2211 cmap = pixGetColormap(pixs);
2213 if (!cmap && d != 32)
2214 return (
PIX *)ERROR_PTR(
"pixs not cmapped or 32 bpp", procName, NULL);
2216 L_WARNING(
"mapval must be > 0; setting to 255\n", procName);
2221 if ((pixd =
pixCopy(pixd, pixs)) == NULL)
2222 return (
PIX *)ERROR_PTR(
"pixd not made", procName, NULL);
2226 nar =
numaGammaTRC(1.0, 0, L_MAX(1, 255 * rval / mapval));
2227 nag =
numaGammaTRC(1.0, 0, L_MAX(1, 255 * gval / mapval));
2228 nab =
numaGammaTRC(1.0, 0, L_MAX(1, 255 * bval / mapval));
2234 if (!nar || !nag || !nab || !rarray || !garray || !barray) {
2235 L_ERROR(
"allocation failure in arrays\n", procName);
2236 goto cleanup_arrays;
2241 for (i = 0; i < ncolors; i++) {
2248 wpl = pixGetWpl(pixd);
2249 for (i = 0; i < h; i++) {
2250 line = data + i * wpl;
2251 for (j = 0; j < w; j++) {
2312 l_float32 rankrval, rankgval, rankbval;
2313 l_float32 rfract, gfract, bfract, maxfract;
2315 PROCNAME(
"pixGlobalNormNoSatRGB");
2318 return (
PIX *)ERROR_PTR(
"pixs not defined", procName, NULL);
2319 if (pixGetDepth(pixs) != 32)
2320 return (
PIX *)ERROR_PTR(
"pixs not 32 bpp", procName, NULL);
2322 return (
PIX *)ERROR_PTR(
"sampling factor < 1", procName, NULL);
2323 if (rank < 0.0 || rank > 1.0)
2324 return (
PIX *)ERROR_PTR(
"rank not in [0.0 ... 1.0]", procName, NULL);
2325 if (rval <= 0 || gval <= 0 || bval <= 0)
2326 return (
PIX *)ERROR_PTR(
"invalid estim. color values", procName, NULL);
2339 &rankgval, &rankbval);
2340 rfract = rankrval / (l_float32)rval;
2341 gfract = rankgval / (l_float32)gval;
2342 bfract = rankbval / (l_float32)bval;
2343 maxfract = L_MAX(rfract, gfract);
2344 maxfract = L_MAX(maxfract, bfract);
2346 lept_stderr(
"rankrval = %7.2f, rankgval = %7.2f, rankbval = %7.2f\n",
2347 rankrval, rankgval, rankbval);
2348 lept_stderr(
"rfract = %7.4f, gfract = %7.4f, bfract = %7.4f\n",
2349 rfract, gfract, bfract);
2352 mapval = (l_int32)(255. / maxfract);
2413 l_int32 targetthresh,
2418 PIX *pixe, *pixet, *pixsd, *pixg1, *pixg2, *pixth;
2420 PROCNAME(
"pixThresholdSpreadNorm");
2422 if (ppixth) *ppixth = NULL;
2423 if (ppixb) *ppixb = NULL;
2424 if (ppixd) *ppixd = NULL;
2425 if (!pixs || pixGetDepth(pixs) != 8)
2426 return ERROR_INT(
"pixs not defined or not 8 bpp", procName, 1);
2427 if (pixGetColormap(pixs))
2428 return ERROR_INT(
"pixs is colormapped", procName, 1);
2429 if (!ppixth && !ppixb && !ppixd)
2430 return ERROR_INT(
"no output requested", procName, 1);
2432 return ERROR_INT(
"invalid filter type", procName, 1);
2453 pixth =
pixGammaTRC(NULL, pixg2, gamma, minval, maxval);
2518 l_float32 scalex, scaley;
2519 PIX *pixt, *pixsd, *pixmin, *pixbg, *pixbgi, *pixd;
2521 PROCNAME(
"pixBackgroundNormFlex");
2523 if (!pixs || pixGetDepth(pixs) != 8)
2524 return (
PIX *)ERROR_PTR(
"pixs undefined or not 8 bpp", procName, NULL);
2525 if (pixGetColormap(pixs))
2526 return (
PIX *)ERROR_PTR(
"pixs is colormapped", procName, NULL);
2527 if (sx < 3 || sy < 3)
2528 return (
PIX *)ERROR_PTR(
"sx and/or sy less than 3", procName, NULL);
2529 if (sx > 10 || sy > 10)
2530 return (
PIX *)ERROR_PTR(
"sx and/or sy exceed 10", procName, NULL);
2531 if (smoothx < 1 || smoothy < 1)
2532 return (
PIX *)ERROR_PTR(
"smooth params less than 1", procName, NULL);
2533 if (smoothx > 3 || smoothy > 3)
2534 return (
PIX *)ERROR_PTR(
"smooth params exceed 3", procName, NULL);
2537 scalex = 1. / (l_float32)sx;
2538 scaley = 1. / (l_float32)sy;
2614 PIX *pixmin, *pixmax;
2616 PROCNAME(
"pixContrastNorm");
2618 if (!pixs || pixGetDepth(pixs) != 8)
2619 return (
PIX *)ERROR_PTR(
"pixs undefined or not 8 bpp", procName, pixd);
2620 if (pixd && pixd != pixs)
2621 return (
PIX *)ERROR_PTR(
"pixd not null or == pixs", procName, pixd);
2622 if (pixGetColormap(pixs))
2623 return (
PIX *)ERROR_PTR(
"pixs is colormapped", procName, pixd);
2624 if (sx < 5 || sy < 5)
2625 return (
PIX *)ERROR_PTR(
"sx and/or sy less than 5", procName, pixd);
2626 if (smoothx < 0 || smoothy < 0)
2627 return (
PIX *)ERROR_PTR(
"smooth params less than 0", procName, pixd);
2628 if (smoothx > 8 || smoothy > 8)
2629 return (
PIX *)ERROR_PTR(
"smooth params exceed 8", procName, pixd);
2633 pixMinMaxTiles(pixs, sx, sy, mindiff, smoothx, smoothy, &pixmin, &pixmax);
2676 PIX *pixmin1, *pixmax1, *pixmin2, *pixmax2;
2678 PROCNAME(
"pixMinMaxTiles");
2680 if (ppixmin) *ppixmin = NULL;
2681 if (ppixmax) *ppixmax = NULL;
2682 if (!ppixmin || !ppixmax)
2683 return ERROR_INT(
"&pixmin or &pixmax undefined", procName, 1);
2684 if (!pixs || pixGetDepth(pixs) != 8)
2685 return ERROR_INT(
"pixs undefined or not 8 bpp", procName, 1);
2686 if (pixGetColormap(pixs))
2687 return ERROR_INT(
"pixs is colormapped", procName, 1);
2688 if (sx < 5 || sy < 5)
2689 return ERROR_INT(
"sx and/or sy less than 3", procName, 1);
2690 if (smoothx < 0 || smoothy < 0)
2691 return ERROR_INT(
"smooth params less than 0", procName, 1);
2692 if (smoothx > 5 || smoothy > 5)
2693 return ERROR_INT(
"smooth params exceed 5", procName, 1);
2717 if (smoothx > 0 || smoothy > 0) {
2718 smoothx = L_MIN(smoothx, (w - 1) / 2);
2719 smoothy = L_MIN(smoothy, (h - 1) / 2);
2727 pixCopyResolution(*ppixmin, pixs);
2728 pixCopyResolution(*ppixmax, pixs);
2761 l_int32 i, j, w, h, d, wpl, val1, val2, found;
2762 l_uint32 *data1, *data2, *line1, *line2;
2764 PROCNAME(
"pixSetLowContrast");
2766 if (!pixs1 || !pixs2)
2767 return ERROR_INT(
"pixs1 and pixs2 not both defined", procName, 1);
2769 return ERROR_INT(
"pixs1 and pixs2 not equal size", procName, 1);
2772 return ERROR_INT(
"depth not 8 bpp", procName, 1);
2773 if (mindiff > 254)
return 0;
2777 wpl = pixGetWpl(pixs1);
2779 for (i = 0; i < h; i++) {
2780 line1 = data1 + i * wpl;
2781 line2 = data2 + i * wpl;
2782 for (j = 0; j < w; j++) {
2785 if (L_ABS(val1 - val2) >= mindiff) {
2793 L_WARNING(
"no pixel pair diffs as large as mindiff\n", procName);
2799 for (i = 0; i < h; i++) {
2800 line1 = data1 + i * wpl;
2801 line2 = data2 + i * wpl;
2802 for (j = 0; j < w; j++) {
2805 if (L_ABS(val1 - val2) < mindiff) {
2847 l_int32 i, j, k, m, w, h, wt, ht, wpl, wplt, xoff, yoff;
2848 l_int32 minval, maxval, val, sval;
2851 l_uint32 *data, *datamin, *datamax, *line, *tline, *linemin, *linemax;
2853 PROCNAME(
"pixLinearTRCTiled");
2855 if (!pixs || pixGetDepth(pixs) != 8)
2856 return (
PIX *)ERROR_PTR(
"pixs undefined or not 8 bpp", procName, pixd);
2857 if (pixd && pixd != pixs)
2858 return (
PIX *)ERROR_PTR(
"pixd not null or == pixs", procName, pixd);
2859 if (pixGetColormap(pixs))
2860 return (
PIX *)ERROR_PTR(
"pixs is colormapped", procName, pixd);
2861 if (!pixmin || !pixmax)
2862 return (
PIX *)ERROR_PTR(
"pixmin & pixmax not defined", procName, pixd);
2863 if (sx < 5 || sy < 5)
2864 return (
PIX *)ERROR_PTR(
"sx and/or sy less than 5", procName, pixd);
2866 iaa = (l_int32 **)LEPT_CALLOC(256,
sizeof(l_int32 *));
2867 if ((pixd =
pixCopy(pixd, pixs)) == NULL) {
2869 return (
PIX *)ERROR_PTR(
"pixd not made", procName, NULL);
2874 wpl = pixGetWpl(pixd);
2877 wplt = pixGetWpl(pixmin);
2879 for (i = 0; i < ht; i++) {
2880 line = data + sy * i * wpl;
2881 linemin = datamin + i * wplt;
2882 linemax = datamax + i * wplt;
2884 for (j = 0; j < wt; j++) {
2888 if (maxval == minval) {
2889 L_ERROR(
"shouldn't happen! i,j = %d,%d, minval = %d\n",
2890 procName, i, j, minval);
2894 L_ERROR(
"failure to make ia for j = %d!\n", procName, j);
2897 for (k = 0; k < sy && yoff + k < h; k++) {
2898 tline = line + k * wpl;
2899 for (m = 0; m < sx && xoff + m < w; m++) {
2901 sval = val - minval;
2902 sval = L_MAX(0, sval);
2909 for (i = 0; i < 256; i++)
2933 PROCNAME(
"iaaGetLinearTRC");
2936 return (l_int32 *)ERROR_PTR(
"iaa not defined", procName, NULL);
2938 if (iaa[diff] != NULL)
2941 ia = (l_int32 *)LEPT_CALLOC(256,
sizeof(l_int32));
2944 for (i = 0; i < 256; i++)
2948 factor = 255. / (l_float32)diff;
2949 for (i = 0; i < diff + 1; i++)
2950 ia[i] = (l_int32)(factor * i + 0.5);
2951 for (i = diff + 1; i < 256; i++)
l_ok pixBackgroundNormGrayArray(PIX *pixs, PIX *pixim, l_int32 sx, l_int32 sy, l_int32 thresh, l_int32 mincount, l_int32 bgval, l_int32 smoothx, l_int32 smoothy, PIX **ppixd)
pixBackgroundNormGrayArray()
l_ok pixGetBackgroundGrayMap(PIX *pixs, PIX *pixim, l_int32 sx, l_int32 sy, l_int32 thresh, l_int32 mincount, PIX **ppixd)
pixGetBackgroundGrayMap()
PIX * pixApplyInvBackgroundGrayMap(PIX *pixs, PIX *pixm, l_int32 sx, l_int32 sy)
pixApplyInvBackgroundGrayMap()
static l_int32 * iaaGetLinearTRC(l_int32 **iaa, l_int32 diff)
iaaGetLinearTRC()
l_ok pixGetBackgroundGrayMapMorph(PIX *pixs, PIX *pixim, l_int32 reduction, l_int32 size, PIX **ppixm)
pixGetBackgroundGrayMapMorph()
l_ok pixSmoothConnectedRegions(PIX *pixs, PIX *pixm, l_int32 factor)
pixSmoothConnectedRegions()
PIX * pixSeedspread(PIX *pixs, l_int32 connectivity)
pixSeedspread()
PIX * pixCreateTemplate(const PIX *pixs)
pixCreateTemplate()
PIX * pixApplyVariableGrayMap(PIX *pixs, PIX *pixg, l_int32 target)
pixApplyVariableGrayMap()
PIX * pixScaleRGBToGrayFast(PIX *pixs, l_int32 factor, l_int32 color)
pixScaleRGBToGrayFast()
l_ok numaAddNumber(NUMA *na, l_float32 val)
numaAddNumber()
PIX * pixScaleGrayMinMax(PIX *pixs, l_int32 xfact, l_int32 yfact, l_int32 type)
pixScaleGrayMinMax()
static const l_int32 DefaultMinCount
NUMA * numaGammaTRC(l_float32 gamma, l_int32 minval, l_int32 maxval)
numaGammaTRC()
PIX * pixCloseGray(PIX *pixs, l_int32 hsize, l_int32 vsize)
pixCloseGray()
l_ok pixRasterop(PIX *pixd, l_int32 dx, l_int32 dy, l_int32 dw, l_int32 dh, l_int32 op, PIX *pixs, l_int32 sx, l_int32 sy)
pixRasterop()
PIX * pixCopy(PIX *pixd, const PIX *pixs)
pixCopy()
PIX * pixConvertTo8(PIX *pixs, l_int32 cmapflag)
pixConvertTo8()
void lept_stderr(const char *fmt,...)
lept_stderr()
l_ok pixLocalExtrema(PIX *pixs, l_int32 maxmin, l_int32 minmax, PIX **ppixmin, PIX **ppixmax)
pixLocalExtrema()
PIX * pixCreate(l_int32 width, l_int32 height, l_int32 depth)
pixCreate()
static const l_int32 DefaultXSmoothSize
PIX * pixInvert(PIX *pixd, PIX *pixs)
pixInvert()
NUMA * numaCreate(l_int32 n)
numaCreate()
void boxaDestroy(BOXA **pboxa)
boxaDestroy()
l_uint32 * pixGetData(PIX *pix)
pixGetData()
PIX * pixThresholdToBinary(PIX *pixs, l_int32 thresh)
pixThresholdToBinary()
PIX * pixScaleBySampling(PIX *pixs, l_float32 scalex, l_float32 scaley)
pixScaleBySampling()
#define GET_DATA_BIT(pdata, n)
static const l_int32 DefaultYSmoothSize
static const l_int32 DefaultTileWidth
l_ok pixBackgroundNormGrayArrayMorph(PIX *pixs, PIX *pixim, l_int32 reduction, l_int32 size, l_int32 bgval, PIX **ppixd)
pixBackgroundNormGrayArrayMorph()
l_ok pixPaintThroughMask(PIX *pixd, PIX *pixm, l_int32 x, l_int32 y, l_uint32 val)
pixPaintThroughMask()
PIX * pixTwoSidedEdgeFilter(PIX *pixs, l_int32 orientflag)
pixTwoSidedEdgeFilter()
l_ok pixCombineMasked(PIX *pixd, PIX *pixs, PIX *pixm)
pixCombineMasked()
l_int32 * numaGetIArray(NUMA *na)
numaGetIArray()
PIX * pixConvertRGBToGrayFast(PIX *pixs)
pixConvertRGBToGrayFast()
BOXA * pixConnComp(PIX *pixs, PIXA **ppixa, l_int32 connectivity)
pixConnComp()
static l_int32 pixMinMaxTiles(PIX *pixs, l_int32 sx, l_int32 sy, l_int32 mindiff, l_int32 smoothx, l_int32 smoothy, PIX **ppixmin, PIX **ppixmax)
pixMinMaxTiles()
l_ok numaGetIValue(NUMA *na, l_int32 index, l_int32 *pival)
numaGetIValue()
l_ok pixGetAverageMasked(PIX *pixs, PIX *pixm, l_int32 x, l_int32 y, l_int32 factor, l_int32 type, l_float32 *pval)
pixGetAverageMasked()
static const l_int32 DefaultTileHeight
PIX * pixBackgroundNormFlex(PIX *pixs, l_int32 sx, l_int32 sy, l_int32 smoothx, l_int32 smoothy, l_int32 delta)
pixBackgroundNormFlex()
l_ok pixClearAll(PIX *pix)
pixClearAll()
static l_int32 pixSetLowContrast(PIX *pixs1, PIX *pixs2, l_int32 mindiff)
pixSetLowContrast()
PIX * pixGetInvBackgroundMap(PIX *pixs, l_int32 bgval, l_int32 smoothx, l_int32 smoothy)
pixGetInvBackgroundMap()
PIX * pixCleanBackgroundToWhite(PIX *pixs, PIX *pixim, PIX *pixg, l_float32 gamma, l_int32 blackval, l_int32 whiteval)
pixCleanBackgroundToWhite()
l_ok boxaGetBoxGeometry(BOXA *boxa, l_int32 index, l_int32 *px, l_int32 *py, l_int32 *pw, l_int32 *ph)
boxaGetBoxGeometry()
PIX * pixAnd(PIX *pixd, PIX *pixs1, PIX *pixs2)
pixAnd()
l_ok pixSetPixel(PIX *pix, l_int32 x, l_int32 y, l_uint32 val)
pixSetPixel()
l_ok pixcmapGetColor(PIXCMAP *cmap, l_int32 index, l_int32 *prval, l_int32 *pgval, l_int32 *pbval)
pixcmapGetColor()
PIX * pixMorphSequence(PIX *pixs, const char *sequence, l_int32 dispsep)
pixMorphSequence()
PIX * pixContrastNorm(PIX *pixd, PIX *pixs, l_int32 sx, l_int32 sy, l_int32 mindiff, l_int32 smoothx, l_int32 smoothy)
pixContrastNorm()
#define SET_DATA_BYTE(pdata, n, val)
l_ok pixBackgroundNormRGBArrays(PIX *pixs, PIX *pixim, PIX *pixg, l_int32 sx, l_int32 sy, l_int32 thresh, l_int32 mincount, l_int32 bgval, l_int32 smoothx, l_int32 smoothy, PIX **ppixr, PIX **ppixg, PIX **ppixb)
pixBackgroundNormRGBArrays()
#define GET_DATA_BYTE(pdata, n)
PIX * pixApplyInvBackgroundRGBMap(PIX *pixs, PIX *pixmr, PIX *pixmg, PIX *pixmb, l_int32 sx, l_int32 sy)
pixApplyInvBackgroundRGBMap()
PIX * pixExtendByReplication(PIX *pixs, l_int32 addw, l_int32 addh)
pixExtendByReplication()
PIX * pixClone(PIX *pixs)
pixClone()
void pixDestroy(PIX **ppix)
pixDestroy()
l_ok pixcmapResetColor(PIXCMAP *cmap, l_int32 index, l_int32 rval, l_int32 gval, l_int32 bval)
pixcmapResetColor()
void numaDestroy(NUMA **pna)
numaDestroy()
l_ok pixGetPixel(PIX *pix, l_int32 x, l_int32 y, l_uint32 *pval)
pixGetPixel()
l_ok pixGetDimensions(const PIX *pix, l_int32 *pw, l_int32 *ph, l_int32 *pd)
pixGetDimensions()
PIX * pixReduceBinary2(PIX *pixs, l_uint8 *intab)
pixReduceBinary2()
PIX * pixExpandReplicate(PIX *pixs, l_int32 factor)
pixExpandReplicate()
static PIX * pixLinearTRCTiled(PIX *pixd, PIX *pixs, l_int32 sx, l_int32 sy, PIX *pixmin, PIX *pixmax)
pixLinearTRCTiled()
l_ok pixGetBackgroundRGBMap(PIX *pixs, PIX *pixim, PIX *pixg, l_int32 sx, l_int32 sy, l_int32 thresh, l_int32 mincount, PIX **ppixmr, PIX **ppixmg, PIX **ppixmb)
pixGetBackgroundRGBMap()
l_ok pixBackgroundNormRGBArraysMorph(PIX *pixs, PIX *pixim, l_int32 reduction, l_int32 size, l_int32 bgval, PIX **ppixr, PIX **ppixg, PIX **ppixb)
pixBackgroundNormRGBArraysMorph()
PIX * pixaGetPix(PIXA *pixa, l_int32 index, l_int32 accesstype)
pixaGetPix()
PIX * pixBackgroundNorm(PIX *pixs, PIX *pixim, PIX *pixg, l_int32 sx, l_int32 sy, l_int32 thresh, l_int32 mincount, l_int32 bgval, l_int32 smoothx, l_int32 smoothy)
pixBackgroundNorm()
PIX * pixBackgroundNormSimple(PIX *pixs, PIX *pixim, PIX *pixg)
pixBackgroundNormSimple()
PIX * pixSobelEdgeFilter(PIX *pixs, l_int32 orientflag)
pixSobelEdgeFilter()
l_ok pixZero(PIX *pix, l_int32 *pempty)
pixZero()
PIX * pixGammaTRC(PIX *pixd, PIX *pixs, l_float32 gamma, l_int32 minval, l_int32 maxval)
pixGammaTRC()
l_int32 pixcmapGetCount(const PIXCMAP *cmap)
pixcmapGetCount()
PIX * pixBlockconv(PIX *pix, l_int32 wc, l_int32 hc)
pixBlockconv()
PIX * pixBackgroundNormMorph(PIX *pixs, PIX *pixim, l_int32 reduction, l_int32 size, l_int32 bgval)
pixBackgroundNormMorph()
l_int32 boxaGetCount(BOXA *boxa)
boxaGetCount()
static const l_int32 DefaultBgVal
l_ok pixFillMapHoles(PIX *pix, l_int32 nx, l_int32 ny, l_int32 filltype)
pixFillMapHoles()
l_ok composeRGBPixel(l_int32 rval, l_int32 gval, l_int32 bval, l_uint32 *ppixel)
composeRGBPixel()
l_ok pixGetRankValueMaskedRGB(PIX *pixs, PIX *pixm, l_int32 x, l_int32 y, l_int32 factor, l_float32 rank, l_float32 *prval, l_float32 *pgval, l_float32 *pbval)
pixGetRankValueMaskedRGB()
l_ok pixGetBackgroundRGBMapMorph(PIX *pixs, PIX *pixim, l_int32 reduction, l_int32 size, PIX **ppixmr, PIX **ppixmg, PIX **ppixmb)
pixGetBackgroundRGBMapMorph()
l_int32 pixSizesEqual(const PIX *pix1, const PIX *pix2)
pixSizesEqual()
PIX * pixScaleSmooth(PIX *pix, l_float32 scalex, l_float32 scaley)
pixScaleSmooth()
PIX * pixVarThresholdToBinary(PIX *pixs, PIX *pixg)
pixVarThresholdToBinary()
PIX * pixGlobalNormRGB(PIX *pixd, PIX *pixs, l_int32 rval, l_int32 gval, l_int32 bval, l_int32 mapval)
pixGlobalNormRGB()
PIX * pixScale(PIX *pixs, l_float32 scalex, l_float32 scaley)
pixScale()
#define SET_DATA_TWO_BYTES(pdata, n, val)
void pixaDestroy(PIXA **ppixa)
pixaDestroy()
void extractRGBValues(l_uint32 pixel, l_int32 *prval, l_int32 *pgval, l_int32 *pbval)
extractRGBValues()
l_ok pixThresholdSpreadNorm(PIX *pixs, l_int32 filtertype, l_int32 edgethresh, l_int32 smoothx, l_int32 smoothy, l_float32 gamma, l_int32 minval, l_int32 maxval, l_int32 targetthresh, PIX **ppixth, PIX **ppixb, PIX **ppixd)
pixThresholdSpreadNorm()
PIX * pixSeedfillGrayBasin(PIX *pixb, PIX *pixm, l_int32 delta, l_int32 connectivity)
pixSeedfillGrayBasin()
PIX * pixGlobalNormNoSatRGB(PIX *pixd, PIX *pixs, l_int32 rval, l_int32 gval, l_int32 bval, l_int32 factor, l_float32 rank)
pixGlobalNormNoSatRGB()
static const l_int32 DefaultFgThreshold
l_ok pixAddConstantGray(PIX *pixs, l_int32 val)
pixAddConstantGray()