From a3d2d97dcfd5cd0dac2d14ed755ad7b193144291 Mon Sep 17 00:00:00 2001 From: Armin Wolf Date: Mon, 18 Sep 2017 23:16:18 +0200 Subject: [PATCH] so siehts schon besser aus :D --- .../src/main/java/model/Line.java | 8 ++ .../src/main/java/model/LineModel.java | 18 +++ .../src/main/java/model/Pair.java | 1 + .../src/main/java/model/Point.java | 8 ++ .../java/presenter/AbstractPresenter.java | 48 ++++--- .../algorithms/util/IntersectionComputer.java | 131 ++++++++++++++++++ .../algorithms/util/IntersectionCounter.java | 29 ++++ .../evaluation/PictureProcessor.java | 11 +- .../main/java/presenter/io/DataImporter.java | 4 +- dataset/minimal.csv | 10 +- 10 files changed, 234 insertions(+), 34 deletions(-) create mode 100644 LinearRegressionTool/src/main/java/presenter/algorithms/util/IntersectionComputer.java diff --git a/LinearRegressionTool/src/main/java/model/Line.java b/LinearRegressionTool/src/main/java/model/Line.java index 0532286..f97cbad 100644 --- a/LinearRegressionTool/src/main/java/model/Line.java +++ b/LinearRegressionTool/src/main/java/model/Line.java @@ -103,5 +103,13 @@ public class Line { this.y2 = y2; } + public boolean equals(Line other){ + if (other.getM() == this.getM() && other.getB() == this.getB()){ + return true; + } else { + return false; + } + } + } diff --git a/LinearRegressionTool/src/main/java/model/LineModel.java b/LinearRegressionTool/src/main/java/model/LineModel.java index 65c7c33..4e77907 100644 --- a/LinearRegressionTool/src/main/java/model/LineModel.java +++ b/LinearRegressionTool/src/main/java/model/LineModel.java @@ -26,6 +26,12 @@ public class LineModel { public LineModel() { nodes = new ArrayList<>(); lines = new LinkedList<>(); + + xMinimum = Double.MAX_VALUE; + xMaximum = Double.MIN_VALUE; + yMinimum = Double.MAX_VALUE; + yMaximum = Double.MIN_VALUE; + } public void setXbounds() { @@ -50,6 +56,11 @@ public class LineModel { public void addNode(Point node) { this.nodes.add(node); + xMaximum = (node.getX() > xMaximum) ? node.getX() : xMinimum; + xMinimum = (node.getX() <= xMinimum) ? node.getX() : xMinimum; + yMaximum = (node.getY() > yMaximum) ? node.getY() : yMaximum; + yMaximum = (node.getY() <= yMaximum) ? node.getY() : yMaximum; + } public void addLine(Line line) { @@ -103,4 +114,11 @@ public class LineModel { public void setyMaximum(Double yMaximum) { this.yMaximum = yMaximum; } + + public void resetRanges(){ + xMinimum = Double.MAX_VALUE; + xMaximum = Double.MIN_VALUE; + yMinimum = Double.MAX_VALUE; + yMaximum = Double.MIN_VALUE; + } } diff --git a/LinearRegressionTool/src/main/java/model/Pair.java b/LinearRegressionTool/src/main/java/model/Pair.java index d870165..faff8eb 100644 --- a/LinearRegressionTool/src/main/java/model/Pair.java +++ b/LinearRegressionTool/src/main/java/model/Pair.java @@ -32,4 +32,5 @@ public class Pair { public void setP2(Integer p2) { this.p2 = p2; } + } diff --git a/LinearRegressionTool/src/main/java/model/Point.java b/LinearRegressionTool/src/main/java/model/Point.java index 850476e..42d7fa4 100644 --- a/LinearRegressionTool/src/main/java/model/Point.java +++ b/LinearRegressionTool/src/main/java/model/Point.java @@ -55,6 +55,14 @@ public class Point implements Comparable { } } + public boolean equals(Point other){ + if (other.getX() == this.getX() && other.getY() == this.getY()){ + return true; + } else { + return false; + } + } + public String getId() { return id; } diff --git a/LinearRegressionTool/src/main/java/presenter/AbstractPresenter.java b/LinearRegressionTool/src/main/java/presenter/AbstractPresenter.java index 94875fb..d611b71 100644 --- a/LinearRegressionTool/src/main/java/presenter/AbstractPresenter.java +++ b/LinearRegressionTool/src/main/java/presenter/AbstractPresenter.java @@ -2,6 +2,7 @@ package presenter; import model.Interval; import model.LineModel; +import presenter.algorithms.util.IntersectionComputer; import presenter.algorithms.util.IntersectionCounter; import presenter.evaluation.EvaluateAlgorithms; import view.MainFrame; @@ -95,12 +96,6 @@ public abstract class AbstractPresenter implements Observer { 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(); }); @@ -110,6 +105,16 @@ public abstract class AbstractPresenter implements Observer { } catch (InterruptedException e) { e.printStackTrace(); } + + SwingUtilities.invokeLater(() -> { + getView().showImportProgress(progress); + getView().enableFunctionality(); + getView().getProgressDialog().dispose(); + getView().logHeading("Import aus Datei"); + getView().log("Anzahl der Geraden: "+ getModel().getLines().size() + "."); + getView().log("Anzahl der Schnittpunkte: "+getModel().getNodes().size()+"."); + getView().logSuccess("Import war Erfolgreich!
"); + }); } else { SwingUtilities.invokeLater(() -> { getView().showImportProgress(progress); @@ -118,16 +123,16 @@ public abstract class AbstractPresenter implements Observer { } if (result[0] == "export") { SwingUtilities.invokeLater(() -> { - getView().logSuccess("Export Erfolgreich"); + getView().logHeading("Export der Daten als CSV"); + getView().logSuccess("Export war Erfolgreich"); getView().log(result[1] + "
"); }); } if (result[0] == "generator") { SwingUtilities.invokeLater(() -> { - getView().logSuccess("Generierung Erfolgreich"); + getView().logSuccess("Generierung war Erfolgreich"); getView().log(result[1] + "
"); - setup(); }); } @@ -135,8 +140,12 @@ public abstract class AbstractPresenter implements Observer { //100% erreicht SwingUtilities.invokeLater(() -> { getView().enableFunctionality(); + getView().logHeading("Import eines Bildes"); + getView().log("Anzahl der Geraden: "+ getModel().getLines().size() + "."); + getView().log("Anzahl der Schnittpunkte: "+getModel().getNodes().size()+"."); + getView().logSuccess("Der Import war Erfolgreich!
"); }); - setup(); + Thread t = new Thread(() -> { calculateIntersections(); }); @@ -150,25 +159,20 @@ public abstract class AbstractPresenter implements Observer { } } - public void setup() { - //Darstellung der Schnittpunkte in einer Tabelle - SwingUtilities.invokeLater(() -> { - getView().logSuccess("Der Import der Daten war Erfolgreich!"); - getView().log("
"); - }); - } 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(); + 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(); diff --git a/LinearRegressionTool/src/main/java/presenter/algorithms/util/IntersectionComputer.java b/LinearRegressionTool/src/main/java/presenter/algorithms/util/IntersectionComputer.java new file mode 100644 index 0000000..6ab0629 --- /dev/null +++ b/LinearRegressionTool/src/main/java/presenter/algorithms/util/IntersectionComputer.java @@ -0,0 +1,131 @@ +package presenter.algorithms.util; + +import model.Interval; +import model.Line; +import model.Point; + +import java.util.ArrayList; +import java.util.LinkedList; +import java.util.List; +import java.util.TreeSet; + +/** + * Implementierung verschiedener Algorithmen zur Berechnung von Ausgleichsgeraden. + * + * @Author: Armin Wolf + * @Email: a_wolf28@uni-muenster.de + * @Date: 18.09.2017. + */ +public class IntersectionComputer { + + private LinkedList lines; + private List[] subList; + private TreeSet intersections; + + private Double xMinimum; + private Double xMaximum; + private Double yMinimum; + private Double yMaximum; + + private Thread[] worker; + + public IntersectionComputer(LinkedList lines) { + this.lines = lines; + this.worker = new Thread[4]; + this.subList = new LinkedList[4]; + this.intersections = new TreeSet<>(); + + xMinimum = Double.MAX_VALUE; + xMaximum = Double.MIN_VALUE; + yMinimum = Double.MAX_VALUE; + yMaximum = Double.MIN_VALUE; + } + + public ArrayList compute(){ + + if (lines.size() >= 12) { + worker[0] = new Thread(() -> { + work(lines.subList(0, (lines.size() / 4))); + }); + worker[0].start(); + worker[1] = new Thread(() -> { + work(lines.subList((lines.size() / 4) + 1, (lines.size() / 2))); + }); + worker[1].start(); + worker[2] = new Thread(() -> { + work(lines.subList((lines.size() / 2) + 1, 3 * (lines.size() / 4))); + }); + worker[2].start(); + worker[3] = new Thread(() -> { + work(lines.subList(3 * (lines.size() / 4) + 1, (lines.size()))); + }); + worker[3].start(); + + + for (Thread t : worker) { + try { + t.join(); + } catch (InterruptedException e) { + e.printStackTrace(); + } + } + } else { + work(lines); + } + + return new ArrayList<>(intersections); + + } + + private synchronized void work(List lines){ + IntersectionCounter counter = new IntersectionCounter(); + counter.run(lines, new Interval(-99999, 99999)); + ArrayList points = counter.calculateIntersectionAbscissas(); + for (Point p :points){ + if (!isFound(p)){ + addIntersection(p); + setRanges(p); + } + } + + } + + public synchronized LinkedList getLines() { + return lines; + } + + public synchronized void addIntersection(Point p){ + this.intersections.add(p); + } + + public synchronized boolean isFound(Point p){ + if (intersections.contains(p)){ + return true; + } else { + return false; + } + } + + public synchronized void setRanges(Point point){ + xMaximum = (point.getX() > xMaximum) ? point.getX() : xMaximum; + xMinimum = (point.getX() < xMinimum) ? point.getX() : xMinimum; + yMaximum = (point.getY() > yMaximum) ? point.getY() : yMaximum; + yMinimum = (point.getY() < yMinimum) ? point.getY() : yMinimum; + } + + public Double getxMinimum() { + return xMinimum; + } + + public Double getxMaximum() { + return xMaximum; + } + + public Double getyMinimum() { + return yMinimum; + } + + public Double getyMaximum() { + return yMaximum; + } +} diff --git a/LinearRegressionTool/src/main/java/presenter/algorithms/util/IntersectionCounter.java b/LinearRegressionTool/src/main/java/presenter/algorithms/util/IntersectionCounter.java index 7f23cbe..c3a94cc 100644 --- a/LinearRegressionTool/src/main/java/presenter/algorithms/util/IntersectionCounter.java +++ b/LinearRegressionTool/src/main/java/presenter/algorithms/util/IntersectionCounter.java @@ -26,6 +26,7 @@ public class IntersectionCounter { private HashMap secondaryDictionaryBACK; private ArrayList umin; + /** * Berechnet die Inversionen zwischen zwei Listen mit Integer Werten. Diese Methode dient als * Wrapper Methode. Die Logik steht in der countInversions Funktion. @@ -242,6 +243,34 @@ public class IntersectionCounter { } + + /** + * Diese Methode liefert nur nach dem Ausführen der run Funktion Sinnvolle Werte. + */ + public ArrayList calculateIntersectionAbscissas() { + ArrayList result = new ArrayList<>(); + + ArrayList points = new ArrayList<>(); + for (int i = 0; i < inversions.size(); i++) { + result.add(new Pair(dictionaryBACK.get(inversions.get(i).getP1()), + dictionaryBACK.get(inversions.get(i).getP2()))); + } + + for (Pair p : result) { + Line line = secondaryDictionaryBACK.get(p.getP1()); + Line sampledLine = secondaryDictionaryBACK.get(p.getP2()); + if (!line.equals(sampledLine)) { + double intersection = (line.getB() - sampledLine.getB()) / (sampledLine.getM() - line.getM()); + double yintercept = sampledLine.getM() * intersection + sampledLine.getB(); + Point point = new Point(intersection, yintercept); + points.add(point); + } + } + + return points; + + } + /** * Berechnet die Schnittpunkte zwischen einer gegebenen Gerade und einer Menge an Geraden. * diff --git a/LinearRegressionTool/src/main/java/presenter/evaluation/PictureProcessor.java b/LinearRegressionTool/src/main/java/presenter/evaluation/PictureProcessor.java index 71c7adc..9d2221d 100644 --- a/LinearRegressionTool/src/main/java/presenter/evaluation/PictureProcessor.java +++ b/LinearRegressionTool/src/main/java/presenter/evaluation/PictureProcessor.java @@ -51,10 +51,8 @@ public class PictureProcessor extends Observable{ Imgproc.findContours(source, contours, new Mat(), Imgproc.RETR_TREE, Imgproc.CHAIN_APPROX_SIMPLE, new Point(0,0)); Mat viscont = new Mat(source.size(), source.type()); for (int i=0;i 20) { - Imgproc.drawContours(viscont, contours, i, new Scalar(255, 255, 255), -1); - } else { - contours.remove(i); + if (Imgproc.contourArea(contours.get(i)) > 100) { + Imgproc.drawContours(viscont, contours, i, new Scalar(255, 255, 100), -1); } } SwingUtilities.invokeLater(() -> { @@ -87,12 +85,13 @@ public class PictureProcessor extends Observable{ int id = 0; for (int j=0;j 200) { + for (int i = 0; i < p.length; i++) { Line line = new Line(-1 * (500 - p[i].x), p[i].y); line.setId("" + id++); presenter.getModel().getLines().add(line); } - + } } setChanged(); diff --git a/LinearRegressionTool/src/main/java/presenter/io/DataImporter.java b/LinearRegressionTool/src/main/java/presenter/io/DataImporter.java index 9f55590..edc30d4 100644 --- a/LinearRegressionTool/src/main/java/presenter/io/DataImporter.java +++ b/LinearRegressionTool/src/main/java/presenter/io/DataImporter.java @@ -57,7 +57,9 @@ public class DataImporter extends Observable { Double y = Double.parseDouble(nextLine[2]) * (-1); Line line = new Line(x, y); line.setId(counter + ""); - this.presenter.getModel().addLine(line); + if (!this.presenter.getModel().getLines().contains(line)) { + this.presenter.getModel().addLine(line); + } //System.out.format("|\t\t\t\t\t %-11d \t|\t\t\t\t\t %-11f \t|\t\t\t\t\t %-11f \t\t\t\t\t|\n", id,x,y); setChanged(); counter++; diff --git a/dataset/minimal.csv b/dataset/minimal.csv index dd180f3..fb9bf10 100644 --- a/dataset/minimal.csv +++ b/dataset/minimal.csv @@ -1,5 +1,5 @@ -1,18,18 -2,24,26 -3,30,30 -4,34,40 -5,38,70 +0,18,18 +1,24,26 +2,30,30 +3,34,40 +4,38,70