2020-03-21 00:37:09 +00:00
|
|
|
package de.wwwu.awolf.presenter.generator;
|
2017-08-01 17:34:09 +00:00
|
|
|
|
2020-03-21 00:37:09 +00:00
|
|
|
import de.wwwu.awolf.model.Line;
|
|
|
|
import de.wwwu.awolf.model.communication.Data;
|
|
|
|
import de.wwwu.awolf.model.communication.GeneratorData;
|
|
|
|
import de.wwwu.awolf.model.communication.SubscriberType;
|
|
|
|
import de.wwwu.awolf.presenter.Presenter;
|
2017-08-01 17:34:09 +00:00
|
|
|
|
2020-03-21 00:37:09 +00:00
|
|
|
import java.security.SecureRandom;
|
2017-09-07 09:21:48 +00:00
|
|
|
import java.util.HashMap;
|
2017-08-01 17:34:09 +00:00
|
|
|
import java.util.LinkedList;
|
2020-03-21 00:37:09 +00:00
|
|
|
import java.util.List;
|
|
|
|
import java.util.Map;
|
|
|
|
import java.util.concurrent.Flow;
|
2017-08-01 17:34:09 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* Implementierung verschiedener Algorithmen zur Berechnung von Ausgleichsgeraden.
|
|
|
|
*
|
|
|
|
* @Author: Armin Wolf
|
|
|
|
* @Email: a_wolf28@uni-muenster.de
|
|
|
|
* @Date: 01.08.2017.
|
|
|
|
*/
|
2020-03-21 00:37:09 +00:00
|
|
|
public class DatasetGenerator implements Flow.Publisher<Data> {
|
2017-08-01 17:34:09 +00:00
|
|
|
|
2017-08-03 06:27:38 +00:00
|
|
|
private Double m;
|
|
|
|
private Double b;
|
2020-03-21 00:37:09 +00:00
|
|
|
private SecureRandom random;
|
|
|
|
private Flow.Subscriber<? super Data> subscriber;
|
2017-08-03 06:27:38 +00:00
|
|
|
|
2017-10-15 10:45:47 +00:00
|
|
|
/**
|
|
|
|
* Konstruktor
|
|
|
|
*/
|
2020-03-21 00:37:09 +00:00
|
|
|
public DatasetGenerator(Presenter presenter) {
|
|
|
|
random = new SecureRandom();
|
|
|
|
this.subscribe(presenter);
|
2017-08-03 06:27:38 +00:00
|
|
|
}
|
2020-03-20 17:08:18 +00:00
|
|
|
|
2017-10-15 10:45:47 +00:00
|
|
|
/**
|
|
|
|
* Konstruktor
|
|
|
|
*/
|
2017-09-10 15:45:47 +00:00
|
|
|
public DatasetGenerator() {
|
2020-03-21 00:37:09 +00:00
|
|
|
random = new SecureRandom();
|
2017-08-03 06:27:38 +00:00
|
|
|
}
|
2017-08-01 17:34:09 +00:00
|
|
|
|
2017-10-15 10:45:47 +00:00
|
|
|
/**
|
|
|
|
* Generiert zu einer gegebenen Größe einen Datensatz des typen: Punktwolke
|
2020-03-20 17:08:18 +00:00
|
|
|
*
|
2017-10-15 10:45:47 +00:00
|
|
|
* @param size Größe des Datensatzes
|
|
|
|
* @return Liste der Geraden
|
|
|
|
*/
|
2017-09-10 15:45:47 +00:00
|
|
|
public LinkedList<Line> generateDataCloud(int size) {
|
2017-08-01 17:34:09 +00:00
|
|
|
LinkedList<Line> lines = new LinkedList<>();
|
2017-09-05 18:39:52 +00:00
|
|
|
m = 1 + random.nextDouble();
|
|
|
|
b = random.nextDouble();
|
2017-08-03 06:27:38 +00:00
|
|
|
|
2017-08-01 17:34:09 +00:00
|
|
|
|
2017-09-10 15:45:47 +00:00
|
|
|
for (int i = 1; i < (size + 1); i++) {
|
2017-08-01 17:34:09 +00:00
|
|
|
double y = (random.nextGaussian() * 100) % 100;
|
|
|
|
double signal = m * i + b;
|
|
|
|
signal *= -1;
|
|
|
|
|
2020-03-20 17:08:18 +00:00
|
|
|
Line line = new Line(i, signal - y);
|
2017-09-10 15:45:47 +00:00
|
|
|
line.setId(i - 1 + "");
|
2017-08-01 17:34:09 +00:00
|
|
|
lines.add(line);
|
|
|
|
}
|
2020-03-21 00:37:09 +00:00
|
|
|
|
|
|
|
communicate("Es wurden " + size + " Daten generiert mit den Parametern", m, b);
|
2017-08-01 17:34:09 +00:00
|
|
|
return lines;
|
|
|
|
}
|
|
|
|
|
2017-10-15 10:45:47 +00:00
|
|
|
/**
|
|
|
|
* Wrapper Methode zum generieren eines Datensatzes des typen: Gerade
|
2020-03-20 17:08:18 +00:00
|
|
|
*
|
2017-10-15 10:45:47 +00:00
|
|
|
* @param size Größe des Datensatzes
|
|
|
|
* @return Liste des Geraden
|
|
|
|
*/
|
2020-03-21 00:37:09 +00:00
|
|
|
public List<Line> generateDataLines(int size) {
|
|
|
|
List<Line> lines = new LinkedList<>();
|
2017-09-08 19:23:02 +00:00
|
|
|
return generateDataLines(lines, size);
|
2017-09-07 11:09:44 +00:00
|
|
|
}
|
|
|
|
|
2017-10-15 10:45:47 +00:00
|
|
|
/**
|
|
|
|
* Generieren eines Datensatzes des typen: Gerade. Die Geraden werden in eine
|
|
|
|
* übergebene Liste hinzugefügt.
|
2020-03-20 17:08:18 +00:00
|
|
|
*
|
2017-10-15 10:45:47 +00:00
|
|
|
* @param lines Liste der Geraden
|
|
|
|
* @param n Größe des Datensatzes
|
2020-03-20 17:08:18 +00:00
|
|
|
* @return Liste des Geraden
|
2017-10-15 10:45:47 +00:00
|
|
|
*/
|
2020-03-21 00:37:09 +00:00
|
|
|
private List<Line> generateDataLines(List<Line> lines, int n) {
|
2017-09-07 11:09:44 +00:00
|
|
|
m = 5d;
|
|
|
|
b = 0d;
|
2017-09-07 09:21:48 +00:00
|
|
|
|
|
|
|
int size = 0;
|
2020-03-21 00:37:09 +00:00
|
|
|
Map<Double, Double> points = new HashMap<>();
|
2017-09-07 09:21:48 +00:00
|
|
|
|
|
|
|
//speichere die Koordinaten in einer HashMap, damit keine Punkte
|
|
|
|
//entstehen deren x-Koordinate zu sehr beieinander liegt.
|
2017-09-10 15:45:47 +00:00
|
|
|
while (size < n) {
|
2017-09-07 11:09:44 +00:00
|
|
|
double y = random.nextGaussian();
|
2017-09-07 09:21:48 +00:00
|
|
|
double signal = m * y + b;
|
|
|
|
signal *= -1;
|
|
|
|
|
2017-09-10 15:45:47 +00:00
|
|
|
if (!points.containsKey(y)) {
|
|
|
|
points.put(y, signal);
|
2017-09-07 09:21:48 +00:00
|
|
|
size++;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-09-07 10:50:07 +00:00
|
|
|
int idx = lines.size();
|
2017-09-10 15:45:47 +00:00
|
|
|
for (Double d : points.keySet()) {
|
2020-03-20 17:08:18 +00:00
|
|
|
Line line = new Line(d, points.get(d));
|
2017-09-10 15:45:47 +00:00
|
|
|
line.setId(idx + "");
|
2017-09-07 09:21:48 +00:00
|
|
|
lines.add(line);
|
|
|
|
idx++;
|
|
|
|
}
|
|
|
|
|
2020-03-21 00:37:09 +00:00
|
|
|
communicate("Es wurden " + n + " Daten generiert mit den Parametern", m, b);
|
2017-09-07 09:21:48 +00:00
|
|
|
return lines;
|
|
|
|
}
|
|
|
|
|
2017-10-15 10:45:47 +00:00
|
|
|
/**
|
|
|
|
* Generiert einen Datensatz des typen: Gerade mit zirkulärer Störung. Zuerst wird die
|
|
|
|
* zirkuläre Störung zu der Liste der (dualen-)Geraden hinzugefügt danach wird die wrapper Methode
|
|
|
|
* <code>generateDataLines()</code> aufgerufen.
|
2020-03-20 17:08:18 +00:00
|
|
|
*
|
2017-10-15 10:45:47 +00:00
|
|
|
* @param size Größe des Datensatzes
|
|
|
|
* @return Liste der Geraden
|
|
|
|
*/
|
2020-03-21 00:37:09 +00:00
|
|
|
public List<Line> generateCircle(int size) {
|
|
|
|
List<Line> lines = new LinkedList<>();
|
2017-09-07 10:50:07 +00:00
|
|
|
|
|
|
|
double from = 0;
|
2017-09-07 11:09:44 +00:00
|
|
|
double to = Math.PI * 5;
|
|
|
|
//obere Grenze für die neuen Punkte
|
2017-09-10 15:45:47 +00:00
|
|
|
int n = size / 2 + lines.size();
|
2017-09-07 10:50:07 +00:00
|
|
|
|
|
|
|
//calculate the distance between every two points
|
|
|
|
double distance = (to - from) / ((double) n);
|
|
|
|
|
|
|
|
//create points
|
2017-09-10 15:45:47 +00:00
|
|
|
double currentDistance = from;
|
2017-09-07 11:09:44 +00:00
|
|
|
//an die aktuelle Liste dranhängen
|
2017-09-10 15:45:47 +00:00
|
|
|
for (int i = lines.size(); i < n; i++) {
|
2017-09-07 10:50:07 +00:00
|
|
|
double x = Math.cos(currentDistance);
|
|
|
|
double y = Math.sin(currentDistance);
|
|
|
|
|
2017-09-10 15:45:47 +00:00
|
|
|
Line line = new Line(x, y);
|
|
|
|
line.setId(i + "");
|
2017-09-07 10:50:07 +00:00
|
|
|
lines.add(line);
|
|
|
|
|
|
|
|
//distance for the next iteration
|
|
|
|
currentDistance += distance;
|
|
|
|
}
|
|
|
|
|
2017-09-10 15:45:47 +00:00
|
|
|
return generateDataLines(lines, size / 2);
|
2017-09-07 10:50:07 +00:00
|
|
|
}
|
|
|
|
|
2020-03-21 00:37:09 +00:00
|
|
|
@Override
|
|
|
|
public void subscribe(Flow.Subscriber<? super Data> subscriber) {
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
private void communicate(final String message, final double m, final double b) {
|
|
|
|
if (this.subscriber != null) {
|
|
|
|
GeneratorData data = new GeneratorData();
|
|
|
|
data.setType(SubscriberType.GENERATOR);
|
|
|
|
data.setMessage(message);
|
|
|
|
data.setM(m);
|
|
|
|
data.setB(b);
|
|
|
|
this.subscriber.onNext(data);
|
|
|
|
}
|
|
|
|
}
|
2017-08-01 17:34:09 +00:00
|
|
|
}
|
|
|
|
|