diff options
Diffstat (limited to 'leptonica/prog/ptra2_reg.c')
| -rw-r--r-- | leptonica/prog/ptra2_reg.c | 266 |
1 files changed, 266 insertions, 0 deletions
diff --git a/leptonica/prog/ptra2_reg.c b/leptonica/prog/ptra2_reg.c new file mode 100644 index 00000000..e823265f --- /dev/null +++ b/leptonica/prog/ptra2_reg.c @@ -0,0 +1,266 @@ +/*====================================================================* + - Copyright (C) 2001 Leptonica. All rights reserved. + - + - Redistribution and use in source and binary forms, with or without + - modification, are permitted provided that the following conditions + - are met: + - 1. Redistributions of source code must retain the above copyright + - notice, this list of conditions and the following disclaimer. + - 2. Redistributions in binary form must reproduce the above + - copyright notice, this list of conditions and the following + - disclaimer in the documentation and/or other materials + - provided with the distribution. + - + - THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + - ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + - LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + - A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL ANY + - CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, + - EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, + - PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR + - PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY + - OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING + - NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + - SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + *====================================================================*/ + +/* + * ptra2_reg.c + * + * Testing: + * - basic ptra and ptraa operations + * - bin sort using ptra + * - boxaEqual() and pixaEqual() + */ + +#ifdef HAVE_CONFIG_H +#include <config_auto.h> +#endif /* HAVE_CONFIG_H */ + +#include "allheaders.h" + +void BoxaSortTest(L_REGPARAMS *rp, const char *fname, l_int32 index, + const char *text); +void PixaSortTest(L_REGPARAMS *rp, const char *fname, l_int32 index, + const char *text); + +int main(int argc, + char **argv) +{ +L_REGPARAMS *rp; + +#if !defined(HAVE_LIBPNG) + L_ERROR("This test requires libpng to run.\n", "ptra2_reg"); + exit(77); +#endif + + if (regTestSetup(argc, argv, &rp)) + return 1; + + lept_mkdir("lept/ptra"); + + /* 0 - 8 */ + BoxaSortTest(rp, "feyn-fract.tif", 1, "Boxa sort test on small image"); + /* 9 - 17 */ + BoxaSortTest(rp, "feyn.tif", 2, "Boxa sort test on large image"); + /* 18 - 27 */ + PixaSortTest(rp, "feyn-fract.tif", 3, "Pixa sort test on small image"); + /* 28 - 37 */ + PixaSortTest(rp, "feyn.tif", 4, "Pixa sort test on large image"); + return regTestCleanup(rp); +} + + +void +BoxaSortTest(L_REGPARAMS *rp, + const char *fname, + l_int32 index, + const char *text) +{ +l_int32 i, n, m, imax, w, h, x, count, same; +BOX *box; +BOXA *boxa, *boxa1, *boxa2, *boxa3; +NUMA *na, *nad1, *nad2, *nad3, *naindex; +PIX *pixs; +L_PTRA *pa, *pad, *paindex; +L_PTRAA *paa; +char buf[256]; + + lept_stderr("Test %d: %s\n", index, text); + pixs = pixRead(fname); + boxa = pixConnComp(pixs, NULL, 8); + + /* Sort by x */ + boxa1 = boxaSort(boxa, L_SORT_BY_X, L_SORT_INCREASING, &nad1); + snprintf(buf, sizeof(buf), "/tmp/lept/ptra/boxa1.%d.ba", index); + boxaWrite(buf, boxa1); + regTestCheckFile(rp, buf); /* 0 */ + snprintf(buf, sizeof(buf), "/tmp/lept/ptra/nad1.%d.na", index); + numaWrite(buf, nad1); + regTestCheckFile(rp, buf); /* 1 */ + + boxa2 = boxaBinSort(boxa, L_SORT_BY_X, L_SORT_INCREASING, &nad2); + snprintf(buf, sizeof(buf), "/tmp/lept/ptra/boxa2.%d.ba", index); + boxaWrite(buf, boxa2); + regTestCheckFile(rp, buf); /* 2 */ + snprintf(buf, sizeof(buf), "/tmp/lept/ptra/nad2.%d.na", index); + numaWrite(buf, nad2); + regTestCheckFile(rp, buf); /* 3 */ + + boxaEqual(boxa1, boxa2, 0, NULL, &same); + regTestCompareValues(rp, 1, same, 0.0); /* 4 */ + if (rp->display && same) + lept_stderr("boxa1 and boxa2 are identical\n"); + boxaEqual(boxa1, boxa2, 2, &naindex, &same); + regTestCompareValues(rp, 1, same, 0.0); /* 5 */ + if (rp->display && same) + lept_stderr("boxa1 and boxa2 are same at maxdiff = 2\n"); + snprintf(buf, sizeof(buf), "/tmp/lept/ptra/naindex.%d.na", index); + numaWrite(buf, naindex); + regTestCheckFile(rp, buf); /* 6 */ + numaDestroy(&naindex); + boxaDestroy(&boxa1); + numaDestroy(&nad1); + numaDestroy(&nad2); + + /* Now do this stuff with ptra and ptraa */ + /* First, store the boxes in a ptraa, where each ptra contains + * the boxes, and store the sort index in a ptra of numa */ + pixGetDimensions(pixs, &w, &h, NULL); + paa = ptraaCreate(w); + paindex = ptraCreate(w); + n = boxaGetCount(boxa); + if (rp->display) lept_stderr("n = %d\n", n); + for (i = 0; i < n; i++) { + box = boxaGetBox(boxa, i, L_CLONE); + boxGetGeometry(box, &x, NULL, NULL, NULL); + pa = ptraaGetPtra(paa, x, L_HANDLE_ONLY); + na = (NUMA *)ptraGetPtrToItem(paindex, x); + if (!pa) { /* na also needs to be made */ + pa = ptraCreate(1); + ptraaInsertPtra(paa, x, pa); + na = numaCreate(1); + ptraInsert(paindex, x, na, L_MIN_DOWNSHIFT); + } + ptraAdd(pa, box); + numaAddNumber(na, i); + } + ptraGetActualCount(paindex, &count); + if (rp->display) lept_stderr("count = %d\n", count); + + /* Flatten the ptraa to a ptra containing all the boxes + * in sorted order, and put them in a boxa */ + pad = ptraaFlattenToPtra(paa); + ptraaDestroy(&paa, FALSE, FALSE); + ptraGetActualCount(pad, &m); + if (m != n) + lept_stderr("n(orig) = %d, m(new) = %d\n", n, m); + boxa3 = boxaCreate(m); + for (i = 0; i < m; i++) { + box = (BOX *)ptraRemove(pad, i, L_NO_COMPACTION); + boxaAddBox(boxa3, box, L_INSERT); + } + ptraDestroy(&pad, FALSE, FALSE); + + /* Extract the data from the ptra of Numa, putting it into + * a single Numa */ + ptraGetMaxIndex(paindex, &imax); + nad3 = numaCreate(0); + if (rp->display) lept_stderr("imax = %d\n\n", imax); + for (i = 0; i <= imax; i++) { + na = (NUMA *)ptraRemove(paindex, i, L_NO_COMPACTION); + numaJoin(nad3, na, 0, -1); + numaDestroy(&na); + } + + snprintf(buf, sizeof(buf), "/tmp/lept/ptra/boxa3.%d.ba", index); + boxaWrite(buf, boxa3); + regTestCheckFile(rp, buf); /* 7 */ + snprintf(buf, sizeof(buf), "/tmp/lept/ptra/nad3.%d.na", index); + numaWrite(buf, nad3); + regTestCheckFile(rp, buf); /* 8 */ + + boxaDestroy(&boxa2); + boxaDestroy(&boxa3); + numaDestroy(&nad3); + ptraDestroy(&paindex, FALSE, FALSE); + pixDestroy(&pixs); + boxaDestroy(&boxa); + return; +} + + +void +PixaSortTest(L_REGPARAMS *rp, + const char *fname, + l_int32 index, + const char *text) +{ +l_int32 same; +BOXA *boxa, *boxa1, *boxa2; +NUMA *nap1, *nap2, *naindex; +PIX *pixs; +PIXA *pixa, *pixa1, *pixa2; +char buf[256]; + + lept_stderr("Test %d: %s\n", index, text); + pixs = pixRead(fname); + boxa = pixConnComp(pixs, &pixa, 8); + + pixa1 = pixaSort(pixa, L_SORT_BY_X, L_SORT_INCREASING, &nap1, L_CLONE); + boxa1 = pixaGetBoxa(pixa1, L_CLONE); + snprintf(buf, sizeof(buf), "/tmp/lept/ptra/bap1.%d.ba", index); + boxaWrite(buf, boxa1); + regTestCheckFile(rp, buf); /* 0 */ + snprintf(buf, sizeof(buf), "/tmp/lept/ptra/nap1.%d.na", index); + numaWrite(buf, nap1); + regTestCheckFile(rp, buf); /* 1 */ + snprintf(buf, sizeof(buf), "/tmp/lept/ptra/pixa1.%d.pa", index); + pixaWrite(buf, pixa1); + regTestCheckFile(rp, buf); /* 2 */ + + pixa2 = pixaBinSort(pixa, L_SORT_BY_X, L_SORT_INCREASING, &nap2, L_CLONE); + boxa2 = pixaGetBoxa(pixa2, L_CLONE); + snprintf(buf, sizeof(buf), "/tmp/lept/ptra/bap2.%d.ba", index); + boxaWrite(buf, boxa2); + regTestCheckFile(rp, buf); /* 3 */ + snprintf(buf, sizeof(buf), "/tmp/lept/ptra/nap2.%d.na", index); + numaWrite(buf, nap2); + regTestCheckFile(rp, buf); /* 4 */ + snprintf(buf, sizeof(buf), "/tmp/lept/ptra/pixa2.%d.pa", index); + pixaWrite(buf, pixa2); + regTestCheckFile(rp, buf); /* 5 */ + + boxaEqual(boxa1, boxa2, 0, &naindex, &same); + regTestCompareValues(rp, 1, same, 0.0); /* 6 */ + if (rp->display && same) + lept_stderr("boxa1 and boxa2 are identical\n"); + numaDestroy(&naindex); + boxaEqual(boxa1, boxa2, 3, &naindex, &same); + regTestCompareValues(rp, 1, same, 0.0); /* 7 */ + if (rp->display && same) + lept_stderr("boxa1 and boxa2 are same at maxdiff = 2\n"); + numaDestroy(&naindex); + + pixaEqual(pixa1, pixa2, 0, &naindex, &same); + regTestCompareValues(rp, 1, same, 0.0); /* 8 */ + if (rp->display && same) + lept_stderr("pixa1 and pixa2 are identical\n"); + numaDestroy(&naindex); + pixaEqual(pixa1, pixa2, 3, &naindex, &same); + regTestCompareValues(rp, 1, same, 0.0); /* 9 */ + if (rp->display && same) + lept_stderr("pixa1 and pixa2 are same at maxdiff = 2\n\n"); + numaDestroy(&naindex); + + boxaDestroy(&boxa); + boxaDestroy(&boxa1); + boxaDestroy(&boxa2); + numaDestroy(&nap1); + numaDestroy(&nap2); + pixaDestroy(&pixa); + pixaDestroy(&pixa1); + pixaDestroy(&pixa2); + pixDestroy(&pixs); + return; +} |