WIP: RM Estimator
This commit is contained in:
parent
04bcaa0f24
commit
6b99966b5e
|
@ -1,8 +1,7 @@
|
|||
import Model.Arrangement;
|
||||
import Presenter.Presenter;
|
||||
import View.MainFrame;
|
||||
|
||||
import javax.swing.*;
|
||||
import javax.swing.SwingUtilities;
|
||||
|
||||
/**
|
||||
* Implementierung verschiedener Algorithmen zur Berechnung von Ausgleichsgeraden.
|
||||
|
|
|
@ -2,7 +2,6 @@ package Model.DCEL;
|
|||
|
||||
|
||||
import Model.Point;
|
||||
|
||||
import java.util.LinkedList;
|
||||
|
||||
/**
|
||||
|
|
|
@ -49,7 +49,8 @@ public class Face {
|
|||
|
||||
public Face insertEdge(Edge edgeWithSameDestination, Edge edgeToMySource) {
|
||||
|
||||
if (edgeWithSameDestination.getIncidentFace().equals(this) || edgeToMySource.getIncidentFace().equals(this)) {
|
||||
if (edgeWithSameDestination.getIncidentFace().equals(this) || edgeToMySource.getIncidentFace()
|
||||
.equals(this)) {
|
||||
LinkedList<Edge> components = new LinkedList<Edge>();
|
||||
for (Edge e : innerComponents) {
|
||||
components.add(e);
|
||||
|
@ -108,7 +109,8 @@ public class Face {
|
|||
}
|
||||
return face;
|
||||
} else {
|
||||
throw new IllegalArgumentException("Die angegebenen Kanten haben keinen zusammenhang mit der Fläche!");
|
||||
throw new IllegalArgumentException(
|
||||
"Die angegebenen Kanten haben keinen zusammenhang mit der Fläche!");
|
||||
}
|
||||
|
||||
}
|
||||
|
|
|
@ -8,8 +8,10 @@ package Model;
|
|||
* @Date: 19.06.2017.
|
||||
*/
|
||||
public class Pair {
|
||||
|
||||
private Integer p1;
|
||||
private Integer p2;
|
||||
|
||||
public Pair(Integer p1, Integer p2) {
|
||||
this.p1 = p1;
|
||||
this.p2 = p2;
|
||||
|
|
|
@ -8,6 +8,7 @@ package Model;
|
|||
* @Date: 16.06.2017.
|
||||
*/
|
||||
public class Slab {
|
||||
|
||||
private double upper;
|
||||
private double lower;
|
||||
private Boolean activity;
|
||||
|
|
|
@ -1,7 +1,5 @@
|
|||
package Presenter.Algorithms;
|
||||
|
||||
import java.util.Observable;
|
||||
|
||||
/**
|
||||
* Implementierung verschiedener Algorithmen zur Berechnung von Ausgleichsgeraden.
|
||||
*
|
||||
|
|
|
@ -1,165 +0,0 @@
|
|||
package Presenter.Algorithms;
|
||||
|
||||
import Model.Line;
|
||||
import Model.Pair;
|
||||
import Model.Point;
|
||||
import Model.Slab;
|
||||
|
||||
import java.util.ArrayList;
|
||||
import java.util.Collections;
|
||||
import java.util.HashMap;
|
||||
import java.util.List;
|
||||
|
||||
/**
|
||||
* Implementierung verschiedener Algorithmen zur Berechnung von Ausgleichsgeraden.
|
||||
*
|
||||
* @Author: Armin Wolf
|
||||
* @Email: a_wolf28@uni-muenster.de
|
||||
* @Date: 18.06.2017.
|
||||
*/
|
||||
public class InversionCounter {
|
||||
|
||||
private HashMap<Integer, Integer> dictionaryTO;
|
||||
private HashMap<Integer, Integer> dictionaryBACK;
|
||||
private ArrayList<Integer> substituted;
|
||||
private ArrayList<Pair> inversions;
|
||||
|
||||
//indexieren der Punkte damit die schnittpunkte berechnet werden können
|
||||
private HashMap<Integer, Integer> secondaryIndex;
|
||||
private ArrayList<Point> umin;
|
||||
private ArrayList<Point> umax;
|
||||
|
||||
|
||||
public int run(List<Integer> a, List<Integer> b){
|
||||
|
||||
dictionaryTO = new HashMap<>();
|
||||
dictionaryBACK = new HashMap<>();
|
||||
substituted = new ArrayList<>();
|
||||
inversions = new ArrayList<>();
|
||||
|
||||
ArrayList<Integer> temp = new ArrayList<>();
|
||||
|
||||
temp.addAll(a);
|
||||
|
||||
for (int i=0;i<a.size();i++){
|
||||
dictionaryTO.put(a.get(i), i+1 );
|
||||
dictionaryBACK.put(i+1 , a.get(i));
|
||||
}
|
||||
|
||||
for (int j=0;j<b.size();j++){
|
||||
substituted.add(dictionaryTO.get(b.get(j)));
|
||||
}
|
||||
|
||||
int ret = countInversions(substituted, 0, substituted.size()-1, temp);
|
||||
|
||||
dictionaryTO = null;
|
||||
substituted = null;
|
||||
inversions = null;
|
||||
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
public int run(List<Line> set, Slab slab){
|
||||
ArrayList<Integer> listA = new ArrayList<>();
|
||||
ArrayList<Integer> listB = new ArrayList<>();
|
||||
|
||||
prepareData(set, slab, listA, listB);
|
||||
return run(listA, listB);
|
||||
}
|
||||
|
||||
|
||||
private void prepareData(List<Line> set, Slab slab, ArrayList<Integer> listA, ArrayList<Integer> listB){
|
||||
secondaryIndex = new HashMap<>();
|
||||
umin = new ArrayList<>();
|
||||
umax = new ArrayList<>();
|
||||
|
||||
int counter = 0;
|
||||
for (Line p : set) {
|
||||
//vertauscht das Point standardmäßig die x lexikografische Ordnung betrachtet
|
||||
umin.add(new Point(slab.getLower() * p.getM() + p.getB(),p.getM(), counter+""));
|
||||
umax.add(new Point(slab.getUpper() * p.getM() + p.getB(),p.getM() ,counter+""));
|
||||
counter++;
|
||||
}
|
||||
|
||||
for (int i=0; i<umin.size();i++){
|
||||
int id = Integer.parseInt(umin.get(i).getId());
|
||||
secondaryIndex.put(id, i);
|
||||
}
|
||||
|
||||
Collections.sort(umin);
|
||||
Collections.sort(umax);
|
||||
|
||||
for (Point p : umax){
|
||||
int x = Integer.parseInt(p.getId());
|
||||
listB.add(secondaryIndex.get(x));
|
||||
}
|
||||
|
||||
for (Point q : umin){
|
||||
int x = Integer.parseInt(q.getId());
|
||||
listA.add(secondaryIndex.get(x));
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Angepasster Merge-Sort Algorithmus.
|
||||
* Die Funktion bekommt neben den standard Parametern zusätzlich eine Liste mit Elementen
|
||||
* die als Groundtruth dienen.
|
||||
* @param a Eingabefeld mit den Elementen die überprüft werden sollen.
|
||||
* @param start Startpunkt des Eingabefeldes.
|
||||
* @param end Endpunkt des Eingabefeldes.
|
||||
* @param aux Groundtruth Ordnung um die Anzahl der Inversionen zu bestimmen.
|
||||
* @return Anzahl der inversionen zwischen a und aux.
|
||||
*/
|
||||
public int countInversions(List<Integer> a, int start, int end, List<Integer> aux) {
|
||||
if (start >= end) {
|
||||
return 0;
|
||||
}
|
||||
int invCount = 0;
|
||||
int mid = start + (end - start) / 2;
|
||||
int invCountLeft = countInversions(a, start, mid, aux); // divide and conquer
|
||||
int invCountRight = countInversions(a, mid + 1, end, aux); // divide and conquer
|
||||
invCount += (invCountLeft + invCountRight);
|
||||
for (int i = start; i <= end; i++) {
|
||||
aux.set(i, a.get(i));
|
||||
}
|
||||
int left = start;
|
||||
int right = mid + 1;
|
||||
int index = start;
|
||||
while (left <= mid && right <= end) {
|
||||
if (aux.get(left) < aux.get(right)) {
|
||||
a.set(index++, aux.get(left++));
|
||||
} else {
|
||||
|
||||
for (int i=left; i<=mid;i++){
|
||||
// System.out.println(aux.get(i)+" -- "+ aux.get(right));
|
||||
inversions.add(new Pair(aux.get(i), aux.get(right)));
|
||||
}
|
||||
a.set(index++, aux.get(right++));
|
||||
invCount += mid - left + 1; // number of inversions for aux[right]
|
||||
}
|
||||
}
|
||||
while (left <= mid) {
|
||||
a.set(index++, aux.get(left++));
|
||||
}
|
||||
// no need to copy over remaining aux[right++] because they are already inside a
|
||||
return invCount;
|
||||
}
|
||||
|
||||
|
||||
public ArrayList<Pair> getInversionPairs(){
|
||||
ArrayList<Pair> result = 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){
|
||||
// System.out.println(p.getP1() + " <==> " + p.getP2());
|
||||
//}
|
||||
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
}
|
|
@ -3,10 +3,15 @@ package Presenter.Algorithms;
|
|||
import Model.Line;
|
||||
import Model.Point;
|
||||
import Model.Slab;
|
||||
import Presenter.InversionCounter;
|
||||
import Presenter.Presenter;
|
||||
|
||||
import java.util.*;
|
||||
import java.util.ArrayList;
|
||||
import java.util.Collections;
|
||||
import java.util.Comparator;
|
||||
import java.util.LinkedList;
|
||||
import java.util.Observable;
|
||||
import java.util.PriorityQueue;
|
||||
import java.util.Random;
|
||||
|
||||
/**
|
||||
* Implementierung verschiedener Algorithmen zur Berechnung von Ausgleichsgeraden.
|
||||
|
@ -35,7 +40,8 @@ public class LeastMedianOfSquaresEstimator extends Observable implements Algorit
|
|||
private Double intersectionsPoint;
|
||||
private Double constant;
|
||||
|
||||
public LeastMedianOfSquaresEstimator(LinkedList<Line> set, LinkedList<Point> intersections, Presenter presenter) {
|
||||
public LeastMedianOfSquaresEstimator(LinkedList<Line> set, LinkedList<Point> intersections,
|
||||
Presenter presenter) {
|
||||
this.set = set;
|
||||
this.intersections = intersections;
|
||||
|
||||
|
@ -59,18 +65,19 @@ public class LeastMedianOfSquaresEstimator extends Observable implements Algorit
|
|||
*/
|
||||
public void run() {
|
||||
|
||||
|
||||
//(2.) Let U <- (-inf, inf) be the initial active slabs...
|
||||
Comparator<Slab> comparator = new Comparator<Slab>() {
|
||||
@Override
|
||||
public int compare(Slab o1, Slab o2) {
|
||||
if (o1.getDistance() < o2.getDistance())
|
||||
if (o1.getDistance() < o2.getDistance()) {
|
||||
return -1;
|
||||
if (o1.getDistance() > o2.getDistance())
|
||||
}
|
||||
if (o1.getDistance() > o2.getDistance()) {
|
||||
return 1;
|
||||
else
|
||||
} else {
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
};
|
||||
slabs = new PriorityQueue<>(comparator);
|
||||
slabs.add(new Slab(-100000, 100000));
|
||||
|
@ -94,7 +101,8 @@ public class LeastMedianOfSquaresEstimator extends Observable implements Algorit
|
|||
// get random intersections point...
|
||||
Collections.shuffle(tmpIntersections, new Random());
|
||||
for (int i = 0; i < tmpIntersections.size(); i++) {
|
||||
if (tmpIntersections.get(i).getX() > slab.getLower() && tmpIntersections.get(i).getX() < slab.getUpper()) {
|
||||
if (tmpIntersections.get(i).getX() > slab.getLower()
|
||||
&& tmpIntersections.get(i).getX() < slab.getUpper()) {
|
||||
intersectionsPoint = tmpIntersections.get(i).getX();
|
||||
break;
|
||||
} else {
|
||||
|
@ -152,7 +160,6 @@ public class LeastMedianOfSquaresEstimator extends Observable implements Algorit
|
|||
}
|
||||
|
||||
|
||||
|
||||
/**
|
||||
* @param slab
|
||||
* @return
|
||||
|
@ -168,7 +175,6 @@ public class LeastMedianOfSquaresEstimator extends Observable implements Algorit
|
|||
}
|
||||
Collections.sort(xQueue);
|
||||
|
||||
|
||||
Line bracelet = sigmaMin;
|
||||
double heightOfBracelet = heightsigmaMin;
|
||||
|
||||
|
@ -188,7 +194,9 @@ public class LeastMedianOfSquaresEstimator extends Observable implements Algorit
|
|||
}
|
||||
|
||||
/**
|
||||
* Diese Methode spaltet den aktiven Slab an der x Koordinate point. Es werden zwei neue Slabs erzeugt.
|
||||
* Diese Methode spaltet den aktiven Slab an der x Koordinate point. Es werden zwei neue Slabs
|
||||
* erzeugt.
|
||||
*
|
||||
* @param point x Koordinate an der, der Split geschieht.
|
||||
*/
|
||||
public void splitActiveSlab(double point, Slab active) {
|
||||
|
@ -208,7 +216,6 @@ public class LeastMedianOfSquaresEstimator extends Observable implements Algorit
|
|||
double tmpHeight;
|
||||
ArrayList<Double> sortedLineSequence = getEjValues(point);
|
||||
|
||||
|
||||
int itnbr = ((n - kMinus) + 1);
|
||||
for (int i = 0; i < itnbr; i++) {
|
||||
tmpHeight = sortedLineSequence.get((i + kMinus) - 1) - sortedLineSequence.get(i);
|
||||
|
@ -222,7 +229,8 @@ public class LeastMedianOfSquaresEstimator extends Observable implements Algorit
|
|||
sigmaMin.setEndPoints(point, sortedLineSequence.get(i)
|
||||
, point, sortedLineSequence.get((i + kMinus) - 1));
|
||||
} else {
|
||||
sigmaMin = new Line(point, point, sortedLineSequence.get(i), sortedLineSequence.get((i + kMinus) - 1));
|
||||
sigmaMin = new Line(point, point, sortedLineSequence.get(i),
|
||||
sortedLineSequence.get((i + kMinus) - 1));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
@ -246,7 +254,9 @@ public class LeastMedianOfSquaresEstimator extends Observable implements Algorit
|
|||
//y koordinaten der Schnittpunkte
|
||||
ArrayList<Line> lines = new ArrayList<>();
|
||||
for (Line p : set) {
|
||||
lines.add(new Line(pslab.getLower(), pslab.getUpper(),((pslab.getLower() * p.getM()) + p.getB()), ((pslab.getUpper() * p.getM()) + p.getB())));
|
||||
lines.add(
|
||||
new Line(pslab.getLower(), pslab.getUpper(), ((pslab.getLower() * p.getM()) + p.getB()),
|
||||
((pslab.getUpper() * p.getM()) + p.getB())));
|
||||
}
|
||||
|
||||
umaxList = getEjValues(pslab.getUpper());
|
||||
|
@ -289,7 +299,8 @@ public class LeastMedianOfSquaresEstimator extends Observable implements Algorit
|
|||
pslab.setActivity(false);
|
||||
break;
|
||||
} else {
|
||||
h = Math.min(Math.abs(uminList.get(j) - uminList.get(i)), Math.abs(umaxList.get(j) - umaxList.get(i)));
|
||||
h = Math.min(Math.abs(uminList.get(j) - uminList.get(i)),
|
||||
Math.abs(umaxList.get(j) - umaxList.get(i)));
|
||||
double error = 0.01;
|
||||
if (((1 + error) * h) < heightsigmaMin) {
|
||||
//System.out.println("h: "+ h +" ist kleiner als height(sigmaMin): "+heightsigmaMin);
|
||||
|
@ -303,8 +314,8 @@ public class LeastMedianOfSquaresEstimator extends Observable implements Algorit
|
|||
}
|
||||
|
||||
/**
|
||||
* Berechnet die Schnittpunkte der Geraden und der vertikalen Gerade u. Im paper sind diese Werte als e_j Werte
|
||||
* bekannt.
|
||||
* Berechnet die Schnittpunkte der Geraden und der vertikalen Gerade u. Im paper sind diese Werte
|
||||
* als e_j Werte bekannt.
|
||||
*
|
||||
* @param u vertikale Gerade
|
||||
* @return Liste der Schnittpunkte (da u bekannt werden nur die y Werte zurück gegeben)
|
||||
|
@ -323,9 +334,10 @@ public class LeastMedianOfSquaresEstimator extends Observable implements Algorit
|
|||
}
|
||||
|
||||
/**
|
||||
* Die Funktion berechnet anhand einer vertikalen Gerade x = px das sogenannte kleinste kMinus Bracelet.
|
||||
* Mit anderen Worten es wird eine vertikale Teilgerade berechnet die mindestens kMinus Geraden schneidet
|
||||
* und dabei minimal ist.
|
||||
* Die Funktion berechnet anhand einer vertikalen Gerade x = px das sogenannte kleinste kMinus
|
||||
* Bracelet. Mit anderen Worten es wird eine vertikale Teilgerade berechnet die mindestens kMinus
|
||||
* Geraden schneidet und dabei minimal ist.
|
||||
*
|
||||
* @param px Koordinate um die "vertikale Gerade" zu simulieren.
|
||||
* @return Das Array enthält höhe des Bracelet, e_j und e_(j + kMinus - 1)
|
||||
*/
|
||||
|
@ -348,7 +360,8 @@ public class LeastMedianOfSquaresEstimator extends Observable implements Algorit
|
|||
}
|
||||
|
||||
/**
|
||||
* Im Allgemeinen werden keine Getter und Setter Methoden benötigt aber sie sind nützlich bei den JUnit Testfällen.
|
||||
* Im Allgemeinen werden keine Getter und Setter Methoden benötigt aber sie sind nützlich bei den
|
||||
* JUnit Testfällen.
|
||||
*/
|
||||
|
||||
public LinkedList<Line> getSet() {
|
||||
|
|
|
@ -1,13 +1,14 @@
|
|||
package Presenter.Algorithms;
|
||||
|
||||
import Model.Line;
|
||||
import Model.Pair;
|
||||
import Model.Slab;
|
||||
|
||||
import Presenter.InversionCounter;
|
||||
import java.util.ArrayList;
|
||||
import java.util.Collections;
|
||||
import java.util.HashMap;
|
||||
import java.util.LinkedList;
|
||||
import java.util.Random;
|
||||
import java.util.concurrent.ThreadLocalRandom;
|
||||
|
||||
/**
|
||||
* Implementierung verschiedener Algorithmen zur Berechnung von Ausgleichsgeraden.
|
||||
|
@ -19,13 +20,13 @@ import java.util.Random;
|
|||
public class RepeatedMedianEstimator implements Algorithm {
|
||||
|
||||
private LinkedList<Line> set;
|
||||
private HashMap<Line, ArrayList<Line>> linePairs;
|
||||
private Slab interval;
|
||||
private InversionCounter invCounter = new InversionCounter();
|
||||
|
||||
//in der Literatur als L_i, C_i, und R_i bekannt
|
||||
private Integer countLeftSlab;
|
||||
private Integer countCenterSlab;
|
||||
private Integer countRightSlab;
|
||||
private ArrayList<Integer> countLeftSlab;
|
||||
private ArrayList<Integer> countCenterSlab;
|
||||
private ArrayList<Integer> countRightSlab;
|
||||
|
||||
//die Mengen L,C und R
|
||||
private ArrayList<Line> linesInLeftSlab;
|
||||
|
@ -39,65 +40,92 @@ public class RepeatedMedianEstimator implements Algorithm {
|
|||
private Double kHigh;
|
||||
private Double beta;
|
||||
|
||||
private Line thetaLow;
|
||||
private Line thetaHigh;
|
||||
|
||||
private Double thetaLow;
|
||||
private Double thetaHigh;
|
||||
|
||||
|
||||
public RepeatedMedianEstimator(LinkedList<Line> set) {
|
||||
this.set = set;
|
||||
interval = new Slab(-10000, 10000);
|
||||
n = set.size();
|
||||
beta = 1.0;
|
||||
countLeftSlab = 0;
|
||||
countCenterSlab = n - 1;
|
||||
countRightSlab = 0;
|
||||
beta = 0.5;
|
||||
countLeftSlab = new ArrayList<>();
|
||||
countCenterSlab = new ArrayList<>();
|
||||
countRightSlab = new ArrayList<>();
|
||||
|
||||
for (int i = 0; i < n; i++) {
|
||||
countLeftSlab.add(0);
|
||||
countRightSlab.add(0);
|
||||
countCenterSlab.add(n - 1);
|
||||
}
|
||||
|
||||
linesInLeftSlab = new ArrayList<>();
|
||||
linesInCenterSlab = new ArrayList<>(set);
|
||||
linesInRightSlab = new ArrayList<>();
|
||||
linePairs = new HashMap<>();
|
||||
}
|
||||
|
||||
|
||||
public void run() {
|
||||
|
||||
while (linesInCenterSlab.size() != 1) {
|
||||
r = Math.floor(Math.pow(n, beta));
|
||||
ArrayList<Line> lines = sampleLines(linesInCenterSlab, r);
|
||||
|
||||
//TODO: hier kommt der neue Ansatz vom zweiten Algorithmus hin
|
||||
estimateMedianIntersectionAbscissas(lines);
|
||||
InversionCounter invCounter = new InversionCounter();
|
||||
invCounter.run(lines, interval);
|
||||
|
||||
HashMap<Line, ArrayList<Line>> tmpMap;
|
||||
tmpMap = invCounter.getIntersectionAbscissas();
|
||||
linePairs.putAll(tmpMap);
|
||||
if (tmpMap.size() > 0){
|
||||
ArrayList<Double> medianIntersections = new ArrayList<>();
|
||||
for (Line l : lines) {
|
||||
medianIntersections.add(estimateMedianIntersectionAbscissas(l));
|
||||
}
|
||||
|
||||
k = (Math.floor(n * 0.5) - linesInLeftSlab.size());
|
||||
computeSlabBorders();
|
||||
thetaLow = randomizedSelect(linesInCenterSlab,0,linesInCenterSlab.size()-1,kLow);
|
||||
thetaHigh = randomizedSelect(linesInCenterSlab,0,linesInCenterSlab.size()-1,kHigh);
|
||||
countNumberOfIntersectionsAbscissas();
|
||||
thetaLow = randomizedSelect(medianIntersections, 0, medianIntersections.size() - 1, kLow);
|
||||
thetaHigh = randomizedSelect(medianIntersections, 0, medianIntersections.size() - 1, kHigh);
|
||||
|
||||
for (Line l : linesInCenterSlab) {
|
||||
countNumberOfIntersectionsAbscissas(l);
|
||||
}
|
||||
|
||||
contractIntervals();
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
System.out.println(
|
||||
"Ergebnis: " + linesInCenterSlab.get(0).getM() + " * x + " + linesInCenterSlab.get(0)
|
||||
.getB());
|
||||
}
|
||||
|
||||
|
||||
public void computeSlabBorders() {
|
||||
kLow = Math.max(1, Math.ceil(((r * k)/(linesInCenterSlab.size()))-((3 * Math.sqrt(r))/(2))));
|
||||
kHigh = Math.min(1, Math.ceil(((r * k)/(linesInCenterSlab.size()))+((3 * Math.sqrt(r))/(2))));
|
||||
kLow = Math
|
||||
.max(1, Math.ceil(((r * k) / (linesInCenterSlab.size())) - ((3 * Math.sqrt(r)) / (2))));
|
||||
kHigh = Math
|
||||
.min(r, Math.ceil(((r * k) / (linesInCenterSlab.size())) + ((3 * Math.sqrt(r)) / (2))));
|
||||
}
|
||||
|
||||
public ArrayList<Line> sampleLines(ArrayList<Line> set, Double r) {
|
||||
|
||||
ArrayList<Line> sampledLines = new ArrayList<>();
|
||||
|
||||
Random random = new Random(n);
|
||||
for (int i=0; i<n; i++){
|
||||
sampledLines.add(set.get(random.nextInt()));
|
||||
for (int i = 0; i < r; i++) {
|
||||
sampledLines.add(set.get(ThreadLocalRandom.current().nextInt(0, n)));
|
||||
}
|
||||
|
||||
return sampledLines;
|
||||
}
|
||||
|
||||
public Line randomizedSelect(ArrayList<Line> a, int start, int end, double i){
|
||||
if (start == end)
|
||||
|
||||
public Double randomizedSelect(ArrayList<Double> a, int start, int end, double i) {
|
||||
if (start == end) {
|
||||
return a.get(start);
|
||||
}
|
||||
int q = randomizedPartition(a, start, end);
|
||||
int tmpPivot = q - start + 1;
|
||||
|
||||
|
@ -110,19 +138,18 @@ public class RepeatedMedianEstimator implements Algorithm {
|
|||
}
|
||||
}
|
||||
|
||||
public int randomizedPartition(ArrayList<Line> a, int start, int end){
|
||||
public int randomizedPartition(ArrayList<Double> a, int start, int end) {
|
||||
int delta = Math.abs(end - start);
|
||||
Random random = new Random(delta);
|
||||
int i = start + random.nextInt();
|
||||
int i = start + ThreadLocalRandom.current().nextInt(0, delta);
|
||||
Collections.swap(a, end, i);
|
||||
return partition(a, start, end);
|
||||
}
|
||||
|
||||
public int partition(ArrayList<Line> a, int start, int end){
|
||||
Line x = a.get(end);
|
||||
public int partition(ArrayList<Double> a, int start, int end) {
|
||||
Double x = a.get(end);
|
||||
int i = start - 1;
|
||||
for (int j = start; j < end; j++) {
|
||||
if (a.get(j).getM() <= x.getM()){
|
||||
if (a.get(j) <= x) {
|
||||
i++;
|
||||
Collections.swap(a, i, j);
|
||||
}
|
||||
|
@ -131,14 +158,86 @@ public class RepeatedMedianEstimator implements Algorithm {
|
|||
return i + 1;
|
||||
}
|
||||
|
||||
public void countNumberOfIntersectionsAbscissas(){
|
||||
|
||||
public void countNumberOfIntersectionsAbscissas(Line sampledLine) {
|
||||
|
||||
if (linePairs.get(sampledLine) != null){
|
||||
double intersection;
|
||||
Integer index = Integer.parseInt(sampledLine.getId());
|
||||
|
||||
for (Line line : linePairs.get(sampledLine)) {
|
||||
intersection = (line.getB() - sampledLine.getB()) / (sampledLine.getM() - line.getM());
|
||||
|
||||
int tmpVal;
|
||||
if (intersection <= thetaLow) {
|
||||
tmpVal = countLeftSlab.get(index) + 1;
|
||||
countLeftSlab.set(index, tmpVal);
|
||||
tmpVal = countCenterSlab.get(index) - 1;
|
||||
countCenterSlab.set(index, tmpVal);
|
||||
} else if (intersection > thetaHigh) {
|
||||
tmpVal = countRightSlab.get(index) + 1;
|
||||
countRightSlab.set(index, tmpVal);
|
||||
tmpVal = countCenterSlab.get(index) - 1;
|
||||
countCenterSlab.set(index, tmpVal);
|
||||
}
|
||||
|
||||
public void estimateMedianIntersectionAbscissas(ArrayList<Line> sampledLines){
|
||||
int inversions = invCounter.run(sampledLines, interval);
|
||||
countCenterSlab
|
||||
.set(index, Math.abs((n - 1) - (countLeftSlab.get(index) + countRightSlab.get(index))));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
public Double estimateMedianIntersectionAbscissas(Line sampledLine) {
|
||||
|
||||
Integer index = Integer.parseInt(sampledLine.getId());
|
||||
ArrayList<Double> intersections = new ArrayList<>();
|
||||
double intersection;
|
||||
|
||||
for (Line line : linePairs.get(sampledLine)) {
|
||||
if (line != sampledLine){
|
||||
intersection = (line.getB() - sampledLine.getB()) / (sampledLine.getM() - line.getM());
|
||||
intersections.add(intersection);
|
||||
}
|
||||
}
|
||||
|
||||
Collections.sort(intersections);
|
||||
double ki = Math.floor((n - 1) / 2) - countLeftSlab.get(index);
|
||||
int accessIndex = ((int) Math.floor((Math.sqrt(n) * ki) / countCenterSlab.get(index)))-1;
|
||||
System.out.println(accessIndex);
|
||||
|
||||
return intersections.get(accessIndex);
|
||||
}
|
||||
|
||||
|
||||
public void contractIntervals() {
|
||||
if (linesInLeftSlab.size() < Math.floor(n / 2) && Math.floor(n / 2) <= (linesInLeftSlab.size()
|
||||
+ linesInCenterSlab.size())) {
|
||||
for (int i = 0; i < linesInCenterSlab.size(); i++) {
|
||||
int maxVal = Math
|
||||
.max(countLeftSlab.get(i), Math.max(countCenterSlab.get(i), countRightSlab.get(i)));
|
||||
if (countLeftSlab.get(i) == maxVal) {
|
||||
linesInLeftSlab.add(linesInCenterSlab.get(i));
|
||||
linesInCenterSlab.remove(i);
|
||||
}
|
||||
|
||||
if (countRightSlab.get(i) == maxVal) {
|
||||
linesInRightSlab.add(linesInCenterSlab.get(i));
|
||||
linesInCenterSlab.remove(i);
|
||||
}
|
||||
}
|
||||
|
||||
for (int i = 0; i < n; i++) {
|
||||
countLeftSlab.set(i,0);
|
||||
countRightSlab.set(i,0);
|
||||
countCenterSlab.set(i,n - 1);
|
||||
}
|
||||
|
||||
interval.setLower(thetaLow - 0.01);
|
||||
interval.setUpper(thetaHigh);
|
||||
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
|
||||
|
|
|
@ -8,4 +8,5 @@ package Presenter.Algorithms;
|
|||
* @Date: 28.05.2017.
|
||||
*/
|
||||
public class TheilSenEstimator implements Algorithm {
|
||||
|
||||
}
|
||||
|
|
|
@ -0,0 +1,29 @@
|
|||
package Presenter.Comparators;
|
||||
|
||||
import Model.Line;
|
||||
import java.util.Comparator;
|
||||
|
||||
/**
|
||||
* Implementierung verschiedener Algorithmen zur Berechnung von Ausgleichsgeraden.
|
||||
*
|
||||
* @Author: Armin Wolf
|
||||
* @Email: a_wolf28@uni-muenster.de
|
||||
* @Date: 19.06.2017.
|
||||
*/
|
||||
public class YOrderLineComparatorBegin implements Comparator<Line> {
|
||||
|
||||
@Override
|
||||
public int compare(Line o1, Line o2) {
|
||||
if (o1.getY1() == o2.getY1()) {
|
||||
if (o1.getX1() <= o2.getX1()) {
|
||||
return -1;
|
||||
} else {
|
||||
return 1;
|
||||
}
|
||||
} else if (o1.getY1() < o2.getY1()) {
|
||||
return -1;
|
||||
} else {
|
||||
return 1;
|
||||
}
|
||||
}
|
||||
}
|
|
@ -0,0 +1,29 @@
|
|||
package Presenter.Comparators;
|
||||
|
||||
import Model.Line;
|
||||
import java.util.Comparator;
|
||||
|
||||
/**
|
||||
* Implementierung verschiedener Algorithmen zur Berechnung von Ausgleichsgeraden.
|
||||
*
|
||||
* @Author: Armin Wolf
|
||||
* @Email: a_wolf28@uni-muenster.de
|
||||
* @Date: 19.06.2017.
|
||||
*/
|
||||
public class YOrderLineComparatorEnd implements Comparator<Line> {
|
||||
|
||||
@Override
|
||||
public int compare(Line o1, Line o2) {
|
||||
if (o1.getY2() == o2.getY2()) {
|
||||
if (o1.getX2() <= o2.getX2()) {
|
||||
return -1;
|
||||
} else {
|
||||
return 1;
|
||||
}
|
||||
} else if (o1.getY2() < o2.getY2()) {
|
||||
return -1;
|
||||
} else {
|
||||
return 1;
|
||||
}
|
||||
}
|
||||
}
|
|
@ -0,0 +1,195 @@
|
|||
package Presenter;
|
||||
|
||||
import Model.Line;
|
||||
import Model.Pair;
|
||||
import Model.Slab;
|
||||
import Presenter.Comparators.YOrderLineComparatorBegin;
|
||||
import Presenter.Comparators.YOrderLineComparatorEnd;
|
||||
import java.util.ArrayList;
|
||||
import java.util.Collections;
|
||||
import java.util.HashMap;
|
||||
import java.util.List;
|
||||
|
||||
/**
|
||||
* Implementierung verschiedener Algorithmen zur Berechnung von Ausgleichsgeraden.
|
||||
*
|
||||
* @Author: Armin Wolf
|
||||
* @Email: a_wolf28@uni-muenster.de
|
||||
* @Date: 18.06.2017.
|
||||
*/
|
||||
public class InversionCounter {
|
||||
|
||||
private HashMap<Integer, Integer> dictionaryTO;
|
||||
private HashMap<Integer, Integer> dictionaryBACK;
|
||||
private ArrayList<Integer> substituted;
|
||||
private ArrayList<Pair> inversions;
|
||||
private List<Line> set;
|
||||
|
||||
//indexieren der Punkte damit die schnittpunkte berechnet werden können
|
||||
private HashMap<Line, Integer> secondaryDictionaryTO;
|
||||
private HashMap<Integer, Line> secondaryDictionaryBACK;
|
||||
private ArrayList<Line> umin;
|
||||
|
||||
|
||||
public int run(List<Integer> a, List<Integer> b) {
|
||||
|
||||
dictionaryTO = new HashMap<>();
|
||||
dictionaryBACK = new HashMap<>();
|
||||
substituted = new ArrayList<>();
|
||||
inversions = new ArrayList<>();
|
||||
|
||||
ArrayList<Integer> temp = new ArrayList<>();
|
||||
|
||||
temp.addAll(a);
|
||||
|
||||
for (int i = 0; i < a.size(); i++) {
|
||||
dictionaryTO.put(a.get(i), i + 1);
|
||||
dictionaryBACK.put(i + 1, a.get(i));
|
||||
}
|
||||
|
||||
for (int j = 0; j < b.size(); j++) {
|
||||
substituted.add(dictionaryTO.get(b.get(j)));
|
||||
}
|
||||
|
||||
int ret = countInversions(substituted, 0, substituted.size() - 1, temp);
|
||||
|
||||
getIntersectionAbscissas();
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
public int run(List<Line> set, Slab slab) {
|
||||
ArrayList<Integer> listA = new ArrayList<>();
|
||||
ArrayList<Integer> listB = new ArrayList<>();
|
||||
|
||||
prepareData(set, slab, listA, listB);
|
||||
return run(listA, listB);
|
||||
}
|
||||
|
||||
|
||||
private void prepareData(List<Line> set, Slab slab, ArrayList<Integer> listA,
|
||||
ArrayList<Integer> listB) {
|
||||
secondaryDictionaryTO = new HashMap<>();
|
||||
secondaryDictionaryBACK = new HashMap<>();
|
||||
this.set = set;
|
||||
umin = new ArrayList<>();
|
||||
Line tmpLine;
|
||||
|
||||
for (Line p : set) {
|
||||
//vertauscht das Point standardmäßig die x lexikografische Ordnung betrachtet
|
||||
tmpLine = new Line(p.getM(), p.getM(), slab.getLower() * p.getM() + p.getB(),
|
||||
slab.getUpper() * p.getM() + p.getB());
|
||||
//wird benötigt um späer die Schnittpunkte ermitteln zu können
|
||||
tmpLine.setB(p.getB());
|
||||
tmpLine.setM(p.getM());
|
||||
umin.add(tmpLine);
|
||||
}
|
||||
|
||||
for (int i = 0; i < umin.size(); i++) {
|
||||
secondaryDictionaryTO.put(umin.get(i), i);
|
||||
secondaryDictionaryBACK.put(i, this.set.get(i));
|
||||
}
|
||||
|
||||
Collections.sort(umin, new YOrderLineComparatorBegin());
|
||||
for (Line q : umin) {
|
||||
listA.add(secondaryDictionaryTO.get(q));
|
||||
}
|
||||
|
||||
Collections.sort(umin, new YOrderLineComparatorEnd());
|
||||
for (Line q : umin) {
|
||||
listB.add(secondaryDictionaryTO.get(q));
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Angepasster Merge-Sort Algorithmus.
|
||||
* Die Funktion bekommt neben den standard Parametern zusätzlich eine Liste mit Elementen
|
||||
* die als Groundtruth dienen.
|
||||
*
|
||||
* @param a Eingabefeld mit den Elementen die überprüft werden sollen.
|
||||
* @param start Startpunkt des Eingabefeldes.
|
||||
* @param end Endpunkt des Eingabefeldes.
|
||||
* @param aux Groundtruth Ordnung um die Anzahl der Inversionen zu bestimmen.
|
||||
* @return Anzahl der inversionen zwischen a und aux.
|
||||
*/
|
||||
public int countInversions(List<Integer> a, int start, int end, List<Integer> aux) {
|
||||
if (start >= end) {
|
||||
return 0;
|
||||
}
|
||||
int invCount = 0;
|
||||
int mid = start + (end - start) / 2;
|
||||
int invCountLeft = countInversions(a, start, mid, aux); // divide and conquer
|
||||
int invCountRight = countInversions(a, mid + 1, end, aux); // divide and conquer
|
||||
invCount += (invCountLeft + invCountRight);
|
||||
for (int i = start; i <= end; i++) {
|
||||
aux.set(i, a.get(i));
|
||||
}
|
||||
int left = start;
|
||||
int right = mid + 1;
|
||||
int index = start;
|
||||
while (left <= mid && right <= end) {
|
||||
if (aux.get(left) < aux.get(right)) {
|
||||
a.set(index++, aux.get(left++));
|
||||
} else {
|
||||
|
||||
for (int i = left; i <= mid; i++) {
|
||||
// System.out.println(aux.get(i)+" -- "+ aux.get(right));
|
||||
inversions.add(new Pair(aux.get(i), aux.get(right)));
|
||||
}
|
||||
a.set(index++, aux.get(right++));
|
||||
invCount += mid - left + 1; // number of inversions for aux[right]
|
||||
}
|
||||
}
|
||||
while (left <= mid) {
|
||||
a.set(index++, aux.get(left++));
|
||||
}
|
||||
// no need to copy over remaining aux[right++] because they are already inside a
|
||||
return invCount;
|
||||
}
|
||||
|
||||
|
||||
public HashMap<Line, ArrayList<Line>> getIntersectionAbscissas() {
|
||||
ArrayList<Pair> result = new ArrayList<>();
|
||||
HashMap<Line, ArrayList<Line>> ret = new HashMap<>();
|
||||
|
||||
for (int i = 0; i < inversions.size(); i++) {
|
||||
result.add(new Pair(dictionaryBACK.get(inversions.get(i).getP1()),
|
||||
dictionaryBACK.get(inversions.get(i).getP2())));
|
||||
}
|
||||
ArrayList<Line> linePairs;
|
||||
|
||||
for (Pair p : result) {
|
||||
Line l1 = secondaryDictionaryBACK.get(p.getP1());
|
||||
Line l2 = secondaryDictionaryBACK.get(p.getP2());
|
||||
if (ret.get(l2) == null){
|
||||
linePairs = new ArrayList<>();
|
||||
} else {
|
||||
linePairs = ret.get(l2);
|
||||
}
|
||||
linePairs.add(l1);
|
||||
ret.put(l2, linePairs);
|
||||
|
||||
//Symetrie
|
||||
if (ret.get(l1) == null){
|
||||
linePairs = new ArrayList<>();
|
||||
} else {
|
||||
linePairs = ret.get(l1);
|
||||
}
|
||||
linePairs.add(l2);
|
||||
ret.put(l1, linePairs);
|
||||
}
|
||||
|
||||
// System.out.println("----------------------------------------------------------");
|
||||
// for (Line outerLine : ret.keySet()){
|
||||
// System.out.println("Linie: "+outerLine);
|
||||
// for (Line innerLine : ret.get(outerLine)){
|
||||
// System.out.println("\t\t -> "+innerLine);
|
||||
// }
|
||||
// }
|
||||
// System.out.println("----------------------------------------------------------");
|
||||
return ret;
|
||||
}
|
||||
|
||||
}
|
|
@ -4,13 +4,13 @@ import Model.Arrangement;
|
|||
import Model.Line;
|
||||
import Model.Point;
|
||||
import Presenter.Algorithms.LeastMedianOfSquaresEstimator;
|
||||
import Presenter.Algorithms.RepeatedMedianEstimator;
|
||||
import View.MainFrame;
|
||||
|
||||
import javax.swing.*;
|
||||
import java.util.LinkedList;
|
||||
import java.util.List;
|
||||
import java.util.Observable;
|
||||
import java.util.Observer;
|
||||
import javax.swing.SwingUtilities;
|
||||
|
||||
|
||||
/**
|
||||
|
@ -42,6 +42,7 @@ public class Presenter implements Observer {
|
|||
view.logHeading("Duale Darstellung der Punkte als Geraden:");
|
||||
for (int j = 0; j < x.length; j++) {
|
||||
Line p = new Line(x[j], y[j]);
|
||||
p.setId(j+"");
|
||||
view.log("f(x) = " + p.getM() + "x + " + p.getB());
|
||||
this.model.addLine(p);
|
||||
}
|
||||
|
@ -62,6 +63,11 @@ public class Presenter implements Observer {
|
|||
view.createTable(heading, rows);
|
||||
|
||||
|
||||
Thread t = new Thread(() -> {
|
||||
RepeatedMedianEstimator rm = new RepeatedMedianEstimator(this.getLines());
|
||||
rm.run();
|
||||
});
|
||||
t.start();
|
||||
|
||||
}
|
||||
|
||||
|
@ -128,7 +134,6 @@ public class Presenter implements Observer {
|
|||
double x1 = -1000;
|
||||
double x2 = 1000;
|
||||
|
||||
|
||||
for (Line point : model.getLines()) {
|
||||
LinkedList line = new LinkedList();
|
||||
double y1 = (point.getM() * x1 + point.getB());
|
||||
|
@ -140,6 +145,7 @@ public class Presenter implements Observer {
|
|||
|
||||
return lineCoordinates;
|
||||
}
|
||||
|
||||
/***************************************************************************************************************************
|
||||
* Getter und Setter Methoden
|
||||
***************************************************************************************************************************/
|
||||
|
|
|
@ -1,7 +1,15 @@
|
|||
package View;
|
||||
|
||||
import Model.Line;
|
||||
import Model.Point;
|
||||
import java.awt.BorderLayout;
|
||||
import java.awt.Color;
|
||||
import java.awt.Dimension;
|
||||
import java.awt.RenderingHints;
|
||||
import java.awt.Shape;
|
||||
import java.util.LinkedList;
|
||||
import javax.swing.JPanel;
|
||||
import javax.swing.JSlider;
|
||||
import javax.swing.SwingConstants;
|
||||
import org.jfree.chart.ChartFactory;
|
||||
import org.jfree.chart.ChartPanel;
|
||||
import org.jfree.chart.JFreeChart;
|
||||
|
@ -13,12 +21,6 @@ import org.jfree.data.xy.XYSeries;
|
|||
import org.jfree.data.xy.XYSeriesCollection;
|
||||
import org.jfree.util.ShapeUtilities;
|
||||
|
||||
import javax.swing.*;
|
||||
import javax.swing.event.ChangeEvent;
|
||||
import javax.swing.event.ChangeListener;
|
||||
import java.awt.*;
|
||||
import java.util.LinkedList;
|
||||
|
||||
/**
|
||||
* Implementierung verschiedener Algorithmen zur Berechnung von Ausgleichsgeraden.
|
||||
*
|
||||
|
@ -82,7 +84,8 @@ public class ArrangementDialog extends JPanel {
|
|||
chart = ChartFactory.createXYLineChart(
|
||||
null, null, null, dataset,
|
||||
PlotOrientation.HORIZONTAL, false, false, false);
|
||||
chart.setRenderingHints( new RenderingHints( RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON ) );
|
||||
chart.setRenderingHints(
|
||||
new RenderingHints(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON));
|
||||
chart.setAntiAlias(true);
|
||||
|
||||
final XYPlot plot = chart.getXYPlot();
|
||||
|
@ -96,8 +99,6 @@ public class ArrangementDialog extends JPanel {
|
|||
plot.setDomainGridlinePaint(Color.white);
|
||||
plot.setRangeGridlinePaint(Color.white);
|
||||
|
||||
|
||||
|
||||
final XYLineAndShapeRenderer renderer = new XYLineAndShapeRenderer();
|
||||
renderer.setSeriesLinesVisible(dataset.indexOf(intersections), false);
|
||||
plot.setRenderer(renderer);
|
||||
|
|
|
@ -1,11 +1,16 @@
|
|||
package View;
|
||||
|
||||
import Model.Point;
|
||||
|
||||
import javax.swing.*;
|
||||
import java.awt.*;
|
||||
import java.awt.BasicStroke;
|
||||
import java.awt.BorderLayout;
|
||||
import java.awt.Color;
|
||||
import java.awt.Dimension;
|
||||
import java.awt.Graphics;
|
||||
import java.awt.Graphics2D;
|
||||
import java.awt.RenderingHints;
|
||||
import java.awt.geom.Line2D;
|
||||
import java.util.LinkedList;
|
||||
import javax.swing.JPanel;
|
||||
|
||||
/**
|
||||
* Implementierung verschiedener Algorithmen zur Berechnung von Ausgleichsgeraden.
|
||||
|
@ -73,7 +78,9 @@ public class ArrangementDialog2 extends JPanel {
|
|||
g2.setColor(Color.BLACK);
|
||||
g2.setStroke(new BasicStroke(5f / (float) scale));
|
||||
for (LinkedList<Point> line : lines) {
|
||||
line2Ds.add(new Line2D.Double(zero +line.getFirst().getX().intValue(), zero +line.getFirst().getY().intValue(), zero +line.getLast().getX().intValue(), zero +line.getLast().getY().intValue()));
|
||||
line2Ds.add(new Line2D.Double(zero + line.getFirst().getX().intValue(),
|
||||
zero + line.getFirst().getY().intValue(), zero + line.getLast().getX().intValue(),
|
||||
zero + line.getLast().getY().intValue()));
|
||||
}
|
||||
for (Line2D.Double line : line2Ds) {
|
||||
g2.draw(line);
|
||||
|
@ -82,7 +89,8 @@ public class ArrangementDialog2 extends JPanel {
|
|||
//draw intersections of the lines
|
||||
g2.setColor(Color.RED);
|
||||
for (Point point : points) {
|
||||
g2.fillOval(zero +point.getX().intValue(),zero +point.getY().intValue(), pointThicknes, pointThicknes);
|
||||
g2.fillOval(zero + point.getX().intValue(), zero + point.getY().intValue(), pointThicknes,
|
||||
pointThicknes);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
|
@ -1,21 +1,20 @@
|
|||
package View;
|
||||
|
||||
|
||||
import Model.Line;
|
||||
import Presenter.Algorithms.LeastMedianOfSquaresEstimator;
|
||||
import Presenter.Presenter;
|
||||
import com.sun.org.apache.xpath.internal.operations.Bool;
|
||||
import jdk.nashorn.internal.scripts.JO;
|
||||
|
||||
import javax.swing.*;
|
||||
import javax.swing.event.ChangeEvent;
|
||||
import javax.swing.event.ChangeListener;
|
||||
import java.awt.*;
|
||||
import java.awt.BorderLayout;
|
||||
import java.awt.Dimension;
|
||||
import java.awt.FlowLayout;
|
||||
import java.awt.event.ActionEvent;
|
||||
import java.awt.event.ActionListener;
|
||||
import java.util.List;
|
||||
import java.util.Observable;
|
||||
import java.util.Observer;
|
||||
import javax.swing.JButton;
|
||||
import javax.swing.JDialog;
|
||||
import javax.swing.JFrame;
|
||||
import javax.swing.JPanel;
|
||||
import javax.swing.JScrollPane;
|
||||
import javax.swing.JSplitPane;
|
||||
import javax.swing.JTabbedPane;
|
||||
import javax.swing.SwingUtilities;
|
||||
|
||||
/**
|
||||
* Implementierung verschiedener Algorithmen zur Berechnung von Ausgleichsgeraden.
|
||||
|
@ -73,7 +72,8 @@ public class MainFrame extends JFrame{
|
|||
public void createArrangement() {
|
||||
if (arrangement == null) {
|
||||
arrangement = new ArrangementDialog();
|
||||
arrangement.setPrameters(getPresenter().calcArrangementLines(), getPresenter().getModel().getNodes());
|
||||
arrangement.setPrameters(getPresenter().calcArrangementLines(),
|
||||
getPresenter().getModel().getNodes());
|
||||
arrangement.createArrangement();
|
||||
SwingUtilities.invokeLater(() -> {
|
||||
arrangementDialog.add(arrangement, BorderLayout.CENTER);
|
||||
|
@ -95,7 +95,6 @@ public class MainFrame extends JFrame{
|
|||
}
|
||||
|
||||
|
||||
|
||||
/*******************************************************************************************************************
|
||||
* init GUI
|
||||
******************************************************************************************************************/
|
||||
|
@ -107,9 +106,9 @@ public class MainFrame extends JFrame{
|
|||
}
|
||||
|
||||
private void setupTabbedPane() {
|
||||
tabbedPane.add("LMS", sidepanel);
|
||||
tabbedPane.add("RM", new JPanel());
|
||||
tabbedPane.add("TS", new JPanel());
|
||||
tabbedPane.add("Least Median of Squares", sidepanel);
|
||||
tabbedPane.add("Repeated Median", new JPanel());
|
||||
tabbedPane.add("Theil-Sen", new JPanel());
|
||||
}
|
||||
|
||||
private void addComponents() {
|
||||
|
@ -175,7 +174,8 @@ public class MainFrame extends JFrame{
|
|||
});
|
||||
|
||||
sidepanel.getStartButton().addActionListener((ActionEvent e) -> {
|
||||
Thread t = new Thread(() -> this.getPresenter().startScatterPlotVisualization(sidepanel.getInput()));
|
||||
Thread t = new Thread(
|
||||
() -> this.getPresenter().startScatterPlotVisualization(sidepanel.getInput()));
|
||||
t.start();
|
||||
});
|
||||
}
|
||||
|
@ -203,6 +203,7 @@ public class MainFrame extends JFrame{
|
|||
public void createTable(List<String> heading, List<List<String>> rows) {
|
||||
SwingUtilities.invokeLater(() -> output.logTable(heading, rows));
|
||||
}
|
||||
|
||||
/*******************************************************************************************************************
|
||||
* Getter und Setter Methoden
|
||||
******************************************************************************************************************/
|
||||
|
|
|
@ -1,9 +1,12 @@
|
|||
package View;
|
||||
|
||||
import javax.swing.*;
|
||||
import java.awt.*;
|
||||
import java.awt.event.ActionEvent;
|
||||
import java.awt.event.ActionListener;
|
||||
import java.awt.BorderLayout;
|
||||
import javax.swing.JMenu;
|
||||
import javax.swing.JMenuBar;
|
||||
import javax.swing.JMenuItem;
|
||||
import javax.swing.JPanel;
|
||||
import javax.swing.JSeparator;
|
||||
import javax.swing.SwingConstants;
|
||||
|
||||
/**
|
||||
* Implementierung verschiedener Algorithmen zur Berechnung von Ausgleichsgeraden.
|
||||
|
@ -24,7 +27,9 @@ public class MenuPanel extends JPanel {
|
|||
this.menu = new JMenu("File");
|
||||
|
||||
this.item = new JMenuItem("Exit");
|
||||
this.item.addActionListener(e -> { System.exit(0);});
|
||||
this.item.addActionListener(e -> {
|
||||
System.exit(0);
|
||||
});
|
||||
|
||||
menu.add(item);
|
||||
menuBar.add(menu);
|
||||
|
|
|
@ -1,9 +1,12 @@
|
|||
package View;
|
||||
|
||||
import javax.swing.*;
|
||||
import javax.swing.border.TitledBorder;
|
||||
import java.awt.*;
|
||||
import java.awt.BorderLayout;
|
||||
import java.util.List;
|
||||
import javax.swing.JPanel;
|
||||
import javax.swing.JScrollPane;
|
||||
import javax.swing.JTextPane;
|
||||
import javax.swing.border.TitledBorder;
|
||||
|
||||
/**
|
||||
* Implementierung verschiedener Algorithmen zur Berechnung von Ausgleichsgeraden.
|
||||
*
|
||||
|
@ -26,7 +29,6 @@ public class OutputPanel extends JPanel {
|
|||
|
||||
content = new StringBuilder();
|
||||
|
||||
|
||||
scrollPane = new JScrollPane(output);
|
||||
scrollPane.setWheelScrollingEnabled(true);
|
||||
this.add(scrollPane, BorderLayout.CENTER);
|
||||
|
@ -54,6 +56,7 @@ public class OutputPanel extends JPanel {
|
|||
|
||||
output.setText(content.toString());
|
||||
}
|
||||
|
||||
public void appendParagraphGreen(String p) {
|
||||
|
||||
content.append("<p style=\" color:green \"><em><strong>" + p + "</strong></em></p></br>");
|
||||
|
|
|
@ -1,24 +1,25 @@
|
|||
package View;
|
||||
|
||||
import Model.Line;
|
||||
import Model.Point;
|
||||
import java.awt.BasicStroke;
|
||||
import java.awt.BorderLayout;
|
||||
import java.awt.Color;
|
||||
import java.awt.Dimension;
|
||||
import java.awt.Shape;
|
||||
import java.util.ArrayList;
|
||||
import java.util.Collections;
|
||||
import java.util.LinkedList;
|
||||
import javax.swing.JPanel;
|
||||
import org.jfree.chart.ChartFactory;
|
||||
import org.jfree.chart.ChartPanel;
|
||||
import org.jfree.chart.JFreeChart;
|
||||
import org.jfree.chart.plot.PlotOrientation;
|
||||
import org.jfree.chart.plot.XYPlot;
|
||||
import org.jfree.chart.renderer.xy.XYItemRenderer;
|
||||
import org.jfree.chart.renderer.xy.XYLineAndShapeRenderer;
|
||||
import org.jfree.data.xy.XYSeries;
|
||||
import org.jfree.data.xy.XYSeriesCollection;
|
||||
import org.jfree.util.ShapeUtilities;
|
||||
|
||||
import javax.swing.*;
|
||||
import java.awt.*;
|
||||
import java.util.ArrayList;
|
||||
import java.util.Collections;
|
||||
import java.util.LinkedList;
|
||||
|
||||
/**
|
||||
* Implementierung verschiedener Algorithmen zur Berechnung von Ausgleichsgeraden.
|
||||
*
|
||||
|
@ -74,7 +75,6 @@ public class PlotDialog extends JPanel {
|
|||
renderer.setSeriesPaint(0, Color.blue);
|
||||
renderer.setSeriesShape(0, diamond);
|
||||
|
||||
|
||||
renderer.setSeriesPaint(1, Color.red);
|
||||
renderer.setSeriesShape(1, diamond);
|
||||
renderer.setSeriesStroke(1, new BasicStroke(2.0f));
|
||||
|
|
|
@ -1,8 +1,14 @@
|
|||
package View;
|
||||
|
||||
import javax.swing.*;
|
||||
import java.awt.BorderLayout;
|
||||
import java.awt.GridBagConstraints;
|
||||
import java.awt.GridBagLayout;
|
||||
import java.awt.Insets;
|
||||
import javax.swing.JButton;
|
||||
import javax.swing.JLabel;
|
||||
import javax.swing.JPanel;
|
||||
import javax.swing.JTextField;
|
||||
import javax.swing.border.TitledBorder;
|
||||
import java.awt.*;
|
||||
|
||||
/**
|
||||
* Implementierung verschiedener Algorithmen zur Berechnung von Ausgleichsgeraden.
|
||||
|
@ -32,7 +38,6 @@ public class SidePanel extends JPanel {
|
|||
this.northPanel.setBorder(new TitledBorder("Konfiguration"));
|
||||
this.centerPanel.setBorder(new TitledBorder("Visualisierung"));
|
||||
|
||||
|
||||
this.continer = new JPanel();
|
||||
this.continer.setLayout(new GridBagLayout());
|
||||
|
||||
|
|
|
@ -1,17 +1,16 @@
|
|||
package Model;
|
||||
|
||||
import static org.junit.Assert.assertArrayEquals;
|
||||
import static org.junit.Assert.assertEquals;
|
||||
|
||||
import Model.DCEL.DoublyConnectedEdgeList;
|
||||
import Model.DCEL.Edge;
|
||||
import Model.DCEL.Face;
|
||||
import Model.DCEL.Node;
|
||||
import java.util.LinkedList;
|
||||
import org.junit.Before;
|
||||
import org.junit.Test;
|
||||
|
||||
import java.util.LinkedList;
|
||||
|
||||
import static org.junit.Assert.assertArrayEquals;
|
||||
import static org.junit.Assert.assertEquals;
|
||||
|
||||
/**
|
||||
* Implementierung verschiedener Algorithmen zur Berechnung von Ausgleichsgeraden.
|
||||
*
|
||||
|
|
|
@ -1,16 +1,18 @@
|
|||
package Presenter.Algorithms;
|
||||
|
||||
|
||||
import static org.junit.Assert.assertArrayEquals;
|
||||
import static org.junit.Assert.assertEquals;
|
||||
import static org.junit.Assert.assertTrue;
|
||||
|
||||
import Model.Line;
|
||||
import Model.Point;
|
||||
import Model.Slab;
|
||||
import org.junit.Before;
|
||||
import org.junit.Test;
|
||||
|
||||
import Presenter.InversionCounter;
|
||||
import java.util.ArrayList;
|
||||
import java.util.LinkedList;
|
||||
|
||||
import static org.junit.Assert.*;
|
||||
import org.junit.Before;
|
||||
import org.junit.Test;
|
||||
|
||||
/**
|
||||
* Implementierung verschiedener Algorithmen zur Berechnung von Ausgleichsgeraden.
|
||||
|
@ -32,11 +34,9 @@ public class LeastMedianOfSquaresEstimatorTest {
|
|||
LinkedList<Line> lines = new LinkedList<>();
|
||||
LinkedList<Point> intersections = new LinkedList<>();
|
||||
|
||||
for (int i=0; i<5; i++)
|
||||
for (int i = 0; i < 5; i++) {
|
||||
lines.add(new Line(x[i], y[i]));
|
||||
|
||||
|
||||
|
||||
}
|
||||
|
||||
lms = new LeastMedianOfSquaresEstimator(lines, intersections);
|
||||
}
|
||||
|
@ -116,5 +116,4 @@ public class LeastMedianOfSquaresEstimatorTest {
|
|||
}
|
||||
|
||||
|
||||
|
||||
}
|
Loading…
Reference in New Issue