136 #include <config_auto.h> 140 #include "allheaders.h" 142 static const l_uint32 rmask32[] = {0x0,
143 0x00000001, 0x00000003, 0x00000007, 0x0000000f,
144 0x0000001f, 0x0000003f, 0x0000007f, 0x000000ff,
145 0x000001ff, 0x000003ff, 0x000007ff, 0x00000fff,
146 0x00001fff, 0x00003fff, 0x00007fff, 0x0000ffff,
147 0x0001ffff, 0x0003ffff, 0x0007ffff, 0x000fffff,
148 0x001fffff, 0x003fffff, 0x007fffff, 0x00ffffff,
149 0x01ffffff, 0x03ffffff, 0x07ffffff, 0x0fffffff,
150 0x1fffffff, 0x3fffffff, 0x7fffffff, 0xffffffff};
155 LEPT_DLL l_float32 AlphaMaskBorderVals[2] = {0.0, 0.5};
158 #ifndef NO_CONSOLE_IO 159 #define DEBUG_SERIALIZE 0 195 l_int32 w, h, d, wpl, val;
196 l_uint32 *line, *data;
198 PROCNAME(
"pixGetPixel");
201 return ERROR_INT(
"&val not defined", procName, 1);
204 return ERROR_INT(
"pix not defined", procName, 1);
207 if (x < 0 || x >= w || y < 0 || y >= h)
210 wpl = pixGetWpl(pix);
212 line = data + y * wpl;
234 return ERROR_INT(
"depth must be in {1,2,4,8,16,32} bpp", procName, 1);
268 l_int32 w, h, d, wpl;
269 l_uint32 *line, *data;
271 PROCNAME(
"pixSetPixel");
274 return ERROR_INT(
"pix not defined", procName, 1);
276 if (x < 0 || x >= w || y < 0 || y >= h)
280 wpl = pixGetWpl(pix);
281 line = data + y * wpl;
306 return ERROR_INT(
"depth must be in {1,2,4,8,16,32} bpp", procName, 1);
337 l_int32 w, h, d, wpl;
338 l_uint32 *data, *ppixel;
340 PROCNAME(
"pixGetRGBPixel");
342 if (prval) *prval = 0;
343 if (pgval) *pgval = 0;
344 if (pbval) *pbval = 0;
345 if (!prval && !pgval && !pbval)
346 return ERROR_INT(
"no output requested", procName, 1);
348 return ERROR_INT(
"pix not defined", procName, 1);
351 return ERROR_INT(
"pix not 32 bpp", procName, 1);
352 if (x < 0 || x >= w || y < 0 || y >= h)
355 wpl = pixGetWpl(pix);
357 ppixel = data + y * wpl + x;
389 l_int32 w, h, d, wpl;
391 l_uint32 *data, *line;
393 PROCNAME(
"pixSetRGBPixel");
396 return ERROR_INT(
"pix not defined", procName, 1);
399 return ERROR_INT(
"pix not 32 bpp", procName, 1);
400 if (x < 0 || x >= w || y < 0 || y >= h)
403 wpl = pixGetWpl(pix);
405 line = data + y * wpl;
447 l_int32 w, h, d, index;
450 PROCNAME(
"pixSetCmapPixel");
453 return ERROR_INT(
"pix not defined", procName, 1);
454 if ((cmap = pixGetColormap(pix)) == NULL)
455 return ERROR_INT(
"pix is not colormapped", procName, 1);
457 if (d != 2 && d != 4 && d != 8)
458 return ERROR_INT(
"pix depth not 2, 4 or 8", procName, 1);
459 if (x < 0 || x >= w || y < 0 || y >= h)
466 return ERROR_INT(
"colormap is full", procName, 2);
493 l_int32 w, h, x, y, rval, gval, bval;
497 PROCNAME(
"pixGetRandomPixel");
502 if (!pval && !px && !py)
503 return ERROR_INT(
"no output requested", procName, 1);
505 return ERROR_INT(
"pix not defined", procName, 1);
514 if ((cmap = pixGetColormap(pix)) != NULL) {
544 l_int32 w, h, d, wpl;
545 l_uint32 *line, *data;
547 PROCNAME(
"pixClearPixel");
550 return ERROR_INT(
"pix not defined", procName, 1);
551 if (pixGetColormap(pix))
552 L_WARNING(
"cmapped: setting to 0 may not be intended\n", procName);
554 if (x < 0 || x >= w || y < 0 || y >= h)
557 wpl = pixGetWpl(pix);
559 line = data + y * wpl;
581 return ERROR_INT(
"depth must be in {1,2,4,8,16,32} bpp", procName, 1);
606 l_int32 w, h, d, wpl;
608 l_uint32 *line, *data;
610 PROCNAME(
"pixFlipPixel");
613 return ERROR_INT(
"pix not defined", procName, 1);
614 if (pixGetColormap(pix))
615 L_WARNING(
"cmapped: setting to 0 may not be intended\n", procName);
617 if (x < 0 || x >= w || y < 0 || y >= h)
621 wpl = pixGetWpl(pix);
622 line = data + y * wpl;
653 val = line[x] ^ 0xffffffff;
657 return ERROR_INT(
"depth must be in {1,2,4,8,16,32} bpp", procName, 1);
740 PROCNAME(
"pixGetBlackOrWhiteVal");
743 return ERROR_INT(
"&val not defined", procName, 1);
746 return ERROR_INT(
"pixs not defined", procName, 1);
748 return ERROR_INT(
"invalid op", procName, 1);
750 cmap = pixGetColormap(pixs);
751 d = pixGetDepth(pixs);
757 val = (d == 32) ? 0xffffff00 : (1 << d) - 1;
791 PROCNAME(
"pixClearAll");
794 return ERROR_INT(
"pix not defined", procName, 1);
796 memset(pix->
data, 0, 4LL * pix->
wpl * pix->
h);
822 PROCNAME(
"pixSetAll");
825 return ERROR_INT(
"pix not defined", procName, 1);
826 if ((cmap = pixGetColormap(pix)) != NULL) {
828 if (n < cmap->nalloc)
829 return ERROR_INT(
"cmap entry does not exist", procName, 1);
832 memset(pix->
data, 0xff, 4LL * pix->
wpl * pix->
h);
862 l_int32 d, spp, index;
867 PROCNAME(
"pixSetAllGray");
870 return ERROR_INT(
"pix not defined", procName, 1);
872 L_WARNING(
"grayval < 0; setting to 0\n", procName);
874 }
else if (grayval > 255) {
875 L_WARNING(
"grayval > 255; setting to 255\n", procName);
880 cmap = pixGetColormap(pix);
888 d = pixGetDepth(pix);
889 spp = pixGetSpp(pix);
900 }
else if (d == 16) {
901 grayval |= (grayval << 8);
903 }
else if (d == 32 && spp == 3) {
906 }
else if (d == 32 && spp == 4) {
913 L_ERROR(
"invalid depth: %d\n", procName, d);
954 l_int32 n, i, j, w, h, d, wpl, npix;
955 l_uint32 maxval, wordval;
956 l_uint32 *data, *line;
959 PROCNAME(
"pixSetAllArbitrary");
962 return ERROR_INT(
"pix not defined", procName, 1);
966 if ((cmap = pixGetColormap(pix)) != NULL) {
969 L_WARNING(
"index not in colormap; using last color\n", procName);
978 maxval = (1 << d) - 1;
980 L_WARNING(
"val = %d too large for depth; using maxval = %d\n",
981 procName, val, maxval);
989 for (j = 0; j < npix; j++)
990 wordval |= (val << (j * d));
991 wpl = pixGetWpl(pix);
993 for (i = 0; i < h; i++) {
994 line = data + i * wpl;
995 for (j = 0; j < wpl; j++) {
996 *(line + j) = wordval;
1027 PROCNAME(
"pixSetBlackOrWhite");
1030 return ERROR_INT(
"pix not defined", procName, 1);
1032 return ERROR_INT(
"invalid op", procName, 1);
1034 cmap = pixGetColormap(pixs);
1035 d = pixGetDepth(pixs);
1073 l_uint32 mask1, mask2;
1076 PROCNAME(
"pixSetComponentArbitrary");
1078 if (!pix || pixGetDepth(pix) != 32)
1079 return ERROR_INT(
"pix not defined or not 32 bpp", procName, 1);
1082 return ERROR_INT(
"invalid component", procName, 1);
1083 if (val < 0 || val > 255)
1084 return ERROR_INT(
"val not in [0 ... 255]", procName, 1);
1086 mask1 = ~(255 << (8 * (3 - comp)));
1087 mask2 = val << (8 * (3 - comp));
1088 nwords = pixGetHeight(pix) * pixGetWpl(pix);
1090 for (i = 0; i < nwords; i++) {
1123 PROCNAME(
"pixClearInRect");
1126 return ERROR_INT(
"pix not defined", procName, 1);
1128 return ERROR_INT(
"box not defined", procName, 1);
1156 l_int32 n, x, y, w, h;
1159 PROCNAME(
"pixSetInRect");
1162 return ERROR_INT(
"pix not defined", procName, 1);
1164 return ERROR_INT(
"box not defined", procName, 1);
1165 if ((cmap = pixGetColormap(pix)) != NULL) {
1167 if (n < cmap->nalloc)
1168 return ERROR_INT(
"cmap entry does not exist", procName, 1);
1199 l_int32 n, x, y, xstart, xend, ystart, yend, bw, bh, w, h, d, wpl, maxval;
1200 l_uint32 *data, *line;
1204 PROCNAME(
"pixSetInRectArbitrary");
1207 return ERROR_INT(
"pix not defined", procName, 1);
1209 return ERROR_INT(
"box not defined", procName, 1);
1211 if (d != 1 && d != 2 && d != 4 && d !=8 && d != 16 && d != 32)
1212 return ERROR_INT(
"depth must be in {1,2,4,8,16,32} bpp", procName, 1);
1213 if ((cmap = pixGetColormap(pix)) != NULL) {
1216 L_WARNING(
"index not in colormap; using last color\n", procName);
1221 maxval = (d == 32) ? 0xffffff00 : (1 << d) - 1;
1222 if (val > maxval) val = maxval;
1230 (d == 2 && val == 3) ||
1231 (d == 4 && val == 0xf) ||
1232 (d == 8 && val == 0xff) ||
1233 (d == 16 && val == 0xffff) ||
1234 (d == 32 && ((val ^ 0xffffff00) >> 8 == 0))) {
1241 return ERROR_INT(
"no overlap of box with image", procName, 1);
1243 xend = xstart + bw - 1;
1244 yend = ystart + bh - 1;
1247 wpl = pixGetWpl(pix);
1249 for (y = ystart; y <= yend; y++) {
1250 line = data + y * wpl;
1251 for (x = xstart; x <= xend; x++) {
1270 return ERROR_INT(
"depth not 2|4|8|16|32 bpp", procName, 1);
1301 l_int32 i, j, bx, by, bw, bh, w, h, wpls;
1302 l_int32 prval, pgval, pbval, rval, gval, bval;
1304 l_uint32 *datas, *lines;
1306 PROCNAME(
"pixBlendInRect");
1308 if (!pixs || pixGetDepth(pixs) != 32)
1309 return ERROR_INT(
"pixs not defined or not 32 bpp", procName, 1);
1314 wpls = pixGetWpl(pixs);
1316 for (i = 0; i < h; i++) {
1317 lines = datas + i * wpls;
1318 for (j = 0; j < w; j++) {
1319 val32 = *(lines + j);
1321 prval = (l_int32)((1. - fract) * prval + fract * rval);
1322 pgval = (l_int32)((1. - fract) * pgval + fract * gval);
1323 pbval = (l_int32)((1. - fract) * pbval + fract * bval);
1325 *(lines + j) = val32;
1332 for (i = 0; i < bh; i++) {
1333 if (by + i < 0 || by + i >= h)
continue;
1334 lines = datas + (by + i) * wpls;
1335 for (j = 0; j < bw; j++) {
1336 if (bx + j < 0 || bx + j >= w)
continue;
1337 val32 = *(lines + bx + j);
1339 prval = (l_int32)((1. - fract) * prval + fract * rval);
1340 pgval = (l_int32)((1. - fract) * pgval + fract * gval);
1341 pbval = (l_int32)((1. - fract) * pbval + fract * bval);
1343 *(lines + bx + j) = val32;
1385 l_int32 i, w, h, d, wpl, endbits, fullwords;
1387 l_uint32 *data, *pword;
1389 PROCNAME(
"pixSetPadBits");
1392 return ERROR_INT(
"pix not defined", procName, 1);
1399 wpl = pixGetWpl(pix);
1400 endbits = 32 - (((l_int64)w * d) % 32);
1403 fullwords = (1LL * w * d) / 32;
1404 mask = rmask32[endbits];
1408 for (i = 0; i < h; i++) {
1409 pword = data + i * wpl + fullwords;
1411 *pword = *pword & mask;
1413 *pword = *pword | mask;
1447 l_int32 i, w, h, d, wpl, endbits, fullwords;
1449 l_uint32 *data, *pword;
1451 PROCNAME(
"pixSetPadBitsBand");
1454 return ERROR_INT(
"pix not defined", procName, 1);
1463 return ERROR_INT(
"start y not in image", procName, 1);
1468 wpl = pixGetWpl(pix);
1469 endbits = 32 - (((l_int64)w * d) % 32);
1472 fullwords = (l_int64)w * d / 32;
1474 mask = rmask32[endbits];
1478 for (i = by; i < by + bh; i++) {
1479 pword = data + i * wpl + fullwords;
1481 *pword = *pword & mask;
1483 *pword = *pword | mask;
1523 PROCNAME(
"pixSetOrClearBorder");
1526 return ERROR_INT(
"pixs not defined", procName, 1);
1528 return ERROR_INT(
"op must be PIX_SET or PIX_CLR", procName, 1);
1532 pixRasterop(pixs, w - right, 0, right, h, op, NULL, 0, 0);
1534 pixRasterop(pixs, 0, h - bot, w, bot, op, NULL, 0, 0);
1570 l_int32 w, h, d, wpls, i, j, bstart, rstart;
1571 l_uint32 *datas, *lines;
1573 PROCNAME(
"pixSetBorderVal");
1576 return ERROR_INT(
"pixs not defined", procName, 1);
1578 if (d != 8 && d != 16 && d != 32)
1579 return ERROR_INT(
"depth must be 8, 16 or 32 bpp", procName, 1);
1582 wpls = pixGetWpl(pixs);
1585 for (i = 0; i < top; i++) {
1586 lines = datas + i * wpls;
1587 for (j = 0; j < w; j++)
1592 for (i = top; i < bstart; i++) {
1593 lines = datas + i * wpls;
1594 for (j = 0; j < left; j++)
1596 for (j = rstart; j < w; j++)
1599 for (i = bstart; i < h; i++) {
1600 lines = datas + i * wpls;
1601 for (j = 0; j < w; j++)
1604 }
else if (d == 16) {
1606 for (i = 0; i < top; i++) {
1607 lines = datas + i * wpls;
1608 for (j = 0; j < w; j++)
1613 for (i = top; i < bstart; i++) {
1614 lines = datas + i * wpls;
1615 for (j = 0; j < left; j++)
1617 for (j = rstart; j < w; j++)
1620 for (i = bstart; i < h; i++) {
1621 lines = datas + i * wpls;
1622 for (j = 0; j < w; j++)
1626 for (i = 0; i < top; i++) {
1627 lines = datas + i * wpls;
1628 for (j = 0; j < w; j++)
1633 for (i = top; i < bstart; i++) {
1634 lines = datas + i * wpls;
1635 for (j = 0; j < left; j++)
1637 for (j = rstart; j < w; j++)
1640 for (i = bstart; i < h; i++) {
1641 lines = datas + i * wpls;
1642 for (j = 0; j < w; j++)
1671 l_int32 w, h, d, i, j, xend, yend;
1673 PROCNAME(
"pixSetBorderRingVal");
1676 return ERROR_INT(
"pixs not defined", procName, 1);
1678 return ERROR_INT(
"dist must be > 0", procName, 1);
1680 if (w < 2 * dist + 1 || h < 2 * dist + 1)
1681 return ERROR_INT(
"ring doesn't exist", procName, 1);
1682 if (d < 32 && (val >= (1 << d)))
1683 return ERROR_INT(
"invalid pixel value", procName, 1);
1687 for (j = dist - 1; j <= xend; j++)
1689 for (j = dist - 1; j <= xend; j++)
1691 for (i = dist - 1; i <= yend; i++)
1693 for (i = dist - 1; i <= yend; i++)
1726 PROCNAME(
"pixSetMirroredBorder");
1729 return ERROR_INT(
"pixs not defined", procName, 1);
1732 for (j = 0; j < left; j++)
1734 pixs, left + j, top);
1735 for (j = 0; j < right; j++)
1737 pixs, w - right - 1 - j, top);
1738 for (i = 0; i < top; i++)
1741 for (i = 0; i < bot; i++)
1743 pixs, 0, h - bot - 1 - i);
1778 PROCNAME(
"pixCopyBorder");
1781 return (
PIX *)ERROR_PTR(
"pixs not defined", procName, pixd);
1785 L_WARNING(
"same: nothing to do\n", procName);
1788 return (
PIX *)ERROR_PTR(
"pixs and pixd sizes differ",
1793 return (
PIX *)ERROR_PTR(
"pixd not made", procName, pixd);
1827 PROCNAME(
"pixAddBorder");
1830 return (
PIX *)ERROR_PTR(
"pixs not defined", procName, NULL);
1872 PROCNAME(
"pixAddBlackOrWhiteBorder");
1875 return (
PIX *)ERROR_PTR(
"pixs not defined", procName, NULL);
1877 return (
PIX *)ERROR_PTR(
"invalid op", procName, NULL);
1924 l_int32 ws, hs, wd, hd, d, maxval, op;
1927 PROCNAME(
"pixAddBorderGeneral");
1930 return (
PIX *)ERROR_PTR(
"pixs not defined", procName, NULL);
1931 if (left < 0 || right < 0 || top < 0 || bot < 0)
1932 return (
PIX *)ERROR_PTR(
"negative border added!", procName, NULL);
1935 wd = ws + left + right;
1936 hd = hs + top + bot;
1937 if ((pixd =
pixCreate(wd, hd, d)) == NULL)
1938 return (
PIX *)ERROR_PTR(
"pixd not made", procName, NULL);
1939 pixCopyResolution(pixd, pixs);
1943 maxval = (d == 32) ? 0xffffff00 : (1 << d) - 1;
1947 else if (val >= maxval)
1952 pixRasterop(pixd, 0, 0, left, hd, op, NULL, 0, 0);
1953 pixRasterop(pixd, wd - right, 0, right, hd, op, NULL, 0, 0);
1955 pixRasterop(pixd, 0, hd - bot, wd, bot, op, NULL, 0, 0);
1975 PROCNAME(
"pixRemoveBorder");
1978 return (
PIX *)ERROR_PTR(
"pixs not defined", procName, NULL);
1999 l_int32 ws, hs, wd, hd, d;
2002 PROCNAME(
"pixRemoveBorderGeneral");
2005 return (
PIX *)ERROR_PTR(
"pixs not defined", procName, NULL);
2006 if (left < 0 || right < 0 || top < 0 || bot < 0)
2007 return (
PIX *)ERROR_PTR(
"negative border removed!", procName, NULL);
2010 wd = ws - left - right;
2011 hd = hs - top - bot;
2013 return (
PIX *)ERROR_PTR(
"width must be > 0", procName, NULL);
2015 return (
PIX *)ERROR_PTR(
"height must be > 0", procName, NULL);
2016 if ((pixd =
pixCreate(wd, hd, d)) == NULL)
2017 return (
PIX *)ERROR_PTR(
"pixd not made", procName, NULL);
2018 pixCopyResolution(pixd, pixs);
2023 if (pixGetDepth(pixs) == 32 && pixGetSpp(pixs) == 4)
2050 l_int32 w, h, top, bot, left, right, delta;
2052 PROCNAME(
"pixRemoveBorderToSize");
2055 return (
PIX *)ERROR_PTR(
"pixs not defined", procName, NULL);
2058 if ((wd <= 0 || wd >= w) && (hd <= 0 || hd >= h))
2061 left = right = (w - wd) / 2;
2062 delta = w - 2 * left - wd;
2064 top = bot = (h - hd) / 2;
2065 delta = h - hd - 2 * top;
2067 if (wd <= 0 || wd > w)
2069 else if (hd <= 0 || hd > h)
2110 PROCNAME(
"pixAddMirroredBorder");
2113 return (
PIX *)ERROR_PTR(
"pixs not defined", procName, NULL);
2115 if (left > w || right > w || top > h || bot > h)
2116 return (
PIX *)ERROR_PTR(
"border too large", procName, NULL);
2120 for (j = 0; j < left; j++)
2122 pixd, left + j, top);
2123 for (j = 0; j < right; j++)
2125 pixd, left + w - 1 - j, top);
2126 for (i = 0; i < top; i++)
2129 for (i = 0; i < bot; i++)
2131 pixd, 0, top + h - 1 - i);
2163 PROCNAME(
"pixAddRepeatedBorder");
2166 return (
PIX *)ERROR_PTR(
"pixs not defined", procName, NULL);
2168 if (left > w || right > w || top > h || bot > h)
2169 return (
PIX *)ERROR_PTR(
"border too large", procName, NULL);
2219 PROCNAME(
"pixAddMixedBorder");
2222 return (
PIX *)ERROR_PTR(
"pixs not defined", procName, NULL);
2224 if (left > w || right > w || top > h || bot > h)
2225 return (
PIX *)ERROR_PTR(
"border too large", procName, NULL);
2230 for (j = 0; j < left; j++)
2232 pixd, left + j, top);
2233 for (j = 0; j < right; j++)
2235 pixd, left + w - 1 - j, top);
2266 PROCNAME(
"pixAddContinuedBorder");
2269 return (
PIX *)ERROR_PTR(
"pixs not defined", procName, NULL);
2273 for (j = 0; j < left; j++)
2275 for (j = 0; j < right; j++)
2277 PIX_SRC, pixd, left + w - 1, top);
2278 for (i = 0; i < top; i++)
2280 for (i = 0; i < bot; i++)
2281 pixRasterop(pixd, 0, top + h + i, left + w + right, 1,
2282 PIX_SRC, pixd, 0, top + h - 1);
2308 PROCNAME(
"pixShiftAndTransferAlpha");
2311 return ERROR_INT(
"pixs and pixd not both defined", procName, 1);
2312 if (pixGetDepth(pixs) != 32 || pixGetSpp(pixs) != 4)
2313 return ERROR_INT(
"pixs not 32 bpp and 4 spp", procName, 1);
2314 if (pixGetDepth(pixd) != 32)
2315 return ERROR_INT(
"pixd not 32 bpp", procName, 1);
2317 if (shiftx == 0 && shifty == 0) {
2356 l_float32 scalefact;
2357 PIX *pix1, *pix2, *pixd;
2361 PROCNAME(
"pixDisplayLayersRGBA");
2364 return (
PIX *)ERROR_PTR(
"pixs not defined", procName, NULL);
2365 cmap = pixGetColormap(pixs);
2366 if (!cmap && !(pixGetDepth(pixs) == 32 && pixGetSpp(pixs) == 4))
2367 return (
PIX *)ERROR_PTR(
"pixs not cmap and not 32 bpp rgba",
2369 if ((w = pixGetWidth(pixs)) == 0)
2370 return (
PIX *)ERROR_PTR(
"pixs width 0 !!", procName, NULL);
2378 scalefact = (maxw == 0) ? 1.0 : L_MIN(1.0, (l_float32)(maxw) / w);
2379 width = (l_int32)(scalefact * w);
2427 l_int32 wr, wg, wb, hr, hg, hb, dr, dg, db;
2430 PROCNAME(
"pixCreateRGBImage");
2433 return (
PIX *)ERROR_PTR(
"pixr not defined", procName, NULL);
2435 return (
PIX *)ERROR_PTR(
"pixg not defined", procName, NULL);
2437 return (
PIX *)ERROR_PTR(
"pixb not defined", procName, NULL);
2441 if (dr != 8 || dg != 8 || db != 8)
2442 return (
PIX *)ERROR_PTR(
"input pix not all 8 bpp", procName, NULL);
2443 if (wr != wg || wr != wb)
2444 return (
PIX *)ERROR_PTR(
"widths not the same", procName, NULL);
2445 if (hr != hg || hr != hb)
2446 return (
PIX *)ERROR_PTR(
"heights not the same", procName, NULL);
2448 if ((pixd =
pixCreate(wr, hr, 32)) == NULL)
2449 return (
PIX *)ERROR_PTR(
"pixd not made", procName, NULL);
2450 pixCopyResolution(pixd, pixr);
2482 l_int32 i, j, w, h, wpls, wpld, val;
2483 l_uint32 *lines, *lined;
2484 l_uint32 *datas, *datad;
2487 PROCNAME(
"pixGetRGBComponent");
2490 return (
PIX *)ERROR_PTR(
"pixs not defined", procName, NULL);
2491 if (pixGetColormap(pixs))
2493 if (pixGetDepth(pixs) != 32)
2494 return (
PIX *)ERROR_PTR(
"pixs not 32 bpp", procName, NULL);
2497 return (
PIX *)ERROR_PTR(
"invalid comp", procName, NULL);
2500 if ((pixd =
pixCreate(w, h, 8)) == NULL)
2501 return (
PIX *)ERROR_PTR(
"pixd not made", procName, NULL);
2502 pixCopyResolution(pixd, pixs);
2503 wpls = pixGetWpl(pixs);
2504 wpld = pixGetWpl(pixd);
2507 for (i = 0; i < h; i++) {
2508 lines = datas + i * wpls;
2509 lined = datad + i * wpld;
2510 for (j = 0; j < w; j++) {
2543 l_int32 i, j, w, h, ws, hs, wd, hd;
2545 l_uint32 *lines, *lined;
2546 l_uint32 *datas, *datad;
2548 PROCNAME(
"pixSetRGBComponent");
2551 return ERROR_INT(
"pixd not defined", procName, 1);
2553 return ERROR_INT(
"pixs not defined", procName, 1);
2554 if (pixGetDepth(pixd) != 32)
2555 return ERROR_INT(
"pixd not 32 bpp", procName, 1);
2556 if (pixGetDepth(pixs) != 8)
2557 return ERROR_INT(
"pixs not 8 bpp", procName, 1);
2560 return ERROR_INT(
"invalid comp", procName, 1);
2563 if (ws != wd || hs != hd)
2564 L_WARNING(
"images sizes not equal\n", procName);
2571 wpls = pixGetWpl(pixs);
2572 wpld = pixGetWpl(pixd);
2573 for (i = 0; i < h; i++) {
2574 lines = datas + i * wpls;
2575 lined = datad + i * wpld;
2576 for (j = 0; j < w; j++) {
2603 l_int32 i, j, w, h, val, index, valid;
2605 l_uint32 *linec, *lined;
2606 l_uint32 *datac, *datad;
2611 PROCNAME(
"pixGetRGBComponentCmap");
2614 return (
PIX *)ERROR_PTR(
"pixs not defined", procName, NULL);
2615 if ((cmap = pixGetColormap(pixs)) == NULL)
2616 return (
PIX *)ERROR_PTR(
"pixs not cmapped", procName, NULL);
2618 return (
PIX *)ERROR_PTR(
"alpha in cmaps not supported", procName, NULL);
2620 return (
PIX *)ERROR_PTR(
"invalid comp", procName, NULL);
2623 if (pixGetDepth(pixs) == 8)
2630 return (
PIX *)ERROR_PTR(
"invalid colormap", procName, NULL);
2634 if ((pixd =
pixCreate(w, h, 8)) == NULL) {
2636 return (
PIX *)ERROR_PTR(
"pixd not made", procName, NULL);
2638 pixCopyResolution(pixd, pixs);
2639 wplc = pixGetWpl(pixc);
2640 wpld = pixGetWpl(pixd);
2645 for (i = 0; i < h; i++) {
2646 linec = datac + i * wplc;
2647 lined = datad + i * wpld;
2649 for (j = 0; j < w; j++) {
2651 val = cta[index].
red;
2655 for (j = 0; j < w; j++) {
2657 val = cta[index].
green;
2661 for (j = 0; j < w; j++) {
2663 val = cta[index].
blue;
2694 l_int32 i, j, w, h, ws, hs, wd, hd, val;
2696 l_uint32 *lines, *lined;
2697 l_uint32 *datas, *datad;
2699 PROCNAME(
"pixCopyRGBComponent");
2701 if (!pixd && pixGetDepth(pixd) != 32)
2702 return ERROR_INT(
"pixd not defined or not 32 bpp", procName, 1);
2703 if (!pixs && pixGetDepth(pixs) != 32)
2704 return ERROR_INT(
"pixs not defined or not 32 bpp", procName, 1);
2707 return ERROR_INT(
"invalid component", procName, 1);
2710 if (ws != wd || hs != hd)
2711 L_WARNING(
"images sizes not equal\n", procName);
2716 wpls = pixGetWpl(pixs);
2717 wpld = pixGetWpl(pixd);
2720 for (i = 0; i < h; i++) {
2721 lines = datas + i * wpls;
2722 lined = datad + i * wpld;
2723 for (j = 0; j < w; j++) {
2756 PROCNAME(
"composeRGBPixel");
2759 return ERROR_INT(
"&pixel not defined", procName, 1);
2761 *ppixel = ((l_uint32)rval << L_RED_SHIFT) |
2762 ((l_uint32)gval << L_GREEN_SHIFT) |
2763 ((l_uint32)bval << L_BLUE_SHIFT);
2789 PROCNAME(
"composeRGBAPixel");
2792 return ERROR_INT(
"&pixel not defined", procName, 1);
2794 *ppixel = ((l_uint32)rval << L_RED_SHIFT) |
2795 ((l_uint32)gval << L_GREEN_SHIFT) |
2796 ((l_uint32)bval << L_BLUE_SHIFT) |
2825 if (prval) *prval = (pixel >> L_RED_SHIFT) & 0xff;
2826 if (pgval) *pgval = (pixel >> L_GREEN_SHIFT) & 0xff;
2827 if (pbval) *pbval = (pixel >> L_BLUE_SHIFT) & 0xff;
2848 if (prval) *prval = (pixel >> L_RED_SHIFT) & 0xff;
2849 if (pgval) *pgval = (pixel >> L_GREEN_SHIFT) & 0xff;
2850 if (pbval) *pbval = (pixel >> L_BLUE_SHIFT) & 0xff;
2851 if (paval) *paval = (pixel >> L_ALPHA_SHIFT) & 0xff;
2866 l_int32 rval, gval, bval, val;
2869 if (type == L_CHOOSE_MIN) {
2870 val = L_MIN(rval, gval);
2871 val = L_MIN(val, bval);
2873 val = L_MAX(rval, gval);
2874 val = L_MAX(val, bval);
2907 PROCNAME(
"pixGetRGBLine");
2910 return ERROR_INT(
"pixs not defined", procName, 1);
2911 if (pixGetDepth(pixs) != 32)
2912 return ERROR_INT(
"pixs not 32 bpp", procName, 1);
2913 if (!bufr || !bufg || !bufb)
2914 return ERROR_INT(
"buffer not defined", procName, 1);
2917 if (row < 0 || row >= h)
2918 return ERROR_INT(
"row out of bounds", procName, 1);
2919 wpls = pixGetWpl(pixs);
2922 for (j = 0; j < w; j++) {
2957 PROCNAME(
"setLineDataVal");
2960 return ERROR_INT(
"line not defined", procName, 1);
2962 return ERROR_INT(
"j must be >= 0", procName, 1);
2963 if (d != 1 && d != 2 && d != 4 && d != 8 && d != 16 && d != 32)
2964 return ERROR_INT(
"invalid d", procName, 1);
3012 l_uint32 *datas, *datad;
3013 l_int32 i, j, h, wpl;
3017 PROCNAME(
"pixEndianByteSwapNew");
3026 return (
PIX *)ERROR_PTR(
"pixs not defined", procName, NULL);
3029 wpl = pixGetWpl(pixs);
3030 h = pixGetHeight(pixs);
3032 return (
PIX *)ERROR_PTR(
"pixd not made", procName, NULL);
3034 for (i = 0; i < h; i++) {
3035 for (j = 0; j < wpl; j++, datas++, datad++) {
3037 *datad = (word >> 24) |
3038 ((word >> 8) & 0x0000ff00) |
3039 ((word << 8) & 0x00ff0000) |
3077 l_int32 i, j, h, wpl;
3080 PROCNAME(
"pixEndianByteSwap");
3089 return ERROR_INT(
"pixs not defined", procName, 1);
3092 wpl = pixGetWpl(pixs);
3093 h = pixGetHeight(pixs);
3094 for (i = 0; i < h; i++) {
3095 for (j = 0; j < wpl; j++, data++) {
3097 *data = (word >> 24) |
3098 ((word >> 8) & 0x0000ff00) |
3099 ((word << 8) & 0x00ff0000) |
3139 PROCNAME(
"lineEndianByteSwap");
3141 if (!datad || !datas)
3142 return ERROR_INT(
"datad and datas not both defined", procName, 1);
3146 memcpy(datad, datas, 4 * wpl);
3151 for (j = 0; j < wpl; j++, datas++, datad++) {
3153 *datad = (word >> 24) |
3154 ((word >> 8) & 0x0000ff00) |
3155 ((word << 8) & 0x00ff0000) |
3187 l_uint32 *datas, *datad;
3188 l_int32 i, j, h, wpl;
3192 PROCNAME(
"pixEndianTwoByteSwapNew");
3201 return (
PIX *)ERROR_PTR(
"pixs not defined", procName, NULL);
3204 wpl = pixGetWpl(pixs);
3205 h = pixGetHeight(pixs);
3207 return (
PIX *)ERROR_PTR(
"pixd not made", procName, NULL);
3209 for (i = 0; i < h; i++) {
3210 for (j = 0; j < wpl; j++, datas++, datad++) {
3212 *datad = (word << 16) | (word >> 16);
3242 l_int32 i, j, h, wpl;
3245 PROCNAME(
"pixEndianTwoByteSwap");
3254 return ERROR_INT(
"pixs not defined", procName, 1);
3257 wpl = pixGetWpl(pixs);
3258 h = pixGetHeight(pixs);
3259 for (i = 0; i < h; i++) {
3260 for (j = 0; j < wpl; j++, data++) {
3262 *data = (word << 16) | (word >> 16);
3297 l_int32 w, h, d, wpl, i, j, rval, gval, bval;
3299 l_uint8 *line, *data;
3300 l_uint32 *rline, *rdata;
3302 PROCNAME(
"pixGetRasterData");
3304 if (pdata) *pdata = NULL;
3305 if (pnbytes) *pnbytes = 0;
3306 if (!pdata || !pnbytes)
3307 return ERROR_INT(
"&data and &nbytes not both defined", procName, 1);
3309 return ERROR_INT(
"pixs not defined", procName, 1);
3311 if (d != 1 && d != 2 && d != 4 && d != 8 && d != 16 && d != 32)
3312 return ERROR_INT(
"depth not in {1,2,4,8,16,32}", procName, 1);
3316 wpl = pixGetWpl(pixs);
3318 databpl = (w + 7) / 8;
3320 databpl = (w + 3) / 4;
3322 databpl = (w + 1) / 2;
3323 else if (d == 8 || d == 16)
3324 databpl = w * (d / 8);
3327 if ((data = (l_uint8 *)LEPT_CALLOC((
size_t)databpl * h,
sizeof(l_uint8)))
3329 return ERROR_INT(
"data not allocated", procName, 1);
3331 *pnbytes = (size_t)databpl * h;
3333 for (i = 0; i < h; i++) {
3334 rline = rdata + i * wpl;
3335 line = data + i * databpl;
3337 for (j = 0; j < databpl; j++)
3339 }
else if (d == 16) {
3340 for (j = 0; j < w; j++)
3343 for (j = 0; j < w; j++) {
3345 *(line + 3 * j) = rval;
3346 *(line + 3 * j + 1) = gval;
3347 *(line + 3 * j + 2) = bval;
3381 l_int32 w, h, maxdim, res;
3383 PROCNAME(
"pixInferResolution");
3386 return ERROR_INT(
"&res not defined", procName, 1);
3389 return ERROR_INT(
"pix not defined", procName, 1);
3390 if (longside <= 0.0)
3391 return ERROR_INT(
"longside not > 0", procName, 1);
3394 maxdim = L_MAX(w, h);
3395 res = (l_int32)(maxdim / longside + 0.5);
3396 res = L_MAX(res, 1);
3398 L_WARNING(
"low inferred resolution: %d ppi\n", procName, res);
3400 L_WARNING(
"high inferred resolution: %d ppi\n", procName, res);
3426 l_int32 w, h, wpl, i, j, alpha;
3427 l_uint32 *data, *line;
3429 PROCNAME(
"pixAlphaIsOpaque");
3432 return ERROR_INT(
"&opaque not defined", procName, 1);
3435 return ERROR_INT(
"&pix not defined", procName, 1);
3436 if (pixGetDepth(pix) != 32)
3437 return ERROR_INT(
"&pix not 32 bpp", procName, 1);
3438 if (pixGetSpp(pix) != 4)
3439 return ERROR_INT(
"&pix not 4 spp", procName, 1);
3442 wpl = pixGetWpl(pix);
3444 for (i = 0; i < h; i++) {
3445 line = data + i * wpl;
3446 for (j = 0; j < w; j++) {
3494 PROCNAME(
"pixSetupByteProcessing");
3498 if (!pix || pixGetDepth(pix) != 8)
3499 return (l_uint8 **)ERROR_PTR(
"pix not defined or not 8 bpp",
3504 if (pixGetColormap(pix))
3505 return (l_uint8 **)ERROR_PTR(
"pix has colormap", procName, NULL);
3529 PROCNAME(
"pixCleanupByteProcessing");
3532 return ERROR_INT(
"pix not defined", procName, 1);
3534 return ERROR_INT(
"lineptrs not defined", procName, 1);
3537 LEPT_FREE(lineptrs);
3571 val1 = L_MAX(0.0, L_MIN(1.0, val1));
3572 val2 = L_MAX(0.0, L_MIN(1.0, val2));
3573 AlphaMaskBorderVals[0] = val1;
3574 AlphaMaskBorderVals[1] = val2;
l_ok pixSetPadBitsBand(PIX *pix, l_int32 by, l_int32 bh, l_int32 val)
pixSetPadBitsBand()
l_ok pixCopyRGBComponent(PIX *pixd, PIX *pixs, l_int32 comp)
pixCopyRGBComponent()
l_int32 lineEndianByteSwap(l_uint32 *datad, l_uint32 *datas, l_int32 wpl)
lineEndianByteSwap()
l_ok pixSetRGBPixel(PIX *pix, l_int32 x, l_int32 y, l_int32 rval, l_int32 gval, l_int32 bval)
pixSetRGBPixel()
PIX * pixAddMixedBorder(PIX *pixs, l_int32 left, l_int32 right, l_int32 top, l_int32 bot)
pixAddMixedBorder()
PIX * pixRemoveColormap(PIX *pixs, l_int32 type)
pixRemoveColormap()
l_ok pixSetRGBComponent(PIX *pixd, PIX *pixs, l_int32 comp)
pixSetRGBComponent()
l_ok pixCleanupByteProcessing(PIX *pix, l_uint8 **lineptrs)
pixCleanupByteProcessing()
PIX * pixConvertTo32(PIX *pixs)
pixConvertTo32()
PIX * pixRemoveBorderGeneral(PIX *pixs, l_int32 left, l_int32 right, l_int32 top, l_int32 bot)
pixRemoveBorderGeneral()
PIX * pixCreateTemplate(const PIX *pixs)
pixCreateTemplate()
l_ok pixSetComponentArbitrary(PIX *pix, l_int32 comp, l_int32 val)
pixSetComponentArbitrary()
void extractRGBAValues(l_uint32 pixel, l_int32 *prval, l_int32 *pgval, l_int32 *pbval, l_int32 *paval)
extractRGBAValues()
l_ok pixSetInRectArbitrary(PIX *pix, BOX *box, l_uint32 val)
pixSetInRectArbitrary()
PIXA * pixaCreate(l_int32 n)
pixaCreate()
void setPixelLow(l_uint32 *line, l_int32 x, l_int32 depth, l_uint32 val)
setPixelLow()
l_ok pixRasterop(PIX *pixd, l_int32 dx, l_int32 dy, l_int32 dw, l_int32 dh, l_int32 op, PIX *pixs, l_int32 sx, l_int32 sy)
pixRasterop()
l_ok pixGetRasterData(PIX *pixs, l_uint8 **pdata, size_t *pnbytes)
pixGetRasterData()
PIX * pixCopy(PIX *pixd, const PIX *pixs)
pixCopy()
PIX * pixConvertTo8(PIX *pixs, l_int32 cmapflag)
pixConvertTo8()
void ** pixGetLinePtrs(PIX *pix, l_int32 *psize)
pixGetLinePtrs()
l_ok pixShiftAndTransferAlpha(PIX *pixd, PIX *pixs, l_float32 shiftx, l_float32 shifty)
pixShiftAndTransferAlpha()
void lept_stderr(const char *fmt,...)
lept_stderr()
BOX * boxClipToRectangle(BOX *box, l_int32 wi, l_int32 hi)
boxClipToRectangle()
PIX * pixCreate(l_int32 width, l_int32 height, l_int32 depth)
pixCreate()
l_ok pixSetAll(PIX *pix)
pixSetAll()
#define SET_DATA_QBIT(pdata, n, val)
PIX * pixAddMirroredBorder(PIX *pixs, l_int32 left, l_int32 right, l_int32 top, l_int32 bot)
pixAddMirroredBorder()
l_uint32 * pixGetData(PIX *pix)
pixGetData()
PIX * pixAddBlackOrWhiteBorder(PIX *pixs, l_int32 left, l_int32 right, l_int32 top, l_int32 bot, l_int32 op)
pixAddBlackOrWhiteBorder()
#define GET_DATA_BIT(pdata, n)
l_ok setLineDataVal(l_uint32 *line, l_int32 j, l_int32 d, l_uint32 val)
setLineDataVal()
l_ok pixClearInRect(PIX *pix, BOX *box)
pixClearInRect()
l_ok pixSetAllGray(PIX *pix, l_int32 grayval)
pixSetAllGray()
l_ok pixSetOrClearBorder(PIX *pixs, l_int32 left, l_int32 right, l_int32 top, l_int32 bot, l_int32 op)
pixSetOrClearBorder()
PIX * pixGetRGBComponent(PIX *pixs, l_int32 comp)
pixGetRGBComponent()
PIX * pixAddBorder(PIX *pixs, l_int32 npix, l_uint32 val)
pixAddBorder()
l_ok pixGetRandomPixel(PIX *pix, l_uint32 *pval, l_int32 *px, l_int32 *py)
pixGetRandomPixel()
#define SET_DATA_DIBIT(pdata, n, val)
l_ok pixSetAllArbitrary(PIX *pix, l_uint32 val)
pixSetAllArbitrary()
l_ok pixSetBorderVal(PIX *pixs, l_int32 left, l_int32 right, l_int32 top, l_int32 bot, l_uint32 val)
pixSetBorderVal()
#define CLEAR_DATA_BIT(pdata, n)
PIX * pixEndianTwoByteSwapNew(PIX *pixs)
pixEndianTwoByteSwapNew()
PIX * pixAlphaBlendUniform(PIX *pixs, l_uint32 color)
pixAlphaBlendUniform()
PIX * pixRemoveBorder(PIX *pixs, l_int32 npix)
pixRemoveBorder()
l_ok pixaAddPix(PIXA *pixa, PIX *pix, l_int32 copyflag)
pixaAddPix()
l_uint8 ** pixSetupByteProcessing(PIX *pix, l_int32 *pw, l_int32 *ph)
pixSetupByteProcessing()
l_ok pixFlipPixel(PIX *pix, l_int32 x, l_int32 y)
pixFlipPixel()
l_ok pixClearPixel(PIX *pix, l_int32 x, l_int32 y)
pixClearPixel()
#define CLEAR_DATA_DIBIT(pdata, n)
l_ok pixClearAll(PIX *pix)
pixClearAll()
l_ok pixSetCmapPixel(PIX *pix, l_int32 x, l_int32 y, l_int32 rval, l_int32 gval, l_int32 bval)
pixSetCmapPixel()
l_ok pixSetBorderRingVal(PIX *pixs, l_int32 dist, l_uint32 val)
pixSetBorderRingVal()
l_ok pixSetPixel(PIX *pix, l_int32 x, l_int32 y, l_uint32 val)
pixSetPixel()
PIX * pixaDisplayTiledInRows(PIXA *pixa, l_int32 outdepth, l_int32 maxwidth, l_float32 scalefactor, l_int32 background, l_int32 spacing, l_int32 border)
pixaDisplayTiledInRows()
l_ok pixcmapGetColor(PIXCMAP *cmap, l_int32 index, l_int32 *prval, l_int32 *pgval, l_int32 *pbval)
pixcmapGetColor()
l_int32 extractMinMaxComponent(l_uint32 pixel, l_int32 type)
extractMinMaxComponent()
l_ok pixEndianByteSwap(PIX *pixs)
pixEndianByteSwap()
l_ok composeRGBAPixel(l_int32 rval, l_int32 gval, l_int32 bval, l_int32 aval, l_uint32 *ppixel)
composeRGBAPixel()
#define SET_DATA_BYTE(pdata, n, val)
l_ok pixcmapAddNewColor(PIXCMAP *cmap, l_int32 rval, l_int32 gval, l_int32 bval, l_int32 *pindex)
pixcmapAddNewColor()
l_ok pixSetPadBits(PIX *pix, l_int32 val)
pixSetPadBits()
#define GET_DATA_QBIT(pdata, n)
l_ok pixSetBlackOrWhite(PIX *pixs, l_int32 op)
pixSetBlackOrWhite()
l_ok pixEndianTwoByteSwap(PIX *pixs)
pixEndianTwoByteSwap()
#define CLEAR_DATA_QBIT(pdata, n)
#define GET_DATA_BYTE(pdata, n)
#define SET_DATA_BIT_VAL(pdata, n, val)
PIX * pixCreateRGBImage(PIX *pixr, PIX *pixg, PIX *pixb)
pixCreateRGBImage()
PIX * pixAddContinuedBorder(PIX *pixs, l_int32 left, l_int32 right, l_int32 top, l_int32 bot)
pixAddContinuedBorder()
PIX * pixClone(PIX *pixs)
pixClone()
void pixDestroy(PIX **ppix)
pixDestroy()
l_ok pixcmapAddNearestColor(PIXCMAP *cmap, l_int32 rval, l_int32 gval, l_int32 bval, l_int32 *pindex)
pixcmapAddNearestColor()
l_ok pixGetRGBLine(PIX *pixs, l_int32 row, l_uint8 *bufr, l_uint8 *bufg, l_uint8 *bufb)
pixGetRGBLine()
PIX * pixGetRGBComponentCmap(PIX *pixs, l_int32 comp)
pixGetRGBComponentCmap()
l_ok pixGetBlackOrWhiteVal(PIX *pixs, l_int32 op, l_uint32 *pval)
pixGetBlackOrWhiteVal()
l_ok pixcmapIsValid(const PIXCMAP *cmap, PIX *pix, l_int32 *pvalid)
pixcmapIsValid()
l_ok pixGetPixel(PIX *pix, l_int32 x, l_int32 y, l_uint32 *pval)
pixGetPixel()
PIX * pixEndianByteSwapNew(PIX *pixs)
pixEndianByteSwapNew()
l_ok pixGetRGBPixel(PIX *pix, l_int32 x, l_int32 y, l_int32 *prval, l_int32 *pgval, l_int32 *pbval)
pixGetRGBPixel()
l_ok pixGetDimensions(const PIX *pix, l_int32 *pw, l_int32 *ph, l_int32 *pd)
pixGetDimensions()
PIX * pixAddRepeatedBorder(PIX *pixs, l_int32 left, l_int32 right, l_int32 top, l_int32 bot)
pixAddRepeatedBorder()
l_ok pixSetMirroredBorder(PIX *pixs, l_int32 left, l_int32 right, l_int32 top, l_int32 bot)
pixSetMirroredBorder()
void l_setAlphaMaskBorder(l_float32 val1, l_float32 val2)
l_setAlphaMaskBorder()
l_ok pixcmapAddBlackOrWhite(PIXCMAP *cmap, l_int32 color, l_int32 *pindex)
pixcmapAddBlackOrWhite()
#define GET_DATA_TWO_BYTES(pdata, n)
#define GET_DATA_DIBIT(pdata, n)
l_ok pixInferResolution(PIX *pix, l_float32 longside, l_int32 *pres)
pixInferResolution()
PIX * pixDisplayLayersRGBA(PIX *pixs, l_uint32 val, l_int32 maxw)
pixDisplayLayersRGBA()
l_ok pixCopyColormap(PIX *pixd, const PIX *pixs)
pixCopyColormap()
l_ok pixAlphaIsOpaque(PIX *pix, l_int32 *popaque)
pixAlphaIsOpaque()
void boxDestroy(BOX **pbox)
boxDestroy()
l_int32 pixcmapGetCount(const PIXCMAP *cmap)
pixcmapGetCount()
PIX * pixRemoveBorderToSize(PIX *pixs, l_int32 wd, l_int32 hd)
pixRemoveBorderToSize()
l_ok composeRGBPixel(l_int32 rval, l_int32 gval, l_int32 bval, l_uint32 *ppixel)
composeRGBPixel()
l_ok pixCopySpp(PIX *pixd, const PIX *pixs)
pixCopySpp()
l_int32 pixSizesEqual(const PIX *pix1, const PIX *pix2)
pixSizesEqual()
l_ok boxGetGeometry(BOX *box, l_int32 *px, l_int32 *py, l_int32 *pw, l_int32 *ph)
boxGetGeometry()
#define SET_DATA_TWO_BYTES(pdata, n, val)
void pixaDestroy(PIXA **ppixa)
pixaDestroy()
PIX * pixCopyBorder(PIX *pixd, PIX *pixs, l_int32 left, l_int32 right, l_int32 top, l_int32 bot)
pixCopyBorder()
l_ok pixSetInRect(PIX *pix, BOX *box)
pixSetInRect()
void extractRGBValues(l_uint32 pixel, l_int32 *prval, l_int32 *pgval, l_int32 *pbval)
extractRGBValues()
l_ok pixBlendInRect(PIX *pixs, BOX *box, l_uint32 val, l_float32 fract)
pixBlendInRect()
#define SET_DATA_BIT(pdata, n)
PIX * pixAddBorderGeneral(PIX *pixs, l_int32 left, l_int32 right, l_int32 top, l_int32 bot, l_uint32 val)
pixAddBorderGeneral()