113 #include <config_auto.h> 118 #include "allheaders.h" 121 l_int32 searchdir, l_int32 mindist,
122 l_int32 tsize, l_int32 ntiles);
124 #ifndef NO_CONSOLE_IO 125 #define EQUAL_SIZE_WARNING 0 167 l_int32 wd, hd, wm, hm, w, h, d, wpld, wplm;
168 l_int32 i, j, rval, gval, bval;
169 l_uint32 *datad, *datam, *lined, *linem;
171 PROCNAME(
"pixSetMasked");
174 return ERROR_INT(
"pixd not defined", procName, 1);
176 L_WARNING(
"no mask; nothing to do\n", procName);
179 if (pixGetColormap(pixd)) {
184 if (pixGetDepth(pixm) != 1)
185 return ERROR_INT(
"pixm not 1 bpp", procName, 1);
186 d = pixGetDepth(pixd);
198 return ERROR_INT(
"pixd not 1, 2, 4, 8, 16 or 32 bpp", procName, 1);
214 if (d < 32 && val == 0) {
222 if (d < 32 && val == ((1 << d) - 1)) {
232 if (L_ABS(wd - wm) > 7 || L_ABS(hd - hm) > 7)
233 L_WARNING(
"pixd and pixm sizes differ\n", procName);
237 wpld = pixGetWpl(pixd);
238 wplm = pixGetWpl(pixm);
239 for (i = 0; i < h; i++) {
240 lined = datad + i * wpld;
241 linem = datam + i * wplm;
242 for (j = 0; j < w; j++) {
262 return ERROR_INT(
"shouldn't get here", procName, 1);
311 PROCNAME(
"pixSetMaskedGeneral");
314 return ERROR_INT(
"pixd not defined", procName, 1);
318 d = pixGetDepth(pixd);
319 if (d != 8 && d != 16 && d != 32)
320 return ERROR_INT(
"pixd not 8, 16 or 32 bpp", procName, 1);
321 if (pixGetDepth(pixm) != 1)
322 return ERROR_INT(
"pixm not 1 bpp", procName, 1);
326 return ERROR_INT(
"pixmu not made", procName, 1);
335 return ERROR_INT(
"pixc not made", procName, 1);
341 pixAnd(pixmu, pixmu, pixc);
386 l_int32 w, h, d, ws, hs, ds, wm, hm, dm, wmin, hmin;
387 l_int32 wpl, wpls, wplm, i, j, val;
388 l_uint32 *data, *datas, *datam, *line, *lines, *linem;
391 PROCNAME(
"pixCombineMasked");
396 return ERROR_INT(
"pixd not defined", procName, 1);
398 return ERROR_INT(
"pixs not defined", procName, 1);
403 return ERROR_INT(
"pixs and pixd depths differ", procName, 1);
405 return ERROR_INT(
"pixm not 1 bpp", procName, 1);
406 if (d != 1 && d != 8 && d != 32)
407 return ERROR_INT(
"pixd not 1, 8 or 32 bpp", procName, 1);
408 if (pixGetColormap(pixd) || pixGetColormap(pixs))
409 return ERROR_INT(
"pixs and/or pixd is cmapped", procName, 1);
415 wmin = L_MIN(w, L_MIN(ws, wm));
416 hmin = L_MIN(h, L_MIN(hs, hm));
418 pixt =
pixAnd(NULL, pixs, pixm);
429 wpl = pixGetWpl(pixd);
430 wpls = pixGetWpl(pixs);
431 wplm = pixGetWpl(pixm);
433 for (i = 0; i < hmin; i++) {
434 line = data + i * wpl;
435 lines = datas + i * wpls;
436 linem = datam + i * wplm;
437 for (j = 0; j < wmin; j++) {
445 for (i = 0; i < hmin; i++) {
446 line = data + i * wpl;
447 lines = datas + i * wpls;
448 linem = datam + i * wplm;
449 for (j = 0; j < wmin; j++) {
507 l_int32 d, w, h, ws, hs, ds, wm, hm, dm, wmin, hmin;
508 l_int32 wpl, wpls, wplm, i, j, val;
509 l_uint32 *data, *datas, *datam, *line, *lines, *linem;
512 PROCNAME(
"pixCombineMaskedGeneral");
517 return ERROR_INT(
"pixd not defined", procName, 1);
519 return ERROR_INT(
"pixs not defined", procName, 1);
524 return ERROR_INT(
"pixs and pixd depths differ", procName, 1);
526 return ERROR_INT(
"pixm not 1 bpp", procName, 1);
527 if (d != 1 && d != 8 && d != 32)
528 return ERROR_INT(
"pixd not 1, 8 or 32 bpp", procName, 1);
529 if (pixGetColormap(pixd) || pixGetColormap(pixs))
530 return ERROR_INT(
"pixs and/or pixd is cmapped", procName, 1);
536 wmin = L_MIN(ws, wm);
537 hmin = L_MIN(hs, hm);
539 pixt =
pixAnd(NULL, pixs, pixm);
547 wpl = pixGetWpl(pixd);
549 wpls = pixGetWpl(pixs);
551 wplm = pixGetWpl(pixm);
554 for (i = 0; i < hmin; i++) {
555 if (y + i < 0 || y + i >= h)
continue;
556 line = data + (y + i) * wpl;
557 lines = datas + i * wpls;
558 linem = datam + i * wplm;
559 for (j = 0; j < wmin; j++) {
560 if (x + j < 0 || x + j >= w)
continue;
569 *(line + x + j) = *(lines + j);
572 return ERROR_INT(
"shouldn't get here", procName, 1);
632 l_int32 d, w, h, wm, hm, wpl, wplm, i, j, rval, gval, bval;
633 l_uint32 *data, *datam, *line, *linem;
635 PROCNAME(
"pixPaintThroughMask");
640 return ERROR_INT(
"pixd not defined", procName, 1);
641 if (pixGetColormap(pixd)) {
646 if (pixGetDepth(pixm) != 1)
647 return ERROR_INT(
"pixm not 1 bpp", procName, 1);
648 d = pixGetDepth(pixd);
660 return ERROR_INT(
"pixd not 1, 2, 4, 8, 16 or 32 bpp", procName, 1);
676 if (d < 32 && val == 0) {
684 if (d < 32 && val == ((1 << d) - 1)) {
693 wpl = pixGetWpl(pixd);
695 wplm = pixGetWpl(pixm);
697 for (i = 0; i < hm; i++) {
698 if (y + i < 0 || y + i >= h)
continue;
699 line = data + (y + i) * wpl;
700 linem = datam + i * wplm;
701 for (j = 0; j < wm; j++) {
702 if (x + j < 0 || x + j >= w)
continue;
719 *(line + x + j) = val;
722 return ERROR_INT(
"shouldn't get here", procName, 1);
763 l_int32 i, n, x, y, w, h;
766 PROCNAME(
"pixCopyWithBoxa");
769 return (
PIX *)ERROR_PTR(
"pixs not defined", procName, NULL);
771 return (
PIX *)ERROR_PTR(
"boxa not defined", procName, NULL);
773 return (
PIX *)ERROR_PTR(
"invalid background", procName, NULL);
778 for (i = 0; i < n; i++) {
858 l_int32 w, h, d, wm, hm, dm, i, n, bx, by, bw, bh, edgeblend, retval, minside;
860 BOX *box, *boxv, *boxh;
862 PIX *pixf, *pixv, *pixh, *pix1, *pix2, *pix3, *pix4, *pix5;
865 PROCNAME(
"pixPaintSelfThroughMask");
870 return ERROR_INT(
"pixd not defined", procName, 1);
871 if (pixGetColormap(pixd) != NULL)
872 return ERROR_INT(
"pixd has colormap", procName, 1);
874 if (d != 8 && d != 32)
875 return ERROR_INT(
"pixd not 8 or 32 bpp", procName, 1);
878 return ERROR_INT(
"pixm not 1 bpp", procName, 1);
880 return ERROR_INT(
"x and y must be non-negative", procName, 1);
881 if (searchdir != L_HORIZ && searchdir != L_VERT &&
882 searchdir != L_BOTH_DIRECTIONS)
883 return ERROR_INT(
"invalid searchdir", procName, 1);
885 return ERROR_INT(
"tilesize must be >= 2", procName, 1);
887 return ERROR_INT(
"distblend must be >= 0", procName, 1);
890 if (wm < w || hm < h) {
900 L_WARNING(
"no fg in mask\n", procName);
913 edgeblend = (n == 1 && distblend > 0) ? 1 : 0;
914 if (distblend > 0 && n > 1)
915 L_WARNING(
"%d components; can not blend at edges\n", procName, n);
917 for (i = 0; i < n; i++) {
925 minside = L_MIN(bw, bh);
928 if (searchdir == L_HORIZ || searchdir == L_BOTH_DIRECTIONS) {
930 L_MIN(minside, tilesize), ntiles, &boxh, 0);
932 if (searchdir == L_VERT || searchdir == L_BOTH_DIRECTIONS) {
934 L_MIN(minside, tilesize), ntiles, &boxv, 0);
936 if (!boxh && !boxv) {
937 L_WARNING(
"tile region not selected; paint color near boundary\n",
954 pix2 =
pixBlend(pixh, pixv, 0, 0, 0.5);
1008 l_int32 w, h, d, i, j, sval, wpls, wpld;
1009 l_uint32 *datas, *datad, *lines, *lined;
1012 PROCNAME(
"pixMakeMaskFromVal");
1015 return (
PIX *)ERROR_PTR(
"pixs not defined", procName, NULL);
1017 if (d != 2 && d != 4 && d != 8)
1018 return (
PIX *)ERROR_PTR(
"pix not 2, 4 or 8 bpp", procName, NULL);
1021 pixCopyResolution(pixd, pixs);
1022 pixCopyInputFormat(pixd, pixs);
1025 wpls = pixGetWpl(pixs);
1026 wpld = pixGetWpl(pixd);
1027 for (i = 0; i < h; i++) {
1028 lines = datas + i * wpls;
1029 lined = datad + i * wpld;
1030 for (j = 0; j < w; j++) {
1065 l_int32 w, h, d, i, j, val, wpls, wpld;
1066 l_uint32 *datas, *datad, *lines, *lined;
1069 PROCNAME(
"pixMakeMaskFromLUT");
1072 return (
PIX *)ERROR_PTR(
"pixs not defined", procName, NULL);
1074 return (
PIX *)ERROR_PTR(
"tab not defined", procName, NULL);
1076 if (d != 2 && d != 4 && d != 8)
1077 return (
PIX *)ERROR_PTR(
"pix not 2, 4 or 8 bpp", procName, NULL);
1080 pixCopyResolution(pixd, pixs);
1081 pixCopyInputFormat(pixd, pixs);
1084 wpls = pixGetWpl(pixs);
1085 wpld = pixGetWpl(pixd);
1086 for (i = 0; i < h; i++) {
1087 lines = datas + i * wpls;
1088 lined = datad + i * wpld;
1089 for (j = 0; j < w; j++) {
1139 PROCNAME(
"pixMakeArbMaskFromRGB");
1141 if (!pixs || pixGetDepth(pixs) != 32)
1142 return (
PIX *)ERROR_PTR(
"pixs undefined or not 32 bpp", procName, NULL);
1143 if (thresh >= 255.0) thresh = 254.0;
1146 return (
PIX *)ERROR_PTR(
"pix1 not made", procName, NULL);
1212 PIX *pixg, *pixm, *pixt, *pixd;
1214 PROCNAME(
"pixSetUnderTransparency");
1216 if (!pixs || pixGetDepth(pixs) != 32)
1217 return (
PIX *)ERROR_PTR(
"pixs not defined or not 32 bpp",
1220 if (pixGetSpp(pixs) != 4) {
1221 L_WARNING(
"no alpha channel; returning a copy\n", procName);
1240 pixDisplay(pixt, 0, 0);
1292 PROCNAME(
"pixMakeAlphaFromMask");
1294 if (pbox) *pbox = NULL;
1295 if (!pixs || pixGetDepth(pixs) != 1)
1296 return (
PIX *)ERROR_PTR(
"pixs undefined or not 1 bpp", procName, NULL);
1298 return (
PIX *)ERROR_PTR(
"dist must be >= 0", procName, NULL);
1304 L_WARNING(
"no ON pixels in mask\n", procName);
1361 l_int32 empty, bx, by;
1362 l_float32 rval, gval, bval;
1364 PIX *pix1, *pix2, *pix3;
1366 PROCNAME(
"pixGetColorNearMaskBoundary");
1369 return ERROR_INT(
"&pval not defined", procName, 1);
1371 if (!pixs || pixGetDepth(pixs) != 32)
1372 return ERROR_INT(
"pixs undefined or not 32 bpp", procName, 1);
1373 if (!pixm || pixGetDepth(pixm) != 1)
1374 return ERROR_INT(
"pixm undefined or not 1 bpp", procName, 1);
1376 return ERROR_INT(
"box not defined", procName, 1);
1378 return ERROR_INT(
"dist must be >= 0", procName, 1);
1383 box1 =
boxAdjustSides(NULL, box, -dist - 5, dist + 5, -dist - 5, dist + 5);
1390 snprintf(op,
sizeof(op),
"d%d.%d", 2 * dist, 2 * dist);
1398 pixXor(pix3, pix3, pix2);
1404 &rval, &gval, &bval);
1406 (l_int32)(bval + 0.5), pval);
1408 L_WARNING(
"no pixels found\n", procName);
1414 pixWriteDebug(
"/tmp/masknear/input.png", pix1, IFF_PNG);
1415 pixWriteDebug(
"/tmp/masknear/adjusted.png", pix2, IFF_PNG);
1416 pixWriteDebug(
"/tmp/masknear/outerfive.png", pix3, IFF_PNG);
1417 lept_stderr(
"Input box; with adjusted sides; clipped\n");
1461 PROCNAME(
"pixDisplaySelectedPixels");
1463 if (!pixm || pixGetDepth(pixm) != 1)
1464 return (
PIX *)ERROR_PTR(
"pixm undefined or not 1 bpp", procName, NULL);
1512 PROCNAME(
"pixInvert");
1515 return (
PIX *)ERROR_PTR(
"pixs not defined", procName, NULL);
1518 if ((pixd =
pixCopy(pixd, pixs)) == NULL)
1519 return (
PIX *)ERROR_PTR(
"pixd not made", procName, NULL);
1521 pixRasterop(pixd, 0, 0, pixGetWidth(pixd), pixGetHeight(pixd),
1567 return (
PIX *)ERROR_PTR(
"pixs1 not defined", procName, pixd);
1569 return (
PIX *)ERROR_PTR(
"pixs2 not defined", procName, pixd);
1571 return (
PIX *)ERROR_PTR(
"cannot have pixs2 == pixd", procName, pixd);
1572 if (pixGetDepth(pixs1) != pixGetDepth(pixs2))
1573 return (
PIX *)ERROR_PTR(
"depths of pixs* unequal", procName, pixd);
1575 #if EQUAL_SIZE_WARNING 1577 L_WARNING(
"pixs1 and pixs2 not equal sizes\n", procName);
1581 if ((pixd =
pixCopy(pixd, pixs1)) == NULL)
1582 return (
PIX *)ERROR_PTR(
"pixd not made", procName, pixd);
1585 pixRasterop(pixd, 0, 0, pixGetWidth(pixd), pixGetHeight(pixd),
1631 return (
PIX *)ERROR_PTR(
"pixs1 not defined", procName, pixd);
1633 return (
PIX *)ERROR_PTR(
"pixs2 not defined", procName, pixd);
1635 return (
PIX *)ERROR_PTR(
"cannot have pixs2 == pixd", procName, pixd);
1636 if (pixGetDepth(pixs1) != pixGetDepth(pixs2))
1637 return (
PIX *)ERROR_PTR(
"depths of pixs* unequal", procName, pixd);
1639 #if EQUAL_SIZE_WARNING 1641 L_WARNING(
"pixs1 and pixs2 not equal sizes\n", procName);
1645 if ((pixd =
pixCopy(pixd, pixs1)) == NULL)
1646 return (
PIX *)ERROR_PTR(
"pixd not made", procName, pixd);
1649 pixRasterop(pixd, 0, 0, pixGetWidth(pixd), pixGetHeight(pixd),
1695 return (
PIX *)ERROR_PTR(
"pixs1 not defined", procName, pixd);
1697 return (
PIX *)ERROR_PTR(
"pixs2 not defined", procName, pixd);
1699 return (
PIX *)ERROR_PTR(
"cannot have pixs2 == pixd", procName, pixd);
1700 if (pixGetDepth(pixs1) != pixGetDepth(pixs2))
1701 return (
PIX *)ERROR_PTR(
"depths of pixs* unequal", procName, pixd);
1703 #if EQUAL_SIZE_WARNING 1705 L_WARNING(
"pixs1 and pixs2 not equal sizes\n", procName);
1709 if ((pixd =
pixCopy(pixd, pixs1)) == NULL)
1710 return (
PIX *)ERROR_PTR(
"pixd not made", procName, pixd);
1713 pixRasterop(pixd, 0, 0, pixGetWidth(pixd), pixGetHeight(pixd),
1759 PROCNAME(
"pixSubtract");
1762 return (
PIX *)ERROR_PTR(
"pixs1 not defined", procName, pixd);
1764 return (
PIX *)ERROR_PTR(
"pixs2 not defined", procName, pixd);
1765 if (pixGetDepth(pixs1) != pixGetDepth(pixs2))
1766 return (
PIX *)ERROR_PTR(
"depths of pixs* unequal", procName, pixd);
1768 #if EQUAL_SIZE_WARNING 1770 L_WARNING(
"pixs1 and pixs2 not equal sizes\n", procName);
1778 }
else if (pixd == pixs1) {
1781 }
else if (pixd == pixs2) {
1818 l_int32 w, h, wpl, i, j, fullwords, endbits;
1820 l_uint32 *data, *line;
1822 PROCNAME(
"pixZero");
1825 return ERROR_INT(
"&empty not defined", procName, 1);
1828 return ERROR_INT(
"pix not defined", procName, 1);
1830 w = pixGetWidth(pix) * pixGetDepth(pix);
1831 h = pixGetHeight(pix);
1832 wpl = pixGetWpl(pix);
1836 endmask = (endbits == 0) ? 0 : (0xffffffffU << (32 - endbits));
1838 for (i = 0; i < h; i++) {
1839 line = data + wpl * i;
1840 for (j = 0; j < fullwords; j++)
1846 if (*line & endmask) {
1868 l_int32 w, h, count;
1870 PROCNAME(
"pixForegroundFraction");
1873 return ERROR_INT(
"&fract not defined", procName, 1);
1875 if (!pix || pixGetDepth(pix) != 1)
1876 return ERROR_INT(
"pix not defined or not 1 bpp", procName, 1);
1880 *pfract = (l_float32)count / (l_float32)(w * h);
1894 l_int32 d, i, n, count;
1899 PROCNAME(
"pixaCountPixels");
1902 return (
NUMA *)ERROR_PTR(
"pix not defined", procName, NULL);
1908 d = pixGetDepth(pix);
1911 return (
NUMA *)ERROR_PTR(
"pixa not 1 bpp", procName, NULL);
1914 return (
NUMA *)ERROR_PTR(
"na not made", procName, NULL);
1916 for (i = 0; i < n; i++) {
1942 l_int32 w, h, wpl, i, j;
1943 l_int32 fullwords, endbits, sum;
1947 PROCNAME(
"pixCountPixels");
1950 return ERROR_INT(
"&count not defined", procName, 1);
1952 if (!pixs || pixGetDepth(pixs) != 1)
1953 return ERROR_INT(
"pixs not defined or not 1 bpp", procName, 1);
1957 wpl = pixGetWpl(pixs);
1961 endmask = (endbits == 0) ? 0 : (0xffffffffU << (32 - endbits));
1964 for (i = 0; i < h; i++, data += wpl) {
1965 for (j = 0; j < fullwords; j++) {
1966 l_uint32 word = data[j];
1968 sum += tab[word & 0xff] +
1969 tab[(word >> 8) & 0xff] +
1970 tab[(word >> 16) & 0xff] +
1971 tab[(word >> 24) & 0xff];
1975 l_uint32 word = data[j] & endmask;
1977 sum += tab[word & 0xff] +
1978 tab[(word >> 8) & 0xff] +
1979 tab[(word >> 16) & 0xff] +
1980 tab[(word >> 24) & 0xff];
1986 if (!tab8) LEPT_FREE(tab);
2006 l_int32 bx, by, bw, bh;
2009 PROCNAME(
"pixCountPixelsInRect");
2012 return ERROR_INT(
"&count not defined", procName, 1);
2014 if (!pixs || pixGetDepth(pixs) != 1)
2015 return ERROR_INT(
"pixs not defined or not 1 bpp", procName, 1);
2048 l_int32 i, j, w, h, wpl, count, xstart, xend, ystart, yend, bw, bh;
2049 l_uint32 *line, *data;
2052 PROCNAME(
"pixCountByRow");
2054 if (!pix || pixGetDepth(pix) != 1)
2055 return (
NUMA *)ERROR_PTR(
"pix undefined or not 1 bpp", procName, NULL);
2062 return (
NUMA *)ERROR_PTR(
"invalid clipping box", procName, NULL);
2065 return (
NUMA *)ERROR_PTR(
"na not made", procName, NULL);
2068 wpl = pixGetWpl(pix);
2069 for (i = ystart; i < yend; i++) {
2071 line = data + i * wpl;
2072 for (j = xstart; j < xend; j++) {
2100 l_int32 i, j, w, h, wpl, count, xstart, xend, ystart, yend, bw, bh;
2101 l_uint32 *line, *data;
2104 PROCNAME(
"pixCountByColumn");
2106 if (!pix || pixGetDepth(pix) != 1)
2107 return (
NUMA *)ERROR_PTR(
"pix undefined or not 1 bpp", procName, NULL);
2114 return (
NUMA *)ERROR_PTR(
"invalid clipping box", procName, NULL);
2117 return (
NUMA *)ERROR_PTR(
"na not made", procName, NULL);
2120 wpl = pixGetWpl(pix);
2121 for (j = xstart; j < xend; j++) {
2123 for (i = ystart; i < yend; i++) {
2124 line = data + i * wpl;
2146 l_int32 h, i, count;
2150 PROCNAME(
"pixCountPixelsByRow");
2152 if (!pix || pixGetDepth(pix) != 1)
2153 return (
NUMA *)ERROR_PTR(
"pix undefined or not 1 bpp", procName, NULL);
2155 h = pixGetHeight(pix);
2157 return (
NUMA *)ERROR_PTR(
"na not made", procName, NULL);
2160 for (i = 0; i < h; i++) {
2165 if (!tab8) LEPT_FREE(tab);
2179 l_int32 i, j, w, h, wpl;
2180 l_uint32 *line, *data;
2184 PROCNAME(
"pixCountPixelsByColumn");
2186 if (!pix || pixGetDepth(pix) != 1)
2187 return (
NUMA *)ERROR_PTR(
"pix undefined or not 1 bpp", procName, NULL);
2191 return (
NUMA *)ERROR_PTR(
"na not made", procName, NULL);
2195 wpl = pixGetWpl(pix);
2196 for (i = 0; i < h; i++) {
2197 line = data + wpl * i;
2198 for (j = 0; j < w; j++) {
2223 l_uint32 word, endmask;
2224 l_int32 j, w, h, wpl;
2225 l_int32 fullwords, endbits, sum;
2229 PROCNAME(
"pixCountPixelsInRow");
2232 return ERROR_INT(
"&count not defined", procName, 1);
2234 if (!pix || pixGetDepth(pix) != 1)
2235 return ERROR_INT(
"pix not defined or not 1 bpp", procName, 1);
2238 if (row < 0 || row >= h)
2239 return ERROR_INT(
"row out of bounds", procName, 1);
2240 wpl = pixGetWpl(pix);
2244 endmask = (endbits == 0) ? 0 : (0xffffffffU << (32 - endbits));
2248 for (j = 0; j < fullwords; j++) {
2251 sum += tab[word & 0xff] +
2252 tab[(word >> 8) & 0xff] +
2253 tab[(word >> 16) & 0xff] +
2254 tab[(word >> 24) & 0xff];
2258 word = line[j] & endmask;
2260 sum += tab[word & 0xff] +
2261 tab[(word >> 8) & 0xff] +
2262 tab[(word >> 16) & 0xff] +
2263 tab[(word >> 24) & 0xff];
2268 if (!tab8) LEPT_FREE(tab);
2284 l_int32 i, j, w, h, wpl;
2285 l_uint32 *line, *data;
2289 PROCNAME(
"pixGetMomentByColumn");
2291 if (!pix || pixGetDepth(pix) != 1)
2292 return (
NUMA *)ERROR_PTR(
"pix undefined or not 1 bpp", procName, NULL);
2293 if (order != 1 && order != 2)
2294 return (
NUMA *)ERROR_PTR(
"order of moment not 1 or 2", procName, NULL);
2298 return (
NUMA *)ERROR_PTR(
"na not made", procName, NULL);
2302 wpl = pixGetWpl(pix);
2303 for (i = 0; i < h; i++) {
2304 line = data + wpl * i;
2305 for (j = 0; j < w; j++) {
2344 l_uint32 word, endmask;
2346 l_int32 w, h, wpl, i, j;
2347 l_int32 fullwords, endbits, sum;
2348 l_uint32 *line, *data;
2350 PROCNAME(
"pixThresholdPixelSum");
2353 return ERROR_INT(
"&above not defined", procName, 1);
2355 if (!pix || pixGetDepth(pix) != 1)
2356 return ERROR_INT(
"pix not defined or not 1 bpp", procName, 1);
2360 wpl = pixGetWpl(pix);
2364 endmask = 0xffffffff << (32 - endbits);
2367 for (i = 0; i < h; i++) {
2368 line = data + wpl * i;
2369 for (j = 0; j < fullwords; j++) {
2372 sum += tab[word & 0xff] +
2373 tab[(word >> 8) & 0xff] +
2374 tab[(word >> 16) & 0xff] +
2375 tab[(word >> 24) & 0xff];
2379 word = line[j] & endmask;
2381 sum += tab[word & 0xff] +
2382 tab[(word >> 8) & 0xff] +
2383 tab[(word >> 16) & 0xff] +
2384 tab[(word >> 24) & 0xff];
2389 if (!tab8) LEPT_FREE(tab);
2394 if (!tab8) LEPT_FREE(tab);
2417 tab = (l_int32 *)LEPT_CALLOC(256,
sizeof(l_int32));
2418 for (i = 0; i < 256; i++) {
2420 tab[i] = (
byte & 0x1) +
2421 ((
byte >> 1) & 0x1) +
2422 ((
byte >> 2) & 0x1) +
2423 ((
byte >> 3) & 0x1) +
2424 ((
byte >> 4) & 0x1) +
2425 ((
byte >> 5) & 0x1) +
2426 ((
byte >> 6) & 0x1) +
2427 ((
byte >> 7) & 0x1);
2456 tab = (l_int32 *)LEPT_CALLOC(256,
sizeof(l_int32));
2459 for (i = 2; i < 4; i++) {
2460 tab[i] = tab[i - 2] + 6;
2462 for (i = 4; i < 8; i++) {
2463 tab[i] = tab[i - 4] + 5;
2465 for (i = 8; i < 16; i++) {
2466 tab[i] = tab[i - 8] + 4;
2468 for (i = 16; i < 32; i++) {
2469 tab[i] = tab[i - 16] + 3;
2471 for (i = 32; i < 64; i++) {
2472 tab[i] = tab[i - 32] + 2;
2474 for (i = 64; i < 128; i++) {
2475 tab[i] = tab[i - 64] + 1;
2477 for (i = 128; i < 256; i++) {
2478 tab[i] = tab[i - 128];
2508 l_int32 i, j, w, h, d, wpl, xstart, xend, ystart, yend, bw, bh;
2509 l_uint32 *line, *data;
2510 l_float64 norm, sum;
2513 PROCNAME(
"pixAverageByRow");
2516 return (
NUMA *)ERROR_PTR(
"pix not defined", procName, NULL);
2518 if (d != 8 && d != 16)
2519 return (
NUMA *)ERROR_PTR(
"pix not 8 or 16 bpp", procName, NULL);
2521 return (
NUMA *)ERROR_PTR(
"invalid type", procName, NULL);
2522 if (pixGetColormap(pix) != NULL)
2523 return (
NUMA *)ERROR_PTR(
"pix colormapped", procName, NULL);
2527 return (
NUMA *)ERROR_PTR(
"invalid clipping box", procName, NULL);
2529 norm = 1. / (l_float32)bw;
2531 return (
NUMA *)ERROR_PTR(
"na not made", procName, NULL);
2534 wpl = pixGetWpl(pix);
2535 for (i = ystart; i < yend; i++) {
2537 line = data + i * wpl;
2539 for (j = xstart; j < xend; j++)
2542 sum = bw * 255 - sum;
2544 for (j = xstart; j < xend; j++)
2547 sum = bw * 0xffff - sum;
2577 l_int32 i, j, w, h, d, wpl, xstart, xend, ystart, yend, bw, bh;
2578 l_uint32 *line, *data;
2579 l_float32 norm, sum;
2582 PROCNAME(
"pixAverageByColumn");
2585 return (
NUMA *)ERROR_PTR(
"pix not defined", procName, NULL);
2588 if (d != 8 && d != 16)
2589 return (
NUMA *)ERROR_PTR(
"pix not 8 or 16 bpp", procName, NULL);
2591 return (
NUMA *)ERROR_PTR(
"invalid type", procName, NULL);
2592 if (pixGetColormap(pix) != NULL)
2593 return (
NUMA *)ERROR_PTR(
"pix colormapped", procName, NULL);
2597 return (
NUMA *)ERROR_PTR(
"invalid clipping box", procName, NULL);
2600 return (
NUMA *)ERROR_PTR(
"na not made", procName, NULL);
2602 norm = 1. / (l_float32)bh;
2604 wpl = pixGetWpl(pix);
2605 for (j = xstart; j < xend; j++) {
2608 for (i = ystart; i < yend; i++) {
2609 line = data + i * wpl;
2613 sum = bh * 255 - sum;
2615 for (i = ystart; i < yend; i++) {
2616 line = data + i * wpl;
2620 sum = bh * 0xffff - sum;
2668 l_int32 w, h, d, wpls, wm, hm, dm, wplm, val, count;
2669 l_int32 i, j, xstart, xend, ystart, yend;
2670 l_uint32 *datas, *datam, *lines, *linem;
2673 PROCNAME(
"pixAverageInRect");
2676 return ERROR_INT(
"&ave not defined", procName, 1);
2679 return ERROR_INT(
"pixs not defined", procName, 1);
2680 if (pixGetColormap(pixs) != NULL)
2681 return ERROR_INT(
"pixs is colormapped", procName, 1);
2683 if (d != 1 && d != 2 && d != 4 && d != 8)
2684 return ERROR_INT(
"pixs not 1, 2, 4 or 8 bpp", procName, 1);
2688 return ERROR_INT(
"pixm not 1 bpp", procName, 1);
2693 return ERROR_INT(
"subsamp must be >= 1", procName, 1);
2697 return ERROR_INT(
"invalid clipping box", procName, 1);
2700 wpls = pixGetWpl(pixs);
2703 wplm = pixGetWpl(pixm);
2707 for (i = ystart; i < yend; i += subsamp) {
2708 lines = datas + i * wpls;
2710 linem = datam + i * wplm;
2711 for (j = xstart; j < xend; j += subsamp) {
2722 if (val >= minval && val <= maxval) {
2731 *pave = sum / (l_float32)count;
2773 l_int32 w, h, wpls, wm, hm, dm, wplm, i, j, xstart, xend, ystart, yend;
2774 l_int32 rval, gval, bval, rave, gave, bave, count;
2775 l_uint32 *datas, *datam, *lines, *linem;
2777 l_float64 rsum, gsum, bsum;
2779 PROCNAME(
"pixAverageInRectRGB");
2782 return ERROR_INT(
"&ave not defined", procName, 1);
2784 if (!pixs || pixGetDepth(pixs) != 32)
2785 return ERROR_INT(
"pixs undefined or not 32 bpp", procName, 1);
2790 return ERROR_INT(
"pixm not 1 bpp", procName, 1);
2795 return ERROR_INT(
"subsamp must be >= 1", procName, 1);
2799 return ERROR_INT(
"invalid clipping box", procName, 1);
2802 wpls = pixGetWpl(pixs);
2805 wplm = pixGetWpl(pixm);
2807 rsum = gsum = bsum = 0.0;
2809 for (i = ystart; i < yend; i += subsamp) {
2810 lines = datas + i * wpls;
2812 linem = datam + i * wplm;
2813 for (j = xstart; j < xend; j += subsamp) {
2816 pixel = *(lines + j);
2827 rave = (l_uint32)(rsum / (l_float64)count);
2828 gave = (l_uint32)(gsum / (l_float64)count);
2829 bave = (l_uint32)(bsum / (l_float64)count);
2857 l_int32 i, j, w, h, d, wpl, xstart, xend, ystart, yend, bw, bh, val;
2858 l_uint32 *line, *data;
2859 l_float64 sum1, sum2, norm, ave, var, rootvar;
2862 PROCNAME(
"pixVarianceByRow");
2865 return (
NUMA *)ERROR_PTR(
"pix not defined", procName, NULL);
2867 if (d != 8 && d != 16)
2868 return (
NUMA *)ERROR_PTR(
"pix not 8 or 16 bpp", procName, NULL);
2869 if (pixGetColormap(pix) != NULL)
2870 return (
NUMA *)ERROR_PTR(
"pix colormapped", procName, NULL);
2874 return (
NUMA *)ERROR_PTR(
"invalid clipping box", procName, NULL);
2877 return (
NUMA *)ERROR_PTR(
"na not made", procName, NULL);
2879 norm = 1. / (l_float32)bw;
2881 wpl = pixGetWpl(pix);
2882 for (i = ystart; i < yend; i++) {
2884 line = data + i * wpl;
2885 for (j = xstart; j < xend; j++) {
2891 sum2 += (l_float64)(val) * val;
2894 var = norm * sum2 - ave * ave;
2895 rootvar = sqrt(var);
2922 l_int32 i, j, w, h, d, wpl, xstart, xend, ystart, yend, bw, bh, val;
2923 l_uint32 *line, *data;
2924 l_float64 sum1, sum2, norm, ave, var, rootvar;
2927 PROCNAME(
"pixVarianceByColumn");
2930 return (
NUMA *)ERROR_PTR(
"pix not defined", procName, NULL);
2932 if (d != 8 && d != 16)
2933 return (
NUMA *)ERROR_PTR(
"pix not 8 or 16 bpp", procName, NULL);
2934 if (pixGetColormap(pix) != NULL)
2935 return (
NUMA *)ERROR_PTR(
"pix colormapped", procName, NULL);
2939 return (
NUMA *)ERROR_PTR(
"invalid clipping box", procName, NULL);
2942 return (
NUMA *)ERROR_PTR(
"na not made", procName, NULL);
2944 norm = 1. / (l_float32)bh;
2946 wpl = pixGetWpl(pix);
2947 for (j = xstart; j < xend; j++) {
2949 for (i = ystart; i < yend; i++) {
2950 line = data + wpl * i;
2956 sum2 += (l_float64)(val) * val;
2959 var = norm * sum2 - ave * ave;
2960 rootvar = sqrt(var);
2979 l_float32 *prootvar)
2981 l_int32 w, h, d, wpl, i, j, xstart, xend, ystart, yend, bw, bh, val;
2982 l_uint32 *data, *line;
2983 l_float64 sum1, sum2, norm, ave, var;
2985 PROCNAME(
"pixVarianceInRect");
2988 return ERROR_INT(
"&rootvar not defined", procName, 1);
2991 return ERROR_INT(
"pix not defined", procName, 1);
2993 if (d != 1 && d != 2 && d != 4 && d != 8)
2994 return ERROR_INT(
"pix not 1, 2, 4 or 8 bpp", procName, 1);
2995 if (pixGetColormap(pix) != NULL)
2996 return ERROR_INT(
"pix is colormapped", procName, 1);
3000 return ERROR_INT(
"invalid clipping box", procName, 1);
3002 wpl = pixGetWpl(pix);
3005 for (i = ystart; i < yend; i++) {
3006 line = data + i * wpl;
3007 for (j = xstart; j < xend; j++) {
3011 sum2 += (l_float64)(val) * val;
3012 }
else if (d == 2) {
3015 sum2 += (l_float64)(val) * val;
3016 }
else if (d == 4) {
3019 sum2 += (l_float64)(val) * val;
3023 sum2 += (l_float64)(val) * val;
3027 norm = 1.0 / ((l_float64)(bw) * bh);
3029 var = norm * sum2 - ave * ave;
3030 *prootvar = (l_float32)sqrt(var);
3057 l_int32 i, j, w, h, wpl, xstart, xend, ystart, yend, bw, bh, val0, val1;
3058 l_uint32 *line, *data;
3059 l_float64 norm, sum;
3062 PROCNAME(
"pixAbsDiffByRow");
3064 if (!pix || pixGetDepth(pix) != 8)
3065 return (
NUMA *)ERROR_PTR(
"pix undefined or not 8 bpp", procName, NULL);
3066 if (pixGetColormap(pix) != NULL)
3067 return (
NUMA *)ERROR_PTR(
"pix colormapped", procName, NULL);
3072 return (
NUMA *)ERROR_PTR(
"invalid clipping box", procName, NULL);
3074 return (
NUMA *)ERROR_PTR(
"row width must be >= 2", procName, NULL);
3076 norm = 1. / (l_float32)(bw - 1);
3078 return (
NUMA *)ERROR_PTR(
"na not made", procName, NULL);
3081 wpl = pixGetWpl(pix);
3082 for (i = ystart; i < yend; i++) {
3084 line = data + i * wpl;
3086 for (j = xstart + 1; j < xend; j++) {
3088 sum += L_ABS(val1 - val0);
3118 l_int32 i, j, w, h, wpl, xstart, xend, ystart, yend, bw, bh, val0, val1;
3119 l_uint32 *line, *data;
3120 l_float64 norm, sum;
3123 PROCNAME(
"pixAbsDiffByColumn");
3125 if (!pix || pixGetDepth(pix) != 8)
3126 return (
NUMA *)ERROR_PTR(
"pix undefined or not 8 bpp", procName, NULL);
3127 if (pixGetColormap(pix) != NULL)
3128 return (
NUMA *)ERROR_PTR(
"pix colormapped", procName, NULL);
3133 return (
NUMA *)ERROR_PTR(
"invalid clipping box", procName, NULL);
3135 return (
NUMA *)ERROR_PTR(
"column height must be >= 2", procName, NULL);
3137 norm = 1. / (l_float32)(bh - 1);
3139 return (
NUMA *)ERROR_PTR(
"na not made", procName, NULL);
3142 wpl = pixGetWpl(pix);
3143 for (j = xstart; j < xend; j++) {
3145 line = data + ystart * wpl;
3147 for (i = ystart + 1; i < yend; i++) {
3148 line = data + i * wpl;
3150 sum += L_ABS(val1 - val0);
3181 l_float32 *pabsdiff)
3183 l_int32 w, h, wpl, i, j, xstart, xend, ystart, yend, bw, bh, val0, val1;
3184 l_uint32 *data, *line;
3185 l_float64 norm, sum;
3187 PROCNAME(
"pixAbsDiffInRect");
3190 return ERROR_INT(
"&absdiff not defined", procName, 1);
3192 if (!pix || pixGetDepth(pix) != 8)
3193 return ERROR_INT(
"pix undefined or not 8 bpp", procName, 1);
3195 return ERROR_INT(
"invalid direction", procName, 1);
3196 if (pixGetColormap(pix) != NULL)
3197 return ERROR_INT(
"pix is colormapped", procName, 1);
3202 return ERROR_INT(
"invalid clipping box", procName, 1);
3204 wpl = pixGetWpl(pix);
3207 norm = 1. / (l_float32)(bh * (bw - 1));
3209 for (i = ystart; i < yend; i++) {
3210 line = data + i * wpl;
3212 for (j = xstart + 1; j < xend; j++) {
3214 sum += L_ABS(val1 - val0);
3219 norm = 1. / (l_float32)(bw * (bh - 1));
3221 for (j = xstart; j < xend; j++) {
3222 line = data + ystart * wpl;
3224 for (i = ystart + 1; i < yend; i++) {
3225 line = data + i * wpl;
3227 sum += L_ABS(val1 - val0);
3232 *pabsdiff = (l_float32)(norm * sum);
3260 l_float32 *pabsdiff)
3262 l_int32 w, h, i, j, dir, size, sum;
3263 l_uint32 val0, val1;
3265 PROCNAME(
"pixAbsDiffOnLine");
3268 return ERROR_INT(
"&absdiff not defined", procName, 1);
3270 if (!pix || pixGetDepth(pix) != 8)
3271 return ERROR_INT(
"pix undefined or not 8 bpp", procName, 1);
3274 }
else if (x1 == x2) {
3277 return ERROR_INT(
"line is neither horiz nor vert", procName, 1);
3279 if (pixGetColormap(pix) != NULL)
3280 return ERROR_INT(
"pix is colormapped", procName, 1);
3286 x2 = L_MIN(x2, w - 1);
3288 return ERROR_INT(
"x1 >= x2", procName, 1);
3291 for (j = x1 + 1; j <= x2; j++) {
3293 sum += L_ABS((l_int32)val1 - (l_int32)val0);
3298 y2 = L_MIN(y2, h - 1);
3300 return ERROR_INT(
"y1 >= y2", procName, 1);
3303 for (i = y1 + 1; i <= y2; i++) {
3305 sum += L_ABS((l_int32)val1 - (l_int32)val0);
3309 *pabsdiff = (l_float32)sum / (l_float32)size;
3343 l_int32 i, j, bx, by, bw, bh, w, h, wpl, pixval;
3344 l_uint32 *data, *line;
3346 PROCNAME(
"pixCountArbInRect");
3349 return ERROR_INT(
"&count not defined", procName, 1);
3352 return ERROR_INT(
"pixs not defined", procName, 1);
3353 if (pixGetDepth(pixs) != 8 && !pixGetColormap(pixs))
3354 return ERROR_INT(
"pixs neither 8 bpp nor colormapped",
3357 return ERROR_INT(
"sampling factor < 1", procName, 1);
3361 wpl = pixGetWpl(pixs);
3364 for (i = 0; i < h; i += factor) {
3365 line = data + i * wpl;
3366 for (j = 0; j < w; j += factor) {
3368 if (pixval == val) (*pcount)++;
3373 for (i = 0; i < bh; i += factor) {
3374 if (by + i < 0 || by + i >= h)
continue;
3375 line = data + (by + i) * wpl;
3376 for (j = 0; j < bw; j += factor) {
3377 if (bx + j < 0 || bx + j >= w)
continue;
3379 if (pixval == val) (*pcount)++;
3385 *pcount = *pcount * factor * factor;
3419 l_int32 wt, ht, d, i, j, nx, ny;
3420 PIX *pixd, *pixsfx, *pixsfy, *pixsfxy, *pix;
3422 PROCNAME(
"pixMirroredTiling");
3425 return (
PIX *)ERROR_PTR(
"pixs not defined", procName, NULL);
3427 if (wt <= 0 || ht <= 0)
3428 return (
PIX *)ERROR_PTR(
"pixs size illegal", procName, NULL);
3429 if (d != 8 && d != 32)
3430 return (
PIX *)ERROR_PTR(
"depth not 32 bpp", procName, NULL);
3432 if ((pixd =
pixCreate(w, h, d)) == NULL)
3433 return (
PIX *)ERROR_PTR(
"pixd not made", procName, NULL);
3436 nx = (w + wt - 1) / wt;
3437 ny = (h + ht - 1) / ht;
3441 for (i = 0; i < ny; i++) {
3442 for (j = 0; j < nx; j++) {
3444 if ((i & 1) && !(j & 1))
3446 else if (!(i & 1) && (j & 1))
3448 else if ((i & 1) && (j & 1))
3499 l_int32 w, h, i, n, bestindex;
3500 l_float32 var_of_mean, median_of_mean, median_of_stdev, mean_val, stdev_val;
3501 l_float32 mindels, bestdelm, delm, dels, mean, stdev;
3503 NUMA *namean, *nastdev;
3507 PROCNAME(
"pixFindRepCloseTile");
3510 return ERROR_INT(
"&boxtile not defined", procName, 1);
3513 return ERROR_INT(
"pixs not defined", procName, 1);
3515 return ERROR_INT(
"box not defined", procName, 1);
3516 if (searchdir != L_HORIZ && searchdir != L_VERT)
3517 return ERROR_INT(
"invalid searchdir", procName, 1);
3519 return ERROR_INT(
"mindist must be >= 0", procName, 1);
3521 return ERROR_INT(
"tsize must be > 1", procName, 1);
3523 L_WARNING(
"ntiles = %d; larger than suggested max of 7\n",
3532 return ERROR_INT(
"no tiles found", procName, 1);
3539 for (i = 0; i < n; i++) {
3558 &median_of_mean, 0.0, NULL, NULL);
3560 &median_of_stdev, 0.0, NULL, NULL);
3564 for (i = 0; i < n; i++) {
3567 if (var_of_mean == 0.0) {
3571 delm = L_ABS(mean_val - median_of_mean) / sqrt(var_of_mean);
3572 dels = stdev_val / median_of_stdev;
3575 if (dels < mindels) {
3578 " stdev = %7.3f, dels = %7.3f\n",
3579 i, mean_val, delm, stdev_val, dels);
3590 L_INFO(
"median of mean = %7.3f\n", procName, median_of_mean);
3591 L_INFO(
"standard dev of mean = %7.3f\n", procName, sqrt(var_of_mean));
3592 L_INFO(
"median of stdev = %7.3f\n", procName, median_of_stdev);
3593 L_INFO(
"best tile: index = %d\n", procName, bestindex);
3594 L_INFO(
"delta from median in units of stdev = %5.3f\n",
3595 procName, bestdelm);
3596 L_INFO(
"stdev as fraction of median stdev = %5.3f\n",
3633 l_int32 bx, by, bw, bh, left, right, top, bot, i, j, nrows, ncols;
3634 l_int32 x0, y0, x, y, w_avail, w_needed, h_avail, h_needed, t_avail;
3638 PROCNAME(
"findTileRegionsForSearch");
3641 return (
BOXA *)ERROR_PTR(
"box not defined", procName, NULL);
3643 return (
BOXA *)ERROR_PTR(
"no tiles requested", procName, NULL);
3646 if (searchdir == L_HORIZ) {
3650 right = w - bx - bw + 1;
3651 w_avail = L_MAX(left, right) - mindist;
3652 if (tsize & 1) tsize++;
3653 if (w_avail < tsize) {
3654 L_ERROR(
"tsize = %d, w_avail = %d\n", procName, tsize, w_avail);
3657 w_needed = tsize + (ntiles - 1) * (tsize / 2);
3658 if (w_needed > w_avail) {
3659 t_avail = 1 + 2 * (w_avail - tsize) / tsize;
3660 L_WARNING(
"ntiles = %d; room for only %d\n", procName,
3663 w_needed = tsize + (ntiles - 1) * (tsize / 2);
3665 nrows = L_MAX(1, 1 + 2 * (bh - tsize) / tsize);
3672 x0 = bx + bw + mindist;
3673 for (i = 0; i < nrows; i++) {
3674 y = by + i * tsize / 2;
3675 for (j = 0; j < ntiles; j++) {
3676 x = x0 + j * tsize / 2;
3684 bot = h - by - bh + 1;
3685 h_avail = L_MAX(top, bot) - mindist;
3686 if (h_avail < tsize) {
3687 L_ERROR(
"tsize = %d, h_avail = %d\n", procName, tsize, h_avail);
3690 h_needed = tsize + (ntiles - 1) * (tsize / 2);
3691 if (h_needed > h_avail) {
3692 t_avail = 1 + 2 * (h_avail - tsize) / tsize;
3693 L_WARNING(
"ntiles = %d; room for only %d\n", procName,
3696 h_needed = tsize + (ntiles - 1) * (tsize / 2);
3698 ncols = L_MAX(1, 1 + 2 * (bw - tsize) / tsize);
3705 y0 = by + bh + mindist;
3706 for (j = 0; j < ncols; j++) {
3707 x = bx + j * tsize / 2;
3708 for (i = 0; i < ntiles; i++) {
3709 y = y0 + i * tsize / 2;
PIX * pixFlipLR(PIX *pixd, PIX *pixs)
pixFlipLR()
NUMA * pixCountPixelsByRow(PIX *pix, l_int32 *tab8)
pixCountPixelsByRow()
PIX * pixUnpackBinary(PIX *pixs, l_int32 depth, l_int32 invert)
pixUnpackBinary()
NUMA * pixCountByRow(PIX *pix, BOX *box)
pixCountByRow()
l_ok numaGetFValue(NUMA *na, l_int32 index, l_float32 *pval)
numaGetFValue()
NUMA * pixCountPixelsByColumn(PIX *pix)
pixCountPixelsByColumn()
PIX * pixCopyWithBoxa(PIX *pixs, BOXA *boxa, l_int32 background)
pixCopyWithBoxa()
l_int32 lept_mkdir(const char *subdir)
lept_mkdir()
l_ok pixCountPixelsInRow(PIX *pix, l_int32 row, l_int32 *pcount, l_int32 *tab8)
pixCountPixelsInRow()
l_ok pixFindRepCloseTile(PIX *pixs, BOX *box, l_int32 searchdir, l_int32 mindist, l_int32 tsize, l_int32 ntiles, BOX **pboxtile, l_int32 debug)
pixFindRepCloseTile()
PIX * pixConvertTo32(PIX *pixs)
pixConvertTo32()
l_ok pixSetMasked(PIX *pixd, PIX *pixm, l_uint32 val)
pixSetMasked()
l_int32 * makePixelCentroidTab8(void)
makePixelCentroidTab8()
PIX * pixCreateTemplate(const PIX *pixs)
pixCreateTemplate()
NUMA * pixVarianceByRow(PIX *pix, BOX *box)
pixVarianceByRow()
l_ok numaAddNumber(NUMA *na, l_float32 val)
numaAddNumber()
l_ok pixAbsDiffInRect(PIX *pix, BOX *box, l_int32 dir, l_float32 *pabsdiff)
pixAbsDiffInRect()
static BOXA * findTileRegionsForSearch(BOX *box, l_int32 w, l_int32 h, l_int32 searchdir, l_int32 mindist, l_int32 tsize, l_int32 ntiles)
findTileRegionsForSearch()
PIX * pixMakeAlphaFromMask(PIX *pixs, l_int32 dist, BOX **pbox)
pixMakeAlphaFromMask()
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()
void lept_stderr(const char *fmt,...)
lept_stderr()
PIX * pixDilateBrick(PIX *pixd, PIX *pixs, l_int32 hsize, l_int32 vsize)
pixDilateBrick()
l_int32 pixCountArbInRect(PIX *pixs, BOX *box, l_int32 val, l_int32 factor, l_int32 *pcount)
pixCountArbInRect()
l_ok pixAverageInRectRGB(PIX *pixs, PIX *pixm, BOX *box, l_int32 subsamp, l_uint32 *pave)
pixAverageInRectRGB()
BOX * boxClipToRectangle(BOX *box, l_int32 wi, l_int32 hi)
boxClipToRectangle()
PIX * pixCreate(l_int32 width, l_int32 height, l_int32 depth)
pixCreate()
l_ok pixSetMaskedGeneral(PIX *pixd, PIX *pixm, l_uint32 val, l_int32 x, l_int32 y)
pixSetMaskedGeneral()
l_ok pixSetAll(PIX *pix)
pixSetAll()
PIX * pixInvert(PIX *pixd, PIX *pixs)
pixInvert()
#define SET_DATA_QBIT(pdata, n, val)
NUMA * numaCreate(l_int32 n)
numaCreate()
void boxaDestroy(BOXA **pboxa)
boxaDestroy()
l_uint32 * pixGetData(PIX *pix)
pixGetData()
BOX * pixaGetBox(PIXA *pixa, l_int32 index, l_int32 accesstype)
pixaGetBox()
l_ok numaSetCount(NUMA *na, l_int32 newcount)
numaSetCount()
PIX * pixThresholdToBinary(PIX *pixs, l_int32 thresh)
pixThresholdToBinary()
l_ok pixGetColorNearMaskBoundary(PIX *pixs, PIX *pixm, BOX *box, l_int32 dist, l_uint32 *pval, l_int32 debug)
pixGetColorNearMaskBoundary()
#define GET_DATA_BIT(pdata, n)
PIX * pixClipRectangle(PIX *pixs, BOX *box, BOX **pboxc)
pixClipRectangle()
l_ok pixThresholdPixelSum(PIX *pix, l_int32 thresh, l_int32 *pabove, l_int32 *tab8)
pixThresholdPixelSum()
PIX * pixGetRGBComponent(PIX *pixs, l_int32 comp)
pixGetRGBComponent()
#define SET_DATA_DIBIT(pdata, n, val)
l_ok pixPaintThroughMask(PIX *pixd, PIX *pixm, l_int32 x, l_int32 y, l_uint32 val)
pixPaintThroughMask()
l_ok pixSetAllArbitrary(PIX *pix, l_uint32 val)
pixSetAllArbitrary()
l_ok pixCombineMasked(PIX *pixd, PIX *pixs, PIX *pixm)
pixCombineMasked()
l_ok pixClipToForeground(PIX *pixs, PIX **ppixd, BOX **pbox)
pixClipToForeground()
PIX * pixMakeMaskFromVal(PIX *pixs, l_int32 val)
pixMakeMaskFromVal()
PIX * pixSetUnderTransparency(PIX *pixs, l_uint32 val, l_int32 debug)
pixSetUnderTransparency()
BOXA * pixConnComp(PIX *pixs, PIXA **ppixa, l_int32 connectivity)
pixConnComp()
PIX * pixFlipTB(PIX *pixd, PIX *pixs)
pixFlipTB()
l_ok pixGetAverageMasked(PIX *pixs, PIX *pixm, l_int32 x, l_int32 y, l_int32 factor, l_int32 type, l_float32 *pval)
pixGetAverageMasked()
PIX * pixXor(PIX *pixd, PIX *pixs1, PIX *pixs2)
pixXor()
PIX * pixBlend(PIX *pixs1, PIX *pixs2, l_int32 x, l_int32 y, l_float32 fract)
pixBlend()
l_ok pixForegroundFraction(PIX *pix, l_float32 *pfract)
pixForegroundFraction()
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()
NUMA * pixAbsDiffByRow(PIX *pix, BOX *box)
pixAbsDiffByRow()
PIX * pixMorphSequence(PIX *pixs, const char *sequence, l_int32 dispsep)
pixMorphSequence()
l_ok pixCountPixels(PIX *pixs, l_int32 *pcount, l_int32 *tab8)
pixCountPixels()
l_ok boxaAddBox(BOXA *boxa, BOX *box, l_int32 copyflag)
boxaAddBox()
PIX * pixBlendWithGrayMask(PIX *pixs1, PIX *pixs2, PIX *pixg, l_int32 x, l_int32 y)
pixBlendWithGrayMask()
l_int32 * makePixelSumTab8(void)
makePixelSumTab8()
#define SET_DATA_BYTE(pdata, n, val)
PIXA * pixClipRectangles(PIX *pixs, BOXA *boxa)
pixClipRectangles()
#define GET_DATA_QBIT(pdata, n)
l_ok pixSetBlackOrWhite(PIX *pixs, l_int32 op)
pixSetBlackOrWhite()
BOX * boxAdjustSides(BOX *boxd, BOX *boxs, l_int32 delleft, l_int32 delright, l_int32 deltop, l_int32 delbot)
boxAdjustSides()
l_ok pixGetAverageMaskedRGB(PIX *pixs, PIX *pixm, l_int32 x, l_int32 y, l_int32 factor, l_int32 type, l_float32 *prval, l_float32 *pgval, l_float32 *pbval)
pixGetAverageMaskedRGB()
l_ok pixSetMaskedCmap(PIX *pixs, PIX *pixm, l_int32 x, l_int32 y, l_int32 rval, l_int32 gval, l_int32 bval)
pixSetMaskedCmap()
#define GET_DATA_BYTE(pdata, n)
l_ok numaSetParameters(NUMA *na, l_float32 startx, l_float32 delx)
numaSetParameters()
NUMA * pixAbsDiffByColumn(PIX *pix, BOX *box)
pixAbsDiffByColumn()
l_ok pixaGetBoxGeometry(PIXA *pixa, l_int32 index, l_int32 *px, l_int32 *py, l_int32 *pw, l_int32 *ph)
pixaGetBoxGeometry()
l_ok pixCountPixelsInRect(PIX *pixs, BOX *box, l_int32 *pcount, l_int32 *tab8)
pixCountPixelsInRect()
NUMA * pixAverageByColumn(PIX *pix, BOX *box, l_int32 type)
pixAverageByColumn()
PIX * pixClone(PIX *pixs)
pixClone()
PIX * pixSubtract(PIX *pixd, PIX *pixs1, PIX *pixs2)
pixSubtract()
void pixDestroy(PIX **ppix)
pixDestroy()
BOX * boxaGetBox(BOXA *boxa, l_int32 index, l_int32 accessflag)
boxaGetBox()
NUMA * pixGetMomentByColumn(PIX *pix, l_int32 order)
pixGetMomentByColumn()
PIX * pixMakeArbMaskFromRGB(PIX *pixs, l_float32 rc, l_float32 gc, l_float32 bc, l_float32 thresh)
pixMakeArbMaskFromRGB()
void numaDestroy(NUMA **pna)
numaDestroy()
PIX * pixDisplaySelectedPixels(PIX *pixs, PIX *pixm, SEL *sel, l_uint32 val)
pixDisplaySelectedPixels()
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 * pixConvertRGBToGray(PIX *pixs, l_float32 rwt, l_float32 gwt, l_float32 bwt)
pixConvertRGBToGray()
PIX * pixOr(PIX *pixd, PIX *pixs1, PIX *pixs2)
pixOr()
NUMA * pixCountByColumn(PIX *pix, BOX *box)
pixCountByColumn()
NUMA * pixaCountPixels(PIXA *pixa)
pixaCountPixels()
l_ok pixVarianceInRect(PIX *pix, BOX *box, l_float32 *prootvar)
pixVarianceInRect()
NUMA * pixVarianceByColumn(PIX *pix, BOX *box)
pixVarianceByColumn()
PIX * pixConvertRGBToGrayArb(PIX *pixs, l_float32 rc, l_float32 gc, l_float32 bc)
pixConvertRGBToGrayArb()
l_float32 * numaGetFArray(NUMA *na, l_int32 copyflag)
numaGetFArray()
l_ok boxClipToRectangleParams(BOX *box, l_int32 w, l_int32 h, l_int32 *pxstart, l_int32 *pystart, l_int32 *pxend, l_int32 *pyend, l_int32 *pbw, l_int32 *pbh)
boxClipToRectangleParams()
l_ok pixPaintSelfThroughMask(PIX *pixd, PIX *pixm, l_int32 x, l_int32 y, l_int32 searchdir, l_int32 mindist, l_int32 tilesize, l_int32 ntiles, l_int32 distblend)
pixPaintSelfThroughMask()
#define GET_DATA_TWO_BYTES(pdata, n)
PIX * pixDistanceFunction(PIX *pixs, l_int32 connectivity, l_int32 outdepth, l_int32 boundcond)
pixDistanceFunction()
#define GET_DATA_DIBIT(pdata, n)
l_ok pixCombineMaskedGeneral(PIX *pixd, PIX *pixs, PIX *pixm, l_int32 x, l_int32 y)
pixCombineMaskedGeneral()
PIX * pixMirroredTiling(PIX *pixs, l_int32 w, l_int32 h)
pixMirroredTiling()
PIX * pixaGetPix(PIXA *pixa, l_int32 index, l_int32 accesstype)
pixaGetPix()
PIX * pixMakeMaskFromLUT(PIX *pixs, l_int32 *tab)
pixMakeMaskFromLUT()
PIX * pixDisplayLayersRGBA(PIX *pixs, l_uint32 val, l_int32 maxw)
pixDisplayLayersRGBA()
l_ok pixMultConstantGray(PIX *pixs, l_float32 val)
pixMultConstantGray()
l_ok pixZero(PIX *pix, l_int32 *pempty)
pixZero()
BOXA * boxaCreate(l_int32 n)
boxaCreate()
void boxDestroy(BOX **pbox)
boxDestroy()
PIX * pixConvert1To8(PIX *pixd, PIX *pixs, l_uint8 val0, l_uint8 val1)
pixConvert1To8()
l_int32 boxaGetCount(BOXA *boxa)
boxaGetCount()
NUMA * pixAverageByRow(PIX *pix, BOX *box, l_int32 type)
pixAverageByRow()
l_ok boxPrintStreamInfo(FILE *fp, BOX *box)
boxPrintStreamInfo()
PIX * pixDilate(PIX *pixd, PIX *pixs, SEL *sel)
pixDilate()
l_ok composeRGBPixel(l_int32 rval, l_int32 gval, l_int32 bval, l_uint32 *ppixel)
composeRGBPixel()
l_int32 lept_rmdir(const char *subdir)
lept_rmdir()
l_ok pixAbsDiffOnLine(PIX *pix, l_int32 x1, l_int32 y1, l_int32 x2, l_int32 y2, l_float32 *pabsdiff)
pixAbsDiffOnLine()
l_ok pixCopySpp(PIX *pixd, const PIX *pixs)
pixCopySpp()
l_int32 pixSizesEqual(const PIX *pix1, const PIX *pix2)
pixSizesEqual()
l_ok boxGetGeometry(BOX *box, l_int32 *px, l_int32 *py, l_int32 *pw, l_int32 *ph)
boxGetGeometry()
#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()
BOX * boxCreate(l_int32 x, l_int32 y, l_int32 w, l_int32 h)
boxCreate()
l_int32 pixaGetCount(PIXA *pixa)
pixaGetCount()
#define SET_DATA_BIT(pdata, n)
l_ok pixAverageInRect(PIX *pixs, PIX *pixm, BOX *box, l_int32 minval, l_int32 maxval, l_int32 subsamp, l_float32 *pave)
pixAverageInRect()
l_ok numaGetStatsUsingHistogram(NUMA *na, l_int32 maxbins, l_float32 *pmin, l_float32 *pmax, l_float32 *pmean, l_float32 *pvariance, l_float32 *pmedian, l_float32 rank, l_float32 *prval, NUMA **phisto)
numaGetStatsUsingHistogram()