88 #include <config_auto.h> 92 #include "allheaders.h" 97 LEPT_DLL l_int32 ConvolveSamplingFactX = 1;
98 LEPT_DLL l_int32 ConvolveSamplingFactY = 1;
101 static void blockconvLow(l_uint32 *data, l_int32 w, l_int32 h, l_int32 wpl,
102 l_uint32 *dataa, l_int32 wpla, l_int32 wc,
104 static void blockconvAccumLow(l_uint32 *datad, l_int32 w, l_int32 h,
105 l_int32 wpld, l_uint32 *datas, l_int32 d,
107 static void blocksumLow(l_uint32 *datad, l_int32 w, l_int32 h, l_int32 wpl,
108 l_uint32 *dataa, l_int32 wpla, l_int32 wc, l_int32 hc);
137 PIX *pixs, *pixd, *pixr, *pixrc, *pixg, *pixgc, *pixb, *pixbc;
139 PROCNAME(
"pixBlockconv");
142 return (
PIX *)ERROR_PTR(
"pix not defined", procName, NULL);
143 if (wc <= 0 || hc <= 0)
146 if (w < 2 * wc + 1 || h < 2 * hc + 1) {
147 L_WARNING(
"kernel too large: wc = %d, hc = %d, w = %d, h = %d; " 148 "reducing!\n", procName, wc, hc, w, h);
149 wc = L_MIN(wc, (w - 1) / 2);
150 hc = L_MIN(hc, (h - 1) / 2);
152 if (wc == 0 || hc == 0)
156 if ((d == 2 || d == 4 || d == 8) && pixGetColormap(pix)) {
157 L_WARNING(
"pix has colormap; removing\n", procName);
159 d = pixGetDepth(pixs);
164 if (d != 8 && d != 32) {
166 return (
PIX *)ERROR_PTR(
"depth not 8 or 32 bpp", procName, NULL);
221 l_int32 w, h, d, wpl, wpla;
222 l_uint32 *datad, *dataa;
225 PROCNAME(
"pixBlockconvGray");
228 return (
PIX *)ERROR_PTR(
"pixs not defined", procName, NULL);
231 return (
PIX *)ERROR_PTR(
"pixs not 8 bpp", procName, NULL);
232 if (wc <= 0 || hc <= 0)
234 if (w < 2 * wc + 1 || h < 2 * hc + 1) {
235 L_WARNING(
"kernel too large: wc = %d, hc = %d, w = %d, h = %d; " 236 "reducing!\n", procName, wc, hc, w, h);
237 wc = L_MIN(wc, (w - 1) / 2);
238 hc = L_MIN(hc, (h - 1) / 2);
240 if (wc == 0 || hc == 0)
244 if (pixGetDepth(pixacc) == 32) {
247 L_WARNING(
"pixacc not 32 bpp; making new one\n", procName);
249 return (
PIX *)ERROR_PTR(
"pixt not made", procName, NULL);
253 return (
PIX *)ERROR_PTR(
"pixt not made", procName, NULL);
258 return (
PIX *)ERROR_PTR(
"pixd not made", procName, NULL);
262 wpl = pixGetWpl(pixd);
263 wpla = pixGetWpl(pixt);
330 l_int32 i, j, imax, imin, jmax, jmin;
331 l_int32 wn, hn, fwc, fhc, wmwc, hmhc;
332 l_float32 norm, normh, normw;
334 l_uint32 *linemina, *linemaxa, *line;
336 PROCNAME(
"blockconvLow");
340 if (wmwc <= 0 || hmhc <= 0) {
341 L_ERROR(
"wc >= w || hc >=h\n", procName);
346 norm = 1.0 / ((l_float32)(fwc) * fhc);
351 for (i = 0; i < h; i++) {
352 imin = L_MAX(i - 1 - hc, 0);
353 imax = L_MIN(i + hc, h - 1);
354 line = data + wpl * i;
355 linemina = dataa + wpla * imin;
356 linemaxa = dataa + wpla * imax;
357 for (j = 0; j < w; j++) {
358 jmin = L_MAX(j - 1 - wc, 0);
359 jmax = L_MIN(j + wc, w - 1);
360 val = linemaxa[jmax] - linemaxa[jmin]
361 + linemina[jmin] - linemina[jmax];
362 val = (l_uint8)(norm * val + 0.5);
370 for (i = 0; i <= hc; i++) {
371 hn = L_MAX(1, hc + i);
372 normh = (l_float32)fhc / (l_float32)hn;
373 line = data + wpl * i;
374 for (j = 0; j <= wc; j++) {
375 wn = L_MAX(1, wc + j);
376 normw = (l_float32)fwc / (l_float32)wn;
378 val = (l_uint8)L_MIN(val * normh * normw, 255);
381 for (j = wc + 1; j < wmwc; j++) {
383 val = (l_uint8)L_MIN(val * normh, 255);
386 for (j = wmwc; j < w; j++) {
388 normw = (l_float32)fwc / (l_float32)wn;
390 val = (l_uint8)L_MIN(val * normh * normw, 255);
395 for (i = hmhc; i < h; i++) {
397 normh = (l_float32)fhc / (l_float32)hn;
398 line = data + wpl * i;
399 for (j = 0; j <= wc; j++) {
401 normw = (l_float32)fwc / (l_float32)wn;
403 val = (l_uint8)L_MIN(val * normh * normw, 255);
406 for (j = wc + 1; j < wmwc; j++) {
408 val = (l_uint8)L_MIN(val * normh, 255);
411 for (j = wmwc; j < w; j++) {
413 normw = (l_float32)fwc / (l_float32)wn;
415 val = (l_uint8)L_MIN(val * normh * normw, 255);
420 for (i = hc + 1; i < hmhc; i++) {
421 line = data + wpl * i;
422 for (j = 0; j <= wc; j++) {
424 normw = (l_float32)fwc / (l_float32)wn;
426 val = (l_uint8)L_MIN(val * normw, 255);
429 for (j = wmwc; j < w; j++) {
431 normw = (l_float32)fwc / (l_float32)wn;
433 val = (l_uint8)L_MIN(val * normw, 255);
462 l_int32 w, h, d, wpls, wpld;
463 l_uint32 *datas, *datad;
466 PROCNAME(
"pixBlockconvAccum");
469 return (
PIX *)ERROR_PTR(
"pixs not defined", procName, NULL);
472 if (d != 1 && d != 8 && d != 32)
473 return (
PIX *)ERROR_PTR(
"pixs not 1, 8 or 32 bpp", procName, NULL);
474 if ((pixd =
pixCreate(w, h, 32)) == NULL)
475 return (
PIX *)ERROR_PTR(
"pixd not made", procName, NULL);
479 wpls = pixGetWpl(pixs);
480 wpld = pixGetWpl(pixd);
481 blockconvAccumLow(datad, w, h, wpld, datas, d, wpls);
508 blockconvAccumLow(l_uint32 *datad,
519 l_uint32 *lines, *lined, *linedp;
521 PROCNAME(
"blockconvAccumLow");
528 for (j = 0; j < w; j++) {
533 lined[j] = lined[j - 1] + val;
537 for (i = 1; i < h; i++) {
538 lines = datas + i * wpls;
539 lined = datad + i * wpld;
540 linedp = lined - wpld;
541 for (j = 0; j < w; j++) {
544 lined[0] = val + linedp[0];
546 lined[j] = val + lined[j - 1] + linedp[j] - linedp[j - 1];
551 for (j = 0; j < w; j++) {
556 lined[j] = lined[j - 1] + val;
560 for (i = 1; i < h; i++) {
561 lines = datas + i * wpls;
562 lined = datad + i * wpld;
563 linedp = lined - wpld;
564 for (j = 0; j < w; j++) {
567 lined[0] = val + linedp[0];
569 lined[j] = val + lined[j - 1] + linedp[j] - linedp[j - 1];
572 }
else if (d == 32) {
574 for (j = 0; j < w; j++) {
579 lined[j] = lined[j - 1] + val32;
583 for (i = 1; i < h; i++) {
584 lines = datas + i * wpls;
585 lined = datad + i * wpld;
586 linedp = lined - wpld;
587 for (j = 0; j < w; j++) {
590 lined[0] = val32 + linedp[0];
592 lined[j] = val32 + lined[j - 1] + linedp[j] - linedp[j - 1];
596 L_ERROR(
"depth not 1, 8 or 32 bpp\n", procName);
646 l_int32 i, j, w, h, d, wpla, wpld, jmax;
647 l_uint32 *linemina, *linemaxa, *lined, *dataa, *datad;
648 PIX *pixsb, *pixacc, *pixd;
650 PROCNAME(
"pixBlockconvGrayUnnormalized");
653 return (
PIX *)ERROR_PTR(
"pixs not defined", procName, NULL);
656 return (
PIX *)ERROR_PTR(
"pixs not 8 bpp", procName, NULL);
657 if (wc <= 0 || hc <= 0)
659 if (w < 2 * wc + 1 || h < 2 * hc + 1) {
660 L_WARNING(
"kernel too large: wc = %d, hc = %d, w = %d, h = %d; " 661 "reducing!\n", procName, wc, hc, w, h);
662 wc = L_MIN(wc, (w - 1) / 2);
663 hc = L_MIN(hc, (h - 1) / 2);
665 if (wc == 0 || hc == 0)
669 return (
PIX *)ERROR_PTR(
"pixsb not made", procName, NULL);
673 return (
PIX *)ERROR_PTR(
"pixacc not made", procName, NULL);
674 if ((pixd =
pixCreate(w, h, 32)) == NULL) {
676 return (
PIX *)ERROR_PTR(
"pixd not made", procName, NULL);
679 wpla = pixGetWpl(pixacc);
680 wpld = pixGetWpl(pixd);
683 for (i = 0; i < h; i++) {
684 lined = datad + i * wpld;
685 linemina = dataa + i * wpla;
686 linemaxa = dataa + (i + 2 * hc + 1) * wpla;
687 for (j = 0; j < w; j++) {
688 jmax = j + 2 * wc + 1;
689 lined[j] = linemaxa[jmax] - linemaxa[j] -
690 linemina[jmax] + linemina[j];
740 l_int32 i, j, w, h, d, xrat, yrat;
741 PIX *pixs, *pixd, *pixc, *pixt;
742 PIX *pixr, *pixrc, *pixg, *pixgc, *pixb, *pixbc;
745 PROCNAME(
"pixBlockconvTiled");
748 return (
PIX *)ERROR_PTR(
"pix not defined", procName, NULL);
749 if (wc <= 0 || hc <= 0)
751 if (nx <= 1 && ny <= 1)
754 if (w < 2 * wc + 3 || h < 2 * hc + 3) {
755 L_WARNING(
"kernel too large: wc = %d, hc = %d, w = %d, h = %d; " 756 "reducing!\n", procName, wc, hc, w, h);
757 wc = L_MIN(wc, (w - 1) / 2);
758 hc = L_MIN(hc, (h - 1) / 2);
760 if (wc == 0 || hc == 0)
770 L_WARNING(
"tile width too small; nx reduced to %d\n", procName, nx);
774 L_WARNING(
"tile height too small; ny reduced to %d\n", procName, ny);
778 if ((d == 2 || d == 4 || d == 8) && pixGetColormap(pix)) {
779 L_WARNING(
"pix has colormap; removing\n", procName);
781 d = pixGetDepth(pixs);
786 if (d != 8 && d != 32) {
788 return (
PIX *)ERROR_PTR(
"depth not 8 or 32 bpp", procName, NULL);
800 return (
PIX *)ERROR_PTR(
"pixd not made", procName, NULL);
803 for (i = 0; i < ny; i++) {
804 for (j = 0; j < nx; j++) {
866 l_int32 w, h, d, wd, hd, i, j, imin, imax, jmin, jmax, wplt, wpld;
869 l_uint32 *datat, *datad, *lined, *linemint, *linemaxt;
872 PROCNAME(
"pixBlockconvGrayTile");
875 return (
PIX *)ERROR_PTR(
"pix not defined", procName, NULL);
878 return (
PIX *)ERROR_PTR(
"pixs not 8 bpp", procName, NULL);
879 if (wc <= 0 || hc <= 0)
881 if (w < 2 * wc + 3 || h < 2 * hc + 3) {
882 L_WARNING(
"kernel too large: wc = %d, hc = %d, w = %d, h = %d; " 883 "reducing!\n", procName, wc, hc, w, h);
884 wc = L_MIN(wc, (w - 1) / 2);
885 hc = L_MIN(hc, (h - 1) / 2);
887 if (wc == 0 || hc == 0)
893 if (pixGetDepth(pixacc) == 32) {
896 L_WARNING(
"pixacc not 32 bpp; making new one\n", procName);
898 return (
PIX *)ERROR_PTR(
"pixt not made", procName, NULL);
902 return (
PIX *)ERROR_PTR(
"pixt not made", procName, NULL);
907 return (
PIX *)ERROR_PTR(
"pixd not made", procName, NULL);
910 wplt = pixGetWpl(pixt);
912 wpld = pixGetWpl(pixd);
913 norm = 1. / (l_float32)((2 * wc + 1) * (2 * hc + 1));
924 for (i = hc; i < hc + hd - 2; i++) {
925 imin = L_MAX(i - hc - 1, 0);
926 imax = L_MIN(i + hc, h - 1);
927 lined = datad + i * wpld;
928 linemint = datat + imin * wplt;
929 linemaxt = datat + imax * wplt;
930 for (j = wc; j < wc + wd - 2; j++) {
931 jmin = L_MAX(j - wc - 1, 0);
932 jmax = L_MIN(j + wc, w - 1);
933 val = linemaxt[jmax] - linemaxt[jmin]
934 + linemint[jmin] - linemint[jmax];
935 val = (l_uint8)(norm * val + 0.5);
997 PIX *pixb, *pixm, *pixms;
999 PROCNAME(
"pixWindowedStats");
1001 if (!ppixm && !ppixms && !pfpixv && !pfpixrv)
1002 return ERROR_INT(
"no output requested", procName, 1);
1003 if (ppixm) *ppixm = NULL;
1004 if (ppixms) *ppixms = NULL;
1005 if (pfpixv) *pfpixv = NULL;
1006 if (pfpixrv) *pfpixrv = NULL;
1007 if (!pixs || pixGetDepth(pixs) != 8)
1008 return ERROR_INT(
"pixs not defined or not 8 bpp", procName, 1);
1009 if (wc < 2 || hc < 2)
1010 return ERROR_INT(
"wc and hc not >= 2", procName, 1);
1018 if (!pfpixv && !pfpixrv) {
1079 l_int32 i, j, w, h, d, wd, hd, wplc, wpld, wincr, hincr;
1081 l_uint32 *datac, *datad, *linec1, *linec2, *lined;
1083 PIX *pixb, *pixc, *pixd;
1085 PROCNAME(
"pixWindowedMean");
1088 return (
PIX *)ERROR_PTR(
"pixs not defined", procName, NULL);
1089 d = pixGetDepth(pixs);
1090 if (d != 8 && d != 32)
1091 return (
PIX *)ERROR_PTR(
"pixs not 8 or 32 bpp", procName, NULL);
1092 if (wc < 2 || hc < 2)
1093 return (
PIX *)ERROR_PTR(
"wc and hc not >= 2", procName, NULL);
1095 pixb = pixc = pixd = NULL;
1105 L_ERROR(
"pixc not made\n", procName);
1108 wplc = pixGetWpl(pixc);
1114 wd = w - 2 * (wc + 1);
1115 hd = h - 2 * (hc + 1);
1116 if (wd < 2 || hd < 2) {
1117 L_ERROR(
"w or h is too small for the kernel\n", procName);
1120 if ((pixd =
pixCreate(wd, hd, d)) == NULL) {
1121 L_ERROR(
"pixd not made\n", procName);
1124 wpld = pixGetWpl(pixd);
1131 norm = 1.0 / ((l_float32)(wincr) * hincr);
1132 for (i = 0; i < hd; i++) {
1133 linec1 = datac + i * wplc;
1134 linec2 = datac + (i + hincr) * wplc;
1135 lined = datad + i * wpld;
1136 for (j = 0; j < wd; j++) {
1137 val = linec2[j + wincr] - linec2[j] - linec1[j + wincr] + linec1[j];
1139 val = (l_uint8)(norm * val);
1142 val = (l_uint32)(norm * val);
1195 l_int32 i, j, w, h, wd, hd, wpl, wpld, wincr, hincr;
1197 l_uint32 *datad, *lined;
1200 l_float64 *data, *line1, *line2;
1204 PROCNAME(
"pixWindowedMeanSquare");
1206 if (!pixs || (pixGetDepth(pixs) != 8))
1207 return (
PIX *)ERROR_PTR(
"pixs undefined or not 8 bpp", procName, NULL);
1208 if (wc < 2 || hc < 2)
1209 return (
PIX *)ERROR_PTR(
"wc and hc not >= 2", procName, NULL);
1220 L_ERROR(
"dpix not made\n", procName);
1229 wd = w - 2 * (wc + 1);
1230 hd = h - 2 * (hc + 1);
1231 if (wd < 2 || hd < 2) {
1232 L_ERROR(
"w or h too small for kernel\n", procName);
1235 if ((pixd =
pixCreate(wd, hd, 32)) == NULL) {
1236 L_ERROR(
"pixd not made\n", procName);
1239 wpld = pixGetWpl(pixd);
1244 norm = 1.0 / ((l_float32)(wincr) * hincr);
1245 for (i = 0; i < hd; i++) {
1246 line1 = data + i * wpl;
1247 line2 = data + (i + hincr) * wpl;
1248 lined = datad + i * wpld;
1249 for (j = 0; j < wd; j++) {
1250 val = line2[j + wincr] - line2[j] - line1[j + wincr] + line1[j];
1251 ival = (l_uint32)(norm * val + 0.5);
1293 l_int32 i, j, w, h, ws, hs, ds, wplm, wplms, wplv, wplrv, valm, valms;
1295 l_uint32 *linem, *linems, *datam, *datams;
1296 l_float32 *linev, *linerv, *datav, *datarv;
1297 FPIX *fpixv, *fpixrv;
1299 PROCNAME(
"pixWindowedVariance");
1301 if (!pfpixv && !pfpixrv)
1302 return ERROR_INT(
"no output requested", procName, 1);
1303 if (pfpixv) *pfpixv = NULL;
1304 if (pfpixrv) *pfpixrv = NULL;
1305 if (!pixm || pixGetDepth(pixm) != 8)
1306 return ERROR_INT(
"pixm undefined or not 8 bpp", procName, 1);
1307 if (!pixms || pixGetDepth(pixms) != 32)
1308 return ERROR_INT(
"pixms undefined or not 32 bpp", procName, 1);
1311 if (w != ws || h != hs)
1312 return ERROR_INT(
"pixm and pixms sizes differ", procName, 1);
1327 wplm = pixGetWpl(pixm);
1328 wplms = pixGetWpl(pixms);
1331 for (i = 0; i < h; i++) {
1332 linem = datam + i * wplm;
1333 linems = datams + i * wplms;
1335 linev = datav + i * wplv;
1337 linerv = datarv + i * wplrv;
1338 for (j = 0; j < w; j++) {
1343 valms = (l_int32)linems[j];
1344 var = (l_float32)valms - (l_float32)valm * valm;
1348 linerv[j] = (l_float32)sqrt(var);
1379 l_int32 i, j, w, h, wpl, wpls, val;
1380 l_uint32 *datas, *lines;
1381 l_float64 *data, *line, *linep;
1384 PROCNAME(
"pixMeanSquareAccum");
1387 if (!pixs || (pixGetDepth(pixs) != 8))
1388 return (
DPIX *)ERROR_PTR(
"pixs undefined or not 8 bpp", procName, NULL);
1391 return (
DPIX *)ERROR_PTR(
"dpix not made", procName, NULL);
1394 wpls = pixGetWpl(pixs);
1400 for (j = 0; j < w; j++) {
1403 line[0] = (l_float64)(val) * val;
1405 line[j] = line[j - 1] + (l_float64)(val) * val;
1409 for (i = 1; i < h; i++) {
1410 lines = datas + i * wpls;
1411 line = data + i * wpl;
1412 linep = line - wpl;;
1413 for (j = 0; j < w; j++) {
1416 line[0] = linep[0] + (l_float64)(val) * val;
1418 line[j] = line[j - 1] + linep[j] - linep[j - 1]
1419 + (l_float64)(val) * val;
1465 l_int32 w, h, d, thresh;
1468 PROCNAME(
"pixBlockrank");
1471 return (
PIX *)ERROR_PTR(
"pixs not defined", procName, NULL);
1474 return (
PIX *)ERROR_PTR(
"pixs not 1 bpp", procName, NULL);
1475 if (rank < 0.0 || rank > 1.0)
1476 return (
PIX *)ERROR_PTR(
"rank must be in [0.0, 1.0]", procName, NULL);
1484 if (wc <= 0 || hc <= 0)
1486 if (w < 2 * wc + 1 || h < 2 * hc + 1) {
1487 L_WARNING(
"kernel too large: wc = %d, hc = %d, w = %d, h = %d; " 1488 "reducing!\n", procName, wc, hc, w, h);
1489 wc = L_MIN(wc, (w - 1) / 2);
1490 hc = L_MIN(hc, (h - 1) / 2);
1492 if (wc == 0 || hc == 0)
1495 if ((pixt =
pixBlocksum(pixs, pixacc, wc, hc)) == NULL)
1496 return (
PIX *)ERROR_PTR(
"pixt not made", procName, NULL);
1501 thresh = (l_int32)(255. * rank);
1547 l_int32 w, h, d, wplt, wpld;
1548 l_uint32 *datat, *datad;
1551 PROCNAME(
"pixBlocksum");
1554 return (
PIX *)ERROR_PTR(
"pixs not defined", procName, NULL);
1557 return (
PIX *)ERROR_PTR(
"pixs not 1 bpp", procName, NULL);
1558 if (wc <= 0 || hc <= 0)
1560 if (w < 2 * wc + 1 || h < 2 * hc + 1) {
1561 L_WARNING(
"kernel too large: wc = %d, hc = %d, w = %d, h = %d; " 1562 "reducing!\n", procName, wc, hc, w, h);
1563 wc = L_MIN(wc, (w - 1) / 2);
1564 hc = L_MIN(hc, (h - 1) / 2);
1566 if (wc == 0 || hc == 0)
1570 if (pixGetDepth(pixacc) != 32)
1571 return (
PIX *)ERROR_PTR(
"pixacc not 32 bpp", procName, NULL);
1575 return (
PIX *)ERROR_PTR(
"pixt not made", procName, NULL);
1579 if ((pixd =
pixCreate(w, h, 8)) == NULL) {
1581 return (
PIX *)ERROR_PTR(
"pixd not made", procName, NULL);
1583 pixCopyResolution(pixd, pixs);
1585 wpld = pixGetWpl(pixd);
1586 wplt = pixGetWpl(pixt);
1589 blocksumLow(datad, w, h, wpld, datat, wplt, wc, hc);
1638 l_int32 i, j, imax, imin, jmax, jmin;
1639 l_int32 wn, hn, fwc, fhc, wmwc, hmhc;
1640 l_float32 norm, normh, normw;
1642 l_uint32 *linemina, *linemaxa, *lined;
1644 PROCNAME(
"blocksumLow");
1648 if (wmwc <= 0 || hmhc <= 0) {
1649 L_ERROR(
"wc >= w || hc >=h\n", procName);
1654 norm = 255. / ((l_float32)(fwc) * fhc);
1659 for (i = 0; i < h; i++) {
1660 imin = L_MAX(i - 1 - hc, 0);
1661 imax = L_MIN(i + hc, h - 1);
1662 lined = datad + wpl * i;
1663 linemina = dataa + wpla * imin;
1664 linemaxa = dataa + wpla * imax;
1665 for (j = 0; j < w; j++) {
1666 jmin = L_MAX(j - 1 - wc, 0);
1667 jmax = L_MIN(j + wc, w - 1);
1668 val = linemaxa[jmax] - linemaxa[jmin]
1669 - linemina[jmax] + linemina[jmin];
1670 val = (l_uint8)(norm * val);
1678 for (i = 0; i <= hc; i++) {
1680 normh = (l_float32)fhc / (l_float32)hn;
1681 lined = datad + wpl * i;
1682 for (j = 0; j <= wc; j++) {
1684 normw = (l_float32)fwc / (l_float32)wn;
1686 val = (l_uint8)(val * normh * normw);
1689 for (j = wc + 1; j < wmwc; j++) {
1691 val = (l_uint8)(val * normh);
1694 for (j = wmwc; j < w; j++) {
1696 normw = (l_float32)fwc / (l_float32)wn;
1698 val = (l_uint8)(val * normh * normw);
1703 for (i = hmhc; i < h; i++) {
1705 normh = (l_float32)fhc / (l_float32)hn;
1706 lined = datad + wpl * i;
1707 for (j = 0; j <= wc; j++) {
1709 normw = (l_float32)fwc / (l_float32)wn;
1711 val = (l_uint8)(val * normh * normw);
1714 for (j = wc + 1; j < wmwc; j++) {
1716 val = (l_uint8)(val * normh);
1719 for (j = wmwc; j < w; j++) {
1721 normw = (l_float32)fwc / (l_float32)wn;
1723 val = (l_uint8)(val * normh * normw);
1728 for (i = hc + 1; i < hmhc; i++) {
1729 lined = datad + wpl * i;
1730 for (j = 0; j <= wc; j++) {
1732 normw = (l_float32)fwc / (l_float32)wn;
1734 val = (l_uint8)(val * normw);
1737 for (j = wmwc; j < w; j++) {
1739 normw = (l_float32)fwc / (l_float32)wn;
1741 val = (l_uint8)(val * normw);
1784 l_int32 i, j, w, h, wpls, wplv, wpld;
1786 l_uint32 *datas, *datav, *datad, *lines, *linev, *lined;
1789 PROCNAME(
"pixCensusTransform");
1792 return (
PIX *)ERROR_PTR(
"pixs not defined", procName, NULL);
1793 if (pixGetDepth(pixs) != 8)
1794 return (
PIX *)ERROR_PTR(
"pixs not 8 bpp", procName, NULL);
1796 return (
PIX *)ERROR_PTR(
"halfsize must be >= 1", procName, NULL);
1801 return (
PIX *)ERROR_PTR(
"pixav not made", procName, NULL);
1806 if ((pixd =
pixCreate(w, h, 1)) == NULL) {
1808 return (
PIX *)ERROR_PTR(
"pixd not made", procName, NULL);
1813 wpls = pixGetWpl(pixs);
1814 wplv = pixGetWpl(pixav);
1815 wpld = pixGetWpl(pixd);
1816 for (i = 0; i < h; i++) {
1817 lines = datas + i * wpls;
1818 linev = datav + i * wplv;
1819 lined = datad + i * wpld;
1820 for (j = 0; j < w; j++) {
1885 l_int32 i, j, id, jd, k, m, w, h, d, wd, hd, sx, sy, cx, cy, wplt, wpld;
1887 l_uint32 *datat, *datad, *linet, *lined;
1892 PROCNAME(
"pixConvolve");
1895 return (
PIX *)ERROR_PTR(
"pixs not defined", procName, NULL);
1896 if (pixGetColormap(pixs))
1897 return (
PIX *)ERROR_PTR(
"pixs has colormap", procName, NULL);
1899 if (d != 8 && d != 16 && d != 32)
1900 return (
PIX *)ERROR_PTR(
"pixs not 8, 16, or 32 bpp", procName, NULL);
1902 return (
PIX *)ERROR_PTR(
"kel not defined", procName, NULL);
1914 L_ERROR(
"pixt not made\n", procName);
1918 wd = (w + ConvolveSamplingFactX - 1) / ConvolveSamplingFactX;
1919 hd = (h + ConvolveSamplingFactY - 1) / ConvolveSamplingFactY;
1923 wplt = pixGetWpl(pixt);
1924 wpld = pixGetWpl(pixd);
1925 for (i = 0,
id = 0;
id < hd; i += ConvolveSamplingFactY,
id++) {
1926 lined = datad +
id * wpld;
1927 for (j = 0, jd = 0; jd < wd; j += ConvolveSamplingFactX, jd++) {
1929 for (k = 0; k < sy; k++) {
1930 linet = datat + (i + k) * wplt;
1932 for (m = 0; m < sx; m++) {
1934 sum += val * keln->
data[k][m];
1936 }
else if (d == 16) {
1937 for (m = 0; m < sx; m++) {
1939 sum += val * keln->
data[k][m];
1942 for (m = 0; m < sx; m++) {
1943 val = *(linet + j + m);
1944 sum += val * keln->
data[k][m];
1948 if (sum < 0.0) sum = -sum;
1951 else if (outdepth == 16)
1954 *(lined + jd) = (l_uint32)(sum + 0.5);
2016 l_int32 d, xfact, yfact;
2020 PROCNAME(
"pixConvolveSep");
2023 return (
PIX *)ERROR_PTR(
"pixs not defined", procName, NULL);
2024 d = pixGetDepth(pixs);
2025 if (d != 8 && d != 16 && d != 32)
2026 return (
PIX *)ERROR_PTR(
"pixs not 8, 16, or 32 bpp", procName, NULL);
2028 return (
PIX *)ERROR_PTR(
"kelx not defined", procName, NULL);
2030 return (
PIX *)ERROR_PTR(
"kely not defined", procName, NULL);
2032 xfact = ConvolveSamplingFactX;
2033 yfact = ConvolveSamplingFactY;
2085 PIX *pixt, *pixr, *pixg, *pixb, *pixd;
2087 PROCNAME(
"pixConvolveRGB");
2090 return (
PIX *)ERROR_PTR(
"pixs not defined", procName, NULL);
2091 if (pixGetDepth(pixs) != 32)
2092 return (
PIX *)ERROR_PTR(
"pixs is not 32 bpp", procName, NULL);
2094 return (
PIX *)ERROR_PTR(
"kel not defined", procName, NULL);
2145 PIX *pixt, *pixr, *pixg, *pixb, *pixd;
2147 PROCNAME(
"pixConvolveRGBSep");
2150 return (
PIX *)ERROR_PTR(
"pixs not defined", procName, NULL);
2151 if (pixGetDepth(pixs) != 32)
2152 return (
PIX *)ERROR_PTR(
"pixs is not 32 bpp", procName, NULL);
2154 return (
PIX *)ERROR_PTR(
"kelx, kely not both defined", procName, NULL);
2207 l_int32 i, j, id, jd, k, m, w, h, wd, hd, sx, sy, cx, cy, wplt, wpld;
2209 l_float32 *datat, *datad, *linet, *lined;
2212 FPIX *fpixt, *fpixd;
2214 PROCNAME(
"fpixConvolve");
2217 return (
FPIX *)ERROR_PTR(
"fpixs not defined", procName, NULL);
2219 return (
FPIX *)ERROR_PTR(
"kel not defined", procName, NULL);
2233 L_ERROR(
"fpixt not made\n", procName);
2237 wd = (w + ConvolveSamplingFactX - 1) / ConvolveSamplingFactX;
2238 hd = (h + ConvolveSamplingFactY - 1) / ConvolveSamplingFactY;
2244 for (i = 0,
id = 0;
id < hd; i += ConvolveSamplingFactY,
id++) {
2245 lined = datad +
id * wpld;
2246 for (j = 0, jd = 0; jd < wd; j += ConvolveSamplingFactX, jd++) {
2248 for (k = 0; k < sy; k++) {
2249 linet = datat + (i + k) * wplt;
2250 for (m = 0; m < sx; m++) {
2251 val = *(linet + j + m);
2252 sum += val * keln->
data[k][m];
2255 *(lined + jd) = sum;
2302 l_int32 xfact, yfact;
2304 FPIX *fpixt, *fpixd;
2306 PROCNAME(
"fpixConvolveSep");
2309 return (
FPIX *)ERROR_PTR(
"pixs not defined", procName, NULL);
2311 return (
FPIX *)ERROR_PTR(
"kelx not defined", procName, NULL);
2313 return (
FPIX *)ERROR_PTR(
"kely not defined", procName, NULL);
2315 xfact = ConvolveSamplingFactX;
2316 yfact = ConvolveSamplingFactY;
2382 l_float32 min1, min2, min, minval, maxval, range;
2383 FPIX *fpix1, *fpix2;
2386 PROCNAME(
"pixConvolveWithBias");
2389 return (
PIX *)ERROR_PTR(
"&bias not defined", procName, NULL);
2391 if (!pixs || pixGetDepth(pixs) != 8)
2392 return (
PIX *)ERROR_PTR(
"pixs undefined or not 8 bpp", procName, NULL);
2393 if (pixGetColormap(pixs))
2394 return (
PIX *)ERROR_PTR(
"pixs has colormap", procName, NULL);
2396 return (
PIX *)ERROR_PTR(
"kel1 not defined", procName, NULL);
2403 min = L_MIN(min1, min2);
2430 range = maxval - minval;
2431 *pbias = (minval < 0.0) ? -minval : 0.0;
2433 if (range <= 255 || !force8) {
2434 outdepth = (range > 255) ? 16 : 8;
2468 if (xfact < 1) xfact = 1;
2469 if (yfact < 1) yfact = 1;
2470 ConvolveSamplingFactX = xfact;
2471 ConvolveSamplingFactY = yfact;
2495 l_int32 i, j, w, h, d, wpls, wpld, val, rval, gval, bval;
2497 l_uint32 *datas, *datad, *lines, *lined;
2500 PROCNAME(
"pixAddGaussianNoise");
2503 return (
PIX *)ERROR_PTR(
"pixs not defined", procName, NULL);
2504 if (pixGetColormap(pixs))
2505 return (
PIX *)ERROR_PTR(
"pixs has colormap", procName, NULL);
2507 if (d != 8 && d != 32)
2508 return (
PIX *)ERROR_PTR(
"pixs not 8 or 32 bpp", procName, NULL);
2513 wpls = pixGetWpl(pixs);
2514 wpld = pixGetWpl(pixd);
2515 for (i = 0; i < h; i++) {
2516 lines = datas + i * wpls;
2517 lined = datad + i * wpld;
2518 for (j = 0; j < w; j++) {
2522 val = L_MIN(255, L_MAX(0, val));
2525 pixel = *(lines + j);
2528 rval = L_MIN(255, L_MAX(0, rval));
2530 gval = L_MIN(255, L_MAX(0, gval));
2532 bval = L_MIN(255, L_MAX(0, bval));
2559 static l_int32 select = 0;
2560 static l_float32 saveval;
2561 l_float32 frand, xval, yval, rsq, factor;
2565 frand = (l_float32)rand() / (l_float32)RAND_MAX;
2566 xval = 2.0 * frand - 1.0;
2567 frand = (l_float32)rand() / (l_float32)RAND_MAX;
2568 yval = 2.0 * frand - 1.0;
2569 rsq = xval * xval + yval * yval;
2570 if (rsq > 0.0 && rsq < 1.0)
2573 factor = sqrt(-2.0 * log(rsq) / rsq);
2574 saveval = xval * factor;
2576 return yval * factor;
l_ok fpixGetMax(FPIX *fpix, l_float32 *pmaxval, l_int32 *pxmaxloc, l_int32 *pymaxloc)
fpixGetMax()
static void blocksumLow(l_uint32 *datad, l_int32 w, l_int32 h, l_int32 wpl, l_uint32 *dataa, l_int32 wpla, l_int32 wc, l_int32 hc)
blocksumLow()
PIX * pixRemoveColormap(PIX *pixs, l_int32 type)
pixRemoveColormap()
void dpixDestroy(DPIX **pdpix)
dpixDestroy()
PIX * pixBlockconvGrayTile(PIX *pixs, PIX *pixacc, l_int32 wc, l_int32 hc)
pixBlockconvGrayTile()
PIX * pixConvolveRGB(PIX *pixs, L_KERNEL *kel)
pixConvolveRGB()
l_float32 gaussDistribSampling(void)
gaussDistribSampling()
l_ok kernelGetParameters(L_KERNEL *kel, l_int32 *psy, l_int32 *psx, l_int32 *pcy, l_int32 *pcx)
kernelGetParameters()
PIX * pixCreateTemplate(const PIX *pixs)
pixCreateTemplate()
DPIX * dpixCreate(l_int32 width, l_int32 height)
dpixCreate()
PIX * pixBlockconvAccum(PIX *pixs)
pixBlockconvAccum()
PIX * pixWindowedMean(PIX *pixs, l_int32 wc, l_int32 hc, l_int32 hasborder, l_int32 normflag)
pixWindowedMean()
PIX * pixCensusTransform(PIX *pixs, l_int32 halfsize, PIX *pixacc)
pixCensusTransform()
l_float64 * dpixGetData(DPIX *dpix)
dpixGetData()
FPIX * fpixAddMirroredBorder(FPIX *fpixs, l_int32 left, l_int32 right, l_int32 top, l_int32 bot)
fpixAddMirroredBorder()
FPIX * fpixConvolveSep(FPIX *fpixs, L_KERNEL *kelx, L_KERNEL *kely, l_int32 normflag)
fpixConvolveSep()
l_int32 dpixGetWpl(DPIX *dpix)
dpixGetWpl()
PIX * pixCopy(PIX *pixd, const PIX *pixs)
pixCopy()
PIX * pixCreate(l_int32 width, l_int32 height, l_int32 depth)
pixCreate()
PIX * pixConvolveRGBSep(PIX *pixs, L_KERNEL *kelx, L_KERNEL *kely)
pixConvolveRGBSep()
l_ok pixSetAll(PIX *pix)
pixSetAll()
l_ok fpixAddMultConstant(FPIX *fpix, l_float32 addc, l_float32 multc)
fpixAddMultConstant()
PIX * pixInvert(PIX *pixd, PIX *pixs)
pixInvert()
l_ok fpixGetDimensions(FPIX *fpix, l_int32 *pw, l_int32 *ph)
fpixGetDimensions()
PIX * pixAddMirroredBorder(PIX *pixs, l_int32 left, l_int32 right, l_int32 top, l_int32 bot)
pixAddMirroredBorder()
l_uint32 * pixGetData(PIX *pix)
pixGetData()
l_ok pixTilingPaintTile(PIX *pixd, l_int32 i, l_int32 j, PIX *pixs, PIXTILING *pt)
pixTilingPaintTile()
PIX * fpixConvertToPix(FPIX *fpixs, l_int32 outdepth, l_int32 negvals, l_int32 errorflag)
fpixConvertToPix()
PIX * pixAddGaussianNoise(PIX *pixs, l_float32 stdev)
pixAddGaussianNoise()
PIX * pixThresholdToBinary(PIX *pixs, l_int32 thresh)
pixThresholdToBinary()
PIX * pixConvolve(PIX *pixs, L_KERNEL *kel, l_int32 outdepth, l_int32 normflag)
pixConvolve()
#define GET_DATA_BIT(pdata, n)
PIXTILING * pixTilingCreate(PIX *pixs, l_int32 nx, l_int32 ny, l_int32 w, l_int32 h, l_int32 xoverlap, l_int32 yoverlap)
pixTilingCreate()
void pixTilingDestroy(PIXTILING **ppt)
pixTilingDestroy()
PIX * pixGetRGBComponent(PIX *pixs, l_int32 comp)
pixGetRGBComponent()
l_ok fpixGetMin(FPIX *fpix, l_float32 *pminval, l_int32 *pxminloc, l_int32 *pyminloc)
fpixGetMin()
l_ok pixWindowedVariance(PIX *pixm, PIX *pixms, FPIX **pfpixv, FPIX **pfpixrv)
pixWindowedVariance()
PIX * pixBlockconvGrayUnnormalized(PIX *pixs, l_int32 wc, l_int32 hc)
pixBlockconvGrayUnnormalized()
L_KERNEL * kernelCopy(L_KERNEL *kels)
kernelCopy()
PIX * pixWindowedMeanSquare(PIX *pixs, l_int32 wc, l_int32 hc, l_int32 hasborder)
pixWindowedMeanSquare()
#define SET_DATA_BYTE(pdata, n, val)
l_ok pixSetPadBits(PIX *pix, l_int32 val)
pixSetPadBits()
#define GET_DATA_BYTE(pdata, n)
static void blockconvLow(l_uint32 *data, l_int32 w, l_int32 h, l_int32 wpl, l_uint32 *dataa, l_int32 wpla, l_int32 wc, l_int32 hc)
blockconvLow()
l_int32 fpixGetWpl(FPIX *fpix)
fpixGetWpl()
void l_setConvolveSampling(l_int32 xfact, l_int32 yfact)
l_setConvolveSampling()
PIX * pixTilingGetTile(PIXTILING *pt, l_int32 i, l_int32 j)
pixTilingGetTile()
PIX * pixCreateRGBImage(PIX *pixr, PIX *pixg, PIX *pixb)
pixCreateRGBImage()
PIX * pixClone(PIX *pixs)
pixClone()
PIX * pixConvolveWithBias(PIX *pixs, L_KERNEL *kel1, L_KERNEL *kel2, l_int32 force8, l_int32 *pbias)
pixConvolveWithBias()
PIX * pixBlockconvGray(PIX *pixs, PIX *pixacc, l_int32 wc, l_int32 hc)
pixBlockconvGray()
void pixDestroy(PIX **ppix)
pixDestroy()
L_KERNEL * kernelNormalize(L_KERNEL *kels, l_float32 normsum)
kernelNormalize()
l_float32 * fpixGetData(FPIX *fpix)
fpixGetData()
PIX * pixConvolveSep(PIX *pixs, L_KERNEL *kelx, L_KERNEL *kely, l_int32 outdepth, l_int32 normflag)
pixConvolveSep()
l_ok pixGetDimensions(const PIX *pix, l_int32 *pw, l_int32 *ph, l_int32 *pd)
pixGetDimensions()
L_KERNEL * kernelInvert(L_KERNEL *kels)
kernelInvert()
void kernelDestroy(L_KERNEL **pkel)
kernelDestroy()
PIX * pixBlockconvTiled(PIX *pix, l_int32 wc, l_int32 hc, l_int32 nx, l_int32 ny)
pixBlockconvTiled()
FPIX * pixConvertToFPix(PIX *pixs, l_int32 ncomps)
pixConvertToFPix()
FPIX * fpixCreate(l_int32 width, l_int32 height)
fpixCreate()
#define GET_DATA_TWO_BYTES(pdata, n)
DPIX * pixMeanSquareAccum(PIX *pixs)
pixMeanSquareAccum()
l_ok kernelGetMinMax(L_KERNEL *kel, l_float32 *pmin, l_float32 *pmax)
kernelGetMinMax()
PIX * pixBlockrank(PIX *pixs, PIX *pixacc, l_int32 wc, l_int32 hc, l_float32 rank)
pixBlockrank()
l_ok pixWindowedStats(PIX *pixs, l_int32 wc, l_int32 hc, l_int32 hasborder, PIX **ppixm, PIX **ppixms, FPIX **pfpixv, FPIX **pfpixrv)
pixWindowedStats()
PIX * pixBlockconv(PIX *pix, l_int32 wc, l_int32 hc)
pixBlockconv()
l_ok composeRGBPixel(l_int32 rval, l_int32 gval, l_int32 bval, l_uint32 *ppixel)
composeRGBPixel()
void fpixDestroy(FPIX **pfpix)
fpixDestroy()
#define SET_DATA_TWO_BYTES(pdata, n, val)
PIX * pixBlocksum(PIX *pixs, PIX *pixacc, l_int32 wc, l_int32 hc)
pixBlocksum()
void extractRGBValues(l_uint32 pixel, l_int32 *prval, l_int32 *pgval, l_int32 *pbval)
extractRGBValues()
#define SET_DATA_BIT(pdata, n)
PIX * pixAddBorderGeneral(PIX *pixs, l_int32 left, l_int32 right, l_int32 top, l_int32 bot, l_uint32 val)
pixAddBorderGeneral()
FPIX * fpixConvolve(FPIX *fpixs, L_KERNEL *kel, l_int32 normflag)
fpixConvolve()