/*!
* boxaaWriteStream()
*
* Input: stream
* boxaa
* Return: 0 if OK, 1 on error
*/
l_int32
boxaaWriteStream(FILE *fp,
BOXAA *baa)
{
l_int32 n, i, x, y, w, h;
BOX *box;
BOXA *boxa;
PROCNAME("boxaaWriteStream");
if (!fp)
return ERROR_INT("stream not defined", procName, 1);
if (!baa)
return ERROR_INT("baa not defined", procName, 1);
n = boxaaGetCount(baa);
fprintf(fp, "\nBoxaa Version %d\n", BOXAA_VERSION_NUMBER);
fprintf(fp, "Number of boxa = %d\n", n);
for (i = 0; i < n; i++) {
if ((boxa = boxaaGetBoxa(baa, i, L_CLONE)) == NULL)
return ERROR_INT("boxa not found", procName, 1);
boxaGetExtent(boxa, NULL, NULL, &box);
boxGetGeometry(box, &x, &y, &w, &h);
fprintf(fp, "\nBoxa[%d] extent: x = %d, y = %d, w = %d, h = %d",
i, x, y, w, h);
boxaWriteStream(fp, boxa);
boxDestroy(&box);
boxaDestroy(&boxa);
}
return 0;
}
/*!
* boxaaAddBoxa()
*
* Input: boxaa
* boxa (to be added)
* copyflag (L_INSERT, L_COPY, L_CLONE)
* Return: 0 if OK, 1 on error
*/
l_int32
boxaaAddBoxa(BOXAA *baa,
BOXA *ba,
l_int32 copyflag)
{
l_int32 n;
BOXA *bac;
PROCNAME("boxaaAddBoxa");
if (!baa)
return ERROR_INT("baa not defined", procName, 1);
if (!ba)
return ERROR_INT("ba not defined", procName, 1);
if (copyflag != L_INSERT && copyflag != L_COPY && copyflag != L_CLONE)
return ERROR_INT("invalid copyflag", procName, 1);
if (copyflag == L_INSERT)
bac = ba;
else
bac = boxaCopy(ba, copyflag);
n = boxaaGetCount(baa);
if (n >= baa->nalloc)
boxaaExtendArray(baa);
baa->boxa[n] = bac;
baa->n++;
return 0;
}
/*!
* boxaaInsertBoxa()
*
* Input: boxaa
* index (location in boxaa to insert new boxa)
* boxa (new boxa to be inserted)
* Return: 0 if OK, 1 on error
*
* Notes:
* (1) This shifts boxa[i] --> boxa[i + 1] for all i >= index,
* and then inserts boxa as boxa[index].
* (2) To insert at the beginning of the array, set index = 0.
* (3) To append to the array, it's easier to use boxaaAddBoxa().
* (4) This should not be used repeatedly to insert into large arrays,
* because the function is O(n).
*/
l_int32
boxaaInsertBoxa(BOXAA *baa,
l_int32 index,
BOXA *boxa)
{
l_int32 i, n;
BOXA **array;
PROCNAME("boxaaInsertBoxa");
if (!baa)
return ERROR_INT("baa not defined", procName, 1);
n = boxaaGetCount(baa);
if (index < 0 || index > n)
return ERROR_INT("index not in {0...n}", procName, 1);
if (!boxa)
return ERROR_INT("boxa not defined", procName, 1);
if (n >= baa->nalloc)
boxaaExtendArray(baa);
array = baa->boxa;
baa->n++;
for (i = n; i > index; i--)
array[i] = array[i - 1];
array[index] = boxa;
return 0;
}
/*!
* boxaaGetExtent()
*
* Input: boxaa
* &w (<optional return> width)
* &h (<optional return> height)
* &box (<optional return>, minimum box containing all boxa
* in boxaa)
* Return: 0 if OK, 1 on error
*
* Notes:
* (1) The returned w and h are the minimum size image
* that would contain all boxes untranslated.
*/
l_int32
boxaaGetExtent(BOXAA *boxaa,
l_int32 *pw,
l_int32 *ph,
BOX **pbox)
{
l_int32 i, j, n, m, x, y, w, h, xmax, ymax, xmin, ymin, found;
BOXA *boxa;
PROCNAME("boxaaGetExtent");
if (!pw && !ph && !pbox)
return ERROR_INT("no ptrs defined", procName, 1);
if (pbox) *pbox = NULL;
if (pw) *pw = 0;
if (ph) *ph = 0;
if (!boxaa)
return ERROR_INT("boxaa not defined", procName, 1);
n = boxaaGetCount(boxaa);
if (n == 0)
return ERROR_INT("no boxa in boxaa", procName, 1);
xmax = ymax = 0;
xmin = ymin = 100000000;
found = FALSE;
for (i = 0; i < n; i++) {
boxa = boxaaGetBoxa(boxaa, i, L_CLONE);
m = boxaGetCount(boxa);
for (j = 0; j < m; j++) {
boxaGetBoxGeometry(boxa, j, &x, &y, &w, &h);
if (w <= 0 || h <= 0)
continue;
found = TRUE;
xmin = L_MIN(xmin, x);
ymin = L_MIN(ymin, y);
xmax = L_MAX(xmax, x + w);
ymax = L_MAX(ymax, y + h);
}
}
if (!found)
return ERROR_INT("no valid boxes in boxaa", procName, 1);
if (pw) *pw = xmax;
if (ph) *ph = ymax;
if (pbox)
*pbox = boxCreate(xmin, ymin, xmax - xmin, ymax - ymin);
return 0;
}
/*!
* boxaaAlignBox()
*
* Input: boxaa
* box (to be aligned with the last of one of the boxa
* in boxaa, if possible)
* delta (amount by which consecutive components can miss
* in overlap and still be included in the array)
* &index (of boxa with best overlap, or if none match,
* this is the index of the next boxa to be generated)
* Return: 0 if OK, 1 on error
*
* Notes:
* (1) This is not greedy; it finds the boxa whose last box has
* the biggest overlap with the input box.
*/
l_int32
boxaaAlignBox(BOXAA *baa,
BOX *box,
l_int32 delta,
l_int32 *pindex)
{
l_int32 i, n, m, y, yt, h, ht, ovlp, maxovlp, maxindex;
BOXA *boxa;
PROCNAME("boxaaAlignBox");
if (!baa)
return ERROR_INT("baa not defined", procName, 1);
if (!box)
return ERROR_INT("box not defined", procName, 1);
if (!pindex)
return ERROR_INT("&index not defined", procName, 1);
n = boxaaGetCount(baa);
boxGetGeometry(box, NULL, &y, NULL, &h);
maxovlp = -10000000;
for (i = 0; i < n; i++) {
boxa = boxaaGetBoxa(baa, i, L_CLONE);
if ((m = boxaGetCount(boxa)) == 0) {
L_WARNING("no boxes in boxa", procName);
continue;
}
boxaGetBoxGeometry(boxa, m - 1, NULL, &yt, NULL, &ht); /* last one */
boxaDestroy(&boxa);
/* Overlap < 0 means the components do not overlap vertically */
if (yt >= y)
ovlp = y + h - 1 - yt;
else
ovlp = yt + ht - 1 - y;
if (ovlp > maxovlp) {
maxovlp = ovlp;
maxindex = i;
}
}
if (maxovlp + delta >= 0)
*pindex = maxindex;
else
*pindex = n;
return 0;
}
/*!
* boxaaFlattenToBoxa()
*
* Input: boxaa
* &naindex (<optional return> the boxa index in the boxaa)
* copyflag (L_COPY or L_CLONE)
* Return: boxa, or null on error
*
* Notes:
* (1) This 'flattens' the boxaa to a boxa, taking the boxes in
* order in the first boxa, then the second, etc.
* (2) If a boxa is empty, we generate an invalid, placeholder box
* of zero size. This is useful when converting from a boxaa
* where each boxa has either 0 or 1 boxes, and it is necessary
* to maintain a 1:1 correspondence between the initial
* boxa array and the resulting box array.
* (3) If &naindex is defined, we generate a Numa that gives, for
* each box in the boxaa, the index of the boxa to which it belongs.
*/
BOXA *
boxaaFlattenToBoxa(BOXAA *baa,
NUMA **pnaindex,
l_int32 copyflag)
{
l_int32 i, j, m, n;
BOXA *boxa, *boxat;
BOX *box;
NUMA *naindex;
PROCNAME("boxaaFlattenToBoxa");
if (pnaindex) *pnaindex = NULL;
if (!baa)
return (BOXA *)ERROR_PTR("baa not defined", procName, NULL);
if (copyflag != L_COPY && copyflag != L_CLONE)
return (BOXA *)ERROR_PTR("invalid copyflag", procName, NULL);
if (pnaindex) {
naindex = numaCreate(0);
*pnaindex = naindex;
}
n = boxaaGetCount(baa);
boxa = boxaCreate(n);
for (i = 0; i < n; i++) {
boxat = boxaaGetBoxa(baa, i, L_CLONE);
m = boxaGetCount(boxat);
if (m == 0) { /* placeholder box */
box = boxCreate(0, 0, 0, 0);
boxaAddBox(boxa, box, L_INSERT);
if (pnaindex)
numaAddNumber(naindex, i); /* save 'row' number */
}
else {
for (j = 0; j < m; j++) {
box = boxaGetBox(boxat, j, copyflag);
boxaAddBox(boxa, box, L_INSERT);
if (pnaindex)
numaAddNumber(naindex, i); /* save 'row' number */
}
}
boxaDestroy(&boxat);
}
return boxa;
}
/*!
* \brief boxaaSizeRange()
*
* \param[in] baa
* \param[out] pminw [optional] min width of all boxes
* \param[out] pmaxw [optional] max width of all boxes
* \param[out] pminh [optional] min height of all boxes
* \param[out] pmaxh [optional] max height of all boxes
* \return 0 if OK, 1 on error
*/
l_ok
boxaaSizeRange(BOXAA *baa,
l_int32 *pminw,
l_int32 *pminh,
l_int32 *pmaxw,
l_int32 *pmaxh)
{
l_int32 minw, minh, maxw, maxh, minbw, minbh, maxbw, maxbh, i, n;
BOXA *boxa;
PROCNAME("boxaaSizeRange");
if (!pminw && !pmaxw && !pminh && !pmaxh)
return ERROR_INT("no data can be returned", procName, 1);
if (pminw) *pminw = 0;
if (pminh) *pminh = 0;
if (pmaxw) *pmaxw = 0;
if (pmaxh) *pmaxh = 0;
if (!baa)
return ERROR_INT("baa not defined", procName, 1);
minw = minh = 100000000;
maxw = maxh = 0;
n = boxaaGetCount(baa);
for (i = 0; i < n; i++) {
boxa = boxaaGetBoxa(baa, i, L_CLONE);
boxaSizeRange(boxa, &minbw, &minbh, &maxbw, &maxbh);
if (minbw < minw)
minw = minbw;
if (minbh < minh)
minh = minbh;
if (maxbw > maxw)
maxw = maxbw;
if (maxbh > maxh)
maxh = maxbh;
boxaDestroy(&boxa);
}
if (pminw) *pminw = minw;
if (pminh) *pminh = minh;
if (pmaxw) *pmaxw = maxw;
if (pmaxh) *pmaxh = maxh;
return 0;
}
/*!
* boxaaGetBoxa()
*
* Input: boxaa
* index (to the index-th boxa)
* accessflag (L_COPY or L_CLONE)
* Return: boxa, or null on error
*/
BOXA *
boxaaGetBoxa(BOXAA *baa,
l_int32 index,
l_int32 accessflag)
{
l_int32 n;
PROCNAME("boxaaGetBoxa");
if (!baa)
return (BOXA *)ERROR_PTR("baa not defined", procName, NULL);
n = boxaaGetCount(baa);
if (index < 0 || index >= n)
return (BOXA *)ERROR_PTR("index not valid", procName, NULL);
if (accessflag != L_COPY && accessflag != L_CLONE)
return (BOXA *)ERROR_PTR("invalid accessflag", procName, NULL);
return boxaCopy(baa->boxa[index], accessflag);
}
/*!
* boxaaGetBoxCount()
*
* Input: boxaa
* Return: count (number of boxes), or 0 if no boxes or on error
*/
l_int32
boxaaGetBoxCount(BOXAA *baa)
{
BOXA *boxa;
l_int32 n, sum, i;
PROCNAME("boxaaGetBoxCount");
if (!baa)
return ERROR_INT("baa not defined", procName, 0);
n = boxaaGetCount(baa);
for (sum = 0, i = 0; i < n; i++) {
boxa = boxaaGetBoxa(baa, i, L_CLONE);
sum += boxaGetCount(boxa);
boxaDestroy(&boxa);
}
return sum;
}
/*!
* boxaaReplaceBoxa()
*
* Input: boxaa
* index (to the index-th boxa)
* boxa (insert and replace any existing one)
* Return: 0 if OK, 1 on error
*
* Notes:
* (1) Any existing boxa is destroyed, and the input one
* is inserted in its place.
* (2) If the index is invalid, return 1 (error)
*/
l_int32
boxaaReplaceBoxa(BOXAA *baa,
l_int32 index,
BOXA *boxa)
{
l_int32 n;
PROCNAME("boxaaReplaceBoxa");
if (!baa)
return ERROR_INT("baa not defined", procName, 1);
if (!boxa)
return ERROR_INT("boxa not defined", procName, 1);
n = boxaaGetCount(baa);
if (index < 0 || index >= n)
return ERROR_INT("index not valid", procName, 1);
boxaDestroy(&baa->boxa[index]);
baa->boxa[index] = boxa;
return 0;
}
/*!
* \brief boxaaSelectRange()
*
* \param[in] baas
* \param[in] first use 0 to select from the beginning
* \param[in] last use -1 to select to the end
* \param[in] copyflag L_COPY, L_CLONE
* \return baad, or NULL on error
*
* <pre>
* Notes:
* (1) The copyflag specifies what we do with each boxa from baas.
* Specifically, L_CLONE inserts a clone into baad of each
* selected boxa from baas.
* </pre>
*/
BOXAA *
boxaaSelectRange(BOXAA *baas,
l_int32 first,
l_int32 last,
l_int32 copyflag)
{
l_int32 n, nboxa, i;
BOXA *boxa;
BOXAA *baad;
PROCNAME("boxaaSelectRange");
if (!baas)
return (BOXAA *)ERROR_PTR("baas not defined", procName, NULL);
if (copyflag != L_COPY && copyflag != L_CLONE)
return (BOXAA *)ERROR_PTR("invalid copyflag", procName, NULL);
if ((n = boxaaGetCount(baas)) == 0)
return (BOXAA *)ERROR_PTR("empty baas", procName, NULL);
first = L_MAX(0, first);
if (last < 0) last = n - 1;
if (first >= n)
return (BOXAA *)ERROR_PTR("invalid first", procName, NULL);
if (last >= n) {
L_WARNING("last = %d is beyond max index = %d; adjusting\n",
procName, last, n - 1);
last = n - 1;
}
if (first > last)
return (BOXAA *)ERROR_PTR("first > last", procName, NULL);
nboxa = last - first + 1;
baad = boxaaCreate(nboxa);
for (i = first; i <= last; i++) {
boxa = boxaaGetBoxa(baas, i, copyflag);
boxaaAddBoxa(baad, boxa, L_INSERT);
}
return baad;
}
/*!
* boxaaAddBox()
*
* Input: boxaa
* index (of boxa with boxaa)
* box (to be added)
* accessflag (L_INSERT, L_COPY or L_CLONE)
* Return: 0 if OK, 1 on error
*
* Notes:
* (1) Adds to an existing boxa only.
*/
l_int32
boxaaAddBox(BOXAA *baa,
l_int32 index,
BOX *box,
l_int32 accessflag)
{
l_int32 n;
BOXA *boxa;
PROCNAME("boxaaAddBox");
if (!baa)
return ERROR_INT("baa not defined", procName, 1);
n = boxaaGetCount(baa);
if (index < 0 || index >= n)
return ERROR_INT("index not valid", procName, 1);
if (accessflag != L_INSERT && accessflag != L_COPY && accessflag != L_CLONE)
return ERROR_INT("invalid accessflag", procName, 1);
boxa = boxaaGetBoxa(baa, index, L_CLONE);
boxaAddBox(boxa, box, accessflag);
boxaDestroy(&boxa);
return 0;
}
/*!
* boxaaFlattenAligned()
*
* Input: boxaa
* num (number extracted from each)
* copyflag (L_COPY or L_CLONE)
* Return: boxa, or null on error
*
* Notes:
* (1) This 'flattens' the boxaa to a boxa, taking the first @num
* boxes from each boxa.
* (2) If less than @num boxes are in a boxa, we add invalid placeholder
* boxes to preserve the alignment between the input boxaa
* and the output boxa.
*/
BOXA *
boxaaFlattenAligned(BOXAA *baa,
l_int32 num,
l_int32 copyflag)
{
l_int32 i, j, m, n, mval, nshort;
BOXA *boxat, *boxad;
BOX *box;
PROCNAME("boxaaFlattenAligned");
if (!baa)
return (BOXA *)ERROR_PTR("baa not defined", procName, NULL);
if (copyflag != L_COPY && copyflag != L_CLONE)
return (BOXA *)ERROR_PTR("invalid copyflag", procName, NULL);
n = boxaaGetCount(baa);
boxad = boxaCreate(n);
for (i = 0; i < n; i++) {
boxat = boxaaGetBoxa(baa, i, L_CLONE);
m = boxaGetCount(boxat);
mval = L_MIN(m, num);
nshort = num - mval;
for (j = 0; j < mval; j++) { /* take the first @num if possible */
box = boxaGetBox(boxat, j, copyflag);
boxaAddBox(boxad, box, L_INSERT);
}
for (j = 0; j < nshort; j++) { /* add placeholders if necessary */
box = boxCreate(0, 0, 0, 0);
boxaAddBox(boxad, box, L_INSERT);
}
boxaDestroy(&boxat);
}
return boxad;
}
/*!
* boxaaExtendWithInit()
*
* Input: boxaa
* maxindex
* boxa (to be replicated into the extended ptr array)
* Return: 0 if OK, 1 on error
*
* Notes:
* (1) This should be used on an existing boxaa that has been
* fully loaded with boxa. It then extends the boxaa,
* loading all the additional ptrs with copies of boxa.
* Typically, boxa will be empty.
*/
l_int32
boxaaExtendWithInit(BOXAA *baa,
l_int32 maxindex,
BOXA *boxa)
{
l_int32 i, n;
PROCNAME("boxaaExtendWithInit");
if (!baa)
return ERROR_INT("baa not defined", procName, 1);
if (!boxa)
return ERROR_INT("boxa not defined", procName, 1);
/* Extend the ptr array if necessary */
n = boxaaGetCount(baa);
if (maxindex < n) return 0;
boxaaExtendArrayToSize(baa, maxindex + 1);
/* Fill the new entries with copies of boxa */
for (i = n; i <= maxindex; i++)
boxaaAddBoxa(baa, boxa, L_COPY);
return 0;
}
/*!
* boxaaCopy()
*
* Input: baas (input boxaa to be copied)
* copyflag (L_COPY, L_CLONE)
* Return: baad (new boxaa, composed of copies or clones of the boxa
* in baas), or null on error
*
* Notes:
* (1) L_COPY makes a copy of each boxa in baas.
* L_CLONE makes a clone of each boxa in baas.
*/
BOXAA *
boxaaCopy(BOXAA *baas,
l_int32 copyflag)
{
l_int32 i, n;
BOXA *boxa;
BOXAA *baad;
PROCNAME("boxaaCopy");
if (!baas)
return (BOXAA *)ERROR_PTR("baas not defined", procName, NULL);
if (copyflag != L_COPY && copyflag != L_CLONE)
return (BOXAA *)ERROR_PTR("invalid copyflag", procName, NULL);
n = boxaaGetCount(baas);
baad = boxaaCreate(n);
for (i = 0; i < n; i++) {
boxa = boxaaGetBoxa(baas, i, copyflag);
boxaaAddBoxa(baad, boxa, L_INSERT);
}
return baad;
}
/*!
* boxaaRemoveBoxa()
*
* Input: boxaa
* index (of the boxa to be removed)
* Return: 0 if OK, 1 on error
*
* Notes:
* (1) This removes boxa[index] and then shifts
* boxa[i] --> boxa[i - 1] for all i > index.
* (2) The removed boxaa is destroyed.
* (2) This should not be used repeatedly on large arrays,
* because the function is O(n).
*/
l_int32
boxaaRemoveBoxa(BOXAA *baa,
l_int32 index)
{
l_int32 i, n;
BOXA **array;
PROCNAME("boxaaRemoveBox");
if (!baa)
return ERROR_INT("baa not defined", procName, 1);
n = boxaaGetCount(baa);
if (index < 0 || index >= n)
return ERROR_INT("index not valid", procName, 1);
array = baa->boxa;
boxaDestroy(&array[index]);
for (i = index + 1; i < n; i++)
array[i - 1] = array[i];
array[n - 1] = NULL;
baa->n--;
return 0;
}
/*!
* boxaSort2d()
*
* Input: boxas
* &naa (<optional return> numaa with sorted indices
* whose values are the indices of the input array)
* delta1 (min overlap that permits aggregation of a box
* onto a boxa of horizontally-aligned boxes; pass 1)
* delta2 (min overlap that permits aggregation of a box
* onto a boxa of horizontally-aligned boxes; pass 2)
* minh1 (components less than this height either join an
* existing boxa or are set aside for pass 2)
* Return: boxaa (2d sorted version of boxa), or null on error
*
* Notes:
* (1) The final result is a sort where the 'fast scan' direction is
* left to right, and the 'slow scan' direction is from top
* to bottom. Each boxa in the boxaa represents a sorted set
* of boxes from left to right.
* (2) Two passes are used to aggregate the boxas, which can corresond
* to characters or words in a line of text. In pass 1, only
* taller components, which correspond to xheight or larger,
* are permitted to start a new boxa, whereas in pass 2,
* the remaining vertically-challenged components are allowed
* to join an existing boxa or start a new one.
* (3) If delta1 < 0, the first pass allows aggregation when
* boxes in the same boxa do not overlap vertically.
* The distance by which they can miss and still be aggregated
* is the absolute value |delta1|. Similar for delta2 on
* the second pass.
* (4) On the first pass, any component of height less than minh1
* cannot start a new boxa; it's put aside for later insertion.
* (5) On the second pass, any small component that doesn't align
* with an existing boxa can start a new one.
* (6) This can be used to identify lines of text from
* character or word bounding boxes.
*/
BOXAA *
boxaSort2d(BOXA *boxas,
NUMAA **pnaad,
l_int32 delta1,
l_int32 delta2,
l_int32 minh1)
{
l_int32 i, index, h, nt, ne, n, m, ival;
BOX *box;
BOXA *boxa, *boxae, *boxan, *boxat1, *boxat2, *boxav, *boxavs;
BOXAA *baa, *baad;
NUMA *naindex, *nae, *nan, *nah, *nav, *nat1, *nat2, *nad;
NUMAA *naa, *naad;
PROCNAME("boxaSort2d");
if (pnaad) *pnaad = NULL;
if (!boxas)
return (BOXAA *)ERROR_PTR("boxas not defined", procName, NULL);
/* Sort from left to right */
if ((boxa = boxaSort(boxas, L_SORT_BY_X, L_SORT_INCREASING, &naindex))
== NULL)
return (BOXAA *)ERROR_PTR("boxa not made", procName, NULL);
/* First pass: assign taller boxes to boxa by row */
nt = boxaGetCount(boxa);
baa = boxaaCreate(0);
naa = numaaCreate(0);
boxae = boxaCreate(0); /* save small height boxes here */
nae = numaCreate(0); /* keep track of small height boxes */
for (i = 0; i < nt; i++) {
box = boxaGetBox(boxa, i, L_CLONE);
boxGetGeometry(box, NULL, NULL, NULL, &h);
if (h < minh1) { /* save for 2nd pass */
boxaAddBox(boxae, box, L_INSERT);
numaAddNumber(nae, i);
}
else {
n = boxaaGetCount(baa);
boxaaAlignBox(baa, box, delta1, &index);
if (index < n) { /* append to an existing boxa */
boxaaAddBox(baa, index, box, L_INSERT);
}
else { /* doesn't align, need new boxa */
boxan = boxaCreate(0);
boxaAddBox(boxan, box, L_INSERT);
boxaaAddBoxa(baa, boxan, L_INSERT);
nan = numaCreate(0);
numaaAddNuma(naa, nan, L_INSERT);
}
numaGetIValue(naindex, i, &ival);
numaaAddNumber(naa, index, ival);
}
}
boxaDestroy(&boxa);
numaDestroy(&naindex);
/* Second pass: feed in small height boxes;
* TODO: this correctly, using local y position! */
ne = boxaGetCount(boxae);
for (i = 0; i < ne; i++) {
box = boxaGetBox(boxae, i, L_CLONE);
n = boxaaGetCount(baa);
boxaaAlignBox(baa, box, delta2, &index);
if (index < n) { /* append to an existing boxa */
boxaaAddBox(baa, index, box, L_INSERT);
}
else { /* doesn't align, need new boxa */
boxan = boxaCreate(0);
boxaAddBox(boxan, box, L_INSERT);
boxaaAddBoxa(baa, boxan, L_INSERT);
nan = numaCreate(0);
numaaAddNuma(naa, nan, L_INSERT);
}
numaGetIValue(nae, i, &ival); /* location in original boxas */
numaaAddNumber(naa, index, ival);
}
/* Sort each boxa in the boxaa */
m = boxaaGetCount(baa);
for (i = 0; i < m; i++) {
boxat1 = boxaaGetBoxa(baa, i, L_CLONE);
boxat2 = boxaSort(boxat1, L_SORT_BY_X, L_SORT_INCREASING, &nah);
boxaaReplaceBoxa(baa, i, boxat2);
nat1 = numaaGetNuma(naa, i, L_CLONE);
nat2 = numaSortByIndex(nat1, nah);
numaaReplaceNuma(naa, i, nat2);
boxaDestroy(&boxat1);
numaDestroy(&nat1);
numaDestroy(&nah);
}
/* Sort boxa vertically within boxaa, using the first box
* in each boxa. */
m = boxaaGetCount(baa);
boxav = boxaCreate(m); /* holds first box in each boxa in baa */
naad = numaaCreate(m);
if (pnaad)
*pnaad = naad;
baad = boxaaCreate(m);
for (i = 0; i < m; i++) {
boxat1 = boxaaGetBoxa(baa, i, L_CLONE);
box = boxaGetBox(boxat1, 0, L_CLONE);
boxaAddBox(boxav, box, L_INSERT);
boxaDestroy(&boxat1);
}
boxavs = boxaSort(boxav, L_SORT_BY_Y, L_SORT_INCREASING, &nav);
for (i = 0; i < m; i++) {
numaGetIValue(nav, i, &index);
boxa = boxaaGetBoxa(baa, index, L_CLONE);
boxaaAddBoxa(baad, boxa, L_INSERT);
nad = numaaGetNuma(naa, index, L_CLONE);
numaaAddNuma(naad, nad, L_INSERT);
}
/* fprintf(stderr, "box count = %d, numaa count = %d\n", nt,
numaaGetNumberCount(naad)); */
boxaaDestroy(&baa);
boxaDestroy(&boxav);
boxaDestroy(&boxavs);
boxaDestroy(&boxae);
numaDestroy(&nav);
numaDestroy(&nae);
numaaDestroy(&naa);
if (!pnaad)
numaaDestroy(&naad);
return baad;
}
int main(int argc,
char **argv)
{
l_uint8 *data1, *data2;
l_int32 i, same, w, h, width, success, nba;
size_t size1, size2;
l_float32 diffarea, diffxor, scalefact;
BOX *box;
BOXA *boxa1, *boxa2, *boxa3;
BOXAA *baa1, *baa2, *baa3;
PIX *pix1, *pixdb;
PIXA *pixa1, *pixa2;
static char mainName[] = "boxa1_reg";
if (argc != 1)
return ERROR_INT(" Syntax: boxa1_reg", mainName, 1);
lept_mkdir("lept/boxa");
/* Make a boxa and display its contents */
boxa1 = boxaCreate(6);
box = boxCreate(60, 60, 40, 20);
boxaAddBox(boxa1, box, L_INSERT);
box = boxCreate(120, 50, 20, 50);
boxaAddBox(boxa1, box, L_INSERT);
box = boxCreate(50, 140, 46, 60);
boxaAddBox(boxa1, box, L_INSERT);
box = boxCreate(166, 130, 64, 28);
boxaAddBox(boxa1, box, L_INSERT);
box = boxCreate(64, 224, 44, 34);
boxaAddBox(boxa1, box, L_INSERT);
box = boxCreate(117, 206, 26, 74);
boxaAddBox(boxa1, box, L_INSERT);
pix1 = DisplayBoxa(boxa1);
pixDisplay(pix1, 100, 100);
pixDestroy(&pix1);
boxaCompareRegions(boxa1, boxa1, 100, &same, &diffarea, &diffxor, NULL);
fprintf(stderr, "same = %d, diffarea = %5.3f, diffxor = %5.3f\n",
same, diffarea, diffxor);
boxa2 = boxaTransform(boxa1, -13, -13, 1.0, 1.0);
boxaCompareRegions(boxa1, boxa2, 10, &same, &diffarea, &diffxor, NULL);
fprintf(stderr, "same = %d, diffarea = %5.3f, diffxor = %5.3f\n",
same, diffarea, diffxor);
boxaDestroy(&boxa2);
boxa2 = boxaReconcileEvenOddHeight(boxa1, L_ADJUST_TOP_AND_BOT, 6,
L_ADJUST_CHOOSE_MIN, 1.0, 0);
pix1 = DisplayBoxa(boxa2);
pixDisplay(pix1, 100, 500);
pixDestroy(&pix1);
boxaCompareRegions(boxa1, boxa2, 10, &same, &diffarea, &diffxor, &pixdb);
fprintf(stderr, "same = %d, diffarea = %5.3f, diffxor = %5.3f\n",
same, diffarea, diffxor);
pixDisplay(pixdb, 700, 100);
pixDestroy(&pixdb);
boxaDestroy(&boxa1);
boxaDestroy(&boxa2);
/* Input is a fairly clean boxa */
boxa1 = boxaRead("boxa1.ba");
boxa2 = boxaReconcileEvenOddHeight(boxa1, L_ADJUST_TOP, 80,
L_ADJUST_CHOOSE_MIN, 1.05, 1);
width = 100;
boxaGetExtent(boxa2, &w, &h, NULL);
scalefact = (l_float32)width / (l_float32)w;
boxa3 = boxaTransform(boxa2, 0, 0, scalefact, scalefact);
pix1 = boxaDisplayTiled(boxa3, NULL, 1500, 2, 1.0, 0, 3, 2);
pixDisplay(pix1, 0, 100);
pixWrite("/tmp/lept/boxa/pix1.png", pix1, IFF_PNG);
pixDestroy(&pix1);
boxaDestroy(&boxa1);
boxaDestroy(&boxa2);
boxaDestroy(&boxa3);
/* Input is an unsmoothed and noisy boxa */
boxa1 = boxaRead("boxa2.ba");
boxa2 = boxaReconcileEvenOddHeight(boxa1, L_ADJUST_TOP, 80,
L_ADJUST_CHOOSE_MIN, 1.05, 1);
width = 100;
boxaGetExtent(boxa2, &w, &h, NULL);
scalefact = (l_float32)width / (l_float32)w;
boxa3 = boxaTransform(boxa2, 0, 0, scalefact, scalefact);
pix1 = boxaDisplayTiled(boxa3, NULL, 1500, 2, 1.0, 0, 3, 2);
pixDisplay(pix1, 500, 100);
pixWrite("/tmp/lept/boxa/pix2.png", pix1, IFF_PNG);
pixDestroy(&pix1);
boxaDestroy(&boxa1);
boxaDestroy(&boxa2);
boxaDestroy(&boxa3);
/* Input is a boxa smoothed with a median window filter */
boxa1 = boxaRead("boxa3.ba");
boxa2 = boxaReconcileEvenOddHeight(boxa1, L_ADJUST_TOP, 80,
L_ADJUST_CHOOSE_MIN, 1.05, 1);
width = 100;
boxaGetExtent(boxa2, &w, &h, NULL);
scalefact = (l_float32)width / (l_float32)w;
boxa3 = boxaTransform(boxa2, 0, 0, scalefact, scalefact);
pix1 = boxaDisplayTiled(boxa3, NULL, 1500, 2, 1.0, 0, 3, 2);
pixDisplay(pix1, 1000, 100);
pixWrite("/tmp/lept/boxa/pix3.png", pix1, IFF_PNG);
pixDestroy(&pix1);
boxaDestroy(&boxa1);
boxaDestroy(&boxa2);
boxaDestroy(&boxa3);
/* Test serialized boxa I/O to and from memory */
data1 = l_binaryRead("boxa2.ba", &size1);
boxa1 = boxaReadMem(data1, size1);
boxaWriteMem(&data2, &size2, boxa1);
boxa2 = boxaReadMem(data2, size2);
boxaWrite("/tmp/lept/boxa/boxa1.ba", boxa1);
boxaWrite("/tmp/lept/boxa/boxa2.ba", boxa2);
filesAreIdentical("/tmp/lept/boxa/boxa1.ba", "/tmp/lept/boxa/boxa2.ba",
&same);
if (same)
fprintf(stderr, "Good: boxes files are identical\n");
else
fprintf(stderr, "Bad: boxes files differ\n");
boxaDestroy(&boxa1);
boxaDestroy(&boxa2);
lept_free(data1);
lept_free(data2);
/* Test pixaDisplayBoxaa() */
pixa1 = pixaReadBoth("showboxes.pac");
baa1 = boxaaRead("showboxes1.baa");
baa2 = boxaaTranspose(baa1);
baa3 = boxaaTranspose(baa2);
nba = boxaaGetCount(baa1);
success = TRUE;
for (i = 0; i < nba; i++) {
boxa1 = boxaaGetBoxa(baa1, i, L_CLONE);
boxa2 = boxaaGetBoxa(baa3, i, L_CLONE);
boxaEqual(boxa1, boxa2, 0, NULL, &same);
boxaDestroy(&boxa1);
boxaDestroy(&boxa2);
if (!same) success = FALSE;
}
if (success)
fprintf(stderr, "Good: transpose is reversible\n");
else
fprintf(stderr, "Bad: transpose failed\n");
pixa2 = pixaDisplayBoxaa(pixa1, baa2, L_DRAW_RGB, 2);
pix1 = pixaDisplayTiledInRows(pixa2, 32, 1400, 1.0, 0, 10, 0);
pixDisplay(pix1, 0, 600);
fprintf(stderr, "Writing to: /tmp/lept/boxa/show.pdf\n");
pixaConvertToPdf(pixa2, 75, 1.0, 0, 0, NULL, "/tmp/lept/boxa/show.pdf");
pixDestroy(&pix1);
pixaDestroy(&pixa1);
pixaDestroy(&pixa2);
boxaaDestroy(&baa1);
boxaaDestroy(&baa2);
boxaaDestroy(&baa3);
return 0;
}
int main(int argc,
char **argv)
{
l_uint8 *data1, *data2;
l_int32 i, same, w, h, width, success, nba;
size_t size1, size2;
l_float32 diffarea, diffxor, scalefact;
BOX *box;
BOXA *boxa1, *boxa2, *boxa3;
BOXAA *baa1, *baa2, *baa3;
PIX *pix1, *pixdb;
PIXA *pixa1, *pixa2;
L_REGPARAMS *rp;
if (regTestSetup(argc, argv, &rp))
return 1;
lept_mkdir("lept/boxa");
/* Make a boxa and display its contents */
boxa1 = boxaCreate(6);
box = boxCreate(60, 60, 40, 20);
boxaAddBox(boxa1, box, L_INSERT);
box = boxCreate(120, 50, 20, 50);
boxaAddBox(boxa1, box, L_INSERT);
box = boxCreate(50, 140, 46, 60);
boxaAddBox(boxa1, box, L_INSERT);
box = boxCreate(166, 130, 64, 28);
boxaAddBox(boxa1, box, L_INSERT);
box = boxCreate(64, 224, 44, 34);
boxaAddBox(boxa1, box, L_INSERT);
box = boxCreate(117, 206, 26, 74);
boxaAddBox(boxa1, box, L_INSERT);
pix1 = DisplayBoxa(boxa1);
regTestWritePixAndCheck(rp, pix1, IFF_PNG); /* 0 */
pixDisplayWithTitle(pix1, 0, 0, NULL, rp->display);
pixDestroy(&pix1);
boxaCompareRegions(boxa1, boxa1, 100, &same, &diffarea, &diffxor, NULL);
regTestCompareValues(rp, 1, same, 0.0); /* 1 */
regTestCompareValues(rp, 0.0, diffarea, 0.0); /* 2 */
regTestCompareValues(rp, 0.0, diffxor, 0.0); /* 3 */
boxa2 = boxaTransform(boxa1, -13, -13, 1.0, 1.0);
boxaCompareRegions(boxa1, boxa2, 10, &same, &diffarea, &diffxor, NULL);
regTestCompareValues(rp, 1, same, 0.0); /* 4 */
regTestCompareValues(rp, 0.0, diffarea, 0.0); /* 5 */
regTestCompareValues(rp, 0.0, diffxor, 0.0); /* 6 */
boxaDestroy(&boxa2);
boxa2 = boxaReconcileEvenOddHeight(boxa1, L_ADJUST_TOP_AND_BOT, 6,
L_ADJUST_CHOOSE_MIN, 1.0, 0);
pix1 = DisplayBoxa(boxa2);
regTestWritePixAndCheck(rp, pix1, IFF_PNG); /* 7 */
pixDisplayWithTitle(pix1, 200, 0, NULL, rp->display);
pixDestroy(&pix1);
boxaCompareRegions(boxa1, boxa2, 10, &same, &diffarea, &diffxor, &pixdb);
regTestCompareValues(rp, 1, same, 0.0); /* 8 */
regTestCompareValues(rp, 0.053, diffarea, 0.002); /* 9 */
regTestCompareValues(rp, 0.240, diffxor, 0.002); /* 10 */
regTestWritePixAndCheck(rp, pixdb, IFF_PNG); /* 11 */
pixDisplayWithTitle(pixdb, 400, 0, NULL, rp->display);
pixDestroy(&pixdb);
boxaDestroy(&boxa1);
boxaDestroy(&boxa2);
/* Input is a fairly clean boxa */
boxa1 = boxaRead("boxa1.ba");
boxa2 = boxaReconcileEvenOddHeight(boxa1, L_ADJUST_TOP, 80,
L_ADJUST_CHOOSE_MIN, 1.05, 1);
width = 100;
boxaGetExtent(boxa2, &w, &h, NULL);
scalefact = (l_float32)width / (l_float32)w;
boxa3 = boxaTransform(boxa2, 0, 0, scalefact, scalefact);
pix1 = boxaDisplayTiled(boxa3, NULL, 1500, 2, 1.0, 0, 3, 2);
regTestWritePixAndCheck(rp, pix1, IFF_PNG); /* 12 */
pixDisplayWithTitle(pix1, 600, 0, NULL, rp->display);
pixDestroy(&pix1);
boxaDestroy(&boxa1);
boxaDestroy(&boxa2);
boxaDestroy(&boxa3);
/* Input is an unsmoothed and noisy boxa */
boxa1 = boxaRead("boxa2.ba");
boxa2 = boxaReconcileEvenOddHeight(boxa1, L_ADJUST_TOP, 80,
L_ADJUST_CHOOSE_MIN, 1.05, 1);
width = 100;
boxaGetExtent(boxa2, &w, &h, NULL);
scalefact = (l_float32)width / (l_float32)w;
boxa3 = boxaTransform(boxa2, 0, 0, scalefact, scalefact);
pix1 = boxaDisplayTiled(boxa3, NULL, 1500, 2, 1.0, 0, 3, 2);
regTestWritePixAndCheck(rp, pix1, IFF_PNG); /* 13 */
pixDisplayWithTitle(pix1, 800, 0, NULL, rp->display);
pixDestroy(&pix1);
boxaDestroy(&boxa1);
boxaDestroy(&boxa2);
boxaDestroy(&boxa3);
/* Input is a boxa smoothed with a median window filter */
boxa1 = boxaRead("boxa3.ba");
boxa2 = boxaReconcileEvenOddHeight(boxa1, L_ADJUST_TOP, 80,
L_ADJUST_CHOOSE_MIN, 1.05, 1);
width = 100;
boxaGetExtent(boxa2, &w, &h, NULL);
scalefact = (l_float32)width / (l_float32)w;
boxa3 = boxaTransform(boxa2, 0, 0, scalefact, scalefact);
pix1 = boxaDisplayTiled(boxa3, NULL, 1500, 2, 1.0, 0, 3, 2);
regTestWritePixAndCheck(rp, pix1, IFF_PNG); /* 14 */
pixDisplayWithTitle(pix1, 1000, 0, NULL, rp->display);
pixDestroy(&pix1);
boxaDestroy(&boxa1);
boxaDestroy(&boxa2);
boxaDestroy(&boxa3);
/* Test serialized boxa I/O to and from memory */
data1 = l_binaryRead("boxa2.ba", &size1);
boxa1 = boxaReadMem(data1, size1);
boxaWriteMem(&data2, &size2, boxa1);
boxa2 = boxaReadMem(data2, size2);
boxaWrite("/tmp/lept/boxa/boxa1.ba", boxa1);
boxaWrite("/tmp/lept/boxa/boxa2.ba", boxa2);
filesAreIdentical("/tmp/lept/boxa/boxa1.ba", "/tmp/lept/boxa/boxa2.ba",
&same);
regTestCompareValues(rp, 1, same, 0.0); /* 15 */
boxaDestroy(&boxa1);
boxaDestroy(&boxa2);
lept_free(data1);
lept_free(data2);
/* ----------- Test pixaDisplayBoxaa() ------------ */
pixa1 = pixaReadBoth("showboxes.pac");
baa1 = boxaaRead("showboxes1.baa");
baa2 = boxaaTranspose(baa1);
baa3 = boxaaTranspose(baa2);
nba = boxaaGetCount(baa1);
success = TRUE;
for (i = 0; i < nba; i++) {
boxa1 = boxaaGetBoxa(baa1, i, L_CLONE);
boxa2 = boxaaGetBoxa(baa3, i, L_CLONE);
boxaEqual(boxa1, boxa2, 0, NULL, &same);
boxaDestroy(&boxa1);
boxaDestroy(&boxa2);
if (!same) success = FALSE;
}
/* Check that the transpose is reversible */
regTestCompareValues(rp, 1, success, 0.0); /* 16 */
pixa2 = pixaDisplayBoxaa(pixa1, baa2, L_DRAW_RGB, 2);
pix1 = pixaDisplayTiledInRows(pixa2, 32, 1400, 1.0, 0, 10, 0);
regTestWritePixAndCheck(rp, pix1, IFF_PNG); /* 17 */
pixDisplayWithTitle(pix1, 0, 600, NULL, rp->display);
fprintf(stderr, "Writing to: /tmp/lept/boxa/show.pdf\n");
l_pdfSetDateAndVersion(FALSE);
pixaConvertToPdf(pixa2, 75, 1.0, 0, 0, NULL, "/tmp/lept/boxa/show.pdf");
regTestCheckFile(rp, "/tmp/lept/boxa/show.pdf"); /* 18 */
pixDestroy(&pix1);
pixaDestroy(&pixa1);
pixaDestroy(&pixa2);
boxaaDestroy(&baa1);
boxaaDestroy(&baa2);
boxaaDestroy(&baa3);
return regTestCleanup(rp);
}
