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

package Presenter;

import Model.Arrangement;
import Model.Coordinates;
import View.*;

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: 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};
//        Float[] x = {18f,24f,30f,34f,38f};
//        Float[] y = {18f,26f,30f,40f,70f};
//        Double[] x = {1d,3d,4d,5d,8d};
//        Double[] y = {4d,2d,1d,0d,0d};
        view.log("Koordinaten der Punkte:");
        for (int j=0;j<7;j++){
            Coordinates p = new Coordinates(x[j], y[j]);
            view.log("f(x) = "+p.getX()+"* x + "+p.getY());
            this.model.addLine(p);
        }
        view.log("");
        calcArrangementNodes();
        //print
        for (Coordinates p : model.getNodes()) {
            view.log(p.getX()+", "+p.getY());
        }
        extractBounds();
    }

    public void getDataFromModel() {

    }

    public void setDataByModel() {

    }

    public void getActionsFromView() {

    }

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

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

    private void extractBounds(){
        Coordinates pmax = Collections.max(model.getLines());
        Coordinates pmin = Collections.min(model.getLines());

        max = pmax.getX() >= pmax.getY() ? pmax.getX() : pmax.getY();
        min = pmin.getX() <= pmin.getY() ? pmin.getX() : pmin.getY();
    }

    public Coordinates calcIntersection(Coordinates a, Coordinates b){
        Coordinates p1;
        Coordinates p2;

        if (a.compareTo(b) > 0){
            p1 = a;
            p2 = b;
        } else {
            p1 = b;
            p2 = a;
        }

        Double x = (p1.getY() - p2.getY()) / (p2.getX() - p1.getX());
        Double y = ((p1.getX() * p2.getY()) - (p2.getX() * p1.getY())) / (p1.getX() - p2.getX());
        System.out.printf("RESULT: (%3.3f, %3.3f)\n",x, y);

        return new Coordinates(x,y);
    }

    public void calcArrangementNodes(){
        Thread thread = new Thread(new Runnable() {
            @Override
            public void run() {
                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();
        try {
            thread.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

    }
    /***************************************************************************************************************************
     *                                          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<Coordinates> getLines() {
        return this.model.getLines();
    }

    public void setLines(LinkedList<Coordinates> 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;
    }
}