evaluation erweitert

LinearRegressionTool/src/main/java/App.java

@@ -1,9 +1,12 @@
 import model.LineModel;
+import org.opencv.core.Core;
 import presenter.Presenter;
+import presenter.evaluation.PictureProcessor;
 import view.MainFrame;
 
 import javax.swing.*;
 import java.awt.*;
+import java.lang.reflect.InvocationTargetException;
 
 /**
  * Implementierung verschiedener Algorithmen zur Berechnung von Ausgleichsgeraden.
@@ -14,6 +17,8 @@ import java.awt.*;
  */
 public class App {
 
+    static {System.loadLibrary(Core.NATIVE_LIBRARY_NAME);}
+
     private static void setUIFont(javax.swing.plaf.FontUIResource f) {
         java.util.Enumeration<Object> keys = UIManager.getDefaults().keys();
         while (keys.hasMoreElements()) {
@@ -47,13 +52,16 @@ public class App {
 
     public static void main(String[] args) {
 
+        final Presenter presenter = new Presenter(new LineModel(), null);
+
         SwingUtilities.invokeLater(() -> {
             JFrame.setDefaultLookAndFeelDecorated(true);
             MainFrame view = new MainFrame();
             setLookAndFeel(view);
             setUIFont(new javax.swing.plaf.FontUIResource(new Font("Verdana", Font.PLAIN, 12)));
-            view.setPresenter(new Presenter(new LineModel(), view));
+            view.setPresenter(presenter);
             view.setActionListeners();
+            presenter.setView(view);
         });
 
     }

LinearRegressionTool/src/main/java/presenter/AbstractPresenter.java

@@ -5,6 +5,7 @@ import model.Line;
 import model.LineModel;
 import presenter.algorithms.util.IntersectionCounter;
 import presenter.evaluation.EvaluateAlgorithms;
+import presenter.evaluation.PictureProcessor;
 import view.MainFrame;
 
 import javax.swing.*;
@@ -133,6 +134,24 @@ public abstract class AbstractPresenter implements Observer {
                 setup();
             });
         }
+
+        if (result[0] == "import-picture") {
+            //100% erreicht
+            SwingUtilities.invokeLater(() -> {
+                getView().enableFunctionality();
+            });
+            setup();
+            Thread t = new Thread(() -> {
+                calculateIntersections();
+            });
+            t.start();
+            try {
+                t.join();
+            } catch (InterruptedException e) {
+                e.printStackTrace();
+            }
+
+        }
     }
 
     public void setup() {

LinearRegressionTool/src/main/java/presenter/Presenter.java

@@ -5,6 +5,7 @@ import presenter.algorithms.advanced.LeastMedianOfSquaresEstimator;
 import presenter.algorithms.advanced.RepeatedMedianEstimator;
 import presenter.algorithms.advanced.TheilSenEstimator;
 import presenter.evaluation.EvaluateAlgorithms;
+import presenter.evaluation.PictureProcessor;
 import presenter.generator.DatasetGenerator;
 import presenter.io.DataExporter;
 import presenter.io.DataImporter;
@@ -29,6 +30,7 @@ public class Presenter extends AbstractPresenter{
     private Thread rmThread;
     private Thread lmsThread;
     private Thread importThread;
+    private Thread importPictureThread;
     private Thread exportThread;
     private Thread exportResultThread;
     private Thread generatorThread;
@@ -129,6 +131,25 @@ public class Presenter extends AbstractPresenter{
         }
     }
 
+    public void startPictureDataImport(File file){
+        if (importPictureThread == null || !importPictureThread.isAlive()) {
+            importPictureThread = new Thread(() -> {
+                PictureProcessor pictureProcessor = new PictureProcessor(this, file);
+                pictureProcessor.addObserver(this);
+                pictureProcessor.run();
+            });
+            importPictureThread.start();
+            try {
+                importPictureThread.join();
+            } catch (InterruptedException e) {
+                e.printStackTrace();
+            }
+        }
+
+
+
+    }
+
     public void startExport(File file) {
         if (exportThread == null || !exportThread.isAlive()) {
             exportThread = new Thread(() -> {

LinearRegressionTool/src/main/java/presenter/evaluation/PictureProcessor.java

@@ -0,0 +1,106 @@
+package presenter.evaluation;
+import model.Line;
+import org.opencv.core.Core;
+import org.opencv.core.CvType;
+import org.opencv.core.Mat;
+import org.opencv.core.Size;
+import org.opencv.highgui.*;
+import org.opencv.imgproc.Imgproc;
+import presenter.Presenter;
+import presenter.algorithms.advanced.LeastMedianOfSquaresEstimator;
+
+import javax.imageio.ImageIO;
+import javax.swing.*;
+import javax.swing.filechooser.FileFilter;
+import javax.swing.filechooser.FileNameExtensionFilter;
+import javax.swing.filechooser.FileSystemView;
+import java.awt.*;
+import java.awt.image.BufferedImage;
+import java.awt.image.DataBufferByte;
+import java.io.File;
+import java.lang.reflect.InvocationTargetException;
+import java.util.LinkedList;
+import java.util.Observable;
+import java.util.Observer;
+
+/**
+ * Implementierung verschiedener Algorithmen zur Berechnung von Ausgleichsgeraden.
+ *
+ * @Author: Armin Wolf
+ * @Email: a_wolf28@uni-muenster.de
+ * @Date: 17.09.2017.
+ */
+public class PictureProcessor extends Observable{
+
+    private Mat image;
+    private Mat threshold;
+    private Presenter presenter;
+    private File file;
+
+    public PictureProcessor(Presenter presenter, File file)  {
+        this.file = file;
+        this.presenter = presenter;
+    }
+
+    public void run(){
+        String msg = "";
+        msg = SwingUtilities.isEventDispatchThread() ?  "EDT" : "nicht EDT";
+        System.out.println(msg);
+
+        System.out.println("Welcome to OpenCV " + Core.VERSION);
+
+        image = Highgui.imread(file.getAbsolutePath());
+        threshold = process(image);
+        createInputData(threshold);
+    }
+
+    private Mat process(Mat image){
+        threshold = new Mat(image.width(), image.height(), CvType.CV_8UC1);
+        Mat source = new Mat(image.width(), image.height(), CvType.CV_8UC1);
+        Imgproc.cvtColor(image, source, Imgproc.COLOR_BGR2GRAY);
+        Imgproc.adaptiveThreshold(source, threshold,255, Imgproc.ADAPTIVE_THRESH_MEAN_C,
+                                  Imgproc.THRESH_BINARY_INV, 11,2);
+        return threshold;
+    }
+
+
+    private BufferedImage toBufferedImage(Mat m) {
+        int type = BufferedImage.TYPE_BYTE_GRAY;
+        if (m.channels() > 1) {
+            type = BufferedImage.TYPE_3BYTE_BGR;
+        }
+        int bufferSize = m.channels() * m.cols() * m.rows();
+        byte[] b = new byte[bufferSize];
+        m.get(0, 0, b); // get all the pixels
+        BufferedImage image = new BufferedImage(m.cols(), m.rows(), type);
+        final byte[] targetPixels = ((DataBufferByte) image.getRaster().getDataBuffer()).getData();
+        System.arraycopy(b, 0, targetPixels, 0, b.length);
+        return image;
+
+    }
+
+    private void createInputData(Mat image){
+        Thread t = new Thread(() -> {
+            int id = 0;
+            for (int i=0;i<image.rows();i++){
+                for (int j=0;j<image.cols();j++){
+                    double[] colVal = image.get(i,j);
+                    if (colVal[0] == 255d){
+                        Line line = new Line(i,j);
+                        line.setId(""+id++);
+                        presenter.getModel().getLines().add(line);
+                    }
+                }
+            }
+        });
+        t.start();
+        try {
+            t.join();
+            setChanged();
+            String[] msg = {"import-picture"};
+            notifyObservers(msg);
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+    }
+}

LinearRegressionTool/src/main/java/view/MenuBar.java

@@ -5,6 +5,7 @@ import view.MainFrame;
 import view.listener.ExportDataListener;
 import view.listener.GenerateDataListener;
 import view.listener.ImportDataListener;
+import view.listener.PictureImportListener;
 import view.panels.AboutPanel;
 
 import javax.swing.*;
@@ -32,6 +33,7 @@ public class MenuBar {
     private JMenuItem generateItem;
     private JMenuItem evaluateItem;
     private JMenuItem aboutItem;
+    private JMenuItem importPicture;
 
     public MenuBar(MainFrame view) {
         this.menuBar = new JMenuBar();
@@ -43,6 +45,7 @@ public class MenuBar {
 
         this.exitItem = new JMenuItem("Exit");
         this.importItem = new JMenuItem("Import");
+        this.importPicture = new JMenuItem("Bildimport");
         this.exportItem = new JMenuItem("Export");
         this.generateItem = new JMenuItem("Generiere...");
         this.aboutItem = new JMenuItem("Über das Programm");
@@ -55,8 +58,10 @@ public class MenuBar {
         fileMenu.add(exportItem);
 
         toolsMenu.add(generateItem);
+        toolsMenu.add(importPicture);
         toolsMenu.add(evaluateItem);
 
+
         aboutMenu.add(aboutItem);
 
         menuBar.add(fileMenu);
@@ -79,6 +84,8 @@ public class MenuBar {
                 dialog.setVisible(true);
             });
         });
+        this.importPicture.addActionListener(new PictureImportListener((Presenter) view.getPresenter(), view));
+
     }
 
     public JMenuBar getMenuBar() {

LinearRegressionTool/src/main/java/view/listener/PictureImportListener.java

@@ -0,0 +1,50 @@
+package view.listener;
+
+import presenter.Presenter;
+
+import javax.swing.*;
+import javax.swing.filechooser.FileNameExtensionFilter;
+import javax.swing.filechooser.FileSystemView;
+import java.awt.*;
+import java.awt.event.ActionEvent;
+import java.awt.event.ActionListener;
+import java.io.File;
+
+/**
+ * Implementierung verschiedener Algorithmen zur Berechnung von Ausgleichsgeraden.
+ *
+ * @Author: Armin Wolf
+ * @Email: a_wolf28@uni-muenster.de
+ * @Date: 17.09.2017.
+ */
+public class PictureImportListener implements ActionListener {
+    private Presenter presenter;
+    private Container component;
+
+    public PictureImportListener(Presenter presenter, Container component) {
+        this.presenter = presenter;
+        this.component = component;
+    }
+
+    @Override
+    public void actionPerformed(ActionEvent e) {
+        SwingUtilities.invokeLater(() -> {
+            File file = null;
+            JFileChooser chooser = new JFileChooser(FileSystemView.getFileSystemView().getHomeDirectory());
+            chooser.setPreferredSize(new Dimension(800, 700));
+            chooser.setFileFilter(new FileNameExtensionFilter("Bilder", "tiff", "png","jpg","jpeg"));
+
+            chooser.setMultiSelectionEnabled(false);
+            chooser.setFileSelectionMode(JFileChooser.FILES_ONLY);
+
+
+            if (chooser.showOpenDialog(component) == JFileChooser.APPROVE_OPTION) {
+                //System.out.println ("Datei "+chooser.getSelectedFile()+ " ausgewählt.");
+                file = chooser.getSelectedFile();
+                final File input = file;
+                Thread t = new Thread(() -> presenter.startPictureDataImport(input));
+                t.start();
+            }
+        });
+    }
+}