152 #include <config_auto.h> 155 #include "allheaders.h" 211 l_int32
w,
h, i, j, wpl1, wplr, wplg, wplb;
212 l_int32 rval, gval, bval, rgdiff, rbdiff, gbdiff, maxval, colorval;
214 l_uint32 *data1, *datar, *datag, *datab, *line1, *liner, *lineg, *lineb;
215 PIX *pix1, *pixr, *pixg, *pixb;
217 PROCNAME(
"pixColorContent");
219 if (!ppixr && !ppixg && !ppixb)
220 return ERROR_INT(
"no return val requested", procName, 1);
221 if (ppixr) *ppixr = NULL;
222 if (ppixg) *ppixg = NULL;
223 if (ppixb) *ppixb = NULL;
225 return ERROR_INT(
"pixs not defined", procName, 1);
226 if (mingray < 0) mingray = 0;
228 return ERROR_INT(
"mingray > 255", procName, 1);
232 return ERROR_INT(
"pix1 not returned", procName, 1);
234 pixr = pixg = pixb = NULL;
239 wplr = pixGetWpl(pixr);
245 wplg = pixGetWpl(pixg);
251 wplb = pixGetWpl(pixb);
256 wpl1 = pixGetWpl(pix1);
257 for (i = 0; i <
h; i++) {
258 line1 = data1 + i * wpl1;
260 liner = datar + i * wplr;
262 lineg = datag + i * wplg;
264 lineb = datab + i * wplb;
265 for (j = 0; j <
w; j++) {
269 maxval = L_MAX(rval, gval);
270 maxval = L_MAX(maxval, bval);
271 if (maxval < mingray)
274 rgdiff = L_ABS(rval - gval);
275 rbdiff = L_ABS(rval - bval);
276 gbdiff = L_ABS(gval - bval);
278 colorval = (rgdiff + rbdiff) / 2;
282 colorval = (rgdiff + gbdiff) / 2;
286 colorval = (rbdiff + gbdiff) / 2;
368 l_int32
w,
h, i, j, wpl1, wpld;
369 l_int32 rval, gval, bval, rdist, gdist, bdist, colorval;
370 l_int32 rgdist, rbdist, gbdist, mindist, maxdist, minval, maxval;
372 l_uint32 *data1, *datad, *line1, *lined;
375 PROCNAME(
"pixColorMagnitude");
378 return (
PIX *)ERROR_PTR(
"pixs not defined", procName, NULL);
381 return (
PIX *)ERROR_PTR(
"invalid type", procName, NULL);
385 return (
PIX *)ERROR_PTR(
"pix1 not returned", procName, NULL);
390 wpld = pixGetWpl(pixd);
392 wpl1 = pixGetWpl(pix1);
393 for (i = 0; i <
h; i++) {
394 line1 = data1 + i * wpl1;
395 lined = datad + i * wpld;
396 for (j = 0; j <
w; j++) {
400 rgdist = L_ABS(rval - gval);
401 rbdist = L_ABS(rval - bval);
402 gbdist = L_ABS(gval - bval);
403 maxdist = L_MAX(rgdist, rbdist);
404 if (gbdist >= maxdist) {
407 mindist = L_MIN(rgdist, rbdist);
408 colorval = L_MAX(mindist, gbdist);
411 rdist = ((gval + bval ) / 2 - rval);
412 rdist = L_ABS(rdist);
413 gdist = ((rval + bval ) / 2 - gval);
414 gdist = L_ABS(gdist);
415 bdist = ((rval + gval ) / 2 - bval);
416 bdist = L_ABS(bdist);
417 colorval = L_MAX(rdist, gdist);
418 colorval = L_MAX(colorval, bdist);
420 minval = L_MIN(rval, gval);
421 minval = L_MIN(minval, bval);
422 maxval = L_MAX(rval, gval);
423 maxval = L_MAX(maxval, bval);
424 colorval = maxval - minval;
499 l_float32 *ppixfract,
500 l_float32 *pcolorfract)
502 l_int32 i, j,
w,
h, wpl, rval, gval, bval, minval, maxval;
503 l_int32 total, npix, ncolor;
505 l_uint32 *data, *line;
507 PROCNAME(
"pixColorFraction");
509 if (ppixfract) *ppixfract = 0.0;
510 if (pcolorfract) *pcolorfract = 0.0;
511 if (!ppixfract || !pcolorfract)
512 return ERROR_INT(
"&pixfract and &colorfract not defined",
514 if (!pixs || pixGetDepth(pixs) != 32)
515 return ERROR_INT(
"pixs not defined or not 32 bpp", procName, 1);
519 wpl = pixGetWpl(pixs);
520 npix = ncolor = total = 0;
521 for (i = 0; i <
h; i += factor) {
522 line = data + i * wpl;
523 for (j = 0; j <
w; j += factor) {
527 minval = L_MIN(rval, gval);
528 minval = L_MIN(minval, bval);
529 if (minval > lightthresh)
531 maxval = L_MAX(rval, gval);
532 maxval = L_MAX(maxval, bval);
533 if (maxval < darkthresh)
537 if (maxval - minval >= diffthresh)
543 L_WARNING(
"No pixels found for consideration\n", procName);
546 *ppixfract = (l_float32)npix / (l_float32)total;
547 *pcolorfract = (l_float32)ncolor / (l_float32)npix;
588 l_int32
w,
h, i, j, wpl1, wpl2, rval, gval, bval;
589 l_int32 *rtab, *gtab, *btab;
591 l_uint32 *data1, *data2, *line1, *line2;
592 NUMA *nar, *nag, *nab;
596 PROCNAME(
"pixColorShiftWhitePoint");
599 return (
PIX *)ERROR_PTR(
"pixs not defined", procName, NULL);
601 cmap = pixGetColormap(pixs);
602 if (!cmap && pixGetDepth(pixs) != 32)
603 return (
PIX *)ERROR_PTR(
"pixs neither cmapped nor 32 bpp",
610 if (!rref && !gref && !bref)
614 if ((rref < 0 || gref < 0 || bref < 0) || (rref * gref * bref == 0)) {
615 L_WARNING(
"invalid set of ref values\n", procName);
623 wpl1 = pixGetWpl(pix1);
625 wpl2 = pixGetWpl(pix2);
632 for (i = 0; i <
h; i++) {
633 line1 = data1 + i * wpl1;
634 line2 = data2 + i * wpl2;
635 for (j = 0; j <
w; j++) {
692 l_int32
w,
h, d, i, j, wpls, wpld, size;
693 l_int32 rval, gval, bval, minval, maxval;
694 l_uint32 *datas, *datad, *lines, *lined;
698 PROCNAME(
"pixMaskOverColorPixels");
701 return (
PIX *)ERROR_PTR(
"pixs not defined", procName, NULL);
704 cmap = pixGetColormap(pixs);
705 if (!cmap && d != 32)
706 return (
PIX *)ERROR_PTR(
"pixs not cmapped or 32 bpp", procName, NULL);
711 if (!pixc || pixGetDepth(pixc) != 32) {
713 return (
PIX *)ERROR_PTR(
"rgb pix not made", procName, NULL);
718 wpld = pixGetWpl(pixd);
720 wpls = pixGetWpl(pixc);
721 for (i = 0; i <
h; i++) {
722 lines = datas + i * wpls;
723 lined = datad + i * wpld;
724 for (j = 0; j <
w; j++) {
726 minval = L_MIN(rval, gval);
727 minval = L_MIN(minval, bval);
728 maxval = L_MAX(rval, gval);
729 maxval = L_MAX(maxval, bval);
730 if (maxval - minval >= threshdiff)
736 size = 2 * (mindist - 1) + 1;
774 l_int32
w,
h, i, j, wpls, wpld;
775 l_int32 rval, gval, bval, minrg, min, maxrg, max, sat;
776 l_uint32 *datas, *datad, *lines, *lined;
779 PROCNAME(
"pixMaskOverGrayPixels");
781 if (!pixs || pixGetDepth(pixs) != 32)
782 return (
PIX *)ERROR_PTR(
"pixs undefined or not 32 bpp", procName, NULL);
783 if (maxlimit < 0 || maxlimit > 255)
784 return (
PIX *)ERROR_PTR(
"invalid maxlimit", procName, NULL);
786 return (
PIX *)ERROR_PTR(
"invalid satlimit", procName, NULL);
790 wpls = pixGetWpl(pixs);
792 return (
PIX *)ERROR_PTR(
"pixd not made", procName, NULL);
794 wpld = pixGetWpl(pixd);
796 for (i = 0; i <
h; i++) {
797 lines = datas + i * wpls;
798 lined = datad + i * wpld;
799 for (j = 0; j <
w; j++) {
801 minrg = L_MIN(rval, gval);
802 min = L_MIN(minrg, bval);
803 maxrg = L_MAX(rval, gval);
804 max = L_MAX(maxrg, bval);
806 if (max <= maxlimit && sat <= satlimit)
836 l_int32
w,
h, d, i, j, wpls, wpld;
837 l_int32 rval, gval, bval;
838 l_uint32 *datas, *datad, *lines, *lined;
842 PROCNAME(
"pixMaskOverColorRange");
845 return (
PIX *)ERROR_PTR(
"pixs not defined", procName, NULL);
848 cmap = pixGetColormap(pixs);
849 if (!cmap && d != 32)
850 return (
PIX *)ERROR_PTR(
"pixs not cmapped or 32 bpp", procName, NULL);
858 wpld = pixGetWpl(pixd);
860 wpls = pixGetWpl(pixc);
861 for (i = 0; i <
h; i++) {
862 lines = datas + i * wpls;
863 lined = datad + i * wpld;
864 for (j = 0; j <
w; j++) {
866 if (rval < rmin || rval > rmax)
continue;
867 if (gval < gmin || gval > gmax)
continue;
868 if (bval < bmin || bval > bmax)
continue;
955 l_float32 *pcolorfract,
960 l_int32
w,
h, count, rval, gval, bval, aveval, proceed;
964 PIX *pix1, *pix2, *pix3, *pix4, *pix5, *pixm1, *pixm2, *pixm3;
966 PROCNAME(
"pixFindColorRegions");
968 if (pcolormask1) *pcolormask1 = NULL;
969 if (pcolormask2) *pcolormask2 = NULL;
971 return ERROR_INT(
"&colorfract not defined", procName, 1);
973 if (!pixs || pixGetDepth(pixs) != 32)
974 return ERROR_INT(
"pixs not defined or not 32 bpp", procName, 1);
975 if (factor < 1) factor = 1;
976 if (lightthresh < 0) lightthresh = 210;
977 if (darkthresh < 0) darkthresh = 70;
978 if (mindiff < 0) mindiff = 10;
979 if (colordiff < 0) colordiff = 90;
980 if (edgefract < 0.0 || edgefract > 1.0) edgefract = 0.05;
986 if (pixadb) L_INFO(
"pixm has big fg: %f5.2\n", procName, ratio);
996 return ERROR_INT(
"rank color array not made", procName, 1);
998 if (pixadb) L_INFO(
"lightest background color: (r,g,b) = (%d,%d,%d)\n",
999 procName, rval, gval, bval);
1001 if ((rval < bval - 2) || (rval < gval - 2)) {
1002 if (pixadb) L_INFO(
"background not reddish\n", procName);
1005 aveval = (rval + gval + bval) / 3;
1006 if (aveval < lightthresh) {
1007 if (pixadb) L_INFO(
"background too dark\n", procName);
1015 if (proceed == FALSE)
return 0;
1027 pixOr(pixm1, pixm1, pixm);
1040 pixOr(pixm2, pixm2, pix1);
1046 pixOr(pixm2, pixm2, pix2);
1066 if (edgefract > 0.0) {
1068 pixAnd(pixm3, pixm3, pix2);
1075 *pcolorfract = (l_float32)count / ((l_float32)(
w) *
h);
1078 L_INFO(
"no light color pixels found\n", procName);
1080 L_INFO(
"fraction of light color pixels = %5.3f\n", procName,
1085 if (pixadb && count > 0) {
1117 if (pcolormask2 && count > 0)
1119 if (pcolormask1 && count > 0)
1120 *pcolormask1 = pixm3;
1165 l_int32 lightthresh,
1170 l_int32 i,
w,
h, count, mincount, ncolors;
1173 PROCNAME(
"pixNumSignificantGrayColors");
1176 return ERROR_INT(
"&ncolors not defined", procName, 1);
1178 if (!pixs || pixGetDepth(pixs) != 8)
1179 return ERROR_INT(
"pixs not defined or not 8 bpp", procName, 1);
1180 if (darkthresh < 0) darkthresh = 20;
1181 if (lightthresh < 0) lightthresh = 236;
1182 if (minfract < 0.0) minfract = 0.0001;
1184 return ERROR_INT(
"minfract > 1.0", procName, 1);
1185 if (minfract >= 0.001)
1186 L_WARNING(
"minfract too big; likely to underestimate ncolors\n",
1188 if (lightthresh > 255 || darkthresh >= lightthresh)
1189 return ERROR_INT(
"invalid thresholds", procName, 1);
1190 if (factor < 1) factor = 1;
1193 mincount = (l_int32)(minfract *
w *
h * factor * factor);
1195 return ERROR_INT(
"na not made", procName, 1);
1197 for (i = darkthresh; i <= lightthresh; i++) {
1199 if (count >= mincount)
1203 *pncolors = ncolors;
1292 l_int32
w,
h, d, minside, factor;
1293 l_float32 pixfract, colorfract;
1294 PIX *pixt, *pixsc, *pixg, *pixe, *pixb, *pixm;
1297 PROCNAME(
"pixColorsForQuantization");
1299 if (piscolor) *piscolor = 0;
1301 return ERROR_INT(
"&ncolors not defined", procName, 1);
1304 return ERROR_INT(
"pixs not defined", procName, 1);
1305 if ((cmap = pixGetColormap(pixs)) != NULL) {
1313 if (d != 8 && d != 32)
1314 return ERROR_INT(
"pixs not 8 or 32 bpp", procName, 1);
1323 minside = L_MIN(
w,
h);
1327 factor = L_MAX(1, minside / 400);
1329 if (pixfract * colorfract < 0.00025) {
1344 factor = L_MAX(1, minside / 500);
1347 else if (factor == 2 || factor == 3)
1384 if (debug) pixWrite(
"junkpix8.png", pixg, IFF_PNG);
1388 if (debug) pixWrite(
"junkpix32.png", pixsc, IFF_PNG);
1432 l_int32
w,
h, d, i, j, wpl, hashsize, sum, count, manycolors;
1433 l_int32 rval, gval, bval, val;
1436 l_uint32 *data, *line;
1439 PROCNAME(
"pixNumColors");
1442 return ERROR_INT(
"&ncolors not defined", procName, 1);
1445 return ERROR_INT(
"pixs not defined", procName, 1);
1447 if (d != 2 && d != 4 && d != 8 && d != 32)
1448 return ERROR_INT(
"d not in {2, 4, 8, 32}", procName, 1);
1449 if (factor < 1) factor = 1;
1452 wpl = pixGetWpl(pixs);
1455 inta = (l_int32 *)LEPT_CALLOC(256,
sizeof(l_int32));
1456 for (i = 0; i <
h; i += factor) {
1457 line = data + i * wpl;
1458 for (j = 0; j <
w; j += factor) {
1468 for (i = 0; i < 256; i++)
1473 cmap = pixGetColormap(pixs);
1474 if (cmap && factor == 1) {
1477 L_WARNING(
"colormap size %d differs from actual colors\n",
1485 inta = (l_int32 *)LEPT_CALLOC(hashsize,
sizeof(l_int32));
1487 for (i = 0; i <
h && manycolors == 0; i += factor) {
1488 line = data + i * wpl;
1489 for (j = 0; j <
w; j += factor) {
1492 val = (137 * rval + 269 * gval + 353 * bval) % hashsize;
1493 if (inta[val] == 0) {
1505 if (manycolors == 0) {
1533 l_int32
w,
h, d, i, j, wpls, wpld, hashsize, hashval, ncolors, index;
1534 l_int32 rval, gval, bval, val;
1535 l_int32 *hasha1, *hasha2;
1537 l_uint32 *datas, *lines, *datad, *lined;
1541 PROCNAME(
"pixConvertRGBToCmapLossless");
1543 if (!pixs || pixGetDepth(pixs) != 32)
1544 return (
PIX *)ERROR_PTR(
"pixs undefined or not 32 bpp", procName, NULL);
1547 if (ncolors > 256) {
1548 L_ERROR(
"too many colors found: %d\n", procName, ncolors);
1555 else if (ncolors <= 4)
1557 else if (ncolors <= 16)
1563 return (
PIX *)ERROR_PTR(
"pixd not made", procName, NULL);
1566 wpls = pixGetWpl(pixs);
1568 wpld = pixGetWpl(pixd);
1575 hasha1 = (l_int32 *)LEPT_CALLOC(hashsize,
sizeof(l_int32));
1576 hasha2 = (l_int32 *)LEPT_CALLOC(hashsize,
sizeof(l_int32));
1578 for (i = 0; i <
h; i++) {
1579 lines = datas + i * wpls;
1580 lined = datad + i * wpld;
1581 for (j = 0; j <
w; j++) {
1584 hashval = (137 * rval + 269 * gval + 353 * bval) % hashsize;
1585 if (hasha1[hashval] == 0) {
1586 hasha1[hashval] = 1;
1588 hasha2[hashval] = index;
1591 val = hasha2[hashval];
1635 l_int32
n, i, rgbindex, rval, gval, bval;
1636 NUMA *nahisto, *naindex;
1638 PROCNAME(
"pixGetMostPopulatedColors");
1640 if (!parray && !pcmap)
1641 return ERROR_INT(
"no return val requested", procName, 1);
1642 if (parray) *parray = NULL;
1643 if (pcmap) *pcmap = NULL;
1644 if (!pixs || pixGetDepth(pixs) != 32)
1645 return ERROR_INT(
"pixs not defined", procName, 1);
1646 if (sigbits < 2 || sigbits > 6)
1647 return ERROR_INT(
"sigbits not in [2 ... 6]", procName, 1);
1648 if (factor < 1 || ncolors < 1)
1649 return ERROR_INT(
"factor < 1 or ncolors < 1", procName, 1);
1652 return ERROR_INT(
"nahisto not made", procName, 1);
1658 return ERROR_INT(
"naindex not made", procName, 1);
1661 ncolors = L_MIN(
n, ncolors);
1662 if (parray) *parray = (l_uint32 *)LEPT_CALLOC(ncolors,
sizeof(l_uint32));
1664 for (i = 0; i < ncolors; i++) {
1714 PROCNAME(
"pixSimpleColorQuantize");
1716 if (!pixs || pixGetDepth(pixs) != 32)
1717 return (
PIX *)ERROR_PTR(
"pixs not defined", procName, NULL);
1718 if (sigbits < 2 || sigbits > 4)
1719 return (
PIX *)ERROR_PTR(
"sigbits not in {2,3,4}", procName, NULL);
1755 l_int32
w,
h, i, j, size, wpl, rval, gval, bval, npts;
1756 l_uint32 val32, rgbindex;
1758 l_uint32 *data, *line, *rtab, *gtab, *btab;
1761 PROCNAME(
"pixGetRGBHistogram");
1763 if (!pixs || pixGetDepth(pixs) != 32)
1764 return (
NUMA *)ERROR_PTR(
"pixs not defined", procName, NULL);
1765 if (sigbits < 2 || sigbits > 6)
1766 return (
NUMA *)ERROR_PTR(
"sigbits not in [2 ... 6]", procName, NULL);
1768 return (
NUMA *)ERROR_PTR(
"factor < 1", procName, NULL);
1771 size = 1 << (3 * sigbits);
1779 npts = ((
w + factor - 1) / factor) * ((
h + factor - 1) / factor);
1781 L_WARNING(
"only sampling %d pixels\n", procName, npts);
1782 wpl = pixGetWpl(pixs);
1784 for (i = 0; i <
h; i += factor) {
1785 line = data + i * wpl;
1786 for (j = 0; j <
w; j += factor) {
1787 val32 = *(line + j);
1789 rgbindex = rtab[rval] | gtab[gval] | btab[bval];
1825 l_uint32 *rtab, *gtab, *btab;
1827 PROCNAME(
"makeRGBIndexTables");
1829 if (prtab) *prtab = NULL;
1830 if (pgtab) *pgtab = NULL;
1831 if (pbtab) *pbtab = NULL;
1832 if (!prtab || !pgtab || !pbtab)
1833 return ERROR_INT(
"not all table ptrs defined", procName, 1);
1834 if (sigbits < 2 || sigbits > 6)
1835 return ERROR_INT(
"sigbits not in [2 ... 6]", procName, 1);
1837 rtab = (l_uint32 *)LEPT_CALLOC(256,
sizeof(l_uint32));
1838 gtab = (l_uint32 *)LEPT_CALLOC(256,
sizeof(l_uint32));
1839 btab = (l_uint32 *)LEPT_CALLOC(256,
sizeof(l_uint32));
1840 if (!rtab || !gtab || !btab)
1841 return ERROR_INT(
"calloc fail for tab", procName, 1);
1847 for (i = 0; i < 256; i++) {
1848 rtab[i] = (i & 0xc0) >> 2;
1849 gtab[i] = (i & 0xc0) >> 4;
1850 btab[i] = (i & 0xc0) >> 6;
1854 for (i = 0; i < 256; i++) {
1855 rtab[i] = (i & 0xe0) << 1;
1856 gtab[i] = (i & 0xe0) >> 2;
1857 btab[i] = (i & 0xe0) >> 5;
1861 for (i = 0; i < 256; i++) {
1862 rtab[i] = (i & 0xf0) << 4;
1863 gtab[i] = (i & 0xf0);
1864 btab[i] = (i & 0xf0) >> 4;
1868 for (i = 0; i < 256; i++) {
1869 rtab[i] = (i & 0xf8) << 7;
1870 gtab[i] = (i & 0xf8) << 2;
1871 btab[i] = (i & 0xf8) >> 3;
1875 for (i = 0; i < 256; i++) {
1876 rtab[i] = (i & 0xfc) << 10;
1877 gtab[i] = (i & 0xfc) << 4;
1878 btab[i] = (i & 0xfc) >> 2;
1882 L_ERROR(
"Illegal sigbits = %d\n", procName, sigbits);
1883 return ERROR_INT(
"sigbits not in [2 ... 6]", procName, 1);
1915 PROCNAME(
"getRGBFromIndex");
1917 if (prval) *prval = 0;
1918 if (pgval) *pgval = 0;
1919 if (pbval) *pbval = 0;
1920 if (!prval || !pgval || !pbval)
1921 return ERROR_INT(
"not all component ptrs defined", procName, 1);
1922 if (sigbits < 2 || sigbits > 6)
1923 return ERROR_INT(
"sigbits not in [2 ... 6]", procName, 1);
1927 *prval = ((index << 2) & 0xc0) | 0x20;
1928 *pgval = ((index << 4) & 0xc0) | 0x20;
1929 *pbval = ((index << 6) & 0xc0) | 0x20;
1932 *prval = ((index >> 1) & 0xe0) | 0x10;
1933 *pgval = ((index << 2) & 0xe0) | 0x10;
1934 *pbval = ((index << 5) & 0xe0) | 0x10;
1937 *prval = ((index >> 4) & 0xf0) | 0x08;
1938 *pgval = (index & 0xf0) | 0x08;
1939 *pbval = ((index << 4) & 0xf0) | 0x08;
1942 *prval = ((index >> 7) & 0xf8) | 0x04;
1943 *pgval = ((index >> 2) & 0xf8) | 0x04;
1944 *pbval = ((index << 3) & 0xf8) | 0x04;
1947 *prval = ((index >> 10) & 0xfc) | 0x02;
1948 *pgval = ((index >> 4) & 0xfc) | 0x02;
1949 *pbval = ((index << 2) & 0xfc) | 0x02;
1952 L_ERROR(
"Illegal sigbits = %d\n", procName, sigbits);
1953 return ERROR_INT(
"sigbits not in [2 ... 6]", procName, 1);
2000 l_float32 fract, ratio;
2001 PIX *pix1, *pix2, *pix3, *pix4;
2004 PROCNAME(
"pixHasHighlightRed");
2006 if (pratio) *pratio = 0.0;
2007 if (ppixdb) *ppixdb = NULL;
2008 if (phasred) *phasred = 0;
2009 if (!pratio && !ppixdb)
2010 return ERROR_INT(
"no return val requested", procName, 1);
2012 return ERROR_INT(
"&hasred not defined", procName, 1);
2013 if (!pixs || pixGetDepth(pixs) != 32)
2014 return ERROR_INT(
"pixs not defined or not 32 bpp", procName, 1);
2015 if (minfract <= 0.0)
2016 return ERROR_INT(
"minfract must be > 0.0", procName, 1);
2017 if (fthresh < 1.5 || fthresh > 3.5)
2018 L_WARNING(
"fthresh = %f is out of normal bounds\n", procName, fthresh);
2035 pixAnd(pix4, pix4, pix2);
2037 ratio = fract / minfract;
2038 L_INFO(
"fract = %7.5f, ratio = %7.3f\n", procName, fract, ratio);
2039 if (pratio) *pratio = ratio;
PIX * pixMaskOverColorPixels(PIX *pixs, l_int32 threshdiff, l_int32 mindist)
pixMaskOverColorPixels()
PIX * pixConvertRGBToLuminance(PIX *pixs)
pixConvertRGBToLuminance()
NUMA * pixGetGrayHistogram(PIX *pixs, l_int32 factor)
pixGetGrayHistogram()
PIX * pixRemoveColormap(PIX *pixs, l_int32 type)
pixRemoveColormap()
PIX * pixConvertRGBToBinaryArb(PIX *pixs, l_float32 rc, l_float32 gc, l_float32 bc, l_int32 thresh, l_int32 relation)
pixConvertRGBToBinaryArb()
PIX * fpixThresholdToPix(FPIX *fpix, l_float32 thresh)
fpixThresholdToPix()
l_ok pixSetMasked(PIX *pixd, PIX *pixm, l_uint32 val)
pixSetMasked()
PIX * pixCreateTemplate(const PIX *pixs)
pixCreateTemplate()
NUMA * numaGammaTRC(l_float32 gamma, l_int32 minval, l_int32 maxval)
numaGammaTRC()
l_ok pixCountRGBColorsByHash(PIX *pixs, l_int32 *pncolors)
pixCountRGBColorsByHash()
PIX * pixCopy(PIX *pixd, const PIX *pixs)
pixCopy()
NUMA * numaMakeConstant(l_float32 val, l_int32 size)
numaMakeConstant()
PIX * pixDilateBrick(PIX *pixd, PIX *pixs, l_int32 hsize, l_int32 vsize)
pixDilateBrick()
PIX * pixCreate(l_int32 width, l_int32 height, l_int32 depth)
pixCreate()
l_ok pixNumberOccupiedOctcubes(PIX *pix, l_int32 level, l_int32 mincount, l_float32 minfract, l_int32 *pncolors)
pixNumberOccupiedOctcubes()
l_ok pixSetAll(PIX *pix)
pixSetAll()
PIX * pixScaleAreaMap(PIX *pix, l_float32 scalex, l_float32 scaley)
pixScaleAreaMap()
PIX * pixInvert(PIX *pixd, PIX *pixs)
pixInvert()
void boxaDestroy(BOXA **pboxa)
boxaDestroy()
l_uint32 * pixGetData(PIX *pix)
pixGetData()
PIX * pixThresholdToBinary(PIX *pixs, l_int32 thresh)
pixThresholdToBinary()
l_ok pixNumColors(PIX *pixs, l_int32 factor, l_int32 *pncolors)
pixNumColors()
l_ok setLineDataVal(l_uint32 *line, l_int32 j, l_int32 d, l_uint32 val)
setLineDataVal()
l_ok pixAssignToNearestColor(PIX *pixd, PIX *pixs, PIX *pixm, l_int32 level, l_int32 *countarray)
pixAssignToNearestColor()
l_ok pixSetColormap(PIX *pix, PIXCMAP *colormap)
pixSetColormap()
PIX * pixGetRGBComponent(PIX *pixs, l_int32 comp)
pixGetRGBComponent()
l_ok pixColorsForQuantization(PIX *pixs, l_int32 thresh, l_int32 *pncolors, l_int32 *piscolor, l_int32 debug)
pixColorsForQuantization()
PIXCMAP * pixcmapCreate(l_int32 depth)
pixcmapCreate()
l_ok pixCombineMasked(PIX *pixd, PIX *pixs, PIX *pixm)
pixCombineMasked()
l_int32 * numaGetIArray(NUMA *na)
numaGetIArray()
NUMA * pixGetRGBHistogram(PIX *pixs, l_int32 sigbits, l_int32 factor)
pixGetRGBHistogram()
FPIX * pixComponentFunction(PIX *pix, l_float32 rnum, l_float32 gnum, l_float32 bnum, l_float32 rdenom, l_float32 gdenom, l_float32 bdenom)
pixComponentFunction()
l_ok numaGetIValue(NUMA *na, l_int32 index, l_int32 *pival)
numaGetIValue()
l_ok pixaAddPix(PIXA *pixa, PIX *pix, l_int32 copyflag)
pixaAddPix()
PIX * pixCloseSafeBrick(PIX *pixd, PIX *pixs, l_int32 hsize, l_int32 vsize)
pixCloseSafeBrick()
l_int32 numaGetCount(NUMA *na)
numaGetCount()
l_ok pixForegroundFraction(PIX *pix, l_float32 *pfract)
pixForegroundFraction()
BOXA * pixConnCompBB(PIX *pixs, l_int32 connectivity)
pixConnCompBB()
l_ok pixGetRankColorArray(PIX *pixs, l_int32 nbins, l_int32 type, l_int32 factor, l_uint32 **pcarray, PIXA *pixadb, l_int32 fontsize)
pixGetRankColorArray()
PIX * pixAnd(PIX *pixd, PIX *pixs1, PIX *pixs2)
pixAnd()
PIX * pixMorphSequence(PIX *pixs, const char *sequence, l_int32 dispsep)
pixMorphSequence()
PIX * pixMakeSymmetricMask(l_int32 w, l_int32 h, l_float32 hf, l_float32 vf, l_int32 type)
pixSelectComponentBySize()
l_ok pixCountPixels(PIX *pixs, l_int32 *pcount, l_int32 *tab8)
pixCountPixels()
#define SET_DATA_BYTE(pdata, n, val)
#define GET_DATA_QBIT(pdata, n)
PIX * pixConvertRGBToGrayMinMax(PIX *pixs, l_int32 type)
pixConvertRGBToGrayMinMax()
#define GET_DATA_BYTE(pdata, n)
PIX * pixRemoveBorderConnComps(PIX *pixs, l_int32 connectivity)
pixRemoveBorderConnComps()
PIX * pixClone(PIX *pixs)
pixClone()
PIX * pixSubtract(PIX *pixd, PIX *pixs1, PIX *pixs2)
pixSubtract()
void pixDestroy(PIX **ppix)
pixDestroy()
l_ok pixColorContent(PIX *pixs, l_int32 rref, l_int32 gref, l_int32 bref, l_int32 mingray, PIX **ppixr, PIX **ppixg, PIX **ppixb)
pixColorContent()
PIX * pixMaskBoxa(PIX *pixd, PIX *pixs, BOXA *boxa, l_int32 op)
pixMaskBoxa()
PIX * pixScaleByIntSampling(PIX *pixs, l_int32 factor)
pixScaleByIntSampling()
l_ok pixcmapHasColor(PIXCMAP *cmap, l_int32 *pcolor)
pixcmapHasColor()
PIX * pixScaleAreaMap2(PIX *pix)
pixScaleAreaMap2()
void numaDestroy(NUMA **pna)
numaDestroy()
l_ok pixNumSignificantGrayColors(PIX *pixs, l_int32 darkthresh, l_int32 lightthresh, l_float32 minfract, l_int32 factor, l_int32 *pncolors)
pixNumSignificantGrayColors()
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()
l_ok makeRGBIndexTables(l_uint32 **prtab, l_uint32 **pgtab, l_uint32 **pbtab, l_int32 sigbits)
makeRGBIndexTables()
PIX * pixConvertRGBToCmapLossless(PIX *pixs)
pixConvertRGBToCmapLossless()
l_ok pixFindColorRegions(PIX *pixs, PIX *pixm, l_int32 factor, l_int32 lightthresh, l_int32 darkthresh, l_int32 mindiff, l_int32 colordiff, l_float32 edgefract, l_float32 *pcolorfract, PIX **pcolormask1, PIX **pcolormask2, PIXA *pixadb)
pixFindColorRegions()
l_ok pixColorFraction(PIX *pixs, l_int32 darkthresh, l_int32 lightthresh, l_int32 diffthresh, l_int32 factor, l_float32 *ppixfract, l_float32 *pcolorfract)
pixColorFraction()
l_float32 * numaGetFArray(NUMA *na, l_int32 copyflag)
numaGetFArray()
PIX * pixColorShiftWhitePoint(PIX *pixs, l_int32 rref, l_int32 gref, l_int32 bref)
pixColorShiftWhitePoint()
#define GET_DATA_DIBIT(pdata, n)
BOXA * boxaCombineOverlaps(BOXA *boxas, PIXA *pixadb)
boxaCombineOverlaps()
PIX * pixSimpleColorQuantize(PIX *pixs, l_int32 sigbits, l_int32 factor, l_int32 ncolors)
pixSimpleColorQuantize()
NUMA * numaSortIndexAutoSelect(NUMA *nas, l_int32 sortorder)
numaSortIndexAutoSelect()
PIX * pixSobelEdgeFilter(PIX *pixs, l_int32 orientflag)
pixSobelEdgeFilter()
PIX * pixColorMagnitude(PIX *pixs, l_int32 rref, l_int32 gref, l_int32 bref, l_int32 type)
pixColorMagnitude()
l_int32 pixcmapGetCount(const PIXCMAP *cmap)
pixcmapGetCount()
PIX * pixDisplayColorArray(l_uint32 *carray, l_int32 ncolors, l_int32 side, l_int32 ncols, l_int32 fontsize)
pixDisplayColorArray()
PIX * pixErodeBrick(PIX *pixd, PIX *pixs, l_int32 hsize, l_int32 vsize)
pixErodeBrick()
l_ok composeRGBPixel(l_int32 rval, l_int32 gval, l_int32 bval, l_uint32 *ppixel)
composeRGBPixel()
l_ok pixGetMostPopulatedColors(PIX *pixs, l_int32 sigbits, l_int32 factor, l_int32 ncolors, l_uint32 **parray, PIXCMAP **pcmap)
pixGetMostPopulatedColors()
PIX * pixMaskOverGrayPixels(PIX *pixs, l_int32 maxlimit, l_int32 satlimit)
pixMaskOverGrayPixels()
PIX * pixMaskOverColorRange(PIX *pixs, l_int32 rmin, l_int32 rmax, l_int32 gmin, l_int32 gmax, l_int32 bmin, l_int32 bmax)
pixMaskOverColorRange()
l_ok pixcmapAddColor(PIXCMAP *cmap, l_int32 rval, l_int32 gval, l_int32 bval)
pixcmapAddColor()
void fpixDestroy(FPIX **pfpix)
fpixDestroy()
l_ok pixHasHighlightRed(PIX *pixs, l_int32 factor, l_float32 minfract, l_float32 fthresh, l_int32 *phasred, l_float32 *pratio, PIX **ppixdb)
pixHasHighlightRed()
void extractRGBValues(l_uint32 pixel, l_int32 *prval, l_int32 *pgval, l_int32 *pbval)
extractRGBValues()
l_ok getRGBFromIndex(l_uint32 index, l_int32 sigbits, l_int32 *prval, l_int32 *pgval, l_int32 *pbval)
getRGBFromIndex()
#define SET_DATA_BIT(pdata, n)