160 #include <config_auto.h> 165 #include "allheaders.h" 195 l_int32 i, n, d, xb, yb, wb, hb, res;
199 PROCNAME(
"pixaDisplay");
202 return (
PIX *)ERROR_PTR(
"pixa not defined", procName, NULL);
205 if (n == 0 && w == 0 && h == 0)
206 return (
PIX *)ERROR_PTR(
"no components; no size", procName, NULL);
208 L_WARNING(
"no components; returning empty 1 bpp pix\n", procName);
214 if (w == 0 || h == 0) {
218 if (w == 0 || h == 0)
219 return (
PIX *)ERROR_PTR(
"no associated boxa", procName, NULL);
224 d = pixGetDepth(pix1);
225 res = pixGetXRes(pix1);
229 return (
PIX *)ERROR_PTR(
"pixd not made", procName, NULL);
233 for (i = 0; i < n; i++) {
235 L_WARNING(
"no box found!\n", procName);
273 l_int32 i, n, same, maxd, index, xb, yb, wb, hb, res;
275 PIX *pixs, *pix1, *pixd;
278 PROCNAME(
"pixaDisplayRandomCmap");
281 return (
PIX *)ERROR_PTR(
"pixa not defined", procName, NULL);
284 return (
PIX *)ERROR_PTR(
"no components", procName, NULL);
287 return (
PIX *)ERROR_PTR(
"not all components are 1 bpp", procName, NULL);
291 if (w == 0 || h == 0) {
299 return (
PIX *)ERROR_PTR(
"pixd not made", procName, NULL);
304 for (i = 0; i < n; i++) {
305 index = 1 + (i % 254);
308 if (i == 0) res = pixGetXRes(pixs);
345 l_float32 scalefactor,
351 l_int32 i, n, x, y, w, h, size, depth, bordval;
353 PIX *pix1, *pix2, *pix3, *pixd;
356 PROCNAME(
"pixaDisplayLinearly");
358 if (pboxa) *pboxa = NULL;
360 return (
PIX *)ERROR_PTR(
"pixas not defined", procName, NULL);
361 if (direction != L_HORIZ && direction != L_VERT)
362 return (
PIX *)ERROR_PTR(
"invalid direction", procName, NULL);
371 bordval = (depth == 1) ? 1 : 0;
372 size = (n - 1) * spacing;
374 for (i = 0; i < n; i++) {
376 L_WARNING(
"missing pix at index %d\n", procName, i);
380 if (scalefactor != 1.0)
381 pix2 =
pixScale(pix1, scalefactor, scalefactor);
391 if (direction == L_HORIZ) {
447 l_int32 n, nw, nh, w, h, d, wt, ht, res, samedepth;
448 l_int32 index, i, j, hascmap;
451 PIX *pix1, *pix2, *pixd;
454 PROCNAME(
"pixaDisplayOnLattice");
456 if (pncols) *pncols = 0;
457 if (pboxa) *pboxa = NULL;
459 return (
PIX *)ERROR_PTR(
"pixa not defined", procName, NULL);
463 return (
PIX *)ERROR_PTR(
"no components", procName, NULL);
466 if (hascmap || !samedepth) {
468 for (i = 0; i < n; i++) {
479 nw = (l_int32)sqrt((l_float64)n);
480 nh = (n + nw - 1) / nw;
486 d = pixGetDepth(pix1);
487 res = pixGetXRes(pix1);
489 if ((pixd =
pixCreate(w, h, d)) == NULL) {
491 return (
PIX *)ERROR_PTR(
"pixd not made", procName, NULL);
499 for (i = 0; i < nh; i++) {
500 for (j = 0; j < nw && index < n; j++, index++) {
503 if (wt > cellw || ht > cellh) {
504 L_INFO(
"pix(%d) omitted; size %dx%x\n", procName, index,
513 box =
boxCreate(j * cellw, i * cellh, wt, ht);
520 snprintf(buf,
sizeof(buf),
"n = %d",
boxaGetCount(boxa));
523 if (pncols) *pncols = nw;
561 l_uint32 bordercolor)
563 l_int32 w, h, d, wt, ht;
564 l_int32 i, j, k, x, y, n;
567 PROCNAME(
"pixaDisplayUnsplit");
570 return (
PIX *)ERROR_PTR(
"pixa not defined", procName, NULL);
571 if (nx <= 0 || ny <= 0)
572 return (
PIX *)ERROR_PTR(
"nx and ny must be > 0", procName, NULL);
574 return (
PIX *)ERROR_PTR(
"no components", procName, NULL);
576 return (
PIX *)ERROR_PTR(
"n != nx * ny", procName, NULL);
577 borderwidth = L_MAX(0, borderwidth);
580 w = nx * (wt + 2 * borderwidth);
581 h = ny * (ht + 2 * borderwidth);
584 return (
PIX *)ERROR_PTR(
"pixd not made", procName, NULL);
592 for (i = 0, k = 0; i < ny; i++) {
594 for (j = 0; j < nx; j++, k++) {
598 x += wt + 2 * borderwidth;
600 y += ht + 2 * borderwidth;
637 l_int32 wmax, hmax, wd, hd, d, hascmap, res, same;
638 l_int32 i, j, n, ni, ncols, nrows;
639 l_int32 ystart, xstart, wt, ht;
640 PIX *pix1, *pix2, *pixd;
643 PROCNAME(
"pixaDisplayTiled");
646 return (
PIX *)ERROR_PTR(
"pixa not defined", procName, NULL);
647 spacing = L_MAX(spacing, 0);
649 return (
PIX *)ERROR_PTR(
"no components", procName, NULL);
655 for (i = 0; i < n; i++) {
669 return (
PIX *)ERROR_PTR(
"depths not equal", procName, NULL);
674 ncols = (l_int32)((l_float32)(maxwidth - spacing) /
675 (l_float32)(wmax + spacing));
676 ncols = L_MAX(ncols, 1);
677 nrows = (n + ncols - 1) / ncols;
678 wd = wmax * ncols + spacing * (ncols + 1);
679 hd = hmax * nrows + spacing * (nrows + 1);
680 if ((pixd =
pixCreate(wd, hd, d)) == NULL) {
682 return (
PIX *)ERROR_PTR(
"pixd not made", procName, NULL);
686 if ((background == 1 && d == 1) || (background == 0 && d != 1))
690 for (i = 0, ni = 0; i < nrows; i++) {
691 ystart = spacing + i * (hmax + spacing);
692 for (j = 0; j < ncols && ni < n; j++, ni++) {
693 xstart = spacing + j * (wmax + spacing);
695 if (ni == 0) res = pixGetXRes(pix1);
749 l_float32 scalefactor,
756 l_int32 bordval, wtry, wt, ht;
760 l_int32 i, j, index, n, x, y, nrows, ninrow, res;
766 PIX *pix, *pixn, *pix1, *pixd;
769 PROCNAME(
"pixaDisplayTiledInRows");
772 return (
PIX *)ERROR_PTR(
"pixa not defined", procName, NULL);
773 if (outdepth != 1 && outdepth != 8 && outdepth != 32)
774 return (
PIX *)ERROR_PTR(
"outdepth not in {1, 8, 32}", procName, NULL);
775 spacing = L_MAX(spacing, 0);
776 border = L_MAX(border, 0);
777 if (scalefactor <= 0.0) scalefactor = 1.0;
780 return (
PIX *)ERROR_PTR(
"no components", procName, NULL);
784 bordval = (outdepth == 1) ? 1 : 0;
785 for (i = 0; i < n; i++) {
791 else if (outdepth == 8)
797 if (scalefactor != 1.0)
798 pix1 =
pixScale(pixn, scalefactor, scalefactor);
812 L_WARNING(
"only got %d components\n", procName, n);
815 return (
PIX *)ERROR_PTR(
"no components", procName, NULL);
825 for (i = 0, irow = 0; i < n; i++, irow++) {
827 wtry = w + wt + spacing;
828 if (wtry > maxwidth) {
831 wmaxrow = L_MAX(wmaxrow, w);
834 w = wt + 2 * spacing;
838 maxh = L_MAX(maxh, ht);
845 wmaxrow = L_MAX(wmaxrow, w);
848 if ((pixd =
pixCreate(wmaxrow, h, outdepth)) == NULL) {
852 return (
PIX *)ERROR_PTR(
"pixd not made", procName, NULL);
856 if ((background == 1 && outdepth == 1) ||
857 (background == 0 && outdepth != 1))
865 for (i = 0, index = 0; i < nrows; i++) {
869 for (j = 0; j < ninrow; j++, index++) {
872 res = pixGetXRes(pix);
877 wt - 2 * border, ht - 2 *border),
L_INSERT);
932 l_float32 scalefactor,
936 l_int32 i, j, index, n, x, y, nrows, wb, hb, w, h, maxd, maxh, bordval, res;
941 PIX *pix1, *pix2, *pix3, *pixd;
944 PROCNAME(
"pixaDisplayTiledInColumns");
947 return (
PIX *)ERROR_PTR(
"pixas not defined", procName, NULL);
948 border = L_MAX(border, 0);
949 if (scalefactor <= 0.0) scalefactor = 1.0;
951 return (
PIX *)ERROR_PTR(
"no components", procName, NULL);
959 bordval = (maxd == 1) ? 1 : 0;
960 for (i = 0; i < n; i++) {
963 if (scalefactor != 1.0)
964 pix2 =
pixScale(pix1, scalefactor, scalefactor);
971 if (i == 0) res = pixGetXRes(pix3);
979 L_WARNING(
"only got %d components\n", procName, n);
982 return (
PIX *)ERROR_PTR(
"no components", procName, NULL);
988 nrows = (n + nx - 1) / nx;
990 for (i = 0, index = 0; i < nrows; i++) {
993 for (j = 0; j < nx && index < n; j++) {
997 maxh = L_MAX(maxh, hb + spacing);
1007 pixd =
pixaDisplay(pixa2, w + spacing, h + spacing);
1053 l_int32 x, y, w, h, wd, hd, d, res;
1054 l_int32 i, n, nrows, maxht, ninrow, irow, bordval;
1056 l_float32 scalefact;
1057 PIX *pix, *pixn, *pix1, *pixb, *pixd;
1060 PROCNAME(
"pixaDisplayTiledAndScaled");
1063 return (
PIX *)ERROR_PTR(
"pixa not defined", procName, NULL);
1064 if (outdepth != 1 && outdepth != 8 && outdepth != 32)
1065 return (
PIX *)ERROR_PTR(
"outdepth not in {1, 8, 32}", procName, NULL);
1067 return (
PIX *)ERROR_PTR(
"ncols must be > 0", procName, NULL);
1068 spacing = L_MAX(spacing, 0);
1069 if (border < 0 || border > tilewidth / 5)
1072 return (
PIX *)ERROR_PTR(
"no components", procName, NULL);
1076 bordval = (outdepth == 1) ? 1 : 0;
1077 for (i = 0; i < n; i++) {
1082 scalefact = (l_float32)(tilewidth - 2 * border) / (l_float32)w;
1083 if (d == 1 && outdepth > 1 && scalefact < 1.0)
1086 pix1 =
pixScale(pix, scalefact, scalefact);
1090 else if (outdepth == 8)
1107 return (
PIX *)ERROR_PTR(
"no components", procName, NULL);
1111 wd = tilewidth * ncols + spacing * (ncols + 1);
1112 nrows = (n + ncols - 1) / ncols;
1113 if ((rowht = (l_int32 *)LEPT_CALLOC(nrows,
sizeof(l_int32))) == NULL) {
1115 return (
PIX *)ERROR_PTR(
"rowht array not made", procName, NULL);
1120 for (i = 0; i < n; i++) {
1124 maxht = L_MAX(h, maxht);
1125 if (ninrow == ncols) {
1126 rowht[irow] = maxht;
1133 rowht[irow] = maxht;
1137 hd = spacing * (nrows + 1);
1138 for (i = 0; i < nrows; i++)
1142 if ((background == 1 && outdepth == 1) ||
1143 (background == 0 && outdepth != 1))
1149 for (i = 0; i < n; i++) {
1152 res = pixGetXRes(pix);
1156 if (i && ((i % ncols) == 0)) {
1158 y += spacing + rowht[irow];
1162 x += tilewidth + spacing;
1202 l_float32 scalefactor,
1212 PIX *pix1, *pix2, *pix3, *pix4, *pixd;
1215 PROCNAME(
"pixaDisplayTiledWithText");
1218 return (
PIX *)ERROR_PTR(
"pixa not defined", procName, NULL);
1220 return (
PIX *)ERROR_PTR(
"no components", procName, NULL);
1222 return (
PIX *)ERROR_PTR(
"invalid maxwidth", procName, NULL);
1223 spacing = L_MAX(spacing, 0);
1224 border = L_MAX(border, 0);
1225 if (scalefactor <= 0.0) scalefactor = 1.0;
1226 if (fontsize < 4 || fontsize > 20 || (fontsize & 1)) {
1227 l_int32 fsize = L_MAX(L_MIN(fontsize, 20), 4);
1228 if (fsize & 1) fsize--;
1229 L_WARNING(
"changed fontsize from %d to %d\n", procName,
1236 maxwidth = L_MAX(maxwidth, scalefactor * (maxw + 2 * spacing + 2 * border));
1240 for (i = 0; i < n; i++) {
1244 spacing / 2, 0xffffff00);
1246 if (textstr && strlen(textstr) > 0) {
1247 snprintf(buf,
sizeof(buf),
"%s", textstr);
1261 0, spacing, border);
1306 l_int32 i, n, x, y, w, h, yval, index;
1311 PIX *pix1, *pix2, *pix3, *pix4, *pix5, *pixd;
1314 PROCNAME(
"pixaDisplayTiledByIndex");
1317 return (
PIX *)ERROR_PTR(
"pixa not defined", procName, NULL);
1319 return (
PIX *)ERROR_PTR(
"na not defined", procName, NULL);
1321 return (
PIX *)ERROR_PTR(
"no pixa components", procName, NULL);
1323 return (
PIX *)ERROR_PTR(
"pixa and na counts differ", procName, NULL);
1325 return (
PIX *)ERROR_PTR(
"invalid width", procName, NULL);
1327 L_WARNING(
"very small width: %d\n", procName, width);
1328 spacing = L_MAX(spacing, 0);
1329 border = L_MAX(border, 0);
1330 if (fontsize < 4 || fontsize > 20 || (fontsize & 1)) {
1331 l_int32 fsize = L_MAX(L_MIN(fontsize, 20), 4);
1332 if (fsize & 1) fsize--;
1333 L_WARNING(
"changed fontsize from %d to %d\n", procName,
1343 for (i = 0; i < n; i++) {
1351 if (textstr && strlen(textstr) > 0) {
1352 snprintf(buf,
sizeof(buf),
"%s", textstr);
1358 x = spacing + border + index * (2 * border + width + spacing);
1361 yval += h + spacing;
1423 l_float32 scalefactor,
1432 l_int32 i, n, w, maxd, maxd1, maxd2, res, text;
1434 PIX *pixs1, *pixs2, *pix1, *pix2, *pix3, *pix4;
1435 PIX *pix5, *pix6, *pix7, *pix8, *pix9;
1436 PIXA *pixa1, *pixa2;
1439 PROCNAME(
"pixaDisplayPairTiledInColumns");
1442 return (
PIX *)ERROR_PTR(
"pixas1 not defined", procName, NULL);
1444 return (
PIX *)ERROR_PTR(
"pixas2 not defined", procName, NULL);
1445 spacing1 = L_MAX(spacing1, 0);
1446 spacing2 = L_MAX(spacing2, 0);
1447 border1 = L_MAX(border1, 0);
1448 border2 = L_MAX(border2, 0);
1449 if (scalefactor <= 0.0) scalefactor = 1.0;
1451 return (
PIX *)ERROR_PTR(
"no components", procName, NULL);
1453 return (
PIX *)ERROR_PTR(
"pixa sizes differ", procName, NULL);
1454 text = (fontsize <= 0) ? 0 : 1;
1455 if (text && (fontsize < 4 || fontsize > 20 || (fontsize & 1))) {
1456 l_int32 fsize = L_MAX(L_MIN(fontsize, 20), 4);
1457 if (fsize & 1) fsize--;
1458 L_WARNING(
"changed fontsize from %d to %d\n", procName,
1469 maxd = L_MAX(maxd1, maxd2);
1475 for (i = 0; i < n; i++) {
1478 if (!pixs1 || !pixs2)
continue;
1482 }
else if (maxd == 8) {
1491 if (scalefactor != 1.0) {
1492 pix3 =
pixScale(pix1, scalefactor, scalefactor);
1493 pix4 =
pixScale(pix2, scalefactor, scalefactor);
1509 if (i == 0) res = pixGetXRes(pix3);
1546 border2, fontsize, 0xff000000);
1576 l_int32 i, j, n, nbox, na, d, wmax, hmax, x, y, xb, yb, wb, hb;
1582 PROCNAME(
"pixaaDisplay");
1585 return (
PIX *)ERROR_PTR(
"paa not defined", procName, NULL);
1589 return (
PIX *)ERROR_PTR(
"no components", procName, NULL);
1595 if (w == 0 || h == 0) {
1600 for (i = 0; i < n; i++) {
1604 wmax = L_MAX(wmax, w);
1605 hmax = L_MAX(hmax, h);
1617 d = pixGetDepth(pix1);
1621 if ((pixd =
pixCreate(w, h, d)) == NULL) {
1623 return (
PIX *)ERROR_PTR(
"pixd not made", procName, NULL);
1627 for (i = 0; i < n; i++) {
1632 for (j = 0; j < na; j++) {
1677 l_float32 scalefactor,
1684 PIXA *pixa1, *pixa2;
1686 PROCNAME(
"pixaaDisplayByPixa");
1689 return (
PIX *)ERROR_PTR(
"paa not defined", procName, NULL);
1690 if (scalefactor <= 0.0) scalefactor = 1.0;
1691 if (hspacing < 0) hspacing = 0;
1692 if (vspacing < 0) vspacing = 0;
1693 if (border < 0) border = 0;
1696 return (
PIX *)ERROR_PTR(
"no components", procName, NULL);
1700 for (i = 0; i < n; i++) {
1708 vs = vspacing - 2 * hspacing;
1750 PROCNAME(
"pixaaDisplayTiledAndScaled");
1753 return (
PIXA *)ERROR_PTR(
"paa not defined", procName, NULL);
1754 if (outdepth != 1 && outdepth != 8 && outdepth != 32)
1755 return (
PIXA *)ERROR_PTR(
"outdepth not in {1, 8, 32}", procName, NULL);
1757 return (
PIXA *)ERROR_PTR(
"ncols must be > 0", procName, NULL);
1758 if (border < 0 || border > tilewidth / 5)
1762 return (
PIXA *)ERROR_PTR(
"no components", procName, NULL);
1765 for (i = 0; i < n; i++) {
1768 background, spacing, border);
1796 PROCNAME(
"pixaConvertTo1");
1799 return (
PIXA *)ERROR_PTR(
"pixas not defined", procName, NULL);
1803 for (i = 0; i < n; i++) {
1837 PROCNAME(
"pixaConvertTo8");
1840 return (
PIXA *)ERROR_PTR(
"pixas not defined", procName, NULL);
1844 for (i = 0; i < n; i++) {
1878 PROCNAME(
"pixaConvertTo8Colormap");
1881 return (
PIXA *)ERROR_PTR(
"pixas not defined", procName, NULL);
1885 for (i = 0; i < n; i++) {
1919 PROCNAME(
"pixaConvertTo32");
1922 return (
PIXA *)ERROR_PTR(
"pixas not defined", procName, NULL);
1926 for (i = 0; i < n; i++) {
1972 l_int32 i, n, nselect, index;
1977 PROCNAME(
"pixaConstrainedSelect");
1980 return (
PIXA *)ERROR_PTR(
"pixas not defined", procName, NULL);
1982 first = L_MAX(0, first);
1983 last = (last < 0) ? n - 1 : L_MIN(n - 1, last);
1985 return (
PIXA *)ERROR_PTR(
"last < first!", procName, NULL);
1987 return (
PIXA *)ERROR_PTR(
"nmax < 1!", procName, NULL);
1992 for (i = 0; i < nselect; i++) {
2037 l_float32 scalefactor,
2042 const char *fileout)
2047 PIXA *pixa1, *pixa2;
2049 PROCNAME(
"pixaSelectToPdf");
2052 return ERROR_INT(
"pixas not defined", procName, 1);
2054 L_WARNING(
"invalid compression type; using default\n", procName);
2058 return ERROR_INT(
"fileout not defined", procName, 1);
2062 first = L_MAX(0, first);
2063 last = (last < 0) ? n - 1 : L_MIN(n - 1, last);
2065 L_ERROR(
"first = %d > last = %d\n", procName, first, last);
2071 bmf = (fontsize <= 0) ? NULL :
bmfCreate(NULL, fontsize);
2120 PIXA *pixad, *pixa1;
2122 PROCNAME(
"pixaMakeFromTiledPixa");
2125 return (
PIXA *)ERROR_PTR(
"pixas not defined", procName, NULL);
2127 return (
PIXA *)ERROR_PTR(
"nsamp too large; typ. 100", procName, NULL);
2131 if (nsamp <= 0) nsamp = 100;
2138 for (i = 0; i < 10; i++) {
2142 L_WARNING(
"requested %d; only %d tiles\n", procName, nsamp, ntiles);
2144 snprintf(buf,
sizeof(buf),
"%d", i);
2199 l_int32 i, j, k, ws, hs, d, nx, ny, n, n_isvalid, ntiles, nmax;
2204 PROCNAME(
"pixaMakeFromTiledPix");
2207 return (
PIXA *)ERROR_PTR(
"pixs not defined", procName, NULL);
2208 if (!boxa && (w <= 0 || h <= 0))
2209 return (
PIXA *)ERROR_PTR(
"w and h must be > 0", procName, NULL);
2218 if (nx < 1 || ny < 1)
2219 return (
PIXA *)ERROR_PTR(
"invalid dimensions", procName, NULL);
2220 if (nx * w != ws || ny * h != hs)
2221 L_WARNING(
"some tiles will be clipped\n", procName);
2227 n_isvalid = (n <= nx * ny && n > nx * (ny - 1)) ? TRUE : FALSE;
2228 ntiles = (n_isvalid) ? n : nx * ny;
2229 nmax = ntiles - start;
2230 num = (num == 0) ? nmax : L_MIN(num, nmax);
2234 return (
PIXA *)ERROR_PTR(
"pixa1 not made", procName, NULL);
2236 cmap = pixGetColormap(pixs);
2237 for (i = 0, k = 0; i < ny; i++) {
2238 for (j = 0; j < nx; j++, k++) {
2239 if (k < start)
continue;
2240 if (k >= start + num)
break;
2273 PROCNAME(
"pixGetTileCount");
2276 return ERROR_INT(
"&n not defined", procName, 1);
2279 return ERROR_INT(
"pix not defined", procName, 1);
2282 if (text && strlen(text) > 4) {
2283 if (sscanf(text,
"n = %d", &n) == 1)
2320 l_float32 scalefactor,
2324 l_int32 n, i, j, ntile, nout, index;
2326 PIXA *pixa1, *pixa2, *pixad;
2328 PROCNAME(
"pixaDisplayMultiTiled");
2331 return (
PIXA *)ERROR_PTR(
"pixas not defined", procName, NULL);
2332 if (nx < 1 || ny < 1 || nx > 50 || ny > 50)
2333 return (
PIXA *)ERROR_PTR(
"invalid tiling factor(s)", procName, NULL);
2335 return (
PIXA *)ERROR_PTR(
"pixas is empty", procName, NULL);
2338 if (maxw == 0 && maxh == 0) {
2341 maxw = (maxw == 0) ? 1000000 : maxw;
2342 maxh = (maxh == 0) ? 1000000 : maxh;
2349 nout = L_MAX(1, (n + ntile - 1) / ntile);
2351 for (i = 0, index = 0; i < nout; i++) {
2353 for (j = 0; j < ntile && index < n; j++, index++) {
2403 l_int32 i, j, index, n, nt;
2407 PROCNAME(
"pixaSplitIntoFiles");
2410 return ERROR_INT(
"pixas not defined", procName, 1);
2412 return ERROR_INT(
"nsplit must be >= 2", procName, 1);
2414 return ERROR_INT(
"pixas is empty", procName, 1);
2415 if (!write_pixa && !write_pix && !write_pdf)
2416 return ERROR_INT(
"no output is requested", procName, 1);
2419 n = (nt + nsplit - 1) / nsplit;
2420 lept_stderr(
"nt = %d, n = %d, nsplit = %d\n", nt, n, nsplit);
2421 for (i = 0, index = 0; i < nsplit; i++) {
2423 for (j = 0; j < n && index < nt; j++, index++) {
2425 pix2 =
pixScale(pix1, scale, scale);
2430 snprintf(buf,
sizeof(buf),
"/tmp/lept/split/split%d.pa", i + 1);
2434 snprintf(buf,
sizeof(buf),
"/tmp/lept/split/split%d.tif", i + 1);
2436 pixWriteDebug(buf, pix1, IFF_TIFF_G4);
2440 snprintf(buf,
sizeof(buf),
"/tmp/lept/split/split%d.pdf", i + 1);
2497 PROCNAME(
"convertToNUpFiles");
2500 return ERROR_INT(
"dir not defined", procName, 1);
2501 if (nx < 1 || ny < 1 || nx > 50 || ny > 50)
2502 return ERROR_INT(
"invalid tiling N-factor", procName, 1);
2503 if (fontsize < 0 || fontsize > 20 || fontsize & 1 || fontsize == 2)
2504 return ERROR_INT(
"invalid fontsize", procName, 1);
2506 return ERROR_INT(
"outdir not defined", procName, 1);
2511 return ERROR_INT(
"pixa not made", procName, 1);
2516 format = (d == 1) ? IFF_TIFF_G4 : IFF_JFIF_JPEG;
2519 pixaWriteFiles(rootpath, pixa, format);
2556 PIXA *pixa1, *pixa2;
2559 PROCNAME(
"convertToNUpPixa");
2562 return (
PIXA *)ERROR_PTR(
"dir not defined", procName, NULL);
2563 if (nx < 1 || ny < 1 || nx > 50 || ny > 50)
2564 return (
PIXA *)ERROR_PTR(
"invalid tiling N-factor", procName, NULL);
2566 return (
PIXA *)ERROR_PTR(
"tw must be >= 20", procName, NULL);
2567 if (fontsize < 0 || fontsize > 20 || fontsize & 1 || fontsize == 2)
2568 return (
PIXA *)ERROR_PTR(
"invalid fontsize", procName, NULL);
2574 for (i = 0; i < n; i++) {
2620 l_int32 i, j, k, nt, n2, nout, d;
2623 PIX *pix1, *pix2, *pix3, *pix4;
2624 PIXA *pixa1, *pixad;
2626 PROCNAME(
"pixaConvertToNUpPixa");
2629 return (
PIXA *)ERROR_PTR(
"pixas not defined", procName, NULL);
2630 if (nx < 1 || ny < 1 || nx > 50 || ny > 50)
2631 return (
PIXA *)ERROR_PTR(
"invalid tiling N-factor", procName, NULL);
2633 return (
PIXA *)ERROR_PTR(
"tw must be >= 20", procName, NULL);
2634 if (fontsize < 0 || fontsize > 20 || fontsize & 1 || fontsize == 2)
2635 return (
PIXA *)ERROR_PTR(
"invalid fontsize", procName, NULL);
2639 L_WARNING(
"pixa size %d not equal to sarray size %d\n", procName,
2644 nout = (nt + n2 - 1) / n2;
2646 bmf = (fontsize == 0) ? NULL :
bmfCreate(NULL, fontsize);
2647 for (i = 0, j = 0; i < nout; i++) {
2649 for (k = 0; k < n2 && j < nt; j++, k++) {
2732 const char *fileout)
2734 l_int32 n1, n2, npairs;
2735 PIXA *pixa3, *pixa4, *pixa5;
2738 PROCNAME(
"pixaCompareInPdf");
2740 if (!pixa1 || !pixa2)
2741 return ERROR_INT(
"pixa1 and pixa2 not both defined", procName, 1);
2742 if (nx < 1 || ny < 1 || nx > 20 || ny > 20)
2743 return ERROR_INT(
"invalid tiling factors", procName, 1);
2745 return ERROR_INT(
"invalid tw; tw must be >= 20", procName, 1);
2746 if (fontsize < 0 || fontsize > 20 || fontsize & 1 || fontsize == 2)
2747 return ERROR_INT(
"invalid fontsize", procName, 1);
2749 return ERROR_INT(
"fileout not defined", procName, 1);
2752 if (n1 == 0 || n2 == 0)
2753 return ERROR_INT(
"at least one pixa is empty", procName, 1);
2755 L_WARNING(
"sizes (%d, %d) differ; using the minimum in interleave\n",
2760 return ERROR_INT(
"pixa3 not made", procName, 1);
2770 2 * tw + 4 * border + spacing,
2771 spacing, border, fontsize);
PIX * pixaaDisplay(PIXAA *paa, l_int32 w, l_int32 h)
pixaaDisplay()
PIXA * pixaInterleave(PIXA *pixa1, PIXA *pixa2, l_int32 copyflag)
pixaInterleave()
void bmfDestroy(L_BMF **pbmf)
bmfDestroy()
PIX * pixConvertTo1(PIX *pixs, l_int32 threshold)
pixConvertTo1()
l_int32 lept_mkdir(const char *subdir)
lept_mkdir()
PIX * pixScaleToGray(PIX *pixs, l_float32 scalefactor)
pixScaleToGray()
PIX * pixConvertTo32(PIX *pixs)
pixConvertTo32()
l_int32 lept_roundftoi(l_float32 fval)
lept_roundftoi()
l_ok pixaSetText(PIXA *pixa, const char *text, SARRAY *sa)
pixaSetText()
SARRAY * sarrayGenerateIntegers(l_int32 n)
sarrayGenerateIntegers()
l_ok pixaWriteDebug(const char *fname, PIXA *pixa)
pixaWriteDebug()
l_ok pixaVerifyDepth(PIXA *pixa, l_int32 *psame, l_int32 *pmaxd)
pixaVerifyDepth()
l_ok numaAddNumber(NUMA *na, l_float32 val)
numaAddNumber()
PIXA * pixaCreate(l_int32 n)
pixaCreate()
PIXA * pixaaDisplayTiledAndScaled(PIXAA *paa, l_int32 outdepth, l_int32 tilewidth, l_int32 ncols, l_int32 background, l_int32 spacing, l_int32 border)
pixaaDisplayTiledAndScaled()
l_ok pixaSetBoxa(PIXA *pixa, BOXA *boxa, l_int32 accesstype)
pixaSetBoxa()
l_ok pixaJoin(PIXA *pixad, PIXA *pixas, l_int32 istart, l_int32 iend)
pixaJoin()
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()
PIXA * pixaaGetPixa(PIXAA *paa, l_int32 index, l_int32 accesstype)
pixaaGetPixa()
PIX * pixaDisplayLinearly(PIXA *pixas, l_int32 direction, l_float32 scalefactor, l_int32 background, l_int32 spacing, l_int32 border, BOXA **pboxa)
pixaDisplayLinearly()
PIX * pixaDisplayUnsplit(PIXA *pixa, l_int32 nx, l_int32 ny, l_int32 borderwidth, l_uint32 bordercolor)
pixaDisplayUnsplit()
PIXA * pixaDisplayMultiTiled(PIXA *pixas, l_int32 nx, l_int32 ny, l_int32 maxw, l_int32 maxh, l_float32 scalefactor, l_int32 spacing, l_int32 border)
pixaDisplayMultiTiled()
PIX * pixConvertTo8(PIX *pixs, l_int32 cmapflag)
pixConvertTo8()
l_int32 pixaaGetCount(PIXAA *paa, NUMA **pna)
pixaaGetCount()
NUMA * numaMakeConstant(l_float32 val, l_int32 size)
numaMakeConstant()
void lept_stderr(const char *fmt,...)
lept_stderr()
PIX * pixaDisplayOnLattice(PIXA *pixa, l_int32 cellw, l_int32 cellh, l_int32 *pncols, BOXA **pboxa)
pixaDisplayOnLattice()
PIX * pixCreate(l_int32 width, l_int32 height, l_int32 depth)
pixCreate()
SARRAY * sarrayCreate(l_int32 n)
sarrayCreate()
l_ok pixSetAll(PIX *pix)
pixSetAll()
PIXA * pixaConvertToSameDepth(PIXA *pixas)
pixaConvertToSameDepth()
NUMA * numaCreate(l_int32 n)
numaCreate()
l_ok pixaGetDepthInfo(PIXA *pixa, l_int32 *pmaxdepth, l_int32 *psame)
pixaGetDepthInfo()
void boxaDestroy(BOXA **pboxa)
boxaDestroy()
PIX * pixAddBlackOrWhiteBorder(PIX *pixs, l_int32 left, l_int32 right, l_int32 top, l_int32 bot, l_int32 op)
pixAddBlackOrWhiteBorder()
PIXA * pixaCreateFromBoxa(PIX *pixs, BOXA *boxa, l_int32 start, l_int32 num, l_int32 *pcropwarn)
pixaCreateFromBoxa()
PIX * pixaDisplay(PIXA *pixa, l_int32 w, l_int32 h)
pixaDisplay()
PIX * pixaDisplayTiledInColumns(PIXA *pixas, l_int32 nx, l_float32 scalefactor, l_int32 spacing, l_int32 border)
pixaDisplayTiledInColumns()
l_ok numaSetValue(NUMA *na, l_int32 index, l_float32 val)
numaSetValue()
l_ok pixSetColormap(PIX *pix, PIXCMAP *colormap)
pixSetColormap()
l_ok modifyTrailingSlash(char *path, size_t nbytes, l_int32 flag)
modifyTrailingSlash()
l_ok pixaSelectToPdf(PIXA *pixas, l_int32 first, l_int32 last, l_int32 res, l_float32 scalefactor, l_int32 type, l_int32 quality, l_uint32 color, l_int32 fontsize, const char *fileout)
pixaSelectToPdf()
l_ok pixaSplitIntoFiles(PIXA *pixas, l_int32 nsplit, l_float32 scale, l_int32 outwidth, l_int32 write_pixa, l_int32 write_pix, l_int32 write_pdf)
pixaSplitIntoFiles()
PIX * pixAddBorder(PIX *pixs, l_int32 npix, l_uint32 val)
pixAddBorder()
PIXA * pixaConvertTo8(PIXA *pixas, l_int32 cmapflag)
pixaConvertTo8()
l_ok pixSetText(PIX *pix, const char *textstring)
pixSetText()
l_ok pixSetAllArbitrary(PIX *pix, l_uint32 val)
pixSetAllArbitrary()
PIXA * pixaCopy(PIXA *pixa, l_int32 copyflag)
pixaCopy()
PIXA * pixaConstrainedSelect(PIXA *pixas, l_int32 first, l_int32 last, l_int32 nmax, l_int32 use_pairs, l_int32 copyflag)
pixaConstrainedSelect()
NUMA * genConstrainedNumaInRange(l_int32 first, l_int32 last, l_int32 nmax, l_int32 use_pairs)
genConstrainedNumaInRange()
PIX * pixaDisplayRandomCmap(PIXA *pixa, l_int32 w, l_int32 h)
pixaDisplayRandomCmap()
l_ok numaGetIValue(NUMA *na, l_int32 index, l_int32 *pival)
numaGetIValue()
l_ok pixaAddPix(PIXA *pixa, PIX *pix, l_int32 copyflag)
pixaAddPix()
PIX * pixaDisplayTiledByIndex(PIXA *pixa, NUMA *na, l_int32 width, l_int32 spacing, l_int32 border, l_int32 fontsize, l_uint32 textcolor)
pixaDisplayTiledByIndex()
l_int32 numaGetCount(NUMA *na)
numaGetCount()
l_ok sarrayAddString(SARRAY *sa, const char *string, l_int32 copyflag)
sarrayAddString()
l_ok boxaGetBoxGeometry(BOXA *boxa, l_int32 index, l_int32 *px, l_int32 *py, l_int32 *pw, l_int32 *ph)
boxaGetBoxGeometry()
PIX * pixaDisplayTiledInRows(PIXA *pixa, l_int32 outdepth, l_int32 maxwidth, l_float32 scalefactor, l_int32 background, l_int32 spacing, l_int32 border)
pixaDisplayTiledInRows()
l_ok boxaAddBox(BOXA *boxa, BOX *box, l_int32 copyflag)
boxaAddBox()
PIXA * pixaSelectBySize(PIXA *pixas, l_int32 width, l_int32 height, l_int32 type, l_int32 relation, l_int32 *pchanged)
pixaSelectBySize()
PIX * pixConvertTo8Colormap(PIX *pixs, l_int32 dither)
pixConvertTo8Colormap()
l_ok pixSetBlackOrWhite(PIX *pixs, l_int32 op)
pixSetBlackOrWhite()
l_ok pixGetTileCount(PIX *pix, l_int32 *pn)
pixGetTileCount()
char * sarrayGetString(SARRAY *sa, l_int32 index, l_int32 copyflag)
sarrayGetString()
l_ok pixaGetBoxGeometry(PIXA *pixa, l_int32 index, l_int32 *px, l_int32 *py, l_int32 *pw, l_int32 *ph)
pixaGetBoxGeometry()
PIX * pixaaDisplayByPixa(PIXAA *paa, l_int32 maxnx, l_float32 scalefactor, l_int32 hspacing, l_int32 vspacing, l_int32 border)
pixaaDisplayByPixa()
PIX * pixClone(PIX *pixs)
pixClone()
PIX * pixaDisplayTiledAndScaled(PIXA *pixa, l_int32 outdepth, l_int32 tilewidth, l_int32 ncols, l_int32 background, l_int32 spacing, l_int32 border)
pixaDisplayTiledAndScaled()
PIX * pixScaleToSize(PIX *pixs, l_int32 wd, l_int32 hd)
pixScaleToSize()
void pixDestroy(PIX **ppix)
pixDestroy()
NUMA * numaMakeSequence(l_float32 startval, l_float32 increment, l_int32 size)
numaMakeSequence()
l_ok pixaCompareInPdf(PIXA *pixa1, PIXA *pixa2, l_int32 nx, l_int32 ny, l_int32 tw, l_int32 spacing, l_int32 border, l_int32 fontsize, const char *fileout)
pixaCompareInPdf()
SARRAY * getSortedPathnamesInDirectory(const char *dirname, const char *substr, l_int32 first, l_int32 nfiles)
getSortedPathnamesInDirectory()
l_ok boxaWriteMem(l_uint8 **pdata, size_t *psize, BOXA *boxa)
boxaWriteMem()
l_ok boxaGetExtent(BOXA *boxa, l_int32 *pw, l_int32 *ph, BOX **pbox)
boxaGetExtent()
l_ok splitPathAtDirectory(const char *pathname, char **pdir, char **ptail)
splitPathAtDirectory()
l_ok convertToNUpFiles(const char *dir, const char *substr, l_int32 nx, l_int32 ny, l_int32 tw, l_int32 spacing, l_int32 border, l_int32 fontsize, const char *outdir)
convertToNUpFiles()
PIXA * pixaReadFilesSA(SARRAY *sa)
pixaReadFilesSA()
void numaDestroy(NUMA **pna)
numaDestroy()
l_ok pixGetDimensions(const PIX *pix, l_int32 *pw, l_int32 *ph, l_int32 *pd)
pixGetDimensions()
PIXA * pixaMakeFromTiledPixa(PIXA *pixas, l_int32 w, l_int32 h, l_int32 nsamp)
pixaMakeFromTiledPixa()
l_ok pixaSizeRange(PIXA *pixa, l_int32 *pminw, l_int32 *pminh, l_int32 *pmaxw, l_int32 *pmaxh)
pixaSizeRange()
l_int32 sarrayGetCount(SARRAY *sa)
sarrayGetCount()
char * pixGetText(PIX *pix)
pixGetText()
l_ok pixaGetRenderingDepth(PIXA *pixa, l_int32 *pdepth)
pixaGetRenderingDepth()
l_ok pixaConvertToPdf(PIXA *pixa, l_int32 res, l_float32 scalefactor, l_int32 type, l_int32 quality, const char *title, const char *fileout)
pixaConvertToPdf()
PIX * pixaGetPix(PIXA *pixa, l_int32 index, l_int32 accesstype)
pixaGetPix()
PIXA * pixaMakeFromTiledPix(PIX *pixs, l_int32 w, l_int32 h, l_int32 start, l_int32 num, BOXA *boxa)
pixaMakeFromTiledPix()
l_ok makeTempDirname(char *result, size_t nbytes, const char *subdir)
makeTempDirname()
PIXA * convertToNUpPixa(const char *dir, const char *substr, l_int32 nx, l_int32 ny, l_int32 tw, l_int32 spacing, l_int32 border, l_int32 fontsize)
convertToNUpPixa()
l_ok pixaGetPixDimensions(PIXA *pixa, l_int32 index, l_int32 *pw, l_int32 *ph, l_int32 *pd)
pixaGetPixDimensions()
BOXA * boxaCreate(l_int32 n)
boxaCreate()
PIXA * pixaConvertTo32(PIXA *pixas)
pixaConvertTo32()
l_ok pixCopyColormap(PIX *pixd, const PIX *pixs)
pixCopyColormap()
PIX * pixConvert1To8(PIX *pixd, PIX *pixs, l_uint8 val0, l_uint8 val1)
pixConvert1To8()
PIX * pixaDisplayPairTiledInColumns(PIXA *pixas1, PIXA *pixas2, l_int32 nx, l_float32 scalefactor, l_int32 spacing1, l_int32 spacing2, l_int32 border1, l_int32 border2, l_int32 fontsize, l_int32 startindex, SARRAY *sa)
pixaDisplayPairTiledInColumns()
PIXA * pixaConvertTo8Colormap(PIXA *pixas, l_int32 dither)
pixaConvertTo8Colormap()
PIX * pixAddTextlines(PIX *pixs, L_BMF *bmf, const char *textstr, l_uint32 val, l_int32 location)
pixAddTextlines()
l_int32 boxaGetCount(BOXA *boxa)
boxaGetCount()
PIXA * pixaConvertToNUpPixa(PIXA *pixas, SARRAY *sa, l_int32 nx, l_int32 ny, l_int32 tw, l_int32 spacing, l_int32 border, l_int32 fontsize)
pixaConvertToNUpPixa()
BOXA * pixaaGetBoxa(PIXAA *paa, l_int32 accesstype)
pixaaGetBoxa()
l_ok pixSetResolution(PIX *pix, l_int32 xres, l_int32 yres)
pixSetResolution()
PIXA * pixaConvertTo1(PIXA *pixas, l_int32 thresh)
pixaConvertTo1()
l_ok numaGetMax(NUMA *na, l_float32 *pmaxval, l_int32 *pimaxloc)
numaGetMax()
PIXA * pixaSelectRange(PIXA *pixas, l_int32 first, l_int32 last, l_int32 copyflag)
pixaSelectRange()
l_int32 lept_rmdir(const char *subdir)
lept_rmdir()
PIX * pixaDisplayTiledWithText(PIXA *pixa, l_int32 maxwidth, l_float32 scalefactor, l_int32 spacing, l_int32 border, l_int32 fontsize, l_uint32 textcolor)
pixaDisplayTiledWithText()
PIXCMAP * pixcmapCopy(const PIXCMAP *cmaps)
pixcmapCopy()
SARRAY * numaConvertToSarray(NUMA *na, l_int32 size1, l_int32 size2, l_int32 addzeros, l_int32 type)
numaConvertToSarray()
l_ok pixaAddBox(PIXA *pixa, BOX *box, l_int32 copyflag)
pixaAddBox()
PIX * pixScale(PIX *pixs, l_float32 scalex, l_float32 scaley)
pixScale()
void pixaDestroy(PIXA **ppixa)
pixaDestroy()
PIX * pixAddSingleTextblock(PIX *pixs, L_BMF *bmf, const char *textstr, l_uint32 val, l_int32 location, l_int32 *poverflow)
pixAddSingleTextblock()
BOX * boxCreate(l_int32 x, l_int32 y, l_int32 w, l_int32 h)
boxCreate()
l_int32 pixaGetCount(PIXA *pixa)
pixaGetCount()
PIX * pixAddBorderGeneral(PIX *pixs, l_int32 left, l_int32 right, l_int32 top, l_int32 bot, l_uint32 val)
pixAddBorderGeneral()
PIXA * pixaAddTextNumber(PIXA *pixas, L_BMF *bmf, NUMA *na, l_uint32 val, l_int32 location)
pixaAddTextNumber()
void sarrayDestroy(SARRAY **psa)
sarrayDestroy()
PIX * pixaDisplayTiled(PIXA *pixa, l_int32 maxwidth, l_int32 background, l_int32 spacing)
pixaDisplayTiled()
l_ok pixaAnyColormaps(PIXA *pixa, l_int32 *phascmap)
pixaAnyColormaps()
PIXCMAP * pixcmapCreateRandom(l_int32 depth, l_int32 hasblack, l_int32 haswhite)
pixcmapCreateRandom()
L_BMF * bmfCreate(const char *dir, l_int32 fontsize)
bmfCreate()
BOXA * pixaGetBoxa(PIXA *pixa, l_int32 accesstype)
pixaGetBoxa()