diff --git a/8thWeek/Canny/Canny.pde b/8thWeek/Canny/Canny.pde
index 3cecc24..8ad45e0 100644
--- a/8thWeek/Canny/Canny.pde
+++ b/8thWeek/Canny/Canny.pde
@@ -1,163 +1,183 @@
 PImage img;
 PImage board1Thresholded, board1Blurred, board1Scharr;
+float minHThreshold = 100, maxHThreshold =140;
+float minBThreshold = 45, maxBThreshold = 170;
+float minSThreshold = 100, maxSThreshold = 255;
 HScrollbar thresholdBar0;
 HScrollbar thresholdBar1;
+enum kernelType { scale , blur , gaussian};
 
 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");
   board1Blurred = loadImage("src/board1Blurred.bmp");
   board1Scharr = loadImage("src/board1Scharr.bmp");
 
-  noLoop(); // no interactive behaviour: draw() will be called only once.
+  //noLoop(); // no interactive behaviour: draw() will be called only once.
 }
 
 void draw() {
-  image(img, 0, 0);//show image
   PImage img1, img2,img3,img4;
-  int I = 100;
   //img2=threshold(img2, (int)map(thresholdBar.getPos(),0,1,0,255), false);
   //img2=HueMap(img2, thresholdBar0.getPos(), thresholdBar1.getPos());
-  img1 = thresholdHSB(img, 100, 200, 100, 255, 45, 100 );
+  //img2 = thresholdHSB(img, 100, 200, 100, 255, 45, 100 );
+  //img3 = convolute(img, kernelType.gaussian);
+  //img4 = scharr(img);
+  image(img, 0, 0);//show image
+  int I = 100;
+  //minHThreshold = thresholdBar0.getPos()*255; 
+  //maxHThreshold = thresholdBar1.getPos()*255; 
+  //println(minHThreshold,maxHThreshold);
+  img1 = thresholdHSB(img, (int)minHThreshold,(int) maxHThreshold, 
+      (int)minSThreshold,(int) maxSThreshold, (int)minBThreshold, (int)maxBThreshold );
+  img1 = convolute(img1, kernelType.gaussian);
   img1 = scharr(img1);
   img1 = threshold(img1, I , false); 
-  img2 = thresholdHSB(img, 100, 200, 100, 255, 45, 100 );
-  img3 = convolute(img);
-  img4 = scharr(img);
   
   
-  image(img3, img.width, 0);
-  /*thresholdBar0.display();
+  
+  image(img1, img.width, 0);
+  thresholdBar0.display();
    thresholdBar0.update();
    thresholdBar1.display();
-   thresholdBar1.update();*/
+   thresholdBar1.update();
   //println(imagesEqual(img2, board1Thresholded));
-  println(imagesEqual(img3, board1Blurred));
+  //println(imagesEqual(img3, board1Blurred));
   //println(imagesEqual(img4, board1Scharr));
 }
 
+//if inverted = false take values for 0 to threshol
 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])){
       //if((i%img1.width)!=0 ||(i%img1.width)!=img1.width-1 ||(i/img1.width)!=0 ||(i/img1.width)!=img1.width-1 )
         //println(i%img1.width+" "+i/img1.width + (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[] buffer = new float[img.width * img.height];
   
   // *************************************
   // Implement here the double convolution
   int N = 3; //kernel size
   for (int x = 1; x<img.width-1; ++x) {
     for (int y = 1; y<img.height-1; y++) { 
       float sum_h = 0, sum_v = 0;
       for (int i = 0; i< N; ++i) {
         for (int j = 0; j<N; ++j) {
           float brightness = brightness(img.pixels[(x-N/2+i)+ img.width *(y-N/2+j)]);
           sum_h += hKernel[i][j] * brightness;
           sum_v += vKernel[i][j] * brightness;
         }
       }
       float value = sqrt(pow(sum_h, 2) + pow(sum_v, 2));
       max = (value > max )? value : max;
       buffer[x+y*img.width] = value;
     }
   }
   // *************************************
   
   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) {
+PImage convolute(PImage img, kernelType kt) {
   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 = 0.f;
-  for (int i = 0; i< N; ++i) {
-    for (int j = 0; j<N; ++j) {
-      normFactor += kernel[i][j];
+  float[][] kernel;
+  float normFactor ;
+  if(kt == kernelType.scale ) {
+    float[][] kernel1 = {{ 0, 0, 0 }, 
+      { 0, 2, 0 }, 
+      { 0, 0, 0 }};
+      kernel = kernel1;
+      normFactor = 1f;
+  }else if(kt == kernelType.blur){
+    float[][] kernel2 = {{ 0, 1, 0 }, 
+      { 1, 0, 1 }, 
+      { 0, 1, 0 }};
+      kernel = kernel2;
+      normFactor = 1f;
+  }else{
+    float[][] gaussianKernel = 
+      {{ 9, 12, 9 }, 
+      { 12, 15, 12 }, 
+      { 9, 12, 9 }};
+    kernel = gaussianKernel;
+      normFactor = 0f;
+    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 = 1; x< img.width-1; x++) {
     for (int y = 1; y<img.height-1; y++) { 
       int sum = 0;
       for (int i = 0; i< N; ++i) {
         for (int j = 0; j<N; ++j) {
           sum += kernel[i][j] * brightness(img.pixels[(x-N/2+i)+ img.width *(y-N/2+j)]);
         }
       }
       result.pixels[x+y*img.width] = color((int)(sum / normFactor));
     }
   }
 
   return result;
 }
diff --git a/8thWeek/Canny/Canny.pde b/8thWeek/Canny/Canny1346447570194487096.autosave
similarity index 93%
copy from 8thWeek/Canny/Canny.pde
copy to 8thWeek/Canny/Canny1346447570194487096.autosave
index 3cecc24..7c9ad28 100644
--- a/8thWeek/Canny/Canny.pde
+++ b/8thWeek/Canny/Canny1346447570194487096.autosave
@@ -1,163 +1,163 @@
 PImage img;
 PImage board1Thresholded, board1Blurred, board1Scharr;
 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");
   board1Blurred = loadImage("src/board1Blurred.bmp");
   board1Scharr = loadImage("src/board1Scharr.bmp");
 
   noLoop(); // no interactive behaviour: draw() will be called only once.
 }
 
 void draw() {
   image(img, 0, 0);//show image
   PImage img1, img2,img3,img4;
   int I = 100;
   //img2=threshold(img2, (int)map(thresholdBar.getPos(),0,1,0,255), false);
   //img2=HueMap(img2, thresholdBar0.getPos(), thresholdBar1.getPos());
   img1 = thresholdHSB(img, 100, 200, 100, 255, 45, 100 );
   img1 = scharr(img1);
   img1 = threshold(img1, I , false); 
   img2 = thresholdHSB(img, 100, 200, 100, 255, 45, 100 );
   img3 = convolute(img);
-  img4 = scharr(img);
+  img4 = scharr(img2);
   
   
-  image(img3, img.width, 0);
-  /*thresholdBar0.display();
+  image(img4, img.width, 0);
+  thresholdBar0.display();
    thresholdBar0.update();
    thresholdBar1.display();
-   thresholdBar1.update();*/
-  //println(imagesEqual(img2, board1Thresholded));
-  println(imagesEqual(img3, board1Blurred));
+   thresholdBar1.update();
+  println(imagesEqual(img2, board1Thresholded));
+  //println(imagesEqual(img3, board1Blurred));
   //println(imagesEqual(img4, board1Scharr));
 }
 
 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])){
       //if((i%img1.width)!=0 ||(i%img1.width)!=img1.width-1 ||(i/img1.width)!=0 ||(i/img1.width)!=img1.width-1 )
         //println(i%img1.width+" "+i/img1.width + (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[] buffer = new float[img.width * img.height];
   
   // *************************************
   // Implement here the double convolution
   int N = 3; //kernel size
   for (int x = 1; x<img.width-1; ++x) {
     for (int y = 1; y<img.height-1; y++) { 
       float sum_h = 0, sum_v = 0;
       for (int i = 0; i< N; ++i) {
         for (int j = 0; j<N; ++j) {
           float brightness = brightness(img.pixels[(x-N/2+i)+ img.width *(y-N/2+j)]);
           sum_h += hKernel[i][j] * brightness;
           sum_v += vKernel[i][j] * brightness;
         }
       }
       float value = sqrt(pow(sum_h, 2) + pow(sum_v, 2));
       max = (value > max )? value : max;
       buffer[x+y*img.width] = value;
     }
   }
   // *************************************
   
   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 = 0.f;
   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 = 1; x< img.width-1; x++) {
     for (int y = 1; y<img.height-1; y++) { 
       int sum = 0;
       for (int i = 0; i< N; ++i) {
         for (int j = 0; j<N; ++j) {
           sum += kernel[i][j] * brightness(img.pixels[(x-N/2+i)+ img.width *(y-N/2+j)]);
         }
       }
       result.pixels[x+y*img.width] = color((int)(sum / normFactor));
     }
   }
 
   return result;
 }
diff --git a/8thWeek/Canny/Canny.pde b/8thWeek/Canny/Canny1455946373015699613.autosave
similarity index 95%
copy from 8thWeek/Canny/Canny.pde
copy to 8thWeek/Canny/Canny1455946373015699613.autosave
index 3cecc24..5c4743c 100644
--- a/8thWeek/Canny/Canny.pde
+++ b/8thWeek/Canny/Canny1455946373015699613.autosave
@@ -1,163 +1,163 @@
 PImage img;
 PImage board1Thresholded, board1Blurred, board1Scharr;
 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");
   board1Blurred = loadImage("src/board1Blurred.bmp");
   board1Scharr = loadImage("src/board1Scharr.bmp");
 
   noLoop(); // no interactive behaviour: draw() will be called only once.
 }
 
 void draw() {
   image(img, 0, 0);//show image
   PImage img1, img2,img3,img4;
   int I = 100;
   //img2=threshold(img2, (int)map(thresholdBar.getPos(),0,1,0,255), false);
   //img2=HueMap(img2, thresholdBar0.getPos(), thresholdBar1.getPos());
   img1 = thresholdHSB(img, 100, 200, 100, 255, 45, 100 );
   img1 = scharr(img1);
   img1 = threshold(img1, I , false); 
   img2 = thresholdHSB(img, 100, 200, 100, 255, 45, 100 );
   img3 = convolute(img);
   img4 = scharr(img);
   
   
   image(img3, img.width, 0);
-  /*thresholdBar0.display();
+  thresholdBar0.display();
    thresholdBar0.update();
    thresholdBar1.display();
-   thresholdBar1.update();*/
+   thresholdBar1.update();
   //println(imagesEqual(img2, board1Thresholded));
   println(imagesEqual(img3, board1Blurred));
   //println(imagesEqual(img4, board1Scharr));
 }
 
 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])){
       //if((i%img1.width)!=0 ||(i%img1.width)!=img1.width-1 ||(i/img1.width)!=0 ||(i/img1.width)!=img1.width-1 )
         //println(i%img1.width+" "+i/img1.width + (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[] buffer = new float[img.width * img.height];
   
   // *************************************
   // Implement here the double convolution
   int N = 3; //kernel size
   for (int x = 1; x<img.width-1; ++x) {
     for (int y = 1; y<img.height-1; y++) { 
       float sum_h = 0, sum_v = 0;
       for (int i = 0; i< N; ++i) {
         for (int j = 0; j<N; ++j) {
           float brightness = brightness(img.pixels[(x-N/2+i)+ img.width *(y-N/2+j)]);
           sum_h += hKernel[i][j] * brightness;
           sum_v += vKernel[i][j] * brightness;
         }
       }
       float value = sqrt(pow(sum_h, 2) + pow(sum_v, 2));
       max = (value > max )? value : max;
       buffer[x+y*img.width] = value;
     }
   }
   // *************************************
   
   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 = 0.f;
   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 = 1; x< img.width-1; x++) {
     for (int y = 1; y<img.height-1; y++) { 
       int sum = 0;
       for (int i = 0; i< N; ++i) {
         for (int j = 0; j<N; ++j) {
           sum += kernel[i][j] * brightness(img.pixels[(x-N/2+i)+ img.width *(y-N/2+j)]);
         }
       }
       result.pixels[x+y*img.width] = color((int)(sum / normFactor));
     }
   }
 
   return result;
 }
diff --git a/8thWeek/Canny/Canny.pde b/8thWeek/Canny/Canny7490791066739572485.autosave
similarity index 76%
copy from 8thWeek/Canny/Canny.pde
copy to 8thWeek/Canny/Canny7490791066739572485.autosave
index 3cecc24..198df5b 100644
--- a/8thWeek/Canny/Canny.pde
+++ b/8thWeek/Canny/Canny7490791066739572485.autosave
@@ -1,163 +1,166 @@
 PImage img;
 PImage board1Thresholded, board1Blurred, board1Scharr;
 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");
   board1Blurred = loadImage("src/board1Blurred.bmp");
   board1Scharr = loadImage("src/board1Scharr.bmp");
 
   noLoop(); // no interactive behaviour: draw() will be called only once.
 }
 
 void draw() {
   image(img, 0, 0);//show image
-  PImage img1, img2,img3,img4;
-  int I = 100;
+  PImage img2,img3,img4;
+
   //img2=threshold(img2, (int)map(thresholdBar.getPos(),0,1,0,255), false);
   //img2=HueMap(img2, thresholdBar0.getPos(), thresholdBar1.getPos());
-  img1 = thresholdHSB(img, 100, 200, 100, 255, 45, 100 );
-  img1 = scharr(img1);
-  img1 = threshold(img1, I , false); 
   img2 = thresholdHSB(img, 100, 200, 100, 255, 45, 100 );
   img3 = convolute(img);
   img4 = scharr(img);
   
-  
-  image(img3, img.width, 0);
-  /*thresholdBar0.display();
+  image(img2, img.width, 0);
+  thresholdBar0.display();
    thresholdBar0.update();
    thresholdBar1.display();
-   thresholdBar1.update();*/
-  //println(imagesEqual(img2, board1Thresholded));
+   thresholdBar1.update();
+  println(imagesEqual(img2, board1Thresholded));
   println(imagesEqual(img3, board1Blurred));
-  //println(imagesEqual(img4, board1Scharr));
+  println(imagesEqual(img4, board1Scharr));
 }
 
 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])){
-      //if((i%img1.width)!=0 ||(i%img1.width)!=img1.width-1 ||(i/img1.width)!=0 ||(i/img1.width)!=img1.width-1 )
-        //println(i%img1.width+" "+i/img1.width + (red(img1.pixels[i]) - red(img2.pixels[i])) );
+    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[] buffer = new float[img.width * img.height];
   
   // *************************************
   // Implement here the double convolution
   int N = 3; //kernel size
-  for (int x = 1; x<img.width-1; ++x) {
-    for (int y = 1; y<img.height-1; y++) { 
+  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) {
-          float brightness = brightness(img.pixels[(x-N/2+i)+ img.width *(y-N/2+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;
         }
       }
       float value = sqrt(pow(sum_h, 2) + pow(sum_v, 2));
       max = (value > max )? value : max;
       buffer[x+y*img.width] = value;
     }
   }
+
   // *************************************
   
   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 = 0.f;
+  float normFactor = 1.f;
   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 = 1; x< img.width-1; x++) {
-    for (int y = 1; y<img.height-1; y++) { 
+  for (int x = 0; x< img.width; ++x) {
+    for (int y = 0; y<img.height; y++) { 
       int sum = 0;
       for (int i = 0; i< N; ++i) {
         for (int j = 0; j<N; ++j) {
-          sum += kernel[i][j] * brightness(img.pixels[(x-N/2+i)+ img.width *(y-N/2+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]);
         }
       }
       result.pixels[x+y*img.width] = color((int)(sum / normFactor));
     }
   }
 
   return result;
 }