86 #include <config_auto.h>
91 #include "allheaders.h"
95 #define SLOW_CUBE_ROOT 0
99 static l_float32 lab_forward(l_float32 v);
100 static l_float32 lab_reverse(l_float32 v);
145 l_int32 w, h, d, wpl, i, j, rval, gval, bval, hval, sval, vval;
146 l_uint32 *line, *data;
149 PROCNAME(
"pixConvertRGBToHSV");
152 return (
PIX *)ERROR_PTR(
"pixs not defined", procName, pixd);
153 if (pixd && pixd != pixs)
154 return (
PIX *)ERROR_PTR(
"pixd defined and not inplace", procName, pixd);
156 d = pixGetDepth(pixs);
157 cmap = pixGetColormap(pixs);
158 if (!cmap && d != 32)
159 return (
PIX *)ERROR_PTR(
"not cmapped or rgb", procName, pixd);
164 cmap = pixGetColormap(pixd);
172 wpl = pixGetWpl(pixd);
174 for (i = 0; i < h; i++) {
175 line = data + i * wpl;
176 for (j = 0; j < w; j++) {
179 line[j] = (hval << 24) | (sval << 16) | (vval << 8);
209 l_int32 w, h, d, wpl, i, j, rval, gval, bval, hval, sval, vval;
211 l_uint32 *line, *data;
214 PROCNAME(
"pixConvertHSVToRGB");
217 return (
PIX *)ERROR_PTR(
"pixs not defined", procName, pixd);
218 if (pixd && pixd != pixs)
219 return (
PIX *)ERROR_PTR(
"pixd defined and not inplace", procName, pixd);
221 d = pixGetDepth(pixs);
222 cmap = pixGetColormap(pixs);
223 if (!cmap && d != 32)
224 return (
PIX *)ERROR_PTR(
"not cmapped or hsv", procName, pixd);
229 cmap = pixGetColormap(pixd);
237 wpl = pixGetWpl(pixd);
239 for (i = 0; i < h; i++) {
240 line = data + i * wpl;
241 for (j = 0; j < w; j++) {
244 sval = (pixel >> 16) & 0xff;
245 vval = (pixel >> 8) & 0xff;
288 l_int32 minrg, maxrg, min, max, delta;
291 PROCNAME(
"convertRGBToHSV");
293 if (phval) *phval = 0;
294 if (psval) *psval = 0;
295 if (pvval) *pvval = 0;
296 if (!phval || !psval || !pvval)
297 return ERROR_INT(
"&hval, &sval, &vval not all defined", procName, 1);
299 minrg = L_MIN(rval, gval);
300 min = L_MIN(minrg, bval);
301 maxrg = L_MAX(rval, gval);
302 max = L_MAX(maxrg, bval);
310 *psval = (l_int32)(255. * (l_float32)delta / (l_float32)max + 0.5);
312 h = (l_float32)(gval - bval) / (l_float32)delta;
313 else if (gval == max)
314 h = 2. + (l_float32)(bval - rval) / (l_float32)delta;
316 h = 4. + (l_float32)(rval - gval) / (l_float32)delta;
322 *phval = (l_int32)(h + 0.5);
353 PROCNAME(
"convertHSVToRGB");
355 if (prval) *prval = 0;
356 if (pgval) *pgval = 0;
357 if (pbval) *pbval = 0;
358 if (!prval || !pgval || !pbval)
359 return ERROR_INT(
"&rval, &gval, &bval not all defined", procName, 1);
366 if (hval < 0 || hval > 240)
367 return ERROR_INT(
"invalid hval", procName, 1);
370 h = (l_float32)hval / 40.;
373 s = (l_float32)sval / 255.;
374 x = (l_int32)(vval * (1. - s) + 0.5);
375 y = (l_int32)(vval * (1. - s * f) + 0.5);
376 z = (l_int32)(vval * (1. - s * (1. - f)) + 0.5);
434 l_int32 i, ncolors, rval, gval, bval, hval, sval, vval;
436 PROCNAME(
"pixcmapConvertRGBToHSV");
439 return ERROR_INT(
"cmap not defined", procName, 1);
442 for (i = 0; i < ncolors; i++) {
467 l_int32 i, ncolors, rval, gval, bval, hval, sval, vval;
469 PROCNAME(
"pixcmapConvertHSVToRGB");
472 return ERROR_INT(
"cmap not defined", procName, 1);
475 for (i = 0; i < ncolors; i++) {
502 l_int32 w, h, d, wplt, wpld;
503 l_int32 i, j, rval, gval, bval, hval, minrg, min, maxrg, max, delta;
506 l_uint32 *linet, *lined, *datat, *datad;
509 PROCNAME(
"pixConvertRGBToHue");
512 return (
PIX *)ERROR_PTR(
"pixs not defined", procName, NULL);
515 if (d != 32 && !pixGetColormap(pixs))
516 return (
PIX *)ERROR_PTR(
"not cmapped or rgb", procName, NULL);
521 pixCopyResolution(pixd, pixs);
522 wplt = pixGetWpl(pixt);
524 wpld = pixGetWpl(pixd);
526 for (i = 0; i < h; i++) {
527 linet = datat + i * wplt;
528 lined = datad + i * wpld;
529 for (j = 0; j < w; j++) {
532 minrg = L_MIN(rval, gval);
533 min = L_MIN(minrg, bval);
534 maxrg = L_MAX(rval, gval);
535 max = L_MAX(maxrg, bval);
541 fh = (l_float32)(gval - bval) / (l_float32)delta;
542 else if (gval == max)
543 fh = 2. + (l_float32)(bval - rval) / (l_float32)delta;
545 fh = 4. + (l_float32)(rval - gval) / (l_float32)delta;
549 hval = (l_int32)(fh + 0.5);
578 l_int32 w, h, d, wplt, wpld;
579 l_int32 i, j, rval, gval, bval, sval, minrg, min, maxrg, max, delta;
581 l_uint32 *linet, *lined, *datat, *datad;
584 PROCNAME(
"pixConvertRGBToSaturation");
587 return (
PIX *)ERROR_PTR(
"pixs not defined", procName, NULL);
590 if (d != 32 && !pixGetColormap(pixs))
591 return (
PIX *)ERROR_PTR(
"not cmapped or rgb", procName, NULL);
596 pixCopyResolution(pixd, pixs);
597 wplt = pixGetWpl(pixt);
599 wpld = pixGetWpl(pixd);
601 for (i = 0; i < h; i++) {
602 linet = datat + i * wplt;
603 lined = datad + i * wpld;
604 for (j = 0; j < w; j++) {
607 minrg = L_MIN(rval, gval);
608 min = L_MIN(minrg, bval);
609 maxrg = L_MAX(rval, gval);
610 max = L_MAX(maxrg, bval);
615 sval = (l_int32)(255. *
616 (l_float32)delta / (l_float32)max + 0.5);
643 l_int32 w, h, d, wplt, wpld;
644 l_int32 i, j, rval, gval, bval, maxrg, max;
646 l_uint32 *linet, *lined, *datat, *datad;
649 PROCNAME(
"pixConvertRGBToValue");
652 return (
PIX *)ERROR_PTR(
"pixs not defined", procName, NULL);
655 if (d != 32 && !pixGetColormap(pixs))
656 return (
PIX *)ERROR_PTR(
"not cmapped or rgb", procName, NULL);
661 pixCopyResolution(pixd, pixs);
662 wplt = pixGetWpl(pixt);
664 wpld = pixGetWpl(pixd);
666 for (i = 0; i < h; i++) {
667 linet = datat + i * wplt;
668 lined = datad + i * wpld;
669 for (j = 0; j < w; j++) {
672 maxrg = L_MAX(rval, gval);
673 max = L_MAX(maxrg, bval);
717 l_int32 i, j, w, h, wplt, wpld, hstart, hend, sstart, send, hval, sval;
718 l_int32 *hlut, *slut;
720 l_uint32 *datat, *datad, *linet, *lined;
723 PROCNAME(
"pixMakeRangeMaskHS");
725 if (!pixs || pixGetDepth(pixs) != 32)
726 return (
PIX *)ERROR_PTR(
"pixs undefined or not 32 bpp", procName, NULL);
728 return (
PIX *)ERROR_PTR(
"invalid regionflag", procName, NULL);
732 hlut = (l_int32 *)LEPT_CALLOC(240,
sizeof(l_int32));
733 slut = (l_int32 *)LEPT_CALLOC(256,
sizeof(l_int32));
734 sstart = L_MAX(0, satcenter - sathw);
735 send = L_MIN(255, satcenter + sathw);
736 for (i = sstart; i <= send; i++)
738 hstart = (huecenter - huehw + 240) % 240;
739 hend = (huecenter + huehw + 240) % 240;
741 for (i = hstart; i <= hend; i++)
744 for (i = hstart; i < 240; i++)
746 for (i = 0; i <= hend; i++)
760 wplt = pixGetWpl(pixt);
761 wpld = pixGetWpl(pixd);
762 for (i = 0; i < h; i++) {
763 linet = datat + i * wplt;
764 lined = datad + i * wpld;
765 for (j = 0; j < w; j++) {
767 hval = (pixel >> L_RED_SHIFT) & 0xff;
768 sval = (pixel >> L_GREEN_SHIFT) & 0xff;
769 if (hlut[hval] == 1 && slut[sval] == 1) {
816 l_int32 i, j, w, h, wplt, wpld, hstart, hend, vstart, vend, hval, vval;
817 l_int32 *hlut, *vlut;
819 l_uint32 *datat, *datad, *linet, *lined;
822 PROCNAME(
"pixMakeRangeMaskHV");
824 if (!pixs || pixGetDepth(pixs) != 32)
825 return (
PIX *)ERROR_PTR(
"pixs undefined or not 32 bpp", procName, NULL);
827 return (
PIX *)ERROR_PTR(
"invalid regionflag", procName, NULL);
831 hlut = (l_int32 *)LEPT_CALLOC(240,
sizeof(l_int32));
832 vlut = (l_int32 *)LEPT_CALLOC(256,
sizeof(l_int32));
833 vstart = L_MAX(0, valcenter - valhw);
834 vend = L_MIN(255, valcenter + valhw);
835 for (i = vstart; i <= vend; i++)
837 hstart = (huecenter - huehw + 240) % 240;
838 hend = (huecenter + huehw + 240) % 240;
840 for (i = hstart; i <= hend; i++)
843 for (i = hstart; i < 240; i++)
845 for (i = 0; i <= hend; i++)
859 wplt = pixGetWpl(pixt);
860 wpld = pixGetWpl(pixd);
861 for (i = 0; i < h; i++) {
862 linet = datat + i * wplt;
863 lined = datad + i * wpld;
864 for (j = 0; j < w; j++) {
866 hval = (pixel >> L_RED_SHIFT) & 0xff;
867 vval = (pixel >> L_BLUE_SHIFT) & 0xff;
868 if (hlut[hval] == 1 && vlut[vval] == 1) {
914 l_int32 i, j, w, h, wplt, wpld, sval, vval, sstart, send, vstart, vend;
915 l_int32 *slut, *vlut;
917 l_uint32 *datat, *datad, *linet, *lined;
920 PROCNAME(
"pixMakeRangeMaskSV");
922 if (!pixs || pixGetDepth(pixs) != 32)
923 return (
PIX *)ERROR_PTR(
"pixs undefined or not 32 bpp", procName, NULL);
925 return (
PIX *)ERROR_PTR(
"invalid regionflag", procName, NULL);
930 slut = (l_int32 *)LEPT_CALLOC(256,
sizeof(l_int32));
931 vlut = (l_int32 *)LEPT_CALLOC(256,
sizeof(l_int32));
932 sstart = L_MAX(0, satcenter - sathw);
933 send = L_MIN(255, satcenter + sathw);
934 vstart = L_MAX(0, valcenter - valhw);
935 vend = L_MIN(255, valcenter + valhw);
936 for (i = sstart; i <= send; i++)
938 for (i = vstart; i <= vend; i++)
951 wplt = pixGetWpl(pixt);
952 wpld = pixGetWpl(pixd);
953 for (i = 0; i < h; i++) {
954 linet = datat + i * wplt;
955 lined = datad + i * wpld;
956 for (j = 0; j < w; j++) {
958 sval = (pixel >> L_GREEN_SHIFT) & 0xff;
959 vval = (pixel >> L_BLUE_SHIFT) & 0xff;
960 if (slut[sval] == 1 && vlut[vval] == 1) {
1001 l_int32 i, j, w, h, wplt, hval, sval, nd;
1003 l_uint32 *datat, *linet;
1005 NUMA *nahue, *nasat;
1008 PROCNAME(
"pixMakeHistoHS");
1010 if (pnahue) *pnahue = NULL;
1011 if (pnasat) *pnasat = NULL;
1012 if (!pixs || pixGetDepth(pixs) != 32)
1013 return (
PIX *)ERROR_PTR(
"pixs undefined or not 32 bpp", procName, NULL);
1030 1.0 / (l_float32)factor);
1037 wplt = pixGetWpl(pixt);
1038 for (i = 0; i < h; i++) {
1039 linet = datat + i * wplt;
1040 for (j = 0; j < w; j++) {
1042 hval = (pixel >> L_RED_SHIFT) & 0xff;
1046 lept_stderr(
"hval = %d for (%d,%d)\n", hval, i, j);
1051 sval = (pixel >> L_GREEN_SHIFT) & 0xff;
1092 l_int32 i, j, w, h, wplt, hval, vval, nd;
1094 l_uint32 *datat, *linet;
1096 NUMA *nahue, *naval;
1099 PROCNAME(
"pixMakeHistoHV");
1101 if (pnahue) *pnahue = NULL;
1102 if (pnaval) *pnaval = NULL;
1103 if (!pixs || pixGetDepth(pixs) != 32)
1104 return (
PIX *)ERROR_PTR(
"pixs undefined or not 32 bpp", procName, NULL);
1121 1.0 / (l_float32)factor);
1128 wplt = pixGetWpl(pixt);
1129 for (i = 0; i < h; i++) {
1130 linet = datat + i * wplt;
1131 for (j = 0; j < w; j++) {
1133 hval = (pixel >> L_RED_SHIFT) & 0xff;
1134 vval = (pixel >> L_BLUE_SHIFT) & 0xff;
1175 l_int32 i, j, w, h, wplt, sval, vval, nd;
1177 l_uint32 *datat, *linet;
1179 NUMA *nasat, *naval;
1182 PROCNAME(
"pixMakeHistoSV");
1184 if (pnasat) *pnasat = NULL;
1185 if (pnaval) *pnaval = NULL;
1186 if (!pixs || pixGetDepth(pixs) != 32)
1187 return (
PIX *)ERROR_PTR(
"pixs undefined or not 32 bpp", procName, NULL);
1204 1.0 / (l_float32)factor);
1211 wplt = pixGetWpl(pixt);
1212 for (i = 0; i < h; i++) {
1213 linet = datat + i * wplt;
1214 for (j = 0; j < w; j++) {
1216 sval = (pixel >> L_GREEN_SHIFT) & 0xff;
1217 vval = (pixel >> L_BLUE_SHIFT) & 0xff;
1266 l_float32 erasefactor,
1271 l_int32 i, xmax, ymax, ewidth, eheight;
1275 PIX *pixh, *pixw, *pix1, *pix2, *pix3;
1278 PROCNAME(
"pixFindHistoPeaksHSV");
1280 if (ppixa) *ppixa = NULL;
1281 if (ppta) *ppta = NULL;
1282 if (pnatot) *pnatot = NULL;
1283 if (!pixs || pixGetDepth(pixs) != 32)
1284 return ERROR_INT(
"pixs undefined or not 32 bpp", procName, 1);
1285 if (!ppta || !pnatot)
1286 return ERROR_INT(
"&pta and &natot not both defined", procName, 1);
1288 return ERROR_INT(
"invalid HSV histo type", procName, 1);
1291 return ERROR_INT(
"pta not made", procName, 1);
1294 return ERROR_INT(
"natot not made", procName, 1);
1316 for (i = 0; i < npeaks; i++) {
1318 if (maxval == 0)
break;
1321 ewidth = (l_int32)(width * erasefactor);
1322 eheight = (l_int32)(height * erasefactor);
1323 box =
boxCreate(xmax - ewidth, ymax - eheight, 2 * ewidth + 1,
1345 if (ymax - eheight < 0) {
1346 box =
boxCreate(xmax - ewidth, 240 + ymax - eheight,
1347 2 * ewidth + 1, eheight - ymax);
1348 }
else if (ymax + eheight > 239) {
1349 box =
boxCreate(xmax - ewidth, 0, 2 * ewidth + 1,
1350 ymax + eheight - 239);
1393 l_int32 i, j, w, huedelta, satdelta, hue, sat, rval, gval, bval;
1396 PROCNAME(
"displayHSVColorRange");
1398 if (hval < 0 || hval > 240)
1399 return (
PIX *)ERROR_PTR(
"invalid hval", procName, NULL);
1400 if (huehw < 5 || huehw > 120)
1401 return (
PIX *)ERROR_PTR(
"invalid huehw", procName, NULL);
1402 if (sval - sathw < 0 || sval + sathw > 255)
1403 return (
PIX *)ERROR_PTR(
"invalid sval/sathw", procName, NULL);
1404 if (nsamp < 1 || factor < 3)
1405 return (
PIX *)ERROR_PTR(
"invalid nsamp or rep. factor", procName, NULL);
1406 if (vval < 0 || vval > 255)
1407 return (
PIX *)ERROR_PTR(
"invalid vval", procName, NULL);
1409 w = (2 * nsamp + 1);
1410 huedelta = (l_int32)((l_float32)huehw / (l_float32)nsamp);
1411 satdelta = (l_int32)((l_float32)sathw / (l_float32)nsamp);
1413 for (i = 0; i < w; i++) {
1414 hue = hval + huedelta * (i - nsamp);
1415 if (hue < 0) hue += 240;
1416 if (hue >= 240) hue -= 240;
1417 for (j = 0; j < w; j++) {
1418 sat = sval + satdelta * (j - nsamp);
1464 l_int32 w, h, d, wpl, i, j, rval, gval, bval, yval, uval, vval;
1465 l_uint32 *line, *data;
1468 PROCNAME(
"pixConvertRGBToYUV");
1471 return (
PIX *)ERROR_PTR(
"pixs not defined", procName, pixd);
1472 if (pixd && pixd != pixs)
1473 return (
PIX *)ERROR_PTR(
"pixd defined and not inplace", procName, pixd);
1475 d = pixGetDepth(pixs);
1476 cmap = pixGetColormap(pixs);
1477 if (!cmap && d != 32)
1478 return (
PIX *)ERROR_PTR(
"not cmapped or rgb", procName, pixd);
1483 cmap = pixGetColormap(pixd);
1491 wpl = pixGetWpl(pixd);
1493 for (i = 0; i < h; i++) {
1494 line = data + i * wpl;
1495 for (j = 0; j < w; j++) {
1498 line[j] = (yval << 24) | (uval << 16) | (vval << 8);
1527 l_int32 w, h, d, wpl, i, j, rval, gval, bval, yval, uval, vval;
1529 l_uint32 *line, *data;
1532 PROCNAME(
"pixConvertYUVToRGB");
1535 return (
PIX *)ERROR_PTR(
"pixs not defined", procName, pixd);
1536 if (pixd && pixd != pixs)
1537 return (
PIX *)ERROR_PTR(
"pixd defined and not inplace", procName, pixd);
1539 d = pixGetDepth(pixs);
1540 cmap = pixGetColormap(pixs);
1541 if (!cmap && d != 32)
1542 return (
PIX *)ERROR_PTR(
"not cmapped or hsv", procName, pixd);
1547 cmap = pixGetColormap(pixd);
1555 wpl = pixGetWpl(pixd);
1557 for (i = 0; i < h; i++) {
1558 line = data + i * wpl;
1559 for (j = 0; j < w; j++) {
1562 uval = (pixel >> 16) & 0xff;
1563 vval = (pixel >> 8) & 0xff;
1598 PROCNAME(
"convertRGBToYUV");
1600 if (pyval) *pyval = 0;
1601 if (puval) *puval = 0;
1602 if (pvval) *pvval = 0;
1603 if (!pyval || !puval || !pvval)
1604 return ERROR_INT(
"&yval, &uval, &vval not all defined", procName, 1);
1607 *pyval = (l_int32)(16.0 +
1608 norm * (65.738 * rval + 129.057 * gval + 25.064 * bval) + 0.5);
1609 *puval = (l_int32)(128.0 +
1610 norm * (-37.945 * rval -74.494 * gval + 112.439 * bval) + 0.5);
1611 *pvval = (l_int32)(128.0 +
1612 norm * (112.439 * rval - 94.154 * gval - 18.285 * bval) + 0.5);
1644 l_int32 rval, gval, bval;
1645 l_float32 norm, ym, um, vm;
1647 PROCNAME(
"convertYUVToRGB");
1649 if (prval) *prval = 0;
1650 if (pgval) *pgval = 0;
1651 if (pbval) *pbval = 0;
1652 if (!prval || !pgval || !pbval)
1653 return ERROR_INT(
"&rval, &gval, &bval not all defined", procName, 1);
1659 rval = (l_int32)(norm * (298.082 * ym + 408.583 * vm) + 0.5);
1660 gval = (l_int32)(norm * (298.082 * ym - 100.291 * um - 208.120 * vm) +
1662 bval = (l_int32)(norm * (298.082 * ym + 516.411 * um) + 0.5);
1663 *prval = L_MIN(255, L_MAX(0, rval));
1664 *pgval = L_MIN(255, L_MAX(0, gval));
1665 *pbval = L_MIN(255, L_MAX(0, bval));
1687 l_int32 i, ncolors, rval, gval, bval, yval, uval, vval;
1689 PROCNAME(
"pixcmapConvertRGBToYUV");
1692 return ERROR_INT(
"cmap not defined", procName, 1);
1695 for (i = 0; i < ncolors; i++) {
1720 l_int32 i, ncolors, rval, gval, bval, yval, uval, vval;
1722 PROCNAME(
"pixcmapConvertYUVToRGB");
1725 return ERROR_INT(
"cmap not defined", procName, 1);
1728 for (i = 0; i < ncolors; i++) {
1771 l_int32 w, h, wpls, wpld, i, j, rval, gval, bval;
1772 l_uint32 *lines, *datas;
1773 l_float32 fxval, fyval, fzval;
1774 l_float32 *linex, *liney, *linez, *datax, *datay, *dataz;
1778 PROCNAME(
"pixConvertRGBToXYZ");
1780 if (!pixs || pixGetDepth(pixs) != 32)
1781 return (
FPIXA *)ERROR_PTR(
"pixs undefined or not rgb", procName, NULL);
1786 for (i = 0; i < 3; i++) {
1790 wpls = pixGetWpl(pixs);
1796 for (i = 0; i < h; i++) {
1797 lines = datas + i * wpls;
1798 linex = datax + i * wpld;
1799 liney = datay + i * wpld;
1800 linez = dataz + i * wpld;
1801 for (j = 0; j < w; j++) {
1804 *(linex + j) = fxval;
1805 *(liney + j) = fyval;
1806 *(linez + j) = fzval;
1830 l_int32 w, h, wpls, wpld, i, j, rval, gval, bval;
1831 l_float32 fxval, fyval, fzval;
1832 l_float32 *linex, *liney, *linez, *datax, *datay, *dataz;
1833 l_uint32 *lined, *datad;
1837 PROCNAME(
"fpixaConvertXYZToRGB");
1840 return (
PIX *)ERROR_PTR(
"fpixa undefined or invalid", procName, NULL);
1844 return (
PIX *)ERROR_PTR(
"fpixa dimensions not found", procName, NULL);
1846 wpld = pixGetWpl(pixd);
1854 for (i = 0; i < h; i++) {
1855 linex = datax + i * wpls;
1856 liney = datay + i * wpls;
1857 linez = dataz + i * wpls;
1858 lined = datad + i * wpld;
1859 for (j = 0; j < w; j++) {
1893 PROCNAME(
"convertRGBToXYZ");
1895 if (pfxval) *pfxval = 0.0;
1896 if (pfyval) *pfyval = 0.0;
1897 if (pfzval) *pfzval = 0.0;
1898 if (!pfxval || !pfyval || !pfzval)
1899 return ERROR_INT(
"&xval, &yval, &zval not all defined", procName, 1);
1901 *pfxval = 0.4125 * rval + 0.3576 * gval + 0.1804 * bval;
1902 *pfyval = 0.2127 * rval + 0.7152 * gval + 0.0722 * bval;
1903 *pfzval = 0.0193 * rval + 0.1192 * gval + 0.9502 * bval;
1936 l_int32 rval, gval, bval;
1938 PROCNAME(
"convertXYZToRGB");
1940 if (prval) *prval = 0;
1941 if (pgval) *pgval = 0;
1942 if (pbval) *pbval = 0;
1943 if (!prval || !pgval ||!pbval)
1944 return ERROR_INT(
"&rval, &gval, &bval not all defined", procName, 1);
1945 *prval = *pgval = *pbval = 0;
1947 rval = (l_int32)(3.2405 * fxval - 1.5372 * fyval - 0.4985 * fzval + 0.5);
1948 gval = (l_int32)(-0.9693 * fxval + 1.8760 * fyval + 0.0416 * fzval + 0.5);
1949 bval = (l_int32)(0.0556 * fxval - 0.2040 * fyval + 1.0573 * fzval + 0.5);
1950 if (blackout == 0) {
1951 *prval = L_MAX(0, L_MIN(rval, 255));
1952 *pgval = L_MAX(0, L_MIN(gval, 255));
1953 *pbval = L_MAX(0, L_MIN(bval, 255));
1955 if (rval >= 0 && rval < 256 && gval >= 0 && gval < 256 &&
1956 bval >= 0 && bval < 256) {
1991 l_int32 w, h, wpl, i, j;
1992 l_float32 fxval, fyval, fzval, flval, faval, fbval;
1993 l_float32 *linex, *liney, *linez, *datax, *datay, *dataz;
1994 l_float32 *linel, *linea, *lineb, *datal, *dataa, *datab;
1998 PROCNAME(
"fpixaConvertXYZToLAB");
2001 return (
FPIXA *)ERROR_PTR(
"fpixas undefined/invalid", procName, NULL);
2005 return (
FPIXA *)ERROR_PTR(
"fpixas sizes not found", procName, NULL);
2007 for (i = 0; i < 3; i++) {
2020 for (i = 0; i < h; i++) {
2021 linex = datax + i * wpl;
2022 liney = datay + i * wpl;
2023 linez = dataz + i * wpl;
2024 linel = datal + i * wpl;
2025 linea = dataa + i * wpl;
2026 lineb = datab + i * wpl;
2027 for (j = 0; j < w; j++) {
2028 fxval = *(linex + j);
2029 fyval = *(liney + j);
2030 fzval = *(linez + j);
2032 *(linel + j) = flval;
2033 *(linea + j) = faval;
2034 *(lineb + j) = fbval;
2057 l_int32 w, h, wpl, i, j;
2058 l_float32 fxval, fyval, fzval, flval, faval, fbval;
2059 l_float32 *linel, *linea, *lineb, *datal, *dataa, *datab;
2060 l_float32 *linex, *liney, *linez, *datax, *datay, *dataz;
2064 PROCNAME(
"fpixaConvertLABToXYZ");
2067 return (
FPIXA *)ERROR_PTR(
"fpixas undefined/invalid", procName, NULL);
2071 return (
FPIXA *)ERROR_PTR(
"fpixas sizes not found", procName, NULL);
2073 for (i = 0; i < 3; i++) {
2086 for (i = 0; i < h; i++) {
2087 linel = datal + i * wpl;
2088 linea = dataa + i * wpl;
2089 lineb = datab + i * wpl;
2090 linex = datax + i * wpl;
2091 liney = datay + i * wpl;
2092 linez = dataz + i * wpl;
2093 for (j = 0; j < w; j++) {
2094 flval = *(linel + j);
2095 faval = *(linea + j);
2096 fbval = *(lineb + j);
2098 *(linex + j) = fxval;
2099 *(liney + j) = fyval;
2100 *(linez + j) = fzval;
2123 l_float32 xn, yn, zn, fx, fy, fz;
2125 PROCNAME(
"convertXYZToLAB");
2127 if (plval) *plval = 0.0;
2128 if (paval) *paval = 0.0;
2129 if (pbval) *pbval = 0.0;
2130 if (!plval || !paval || !pbval)
2131 return ERROR_INT(
"&lval, &aval, &bval not all defined", procName, 1);
2134 xn = 0.0041259 * xval;
2135 yn = 0.0039216 * yval;
2136 zn = 0.0036012 * zval;
2138 fx = lab_forward(xn);
2139 fy = lab_forward(yn);
2140 fz = lab_forward(zn);
2141 *plval = 116.0 * fy - 16.0;
2142 *paval = 500.0 * (fx - fy);
2143 *pbval = 200.0 * (fy - fz);
2163 l_float32 fx, fy, fz;
2164 l_float32 xw = 242.37;
2165 l_float32 yw = 255.0;
2166 l_float32 zw = 277.69;
2168 PROCNAME(
"convertLABToXYZ");
2170 if (pxval) *pxval = 0.0;
2171 if (pyval) *pyval = 0.0;
2172 if (pzval) *pzval = 0.0;
2173 if (!pxval || !pyval || !pzval)
2174 return ERROR_INT(
"&xval, &yval, &zval not all defined", procName, 1);
2176 fy = 0.0086207 * (16.0 + lval);
2177 fx = fy + 0.002 * aval;
2178 fz = fy - 0.005 * bval;
2179 *pxval = xw * lab_reverse(fx);
2180 *pyval = yw * lab_reverse(fy);
2181 *pzval = zw * lab_reverse(fz);
2194 lab_forward(l_float32 v)
2196 const l_float32 f_thresh = 0.008856;
2197 const l_float32 f_factor = 7.787;
2198 const l_float32 f_offset = 0.13793;
2202 return powf(v, 0.333333);
2205 num = 4.37089e-04 + v * (9.52695e-02 + v * (1.25201 + v * 1.30273));
2206 den = 3.91236e-03 + v * (2.95408e-01 + v * (1.71714 + v * 6.34341e-01));
2210 return f_factor * v + f_offset;
2220 lab_reverse(l_float32 v)
2222 const l_float32 r_thresh = 0.20690;
2223 const l_float32 r_factor = 0.12842;
2224 const l_float32 r_offset = 0.13793;
2229 return r_factor * (v - r_offset);
2252 l_int32 w, h, wpls, wpld, i, j, rval, gval, bval;
2253 l_uint32 *lines, *datas;
2254 l_float32 flval, faval, fbval;
2255 l_float32 *linel, *linea, *lineb, *datal, *dataa, *datab;
2259 PROCNAME(
"pixConvertRGBToLAB");
2261 if (!pixs || pixGetDepth(pixs) != 32)
2262 return (
FPIXA *)ERROR_PTR(
"pixs undefined or not rgb", procName, NULL);
2267 for (i = 0; i < 3; i++) {
2271 wpls = pixGetWpl(pixs);
2277 for (i = 0; i < h; i++) {
2278 lines = datas + i * wpls;
2279 linel = datal + i * wpld;
2280 linea = dataa + i * wpld;
2281 lineb = datab + i * wpld;
2282 for (j = 0; j < w; j++) {
2285 *(linel + j) = flval;
2286 *(linea + j) = faval;
2287 *(lineb + j) = fbval;
2309 l_int32 w, h, wpls, wpld, i, j, rval, gval, bval;
2310 l_float32 flval, faval, fbval;
2311 l_float32 *linel, *linea, *lineb, *datal, *dataa, *datab;
2312 l_uint32 *lined, *datad;
2316 PROCNAME(
"fpixaConvertLABToRGB");
2319 return (
PIX *)ERROR_PTR(
"fpixa undefined or invalid", procName, NULL);
2323 return (
PIX *)ERROR_PTR(
"fpixa dimensions not found", procName, NULL);
2325 wpld = pixGetWpl(pixd);
2333 for (i = 0; i < h; i++) {
2334 linel = datal + i * wpls;
2335 linea = dataa + i * wpls;
2336 lineb = datab + i * wpls;
2337 lined = datad + i * wpld;
2338 for (j = 0; j < w; j++) {
2372 l_float32 fxval, fyval, fzval;
2374 PROCNAME(
"convertRGBToLAB");
2376 if (pflval) *pflval = 0.0;
2377 if (pfaval) *pfaval = 0.0;
2378 if (pfbval) *pfbval = 0.0;
2379 if (!pflval || !pfaval || !pfbval)
2380 return ERROR_INT(
"&flval, &faval, &fbval not all defined", procName, 1);
2409 l_float32 fxval, fyval, fzval;
2411 PROCNAME(
"convertLABToRGB");
2413 if (prval) *prval = 0;
2414 if (pgval) *pgval = 0;
2415 if (pbval) *pbval = 0;
2416 if (!prval || !pgval || !pbval)
2417 return ERROR_INT(
"&rval, &gval, &bval not all defined", procName, 1);
2455 if (scale <= 0) scale = 8;
2458 for (k = 0; k < 32; k++) {
2460 for (i = 0; i < 32; i++) {
2461 for (j = 0; j < 32; j++) {
#define SET_DATA_BIT(pdata, n)
#define SET_DATA_FOUR_BYTES(pdata, n, val)
#define GET_DATA_FOUR_BYTES(pdata, n)
#define SET_DATA_BYTE(pdata, n, val)
#define CLEAR_DATA_BIT(pdata, n)
void boxDestroy(BOX **pbox)
boxDestroy()
BOX * boxCreate(l_int32 x, l_int32 y, l_int32 w, l_int32 h)
boxCreate()
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 pixcmapGetColor(PIXCMAP *cmap, l_int32 index, l_int32 *prval, l_int32 *pgval, l_int32 *pbval)
pixcmapGetColor()
PIX * fpixaConvertXYZToRGB(FPIXA *fpixa)
fpixaConvertXYZToRGB()
l_ok pixFindHistoPeaksHSV(PIX *pixs, l_int32 type, l_int32 width, l_int32 height, l_int32 npeaks, l_float32 erasefactor, PTA **ppta, NUMA **pnatot, PIXA **ppixa)
pixFindHistoPeaksHSV()
PIX * pixMakeRangeMaskHV(PIX *pixs, l_int32 huecenter, l_int32 huehw, l_int32 valcenter, l_int32 valhw, l_int32 regionflag)
pixMakeRangeMaskHV()
l_ok convertLABToRGB(l_float32 flval, l_float32 faval, l_float32 fbval, l_int32 *prval, l_int32 *pgval, l_int32 *pbval)
convertLABToRGB()
PIX * pixConvertRGBToHSV(PIX *pixd, PIX *pixs)
pixConvertRGBToHSV()
FPIXA * fpixaConvertXYZToLAB(FPIXA *fpixas)
fpixaConvertXYZToLAB()
l_ok convertXYZToRGB(l_float32 fxval, l_float32 fyval, l_float32 fzval, l_int32 blackout, l_int32 *prval, l_int32 *pgval, l_int32 *pbval)
convertXYZToRGB()
FPIXA * fpixaConvertLABToXYZ(FPIXA *fpixas)
fpixaConvertLABToXYZ()
FPIXA * pixConvertRGBToLAB(PIX *pixs)
pixConvertRGBToLAB()
PIX * pixConvertRGBToValue(PIX *pixs)
pixConvertRGBToValue()
PIX * displayHSVColorRange(l_int32 hval, l_int32 sval, l_int32 vval, l_int32 huehw, l_int32 sathw, l_int32 nsamp, l_int32 factor)
displayHSVColorRange()
l_ok convertHSVToRGB(l_int32 hval, l_int32 sval, l_int32 vval, l_int32 *prval, l_int32 *pgval, l_int32 *pbval)
convertHSVToRGB()
PIX * pixConvertRGBToHue(PIX *pixs)
pixConvertRGBToHue()
PIX * pixMakeHistoHV(PIX *pixs, l_int32 factor, NUMA **pnahue, NUMA **pnaval)
pixMakeHistoHV()
l_ok convertRGBToHSV(l_int32 rval, l_int32 gval, l_int32 bval, l_int32 *phval, l_int32 *psval, l_int32 *pvval)
convertRGBToHSV()
l_ok pixcmapConvertHSVToRGB(PIXCMAP *cmap)
pixcmapConvertHSVToRGB()
l_ok pixcmapConvertRGBToHSV(PIXCMAP *cmap)
pixcmapConvertRGBToHSV()
PIX * pixConvertYUVToRGB(PIX *pixd, PIX *pixs)
pixConvertYUVToRGB()
l_ok convertRGBToYUV(l_int32 rval, l_int32 gval, l_int32 bval, l_int32 *pyval, l_int32 *puval, l_int32 *pvval)
convertRGBToYUV()
PIX * pixMakeGamutRGB(l_int32 scale)
pixMakeGamutRGB()
PIX * fpixaConvertLABToRGB(FPIXA *fpixa)
fpixaConvertLABToRGB()
l_ok pixcmapConvertRGBToYUV(PIXCMAP *cmap)
pixcmapConvertRGBToYUV()
l_ok convertLABToXYZ(l_float32 lval, l_float32 aval, l_float32 bval, l_float32 *pxval, l_float32 *pyval, l_float32 *pzval)
convertLABToXYZ()
l_ok convertXYZToLAB(l_float32 xval, l_float32 yval, l_float32 zval, l_float32 *plval, l_float32 *paval, l_float32 *pbval)
convertXYZToLAB()
FPIXA * pixConvertRGBToXYZ(PIX *pixs)
pixConvertRGBToXYZ()
PIX * pixConvertHSVToRGB(PIX *pixd, PIX *pixs)
pixConvertHSVToRGB()
PIX * pixMakeRangeMaskHS(PIX *pixs, l_int32 huecenter, l_int32 huehw, l_int32 satcenter, l_int32 sathw, l_int32 regionflag)
pixMakeRangeMaskHS()
PIX * pixMakeRangeMaskSV(PIX *pixs, l_int32 satcenter, l_int32 sathw, l_int32 valcenter, l_int32 valhw, l_int32 regionflag)
pixMakeRangeMaskSV()
l_ok convertRGBToLAB(l_int32 rval, l_int32 gval, l_int32 bval, l_float32 *pflval, l_float32 *pfaval, l_float32 *pfbval)
convertRGBToLAB()
PIX * pixConvertRGBToYUV(PIX *pixd, PIX *pixs)
pixConvertRGBToYUV()
PIX * pixMakeHistoHS(PIX *pixs, l_int32 factor, NUMA **pnahue, NUMA **pnasat)
pixMakeHistoHS()
l_ok convertYUVToRGB(l_int32 yval, l_int32 uval, l_int32 vval, l_int32 *prval, l_int32 *pgval, l_int32 *pbval)
convertYUVToRGB()
l_ok convertRGBToXYZ(l_int32 rval, l_int32 gval, l_int32 bval, l_float32 *pfxval, l_float32 *pfyval, l_float32 *pfzval)
convertRGBToXYZ()
l_ok pixcmapConvertYUVToRGB(PIXCMAP *cmap)
pixcmapConvertYUVToRGB()
PIX * pixConvertRGBToSaturation(PIX *pixs)
pixConvertRGBToSaturation()
PIX * pixMakeHistoSV(PIX *pixs, l_int32 factor, NUMA **pnasat, NUMA **pnaval)
pixMakeHistoSV()
PIX * pixWindowedMean(PIX *pixs, l_int32 wc, l_int32 hc, l_int32 hasborder, l_int32 normflag)
pixWindowedMean()
l_ok fpixaAddFPix(FPIXA *fpixa, FPIX *fpix, l_int32 copyflag)
fpixaAddFPix()
l_float32 * fpixaGetData(FPIXA *fpixa, l_int32 index)
fpixaGetData()
FPIX * fpixaGetFPix(FPIXA *fpixa, l_int32 index, l_int32 accesstype)
fpixaGetFPix()
l_int32 fpixGetWpl(FPIX *fpix)
fpixGetWpl()
FPIXA * fpixaCreate(l_int32 n)
fpixaCreate()
void fpixDestroy(FPIX **pfpix)
fpixDestroy()
l_int32 fpixaGetCount(FPIXA *fpixa)
fpixaGetCount()
FPIX * fpixCreate(l_int32 width, l_int32 height)
fpixCreate()
l_ok fpixaGetFPixDimensions(FPIXA *fpixa, l_int32 index, l_int32 *pw, l_int32 *ph)
fpixaGetFPixDimensions()
l_ok pixRenderHashBoxArb(PIX *pix, BOX *box, l_int32 spacing, l_int32 width, l_int32 orient, l_int32 outline, l_int32 rval, l_int32 gval, l_int32 bval)
pixRenderHashBoxArb()
l_ok numaAddNumber(NUMA *na, l_float32 val)
numaAddNumber()
NUMA * numaCreate(l_int32 n)
numaCreate()
l_ok numaSetCount(NUMA *na, l_int32 newcount)
numaSetCount()
l_ok numaShiftValue(NUMA *na, l_int32 index, l_float32 diff)
numaShiftValue()
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 * pixCreate(l_int32 width, l_int32 height, l_int32 depth)
pixCreate()
PIX * pixClone(PIX *pixs)
pixClone()
void ** pixGetLinePtrs(PIX *pix, l_int32 *psize)
pixGetLinePtrs()
l_ok pixSetPixel(PIX *pix, l_int32 x, l_int32 y, l_uint32 val)
pixSetPixel()
l_ok pixClearAll(PIX *pix)
pixClearAll()
l_ok pixClearInRect(PIX *pix, BOX *box)
pixClearInRect()
l_ok pixSetAll(PIX *pix)
pixSetAll()
PIX * pixAddMixedBorder(PIX *pixs, l_int32 left, l_int32 right, l_int32 top, l_int32 bot)
pixAddMixedBorder()
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 pixSetRGBPixel(PIX *pix, l_int32 x, l_int32 y, l_int32 rval, l_int32 gval, l_int32 bval)
pixSetRGBPixel()
PIX * pixAddMirroredBorder(PIX *pixs, l_int32 left, l_int32 right, l_int32 top, l_int32 bot)
pixAddMirroredBorder()
l_ok pixGetMaxValueInRect(PIX *pixs, BOX *box, l_uint32 *pmaxval, l_int32 *pxmax, l_int32 *pymax)
pixGetMaxValueInRect()
@ REMOVE_CMAP_TO_FULL_COLOR
l_ok pixaAddPix(PIXA *pixa, PIX *pix, l_int32 copyflag)
pixaAddPix()
void pixaDestroy(PIXA **ppixa)
pixaDestroy()
PIXA * pixaCreate(l_int32 n)
pixaCreate()
PIX * pixaDisplayTiledInColumns(PIXA *pixas, l_int32 nx, l_float32 scalefactor, l_int32 spacing, l_int32 border)
pixaDisplayTiledInColumns()
PIX * pixMaxDynamicRange(PIX *pixs, l_int32 type)
pixMaxDynamicRange()
PIX * pixRemoveColormap(PIX *pixs, l_int32 type)
pixRemoveColormap()
PIX * pixConvertGrayToFalseColor(PIX *pixs, l_float32 gamma)
pixConvertGrayToFalseColor()
PIX * pixConvertTo32(PIX *pixs)
pixConvertTo32()
l_ok ptaAddPt(PTA *pta, l_float32 x, l_float32 y)
ptaAddPt()
PTA * ptaCreate(l_int32 n)
ptaCreate()
PIX * pixScaleBySampling(PIX *pixs, l_float32 scalex, l_float32 scaley)
pixScaleBySampling()
PIX * pixExpandReplicate(PIX *pixs, l_int32 factor)
pixExpandReplicate()
void lept_stderr(const char *fmt,...)
lept_stderr()