/*====================================================================*
- Copyright (C) 2001 Leptonica. All rights reserved.
- This software is distributed in the hope that it will be
- useful, but with NO WARRANTY OF ANY KIND.
- No author or distributor accepts responsibility to anyone for the
- consequences of using this software, or for whether it serves any
- particular purpose or works at all, unless he or she says so in
- writing. Everyone is granted permission to copy, modify and
- redistribute this source code, for commercial or non-commercial
- purposes, with the following restrictions: (1) the origin of this
- source code must not be misrepresented; (2) modified versions must
- be plainly marked as such; and (3) this notice may not be removed
- or altered from any source or modified source distribution.
*====================================================================*/
/*
* boxbasic.c
*
* Basic 'class' functions for box, boxa and boxaa,
* including accessors and serialization.
*
* Box creation, copy, clone, destruction
* BOX *boxCreate()
* BOX *boxCopy()
* BOX *boxClone()
* void boxDestroy()
*
* Box accessors
* l_int32 boxGetGeometry()
* l_int32 boxSetGeometry()
* l_int32 boxGetRefcount()
* l_int32 boxChangeRefcount()
*
* Boxa creation, copy, destruction
* BOXA *boxaCreate()
* BOXA *boxaCopy()
* void boxaDestroy()
*
* Boxa array extension
* l_int32 boxaAddBox()
* l_int32 boxaExtendArray()
*
* Boxa accessors
* l_int32 boxaGetCount()
* l_int32 boxaGetBox()
* l_int32 boxaGetBoxGeometry()
*
* Boxa array modifiers
* l_int32 boxaReplaceBox()
* l_int32 boxaInsertBox()
* l_int32 boxaRemoveBox()
*
* Boxaa creation, copy, destruction
* BOXAA *boxaaCreate()
* BOXAA *boxaaCopy()
* void boxaaDestroy()
*
* Boxaa array extension
* l_int32 boxaaAddBoxa()
* l_int32 boxaaExtendArray()
*
* Boxaa accessors
* l_int32 boxaaGetCount()
* l_int32 boxaaGetBoxCount()
* BOXA *boxaaGetBoxa()
*
* Boxa array modifiers
* l_int32 boxaaReplaceBoxa()
* l_int32 boxaaInsertBoxa()
* l_int32 boxaaRemoveBoxa()
* l_int32 boxaaAddBox()
*
* Boxaa serialized I/O
* BOXAA *boxaaRead()
* BOXAA *boxaaReadStream()
* l_int32 boxaaWrite()
* l_int32 boxaaWriteStream()
*
* Boxa serialized I/O
* BOXA *boxaRead()
* BOXA *boxaReadStream()
* l_int32 boxaWrite()
* l_int32 boxaWriteStream()
*
* Box print (for debug)
* l_int32 boxPrintStreamInfo()
*
* Backward compatibility old boxaa read functions
* BOXAA *boxaaReadVersion2()
* BOXAA *boxaaReadStreamVersion2()
*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "allheaders.h"
static const l_int32 INITIAL_PTR_ARRAYSIZE = 20; /* n'import quoi */
/*---------------------------------------------------------------------*
* Box creation, destruction and copy *
*---------------------------------------------------------------------*/
/*!
* boxCreate()
*
* Input: x, y, width, height
* Return: box, or null on error
*
* Notes:
* (1) This clips the box to the +quad. If no part of the
* box is in the +quad, this returns NULL.
*/
BOX *
boxCreate(l_int32 x,
l_int32 y,
l_int32 w,
l_int32 h)
{
BOX *box;
PROCNAME("boxCreate");
if (w <= 0 || h <= 0)
return (BOX *)ERROR_PTR("w and h not both > 0", procName, NULL);
if (x < 0) { /* take part in +quad */
w = w + x;
x = 0;
if (w <= 0)
return (BOX *)ERROR_PTR("x < 0 and box off +quad", procName, NULL);
}
if (y < 0) { /* take part in +quad */
h = h + y;
y = 0;
if (h <= 0)
return (BOX *)ERROR_PTR("y < 0 and box off +quad", procName, NULL);
}
if ((box = (BOX *)CALLOC(1, sizeof(BOX))) == NULL)
return (BOX *)ERROR_PTR("box not made", procName, NULL);
boxSetGeometry(box, x, y, w, h);
box->refcount = 1;
return box;
}
/*!
* boxCopy()
*
* Input: box
* Return: copy of box, or null on error
*/
BOX *
boxCopy(BOX *box)
{
BOX *boxc;
PROCNAME("boxCopy");
if (!box)
return (BOX *)ERROR_PTR("box not defined", procName, NULL);
boxc = boxCreate(box->x, box->y, box->w, box->h);
return boxc;
}
/*!
* boxClone()
*
* Input: box
* Return: ptr to same box, or null on error
*/
BOX *
boxClone(BOX *box)
{
PROCNAME("boxClone");
if (!box)
return (BOX *)ERROR_PTR("box not defined", procName, NULL);
boxChangeRefcount(box, 1);
return box;
}
/*!
* boxDestroy()
*
* Input: &box (<will be set to null before returning>)
* Return: void
*
* Notes:
* (1) Decrements the ref count and, if 0, destroys the box.
* (2) Always nulls the input ptr.
*/
void
boxDestroy(BOX **pbox)
{
BOX *box;
PROCNAME("boxDestroy");
if (pbox == NULL) {
L_WARNING("ptr address is null!", procName);
return;
}
if ((box = *pbox) == NULL)
return;
boxChangeRefcount(box, -1);
if (boxGetRefcount(box) <= 0)
FREE(box);
*pbox = NULL;
return;
}
/*---------------------------------------------------------------------*
* Box accessors *
*---------------------------------------------------------------------*/
/*!
* boxGetGeometry()
*
* Input: box
* &x, &y, &w, &h (<optional return>; each can be null)
* Return: 0 if OK, 1 on error
*/
l_int32
boxGetGeometry(BOX *box,
l_int32 *px,
l_int32 *py,
l_int32 *pw,
l_int32 *ph)
{
PROCNAME("boxGetGeometry");
if (px) *px = 0;
if (py) *py = 0;
if (pw) *pw = 0;
if (ph) *ph = 0;
if (!box)
return ERROR_INT("box not defined", procName, 1);
if (px) *px = box->x;
if (py) *py = box->y;
if (pw) *pw = box->w;
if (ph) *ph = box->h;
return 0;
}
/*!
* boxSetGeometry()
*
* Input: box
* x, y, w, h (use -1 to leave unchanged)
* Return: 0 if OK, 1 on error
*/
l_int32
boxSetGeometry(BOX *box,
l_int32 x,
l_int32 y,
l_int32 w,
l_int32 h)
{
PROCNAME("boxSetGeometry");
if (!box)
return ERROR_INT("box not defined", procName, 1);
if (x != -1) box->x = x;
if (y != -1) box->y = y;
if (w != -1) box->w = w;
if (h != -1) box->h = h;
return 0;
}
l_int32
boxGetRefcount(BOX *box)
{
PROCNAME("boxGetRefcount");
if (!box)
return ERROR_INT("box not defined", procName, UNDEF);
return box->refcount;
}
l_int32
boxChangeRefcount(BOX *box,
l_int32 delta)
{
PROCNAME("boxChangeRefcount");
if (!box)
return ERROR_INT("box not defined", procName, 1);
box->refcount += delta;
return 0;
}
/*---------------------------------------------------------------------*
* Boxa creation, destruction, copy, extension *
*---------------------------------------------------------------------*/
/*!
* boxaCreate()
*
* Input: n (initial number of ptrs)
* Return: boxa, or null on error
*/
BOXA *
boxaCreate(l_int32 n)
{
BOXA *boxa;
PROCNAME("boxaCreate");
if (n <= 0)
n = INITIAL_PTR_ARRAYSIZE;
if ((boxa = (BOXA *)CALLOC(1, sizeof(BOXA))) == NULL)
return (BOXA *)ERROR_PTR("boxa not made", procName, NULL);
boxa->n = 0;
boxa->nalloc = n;
boxa->refcount = 1;
if ((boxa->box = (BOX **)CALLOC(n, sizeof(BOX *))) == NULL)
return (BOXA *)ERROR_PTR("boxa ptrs not made", procName, NULL);
return boxa;
}
/*!
* boxaCopy()
*
* Input: boxa
* copyflag (L_COPY, L_CLONE, L_COPY_CLONE)
* Return: new boxa, or null on error
*
* Notes:
* (1) See pix.h for description of the copyflag.
* (2) The copy-clone makes a new boxa that holds clones of each box.
*/
BOXA *
boxaCopy(BOXA *boxa,
l_int32 copyflag)
{
l_int32 i;
BOX *boxc;
BOXA *boxac;
PROCNAME("boxaCopy");
if (!boxa)
return (BOXA *)ERROR_PTR("boxa not defined", procName, NULL);
if (copyflag == L_CLONE) {
boxa->refcount++;
return boxa;
}
if (copyflag != L_COPY && copyflag != L_COPY_CLONE)
return (BOXA *)ERROR_PTR("invalid copyflag", procName, NULL);
if ((boxac = boxaCreate(boxa->nalloc)) == NULL)
return (BOXA *)ERROR_PTR("boxac not made", procName, NULL);
for (i = 0; i < boxa->n; i++) {
if (copyflag == L_COPY)
boxc = boxaGetBox(boxa, i, L_COPY);
else /* copy-clone */
boxc = boxaGetBox(boxa, i, L_CLONE);
boxaAddBox(boxac, boxc, L_INSERT);
}
return boxac;
}
/*!
* boxaDestroy()
*
* Input: &boxa (<will be set to null before returning>)
* Return: void
*
* Note:
* - Decrements the ref count and, if 0, destroys the boxa.
* - Always nulls the input ptr.
*/
void
boxaDestroy(BOXA **pboxa)
{
l_int32 i;
BOXA *boxa;
PROCNAME("boxaDestroy");
if (pboxa == NULL) {
L_WARNING("ptr address is null!", procName);
return;
}
if ((boxa = *pboxa) == NULL)
return;
/* Decrement the ref count. If it is 0, destroy the boxa. */
boxa->refcount--;
if (boxa->refcount <= 0) {
for (i = 0; i < boxa->n; i++)
boxDestroy(&boxa->box[i]);
FREE(boxa->box);
FREE(boxa);
}
*pboxa = NULL;
return;
}
/*!
* boxaAddBox()
*
* Input: boxa
* box (to be added)
* copyflag (L_INSERT, L_COPY, L_CLONE)
* Return: 0 if OK, 1 on error
*/
l_int32
boxaAddBox(BOXA *boxa,
BOX *box,
l_int32 copyflag)
{
l_int32 n;
BOX *boxc;
PROCNAME("boxaAddBox");
if (!boxa)
return ERROR_INT("boxa not defined", procName, 1);
if (!box)
return ERROR_INT("box not defined", procName, 1);
if (copyflag == L_INSERT)
boxc = box;
else if (copyflag == L_COPY)
boxc = boxCopy(box);
else if (copyflag == L_CLONE)
boxc = boxClone(box);
else
return ERROR_INT("invalid copyflag", procName, 1);
if (!boxc)
return ERROR_INT("boxc not made", procName, 1);
n = boxaGetCount(boxa);
if (n >= boxa->nalloc)
boxaExtendArray(boxa);
boxa->box[n] = boxc;
boxa->n++;
return 0;
}
/*!
* boxaExtendArray()
*
* Input: boxa
* Return: 0 if OK; 1 on error
*/
l_int32
boxaExtendArray(BOXA *boxa)
{
PROCNAME("boxaExtendArray");
if (!boxa)
return ERROR_INT("boxa not defined", procName, 1);
if ((boxa->box = (BOX **)reallocNew((void **)&boxa->box,
sizeof(BOX *) * boxa->nalloc,
2 * sizeof(BOX *) * boxa->nalloc)) == NULL)
return ERROR_INT("new ptr array not returned", procName, 1);
boxa->nalloc = 2 * boxa->nalloc;
return 0;
}
/*---------------------------------------------------------------------*
* Boxa accessors *
*---------------------------------------------------------------------*/
/*!
* boxaGetCount()
*
* Input: boxa
* Return: count, or 0 on error
*/
l_int32
boxaGetCount(BOXA *boxa)
{
PROCNAME("boxaGetCount");
if (!boxa)
return ERROR_INT("boxa not defined", procName, 0);
return boxa->n;
}
/*!
* boxaGetBox()
*
* Input: boxa
* index (to the index-th box)
* accessflag (L_COPY or L_CLONE)
* Return: box, or null on error
*/
BOX *
boxaGetBox(BOXA *boxa,
l_int32 index,
l_int32 accessflag)
{
PROCNAME("boxaGetBox");
if (!boxa)
return (BOX *)ERROR_PTR("boxa not defined", procName, NULL);
if (index < 0 || index >= boxa->n)
return (BOX *)ERROR_PTR("index not valid", procName, NULL);
if (accessflag == L_COPY)
return boxCopy(boxa->box[index]);
else if (accessflag == L_CLONE)
return boxClone(boxa->box[index]);
else
return (BOX *)ERROR_PTR("invalid accessflag", procName, NULL);
}
/*!
* boxaGetBoxGeometry()
*
* Input: boxa
* index (to the index-th box)
* &x, &y, &w, &h (<optional return>; each can be null)
* Return: 0 if OK, 1 on error
*/
l_int32
boxaGetBoxGeometry(BOXA *boxa,
l_int32 index,
l_int32 *px,
l_int32 *py,
l_int32 *pw,
l_int32 *ph)
{
BOX *box;
PROCNAME("boxaGetBoxGeometry");
if (px) *px = 0;
if (py) *py = 0;
if (pw) *pw = 0;
if (ph) *ph = 0;
if (!boxa)
return ERROR_INT("boxa not defined", procName, 1);
if (index < 0 || index >= boxa->n)
return ERROR_INT("index not valid", procName, 1);
if ((box = boxaGetBox(boxa, index, L_CLONE)) == NULL)
return ERROR_INT("box not found!", procName, 1);
boxGetGeometry(box, px, py, pw, ph);
boxDestroy(&box);
return 0;
}
/*---------------------------------------------------------------------*
* Boxa array modifiers *
*---------------------------------------------------------------------*/
/*!
* boxaReplaceBox()
*
* Input: boxa
* index (to the index-th box)
* box (insert to replace existing one)
* Return: 0 if OK, 1 on error
*
* Notes:
* (1) In-place replacement of one box.
* (2) The previous box at that location is destroyed.
*/
l_int32
boxaReplaceBox(BOXA *boxa,
l_int32 index,
BOX *box)
{
PROCNAME("boxaReplaceBox");
if (!boxa)
return ERROR_INT("boxa not defined", procName, 1);
if (index < 0 || index >= boxa->n)
return ERROR_INT("index not valid", procName, 1);
if (!box)
return ERROR_INT("box not defined", procName, 1);
boxDestroy(&(boxa->box[index]));
boxa->box[index] = box;
return 0;
}
/*!
* boxaInsertBox()
*
* Input: boxa
* index (location in boxa to insert new value)
* box (new box to be inserted)
* Return: 0 if OK, 1 on error
*
* Notes:
* (1) This shifts box[i] --> box[i + 1] for all i >= index,
* and then inserts box as box[index].
* (2) To insert at the beginning of the array, set index = 0.
* (3) To append to the array, it's easier to use boxaAddBox().
* (4) This should not be used repeatedly to insert into large arrays,
* because the function is O(n).
*/
l_int32
boxaInsertBox(BOXA *boxa,
l_int32 index,
BOX *box)
{
l_int32 i, n;
BOX **array;
PROCNAME("boxaInsertBox");
if (!boxa)
return ERROR_INT("boxa not defined", procName, 1);
n = boxaGetCount(boxa);
if (index < 0 || index > n)
return ERROR_INT("index not in {0...n}", procName, 1);
if (!box)
return ERROR_INT("box not defined", procName, 1);
if (n >= boxa->nalloc)
boxaExtendArray(boxa);
array = boxa->box;
boxa->n++;
for (i = n; i > index; i--)
array[i] = array[i - 1];
array[index] = box;
return 0;
}
/*!
* boxaRemoveBox()
*
* Input: boxa
* index (of box to be removed)
* Return: 0 if OK, 1 on error
*
* Notes:
* (1) This removes box[index] and then shifts
* box[i] --> box[i - 1] for all i > index.
* (2) It should not be used repeatedly to remove boxes from
* large arrays, because the function is O(n).
*/
l_int32
boxaRemoveBox(BOXA *boxa,
l_int32 index)
{
l_int32 i, n;
BOX **array;
PROCNAME("boxaRemoveBox");
if (!boxa)
return ERROR_INT("boxa not defined", procName, 1);
n = boxaGetCount(boxa);
if (index < 0 || index >= n)
return ERROR_INT("index not in {0...n - 1}", procName, 1);
array = boxa->box;
boxDestroy(&array[index]);
for (i = index + 1; i < n; i++)
array[i - 1] = array[i];
array[n - 1] = NULL;
boxa->n--;
return 0;
}
/*--------------------------------------------------------------------------*
* Boxaa creation, destruction *
*--------------------------------------------------------------------------*/
/*!
* boxaaCreate()
*
* Input: size of boxa ptr array to be alloc'd (0 for default)
* Return: baa, or null on error
*/
BOXAA *
boxaaCreate(l_int32 n)
{
BOXAA *baa;
PROCNAME("boxaaCreate");
if (n <= 0)
n = INITIAL_PTR_ARRAYSIZE;
if ((baa = (BOXAA *)CALLOC(1, sizeof(BOXAA))) == NULL)
return (BOXAA *)ERROR_PTR("baa not made", procName, NULL);
if ((baa->boxa = (BOXA **)CALLOC(n, sizeof(BOXA *))) == NULL)
return (BOXAA *)ERROR_PTR("boxa ptr array not made", procName, NULL);
baa->nalloc = n;
baa->n = 0;
return baa;
}
/*!
* 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;
}
/*!
* boxaaDestroy()
*
* Input: &boxaa (<will be set to null before returning>)
* Return: void
*/
void
boxaaDestroy(BOXAA **pbaa)
{
l_int32 i;
BOXAA *baa;
PROCNAME("boxaaDestroy");
if (pbaa == NULL) {
L_WARNING("ptr address is NULL!", procName);
return;
}
if ((baa = *pbaa) == NULL)
return;
for (i = 0; i < baa->n; i++)
boxaDestroy(&baa->boxa[i]);
FREE(baa->boxa);
FREE(baa);
*pbaa = NULL;
return;
}
/*--------------------------------------------------------------------------*
* Add Boxa to Boxaa *
*--------------------------------------------------------------------------*/
/*!
* 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;
}
/*!
* boxaaExtendArray()
*
* Input: boxaa
* Return: 0 if OK, 1 on error
*/
l_int32
boxaaExtendArray(BOXAA *baa)
{
PROCNAME("boxaaExtendArray");
if (!baa)
return ERROR_INT("baa not defined", procName, 1);
if ((baa->boxa = (BOXA **)reallocNew((void **)&baa->boxa,
sizeof(BOXA *) * baa->nalloc,
2 * sizeof(BOXA *) * baa->nalloc)) == NULL)
return ERROR_INT("new ptr array not returned", procName, 1);
baa->nalloc *= 2;
return 0;
}
/*----------------------------------------------------------------------*
* Boxaa accessors *
*----------------------------------------------------------------------*/
/*!
* boxaaGetCount()
*
* Input: boxaa
* Return: count (number of boxa), or 0 if no boxa or on error
*/
l_int32
boxaaGetCount(BOXAA *baa)
{
PROCNAME("boxaaGetCount");
if (!baa)
return ERROR_INT("baa not defined", procName, 0);
return baa->n;
}
/*!
* 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;
}
/*!
* 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);
}
/*!
* 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;
}
/*!
* 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;
}
/*!
* 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;
}
/*!
* 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;
}
/*---------------------------------------------------------------------*
* Boxaa serialized I/O *
*---------------------------------------------------------------------*/
/*!
* boxaaRead()
*
* Input: filename
* Return: boxaa, or null on error
*/
BOXAA *
boxaaRead(const char *filename)
{
FILE *fp;
BOXAA *baa;
PROCNAME("boxaaRead");
if (!filename)
return (BOXAA *)ERROR_PTR("filename not defined", procName, NULL);
if ((fp = fopenReadStream(filename)) == NULL)
return (BOXAA *)ERROR_PTR("stream not opened", procName, NULL);
if ((baa = boxaaReadStream(fp)) == NULL) {
fclose(fp);
return (BOXAA *)ERROR_PTR("boxaa not read", procName, NULL);
}
fclose(fp);
return baa;
}
/*!
* boxaaReadStream()
*
* Input: stream
* Return: boxaa, or null on error
*/
BOXAA *
boxaaReadStream(FILE *fp)
{
l_int32 n, i, x, y, w, h, version;
l_int32 ignore;
BOXA *boxa;
BOXAA *baa;
PROCNAME("boxaaReadStream");
if (!fp)
return (BOXAA *)ERROR_PTR("stream not defined", procName, NULL);
if (fscanf(fp, "\nBoxaa Version %d\n", &version) != 1)
return (BOXAA *)ERROR_PTR("not a boxaa file", procName, NULL);
if (version != BOXAA_VERSION_NUMBER)
return (BOXAA *)ERROR_PTR("invalid boxa version", procName, NULL);
if (fscanf(fp, "Number of boxa = %d\n", &n) != 1)
return (BOXAA *)ERROR_PTR("not a boxaa file", procName, NULL);
if ((baa = boxaaCreate(n)) == NULL)
return (BOXAA *)ERROR_PTR("boxaa not made", procName, NULL);
for (i = 0; i < n; i++) {
if (fscanf(fp, "\nBoxa[%d] extent: x = %d, y = %d, w = %d, h = %d",
&ignore, &x, &y, &w, &h) != 5)
return (BOXAA *)ERROR_PTR("boxa descr not valid", procName, NULL);
if ((boxa = boxaReadStream(fp)) == NULL)
return (BOXAA *)ERROR_PTR("boxa not made", procName, NULL);
boxaaAddBoxa(baa, boxa, L_INSERT);
}
return baa;
}
/*!
* boxaaWrite()
*
* Input: filename
* boxaa
* Return: 0 if OK, 1 on error
*/
l_int32
boxaaWrite(const char *filename,
BOXAA *baa)
{
FILE *fp;
PROCNAME("boxaaWrite");
if (!filename)
return ERROR_INT("filename not defined", procName, 1);
if (!baa)
return ERROR_INT("baa not defined", procName, 1);
if ((fp = fopen(filename, "w")) == NULL)
return ERROR_INT("stream not opened", procName, 1);
if (boxaaWriteStream(fp, baa))
return ERROR_INT("baa not written to stream", procName, 1);
fclose(fp);
return 0;
}
/*!
* 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;
}
/*---------------------------------------------------------------------*
* Boxa serialized I/O *
*---------------------------------------------------------------------*/
/*!
* boxaRead()
*
* Input: filename
* Return: boxa, or null on error
*/
BOXA *
boxaRead(const char *filename)
{
FILE *fp;
BOXA *boxa;
PROCNAME("boxaRead");
if (!filename)
return (BOXA *)ERROR_PTR("filename not defined", procName, NULL);
if ((fp = fopenReadStream(filename)) == NULL)
return (BOXA *)ERROR_PTR("stream not opened", procName, NULL);
if ((boxa = boxaReadStream(fp)) == NULL) {
fclose(fp);
return (BOXA *)ERROR_PTR("boxa not read", procName, NULL);
}
fclose(fp);
return boxa;
}
/*!
* boxaReadStream()
*
* Input: stream
* Return: boxa, or null on error
*/
BOXA *
boxaReadStream(FILE *fp)
{
l_int32 n, i, x, y, w, h, version;
l_int32 ignore;
BOX *box;
BOXA *boxa;
PROCNAME("boxaReadStream");
if (!fp)
return (BOXA *)ERROR_PTR("stream not defined", procName, NULL);
if (fscanf(fp, "\nBoxa Version %d\n", &version) != 1)
return (BOXA *)ERROR_PTR("not a boxa file", procName, NULL);
if (version != BOXA_VERSION_NUMBER)
return (BOXA *)ERROR_PTR("invalid boxa version", procName, NULL);
if (fscanf(fp, "Number of boxes = %d\n", &n) != 1)
return (BOXA *)ERROR_PTR("not a boxa file", procName, NULL);
if ((boxa = boxaCreate(n)) == NULL)
return (BOXA *)ERROR_PTR("boxa not made", procName, NULL);
for (i = 0; i < n; i++) {
if (fscanf(fp, " Box[%d]: x = %d, y = %d, w = %d, h = %d\n",
&ignore, &x, &y, &w, &h) != 5)
return (BOXA *)ERROR_PTR("box descr not valid", procName, NULL);
if ((box = boxCreate(x, y, w, h)) == NULL)
return (BOXA *)ERROR_PTR("box not made", procName, NULL);
boxaAddBox(boxa, box, L_INSERT);
}
return boxa;
}
/*!
* boxaWrite()
*
* Input: filename
* boxa
* Return: 0 if OK, 1 on error
*/
l_int32
boxaWrite(const char *filename,
BOXA *boxa)
{
FILE *fp;
PROCNAME("boxaWrite");
if (!filename)
return ERROR_INT("filename not defined", procName, 1);
if (!boxa)
return ERROR_INT("boxa not defined", procName, 1);
if ((fp = fopen(filename, "w")) == NULL)
return ERROR_INT("stream not opened", procName, 1);
if (boxaWriteStream(fp, boxa))
return ERROR_INT("boxa not written to stream", procName, 1);
fclose(fp);
return 0;
}
/*!
* boxaWriteStream()
*
* Input: stream
* boxa
* Return: 0 if OK, 1 on error
*/
l_int32
boxaWriteStream(FILE *fp,
BOXA *boxa)
{
l_int32 n, i;
BOX *box;
PROCNAME("boxaWriteStream");
if (!fp)
return ERROR_INT("stream not defined", procName, 1);
if (!boxa)
return ERROR_INT("boxa not defined", procName, 1);
n = boxaGetCount(boxa);
fprintf(fp, "\nBoxa Version %d\n", BOXA_VERSION_NUMBER);
fprintf(fp, "Number of boxes = %d\n", n);
for (i = 0; i < n; i++) {
if ((box = boxaGetBox(boxa, i, L_CLONE)) == NULL)
return ERROR_INT("box not found", procName, 1);
fprintf(fp, " Box[%d]: x = %d, y = %d, w = %d, h = %d\n",
i, box->x, box->y, box->w, box->h);
boxDestroy(&box);
}
return 0;
}
/*---------------------------------------------------------------------*
* Debug printing *
*---------------------------------------------------------------------*/
/*!
* boxPrintStreamInfo()
*
* Input: stream
* box
* Return: 0 if OK, 1 on error
*
* Notes:
* (1) This outputs information about the box, for debugging.
* (2) Use serialization functions to write to file if you want
* to read the data back.
*/
l_int32
boxPrintStreamInfo(FILE *fp,
BOX *box)
{
PROCNAME("boxPrintStreamInfo");
if (!fp)
return ERROR_INT("stream not defined", procName, 1);
if (!box)
return ERROR_INT("box not defined", procName, 1);
fprintf(fp, " Box x (pixels) = %d\n", box->x);
fprintf(fp, " Box y (pixels) = %d\n", box->y);
fprintf(fp, " Box width (pixels) = %d\n", box->w);
fprintf(fp, " Box height (pixels) = %d\n", box->h);
return 0;
}
/*---------------------------------------------------------------------*
* Version for reading v.2 boxaa; kept for backward compatibility *
*---------------------------------------------------------------------*/
/*!
* boxaaReadVersion2()
*
* Input: filename
* Return: boxaa, or null on error
*
* Notes:
* (1) These old functions only work on version 2 boxaa.
* They will go to an archive directory sometime after Sept 2009.
* (2) The current format uses BOXAA_VERSION_NUMBER == 3)
*/
BOXAA *
boxaaReadVersion2(const char *filename)
{
FILE *fp;
BOXAA *baa;
PROCNAME("boxaaReadVersion2");
if (!filename)
return (BOXAA *)ERROR_PTR("filename not defined", procName, NULL);
if ((fp = fopenReadStream(filename)) == NULL)
return (BOXAA *)ERROR_PTR("stream not opened", procName, NULL);
if ((baa = boxaaReadStreamVersion2(fp)) == NULL) {
fclose(fp);
return (BOXAA *)ERROR_PTR("boxaa not read", procName, NULL);
}
fclose(fp);
return baa;
}
/*!
* boxaaReadStreamVersion2()
*
* Input: stream
* Return: boxaa, or null on error
*
*/
BOXAA *
boxaaReadStreamVersion2(FILE *fp)
{
l_int32 n, i, x, y, w, h, version;
l_int32 ignore;
BOXA *boxa;
BOXAA *baa;
PROCNAME("boxaaReadStreamVersion2");
if (!fp)
return (BOXAA *)ERROR_PTR("stream not defined", procName, NULL);
if (fscanf(fp, "\nBoxaa Version %d\n", &version) != 1)
return (BOXAA *)ERROR_PTR("not a boxaa file", procName, NULL);
if (version != 2) {
fprintf(stderr, "This is version %d\n", version);
return (BOXAA *)ERROR_PTR("Not old version 2", procName, NULL);
}
if (fscanf(fp, "Number of boxa = %d\n", &n) != 1)
return (BOXAA *)ERROR_PTR("not a boxaa file", procName, NULL);
if ((baa = boxaaCreate(n)) == NULL)
return (BOXAA *)ERROR_PTR("boxaa not made", procName, NULL);
for (i = 0; i < n; i++) {
if (fscanf(fp, " Boxa[%d]: x = %d, y = %d, w = %d, h = %d\n",
&ignore, &x, &y, &w, &h) != 5)
return (BOXAA *)ERROR_PTR("boxa descr not valid", procName, NULL);
if ((boxa = boxaReadStream(fp)) == NULL)
return (BOXAA *)ERROR_PTR("boxa not made", procName, NULL);
boxaaAddBoxa(baa, boxa, L_INSERT);
}
return baa;
}