Homec4science
Diffusion InfoVisuGit (Alex) Browse

BA4Project/8thWeek/Canny/Canny.pde
cacaed2a3de3Alex

Last Change
Raw File

Canny.pde
View Options

PImage img;
PImage board1Thresholded;
HScrollbar thresholdBar0;
HScrollbar thresholdBar1;
void settings() {
size(1600, 600);
}
void setup() {
thresholdBar0 = new HScrollbar(0, 560, 800, 20);
thresholdBar1 = new HScrollbar(0, 580, 800, 20);
img = loadImage("src/board1.jpg");
board1Thresholded = loadImage("src/board1Thresholded.bmp");
noLoop(); // no interactive behaviour: draw() will be called only once.
}
void draw() {
image(img, 0, 0);//show image
PImage img2 = img.copy();//make a deep copy
img2.loadPixels();// load pixels
//img2=threshold(img2, (int)map(thresholdBar.getPos(),0,1,0,255), false);
//img2=HueMap(img2, thresholdBar0.getPos(), thresholdBar1.getPos());
img2=thresholdHSB(img2, 100, 200, 100, 255, 45, 100 );
img2.updatePixels();//update pixels
image(img2, img.width, 0);
/*thresholdBar0.display();
thresholdBar0.update();
thresholdBar1.display();
thresholdBar1.update();*/
println(imagesEqual(img2,board1Thresholded));
}
PImage threshold(PImage img, int threshold, boolean inverted) {
PImage result = createImage(img.width, img.height, RGB);
for (int i = 0; i < img.width * img.height; i++) {
result.pixels[i]=brightness(img.pixels[i])>threshold^inverted?color(255):color(0);
}
return result;
}
PImage thresholdHSB(PImage img, int minH, int maxH, int minS, int maxS, int minB, int maxB) {
PImage result = createImage(img.width, img.height, RGB);
for (int i = 0; i < img.width * img.height; i++) {
if (hue(img.pixels[i])<minH||maxH<hue(img.pixels[i])||
saturation(img.pixels[i])<minS||maxS<saturation(img.pixels[i])||
brightness(img.pixels[i])<minB||maxB<brightness(img.pixels[i])) {
result.pixels[i]=0;
} else {
result.pixels[i]=Integer.MAX_VALUE;
}
}
return result;
}
boolean imagesEqual(PImage img1, PImage img2) {
if (img1.width != img2.width || img1.height != img2.height)
return false;
for (int i = 0; i < img1.width*img1.height; i++)
//assuming that all the three channels have the same value
if (red(img1.pixels[i]) != red(img2.pixels[i]))
return false;
return true;
}
PImage scharr(PImage img) {
float[][] vKernel = {
{ 3, 0, -3 },
{ 10, 0, -10 },
{ 3, 0, -3 } };
float[][] hKernel = {
{ 3, 10, 3 },
{ 0, 0, 0 },
{ -3, -10, -3 } };
PImage result = createImage(img.width, img.height, ALPHA);
// clear the image
for (int i = 0; i < img.width * img.height; i++) {
result.pixels[i] = color(0);
}
float max=0;
float normFactor = 1.f;
float[] buffer = new float[img.width * img.height];
// *************************************
// Implement here the double convolution
int N = 3; //kernel size
for (int x = 0; x< img.width; ++x) {
for (int y = 0; y<img.height; y++) {
float sum_h = 0, sum_v = 0;
for (int i = 0; i< N; ++i) {
for (int j = 0; j<N; ++j) {
int row = ((row = y-N/2+i) < 0)? 0 : row;
row = (row >= img.height)? img.height-1 : row;
int column = ((column = x-N/2+i) < 0)? 0 : column;
column = (column >= img.width)? img.width-1: column;
float brightness = brightness(img.pixels[column + img.width *row]);
sum_h += hKernel[i][j] * brightness;
sum_v += vKernel[i][j] * brightness;
}
}
// - sum all these intensities and divide it by normFactor
// - set result.pixels[y * img.width + x] to this value
float value = sqrt(pow(sum_h, 2) + pow(sum_v, 2));
max = (value > max )? value : max;
buffer[x+y*img.width] = value / normFactor;
}
}
// *************************************
for (int y = 1; y < img.height - 1; y++) { // Skip top and bottom edges
for (int x = 1; x < img.width - 1; x++) { // Skip left and right
int val=(int) ((buffer[y * img.width + x] / max)*255);
result.pixels[y * img.width + x]=color(val);
}
}
return result;
}
PImage convolute(PImage img) {
int N = 3; //kernel size
float[][] kernel1 = {{ 0, 0, 0 },
{ 0, 2, 0 },
{ 0, 0, 0 }};
float[][] kernel2 = {{ 0, 1, 0 },
{ 1, 0, 1 },
{ 0, 1, 0 }};
float[][] gaussianKernel =
{{ 9, 12, 9 },
{ 12, 15, 12 },
{ 9, 12, 9 }};
float[][] kernel = gaussianKernel;
float normFactor = 1.f;
/* For the gaussian kernel
for(int i = 0; i< N; ++i){
for(int j = 0; j<N; ++j){
normFactor += kernel[i][j];
}
}
*/
// create a greyscale image (type: ALPHA) for output
PImage result = createImage(img.width, img.height, ALPHA);
//
// for each (x,y) pixel in the image:
for (int x = 0; x< img.width; ++x) {
for (int y = 0; y<img.height; y++) {
// - multiply intensities for pixels in the range
//(x - N/2, y - N/2) to (x + N/2, y + N/2) by the
//corresponding weights in the kernel matrix
int sum = 0;
for (int i = 0; i< N; ++i) {
for (int j = 0; j<N; ++j) {
int row = ((row = y-N/2+i) < 0)? 0 : row;
row = (row >= img.height)? img.height-1 : row;
int column = ((column = x-N/2+i) < 0)? 0 : column;
column = (column >= img.width)? img.width-1: column;
sum += kernel[i][j] * brightness(img.pixels[column + img.width *row]);
}
}
// - sum all these intensities and divide it by normFactor
// - set result.pixels[y * img.width + x] to this value
result.pixels[x+y*img.width] = color((int)(sum / normFactor));
}
}
return result;
}
c4science · Help