algorithms-for-computing-line-estimators/src/main/java/Presenter/Presenter.java

package Presenter;

import Model.Arrangement;
import Model.Line;
import Model.Point;
import Presenter.Algorithms.LeastMedianOfSquaresEstimator;
import Presenter.Algorithms.RepeatedMedianEstimator;
import View.MainFrame;
import java.util.LinkedList;
import java.util.List;
import java.util.Observable;
import java.util.Observer;
import javax.swing.SwingUtilities;


/**
 * Implementierung verschiedener Algorithmen zur Berechnung von Ausgleichsgeraden.
 *
 * @Author: Armin Wolf
 * @Email: a_wolf28@uni-muenster.de
 * @Date: 28.05.2017.
 */
public class Presenter implements Observer {

  private Arrangement model;
  private MainFrame view;

  private LeastMedianOfSquaresEstimator lms;

  private Double max;
  private Double min;

  public Presenter(Arrangement model, MainFrame view) {
    this.model = model;
    this.view = view;
//        Double[] x = {1d, 2d, 3d, 4d, 10d, 12d, 18d};
//        Double[] y = {9d, 15d, 19d, 20d, 45d, 55d, 78d};
    Double[] x = {18d, 24d, 30d, 34d, 38d};
    Double[] y = {18d, 26d, 30d, 40d, 70d};
//        Double[] x = {1d,3d,4d,5d,8d};
//        Double[] y = {4d,2d,1d,0d,0d};
    view.logHeading("Duale Darstellung der Punkte als Geraden:");
    for (int j = 0; j < x.length; j++) {
      Line p = new Line(x[j], y[j]);
      p.setId(j+"");
      view.log("f(x) = " + p.getM() + "x + " + p.getB());
      this.model.addLine(p);
    }

    calcArrangementNodes();
    //print
    List<String> heading = new LinkedList<>();
    List<List<String>> rows = new LinkedList<>();
    heading.add("X - Koordinate");
    heading.add("Y - Koordinate");
    for (Point p : model.getNodes()) {
      LinkedList<String> rowEntry = new LinkedList<>();
      rowEntry.add(p.getX().toString());
      rowEntry.add(p.getY().toString());
      rows.add(rowEntry);
    }
    view.logHeading("Schnittpunkte der Dualen Geraden:");
    view.createTable(heading, rows);
  }


  @Override
  public void update(Observable o, Object arg) {
    Line result = ((Line) arg);
    if (result.getId() == "lms"){
      SwingUtilities.invokeLater(() -> {
        getView().visualizeLMS(result.getM(), result.getB());
        //getView().setLmsIsComplete(true);
        getView().logHeading("Least Median of Squares");
        getView().log("<b>m:</b> " + result.getM());
        getView().log("<b>b:</b> " + result.getB());
        getView().logSuccess("Berechnung wurde Erfolgreich durchgeführt");
      });
    }

    if (result.getId() == "rm"){
      SwingUtilities.invokeLater(() -> {
        getView().visualizeRM(result.getM(), result.getB());
        getView().logHeading("Repeated Median Estimator");
        getView().log("<b>m:</b> " + result.getM());
        getView().log("<b>b:</b> " + result.getB());
        getView().logSuccess("Berechnung wurde Erfolgreich durchgeführt");
      });
    }

  }


  public void startArrangementVisualization() {
    view.createArrangement();
  }

  public void calculateLMS(String[] input) {
    Double constant = Double.parseDouble(input[0]);
    Double error = Double.parseDouble(input[1]);
    lms = new LeastMedianOfSquaresEstimator(model.getLines(), model.getNodes(), this);
    lms.setConstant(constant);
    lms.setQuantileError(error);
    lms.addObserver(this);
    lms.run();
  }

  public void calculateRM(String input){
    RepeatedMedianEstimator rm =  new RepeatedMedianEstimator(this.getLines(), this);
    rm.setBeta(Double.parseDouble(input));
    rm.addObserver(this);
    rm.run();
  }


  public Point calcIntersection(Line a, Line b) {
    Line p1 = a;
    Line p2 = b;

    Double x = (p1.getB() - p2.getB()) / (p2.getM() - p1.getM());
    Double y = ((p1.getM() * p2.getB()) - (p2.getM() * p1.getB())) / (p1.getM() - p2.getM());

    return new Point(x, y);
  }

  public void calcArrangementNodes() {
    try {
      Thread thread = new Thread(() -> {
        for (int i = 0; i < getLines().size(); i++) {
          for (int j = i; j < getLines().size(); j++) {
            if (i != j) {
              model.addNode(calcIntersection(getLines().get(j), getLines().get(i)));
            }
          }
        }
      });
      thread.start();
      thread.join();
    } catch (InterruptedException e) {
      e.printStackTrace();
    }

  }

  public LinkedList<LinkedList<Point>> calcArrangementLines() {
    LinkedList<LinkedList<Point>> lineCoordinates = new LinkedList<>();
    double x1 = -1000;
    double x2 = 1000;

    for (Line point : model.getLines()) {
      LinkedList line = new LinkedList();
      double y1 = (point.getM() * x1 + point.getB());
      double y2 = (point.getM() * x2 + point.getB());
      line.add(new Point(x1, y1));
      line.add(new Point(x2, y2));
      lineCoordinates.add(line);
    }

    return lineCoordinates;
  }

  /***************************************************************************************************************************
   *                                          Getter und Setter Methoden
   ***************************************************************************************************************************/


  public Arrangement getModel() {
    return model;
  }

  public void setModel(Arrangement model) {
    this.model = model;
  }

  public MainFrame getView() {
    return view;
  }

  public void setView(MainFrame view) {
    this.view = view;
  }

  public LinkedList<Line> getLines() {
    return this.model.getLines();
  }

  public void setLines(LinkedList<Line> lines) {
    this.model.setLines(lines);
  }

  public Double getMax() {
    return max;
  }

  public void setMax(Double max) {
    this.max = max;
  }

  public Double getMin() {
    return min;
  }

  public void setMin(Double min) {
    this.min = min;
  }
}