Leptonica  1.82.0
Image processing and image analysis suite
quadtree.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 
64 #ifdef HAVE_CONFIG_H
65 #include <config_auto.h>
66 #endif /* HAVE_CONFIG_H */
67 
68 #include <math.h>
69 #include "allheaders.h"
70 
71 #ifndef NO_CONSOLE_IO
72 #define DEBUG_BOXES 0
73 #endif /* !NO_CONSOLE_IO */
74 
75 
76 /*----------------------------------------------------------------------*
77  * Top-level quadtree linear statistics *
78  *----------------------------------------------------------------------*/
95 l_ok
97  l_int32 nlevels,
98  PIX *pix_ma,
99  FPIXA **pfpixa)
100 {
101 l_int32 i, j, w, h, size, n;
102 l_float32 val;
103 BOX *box;
104 BOXA *boxa;
105 BOXAA *baa;
106 FPIX *fpix;
107 PIX *pix_mac;
108 
109  PROCNAME("pixQuadtreeMean");
110 
111  if (!pfpixa)
112  return ERROR_INT("&fpixa not defined", procName, 1);
113  *pfpixa = NULL;
114  if (!pixs || pixGetDepth(pixs) != 8)
115  return ERROR_INT("pixs not defined or not 8 bpp", procName, 1);
116  pixGetDimensions(pixs, &w, &h, NULL);
117  if (nlevels > quadtreeMaxLevels(w, h))
118  return ERROR_INT("nlevels too large for image", procName, 1);
119 
120  if (!pix_ma)
121  pix_mac = pixBlockconvAccum(pixs);
122  else
123  pix_mac = pixClone(pix_ma);
124  if (!pix_mac)
125  return ERROR_INT("pix_mac not made", procName, 1);
126 
127  if ((baa = boxaaQuadtreeRegions(w, h, nlevels)) == NULL) {
128  pixDestroy(&pix_mac);
129  return ERROR_INT("baa not made", procName, 1);
130  }
131 
132  *pfpixa = fpixaCreate(nlevels);
133  for (i = 0; i < nlevels; i++) {
134  boxa = boxaaGetBoxa(baa, i, L_CLONE);
135  size = 1 << i;
136  n = boxaGetCount(boxa); /* n == size * size */
137  fpix = fpixCreate(size, size);
138  for (j = 0; j < n; j++) {
139  box = boxaGetBox(boxa, j, L_CLONE);
140  pixMeanInRectangle(pixs, box, pix_mac, &val);
141  fpixSetPixel(fpix, j % size, j / size, val);
142  boxDestroy(&box);
143  }
144  fpixaAddFPix(*pfpixa, fpix, L_INSERT);
145  boxaDestroy(&boxa);
146  }
147 
148  pixDestroy(&pix_mac);
149  boxaaDestroy(&baa);
150  return 0;
151 }
152 
153 
172 l_ok
174  l_int32 nlevels,
175  PIX *pix_ma,
176  DPIX *dpix_msa,
177  FPIXA **pfpixa_v,
178  FPIXA **pfpixa_rv)
179 {
180 l_int32 i, j, w, h, size, n;
181 l_float32 var, rvar;
182 BOX *box;
183 BOXA *boxa;
184 BOXAA *baa;
185 FPIX *fpixv, *fpixrv;
186 PIX *pix_mac; /* copy of mean accumulator */
187 DPIX *dpix_msac; /* msa clone */
188 
189  PROCNAME("pixQuadtreeVariance");
190 
191  if (!pfpixa_v && !pfpixa_rv)
192  return ERROR_INT("neither &fpixav nor &fpixarv defined", procName, 1);
193  if (pfpixa_v) *pfpixa_v = NULL;
194  if (pfpixa_rv) *pfpixa_rv = NULL;
195  if (!pixs || pixGetDepth(pixs) != 8)
196  return ERROR_INT("pixs not defined or not 8 bpp", procName, 1);
197  pixGetDimensions(pixs, &w, &h, NULL);
198  if (nlevels > quadtreeMaxLevels(w, h))
199  return ERROR_INT("nlevels too large for image", procName, 1);
200 
201  if (!pix_ma)
202  pix_mac = pixBlockconvAccum(pixs);
203  else
204  pix_mac = pixClone(pix_ma);
205  if (!pix_mac)
206  return ERROR_INT("pix_mac not made", procName, 1);
207  if (!dpix_msa)
208  dpix_msac = pixMeanSquareAccum(pixs);
209  else
210  dpix_msac = dpixClone(dpix_msa);
211  if (!dpix_msac) {
212  pixDestroy(&pix_mac);
213  return ERROR_INT("dpix_msac not made", procName, 1);
214  }
215 
216  if ((baa = boxaaQuadtreeRegions(w, h, nlevels)) == NULL) {
217  pixDestroy(&pix_mac);
218  dpixDestroy(&dpix_msac);
219  return ERROR_INT("baa not made", procName, 1);
220  }
221 
222  if (pfpixa_v) *pfpixa_v = fpixaCreate(nlevels);
223  if (pfpixa_rv) *pfpixa_rv = fpixaCreate(nlevels);
224  for (i = 0; i < nlevels; i++) {
225  boxa = boxaaGetBoxa(baa, i, L_CLONE);
226  size = 1 << i;
227  n = boxaGetCount(boxa); /* n == size * size */
228  if (pfpixa_v) fpixv = fpixCreate(size, size);
229  if (pfpixa_rv) fpixrv = fpixCreate(size, size);
230  for (j = 0; j < n; j++) {
231  box = boxaGetBox(boxa, j, L_CLONE);
232  pixVarianceInRectangle(pixs, box, pix_mac, dpix_msac, &var, &rvar);
233  if (pfpixa_v) fpixSetPixel(fpixv, j % size, j / size, var);
234  if (pfpixa_rv) fpixSetPixel(fpixrv, j % size, j / size, rvar);
235  boxDestroy(&box);
236  }
237  if (pfpixa_v) fpixaAddFPix(*pfpixa_v, fpixv, L_INSERT);
238  if (pfpixa_rv) fpixaAddFPix(*pfpixa_rv, fpixrv, L_INSERT);
239  boxaDestroy(&boxa);
240  }
241 
242  pixDestroy(&pix_mac);
243  dpixDestroy(&dpix_msac);
244  boxaaDestroy(&baa);
245  return 0;
246 }
247 
248 
249 /*----------------------------------------------------------------------*
250  * Statistics in an arbitrary rectangle *
251  *----------------------------------------------------------------------*/
268 l_ok
270  BOX *box,
271  PIX *pixma,
272  l_float32 *pval)
273 {
274 l_int32 w, h, bx, by, bw, bh;
275 l_uint32 val00, val01, val10, val11;
276 l_float32 norm;
277 BOX *boxc;
278 
279  PROCNAME("pixMeanInRectangle");
280 
281  if (!pval)
282  return ERROR_INT("&val not defined", procName, 1);
283  *pval = 0.0;
284  if (!pixs || pixGetDepth(pixs) != 8)
285  return ERROR_INT("pixs not defined", procName, 1);
286  if (!box)
287  return ERROR_INT("box not defined", procName, 1);
288  if (!pixma)
289  return ERROR_INT("pixma not defined", procName, 1);
290 
291  /* Clip rectangle to image */
292  pixGetDimensions(pixs, &w, &h, NULL);
293  boxc = boxClipToRectangle(box, w, h);
294  boxGetGeometry(boxc, &bx, &by, &bw, &bh);
295  boxDestroy(&boxc);
296 
297  if (bw == 0 || bh == 0)
298  return ERROR_INT("no pixels in box", procName, 1);
299 
300  /* Use up to 4 points in the accumulator */
301  norm = 1.0 / ((l_float32)(bw) * bh);
302  if (bx > 0 && by > 0) {
303  pixGetPixel(pixma, bx + bw - 1, by + bh - 1, &val11);
304  pixGetPixel(pixma, bx + bw - 1, by - 1, &val10);
305  pixGetPixel(pixma, bx - 1, by + bh - 1, &val01);
306  pixGetPixel(pixma, bx - 1, by - 1, &val00);
307  *pval = norm * (val11 - val01 + val00 - val10);
308  } else if (by > 0) { /* bx == 0 */
309  pixGetPixel(pixma, bw - 1, by + bh - 1, &val11);
310  pixGetPixel(pixma, bw - 1, by - 1, &val10);
311  *pval = norm * (val11 - val10);
312  } else if (bx > 0) { /* by == 0 */
313  pixGetPixel(pixma, bx + bw - 1, bh - 1, &val11);
314  pixGetPixel(pixma, bx - 1, bh - 1, &val01);
315  *pval = norm * (val11 - val01);
316  } else { /* bx == 0 && by == 0 */
317  pixGetPixel(pixma, bw - 1, bh - 1, &val11);
318  *pval = norm * val11;
319  }
320 
321  return 0;
322 }
323 
324 
344 l_ok
346  BOX *box,
347  PIX *pix_ma,
348  DPIX *dpix_msa,
349  l_float32 *pvar,
350  l_float32 *prvar)
351 {
352 l_int32 w, h, bx, by, bw, bh;
353 l_uint32 val00, val01, val10, val11;
354 l_float64 dval00, dval01, dval10, dval11, mval, msval, var, norm;
355 BOX *boxc;
356 
357  PROCNAME("pixVarianceInRectangle");
358 
359  if (!pvar && !prvar)
360  return ERROR_INT("neither &var nor &rvar defined", procName, 1);
361  if (pvar) *pvar = 0.0;
362  if (prvar) *prvar = 0.0;
363  if (!pixs || pixGetDepth(pixs) != 8)
364  return ERROR_INT("pixs not defined", procName, 1);
365  if (!box)
366  return ERROR_INT("box not defined", procName, 1);
367  if (!pix_ma)
368  return ERROR_INT("pix_ma not defined", procName, 1);
369  if (!dpix_msa)
370  return ERROR_INT("dpix_msa not defined", procName, 1);
371 
372  /* Clip rectangle to image */
373  pixGetDimensions(pixs, &w, &h, NULL);
374  boxc = boxClipToRectangle(box, w, h);
375  boxGetGeometry(boxc, &bx, &by, &bw, &bh);
376  boxDestroy(&boxc);
377 
378  if (bw == 0 || bh == 0)
379  return ERROR_INT("no pixels in box", procName, 1);
380 
381  /* Use up to 4 points in the accumulators */
382  norm = 1.0 / ((l_float32)(bw) * bh);
383  if (bx > 0 && by > 0) {
384  pixGetPixel(pix_ma, bx + bw - 1, by + bh - 1, &val11);
385  pixGetPixel(pix_ma, bx + bw - 1, by - 1, &val10);
386  pixGetPixel(pix_ma, bx - 1, by + bh - 1, &val01);
387  pixGetPixel(pix_ma, bx - 1, by - 1, &val00);
388  dpixGetPixel(dpix_msa, bx + bw - 1, by + bh - 1, &dval11);
389  dpixGetPixel(dpix_msa, bx + bw - 1, by - 1, &dval10);
390  dpixGetPixel(dpix_msa, bx - 1, by + bh - 1, &dval01);
391  dpixGetPixel(dpix_msa, bx - 1, by - 1, &dval00);
392  mval = norm * (val11 - val01 + val00 - val10);
393  msval = norm * (dval11 - dval01 + dval00 - dval10);
394  var = (msval - mval * mval);
395  if (pvar) *pvar = (l_float32)var;
396  if (prvar) *prvar = (l_float32)(sqrt(var));
397  } else if (by > 0) { /* bx == 0 */
398  pixGetPixel(pix_ma, bw - 1, by + bh - 1, &val11);
399  pixGetPixel(pix_ma, bw - 1, by - 1, &val10);
400  dpixGetPixel(dpix_msa, bw - 1, by + bh - 1, &dval11);
401  dpixGetPixel(dpix_msa, bw - 1, by - 1, &dval10);
402  mval = norm * (val11 - val10);
403  msval = norm * (dval11 - dval10);
404  var = (msval - mval * mval);
405  if (pvar) *pvar = (l_float32)var;
406  if (prvar) *prvar = (l_float32)(sqrt(var));
407  } else if (bx > 0) { /* by == 0 */
408  pixGetPixel(pix_ma, bx + bw - 1, bh - 1, &val11);
409  pixGetPixel(pix_ma, bx - 1, bh - 1, &val01);
410  dpixGetPixel(dpix_msa, bx + bw - 1, bh - 1, &dval11);
411  dpixGetPixel(dpix_msa, bx - 1, bh - 1, &dval01);
412  mval = norm * (val11 - val01);
413  msval = norm * (dval11 - dval01);
414  var = (msval - mval * mval);
415  if (pvar) *pvar = (l_float32)var;
416  if (prvar) *prvar = (l_float32)(sqrt(var));
417  } else { /* bx == 0 && by == 0 */
418  pixGetPixel(pix_ma, bw - 1, bh - 1, &val11);
419  dpixGetPixel(dpix_msa, bw - 1, bh - 1, &dval11);
420  mval = norm * val11;
421  msval = norm * dval11;
422  var = (msval - mval * mval);
423  if (pvar) *pvar = (l_float32)var;
424  if (prvar) *prvar = (l_float32)(sqrt(var));
425  }
426 
427  return 0;
428 }
429 
430 
431 /*----------------------------------------------------------------------*
432  * Quadtree regions *
433  *----------------------------------------------------------------------*/
452 BOXAA *
454  l_int32 h,
455  l_int32 nlevels)
456 {
457 l_int32 i, j, k, maxpts, nside, nbox, bw, bh;
458 l_int32 *xstart, *xend, *ystart, *yend;
459 BOX *box;
460 BOXA *boxa;
461 BOXAA *baa;
462 
463  PROCNAME("boxaaQuadtreeRegions");
464 
465  if (nlevels < 1)
466  return (BOXAA *)ERROR_PTR("nlevels must be >= 1", procName, NULL);
467  if (w < (1 << (nlevels - 1)))
468  return (BOXAA *)ERROR_PTR("w doesn't support nlevels", procName, NULL);
469  if (h < (1 << (nlevels - 1)))
470  return (BOXAA *)ERROR_PTR("h doesn't support nlevels", procName, NULL);
471 
472  baa = boxaaCreate(nlevels);
473  maxpts = 1 << (nlevels - 1);
474  xstart = (l_int32 *)LEPT_CALLOC(maxpts, sizeof(l_int32));
475  xend = (l_int32 *)LEPT_CALLOC(maxpts, sizeof(l_int32));
476  ystart = (l_int32 *)LEPT_CALLOC(maxpts, sizeof(l_int32));
477  yend = (l_int32 *)LEPT_CALLOC(maxpts, sizeof(l_int32));
478  for (k = 0; k < nlevels; k++) {
479  nside = 1 << k; /* number of boxes in each direction */
480  for (i = 0; i < nside; i++) {
481  xstart[i] = (w - 1) * i / nside;
482  if (i > 0) xstart[i]++;
483  xend[i] = (w - 1) * (i + 1) / nside;
484  ystart[i] = (h - 1) * i / nside;
485  if (i > 0) ystart[i]++;
486  yend[i] = (h - 1) * (i + 1) / nside;
487 #if DEBUG_BOXES
488  lept_stderr(
489  "k = %d, xs[%d] = %d, xe[%d] = %d, ys[%d] = %d, ye[%d] = %d\n",
490  k, i, xstart[i], i, xend[i], i, ystart[i], i, yend[i]);
491 #endif /* DEBUG_BOXES */
492  }
493  nbox = 1 << (2 * k);
494  boxa = boxaCreate(nbox);
495  for (i = 0; i < nside; i++) {
496  bh = yend[i] - ystart[i] + 1;
497  for (j = 0; j < nside; j++) {
498  bw = xend[j] - xstart[j] + 1;
499  box = boxCreate(xstart[j], ystart[i], bw, bh);
500  boxaAddBox(boxa, box, L_INSERT);
501  }
502  }
503  boxaaAddBoxa(baa, boxa, L_INSERT);
504  }
505 
506  LEPT_FREE(xstart);
507  LEPT_FREE(xend);
508  LEPT_FREE(ystart);
509  LEPT_FREE(yend);
510  return baa;
511 }
512 
513 
514 /*----------------------------------------------------------------------*
515  * Quadtree access *
516  *----------------------------------------------------------------------*/
533 l_ok
535  l_int32 level,
536  l_int32 x,
537  l_int32 y,
538  l_float32 *pval)
539 {
540 l_int32 n;
541 
542  PROCNAME("quadtreeGetParent");
543 
544  if (!pval)
545  return ERROR_INT("&val not defined", procName, 1);
546  *pval = 0.0;
547  if (!fpixa)
548  return ERROR_INT("fpixa not defined", procName, 1);
549  n = fpixaGetCount(fpixa);
550  if (level < 1 || level >= n)
551  return ERROR_INT("invalid level", procName, 1);
552 
553  if (fpixaGetPixel(fpixa, level - 1, x / 2, y / 2, pval) != 0)
554  return ERROR_INT("invalid coordinates", procName, 1);
555  return 0;
556 }
557 
558 
576 l_ok
578  l_int32 level,
579  l_int32 x,
580  l_int32 y,
581  l_float32 *pval00,
582  l_float32 *pval10,
583  l_float32 *pval01,
584  l_float32 *pval11)
585 {
586 l_int32 n;
587 
588  PROCNAME("quadtreeGetChildren");
589 
590  if (!pval00 || !pval01 || !pval10 || !pval11)
591  return ERROR_INT("&val* not all defined", procName, 1);
592  *pval00 = *pval10 = *pval01 = *pval11 = 0.0;
593  if (!fpixa)
594  return ERROR_INT("fpixa not defined", procName, 1);
595  n = fpixaGetCount(fpixa);
596  if (level < 0 || level >= n - 1)
597  return ERROR_INT("invalid level", procName, 1);
598 
599  if (fpixaGetPixel(fpixa, level + 1, 2 * x, 2 * y, pval00) != 0)
600  return ERROR_INT("invalid coordinates", procName, 1);
601  fpixaGetPixel(fpixa, level + 1, 2 * x + 1, 2 * y, pval10);
602  fpixaGetPixel(fpixa, level + 1, 2 * x, 2 * y + 1, pval01);
603  fpixaGetPixel(fpixa, level + 1, 2 * x + 1, 2 * y + 1, pval11);
604  return 0;
605 }
606 
607 
622 l_int32
624  l_int32 h)
625 {
626 l_int32 i, minside;
627 
628  minside = L_MIN(w, h);
629  for (i = 0; i < 20; i++) { /* 2^10 = one million */
630  if (minside < (1.5 * (1 << i)))
631  return i - 1;
632  }
633 
634  return -1; /* fail if the image has over a trillion pixels! */
635 }
636 
637 
638 /*----------------------------------------------------------------------*
639  * Display quadtree *
640  *----------------------------------------------------------------------*/
657 PIX *
659  l_int32 factor,
660  l_int32 fontsize)
661 {
662 char buf[256];
663 l_int32 nlevels, i, mag, w;
664 L_BMF *bmf;
665 FPIX *fpix;
666 PIX *pixt1, *pixt2, *pixt3, *pixt4, *pixd;
667 PIXA *pixat;
668 
669  PROCNAME("fpixaDisplayQuadtree");
670 
671  if (!fpixa)
672  return (PIX *)ERROR_PTR("fpixa not defined", procName, NULL);
673 
674  if ((nlevels = fpixaGetCount(fpixa)) == 0)
675  return (PIX *)ERROR_PTR("pixas empty", procName, NULL);
676 
677  if ((bmf = bmfCreate(NULL, fontsize)) == NULL)
678  L_ERROR("bmf not made; text will not be added", procName);
679  pixat = pixaCreate(nlevels);
680  for (i = 0; i < nlevels; i++) {
681  fpix = fpixaGetFPix(fpixa, i, L_CLONE);
682  pixt1 = fpixConvertToPix(fpix, 8, L_CLIP_TO_ZERO, 0);
683  mag = factor * (1 << (nlevels - i - 1));
684  pixt2 = pixExpandReplicate(pixt1, mag);
685  pixt3 = pixConvertTo32(pixt2);
686  snprintf(buf, sizeof(buf), "Level %d\n", i);
687  pixt4 = pixAddSingleTextblock(pixt3, bmf, buf, 0xff000000,
688  L_ADD_BELOW, NULL);
689  pixaAddPix(pixat, pixt4, L_INSERT);
690  fpixDestroy(&fpix);
691  pixDestroy(&pixt1);
692  pixDestroy(&pixt2);
693  pixDestroy(&pixt3);
694  }
695  w = pixGetWidth(pixt4);
696  pixd = pixaDisplayTiledInRows(pixat, 32, nlevels * (w + 80), 1.0, 0, 30, 2);
697 
698  pixaDestroy(&pixat);
699  bmfDestroy(&bmf);
700  return pixd;
701 }
void bmfDestroy(L_BMF **pbmf)
bmfDestroy()
Definition: bmf.c:169
L_BMF * bmfCreate(const char *dir, l_int32 fontsize)
bmfCreate()
Definition: bmf.c:117
void boxDestroy(BOX **pbox)
boxDestroy()
Definition: boxbasic.c:282
BOXAA * boxaaCreate(l_int32 n)
boxaaCreate()
Definition: boxbasic.c:1244
l_int32 boxaGetCount(BOXA *boxa)
boxaGetCount()
Definition: boxbasic.c:734
l_ok boxaaAddBoxa(BOXAA *baa, BOXA *ba, l_int32 copyflag)
boxaaAddBoxa()
Definition: boxbasic.c:1346
l_ok boxGetGeometry(BOX *box, l_int32 *px, l_int32 *py, l_int32 *pw, l_int32 *ph)
boxGetGeometry()
Definition: boxbasic.c:313
l_ok boxaAddBox(BOXA *boxa, BOX *box, l_int32 copyflag)
boxaAddBox()
Definition: boxbasic.c:620
void boxaDestroy(BOXA **pboxa)
boxaDestroy()
Definition: boxbasic.c:583
BOXA * boxaaGetBoxa(BOXAA *baa, l_int32 index, l_int32 accessflag)
boxaaGetBoxa()
Definition: boxbasic.c:1501
BOX * boxaGetBox(BOXA *boxa, l_int32 index, l_int32 accessflag)
boxaGetBox()
Definition: boxbasic.c:779
void boxaaDestroy(BOXAA **pbaa)
boxaaDestroy()
Definition: boxbasic.c:1310
BOX * boxCreate(l_int32 x, l_int32 y, l_int32 w, l_int32 h)
boxCreate()
Definition: boxbasic.c:172
BOXA * boxaCreate(l_int32 n)
boxaCreate()
Definition: boxbasic.c:502
BOX * boxClipToRectangle(BOX *box, l_int32 wi, l_int32 hi)
boxClipToRectangle()
Definition: boxfunc1.c:1728
PIX * pixBlockconvAccum(PIX *pixs)
pixBlockconvAccum()
Definition: convolve.c:460
DPIX * pixMeanSquareAccum(PIX *pixs)
pixMeanSquareAccum()
Definition: convolve.c:1377
l_ok fpixaAddFPix(FPIXA *fpixa, FPIX *fpix, l_int32 copyflag)
fpixaAddFPix()
Definition: fpix1.c:751
void dpixDestroy(DPIX **pdpix)
dpixDestroy()
Definition: fpix1.c:1214
l_ok fpixaGetPixel(FPIXA *fpixa, l_int32 index, l_int32 x, l_int32 y, l_float32 *pval)
fpixaGetPixel()
Definition: fpix1.c:1002
DPIX * dpixClone(DPIX *dpix)
dpixClone()
Definition: fpix1.c:1159
l_ok dpixGetPixel(DPIX *dpix, l_int32 x, l_int32 y, l_float64 *pval)
dpixGetPixel()
Definition: fpix1.c:1485
FPIX * fpixaGetFPix(FPIXA *fpixa, l_int32 index, l_int32 accesstype)
fpixaGetFPix()
Definition: fpix1.c:907
FPIXA * fpixaCreate(l_int32 n)
fpixaCreate()
Definition: fpix1.c:631
l_ok fpixSetPixel(FPIX *fpix, l_int32 x, l_int32 y, l_float32 val)
fpixSetPixel()
Definition: fpix1.c:600
void fpixDestroy(FPIX **pfpix)
fpixDestroy()
Definition: fpix1.c:292
l_int32 fpixaGetCount(FPIXA *fpixa)
fpixaGetCount()
Definition: fpix1.c:866
FPIX * fpixCreate(l_int32 width, l_int32 height)
fpixCreate()
Definition: fpix1.c:156
PIX * fpixConvertToPix(FPIX *fpixs, l_int32 outdepth, l_int32 negvals, l_int32 errorflag)
fpixConvertToPix()
Definition: fpix2.c:324
void pixDestroy(PIX **ppix)
pixDestroy()
Definition: pix1.c:621
l_ok pixGetDimensions(const PIX *pix, l_int32 *pw, l_int32 *ph, l_int32 *pd)
pixGetDimensions()
Definition: pix1.c:1113
PIX * pixClone(PIX *pixs)
pixClone()
Definition: pix1.c:593
l_ok pixGetPixel(PIX *pix, l_int32 x, l_int32 y, l_uint32 *pval)
pixGetPixel()
Definition: pix2.c:190
@ L_ADD_BELOW
Definition: pix.h:1210
@ L_CLONE
Definition: pix.h:713
@ L_INSERT
Definition: pix.h:711
@ L_CLIP_TO_ZERO
Definition: pix.h:1269
l_ok pixaAddPix(PIXA *pixa, PIX *pix, l_int32 copyflag)
pixaAddPix()
Definition: pixabasic.c:506
void pixaDestroy(PIXA **ppixa)
pixaDestroy()
Definition: pixabasic.c:412
PIXA * pixaCreate(l_int32 n)
pixaCreate()
Definition: pixabasic.c:167
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
PIX * pixConvertTo32(PIX *pixs)
pixConvertTo32()
Definition: pixconv.c:3332
l_ok pixMeanInRectangle(PIX *pixs, BOX *box, PIX *pixma, l_float32 *pval)
pixMeanInRectangle()
Definition: quadtree.c:269
BOXAA * boxaaQuadtreeRegions(l_int32 w, l_int32 h, l_int32 nlevels)
boxaaQuadtreeRegions()
Definition: quadtree.c:453
l_int32 quadtreeMaxLevels(l_int32 w, l_int32 h)
quadtreeMaxLevels()
Definition: quadtree.c:623
l_ok pixQuadtreeVariance(PIX *pixs, l_int32 nlevels, PIX *pix_ma, DPIX *dpix_msa, FPIXA **pfpixa_v, FPIXA **pfpixa_rv)
pixQuadtreeVariance()
Definition: quadtree.c:173
l_ok quadtreeGetParent(FPIXA *fpixa, l_int32 level, l_int32 x, l_int32 y, l_float32 *pval)
quadtreeGetParent()
Definition: quadtree.c:534
PIX * fpixaDisplayQuadtree(FPIXA *fpixa, l_int32 factor, l_int32 fontsize)
fpixaDisplayQuadtree()
Definition: quadtree.c:658
l_ok quadtreeGetChildren(FPIXA *fpixa, l_int32 level, l_int32 x, l_int32 y, l_float32 *pval00, l_float32 *pval10, l_float32 *pval01, l_float32 *pval11)
quadtreeGetChildren()
Definition: quadtree.c:577
l_ok pixVarianceInRectangle(PIX *pixs, BOX *box, PIX *pix_ma, DPIX *dpix_msa, l_float32 *pvar, l_float32 *prvar)
pixVarianceInRectangle()
Definition: quadtree.c:345
l_ok pixQuadtreeMean(PIX *pixs, l_int32 nlevels, PIX *pix_ma, FPIXA **pfpixa)
pixQuadtreeMean()
Definition: quadtree.c:96
PIX * pixExpandReplicate(PIX *pixs, l_int32 factor)
pixExpandReplicate()
Definition: scale2.c:872
Definition: pix.h:481
Definition: pix.h:492
Definition: pix.h:502
Definition: pix.h:610
Definition: pix.h:579
Definition: pix.h:594
Definition: bmf.h:47
Definition: pix.h:139
Definition: pix.h:456
PIX * pixAddSingleTextblock(PIX *pixs, L_BMF *bmf, const char *textstr, l_uint32 val, l_int32 location, l_int32 *poverflow)
pixAddSingleTextblock()
Definition: textops.c:120
void lept_stderr(const char *fmt,...)
lept_stderr()
Definition: utils1.c:306