diff --git a/LinearRegressionTool/src/main/java/App.java b/LinearRegressionTool/src/main/java/App.java
index 5aaa562..276e00a 100644
--- a/LinearRegressionTool/src/main/java/App.java
+++ b/LinearRegressionTool/src/main/java/App.java
@@ -1,3 +1,4 @@
+import com.sun.java.swing.plaf.windows.WindowsLookAndFeel;
 import model.Line;
 import model.LineModel;
 import nu.pattern.OpenCV;
@@ -26,24 +27,6 @@ import static nu.pattern.OpenCV.loadShared;
  */
 public class App {
 
-    private static void loadLibrary() {
-        try {
-            InputStream in = null;
-            File fileOut = null;
-
-            in = App.class.getResourceAsStream("/libs/x64/opencv_java2413.dll");
-            fileOut = File.createTempFile("tmp", ".dll");
-
-            OutputStream out = new FileOutputStream(fileOut);
-            IOUtils.copy(in, out);
-            in.close();
-            out.close();
-            System.load(fileOut.toString());
-        } catch (Exception e) {
-            throw new RuntimeException("Failed to load opencv native library", e);
-        }
-    }
-
     private static void setUIFont(javax.swing.plaf.FontUIResource f) {
         java.util.Enumeration<Object> keys = UIManager.getDefaults().keys();
         while (keys.hasMoreElements()) {
@@ -60,7 +43,9 @@ public class App {
                 "com.jtattoo.plaf.acryl.AcrylLookAndFeel",
                 "com.jtattoo.plaf.aero.AeroLookAndFeel",
                 "com.jtattoo.plaf.fast.FastLookAndFeel",
-                "com.jtattoo.plaf.graphite.GraphiteLookAndFeel"};
+                "com.jtattoo.plaf.graphite.GraphiteLookAndFeel",
+                "com.jtattoo.plaf.luna.LunaLookAndFeel",
+                "com.jtattoo.plaf.noire.NoireLookAndFeel"};
         try {
             UIManager.setLookAndFeel(laf[4]);
         } catch (ClassNotFoundException e) {
@@ -93,7 +78,7 @@ public class App {
         if (chosen == "Normal"){
         final Presenter presenter = new Presenter(new LineModel(), null);
         SwingUtilities.invokeLater(() -> {
-            JFrame.setDefaultLookAndFeelDecorated(true);
+            //JFrame.setDefaultLookAndFeelDecorated(true);
             MainFrame view = new MainFrame();
             setLookAndFeel(view);
             setUIFont(new javax.swing.plaf.FontUIResource(new Font("Verdana", Font.PLAIN, 12)));
diff --git a/LinearRegressionTool/src/main/java/model/DCEL/DoublyConnectedEdgeList.java b/LinearRegressionTool/src/main/java/model/DCEL/DoublyConnectedEdgeList.java
deleted file mode 100644
index 5c09e02..0000000
--- a/LinearRegressionTool/src/main/java/model/DCEL/DoublyConnectedEdgeList.java
+++ /dev/null
@@ -1,154 +0,0 @@
-package model.DCEL;
-
-
-import model.Point;
-
-import java.util.LinkedList;
-
-/**
- * Implementierung verschiedener Algorithmen zur Berechnung von Ausgleichsgeraden.
- *
- * @Author: Armin Wolf
- * @Email: a_wolf28@uni-muenster.de
- * @Date: 30.05.2017.
- */
-public class DoublyConnectedEdgeList {
-
-    private LinkedList<Node> nodes;
-    private LinkedList<Edge> edges;
-    private LinkedList<Face> faces;
-
-    public DoublyConnectedEdgeList() {
-        this.nodes = new LinkedList<>();
-        this.edges = new LinkedList<>();
-        this.faces = new LinkedList<>();
-    }
-
-    public Node createNode(Point point, String id) {
-
-        Node node = new Node();
-        node.setPoint(point);
-        node.setID(id);
-
-        return node;
-    }
-
-    public Edge createEdge(Node source, Node destination, String id) {
-
-        Edge edge = new Edge();
-        Edge twin = new Edge();
-
-        edge.setOrigin(source);
-        edge.setID(id);
-        edge.setTwin(twin);
-        twin.setOrigin(destination);
-        twin.setID("#" + id);
-        twin.setTwin(edge);
-
-        source.setIncidentEdge(edge);
-        destination.setIncidentEdge(twin);
-
-        return edge;
-    }
-
-    public Face createFace(Edge outerComponent, Edge innerComponent, String id) {
-
-        Face face = new Face(outerComponent, null);
-        face.setID(id);
-        Edge tempEdge;
-
-        if (outerComponent != null) {
-            tempEdge = outerComponent;
-            do {
-                tempEdge.setIncidentFace(face);
-                tempEdge = tempEdge.getNext();
-            } while (!tempEdge.equals(outerComponent));
-        }
-
-        if (innerComponent != null) {
-            LinkedList<Edge> componentlist;
-            componentlist = face.getInnerComponents();
-            componentlist.add(innerComponent);
-            tempEdge = innerComponent;
-            do {
-                tempEdge.setIncidentFace(face);
-                tempEdge = tempEdge.getNext();
-            } while (!tempEdge.equals(innerComponent));
-        }
-
-        return face;
-    }
-
-    public void createConnection(Edge edge, Edge succ) {
-        edge.setNext(succ);
-        succ.setPrev(edge);
-
-        edge.getTwin().setPrev(succ.getTwin());
-        succ.getTwin().setNext(edge.getTwin());
-    }
-
-    public LinkedList<Edge> getEdgesOfInnerComponents(Face face) {
-
-        LinkedList<Edge> list = new LinkedList();
-        LinkedList<Edge> innerComponents = face.getInnerComponents();
-        Edge it;
-        for (Edge e : innerComponents) {
-            it = e;
-            do {
-                list.add(it);
-                //System.out.println("Current Edge: "+it.getID()+"\tNext Edge: "+it.getNext().getID());
-                it = it.getNext();
-            } while (it != e);
-        }
-
-        return list;
-    }
-
-    public LinkedList<Edge> getEdgesOfOuterComponents(Face face) {
-
-        LinkedList<Edge> list = new LinkedList();
-        Edge it = face.getOuterComponent();
-        do {
-            list.add(it);
-            //System.out.println("Current Edge: "+it.getID()+"\tNext Edge: "+it.getNext().getID());
-            it = it.getNext();
-        } while (it != face.getOuterComponent());
-
-        return list;
-    }
-
-
-    public LinkedList<Edge> getConnectedEdges(Node node) {
-        Edge edge = node.getIncidentEdge();
-        LinkedList list = new LinkedList();
-        do {
-            list.add(edge);
-            edge = edge.getNext();
-        } while (node != edge.getOrigin());
-        return list;
-    }
-
-    public LinkedList<Node> getNodes() {
-        return nodes;
-    }
-
-    public void setNodes(LinkedList<Node> nodes) {
-        this.nodes = nodes;
-    }
-
-    public LinkedList<Edge> getEdges() {
-        return edges;
-    }
-
-    public void setEdges(LinkedList<Edge> edges) {
-        this.edges = edges;
-    }
-
-    public LinkedList<Face> getFaces() {
-        return faces;
-    }
-
-    public void setFaces(LinkedList<Face> faces) {
-        this.faces = faces;
-    }
-}
diff --git a/LinearRegressionTool/src/main/java/model/DCEL/Edge.java b/LinearRegressionTool/src/main/java/model/DCEL/Edge.java
deleted file mode 100644
index 8955fdc..0000000
--- a/LinearRegressionTool/src/main/java/model/DCEL/Edge.java
+++ /dev/null
@@ -1,117 +0,0 @@
-package model.DCEL;
-
-/**
- * Implementierung verschiedener Algorithmen zur Berechnung von Ausgleichsgeraden.
- *
- * @Author: Armin Wolf
- * @Email: a_wolf28@uni-muenster.de
- * @Date: 30.05.2017.
- */
-public class Edge {
-
-    private Node origin;
-    private Edge twin;
-    private Face incidentFace;
-    private Edge next;
-    private Edge prev;
-    private String id;
-
-    public Edge() {
-        new Edge(null, null, null, null, null);
-    }
-
-    public Edge(Node origin, Edge twin, Edge next, Edge prev, Face incidentFace) {
-        this.origin = origin;
-        this.twin = twin;
-        this.next = next;
-        this.prev = prev;
-        this.incidentFace = incidentFace;
-    }
-
-    public Node getOrigin() {
-        return origin;
-    }
-
-    public void setOrigin(Node origin) {
-        this.origin = origin;
-    }
-
-    public Edge getTwin() {
-        return twin;
-    }
-
-    public void setTwin(Edge twin) {
-        this.twin = twin;
-    }
-
-    public Face getIncidentFace() {
-        return incidentFace;
-    }
-
-    public void setIncidentFace(Face incidentFace) {
-        this.incidentFace = incidentFace;
-    }
-
-    public Edge getNext() {
-        return next;
-    }
-
-    public void setNext(Edge next) {
-        this.next = next;
-    }
-
-    public Edge getPrev() {
-        return prev;
-    }
-
-    public void setPrev(Edge prev) {
-        this.prev = prev;
-    }
-
-    public boolean hasNext() {
-        if (getNext() == null) {
-            return false;
-        } else {
-            return true;
-        }
-
-    }
-
-    public Edge insertNode(Node node) {
-
-        Edge edge = new Edge();
-        Edge twin = new Edge();
-
-        edge.setOrigin(node);
-        edge.setNext(this.getNext());
-        edge.setPrev(this);
-        edge.setTwin(twin);
-        edge.setIncidentFace(this.getIncidentFace());
-
-        twin.setOrigin(this.getTwin().getOrigin());
-        twin.setPrev(this.getTwin().getPrev());
-        twin.setNext(this.getTwin());
-        twin.setTwin(edge);
-        twin.setIncidentFace(this.getTwin().getIncidentFace());
-
-        Node twinOrigin = this.getTwin().getOrigin();
-        twinOrigin.setIncidentEdge(twin);
-        node.setIncidentEdge(edge);
-
-        this.getTwin().setOrigin(node);
-        this.getTwin().getPrev().setNext(twin);
-        this.getNext().setPrev(edge);
-        this.setNext(edge);
-        this.getTwin().setPrev(twin);
-
-        return edge;
-    }
-
-    public String getID() {
-        return this.id;
-    }
-
-    public void setID(String id) {
-        this.id = id;
-    }
-}
diff --git a/LinearRegressionTool/src/main/java/model/DCEL/Face.java b/LinearRegressionTool/src/main/java/model/DCEL/Face.java
deleted file mode 100644
index 5d94334..0000000
--- a/LinearRegressionTool/src/main/java/model/DCEL/Face.java
+++ /dev/null
@@ -1,125 +0,0 @@
-package model.DCEL;
-
-import java.util.LinkedList;
-
-/**
- * Implementierung verschiedener Algorithmen zur Berechnung von Ausgleichsgeraden.
- *
- * @Author: Armin Wolf
- * @Email: a_wolf28@uni-muenster.de
- * @Date: 30.05.2017.
- */
-public class Face {
-
-    private LinkedList<Edge> innerComponents;
-    private Edge outerComponent;
-    private String id;
-
-    public Face() {
-        this.outerComponent = null;
-        this.innerComponents = new LinkedList<>();
-    }
-
-    public Face(Edge outerComponent, LinkedList<Edge> innerComponents) {
-        this.outerComponent = outerComponent;
-        if (innerComponents != null) {
-            this.innerComponents = innerComponents;
-        } else {
-            this.innerComponents = new LinkedList<>();
-
-        }
-
-    }
-
-    public LinkedList<Edge> getInnerComponents() {
-        return innerComponents;
-    }
-
-    public void setInnerComponents(LinkedList<Edge> innerComponents) {
-        this.innerComponents = innerComponents;
-    }
-
-    public Edge getOuterComponent() {
-        return outerComponent;
-    }
-
-    public void setOuterComponent(Edge outerComponent) {
-        this.outerComponent = outerComponent;
-    }
-
-    public Face insertEdge(Edge edgeWithSameDestination, Edge edgeToMySource) {
-
-        if (edgeWithSameDestination.getIncidentFace().equals(this) || edgeToMySource.getIncidentFace()
-                .equals(this)) {
-            LinkedList<Edge> components = new LinkedList<Edge>();
-            for (Edge e : innerComponents) {
-                components.add(e);
-            }
-            Face face = new Face(getOuterComponent(), components);
-            Edge edge = new Edge();
-            Edge twin = new Edge();
-
-            edge.setOrigin(edgeWithSameDestination.getOrigin());
-            edge.setTwin(twin);
-            edge.setNext(edgeToMySource);
-            edge.setPrev(edgeWithSameDestination.getPrev());
-
-            twin.setOrigin(edgeToMySource.getOrigin());
-            twin.setTwin(edge);
-            twin.setNext(edgeWithSameDestination);
-            twin.setPrev(edgeToMySource.getPrev());
-
-            Edge tempEdge = edge.getNext();
-            Edge tempTwin = twin.getNext();
-            //kreis umlaufen um festzustellen welche fläche kleiner ist
-            while ((tempEdge.equals(edge) == false) && (tempTwin.equals(twin) == false)) {
-                tempEdge = tempEdge.getNext();
-                tempTwin = tempTwin.getNext();
-            }
-
-            if (tempEdge.equals(edge)) {
-                setOuterComponent(twin);
-                twin.setIncidentFace(this);
-                face.setOuterComponent(edge);
-            } else {
-                setOuterComponent(edge);
-                edge.setIncidentFace(this);
-                face.setOuterComponent(twin);
-            }
-
-            LinkedList<Edge> bla = new LinkedList<Edge>();
-            Edge iterEdge = face.getOuterComponent();
-            bla.add(face.getOuterComponent());
-
-            while (iterEdge.hasNext()) {
-                bla.add(iterEdge.getNext());
-                iterEdge = iterEdge.getNext();
-            }
-
-            for (Edge e : face.getInnerComponents()) {
-                iterEdge = e;
-                while (iterEdge.hasNext()) {
-                    bla.add(iterEdge.getNext());
-                    iterEdge = iterEdge.getNext();
-                }
-            }
-
-            for (Edge e : bla) {
-                e.setIncidentFace(face);
-            }
-            return face;
-        } else {
-            throw new IllegalArgumentException(
-                    "Die angegebenen Kanten haben keinen zusammenhang mit der Fläche!");
-        }
-
-    }
-
-    public String getID() {
-        return this.id;
-    }
-
-    public void setID(String id) {
-        this.id = id;
-    }
-}
diff --git a/LinearRegressionTool/src/main/java/model/DCEL/Node.java b/LinearRegressionTool/src/main/java/model/DCEL/Node.java
deleted file mode 100644
index 985b830..0000000
--- a/LinearRegressionTool/src/main/java/model/DCEL/Node.java
+++ /dev/null
@@ -1,50 +0,0 @@
-package model.DCEL;
-
-import model.Point;
-
-/**
- * Implementierung verschiedener Algorithmen zur Berechnung von Ausgleichsgeraden.
- *
- * @Author: Armin Wolf
- * @Email: a_wolf28@uni-muenster.de
- * @Date: 30.05.2017.
- */
-public class Node {
-
-    private Point point;
-    private Edge incidentEdge;
-    private String id;
-
-    public Node() {
-        new Node(null, null);
-    }
-
-    public Node(Point point, Edge incidentEdge) {
-        this.point = point;
-        this.incidentEdge = incidentEdge;
-    }
-
-    public Point getPoint() {
-        return point;
-    }
-
-    public void setPoint(Point point) {
-        this.point = point;
-    }
-
-    public Edge getIncidentEdge() {
-        return incidentEdge;
-    }
-
-    public void setIncidentEdge(Edge incidentEdge) {
-        this.incidentEdge = incidentEdge;
-    }
-
-    public String getID() {
-        return this.id;
-    }
-
-    public void setID(String id) {
-        this.id = id;
-    }
-}
diff --git a/LinearRegressionTool/src/main/java/model/Interval.java b/LinearRegressionTool/src/main/java/model/Interval.java
index 8da7c66..e50bba7 100644
--- a/LinearRegressionTool/src/main/java/model/Interval.java
+++ b/LinearRegressionTool/src/main/java/model/Interval.java
@@ -13,38 +13,64 @@ public class Interval {
     private double lower;
     private Boolean activity;
 
+    /**
+     * Konstruktor
+     * @param lower untere Schranke
+     * @param upper obere Schranke
+     */
     public Interval(double lower, double upper) {
         this.upper = upper;
         this.lower = lower;
         this.activity = true;
     }
 
+    /**
+     * @return <code>true</code> falls das Intervall aktiv ist
+     */
     public Boolean getActivity() {
         return activity;
     }
 
+    /**
+     * @param isActive <code>true</code> falls das Intervall als aktiv gesetzt werden soll
+     */
     public void setActivity(Boolean isActive) {
         this.activity = isActive;
     }
 
+    /**
+     * @return obere Schranke des Intervalls
+     */
     public double getUpper() {
         return upper;
     }
 
+    /**
+     * @param upper obere Schranke des Intervalls
+     */
     public void setUpper(double upper) {
         this.upper = upper;
     }
 
+    /**
+     * @return untere Schranke des Intervalls
+     */
     public double getLower() {
         return lower;
     }
 
+    /**
+     * @param lower untere Schranke des Intervalls
+     */
     public void setLower(double lower) {
         this.lower = lower;
     }
 
+    /**
+     * Berechnet die Distanz zwischen der oberen und unteren Schranke
+     * @return Distanz
+     */
     public Double getDistance() {
-
         return Math.abs(this.upper - this.lower);
     }
 
diff --git a/LinearRegressionTool/src/main/java/model/Line.java b/LinearRegressionTool/src/main/java/model/Line.java
index 8701eb3..864c19f 100644
--- a/LinearRegressionTool/src/main/java/model/Line.java
+++ b/LinearRegressionTool/src/main/java/model/Line.java
@@ -23,6 +23,12 @@ public class Line {
 
     private String id;
 
+    /**
+     * Konstruktor
+     * @param m Steigung
+     * @param b y-Achsenabschnitt
+     * @param id id
+     */
     public Line(double m, double b, String id) {
         this.m = m;
         this.b = b;
@@ -34,7 +40,11 @@ public class Line {
         this.id = id;
     }
 
-
+    /**
+     * Konstruktor
+     * @param m Steigung
+     * @param b y-Achsenabschnitt
+     */
     public Line(double m, double b) {
         this.m = m;
         this.b = b;
@@ -45,6 +55,13 @@ public class Line {
         this.y2 = ((MAX * 0.5) * m) + b;
     }
 
+    /**
+     * Konstruktor
+     * @param x1 x-Koordiante des Startpunkts
+     * @param x2 x-Koordinate des Endpunkts
+     * @param y1 y-Koordinate des Startpunkts
+     * @param y2 y-Koordinate des Endpunkts
+     */
     public Line(double x1, double x2, double y1, double y2) {
         this.x1 = x1;
         this.x2 = x2;
@@ -56,53 +73,97 @@ public class Line {
 
     }
 
+    /**
+     * @return Steigung der Gerade
+     */
     public Double getM() {
         return m;
     }
 
+    /**
+     * @param m Steigung der Gerade
+     */
     public void setM(double m) {
         this.m = m;
     }
 
+    /**
+     * @return y-Achsenabschnitt der Gerade
+     */
     public Double getB() {
         return b;
     }
 
+    /**
+     * @param b y-Achsenabschnitt der Gerade
+     */
     public void setB(double b) {
         this.b = b;
     }
 
+    /**
+     * @return id der Gerade
+     */
     public String getId() {
         return id;
     }
 
+    /**
+     * @param id id der Gerade
+     */
     public void setId(String id) {
         this.id = id;
     }
 
+    /**
+     * @return x-Koordiante des Startpunkts
+     */
     public Double getX1() {
         return x1;
     }
 
+    /**
+     * @return x-Koordiante des Endpunkts
+     */
     public Double getX2() {
         return x2;
     }
 
+    /**
+     * @return y-Koordiante des Startpunkts
+     */
     public Double getY1() {
         return y1;
     }
 
+    /**
+     * @return y-Koordiante des Endpunkts
+     */
     public Double getY2() {
         return y2;
     }
 
+    /**
+     * Setzt die Koordianten des Segments. Aus dem Segment wird eine Gerade berechnet.
+     * @param x1 x-Koordiante des Startpunkts
+     * @param y1 y-Koordiante des Endpunkts
+     * @param x2 x-Koordinate des Startpunkts
+     * @param y2 y-Koordinte des Endpunkts
+     */
     public void setEndPoints(double x1, double y1, double x2, double y2) {
         this.x1 = x1;
         this.x2 = x2;
         this.y1 = y1;
         this.y2 = y2;
+        this.m = (y2 - y1) / (x2 - x1);
+        this.b = y2 - (x2 * m);
     }
 
+    /**
+     * Vergleich einzelner Geradern
+     * @param other zu vergleichende Gerade
+     * @return <code>true</code> falls die Geraden Gleich sind
+     */
     public boolean equals(Line other) {
         if (other.getM() == this.getM() && other.getB() == this.getB()) {
             return true;
diff --git a/LinearRegressionTool/src/main/java/model/LineModel.java b/LinearRegressionTool/src/main/java/model/LineModel.java
index 7089b2b..cdb7063 100644
--- a/LinearRegressionTool/src/main/java/model/LineModel.java
+++ b/LinearRegressionTool/src/main/java/model/LineModel.java
@@ -19,6 +19,9 @@ public class LineModel {
     private Double yMinimum;
     private Double yMaximum;
 
+    /**
+     * Konstruktor
+     */
     public LineModel() {
         nodes = new ArrayList<>();
         lines = new LinkedList<>();
@@ -30,62 +33,109 @@ public class LineModel {
 
     }
 
+    /**
+     * Fügt einen Schnittpunkt zum Modell hinzu
+     * @param node Schnittpunkt
+     */
     public void addNode(Point node) {
         this.nodes.add(node);
     }
 
+    /**
+     * Fügt eine Gerade zu dem Modell hinzu
+     * @param line Gerade
+     */
     public void addLine(Line line) {
         this.lines.add(line);
     }
 
+    /**
+     * @return Liste der Schnittpunkte
+     */
     public ArrayList<Point> getNodes() {
         return nodes;
     }
 
+    /**
+     * @param nodes Liste der Schnittpunkte
+     */
     public void setNodes(ArrayList<Point> nodes) {
         this.nodes = nodes;
     }
 
+    /**
+     * @return Liste der Geraden
+     */
     public LinkedList<Line> getLines() {
         return lines;
     }
 
+    /**
+     * @param lines Liste der Geraden
+     */
     public void setLines(LinkedList<Line> lines) {
         this.lines = lines;
     }
 
+    /**
+     * @return Minimale x-Koordiante
+     */
     public Double getxMinimum() {
         return xMinimum;
     }
 
+    /**
+     * @param xMinimum Minimale x-Koordiante
+     */
     public void setxMinimum(Double xMinimum) {
         this.xMinimum = xMinimum;
     }
 
+    /**
+     * @return Maximale x-Koordiante
+     */
     public Double getxMaximum() {
         return xMaximum;
     }
 
+    /**
+     * @param xMaximum Maximale x-Koordiante
+     */
     public void setxMaximum(Double xMaximum) {
         this.xMaximum = xMaximum;
     }
 
+    /**
+     * @return Minimale y-Koordiante
+     */
     public Double getyMinimum() {
         return yMinimum;
     }
 
+    /**
+     * @param yMinimum Minimale y-Koordiante
+     */
     public void setyMinimum(Double yMinimum) {
         this.yMinimum = yMinimum;
     }
 
+    /**
+     * @return Maximale y-Koordiante
+     */
     public Double getyMaximum() {
         return yMaximum;
     }
 
+    /**
+     * @param yMaximum Maximale y-Koordiante
+     */
     public void setyMaximum(Double yMaximum) {
         this.yMaximum = yMaximum;
     }
 
+    /**
+     * Setzt die minimalen, maximalen x- und y-Koordinaten
+     */
     public void resetRanges() {
         xMinimum = Double.MAX_VALUE;
         xMaximum = Double.MIN_VALUE;
diff --git a/LinearRegressionTool/src/main/java/model/Pair.java b/LinearRegressionTool/src/main/java/model/Pair.java
index faff8eb..185d2c1 100644
--- a/LinearRegressionTool/src/main/java/model/Pair.java
+++ b/LinearRegressionTool/src/main/java/model/Pair.java
@@ -12,23 +12,40 @@ public class Pair {
     private Integer p1;
     private Integer p2;
 
+    /**
+     * Konstruktor
+     * @param p1 erstes Element des Tupels
+     * @param p2 zweites Element des Tupels
+     */
     public Pair(Integer p1, Integer p2) {
         this.p1 = p1;
         this.p2 = p2;
     }
 
+    /**
+     * @return erstes Element des Tupels
+     */
     public Integer getP1() {
         return p1;
     }
 
+    /**
+     * @param p1 erstes Element des Tupels
+     */
     public void setP1(Integer p1) {
         this.p1 = p1;
     }
 
+    /**
+     * @return zweites Element des Tupels
+     */
     public Integer getP2() {
         return p2;
     }
 
+    /**
+     * @param p2 zweites Element des Tupels
+     */
     public void setP2(Integer p2) {
         this.p2 = p2;
     }
diff --git a/LinearRegressionTool/src/main/java/model/Point.java b/LinearRegressionTool/src/main/java/model/Point.java
index 632c038..142c190 100644
--- a/LinearRegressionTool/src/main/java/model/Point.java
+++ b/LinearRegressionTool/src/main/java/model/Point.java
@@ -13,29 +13,52 @@ public class Point implements Comparable<Point> {
     private Double y;
     private String id;
 
+    /**
+     * Konstruktor
+     * @param x x-Koordiante
+     * @param y y-Koordiante
+     */
     public Point(Double x, Double y) {
         this.x = x;
         this.y = y;
     }
 
+    /**
+     * Konstruktor
+     * @param x x-Koordiante
+     * @param y y-Koordiante
+     * @param id id des Punkts
+     */
     public Point(Double x, Double y, String id) {
         this.x = x;
         this.y = y;
         this.id = id;
     }
 
+    /**
+     * @return x-Koordinate des Punkts
+     */
     public Double getX() {
         return x;
     }
 
+    /**
+     * @param x x-Koordinate des Punkts
+     */
     public void setX(Double x) {
         this.x = x;
     }
 
+    /**
+     * @return y-Koordinate des Punkts
+     */
     public Double getY() {
         return y;
     }
 
+    /**
+     * @param y y-Koordinate des Punkts
+     */
     public void setY(Double y) {
         this.y = y;
     }
@@ -55,6 +78,11 @@ public class Point implements Comparable<Point> {
         }
     }
 
+    /**
+     * Vergleich zweier Punkte
+     * @param other zu vergleichernder Punkt
+     * @return <code>true</code> falls die Punkte gleich sind
+     */
     public boolean equals(Point other) {
         if (other.getX() == this.getX() && other.getY() == this.getY()) {
             return true;
@@ -63,10 +91,16 @@ public class Point implements Comparable<Point> {
         }
     }
 
+    /**
+     * @return id des Punkts
+     */
     public String getId() {
         return id;
     }
 
+    /**
+     * @param id id des Punkts
+     */
     public void setId(String id) {
         this.id = id;
     }
diff --git a/LinearRegressionTool/src/main/java/view/MainFrame.java b/LinearRegressionTool/src/main/java/view/MainFrame.java
index 8a6b4e7..a4faccf 100644
--- a/LinearRegressionTool/src/main/java/view/MainFrame.java
+++ b/LinearRegressionTool/src/main/java/view/MainFrame.java
@@ -284,7 +284,7 @@ public class MainFrame extends JFrame {
     }
 
     private void setDimensions() {
-        this.setSize(1600,1050);
+        this.setPreferredSize(new Dimension(1600,1050));
         this.setMinimumSize(new Dimension(1024, 768));
         this.setResizable(true);
         GraphicsEnvironment env = GraphicsEnvironment.getLocalGraphicsEnvironment();
@@ -327,6 +327,7 @@ public class MainFrame extends JFrame {
         importButton = new JButton();
         generateButton = new JButton();
         exportButton = new JButton();
+        pack();
     }
 
     private void setIcons() {
diff --git a/LinearRegressionTool/src/test/java/model/DoublyConnectedEdgeListTest.java b/LinearRegressionTool/src/test/java/model/DoublyConnectedEdgeListTest.java
deleted file mode 100644
index d3be8cd..0000000
--- a/LinearRegressionTool/src/test/java/model/DoublyConnectedEdgeListTest.java
+++ /dev/null
@@ -1,100 +0,0 @@
-package model;
-
-import model.DCEL.DoublyConnectedEdgeList;
-import model.DCEL.Edge;
-import model.DCEL.Face;
-import model.DCEL.Node;
-import org.junit.Before;
-import org.junit.Test;
-
-import java.util.LinkedList;
-
-import static org.junit.Assert.assertArrayEquals;
-import static org.junit.Assert.assertEquals;
-
-/**
- * Implementierung verschiedener Algorithmen zur Berechnung von Ausgleichsgeraden.
- *
- * @Author: Armin Wolf
- * @Email: a_wolf28@uni-muenster.de
- * @Date: 30.05.2017.
- */
-public class DoublyConnectedEdgeListTest {
-
-    private static DoublyConnectedEdgeList dcel;
-    private static Node v1, v2, v3, v4, v5;
-    private static Edge e1, e2, e3, e4, e5;
-    private static Face f1, f2;
-
-    @Before
-    public void setUp() throws Exception {
-        dcel = new DoublyConnectedEdgeList();
-
-        //initialisiere die TestKnoten im Graphen
-        v1 = dcel.createNode(new Point(2.5, 7.5), "v1");
-        v2 = dcel.createNode(new Point(2.5, 4.0), "v2");
-        v3 = dcel.createNode(new Point(6.5, 3.5), "v3");
-        v4 = dcel.createNode(new Point(8.5, 6.5), "v4");
-        v5 = dcel.createNode(new Point(6.0, 8.0), "v5");
-
-        //initialisere Kanten im Graph
-        e1 = dcel.createEdge(v1, v5, "e1");
-        e2 = dcel.createEdge(v5, v4, "e2");
-        e3 = dcel.createEdge(v4, v3, "e3");
-        e4 = dcel.createEdge(v3, v2, "e4");
-        e5 = dcel.createEdge(v2, v1, "e5");
-
-        dcel.createConnection(e1, e2);
-        dcel.createConnection(e2, e3);
-        dcel.createConnection(e3, e4);
-        dcel.createConnection(e4, e5);
-        dcel.createConnection(e5, e1);
-
-        //intialisiere die Flaechen
-        f1 = dcel.createFace(null, e1, "f1");
-        f2 = dcel.createFace(e1.getTwin(), null, "f2");
-    }
-
-
-    @Test
-    public void testInnerComponentsAccess() {
-        System.out.println("Test: testInnerComponentAccess();");
-        Edge[] expected = {e1, e2, e3, e4, e5};
-        LinkedList<Edge> list = dcel.getEdgesOfInnerComponents(f1);
-
-        assertArrayEquals(expected, list.toArray());
-    }
-
-    @Test
-    public void testOuterComponentsAccess() {
-        System.out.println("Test: testOuterComponentAccess();");
-        String[] expected = {"#e1", "#e5", "#e4", "#e3", "#e2"};
-        LinkedList<Edge> list = dcel.getEdgesOfOuterComponents(f2);
-
-        for (int i = 0; i < list.size(); i++) {
-            assertEquals(expected[i], list.get(i).getID());
-        }
-
-    }
-
-
-    @Test
-    public void testNodeEdgeAccess() {
-        System.out.println("Test: testNodeEdgeAccess();");
-
-        assertEquals(5, dcel.getConnectedEdges(v4).size());
-    }
-
-    @Test
-    public void testDCELAccess() {
-        System.out.println("Test: testDCELAccess();");
-
-        assertEquals(e1, e1.getTwin().getTwin());
-        assertEquals(e1, e1.getPrev().getNext());
-        assertEquals(e2.getID(), e1.getTwin().getPrev().getTwin().getID());
-        assertEquals(e1, e1.getNext().getNext().getNext().getNext().getNext());
-        assertEquals(e1.getTwin(), e1.getTwin().getNext().getNext().getNext().getNext().getNext());
-    }
-
-
-}
\ No newline at end of file