Leptonica  1.82.0
Image processing and image analysis suite
pix2.c
Go to the documentation of this file.
1 /*====================================================================*
2  - Copyright (C) 2001 Leptonica. All rights reserved.
3  -
4  - Redistribution and use in source and binary forms, with or without
5  - modification, are permitted provided that the following conditions
6  - are met:
7  - 1. Redistributions of source code must retain the above copyright
8  - notice, this list of conditions and the following disclaimer.
9  - 2. Redistributions in binary form must reproduce the above
10  - copyright notice, this list of conditions and the following
11  - disclaimer in the documentation and/or other materials
12  - provided with the distribution.
13  -
14  - THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
15  - ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
16  - LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
17  - A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL ANY
18  - CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
19  - EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
20  - PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
21  - PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
22  - OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
23  - NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
24  - SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
25  *====================================================================*/
26 
135 #ifdef HAVE_CONFIG_H
136 #include <config_auto.h>
137 #endif /* HAVE_CONFIG_H */
138 
139 #include <string.h>
140 #include "allheaders.h"
141 
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};
151 
152  /* This is a global that determines the default 8 bpp alpha mask values
153  * for rings at distance 1 and 2 from the border. Declare extern
154  * to use. To change the values, use l_setAlphaMaskBorder(). */
155 LEPT_DLL l_float32 AlphaMaskBorderVals[2] = {0.0, 0.5};
156 
157 
158 #ifndef NO_CONSOLE_IO
159 #define DEBUG_SERIALIZE 0
160 #endif /* ~NO_CONSOLE_IO */
161 
162 
163 /*-------------------------------------------------------------*
164  * Pixel poking *
165  *-------------------------------------------------------------*/
189 l_ok
191  l_int32 x,
192  l_int32 y,
193  l_uint32 *pval)
194 {
195 l_int32 w, h, d, wpl, val;
196 l_uint32 *line, *data;
197 
198  PROCNAME("pixGetPixel");
199 
200  if (!pval)
201  return ERROR_INT("&val not defined", procName, 1);
202  *pval = 0;
203  if (!pix)
204  return ERROR_INT("pix not defined", procName, 1);
205 
206  pixGetDimensions(pix, &w, &h, &d);
207  if (x < 0 || x >= w || y < 0 || y >= h)
208  return 2;
209 
210  wpl = pixGetWpl(pix);
211  data = pixGetData(pix);
212  line = data + y * wpl;
213  switch (d)
214  {
215  case 1:
216  val = GET_DATA_BIT(line, x);
217  break;
218  case 2:
219  val = GET_DATA_DIBIT(line, x);
220  break;
221  case 4:
222  val = GET_DATA_QBIT(line, x);
223  break;
224  case 8:
225  val = GET_DATA_BYTE(line, x);
226  break;
227  case 16:
228  val = GET_DATA_TWO_BYTES(line, x);
229  break;
230  case 32:
231  val = line[x];
232  break;
233  default:
234  return ERROR_INT("depth must be in {1,2,4,8,16,32} bpp", procName, 1);
235  }
236 
237  *pval = val;
238  return 0;
239 }
240 
241 
262 l_ok
264  l_int32 x,
265  l_int32 y,
266  l_uint32 val)
267 {
268 l_int32 w, h, d, wpl;
269 l_uint32 *line, *data;
270 
271  PROCNAME("pixSetPixel");
272 
273  if (!pix)
274  return ERROR_INT("pix not defined", procName, 1);
275  pixGetDimensions(pix, &w, &h, &d);
276  if (x < 0 || x >= w || y < 0 || y >= h)
277  return 2;
278 
279  data = pixGetData(pix);
280  wpl = pixGetWpl(pix);
281  line = data + y * wpl;
282  switch (d)
283  {
284  case 1:
285  if (val)
286  SET_DATA_BIT(line, x);
287  else
288  CLEAR_DATA_BIT(line, x);
289  break;
290  case 2:
291  SET_DATA_DIBIT(line, x, val);
292  break;
293  case 4:
294  SET_DATA_QBIT(line, x, val);
295  break;
296  case 8:
297  SET_DATA_BYTE(line, x, val);
298  break;
299  case 16:
300  SET_DATA_TWO_BYTES(line, x, val);
301  break;
302  case 32:
303  line[x] = val;
304  break;
305  default:
306  return ERROR_INT("depth must be in {1,2,4,8,16,32} bpp", procName, 1);
307  }
308 
309  return 0;
310 }
311 
312 
329 l_ok
331  l_int32 x,
332  l_int32 y,
333  l_int32 *prval,
334  l_int32 *pgval,
335  l_int32 *pbval)
336 {
337 l_int32 w, h, d, wpl;
338 l_uint32 *data, *ppixel;
339 
340  PROCNAME("pixGetRGBPixel");
341 
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);
347  if (!pix)
348  return ERROR_INT("pix not defined", procName, 1);
349  pixGetDimensions(pix, &w, &h, &d);
350  if (d != 32)
351  return ERROR_INT("pix not 32 bpp", procName, 1);
352  if (x < 0 || x >= w || y < 0 || y >= h)
353  return 2;
354 
355  wpl = pixGetWpl(pix);
356  data = pixGetData(pix);
357  ppixel = data + y * wpl + x;
358  if (prval) *prval = GET_DATA_BYTE(ppixel, COLOR_RED);
359  if (pgval) *pgval = GET_DATA_BYTE(ppixel, COLOR_GREEN);
360  if (pbval) *pbval = GET_DATA_BYTE(ppixel, COLOR_BLUE);
361  return 0;
362 }
363 
364 
381 l_ok
383  l_int32 x,
384  l_int32 y,
385  l_int32 rval,
386  l_int32 gval,
387  l_int32 bval)
388 {
389 l_int32 w, h, d, wpl;
390 l_uint32 pixel;
391 l_uint32 *data, *line;
392 
393  PROCNAME("pixSetRGBPixel");
394 
395  if (!pix)
396  return ERROR_INT("pix not defined", procName, 1);
397  pixGetDimensions(pix, &w, &h, &d);
398  if (d != 32)
399  return ERROR_INT("pix not 32 bpp", procName, 1);
400  if (x < 0 || x >= w || y < 0 || y >= h)
401  return 2;
402 
403  wpl = pixGetWpl(pix);
404  data = pixGetData(pix);
405  line = data + y * wpl;
406  composeRGBPixel(rval, gval, bval, &pixel);
407  *(line + x) = pixel;
408  return 0;
409 }
410 
411 
439 l_ok
441  l_int32 x,
442  l_int32 y,
443  l_int32 rval,
444  l_int32 gval,
445  l_int32 bval)
446 {
447 l_int32 w, h, d, index;
448 PIXCMAP *cmap;
449 
450  PROCNAME("pixSetCmapPixel");
451 
452  if (!pix)
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);
456  pixGetDimensions(pix, &w, &h, &d);
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)
460  return 2;
461 
462  if (d == 8) { /* always add */
463  pixcmapAddNearestColor(cmap, rval, gval, bval, &index);
464  } else { /* d < 8 */
465  if (pixcmapAddNewColor(cmap, rval, gval, bval, &index) == 2)
466  return ERROR_INT("colormap is full", procName, 2);
467  }
468  pixSetPixel(pix, x, y, index);
469  return 0;
470 }
471 
472 
487 l_ok
489  l_uint32 *pval,
490  l_int32 *px,
491  l_int32 *py)
492 {
493 l_int32 w, h, x, y, rval, gval, bval;
494 l_uint32 val;
495 PIXCMAP *cmap;
496 
497  PROCNAME("pixGetRandomPixel");
498 
499  if (pval) *pval = 0;
500  if (px) *px = 0;
501  if (py) *py = 0;
502  if (!pval && !px && !py)
503  return ERROR_INT("no output requested", procName, 1);
504  if (!pix)
505  return ERROR_INT("pix not defined", procName, 1);
506 
507  pixGetDimensions(pix, &w, &h, NULL);
508  x = rand() % w;
509  y = rand() % h;
510  if (px) *px = x;
511  if (py) *py = y;
512  if (pval) {
513  pixGetPixel(pix, x, y, &val);
514  if ((cmap = pixGetColormap(pix)) != NULL) {
515  pixcmapGetColor(cmap, val, &rval, &gval, &bval);
516  composeRGBPixel(rval, gval, bval, pval);
517  } else {
518  *pval = val;
519  }
520  }
521 
522  return 0;
523 }
524 
525 
539 l_ok
541  l_int32 x,
542  l_int32 y)
543 {
544 l_int32 w, h, d, wpl;
545 l_uint32 *line, *data;
546 
547  PROCNAME("pixClearPixel");
548 
549  if (!pix)
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);
553  pixGetDimensions(pix, &w, &h, &d);
554  if (x < 0 || x >= w || y < 0 || y >= h)
555  return 2;
556 
557  wpl = pixGetWpl(pix);
558  data = pixGetData(pix);
559  line = data + y * wpl;
560  switch (d)
561  {
562  case 1:
563  CLEAR_DATA_BIT(line, x);
564  break;
565  case 2:
566  CLEAR_DATA_DIBIT(line, x);
567  break;
568  case 4:
569  CLEAR_DATA_QBIT(line, x);
570  break;
571  case 8:
572  SET_DATA_BYTE(line, x, 0);
573  break;
574  case 16:
575  SET_DATA_TWO_BYTES(line, x, 0);
576  break;
577  case 32:
578  line[x] = 0;
579  break;
580  default:
581  return ERROR_INT("depth must be in {1,2,4,8,16,32} bpp", procName, 1);
582  }
583 
584  return 0;
585 }
586 
587 
601 l_ok
603  l_int32 x,
604  l_int32 y)
605 {
606 l_int32 w, h, d, wpl;
607 l_uint32 val;
608 l_uint32 *line, *data;
609 
610  PROCNAME("pixFlipPixel");
611 
612  if (!pix)
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);
616  pixGetDimensions(pix, &w, &h, &d);
617  if (x < 0 || x >= w || y < 0 || y >= h)
618  return 2;
619 
620  data = pixGetData(pix);
621  wpl = pixGetWpl(pix);
622  line = data + y * wpl;
623  switch (d)
624  {
625  case 1:
626  val = GET_DATA_BIT(line, x);
627  if (val)
628  CLEAR_DATA_BIT(line, x);
629  else
630  SET_DATA_BIT(line, x);
631  break;
632  case 2:
633  val = GET_DATA_DIBIT(line, x);
634  val ^= 0x3;
635  SET_DATA_DIBIT(line, x, val);
636  break;
637  case 4:
638  val = GET_DATA_QBIT(line, x);
639  val ^= 0xf;
640  SET_DATA_QBIT(line, x, val);
641  break;
642  case 8:
643  val = GET_DATA_BYTE(line, x);
644  val ^= 0xff;
645  SET_DATA_BYTE(line, x, val);
646  break;
647  case 16:
648  val = GET_DATA_TWO_BYTES(line, x);
649  val ^= 0xffff;
650  SET_DATA_TWO_BYTES(line, x, val);
651  break;
652  case 32:
653  val = line[x] ^ 0xffffffff;
654  line[x] = val;
655  break;
656  default:
657  return ERROR_INT("depth must be in {1,2,4,8,16,32} bpp", procName, 1);
658  }
659 
660  return 0;
661 }
662 
663 
678 void
679 setPixelLow(l_uint32 *line,
680  l_int32 x,
681  l_int32 depth,
682  l_uint32 val)
683 {
684  switch (depth)
685  {
686  case 1:
687  if (val)
688  SET_DATA_BIT(line, x);
689  else
690  CLEAR_DATA_BIT(line, x);
691  break;
692  case 2:
693  SET_DATA_DIBIT(line, x, val);
694  break;
695  case 4:
696  SET_DATA_QBIT(line, x, val);
697  break;
698  case 8:
699  SET_DATA_BYTE(line, x, val);
700  break;
701  case 16:
702  SET_DATA_TWO_BYTES(line, x, val);
703  break;
704  case 32:
705  line[x] = val;
706  break;
707  default:
708  lept_stderr("illegal depth in setPixelLow()\n");
709  }
710 }
711 
712 
713 /*-------------------------------------------------------------*
714  * Find black or white value *
715  *-------------------------------------------------------------*/
732 l_ok
734  l_int32 op,
735  l_uint32 *pval)
736 {
737 l_int32 d, val;
738 PIXCMAP *cmap;
739 
740  PROCNAME("pixGetBlackOrWhiteVal");
741 
742  if (!pval)
743  return ERROR_INT("&val not defined", procName, 1);
744  *pval = 0;
745  if (!pixs)
746  return ERROR_INT("pixs not defined", procName, 1);
747  if (op != L_GET_BLACK_VAL && op != L_GET_WHITE_VAL)
748  return ERROR_INT("invalid op", procName, 1);
749 
750  cmap = pixGetColormap(pixs);
751  d = pixGetDepth(pixs);
752  if (!cmap) {
753  if ((d == 1 && op == L_GET_WHITE_VAL) ||
754  (d > 1 && op == L_GET_BLACK_VAL)) { /* min val */
755  val = 0;
756  } else { /* max val */
757  val = (d == 32) ? 0xffffff00 : (1 << d) - 1;
758  }
759  } else { /* handle colormap */
760  if (op == L_GET_BLACK_VAL)
761  pixcmapAddBlackOrWhite(cmap, 0, &val);
762  else /* L_GET_WHITE_VAL */
763  pixcmapAddBlackOrWhite(cmap, 1, &val);
764  }
765  *pval = val;
766 
767  return 0;
768 }
769 
770 
771 /*-------------------------------------------------------------*
772  * Full image clear/set/set-to-arbitrary-value/invert *
773  *-------------------------------------------------------------*/
788 l_ok
790 {
791  PROCNAME("pixClearAll");
792 
793  if (!pix)
794  return ERROR_INT("pix not defined", procName, 1);
795 
796  memset(pix->data, 0, 4LL * pix->wpl * pix->h);
797  return 0;
798 }
799 
800 
816 l_ok
818 {
819 l_int32 n;
820 PIXCMAP *cmap;
821 
822  PROCNAME("pixSetAll");
823 
824  if (!pix)
825  return ERROR_INT("pix not defined", procName, 1);
826  if ((cmap = pixGetColormap(pix)) != NULL) {
827  n = pixcmapGetCount(cmap);
828  if (n < cmap->nalloc) /* cmap is not full */
829  return ERROR_INT("cmap entry does not exist", procName, 1);
830  }
831 
832  memset(pix->data, 0xff, 4LL * pix->wpl * pix->h);
833  return 0;
834 }
835 
836 
858 l_ok
860  l_int32 grayval)
861 {
862 l_int32 d, spp, index;
863 l_uint32 val32;
864 PIX *alpha;
865 PIXCMAP *cmap;
866 
867  PROCNAME("pixSetAllGray");
868 
869  if (!pix)
870  return ERROR_INT("pix not defined", procName, 1);
871  if (grayval < 0) {
872  L_WARNING("grayval < 0; setting to 0\n", procName);
873  grayval = 0;
874  } else if (grayval > 255) {
875  L_WARNING("grayval > 255; setting to 255\n", procName);
876  grayval = 255;
877  }
878 
879  /* Handle the colormap case */
880  cmap = pixGetColormap(pix);
881  if (cmap) {
882  pixcmapAddNearestColor(cmap, grayval, grayval, grayval, &index);
883  pixSetAllArbitrary(pix, index);
884  return 0;
885  }
886 
887  /* Non-cmapped */
888  d = pixGetDepth(pix);
889  spp = pixGetSpp(pix);
890  if (d == 1) {
891  if (grayval < 128) /* black */
892  pixSetAll(pix);
893  else
894  pixClearAll(pix); /* white */
895  } else if (d < 8) {
896  grayval >>= 8 - d;
897  pixSetAllArbitrary(pix, grayval);
898  } else if (d == 8) {
899  pixSetAllArbitrary(pix, grayval);
900  } else if (d == 16) {
901  grayval |= (grayval << 8);
902  pixSetAllArbitrary(pix, grayval);
903  } else if (d == 32 && spp == 3) {
904  composeRGBPixel(grayval, grayval, grayval, &val32);
905  pixSetAllArbitrary(pix, val32);
906  } else if (d == 32 && spp == 4) {
907  alpha = pixGetRGBComponent(pix, L_ALPHA_CHANNEL);
908  composeRGBPixel(grayval, grayval, grayval, &val32);
909  pixSetAllArbitrary(pix, val32);
910  pixSetRGBComponent(pix, alpha, L_ALPHA_CHANNEL);
911  pixDestroy(&alpha);
912  } else {
913  L_ERROR("invalid depth: %d\n", procName, d);
914  return 1;
915  }
916 
917  return 0;
918 }
919 
920 
950 l_ok
952  l_uint32 val)
953 {
954 l_int32 n, i, j, w, h, d, wpl, npix;
955 l_uint32 maxval, wordval;
956 l_uint32 *data, *line;
957 PIXCMAP *cmap;
958 
959  PROCNAME("pixSetAllArbitrary");
960 
961  if (!pix)
962  return ERROR_INT("pix not defined", procName, 1);
963 
964  /* If colormapped, make sure that val is less than the size
965  * of the cmap array. */
966  if ((cmap = pixGetColormap(pix)) != NULL) {
967  n = pixcmapGetCount(cmap);
968  if (val >= n) {
969  L_WARNING("index not in colormap; using last color\n", procName);
970  val = n - 1;
971  }
972  }
973 
974  /* Make sure val isn't too large for the pixel depth.
975  * If it is too large, set the pixel color to white. */
976  pixGetDimensions(pix, &w, &h, &d);
977  if (d < 32) {
978  maxval = (1 << d) - 1;
979  if (val > maxval) {
980  L_WARNING("val = %d too large for depth; using maxval = %d\n",
981  procName, val, maxval);
982  val = maxval;
983  }
984  }
985 
986  /* Set up word to tile with */
987  wordval = 0;
988  npix = 32 / d; /* number of pixels per 32 bit word */
989  for (j = 0; j < npix; j++)
990  wordval |= (val << (j * d));
991  wpl = pixGetWpl(pix);
992  data = pixGetData(pix);
993  for (i = 0; i < h; i++) {
994  line = data + i * wpl;
995  for (j = 0; j < wpl; j++) {
996  *(line + j) = wordval;
997  }
998  }
999  return 0;
1000 }
1001 
1002 
1020 l_ok
1022  l_int32 op)
1023 {
1024 l_int32 d, index;
1025 PIXCMAP *cmap;
1026 
1027  PROCNAME("pixSetBlackOrWhite");
1028 
1029  if (!pixs)
1030  return ERROR_INT("pix not defined", procName, 1);
1031  if (op != L_SET_BLACK && op != L_SET_WHITE)
1032  return ERROR_INT("invalid op", procName, 1);
1033 
1034  cmap = pixGetColormap(pixs);
1035  d = pixGetDepth(pixs);
1036  if (!cmap) {
1037  if ((d == 1 && op == L_SET_BLACK) || (d > 1 && op == L_SET_WHITE))
1038  pixSetAll(pixs);
1039  else
1040  pixClearAll(pixs);
1041  } else { /* handle colormap */
1042  if (op == L_SET_BLACK)
1043  pixcmapAddBlackOrWhite(cmap, 0, &index);
1044  else /* L_SET_WHITE */
1045  pixcmapAddBlackOrWhite(cmap, 1, &index);
1046  pixSetAllArbitrary(pixs, index);
1047  }
1048 
1049  return 0;
1050 }
1051 
1052 
1067 l_ok
1069  l_int32 comp,
1070  l_int32 val)
1071 {
1072 l_int32 i, nwords;
1073 l_uint32 mask1, mask2;
1074 l_uint32 *data;
1075 
1076  PROCNAME("pixSetComponentArbitrary");
1077 
1078  if (!pix || pixGetDepth(pix) != 32)
1079  return ERROR_INT("pix not defined or not 32 bpp", procName, 1);
1080  if (comp != COLOR_RED && comp != COLOR_GREEN && comp != COLOR_BLUE &&
1081  comp != L_ALPHA_CHANNEL)
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);
1085 
1086  mask1 = ~(255 << (8 * (3 - comp)));
1087  mask2 = val << (8 * (3 - comp));
1088  nwords = pixGetHeight(pix) * pixGetWpl(pix);
1089  data = pixGetData(pix);
1090  for (i = 0; i < nwords; i++) {
1091  data[i] &= mask1; /* clear out the component */
1092  data[i] |= mask2; /* insert the new component value */
1093  }
1094 
1095  return 0;
1096 }
1097 
1098 
1099 /*-------------------------------------------------------------*
1100  * Rectangular region clear/set/set-to-arbitrary-value *
1101  *-------------------------------------------------------------*/
1117 l_ok
1119  BOX *box)
1120 {
1121 l_int32 x, y, w, h;
1122 
1123  PROCNAME("pixClearInRect");
1124 
1125  if (!pix)
1126  return ERROR_INT("pix not defined", procName, 1);
1127  if (!box)
1128  return ERROR_INT("box not defined", procName, 1);
1129 
1130  boxGetGeometry(box, &x, &y, &w, &h);
1131  pixRasterop(pix, x, y, w, h, PIX_CLR, NULL, 0, 0);
1132  return 0;
1133 }
1134 
1135 
1152 l_ok
1154  BOX *box)
1155 {
1156 l_int32 n, x, y, w, h;
1157 PIXCMAP *cmap;
1158 
1159  PROCNAME("pixSetInRect");
1160 
1161  if (!pix)
1162  return ERROR_INT("pix not defined", procName, 1);
1163  if (!box)
1164  return ERROR_INT("box not defined", procName, 1);
1165  if ((cmap = pixGetColormap(pix)) != NULL) {
1166  n = pixcmapGetCount(cmap);
1167  if (n < cmap->nalloc) /* cmap is not full */
1168  return ERROR_INT("cmap entry does not exist", procName, 1);
1169  }
1170 
1171  boxGetGeometry(box, &x, &y, &w, &h);
1172  pixRasterop(pix, x, y, w, h, PIX_SET, NULL, 0, 0);
1173  return 0;
1174 }
1175 
1176 
1194 l_ok
1196  BOX *box,
1197  l_uint32 val)
1198 {
1199 l_int32 n, x, y, xstart, xend, ystart, yend, bw, bh, w, h, d, wpl, maxval;
1200 l_uint32 *data, *line;
1201 BOX *boxc;
1202 PIXCMAP *cmap;
1203 
1204  PROCNAME("pixSetInRectArbitrary");
1205 
1206  if (!pix)
1207  return ERROR_INT("pix not defined", procName, 1);
1208  if (!box)
1209  return ERROR_INT("box not defined", procName, 1);
1210  pixGetDimensions(pix, &w, &h, &d);
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) {
1214  n = pixcmapGetCount(cmap);
1215  if (val >= n) {
1216  L_WARNING("index not in colormap; using last color\n", procName);
1217  val = n - 1;
1218  }
1219  }
1220 
1221  maxval = (d == 32) ? 0xffffff00 : (1 << d) - 1;
1222  if (val > maxval) val = maxval;
1223 
1224  /* Handle the simple cases: the min and max values */
1225  if (val == 0) {
1226  pixClearInRect(pix, box);
1227  return 0;
1228  }
1229  if (d == 1 ||
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))) {
1235  pixSetInRect(pix, box);
1236  return 0;
1237  }
1238 
1239  /* Find the overlap of box with the input pix */
1240  if ((boxc = boxClipToRectangle(box, w, h)) == NULL)
1241  return ERROR_INT("no overlap of box with image", procName, 1);
1242  boxGetGeometry(boxc, &xstart, &ystart, &bw, &bh);
1243  xend = xstart + bw - 1;
1244  yend = ystart + bh - 1;
1245  boxDestroy(&boxc);
1246 
1247  wpl = pixGetWpl(pix);
1248  data = pixGetData(pix);
1249  for (y = ystart; y <= yend; y++) {
1250  line = data + y * wpl;
1251  for (x = xstart; x <= xend; x++) {
1252  switch(d)
1253  {
1254  case 2:
1255  SET_DATA_DIBIT(line, x, val);
1256  break;
1257  case 4:
1258  SET_DATA_QBIT(line, x, val);
1259  break;
1260  case 8:
1261  SET_DATA_BYTE(line, x, val);
1262  break;
1263  case 16:
1264  SET_DATA_TWO_BYTES(line, x, val);
1265  break;
1266  case 32:
1267  line[x] = val;
1268  break;
1269  default:
1270  return ERROR_INT("depth not 2|4|8|16|32 bpp", procName, 1);
1271  }
1272  }
1273  }
1274 
1275  return 0;
1276 }
1277 
1278 
1295 l_ok
1297  BOX *box,
1298  l_uint32 val,
1299  l_float32 fract)
1300 {
1301 l_int32 i, j, bx, by, bw, bh, w, h, wpls;
1302 l_int32 prval, pgval, pbval, rval, gval, bval;
1303 l_uint32 val32;
1304 l_uint32 *datas, *lines;
1305 
1306  PROCNAME("pixBlendInRect");
1307 
1308  if (!pixs || pixGetDepth(pixs) != 32)
1309  return ERROR_INT("pixs not defined or not 32 bpp", procName, 1);
1310 
1311  extractRGBValues(val, &rval, &gval, &bval);
1312  pixGetDimensions(pixs, &w, &h, NULL);
1313  datas = pixGetData(pixs);
1314  wpls = pixGetWpl(pixs);
1315  if (!box) {
1316  for (i = 0; i < h; i++) { /* scan over box */
1317  lines = datas + i * wpls;
1318  for (j = 0; j < w; j++) {
1319  val32 = *(lines + j);
1320  extractRGBValues(val32, &prval, &pgval, &pbval);
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);
1324  composeRGBPixel(prval, pgval, pbval, &val32);
1325  *(lines + j) = val32;
1326  }
1327  }
1328  return 0;
1329  }
1330 
1331  boxGetGeometry(box, &bx, &by, &bw, &bh);
1332  for (i = 0; i < bh; i++) { /* scan over box */
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);
1338  extractRGBValues(val32, &prval, &pgval, &pbval);
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);
1342  composeRGBPixel(prval, pgval, pbval, &val32);
1343  *(lines + bx + j) = val32;
1344  }
1345  }
1346  return 0;
1347 }
1348 
1349 
1350 /*-------------------------------------------------------------*
1351  * Set pad bits *
1352  *-------------------------------------------------------------*/
1381 l_ok
1383  l_int32 val)
1384 {
1385 l_int32 i, w, h, d, wpl, endbits, fullwords;
1386 l_uint32 mask;
1387 l_uint32 *data, *pword;
1388 
1389  PROCNAME("pixSetPadBits");
1390 
1391  if (!pix)
1392  return ERROR_INT("pix not defined", procName, 1);
1393 
1394  pixGetDimensions(pix, &w, &h, &d);
1395  if (d == 32) /* no padding exists for 32 bpp */
1396  return 0;
1397 
1398  data = pixGetData(pix);
1399  wpl = pixGetWpl(pix);
1400  endbits = 32 - (((l_int64)w * d) % 32);
1401  if (endbits == 32) /* no partial word */
1402  return 0;
1403  fullwords = (1LL * w * d) / 32;
1404  mask = rmask32[endbits];
1405  if (val == 0)
1406  mask = ~mask;
1407 
1408  for (i = 0; i < h; i++) {
1409  pword = data + i * wpl + fullwords;
1410  if (val == 0) /* clear */
1411  *pword = *pword & mask;
1412  else /* set */
1413  *pword = *pword | mask;
1414  }
1415 
1416  return 0;
1417 }
1418 
1419 
1441 l_ok
1443  l_int32 by,
1444  l_int32 bh,
1445  l_int32 val)
1446 {
1447 l_int32 i, w, h, d, wpl, endbits, fullwords;
1448 l_uint32 mask;
1449 l_uint32 *data, *pword;
1450 
1451  PROCNAME("pixSetPadBitsBand");
1452 
1453  if (!pix)
1454  return ERROR_INT("pix not defined", procName, 1);
1455 
1456  pixGetDimensions(pix, &w, &h, &d);
1457  if (d == 32) /* no padding exists for 32 bpp */
1458  return 0;
1459 
1460  if (by < 0)
1461  by = 0;
1462  if (by >= h)
1463  return ERROR_INT("start y not in image", procName, 1);
1464  if (by + bh > h)
1465  bh = h - by;
1466 
1467  data = pixGetData(pix);
1468  wpl = pixGetWpl(pix);
1469  endbits = 32 - (((l_int64)w * d) % 32);
1470  if (endbits == 32) /* no partial word */
1471  return 0;
1472  fullwords = (l_int64)w * d / 32;
1473 
1474  mask = rmask32[endbits];
1475  if (val == 0)
1476  mask = ~mask;
1477 
1478  for (i = by; i < by + bh; i++) {
1479  pword = data + i * wpl + fullwords;
1480  if (val == 0) /* clear */
1481  *pword = *pword & mask;
1482  else /* set */
1483  *pword = *pword | mask;
1484  }
1485 
1486  return 0;
1487 }
1488 
1489 
1490 /*-------------------------------------------------------------*
1491  * Set border pixels *
1492  *-------------------------------------------------------------*/
1513 l_ok
1515  l_int32 left,
1516  l_int32 right,
1517  l_int32 top,
1518  l_int32 bot,
1519  l_int32 op)
1520 {
1521 l_int32 w, h;
1522 
1523  PROCNAME("pixSetOrClearBorder");
1524 
1525  if (!pixs)
1526  return ERROR_INT("pixs not defined", procName, 1);
1527  if (op != PIX_SET && op != PIX_CLR)
1528  return ERROR_INT("op must be PIX_SET or PIX_CLR", procName, 1);
1529 
1530  pixGetDimensions(pixs, &w, &h, NULL);
1531  pixRasterop(pixs, 0, 0, left, h, op, NULL, 0, 0);
1532  pixRasterop(pixs, w - right, 0, right, h, op, NULL, 0, 0);
1533  pixRasterop(pixs, 0, 0, w, top, op, NULL, 0, 0);
1534  pixRasterop(pixs, 0, h - bot, w, bot, op, NULL, 0, 0);
1535 
1536  return 0;
1537 }
1538 
1539 
1562 l_ok
1564  l_int32 left,
1565  l_int32 right,
1566  l_int32 top,
1567  l_int32 bot,
1568  l_uint32 val)
1569 {
1570 l_int32 w, h, d, wpls, i, j, bstart, rstart;
1571 l_uint32 *datas, *lines;
1572 
1573  PROCNAME("pixSetBorderVal");
1574 
1575  if (!pixs)
1576  return ERROR_INT("pixs not defined", procName, 1);
1577  pixGetDimensions(pixs, &w, &h, &d);
1578  if (d != 8 && d != 16 && d != 32)
1579  return ERROR_INT("depth must be 8, 16 or 32 bpp", procName, 1);
1580 
1581  datas = pixGetData(pixs);
1582  wpls = pixGetWpl(pixs);
1583  if (d == 8) {
1584  val &= 0xff;
1585  for (i = 0; i < top; i++) {
1586  lines = datas + i * wpls;
1587  for (j = 0; j < w; j++)
1588  SET_DATA_BYTE(lines, j, val);
1589  }
1590  rstart = w - right;
1591  bstart = h - bot;
1592  for (i = top; i < bstart; i++) {
1593  lines = datas + i * wpls;
1594  for (j = 0; j < left; j++)
1595  SET_DATA_BYTE(lines, j, val);
1596  for (j = rstart; j < w; j++)
1597  SET_DATA_BYTE(lines, j, val);
1598  }
1599  for (i = bstart; i < h; i++) {
1600  lines = datas + i * wpls;
1601  for (j = 0; j < w; j++)
1602  SET_DATA_BYTE(lines, j, val);
1603  }
1604  } else if (d == 16) {
1605  val &= 0xffff;
1606  for (i = 0; i < top; i++) {
1607  lines = datas + i * wpls;
1608  for (j = 0; j < w; j++)
1609  SET_DATA_TWO_BYTES(lines, j, val);
1610  }
1611  rstart = w - right;
1612  bstart = h - bot;
1613  for (i = top; i < bstart; i++) {
1614  lines = datas + i * wpls;
1615  for (j = 0; j < left; j++)
1616  SET_DATA_TWO_BYTES(lines, j, val);
1617  for (j = rstart; j < w; j++)
1618  SET_DATA_TWO_BYTES(lines, j, val);
1619  }
1620  for (i = bstart; i < h; i++) {
1621  lines = datas + i * wpls;
1622  for (j = 0; j < w; j++)
1623  SET_DATA_TWO_BYTES(lines, j, val);
1624  }
1625  } else { /* d == 32 */
1626  for (i = 0; i < top; i++) {
1627  lines = datas + i * wpls;
1628  for (j = 0; j < w; j++)
1629  *(lines + j) = val;
1630  }
1631  rstart = w - right;
1632  bstart = h - bot;
1633  for (i = top; i < bstart; i++) {
1634  lines = datas + i * wpls;
1635  for (j = 0; j < left; j++)
1636  *(lines + j) = val;
1637  for (j = rstart; j < w; j++)
1638  *(lines + j) = val;
1639  }
1640  for (i = bstart; i < h; i++) {
1641  lines = datas + i * wpls;
1642  for (j = 0; j < w; j++)
1643  *(lines + j) = val;
1644  }
1645  }
1646 
1647  return 0;
1648 }
1649 
1650 
1666 l_ok
1668  l_int32 dist,
1669  l_uint32 val)
1670 {
1671 l_int32 w, h, d, i, j, xend, yend;
1672 
1673  PROCNAME("pixSetBorderRingVal");
1674 
1675  if (!pixs)
1676  return ERROR_INT("pixs not defined", procName, 1);
1677  if (dist < 1)
1678  return ERROR_INT("dist must be > 0", procName, 1);
1679  pixGetDimensions(pixs, &w, &h, &d);
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);
1684 
1685  xend = w - dist;
1686  yend = h - dist;
1687  for (j = dist - 1; j <= xend; j++)
1688  pixSetPixel(pixs, j, dist - 1, val);
1689  for (j = dist - 1; j <= xend; j++)
1690  pixSetPixel(pixs, j, yend, val);
1691  for (i = dist - 1; i <= yend; i++)
1692  pixSetPixel(pixs, dist - 1, i, val);
1693  for (i = dist - 1; i <= yend; i++)
1694  pixSetPixel(pixs, xend, i, val);
1695 
1696  return 0;
1697 }
1698 
1699 
1717 l_ok
1719  l_int32 left,
1720  l_int32 right,
1721  l_int32 top,
1722  l_int32 bot)
1723 {
1724 l_int32 i, j, w, h;
1725 
1726  PROCNAME("pixSetMirroredBorder");
1727 
1728  if (!pixs)
1729  return ERROR_INT("pixs not defined", procName, 1);
1730 
1731  pixGetDimensions(pixs, &w, &h, NULL);
1732  for (j = 0; j < left; j++)
1733  pixRasterop(pixs, left - 1 - j, top, 1, h - top - bot, PIX_SRC,
1734  pixs, left + j, top);
1735  for (j = 0; j < right; j++)
1736  pixRasterop(pixs, w - right + j, top, 1, h - top - bot, PIX_SRC,
1737  pixs, w - right - 1 - j, top);
1738  for (i = 0; i < top; i++)
1739  pixRasterop(pixs, 0, top - 1 - i, w, 1, PIX_SRC,
1740  pixs, 0, top + i);
1741  for (i = 0; i < bot; i++)
1742  pixRasterop(pixs, 0, h - bot + i, w, 1, PIX_SRC,
1743  pixs, 0, h - bot - 1 - i);
1744 
1745  return 0;
1746 }
1747 
1748 
1768 PIX *
1770  PIX *pixs,
1771  l_int32 left,
1772  l_int32 right,
1773  l_int32 top,
1774  l_int32 bot)
1775 {
1776 l_int32 w, h;
1777 
1778  PROCNAME("pixCopyBorder");
1779 
1780  if (!pixs)
1781  return (PIX *)ERROR_PTR("pixs not defined", procName, pixd);
1782 
1783  if (pixd) {
1784  if (pixd == pixs) {
1785  L_WARNING("same: nothing to do\n", procName);
1786  return pixd;
1787  } else if (!pixSizesEqual(pixs, pixd)) {
1788  return (PIX *)ERROR_PTR("pixs and pixd sizes differ",
1789  procName, pixd);
1790  }
1791  } else {
1792  if ((pixd = pixCreateTemplate(pixs)) == NULL)
1793  return (PIX *)ERROR_PTR("pixd not made", procName, pixd);
1794  }
1795 
1796  pixGetDimensions(pixs, &w, &h, NULL);
1797  pixRasterop(pixd, 0, 0, left, h, PIX_SRC, pixs, 0, 0);
1798  pixRasterop(pixd, w - right, 0, right, h, PIX_SRC, pixs, w - right, 0);
1799  pixRasterop(pixd, 0, 0, w, top, PIX_SRC, pixs, 0, 0);
1800  pixRasterop(pixd, 0, h - bot, w, bot, PIX_SRC, pixs, 0, h - bot);
1801  return pixd;
1802 }
1803 
1804 
1805 
1806 /*-------------------------------------------------------------*
1807  * Add and remove border *
1808  *-------------------------------------------------------------*/
1822 PIX *
1824  l_int32 npix,
1825  l_uint32 val)
1826 {
1827  PROCNAME("pixAddBorder");
1828 
1829  if (!pixs)
1830  return (PIX *)ERROR_PTR("pixs not defined", procName, NULL);
1831  if (npix == 0)
1832  return pixClone(pixs);
1833  return pixAddBorderGeneral(pixs, npix, npix, npix, npix, val);
1834 }
1835 
1836 
1862 PIX *
1864  l_int32 left,
1865  l_int32 right,
1866  l_int32 top,
1867  l_int32 bot,
1868  l_int32 op)
1869 {
1870 l_uint32 val;
1871 
1872  PROCNAME("pixAddBlackOrWhiteBorder");
1873 
1874  if (!pixs)
1875  return (PIX *)ERROR_PTR("pixs not defined", procName, NULL);
1876  if (op != L_GET_BLACK_VAL && op != L_GET_WHITE_VAL)
1877  return (PIX *)ERROR_PTR("invalid op", procName, NULL);
1878 
1879  pixGetBlackOrWhiteVal(pixs, op, &val);
1880  return pixAddBorderGeneral(pixs, left, right, top, bot, val);
1881 }
1882 
1883 
1916 PIX *
1918  l_int32 left,
1919  l_int32 right,
1920  l_int32 top,
1921  l_int32 bot,
1922  l_uint32 val)
1923 {
1924 l_int32 ws, hs, wd, hd, d, maxval, op;
1925 PIX *pixd;
1926 
1927  PROCNAME("pixAddBorderGeneral");
1928 
1929  if (!pixs)
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);
1933 
1934  pixGetDimensions(pixs, &ws, &hs, &d);
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);
1940  pixCopyColormap(pixd, pixs);
1941 
1942  /* Set the new border pixels */
1943  maxval = (d == 32) ? 0xffffff00 : (1 << d) - 1;
1944  op = UNDEF;
1945  if (val == 0)
1946  op = PIX_CLR;
1947  else if (val >= maxval)
1948  op = PIX_SET;
1949  if (op == UNDEF) {
1950  pixSetAllArbitrary(pixd, val);
1951  } else { /* just set or clear the border pixels */
1952  pixRasterop(pixd, 0, 0, left, hd, op, NULL, 0, 0);
1953  pixRasterop(pixd, wd - right, 0, right, hd, op, NULL, 0, 0);
1954  pixRasterop(pixd, 0, 0, wd, top, op, NULL, 0, 0);
1955  pixRasterop(pixd, 0, hd - bot, wd, bot, op, NULL, 0, 0);
1956  }
1957 
1958  /* Copy pixs into the interior */
1959  pixRasterop(pixd, left, top, ws, hs, PIX_SRC, pixs, 0, 0);
1960  return pixd;
1961 }
1962 
1963 
1971 PIX *
1973  l_int32 npix)
1974 {
1975  PROCNAME("pixRemoveBorder");
1976 
1977  if (!pixs)
1978  return (PIX *)ERROR_PTR("pixs not defined", procName, NULL);
1979  if (npix == 0)
1980  return pixClone(pixs);
1981  return pixRemoveBorderGeneral(pixs, npix, npix, npix, npix);
1982 }
1983 
1984 
1992 PIX *
1994  l_int32 left,
1995  l_int32 right,
1996  l_int32 top,
1997  l_int32 bot)
1998 {
1999 l_int32 ws, hs, wd, hd, d;
2000 PIX *pixd;
2001 
2002  PROCNAME("pixRemoveBorderGeneral");
2003 
2004  if (!pixs)
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);
2008 
2009  pixGetDimensions(pixs, &ws, &hs, &d);
2010  wd = ws - left - right;
2011  hd = hs - top - bot;
2012  if (wd <= 0)
2013  return (PIX *)ERROR_PTR("width must be > 0", procName, NULL);
2014  if (hd <= 0)
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);
2019  pixCopySpp(pixd, pixs);
2020  pixCopyColormap(pixd, pixs);
2021 
2022  pixRasterop(pixd, 0, 0, wd, hd, PIX_SRC, pixs, left, top);
2023  if (pixGetDepth(pixs) == 32 && pixGetSpp(pixs) == 4)
2024  pixShiftAndTransferAlpha(pixd, pixs, -left, -top);
2025  return pixd;
2026 }
2027 
2028 
2045 PIX *
2047  l_int32 wd,
2048  l_int32 hd)
2049 {
2050 l_int32 w, h, top, bot, left, right, delta;
2051 
2052  PROCNAME("pixRemoveBorderToSize");
2053 
2054  if (!pixs)
2055  return (PIX *)ERROR_PTR("pixs not defined", procName, NULL);
2056 
2057  pixGetDimensions(pixs, &w, &h, NULL);
2058  if ((wd <= 0 || wd >= w) && (hd <= 0 || hd >= h))
2059  return pixClone(pixs);
2060 
2061  left = right = (w - wd) / 2;
2062  delta = w - 2 * left - wd;
2063  right += delta;
2064  top = bot = (h - hd) / 2;
2065  delta = h - hd - 2 * top;
2066  bot += delta;
2067  if (wd <= 0 || wd > w)
2068  left = right = 0;
2069  else if (hd <= 0 || hd > h)
2070  top = bot = 0;
2071 
2072  return pixRemoveBorderGeneral(pixs, left, right, top, bot);
2073 }
2074 
2075 
2100 PIX *
2102  l_int32 left,
2103  l_int32 right,
2104  l_int32 top,
2105  l_int32 bot)
2106 {
2107 l_int32 i, j, w, h;
2108 PIX *pixd;
2109 
2110  PROCNAME("pixAddMirroredBorder");
2111 
2112  if (!pixs)
2113  return (PIX *)ERROR_PTR("pixs not defined", procName, NULL);
2114  pixGetDimensions(pixs, &w, &h, NULL);
2115  if (left > w || right > w || top > h || bot > h)
2116  return (PIX *)ERROR_PTR("border too large", procName, NULL);
2117 
2118  /* Set pixels on left, right, top and bottom, in that order */
2119  pixd = pixAddBorderGeneral(pixs, left, right, top, bot, 0);
2120  for (j = 0; j < left; j++)
2121  pixRasterop(pixd, left - 1 - j, top, 1, h, PIX_SRC,
2122  pixd, left + j, top);
2123  for (j = 0; j < right; j++)
2124  pixRasterop(pixd, left + w + j, top, 1, h, PIX_SRC,
2125  pixd, left + w - 1 - j, top);
2126  for (i = 0; i < top; i++)
2127  pixRasterop(pixd, 0, top - 1 - i, left + w + right, 1, PIX_SRC,
2128  pixd, 0, top + i);
2129  for (i = 0; i < bot; i++)
2130  pixRasterop(pixd, 0, top + h + i, left + w + right, 1, PIX_SRC,
2131  pixd, 0, top + h - 1 - i);
2132 
2133  return pixd;
2134 }
2135 
2136 
2153 PIX *
2155  l_int32 left,
2156  l_int32 right,
2157  l_int32 top,
2158  l_int32 bot)
2159 {
2160 l_int32 w, h;
2161 PIX *pixd;
2162 
2163  PROCNAME("pixAddRepeatedBorder");
2164 
2165  if (!pixs)
2166  return (PIX *)ERROR_PTR("pixs not defined", procName, NULL);
2167  pixGetDimensions(pixs, &w, &h, NULL);
2168  if (left > w || right > w || top > h || bot > h)
2169  return (PIX *)ERROR_PTR("border too large", procName, NULL);
2170 
2171  pixd = pixAddBorderGeneral(pixs, left, right, top, bot, 0);
2172 
2173  /* Set pixels on left, right, top and bottom, in that order */
2174  pixRasterop(pixd, 0, top, left, h, PIX_SRC, pixd, w, top);
2175  pixRasterop(pixd, left + w, top, right, h, PIX_SRC, pixd, left, top);
2176  pixRasterop(pixd, 0, 0, left + w + right, top, PIX_SRC, pixd, 0, h);
2177  pixRasterop(pixd, 0, top + h, left + w + right, bot, PIX_SRC, pixd, 0, top);
2178 
2179  return pixd;
2180 }
2181 
2182 
2209 PIX *
2211  l_int32 left,
2212  l_int32 right,
2213  l_int32 top,
2214  l_int32 bot)
2215 {
2216 l_int32 j, w, h;
2217 PIX *pixd;
2218 
2219  PROCNAME("pixAddMixedBorder");
2220 
2221  if (!pixs)
2222  return (PIX *)ERROR_PTR("pixs not defined", procName, NULL);
2223  pixGetDimensions(pixs, &w, &h, NULL);
2224  if (left > w || right > w || top > h || bot > h)
2225  return (PIX *)ERROR_PTR("border too large", procName, NULL);
2226 
2227  /* Set mirrored pixels on left and right;
2228  * then set repeated pixels on top and bottom. */
2229  pixd = pixAddBorderGeneral(pixs, left, right, top, bot, 0);
2230  for (j = 0; j < left; j++)
2231  pixRasterop(pixd, left - 1 - j, top, 1, h, PIX_SRC,
2232  pixd, left + j, top);
2233  for (j = 0; j < right; j++)
2234  pixRasterop(pixd, left + w + j, top, 1, h, PIX_SRC,
2235  pixd, left + w - 1 - j, top);
2236  pixRasterop(pixd, 0, 0, left + w + right, top, PIX_SRC, pixd, 0, h);
2237  pixRasterop(pixd, 0, top + h, left + w + right, bot, PIX_SRC, pixd, 0, top);
2238 
2239  return pixd;
2240 }
2241 
2242 
2256 PIX *
2258  l_int32 left,
2259  l_int32 right,
2260  l_int32 top,
2261  l_int32 bot)
2262 {
2263 l_int32 i, j, w, h;
2264 PIX *pixd;
2265 
2266  PROCNAME("pixAddContinuedBorder");
2267 
2268  if (!pixs)
2269  return (PIX *)ERROR_PTR("pixs not defined", procName, NULL);
2270 
2271  pixd = pixAddBorderGeneral(pixs, left, right, top, bot, 0);
2272  pixGetDimensions(pixs, &w, &h, NULL);
2273  for (j = 0; j < left; j++)
2274  pixRasterop(pixd, j, top, 1, h, PIX_SRC, pixd, left, top);
2275  for (j = 0; j < right; j++)
2276  pixRasterop(pixd, left + w + j, top, 1, h,
2277  PIX_SRC, pixd, left + w - 1, top);
2278  for (i = 0; i < top; i++)
2279  pixRasterop(pixd, 0, i, left + w + right, 1, PIX_SRC, pixd, 0, top);
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);
2283 
2284  return pixd;
2285 }
2286 
2287 
2288 /*-------------------------------------------------------------------*
2289  * Helper functions using alpha *
2290  *-------------------------------------------------------------------*/
2299 l_ok
2301  PIX *pixs,
2302  l_float32 shiftx,
2303  l_float32 shifty)
2304 {
2305 l_int32 w, h;
2306 PIX *pix1, *pix2;
2307 
2308  PROCNAME("pixShiftAndTransferAlpha");
2309 
2310  if (!pixs || !pixd)
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);
2316 
2317  if (shiftx == 0 && shifty == 0) {
2318  pixCopyRGBComponent(pixd, pixs, L_ALPHA_CHANNEL);
2319  return 0;
2320  }
2321 
2322  pix1 = pixGetRGBComponent(pixs, L_ALPHA_CHANNEL);
2323  pixGetDimensions(pixd, &w, &h, NULL);
2324  pix2 = pixCreate(w, h, 8);
2325  pixRasterop(pix2, 0, 0, w, h, PIX_SRC, pix1, -shiftx, -shifty);
2326  pixSetRGBComponent(pixd, pix2, L_ALPHA_CHANNEL);
2327  pixDestroy(&pix1);
2328  pixDestroy(&pix2);
2329  return 0;
2330 }
2331 
2332 
2350 PIX *
2352  l_uint32 val,
2353  l_int32 maxw)
2354 {
2355 l_int32 w, width;
2356 l_float32 scalefact;
2357 PIX *pix1, *pix2, *pixd;
2358 PIXA *pixa;
2359 PIXCMAP *cmap;
2360 
2361  PROCNAME("pixDisplayLayersRGBA");
2362 
2363  if (!pixs)
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",
2368  procName, NULL);
2369  if ((w = pixGetWidth(pixs)) == 0)
2370  return (PIX *)ERROR_PTR("pixs width 0 !!", procName, NULL);
2371 
2372  if (cmap)
2374  else
2375  pix1 = pixCopy(NULL, pixs);
2376 
2377  /* Scale if necessary so the output width is not larger than maxw */
2378  scalefact = (maxw == 0) ? 1.0 : L_MIN(1.0, (l_float32)(maxw) / w);
2379  width = (l_int32)(scalefact * w);
2380 
2381  pixa = pixaCreate(3);
2382  pixSetSpp(pix1, 3);
2383  pixaAddPix(pixa, pix1, L_INSERT); /* show the rgb values */
2384  pix1 = pixGetRGBComponent(pixs, L_ALPHA_CHANNEL);
2385  pix2 = pixConvertTo32(pix1);
2386  pixaAddPix(pixa, pix2, L_INSERT); /* show the alpha channel */
2387  pixDestroy(&pix1);
2388  pix1 = pixAlphaBlendUniform(pixs, (val & 0xffffff00));
2389  pixaAddPix(pixa, pix1, L_INSERT); /* with %val color bg showing */
2390  pixd = pixaDisplayTiledInRows(pixa, 32, width, scalefact, 0, 25, 2);
2391  pixaDestroy(&pixa);
2392  return pixd;
2393 }
2394 
2395 
2396 /*-------------------------------------------------------------*
2397  * Color sample setting and extraction *
2398  *-------------------------------------------------------------*/
2422 PIX *
2424  PIX *pixg,
2425  PIX *pixb)
2426 {
2427 l_int32 wr, wg, wb, hr, hg, hb, dr, dg, db;
2428 PIX *pixd;
2429 
2430  PROCNAME("pixCreateRGBImage");
2431 
2432  if (!pixr)
2433  return (PIX *)ERROR_PTR("pixr not defined", procName, NULL);
2434  if (!pixg)
2435  return (PIX *)ERROR_PTR("pixg not defined", procName, NULL);
2436  if (!pixb)
2437  return (PIX *)ERROR_PTR("pixb not defined", procName, NULL);
2438  pixGetDimensions(pixr, &wr, &hr, &dr);
2439  pixGetDimensions(pixg, &wg, &hg, &dg);
2440  pixGetDimensions(pixb, &wb, &hb, &db);
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);
2447 
2448  if ((pixd = pixCreate(wr, hr, 32)) == NULL)
2449  return (PIX *)ERROR_PTR("pixd not made", procName, NULL);
2450  pixCopyResolution(pixd, pixr);
2451  pixSetRGBComponent(pixd, pixr, COLOR_RED);
2452  pixSetRGBComponent(pixd, pixg, COLOR_GREEN);
2453  pixSetRGBComponent(pixd, pixb, COLOR_BLUE);
2454 
2455  return pixd;
2456 }
2457 
2458 
2478 PIX *
2480  l_int32 comp)
2481 {
2482 l_int32 i, j, w, h, wpls, wpld, val;
2483 l_uint32 *lines, *lined;
2484 l_uint32 *datas, *datad;
2485 PIX *pixd;
2486 
2487  PROCNAME("pixGetRGBComponent");
2488 
2489  if (!pixs)
2490  return (PIX *)ERROR_PTR("pixs not defined", procName, NULL);
2491  if (pixGetColormap(pixs))
2492  return pixGetRGBComponentCmap(pixs, comp);
2493  if (pixGetDepth(pixs) != 32)
2494  return (PIX *)ERROR_PTR("pixs not 32 bpp", procName, NULL);
2495  if (comp != COLOR_RED && comp != COLOR_GREEN &&
2496  comp != COLOR_BLUE && comp != L_ALPHA_CHANNEL)
2497  return (PIX *)ERROR_PTR("invalid comp", procName, NULL);
2498 
2499  pixGetDimensions(pixs, &w, &h, 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);
2505  datas = pixGetData(pixs);
2506  datad = pixGetData(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++) {
2511  val = GET_DATA_BYTE(lines + j, comp);
2512  SET_DATA_BYTE(lined, j, val);
2513  }
2514  }
2515 
2516  return pixd;
2517 }
2518 
2519 
2537 l_ok
2539  PIX *pixs,
2540  l_int32 comp)
2541 {
2542 l_uint8 srcbyte;
2543 l_int32 i, j, w, h, ws, hs, wd, hd;
2544 l_int32 wpls, wpld;
2545 l_uint32 *lines, *lined;
2546 l_uint32 *datas, *datad;
2547 
2548  PROCNAME("pixSetRGBComponent");
2549 
2550  if (!pixd)
2551  return ERROR_INT("pixd not defined", procName, 1);
2552  if (!pixs)
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);
2558  if (comp != COLOR_RED && comp != COLOR_GREEN &&
2559  comp != COLOR_BLUE && comp != L_ALPHA_CHANNEL)
2560  return ERROR_INT("invalid comp", procName, 1);
2561  pixGetDimensions(pixs, &ws, &hs, NULL);
2562  pixGetDimensions(pixd, &wd, &hd, NULL);
2563  if (ws != wd || hs != hd)
2564  L_WARNING("images sizes not equal\n", procName);
2565  w = L_MIN(ws, wd);
2566  h = L_MIN(hs, hd);
2567  if (comp == L_ALPHA_CHANNEL)
2568  pixSetSpp(pixd, 4);
2569  datas = pixGetData(pixs);
2570  datad = pixGetData(pixd);
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++) {
2577  srcbyte = GET_DATA_BYTE(lines, j);
2578  SET_DATA_BYTE(lined + j, comp, srcbyte);
2579  }
2580  }
2581 
2582  return 0;
2583 }
2584 
2585 
2599 PIX *
2601  l_int32 comp)
2602 {
2603 l_int32 i, j, w, h, val, index, valid;
2604 l_int32 wplc, wpld;
2605 l_uint32 *linec, *lined;
2606 l_uint32 *datac, *datad;
2607 PIX *pixc, *pixd;
2608 PIXCMAP *cmap;
2609 RGBA_QUAD *cta;
2610 
2611  PROCNAME("pixGetRGBComponentCmap");
2612 
2613  if (!pixs)
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);
2617  if (comp == L_ALPHA_CHANNEL)
2618  return (PIX *)ERROR_PTR("alpha in cmaps not supported", procName, NULL);
2619  if (comp != COLOR_RED && comp != COLOR_GREEN && comp != COLOR_BLUE)
2620  return (PIX *)ERROR_PTR("invalid comp", procName, NULL);
2621 
2622  /* If not 8 bpp, make a cmapped 8 bpp pix */
2623  if (pixGetDepth(pixs) == 8)
2624  pixc = pixClone(pixs);
2625  else
2626  pixc = pixConvertTo8(pixs, TRUE);
2627  pixcmapIsValid(cmap, pixc, &valid);
2628  if (!valid) {
2629  pixDestroy(&pixc);
2630  return (PIX *)ERROR_PTR("invalid colormap", procName, NULL);
2631  }
2632 
2633  pixGetDimensions(pixs, &w, &h, NULL);
2634  if ((pixd = pixCreate(w, h, 8)) == NULL) {
2635  pixDestroy(&pixc);
2636  return (PIX *)ERROR_PTR("pixd not made", procName, NULL);
2637  }
2638  pixCopyResolution(pixd, pixs);
2639  wplc = pixGetWpl(pixc);
2640  wpld = pixGetWpl(pixd);
2641  datac = pixGetData(pixc);
2642  datad = pixGetData(pixd);
2643  cta = (RGBA_QUAD *)cmap->array;
2644 
2645  for (i = 0; i < h; i++) {
2646  linec = datac + i * wplc;
2647  lined = datad + i * wpld;
2648  if (comp == COLOR_RED) {
2649  for (j = 0; j < w; j++) {
2650  index = GET_DATA_BYTE(linec, j);
2651  val = cta[index].red;
2652  SET_DATA_BYTE(lined, j, val);
2653  }
2654  } else if (comp == COLOR_GREEN) {
2655  for (j = 0; j < w; j++) {
2656  index = GET_DATA_BYTE(linec, j);
2657  val = cta[index].green;
2658  SET_DATA_BYTE(lined, j, val);
2659  }
2660  } else if (comp == COLOR_BLUE) {
2661  for (j = 0; j < w; j++) {
2662  index = GET_DATA_BYTE(linec, j);
2663  val = cta[index].blue;
2664  SET_DATA_BYTE(lined, j, val);
2665  }
2666  }
2667  }
2668 
2669  pixDestroy(&pixc);
2670  return pixd;
2671 }
2672 
2673 
2689 l_ok
2691  PIX *pixs,
2692  l_int32 comp)
2693 {
2694 l_int32 i, j, w, h, ws, hs, wd, hd, val;
2695 l_int32 wpls, wpld;
2696 l_uint32 *lines, *lined;
2697 l_uint32 *datas, *datad;
2698 
2699  PROCNAME("pixCopyRGBComponent");
2700 
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);
2705  if (comp != COLOR_RED && comp != COLOR_GREEN &&
2706  comp != COLOR_BLUE && comp != L_ALPHA_CHANNEL)
2707  return ERROR_INT("invalid component", procName, 1);
2708  pixGetDimensions(pixs, &ws, &hs, NULL);
2709  pixGetDimensions(pixd, &wd, &hd, NULL);
2710  if (ws != wd || hs != hd)
2711  L_WARNING("images sizes not equal\n", procName);
2712  w = L_MIN(ws, wd);
2713  h = L_MIN(hs, hd);
2714  if (comp == L_ALPHA_CHANNEL)
2715  pixSetSpp(pixd, 4);
2716  wpls = pixGetWpl(pixs);
2717  wpld = pixGetWpl(pixd);
2718  datas = pixGetData(pixs);
2719  datad = pixGetData(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++) {
2724  val = GET_DATA_BYTE(lines + j, comp);
2725  SET_DATA_BYTE(lined + j, comp, val);
2726  }
2727  }
2728  return 0;
2729 }
2730 
2731 
2750 l_ok
2751 composeRGBPixel(l_int32 rval,
2752  l_int32 gval,
2753  l_int32 bval,
2754  l_uint32 *ppixel)
2755 {
2756  PROCNAME("composeRGBPixel");
2757 
2758  if (!ppixel)
2759  return ERROR_INT("&pixel not defined", procName, 1);
2760 
2761  *ppixel = ((l_uint32)rval << L_RED_SHIFT) |
2762  ((l_uint32)gval << L_GREEN_SHIFT) |
2763  ((l_uint32)bval << L_BLUE_SHIFT);
2764  return 0;
2765 }
2766 
2767 
2782 l_ok
2783 composeRGBAPixel(l_int32 rval,
2784  l_int32 gval,
2785  l_int32 bval,
2786  l_int32 aval,
2787  l_uint32 *ppixel)
2788 {
2789  PROCNAME("composeRGBAPixel");
2790 
2791  if (!ppixel)
2792  return ERROR_INT("&pixel not defined", procName, 1);
2793 
2794  *ppixel = ((l_uint32)rval << L_RED_SHIFT) |
2795  ((l_uint32)gval << L_GREEN_SHIFT) |
2796  ((l_uint32)bval << L_BLUE_SHIFT) |
2797  aval;
2798  return 0;
2799 }
2800 
2801 
2819 void
2820 extractRGBValues(l_uint32 pixel,
2821  l_int32 *prval,
2822  l_int32 *pgval,
2823  l_int32 *pbval)
2824 {
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;
2828 }
2829 
2830 
2841 void
2842 extractRGBAValues(l_uint32 pixel,
2843  l_int32 *prval,
2844  l_int32 *pgval,
2845  l_int32 *pbval,
2846  l_int32 *paval)
2847 {
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;
2852 }
2853 
2854 
2862 l_int32
2863 extractMinMaxComponent(l_uint32 pixel,
2864  l_int32 type)
2865 {
2866 l_int32 rval, gval, bval, val;
2867 
2868  extractRGBValues(pixel, &rval, &gval, &bval);
2869  if (type == L_CHOOSE_MIN) {
2870  val = L_MIN(rval, gval);
2871  val = L_MIN(val, bval);
2872  } else { /* type == L_CHOOSE_MAX */
2873  val = L_MAX(rval, gval);
2874  val = L_MAX(val, bval);
2875  }
2876  return val;
2877 }
2878 
2879 
2896 l_ok
2898  l_int32 row,
2899  l_uint8 *bufr,
2900  l_uint8 *bufg,
2901  l_uint8 *bufb)
2902 {
2903 l_uint32 *lines;
2904 l_int32 j, w, h;
2905 l_int32 wpls;
2906 
2907  PROCNAME("pixGetRGBLine");
2908 
2909  if (!pixs)
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);
2915 
2916  pixGetDimensions(pixs, &w, &h, NULL);
2917  if (row < 0 || row >= h)
2918  return ERROR_INT("row out of bounds", procName, 1);
2919  wpls = pixGetWpl(pixs);
2920  lines = pixGetData(pixs) + row * wpls;
2921 
2922  for (j = 0; j < w; j++) {
2923  bufr[j] = GET_DATA_BYTE(lines + j, COLOR_RED);
2924  bufg[j] = GET_DATA_BYTE(lines + j, COLOR_GREEN);
2925  bufb[j] = GET_DATA_BYTE(lines + j, COLOR_BLUE);
2926  }
2927 
2928  return 0;
2929 }
2930 
2931 
2932 /*-------------------------------------------------------------*
2933  * Raster line pixel setter *
2934  *-------------------------------------------------------------*/
2951 l_ok
2952 setLineDataVal(l_uint32 *line,
2953  l_int32 j,
2954  l_int32 d,
2955  l_uint32 val)
2956 {
2957  PROCNAME("setLineDataVal");
2958 
2959  if (!line)
2960  return ERROR_INT("line not defined", procName, 1);
2961  if (j < 0)
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);
2965 
2966  if (d == 1)
2967  SET_DATA_BIT_VAL(line, j, val);
2968  else if (d == 2)
2969  SET_DATA_DIBIT(line, j, val);
2970  else if (d == 4)
2971  SET_DATA_QBIT(line, j, val);
2972  else if (d == 8)
2973  SET_DATA_BYTE(line, j, val);
2974  else if (d == 16)
2975  SET_DATA_TWO_BYTES(line, j, val);
2976  else /* d == 32 */
2977  *(line + j) = val;
2978  return 0;
2979 }
2980 
2981 
2982 /*-------------------------------------------------------------*
2983  * Pixel endian conversion *
2984  *-------------------------------------------------------------*/
3009 PIX *
3011 {
3012 l_uint32 *datas, *datad;
3013 l_int32 i, j, h, wpl;
3014 l_uint32 word;
3015 PIX *pixd;
3016 
3017  PROCNAME("pixEndianByteSwapNew");
3018 
3019 #ifdef L_BIG_ENDIAN
3020 
3021  return pixClone(pixs);
3022 
3023 #else /* L_LITTLE_ENDIAN */
3024 
3025  if (!pixs)
3026  return (PIX *)ERROR_PTR("pixs not defined", procName, NULL);
3027 
3028  datas = pixGetData(pixs);
3029  wpl = pixGetWpl(pixs);
3030  h = pixGetHeight(pixs);
3031  if ((pixd = pixCreateTemplate(pixs)) == NULL)
3032  return (PIX *)ERROR_PTR("pixd not made", procName, NULL);
3033  datad = pixGetData(pixd);
3034  for (i = 0; i < h; i++) {
3035  for (j = 0; j < wpl; j++, datas++, datad++) {
3036  word = *datas;
3037  *datad = (word >> 24) |
3038  ((word >> 8) & 0x0000ff00) |
3039  ((word << 8) & 0x00ff0000) |
3040  (word << 24);
3041  }
3042  }
3043 
3044  return pixd;
3045 
3046 #endif /* L_BIG_ENDIAN */
3047 
3048 }
3049 
3050 
3073 l_ok
3075 {
3076 l_uint32 *data;
3077 l_int32 i, j, h, wpl;
3078 l_uint32 word;
3079 
3080  PROCNAME("pixEndianByteSwap");
3081 
3082 #ifdef L_BIG_ENDIAN
3083 
3084  return 0;
3085 
3086 #else /* L_LITTLE_ENDIAN */
3087 
3088  if (!pixs)
3089  return ERROR_INT("pixs not defined", procName, 1);
3090 
3091  data = pixGetData(pixs);
3092  wpl = pixGetWpl(pixs);
3093  h = pixGetHeight(pixs);
3094  for (i = 0; i < h; i++) {
3095  for (j = 0; j < wpl; j++, data++) {
3096  word = *data;
3097  *data = (word >> 24) |
3098  ((word >> 8) & 0x0000ff00) |
3099  ((word << 8) & 0x00ff0000) |
3100  (word << 24);
3101  }
3102  }
3103 
3104  return 0;
3105 
3106 #endif /* L_BIG_ENDIAN */
3107 
3108 }
3109 
3110 
3131 l_int32
3132 lineEndianByteSwap(l_uint32 *datad,
3133  l_uint32 *datas,
3134  l_int32 wpl)
3135 {
3136 l_int32 j;
3137 l_uint32 word;
3138 
3139  PROCNAME("lineEndianByteSwap");
3140 
3141  if (!datad || !datas)
3142  return ERROR_INT("datad and datas not both defined", procName, 1);
3143 
3144 #ifdef L_BIG_ENDIAN
3145 
3146  memcpy(datad, datas, 4 * wpl);
3147  return 0;
3148 
3149 #else /* L_LITTLE_ENDIAN */
3150 
3151  for (j = 0; j < wpl; j++, datas++, datad++) {
3152  word = *datas;
3153  *datad = (word >> 24) |
3154  ((word >> 8) & 0x0000ff00) |
3155  ((word << 8) & 0x00ff0000) |
3156  (word << 24);
3157  }
3158  return 0;
3159 
3160 #endif /* L_BIG_ENDIAN */
3161 
3162 }
3163 
3164 
3184 PIX *
3186 {
3187 l_uint32 *datas, *datad;
3188 l_int32 i, j, h, wpl;
3189 l_uint32 word;
3190 PIX *pixd;
3191 
3192  PROCNAME("pixEndianTwoByteSwapNew");
3193 
3194 #ifdef L_BIG_ENDIAN
3195 
3196  return pixClone(pixs);
3197 
3198 #else /* L_LITTLE_ENDIAN */
3199 
3200  if (!pixs)
3201  return (PIX *)ERROR_PTR("pixs not defined", procName, NULL);
3202 
3203  datas = pixGetData(pixs);
3204  wpl = pixGetWpl(pixs);
3205  h = pixGetHeight(pixs);
3206  if ((pixd = pixCreateTemplate(pixs)) == NULL)
3207  return (PIX *)ERROR_PTR("pixd not made", procName, NULL);
3208  datad = pixGetData(pixd);
3209  for (i = 0; i < h; i++) {
3210  for (j = 0; j < wpl; j++, datas++, datad++) {
3211  word = *datas;
3212  *datad = (word << 16) | (word >> 16);
3213  }
3214  }
3215 
3216  return pixd;
3217 
3218 #endif /* L_BIG_ENDIAN */
3219 
3220 }
3221 
3222 
3238 l_ok
3240 {
3241 l_uint32 *data;
3242 l_int32 i, j, h, wpl;
3243 l_uint32 word;
3244 
3245  PROCNAME("pixEndianTwoByteSwap");
3246 
3247 #ifdef L_BIG_ENDIAN
3248 
3249  return 0;
3250 
3251 #else /* L_LITTLE_ENDIAN */
3252 
3253  if (!pixs)
3254  return ERROR_INT("pixs not defined", procName, 1);
3255 
3256  data = pixGetData(pixs);
3257  wpl = pixGetWpl(pixs);
3258  h = pixGetHeight(pixs);
3259  for (i = 0; i < h; i++) {
3260  for (j = 0; j < wpl; j++, data++) {
3261  word = *data;
3262  *data = (word << 16) | (word >> 16);
3263  }
3264  }
3265 
3266  return 0;
3267 
3268 #endif /* L_BIG_ENDIAN */
3269 
3270 }
3271 
3272 
3273 /*-------------------------------------------------------------*
3274  * Extract raster data as binary string *
3275  *-------------------------------------------------------------*/
3292 l_ok
3294  l_uint8 **pdata,
3295  size_t *pnbytes)
3296 {
3297 l_int32 w, h, d, wpl, i, j, rval, gval, bval;
3298 l_int32 databpl; /* bytes for each raster line in returned data */
3299 l_uint8 *line, *data; /* packed data in returned array */
3300 l_uint32 *rline, *rdata; /* data in pix raster */
3301 
3302  PROCNAME("pixGetRasterData");
3303 
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);
3308  if (!pixs)
3309  return ERROR_INT("pixs not defined", procName, 1);
3310  pixGetDimensions(pixs, &w, &h, &d);
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);
3313 
3314  pixSetPadBits(pixs, 0);
3315  rdata = pixGetData(pixs);
3316  wpl = pixGetWpl(pixs);
3317  if (d == 1)
3318  databpl = (w + 7) / 8;
3319  else if (d == 2)
3320  databpl = (w + 3) / 4;
3321  else if (d == 4)
3322  databpl = (w + 1) / 2;
3323  else if (d == 8 || d == 16)
3324  databpl = w * (d / 8);
3325  else /* d == 32 bpp rgb */
3326  databpl = 3 * w;
3327  if ((data = (l_uint8 *)LEPT_CALLOC((size_t)databpl * h, sizeof(l_uint8)))
3328  == NULL)
3329  return ERROR_INT("data not allocated", procName, 1);
3330  *pdata = data;
3331  *pnbytes = (size_t)databpl * h;
3332 
3333  for (i = 0; i < h; i++) {
3334  rline = rdata + i * wpl;
3335  line = data + i * databpl;
3336  if (d <= 8) {
3337  for (j = 0; j < databpl; j++)
3338  line[j] = GET_DATA_BYTE(rline, j);
3339  } else if (d == 16) {
3340  for (j = 0; j < w; j++)
3341  line[2 * j] = GET_DATA_TWO_BYTES(rline, j);
3342  } else { /* d == 32 bpp rgb */
3343  for (j = 0; j < w; j++) {
3344  extractRGBValues(rline[j], &rval, &gval, &bval);
3345  *(line + 3 * j) = rval;
3346  *(line + 3 * j + 1) = gval;
3347  *(line + 3 * j + 2) = bval;
3348  }
3349  }
3350  }
3351 
3352  return 0;
3353 }
3354 
3355 
3356 /*-------------------------------------------------------------*
3357  * Infer resolution from image size *
3358  *-------------------------------------------------------------*/
3376 l_ok
3378  l_float32 longside,
3379  l_int32 *pres)
3380 {
3381 l_int32 w, h, maxdim, res;
3382 
3383  PROCNAME("pixInferResolution");
3384 
3385  if (!pres)
3386  return ERROR_INT("&res not defined", procName, 1);
3387  *pres = 300;
3388  if (!pix)
3389  return ERROR_INT("pix not defined", procName, 1);
3390  if (longside <= 0.0)
3391  return ERROR_INT("longside not > 0", procName, 1);
3392 
3393  pixGetDimensions(pix, &w, &h, NULL);
3394  maxdim = L_MAX(w, h);
3395  res = (l_int32)(maxdim / longside + 0.5);
3396  res = L_MAX(res, 1); /* don't let it be 0 */
3397  if (res < 10)
3398  L_WARNING("low inferred resolution: %d ppi\n", procName, res);
3399  if (res > 10000)
3400  L_WARNING("high inferred resolution: %d ppi\n", procName, res);
3401  *pres = res;
3402  return 0;
3403 }
3404 
3405 
3406 /*-------------------------------------------------------------*
3407  * Test alpha component opaqueness *
3408  *-------------------------------------------------------------*/
3422 l_ok
3424  l_int32 *popaque)
3425 {
3426 l_int32 w, h, wpl, i, j, alpha;
3427 l_uint32 *data, *line;
3428 
3429  PROCNAME("pixAlphaIsOpaque");
3430 
3431  if (!popaque)
3432  return ERROR_INT("&opaque not defined", procName, 1);
3433  *popaque = FALSE;
3434  if (!pix)
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);
3440 
3441  data = pixGetData(pix);
3442  wpl = pixGetWpl(pix);
3443  pixGetDimensions(pix, &w, &h, NULL);
3444  for (i = 0; i < h; i++) {
3445  line = data + i * wpl;
3446  for (j = 0; j < w; j++) {
3447  alpha = GET_DATA_BYTE(line + j, L_ALPHA_CHANNEL);
3448  if (alpha ^ 0xff) /* not opaque */
3449  return 0;
3450  }
3451  }
3452 
3453  *popaque = TRUE;
3454  return 0;
3455 }
3456 
3457 
3458 /*-------------------------------------------------------------*
3459  * Setup helpers for 8 bpp byte processing *
3460  *-------------------------------------------------------------*/
3487 l_uint8 **
3489  l_int32 *pw,
3490  l_int32 *ph)
3491 {
3492 l_int32 w, h;
3493 
3494  PROCNAME("pixSetupByteProcessing");
3495 
3496  if (pw) *pw = 0;
3497  if (ph) *ph = 0;
3498  if (!pix || pixGetDepth(pix) != 8)
3499  return (l_uint8 **)ERROR_PTR("pix not defined or not 8 bpp",
3500  procName, NULL);
3501  pixGetDimensions(pix, &w, &h, NULL);
3502  if (pw) *pw = w;
3503  if (ph) *ph = h;
3504  if (pixGetColormap(pix))
3505  return (l_uint8 **)ERROR_PTR("pix has colormap", procName, NULL);
3506 
3507  pixEndianByteSwap(pix);
3508  return (l_uint8 **)pixGetLinePtrs(pix, NULL);
3509 }
3510 
3511 
3525 l_ok
3527  l_uint8 **lineptrs)
3528 {
3529  PROCNAME("pixCleanupByteProcessing");
3530 
3531  if (!pix)
3532  return ERROR_INT("pix not defined", procName, 1);
3533  if (!lineptrs)
3534  return ERROR_INT("lineptrs not defined", procName, 1);
3535 
3536  pixEndianByteSwap(pix);
3537  LEPT_FREE(lineptrs);
3538  return 0;
3539 }
3540 
3541 
3542 /*------------------------------------------------------------------------*
3543  * Setting parameters for antialias masking with alpha transforms *
3544  *------------------------------------------------------------------------*/
3567 void
3568 l_setAlphaMaskBorder(l_float32 val1,
3569  l_float32 val2)
3570 {
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;
3575 }
l_ok pixSetPadBitsBand(PIX *pix, l_int32 by, l_int32 bh, l_int32 val)
pixSetPadBitsBand()
Definition: pix2.c:1442
l_ok pixCopyRGBComponent(PIX *pixd, PIX *pixs, l_int32 comp)
pixCopyRGBComponent()
Definition: pix2.c:2690
l_int32 lineEndianByteSwap(l_uint32 *datad, l_uint32 *datas, l_int32 wpl)
lineEndianByteSwap()
Definition: pix2.c:3132
l_ok pixSetRGBPixel(PIX *pix, l_int32 x, l_int32 y, l_int32 rval, l_int32 gval, l_int32 bval)
pixSetRGBPixel()
Definition: pix2.c:382
PIX * pixAddMixedBorder(PIX *pixs, l_int32 left, l_int32 right, l_int32 top, l_int32 bot)
pixAddMixedBorder()
Definition: pix2.c:2210
PIX * pixRemoveColormap(PIX *pixs, l_int32 type)
pixRemoveColormap()
Definition: pixconv.c:328
l_uint32 * data
Definition: pix.h:154
l_ok pixSetRGBComponent(PIX *pixd, PIX *pixs, l_int32 comp)
pixSetRGBComponent()
Definition: pix2.c:2538
l_ok pixCleanupByteProcessing(PIX *pix, l_uint8 **lineptrs)
pixCleanupByteProcessing()
Definition: pix2.c:3526
PIX * pixConvertTo32(PIX *pixs)
pixConvertTo32()
Definition: pixconv.c:3332
#define PIX_CLR
Definition: pix.h:333
PIX * pixRemoveBorderGeneral(PIX *pixs, l_int32 left, l_int32 right, l_int32 top, l_int32 bot)
pixRemoveBorderGeneral()
Definition: pix2.c:1993
PIX * pixCreateTemplate(const PIX *pixs)
pixCreateTemplate()
Definition: pix1.c:383
l_ok pixSetComponentArbitrary(PIX *pix, l_int32 comp, l_int32 val)
pixSetComponentArbitrary()
Definition: pix2.c:1068
Definition: pix.h:204
void extractRGBAValues(l_uint32 pixel, l_int32 *prval, l_int32 *pgval, l_int32 *pbval, l_int32 *paval)
extractRGBAValues()
Definition: pix2.c:2842
l_ok pixSetInRectArbitrary(PIX *pix, BOX *box, l_uint32 val)
pixSetInRectArbitrary()
Definition: pix2.c:1195
PIXA * pixaCreate(l_int32 n)
pixaCreate()
Definition: pixabasic.c:167
void setPixelLow(l_uint32 *line, l_int32 x, l_int32 depth, l_uint32 val)
setPixelLow()
Definition: pix2.c:679
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()
Definition: rop.c:204
l_ok pixGetRasterData(PIX *pixs, l_uint8 **pdata, size_t *pnbytes)
pixGetRasterData()
Definition: pix2.c:3293
PIX * pixCopy(PIX *pixd, const PIX *pixs)
pixCopy()
Definition: pix1.c:705
PIX * pixConvertTo8(PIX *pixs, l_int32 cmapflag)
pixConvertTo8()
Definition: pixconv.c:3133
void ** pixGetLinePtrs(PIX *pix, l_int32 *psize)
pixGetLinePtrs()
Definition: pix1.c:1949
l_ok pixShiftAndTransferAlpha(PIX *pixd, PIX *pixs, l_float32 shiftx, l_float32 shifty)
pixShiftAndTransferAlpha()
Definition: pix2.c:2300
void lept_stderr(const char *fmt,...)
lept_stderr()
Definition: utils1.c:306
l_uint8 red
Definition: pix.h:177
BOX * boxClipToRectangle(BOX *box, l_int32 wi, l_int32 hi)
boxClipToRectangle()
Definition: boxfunc1.c:1728
PIX * pixCreate(l_int32 width, l_int32 height, l_int32 depth)
pixCreate()
Definition: pix1.c:315
l_ok pixSetAll(PIX *pix)
pixSetAll()
Definition: pix2.c:817
#define SET_DATA_QBIT(pdata, n, val)
Definition: arrayaccess.h:168
PIX * pixAddMirroredBorder(PIX *pixs, l_int32 left, l_int32 right, l_int32 top, l_int32 bot)
pixAddMirroredBorder()
Definition: pix2.c:2101
l_uint32 * pixGetData(PIX *pix)
pixGetData()
Definition: pix1.c:1763
PIX * pixAddBlackOrWhiteBorder(PIX *pixs, l_int32 left, l_int32 right, l_int32 top, l_int32 bot, l_int32 op)
pixAddBlackOrWhiteBorder()
Definition: pix2.c:1863
#define GET_DATA_BIT(pdata, n)
Definition: arrayaccess.h:123
l_ok setLineDataVal(l_uint32 *line, l_int32 j, l_int32 d, l_uint32 val)
setLineDataVal()
Definition: pix2.c:2952
l_ok pixClearInRect(PIX *pix, BOX *box)
pixClearInRect()
Definition: pix2.c:1118
l_ok pixSetAllGray(PIX *pix, l_int32 grayval)
pixSetAllGray()
Definition: pix2.c:859
l_ok pixSetOrClearBorder(PIX *pixs, l_int32 left, l_int32 right, l_int32 top, l_int32 bot, l_int32 op)
pixSetOrClearBorder()
Definition: pix2.c:1514
PIX * pixGetRGBComponent(PIX *pixs, l_int32 comp)
pixGetRGBComponent()
Definition: pix2.c:2479
l_uint8 blue
Definition: pix.h:175
PIX * pixAddBorder(PIX *pixs, l_int32 npix, l_uint32 val)
pixAddBorder()
Definition: pix2.c:1823
l_ok pixGetRandomPixel(PIX *pix, l_uint32 *pval, l_int32 *px, l_int32 *py)
pixGetRandomPixel()
Definition: pix2.c:488
#define SET_DATA_DIBIT(pdata, n, val)
Definition: arrayaccess.h:149
l_ok pixSetAllArbitrary(PIX *pix, l_uint32 val)
pixSetAllArbitrary()
Definition: pix2.c:951
l_ok pixSetBorderVal(PIX *pixs, l_int32 left, l_int32 right, l_int32 top, l_int32 bot, l_uint32 val)
pixSetBorderVal()
Definition: pix2.c:1563
#define CLEAR_DATA_BIT(pdata, n)
Definition: arrayaccess.h:131
PIX * pixEndianTwoByteSwapNew(PIX *pixs)
pixEndianTwoByteSwapNew()
Definition: pix2.c:3185
PIX * pixAlphaBlendUniform(PIX *pixs, l_uint32 color)
pixAlphaBlendUniform()
Definition: blend.c:2024
PIX * pixRemoveBorder(PIX *pixs, l_int32 npix)
pixRemoveBorder()
Definition: pix2.c:1972
l_ok pixaAddPix(PIXA *pixa, PIX *pix, l_int32 copyflag)
pixaAddPix()
Definition: pixabasic.c:506
l_uint8 ** pixSetupByteProcessing(PIX *pix, l_int32 *pw, l_int32 *ph)
pixSetupByteProcessing()
Definition: pix2.c:3488
l_uint32 h
Definition: pix.h:141
l_ok pixFlipPixel(PIX *pix, l_int32 x, l_int32 y)
pixFlipPixel()
Definition: pix2.c:602
l_ok pixClearPixel(PIX *pix, l_int32 x, l_int32 y)
pixClearPixel()
Definition: pix2.c:540
#define CLEAR_DATA_DIBIT(pdata, n)
Definition: arrayaccess.h:156
l_ok pixClearAll(PIX *pix)
pixClearAll()
Definition: pix2.c:789
l_ok pixSetCmapPixel(PIX *pix, l_int32 x, l_int32 y, l_int32 rval, l_int32 gval, l_int32 bval)
pixSetCmapPixel()
Definition: pix2.c:440
#define PIX_SET
Definition: pix.h:334
l_ok pixSetBorderRingVal(PIX *pixs, l_int32 dist, l_uint32 val)
pixSetBorderRingVal()
Definition: pix2.c:1667
l_ok pixSetPixel(PIX *pix, l_int32 x, l_int32 y, l_uint32 val)
pixSetPixel()
Definition: pix2.c:263
PIX * pixaDisplayTiledInRows(PIXA *pixa, l_int32 outdepth, l_int32 maxwidth, l_float32 scalefactor, l_int32 background, l_int32 spacing, l_int32 border)
pixaDisplayTiledInRows()
Definition: pixafunc2.c:746
l_ok pixcmapGetColor(PIXCMAP *cmap, l_int32 index, l_int32 *prval, l_int32 *pgval, l_int32 *pbval)
pixcmapGetColor()
Definition: colormap.c:824
l_int32 extractMinMaxComponent(l_uint32 pixel, l_int32 type)
extractMinMaxComponent()
Definition: pix2.c:2863
l_ok pixEndianByteSwap(PIX *pixs)
pixEndianByteSwap()
Definition: pix2.c:3074
l_ok composeRGBAPixel(l_int32 rval, l_int32 gval, l_int32 bval, l_int32 aval, l_uint32 *ppixel)
composeRGBAPixel()
Definition: pix2.c:2783
#define SET_DATA_BYTE(pdata, n, val)
Definition: arrayaccess.h:198
l_ok pixcmapAddNewColor(PIXCMAP *cmap, l_int32 rval, l_int32 gval, l_int32 bval, l_int32 *pindex)
pixcmapAddNewColor()
Definition: colormap.c:496
l_ok pixSetPadBits(PIX *pix, l_int32 val)
pixSetPadBits()
Definition: pix2.c:1382
#define GET_DATA_QBIT(pdata, n)
Definition: arrayaccess.h:164
l_ok pixSetBlackOrWhite(PIX *pixs, l_int32 op)
pixSetBlackOrWhite()
Definition: pix2.c:1021
l_ok pixEndianTwoByteSwap(PIX *pixs)
pixEndianTwoByteSwap()
Definition: pix2.c:3239
#define CLEAR_DATA_QBIT(pdata, n)
Definition: arrayaccess.h:175
#define GET_DATA_BYTE(pdata, n)
Definition: arrayaccess.h:188
#define SET_DATA_BIT_VAL(pdata, n, val)
Definition: arrayaccess.h:135
l_uint8 green
Definition: pix.h:176
Definition: pix.h:173
PIX * pixCreateRGBImage(PIX *pixr, PIX *pixg, PIX *pixb)
pixCreateRGBImage()
Definition: pix2.c:2423
PIX * pixAddContinuedBorder(PIX *pixs, l_int32 left, l_int32 right, l_int32 top, l_int32 bot)
pixAddContinuedBorder()
Definition: pix2.c:2257
PIX * pixClone(PIX *pixs)
pixClone()
Definition: pix1.c:593
void pixDestroy(PIX **ppix)
pixDestroy()
Definition: pix1.c:621
l_ok pixcmapAddNearestColor(PIXCMAP *cmap, l_int32 rval, l_int32 gval, l_int32 bval, l_int32 *pindex)
pixcmapAddNearestColor()
Definition: colormap.c:545
l_ok pixGetRGBLine(PIX *pixs, l_int32 row, l_uint8 *bufr, l_uint8 *bufg, l_uint8 *bufb)
pixGetRGBLine()
Definition: pix2.c:2897
Definition: pix.h:711
PIX * pixGetRGBComponentCmap(PIX *pixs, l_int32 comp)
pixGetRGBComponentCmap()
Definition: pix2.c:2600
l_ok pixGetBlackOrWhiteVal(PIX *pixs, l_int32 op, l_uint32 *pval)
pixGetBlackOrWhiteVal()
Definition: pix2.c:733
l_ok pixcmapIsValid(const PIXCMAP *cmap, PIX *pix, l_int32 *pvalid)
pixcmapIsValid()
Definition: colormap.c:317
Definition: pix.h:455
l_ok pixGetPixel(PIX *pix, l_int32 x, l_int32 y, l_uint32 *pval)
pixGetPixel()
Definition: pix2.c:190
PIX * pixEndianByteSwapNew(PIX *pixs)
pixEndianByteSwapNew()
Definition: pix2.c:3010
l_ok pixGetRGBPixel(PIX *pix, l_int32 x, l_int32 y, l_int32 *prval, l_int32 *pgval, l_int32 *pbval)
pixGetRGBPixel()
Definition: pix2.c:330
l_ok pixGetDimensions(const PIX *pix, l_int32 *pw, l_int32 *ph, l_int32 *pd)
pixGetDimensions()
Definition: pix1.c:1113
PIX * pixAddRepeatedBorder(PIX *pixs, l_int32 left, l_int32 right, l_int32 top, l_int32 bot)
pixAddRepeatedBorder()
Definition: pix2.c:2154
l_ok pixSetMirroredBorder(PIX *pixs, l_int32 left, l_int32 right, l_int32 top, l_int32 bot)
pixSetMirroredBorder()
Definition: pix2.c:1718
void l_setAlphaMaskBorder(l_float32 val1, l_float32 val2)
l_setAlphaMaskBorder()
Definition: pix2.c:3568
l_ok pixcmapAddBlackOrWhite(PIXCMAP *cmap, l_int32 color, l_int32 *pindex)
pixcmapAddBlackOrWhite()
Definition: colormap.c:639
#define GET_DATA_TWO_BYTES(pdata, n)
Definition: arrayaccess.h:212
#define GET_DATA_DIBIT(pdata, n)
Definition: arrayaccess.h:145
void * array
Definition: pix.h:161
l_ok pixInferResolution(PIX *pix, l_float32 longside, l_int32 *pres)
pixInferResolution()
Definition: pix2.c:3377
PIX * pixDisplayLayersRGBA(PIX *pixs, l_uint32 val, l_int32 maxw)
pixDisplayLayersRGBA()
Definition: pix2.c:2351
Definition: pix.h:138
#define PIX_SRC
Definition: pix.h:330
l_ok pixCopyColormap(PIX *pixd, const PIX *pixs)
pixCopyColormap()
Definition: pix1.c:816
l_ok pixAlphaIsOpaque(PIX *pix, l_int32 *popaque)
pixAlphaIsOpaque()
Definition: pix2.c:3423
void boxDestroy(BOX **pbox)
boxDestroy()
Definition: boxbasic.c:282
l_int32 pixcmapGetCount(const PIXCMAP *cmap)
pixcmapGetCount()
Definition: colormap.c:708
l_uint32 wpl
Definition: pix.h:144
PIX * pixRemoveBorderToSize(PIX *pixs, l_int32 wd, l_int32 hd)
pixRemoveBorderToSize()
Definition: pix2.c:2046
l_ok composeRGBPixel(l_int32 rval, l_int32 gval, l_int32 bval, l_uint32 *ppixel)
composeRGBPixel()
Definition: pix2.c:2751
l_ok pixCopySpp(PIX *pixd, const PIX *pixs)
pixCopySpp()
Definition: pix1.c:1236
l_int32 pixSizesEqual(const PIX *pix1, const PIX *pix2)
pixSizesEqual()
Definition: pix1.c:1985
l_ok boxGetGeometry(BOX *box, l_int32 *px, l_int32 *py, l_int32 *pw, l_int32 *ph)
boxGetGeometry()
Definition: boxbasic.c:313
Definition: pix.h:480
#define SET_DATA_TWO_BYTES(pdata, n, val)
Definition: arrayaccess.h:222
void pixaDestroy(PIXA **ppixa)
pixaDestroy()
Definition: pixabasic.c:412
PIX * pixCopyBorder(PIX *pixd, PIX *pixs, l_int32 left, l_int32 right, l_int32 top, l_int32 bot)
pixCopyBorder()
Definition: pix2.c:1769
l_ok pixSetInRect(PIX *pix, BOX *box)
pixSetInRect()
Definition: pix2.c:1153
void extractRGBValues(l_uint32 pixel, l_int32 *prval, l_int32 *pgval, l_int32 *pbval)
extractRGBValues()
Definition: pix2.c:2820
l_ok pixBlendInRect(PIX *pixs, BOX *box, l_uint32 val, l_float32 fract)
pixBlendInRect()
Definition: pix2.c:1296
#define SET_DATA_BIT(pdata, n)
Definition: arrayaccess.h:127
PIX * pixAddBorderGeneral(PIX *pixs, l_int32 left, l_int32 right, l_int32 top, l_int32 bot, l_uint32 val)
pixAddBorderGeneral()
Definition: pix2.c:1917