105 #include <config_auto.h>
109 #include "allheaders.h"
133 l_int32 w, h, d, i, j, val, wplt, wpld;
135 l_uint32 *datat, *linet;
136 l_float32 *datad, *lined;
141 return (
FPIX *)ERROR_PTR(
"pixs not defined", __func__, NULL);
144 if (pixGetColormap(pixs))
146 else if (pixGetDepth(pixs) == 32 && ncomps == 3)
151 if (d != 1 && d != 2 && d != 4 && d != 8 && d != 16 && d != 32) {
153 return (
FPIX *)ERROR_PTR(
"invalid depth", __func__, NULL);
158 return (
FPIX *)ERROR_PTR(
"fpixd not made", __func__, NULL);
161 wplt = pixGetWpl(pixt);
164 for (i = 0; i < h; i++) {
165 linet = datat + i * wplt;
166 lined = datad + i * wpld;
168 for (j = 0; j < w; j++) {
170 lined[j] = (l_float32)val;
173 for (j = 0; j < w; j++) {
175 lined[j] = (l_float32)val;
178 for (j = 0; j < w; j++) {
180 lined[j] = (l_float32)val;
183 for (j = 0; j < w; j++) {
185 lined[j] = (l_float32)val;
187 }
else if (d == 16) {
188 for (j = 0; j < w; j++) {
190 lined[j] = (l_float32)val;
193 for (j = 0; j < w; j++) {
195 lined[j] = (l_float32)uval;
224 l_int32 w, h, d, i, j, val, wplt, wpld;
226 l_uint32 *datat, *linet;
227 l_float64 *datad, *lined;
232 return (
DPIX *)ERROR_PTR(
"pixs not defined", __func__, NULL);
235 if (pixGetColormap(pixs))
237 else if (pixGetDepth(pixs) == 32 && ncomps == 3)
242 if (d != 1 && d != 2 && d != 4 && d != 8 && d != 16 && d != 32) {
244 return (
DPIX *)ERROR_PTR(
"invalid depth", __func__, NULL);
249 return (
DPIX *)ERROR_PTR(
"dpixd not made", __func__, NULL);
252 wplt = pixGetWpl(pixt);
255 for (i = 0; i < h; i++) {
256 linet = datat + i * wplt;
257 lined = datad + i * wpld;
259 for (j = 0; j < w; j++) {
261 lined[j] = (l_float64)val;
264 for (j = 0; j < w; j++) {
266 lined[j] = (l_float64)val;
269 for (j = 0; j < w; j++) {
271 lined[j] = (l_float64)val;
274 for (j = 0; j < w; j++) {
276 lined[j] = (l_float64)val;
278 }
else if (d == 16) {
279 for (j = 0; j < w; j++) {
281 lined[j] = (l_float64)val;
284 for (j = 0; j < w; j++) {
286 lined[j] = (l_float64)uval;
325 l_int32 w, h, i, j, wpls, wpld;
326 l_uint32 vald, maxval;
328 l_float32 *datas, *lines;
329 l_uint32 *datad, *lined;
333 return (
PIX *)ERROR_PTR(
"fpixs not defined", __func__, NULL);
335 return (
PIX *)ERROR_PTR(
"invalid negvals", __func__, NULL);
336 if (outdepth != 0 && outdepth != 8 && outdepth != 16 && outdepth != 32)
337 return (
PIX *)ERROR_PTR(
"outdepth not in {0,8,16,32}", __func__, NULL);
346 for (i = 0; i < h && outdepth < 32; i++) {
347 lines = datas + i * wpls;
348 for (j = 0; j < w && outdepth < 32; j++) {
349 if (lines[j] > 65535.5)
351 else if (lines[j] > 255.5)
358 else if (outdepth == 16)
366 l_int32 overvals = 0;
367 for (i = 0; i < h; i++) {
368 lines = datas + i * wpls;
369 for (j = 0; j < w; j++) {
373 else if (val > maxval)
378 L_ERROR(
"Number of negative values: %d\n", __func__, negs);
380 L_ERROR(
"Number of too-large values: %d\n", __func__, overvals);
384 if ((pixd =
pixCreate(w, h, outdepth)) == NULL)
385 return (
PIX *)ERROR_PTR(
"pixd not made", __func__, NULL);
387 wpld = pixGetWpl(pixd);
388 for (i = 0; i < h; i++) {
389 lines = datas + i * wpls;
390 lined = datad + i * wpld;
391 for (j = 0; j < w; j++) {
394 vald = (l_uint32)(val + 0.5);
398 vald = (l_uint32)(-val + 0.5);
404 else if (outdepth == 16)
425 l_int32 i, j, w, h, wpls, wpld;
426 l_float32 factor, sval, maxval;
427 l_float32 *lines, *datas;
428 l_uint32 *lined, *datad;
432 return (
PIX *)ERROR_PTR(
"fpixs not defined", __func__, NULL);
439 for (i = 0; i < h; i++) {
440 lines = datas + i * wpls;
441 for (j = 0; j < w; j++) {
453 wpld = pixGetWpl(pixd);
454 factor = 255. / maxval;
455 for (i = 0; i < h; i++) {
456 lines = datas + i * wpls;
457 lined = datad + i * wpld;
458 for (j = 0; j < w; j++) {
460 if (sval < 0.0) sval = 0.0;
461 dval = (l_uint8)(factor * sval + 0.5);
479 l_int32 w, h, i, j, wpls, wpld;
481 l_float32 *datas, *lines;
482 l_float64 *datad, *lined;
486 return (
DPIX *)ERROR_PTR(
"fpix not defined", __func__, NULL);
490 return (
DPIX *)ERROR_PTR(
"dpix not made", __func__, NULL);
496 for (i = 0; i < h; i++) {
497 lines = datas + i * wpls;
498 lined = datad + i * wpld;
499 for (j = 0; j < w; j++) {
538 l_int32 w, h, i, j, wpls, wpld, maxval;
541 l_float64 *datas, *lines;
542 l_uint32 *datad, *lined;
546 return (
PIX *)ERROR_PTR(
"dpixs not defined", __func__, NULL);
548 return (
PIX *)ERROR_PTR(
"invalid negvals", __func__, NULL);
549 if (outdepth != 0 && outdepth != 8 && outdepth != 16 && outdepth != 32)
550 return (
PIX *)ERROR_PTR(
"outdepth not in {0,8,16,32}", __func__, NULL);
559 for (i = 0; i < h && outdepth < 32; i++) {
560 lines = datas + i * wpls;
561 for (j = 0; j < w && outdepth < 32; j++) {
562 if (lines[j] > 65535.5)
564 else if (lines[j] > 255.5)
578 l_int32 overvals = 0;
579 for (i = 0; i < h; i++) {
580 lines = datas + i * wpls;
581 for (j = 0; j < w; j++) {
585 else if (val > maxval)
590 L_ERROR(
"Number of negative values: %d\n", __func__, negs);
592 L_ERROR(
"Number of too-large values: %d\n", __func__, overvals);
596 if ((pixd =
pixCreate(w, h, outdepth)) == NULL)
597 return (
PIX *)ERROR_PTR(
"pixd not made", __func__, NULL);
599 wpld = pixGetWpl(pixd);
600 for (i = 0; i < h; i++) {
601 lines = datas + i * wpls;
602 lined = datad + i * wpld;
603 for (j = 0; j < w; j++) {
606 vald = (l_uint32)(val + 0.5);
611 vald = (l_uint32)(-val + 0.5);
617 else if (outdepth == 16)
637 l_int32 w, h, i, j, wpls, wpld;
639 l_float32 *datad, *lined;
640 l_float64 *datas, *lines;
644 return (
FPIX *)ERROR_PTR(
"dpix not defined", __func__, NULL);
648 return (
FPIX *)ERROR_PTR(
"fpix not made", __func__, NULL);
654 for (i = 0; i < h; i++) {
655 lines = datas + i * wpls;
656 lined = datad + i * wpld;
657 for (j = 0; j < w; j++) {
659 lined[j] = (l_float32)val;
686 l_int32 i, j, w, h, wpl, xminloc, yminloc;
687 l_float32 *data, *line;
690 if (!pminval && !pxminloc && !pyminloc)
691 return ERROR_INT(
"no return val requested", __func__, 1);
692 if (pminval) *pminval = 0.0;
693 if (pxminloc) *pxminloc = 0;
694 if (pyminloc) *pyminloc = 0;
696 return ERROR_INT(
"fpix not defined", __func__, 1);
704 for (i = 0; i < h; i++) {
705 line = data + i * wpl;
706 for (j = 0; j < w; j++) {
707 if (line[j] < minval) {
715 if (pminval) *pminval = minval;
716 if (pxminloc) *pxminloc = xminloc;
717 if (pyminloc) *pyminloc = yminloc;
737 l_int32 i, j, w, h, wpl, xmaxloc, ymaxloc;
738 l_float32 *data, *line;
741 if (!pmaxval && !pxmaxloc && !pymaxloc)
742 return ERROR_INT(
"no return val requested", __func__, 1);
743 if (pmaxval) *pmaxval = 0.0;
744 if (pxmaxloc) *pxmaxloc = 0;
745 if (pymaxloc) *pymaxloc = 0;
747 return ERROR_INT(
"fpix not defined", __func__, 1);
755 for (i = 0; i < h; i++) {
756 line = data + i * wpl;
757 for (j = 0; j < w; j++) {
758 if (line[j] > maxval) {
766 if (pmaxval) *pmaxval = maxval;
767 if (pxmaxloc) *pxmaxloc = xmaxloc;
768 if (pymaxloc) *pymaxloc = ymaxloc;
788 l_int32 i, j, w, h, wpl, xminloc, yminloc;
789 l_float64 *data, *line;
792 if (!pminval && !pxminloc && !pyminloc)
793 return ERROR_INT(
"no return val requested", __func__, 1);
794 if (pminval) *pminval = 0.0;
795 if (pxminloc) *pxminloc = 0;
796 if (pyminloc) *pyminloc = 0;
798 return ERROR_INT(
"dpix not defined", __func__, 1);
806 for (i = 0; i < h; i++) {
807 line = data + i * wpl;
808 for (j = 0; j < w; j++) {
809 if (line[j] < minval) {
817 if (pminval) *pminval = minval;
818 if (pxminloc) *pxminloc = xminloc;
819 if (pyminloc) *pyminloc = yminloc;
839 l_int32 i, j, w, h, wpl, xmaxloc, ymaxloc;
840 l_float64 *data, *line;
843 if (!pmaxval && !pxmaxloc && !pymaxloc)
844 return ERROR_INT(
"no return val requested", __func__, 1);
845 if (pmaxval) *pmaxval = 0.0;
846 if (pxmaxloc) *pxmaxloc = 0;
847 if (pymaxloc) *pymaxloc = 0;
849 return ERROR_INT(
"dpix not defined", __func__, 1);
857 for (i = 0; i < h; i++) {
858 line = data + i * wpl;
859 for (j = 0; j < w; j++) {
860 if (line[j] > maxval) {
868 if (pmaxval) *pmaxval = maxval;
869 if (pxmaxloc) *pxmaxloc = xmaxloc;
870 if (pymaxloc) *pymaxloc = ymaxloc;
902 l_int32 i, j, k, m, ws, hs, wd, hd, wpls, wpld;
903 l_float32 val0, val1, val2, val3;
904 l_float32 *datas, *datad, *lines, *lined, *fract;
908 return (
FPIX *)ERROR_PTR(
"fpixs not defined", __func__, NULL);
911 wd = factor * (ws - 1) + 1;
912 hd = factor * (hs - 1) + 1;
918 fract = (l_float32 *)LEPT_CALLOC(factor,
sizeof(l_float32));
919 for (i = 0; i < factor; i++)
920 fract[i] = i / (l_float32)factor;
921 for (i = 0; i < hs - 1; i++) {
922 lines = datas + i * wpls;
923 for (j = 0; j < ws - 1; j++) {
926 val2 = lines[wpls + j];
927 val3 = lines[wpls + j + 1];
928 for (k = 0; k < factor; k++) {
929 lined = datad + (i * factor + k) * wpld;
930 for (m = 0; m < factor; m++) {
931 lined[j * factor + m] =
932 val0 * (1.0 - fract[m]) * (1.0 - fract[k]) +
933 val1 * fract[m] * (1.0 - fract[k]) +
934 val2 * (1.0 - fract[m]) * fract[k] +
935 val3 * fract[m] * fract[k];
942 for (i = 0; i < hs - 1; i++) {
943 lines = datas + i * wpls;
944 val0 = lines[ws - 1];
945 val1 = lines[wpls + ws - 1];
946 for (k = 0; k < factor; k++) {
947 lined = datad + (i * factor + k) * wpld;
948 lined[wd - 1] = val0 * (1.0 - fract[k]) + val1 * fract[k];
953 lines = datas + (hs - 1) * wpls;
954 lined = datad + (hd - 1) * wpld;
955 for (j = 0; j < ws - 1; j++) {
958 for (m = 0; m < factor; m++)
959 lined[j * factor + m] = val0 * (1.0 - fract[m]) + val1 * fract[m];
960 lined[wd - 1] = lines[ws - 1];
992 l_int32 i, j, k, m, ws, hs, wd, hd, wpls, wpld;
993 l_float64 val0, val1, val2, val3;
994 l_float64 *datas, *datad, *lines, *lined, *fract;
998 return (
DPIX *)ERROR_PTR(
"dpixs not defined", __func__, NULL);
1001 wd = factor * (ws - 1) + 1;
1002 hd = factor * (hs - 1) + 1;
1008 fract = (l_float64 *)LEPT_CALLOC(factor,
sizeof(l_float64));
1009 for (i = 0; i < factor; i++)
1010 fract[i] = i / (l_float64)factor;
1011 for (i = 0; i < hs - 1; i++) {
1012 lines = datas + i * wpls;
1013 for (j = 0; j < ws - 1; j++) {
1015 val1 = lines[j + 1];
1016 val2 = lines[wpls + j];
1017 val3 = lines[wpls + j + 1];
1018 for (k = 0; k < factor; k++) {
1019 lined = datad + (i * factor + k) * wpld;
1020 for (m = 0; m < factor; m++) {
1021 lined[j * factor + m] =
1022 val0 * (1.0 - fract[m]) * (1.0 - fract[k]) +
1023 val1 * fract[m] * (1.0 - fract[k]) +
1024 val2 * (1.0 - fract[m]) * fract[k] +
1025 val3 * fract[m] * fract[k];
1032 for (i = 0; i < hs - 1; i++) {
1033 lines = datas + i * wpls;
1034 val0 = lines[ws - 1];
1035 val1 = lines[wpls + ws - 1];
1036 for (k = 0; k < factor; k++) {
1037 lined = datad + (i * factor + k) * wpld;
1038 lined[wd - 1] = val0 * (1.0 - fract[k]) + val1 * fract[k];
1043 lines = datas + (hs - 1) * wpls;
1044 lined = datad + (hd - 1) * wpld;
1045 for (j = 0; j < ws - 1; j++) {
1047 val1 = lines[j + 1];
1048 for (m = 0; m < factor; m++)
1049 lined[j * factor + m] = val0 * (1.0 - fract[m]) + val1 * fract[m];
1050 lined[wd - 1] = lines[ws - 1];
1088 l_int32 i, j, ws, hs, w, h, wpls, wpld;
1089 l_float32 *datas, *datad, *lines, *lined;
1092 return (
FPIX *)ERROR_PTR(
"fpixs1 not defined", __func__, fpixd);
1094 return (
FPIX *)ERROR_PTR(
"fpixs2 not defined", __func__, fpixd);
1095 if (fpixd && (fpixd != fpixs1))
1096 return (
FPIX *)ERROR_PTR(
"invalid inplace operation", __func__, fpixd);
1108 for (i = 0; i < h; i++) {
1109 lines = datas + i * wpls;
1110 lined = datad + i * wpld;
1111 for (j = 0; j < w; j++)
1112 lined[j] = a * lined[j] + b * lines[j];
1140 l_int32 i, j, w, h, wpl;
1141 l_float32 *line, *data;
1144 return ERROR_INT(
"fpix not defined", __func__, 1);
1146 if (addc == 0.0 && multc == 1.0)
1152 for (i = 0; i < h; i++) {
1153 line = data + i * wpl;
1155 for (j = 0; j < w; j++)
1157 }
else if (multc == 1.0) {
1158 for (j = 0; j < w; j++)
1161 for (j = 0; j < w; j++) {
1162 line[j] = multc * line[j] + addc;
1198 l_int32 i, j, ws, hs, w, h, wpls, wpld;
1199 l_float64 *datas, *datad, *lines, *lined;
1202 return (
DPIX *)ERROR_PTR(
"dpixs1 not defined", __func__, dpixd);
1204 return (
DPIX *)ERROR_PTR(
"dpixs2 not defined", __func__, dpixd);
1205 if (dpixd && (dpixd != dpixs1))
1206 return (
DPIX *)ERROR_PTR(
"invalid inplace operation", __func__, dpixd);
1218 for (i = 0; i < h; i++) {
1219 lines = datas + i * wpls;
1220 lined = datad + i * wpld;
1221 for (j = 0; j < w; j++)
1222 lined[j] = a * lined[j] + b * lines[j];
1250 l_int32 i, j, w, h, wpl;
1251 l_float64 *line, *data;
1254 return ERROR_INT(
"dpix not defined", __func__, 1);
1256 if (addc == 0.0 && multc == 1.0)
1262 for (i = 0; i < h; i++) {
1263 line = data + i * wpl;
1265 for (j = 0; j < w; j++)
1267 }
else if (multc == 1.0) {
1268 for (j = 0; j < w; j++)
1271 for (j = 0; j < w; j++)
1272 line[j] = multc * line[j] + addc;
1295 l_float32 *data, *line;
1298 return ERROR_INT(
"fpix not defined", __func__, 1);
1302 for (i = 0; i < h; i++) {
1303 line = data + i * w;
1304 for (j = 0; j < w; j++)
1305 *(line + j) = inval;
1324 l_float64 *data, *line;
1327 return ERROR_INT(
"dpix not defined", __func__, 1);
1331 for (i = 0; i < h; i++) {
1332 line = data + i * w;
1333 for (j = 0; j < w; j++)
1334 *(line + j) = inval;
1363 l_int32 ws, hs, wd, hd;
1367 return (
FPIX *)ERROR_PTR(
"fpixs not defined", __func__, NULL);
1369 if (left <= 0 && right <= 0 && top <= 0 && bot <= 0)
1372 wd = ws + left + right;
1373 hd = hs + top + bot;
1375 return (
FPIX *)ERROR_PTR(
"fpixd not made", __func__, NULL);
1397 l_int32 ws, hs, wd, hd;
1401 return (
FPIX *)ERROR_PTR(
"fpixs not defined", __func__, NULL);
1403 if (left <= 0 && right <= 0 && top <= 0 && bot <= 0)
1406 wd = ws - left - right;
1407 hd = hs - top - bot;
1408 if (wd <= 0 || hd <= 0)
1409 return (
FPIX *)ERROR_PTR(
"width & height not both > 0", __func__, NULL);
1411 return (
FPIX *)ERROR_PTR(
"fpixd not made", __func__, NULL);
1443 return (
FPIX *)ERROR_PTR(
"fpixs not defined", __func__, NULL);
1447 for (j = 0; j < left; j++)
1449 fpixd, left + j, top);
1450 for (j = 0; j < right; j++)
1452 fpixd, left + w - 1 - j, top);
1453 for (i = 0; i < top; i++)
1454 fpixRasterop(fpixd, 0, top - 1 - i, left + w + right, 1,
1456 for (i = 0; i < bot; i++)
1457 fpixRasterop(fpixd, 0, top + h + i, left + w + right, 1,
1458 fpixd, 0, top + h - 1 - i);
1488 return (
FPIX *)ERROR_PTR(
"fpixs not defined", __func__, NULL);
1492 for (j = 0; j < left; j++)
1494 for (j = 0; j < right; j++)
1495 fpixRasterop(fpixd, left + w + j, top, 1, h, fpixd, left + w - 1, top);
1496 for (i = 0; i < top; i++)
1497 fpixRasterop(fpixd, 0, i, left + w + right, 1, fpixd, 0, top);
1498 for (i = 0; i < bot; i++)
1499 fpixRasterop(fpixd, 0, top + h + i, left + w + right, 1,
1500 fpixd, 0, top + h - 1);
1527 l_int32 i, j, w, h, fullw, fullh;
1528 l_float32 val1, val2, del;
1532 return (
FPIX *)ERROR_PTR(
"fpixs not defined", __func__, NULL);
1538 for (i = top; i < top + h; i++) {
1542 for (j = 0; j < left; j++)
1547 fullw = left + w + right;
1548 for (i = top; i < top + h; i++) {
1552 for (j = left + w; j < fullw; j++)
1553 fpixSetPixel(fpixd, j, i, val1 + del * (j - left - w + 1));
1557 for (j = 0; j < fullw; j++) {
1561 for (i = 0; i < top; i++)
1566 fullh = top + h + bot;
1567 for (j = 0; j < fullw; j++) {
1571 for (i = top + h; i < fullh; i++)
1572 fpixSetPixel(fpixd, j, i, val1 + del * (i - top - h + 1));
1617 l_int32 fsw, fsh, fdw, fdh, dhangw, shangw, dhangh, shangh;
1618 l_int32 i, j, wpls, wpld;
1619 l_float32 *datas, *datad, *lines, *lined;
1622 return ERROR_INT(
"fpixs not defined", __func__, 1);
1624 return ERROR_INT(
"fpixd not defined", __func__, 1);
1643 dhangw = dx + dw - fdw;
1646 shangw = sx + dw - fsw;
1661 dhangh = dy + dh - fdh;
1664 shangh = sy + dh - fsh;
1669 if ((dw <= 0) || (dh <= 0))
1679 datas += sy * wpls + sx;
1680 datad += dy * wpld + dx;
1681 for (i = 0; i < dh; i++) {
1682 lines = datas + i * wpls;
1683 lined = datad + i * wpld;
1684 for (j = 0; j < dw; j++) {
1710 return (
FPIX *)ERROR_PTR(
"fpixs not defined", __func__, NULL);
1711 if (quads < 0 || quads > 3)
1712 return (
FPIX *)ERROR_PTR(
"quads not in {0,1,2,3}", __func__, NULL);
1716 else if (quads == 1)
1718 else if (quads == 2)
1751 return (
FPIX *)ERROR_PTR(
"fpixs not defined", __func__, NULL);
1781 l_int32 i, j, wd, hd, wpls, wpld;
1782 l_float32 *datas, *datad, *lines, *lined;
1786 return (
FPIX *)ERROR_PTR(
"fpixs not defined", __func__, NULL);
1787 if (direction != 1 && direction != -1)
1788 return (
FPIX *)ERROR_PTR(
"invalid direction", __func__, NULL);
1792 return (
FPIX *)ERROR_PTR(
"fpixd not made", __func__, NULL);
1799 if (direction == 1) {
1800 for (i = 0; i < hd; i++) {
1801 lined = datad + i * wpld;
1802 lines = datas + (wd - 1) * wpls;
1803 for (j = 0; j < wd; j++) {
1804 lined[j] = lines[i];
1809 for (i = 0; i < hd; i++) {
1810 lined = datad + i * wpld;
1812 for (j = 0; j < wd; j++) {
1813 lined[j] = lines[hd - 1 - i];
1847 l_int32 i, j, w, h, wpl, bpl;
1848 l_float32 *line, *data, *buffer;
1851 return (
FPIX *)ERROR_PTR(
"fpixs not defined", __func__, NULL);
1861 buffer = (l_float32 *)LEPT_CALLOC(wpl,
sizeof(l_float32));
1862 for (i = 0; i < h; i++) {
1863 line = data + i * wpl;
1864 memcpy(buffer, line, bpl);
1865 for (j = 0; j < w; j++)
1866 line[j] = buffer[w - 1 - j];
1897 l_int32 i, k, h, h2, wpl, bpl;
1898 l_float32 *linet, *lineb, *data, *buffer;
1901 return (
FPIX *)ERROR_PTR(
"fpixs not defined", __func__, NULL);
1910 buffer = (l_float32 *)LEPT_CALLOC(wpl,
sizeof(l_float32));
1913 for (i = 0, k = h - 1; i < h2; i++, k--) {
1914 linet = data + i * wpl;
1915 lineb = data + k * wpl;
1916 memcpy(buffer, linet, bpl);
1917 memcpy(linet, lineb, bpl);
1918 memcpy(lineb, buffer, bpl);
1959 FPIX *fpixs2, *fpixd, *fpixd2;
1962 return (
FPIX *)ERROR_PTR(
"fpixs not defined", __func__, NULL);
1964 return (
FPIX *)ERROR_PTR(
"ptas not defined", __func__, NULL);
1966 return (
FPIX *)ERROR_PTR(
"ptad not defined", __func__, NULL);
2010 l_int32 i, j, w, h, wpld;
2012 l_float32 *datas, *datad, *lined;
2017 return (
FPIX *)ERROR_PTR(
"fpixs not defined", __func__, NULL);
2020 return (
FPIX *)ERROR_PTR(
"vc not defined", __func__, NULL);
2029 for (i = 0; i < h; i++) {
2030 lined = datad + i * wpld;
2031 for (j = 0; j < w; j++) {
2074 FPIX *fpixs2, *fpixd, *fpixd2;
2077 return (
FPIX *)ERROR_PTR(
"fpixs not defined", __func__, NULL);
2079 return (
FPIX *)ERROR_PTR(
"ptas not defined", __func__, NULL);
2081 return (
FPIX *)ERROR_PTR(
"ptad not defined", __func__, NULL);
2125 l_int32 i, j, w, h, wpld;
2127 l_float32 *datas, *datad, *lined;
2132 return (
FPIX *)ERROR_PTR(
"fpixs not defined", __func__, NULL);
2135 return (
FPIX *)ERROR_PTR(
"vc not defined", __func__, NULL);
2144 for (i = 0; i < h; i++) {
2145 lined = datad + i * wpld;
2146 for (j = 0; j < w; j++) {
2185 l_int32 xpm, ypm, xp, yp, xf, yf;
2186 l_float32 v00, v01, v10, v11;
2190 return ERROR_INT(
"&val not defined", __func__, 1);
2193 return ERROR_INT(
"datas not defined", __func__, 1);
2196 if (x < 0.0 || y < 0.0 || x > w - 2.0 || y > h - 2.0)
2199 xpm = (l_int32)(16.0 * x + 0.5);
2200 ypm = (l_int32)(16.0 * y + 0.5);
2207 if (xf < 0 || yf < 0)
2208 lept_stderr(
"xp = %d, yp = %d, xf = %d, yf = %d\n", xp, yp, xf, yf);
2212 lines = datas + yp * w;
2213 v00 = (16.0 - xf) * (16.0 - yf) * (*(lines + xp));
2214 v10 = xf * (16.0 - yf) * (*(lines + xp + 1));
2215 v01 = (16.0 - xf) * yf * (*(lines + w + xp));
2216 v11 = (l_float32)(xf) * yf * (*(lines + w + xp + 1));
2217 *pval = (v00 + v01 + v10 + v11) / 256.0;
2242 l_int32 i, j, w, h, wpls, wpld;
2243 l_float32 *datas, *lines;
2244 l_uint32 *datad, *lined;
2248 return (
PIX *)ERROR_PTR(
"fpix not defined", __func__, NULL);
2255 wpld = pixGetWpl(pixd);
2256 for (i = 0; i < h; i++) {
2257 lines = datas + i * wpls;
2258 lined = datad + i * wpld;
2259 for (j = 0; j < w; j++) {
2260 if (lines[j] <= thresh)
2303 l_int32 i, j, w, h, wpls, wpld, rval, gval, bval, zerodenom, onedenom;
2304 l_float32 fnum, fdenom;
2305 l_uint32 *datas, *lines;
2306 l_float32 *datad, *lined, *recip;
2309 if (!pix || pixGetDepth(pix) != 32)
2310 return (
FPIX *)ERROR_PTR(
"pix undefined or not 32 bpp", __func__, NULL);
2314 wpls = pixGetWpl(pix);
2318 zerodenom = (rdenom == 0.0 && gdenom == 0.0 && bdenom == 0.0) ? 1: 0;
2319 onedenom = ((rdenom == 1.0 && gdenom == 0.0 && bdenom == 0.0) ||
2320 (rdenom == 0.0 && gdenom == 1.0 && bdenom == 0.0) ||
2321 (rdenom == 0.0 && gdenom == 0.0 && bdenom == 1.0)) ? 1 : 0;
2324 recip = (l_float32 *)LEPT_CALLOC(256,
sizeof(l_float32));
2326 for (i = 1; i < 256; i++)
2327 recip[i] = 1.0 / (l_float32)i;
2329 for (i = 0; i < h; i++) {
2330 lines = datas + i * wpls;
2331 lined = datad + i * wpld;
2333 for (j = 0; j < w; j++) {
2335 lined[j] = rnum * rval + gnum * gval + bnum * bval;
2337 }
else if (onedenom && rdenom == 1.0) {
2338 for (j = 0; j < w; j++) {
2341 = recip[rval] * (rnum * rval + gnum * gval + bnum * bval);
2343 }
else if (onedenom && gdenom == 1.0) {
2344 for (j = 0; j < w; j++) {
2347 = recip[gval] * (rnum * rval + gnum * gval + bnum * bval);
2349 }
else if (onedenom && bdenom == 1.0) {
2350 for (j = 0; j < w; j++) {
2353 = recip[bval] * (rnum * rval + gnum * gval + bnum * bval);
2356 for (j = 0; j < w; j++) {
2358 fnum = rnum * rval + gnum * gval + bnum * bval;
2359 fdenom = rdenom * rval + gdenom * gval + bdenom * bval;
2360 lined[j] = (fdenom == 0) ? 256.0 * fnum : fnum / fdenom;
l_ok affineXformPt(l_float32 *vc, l_int32 x, l_int32 y, l_float32 *pxp, l_float32 *pyp)
affineXformPt()
l_ok getAffineXformCoeffs(PTA *ptas, PTA *ptad, l_float32 **pvc)
getAffineXformCoeffs()
#define GET_DATA_QBIT(pdata, n)
#define GET_DATA_TWO_BYTES(pdata, n)
#define SET_DATA_BIT(pdata, n)
#define SET_DATA_TWO_BYTES(pdata, n, val)
#define SET_DATA_FOUR_BYTES(pdata, n, val)
#define GET_DATA_BYTE(pdata, n)
#define GET_DATA_FOUR_BYTES(pdata, n)
#define GET_DATA_DIBIT(pdata, n)
#define SET_DATA_BYTE(pdata, n, val)
#define GET_DATA_BIT(pdata, n)
DPIX * dpixCopy(DPIX *dpixs)
dpixCopy()
l_ok fpixCopyResolution(FPIX *fpixd, FPIX *fpixs)
fpixCopyResolution()
FPIX * fpixCreateTemplate(FPIX *fpixs)
fpixCreateTemplate()
l_ok dpixGetDimensions(DPIX *dpix, l_int32 *pw, l_int32 *ph)
dpixGetDimensions()
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()
l_ok fpixSetPixel(FPIX *fpix, l_int32 x, l_int32 y, l_float32 val)
fpixSetPixel()
void fpixDestroy(FPIX **pfpix)
fpixDestroy()
FPIX * fpixCreate(l_int32 width, l_int32 height)
fpixCreate()
l_ok fpixGetPixel(FPIX *fpix, l_int32 x, l_int32 y, l_float32 *pval)
fpixGetPixel()
FPIX * fpixClone(FPIX *fpix)
fpixClone()
l_float32 * fpixGetData(FPIX *fpix)
fpixGetData()
FPIX * fpixCopy(FPIX *fpixs)
fpixCopy()
DPIX * pixConvertToDPix(PIX *pixs, l_int32 ncomps)
pixConvertToDPix()
DPIX * dpixScaleByInteger(DPIX *dpixs, l_int32 factor)
dpixScaleByInteger()
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()
FPIX * fpixAddSlopeBorder(FPIX *fpixs, l_int32 left, l_int32 right, l_int32 top, l_int32 bot)
fpixAddSlopeBorder()
FPIX * fpixRotate180(FPIX *fpixd, FPIX *fpixs)
fpixRotate180()
l_ok fpixRasterop(FPIX *fpixd, l_int32 dx, l_int32 dy, l_int32 dw, l_int32 dh, FPIX *fpixs, l_int32 sx, l_int32 sy)
fpixRasterop()
FPIX * fpixFlipLR(FPIX *fpixd, FPIX *fpixs)
pixFlipLR()
l_ok fpixGetMax(FPIX *fpix, l_float32 *pmaxval, l_int32 *pxmaxloc, l_int32 *pymaxloc)
fpixGetMax()
PIX * fpixDisplayMaxDynamicRange(FPIX *fpixs)
fpixDisplayMaxDynamicRange()
FPIX * fpixProjectivePta(FPIX *fpixs, PTA *ptad, PTA *ptas, l_int32 border, l_float32 inval)
fpixProjectivePta()
FPIX * fpixScaleByInteger(FPIX *fpixs, l_int32 factor)
fpixScaleByInteger()
FPIX * fpixRemoveBorder(FPIX *fpixs, l_int32 left, l_int32 right, l_int32 top, l_int32 bot)
fpixRemoveBorder()
l_ok linearInterpolatePixelFloat(l_float32 *datas, l_int32 w, l_int32 h, l_float32 x, l_float32 y, l_float32 inval, l_float32 *pval)
linearInterpolatePixelFloat()
l_ok fpixAddMultConstant(FPIX *fpix, l_float32 addc, l_float32 multc)
fpixAddMultConstant()
FPIX * fpixAffine(FPIX *fpixs, l_float32 *vc, l_float32 inval)
fpixAffine()
FPIX * pixComponentFunction(PIX *pix, l_float32 rnum, l_float32 gnum, l_float32 bnum, l_float32 rdenom, l_float32 gdenom, l_float32 bdenom)
pixComponentFunction()
DPIX * fpixConvertToDPix(FPIX *fpix)
fpixConvertToDPix()
FPIX * fpixRotateOrth(FPIX *fpixs, l_int32 quads)
fpixRotateOrth()
FPIX * fpixAffinePta(FPIX *fpixs, PTA *ptad, PTA *ptas, l_int32 border, l_float32 inval)
fpixAffinePta()
l_ok dpixSetAllArbitrary(DPIX *dpix, l_float64 inval)
dpixSetAllArbitrary()
l_ok fpixGetMin(FPIX *fpix, l_float32 *pminval, l_int32 *pxminloc, l_int32 *pyminloc)
fpixGetMin()
PIX * dpixConvertToPix(DPIX *dpixs, l_int32 outdepth, l_int32 negvals, l_int32 errorflag)
dpixConvertToPix()
FPIX * fpixAddBorder(FPIX *fpixs, l_int32 left, l_int32 right, l_int32 top, l_int32 bot)
fpixAddBorder()
FPIX * fpixAddContinuedBorder(FPIX *fpixs, l_int32 left, l_int32 right, l_int32 top, l_int32 bot)
fpixAddContinuedBorder()
FPIX * pixConvertToFPix(PIX *pixs, l_int32 ncomps)
pixConvertToFPix()
FPIX * fpixLinearCombination(FPIX *fpixd, FPIX *fpixs1, FPIX *fpixs2, l_float32 a, l_float32 b)
fpixLinearCombination()
FPIX * fpixFlipTB(FPIX *fpixd, FPIX *fpixs)
fpixFlipTB()
l_ok dpixGetMin(DPIX *dpix, l_float64 *pminval, l_int32 *pxminloc, l_int32 *pyminloc)
dpixGetMin()
PIX * fpixThresholdToPix(FPIX *fpix, l_float32 thresh)
fpixThresholdToPix()
FPIX * fpixRotate90(FPIX *fpixs, l_int32 direction)
fpixRotate90()
l_ok fpixSetAllArbitrary(FPIX *fpix, l_float32 inval)
fpixSetAllArbitrary()
l_ok dpixAddMultConstant(DPIX *dpix, l_float64 addc, l_float64 multc)
dpixAddMultConstant()
FPIX * fpixProjective(FPIX *fpixs, l_float32 *vc, l_float32 inval)
fpixProjective()
DPIX * dpixLinearCombination(DPIX *dpixd, DPIX *dpixs1, DPIX *dpixs2, l_float32 a, l_float32 b)
dpixLinearCombination()
FPIX * dpixConvertToFPix(DPIX *dpix)
dpixConvertToFPix()
l_ok dpixGetMax(DPIX *dpix, l_float64 *pmaxval, l_int32 *pxmaxloc, l_int32 *pymaxloc)
dpixGetMax()
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 * pixCreate(l_int32 width, l_int32 height, l_int32 depth)
pixCreate()
PIX * pixClone(PIX *pixs)
pixClone()
void extractRGBValues(l_uint32 pixel, l_int32 *prval, l_int32 *pgval, l_int32 *pbval)
extractRGBValues()
@ REMOVE_CMAP_TO_GRAYSCALE
PIX * pixRemoveColormap(PIX *pixs, l_int32 type)
pixRemoveColormap()
PIX * pixConvertRGBToLuminance(PIX *pixs)
pixConvertRGBToLuminance()
l_ok getProjectiveXformCoeffs(PTA *ptas, PTA *ptad, l_float32 **pvc)
getProjectiveXformCoeffs()
l_ok projectiveXformPt(l_float32 *vc, l_int32 x, l_int32 y, l_float32 *pxp, l_float32 *pyp)
projectiveXformPt()
PTA * ptaClone(PTA *pta)
ptaClone()
void ptaDestroy(PTA **ppta)
ptaDestroy()
PTA * ptaTransform(PTA *ptas, l_int32 shiftx, l_int32 shifty, l_float32 scalex, l_float32 scaley)
ptaTransform()
void lept_stderr(const char *fmt,...)
lept_stderr()