136 #include <config_auto.h> 140 #include "allheaders.h" 143 static const size_t MaxInitPtrArraySize = 100000;
144 static const size_t MaxPixaPtrArraySize = 5000000;
145 static const size_t MaxPixaaPtrArraySize = 1000000;
171 PROCNAME(
"pixaCreate");
173 if (n <= 0 || n > MaxInitPtrArraySize)
176 pixa = (
PIXA *)LEPT_CALLOC(1,
sizeof(
PIXA));
180 pixa->
pix = (
PIX **)LEPT_CALLOC(n,
sizeof(
PIX *));
182 if (!pixa->
pix || !pixa->
boxa) {
184 return (
PIXA *)ERROR_PTR(
"pix or boxa not made", procName, NULL);
211 l_int32 w, h, d, nw, nh, i, j, index;
215 PROCNAME(
"pixaCreateFromPix");
218 return (
PIXA *)ERROR_PTR(
"pixs not defined", procName, NULL);
220 return (
PIXA *)ERROR_PTR(
"n must be > 0", procName, NULL);
223 return (
PIXA *)ERROR_PTR(
"pixa not made", procName, NULL);
225 if ((pix1 =
pixCreate(cellw, cellh, d)) == NULL) {
227 return (
PIXA *)ERROR_PTR(
"pix1 not made", procName, NULL);
230 nw = (w + cellw - 1) / cellw;
231 nh = (h + cellh - 1) / cellh;
232 for (i = 0, index = 0; i < nh; i++) {
233 for (j = 0; j < nw && index < n; j++, index++) {
235 j * cellw, i * cellh);
278 l_int32 i, n, end, w, h, wbox, hbox, cropwarn;
283 PROCNAME(
"pixaCreateFromBoxa");
286 return (
PIXA *)ERROR_PTR(
"pixs not defined", procName, NULL);
288 return (
PIXA *)ERROR_PTR(
"boxa not defined", procName, NULL);
290 return (
PIXA *)ERROR_PTR(
"num must be >= 0", procName, NULL);
293 end = (num == 0) ? n - 1 : L_MIN(start + num - 1, n - 1);
294 if ((pixad =
pixaCreate(end - start + 1)) == NULL)
295 return (
PIXA *)ERROR_PTR(
"pixad not made", procName, NULL);
300 if (wbox > w || hbox > h)
303 *pcropwarn = cropwarn;
305 for (i = start; i <= end; i++) {
354 l_uint32 bordercolor)
356 l_int32 w, h, d, cellw, cellh, i, j;
360 PROCNAME(
"pixaSplitPix");
363 return (
PIXA *)ERROR_PTR(
"pixs not defined", procName, NULL);
364 if (nx <= 0 || ny <= 0)
365 return (
PIXA *)ERROR_PTR(
"nx and ny must be > 0", procName, NULL);
366 borderwidth = L_MAX(0, borderwidth);
369 return (
PIXA *)ERROR_PTR(
"pixa not made", procName, NULL);
371 cellw = (w + nx - 1) / nx;
372 cellh = (h + ny - 1) / ny;
374 for (i = 0; i < ny; i++) {
375 for (j = 0; j < nx; j++) {
376 if ((pix1 =
pixCreate(cellw + 2 * borderwidth,
377 cellh + 2 * borderwidth, d)) == NULL) {
379 return (
PIXA *)ERROR_PTR(
"pix1 not made", procName, NULL);
382 if (borderwidth == 0) {
390 pixRasterop(pix1, borderwidth, borderwidth, cellw, cellh,
391 PIX_SRC, pixs, j * cellw, i * cellh);
417 PROCNAME(
"pixaDestroy");
420 L_WARNING(
"ptr address is NULL!\n", procName);
424 if ((pixa = *ppixa) == NULL)
430 for (i = 0; i < pixa->
n; i++)
432 LEPT_FREE(pixa->
pix);
461 PROCNAME(
"pixaCopy");
464 return (
PIXA *)ERROR_PTR(
"pixa not defined", procName, NULL);
472 return (
PIXA *)ERROR_PTR(
"invalid copyflag", procName, NULL);
475 return (
PIXA *)ERROR_PTR(
"pixac not made", procName, NULL);
477 for (i = 0; i < pixa->
n; i++) {
513 PROCNAME(
"pixaAddPix");
516 return ERROR_INT(
"pixa not defined", procName, 1);
518 return ERROR_INT(
"pix not defined", procName, 1);
522 else if (copyflag ==
L_COPY)
527 return ERROR_INT(
"invalid copyflag", procName, 1);
529 return ERROR_INT(
"pixc not made", procName, 1);
536 return ERROR_INT(
"extension failed", procName, 1);
559 PROCNAME(
"pixaAddBox");
562 return ERROR_INT(
"pixa not defined", procName, 1);
564 return ERROR_INT(
"box not defined", procName, 1);
566 return ERROR_INT(
"invalid copyflag", procName, 1);
588 PROCNAME(
"pixaExtendArray");
591 return ERROR_INT(
"pixa not defined", procName, 1);
615 size_t oldsize, newsize;
617 PROCNAME(
"pixaExtendArrayToSize");
620 return ERROR_INT(
"pixa not defined", procName, 1);
621 if (pixa->
nalloc > MaxPixaPtrArraySize)
622 return ERROR_INT(
"pixa has too many ptrs", procName, 1);
623 if (size > MaxPixaPtrArraySize)
624 return ERROR_INT(
"size > 5M ptrs; too large", procName, 1);
625 if (size <= pixa->nalloc) {
626 L_INFO(
"size too small; no extension\n", procName);
631 newsize = size *
sizeof(
PIX *);
633 oldsize, newsize)) == NULL)
634 return ERROR_INT(
"new ptr array not returned", procName, 1);
652 PROCNAME(
"pixaGetCount");
655 return ERROR_INT(
"pixa not defined", procName, 0);
672 PROCNAME(
"pixaChangeRefcount");
675 return ERROR_INT(
"pixa not defined", procName, 1);
697 PROCNAME(
"pixaGetPix");
700 return (
PIX *)ERROR_PTR(
"pixa not defined", procName, NULL);
701 if (index < 0 || index >= pixa->
n)
702 return (
PIX *)ERROR_PTR(
"index not valid", procName, NULL);
703 if ((pix = pixa->
pix[index]) == NULL) {
704 L_ERROR(
"no pix at pixa[%d]\n", procName, index);
705 return (
PIX *)ERROR_PTR(
"pix not found!", procName, NULL);
710 else if (accesstype ==
L_CLONE)
713 return (
PIX *)ERROR_PTR(
"invalid accesstype", procName, NULL);
734 PROCNAME(
"pixaGetPixDimensions");
740 return ERROR_INT(
"pixa not defined", procName, 1);
741 if (index < 0 || index >= pixa->
n)
742 return ERROR_INT(
"index not valid", procName, 1);
745 return ERROR_INT(
"pix not found!", procName, 1);
763 PROCNAME(
"pixaGetBoxa");
766 return (
BOXA *)ERROR_PTR(
"pixa not defined", procName, NULL);
768 return (
BOXA *)ERROR_PTR(
"boxa not defined", procName, NULL);
771 return (
BOXA *)ERROR_PTR(
"invalid accesstype", procName, NULL);
786 PROCNAME(
"pixaGetBoxaCount");
789 return ERROR_INT(
"pixa not defined", procName, 0);
822 PROCNAME(
"pixaGetBox");
825 return (
BOX *)ERROR_PTR(
"pixa not defined", procName, NULL);
827 return (
BOX *)ERROR_PTR(
"boxa not defined", procName, NULL);
828 if (index < 0 || index >= pixa->
boxa->
n)
829 return (
BOX *)ERROR_PTR(
"index not valid", procName, NULL);
831 return (
BOX *)ERROR_PTR(
"invalid accesstype", procName, NULL);
863 PROCNAME(
"pixaGetBoxGeometry");
870 return ERROR_INT(
"pixa not defined", procName, 1);
871 if (index < 0 || index >= pixa->
n)
872 return ERROR_INT(
"index not valid", procName, 1);
875 return ERROR_INT(
"box not found!", procName, 1);
900 PROCNAME(
"pixaSetBoxa");
903 return ERROR_INT(
"pixa not defined", procName, 1);
905 return ERROR_INT(
"boxa not defined", procName, 1);
908 return ERROR_INT(
"invalid access type", procName, 1);
937 PROCNAME(
"pixaGetPixArray");
940 return (
PIX **)ERROR_PTR(
"pixa not defined", procName, NULL);
964 l_int32 i, n, d, maxd, same;
966 PROCNAME(
"pixaVerifyDepth");
968 if (pmaxd) *pmaxd = 0;
970 return ERROR_INT(
"psame not defined", procName, 1);
972 return ERROR_INT(
"pixa not defined", procName, 1);
974 return ERROR_INT(
"no pix in pixa", procName, 1);
978 for (i = 1; i < n; i++) {
980 return ERROR_INT(
"pix depth not found", procName, 1);
981 maxd = L_MAX(maxd, d);
986 if (pmaxd) *pmaxd = maxd;
1011 l_int32 i, n, w, h, maxw, maxh, same;
1013 PROCNAME(
"pixaVerifyDimensions");
1015 if (pmaxw) *pmaxw = 0;
1016 if (pmaxh) *pmaxh = 0;
1018 return ERROR_INT(
"psame not defined", procName, 1);
1021 return ERROR_INT(
"pixa not defined", procName, 1);
1023 return ERROR_INT(
"no pix in pixa", procName, 1);
1027 for (i = 1; i < n; i++) {
1029 return ERROR_INT(
"pix dimensions not found", procName, 1);
1030 maxw = L_MAX(maxw, w);
1031 maxh = L_MAX(maxh, h);
1032 if (w != maxw || h != maxh)
1036 if (pmaxw) *pmaxw = maxw;
1037 if (pmaxh) *pmaxh = maxh;
1065 PROCNAME(
"pixaIsFull");
1067 if (pfullpa) *pfullpa = 0;
1068 if (pfullba) *pfullba = 0;
1070 return ERROR_INT(
"pixa not defined", procName, 1);
1075 for (i = 0; i < n; i++) {
1114 PROCNAME(
"pixaCountText");
1117 return ERROR_INT(
"&ntext not defined", procName, 1);
1120 return ERROR_INT(
"pixa not defined", procName, 1);
1123 for (i = 0; i < n; i++) {
1127 if (text && strlen(text) > 0)
1163 PROCNAME(
"pixaSetText");
1166 return ERROR_INT(
"pixa not defined", procName, 1);
1170 return ERROR_INT(
"pixa and sa sizes differ", procName, 1);
1173 for (i = 0; i < n; i++) {
1182 for (i = 0; i < n; i++) {
1222 PROCNAME(
"pixaGetLinePtrs");
1224 if (psize) *psize = 0;
1226 return (
void ***)ERROR_PTR(
"pixa not defined", procName, NULL);
1229 return (
void ***)ERROR_PTR(
"pixa not all same depth", procName, NULL);
1231 if (psize) *psize = n;
1232 if ((lineset = (
void ***)LEPT_CALLOC(n,
sizeof(
void **))) == NULL)
1233 return (
void ***)ERROR_PTR(
"lineset not made", procName, NULL);
1234 for (i = 0; i < n; i++) {
1237 lineset[i] = lineptrs;
1266 l_int32 i, n, w, h, d, spp, count, hastext;
1270 PROCNAME(
"pixaWriteStreamInfo");
1273 return ERROR_INT(
"stream not defined", procName, 1);
1275 return ERROR_INT(
"pixa not defined", procName, 1);
1278 for (i = 0; i < n; i++) {
1280 fprintf(fp,
"%d: no pix at this index\n", i);
1284 spp = pixGetSpp(pix);
1286 hastext = (text && strlen(text) > 0);
1287 if ((cmap = pixGetColormap(pix)) != NULL)
1289 fprintf(fp,
"Pix %d: w = %d, h = %d, d = %d, spp = %d",
1291 if (cmap) fprintf(fp,
", cmap(%d colors)", count);
1292 if (hastext) fprintf(fp,
", text = %s", text);
1327 PROCNAME(
"pixaReplacePix");
1330 return ERROR_INT(
"pixa not defined", procName, 1);
1331 if (index < 0 || index >= pixa->
n)
1332 return ERROR_INT(
"index not valid", procName, 1);
1334 return ERROR_INT(
"pix not defined", procName, 1);
1337 pixa->
pix[index] = pix;
1341 if (index > boxa->
n)
1342 return ERROR_INT(
"boxa index not valid", procName, 1);
1377 PROCNAME(
"pixaInsertPix");
1380 return ERROR_INT(
"pixa not defined", procName, 1);
1382 if (index < 0 || index > n) {
1383 L_ERROR(
"index %d not in [0,...,%d]\n", procName, index, n);
1387 return ERROR_INT(
"pixs not defined", procName, 1);
1391 return ERROR_INT(
"extension failed", procName, 1);
1393 return ERROR_INT(
"extension failed", procName, 1);
1396 for (i = n; i > index; i--)
1397 pixa->
pix[i] = pixa->
pix[i - 1];
1398 pixa->
pix[index] = pixs;
1430 PROCNAME(
"pixaRemovePix");
1433 return ERROR_INT(
"pixa not defined", procName, 1);
1435 if (index < 0 || index >= n) {
1436 L_ERROR(
"index %d not in [0,...,%d]\n", procName, index, n - 1);
1443 for (i = index + 1; i < n; i++)
1444 array[i - 1] = array[i];
1445 array[n - 1] = NULL;
1486 PROCNAME(
"pixaRemovePixAndSave");
1488 if (ppix) *ppix = NULL;
1489 if (pbox) *pbox = NULL;
1491 return ERROR_INT(
"pixa not defined", procName, 1);
1493 if (index < 0 || index >= n) {
1494 L_ERROR(
"index %d not in [0,...,%d]\n", procName, index, n - 1);
1503 for (i = index + 1; i < n; i++)
1504 array[i - 1] = array[i];
1505 array[n - 1] = NULL;
1534 l_int32 i, n, index;
1537 PROCNAME(
"pixaRemoveSelected");
1540 return ERROR_INT(
"pixa not defined", procName, 1);
1542 return ERROR_INT(
"naindex not defined", procName, 1);
1544 return ERROR_INT(
"naindex is empty", procName, 1);
1548 for (i = 0; i < n; i++) {
1600 PROCNAME(
"pixaInitFull");
1603 return ERROR_INT(
"pixa not defined", procName, 1);
1607 for (i = 0; i < n; i++) {
1639 PROCNAME(
"pixaClear");
1642 return ERROR_INT(
"pixa not defined", procName, 1);
1645 for (i = 0; i < n; i++)
1679 BOXA *boxas, *boxad;
1682 PROCNAME(
"pixaJoin");
1685 return ERROR_INT(
"pixad not defined", procName, 1);
1691 if (iend < 0 || iend >= n)
1694 return ERROR_INT(
"istart > iend; nothing to add", procName, 1);
1696 for (i = istart; i <= iend; i++) {
1704 iend = L_MIN(iend, nb - 1);
1705 boxaJoin(boxad, boxas, istart, iend);
1733 l_int32 i, n1, n2, n, nb1, nb2;
1738 PROCNAME(
"pixaInterleave");
1741 return (
PIXA *)ERROR_PTR(
"pixa1 not defined", procName, NULL);
1743 return (
PIXA *)ERROR_PTR(
"pixa2 not defined", procName, NULL);
1745 return (
PIXA *)ERROR_PTR(
"invalid copyflag", procName, NULL);
1750 return (
PIXA *)ERROR_PTR(
"at least one input pixa is empty",
1753 L_WARNING(
"counts differ: %d != %d\n", procName, n1, n2);
1758 for (i = 0; i < n; i++) {
1802 PROCNAME(
"pixaaJoin");
1805 return ERROR_INT(
"pixaad not defined", procName, 1);
1812 if (iend < 0 || iend >= n)
1815 return ERROR_INT(
"istart > iend; nothing to add", procName, 1);
1817 for (i = istart; i <= iend; i++) {
1856 PROCNAME(
"pixaaCreate");
1858 if (n <= 0 || n > MaxInitPtrArraySize)
1861 paa = (
PIXAA *)LEPT_CALLOC(1,
sizeof(
PIXAA));
1864 if ((paa->
pixa = (
PIXA **)LEPT_CALLOC(n,
sizeof(
PIXA *))) == NULL) {
1866 return (
PIXAA *)ERROR_PTR(
"pixa ptrs not made", procName, NULL);
1900 l_int32 count, i, j, npixa;
1905 PROCNAME(
"pixaaCreateFromPixa");
1908 return (
PIXAA *)ERROR_PTR(
"pixa not defined", procName, NULL);
1911 return (
PIXAA *)ERROR_PTR(
"no pix in pixa", procName, NULL);
1913 return (
PIXAA *)ERROR_PTR(
"n must be > 0", procName, NULL);
1915 return (
PIXAA *)ERROR_PTR(
"invalid type", procName, NULL);
1917 return (
PIXAA *)ERROR_PTR(
"invalid copyflag", procName, NULL);
1920 npixa = (count + n - 1) / n;
1922 npixa = L_MIN(n, count);
1925 for (i = 0; i < count; i++) {
1936 for (i = 0; i < npixa; i++) {
1938 for (j = i; j < count; j += n) {
1962 PROCNAME(
"pixaaDestroy");
1965 L_WARNING(
"ptr address is NULL!\n", procName);
1969 if ((paa = *ppaa) == NULL)
1972 for (i = 0; i < paa->
n; i++)
1974 LEPT_FREE(paa->
pixa);
2005 PROCNAME(
"pixaaAddPixa");
2008 return ERROR_INT(
"paa not defined", procName, 1);
2010 return ERROR_INT(
"pixa not defined", procName, 1);
2013 return ERROR_INT(
"invalid copyflag", procName, 1);
2018 if ((pixac =
pixaCopy(pixa, copyflag)) == NULL)
2019 return ERROR_INT(
"pixac not made", procName, 1);
2027 return ERROR_INT(
"extension failed", procName, 1);
2030 paa->
pixa[n] = pixac;
2050 size_t oldsize, newsize;
2052 PROCNAME(
"pixaaExtendArray");
2055 return ERROR_INT(
"paa not defined", procName, 1);
2056 if (paa->
nalloc > MaxPixaaPtrArraySize)
2057 return ERROR_INT(
"paa has too many ptrs", procName, 1);
2059 newsize = 2 * oldsize;
2060 if (newsize > 8 * MaxPixaaPtrArraySize)
2061 return ERROR_INT(
"newsize > 8 MB; too large", procName, 1);
2064 oldsize, newsize)) == NULL)
2065 return ERROR_INT(
"new ptr array not returned", procName, 1);
2091 PROCNAME(
"pixaaAddPix");
2094 return ERROR_INT(
"paa not defined", procName, 1);
2096 return ERROR_INT(
"pix not defined", procName, 1);
2099 return ERROR_INT(
"pixa not found", procName, 1);
2126 PROCNAME(
"pixaaAddBox");
2129 return ERROR_INT(
"paa not defined", procName, 1);
2131 return ERROR_INT(
"box not defined", procName, 1);
2133 return ERROR_INT(
"invalid copyflag", procName, 1);
2164 PROCNAME(
"pixaaGetCount");
2166 if (pna) *pna = NULL;
2168 return ERROR_INT(
"paa not defined", procName, 0);
2173 return ERROR_INT(
"na not made", procName, 0);
2175 for (i = 0; i < n; i++) {
2212 PROCNAME(
"pixaaGetPixa");
2215 return (
PIXA *)ERROR_PTR(
"paa not defined", procName, NULL);
2216 if (index < 0 || index >= paa->
n)
2217 return (
PIXA *)ERROR_PTR(
"index not valid", procName, NULL);
2220 return (
PIXA *)ERROR_PTR(
"invalid accesstype", procName, NULL);
2222 if ((pixa = paa->
pixa[index]) == NULL) {
2223 L_ERROR(
"missing pixa[%d]\n", procName, index);
2224 return (
PIXA *)ERROR_PTR(
"pixa not found at index", procName, NULL);
2247 PROCNAME(
"pixaaGetBoxa");
2250 return (
BOXA *)ERROR_PTR(
"paa not defined", procName, NULL);
2252 return (
BOXA *)ERROR_PTR(
"invalid access type", procName, NULL);
2276 PROCNAME(
"pixaaGetPix");
2279 return (
PIX *)ERROR_PTR(
"pixa not retrieved", procName, NULL);
2280 if ((pix =
pixaGetPix(pixa, ipix, accessflag)) == NULL)
2281 L_ERROR(
"pix not retrieved\n", procName);
2305 l_int32 i, n, d, maxd, same, samed;
2308 PROCNAME(
"pixaaVerifyDepth");
2310 if (pmaxd) *pmaxd = 0;
2312 return ERROR_INT(
"psame not defined", procName, 1);
2315 return ERROR_INT(
"paa not defined", procName, 1);
2317 return ERROR_INT(
"no pixa in paa", procName, 1);
2322 for (i = 1; i < n; i++) {
2326 maxd = L_MAX(maxd, d);
2327 if (!samed || maxd != d)
2331 if (pmaxd) *pmaxd = maxd;
2356 l_int32 i, n, w, h, maxw, maxh, same, same2;
2359 PROCNAME(
"pixaaVerifyDimensions");
2361 if (pmaxw) *pmaxw = 0;
2362 if (pmaxh) *pmaxh = 0;
2364 return ERROR_INT(
"psame not defined", procName, 1);
2367 return ERROR_INT(
"paa not defined", procName, 1);
2369 return ERROR_INT(
"no pixa in paa", procName, 1);
2376 for (i = 1; i < n; i++) {
2380 maxw = L_MAX(maxw, w);
2381 maxh = L_MAX(maxh, h);
2382 if (!same2 || maxw != w || maxh != h)
2386 if (pmaxw) *pmaxw = maxw;
2387 if (pmaxh) *pmaxh = maxh;
2411 PROCNAME(
"pixaaIsFull");
2414 return ERROR_INT(
"&full not defined", procName, 0);
2417 return ERROR_INT(
"paa not defined", procName, 0);
2421 for (i = 0; i < n; i++) {
2463 PROCNAME(
"pixaaInitFull");
2466 return ERROR_INT(
"paa not defined", procName, 1);
2468 return ERROR_INT(
"pixa not defined", procName, 1);
2472 for (i = 0; i < n; i++) {
2504 PROCNAME(
"pixaaReplacePixa");
2507 return ERROR_INT(
"paa not defined", procName, 1);
2508 if (index < 0 || index >= paa->
n)
2509 return ERROR_INT(
"index not valid", procName, 1);
2511 return ERROR_INT(
"pixa not defined", procName, 1);
2514 paa->
pixa[index] = pixa;
2536 PROCNAME(
"pixaClear");
2539 return ERROR_INT(
"paa not defined", procName, 1);
2542 for (i = 0; i < n; i++)
2568 PROCNAME(
"pixaaTruncate");
2571 return ERROR_INT(
"paa not defined", procName, 1);
2574 for (i = n - 1; i >= 0; i--) {
2615 PROCNAME(
"pixaRead");
2618 return (
PIXA *)ERROR_PTR(
"no libpng: can't read data", procName, NULL);
2622 return (
PIXA *)ERROR_PTR(
"filename not defined", procName, NULL);
2625 return (
PIXA *)ERROR_PTR(
"stream not opened", procName, NULL);
2629 return (
PIXA *)ERROR_PTR(
"pixa not read", procName, NULL);
2650 l_int32 n, i, xres, yres, version;
2656 PROCNAME(
"pixaReadStream");
2659 return (
PIXA *)ERROR_PTR(
"no libpng: can't read data", procName, NULL);
2663 return (
PIXA *)ERROR_PTR(
"stream not defined", procName, NULL);
2665 if (fscanf(fp,
"\nPixa Version %d\n", &version) != 1)
2666 return (
PIXA *)ERROR_PTR(
"not a pixa file", procName, NULL);
2668 return (
PIXA *)ERROR_PTR(
"invalid pixa version", procName, NULL);
2669 if (fscanf(fp,
"Number of pix = %d\n", &n) != 1)
2670 return (
PIXA *)ERROR_PTR(
"not a pixa file", procName, NULL);
2672 return (
PIXA *)ERROR_PTR(
"num pix ptrs < 0", procName, NULL);
2673 if (n > MaxPixaPtrArraySize)
2674 return (
PIXA *)ERROR_PTR(
"too many pix ptrs", procName, NULL);
2675 if (n == 0) L_INFO(
"the pixa is empty\n", procName);
2678 return (
PIXA *)ERROR_PTR(
"boxa not made", procName, NULL);
2681 return (
PIXA *)ERROR_PTR(
"pixa not made", procName, NULL);
2686 for (i = 0; i < n; i++) {
2687 if ((fscanf(fp,
" pix[%d]: xres = %d, yres = %d\n",
2688 &ignore, &xres, &yres)) != 3) {
2690 return (
PIXA *)ERROR_PTR(
"res reading error", procName, NULL);
2694 return (
PIXA *)ERROR_PTR(
"pix not read", procName, NULL);
2696 pixSetXRes(pix, xres);
2697 pixSetYRes(pix, yres);
2718 PROCNAME(
"pixaReadMem");
2721 return (
PIXA *)ERROR_PTR(
"data not defined", procName, NULL);
2723 return (
PIXA *)ERROR_PTR(
"stream not opened", procName, NULL);
2727 if (!pixa) L_ERROR(
"pixa not read\n", procName);
2752 PROCNAME(
"pixaWriteDebug");
2757 L_INFO(
"write to named temp file %s is disabled\n", procName, fname);
2783 PROCNAME(
"pixaWrite");
2786 return ERROR_INT(
"no libpng: can't write data", procName, 1);
2790 return ERROR_INT(
"filename not defined", procName, 1);
2792 return ERROR_INT(
"pixa not defined", procName, 1);
2795 return ERROR_INT(
"stream not opened", procName, 1);
2799 return ERROR_INT(
"pixa not written to stream", procName, 1);
2824 PROCNAME(
"pixaWriteStream");
2827 return ERROR_INT(
"no libpng: can't write data", procName, 1);
2831 return ERROR_INT(
"stream not defined", procName, 1);
2833 return ERROR_INT(
"pixa not defined", procName, 1);
2837 fprintf(fp,
"Number of pix = %d\n", n);
2839 for (i = 0; i < n; i++) {
2841 return ERROR_INT(
"pix not found", procName, 1);
2842 fprintf(fp,
" pix[%d]: xres = %d, yres = %d\n",
2872 PROCNAME(
"pixaWriteMem");
2874 if (pdata) *pdata = NULL;
2875 if (psize) *psize = 0;
2877 return ERROR_INT(
"&data not defined", procName, 1);
2879 return ERROR_INT(
"&size not defined", procName, 1);
2881 return ERROR_INT(
"pixa not defined", procName, 1);
2884 if ((fp = open_memstream((
char **)pdata, psize)) == NULL)
2885 return ERROR_INT(
"stream not opened", procName, 1);
2889 *psize = *psize - 1;
2891 L_INFO(
"work-around: writing to a temp file\n", procName);
2894 return ERROR_INT(
"tmpfile stream not opened", procName, 1);
2896 if ((fp = tmpfile()) == NULL)
2897 return ERROR_INT(
"tmpfile stream not opened", procName, 1);
2928 PROCNAME(
"pixaReadBoth");
2931 return (
PIXA *)ERROR_PTR(
"filename not defined", procName, NULL);
2935 return (
PIXA *)ERROR_PTR(
"struct name not found", procName, NULL);
2936 snprintf(buf,
sizeof(buf),
"%s", sname);
2939 if (strcmp(buf,
"Pixacomp") == 0) {
2941 return (
PIXA *)ERROR_PTR(
"pac not made", procName, NULL);
2944 }
else if (strcmp(buf,
"Pixa") == 0) {
2945 if ((pixa =
pixaRead(filename)) == NULL)
2946 return (
PIXA *)ERROR_PTR(
"pixa not made", procName, NULL);
2948 return (
PIXA *)ERROR_PTR(
"invalid file type", procName, NULL);
2989 PROCNAME(
"pixaaReadFromFiles");
2992 return (
PIXAA *)ERROR_PTR(
"dirname not defined", procName, NULL);
2997 return (
PIXAA *)ERROR_PTR(
"no pixa files found", procName, NULL);
3001 for (i = 0; i < n; i++) {
3003 if ((pixa =
pixaRead(fname)) == NULL) {
3004 L_ERROR(
"pixa not read for %d-th file", procName, i);
3033 PROCNAME(
"pixaaRead");
3036 return (
PIXAA *)ERROR_PTR(
"no libpng: can't read data", procName, NULL);
3040 return (
PIXAA *)ERROR_PTR(
"filename not defined", procName, NULL);
3043 return (
PIXAA *)ERROR_PTR(
"stream not opened", procName, NULL);
3047 return (
PIXAA *)ERROR_PTR(
"paa not read", procName, NULL);
3068 l_int32 n, i, version;
3074 PROCNAME(
"pixaaReadStream");
3077 return (
PIXAA *)ERROR_PTR(
"no libpng: can't read data", procName, NULL);
3081 return (
PIXAA *)ERROR_PTR(
"stream not defined", procName, NULL);
3083 if (fscanf(fp,
"\nPixaa Version %d\n", &version) != 1)
3084 return (
PIXAA *)ERROR_PTR(
"not a pixaa file", procName, NULL);
3086 return (
PIXAA *)ERROR_PTR(
"invalid pixaa version", procName, NULL);
3087 if (fscanf(fp,
"Number of pixa = %d\n", &n) != 1)
3088 return (
PIXAA *)ERROR_PTR(
"not a pixaa file", procName, NULL);
3090 return (
PIXAA *)ERROR_PTR(
"num pixa ptrs < 0", procName, NULL);
3091 if (n > MaxPixaaPtrArraySize)
3092 return (
PIXAA *)ERROR_PTR(
"too many pixa ptrs", procName, NULL);
3093 if (n == 0) L_INFO(
"the pixaa is empty\n", procName);
3096 return (
PIXAA *)ERROR_PTR(
"paa not made", procName, NULL);
3099 return (
PIXAA *)ERROR_PTR(
"boxa not made", procName, NULL);
3104 for (i = 0; i < n; i++) {
3105 if ((fscanf(fp,
"\n\n --------------- pixa[%d] ---------------\n",
3108 return (
PIXAA *)ERROR_PTR(
"text reading", procName, NULL);
3112 return (
PIXAA *)ERROR_PTR(
"pixa not read", procName, NULL);
3135 PROCNAME(
"paaReadMem");
3138 return (
PIXAA *)ERROR_PTR(
"data not defined", procName, NULL);
3140 return (
PIXAA *)ERROR_PTR(
"stream not opened", procName, NULL);
3144 if (!paa) L_ERROR(
"paa not read\n", procName);
3169 PROCNAME(
"pixaaWrite");
3172 return ERROR_INT(
"no libpng: can't read data", procName, 1);
3176 return ERROR_INT(
"filename not defined", procName, 1);
3178 return ERROR_INT(
"paa not defined", procName, 1);
3181 return ERROR_INT(
"stream not opened", procName, 1);
3185 return ERROR_INT(
"paa not written to stream", procName, 1);
3210 PROCNAME(
"pixaaWriteStream");
3213 return ERROR_INT(
"no libpng: can't read data", procName, 1);
3217 return ERROR_INT(
"stream not defined", procName, 1);
3219 return ERROR_INT(
"paa not defined", procName, 1);
3223 fprintf(fp,
"Number of pixa = %d\n", n);
3225 for (i = 0; i < n; i++) {
3227 return ERROR_INT(
"pixa not found", procName, 1);
3228 fprintf(fp,
"\n\n --------------- pixa[%d] ---------------\n", i);
3257 PROCNAME(
"pixaaWriteMem");
3259 if (pdata) *pdata = NULL;
3260 if (psize) *psize = 0;
3262 return ERROR_INT(
"&data not defined", procName, 1);
3264 return ERROR_INT(
"&size not defined", procName, 1);
3266 return ERROR_INT(
"paa not defined", procName, 1);
3269 if ((fp = open_memstream((
char **)pdata, psize)) == NULL)
3270 return ERROR_INT(
"stream not opened", procName, 1);
3274 *psize = *psize - 1;
3276 L_INFO(
"work-around: writing to a temp file\n", procName);
3279 return ERROR_INT(
"tmpfile stream not opened", procName, 1);
3281 if ((fp = tmpfile()) == NULL)
3282 return ERROR_INT(
"tmpfile stream not opened", procName, 1);
BOXA * boxaReadStream(FILE *fp)
boxaReadStream()
PIXA * pixaInterleave(PIXA *pixa1, PIXA *pixa2, l_int32 copyflag)
pixaInterleave()
void pixaaDestroy(PIXAA **ppaa)
pixaaDestroy()
PIXAA * pixaaCreate(l_int32 n)
pixaaCreate()
l_ok pixaInitFull(PIXA *pixa, PIX *pix, BOX *box)
pixaInitFull()
l_ok boxaJoin(BOXA *boxad, BOXA *boxas, l_int32 istart, l_int32 iend)
boxaJoin()
l_int32 pixaaIsFull(PIXAA *paa, l_int32 *pfull)
pixaaIsFull()
static l_int32 pixaaExtendArray(PIXAA *paa)
pixaaExtendArray()
PIX * pixReadStreamPng(FILE *fp)
pixReadStreamPng()
l_ok pixaSetText(PIXA *pixa, const char *text, SARRAY *sa)
pixaSetText()
PIXAA * pixaaReadMem(const l_uint8 *data, size_t size)
pixaaReadMem()
l_ok pixaWriteDebug(const char *fname, PIXA *pixa)
pixaWriteDebug()
l_ok pixaVerifyDepth(PIXA *pixa, l_int32 *psame, l_int32 *pmaxd)
pixaVerifyDepth()
l_ok pixaaAddBox(PIXAA *paa, BOX *box, l_int32 copyflag)
pixaaAddBox()
l_ok numaAddNumber(NUMA *na, l_float32 val)
numaAddNumber()
PIXA * pixaReadMem(const l_uint8 *data, size_t size)
pixaReadMem()
PIXA * pixaCreate(l_int32 n)
pixaCreate()
l_ok pixaWriteStreamInfo(FILE *fp, PIXA *pixa)
pixaWriteStreamInfo()
l_ok pixaRemovePixAndSave(PIXA *pixa, l_int32 index, PIX **ppix, BOX **pbox)
pixaRemovePixAndSave()
PIXAC * pixacompRead(const char *filename)
pixacompRead()
l_ok boxaExtendArray(BOXA *boxa)
boxaExtendArray()
l_ok pixaCountText(PIXA *pixa, l_int32 *pntext)
pixaCountText()
l_ok pixaSetBoxa(PIXA *pixa, BOXA *boxa, l_int32 accesstype)
pixaSetBoxa()
l_ok pixaWrite(const char *filename, PIXA *pixa)
pixaWrite()
l_ok pixaJoin(PIXA *pixad, PIXA *pixas, l_int32 istart, l_int32 iend)
pixaJoin()
PIXAA * pixaaReadStream(FILE *fp)
pixaaReadStream()
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()
PIXA * pixaCreateFromPixacomp(PIXAC *pixac, l_int32 accesstype)
pixaCreateFromPixacomp()
l_ok boxaWriteStream(FILE *fp, BOXA *boxa)
boxaWriteStream()
PIX * pixCopy(PIX *pixd, const PIX *pixs)
pixCopy()
void ** pixGetLinePtrs(PIX *pix, l_int32 *psize)
pixGetLinePtrs()
PIXA * pixaRead(const char *filename)
pixaRead()
l_int32 pixaaGetCount(PIXAA *paa, NUMA **pna)
pixaaGetCount()
NUMA * numaSort(NUMA *naout, NUMA *nain, l_int32 sortorder)
numaSort()
PIXAA * pixaaReadFromFiles(const char *dirname, const char *substr, l_int32 first, l_int32 nfiles)
pixaaReadFromFiles()
l_ok boxaReplaceBox(BOXA *boxa, l_int32 index, BOX *box)
boxaReplaceBox()
PIX * pixCreate(l_int32 width, l_int32 height, l_int32 depth)
pixCreate()
PIXA * pixaSplitPix(PIX *pixs, l_int32 nx, l_int32 ny, l_int32 borderwidth, l_uint32 bordercolor)
pixaSplitPix()
l_ok pixSetAll(PIX *pix)
pixSetAll()
FILE * fopenReadFromMemory(const l_uint8 *data, size_t size)
fopenReadFromMemory()
PIXA * pixaReadBoth(const char *filename)
pixaReadBoth()
BOXA * boxaCopy(BOXA *boxa, l_int32 copyflag)
boxaCopy()
NUMA * numaCreate(l_int32 n)
numaCreate()
void boxaDestroy(BOXA **pboxa)
boxaDestroy()
BOX * pixaGetBox(PIXA *pixa, l_int32 index, l_int32 accesstype)
pixaGetBox()
PIXA * pixaCreateFromBoxa(PIX *pixs, BOXA *boxa, l_int32 start, l_int32 num, l_int32 *pcropwarn)
pixaCreateFromBoxa()
static const size_t InitialPtrArraySize
l_ok pixWriteStreamPng(FILE *fp, PIX *pix, l_float32 gamma)
pixWriteStreamPng()
l_ok pixaInsertPix(PIXA *pixa, l_int32 index, PIX *pixs, BOX *box)
pixaInsertPix()
PIX * pixClipRectangle(PIX *pixs, BOX *box, BOX **pboxc)
pixClipRectangle()
l_int32 pixaGetBoxaCount(PIXA *pixa)
pixaGetBoxaCount()
PIX ** pixaGetPixArray(PIXA *pixa)
pixaGetPixArray()
l_ok pixaaJoin(PIXAA *paad, PIXAA *paas, l_int32 istart, l_int32 iend)
pixaaJoin()
l_ok pixaaWrite(const char *filename, PIXAA *paa)
pixaaWrite()
l_ok pixaChangeRefcount(PIXA *pixa, l_int32 delta)
pixaChangeRefcount()
PIX * pixaaGetPix(PIXAA *paa, l_int32 index, l_int32 ipix, l_int32 accessflag)
pixaaGetPix()
l_ok pixSetText(PIX *pix, const char *textstring)
pixSetText()
BOX * boxClone(BOX *box)
boxClone()
l_ok pixSetAllArbitrary(PIX *pix, l_uint32 val)
pixSetAllArbitrary()
l_int32 l_getStructStrFromFile(const char *filename, l_int32 field, char **pstr)
l_getStructStrFromFile()
l_ok pixClipToForeground(PIX *pixs, PIX **ppixd, BOX **pbox)
pixClipToForeground()
PIXA * pixaCopy(PIXA *pixa, l_int32 copyflag)
pixaCopy()
l_ok pixaWriteMem(l_uint8 **pdata, size_t *psize, PIXA *pixa)
pixaWriteMem()
l_ok pixaExtendArrayToSize(PIXA *pixa, size_t size)
pixaExtendArrayToSize()
l_ok numaGetIValue(NUMA *na, l_int32 index, l_int32 *pival)
numaGetIValue()
l_ok pixaAddPix(PIXA *pixa, PIX *pix, l_int32 copyflag)
pixaAddPix()
l_ok pixaaVerifyDimensions(PIXAA *paa, l_int32 *psame, l_int32 *pmaxw, l_int32 *pmaxh)
pixaaVerifyDimensions()
l_ok pixaClear(PIXA *pixa)
pixaClear()
l_ok boxaRemoveBoxAndSave(BOXA *boxa, l_int32 index, BOX **pbox)
boxaRemoveBoxAndSave()
l_int32 numaGetCount(NUMA *na)
numaGetCount()
l_ok pixaaReplacePixa(PIXAA *paa, l_int32 index, PIXA *pixa)
pixaaReplacePixa()
l_ok pixClearAll(PIX *pix)
pixClearAll()
PIXA * pixaCreateFromPix(PIX *pixs, l_int32 n, l_int32 cellw, l_int32 cellh)
pixaCreateFromPix()
l_ok boxaAddBox(BOXA *boxa, BOX *box, l_int32 copyflag)
boxaAddBox()
l_ok pixaaClear(PIXAA *paa)
pixaaClear()
#define PIXAA_VERSION_NUMBER
l_ok boxaExtendArrayToSize(BOXA *boxa, size_t size)
boxaExtendArrayToSize()
l_ok pixaaTruncate(PIXAA *paa)
pixaaTruncate()
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()
void * reallocNew(void **pindata, size_t oldsize, size_t newsize)
reallocNew()
PIXA * pixaReadStream(FILE *fp)
pixaReadStream()
PIX * pixClone(PIX *pixs)
pixClone()
void pixacompDestroy(PIXAC **ppixac)
pixacompDestroy()
PIXAA * pixaaRead(const char *filename)
pixaaRead()
void pixDestroy(PIX **ppix)
pixDestroy()
l_ok pixaRemoveSelected(PIXA *pixa, NUMA *naindex)
pixaRemoveSelected()
BOX * boxaGetBox(BOXA *boxa, l_int32 index, l_int32 accessflag)
boxaGetBox()
static l_int32 pixaExtendArray(PIXA *pixa)
pixaExtendArray()
void *** pixaGetLinePtrs(PIXA *pixa, l_int32 *psize)
pixaGetLinePtrs()
SARRAY * getSortedPathnamesInDirectory(const char *dirname, const char *substr, l_int32 first, l_int32 nfiles)
getSortedPathnamesInDirectory()
l_ok boxaGetExtent(BOXA *boxa, l_int32 *pw, l_int32 *ph, BOX **pbox)
boxaGetExtent()
void numaDestroy(NUMA **pna)
numaDestroy()
l_ok pixGetDimensions(const PIX *pix, l_int32 *pw, l_int32 *ph, l_int32 *pd)
pixGetDimensions()
FILE * fopenWriteStream(const char *filename, const char *modestring)
fopenWriteStream()
FILE * fopenWriteWinTempfile(void)
fopenWriteWinTempfile()
#define PIXA_VERSION_NUMBER
FILE * fopenReadStream(const char *filename)
fopenReadStream()
PIXAA * pixaaCreateFromPixa(PIXA *pixa, l_int32 n, l_int32 type, l_int32 copyflag)
pixaaCreateFromPixa()
l_ok boxaInitFull(BOXA *boxa, BOX *box)
boxaInitFull()
l_ok pixaVerifyDimensions(PIXA *pixa, l_int32 *psame, l_int32 *pmaxw, l_int32 *pmaxh)
pixaVerifyDimensions()
l_uint8 * l_binaryReadStream(FILE *fp, size_t *pnbytes)
l_binaryReadStream()
l_int32 sarrayGetCount(SARRAY *sa)
sarrayGetCount()
l_ok boxaIsFull(BOXA *boxa, l_int32 *pfull)
boxaIsFull()
char * pixGetText(PIX *pix)
pixGetText()
l_ok pixaIsFull(PIXA *pixa, l_int32 *pfullpa, l_int32 *pfullba)
pixaIsFull()
l_ok pixaaWriteMem(l_uint8 **pdata, size_t *psize, PIXAA *paa)
pixaaWriteMem()
l_ok boxaRemoveBox(BOXA *boxa, l_int32 index)
boxaRemoveBox()
PIX * pixaGetPix(PIXA *pixa, l_int32 index, l_int32 accesstype)
pixaGetPix()
l_ok pixaaInitFull(PIXAA *paa, PIXA *pixa)
pixaaInitFull()
l_ok pixaaAddPixa(PIXAA *paa, PIXA *pixa, l_int32 copyflag)
pixaaAddPixa()
l_ok pixaRemovePix(PIXA *pixa, l_int32 index)
pixaRemovePix()
BOX * boxCopy(BOX *box)
boxCopy()
l_ok pixaGetPixDimensions(PIXA *pixa, l_int32 index, l_int32 *pw, l_int32 *ph, l_int32 *pd)
pixaGetPixDimensions()
BOXA * boxaCreate(l_int32 n)
boxaCreate()
l_ok pixCopyColormap(PIX *pixd, const PIX *pixs)
pixCopyColormap()
void boxDestroy(BOX **pbox)
boxDestroy()
l_ok pixaaVerifyDepth(PIXAA *paa, l_int32 *psame, l_int32 *pmaxd)
pixaaVerifyDepth()
l_int32 pixcmapGetCount(const PIXCMAP *cmap)
pixcmapGetCount()
l_int32 boxaGetCount(BOXA *boxa)
boxaGetCount()
BOXA * pixaaGetBoxa(PIXAA *paa, l_int32 accesstype)
pixaaGetBoxa()
l_ok pixaaWriteStream(FILE *fp, PIXAA *paa)
pixaaWriteStream()
l_ok boxaClear(BOXA *boxa)
boxaClear()
l_ok pixaWriteStream(FILE *fp, PIXA *pixa)
pixaWriteStream()
l_ok pixaAddBox(PIXA *pixa, BOX *box, l_int32 copyflag)
pixaAddBox()
l_ok boxGetGeometry(BOX *box, l_int32 *px, l_int32 *py, l_int32 *pw, l_int32 *ph)
boxGetGeometry()
void pixaDestroy(PIXA **ppixa)
pixaDestroy()
l_int32 pixaGetCount(PIXA *pixa)
pixaGetCount()
l_ok pixaaAddPix(PIXAA *paa, l_int32 index, PIX *pix, BOX *box, l_int32 copyflag)
pixaaAddPix()
l_ok pixaReplacePix(PIXA *pixa, l_int32 index, PIX *pix, BOX *box)
pixaReplacePix()
l_ok boxaInsertBox(BOXA *boxa, l_int32 index, BOX *box)
boxaInsertBox()
void sarrayDestroy(SARRAY **psa)
sarrayDestroy()
BOXA * pixaGetBoxa(PIXA *pixa, l_int32 accesstype)
pixaGetBoxa()