/*====================================================================*
 -  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;
}