init

Author: mdex-geek

Readme.md

@@ -0,0 +1 @@
+# Async image processing

src/main/java/com/image/imageprocessing/filter/GreyScaleFilter.java

@@ -0,0 +1,30 @@
+package com.image.imageprocessing.filter;
+
+import java.awt.*;
+import java.awt.image.BufferedImage;
+
+public class GreyScaleFilter implements ImageFilter{
+
+    @Override
+    public BufferedImage filter(BufferedImage originalImage){
+        int width = originalImage.getWidth();
+        int height = originalImage.getHeight();
+
+        BufferedImage grayscaleImage = new BufferedImage(width, height, BufferedImage.TYPE_BYTE_GRAY);
+
+        for (int y = 0; y < height; y++) {
+            for (int x = 0; x < width; x++) {
+                int rgb = originalImage.getRGB(x, y);
+
+                int r = (rgb >> 16) & 0xFF;
+                int g = (rgb >> 8) & 0xFF;
+                int b = rgb & 0xFF;
+                int gray = (int) (0.2126 * r + 0.7152 * g + 0.0722 * b);
+                int newRgb = new Color(gray, gray, gray).getRGB();
+                grayscaleImage.setRGB(x, y, newRgb);
+            }
+        }
+        return grayscaleImage;
+    }
+
+}

src/main/java/com/image/imageprocessing/filter/ImageFilter.java

@@ -0,0 +1,7 @@
+package com.image.imageprocessing.filter;
+
+import java.awt.image.BufferedImage;
+
+public interface ImageFilter {
+    BufferedImage filter(BufferedImage image);
+}

src/main/java/com/image/imageprocessing/image/DrawMultipleImagesOnCanvas.java

@@ -0,0 +1,73 @@
+package com.image.imageprocessing.image;
+
+import javafx.animation.AnimationTimer;
+import javafx.application.Platform;
+import javafx.embed.swing.SwingFXUtils;
+import javafx.scene.Group;
+import javafx.scene.Scene;
+import javafx.scene.canvas.Canvas;
+import javafx.scene.canvas.GraphicsContext;
+import javafx.scene.layout.StackPane;
+import javafx.stage.Stage;
+
+import java.util.Queue;
+import java.util.concurrent.LinkedBlockingQueue;
+
+public class DrawMultipleImagesOnCanvas {
+
+    private static DrawMultipleImagesOnCanvas instance;
+    private Queue<ImageData> queue = new LinkedBlockingQueue<>();
+    private GraphicsContext gc;
+    private boolean isDrawing = false;
+
+    public static DrawMultipleImagesOnCanvas getInstance(){
+        if(instance == null){
+            return new DrawMultipleImagesOnCanvas();
+        }
+        return instance;
+    }
+
+    public void addImageToQueue(ImageData image){
+        queue.offer(image);
+    }
+
+    public void initialize(Stage primaryStage){
+        Canvas canvas = new Canvas(1920, 1080);
+        this.gc = canvas.getGraphicsContext2D();
+        this.gc.clearRect(0,0, 1920, 1080);
+
+        new AnimationTimer() {
+            @Override
+            public void handle(long now) {
+                // Todo: poll the image from queue, spin a thread and draw
+                if (!isDrawing && !queue.isEmpty()) {
+                    new Thread(() -> {
+                        try{
+                            drawNextImage();
+                        }finally {
+                            isDrawing = false;
+                        }
+                    }).start();
+                }
+            }
+        }.start();
+
+        StackPane stack = new StackPane(canvas);
+        Scene scene = new Scene(stack, 1920, 1080);
+        primaryStage.setScene(scene);
+        primaryStage.setTitle("Canvas Example");
+        primaryStage.show();
+    }
+
+    private void drawNextImage(){
+        ImageData imageData = queue.poll();
+        Platform.runLater(() -> {
+            if(imageData != null){
+                this.gc.drawImage(SwingFXUtils.toFXImage(imageData.getImage(), null),
+                        imageData.getI(), imageData.getJ(), imageData.getX(), imageData.getY());
+                System.out.println("Drawing using thread "+Thread.currentThread().getName());
+                System.out.println(String.format("Drawing image at i: %s, j: %s", imageData.getI(), imageData.getJ()));
+            }
+        });
+    }
+}

src/main/java/com/image/imageprocessing/image/ImageData.java

@@ -0,0 +1,61 @@
+package com.image.imageprocessing.image;
+
+import java.awt.image.BufferedImage;
+
+public class ImageData {
+
+    public int getI() {
+        return i;
+    }
+
+    public void setI(int i) {
+        this.i = i;
+    }
+
+    public BufferedImage getImage() {
+        return image;
+    }
+
+    public void setImage(BufferedImage image) {
+        this.image = image;
+    }
+
+    public int getJ() {
+        return j;
+    }
+
+    public void setJ(int j) {
+        this.j = j;
+    }
+
+    public int getX() {
+        return x;
+    }
+
+    public void setX(int x) {
+        this.x = x;
+    }
+
+    public int getY() {
+        return y;
+    }
+
+    public void setY(int y) {
+        this.y = y;
+    }
+
+    public ImageData(BufferedImage image, int i, int j, int x, int y) {
+        this.image = image;
+        this.i = i;
+        this.j = j;
+        this.x = x;
+        this.y = y;
+    }
+
+    private BufferedImage image;
+    private int i;
+    private int j;
+    private int x;
+    private int y;
+
+}

src/main/java/com/image/imageprocessing/io/FileImageIO.java

@@ -0,0 +1,26 @@
+package com.image.imageprocessing.io;
+
+import javax.imageio.ImageIO;
+import java.awt.image.BufferedImage;
+import java.io.File;
+
+public class FileImageIO implements ImageReadInf {
+
+    @Override
+    public <T> BufferedImage readImage(T src){
+        try{
+            String path = (String) src;
+            File imageFile = new File(path);
+            return ImageIO.read(imageFile);
+        }catch (Exception ex){
+            System.err.println("Not able to read the image");
+            return null;
+        }
+    }
+
+    @Override
+    public void sendImage(BufferedImage src){
+        // Todo: implement this fucntion to store the imageFile
+    }
+
+}

src/main/java/com/image/imageprocessing/io/ImageReadInf.java

@@ -0,0 +1,9 @@
+package com.image.imageprocessing.io;
+
+import java.awt.image.BufferedImage;
+
+public interface ImageReadInf {
+     <T> BufferedImage readImage(T src);
+
+     void sendImage(BufferedImage image);
+}

src/main/java/com/image/imageprocessing/io/img.png

@@ -0,0 +1,59 @@
+package com.image.imageprocessing.processor;
+
+import com.image.imageprocessing.filter.ImageFilter;
+import com.image.imageprocessing.image.DrawMultipleImagesOnCanvas;
+import com.image.imageprocessing.image.ImageData;
+
+import java.awt.image.BufferedImage;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.concurrent.Callable;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.concurrent.Future;
+
+public class ImageProcessor {
+
+    private ExecutorService executorService;
+    private DrawMultipleImagesOnCanvas drawFn;
+
+    public ImageProcessor(){
+        executorService = Executors.newFixedThreadPool(100);
+    }
+
+    public void processImage(BufferedImage image, int num, ImageFilter imageFilter, DrawMultipleImagesOnCanvas drawFn){
+        int numHorizontalImages = image.getWidth() / num;
+        int numVerticalImages = image.getHeight() / num;
+
+        List<Future<ImageData>> futures = new ArrayList<>();
+
+        for (int i = 0; i<numHorizontalImages; i++){
+            for(int j=0; j<numVerticalImages; j++){
+                BufferedImage subImage = image.getSubimage(i*num, j*num, num, num);
+                int finalI = i;
+                int finalJ = j;
+                Future<ImageData> future = executorService.submit(new Callable<ImageData>() {
+                    @Override
+                    public ImageData call(){
+                        BufferedImage result = imageFilter.filter(subImage);
+                        ImageData imageData = new ImageData(result, finalI *num, finalJ *num, num, num);
+
+                        drawFn.addImageToQueue(imageData);
+                        return imageData;
+                    }
+                });
+                futures.add(future);
+            }
+        }
+
+        for (Future<ImageData> future : futures) {
+            try {
+                future.get();
+            } catch (Exception ex) {
+                System.err.println("Not able to push the image into the queue");
+            }
+        }
+
+    }
+
+}