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

package presenter;

import model.LineModel;
import presenter.evaluation.EvaluateAlgorithms;
import presenter.util.IntersectionComputer;
import view.MainFrame;

import javax.swing.*;
import java.util.Observable;
import java.util.Observer;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

/**
 * 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 final ExecutorService executor;
    private LineModel model;
    private MainFrame view;
    private EvaluateAlgorithms eval;


    /**
     * Konstruktor
     *
     * @param model Modell
     * @param view  View
     */
    public AbstractPresenter(LineModel model, MainFrame view) {
        this.model = model;
        this.view = view;
        executor = Executors.newCachedThreadPool();
    }

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

        switch (observable) {
            case "eval-dataset-generated":
                SwingUtilities.invokeLater(() -> getView().addEvalDataset(getEval().getData()));
                break;
            case "eval-d":
                SwingUtilities.invokeLater(() -> getView().appendEvalResult(result, Integer.parseInt(result[1]), false));
                break;
            case "eval-ds":
                SwingUtilities.invokeLater(() -> getView().appendEvalResult(result));
                break;
            case "eval-t":
                SwingUtilities.invokeLater(() -> getView().appendEvalResult(result, Integer.parseInt(result[1]), true));
                break;
            case "lines-res":
                SwingUtilities.invokeLater(() -> getView().drawLineResult(result, Integer.parseInt(result[1])));
                break;
            case "lines-res-mult":
                SwingUtilities.invokeLater(() -> getView().drawLineResults(result));
                break;
            case "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>");
                });
                break;
            case "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>");
                });
                break;
            case "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>");
                });
                break;
            case "import":
                Double max = Double.parseDouble(result[1]);
                Double current = Double.parseDouble(result[2]);
                Integer progress = (int) (100 * (current / max));
                //100% erreicht
                SwingUtilities.invokeLater(() -> {
                    getView().showImportProgress(progress);
                });
                break;
            case "export":
                SwingUtilities.invokeLater(() -> {
                    getView().logHeading("Export der Daten als CSV");
                    getView().logSuccess("Export war Erfolgreich");
                    getView().log(result[1] + "<hr>");
                });
                break;
            case "generator":
                SwingUtilities.invokeLater(() -> {
                    getView().logSuccess("Generierung war Erfolgreich");
                    getView().log(result[1] + "<hr>");
                });
                break;
        }
    }

    /**
     * Startet das parallele Berechnen der Schnittpunkte der Geraden die im Modell enthalten sind.
     */
    private void startIntersectionCalculation() {
        try {
            Thread thread = new Thread(() -> {
                getModel().resetRanges();
                IntersectionComputer intersectionComputer = new IntersectionComputer(getModel().getLines());
                getModel().setNodes(intersectionComputer.compute());

                getModel().setxMaximum(intersectionComputer.getxMaximum());
                getModel().setxMinimum(intersectionComputer.getxMinimum());
                getModel().setyMaximum(intersectionComputer.getyMaximum());
                getModel().setyMinimum(intersectionComputer.getyMinimum());
            });
            thread.start();
            thread.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    /**
     * Wrapper Methode die das berechnen der Schnittpunkte anstößt und die Ergebnisse(Anzahl der Schnittpunkte)
     * visuell darstellt.
     */
    protected void computeIntersections() {
        Thread t = new Thread(() -> {
            long start, end;

            start = System.currentTimeMillis();
            startIntersectionCalculation();
            end = System.currentTimeMillis();

            System.out.println("Zeit: " + (end - start) / 1000);
        });
        t.start();
        try {
            t.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        //darstellung der Ergebnisse
        SwingUtilities.invokeLater(() -> {
            getView().enableFunctionality();
            getView().getProgressDialog().dispose();
            getView().logHeading("Informationen zu dem aktuellen Modell");
            getView().log("Anzahl der Geraden: " + getModel().getLines().size() + ".");
            getView().log("Anzahl der Schnittpunkte: " + getModel().getNodes().size() + ".");
            getView().logSuccess("Import war Erfolgreich! <hr>");
        });
    }

    /**
     * @return das zu grunde legende Modell
     */
    public LineModel getModel() {
        return model;
    }

    /**
     * @param model das zu grunde legende Modell
     */
    public void setModel(LineModel model) {
        this.model = model;
    }

    /**
     * @return die zu grunde legende View
     */
    public MainFrame getView() {
        return view;
    }

    /**
     * @param view die zu grunde legende View
     */
    public void setView(MainFrame view) {
        this.view = view;
    }

    /**
     * @return Evaluation
     */
    public EvaluateAlgorithms getEval() {
        return eval;
    }

    /**
     * @param eval Evaluation
     */
    public void setEval(EvaluateAlgorithms eval) {
        this.eval = eval;
    }

    public ExecutorService getExecutor() {
        return executor;
    }
}