/*====================================================================*
- 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.
*====================================================================*/
/*
* graymorph.c
*
* Top-level binary morphological operations
*
* PIX *pixErodeGray()
* PIX *pixDilateGray()
* PIX *pixOpenGray()
* PIX *pixCloseGray()
*
*
* Method: Algorithm by van Herk and Gil and Werman, 1992
*
* Measured speed is about 1 output pixel per 120 PIII clock cycles,
* for a horizontal or vertical erosion or dilation. The
* computation time doubles for opening or closing, or for a
* square SE, as expected, and is independent of the size of the SE.
*/
#include <stdio.h>
#include <stdlib.h>
#include "allheaders.h"
/*-----------------------------------------------------------------*
* Top-level gray morphological operations *
*-----------------------------------------------------------------*/
/*!
* pixErodeGray()
*
* Input: pixs
* hsize (of Sel; must be odd; origin implicitly in center)
* vsize (ditto)
* Return: pixd
*
* Notes:
* (1) Sel is a brick with all elements being hits
* (2) If hsize = vsize = 1, just returns a copy.
*/
PIX *
pixErodeGray(PIX *pixs,
l_int32 hsize,
l_int32 vsize)
{
l_uint8 *buffer, *minarray;
l_int32 w, h, wplb, wplt;
l_int32 leftpix, rightpix, toppix, bottompix, maxsize;
l_uint32 *datab, *datat;
PIX *pixb, *pixt, *pixd;
PROCNAME("pixErodeGray");
if (!pixs)
return (PIX *)ERROR_PTR("pixs not defined", procName, NULL);
if (pixGetDepth(pixs) != 8)
return (PIX *)ERROR_PTR("pixs not 8 bpp", procName, NULL);
if (hsize < 1 || vsize < 1)
return (PIX *)ERROR_PTR("hsize or vsize < 1", procName, NULL);
if ((hsize & 1) == 0 ) {
L_WARNING("horiz sel size must be odd; increasing by 1", procName);
hsize++;
}
if ((vsize & 1) == 0 ) {
L_WARNING("vert sel size must be odd; increasing by 1", procName);
vsize++;
}
if (hsize == 1 && vsize == 1)
return pixCopy(NULL, pixs);
if (vsize == 1) { /* horizontal sel */
leftpix = (hsize + 1) / 2;
rightpix = (3 * hsize + 1) / 2;
toppix = 0;
bottompix = 0;
}
else if (hsize == 1) { /* vertical sel */
leftpix = 0;
rightpix = 0;
toppix = (vsize + 1) / 2;
bottompix = (3 * vsize + 1) / 2;
}
else {
leftpix = (hsize + 1) / 2;
rightpix = (3 * hsize + 1) / 2;
toppix = (vsize + 1) / 2;
bottompix = (3 * vsize + 1) / 2;
}
if ((pixb = pixAddBorderGeneral(pixs,
leftpix, rightpix, toppix, bottompix, 255)) == NULL)
return (PIX *)ERROR_PTR("pixb not made", procName, NULL);
if ((pixt = pixCreateTemplate(pixb)) == NULL)
return (PIX *)ERROR_PTR("pixt not made", procName, NULL);
w = pixGetWidth(pixt);
h = pixGetHeight(pixt);
datab = pixGetData(pixb);
datat = pixGetData(pixt);
wplb = pixGetWpl(pixb);
wplt = pixGetWpl(pixt);
if ((buffer = (l_uint8 *)CALLOC(L_MAX(w, h), sizeof(l_uint8))) == NULL)
return (PIX *)ERROR_PTR("buffer not made", procName, NULL);
maxsize = L_MAX(hsize, vsize);
if ((minarray = (l_uint8 *)CALLOC(2 * maxsize, sizeof(l_uint8))) == NULL)
return (PIX *)ERROR_PTR("minarray not made", procName, NULL);
if (vsize == 1)
erodeGrayLow(datat, w, h, wplt, datab, wplb, hsize, L_HORIZ,
buffer, minarray);
else if (hsize == 1)
erodeGrayLow(datat, w, h, wplt, datab, wplb, vsize, L_VERT,
buffer, minarray);
else {
erodeGrayLow(datat, w, h, wplt, datab, wplb, hsize, L_HORIZ,
buffer, minarray);
pixSetOrClearBorder(pixt, leftpix, rightpix, toppix, bottompix,
PIX_SET);
erodeGrayLow(datab, w, h, wplb, datat, wplt, vsize, L_VERT,
buffer, minarray);
pixDestroy(&pixt);
pixt = pixClone(pixb);
}
if ((pixd = pixRemoveBorderGeneral(pixt,
leftpix, rightpix, toppix, bottompix)) == NULL)
return (PIX *)ERROR_PTR("pixd not made", procName, NULL);
FREE(buffer);
FREE(minarray);
pixDestroy(&pixb);
pixDestroy(&pixt);
return pixd;
}
/*!
* pixDilateGray()
*
* Input: pixs
* hsize (of Sel; must be odd; origin implicitly in center)
* vsize (ditto)
* Return: pixd
*
* Notes:
* (1) Sel is a brick with all elements being hits
* (2) If hsize = vsize = 1, just returns a copy.
*/
PIX *
pixDilateGray(PIX *pixs,
l_int32 hsize,
l_int32 vsize)
{
l_uint8 *buffer, *maxarray;
l_int32 w, h, wplb, wplt;
l_int32 leftpix, rightpix, toppix, bottompix, maxsize;
l_uint32 *datab, *datat;
PIX *pixb, *pixt, *pixd;
PROCNAME("pixDilateGray");
if (!pixs)
return (PIX *)ERROR_PTR("pixs not defined", procName, NULL);
if (pixGetDepth(pixs) != 8)
return (PIX *)ERROR_PTR("pixs not 8 bpp", procName, NULL);
if (hsize < 1 || vsize < 1)
return (PIX *)ERROR_PTR("hsize or vsize < 1", procName, NULL);
if ((hsize & 1) == 0 ) {
L_WARNING("horiz sel size must be odd; increasing by 1", procName);
hsize++;
}
if ((vsize & 1) == 0 ) {
L_WARNING("vert sel size must be odd; increasing by 1", procName);
vsize++;
}
if (hsize == 1 && vsize == 1)
return pixCopy(NULL, pixs);
if (vsize == 1) { /* horizontal sel */
leftpix = (hsize + 1) / 2;
rightpix = (3 * hsize + 1) / 2;
toppix = 0;
bottompix = 0;
}
else if (hsize == 1) { /* vertical sel */
leftpix = 0;
rightpix = 0;
toppix = (vsize + 1) / 2;
bottompix = (3 * vsize + 1) / 2;
}
else {
leftpix = (hsize + 1) / 2;
rightpix = (3 * hsize + 1) / 2;
toppix = (vsize + 1) / 2;
bottompix = (3 * vsize + 1) / 2;
}
if ((pixb = pixAddBorderGeneral(pixs,
leftpix, rightpix, toppix, bottompix, 0)) == NULL)
return (PIX *)ERROR_PTR("pixb not made", procName, NULL);
if ((pixt = pixCreateTemplate(pixb)) == NULL)
return (PIX *)ERROR_PTR("pixt not made", procName, NULL);
w = pixGetWidth(pixt);
h = pixGetHeight(pixt);
datab = pixGetData(pixb);
datat = pixGetData(pixt);
wplb = pixGetWpl(pixb);
wplt = pixGetWpl(pixt);
if ((buffer = (l_uint8 *)CALLOC(L_MAX(w, h), sizeof(l_uint8))) == NULL)
return (PIX *)ERROR_PTR("buffer not made", procName, NULL);
maxsize = L_MAX(hsize, vsize);
if ((maxarray = (l_uint8 *)CALLOC(2 * maxsize, sizeof(l_uint8))) == NULL)
return (PIX *)ERROR_PTR("buffer not made", procName, NULL);
if (vsize == 1)
dilateGrayLow(datat, w, h, wplt, datab, wplb, hsize, L_HORIZ,
buffer, maxarray);
else if (hsize == 1)
dilateGrayLow(datat, w, h, wplt, datab, wplb, vsize, L_VERT,
buffer, maxarray);
else {
dilateGrayLow(datat, w, h, wplt, datab, wplb, hsize, L_HORIZ,
buffer, maxarray);
pixSetOrClearBorder(pixt, leftpix, rightpix, toppix, bottompix,
PIX_CLR);
dilateGrayLow(datab, w, h, wplb, datat, wplt, vsize, L_VERT,
buffer, maxarray);
pixDestroy(&pixt);
pixt = pixClone(pixb);
}
if ((pixd = pixRemoveBorderGeneral(pixt,
leftpix, rightpix, toppix, bottompix)) == NULL)
return (PIX *)ERROR_PTR("pixd not made", procName, NULL);
FREE(buffer);
FREE(maxarray);
pixDestroy(&pixb);
pixDestroy(&pixt);
return pixd;
}
/*!
* pixOpenGray()
*
* Input: pixs
* hsize (of Sel; must be odd; origin implicitly in center)
* vsize (ditto)
* Return: pixd
*
* Notes:
* (1) Sel is a brick with all elements being hits
* (2) If hsize = vsize = 1, just returns a copy.
*/
PIX *
pixOpenGray(PIX *pixs,
l_int32 hsize,
l_int32 vsize)
{
l_uint8 *buffer;
l_uint8 *array; /* used to find either min or max in interval */
l_int32 w, h, wplb, wplt;
l_int32 leftpix, rightpix, toppix, bottompix, maxsize;
l_uint32 *datab, *datat;
PIX *pixb, *pixt, *pixd;
PROCNAME("pixOpenGray");
if (!pixs)
return (PIX *)ERROR_PTR("pixs not defined", procName, NULL);
if (pixGetDepth(pixs) != 8)
return (PIX *)ERROR_PTR("pixs not 8 bpp", procName, NULL);
if (hsize < 1 || vsize < 1)
return (PIX *)ERROR_PTR("hsize or vsize < 1", procName, NULL);
if ((hsize & 1) == 0 ) {
L_WARNING("horiz sel size must be odd; increasing by 1", procName);
hsize++;
}
if ((vsize & 1) == 0 ) {
L_WARNING("vert sel size must be odd; increasing by 1", procName);
vsize++;
}
if (hsize == 1 && vsize == 1)
return pixCopy(NULL, pixs);
if (vsize == 1) { /* horizontal sel */
leftpix = (hsize + 1) / 2;
rightpix = (3 * hsize + 1) / 2;
toppix = 0;
bottompix = 0;
}
else if (hsize == 1) { /* vertical sel */
leftpix = 0;
rightpix = 0;
toppix = (vsize + 1) / 2;
bottompix = (3 * vsize + 1) / 2;
}
else {
leftpix = (hsize + 1) / 2;
rightpix = (3 * hsize + 1) / 2;
toppix = (vsize + 1) / 2;
bottompix = (3 * vsize + 1) / 2;
}
if ((pixb = pixAddBorderGeneral(pixs,
leftpix, rightpix, toppix, bottompix, 255)) == NULL)
return (PIX *)ERROR_PTR("pixb not made", procName, NULL);
if ((pixt = pixCreateTemplate(pixb)) == NULL)
return (PIX *)ERROR_PTR("pixt not made", procName, NULL);
w = pixGetWidth(pixt);
h = pixGetHeight(pixt);
datab = pixGetData(pixb);
datat = pixGetData(pixt);
wplb = pixGetWpl(pixb);
wplt = pixGetWpl(pixt);
if ((buffer = (l_uint8 *)CALLOC(L_MAX(w, h), sizeof(l_uint8))) == NULL)
return (PIX *)ERROR_PTR("buffer not made", procName, NULL);
maxsize = L_MAX(hsize, vsize);
if ((array = (l_uint8 *)CALLOC(2 * maxsize, sizeof(l_uint8))) == NULL)
return (PIX *)ERROR_PTR("array not made", procName, NULL);
if (vsize == 1) {
erodeGrayLow(datat, w, h, wplt, datab, wplb, hsize, L_HORIZ,
buffer, array);
pixSetOrClearBorder(pixt, leftpix, rightpix, toppix, bottompix,
PIX_CLR);
dilateGrayLow(datab, w, h, wplb, datat, wplt, hsize, L_HORIZ,
buffer, array);
}
else if (hsize == 1) {
erodeGrayLow(datat, w, h, wplt, datab, wplb, vsize, L_VERT,
buffer, array);
pixSetOrClearBorder(pixt, leftpix, rightpix, toppix, bottompix,
PIX_CLR);
dilateGrayLow(datab, w, h, wplb, datat, wplt, vsize, L_VERT,
buffer, array);
}
else {
erodeGrayLow(datat, w, h, wplt, datab, wplb, hsize, L_HORIZ,
buffer, array);
pixSetOrClearBorder(pixt, leftpix, rightpix, toppix, bottompix,
PIX_SET);
erodeGrayLow(datab, w, h, wplb, datat, wplt, vsize, L_VERT,
buffer, array);
pixSetOrClearBorder(pixb, leftpix, rightpix, toppix, bottompix,
PIX_CLR);
dilateGrayLow(datat, w, h, wplt, datab, wplb, hsize, L_HORIZ,
buffer, array);
pixSetOrClearBorder(pixt, leftpix, rightpix, toppix, bottompix,
PIX_CLR);
dilateGrayLow(datab, w, h, wplb, datat, wplt, vsize, L_VERT,
buffer, array);
}
if ((pixd = pixRemoveBorderGeneral(pixb,
leftpix, rightpix, toppix, bottompix)) == NULL)
return (PIX *)ERROR_PTR("pixd not made", procName, NULL);
FREE(buffer);
FREE(array);
pixDestroy(&pixb);
pixDestroy(&pixt);
return pixd;
}
/*!
* pixCloseGray()
*
* Input: pixs
* hsize (of Sel; must be odd; origin implicitly in center)
* vsize (ditto)
* Return: pixd
*
* Notes:
* (1) Sel is a brick with all elements being hits
* (2) If hsize = vsize = 1, just returns a copy.
*/
PIX *
pixCloseGray(PIX *pixs,
l_int32 hsize,
l_int32 vsize)
{
l_uint8 *buffer;
l_uint8 *array; /* used to find either min or max in interval */
l_int32 w, h, wplb, wplt;
l_int32 leftpix, rightpix, toppix, bottompix, maxsize;
l_uint32 *datab, *datat;
PIX *pixb, *pixt, *pixd;
PROCNAME("pixCloseGray");
if (!pixs)
return (PIX *)ERROR_PTR("pixs not defined", procName, NULL);
if (pixGetDepth(pixs) != 8)
return (PIX *)ERROR_PTR("pixs not 8 bpp", procName, NULL);
if (hsize < 1 || vsize < 1)
return (PIX *)ERROR_PTR("hsize or vsize < 1", procName, NULL);
if ((hsize & 1) == 0 ) {
L_WARNING("horiz sel size must be odd; increasing by 1", procName);
hsize++;
}
if ((vsize & 1) == 0 ) {
L_WARNING("vert sel size must be odd; increasing by 1", procName);
vsize++;
}
if (hsize == 1 && vsize == 1)
return pixCopy(NULL, pixs);
if (vsize == 1) { /* horizontal sel */
leftpix = (hsize + 1) / 2;
rightpix = (3 * hsize + 1) / 2;
toppix = 0;
bottompix = 0;
}
else if (hsize == 1) { /* vertical sel */
leftpix = 0;
rightpix = 0;
toppix = (vsize + 1) / 2;
bottompix = (3 * vsize + 1) / 2;
}
else {
leftpix = (hsize + 1) / 2;
rightpix = (3 * hsize + 1) / 2;
toppix = (vsize + 1) / 2;
bottompix = (3 * vsize + 1) / 2;
}
if ((pixb = pixAddBorderGeneral(pixs,
leftpix, rightpix, toppix, bottompix, 0)) == NULL)
return (PIX *)ERROR_PTR("pixb not made", procName, NULL);
if ((pixt = pixCreateTemplate(pixb)) == NULL)
return (PIX *)ERROR_PTR("pixt not made", procName, NULL);
w = pixGetWidth(pixt);
h = pixGetHeight(pixt);
datab = pixGetData(pixb);
datat = pixGetData(pixt);
wplb = pixGetWpl(pixb);
wplt = pixGetWpl(pixt);
if ((buffer = (l_uint8 *)CALLOC(L_MAX(w, h), sizeof(l_uint8))) == NULL)
return (PIX *)ERROR_PTR("buffer not made", procName, NULL);
maxsize = L_MAX(hsize, vsize);
if ((array = (l_uint8 *)CALLOC(2 * maxsize, sizeof(l_uint8))) == NULL)
return (PIX *)ERROR_PTR("array not made", procName, NULL);
if (vsize == 1) {
dilateGrayLow(datat, w, h, wplt, datab, wplb, hsize, L_HORIZ,
buffer, array);
pixSetOrClearBorder(pixt, leftpix, rightpix, toppix, bottompix,
PIX_SET);
erodeGrayLow(datab, w, h, wplb, datat, wplt, hsize, L_HORIZ,
buffer, array);
}
else if (hsize == 1) {
dilateGrayLow(datat, w, h, wplt, datab, wplb, vsize, L_VERT,
buffer, array);
pixSetOrClearBorder(pixt, leftpix, rightpix, toppix, bottompix,
PIX_SET);
erodeGrayLow(datab, w, h, wplb, datat, wplt, vsize, L_VERT,
buffer, array);
}
else {
dilateGrayLow(datat, w, h, wplt, datab, wplb, hsize, L_HORIZ,
buffer, array);
pixSetOrClearBorder(pixt, leftpix, rightpix, toppix, bottompix,
PIX_CLR);
dilateGrayLow(datab, w, h, wplb, datat, wplt, vsize, L_VERT,
buffer, array);
pixSetOrClearBorder(pixb, leftpix, rightpix, toppix, bottompix,
PIX_SET);
erodeGrayLow(datat, w, h, wplt, datab, wplb, hsize, L_HORIZ,
buffer, array);
pixSetOrClearBorder(pixt, leftpix, rightpix, toppix, bottompix,
PIX_SET);
erodeGrayLow(datab, w, h, wplb, datat, wplt, vsize, L_VERT,
buffer, array);
}
if ((pixd = pixRemoveBorderGeneral(pixb,
leftpix, rightpix, toppix, bottompix)) == NULL)
return (PIX *)ERROR_PTR("pixd not made", procName, NULL);
FREE(buffer);
FREE(array);
pixDestroy(&pixb);
pixDestroy(&pixt);
return pixd;
}