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;
140 return (
PIX *)ERROR_PTR(
"pix not defined", __func__, NULL);
141 if (wc <= 0 || hc <= 0)
144 if (w < 2 * wc + 1 || h < 2 * hc + 1) {
145 L_WARNING(
"kernel too large: wc = %d, hc = %d, w = %d, h = %d; "
146 "reducing!\n", __func__, wc, hc, w, h);
147 wc = L_MIN(wc, (w - 1) / 2);
148 hc = L_MIN(hc, (h - 1) / 2);
150 if (wc == 0 || hc == 0)
154 if ((d == 2 || d == 4 || d == 8) && pixGetColormap(pix)) {
155 L_WARNING(
"pix has colormap; removing\n", __func__);
157 d = pixGetDepth(pixs);
162 if (d != 8 && d != 32) {
164 return (
PIX *)ERROR_PTR(
"depth not 8 or 32 bpp", __func__, NULL);
219 l_int32 w, h, d, wpl, wpla;
220 l_uint32 *datad, *dataa;
224 return (
PIX *)ERROR_PTR(
"pixs not defined", __func__, NULL);
227 return (
PIX *)ERROR_PTR(
"pixs not 8 bpp", __func__, NULL);
228 if (wc <= 0 || hc <= 0)
230 if (w < 2 * wc + 1 || h < 2 * hc + 1) {
231 L_WARNING(
"kernel too large: wc = %d, hc = %d, w = %d, h = %d; "
232 "reducing!\n", __func__, wc, hc, w, h);
233 wc = L_MIN(wc, (w - 1) / 2);
234 hc = L_MIN(hc, (h - 1) / 2);
236 if (wc == 0 || hc == 0)
240 if (pixGetDepth(pixacc) == 32) {
243 L_WARNING(
"pixacc not 32 bpp; making new one\n", __func__);
245 return (
PIX *)ERROR_PTR(
"pixt not made", __func__, NULL);
249 return (
PIX *)ERROR_PTR(
"pixt not made", __func__, NULL);
254 return (
PIX *)ERROR_PTR(
"pixd not made", __func__, NULL);
258 wpl = pixGetWpl(pixd);
259 wpla = pixGetWpl(pixt);
326 l_int32 i, j, imax, imin, jmax, jmin;
327 l_int32 wn, hn, fwc, fhc, wmwc, hmhc;
328 l_float32 norm, normh, normw;
330 l_uint32 *linemina, *linemaxa, *line;
334 if (wmwc <= 0 || hmhc <= 0) {
335 L_ERROR(
"wc >= w || hc >=h\n", __func__);
340 norm = 1.0 / ((l_float32)(fwc) * fhc);
345 for (i = 0; i < h; i++) {
346 imin = L_MAX(i - 1 - hc, 0);
347 imax = L_MIN(i + hc, h - 1);
348 line = data + wpl * i;
349 linemina = dataa + wpla * imin;
350 linemaxa = dataa + wpla * imax;
351 for (j = 0; j < w; j++) {
352 jmin = L_MAX(j - 1 - wc, 0);
353 jmax = L_MIN(j + wc, w - 1);
354 val = linemaxa[jmax] - linemaxa[jmin]
355 + linemina[jmin] - linemina[jmax];
356 val = (l_uint8)(norm * val + 0.5);
364 for (i = 0; i <= hc; i++) {
365 hn = L_MAX(1, hc + i);
366 normh = (l_float32)fhc / (l_float32)hn;
367 line = data + wpl * i;
368 for (j = 0; j <= wc; j++) {
369 wn = L_MAX(1, wc + j);
370 normw = (l_float32)fwc / (l_float32)wn;
372 val = (l_uint8)L_MIN(val * normh * normw, 255);
375 for (j = wc + 1; j < wmwc; j++) {
377 val = (l_uint8)L_MIN(val * normh, 255);
380 for (j = wmwc; j < w; j++) {
382 normw = (l_float32)fwc / (l_float32)wn;
384 val = (l_uint8)L_MIN(val * normh * normw, 255);
389 for (i = hmhc; i < h; i++) {
391 normh = (l_float32)fhc / (l_float32)hn;
392 line = data + wpl * i;
393 for (j = 0; j <= wc; j++) {
395 normw = (l_float32)fwc / (l_float32)wn;
397 val = (l_uint8)L_MIN(val * normh * normw, 255);
400 for (j = wc + 1; j < wmwc; j++) {
402 val = (l_uint8)L_MIN(val * normh, 255);
405 for (j = wmwc; j < w; j++) {
407 normw = (l_float32)fwc / (l_float32)wn;
409 val = (l_uint8)L_MIN(val * normh * normw, 255);
414 for (i = hc + 1; i < hmhc; i++) {
415 line = data + wpl * i;
416 for (j = 0; j <= wc; j++) {
418 normw = (l_float32)fwc / (l_float32)wn;
420 val = (l_uint8)L_MIN(val * normw, 255);
423 for (j = wmwc; j < w; j++) {
425 normw = (l_float32)fwc / (l_float32)wn;
427 val = (l_uint8)L_MIN(val * normw, 255);
456 l_int32 w, h, d, wpls, wpld;
457 l_uint32 *datas, *datad;
461 return (
PIX *)ERROR_PTR(
"pixs not defined", __func__, NULL);
464 if (d != 1 && d != 8 && d != 32)
465 return (
PIX *)ERROR_PTR(
"pixs not 1, 8 or 32 bpp", __func__, NULL);
466 if ((pixd =
pixCreate(w, h, 32)) == NULL)
467 return (
PIX *)ERROR_PTR(
"pixd not made", __func__, NULL);
471 wpls = pixGetWpl(pixs);
472 wpld = pixGetWpl(pixd);
473 blockconvAccumLow(datad, w, h, wpld, datas, d, wpls);
500 blockconvAccumLow(l_uint32 *datad,
511 l_uint32 *lines, *lined, *linedp;
518 for (j = 0; j < w; j++) {
523 lined[j] = lined[j - 1] + val;
527 for (i = 1; i < h; i++) {
528 lines = datas + i * wpls;
529 lined = datad + i * wpld;
530 linedp = lined - wpld;
531 for (j = 0; j < w; j++) {
534 lined[0] = val + linedp[0];
536 lined[j] = val + lined[j - 1] + linedp[j] - linedp[j - 1];
541 for (j = 0; j < w; j++) {
546 lined[j] = lined[j - 1] + val;
550 for (i = 1; i < h; i++) {
551 lines = datas + i * wpls;
552 lined = datad + i * wpld;
553 linedp = lined - wpld;
554 for (j = 0; j < w; j++) {
557 lined[0] = val + linedp[0];
559 lined[j] = val + lined[j - 1] + linedp[j] - linedp[j - 1];
562 }
else if (d == 32) {
564 for (j = 0; j < w; j++) {
569 lined[j] = lined[j - 1] + val32;
573 for (i = 1; i < h; i++) {
574 lines = datas + i * wpls;
575 lined = datad + i * wpld;
576 linedp = lined - wpld;
577 for (j = 0; j < w; j++) {
580 lined[0] = val32 + linedp[0];
582 lined[j] = val32 + lined[j - 1] + linedp[j] - linedp[j - 1];
586 L_ERROR(
"depth not 1, 8 or 32 bpp\n", __func__);
636 l_int32 i, j, w, h, d, wpla, wpld, jmax;
637 l_uint32 *linemina, *linemaxa, *lined, *dataa, *datad;
638 PIX *pixsb, *pixacc, *pixd;
641 return (
PIX *)ERROR_PTR(
"pixs not defined", __func__, NULL);
644 return (
PIX *)ERROR_PTR(
"pixs not 8 bpp", __func__, NULL);
645 if (wc <= 0 || hc <= 0)
647 if (w < 2 * wc + 1 || h < 2 * hc + 1) {
648 L_WARNING(
"kernel too large: wc = %d, hc = %d, w = %d, h = %d; "
649 "reducing!\n", __func__, wc, hc, w, h);
650 wc = L_MIN(wc, (w - 1) / 2);
651 hc = L_MIN(hc, (h - 1) / 2);
653 if (wc == 0 || hc == 0)
657 return (
PIX *)ERROR_PTR(
"pixsb not made", __func__, NULL);
661 return (
PIX *)ERROR_PTR(
"pixacc not made", __func__, NULL);
662 if ((pixd =
pixCreate(w, h, 32)) == NULL) {
664 return (
PIX *)ERROR_PTR(
"pixd not made", __func__, NULL);
667 wpla = pixGetWpl(pixacc);
668 wpld = pixGetWpl(pixd);
671 for (i = 0; i < h; i++) {
672 lined = datad + i * wpld;
673 linemina = dataa + i * wpla;
674 linemaxa = dataa + (i + 2 * hc + 1) * wpla;
675 for (j = 0; j < w; j++) {
676 jmax = j + 2 * wc + 1;
677 lined[j] = linemaxa[jmax] - linemaxa[j] -
678 linemina[jmax] + linemina[j];
728 l_int32 i, j, w, h, d, xrat, yrat;
729 PIX *pixs, *pixd, *pixc, *pixt;
730 PIX *pixr, *pixrc, *pixg, *pixgc, *pixb, *pixbc;
734 return (
PIX *)ERROR_PTR(
"pix not defined", __func__, NULL);
735 if (wc <= 0 || hc <= 0)
737 if (nx <= 1 && ny <= 1)
740 if (w < 2 * wc + 3 || h < 2 * hc + 3) {
741 L_WARNING(
"kernel too large: wc = %d, hc = %d, w = %d, h = %d; "
742 "reducing!\n", __func__, wc, hc, w, h);
743 wc = L_MIN(wc, (w - 1) / 2);
744 hc = L_MIN(hc, (h - 1) / 2);
746 if (wc == 0 || hc == 0)
756 L_WARNING(
"tile width too small; nx reduced to %d\n", __func__, nx);
760 L_WARNING(
"tile height too small; ny reduced to %d\n", __func__, ny);
764 if ((d == 2 || d == 4 || d == 8) && pixGetColormap(pix)) {
765 L_WARNING(
"pix has colormap; removing\n", __func__);
767 d = pixGetDepth(pixs);
772 if (d != 8 && d != 32) {
774 return (
PIX *)ERROR_PTR(
"depth not 8 or 32 bpp", __func__, NULL);
786 return (
PIX *)ERROR_PTR(
"pixd not made", __func__, NULL);
789 for (i = 0; i < ny; i++) {
790 for (j = 0; j < nx; j++) {
852 l_int32 w, h, d, wd, hd, i, j, imin, imax, jmin, jmax, wplt, wpld;
855 l_uint32 *datat, *datad, *lined, *linemint, *linemaxt;
859 return (
PIX *)ERROR_PTR(
"pix not defined", __func__, NULL);
862 return (
PIX *)ERROR_PTR(
"pixs not 8 bpp", __func__, NULL);
863 if (wc <= 0 || hc <= 0)
865 if (w < 2 * wc + 3 || h < 2 * hc + 3) {
866 L_WARNING(
"kernel too large: wc = %d, hc = %d, w = %d, h = %d; "
867 "reducing!\n", __func__, wc, hc, w, h);
868 wc = L_MIN(wc, (w - 1) / 2);
869 hc = L_MIN(hc, (h - 1) / 2);
871 if (wc == 0 || hc == 0)
877 if (pixGetDepth(pixacc) == 32) {
880 L_WARNING(
"pixacc not 32 bpp; making new one\n", __func__);
882 return (
PIX *)ERROR_PTR(
"pixt not made", __func__, NULL);
886 return (
PIX *)ERROR_PTR(
"pixt not made", __func__, NULL);
891 return (
PIX *)ERROR_PTR(
"pixd not made", __func__, NULL);
894 wplt = pixGetWpl(pixt);
896 wpld = pixGetWpl(pixd);
897 norm = 1. / (l_float32)((2 * wc + 1) * (2 * hc + 1));
908 for (i = hc; i < hc + hd - 2; i++) {
909 imin = L_MAX(i - hc - 1, 0);
910 imax = L_MIN(i + hc, h - 1);
911 lined = datad + i * wpld;
912 linemint = datat + imin * wplt;
913 linemaxt = datat + imax * wplt;
914 for (j = wc; j < wc + wd - 2; j++) {
915 jmin = L_MAX(j - wc - 1, 0);
916 jmax = L_MIN(j + wc, w - 1);
917 val = linemaxt[jmax] - linemaxt[jmin]
918 + linemint[jmin] - linemint[jmax];
919 val = (l_uint8)(norm * val + 0.5);
981 PIX *pixb, *pixm, *pixms;
983 if (!ppixm && !ppixms && !pfpixv && !pfpixrv)
984 return ERROR_INT(
"no output requested", __func__, 1);
985 if (ppixm) *ppixm = NULL;
986 if (ppixms) *ppixms = NULL;
987 if (pfpixv) *pfpixv = NULL;
988 if (pfpixrv) *pfpixrv = NULL;
989 if (!pixs || pixGetDepth(pixs) != 8)
990 return ERROR_INT(
"pixs not defined or not 8 bpp", __func__, 1);
991 if (wc < 2 || hc < 2)
992 return ERROR_INT(
"wc and hc not >= 2", __func__, 1);
1000 if (!pfpixv && !pfpixrv) {
1061 l_int32 i, j, w, h, d, wd, hd, wplc, wpld, wincr, hincr;
1063 l_uint32 *datac, *datad, *linec1, *linec2, *lined;
1065 PIX *pixb, *pixc, *pixd;
1068 return (
PIX *)ERROR_PTR(
"pixs not defined", __func__, NULL);
1069 d = pixGetDepth(pixs);
1070 if (d != 8 && d != 32)
1071 return (
PIX *)ERROR_PTR(
"pixs not 8 or 32 bpp", __func__, NULL);
1072 if (wc < 2 || hc < 2)
1073 return (
PIX *)ERROR_PTR(
"wc and hc not >= 2", __func__, NULL);
1075 pixb = pixc = pixd = NULL;
1085 L_ERROR(
"pixc not made\n", __func__);
1088 wplc = pixGetWpl(pixc);
1094 wd = w - 2 * (wc + 1);
1095 hd = h - 2 * (hc + 1);
1096 if (wd < 2 || hd < 2) {
1097 L_ERROR(
"w or h is too small for the kernel\n", __func__);
1100 if ((pixd =
pixCreate(wd, hd, d)) == NULL) {
1101 L_ERROR(
"pixd not made\n", __func__);
1104 wpld = pixGetWpl(pixd);
1111 norm = 1.0 / ((l_float32)(wincr) * hincr);
1112 for (i = 0; i < hd; i++) {
1113 linec1 = datac + i * wplc;
1114 linec2 = datac + (i + hincr) * wplc;
1115 lined = datad + i * wpld;
1116 for (j = 0; j < wd; j++) {
1117 val = linec2[j + wincr] - linec2[j] - linec1[j + wincr] + linec1[j];
1119 val = (l_uint8)(norm * val);
1122 val = (l_uint32)(norm * val);
1175 l_int32 i, j, w, h, wd, hd, wpl, wpld, wincr, hincr;
1177 l_uint32 *datad, *lined;
1180 l_float64 *data, *line1, *line2;
1184 if (!pixs || (pixGetDepth(pixs) != 8))
1185 return (
PIX *)ERROR_PTR(
"pixs undefined or not 8 bpp", __func__, NULL);
1186 if (wc < 2 || hc < 2)
1187 return (
PIX *)ERROR_PTR(
"wc and hc not >= 2", __func__, NULL);
1198 L_ERROR(
"dpix not made\n", __func__);
1207 wd = w - 2 * (wc + 1);
1208 hd = h - 2 * (hc + 1);
1209 if (wd < 2 || hd < 2) {
1210 L_ERROR(
"w or h too small for kernel\n", __func__);
1213 if ((pixd =
pixCreate(wd, hd, 32)) == NULL) {
1214 L_ERROR(
"pixd not made\n", __func__);
1217 wpld = pixGetWpl(pixd);
1222 norm = 1.0 / ((l_float32)(wincr) * hincr);
1223 for (i = 0; i < hd; i++) {
1224 line1 = data + i * wpl;
1225 line2 = data + (i + hincr) * wpl;
1226 lined = datad + i * wpld;
1227 for (j = 0; j < wd; j++) {
1228 val = line2[j + wincr] - line2[j] - line1[j + wincr] + line1[j];
1229 ival = (l_uint32)(norm * val + 0.5);
1271 l_int32 i, j, w, h, ws, hs, ds, wplm, wplms, wplv, wplrv, valm, valms;
1273 l_uint32 *linem, *linems, *datam, *datams;
1274 l_float32 *linev, *linerv, *datav, *datarv;
1275 FPIX *fpixv, *fpixrv;
1277 if (!pfpixv && !pfpixrv)
1278 return ERROR_INT(
"no output requested", __func__, 1);
1279 if (pfpixv) *pfpixv = NULL;
1280 if (pfpixrv) *pfpixrv = NULL;
1281 if (!pixm || pixGetDepth(pixm) != 8)
1282 return ERROR_INT(
"pixm undefined or not 8 bpp", __func__, 1);
1283 if (!pixms || pixGetDepth(pixms) != 32)
1284 return ERROR_INT(
"pixms undefined or not 32 bpp", __func__, 1);
1287 if (w != ws || h != hs)
1288 return ERROR_INT(
"pixm and pixms sizes differ", __func__, 1);
1303 wplm = pixGetWpl(pixm);
1304 wplms = pixGetWpl(pixms);
1307 for (i = 0; i < h; i++) {
1308 linem = datam + i * wplm;
1309 linems = datams + i * wplms;
1311 linev = datav + i * wplv;
1313 linerv = datarv + i * wplrv;
1314 for (j = 0; j < w; j++) {
1319 valms = (l_int32)linems[j];
1320 var = (l_float32)valms - (l_float32)valm * valm;
1324 linerv[j] = (l_float32)sqrt(var);
1355 l_int32 i, j, w, h, wpl, wpls, val;
1356 l_uint32 *datas, *lines;
1357 l_float64 *data, *line, *linep;
1360 if (!pixs || (pixGetDepth(pixs) != 8))
1361 return (
DPIX *)ERROR_PTR(
"pixs undefined or not 8 bpp", __func__, NULL);
1364 return (
DPIX *)ERROR_PTR(
"dpix not made", __func__, NULL);
1367 wpls = pixGetWpl(pixs);
1373 for (j = 0; j < w; j++) {
1376 line[0] = (l_float64)(val) * val;
1378 line[j] = line[j - 1] + (l_float64)(val) * val;
1382 for (i = 1; i < h; i++) {
1383 lines = datas + i * wpls;
1384 line = data + i * wpl;
1385 linep = line - wpl;;
1386 for (j = 0; j < w; j++) {
1389 line[0] = linep[0] + (l_float64)(val) * val;
1391 line[j] = line[j - 1] + linep[j] - linep[j - 1]
1392 + (l_float64)(val) * val;
1438 l_int32 w, h, d, thresh;
1442 return (
PIX *)ERROR_PTR(
"pixs not defined", __func__, NULL);
1445 return (
PIX *)ERROR_PTR(
"pixs not 1 bpp", __func__, NULL);
1446 if (rank < 0.0 || rank > 1.0)
1447 return (
PIX *)ERROR_PTR(
"rank must be in [0.0, 1.0]", __func__, NULL);
1455 if (wc <= 0 || hc <= 0)
1457 if (w < 2 * wc + 1 || h < 2 * hc + 1) {
1458 L_WARNING(
"kernel too large: wc = %d, hc = %d, w = %d, h = %d; "
1459 "reducing!\n", __func__, wc, hc, w, h);
1460 wc = L_MIN(wc, (w - 1) / 2);
1461 hc = L_MIN(hc, (h - 1) / 2);
1463 if (wc == 0 || hc == 0)
1466 if ((pixt =
pixBlocksum(pixs, pixacc, wc, hc)) == NULL)
1467 return (
PIX *)ERROR_PTR(
"pixt not made", __func__, NULL);
1472 thresh = (l_int32)(255. * rank);
1518 l_int32 w, h, d, wplt, wpld;
1519 l_uint32 *datat, *datad;
1523 return (
PIX *)ERROR_PTR(
"pixs not defined", __func__, NULL);
1526 return (
PIX *)ERROR_PTR(
"pixs not 1 bpp", __func__, NULL);
1527 if (wc <= 0 || hc <= 0)
1529 if (w < 2 * wc + 1 || h < 2 * hc + 1) {
1530 L_WARNING(
"kernel too large: wc = %d, hc = %d, w = %d, h = %d; "
1531 "reducing!\n", __func__, wc, hc, w, h);
1532 wc = L_MIN(wc, (w - 1) / 2);
1533 hc = L_MIN(hc, (h - 1) / 2);
1535 if (wc == 0 || hc == 0)
1539 if (pixGetDepth(pixacc) != 32)
1540 return (
PIX *)ERROR_PTR(
"pixacc not 32 bpp", __func__, NULL);
1544 return (
PIX *)ERROR_PTR(
"pixt not made", __func__, NULL);
1548 if ((pixd =
pixCreate(w, h, 8)) == NULL) {
1550 return (
PIX *)ERROR_PTR(
"pixd not made", __func__, NULL);
1552 pixCopyResolution(pixd, pixs);
1554 wpld = pixGetWpl(pixd);
1555 wplt = pixGetWpl(pixt);
1558 blocksumLow(datad, w, h, wpld, datat, wplt, wc, hc);
1607 l_int32 i, j, imax, imin, jmax, jmin;
1608 l_int32 wn, hn, fwc, fhc, wmwc, hmhc;
1609 l_float32 norm, normh, normw;
1611 l_uint32 *linemina, *linemaxa, *lined;
1615 if (wmwc <= 0 || hmhc <= 0) {
1616 L_ERROR(
"wc >= w || hc >=h\n", __func__);
1621 norm = 255. / ((l_float32)(fwc) * fhc);
1626 for (i = 0; i < h; i++) {
1627 imin = L_MAX(i - 1 - hc, 0);
1628 imax = L_MIN(i + hc, h - 1);
1629 lined = datad + wpl * i;
1630 linemina = dataa + wpla * imin;
1631 linemaxa = dataa + wpla * imax;
1632 for (j = 0; j < w; j++) {
1633 jmin = L_MAX(j - 1 - wc, 0);
1634 jmax = L_MIN(j + wc, w - 1);
1635 val = linemaxa[jmax] - linemaxa[jmin]
1636 - linemina[jmax] + linemina[jmin];
1637 val = (l_uint8)(norm * val);
1645 for (i = 0; i <= hc; i++) {
1647 normh = (l_float32)fhc / (l_float32)hn;
1648 lined = datad + wpl * i;
1649 for (j = 0; j <= wc; j++) {
1651 normw = (l_float32)fwc / (l_float32)wn;
1653 val = (l_uint8)(val * normh * normw);
1656 for (j = wc + 1; j < wmwc; j++) {
1658 val = (l_uint8)(val * normh);
1661 for (j = wmwc; j < w; j++) {
1663 normw = (l_float32)fwc / (l_float32)wn;
1665 val = (l_uint8)(val * normh * normw);
1670 for (i = hmhc; i < h; i++) {
1672 normh = (l_float32)fhc / (l_float32)hn;
1673 lined = datad + wpl * i;
1674 for (j = 0; j <= wc; j++) {
1676 normw = (l_float32)fwc / (l_float32)wn;
1678 val = (l_uint8)(val * normh * normw);
1681 for (j = wc + 1; j < wmwc; j++) {
1683 val = (l_uint8)(val * normh);
1686 for (j = wmwc; j < w; j++) {
1688 normw = (l_float32)fwc / (l_float32)wn;
1690 val = (l_uint8)(val * normh * normw);
1695 for (i = hc + 1; i < hmhc; i++) {
1696 lined = datad + wpl * i;
1697 for (j = 0; j <= wc; j++) {
1699 normw = (l_float32)fwc / (l_float32)wn;
1701 val = (l_uint8)(val * normw);
1704 for (j = wmwc; j < w; j++) {
1706 normw = (l_float32)fwc / (l_float32)wn;
1708 val = (l_uint8)(val * normw);
1751 l_int32 i, j, w, h, wpls, wplv, wpld;
1753 l_uint32 *datas, *datav, *datad, *lines, *linev, *lined;
1757 return (
PIX *)ERROR_PTR(
"pixs not defined", __func__, NULL);
1758 if (pixGetDepth(pixs) != 8)
1759 return (
PIX *)ERROR_PTR(
"pixs not 8 bpp", __func__, NULL);
1761 return (
PIX *)ERROR_PTR(
"halfsize must be >= 1", __func__, NULL);
1766 return (
PIX *)ERROR_PTR(
"pixav not made", __func__, NULL);
1771 if ((pixd =
pixCreate(w, h, 1)) == NULL) {
1773 return (
PIX *)ERROR_PTR(
"pixd not made", __func__, NULL);
1778 wpls = pixGetWpl(pixs);
1779 wplv = pixGetWpl(pixav);
1780 wpld = pixGetWpl(pixd);
1781 for (i = 0; i < h; i++) {
1782 lines = datas + i * wpls;
1783 linev = datav + i * wplv;
1784 lined = datad + i * wpld;
1785 for (j = 0; j < w; j++) {
1850 l_int32 i, j, id, jd, k, m, w, h, d, wd, hd, sx, sy, cx, cy, wplt, wpld;
1852 l_uint32 *datat, *datad, *linet, *lined;
1858 return (
PIX *)ERROR_PTR(
"pixs not defined", __func__, NULL);
1859 if (pixGetColormap(pixs))
1860 return (
PIX *)ERROR_PTR(
"pixs has colormap", __func__, NULL);
1862 if (d != 8 && d != 16 && d != 32)
1863 return (
PIX *)ERROR_PTR(
"pixs not 8, 16, or 32 bpp", __func__, NULL);
1865 return (
PIX *)ERROR_PTR(
"kel not defined", __func__, NULL);
1877 L_ERROR(
"pixt not made\n", __func__);
1881 wd = (w + ConvolveSamplingFactX - 1) / ConvolveSamplingFactX;
1882 hd = (h + ConvolveSamplingFactY - 1) / ConvolveSamplingFactY;
1886 wplt = pixGetWpl(pixt);
1887 wpld = pixGetWpl(pixd);
1888 for (i = 0,
id = 0;
id < hd; i += ConvolveSamplingFactY,
id++) {
1889 lined = datad +
id * wpld;
1890 for (j = 0, jd = 0; jd < wd; j += ConvolveSamplingFactX, jd++) {
1892 for (k = 0; k < sy; k++) {
1893 linet = datat + (i + k) * wplt;
1895 for (m = 0; m < sx; m++) {
1897 sum += val * keln->
data[k][m];
1899 }
else if (d == 16) {
1900 for (m = 0; m < sx; m++) {
1902 sum += val * keln->
data[k][m];
1905 for (m = 0; m < sx; m++) {
1906 val = *(linet + j + m);
1907 sum += val * keln->
data[k][m];
1911 if (sum < 0.0) sum = -sum;
1914 else if (outdepth == 16)
1917 *(lined + jd) = (l_uint32)(sum + 0.5);
1979 l_int32 d, xfact, yfact;
1984 return (
PIX *)ERROR_PTR(
"pixs not defined", __func__, NULL);
1985 d = pixGetDepth(pixs);
1986 if (d != 8 && d != 16 && d != 32)
1987 return (
PIX *)ERROR_PTR(
"pixs not 8, 16, or 32 bpp", __func__, NULL);
1989 return (
PIX *)ERROR_PTR(
"kelx not defined", __func__, NULL);
1991 return (
PIX *)ERROR_PTR(
"kely not defined", __func__, NULL);
1993 xfact = ConvolveSamplingFactX;
1994 yfact = ConvolveSamplingFactY;
2046 PIX *pixt, *pixr, *pixg, *pixb, *pixd;
2049 return (
PIX *)ERROR_PTR(
"pixs not defined", __func__, NULL);
2050 if (pixGetDepth(pixs) != 32)
2051 return (
PIX *)ERROR_PTR(
"pixs is not 32 bpp", __func__, NULL);
2053 return (
PIX *)ERROR_PTR(
"kel not defined", __func__, NULL);
2104 PIX *pixt, *pixr, *pixg, *pixb, *pixd;
2107 return (
PIX *)ERROR_PTR(
"pixs not defined", __func__, NULL);
2108 if (pixGetDepth(pixs) != 32)
2109 return (
PIX *)ERROR_PTR(
"pixs is not 32 bpp", __func__, NULL);
2111 return (
PIX *)ERROR_PTR(
"kelx, kely not both defined", __func__, NULL);
2164 l_int32 i, j, id, jd, k, m, w, h, wd, hd, sx, sy, cx, cy, wplt, wpld;
2166 l_float32 *datat, *datad, *linet, *lined;
2169 FPIX *fpixt, *fpixd;
2172 return (
FPIX *)ERROR_PTR(
"fpixs not defined", __func__, NULL);
2174 return (
FPIX *)ERROR_PTR(
"kel not defined", __func__, NULL);
2188 L_ERROR(
"fpixt not made\n", __func__);
2192 wd = (w + ConvolveSamplingFactX - 1) / ConvolveSamplingFactX;
2193 hd = (h + ConvolveSamplingFactY - 1) / ConvolveSamplingFactY;
2199 for (i = 0,
id = 0;
id < hd; i += ConvolveSamplingFactY,
id++) {
2200 lined = datad +
id * wpld;
2201 for (j = 0, jd = 0; jd < wd; j += ConvolveSamplingFactX, jd++) {
2203 for (k = 0; k < sy; k++) {
2204 linet = datat + (i + k) * wplt;
2205 for (m = 0; m < sx; m++) {
2206 val = *(linet + j + m);
2207 sum += val * keln->
data[k][m];
2210 *(lined + jd) = sum;
2257 l_int32 xfact, yfact;
2259 FPIX *fpixt, *fpixd;
2262 return (
FPIX *)ERROR_PTR(
"pixs not defined", __func__, NULL);
2264 return (
FPIX *)ERROR_PTR(
"kelx not defined", __func__, NULL);
2266 return (
FPIX *)ERROR_PTR(
"kely not defined", __func__, NULL);
2268 xfact = ConvolveSamplingFactX;
2269 yfact = ConvolveSamplingFactY;
2335 l_float32 min1, min2, min, minval, maxval, range;
2336 FPIX *fpix1, *fpix2;
2340 return (
PIX *)ERROR_PTR(
"&bias not defined", __func__, NULL);
2342 if (!pixs || pixGetDepth(pixs) != 8)
2343 return (
PIX *)ERROR_PTR(
"pixs undefined or not 8 bpp", __func__, NULL);
2344 if (pixGetColormap(pixs))
2345 return (
PIX *)ERROR_PTR(
"pixs has colormap", __func__, NULL);
2347 return (
PIX *)ERROR_PTR(
"kel1 not defined", __func__, NULL);
2354 min = L_MIN(min1, min2);
2381 range = maxval - minval;
2382 *pbias = (minval < 0.0) ? -minval : 0.0;
2384 if (range <= 255 || !force8) {
2385 outdepth = (range > 255) ? 16 : 8;
2419 if (xfact < 1) xfact = 1;
2420 if (yfact < 1) yfact = 1;
2421 ConvolveSamplingFactX = xfact;
2422 ConvolveSamplingFactY = yfact;
2446 l_int32 i, j, w, h, d, wpls, wpld, val, rval, gval, bval;
2448 l_uint32 *datas, *datad, *lines, *lined;
2452 return (
PIX *)ERROR_PTR(
"pixs not defined", __func__, NULL);
2453 if (pixGetColormap(pixs))
2454 return (
PIX *)ERROR_PTR(
"pixs has colormap", __func__, NULL);
2456 if (d != 8 && d != 32)
2457 return (
PIX *)ERROR_PTR(
"pixs not 8 or 32 bpp", __func__, NULL);
2462 wpls = pixGetWpl(pixs);
2463 wpld = pixGetWpl(pixd);
2464 for (i = 0; i < h; i++) {
2465 lines = datas + i * wpls;
2466 lined = datad + i * wpld;
2467 for (j = 0; j < w; j++) {
2471 val = L_MIN(255, L_MAX(0, val));
2474 pixel = *(lines + j);
2477 rval = L_MIN(255, L_MAX(0, rval));
2479 gval = L_MIN(255, L_MAX(0, gval));
2481 bval = L_MIN(255, L_MAX(0, bval));
2508 static l_int32 select = 0;
2509 static l_float32 saveval;
2510 l_float32 frand, xval, yval, rsq, factor;
2514 frand = (l_float32)rand() / (l_float32)RAND_MAX;
2515 xval = 2.0 * frand - 1.0;
2516 frand = (l_float32)rand() / (l_float32)RAND_MAX;
2517 yval = 2.0 * frand - 1.0;
2518 rsq = xval * xval + yval * yval;
2519 if (rsq > 0.0 && rsq < 1.0)
2522 factor = sqrt(-2.0 * log(rsq) / rsq);
2523 saveval = xval * factor;
2525 return yval * factor;
#define GET_DATA_TWO_BYTES(pdata, n)
#define SET_DATA_BIT(pdata, n)
#define SET_DATA_TWO_BYTES(pdata, n, val)
#define GET_DATA_BYTE(pdata, n)
#define SET_DATA_BYTE(pdata, n, val)
#define GET_DATA_BIT(pdata, n)
PIX * pixBlockconvGrayTile(PIX *pixs, PIX *pixacc, l_int32 wc, l_int32 hc)
pixBlockconvGrayTile()
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()
PIX * pixConvolveRGB(PIX *pixs, L_KERNEL *kel)
pixConvolveRGB()
PIX * pixBlockconvTiled(PIX *pix, l_int32 wc, l_int32 hc, l_int32 nx, l_int32 ny)
pixBlockconvTiled()
PIX * pixWindowedMeanSquare(PIX *pixs, l_int32 wc, l_int32 hc, l_int32 hasborder)
pixWindowedMeanSquare()
PIX * pixCensusTransform(PIX *pixs, l_int32 halfsize, PIX *pixacc)
pixCensusTransform()
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 * pixBlocksum(PIX *pixs, PIX *pixacc, l_int32 wc, l_int32 hc)
pixBlocksum()
PIX * pixBlockconv(PIX *pix, l_int32 wc, l_int32 hc)
pixBlockconv()
void l_setConvolveSampling(l_int32 xfact, l_int32 yfact)
l_setConvolveSampling()
PIX * pixBlockrank(PIX *pixs, PIX *pixacc, l_int32 wc, l_int32 hc, l_float32 rank)
pixBlockrank()
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()
PIX * pixConvolve(PIX *pixs, L_KERNEL *kel, l_int32 outdepth, l_int32 normflag)
pixConvolve()
PIX * pixBlockconvGrayUnnormalized(PIX *pixs, l_int32 wc, l_int32 hc)
pixBlockconvGrayUnnormalized()
l_ok pixWindowedVariance(PIX *pixm, PIX *pixms, FPIX **pfpixv, FPIX **pfpixrv)
pixWindowedVariance()
FPIX * fpixConvolve(FPIX *fpixs, L_KERNEL *kel, l_int32 normflag)
fpixConvolve()
PIX * pixBlockconvAccum(PIX *pixs)
pixBlockconvAccum()
l_ok pixWindowedStats(PIX *pixs, l_int32 wc, l_int32 hc, l_int32 hasborder, PIX **ppixm, PIX **ppixms, FPIX **pfpixv, FPIX **pfpixrv)
pixWindowedStats()
PIX * pixAddGaussianNoise(PIX *pixs, l_float32 stdev)
pixAddGaussianNoise()
PIX * pixWindowedMean(PIX *pixs, l_int32 wc, l_int32 hc, l_int32 hasborder, l_int32 normflag)
pixWindowedMean()
DPIX * pixMeanSquareAccum(PIX *pixs)
pixMeanSquareAccum()
l_float32 gaussDistribSampling(void)
gaussDistribSampling()
FPIX * fpixConvolveSep(FPIX *fpixs, L_KERNEL *kelx, L_KERNEL *kely, l_int32 normflag)
fpixConvolveSep()
PIX * pixConvolveRGBSep(PIX *pixs, L_KERNEL *kelx, L_KERNEL *kely)
pixConvolveRGBSep()
PIX * pixConvolveSep(PIX *pixs, L_KERNEL *kelx, L_KERNEL *kely, l_int32 outdepth, l_int32 normflag)
pixConvolveSep()
void dpixDestroy(DPIX **pdpix)
dpixDestroy()
l_int32 dpixGetWpl(DPIX *dpix)
dpixGetWpl()
DPIX * dpixCreate(l_int32 width, l_int32 height)
dpixCreate()
l_float64 * dpixGetData(DPIX *dpix)
dpixGetData()
l_ok fpixGetDimensions(FPIX *fpix, l_int32 *pw, l_int32 *ph)
fpixGetDimensions()
l_int32 fpixGetWpl(FPIX *fpix)
fpixGetWpl()
void fpixDestroy(FPIX **pfpix)
fpixDestroy()
FPIX * fpixCreate(l_int32 width, l_int32 height)
fpixCreate()
l_float32 * fpixGetData(FPIX *fpix)
fpixGetData()
FPIX * fpixAddMirroredBorder(FPIX *fpixs, l_int32 left, l_int32 right, l_int32 top, l_int32 bot)
fpixAddMirroredBorder()
PIX * fpixConvertToPix(FPIX *fpixs, l_int32 outdepth, l_int32 negvals, l_int32 errorflag)
fpixConvertToPix()
l_ok fpixGetMax(FPIX *fpix, l_float32 *pmaxval, l_int32 *pxmaxloc, l_int32 *pymaxloc)
fpixGetMax()
l_ok fpixAddMultConstant(FPIX *fpix, l_float32 addc, l_float32 multc)
fpixAddMultConstant()
l_ok fpixGetMin(FPIX *fpix, l_float32 *pminval, l_int32 *pxminloc, l_int32 *pyminloc)
fpixGetMin()
FPIX * pixConvertToFPix(PIX *pixs, l_int32 ncomps)
pixConvertToFPix()
PIX * pixThresholdToBinary(PIX *pixs, l_int32 thresh)
pixThresholdToBinary()
l_ok kernelGetMinMax(L_KERNEL *kel, l_float32 *pmin, l_float32 *pmax)
kernelGetMinMax()
L_KERNEL * kernelInvert(L_KERNEL *kels)
kernelInvert()
void kernelDestroy(L_KERNEL **pkel)
kernelDestroy()
l_ok kernelGetParameters(L_KERNEL *kel, l_int32 *psy, l_int32 *psx, l_int32 *pcy, l_int32 *pcx)
kernelGetParameters()
L_KERNEL * kernelNormalize(L_KERNEL *kels, l_float32 normsum)
kernelNormalize()
L_KERNEL * kernelCopy(L_KERNEL *kels)
kernelCopy()
l_uint32 * pixGetData(PIX *pix)
pixGetData()
void pixDestroy(PIX **ppix)
pixDestroy()
l_ok pixGetDimensions(const PIX *pix, l_int32 *pw, l_int32 *ph, l_int32 *pd)
pixGetDimensions()
PIX * pixCopy(PIX *pixd, const PIX *pixs)
pixCopy()
PIX * pixCreateTemplate(const PIX *pixs)
pixCreateTemplate()
PIX * pixCreate(l_int32 width, l_int32 height, l_int32 depth)
pixCreate()
PIX * pixClone(PIX *pixs)
pixClone()
PIX * pixGetRGBComponent(PIX *pixs, l_int32 comp)
pixGetRGBComponent()
PIX * pixCreateRGBImage(PIX *pixr, PIX *pixg, PIX *pixb)
pixCreateRGBImage()
PIX * pixAddBorderGeneral(PIX *pixs, l_int32 left, l_int32 right, l_int32 top, l_int32 bot, l_uint32 val)
pixAddBorderGeneral()
l_ok pixSetAll(PIX *pix)
pixSetAll()
l_ok pixSetPadBits(PIX *pix, l_int32 val)
pixSetPadBits()
l_ok composeRGBPixel(l_int32 rval, l_int32 gval, l_int32 bval, l_uint32 *ppixel)
composeRGBPixel()
void extractRGBValues(l_uint32 pixel, l_int32 *prval, l_int32 *pgval, l_int32 *pbval)
extractRGBValues()
PIX * pixAddMirroredBorder(PIX *pixs, l_int32 left, l_int32 right, l_int32 top, l_int32 bot)
pixAddMirroredBorder()
PIX * pixInvert(PIX *pixd, PIX *pixs)
pixInvert()
@ REMOVE_CMAP_BASED_ON_SRC
PIX * pixRemoveColormap(PIX *pixs, l_int32 type)
pixRemoveColormap()
PIX * pixTilingGetTile(PIXTILING *pt, l_int32 i, l_int32 j)
pixTilingGetTile()
void pixTilingDestroy(PIXTILING **ppt)
pixTilingDestroy()
l_ok pixTilingPaintTile(PIX *pixd, l_int32 i, l_int32 j, PIX *pixs, PIXTILING *pt)
pixTilingPaintTile()
PIXTILING * pixTilingCreate(PIX *pixs, l_int32 nx, l_int32 ny, l_int32 w, l_int32 h, l_int32 xoverlap, l_int32 yoverlap)
pixTilingCreate()