diff --git a/build/classes/image2d/EdgeDetector.class b/build/classes/image2d/EdgeDetector.class
index 9301234..0977c48 100644
Binary files a/build/classes/image2d/EdgeDetector.class and b/build/classes/image2d/EdgeDetector.class differ
diff --git a/build/classes/image2d/EdgeOperator.class b/build/classes/image2d/EdgeOperator.class
index 7607acf..4d6f7b6 100644
Binary files a/build/classes/image2d/EdgeOperator.class and b/build/classes/image2d/EdgeOperator.class differ
diff --git a/build/classes/image2d/ImageProcessor.class b/build/classes/image2d/ImageProcessor.class
index ebf373c..e27fd77 100644
Binary files a/build/classes/image2d/ImageProcessor.class and b/build/classes/image2d/ImageProcessor.class differ
diff --git a/src/image2d/EdgeDetector.java b/src/image2d/EdgeDetector.java
index e605c57..9f618d4 100644
--- a/src/image2d/EdgeDetector.java
+++ b/src/image2d/EdgeDetector.java
@@ -19,8 +19,10 @@ public static BufferedImage findEdgeSobel(BufferedImage _image) {
         double vertical[][] = new EdgeOperator().edgeVertical();
         // copy image form original
         BufferedImage imageOutput = new Unitys().copyImg(_image);
-         
         // get result
-        return ImageProcessor.convolution(_image, horizontal, vertical);
+        return new EdgeOperator().sobelOperation(_image, horizontal, vertical);
+
     }
+    
+    
 }
diff --git a/src/image2d/EdgeOperator.java b/src/image2d/EdgeOperator.java
index 52bc1e7..b333104 100644
--- a/src/image2d/EdgeOperator.java
+++ b/src/image2d/EdgeOperator.java
@@ -4,6 +4,7 @@
  */
 package image2d;
 
+import java.awt.Color;
 import java.awt.image.BufferedImage;
 
 /**
@@ -35,4 +36,64 @@ public double[][] edgeVertical() {
         return sobel;
     }
     // ----------------------------- end sobel ---------------------------------
+    
+    
+    
+     public BufferedImage sobelOperation(BufferedImage _image, double horizon[][], double vertical[][]) {
+        BufferedImage imageOutput = new Unitys().copyImg(_image);     // Set initial BufferedImage
+        int pixel[][] = doPixels.getPixel(_image); //use to store pixels
+
+        int kernelXY = horizon.length / 2;
+        // calculate image
+        for (int i = 0 + kernelXY; i < imageOutput.getWidth() - kernelXY - 1; i++) {
+            for (int j = 0 + kernelXY; j < imageOutput.getHeight() - kernelXY - 1; j++) {
+                int a = 0, r = 0, g = 0, b = 0; // store RGB
+                int horiz = 0, verti = 0;
+                // horizontal
+                for (int k = -(kernelXY); k < kernelXY + 1; k++) {
+                    for (int l = -(kernelXY); l < kernelXY + 1; l++) {
+
+                        // calculate a RGB by chip bit
+                        a += RGB.alpha(pixel, i - k, j - l) * horizon[k + kernelXY][l + kernelXY];
+                        r += RGB.red(pixel, i - k, j - l) * horizon[k + kernelXY][l + kernelXY];
+                        g += RGB.green(pixel, i - k, j - l) * horizon[k + kernelXY][l + kernelXY];
+                        b += RGB.blue(pixel, i - k, j - l) * horizon[k + kernelXY][l + kernelXY];
+
+                    } //end k
+                }//end j
+                horiz += ((r & 0xff) << 16) | ((g & 0xff) << 8) | (b & 0xff);
+
+
+
+                // vertical
+                for (int k = -(kernelXY); k < kernelXY + 1; k++) {
+                    for (int l = -(kernelXY); l < kernelXY + 1; l++) {
+
+                        // calculate a RGB by chip bit
+                        a += RGB.alpha(pixel, i - k, j - l) * vertical[k + kernelXY][l + kernelXY];
+                        r += RGB.red(pixel, i - k, j - l) * vertical[k + kernelXY][l + kernelXY];
+                        g += RGB.green(pixel, i - k, j - l) * vertical[k + kernelXY][l + kernelXY];
+                        b += RGB.blue(pixel, i - k, j - l) * vertical[k + kernelXY][l + kernelXY];
+
+                    } //end k
+                }//end j
+                verti += ((r & 0xff) << 16) | ((g & 0xff) << 8) | (b & 0xff);
+
+                // add x-coordinate,y-coordinate form (diff) wiht sqrt(x.diff^2)+sqrt(y.diff^2)+
+                double rgb = Math.sqrt(Math.pow(horiz, 2.0)) + Math.sqrt(Math.pow(verti, 2.0));
+                // set color 0-255
+                if (rgb > 255) {
+                    rgb = 255;
+                }
+                if (rgb < 0) {
+                    rgb = 0;
+                }
+                Color c = new Color((int) rgb, (int) rgb, (int) rgb);
+                //set RGB revert to image
+                imageOutput.setRGB(i, j, (int) c.getRGB());
+            }// end i
+        }  //end j
+
+        return imageOutput;
+    }
 }
diff --git a/src/image2d/ImageProcessor.java b/src/image2d/ImageProcessor.java
index 383cc26..a9341e1 100644
--- a/src/image2d/ImageProcessor.java
+++ b/src/image2d/ImageProcessor.java
@@ -39,59 +39,7 @@ public static BufferedImage load_image(String url) {
     //---------------------------------end--------------------------------------
 
     // -----------------------------Convolution --------------------------------
-    public static BufferedImage convolution(BufferedImage _image, double horizon[][], double vertical[][]) {
-        BufferedImage imageOutput = new Unitys().copyImg(_image);     // Set initial BufferedImage
-        int pixel[][] = doPixels.getPixel(_image); //use to store pixels
-
-        int kernelXY = horizon.length / 2;
-        // calculate image
-        for (int i = 0 + kernelXY; i < imageOutput.getWidth() - kernelXY - 1; i++) {
-            for (int j = 0 + kernelXY; j < imageOutput.getHeight() - kernelXY - 1; j++) {
-                int a = 0, r = 0, g = 0, b = 0; // store RGB
-                int horiz = 0, verti = 0;
-                // horizontal
-                for (int k = -(kernelXY); k < kernelXY + 1; k++) {
-                    for (int l = -(kernelXY); l < kernelXY + 1; l++) {
-
-                        // calculate a RGB by chip bit
-                        a += RGB.alpha(pixel, i - k, j - l) * horizon[k + kernelXY][l + kernelXY];
-                        r += RGB.red(pixel, i - k, j - l) * horizon[k + kernelXY][l + kernelXY];
-                        g += RGB.green(pixel, i - k, j - l) * horizon[k + kernelXY][l + kernelXY];
-                        b += RGB.blue(pixel, i - k, j - l) * horizon[k + kernelXY][l + kernelXY];
-
-                    } //end k
-                }//end j
-                horiz += ((r & 0xff) << 16) | ((g & 0xff) << 8) | (b & 0xff);
-
-
-                // vertical
-                for (int k = -(kernelXY); k < kernelXY + 1; k++) {
-                    for (int l = -(kernelXY); l < kernelXY + 1; l++) {
-
-                        // calculate a RGB by chip bit
-                        a += RGB.alpha(pixel, i - k, j - l) * vertical[k + kernelXY][l + kernelXY];
-                        r += RGB.red(pixel, i - k, j - l) * vertical[k + kernelXY][l + kernelXY];
-                        g += RGB.green(pixel, i - k, j - l) * vertical[k + kernelXY][l + kernelXY];
-                        b += RGB.blue(pixel, i - k, j - l) * vertical[k + kernelXY][l + kernelXY];
-
-                    } //end k
-                }//end j
-                verti += ((r & 0xff) << 16) | ((g & 0xff) << 8) | (b & 0xff);
-                
-                // add x-coordinate,y-coordinate form (diff) wiht sqrt(x.diff^2)+sqrt(y.diff^2)+
-                double rgb = Math.sqrt(Math.pow(horiz, 2.0)) + Math.sqrt(Math.pow(verti, 2.0)); 
-                // set color 0-255
-                if (rgb > 255)rgb = 255;
-                if (rgb < 0)rgb = 0;
-                
-                //set RGB revert to image
-                imageOutput.setRGB(i, j, (int)rgb);
-            }// end i
-        }  //end j
-
-        return imageOutput;
-    }
-
+   
     public static BufferedImage convolution(BufferedImage _image, double kernel[][], int wigth, int height, int sizeKernel, int kernelXY) {
         BufferedImage imageOutput = new Unitys().copyImg(_image);     // Set initial BufferedImage
         int pixel[][] = doPixels.getPixel(_image); //use to store pixels