355 lines
11 KiB
Java
355 lines
11 KiB
Java
package Presenter;
|
|
|
|
import Model.LineModel;
|
|
import Model.Interval;
|
|
import Model.Line;
|
|
import Presenter.Algorithms.IntersectionCounter;
|
|
import Presenter.Algorithms.LeastMedianOfSquaresEstimator;
|
|
import Presenter.Algorithms.RepeatedMedianEstimator;
|
|
import Presenter.Algorithms.TheilSenEstimator;
|
|
import Presenter.Evaluation.EvaluateAlgorithms;
|
|
import Presenter.Generator.DatasetGenerator;
|
|
import Presenter.ImportExport.DataExporter;
|
|
import Presenter.ImportExport.DataImporter;
|
|
import View.MainFrame;
|
|
|
|
import javax.swing.*;
|
|
import java.io.File;
|
|
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: 28.05.2017.
|
|
*/
|
|
public class Presenter implements Observer {
|
|
|
|
private LineModel model;
|
|
private MainFrame view;
|
|
private EvaluateAlgorithms eval;
|
|
|
|
/* Threads */
|
|
private Thread tsThread;
|
|
private Thread rmThread;
|
|
private Thread lmsThread;
|
|
private Thread importThread;
|
|
private Thread exportThread;
|
|
private Thread generatorThread;
|
|
private Thread evalThread;
|
|
|
|
public Presenter(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(eval.getData()));
|
|
}
|
|
|
|
if (result[0] == "eval"){
|
|
SwingUtilities.invokeLater(() -> getView().appendEvalResult(result));
|
|
}
|
|
|
|
if (result[0] == "lines-res"){
|
|
SwingUtilities.invokeLater(() -> getView().drawLineResult(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]);
|
|
getView().log(result[2]);
|
|
getView().log(result[3] + "<hr>");
|
|
});
|
|
}
|
|
}
|
|
|
|
public void visualizeDualLines() {
|
|
view.createDualityDialog();
|
|
}
|
|
|
|
/***************************************************************************************************************************
|
|
* Ausführung der Algorithmen
|
|
***************************************************************************************************************************/
|
|
public void calculateLMS(String[] input) {
|
|
if (input[0] != null && input[1] != null){
|
|
if (lmsThread == null || !lmsThread.isAlive()){
|
|
lmsThread = new Thread(() -> {
|
|
Double constant = Double.parseDouble(input[0]);
|
|
Double error = Double.parseDouble(input[1]);
|
|
LeastMedianOfSquaresEstimator lms = new LeastMedianOfSquaresEstimator(getModel().getLines(), getModel().getNodes(), this);
|
|
lms.setConstant(constant);
|
|
lms.setQuantileError(error);
|
|
lms.addObserver(this);
|
|
lms.run();
|
|
lms.getResult();
|
|
});
|
|
lmsThread.start();
|
|
try {
|
|
lmsThread.join();
|
|
} catch (InterruptedException e) {
|
|
e.printStackTrace();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
public void calculateRM(String input){
|
|
if (input != null){
|
|
if (rmThread == null || !rmThread.isAlive()){
|
|
rmThread = new Thread(() -> {
|
|
RepeatedMedianEstimator rm = new RepeatedMedianEstimator(getModel().getLines(), this);
|
|
Double parameter = Double.parseDouble(input);
|
|
rm.setBeta(parameter);
|
|
rm.addObserver(this);
|
|
rm.run();
|
|
rm.getResult();
|
|
});
|
|
rmThread.start();
|
|
try {
|
|
rmThread.join();
|
|
} catch (InterruptedException e) {
|
|
e.printStackTrace();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
public void calculateTS(String input){
|
|
if (input != null){
|
|
if (tsThread == null || !tsThread.isAlive()){
|
|
tsThread = new Thread(() ->{
|
|
TheilSenEstimator ts = new TheilSenEstimator(getModel().getLines(), getModel().getNodes(),this);
|
|
ts.addObserver(this);
|
|
ts.run();
|
|
ts.getResult();
|
|
});
|
|
tsThread.start();
|
|
try {
|
|
tsThread.join();
|
|
} catch (InterruptedException e) {
|
|
e.printStackTrace();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/***************************************************************************************************************************
|
|
* Hilfsmethoden
|
|
***************************************************************************************************************************/
|
|
public void setup(){
|
|
//Darstellung der Schnittpunkte in einer Tabelle
|
|
List<String> heading = new LinkedList<>();
|
|
List<List<String>> rows = new LinkedList<>();
|
|
heading.add("Geraden");
|
|
for (int j = 0; j < getModel().getLines().size()-2; j++) {
|
|
LinkedList<String> rowEntry = new LinkedList<>();
|
|
Line p1 = getModel().getLines().get(j);
|
|
rowEntry.add("f(x) = " + p1.getM() + "x + " + p1.getB());
|
|
|
|
if (j+1 < getModel().getLines().size()){
|
|
Line p2 = getModel().getLines().get(j+1);
|
|
rowEntry.add("f(x) = " + p2.getM() + "x + " + p2.getB());
|
|
}
|
|
|
|
if (j+2 < getModel().getLines().size()){
|
|
Line p3 = getModel().getLines().get(j+2);
|
|
rowEntry.add("f(x) = " + p3.getM() + "x + " + p3.getB());
|
|
}
|
|
rows.add(rowEntry);
|
|
}
|
|
getView().logHeading("Schnittpunkte der Dualen Geraden:");
|
|
getView().createTable(heading, rows);
|
|
|
|
getView().log("<hr>");
|
|
}
|
|
|
|
public void calculateIntersections() {
|
|
try {
|
|
Thread thread = new Thread(() -> {
|
|
IntersectionCounter counter = new IntersectionCounter();
|
|
counter.run(getLines(), new Interval(-99999,99999));
|
|
counter.calculateIntersectionAbscissas(getModel());
|
|
getModel().setXbounds();
|
|
getModel().setYbounds();
|
|
|
|
});
|
|
thread.start();
|
|
thread.join();
|
|
} catch (InterruptedException e) {
|
|
e.printStackTrace();
|
|
}
|
|
}
|
|
|
|
public void startImport(File file){
|
|
if (importThread == null || !importThread.isAlive()){
|
|
importThread = new Thread(()->{
|
|
DataImporter importer = new DataImporter(file, this);
|
|
importer.addObserver(this);
|
|
importer.run();
|
|
});
|
|
importThread.start();
|
|
try {
|
|
importThread.join();
|
|
} catch (InterruptedException e) {
|
|
e.printStackTrace();
|
|
}
|
|
}
|
|
}
|
|
|
|
public void startExport(File file){
|
|
if (exportThread == null || !exportThread.isAlive()){
|
|
exportThread = new Thread(()->{
|
|
DataExporter exporter = new DataExporter(getModel(), file);
|
|
exporter.addObserver(this);
|
|
exporter.export();
|
|
});
|
|
exportThread.start();
|
|
try {
|
|
exportThread.join();
|
|
} catch (InterruptedException e) {
|
|
e.printStackTrace();
|
|
}
|
|
}
|
|
}
|
|
|
|
public void generateDataset(){
|
|
if (generatorThread == null || !generatorThread.isAlive()){
|
|
generatorThread = new Thread(() -> {
|
|
DatasetGenerator generator = new DatasetGenerator();
|
|
generator.addObserver(this);
|
|
getModel().setLines(generator.generateDataset());
|
|
calculateIntersections();
|
|
getView().enableFunctionality();
|
|
});
|
|
generatorThread.start();
|
|
try {
|
|
generatorThread.join();
|
|
} catch (InterruptedException e) {
|
|
e.printStackTrace();
|
|
}
|
|
}
|
|
}
|
|
|
|
public void startEvaluation(){
|
|
|
|
if (evalThread == null || !evalThread.isAlive()){
|
|
evalThread = new Thread(() ->{
|
|
try {
|
|
eval = new EvaluateAlgorithms();
|
|
eval.addObserver(this);
|
|
eval.run();
|
|
} catch (InterruptedException e) {
|
|
e.printStackTrace();
|
|
}
|
|
});
|
|
evalThread.start();
|
|
}
|
|
}
|
|
/***************************************************************************************************************************
|
|
* Getter und Setter Methoden
|
|
***************************************************************************************************************************/
|
|
|
|
|
|
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 LinkedList<Line> getLines() {
|
|
return this.model.getLines();
|
|
}
|
|
|
|
public void setLines(LinkedList<Line> lines) {
|
|
this.model.setLines(lines);
|
|
}
|
|
|
|
}
|