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;
140 PROCNAME(
"pixConvertToFPix");
143 return (
FPIX *)ERROR_PTR(
"pixs not defined", procName, NULL);
146 if (pixGetColormap(pixs))
148 else if (pixGetDepth(pixs) == 32 && ncomps == 3)
153 if (d != 1 && d != 2 && d != 4 && d != 8 && d != 16 && d != 32) {
155 return (
FPIX *)ERROR_PTR(
"invalid depth", procName, NULL);
160 return (
FPIX *)ERROR_PTR(
"fpixd not made", procName, NULL);
163 wplt = pixGetWpl(pixt);
166 for (i = 0; i < h; i++) {
167 linet = datat + i * wplt;
168 lined = datad + i * wpld;
170 for (j = 0; j < w; j++) {
172 lined[j] = (l_float32)val;
175 for (j = 0; j < w; j++) {
177 lined[j] = (l_float32)val;
180 for (j = 0; j < w; j++) {
182 lined[j] = (l_float32)val;
185 for (j = 0; j < w; j++) {
187 lined[j] = (l_float32)val;
189 }
else if (d == 16) {
190 for (j = 0; j < w; j++) {
192 lined[j] = (l_float32)val;
195 for (j = 0; j < w; j++) {
197 lined[j] = (l_float32)uval;
226 l_int32 w, h, d, i, j, val, wplt, wpld;
228 l_uint32 *datat, *linet;
229 l_float64 *datad, *lined;
233 PROCNAME(
"pixConvertToDPix");
236 return (
DPIX *)ERROR_PTR(
"pixs not defined", procName, NULL);
239 if (pixGetColormap(pixs))
241 else if (pixGetDepth(pixs) == 32 && ncomps == 3)
246 if (d != 1 && d != 2 && d != 4 && d != 8 && d != 16 && d != 32) {
248 return (
DPIX *)ERROR_PTR(
"invalid depth", procName, NULL);
253 return (
DPIX *)ERROR_PTR(
"dpixd not made", procName, NULL);
256 wplt = pixGetWpl(pixt);
259 for (i = 0; i < h; i++) {
260 linet = datat + i * wplt;
261 lined = datad + i * wpld;
263 for (j = 0; j < w; j++) {
265 lined[j] = (l_float64)val;
268 for (j = 0; j < w; j++) {
270 lined[j] = (l_float64)val;
273 for (j = 0; j < w; j++) {
275 lined[j] = (l_float64)val;
278 for (j = 0; j < w; j++) {
280 lined[j] = (l_float64)val;
282 }
else if (d == 16) {
283 for (j = 0; j < w; j++) {
285 lined[j] = (l_float64)val;
288 for (j = 0; j < w; j++) {
290 lined[j] = (l_float64)uval;
329 l_int32 w, h, i, j, wpls, wpld;
330 l_uint32 vald, maxval;
332 l_float32 *datas, *lines;
333 l_uint32 *datad, *lined;
336 PROCNAME(
"fpixConvertToPix");
339 return (
PIX *)ERROR_PTR(
"fpixs not defined", procName, NULL);
341 return (
PIX *)ERROR_PTR(
"invalid negvals", procName, NULL);
342 if (outdepth != 0 && outdepth != 8 && outdepth != 16 && outdepth != 32)
343 return (
PIX *)ERROR_PTR(
"outdepth not in {0,8,16,32}", procName, NULL);
352 for (i = 0; i < h && outdepth < 32; i++) {
353 lines = datas + i * wpls;
354 for (j = 0; j < w && outdepth < 32; j++) {
355 if (lines[j] > 65535.5)
357 else if (lines[j] > 255.5)
364 else if (outdepth == 16)
372 l_int32 overvals = 0;
373 for (i = 0; i < h; i++) {
374 lines = datas + i * wpls;
375 for (j = 0; j < w; j++) {
379 else if (val > maxval)
384 L_ERROR(
"Number of negative values: %d\n", procName, negs);
386 L_ERROR(
"Number of too-large values: %d\n", procName, overvals);
390 if ((pixd =
pixCreate(w, h, outdepth)) == NULL)
391 return (
PIX *)ERROR_PTR(
"pixd not made", procName, NULL);
393 wpld = pixGetWpl(pixd);
394 for (i = 0; i < h; i++) {
395 lines = datas + i * wpls;
396 lined = datad + i * wpld;
397 for (j = 0; j < w; j++) {
400 vald = (l_uint32)(val + 0.5);
404 vald = (l_uint32)(-val + 0.5);
410 else if (outdepth == 16)
431 l_int32 i, j, w, h, wpls, wpld;
432 l_float32 factor, sval, maxval;
433 l_float32 *lines, *datas;
434 l_uint32 *lined, *datad;
437 PROCNAME(
"fpixDisplayMaxDynamicRange");
440 return (
PIX *)ERROR_PTR(
"fpixs not defined", procName, NULL);
447 for (i = 0; i < h; i++) {
448 lines = datas + i * wpls;
449 for (j = 0; j < w; j++) {
461 wpld = pixGetWpl(pixd);
462 factor = 255. / maxval;
463 for (i = 0; i < h; i++) {
464 lines = datas + i * wpls;
465 lined = datad + i * wpld;
466 for (j = 0; j < w; j++) {
468 if (sval < 0.0) sval = 0.0;
469 dval = (l_uint8)(factor * sval + 0.5);
487 l_int32 w, h, i, j, wpls, wpld;
489 l_float32 *datas, *lines;
490 l_float64 *datad, *lined;
493 PROCNAME(
"fpixConvertToDPix");
496 return (
DPIX *)ERROR_PTR(
"fpix not defined", procName, NULL);
500 return (
DPIX *)ERROR_PTR(
"dpix not made", procName, NULL);
506 for (i = 0; i < h; i++) {
507 lines = datas + i * wpls;
508 lined = datad + i * wpld;
509 for (j = 0; j < w; j++) {
548 l_int32 w, h, i, j, wpls, wpld, maxval;
551 l_float64 *datas, *lines;
552 l_uint32 *datad, *lined;
555 PROCNAME(
"dpixConvertToPix");
558 return (
PIX *)ERROR_PTR(
"dpixs not defined", procName, NULL);
560 return (
PIX *)ERROR_PTR(
"invalid negvals", procName, NULL);
561 if (outdepth != 0 && outdepth != 8 && outdepth != 16 && outdepth != 32)
562 return (
PIX *)ERROR_PTR(
"outdepth not in {0,8,16,32}", procName, NULL);
571 for (i = 0; i < h && outdepth < 32; i++) {
572 lines = datas + i * wpls;
573 for (j = 0; j < w && outdepth < 32; j++) {
574 if (lines[j] > 65535.5)
576 else if (lines[j] > 255.5)
590 l_int32 overvals = 0;
591 for (i = 0; i < h; i++) {
592 lines = datas + i * wpls;
593 for (j = 0; j < w; j++) {
597 else if (val > maxval)
602 L_ERROR(
"Number of negative values: %d\n", procName, negs);
604 L_ERROR(
"Number of too-large values: %d\n", procName, overvals);
608 if ((pixd =
pixCreate(w, h, outdepth)) == NULL)
609 return (
PIX *)ERROR_PTR(
"pixd not made", procName, NULL);
611 wpld = pixGetWpl(pixd);
612 for (i = 0; i < h; i++) {
613 lines = datas + i * wpls;
614 lined = datad + i * wpld;
615 for (j = 0; j < w; j++) {
618 vald = (l_uint32)(val + 0.5);
623 vald = (l_uint32)(-val + 0.5);
629 else if (outdepth == 16)
649 l_int32 w, h, i, j, wpls, wpld;
651 l_float32 *datad, *lined;
652 l_float64 *datas, *lines;
655 PROCNAME(
"dpixConvertToFPix");
658 return (
FPIX *)ERROR_PTR(
"dpix not defined", procName, NULL);
662 return (
FPIX *)ERROR_PTR(
"fpix not made", procName, NULL);
668 for (i = 0; i < h; i++) {
669 lines = datas + i * wpls;
670 lined = datad + i * wpld;
671 for (j = 0; j < w; j++) {
673 lined[j] = (l_float32)val;
700 l_int32 i, j, w, h, wpl, xminloc, yminloc;
701 l_float32 *data, *line;
704 PROCNAME(
"fpixGetMin");
706 if (!pminval && !pxminloc && !pyminloc)
707 return ERROR_INT(
"no return val requested", procName, 1);
708 if (pminval) *pminval = 0.0;
709 if (pxminloc) *pxminloc = 0;
710 if (pyminloc) *pyminloc = 0;
712 return ERROR_INT(
"fpix not defined", procName, 1);
720 for (i = 0; i < h; i++) {
721 line = data + i * wpl;
722 for (j = 0; j < w; j++) {
723 if (line[j] < minval) {
731 if (pminval) *pminval = minval;
732 if (pxminloc) *pxminloc = xminloc;
733 if (pyminloc) *pyminloc = yminloc;
753 l_int32 i, j, w, h, wpl, xmaxloc, ymaxloc;
754 l_float32 *data, *line;
757 PROCNAME(
"fpixGetMax");
759 if (!pmaxval && !pxmaxloc && !pymaxloc)
760 return ERROR_INT(
"no return val requested", procName, 1);
761 if (pmaxval) *pmaxval = 0.0;
762 if (pxmaxloc) *pxmaxloc = 0;
763 if (pymaxloc) *pymaxloc = 0;
765 return ERROR_INT(
"fpix not defined", procName, 1);
773 for (i = 0; i < h; i++) {
774 line = data + i * wpl;
775 for (j = 0; j < w; j++) {
776 if (line[j] > maxval) {
784 if (pmaxval) *pmaxval = maxval;
785 if (pxmaxloc) *pxmaxloc = xmaxloc;
786 if (pymaxloc) *pymaxloc = ymaxloc;
806 l_int32 i, j, w, h, wpl, xminloc, yminloc;
807 l_float64 *data, *line;
810 PROCNAME(
"dpixGetMin");
812 if (!pminval && !pxminloc && !pyminloc)
813 return ERROR_INT(
"no return val requested", procName, 1);
814 if (pminval) *pminval = 0.0;
815 if (pxminloc) *pxminloc = 0;
816 if (pyminloc) *pyminloc = 0;
818 return ERROR_INT(
"dpix not defined", procName, 1);
826 for (i = 0; i < h; i++) {
827 line = data + i * wpl;
828 for (j = 0; j < w; j++) {
829 if (line[j] < minval) {
837 if (pminval) *pminval = minval;
838 if (pxminloc) *pxminloc = xminloc;
839 if (pyminloc) *pyminloc = yminloc;
859 l_int32 i, j, w, h, wpl, xmaxloc, ymaxloc;
860 l_float64 *data, *line;
863 PROCNAME(
"dpixGetMax");
865 if (!pmaxval && !pxmaxloc && !pymaxloc)
866 return ERROR_INT(
"no return val requested", procName, 1);
867 if (pmaxval) *pmaxval = 0.0;
868 if (pxmaxloc) *pxmaxloc = 0;
869 if (pymaxloc) *pymaxloc = 0;
871 return ERROR_INT(
"dpix not defined", procName, 1);
879 for (i = 0; i < h; i++) {
880 line = data + i * wpl;
881 for (j = 0; j < w; j++) {
882 if (line[j] > maxval) {
890 if (pmaxval) *pmaxval = maxval;
891 if (pxmaxloc) *pxmaxloc = xmaxloc;
892 if (pymaxloc) *pymaxloc = ymaxloc;
924 l_int32 i, j, k, m, ws, hs, wd, hd, wpls, wpld;
925 l_float32 val0, val1, val2, val3;
926 l_float32 *datas, *datad, *lines, *lined, *fract;
929 PROCNAME(
"fpixScaleByInteger");
932 return (
FPIX *)ERROR_PTR(
"fpixs not defined", procName, NULL);
935 wd = factor * (ws - 1) + 1;
936 hd = factor * (hs - 1) + 1;
942 fract = (l_float32 *)LEPT_CALLOC(factor,
sizeof(l_float32));
943 for (i = 0; i < factor; i++)
944 fract[i] = i / (l_float32)factor;
945 for (i = 0; i < hs - 1; i++) {
946 lines = datas + i * wpls;
947 for (j = 0; j < ws - 1; j++) {
950 val2 = lines[wpls + j];
951 val3 = lines[wpls + j + 1];
952 for (k = 0; k < factor; k++) {
953 lined = datad + (i * factor + k) * wpld;
954 for (m = 0; m < factor; m++) {
955 lined[j * factor + m] =
956 val0 * (1.0 - fract[m]) * (1.0 - fract[k]) +
957 val1 * fract[m] * (1.0 - fract[k]) +
958 val2 * (1.0 - fract[m]) * fract[k] +
959 val3 * fract[m] * fract[k];
966 for (i = 0; i < hs - 1; i++) {
967 lines = datas + i * wpls;
968 val0 = lines[ws - 1];
969 val1 = lines[wpls + ws - 1];
970 for (k = 0; k < factor; k++) {
971 lined = datad + (i * factor + k) * wpld;
972 lined[wd - 1] = val0 * (1.0 - fract[k]) + val1 * fract[k];
977 lines = datas + (hs - 1) * wpls;
978 lined = datad + (hd - 1) * wpld;
979 for (j = 0; j < ws - 1; j++) {
982 for (m = 0; m < factor; m++)
983 lined[j * factor + m] = val0 * (1.0 - fract[m]) + val1 * fract[m];
984 lined[wd - 1] = lines[ws - 1];
1016 l_int32 i, j, k, m, ws, hs, wd, hd, wpls, wpld;
1017 l_float64 val0, val1, val2, val3;
1018 l_float64 *datas, *datad, *lines, *lined, *fract;
1021 PROCNAME(
"dpixScaleByInteger");
1024 return (
DPIX *)ERROR_PTR(
"dpixs not defined", procName, NULL);
1027 wd = factor * (ws - 1) + 1;
1028 hd = factor * (hs - 1) + 1;
1034 fract = (l_float64 *)LEPT_CALLOC(factor,
sizeof(l_float64));
1035 for (i = 0; i < factor; i++)
1036 fract[i] = i / (l_float64)factor;
1037 for (i = 0; i < hs - 1; i++) {
1038 lines = datas + i * wpls;
1039 for (j = 0; j < ws - 1; j++) {
1041 val1 = lines[j + 1];
1042 val2 = lines[wpls + j];
1043 val3 = lines[wpls + j + 1];
1044 for (k = 0; k < factor; k++) {
1045 lined = datad + (i * factor + k) * wpld;
1046 for (m = 0; m < factor; m++) {
1047 lined[j * factor + m] =
1048 val0 * (1.0 - fract[m]) * (1.0 - fract[k]) +
1049 val1 * fract[m] * (1.0 - fract[k]) +
1050 val2 * (1.0 - fract[m]) * fract[k] +
1051 val3 * fract[m] * fract[k];
1058 for (i = 0; i < hs - 1; i++) {
1059 lines = datas + i * wpls;
1060 val0 = lines[ws - 1];
1061 val1 = lines[wpls + ws - 1];
1062 for (k = 0; k < factor; k++) {
1063 lined = datad + (i * factor + k) * wpld;
1064 lined[wd - 1] = val0 * (1.0 - fract[k]) + val1 * fract[k];
1069 lines = datas + (hs - 1) * wpls;
1070 lined = datad + (hd - 1) * wpld;
1071 for (j = 0; j < ws - 1; j++) {
1073 val1 = lines[j + 1];
1074 for (m = 0; m < factor; m++)
1075 lined[j * factor + m] = val0 * (1.0 - fract[m]) + val1 * fract[m];
1076 lined[wd - 1] = lines[ws - 1];
1114 l_int32 i, j, ws, hs, w, h, wpls, wpld;
1115 l_float32 *datas, *datad, *lines, *lined;
1117 PROCNAME(
"fpixLinearCombination");
1120 return (
FPIX *)ERROR_PTR(
"fpixs1 not defined", procName, fpixd);
1122 return (
FPIX *)ERROR_PTR(
"fpixs2 not defined", procName, fpixd);
1123 if (fpixd && (fpixd != fpixs1))
1124 return (
FPIX *)ERROR_PTR(
"invalid inplace operation", procName, fpixd);
1136 for (i = 0; i < h; i++) {
1137 lines = datas + i * wpls;
1138 lined = datad + i * wpld;
1139 for (j = 0; j < w; j++)
1140 lined[j] = a * lined[j] + b * lines[j];
1168 l_int32 i, j, w, h, wpl;
1169 l_float32 *line, *data;
1171 PROCNAME(
"fpixAddMultConstant");
1174 return ERROR_INT(
"fpix not defined", procName, 1);
1176 if (addc == 0.0 && multc == 1.0)
1182 for (i = 0; i < h; i++) {
1183 line = data + i * wpl;
1185 for (j = 0; j < w; j++)
1187 }
else if (multc == 1.0) {
1188 for (j = 0; j < w; j++)
1191 for (j = 0; j < w; j++) {
1192 line[j] = multc * line[j] + addc;
1228 l_int32 i, j, ws, hs, w, h, wpls, wpld;
1229 l_float64 *datas, *datad, *lines, *lined;
1231 PROCNAME(
"dpixLinearCombination");
1234 return (
DPIX *)ERROR_PTR(
"dpixs1 not defined", procName, dpixd);
1236 return (
DPIX *)ERROR_PTR(
"dpixs2 not defined", procName, dpixd);
1237 if (dpixd && (dpixd != dpixs1))
1238 return (
DPIX *)ERROR_PTR(
"invalid inplace operation", procName, dpixd);
1250 for (i = 0; i < h; i++) {
1251 lines = datas + i * wpls;
1252 lined = datad + i * wpld;
1253 for (j = 0; j < w; j++)
1254 lined[j] = a * lined[j] + b * lines[j];
1282 l_int32 i, j, w, h, wpl;
1283 l_float64 *line, *data;
1285 PROCNAME(
"dpixAddMultConstant");
1288 return ERROR_INT(
"dpix not defined", procName, 1);
1290 if (addc == 0.0 && multc == 1.0)
1296 for (i = 0; i < h; i++) {
1297 line = data + i * wpl;
1299 for (j = 0; j < w; j++)
1301 }
else if (multc == 1.0) {
1302 for (j = 0; j < w; j++)
1305 for (j = 0; j < w; j++)
1306 line[j] = multc * line[j] + addc;
1329 l_float32 *data, *line;
1331 PROCNAME(
"fpixSetAllArbitrary");
1334 return ERROR_INT(
"fpix not defined", procName, 1);
1338 for (i = 0; i < h; i++) {
1339 line = data + i * w;
1340 for (j = 0; j < w; j++)
1341 *(line + j) = inval;
1360 l_float64 *data, *line;
1362 PROCNAME(
"dpixSetAllArbitrary");
1365 return ERROR_INT(
"dpix not defined", procName, 1);
1369 for (i = 0; i < h; i++) {
1370 line = data + i * w;
1371 for (j = 0; j < w; j++)
1372 *(line + j) = inval;
1401 l_int32 ws, hs, wd, hd;
1404 PROCNAME(
"fpixAddBorder");
1407 return (
FPIX *)ERROR_PTR(
"fpixs not defined", procName, NULL);
1409 if (left <= 0 && right <= 0 && top <= 0 && bot <= 0)
1412 wd = ws + left + right;
1413 hd = hs + top + bot;
1415 return (
FPIX *)ERROR_PTR(
"fpixd not made", procName, NULL);
1437 l_int32 ws, hs, wd, hd;
1440 PROCNAME(
"fpixRemoveBorder");
1443 return (
FPIX *)ERROR_PTR(
"fpixs not defined", procName, NULL);
1445 if (left <= 0 && right <= 0 && top <= 0 && bot <= 0)
1448 wd = ws - left - right;
1449 hd = hs - top - bot;
1450 if (wd <= 0 || hd <= 0)
1451 return (
FPIX *)ERROR_PTR(
"width & height not both > 0", procName, NULL);
1453 return (
FPIX *)ERROR_PTR(
"fpixd not made", procName, NULL);
1484 PROCNAME(
"fpixAddMirroredBorder");
1487 return (
FPIX *)ERROR_PTR(
"fpixs not defined", procName, NULL);
1491 for (j = 0; j < left; j++)
1493 fpixd, left + j, top);
1494 for (j = 0; j < right; j++)
1496 fpixd, left + w - 1 - j, top);
1497 for (i = 0; i < top; i++)
1498 fpixRasterop(fpixd, 0, top - 1 - i, left + w + right, 1,
1500 for (i = 0; i < bot; i++)
1501 fpixRasterop(fpixd, 0, top + h + i, left + w + right, 1,
1502 fpixd, 0, top + h - 1 - i);
1531 PROCNAME(
"fpixAddContinuedBorder");
1534 return (
FPIX *)ERROR_PTR(
"fpixs not defined", procName, NULL);
1538 for (j = 0; j < left; j++)
1540 for (j = 0; j < right; j++)
1541 fpixRasterop(fpixd, left + w + j, top, 1, h, fpixd, left + w - 1, top);
1542 for (i = 0; i < top; i++)
1543 fpixRasterop(fpixd, 0, i, left + w + right, 1, fpixd, 0, top);
1544 for (i = 0; i < bot; i++)
1545 fpixRasterop(fpixd, 0, top + h + i, left + w + right, 1,
1546 fpixd, 0, top + h - 1);
1573 l_int32 i, j, w, h, fullw, fullh;
1574 l_float32 val1, val2, del;
1577 PROCNAME(
"fpixAddSlopeBorder");
1580 return (
FPIX *)ERROR_PTR(
"fpixs not defined", procName, NULL);
1586 for (i = top; i < top + h; i++) {
1590 for (j = 0; j < left; j++)
1595 fullw = left + w + right;
1596 for (i = top; i < top + h; i++) {
1600 for (j = left + w; j < fullw; j++)
1601 fpixSetPixel(fpixd, j, i, val1 + del * (j - left - w + 1));
1605 for (j = 0; j < fullw; j++) {
1609 for (i = 0; i < top; i++)
1614 fullh = top + h + bot;
1615 for (j = 0; j < fullw; j++) {
1619 for (i = top + h; i < fullh; i++)
1620 fpixSetPixel(fpixd, j, i, val1 + del * (i - top - h + 1));
1665 l_int32 fsw, fsh, fdw, fdh, dhangw, shangw, dhangh, shangh;
1666 l_int32 i, j, wpls, wpld;
1667 l_float32 *datas, *datad, *lines, *lined;
1669 PROCNAME(
"fpixRasterop");
1672 return ERROR_INT(
"fpixs not defined", procName, 1);
1674 return ERROR_INT(
"fpixd not defined", procName, 1);
1693 dhangw = dx + dw - fdw;
1696 shangw = sx + dw - fsw;
1711 dhangh = dy + dh - fdh;
1714 shangh = sy + dh - fsh;
1719 if ((dw <= 0) || (dh <= 0))
1729 datas += sy * wpls + sx;
1730 datad += dy * wpld + dx;
1731 for (i = 0; i < dh; i++) {
1732 lines = datas + i * wpls;
1733 lined = datad + i * wpld;
1734 for (j = 0; j < dw; j++) {
1759 PROCNAME(
"fpixRotateOrth");
1762 return (
FPIX *)ERROR_PTR(
"fpixs not defined", procName, NULL);
1763 if (quads < 0 || quads > 3)
1764 return (
FPIX *)ERROR_PTR(
"quads not in {0,1,2,3}", procName, NULL);
1768 else if (quads == 1)
1770 else if (quads == 2)
1802 PROCNAME(
"fpixRotate180");
1805 return (
FPIX *)ERROR_PTR(
"fpixs not defined", procName, NULL);
1835 l_int32 i, j, wd, hd, wpls, wpld;
1836 l_float32 *datas, *datad, *lines, *lined;
1839 PROCNAME(
"fpixRotate90");
1842 return (
FPIX *)ERROR_PTR(
"fpixs not defined", procName, NULL);
1843 if (direction != 1 && direction != -1)
1844 return (
FPIX *)ERROR_PTR(
"invalid direction", procName, NULL);
1848 return (
FPIX *)ERROR_PTR(
"fpixd not made", procName, NULL);
1855 if (direction == 1) {
1856 for (i = 0; i < hd; i++) {
1857 lined = datad + i * wpld;
1858 lines = datas + (wd - 1) * wpls;
1859 for (j = 0; j < wd; j++) {
1860 lined[j] = lines[i];
1865 for (i = 0; i < hd; i++) {
1866 lined = datad + i * wpld;
1868 for (j = 0; j < wd; j++) {
1869 lined[j] = lines[hd - 1 - i];
1903 l_int32 i, j, w, h, wpl, bpl;
1904 l_float32 *line, *data, *buffer;
1906 PROCNAME(
"fpixFlipLR");
1909 return (
FPIX *)ERROR_PTR(
"fpixs not defined", procName, NULL);
1919 buffer = (l_float32 *)LEPT_CALLOC(wpl,
sizeof(l_float32));
1920 for (i = 0; i < h; i++) {
1921 line = data + i * wpl;
1922 memcpy(buffer, line, bpl);
1923 for (j = 0; j < w; j++)
1924 line[j] = buffer[w - 1 - j];
1955 l_int32 i, k, h, h2, wpl, bpl;
1956 l_float32 *linet, *lineb, *data, *buffer;
1958 PROCNAME(
"fpixFlipTB");
1961 return (
FPIX *)ERROR_PTR(
"fpixs not defined", procName, NULL);
1970 buffer = (l_float32 *)LEPT_CALLOC(wpl,
sizeof(l_float32));
1973 for (i = 0, k = h - 1; i < h2; i++, k--) {
1974 linet = data + i * wpl;
1975 lineb = data + k * wpl;
1976 memcpy(buffer, linet, bpl);
1977 memcpy(linet, lineb, bpl);
1978 memcpy(lineb, buffer, bpl);
2019 FPIX *fpixs2, *fpixd, *fpixd2;
2021 PROCNAME(
"fpixAffinePta");
2024 return (
FPIX *)ERROR_PTR(
"fpixs not defined", procName, NULL);
2026 return (
FPIX *)ERROR_PTR(
"ptas not defined", procName, NULL);
2028 return (
FPIX *)ERROR_PTR(
"ptad not defined", procName, NULL);
2072 l_int32 i, j, w, h, wpld;
2074 l_float32 *datas, *datad, *lined;
2078 PROCNAME(
"fpixAffine");
2081 return (
FPIX *)ERROR_PTR(
"fpixs not defined", procName, NULL);
2084 return (
FPIX *)ERROR_PTR(
"vc not defined", procName, NULL);
2093 for (i = 0; i < h; i++) {
2094 lined = datad + i * wpld;
2095 for (j = 0; j < w; j++) {
2138 FPIX *fpixs2, *fpixd, *fpixd2;
2140 PROCNAME(
"fpixProjectivePta");
2143 return (
FPIX *)ERROR_PTR(
"fpixs not defined", procName, NULL);
2145 return (
FPIX *)ERROR_PTR(
"ptas not defined", procName, NULL);
2147 return (
FPIX *)ERROR_PTR(
"ptad not defined", procName, NULL);
2191 l_int32 i, j, w, h, wpld;
2193 l_float32 *datas, *datad, *lined;
2197 PROCNAME(
"fpixProjective");
2200 return (
FPIX *)ERROR_PTR(
"fpixs not defined", procName, NULL);
2203 return (
FPIX *)ERROR_PTR(
"vc not defined", procName, NULL);
2212 for (i = 0; i < h; i++) {
2213 lined = datad + i * wpld;
2214 for (j = 0; j < w; j++) {
2253 l_int32 xpm, ypm, xp, yp, xf, yf;
2254 l_float32 v00, v01, v10, v11;
2257 PROCNAME(
"linearInterpolatePixelFloat");
2260 return ERROR_INT(
"&val not defined", procName, 1);
2263 return ERROR_INT(
"datas not defined", procName, 1);
2266 if (x < 0.0 || y < 0.0 || x > w - 2.0 || y > h - 2.0)
2269 xpm = (l_int32)(16.0 * x + 0.5);
2270 ypm = (l_int32)(16.0 * y + 0.5);
2277 if (xf < 0 || yf < 0)
2278 lept_stderr(
"xp = %d, yp = %d, xf = %d, yf = %d\n", xp, yp, xf, yf);
2282 lines = datas + yp * w;
2283 v00 = (16.0 - xf) * (16.0 - yf) * (*(lines + xp));
2284 v10 = xf * (16.0 - yf) * (*(lines + xp + 1));
2285 v01 = (16.0 - xf) * yf * (*(lines + w + xp));
2286 v11 = (l_float32)(xf) * yf * (*(lines + w + xp + 1));
2287 *pval = (v00 + v01 + v10 + v11) / 256.0;
2312 l_int32 i, j, w, h, wpls, wpld;
2313 l_float32 *datas, *lines;
2314 l_uint32 *datad, *lined;
2317 PROCNAME(
"fpixThresholdToPix");
2320 return (
PIX *)ERROR_PTR(
"fpix not defined", procName, NULL);
2327 wpld = pixGetWpl(pixd);
2328 for (i = 0; i < h; i++) {
2329 lines = datas + i * wpls;
2330 lined = datad + i * wpld;
2331 for (j = 0; j < w; j++) {
2332 if (lines[j] <= thresh)
2375 l_int32 i, j, w, h, wpls, wpld, rval, gval, bval, zerodenom, onedenom;
2376 l_float32 fnum, fdenom;
2377 l_uint32 *datas, *lines;
2378 l_float32 *datad, *lined, *recip;
2381 PROCNAME(
"pixComponentFunction");
2383 if (!pix || pixGetDepth(pix) != 32)
2384 return (
FPIX *)ERROR_PTR(
"pix undefined or not 32 bpp", procName, NULL);
2388 wpls = pixGetWpl(pix);
2392 zerodenom = (rdenom == 0.0 && gdenom == 0.0 && bdenom == 0.0) ? 1: 0;
2393 onedenom = ((rdenom == 1.0 && gdenom == 0.0 && bdenom == 0.0) ||
2394 (rdenom == 0.0 && gdenom == 1.0 && bdenom == 0.0) ||
2395 (rdenom == 0.0 && gdenom == 0.0 && bdenom == 1.0)) ? 1 : 0;
2398 recip = (l_float32 *)LEPT_CALLOC(256,
sizeof(l_float32));
2400 for (i = 1; i < 256; i++)
2401 recip[i] = 1.0 / (l_float32)i;
2403 for (i = 0; i < h; i++) {
2404 lines = datas + i * wpls;
2405 lined = datad + i * wpld;
2407 for (j = 0; j < w; j++) {
2409 lined[j] = rnum * rval + gnum * gval + bnum * bval;
2411 }
else if (onedenom && rdenom == 1.0) {
2412 for (j = 0; j < w; j++) {
2415 = recip[rval] * (rnum * rval + gnum * gval + bnum * bval);
2417 }
else if (onedenom && gdenom == 1.0) {
2418 for (j = 0; j < w; j++) {
2421 = recip[gval] * (rnum * rval + gnum * gval + bnum * bval);
2423 }
else if (onedenom && bdenom == 1.0) {
2424 for (j = 0; j < w; j++) {
2427 = recip[bval] * (rnum * rval + gnum * gval + bnum * bval);
2430 for (j = 0; j < w; j++) {
2432 fnum = rnum * rval + gnum * gval + bnum * bval;
2433 fdenom = rdenom * rval + gdenom * gval + bdenom * bval;
2434 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()