119 #include <config_auto.h>
123 #include "allheaders.h"
127 static const l_float32 EnhanceScaleFactor = 5.0;
187 return (
PIX *)ERROR_PTR(
"pixs not defined", __func__, pixd);
188 if (pixd && (pixd != pixs))
189 return (
PIX *)ERROR_PTR(
"pixd not null or pixs", __func__, pixd);
191 L_WARNING(
"gamma must be > 0.0; setting to 1.0\n", __func__);
194 if (minval >= maxval)
195 return (
PIX *)ERROR_PTR(
"minval not < maxval", __func__, pixd);
196 cmap = pixGetColormap(pixs);
197 d = pixGetDepth(pixs);
198 if (!cmap && d != 8 && d != 32)
199 return (
PIX *)ERROR_PTR(
"depth not 8 or 32 bpp", __func__, pixd);
201 if (gamma == 1.0 && minval == 0 && maxval == 255)
213 if ((nag =
numaGammaTRC(gamma, minval, maxval)) == NULL)
214 return (
PIX *)ERROR_PTR(
"nag not made", __func__, pixd);
253 return pixGammaTRC(pixd, pixs, gamma, minval, maxval);
256 return (
PIX *)ERROR_PTR(
"pixs not defined", __func__, pixd);
257 if (pixGetColormap(pixs))
258 return (
PIX *)ERROR_PTR(
"invalid: pixs has a colormap", __func__, pixd);
259 if (pixd && (pixd != pixs))
260 return (
PIX *)ERROR_PTR(
"pixd not null or pixs", __func__, pixd);
261 d = pixGetDepth(pixs);
262 if (d != 8 && d != 32)
263 return (
PIX *)ERROR_PTR(
"depth not 8 or 32 bpp", __func__, pixd);
264 if (minval >= maxval)
265 return (
PIX *)ERROR_PTR(
"minval not < maxval", __func__, pixd);
267 L_WARNING(
"gamma must be > 0.0; setting to 1.0\n", __func__);
271 if (gamma == 1.0 && minval == 0 && maxval == 255)
277 if ((nag =
numaGammaTRC(gamma, minval, maxval)) == NULL)
278 return (
PIX *)ERROR_PTR(
"nag not made", __func__, pixd);
313 if (!pixs || pixGetDepth(pixs) != 32)
314 return (
PIX *)ERROR_PTR(
"pixs undefined or not 32 bpp", __func__, pixd);
315 if (pixd && (pixd != pixs))
316 return (
PIX *)ERROR_PTR(
"pixd not null or pixs", __func__, pixd);
318 L_WARNING(
"gamma must be > 0.0; setting to 1.0\n", __func__);
321 if (minval >= maxval)
322 return (
PIX *)ERROR_PTR(
"minval not < maxval", __func__, pixd);
324 if (gamma == 1.0 && minval == 0 && maxval == 255)
330 if ((nag =
numaGammaTRC(gamma, minval, maxval)) == NULL)
331 return (
PIX *)ERROR_PTR(
"nag not made", __func__, pixd);
368 l_float32 x, invgamma;
371 if (minval >= maxval)
372 return (
NUMA *)ERROR_PTR(
"minval not < maxval", __func__, NULL);
374 L_WARNING(
"gamma must be > 0.0; setting to 1.0\n", __func__);
378 invgamma = 1. / gamma;
380 for (i = 0; i < minval; i++)
382 for (i = minval; i <= maxval; i++) {
384 if (i > 255)
continue;
385 x = (l_float32)(i - minval) / (l_float32)(maxval - minval);
386 val = (l_int32)(255. * powf(x, invgamma) + 0.5);
388 val = L_MIN(val, 255);
391 for (i = maxval + 1; i < 256; i++)
440 return (
PIX *)ERROR_PTR(
"pixs not defined", __func__, pixd);
441 if (pixd && (pixd != pixs))
442 return (
PIX *)ERROR_PTR(
"pixd not null or pixs", __func__, pixd);
444 L_WARNING(
"factor must be >= 0.0; using 0.0\n", __func__);
450 cmap = pixGetColormap(pixs);
451 d = pixGetDepth(pixs);
452 if (!cmap && d != 8 && d != 32)
453 return (
PIX *)ERROR_PTR(
"depth not 8 or 32 bpp", __func__, pixd);
465 return (
PIX *)ERROR_PTR(
"nac not made", __func__, pixd);
503 return (
PIX *)ERROR_PTR(
"pixs not defined", __func__, pixd);
504 if (pixGetColormap(pixs))
505 return (
PIX *)ERROR_PTR(
"invalid: pixs has a colormap", __func__, pixd);
506 if (pixd && (pixd != pixs))
507 return (
PIX *)ERROR_PTR(
"pixd not null or pixs", __func__, pixd);
508 d = pixGetDepth(pixs);
509 if (d != 8 && d != 32)
510 return (
PIX *)ERROR_PTR(
"depth not 8 or 32 bpp", __func__, pixd);
513 L_WARNING(
"factor must be >= 0.0; using 0.0\n", __func__);
523 return (
PIX *)ERROR_PTR(
"nac not made", __func__, pixd);
551 l_float64 x, ymax, ymin, dely, scale;
555 L_WARNING(
"factor must be >= 0.0; using 0.0; no enhancement\n",
562 scale = EnhanceScaleFactor;
563 ymax = atan((l_float64)(1.0 * factor * scale));
564 ymin = atan((l_float64)(-127. * factor * scale / 128.));
567 for (i = 0; i < 256; i++) {
569 val = (l_int32)((255. / dely) *
570 (-ymin + atan((l_float64)(factor * scale * (x - 127.) / 128.))) +
627 return (
PIX *)ERROR_PTR(
"pixs not defined", __func__, NULL);
628 if (pixd && (pixd != pixs))
629 return (
PIX *)ERROR_PTR(
"pixd not null or pixs", __func__, pixd);
630 cmap = pixGetColormap(pixs);
631 d = pixGetDepth(pixs);
632 if (d != 8 && d != 32 && !cmap)
633 return (
PIX *)ERROR_PTR(
"pixs not 8/32 bpp or cmapped", __func__, NULL);
634 if (fract < 0.0 || fract > 1.0)
635 return (
PIX *)ERROR_PTR(
"fract not in [0.0 ... 1.0]", __func__, NULL);
637 return (
PIX *)ERROR_PTR(
"sampling factor < 1", __func__, NULL);
652 d = pixGetDepth(pixd);
705 l_int32 iin, iout, itarg;
707 NUMA *nah, *nasum, *nad;
710 return (
NUMA *)ERROR_PTR(
"pix not defined", __func__, NULL);
711 if (pixGetDepth(pix) != 8)
712 return (
NUMA *)ERROR_PTR(
"pix not 8 bpp", __func__, NULL);
713 if (fract < 0.0 || fract > 1.0)
714 return (
NUMA *)ERROR_PTR(
"fract not in [0.0 ... 1.0]", __func__, NULL);
716 return (
NUMA *)ERROR_PTR(
"sampling factor < 1", __func__, NULL);
719 L_WARNING(
"fract = 0.0; no equalization requested\n", __func__);
722 return (
NUMA *)ERROR_PTR(
"histogram not made", __func__, NULL);
727 for (iin = 0; iin < 256; iin++) {
729 itarg = (l_int32)(255. * val / sum + 0.5);
730 iout = iin + (l_int32)(fract * (itarg - iin));
731 iout = L_MIN(iout, 255);
770 l_int32 w, h, d, wm, hm, wpl, wplm, i, j, sval8, dval8;
771 l_uint32 sval32, dval32;
772 l_uint32 *data, *datam, *line, *linem, *tab;
775 return ERROR_INT(
"pixs not defined", __func__, 1);
776 if (pixGetColormap(pixs))
777 return ERROR_INT(
"pixs is colormapped", __func__, 1);
779 return ERROR_INT(
"na not defined", __func__, 1);
781 return ERROR_INT(
"na not of size 256", __func__, 1);
783 if (d != 8 && d != 32)
784 return ERROR_INT(
"pixs not 8 or 32 bpp", __func__, 1);
786 if (pixGetDepth(pixm) != 1)
787 return ERROR_INT(
"pixm not 1 bpp", __func__, 1);
791 wpl = pixGetWpl(pixs);
795 for (i = 0; i < h; i++) {
796 line = data + i * wpl;
797 for (j = 0; j < w; j++) {
804 for (i = 0; i < h; i++) {
805 line = data + i * wpl;
806 for (j = 0; j < w; j++) {
807 sval32 = *(line + j);
809 tab[(sval32 >> L_RED_SHIFT) & 0xff] << L_RED_SHIFT |
810 tab[(sval32 >> L_GREEN_SHIFT) & 0xff] << L_GREEN_SHIFT |
811 tab[(sval32 >> L_BLUE_SHIFT) & 0xff] << L_BLUE_SHIFT;
812 *(line + j) = dval32;
818 wplm = pixGetWpl(pixm);
821 for (i = 0; i < h; i++) {
824 line = data + i * wpl;
825 linem = datam + i * wplm;
826 for (j = 0; j < w; j++) {
837 for (i = 0; i < h; i++) {
840 line = data + i * wpl;
841 linem = datam + i * wplm;
842 for (j = 0; j < w; j++) {
847 sval32 = *(line + j);
849 tab[(sval32 >> L_RED_SHIFT) & 0xff] << L_RED_SHIFT |
850 tab[(sval32 >> L_GREEN_SHIFT) & 0xff] << L_GREEN_SHIFT |
851 tab[(sval32 >> L_BLUE_SHIFT) & 0xff] << L_BLUE_SHIFT;
852 *(line + j) = dval32;
892 l_int32 w, h, wm, hm, wpl, wplm, i, j;
893 l_uint32 sval32, dval32;
894 l_uint32 *data, *datam, *line, *linem, *tabr, *tabg, *tabb;
896 if (!pixs || pixGetDepth(pixs) != 32)
897 return ERROR_INT(
"pixs not defined or not 32 bpp", __func__, 1);
898 if (pixm && pixGetDepth(pixm) != 1)
899 return ERROR_INT(
"pixm defined and not 1 bpp", __func__, 1);
900 if (!nar || !nag || !nab)
901 return ERROR_INT(
"na{r,g,b} not all defined", __func__, 1);
904 return ERROR_INT(
"na{r,g,b} not all of size 256", __func__, 1);
911 wpl = pixGetWpl(pixs);
914 for (i = 0; i < h; i++) {
915 line = data + i * wpl;
916 for (j = 0; j < w; j++) {
917 sval32 = *(line + j);
919 tabr[(sval32 >> L_RED_SHIFT) & 0xff] << L_RED_SHIFT |
920 tabg[(sval32 >> L_GREEN_SHIFT) & 0xff] << L_GREEN_SHIFT |
921 tabb[(sval32 >> L_BLUE_SHIFT) & 0xff] << L_BLUE_SHIFT;
922 *(line + j) = dval32;
927 wplm = pixGetWpl(pixm);
929 for (i = 0; i < h; i++) {
932 line = data + i * wpl;
933 linem = datam + i * wplm;
934 for (j = 0; j < w; j++) {
939 sval32 = *(line + j);
941 tabr[(sval32 >> L_RED_SHIFT) & 0xff] << L_RED_SHIFT |
942 tabg[(sval32 >> L_GREEN_SHIFT) & 0xff] << L_GREEN_SHIFT |
943 tabb[(sval32 >> L_BLUE_SHIFT) & 0xff] << L_BLUE_SHIFT;
944 *(line + j) = dval32;
984 PIX *pix1, *pixd, *pixr, *pixrs, *pixg, *pixgs, *pixb, *pixbs;
986 if (!pixs || (pixGetDepth(pixs) == 1))
987 return (
PIX *)ERROR_PTR(
"pixs not defined or 1 bpp", __func__, NULL);
988 if (fract <= 0.0 || halfwidth <= 0) {
989 L_WARNING(
"no sharpening requested; clone returned\n", __func__);
993 if (halfwidth == 1 || halfwidth == 2)
998 return (
PIX *)ERROR_PTR(
"pix1 not made", __func__, NULL);
1001 d = pixGetDepth(pix1);
1018 if (pixGetSpp(pixs) == 4)
1055 return (
PIX *)ERROR_PTR(
"pixs not defined", __func__, NULL);
1057 if (d != 8 || pixGetColormap(pixs) != NULL)
1058 return (
PIX *)ERROR_PTR(
"pixs not 8 bpp or has cmap", __func__, NULL);
1059 if (fract <= 0.0 || halfwidth <= 0) {
1060 L_WARNING(
"no sharpening requested; clone returned\n", __func__);
1063 if (halfwidth == 1 || halfwidth == 2)
1068 return (
PIX *)ERROR_PTR(
"pixc not made", __func__, NULL);
1147 PIX *pixt, *pixd, *pixr, *pixrs, *pixg, *pixgs, *pixb, *pixbs;
1149 if (!pixs || (pixGetDepth(pixs) == 1))
1150 return (
PIX *)ERROR_PTR(
"pixs not defined or 1 bpp", __func__, NULL);
1151 if (fract <= 0.0 || halfwidth <= 0) {
1152 L_WARNING(
"no sharpening requested; clone returned\n", __func__);
1155 if (halfwidth != 1 && halfwidth != 2)
1156 return (
PIX *)ERROR_PTR(
"halfwidth must be 1 or 2", __func__, NULL);
1157 if (direction != L_HORIZ && direction != L_VERT &&
1158 direction != L_BOTH_DIRECTIONS)
1159 return (
PIX *)ERROR_PTR(
"invalid direction", __func__, NULL);
1163 return (
PIX *)ERROR_PTR(
"pixt not made", __func__, NULL);
1166 d = pixGetDepth(pixt);
1180 if (pixGetSpp(pixs) == 4)
1218 return (
PIX *)ERROR_PTR(
"pixs not defined", __func__, NULL);
1219 if (pixGetDepth(pixs) != 8 || pixGetColormap(pixs) != NULL)
1220 return (
PIX *)ERROR_PTR(
"pixs not 8 bpp or has cmap", __func__, NULL);
1221 if (fract <= 0.0 || halfwidth <= 0) {
1222 L_WARNING(
"no sharpening requested; clone returned\n", __func__);
1225 if (halfwidth != 1 && halfwidth != 2)
1226 return (
PIX *)ERROR_PTR(
"halfwidth must be 1 or 2", __func__, NULL);
1227 if (direction != L_HORIZ && direction != L_VERT &&
1228 direction != L_BOTH_DIRECTIONS)
1229 return (
PIX *)ERROR_PTR(
"invalid direction", __func__, NULL);
1231 if (direction != L_BOTH_DIRECTIONS)
1262 l_int32 w, h, d, wpls, wpld, i, j, ival;
1263 l_uint32 *datas, *datad;
1264 l_uint32 *lines, *lines0, *lines1, *lines2, *lines3, *lines4, *lined;
1265 l_float32 val, a[5];
1269 return (
PIX *)ERROR_PTR(
"pixs not defined", __func__, NULL);
1271 if (d != 8 || pixGetColormap(pixs) != NULL)
1272 return (
PIX *)ERROR_PTR(
"pixs not 8 bpp or has cmap", __func__, NULL);
1273 if (fract <= 0.0 || halfwidth <= 0) {
1274 L_WARNING(
"no sharpening requested; clone returned\n", __func__);
1277 if (halfwidth != 1 && halfwidth != 2)
1278 return (
PIX *)ERROR_PTR(
"halfwidth must be 1 or 2", __func__, NULL);
1283 halfwidth, halfwidth);
1286 wpls = pixGetWpl(pixs);
1287 wpld = pixGetWpl(pixd);
1289 if (halfwidth == 1) {
1290 a[0] = -fract / 3.0;
1291 a[1] = 1.0 + fract * 2.0 / 3.0;
1294 a[0] = -fract / 5.0;
1296 a[2] = 1.0 + fract * 4.0 / 5.0;
1301 if (direction == L_HORIZ) {
1302 for (i = 0; i < h; i++) {
1303 lines = datas + i * wpls;
1304 lined = datad + i * wpld;
1305 if (halfwidth == 1) {
1306 for (j = 1; j < w - 1; j++) {
1310 ival = (l_int32)val;
1311 ival = L_MAX(0, ival);
1312 ival = L_MIN(255, ival);
1316 for (j = 2; j < w - 2; j++) {
1322 ival = (l_int32)val;
1323 ival = L_MAX(0, ival);
1324 ival = L_MIN(255, ival);
1330 if (halfwidth == 1) {
1331 for (i = 1; i < h - 1; i++) {
1332 lines0 = datas + (i - 1) * wpls;
1333 lines1 = datas + i * wpls;
1334 lines2 = datas + (i + 1) * wpls;
1335 lined = datad + i * wpld;
1336 for (j = 0; j < w; j++) {
1340 ival = (l_int32)val;
1341 ival = L_MAX(0, ival);
1342 ival = L_MIN(255, ival);
1347 for (i = 2; i < h - 2; i++) {
1348 lines0 = datas + (i - 2) * wpls;
1349 lines1 = datas + (i - 1) * wpls;
1350 lines2 = datas + i * wpls;
1351 lines3 = datas + (i + 1) * wpls;
1352 lines4 = datas + (i + 2) * wpls;
1353 lined = datad + i * wpld;
1354 for (j = 0; j < w; j++) {
1360 ival = (l_int32)val;
1361 ival = L_MAX(0, ival);
1362 ival = L_MIN(255, ival);
1393 l_int32 w, h, d, wpls, wpld, wplf, i, j, ival, sval;
1394 l_uint32 *datas, *datad, *lines, *lined;
1395 l_float32 val, norm;
1396 l_float32 *dataf, *linef, *linef0, *linef1, *linef2, *linef3, *linef4;
1401 return (
PIX *)ERROR_PTR(
"pixs not defined", __func__, NULL);
1403 if (d != 8 || pixGetColormap(pixs) != NULL)
1404 return (
PIX *)ERROR_PTR(
"pixs not 8 bpp or has cmap", __func__, NULL);
1405 if (fract <= 0.0 || halfwidth <= 0) {
1406 L_WARNING(
"no sharpening requested; clone returned\n", __func__);
1409 if (halfwidth != 1 && halfwidth != 2)
1410 return (
PIX *)ERROR_PTR(
"halfwidth must be 1 or 2", __func__, NULL);
1413 halfwidth, halfwidth)) == NULL)
1414 return (
PIX *)ERROR_PTR(
"pixd not made", __func__, NULL);
1416 wpld = pixGetWpl(pixd);
1418 wpls = pixGetWpl(pixs);
1424 return (
PIX *)ERROR_PTR(
"fpix not made", __func__, NULL);
1428 if (halfwidth == 1) {
1429 for (i = 0; i < h; i++) {
1430 lines = datas + i * wpls;
1431 linef = dataf + i * wplf;
1432 for (j = 1; j < w - 1; j++) {
1440 for (i = 0; i < h; i++) {
1441 lines = datas + i * wpls;
1442 linef = dataf + i * wplf;
1443 for (j = 2; j < w - 2; j++) {
1461 if (halfwidth == 1) {
1462 for (i = 1; i < h - 1; i++) {
1463 linef0 = dataf + (i - 1) * wplf;
1464 linef1 = dataf + i * wplf;
1465 linef2 = dataf + (i + 1) * wplf;
1466 lined = datad + i * wpld;
1467 lines = datas + i * wpls;
1469 for (j = 1; j < w - 1; j++) {
1470 val = norm * (linef0[j] + linef1[j] +
1473 ival = (l_int32)(sval + fract * (sval - val) + 0.5);
1474 ival = L_MAX(0, ival);
1475 ival = L_MIN(255, ival);
1480 for (i = 2; i < h - 2; i++) {
1481 linef0 = dataf + (i - 2) * wplf;
1482 linef1 = dataf + (i - 1) * wplf;
1483 linef2 = dataf + i * wplf;
1484 linef3 = dataf + (i + 1) * wplf;
1485 linef4 = dataf + (i + 2) * wplf;
1486 lined = datad + i * wpld;
1487 lines = datas + i * wpls;
1489 for (j = 2; j < w - 2; j++) {
1490 val = norm * (linef0[j] + linef1[j] + linef2[j] + linef3[j] +
1493 ival = (l_int32)(sval + fract * (sval - val) + 0.5);
1494 ival = L_MAX(0, ival);
1495 ival = L_MIN(255, ival);
1537 l_int32 w, h, d, i, j, wpl, delhue;
1538 l_int32 rval, gval, bval, hval, sval, vval;
1539 l_uint32 *data, *line;
1542 return (
PIX *)ERROR_PTR(
"pixs not defined", __func__, NULL);
1543 if (pixGetColormap(pixs) != NULL)
1544 return (
PIX *)ERROR_PTR(
"pixs colormapped", __func__, NULL);
1545 if (pixd && (pixd != pixs))
1546 return (
PIX *)ERROR_PTR(
"pixd not null or pixs", __func__, pixd);
1549 return (
PIX *)ERROR_PTR(
"pixs not 32 bpp", __func__, NULL);
1550 if (L_ABS(fract) > 1.0)
1551 return (
PIX *)ERROR_PTR(
"fract not in [-1.0 ... 1.0]", __func__, NULL);
1555 delhue = (l_int32)(240 * fract);
1556 if (delhue == 0 || delhue == 240 || delhue == -240) {
1557 L_WARNING(
"no change requested in hue\n", __func__);
1564 wpl = pixGetWpl(pixd);
1565 for (i = 0; i < h; i++) {
1566 line = data + i * wpl;
1567 for (j = 0; j < w; j++) {
1570 hval = (hval + delhue) % 240;
1575 if (pixGetSpp(pixs) == 4)
1609 l_int32 w, h, d, i, j, wpl;
1610 l_int32 rval, gval, bval, hval, sval, vval;
1611 l_uint32 *data, *line;
1614 return (
PIX *)ERROR_PTR(
"pixs not defined", __func__, NULL);
1617 return (
PIX *)ERROR_PTR(
"pixs not 32 bpp", __func__, NULL);
1618 if (L_ABS(fract) > 1.0)
1619 return (
PIX *)ERROR_PTR(
"fract not in [-1.0 ... 1.0]", __func__, NULL);
1623 L_WARNING(
"no change requested in saturation\n", __func__);
1628 wpl = pixGetWpl(pixd);
1629 for (i = 0; i < h; i++) {
1630 line = data + i * wpl;
1631 for (j = 0; j < w; j++) {
1635 sval = (l_int32)(sval * (1.0 + fract));
1637 sval = (l_int32)(sval + fract * (255 - sval));
1642 if (pixGetSpp(pixs) == 4)
1662 l_int32 w, h, d, i, j, wpl, sum, count;
1663 l_int32 rval, gval, bval, hval, sval, vval;
1664 l_uint32 *data, *line;
1667 return ERROR_INT(
"pixs not defined", __func__, 1);
1670 return ERROR_INT(
"pixs not defined", __func__, 1);
1673 return ERROR_INT(
"pixs not 32 bpp", __func__, 1);
1675 return ERROR_INT(
"subsampling factor < 1", __func__, 1);
1678 wpl = pixGetWpl(pixs);
1679 for (i = 0, sum = 0, count = 0; i < h; i += factor) {
1680 line = data + i * wpl;
1681 for (j = 0; j < w; j += factor) {
1690 *psat = (l_float32)sum / (l_float32)count;
1722 l_int32 w, h, d, i, j, wpl;
1723 l_int32 rval, gval, bval, hval, sval, vval;
1724 l_uint32 *data, *line;
1727 return (
PIX *)ERROR_PTR(
"pixs not defined", __func__, NULL);
1730 return (
PIX *)ERROR_PTR(
"pixs not 32 bpp", __func__, NULL);
1731 if (L_ABS(fract) > 1.0)
1732 return (
PIX *)ERROR_PTR(
"fract not in [-1.0 ... 1.0]", __func__, NULL);
1736 L_WARNING(
"no change requested in brightness\n", __func__);
1741 wpl = pixGetWpl(pixd);
1742 for (i = 0; i < h; i++) {
1743 line = data + i * wpl;
1744 for (j = 0; j < w; j++) {
1748 vval = (l_int32)(vval + fract * (255.0 - vval));
1750 vval = (l_int32)(vval * (1.0 + fract));
1755 if (pixGetSpp(pixs) == 4)
1806 l_float32 del, ratio;
1808 PIX *pix1, *pix2, *pix3;
1811 if (!pixs || pixGetDepth(pixs) != 32)
1812 return (
PIX *)ERROR_PTR(
"pixs undefined or not rgb", __func__, NULL);
1813 if (roff < -1.0 || roff > 1.0)
1814 return (
PIX *)ERROR_PTR(
"roff not in [-1.0, 1.0]", __func__, NULL);
1815 if (goff < -1.0 || goff > 1.0)
1816 return (
PIX *)ERROR_PTR(
"goff not in [-1.0, 1.0]", __func__, NULL);
1817 if (boff < -1.0 || boff > 1.0)
1818 return (
PIX *)ERROR_PTR(
"boff not in [-1.0, 1.0]", __func__, NULL);
1819 if (delta < 0.0 || delta > 0.1)
1820 return (
PIX *)ERROR_PTR(
"delta not in [0.0, 0.1]", __func__, NULL);
1821 if (delta == 0.0) delta = 0.04;
1822 if (nincr < 0 || nincr > 6)
1823 return (
PIX *)ERROR_PTR(
"nincr not in [0, 6]", __func__, NULL);
1824 if (nincr == 0) nincr = 2;
1828 if (w < 100 || h < 100)
1829 return (
PIX *)ERROR_PTR(
"w and h not both >= 100", __func__, NULL);
1831 if (ratio < 1.0 || ratio > 5.0) {
1832 L_ERROR(
"invalid aspect ratio %5.1f\n", __func__, ratio);
1839 for (i = 0, del = - nincr * delta; i < 2 * nincr + 1; i++, del += delta) {
1841 snprintf(buf,
sizeof(buf),
"%4.2f, %4.2f, %4.2f",
1842 roff + del, goff, boff);
1848 for (i = 0, del = - nincr * delta; i < 2 * nincr + 1; i++, del += delta) {
1850 snprintf(buf,
sizeof(buf),
"%4.2f, %4.2f, %4.2f",
1851 roff, goff + del, boff);
1857 for (i = 0, del = - nincr * delta; i < 2 * nincr + 1; i++, del += delta) {
1859 snprintf(buf,
sizeof(buf),
"%4.2f, %4.2f, %4.2f",
1860 roff, goff, boff + del);
1906 l_int32 w, h, i, j, wpls, wpld, rval, gval, bval;
1907 l_int32 *rlut, *glut, *blut;
1908 l_uint32 *datas, *datad, *lines, *lined;
1913 return (
PIX *)ERROR_PTR(
"pixs not defined", __func__, NULL);
1914 if (pixGetDepth(pixs) != 32)
1915 return (
PIX *)ERROR_PTR(
"pixs not 32 bpp", __func__, NULL);
1916 if (rfract < -1.0 || rfract > 1.0)
1917 return (
PIX *)ERROR_PTR(
"rfract not in [-1.0, 1.0]", __func__, NULL);
1918 if (gfract < -1.0 || gfract > 1.0)
1919 return (
PIX *)ERROR_PTR(
"gfract not in [-1.0, 1.0]", __func__, NULL);
1920 if (bfract < -1.0 || bfract > 1.0)
1921 return (
PIX *)ERROR_PTR(
"bfract not in [-1.0, 1.0]", __func__, NULL);
1922 if (rfract == 0.0 && gfract == 0.0 && bfract == 0.0)
1925 rlut = (l_int32 *)LEPT_CALLOC(256,
sizeof(l_int32));
1926 glut = (l_int32 *)LEPT_CALLOC(256,
sizeof(l_int32));
1927 blut = (l_int32 *)LEPT_CALLOC(256,
sizeof(l_int32));
1928 for (i = 0; i < 256; i++) {
1931 rlut[i] = (l_int32)(fi + (255.0 - fi) * rfract);
1933 rlut[i] = (l_int32)(fi * (1.0 + rfract));
1936 glut[i] = (l_int32)(fi + (255.0 - fi) * gfract);
1938 glut[i] = (l_int32)(fi * (1.0 + gfract));
1941 blut[i] = (l_int32)(fi + (255.0 - fi) * bfract);
1943 blut[i] = (l_int32)(fi * (1.0 + bfract));
1949 wpls = pixGetWpl(pixs);
1952 wpld = pixGetWpl(pixd);
1953 for (i = 0; i < h; i++) {
1954 lines = datas + i * wpls;
1955 lined = datad + i * wpld;
1956 for (j = 0; j < w; j++) {
2003 l_int32 w, h, i, j, wpls, wpld;
2004 l_int32 rval, gval, bval, minrg, min, maxrg, max, sat;
2005 l_uint32 *datas, *datad, *lines, *lined;
2008 if (!pixs || pixGetDepth(pixs) != 32)
2009 return (
PIX *)ERROR_PTR(
"pixs undefined or not 32 bpp", __func__, NULL);
2010 if (thresh < 0 || thresh > 255)
2011 return (
PIX *)ERROR_PTR(
"invalid thresh", __func__, NULL);
2013 return (
PIX *)ERROR_PTR(
"invalid satlimit", __func__, NULL);
2014 if (pixd && (pixs != pixd))
2015 return (
PIX *)ERROR_PTR(
"not new or in-place", __func__, NULL);
2019 wpls = pixGetWpl(pixs);
2020 if ((pixd =
pixCopy(pixd, pixs)) == NULL)
2021 return (
PIX *)ERROR_PTR(
"pixd not made", __func__, NULL);
2023 wpld = pixGetWpl(pixd);
2025 for (i = 0; i < h; i++) {
2026 lines = datas + i * wpls;
2027 lined = datad + i * wpld;
2028 for (j = 0; j < w; j++) {
2030 minrg = L_MIN(rval, gval);
2031 min = L_MIN(minrg, bval);
2032 maxrg = L_MAX(rval, gval);
2033 max = L_MAX(maxrg, bval);
2035 if (max >= thresh || sat >= satlimit)
2037 ratio = (l_float32)sat / (l_float32)satlimit;
2039 (l_int32)(ratio * bval), &lined[j]);
2073 l_int32 i, j, w, h, d, wpls, wpld;
2074 l_int32 ncolors, rval, gval, bval, nrval, ngval, nbval;
2076 l_uint32 *datas, *datad, *lines, *lined;
2081 return (
PIX *)ERROR_PTR(
"pixs not defined", __func__, NULL);
2083 cmap = pixGetColormap(pixs);
2084 if (!cmap && d != 32)
2085 return (
PIX *)ERROR_PTR(
"pixs not cmapped or 32 bpp", __func__, NULL);
2086 rfact = L_MAX(0.0, rfact);
2087 gfact = L_MAX(0.0, gfact);
2088 bfact = L_MAX(0.0, bfact);
2091 if ((pixd =
pixCopy(NULL, pixs)) == NULL)
2092 return (
PIX *)ERROR_PTR(
"pixd not made", __func__, NULL);
2093 cmap = pixGetColormap(pixd);
2095 for (i = 0; i < ncolors; i++) {
2097 nrval = (l_int32)(rfact * rval);
2098 ngval = (l_int32)(gfact * gval);
2099 nbval = (l_int32)(bfact * bval);
2100 nrval = L_MIN(255, nrval);
2101 ngval = L_MIN(255, ngval);
2102 nbval = L_MIN(255, nbval);
2109 return (
PIX *)ERROR_PTR(
"pixd not made", __func__, NULL);
2112 wpls = pixGetWpl(pixs);
2113 wpld = pixGetWpl(pixd);
2114 for (i = 0; i < h; i++) {
2115 lines = datas + i * wpls;
2116 lined = datad + i * wpld;
2117 for (j = 0; j < w; j++) {
2119 nrval = (l_int32)(rfact * rval);
2120 ngval = (l_int32)(gfact * gval);
2121 nbval = (l_int32)(bfact * bval);
2122 nrval = L_MIN(255, nrval);
2123 ngval = L_MIN(255, ngval);
2124 nbval = L_MIN(255, nbval);
2126 *(lined + j) = nval;
2171 l_int32 i, j, index, kw, kh, w, h, d, wpls, wpld;
2172 l_int32 ncolors, rval, gval, bval, nrval, ngval, nbval;
2174 l_uint32 *datas, *datad, *lines, *lined;
2180 return (
PIX *)ERROR_PTR(
"pixs not defined", __func__, NULL);
2182 return (
PIX *)ERROR_PTR(
"kel not defined", __func__, NULL);
2184 if (kw != 3 || kh != 3)
2185 return (
PIX *)ERROR_PTR(
"matrix not 3x3", __func__, NULL);
2187 cmap = pixGetColormap(pixs);
2188 if (!cmap && d != 32)
2189 return (
PIX *)ERROR_PTR(
"pixs not cmapped or 32 bpp", __func__, NULL);
2191 for (i = 0, index = 0; i < 3; i++)
2192 for (j = 0; j < 3; j++, index++)
2196 if ((pixd =
pixCopy(NULL, pixs)) == NULL)
2197 return (
PIX *)ERROR_PTR(
"pixd not made", __func__, NULL);
2198 cmap = pixGetColormap(pixd);
2200 for (i = 0; i < ncolors; i++) {
2202 nrval = (l_int32)(v[0] * rval + v[1] * gval + v[2] * bval);
2203 ngval = (l_int32)(v[3] * rval + v[4] * gval + v[5] * bval);
2204 nbval = (l_int32)(v[6] * rval + v[7] * gval + v[8] * bval);
2205 nrval = L_MAX(0, L_MIN(255, nrval));
2206 ngval = L_MAX(0, L_MIN(255, ngval));
2207 nbval = L_MAX(0, L_MIN(255, nbval));
2214 return (
PIX *)ERROR_PTR(
"pixd not made", __func__, NULL);
2217 wpls = pixGetWpl(pixs);
2218 wpld = pixGetWpl(pixd);
2219 for (i = 0; i < h; i++) {
2220 lines = datas + i * wpls;
2221 lined = datad + i * wpld;
2222 for (j = 0; j < w; j++) {
2224 nrval = (l_int32)(v[0] * rval + v[1] * gval + v[2] * bval);
2225 ngval = (l_int32)(v[3] * rval + v[4] * gval + v[5] * bval);
2226 nbval = (l_int32)(v[6] * rval + v[7] * gval + v[8] * bval);
2227 nrval = L_MAX(0, L_MIN(255, nrval));
2228 ngval = L_MAX(0, L_MIN(255, ngval));
2229 nbval = L_MAX(0, L_MIN(255, nbval));
2231 *(lined + j) = nval;
2282 PIX *pixg, *pixacc, *pixc1, *pixc2;
2285 return (
PIX *)ERROR_PTR(
"pixs not defined", __func__, NULL);
2286 if (sm1h == sm2h && sm1v == sm2v)
2287 return (
PIX *)ERROR_PTR(
"sm2 = sm1", __func__, NULL);
2288 d = pixGetDepth(pixs);
2289 if (d != 8 && d != 32)
2290 return (
PIX *)ERROR_PTR(
"pixs not 8 or 32 bpp", __func__, NULL);
2299 return (
PIX *)ERROR_PTR(
"pixacc not made", __func__, NULL);
2304 return (
PIX *)ERROR_PTR(
"pixc1 not made", __func__, NULL);
2311 return (
PIX *)ERROR_PTR(
"pixc2 not made", __func__, NULL);
#define GET_DATA_BYTE(pdata, n)
#define SET_DATA_BYTE(pdata, n, val)
#define GET_DATA_BIT(pdata, n)
void bmfDestroy(L_BMF **pbmf)
bmfDestroy()
L_BMF * bmfCreate(const char *dir, l_int32 fontsize)
bmfCreate()
l_ok pixcmapContrastTRC(PIXCMAP *cmap, l_float32 factor)
pixcmapContrastTRC()
l_int32 pixcmapGetCount(const PIXCMAP *cmap)
pixcmapGetCount()
l_ok pixcmapResetColor(PIXCMAP *cmap, l_int32 index, l_int32 rval, l_int32 gval, l_int32 bval)
pixcmapResetColor()
l_ok pixcmapGammaTRC(PIXCMAP *cmap, l_float32 gamma, l_int32 minval, l_int32 maxval)
pixcmapGammaTRC()
l_ok pixcmapGetColor(PIXCMAP *cmap, l_int32 index, l_int32 *prval, l_int32 *pgval, l_int32 *pbval)
pixcmapGetColor()
l_ok convertHSVToRGB(l_int32 hval, l_int32 sval, l_int32 vval, l_int32 *prval, l_int32 *pgval, l_int32 *pbval)
convertHSVToRGB()
l_ok convertRGBToHSV(l_int32 rval, l_int32 gval, l_int32 bval, l_int32 *phval, l_int32 *psval, l_int32 *pvval)
convertRGBToHSV()
PIX * pixBlockconvGray(PIX *pixs, PIX *pixacc, l_int32 wc, l_int32 hc)
pixBlockconvGray()
PIX * pixBlockconvAccum(PIX *pixs)
pixBlockconvAccum()
l_int32 pixMeasureSaturation(PIX *pixs, l_int32 factor, l_float32 *psat)
pixMeasureSaturation()
NUMA * numaContrastTRC(l_float32 factor)
numaContrastTRC()
PIX * pixHalfEdgeByBandpass(PIX *pixs, l_int32 sm1h, l_int32 sm1v, l_int32 sm2h, l_int32 sm2v)
pixHalfEdgeByBandpass()
PIX * pixModifyHue(PIX *pixd, PIX *pixs, l_float32 fract)
pixModifyHue()
PIX * pixEqualizeTRC(PIX *pixd, PIX *pixs, l_float32 fract, l_int32 factor)
pixEqualizeTRC()
PIX * pixDarkenGray(PIX *pixd, PIX *pixs, l_int32 thresh, l_int32 satlimit)
pixDarkenGray()
PIX * pixUnsharpMaskingGrayFast(PIX *pixs, l_int32 halfwidth, l_float32 fract, l_int32 direction)
pixUnsharpMaskingGrayFast()
NUMA * numaGammaTRC(l_float32 gamma, l_int32 minval, l_int32 maxval)
numaGammaTRC()
PIX * pixColorShiftRGB(PIX *pixs, l_float32 rfract, l_float32 gfract, l_float32 bfract)
pixColorShiftRGB()
PIX * pixContrastTRC(PIX *pixd, PIX *pixs, l_float32 factor)
pixContrastTRC()
PIX * pixUnsharpMaskingFast(PIX *pixs, l_int32 halfwidth, l_float32 fract, l_int32 direction)
pixUnsharpMaskingFast()
PIX * pixModifySaturation(PIX *pixd, PIX *pixs, l_float32 fract)
pixModifySaturation()
PIX * pixMultMatrixColor(PIX *pixs, L_KERNEL *kel)
pixMultMatrixColor()
PIX * pixMultConstantColor(PIX *pixs, l_float32 rfact, l_float32 gfact, l_float32 bfact)
pixMultConstantColor()
l_int32 pixTRCMap(PIX *pixs, PIX *pixm, NUMA *na)
pixTRCMap()
PIX * pixGammaTRC(PIX *pixd, PIX *pixs, l_float32 gamma, l_int32 minval, l_int32 maxval)
pixGammaTRC()
PIX * pixContrastTRCMasked(PIX *pixd, PIX *pixs, PIX *pixm, l_float32 factor)
pixContrastTRCMasked()
PIX * pixMosaicColorShiftRGB(PIX *pixs, l_float32 roff, l_float32 goff, l_float32 boff, l_float32 delta, l_int32 nincr)
pixMosaicColorShiftRGB()
l_int32 pixTRCMapGeneral(PIX *pixs, PIX *pixm, NUMA *nar, NUMA *nag, NUMA *nab)
pixTRCMapGeneral()
PIX * pixModifyBrightness(PIX *pixd, PIX *pixs, l_float32 fract)
pixModifyBrightness()
PIX * pixGammaTRCWithAlpha(PIX *pixd, PIX *pixs, l_float32 gamma, l_int32 minval, l_int32 maxval)
pixGammaTRCWithAlpha()
PIX * pixUnsharpMaskingGray2D(PIX *pixs, l_int32 halfwidth, l_float32 fract)
pixUnsharpMaskingGray2D()
PIX * pixUnsharpMaskingGray(PIX *pixs, l_int32 halfwidth, l_float32 fract)
pixUnsharpMaskingGray()
NUMA * numaEqualizeTRC(PIX *pix, l_float32 fract, l_int32 factor)
numaEqualizeTRC()
PIX * pixUnsharpMaskingGray1D(PIX *pixs, l_int32 halfwidth, l_float32 fract, l_int32 direction)
pixUnsharpMaskingGray1D()
PIX * pixGammaTRCMasked(PIX *pixd, PIX *pixs, PIX *pixm, l_float32 gamma, l_int32 minval, l_int32 maxval)
pixGammaTRCMasked()
PIX * pixUnsharpMasking(PIX *pixs, l_int32 halfwidth, l_float32 fract)
pixUnsharpMasking()
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()
l_ok kernelGetParameters(L_KERNEL *kel, l_int32 *psy, l_int32 *psx, l_int32 *pcy, l_int32 *pcx)
kernelGetParameters()
l_ok kernelGetElement(L_KERNEL *kel, l_int32 row, l_int32 col, l_float32 *pval)
kernelGetElement()
l_ok numaAddNumber(NUMA *na, l_float32 val)
numaAddNumber()
l_ok numaGetFValue(NUMA *na, l_int32 index, l_float32 *pval)
numaGetFValue()
NUMA * numaCreate(l_int32 n)
numaCreate()
void numaDestroy(NUMA **pna)
numaDestroy()
l_int32 numaGetCount(NUMA *na)
numaGetCount()
l_int32 * numaGetIArray(NUMA *na)
numaGetIArray()
NUMA * numaGetPartialSums(NUMA *na)
numaGetPartialSums()
NUMA * numaMakeSequence(l_float32 startval, l_float32 increment, l_int32 size)
numaMakeSequence()
l_ok numaGetSum(NUMA *na, l_float32 *psum)
numaGetSum()
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()
l_ok pixMaxAspectRatio(PIX *pixs, l_float32 *pratio)
pixMaxAspectRatio()
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()
l_ok pixCopyRGBComponent(PIX *pixd, PIX *pixs, l_int32 comp)
pixCopyRGBComponent()
PIX * pixCopyBorder(PIX *pixd, PIX *pixs, l_int32 left, l_int32 right, l_int32 top, l_int32 bot)
pixCopyBorder()
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()
l_ok pixSetRGBComponent(PIX *pixd, PIX *pixs, l_int32 comp)
pixSetRGBComponent()
NUMA * pixGetGrayHistogram(PIX *pixs, l_int32 factor)
pixGetGrayHistogram()
@ REMOVE_CMAP_BASED_ON_SRC
l_ok pixaAddPix(PIXA *pixa, PIX *pix, l_int32 copyflag)
pixaAddPix()
void pixaDestroy(PIXA **ppixa)
pixaDestroy()
PIXA * pixaCreate(l_int32 n)
pixaCreate()
PIX * pixaccFinal(PIXACC *pixacc, l_int32 outdepth)
pixaccFinal()
l_ok pixaccSubtract(PIXACC *pixacc, PIX *pix)
pixaccSubtract()
l_ok pixaccAdd(PIXACC *pixacc, PIX *pix)
pixaccAdd()
void pixaccDestroy(PIXACC **ppixacc)
pixaccDestroy()
PIXACC * pixaccCreate(l_int32 w, l_int32 h, l_int32 negflag)
pixaccCreate()
l_ok pixaccMultConst(PIXACC *pixacc, l_float32 factor)
pixaccMultConst()
PIX * pixaDisplayTiledAndScaled(PIXA *pixa, l_int32 outdepth, l_int32 tilewidth, l_int32 ncols, l_int32 background, l_int32 spacing, l_int32 border)
pixaDisplayTiledAndScaled()
PIX * pixSubtractGray(PIX *pixd, PIX *pixs1, PIX *pixs2)
pixSubtractGray()
PIX * pixConvertTo8Or32(PIX *pixs, l_int32 copyflag, l_int32 warnflag)
pixConvertTo8Or32()
PIX * pixRemoveColormap(PIX *pixs, l_int32 type)
pixRemoveColormap()
PIX * pixConvertRGBToLuminance(PIX *pixs)
pixConvertRGBToLuminance()
PIX * pixScaleToSize(PIX *pixs, l_int32 wd, l_int32 hd)
pixScaleToSize()
PIX * pixAddSingleTextblock(PIX *pixs, L_BMF *bmf, const char *textstr, l_uint32 val, l_int32 location, l_int32 *poverflow)
pixAddSingleTextblock()