138 #include <config_auto.h> 142 #include "allheaders.h" 145 static const l_int32 BinSizeArray[] = {2, 5, 10, 20, 50, 100, 200, 500, 1000,\
146 2000, 5000, 10000, 20000, 50000, 100000, 200000,\
147 500000, 1000000, 2000000, 5000000, 10000000,\
148 200000000, 50000000, 100000000};
149 static const l_int32 NBinSizes = 24;
152 #ifndef NO_CONSOLE_IO 153 #define DEBUG_HISTO 0 154 #define DEBUG_CROSSINGS 0 155 #define DEBUG_FREQUENCY 0 186 l_int32 i, j, n, hsize, len;
188 l_float32 *fa, *fas, *fad;
191 PROCNAME(
"numaErode");
194 return (
NUMA *)ERROR_PTR(
"nas not defined", procName, NULL);
196 return (
NUMA *)ERROR_PTR(
"size must be > 0", procName, NULL);
197 if ((size & 1) == 0 ) {
198 L_WARNING(
"sel size must be odd; increasing by 1\n", procName);
212 if ((fas = (l_float32 *)LEPT_CALLOC(len,
sizeof(l_float32))) == NULL)
213 return (
NUMA *)ERROR_PTR(
"fas not made", procName, NULL);
214 for (i = 0; i < hsize; i++)
216 for (i = hsize + n; i < len; i++)
219 for (i = 0; i < n; i++)
220 fas[hsize + i] = fa[i];
225 for (i = 0; i < n; i++) {
227 for (j = 0; j < size; j++)
228 minval = L_MIN(minval, fas[i + j]);
255 l_int32 i, j, n, hsize, len;
257 l_float32 *fa, *fas, *fad;
260 PROCNAME(
"numaDilate");
263 return (
NUMA *)ERROR_PTR(
"nas not defined", procName, NULL);
265 return (
NUMA *)ERROR_PTR(
"size must be > 0", procName, NULL);
266 if ((size & 1) == 0 ) {
267 L_WARNING(
"sel size must be odd; increasing by 1\n", procName);
281 if ((fas = (l_float32 *)LEPT_CALLOC(len,
sizeof(l_float32))) == NULL)
282 return (
NUMA *)ERROR_PTR(
"fas not made", procName, NULL);
283 for (i = 0; i < hsize; i++)
285 for (i = hsize + n; i < len; i++)
288 for (i = 0; i < n; i++)
289 fas[hsize + i] = fa[i];
294 for (i = 0; i < n; i++) {
296 for (j = 0; j < size; j++)
297 maxval = L_MAX(maxval, fas[i + j]);
326 PROCNAME(
"numaOpen");
329 return (
NUMA *)ERROR_PTR(
"nas not defined", procName, NULL);
331 return (
NUMA *)ERROR_PTR(
"size must be > 0", procName, NULL);
332 if ((size & 1) == 0 ) {
333 L_WARNING(
"sel size must be odd; increasing by 1\n", procName);
371 NUMA *nab, *nat1, *nat2, *nad;
373 PROCNAME(
"numaClose");
376 return (
NUMA *)ERROR_PTR(
"nas not defined", procName, NULL);
378 return (
NUMA *)ERROR_PTR(
"size must be > 0", procName, NULL);
379 if ((size & 1) == 0 ) {
380 L_WARNING(
"sel size must be odd; increasing by 1\n", procName);
423 PROCNAME(
"numaTransform");
426 return (
NUMA *)ERROR_PTR(
"nas not defined", procName, NULL);
429 return (
NUMA *)ERROR_PTR(
"nad not made", procName, NULL);
431 for (i = 0; i < n; i++) {
433 val = scale * (val + shift);
460 l_float32 sum, sumsq, val, mean, var;
462 PROCNAME(
"numaSimpleStats");
464 if (pmean) *pmean = 0.0;
465 if (pvar) *pvar = 0.0;
466 if (prvar) *prvar = 0.0;
467 if (!pmean && !pvar && !prvar)
468 return ERROR_INT(
"nothing requested", procName, 1);
470 return ERROR_INT(
"na not defined", procName, 1);
472 return ERROR_INT(
"na is empty", procName, 1);
473 first = L_MAX(0, first);
474 if (last < 0) last = n - 1;
476 return ERROR_INT(
"invalid first", procName, 1);
478 L_WARNING(
"last = %d is beyond max index = %d; adjusting\n",
479 procName, last, n - 1);
483 return ERROR_INT(
"first > last\n", procName, 1);
484 ni = last - first + 1;
486 for (i = first; i <= last; i++) {
496 var = sumsq / ni - mean * mean;
497 if (pvar) *pvar = var;
498 if (prvar) *prvar = sqrtf(var);
546 PROCNAME(
"numaWindowedStats");
549 return ERROR_INT(
"nas not defined", procName, 1);
551 L_WARNING(
"filter wider than input array!\n", procName);
553 if (!pnav && !pnarv) {
591 l_int32 i, n, n1, width;
593 l_float32 *fa1, *fad, *suma;
596 PROCNAME(
"numaWindowedMean");
599 return (
NUMA *)ERROR_PTR(
"nas not defined", procName, NULL);
603 L_WARNING(
"filter wider than input array!\n", procName);
612 if ((suma = (l_float32 *)LEPT_CALLOC(n1 + 1,
sizeof(l_float32))) == NULL) {
615 return (
NUMA *)ERROR_PTR(
"suma not made", procName, NULL);
619 for (i = 0; i < n1; i++) {
624 norm = 1. / (2 * wc + 1);
625 for (i = 0; i < n; i++)
626 fad[i] = norm * (suma[width + i] - suma[i]);
651 l_int32 i, n, n1, width;
653 l_float32 *fa1, *fad, *suma;
656 PROCNAME(
"numaWindowedMeanSquare");
659 return (
NUMA *)ERROR_PTR(
"nas not defined", procName, NULL);
663 L_WARNING(
"filter wider than input array!\n", procName);
672 if ((suma = (l_float32 *)LEPT_CALLOC(n1 + 1,
sizeof(l_float32))) == NULL) {
675 return (
NUMA *)ERROR_PTR(
"suma not made", procName, NULL);
679 for (i = 0; i < n1; i++) {
680 sum += fa1[i] * fa1[i];
684 norm = 1. / (2 * wc + 1);
685 for (i = 0; i < n; i++)
686 fad[i] = norm * (suma[width + i] - suma[i]);
723 l_float32 *fam, *fams, *fav, *farv;
726 PROCNAME(
"numaWindowedVariance");
728 if (pnav) *pnav = NULL;
729 if (pnarv) *pnarv = NULL;
731 return ERROR_INT(
"neither &nav nor &narv are defined", procName, 1);
733 return ERROR_INT(
"nam not defined", procName, 1);
735 return ERROR_INT(
"nams not defined", procName, 1);
739 return ERROR_INT(
"sizes of nam and nams differ", procName, 1);
754 for (i = 0; i < nm; i++) {
755 var = fams[i] - fam[i] * fam[i];
759 farv[i] = sqrtf(var);
789 NUMA *na1, *na2, *nad;
791 PROCNAME(
"numaWindowedMedian");
794 return (
NUMA *)ERROR_PTR(
"nas not defined", procName, NULL);
798 L_ERROR(
"filter too small; returning a copy\n", procName);
802 if (halfwin > (n - 1) / 2) {
803 halfwin = (n - 1) / 2;
804 L_INFO(
"reducing filter to halfwin = %d\n", procName, halfwin);
813 for (i = 0; i < n; i++) {
838 PROCNAME(
"numaConvertToInt");
841 return (
NUMA *)ERROR_PTR(
"nas not defined", procName, NULL);
845 return (
NUMA *)ERROR_PTR(
"nad not made", procName, NULL);
847 for (i = 0; i < n; i++) {
890 l_int32 i, n, ival, hval;
891 l_int32 iminval, imaxval, range, binsize, nbins, ibin;
892 l_float32 val, ratio;
895 PROCNAME(
"numaMakeHistogram");
897 if (pbinsize) *pbinsize = 0;
898 if (pbinstart) *pbinstart = 0;
900 return (
NUMA *)ERROR_PTR(
"na not defined", procName, NULL);
902 return (
NUMA *)ERROR_PTR(
"maxbins < 1", procName, NULL);
906 iminval = (l_int32)(val + 0.5);
908 imaxval = (l_int32)(val + 0.5);
909 if (pbinstart == NULL) {
912 return (
NUMA *)ERROR_PTR(
"all values < 0", procName, NULL);
916 range = imaxval - iminval + 1;
917 if (range > maxbins - 1) {
918 ratio = (l_float64)range / (l_float64)maxbins;
920 for (i = 0; i < NBinSizes; i++) {
921 if (ratio < BinSizeArray[i]) {
922 binsize = BinSizeArray[i];
927 return (
NUMA *)ERROR_PTR(
"numbers too large", procName, NULL);
931 if (pbinsize) *pbinsize = binsize;
932 nbins = 1 + range / binsize;
935 if (pbinstart && binsize > 1) {
937 iminval = binsize * (iminval / binsize);
939 iminval = binsize * ((iminval - binsize + 1) / binsize);
941 if (pbinstart) *pbinstart = iminval;
944 lept_stderr(
" imaxval = %d, range = %d, nbins = %d\n",
945 imaxval, range, nbins);
950 return (
NUMA *)ERROR_PTR(
"nai not made", procName, NULL);
957 return (
NUMA *)ERROR_PTR(
"nahist not made", procName, NULL);
961 for (i = 0; i < n; i++) {
963 ibin = (ival - iminval) / binsize;
964 if (ibin >= 0 && ibin < nbins) {
1001 l_int32 i, n, imin, imax, irange, ibin, ival, allints;
1002 l_float32 minval, maxval, range, binsize, fval;
1005 PROCNAME(
"numaMakeHistogramAuto");
1008 return (
NUMA *)ERROR_PTR(
"na not defined", procName, NULL);
1009 maxbins = L_MAX(1, maxbins);
1020 if (allints && (maxval - minval < maxbins)) {
1021 imin = (l_int32)minval;
1022 imax = (l_int32)maxval;
1023 irange = imax - imin + 1;
1027 for (i = 0; i < n; i++) {
1038 range = maxval - minval;
1039 binsize = range / (l_float32)maxbins;
1049 for (i = 0; i < n; i++) {
1051 ibin = (l_int32)((fval - minval) / binsize);
1052 ibin = L_MIN(ibin, maxbins - 1);
1086 l_int32 i, n, nbins, ival, ibin;
1087 l_float32 val, maxval;
1090 PROCNAME(
"numaMakeHistogramClipped");
1093 return (
NUMA *)ERROR_PTR(
"na not defined", procName, NULL);
1095 return (
NUMA *)ERROR_PTR(
"binsize must be > 0.0", procName, NULL);
1096 if (binsize > maxsize)
1101 maxsize = L_MIN(maxsize, maxval);
1102 nbins = (l_int32)(maxsize / binsize) + 1;
1107 return (
NUMA *)ERROR_PTR(
"nad not made", procName, NULL);
1110 for (i = 0; i < n; i++) {
1112 ibin = (l_int32)(val / binsize);
1113 if (ibin >= 0 && ibin < nbins) {
1134 l_int32 i, j, ns, nd, index, count, val;
1135 l_float32 start, oldsize;
1138 PROCNAME(
"numaRebinHistogram");
1141 return (
NUMA *)ERROR_PTR(
"nas not defined", procName, NULL);
1143 return (
NUMA *)ERROR_PTR(
"newsize must be > 1", procName, NULL);
1145 return (
NUMA *)ERROR_PTR(
"no bins in nas", procName, NULL);
1147 nd = (ns + newsize - 1) / newsize;
1149 return (
NUMA *)ERROR_PTR(
"nad not made", procName, NULL);
1153 for (i = 0; i < nd; i++) {
1155 index = i * newsize;
1156 for (j = 0; j < newsize; j++) {
1183 l_float32 sum, factor, fval;
1186 PROCNAME(
"numaNormalizeHistogram");
1189 return (
NUMA *)ERROR_PTR(
"nas not defined", procName, NULL);
1191 return (
NUMA *)ERROR_PTR(
"tsum must be > 0.0", procName, NULL);
1193 return (
NUMA *)ERROR_PTR(
"no bins in nas", procName, NULL);
1196 factor = tsum / sum;
1199 return (
NUMA *)ERROR_PTR(
"nad not made", procName, NULL);
1202 for (i = 0; i < ns; i++) {
1266 l_float32 *pvariance,
1273 l_float32 minval, maxval, fval, mean, sum;
1276 PROCNAME(
"numaGetStatsUsingHistogram");
1278 if (pmin) *pmin = 0.0;
1279 if (pmax) *pmax = 0.0;
1280 if (pmean) *pmean = 0.0;
1281 if (pvariance) *pvariance = 0.0;
1282 if (pmedian) *pmedian = 0.0;
1283 if (prval) *prval = 0.0;
1284 if (phisto) *phisto = NULL;
1286 return ERROR_INT(
"na not defined", procName, 1);
1288 return ERROR_INT(
"numa is empty", procName, 1);
1292 if (pmin) *pmin = minval;
1293 if (pmax) *pmax = maxval;
1294 if (pmean || pvariance) {
1296 for (i = 0; i < n; i++) {
1300 mean = sum / (l_float32)n;
1301 if (pmean) *pmean = mean;
1305 for (i = 0; i < n; i++) {
1309 *pvariance = sum / (l_float32)n - mean * mean;
1312 if (!pmedian && !prval && !phisto)
1356 l_float32 *pxmedian,
1358 l_float32 *pxvariance)
1360 PROCNAME(
"numaGetHistogramStats");
1362 if (pxmean) *pxmean = 0.0;
1363 if (pxmedian) *pxmedian = 0.0;
1364 if (pxmode) *pxmode = 0.0;
1365 if (pxvariance) *pxvariance = 0.0;
1367 return ERROR_INT(
"nahisto not defined", procName, 1);
1370 pxmean, pxmedian, pxmode,
1407 l_float32 *pxmedian,
1409 l_float32 *pxvariance)
1412 l_float32 sum, sumval, halfsum, moment, var, x, y, ymax;
1414 PROCNAME(
"numaGetHistogramStatsOnInterval");
1416 if (pxmean) *pxmean = 0.0;
1417 if (pxmedian) *pxmedian = 0.0;
1418 if (pxmode) *pxmode = 0.0;
1419 if (pxvariance) *pxvariance = 0.0;
1421 return ERROR_INT(
"nahisto not defined", procName, 1);
1422 if (!pxmean && !pxmedian && !pxmode && !pxvariance)
1423 return ERROR_INT(
"nothing to compute", procName, 1);
1426 ifirst = L_MAX(0, ifirst);
1427 if (ilast < 0) ilast = n - 1;
1429 return ERROR_INT(
"invalid ifirst", procName, 1);
1431 L_WARNING(
"ilast = %d is beyond max index = %d; adjusting\n",
1432 procName, ilast, n - 1);
1436 return ERROR_INT(
"ifirst > ilast", procName, 1);
1437 for (sum = 0.0, moment = 0.0, var = 0.0, i = ifirst; i <= ilast ; i++) {
1438 x = startx + i * deltax;
1445 L_INFO(
"sum is 0\n", procName);
1450 *pxmean = moment / sum;
1452 *pxvariance = var / sum - moment * moment / (sum * sum);
1455 halfsum = sum / 2.0;
1456 for (sumval = 0.0, i = ifirst; i <= ilast; i++) {
1459 if (sumval >= halfsum) {
1460 *pxmedian = startx + i * deltax;
1469 for (i = ifirst; i <= ilast; i++) {
1476 *pxmode = startx + imax * deltax;
1503 l_float32 sum, fval;
1506 PROCNAME(
"numaMakeRankFromHistogram");
1508 if (pnax) *pnax = NULL;
1510 return ERROR_INT(
"&nay not defined", procName, 1);
1513 return ERROR_INT(
"nasy not defined", procName, 1);
1515 return ERROR_INT(
"no bins in nas", procName, 1);
1523 for (i = 0; i < n; i++) {
1532 startx, startx + n * deltax, npts,
1567 l_int32 i, ibinval, n;
1568 l_float32 startval, binsize, binval, maxval, fractval, total, sum, val;
1570 PROCNAME(
"numaHistogramGetRankFromVal");
1573 return ERROR_INT(
"prank not defined", procName, 1);
1576 return ERROR_INT(
"na not defined", procName, 1);
1579 if (rval < startval)
1581 maxval = startval + n * binsize;
1582 if (rval > maxval) {
1587 binval = (rval - startval) / binsize;
1588 ibinval = (l_int32)binval;
1593 fractval = binval - (l_float32)ibinval;
1596 for (i = 0; i < ibinval; i++) {
1601 sum += fractval * val;
1603 *prank = sum / total;
1639 l_float32 startval, binsize, rankcount, total, sum, fract, val;
1641 PROCNAME(
"numaHistogramGetValFromRank");
1644 return ERROR_INT(
"prval not defined", procName, 1);
1647 return ERROR_INT(
"na not defined", procName, 1);
1649 L_WARNING(
"rank < 0; setting to 0.0\n", procName);
1653 L_WARNING(
"rank > 1.0; setting to 1.0\n", procName);
1660 rankcount = rank * total;
1662 for (i = 0; i < n; i++) {
1664 if (sum + val >= rankcount)
1671 fract = (rankcount - sum) / val;
1675 *prval = startval + binsize * ((l_float32)i + fract);
1712 l_int32 i, ntot, count, bincount, binindex, binsize;
1713 l_float32 sum, val, ave;
1715 PROCNAME(
"numaDiscretizeSortedInBins");
1718 return ERROR_INT(
"&nabinval not defined", procName, 1);
1721 return ERROR_INT(
"na not defined", procName, 1);
1723 return ERROR_INT(
"nbins must be > 1", procName, 1);
1728 return ERROR_INT(
"naeach not made", procName, 1);
1736 for (i = 0; i < ntot; i++) {
1740 if (bincount == binsize) {
1741 ave = sum / binsize;
1746 if (binindex == nbins)
break;
1750 *pnabinval = nabinval;
1791 l_int32 i, j, k, nxvals, occup, count, bincount, binindex, binsize;
1792 l_float32 sum, ave, ntot;
1794 PROCNAME(
"numaDiscretizeHistoInBins");
1796 if (pnarank) *pnarank = NULL;
1798 return ERROR_INT(
"&nabinval not defined", procName, 1);
1801 return ERROR_INT(
"na not defined", procName, 1);
1803 return ERROR_INT(
"nbins must be > 1", procName, 1);
1807 occup = ntot / nxvals;
1808 if (occup < 1) L_INFO(
"average occupancy %d < 1\n", procName, occup);
1812 return ERROR_INT(
"naeach not made", procName, 1);
1821 for (i = 0; i < nxvals; i++) {
1823 for (j = 0; j < count; j++) {
1827 if (bincount == binsize) {
1828 ave = sum / binsize;
1833 if (binindex == nbins)
break;
1837 if (binindex == nbins)
break;
1839 *pnabinval = nabinval;
1840 if (binindex != nbins)
1841 L_ERROR(
"binindex = %d != nbins = %d\n", procName, binindex, nbins);
1879 l_int32 maxbins, type;
1880 l_float32 maxval, delx;
1882 PROCNAME(
"numaGetRankBinValues");
1885 return ERROR_INT(
"&pnam not defined", procName, 1);
1888 return ERROR_INT(
"na not defined", procName, 1);
1890 return ERROR_INT(
"na is empty", procName, 1);
1892 return ERROR_INT(
"nbins must be > 1", procName, 1);
1902 L_INFO(
"sort the array: input size = %d\n", procName,
numaGetCount(na));
1913 L_INFO(
"use a histogram: input size = %d\n", procName,
numaGetCount(na));
1915 maxbins = L_MIN(100002, (l_int32)maxval + 2);
1922 L_WARNING(
"scale change: delx = %6.2f\n", procName, delx);
1948 l_int32 i, start, end;
1951 PROCNAME(
"numaGetUniformBinSizes");
1954 return (
NUMA *)ERROR_PTR(
"ntotal <= 0", procName, NULL);
1956 return (
NUMA *)ERROR_PTR(
"nbins <= 0", procName, NULL);
1959 return (
NUMA *)ERROR_PTR(
"naeach not made", procName, NULL);
1961 for (i = 0; i < nbins; i++) {
1962 end = ntotal * (i + 1) / nbins;
2024 l_float32 scorefract,
2025 l_int32 *psplitindex,
2032 l_int32 i, n, bestsplit, minrange, maxrange, maxindex;
2033 l_float32 ave1, ave2, ave1prev, ave2prev;
2034 l_float32 num1, num2, num1prev, num2prev;
2035 l_float32 val, minval, sum, fract1;
2036 l_float32 norm, score, minscore, maxscore;
2037 NUMA *nascore, *naave1, *naave2, *nanum1, *nanum2;
2039 PROCNAME(
"numaSplitDistribution");
2041 if (psplitindex) *psplitindex = 0;
2042 if (pave1) *pave1 = 0.0;
2043 if (pave2) *pave2 = 0.0;
2044 if (pnum1) *pnum1 = 0.0;
2045 if (pnum2) *pnum2 = 0.0;
2046 if (pnascore) *pnascore = NULL;
2048 return ERROR_INT(
"na not defined", procName, 1);
2052 return ERROR_INT(
"n = 1 in histogram", procName, 1);
2055 return ERROR_INT(
"sum <= 0.0", procName, 1);
2056 norm = 4.0 / ((l_float32)(n - 1) * (n - 1));
2067 return ERROR_INT(
"nascore not made", procName, 1);
2073 for (i = 0; i < n; i++) {
2075 num1 = num1prev + val;
2079 ave1 = (num1prev * ave1prev + i * val) / num1;
2080 num2 = num2prev - val;
2084 ave2 = (num2prev * ave2prev - i * val) / num2;
2085 fract1 = num1 / sum;
2086 score = norm * (fract1 * (1 - fract1)) * (ave2 - ave1) * (ave2 - ave1);
2092 if (score > maxscore) {
2105 minscore = (1. - scorefract) * maxscore;
2106 for (i = maxindex - 1; i >= 0; i--) {
2112 for (i = maxindex + 1; i < n; i++) {
2119 bestsplit = minrange;
2120 for (i = minrange + 1; i <= maxrange; i++) {
2131 bestsplit = L_MIN(255, bestsplit + 1);
2133 if (psplitindex) *psplitindex = bestsplit;
2140 lept_stderr(
"minrange = %d, maxrange = %d\n", minrange, maxrange);
2143 "Score for split distribution");
2144 *pnascore = nascore;
2191 NUMA *na1, *na2, *nad;
2193 PROCNAME(
"grayHistogramsToEMD");
2196 return ERROR_INT(
"&nad not defined", procName, 1);
2199 return ERROR_INT(
"na1 and na2 not both defined", procName, 1);
2202 return ERROR_INT(
"naa1 and naa2 numa counts differ", procName, 1);
2205 return ERROR_INT(
"naa1 and naa2 number counts differ", procName, 1);
2207 return ERROR_INT(
"na sizes must be 256", procName, 1);
2211 for (i = 0; i < n; i++) {
2256 l_float32 sum1, sum2, diff, total;
2257 l_float32 *array1, *array3;
2260 PROCNAME(
"numaEarthMoverDistance");
2263 return ERROR_INT(
"&dist not defined", procName, 1);
2266 return ERROR_INT(
"na1 and na2 not both defined", procName, 1);
2269 return ERROR_INT(
"na1 and na2 have different size", procName, 1);
2274 norm = (L_ABS(sum1 - sum2) < 0.00001 * L_ABS(sum1)) ? 1 : 0;
2284 for (i = 1; i < n; i++) {
2285 diff = array1[i - 1] - array3[i - 1];
2287 total += L_ABS(diff);
2289 *pdist = total / sum1;
2349 l_int32 i, j, n, nn;
2351 l_float32 mean, var, rvar;
2352 NUMA *na1, *na2, *na3, *na4;
2354 PROCNAME(
"grayInterHistogramStats");
2356 if (pnam) *pnam = NULL;
2357 if (pnams) *pnams = NULL;
2358 if (pnav) *pnav = NULL;
2359 if (pnarv) *pnarv = NULL;
2360 if (!pnam && !pnams && !pnav && !pnarv)
2361 return ERROR_INT(
"nothing requested", procName, 1);
2363 return ERROR_INT(
"naa not defined", procName, 1);
2365 for (i = 0; i < n; i++) {
2368 L_ERROR(
"%d numbers in numa[%d]\n", procName, nn, i);
2380 arrays = (l_float32 **)LEPT_CALLOC(n,
sizeof(l_float32 *));
2381 for (i = 0; i < n; i++) {
2392 for (j = 0; j < 256; j++) {
2394 for (i = 0; i < n; i++) {
2405 for (i = 0; i < n; i++)
2406 LEPT_FREE(arrays[i]);
2437 l_int32 i, k, n, maxloc, lloc, rloc;
2438 l_float32 fmaxval, sum, total, newtotal, val, lastval;
2439 l_float32 peakfract;
2442 PROCNAME(
"numaFindPeaks");
2445 return (
NUMA *)ERROR_PTR(
"nas not defined", procName, NULL);
2451 return (
NUMA *)ERROR_PTR(
"na not made", procName, NULL);
2452 if ((napeak =
numaCreate(4 * nmax)) == NULL) {
2454 return (
NUMA *)ERROR_PTR(
"napeak not made", procName, NULL);
2457 for (k = 0; k < nmax; k++) {
2459 if (newtotal == 0.0)
2465 for (i = maxloc - 1; i >= 0; --i) {
2471 if (val > fract1 * fmaxval) {
2476 if (lastval - val > fract2 * lastval) {
2486 for (i = maxloc + 1; i < n; ++i) {
2492 if (val > fract1 * fmaxval) {
2497 if (lastval - val > fract2 * lastval) {
2505 peakfract = sum / total;
2511 for (i = lloc; i <= rloc; i++)
2554 l_int32 i, n, found, loc, direction;
2555 l_float32 startval, val, maxval, minval;
2558 PROCNAME(
"numaFindExtrema");
2560 if (pnav) *pnav = NULL;
2562 return (
NUMA *)ERROR_PTR(
"nas not defined", procName, NULL);
2564 return (
NUMA *)ERROR_PTR(
"delta < 0", procName, NULL);
2579 for (i = 1; i < n; i++) {
2581 if (L_ABS(val - startval) >= delta) {
2591 if (val > startval) {
2602 for (i = i + 1; i < n; i++) {
2604 if (direction == 1 && val > maxval ) {
2607 }
else if (direction == -1 && val < minval ) {
2610 }
else if (direction == 1 && (maxval - val >= delta)) {
2616 }
else if (direction == -1 && (val - minval >= delta)) {
2662 l_int32 i, n, start, index, minloc;
2663 l_float32 val, pval, jval, minval, sum, partsum;
2666 PROCNAME(
"numaFindLocForThreshold");
2668 if (pfract) *pfract = 0.0;
2670 return ERROR_INT(
"&thresh not defined", procName, 1);
2673 return ERROR_INT(
"na not defined", procName, 1);
2674 if (skip <= 0) skip = 20;
2680 for (i = 1; i < n; i++) {
2682 index = L_MIN(i + skip, n - 1);
2684 if (val < pval && jval < pval)
2692 for (i = start + 1; i < n; i++) {
2697 index = L_MIN(i + skip, n - 1);
2711 for (i = index - 1; i > index - skip; i--) {
2712 if (fa[i] < minval) {
2724 *pfract = partsum / sum;
2753 l_float32 minreversal,
2757 l_int32 i, n, nr, ival, binvals;
2759 l_float32 fval, delx, len;
2762 PROCNAME(
"numaCountReversals");
2765 if (prd) *prd = 0.0;
2767 return ERROR_INT(
"neither &nr nor &rd are defined", procName, 1);
2769 return ERROR_INT(
"nas not defined", procName, 1);
2771 L_INFO(
"nas is empty\n", procName);
2774 if (minreversal < 0.0)
2775 return ERROR_INT(
"minreversal < 0", procName, 1);
2779 for (i = 0; i < n; i++) {
2781 if (fval != 0.0 && fval != 1.0) {
2789 if (minreversal > 1.0) {
2790 L_WARNING(
"binary values but minreversal > 1\n", procName);
2794 for (i = 1; i < n; i++) {
2795 if (ia[i] != ival) {
2811 *prd = (l_float32)nr / len;
2850 l_float32 estthresh,
2851 l_float32 *pbestthresh)
2853 l_int32 i, inrun, istart, iend, maxstart, maxend, runlen, maxrunlen;
2854 l_int32 val, maxval, nmax, count;
2855 l_float32 thresh, fmaxval, fmodeval;
2858 PROCNAME(
"numaSelectCrossingThreshold");
2861 return ERROR_INT(
"&bestthresh not defined", procName, 1);
2864 return ERROR_INT(
"nay not defined", procName, 1);
2866 L_WARNING(
"nay count < 2; no threshold crossing\n", procName);
2872 for (i = 0; i < 41; i++) {
2873 thresh = estthresh - 80.0 + 4.0 * i;
2882 maxval = (l_int32)fmaxval;
2884 for (i = 0; i < 41; i++) {
2891 if (count > nmax && fmodeval > 0.5 * fmaxval)
2892 maxval = (l_int32)fmodeval;
2897 maxrunlen = 0, maxstart = 0, maxend = 0;
2898 for (i = 0; i < 41; i++) {
2900 if (val == maxval) {
2907 if (inrun && (val != maxval)) {
2909 runlen = iend - istart + 1;
2911 if (runlen > maxrunlen) {
2919 runlen = i - istart;
2920 if (runlen > maxrunlen) {
2927 *pbestthresh = estthresh - 80.0 + 2.0 * (l_float32)(maxstart + maxend);
2930 lept_stderr(
"\nCrossings attain a maximum at %d thresholds, between:\n" 2931 " thresh[%d] = %5.1f and thresh[%d] = %5.1f\n",
2932 nmax, maxstart, estthresh - 80.0 + 4.0 * maxstart,
2933 maxend, estthresh - 80.0 + 4.0 * maxend);
2934 lept_stderr(
"The best choice: %5.1f\n", *pbestthresh);
2935 lept_stderr(
"Number of crossings at the 41 thresholds:");
2964 l_float32 startx, delx;
2965 l_float32 xval1, xval2, yval1, yval2, delta1, delta2, crossval, fract;
2968 PROCNAME(
"numaCrossingsByThreshold");
2971 return (
NUMA *)ERROR_PTR(
"nay not defined", procName, NULL);
2975 return (
NUMA *)ERROR_PTR(
"nax and nay sizes differ", procName, NULL);
2978 if (n < 2)
return nad;
2985 for (i = 1; i < n; i++) {
2990 xval2 = startx + i * delx;
2991 delta1 = yval1 - thresh;
2992 delta2 = yval2 - thresh;
2993 if (delta1 == 0.0) {
2995 }
else if (delta2 == 0.0) {
2997 }
else if (delta1 * delta2 < 0.0) {
2998 fract = L_ABS(delta1) / L_ABS(yval1 - yval2);
2999 crossval = xval1 + fract * (xval2 - xval1);
3029 l_int32 i, j, n, np, previndex, curindex;
3030 l_float32 startx, delx;
3031 l_float32 xval1, xval2, yval1, yval2, delta1, delta2;
3032 l_float32 prevval, curval, thresh, crossval, fract;
3035 PROCNAME(
"numaCrossingsByPeaks");
3038 return (
NUMA *)ERROR_PTR(
"nay not defined", procName, NULL);
3042 return (
NUMA *)ERROR_PTR(
"nax and nay sizes differ", procName, NULL);
3050 L_INFO(
"Number of crossings: %d\n", procName, np);
3057 for (i = 0; i < np; i++) {
3060 thresh = (prevval + curval) / 2.0;
3064 xval1 = startx + previndex * delx;
3066 for (j = previndex + 1; j <= curindex; j++) {
3070 xval2 = startx + j * delx;
3072 delta1 = yval1 - thresh;
3073 delta2 = yval2 - thresh;
3074 if (delta1 == 0.0) {
3077 }
else if (delta2 == 0.0) {
3080 }
else if (delta1 * delta2 < 0.0) {
3081 fract = L_ABS(delta1) / L_ABS(yval1 - yval2);
3082 crossval = xval1 + fract * (xval2 - xval1);
3089 previndex = curindex;
3137 l_float32 relweight,
3142 l_float32 *pbestwidth,
3143 l_float32 *pbestshift,
3144 l_float32 *pbestscore)
3147 l_float32 delwidth, delshift, width, shift, score;
3148 l_float32 bestwidth, bestshift, bestscore;
3150 PROCNAME(
"numaEvalBestHaarParameters");
3152 if (pbestscore) *pbestscore = 0.0;
3153 if (pbestwidth) *pbestwidth = 0.0;
3154 if (pbestshift) *pbestshift = 0.0;
3155 if (!pbestwidth || !pbestshift)
3156 return ERROR_INT(
"&bestwidth and &bestshift not defined", procName, 1);
3158 return ERROR_INT(
"nas not defined", procName, 1);
3160 bestscore = bestwidth = bestshift = 0.0;
3161 delwidth = (maxwidth - minwidth) / (nwidth - 1.0);
3162 for (i = 0; i < nwidth; i++) {
3163 width = minwidth + delwidth * i;
3164 delshift = width / (l_float32)(nshift);
3165 for (j = 0; j < nshift; j++) {
3166 shift = j * delshift;
3168 if (score > bestscore) {
3173 lept_stderr(
"width = %7.3f, shift = %7.3f, score = %7.3f\n",
3174 width, shift, score);
3180 *pbestwidth = bestwidth;
3181 *pbestshift = bestshift;
3183 *pbestscore = bestscore;
3224 l_float32 relweight,
3227 l_int32 i, n, nsamp, index;
3228 l_float32 score, weight, val;
3230 PROCNAME(
"numaEvalHaarSum");
3233 return ERROR_INT(
"&score not defined", procName, 1);
3236 return ERROR_INT(
"nas not defined", procName, 1);
3238 return ERROR_INT(
"nas size too small", procName, 1);
3241 nsamp = (l_int32)((n - shift) / width);
3242 for (i = 0; i < nsamp; i++) {
3243 index = (l_int32)(shift + i * width);
3244 weight = (i % 2) ? 1.0 : -1.0 * relweight;
3246 score += weight * val;
3249 *pscore = 2.0 * width * score / (l_float32)n;
3283 l_int32 i, nsets, val;
3287 PROCNAME(
"genConstrainedNumaInRange");
3289 first = L_MAX(0, first);
3291 return (
NUMA *)ERROR_PTR(
"last < first!", procName, NULL);
3293 return (
NUMA *)ERROR_PTR(
"nmax < 1!", procName, NULL);
3295 nsets = L_MIN(nmax, last - first + 1);
3299 return (
NUMA *)ERROR_PTR(
"nsets == 0", procName, NULL);
3306 delta = (l_float32)(last - first) / (nsets - 1);
3308 delta = (l_float32)(last - first - 1) / (nsets - 1);
3312 for (i = 0; i < nsets; i++) {
3313 val = (l_int32)(first + i * delta + 0.5);
l_ok numaGetSum(NUMA *na, l_float32 *psum)
numaGetSum()
l_ok numaGetFValue(NUMA *na, l_int32 index, l_float32 *pval)
numaGetFValue()
l_ok numaDiscretizeHistoInBins(NUMA *na, l_int32 nbins, NUMA **pnabinval, NUMA **pnarank)
numaDiscretizeHistoInBins()
NUMA * numaFindExtrema(NUMA *nas, l_float32 delta, NUMA **pnav)
numaFindExtrema()
l_ok numaHasOnlyIntegers(NUMA *na, l_int32 *pallints)
numaHasOnlyIntegers()
NUMA * numaDilate(NUMA *nas, l_int32 size)
numaDilate()
l_ok numaGetRankBinValues(NUMA *na, l_int32 nbins, NUMA **pnam)
numaGetRankBinValues()
NUMA * numaCrossingsByPeaks(NUMA *nax, NUMA *nay, l_float32 delta)
numaCrossingsByPeaks()
NUMA * numaConvertToInt(NUMA *nas)
numaConvertToInt()
NUMA * numaMakeHistogram(NUMA *na, l_int32 maxbins, l_int32 *pbinsize, l_int32 *pbinstart)
numaMakeHistogram()
l_ok numaSimpleStats(NUMA *na, l_int32 first, l_int32 last, l_float32 *pmean, l_float32 *pvar, l_float32 *prvar)
numaSimpleStats()
l_ok numaAddNumber(NUMA *na, l_float32 val)
numaAddNumber()
NUMA * numaFindPeaks(NUMA *nas, l_int32 nmax, l_float32 fract1, l_float32 fract2)
numaFindPeaks()
l_int32 numaaGetNumberCount(NUMAA *naa)
numaaGetNumberCount()
NUMA * numaRebinHistogram(NUMA *nas, l_int32 newsize)
numaRebinHistogram()
l_ok numaFindLocForThreshold(NUMA *na, l_int32 skip, l_int32 *pthresh, l_float32 *pfract)
numaFindLocForThreshold()
l_ok numaEarthMoverDistance(NUMA *na1, NUMA *na2, l_float32 *pdist)
numaEarthMoverDistance()
l_ok numaDiscretizeSortedInBins(NUMA *na, l_int32 nbins, NUMA **pnabinval)
numaDiscretizeSortedInBins()
l_ok numaCopyParameters(NUMA *nad, NUMA *nas)
numaCopyParameters()
l_ok numaGetMedian(NUMA *na, l_float32 *pval)
numaGetMedian()
NUMA * numaMakeConstant(l_float32 val, l_int32 size)
numaMakeConstant()
void lept_stderr(const char *fmt,...)
lept_stderr()
NUMA * numaSort(NUMA *naout, NUMA *nain, l_int32 sortorder)
numaSort()
NUMA * numaErode(NUMA *nas, l_int32 size)
numaErode()
l_int32 numaChooseSortType(NUMA *nas)
numaChooseSortType()
NUMA * numaMakeHistogramClipped(NUMA *na, l_float32 binsize, l_float32 maxsize)
numaMakeHistogramClipped()
l_ok numaSplitDistribution(NUMA *na, l_float32 scorefract, l_int32 *psplitindex, l_float32 *pave1, l_float32 *pave2, l_float32 *pnum1, l_float32 *pnum2, NUMA **pnascore)
numaSplitDistribution()
NUMA * numaCreate(l_int32 n)
numaCreate()
l_ok numaSetCount(NUMA *na, l_int32 newcount)
numaSetCount()
NUMA * numaWindowedMedian(NUMA *nas, l_int32 halfwin)
numaWindowedMedian()
NUMA * numaClipToInterval(NUMA *nas, l_int32 first, l_int32 last)
numaClipToInterval()
NUMA * numaGetPartialSums(NUMA *na)
numaGetPartialSums()
l_ok numaSetValue(NUMA *na, l_int32 index, l_float32 val)
numaSetValue()
NUMA * numaRemoveBorder(NUMA *nas, l_int32 left, l_int32 right)
numaRemoveBorder()
l_ok numaSelectCrossingThreshold(NUMA *nax, NUMA *nay, l_float32 estthresh, l_float32 *pbestthresh)
numaSelectCrossingThreshold()
l_ok numaGetHistogramStats(NUMA *nahisto, l_float32 startx, l_float32 deltax, l_float32 *pxmean, l_float32 *pxmedian, l_float32 *pxmode, l_float32 *pxvariance)
numaGetHistogramStats()
l_int32 * numaGetIArray(NUMA *na)
numaGetIArray()
l_ok numaCountReversals(NUMA *nas, l_float32 minreversal, l_int32 *pnr, l_float32 *prd)
numaCountReversals()
NUMA * genConstrainedNumaInRange(l_int32 first, l_int32 last, l_int32 nmax, l_int32 use_pairs)
genConstrainedNumaInRange()
NUMA * numaaGetNuma(NUMAA *naa, l_int32 index, l_int32 accessflag)
numaaGetNuma()
NUMA * numaClose(NUMA *nas, l_int32 size)
numaClose()
NUMA * numaGetUniformBinSizes(l_int32 ntotal, l_int32 nbins)
numaGetUniformBinSizes()
l_ok numaGetIValue(NUMA *na, l_int32 index, l_int32 *pival)
numaGetIValue()
l_int32 numaGetCount(NUMA *na)
numaGetCount()
l_ok numaGetMode(NUMA *na, l_float32 *pval, l_int32 *pcount)
numaGetMode()
l_ok numaInterpolateEqxInterval(l_float32 startx, l_float32 deltax, NUMA *nasy, l_int32 type, l_float32 x0, l_float32 x1, l_int32 npts, NUMA **pnax, NUMA **pnay)
numaInterpolateEqxInterval()
l_ok numaSetParameters(NUMA *na, l_float32 startx, l_float32 delx)
numaSetParameters()
NUMA * numaAddSpecifiedBorder(NUMA *nas, l_int32 left, l_int32 right, l_int32 type)
numaAddSpecifiedBorder()
NUMA * numaWindowedMeanSquare(NUMA *nas, l_int32 wc)
numaWindowedMeanSquare()
NUMA * numaOpen(NUMA *nas, l_int32 size)
numaOpen()
l_ok numaWindowedStats(NUMA *nas, l_int32 wc, NUMA **pnam, NUMA **pnams, NUMA **pnav, NUMA **pnarv)
numaWindowedStats()
l_ok numaGetParameters(NUMA *na, l_float32 *pstartx, l_float32 *pdelx)
numaGetParameters()
NUMA * numaMakeHistogramAuto(NUMA *na, l_int32 maxbins)
numaMakeHistogramAuto()
l_ok numaHistogramGetValFromRank(NUMA *na, l_float32 rank, l_float32 *prval)
numaHistogramGetValFromRank()
NUMA * numaCopy(NUMA *na)
numaCopy()
l_ok numaEvalBestHaarParameters(NUMA *nas, l_float32 relweight, l_int32 nwidth, l_int32 nshift, l_float32 minwidth, l_float32 maxwidth, l_float32 *pbestwidth, l_float32 *pbestshift, l_float32 *pbestscore)
numaEvalBestHaarParameters()
l_ok numaGetHistogramStatsOnInterval(NUMA *nahisto, l_float32 startx, l_float32 deltax, l_int32 ifirst, l_int32 ilast, l_float32 *pxmean, l_float32 *pxmedian, l_float32 *pxmode, l_float32 *pxvariance)
numaGetHistogramStatsOnInterval()
NUMA * numaAddBorder(NUMA *nas, l_int32 left, l_int32 right, l_float32 val)
numaAddBorder()
l_ok numaMakeRankFromHistogram(l_float32 startx, l_float32 deltax, NUMA *nasy, l_int32 npts, NUMA **pnax, NUMA **pnay)
numaMakeRankFromHistogram()
void numaDestroy(NUMA **pna)
numaDestroy()
NUMA * numaCrossingsByThreshold(NUMA *nax, NUMA *nay, l_float32 thresh)
numaCrossingsByThreshold()
l_ok numaGetMin(NUMA *na, l_float32 *pminval, l_int32 *piminloc)
numaGetMin()
NUMA * numaTransform(NUMA *nas, l_float32 shift, l_float32 scale)
numaTransform()
l_ok numaHistogramGetRankFromVal(NUMA *na, l_float32 rval, l_float32 *prank)
numaHistogramGetRankFromVal()
NUMA * numaWindowedMean(NUMA *nas, l_int32 wc)
numaWindowedMean()
l_float32 * numaGetFArray(NUMA *na, l_int32 copyflag)
numaGetFArray()
l_int32 numaaGetCount(NUMAA *naa)
numaaGetCount()
l_int32 numaaGetNumaCount(NUMAA *naa, l_int32 index)
numaaGetNumaCount()
l_ok grayHistogramsToEMD(NUMAA *naa1, NUMAA *naa2, NUMA **pnad)
grayHistogramsToEMD()
l_ok numaWindowedVariance(NUMA *nam, NUMA *nams, NUMA **pnav, NUMA **pnarv)
numaWindowedVariance()
NUMA * numaNormalizeHistogram(NUMA *nas, l_float32 tsum)
numaNormalizeHistogram()
l_ok numaGetMax(NUMA *na, l_float32 *pmaxval, l_int32 *pimaxloc)
numaGetMax()
l_ok grayInterHistogramStats(NUMAA *naa, l_int32 wc, NUMA **pnam, NUMA **pnams, NUMA **pnav, NUMA **pnarv)
grayInterHistogramStats()
l_ok numaEvalHaarSum(NUMA *nas, l_float32 width, l_float32 shift, l_float32 relweight, l_float32 *pscore)
numaEvalHaarSum()
l_ok numaGetSumOnInterval(NUMA *na, l_int32 first, l_int32 last, l_float32 *psum)
numaGetSumOnInterval()
l_ok numaWriteStderr(NUMA *na)
numaWriteStderr()
l_ok gplotSimple1(NUMA *na, l_int32 outformat, const char *outroot, const char *title)
gplotSimple1()
l_ok numaGetStatsUsingHistogram(NUMA *na, l_int32 maxbins, l_float32 *pmin, l_float32 *pmax, l_float32 *pmean, l_float32 *pvariance, l_float32 *pmedian, l_float32 rank, l_float32 *prval, NUMA **phisto)
numaGetStatsUsingHistogram()