algorithms-for-computing-line-estimators/LinearRegressionTool/src/main/java/presenter/AbstractPresenter.java

package presenter;

import model.Interval;
import model.Line;
import model.LineModel;
import presenter.algorithms.util.IntersectionCounter;
import presenter.evaluation.EvaluateAlgorithms;
import view.MainFrame;

import javax.swing.*;
import java.util.LinkedList;
import java.util.List;
import java.util.Observable;
import java.util.Observer;

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

    private LineModel model;
    private MainFrame view;

    private EvaluateAlgorithms eval;


    public AbstractPresenter(LineModel model, MainFrame view) {
        this.model = model;
        this.view = view;
    }

    @Override
    public void update(Observable o, Object arg) {
        String[] result = ((String[]) arg);

        if (result[0] == "eval-dataset-generated") {
            SwingUtilities.invokeLater(() -> getView().addEvalDataset(getEval().getData()));
        }

        if (result[0] == "eval-d") {
            SwingUtilities.invokeLater(() -> getView().appendEvalResult(result, Integer.parseInt(result[1]), false));
        }

        if (result[0] == "eval-ds") {
            SwingUtilities.invokeLater(() -> getView().appendEvalResult(result));
        }

        if (result[0] == "eval-t") {
            SwingUtilities.invokeLater(() -> getView().appendEvalResult(result, Integer.parseInt(result[1]), true));
        }

        if (result[0] == "lines-res") {
            SwingUtilities.invokeLater(() -> getView().drawLineResult(result, Integer.parseInt(result[1])));
        }

        if (result[0] == "lines-res-mult") {
            SwingUtilities.invokeLater(() -> getView().drawLineResults(result));
        }

        if (result[0] == "lms") {
            SwingUtilities.invokeLater(() -> {
                getView().visualizeLMS(Double.parseDouble(result[1]), Double.parseDouble(result[2]));
                //getView().setLmsIsComplete(true);
                getView().logHeading("Least Median of Squares");
                getView().log("<b>m:</b> " + result[1]);
                getView().log("<b>b:</b> " + result[2]);
                getView().logSuccess("Berechnung wurde Erfolgreich durchgeführt <hr>");
            });
        }

        if (result[0] == "rm") {
            SwingUtilities.invokeLater(() -> {
                getView().visualizeRM(Double.parseDouble(result[1]), Double.parseDouble(result[2]));
                getView().logHeading("Repeated Median Estimator");
                getView().log("<b>m:</b> " + result[1]);
                getView().log("<b>b:</b> " + result[2]);
                getView().logSuccess("Berechnung wurde Erfolgreich durchgeführt <hr>");
            });
        }

        if (result[0] == "ts") {
            SwingUtilities.invokeLater(() -> {
                getView().visualizeTS(Double.parseDouble(result[1]), Double.parseDouble(result[2]));
                getView().logHeading("Theil-Sen Estimator");
                getView().log("<b>m:</b> " + result[1]);
                getView().log("<b>b:</b> " + result[2]);
                getView().logSuccess("Berechnung wurde Erfolgreich durchgeführt <hr>");
            });
        }

        if (result[0] == "import") {
            Double max = Double.parseDouble(result[1]);
            Double current = Double.parseDouble(result[2]);
            Integer progress = (int) (100 * (current / max));
            //100% erreicht
            if (progress == 100) {
                SwingUtilities.invokeLater(() -> {
                    getView().showImportProgress(progress);
                    getView().enableFunctionality();
                    getView().getProgressDialog().dispose();
                });
                setup();
                Thread t = new Thread(() -> {
                    calculateIntersections();
                });
                t.start();
                try {
                    t.join();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            } else {
                SwingUtilities.invokeLater(() -> {
                    getView().showImportProgress(progress);
                });
            }
        }
        if (result[0] == "export") {
            SwingUtilities.invokeLater(() -> {
                getView().logSuccess("Export Erfolgreich");
                getView().log(result[1] + "<hr>");
            });
        }

        if (result[0] == "generator") {
            SwingUtilities.invokeLater(() -> {
                getView().logSuccess("Generierung Erfolgreich");
                getView().log(result[1] + "<hr>");
                setup();
            });
        }
    }

    public void setup() {
        //Darstellung der Schnittpunkte in einer Tabelle
        List<String> heading = new LinkedList<>();
        List<List<String>> rows = new LinkedList<>();
        heading.add("Geraden im Dualraum");
        for (int j = 0; j < getModel().getLines().size() - 2; j++) {
            LinkedList<String> rowEntry = new LinkedList<>();
            Line p1 = getModel().getLines().get(j);
            String sign = p1.getB() < 0 ? "" : "+";
            rowEntry.add("f(x) = " +String.format("%.3f", p1.getM()) + "x "+ sign + String.format("%.3f",p1.getB()));

            if (j + 1 < getModel().getLines().size()) {
                Line p2 = getModel().getLines().get(j + 1);
                sign = p2.getB() < 0 ? "" : "+";
                rowEntry.add("f(x) = " +String.format("%.3f",p2.getM()) + "x" + sign + String.format("%.3f", p2.getB()));
            }

            if (j + 2 < getModel().getLines().size()) {
                Line p3 = getModel().getLines().get(j + 2);
                sign = p3.getB() < 0 ? "" : "+";
                rowEntry.add("f(x) = " + String.format("%.3f",p3.getM()) + "x"+ sign + String.format("%.3f",p3.getB()));
            }
            rows.add(rowEntry);
        }
        getView().createTable(heading, rows);

        getView().log("<hr>");
    }



    public void calculateIntersections() {
        try {
            Thread thread = new Thread(() -> {
                IntersectionCounter counter = new IntersectionCounter();
                counter.run(getModel().getLines(), new Interval(-99999, 99999));
                counter.calculateIntersectionAbscissas(getModel());
                getModel().setXbounds();
                getModel().setYbounds();

            });
            thread.start();
            thread.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }


    public LineModel getModel() {
        return model;
    }

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

    public MainFrame getView() {
        return view;
    }

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

    public EvaluateAlgorithms getEval() {
        return eval;
    }

    public void setEval(EvaluateAlgorithms eval) {
        this.eval = eval;
    }
}