101 #include <config_auto.h>
106 #include "allheaders.h"
109 l_int32 wpld, l_uint32 *datas, l_int32 wpls,
110 l_uint32 *bufs1, l_uint32 *bufs2,
111 l_int32 lowerclip, l_int32 upperclip);
113 l_int32 wpld, l_uint32 *datas, l_int32 d,
114 l_int32 wpls, l_int32 thresh);
115 static void ditherTo2bppLow(l_uint32 *datad, l_int32 w, l_int32 h, l_int32 wpld,
116 l_uint32 *datas, l_int32 wpls, l_uint32 *bufs1,
117 l_uint32 *bufs2, l_int32 *tabval, l_int32 *tab38,
120 l_uint32 *bufs2, l_int32 *tabval,
121 l_int32 *tab38, l_int32 *tab14,
122 l_int32 lastlineflag);
124 l_int32 **ptab14, l_int32 cliptoblack,
125 l_int32 cliptowhite);
127 l_uint32 *datas, l_int32 wpls, l_int32 *tab);
129 l_uint32 *datas, l_int32 wpls, l_int32 *tab);
132 l_int32 outdepth,
PIXCMAP **pcmap);
134 l_float32 minfract, l_int32 maxsize,
137 #ifndef NO_CONSOLE_IO
138 #define DEBUG_UNROLLING 0
177 PROCNAME(
"pixDitherToBinary");
180 return (
PIX *)ERROR_PTR(
"pixs not defined", procName, NULL);
181 if (pixGetDepth(pixs) != 8)
182 return (
PIX *)ERROR_PTR(
"must be 8 bpp for dithering", procName, NULL);
211 l_int32 w, h, d, wplt, wpld;
212 l_uint32 *datat, *datad;
213 l_uint32 *bufs1, *bufs2;
216 PROCNAME(
"pixDitherToBinarySpec");
219 return (
PIX *)ERROR_PTR(
"pixs not defined", procName, NULL);
222 return (
PIX *)ERROR_PTR(
"must be 8 bpp for dithering", procName, NULL);
223 if (lowerclip < 0 || lowerclip > 255)
224 return (
PIX *)ERROR_PTR(
"invalid value for lowerclip", procName, NULL);
225 if (upperclip < 0 || upperclip > 255)
226 return (
PIX *)ERROR_PTR(
"invalid value for upperclip", procName, NULL);
229 return (
PIX *)ERROR_PTR(
"pixd not made", procName, NULL);
230 pixCopyResolution(pixd, pixs);
231 pixCopyInputFormat(pixd, pixs);
233 wpld = pixGetWpl(pixd);
238 return (
PIX *)ERROR_PTR(
"pixt not made", procName, NULL);
241 wplt = pixGetWpl(pixt);
244 bufs1 = (l_uint32 *)LEPT_CALLOC(wplt,
sizeof(l_uint32));
245 bufs2 = (l_uint32 *)LEPT_CALLOC(wplt,
sizeof(l_uint32));
246 if (!bufs1 || !bufs2) {
251 return (
PIX *)ERROR_PTR(
"bufs1, bufs2 not both made", procName, NULL);
255 lowerclip, upperclip);
285 memcpy(bufs2, datas, 4 * wpls);
286 for (i = 0; i < h - 1; i++) {
287 memcpy(bufs1, bufs2, 4 * wpls);
288 memcpy(bufs2, datas + (i + 1) * wpls, 4 * wpls);
289 lined = datad + i * wpld;
294 memcpy(bufs1, bufs2, 4 * wpls);
295 lined = datad + (h - 1) * wpld;
332 l_int32 lastlineflag)
336 l_uint8 fval1, fval2, rval, bval, dval;
338 if (lastlineflag == 0) {
339 for (j = 0; j < w - 1; j++) {
342 if ((eval = 255 - oval) > upperclip) {
344 fval1 = (3 * eval) / 8;
347 rval = L_MAX(0, rval - fval1);
350 bval = L_MAX(0, bval - fval1);
353 dval = L_MAX(0, dval - fval2);
358 if (oval > lowerclip) {
360 fval1 = (3 * oval) / 8;
363 rval = L_MIN(255, rval + fval1);
366 bval = L_MIN(255, bval + fval1);
369 dval = L_MIN(255, dval + fval2);
378 if ((eval = 255 - oval) > upperclip) {
380 fval1 = (3 * eval) / 8;
382 bval = L_MAX(0, bval - fval1);
387 if (oval > lowerclip) {
389 fval1 = (3 * oval) / 8;
391 bval = L_MIN(255, bval + fval1);
396 for (j = 0; j < w - 1; j++) {
399 if ((eval = 255 - oval) > upperclip) {
401 fval1 = (3 * eval) / 8;
403 rval = L_MAX(0, rval - fval1);
408 if (oval > lowerclip) {
410 fval1 = (3 * oval) / 8;
412 rval = L_MIN(255, rval + fval1);
450 l_int32 d, w, h, wplt, wpld;
451 l_uint32 *datat, *datad;
454 PROCNAME(
"pixThresholdToBinary");
457 return (
PIX *)ERROR_PTR(
"pixs not defined", procName, NULL);
459 if (d != 4 && d != 8)
460 return (
PIX *)ERROR_PTR(
"pixs must be 4 or 8 bpp", procName, NULL);
462 return (
PIX *)ERROR_PTR(
"thresh must be non-negative", procName, NULL);
463 if (d == 4 && thresh > 16)
464 return (
PIX *)ERROR_PTR(
"4 bpp thresh not in {0-16}", procName, NULL);
465 if (d == 8 && thresh > 256)
466 return (
PIX *)ERROR_PTR(
"8 bpp thresh not in {0-256}", procName, NULL);
469 return (
PIX *)ERROR_PTR(
"pixd not made", procName, NULL);
470 pixCopyResolution(pixd, pixs);
471 pixCopyInputFormat(pixd, pixs);
473 wpld = pixGetWpl(pixd);
479 wplt = pixGetWpl(pixt);
480 if (pixGetColormap(pixs) && d == 4) {
508 l_uint32 *lines, *lined;
510 for (i = 0; i < h; i++) {
511 lines = datas + i * wpls;
512 lined = datad + i * wpld;
513 thresholdToBinaryLineLow(lined, w, lines, d, thresh);
523 thresholdToBinaryLineLow(l_uint32 *lined,
529 l_int32 j, k, gval, scount, dcount;
530 l_uint32 sword, dword;
532 PROCNAME(
"thresholdToBinaryLineLow");
538 for (j = 0, scount = 0, dcount = 0; j + 31 < w; j += 32) {
540 for (k = 0; k < 4; k++) {
541 sword = lines[scount++];
543 gval = (sword >> 28) & 0xf;
550 dword |= ((gval - thresh) >> 24) & 128;
551 gval = (sword >> 24) & 0xf;
552 dword |= ((gval - thresh) >> 25) & 64;
553 gval = (sword >> 20) & 0xf;
554 dword |= ((gval - thresh) >> 26) & 32;
555 gval = (sword >> 16) & 0xf;
556 dword |= ((gval - thresh) >> 27) & 16;
557 gval = (sword >> 12) & 0xf;
558 dword |= ((gval - thresh) >> 28) & 8;
559 gval = (sword >> 8) & 0xf;
560 dword |= ((gval - thresh) >> 29) & 4;
561 gval = (sword >> 4) & 0xf;
562 dword |= ((gval - thresh) >> 30) & 2;
564 dword |= ((gval - thresh) >> 31) & 1;
566 lined[dcount++] = dword;
573 sword = lines[scount++];
575 gval = (sword >> 28) & 0xf;
577 dword |= (((gval - thresh) >> 31) & 1) << (31 - (j & 31));
579 lined[dcount] = dword;
582 #define CHECK_BIT(a, b, c) if (GET_DATA_BIT(a, b) != c) { \
583 lept_stderr("Error: mismatch at %d/%d(%d), %d vs %d\n", \
584 j, w, d, GET_DATA_BIT(a, b), c); }
585 for (j = 0; j < w; j++) {
587 CHECK_BIT(lined, j, gval < thresh ? 1 : 0);
593 for (j = 0, scount = 0, dcount = 0; j + 31 < w; j += 32) {
595 for (k = 0; k < 8; k++) {
596 sword = lines[scount++];
598 gval = (sword >> 24) & 0xff;
599 dword |= ((gval - thresh) >> 28) & 8;
600 gval = (sword >> 16) & 0xff;
601 dword |= ((gval - thresh) >> 29) & 4;
602 gval = (sword >> 8) & 0xff;
603 dword |= ((gval - thresh) >> 30) & 2;
605 dword |= ((gval - thresh) >> 31) & 1;
607 lined[dcount++] = dword;
614 sword = lines[scount++];
616 gval = (sword >> 24) & 0xff;
618 dword |= (l_uint64)(((gval - thresh) >> 31) & 1)
621 lined[dcount] = dword;
624 for (j = 0; j < w; j++) {
626 CHECK_BIT(lined, j, gval < thresh ? 1 : 0);
632 L_ERROR(
"src depth not 4 or 8 bpp\n", procName);
658 l_int32 i, j, vals, valg, w, h, d, wpls, wplg, wpld;
659 l_uint32 *datas, *datag, *datad, *lines, *lineg, *lined;
662 PROCNAME(
"pixVarThresholdToBinary");
665 return (
PIX *)ERROR_PTR(
"pixs not defined", procName, NULL);
667 return (
PIX *)ERROR_PTR(
"pixg not defined", procName, NULL);
669 return (
PIX *)ERROR_PTR(
"pix sizes not equal", procName, NULL);
672 return (
PIX *)ERROR_PTR(
"pixs must be 8 bpp", procName, NULL);
675 pixCopyResolution(pixd, pixs);
676 pixCopyInputFormat(pixd, pixs);
678 wpld = pixGetWpl(pixd);
680 wpls = pixGetWpl(pixs);
682 wplg = pixGetWpl(pixg);
683 for (i = 0; i < h; i++) {
684 lines = datas + i * wpls;
685 lineg = datag + i * wplg;
686 lined = datad + i * wpld;
687 for (j = 0; j < w; j++) {
734 PROCNAME(
"pixAdaptThresholdToBinary");
736 if (!pixs || pixGetDepth(pixs) != 8)
737 return (
PIX *)ERROR_PTR(
"pixs undefined or not 8 bpp", procName, NULL);
779 PROCNAME(
"pixAdaptThresholdToBinaryGen");
781 if (!pixs || pixGetDepth(pixs) != 8)
782 return (
PIX *)ERROR_PTR(
"pixs undefined or not 8 bpp", procName, NULL);
785 return (
PIX *)ERROR_PTR(
"pix1 not made", procName, NULL);
786 pixGammaTRC(pix1, pix1, gamma, blackval, whiteval);
820 l_int32 i, j, w, h, d, wplg, wpld;
821 l_uint32 *datag, *datad, *lineg, *lined;
824 PROCNAME(
"pixGenerateMaskByValue");
827 return (
PIX *)ERROR_PTR(
"pixs not defined", procName, NULL);
828 d = pixGetDepth(pixs);
829 if (d != 2 && d != 4 && d != 8)
830 return (
PIX *)ERROR_PTR(
"not 2, 4 or 8 bpp", procName, NULL);
832 if (!usecmap && pixGetColormap(pixs))
837 if (d == 8 && (val < 0 || val > 255)) {
839 return (
PIX *)ERROR_PTR(
"val out of 8 bpp range", procName, NULL);
841 if (d == 4 && (val < 0 || val > 15)) {
843 return (
PIX *)ERROR_PTR(
"val out of 4 bpp range", procName, NULL);
845 if (d == 2 && (val < 0 || val > 3)) {
847 return (
PIX *)ERROR_PTR(
"val out of 2 bpp range", procName, NULL);
851 pixCopyResolution(pixd, pixg);
852 pixCopyInputFormat(pixd, pixs);
854 wplg = pixGetWpl(pixg);
856 wpld = pixGetWpl(pixd);
857 for (i = 0; i < h; i++) {
858 lineg = datag + i * wplg;
859 lined = datad + i * wpld;
860 for (j = 0; j < w; j++) {
913 l_int32 i, j, w, h, d, wplg, wpld, val;
914 l_uint32 *datag, *datad, *lineg, *lined;
917 PROCNAME(
"pixGenerateMaskByBand");
920 return (
PIX *)ERROR_PTR(
"pixs not defined", procName, NULL);
921 d = pixGetDepth(pixs);
922 if (d != 2 && d != 4 && d != 8)
923 return (
PIX *)ERROR_PTR(
"not 2, 4 or 8 bpp", procName, NULL);
924 if (lower < 0 || lower > upper)
925 return (
PIX *)ERROR_PTR(
"lower < 0 or lower > upper!", procName, NULL);
927 if (!usecmap && pixGetColormap(pixs))
932 if (d == 8 && upper > 255) {
934 return (
PIX *)ERROR_PTR(
"d == 8 and upper > 255", procName, NULL);
936 if (d == 4 && upper > 15) {
938 return (
PIX *)ERROR_PTR(
"d == 4 and upper > 15", procName, NULL);
940 if (d == 2 && upper > 3) {
942 return (
PIX *)ERROR_PTR(
"d == 2 and upper > 3", procName, NULL);
946 pixCopyResolution(pixd, pixg);
947 pixCopyInputFormat(pixd, pixs);
949 wplg = pixGetWpl(pixg);
951 wpld = pixGetWpl(pixd);
952 for (i = 0; i < h; i++) {
953 lineg = datag + i * wplg;
954 lined = datad + i * wpld;
955 for (j = 0; j < w; j++) {
963 if (val >= lower && val <= upper)
966 if (val < lower || val > upper)
1023 PROCNAME(
"pixDitherTo2bpp");
1026 return (
PIX *)ERROR_PTR(
"pixs not defined", procName, NULL);
1027 if (pixGetDepth(pixs) != 8)
1028 return (
PIX *)ERROR_PTR(
"must be 8 bpp for dithering", procName, NULL);
1059 l_int32 w, h, d, wplt, wpld;
1060 l_int32 *tabval, *tab38, *tab14;
1061 l_uint32 *datat, *datad;
1062 l_uint32 *bufs1, *bufs2;
1066 PROCNAME(
"pixDitherTo2bppSpec");
1069 return (
PIX *)ERROR_PTR(
"pixs not defined", procName, NULL);
1072 return (
PIX *)ERROR_PTR(
"must be 8 bpp for dithering", procName, NULL);
1073 if (lowerclip < 0 || lowerclip > 255)
1074 return (
PIX *)ERROR_PTR(
"invalid value for lowerclip", procName, NULL);
1075 if (upperclip < 0 || upperclip > 255)
1076 return (
PIX *)ERROR_PTR(
"invalid value for upperclip", procName, NULL);
1078 if ((pixd =
pixCreate(w, h, 2)) == NULL)
1079 return (
PIX *)ERROR_PTR(
"pixd not made", procName, NULL);
1080 pixCopyResolution(pixd, pixs);
1081 pixCopyInputFormat(pixd, pixs);
1083 wpld = pixGetWpl(pixd);
1088 wplt = pixGetWpl(pixt);
1091 bufs1 = (l_uint32 *)LEPT_CALLOC(wplt,
sizeof(l_uint32));
1092 bufs2 = (l_uint32 *)LEPT_CALLOC(wplt,
sizeof(l_uint32));
1093 if (!bufs1 || !bufs2) {
1098 return (
PIX *)ERROR_PTR(
"bufs1, bufs2 not both made", procName, NULL);
1105 tabval, tab38, tab14);
1153 memcpy(bufs2, datas, 4 * wpls);
1154 for (i = 0; i < h - 1; i++) {
1155 memcpy(bufs1, bufs2, 4 * wpls);
1156 memcpy(bufs2, datas + (i + 1) * wpls, 4 * wpls);
1157 lined = datad + i * wpld;
1162 memcpy(bufs1, bufs2, 4 * wpls);
1163 lined = datad + (h - 1) * wpld;
1202 l_int32 lastlineflag)
1205 l_int32 oval, tab38val, tab14val;
1206 l_uint8 rval, bval, dval;
1208 if (lastlineflag == 0) {
1209 for (j = 0; j < w - 1; j++) {
1215 tab38val = tab38[oval];
1216 tab14val = tab14[oval];
1218 rval = L_MAX(0, rval + tab38val);
1219 bval = L_MAX(0, bval + tab38val);
1220 dval = L_MAX(0, dval + tab14val);
1222 rval = L_MIN(255, rval + tab38val);
1223 bval = L_MIN(255, bval + tab38val);
1224 dval = L_MIN(255, dval + tab14val);
1235 tab38val = tab38[oval];
1237 bval = L_MAX(0, bval + tab38val);
1239 bval = L_MIN(255, bval + tab38val);
1242 for (j = 0; j < w - 1; j++) {
1246 tab38val = tab38[oval];
1248 rval = L_MAX(0, rval + tab38val);
1250 rval = L_MIN(255, rval + tab38val);
1276 l_int32 cliptoblack,
1277 l_int32 cliptowhite)
1280 l_int32 *tabval, *tab38, *tab14;
1283 tabval = (l_int32 *)LEPT_CALLOC(256,
sizeof(l_int32));
1284 tab38 = (l_int32 *)LEPT_CALLOC(256,
sizeof(l_int32));
1285 tab14 = (l_int32 *)LEPT_CALLOC(256,
sizeof(l_int32));
1290 for (i = 0; i < 256; i++) {
1291 if (i <= cliptoblack) {
1295 }
else if (i < 43) {
1297 tab38[i] = (3 * i + 4) / 8;
1298 tab14[i] = (i + 2) / 4;
1299 }
else if (i < 85) {
1301 tab38[i] = (3 * (i - 85) - 4) / 8;
1302 tab14[i] = ((i - 85) - 2) / 4;
1303 }
else if (i < 128) {
1305 tab38[i] = (3 * (i - 85) + 4) / 8;
1306 tab14[i] = ((i - 85) + 2) / 4;
1307 }
else if (i < 170) {
1309 tab38[i] = (3 * (i - 170) - 4) / 8;
1310 tab14[i] = ((i - 170) - 2) / 4;
1311 }
else if (i < 213) {
1313 tab38[i] = (3 * (i - 170) + 4) / 8;
1314 tab14[i] = ((i - 170) + 2) / 4;
1315 }
else if (i < 255 - cliptowhite) {
1317 tab38[i] = (3 * (i - 255) - 4) / 8;
1318 tab14[i] = ((i - 255) - 2) / 4;
1383 l_int32 w, h, d, wplt, wpld;
1384 l_uint32 *datat, *datad;
1388 PROCNAME(
"pixThresholdTo2bpp");
1391 return (
PIX *)ERROR_PTR(
"pixs not defined", procName, NULL);
1394 return (
PIX *)ERROR_PTR(
"pixs not 8 bpp", procName, NULL);
1395 if (nlevels < 2 || nlevels > 4)
1396 return (
PIX *)ERROR_PTR(
"nlevels not in {2, 3, 4}", procName, NULL);
1398 if ((pixd =
pixCreate(w, h, 2)) == NULL)
1399 return (
PIX *)ERROR_PTR(
"pixd not made", procName, NULL);
1400 pixCopyResolution(pixd, pixs);
1401 pixCopyInputFormat(pixd, pixs);
1403 wpld = pixGetWpl(pixd);
1413 wplt = pixGetWpl(pixt);
1449 l_uint8 sval1, sval2, sval3, sval4, dval;
1451 l_uint32 *lines, *lined;
1453 for (i = 0; i < h; i++) {
1454 lines = datas + i * wpls;
1455 lined = datad + i * wpld;
1456 for (j = 0; j < wpls; j++) {
1462 dval = (tab[sval1] << 6) | (tab[sval2] << 4) |
1463 (tab[sval3] << 2) | tab[sval4];
1525 l_int32 w, h, d, wplt, wpld;
1526 l_uint32 *datat, *datad;
1530 PROCNAME(
"pixThresholdTo4bpp");
1533 return (
PIX *)ERROR_PTR(
"pixs not defined", procName, NULL);
1536 return (
PIX *)ERROR_PTR(
"pixs not 8 bpp", procName, NULL);
1537 if (nlevels < 2 || nlevels > 16)
1538 return (
PIX *)ERROR_PTR(
"nlevels not in [2,...,16]", procName, NULL);
1540 if ((pixd =
pixCreate(w, h, 4)) == NULL)
1541 return (
PIX *)ERROR_PTR(
"pixd not made", procName, NULL);
1542 pixCopyResolution(pixd, pixs);
1543 pixCopyInputFormat(pixd, pixs);
1545 wpld = pixGetWpl(pixd);
1555 wplt = pixGetWpl(pixt);
1591 l_uint8 sval1, sval2, sval3, sval4;
1594 l_uint32 *lines, *lined;
1596 for (i = 0; i < h; i++) {
1597 lines = datas + i * wpls;
1598 lined = datad + i * wpld;
1599 for (j = 0; j < wpls; j++) {
1605 dval = (tab[sval1] << 12) | (tab[sval2] << 8) |
1606 (tab[sval3] << 4) | tab[sval4];
1642 l_int32 i, j, w, h, wpld, val, newval;
1643 l_uint32 *datad, *lined;
1647 PROCNAME(
"pixThresholdOn8bpp");
1650 return (
PIX *)ERROR_PTR(
"pixs not defined", procName, NULL);
1651 if (pixGetDepth(pixs) != 8)
1652 return (
PIX *)ERROR_PTR(
"pixs not 8 bpp", procName, NULL);
1653 if (nlevels < 2 || nlevels > 256)
1654 return (
PIX *)ERROR_PTR(
"nlevels not in [2,...,256]", procName, NULL);
1657 if (pixGetColormap(pixs))
1673 pixCopyResolution(pixd, pixs);
1674 pixCopyInputFormat(pixd, pixs);
1676 wpld = pixGetWpl(pixd);
1677 for (i = 0; i < h; i++) {
1678 lined = datad + i * wpld;
1679 for (j = 0; j < w; j++) {
1739 const char *edgevals,
1741 l_int32 use_average,
1746 l_int32 w, h, d, i, j, n, wplt, wpld, val, newval;
1747 l_uint32 *datat, *datad, *linet, *lined;
1752 PROCNAME(
"pixThresholdGrayArb");
1755 return (
PIX *)ERROR_PTR(
"pixs not defined", procName, NULL);
1758 return (
PIX *)ERROR_PTR(
"pixs not 8 bpp", procName, NULL);
1760 return (
PIX *)ERROR_PTR(
"edgevals not defined", procName, NULL);
1761 if (outdepth != 0 && outdepth != 2 && outdepth != 4 && outdepth != 8)
1762 return (
PIX *)ERROR_PTR(
"invalid outdepth", procName, NULL);
1769 return (
PIX *)ERROR_PTR(
"more than 256 levels", procName, NULL);
1771 if (outdepth == 0) {
1778 }
else if (n + 1 > (1 << outdepth)) {
1779 L_WARNING(
"outdepth too small; setting to 8 bpp\n", procName);
1793 if ((pixd =
pixCreate(w, h, outdepth)) == NULL) {
1796 return (
PIX *)ERROR_PTR(
"pixd not made", procName, NULL);
1798 pixCopyResolution(pixd, pixs);
1799 pixCopyInputFormat(pixd, pixs);
1802 wpld = pixGetWpl(pixd);
1807 wplt = pixGetWpl(pixt);
1809 if (outdepth == 2) {
1811 }
else if (outdepth == 4) {
1814 for (i = 0; i < h; i++) {
1815 lined = datad + i * wpld;
1816 linet = datat + i * wplt;
1817 for (j = 0; j < w; j++) {
1851 l_int32 i, j, thresh;
1853 tab = (l_int32 *)LEPT_CALLOC(256,
sizeof(l_int32));
1854 for (i = 0; i < 256; i++) {
1855 for (j = 0; j < nlevels; j++) {
1856 thresh = 255 * (2 * j + 1) / (2 * nlevels - 2);
1901 l_int32 i, j, thresh, maxval, quantval;
1903 tab = (l_int32 *)LEPT_CALLOC(256,
sizeof(l_int32));
1904 maxval = (1 << depth) - 1;
1906 nlevels = 1 << depth;
1907 for (i = 0; i < 256; i++) {
1908 for (j = 0; j < nlevels; j++) {
1909 thresh = 255 * (2 * j + 1) / (2 * nlevels - 2);
1911 quantval = maxval * j / (nlevels - 1);
1955 l_int32 i, j, n, jstart, ave, val;
1959 PROCNAME(
"makeGrayQuantTableArb");
1962 return ERROR_INT(
"&tab not defined", procName, 1);
1965 return ERROR_INT(
"&cmap not defined", procName, 1);
1968 return ERROR_INT(
"na not defined", procName, 1);
1970 if (n + 1 > (1 << outdepth))
1971 return ERROR_INT(
"more bins than cmap levels", procName, 1);
1974 return ERROR_INT(
"cmap not made", procName, 1);
1975 tab = (l_int32 *)LEPT_CALLOC(256,
sizeof(l_int32));
1981 for (i = 0; i < n; i++) {
1983 ave = (jstart + val) / 2;
1985 for (j = jstart; j < val; j++)
1991 ave = (jstart + 255) / 2;
1993 for (j = jstart; j < 256; j++)
2027 l_int32 i, j, index, w, h, d, nbins, wpl, factor, val;
2028 l_int32 *bincount, *binave, *binstart;
2029 l_uint32 *line, *data;
2031 PROCNAME(
"makeGrayQuantColormapArb");
2034 return ERROR_INT(
"&cmap not defined", procName, 1);
2037 return ERROR_INT(
"pixs not defined", procName, 1);
2040 return ERROR_INT(
"pixs not 8 bpp", procName, 1);
2042 return ERROR_INT(
"tab not defined", procName, 1);
2043 nbins = tab[255] + 1;
2044 if (nbins > (1 << outdepth))
2045 return ERROR_INT(
"more bins than cmap levels", procName, 1);
2048 if ((bincount = (l_int32 *)LEPT_CALLOC(nbins,
sizeof(l_int32))) == NULL)
2049 return ERROR_INT(
"calloc fail for bincount", procName, 1);
2050 if ((binave = (l_int32 *)LEPT_CALLOC(nbins,
sizeof(l_int32))) == NULL) {
2051 LEPT_FREE(bincount);
2052 return ERROR_INT(
"calloc fail for binave", procName, 1);
2054 factor = (l_int32)(sqrt((l_float64)(w * h) / 30000.) + 0.5);
2055 factor = L_MAX(1, factor);
2057 wpl = pixGetWpl(pixs);
2058 for (i = 0; i < h; i += factor) {
2059 line = data + i * wpl;
2060 for (j = 0; j < w; j += factor) {
2062 bincount[tab[val]]++;
2063 binave[tab[val]] += val;
2068 binstart = (l_int32 *)LEPT_CALLOC(nbins,
sizeof(l_int32));
2069 for (i = 1, index = 1; i < 256; i++) {
2070 if (tab[i] < index)
continue;
2071 if (tab[i] == index)
2072 binstart[index++] = i;
2078 for (i = 0; i < nbins; i++) {
2080 val = binave[i] / bincount[i];
2083 val = (binstart[i] + binstart[i + 1]) / 2;
2085 val = (binstart[i] + 255) / 2;
2090 LEPT_FREE(bincount);
2092 LEPT_FREE(binstart);
2134 l_int32 i, j, w, h, d, wpls, wpld;
2135 l_int32 rref, gref, bref, rval, gval, bval;
2136 l_int32 rmin, gmin, bmin, rmax, gmax, bmax;
2138 l_uint32 *datas, *datad, *lines, *lined;
2141 PROCNAME(
"pixGenerateMaskByBand32");
2144 return (
PIX *)ERROR_PTR(
"pixs not defined", procName, NULL);
2147 return (
PIX *)ERROR_PTR(
"not 32 bpp", procName, NULL);
2148 if (delm < 0 || delp < 0)
2149 return (
PIX *)ERROR_PTR(
"delm and delp must be >= 0", procName, NULL);
2150 if (fractm < 0.0 || fractm > 1.0 || fractp < 0.0 || fractp > 1.0)
2151 return (
PIX *)ERROR_PTR(
"fractm and/or fractp invalid", procName, NULL);
2154 if (fractm == 0.0 && fractp == 0.0) {
2161 }
else if (delm == 0 && delp == 0) {
2162 rmin = (l_int32)((1.0 - fractm) * rref);
2163 gmin = (l_int32)((1.0 - fractm) * gref);
2164 bmin = (l_int32)((1.0 - fractm) * bref);
2165 rmax = rref + (l_int32)(fractp * (255 - rref));
2166 gmax = gref + (l_int32)(fractp * (255 - gref));
2167 bmax = bref + (l_int32)(fractp * (255 - bref));
2169 L_ERROR(
"bad input: either (delm, delp) or (fractm, fractp) "
2170 "must be 0\n", procName);
2175 pixCopyResolution(pixd, pixs);
2176 pixCopyInputFormat(pixd, pixs);
2178 wpls = pixGetWpl(pixs);
2180 wpld = pixGetWpl(pixd);
2181 for (i = 0; i < h; i++) {
2182 lines = datas + i * wpls;
2183 lined = datad + i * wpld;
2184 for (j = 0; j < w; j++) {
2186 rval = (pixel >> L_RED_SHIFT) & 0xff;
2187 if (rval < rmin || rval > rmax)
2189 gval = (pixel >> L_GREEN_SHIFT) & 0xff;
2190 if (gval < gmin || gval > gmax)
2192 bval = (pixel >> L_BLUE_SHIFT) & 0xff;
2193 if (bval < bmin || bval > bmax)
2230 l_int32 i, j, w, h, d, wpls, wpld;
2231 l_int32 rref1, gref1, bref1, rref2, gref2, bref2, rval, gval, bval;
2232 l_uint32 pixel, dist1, dist2;
2233 l_uint32 *datas, *datad, *lines, *lined;
2236 PROCNAME(
"pixGenerateMaskByDiscr32");
2239 return (
PIX *)ERROR_PTR(
"pixs not defined", procName, NULL);
2242 return (
PIX *)ERROR_PTR(
"not 32 bpp", procName, NULL);
2244 return (
PIX *)ERROR_PTR(
"invalid distflag", procName, NULL);
2249 pixCopyResolution(pixd, pixs);
2250 pixCopyInputFormat(pixd, pixs);
2252 wpls = pixGetWpl(pixs);
2254 wpld = pixGetWpl(pixd);
2255 for (i = 0; i < h; i++) {
2256 lines = datas + i * wpls;
2257 lined = datad + i * wpld;
2258 for (j = 0; j < w; j++) {
2262 dist1 = L_ABS(rref1 - rval);
2263 dist2 = L_ABS(rref2 - rval);
2264 dist1 += L_ABS(gref1 - gval);
2265 dist2 += L_ABS(gref2 - gval);
2266 dist1 += L_ABS(bref1 - bval);
2267 dist2 += L_ABS(bref2 - bval);
2269 dist1 = (rref1 - rval) * (rref1 - rval);
2270 dist2 = (rref2 - rval) * (rref2 - rval);
2271 dist1 += (gref1 - gval) * (gref1 - gval);
2272 dist2 += (gref2 - gval) * (gref2 - gval);
2273 dist1 += (bref1 - bval) * (bref1 - bval);
2274 dist2 += (bref2 - bval) * (bref2 - bval);
2345 l_int32 w, h, wd, hd, wm, hm, wpls, wplm, wpld;
2346 l_int32 nc, nestim, i, j, vals, vald;
2348 l_uint32 *datas, *datam, *datad, *lines, *linem, *lined;
2353 PROCNAME(
"pixGrayQuantFromHisto");
2355 if (!pixs || pixGetDepth(pixs) != 8)
2356 return (
PIX *)ERROR_PTR(
"pixs undefined or not 8 bpp", procName, NULL);
2357 if (minfract < 0.01) {
2358 L_WARNING(
"minfract < 0.01; setting to 0.05\n", procName);
2362 L_WARNING(
"maxsize < 2; setting to 10\n", procName);
2365 if ((pixd && !pixm) || (!pixd && pixm))
2366 return (
PIX *)ERROR_PTR(
"(pixd,pixm) not defined together",
2370 if (pixGetDepth(pixm) != 1)
2371 return (
PIX *)ERROR_PTR(
"pixm not 1 bpp", procName, NULL);
2372 if ((cmap = pixGetColormap(pixd)) == NULL)
2373 return (
PIX *)ERROR_PTR(
"pixd not cmapped", procName, NULL);
2375 if (w != wd || h != hd)
2376 return (
PIX *)ERROR_PTR(
"pixs, pixd sizes differ", procName, NULL);
2378 nestim = nc + (l_int32)(1.5 * 255 / maxsize);
2381 L_ERROR(
"Estimate %d colors!\n", procName, nestim);
2382 return (
PIX *)ERROR_PTR(
"probably too many colors", procName, NULL);
2385 if (w != wm || h != hm) {
2386 L_WARNING(
"mask and dest sizes not equal\n", procName);
2399 pixCopyResolution(pixd, pixs);
2400 pixCopyInputFormat(pixd, pixs);
2408 L_ERROR(
"ran out of colors in cmap!\n", procName);
2414 wpls = pixGetWpl(pixs);
2415 wpld = pixGetWpl(pixd);
2417 for (i = 0; i < h; i++) {
2418 lines = datas + i * wpls;
2419 lined = datad + i * wpld;
2420 for (j = 0; j < w; j++) {
2431 wplm = pixGetWpl(pixmr);
2432 for (i = 0; i < h; i++) {
2433 lines = datas + i * wpls;
2434 linem = datam + i * wplm;
2435 lined = datad + i * wpld;
2436 for (j = 0; j < w; j++) {
2477 l_int32 mincount, index, sum, wtsum, span, istart, i, val, ret;
2478 l_int32 *iahisto, *lut;
2481 PROCNAME(
"numaFillCmapFromHisto");
2484 return ERROR_INT(
"&lut not defined", procName, 1);
2487 return ERROR_INT(
"na not defined", procName, 1);
2489 return ERROR_INT(
"cmap not defined", procName, 1);
2492 mincount = (l_int32)(minfract * total);
2494 lut = (l_int32 *)LEPT_CALLOC(256,
sizeof(l_int32));
2511 for (i = 0; i < 256; i++) {
2514 wtsum += i * iahisto[i];
2515 span = i - istart + 1;
2516 if (sum < mincount && span < maxsize)
2525 val = (l_int32)((l_float32)wtsum / (l_float32)sum + 0.5);
2532 if (istart < 256 && sum > 0) {
2533 span = 256 - istart;
2534 val = (l_int32)((l_float32)wtsum / (l_float32)sum + 0.5);
2566 l_int32 i, j, index, w, h, d, depth, wpls, wpld;
2567 l_int32 hascolor, vals, vald;
2569 l_uint32 *datas, *datad, *lines, *lined;
2573 PROCNAME(
"pixGrayQuantFromCmap");
2576 return (
PIX *)ERROR_PTR(
"pixs not defined", procName, NULL);
2577 if (pixGetColormap(pixs) != NULL) {
2578 L_WARNING(
"pixs already has a colormap; returning a copy\n", procName);
2583 return (
PIX *)ERROR_PTR(
"pixs not 8 bpp", procName, NULL);
2585 return (
PIX *)ERROR_PTR(
"cmap not defined", procName, NULL);
2586 if (mindepth != 2 && mindepth != 4 && mindepth != 8)
2587 return (
PIX *)ERROR_PTR(
"invalid mindepth", procName, NULL);
2592 L_WARNING(
"Converting colormap colors to gray\n", procName);
2599 tab = (l_int32 *)LEPT_CALLOC(256,
sizeof(l_int32));
2600 for (i = 0; i < 256; i++) {
2606 depth = L_MAX(depth, mindepth);
2609 pixCopyResolution(pixd, pixs);
2610 pixCopyInputFormat(pixd, pixs);
2613 wpls = pixGetWpl(pixs);
2614 wpld = pixGetWpl(pixd);
2615 for (i = 0; i < h; i++) {
2616 lines = datas + i * wpls;
2617 lined = datad + i * wpld;
2618 for (j = 0; j < w; j++) {
2623 else if (depth == 4)
2655 pixDitherToBinaryLUT(
PIX *pixs,
2659 l_int32 w, h, d, wplt, wpld;
2660 l_int32 *tabval, *tab38, *tab14;
2661 l_uint32 *datat, *datad;
2662 l_uint32 *bufs1, *bufs2;
2665 PROCNAME(
"pixDitherToBinaryLUT");
2668 return (
PIX *)ERROR_PTR(
"pixs not defined", procName, NULL);
2671 return (
PIX *)ERROR_PTR(
"must be 8 bpp for dithering", procName, NULL);
2677 if ((pixd =
pixCreate(w, h, 1)) == NULL)
2678 return (
PIX *)ERROR_PTR(
"pixd not made", procName, NULL);
2679 pixCopyResolution(pixd, pixs);
2680 pixCopyInputFormat(pixd, pixs);
2682 wpld = pixGetWpl(pixd);
2687 wplt = pixGetWpl(pixt);
2690 bufs1 = (l_uint32 *)LEPT_CALLOC(wplt,
sizeof(l_uint32));
2691 bufs2 = (l_uint32 *)LEPT_CALLOC(wplt,
sizeof(l_uint32));
2692 if (!bufs1 || !bufs2) {
2697 return (
PIX *)ERROR_PTR(
"bufs1, bufs2 not both made", procName, NULL);
2701 make8To1DitherTables(&tabval, &tab38, &tab14, lowerclip, upperclip);
2703 ditherToBinaryLUTLow(datad, w, h, wpld, datat, wplt, bufs1, bufs2,
2704 tabval, tab38, tab14);
2729 ditherToBinaryLUTLow(l_uint32 *datad,
2745 memcpy(bufs2, datas, 4 * wpls);
2746 for (i = 0; i < h - 1; i++) {
2747 memcpy(bufs1, bufs2, 4 * wpls);
2748 memcpy(bufs2, datas + (i + 1) * wpls, 4 * wpls);
2749 lined = datad + i * wpld;
2750 ditherToBinaryLineLUTLow(lined, w, bufs1, bufs2,
2751 tabval, tab38, tab14, 0);
2755 memcpy(bufs1, bufs2, 4 * wpls);
2756 lined = datad + (h - 1) * wpld;
2757 ditherToBinaryLineLUTLow(lined, w, bufs1, bufs2, tabval, tab38, tab14, 1);
2775 ditherToBinaryLineLUTLow(l_uint32 *lined,
2782 l_int32 lastlineflag)
2785 l_int32 oval, tab38val, tab14val;
2786 l_uint8 rval, bval, dval;
2788 if (lastlineflag == 0) {
2789 for (j = 0; j < w - 1; j++) {
2796 tab38val = tab38[oval];
2799 tab14val = tab14[oval];
2801 rval = L_MAX(0, rval + tab38val);
2802 bval = L_MAX(0, bval + tab38val);
2803 dval = L_MAX(0, dval + tab14val);
2805 rval = L_MIN(255, rval + tab38val);
2806 bval = L_MIN(255, bval + tab38val);
2807 dval = L_MIN(255, dval + tab14val);
2819 tab38val = tab38[oval];
2821 bval = L_MAX(0, bval + tab38val);
2823 }
else if (tab38val > 0 ) {
2824 bval = L_MIN(255, bval + tab38val);
2828 for (j = 0; j < w - 1; j++) {
2833 tab38val = tab38[oval];
2837 rval = L_MAX(0, rval + tab38val);
2839 rval = L_MIN(255, rval + tab38val);
2864 make8To1DitherTables(l_int32 **ptabval,
2871 l_int32 *tabval, *tab38, *tab14;
2873 PROCNAME(
"make8To1DitherTables");
2875 if (ptabval) *ptabval = NULL;
2876 if (ptab38) *ptab38 = NULL;
2877 if (ptab14) *ptab14 = NULL;
2878 if (!ptabval || !ptab38 || !ptab14)
2879 return ERROR_INT(
"table ptrs not all defined", procName, 1);
2882 tabval = (l_int32 *)LEPT_CALLOC(256,
sizeof(l_int32));
2883 tab38 = (l_int32 *)LEPT_CALLOC(256,
sizeof(l_int32));
2884 tab14 = (l_int32 *)LEPT_CALLOC(256,
sizeof(l_int32));
2885 if (!tabval || !tab38 || !tab14)
2886 return ERROR_INT(
"calloc failure to make small table", procName, 1);
2891 for (i = 0; i < 256; i++) {
2892 if (i <= lowerclip) {
2896 }
else if (i < 128) {
2898 tab38[i] = (3 * i + 4) / 8;
2899 tab14[i] = (i + 2) / 4;
2900 }
else if (i < 255 - upperclip) {
2902 tab38[i] = (3 * (i - 255) + 4) / 8;
2903 tab14[i] = ((i - 255) + 2) / 4;
PIX * pixBackgroundNormSimple(PIX *pixs, PIX *pixim, PIX *pixg)
pixBackgroundNormSimple()
#define GET_DATA_QBIT(pdata, n)
#define SET_DATA_BIT(pdata, n)
#define SET_DATA_DIBIT(pdata, n, val)
#define SET_DATA_TWO_BYTES(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)
void pixcmapDestroy(PIXCMAP **pcmap)
pixcmapDestroy()
l_ok pixcmapHasColor(PIXCMAP *cmap, l_int32 *pcolor)
pixcmapHasColor()
l_int32 pixcmapGetCount(const PIXCMAP *cmap)
pixcmapGetCount()
l_ok pixcmapSetBlackAndWhite(PIXCMAP *cmap, l_int32 setblack, l_int32 setwhite)
pixcmapSetBlackAndWhite()
PIXCMAP * pixcmapCreate(l_int32 depth)
pixcmapCreate()
PIXCMAP * pixcmapColorToGray(PIXCMAP *cmaps, l_float32 rwt, l_float32 gwt, l_float32 bwt)
pixcmapColorToGray()
l_ok pixcmapGetMinDepth(PIXCMAP *cmap, l_int32 *pmindepth)
pixcmapGetMinDepth()
PIXCMAP * pixcmapCreateLinear(l_int32 d, l_int32 nlevels)
pixcmapCreateLinear()
PIXCMAP * pixcmapCopy(const PIXCMAP *cmaps)
pixcmapCopy()
l_ok pixcmapAddColor(PIXCMAP *cmap, l_int32 rval, l_int32 gval, l_int32 bval)
pixcmapAddColor()
l_ok pixcmapGetNearestGrayIndex(PIXCMAP *cmap, l_int32 val, l_int32 *pindex)
pixcmapGetNearestGrayIndex()
PIX * pixGammaTRC(PIX *pixd, PIX *pixs, l_float32 gamma, l_int32 minval, l_int32 maxval)
pixGammaTRC()
PIX * pixGenerateMaskByBand32(PIX *pixs, l_uint32 refval, l_int32 delm, l_int32 delp, l_float32 fractm, l_float32 fractp)
pixGenerateMaskByBand32()
static void thresholdToBinaryLow(l_uint32 *datad, l_int32 w, l_int32 h, l_int32 wpld, l_uint32 *datas, l_int32 d, l_int32 wpls, l_int32 thresh)
thresholdToBinaryLow()
void ditherToBinaryLineLow(l_uint32 *lined, l_int32 w, l_uint32 *bufs1, l_uint32 *bufs2, l_int32 lowerclip, l_int32 upperclip, l_int32 lastlineflag)
ditherToBinaryLineLow()
PIX * pixThresholdTo2bpp(PIX *pixs, l_int32 nlevels, l_int32 cmapflag)
pixThresholdTo2bpp()
static l_int32 make8To2DitherTables(l_int32 **ptabval, l_int32 **ptab38, l_int32 **ptab14, l_int32 cliptoblack, l_int32 cliptowhite)
make8To2DitherTables()
PIX * pixThresholdTo4bpp(PIX *pixs, l_int32 nlevels, l_int32 cmapflag)
pixThresholdTo4bpp()
static void thresholdTo4bppLow(l_uint32 *datad, l_int32 h, l_int32 wpld, l_uint32 *datas, l_int32 wpls, l_int32 *tab)
thresholdTo4bppLow()
static l_int32 makeGrayQuantColormapArb(PIX *pixs, l_int32 *tab, l_int32 outdepth, PIXCMAP **pcmap)
makeGrayQuantColormapArb()
PIX * pixGrayQuantFromCmap(PIX *pixs, PIXCMAP *cmap, l_int32 mindepth)
pixGrayQuantFromCmap()
static void ditherTo2bppLow(l_uint32 *datad, l_int32 w, l_int32 h, l_int32 wpld, l_uint32 *datas, l_int32 wpls, l_uint32 *bufs1, l_uint32 *bufs2, l_int32 *tabval, l_int32 *tab38, l_int32 *tab14)
ditherTo2bppLow()
PIX * pixThresholdOn8bpp(PIX *pixs, l_int32 nlevels, l_int32 cmapflag)
pixThresholdOn8bpp()
PIX * pixDitherTo2bpp(PIX *pixs, l_int32 cmapflag)
pixDitherTo2bpp()
PIX * pixGenerateMaskByValue(PIX *pixs, l_int32 val, l_int32 usecmap)
pixGenerateMaskByValue()
l_int32 * makeGrayQuantIndexTable(l_int32 nlevels)
makeGrayQuantIndexTable()
PIX * pixAdaptThresholdToBinary(PIX *pixs, PIX *pixm, l_float32 gamma)
pixAdaptThresholdToBinary()
PIX * pixGenerateMaskByBand(PIX *pixs, l_int32 lower, l_int32 upper, l_int32 inband, l_int32 usecmap)
pixGenerateMaskByBand()
PIX * pixGenerateMaskByDiscr32(PIX *pixs, l_uint32 refval1, l_uint32 refval2, l_int32 distflag)
pixGenerateMaskByDiscr32()
static void ditherToBinaryLow(l_uint32 *datad, l_int32 w, l_int32 h, l_int32 wpld, l_uint32 *datas, l_int32 wpls, l_uint32 *bufs1, l_uint32 *bufs2, l_int32 lowerclip, l_int32 upperclip)
ditherToBinaryLow()
static l_int32 * makeGrayQuantTargetTable(l_int32 nlevels, l_int32 depth)
makeGrayQuantTargetTable()
PIX * pixThresholdGrayArb(PIX *pixs, const char *edgevals, l_int32 outdepth, l_int32 use_average, l_int32 setblack, l_int32 setwhite)
pixThresholdGrayArb()
PIX * pixVarThresholdToBinary(PIX *pixs, PIX *pixg)
pixVarThresholdToBinary()
PIX * pixDitherToBinarySpec(PIX *pixs, l_int32 lowerclip, l_int32 upperclip)
pixDitherToBinarySpec()
PIX * pixDitherTo2bppSpec(PIX *pixs, l_int32 lowerclip, l_int32 upperclip, l_int32 cmapflag)
pixDitherTo2bppSpec()
PIX * pixDitherToBinary(PIX *pixs)
pixDitherToBinary()
static l_int32 numaFillCmapFromHisto(NUMA *na, PIXCMAP *cmap, l_float32 minfract, l_int32 maxsize, l_int32 **plut)
numaFillCmapFromHisto()
static void thresholdTo2bppLow(l_uint32 *datad, l_int32 h, l_int32 wpld, l_uint32 *datas, l_int32 wpls, l_int32 *tab)
thresholdTo2bppLow()
l_ok makeGrayQuantTableArb(NUMA *na, l_int32 outdepth, l_int32 **ptab, PIXCMAP **pcmap)
makeGrayQuantTableArb()
static void ditherTo2bppLineLow(l_uint32 *lined, l_int32 w, l_uint32 *bufs1, l_uint32 *bufs2, l_int32 *tabval, l_int32 *tab38, l_int32 *tab14, l_int32 lastlineflag)
ditherTo2bppLineLow()
PIX * pixGrayQuantFromHisto(PIX *pixd, PIX *pixs, PIX *pixm, l_float32 minfract, l_int32 maxsize)
pixGrayQuantFromHisto()
PIX * pixThresholdToBinary(PIX *pixs, l_int32 thresh)
pixThresholdToBinary()
PIX * pixAdaptThresholdToBinaryGen(PIX *pixs, PIX *pixm, l_float32 gamma, l_int32 blackval, l_int32 whiteval, l_int32 thresh)
pixAdaptThresholdToBinaryGen()
NUMA * parseStringForNumbers(const char *str, const char *seps)
parseStringForNumbers()
void numaDestroy(NUMA **pna)
numaDestroy()
l_int32 numaGetCount(NUMA *na)
numaGetCount()
l_ok numaGetIValue(NUMA *na, l_int32 index, l_int32 *pival)
numaGetIValue()
l_int32 * numaGetIArray(NUMA *na)
numaGetIArray()
NUMA * numaSort(NUMA *naout, NUMA *nain, l_int32 sortorder)
numaSort()
l_ok numaGetSum(NUMA *na, l_float32 *psum)
numaGetSum()
l_uint32 * pixGetData(PIX *pix)
pixGetData()
l_ok pixSetColormap(PIX *pix, PIXCMAP *colormap)
pixSetColormap()
void pixDestroy(PIX **ppix)
pixDestroy()
l_ok pixGetDimensions(const PIX *pix, l_int32 *pw, l_int32 *ph, l_int32 *pd)
pixGetDimensions()
l_int32 pixSizesEqual(const PIX *pix1, const PIX *pix2)
pixSizesEqual()
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()
void extractRGBValues(l_uint32 pixel, l_int32 *prval, l_int32 *pgval, l_int32 *pbval)
extractRGBValues()
NUMA * pixGetGrayHistogramMasked(PIX *pixs, PIX *pixm, l_int32 x, l_int32 y, l_int32 factor)
pixGetGrayHistogramMasked()
@ REMOVE_CMAP_TO_GRAYSCALE
PIX * pixRemoveColormap(PIX *pixs, l_int32 type)
pixRemoveColormap()
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()
void lept_stderr(const char *fmt,...)
lept_stderr()