gui anpassungen

src/main/java/Model/Line.java

@@ -49,6 +49,7 @@ public class Line {
 
         this.m = (y2 -y1)/(x2-x1);
         this.b = y2 - (x2 * m);
+
     }
 
     public double getM() {

src/main/java/Presenter/Algorithms/Algorithm.java

@@ -1,5 +1,7 @@
 package Presenter.Algorithms;
 
+import java.util.Observable;
+
 /**
  * Implementierung verschiedener Algorithmen zur Berechnung von Ausgleichsgeraden.
  *
@@ -7,7 +9,7 @@ package Presenter.Algorithms;
  * @Email: a_wolf28@uni-muenster.de
  * @Date: 28.05.2017.
  */
-public abstract class Algorithm {
+public interface Algorithm {
 
 
 }

src/main/java/Presenter/Algorithms/LeastMedianOfSquaresEstimator.java

@@ -2,8 +2,13 @@ package Presenter.Algorithms;
 
 import Model.Line;
 import Model.Point;
+import Presenter.Presenter;
+import View.MainFrame;
+import javafx.beans.*;
+import sun.applet.Main;
 
 import java.util.*;
+import java.util.Observable;
 
 /**
  * Implementierung verschiedener Algorithmen zur Berechnung von Ausgleichsgeraden.
@@ -12,9 +17,11 @@ import java.util.*;
  * @Email: a_wolf28@uni-muenster.de
  * @Date: 28.05.2017.
  */
-public class LeastMedianOfSquaresEstimator extends Algorithm {
+public class LeastMedianOfSquaresEstimator extends Observable implements Algorithm {
 
 
+    private Presenter presenter;
+
     private LinkedList<Line> set = new LinkedList<>();
     private LinkedList<Point> intersections = new LinkedList<>();
     private int n;
@@ -26,7 +33,21 @@ public class LeastMedianOfSquaresEstimator extends Algorithm {
     private Slab subSlabU2;
     private Line sigmaMin;
     private double heightsigmaMin;
-    private double intersectionsPoint;
+    private Double intersectionsPoint;
+
+    public LeastMedianOfSquaresEstimator(LinkedList<Line> set, LinkedList<Point> intersections, Presenter presenter) {
+        this.set = set;
+        this.intersections = intersections;
+
+        //(1.) Let n <- |S|; q+ <- q; q- <- q+ * (1 - quantileError);....
+        n = set.size();
+        double quantile = 0.5;
+        double qPlus = quantile;
+        double qMinus = qPlus * (1 - quantileError);
+        kMinus = (int) Math.ceil(n * qMinus);
+        kPlus = (int) Math.ceil(n * qPlus);
+        this.presenter = presenter;
+    }
 
     public LeastMedianOfSquaresEstimator(LinkedList<Line> set, LinkedList<Point> intersections) {
         this.set = set;
@@ -39,6 +60,7 @@ public class LeastMedianOfSquaresEstimator extends Algorithm {
         double qMinus = qPlus * (1 - quantileError);
         kMinus = (int) Math.ceil(n * qMinus);
         kPlus = (int) Math.ceil(n * qPlus);
+
     }
 
     public void printResult(){
@@ -81,20 +103,21 @@ public class LeastMedianOfSquaresEstimator extends Algorithm {
                 int constant = 1;
                 if ((constant * n) >= numberOfIntersections) {
                     sigmaMin = planeSweep(slab);
-                } else {//(c.) otherwise....
+                } else {
-                    //get random intersections point...
+                //(c.) otherwise....
-                    Double randomIntersection = null;
+                // get random intersections point...
                     Collections.shuffle(tmpIntersections, new Random());
-                    for (Point point : tmpIntersections) {
+                    for (int i=0;i<tmpIntersections.size();i++) {
-                        if (point.getX() > slab.getLower() && point.getX() < slab.getUpper()) {
+                        if (tmpIntersections.get(i).getX() > slab.getLower() && tmpIntersections.get(i).getX() < slab.getUpper()) {
-                            randomIntersection = point.getX();
+                            intersectionsPoint = tmpIntersections.get(i).getX();
                             break;
+                        } else {
+                            intersectionsPoint = null;
                         }
                     }
 
-                    if (randomIntersection != null){
+                    if (intersectionsPoint != null){
-                        splitActiveSlab(randomIntersection, slab);
+                        splitActiveSlab(intersectionsPoint, slab);
-
                         //(d.) this may update sigma min
                         upperBound(intersectionsPoint);
                         //(e.) for i={1,2}, call lower bound(Ui)
@@ -107,15 +130,22 @@ public class LeastMedianOfSquaresEstimator extends Algorithm {
                         if (subSlabU2.getActivity()){
                             this.slabs.add(subSlabU2);
                         }
+
                     } else {
                         this.slabs.poll();
                     }
                 }
+
+
             } else {
                 this.slabs.remove(slab);
             }
-
+        }
-
+        if (presenter != null){
+            setChanged();
+            double m = (getSigmaMin().getX2() + getSigmaMin().getX1()) * 0.5;
+            double b = (getSigmaMin().getY2() + getSigmaMin().getY1()) * 0.5;
+            notifyObservers(new Line(m,b));
         }
     }
 
@@ -220,7 +250,7 @@ public class LeastMedianOfSquaresEstimator extends Algorithm {
      * @param point x Koordinate an der, der Split geschieht.
      */
     public void splitActiveSlab(double point, Slab active) {
-        subSlabU1 = new Slab(active.getLower(), point);
+        subSlabU1 = new Slab(active.getLower()+0.01, point);
         subSlabU2 = new Slab(point, active.getUpper());
 
         this.slabs.remove(active);

src/main/java/Presenter/Algorithms/RepeatedMedianEstimator.java

@@ -7,5 +7,5 @@ package Presenter.Algorithms;
  * @Email: a_wolf28@uni-muenster.de
  * @Date: 28.05.2017.
  */
-public class RepeatedMedianEstimator extends Algorithm {
+public class RepeatedMedianEstimator implements Algorithm {
 }

src/main/java/Presenter/Algorithms/TheilSenEstimator.java

@@ -7,5 +7,5 @@ package Presenter.Algorithms;
  * @Email: a_wolf28@uni-muenster.de
  * @Date: 28.05.2017.
  */
-public class TheilSenEstimator extends Algorithm {
+public class TheilSenEstimator implements Algorithm {
 }

src/main/java/Presenter/Presenter.java

@@ -6,9 +6,11 @@ import Model.Point;
 import Presenter.Algorithms.LeastMedianOfSquaresEstimator;
 import View.MainFrame;
 
-import java.util.Collections;
+import javax.swing.*;
 import java.util.LinkedList;
 import java.util.List;
+import java.util.Observable;
+import java.util.Observer;
 
 
 /**
@@ -18,11 +20,12 @@ import java.util.List;
  * @Email: a_wolf28@uni-muenster.de
  * @Date: 28.05.2017.
  */
-public class Presenter {
+public class Presenter implements Observer {
 
     private Arrangement model;
     private MainFrame view;
 
+    private LeastMedianOfSquaresEstimator lms;
 
     private Double max;
     private Double min;
@@ -36,8 +39,8 @@ public class Presenter {
         Double[] y = {18d,26d,30d,40d,70d};
 //        Double[] x = {1d,3d,4d,5d,8d};
 //        Double[] y = {4d,2d,1d,0d,0d};
-        view.logHeading("Dualen Geraden");
+        view.logHeading("Duale Darstellung der Punkte als Geraden:");
-        for (int j = 0; j < 5; j++) {
+        for (int j = 0; j < x.length; j++) {
             Line p = new Line(x[j], y[j]);
             view.log("f(x) = " + p.getM() + "x + " + p.getB());
             this.model.addLine(p);
@@ -55,62 +58,39 @@ public class Presenter {
             rowEntry.add(p.getY().toString());
             rows.add(rowEntry);
         }
-        view.logHeading("Koordinaten der Punkte");
+        view.logHeading("Schnittpunkte der Dualen Geraden:");
         view.createTable(heading, rows);
-        view.logSuccess("Berechnung wurde Erfolgreich durchgeführt");
 
-        Thread thread = new Thread(() -> {
+
-            LeastMedianOfSquaresEstimator lms = new LeastMedianOfSquaresEstimator(model.getLines(), model.getNodes());
+
-            lms.approximateLMS();
-        });
-        thread.start();
     }
 
+
+    @Override
+    public void update(Observable o, Object arg) {
+        Line result = ((Line) arg);
+        SwingUtilities.invokeLater(()->{
+            getView().createPlot(result.getM(), result.getB());
+            getView().setLmsIsComplete(true);
+            getView().getPlotButton().setEnabled(true);
+            getView().logSuccess("Berechnung wurde Erfolgreich durchgeführt");
+            getView().log("m: "+result.getM()+"   b: "+result.getB());
+        });
+
+    }
+
+
     public void startArrangementVisualization() {
         view.createArrangement();
     }
 
     public void startScatterPlotVisualization() {
-        view.createPlot();
+        lms = new LeastMedianOfSquaresEstimator(model.getLines(), model.getNodes(), this);
+        lms.addObserver(this);
+        lms.approximateLMS();
     }
 
 
-
-    private void convertCoordinates() {
-        LinkedList<Double> xCoordinates = new LinkedList<>();
-        LinkedList<Double> yCoordinates = new LinkedList<>();
-
-        for (Point point : model.getNodes()) {
-            xCoordinates.add(point.getX());
-            yCoordinates.add(point.getY());
-        }
-
-        Collections.sort(xCoordinates);
-        Collections.sort(yCoordinates);
-
-        double xmin, xmax;
-        double ymin, ymax;
-
-        xmin = xCoordinates.getFirst();
-        xmax = xCoordinates.getLast();
-        ymin = yCoordinates.getFirst();
-        ymax = yCoordinates.getLast();
-
-
-//        for (Point p : model.getNodes()) {
-//            p.setX(scale(p.getX(), xmin, xmax, 0, 700));
-//            p.setY(scale(p.getY(), ymin, ymax, 0, 700));
-//        }
-    }
-
-    public double scale(double x, double old_min, double old_max, double new_min, double new_max){
-        double old_range = Math.abs(old_max - old_min);
-        double new_range = Math.abs(new_max - new_min);
-        double ret = new_min + ((x - old_min) * Math.abs(new_range / old_range));
-        System.out.println("Old Range: "+old_range+"\t New Range: "+new_range+"\t ret: "+ret);
-        return ret;
-    }
-
     public Point calcIntersection(Line a, Line b) {
         Line p1 = a;
         Line p2 = b;
@@ -122,18 +102,17 @@ public class Presenter {
     }
 
     public void calcArrangementNodes() {
-        Thread thread = new Thread(() -> {
+        try {
-            for (int i = 0; i < getLines().size(); i++) {
+            Thread thread = new Thread(() -> {
-                for (int j = i; j < getLines().size(); j++) {
+                for (int i = 0; i < getLines().size(); i++) {
-                    if (i != j){
+                    for (int j = i; j < getLines().size(); j++) {
-                        model.addNode(calcIntersection(getLines().get(j), getLines().get(i)));
+                        if (i != j){
+                            model.addNode(calcIntersection(getLines().get(j), getLines().get(i)));
+                        }
                     }
                 }
-            }
+            });
-            convertCoordinates();
+            thread.start();
-        });
-        thread.start();
-        try {
             thread.join();
         } catch (InterruptedException e) {
             e.printStackTrace();

src/main/java/View/ArrangementDialog.java

@@ -1,5 +1,6 @@
 package View;
 
+import Model.Line;
 import Model.Point;
 import org.jfree.chart.ChartFactory;
 import org.jfree.chart.ChartPanel;
@@ -10,8 +11,11 @@ import org.jfree.chart.plot.XYPlot;
 import org.jfree.chart.renderer.xy.XYLineAndShapeRenderer;
 import org.jfree.data.xy.XYSeries;
 import org.jfree.data.xy.XYSeriesCollection;
+import org.jfree.util.ShapeUtilities;
 
 import javax.swing.*;
+import javax.swing.event.ChangeEvent;
+import javax.swing.event.ChangeListener;
 import java.awt.*;
 import java.util.LinkedList;
 
@@ -24,24 +28,29 @@ import java.util.LinkedList;
  */
 public class ArrangementDialog extends JPanel {
 
-    private LinkedList<Point> lines;
+    private LinkedList<LinkedList<Point>> lines;
     private LinkedList<Point> points;
     private double max;
     private double min;
     private JFreeChart chart;
     private ChartPanel panel;
+    private JSlider hslider;
+    private JSlider vslider;
     private double domainMin, domainMax;
     private double rangeMin, rangeMax;
+    private ValueAxis domain;
+    private ValueAxis range;
 
     public ArrangementDialog() {
         super();
-        this.setPreferredSize(new Dimension(800, 500));
+        this.setPreferredSize(new Dimension(800, 800));
-        this.setMinimumSize(new Dimension(800, 500));
+        this.setMinimumSize(new Dimension(800, 800));
+        this.setLayout(new BorderLayout());
+        this.vslider = new JSlider(SwingConstants.VERTICAL,1,100,50);
+        this.hslider = new JSlider(SwingConstants.HORIZONTAL,10,1000,500);
     }
 
-    public void setPrameters(Double pmax, Double pmin, LinkedList<Point> lines, LinkedList<Point> points) {
+    public void setPrameters(LinkedList<LinkedList<Point>> lines, LinkedList<Point> points) {
-        this.max = pmax;
-        this.min = pmin;
         this.lines = lines;
         this.points = points;
         this.domainMin = Double.MAX_VALUE;
@@ -53,10 +62,10 @@ public class ArrangementDialog extends JPanel {
     public void createArrangement() {
         XYSeriesCollection dataset = new XYSeriesCollection();
 
-        for (Point p : lines) {
+        for (LinkedList<Point> p : lines) {
-            XYSeries series = new XYSeries(p.getX() + p.getY());
+            XYSeries series = new XYSeries(p.get(0).getX() + p.get(0).getY());
-            series.add((-1 * this.max), (((-1 * this.max) * p.getX()) + p.getY()));
+            series.add(p.get(0).getX(), p.get(0).getY());
-            series.add(this.max, ((this.max * p.getX()) + p.getY()));
+            series.add(p.get(1).getX(), p.get(1).getY());
             dataset.addSeries(series);
         }
 
@@ -73,24 +82,68 @@ public class ArrangementDialog extends JPanel {
         chart = ChartFactory.createXYLineChart(
                 null, null, null, dataset,
                 PlotOrientation.HORIZONTAL, false, false, false);
+        chart.setRenderingHints( new RenderingHints( RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON ) );
+        chart.setAntiAlias(true);
 
         final XYPlot plot = chart.getXYPlot();
-        ValueAxis domain = plot.getDomainAxis();
+
-        ValueAxis range = plot.getRangeAxis();
+        domain = plot.getDomainAxis();
+        range  = plot.getRangeAxis();
 
         domain.setRange(domainMin - 1, domainMax + 1);
-        range.setRange(rangeMin - 1, rangeMax +
+        range.setRange(rangeMin - 1, rangeMax + 1);
-                1);
         plot.setBackgroundPaint(Color.WHITE);
         plot.setDomainGridlinePaint(Color.white);
         plot.setRangeGridlinePaint(Color.white);
 
+
+
         final XYLineAndShapeRenderer renderer = new XYLineAndShapeRenderer();
         renderer.setSeriesLinesVisible(dataset.indexOf(intersections), false);
         plot.setRenderer(renderer);
 
+        for (int i=0;i<lines.size();i++){
+            // Setze die Shapes für die Schnittpunkte
+            renderer.setSeriesPaint(i, Color.BLUE);
+            renderer.setBaseSeriesVisible(true);
+        }
+
+        Shape shape = ShapeUtilities.createDiagonalCross(4,1);
+        renderer.setSeriesPaint(lines.size(), Color.BLACK);
+        renderer.setSeriesShape(lines.size(), shape);
+
         panel = new ChartPanel(chart);
-        this.add(panel);
+        panel.setPreferredSize(new Dimension(800, 800));
+
+        addListener();
+
+        this.add(panel, BorderLayout.CENTER);
+        this.add(hslider, BorderLayout.SOUTH);
+        this.add(vslider, BorderLayout.EAST);
+    }
+
+    private void addListener(){
+        this.vslider.addChangeListener(e -> {
+            JSlider slider = (JSlider) e.getSource();
+            double delta = Math.abs(slider.getValue() - 50) * 0.1;
+            if (slider.getValue() < 50){
+                domain.setRange(domainMin - delta, domainMax - delta);
+            } else {
+                domain.setRange(domainMin + delta, domainMax + delta);
+            }
+        });
+
+        this.hslider.addChangeListener(e -> {
+            JSlider slider = (JSlider) e.getSource();
+            double delta = Math.abs(slider.getValue() - 500);
+
+            if (slider.getValue() < 500){
+                range.setRange(rangeMin - delta, rangeMax - delta);
+            } else {
+                range.setRange(rangeMin + delta, rangeMax + delta);
+            }
+        });
+
     }
 
 

src/main/java/View/MainFrame.java

@@ -1,13 +1,21 @@
 package View;
 
 
+import Model.Line;
+import Presenter.Algorithms.LeastMedianOfSquaresEstimator;
 import Presenter.Presenter;
+import com.sun.org.apache.xpath.internal.operations.Bool;
+import jdk.nashorn.internal.scripts.JO;
 
 import javax.swing.*;
 import javax.swing.event.ChangeEvent;
 import javax.swing.event.ChangeListener;
 import java.awt.*;
+import java.awt.event.ActionEvent;
+import java.awt.event.ActionListener;
 import java.util.List;
+import java.util.Observable;
+import java.util.Observer;
 
 /**
  * Implementierung verschiedener Algorithmen zur Berechnung von Ausgleichsgeraden.
@@ -16,16 +24,19 @@ import java.util.List;
  * @Email: a_wolf28@uni-muenster.de
  * @Date: 28.05.2017.
  */
-public class MainFrame extends JFrame {
+public class MainFrame extends JFrame{
 
     private Presenter presenter;
+    private Boolean lmsIsComplete = false;
+    private Boolean rmIsComplete = false;
+    private Boolean tsIsComplete = false;
+
 
     //TODO refactoring
     private JButton arrangementButton;
     private JButton plotButton;
     private JButton button3;
     private JPanel pane;
-    private JSlider slider;
     private JDialog arrangementDialog;
     private JDialog plotDialog;
     private OutputPanel output;
@@ -33,7 +44,8 @@ public class MainFrame extends JFrame {
     private JPanel sidepanel;
     private JSplitPane splitpane;
     private JScrollPane scrollPane;
-    private ArrangementDialog2 arrangement;
+    private ArrangementDialog arrangement;
+    private JTabbedPane tabbedPane;
     private PlotDialog plot;
 
     public MainFrame() {
@@ -54,43 +66,30 @@ public class MainFrame extends JFrame {
 
     public void createArrangement() {
         if (arrangement == null) {
-            arrangement = new ArrangementDialog2();
+            arrangement = new ArrangementDialog();
             arrangement.setPrameters(getPresenter().calcArrangementLines(), getPresenter().getModel().getNodes());
-         //   arrangement.createArrangement();
+            arrangement.createArrangement();
-            SwingUtilities.invokeLater(new Runnable() {
+            SwingUtilities.invokeLater(() -> {
-                @Override
+                arrangementDialog.add(arrangement, BorderLayout.CENTER);
-                public void run() {
+                arrangementDialog.setVisible(true);
-                    arrangementDialog.add(arrangement, BorderLayout.CENTER);
-                    arrangementDialog.add(slider, BorderLayout.SOUTH);
-                    arrangementDialog.setVisible(true);
-                }
             });
         } else {
             arrangementDialog.setVisible(true);
         }
     }
 
-    public void createLine() {
-        //TODO
-    }
 
-    public void createPlot() {
+    public void createPlot(double m, double b) {
-        if (plot == null) {
             plot = new PlotDialog();
-            plot.createPlot(getPresenter().getLines());
+            SwingUtilities.invokeLater(() -> {
-            SwingUtilities.invokeLater(new Runnable() {
+                plot.createPlot(getPresenter().getLines());
-                @Override
+                plot.addLineToPlot(m, b);
-                public void run() {
+                plotDialog.add(plot);
-                    plotDialog.add(plot);
+                plotDialog.setVisible(true);
-                    plotDialog.setVisible(true);
-                }
             });
-        } else {
-            plotDialog.setVisible(true);
-        }
     }
 
-
+    /******************************************************************************************************************/
     /**
      * init GUI
      */
@@ -104,37 +103,17 @@ public class MainFrame extends JFrame {
         pane.setLayout(new FlowLayout());
 
         menupanel = new MenuPanel();
+        tabbedPane = new JTabbedPane();
 
         arrangementDialog = new JDialog();
         plotDialog = new JDialog();
         arrangementDialog.setSize(new Dimension(800, 800));
         plotDialog.setSize(new Dimension(700, 470));
-        arrangementDialog.setTitle("Arrangement Dialog");
+        arrangementDialog.setTitle("Dual Representation - Dialog");
-        plotDialog.setTitle("Scatter Plot Dialog");
+        plotDialog.setTitle("Scatter Plot - Dialog");
         arrangementDialog.setDefaultCloseOperation(JDialog.HIDE_ON_CLOSE);
         plotDialog.setDefaultCloseOperation(JDialog.HIDE_ON_CLOSE);
 
-        this.slider = new JSlider(JSlider.HORIZONTAL, 10, 300, 10);
-        this.slider.addChangeListener(new ChangeListener() {
-            @Override
-            public void stateChanged(ChangeEvent e) {
-                SwingUtilities.invokeLater(new Runnable() {
-                    @Override
-                    public void run() {
-                        JSlider source = (JSlider) e.getSource();
-                        arrangement.setScale((double) source.getValue() / 10);
-                        int thicknes = 50 / source.getValue();
-                        if (thicknes == 0) {
-                            arrangement.setPointThicknes(1);
-                        } else {
-                            arrangement.setPointThicknes(thicknes);
-                        }
-                        arrangement.repaint();
-                        arrangement.validate();
-                    }
-                });
-            }
-        });
 
 
         output = new OutputPanel();
@@ -147,31 +126,39 @@ public class MainFrame extends JFrame {
         plotButton = new JButton("Plot");
         button3 = new JButton("Import");
 
-        arrangementButton.addActionListener(e -> getPresenter().startArrangementVisualization());
 
-        plotButton.addActionListener(e -> getPresenter().startScatterPlotVisualization());
+        arrangementButton.addActionListener((ActionEvent e) -> {
-
+            Thread t = new Thread(() -> getPresenter().startArrangementVisualization());
-        button3.addActionListener(e -> log("Lorem ipsum dolor sit amet, consetetur sadipscing elitr, sed diam nonumy eirmod tempor invidunt ut labore et dolore magna aliquyam erat, sed diam voluptua. At vero eos et accusam et justo duo dolores et ea rebum. Stet clita kasd gubergren, no sea takimata sanctus est Lorem ipsum dolor sit amet. Lorem ipsum dolor sit amet, consetetur sadipscing elitr, sed diam nonumy eirmod tempor invidunt ut labore et dolore magna aliquyam erat, sed diam voluptua. At vero eos et accusam et justo duo dolores et ea rebum. Stet clita kasd gubergren, no sea takimata sanctus est Lorem ipsum dolor sit amet. Lorem ipsum dolor sit amet, consetetur sadipscing elitr, sed diam nonumy eirmod tempor invidunt ut labore et dolore magna aliquyam erat, sed diam voluptua. At vero eos et accusam et justo duo dolores et ea rebum. Stet clita kasd gubergren, no sea takimata sanctus est Lorem ipsum dolor sit amet.   \n" +
+            t.start();
-                "\n" +
+        });
-                "Duis autem vel eum iriure dolor in hendrerit in vulputate velit esse molestie consequat, vel illum dolore eu feugiat nulla facilisis at vero eros et accumsan et iusto odio dignissim qui blandit praesent luptatum zzril delenit augue duis dolore te feugait nulla facilisi. Lorem ipsum dolor sit amet,"));
+        plotButton.addActionListener((ActionEvent e) -> {
+            plotButton.setEnabled(false);
+            Thread t = new Thread(() -> getPresenter().startScatterPlotVisualization());
+            t.start();
+        });
 
         pane.add(arrangementButton);
         pane.add(plotButton);
         pane.add(button3);
+        tabbedPane.add("LMS", sidepanel);
+        tabbedPane.add("RM", new JPanel());
+        tabbedPane.add("TS", new JPanel());
+
         splitpane.setOrientation(JSplitPane.HORIZONTAL_SPLIT);
         splitpane.setResizeWeight(.5d);
         splitpane.setContinuousLayout(true);
         splitpane.setLeftComponent(output);
-        splitpane.setRightComponent(sidepanel);
+        splitpane.setRightComponent(tabbedPane);
         this.add(pane, BorderLayout.SOUTH);
         this.add(splitpane, BorderLayout.CENTER);
         this.add(menupanel, BorderLayout.NORTH);
-//        this.add(output, BorderLayout.CENTER);
-//        this.add(sidepanel, BorderLayout.EAST);
         this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
         this.setVisible(true);
     }
 
+
+
+    /******************************************************************************************************************/
     /**
      * log Methode
      */
@@ -196,5 +183,129 @@ public class MainFrame extends JFrame {
         SwingUtilities.invokeLater(() -> output.logTable(heading, rows));
     }
 
+    /******************************************************************************************************************/
+    /**
+     * Getter und Setter Methoden!
+     */
 
+    public Boolean getLmsIsComplete() {
+        return lmsIsComplete;
+    }
+
+    public void setLmsIsComplete(Boolean lmsIsComplete) {
+        this.lmsIsComplete = lmsIsComplete;
+    }
+
+    public Boolean getRmIsComplete() {
+        return rmIsComplete;
+    }
+
+    public void setRmIsComplete(Boolean rmIsComplete) {
+        this.rmIsComplete = rmIsComplete;
+    }
+
+    public Boolean getTsIsComplete() {
+        return tsIsComplete;
+    }
+
+    public void setTsIsComplete(Boolean tsIsComplete) {
+        this.tsIsComplete = tsIsComplete;
+    }
+
+    public JButton getArrangementButton() {
+        return arrangementButton;
+    }
+
+    public void setArrangementButton(JButton arrangementButton) {
+        this.arrangementButton = arrangementButton;
+    }
+
+    public JButton getPlotButton() {
+        return plotButton;
+    }
+
+    public void setPlotButton(JButton plotButton) {
+        this.plotButton = plotButton;
+    }
+
+    public JButton getButton3() {
+        return button3;
+    }
+
+    public void setButton3(JButton button3) {
+        this.button3 = button3;
+    }
+
+    public JPanel getPane() {
+        return pane;
+    }
+
+    public void setPane(JPanel pane) {
+        this.pane = pane;
+    }
+
+    public JDialog getArrangementDialog() {
+        return arrangementDialog;
+    }
+
+    public void setArrangementDialog(JDialog arrangementDialog) {
+        this.arrangementDialog = arrangementDialog;
+    }
+
+    public JDialog getPlotDialog() {
+        return plotDialog;
+    }
+
+    public void setPlotDialog(JDialog plotDialog) {
+        this.plotDialog = plotDialog;
+    }
+
+    public OutputPanel getOutput() {
+        return output;
+    }
+
+    public void setOutput(OutputPanel output) {
+        this.output = output;
+    }
+
+    public JPanel getMenupanel() {
+        return menupanel;
+    }
+
+    public void setMenupanel(JPanel menupanel) {
+        this.menupanel = menupanel;
+    }
+
+    public JPanel getSidepanel() {
+        return sidepanel;
+    }
+
+    public void setSidepanel(JPanel sidepanel) {
+        this.sidepanel = sidepanel;
+    }
+
+    public JSplitPane getSplitpane() {
+        return splitpane;
+    }
+
+    public void setSplitpane(JSplitPane splitpane) {
+        this.splitpane = splitpane;
+    }
+
+    public JScrollPane getScrollPane() {
+        return scrollPane;
+    }
+
+    public void setScrollPane(JScrollPane scrollPane) {
+        this.scrollPane = scrollPane;
+    }
+
+
+    public PlotDialog getPlot() {
+        return plot;
+    }
+
+    public void setPlot(PlotDialog plot) {
+        this.plot = plot;
+    }
 }

src/main/java/View/MenuPanel.java

@@ -2,6 +2,8 @@ package View;
 
 import javax.swing.*;
 import java.awt.*;
+import java.awt.event.ActionEvent;
+import java.awt.event.ActionListener;
 
 /**
  * Implementierung verschiedener Algorithmen zur Berechnung von Ausgleichsgeraden.
@@ -20,8 +22,9 @@ public class MenuPanel extends JPanel {
         this.setLayout(new BorderLayout());
         this.menuBar = new JMenuBar();
         this.menu = new JMenu("File");
-        this.item = new JMenuItem("Exit");
 
+        this.item = new JMenuItem("Exit");
+        this.item.addActionListener(e -> { System.exit(0);});
 
         menu.add(item);
         menuBar.add(menu);

src/main/java/View/PlotDialog.java

@@ -8,12 +8,15 @@ import org.jfree.chart.JFreeChart;
 import org.jfree.chart.plot.PlotOrientation;
 import org.jfree.chart.plot.XYPlot;
 import org.jfree.chart.renderer.xy.XYItemRenderer;
+import org.jfree.chart.renderer.xy.XYLineAndShapeRenderer;
 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;
 
 /**
@@ -29,24 +32,29 @@ public class PlotDialog extends JPanel {
     private ChartPanel panel;
     private XYSeriesCollection datapoints;
     private XYSeries series;
+    private XYSeries linesA, linesB;
+    private Double min;
+    private Double max;
 
     public PlotDialog() {
         super();
         this.setPreferredSize(new Dimension(800, 500));
         this.setMinimumSize(new Dimension(800, 500));
+        this.setLayout(new BorderLayout());
     }
 
     public void createPlot(LinkedList<Line> points) {
 
-        Thread thread = new Thread(() -> convertData(points));
-        thread.start();
         try {
+            Thread thread = new Thread(() -> convertData(points));
+            thread.start();
             thread.join();
         } catch (InterruptedException e) {
             e.printStackTrace();
         }
 
-        chart = ChartFactory.createScatterPlot("",
+        //createScatterPlot
+        chart = ChartFactory.createXYLineChart("",
                 "X", "Y", datapoints, PlotOrientation.VERTICAL, false, true, false);
         Shape diamond = ShapeUtilities.createDiamond(2f);
         chart.setBorderVisible(false);
@@ -57,29 +65,54 @@ public class PlotDialog extends JPanel {
         xyPlot.setDomainCrosshairVisible(true);
         xyPlot.setRangeCrosshairVisible(true);
 
-        XYItemRenderer renderer = xyPlot.getRenderer();
+        XYLineAndShapeRenderer renderer = (XYLineAndShapeRenderer) xyPlot.getRenderer();
+        renderer.setSeriesLinesVisible(0,false);
+        renderer.setSeriesShapesVisible(0, true);
+        renderer.setSeriesLinesVisible(1,true);
+        renderer.setSeriesLinesVisible(2,true);
+
         renderer.setSeriesPaint(0, Color.blue);
         renderer.setSeriesShape(0, diamond);
 
+
+        renderer.setSeriesPaint(1, Color.red);
+        renderer.setSeriesShape(1, diamond);
+        renderer.setSeriesStroke(1,new BasicStroke(2.0f));
+        renderer.setBaseSeriesVisible(true);
+
+        renderer.setSeriesPaint(2, Color.GREEN);
+        renderer.setSeriesShape(2, diamond);
+        renderer.setSeriesStroke(2,new BasicStroke(2.0f));
+        renderer.setBaseSeriesVisible(true);
+
         xyPlot.setDomainCrosshairVisible(true);
         xyPlot.setRangeCrosshairVisible(true);
 
         panel = new ChartPanel(chart);
-        this.add(panel);
+        this.add(panel, BorderLayout.CENTER);
     }
 
-    public void addLineToPlot() {
+    public void addLineToPlot(double m, double b) {
-        //TODO Line Estimator
+        linesA = new XYSeries("linesA");
+        JOptionPane.showMessageDialog(null, "m: "+m+"         b: "+b);
+        linesA.add(min.intValue(), min.intValue() * (-1) *  m + b );
+        linesA.add(max.intValue(), max.intValue() * (-1) * m + b );
+
+        datapoints.addSeries(linesA);
     }
 
     private void convertData(LinkedList<Line> points) {
 
         datapoints = new XYSeriesCollection();
-        series = new XYSeries("");
+        ArrayList<Double> coordinates = new ArrayList<>();
+        series = new XYSeries("points");
         for (Line p : points) {
             series.add(p.getM(), p.getB());
-        }
+            coordinates.add(p.getM());
 
+        }
+        this.max = Collections.max(coordinates) + 1;
+        this.min = Collections.min(coordinates) - 1;
         datapoints.addSeries(series);
     }
 

src/main/java/View/SidePanel.java

@@ -34,28 +34,31 @@ public class SidePanel extends JPanel {
         gbc.fill = GridBagConstraints.HORIZONTAL;
 
 
+        addElement(0, "Konstante");
+        addElement(1, "Fehler");
+        addElement(2,"Quantile");
 
-        for (int i=0;i<9;i++){
-            this.labels[i] = new JLabel("dummy "+i);
-            this.text[i]   = new JTextField();
-
-            gbc.insets = new Insets(0, 5,0,0);
-            gbc.gridx = 0;
-            gbc.gridy = i;
-            gbc.weightx = 0.05;
-            gbc.weighty = 0.05;
-            continer.add(this.labels[i], gbc);
-
-            gbc.gridx = 1;
-            gbc.gridy = i;
-            gbc.weightx = 0.9;
-            gbc.weighty = 0.05;
-            gbc.insets = new Insets(0, 0,0,5);
-            continer.add(this.text[i], gbc);
-        }
         this.add(continer, BorderLayout.NORTH);
 
-
     }
 
+
+    private void addElement(int row, String name){
+        this.labels[row] = new JLabel(name);
+        this.text[row]   = new JTextField();
+
+        gbc.insets = new Insets(0, 5,0,0);
+        gbc.gridx = 0;
+        gbc.gridy = row;
+        gbc.weightx = 0.05;
+        gbc.weighty = 0.05;
+        continer.add(this.labels[row], gbc);
+
+        gbc.gridx = 1;
+        gbc.gridy = row;
+        gbc.weightx = 0.9;
+        gbc.weighty = 0.05;
+        gbc.insets = new Insets(0, 0,0,5);
+        continer.add(this.text[row], gbc);
+    }
 }