naive Implementierung der Algortihmen für die Evaluation.

src/main/java/presenter/AbstractPresenter.java

@@ -3,7 +3,7 @@ package presenter;
 import model.Interval;
 import model.Line;
 import model.LineModel;
-import presenter.algorithms.IntersectionCounter;
+import presenter.algorithms.util.IntersectionCounter;
 import presenter.evaluation.EvaluateAlgorithms;
 import view.MainFrame;
 

src/main/java/presenter/Presenter.java

@@ -1,9 +1,9 @@
 package presenter;
 
 import model.LineModel;
-import presenter.algorithms.LeastMedianOfSquaresEstimator;
-import presenter.algorithms.RepeatedMedianEstimator;
-import presenter.algorithms.TheilSenEstimator;
+import presenter.algorithms.advanced.LeastMedianOfSquaresEstimator;
+import presenter.algorithms.advanced.RepeatedMedianEstimator;
+import presenter.algorithms.advanced.TheilSenEstimator;
 import presenter.evaluation.EvaluateAlgorithms;
 import presenter.generator.DatasetGenerator;
 import presenter.io.DataExporter;

src/main/java/presenter/algorithms/advanced/LeastMedianOfSquaresEstimator.java

@@ -1,9 +1,11 @@
-package presenter.algorithms;
+package presenter.algorithms.advanced;
 
 import model.Interval;
 import model.Line;
 import model.Point;
 import presenter.Presenter;
+import presenter.algorithms.Algorithm;
+import presenter.algorithms.util.IntersectionCounter;
 
 import java.util.*;
 

src/main/java/presenter/algorithms/advanced/RepeatedMedianEstimator.java

@@ -1,8 +1,12 @@
-package presenter.algorithms;
+package presenter.algorithms.advanced;
 
 import model.Interval;
 import model.Line;
 import presenter.Presenter;
+import presenter.algorithms.Algorithm;
+import presenter.algorithms.util.FastElementSelector;
+import presenter.algorithms.util.IntersectionCounter;
+import presenter.algorithms.util.RandomSampler;
 
 import java.util.ArrayList;
 import java.util.HashMap;

src/main/java/presenter/algorithms/advanced/TheilSenEstimator.java

@@ -1,9 +1,13 @@
-package presenter.algorithms;
+package presenter.algorithms.advanced;
 
 import model.Interval;
 import model.Line;
 import model.Point;
 import presenter.Presenter;
+import presenter.algorithms.Algorithm;
+import presenter.algorithms.util.BinomialCoeffizient;
+import presenter.algorithms.util.FastElementSelector;
+import presenter.algorithms.util.RandomSampler;
 
 import java.util.*;
 

src/main/java/presenter/algorithms/naiv/NaivLeastMedianOfSquaresEstimator.java

@@ -0,0 +1,90 @@
+package presenter.algorithms.naiv;
+
+import model.Line;
+import model.Point;
+import presenter.algorithms.Algorithm;
+import presenter.algorithms.util.FastElementSelector;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.LinkedList;
+
+/**
+ * Implementierung verschiedener Algorithmen zur Berechnung von Ausgleichsgeraden.
+ *
+ * @Author: Armin Wolf
+ * @Email: a_wolf28@uni-muenster.de
+ * @Date: 15.09.2017.
+ */
+public class NaivLeastMedianOfSquaresEstimator implements Algorithm {
+    private ArrayList<Point> set = new ArrayList<>();
+
+    private Integer n;
+    private Double ds,as,bs;
+
+    public NaivLeastMedianOfSquaresEstimator(LinkedList<Line> lines) {
+        for (Line l :lines){
+            set.add(new Point(l.getM(),l.getB()));
+        }
+    }
+
+
+    private void crudeAlg(){
+        ds = Double.MAX_VALUE;
+        as = 0d;
+        bs = 0d;
+        ArrayList<Point> triple = new ArrayList<>();
+        Double beta;
+        Double alpha;
+        Double dijk;
+        for (Point i : set){
+            for (Point j : set) {
+                for (Point k : set){
+                    triple.add(i);
+                    triple.add(j);
+                    triple.add(k);
+                    Collections.sort(triple);
+                    beta    = (triple.get(0).getY() - triple.get(2).getY()) / (triple.get(0).getX() - triple.get(2).getX());
+                    alpha   = (triple.get(1).getY() + triple.get(2).getY() - ( beta * (triple.get(1).getX() + triple.get(2).getX()))) / 2f;
+                    dijk    = f(alpha, beta);
+                    if (dijk < ds){
+                        ds = dijk;
+                        as = alpha;
+                        bs = beta;
+                       // System.out.printf("Distanz: %6.2f\tAlpha: %6.2f\tBeta: %6.2f",ds,as,bs);
+                    }
+                    triple.clear();
+                }
+            }
+        }
+        System.out.printf("Naiv LMS: %6.2f * x + %6.3f\n",bs, as);
+    }
+
+
+
+    private Double f(Double a, Double b){
+        ArrayList<Double> res = new ArrayList<>();
+        for (Point p : set){
+            res.add(Math.abs(p.getY() - (a + b * p.getX())));
+        }
+        return FastElementSelector.randomizedSelect(res, res.size()/2);
+    }
+
+    @Override
+    public void run() {
+        crudeAlg();
+    }
+
+    @Override
+    public void getResult() {
+
+    }
+
+    public Double getAs() {
+        return as;
+    }
+
+    public Double getBs() {
+        return bs;
+    }
+}

src/main/java/presenter/algorithms/naiv/NaivRepeatedMedianEstimator.java

@@ -0,0 +1,121 @@
+package presenter.algorithms.naiv;
+
+import model.Line;
+import model.Point;
+import presenter.algorithms.Algorithm;
+import presenter.algorithms.util.FastElementSelector;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.LinkedList;
+
+/**
+ * Implementierung verschiedener Algorithmen zur Berechnung von Ausgleichsgeraden.
+ *
+ * @Author: Armin Wolf
+ * @Email: a_wolf28@uni-muenster.de
+ * @Date: 15.09.2017.
+ */
+public class NaivRepeatedMedianEstimator implements Algorithm{
+
+    private LinkedList<Line> lines;
+    private HashMap<String, ArrayList<Double>> slopesPerLine;
+    private HashMap<String, ArrayList<Double>> interceptPerLine;
+    private ArrayList<Double> xMedians, yMedians;
+    private Double medianX;
+    private Double medianY;
+
+    public NaivRepeatedMedianEstimator(LinkedList<Line> lines) {
+        this.lines = lines;
+        slopesPerLine = new HashMap<>();
+        interceptPerLine = new HashMap<>();
+        xMedians = new ArrayList<>();
+        yMedians = new ArrayList<>();
+    }
+
+    @Override
+    public void run() {
+        //init the List for the slopes
+        for (int j=0;j<lines.size();j++) {
+            Line leq = lines.get(j);
+            if (slopesPerLine.get(leq.getId()) == null) {
+                slopesPerLine.put(leq.getId(), new ArrayList<>());
+            }
+            if (interceptPerLine.get(leq.getId()) == null) {
+                interceptPerLine.put(leq.getId(), new ArrayList<>());
+            }
+        }
+
+
+        //calculate all slopes for each line
+        Point ret;
+        for (int i=0;i<lines.size();i++) {
+            for (int j=i+1;j<lines.size();j++){
+                ret = calculateSlope(lines.get(i), lines.get(j));
+                slopesPerLine.get(lines.get(i).getId()).add(ret.getX());
+                interceptPerLine.get(lines.get(i).getId()).add(ret.getY());
+            }
+        }
+
+        //calculate median of slopes for each line
+        for (String l : slopesPerLine.keySet()) {
+            ArrayList<Double> list = slopesPerLine.get(l);
+            int size = list.size() / 2;
+            if (size > 0) {
+                Double medianX = FastElementSelector.randomizedSelect(list, size);
+                xMedians.add(medianX);
+            }
+        }
+
+        //calculate median of slopes for each line
+        for (String l : interceptPerLine.keySet()) {
+            ArrayList<Double> list = interceptPerLine.get(l);
+            int size = list.size() / 2;
+            if (size > 0) {
+                Double medianY = FastElementSelector.randomizedSelect(list, size);
+                yMedians.add(medianY);
+            }
+        }
+
+        medianX = FastElementSelector.randomizedSelect(xMedians, xMedians.size()/2);
+        medianY = FastElementSelector.randomizedSelect(yMedians, yMedians.size()/2);
+        System.out.printf("Naiv RM:  %6.2f * x + %6.2f \n", medianX, medianY);
+    }
+
+    @Override
+    public void getResult() {
+
+    }
+
+    private Point calculateSlope(Line lineA, Line lineB){
+        Double xi;
+        Double xj;
+        Double yi;
+        Double yj;
+
+        if (lineB.getM() > lineA.getM()){
+            xi = lineA.getM();
+            yi = lineA.getB();
+            xj = lineB.getM();
+            yj = lineB.getB();
+        } else {
+            xj = lineA.getM();
+            yj = lineA.getB();
+            xi = lineB.getM();
+            yi = lineB.getB();
+        }
+
+
+        Double m = (yj - yi) / (xj -xi);
+        Double b =  ((xj * yi) - (xi * yj)) / (xj - xi);
+        return new Point(m,b);
+    }
+
+    public Double getMedianX() {
+        return medianX;
+    }
+
+    public Double getMedianY() {
+        return medianY;
+    }
+}

src/main/java/presenter/algorithms/naiv/NaivTheilSenEstimator.java

@@ -0,0 +1,75 @@
+package presenter.algorithms.naiv;
+
+import model.Line;
+import presenter.algorithms.Algorithm;
+import presenter.algorithms.util.FastElementSelector;
+
+import java.util.ArrayList;
+import java.util.LinkedList;
+
+/**
+ * Implementierung verschiedener Algorithmen zur Berechnung von Ausgleichsgeraden.
+ *
+ * @Author: Armin Wolf
+ * @Email: a_wolf28@uni-muenster.de
+ * @Date: 15.09.2017.
+ */
+public class NaivTheilSenEstimator implements Algorithm {
+
+
+    private LinkedList<Line> lines;
+    private Double slope;
+    private Double yInterception;
+
+    public NaivTheilSenEstimator(LinkedList<Line> lines) {
+        this.lines = lines;
+        this.slope = 0d;
+        this.yInterception = 0d;
+    }
+
+
+    @Override
+    public void run() {
+        ArrayList<Double> slopesList = new ArrayList<>();
+        int cnt = 0;
+        for (int i = 0; i < lines.size(); i++) {
+            double x = lines.get(i).getM();
+            double y = lines.get(i).getB();
+
+            for (int j = i + 1; j < lines.size(); j++) {
+                if (x != lines.get(j).getM()) { // x must be different, otherwise slope becomes infinite
+                    Double slope = (lines.get(j).getB() - y) / (lines.get(j).getM() - x);
+                    slopesList.add(slope);
+                    ++cnt;
+                }
+            }
+        }
+
+
+        ArrayList<Double> list1 = new ArrayList<>();
+        ArrayList<Double> list2 = new ArrayList<>();
+        for (int i=0;i<lines.size();i++){
+            list1.add(lines.get(i).getM());
+            list2.add(lines.get(i).getB());
+        }
+        Double median1 = FastElementSelector.randomizedSelect(list1, list1.size()/2);
+        Double median2 = FastElementSelector.randomizedSelect(list2, list2.size()/2);
+        slope = FastElementSelector.randomizedSelect(slopesList, slopesList.size()/2);
+        yInterception = median2 - slope * median1;
+        System.out.printf("Naiv TS: %6.2f * x + %6.3f\n",slope, yInterception);
+    }
+
+    @Override
+    public void getResult() {
+
+    }
+
+
+    public Double getSlope() {
+        return slope;
+    }
+
+    public Double getyInterception() {
+        return yInterception;
+    }
+}

src/main/java/presenter/algorithms/util/BinomialCoeffizient.java

@@ -1,4 +1,4 @@
-package presenter.algorithms;
+package presenter.algorithms.util;
 
 /**
  * Implementierung verschiedener Algorithmen zur Berechnung von Ausgleichsgeraden.

src/main/java/presenter/algorithms/util/FastElementSelector.java

@@ -1,4 +1,4 @@
-package presenter.algorithms;
+package presenter.algorithms.util;
 
 import java.util.ArrayList;
 import java.util.Collections;

src/main/java/presenter/algorithms/util/IntersectionCounter.java

@@ -1,4 +1,4 @@
-package presenter.algorithms;
+package presenter.algorithms.util;
 
 import model.*;
 import presenter.algorithms.Comparators.YOrderLineComparatorBegin;

src/main/java/presenter/algorithms/util/RandomSampler.java

@@ -1,4 +1,4 @@
-package presenter.algorithms;
+package presenter.algorithms.util;
 
 import model.Line;
 import model.Point;

src/main/java/presenter/evaluation/EvaluateAlgorithms.java

@@ -4,10 +4,13 @@ import model.Interval;
 import model.Line;
 import model.LineModel;
 import model.Point;
-import presenter.algorithms.IntersectionCounter;
-import presenter.algorithms.LeastMedianOfSquaresEstimator;
-import presenter.algorithms.RepeatedMedianEstimator;
-import presenter.algorithms.TheilSenEstimator;
+import presenter.algorithms.naiv.NaivLeastMedianOfSquaresEstimator;
+import presenter.algorithms.naiv.NaivRepeatedMedianEstimator;
+import presenter.algorithms.naiv.NaivTheilSenEstimator;
+import presenter.algorithms.util.IntersectionCounter;
+import presenter.algorithms.advanced.LeastMedianOfSquaresEstimator;
+import presenter.algorithms.advanced.RepeatedMedianEstimator;
+import presenter.algorithms.advanced.TheilSenEstimator;
 import presenter.generator.DatasetGenerator;
 
 import java.util.ArrayList;
@@ -100,6 +103,19 @@ public class EvaluateAlgorithms extends Observable {
         ArrayList<String> result;
         ArrayList<ArrayList<String>> multipleResults = new ArrayList<>();
 
+        /*  DEBUG  */
+
+        NaivLeastMedianOfSquaresEstimator l = new NaivLeastMedianOfSquaresEstimator(arrangement.getLines());
+        NaivRepeatedMedianEstimator r = new NaivRepeatedMedianEstimator(arrangement.getLines());
+        NaivTheilSenEstimator t = new NaivTheilSenEstimator(arrangement.getLines());
+
+        l.run();
+        r.run();
+        t.run();
+        System.out.println();
+
+
+        /*  DEBUG  */
         startLMS();
         startRM();
         startTS();

src/main/java/presenter/evaluation/PercentageErrorBasedMeasure.java

@@ -1,7 +1,7 @@
 package presenter.evaluation;
 
 import model.Line;
-import presenter.algorithms.FastElementSelector;
+import presenter.algorithms.util.FastElementSelector;
 
 import java.util.ArrayList;
 import java.util.LinkedList;

src/main/java/presenter/evaluation/ScaleDependentMeasure.java

@@ -1,7 +1,7 @@
 package presenter.evaluation;
 
 import model.Line;
-import presenter.algorithms.FastElementSelector;
+import presenter.algorithms.util.FastElementSelector;
 
 import java.util.ArrayList;
 import java.util.LinkedList;

src/main/java/presenter/evaluation/ScaledErrorBasedMeasure.java

@@ -1,7 +1,7 @@
 package presenter.evaluation;
 
 import model.Line;
-import presenter.algorithms.FastElementSelector;
+import presenter.algorithms.util.FastElementSelector;
 
 import java.util.ArrayList;
 import java.util.LinkedList;

src/main/java/view/listener/StartAlgorithmListener.java

@@ -1,8 +1,6 @@
 package view.listener;
 
 import presenter.Presenter;
-import presenter.algorithms.Algorithm;
-import presenter.algorithms.LeastMedianOfSquaresEstimator;
 import view.panels.tabs.LMSPanel;
 import view.panels.tabs.RMPanel;
 import view.panels.tabs.TSPanel;

src/test/java/presenter/algorithms/LeastMedianOfSquaresEstimatorTest.java

@@ -6,6 +6,8 @@ import model.Line;
 import model.Point;
 import org.junit.Before;
 import org.junit.Test;
+import presenter.algorithms.advanced.LeastMedianOfSquaresEstimator;
+import presenter.algorithms.util.IntersectionCounter;
 
 import java.util.ArrayList;
 import java.util.LinkedList;