kleiner Fix, bevor evaluiert wird müssen noch die Ergebnisse geholt werden.

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

@@ -364,6 +364,12 @@ public class LeastMedianOfSquaresEstimator extends Observable implements Algorit
 
       String[] result = {"lms", m+"", b+""};
       notifyObservers(result);
+    } else {
+      double m = (getSigmaMin().getX2() + getSigmaMin().getX1()) * 0.5;
+      double b = (getSigmaMin().getY2() + getSigmaMin().getY1()) * -0.5;
+
+      slope = m;
+      yInterception = b;
     }
   }
 

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

@@ -283,6 +283,11 @@ public class RepeatedMedianEstimator extends Observable implements Algorithm {
       yInterception = b;
       String[] result = new String[]{"rm", m+"", b+""};
       notifyObservers(result);
+    }else {
+      double m = thetaLow;
+      double b = (-1)*((linesInCenterSlab.get(0).getM() * (thetaLow)) + linesInCenterSlab.get(0).getB());
+      slope = m;
+      yInterception = b;
     }
   }
 

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

@@ -224,36 +224,36 @@ public class TheilSenEstimator extends Observable implements Algorithm {
 
     @Override
     public void getResult() {
+        double m, x;
+        double b, y;
+
+        Collections.sort(xCoordinates);
+        Collections.sort(yCoordinates);
+        int n = xCoordinates.size();
+        if (n % 2 == 0) {
+            x = 0.5 * (xCoordinates.get((n / 2) - 1) + xCoordinates.get((n / 2)));
+            y = 0.5 * (yCoordinates.get((n / 2) - 1) + yCoordinates.get((n / 2)));
+        } else {
+            x = xCoordinates.get(((n + 1) / 2) - 1);
+            y = yCoordinates.get(((n + 1) / 2) - 1);
+        }
+
+        ArrayList<Point> resultSt = getIntervalElements(interval.getLower(), interval.getUpper());
+        int size = resultSt.size();
+        if (size % 2 == 0) {
+            m = 0.5 * (resultSt.get((size / 2) - 1).getX() + resultSt.get((size / 2)).getX());
+        } else {
+            m = resultSt.get(((size + 1) / 2) - 1).getX();
+        }
+
+        b = (x * m) - y;
+
+        slope = m;
+        yInterception = b;
+
         if (presenter != null) {
             setChanged();
 
-            double m, x;
-            double b, y;
-
-            Collections.sort(xCoordinates);
-            Collections.sort(yCoordinates);
-            int n = xCoordinates.size();
-            if (n % 2 == 0) {
-                x = 0.5 * (xCoordinates.get((n / 2) - 1) + xCoordinates.get((n / 2)));
-                y = 0.5 * (yCoordinates.get((n / 2) - 1) + yCoordinates.get((n / 2)));
-            } else {
-                x = xCoordinates.get(((n + 1) / 2) - 1);
-                y = yCoordinates.get(((n + 1) / 2) - 1);
-            }
-
-            ArrayList<Point> resultSt = getIntervalElements(interval.getLower(), interval.getUpper());
-            int size = resultSt.size();
-            if (size % 2 == 0) {
-                m = 0.5 * (resultSt.get((size / 2) - 1).getX() + resultSt.get((size / 2)).getX());
-            } else {
-                m = resultSt.get(((size + 1) / 2) - 1).getX();
-            }
-
-            b = (x * m) - y;
-
-            slope = m;
-            yInterception = b;
-
             String[] result = new String[]{"ts", m + "", b + ""};
             notifyObservers(result);
         }

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

@@ -24,6 +24,7 @@ public class EvaluateAlgorithms {
     private Double[] rmResult;
     private Double[] tsResult;
 
+    private String[] names = {"MSE:\n", "RMSE:\n", "MAE:\n", "MdAE:\n"};
 
     public EvaluateAlgorithms(){
         this.arrangement = new Arrangement();
@@ -56,20 +57,21 @@ public class EvaluateAlgorithms {
             LeastMedianOfSquaresEstimator lmsAlg = new LeastMedianOfSquaresEstimator(arrangement.getLines()
                                                                                     ,arrangement.getNodes());
             lmsAlg.run();
-
+            lmsAlg.getResult();
             List<Double> errors = sampsonError(arrangement.getLines(), lmsAlg.getSlope(), lmsAlg.getyInterception());
             lmsResult = getResults(errors);
         });
         Thread rm = 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);
         });
         Thread ts = 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);
         });
@@ -82,7 +84,8 @@ public class EvaluateAlgorithms {
         ts.join();
 
         for (int i=0;i<4;i++){
-            System.out.println("LMS: "+ lmsResult[i] + "\tTS: " + tsResult[i] + "\tRM: " + rmResult[i] + "\t");
+            System.out.print(names[i]);
+            System.out.println("LMS: "+ lmsResult[i] + "\tTS: " + tsResult[i] + "\tRM: " + rmResult[i] + "\n\n");
         }
     }
 
@@ -133,17 +136,17 @@ public class EvaluateAlgorithms {
     }
 
 
-    public List<Double> sampsonError(LinkedList<Line> lines, Double m, Double b){
+    public List<Double> sampsonError(final LinkedList<Line> lines, Double m, Double b){
 
         //Liste mit den Fehler zu jedem Punkt
-        List<Double> sampsonrror = new ArrayList<>();
+        List<Double> sampsonerror = new ArrayList<>();
 
         for (Line line : lines){
             Double error = Math.pow(m * line.getM() - line.getB() + b, 2) / (Math.pow(m,2) + 1);
-            sampsonrror.add(error);
+            sampsonerror.add(error);
         }
 
-        return sampsonrror;
+        return sampsonerror;
     }
 
 }