some improvements: usage of executor instead of threads and primitve data types

master
Armin Wolf 5 years ago
parent 51ada744da
commit 0171629a9a

@ -8,6 +8,8 @@ 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.
@ -21,6 +23,7 @@ public abstract class AbstractPresenter implements Observer {
private LineModel model;
private MainFrame view;
private EvaluateAlgorithms eval;
private final ExecutorService executor;
/**
@ -31,6 +34,7 @@ public abstract class AbstractPresenter implements Observer {
public AbstractPresenter(LineModel model, MainFrame view) {
this.model = model;
this.view = view;
executor = Executors.newCachedThreadPool();
}
@Override
@ -204,4 +208,8 @@ public abstract class AbstractPresenter implements Observer {
public void setEval(EvaluateAlgorithms eval) {
this.eval = eval;
}
public ExecutorService getExecutor() {
return executor;
}
}

@ -16,6 +16,8 @@ import view.MainFrame;
import javax.swing.table.DefaultTableModel;
import java.io.File;
import java.util.LinkedList;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
/**
@ -27,17 +29,6 @@ import java.util.LinkedList;
*/
public class Presenter extends AbstractPresenter {
/* Threads */
private Thread tsThread;
private Thread rmThread;
private Thread lmsThread;
private Thread importThread;
private Thread importPictureThread;
private Thread exportThread;
private Thread exportResultThread;
private Thread generatorThread;
private Thread evalThread;
public Presenter(LineModel model, MainFrame view) {
super(model, view);
@ -54,81 +45,56 @@ public class Presenter extends AbstractPresenter {
/**
* Die Berechnung durch des Algorithmus zum LMS-Schätzer wird gestartet.
*
* @param input Parameter für den Algorithmus
*/
public void calculateLMS(String[] input) {
if (input[0] != null && input[1] != null) {
if (lmsThread == null || !lmsThread.isAlive()) {
lmsThread = new Thread(() -> {
//Parameter für den Algortihmus
Double constant = Double.parseDouble(input[0]);
Double error = Double.parseDouble(input[1]);
LeastMedianOfSquaresEstimator lms = new LeastMedianOfSquaresEstimator(getModel().getLines(), getModel().getNodes(), this);
//setzen der Parameter
lms.setConstant(constant);
lms.setQuantileError(error);
//Presenter soll die Klasse überwachen
lms.addObserver(this);
lms.run();
lms.pepareResult();
});
lmsThread.start();
try {
lmsThread.join();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
//Parameter für den Algortihmus
Double constant = Double.parseDouble(input[0]);
Double error = Double.parseDouble(input[1]);
LeastMedianOfSquaresEstimator lms = new LeastMedianOfSquaresEstimator(getModel().getLines(), getModel().getNodes(), this);
//setzen der Parameter
lms.setConstant(constant);
lms.setQuantileError(error);
//Presenter soll die Klasse überwachen
lms.addObserver(this);
getExecutor().execute(lms);
}
}
/**
* Die Berechnung durch des Algorithmus zum RM-Schätzer wird gestartet.
*
* @param input Parameter für den Algorithmus
*/
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);
//Presenter soll die Klasse überwachen
rm.addObserver(this);
rm.run();
rm.pepareResult();
});
rmThread.start();
try {
rmThread.join();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
RepeatedMedianEstimator rm = new RepeatedMedianEstimator(getModel().getLines(), this);
Double parameter = Double.parseDouble(input);
rm.setBeta(parameter);
//Presenter soll die Klasse überwachen
rm.addObserver(this);
getExecutor().execute(rm);
}
}
/**
* Die Berechnung durch des Algorithmus zum TS-Schätzer wird gestartet.
* Die Berechnung durch des Algorithmus zum TS-Schätzer wird gestartet.
*
* @param input Parameter für den Algorithmus
*/
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);
//Presenter soll die Klasse überwachen
ts.addObserver(this);
ts.run();
ts.pepareResult();
});
tsThread.start();
try {
tsThread.join();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
TheilSenEstimator ts = new TheilSenEstimator(getModel().getLines(), getModel().getNodes(), this);
//Presenter soll die Klasse überwachen
ts.addObserver(this);
getExecutor().execute(ts);
}
}
@ -138,201 +104,167 @@ public class Presenter extends AbstractPresenter {
/**
* Startet den Import des Datensatzes.
*
* @param file importierender Datensatz
*/
public void startImport(File file) {
if (importThread == null || !importThread.isAlive()) {
importThread = new Thread(() -> {
DataImporter importer = new DataImporter(file);
//Presenter soll die Klasse überwachen
importer.addObserver(this);
DataImporter importer = new DataImporter(file);
//Presenter soll die Klasse überwachen
importer.addObserver(this);
getExecutor().execute(new Runnable() {
@Override
public void run() {
LinkedList<Line> importedLines = importer.run();
if (importedLines != null) {
//Berechnung der Schnittpunkte und vis. der Ergebnisse (anz. Geraden, anz. Schnittpunkte)
getModel().setLines(importedLines);
computeIntersections();
}
});
importThread.start();
try {
importThread.join();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
});
}
/**
* Startet den Import eines Bildes.
*
* @param file importierendes Bild
*/
public void startPictureDataImport(File file) {
if (importPictureThread == null || !importPictureThread.isAlive()) {
importPictureThread = new Thread(() -> {
PictureProcessor pictureProcessor = new PictureProcessor(this, file);
//Presenter soll die Klasse überwachen
pictureProcessor.addObserver(this);
PictureProcessor pictureProcessor = new PictureProcessor(this, file);
//Presenter soll die Klasse überwachen
pictureProcessor.addObserver(this);
getExecutor().execute(new Runnable() {
@Override
public void run() {
pictureProcessor.run();
//Berechnung der Schnittpunkte und vis. der Ergebnisse (anz. Geraden, anz. Schnittpunkte)
computeIntersections();
});
importPictureThread.start();
try {
importPictureThread.join();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
});
}
/**
* Startet den Export des akteullen Datensatzes (nur der Geraden)
*
* @param file Datei in der die Informationen gespeichert werden sollen
*/
public void startExport(File file) {
if (exportThread == null || !exportThread.isAlive()) {
exportThread = new Thread(() -> {
DataExporter exporter = new DataExporter(getModel().getLines(), file);
//Presenter soll die Klasse überwachen
exporter.addObserver(this);
DataExporter exporter = new DataExporter(getModel().getLines(), file);
//Presenter soll die Klasse überwachen
exporter.addObserver(this);
getExecutor().execute(new Runnable() {
@Override
public void run() {
exporter.export();
});
exportThread.start();
try {
exportThread.join();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
});
}
/**
* Startet den Export des akteullen Datensatzes im Rahmen der Evaluation (nur der Geraden)
*
* @param file Datei in der die Informationen gespeichert werden sollen
*/
public void startDatasetExportEvaluation(File file) {
if (exportThread == null || !exportThread.isAlive()) {
exportThread = new Thread(() -> {
DataExporter exporter = new DataExporter(getEval().getData(), file);
//Presenter soll die Klasse überwachen
exporter.addObserver(this);
DataExporter exporter = new DataExporter(getEval().getData(), file);
//Presenter soll die Klasse überwachen
exporter.addObserver(this);
getExecutor().execute(new Runnable() {
@Override
public void run() {
exporter.export();
});
exportThread.start();
try {
exportThread.join();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
});
}
/**
* Startet den Export der Ergebnisse der Evaluation in Form einer LaTeX Datei
*
* @param model TableModel das die Berechnenten Ergebnisse enthält
* @param file Datei in die exportiert werden soll
*/
public void startResultExport(DefaultTableModel model, File file) {
if (exportResultThread == null || !exportResultThread.isAlive()) {
exportResultThread = new Thread(() -> {
EvalResultLatexExport exporter = new EvalResultLatexExport(model, file);
exporter.writeFile();
});
exportResultThread.start();
try {
exportResultThread.join();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
getExecutor().execute(() -> {
EvalResultLatexExport exporter = new EvalResultLatexExport(model, file);
exporter.writeFile();
});
}
/**
* Startet das generieren der Datensätze der Größe <code>n</code>
* @param n Größe des Datensatzes
*
* @param n Größe des Datensatzes
* @param type Art der Datensatzes
*/
public void generateDataset(int n, int type) {
if (generatorThread == null || !generatorThread.isAlive()) {
generatorThread = new Thread(() -> {
DatasetGenerator generator = new DatasetGenerator();
generator.addObserver(this);
switch (type){
case 0:
getModel().setLines(generator.generateDataCloud(n));
break;
case 1:
getModel().setLines(generator.generateDataLines(n));
break;
case 2:
getModel().setLines(generator.generateCircle(n));
break;
default:
getModel().setLines(generator.generateDataCloud(n));
break;
}
computeIntersections();
getView().enableFunctionality();
});
generatorThread.start();
try {
generatorThread.join();
} catch (InterruptedException e) {
e.printStackTrace();
DatasetGenerator generator = new DatasetGenerator();
generator.addObserver(this);
getExecutor().execute(() -> {
switch (type) {
case 0:
getModel().setLines(generator.generateDataCloud(n));
break;
case 1:
getModel().setLines(generator.generateDataLines(n));
break;
case 2:
getModel().setLines(generator.generateCircle(n));
break;
default:
getModel().setLines(generator.generateDataCloud(n));
break;
}
}
computeIntersections();
getView().enableFunctionality();
});
}
/**
* Startet die Evaluation zu einen gegegbenen Typ mit den Informationen zu den Datensatz.
* Beispielsweise kann ein Alg. auf mit verschiedenen Datensätzen untersucht werden, oder mehrere Algorithmen
* auf einem gegebenen Datensatz.
* @param typ Typ der Evaluation
* @param n Größe des Datensatzes
* @param alg code für die auszuführenden Algorithmen (siehe <code>EvaluationPanel.checkSelection()</code> Method)
*
* @param typ Typ der Evaluation
* @param n Größe des Datensatzes
* @param alg code für die auszuführenden Algorithmen (siehe <code>EvaluationPanel.checkSelection()</code> Method)
* @param datasettyp Typ des Datensatzes (Geradem Punktwolke, Kreis und Gerade)
*/
public void startEvaluation(int typ, int n, int alg, String datasettyp) {
if (evalThread == null || !evalThread.isAlive()) {
evalThread = new Thread(() -> {
try {
setEval(new EvaluateAlgorithms(typ, n, alg, datasettyp));
getEval().addObserver(this);
getEval().run();
} catch (InterruptedException e) {
e.printStackTrace();
}
});
evalThread.start();
}
setEval(new EvaluateAlgorithms(typ, n, alg, datasettyp));
getEval().addObserver(this);
getExecutor().submit(() -> {
getEval().run();
});
}
/**
* Startet die Evaluation zu einen gegegbenen Datensatz, der importiert wird.
* Beispielsweise kann ein Alg. auf mit verschiedenen Datensätzen untersucht werden, oder mehrere Algorithmen
* auf einem gegebenen Datensatz.
* @param typ Typ der Evaluation
* @param alg code für die auszuführenden Algorithmen (siehe <code>EvaluationPanel.checkSelection()</code> Method)
*
* @param typ Typ der Evaluation
* @param alg code für die auszuführenden Algorithmen (siehe <code>EvaluationPanel.checkSelection()</code> Method)
* @param file Typ des Datensatzes (Geradem Punktwolke, Kreis und Gerade)
*/
public void startEvaluation(int typ, int alg, File file) {
if (evalThread == null || !evalThread.isAlive()) {
evalThread = new Thread(() -> {
try {
EvaluateAlgorithms evaluateAlgorithms = new EvaluateAlgorithms(typ, alg, file);
if (evaluateAlgorithms.getData().size() > 0) {
setEval(evaluateAlgorithms);
getEval().addObserver(this);
getEval().run();
}
} catch (InterruptedException e) {
e.printStackTrace();
}
});
evalThread.start();
EvaluateAlgorithms evaluateAlgorithms = new EvaluateAlgorithms(typ, alg, file);
if (evaluateAlgorithms.getData().size() > 0) {
setEval(evaluateAlgorithms);
getEval().addObserver(this);
}
getExecutor().submit(() -> {
getEval().run();
}).isDone();
}
}

@ -7,10 +7,11 @@ package presenter.algorithms;
* @Email: a_wolf28@uni-muenster.de
* @Date: 28.05.2017.
*/
public interface Algorithm {
public interface Algorithm extends Runnable{
/**
* Startet die Berechnung des jeweiligen Algorithmus.
*/
@Override
void run();
/**

@ -33,11 +33,11 @@ public class LeastMedianOfSquaresEstimator extends Observable implements Algorit
private Interval subSlabU2;
private Line sigmaMin;
private double heightsigmaMin;
private Double intersectionsPoint;
private Double constant = 0.5;
private double intersectionsPoint;
private double constant = 0.5;
private Double slope;
private Double yInterception;
private double slope;
private double yInterception;
/**
* Konstruktor
@ -115,16 +115,16 @@ public class LeastMedianOfSquaresEstimator extends Observable implements Algorit
//(c.) otherwise....
// get random intersections point...
Collections.shuffle(tmpIntersections, new Random());
boolean found = false;
for (int i = 0; i < tmpIntersections.size(); i++) {
if (tmpIntersections.get(i).getX() > interval.getLower()
&& tmpIntersections.get(i).getX() < interval.getUpper()) {
intersectionsPoint = tmpIntersections.get(i).getX();
found = true;
break;
} else {
intersectionsPoint = null;
}
}
if (intersectionsPoint != null) {
if (found) {
splitActiveSlab(intersectionsPoint, interval);
//(d.) this may update sigma min
upperBound(intersectionsPoint);
@ -149,6 +149,8 @@ public class LeastMedianOfSquaresEstimator extends Observable implements Algorit
}
end = System.currentTimeMillis();
System.out.println("Zeit: "+ ((end-start)/1000));
pepareResult();
}
/**

@ -40,18 +40,18 @@ public class RepeatedMedianEstimator extends Observable implements Algorithm {
private ArrayList<Line> linesInCenterSlab;
private ArrayList<Line> linesInRightSlab;
private Double r;
private Integer n;
private Double k;
private Double kLow;
private Double kHigh;
private Double beta;
private double r;
private int n;
private double k;
private double kLow;
private double kHigh;
private double beta;
private Double thetaLow;
private Double thetaHigh;
private double thetaLow;
private double thetaHigh;
private Double slope;
private Double yInterception;
private double slope;
private double yInterception;
/**
* Konstruktor
@ -137,6 +137,8 @@ public class RepeatedMedianEstimator extends Observable implements Algorithm {
}
end = System.currentTimeMillis();
System.out.println("Zeit: "+ ((end-start)/1000));
pepareResult();
}

@ -18,9 +18,9 @@ import java.util.*;
*/
public class TheilSenEstimator extends Observable implements Algorithm {
private final Double POSITIV_INF = 99999.0;
private final Double NEGATIV_INF = -99999.0;
private final Double EPSILON = 0.00001;
private final double POSITIV_INF = 99999.0;
private final double NEGATIV_INF = -99999.0;
private final double EPSILON = 0.00001;
private Presenter presenter;
private ArrayList<Line> setOfLines;
private ArrayList<Point> setOfIntersections;
@ -30,19 +30,19 @@ public class TheilSenEstimator extends Observable implements Algorithm {
private ArrayList<Double> yCoordinates;
private ArrayList<Double> xCoordinates;
//Hilfsvariablen (siehe original Paper)
private Double j;
private Integer jA;
private Integer jB;
private Double r;
private Integer n;
private Double N;
private Integer k;
private double j;
private int jA;
private int jB;
private double r;
private int n;
private double N;
private int k;
//Intervall und die temporaeren Grenzen
private Interval interval;
private Double aVariant;
private Double bVariant;
private Double slope;
private Double yInterception;
private double aVariant;
private double bVariant;
private double slope;
private double yInterception;
/**
* Konstruktor
@ -116,6 +116,8 @@ public class TheilSenEstimator extends Observable implements Algorithm {
N = (double) getOpenIntervalSize(interval.getLower(), interval.getUpper(), intervalIntersections);
}
}
pepareResult();
}

@ -19,8 +19,8 @@ import java.util.LinkedList;
public class NaivLeastMedianOfSquaresEstimator implements Algorithm {
private ArrayList<Point> set = new ArrayList<>();
private Integer n;
private Double ds, b, m;
private int n;
private double ds, b, m;
/**
* Konstruktor
@ -40,9 +40,9 @@ public class NaivLeastMedianOfSquaresEstimator implements Algorithm {
b = 0d;
m = 0d;
ArrayList<Point> triple = new ArrayList<>();
Double beta;
Double alpha;
Double dijk;
double beta;
double alpha;
double dijk;
System.out.println("=== S T A R T - naiv L M S ===");
long start;
long end;
@ -76,7 +76,7 @@ public class NaivLeastMedianOfSquaresEstimator implements Algorithm {
* @param b Steigung
* @return medianer Fehler
*/
private Double f(Double a, Double b) {
private Double f(double a, double b) {
ArrayList<Double> res = new ArrayList<>();
for (Point p : set) {
res.add(Math.abs(p.getY() - (a + b * p.getX())));

@ -22,8 +22,8 @@ public class NaivRepeatedMedianEstimator implements Algorithm {
private HashMap<String, ArrayList<Double>> slopesPerLine;
private HashMap<String, ArrayList<Double>> interceptPerLine;
private ArrayList<Double> xMedians, yMedians;
private Double medianX;
private Double medianY;
private double medianX;
private double medianY;
/**
* Konstruktor
@ -69,7 +69,7 @@ public class NaivRepeatedMedianEstimator implements Algorithm {
ArrayList<Double> list = slopesPerLine.get(l);
int size = list.size() / 2;
if (size > 0) {
Double medianX = FastElementSelector.randomizedSelect(list, size);
double medianX = FastElementSelector.randomizedSelect(list, size);
xMedians.add(medianX);
}
}
@ -79,7 +79,7 @@ public class NaivRepeatedMedianEstimator implements Algorithm {
ArrayList<Double> list = interceptPerLine.get(l);
int size = list.size() / 2;
if (size > 0) {
Double medianY = FastElementSelector.randomizedSelect(list, size);
double medianY = FastElementSelector.randomizedSelect(list, size);
yMedians.add(medianY);
}
}
@ -102,10 +102,10 @@ public class NaivRepeatedMedianEstimator implements Algorithm {
* @return
*/
private Point calculateLine(Line startPoint, Line endPoint) {
Double xi;
Double xj;
Double yi;
Double yj;
double xi;
double xj;
double yi;
double yj;
if (endPoint.getM() > startPoint.getM()) {
xi = startPoint.getM();
@ -120,22 +120,22 @@ public class NaivRepeatedMedianEstimator implements Algorithm {
}
Double m = (yj - yi) / (xj - xi);
Double b = ((xj * yi) - (xi * yj)) / (xj - xi);
double m = (yj - yi) / (xj - xi);
double b = ((xj * yi) - (xi * yj)) / (xj - xi);
return new Point(m, b);
}
/**
* @return Steigung
*/
public Double getM() {
public double getM() {
return medianX * -1;
}
/**
* @return y-Achsenabschnitt
*/
public Double getB() {
public double getB() {
return medianY * -1;
}
}

@ -18,8 +18,8 @@ public class NaivTheilSenEstimator implements Algorithm {
private LinkedList<Line> lines;
private Double slope;
private Double yInterception;
private double slope;
private double yInterception;
/**
* Konstruktor
@ -60,8 +60,8 @@ public class NaivTheilSenEstimator implements Algorithm {
list1.add(lines.get(i).getM());
list2.add(lines.get(i).getB());
}
Double median1 = FastElementSelector.randomizedSelect(list1, list1.size() / 2);
Double median2 = FastElementSelector.randomizedSelect(list2, list2.size() / 2);
double median1 = FastElementSelector.randomizedSelect(list1, list1.size() / 2);
double median2 = FastElementSelector.randomizedSelect(list2, list2.size() / 2);
slope = FastElementSelector.randomizedSelect(slopesList, slopesList.size() / 2);
yInterception = median2 - slope * median1;
end = System.currentTimeMillis();
@ -76,14 +76,14 @@ public class NaivTheilSenEstimator implements Algorithm {
/**
* @return Steigung
*/
public Double getM() {
public double getM() {
return slope * -1;
}
/**
* @return y-Achsenabschnitt
*/
public Double getB() {
public double getB() {
return yInterception * -1;
}
}

@ -145,7 +145,7 @@ public class EvaluateAlgorithms extends Observable {
* Startet die Evaluation zu den passenden Typ. Bei beendigung wird der Beobachter informiert.
* @throws InterruptedException
*/
public void run() throws InterruptedException {
public void run() {
setChanged();
String[] msg = {"eval-dataset-generated"};
notifyObservers(msg);
@ -165,8 +165,12 @@ public class EvaluateAlgorithms extends Observable {
b[0] = l.getB();
});
t.start();
startLMS();
t.join();
try {
startLMS();
t.join();
} catch (InterruptedException e) {
e.printStackTrace();
}
result = getScaleDependentMeasure(arrangement.getLines(), lmsRes[0], lmsRes[1]);
result.addAll(getScaledErrorBasedMeasure(arrangement.getLines(), lmsRes[0], lmsRes[1], m[0], b[0]));
@ -182,7 +186,11 @@ public class EvaluateAlgorithms extends Observable {
b[0] = r.getB();
});
t.start();
startRM();
try {
startRM();
} catch (InterruptedException e) {
e.printStackTrace();
}
result = getScaleDependentMeasure(arrangement.getLines(), rmRes[0], rmRes[1]);
result.addAll(getScaledErrorBasedMeasure(arrangement.getLines(), rmRes[0], rmRes[1], m[0], b[0]));
Double[] tmp = {rmRes[0], rmRes[1], m[0], b[0]};
@ -197,7 +205,11 @@ public class EvaluateAlgorithms extends Observable {
b[0] = ts.getB();
});
t.start();
startTS();
try {
startTS();
} catch (InterruptedException e) {
e.printStackTrace();
}
result = getScaleDependentMeasure(arrangement.getLines(), tsRes[0], tsRes[1]);
result.addAll(getScaledErrorBasedMeasure(arrangement.getLines(), tsRes[0], tsRes[1], m[0], b[0]));
Double[] tmp = {tsRes[0], tsRes[1], m[0], b[0]};
@ -210,8 +222,12 @@ public class EvaluateAlgorithms extends Observable {
ArrayList<Double[]> lineRes;
switch (alg) {
case 3:
startLMS();
startRM();
try {
startLMS();
startRM();
} catch (InterruptedException e) {
e.printStackTrace();
}
result = getPercentigeErrorBasedMeasure(arrangement.getLines(), lmsRes[0], lmsRes[1]);
multipleResults.add(result);
@ -227,8 +243,12 @@ public class EvaluateAlgorithms extends Observable {
break;
case 4:
startLMS();
startTS();
try {
startLMS();
startTS();
} catch (InterruptedException e) {
e.printStackTrace();
}
result = getPercentigeErrorBasedMeasure(arrangement.getLines(), lmsRes[0], lmsRes[1]);
multipleResults.add(result);
@ -243,8 +263,12 @@ public class EvaluateAlgorithms extends Observable {
sendPloteLineResults(lineRes, new Integer[]{0, 2});
break;
case 5:
startRM();
startTS();
try {
startRM();
startTS();
} catch (InterruptedException e) {
e.printStackTrace();
}
result = fillPseudoResults();
multipleResults.add(result);
@ -259,9 +283,13 @@ public class EvaluateAlgorithms extends Observable {
sendPloteLineResults(lineRes, new Integer[]{1, 2});
break;
case 6:
startLMS();
startRM();
startTS();
try {
startLMS();
startRM();
startTS();
} catch (InterruptedException e) {
e.printStackTrace();
}
result = getPercentigeErrorBasedMeasure(arrangement.getLines(), lmsRes[0], lmsRes[1]);
multipleResults.add(result);

Loading…
Cancel
Save