Leptonica  1.82.0
Image processing and image analysis suite
numabasic.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 
167 #ifdef HAVE_CONFIG_H
168 #include <config_auto.h>
169 #endif /* HAVE_CONFIG_H */
170 
171 #include <string.h>
172 #include <math.h>
173 #include "allheaders.h"
174 
175  /* Bounds on initial array size */
176 static const l_uint32 MaxFloatArraySize = 100000000; /* for numa */
177 static const l_uint32 MaxPtrArraySize = 1000000; /* for numaa */
178 static const l_int32 InitialArraySize = 50;
180  /* Static functions */
181 static l_int32 numaExtendArray(NUMA *na);
182 static l_int32 numaaExtendArray(NUMAA *naa);
183 
184 /*--------------------------------------------------------------------------*
185  * Numa creation, destruction, copy, clone, etc. *
186  *--------------------------------------------------------------------------*/
193 NUMA *
194 numaCreate(l_int32 n)
195 {
196 NUMA *na;
197 
198  PROCNAME("numaCreate");
199 
200  if (n <= 0 || n > MaxFloatArraySize)
201  n = InitialArraySize;
202 
203  na = (NUMA *)LEPT_CALLOC(1, sizeof(NUMA));
204  if ((na->array = (l_float32 *)LEPT_CALLOC(n, sizeof(l_float32))) == NULL) {
205  numaDestroy(&na);
206  return (NUMA *)ERROR_PTR("number array not made", procName, NULL);
207  }
208 
209  na->nalloc = n;
210  na->n = 0;
211  na->refcount = 1;
212  na->startx = 0.0;
213  na->delx = 1.0;
214  return na;
215 }
216 
217 
233 NUMA *
234 numaCreateFromIArray(l_int32 *iarray,
235  l_int32 size)
236 {
237 l_int32 i;
238 NUMA *na;
239 
240  PROCNAME("numaCreateFromIArray");
241 
242  if (!iarray)
243  return (NUMA *)ERROR_PTR("iarray not defined", procName, NULL);
244  if (size <= 0)
245  return (NUMA *)ERROR_PTR("size must be > 0", procName, NULL);
246 
247  na = numaCreate(size);
248  for (i = 0; i < size; i++)
249  numaAddNumber(na, iarray[i]);
250 
251  return na;
252 }
253 
254 
270 NUMA *
271 numaCreateFromFArray(l_float32 *farray,
272  l_int32 size,
273  l_int32 copyflag)
274 {
275 l_int32 i;
276 NUMA *na;
277 
278  PROCNAME("numaCreateFromFArray");
279 
280  if (!farray)
281  return (NUMA *)ERROR_PTR("farray not defined", procName, NULL);
282  if (size <= 0)
283  return (NUMA *)ERROR_PTR("size must be > 0", procName, NULL);
284  if (copyflag != L_INSERT && copyflag != L_COPY)
285  return (NUMA *)ERROR_PTR("invalid copyflag", procName, NULL);
286 
287  na = numaCreate(size);
288  if (copyflag == L_INSERT) {
289  if (na->array) LEPT_FREE(na->array);
290  na->array = farray;
291  na->n = size;
292  } else { /* just copy the contents */
293  for (i = 0; i < size; i++)
294  numaAddNumber(na, farray[i]);
295  }
296 
297  return na;
298 }
299 
300 
314 NUMA *
315 numaCreateFromString(const char *str)
316 {
317 char *substr;
318 l_int32 i, n, nerrors;
319 l_float32 val;
320 NUMA *na;
321 SARRAY *sa;
322 
323  PROCNAME("numaCreateFromString");
324 
325  if (!str || (strlen(str) == 0))
326  return (NUMA *)ERROR_PTR("str not defined or empty", procName, NULL);
327 
328  sa = sarrayCreate(0);
329  sarraySplitString(sa, str, ",");
330  n = sarrayGetCount(sa);
331  na = numaCreate(n);
332  nerrors = 0;
333  for (i = 0; i < n; i++) {
334  substr = sarrayGetString(sa, i, L_NOCOPY);
335  if (sscanf(substr, "%f", &val) != 1) {
336  L_ERROR("substr %d not float\n", procName, i);
337  nerrors++;
338  } else {
339  numaAddNumber(na, val);
340  }
341  }
342 
343  sarrayDestroy(&sa);
344  if (nerrors > 0) {
345  numaDestroy(&na);
346  return (NUMA *)ERROR_PTR("non-floats in string", procName, NULL);
347  }
348 
349  return na;
350 }
351 
352 
365 void
367 {
368 NUMA *na;
369 
370  PROCNAME("numaDestroy");
371 
372  if (pna == NULL) {
373  L_WARNING("ptr address is NULL\n", procName);
374  return;
375  }
376 
377  if ((na = *pna) == NULL)
378  return;
379 
380  /* Decrement the ref count. If it is 0, destroy the numa. */
381  numaChangeRefcount(na, -1);
382  if (numaGetRefcount(na) <= 0) {
383  if (na->array)
384  LEPT_FREE(na->array);
385  LEPT_FREE(na);
386  }
387 
388  *pna = NULL;
389 }
390 
391 
398 NUMA *
400 {
401 l_int32 i;
402 NUMA *cna;
403 
404  PROCNAME("numaCopy");
405 
406  if (!na)
407  return (NUMA *)ERROR_PTR("na not defined", procName, NULL);
408 
409  if ((cna = numaCreate(na->nalloc)) == NULL)
410  return (NUMA *)ERROR_PTR("cna not made", procName, NULL);
411  cna->startx = na->startx;
412  cna->delx = na->delx;
413 
414  for (i = 0; i < na->n; i++)
415  numaAddNumber(cna, na->array[i]);
416 
417  return cna;
418 }
419 
420 
427 NUMA *
429 {
430  PROCNAME("numaClone");
431 
432  if (!na)
433  return (NUMA *)ERROR_PTR("na not defined", procName, NULL);
434 
435  numaChangeRefcount(na, 1);
436  return na;
437 }
438 
439 
453 l_ok
455 {
456  PROCNAME("numaEmpty");
457 
458  if (!na)
459  return ERROR_INT("na not defined", procName, 1);
460 
461  na->n = 0;
462  return 0;
463 }
464 
465 
466 
467 /*--------------------------------------------------------------------------*
468  * Number array: add number and extend array *
469  *--------------------------------------------------------------------------*/
477 l_ok
479  l_float32 val)
480 {
481 l_int32 n;
482 
483  PROCNAME("numaAddNumber");
484 
485  if (!na)
486  return ERROR_INT("na not defined", procName, 1);
487 
488  n = numaGetCount(na);
489  if (n >= na->nalloc) {
490  if (numaExtendArray(na))
491  return ERROR_INT("extension failed", procName, 1);
492  }
493  na->array[n] = val;
494  na->n++;
495  return 0;
496 }
497 
498 
510 static l_int32
512 {
513 size_t oldsize, newsize;
514 
515  PROCNAME("numaExtendArray");
516 
517  if (!na)
518  return ERROR_INT("na not defined", procName, 1);
519  if (na->nalloc > MaxFloatArraySize) /* belt & suspenders */
520  return ERROR_INT("na has too many ptrs", procName, 1);
521  oldsize = na->nalloc * sizeof(l_float32);
522  newsize = 2 * oldsize;
523  if (newsize > 4 * MaxFloatArraySize)
524  return ERROR_INT("newsize > 400 MB; too large", procName, 1);
525 
526  if ((na->array = (l_float32 *)reallocNew((void **)&na->array,
527  oldsize, newsize)) == NULL)
528  return ERROR_INT("new ptr array not returned", procName, 1);
529 
530  na->nalloc *= 2;
531  return 0;
532 }
533 
534 
552 l_ok
554  l_int32 index,
555  l_float32 val)
556 {
557 l_int32 i, n;
558 
559  PROCNAME("numaInsertNumber");
560 
561  if (!na)
562  return ERROR_INT("na not defined", procName, 1);
563  n = numaGetCount(na);
564  if (index < 0 || index > n) {
565  L_ERROR("index %d not in [0,...,%d]\n", procName, index, n);
566  return 1;
567  }
568 
569  if (n >= na->nalloc) {
570  if (numaExtendArray(na))
571  return ERROR_INT("extension failed", procName, 1);
572  }
573  for (i = n; i > index; i--)
574  na->array[i] = na->array[i - 1];
575  na->array[index] = val;
576  na->n++;
577  return 0;
578 }
579 
580 
595 l_ok
597  l_int32 index)
598 {
599 l_int32 i, n;
600 
601  PROCNAME("numaRemoveNumber");
602 
603  if (!na)
604  return ERROR_INT("na not defined", procName, 1);
605  n = numaGetCount(na);
606  if (index < 0 || index >= n) {
607  L_ERROR("index %d not in [0,...,%d]\n", procName, index, n - 1);
608  return 1;
609  }
610 
611  for (i = index + 1; i < n; i++)
612  na->array[i - 1] = na->array[i];
613  na->n--;
614  return 0;
615 }
616 
617 
626 l_ok
628  l_int32 index,
629  l_float32 val)
630 {
631 l_int32 n;
632 
633  PROCNAME("numaReplaceNumber");
634 
635  if (!na)
636  return ERROR_INT("na not defined", procName, 1);
637  n = numaGetCount(na);
638  if (index < 0 || index >= n) {
639  L_ERROR("index %d not in [0,...,%d]\n", procName, index, n - 1);
640  return 1;
641  }
642 
643  na->array[index] = val;
644  return 0;
645 }
646 
647 
648 /*----------------------------------------------------------------------*
649  * Numa accessors *
650  *----------------------------------------------------------------------*/
657 l_int32
659 {
660  PROCNAME("numaGetCount");
661 
662  if (!na)
663  return ERROR_INT("na not defined", procName, 0);
664  return na->n;
665 }
666 
667 
684 l_ok
686  l_int32 newcount)
687 {
688  PROCNAME("numaSetCount");
689 
690  if (!na)
691  return ERROR_INT("na not defined", procName, 1);
692  if (newcount > na->nalloc) {
693  if ((na->array = (l_float32 *)reallocNew((void **)&na->array,
694  sizeof(l_float32) * na->nalloc,
695  sizeof(l_float32) * newcount)) == NULL)
696  return ERROR_INT("new ptr array not returned", procName, 1);
697  na->nalloc = newcount;
698  }
699  na->n = newcount;
700  return 0;
701 }
702 
703 
718 l_ok
720  l_int32 index,
721  l_float32 *pval)
722 {
723  PROCNAME("numaGetFValue");
724 
725  if (!pval)
726  return ERROR_INT("&val not defined", procName, 1);
727  *pval = 0.0;
728  if (!na)
729  return ERROR_INT("na not defined", procName, 1);
730 
731  if (index < 0 || index >= na->n)
732  return ERROR_INT("index not valid", procName, 1);
733 
734  *pval = na->array[index];
735  return 0;
736 }
737 
738 
753 l_ok
755  l_int32 index,
756  l_int32 *pival)
757 {
758 l_float32 val;
759 
760  PROCNAME("numaGetIValue");
761 
762  if (!pival)
763  return ERROR_INT("&ival not defined", procName, 1);
764  *pival = 0;
765  if (!na)
766  return ERROR_INT("na not defined", procName, 1);
767 
768  if (index < 0 || index >= na->n)
769  return ERROR_INT("index not valid", procName, 1);
770 
771  val = na->array[index];
772  *pival = (l_int32)(val + L_SIGN(val) * 0.5);
773  return 0;
774 }
775 
776 
785 l_ok
787  l_int32 index,
788  l_float32 val)
789 {
790  PROCNAME("numaSetValue");
791 
792  if (!na)
793  return ERROR_INT("na not defined", procName, 1);
794  if (index < 0 || index >= na->n)
795  return ERROR_INT("index not valid", procName, 1);
796 
797  na->array[index] = val;
798  return 0;
799 }
800 
801 
810 l_ok
812  l_int32 index,
813  l_float32 diff)
814 {
815  PROCNAME("numaShiftValue");
816 
817  if (!na)
818  return ERROR_INT("na not defined", procName, 1);
819  if (index < 0 || index >= na->n)
820  return ERROR_INT("index not valid", procName, 1);
821 
822  na->array[index] += diff;
823  return 0;
824 }
825 
826 
846 l_int32 *
848 {
849 l_int32 i, n, ival;
850 l_int32 *array;
851 
852  PROCNAME("numaGetIArray");
853 
854  if (!na)
855  return (l_int32 *)ERROR_PTR("na not defined", procName, NULL);
856 
857  n = numaGetCount(na);
858  if ((array = (l_int32 *)LEPT_CALLOC(n, sizeof(l_int32))) == NULL)
859  return (l_int32 *)ERROR_PTR("array not made", procName, NULL);
860  for (i = 0; i < n; i++) {
861  numaGetIValue(na, i, &ival);
862  array[i] = ival;
863  }
864 
865  return array;
866 }
867 
868 
891 l_float32 *
893  l_int32 copyflag)
894 {
895 l_int32 i, n;
896 l_float32 *array;
897 
898  PROCNAME("numaGetFArray");
899 
900  if (!na)
901  return (l_float32 *)ERROR_PTR("na not defined", procName, NULL);
902 
903  if (copyflag == L_NOCOPY) {
904  array = na->array;
905  } else { /* copyflag == L_COPY */
906  n = numaGetCount(na);
907  if ((array = (l_float32 *)LEPT_CALLOC(n, sizeof(l_float32))) == NULL)
908  return (l_float32 *)ERROR_PTR("array not made", procName, NULL);
909  for (i = 0; i < n; i++)
910  array[i] = na->array[i];
911  }
912 
913  return array;
914 }
915 
916 
923 l_int32
925 {
926  PROCNAME("numaGetRefcount");
927 
928  if (!na)
929  return ERROR_INT("na not defined", procName, UNDEF);
930  return na->refcount;
931 }
932 
933 
941 l_ok
943  l_int32 delta)
944 {
945  PROCNAME("numaChangeRefcount");
946 
947  if (!na)
948  return ERROR_INT("na not defined", procName, 1);
949  na->refcount += delta;
950  return 0;
951 }
952 
953 
962 l_ok
964  l_float32 *pstartx,
965  l_float32 *pdelx)
966 {
967  PROCNAME("numaGetParameters");
968 
969  if (!pdelx && !pstartx)
970  return ERROR_INT("no return val requested", procName, 1);
971  if (pstartx) *pstartx = 0.0;
972  if (pdelx) *pdelx = 1.0;
973  if (!na)
974  return ERROR_INT("na not defined", procName, 1);
975 
976  if (pstartx) *pstartx = na->startx;
977  if (pdelx) *pdelx = na->delx;
978  return 0;
979 }
980 
981 
992 l_ok
994  l_float32 startx,
995  l_float32 delx)
996 {
997  PROCNAME("numaSetParameters");
998 
999  if (!na)
1000  return ERROR_INT("na not defined", procName, 1);
1001 
1002  na->startx = startx;
1003  na->delx = delx;
1004  return 0;
1005 }
1006 
1007 
1015 l_ok
1017  NUMA *nas)
1018 {
1019 l_float32 start, binsize;
1020 
1021  PROCNAME("numaCopyParameters");
1022 
1023  if (!nas || !nad)
1024  return ERROR_INT("nas and nad not both defined", procName, 1);
1025 
1026  numaGetParameters(nas, &start, &binsize);
1027  numaSetParameters(nad, start, binsize);
1028  return 0;
1029 }
1030 
1031 
1032 /*----------------------------------------------------------------------*
1033  * Convert to string array *
1034  *----------------------------------------------------------------------*/
1053 SARRAY *
1055  l_int32 size1,
1056  l_int32 size2,
1057  l_int32 addzeros,
1058  l_int32 type)
1059 {
1060 char fmt[32], strbuf[64];
1061 l_int32 i, n, ival;
1062 l_float32 fval;
1063 SARRAY *sa;
1064 
1065  PROCNAME("numaConvertToSarray");
1066 
1067  if (!na)
1068  return (SARRAY *)ERROR_PTR("na not defined", procName, NULL);
1069  if (type != L_INTEGER_VALUE && type != L_FLOAT_VALUE)
1070  return (SARRAY *)ERROR_PTR("invalid type", procName, NULL);
1071 
1072  if (type == L_INTEGER_VALUE) {
1073  if (addzeros)
1074  snprintf(fmt, sizeof(fmt), "%%0%dd", size1);
1075  else
1076  snprintf(fmt, sizeof(fmt), "%%%dd", size1);
1077  } else { /* L_FLOAT_VALUE */
1078  snprintf(fmt, sizeof(fmt), "%%%d.%df", size1, size2);
1079  }
1080 
1081  n = numaGetCount(na);
1082  if ((sa = sarrayCreate(n)) == NULL)
1083  return (SARRAY *)ERROR_PTR("sa not made", procName, NULL);
1084 
1085  for (i = 0; i < n; i++) {
1086  if (type == L_INTEGER_VALUE) {
1087  numaGetIValue(na, i, &ival);
1088  snprintf(strbuf, sizeof(strbuf), fmt, ival);
1089  } else { /* L_FLOAT_VALUE */
1090  numaGetFValue(na, i, &fval);
1091  snprintf(strbuf, sizeof(strbuf), fmt, fval);
1092  }
1093  sarrayAddString(sa, strbuf, L_COPY);
1094  }
1095 
1096  return sa;
1097 }
1098 
1099 
1100 /*----------------------------------------------------------------------*
1101  * Serialize numa for I/O *
1102  *----------------------------------------------------------------------*/
1109 NUMA *
1110 numaRead(const char *filename)
1111 {
1112 FILE *fp;
1113 NUMA *na;
1114 
1115  PROCNAME("numaRead");
1116 
1117  if (!filename)
1118  return (NUMA *)ERROR_PTR("filename not defined", procName, NULL);
1119 
1120  if ((fp = fopenReadStream(filename)) == NULL)
1121  return (NUMA *)ERROR_PTR("stream not opened", procName, NULL);
1122  na = numaReadStream(fp);
1123  fclose(fp);
1124  if (!na)
1125  return (NUMA *)ERROR_PTR("na not read", procName, NULL);
1126  return na;
1127 }
1128 
1129 
1136 NUMA *
1138 {
1139 l_int32 i, n, index, ret, version;
1140 l_float32 val, startx, delx;
1141 NUMA *na;
1142 
1143  PROCNAME("numaReadStream");
1144 
1145  if (!fp)
1146  return (NUMA *)ERROR_PTR("stream not defined", procName, NULL);
1147 
1148  ret = fscanf(fp, "\nNuma Version %d\n", &version);
1149  if (ret != 1)
1150  return (NUMA *)ERROR_PTR("not a numa file", procName, NULL);
1151  if (version != NUMA_VERSION_NUMBER)
1152  return (NUMA *)ERROR_PTR("invalid numa version", procName, NULL);
1153  if (fscanf(fp, "Number of numbers = %d\n", &n) != 1)
1154  return (NUMA *)ERROR_PTR("invalid number of numbers", procName, NULL);
1155 
1156  if (n > MaxFloatArraySize) {
1157  L_ERROR("n = %d > %d\n", procName, n, MaxFloatArraySize);
1158  return NULL;
1159  }
1160  if ((na = numaCreate(n)) == NULL)
1161  return (NUMA *)ERROR_PTR("na not made", procName, NULL);
1162 
1163  for (i = 0; i < n; i++) {
1164  if (fscanf(fp, " [%d] = %f\n", &index, &val) != 2) {
1165  numaDestroy(&na);
1166  return (NUMA *)ERROR_PTR("bad input data", procName, NULL);
1167  }
1168  numaAddNumber(na, val);
1169  }
1170 
1171  /* Optional data */
1172  if (fscanf(fp, "startx = %f, delx = %f\n", &startx, &delx) == 2)
1173  numaSetParameters(na, startx, delx);
1174 
1175  return na;
1176 }
1177 
1178 
1186 NUMA *
1187 numaReadMem(const l_uint8 *data,
1188  size_t size)
1189 {
1190 FILE *fp;
1191 NUMA *na;
1192 
1193  PROCNAME("numaReadMem");
1194 
1195  if (!data)
1196  return (NUMA *)ERROR_PTR("data not defined", procName, NULL);
1197  if ((fp = fopenReadFromMemory(data, size)) == NULL)
1198  return (NUMA *)ERROR_PTR("stream not opened", procName, NULL);
1199 
1200  na = numaReadStream(fp);
1201  fclose(fp);
1202  if (!na) L_ERROR("numa not read\n", procName);
1203  return na;
1204 }
1205 
1206 
1223 l_ok
1224 numaWriteDebug(const char *filename,
1225  NUMA *na)
1226 {
1227  PROCNAME("numaWriteDebug");
1228 
1229  if (LeptDebugOK) {
1230  return numaWrite(filename, na);
1231  } else {
1232  L_INFO("write to named temp file %s is disabled\n", procName, filename);
1233  return 0;
1234  }
1235 }
1236 
1237 
1245 l_ok
1246 numaWrite(const char *filename,
1247  NUMA *na)
1248 {
1249 l_int32 ret;
1250 FILE *fp;
1251 
1252  PROCNAME("numaWrite");
1253 
1254  if (!filename)
1255  return ERROR_INT("filename not defined", procName, 1);
1256  if (!na)
1257  return ERROR_INT("na not defined", procName, 1);
1258 
1259  if ((fp = fopenWriteStream(filename, "w")) == NULL)
1260  return ERROR_INT("stream not opened", procName, 1);
1261  ret = numaWriteStream(fp, na);
1262  fclose(fp);
1263  if (ret)
1264  return ERROR_INT("na not written to stream", procName, 1);
1265  return 0;
1266 }
1267 
1268 
1276 l_ok
1278  NUMA *na)
1279 {
1280 l_int32 i, n;
1281 l_float32 startx, delx;
1282 
1283  PROCNAME("numaWriteStream");
1284 
1285  if (!na)
1286  return ERROR_INT("na not defined", procName, 1);
1287  if (!fp)
1288  return numaWriteStderr(na);
1289 
1290  n = numaGetCount(na);
1291  fprintf(fp, "\nNuma Version %d\n", NUMA_VERSION_NUMBER);
1292  fprintf(fp, "Number of numbers = %d\n", n);
1293  for (i = 0; i < n; i++)
1294  fprintf(fp, " [%d] = %f\n", i, na->array[i]);
1295  fprintf(fp, "\n");
1296 
1297  /* Optional data */
1298  numaGetParameters(na, &startx, &delx);
1299  if (startx != 0.0 || delx != 1.0)
1300  fprintf(fp, "startx = %f, delx = %f\n", startx, delx);
1301 
1302  return 0;
1303 }
1304 
1305 
1312 l_ok
1314 {
1315 l_int32 i, n;
1316 l_float32 startx, delx;
1317 
1318  PROCNAME("numaWriteStderr");
1319 
1320  if (!na)
1321  return ERROR_INT("na not defined", procName, 1);
1322 
1323  n = numaGetCount(na);
1324  lept_stderr("\nNuma Version %d\n", NUMA_VERSION_NUMBER);
1325  lept_stderr("Number of numbers = %d\n", n);
1326  for (i = 0; i < n; i++)
1327  lept_stderr(" [%d] = %f\n", i, na->array[i]);
1328  lept_stderr("\n");
1329 
1330  /* Optional data */
1331  numaGetParameters(na, &startx, &delx);
1332  if (startx != 0.0 || delx != 1.0)
1333  lept_stderr("startx = %f, delx = %f\n", startx, delx);
1334 
1335  return 0;
1336 }
1337 
1338 
1352 l_ok
1353 numaWriteMem(l_uint8 **pdata,
1354  size_t *psize,
1355  NUMA *na)
1356 {
1357 l_int32 ret;
1358 FILE *fp;
1359 
1360  PROCNAME("numaWriteMem");
1361 
1362  if (pdata) *pdata = NULL;
1363  if (psize) *psize = 0;
1364  if (!pdata)
1365  return ERROR_INT("&data not defined", procName, 1);
1366  if (!psize)
1367  return ERROR_INT("&size not defined", procName, 1);
1368  if (!na)
1369  return ERROR_INT("na not defined", procName, 1);
1370 
1371 #if HAVE_FMEMOPEN
1372  if ((fp = open_memstream((char **)pdata, psize)) == NULL)
1373  return ERROR_INT("stream not opened", procName, 1);
1374  ret = numaWriteStream(fp, na);
1375  fputc('\0', fp);
1376  fclose(fp);
1377  *psize = *psize - 1;
1378 #else
1379  L_INFO("work-around: writing to a temp file\n", procName);
1380  #ifdef _WIN32
1381  if ((fp = fopenWriteWinTempfile()) == NULL)
1382  return ERROR_INT("tmpfile stream not opened", procName, 1);
1383  #else
1384  if ((fp = tmpfile()) == NULL)
1385  return ERROR_INT("tmpfile stream not opened", procName, 1);
1386  #endif /* _WIN32 */
1387  ret = numaWriteStream(fp, na);
1388  rewind(fp);
1389  *pdata = l_binaryReadStream(fp, psize);
1390  fclose(fp);
1391 #endif /* HAVE_FMEMOPEN */
1392  return ret;
1393 }
1394 
1395 
1396 /*--------------------------------------------------------------------------*
1397  * Numaa creation, destruction *
1398  *--------------------------------------------------------------------------*/
1406 NUMAA *
1407 numaaCreate(l_int32 n)
1408 {
1409 NUMAA *naa;
1410 
1411  PROCNAME("numaaCreate");
1412 
1413  if (n <= 0 || n > MaxPtrArraySize)
1414  n = InitialArraySize;
1415 
1416  naa = (NUMAA *)LEPT_CALLOC(1, sizeof(NUMAA));
1417  if ((naa->numa = (NUMA **)LEPT_CALLOC(n, sizeof(NUMA *))) == NULL) {
1418  numaaDestroy(&naa);
1419  return (NUMAA *)ERROR_PTR("numa ptr array not made", procName, NULL);
1420  }
1421 
1422  naa->nalloc = n;
1423  naa->n = 0;
1424  return naa;
1425 }
1426 
1427 
1444 NUMAA *
1445 numaaCreateFull(l_int32 nptr,
1446  l_int32 n)
1447 {
1448 l_int32 i;
1449 NUMAA *naa;
1450 NUMA *na;
1451 
1452  naa = numaaCreate(nptr);
1453  for (i = 0; i < nptr; i++) {
1454  na = numaCreate(n);
1455  numaaAddNuma(naa, na, L_INSERT);
1456  }
1457 
1458  return naa;
1459 }
1460 
1461 
1475 l_ok
1477 {
1478 l_int32 i, n, nn;
1479 NUMA *na;
1480 
1481  PROCNAME("numaaTruncate");
1482 
1483  if (!naa)
1484  return ERROR_INT("naa not defined", procName, 1);
1485 
1486  n = numaaGetCount(naa);
1487  for (i = n - 1; i >= 0; i--) {
1488  na = numaaGetNuma(naa, i, L_CLONE);
1489  if (!na)
1490  continue;
1491  nn = numaGetCount(na);
1492  numaDestroy(&na);
1493  if (nn == 0)
1494  numaDestroy(&naa->numa[i]);
1495  else
1496  break;
1497  }
1498  naa->n = i + 1;
1499  return 0;
1500 }
1501 
1502 
1509 void
1511 {
1512 l_int32 i;
1513 NUMAA *naa;
1514 
1515  PROCNAME("numaaDestroy");
1516 
1517  if (pnaa == NULL) {
1518  L_WARNING("ptr address is NULL!\n", procName);
1519  return;
1520  }
1521 
1522  if ((naa = *pnaa) == NULL)
1523  return;
1524 
1525  for (i = 0; i < naa->n; i++)
1526  numaDestroy(&naa->numa[i]);
1527  LEPT_FREE(naa->numa);
1528  LEPT_FREE(naa);
1529  *pnaa = NULL;
1530 }
1531 
1532 
1533 
1534 /*--------------------------------------------------------------------------*
1535  * Add Numa to Numaa *
1536  *--------------------------------------------------------------------------*/
1545 l_ok
1547  NUMA *na,
1548  l_int32 copyflag)
1549 {
1550 l_int32 n;
1551 NUMA *nac;
1552 
1553  PROCNAME("numaaAddNuma");
1554 
1555  if (!naa)
1556  return ERROR_INT("naa not defined", procName, 1);
1557  if (!na)
1558  return ERROR_INT("na not defined", procName, 1);
1559 
1560  if (copyflag == L_INSERT) {
1561  nac = na;
1562  } else if (copyflag == L_COPY) {
1563  if ((nac = numaCopy(na)) == NULL)
1564  return ERROR_INT("nac not made", procName, 1);
1565  } else if (copyflag == L_CLONE) {
1566  nac = numaClone(na);
1567  } else {
1568  return ERROR_INT("invalid copyflag", procName, 1);
1569  }
1570 
1571  n = numaaGetCount(naa);
1572  if (n >= naa->nalloc) {
1573  if (numaaExtendArray(naa)) {
1574  if (copyflag != L_INSERT)
1575  numaDestroy(&nac);
1576  return ERROR_INT("extension failed", procName, 1);
1577  }
1578  }
1579  naa->numa[n] = nac;
1580  naa->n++;
1581  return 0;
1582 }
1583 
1584 
1596 static l_int32
1598 {
1599 size_t oldsize, newsize;
1600 
1601  PROCNAME("numaaExtendArray");
1602 
1603  if (!naa)
1604  return ERROR_INT("naa not defined", procName, 1);
1605  if (naa->nalloc > MaxPtrArraySize) /* belt & suspenders */
1606  return ERROR_INT("naa has too many ptrs", procName, 1);
1607  oldsize = naa->nalloc * sizeof(NUMA *);
1608  newsize = 2 * oldsize;
1609  if (newsize > 8 * MaxPtrArraySize)
1610  return ERROR_INT("newsize > 8 MB; too large", procName, 1);
1611 
1612  if ((naa->numa = (NUMA **)reallocNew((void **)&naa->numa,
1613  oldsize, newsize)) == NULL)
1614  return ERROR_INT("new ptr array not returned", procName, 1);
1615 
1616  naa->nalloc *= 2;
1617  return 0;
1618 }
1619 
1620 
1621 /*----------------------------------------------------------------------*
1622  * Numaa accessors *
1623  *----------------------------------------------------------------------*/
1630 l_int32
1632 {
1633  PROCNAME("numaaGetCount");
1634 
1635  if (!naa)
1636  return ERROR_INT("naa not defined", procName, 0);
1637  return naa->n;
1638 }
1639 
1640 
1648 l_int32
1650  l_int32 index)
1651 {
1652  PROCNAME("numaaGetNumaCount");
1653 
1654  if (!naa)
1655  return ERROR_INT("naa not defined", procName, 0);
1656  if (index < 0 || index >= naa->n)
1657  return ERROR_INT("invalid index into naa", procName, 0);
1658  return numaGetCount(naa->numa[index]);
1659 }
1660 
1661 
1669 l_int32
1671 {
1672 NUMA *na;
1673 l_int32 n, sum, i;
1674 
1675  PROCNAME("numaaGetNumberCount");
1676 
1677  if (!naa)
1678  return ERROR_INT("naa not defined", procName, 0);
1679 
1680  n = numaaGetCount(naa);
1681  for (sum = 0, i = 0; i < n; i++) {
1682  na = numaaGetNuma(naa, i, L_CLONE);
1683  sum += numaGetCount(na);
1684  numaDestroy(&na);
1685  }
1686 
1687  return sum;
1688 }
1689 
1690 
1718 NUMA **
1720 {
1721  PROCNAME("numaaGetPtrArray");
1722 
1723  if (!naa)
1724  return (NUMA **)ERROR_PTR("naa not defined", procName, NULL);
1725 
1726  naa->n = naa->nalloc;
1727  return naa->numa;
1728 }
1729 
1730 
1739 NUMA *
1741  l_int32 index,
1742  l_int32 accessflag)
1743 {
1744  PROCNAME("numaaGetNuma");
1745 
1746  if (!naa)
1747  return (NUMA *)ERROR_PTR("naa not defined", procName, NULL);
1748  if (index < 0 || index >= naa->n)
1749  return (NUMA *)ERROR_PTR("index not valid", procName, NULL);
1750 
1751  if (accessflag == L_COPY)
1752  return numaCopy(naa->numa[index]);
1753  else if (accessflag == L_CLONE)
1754  return numaClone(naa->numa[index]);
1755  else
1756  return (NUMA *)ERROR_PTR("invalid accessflag", procName, NULL);
1757 }
1758 
1759 
1775 l_ok
1777  l_int32 index,
1778  NUMA *na)
1779 {
1780 l_int32 n;
1781 
1782  PROCNAME("numaaReplaceNuma");
1783 
1784  if (!naa)
1785  return ERROR_INT("naa not defined", procName, 1);
1786  if (!na)
1787  return ERROR_INT("na not defined", procName, 1);
1788  n = numaaGetCount(naa);
1789  if (index < 0 || index >= n)
1790  return ERROR_INT("index not valid", procName, 1);
1791 
1792  numaDestroy(&naa->numa[index]);
1793  naa->numa[index] = na;
1794  return 0;
1795 }
1796 
1797 
1808 l_ok
1810  l_int32 i,
1811  l_int32 j,
1812  l_float32 *pfval,
1813  l_int32 *pival)
1814 {
1815 l_int32 n;
1816 NUMA *na;
1817 
1818  PROCNAME("numaaGetValue");
1819 
1820  if (!pfval && !pival)
1821  return ERROR_INT("no return val requested", procName, 1);
1822  if (pfval) *pfval = 0.0;
1823  if (pival) *pival = 0;
1824  if (!naa)
1825  return ERROR_INT("naa not defined", procName, 1);
1826  n = numaaGetCount(naa);
1827  if (i < 0 || i >= n)
1828  return ERROR_INT("invalid index into naa", procName, 1);
1829  na = naa->numa[i];
1830  if (j < 0 || j >= na->n)
1831  return ERROR_INT("invalid index into na", procName, 1);
1832  if (pfval) *pfval = na->array[j];
1833  if (pival) *pival = (l_int32)(na->array[j]);
1834  return 0;
1835 }
1836 
1837 
1851 l_ok
1853  l_int32 index,
1854  l_float32 val)
1855 {
1856 l_int32 n;
1857 NUMA *na;
1858 
1859  PROCNAME("numaaAddNumber");
1860 
1861  if (!naa)
1862  return ERROR_INT("naa not defined", procName, 1);
1863  n = numaaGetCount(naa);
1864  if (index < 0 || index >= n)
1865  return ERROR_INT("invalid index in naa", procName, 1);
1866 
1867  na = numaaGetNuma(naa, index, L_CLONE);
1868  numaAddNumber(na, val);
1869  numaDestroy(&na);
1870  return 0;
1871 }
1872 
1873 
1874 /*----------------------------------------------------------------------*
1875  * Serialize numaa for I/O *
1876  *----------------------------------------------------------------------*/
1883 NUMAA *
1884 numaaRead(const char *filename)
1885 {
1886 FILE *fp;
1887 NUMAA *naa;
1888 
1889  PROCNAME("numaaRead");
1890 
1891  if (!filename)
1892  return (NUMAA *)ERROR_PTR("filename not defined", procName, NULL);
1893 
1894  if ((fp = fopenReadStream(filename)) == NULL)
1895  return (NUMAA *)ERROR_PTR("stream not opened", procName, NULL);
1896  naa = numaaReadStream(fp);
1897  fclose(fp);
1898  if (!naa)
1899  return (NUMAA *)ERROR_PTR("naa not read", procName, NULL);
1900  return naa;
1901 }
1902 
1903 
1910 NUMAA *
1912 {
1913 l_int32 i, n, index, ret, version;
1914 NUMA *na;
1915 NUMAA *naa;
1916 
1917  PROCNAME("numaaReadStream");
1918 
1919  if (!fp)
1920  return (NUMAA *)ERROR_PTR("stream not defined", procName, NULL);
1921 
1922  ret = fscanf(fp, "\nNumaa Version %d\n", &version);
1923  if (ret != 1)
1924  return (NUMAA *)ERROR_PTR("not a numa file", procName, NULL);
1925  if (version != NUMA_VERSION_NUMBER)
1926  return (NUMAA *)ERROR_PTR("invalid numaa version", procName, NULL);
1927  if (fscanf(fp, "Number of numa = %d\n\n", &n) != 1)
1928  return (NUMAA *)ERROR_PTR("invalid number of numa", procName, NULL);
1929 
1930  if (n > MaxPtrArraySize) {
1931  L_ERROR("n = %d > %d\n", procName, n, MaxPtrArraySize);
1932  return NULL;
1933  }
1934  if ((naa = numaaCreate(n)) == NULL)
1935  return (NUMAA *)ERROR_PTR("naa not made", procName, NULL);
1936 
1937  for (i = 0; i < n; i++) {
1938  if (fscanf(fp, "Numa[%d]:", &index) != 1) {
1939  numaaDestroy(&naa);
1940  return (NUMAA *)ERROR_PTR("invalid numa header", procName, NULL);
1941  }
1942  if ((na = numaReadStream(fp)) == NULL) {
1943  numaaDestroy(&naa);
1944  return (NUMAA *)ERROR_PTR("na not made", procName, NULL);
1945  }
1946  numaaAddNuma(naa, na, L_INSERT);
1947  }
1948 
1949  return naa;
1950 }
1951 
1952 
1960 NUMAA *
1961 numaaReadMem(const l_uint8 *data,
1962  size_t size)
1963 {
1964 FILE *fp;
1965 NUMAA *naa;
1966 
1967  PROCNAME("numaaReadMem");
1968 
1969  if (!data)
1970  return (NUMAA *)ERROR_PTR("data not defined", procName, NULL);
1971  if ((fp = fopenReadFromMemory(data, size)) == NULL)
1972  return (NUMAA *)ERROR_PTR("stream not opened", procName, NULL);
1973 
1974  naa = numaaReadStream(fp);
1975  fclose(fp);
1976  if (!naa) L_ERROR("naa not read\n", procName);
1977  return naa;
1978 }
1979 
1980 
1988 l_ok
1989 numaaWrite(const char *filename,
1990  NUMAA *naa)
1991 {
1992 l_int32 ret;
1993 FILE *fp;
1994 
1995  PROCNAME("numaaWrite");
1996 
1997  if (!filename)
1998  return ERROR_INT("filename not defined", procName, 1);
1999  if (!naa)
2000  return ERROR_INT("naa not defined", procName, 1);
2001 
2002  if ((fp = fopenWriteStream(filename, "w")) == NULL)
2003  return ERROR_INT("stream not opened", procName, 1);
2004  ret = numaaWriteStream(fp, naa);
2005  fclose(fp);
2006  if (ret)
2007  return ERROR_INT("naa not written to stream", procName, 1);
2008  return 0;
2009 }
2010 
2011 
2019 l_ok
2021  NUMAA *naa)
2022 {
2023 l_int32 i, n;
2024 NUMA *na;
2025 
2026  PROCNAME("numaaWriteStream");
2027 
2028  if (!fp)
2029  return ERROR_INT("stream not defined", procName, 1);
2030  if (!naa)
2031  return ERROR_INT("naa not defined", procName, 1);
2032 
2033  n = numaaGetCount(naa);
2034  fprintf(fp, "\nNumaa Version %d\n", NUMA_VERSION_NUMBER);
2035  fprintf(fp, "Number of numa = %d\n\n", n);
2036  for (i = 0; i < n; i++) {
2037  if ((na = numaaGetNuma(naa, i, L_CLONE)) == NULL)
2038  return ERROR_INT("na not found", procName, 1);
2039  fprintf(fp, "Numa[%d]:", i);
2040  numaWriteStream(fp, na);
2041  numaDestroy(&na);
2042  }
2043 
2044  return 0;
2045 }
2046 
2047 
2061 l_ok
2062 numaaWriteMem(l_uint8 **pdata,
2063  size_t *psize,
2064  NUMAA *naa)
2065 {
2066 l_int32 ret;
2067 FILE *fp;
2068 
2069  PROCNAME("numaaWriteMem");
2070 
2071  if (pdata) *pdata = NULL;
2072  if (psize) *psize = 0;
2073  if (!pdata)
2074  return ERROR_INT("&data not defined", procName, 1);
2075  if (!psize)
2076  return ERROR_INT("&size not defined", procName, 1);
2077  if (!naa)
2078  return ERROR_INT("naa not defined", procName, 1);
2079 
2080 #if HAVE_FMEMOPEN
2081  if ((fp = open_memstream((char **)pdata, psize)) == NULL)
2082  return ERROR_INT("stream not opened", procName, 1);
2083  ret = numaaWriteStream(fp, naa);
2084  fputc('\0', fp);
2085  fclose(fp);
2086  *psize = *psize - 1;
2087 #else
2088  L_INFO("work-around: writing to a temp file\n", procName);
2089  #ifdef _WIN32
2090  if ((fp = fopenWriteWinTempfile()) == NULL)
2091  return ERROR_INT("tmpfile stream not opened", procName, 1);
2092  #else
2093  if ((fp = tmpfile()) == NULL)
2094  return ERROR_INT("tmpfile stream not opened", procName, 1);
2095  #endif /* _WIN32 */
2096  ret = numaaWriteStream(fp, naa);
2097  rewind(fp);
2098  *pdata = l_binaryReadStream(fp, psize);
2099  fclose(fp);
2100 #endif /* HAVE_FMEMOPEN */
2101  return ret;
2102 }
2103 
#define NUMA_VERSION_NUMBER
Definition: array.h:67
@ L_FLOAT_VALUE
Definition: array.h:165
@ L_INTEGER_VALUE
Definition: array.h:164
SARRAY * numaConvertToSarray(NUMA *na, l_int32 size1, l_int32 size2, l_int32 addzeros, l_int32 type)
numaConvertToSarray()
Definition: numabasic.c:1054
NUMA * numaReadMem(const l_uint8 *data, size_t size)
numaReadMem()
Definition: numabasic.c:1187
NUMAA * numaaRead(const char *filename)
numaaRead()
Definition: numabasic.c:1884
l_ok numaaWriteMem(l_uint8 **pdata, size_t *psize, NUMAA *naa)
numaaWriteMem()
Definition: numabasic.c:2062
l_ok numaAddNumber(NUMA *na, l_float32 val)
numaAddNumber()
Definition: numabasic.c:478
l_int32 numaGetRefcount(NUMA *na)
numaGetRefCount()
Definition: numabasic.c:924
NUMA * numaReadStream(FILE *fp)
numaReadStream()
Definition: numabasic.c:1137
l_int32 numaaGetNumberCount(NUMAA *naa)
numaaGetNumberCount()
Definition: numabasic.c:1670
NUMAA * numaaReadMem(const l_uint8 *data, size_t size)
numaaReadMem()
Definition: numabasic.c:1961
l_ok numaReplaceNumber(NUMA *na, l_int32 index, l_float32 val)
numaReplaceNumber()
Definition: numabasic.c:627
NUMA * numaCreateFromString(const char *str)
numaCreateFromString()
Definition: numabasic.c:315
l_ok numaGetFValue(NUMA *na, l_int32 index, l_float32 *pval)
numaGetFValue()
Definition: numabasic.c:719
l_ok numaChangeRefcount(NUMA *na, l_int32 delta)
numaChangeRefCount()
Definition: numabasic.c:942
l_ok numaWriteStderr(NUMA *na)
numaWriteStderr()
Definition: numabasic.c:1313
NUMA ** numaaGetPtrArray(NUMAA *naa)
numaaGetPtrArray()
Definition: numabasic.c:1719
NUMA * numaCreate(l_int32 n)
numaCreate()
Definition: numabasic.c:194
l_ok numaWrite(const char *filename, NUMA *na)
numaWrite()
Definition: numabasic.c:1246
l_int32 numaaGetCount(NUMAA *naa)
numaaGetCount()
Definition: numabasic.c:1631
l_ok numaaAddNumber(NUMAA *naa, l_int32 index, l_float32 val)
numaaAddNumber()
Definition: numabasic.c:1852
l_ok numaInsertNumber(NUMA *na, l_int32 index, l_float32 val)
numaInsertNumber()
Definition: numabasic.c:553
NUMAA * numaaCreateFull(l_int32 nptr, l_int32 n)
numaaCreateFull()
Definition: numabasic.c:1445
NUMA * numaaGetNuma(NUMAA *naa, l_int32 index, l_int32 accessflag)
numaaGetNuma()
Definition: numabasic.c:1740
l_ok numaaWriteStream(FILE *fp, NUMAA *naa)
numaaWriteStream()
Definition: numabasic.c:2020
l_int32 numaaGetNumaCount(NUMAA *naa, l_int32 index)
numaaGetNumaCount()
Definition: numabasic.c:1649
NUMA * numaRead(const char *filename)
numaRead()
Definition: numabasic.c:1110
l_ok numaSetCount(NUMA *na, l_int32 newcount)
numaSetCount()
Definition: numabasic.c:685
NUMA * numaClone(NUMA *na)
numaClone()
Definition: numabasic.c:428
l_ok numaaGetValue(NUMAA *naa, l_int32 i, l_int32 j, l_float32 *pfval, l_int32 *pival)
numaaGetValue()
Definition: numabasic.c:1809
void numaDestroy(NUMA **pna)
numaDestroy()
Definition: numabasic.c:366
l_ok numaaTruncate(NUMAA *naa)
numaaTruncate()
Definition: numabasic.c:1476
NUMAA * numaaCreate(l_int32 n)
numaaCreate()
Definition: numabasic.c:1407
l_ok numaSetValue(NUMA *na, l_int32 index, l_float32 val)
numaSetValue()
Definition: numabasic.c:786
l_ok numaEmpty(NUMA *na)
numaEmpty()
Definition: numabasic.c:454
l_int32 numaGetCount(NUMA *na)
numaGetCount()
Definition: numabasic.c:658
l_ok numaGetIValue(NUMA *na, l_int32 index, l_int32 *pival)
numaGetIValue()
Definition: numabasic.c:754
l_ok numaRemoveNumber(NUMA *na, l_int32 index)
numaRemoveNumber()
Definition: numabasic.c:596
l_ok numaaAddNuma(NUMAA *naa, NUMA *na, l_int32 copyflag)
numaaAddNuma()
Definition: numabasic.c:1546
l_ok numaaWrite(const char *filename, NUMAA *naa)
numaaWrite()
Definition: numabasic.c:1989
NUMA * numaCreateFromFArray(l_float32 *farray, l_int32 size, l_int32 copyflag)
numaCreateFromFArray()
Definition: numabasic.c:271
l_ok numaWriteDebug(const char *filename, NUMA *na)
numaWriteDebug()
Definition: numabasic.c:1224
static const l_int32 InitialArraySize
Definition: numabasic.c:178
l_ok numaShiftValue(NUMA *na, l_int32 index, l_float32 diff)
numaShiftValue()
Definition: numabasic.c:811
NUMAA * numaaReadStream(FILE *fp)
numaaReadStream()
Definition: numabasic.c:1911
NUMA * numaCopy(NUMA *na)
numaCopy()
Definition: numabasic.c:399
static l_int32 numaExtendArray(NUMA *na)
numaExtendArray()
Definition: numabasic.c:511
l_ok numaWriteMem(l_uint8 **pdata, size_t *psize, NUMA *na)
numaWriteMem()
Definition: numabasic.c:1353
l_int32 * numaGetIArray(NUMA *na)
numaGetIArray()
Definition: numabasic.c:847
l_ok numaGetParameters(NUMA *na, l_float32 *pstartx, l_float32 *pdelx)
numaGetParameters()
Definition: numabasic.c:963
NUMA * numaCreateFromIArray(l_int32 *iarray, l_int32 size)
numaCreateFromIArray()
Definition: numabasic.c:234
void numaaDestroy(NUMAA **pnaa)
numaaDestroy()
Definition: numabasic.c:1510
l_ok numaCopyParameters(NUMA *nad, NUMA *nas)
numaCopyParameters()
Definition: numabasic.c:1016
l_ok numaSetParameters(NUMA *na, l_float32 startx, l_float32 delx)
numaSetParameters()
Definition: numabasic.c:993
l_float32 * numaGetFArray(NUMA *na, l_int32 copyflag)
numaGetFArray()
Definition: numabasic.c:892
l_ok numaaReplaceNuma(NUMAA *naa, l_int32 index, NUMA *na)
numaaReplaceNuma()
Definition: numabasic.c:1776
l_ok numaWriteStream(FILE *fp, NUMA *na)
numaWriteStream()
Definition: numabasic.c:1277
static l_int32 numaaExtendArray(NUMAA *naa)
numaaExtendArray()
Definition: numabasic.c:1597
@ L_COPY
Definition: pix.h:712
@ L_CLONE
Definition: pix.h:713
@ L_NOCOPY
Definition: pix.h:710
@ L_INSERT
Definition: pix.h:711
SARRAY * sarrayCreate(l_int32 n)
sarrayCreate()
Definition: sarray1.c:170
char * sarrayGetString(SARRAY *sa, l_int32 index, l_int32 copyflag)
sarrayGetString()
Definition: sarray1.c:703
l_int32 sarrayGetCount(SARRAY *sa)
sarrayGetCount()
Definition: sarray1.c:643
void sarrayDestroy(SARRAY **psa)
sarrayDestroy()
Definition: sarray1.c:362
l_ok sarrayAddString(SARRAY *sa, const char *string, l_int32 copyflag)
sarrayAddString()
Definition: sarray1.c:451
Definition: array.h:71
l_float32 startx
Definition: array.h:75
l_float32 delx
Definition: array.h:76
l_int32 nalloc
Definition: array.h:72
l_float32 * array
Definition: array.h:77
l_int32 refcount
Definition: array.h:74
l_int32 n
Definition: array.h:73
Definition: array.h:83
struct Numa ** numa
Definition: array.h:86
l_int32 n
Definition: array.h:85
l_int32 nalloc
Definition: array.h:84
Definition: array.h:127
void lept_stderr(const char *fmt,...)
lept_stderr()
Definition: utils1.c:306
l_uint8 * l_binaryReadStream(FILE *fp, size_t *pnbytes)
l_binaryReadStream()
Definition: utils2.c:1402
FILE * fopenReadFromMemory(const l_uint8 *data, size_t size)
fopenReadFromMemory()
Definition: utils2.c:2009
FILE * fopenWriteStream(const char *filename, const char *modestring)
fopenWriteStream()
Definition: utils2.c:1975
void * reallocNew(void **pindata, size_t oldsize, size_t newsize)
reallocNew()
Definition: utils2.c:1302
FILE * fopenWriteWinTempfile(void)
fopenWriteWinTempfile()
Definition: utils2.c:2055
FILE * fopenReadStream(const char *filename)
fopenReadStream()
Definition: utils2.c:1932