/*!
* lqueueDestroy()
*
* Input: &lqueue (<to be nulled>)
* freeflag (TRUE to free each remaining struct in the array)
* Return: void
*
* Notes:
* (1) If freeflag is TRUE, frees each struct in the array.
* (2) If freeflag is FALSE but there are elements on the array,
* gives a warning and destroys the array. This will
* cause a memory leak of all the items that were on the queue.
* So if the items require their own destroy function, they
* must be destroyed before the queue. The same applies to the
* auxiliary stack, if it is used.
* (3) To destroy the L_Queue, we destroy the ptr array, then
* the lqueue, and then null the contents of the input ptr.
*/
void
lqueueDestroy(L_QUEUE **plq,
l_int32 freeflag)
{
void *item;
L_QUEUE *lq;
PROCNAME("lqueueDestroy");
if (plq == NULL) {
L_WARNING("ptr address is NULL", procName);
return;
}
if ((lq = *plq) == NULL)
return;
if (freeflag) {
while(lq->nelem > 0) {
item = lqueueRemove(lq);
FREE(item);
}
}
else if (lq->nelem > 0)
L_WARNING_INT("memory leak of %d items in lqueue!",
procName, lq->nelem);
if (lq->array)
FREE(lq->array);
if (lq->stack)
lstackDestroy(&lq->stack, freeflag);
FREE(lq);
*plq = NULL;
return;
}
/*!
* lstackDestroy()
*
* Input: &lstack (<to be nulled>)
* freeflag (TRUE to free each remaining struct in the array)
* Return: void
*
* Notes:
* (1) If freeflag is TRUE, frees each struct in the array.
* (2) If freeflag is FALSE but there are elements on the array,
* gives a warning and destroys the array. This will
* cause a memory leak of all the items that were on the lstack.
* So if the items require their own destroy function, they
* must be destroyed before the lstack.
* (3) To destroy the lstack, we destroy the ptr array, then
* the lstack, and then null the contents of the input ptr.
*/
void
lstackDestroy(L_STACK **plstack,
l_int32 freeflag)
{
void *item;
L_STACK *lstack;
PROCNAME("lstackDestroy");
if (plstack == NULL) {
L_WARNING("ptr address is NULL\n", procName);
return;
}
if ((lstack = *plstack) == NULL)
return;
if (freeflag) {
while(lstack->n > 0) {
item = lstackRemove(lstack);
LEPT_FREE(item);
}
} else if (lstack->n > 0) {
L_WARNING("memory leak of %d items in lstack\n", procName, lstack->n);
}
if (lstack->auxstack)
lstackDestroy(&lstack->auxstack, freeflag);
if (lstack->array)
LEPT_FREE(lstack->array);
LEPT_FREE(lstack);
*plstack = NULL;
}
/*!
* \brief pixCountConnComp()
*
* \param[in] pixs 1 bpp
* \param[in] connectivity 4 or 8
* \param[out] pcount
* \return 0 if OK, 1 on error
*
* Notes:
* (1 This is the top-level call for getting the number of
* 4- or 8-connected components in a 1 bpp image.
* 2 It works on a copy of the input pix. The c.c. are located
* in raster order and erased one at a time.
*/
l_int32
pixCountConnComp(PIX *pixs,
l_int32 connectivity,
l_int32 *pcount)
{
l_int32 h, iszero;
l_int32 x, y, xstart, ystart;
PIX *pixt;
L_STACK *stack, *auxstack;
PROCNAME("pixCountConnComp");
if (!pcount)
return ERROR_INT("&count not defined", procName, 1);
*pcount = 0; /* initialize the count to 0 */
if (!pixs || pixGetDepth(pixs) != 1)
return ERROR_INT("pixs not defined or not 1 bpp", procName, 1);
if (connectivity != 4 && connectivity != 8)
return ERROR_INT("connectivity not 4 or 8", procName, 1);
pixt = NULL;
stack = NULL;
pixZero(pixs, &iszero);
if (iszero)
return 0;
if ((pixt = pixCopy(NULL, pixs)) == NULL)
return ERROR_INT("pixt not made", procName, 1);
h = pixGetHeight(pixs);
if ((stack = lstackCreate(h)) == NULL) {
L_ERROR("stack not made\n", procName);
goto cleanup;
}
auxstack = lstackCreate(0);
stack->auxstack = auxstack;
xstart = 0;
ystart = 0;
while (1) {
if (!nextOnPixelInRaster(pixt, xstart, ystart, &x, &y))
break;
pixSeedfill(pixt, stack, x, y, connectivity);
(*pcount)++;
xstart = x;
ystart = y;
}
/* Cleanup, freeing the fillsegs on each stack */
cleanup:
lstackDestroy(&stack, TRUE);
pixDestroy(&pixt);
return 0;
}
/*!
* \brief lstackCreate()
*
* \param[in] nalloc initial ptr array size; use 0 for default
* \return lstack, or NULL on error
*/
L_STACK *
lstackCreate(l_int32 nalloc)
{
L_STACK *lstack;
PROCNAME("lstackCreate");
if (nalloc <= 0)
nalloc = INITIAL_PTR_ARRAYSIZE;
lstack = (L_STACK *)LEPT_CALLOC(1, sizeof(L_STACK));
lstack->array = (void **)LEPT_CALLOC(nalloc, sizeof(void *));
if (!lstack->array) {
lstackDestroy(&lstack, FALSE);
return (L_STACK *)ERROR_PTR("lstack array not made", procName, NULL);
}
lstack->nalloc = nalloc;
lstack->n = 0;
return lstack;
}
/*!
* \brief pixConnCompBB()
*
* \param[in] pixs 1 bpp
* \param[in] connectivity 4 or 8
* \return boxa, or NULL on error
*
* <pre>
* Notes:
* (1) Finds bounding boxes of 4- or 8-connected components
* in a binary image.
* (2) This works on a copy of the input pix. The c.c. are located
* in raster order and erased one at a time. In the process,
* the b.b. is computed and saved.
* </pre>
*/
BOXA *
pixConnCompBB(PIX *pixs,
l_int32 connectivity)
{
l_int32 h, iszero;
l_int32 x, y, xstart, ystart;
PIX *pixt;
BOX *box;
BOXA *boxa;
L_STACK *stack, *auxstack;
PROCNAME("pixConnCompBB");
if (!pixs || pixGetDepth(pixs) != 1)
return (BOXA *)ERROR_PTR("pixs undefined or not 1 bpp", procName, NULL);
if (connectivity != 4 && connectivity != 8)
return (BOXA *)ERROR_PTR("connectivity not 4 or 8", procName, NULL);
boxa = NULL;
pixt = NULL;
stack = NULL;
pixZero(pixs, &iszero);
if (iszero)
return boxaCreate(1); /* return empty boxa */
if ((pixt = pixCopy(NULL, pixs)) == NULL)
return (BOXA *)ERROR_PTR("pixt not made", procName, NULL);
h = pixGetHeight(pixs);
if ((stack = lstackCreate(h)) == NULL) {
L_ERROR("stack not made\n", procName);
goto cleanup;
}
auxstack = lstackCreate(0);
stack->auxstack = auxstack;
boxa = boxaCreate(0);
xstart = 0;
ystart = 0;
while (1) {
if (!nextOnPixelInRaster(pixt, xstart, ystart, &x, &y))
break;
if ((box = pixSeedfillBB(pixt, stack, x, y, connectivity)) == NULL) {
L_ERROR("box not made\n", procName);
boxaDestroy(&boxa);
goto cleanup;
}
boxaAddBox(boxa, box, L_INSERT);
xstart = x;
ystart = y;
}
#if DEBUG
pixCountPixels(pixt, &iszero, NULL);
fprintf(stderr, "Number of remaining pixels = %d\n", iszero);
pixWrite("junkremain", pixt1, IFF_PNG);
#endif /* DEBUG */
/* Cleanup, freeing the fillsegs on each stack */
cleanup:
lstackDestroy(&stack, TRUE);
pixDestroy(&pixt);
return boxa;
}
/*!
* \brief pixConnCompPixa()
*
* \param[in] pixs 1 bpp
* \param[out] ppixa pixa of each c.c.
* \param[in] connectivity 4 or 8
* \return boxa, or NULL on error
*
* <pre>
* Notes:
* (1) This finds bounding boxes of 4- or 8-connected components
* in a binary image, and saves images of each c.c
* in a pixa array.
* (2) It sets up 2 temporary pix, and for each c.c. that is
* located in raster order, it erases the c.c. from one pix,
* then uses the b.b. to extract the c.c. from the two pix using
* an XOR, and finally erases the c.c. from the second pix.
* (3) A clone of the returned boxa (where all boxes in the array
* are clones) is inserted into the pixa.
* (4) If the input is valid, this always returns a boxa and a pixa.
* If pixs is empty, the boxa and pixa will be empty.
* </pre>
*/
BOXA *
pixConnCompPixa(PIX *pixs,
PIXA **ppixa,
l_int32 connectivity)
{
l_int32 h, iszero;
l_int32 x, y, xstart, ystart;
PIX *pix1, *pix2, *pix3, *pix4;
PIXA *pixa;
BOX *box;
BOXA *boxa;
L_STACK *stack, *auxstack;
PROCNAME("pixConnCompPixa");
if (!ppixa)
return (BOXA *)ERROR_PTR("&pixa not defined", procName, NULL);
*ppixa = NULL;
if (!pixs || pixGetDepth(pixs) != 1)
return (BOXA *)ERROR_PTR("pixs undefined or not 1 bpp", procName, NULL);
if (connectivity != 4 && connectivity != 8)
return (BOXA *)ERROR_PTR("connectivity not 4 or 8", procName, NULL);
boxa = NULL;
pix1 = pix2 = pix3 = pix4 = NULL;
stack = NULL;
pixZero(pixs, &iszero);
if (iszero)
return boxaCreate(1); /* return empty boxa */
pix1 = pixCopy(NULL, pixs);
pix2 = pixCopy(NULL, pixs);
if (!pix1 || !pix2) {
L_ERROR("pix1 or pix2 not made\n", procName);
goto cleanup;
}
h = pixGetHeight(pixs);
if ((stack = lstackCreate(h)) == NULL) {
L_ERROR("stack not made\n", procName);
goto cleanup;
}
auxstack = lstackCreate(0);
stack->auxstack = auxstack;
pixa = pixaCreate(0);
boxa = boxaCreate(0);
xstart = 0;
ystart = 0;
while (1) {
if (!nextOnPixelInRaster(pix1, xstart, ystart, &x, &y))
break;
if ((box = pixSeedfillBB(pix1, stack, x, y, connectivity)) == NULL) {
L_ERROR("box not made\n", procName);
pixaDestroy(&pixa);
boxaDestroy(&boxa);
goto cleanup;
}
boxaAddBox(boxa, box, L_INSERT);
/* Save the c.c. and remove from pix2 as well */
pix3 = pixClipRectangle(pix1, box, NULL);
pix4 = pixClipRectangle(pix2, box, NULL);
pixXor(pix3, pix3, pix4);
pixRasterop(pix2, box->x, box->y, box->w, box->h, PIX_SRC ^ PIX_DST,
pix3, 0, 0);
pixaAddPix(pixa, pix3, L_INSERT);
pixDestroy(&pix4);
xstart = x;
ystart = y;
}
#if DEBUG
pixCountPixels(pix1, &iszero, NULL);
fprintf(stderr, "Number of remaining pixels = %d\n", iszero);
pixWrite("junkremain", pix1, IFF_PNG);
#endif /* DEBUG */
/* Remove old boxa of pixa and replace with a clone copy */
boxaDestroy(&pixa->boxa);
pixa->boxa = boxaCopy(boxa, L_CLONE);
*ppixa = pixa;
/* Cleanup, freeing the fillsegs on each stack */
cleanup:
lstackDestroy(&stack, TRUE);
pixDestroy(&pix1);
pixDestroy(&pix2);
return boxa;
}
/*!
* wshedApply()
*
* Input: wshed (generated from wshedCreate())
* Return: 0 if OK, 1 on error
*
* Iportant note:
* (1) This is buggy. It seems to locate watersheds that are
* duplicates. The watershed extraction after complete fill
* grabs some regions belonging to existing watersheds.
* See prog/watershedtest.c for testing.
*/
l_int32
wshedApply(L_WSHED *wshed) {
char two_new_watersheds[] = "Two new watersheds";
char seed_absorbed_into_seeded_basin[] = "Seed absorbed into seeded basin";
char one_new_watershed_label[] = "One new watershed (label)";
char one_new_watershed_index[] = "One new watershed (index)";
char minima_absorbed_into_seeded_basin[] =
"Minima absorbed into seeded basin";
char minima_absorbed_by_filler_or_another[] =
"Minima absorbed by filler or another";
l_int32 nseeds, nother, nboth, arraysize;
l_int32 i, j, val, x, y, w, h, index, mindepth;
l_int32 imin, imax, jmin, jmax, cindex, clabel, nindex;
l_int32 hindex, hlabel, hmin, hmax, minhindex, maxhindex;
l_int32 *lut;
l_uint32 ulabel, uval;
void **lines8, **linelab32;
NUMA *nalut, *nalevels, *nash, *namh, *nasi;
NUMA **links;
L_HEAP *lh;
PIX *pixmin, *pixsd;
PIXA *pixad;
L_STACK *rstack;
PTA *ptas, *ptao;
PROCNAME("wshedApply");
if (!wshed)
return ERROR_INT("wshed not defined", procName, 1);
/* ------------------------------------------------------------ *
* Initialize priority queue and pixlab with seeds and minima *
* ------------------------------------------------------------ */
lh = lheapCreate(0, L_SORT_INCREASING); /* remove lowest values first */
rstack = lstackCreate(0); /* for reusing the WSPixels */
pixGetDimensions(wshed->pixs, &w, &h, NULL);
lines8 = wshed->lines8; /* wshed owns this */
linelab32 = wshed->linelab32; /* ditto */
/* Identify seed (marker) pixels, 1 for each c.c. in pixm */
pixSelectMinInConnComp(wshed->pixs, wshed->pixm, &ptas, &nash);
pixsd = pixGenerateFromPta(ptas, w, h);
nseeds = ptaGetCount(ptas);
for (i = 0; i < nseeds; i++) {
ptaGetIPt(ptas, i, &x, &y);
uval = GET_DATA_BYTE(lines8[y], x);
pushWSPixel(lh, rstack, (l_int32) uval, x, y, i);
}
wshed->ptas = ptas;
nasi = numaMakeConstant(1, nseeds); /* indicator array */
wshed->nasi = nasi;
wshed->nash = nash;
wshed->nseeds = nseeds;
/* Identify minima that are not seeds. Use these 4 steps:
* (1) Get the local minima, which can have components
* of arbitrary size. This will be a clipping mask.
* (2) Get the image of the actual seeds (pixsd)
* (3) Remove all elements of the clipping mask that have a seed.
* (4) Shrink each of the remaining elements of the minima mask
* to a single pixel. */
pixLocalExtrema(wshed->pixs, 200, 0, &pixmin, NULL);
pixRemoveSeededComponents(pixmin, pixsd, pixmin, 8, 2);
pixSelectMinInConnComp(wshed->pixs, pixmin, &ptao, &namh);
nother = ptaGetCount(ptao);
for (i = 0; i < nother; i++) {
ptaGetIPt(ptao, i, &x, &y);
uval = GET_DATA_BYTE(lines8[y], x);
pushWSPixel(lh, rstack, (l_int32) uval, x, y, nseeds + i);
}
wshed->namh = namh;
/* ------------------------------------------------------------ *
* Initialize merging lookup tables *
* ------------------------------------------------------------ */
/* nalut should always give the current after-merging index.
* links are effectively backpointers: they are numas associated with
* a dest index of all indices in nalut that point to that index. */
mindepth = wshed->mindepth;
nboth = nseeds + nother;
arraysize = 2 * nboth;
wshed->arraysize = arraysize;
nalut = numaMakeSequence(0, 1, arraysize);
lut = numaGetIArray(nalut);
wshed->lut = lut; /* wshed owns this */
links = (NUMA **) CALLOC(arraysize, sizeof(NUMA * ));
wshed->links = links; /* wshed owns this */
nindex = nseeds + nother; /* the next unused index value */
/* ------------------------------------------------------------ *
* Fill the basins, using the priority queue *
* ------------------------------------------------------------ */
pixad = pixaCreate(nseeds);
wshed->pixad = pixad; /* wshed owns this */
nalevels = numaCreate(nseeds);
wshed->nalevels = nalevels; /* wshed owns this */
L_INFO("nseeds = %d, nother = %d\n", procName, nseeds, nother);
while (lheapGetCount(lh) > 0) {
popWSPixel(lh, rstack, &val, &x, &y, &index);
/* fprintf(stderr, "x = %d, y = %d, index = %d\n", x, y, index); */
ulabel = GET_DATA_FOUR_BYTES(linelab32[y], x);
if (ulabel == MAX_LABEL_VALUE)
clabel = ulabel;
else
clabel = lut[ulabel];
cindex = lut[index];
if (clabel == cindex) continue; /* have already seen this one */
if (clabel == MAX_LABEL_VALUE) { /* new one; assign index and try to
* propagate to all neighbors */
SET_DATA_FOUR_BYTES(linelab32[y], x, cindex);
imin = L_MAX(0, y - 1);
imax = L_MIN(h - 1, y + 1);
jmin = L_MAX(0, x - 1);
jmax = L_MIN(w - 1, x + 1);
for (i = imin; i <= imax; i++) {
for (j = jmin; j <= jmax; j++) {
if (i == y && j == x) continue;
uval = GET_DATA_BYTE(lines8[i], j);
pushWSPixel(lh, rstack, (l_int32) uval, j, i, cindex);
}
}
} else { /* pixel is already labeled (differently); must resolve */
/* If both indices are seeds, check if the min height is
* greater than mindepth. If so, we have two new watersheds;
* locate them and assign to both regions a new index
* for further waterfill. If not, absorb the shallower
* watershed into the deeper one and continue filling it. */
pixGetPixel(pixsd, x, y, &uval);
if (clabel < nseeds && cindex < nseeds) {
wshedGetHeight(wshed, val, clabel, &hlabel);
wshedGetHeight(wshed, val, cindex, &hindex);
hmin = L_MIN(hlabel, hindex);
hmax = L_MAX(hlabel, hindex);
if (hmin == hmax) {
hmin = hlabel;
hmax = hindex;
}
if (wshed->debug) {
fprintf(stderr, "clabel,hlabel = %d,%d\n", clabel, hlabel);
fprintf(stderr, "hmin = %d, hmax = %d\n", hmin, hmax);
fprintf(stderr, "cindex,hindex = %d,%d\n", cindex, hindex);
if (hmin < mindepth)
fprintf(stderr, "Too shallow!\n");
}
if (hmin >= mindepth) {
debugWshedMerge(wshed, two_new_watersheds,
x, y, clabel, cindex);
wshedSaveBasin(wshed, cindex, val - 1);
wshedSaveBasin(wshed, clabel, val - 1);
numaSetValue(nasi, cindex, 0);
numaSetValue(nasi, clabel, 0);
if (wshed->debug) fprintf(stderr, "nindex = %d\n", nindex);
debugPrintLUT(lut, nindex, wshed->debug);
mergeLookup(wshed, clabel, nindex);
debugPrintLUT(lut, nindex, wshed->debug);
mergeLookup(wshed, cindex, nindex);
debugPrintLUT(lut, nindex, wshed->debug);
nindex++;
} else /* extraneous seed within seeded basin; absorb */ {
debugWshedMerge(wshed, seed_absorbed_into_seeded_basin,
x, y, clabel, cindex);
}
maxhindex = clabel; /* TODO: is this part of above 'else'? */
minhindex = cindex;
if (hindex > hlabel) {
maxhindex = cindex;
minhindex = clabel;
}
mergeLookup(wshed, minhindex, maxhindex);
} else if (clabel < nseeds && cindex >= nboth) {
/* If one index is a seed and the other is a merge of
* 2 watersheds, generate a single watershed. */
debugWshedMerge(wshed, one_new_watershed_label,
x, y, clabel, cindex);
wshedSaveBasin(wshed, clabel, val - 1);
numaSetValue(nasi, clabel, 0);
mergeLookup(wshed, clabel, cindex);
} else if (cindex < nseeds && clabel >= nboth) {
debugWshedMerge(wshed, one_new_watershed_index,
x, y, clabel, cindex);
wshedSaveBasin(wshed, cindex, val - 1);
numaSetValue(nasi, cindex, 0);
mergeLookup(wshed, cindex, clabel);
} else if (clabel < nseeds) { /* cindex from minima; absorb */
/* If one index is a seed and the other is from a minimum,
* merge the minimum wshed into the seed wshed. */
debugWshedMerge(wshed, minima_absorbed_into_seeded_basin,
x, y, clabel, cindex);
mergeLookup(wshed, cindex, clabel);
} else if (cindex < nseeds) { /* clabel from minima; absorb */
debugWshedMerge(wshed, minima_absorbed_into_seeded_basin,
x, y, clabel, cindex);
mergeLookup(wshed, clabel, cindex);
} else { /* If neither index is a seed, just merge */
debugWshedMerge(wshed, minima_absorbed_by_filler_or_another,
x, y, clabel, cindex);
mergeLookup(wshed, clabel, cindex);
}
}
}
#if 0
/* Use the indicator array to save any watersheds that fill
* to the maximum value. This seems to screw things up! */
for (i = 0; i < nseeds; i++) {
numaGetIValue(nasi, i, &ival);
if (ival == 1) {
wshedSaveBasin(wshed, lut[i], val - 1);
numaSetValue(nasi, i, 0);
}
}
#endif
numaDestroy(&nalut);
pixDestroy(&pixmin);
pixDestroy(&pixsd);
ptaDestroy(&ptao);
lheapDestroy(&lh, TRUE);
lstackDestroy(&rstack, TRUE);
return 0;
}
