Leptonica  1.83.1
Image processing and image analysis suite
pixabasic.c
Go to the documentation of this file.
1 /*====================================================================*
2  - Copyright (C) 2001 Leptonica. All rights reserved.
3  -
4  - Redistribution and use in source and binary forms, with or without
5  - modification, are permitted provided that the following conditions
6  - are met:
7  - 1. Redistributions of source code must retain the above copyright
8  - notice, this list of conditions and the following disclaimer.
9  - 2. Redistributions in binary form must reproduce the above
10  - copyright notice, this list of conditions and the following
11  - disclaimer in the documentation and/or other materials
12  - provided with the distribution.
13  -
14  - THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
15  - ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
16  - LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
17  - A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL ANY
18  - CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
19  - EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
20  - PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
21  - PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
22  - OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
23  - NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
24  - SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
25  *====================================================================*/
26 
134 #ifdef HAVE_CONFIG_H
135 #include <config_auto.h>
136 #endif /* HAVE_CONFIG_H */
137 
138 #include <string.h>
139 #include "allheaders.h"
140 #include "pix_internal.h"
141 
142  /* Bounds on array sizes */
143 static const size_t MaxInitPtrArraySize = 100000;
144 static const size_t MaxPixaPtrArraySize = 5000000;
145 static const size_t MaxPixaaPtrArraySize = 1000000;
146 static const size_t InitialPtrArraySize = 20;
148  /* Static functions */
149 static l_int32 pixaExtendArray(PIXA *pixa);
150 static l_int32 pixaaExtendArray(PIXAA *paa);
151 
152 /*---------------------------------------------------------------------*
153  * Pixa creation, destruction, copy *
154  *---------------------------------------------------------------------*/
166 PIXA *
167 pixaCreate(l_int32 n)
168 {
169 PIXA *pixa;
170 
171  if (n <= 0 || n > MaxInitPtrArraySize)
173 
174  pixa = (PIXA *)LEPT_CALLOC(1, sizeof(PIXA));
175  pixa->n = 0;
176  pixa->nalloc = n;
177  pixa->refcount = 1;
178  pixa->pix = (PIX **)LEPT_CALLOC(n, sizeof(PIX *));
179  pixa->boxa = boxaCreate(n);
180  if (!pixa->pix || !pixa->boxa) {
181  pixaDestroy(&pixa);
182  return (PIXA *)ERROR_PTR("pix or boxa not made", __func__, NULL);
183  }
184  return pixa;
185 }
186 
187 
203 PIXA *
205  l_int32 n,
206  l_int32 cellw,
207  l_int32 cellh)
208 {
209 l_int32 w, h, d, nw, nh, i, j, index;
210 PIX *pix1, *pix2;
211 PIXA *pixa;
212 
213  if (!pixs)
214  return (PIXA *)ERROR_PTR("pixs not defined", __func__, NULL);
215  if (n <= 0)
216  return (PIXA *)ERROR_PTR("n must be > 0", __func__, NULL);
217 
218  if ((pixa = pixaCreate(n)) == NULL)
219  return (PIXA *)ERROR_PTR("pixa not made", __func__, NULL);
220  pixGetDimensions(pixs, &w, &h, &d);
221  if ((pix1 = pixCreate(cellw, cellh, d)) == NULL) {
222  pixaDestroy(&pixa);
223  return (PIXA *)ERROR_PTR("pix1 not made", __func__, NULL);
224  }
225 
226  nw = (w + cellw - 1) / cellw;
227  nh = (h + cellh - 1) / cellh;
228  for (i = 0, index = 0; i < nh; i++) {
229  for (j = 0; j < nw && index < n; j++, index++) {
230  pixRasterop(pix1, 0, 0, cellw, cellh, PIX_SRC, pixs,
231  j * cellw, i * cellh);
232  if (d == 1 && !pixClipToForeground(pix1, &pix2, NULL))
233  pixaAddPix(pixa, pix2, L_INSERT);
234  else
235  pixaAddPix(pixa, pix1, L_COPY);
236  }
237  }
238 
239  pixDestroy(&pix1);
240  return pixa;
241 }
242 
243 
267 PIXA *
269  BOXA *boxa,
270  l_int32 start,
271  l_int32 num,
272  l_int32 *pcropwarn)
273 {
274 l_int32 i, n, end, w, h, wbox, hbox, cropwarn;
275 BOX *box, *boxc;
276 PIX *pixd;
277 PIXA *pixad;
278 
279  if (!pixs)
280  return (PIXA *)ERROR_PTR("pixs not defined", __func__, NULL);
281  if (!boxa)
282  return (PIXA *)ERROR_PTR("boxa not defined", __func__, NULL);
283  if (num < 0)
284  return (PIXA *)ERROR_PTR("num must be >= 0", __func__, NULL);
285 
286  n = boxaGetCount(boxa);
287  end = (num == 0) ? n - 1 : L_MIN(start + num - 1, n - 1);
288  if ((pixad = pixaCreate(end - start + 1)) == NULL)
289  return (PIXA *)ERROR_PTR("pixad not made", __func__, NULL);
290 
291  boxaGetExtent(boxa, &wbox, &hbox, NULL);
292  pixGetDimensions(pixs, &w, &h, NULL);
293  cropwarn = FALSE;
294  if (wbox > w || hbox > h)
295  cropwarn = TRUE;
296  if (pcropwarn)
297  *pcropwarn = cropwarn;
298 
299  for (i = start; i <= end; i++) {
300  box = boxaGetBox(boxa, i, L_COPY);
301  if (cropwarn) { /* if box is outside pixs, pixd is NULL */
302  pixd = pixClipRectangle(pixs, box, &boxc); /* may be NULL */
303  if (pixd) {
304  pixaAddPix(pixad, pixd, L_INSERT);
305  pixaAddBox(pixad, boxc, L_INSERT);
306  }
307  boxDestroy(&box);
308  } else {
309  pixd = pixClipRectangle(pixs, box, NULL);
310  pixaAddPix(pixad, pixd, L_INSERT);
311  pixaAddBox(pixad, box, L_INSERT);
312  }
313  }
314 
315  return pixad;
316 }
317 
318 
343 PIXA *
345  l_int32 nx,
346  l_int32 ny,
347  l_int32 borderwidth,
348  l_uint32 bordercolor)
349 {
350 l_int32 w, h, d, cellw, cellh, i, j;
351 PIX *pix1;
352 PIXA *pixa;
353 
354  if (!pixs)
355  return (PIXA *)ERROR_PTR("pixs not defined", __func__, NULL);
356  if (nx <= 0 || ny <= 0)
357  return (PIXA *)ERROR_PTR("nx and ny must be > 0", __func__, NULL);
358  borderwidth = L_MAX(0, borderwidth);
359 
360  if ((pixa = pixaCreate(nx * ny)) == NULL)
361  return (PIXA *)ERROR_PTR("pixa not made", __func__, NULL);
362  pixGetDimensions(pixs, &w, &h, &d);
363  cellw = (w + nx - 1) / nx; /* round up */
364  cellh = (h + ny - 1) / ny;
365 
366  for (i = 0; i < ny; i++) {
367  for (j = 0; j < nx; j++) {
368  if ((pix1 = pixCreate(cellw + 2 * borderwidth,
369  cellh + 2 * borderwidth, d)) == NULL) {
370  pixaDestroy(&pixa);
371  return (PIXA *)ERROR_PTR("pix1 not made", __func__, NULL);
372  }
373  pixCopyColormap(pix1, pixs);
374  if (borderwidth == 0) { /* initialize full image to white */
375  if (d == 1)
376  pixClearAll(pix1);
377  else
378  pixSetAll(pix1);
379  } else {
380  pixSetAllArbitrary(pix1, bordercolor);
381  }
382  pixRasterop(pix1, borderwidth, borderwidth, cellw, cellh,
383  PIX_SRC, pixs, j * cellw, i * cellh);
384  pixaAddPix(pixa, pix1, L_INSERT);
385  }
386  }
387 
388  return pixa;
389 }
390 
391 
403 void
405 {
406 l_int32 i;
407 PIXA *pixa;
408 
409  if (ppixa == NULL) {
410  L_WARNING("ptr address is NULL!\n", __func__);
411  return;
412  }
413 
414  if ((pixa = *ppixa) == NULL)
415  return;
416 
417  /* Decrement the refcount. If it is 0, destroy the pixa. */
418  if (--pixa->refcount == 0) {
419  for (i = 0; i < pixa->n; i++)
420  pixDestroy(&pixa->pix[i]);
421  LEPT_FREE(pixa->pix);
422  boxaDestroy(&pixa->boxa);
423  LEPT_FREE(pixa);
424  }
425 
426  *ppixa = NULL;
427 }
428 
429 
441 PIXA *
443  l_int32 copyflag)
444 {
445 l_int32 i, nb;
446 BOX *boxc;
447 PIX *pixc;
448 PIXA *pixac;
449 
450  if (!pixa)
451  return (PIXA *)ERROR_PTR("pixa not defined", __func__, NULL);
452 
453  if (copyflag == L_CLONE) {
454  ++pixa->refcount;
455  return pixa;
456  }
457 
458  if (copyflag != L_COPY && copyflag != L_COPY_CLONE)
459  return (PIXA *)ERROR_PTR("invalid copyflag", __func__, NULL);
460 
461  if ((pixac = pixaCreate(pixa->n)) == NULL)
462  return (PIXA *)ERROR_PTR("pixac not made", __func__, NULL);
463  nb = pixaGetBoxaCount(pixa);
464  for (i = 0; i < pixa->n; i++) {
465  if (copyflag == L_COPY) {
466  pixc = pixaGetPix(pixa, i, L_COPY);
467  if (i < nb) boxc = pixaGetBox(pixa, i, L_COPY);
468  } else { /* copy-clone */
469  pixc = pixaGetPix(pixa, i, L_CLONE);
470  if (i < nb) boxc = pixaGetBox(pixa, i, L_CLONE);
471  }
472  pixaAddPix(pixac, pixc, L_INSERT);
473  if (i < nb) pixaAddBox(pixac, boxc, L_INSERT);
474  }
475 
476  return pixac;
477 }
478 
479 
480 
481 /*---------------------------------------------------------------------*
482  * Pixa addition *
483  *---------------------------------------------------------------------*/
492 l_ok
494  PIX *pix,
495  l_int32 copyflag)
496 {
497 l_int32 n;
498 PIX *pixc;
499 
500  if (!pixa)
501  return ERROR_INT("pixa not defined", __func__, 1);
502  if (!pix)
503  return ERROR_INT("pix not defined", __func__, 1);
504 
505  if (copyflag == L_INSERT)
506  pixc = pix;
507  else if (copyflag == L_COPY)
508  pixc = pixCopy(NULL, pix);
509  else if (copyflag == L_CLONE)
510  pixc = pixClone(pix);
511  else
512  return ERROR_INT("invalid copyflag", __func__, 1);
513  if (!pixc)
514  return ERROR_INT("pixc not made", __func__, 1);
515 
516  n = pixaGetCount(pixa);
517  if (n >= pixa->nalloc) {
518  if (pixaExtendArray(pixa)) {
519  if (copyflag != L_INSERT)
520  pixDestroy(&pixc);
521  return ERROR_INT("extension failed", __func__, 1);
522  }
523  }
524 
525  pixa->pix[n] = pixc;
526  pixa->n++;
527  return 0;
528 }
529 
530 
539 l_ok
541  BOX *box,
542  l_int32 copyflag)
543 {
544  if (!pixa)
545  return ERROR_INT("pixa not defined", __func__, 1);
546  if (!box)
547  return ERROR_INT("box not defined", __func__, 1);
548  if (copyflag != L_INSERT && copyflag != L_COPY && copyflag != L_CLONE)
549  return ERROR_INT("invalid copyflag", __func__, 1);
550 
551  boxaAddBox(pixa->boxa, box, copyflag);
552  return 0;
553 }
554 
555 
568 static l_int32
570 {
571  if (!pixa)
572  return ERROR_INT("pixa not defined", __func__, 1);
573 
574  return pixaExtendArrayToSize(pixa, 2 * pixa->nalloc);
575 }
576 
577 
592 l_ok
594  size_t size)
595 {
596 size_t oldsize, newsize;
597 
598  if (!pixa)
599  return ERROR_INT("pixa not defined", __func__, 1);
600  if (pixa->nalloc > MaxPixaPtrArraySize) /* belt & suspenders */
601  return ERROR_INT("pixa has too many ptrs", __func__, 1);
602  if (size > MaxPixaPtrArraySize)
603  return ERROR_INT("size > 5M ptrs; too large", __func__, 1);
604  if (size <= pixa->nalloc) {
605  L_INFO("size too small; no extension\n", __func__);
606  return 0;
607  }
608 
609  oldsize = pixa->nalloc * sizeof(PIX *);
610  newsize = size * sizeof(PIX *);
611  if ((pixa->pix = (PIX **)reallocNew((void **)&pixa->pix,
612  oldsize, newsize)) == NULL)
613  return ERROR_INT("new ptr array not returned", __func__, 1);
614  pixa->nalloc = size;
615  return boxaExtendArrayToSize(pixa->boxa, size);
616 }
617 
618 
619 /*---------------------------------------------------------------------*
620  * Pixa accessors *
621  *---------------------------------------------------------------------*/
628 l_int32
630 {
631  if (!pixa)
632  return ERROR_INT("pixa not defined", __func__, 0);
633 
634  return pixa->n;
635 }
636 
637 
646 PIX *
648  l_int32 index,
649  l_int32 accesstype)
650 {
651 PIX *pix;
652 
653  if (!pixa)
654  return (PIX *)ERROR_PTR("pixa not defined", __func__, NULL);
655  if (index < 0 || index >= pixa->n)
656  return (PIX *)ERROR_PTR("index not valid", __func__, NULL);
657  if ((pix = pixa->pix[index]) == NULL) {
658  L_ERROR("no pix at pixa[%d]\n", __func__, index);
659  return (PIX *)ERROR_PTR("pix not found!", __func__, NULL);
660  }
661 
662  if (accesstype == L_COPY)
663  return pixCopy(NULL, pix);
664  else if (accesstype == L_CLONE)
665  return pixClone(pix);
666  else
667  return (PIX *)ERROR_PTR("invalid accesstype", __func__, NULL);
668 }
669 
670 
679 l_ok
681  l_int32 index,
682  l_int32 *pw,
683  l_int32 *ph,
684  l_int32 *pd)
685 {
686 PIX *pix;
687 
688  if (pw) *pw = 0;
689  if (ph) *ph = 0;
690  if (pd) *pd = 0;
691  if (!pixa)
692  return ERROR_INT("pixa not defined", __func__, 1);
693  if (index < 0 || index >= pixa->n)
694  return ERROR_INT("index not valid", __func__, 1);
695 
696  if ((pix = pixaGetPix(pixa, index, L_CLONE)) == NULL)
697  return ERROR_INT("pix not found!", __func__, 1);
698  pixGetDimensions(pix, pw, ph, pd);
699  pixDestroy(&pix);
700  return 0;
701 }
702 
703 
711 BOXA *
713  l_int32 accesstype)
714 {
715  if (!pixa)
716  return (BOXA *)ERROR_PTR("pixa not defined", __func__, NULL);
717  if (!pixa->boxa)
718  return (BOXA *)ERROR_PTR("boxa not defined", __func__, NULL);
719  if (accesstype != L_COPY && accesstype != L_CLONE &&
720  accesstype != L_COPY_CLONE)
721  return (BOXA *)ERROR_PTR("invalid accesstype", __func__, NULL);
722 
723  return boxaCopy(pixa->boxa, accesstype);
724 }
725 
726 
733 l_int32
735 {
736  if (!pixa)
737  return ERROR_INT("pixa not defined", __func__, 0);
738 
739  return boxaGetCount(pixa->boxa);
740 }
741 
742 
763 BOX *
765  l_int32 index,
766  l_int32 accesstype)
767 {
768 BOX *box;
769 
770  if (!pixa)
771  return (BOX *)ERROR_PTR("pixa not defined", __func__, NULL);
772  if (!pixa->boxa)
773  return (BOX *)ERROR_PTR("boxa not defined", __func__, NULL);
774  if (index < 0 || index >= pixa->boxa->n)
775  return (BOX *)ERROR_PTR("index not valid", __func__, NULL);
776  if (accesstype != L_COPY && accesstype != L_CLONE)
777  return (BOX *)ERROR_PTR("invalid accesstype", __func__, NULL);
778 
779  box = pixa->boxa->box[index];
780  if (box) {
781  if (accesstype == L_COPY)
782  return boxCopy(box);
783  else /* accesstype == L_CLONE */
784  return boxClone(box);
785  } else {
786  return NULL;
787  }
788 }
789 
790 
799 l_ok
801  l_int32 index,
802  l_int32 *px,
803  l_int32 *py,
804  l_int32 *pw,
805  l_int32 *ph)
806 {
807 BOX *box;
808 
809  if (px) *px = 0;
810  if (py) *py = 0;
811  if (pw) *pw = 0;
812  if (ph) *ph = 0;
813  if (!pixa)
814  return ERROR_INT("pixa not defined", __func__, 1);
815  if (index < 0 || index >= pixa->n)
816  return ERROR_INT("index not valid", __func__, 1);
817 
818  if ((box = pixaGetBox(pixa, index, L_CLONE)) == NULL)
819  return ERROR_INT("box not found!", __func__, 1);
820  boxGetGeometry(box, px, py, pw, ph);
821  boxDestroy(&box);
822  return 0;
823 }
824 
825 
839 l_ok
841  BOXA *boxa,
842  l_int32 accesstype)
843 {
844  if (!pixa)
845  return ERROR_INT("pixa not defined", __func__, 1);
846  if (!boxa)
847  return ERROR_INT("boxa not defined", __func__, 1);
848  if (accesstype != L_INSERT && accesstype != L_COPY &&
849  accesstype != L_CLONE)
850  return ERROR_INT("invalid access type", __func__, 1);
851 
852  boxaDestroy(&pixa->boxa);
853  if (accesstype == L_INSERT)
854  pixa->boxa = boxa;
855  else
856  pixa->boxa = boxaCopy(boxa, accesstype);
857 
858  return 0;
859 }
860 
861 
876 PIX **
878 {
879  if (!pixa)
880  return (PIX **)ERROR_PTR("pixa not defined", __func__, NULL);
881 
882  return pixa->pix;
883 }
884 
885 
899 l_ok
901  l_int32 *psame,
902  l_int32 *pmaxd)
903 {
904 l_int32 i, n, d, maxd, same;
905 
906  if (pmaxd) *pmaxd = 0;
907  if (!psame)
908  return ERROR_INT("psame not defined", __func__, 1);
909  if (!pixa)
910  return ERROR_INT("pixa not defined", __func__, 1);
911  if ((n = pixaGetCount(pixa)) == 0)
912  return ERROR_INT("no pix in pixa", __func__, 1);
913 
914  same = 1;
915  pixaGetPixDimensions(pixa, 0, NULL, NULL, &maxd);
916  for (i = 1; i < n; i++) {
917  if (pixaGetPixDimensions(pixa, i, NULL, NULL, &d))
918  return ERROR_INT("pix depth not found", __func__, 1);
919  maxd = L_MAX(maxd, d);
920  if (d != maxd)
921  same = 0;
922  }
923  *psame = same;
924  if (pmaxd) *pmaxd = maxd;
925  return 0;
926 }
927 
928 
943 l_ok
945  l_int32 *psame,
946  l_int32 *pmaxw,
947  l_int32 *pmaxh)
948 {
949 l_int32 i, n, w, h, maxw, maxh, same;
950 
951  if (pmaxw) *pmaxw = 0;
952  if (pmaxh) *pmaxh = 0;
953  if (!psame)
954  return ERROR_INT("psame not defined", __func__, 1);
955  *psame = 0;
956  if (!pixa)
957  return ERROR_INT("pixa not defined", __func__, 1);
958  if ((n = pixaGetCount(pixa)) == 0)
959  return ERROR_INT("no pix in pixa", __func__, 1);
960 
961  same = 1;
962  pixaGetPixDimensions(pixa, 0, &maxw, &maxh, NULL);
963  for (i = 1; i < n; i++) {
964  if (pixaGetPixDimensions(pixa, i, &w, &h, NULL))
965  return ERROR_INT("pix dimensions not found", __func__, 1);
966  maxw = L_MAX(maxw, w);
967  maxh = L_MAX(maxh, h);
968  if (w != maxw || h != maxh)
969  same = 0;
970  }
971  *psame = same;
972  if (pmaxw) *pmaxw = maxw;
973  if (pmaxh) *pmaxh = maxh;
974  return 0;
975 }
976 
977 
992 l_ok
994  l_int32 *pfullpa,
995  l_int32 *pfullba)
996 {
997 l_int32 i, n, full;
998 BOXA *boxa;
999 PIX *pix;
1000 
1001  if (pfullpa) *pfullpa = 0;
1002  if (pfullba) *pfullba = 0;
1003  if (!pixa)
1004  return ERROR_INT("pixa not defined", __func__, 1);
1005 
1006  n = pixaGetCount(pixa);
1007  if (pfullpa) {
1008  full = 1;
1009  for (i = 0; i < n; i++) {
1010  if ((pix = pixaGetPix(pixa, i, L_CLONE)) == NULL) {
1011  full = 0;
1012  break;
1013  }
1014  pixDestroy(&pix);
1015  }
1016  *pfullpa = full;
1017  }
1018  if (pfullba) {
1019  boxa = pixaGetBoxa(pixa, L_CLONE);
1020  boxaIsFull(boxa, pfullba);
1021  boxaDestroy(&boxa);
1022  }
1023  return 0;
1024 }
1025 
1026 
1040 l_ok
1042  l_int32 *pntext)
1043 {
1044 char *text;
1045 l_int32 i, n;
1046 PIX *pix;
1047 
1048  if (!pntext)
1049  return ERROR_INT("&ntext not defined", __func__, 1);
1050  *pntext = 0;
1051  if (!pixa)
1052  return ERROR_INT("pixa not defined", __func__, 1);
1053 
1054  n = pixaGetCount(pixa);
1055  for (i = 0; i < n; i++) {
1056  if ((pix = pixaGetPix(pixa, i, L_CLONE)) == NULL)
1057  continue;
1058  text = pixGetText(pix);
1059  if (text && strlen(text) > 0)
1060  (*pntext)++;
1061  pixDestroy(&pix);
1062  }
1063 
1064  return 0;
1065 }
1066 
1067 
1086 l_ok
1088  const char *text,
1089  SARRAY *sa)
1090 {
1091 char *str;
1092 l_int32 i, n;
1093 PIX *pix;
1094 
1095  if (!pixa)
1096  return ERROR_INT("pixa not defined", __func__, 1);
1097 
1098  n = pixaGetCount(pixa);
1099  if (sa && (sarrayGetCount(sa) != n))
1100  return ERROR_INT("pixa and sa sizes differ", __func__, 1);
1101 
1102  if (!sa) {
1103  for (i = 0; i < n; i++) {
1104  if ((pix = pixaGetPix(pixa, i, L_CLONE)) == NULL)
1105  continue;
1106  pixSetText(pix, text);
1107  pixDestroy(&pix);
1108  }
1109  return 0;
1110  }
1111 
1112  for (i = 0; i < n; i++) {
1113  if ((pix = pixaGetPix(pixa, i, L_CLONE)) == NULL)
1114  continue;
1115  str = sarrayGetString(sa, i, L_NOCOPY);
1116  pixSetText(pix, str);
1117  pixDestroy(&pix);
1118  }
1119 
1120  return 0;
1121 }
1122 
1123 
1143 void ***
1145  l_int32 *psize)
1146 {
1147 l_int32 i, n, same;
1148 void **lineptrs;
1149 void ***lineset;
1150 PIX *pix;
1151 
1152  if (psize) *psize = 0;
1153  if (!pixa)
1154  return (void ***)ERROR_PTR("pixa not defined", __func__, NULL);
1155  pixaVerifyDepth(pixa, &same, NULL);
1156  if (!same)
1157  return (void ***)ERROR_PTR("pixa not all same depth", __func__, NULL);
1158  n = pixaGetCount(pixa);
1159  if (psize) *psize = n;
1160  if ((lineset = (void ***)LEPT_CALLOC(n, sizeof(void **))) == NULL)
1161  return (void ***)ERROR_PTR("lineset not made", __func__, NULL);
1162  for (i = 0; i < n; i++) {
1163  pix = pixaGetPix(pixa, i, L_CLONE);
1164  lineptrs = pixGetLinePtrs(pix, NULL);
1165  lineset[i] = lineptrs;
1166  pixDestroy(&pix);
1167  }
1168 
1169  return lineset;
1170 }
1171 
1172 
1173 /*---------------------------------------------------------------------*
1174  * Pixa output info *
1175  *---------------------------------------------------------------------*/
1189 l_ok
1191  PIXA *pixa)
1192 {
1193 char *text;
1194 l_int32 i, n, w, h, d, spp, count, hastext;
1195 PIX *pix;
1196 PIXCMAP *cmap;
1197 
1198  if (!fp)
1199  return ERROR_INT("stream not defined", __func__, 1);
1200  if (!pixa)
1201  return ERROR_INT("pixa not defined", __func__, 1);
1202 
1203  n = pixaGetCount(pixa);
1204  for (i = 0; i < n; i++) {
1205  if ((pix = pixaGetPix(pixa, i, L_CLONE)) == NULL) {
1206  fprintf(fp, "%d: no pix at this index\n", i);
1207  continue;
1208  }
1209  pixGetDimensions(pix, &w, &h, &d);
1210  spp = pixGetSpp(pix);
1211  text = pixGetText(pix);
1212  hastext = (text && strlen(text) > 0);
1213  if ((cmap = pixGetColormap(pix)) != NULL)
1214  count = pixcmapGetCount(cmap);
1215  fprintf(fp, "Pix %d: w = %d, h = %d, d = %d, spp = %d",
1216  i, w, h, d, spp);
1217  if (cmap) fprintf(fp, ", cmap(%d colors)", count);
1218  if (hastext) fprintf(fp, ", text = %s", text);
1219  fprintf(fp, "\n");
1220  pixDestroy(&pix);
1221  }
1222 
1223  return 0;
1224 }
1225 
1226 
1227 /*---------------------------------------------------------------------*
1228  * Pixa array modifiers *
1229  *---------------------------------------------------------------------*/
1245 l_ok
1247  l_int32 index,
1248  PIX *pix,
1249  BOX *box)
1250 {
1251 BOXA *boxa;
1252 
1253  if (!pixa)
1254  return ERROR_INT("pixa not defined", __func__, 1);
1255  if (index < 0 || index >= pixa->n)
1256  return ERROR_INT("index not valid", __func__, 1);
1257  if (!pix)
1258  return ERROR_INT("pix not defined", __func__, 1);
1259 
1260  pixDestroy(&(pixa->pix[index]));
1261  pixa->pix[index] = pix;
1262 
1263  if (box) {
1264  boxa = pixa->boxa;
1265  if (index > boxa->n)
1266  return ERROR_INT("boxa index not valid", __func__, 1);
1267  boxaReplaceBox(boxa, index, box);
1268  }
1269 
1270  return 0;
1271 }
1272 
1273 
1293 l_ok
1295  l_int32 index,
1296  PIX *pixs,
1297  BOX *box)
1298 {
1299 l_int32 i, n;
1300 
1301  if (!pixa)
1302  return ERROR_INT("pixa not defined", __func__, 1);
1303  n = pixaGetCount(pixa);
1304  if (index < 0 || index > n) {
1305  L_ERROR("index %d not in [0,...,%d]\n", __func__, index, n);
1306  return 1;
1307  }
1308  if (!pixs)
1309  return ERROR_INT("pixs not defined", __func__, 1);
1310 
1311  if (n >= pixa->nalloc) { /* extend both ptr arrays */
1312  if (pixaExtendArray(pixa))
1313  return ERROR_INT("extension failed", __func__, 1);
1314  if (boxaExtendArray(pixa->boxa))
1315  return ERROR_INT("extension failed", __func__, 1);
1316  }
1317  pixa->n++;
1318  for (i = n; i > index; i--)
1319  pixa->pix[i] = pixa->pix[i - 1];
1320  pixa->pix[index] = pixs;
1321 
1322  /* Optionally, insert the box */
1323  if (box)
1324  boxaInsertBox(pixa->boxa, index, box);
1325  return 0;
1326 }
1327 
1328 
1344 l_ok
1346  l_int32 index)
1347 {
1348 l_int32 i, n, nbox;
1349 BOXA *boxa;
1350 PIX **array;
1351 
1352  if (!pixa)
1353  return ERROR_INT("pixa not defined", __func__, 1);
1354  n = pixaGetCount(pixa);
1355  if (index < 0 || index >= n) {
1356  L_ERROR("index %d not in [0,...,%d]\n", __func__, index, n - 1);
1357  return 1;
1358  }
1359 
1360  /* Remove the pix */
1361  array = pixa->pix;
1362  pixDestroy(&array[index]);
1363  for (i = index + 1; i < n; i++)
1364  array[i - 1] = array[i];
1365  array[n - 1] = NULL;
1366  pixa->n--;
1367 
1368  /* Remove the box if it exists */
1369  boxa = pixa->boxa;
1370  nbox = boxaGetCount(boxa);
1371  if (index < nbox)
1372  boxaRemoveBox(boxa, index);
1373 
1374  return 0;
1375 }
1376 
1377 
1396 l_ok
1398  l_int32 index,
1399  PIX **ppix,
1400  BOX **pbox)
1401 {
1402 l_int32 i, n, nbox;
1403 BOXA *boxa;
1404 PIX **array;
1405 
1406  if (ppix) *ppix = NULL;
1407  if (pbox) *pbox = NULL;
1408  if (!pixa)
1409  return ERROR_INT("pixa not defined", __func__, 1);
1410  n = pixaGetCount(pixa);
1411  if (index < 0 || index >= n) {
1412  L_ERROR("index %d not in [0,...,%d]\n", __func__, index, n - 1);
1413  return 1;
1414  }
1415 
1416  /* Remove the pix */
1417  array = pixa->pix;
1418  if (ppix)
1419  *ppix = pixaGetPix(pixa, index, L_CLONE);
1420  pixDestroy(&array[index]);
1421  for (i = index + 1; i < n; i++)
1422  array[i - 1] = array[i];
1423  array[n - 1] = NULL;
1424  pixa->n--;
1425 
1426  /* Remove the box if it exists */
1427  boxa = pixa->boxa;
1428  nbox = boxaGetCount(boxa);
1429  if (index < nbox)
1430  boxaRemoveBoxAndSave(boxa, index, pbox);
1431 
1432  return 0;
1433 }
1434 
1435 
1448 l_ok
1450  NUMA *naindex)
1451 {
1452 l_int32 i, n, index;
1453 NUMA *na1;
1454 
1455  if (!pixa)
1456  return ERROR_INT("pixa not defined", __func__, 1);
1457  if (!naindex)
1458  return ERROR_INT("naindex not defined", __func__, 1);
1459  if ((n = numaGetCount(naindex)) == 0)
1460  return ERROR_INT("naindex is empty", __func__, 1);
1461 
1462  /* Remove from highest indices first */
1463  na1 = numaSort(NULL, naindex, L_SORT_DECREASING);
1464  for (i = 0; i < n; i++) {
1465  numaGetIValue(na1, i, &index);
1466  pixaRemovePix(pixa, index);
1467  }
1468  numaDestroy(&na1);
1469  return 0;
1470 }
1471 
1472 
1508 l_ok
1510  PIX *pix,
1511  BOX *box)
1512 {
1513 l_int32 i, n;
1514 PIX *pix1;
1515 
1516  if (!pixa)
1517  return ERROR_INT("pixa not defined", __func__, 1);
1518 
1519  n = pixa->nalloc;
1520  pixa->n = n;
1521  for (i = 0; i < n; i++) {
1522  if (pix)
1523  pix1 = pixCopy(NULL, pix);
1524  else
1525  pix1 = pixCreate(1, 1, 1);
1526  pixaReplacePix(pixa, i, pix1, NULL);
1527  }
1528  if (box)
1529  boxaInitFull(pixa->boxa, box);
1530 
1531  return 0;
1532 }
1533 
1534 
1548 l_ok
1550 {
1551 l_int32 i, n;
1552 
1553  if (!pixa)
1554  return ERROR_INT("pixa not defined", __func__, 1);
1555 
1556  n = pixaGetCount(pixa);
1557  for (i = 0; i < n; i++)
1558  pixDestroy(&pixa->pix[i]);
1559  pixa->n = 0;
1560  return boxaClear(pixa->boxa);
1561 }
1562 
1563 
1564 /*---------------------------------------------------------------------*
1565  * Pixa and Pixaa combination *
1566  *---------------------------------------------------------------------*/
1584 l_ok
1586  PIXA *pixas,
1587  l_int32 istart,
1588  l_int32 iend)
1589 {
1590 l_int32 i, n, nb;
1591 BOXA *boxas, *boxad;
1592 PIX *pix;
1593 
1594  if (!pixad)
1595  return ERROR_INT("pixad not defined", __func__, 1);
1596  if (!pixas || ((n = pixaGetCount(pixas)) == 0))
1597  return 0;
1598 
1599  if (istart < 0)
1600  istart = 0;
1601  if (iend < 0 || iend >= n)
1602  iend = n - 1;
1603  if (istart > iend)
1604  return ERROR_INT("istart > iend; nothing to add", __func__, 1);
1605 
1606  for (i = istart; i <= iend; i++) {
1607  pix = pixaGetPix(pixas, i, L_CLONE);
1608  pixaAddPix(pixad, pix, L_INSERT);
1609  }
1610 
1611  boxas = pixaGetBoxa(pixas, L_CLONE);
1612  boxad = pixaGetBoxa(pixad, L_CLONE);
1613  nb = pixaGetBoxaCount(pixas);
1614  iend = L_MIN(iend, nb - 1);
1615  boxaJoin(boxad, boxas, istart, iend);
1616  boxaDestroy(&boxas); /* just the clones */
1617  boxaDestroy(&boxad);
1618  return 0;
1619 }
1620 
1621 
1638 PIXA *
1640  PIXA *pixa2,
1641  l_int32 copyflag)
1642 {
1643 l_int32 i, n1, n2, n, nb1, nb2;
1644 BOX *box;
1645 PIX *pix;
1646 PIXA *pixad;
1647 
1648  if (!pixa1)
1649  return (PIXA *)ERROR_PTR("pixa1 not defined", __func__, NULL);
1650  if (!pixa2)
1651  return (PIXA *)ERROR_PTR("pixa2 not defined", __func__, NULL);
1652  if (copyflag != L_COPY && copyflag != L_CLONE)
1653  return (PIXA *)ERROR_PTR("invalid copyflag", __func__, NULL);
1654  n1 = pixaGetCount(pixa1);
1655  n2 = pixaGetCount(pixa2);
1656  n = L_MIN(n1, n2);
1657  if (n == 0)
1658  return (PIXA *)ERROR_PTR("at least one input pixa is empty",
1659  __func__, NULL);
1660  if (n1 != n2)
1661  L_WARNING("counts differ: %d != %d\n", __func__, n1, n2);
1662 
1663  pixad = pixaCreate(2 * n);
1664  nb1 = pixaGetBoxaCount(pixa1);
1665  nb2 = pixaGetBoxaCount(pixa2);
1666  for (i = 0; i < n; i++) {
1667  pix = pixaGetPix(pixa1, i, copyflag);
1668  pixaAddPix(pixad, pix, L_INSERT);
1669  if (i < nb1) {
1670  box = pixaGetBox(pixa1, i, L_COPY);
1671  pixaAddBox(pixad, box, L_INSERT);
1672  }
1673  pix = pixaGetPix(pixa2, i, copyflag);
1674  pixaAddPix(pixad, pix, L_INSERT);
1675  if (i < nb2) {
1676  box = pixaGetBox(pixa2, i, L_COPY);
1677  pixaAddBox(pixad, box, L_INSERT);
1678  }
1679  }
1680 
1681  return pixad;
1682 }
1683 
1684 
1701 l_ok
1703  PIXAA *paas,
1704  l_int32 istart,
1705  l_int32 iend)
1706 {
1707 l_int32 i, n;
1708 PIXA *pixa;
1709 
1710  if (!paad)
1711  return ERROR_INT("pixaad not defined", __func__, 1);
1712  if (!paas)
1713  return 0;
1714 
1715  if (istart < 0)
1716  istart = 0;
1717  n = pixaaGetCount(paas, NULL);
1718  if (iend < 0 || iend >= n)
1719  iend = n - 1;
1720  if (istart > iend)
1721  return ERROR_INT("istart > iend; nothing to add", __func__, 1);
1722 
1723  for (i = istart; i <= iend; i++) {
1724  pixa = pixaaGetPixa(paas, i, L_CLONE);
1725  pixaaAddPixa(paad, pixa, L_INSERT);
1726  }
1727 
1728  return 0;
1729 }
1730 
1731 
1732 /*---------------------------------------------------------------------*
1733  * Pixaa creation and destruction *
1734  *---------------------------------------------------------------------*/
1757 PIXAA *
1758 pixaaCreate(l_int32 n)
1759 {
1760 PIXAA *paa;
1761 
1762  if (n <= 0 || n > MaxInitPtrArraySize)
1763  n = InitialPtrArraySize;
1764 
1765  paa = (PIXAA *)LEPT_CALLOC(1, sizeof(PIXAA));
1766  paa->n = 0;
1767  paa->nalloc = n;
1768  if ((paa->pixa = (PIXA **)LEPT_CALLOC(n, sizeof(PIXA *))) == NULL) {
1769  pixaaDestroy(&paa);
1770  return (PIXAA *)ERROR_PTR("pixa ptrs not made", __func__, NULL);
1771  }
1772  paa->boxa = boxaCreate(n);
1773 
1774  return paa;
1775 }
1776 
1777 
1798 PIXAA *
1800  l_int32 n,
1801  l_int32 type,
1802  l_int32 copyflag)
1803 {
1804 l_int32 count, i, j, npixa;
1805 PIX *pix;
1806 PIXA *pixat;
1807 PIXAA *paa;
1808 
1809  if (!pixa)
1810  return (PIXAA *)ERROR_PTR("pixa not defined", __func__, NULL);
1811  count = pixaGetCount(pixa);
1812  if (count == 0)
1813  return (PIXAA *)ERROR_PTR("no pix in pixa", __func__, NULL);
1814  if (n <= 0)
1815  return (PIXAA *)ERROR_PTR("n must be > 0", __func__, NULL);
1816  if (type != L_CHOOSE_CONSECUTIVE && type != L_CHOOSE_SKIP_BY)
1817  return (PIXAA *)ERROR_PTR("invalid type", __func__, NULL);
1818  if (copyflag != L_CLONE && copyflag != L_COPY)
1819  return (PIXAA *)ERROR_PTR("invalid copyflag", __func__, NULL);
1820 
1821  if (type == L_CHOOSE_CONSECUTIVE)
1822  npixa = (count + n - 1) / n;
1823  else /* L_CHOOSE_SKIP_BY */
1824  npixa = L_MIN(n, count);
1825  paa = pixaaCreate(npixa);
1826  if (type == L_CHOOSE_CONSECUTIVE) {
1827  for (i = 0; i < count; i++) {
1828  if (i % n == 0)
1829  pixat = pixaCreate(n);
1830  pix = pixaGetPix(pixa, i, copyflag);
1831  pixaAddPix(pixat, pix, L_INSERT);
1832  if (i % n == n - 1)
1833  pixaaAddPixa(paa, pixat, L_INSERT);
1834  }
1835  if (i % n != 0)
1836  pixaaAddPixa(paa, pixat, L_INSERT);
1837  } else { /* L_CHOOSE_SKIP_BY */
1838  for (i = 0; i < npixa; i++) {
1839  pixat = pixaCreate(count / npixa + 1);
1840  for (j = i; j < count; j += n) {
1841  pix = pixaGetPix(pixa, j, copyflag);
1842  pixaAddPix(pixat, pix, L_INSERT);
1843  }
1844  pixaaAddPixa(paa, pixat, L_INSERT);
1845  }
1846  }
1847 
1848  return paa;
1849 }
1850 
1851 
1858 void
1860 {
1861 l_int32 i;
1862 PIXAA *paa;
1863 
1864  if (ppaa == NULL) {
1865  L_WARNING("ptr address is NULL!\n", __func__);
1866  return;
1867  }
1868 
1869  if ((paa = *ppaa) == NULL)
1870  return;
1871 
1872  for (i = 0; i < paa->n; i++)
1873  pixaDestroy(&paa->pixa[i]);
1874  LEPT_FREE(paa->pixa);
1875  boxaDestroy(&paa->boxa);
1876  LEPT_FREE(paa);
1877  *ppaa = NULL;
1878 }
1879 
1880 
1881 /*---------------------------------------------------------------------*
1882  * Pixaa addition *
1883  *---------------------------------------------------------------------*/
1897 l_ok
1899  PIXA *pixa,
1900  l_int32 copyflag)
1901 {
1902 l_int32 n;
1903 PIXA *pixac;
1904 
1905  if (!paa)
1906  return ERROR_INT("paa not defined", __func__, 1);
1907  if (!pixa)
1908  return ERROR_INT("pixa not defined", __func__, 1);
1909  if (copyflag != L_INSERT && copyflag != L_COPY &&
1910  copyflag != L_CLONE && copyflag != L_COPY_CLONE)
1911  return ERROR_INT("invalid copyflag", __func__, 1);
1912 
1913  if (copyflag == L_INSERT) {
1914  pixac = pixa;
1915  } else {
1916  if ((pixac = pixaCopy(pixa, copyflag)) == NULL)
1917  return ERROR_INT("pixac not made", __func__, 1);
1918  }
1919 
1920  n = pixaaGetCount(paa, NULL);
1921  if (n >= paa->nalloc) {
1922  if (pixaaExtendArray(paa)) {
1923  if (copyflag != L_INSERT)
1924  pixaDestroy(&pixac);
1925  return ERROR_INT("extension failed", __func__, 1);
1926  }
1927  }
1928  paa->pixa[n] = pixac;
1929  paa->n++;
1930  return 0;
1931 }
1932 
1933 
1945 static l_int32
1947 {
1948 size_t oldsize, newsize;
1949 
1950  if (!paa)
1951  return ERROR_INT("paa not defined", __func__, 1);
1952  if (paa->nalloc > MaxPixaaPtrArraySize) /* belt & suspenders */
1953  return ERROR_INT("paa has too many ptrs", __func__, 1);
1954  oldsize = paa->nalloc * sizeof(PIXA *);
1955  newsize = 2 * oldsize;
1956  if (newsize > 8 * MaxPixaaPtrArraySize)
1957  return ERROR_INT("newsize > 8 MB; too large", __func__, 1);
1958 
1959  if ((paa->pixa = (PIXA **)reallocNew((void **)&paa->pixa,
1960  oldsize, newsize)) == NULL)
1961  return ERROR_INT("new ptr array not returned", __func__, 1);
1962 
1963  paa->nalloc *= 2;
1964  return 0;
1965 }
1966 
1967 
1978 l_ok
1980  l_int32 index,
1981  PIX *pix,
1982  BOX *box,
1983  l_int32 copyflag)
1984 {
1985 PIXA *pixa;
1986 
1987  if (!paa)
1988  return ERROR_INT("paa not defined", __func__, 1);
1989  if (!pix)
1990  return ERROR_INT("pix not defined", __func__, 1);
1991 
1992  if ((pixa = pixaaGetPixa(paa, index, L_CLONE)) == NULL)
1993  return ERROR_INT("pixa not found", __func__, 1);
1994  pixaAddPix(pixa, pix, copyflag);
1995  if (box) pixaAddBox(pixa, box, copyflag);
1996  pixaDestroy(&pixa);
1997  return 0;
1998 }
1999 
2000 
2015 l_ok
2017  BOX *box,
2018  l_int32 copyflag)
2019 {
2020  if (!paa)
2021  return ERROR_INT("paa not defined", __func__, 1);
2022  if (!box)
2023  return ERROR_INT("box not defined", __func__, 1);
2024  if (copyflag != L_INSERT && copyflag != L_COPY && copyflag != L_CLONE)
2025  return ERROR_INT("invalid copyflag", __func__, 1);
2026 
2027  boxaAddBox(paa->boxa, box, copyflag);
2028  return 0;
2029 }
2030 
2031 
2032 
2033 /*---------------------------------------------------------------------*
2034  * Pixaa accessors *
2035  *---------------------------------------------------------------------*/
2048 l_int32
2050  NUMA **pna)
2051 {
2052 l_int32 i, n;
2053 NUMA *na;
2054 PIXA *pixa;
2055 
2056  if (pna) *pna = NULL;
2057  if (!paa)
2058  return ERROR_INT("paa not defined", __func__, 0);
2059 
2060  n = paa->n;
2061  if (pna) {
2062  if ((na = numaCreate(n)) == NULL)
2063  return ERROR_INT("na not made", __func__, 0);
2064  *pna = na;
2065  for (i = 0; i < n; i++) {
2066  pixa = pixaaGetPixa(paa, i, L_CLONE);
2067  numaAddNumber(na, pixaGetCount(pixa));
2068  pixaDestroy(&pixa);
2069  }
2070  }
2071  return n;
2072 }
2073 
2074 
2095 PIXA *
2097  l_int32 index,
2098  l_int32 accesstype)
2099 {
2100 PIXA *pixa;
2101 
2102  if (!paa)
2103  return (PIXA *)ERROR_PTR("paa not defined", __func__, NULL);
2104  if (index < 0 || index >= paa->n)
2105  return (PIXA *)ERROR_PTR("index not valid", __func__, NULL);
2106  if (accesstype != L_COPY && accesstype != L_CLONE &&
2107  accesstype != L_COPY_CLONE)
2108  return (PIXA *)ERROR_PTR("invalid accesstype", __func__, NULL);
2109 
2110  if ((pixa = paa->pixa[index]) == NULL) { /* shouldn't happen! */
2111  L_ERROR("missing pixa[%d]\n", __func__, index);
2112  return (PIXA *)ERROR_PTR("pixa not found at index", __func__, NULL);
2113  }
2114  return pixaCopy(pixa, accesstype);
2115 }
2116 
2117 
2131 BOXA *
2133  l_int32 accesstype)
2134 {
2135  if (!paa)
2136  return (BOXA *)ERROR_PTR("paa not defined", __func__, NULL);
2137  if (accesstype != L_COPY && accesstype != L_CLONE)
2138  return (BOXA *)ERROR_PTR("invalid access type", __func__, NULL);
2139 
2140  return boxaCopy(paa->boxa, accesstype);
2141 }
2142 
2143 
2153 PIX *
2155  l_int32 index,
2156  l_int32 ipix,
2157  l_int32 accessflag)
2158 {
2159 PIX *pix;
2160 PIXA *pixa;
2161 
2162  if ((pixa = pixaaGetPixa(paa, index, L_CLONE)) == NULL)
2163  return (PIX *)ERROR_PTR("pixa not retrieved", __func__, NULL);
2164  if ((pix = pixaGetPix(pixa, ipix, accessflag)) == NULL)
2165  L_ERROR("pix not retrieved\n", __func__);
2166  pixaDestroy(&pixa);
2167  return pix;
2168 }
2169 
2170 
2184 l_ok
2186  l_int32 *psame,
2187  l_int32 *pmaxd)
2188 {
2189 l_int32 i, n, d, maxd, same, samed;
2190 PIXA *pixa;
2191 
2192  if (pmaxd) *pmaxd = 0;
2193  if (!psame)
2194  return ERROR_INT("psame not defined", __func__, 1);
2195  *psame = 0;
2196  if (!paa)
2197  return ERROR_INT("paa not defined", __func__, 1);
2198  if ((n = pixaaGetCount(paa, NULL)) == 0)
2199  return ERROR_INT("no pixa in paa", __func__, 1);
2200 
2201  pixa = pixaaGetPixa(paa, 0, L_CLONE);
2202  pixaVerifyDepth(pixa, &same, &maxd); /* init same, maxd with first pixa */
2203  pixaDestroy(&pixa);
2204  for (i = 1; i < n; i++) {
2205  pixa = pixaaGetPixa(paa, i, L_CLONE);
2206  pixaVerifyDepth(pixa, &samed, &d);
2207  pixaDestroy(&pixa);
2208  maxd = L_MAX(maxd, d);
2209  if (!samed || maxd != d)
2210  same = 0;
2211  }
2212  *psame = same;
2213  if (pmaxd) *pmaxd = maxd;
2214  return 0;
2215 }
2216 
2217 
2232 l_ok
2234  l_int32 *psame,
2235  l_int32 *pmaxw,
2236  l_int32 *pmaxh)
2237 {
2238 l_int32 i, n, w, h, maxw, maxh, same, same2;
2239 PIXA *pixa;
2240 
2241  if (pmaxw) *pmaxw = 0;
2242  if (pmaxh) *pmaxh = 0;
2243  if (!psame)
2244  return ERROR_INT("psame not defined", __func__, 1);
2245  *psame = 0;
2246  if (!paa)
2247  return ERROR_INT("paa not defined", __func__, 1);
2248  if ((n = pixaaGetCount(paa, NULL)) == 0)
2249  return ERROR_INT("no pixa in paa", __func__, 1);
2250 
2251  /* Init same; init maxw and maxh from first pixa */
2252  pixa = pixaaGetPixa(paa, 0, L_CLONE);
2253  pixaVerifyDimensions(pixa, &same, &maxw, &maxh);
2254  pixaDestroy(&pixa);
2255 
2256  for (i = 1; i < n; i++) {
2257  pixa = pixaaGetPixa(paa, i, L_CLONE);
2258  pixaVerifyDimensions(pixa, &same2, &w, &h);
2259  pixaDestroy(&pixa);
2260  maxw = L_MAX(maxw, w);
2261  maxh = L_MAX(maxh, h);
2262  if (!same2 || maxw != w || maxh != h)
2263  same = 0;
2264  }
2265  *psame = same;
2266  if (pmaxw) *pmaxw = maxw;
2267  if (pmaxh) *pmaxh = maxh;
2268  return 0;
2269 }
2270 
2271 
2284 l_int32
2286  l_int32 *pfull)
2287 {
2288 l_int32 i, n, full;
2289 PIXA *pixa;
2290 
2291  if (!pfull)
2292  return ERROR_INT("&full not defined", __func__, 0);
2293  *pfull = 0;
2294  if (!paa)
2295  return ERROR_INT("paa not defined", __func__, 0);
2296 
2297  n = pixaaGetCount(paa, NULL);
2298  full = 1;
2299  for (i = 0; i < n; i++) {
2300  pixa = pixaaGetPixa(paa, i, L_CLONE);
2301  pixaIsFull(pixa, &full, NULL);
2302  pixaDestroy(&pixa);
2303  if (!full) break;
2304  }
2305  *pfull = full;
2306  return 0;
2307 }
2308 
2309 
2310 /*---------------------------------------------------------------------*
2311  * Pixaa array modifiers *
2312  *---------------------------------------------------------------------*/
2334 l_ok
2336  PIXA *pixa)
2337 {
2338 l_int32 i, n;
2339 PIXA *pixat;
2340 
2341  if (!paa)
2342  return ERROR_INT("paa not defined", __func__, 1);
2343  if (!pixa)
2344  return ERROR_INT("pixa not defined", __func__, 1);
2345 
2346  n = paa->nalloc;
2347  paa->n = n;
2348  for (i = 0; i < n; i++) {
2349  pixat = pixaCopy(pixa, L_COPY);
2350  pixaaReplacePixa(paa, i, pixat);
2351  }
2352 
2353  return 0;
2354 }
2355 
2356 
2374 l_ok
2376  l_int32 index,
2377  PIXA *pixa)
2378 {
2379 
2380  if (!paa)
2381  return ERROR_INT("paa not defined", __func__, 1);
2382  if (index < 0 || index >= paa->n)
2383  return ERROR_INT("index not valid", __func__, 1);
2384  if (!pixa)
2385  return ERROR_INT("pixa not defined", __func__, 1);
2386 
2387  pixaDestroy(&(paa->pixa[index]));
2388  paa->pixa[index] = pixa;
2389  return 0;
2390 }
2391 
2392 
2405 l_ok
2407 {
2408 l_int32 i, n;
2409 
2410  if (!paa)
2411  return ERROR_INT("paa not defined", __func__, 1);
2412 
2413  n = pixaaGetCount(paa, NULL);
2414  for (i = 0; i < n; i++)
2415  pixaDestroy(&paa->pixa[i]);
2416  paa->n = 0;
2417  return 0;
2418 }
2419 
2420 
2434 l_ok
2436 {
2437 l_int32 i, n, np;
2438 PIXA *pixa;
2439 
2440  if (!paa)
2441  return ERROR_INT("paa not defined", __func__, 1);
2442 
2443  n = pixaaGetCount(paa, NULL);
2444  for (i = n - 1; i >= 0; i--) {
2445  pixa = pixaaGetPixa(paa, i, L_CLONE);
2446  if (!pixa) {
2447  paa->n--;
2448  continue;
2449  }
2450  np = pixaGetCount(pixa);
2451  pixaDestroy(&pixa);
2452  if (np == 0) {
2453  pixaDestroy(&paa->pixa[i]);
2454  paa->n--;
2455  } else {
2456  break;
2457  }
2458  }
2459  return 0;
2460 }
2461 
2462 
2463 
2464 /*---------------------------------------------------------------------*
2465  * Pixa serialized I/O *
2466  *---------------------------------------------------------------------*/
2479 PIXA *
2480 pixaRead(const char *filename)
2481 {
2482 FILE *fp;
2483 PIXA *pixa;
2484 
2485 #if !HAVE_LIBPNG /* defined in environ.h and config_auto.h */
2486  return (PIXA *)ERROR_PTR("no libpng: can't read data", __func__, NULL);
2487 #endif /* !HAVE_LIBPNG */
2488 
2489  if (!filename)
2490  return (PIXA *)ERROR_PTR("filename not defined", __func__, NULL);
2491 
2492  if ((fp = fopenReadStream(filename)) == NULL)
2493  return (PIXA *)ERROR_PTR("stream not opened", __func__, NULL);
2494  pixa = pixaReadStream(fp);
2495  fclose(fp);
2496  if (!pixa)
2497  return (PIXA *)ERROR_PTR("pixa not read", __func__, NULL);
2498  return pixa;
2499 }
2500 
2501 
2515 PIXA *
2517 {
2518 l_int32 n, i, xres, yres, version;
2519 l_int32 ignore;
2520 BOXA *boxa;
2521 PIX *pix;
2522 PIXA *pixa;
2523 
2524 #if !HAVE_LIBPNG /* defined in environ.h and config_auto.h */
2525  return (PIXA *)ERROR_PTR("no libpng: can't read data", __func__, NULL);
2526 #endif /* !HAVE_LIBPNG */
2527 
2528  if (!fp)
2529  return (PIXA *)ERROR_PTR("stream not defined", __func__, NULL);
2530 
2531  if (fscanf(fp, "\nPixa Version %d\n", &version) != 1)
2532  return (PIXA *)ERROR_PTR("not a pixa file", __func__, NULL);
2533  if (version != PIXA_VERSION_NUMBER)
2534  return (PIXA *)ERROR_PTR("invalid pixa version", __func__, NULL);
2535  if (fscanf(fp, "Number of pix = %d\n", &n) != 1)
2536  return (PIXA *)ERROR_PTR("not a pixa file", __func__, NULL);
2537  if (n < 0)
2538  return (PIXA *)ERROR_PTR("num pix ptrs < 0", __func__, NULL);
2539  if (n > MaxPixaPtrArraySize)
2540  return (PIXA *)ERROR_PTR("too many pix ptrs", __func__, NULL);
2541  if (n == 0) L_INFO("the pixa is empty\n", __func__);
2542 
2543  if ((boxa = boxaReadStream(fp)) == NULL)
2544  return (PIXA *)ERROR_PTR("boxa not made", __func__, NULL);
2545  if ((pixa = pixaCreate(n)) == NULL) {
2546  boxaDestroy(&boxa);
2547  return (PIXA *)ERROR_PTR("pixa not made", __func__, NULL);
2548  }
2549  boxaDestroy(&pixa->boxa);
2550  pixa->boxa = boxa;
2551 
2552  for (i = 0; i < n; i++) {
2553  if ((fscanf(fp, " pix[%d]: xres = %d, yres = %d\n",
2554  &ignore, &xres, &yres)) != 3) {
2555  pixaDestroy(&pixa);
2556  return (PIXA *)ERROR_PTR("res reading error", __func__, NULL);
2557  }
2558  if ((pix = pixReadStreamPng(fp)) == NULL) {
2559  pixaDestroy(&pixa);
2560  return (PIXA *)ERROR_PTR("pix not read", __func__, NULL);
2561  }
2562  pixSetXRes(pix, xres);
2563  pixSetYRes(pix, yres);
2564  pixaAddPix(pixa, pix, L_INSERT);
2565  }
2566  return pixa;
2567 }
2568 
2569 
2577 PIXA *
2578 pixaReadMem(const l_uint8 *data,
2579  size_t size)
2580 {
2581 FILE *fp;
2582 PIXA *pixa;
2583 
2584  if (!data)
2585  return (PIXA *)ERROR_PTR("data not defined", __func__, NULL);
2586  if ((fp = fopenReadFromMemory(data, size)) == NULL)
2587  return (PIXA *)ERROR_PTR("stream not opened", __func__, NULL);
2588 
2589  pixa = pixaReadStream(fp);
2590  fclose(fp);
2591  if (!pixa) L_ERROR("pixa not read\n", __func__);
2592  return pixa;
2593 }
2594 
2595 
2612 l_ok
2613 pixaWriteDebug(const char *fname,
2614  PIXA *pixa)
2615 {
2616  if (LeptDebugOK) {
2617  return pixaWrite(fname, pixa);
2618  } else {
2619  L_INFO("write to named temp file %s is disabled\n", __func__, fname);
2620  return 0;
2621  }
2622 }
2623 
2624 
2638 l_ok
2639 pixaWrite(const char *filename,
2640  PIXA *pixa)
2641 {
2642 l_int32 ret;
2643 FILE *fp;
2644 
2645 #if !HAVE_LIBPNG /* defined in environ.h and config_auto.h */
2646  return ERROR_INT("no libpng: can't write data", __func__, 1);
2647 #endif /* !HAVE_LIBPNG */
2648 
2649  if (!filename)
2650  return ERROR_INT("filename not defined", __func__, 1);
2651  if (!pixa)
2652  return ERROR_INT("pixa not defined", __func__, 1);
2653 
2654  if ((fp = fopenWriteStream(filename, "wb")) == NULL)
2655  return ERROR_INT("stream not opened", __func__, 1);
2656  ret = pixaWriteStream(fp, pixa);
2657  fclose(fp);
2658  if (ret)
2659  return ERROR_INT("pixa not written to stream", __func__, 1);
2660  return 0;
2661 }
2662 
2663 
2677 l_ok
2679  PIXA *pixa)
2680 {
2681 l_int32 n, i;
2682 PIX *pix;
2683 
2684 #if !HAVE_LIBPNG /* defined in environ.h and config_auto.h */
2685  return ERROR_INT("no libpng: can't write data", __func__, 1);
2686 #endif /* !HAVE_LIBPNG */
2687 
2688  if (!fp)
2689  return ERROR_INT("stream not defined", __func__, 1);
2690  if (!pixa)
2691  return ERROR_INT("pixa not defined", __func__, 1);
2692 
2693  n = pixaGetCount(pixa);
2694  fprintf(fp, "\nPixa Version %d\n", PIXA_VERSION_NUMBER);
2695  fprintf(fp, "Number of pix = %d\n", n);
2696  boxaWriteStream(fp, pixa->boxa);
2697  for (i = 0; i < n; i++) {
2698  if ((pix = pixaGetPix(pixa, i, L_CLONE)) == NULL)
2699  return ERROR_INT("pix not found", __func__, 1);
2700  fprintf(fp, " pix[%d]: xres = %d, yres = %d\n",
2701  i, pix->xres, pix->yres);
2702  pixWriteStreamPng(fp, pix, 0.0);
2703  pixDestroy(&pix);
2704  }
2705  return 0;
2706 }
2707 
2708 
2722 l_ok
2723 pixaWriteMem(l_uint8 **pdata,
2724  size_t *psize,
2725  PIXA *pixa)
2726 {
2727 l_int32 ret;
2728 FILE *fp;
2729 
2730  if (pdata) *pdata = NULL;
2731  if (psize) *psize = 0;
2732  if (!pdata)
2733  return ERROR_INT("&data not defined", __func__, 1);
2734  if (!psize)
2735  return ERROR_INT("&size not defined", __func__, 1);
2736  if (!pixa)
2737  return ERROR_INT("pixa not defined", __func__, 1);
2738 
2739 #if HAVE_FMEMOPEN
2740  if ((fp = open_memstream((char **)pdata, psize)) == NULL)
2741  return ERROR_INT("stream not opened", __func__, 1);
2742  ret = pixaWriteStream(fp, pixa);
2743  fputc('\0', fp);
2744  fclose(fp);
2745  *psize = *psize - 1;
2746 #else
2747  L_INFO("work-around: writing to a temp file\n", __func__);
2748  #ifdef _WIN32
2749  if ((fp = fopenWriteWinTempfile()) == NULL)
2750  return ERROR_INT("tmpfile stream not opened", __func__, 1);
2751  #else
2752  if ((fp = tmpfile()) == NULL)
2753  return ERROR_INT("tmpfile stream not opened", __func__, 1);
2754  #endif /* _WIN32 */
2755  ret = pixaWriteStream(fp, pixa);
2756  rewind(fp);
2757  *pdata = l_binaryReadStream(fp, psize);
2758  fclose(fp);
2759 #endif /* HAVE_FMEMOPEN */
2760  return ret;
2761 }
2762 
2763 
2776 PIXA *
2777 pixaReadBoth(const char *filename)
2778 {
2779 char buf[32];
2780 char *sname;
2781 PIXA *pixa;
2782 PIXAC *pac;
2783 
2784  if (!filename)
2785  return (PIXA *)ERROR_PTR("filename not defined", __func__, NULL);
2786 
2787  l_getStructStrFromFile(filename, L_STR_NAME, &sname);
2788  if (!sname)
2789  return (PIXA *)ERROR_PTR("struct name not found", __func__, NULL);
2790  snprintf(buf, sizeof(buf), "%s", sname);
2791  LEPT_FREE(sname);
2792 
2793  if (strcmp(buf, "Pixacomp") == 0) {
2794  if ((pac = pixacompRead(filename)) == NULL)
2795  return (PIXA *)ERROR_PTR("pac not made", __func__, NULL);
2796  pixa = pixaCreateFromPixacomp(pac, L_COPY);
2797  pixacompDestroy(&pac);
2798  } else if (strcmp(buf, "Pixa") == 0) {
2799  if ((pixa = pixaRead(filename)) == NULL)
2800  return (PIXA *)ERROR_PTR("pixa not made", __func__, NULL);
2801  } else {
2802  return (PIXA *)ERROR_PTR("invalid file type", __func__, NULL);
2803  }
2804  return pixa;
2805 }
2806 
2807 
2808 /*---------------------------------------------------------------------*
2809  * Pixaa serialized I/O *
2810  *---------------------------------------------------------------------*/
2831 PIXAA *
2832 pixaaReadFromFiles(const char *dirname,
2833  const char *substr,
2834  l_int32 first,
2835  l_int32 nfiles)
2836 {
2837 char *fname;
2838 l_int32 i, n;
2839 PIXA *pixa;
2840 PIXAA *paa;
2841 SARRAY *sa;
2842 
2843  if (!dirname)
2844  return (PIXAA *)ERROR_PTR("dirname not defined", __func__, NULL);
2845 
2846  sa = getSortedPathnamesInDirectory(dirname, substr, first, nfiles);
2847  if (!sa || ((n = sarrayGetCount(sa)) == 0)) {
2848  sarrayDestroy(&sa);
2849  return (PIXAA *)ERROR_PTR("no pixa files found", __func__, NULL);
2850  }
2851 
2852  paa = pixaaCreate(n);
2853  for (i = 0; i < n; i++) {
2854  fname = sarrayGetString(sa, i, L_NOCOPY);
2855  if ((pixa = pixaRead(fname)) == NULL) {
2856  L_ERROR("pixa not read for %d-th file", __func__, i);
2857  continue;
2858  }
2859  pixaaAddPixa(paa, pixa, L_INSERT);
2860  }
2861 
2862  sarrayDestroy(&sa);
2863  return paa;
2864 }
2865 
2866 
2879 PIXAA *
2880 pixaaRead(const char *filename)
2881 {
2882 FILE *fp;
2883 PIXAA *paa;
2884 
2885 #if !HAVE_LIBPNG /* defined in environ.h and config_auto.h */
2886  return (PIXAA *)ERROR_PTR("no libpng: can't read data", __func__, NULL);
2887 #endif /* !HAVE_LIBPNG */
2888 
2889  if (!filename)
2890  return (PIXAA *)ERROR_PTR("filename not defined", __func__, NULL);
2891 
2892  if ((fp = fopenReadStream(filename)) == NULL)
2893  return (PIXAA *)ERROR_PTR("stream not opened", __func__, NULL);
2894  paa = pixaaReadStream(fp);
2895  fclose(fp);
2896  if (!paa)
2897  return (PIXAA *)ERROR_PTR("paa not read", __func__, NULL);
2898  return paa;
2899 }
2900 
2901 
2915 PIXAA *
2917 {
2918 l_int32 n, i, version;
2919 l_int32 ignore;
2920 BOXA *boxa;
2921 PIXA *pixa;
2922 PIXAA *paa;
2923 
2924 #if !HAVE_LIBPNG /* defined in environ.h and config_auto.h */
2925  return (PIXAA *)ERROR_PTR("no libpng: can't read data", __func__, NULL);
2926 #endif /* !HAVE_LIBPNG */
2927 
2928  if (!fp)
2929  return (PIXAA *)ERROR_PTR("stream not defined", __func__, NULL);
2930 
2931  if (fscanf(fp, "\nPixaa Version %d\n", &version) != 1)
2932  return (PIXAA *)ERROR_PTR("not a pixaa file", __func__, NULL);
2933  if (version != PIXAA_VERSION_NUMBER)
2934  return (PIXAA *)ERROR_PTR("invalid pixaa version", __func__, NULL);
2935  if (fscanf(fp, "Number of pixa = %d\n", &n) != 1)
2936  return (PIXAA *)ERROR_PTR("not a pixaa file", __func__, NULL);
2937  if (n < 0)
2938  return (PIXAA *)ERROR_PTR("num pixa ptrs < 0", __func__, NULL);
2939  if (n > MaxPixaaPtrArraySize)
2940  return (PIXAA *)ERROR_PTR("too many pixa ptrs", __func__, NULL);
2941  if (n == 0) L_INFO("the pixaa is empty\n", __func__);
2942 
2943  if ((paa = pixaaCreate(n)) == NULL)
2944  return (PIXAA *)ERROR_PTR("paa not made", __func__, NULL);
2945  if ((boxa = boxaReadStream(fp)) == NULL) {
2946  pixaaDestroy(&paa);
2947  return (PIXAA *)ERROR_PTR("boxa not made", __func__, NULL);
2948  }
2949  boxaDestroy(&paa->boxa);
2950  paa->boxa = boxa;
2951 
2952  for (i = 0; i < n; i++) {
2953  if ((fscanf(fp, "\n\n --------------- pixa[%d] ---------------\n",
2954  &ignore)) != 1) {
2955  pixaaDestroy(&paa);
2956  return (PIXAA *)ERROR_PTR("text reading", __func__, NULL);
2957  }
2958  if ((pixa = pixaReadStream(fp)) == NULL) {
2959  pixaaDestroy(&paa);
2960  return (PIXAA *)ERROR_PTR("pixa not read", __func__, NULL);
2961  }
2962  pixaaAddPixa(paa, pixa, L_INSERT);
2963  }
2964 
2965  return paa;
2966 }
2967 
2968 
2976 PIXAA *
2977 pixaaReadMem(const l_uint8 *data,
2978  size_t size)
2979 {
2980 FILE *fp;
2981 PIXAA *paa;
2982 
2983  if (!data)
2984  return (PIXAA *)ERROR_PTR("data not defined", __func__, NULL);
2985  if ((fp = fopenReadFromMemory(data, size)) == NULL)
2986  return (PIXAA *)ERROR_PTR("stream not opened", __func__, NULL);
2987 
2988  paa = pixaaReadStream(fp);
2989  fclose(fp);
2990  if (!paa) L_ERROR("paa not read\n", __func__);
2991  return paa;
2992 }
2993 
2994 
3008 l_ok
3009 pixaaWrite(const char *filename,
3010  PIXAA *paa)
3011 {
3012 l_int32 ret;
3013 FILE *fp;
3014 
3015 #if !HAVE_LIBPNG /* defined in environ.h and config_auto.h */
3016  return ERROR_INT("no libpng: can't read data", __func__, 1);
3017 #endif /* !HAVE_LIBPNG */
3018 
3019  if (!filename)
3020  return ERROR_INT("filename not defined", __func__, 1);
3021  if (!paa)
3022  return ERROR_INT("paa not defined", __func__, 1);
3023 
3024  if ((fp = fopenWriteStream(filename, "wb")) == NULL)
3025  return ERROR_INT("stream not opened", __func__, 1);
3026  ret = pixaaWriteStream(fp, paa);
3027  fclose(fp);
3028  if (ret)
3029  return ERROR_INT("paa not written to stream", __func__, 1);
3030  return 0;
3031 }
3032 
3033 
3047 l_ok
3049  PIXAA *paa)
3050 {
3051 l_int32 n, i;
3052 PIXA *pixa;
3053 
3054 #if !HAVE_LIBPNG /* defined in environ.h and config_auto.h */
3055  return ERROR_INT("no libpng: can't read data", __func__, 1);
3056 #endif /* !HAVE_LIBPNG */
3057 
3058  if (!fp)
3059  return ERROR_INT("stream not defined", __func__, 1);
3060  if (!paa)
3061  return ERROR_INT("paa not defined", __func__, 1);
3062 
3063  n = pixaaGetCount(paa, NULL);
3064  fprintf(fp, "\nPixaa Version %d\n", PIXAA_VERSION_NUMBER);
3065  fprintf(fp, "Number of pixa = %d\n", n);
3066  boxaWriteStream(fp, paa->boxa);
3067  for (i = 0; i < n; i++) {
3068  if ((pixa = pixaaGetPixa(paa, i, L_CLONE)) == NULL)
3069  return ERROR_INT("pixa not found", __func__, 1);
3070  fprintf(fp, "\n\n --------------- pixa[%d] ---------------\n", i);
3071  pixaWriteStream(fp, pixa);
3072  pixaDestroy(&pixa);
3073  }
3074  return 0;
3075 }
3076 
3077 
3091 l_ok
3092 pixaaWriteMem(l_uint8 **pdata,
3093  size_t *psize,
3094  PIXAA *paa)
3095 {
3096 l_int32 ret;
3097 FILE *fp;
3098 
3099  if (pdata) *pdata = NULL;
3100  if (psize) *psize = 0;
3101  if (!pdata)
3102  return ERROR_INT("&data not defined", __func__, 1);
3103  if (!psize)
3104  return ERROR_INT("&size not defined", __func__, 1);
3105  if (!paa)
3106  return ERROR_INT("paa not defined", __func__, 1);
3107 
3108 #if HAVE_FMEMOPEN
3109  if ((fp = open_memstream((char **)pdata, psize)) == NULL)
3110  return ERROR_INT("stream not opened", __func__, 1);
3111  ret = pixaaWriteStream(fp, paa);
3112  fputc('\0', fp);
3113  fclose(fp);
3114  *psize = *psize - 1;
3115 #else
3116  L_INFO("work-around: writing to a temp file\n", __func__);
3117  #ifdef _WIN32
3118  if ((fp = fopenWriteWinTempfile()) == NULL)
3119  return ERROR_INT("tmpfile stream not opened", __func__, 1);
3120  #else
3121  if ((fp = tmpfile()) == NULL)
3122  return ERROR_INT("tmpfile stream not opened", __func__, 1);
3123  #endif /* _WIN32 */
3124  ret = pixaaWriteStream(fp, paa);
3125  rewind(fp);
3126  *pdata = l_binaryReadStream(fp, psize);
3127  fclose(fp);
3128 #endif /* HAVE_FMEMOPEN */
3129  return ret;
3130 }
3131 
l_ok boxGetGeometry(const BOX *box, l_int32 *px, l_int32 *py, l_int32 *pw, l_int32 *ph)
boxGetGeometry()
Definition: boxbasic.c:301
l_ok boxaClear(BOXA *boxa)
boxaClear()
Definition: boxbasic.c:1120
BOXA * boxaReadStream(FILE *fp)
boxaReadStream()
Definition: boxbasic.c:2014
l_ok boxaInitFull(BOXA *boxa, BOX *box)
boxaInitFull()
Definition: boxbasic.c:1085
l_ok boxaIsFull(BOXA *boxa, l_int32 *pfull)
boxaIsFull()
Definition: boxbasic.c:830
BOXA * boxaCopy(BOXA *boxa, l_int32 copyflag)
boxaCopy()
Definition: boxbasic.c:475
l_ok boxaInsertBox(BOXA *boxa, l_int32 index, BOX *box)
boxaInsertBox()
Definition: boxbasic.c:911
void boxDestroy(BOX **pbox)
boxDestroy()
Definition: boxbasic.c:273
l_ok boxaRemoveBoxAndSave(BOXA *boxa, l_int32 index, BOX **pbox)
boxaRemoveBoxAndSave()
Definition: boxbasic.c:981
l_ok boxaRemoveBox(BOXA *boxa, l_int32 index)
boxaRemoveBox()
Definition: boxbasic.c:957
BOX * boxClone(BOX *box)
boxClone()
Definition: boxbasic.c:249
l_ok boxaReplaceBox(BOXA *boxa, l_int32 index, BOX *box)
boxaReplaceBox()
Definition: boxbasic.c:875
l_ok boxaExtendArrayToSize(BOXA *boxa, size_t size)
boxaExtendArrayToSize()
Definition: boxbasic.c:625
l_ok boxaAddBox(BOXA *boxa, BOX *box, l_int32 copyflag)
boxaAddBox()
Definition: boxbasic.c:553
l_ok boxaExtendArray(BOXA *boxa)
boxaExtendArray()
Definition: boxbasic.c:602
void boxaDestroy(BOXA **pboxa)
boxaDestroy()
Definition: boxbasic.c:519
l_int32 boxaGetCount(const BOXA *boxa)
boxaGetCount()
Definition: boxbasic.c:661
BOX * boxaGetBox(BOXA *boxa, l_int32 index, l_int32 accessflag)
boxaGetBox()
Definition: boxbasic.c:702
BOX * boxCopy(BOX *box)
boxCopy()
Definition: boxbasic.c:230
BOXA * boxaCreate(l_int32 n)
boxaCreate()
Definition: boxbasic.c:442
l_ok boxaWriteStream(FILE *fp, BOXA *boxa)
boxaWriteStream()
Definition: boxbasic.c:2144
l_ok boxaJoin(BOXA *boxad, BOXA *boxas, l_int32 istart, l_int32 iend)
boxaJoin()
Definition: boxfunc1.c:2460
l_ok boxaGetExtent(BOXA *boxa, l_int32 *pw, l_int32 *ph, BOX **pbox)
boxaGetExtent()
Definition: boxfunc4.c:922
l_int32 pixcmapGetCount(const PIXCMAP *cmap)
pixcmapGetCount()
Definition: colormap.c:683
l_ok numaAddNumber(NUMA *na, l_float32 val)
numaAddNumber()
Definition: numabasic.c:460
NUMA * numaCreate(l_int32 n)
numaCreate()
Definition: numabasic.c:193
void numaDestroy(NUMA **pna)
numaDestroy()
Definition: numabasic.c:357
l_int32 numaGetCount(NUMA *na)
numaGetCount()
Definition: numabasic.c:630
l_ok numaGetIValue(NUMA *na, l_int32 index, l_int32 *pival)
numaGetIValue()
Definition: numabasic.c:720
NUMA * numaSort(NUMA *naout, NUMA *nain, l_int32 sortorder)
numaSort()
Definition: numafunc1.c:2567
void pixDestroy(PIX **ppix)
pixDestroy()
Definition: pix1.c:608
l_ok pixGetDimensions(const PIX *pix, l_int32 *pw, l_int32 *ph, l_int32 *pd)
pixGetDimensions()
Definition: pix1.c:1074
char * pixGetText(PIX *pix)
pixGetText()
Definition: pix1.c:1408
l_ok pixSetText(PIX *pix, const char *textstring)
pixSetText()
Definition: pix1.c:1430
PIX * pixCopy(PIX *pixd, const PIX *pixs)
pixCopy()
Definition: pix1.c:689
l_ok pixCopyColormap(PIX *pixd, const PIX *pixs)
pixCopyColormap()
Definition: pix1.c:795
PIX * pixCreate(l_int32 width, l_int32 height, l_int32 depth)
pixCreate()
Definition: pix1.c:315
PIX * pixClone(PIX *pixs)
pixClone()
Definition: pix1.c:582
void ** pixGetLinePtrs(PIX *pix, l_int32 *psize)
pixGetLinePtrs()
Definition: pix1.c:1844
l_ok pixClearAll(PIX *pix)
pixClearAll()
Definition: pix2.c:773
l_ok pixSetAll(PIX *pix)
pixSetAll()
Definition: pix2.c:799
l_ok pixSetAllArbitrary(PIX *pix, l_uint32 val)
pixSetAllArbitrary()
Definition: pix2.c:929
PIX * pixClipRectangle(PIX *pixs, BOX *box, BOX **pboxc)
pixClipRectangle()
Definition: pix5.c:994
l_ok pixClipToForeground(PIX *pixs, PIX **ppixd, BOX **pbox)
pixClipToForeground()
Definition: pix5.c:1728
@ L_COPY
Definition: pix.h:505
@ L_CLONE
Definition: pix.h:506
@ L_COPY_CLONE
Definition: pix.h:507
@ L_NOCOPY
Definition: pix.h:503
@ L_INSERT
Definition: pix.h:504
@ L_CHOOSE_CONSECUTIVE
Definition: pix.h:775
@ L_CHOOSE_SKIP_BY
Definition: pix.h:776
#define PIX_SRC
Definition: pix.h:444
@ L_SORT_DECREASING
Definition: pix.h:523
#define PIXA_VERSION_NUMBER
Definition: pix_internal.h:227
#define PIXAA_VERSION_NUMBER
Definition: pix_internal.h:226
PIXAA * pixaaCreate(l_int32 n)
pixaaCreate()
Definition: pixabasic.c:1758
l_ok pixaAddPix(PIXA *pixa, PIX *pix, l_int32 copyflag)
pixaAddPix()
Definition: pixabasic.c:493
l_ok pixaaReplacePixa(PIXAA *paa, l_int32 index, PIXA *pixa)
pixaaReplacePixa()
Definition: pixabasic.c:2375
void pixaDestroy(PIXA **ppixa)
pixaDestroy()
Definition: pixabasic.c:404
static l_int32 pixaExtendArray(PIXA *pixa)
pixaExtendArray()
Definition: pixabasic.c:569
l_ok pixaaWriteMem(l_uint8 **pdata, size_t *psize, PIXAA *paa)
pixaaWriteMem()
Definition: pixabasic.c:3092
l_ok pixaVerifyDepth(PIXA *pixa, l_int32 *psame, l_int32 *pmaxd)
pixaVerifyDepth()
Definition: pixabasic.c:900
l_ok pixaaInitFull(PIXAA *paa, PIXA *pixa)
pixaaInitFull()
Definition: pixabasic.c:2335
l_ok pixaCountText(PIXA *pixa, l_int32 *pntext)
pixaCountText()
Definition: pixabasic.c:1041
l_int32 pixaaIsFull(PIXAA *paa, l_int32 *pfull)
pixaaIsFull()
Definition: pixabasic.c:2285
l_ok pixaExtendArrayToSize(PIXA *pixa, size_t size)
pixaExtendArrayToSize()
Definition: pixabasic.c:593
PIXAA * pixaaReadStream(FILE *fp)
pixaaReadStream()
Definition: pixabasic.c:2916
l_ok pixaRemovePix(PIXA *pixa, l_int32 index)
pixaRemovePix()
Definition: pixabasic.c:1345
l_ok pixaaAddBox(PIXAA *paa, BOX *box, l_int32 copyflag)
pixaaAddBox()
Definition: pixabasic.c:2016
l_ok pixaWriteStream(FILE *fp, PIXA *pixa)
pixaWriteStream()
Definition: pixabasic.c:2678
PIXA * pixaReadBoth(const char *filename)
pixaReadBoth()
Definition: pixabasic.c:2777
l_ok pixaaTruncate(PIXAA *paa)
pixaaTruncate()
Definition: pixabasic.c:2435
l_ok pixaaAddPix(PIXAA *paa, l_int32 index, PIX *pix, BOX *box, l_int32 copyflag)
pixaaAddPix()
Definition: pixabasic.c:1979
BOX * pixaGetBox(PIXA *pixa, l_int32 index, l_int32 accesstype)
pixaGetBox()
Definition: pixabasic.c:764
static l_int32 pixaaExtendArray(PIXAA *paa)
pixaaExtendArray()
Definition: pixabasic.c:1946
l_int32 pixaGetBoxaCount(PIXA *pixa)
pixaGetBoxaCount()
Definition: pixabasic.c:734
PIXA * pixaInterleave(PIXA *pixa1, PIXA *pixa2, l_int32 copyflag)
pixaInterleave()
Definition: pixabasic.c:1639
l_ok pixaSetText(PIXA *pixa, const char *text, SARRAY *sa)
pixaSetText()
Definition: pixabasic.c:1087
l_ok pixaaAddPixa(PIXAA *paa, PIXA *pixa, l_int32 copyflag)
pixaaAddPixa()
Definition: pixabasic.c:1898
void *** pixaGetLinePtrs(PIXA *pixa, l_int32 *psize)
pixaGetLinePtrs()
Definition: pixabasic.c:1144
PIXA * pixaCreate(l_int32 n)
pixaCreate()
Definition: pixabasic.c:167
l_ok pixaRemovePixAndSave(PIXA *pixa, l_int32 index, PIX **ppix, BOX **pbox)
pixaRemovePixAndSave()
Definition: pixabasic.c:1397
PIXA * pixaSplitPix(PIX *pixs, l_int32 nx, l_int32 ny, l_int32 borderwidth, l_uint32 bordercolor)
pixaSplitPix()
Definition: pixabasic.c:344
l_ok pixaGetPixDimensions(PIXA *pixa, l_int32 index, l_int32 *pw, l_int32 *ph, l_int32 *pd)
pixaGetPixDimensions()
Definition: pixabasic.c:680
PIX ** pixaGetPixArray(PIXA *pixa)
pixaGetPixArray()
Definition: pixabasic.c:877
PIXA * pixaRead(const char *filename)
pixaRead()
Definition: pixabasic.c:2480
l_ok pixaaJoin(PIXAA *paad, PIXAA *paas, l_int32 istart, l_int32 iend)
pixaaJoin()
Definition: pixabasic.c:1702
l_ok pixaRemoveSelected(PIXA *pixa, NUMA *naindex)
pixaRemoveSelected()
Definition: pixabasic.c:1449
PIXA * pixaCopy(PIXA *pixa, l_int32 copyflag)
pixaCopy()
Definition: pixabasic.c:442
l_ok pixaReplacePix(PIXA *pixa, l_int32 index, PIX *pix, BOX *box)
pixaReplacePix()
Definition: pixabasic.c:1246
l_int32 pixaGetCount(PIXA *pixa)
pixaGetCount()
Definition: pixabasic.c:629
l_ok pixaWrite(const char *filename, PIXA *pixa)
pixaWrite()
Definition: pixabasic.c:2639
l_ok pixaaVerifyDimensions(PIXAA *paa, l_int32 *psame, l_int32 *pmaxw, l_int32 *pmaxh)
pixaaVerifyDimensions()
Definition: pixabasic.c:2233
l_ok pixaAddBox(PIXA *pixa, BOX *box, l_int32 copyflag)
pixaAddBox()
Definition: pixabasic.c:540
l_ok pixaWriteMem(l_uint8 **pdata, size_t *psize, PIXA *pixa)
pixaWriteMem()
Definition: pixabasic.c:2723
static const size_t InitialPtrArraySize
Definition: pixabasic.c:146
PIXA * pixaReadMem(const l_uint8 *data, size_t size)
pixaReadMem()
Definition: pixabasic.c:2578
l_ok pixaWriteStreamInfo(FILE *fp, PIXA *pixa)
pixaWriteStreamInfo()
Definition: pixabasic.c:1190
l_ok pixaIsFull(PIXA *pixa, l_int32 *pfullpa, l_int32 *pfullba)
pixaIsFull()
Definition: pixabasic.c:993
PIXAA * pixaaReadFromFiles(const char *dirname, const char *substr, l_int32 first, l_int32 nfiles)
pixaaReadFromFiles()
Definition: pixabasic.c:2832
PIXAA * pixaaCreateFromPixa(PIXA *pixa, l_int32 n, l_int32 type, l_int32 copyflag)
pixaaCreateFromPixa()
Definition: pixabasic.c:1799
PIXAA * pixaaReadMem(const l_uint8 *data, size_t size)
pixaaReadMem()
Definition: pixabasic.c:2977
l_ok pixaInitFull(PIXA *pixa, PIX *pix, BOX *box)
pixaInitFull()
Definition: pixabasic.c:1509
PIXA * pixaReadStream(FILE *fp)
pixaReadStream()
Definition: pixabasic.c:2516
l_ok pixaVerifyDimensions(PIXA *pixa, l_int32 *psame, l_int32 *pmaxw, l_int32 *pmaxh)
pixaVerifyDimensions()
Definition: pixabasic.c:944
l_ok pixaaWriteStream(FILE *fp, PIXAA *paa)
pixaaWriteStream()
Definition: pixabasic.c:3048
BOXA * pixaGetBoxa(PIXA *pixa, l_int32 accesstype)
pixaGetBoxa()
Definition: pixabasic.c:712
BOXA * pixaaGetBoxa(PIXAA *paa, l_int32 accesstype)
pixaaGetBoxa()
Definition: pixabasic.c:2132
l_ok pixaGetBoxGeometry(PIXA *pixa, l_int32 index, l_int32 *px, l_int32 *py, l_int32 *pw, l_int32 *ph)
pixaGetBoxGeometry()
Definition: pixabasic.c:800
l_ok pixaWriteDebug(const char *fname, PIXA *pixa)
pixaWriteDebug()
Definition: pixabasic.c:2613
PIXA * pixaCreateFromBoxa(PIX *pixs, BOXA *boxa, l_int32 start, l_int32 num, l_int32 *pcropwarn)
pixaCreateFromBoxa()
Definition: pixabasic.c:268
void pixaaDestroy(PIXAA **ppaa)
pixaaDestroy()
Definition: pixabasic.c:1859
l_ok pixaaClear(PIXAA *paa)
pixaaClear()
Definition: pixabasic.c:2406
l_ok pixaaVerifyDepth(PIXAA *paa, l_int32 *psame, l_int32 *pmaxd)
pixaaVerifyDepth()
Definition: pixabasic.c:2185
l_int32 pixaaGetCount(PIXAA *paa, NUMA **pna)
pixaaGetCount()
Definition: pixabasic.c:2049
l_ok pixaJoin(PIXA *pixad, PIXA *pixas, l_int32 istart, l_int32 iend)
pixaJoin()
Definition: pixabasic.c:1585
PIX * pixaaGetPix(PIXAA *paa, l_int32 index, l_int32 ipix, l_int32 accessflag)
pixaaGetPix()
Definition: pixabasic.c:2154
PIXA * pixaaGetPixa(PIXAA *paa, l_int32 index, l_int32 accesstype)
pixaaGetPixa()
Definition: pixabasic.c:2096
PIX * pixaGetPix(PIXA *pixa, l_int32 index, l_int32 accesstype)
pixaGetPix()
Definition: pixabasic.c:647
l_ok pixaInsertPix(PIXA *pixa, l_int32 index, PIX *pixs, BOX *box)
pixaInsertPix()
Definition: pixabasic.c:1294
PIXAA * pixaaRead(const char *filename)
pixaaRead()
Definition: pixabasic.c:2880
l_ok pixaSetBoxa(PIXA *pixa, BOXA *boxa, l_int32 accesstype)
pixaSetBoxa()
Definition: pixabasic.c:840
l_ok pixaClear(PIXA *pixa)
pixaClear()
Definition: pixabasic.c:1549
l_ok pixaaWrite(const char *filename, PIXAA *paa)
pixaaWrite()
Definition: pixabasic.c:3009
PIXA * pixaCreateFromPix(PIX *pixs, l_int32 n, l_int32 cellw, l_int32 cellh)
pixaCreateFromPix()
Definition: pixabasic.c:204
void pixacompDestroy(PIXAC **ppixac)
pixacompDestroy()
Definition: pixcomp.c:851
PIXA * pixaCreateFromPixacomp(PIXAC *pixac, l_int32 accesstype)
pixaCreateFromPixacomp()
Definition: pixcomp.c:1434
PIXAC * pixacompRead(const char *filename)
pixacompRead()
Definition: pixcomp.c:1601
l_ok pixWriteStreamPng(FILE *fp, PIX *pix, l_float32 gamma)
pixWriteStreamPng()
Definition: pngio.c:1057
PIX * pixReadStreamPng(FILE *fp)
pixReadStreamPng()
Definition: pngio.c:188
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()
Definition: rop.c:204
char * sarrayGetString(SARRAY *sa, l_int32 index, l_int32 copyflag)
sarrayGetString()
Definition: sarray1.c:673
l_int32 sarrayGetCount(SARRAY *sa)
sarrayGetCount()
Definition: sarray1.c:617
void sarrayDestroy(SARRAY **psa)
sarrayDestroy()
Definition: sarray1.c:353
SARRAY * getSortedPathnamesInDirectory(const char *dirname, const char *substr, l_int32 first, l_int32 nfiles)
getSortedPathnamesInDirectory()
Definition: sarray1.c:1739
l_int32 l_getStructStrFromFile(const char *filename, l_int32 field, char **pstr)
l_getStructStrFromFile()
Definition: stringcode.c:518
@ L_STR_NAME
Definition: stringcode.h:56
l_int32 n
Definition: pix_internal.h:267
struct Box ** box
Definition: pix_internal.h:270
l_int32 xres
Definition: pix_internal.h:188
l_int32 yres
Definition: pix_internal.h:190
struct Pix ** pix
Definition: pix_internal.h:237
l_atomic refcount
Definition: pix_internal.h:236
struct Boxa * boxa
Definition: pix_internal.h:238
l_int32 nalloc
Definition: pix_internal.h:235
l_int32 n
Definition: pix_internal.h:234
l_int32 nalloc
Definition: pix_internal.h:245
l_int32 n
Definition: pix_internal.h:244
struct Pixa ** pixa
Definition: pix_internal.h:246
struct Boxa * boxa
Definition: pix_internal.h:247
l_uint8 * l_binaryReadStream(FILE *fp, size_t *pnbytes)
l_binaryReadStream()
Definition: utils2.c:1358
FILE * fopenReadFromMemory(const l_uint8 *data, size_t size)
fopenReadFromMemory()
Definition: utils2.c:1937
FILE * fopenWriteStream(const char *filename, const char *modestring)
fopenWriteStream()
Definition: utils2.c:1905
void * reallocNew(void **pindata, size_t oldsize, size_t newsize)
reallocNew()
Definition: utils2.c:1262
FILE * fopenWriteWinTempfile(void)
fopenWriteWinTempfile()
Definition: utils2.c:1981
FILE * fopenReadStream(const char *filename)
fopenReadStream()
Definition: utils2.c:1864