119 #include <config_auto.h>
123 #include "allheaders.h"
127 static const l_float32 EnhanceScaleFactor = 5.0;
186 PROCNAME(
"pixGammaTRC");
189 return (
PIX *)ERROR_PTR(
"pixs not defined", procName, pixd);
190 if (pixd && (pixd != pixs))
191 return (
PIX *)ERROR_PTR(
"pixd not null or pixs", procName, pixd);
193 L_WARNING(
"gamma must be > 0.0; setting to 1.0\n", procName);
196 if (minval >= maxval)
197 return (
PIX *)ERROR_PTR(
"minval not < maxval", procName, pixd);
198 cmap = pixGetColormap(pixs);
199 d = pixGetDepth(pixs);
200 if (!cmap && d != 8 && d != 32)
201 return (
PIX *)ERROR_PTR(
"depth not 8 or 32 bpp", procName, pixd);
203 if (gamma == 1.0 && minval == 0 && maxval == 255)
215 if ((nag =
numaGammaTRC(gamma, minval, maxval)) == NULL)
216 return (
PIX *)ERROR_PTR(
"nag not made", procName, pixd);
254 PROCNAME(
"pixGammaTRCMasked");
257 return pixGammaTRC(pixd, pixs, gamma, minval, maxval);
260 return (
PIX *)ERROR_PTR(
"pixs not defined", procName, pixd);
261 if (pixGetColormap(pixs))
262 return (
PIX *)ERROR_PTR(
"invalid: pixs has a colormap", procName, pixd);
263 if (pixd && (pixd != pixs))
264 return (
PIX *)ERROR_PTR(
"pixd not null or pixs", procName, pixd);
265 d = pixGetDepth(pixs);
266 if (d != 8 && d != 32)
267 return (
PIX *)ERROR_PTR(
"depth not 8 or 32 bpp", procName, pixd);
268 if (minval >= maxval)
269 return (
PIX *)ERROR_PTR(
"minval not < maxval", procName, pixd);
271 L_WARNING(
"gamma must be > 0.0; setting to 1.0\n", procName);
275 if (gamma == 1.0 && minval == 0 && maxval == 255)
281 if ((nag =
numaGammaTRC(gamma, minval, maxval)) == NULL)
282 return (
PIX *)ERROR_PTR(
"nag not made", procName, pixd);
317 PROCNAME(
"pixGammaTRCWithAlpha");
319 if (!pixs || pixGetDepth(pixs) != 32)
320 return (
PIX *)ERROR_PTR(
"pixs undefined or not 32 bpp", procName, pixd);
321 if (pixd && (pixd != pixs))
322 return (
PIX *)ERROR_PTR(
"pixd not null or pixs", procName, pixd);
324 L_WARNING(
"gamma must be > 0.0; setting to 1.0\n", procName);
327 if (minval >= maxval)
328 return (
PIX *)ERROR_PTR(
"minval not < maxval", procName, pixd);
330 if (gamma == 1.0 && minval == 0 && maxval == 255)
336 if ((nag =
numaGammaTRC(gamma, minval, maxval)) == NULL)
337 return (
PIX *)ERROR_PTR(
"nag not made", procName, pixd);
374 l_float32 x, invgamma;
377 PROCNAME(
"numaGammaTRC");
379 if (minval >= maxval)
380 return (
NUMA *)ERROR_PTR(
"minval not < maxval", procName, NULL);
382 L_WARNING(
"gamma must be > 0.0; setting to 1.0\n", procName);
386 invgamma = 1. / gamma;
388 for (i = 0; i < minval; i++)
390 for (i = minval; i <= maxval; i++) {
392 if (i > 255)
continue;
393 x = (l_float32)(i - minval) / (l_float32)(maxval - minval);
394 val = (l_int32)(255. * powf(x, invgamma) + 0.5);
396 val = L_MIN(val, 255);
399 for (i = maxval + 1; i < 256; i++)
447 PROCNAME(
"pixContrastTRC");
450 return (
PIX *)ERROR_PTR(
"pixs not defined", procName, pixd);
451 if (pixd && (pixd != pixs))
452 return (
PIX *)ERROR_PTR(
"pixd not null or pixs", procName, pixd);
454 L_WARNING(
"factor must be >= 0.0; using 0.0\n", procName);
460 cmap = pixGetColormap(pixs);
461 d = pixGetDepth(pixs);
462 if (!cmap && d != 8 && d != 32)
463 return (
PIX *)ERROR_PTR(
"depth not 8 or 32 bpp", procName, pixd);
475 return (
PIX *)ERROR_PTR(
"nac not made", procName, pixd);
509 PROCNAME(
"pixContrastTRCMasked");
515 return (
PIX *)ERROR_PTR(
"pixs not defined", procName, pixd);
516 if (pixGetColormap(pixs))
517 return (
PIX *)ERROR_PTR(
"invalid: pixs has a colormap", procName, pixd);
518 if (pixd && (pixd != pixs))
519 return (
PIX *)ERROR_PTR(
"pixd not null or pixs", procName, pixd);
520 d = pixGetDepth(pixs);
521 if (d != 8 && d != 32)
522 return (
PIX *)ERROR_PTR(
"depth not 8 or 32 bpp", procName, pixd);
525 L_WARNING(
"factor must be >= 0.0; using 0.0\n", procName);
535 return (
PIX *)ERROR_PTR(
"nac not made", procName, pixd);
563 l_float64 x, ymax, ymin, dely, scale;
566 PROCNAME(
"numaContrastTRC");
569 L_WARNING(
"factor must be >= 0.0; using 0.0; no enhancement\n",
576 scale = EnhanceScaleFactor;
577 ymax = atan((l_float64)(1.0 * factor * scale));
578 ymin = atan((l_float64)(-127. * factor * scale / 128.));
581 for (i = 0; i < 256; i++) {
583 val = (l_int32)((255. / dely) *
584 (-ymin + atan((l_float64)(factor * scale * (x - 127.) / 128.))) +
640 PROCNAME(
"pixEqualizeTRC");
643 return (
PIX *)ERROR_PTR(
"pixs not defined", procName, NULL);
644 if (pixd && (pixd != pixs))
645 return (
PIX *)ERROR_PTR(
"pixd not null or pixs", procName, pixd);
646 cmap = pixGetColormap(pixs);
647 d = pixGetDepth(pixs);
648 if (d != 8 && d != 32 && !cmap)
649 return (
PIX *)ERROR_PTR(
"pixs not 8/32 bpp or cmapped", procName, NULL);
650 if (fract < 0.0 || fract > 1.0)
651 return (
PIX *)ERROR_PTR(
"fract not in [0.0 ... 1.0]", procName, NULL);
653 return (
PIX *)ERROR_PTR(
"sampling factor < 1", procName, NULL);
668 d = pixGetDepth(pixd);
721 l_int32 iin, iout, itarg;
723 NUMA *nah, *nasum, *nad;
725 PROCNAME(
"numaEqualizeTRC");
728 return (
NUMA *)ERROR_PTR(
"pix not defined", procName, NULL);
729 if (pixGetDepth(pix) != 8)
730 return (
NUMA *)ERROR_PTR(
"pix not 8 bpp", procName, NULL);
731 if (fract < 0.0 || fract > 1.0)
732 return (
NUMA *)ERROR_PTR(
"fract not in [0.0 ... 1.0]", procName, NULL);
734 return (
NUMA *)ERROR_PTR(
"sampling factor < 1", procName, NULL);
737 L_WARNING(
"fract = 0.0; no equalization requested\n", procName);
740 return (
NUMA *)ERROR_PTR(
"histogram not made", procName, NULL);
745 for (iin = 0; iin < 256; iin++) {
747 itarg = (l_int32)(255. * val / sum + 0.5);
748 iout = iin + (l_int32)(fract * (itarg - iin));
749 iout = L_MIN(iout, 255);
788 l_int32 w, h, d, wm, hm, wpl, wplm, i, j, sval8, dval8;
789 l_uint32 sval32, dval32;
790 l_uint32 *data, *datam, *line, *linem, *tab;
792 PROCNAME(
"pixTRCMap");
795 return ERROR_INT(
"pixs not defined", procName, 1);
796 if (pixGetColormap(pixs))
797 return ERROR_INT(
"pixs is colormapped", procName, 1);
799 return ERROR_INT(
"na not defined", procName, 1);
801 return ERROR_INT(
"na not of size 256", procName, 1);
803 if (d != 8 && d != 32)
804 return ERROR_INT(
"pixs not 8 or 32 bpp", procName, 1);
806 if (pixGetDepth(pixm) != 1)
807 return ERROR_INT(
"pixm not 1 bpp", procName, 1);
811 wpl = pixGetWpl(pixs);
815 for (i = 0; i < h; i++) {
816 line = data + i * wpl;
817 for (j = 0; j < w; j++) {
824 for (i = 0; i < h; i++) {
825 line = data + i * wpl;
826 for (j = 0; j < w; j++) {
827 sval32 = *(line + j);
829 tab[(sval32 >> L_RED_SHIFT) & 0xff] << L_RED_SHIFT |
830 tab[(sval32 >> L_GREEN_SHIFT) & 0xff] << L_GREEN_SHIFT |
831 tab[(sval32 >> L_BLUE_SHIFT) & 0xff] << L_BLUE_SHIFT;
832 *(line + j) = dval32;
838 wplm = pixGetWpl(pixm);
841 for (i = 0; i < h; i++) {
844 line = data + i * wpl;
845 linem = datam + i * wplm;
846 for (j = 0; j < w; j++) {
857 for (i = 0; i < h; i++) {
860 line = data + i * wpl;
861 linem = datam + i * wplm;
862 for (j = 0; j < w; j++) {
867 sval32 = *(line + j);
869 tab[(sval32 >> L_RED_SHIFT) & 0xff] << L_RED_SHIFT |
870 tab[(sval32 >> L_GREEN_SHIFT) & 0xff] << L_GREEN_SHIFT |
871 tab[(sval32 >> L_BLUE_SHIFT) & 0xff] << L_BLUE_SHIFT;
872 *(line + j) = dval32;
912 l_int32 w, h, wm, hm, wpl, wplm, i, j;
913 l_uint32 sval32, dval32;
914 l_uint32 *data, *datam, *line, *linem, *tabr, *tabg, *tabb;
916 PROCNAME(
"pixTRCMapGeneral");
918 if (!pixs || pixGetDepth(pixs) != 32)
919 return ERROR_INT(
"pixs not defined or not 32 bpp", procName, 1);
920 if (pixm && pixGetDepth(pixm) != 1)
921 return ERROR_INT(
"pixm defined and not 1 bpp", procName, 1);
922 if (!nar || !nag || !nab)
923 return ERROR_INT(
"na{r,g,b} not all defined", procName, 1);
926 return ERROR_INT(
"na{r,g,b} not all of size 256", procName, 1);
933 wpl = pixGetWpl(pixs);
936 for (i = 0; i < h; i++) {
937 line = data + i * wpl;
938 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;
949 wplm = pixGetWpl(pixm);
951 for (i = 0; i < h; i++) {
954 line = data + i * wpl;
955 linem = datam + i * wplm;
956 for (j = 0; j < w; j++) {
961 sval32 = *(line + j);
963 tabr[(sval32 >> L_RED_SHIFT) & 0xff] << L_RED_SHIFT |
964 tabg[(sval32 >> L_GREEN_SHIFT) & 0xff] << L_GREEN_SHIFT |
965 tabb[(sval32 >> L_BLUE_SHIFT) & 0xff] << L_BLUE_SHIFT;
966 *(line + j) = dval32;
1006 PIX *pix1, *pixd, *pixr, *pixrs, *pixg, *pixgs, *pixb, *pixbs;
1008 PROCNAME(
"pixUnsharpMasking");
1010 if (!pixs || (pixGetDepth(pixs) == 1))
1011 return (
PIX *)ERROR_PTR(
"pixs not defined or 1 bpp", procName, NULL);
1012 if (fract <= 0.0 || halfwidth <= 0) {
1013 L_WARNING(
"no sharpening requested; clone returned\n", procName);
1017 if (halfwidth == 1 || halfwidth == 2)
1022 return (
PIX *)ERROR_PTR(
"pix1 not made", procName, NULL);
1025 d = pixGetDepth(pix1);
1042 if (pixGetSpp(pixs) == 4)
1078 PROCNAME(
"pixUnsharpMaskingGray");
1081 return (
PIX *)ERROR_PTR(
"pixs not defined", procName, NULL);
1083 if (d != 8 || pixGetColormap(pixs) != NULL)
1084 return (
PIX *)ERROR_PTR(
"pixs not 8 bpp or has cmap", procName, NULL);
1085 if (fract <= 0.0 || halfwidth <= 0) {
1086 L_WARNING(
"no sharpening requested; clone returned\n", procName);
1089 if (halfwidth == 1 || halfwidth == 2)
1094 return (
PIX *)ERROR_PTR(
"pixc not made", procName, NULL);
1173 PIX *pixt, *pixd, *pixr, *pixrs, *pixg, *pixgs, *pixb, *pixbs;
1175 PROCNAME(
"pixUnsharpMaskingFast");
1177 if (!pixs || (pixGetDepth(pixs) == 1))
1178 return (
PIX *)ERROR_PTR(
"pixs not defined or 1 bpp", procName, NULL);
1179 if (fract <= 0.0 || halfwidth <= 0) {
1180 L_WARNING(
"no sharpening requested; clone returned\n", procName);
1183 if (halfwidth != 1 && halfwidth != 2)
1184 return (
PIX *)ERROR_PTR(
"halfwidth must be 1 or 2", procName, NULL);
1185 if (direction != L_HORIZ && direction != L_VERT &&
1186 direction != L_BOTH_DIRECTIONS)
1187 return (
PIX *)ERROR_PTR(
"invalid direction", procName, NULL);
1191 return (
PIX *)ERROR_PTR(
"pixt not made", procName, NULL);
1194 d = pixGetDepth(pixt);
1208 if (pixGetSpp(pixs) == 4)
1245 PROCNAME(
"pixUnsharpMaskingGrayFast");
1248 return (
PIX *)ERROR_PTR(
"pixs not defined", procName, NULL);
1249 if (pixGetDepth(pixs) != 8 || pixGetColormap(pixs) != NULL)
1250 return (
PIX *)ERROR_PTR(
"pixs not 8 bpp or has cmap", procName, NULL);
1251 if (fract <= 0.0 || halfwidth <= 0) {
1252 L_WARNING(
"no sharpening requested; clone returned\n", procName);
1255 if (halfwidth != 1 && halfwidth != 2)
1256 return (
PIX *)ERROR_PTR(
"halfwidth must be 1 or 2", procName, NULL);
1257 if (direction != L_HORIZ && direction != L_VERT &&
1258 direction != L_BOTH_DIRECTIONS)
1259 return (
PIX *)ERROR_PTR(
"invalid direction", procName, NULL);
1261 if (direction != L_BOTH_DIRECTIONS)
1292 l_int32 w, h, d, wpls, wpld, i, j, ival;
1293 l_uint32 *datas, *datad;
1294 l_uint32 *lines, *lines0, *lines1, *lines2, *lines3, *lines4, *lined;
1295 l_float32 val, a[5];
1298 PROCNAME(
"pixUnsharpMaskingGray1D");
1301 return (
PIX *)ERROR_PTR(
"pixs not defined", procName, NULL);
1303 if (d != 8 || pixGetColormap(pixs) != NULL)
1304 return (
PIX *)ERROR_PTR(
"pixs not 8 bpp or has cmap", procName, NULL);
1305 if (fract <= 0.0 || halfwidth <= 0) {
1306 L_WARNING(
"no sharpening requested; clone returned\n", procName);
1309 if (halfwidth != 1 && halfwidth != 2)
1310 return (
PIX *)ERROR_PTR(
"halfwidth must be 1 or 2", procName, NULL);
1315 halfwidth, halfwidth);
1318 wpls = pixGetWpl(pixs);
1319 wpld = pixGetWpl(pixd);
1321 if (halfwidth == 1) {
1322 a[0] = -fract / 3.0;
1323 a[1] = 1.0 + fract * 2.0 / 3.0;
1326 a[0] = -fract / 5.0;
1328 a[2] = 1.0 + fract * 4.0 / 5.0;
1333 if (direction == L_HORIZ) {
1334 for (i = 0; i < h; i++) {
1335 lines = datas + i * wpls;
1336 lined = datad + i * wpld;
1337 if (halfwidth == 1) {
1338 for (j = 1; j < w - 1; j++) {
1342 ival = (l_int32)val;
1343 ival = L_MAX(0, ival);
1344 ival = L_MIN(255, ival);
1348 for (j = 2; j < w - 2; j++) {
1354 ival = (l_int32)val;
1355 ival = L_MAX(0, ival);
1356 ival = L_MIN(255, ival);
1362 if (halfwidth == 1) {
1363 for (i = 1; i < h - 1; i++) {
1364 lines0 = datas + (i - 1) * wpls;
1365 lines1 = datas + i * wpls;
1366 lines2 = datas + (i + 1) * wpls;
1367 lined = datad + i * wpld;
1368 for (j = 0; j < w; j++) {
1372 ival = (l_int32)val;
1373 ival = L_MAX(0, ival);
1374 ival = L_MIN(255, ival);
1379 for (i = 2; i < h - 2; i++) {
1380 lines0 = datas + (i - 2) * wpls;
1381 lines1 = datas + (i - 1) * wpls;
1382 lines2 = datas + i * wpls;
1383 lines3 = datas + (i + 1) * wpls;
1384 lines4 = datas + (i + 2) * wpls;
1385 lined = datad + i * wpld;
1386 for (j = 0; j < w; j++) {
1392 ival = (l_int32)val;
1393 ival = L_MAX(0, ival);
1394 ival = L_MIN(255, ival);
1425 l_int32 w, h, d, wpls, wpld, wplf, i, j, ival, sval;
1426 l_uint32 *datas, *datad, *lines, *lined;
1427 l_float32 val, norm;
1428 l_float32 *dataf, *linef, *linef0, *linef1, *linef2, *linef3, *linef4;
1432 PROCNAME(
"pixUnsharpMaskingGray2D");
1435 return (
PIX *)ERROR_PTR(
"pixs not defined", procName, NULL);
1437 if (d != 8 || pixGetColormap(pixs) != NULL)
1438 return (
PIX *)ERROR_PTR(
"pixs not 8 bpp or has cmap", procName, NULL);
1439 if (fract <= 0.0 || halfwidth <= 0) {
1440 L_WARNING(
"no sharpening requested; clone returned\n", procName);
1443 if (halfwidth != 1 && halfwidth != 2)
1444 return (
PIX *)ERROR_PTR(
"halfwidth must be 1 or 2", procName, NULL);
1447 halfwidth, halfwidth)) == NULL)
1448 return (
PIX *)ERROR_PTR(
"pixd not made", procName, NULL);
1450 wpld = pixGetWpl(pixd);
1452 wpls = pixGetWpl(pixs);
1458 return (
PIX *)ERROR_PTR(
"fpix not made", procName, NULL);
1462 if (halfwidth == 1) {
1463 for (i = 0; i < h; i++) {
1464 lines = datas + i * wpls;
1465 linef = dataf + i * wplf;
1466 for (j = 1; j < w - 1; j++) {
1474 for (i = 0; i < h; i++) {
1475 lines = datas + i * wpls;
1476 linef = dataf + i * wplf;
1477 for (j = 2; j < w - 2; j++) {
1495 if (halfwidth == 1) {
1496 for (i = 1; i < h - 1; i++) {
1497 linef0 = dataf + (i - 1) * wplf;
1498 linef1 = dataf + i * wplf;
1499 linef2 = dataf + (i + 1) * wplf;
1500 lined = datad + i * wpld;
1501 lines = datas + i * wpls;
1503 for (j = 1; j < w - 1; j++) {
1504 val = norm * (linef0[j] + linef1[j] +
1507 ival = (l_int32)(sval + fract * (sval - val) + 0.5);
1508 ival = L_MAX(0, ival);
1509 ival = L_MIN(255, ival);
1514 for (i = 2; i < h - 2; i++) {
1515 linef0 = dataf + (i - 2) * wplf;
1516 linef1 = dataf + (i - 1) * wplf;
1517 linef2 = dataf + i * wplf;
1518 linef3 = dataf + (i + 1) * wplf;
1519 linef4 = dataf + (i + 2) * wplf;
1520 lined = datad + i * wpld;
1521 lines = datas + i * wpls;
1523 for (j = 2; j < w - 2; j++) {
1524 val = norm * (linef0[j] + linef1[j] + linef2[j] + linef3[j] +
1527 ival = (l_int32)(sval + fract * (sval - val) + 0.5);
1528 ival = L_MAX(0, ival);
1529 ival = L_MIN(255, ival);
1571 l_int32 w, h, d, i, j, wpl, delhue;
1572 l_int32 rval, gval, bval, hval, sval, vval;
1573 l_uint32 *data, *line;
1575 PROCNAME(
"pixModifyHue");
1578 return (
PIX *)ERROR_PTR(
"pixs not defined", procName, NULL);
1579 if (pixGetColormap(pixs) != NULL)
1580 return (
PIX *)ERROR_PTR(
"pixs colormapped", procName, NULL);
1581 if (pixd && (pixd != pixs))
1582 return (
PIX *)ERROR_PTR(
"pixd not null or pixs", procName, pixd);
1585 return (
PIX *)ERROR_PTR(
"pixs not 32 bpp", procName, NULL);
1586 if (L_ABS(fract) > 1.0)
1587 return (
PIX *)ERROR_PTR(
"fract not in [-1.0 ... 1.0]", procName, NULL);
1591 delhue = (l_int32)(240 * fract);
1592 if (delhue == 0 || delhue == 240 || delhue == -240) {
1593 L_WARNING(
"no change requested in hue\n", procName);
1600 wpl = pixGetWpl(pixd);
1601 for (i = 0; i < h; i++) {
1602 line = data + i * wpl;
1603 for (j = 0; j < w; j++) {
1606 hval = (hval + delhue) % 240;
1611 if (pixGetSpp(pixs) == 4)
1645 l_int32 w, h, d, i, j, wpl;
1646 l_int32 rval, gval, bval, hval, sval, vval;
1647 l_uint32 *data, *line;
1649 PROCNAME(
"pixModifySaturation");
1652 return (
PIX *)ERROR_PTR(
"pixs not defined", procName, NULL);
1655 return (
PIX *)ERROR_PTR(
"pixs not 32 bpp", procName, NULL);
1656 if (L_ABS(fract) > 1.0)
1657 return (
PIX *)ERROR_PTR(
"fract not in [-1.0 ... 1.0]", procName, NULL);
1661 L_WARNING(
"no change requested in saturation\n", procName);
1666 wpl = pixGetWpl(pixd);
1667 for (i = 0; i < h; i++) {
1668 line = data + i * wpl;
1669 for (j = 0; j < w; j++) {
1673 sval = (l_int32)(sval * (1.0 + fract));
1675 sval = (l_int32)(sval + fract * (255 - sval));
1680 if (pixGetSpp(pixs) == 4)
1700 l_int32 w, h, d, i, j, wpl, sum, count;
1701 l_int32 rval, gval, bval, hval, sval, vval;
1702 l_uint32 *data, *line;
1704 PROCNAME(
"pixMeasureSaturation");
1707 return ERROR_INT(
"pixs not defined", procName, 1);
1710 return ERROR_INT(
"pixs not defined", procName, 1);
1713 return ERROR_INT(
"pixs not 32 bpp", procName, 1);
1715 return ERROR_INT(
"subsampling factor < 1", procName, 1);
1718 wpl = pixGetWpl(pixs);
1719 for (i = 0, sum = 0, count = 0; i < h; i += factor) {
1720 line = data + i * wpl;
1721 for (j = 0; j < w; j += factor) {
1730 *psat = (l_float32)sum / (l_float32)count;
1762 l_int32 w, h, d, i, j, wpl;
1763 l_int32 rval, gval, bval, hval, sval, vval;
1764 l_uint32 *data, *line;
1766 PROCNAME(
"pixModifyBrightness");
1769 return (
PIX *)ERROR_PTR(
"pixs not defined", procName, NULL);
1772 return (
PIX *)ERROR_PTR(
"pixs not 32 bpp", procName, NULL);
1773 if (L_ABS(fract) > 1.0)
1774 return (
PIX *)ERROR_PTR(
"fract not in [-1.0 ... 1.0]", procName, NULL);
1778 L_WARNING(
"no change requested in brightness\n", procName);
1783 wpl = pixGetWpl(pixd);
1784 for (i = 0; i < h; i++) {
1785 line = data + i * wpl;
1786 for (j = 0; j < w; j++) {
1790 vval = (l_int32)(vval + fract * (255.0 - vval));
1792 vval = (l_int32)(vval * (1.0 + fract));
1797 if (pixGetSpp(pixs) == 4)
1848 l_float32 del, ratio;
1850 PIX *pix1, *pix2, *pix3;
1853 PROCNAME(
"pixMosaicColorShiftRGB");
1855 if (!pixs || pixGetDepth(pixs) != 32)
1856 return (
PIX *)ERROR_PTR(
"pixs undefined or not rgb", procName, NULL);
1857 if (roff < -1.0 || roff > 1.0)
1858 return (
PIX *)ERROR_PTR(
"roff not in [-1.0, 1.0]", procName, NULL);
1859 if (goff < -1.0 || goff > 1.0)
1860 return (
PIX *)ERROR_PTR(
"goff not in [-1.0, 1.0]", procName, NULL);
1861 if (boff < -1.0 || boff > 1.0)
1862 return (
PIX *)ERROR_PTR(
"boff not in [-1.0, 1.0]", procName, NULL);
1863 if (delta < 0.0 || delta > 0.1)
1864 return (
PIX *)ERROR_PTR(
"delta not in [0.0, 0.1]", procName, NULL);
1865 if (delta == 0.0) delta = 0.04;
1866 if (nincr < 0 || nincr > 6)
1867 return (
PIX *)ERROR_PTR(
"nincr not in [0, 6]", procName, NULL);
1868 if (nincr == 0) nincr = 2;
1872 if (w < 100 || h < 100)
1873 return (
PIX *)ERROR_PTR(
"w and h not both >= 100", procName, NULL);
1875 if (ratio < 1.0 || ratio > 5.0) {
1876 L_ERROR(
"invalid aspect ratio %5.1f\n", procName, ratio);
1883 for (i = 0, del = - nincr * delta; i < 2 * nincr + 1; i++, del += delta) {
1885 snprintf(buf,
sizeof(buf),
"%4.2f, %4.2f, %4.2f",
1886 roff + del, goff, boff);
1892 for (i = 0, del = - nincr * delta; i < 2 * nincr + 1; i++, del += delta) {
1894 snprintf(buf,
sizeof(buf),
"%4.2f, %4.2f, %4.2f",
1895 roff, goff + del, boff);
1901 for (i = 0, del = - nincr * delta; i < 2 * nincr + 1; i++, del += delta) {
1903 snprintf(buf,
sizeof(buf),
"%4.2f, %4.2f, %4.2f",
1904 roff, goff, boff + del);
1950 l_int32 w, h, i, j, wpls, wpld, rval, gval, bval;
1951 l_int32 *rlut, *glut, *blut;
1952 l_uint32 *datas, *datad, *lines, *lined;
1956 PROCNAME(
"pixColorShiftRGB");
1959 return (
PIX *)ERROR_PTR(
"pixs not defined", procName, NULL);
1960 if (pixGetDepth(pixs) != 32)
1961 return (
PIX *)ERROR_PTR(
"pixs not 32 bpp", procName, NULL);
1962 if (rfract < -1.0 || rfract > 1.0)
1963 return (
PIX *)ERROR_PTR(
"rfract not in [-1.0, 1.0]", procName, NULL);
1964 if (gfract < -1.0 || gfract > 1.0)
1965 return (
PIX *)ERROR_PTR(
"gfract not in [-1.0, 1.0]", procName, NULL);
1966 if (bfract < -1.0 || bfract > 1.0)
1967 return (
PIX *)ERROR_PTR(
"bfract not in [-1.0, 1.0]", procName, NULL);
1968 if (rfract == 0.0 && gfract == 0.0 && bfract == 0.0)
1971 rlut = (l_int32 *)LEPT_CALLOC(256,
sizeof(l_int32));
1972 glut = (l_int32 *)LEPT_CALLOC(256,
sizeof(l_int32));
1973 blut = (l_int32 *)LEPT_CALLOC(256,
sizeof(l_int32));
1974 for (i = 0; i < 256; i++) {
1977 rlut[i] = (l_int32)(fi + (255.0 - fi) * rfract);
1979 rlut[i] = (l_int32)(fi * (1.0 + rfract));
1982 glut[i] = (l_int32)(fi + (255.0 - fi) * gfract);
1984 glut[i] = (l_int32)(fi * (1.0 + gfract));
1987 blut[i] = (l_int32)(fi + (255.0 - fi) * bfract);
1989 blut[i] = (l_int32)(fi * (1.0 + bfract));
1995 wpls = pixGetWpl(pixs);
1998 wpld = pixGetWpl(pixd);
1999 for (i = 0; i < h; i++) {
2000 lines = datas + i * wpls;
2001 lined = datad + i * wpld;
2002 for (j = 0; j < w; j++) {
2049 l_int32 w, h, i, j, wpls, wpld;
2050 l_int32 rval, gval, bval, minrg, min, maxrg, max, sat;
2051 l_uint32 *datas, *datad, *lines, *lined;
2054 PROCNAME(
"pixDarkenGray");
2056 if (!pixs || pixGetDepth(pixs) != 32)
2057 return (
PIX *)ERROR_PTR(
"pixs undefined or not 32 bpp", procName, NULL);
2058 if (thresh < 0 || thresh > 255)
2059 return (
PIX *)ERROR_PTR(
"invalid thresh", procName, NULL);
2061 return (
PIX *)ERROR_PTR(
"invalid satlimit", procName, NULL);
2062 if (pixd && (pixs != pixd))
2063 return (
PIX *)ERROR_PTR(
"not new or in-place", procName, NULL);
2067 wpls = pixGetWpl(pixs);
2068 if ((pixd =
pixCopy(pixd, pixs)) == NULL)
2069 return (
PIX *)ERROR_PTR(
"pixd not made", procName, NULL);
2071 wpld = pixGetWpl(pixd);
2073 for (i = 0; i < h; i++) {
2074 lines = datas + i * wpls;
2075 lined = datad + i * wpld;
2076 for (j = 0; j < w; j++) {
2078 minrg = L_MIN(rval, gval);
2079 min = L_MIN(minrg, bval);
2080 maxrg = L_MAX(rval, gval);
2081 max = L_MAX(maxrg, bval);
2083 if (max >= thresh || sat >= satlimit)
2085 ratio = (l_float32)sat / (l_float32)satlimit;
2087 (l_int32)(ratio * bval), &lined[j]);
2121 l_int32 i, j, w, h, d, wpls, wpld;
2122 l_int32 ncolors, rval, gval, bval, nrval, ngval, nbval;
2124 l_uint32 *datas, *datad, *lines, *lined;
2128 PROCNAME(
"pixMultConstantColor");
2131 return (
PIX *)ERROR_PTR(
"pixs not defined", procName, NULL);
2133 cmap = pixGetColormap(pixs);
2134 if (!cmap && d != 32)
2135 return (
PIX *)ERROR_PTR(
"pixs not cmapped or 32 bpp", procName, NULL);
2136 rfact = L_MAX(0.0, rfact);
2137 gfact = L_MAX(0.0, gfact);
2138 bfact = L_MAX(0.0, bfact);
2141 if ((pixd =
pixCopy(NULL, pixs)) == NULL)
2142 return (
PIX *)ERROR_PTR(
"pixd not made", procName, NULL);
2143 cmap = pixGetColormap(pixd);
2145 for (i = 0; i < ncolors; i++) {
2147 nrval = (l_int32)(rfact * rval);
2148 ngval = (l_int32)(gfact * gval);
2149 nbval = (l_int32)(bfact * bval);
2150 nrval = L_MIN(255, nrval);
2151 ngval = L_MIN(255, ngval);
2152 nbval = L_MIN(255, nbval);
2159 return (
PIX *)ERROR_PTR(
"pixd not made", procName, NULL);
2162 wpls = pixGetWpl(pixs);
2163 wpld = pixGetWpl(pixd);
2164 for (i = 0; i < h; i++) {
2165 lines = datas + i * wpls;
2166 lined = datad + i * wpld;
2167 for (j = 0; j < w; j++) {
2169 nrval = (l_int32)(rfact * rval);
2170 ngval = (l_int32)(gfact * gval);
2171 nbval = (l_int32)(bfact * bval);
2172 nrval = L_MIN(255, nrval);
2173 ngval = L_MIN(255, ngval);
2174 nbval = L_MIN(255, nbval);
2176 *(lined + j) = nval;
2221 l_int32 i, j, index, kw, kh, w, h, d, wpls, wpld;
2222 l_int32 ncolors, rval, gval, bval, nrval, ngval, nbval;
2224 l_uint32 *datas, *datad, *lines, *lined;
2229 PROCNAME(
"pixMultMatrixColor");
2232 return (
PIX *)ERROR_PTR(
"pixs not defined", procName, NULL);
2234 return (
PIX *)ERROR_PTR(
"kel not defined", procName, NULL);
2236 if (kw != 3 || kh != 3)
2237 return (
PIX *)ERROR_PTR(
"matrix not 3x3", procName, NULL);
2239 cmap = pixGetColormap(pixs);
2240 if (!cmap && d != 32)
2241 return (
PIX *)ERROR_PTR(
"pixs not cmapped or 32 bpp", procName, NULL);
2243 for (i = 0, index = 0; i < 3; i++)
2244 for (j = 0; j < 3; j++, index++)
2248 if ((pixd =
pixCopy(NULL, pixs)) == NULL)
2249 return (
PIX *)ERROR_PTR(
"pixd not made", procName, NULL);
2250 cmap = pixGetColormap(pixd);
2252 for (i = 0; i < ncolors; i++) {
2254 nrval = (l_int32)(v[0] * rval + v[1] * gval + v[2] * bval);
2255 ngval = (l_int32)(v[3] * rval + v[4] * gval + v[5] * bval);
2256 nbval = (l_int32)(v[6] * rval + v[7] * gval + v[8] * bval);
2257 nrval = L_MAX(0, L_MIN(255, nrval));
2258 ngval = L_MAX(0, L_MIN(255, ngval));
2259 nbval = L_MAX(0, L_MIN(255, nbval));
2266 return (
PIX *)ERROR_PTR(
"pixd not made", procName, NULL);
2269 wpls = pixGetWpl(pixs);
2270 wpld = pixGetWpl(pixd);
2271 for (i = 0; i < h; i++) {
2272 lines = datas + i * wpls;
2273 lined = datad + i * wpld;
2274 for (j = 0; j < w; j++) {
2276 nrval = (l_int32)(v[0] * rval + v[1] * gval + v[2] * bval);
2277 ngval = (l_int32)(v[3] * rval + v[4] * gval + v[5] * bval);
2278 nbval = (l_int32)(v[6] * rval + v[7] * gval + v[8] * bval);
2279 nrval = L_MAX(0, L_MIN(255, nrval));
2280 ngval = L_MAX(0, L_MIN(255, ngval));
2281 nbval = L_MAX(0, L_MIN(255, nbval));
2283 *(lined + j) = nval;
2334 PIX *pixg, *pixacc, *pixc1, *pixc2;
2336 PROCNAME(
"pixHalfEdgeByBandpass");
2339 return (
PIX *)ERROR_PTR(
"pixs not defined", procName, NULL);
2340 if (sm1h == sm2h && sm1v == sm2v)
2341 return (
PIX *)ERROR_PTR(
"sm2 = sm1", procName, NULL);
2342 d = pixGetDepth(pixs);
2343 if (d != 8 && d != 32)
2344 return (
PIX *)ERROR_PTR(
"pixs not 8 or 32 bpp", procName, NULL);
2353 return (
PIX *)ERROR_PTR(
"pixacc not made", procName, NULL);
2358 return (
PIX *)ERROR_PTR(
"pixc1 not made", procName, NULL);
2365 return (
PIX *)ERROR_PTR(
"pixc2 not made", procName, 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()