mirror of
https://github.com/ultimatepp/ultimatepp.git
synced 2026-05-17 14:16:10 -06:00
247 lines
9.4 KiB
C
247 lines
9.4 KiB
C
/*====================================================================*
|
|
- 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.
|
|
*====================================================================*/
|
|
|
|
/*
|
|
* edge.c
|
|
*
|
|
* Sobel edge detecting filter
|
|
* PIX *pixSobelEdgeFilter()
|
|
*
|
|
* Two-sided edge gradient filter
|
|
* PIX *pixTwoSidedEdgeFilter()
|
|
*
|
|
* The Sobel edge detector uses these two simple gradient filters.
|
|
*
|
|
* 1 2 1 1 0 -1
|
|
* 0 0 0 2 0 -2
|
|
* -1 -2 -1 1 0 -1
|
|
*
|
|
* (horizontal) (vertical)
|
|
*
|
|
* To use both the vertical and horizontal filters, set the orientation
|
|
* flag to L_ALL_EDGES; this sums the abs. value of their outputs,
|
|
* clipped to 255.
|
|
*
|
|
* See comments below for displaying the resulting image with
|
|
* the edges dark, both for 8 bpp and 1 bpp.
|
|
*/
|
|
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include "allheaders.h"
|
|
|
|
|
|
/*----------------------------------------------------------------------*
|
|
* Sobel edge detecting filter *
|
|
*----------------------------------------------------------------------*/
|
|
/*!
|
|
* pixSobelEdgeFilter()
|
|
*
|
|
* Input: pixs (8 bpp; no colormap)
|
|
* orientflag (L_HORIZONTAL_EDGES, L_VERTICAL_EDGES, L_ALL_EDGES)
|
|
* Return: pixd (8 bpp, edges are brighter), or null on error
|
|
*
|
|
* Notes:
|
|
* (1) Invert pixd to see larger gradients as darker (grayscale).
|
|
* (2) To generate a binary image of the edges, threshold
|
|
* the result using pixThresholdToBinary(). If the high
|
|
* edge values are to be fg (1), invert after running
|
|
* pixThresholdToBinary().
|
|
* (3) Label the pixels as follows:
|
|
* 1 4 7
|
|
* 2 5 8
|
|
* 3 6 9
|
|
* Read the data incrementally across the image and unroll
|
|
* the loop.
|
|
* (4) This runs at about 45 Mpix/sec on a 3 GHz processor.
|
|
*/
|
|
PIX *
|
|
pixSobelEdgeFilter(PIX *pixs,
|
|
l_int32 orientflag)
|
|
{
|
|
l_int32 w, h, d, i, j, wplt, wpld, gx, gy, vald;
|
|
l_int32 val1, val2, val3, val4, val5, val6, val7, val8, val9;
|
|
l_uint32 *datat, *linet, *datad, *lined;
|
|
PIX *pixt, *pixd;
|
|
|
|
PROCNAME("pixSobelEdgeFilter");
|
|
|
|
if (!pixs)
|
|
return (PIX *)ERROR_PTR("pixs not defined", procName, NULL);
|
|
pixGetDimensions(pixs, &w, &h, &d);
|
|
if (d != 8)
|
|
return (PIX *)ERROR_PTR("pixs not 8 bpp", procName, NULL);
|
|
if (orientflag != L_HORIZONTAL_EDGES && orientflag != L_VERTICAL_EDGES &&
|
|
orientflag != L_ALL_EDGES)
|
|
return (PIX *)ERROR_PTR("invalid orientflag", procName, NULL);
|
|
|
|
/* Add 1 pixel (mirrored) to each side of the image. */
|
|
if ((pixt = pixAddMirroredBorder(pixs, 1, 1, 1, 1)) == NULL)
|
|
return (PIX *)ERROR_PTR("pixt not made", procName, NULL);
|
|
|
|
/* Compute filter output at each location. */
|
|
pixd = pixCreateTemplate(pixs);
|
|
datat = pixGetData(pixt);
|
|
wplt = pixGetWpl(pixt);
|
|
datad = pixGetData(pixd);
|
|
wpld = pixGetWpl(pixd);
|
|
for (i = 0; i < h; i++) {
|
|
linet = datat + i * wplt;
|
|
lined = datad + i * wpld;
|
|
for (j = 0; j < w; j++) {
|
|
if (j == 0) { /* start a new row */
|
|
val1 = GET_DATA_BYTE(linet, j);
|
|
val2 = GET_DATA_BYTE(linet + wplt, j);
|
|
val3 = GET_DATA_BYTE(linet + 2 * wplt, j);
|
|
val4 = GET_DATA_BYTE(linet, j + 1);
|
|
val5 = GET_DATA_BYTE(linet + wplt, j + 1);
|
|
val6 = GET_DATA_BYTE(linet + 2 * wplt, j + 1);
|
|
val7 = GET_DATA_BYTE(linet, j + 2);
|
|
val8 = GET_DATA_BYTE(linet + wplt, j + 2);
|
|
val9 = GET_DATA_BYTE(linet + 2 * wplt, j + 2);
|
|
} else { /* shift right by 1 pixel; update incrementally */
|
|
val1 = val4;
|
|
val2 = val5;
|
|
val3 = val6;
|
|
val4 = val7;
|
|
val5 = val8;
|
|
val6 = val9;
|
|
val7 = GET_DATA_BYTE(linet, j + 2);
|
|
val8 = GET_DATA_BYTE(linet + wplt, j + 2);
|
|
val9 = GET_DATA_BYTE(linet + 2 * wplt, j + 2);
|
|
}
|
|
if (orientflag == L_HORIZONTAL_EDGES)
|
|
vald = L_ABS(val1 + 2 * val4 + val7
|
|
- val3 - 2 * val6 - val9) >> 3;
|
|
else if (orientflag == L_VERTICAL_EDGES)
|
|
vald = L_ABS(val1 + 2 * val2 + val3 - val7
|
|
- 2 * val8 - val9) >> 3;
|
|
else { /* L_ALL_EDGES */
|
|
gx = L_ABS(val1 + 2 * val2 + val3 - val7
|
|
- 2 * val8 - val9) >> 3;
|
|
gy = L_ABS(val1 + 2 * val4 + val7
|
|
- val3 - 2 * val6 - val9) >> 3;
|
|
vald = L_MIN(255, gx + gy);
|
|
}
|
|
SET_DATA_BYTE(lined, j, vald);
|
|
}
|
|
}
|
|
|
|
pixDestroy(&pixt);
|
|
return pixd;
|
|
}
|
|
|
|
|
|
/*----------------------------------------------------------------------*
|
|
* Two-sided edge gradient filter *
|
|
*----------------------------------------------------------------------*/
|
|
/*!
|
|
* pixTwoSidedEdgeFilter()
|
|
*
|
|
* Input: pixs (8 bpp; no colormap)
|
|
* orientflag (L_HORIZONTAL_EDGES, L_VERTICAL_EDGES)
|
|
* Return: pixd (8 bpp, edges are brighter), or null on error
|
|
*
|
|
* Notes:
|
|
* (1) For detecting vertical edges, this considers the
|
|
* difference of the central pixel from those on the left
|
|
* and right. For situations where the gradient is the same
|
|
* sign on both sides, this computes and stores the minimum
|
|
* (absolute value of the) difference. The reason for
|
|
* checking the sign is that we are looking for pixels within
|
|
* a transition. By contrast, for single pixel noise, the pixel
|
|
* value is either larger than or smaller than its neighbors,
|
|
* so the gradient would change direction on each side. Horizontal
|
|
* edges are handled similarly, looking for vertical gradients.
|
|
* (2) To generate a binary image of the edges, threshold
|
|
* the result using pixThresholdToBinary(). If the high
|
|
* edge values are to be fg (1), invert after running
|
|
* pixThresholdToBinary().
|
|
* (3) This runs at about 60 Mpix/sec on a 3 GHz processor.
|
|
* It is about 30% faster than Sobel, and the results are
|
|
* similar.
|
|
*/
|
|
PIX *
|
|
pixTwoSidedEdgeFilter(PIX *pixs,
|
|
l_int32 orientflag)
|
|
{
|
|
l_int32 w, h, d, i, j, wpls, wpld;
|
|
l_int32 cval, rval, bval, val, lgrad, rgrad, tgrad, bgrad;
|
|
l_uint32 *datas, *lines, *datad, *lined;
|
|
PIX *pixd;
|
|
|
|
PROCNAME("pixTwoSidedEdgeFilter");
|
|
|
|
if (!pixs)
|
|
return (PIX *)ERROR_PTR("pixs not defined", procName, NULL);
|
|
pixGetDimensions(pixs, &w, &h, &d);
|
|
if (d != 8)
|
|
return (PIX *)ERROR_PTR("pixs not 8 bpp", procName, NULL);
|
|
if (orientflag != L_HORIZONTAL_EDGES && orientflag != L_VERTICAL_EDGES)
|
|
return (PIX *)ERROR_PTR("invalid orientflag", procName, NULL);
|
|
|
|
pixd = pixCreateTemplate(pixs);
|
|
datas = pixGetData(pixs);
|
|
wpls = pixGetWpl(pixs);
|
|
datad = pixGetData(pixd);
|
|
wpld = pixGetWpl(pixd);
|
|
if (orientflag == L_VERTICAL_EDGES) {
|
|
for (i = 0; i < h; i++) {
|
|
lines = datas + i * wpls;
|
|
lined = datad + i * wpld;
|
|
cval = GET_DATA_BYTE(lines, 1);
|
|
lgrad = cval - GET_DATA_BYTE(lines, 0);
|
|
for (j = 1; j < w - 1; j++) {
|
|
rval = GET_DATA_BYTE(lines, j + 1);
|
|
rgrad = rval - cval;
|
|
if (lgrad * rgrad > 0) {
|
|
if (lgrad < 0)
|
|
val = -L_MAX(lgrad, rgrad);
|
|
else
|
|
val = L_MIN(lgrad, rgrad);
|
|
SET_DATA_BYTE(lined, j, val);
|
|
}
|
|
lgrad = rgrad;
|
|
cval = rval;
|
|
}
|
|
}
|
|
}
|
|
else { /* L_HORIZONTAL_EDGES) */
|
|
for (j = 0; j < w; j++) {
|
|
lines = datas + wpls;
|
|
cval = GET_DATA_BYTE(lines, j); /* for line 1 */
|
|
tgrad = cval - GET_DATA_BYTE(datas, j);
|
|
for (i = 1; i < h - 1; i++) {
|
|
lines += wpls; /* for line i + 1 */
|
|
lined = datad + i * wpld;
|
|
bval = GET_DATA_BYTE(lines, j);
|
|
bgrad = bval - cval;
|
|
if (tgrad * bgrad > 0) {
|
|
if (tgrad < 0)
|
|
val = -L_MAX(tgrad, bgrad);
|
|
else
|
|
val = L_MIN(tgrad, bgrad);
|
|
SET_DATA_BYTE(lined, j, val);
|
|
}
|
|
tgrad = bgrad;
|
|
cval = bval;
|
|
}
|
|
}
|
|
}
|
|
|
|
return pixd;
|
|
}
|
|
|
|
|