96 #include <config_auto.h>
100 #include "allheaders.h"
105 static const l_int32 MinCompsForBinSort = 200;
108 static const l_float32 MinAngleToRotate = 0.001;
222 l_int32 connectivity,
227 l_int32 w, h, empty, changed, count;
232 PROCNAME(
"pixSelectBySize");
235 return (
PIX *)ERROR_PTR(
"pixs not defined", procName, NULL);
236 if (connectivity != 4 && connectivity != 8)
237 return (
PIX *)ERROR_PTR(
"connectivity not 4 or 8", procName, NULL);
240 return (
PIX *)ERROR_PTR(
"invalid type", procName, NULL);
243 return (
PIX *)ERROR_PTR(
"invalid relation", procName, NULL);
244 if (pchanged) *pchanged = FALSE;
263 if (pchanged) *pchanged = TRUE;
270 pixCopyResolution(pixd, pixs);
272 pixCopyText(pixd, pixs);
273 pixCopyInputFormat(pixd, pixs);
316 PROCNAME(
"pixaSelectBySize");
319 return (
PIXA *)ERROR_PTR(
"pixas not defined", procName, NULL);
322 return (
PIXA *)ERROR_PTR(
"invalid type", procName, NULL);
325 return (
PIXA *)ERROR_PTR(
"invalid relation", procName, NULL);
368 l_int32 i, n, w, h, ival;
371 PROCNAME(
"pixaMakeSizeIndicator");
374 return (
NUMA *)ERROR_PTR(
"pixa not defined", procName, NULL);
377 return (
NUMA *)ERROR_PTR(
"invalid type", procName, NULL);
380 return (
NUMA *)ERROR_PTR(
"invalid relation", procName, NULL);
384 for (i = 0; i < n; i++) {
404 if (((relation ==
L_SELECT_IF_LT) && (w < width || h < height)) ||
411 if (((relation ==
L_SELECT_IF_LT) && (w < width && h < height)) ||
418 L_WARNING(
"can't get here!\n", procName);
455 l_int32 connectivity,
459 l_int32 w, h, empty, changed, count;
464 PROCNAME(
"pixSelectByPerimToAreaRatio");
467 return (
PIX *)ERROR_PTR(
"pixs not defined", procName, NULL);
468 if (connectivity != 4 && connectivity != 8)
469 return (
PIX *)ERROR_PTR(
"connectivity not 4 or 8", procName, NULL);
472 return (
PIX *)ERROR_PTR(
"invalid type", procName, NULL);
473 if (pchanged) *pchanged = FALSE;
492 if (pchanged) *pchanged = TRUE;
499 pixCopyResolution(pixd, pixs);
501 pixCopyText(pixd, pixs);
502 pixCopyInputFormat(pixd, pixs);
535 PROCNAME(
"pixaSelectByPerimToAreaRatio");
538 return (
PIXA *)ERROR_PTR(
"pixas not defined", procName, NULL);
541 return (
PIXA *)ERROR_PTR(
"invalid type", procName, NULL);
586 l_int32 connectivity,
590 l_int32 w, h, empty, changed, count;
595 PROCNAME(
"pixSelectByPerimSizeRatio");
598 return (
PIX *)ERROR_PTR(
"pixs not defined", procName, NULL);
599 if (connectivity != 4 && connectivity != 8)
600 return (
PIX *)ERROR_PTR(
"connectivity not 4 or 8", procName, NULL);
603 return (
PIX *)ERROR_PTR(
"invalid type", procName, NULL);
604 if (pchanged) *pchanged = FALSE;
623 if (pchanged) *pchanged = TRUE;
630 pixCopyResolution(pixd, pixs);
632 pixCopyText(pixd, pixs);
633 pixCopyInputFormat(pixd, pixs);
666 PROCNAME(
"pixaSelectByPerimSizeRatio");
669 return (
PIXA *)ERROR_PTR(
"pixas not defined", procName, NULL);
672 return (
PIXA *)ERROR_PTR(
"invalid type", procName, NULL);
716 l_int32 connectivity,
720 l_int32 w, h, empty, changed, count;
725 PROCNAME(
"pixSelectByAreaFraction");
728 return (
PIX *)ERROR_PTR(
"pixs not defined", procName, NULL);
729 if (connectivity != 4 && connectivity != 8)
730 return (
PIX *)ERROR_PTR(
"connectivity not 4 or 8", procName, NULL);
733 return (
PIX *)ERROR_PTR(
"invalid type", procName, NULL);
734 if (pchanged) *pchanged = FALSE;
753 if (pchanged) *pchanged = TRUE;
760 pixCopyResolution(pixd, pixs);
762 pixCopyText(pixd, pixs);
763 pixCopyInputFormat(pixd, pixs);
800 PROCNAME(
"pixaSelectByAreaFraction");
803 return (
PIXA *)ERROR_PTR(
"pixas not defined", procName, NULL);
806 return (
PIXA *)ERROR_PTR(
"invalid type", procName, NULL);
850 l_int32 connectivity,
854 l_int32 w, h, empty, changed, count;
859 PROCNAME(
"pixSelectByArea");
862 return (
PIX *)ERROR_PTR(
"pixs not defined", procName, NULL);
863 if (connectivity != 4 && connectivity != 8)
864 return (
PIX *)ERROR_PTR(
"connectivity not 4 or 8", procName, NULL);
867 return (
PIX *)ERROR_PTR(
"invalid type", procName, NULL);
868 if (pchanged) *pchanged = FALSE;
887 if (pchanged) *pchanged = TRUE;
894 pixCopyResolution(pixd, pixs);
896 pixCopyText(pixd, pixs);
897 pixCopyInputFormat(pixd, pixs);
934 PROCNAME(
"pixaSelectByArea");
937 return (
PIXA *)ERROR_PTR(
"pixas not defined", procName, NULL);
940 return (
PIXA *)ERROR_PTR(
"invalid type", procName, NULL);
983 l_int32 connectivity,
987 l_int32 w, h, empty, changed, count;
992 PROCNAME(
"pixSelectByWidthHeightRatio");
995 return (
PIX *)ERROR_PTR(
"pixs not defined", procName, NULL);
996 if (connectivity != 4 && connectivity != 8)
997 return (
PIX *)ERROR_PTR(
"connectivity not 4 or 8", procName, NULL);
1000 return (
PIX *)ERROR_PTR(
"invalid type", procName, NULL);
1001 if (pchanged) *pchanged = FALSE;
1020 if (pchanged) *pchanged = TRUE;
1027 pixCopyResolution(pixd, pixs);
1029 pixCopyText(pixd, pixs);
1030 pixCopyInputFormat(pixd, pixs);
1067 PROCNAME(
"pixaSelectByWidthHeightRatio");
1070 return (
PIXA *)ERROR_PTR(
"pixas not defined", procName, NULL);
1073 return (
PIXA *)ERROR_PTR(
"invalid type", procName, NULL);
1112 l_int32 connectivity,
1115 l_int32 n, i, count;
1120 PROCNAME(
"pixaSelectByNumConnComp");
1122 if (pchanged) *pchanged = 0;
1124 return (
PIXA *)ERROR_PTR(
"pixas not defined", procName, NULL);
1126 return (
PIXA *)ERROR_PTR(
"nmin > nmax", procName, NULL);
1127 if (connectivity != 4 && connectivity != 8)
1128 return (
PIXA *)ERROR_PTR(
"connectivity not 4 or 8", procName, NULL);
1133 for (i = 0; i < n; i++) {
1136 if (count >= nmin && count <= nmax)
1172 l_int32 i, n, nbox, ival, nsave;
1177 PROCNAME(
"pixaSelectWithIndicator");
1180 return (
PIXA *)ERROR_PTR(
"pixas not defined", procName, NULL);
1182 return (
PIXA *)ERROR_PTR(
"na not defined", procName, NULL);
1186 for (i = 0; i < n; i++) {
1188 if (ival == 1) nsave++;
1192 if (pchanged) *pchanged = FALSE;
1195 if (pchanged) *pchanged = TRUE;
1198 for (i = 0; i < n; i++) {
1200 if (ival == 0)
continue;
1232 l_int32 i, n, ival, x, y, w, h;
1236 PROCNAME(
"pixRemoveWithIndicator");
1239 return ERROR_INT(
"pixs not defined", procName, 1);
1241 return ERROR_INT(
"pixa not defined", procName, 1);
1243 return ERROR_INT(
"na not defined", procName, 1);
1246 return ERROR_INT(
"pixa and na sizes not equal", procName, 1);
1248 for (i = 0; i < n; i++) {
1285 l_int32 i, n, ival, x, y, w, h;
1289 PROCNAME(
"pixAddWithIndicator");
1292 return ERROR_INT(
"pixs not defined", procName, 1);
1294 return ERROR_INT(
"pixa not defined", procName, 1);
1296 return ERROR_INT(
"na not defined", procName, 1);
1299 return ERROR_INT(
"pixa and na sizes not equal", procName, 1);
1301 for (i = 0; i < n; i++) {
1338 l_int32 i, nval, npix, nbox, val, imaxval;
1345 PROCNAME(
"pixaSelectWithString");
1347 if (perror) *perror = 0;
1349 return (
PIXA *)ERROR_PTR(
"pixas not defined", procName, NULL);
1351 return (
PIXA *)ERROR_PTR(
"str not defined", procName, NULL);
1354 return (
PIXA *)ERROR_PTR(
"na not made", procName, NULL);
1357 return (
PIXA *)ERROR_PTR(
"no indices found", procName, NULL);
1360 imaxval = (l_int32)(maxval + 0.1);
1363 if (imaxval >= npix) {
1364 if (perror) *perror = 1;
1365 L_ERROR(
"max index = %d, size of pixa = %d\n", procName, imaxval, npix);
1369 for (i = 0; i < nval; i++) {
1371 if (val < 0 || val >= npix) {
1372 L_ERROR(
"index %d out of range of pix\n", procName, val);
1409 l_int32 n, x, y, w, h, same, maxd;
1414 PROCNAME(
"pixaRenderComponent");
1417 return (
PIX *)ERROR_PTR(
"pixa not defined", procName, pixs);
1419 if (index < 0 || index >= n)
1420 return (
PIX *)ERROR_PTR(
"invalid index", procName, pixs);
1421 if (pixs && (pixGetDepth(pixs) != 1))
1422 return (
PIX *)ERROR_PTR(
"pixs not 1 bpp", procName, pixs);
1425 return (
PIX *)ERROR_PTR(
"not all pix with d == 1", procName, pixs);
1481 l_int32 i, n, nb, x, y, w, h;
1486 PROCNAME(
"pixaSort");
1488 if (pnaindex) *pnaindex = NULL;
1490 return (
PIXA *)ERROR_PTR(
"pixas not defined", procName, NULL);
1498 return (
PIXA *)ERROR_PTR(
"invalid sort type", procName, NULL);
1500 return (
PIXA *)ERROR_PTR(
"invalid sort order", procName, NULL);
1502 return (
PIXA *)ERROR_PTR(
"invalid copy flag", procName, NULL);
1506 L_INFO(
"no pix in pixa\n", procName);
1509 if ((boxa = pixas->
boxa) == NULL)
1510 return (
PIXA *)ERROR_PTR(
"boxa not found!", procName, NULL);
1517 L_WARNING(
"sort by x or y where all values are 0\n", procName);
1520 return (
PIXA *)ERROR_PTR(
"boxa and pixa counts differ", procName, NULL);
1523 if (n > MinCompsForBinSort &&
1527 return pixaBinSort(pixas, sorttype, sortorder, pnaindex, copyflag);
1531 return (
PIXA *)ERROR_PTR(
"na not made", procName, NULL);
1532 for (i = 0; i < n; i++) {
1564 L_WARNING(
"invalid sort type\n", procName);
1572 return (
PIXA *)ERROR_PTR(
"naindex not made", procName, NULL);
1577 return (
PIXA *)ERROR_PTR(
"pixad not made", procName, NULL);
1581 *pnaindex = naindex;
1621 l_int32 i, n, x, y, w, h;
1626 PROCNAME(
"pixaBinSort");
1628 if (pnaindex) *pnaindex = NULL;
1630 return (
PIXA *)ERROR_PTR(
"pixas not defined", procName, NULL);
1634 return (
PIXA *)ERROR_PTR(
"invalid sort type", procName, NULL);
1636 return (
PIXA *)ERROR_PTR(
"invalid sort order", procName, NULL);
1638 return (
PIXA *)ERROR_PTR(
"invalid copy flag", procName, NULL);
1641 if ((boxa = pixas->
boxa) == NULL)
1642 return (
PIXA *)ERROR_PTR(
"boxa not found", procName, NULL);
1645 return (
PIXA *)ERROR_PTR(
"boxa and pixa counts differ", procName, NULL);
1649 return (
PIXA *)ERROR_PTR(
"na not made", procName, NULL);
1650 for (i = 0; i < n; i++) {
1670 L_WARNING(
"invalid sort type\n", procName);
1678 return (
PIXA *)ERROR_PTR(
"naindex not made", procName, NULL);
1683 return (
PIXA *)ERROR_PTR(
"pixad not made", procName, NULL);
1687 *pnaindex = naindex;
1707 l_int32 i, n, index;
1712 PROCNAME(
"pixaSortByIndex");
1715 return (
PIXA *)ERROR_PTR(
"pixas not defined", procName, NULL);
1717 return (
PIXA *)ERROR_PTR(
"naindex not defined", procName, NULL);
1719 return (
PIXA *)ERROR_PTR(
"invalid copyflag", procName, NULL);
1723 for (i = 0; i < n; i++) {
1748 l_int32 pixtot, ntot, i, j, n, nn, index;
1755 PROCNAME(
"pixaSort2dByIndex");
1758 return (
PIXAA *)ERROR_PTR(
"pixas not defined", procName, NULL);
1760 return (
PIXAA *)ERROR_PTR(
"naindex not defined", procName, NULL);
1766 return (
PIXAA *)ERROR_PTR(
"element count mismatch", procName, NULL);
1770 for (i = 0; i < n; i++) {
1774 for (j = 0; j < nn; j++) {
1818 PROCNAME(
"pixaSelectRange");
1821 return (
PIXA *)ERROR_PTR(
"pixas not defined", procName, NULL);
1823 return (
PIXA *)ERROR_PTR(
"invalid copyflag", procName, NULL);
1825 first = L_MAX(0, first);
1826 if (last < 0) last = n - 1;
1828 return (
PIXA *)ERROR_PTR(
"invalid first", procName, NULL);
1830 L_WARNING(
"last = %d is beyond max index = %d; adjusting\n",
1831 procName, last, n - 1);
1835 return (
PIXA *)ERROR_PTR(
"first > last", procName, NULL);
1837 npix = last - first + 1;
1839 for (i = first; i <= last; i++) {
1869 l_int32 n, npixa, i;
1873 PROCNAME(
"pixaaSelectRange");
1876 return (
PIXAA *)ERROR_PTR(
"paas not defined", procName, NULL);
1878 return (
PIXAA *)ERROR_PTR(
"invalid copyflag", procName, NULL);
1880 first = L_MAX(0, first);
1881 if (last < 0) last = n - 1;
1883 return (
PIXAA *)ERROR_PTR(
"invalid first", procName, NULL);
1885 L_WARNING(
"last = %d is beyond max index = %d; adjusting\n",
1886 procName, last, n - 1);
1890 return (
PIXAA *)ERROR_PTR(
"first > last", procName, NULL);
1892 npixa = last - first + 1;
1894 for (i = first; i <= last; i++) {
1930 PIXA *pixa1, *pixa2;
1933 PROCNAME(
"pixaaScaleToSize");
1936 return (
PIXAA *)ERROR_PTR(
"paas not defined", procName, NULL);
1937 if (wd <= 0 && hd <= 0)
1938 return (
PIXAA *)ERROR_PTR(
"neither wd nor hd > 0", procName, NULL);
1942 for (i = 0; i < n; i++) {
1978 l_int32 n, i, wd, hd;
1979 PIXA *pixa1, *pixa2;
1982 PROCNAME(
"pixaaScaleToSizeVar");
1985 return (
PIXAA *)ERROR_PTR(
"paas not defined", procName, NULL);
1987 return (
PIXAA *)ERROR_PTR(
"!nawd && !nahd", procName, NULL);
1991 return (
PIXAA *)ERROR_PTR(
"nawd wrong size", procName, NULL);
1993 return (
PIXAA *)ERROR_PTR(
"nahd wrong size", procName, NULL);
1995 for (i = 0; i < n; i++) {
2030 PROCNAME(
"pixaScaleToSize");
2033 return (
PIXA *)ERROR_PTR(
"pixas not defined", procName, NULL);
2035 if (wd <= 0 && hd <= 0)
2040 for (i = 0; i < n; i++) {
2043 pixCopyText(pix2, pix1);
2075 PROCNAME(
"pixaScaleToSizeRel");
2078 return (
PIXA *)ERROR_PTR(
"pixas not defined", procName, NULL);
2082 for (i = 0; i < n; i++) {
2088 L_WARNING(
"relative scale to size failed; use a copy\n", procName);
2116 BOXA *boxa1, *boxa2;
2120 PROCNAME(
"pixaScale");
2123 return (
PIXA *)ERROR_PTR(
"pixas not defined", procName, NULL);
2124 if (scalex <= 0.0 || scaley <= 0.0)
2125 return (
PIXA *)ERROR_PTR(
"invalid scaling parameters", procName, NULL);
2129 for (i = 0; i < n; i++) {
2131 pix2 =
pixScale(pix1, scalex, scaley);
2132 pixCopyText(pix2, pix1);
2167 BOXA *boxa1, *boxa2;
2171 PROCNAME(
"pixaScaleBySampling");
2174 return (
PIXA *)ERROR_PTR(
"pixas not defined", procName, NULL);
2175 if (scalex <= 0.0 || scaley <= 0.0)
2176 return (
PIXA *)ERROR_PTR(
"invalid scaling parameters", procName, NULL);
2180 for (i = 0; i < n; i++) {
2183 pixCopyText(pix2, pix1);
2239 PROCNAME(
"pixaRotate");
2242 return (
PIXA *)ERROR_PTR(
"pixas not defined", procName, NULL);
2245 return (
PIXA *)ERROR_PTR(
"invalid type", procName, NULL);
2247 return (
PIXA *)ERROR_PTR(
"invalid incolor", procName, NULL);
2248 if (L_ABS(angle) < MinAngleToRotate)
2253 return (
PIXA *)ERROR_PTR(
"pixad not made", procName, NULL);
2256 for (i = 0; i < n; i++) {
2259 return (
PIXA *)ERROR_PTR(
"pixs not found", procName, NULL);
2261 pixd =
pixRotate(pixs, angle, type, incolor, width, height);
2288 l_int32 i, n, nb, w, h;
2293 PROCNAME(
"pixaRotateOrth");
2296 return (
PIXA *)ERROR_PTR(
"pixas not defined", procName, NULL);
2297 if (rotation < 0 || rotation > 3)
2298 return (
PIXA *)ERROR_PTR(
"rotation not in {0,1,2,3}", procName, NULL);
2305 return (
PIXA *)ERROR_PTR(
"pixad not made", procName, NULL);
2306 for (i = 0; i < n; i++) {
2309 return (
PIXA *)ERROR_PTR(
"pixs not found", procName, NULL);
2343 BOXA *boxas, *boxad;
2347 PROCNAME(
"pixaTranslate");
2350 return (
PIXA *)ERROR_PTR(
"pixas not defined", procName, NULL);
2351 if (hshift == 0 && vshift == 0)
2357 return (
PIXA *)ERROR_PTR(
"pixad not made", procName, NULL);
2358 for (i = 0; i < n; i++) {
2361 return (
PIXA *)ERROR_PTR(
"pixs not found", procName, NULL);
2363 pixd =
pixTranslate(NULL, pixs, hshift, vshift, incolor);
2424 PROCNAME(
"pixaAddBorderGeneral");
2427 return (
PIXA *)ERROR_PTR(
"pixas not defined", procName, pixad);
2428 if (left < 0 || right < 0 || top < 0 || bot < 0)
2429 return (
PIXA *)ERROR_PTR(
"negative border added!", procName, pixad);
2430 if (pixad && (pixad != pixas))
2431 return (
PIXA *)ERROR_PTR(
"pixad defined but != pixas", procName, pixad);
2436 for (i = 0; i < n; i++) {
2448 for (i = 0; i < nbox; i++) {
2450 L_WARNING(
"box %d not found\n", procName, i);
2486 l_int32 i, j, m, mb, n;
2492 PROCNAME(
"pixaaFlattenToPixa");
2494 if (pnaindex) *pnaindex = NULL;
2496 return (
PIXA *)ERROR_PTR(
"paa not defined", procName, NULL);
2498 return (
PIXA *)ERROR_PTR(
"invalid copyflag", procName, NULL);
2502 *pnaindex = naindex;
2507 for (i = 0; i < n; i++) {
2511 for (j = 0; j < m; j++) {
2543 l_int32 minw, minh, maxw, maxh, minpw, minph, maxpw, maxph, i, n;
2546 PROCNAME(
"pixaaSizeRange");
2548 if (pminw) *pminw = 0;
2549 if (pminh) *pminh = 0;
2550 if (pmaxw) *pmaxw = 0;
2551 if (pmaxh) *pmaxh = 0;
2553 return ERROR_INT(
"paa not defined", procName, 1);
2554 if (!pminw && !pmaxw && !pminh && !pmaxh)
2555 return ERROR_INT(
"no data can be returned", procName, 1);
2557 minw = minh = 100000000;
2560 for (i = 0; i < n; i++) {
2574 if (pminw) *pminw = minw;
2575 if (pminh) *pminh = minh;
2576 if (pmaxw) *pmaxw = maxw;
2577 if (pmaxh) *pmaxh = maxh;
2597 l_int32 minw, minh, maxw, maxh, i, n, w, h;
2600 PROCNAME(
"pixaSizeRange");
2602 if (pminw) *pminw = 0;
2603 if (pminh) *pminh = 0;
2604 if (pmaxw) *pmaxw = 0;
2605 if (pmaxh) *pmaxh = 0;
2607 return ERROR_INT(
"pixa not defined", procName, 1);
2608 if (!pminw && !pmaxw && !pminh && !pmaxh)
2609 return ERROR_INT(
"no data can be returned", procName, 1);
2611 minw = minh = 1000000;
2614 for (i = 0; i < n; i++) {
2616 w = pixGetWidth(pix);
2617 h = pixGetHeight(pix);
2629 if (pminw) *pminw = minw;
2630 if (pminh) *pminh = minh;
2631 if (pmaxw) *pmaxw = maxw;
2632 if (pmaxh) *pmaxh = maxh;
2669 PROCNAME(
"pixaClipToPix");
2672 return (
PIXA *)ERROR_PTR(
"pixas not defined", procName, NULL);
2674 return (
PIXA *)ERROR_PTR(
"pixs not defined", procName, NULL);
2678 return (
PIXA *)ERROR_PTR(
"pixad not made", procName, NULL);
2680 for (i = 0; i < n; i++) {
2718 PROCNAME(
"pixaClipToForeground");
2720 if (ppixad) *ppixad = NULL;
2721 if (pboxa) *pboxa = NULL;
2723 return ERROR_INT(
"pixas not defined", procName, 1);
2724 if (!ppixad && !pboxa)
2725 return ERROR_INT(
"no output requested", procName, 1);
2730 for (i = 0; i < n; i++) {
2770 l_int32 hascolor, maxdepth;
2772 PROCNAME(
"pixaGetRenderingDepth");
2775 return ERROR_INT(
"&depth not defined", procName, 1);
2778 return ERROR_INT(
"pixa not defined", procName, 1);
2807 l_int32 i, n, hascolor, d;
2811 PROCNAME(
"pixaHasColor");
2814 return ERROR_INT(
"&hascolor not defined", procName, 1);
2817 return ERROR_INT(
"pixa not defined", procName, 1);
2821 for (i = 0; i < n; i++) {
2823 if ((cmap = pixGetColormap(pix)) != NULL)
2825 d = pixGetDepth(pix);
2827 if (d == 32 || hascolor == 1) {
2852 PROCNAME(
"pixaAnyColormaps");
2855 return ERROR_INT(
"&hascmap not defined", procName, 1);
2858 return ERROR_INT(
"pixa not defined", procName, 1);
2861 for (i = 0; i < n; i++) {
2863 cmap = pixGetColormap(pix);
2888 l_int32 i, n, d, d0;
2891 PROCNAME(
"pixaGetDepthInfo");
2893 if (pmaxdepth) *pmaxdepth = 0;
2894 if (psame) *psame = TRUE;
2895 if (!pmaxdepth && !psame)
return 0;
2897 return ERROR_INT(
"pixa not defined", procName, 1);
2899 return ERROR_INT(
"pixa is empty", procName, 1);
2903 for (i = 0; i < n; i++) {
2909 if (d > maxd) maxd = d;
2912 if (pmaxdepth) *pmaxdepth = maxd;
2913 if (psame) *psame = same;
2939 l_int32 i, n, depth, same, hascmap, maxdepth;
2942 PIXA *pixa1, *pixad;
2944 PROCNAME(
"pixaConvertToSameDepth");
2947 return (
PIXA *)ERROR_PTR(
"pixas not defined", procName, NULL);
2949 return (
PIXA *)ERROR_PTR(
"no components", procName, NULL);
2957 for (i = 0; i < n; i++) {
2973 for (i = 0; i < n; i++) {
3017 PROCNAME(
"pixaConvertToGivenDepth");
3020 return (
PIXA *)ERROR_PTR(
"pixas not defined", procName, NULL);
3022 return (
PIXA *)ERROR_PTR(
"no components", procName, NULL);
3023 if (depth != 8 && depth != 32)
3024 return (
PIXA *)ERROR_PTR(
"depth not 8 or 32", procName, NULL);
3029 L_WARNING(
"All pix are 1 bpp; converting to %d bpp\n", procName, depth);
3031 L_WARNING(
"Lossy conversion: max rendering depth %d > input %d\n",
3032 procName, maxd, depth);
3035 for (i = 0; i < n; i++) {
3038 pix2 = (pixGetDepth(pix1) == 32) ?
pixClone(pix1) :
3088 l_int32 i, j, n, empty1, empty2, same, sameboxa;
3089 BOXA *boxa1, *boxa2;
3093 PROCNAME(
"pixaEqual");
3095 if (pnaindex) *pnaindex = NULL;
3097 return ERROR_INT(
"&same not defined", procName, 1);
3101 if (!pixa1 || !pixa2)
3102 return ERROR_INT(
"pixa1 and pixa2 not both defined", procName, 1);
3113 if (!empty1 && !empty2) {
3114 boxaEqual(boxa1, boxa2, maxdist, &na, &sameboxa);
3124 if ((!empty1 && empty2) || (empty1 && !empty2))
3127 for (i = 0; i < n; i++) {
3173 PROCNAME(
"pixaSetFullSizeBoxa");
3176 return ERROR_INT(
"pixa not defined", procName, 1);
3178 L_INFO(
"pixa contains no pix\n", procName);
3184 for (i = 0; i < n; i++) {
void boxDestroy(BOX **pbox)
boxDestroy()
l_ok boxaReplaceBox(BOXA *boxa, l_int32 index, BOX *box)
boxaReplaceBox()
l_ok boxaGetBoxGeometry(BOXA *boxa, l_int32 index, l_int32 *px, l_int32 *py, l_int32 *pw, l_int32 *ph)
boxaGetBoxGeometry()
l_int32 boxaGetCount(BOXA *boxa)
boxaGetCount()
l_ok boxGetGeometry(BOX *box, l_int32 *px, l_int32 *py, l_int32 *pw, l_int32 *ph)
boxGetGeometry()
l_ok boxaAddBox(BOXA *boxa, BOX *box, l_int32 copyflag)
boxaAddBox()
void boxaDestroy(BOXA **pboxa)
boxaDestroy()
BOX * boxaGetBox(BOXA *boxa, l_int32 index, l_int32 accessflag)
boxaGetBox()
BOX * boxCreate(l_int32 x, l_int32 y, l_int32 w, l_int32 h)
boxCreate()
BOXA * boxaCreate(l_int32 n)
boxaCreate()
l_ok boxaEqual(BOXA *boxa1, BOXA *boxa2, l_int32 maxdist, NUMA **pnaindex, l_int32 *psame)
boxaEqual()
BOX * boxAdjustSides(BOX *boxd, BOX *boxs, l_int32 delleft, l_int32 delright, l_int32 deltop, l_int32 delbot)
boxAdjustSides()
BOX * boxRotateOrth(BOX *box, l_int32 w, l_int32 h, l_int32 rotation)
boxRotateOrth()
BOXA * boxaTransform(BOXA *boxas, l_int32 shiftx, l_int32 shifty, l_float32 scalex, l_float32 scaley)
boxaTransform()
l_ok boxaGetExtent(BOXA *boxa, l_int32 *pw, l_int32 *ph, BOX **pbox)
boxaGetExtent()
l_ok pixcmapHasColor(PIXCMAP *cmap, l_int32 *pcolor)
pixcmapHasColor()
l_ok pixEqual(PIX *pix1, PIX *pix2, l_int32 *psame)
pixEqual()
BOXA * pixConnComp(PIX *pixs, PIXA **ppixa, l_int32 connectivity)
pixConnComp()
l_ok pixCountConnComp(PIX *pixs, l_int32 connectivity, l_int32 *pcount)
pixCountConnComp()
l_ok numaAddNumber(NUMA *na, l_float32 val)
numaAddNumber()
l_int32 numaaGetNumberCount(NUMAA *naa)
numaaGetNumberCount()
NUMA * numaCreateFromString(const char *str)
numaCreateFromString()
NUMA * numaCreate(l_int32 n)
numaCreate()
l_int32 numaaGetCount(NUMAA *naa)
numaaGetCount()
NUMA * numaaGetNuma(NUMAA *naa, l_int32 index, l_int32 accessflag)
numaaGetNuma()
void numaDestroy(NUMA **pna)
numaDestroy()
l_int32 numaGetCount(NUMA *na)
numaGetCount()
l_ok numaGetIValue(NUMA *na, l_int32 index, l_int32 *pival)
numaGetIValue()
NUMA * numaMakeThresholdIndicator(NUMA *nas, l_float32 thresh, l_int32 type)
numaMakeThresholdIndicator()
NUMA * numaGetSortIndex(NUMA *na, l_int32 sortorder)
numaGetSortIndex()
l_ok numaGetMax(NUMA *na, l_float32 *pmaxval, l_int32 *pimaxloc)
numaGetMax()
NUMA * numaGetBinSortIndex(NUMA *nas, l_int32 sortorder)
numaGetBinSortIndex()
void pixDestroy(PIX **ppix)
pixDestroy()
l_ok pixGetDimensions(const PIX *pix, l_int32 *pw, l_int32 *ph, l_int32 *pd)
pixGetDimensions()
PIX * pixCopy(PIX *pixd, const PIX *pixs)
pixCopy()
PIX * pixCreateTemplate(const PIX *pixs)
pixCreateTemplate()
l_ok pixCopyColormap(PIX *pixd, const PIX *pixs)
pixCopyColormap()
PIX * pixCreate(l_int32 width, l_int32 height, l_int32 depth)
pixCreate()
PIX * pixClone(PIX *pixs)
pixClone()
PIX * pixAddBorderGeneral(PIX *pixs, l_int32 left, l_int32 right, l_int32 top, l_int32 bot, l_uint32 val)
pixAddBorderGeneral()
l_ok pixZero(PIX *pix, l_int32 *pempty)
pixZero()
NUMA * pixaCountPixels(PIXA *pixa)
pixaCountPixels()
PIX * pixAnd(PIX *pixd, PIX *pixs1, PIX *pixs2)
pixAnd()
NUMA * pixaFindAreaFraction(PIXA *pixa)
pixaFindAreaFraction()
NUMA * pixaFindPerimSizeRatio(PIXA *pixa)
pixaFindPerimSizeRatio()
NUMA * pixaFindPerimToAreaRatio(PIXA *pixa)
pixaFindPerimToAreaRatio()
PIX * pixClipRectangle(PIX *pixs, BOX *box, BOX **pboxc)
pixClipRectangle()
NUMA * pixaFindWidthHeightRatio(PIXA *pixa)
pixaFindWidthHeightRatio()
l_ok pixClipToForeground(PIX *pixs, PIX **ppixd, BOX **pbox)
pixClipToForeground()
@ L_SORT_BY_MIN_DIMENSION
@ L_SORT_BY_MAX_DIMENSION
PIXAA * pixaaCreate(l_int32 n)
pixaaCreate()
l_ok pixaAddPix(PIXA *pixa, PIX *pix, l_int32 copyflag)
pixaAddPix()
void pixaDestroy(PIXA **ppixa)
pixaDestroy()
l_ok pixaVerifyDepth(PIXA *pixa, l_int32 *psame, l_int32 *pmaxd)
pixaVerifyDepth()
BOX * pixaGetBox(PIXA *pixa, l_int32 index, l_int32 accesstype)
pixaGetBox()
l_int32 pixaGetBoxaCount(PIXA *pixa)
pixaGetBoxaCount()
l_ok pixaaAddPixa(PIXAA *paa, PIXA *pixa, l_int32 copyflag)
pixaaAddPixa()
PIXA * pixaCreate(l_int32 n)
pixaCreate()
l_ok pixaGetPixDimensions(PIXA *pixa, l_int32 index, l_int32 *pw, l_int32 *ph, l_int32 *pd)
pixaGetPixDimensions()
PIXA * pixaCopy(PIXA *pixa, l_int32 copyflag)
pixaCopy()
l_ok pixaReplacePix(PIXA *pixa, l_int32 index, PIX *pix, BOX *box)
pixaReplacePix()
l_int32 pixaGetCount(PIXA *pixa)
pixaGetCount()
l_ok pixaAddBox(PIXA *pixa, BOX *box, l_int32 copyflag)
pixaAddBox()
BOXA * pixaGetBoxa(PIXA *pixa, l_int32 accesstype)
pixaGetBoxa()
l_int32 pixaaGetCount(PIXAA *paa, NUMA **pna)
pixaaGetCount()
PIXA * pixaaGetPixa(PIXAA *paa, l_int32 index, l_int32 accesstype)
pixaaGetPixa()
PIX * pixaGetPix(PIXA *pixa, l_int32 index, l_int32 accesstype)
pixaGetPix()
l_ok pixaSetBoxa(PIXA *pixa, BOXA *boxa, l_int32 accesstype)
pixaSetBoxa()
PIXA * pixaSelectRange(PIXA *pixas, l_int32 first, l_int32 last, l_int32 copyflag)
pixaSelectRange()
l_ok pixaGetRenderingDepth(PIXA *pixa, l_int32 *pdepth)
pixaGetRenderingDepth()
PIXA * pixaSelectByWidthHeightRatio(PIXA *pixas, l_float32 thresh, l_int32 type, l_int32 *pchanged)
pixaSelectByWidthHeightRatio()
PIXA * pixaRotateOrth(PIXA *pixas, l_int32 rotation)
pixaRotateOrth()
l_ok pixaHasColor(PIXA *pixa, l_int32 *phascolor)
pixaHasColor()
PIXA * pixaSelectByAreaFraction(PIXA *pixas, l_float32 thresh, l_int32 type, l_int32 *pchanged)
pixaSelectByAreaFraction()
PIX * pixSelectBySize(PIX *pixs, l_int32 width, l_int32 height, l_int32 connectivity, l_int32 type, l_int32 relation, l_int32 *pchanged)
pixSelectBySize()
PIXA * pixaSelectByNumConnComp(PIXA *pixas, l_int32 nmin, l_int32 nmax, l_int32 connectivity, l_int32 *pchanged)
pixaSelectByNumConnComp()
PIX * pixaRenderComponent(PIX *pixs, PIXA *pixa, l_int32 index)
pixaRenderComponent()
l_ok pixaSizeRange(PIXA *pixa, l_int32 *pminw, l_int32 *pminh, l_int32 *pmaxw, l_int32 *pmaxh)
pixaSizeRange()
PIXAA * pixaSort2dByIndex(PIXA *pixas, NUMAA *naa, l_int32 copyflag)
pixaSort2dByIndex()
PIXA * pixaSelectByPerimSizeRatio(PIXA *pixas, l_float32 thresh, l_int32 type, l_int32 *pchanged)
pixaSelectByPerimSizeRatio()
PIXAA * pixaaScaleToSize(PIXAA *paas, l_int32 wd, l_int32 hd)
pixaaScaleToSize()
l_ok pixaaSizeRange(PIXAA *paa, l_int32 *pminw, l_int32 *pminh, l_int32 *pmaxw, l_int32 *pmaxh)
pixaaSizeRange()
l_ok pixaSetFullSizeBoxa(PIXA *pixa)
pixaSetFullSizeBoxa()
PIXA * pixaSelectByPerimToAreaRatio(PIXA *pixas, l_float32 thresh, l_int32 type, l_int32 *pchanged)
pixaSelectByPerimToAreaRatio()
PIXA * pixaSelectWithString(PIXA *pixas, const char *str, l_int32 *perror)
pixaSelectWithString()
PIX * pixSelectByAreaFraction(PIX *pixs, l_float32 thresh, l_int32 connectivity, l_int32 type, l_int32 *pchanged)
pixSelectByAreaFraction()
PIXA * pixaTranslate(PIXA *pixas, l_int32 hshift, l_int32 vshift, l_int32 incolor)
pixaTranslate()
PIXAA * pixaaSelectRange(PIXAA *paas, l_int32 first, l_int32 last, l_int32 copyflag)
pixaaSelectRange()
l_ok pixaAnyColormaps(PIXA *pixa, l_int32 *phascmap)
pixaAnyColormaps()
PIX * pixSelectByPerimToAreaRatio(PIX *pixs, l_float32 thresh, l_int32 connectivity, l_int32 type, l_int32 *pchanged)
pixSelectByPerimToAreaRatio()
PIXA * pixaScale(PIXA *pixas, l_float32 scalex, l_float32 scaley)
pixaScale()
l_ok pixRemoveWithIndicator(PIX *pixs, PIXA *pixa, NUMA *na)
pixRemoveWithIndicator()
PIXA * pixaConvertToGivenDepth(PIXA *pixas, l_int32 depth)
pixaConvertToGivenDepth()
PIXA * pixaScaleBySampling(PIXA *pixas, l_float32 scalex, l_float32 scaley)
pixaScaleBySampling()
l_ok pixAddWithIndicator(PIX *pixs, PIXA *pixa, NUMA *na)
pixAddWithIndicator()
PIX * pixSelectByWidthHeightRatio(PIX *pixs, l_float32 thresh, l_int32 connectivity, l_int32 type, l_int32 *pchanged)
pixSelectByWidthHeightRatio()
l_ok pixaClipToForeground(PIXA *pixas, PIXA **ppixad, BOXA **pboxa)
pixaClipToForeground()
PIXA * pixaAddBorderGeneral(PIXA *pixad, PIXA *pixas, l_int32 left, l_int32 right, l_int32 top, l_int32 bot, l_uint32 val)
pixaAddBorderGeneral()
l_ok pixaGetDepthInfo(PIXA *pixa, l_int32 *pmaxdepth, l_int32 *psame)
pixaGetDepthInfo()
PIXA * pixaRotate(PIXA *pixas, l_float32 angle, l_int32 type, l_int32 incolor, l_int32 width, l_int32 height)
pixaRotate()
PIXA * pixaSortByIndex(PIXA *pixas, NUMA *naindex, l_int32 copyflag)
pixaSortByIndex()
PIXA * pixaSort(PIXA *pixas, l_int32 sorttype, l_int32 sortorder, NUMA **pnaindex, l_int32 copyflag)
pixaSort()
PIXA * pixaBinSort(PIXA *pixas, l_int32 sorttype, l_int32 sortorder, NUMA **pnaindex, l_int32 copyflag)
pixaBinSort()
PIXA * pixaSelectBySize(PIXA *pixas, l_int32 width, l_int32 height, l_int32 type, l_int32 relation, l_int32 *pchanged)
pixaSelectBySize()
PIXAA * pixaaScaleToSizeVar(PIXAA *paas, NUMA *nawd, NUMA *nahd)
pixaaScaleToSizeVar()
l_ok pixaEqual(PIXA *pixa1, PIXA *pixa2, l_int32 maxdist, NUMA **pnaindex, l_int32 *psame)
pixaEqual()
PIXA * pixaClipToPix(PIXA *pixas, PIX *pixs)
pixaClipToPix()
PIXA * pixaSelectByArea(PIXA *pixas, l_float32 thresh, l_int32 type, l_int32 *pchanged)
pixaSelectByArea()
PIXA * pixaScaleToSize(PIXA *pixas, l_int32 wd, l_int32 hd)
pixaScaleToSize()
PIXA * pixaaFlattenToPixa(PIXAA *paa, NUMA **pnaindex, l_int32 copyflag)
pixaaFlattenToPixa()
PIXA * pixaScaleToSizeRel(PIXA *pixas, l_int32 delw, l_int32 delh)
pixaScaleToSizeRel()
PIXA * pixaSelectWithIndicator(PIXA *pixas, NUMA *na, l_int32 *pchanged)
pixaSelectWithIndicator()
PIXA * pixaConvertToSameDepth(PIXA *pixas)
pixaConvertToSameDepth()
NUMA * pixaMakeSizeIndicator(PIXA *pixa, l_int32 width, l_int32 height, l_int32 type, l_int32 relation)
pixaMakeSizeIndicator()
PIX * pixSelectByPerimSizeRatio(PIX *pixs, l_float32 thresh, l_int32 connectivity, l_int32 type, l_int32 *pchanged)
pixSelectByPerimSizeRatio()
PIX * pixSelectByArea(PIX *pixs, l_float32 thresh, l_int32 connectivity, l_int32 type, l_int32 *pchanged)
pixSelectByArea()
PIX * pixaDisplay(PIXA *pixa, l_int32 w, l_int32 h)
pixaDisplay()
PIX * pixConvertTo8(PIX *pixs, l_int32 cmapflag)
pixConvertTo8()
PIX * pixConvertTo32(PIX *pixs)
pixConvertTo32()
PIX * pixTranslate(PIX *pixd, PIX *pixs, l_int32 hshift, l_int32 vshift, l_int32 incolor)
pixTranslate()
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 * pixRotate(PIX *pixs, l_float32 angle, l_int32 type, l_int32 incolor, l_int32 width, l_int32 height)
pixRotate()
PIX * pixRotateOrth(PIX *pixs, l_int32 quads)
pixRotateOrth()
PIX * pixScale(PIX *pixs, l_float32 scalex, l_float32 scaley)
pixScale()
PIX * pixScaleToSizeRel(PIX *pixs, l_int32 delw, l_int32 delh)
pixScaleToSizeRel()
PIX * pixScaleToSize(PIX *pixs, l_int32 wd, l_int32 hd)
pixScaleToSize()
PIX * pixScaleBySampling(PIX *pixs, l_float32 scalex, l_float32 scaley)
pixScaleBySampling()