108 #include <config_auto.h> 113 #include "allheaders.h" 130 PROCNAME(
"pixcmapCreate");
132 if (depth != 1 && depth != 2 && depth !=4 && depth != 8)
133 return (
PIXCMAP *)ERROR_PTR(
"depth not in {1,2,4,8}", procName, NULL);
137 cmap->
nalloc = 1 << depth;
177 l_int32 red[256], green[256], blue[256];
180 PROCNAME(
"pixcmapCreateRandom");
182 if (depth != 2 && depth != 4 && depth != 8)
183 return (
PIXCMAP *)ERROR_PTR(
"depth not in {2, 4, 8}", procName, NULL);
184 if (hasblack != 0) hasblack = 1;
185 if (haswhite != 0) haswhite = 1;
188 ncolors = 1 << depth;
191 for (i = hasblack; i < ncolors - haswhite; i++) {
192 red[i] = (l_uint32)rand() & 0xff;
193 green[i] = (l_uint32)rand() & 0xff;
194 blue[i] = (l_uint32)rand() & 0xff;
221 l_int32 maxlevels, i, val;
224 PROCNAME(
"pixcmapCreateLinear");
226 if (d != 1 && d != 2 && d !=4 && d != 8)
227 return (
PIXCMAP *)ERROR_PTR(
"d not in {1, 2, 4, 8}", procName, NULL);
229 if (nlevels < 2 || nlevels > maxlevels)
230 return (
PIXCMAP *)ERROR_PTR(
"invalid nlevels", procName, NULL);
233 for (i = 0; i < nlevels; i++) {
234 val = (255 * i) / (nlevels - 1);
250 l_int32 nbytes, valid;
253 PROCNAME(
"pixcmapCopy");
256 return (
PIXCMAP *)ERROR_PTR(
"cmaps not defined", procName, NULL);
259 return (
PIXCMAP *)ERROR_PTR(
"invalid cmap", procName, NULL);
263 cmapd->
array = (
void *)LEPT_CALLOC(1, nbytes);
283 PROCNAME(
"pixcmapDestroy");
286 L_WARNING(
"ptr address is null!\n", procName);
290 if ((cmap = *pcmap) == NULL)
293 LEPT_FREE(cmap->
array);
321 l_int32 d, depth, nalloc, maxindex, maxcolors;
323 PROCNAME(
"pixcmapIsValid");
326 return ERROR_INT(
"&valid not defined", procName, 1);
329 return ERROR_INT(
"cmap not defined", procName, 1);
331 return ERROR_INT(
"cmap array not defined", procName, 1);
333 if (d != 1 && d != 2 && d != 4 && d != 8) {
334 L_ERROR(
"invalid cmap depth: %d\n", procName, d);
338 if (nalloc != (1 << d)) {
339 L_ERROR(
"invalid cmap nalloc = %d; d = %d\n", procName, nalloc, d);
342 if (cmap->
n < 0 || cmap->
n > nalloc) {
343 L_ERROR(
"invalid cmap n: %d; nalloc = %d\n", procName, cmap->
n, nalloc);
349 depth = pixGetDepth(pix);
351 L_ERROR(
"pix depth %d > 8\n", procName, depth);
354 maxcolors = 1 << depth;
361 if (pix && (depth > d)) {
362 L_ERROR(
"(pix depth = %d) > (cmap depth = %d)\n", procName, depth, d);
365 if (pix && cmap->
n < 1) {
366 L_ERROR(
"cmap array is empty; invalid with any pix\n", procName);
375 if (pix && (cmap->
n > maxcolors)) {
376 L_ERROR(
"cmap entries = %d > max colors for pix = %d\n", procName,
387 if (maxindex >= cmap->
n) {
388 L_ERROR(
"(max index = %d) >= (num colors = %d)\n", procName,
421 PROCNAME(
"pixcmapAddColor");
424 return ERROR_INT(
"cmap not defined", procName, 1);
426 return ERROR_INT(
"no free color entries", procName, 1);
429 cta[cmap->
n].
red = rval;
430 cta[cmap->
n].
green = gval;
431 cta[cmap->
n].
blue = bval;
460 PROCNAME(
"pixcmapAddRGBA");
463 return ERROR_INT(
"cmap not defined", procName, 1);
465 return ERROR_INT(
"no free color entries", procName, 1);
468 cta[cmap->
n].
red = rval;
469 cta[cmap->
n].
green = gval;
470 cta[cmap->
n].
blue = bval;
471 cta[cmap->
n].
alpha = aval;
502 PROCNAME(
"pixcmapAddNewColor");
505 return ERROR_INT(
"&index not defined", procName, 1);
508 return ERROR_INT(
"cmap not defined", procName, 1);
516 L_WARNING(
"no free color entries\n", procName);
551 PROCNAME(
"pixcmapAddNearestColor");
554 return ERROR_INT(
"&index not defined", procName, 1);
557 return ERROR_INT(
"cmap not defined", procName, 1);
600 PROCNAME(
"pixcmapUsableColor");
603 return ERROR_INT(
"&usable not defined", procName, 1);
606 return ERROR_INT(
"cmap not defined", procName, 1);
645 PROCNAME(
"pixcmapAddBlackOrWhite");
647 if (pindex) *pindex = 0;
649 return ERROR_INT(
"cmap not defined", procName, 1);
684 PROCNAME(
"pixcmapSetBlackAndWhite");
687 return ERROR_INT(
"cmap not defined", procName, 1);
710 PROCNAME(
"pixcmapGetCount");
713 return ERROR_INT(
"cmap not defined", procName, 0);
727 PROCNAME(
"pixcmapGetFreeCount");
730 return ERROR_INT(
"cmap not defined", procName, 0);
731 return (cmap->
nalloc - cmap->
n);
744 PROCNAME(
"pixcmapGetDepth");
747 return ERROR_INT(
"cmap not defined", procName, 0);
770 PROCNAME(
"pixcmapGetMinDepth");
773 return ERROR_INT(
"&mindepth not defined", procName, 1);
776 return ERROR_INT(
"cmap not defined", procName, 1);
781 else if (ncolors <= 16)
803 PROCNAME(
"pixcmapClear");
806 return ERROR_INT(
"cmap not defined", procName, 1);
832 PROCNAME(
"pixcmapGetColor");
834 if (!prval || !pgval || !pbval)
835 return ERROR_INT(
"&rval, &gval, &bval not all defined", procName, 1);
836 *prval = *pgval = *pbval = 0;
838 return ERROR_INT(
"cmap not defined", procName, 1);
839 if (index < 0 || index >= cmap->
n)
840 return ERROR_INT(
"index out of bounds", procName, 1);
843 *prval = cta[index].
red;
844 *pgval = cta[index].
green;
845 *pbval = cta[index].
blue;
868 l_int32 rval, gval, bval;
870 PROCNAME(
"pixcmapGetColor32");
873 return ERROR_INT(
"&val32 not defined", procName, 1);
877 return ERROR_INT(
"rgb values not found", procName, 1);
901 PROCNAME(
"pixcmapGetRGBA");
903 if (!prval || !pgval || !pbval || !paval)
904 return ERROR_INT(
"&rval, &gval, &bval, &aval not all defined",
906 *prval = *pgval = *pbval = *paval = 0;
908 return ERROR_INT(
"cmap not defined", procName, 1);
909 if (index < 0 || index >= cmap->
n)
910 return ERROR_INT(
"index out of bounds", procName, 1);
913 *prval = cta[index].
red;
914 *pgval = cta[index].
green;
915 *pbval = cta[index].
blue;
916 *paval = cta[index].
alpha;
934 l_int32 rval, gval, bval, aval;
936 PROCNAME(
"pixcmapGetRGBA32");
939 return ERROR_INT(
"&val32 not defined", procName, 1);
943 return ERROR_INT(
"rgba values not found", procName, 1);
974 PROCNAME(
"pixcmapResetColor");
977 return ERROR_INT(
"cmap not defined", procName, 1);
978 if (index < 0 || index >= cmap->
n)
979 return ERROR_INT(
"index out of bounds", procName, 1);
982 cta[index].
red = rval;
983 cta[index].
green = gval;
984 cta[index].
blue = bval;
985 cta[index].
alpha = 255;
1013 PROCNAME(
"pixcmapSetAlpha");
1016 return ERROR_INT(
"cmap not defined", procName, 1);
1017 if (index < 0 || index >= cmap->
n)
1018 return ERROR_INT(
"index out of bounds", procName, 1);
1021 cta[index].
alpha = aval;
1045 PROCNAME(
"pixcmapGetIndex");
1048 return ERROR_INT(
"&index not defined", procName, 1);
1051 return ERROR_INT(
"cmap not defined", procName, 1);
1055 for (i = 0; i < n; i++) {
1056 if (rval == cta[i].red &&
1057 gval == cta[i].green &&
1058 bval == cta[i].blue) {
1079 l_int32 *rmap, *gmap, *bmap;
1081 PROCNAME(
"pixcmapHasColor");
1084 return ERROR_INT(
"&color not defined", procName, 1);
1087 return ERROR_INT(
"cmap not defined", procName, 1);
1090 return ERROR_INT(
"colormap arrays not made", procName, 1);
1092 for (i = 0; i < n; i++) {
1093 if ((rmap[i] != gmap[i]) || (rmap[i] != bmap[i])) {
1120 PROCNAME(
"pixcmapIsOpaque");
1123 return ERROR_INT(
"&opaque not defined", procName, 1);
1126 return ERROR_INT(
"cmap not defined", procName, 1);
1130 for (i = 0; i < n; i++) {
1131 if (cta[i].alpha != 255) {
1175 l_int32 *pmax_trans,
1176 l_int32 *pmin_opaque)
1178 l_int32 i, n, ntrans, max_trans, min_opaque, opaque_found;
1181 PROCNAME(
"pixcmapCountNonOpaqueColors");
1183 if (pntrans) *pntrans = 0;
1184 if (pmax_trans) *pmax_trans = -1;
1185 if (pmin_opaque) *pmin_opaque = 256;
1187 return ERROR_INT(
"cmap not defined", procName, 1);
1194 opaque_found = FALSE;
1195 for (i = 0; i < n; i++) {
1196 if (cta[i].alpha != 255) {
1199 }
else if (opaque_found == FALSE) {
1200 opaque_found = TRUE;
1204 if (pntrans) *pntrans = ntrans;
1205 if (pmax_trans) *pmax_trans = max_trans;
1206 if (pmin_opaque) *pmin_opaque = min_opaque;
1221 l_int32 *pblackwhite)
1223 l_int32 val0, val1, hascolor;
1226 PROCNAME(
"pixcmapIsBlackAndWhite");
1229 return ERROR_INT(
"&blackwhite not defined", procName, 1);
1230 *pblackwhite = FALSE;
1232 return ERROR_INT(
"cmap not defined", procName, 1);
1237 if (hascolor)
return 0;
1242 if ((val0 == 0 && val1 == 255) || (val0 == 255 && val1 == 0))
1243 *pblackwhite = TRUE;
1264 l_int32 n, i, rval, gval, bval, count;
1267 PROCNAME(
"pixcmapCountGrayColors");
1270 return ERROR_INT(
"&ngray not defined", procName, 1);
1273 return ERROR_INT(
"cmap not defined", procName, 1);
1275 array = (l_int32 *)LEPT_CALLOC(256,
sizeof(l_int32));
1278 for (i = 0; i < n; i++) {
1280 if ((rval == gval) && (rval == bval) && (array[rval] == 0)) {
1306 l_int32 n, i, rval, gval, bval, rankindex;
1309 PROCNAME(
"pixcmapGetRankIntensity");
1312 return ERROR_INT(
"&index not defined", procName, 1);
1315 return ERROR_INT(
"cmap not defined", procName, 1);
1316 if (rankval < 0.0 || rankval > 1.0)
1317 return ERROR_INT(
"rankval not in [0.0 ... 1.0]", procName, 1);
1321 for (i = 0; i < n; i++) {
1326 rankindex = (l_int32)(rankval * (n - 1) + 0.5);
1359 l_int32 i, n, delta, dist, mindist;
1362 PROCNAME(
"pixcmapGetNearestIndex");
1365 return ERROR_INT(
"&index not defined", procName, 1);
1368 return ERROR_INT(
"cmap not defined", procName, 1);
1371 return ERROR_INT(
"cta not defined(!)", procName, 1);
1374 mindist = 3 * 255 * 255 + 1;
1375 for (i = 0; i < n; i++) {
1376 delta = cta[i].
red - rval;
1377 dist = delta * delta;
1378 delta = cta[i].
green - gval;
1379 dist += delta * delta;
1380 delta = cta[i].
blue - bval;
1381 dist += delta * delta;
1382 if (dist < mindist) {
1415 l_int32 i, n, dist, mindist;
1418 PROCNAME(
"pixcmapGetNearestGrayIndex");
1421 return ERROR_INT(
"&index not defined", procName, 1);
1424 return ERROR_INT(
"cmap not defined", procName, 1);
1425 if (val < 0 || val > 255)
1426 return ERROR_INT(
"val not in [0 ... 255]", procName, 1);
1429 return ERROR_INT(
"cta not defined(!)", procName, 1);
1433 for (i = 0; i < n; i++) {
1434 dist = cta[i].
green - val;
1436 if (dist < mindist) {
1471 l_int32 n, delta, dist;
1474 PROCNAME(
"pixcmapGetDistanceToColor");
1477 return ERROR_INT(
"&dist not defined", procName, 1);
1480 return ERROR_INT(
"cmap not defined", procName, 1);
1483 return ERROR_INT(
"invalid index", procName, 1);
1486 return ERROR_INT(
"cta not defined(!)", procName, 1);
1488 delta = cta[index].
red - rval;
1489 dist = delta * delta;
1490 delta = cta[index].
green - gval;
1491 dist += delta * delta;
1492 delta = cta[index].
blue - bval;
1493 dist += delta * delta;
1527 l_int32 i, n, imin, imax, minval, maxval, rval, gval, bval, aveval;
1529 PROCNAME(
"pixcmapGetRangeValues");
1531 if (pminval) *pminval = UNDEF;
1532 if (pmaxval) *pmaxval = UNDEF;
1533 if (pminindex) *pminindex = UNDEF;
1534 if (pmaxindex) *pmaxindex = UNDEF;
1535 if (!pminval && !pmaxval && !pminindex && !pmaxindex)
1536 return ERROR_INT(
"no result requested", procName, 1);
1538 return ERROR_INT(
"cmap not defined", procName, 1);
1545 for (i = 0; i < n; i++) {
1548 if (rval < minval) {
1552 if (rval > maxval) {
1557 if (gval < minval) {
1561 if (gval > maxval) {
1566 if (bval < minval) {
1570 if (bval > maxval) {
1575 aveval = (rval + gval + bval) / 3;
1576 if (aveval < minval) {
1580 if (aveval > maxval) {
1585 return ERROR_INT(
"invalid selection", procName, 1);
1589 if (pminval) *pminval = minval;
1590 if (pmaxval) *pmaxval = maxval;
1591 if (pminindex) *pminindex = imin;
1592 if (pmaxindex) *pmaxindex = imax;
1616 l_int32 i, rval, gval, bval;
1618 l_float32 invgamma, x;
1621 if (gamma <= 0.0) gamma = 1.0;
1624 curve = (l_int32 *)LEPT_CALLOC(64,
sizeof(l_int32));
1625 invgamma = 1. / gamma;
1626 for (i = 0; i < 64; i++) {
1627 x = (l_float32)i / 64.;
1628 curve[i] = (l_int32)(255. * powf(x, invgamma) + 0.5);
1632 for (i = 0; i < 256; i++) {
1636 bval = curve[i + 32];
1637 }
else if (i < 96) {
1639 gval = curve[i - 32];
1641 }
else if (i < 160) {
1642 rval = curve[i - 96];
1644 bval = curve[159 - i];
1645 }
else if (i < 224) {
1647 gval = curve[223 - i];
1650 rval = curve[287 - i];
1680 l_int32 i, rval, gval, bval;
1685 for (i = 0; i < 256; i++) {
1687 gval + (i * (255 - gval)) / 255,
1688 bval + (i * (255 - bval)) / 255);
1715 l_int32 i, n, rval, gval, bval, val;
1719 PROCNAME(
"pixcmapColorToGray");
1722 return (
PIXCMAP *)ERROR_PTR(
"cmaps not defined", procName, NULL);
1723 if (rwt < 0.0 || gwt < 0.0 || bwt < 0.0)
1724 return (
PIXCMAP *)ERROR_PTR(
"weights not all >= 0.0", procName, NULL);
1728 sum = rwt + gwt + bwt;
1730 L_WARNING(
"all weights zero; setting equal to 1/3\n", procName);
1731 rwt = gwt = bwt = 0.33333;
1734 if (L_ABS(sum - 1.0) > 0.0001) {
1735 L_WARNING(
"weights don't sum to 1; maintaining ratios\n", procName);
1742 return (
PIXCMAP *)ERROR_PTR(
"cmapd not made", procName, NULL);
1744 for (i = 0; i < n; i++) {
1746 val = (l_int32)(rwt * rval + gwt * gval + bwt * bval + 0.5);
1769 l_int32 i, n, rval, gval, bval;
1772 PROCNAME(
"pixcmapConvertTo4");
1775 return (
PIXCMAP *)ERROR_PTR(
"cmaps not defined", procName, NULL);
1777 return (
PIXCMAP *)ERROR_PTR(
"cmaps not for 2 bpp pix", procName, NULL);
1781 for (i = 0; i < n; i++) {
1804 l_int32 i, n, depth, rval, gval, bval;
1807 PROCNAME(
"pixcmapConvertTo8");
1810 return (
PIXCMAP *)ERROR_PTR(
"cmaps not defined", procName, NULL);
1813 if (depth != 2 && depth != 4)
1814 return (
PIXCMAP *)ERROR_PTR(
"cmaps not 2 or 4 bpp", procName, NULL);
1818 for (i = 0; i < n; i++) {
1841 PROCNAME(
"pixcmapRead");
1844 return (
PIXCMAP *)ERROR_PTR(
"filename not defined", procName, NULL);
1847 return (
PIXCMAP *)ERROR_PTR(
"stream not opened", procName, NULL);
1851 return (
PIXCMAP *)ERROR_PTR(
"cmap not read", procName, NULL);
1865 l_int32 rval, gval, bval, aval, ignore;
1866 l_int32 i, index, ret, depth, ncolors;
1869 PROCNAME(
"pixcmapReadStream");
1872 return (
PIXCMAP *)ERROR_PTR(
"stream not defined", procName, NULL);
1874 ret = fscanf(fp,
"\nPixcmap: depth = %d bpp; %d colors\n",
1877 (depth != 1 && depth != 2 && depth != 4 && depth != 8) ||
1878 (ncolors < 2 || ncolors > 256))
1879 return (
PIXCMAP *)ERROR_PTR(
"invalid cmap size", procName, NULL);
1880 ignore = fscanf(fp,
"Color R-val G-val B-val Alpha\n");
1881 ignore = fscanf(fp,
"----------------------------------------\n");
1884 return (
PIXCMAP *)ERROR_PTR(
"cmap not made", procName, NULL);
1885 for (i = 0; i < ncolors; i++) {
1886 if (fscanf(fp,
"%3d %3d %3d %3d %3d\n",
1887 &index, &rval, &gval, &bval, &aval) != 5) {
1889 return (
PIXCMAP *)ERROR_PTR(
"invalid entry", procName, NULL);
1911 PROCNAME(
"pixcmapReadMem");
1914 return (
PIXCMAP *)ERROR_PTR(
"data not defined", procName, NULL);
1916 return (
PIXCMAP *)ERROR_PTR(
"stream not opened", procName, NULL);
1920 if (!cmap) L_ERROR(
"cmap not read\n", procName);
1939 PROCNAME(
"pixcmapWrite");
1942 return ERROR_INT(
"filename not defined", procName, 1);
1944 return ERROR_INT(
"cmap not defined", procName, 1);
1947 return ERROR_INT(
"stream not opened", procName, 1);
1951 return ERROR_INT(
"cmap not written to stream", procName, 1);
1968 l_int32 *rmap, *gmap, *bmap, *amap;
1971 PROCNAME(
"pixcmapWriteStream");
1974 return ERROR_INT(
"stream not defined", procName, 1);
1976 return ERROR_INT(
"cmap not defined", procName, 1);
1979 return ERROR_INT(
"colormap arrays not made", procName, 1);
1981 fprintf(fp,
"\nPixcmap: depth = %d bpp; %d colors\n", cmap->
depth, cmap->
n);
1982 fprintf(fp,
"Color R-val G-val B-val Alpha\n");
1983 fprintf(fp,
"----------------------------------------\n");
1984 for (i = 0; i < cmap->
n; i++)
1985 fprintf(fp,
"%3d %3d %3d %3d %3d\n",
1986 i, rmap[i], gmap[i], bmap[i], amap[i]);
2018 PROCNAME(
"pixcmapWriteMem");
2020 if (pdata) *pdata = NULL;
2021 if (psize) *psize = 0;
2023 return ERROR_INT(
"&data not defined", procName, 1);
2025 return ERROR_INT(
"&size not defined", procName, 1);
2027 return ERROR_INT(
"cmap not defined", procName, 1);
2030 if ((fp = open_memstream((
char **)pdata, psize)) == NULL)
2031 return ERROR_INT(
"stream not opened", procName, 1);
2035 *psize = *psize - 1;
2037 L_INFO(
"work-around: writing to a temp file\n", procName);
2040 return ERROR_INT(
"tmpfile stream not opened", procName, 1);
2042 if ((fp = tmpfile()) == NULL)
2043 return ERROR_INT(
"tmpfile stream not opened", procName, 1);
2074 l_int32 *rmap, *gmap, *bmap, *amap;
2078 PROCNAME(
"pixcmapToArrays");
2080 if (!prmap || !pgmap || !pbmap)
2081 return ERROR_INT(
"&rmap, &gmap, &bmap not all defined", procName, 1);
2082 *prmap = *pgmap = *pbmap = NULL;
2083 if (pamap) *pamap = NULL;
2085 return ERROR_INT(
"cmap not defined", procName, 1);
2088 rmap = (l_int32 *)LEPT_CALLOC(ncolors,
sizeof(l_int32));
2089 gmap = (l_int32 *)LEPT_CALLOC(ncolors,
sizeof(l_int32));
2090 bmap = (l_int32 *)LEPT_CALLOC(ncolors,
sizeof(l_int32));
2095 amap = (l_int32 *)LEPT_CALLOC(ncolors,
sizeof(l_int32));
2100 for (i = 0; i < ncolors; i++) {
2101 rmap[i] = cta[i].
red;
2102 gmap[i] = cta[i].
green;
2103 bmap[i] = cta[i].
blue;
2105 amap[i] = cta[i].
alpha;
2125 l_int32 i, ncolors, rval, gval, bval, aval;
2128 PROCNAME(
"pixcmapToRGBTable");
2131 return ERROR_INT(
"&tab not defined", procName, 1);
2134 return ERROR_INT(
"cmap not defined", procName, 1);
2137 if (pncolors) *pncolors = ncolors;
2138 tab = (l_uint32 *)LEPT_CALLOC(ncolors,
sizeof(l_uint32));
2141 for (i = 0; i < ncolors; i++) {
2169 l_int32 i, ncolors, rval, gval, bval, aval;
2172 PROCNAME(
"pixcmapSerializeToMemory");
2175 return ERROR_INT(
"&data not defined", procName, 1);
2178 return ERROR_INT(
"&ncolors not defined", procName, 1);
2181 return ERROR_INT(
"cmap not defined", procName, 1);
2182 if (cpc != 3 && cpc != 4)
2183 return ERROR_INT(
"cpc not 3 or 4", procName, 1);
2186 *pncolors = ncolors;
2187 data = (l_uint8 *)LEPT_CALLOC((
size_t)cpc * ncolors,
sizeof(l_uint8));
2190 for (i = 0; i < ncolors; i++) {
2192 data[cpc * i] = rval;
2193 data[cpc * i + 1] = gval;
2194 data[cpc * i + 2] = bval;
2196 data[cpc * i + 3] = aval;
2215 l_int32 i, d, rval, gval, bval, aval;
2218 PROCNAME(
"pixcmapDeserializeFromMemory");
2221 return (
PIXCMAP *)ERROR_PTR(
"data not defined", procName, NULL);
2222 if (cpc != 3 && cpc != 4)
2223 return (
PIXCMAP *)ERROR_PTR(
"cpc not 3 or 4", procName, NULL);
2225 return (
PIXCMAP *)ERROR_PTR(
"no entries", procName, NULL);
2227 return (
PIXCMAP *)ERROR_PTR(
"ncolors > 256", procName, NULL);
2231 else if (ncolors > 4)
2233 else if (ncolors > 2)
2238 for (i = 0; i < ncolors; i++) {
2239 rval = data[cpc * i];
2240 gval = data[cpc * i + 1];
2241 bval = data[cpc * i + 2];
2243 aval = data[cpc * i + 3];
2275 l_int32 i, j, hexbytes;
2276 char *hexdata = NULL;
2279 PROCNAME(
"pixcmapConvertToHex");
2282 return (
char *)ERROR_PTR(
"data not defined", procName, NULL);
2284 return (
char *)ERROR_PTR(
"no colors", procName, NULL);
2286 hexbytes = 2 + (2 * 3 + 1) * ncolors + 2;
2287 hexdata = (
char *)LEPT_CALLOC(hexbytes,
sizeof(
char));
2291 for (i = 0; i < ncolors; i++) {
2292 j = 2 + (2 * 3 + 1) * i;
2293 snprintf(buf,
sizeof(buf),
"%02x", data[3 * i]);
2294 hexdata[j] = buf[0];
2295 hexdata[j + 1] = buf[1];
2296 snprintf(buf,
sizeof(buf),
"%02x", data[3 * i + 1]);
2297 hexdata[j + 2] = buf[0];
2298 hexdata[j + 3] = buf[1];
2299 snprintf(buf,
sizeof(buf),
"%02x", data[3 * i + 2]);
2300 hexdata[j + 4] = buf[0];
2301 hexdata[j + 5] = buf[1];
2302 hexdata[j + 6] =
' ';
2304 hexdata[j + 7] =
'>';
2305 hexdata[j + 8] =
'\0';
2335 l_int32 rval, gval, bval, trval, tgval, tbval, i, ncolors;
2338 PROCNAME(
"pixcmapGammaTRC");
2341 return ERROR_INT(
"cmap not defined", procName, 1);
2343 L_WARNING(
"gamma must be > 0.0; setting to 1.0\n", procName);
2346 if (minval >= maxval)
2347 return ERROR_INT(
"minval not < maxval", procName, 1);
2349 if (gamma == 1.0 && minval == 0 && maxval == 255)
2352 if ((nag =
numaGammaTRC(gamma, minval, maxval)) == NULL)
2353 return ERROR_INT(
"nag not made", procName, 1);
2356 for (i = 0; i < ncolors; i++) {
2388 l_int32 i, ncolors, rval, gval, bval, trval, tgval, tbval;
2391 PROCNAME(
"pixcmapContrastTRC");
2394 return ERROR_INT(
"cmap not defined", procName, 1);
2396 L_WARNING(
"factor must be >= 0.0; setting to 0.0\n", procName);
2401 return ERROR_INT(
"nac not made", procName, 1);
2404 for (i = 0; i < ncolors; i++) {
2440 l_int32 i, ncolors, rval, gval, bval;
2442 PROCNAME(
"pixcmapShiftIntensity");
2445 return ERROR_INT(
"cmap not defined", procName, 1);
2446 if (fraction < -1.0 || fraction > 1.0)
2447 return ERROR_INT(
"fraction not in [-1.0, 1.0]", procName, 1);
2450 for (i = 0; i < ncolors; i++) {
2454 (l_int32)((1.0 + fraction) * rval),
2455 (l_int32)((1.0 + fraction) * gval),
2456 (l_int32)((1.0 + fraction) * bval));
2459 rval + (l_int32)(fraction * (255 - rval)),
2460 gval + (l_int32)(fraction * (255 - gval)),
2461 bval + (l_int32)(fraction * (255 - bval)));
2491 l_int32 i, ncolors, rval, gval, bval;
2494 PROCNAME(
"pixcmapShiftByComponent");
2497 return ERROR_INT(
"cmap not defined", procName, 1);
2500 for (i = 0; i < ncolors; i++) {
l_ok pixcmapWriteMem(l_uint8 **pdata, size_t *psize, const PIXCMAP *cmap)
pixcmapWriteMem()
l_ok pixcmapCountGrayColors(PIXCMAP *cmap, l_int32 *pngray)
pixcmapCountGrayColors()
l_int32 pixcmapGetDepth(PIXCMAP *cmap)
pixcmapGetDepth()
NUMA * numaGetSortIndex(NUMA *na, l_int32 sortorder)
numaGetSortIndex()
l_ok pixcmapGetMinDepth(PIXCMAP *cmap, l_int32 *pmindepth)
pixcmapGetMinDepth()
char * pixcmapConvertToHex(l_uint8 *data, l_int32 ncolors)
pixcmapConvertToHex()
PIXCMAP * pixcmapReadStream(FILE *fp)
pixcmapReadStream()
l_ok numaAddNumber(NUMA *na, l_float32 val)
numaAddNumber()
PIXCMAP * pixcmapConvertTo8(PIXCMAP *cmaps)
pixcmapConvertTo8()
NUMA * numaGammaTRC(l_float32 gamma, l_int32 minval, l_int32 maxval)
numaGammaTRC()
l_ok pixcmapGetNearestIndex(PIXCMAP *cmap, l_int32 rval, l_int32 gval, l_int32 bval, l_int32 *pindex)
pixcmapGetNearestIndex()
PIXCMAP * pixcmapGrayToColor(l_uint32 color)
pixcmapGrayToColor()
PIXCMAP * pixcmapRead(const char *filename)
pixcmapRead()
l_ok pixcmapSerializeToMemory(PIXCMAP *cmap, l_int32 cpc, l_int32 *pncolors, l_uint8 **pdata)
pixcmapSerializeToMemory()
l_ok pixcmapIsBlackAndWhite(PIXCMAP *cmap, l_int32 *pblackwhite)
pixcmapIsBlackAndWhite()
FILE * fopenReadFromMemory(const l_uint8 *data, size_t size)
fopenReadFromMemory()
void pixcmapDestroy(PIXCMAP **pcmap)
pixcmapDestroy()
NUMA * numaCreate(l_int32 n)
numaCreate()
PIXCMAP * pixcmapReadMem(const l_uint8 *data, size_t size)
pixcmapReadMem()
PIXCMAP * pixcmapConvertTo4(PIXCMAP *cmaps)
pixcmapConvertTo4()
l_ok pixcmapGetRangeValues(PIXCMAP *cmap, l_int32 select, l_int32 *pminval, l_int32 *pmaxval, l_int32 *pminindex, l_int32 *pmaxindex)
pixcmapGetRangeValues()
PIXCMAP * pixcmapCreateLinear(l_int32 d, l_int32 nlevels)
pixcmapCreateLinear()
l_ok pixcmapShiftIntensity(PIXCMAP *cmap, l_float32 fraction)
pixcmapShiftIntensity()
l_ok pixcmapGetRGBA32(PIXCMAP *cmap, l_int32 index, l_uint32 *pval32)
pixcmapGetRGBA32()
l_ok pixelShiftByComponent(l_int32 rval, l_int32 gval, l_int32 bval, l_uint32 srcval, l_uint32 dstval, l_uint32 *ppixel)
pixelShiftByComponent()
PIXCMAP * pixcmapCreate(l_int32 depth)
pixcmapCreate()
l_ok pixcmapGetNearestGrayIndex(PIXCMAP *cmap, l_int32 val, l_int32 *pindex)
pixcmapGetNearestGrayIndex()
l_int32 pixcmapGetIndex(PIXCMAP *cmap, l_int32 rval, l_int32 gval, l_int32 bval, l_int32 *pindex)
pixcmapGetIndex()
l_ok pixGetMaxColorIndex(PIX *pixs, l_int32 *pmaxindex)
pixGetMaxColorIndex()
l_ok numaGetIValue(NUMA *na, l_int32 index, l_int32 *pival)
numaGetIValue()
PIXCMAP * pixcmapColorToGray(PIXCMAP *cmaps, l_float32 rwt, l_float32 gwt, l_float32 bwt)
pixcmapColorToGray()
l_ok pixcmapNonOpaqueColorsInfo(PIXCMAP *cmap, l_int32 *pntrans, l_int32 *pmax_trans, l_int32 *pmin_opaque)
pixcmapNonOpaqueColorsInfo()
l_ok pixcmapContrastTRC(PIXCMAP *cmap, l_float32 factor)
pixcmapContrastTRC()
l_ok pixcmapGetColor(PIXCMAP *cmap, l_int32 index, l_int32 *prval, l_int32 *pgval, l_int32 *pbval)
pixcmapGetColor()
l_ok composeRGBAPixel(l_int32 rval, l_int32 gval, l_int32 bval, l_int32 aval, l_uint32 *ppixel)
composeRGBAPixel()
l_ok pixcmapAddNewColor(PIXCMAP *cmap, l_int32 rval, l_int32 gval, l_int32 bval, l_int32 *pindex)
pixcmapAddNewColor()
l_ok pixcmapSetBlackAndWhite(PIXCMAP *cmap, l_int32 setblack, l_int32 setwhite)
pixcmapSetBlackAndWhite()
PIXCMAP * pixcmapDeserializeFromMemory(l_uint8 *data, l_int32 cpc, l_int32 ncolors)
pixcmapDeserializeFromMemory()
l_int32 pixcmapGetFreeCount(PIXCMAP *cmap)
pixcmapGetFreeCount()
l_ok pixcmapShiftByComponent(PIXCMAP *cmap, l_uint32 srcval, l_uint32 dstval)
pixcmapShiftByComponent()
l_ok pixcmapIsOpaque(PIXCMAP *cmap, l_int32 *popaque)
pixcmapIsOpaque()
l_ok pixcmapAddNearestColor(PIXCMAP *cmap, l_int32 rval, l_int32 gval, l_int32 bval, l_int32 *pindex)
pixcmapAddNearestColor()
l_ok pixcmapSetAlpha(PIXCMAP *cmap, l_int32 index, l_int32 aval)
pixcmapSetAlpha()
NUMA * numaContrastTRC(l_float32 factor)
numaContrastTRC()
l_ok pixcmapResetColor(PIXCMAP *cmap, l_int32 index, l_int32 rval, l_int32 gval, l_int32 bval)
pixcmapResetColor()
l_ok pixcmapHasColor(PIXCMAP *cmap, l_int32 *pcolor)
pixcmapHasColor()
l_ok pixcmapIsValid(const PIXCMAP *cmap, PIX *pix, l_int32 *pvalid)
pixcmapIsValid()
l_ok pixcmapWriteStream(FILE *fp, const PIXCMAP *cmap)
pixcmapWriteStream()
void numaDestroy(NUMA **pna)
numaDestroy()
FILE * fopenWriteStream(const char *filename, const char *modestring)
fopenWriteStream()
FILE * fopenWriteWinTempfile(void)
fopenWriteWinTempfile()
l_ok pixcmapUsableColor(PIXCMAP *cmap, l_int32 rval, l_int32 gval, l_int32 bval, l_int32 *pusable)
pixcmapUsableColor()
FILE * fopenReadStream(const char *filename)
fopenReadStream()
l_uint8 * l_binaryReadStream(FILE *fp, size_t *pnbytes)
l_binaryReadStream()
l_ok pixcmapAddBlackOrWhite(PIXCMAP *cmap, l_int32 color, l_int32 *pindex)
pixcmapAddBlackOrWhite()
PIXCMAP * pixcmapGrayToFalseColor(l_float32 gamma)
pixcmapGrayToFalseColor()
l_ok pixcmapGetColor32(PIXCMAP *cmap, l_int32 index, l_uint32 *pval32)
pixcmapGetColor32()
l_ok pixcmapToRGBTable(PIXCMAP *cmap, l_uint32 **ptab, l_int32 *pncolors)
pixcmapToRGBTable()
l_ok pixcmapWrite(const char *filename, const PIXCMAP *cmap)
pixcmapWrite()
l_int32 pixcmapGetCount(const PIXCMAP *cmap)
pixcmapGetCount()
l_ok pixcmapGetRGBA(PIXCMAP *cmap, l_int32 index, l_int32 *prval, l_int32 *pgval, l_int32 *pbval, l_int32 *paval)
pixcmapGetRGBA()
PIXCMAP * pixcmapCopy(const PIXCMAP *cmaps)
pixcmapCopy()
l_ok pixcmapGetDistanceToColor(PIXCMAP *cmap, l_int32 index, l_int32 rval, l_int32 gval, l_int32 bval, l_int32 *pdist)
pixcmapGetDistanceToColor()
l_ok pixcmapAddColor(PIXCMAP *cmap, l_int32 rval, l_int32 gval, l_int32 bval)
pixcmapAddColor()
void extractRGBValues(l_uint32 pixel, l_int32 *prval, l_int32 *pgval, l_int32 *pbval)
extractRGBValues()
l_ok pixcmapGammaTRC(PIXCMAP *cmap, l_float32 gamma, l_int32 minval, l_int32 maxval)
pixcmapGammaTRC()
l_ok pixcmapToArrays(const PIXCMAP *cmap, l_int32 **prmap, l_int32 **pgmap, l_int32 **pbmap, l_int32 **pamap)
pixcmapToArrays()
l_ok pixcmapAddRGBA(PIXCMAP *cmap, l_int32 rval, l_int32 gval, l_int32 bval, l_int32 aval)
pixcmapAddRGBA()
l_ok pixcmapGetRankIntensity(PIXCMAP *cmap, l_float32 rankval, l_int32 *pindex)
pixcmapGetRankIntensity()
l_ok pixcmapClear(PIXCMAP *cmap)
pixcmapClear()
PIXCMAP * pixcmapCreateRandom(l_int32 depth, l_int32 hasblack, l_int32 haswhite)
pixcmapCreateRandom()