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 *----------------------------------------------------------------------*/
95l_ok
96pixQuadtreeMean(PIX *pixs,
97 l_int32 nlevels,
98 PIX *pix_ma,
99 FPIXA **pfpixa)
100{
101l_int32 i, j, w, h, size, n;
102l_float32 val;
103BOX *box;
104BOXA *boxa;
105BOXAA *baa;
106FPIX *fpix;
107PIX *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
172l_ok
173pixQuadtreeVariance(PIX *pixs,
174 l_int32 nlevels,
175 PIX *pix_ma,
176 DPIX *dpix_msa,
177 FPIXA **pfpixa_v,
178 FPIXA **pfpixa_rv)
179{
180l_int32 i, j, w, h, size, n;
181l_float32 var, rvar;
182BOX *box;
183BOXA *boxa;
184BOXAA *baa;
185FPIX *fpixv, *fpixrv;
186PIX *pix_mac; /* copy of mean accumulator */
187DPIX *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 *----------------------------------------------------------------------*/
268l_ok
269pixMeanInRectangle(PIX *pixs,
270 BOX *box,
271 PIX *pixma,
272 l_float32 *pval)
273{
274l_int32 w, h, bx, by, bw, bh;
275l_uint32 val00, val01, val10, val11;
276l_float32 norm;
277BOX *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
344l_ok
345pixVarianceInRectangle(PIX *pixs,
346 BOX *box,
347 PIX *pix_ma,
348 DPIX *dpix_msa,
349 l_float32 *pvar,
350 l_float32 *prvar)
351{
352l_int32 w, h, bx, by, bw, bh;
353l_uint32 val00, val01, val10, val11;
354l_float64 dval00, dval01, dval10, dval11, mval, msval, var, norm;
355BOX *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 *----------------------------------------------------------------------*/
452BOXAA *
453boxaaQuadtreeRegions(l_int32 w,
454 l_int32 h,
455 l_int32 nlevels)
456{
457l_int32 i, j, k, maxpts, nside, nbox, bw, bh;
458l_int32 *xstart, *xend, *ystart, *yend;
459BOX *box;
460BOXA *boxa;
461BOXAA *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 *----------------------------------------------------------------------*/
533l_ok
534quadtreeGetParent(FPIXA *fpixa,
535 l_int32 level,
536 l_int32 x,
537 l_int32 y,
538 l_float32 *pval)
539{
540l_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
576l_ok
577quadtreeGetChildren(FPIXA *fpixa,
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{
586l_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
622l_int32
623quadtreeMaxLevels(l_int32 w,
624 l_int32 h)
625{
626l_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 *----------------------------------------------------------------------*/
657PIX *
658fpixaDisplayQuadtree(FPIXA *fpixa,
659 l_int32 factor,
660 l_int32 fontsize)
661{
662char buf[256];
663l_int32 nlevels, i, mag, w;
664L_BMF *bmf;
665FPIX *fpix;
666PIX *pixt1, *pixt2, *pixt3, *pixt4, *pixd;
667PIXA *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}
bmfDestroy
void bmfDestroy(L_BMF **pbmf)
bmfDestroy()
Definition: bmf.c:169
bmfCreate
L_BMF * bmfCreate(const char *dir, l_int32 fontsize)
bmfCreate()
Definition: bmf.c:117
boxaaGetBoxa
BOXA * boxaaGetBoxa(BOXAA *baa, l_int32 index, l_int32 accessflag)
boxaaGetBoxa()
Definition: boxbasic.c:1501
boxaGetBox
BOX * boxaGetBox(BOXA *boxa, l_int32 index, l_int32 accessflag)
boxaGetBox()
Definition: boxbasic.c:779
boxDestroy
void boxDestroy(BOX **pbox)
boxDestroy()
Definition: boxbasic.c:282
boxCreate
BOX * boxCreate(l_int32 x, l_int32 y, l_int32 w, l_int32 h)
boxCreate()
Definition: boxbasic.c:172
boxaaCreate
BOXAA * boxaaCreate(l_int32 n)
boxaaCreate()
Definition: boxbasic.c:1244
boxaGetCount
l_int32 boxaGetCount(BOXA *boxa)
boxaGetCount()
Definition: boxbasic.c:734
boxaaAddBoxa
l_ok boxaaAddBoxa(BOXAA *baa, BOXA *ba, l_int32 copyflag)
boxaaAddBoxa()
Definition: boxbasic.c:1346
boxGetGeometry
l_ok boxGetGeometry(BOX *box, l_int32 *px, l_int32 *py, l_int32 *pw, l_int32 *ph)
boxGetGeometry()
Definition: boxbasic.c:313
boxaCreate
BOXA * boxaCreate(l_int32 n)
boxaCreate()
Definition: boxbasic.c:502
boxaAddBox
l_ok boxaAddBox(BOXA *boxa, BOX *box, l_int32 copyflag)
boxaAddBox()
Definition: boxbasic.c:620
boxaDestroy
void boxaDestroy(BOXA **pboxa)
boxaDestroy()
Definition: boxbasic.c:583
boxaaDestroy
void boxaaDestroy(BOXAA **pbaa)
boxaaDestroy()
Definition: boxbasic.c:1310
boxClipToRectangle
BOX * boxClipToRectangle(BOX *box, l_int32 wi, l_int32 hi)
boxClipToRectangle()
Definition: boxfunc1.c:1728
pixMeanSquareAccum
DPIX * pixMeanSquareAccum(PIX *pixs)
pixMeanSquareAccum()
Definition: convolve.c:1377
pixBlockconvAccum
PIX * pixBlockconvAccum(PIX *pixs)
pixBlockconvAccum()
Definition: convolve.c:460
dpixClone
DPIX * dpixClone(DPIX *dpix)
dpixClone()
Definition: fpix1.c:1159
fpixCreate
FPIX * fpixCreate(l_int32 width, l_int32 height)
fpixCreate()
Definition: fpix1.c:156
fpixaAddFPix
l_ok fpixaAddFPix(FPIXA *fpixa, FPIX *fpix, l_int32 copyflag)
fpixaAddFPix()
Definition: fpix1.c:751
dpixDestroy
void dpixDestroy(DPIX **pdpix)
dpixDestroy()
Definition: fpix1.c:1214
fpixaGetPixel
l_ok fpixaGetPixel(FPIXA *fpixa, l_int32 index, l_int32 x, l_int32 y, l_float32 *pval)
fpixaGetPixel()
Definition: fpix1.c:1002
fpixaGetFPix
FPIX * fpixaGetFPix(FPIXA *fpixa, l_int32 index, l_int32 accesstype)
fpixaGetFPix()
Definition: fpix1.c:907
dpixGetPixel
l_ok dpixGetPixel(DPIX *dpix, l_int32 x, l_int32 y, l_float64 *pval)
dpixGetPixel()
Definition: fpix1.c:1485
fpixaCreate
FPIXA * fpixaCreate(l_int32 n)
fpixaCreate()
Definition: fpix1.c:631
fpixSetPixel
l_ok fpixSetPixel(FPIX *fpix, l_int32 x, l_int32 y, l_float32 val)
fpixSetPixel()
Definition: fpix1.c:600
fpixDestroy
void fpixDestroy(FPIX **pfpix)
fpixDestroy()
Definition: fpix1.c:292
fpixaGetCount
l_int32 fpixaGetCount(FPIXA *fpixa)
fpixaGetCount()
Definition: fpix1.c:866
fpixConvertToPix
PIX * fpixConvertToPix(FPIX *fpixs, l_int32 outdepth, l_int32 negvals, l_int32 errorflag)
fpixConvertToPix()
Definition: fpix2.c:324
pixDestroy
void pixDestroy(PIX **ppix)
pixDestroy()
Definition: pix1.c:621
pixGetDimensions
l_ok pixGetDimensions(const PIX *pix, l_int32 *pw, l_int32 *ph, l_int32 *pd)
pixGetDimensions()
Definition: pix1.c:1113
pixClone
PIX * pixClone(PIX *pixs)
pixClone()
Definition: pix1.c:593
pixGetPixel
l_ok pixGetPixel(PIX *pix, l_int32 x, l_int32 y, l_uint32 *pval)
pixGetPixel()
Definition: pix2.c:190
L_ADD_BELOW
@ L_ADD_BELOW
Definition: pix.h:1210
L_CLONE
@ L_CLONE
Definition: pix.h:713
L_INSERT
@ L_INSERT
Definition: pix.h:711
L_CLIP_TO_ZERO
@ L_CLIP_TO_ZERO
Definition: pix.h:1269
pixaAddPix
l_ok pixaAddPix(PIXA *pixa, PIX *pix, l_int32 copyflag)
pixaAddPix()
Definition: pixabasic.c:506
pixaDestroy
void pixaDestroy(PIXA **ppixa)
pixaDestroy()
Definition: pixabasic.c:412
pixaCreate
PIXA * pixaCreate(l_int32 n)
pixaCreate()
Definition: pixabasic.c:167
pixaDisplayTiledInRows
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
pixConvertTo32
PIX * pixConvertTo32(PIX *pixs)
pixConvertTo32()
Definition: pixconv.c:3332
pixMeanInRectangle
l_ok pixMeanInRectangle(PIX *pixs, BOX *box, PIX *pixma, l_float32 *pval)
pixMeanInRectangle()
Definition: quadtree.c:269
fpixaDisplayQuadtree
PIX * fpixaDisplayQuadtree(FPIXA *fpixa, l_int32 factor, l_int32 fontsize)
fpixaDisplayQuadtree()
Definition: quadtree.c:658
quadtreeMaxLevels
l_int32 quadtreeMaxLevels(l_int32 w, l_int32 h)
quadtreeMaxLevels()
Definition: quadtree.c:623
boxaaQuadtreeRegions
BOXAA * boxaaQuadtreeRegions(l_int32 w, l_int32 h, l_int32 nlevels)
boxaaQuadtreeRegions()
Definition: quadtree.c:453
pixQuadtreeVariance
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
quadtreeGetParent
l_ok quadtreeGetParent(FPIXA *fpixa, l_int32 level, l_int32 x, l_int32 y, l_float32 *pval)
quadtreeGetParent()
Definition: quadtree.c:534
quadtreeGetChildren
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
pixVarianceInRectangle
l_ok pixVarianceInRectangle(PIX *pixs, BOX *box, PIX *pix_ma, DPIX *dpix_msa, l_float32 *pvar, l_float32 *prvar)
pixVarianceInRectangle()
Definition: quadtree.c:345
pixQuadtreeMean
l_ok pixQuadtreeMean(PIX *pixs, l_int32 nlevels, PIX *pix_ma, FPIXA **pfpixa)
pixQuadtreeMean()
Definition: quadtree.c:96
pixExpandReplicate
PIX * pixExpandReplicate(PIX *pixs, l_int32 factor)
pixExpandReplicate()
Definition: scale2.c:872
Box
Definition: pix.h:481
Boxa
Definition: pix.h:492
Boxaa
Definition: pix.h:502
DPix
Definition: pix.h:610
FPix
Definition: pix.h:579
FPixa
Definition: pix.h:594
L_Bmf
Definition: bmf.h:47
Pix
Definition: pix.h:139
Pixa
Definition: pix.h:456
pixAddSingleTextblock
PIX * pixAddSingleTextblock(PIX *pixs, L_BMF *bmf, const char *textstr, l_uint32 val, l_int32 location, l_int32 *poverflow)
pixAddSingleTextblock()
Definition: textops.c:120
lept_stderr
void lept_stderr(const char *fmt,...)
lept_stderr()
Definition: utils1.c:306