/*====================================================================*
- 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.
*====================================================================*/
/*
* pts.c
*
* Pta creation, destruction, copy, clone, empty
* PTA *ptaCreate()
* void ptaDestroy()
* PTA *ptaCopy()
* PTA *ptaClone()
* l_int32 ptaEmpty()
*
* Pta array extension
* l_int32 ptaAddPt()
* l_int32 ptaExtendArrays()
*
* Pta rearrangements
* l_int32 ptaJoin()
* PTA *ptaReverse()
* PTA *ptaCyclicPerm()
* PTA *ptaSort()
* PTA *ptaRemoveDuplicates()
*
* Pta Accessors
* l_int32 ptaGetRefcount()
* l_int32 ptaChangeRefcount()
* l_int32 ptaGetCount()
* l_int32 ptaGetPt()
* l_int32 ptaGetIPt()
* l_int32 ptaGetArrays()
*
* Ptaa creation, destruction
* PTAA *ptaaCreate()
* void ptaaDestroy()
*
* Ptaa array extension
* l_int32 ptaaAddPta()
* l_int32 ptaaExtendArray()
*
* Ptaa Accessors
* l_int32 ptaaGetCount()
* l_int32 ptaaGetPta()
*
* Ptaa serialized I/O
* PTAA *ptaaRead()
* PTAA *ptaaReadStream()
* l_int32 ptaaWrite()
* l_int32 ptaaWriteStream()
*
* Pta serialized I/O
* PTA *ptaRead()
* PTA *ptaReadStream()
* l_int32 ptaWrite()
* l_int32 ptaWriteStream()
*
* In use
* BOX *ptaGetExtent()
* PTA *ptaGetInsideBox()
* PTA *pixFindCornerPixels()
* l_int32 pixPlotAlongPta()
* l_int32 ptaContainsPt()
* l_int32 ptaTestIntersection()
* PTA *ptaTransform()
* PTA *ptaSubsample()
* l_int32 ptaGetLinearLSF()
* PTA *ptaGetPixelsFromPix()
* PIX *pixGenerateFromPta()
* PTA *ptaGetBoundaryPixels()
* PTAA *ptaaGetBoundaryPixels()
*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "allheaders.h"
static const l_int32 INITIAL_PTR_ARRAYSIZE = 20; /* n'import quoi */
/* Default spreading factor for hashing pts in a plane */
static const l_int32 DEFAULT_SPREADING_FACTOR = 7500;
/*---------------------------------------------------------------------*
* PTA creation, destruction, copy, clone *
*---------------------------------------------------------------------*/
/*!
* ptaCreate()
*
* Input: n (initial array sizes)
* Return: pta, or null on error.
*/
PTA *
ptaCreate(l_int32 n)
{
PTA *pta;
PROCNAME("ptaCreate");
if (n <= 0)
n = INITIAL_PTR_ARRAYSIZE;
if ((pta = (PTA *)CALLOC(1, sizeof(PTA))) == NULL)
return (PTA *)ERROR_PTR("pta not made", procName, NULL);
pta->n = 0;
pta->nalloc = n;
ptaChangeRefcount(pta, 1); /* sets to 1 */
if ((pta->x = (l_float32 *)CALLOC(n, sizeof(l_float32))) == NULL)
return (PTA *)ERROR_PTR("x array not made", procName, NULL);
if ((pta->y = (l_float32 *)CALLOC(n, sizeof(l_float32))) == NULL)
return (PTA *)ERROR_PTR("y array not made", procName, NULL);
return pta;
}
/*!
* ptaDestroy()
*
* Input: &pta (<to be nulled>)
* Return: void
*
* Note:
* - Decrements the ref count and, if 0, destroys the pta.
* - Always nulls the input ptr.
*/
void
ptaDestroy(PTA **ppta)
{
PTA *pta;
PROCNAME("ptaDestroy");
if (ppta == NULL) {
L_WARNING("ptr address is NULL!", procName);
return;
}
if ((pta = *ppta) == NULL)
return;
ptaChangeRefcount(pta, -1);
if (ptaGetRefcount(pta) <= 0) {
FREE(pta->x);
FREE(pta->y);
FREE(pta);
}
*ppta = NULL;
return;
}
/*!
* ptaCopy()
*
* Input: pta
* Return: copy of pta, or null on error
*/
PTA *
ptaCopy(PTA *pta)
{
l_int32 i;
l_float32 x, y;
PTA *npta;
PROCNAME("ptaCopy");
if (!pta)
return (PTA *)ERROR_PTR("pta not defined", procName, NULL);
if ((npta = ptaCreate(pta->nalloc)) == NULL)
return (PTA *)ERROR_PTR("npta not made", procName, NULL);
for (i = 0; i < pta->n; i++) {
ptaGetPt(pta, i, &x, &y);
ptaAddPt(npta, x, y);
}
return npta;
}
/*!
* ptaClone()
*
* Input: pta
* Return: ptr to same pta, or null on error
*/
PTA *
ptaClone(PTA *pta)
{
PROCNAME("ptaClone");
if (!pta)
return (PTA *)ERROR_PTR("pta not defined", procName, NULL);
ptaChangeRefcount(pta, 1);
return pta;
}
/*!
* ptaEmpty()
*
* Input: pta
* Return: 0 if OK, 1 on error
*
* Note: this only resets the "n" field, for reuse
*/
l_int32
ptaEmpty(PTA *pta)
{
PROCNAME("ptaEmpty");
if (!pta)
return ERROR_INT("ptad not defined", procName, 1);
pta->n = 0;
return 0;
}
/*---------------------------------------------------------------------*
* PTA array extension *
*---------------------------------------------------------------------*/
/*!
* ptaAddPt()
*
* Input: pta
* x, y
* Return: 0 if OK, 1 on error
*/
l_int32
ptaAddPt(PTA *pta,
l_float32 x,
l_float32 y)
{
l_int32 n;
PROCNAME("ptaAddPt");
if (!pta)
return ERROR_INT("pta not defined", procName, 1);
n = pta->n;
if (n >= pta->nalloc)
ptaExtendArrays(pta);
pta->x[n] = x;
pta->y[n] = y;
pta->n++;
return 0;
}
/*!
* ptaExtendArrays()
*
* Input: pta
* Return: 0 if OK; 1 on error
*/
l_int32
ptaExtendArrays(PTA *pta)
{
PROCNAME("ptaExtendArrays");
if (!pta)
return ERROR_INT("pta not defined", procName, 1);
if ((pta->x = (l_float32 *)reallocNew((void **)&pta->x,
sizeof(l_float32) * pta->nalloc,
2 * sizeof(l_float32) * pta->nalloc)) == NULL)
return ERROR_INT("new x array not returned", procName, 1);
if ((pta->y = (l_float32 *)reallocNew((void **)&pta->y,
sizeof(l_float32) * pta->nalloc,
2 * sizeof(l_float32) * pta->nalloc)) == NULL)
return ERROR_INT("new y array not returned", procName, 1);
pta->nalloc = 2 * pta->nalloc;
return 0;
}
/*---------------------------------------------------------------------*
* Pta rearrangements *
*---------------------------------------------------------------------*/
/*!
* ptaJoin()
*
* Input: ptad (dest pta; add to this one)
* ptas (source pta; add from this one)
* istart (starting index in ptas)
* iend (ending index in ptas; use 0 to cat all)
* Return: 0 if OK, 1 on error
*
* Notes:
* (1) istart < 0 is taken to mean 'read from the start' (istart = 0)
* (2) iend <= 0 means 'read to the end'
*/
l_int32
ptaJoin(PTA *ptad,
PTA *ptas,
l_int32 istart,
l_int32 iend)
{
l_int32 ns, i, x, y;
PROCNAME("ptaJoin");
if (!ptad)
return ERROR_INT("ptad not defined", procName, 1);
if (!ptas)
return ERROR_INT("ptas not defined", procName, 1);
ns = ptaGetCount(ptas);
if (istart < 0)
istart = 0;
if (istart >= ns)
return ERROR_INT("istart out of bounds", procName, 1);
if (iend <= 0)
iend = ns - 1;
if (iend >= ns)
return ERROR_INT("iend out of bounds", procName, 1);
if (istart > iend)
return ERROR_INT("istart > iend; no pts", procName, 1);
for (i = istart; i <= iend; i++) {
ptaGetIPt(ptas, i, &x, &y);
ptaAddPt(ptad, x, y);
}
return 0;
}
/*!
* ptaReverse()
*
* Input: ptas
* type (0 for float values; 1 for integer values)
* Return: ptad (reversed pta), or null on error
*/
PTA *
ptaReverse(PTA *ptas,
l_int32 type)
{
l_int32 n, i, ix, iy;
l_float32 x, y;
PTA *ptad;
PROCNAME("ptaReverse");
if (!ptas)
return (PTA *)ERROR_PTR("ptas not defined", procName, NULL);
n = ptaGetCount(ptas);
if ((ptad = ptaCreate(n)) == NULL)
return (PTA *)ERROR_PTR("ptad not made", procName, NULL);
for (i = n - 1; i >= 0; i--) {
if (type == 0) {
ptaGetPt(ptas, i, &x, &y);
ptaAddPt(ptad, x, y);
}
else { /* type == 1 */
ptaGetIPt(ptas, i, &ix, &iy);
ptaAddPt(ptad, ix, iy);
}
}
return ptad;
}
/*!
* ptaCyclicPerm()
*
* Input: ptas
* xs, ys (start point; must be in ptas)
* Return: ptad (cyclic permutation, starting and ending at (xs, ys),
* or null on error
*
* Note: we check to insure that ptas is a closed path where
* the first and last points are identical, and the
* resulting pta also starts and ends on the same point
* (which in this case is (xs, ys).
*/
PTA *
ptaCyclicPerm(PTA *ptas,
l_int32 xs,
l_int32 ys)
{
l_int32 n, i, x, y, j, index, state;
l_int32 x1, y1, x2, y2;
PTA *ptad;
PROCNAME("ptaCyclicPerm");
if (!ptas)
return (PTA *)ERROR_PTR("ptas not defined", procName, NULL);
n = ptaGetCount(ptas);
/* verify input data */
ptaGetIPt(ptas, 0, &x1, &y1);
ptaGetIPt(ptas, n - 1, &x2, &y2);
if (x1 != x2 || y1 != y2)
return (PTA *)ERROR_PTR("start and end pts not same", procName, NULL);
state = L_NOT_FOUND;
for (i = 0; i < n; i++) {
ptaGetIPt(ptas, i, &x, &y);
if (x == xs && y == ys) {
state = L_FOUND;
break;
}
}
if (state == L_NOT_FOUND)
return (PTA *)ERROR_PTR("start pt not in ptas", procName, NULL);
if ((ptad = ptaCreate(n)) == NULL)
return (PTA *)ERROR_PTR("ptad not made", procName, NULL);
for (j = 0; j < n - 1; j++) {
if (i + j < n - 1)
index = i + j;
else
index = (i + j + 1) % n;
ptaGetIPt(ptas, index, &x, &y);
ptaAddPt(ptad, x, y);
}
ptaAddPt(ptad, xs, ys);
return ptad;
}
/*!
* ptaSort()
*
* Input: ptas
* sorttype (L_SORT_BY_X, L_SORT_BY_Y)
* sortorder (L_SORT_INCREASING, L_SORT_DECREASING)
* &naindex (<optional return> index of sorted order into
* original array)
* Return: ptad (sorted version of ptas), or null on error
*/
PTA *
ptaSort(PTA *ptas,
l_int32 sorttype,
l_int32 sortorder,
NUMA **pnaindex)
{
l_int32 i, index, n;
l_float32 x, y;
PTA *ptad;
NUMA *na, *naindex;
PROCNAME("ptaSort");
if (!ptas)
return (PTA *)ERROR_PTR("ptas not defined", procName, NULL);
if (sorttype != L_SORT_BY_X && sorttype != L_SORT_BY_Y)
return (PTA *)ERROR_PTR("invalid sort type", procName, NULL);
if (sortorder != L_SORT_INCREASING && sortorder != L_SORT_DECREASING)
return (PTA *)ERROR_PTR("invalid sort order", procName, NULL);
/* Build up numa of specific data */
n = ptaGetCount(ptas);
if ((na = numaCreate(n)) == NULL)
return (PTA *)ERROR_PTR("na not made", procName, NULL);
for (i = 0; i < n; i++) {
ptaGetPt(ptas, i, &x, &y);
if (sorttype == L_SORT_BY_X)
numaAddNumber(na, x);
else
numaAddNumber(na, y);
}
/* Get the sort index for data array */
if ((naindex = numaGetSortIndex(na, sortorder)) == NULL)
return (PTA *)ERROR_PTR("naindex not made", procName, NULL);
/* Build up sorted pta using sort index */
if ((ptad = ptaCreate(n)) == NULL)
return (PTA *)ERROR_PTR("ptad not made", procName, NULL);
for (i = 0; i < n; i++) {
numaGetIValue(naindex, i, &index);
ptaGetPt(ptas, index, &x, &y);
ptaAddPt(ptad, x, y);
}
if (pnaindex)
*pnaindex = naindex;
else
numaDestroy(&naindex);
numaDestroy(&na);
return ptad;
}
/*!
* ptaRemoveDuplicates()
*
* Input: ptas (assumed to be integer values)
* factor (should be larger than the largest point value;
* use 0 for default)
* Return: ptad (with duplicates removed), or null on error
*/
PTA *
ptaRemoveDuplicates(PTA *ptas,
l_uint32 factor)
{
l_int32 nsize, i, j, k, index, n, nvals;
l_int32 x, y, xk, yk;
l_int32 *ia;
PTA *ptad;
NUMA *na;
NUMAHASH *nahash;
PROCNAME("ptaRemoveDuplicates");
if (!ptas)
return (PTA *)ERROR_PTR("ptas not defined", procName, NULL);
if (factor == 0)
factor = DEFAULT_SPREADING_FACTOR;
/* Build up numaHash of indices, hashed by a key that is
* a large linear combination of x and y values designed to
* randomize the key. */
nsize = 5507; /* buckets in hash table; prime */
nahash = numaHashCreate(nsize, 2);
n = ptaGetCount(ptas);
for (i = 0; i < n; i++) {
ptaGetIPt(ptas, i, &x, &y);
numaHashAdd(nahash, factor * x + y, (l_float32)i);
}
if ((ptad = ptaCreate(n)) == NULL)
return (PTA *)ERROR_PTR("ptad not made", procName, NULL);
for (i = 0; i < nsize; i++) {
na = numaHashGetNuma(nahash, i);
if (!na) continue;
nvals = numaGetCount(na);
/* If more than 1 pt, compare exhaustively with double loop;
* otherwise, just enter it. */
if (nvals > 1) {
if ((ia = (l_int32 *)CALLOC(nvals, sizeof(l_int32))) == NULL)
return (PTA *)ERROR_PTR("ia not made", procName, NULL);
for (j = 0; j < nvals; j++) {
if (ia[j] == 1) continue;
numaGetIValue(na, j, &index);
ptaGetIPt(ptas, index, &x, &y);
ptaAddPt(ptad, x, y);
for (k = j + 1; k < nvals; k++) {
if (ia[k] == 1) continue;
numaGetIValue(na, k, &index);
ptaGetIPt(ptas, index, &xk, &yk);
if (x == xk && y == yk) /* duplicate */
ia[k] = 1;
}
}
FREE(ia);
}
else {
numaGetIValue(na, 0, &index);
ptaGetIPt(ptas, index, &x, &y);
ptaAddPt(ptad, x, y);
}
numaDestroy(&na); /* the clone */
}
numaHashDestroy(&nahash);
return ptad;
}
/*---------------------------------------------------------------------*
* Pta accessors *
*---------------------------------------------------------------------*/
l_int32
ptaGetRefcount(PTA *pta)
{
PROCNAME("ptaGetRefcount");
if (!pta)
return ERROR_INT("pta not defined", procName, 1);
return pta->refcount;
}
l_int32
ptaChangeRefcount(PTA *pta,
l_int32 delta)
{
PROCNAME("ptaChangeRefcount");
if (!pta)
return ERROR_INT("pta not defined", procName, 1);
pta->refcount += delta;
return 0;
}
/*!
* ptaGetCount()
*
* Input: pta
* Return: count, or 0 if no pta
*/
l_int32
ptaGetCount(PTA *pta)
{
PROCNAME("ptaGetCount");
if (!pta)
return ERROR_INT("pta not defined", procName, 0);
return pta->n;
}
/*!
* ptaGetPt()
*
* Input: pta
* index (into arrays)
* &x, &y (<return> float values)
* Return: 0 if OK; 1 on error
*/
l_int32
ptaGetPt(PTA *pta,
l_int32 index,
l_float32 *px,
l_float32 *py)
{
PROCNAME("ptaGetPt");
if (!pta)
return ERROR_INT("pta not defined", procName, 1);
*px = pta->x[index];
*py = pta->y[index];
return 0;
}
/*!
* ptaGetIPt()
*
* Input: pta
* index (into arrays)
* &x, &y (<return> integer values)
* Return: 0 if OK; 1 on error
*/
l_int32
ptaGetIPt(PTA *pta,
l_int32 index,
l_int32 *px,
l_int32 *py)
{
PROCNAME("ptaGetIPt");
if (!pta)
return ERROR_INT("pta not defined", procName, 1);
*px = (l_int32)(pta->x[index] + 0.5);
*py = (l_int32)(pta->y[index] + 0.5);
return 0;
}
/*!
* ptaGetArrays()
*
* Input: pta
* &nax, &nay (<return> numas of x and y arrays)
* Return: 0 if OK; 1 on error or if pta is empty
*
* Notes:
* (1) This copies the internal arrays into new Numas, and returns them.
* (2) Manipulates internal arrays in pta and numa directly.
*/
l_int32
ptaGetArrays(PTA *pta,
NUMA **pnax,
NUMA **pnay)
{
l_int32 i, n;
NUMA *nax, *nay;
PROCNAME("ptaGetArrays");
if (!pta)
return ERROR_INT("pta not defined", procName, 1);
if (!pnax)
return ERROR_INT("&nax not defined", procName, 1);
if (!pnay)
return ERROR_INT("&nay not defined", procName, 1);
*pnax = *pnay = NULL;
if ((n = ptaGetCount(pta)) == 0)
return ERROR_INT("pta is empty", procName, 1);
if ((nax = numaCreate(n)) == NULL)
return ERROR_INT("nax not made", procName, 1);
*pnax = nax;
if ((nay = numaCreate(n)) == NULL)
return ERROR_INT("nay not made", procName, 1);
*pnay = nay;
/* use arrays directly for efficiency */
for (i = 0; i < n; i++) {
nax->array[i] = pta->x[i];
nay->array[i] = pta->y[i];
}
nax->n = nay->n = n;
return 0;
}
/*---------------------------------------------------------------------*
* PTAA creation, destruction *
*---------------------------------------------------------------------*/
/*!
* ptaaCreate()
*
* Input: n (initial number of ptrs)
* Return: ptaa, or null on error
*/
PTAA *
ptaaCreate(l_int32 n)
{
PTAA *ptaa;
PROCNAME("ptaaCreate");
if (n <= 0)
n = INITIAL_PTR_ARRAYSIZE;
if ((ptaa = (PTAA *)CALLOC(1, sizeof(PTAA))) == NULL)
return (PTAA *)ERROR_PTR("ptaa not made", procName, NULL);
ptaa->n = 0;
ptaa->nalloc = n;
if ((ptaa->pta = (PTA **)CALLOC(n, sizeof(PTA *))) == NULL)
return (PTAA *)ERROR_PTR("pta ptrs not made", procName, NULL);
return ptaa;
}
/*!
* ptaaDestroy()
*
* Input: &ptaa <to be nulled>
* Return: void
*/
void
ptaaDestroy(PTAA **pptaa)
{
l_int32 i;
PTAA *ptaa;
PROCNAME("ptaaDestroy");
if (pptaa == NULL) {
L_WARNING("ptr address is NULL!", procName);
return;
}
if ((ptaa = *pptaa) == NULL)
return;
for (i = 0; i < ptaa->n; i++)
ptaDestroy(&ptaa->pta[i]);
FREE(ptaa->pta);
FREE(ptaa);
*pptaa = NULL;
return;
}
/*---------------------------------------------------------------------*
* PTAA array extension *
*---------------------------------------------------------------------*/
/*!
* ptaaAddPta()
*
* Input: ptaa
* pta (to be added)
* copyflag (L_INSERT, L_COPY, L_CLONE)
* Return: 0 if OK, 1 on error
*/
l_int32
ptaaAddPta(PTAA *ptaa,
PTA *pta,
l_int32 copyflag)
{
l_int32 n;
PTA *ptac;
PROCNAME("ptaaAddPta");
if (!ptaa)
return ERROR_INT("ptaa not defined", procName, 1);
if (!pta)
return ERROR_INT("pta not defined", procName, 1);
if (copyflag == L_INSERT)
ptac = pta;
else if (copyflag == L_COPY) {
if ((ptac = ptaCopy(pta)) == NULL)
return ERROR_INT("ptac not made", procName, 1);
}
else if (copyflag == L_CLONE) {
if ((ptac = ptaClone(pta)) == NULL)
return ERROR_INT("pta clone not made", procName, 1);
}
else
return ERROR_INT("invalid copyflag", procName, 1);
n = ptaaGetCount(ptaa);
if (n >= ptaa->nalloc)
ptaaExtendArray(ptaa);
ptaa->pta[n] = ptac;
ptaa->n++;
return 0;
}
/*!
* ptaaExtendArray()
*
* Input: ptaa
* Return: 0 if OK, 1 on error
*/
l_int32
ptaaExtendArray(PTAA *ptaa)
{
PROCNAME("ptaaExtendArray");
if (!ptaa)
return ERROR_INT("ptaa not defined", procName, 1);
if ((ptaa->pta = (PTA **)reallocNew((void **)&ptaa->pta,
sizeof(PTA *) * ptaa->nalloc,
2 * sizeof(PTA *) * ptaa->nalloc)) == NULL)
return ERROR_INT("new ptr array not returned", procName, 1);
ptaa->nalloc = 2 * ptaa->nalloc;
return 0;
}
/*---------------------------------------------------------------------*
* Ptaa accessors *
*---------------------------------------------------------------------*/
/*!
* ptaaGetCount()
*
* Input: ptaa
* Return: count, or 0 if no ptaa
*/
l_int32
ptaaGetCount(PTAA *ptaa)
{
PROCNAME("ptaaGetCount");
if (!ptaa)
return ERROR_INT("ptaa not defined", procName, 0);
return ptaa->n;
}
/*!
* ptaaGetPta()
*
* Input: ptaa
* index (to the i-th pta)
* accessflag (L_COPY or L_CLONE)
* Return: pta, or null on error
*/
PTA *
ptaaGetPta(PTAA *ptaa,
l_int32 index,
l_int32 accessflag)
{
PROCNAME("ptaaGetPta");
if (!ptaa)
return (PTA *)ERROR_PTR("ptaa not defined", procName, NULL);
if (index < 0 || index >= ptaa->n)
return (PTA *)ERROR_PTR("index not valid", procName, NULL);
if (accessflag == L_COPY)
return ptaCopy(ptaa->pta[index]);
else if (accessflag == L_CLONE)
return ptaClone(ptaa->pta[index]);
else
return (PTA *)ERROR_PTR("invalid accessflag", procName, NULL);
}
/*---------------------------------------------------------------------*
* Ptaa serialized I/O *
*---------------------------------------------------------------------*/
/*!
* ptaaRead()
*
* Input: filename
* Return: ptaa, or null on error
*/
PTAA *
ptaaRead(const char *filename)
{
FILE *fp;
PTAA *ptaa;
PROCNAME("ptaaRead");
if (!filename)
return (PTAA *)ERROR_PTR("filename not defined", procName, NULL);
if ((fp = fopenReadStream(filename)) == NULL)
return (PTAA *)ERROR_PTR("stream not opened", procName, NULL);
if ((ptaa = ptaaReadStream(fp)) == NULL) {
fclose(fp);
return (PTAA *)ERROR_PTR("ptaa not read", procName, NULL);
}
fclose(fp);
return ptaa;
}
/*!
* ptaaReadStream()
*
* Input: stream
* Return: ptaa, or null on error
*/
PTAA *
ptaaReadStream(FILE *fp)
{
l_int32 i, n, version;
PTA *pta;
PTAA *ptaa;
PROCNAME("ptaaReadStream");
if (!fp)
return (PTAA *)ERROR_PTR("stream not defined", procName, NULL);
if (fscanf(fp, "\nPtaa Version %d\n", &version) != 1)
return (PTAA *)ERROR_PTR("not a ptaa file", procName, NULL);
if (version != PTA_VERSION_NUMBER)
return (PTAA *)ERROR_PTR("invalid ptaa version", procName, NULL);
if (fscanf(fp, "Number of Pta = %d\n", &n) != 1)
return (PTAA *)ERROR_PTR("not a ptaa file", procName, NULL);
if ((ptaa = ptaaCreate(n)) == NULL)
return (PTAA *)ERROR_PTR("ptaa not made", procName, NULL);
for (i = 0; i < n; i++) {
if ((pta = ptaReadStream(fp)) == NULL)
return (PTAA *)ERROR_PTR("error reading pta", procName, NULL);
ptaaAddPta(ptaa, pta, L_INSERT);
}
return ptaa;
}
/*!
* ptaaWrite()
*
* Input: filename
* ptaa
* type (0 for float values; 1 for integer values)
* Return: 0 if OK, 1 on error
*/
l_int32
ptaaWrite(const char *filename,
PTAA *ptaa,
l_int32 type)
{
FILE *fp;
PROCNAME("ptaaWrite");
if (!filename)
return ERROR_INT("filename not defined", procName, 1);
if (!ptaa)
return ERROR_INT("ptaa not defined", procName, 1);
if ((fp = fopen(filename, "w")) == NULL)
return ERROR_INT("stream not opened", procName, 1);
if (ptaaWriteStream(fp, ptaa, type))
return ERROR_INT("ptaa not written to stream", procName, 1);
fclose(fp);
return 0;
}
/*!
* ptaaWriteStream()
*
* Input: stream
* ptaa
* type (0 for float values; 1 for integer values)
* Return: 0 if OK; 1 on error
*/
l_int32
ptaaWriteStream(FILE *fp,
PTAA *ptaa,
l_int32 type)
{
l_int32 i, n;
PTA *pta;
PROCNAME("ptaaWriteStream");
if (!fp)
return ERROR_INT("stream not defined", procName, 1);
if (!ptaa)
return ERROR_INT("ptaa not defined", procName, 1);
n = ptaaGetCount(ptaa);
fprintf(fp, "\nPtaa Version %d\n", PTA_VERSION_NUMBER);
fprintf(fp, "Number of Pta = %d\n", n);
for (i = 0; i < n; i++) {
pta = ptaaGetPta(ptaa, i, L_CLONE);
ptaWriteStream(fp, pta, type);
ptaDestroy(&pta);
}
return 0;
}
/*---------------------------------------------------------------------*
* Pta serialized I/O *
*---------------------------------------------------------------------*/
/*!
* ptaRead()
*
* Input: filename
* Return: pta, or null on error
*/
PTA *
ptaRead(const char *filename)
{
FILE *fp;
PTA *pta;
PROCNAME("ptaRead");
if (!filename)
return (PTA *)ERROR_PTR("filename not defined", procName, NULL);
if ((fp = fopenReadStream(filename)) == NULL)
return (PTA *)ERROR_PTR("stream not opened", procName, NULL);
if ((pta = ptaReadStream(fp)) == NULL) {
fclose(fp);
return (PTA *)ERROR_PTR("pta not read", procName, NULL);
}
fclose(fp);
return pta;
}
/*!
* ptaReadStream()
*
* Input: stream
* Return: pta, or null on error
*/
PTA *
ptaReadStream(FILE *fp)
{
char typestr[128];
l_int32 i, n, ix, iy, type, version;
l_float32 x, y;
PTA *pta;
PROCNAME("ptaReadStream");
if (!fp)
return (PTA *)ERROR_PTR("stream not defined", procName, NULL);
if (fscanf(fp, "\n Pta Version %d\n", &version) != 1)
return (PTA *)ERROR_PTR("not a pta file", procName, NULL);
if (version != PTA_VERSION_NUMBER)
return (PTA *)ERROR_PTR("invalid pta version", procName, NULL);
if (fscanf(fp, " Number of pts = %d; format = %s\n", &n, typestr) != 2)
return (PTA *)ERROR_PTR("not a pta file", procName, NULL);
if (!strcmp(typestr, "float"))
type = 0;
else /* typestr is "integer" */
type = 1;
if ((pta = ptaCreate(n)) == NULL)
return (PTA *)ERROR_PTR("pta not made", procName, NULL);
for (i = 0; i < n; i++) {
if (type == 0) { /* data is float */
fscanf(fp, " (%f, %f)\n", &x, &y);
ptaAddPt(pta, x, y);
}
else { /* data is integer */
fscanf(fp, " (%d, %d)\n", &ix, &iy);
ptaAddPt(pta, ix, iy);
}
}
return pta;
}
/*!
* ptaWrite()
*
* Input: filename
* pta
* type (0 for float values; 1 for integer values)
* Return: 0 if OK, 1 on error
*/
l_int32
ptaWrite(const char *filename,
PTA *pta,
l_int32 type)
{
FILE *fp;
PROCNAME("ptaWrite");
if (!filename)
return ERROR_INT("filename not defined", procName, 1);
if (!pta)
return ERROR_INT("pta not defined", procName, 1);
if ((fp = fopen(filename, "w")) == NULL)
return ERROR_INT("stream not opened", procName, 1);
if (ptaWriteStream(fp, pta, type))
return ERROR_INT("pta not written to stream", procName, 1);
fclose(fp);
return 0;
}
/*!
* ptaWriteStream()
*
* Input: stream
* pta
* type (0 for float values; 1 for integer values)
* Return: 0 if OK; 1 on error
*/
l_int32
ptaWriteStream(FILE *fp,
PTA *pta,
l_int32 type)
{
l_int32 i, n, ix, iy;
l_float32 x, y;
PROCNAME("ptaWriteStream");
if (!fp)
return ERROR_INT("stream not defined", procName, 1);
if (!pta)
return ERROR_INT("pta not defined", procName, 1);
n = ptaGetCount(pta);
fprintf(fp, "\n Pta Version %d\n", PTA_VERSION_NUMBER);
if (type == 0)
fprintf(fp, " Number of pts = %d; format = float\n", n);
else /* type == 1 */
fprintf(fp, " Number of pts = %d; format = integer\n", n);
for (i = 0; i < n; i++) {
if (type == 0) { /* data is float */
ptaGetPt(pta, i, &x, &y);
fprintf(fp, " (%f, %f)\n", x, y);
}
else { /* data is integer */
ptaGetIPt(pta, i, &ix, &iy);
fprintf(fp, " (%d, %d)\n", ix, iy);
}
}
return 0;
}
/*---------------------------------------------------------------------*
* In use *
*---------------------------------------------------------------------*/
/*!
* ptaGetExtent()
*
* Input: pta
* Return: box, or null on error
*
* Notes:
* (1) Returns a box of minimum size containing pts in pta.
*/
BOX *
ptaGetExtent(PTA *pta)
{
l_int32 n, i, x, y, minx, maxx, miny, maxy;
PROCNAME("ptaGetExtent");
if (!pta)
return (BOX *)ERROR_PTR("pta not defined", procName, NULL);
minx = 10000000;
miny = 10000000;
maxx = -10000000;
maxy = -10000000;
n = ptaGetCount(pta);
for (i = 0; i < n; i++) {
ptaGetIPt(pta, i, &x, &y);
if (x < minx) minx = x;
if (x > maxx) maxx = x;
if (y < miny) miny = y;
if (y > maxy) maxy = y;
}
return boxCreate(minx, miny, maxx - minx + 1, maxy - miny + 1);
}
/*!
* ptaGetInsideBox()
*
* Input: ptas (input pts)
* box
* Return: ptad (of pts in ptas that are inside the box),
* or null on error
*/
PTA *
ptaGetInsideBox(PTA *ptas,
BOX *box)
{
PTA *ptad;
l_int32 n, i, contains;
l_float32 x, y;
PROCNAME("ptaGetInsideBox");
if (!ptas)
return (PTA *)ERROR_PTR("ptas not defined", procName, NULL);
if (!box)
return (PTA *)ERROR_PTR("box not defined", procName, NULL);
n = ptaGetCount(ptas);
ptad = ptaCreate(0);
for (i = 0; i < n; i++) {
ptaGetPt(ptas, i, &x, &y);
boxContainsPt(box, x, y, &contains);
if (contains)
ptaAddPt(ptad, x, y);
}
return ptad;
}
/*!
* pixFindCornerPixels()
*
* Input: pixs (1 bpp)
* Return: pta, or null on error
*
* Notes:
* (1) Finds the 4 corner-most pixels, as defined by a search
* inward from each corner, using a 45 degree line.
*/
PTA *
pixFindCornerPixels(PIX *pixs)
{
l_int32 i, j, x, y, w, h, wpl, mindim, found;
l_uint32 *data, *line;
PTA *pta;
PROCNAME("pixFindCornerPixels");
if (!pixs)
return (PTA *)ERROR_PTR("pixs not defined", procName, NULL);
if (pixGetDepth(pixs) != 1)
return (PTA *)ERROR_PTR("pixs not 1 bpp", procName, NULL);
w = pixGetWidth(pixs);
h = pixGetHeight(pixs);
mindim = L_MIN(w, h);
data = pixGetData(pixs);
wpl = pixGetWpl(pixs);
if ((pta = ptaCreate(4)) == NULL)
return (PTA *)ERROR_PTR("pta not made", procName, NULL);
for (found = FALSE, i = 0; i < mindim; i++) {
for (j = 0; j <= i; j++) {
y = i - j;
line = data + y * wpl;
if (GET_DATA_BIT(line, j)) {
ptaAddPt(pta, j, y);
found = TRUE;
break;
}
}
if (found == TRUE)
break;
}
for (found = FALSE, i = 0; i < mindim; i++) {
for (j = 0; j <= i; j++) {
y = i - j;
line = data + y * wpl;
x = w - 1 - j;
if (GET_DATA_BIT(line, x)) {
ptaAddPt(pta, x, y);
found = TRUE;
break;
}
}
if (found == TRUE)
break;
}
for (found = FALSE, i = 0; i < mindim; i++) {
for (j = 0; j <= i; j++) {
y = h - 1 - i + j;
line = data + y * wpl;
if (GET_DATA_BIT(line, j)) {
ptaAddPt(pta, j, y);
found = TRUE;
break;
}
}
if (found == TRUE)
break;
}
for (found = FALSE, i = 0; i < mindim; i++) {
for (j = 0; j <= i; j++) {
y = h - 1 - i + j;
line = data + y * wpl;
x = w - 1 - j;
if (GET_DATA_BIT(line, x)) {
ptaAddPt(pta, x, y);
found = TRUE;
break;
}
}
if (found == TRUE)
break;
}
return pta;
}
/*!
* pixPlotAlongPta()
*
* Input: pixs (any depth)
* pta (set of points on which to plot)
* outformat (GPLOT_PNG, GPLOT_PS, GPLOT_EPS, GPLOT_X11,
* GPLOT_LATEX)
* title (<optional> for plot; can be null)
* Return: 0 if OK, 1 on error
*
* Notes:
* (1) We remove any existing colormap and clip the pta to the input pixs.
* (2) This is a debugging function, and does not remove temporary
* plotting files that it generates.
* (3) If the image is RGB, three separate plots are generated.
*/
l_int32
pixPlotAlongPta(PIX *pixs,
PTA *pta,
l_int32 outformat,
const char *title)
{
char buffer[128];
char *rtitle, *gtitle, *btitle;
static l_int32 count = 0; /* require separate temp files for each call */
l_int32 i, x, y, d, w, h, npts, rval, gval, bval;
l_uint32 val;
NUMA *na, *nar, *nag, *nab;
PIX *pixt;
PROCNAME("pixPlotAlongLine");
if (!pixs)
return ERROR_INT("pixs not defined", procName, 1);
if (!pta)
return ERROR_INT("pta not defined", procName, 1);
if (outformat != GPLOT_PNG && outformat != GPLOT_PS &&
outformat != GPLOT_EPS && outformat != GPLOT_X11 &&
outformat != GPLOT_LATEX) {
L_WARNING("outformat invalid; using GPLOT_PNG", procName);
outformat = GPLOT_PNG;
}
pixt = pixRemoveColormap(pixs, REMOVE_CMAP_BASED_ON_SRC);
d = pixGetDepth(pixt);
w = pixGetWidth(pixt);
h = pixGetHeight(pixt);
npts = ptaGetCount(pta);
if (d == 32) {
nar = numaCreate(npts);
nag = numaCreate(npts);
nab = numaCreate(npts);
for (i = 0; i < npts; i++) {
ptaGetIPt(pta, i, &x, &y);
if (x < 0 || x >= w)
continue;
if (y < 0 || y >= h)
continue;
pixGetPixel(pixt, x, y, &val);
rval = GET_DATA_BYTE(&val, COLOR_RED);
gval = GET_DATA_BYTE(&val, COLOR_GREEN);
bval = GET_DATA_BYTE(&val, COLOR_BLUE);
numaAddNumber(nar, rval);
numaAddNumber(nag, gval);
numaAddNumber(nab, bval);
}
sprintf(buffer, "junkplot.%d", count++);
rtitle = stringJoin("Red: ", title);
gplotSimple1(nar, outformat, buffer, rtitle);
sprintf(buffer, "junkplot.%d", count++);
gtitle = stringJoin("Green: ", title);
gplotSimple1(nag, outformat, buffer, gtitle);
sprintf(buffer, "junkplot.%d", count++);
btitle = stringJoin("Blue: ", title);
gplotSimple1(nab, outformat, buffer, btitle);
numaDestroy(&nar);
numaDestroy(&nag);
numaDestroy(&nab);
FREE(rtitle);
FREE(gtitle);
FREE(btitle);
}
else {
na = numaCreate(npts);
for (i = 0; i < npts; i++) {
ptaGetIPt(pta, i, &x, &y);
if (x < 0 || x >= w)
continue;
if (y < 0 || y >= h)
continue;
pixGetPixel(pixt, x, y, &val);
numaAddNumber(na, (l_float32)val);
}
sprintf(buffer, "junkplot.%d", count++);
gplotSimple1(na, outformat, buffer, title);
numaDestroy(&na);
}
pixDestroy(&pixt);
return 0;
}
/*!
* ptaContainsPt()
*
* Input: pta
* x, y (point)
* Return: 1 if contained, 0 otherwise or on error
*/
l_int32
ptaContainsPt(PTA *pta,
l_int32 x,
l_int32 y)
{
l_int32 i, n, ix, iy;
PROCNAME("ptaContainsPt");
if (!pta)
return ERROR_INT("pta not defined", procName, 0);
n = ptaGetCount(pta);
for (i = 0; i < n; i++) {
ptaGetIPt(pta, i, &ix, &iy);
if (x == ix && y == iy)
return 1;
}
return 0;
}
/*!
* ptaTestIntersection()
*
* Input: pta1, pta2
* Return: bval which is 1 if they have any elements in common;
* 0 otherwise or on error.
*/
l_int32
ptaTestIntersection(PTA *pta1,
PTA *pta2)
{
l_int32 i, j, n1, n2, x1, y1, x2, y2;
PROCNAME("ptaTestIntersection");
if (!pta1)
return ERROR_INT("pta1 not defined", procName, 0);
if (!pta2)
return ERROR_INT("pta2 not defined", procName, 0);
n1 = ptaGetCount(pta1);
n2 = ptaGetCount(pta2);
for (i = 0; i < n1; i++) {
ptaGetIPt(pta1, i, &x1, &y1);
for (j = 0; j < n2; j++) {
ptaGetIPt(pta2, i, &x2, &y2);
if (x1 == x2 && y1 == y2)
return 1;
}
}
return 0;
}
/*!
* ptaTransform()
*
* Input: pta
* shiftx, shifty
* scalex, scaley
* Return: pta, or null on error
*
* Notes:
* (1) Shift first, then scale.
*/
PTA *
ptaTransform(PTA *ptas,
l_int32 shiftx,
l_int32 shifty,
l_float32 scalex,
l_float32 scaley)
{
l_int32 n, i, x, y;
PTA *ptad;
PROCNAME("ptaTransform");
if (!ptas)
return (PTA *)ERROR_PTR("ptas not defined", procName, NULL);
n = ptaGetCount(ptas);
ptad = ptaCreate(n);
for (i = 0; i < n; i++) {
ptaGetIPt(ptas, i, &x, &y);
x = (l_int32)(scalex * (x + shiftx) + 0.5);
y = (l_int32)(scaley * (y + shifty) + 0.5);
ptaAddPt(ptad, x, y);
}
return ptad;
}
/*!
* ptaSubsample()
*
* Input: ptas
* subfactor (subsample factor, >= 1)
* Return: ptad (evenly sampled pt values from ptas, or null on error
*/
PTA *
ptaSubsample(PTA *ptas,
l_int32 subfactor)
{
l_int32 n, i;
l_float32 x, y;
PTA *ptad;
PROCNAME("pixSubsample");
if (!ptas)
return (PTA *)ERROR_PTR("ptas not defined", procName, NULL);
if (subfactor < 1)
return (PTA *)ERROR_PTR("subfactor < 1", procName, NULL);
ptad = ptaCreate(0);
n = ptaGetCount(ptas);
for (i = 0; i < n; i++) {
if (i % subfactor != 0) continue;
ptaGetPt(ptas, i, &x, &y);
ptaAddPt(ptad, x, y);
}
return ptad;
}
/*!
* ptaGetLinearLSF()
*
* Input: pta
* &a (<optional return> slope a of least square fit: y = ax + b)
* &b (<optional return> intercept b of least square fit)
* &nafit (<optional return> numa of least square fit)
* Return: 0 if OK, 1 on error
*
* Notes:
* (1) At least one of: &a and &b must not be null.
* (2) If both &a and &b are defined, this returns a and b that minimize:
*
* sum (yi - axi -b)^2
* i
*
* The method is simple: differentiate this expression w/rt a and b,
* and solve the resulting two equations for a and b in terms of
* various sums over the input data (xi, yi).
* (3) We also allow two special cases, where either a = 0 or b = 0:
* (a) If &a is given and &b = null, find the linear LSF that
* goes through the origin (b = 0).
* (b) If &b is given and &a = null, find the linear LSF with
* zero slope (a = 0).
* (4) If @nafit is defined, this returns an array of fitted values,
* corresponding to the two implicit Numa arrays (nax and nay) in pta.
* Thus, just as you can plot the data in pta as nay vs. nax,
* you can plot the linear least square fit as nafit vs. nax.
*/
l_int32
ptaGetLinearLSF(PTA *pta,
l_float32 *pa,
l_float32 *pb,
NUMA **pnafit)
{
l_int32 n, i;
l_float32 factor, sx, sy, sxx, sxy, val;
l_float32 *xa, *ya;
PROCNAME("ptaGetLinearLSF");
if (!pta)
return ERROR_INT("pta not defined", procName, 1);
if (!pa && !pb)
return ERROR_INT("&a and/or &b not defined", procName, 1);
if (pa) *pa = 0.0;
if (pb) *pb = 0.0;
if ((n = ptaGetCount(pta)) < 2)
return ERROR_INT("less than 2 pts not found", procName, 1);
xa = pta->x; /* not a copy */
ya = pta->y; /* not a copy */
sx = sy = sxx = sxy = 0.;
if (pa && pb) {
for (i = 0; i < n; i++) {
sx += xa[i];
sy += ya[i];
sxx += xa[i] * xa[i];
sxy += xa[i] * ya[i];
}
factor = n * sxx - sx * sx;
if (factor == 0.0)
return ERROR_INT("no solution found", procName, 1);
factor = 1. / factor;
*pa = factor * ((l_float32)n * sxy - sx * sy);
*pb = factor * (sxx * sy - sx * sxy);
}
else if (pa) { /* line through origin */
for (i = 0; i < n; i++) {
sxx += xa[i] * xa[i];
sxy += xa[i] * ya[i];
}
if (sxx == 0.0)
return ERROR_INT("no solution found", procName, 1);
*pa = sxy / sxx;
}
else { /* a = 0; horizontal line */
for (i = 0; i < n; i++)
sy += ya[i];
*pb = sy / (l_float32)n;
}
if (pnafit) {
*pnafit = numaCreate(n);
for (i = 0; i < n; i++) {
val = (*pa) * xa[i] + *pb;
numaAddNumber(*pnafit, val);
}
}
return 0;
}
/*!
* ptaGetPixelsFromPix()
*
* Input: pixs (1 bpp)
* box (<optional> can be null)
* Return: pta, or null on error
*
* Notes:
* (1) Generates a pta of fg pixels in the pix, within the box.
* If box == NULL, it uses the entire pix.
*/
PTA *
ptaGetPixelsFromPix(PIX *pixs,
BOX *box)
{
l_int32 i, j, w, h, wpl, xstart, xend, ystart, yend, bw, bh;
l_uint32 *data, *line;
PTA *pta;
PROCNAME("ptaGetPixelsFromPix");
if (!pixs || (pixGetDepth(pixs) != 1))
return (PTA *)ERROR_PTR("pixs undefined or not 1 bpp", procName, NULL);
pixGetDimensions(pixs, &w, &h, NULL);
data = pixGetData(pixs);
wpl = pixGetWpl(pixs);
xstart = ystart = 0;
xend = w - 1;
yend = h - 1;
if (box) {
boxGetGeometry(box, &xstart, &ystart, &bw, &bh);
xend = xstart + bw - 1;
yend = ystart + bh - 1;
}
if ((pta = ptaCreate(0)) == NULL)
return (PTA *)ERROR_PTR("pta not made", procName, NULL);
for (i = ystart; i <= yend; i++) {
line = data + i * wpl;
for (j = xstart; j <= xend; j++) {
if (GET_DATA_BIT(line, j))
ptaAddPt(pta, j, i);
}
}
return pta;
}
/*!
* pixGenerateFromPta()
*
* Input: pta
* w, h (of pix)
* Return: pix (1 bpp), or null on error
*
* Notes:
* (1) Points are rounded to nearest ints.
* (2) Any points outside (w,h) are silently discarded.
* (3) Output 1 bpp pix has values 1 for each point in the pta.
*/
PIX *
pixGenerateFromPta(PTA *pta,
l_int32 w,
l_int32 h)
{
l_int32 n, i, x, y;
PIX *pix;
PROCNAME("pixGenerateFromPta");
if (!pta)
return (PIX *)ERROR_PTR("pta not defined", procName, NULL);
if ((pix = pixCreate(w, h, 1)) == NULL)
return (PIX *)ERROR_PTR("pix not made", procName, NULL);
n = ptaGetCount(pta);
for (i = 0; i < n; i++) {
ptaGetIPt(pta, i, &x, &y);
if (x < 0 || x >= w || y < 0 || y >= h)
continue;
pixSetPixel(pix, x, y, 1);
}
return pix;
}
/*!
* ptaGetBoundaryPixels()
*
* Input: pixs (1 bpp)
* type (L_BOUNDARY_FG, L_BOUNDARY_BG)
* Return: pta, or null on error
*
* Notes:
* (1) This generates a pta of either fg or bg boundary pixels.
*/
PTA *
ptaGetBoundaryPixels(PIX *pixs,
l_int32 type)
{
PIX *pixt;
PTA *pta;
PROCNAME("ptaGetBoundaryPixels");
if (!pixs || (pixGetDepth(pixs) != 1))
return (PTA *)ERROR_PTR("pixs undefined or not 1 bpp", procName, NULL);
if (type != L_BOUNDARY_FG && type != L_BOUNDARY_BG)
return (PTA *)ERROR_PTR("invalid type", procName, NULL);
if (type == L_BOUNDARY_FG)
pixt = pixMorphSequence(pixs, "e3.3", 0);
else
pixt = pixMorphSequence(pixs, "d3.3", 0);
pixXor(pixt, pixt, pixs);
pta = ptaGetPixelsFromPix(pixt, NULL);
pixDestroy(&pixt);
return pta;
}
/*!
* ptaaGetBoundaryPixels()
*
* Input: pixs (1 bpp)
* type (L_BOUNDARY_FG, L_BOUNDARY_BG)
* connectivity (4 or 8)
* &boxa (<optional return> bounding boxes of the c.c.)
* &pixa (<optional return> pixa of the c.c.)
* Return: ptaa, or null on error
*
* Notes:
* (1) This generates a ptaa of either fg or bg boundary pixels,
* where each pta has the boundary pixels for a connected
* component.
* (2) We can't simply find all the boundary pixels and then select
* those within the bounding box of each component, because
* bounding boxes can overlap. It is necessary to extract and
* dilate or erode each component separately. Note also that
* special handling is required for bg pixels when the
* component touches the pix boundary.
*/
PTAA *
ptaaGetBoundaryPixels(PIX *pixs,
l_int32 type,
l_int32 connectivity,
BOXA **pboxa,
PIXA **ppixa)
{
l_int32 i, n, w, h, x, y, bw, bh, left, right, top, bot;
BOXA *boxa;
PIX *pixt1, *pixt2;
PIXA *pixa;
PTA *pta1, *pta2;
PTAA *ptaa;
PROCNAME("ptaaGetBoundaryPixels");
if (pboxa) *pboxa = NULL;
if (ppixa) *ppixa = NULL;
if (!pixs || (pixGetDepth(pixs) != 1))
return (PTAA *)ERROR_PTR("pixs undefined or not 1 bpp", procName, NULL);
if (type != L_BOUNDARY_FG && type != L_BOUNDARY_BG)
return (PTAA *)ERROR_PTR("invalid type", procName, NULL);
if (connectivity != 4 && connectivity != 8)
return (PTAA *)ERROR_PTR("connectivity not 4 or 8", procName, NULL);
pixGetDimensions(pixs, &w, &h, NULL);
boxa = pixConnComp(pixs, &pixa, connectivity);
n = boxaGetCount(boxa);
ptaa = ptaaCreate(0);
for (i = 0; i < n; i++) {
pixt1 = pixaGetPix(pixa, i, L_CLONE);
boxaGetBoxGeometry(boxa, i, &x, &y, &bw, &bh);
left = right = top = bot = 0;
if (type == L_BOUNDARY_BG) {
if (x > 0) left = 1;
if (y > 0) top = 1;
if (x + bw < w) right = 1;
if (y + bh < h) bot = 1;
pixt2 = pixAddBorderGeneral(pixt1, left, right, top, bot, 0);
}
else
pixt2 = pixClone(pixt1);
pta1 = ptaGetBoundaryPixels(pixt2, type);
pta2 = ptaTransform(pta1, x - left, y - top, 1.0, 1.0);
ptaaAddPta(ptaa, pta2, L_INSERT);
ptaDestroy(&pta1);
pixDestroy(&pixt1);
pixDestroy(&pixt2);
}
if (pboxa)
*pboxa = boxa;
else
boxaDestroy(&boxa);
if (ppixa)
*ppixa = pixa;
else
pixaDestroy(&pixa);
return ptaa;
}