neue icons, export, neue appr. güten

dataset/generiert.csv

@@ -0,0 +1,100 @@
+"0","1.0","16.22119669442887"
+"1","2.0","25.80477124685905"
+"2","3.0","-72.04300006903107"
+"3","4.0","-54.01155546037189"
+"4","5.0","-58.08904821178542"
+"5","6.0","-13.855952715991759"
+"6","7.0","30.410625723721783"
+"7","8.0","-10.637396818815162"
+"8","9.0","4.734973191518623"
+"9","10.0","17.410060576917278"
+"10","11.0","-31.81430974794962"
+"11","12.0","39.27347277802508"
+"12","13.0","47.24504443170598"
+"13","14.0","101.46956641817718"
+"14","15.0","-21.86300061325103"
+"15","16.0","26.89044634787369"
+"16","17.0","67.77465763861309"
+"17","18.0","-9.716251069039245"
+"18","19.0","46.293342087345636"
+"19","20.0","9.94830724469712"
+"20","21.0","-35.1375154989108"
+"21","22.0","44.64267504556884"
+"22","23.0","112.14475732522466"
+"23","24.0","77.83165101191148"
+"24","25.0","54.5757968038933"
+"25","26.0","12.37771696214849"
+"26","27.0","17.153461826476942"
+"27","28.0","41.78209816692834"
+"28","29.0","115.20301484105156"
+"29","30.0","79.44476485619303"
+"30","31.0","59.22199288430279"
+"31","32.0","26.84656479593665"
+"32","33.0","71.50954558155718"
+"33","34.0","-21.796666001073227"
+"34","35.0","83.72299346478545"
+"35","36.0","125.78652143066242"
+"36","37.0","104.09147286594288"
+"37","38.0","8.114092657109154"
+"38","39.0","141.34179545885274"
+"39","40.0","156.06167380483004"
+"40","41.0","162.62724790460692"
+"41","42.0","116.98829941670294"
+"42","43.0","153.02663483434304"
+"43","44.0","119.08295325685637"
+"44","45.0","91.75116533316154"
+"45","46.0","82.09805221793917"
+"46","47.0","121.02799689787233"
+"47","48.0","162.76621387709505"
+"48","49.0","99.67534990947173"
+"49","50.0","102.86707227211184"
+"50","51.0","102.78866286264291"
+"51","52.0","89.18217159450033"
+"52","53.0","81.90236028976297"
+"53","54.0","77.8279511275179"
+"54","55.0","192.77352672997017"
+"55","56.0","76.57669484415533"
+"56","57.0","163.48311393643186"
+"57","58.0","76.41776000032146"
+"58","59.0","201.07871124858988"
+"59","60.0","206.89941103616334"
+"60","61.0","96.35313355593001"
+"61","62.0","92.7900577842275"
+"62","63.0","165.3400269439533"
+"63","64.0","110.54182140513655"
+"64","65.0","108.0286043331365"
+"65","66.0","181.6537633597365"
+"66","67.0","221.7017992677171"
+"67","68.0","104.57683586004656"
+"68","69.0","150.1523684575613"
+"69","70.0","149.69167265549368"
+"70","71.0","142.77484092691068"
+"71","72.0","198.55958856526587"
+"72","73.0","209.5160964076958"
+"73","74.0","93.37118023083491"
+"74","75.0","170.01320959046683"
+"75","76.0","188.41029087779074"
+"76","77.0","97.04625662361508"
+"77","78.0","164.61152689266532"
+"78","79.0","135.86406141133045"
+"79","80.0","227.3958329978388"
+"80","81.0","199.6654242315915"
+"81","82.0","160.3280688871774"
+"82","83.0","191.41740213598078"
+"83","84.0","195.08188636234948"
+"84","85.0","159.66894070672464"
+"85","86.0","172.10801191257485"
+"86","87.0","223.88843060643995"
+"87","88.0","265.3946946905645"
+"88","89.0","102.98357156182095"
+"89","90.0","163.71083795959555"
+"90","91.0","246.89709410320495"
+"91","92.0","113.77849431212871"
+"92","93.0","228.47656531038604"
+"93","94.0","249.3776282516239"
+"94","95.0","235.74765582159455"
+"95","96.0","233.38236835629633"
+"96","97.0","171.04614600098745"
+"97","98.0","249.30640052004117"
+"98","99.0","144.19408210798673"
+"99","100.0","261.25444551792765"

src/main/java/App.java

@@ -1,11 +1,9 @@
 import Model.LineModel;
 import Presenter.Presenter;
 import View.MainFrame;
-import java.awt.Font;
-import javax.swing.JFrame;
-import javax.swing.SwingUtilities;
-import javax.swing.UIManager;
-import javax.swing.UnsupportedLookAndFeelException;
+
+import javax.swing.*;
+import java.awt.*;
 
 /**
  * Implementierung verschiedener Algorithmen zur Berechnung von Ausgleichsgeraden.
@@ -48,6 +46,7 @@ public class App {
   public static void main(String[] args) {
 
     SwingUtilities.invokeLater(() -> {
+      JFrame.setDefaultLookAndFeelDecorated(true);
       MainFrame view = new MainFrame();
       setLookAndFeel(view);
       setUIFont (new javax.swing.plaf.FontUIResource(new Font("Verdana",Font.PLAIN, 12)));

src/main/java/Model/Line.java

@@ -13,13 +13,13 @@ public class Line {
   private final Double MIN = -9999d;
 
 
-  private double m;
-  private double b;
+  private Double m;
+  private Double b;
 
-  private double x1;
-  private double x2;
-  private double y1;
-  private double y2;
+  private Double x1;
+  private Double x2;
+  private Double y1;
+  private Double y2;
 
   private String id;
 
@@ -56,7 +56,7 @@ public class Line {
 
   }
 
-  public double getM() {
+  public Double getM() {
     return m;
   }
 
@@ -64,7 +64,7 @@ public class Line {
     this.m = m;
   }
 
-  public double getB() {
+  public Double getB() {
     return b;
   }
 
@@ -80,19 +80,19 @@ public class Line {
     this.id = id;
   }
 
-  public double getX1() {
+  public Double getX1() {
     return x1;
   }
 
-  public double getX2() {
+  public Double getX2() {
     return x2;
   }
 
-  public double getY1() {
+  public Double getY1() {
     return y1;
   }
 
-  public double getY2() {
+  public Double getY2() {
     return y2;
   }
 

src/main/java/Presenter/Evaluation/EvaluateAlgorithms.java

@@ -25,14 +25,30 @@ public class EvaluateAlgorithms extends Observable {
     private Integer iterationCount;
 
     private LineModel arrangement;
-    private Object[] lmsResult;
-    private Object[] rmResult;
-    private Object[] tsResult;
+    private String[] lmsResult;
+    private String[] rmResult;
+    private String[] tsResult;
+    /*
+        ret.add(mse(errorValues).toString());
+        ret.add(rmse(errorValues).toString());
+        ret.add(mae(errorValues).toString());
+        ret.add(mdae(errorValues).toString());
+
+        ret.add(mape(perrorValues).toString());
+        ret.add(mdape(perrorValues).toString());
+        ret.add(rmspe(perrorValues).toString());
+        ret.add(rmdspe(perrorValues).toString());
+    */
+    private String[] names = {"MSE", "RMSE", "MAE", "MDAE", "MAPE", "MDAPE", "RMSPE", "RMDSPE"};
 
     private Thread lmsThread;
     private Thread rmThread;
     private Thread tsThread;
 
+    private Double[] tsRes = new Double[2];
+    private Double[] rmRes = new Double[2];
+    private Double[] lmsRes = new Double[2];
+
     public EvaluateAlgorithms(Double m, Double b, Integer iterationCount) {
         this.m = m;
         this.b = b;
@@ -71,27 +87,33 @@ public class EvaluateAlgorithms extends Observable {
                 lmsAlg.run();
                 lmsAlg.getResult();
                 List<Double> errors = sampsonError(arrangement.getLines(), lmsAlg.getSlope(), lmsAlg.getyInterception());
-                lmsResult = getResults(errors, "Least Median of Squares");
-                setChanged();
-                notifyObservers(lmsResult);
+                List<Double> perrors = percentigeError(arrangement.getLines(), lmsAlg.getSlope(), lmsAlg.getyInterception());
+
+                lmsRes[0] = lmsAlg.getSlope();
+                lmsRes[1] = lmsAlg.getyInterception();
+                lmsResult = getResults(errors,perrors);
+
             });
             rmThread = new Thread(() -> {
                 RepeatedMedianEstimator rmAlg = new RepeatedMedianEstimator(arrangement.getLines());
                 rmAlg.run();
                 rmAlg.getResult();
                 List<Double> errors = sampsonError(arrangement.getLines(), rmAlg.getSlope(), rmAlg.getyInterception());
-                rmResult = getResults(errors, "Repeated-Median");
-                setChanged();
-                notifyObservers(rmResult);
+                List<Double> perrors = percentigeError(arrangement.getLines(), rmAlg.getSlope(), rmAlg.getyInterception());
+
+                rmRes[0] = rmAlg.getSlope();
+                rmRes[1] = rmAlg.getyInterception();
+                rmResult = getResults(errors,perrors);
             });
             tsThread = new Thread(() -> {
                 TheilSenEstimator tsAlg = new TheilSenEstimator(arrangement.getLines(), arrangement.getNodes());
                 tsAlg.run();
                 tsAlg.getResult();
                 List<Double> errors = sampsonError(arrangement.getLines(), tsAlg.getSlope(), tsAlg.getyInterception());
-                tsResult = getResults(errors, "Theil-Sen");
-                setChanged();
-                notifyObservers(tsResult);
+                List<Double> perrors = percentigeError(arrangement.getLines(), tsAlg.getSlope(), tsAlg.getyInterception());
+                tsRes[0] = tsAlg.getSlope();
+                tsRes[1] = tsAlg.getyInterception();
+                tsResult = getResults(errors,perrors);
             });
 
             lmsThread.start();
@@ -101,20 +123,45 @@ public class EvaluateAlgorithms extends Observable {
             lmsThread.join();
             rmThread.join();
             tsThread.join();
+
+            createGlobalResult();
         }
     }
 
+    public void  createGlobalResult(){
+        ArrayList<String> result = new ArrayList<>();
+        for (int i=0;i<names.length;i++){
+            result.add("eval");
+            result.add(names[i]);
+            result.add(tsResult[i]);
+            result.add(rmResult[i]);
+            result.add(lmsResult[i]);
+            setChanged();
+            notifyObservers(result.stream().toArray(String[]::new));
+            result.clear();
+        }
 
-    public String[] getResults(List<Double> errorValues, String name) {
+        String[] separator = {"eval", "", "", "", ""};
+        setChanged();
+        notifyObservers(separator);
+
+
+    }
+
+
+    public String[] getResults(List<Double> errorValues, List<Double> perrorValues) {
 
         ArrayList<String> ret = new ArrayList<>();
-        ret.add("eval");
-        ret.add(name);
         ret.add(mse(errorValues).toString());
         ret.add(rmse(errorValues).toString());
         ret.add(mae(errorValues).toString());
         ret.add(mdae(errorValues).toString());
 
+        ret.add(mape(perrorValues).toString());
+        ret.add(mdape(perrorValues).toString());
+        ret.add(rmspe(perrorValues).toString());
+        ret.add(rmdspe(perrorValues).toString());
+
 
         return ret.stream().toArray(String[]::new);
     }
@@ -153,6 +200,40 @@ public class EvaluateAlgorithms extends Observable {
     }
 
 
+    /* Percentege Error Approximation Measures */
+    public Double mape(List<Double> errorValues){
+        return mae(errorValues);
+    }
+
+    public Double mdape(List<Double> errorValues){
+        return mape(errorValues);
+    }
+
+    public Double rmspe(List<Double> errorValues){
+        return rmse(errorValues);
+    }
+
+    public Double rmdspe(List<Double> errorValues){
+        ArrayList squares = new ArrayList();
+        for (Double d : errorValues){
+            squares.add(Math.pow(d,2));
+        }
+
+        return  Math.sqrt(FastElementSelector.randomizedSelect(squares, squares.size() * 0.5));
+    }
+
+
+    public List<Double> percentigeError(final LinkedList<Line> lines, Double m, Double b){
+        ArrayList<Double> sampsonError = (ArrayList<Double>) sampsonError(lines, m, b);
+        ArrayList<Double> r = new ArrayList<>();
+
+        for (int j=0;j<sampsonError.size();j++){
+            r.add(100 * sampsonError.get(j) / lines.get(j).getB());
+        }
+
+        return r;
+    }
+
     public List<Double> sampsonError(final LinkedList<Line> lines, Double m, Double b) {
 
         //Liste mit den Fehler zu jedem Punkt

src/main/java/Presenter/Generator/DatasetGenerator.java

@@ -3,6 +3,7 @@ package Presenter.Generator;
 import Model.Line;
 
 import java.util.LinkedList;
+import java.util.Observable;
 import java.util.Random;
 
 /**
@@ -12,7 +13,7 @@ import java.util.Random;
  * @Email: a_wolf28@uni-muenster.de
  * @Date: 01.08.2017.
  */
-public class DatasetGenerator {
+public class DatasetGenerator extends Observable{
 
     private Double m;
     private Double b;
@@ -43,11 +44,15 @@ public class DatasetGenerator {
             double signal = m * i + b;
             signal *= -1;
 
-            Line line = new Line(i, signal - y);
+            Line line = new Line((double) i, signal - y);
             line.setId(i-1+"");
             lines.add(line);
         }
-
+        String[] ret = {"generator","Es wurden "+100+" Daten generiert mit den Parametern",
+                        "</br> <b>m</b> = "+m+"",
+                        "</br> <b>b</b> = "+b+""};
+        setChanged();
+        notifyObservers(ret);
         return lines;
     }
 

src/main/java/Presenter/ImportExport/DataExporter.java

@@ -0,0 +1,53 @@
+package Presenter.ImportExport;
+
+import Model.Line;
+import Model.LineModel;
+import com.opencsv.CSVWriter;
+
+import java.io.File;
+import java.io.FileWriter;
+import java.io.IOException;
+import java.util.Observable;
+
+/**
+ * Implementierung verschiedener Algorithmen zur Berechnung von Ausgleichsgeraden.
+ *
+ * @Author: Armin Wolf
+ * @Email: a_wolf28@uni-muenster.de
+ * @Date: 03.08.2017.
+ */
+public class DataExporter extends Observable{
+
+    private LineModel lineModel;
+    private File file;
+
+    public DataExporter(LineModel model, File file){
+        this.file = file;
+        this.lineModel = model;
+    }
+
+    public void export(){
+        CSVWriter writer = null;
+
+        try {
+            writer = new CSVWriter(new FileWriter(file), ',');
+            // feed in your array (or convert your data to an array)
+            String[] entries = new String[3];
+            for (Line line : lineModel.getLines()){
+                entries[0] = line.getId();
+                entries[1] = line.getM().toString();
+                Double tmp = (-1) * line.getB();
+                entries[2] = tmp.toString();
+                writer.writeNext(entries);
+            }
+            writer.close();
+            String[] ret = {"export","Das aktuelle Modell wurde erfolgreich unter: "+file.getAbsolutePath()+" gespeichert."};
+            setChanged();
+            notifyObservers(ret);
+        } catch (IOException e) {
+            e.printStackTrace();
+        }
+
+    }
+
+}

src/main/java/Presenter/ImportExport/DataImporter.java

@@ -1,4 +1,4 @@
-package Presenter.Import;
+package Presenter.ImportExport;
 
 import Model.LineModel;
 import Model.Line;

src/main/java/Presenter/Presenter.java

@@ -9,7 +9,8 @@ import Presenter.Algorithms.RepeatedMedianEstimator;
 import Presenter.Algorithms.TheilSenEstimator;
 import Presenter.Evaluation.EvaluateAlgorithms;
 import Presenter.Generator.DatasetGenerator;
-import Presenter.Import.DataImporter;
+import Presenter.ImportExport.DataExporter;
+import Presenter.ImportExport.DataImporter;
 import View.MainFrame;
 
 import javax.swing.*;
@@ -38,6 +39,7 @@ public class Presenter implements Observer {
   private Thread rmThread;
   private Thread lmsThread;
   private Thread importThread;
+  private Thread exportThread;
   private Thread generatorThread;
   private Thread evalThread;
 
@@ -114,7 +116,21 @@ public class Presenter implements Observer {
           getView().showImportProgress(progress);
         });
         }
+    }
+    if (result[0] == "export"){
+      SwingUtilities.invokeLater(() -> {
+        getView().logSuccess("Export Erfolgreich");
+        getView().log(result[1]+"<hr>");
+      });
+    }
 
+    if (result[0] == "generator"){
+      SwingUtilities.invokeLater(() -> {
+        getView().logSuccess("Generierung Erfolgreich");
+        getView().log(result[1]);
+        getView().log(result[2]);
+        getView().log(result[3] + "<hr>");
+      });
     }
   }
 
@@ -192,8 +208,6 @@ public class Presenter implements Observer {
    *                                          Hilfsmethoden
    ***************************************************************************************************************************/
   public void setup(){
-    getView().logHeading("Duale Darstellung der Punkte als Geraden:");
-
     //Darstellung der Schnittpunkte in einer Tabelle
         List<String> heading = new LinkedList<>();
         List<List<String>> rows = new LinkedList<>();
@@ -253,10 +267,27 @@ public class Presenter implements Observer {
     }
   }
 
+  public void startExport(File file){
+    if (exportThread == null || !exportThread.isAlive()){
+      exportThread = new Thread(()->{
+        DataExporter exporter = new DataExporter(getModel(), file);
+        exporter.addObserver(this);
+        exporter.export();
+      });
+      exportThread.start();
+      try {
+        exportThread.join();
+      } catch (InterruptedException e) {
+        e.printStackTrace();
+      }
+    }
+  }
+
   public void generateDataset(){
     if (generatorThread == null || !generatorThread.isAlive()){
       generatorThread = new Thread(() -> {
         DatasetGenerator generator = new DatasetGenerator();
+        generator.addObserver(this);
         getModel().setLines(generator.generateDataset());
         calculateIntersections();
         getView().enableFunctionality();

src/main/java/View/MainFrame.java

@@ -31,6 +31,7 @@ public class MainFrame extends JFrame {
   private JButton arrangementButton;
   private JButton importButton;
   private JButton generateButton;
+  private JButton exportButton;
 
   private OutputPanel output;
   private MenuPanel menupanel;
@@ -137,6 +138,12 @@ public class MainFrame extends JFrame {
   public void showEvauluationDialog(){
     if (evaluationPanel == null){
       SwingUtilities.invokeLater(() -> {
+        evaluationDialog = new JDialog();
+        evaluationDialog.setTitle("Evaluation");
+        evaluationDialog.setDefaultCloseOperation(JDialog.DISPOSE_ON_CLOSE);
+        evaluationDialog.setSize(800,500);
+        evaluationDialog.setLocationRelativeTo(null);
+
         evaluationPanel = new EvaluationPanel(this);
         evaluationDialog.add(evaluationPanel);
         evaluationDialog.setVisible(true);
@@ -164,6 +171,7 @@ public class MainFrame extends JFrame {
   private void setTitles() {
     this.setTitle("Algorithmen zur Berechnung von Ausgleichgeraden");
     importButton.setText("Import");
+    exportButton.setText("Export");
     generateButton.setText("Generiere");
     arrangementButton.setText("Dualraum");
   }
@@ -177,7 +185,9 @@ public class MainFrame extends JFrame {
   private void addComponents() {
     pane.add(arrangementButton);
     pane.add(importButton);
+    pane.add(exportButton);
     pane.add(generateButton);
+
     northPanel.add(menupanel);
     northPanel.add(pane);
 
@@ -203,7 +213,6 @@ public class MainFrame extends JFrame {
   private void setCloseOperations() {
     this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
     progressDialog.setDefaultCloseOperation(JDialog.DISPOSE_ON_CLOSE);
-    evaluationDialog.setDefaultCloseOperation(JDialog.DISPOSE_ON_CLOSE);
   }
 
   private void setDimensions() {
@@ -215,7 +224,6 @@ public class MainFrame extends JFrame {
     output.setMinimumSize(new Dimension(400, 500));
     progressDialog.setSize(300, 80);
     progressDialog.setResizable(false);
-    evaluationDialog.setSize(800,500);
   }
 
   private void setLayouts() {
@@ -238,7 +246,6 @@ public class MainFrame extends JFrame {
     progressDialog.setLocationRelativeTo(null);
     progressContent   = progressDialog.getContentPane();
     progressBar = new JProgressBar();
-    evaluationDialog = new JDialog();
 
     //Panes
     tabbedPane = new JTabbedPane();
@@ -249,6 +256,7 @@ public class MainFrame extends JFrame {
     arrangementButton = new JButton();
     importButton = new JButton();
     generateButton = new JButton();
+    exportButton = new JButton();
   }
 
   private void setIcons(){
@@ -257,12 +265,19 @@ public class MainFrame extends JFrame {
       Image imgImport = ImageIO.read(classLoader.getResource("import.png")).getScaledInstance(16,16,Image.SCALE_SMOOTH);
       Image imgPlot   = ImageIO.read(classLoader.getResource("plot.png")).getScaledInstance(16,16,Image.SCALE_SMOOTH);
       Image imgStart  = ImageIO.read(classLoader.getResource("start.png")).getScaledInstance(32,32,Image.SCALE_SMOOTH);
+      Image imgGenerate  = ImageIO.read(classLoader.getResource("generate.png")).getScaledInstance(16,16,Image.SCALE_SMOOTH);
+      Image imgExport  = ImageIO.read(classLoader.getResource("export.png")).getScaledInstance(16,16,Image.SCALE_SMOOTH);
+      Image imgFrame   = ImageIO.read(classLoader.getResource("frame.png")).getScaledInstance(32,23,Image.SCALE_SMOOTH);
+
 
       importButton.setIcon(new ImageIcon(imgImport));
+      exportButton.setIcon(new ImageIcon(imgExport));
+      generateButton.setIcon(new ImageIcon(imgGenerate));
       arrangementButton.setIcon(new ImageIcon(imgPlot));
       lmsPanel.getStartButton().setIcon(new ImageIcon(imgStart));
       rmPanel.getStartButton().setIcon(new ImageIcon(imgStart));
       tsPanel.getStartButton().setIcon(new ImageIcon(imgStart));
+      this.setIconImage(imgFrame);
     } catch (IOException e) {
       e.printStackTrace();
     }
@@ -319,6 +334,29 @@ public class MainFrame extends JFrame {
       });
     });
 
+    exportButton.addActionListener((ActionEvent e)  -> {
+      SwingUtilities.invokeLater(() -> {
+        File file = null;
+        JFileChooser chooser = new JFileChooser();
+        chooser.setPreferredSize(new Dimension(800,700));
+        File workingDirectory = new File(System.getProperty("user.dir"));
+        chooser.setCurrentDirectory(workingDirectory);
+        chooser.setFileFilter(new FileNameExtensionFilter("Comma-Separated Value", "csv", "text"));
+
+        chooser.setMultiSelectionEnabled(false);
+        chooser.setFileSelectionMode(JFileChooser.FILES_ONLY);
+
+
+        if (chooser.showSaveDialog(null) == JFileChooser.APPROVE_OPTION){
+          //System.out.println ("Datei "+chooser.getSelectedFile()+ " ausgewählt.");
+          file = chooser.getSelectedFile();
+          final File input = file;
+          Thread t = new Thread(() -> this.getPresenter().startExport(input));
+          t.start();
+        }
+      });
+    });
+
     generateButton.addActionListener((ActionEvent e) -> {
       SwingUtilities.invokeLater(() -> {
         getPresenter().generateDataset();
@@ -332,6 +370,7 @@ public class MainFrame extends JFrame {
     this.getRmPanel().getStartButton().setEnabled(true);
     this.getTsPanel().getStartButton().setEnabled(true);
     this.getArrangementButton().setEnabled(true);
+    this.getExportButton().setEnabled(true);
   }
 
   public void disableFunctionality(){
@@ -339,6 +378,7 @@ public class MainFrame extends JFrame {
     this.getRmPanel().getStartButton().setEnabled(false);
     this.getTsPanel().getStartButton().setEnabled(false);
     this.getArrangementButton().setEnabled(false);
+    this.getExportButton().setEnabled(false);
   }
 
   /*******************************************************************************************************************
@@ -495,4 +535,12 @@ public class MainFrame extends JFrame {
   public void setTsPanel(TSPanel tsPanel) {
     this.tsPanel = tsPanel;
   }
+
+  public JButton getExportButton() {
+    return exportButton;
+  }
+
+  public void setExportButton(JButton exportButton) {
+    this.exportButton = exportButton;
+  }
 }

src/main/java/View/Panels/EvaluationPanel.java

@@ -69,7 +69,7 @@ public class EvaluationPanel extends JPanel{
             view.getPresenter().stopEvaluation();
         });
 
-        String[] selections = { "Schätzer","MSE", "RMSE", "MAE", "MdAE"};
+        String[] selections = { "Approximationsgüte","Theil-Sen", "Repeated-Median", "Least Median of Squares"};
         model = new DefaultTableModel(){
             @Override
             public boolean isCellEditable(int row, int column) {

src/main/java/View/PlotDialog.java

@@ -1,15 +1,6 @@
 package View;
 
 import Model.Line;
-import java.awt.BasicStroke;
-import java.awt.BorderLayout;
-import java.awt.Color;
-import java.awt.Dimension;
-import java.awt.Shape;
-import java.util.ArrayList;
-import java.util.Collections;
-import java.util.LinkedList;
-import javax.swing.JPanel;
 import org.jfree.chart.ChartFactory;
 import org.jfree.chart.ChartPanel;
 import org.jfree.chart.JFreeChart;
@@ -20,6 +11,12 @@ import org.jfree.data.xy.XYSeries;
 import org.jfree.data.xy.XYSeriesCollection;
 import org.jfree.util.ShapeUtilities;
 
+import javax.swing.*;
+import java.awt.*;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.LinkedList;
+
 /**
  * Implementierung verschiedener Algorithmen zur Berechnung von Ausgleichsgeraden.
  *
@@ -113,7 +110,7 @@ public class PlotDialog extends JPanel {
     ArrayList<Double> coordinates = new ArrayList<>();
     series = new XYSeries("points");
     for (Line p : points) {
-      series.add(p.getM(), p.getB()* (-1));
+      series.add(p.getM().doubleValue(), p.getB().doubleValue() * (-1));
       coordinates.add(p.getM());
 
     }

src/test/java/Presenter/ImportExport/DataImporterTest.java

@@ -1,6 +1,4 @@
-package Presenter.Import;
-
-import static org.junit.Assert.*;
+package Presenter.ImportExport;
 
 import org.junit.Before;
 import org.junit.Test;