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;
150 return (
PIX *)ERROR_PTR(
"pixs not defined", __func__, pixd);
151 if (pixd && pixd != pixs)
152 return (
PIX *)ERROR_PTR(
"pixd defined and not inplace", __func__, pixd);
154 d = pixGetDepth(pixs);
155 cmap = pixGetColormap(pixs);
156 if (!cmap && d != 32)
157 return (
PIX *)ERROR_PTR(
"not cmapped or rgb", __func__, pixd);
162 cmap = pixGetColormap(pixd);
170 wpl = pixGetWpl(pixd);
172 for (i = 0; i < h; i++) {
173 line = data + i * wpl;
174 for (j = 0; j < w; j++) {
177 line[j] = (hval << 24) | (sval << 16) | (vval << 8);
207 l_int32 w, h, d, wpl, i, j, rval, gval, bval, hval, sval, vval;
209 l_uint32 *line, *data;
213 return (
PIX *)ERROR_PTR(
"pixs not defined", __func__, pixd);
214 if (pixd && pixd != pixs)
215 return (
PIX *)ERROR_PTR(
"pixd defined and not inplace", __func__, pixd);
217 d = pixGetDepth(pixs);
218 cmap = pixGetColormap(pixs);
219 if (!cmap && d != 32)
220 return (
PIX *)ERROR_PTR(
"not cmapped or hsv", __func__, pixd);
225 cmap = pixGetColormap(pixd);
233 wpl = pixGetWpl(pixd);
235 for (i = 0; i < h; i++) {
236 line = data + i * wpl;
237 for (j = 0; j < w; j++) {
240 sval = (pixel >> 16) & 0xff;
241 vval = (pixel >> 8) & 0xff;
284 l_int32 minrg, maxrg, min, max, delta;
287 if (phval) *phval = 0;
288 if (psval) *psval = 0;
289 if (pvval) *pvval = 0;
290 if (!phval || !psval || !pvval)
291 return ERROR_INT(
"&hval, &sval, &vval not all defined", __func__, 1);
293 minrg = L_MIN(rval, gval);
294 min = L_MIN(minrg, bval);
295 maxrg = L_MAX(rval, gval);
296 max = L_MAX(maxrg, bval);
304 *psval = (l_int32)(255. * (l_float32)delta / (l_float32)max + 0.5);
306 h = (l_float32)(gval - bval) / (l_float32)delta;
307 else if (gval == max)
308 h = 2. + (l_float32)(bval - rval) / (l_float32)delta;
310 h = 4. + (l_float32)(rval - gval) / (l_float32)delta;
316 *phval = (l_int32)(h + 0.5);
347 if (prval) *prval = 0;
348 if (pgval) *pgval = 0;
349 if (pbval) *pbval = 0;
350 if (!prval || !pgval || !pbval)
351 return ERROR_INT(
"&rval, &gval, &bval not all defined", __func__, 1);
358 if (hval < 0 || hval > 240)
359 return ERROR_INT(
"invalid hval", __func__, 1);
362 h = (l_float32)hval / 40.;
365 s = (l_float32)sval / 255.;
366 x = (l_int32)(vval * (1. - s) + 0.5);
367 y = (l_int32)(vval * (1. - s * f) + 0.5);
368 z = (l_int32)(vval * (1. - s * (1. - f)) + 0.5);
426 l_int32 i, ncolors, rval, gval, bval, hval, sval, vval;
429 return ERROR_INT(
"cmap not defined", __func__, 1);
432 for (i = 0; i < ncolors; i++) {
457 l_int32 i, ncolors, rval, gval, bval, hval, sval, vval;
460 return ERROR_INT(
"cmap not defined", __func__, 1);
463 for (i = 0; i < ncolors; i++) {
490 l_int32 w, h, d, wplt, wpld;
491 l_int32 i, j, rval, gval, bval, hval, minrg, min, maxrg, max, delta;
494 l_uint32 *linet, *lined, *datat, *datad;
498 return (
PIX *)ERROR_PTR(
"pixs not defined", __func__, NULL);
501 if (d != 32 && !pixGetColormap(pixs))
502 return (
PIX *)ERROR_PTR(
"not cmapped or rgb", __func__, NULL);
507 pixCopyResolution(pixd, pixs);
508 wplt = pixGetWpl(pixt);
510 wpld = pixGetWpl(pixd);
512 for (i = 0; i < h; i++) {
513 linet = datat + i * wplt;
514 lined = datad + i * wpld;
515 for (j = 0; j < w; j++) {
518 minrg = L_MIN(rval, gval);
519 min = L_MIN(minrg, bval);
520 maxrg = L_MAX(rval, gval);
521 max = L_MAX(maxrg, bval);
527 fh = (l_float32)(gval - bval) / (l_float32)delta;
528 else if (gval == max)
529 fh = 2. + (l_float32)(bval - rval) / (l_float32)delta;
531 fh = 4. + (l_float32)(rval - gval) / (l_float32)delta;
535 hval = (l_int32)(fh + 0.5);
564 l_int32 w, h, d, wplt, wpld;
565 l_int32 i, j, rval, gval, bval, sval, minrg, min, maxrg, max, delta;
567 l_uint32 *linet, *lined, *datat, *datad;
571 return (
PIX *)ERROR_PTR(
"pixs not defined", __func__, NULL);
574 if (d != 32 && !pixGetColormap(pixs))
575 return (
PIX *)ERROR_PTR(
"not cmapped or rgb", __func__, NULL);
580 pixCopyResolution(pixd, pixs);
581 wplt = pixGetWpl(pixt);
583 wpld = pixGetWpl(pixd);
585 for (i = 0; i < h; i++) {
586 linet = datat + i * wplt;
587 lined = datad + i * wpld;
588 for (j = 0; j < w; j++) {
591 minrg = L_MIN(rval, gval);
592 min = L_MIN(minrg, bval);
593 maxrg = L_MAX(rval, gval);
594 max = L_MAX(maxrg, bval);
599 sval = (l_int32)(255. *
600 (l_float32)delta / (l_float32)max + 0.5);
627 l_int32 w, h, d, wplt, wpld;
628 l_int32 i, j, rval, gval, bval, maxrg, max;
630 l_uint32 *linet, *lined, *datat, *datad;
634 return (
PIX *)ERROR_PTR(
"pixs not defined", __func__, NULL);
637 if (d != 32 && !pixGetColormap(pixs))
638 return (
PIX *)ERROR_PTR(
"not cmapped or rgb", __func__, NULL);
643 pixCopyResolution(pixd, pixs);
644 wplt = pixGetWpl(pixt);
646 wpld = pixGetWpl(pixd);
648 for (i = 0; i < h; i++) {
649 linet = datat + i * wplt;
650 lined = datad + i * wpld;
651 for (j = 0; j < w; j++) {
654 maxrg = L_MAX(rval, gval);
655 max = L_MAX(maxrg, bval);
699 l_int32 i, j, w, h, wplt, wpld, hstart, hend, sstart, send, hval, sval;
700 l_int32 *hlut, *slut;
702 l_uint32 *datat, *datad, *linet, *lined;
705 if (!pixs || pixGetDepth(pixs) != 32)
706 return (
PIX *)ERROR_PTR(
"pixs undefined or not 32 bpp", __func__, NULL);
708 return (
PIX *)ERROR_PTR(
"invalid regionflag", __func__, NULL);
712 hlut = (l_int32 *)LEPT_CALLOC(240,
sizeof(l_int32));
713 slut = (l_int32 *)LEPT_CALLOC(256,
sizeof(l_int32));
714 sstart = L_MAX(0, satcenter - sathw);
715 send = L_MIN(255, satcenter + sathw);
716 for (i = sstart; i <= send; i++)
718 hstart = (huecenter - huehw + 240) % 240;
719 hend = (huecenter + huehw + 240) % 240;
721 for (i = hstart; i <= hend; i++)
724 for (i = hstart; i < 240; i++)
726 for (i = 0; i <= hend; i++)
740 wplt = pixGetWpl(pixt);
741 wpld = pixGetWpl(pixd);
742 for (i = 0; i < h; i++) {
743 linet = datat + i * wplt;
744 lined = datad + i * wpld;
745 for (j = 0; j < w; j++) {
747 hval = (pixel >> L_RED_SHIFT) & 0xff;
748 sval = (pixel >> L_GREEN_SHIFT) & 0xff;
749 if (hlut[hval] == 1 && slut[sval] == 1) {
796 l_int32 i, j, w, h, wplt, wpld, hstart, hend, vstart, vend, hval, vval;
797 l_int32 *hlut, *vlut;
799 l_uint32 *datat, *datad, *linet, *lined;
802 if (!pixs || pixGetDepth(pixs) != 32)
803 return (
PIX *)ERROR_PTR(
"pixs undefined or not 32 bpp", __func__, NULL);
805 return (
PIX *)ERROR_PTR(
"invalid regionflag", __func__, NULL);
809 hlut = (l_int32 *)LEPT_CALLOC(240,
sizeof(l_int32));
810 vlut = (l_int32 *)LEPT_CALLOC(256,
sizeof(l_int32));
811 vstart = L_MAX(0, valcenter - valhw);
812 vend = L_MIN(255, valcenter + valhw);
813 for (i = vstart; i <= vend; i++)
815 hstart = (huecenter - huehw + 240) % 240;
816 hend = (huecenter + huehw + 240) % 240;
818 for (i = hstart; i <= hend; i++)
821 for (i = hstart; i < 240; i++)
823 for (i = 0; i <= hend; i++)
837 wplt = pixGetWpl(pixt);
838 wpld = pixGetWpl(pixd);
839 for (i = 0; i < h; i++) {
840 linet = datat + i * wplt;
841 lined = datad + i * wpld;
842 for (j = 0; j < w; j++) {
844 hval = (pixel >> L_RED_SHIFT) & 0xff;
845 vval = (pixel >> L_BLUE_SHIFT) & 0xff;
846 if (hlut[hval] == 1 && vlut[vval] == 1) {
892 l_int32 i, j, w, h, wplt, wpld, sval, vval, sstart, send, vstart, vend;
893 l_int32 *slut, *vlut;
895 l_uint32 *datat, *datad, *linet, *lined;
898 if (!pixs || pixGetDepth(pixs) != 32)
899 return (
PIX *)ERROR_PTR(
"pixs undefined or not 32 bpp", __func__, NULL);
901 return (
PIX *)ERROR_PTR(
"invalid regionflag", __func__, NULL);
906 slut = (l_int32 *)LEPT_CALLOC(256,
sizeof(l_int32));
907 vlut = (l_int32 *)LEPT_CALLOC(256,
sizeof(l_int32));
908 sstart = L_MAX(0, satcenter - sathw);
909 send = L_MIN(255, satcenter + sathw);
910 vstart = L_MAX(0, valcenter - valhw);
911 vend = L_MIN(255, valcenter + valhw);
912 for (i = sstart; i <= send; i++)
914 for (i = vstart; i <= vend; i++)
927 wplt = pixGetWpl(pixt);
928 wpld = pixGetWpl(pixd);
929 for (i = 0; i < h; i++) {
930 linet = datat + i * wplt;
931 lined = datad + i * wpld;
932 for (j = 0; j < w; j++) {
934 sval = (pixel >> L_GREEN_SHIFT) & 0xff;
935 vval = (pixel >> L_BLUE_SHIFT) & 0xff;
936 if (slut[sval] == 1 && vlut[vval] == 1) {
977 l_int32 i, j, w, h, wplt, hval, sval, nd;
979 l_uint32 *datat, *linet;
984 if (pnahue) *pnahue = NULL;
985 if (pnasat) *pnasat = NULL;
986 if (!pixs || pixGetDepth(pixs) != 32)
987 return (
PIX *)ERROR_PTR(
"pixs undefined or not 32 bpp", __func__, NULL);
1004 1.0 / (l_float32)factor);
1011 wplt = pixGetWpl(pixt);
1012 for (i = 0; i < h; i++) {
1013 linet = datat + i * wplt;
1014 for (j = 0; j < w; j++) {
1016 hval = (pixel >> L_RED_SHIFT) & 0xff;
1020 lept_stderr(
"hval = %d for (%d,%d)\n", hval, i, j);
1025 sval = (pixel >> L_GREEN_SHIFT) & 0xff;
1066 l_int32 i, j, w, h, wplt, hval, vval, nd;
1068 l_uint32 *datat, *linet;
1070 NUMA *nahue, *naval;
1073 if (pnahue) *pnahue = NULL;
1074 if (pnaval) *pnaval = NULL;
1075 if (!pixs || pixGetDepth(pixs) != 32)
1076 return (
PIX *)ERROR_PTR(
"pixs undefined or not 32 bpp", __func__, NULL);
1093 1.0 / (l_float32)factor);
1100 wplt = pixGetWpl(pixt);
1101 for (i = 0; i < h; i++) {
1102 linet = datat + i * wplt;
1103 for (j = 0; j < w; j++) {
1105 hval = (pixel >> L_RED_SHIFT) & 0xff;
1106 vval = (pixel >> L_BLUE_SHIFT) & 0xff;
1147 l_int32 i, j, w, h, wplt, sval, vval, nd;
1149 l_uint32 *datat, *linet;
1151 NUMA *nasat, *naval;
1154 if (pnasat) *pnasat = NULL;
1155 if (pnaval) *pnaval = NULL;
1156 if (!pixs || pixGetDepth(pixs) != 32)
1157 return (
PIX *)ERROR_PTR(
"pixs undefined or not 32 bpp", __func__, NULL);
1174 1.0 / (l_float32)factor);
1181 wplt = pixGetWpl(pixt);
1182 for (i = 0; i < h; i++) {
1183 linet = datat + i * wplt;
1184 for (j = 0; j < w; j++) {
1186 sval = (pixel >> L_GREEN_SHIFT) & 0xff;
1187 vval = (pixel >> L_BLUE_SHIFT) & 0xff;
1236 l_float32 erasefactor,
1241 l_int32 i, xmax, ymax, ewidth, eheight;
1245 PIX *pixh, *pixw, *pix1, *pix2, *pix3;
1248 if (ppixa) *ppixa = NULL;
1249 if (ppta) *ppta = NULL;
1250 if (pnatot) *pnatot = NULL;
1251 if (!pixs || pixGetDepth(pixs) != 32)
1252 return ERROR_INT(
"pixs undefined or not 32 bpp", __func__, 1);
1253 if (!ppta || !pnatot)
1254 return ERROR_INT(
"&pta and &natot not both defined", __func__, 1);
1256 return ERROR_INT(
"invalid HSV histo type", __func__, 1);
1259 return ERROR_INT(
"pta not made", __func__, 1);
1262 return ERROR_INT(
"natot not made", __func__, 1);
1284 for (i = 0; i < npeaks; i++) {
1286 if (maxval == 0)
break;
1289 ewidth = (l_int32)(width * erasefactor);
1290 eheight = (l_int32)(height * erasefactor);
1291 box =
boxCreate(xmax - ewidth, ymax - eheight, 2 * ewidth + 1,
1313 if (ymax - eheight < 0) {
1314 box =
boxCreate(xmax - ewidth, 240 + ymax - eheight,
1315 2 * ewidth + 1, eheight - ymax);
1316 }
else if (ymax + eheight > 239) {
1317 box =
boxCreate(xmax - ewidth, 0, 2 * ewidth + 1,
1318 ymax + eheight - 239);
1361 l_int32 i, j, w, huedelta, satdelta, hue, sat, rval, gval, bval;
1364 if (hval < 0 || hval > 240)
1365 return (
PIX *)ERROR_PTR(
"invalid hval", __func__, NULL);
1366 if (huehw < 5 || huehw > 120)
1367 return (
PIX *)ERROR_PTR(
"invalid huehw", __func__, NULL);
1368 if (sval - sathw < 0 || sval + sathw > 255)
1369 return (
PIX *)ERROR_PTR(
"invalid sval/sathw", __func__, NULL);
1370 if (nsamp < 1 || factor < 3)
1371 return (
PIX *)ERROR_PTR(
"invalid nsamp or rep. factor", __func__, NULL);
1372 if (vval < 0 || vval > 255)
1373 return (
PIX *)ERROR_PTR(
"invalid vval", __func__, NULL);
1375 w = (2 * nsamp + 1);
1376 huedelta = (l_int32)((l_float32)huehw / (l_float32)nsamp);
1377 satdelta = (l_int32)((l_float32)sathw / (l_float32)nsamp);
1379 for (i = 0; i < w; i++) {
1380 hue = hval + huedelta * (i - nsamp);
1381 if (hue < 0) hue += 240;
1382 if (hue >= 240) hue -= 240;
1383 for (j = 0; j < w; j++) {
1384 sat = sval + satdelta * (j - nsamp);
1430 l_int32 w, h, d, wpl, i, j, rval, gval, bval, yval, uval, vval;
1431 l_uint32 *line, *data;
1435 return (
PIX *)ERROR_PTR(
"pixs not defined", __func__, pixd);
1436 if (pixd && pixd != pixs)
1437 return (
PIX *)ERROR_PTR(
"pixd defined and not inplace", __func__, pixd);
1439 d = pixGetDepth(pixs);
1440 cmap = pixGetColormap(pixs);
1441 if (!cmap && d != 32)
1442 return (
PIX *)ERROR_PTR(
"not cmapped or rgb", __func__, pixd);
1447 cmap = pixGetColormap(pixd);
1455 wpl = pixGetWpl(pixd);
1457 for (i = 0; i < h; i++) {
1458 line = data + i * wpl;
1459 for (j = 0; j < w; j++) {
1462 line[j] = (yval << 24) | (uval << 16) | (vval << 8);
1491 l_int32 w, h, d, wpl, i, j, rval, gval, bval, yval, uval, vval;
1493 l_uint32 *line, *data;
1497 return (
PIX *)ERROR_PTR(
"pixs not defined", __func__, pixd);
1498 if (pixd && pixd != pixs)
1499 return (
PIX *)ERROR_PTR(
"pixd defined and not inplace", __func__, pixd);
1501 d = pixGetDepth(pixs);
1502 cmap = pixGetColormap(pixs);
1503 if (!cmap && d != 32)
1504 return (
PIX *)ERROR_PTR(
"not cmapped or hsv", __func__, pixd);
1509 cmap = pixGetColormap(pixd);
1517 wpl = pixGetWpl(pixd);
1519 for (i = 0; i < h; i++) {
1520 line = data + i * wpl;
1521 for (j = 0; j < w; j++) {
1524 uval = (pixel >> 16) & 0xff;
1525 vval = (pixel >> 8) & 0xff;
1560 if (pyval) *pyval = 0;
1561 if (puval) *puval = 0;
1562 if (pvval) *pvval = 0;
1563 if (!pyval || !puval || !pvval)
1564 return ERROR_INT(
"&yval, &uval, &vval not all defined", __func__, 1);
1567 *pyval = (l_int32)(16.0 +
1568 norm * (65.738 * rval + 129.057 * gval + 25.064 * bval) + 0.5);
1569 *puval = (l_int32)(128.0 +
1570 norm * (-37.945 * rval -74.494 * gval + 112.439 * bval) + 0.5);
1571 *pvval = (l_int32)(128.0 +
1572 norm * (112.439 * rval - 94.154 * gval - 18.285 * bval) + 0.5);
1604 l_int32 rval, gval, bval;
1605 l_float32 norm, ym, um, vm;
1607 if (prval) *prval = 0;
1608 if (pgval) *pgval = 0;
1609 if (pbval) *pbval = 0;
1610 if (!prval || !pgval || !pbval)
1611 return ERROR_INT(
"&rval, &gval, &bval not all defined", __func__, 1);
1617 rval = (l_int32)(norm * (298.082 * ym + 408.583 * vm) + 0.5);
1618 gval = (l_int32)(norm * (298.082 * ym - 100.291 * um - 208.120 * vm) +
1620 bval = (l_int32)(norm * (298.082 * ym + 516.411 * um) + 0.5);
1621 *prval = L_MIN(255, L_MAX(0, rval));
1622 *pgval = L_MIN(255, L_MAX(0, gval));
1623 *pbval = L_MIN(255, L_MAX(0, bval));
1645 l_int32 i, ncolors, rval, gval, bval, yval, uval, vval;
1648 return ERROR_INT(
"cmap not defined", __func__, 1);
1651 for (i = 0; i < ncolors; i++) {
1676 l_int32 i, ncolors, rval, gval, bval, yval, uval, vval;
1679 return ERROR_INT(
"cmap not defined", __func__, 1);
1682 for (i = 0; i < ncolors; i++) {
1725 l_int32 w, h, wpls, wpld, i, j, rval, gval, bval;
1726 l_uint32 *lines, *datas;
1727 l_float32 fxval, fyval, fzval;
1728 l_float32 *linex, *liney, *linez, *datax, *datay, *dataz;
1732 if (!pixs || pixGetDepth(pixs) != 32)
1733 return (
FPIXA *)ERROR_PTR(
"pixs undefined or not rgb", __func__, NULL);
1738 for (i = 0; i < 3; i++) {
1742 wpls = pixGetWpl(pixs);
1748 for (i = 0; i < h; i++) {
1749 lines = datas + i * wpls;
1750 linex = datax + i * wpld;
1751 liney = datay + i * wpld;
1752 linez = dataz + i * wpld;
1753 for (j = 0; j < w; j++) {
1756 *(linex + j) = fxval;
1757 *(liney + j) = fyval;
1758 *(linez + j) = fzval;
1782 l_int32 w, h, wpls, wpld, i, j, rval, gval, bval;
1783 l_float32 fxval, fyval, fzval;
1784 l_float32 *linex, *liney, *linez, *datax, *datay, *dataz;
1785 l_uint32 *lined, *datad;
1790 return (
PIX *)ERROR_PTR(
"fpixa undefined or invalid", __func__, NULL);
1794 return (
PIX *)ERROR_PTR(
"fpixa dimensions not found", __func__, NULL);
1796 wpld = pixGetWpl(pixd);
1804 for (i = 0; i < h; i++) {
1805 linex = datax + i * wpls;
1806 liney = datay + i * wpls;
1807 linez = dataz + i * wpls;
1808 lined = datad + i * wpld;
1809 for (j = 0; j < w; j++) {
1843 if (pfxval) *pfxval = 0.0;
1844 if (pfyval) *pfyval = 0.0;
1845 if (pfzval) *pfzval = 0.0;
1846 if (!pfxval || !pfyval || !pfzval)
1847 return ERROR_INT(
"&xval, &yval, &zval not all defined", __func__, 1);
1849 *pfxval = 0.4125 * rval + 0.3576 * gval + 0.1804 * bval;
1850 *pfyval = 0.2127 * rval + 0.7152 * gval + 0.0722 * bval;
1851 *pfzval = 0.0193 * rval + 0.1192 * gval + 0.9502 * bval;
1884 l_int32 rval, gval, bval;
1886 if (prval) *prval = 0;
1887 if (pgval) *pgval = 0;
1888 if (pbval) *pbval = 0;
1889 if (!prval || !pgval ||!pbval)
1890 return ERROR_INT(
"&rval, &gval, &bval not all defined", __func__, 1);
1891 *prval = *pgval = *pbval = 0;
1893 rval = (l_int32)(3.2405 * fxval - 1.5372 * fyval - 0.4985 * fzval + 0.5);
1894 gval = (l_int32)(-0.9693 * fxval + 1.8760 * fyval + 0.0416 * fzval + 0.5);
1895 bval = (l_int32)(0.0556 * fxval - 0.2040 * fyval + 1.0573 * fzval + 0.5);
1896 if (blackout == 0) {
1897 *prval = L_MAX(0, L_MIN(rval, 255));
1898 *pgval = L_MAX(0, L_MIN(gval, 255));
1899 *pbval = L_MAX(0, L_MIN(bval, 255));
1901 if (rval >= 0 && rval < 256 && gval >= 0 && gval < 256 &&
1902 bval >= 0 && bval < 256) {
1937 l_int32 w, h, wpl, i, j;
1938 l_float32 fxval, fyval, fzval, flval, faval, fbval;
1939 l_float32 *linex, *liney, *linez, *datax, *datay, *dataz;
1940 l_float32 *linel, *linea, *lineb, *datal, *dataa, *datab;
1945 return (
FPIXA *)ERROR_PTR(
"fpixas undefined/invalid", __func__, NULL);
1949 return (
FPIXA *)ERROR_PTR(
"fpixas sizes not found", __func__, NULL);
1951 for (i = 0; i < 3; i++) {
1964 for (i = 0; i < h; i++) {
1965 linex = datax + i * wpl;
1966 liney = datay + i * wpl;
1967 linez = dataz + i * wpl;
1968 linel = datal + i * wpl;
1969 linea = dataa + i * wpl;
1970 lineb = datab + i * wpl;
1971 for (j = 0; j < w; j++) {
1972 fxval = *(linex + j);
1973 fyval = *(liney + j);
1974 fzval = *(linez + j);
1976 *(linel + j) = flval;
1977 *(linea + j) = faval;
1978 *(lineb + j) = fbval;
2001 l_int32 w, h, wpl, i, j;
2002 l_float32 fxval, fyval, fzval, flval, faval, fbval;
2003 l_float32 *linel, *linea, *lineb, *datal, *dataa, *datab;
2004 l_float32 *linex, *liney, *linez, *datax, *datay, *dataz;
2009 return (
FPIXA *)ERROR_PTR(
"fpixas undefined/invalid", __func__, NULL);
2013 return (
FPIXA *)ERROR_PTR(
"fpixas sizes not found", __func__, NULL);
2015 for (i = 0; i < 3; i++) {
2028 for (i = 0; i < h; i++) {
2029 linel = datal + i * wpl;
2030 linea = dataa + i * wpl;
2031 lineb = datab + i * wpl;
2032 linex = datax + i * wpl;
2033 liney = datay + i * wpl;
2034 linez = dataz + i * wpl;
2035 for (j = 0; j < w; j++) {
2036 flval = *(linel + j);
2037 faval = *(linea + j);
2038 fbval = *(lineb + j);
2040 *(linex + j) = fxval;
2041 *(liney + j) = fyval;
2042 *(linez + j) = fzval;
2065 l_float32 xn, yn, zn, fx, fy, fz;
2067 if (plval) *plval = 0.0;
2068 if (paval) *paval = 0.0;
2069 if (pbval) *pbval = 0.0;
2070 if (!plval || !paval || !pbval)
2071 return ERROR_INT(
"&lval, &aval, &bval not all defined", __func__, 1);
2074 xn = 0.0041259 * xval;
2075 yn = 0.0039216 * yval;
2076 zn = 0.0036012 * zval;
2078 fx = lab_forward(xn);
2079 fy = lab_forward(yn);
2080 fz = lab_forward(zn);
2081 *plval = 116.0 * fy - 16.0;
2082 *paval = 500.0 * (fx - fy);
2083 *pbval = 200.0 * (fy - fz);
2103 l_float32 fx, fy, fz;
2104 l_float32 xw = 242.37;
2105 l_float32 yw = 255.0;
2106 l_float32 zw = 277.69;
2108 if (pxval) *pxval = 0.0;
2109 if (pyval) *pyval = 0.0;
2110 if (pzval) *pzval = 0.0;
2111 if (!pxval || !pyval || !pzval)
2112 return ERROR_INT(
"&xval, &yval, &zval not all defined", __func__, 1);
2114 fy = 0.0086207 * (16.0 + lval);
2115 fx = fy + 0.002 * aval;
2116 fz = fy - 0.005 * bval;
2117 *pxval = xw * lab_reverse(fx);
2118 *pyval = yw * lab_reverse(fy);
2119 *pzval = zw * lab_reverse(fz);
2132 lab_forward(l_float32 v)
2134 const l_float32 f_thresh = 0.008856;
2135 const l_float32 f_factor = 7.787;
2136 const l_float32 f_offset = 0.13793;
2140 return powf(v, 0.333333);
2143 num = 4.37089e-04 + v * (9.52695e-02 + v * (1.25201 + v * 1.30273));
2144 den = 3.91236e-03 + v * (2.95408e-01 + v * (1.71714 + v * 6.34341e-01));
2148 return f_factor * v + f_offset;
2158 lab_reverse(l_float32 v)
2160 const l_float32 r_thresh = 0.20690;
2161 const l_float32 r_factor = 0.12842;
2162 const l_float32 r_offset = 0.13793;
2167 return r_factor * (v - r_offset);
2190 l_int32 w, h, wpls, wpld, i, j, rval, gval, bval;
2191 l_uint32 *lines, *datas;
2192 l_float32 flval, faval, fbval;
2193 l_float32 *linel, *linea, *lineb, *datal, *dataa, *datab;
2197 if (!pixs || pixGetDepth(pixs) != 32)
2198 return (
FPIXA *)ERROR_PTR(
"pixs undefined or not rgb", __func__, NULL);
2203 for (i = 0; i < 3; i++) {
2207 wpls = pixGetWpl(pixs);
2213 for (i = 0; i < h; i++) {
2214 lines = datas + i * wpls;
2215 linel = datal + i * wpld;
2216 linea = dataa + i * wpld;
2217 lineb = datab + i * wpld;
2218 for (j = 0; j < w; j++) {
2221 *(linel + j) = flval;
2222 *(linea + j) = faval;
2223 *(lineb + j) = fbval;
2245 l_int32 w, h, wpls, wpld, i, j, rval, gval, bval;
2246 l_float32 flval, faval, fbval;
2247 l_float32 *linel, *linea, *lineb, *datal, *dataa, *datab;
2248 l_uint32 *lined, *datad;
2253 return (
PIX *)ERROR_PTR(
"fpixa undefined or invalid", __func__, NULL);
2257 return (
PIX *)ERROR_PTR(
"fpixa dimensions not found", __func__, NULL);
2259 wpld = pixGetWpl(pixd);
2267 for (i = 0; i < h; i++) {
2268 linel = datal + i * wpls;
2269 linea = dataa + i * wpls;
2270 lineb = datab + i * wpls;
2271 lined = datad + i * wpld;
2272 for (j = 0; j < w; j++) {
2306 l_float32 fxval, fyval, fzval;
2308 if (pflval) *pflval = 0.0;
2309 if (pfaval) *pfaval = 0.0;
2310 if (pfbval) *pfbval = 0.0;
2311 if (!pflval || !pfaval || !pfbval)
2312 return ERROR_INT(
"&flval, &faval, &fbval not all defined", __func__, 1);
2341 l_float32 fxval, fyval, fzval;
2343 if (prval) *prval = 0;
2344 if (pgval) *pgval = 0;
2345 if (pbval) *pbval = 0;
2346 if (!prval || !pgval || !pbval)
2347 return ERROR_INT(
"&rval, &gval, &bval not all defined", __func__, 1);
2385 if (scale <= 0) scale = 8;
2388 for (k = 0; k < 32; k++) {
2390 for (i = 0; i < 32; i++) {
2391 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()