| An OpImage class to perform erosion on a source image.
This class implements an erosion operation.
Grey Scale Erosion
is a spatial operation that computes
each output sample by subtract elements of a kernel to the samples
surrounding a particular source sample with some care.
A mathematical expression is:
For a kernel K with a key position (xKey, yKey), the erosion
of image I at (x,y) is given by:
max{a: a + K(xKey+i, yKey+j) <= I(x+i,y+j): all (i,j) }
all possible (i,j) means that both I(x+i,y+j) and K(xKey+i, yKey+j)
are in bounds. Otherwise, the value is set to 0.
Intuitively, the kernel is like an unbrella and the key point
is the handle. At every point, you try to push the umbrella up as high
as possible but still underneath the image surface. The final height
of the handle is the value after erosion. Thus if you want the image
to erode from the upper right to bottom left, the following would do.
Note that zero kernel erosion has effects on the image, the
location of the key position and size of kernel all matter.
Pseudo code for the erosion operation is as follows.
Assuming the kernel K is of size M rows x N cols
and the key position is (xKey, yKey).
// erosion
for every dst pixel location (x,y){
tmp = infinity;
for (i = -xKey; i < M - xKey; i++){
for (j = -yKey; j < N - yKey; j++){
if((x+i, y+j) are in bounds of src){
tmp = min{tmp, src[x + i][y + j] - K[xKey + i][yKey + j]};
}
}
}
dst[x][y] = tmp;
if (dst[x][y] == infinity)
dst[x][y] = 0;
}
The kernel cannot be bigger in any dimension than the image data.
Binary Image Erosion
requires the kernel to be binary as well.
Intuitively, binary erosion slides the kernel
key position and place it at every non-zero point (x,y) in the src image.
The dst value at this position is set to 1 if all the kernel
are fully supported by the src image, and the src image value is 1
whenever the kernel has value 1.
Otherwise, the value after erosion at (x,y) is set to 0.
Erosion usually shrinks images, but it can fill holes
with kernels like
[1 0 1]
and the key position at the center.
Pseudo code for the erosion operation is as follows.
// erosion
for every dst pixel location (x,y){
dst[x][y] = 1;
for (i = -xKey; i < M - xKey; i++){
for (j = -yKey; j < N - yKey; j++){
if((x+i,y+j) is out of bounds of src ||
src(x+i, y+j)==0 && Key(xKey+i, yKey+j)==1){
dst[x][y] = 0; break;
}
}
}
}
Reference: An Introduction to Nonlinear Image Processing,
by Edward R. Bougherty and Jaakko Astola,
Spie Optical Engineering Press, 1994.
See Also: KernelJAI | 