Edge Detection
/**
* Edge Detection.
*
* This program analyzes every pixel in an image and compares it with the
* neighboring pixels to identify edges.
*
* This is an example of an "image convolution" using a kernel (small matrix)
* to analyze and transform a pixel based on the values of its neighbors.
*
* This kernel describes a "Laplacian Edge Detector". It is effective,
* but sensitive to noise. One common enhancement is to add a Gaussian
* blur to the source image first, as in
* grayImg->filter(BLUR);
* to reduce impact of noise on the output. The combination is often called
* "Laplace of Gaussian", or "LoG" for short.
*
* For weaker detection effect, try this kernel: [ 0 -1 0 ]
* [ -1 4 -1 ]
* [ 0 -1 0 ]
*/
float kernel[3][3] = {{ -1, -1, -1},
{ -1, 8, -1},
{ -1, -1, -1}};
PImage* img;
void setup() {
size(640, 360);
img = loadImage("moon.jpg"); // Load the original image
noLoop();
}
void draw() {
image(img, 0, 0); // Displays the image from point (0,0)
img->loadPixels();
// Edge detection should be done on a grayscale image.
// Create a copy of the source image, and convert to gray.
// PImage's copy CONSTRUCTOR is deleted (see E0002 in Processing.h --
// it owns a GPU texture, so value-style copying isn't supported), but
// PImage::copy() is a real method that duplicates the whole image into
// an independent PImage. It returns by value, so wrap it in `new` to
// fit this codebase's PImage* convention -- the move constructor
// handles the transfer, no pixel data is copied twice.
PImage* grayImg = new PImage(img->copy());
grayImg->filter(GRAY);
// grayImg->filter(BLUR);
// Create an opaque image of the same size as the original
PImage* edgeImg = createImage(grayImg->width, grayImg->height, RGB);
// Loop through every pixel in the image
for (int y = 1; y < grayImg->height - 1; y++) { // Skip top and bottom edges
for (int x = 1; x < grayImg->width - 1; x++) { // Skip left and right edges
// Output of this filter is shown as offset from 50% gray.
// This preserves transitions from low (dark) to high (light) value.
// Starting from zero will show only high edges on black instead.
float sum = 128;
for (int ky = -1; ky <= 1; ky++) {
for (int kx = -1; kx <= 1; kx++) {
// Calculate the adjacent pixel for this kernel point
int pos = (y + ky) * grayImg->width + (x + kx);
// Image is grayscale, red/green/blue are identical
float val = blue(grayImg->pixels[pos]);
// Multiply adjacent pixels based on the kernel values
sum += kernel[ky + 1][kx + 1] * val;
}
}
// For this pixel in the new image, set the output value
// based on the sum from the kernel
edgeImg->pixels[y * edgeImg->width + x] = color(sum);
}
}
// State that there are changes to edgeImg->pixels[]
edgeImg->updatePixels();
image(edgeImg, width / 2, 0); // Draw the new image
}