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 View.MainFrame;

import java.util.Collections;
import java.util.LinkedList;
import java.util.List;


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

    private Arrangement model;
    private MainFrame view;


    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("Dualen Geraden");
        for (int j = 0; j < 5; j++) {
            Line p = new Line(x[j], y[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("Koordinaten der Punkte");
        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();
    }

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

    public void startScatterPlotVisualization() {
        view.createPlot();
    }



    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;

        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() {
        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)));
                    }
                }
            }
            convertCoordinates();
        });
        thread.start();
        try {
            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;
    }
}