huge clean up

master
Armin Wolf 4 years ago
parent 471ad99190
commit 21c072fe7a

File diff suppressed because it is too large Load Diff

@ -1,4 +0,0 @@
path.variable.kotlin_bundled=C\:\\Program Files\\JetBrains\\IntelliJ IDEA 2017.2.3\\plugins\\Kotlin\\kotlinc
path.variable.maven_repository=C\:\\Users\\Armin\\.m2\\repository
jdk.home.1.8=C\:/Program Files/Java/jdk1.8.0_121
javac2.instrumentation.includeJavaRuntime=false

@ -1,182 +0,0 @@
<?xml version="1.0" encoding="UTF-8"?>
<project name="masterarbeit" default="all">
<property file="masterarbeit.properties"/>
<!-- Uncomment the following property if no tests compilation is needed -->
<!--
<property name="skip.tests" value="true"/>
-->
<!-- Compiler options -->
<property name="compiler.debug" value="on"/>
<property name="compiler.generate.no.warnings" value="off"/>
<property name="compiler.args" value=""/>
<property name="compiler.max.memory" value="6500m"/>
<patternset id="ignored.files">
<exclude name="**/*.hprof/**"/>
<exclude name="**/*.pyc/**"/>
<exclude name="**/*.pyo/**"/>
<exclude name="**/*.rbc/**"/>
<exclude name="**/*.yarb/**"/>
<exclude name="**/*~/**"/>
<exclude name="**/.DS_Store/**"/>
<exclude name="**/.git/**"/>
<exclude name="**/.hg/**"/>
<exclude name="**/.svn/**"/>
<exclude name="**/CVS/**"/>
<exclude name="**/__pycache__/**"/>
<exclude name="**/_svn/**"/>
<exclude name="**/vssver.scc/**"/>
<exclude name="**/vssver2.scc/**"/>
</patternset>
<patternset id="library.patterns">
<include name="*.egg"/>
<include name="*.jar"/>
<include name="*.ear"/>
<include name="*.swc"/>
<include name="*.war"/>
<include name="*.ane"/>
<include name="*.zip"/>
</patternset>
<patternset id="compiler.resources">
<exclude name="**/?*.java"/>
<exclude name="**/?*.form"/>
<exclude name="**/?*.class"/>
<exclude name="**/?*.groovy"/>
<exclude name="**/?*.scala"/>
<exclude name="**/?*.flex"/>
<exclude name="**/?*.kt"/>
<exclude name="**/?*.clj"/>
<exclude name="**/?*.aj"/>
</patternset>
<!-- JDK definitions -->
<property name="jdk.bin.1.8" value="${jdk.home.1.8}/bin"/>
<path id="jdk.classpath.1.8">
<fileset dir="${jdk.home.1.8}">
<include name="jre/lib/charsets.jar"/>
<include name="jre/lib/deploy.jar"/>
<include name="jre/lib/ext/access-bridge-64.jar"/>
<include name="jre/lib/ext/cldrdata.jar"/>
<include name="jre/lib/ext/dnsns.jar"/>
<include name="jre/lib/ext/jaccess.jar"/>
<include name="jre/lib/ext/jfxrt.jar"/>
<include name="jre/lib/ext/localedata.jar"/>
<include name="jre/lib/ext/nashorn.jar"/>
<include name="jre/lib/ext/sunec.jar"/>
<include name="jre/lib/ext/sunjce_provider.jar"/>
<include name="jre/lib/ext/sunmscapi.jar"/>
<include name="jre/lib/ext/sunpkcs11.jar"/>
<include name="jre/lib/ext/zipfs.jar"/>
<include name="jre/lib/javaws.jar"/>
<include name="jre/lib/jce.jar"/>
<include name="jre/lib/jfr.jar"/>
<include name="jre/lib/jfxswt.jar"/>
<include name="jre/lib/jsse.jar"/>
<include name="jre/lib/management-agent.jar"/>
<include name="jre/lib/plugin.jar"/>
<include name="jre/lib/resources.jar"/>
<include name="jre/lib/rt.jar"/>
</fileset>
</path>
<property name="project.jdk.home" value="${jdk.home.1.8}"/>
<property name="project.jdk.bin" value="${jdk.bin.1.8}"/>
<property name="project.jdk.classpath" value="jdk.classpath.1.8"/>
<!-- Project Libraries -->
<path id="library.maven:_bouncycastle:bcmail-jdk14:138.classpath">
<pathelement location="${path.variable.maven_repository}/bouncycastle/bcmail-jdk14/138/bcmail-jdk14-138.jar"/>
</path>
<path id="library.maven:_bouncycastle:bcprov-jdk14:138.classpath">
<pathelement location="${path.variable.maven_repository}/bouncycastle/bcprov-jdk14/138/bcprov-jdk14-138.jar"/>
</path>
<path id="library.maven:_com.jtattoo:jtattoo:1.6.11.classpath">
<pathelement location="${path.variable.maven_repository}/com/jtattoo/JTattoo/1.6.11/JTattoo-1.6.11.jar"/>
</path>
<path id="library.maven:_com.lowagie:itext:2.1.5.classpath">
<pathelement location="${path.variable.maven_repository}/com/lowagie/itext/2.1.5/itext-2.1.5.jar"/>
</path>
<path id="library.maven:_com.opencsv:opencsv:3.9.classpath">
<pathelement location="${path.variable.maven_repository}/com/opencsv/opencsv/3.9/opencsv-3.9.jar"/>
</path>
<path id="library.maven:_commons-beanutils:commons-beanutils:1.9.3.classpath">
<pathelement location="${path.variable.maven_repository}/commons-beanutils/commons-beanutils/1.9.3/commons-beanutils-1.9.3.jar"/>
</path>
<path id="library.maven:_commons-collections:commons-collections:3.2.2.classpath">
<pathelement location="${path.variable.maven_repository}/commons-collections/commons-collections/3.2.2/commons-collections-3.2.2.jar"/>
</path>
<path id="library.maven:_commons-io:commons-io:1.3.2.classpath">
<pathelement location="${path.variable.maven_repository}/commons-io/commons-io/1.3.2/commons-io-1.3.2.jar"/>
</path>
<path id="library.maven:_commons-logging:commons-logging:1.2.classpath">
<pathelement location="${path.variable.maven_repository}/commons-logging/commons-logging/1.2/commons-logging-1.2.jar"/>
</path>
<path id="library.maven:_junit:junit:4.12.classpath">
<pathelement location="${path.variable.maven_repository}/junit/junit/4.12/junit-4.12.jar"/>
</path>
<path id="library.maven:_org.apache.commons:commons-lang3:3.5.classpath">
<pathelement location="${path.variable.maven_repository}/org/apache/commons/commons-lang3/3.5/commons-lang3-3.5.jar"/>
</path>
<path id="library.maven:_org.hamcrest:hamcrest-core:1.3.classpath">
<pathelement location="${path.variable.maven_repository}/org/hamcrest/hamcrest-core/1.3/hamcrest-core-1.3.jar"/>
</path>
<path id="library.maven:_org.jfree:jcommon:1.0.17.classpath">
<pathelement location="${path.variable.maven_repository}/org/jfree/jcommon/1.0.17/jcommon-1.0.17.jar"/>
</path>
<path id="library.maven:_org.jfree:jfreechart:1.0.14.classpath">
<pathelement location="${path.variable.maven_repository}/org/jfree/jfreechart/1.0.14/jfreechart-1.0.14.jar"/>
</path>
<path id="library.maven:_org:opencv:2.4.13.classpath">
<pathelement location="${path.variable.maven_repository}/org/opencv/2.4.13/opencv-2.4.13.jar"/>
</path>
<path id="library.maven:_xml-apis:xml-apis:1.3.04.classpath">
<pathelement location="${path.variable.maven_repository}/xml-apis/xml-apis/1.3.04/xml-apis-1.3.04.jar"/>
</path>
<!-- Register Custom Compiler Taskdefs -->
<property name="javac2.home" value="${idea.home}/lib"/>
<path id="javac2.classpath">
<pathelement location="${javac2.home}/javac2.jar"/>
<pathelement location="${javac2.home}/jdom.jar"/>
<pathelement location="${javac2.home}/asm-all.jar"/>
<pathelement location="${javac2.home}/jgoodies-forms.jar"/>
</path>
<target name="register.custom.compilers">
<taskdef name="javac2" classname="com.intellij.ant.Javac2" classpathref="javac2.classpath"/>
<taskdef name="instrumentIdeaExtensions" classname="com.intellij.ant.InstrumentIdeaExtensions" classpathref="javac2.classpath"/>
</target>
<!-- Modules -->
<import file="${basedir}/module_masterarbeit.xml"/>
<target name="init" description="Build initialization">
<!-- Perform any build initialization in this target -->
</target>
<target name="clean" depends="clean.module.masterarbeit" description="cleanup all"/>
<target name="build.modules" depends="init, clean, compile.module.masterarbeit" description="build all modules"/>
<target name="all" depends="build.modules" description="build all"/>
</project>

@ -1,177 +0,0 @@
<?xml version="1.0" encoding="UTF-8"?>
<project name="module_masterarbeit" default="compile.module.masterarbeit">
<dirname property="module.masterarbeit.basedir" file="${ant.file.module_masterarbeit}"/>
<property name="module.jdk.home.masterarbeit" value="${project.jdk.home}"/>
<property name="module.jdk.bin.masterarbeit" value="${project.jdk.bin}"/>
<property name="module.jdk.classpath.masterarbeit" value="${project.jdk.classpath}"/>
<property name="compiler.args.masterarbeit" value="-encoding UTF-8 -source 1.8 -target 1.8 ${compiler.args}"/>
<property name="masterarbeit.output.dir" value="${module.masterarbeit.basedir}/target/classes"/>
<property name="masterarbeit.testoutput.dir" value="${module.masterarbeit.basedir}/target/test-classes"/>
<path id="masterarbeit.module.bootclasspath">
<!-- Paths to be included in compilation bootclasspath -->
</path>
<path id="masterarbeit.module.production.classpath">
<path refid="${module.jdk.classpath.masterarbeit}"/>
<pathelement location="${basedir}/../../../Downloads/opencv/build/java/opencv-2413.jar"/>
<pathelement location="${basedir}/libs/opencv-2413.jar"/>
<path refid="library.maven:_org.jfree:jfreechart:1.0.14.classpath"/>
<path refid="library.maven:_org.jfree:jcommon:1.0.17.classpath"/>
<path refid="library.maven:_xml-apis:xml-apis:1.3.04.classpath"/>
<path refid="library.maven:_com.lowagie:itext:2.1.5.classpath"/>
<path refid="library.maven:_bouncycastle:bcmail-jdk14:138.classpath"/>
<path refid="library.maven:_bouncycastle:bcprov-jdk14:138.classpath"/>
<path refid="library.maven:_junit:junit:4.12.classpath"/>
<path refid="library.maven:_org.hamcrest:hamcrest-core:1.3.classpath"/>
<path refid="library.maven:_com.opencsv:opencsv:3.9.classpath"/>
<path refid="library.maven:_org.apache.commons:commons-lang3:3.5.classpath"/>
<path refid="library.maven:_commons-beanutils:commons-beanutils:1.9.3.classpath"/>
<path refid="library.maven:_commons-logging:commons-logging:1.2.classpath"/>
<path refid="library.maven:_commons-collections:commons-collections:3.2.2.classpath"/>
<path refid="library.maven:_com.jtattoo:jtattoo:1.6.11.classpath"/>
<path refid="library.maven:_org:opencv:2.4.13.classpath"/>
<path refid="library.maven:_commons-io:commons-io:1.3.2.classpath"/>
</path>
<path id="masterarbeit.runtime.production.module.classpath">
<pathelement location="${masterarbeit.output.dir}"/>
<pathelement location="${basedir}/../../../Downloads/opencv/build/java/opencv-2413.jar"/>
<pathelement location="${basedir}/libs/opencv-2413.jar"/>
<path refid="library.maven:_org.jfree:jfreechart:1.0.14.classpath"/>
<path refid="library.maven:_org.jfree:jcommon:1.0.17.classpath"/>
<path refid="library.maven:_xml-apis:xml-apis:1.3.04.classpath"/>
<path refid="library.maven:_com.lowagie:itext:2.1.5.classpath"/>
<path refid="library.maven:_bouncycastle:bcmail-jdk14:138.classpath"/>
<path refid="library.maven:_bouncycastle:bcprov-jdk14:138.classpath"/>
<path refid="library.maven:_junit:junit:4.12.classpath"/>
<path refid="library.maven:_org.hamcrest:hamcrest-core:1.3.classpath"/>
<path refid="library.maven:_com.opencsv:opencsv:3.9.classpath"/>
<path refid="library.maven:_org.apache.commons:commons-lang3:3.5.classpath"/>
<path refid="library.maven:_commons-beanutils:commons-beanutils:1.9.3.classpath"/>
<path refid="library.maven:_commons-logging:commons-logging:1.2.classpath"/>
<path refid="library.maven:_commons-collections:commons-collections:3.2.2.classpath"/>
<path refid="library.maven:_com.jtattoo:jtattoo:1.6.11.classpath"/>
<path refid="library.maven:_org:opencv:2.4.13.classpath"/>
<path refid="library.maven:_commons-io:commons-io:1.3.2.classpath"/>
</path>
<path id="masterarbeit.module.classpath">
<path refid="${module.jdk.classpath.masterarbeit}"/>
<pathelement location="${masterarbeit.output.dir}"/>
<pathelement location="${basedir}/../../../Downloads/opencv/build/java/opencv-2413.jar"/>
<pathelement location="${basedir}/libs/opencv-2413.jar"/>
<path refid="library.maven:_org.jfree:jfreechart:1.0.14.classpath"/>
<path refid="library.maven:_org.jfree:jcommon:1.0.17.classpath"/>
<path refid="library.maven:_xml-apis:xml-apis:1.3.04.classpath"/>
<path refid="library.maven:_com.lowagie:itext:2.1.5.classpath"/>
<path refid="library.maven:_bouncycastle:bcmail-jdk14:138.classpath"/>
<path refid="library.maven:_bouncycastle:bcprov-jdk14:138.classpath"/>
<path refid="library.maven:_junit:junit:4.12.classpath"/>
<path refid="library.maven:_org.hamcrest:hamcrest-core:1.3.classpath"/>
<path refid="library.maven:_com.opencsv:opencsv:3.9.classpath"/>
<path refid="library.maven:_org.apache.commons:commons-lang3:3.5.classpath"/>
<path refid="library.maven:_commons-beanutils:commons-beanutils:1.9.3.classpath"/>
<path refid="library.maven:_commons-logging:commons-logging:1.2.classpath"/>
<path refid="library.maven:_commons-collections:commons-collections:3.2.2.classpath"/>
<path refid="library.maven:_com.jtattoo:jtattoo:1.6.11.classpath"/>
<path refid="library.maven:_org:opencv:2.4.13.classpath"/>
<path refid="library.maven:_commons-io:commons-io:1.3.2.classpath"/>
</path>
<path id="masterarbeit.runtime.module.classpath">
<pathelement location="${masterarbeit.testoutput.dir}"/>
<pathelement location="${masterarbeit.output.dir}"/>
<pathelement location="${basedir}/../../../Downloads/opencv/build/java/opencv-2413.jar"/>
<pathelement location="${basedir}/libs/opencv-2413.jar"/>
<path refid="library.maven:_org.jfree:jfreechart:1.0.14.classpath"/>
<path refid="library.maven:_org.jfree:jcommon:1.0.17.classpath"/>
<path refid="library.maven:_xml-apis:xml-apis:1.3.04.classpath"/>
<path refid="library.maven:_com.lowagie:itext:2.1.5.classpath"/>
<path refid="library.maven:_bouncycastle:bcmail-jdk14:138.classpath"/>
<path refid="library.maven:_bouncycastle:bcprov-jdk14:138.classpath"/>
<path refid="library.maven:_junit:junit:4.12.classpath"/>
<path refid="library.maven:_org.hamcrest:hamcrest-core:1.3.classpath"/>
<path refid="library.maven:_com.opencsv:opencsv:3.9.classpath"/>
<path refid="library.maven:_org.apache.commons:commons-lang3:3.5.classpath"/>
<path refid="library.maven:_commons-beanutils:commons-beanutils:1.9.3.classpath"/>
<path refid="library.maven:_commons-logging:commons-logging:1.2.classpath"/>
<path refid="library.maven:_commons-collections:commons-collections:3.2.2.classpath"/>
<path refid="library.maven:_com.jtattoo:jtattoo:1.6.11.classpath"/>
<path refid="library.maven:_org:opencv:2.4.13.classpath"/>
<path refid="library.maven:_commons-io:commons-io:1.3.2.classpath"/>
</path>
<patternset id="excluded.from.module.masterarbeit">
<patternset refid="ignored.files"/>
</patternset>
<patternset id="excluded.from.compilation.masterarbeit">
<patternset refid="excluded.from.module.masterarbeit"/>
</patternset>
<path id="masterarbeit.module.sourcepath">
<dirset dir="${module.masterarbeit.basedir}">
<include name="src/main/java"/>
<include name="src/main/resources"/>
</dirset>
</path>
<path id="masterarbeit.module.test.sourcepath">
<dirset dir="${module.masterarbeit.basedir}">
<include name="src/test/java"/>
</dirset>
</path>
<target name="compile.module.masterarbeit" depends="compile.module.masterarbeit.production,compile.module.masterarbeit.tests" description="Compile module masterarbeit"/>
<target name="compile.module.masterarbeit.production" depends="register.custom.compilers" description="Compile module masterarbeit; production classes">
<mkdir dir="${masterarbeit.output.dir}"/>
<javac2 destdir="${masterarbeit.output.dir}" debug="${compiler.debug}" nowarn="${compiler.generate.no.warnings}" memorymaximumsize="${compiler.max.memory}" fork="true" executable="${module.jdk.bin.masterarbeit}/javac">
<compilerarg line="${compiler.args.masterarbeit}"/>
<bootclasspath refid="masterarbeit.module.bootclasspath"/>
<classpath refid="masterarbeit.module.production.classpath"/>
<src refid="masterarbeit.module.sourcepath"/>
<patternset refid="excluded.from.compilation.masterarbeit"/>
</javac2>
<copy todir="${masterarbeit.output.dir}">
<fileset dir="${module.masterarbeit.basedir}/src/main/java">
<patternset refid="compiler.resources"/>
<type type="file"/>
</fileset>
<fileset dir="${module.masterarbeit.basedir}/src/main/resources">
<patternset refid="compiler.resources"/>
<type type="file"/>
</fileset>
</copy>
</target>
<target name="compile.module.masterarbeit.tests" depends="register.custom.compilers,compile.module.masterarbeit.production" description="compile module masterarbeit; test classes" unless="skip.tests">
<mkdir dir="${masterarbeit.testoutput.dir}"/>
<javac2 destdir="${masterarbeit.testoutput.dir}" debug="${compiler.debug}" nowarn="${compiler.generate.no.warnings}" memorymaximumsize="${compiler.max.memory}" fork="true" executable="${module.jdk.bin.masterarbeit}/javac">
<compilerarg line="${compiler.args.masterarbeit}"/>
<bootclasspath refid="masterarbeit.module.bootclasspath"/>
<classpath refid="masterarbeit.module.classpath"/>
<src refid="masterarbeit.module.test.sourcepath"/>
<patternset refid="excluded.from.compilation.masterarbeit"/>
</javac2>
<copy todir="${masterarbeit.testoutput.dir}">
<fileset dir="${module.masterarbeit.basedir}/src/test/java">
<patternset refid="compiler.resources"/>
<type type="file"/>
</fileset>
</copy>
</target>
<target name="clean.module.masterarbeit" description="cleanup module">
<delete dir="${masterarbeit.output.dir}"/>
<delete dir="${masterarbeit.testoutput.dir}"/>
</target>
</project>

@ -14,8 +14,8 @@
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-compiler-plugin</artifactId>
<configuration>
<source>1.8</source>
<target>1.8</target>
<source>11</source>
<target>11</target>
</configuration>
</plugin>
@ -33,7 +33,7 @@
<!-- MainClass in mainfest make a executable jar -->
<archive>
<manifest>
<mainClass>App</mainClass>
<mainClass>de.wwwu.awolf.App</mainClass>
</manifest>
</archive>
@ -114,6 +114,20 @@
<artifactId>opencv</artifactId>
<version>3.2.0-1</version>
</dependency>
<dependency>
<groupId>log4j</groupId>
<artifactId>log4j</artifactId>
<version>1.2.17</version>
</dependency>
<dependency>
<groupId>commons-cli</groupId>
<artifactId>commons-cli</artifactId>
<version>1.4</version>
</dependency>
</dependencies>

@ -1,136 +0,0 @@
import model.Line;
import model.LineModel;
import model.Point;
import presenter.Presenter;
import presenter.algorithms.advanced.LeastMedianOfSquaresEstimator;
import presenter.algorithms.advanced.RepeatedMedianEstimator;
import presenter.algorithms.advanced.TheilSenEstimator;
import presenter.algorithms.naiv.NaivLeastMedianOfSquaresEstimator;
import presenter.algorithms.naiv.NaivRepeatedMedianEstimator;
import presenter.algorithms.naiv.NaivTheilSenEstimator;
import presenter.generator.DatasetGenerator;
import presenter.util.IntersectionComputer;
import view.MainFrame;
import javax.swing.*;
import java.awt.*;
import java.util.ArrayList;
import java.util.LinkedList;
/**
* Implementierung verschiedener Algorithmen zur Berechnung von Ausgleichsgeraden.
*
* @Author: Armin Wolf
* @Email: a_wolf28@uni-muenster.de
* @Date: 28.05.2017.
*/
public class App {
/**
* Laden der native Library für OpenCV
*/
static {
nu.pattern.OpenCV.loadShared();
System.loadLibrary(org.opencv.core.Core.NATIVE_LIBRARY_NAME);
}
/**
* Schriftart wird neu gesetzt
*
* @param f Schriftart
*/
private static void setUIFont(javax.swing.plaf.FontUIResource f) {
java.util.Enumeration<Object> keys = UIManager.getDefaults().keys();
while (keys.hasMoreElements()) {
Object key = keys.nextElement();
Object value = UIManager.get(key);
if (value instanceof javax.swing.plaf.FontUIResource) {
UIManager.put(key, f);
}
}
}
/**
* Das LookAndFeel wird neu gesetzt.
*
* @param view View Klasse
*/
private static void setLookAndFeel(JFrame view) {
String[] laf = {"com.jtattoo.plaf.aluminium.AluminiumLookAndFeel",
"com.jtattoo.plaf.acryl.AcrylLookAndFeel",
"com.jtattoo.plaf.aero.AeroLookAndFeel",
"com.jtattoo.plaf.fast.FastLookAndFeel",
"com.jtattoo.plaf.graphite.GraphiteLookAndFeel",
"com.jtattoo.plaf.luna.LunaLookAndFeel",
"com.jtattoo.plaf.noire.NoireLookAndFeel"};
try {
UIManager.setLookAndFeel(laf[4]);
} catch (ClassNotFoundException e) {
e.printStackTrace();
} catch (InstantiationException e) {
e.printStackTrace();
} catch (IllegalAccessException e) {
e.printStackTrace();
} catch (UnsupportedLookAndFeelException e) {
e.printStackTrace();
}
SwingUtilities.updateComponentTreeUI(view);
}
/**
* Die Methode rechnet für gegebene Größen die Algorithmen durch und gibt jeweils die benötigte Zeit
*/
public static void benchmark() {
int[] sizes = {50, 500, 1000, 3000, 5000, 10000};
for (int i = 5; i < sizes.length; i++) {
System.out.println("---- Datasetgröße: " + sizes[i] + " ----");
DatasetGenerator generator = new DatasetGenerator();
LinkedList<Line> lines = generator.generateDataCloud(sizes[i]);
IntersectionComputer computer = new IntersectionComputer(lines);
ArrayList<Point> points = computer.compute();
NaivLeastMedianOfSquaresEstimator naivLms = new NaivLeastMedianOfSquaresEstimator(lines);
naivLms.run();
NaivRepeatedMedianEstimator naivRm = new NaivRepeatedMedianEstimator(lines);
naivRm.run();
NaivTheilSenEstimator naivTs = new NaivTheilSenEstimator(lines);
naivTs.run();
LeastMedianOfSquaresEstimator lms = new LeastMedianOfSquaresEstimator(lines, points);
lms.run();
RepeatedMedianEstimator rm = new RepeatedMedianEstimator(lines);
rm.run();
TheilSenEstimator ts = new TheilSenEstimator(lines, points);
ts.run();
}
}
/**
* Maim Methode
*
* @param args
*/
public static void main(String[] args) {
if (args.length > 0 && args[0] == "--benchmark") {
benchmark();
} else {
final Presenter presenter = new Presenter(new LineModel(), null);
SwingUtilities.invokeLater(() -> {
//JFrame.setDefaultLookAndFeelDecorated(true);
MainFrame view = new MainFrame();
setLookAndFeel(view);
setUIFont(new javax.swing.plaf.FontUIResource(new Font("SansSerif", Font.PLAIN, 12)));
view.setPresenter(presenter);
view.setActionListeners();
presenter.setView(view);
});
}
}
}

@ -0,0 +1,111 @@
package de.wwwu.awolf;
import de.wwwu.awolf.model.Line;
import de.wwwu.awolf.model.LineModel;
import de.wwwu.awolf.model.Point;
import de.wwwu.awolf.presenter.Presenter;
import de.wwwu.awolf.presenter.algorithms.advanced.LeastMedianOfSquaresEstimator;
import de.wwwu.awolf.presenter.algorithms.advanced.RepeatedMedianEstimator;
import de.wwwu.awolf.presenter.algorithms.advanced.TheilSenEstimator;
import de.wwwu.awolf.presenter.algorithms.naiv.NaivLeastMedianOfSquaresEstimator;
import de.wwwu.awolf.presenter.algorithms.naiv.NaivRepeatedMedianEstimator;
import de.wwwu.awolf.presenter.algorithms.naiv.NaivTheilSenEstimator;
import de.wwwu.awolf.presenter.generator.DatasetGenerator;
import de.wwwu.awolf.presenter.util.IntersectionComputer;
import de.wwwu.awolf.presenter.util.Logging;
import de.wwwu.awolf.view.MainFrame;
import org.apache.commons.cli.*;
import javax.swing.*;
import java.awt.*;
import java.util.ArrayList;
import java.util.LinkedList;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
/**
* Implementierung verschiedener Algorithmen zur Berechnung von Ausgleichsgeraden.
*
* @Author: Armin Wolf
* @Email: a_wolf28@uni-muenster.de
* @Date: 28.05.2017.
*/
public class App {
/**
* Schriftart wird neu gesetzt
*
* @param f Schriftart
*/
private static void setUIFont(javax.swing.plaf.FontUIResource f) {
java.util.Enumeration<Object> keys = UIManager.getDefaults().keys();
while (keys.hasMoreElements()) {
Object key = keys.nextElement();
Object value = UIManager.get(key);
if (value instanceof javax.swing.plaf.FontUIResource) {
UIManager.put(key, f);
}
}
}
/**
* Die Methode rechnet für gegebene Größen die Algorithmen durch und gibt jeweils die benötigte Zeit
*/
public static void benchmark() {
ExecutorService executorService = Executors.newFixedThreadPool(6);
Logging.logInfo("---- Datasetgröße: " + 100 + " ----");
DatasetGenerator generator = new DatasetGenerator();
LinkedList<Line> lines = generator.generateDataCloud(10000);
IntersectionComputer computer = new IntersectionComputer(lines);
ArrayList<Point> points = computer.compute();
executorService.submit(new NaivLeastMedianOfSquaresEstimator(lines));
executorService.submit(new NaivRepeatedMedianEstimator(lines));
executorService.submit(new NaivTheilSenEstimator(lines));
executorService.submit(new LeastMedianOfSquaresEstimator(lines, points));
executorService.submit(new RepeatedMedianEstimator(lines));
executorService.submit(new TheilSenEstimator(lines, points));
}
/**
* Maim Methode
*
* @param argv
*/
public static void main(String[] argv) {
Options options = new Options();
options.addOption("benchmark", "Start stresstest");
options.addOption("", "default");
CommandLineParser parser = new DefaultParser();
try {
CommandLine line = parser.parse(options, argv); // Sensitive
String[] args = line.getArgs();
if (args.length > 0 && args[0].equals("benchmark")) {
benchmark();
} else {
final Presenter presenter = new Presenter(new LineModel(), null);
SwingUtilities.invokeLater(() -> {
MainFrame view = new MainFrame();
setUIFont(new javax.swing.plaf.FontUIResource(new Font("SansSerif", Font.PLAIN, 12)));
try {
UIManager.setLookAndFeel("javax.swing.plaf.metal.MetalLookAndFeel");
} catch (ClassNotFoundException | UnsupportedLookAndFeelException | IllegalAccessException | InstantiationException e) {
Logging.logError("Error with the UI. ", e);
}
view.setPresenter(presenter);
view.setActionListeners();
presenter.setView(view);
});
}
} catch (ParseException e) {
Logging.logError("Error while parsing the command line arguments.", e);
}
}
}

@ -1,4 +1,4 @@
package model;
package de.wwwu.awolf.model;
/**
* Implementierung verschiedener Algorithmen zur Berechnung von Ausgleichsgeraden.

@ -1,4 +1,4 @@
package model;
package de.wwwu.awolf.model;
/**
* Implementierung verschiedener Algorithmen zur Berechnung von Ausgleichsgeraden.
@ -166,12 +166,26 @@ public class Line {
/**
* Vergleich einzelner Geradern
*
* @param other zu vergleichende Gerade
* @param obj zu vergleichende Gerade
* @return <code>true</code> falls die Geraden Gleich sind
*/
public boolean equals(Line other) {
return other.getM() == this.getM() && other.getB() == this.getB();
@Override
public boolean equals(Object obj) {
if (obj instanceof Line) {
Line other = (Line) obj;
return other.getM().equals(this.getM()) && other.getB().equals(this.getB());
} else {
return super.equals(obj);
}
}
@Override
public int hashCode() {
return super.hashCode() + this.getM().hashCode() + this.getB().hashCode();
}
@Override
public String toString() {
return "Line m: " + this.getM() + ", b: " + this.getB();
}
}

@ -1,7 +1,8 @@
package model;
package de.wwwu.awolf.model;
import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;
/**
* Implementierung verschiedener Algorithmen zur Berechnung von Ausgleichsgeraden.
@ -12,8 +13,8 @@ import java.util.LinkedList;
*/
public class LineModel {
private ArrayList<Point> nodes;
private LinkedList<Line> lines;
private List<Point> nodes;
private List<Line> lines;
private Double xMinimum;
private Double xMaximum;
private Double yMinimum;
@ -54,28 +55,28 @@ public class LineModel {
/**
* @return Liste der Schnittpunkte
*/
public ArrayList<Point> getNodes() {
public List<Point> getNodes() {
return nodes;
}
/**
* @param nodes Liste der Schnittpunkte
*/
public void setNodes(ArrayList<Point> nodes) {
public void setNodes(List<Point> nodes) {
this.nodes = nodes;
}
/**
* @return Liste der Geraden
*/
public LinkedList<Line> getLines() {
public List<Line> getLines() {
return lines;
}
/**
* @param lines Liste der Geraden
*/
public void setLines(LinkedList<Line> lines) {
public void setLines(List<Line> lines) {
this.lines = lines;
}

@ -1,4 +1,4 @@
package model;
package de.wwwu.awolf.model;
/**
* Implementierung verschiedener Algorithmen zur Berechnung von Ausgleichsgeraden.

@ -1,4 +1,4 @@
package model;
package de.wwwu.awolf.model;
/**
* Implementierung verschiedener Algorithmen zur Berechnung von Ausgleichsgeraden.
@ -67,7 +67,7 @@ public class Point implements Comparable<Point> {
@Override
public int compareTo(Point o) {
if (this.getX() == o.getX()) {
if (this.getX().equals(o.getX())) {
if (this.getY() <= o.getY()) {
return -1;
} else {
@ -83,11 +83,22 @@ public class Point implements Comparable<Point> {
/**
* Vergleich zweier Punkte
*
* @param other zu vergleichernder Punkt
* @param obj zu vergleichernder Punkt
* @return <code>true</code> falls die Punkte gleich sind
*/
public boolean equals(Point other) {
return other.getX() == this.getX() && other.getY() == this.getY();
@Override
public boolean equals(Object obj) {
if (obj instanceof Point) {
Point other = (Point) obj;
return other.getX().equals(this.getX()) && other.getY().equals(this.getY());
} else {
return super.equals(obj);
}
}
@Override
public int hashCode() {
return super.hashCode() + this.getX().hashCode() + this.getY().hashCode();
}
/**

@ -0,0 +1,27 @@
package de.wwwu.awolf.model.communication;
import de.wwwu.awolf.model.Line;
public class AlgorithmData implements Data {
private SubscriberType type;
private Line lineData;
@Override
public SubscriberType getType() {
return type;
}
@Override
public void setType(SubscriberType type) {
this.type = type;
}
public Line getLineData() {
return lineData;
}
public void setLineData(Line lineData) {
this.lineData = lineData;
}
}

@ -0,0 +1,7 @@
package de.wwwu.awolf.model.communication;
public interface Data {
SubscriberType getType();
void setType(SubscriberType type);
}

@ -0,0 +1,56 @@
package de.wwwu.awolf.model.communication;
import de.wwwu.awolf.presenter.algorithms.Algorithm;
import java.util.List;
public class EvaluationData implements Data {
private SubscriberType type;
private List<Algorithm.Type> algorithmtypes;
private List<Double> oneColumnresult;
private List<List<String>> multipleColumnResult;
private int column;
private List<String> labels;
public List<Algorithm.Type> getAlgorithmtypes() {
return algorithmtypes;
}
public void setAlgorithmtypes(List<Algorithm.Type> algorithmtype) {
this.algorithmtypes = algorithmtype;
}
public List<Double> getOneColumnresult() {
return oneColumnresult;
}
public void setOneColumnresult(List<Double> oneColumnresult) {
this.oneColumnresult = oneColumnresult;
}
public List<List<String>> getMultipleColumnResult() {
return multipleColumnResult;
}
public void setMultipleColumnResult(List<List<String>> multipleColumnResult) {
this.multipleColumnResult = multipleColumnResult;
}
@Override
public SubscriberType getType() {
return type;
}
@Override
public void setType(SubscriberType type) {
this.type = type;
}
public void setColumn(int col) {
this.column = col;
}
public void setLabels(List<String> tableInput) {
this.labels = tableInput;
}
}

@ -0,0 +1,25 @@
package de.wwwu.awolf.model.communication;
public class ExportData implements Data {
private SubscriberType type;
private String message;
public String getMessage() {
return message;
}
public void setMessage(String message) {
this.message = message;
}
@Override
public SubscriberType getType() {
return type;
}
@Override
public void setType(SubscriberType type) {
this.type = type;
}
}

@ -0,0 +1,43 @@
package de.wwwu.awolf.model.communication;
public class GeneratorData implements Data {
private SubscriberType type;
private String message;
private double m;
private double b;
public double getM() {
return m;
}
public void setM(double m) {
this.m = m;
}
public double getB() {
return b;
}
public void setB(double b) {
this.b = b;
}
public String getMessage() {
return message;
}
public void setMessage(String message) {
this.message = message;
}
@Override
public SubscriberType getType() {
return type;
}
@Override
public void setType(SubscriberType type) {
this.type = type;
}
}

@ -0,0 +1,34 @@
package de.wwwu.awolf.model.communication;
public class ImportData implements Data {
private SubscriberType type;
private int numberOfLines;
private int current;
@Override
public SubscriberType getType() {
return type;
}
@Override
public void setType(SubscriberType type) {
this.type = type;
}
public int getNumberOfLines() {
return numberOfLines;
}
public void setNumberOfLines(int numberOfLines) {
this.numberOfLines = numberOfLines;
}
public int getCurrent() {
return current;
}
public void setCurrent(int current) {
this.current = current;
}
}

@ -0,0 +1,18 @@
package de.wwwu.awolf.model.communication;
public enum SubscriberType {
EVALUATE_DATASET_GENERATED,
EVAL_D,
EVAL_DS,
EVAL_T,
LINES_RES,
LINES_RES_MULT,
LMS,
RM,
TS,
IMPORT,
PICTURE,
EXPORT,
GENERATOR
}

@ -0,0 +1,15 @@
package de.wwwu.awolf.model.communication;
public class TypeData implements Data {
private SubscriberType type;
@Override
public SubscriberType getType() {
return type;
}
@Override
public void setType(SubscriberType type) {
this.type = type;
}
}

@ -0,0 +1,206 @@
package de.wwwu.awolf.presenter;
import de.wwwu.awolf.model.LineModel;
import de.wwwu.awolf.model.communication.Data;
import de.wwwu.awolf.presenter.evaluation.EvaluateAlgorithms;
import de.wwwu.awolf.presenter.util.IntersectionComputer;
import de.wwwu.awolf.presenter.util.Logging;
import de.wwwu.awolf.view.MainFrame;
import javax.swing.*;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Flow;
/**
* Implementierung verschiedener Algorithmen zur Berechnung von Ausgleichsgeraden.
*
* @Author: Armin Wolf
* @Email: a_wolf28@uni-muenster.de
* @Date: 10.09.2017.
*/
public abstract class AbstractPresenter implements Flow.Subscriber<Data> {
private final ExecutorService executor;
private LineModel model;
private MainFrame view;
private EvaluateAlgorithms eval;
/**
* Konstruktor
*
* @param model Modell
* @param view View
*/
public AbstractPresenter(LineModel model, MainFrame view) {
this.model = model;
this.view = view;
executor = Executors.newCachedThreadPool();
}
@Override
public void onSubscribe(Flow.Subscription subscription) {
Logging.logInfo("New Subscription: " + subscription.toString());
subscription.request(15);
}
@Override
public void onNext(Data data) {
switch (data.getType()) {
case EVAL_D:
evaluatedData(data);
break;
case EVAL_DS:
evaluatedDatas(data);
break;
case EVAL_T:
evaluatedTypes(data);
break;
case LINES_RES:
visualizeResults(data);
break;
case LINES_RES_MULT:
visualizeMultipleData(data);
break;
case LMS:
visualizeLmsAlgorithm(data);
break;
case RM:
visualizeRmAlgorithm(data);
break;
case TS:
visualizeTsAlgorithm(data);
break;
case IMPORT:
handleImport(data);
break;
case EXPORT:
handleExport(data);
break;
case GENERATOR:
Logging.logInfo("Generierung war Erfolgreich");
break;
default:
break;
}
}
protected abstract void handleExport(Data data);
protected abstract void handleImport(Data data);
protected abstract void visualizeTsAlgorithm(Data data);
protected abstract void visualizeRmAlgorithm(Data data);
protected abstract void visualizeLmsAlgorithm(Data data);
protected abstract void visualizeMultipleData(Data data);
protected abstract void visualizeResults(Data data);
protected abstract void evaluatedTypes(Data data);
protected abstract void evaluatedDatas(Data data);
protected abstract void evaluatedData(Data data);
@Override
public void onError(Throwable throwable) {
}
@Override
public void onComplete() {
}
/**
* Startet das parallele Berechnen der Schnittpunkte der Geraden die im Modell enthalten sind.
*/
private void startIntersectionCalculation() {
getExecutor().submit(() -> {
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());
});
}
/**
* Wrapper Methode die das berechnen der Schnittpunkte anstößt und die Ergebnisse(Anzahl der Schnittpunkte)
* visuell darstellt.
*/
protected void computeIntersections() {
getExecutor().submit(() -> {
long start, end;
start = System.currentTimeMillis();
startIntersectionCalculation();
end = System.currentTimeMillis();
Logging.logInfo("Zeit: " + (end - start) / 1000);
});
//darstellung der Ergebnisse
SwingUtilities.invokeLater(() -> {
getView().enableFunctionality();
getView().getProgressDialog().dispose();
});
Logging.logInfo("Informationen zu dem aktuellen Modell");
Logging.logInfo("Anzahl der Geraden: " + getModel().getLines().size() + ".");
Logging.logInfo("Anzahl der Schnittpunkte: " + getModel().getNodes().size() + ".");
Logging.logInfo("Import war Erfolgreich!");
}
/**
* @return das zu grunde legende Modell
*/
public LineModel getModel() {
return model;
}
/**
* @param model das zu grunde legende Modell
*/
public void setModel(LineModel model) {
this.model = model;
}
/**
* @return die zu grunde legende View
*/
public MainFrame getView() {
return view;
}
/**
* @param view die zu grunde legende View
*/
public void setView(MainFrame view) {
this.view = view;
}
/**
* @return Evaluation
*/
public EvaluateAlgorithms getEval() {
return eval;
}
/**
* @param eval Evaluation
*/
public void setEval(EvaluateAlgorithms eval) {
this.eval = eval;
}
public ExecutorService getExecutor() {
return executor;
}
}

@ -1,21 +1,25 @@
package presenter;
import model.Line;
import model.LineModel;
import presenter.algorithms.advanced.LeastMedianOfSquaresEstimator;
import presenter.algorithms.advanced.RepeatedMedianEstimator;
import presenter.algorithms.advanced.TheilSenEstimator;
import presenter.evaluation.EvaluateAlgorithms;
import presenter.evaluation.PictureProcessor;
import presenter.generator.DatasetGenerator;
import presenter.io.DataExporter;
import presenter.io.DataImporter;
import presenter.io.EvalResultLatexExport;
import view.MainFrame;
import javax.swing.table.DefaultTableModel;
package de.wwwu.awolf.presenter;
import de.wwwu.awolf.model.Line;
import de.wwwu.awolf.model.LineModel;
import de.wwwu.awolf.model.communication.AlgorithmData;
import de.wwwu.awolf.model.communication.Data;
import de.wwwu.awolf.model.communication.ExportData;
import de.wwwu.awolf.model.communication.ImportData;
import de.wwwu.awolf.presenter.algorithms.advanced.LeastMedianOfSquaresEstimator;
import de.wwwu.awolf.presenter.algorithms.advanced.RepeatedMedianEstimator;
import de.wwwu.awolf.presenter.algorithms.advanced.TheilSenEstimator;
import de.wwwu.awolf.presenter.evaluation.EvaluateAlgorithms;
import de.wwwu.awolf.presenter.evaluation.PictureProcessor;
import de.wwwu.awolf.presenter.generator.DatasetGenerator;
import de.wwwu.awolf.presenter.io.DataExporter;
import de.wwwu.awolf.presenter.io.DataImporter;
import de.wwwu.awolf.presenter.util.Logging;
import de.wwwu.awolf.view.MainFrame;
import javax.swing.*;
import java.io.File;
import java.util.LinkedList;
import java.util.List;
/**
@ -33,6 +37,80 @@ public class Presenter extends AbstractPresenter {
}
@Override
protected void handleExport(Data data) {
ExportData exportData = (ExportData) data;
Logging.logInfo(exportData.getMessage());
Logging.logInfo("Export der Daten als CSV");
Logging.logInfo("Export war Erfolgreich");
}
@Override
protected void handleImport(Data data) {
ImportData importData = (ImportData) data;
double max = importData.getNumberOfLines();
double current = importData.getCurrent();
Integer progress = (int) (100 * (current / max));
//100% erreicht
Logging.logInfo("Import war erfolgreich!");
SwingUtilities.invokeLater(() -> getView().showImportProgress(progress));
}
@Override
protected void visualizeTsAlgorithm(Data data) {
AlgorithmData algorithmData = (AlgorithmData) data;
SwingUtilities.invokeLater(() -> getView().visualizeTS(algorithmData.getLineData()));
Logging.logInfo("Theil-Sen Estimator");
Logging.logInfo(algorithmData.getLineData().toString());
Logging.logInfo("Berechnung wurde Erfolgreich durchgeführt.");
}
@Override
protected void visualizeRmAlgorithm(Data data) {
AlgorithmData algorithmData = (AlgorithmData) data;
SwingUtilities.invokeLater(() -> getView().visualizeRM(algorithmData.getLineData()));
Logging.logInfo("Repeated Median Estimator");
Logging.logInfo(algorithmData.getLineData().toString());
Logging.logInfo("Berechnung wurde Erfolgreich durchgeführt.");
}
@Override
protected void visualizeLmsAlgorithm(Data data) {
AlgorithmData algorithmData = (AlgorithmData) data;
SwingUtilities.invokeLater(() -> getView().visualizeLMS(algorithmData.getLineData()));
Logging.logInfo("Least Median of Squares");
Logging.logInfo(algorithmData.getLineData().toString());
Logging.logInfo("Berechnung wurde Erfolgreich durchgeführt.");
}
@Override
protected void visualizeMultipleData(Data data) {
//Result:
//0:
SwingUtilities.invokeLater(() -> getView().drawLineResults(result));
}
@Override
protected void visualizeResults(Data data) {
SwingUtilities.invokeLater(() -> getView().drawLineResults(result));
}
@Override
protected void evaluatedTypes(Data data) {
SwingUtilities.invokeLater(() -> getView().appendEvalResult(result, Integer.parseInt(result[1]), true));
}
@Override
protected void evaluatedDatas(Data data) {
SwingUtilities.invokeLater(() -> getView().appendEvalResult(result));
}
@Override
protected void evaluatedData(Data data) {
SwingUtilities.invokeLater(() -> getView().appendEvalResult(result, Integer.parseInt(result[1]), false));
}
public void visualizeDualLines() {
getView().createDualityDialog();
}
@ -56,7 +134,6 @@ public class Presenter extends AbstractPresenter {
lms.setConstant(constant);
lms.setQuantileError(error);
//Presenter soll die Klasse überwachen
lms.addObserver(this);
getExecutor().execute(lms);
}
@ -74,7 +151,6 @@ public class Presenter extends AbstractPresenter {
Double parameter = Double.parseDouble(input);
rm.setBeta(parameter);
//Presenter soll die Klasse überwachen
rm.addObserver(this);
getExecutor().execute(rm);
@ -90,7 +166,6 @@ public class Presenter extends AbstractPresenter {
if (input != null) {
TheilSenEstimator ts = new TheilSenEstimator(getModel().getLines(), getModel().getNodes(), this);
//Presenter soll die Klasse überwachen
ts.addObserver(this);
getExecutor().execute(ts);
}
@ -107,14 +182,13 @@ public class Presenter extends AbstractPresenter {
*/
public void startImport(File file) {
DataImporter importer = new DataImporter(file);
DataImporter importer = new DataImporter(file, this);
//Presenter soll die Klasse überwachen
importer.addObserver(this);
getExecutor().execute(new Runnable() {
@Override
public void run() {
LinkedList<Line> importedLines = importer.run();
List<Line> importedLines = importer.run();
if (importedLines != null) {
//Berechnung der Schnittpunkte und vis. der Ergebnisse (anz. Geraden, anz. Schnittpunkte)
getModel().setLines(importedLines);
@ -132,7 +206,6 @@ public class Presenter extends AbstractPresenter {
public void startPictureDataImport(File file) {
PictureProcessor pictureProcessor = new PictureProcessor(this, file);
//Presenter soll die Klasse überwachen
pictureProcessor.addObserver(this);
getExecutor().execute(new Runnable() {
@Override
@ -152,9 +225,8 @@ public class Presenter extends AbstractPresenter {
* @param file Datei in der die Informationen gespeichert werden sollen
*/
public void startExport(File file) {
DataExporter exporter = new DataExporter(getModel().getLines(), file);
DataExporter exporter = new DataExporter(getModel().getLines(), file, this);
//Presenter soll die Klasse überwachen
exporter.addObserver(this);
getExecutor().execute(new Runnable() {
@Override
@ -170,9 +242,8 @@ public class Presenter extends AbstractPresenter {
* @param file Datei in der die Informationen gespeichert werden sollen
*/
public void startDatasetExportEvaluation(File file) {
DataExporter exporter = new DataExporter(getEval().getData(), file);
DataExporter exporter = new DataExporter(getEval().getData(), file, this);
//Presenter soll die Klasse überwachen
exporter.addObserver(this);
getExecutor().execute(new Runnable() {
@Override
@ -182,19 +253,6 @@ public class Presenter extends AbstractPresenter {
});
}
/**
* 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) {
getExecutor().execute(() -> {
EvalResultLatexExport exporter = new EvalResultLatexExport(model, file);
exporter.writeFile();
});
}
/**
* Startet das generieren der Datensätze der Größe <code>n</code>
*
@ -202,13 +260,9 @@ public class Presenter extends AbstractPresenter {
* @param type Art der Datensatzes
*/
public void generateDataset(int n, int type) {
DatasetGenerator generator = new DatasetGenerator();
generator.addObserver(this);
DatasetGenerator generator = new DatasetGenerator(this);
getExecutor().execute(() -> {
switch (type) {
case 0:
getModel().setLines(generator.generateDataCloud(n));
break;
case 1:
getModel().setLines(generator.generateDataLines(n));
break;
@ -219,7 +273,6 @@ public class Presenter extends AbstractPresenter {
getModel().setLines(generator.generateDataCloud(n));
break;
}
computeIntersections();
getView().enableFunctionality();
});
@ -236,8 +289,7 @@ public class Presenter extends AbstractPresenter {
* @param datasettyp Typ des Datensatzes (Geradem Punktwolke, Kreis und Gerade)
*/
public void startEvaluation(int typ, int n, int alg, String datasettyp) {
setEval(new EvaluateAlgorithms(typ, n, alg, datasettyp));
getEval().addObserver(this);
setEval(new EvaluateAlgorithms(typ, n, alg, datasettyp, this));
getExecutor().submit(() -> {
getEval().run();
@ -258,7 +310,6 @@ public class Presenter extends AbstractPresenter {
EvaluateAlgorithms evaluateAlgorithms = new EvaluateAlgorithms(typ, alg, file);
if (evaluateAlgorithms.getData().size() > 0) {
setEval(evaluateAlgorithms);
getEval().addObserver(this);
}
getExecutor().submit(() -> {

@ -1,4 +1,4 @@
package presenter.algorithms;
package de.wwwu.awolf.presenter.algorithms;
/**
* Implementierung verschiedener Algorithmen zur Berechnung von Ausgleichsgeraden.
@ -8,6 +8,17 @@ package presenter.algorithms;
* @Date: 28.05.2017.
*/
public interface Algorithm extends Runnable {
enum Type {
LMS,
RM,
TS,
NAIV_LMS,
NAIV_RM,
NAIV_TS
}
/**
* Startet die Berechnung des jeweiligen Algorithmus.
*/

@ -1,13 +1,19 @@
package presenter.algorithms.advanced;
import model.Interval;
import model.Line;
import model.Point;
import presenter.Presenter;
import presenter.algorithms.Algorithm;
import presenter.util.IntersectionCounter;
package de.wwwu.awolf.presenter.algorithms.advanced;
import de.wwwu.awolf.model.Interval;
import de.wwwu.awolf.model.Line;
import de.wwwu.awolf.model.Point;
import de.wwwu.awolf.model.communication.AlgorithmData;
import de.wwwu.awolf.model.communication.Data;
import de.wwwu.awolf.model.communication.SubscriberType;
import de.wwwu.awolf.presenter.Presenter;
import de.wwwu.awolf.presenter.algorithms.Algorithm;
import de.wwwu.awolf.presenter.util.IntersectionCounter;
import de.wwwu.awolf.presenter.util.Logging;
import java.security.SecureRandom;
import java.util.*;
import java.util.concurrent.Flow;
/**
* Implementierung verschiedener Algorithmen zur Berechnung von Ausgleichsgeraden.
@ -16,19 +22,16 @@ import java.util.*;
* @Email: a_wolf28@uni-muenster.de
* @Date: 28.05.2017.
*/
public class LeastMedianOfSquaresEstimator extends Observable implements Algorithm {
private Presenter presenter;
public class LeastMedianOfSquaresEstimator implements Algorithm, Flow.Publisher<Data> {
private LinkedList<Line> set = new LinkedList<>();
private ArrayList<Point> intersections = new ArrayList<>();
private List<Line> set;
private List<Point> intersections;
private IntersectionCounter invCounter = new IntersectionCounter();
private int n;
private double quantileError;
private int kPlus;
private int kMinus;
private PriorityQueue<Interval> intervals;
private Queue<Interval> intervals;
private Interval subSlabU1;
private Interval subSlabU2;
private Line sigmaMin;
@ -38,6 +41,7 @@ public class LeastMedianOfSquaresEstimator extends Observable implements Algorit
private double slope;
private double yInterception;
private Flow.Subscriber<? super AlgorithmData> subscriber;
/**
* Konstruktor
@ -46,7 +50,7 @@ public class LeastMedianOfSquaresEstimator extends Observable implements Algorit
* @param intersections Liste der Schnittpunkte
* @param presenter Presenter (Beobachter)
*/
public LeastMedianOfSquaresEstimator(LinkedList<Line> set, ArrayList<Point> intersections,
public LeastMedianOfSquaresEstimator(List<Line> set, List<Point> intersections,
Presenter presenter) {
this.set = set;
this.intersections = intersections;
@ -57,7 +61,7 @@ public class LeastMedianOfSquaresEstimator extends Observable implements Algorit
double qMinus = qPlus * (1 - quantileError);
kMinus = (int) Math.ceil(n * qMinus);
kPlus = (int) Math.ceil(n * qPlus);
this.presenter = presenter;
this.subscribe(presenter);
}
/**
@ -66,7 +70,7 @@ public class LeastMedianOfSquaresEstimator extends Observable implements Algorit
* @param set Liste der Geraden
* @param intersections Liste der Schnittpunkte
*/
public LeastMedianOfSquaresEstimator(LinkedList<Line> set, ArrayList<Point> intersections) {
public LeastMedianOfSquaresEstimator(List<Line> set, List<Point> intersections) {
this(set, intersections, null);
}
@ -80,7 +84,7 @@ public class LeastMedianOfSquaresEstimator extends Observable implements Algorit
*/
public void run() {
System.out.println("=== S T A R T - L M S ===");
Logging.logInfo("=== S T A R T - L M S ===");
long start;
long end;
start = System.currentTimeMillis();
@ -99,7 +103,7 @@ public class LeastMedianOfSquaresEstimator extends Observable implements Algorit
intervals = new PriorityQueue<>(comparator);
intervals.add(new Interval(-100000, 100000));
heightsigmaMin = Double.MAX_VALUE;
ArrayList<Point> tmpIntersections = intersections;
List<Point> tmpIntersections = intersections;
//(3.) Apply the following steps as long as the exists active intervals
boolean active = true;
@ -116,12 +120,12 @@ public class LeastMedianOfSquaresEstimator extends Observable implements Algorit
} else {
//(c.) otherwise....
// get random intersections point...
Collections.shuffle(tmpIntersections, new Random());
Collections.shuffle(tmpIntersections, new SecureRandom());
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();
for (Point tmpIntersection : tmpIntersections) {
if (tmpIntersection.getX() > interval.getLower()
&& tmpIntersection.getX() < interval.getUpper()) {
intersectionsPoint = tmpIntersection.getX();
found = true;
break;
}
@ -150,7 +154,7 @@ public class LeastMedianOfSquaresEstimator extends Observable implements Algorit
}
}
end = System.currentTimeMillis();
System.out.println("Zeit: " + ((end - start) / 1000));
Logging.logInfo("Zeit: " + ((end - start) / 1000));
pepareResult();
}
@ -178,7 +182,7 @@ public class LeastMedianOfSquaresEstimator extends Observable implements Algorit
public Line pseudoSweep(Interval interval) {
//initialisiere die x-Queue mit den 2D Punkten und sortiere nach x-Lexikographischer Ordnung
ArrayList<Point> xQueue = new ArrayList<>();
List<Point> xQueue = new ArrayList<>();
for (Point point : intersections) {
if (point.getX() >= interval.getLower() && point.getX() < interval.getUpper()) {
xQueue.add(point);
@ -227,7 +231,7 @@ public class LeastMedianOfSquaresEstimator extends Observable implements Algorit
double height = heightsigmaMin;
double tmpHeight;
ArrayList<Double> sortedLineSequence = getEjValues(point);
List<Double> sortedLineSequence = getEjValues(point);
int itnbr = ((n - kMinus) + 1);
for (int i = 0; i < itnbr; i++) {
@ -262,11 +266,11 @@ public class LeastMedianOfSquaresEstimator extends Observable implements Algorit
int strictlyGreater = 0;
//Teil I.
ArrayList<Double> umaxList;
ArrayList<Double> uminList;
List<Double> umaxList;
List<Double> uminList;
//y koordinaten der Schnittpunkte
ArrayList<Line> lines = new ArrayList<>();
List<Line> lines = new ArrayList<>();
for (Line p : set) {
lines.add(
new Line(pslab.getLower(), pslab.getUpper(), ((pslab.getLower() * p.getM()) + p.getB()),
@ -325,9 +329,9 @@ public class LeastMedianOfSquaresEstimator extends Observable implements Algorit
* @param u vertikale Gerade
* @return Liste der Schnittpunkte (da u bekannt werden nur die y Werte zurück gegeben)
*/
public ArrayList<Double> getEjValues(double u) {
public List<Double> getEjValues(double u) {
ArrayList<Double> ret = new ArrayList<>();
List<Double> ret = new ArrayList<>();
for (Line p : set) {
ret.add((p.getM() * u) + p.getB());
@ -349,15 +353,14 @@ public class LeastMedianOfSquaresEstimator extends Observable implements Algorit
public Double[] calcKMinusBracelet(Point px, int kMinusValue) {
//y Koordinaten für das kMinus brecalet
LinkedList<Double> intersections = new LinkedList<>();
List<Double> intersections = new LinkedList<>();
for (Line line : set) {
intersections.add((px.getX() * line.getM()) + line.getB());
}
if (intersections.size() >= kMinusValue) {
Collections.sort(intersections);
double height = Math.abs(intersections.get(0) - intersections.get(0 + kMinusValue - 1));
Double[] ret = {height, intersections.get(0), intersections.get(0 + kMinusValue - 1)};
return ret;
double height = Math.abs(intersections.get(0) - intersections.get(kMinusValue - 1));
return new Double[]{height, intersections.get(0), intersections.get(kMinusValue - 1)};
} else {
return null;
}
@ -366,16 +369,17 @@ public class LeastMedianOfSquaresEstimator extends Observable implements Algorit
@Override
public void pepareResult() {
if (presenter != null) {
setChanged();
if (this.subscriber != null) {
double m = (getSigmaMin().getX2() + getSigmaMin().getX1()) * 0.5;
double b = (getSigmaMin().getY2() + getSigmaMin().getY1()) * -0.5;
slope = m;
yInterception = b;
String[] result = {"lms", m + "", b + ""};
notifyObservers(result);
AlgorithmData data = new AlgorithmData();
data.setType(SubscriberType.LMS);
data.setLineData(new Line(m, b));
this.subscriber.onNext(data);
} else {
double m = (getSigmaMin().getX2() + getSigmaMin().getX1()) * 0.5;
double b = (getSigmaMin().getY2() + getSigmaMin().getY1()) * -0.5;
@ -454,4 +458,9 @@ public class LeastMedianOfSquaresEstimator extends Observable implements Algorit
public Double getyInterception() {
return yInterception;
}
@Override
public void subscribe(Flow.Subscriber<? super Data> subscriber) {
this.subscriber = subscriber;
}
}

@ -1,17 +1,22 @@
package presenter.algorithms.advanced;
import model.Interval;
import model.Line;
import presenter.Presenter;
import presenter.algorithms.Algorithm;
import presenter.util.FastElementSelector;
import presenter.util.IntersectionCounter;
import presenter.util.RandomSampler;
package de.wwwu.awolf.presenter.algorithms.advanced;
import de.wwwu.awolf.model.Interval;
import de.wwwu.awolf.model.Line;
import de.wwwu.awolf.model.communication.AlgorithmData;
import de.wwwu.awolf.model.communication.Data;
import de.wwwu.awolf.model.communication.SubscriberType;
import de.wwwu.awolf.presenter.Presenter;
import de.wwwu.awolf.presenter.algorithms.Algorithm;
import de.wwwu.awolf.presenter.util.FastElementSelector;
import de.wwwu.awolf.presenter.util.IntersectionCounter;
import de.wwwu.awolf.presenter.util.Logging;
import de.wwwu.awolf.presenter.util.RandomSampler;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.LinkedList;
import java.util.Observable;
import java.util.List;
import java.util.Map;
import java.util.concurrent.Flow;
/**
@ -21,24 +26,23 @@ import java.util.Observable;
* @Email: a_wolf28@uni-muenster.de
* @Date: 28.05.2017.
*/
public class RepeatedMedianEstimator extends Observable implements Algorithm {
public class RepeatedMedianEstimator implements Algorithm, Flow.Publisher<Data> {
private Presenter presenter;
private LinkedList<Line> set;
private HashMap<Line, ArrayList<Line>> linePairs;
private HashMap<Line, Double> medianIntersections = new HashMap<>();
private HashMap<Line, ArrayList<Double>> intersectionAbscissas = new HashMap<>();
private List<Line> set;
private Map<Line, Double> medianIntersections = new HashMap<>();
private Map<Line, ArrayList<Double>> intersectionAbscissas = new HashMap<>();
private Interval interval;
//in der Literatur als L_i, C_i, und R_i bekannt
private ArrayList<Double> countLeftSlab;
private ArrayList<Double> countCenterSlab;
private ArrayList<Double> countRightSlab;
private List<Double> countLeftSlab;
private List<Double> countCenterSlab;
private List<Double> countRightSlab;
//die Mengen L,C und R
private ArrayList<Line> linesInLeftSlab;
private ArrayList<Line> linesInCenterSlab;
private ArrayList<Line> linesInRightSlab;
private List<Line> linesInLeftSlab;
private List<Line> linesInCenterSlab;
private List<Line> linesInRightSlab;
private double r;
private int n;
@ -52,6 +56,7 @@ public class RepeatedMedianEstimator extends Observable implements Algorithm {
private double slope;
private double yInterception;
private Flow.Subscriber<? super AlgorithmData> subscriber;
/**
* Konstruktor
@ -59,7 +64,7 @@ public class RepeatedMedianEstimator extends Observable implements Algorithm {
* @param set Liste der Geraden
* @param presenter Presenter (Beobachter)
*/
public RepeatedMedianEstimator(LinkedList<Line> set, Presenter presenter) {
public RepeatedMedianEstimator(List<Line> set, Presenter presenter) {
this.set = set;
this.presenter = presenter;
interval = new Interval(-10000, 10000);
@ -79,7 +84,7 @@ public class RepeatedMedianEstimator extends Observable implements Algorithm {
linesInLeftSlab = new ArrayList<>();
linesInCenterSlab = new ArrayList<>(set);
linesInRightSlab = new ArrayList<>();
linePairs = new HashMap<>();
subscribe(presenter);
}
/**
@ -87,7 +92,7 @@ public class RepeatedMedianEstimator extends Observable implements Algorithm {
*
* @param set Liste der Geraden
*/
public RepeatedMedianEstimator(LinkedList<Line> set) {
public RepeatedMedianEstimator(List<Line> set) {
this(set, null);
}
@ -101,7 +106,7 @@ public class RepeatedMedianEstimator extends Observable implements Algorithm {
*/
public void run() {
System.out.println("=== S T A R T - R M ===");
Logging.logInfo("=== S T A R T - R M ===");
long start;
long end;
start = System.currentTimeMillis();
@ -109,11 +114,11 @@ public class RepeatedMedianEstimator extends Observable implements Algorithm {
while (linesInCenterSlab.size() != 1) {
n = linesInCenterSlab.size();
r = Math.ceil(Math.pow(n, beta));
ArrayList<Line> lines = RandomSampler.run(linesInCenterSlab, r, linesInCenterSlab.size());
List<Line> lines = RandomSampler.run(linesInCenterSlab, r, linesInCenterSlab.size());
//Für jede Gerade aus der Stichprobe wird der Schnittpunkt mit der medianen
//x-Koordinate bestimmt
ArrayList<Double> medianIntersectionAbscissas = new ArrayList<>();
List<Double> medianIntersectionAbscissas = new ArrayList<>();
for (Line l : lines) {
Double abscissa = estimateMedianIntersectionAbscissas(l);
medianIntersections.put(l, abscissa);
@ -138,7 +143,7 @@ public class RepeatedMedianEstimator extends Observable implements Algorithm {
}
end = System.currentTimeMillis();
System.out.println("Zeit: " + ((end - start) / 1000));
Logging.logInfo("Zeit: " + ((end - start) / 1000));
pepareResult();
}
@ -152,11 +157,11 @@ public class RepeatedMedianEstimator extends Observable implements Algorithm {
*/
public Double estimateMedianIntersectionAbscissas(Line sampledLine) {
Integer index = Integer.parseInt(sampledLine.getId());
int index = Integer.parseInt(sampledLine.getId());
IntersectionCounter intersectionCounter = new IntersectionCounter();
ArrayList<Double> intersections = intersectionCounter.calculateIntersectionAbscissas(linesInCenterSlab, sampledLine);
List<Double> intersections = intersectionCounter.calculateIntersectionAbscissas(linesInCenterSlab, sampledLine);
double ki = Math.ceil((n - 1) / 2) - FastElementSelector.randomizedSelect(countLeftSlab, index);
double ki = Math.ceil((n - 1) * 0.5) - FastElementSelector.randomizedSelect(countLeftSlab, index);
double i = (Math.ceil((Math.sqrt(n) * ki) / FastElementSelector.randomizedSelect(countCenterSlab, index)));
int accessIndex;
if (i < 0)
@ -174,9 +179,9 @@ public class RepeatedMedianEstimator extends Observable implements Algorithm {
*/
public void computeSlabBorders() {
kLow = Math.max(1, Math.floor(((r * k) / (linesInCenterSlab.size()))
- ((3 * Math.sqrt(r)) / (2))));
- ((3 * Math.sqrt(r)) * (0.5))));
kHigh = Math.min(r, Math.floor(((r * k) / (linesInCenterSlab.size()))
+ ((3 * Math.sqrt(r)) / (2))));
+ ((3 * Math.sqrt(r)) * (0.5))));
}
@ -186,8 +191,8 @@ public class RepeatedMedianEstimator extends Observable implements Algorithm {
*/
public void countNumberOfIntersectionsAbscissas() {
for (Line line : linesInCenterSlab) {
ArrayList<Double> intersections = intersectionAbscissas.get(line);
Integer index = Integer.parseInt(line.getId());
List<Double> intersections = intersectionAbscissas.get(line);
int index = Integer.parseInt(line.getId());
int left = 0;
int center = 0;
int right = 0;
@ -210,6 +215,7 @@ public class RepeatedMedianEstimator extends Observable implements Algorithm {
}
/**
* TODO bad idea!!!
* Verkleinert das aktuelle Intervall. Eines der drei Bereiche wird als neues Intervall gewählt.
* Auf diesem Intervall werden dann in der nächsten Iteration wieder drei Bereiche bestimmt.
*/
@ -232,24 +238,23 @@ public class RepeatedMedianEstimator extends Observable implements Algorithm {
}
//wähle C als C
if (linesInLeftSlab.size() < Math.ceil(n / 2) && Math.ceil(n / 2) <= linesInLeftSlab.size() + linesInCenterSlab.size()) {
if (linesInLeftSlab.size() < Math.ceil(n * 0.5) && Math.ceil(n * 0.5) <= linesInLeftSlab.size() + linesInCenterSlab.size()) {
interval.setLower(thetaLow + 0.1);
interval.setUpper(thetaHigh);
}
// wähle L als C
else if (Math.ceil(n / 2) <= linesInLeftSlab.size()) {
else if (Math.ceil(n * 0.5) <= linesInLeftSlab.size()) {
interval.setUpper(thetaLow);
}
//wähle R als C
else if (linesInLeftSlab.size() + linesInCenterSlab.size() < Math.ceil(n / 2) && Math.ceil(n / 2) <= (linesInLeftSlab.size() + linesInCenterSlab.size() + linesInRightSlab.size())) {
else if (linesInLeftSlab.size() + linesInCenterSlab.size() < Math.ceil(n * 0.5) && Math.ceil(n * 0.5) <= (linesInLeftSlab.size() + linesInCenterSlab.size() + linesInRightSlab.size())) {
interval.setLower(thetaHigh - 0.1);
}
}
@Override
public void pepareResult() {
if (presenter != null) {
setChanged();
if (this.subscriber != null) {
double m = thetaLow;
double b = (-1) * (
(linesInCenterSlab.get(0).getM() * (thetaLow)) + linesInCenterSlab.get(0)
@ -257,8 +262,10 @@ public class RepeatedMedianEstimator extends Observable implements Algorithm {
slope = m;
yInterception = b;
String[] result = new String[]{"rm", m + "", b + ""};
notifyObservers(result);
AlgorithmData data = new AlgorithmData();
data.setType(SubscriberType.RM);
data.setLineData(new Line(m, b));
this.subscriber.onNext(data);
} else {
double m = thetaLow;
double b = (-1) * ((linesInCenterSlab.get(0).getM() * (thetaLow)) + linesInCenterSlab.get(0).getB());
@ -267,9 +274,6 @@ public class RepeatedMedianEstimator extends Observable implements Algorithm {
}
}
/*******************************************************************************************************************
* Getter und Setter Methoden
******************************************************************************************************************/
/**
* @return Anzahl der Geraden
*/
@ -336,23 +340,28 @@ public class RepeatedMedianEstimator extends Observable implements Algorithm {
/**
* @return verteilung der Punkte
*/
public ArrayList<Double> getCountLeftSlab() {
public List<Double> getCountLeftSlab() {
return countLeftSlab;
}
/**
* @return verteilung der Punkte
*/
public ArrayList<Double> getCountCenterSlab() {
public List<Double> getCountCenterSlab() {
return countCenterSlab;
}
/**
* @return verteilung der Punkte
*/
public ArrayList<Double> getCountRightSlab() {
public List<Double> getCountRightSlab() {
return countRightSlab;
}
@Override
public void subscribe(Flow.Subscriber<? super Data> subscriber) {
this.subscriber = subscriber;
}
}

@ -1,16 +1,23 @@
package presenter.algorithms.advanced;
import model.Interval;
import model.Line;
import model.Point;
import presenter.Presenter;
import presenter.algorithms.Algorithm;
import presenter.util.BinomialCoeffizient;
import presenter.util.FastElementSelector;
import presenter.util.IntersectionCounter;
import presenter.util.RandomSampler;
import java.util.*;
package de.wwwu.awolf.presenter.algorithms.advanced;
import de.wwwu.awolf.model.Interval;
import de.wwwu.awolf.model.Line;
import de.wwwu.awolf.model.Point;
import de.wwwu.awolf.model.communication.AlgorithmData;
import de.wwwu.awolf.model.communication.Data;
import de.wwwu.awolf.model.communication.SubscriberType;
import de.wwwu.awolf.presenter.Presenter;
import de.wwwu.awolf.presenter.algorithms.Algorithm;
import de.wwwu.awolf.presenter.util.BinomialCoeffizient;
import de.wwwu.awolf.presenter.util.FastElementSelector;
import de.wwwu.awolf.presenter.util.IntersectionCounter;
import de.wwwu.awolf.presenter.util.RandomSampler;
import java.util.ArrayList;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Set;
import java.util.concurrent.Flow;
/**
* Implementierung verschiedener Algorithmen zur Berechnung von Ausgleichsgeraden.
@ -19,19 +26,18 @@ import java.util.*;
* @Email: a_wolf28@uni-muenster.de
* @Date: 28.05.2017.
*/
public class TheilSenEstimator extends Observable implements Algorithm {
public class TheilSenEstimator implements Algorithm, Flow.Publisher<Data> {
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;
private ArrayList<Point> intervalIntersections;
private ArrayList<Double> sampledIntersections;
private List<Line> setOfLines;
private List<Point> setOfIntersections;
private List<Point> intervalIntersections;
private List<Double> sampledIntersections;
//wird benötigt um den y Achsenabschnitt zu Berechnen
private ArrayList<Double> yCoordinates;
private ArrayList<Double> xCoordinates;
private List<Double> yCoordinates;
private List<Double> xCoordinates;
//Hilfsvariablen (siehe original Paper)
private double j;
private int jA;
@ -46,6 +52,7 @@ public class TheilSenEstimator extends Observable implements Algorithm {
private double bVariant;
private double slope;
private double yInterception;
private Flow.Subscriber<? super AlgorithmData> subscriber;
/**
* Konstruktor
@ -54,8 +61,8 @@ public class TheilSenEstimator extends Observable implements Algorithm {
* @param setOfIntersections Liste der Schnittpunkte
* @param presenter Presenter (Beobachter)
*/
public TheilSenEstimator(LinkedList<Line> setOfLines, ArrayList<Point> setOfIntersections, Presenter presenter) {
this.presenter = presenter;
public TheilSenEstimator(List<Line> setOfLines, List<Point> setOfIntersections, Presenter presenter) {
this.setOfLines = new ArrayList<>(setOfLines);
this.setOfIntersections = new ArrayList<>(setOfIntersections);
this.intervalIntersections = new ArrayList<>(setOfIntersections);
@ -69,6 +76,7 @@ public class TheilSenEstimator extends Observable implements Algorithm {
this.k = (int) (N / 2);
interval = new Interval(NEGATIV_INF, POSITIV_INF);
subscribe(presenter);
}
/**
@ -77,7 +85,7 @@ public class TheilSenEstimator extends Observable implements Algorithm {
* @param setOfLines Liste der Geraden
* @param setOfIntersections Liste der Schnittpunkte
*/
public TheilSenEstimator(LinkedList<Line> setOfLines, ArrayList<Point> setOfIntersections) {
public TheilSenEstimator(List<Line> setOfLines, List<Point> setOfIntersections) {
this(setOfLines, setOfIntersections, null);
}
@ -175,7 +183,7 @@ public class TheilSenEstimator extends Observable implements Algorithm {
* @param b obere Grenze des Intrvals
* @return Anzahl der Schnittpunkte im Interval (a,b)
*/
public int getOpenIntervalSize(double a, double b, ArrayList<Point> set) {
public int getOpenIntervalSize(double a, double b, List<Point> set) {
int counter = 0;
for (int i = 0; i < set.size(); i++) {
Point x = set.get(i);
@ -195,8 +203,8 @@ public class TheilSenEstimator extends Observable implements Algorithm {
* @param b obere Grenze des Intrvals
* @return Liste der Schnittpunkte die im Interval (a,b) vertreten sind
*/
public ArrayList<Point> getOpenIntervalElements(double a, double b) {
ArrayList<Point> list = new ArrayList<>();
public List<Point> getOpenIntervalElements(double a, double b) {
List<Point> list = new ArrayList<>();
for (int i = 0; i < intervalIntersections.size(); i++) {
Point x = intervalIntersections.get(i);
if ((x.getX() > a && x.getX() < b) || (Math.abs(interval.getUpper() - interval.getLower())) < EPSILON) {
@ -213,8 +221,8 @@ public class TheilSenEstimator extends Observable implements Algorithm {
double m, x;
double b, y;
ArrayList<Point> resultSt = getOpenIntervalElements(interval.getLower(), interval.getUpper());
ArrayList<Double> resultAbscissas = new ArrayList<>();
List<Point> resultSt = getOpenIntervalElements(interval.getLower(), interval.getUpper());
List<Double> resultAbscissas = new ArrayList<>();
for (Point p : resultSt) {
resultAbscissas.add(p.getX());
@ -224,7 +232,7 @@ public class TheilSenEstimator extends Observable implements Algorithm {
yCoordinates.add(p.getY());
}
int pseudoIndex = getOpenIntervalSize(NEGATIV_INF, interval.getLower(), setOfIntersections);
double pseudoIndex = getOpenIntervalSize(NEGATIV_INF, interval.getLower(), setOfIntersections) * 1.0;
m = FastElementSelector.randomizedSelect(resultAbscissas, k - pseudoIndex);
Set<Double> unique = new LinkedHashSet<>(yCoordinates);
@ -234,11 +242,11 @@ public class TheilSenEstimator extends Observable implements Algorithm {
slope = m;
yInterception = b;
if (presenter != null) {
setChanged();
String[] result = new String[]{"ts", m + "", b + ""};
notifyObservers(result);
if (this.subscriber != null) {
AlgorithmData data = new AlgorithmData();
data.setType(SubscriberType.TS);
data.setLineData(new Line(m, b));
this.subscriber.onNext(data);
}
}
@ -255,4 +263,9 @@ public class TheilSenEstimator extends Observable implements Algorithm {
public Double getyInterception() {
return yInterception;
}
@Override
public void subscribe(Flow.Subscriber<? super Data> subscriber) {
this.subscriber = subscriber;
}
}

@ -1,13 +1,14 @@
package presenter.algorithms.naiv;
package de.wwwu.awolf.presenter.algorithms.naiv;
import model.Line;
import model.Point;
import presenter.algorithms.Algorithm;
import presenter.util.FastElementSelector;
import de.wwwu.awolf.model.Line;
import de.wwwu.awolf.model.Point;
import de.wwwu.awolf.presenter.algorithms.Algorithm;
import de.wwwu.awolf.presenter.util.FastElementSelector;
import de.wwwu.awolf.presenter.util.Logging;
import java.util.ArrayList;
import java.util.Collections;
import java.util.LinkedList;
import java.util.List;
/**
* Implementierung verschiedener Algorithmen zur Berechnung von Ausgleichsgeraden.
@ -17,7 +18,7 @@ import java.util.LinkedList;
* @Date: 15.09.2017.
*/
public class NaivLeastMedianOfSquaresEstimator implements Algorithm {
private ArrayList<Point> set = new ArrayList<>();
private List<Point> set = new ArrayList<>();
private int n;
private double ds, b, m;
@ -27,7 +28,7 @@ public class NaivLeastMedianOfSquaresEstimator implements Algorithm {
*
* @param lines Liste des Geraden
*/
public NaivLeastMedianOfSquaresEstimator(LinkedList<Line> lines) {
public NaivLeastMedianOfSquaresEstimator(List<Line> lines) {
for (Line l : lines) {
set.add(new Point(l.getM(), l.getB()));
}
@ -40,11 +41,11 @@ public class NaivLeastMedianOfSquaresEstimator implements Algorithm {
ds = Double.MAX_VALUE;
b = 0d;
m = 0d;
ArrayList<Point> triple = new ArrayList<>();
List<Point> triple = new ArrayList<>();
double beta;
double alpha;
double dijk;
System.out.println("=== S T A R T - naiv L M S ===");
Logging.logInfo("=== S T A R T - naiv L M S ===");
long start;
long end;
start = System.currentTimeMillis();
@ -56,7 +57,7 @@ public class NaivLeastMedianOfSquaresEstimator implements Algorithm {
triple.add(k);
Collections.sort(triple);
beta = (triple.get(0).getY() - triple.get(2).getY()) / (triple.get(0).getX() - triple.get(2).getX());
alpha = (triple.get(1).getY() + triple.get(2).getY() - (beta * (triple.get(1).getX() + triple.get(2).getX()))) / 2f;
alpha = (triple.get(1).getY() + triple.get(2).getY() - (beta * (triple.get(1).getX() + triple.get(2).getX()))) * 0.5;
dijk = f(alpha, beta);
if (dijk < ds) {
ds = dijk;
@ -68,7 +69,7 @@ public class NaivLeastMedianOfSquaresEstimator implements Algorithm {
}
}
end = System.currentTimeMillis();
System.out.println("Zeit: " + ((end - start) / 1000));
Logging.logInfo("Zeit: " + ((end - start) / 1000));
}
/**
@ -79,11 +80,11 @@ public class NaivLeastMedianOfSquaresEstimator implements Algorithm {
* @return medianer Fehler
*/
private Double f(double a, double b) {
ArrayList<Double> res = new ArrayList<>();
List<Double> res = new ArrayList<>();
for (Point p : set) {
res.add(Math.abs(p.getY() - (a + b * p.getX())));
}
return FastElementSelector.randomizedSelect(res, res.size() / 2);
return FastElementSelector.randomizedSelect(res, res.size() * 0.5);
}
@Override

@ -1,13 +1,15 @@
package presenter.algorithms.naiv;
package de.wwwu.awolf.presenter.algorithms.naiv;
import model.Line;
import model.Point;
import presenter.algorithms.Algorithm;
import presenter.util.FastElementSelector;
import de.wwwu.awolf.model.Line;
import de.wwwu.awolf.model.Point;
import de.wwwu.awolf.presenter.algorithms.Algorithm;
import de.wwwu.awolf.presenter.util.FastElementSelector;
import de.wwwu.awolf.presenter.util.Logging;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
/**
* Implementierung verschiedener Algorithmen zur Berechnung von Ausgleichsgeraden.
@ -18,10 +20,11 @@ import java.util.LinkedList;
*/
public class NaivRepeatedMedianEstimator implements Algorithm {
private LinkedList<Line> lines;
private HashMap<String, ArrayList<Double>> slopesPerLine;
private HashMap<String, ArrayList<Double>> interceptPerLine;
private ArrayList<Double> xMedians, yMedians;
private List<Line> lines;
private Map<String, List<Double>> slopesPerLine;
private Map<String, List<Double>> interceptPerLine;
private List<Double> xMedians;
private List<Double> yMedians;
private double medianX;
private double medianY;
@ -30,7 +33,7 @@ public class NaivRepeatedMedianEstimator implements Algorithm {
*
* @param lines Liste der Geraden
*/
public NaivRepeatedMedianEstimator(LinkedList<Line> lines) {
public NaivRepeatedMedianEstimator(List<Line> lines) {
this.lines = lines;
slopesPerLine = new HashMap<>();
interceptPerLine = new HashMap<>();
@ -41,18 +44,13 @@ public class NaivRepeatedMedianEstimator implements Algorithm {
@Override
public void run() {
//init the List for the slopes
System.out.println("=== S T A R T - naiv R M ===");
Logging.logInfo("=== S T A R T - naiv R M ===");
long start;
long end;
start = System.currentTimeMillis();
for (int j = 0; j < lines.size(); j++) {
Line leq = lines.get(j);
if (slopesPerLine.get(leq.getId()) == null) {
slopesPerLine.put(leq.getId(), new ArrayList<>());
}
if (interceptPerLine.get(leq.getId()) == null) {
interceptPerLine.put(leq.getId(), new ArrayList<>());
}
for (Line leq : lines) {
slopesPerLine.computeIfAbsent(leq.getId(), k -> new ArrayList<>());
interceptPerLine.computeIfAbsent(leq.getId(), k -> new ArrayList<>());
}
//calculate all slopes for each line
@ -67,7 +65,7 @@ public class NaivRepeatedMedianEstimator implements Algorithm {
//berechne mediane Steigung
for (String l : slopesPerLine.keySet()) {
ArrayList<Double> list = slopesPerLine.get(l);
List<Double> list = slopesPerLine.get(l);
int size = list.size() / 2;
if (size > 0) {
double medianX = FastElementSelector.randomizedSelect(list, size);
@ -77,7 +75,7 @@ public class NaivRepeatedMedianEstimator implements Algorithm {
//berechne medianen y-Achsenabschnitt
for (String l : interceptPerLine.keySet()) {
ArrayList<Double> list = interceptPerLine.get(l);
List<Double> list = interceptPerLine.get(l);
int size = list.size() / 2;
if (size > 0) {
double medianY = FastElementSelector.randomizedSelect(list, size);
@ -85,10 +83,10 @@ public class NaivRepeatedMedianEstimator implements Algorithm {
}
}
medianX = FastElementSelector.randomizedSelect(xMedians, xMedians.size() / 2);
medianY = FastElementSelector.randomizedSelect(yMedians, yMedians.size() / 2);
medianX = FastElementSelector.randomizedSelect(xMedians, xMedians.size() * 0.5);
medianY = FastElementSelector.randomizedSelect(yMedians, yMedians.size() * 0.5);
end = System.currentTimeMillis();
System.out.println("Zeit: " + ((end - start) / 1000));
Logging.logInfo("Zeit: " + ((end - start) / 1000));
}
@Override

@ -1,11 +1,12 @@
package presenter.algorithms.naiv;
package de.wwwu.awolf.presenter.algorithms.naiv;
import model.Line;
import presenter.algorithms.Algorithm;
import presenter.util.FastElementSelector;
import de.wwwu.awolf.model.Line;
import de.wwwu.awolf.presenter.algorithms.Algorithm;
import de.wwwu.awolf.presenter.util.FastElementSelector;
import de.wwwu.awolf.presenter.util.Logging;
import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;
/**
* Implementierung verschiedener Algorithmen zur Berechnung von Ausgleichsgeraden.
@ -17,7 +18,7 @@ import java.util.LinkedList;
public class NaivTheilSenEstimator implements Algorithm {
private LinkedList<Line> lines;
private List<Line> lines;
private double slope;
private double yInterception;
@ -26,7 +27,7 @@ public class NaivTheilSenEstimator implements Algorithm {
*
* @param lines Liste der Geraden
*/
public NaivTheilSenEstimator(LinkedList<Line> lines) {
public NaivTheilSenEstimator(List<Line> lines) {
this.lines = lines;
this.slope = 0d;
this.yInterception = 0d;
@ -35,11 +36,11 @@ public class NaivTheilSenEstimator implements Algorithm {
@Override
public void run() {
System.out.println("=== S T A R T - naiv T S ===");
Logging.logInfo("=== S T A R T - naiv T S ===");
long start;
long end;
start = System.currentTimeMillis();
ArrayList<Double> slopesList = new ArrayList<>();
List<Double> slopesList = new ArrayList<>();
int cnt = 0;
for (int i = 0; i < lines.size(); i++) {
double x = lines.get(i).getM();
@ -55,18 +56,18 @@ public class NaivTheilSenEstimator implements Algorithm {
}
ArrayList<Double> list1 = new ArrayList<>();
ArrayList<Double> list2 = new ArrayList<>();
for (int i = 0; i < lines.size(); i++) {
list1.add(lines.get(i).getM());
list2.add(lines.get(i).getB());
List<Double> list1 = new ArrayList<>();
List<Double> list2 = new ArrayList<>();
for (Line line : lines) {
list1.add(line.getM());
list2.add(line.getB());
}
double median1 = FastElementSelector.randomizedSelect(list1, list1.size() / 2);
double median2 = FastElementSelector.randomizedSelect(list2, list2.size() / 2);
slope = FastElementSelector.randomizedSelect(slopesList, slopesList.size() / 2);
double median1 = FastElementSelector.randomizedSelect(list1, list1.size() * 0.5);
double median2 = FastElementSelector.randomizedSelect(list2, list2.size() * 0.5);
slope = FastElementSelector.randomizedSelect(slopesList, slopesList.size() * 0.5);
yInterception = median2 - slope * median1;
end = System.currentTimeMillis();
System.out.println("Zeit: " + ((end - start) / 1000));
Logging.logInfo("Zeit: " + ((end - start) / 1000));
}
@Override

@ -1,22 +1,29 @@
package presenter.evaluation;
import model.Line;
import model.LineModel;
import model.Point;
import presenter.algorithms.advanced.LeastMedianOfSquaresEstimator;
import presenter.algorithms.advanced.RepeatedMedianEstimator;
import presenter.algorithms.advanced.TheilSenEstimator;
import presenter.algorithms.naiv.NaivLeastMedianOfSquaresEstimator;
import presenter.algorithms.naiv.NaivRepeatedMedianEstimator;
import presenter.algorithms.naiv.NaivTheilSenEstimator;
import presenter.generator.DatasetGenerator;
import presenter.io.DataImporter;
import presenter.util.IntersectionComputer;
package de.wwwu.awolf.presenter.evaluation;
import de.wwwu.awolf.model.Line;
import de.wwwu.awolf.model.LineModel;
import de.wwwu.awolf.model.Point;
import de.wwwu.awolf.model.communication.Data;
import de.wwwu.awolf.model.communication.EvaluationData;
import de.wwwu.awolf.model.communication.SubscriberType;
import de.wwwu.awolf.presenter.Presenter;
import de.wwwu.awolf.presenter.algorithms.Algorithm;
import de.wwwu.awolf.presenter.algorithms.advanced.LeastMedianOfSquaresEstimator;
import de.wwwu.awolf.presenter.algorithms.advanced.RepeatedMedianEstimator;
import de.wwwu.awolf.presenter.algorithms.advanced.TheilSenEstimator;
import de.wwwu.awolf.presenter.algorithms.naiv.NaivLeastMedianOfSquaresEstimator;
import de.wwwu.awolf.presenter.algorithms.naiv.NaivRepeatedMedianEstimator;
import de.wwwu.awolf.presenter.algorithms.naiv.NaivTheilSenEstimator;
import de.wwwu.awolf.presenter.generator.DatasetGenerator;
import de.wwwu.awolf.presenter.io.DataImporter;
import de.wwwu.awolf.presenter.util.IntersectionComputer;
import de.wwwu.awolf.presenter.util.Logging;
import java.io.File;
import java.util.ArrayList;
import java.util.LinkedList;
import java.util.Observable;
import java.util.*;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Flow;
/**
* Implementierung verschiedener Algorithmen zur Berechnung von Ausgleichsgeraden.
@ -25,25 +32,21 @@ import java.util.Observable;
* @Email: a_wolf28@uni-muenster.de
* @Date: 01.08.2017.
*/
public class EvaluateAlgorithms extends Observable {
public class EvaluateAlgorithms implements Flow.Publisher<Data> {
private LineModel arrangement;
private LinkedList<Line> lmsL;
private LinkedList<Line> rmL;
private LinkedList<Line> tsL;
private List<Line> lmsL;
private List<Line> rmL;
private List<Line> tsL;
private ArrayList<Point> lmsP;
private ArrayList<Point> tsP;
private List<Point> lmsP;
private List<Point> tsP;
private Thread lmsThread;
private Thread rmThread;
private Thread tsThread;
private Double[] tsRes = new Double[2];
private Double[] rmRes = new Double[2];
private Double[] lmsRes = new Double[2];
private DatasetGenerator generator;
private String[][] names = {{"MSE", "RMSE", "MAE", "MDAE", "Steigung", "y-Achsenabschnitt", "S-MSE", "S-RMSE", "S-MAE", "S-MDAE", "Brute-force Steigung", "Brute-force y-Achsenabschnitt"}, {"MAPE", "MDAPE", "RMSPE", "RMDSPE", "Steigung", "y-Achsenabschnitt"}};
@ -52,6 +55,7 @@ public class EvaluateAlgorithms extends Observable {
private int type;
private int iterations;
private int alg;
private Flow.Subscriber<? super Data> subscriber;
/**
* Konstruktor zur evaluation
@ -67,9 +71,10 @@ public class EvaluateAlgorithms extends Observable {
* 6 = lms, rm, ts,
* @param datasettyp typ der zu generierenden Datensatz
*/
public EvaluateAlgorithms(int type, int n, int alg, String datasettyp) {
public EvaluateAlgorithms(int type, int n, int alg, String datasettyp, Presenter presenter) {
subscribe(presenter);
this.arrangement = new LineModel();
generator = new DatasetGenerator();
generator = new DatasetGenerator(presenter);
switch (datasettyp) {
case "Punktwolke":
arrangement.setLines(generator.generateDataCloud(n));
@ -85,10 +90,6 @@ public class EvaluateAlgorithms extends Observable {
this.iterations = n;
this.alg = alg;
//IntersectionCounter counter = new IntersectionCounter();
//counter.run(arrangement.getLines(), new Interval(-99999, 99999));
//counter.calculateIntersectionAbscissas(arrangement);
IntersectionComputer computer = new IntersectionComputer(arrangement.getLines());
arrangement.setNodes(computer.compute());
@ -116,19 +117,15 @@ public class EvaluateAlgorithms extends Observable {
public EvaluateAlgorithms(int type, int alg, File file) {
this.arrangement = new LineModel();
DataImporter importer = new DataImporter(file);
DataImporter importer = new DataImporter(file, this.subscriber);
LinkedList<Line> importedLines = importer.run();
List<Line> importedLines = importer.run();
if (importedLines != null)
arrangement.setLines(importedLines);
this.type = type;
this.alg = alg;
//IntersectionCounter counter = new IntersectionCounter();
//counter.run(arrangement.getLines(), new Interval(-99999, 99999));
//counter.calculateIntersectionAbscissas(arrangement);
IntersectionComputer computer = new IntersectionComputer(arrangement.getLines());
arrangement.setNodes(computer.compute());
@ -147,36 +144,36 @@ public class EvaluateAlgorithms extends Observable {
* @throws InterruptedException
*/
public void run() {
setChanged();
String[] msg = {"eval-dataset-generated"};
notifyObservers(msg);
ArrayList<String> result;
ArrayList<ArrayList<String>> multipleResults = new ArrayList<>();
List<String> result;
List<List<String>> multipleResults = new ArrayList<>();
ExecutorService executorService = Executors.newCachedThreadPool();
switch (type) {
case 0:
//der alg der gewählt wurde
if (alg == 0) {
final double[] m = new double[1];
final double[] b = new double[1];
Thread t = new Thread(() -> {
final Line naivEstimator = new Line(0,0);
final Line advancedEstimator = new Line(0,0);
executorService.submit(() -> {
NaivLeastMedianOfSquaresEstimator l = new NaivLeastMedianOfSquaresEstimator(arrangement.getLines());
l.run();
m[0] = l.getM();
b[0] = l.getB();
naivEstimator.setM(l.getM());
naivEstimator.setB(l.getB());
});
executorService.submit(() -> {
LeastMedianOfSquaresEstimator lmsAlg = new LeastMedianOfSquaresEstimator(lmsL, lmsP);
lmsAlg.run();
lmsAlg.pepareResult();
advancedEstimator.setM(lmsAlg.getSlope());
advancedEstimator.setB(lmsAlg.getyInterception());
});
t.start();
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]));
Double[] tmp = {lmsRes[0], lmsRes[1], m[0], b[0]};
sendPlotLineResults(tmp, 0);
result = getScaleDependentMeasure(arrangement.getLines(), advancedEstimator.getM(), advancedEstimator.getB());
result.addAll(getScaledErrorBasedMeasure(arrangement.getLines(), advancedEstimator.getM(), advancedEstimator.getB(), naivEstimator.getM(), naivEstimator.getB()));
Double[] tmp = {advancedEstimator.getM(), advancedEstimator.getB(), naivEstimator.getM(), naivEstimator.getB()};
sendPlotLineResults(Arrays.asList(tmp), Algorithm.Type.LMS);
} else if (alg == 1) {
final double[] m = new double[1];
final double[] b = new double[1];
@ -190,12 +187,13 @@ public class EvaluateAlgorithms extends Observable {
try {
startRM();
} catch (InterruptedException e) {
e.printStackTrace();
Logging.logError(e.getMessage(), e);
Thread.currentThread().interrupt();
}
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]};
sendPlotLineResults(tmp, 1);
result = getScaleDependentMeasure(arrangement.getLines(), Double.valueOf(rmRes[0]), Double.valueOf(rmRes[1]));
result.addAll(getScaledErrorBasedMeasure(arrangement.getLines(), Double.valueOf(rmRes[0]), Double.valueOf(rmRes[1]), m[0], b[0]));
Double[] tmp = {Double.valueOf(rmRes[0]), Double.valueOf(rmRes[1]), m[0], b[0]};
sendPlotLineResults(Arrays.asList(tmp), Algorithm.Type.NAIV_RM);
} else {
final double[] m = new double[1];
final double[] b = new double[1];
@ -209,25 +207,27 @@ public class EvaluateAlgorithms extends Observable {
try {
startTS();
} catch (InterruptedException e) {
e.printStackTrace();
Logging.logError(e.getMessage(), e);
Thread.currentThread().interrupt();
}
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]};
sendPlotLineResults(tmp, 2);
result = getScaleDependentMeasure(arrangement.getLines(), Double.valueOf(tsRes[0]), Double.valueOf(tsRes[1]));
result.addAll(getScaledErrorBasedMeasure(arrangement.getLines(), Double.valueOf(tsRes[0]), Double.valueOf(tsRes[1]), m[0], b[0]));
Double[] tmp = { Double.valueOf(tsRes[0]), Double.valueOf(tsRes[1]), m[0], b[0]};
sendPlotLineResults(Arrays.asList(tmp), Algorithm.Type.NAIV_TS);
}
sendTableApproximationTypes();
sendTableApproximationData(result, alg);
break;
case 1:
ArrayList<Double[]> lineRes;
List<List<String>> lineRes;
switch (alg) {
case 3:
try {
startLMS();
startRM();
} catch (InterruptedException e) {
e.printStackTrace();
Logging.logError(e.getMessage(), e);
Thread.currentThread().interrupt();
}
result = getPercentigeErrorBasedMeasure(arrangement.getLines(), lmsRes[0], lmsRes[1]);
@ -238,9 +238,9 @@ public class EvaluateAlgorithms extends Observable {
multipleResults.add(result);
lineRes = new ArrayList<>();
lineRes.add(lmsRes);
lineRes.add(rmRes);
sendPloteLineResults(lineRes, new Integer[]{0, 1});
lineRes.add(Arrays.asList(lmsRes));
lineRes.add(Arrays.asList(rmRes));
sendPloteLineResults(lineRes, Arrays.asList(Algorithm.Type.LMS, Algorithm.Type.RM));
break;
case 4:
@ -248,7 +248,8 @@ public class EvaluateAlgorithms extends Observable {
startLMS();
startTS();
} catch (InterruptedException e) {
e.printStackTrace();
Logging.logError(e.getMessage(), e);
Thread.currentThread().interrupt();
}
result = getPercentigeErrorBasedMeasure(arrangement.getLines(), lmsRes[0], lmsRes[1]);
@ -259,16 +260,17 @@ public class EvaluateAlgorithms extends Observable {
multipleResults.add(result);
lineRes = new ArrayList<>();
lineRes.add(lmsRes);
lineRes.add(tsRes);
sendPloteLineResults(lineRes, new Integer[]{0, 2});
lineRes.add(Arrays.asList(lmsRes));
lineRes.add(Arrays.asList(tsRes));
sendPloteLineResults(lineRes, Arrays.asList(Algorithm.Type.LMS, Algorithm.Type.TS));
break;
case 5:
try {
startRM();
startTS();
} catch (InterruptedException e) {
e.printStackTrace();
Logging.logError(e.getMessage(), e);
Thread.currentThread().interrupt();
}
result = fillPseudoResults();
@ -279,9 +281,9 @@ public class EvaluateAlgorithms extends Observable {
multipleResults.add(result);
lineRes = new ArrayList<>();
lineRes.add(rmRes);
lineRes.add(tsRes);
sendPloteLineResults(lineRes, new Integer[]{1, 2});
lineRes.add(Arrays.asList(rmRes));
lineRes.add(Arrays.asList(tsRes));
sendPloteLineResults(lineRes, Arrays.asList(Algorithm.Type.RM, Algorithm.Type.TS));
break;
case 6:
try {
@ -289,7 +291,8 @@ public class EvaluateAlgorithms extends Observable {
startRM();
startTS();
} catch (InterruptedException e) {
e.printStackTrace();
Logging.logError(e.getMessage(), e);
Thread.currentThread().interrupt();
}
result = getPercentigeErrorBasedMeasure(arrangement.getLines(), lmsRes[0], lmsRes[1]);
@ -300,10 +303,10 @@ public class EvaluateAlgorithms extends Observable {
multipleResults.add(result);
lineRes = new ArrayList<>();
lineRes.add(lmsRes);
lineRes.add(rmRes);
lineRes.add(tsRes);
sendPloteLineResults(lineRes, new Integer[]{0, 1, 2});
lineRes.add(Arrays.asList(lmsRes));
lineRes.add(Arrays.asList(rmRes));
lineRes.add(Arrays.asList(tsRes));
sendPloteLineResults(lineRes, Arrays.asList(Algorithm.Type.LMS, Algorithm.Type.RM, Algorithm.Type.TS));
break;
}
@ -320,16 +323,15 @@ public class EvaluateAlgorithms extends Observable {
* @param result Ergebnisse
* @param col Spalte
*/
public void sendTableApproximationData(ArrayList<String> result, int col) {
ArrayList<String> tableInput = new ArrayList<>();
tableInput.add("eval-d");
tableInput.add("" + col);
public void sendTableApproximationData(List<String> result, int col) {
List<String> tableInput = new ArrayList<>();
for (int i = 0; i < names[type].length; i++) {
tableInput.add(result.get(i));
}
tableInput.add("");
setChanged();
notifyObservers(tableInput.stream().toArray(String[]::new));
EvaluationData data = new EvaluationData();
data.setColumn(col);
data.setLabels(tableInput);
tableInput.clear();
}
@ -338,9 +340,10 @@ public class EvaluateAlgorithms extends Observable {
*
* @param result Ergebnisse
*/
public void sendTableApproximationData(ArrayList<ArrayList<String>> result) {
ArrayList<String> tableInput = new ArrayList<>();
public void sendTableApproximationData(List<List<String>> result) {
List<String> tableInput = new ArrayList<>();
//TODO Hääää? xD
//iteration über die ApproximationsGüten -- Zeilen
for (int j = 0; j <= result.get(0).size(); j++) {
tableInput.add("eval-ds");
@ -357,8 +360,12 @@ public class EvaluateAlgorithms extends Observable {
tableInput.add("");
tableInput.add("");
}
setChanged();
notifyObservers(tableInput.stream().toArray(String[]::new));
EvaluationData data = new EvaluationData();
data.setType(SubscriberType.EVAL_DS);
data.setMultipleColumnResult(result);
this.subscriber.onNext(data);
tableInput.clear();
}
}
@ -367,16 +374,10 @@ public class EvaluateAlgorithms extends Observable {
* Die Art der Ergebnisse (MSE, RMSE,...) wird an der Beobachter übermittelt.
*/
public void sendTableApproximationTypes() {
ArrayList<String> tableInput = new ArrayList<>();
tableInput.add("eval-t");
tableInput.add("" + 0);
for (int i = 0; i < names[type].length; i++) {
tableInput.add(names[type][i]);
}
tableInput.add("");
setChanged();
notifyObservers(tableInput.stream().toArray(String[]::new));
tableInput.clear();
EvaluationData data = new EvaluationData();
data.setType(SubscriberType.EVAL_T);
data.setLabels(Arrays.asList(names[type]));
this.subscriber.onNext(data);
}
/**
@ -386,18 +387,12 @@ public class EvaluateAlgorithms extends Observable {
* @param res Feld mit den Werten für die Steigung und dern y-Achsenabschnitt
* @param alg code für welchen Algorithmus sich die Werte beziehen
*/
public void sendPlotLineResults(Double[] res, int alg) {
//visualisiere m,b
ArrayList<String> lines = new ArrayList<>();
lines.add("lines-res");
lines.add("" + alg);
//lms res
for (int i = 0; i < res.length; i++) {
lines.add(res[i] + "");
}
setChanged();
notifyObservers(lines.stream().toArray(String[]::new));
public void sendPlotLineResults(List<Double> res, Algorithm.Type alg) {
EvaluationData data = new EvaluationData();
data.setType(SubscriberType.LINES_RES);
data.setAlgorithmtypes(Collections.singletonList(alg));
data.setOneColumnresult(res);
this.subscriber.onNext(data);
}
/**
@ -407,18 +402,12 @@ public class EvaluateAlgorithms extends Observable {
* @param res Feld mit den Werten für die Steigung und dern y-Achsenabschnitt (alle)
* @param algs codes für welchen Algorithmus sich die Werte beziehen (alle)
*/
public void sendPloteLineResults(ArrayList<Double[]> res, Integer[] algs) {
ArrayList<String> lines = new ArrayList<>();
lines.add("lines-res-mult");
for (int i = 0; i < algs.length; i++) {
lines.add("" + algs[i]);
//lms res
Double[] tmp = res.get(i);
lines.add(tmp[0] + "");
lines.add(tmp[1] + "");
}
setChanged();
notifyObservers(lines.stream().toArray(String[]::new));
public void sendPloteLineResults(List<List<String>> res, List<Algorithm.Type> algs) {
EvaluationData data = new EvaluationData();
data.setType(SubscriberType.LINES_RES_MULT);
data.setAlgorithmtypes(algs);
data.setMultipleColumnResult(res);
this.subscriber.onNext(data);
}
/**
@ -433,6 +422,7 @@ public class EvaluateAlgorithms extends Observable {
lmsAlg.pepareResult();
lmsRes[0] = lmsAlg.getSlope();
lmsRes[1] = lmsAlg.getyInterception();
});
lmsThread.start();
lmsThread.join();
@ -480,9 +470,9 @@ public class EvaluateAlgorithms extends Observable {
* @param b y-Achsenabschnitt
* @return Liste mit den Ergebnissen, bereit zum visualisieren
*/
public ArrayList<String> getScaleDependentMeasure(final LinkedList<Line> lines, final Double m, final Double b) {
public List<String> getScaleDependentMeasure(final List<Line> lines, final Double m, final Double b) {
ScaleDependentMeasure scaleDependentMeasure = new ScaleDependentMeasure(lines, m, b);
ArrayList<String> ret = new ArrayList<>();
List<String> ret = new ArrayList<>();
ret.add(scaleDependentMeasure.mse().toString());
ret.add(scaleDependentMeasure.rmse().toString());
ret.add(scaleDependentMeasure.mae().toString());
@ -501,7 +491,7 @@ public class EvaluateAlgorithms extends Observable {
* @param b y-Achsenabschnitt
* @return Liste mit den Ergebnissen, bereit zum visualisieren
*/
public ArrayList<String> getPercentigeErrorBasedMeasure(final LinkedList<Line> lines, final Double m, final Double b) {
public List<String> getPercentigeErrorBasedMeasure(final List<Line> lines, final Double m, final Double b) {
PercentageErrorBasedMeasure percentageErrorBasedMeasure = new PercentageErrorBasedMeasure(lines, m, b);
ArrayList<String> ret = new ArrayList<>();
ret.add(percentageErrorBasedMeasure.mape().toString());
@ -521,9 +511,9 @@ public class EvaluateAlgorithms extends Observable {
* @param b y-Achsenabschnitt
* @return Liste mit den Ergebnissen, bereit zum visualisieren
*/
public ArrayList<String> getScaledErrorBasedMeasure(final LinkedList<Line> lines, final Double m, final Double b, final Double nM, final Double nB) {
public List<String> getScaledErrorBasedMeasure(final List<Line> lines, final Double m, final Double b, final Double nM, final Double nB) {
ScaledErrorBasedMeasure scaledErrorBasedMeasure = new ScaledErrorBasedMeasure(lines, m, b, nM, nB);
ArrayList<String> ret = new ArrayList<>();
List<String> ret = new ArrayList<>();
ret.add(scaledErrorBasedMeasure.mse().toString());
ret.add(scaledErrorBasedMeasure.rmse().toString());
ret.add(scaledErrorBasedMeasure.mae().toString());
@ -538,8 +528,8 @@ public class EvaluateAlgorithms extends Observable {
*
* @return
*/
private ArrayList<String> fillPseudoResults() {
ArrayList<String> result = new ArrayList<>();
private List<String> fillPseudoResults() {
List<String> result = new ArrayList<>();
result.add(" ");
result.add(" ");
result.add(" ");
@ -552,7 +542,12 @@ public class EvaluateAlgorithms extends Observable {
/**
* @return Liste der Geraden auf der die Berechnungen ausgeführt wurden
*/
public LinkedList<Line> getData() {
public List<Line> getData() {
return arrangement.getLines();
}
@Override
public void subscribe(Flow.Subscriber<? super Data> subscriber) {
this.subscriber = subscriber;
}
}

@ -1,10 +1,10 @@
package presenter.evaluation;
package de.wwwu.awolf.presenter.evaluation;
import model.Line;
import presenter.util.FastElementSelector;
import de.wwwu.awolf.model.Line;
import de.wwwu.awolf.presenter.util.FastElementSelector;
import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;
/**
* Implementierung verschiedener Algorithmen zur Berechnung von Ausgleichsgeraden.
@ -25,10 +25,10 @@ public class PercentageErrorBasedMeasure {
* @param m Steigung
* @param b y-Achenabschnitt
*/
public PercentageErrorBasedMeasure(final LinkedList<Line> lines, Double m, Double b) {
public PercentageErrorBasedMeasure(final List<Line> lines, Double m, Double b) {
//Berechnung des Sampson-Fehlers
ArrayList<Double> sampson = new ArrayList<>();
List<Double> sampson = new ArrayList<>();
for (Line line : lines) {
Double e = Math.pow(m * line.getM() - line.getB() + b, 2) / (Math.pow(m, 2) + 1);
sampson.add(e);

@ -1,17 +1,21 @@
package presenter.evaluation;
package de.wwwu.awolf.presenter.evaluation;
import model.Line;
import de.wwwu.awolf.model.Line;
import de.wwwu.awolf.model.communication.Data;
import de.wwwu.awolf.model.communication.SubscriberType;
import de.wwwu.awolf.model.communication.TypeData;
import de.wwwu.awolf.presenter.Presenter;
import de.wwwu.awolf.presenter.util.Logging;
import org.opencv.core.*;
import org.opencv.imgcodecs.Imgcodecs;
import org.opencv.imgproc.Imgproc;
import presenter.Presenter;
import javax.swing.*;
import java.awt.image.BufferedImage;
import java.awt.image.DataBufferByte;
import java.io.File;
import java.util.ArrayList;
import java.util.Observable;
import java.util.concurrent.Flow;
/**
* Implementierung verschiedener Algorithmen zur Berechnung von Ausgleichsgeraden.
@ -20,7 +24,7 @@ import java.util.Observable;
* @Email: a_wolf28@uni-muenster.de
* @Date: 17.09.2017.
*/
public class PictureProcessor extends Observable {
public class PictureProcessor implements Flow.Publisher<Data> {
private Mat image;
private Mat contour;
@ -28,6 +32,7 @@ public class PictureProcessor extends Observable {
private File file;
private ArrayList<MatOfPoint> contours;
private double contourLength;
private Flow.Subscriber<? super Data> subscriber;
/**
* Konstruktor
@ -38,6 +43,7 @@ public class PictureProcessor extends Observable {
public PictureProcessor(Presenter presenter, File file) {
this.file = file;
this.presenter = presenter;
subscribe(presenter);
}
/**
@ -133,15 +139,21 @@ public class PictureProcessor extends Observable {
}
}
setChanged();
String[] msg = {"import-picture"};
notifyObservers(msg);
TypeData data = new TypeData();
data.setType(SubscriberType.PICTURE);
this.subscriber.onNext(data);
});
t.start();
try {
t.join();
} catch (InterruptedException e) {
e.printStackTrace();
Logging.logError(e.getMessage(), e);
Thread.currentThread().interrupt();
}
}
@Override
public void subscribe(Flow.Subscriber<? super Data> subscriber) {
this.subscriber = subscriber;
}
}

@ -1,10 +1,10 @@
package presenter.evaluation;
package de.wwwu.awolf.presenter.evaluation;
import model.Line;
import presenter.util.FastElementSelector;
import de.wwwu.awolf.model.Line;
import de.wwwu.awolf.presenter.util.FastElementSelector;
import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;
/**
* Implementierung verschiedener Algorithmen zur Berechnung von Ausgleichsgeraden.
@ -24,7 +24,7 @@ public class ScaleDependentMeasure {
* @param m Steigung
* @param b y-Achsenabschnitt
*/
public ScaleDependentMeasure(final LinkedList<Line> lines, Double m, Double b) {
public ScaleDependentMeasure(final List<Line> lines, Double m, Double b) {
//Liste mit den Fehler zu jedem Punkt
errorValues = new ArrayList<>();

@ -1,10 +1,10 @@
package presenter.evaluation;
package de.wwwu.awolf.presenter.evaluation;
import model.Line;
import presenter.util.FastElementSelector;
import de.wwwu.awolf.model.Line;
import de.wwwu.awolf.presenter.util.FastElementSelector;
import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;
/**
* Implementierung verschiedener Algorithmen zur Berechnung von Ausgleichsgeraden.
@ -29,7 +29,7 @@ public class ScaledErrorBasedMeasure {
* @param naivSlope naive Steigung
* @param naivInterception naiver y-Achsenabschnitt
*/
public ScaledErrorBasedMeasure(final LinkedList<Line> lines, Double m, Double b, Double naivSlope, Double naivInterception) {
public ScaledErrorBasedMeasure(final List<Line> lines, Double m, Double b, Double naivSlope, Double naivInterception) {
this.sampsonError = new ArrayList<>();
this.naivSampsonError = new ArrayList<>();

@ -1,11 +1,17 @@
package presenter.generator;
package de.wwwu.awolf.presenter.generator;
import model.Line;
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;
import java.security.SecureRandom;
import java.util.HashMap;
import java.util.LinkedList;
import java.util.Observable;
import java.util.Random;
import java.util.List;
import java.util.Map;
import java.util.concurrent.Flow;
/**
* Implementierung verschiedener Algorithmen zur Berechnung von Ausgleichsgeraden.
@ -14,30 +20,26 @@ import java.util.Random;
* @Email: a_wolf28@uni-muenster.de
* @Date: 01.08.2017.
*/
public class DatasetGenerator extends Observable {
public class DatasetGenerator implements Flow.Publisher<Data> {
private Double m;
private Double b;
private Random random;
private SecureRandom random;
private Flow.Subscriber<? super Data> subscriber;
/**
* Konstruktor
*
* @param m Steigung
* @param b y-Achsenabschnitt
*/
public DatasetGenerator(Double m, Double b) {
this.m = m;
this.b = b;
random = new Random();
random.setSeed(9999);
public DatasetGenerator(Presenter presenter) {
random = new SecureRandom();
this.subscribe(presenter);
}
/**
* Konstruktor
*/
public DatasetGenerator() {
random = new Random();
random = new SecureRandom();
}
/**
@ -61,11 +63,8 @@ public class DatasetGenerator extends Observable {
line.setId(i - 1 + "");
lines.add(line);
}
String[] ret = {"generator", "Es wurden " + size + " Daten generiert mit den Parametern",
"</br> <b>m</b> = " + m + "",
"</br> <b>b</b> = " + b + ""};
setChanged();
notifyObservers(ret);
communicate("Es wurden " + size + " Daten generiert mit den Parametern", m, b);
return lines;
}
@ -75,8 +74,8 @@ public class DatasetGenerator extends Observable {
* @param size Größe des Datensatzes
* @return Liste des Geraden
*/
public LinkedList<Line> generateDataLines(int size) {
LinkedList<Line> lines = new LinkedList<>();
public List<Line> generateDataLines(int size) {
List<Line> lines = new LinkedList<>();
return generateDataLines(lines, size);
}
@ -88,12 +87,12 @@ public class DatasetGenerator extends Observable {
* @param n Größe des Datensatzes
* @return Liste des Geraden
*/
private LinkedList<Line> generateDataLines(LinkedList<Line> lines, int n) {
private List<Line> generateDataLines(List<Line> lines, int n) {
m = 5d;
b = 0d;
int size = 0;
HashMap<Double, Double> points = new HashMap<>();
Map<Double, Double> points = new HashMap<>();
//speichere die Koordinaten in einer HashMap, damit keine Punkte
//entstehen deren x-Koordinate zu sehr beieinander liegt.
@ -116,9 +115,7 @@ public class DatasetGenerator extends Observable {
idx++;
}
String[] ret = {"generator", "Es wurden " + n + " Daten generiert mit den Parametern"};
setChanged();
notifyObservers(ret);
communicate("Es wurden " + n + " Daten generiert mit den Parametern", m, b);
return lines;
}
@ -130,8 +127,8 @@ public class DatasetGenerator extends Observable {
* @param size Größe des Datensatzes
* @return Liste der Geraden
*/
public LinkedList<Line> generateCircle(int size) {
LinkedList<Line> lines = new LinkedList<>();
public List<Line> generateCircle(int size) {
List<Line> lines = new LinkedList<>();
double from = 0;
double to = Math.PI * 5;
@ -159,5 +156,20 @@ public class DatasetGenerator extends Observable {
return generateDataLines(lines, size / 2);
}
@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);
}
}
}

@ -1,13 +1,17 @@
package presenter.io;
package de.wwwu.awolf.presenter.io;
import com.opencsv.CSVWriter;
import model.Line;
import de.wwwu.awolf.model.Line;
import de.wwwu.awolf.model.communication.Data;
import de.wwwu.awolf.model.communication.ExportData;
import de.wwwu.awolf.model.communication.SubscriberType;
import de.wwwu.awolf.presenter.util.Logging;
import java.io.File;
import java.io.FileWriter;
import java.io.IOException;
import java.util.LinkedList;
import java.util.Observable;
import java.util.List;
import java.util.concurrent.Flow;
/**
* Implementierung verschiedener Algorithmen zur Berechnung von Ausgleichsgeraden.
@ -16,10 +20,11 @@ import java.util.Observable;
* @Email: a_wolf28@uni-muenster.de
* @Date: 03.08.2017.
*/
public class DataExporter extends Observable {
public class DataExporter implements Flow.Publisher<Data> {
private LinkedList<Line> lines;
private List<Line> lines;
private File file;
private Flow.Subscriber<? super Data> subscriber;
/**
* Konstruktor
@ -27,9 +32,10 @@ public class DataExporter extends Observable {
* @param lines Liste der Geraden
* @param file Datei in die, die Informationen exportiert werden sollen
*/
public DataExporter(LinkedList<Line> lines, File file) {
public DataExporter(List<Line> lines, File file, Flow.Subscriber<Data> subscriber) {
this.file = file;
this.lines = lines;
subscribe(subscriber);
}
/**
@ -46,18 +52,25 @@ public class DataExporter extends Observable {
for (Line line : lines) {
entries[0] = line.getId();
entries[1] = line.getM().toString();
Double tmp = (-1) * line.getB();
entries[2] = tmp.toString();
double tmp = (-1) * line.getB();
entries[2] = Double.toString(tmp);
writer.writeNext(entries);
}
writer.close();
String[] ret = {"export", "Das aktuelle Modell wurde erfolgreich unter: " + file.getAbsolutePath() + " gespeichert."};
setChanged();
notifyObservers(ret);
ExportData data = new ExportData();
data.setType(SubscriberType.EXPORT);
data.setMessage("Das aktuelle Modell wurde erfolgreich unter: " + file.getAbsolutePath() + " gespeichert.");
this.subscriber.onNext(data);
} catch (IOException e) {
e.printStackTrace();
Logging.logError(e.getMessage(), e);
}
}
@Override
public void subscribe(Flow.Subscriber<? super Data> subscriber) {
this.subscriber = subscriber;
}
}

@ -1,7 +1,11 @@
package presenter.io;
package de.wwwu.awolf.presenter.io;
import com.opencsv.CSVReader;
import model.Line;
import de.wwwu.awolf.model.Line;
import de.wwwu.awolf.model.communication.Data;
import de.wwwu.awolf.model.communication.ImportData;
import de.wwwu.awolf.model.communication.SubscriberType;
import de.wwwu.awolf.presenter.util.Logging;
import javax.swing.*;
import java.io.File;
@ -10,7 +14,7 @@ import java.io.FileReader;
import java.io.IOException;
import java.util.LinkedList;
import java.util.List;
import java.util.Observable;
import java.util.concurrent.Flow;
/**
@ -20,24 +24,23 @@ import java.util.Observable;
* @Email: a_wolf28@uni-muenster.de
* @Date: 21.06.2017.
*/
public class DataImporter extends Observable {
public class DataImporter implements Flow.Publisher<Data> {
private File file;
private CSVReader reader;
private Flow.Subscriber<? super Data> subscriber;
/**
* Konstruktor
*
* @param file Datei aus der die Informationen imortiert werden sollen.
*/
public DataImporter(File file) {
//System.out.println(this.model.getLines().size()+ " die Anzahl der aktuellen Lines.");
this.file = file;
try {
public DataImporter(File file, Flow.Subscriber<? super Data> subscriber) {
subscribe(subscriber);
try {
this.reader = new CSVReader(new FileReader(file));
} catch (FileNotFoundException e) {
e.printStackTrace();
Logging.logError(e.getMessage(), e);
}
}
@ -48,52 +51,68 @@ public class DataImporter extends Observable {
*
* @return Liste der Geraden
*/
public LinkedList<Line> run() {
LinkedList<Line> list = new LinkedList<>();
public List<Line> run() {
List<Line> list = new LinkedList<>();
try {
List<String[]> lines = reader.readAll();
int counter = 0;
String[] result = {"import", lines.size() + "", ""};
//System.out.println("+-------------------------------------------------------------------------------+");
for (String[] nextLine : lines) {
if (nextLine.length == 3) {
Double x = Double.parseDouble(nextLine[1]);
Double y = Double.parseDouble(nextLine[2]) * (-1);
double x = Double.parseDouble(nextLine[1]);
double y = Double.parseDouble(nextLine[2]) * (-1);
Line line = new Line(x, y);
line.setId(nextLine[0] + "");
if (!list.contains(line)) {
list.add(line);
}
setChanged();
counter++;
result[2] = counter + "";
Thread.sleep(10);
notifyObservers(result);
communicate(counter, lines.size());
} else if (nextLine.length == 2) {
Double x = Double.parseDouble(nextLine[1]);
Double y = Double.parseDouble(nextLine[2]) * (-1);
double x = Double.parseDouble(nextLine[1]);
double y = Double.parseDouble(nextLine[2]) * (-1);
Line line = new Line(x, y);
line.setId(counter + "");
if (!list.contains(line)) {
list.add(line);
}
setChanged();
counter++;
result[2] = counter + "";
Thread.sleep(10);
notifyObservers(result);
communicate(counter, lines.size());
} else {
JOptionPane.showMessageDialog(null, "Diese Datei kann nicht importiert werden." +
"Es müssen mindestens zwei Spalten enthalten sein (x,y).", "Fehler bei der Eingabe", JOptionPane.ERROR_MESSAGE);
Logging.logWarning("Diese Datei kann nicht importiert werden. Es müssen mindestens zwei Spalten enthalten sein (x,y). Fehler bei der Eingabe");
return null;
}
}
} catch (IOException e) {
e.printStackTrace();
Logging.logError(e.getMessage(), e);
} catch (InterruptedException e) {
e.printStackTrace();
Logging.logError(e.getMessage(), e);
Thread.currentThread().interrupt();
}
return list;
}
private void communicate(int counter, int size) {
// communication
ImportData data = new ImportData();
data.setType(SubscriberType.IMPORT);
data.setCurrent(counter);
data.setNumberOfLines(size);
this.subscriber.onNext(data);
}
@Override
public void subscribe(Flow.Subscriber<? super Data> subscriber) {
this.subscriber = subscriber;
}
}

@ -1,4 +1,4 @@
package presenter.util;
package de.wwwu.awolf.presenter.util;
/**
* Implementierung verschiedener Algorithmen zur Berechnung von Ausgleichsgeraden.

@ -1,6 +1,6 @@
package presenter.util.Comparators;
package de.wwwu.awolf.presenter.util.Comparators;
import model.Line;
import de.wwwu.awolf.model.Line;
import java.util.Comparator;

@ -1,6 +1,6 @@
package presenter.util.Comparators;
package de.wwwu.awolf.presenter.util.Comparators;
import model.Line;
import de.wwwu.awolf.model.Line;
import java.util.Comparator;

@ -1,8 +1,8 @@
package presenter.util;
package de.wwwu.awolf.presenter.util;
import java.security.SecureRandom;
import java.util.Collections;
import java.util.List;
import java.util.Random;
/**
* Implementierung verschiedener Algorithmen zur Berechnung von Ausgleichsgeraden.
@ -58,7 +58,7 @@ public class FastElementSelector {
*/
private static int randomizedPartition(List<Double> a, int start, int end) {
int i = 0;
Random random = new Random(System.currentTimeMillis());
SecureRandom random = new SecureRandom();
//alternative: ThreadLocalRandom.current()
if (start < end) {

@ -1,12 +1,12 @@
package presenter.util;
package de.wwwu.awolf.presenter.util;
import model.Interval;
import model.Line;
import model.Point;
import de.wwwu.awolf.model.Interval;
import de.wwwu.awolf.model.Line;
import de.wwwu.awolf.model.Point;
import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;
import java.util.Set;
import java.util.TreeSet;
/**
@ -18,8 +18,8 @@ import java.util.TreeSet;
*/
public class IntersectionComputer {
private LinkedList<Line> lines;
private TreeSet<Point> intersections;
private List<Line> lines;
private Set<Point> intersections;
private Double xMinimum;
private Double xMaximum;
@ -33,7 +33,7 @@ public class IntersectionComputer {
*
* @param lines Liste der Geraden
*/
public IntersectionComputer(LinkedList<Line> lines) {
public IntersectionComputer(List<Line> lines) {
this.lines = lines;
this.worker = new Thread[4];
this.intersections = new TreeSet<>();
@ -78,7 +78,8 @@ public class IntersectionComputer {
try {
t.join();
} catch (InterruptedException e) {
e.printStackTrace();
Logging.logError(e.getMessage(), e);
Thread.currentThread().interrupt();
}
}
} else {
@ -118,7 +119,7 @@ public class IntersectionComputer {
*
* @return Liste der Geraden
*/
public synchronized LinkedList<Line> getLines() {
public synchronized List<Line> getLines() {
return lines;
}

@ -1,11 +1,11 @@
package presenter.util;
package de.wwwu.awolf.presenter.util;
import model.Interval;
import model.Line;
import model.Pair;
import model.Point;
import presenter.util.Comparators.YOrderLineComparatorBegin;
import presenter.util.Comparators.YOrderLineComparatorEnd;
import de.wwwu.awolf.model.Interval;
import de.wwwu.awolf.model.Line;
import de.wwwu.awolf.model.Pair;
import de.wwwu.awolf.model.Point;
import de.wwwu.awolf.presenter.util.Comparators.YOrderLineComparatorBegin;
import de.wwwu.awolf.presenter.util.Comparators.YOrderLineComparatorEnd;
import java.util.*;
@ -161,7 +161,7 @@ public class IntersectionCounter {
} else {
//merke die inversionspaare
for (int i = left; i <= mid; i++) {
// System.out.println(aux.get(i)+" -- "+ aux.get(right));
// Logging.logInfo(aux.get(i)+" -- "+ aux.get(right));
inversions.add(new Pair(aux.get(i), aux.get(right)));
}
a.set(index++, aux.get(right++));
@ -210,9 +210,9 @@ public class IntersectionCounter {
* @param sampledLine eine spezielle Gerade
* @return Liste mit x Koordinaten der Schnittpunkte
*/
public ArrayList<Double> calculateIntersectionAbscissas(ArrayList<Line> set, Line sampledLine) {
LinkedList<Line> lines = new LinkedList<>(set);
ArrayList<Double> intersections = new ArrayList<>();
public List<Double> calculateIntersectionAbscissas(List<Line> set, Line sampledLine) {
List<Line> lines = new LinkedList<>(set);
List<Double> intersections = new ArrayList<>();
double intersection;
for (Line line : lines) {

@ -0,0 +1,40 @@
package de.wwwu.awolf.presenter.util;
import org.apache.log4j.Logger;
public class Logging {
private static Logger logger = Logger.getRootLogger();
public static void logInfo(final String message, Throwable throwable) {
logger.info(message, throwable);
}
public static void logInfo(final String message) {
logger.info(message);
}
public static void logDebug(final String message, Throwable throwable) {
logger.debug(message, throwable);
}
public static void logDebug(final String message) {
logger.debug(message);
}
public static void logWarning(final String message, Throwable throwable) {
logger.warn(message, throwable);
}
public static void logWarning(final String message) {
logger.warn(message);
}
public static void logError(final String message, Throwable throwable) {
logger.error(message, throwable);
}
public static void logError(final String message) {
logger.error(message);
}
}

@ -1,11 +1,11 @@
package presenter.util;
package de.wwwu.awolf.presenter.util;
import model.Line;
import model.Point;
import de.wwwu.awolf.model.Line;
import de.wwwu.awolf.model.Point;
import java.security.SecureRandom;
import java.util.ArrayList;
import java.util.Random;
import java.util.concurrent.ThreadLocalRandom;
import java.util.List;
/**
* Implementierung verschiedener Algorithmen zur Berechnung von Ausgleichsgeraden.
@ -16,6 +16,12 @@ import java.util.concurrent.ThreadLocalRandom;
*/
public class RandomSampler {
private static SecureRandom random = new SecureRandom(); // Compliant for security-sensitive use cases
private RandomSampler() {
super();
}
/**
* Diese Methode liefert eine <code>r</code> Elementige zufällige Stichprobe an Geraden.
*
@ -23,12 +29,12 @@ public class RandomSampler {
* @param r Anzahl der zu wählenden Geraden
* @return <code>r</code> Elementige zufällige Stichprobe an Geraden
*/
public static ArrayList<Line> run(ArrayList<Line> set, Double r, Integer indexOfEnd) {
public static List<Line> run(List<Line> set, Double r, Integer indexOfEnd) {
ArrayList<Line> sampledLines = new ArrayList<>();
List<Line> sampledLines = new ArrayList<>();
for (int i = 0; i < r; i++) {
sampledLines.add(set.get(ThreadLocalRandom.current().nextInt(0, indexOfEnd)));
sampledLines.add(set.get(random.nextInt(indexOfEnd)));
}
return sampledLines;
@ -41,17 +47,16 @@ public class RandomSampler {
* @param r Anzahl der zu wählenden Geraden
* @return <code>r</code> Elementige zufällige Stichprobe an Schnittpunkten
*/
public static ArrayList<Double> run(ArrayList<Point> set, Double r) {
public static List<Double> run(List<Point> set, Double r) {
ArrayList<Double> sampledLines = new ArrayList<>();
List<Double> sampledLines = new ArrayList<>();
for (Point p : set) {
sampledLines.add(p.getX());
}
Random rand = new Random();
int inputSize = sampledLines.size();
for (int i = 0; i < r; i++) {
int indexToSwap = i + rand.nextInt(inputSize - i);
int indexToSwap = i + random.nextInt(inputSize - i);
Double temp = sampledLines.get(i);
sampledLines.set(i, sampledLines.get(indexToSwap));
sampledLines.set(indexToSwap, temp);

@ -1,18 +1,19 @@
package view;
import model.Line;
import presenter.AbstractPresenter;
import presenter.Presenter;
import view.listener.*;
import view.panels.DualityPanel;
import view.panels.EvaluationPanel;
import view.panels.InfoPanel;
import view.panels.PlotPanel;
import view.panels.tabs.LMSPanel;
import view.panels.tabs.RMPanel;
import view.panels.tabs.TSPanel;
import view.panels.tabs.TabPanel;
package de.wwwu.awolf.view;
import de.wwwu.awolf.model.Line;
import de.wwwu.awolf.presenter.AbstractPresenter;
import de.wwwu.awolf.presenter.Presenter;
import de.wwwu.awolf.presenter.util.Logging;
import de.wwwu.awolf.view.listener.*;
import de.wwwu.awolf.view.panels.DualityPanel;
import de.wwwu.awolf.view.panels.EvaluationPanel;
import de.wwwu.awolf.view.panels.InfoPanel;
import de.wwwu.awolf.view.panels.PlotPanel;
import de.wwwu.awolf.view.panels.tabs.LMSPanel;
import de.wwwu.awolf.view.panels.tabs.RMPanel;
import de.wwwu.awolf.view.panels.tabs.TSPanel;
import de.wwwu.awolf.view.panels.tabs.TabPanel;
import javax.imageio.ImageIO;
import javax.swing.*;
@ -20,7 +21,6 @@ import java.awt.*;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.LinkedList;
import java.util.List;
/**
@ -131,6 +131,17 @@ public class MainFrame extends JFrame {
createPlot(m, b, plotLMS, lmsPanel, "LMS");
}
/**
* Visualisiert das Ergebnis des LMS-Schätzers
*
* @param line Line
*/
public void visualizeLMS(final Line line) {
plotLMS = new PlotPanel();
lmsPanel.setPlotPanel(plotLMS);
createPlot(line.getM(), line.getB(), plotLMS, lmsPanel, "LMS");
}
/**
* Visualisiert das Ergebnis des RM-Schätzers
*
@ -143,6 +154,17 @@ public class MainFrame extends JFrame {
createPlot(m, b, plotRM, rmPanel, "RM");
}
/**
* Visualisiert das Ergebnis des RM-Schätzers
*
* @param line Line
*/
public void visualizeRM(final Line line) {
plotRM = new PlotPanel();
rmPanel.setPlotPanel(plotRM);
createPlot(line.getM(), line.getB(), plotRM, rmPanel, "RM");
}
/**
* Visualisiert das Ergebnis des TS-Schätzers
*
@ -155,6 +177,17 @@ public class MainFrame extends JFrame {
createPlot(m, b, plotTS, tsPanel, "TS");
}
/**
* Visualisiert das Ergebnis des TS-Schätzers
*
* @param line Line
*/
public void visualizeTS(final Line line) {
plotTS = new PlotPanel();
tsPanel.setPlotPanel(plotTS);
createPlot(line.getM(), line.getB(), plotTS, tsPanel, "TS");
}
/**
* Erzeugt den Plot zu einer Eingabe von Punkten und der Lösung eines Schätzers (m,b)
*
@ -268,7 +301,7 @@ public class MainFrame extends JFrame {
public void drawLineResults(Object[] res) {
SwingUtilities.invokeLater(() -> {
Object[] result = Arrays.copyOfRange(res, 1, res.length);
ArrayList<Double[]> algs = new ArrayList<>();
List<Double[]> algs = new ArrayList<>();
for (int i = 0; i < (result.length + 1) / 3; i++) {
String name = (String) result[(3 * i)];
@ -289,7 +322,7 @@ public class MainFrame extends JFrame {
*
* @param lines Liste der Geraden
*/
public void addEvalDataset(LinkedList<Line> lines) {
public void addEvalDataset(List<Line> lines) {
SwingUtilities.invokeLater(() -> {
evaluationPanel.setDualPoints(lines);
evaluationPanel.repaint();
@ -444,7 +477,7 @@ public class MainFrame extends JFrame {
tsPanel.getStartButton().setIcon(new ImageIcon(imgStart));
this.setIconImage(imgFrame);
} catch (IOException e) {
e.printStackTrace();
Logging.logError(e.getMessage(), e);
}
}

@ -1,11 +1,11 @@
package view;
import presenter.Presenter;
import view.listener.ExportDataListener;
import view.listener.GenerateDataListener;
import view.listener.ImportDataListener;
import view.listener.PictureImportListener;
import view.panels.AboutPanel;
package de.wwwu.awolf.view;
import de.wwwu.awolf.presenter.Presenter;
import de.wwwu.awolf.view.listener.ExportDataListener;
import de.wwwu.awolf.view.listener.GenerateDataListener;
import de.wwwu.awolf.view.listener.ImportDataListener;
import de.wwwu.awolf.view.listener.PictureImportListener;
import de.wwwu.awolf.view.panels.AboutPanel;
import javax.swing.*;

@ -1,4 +1,4 @@
package view.custom;
package de.wwwu.awolf.view.custom;
import javax.swing.*;
import javax.swing.table.DefaultTableCellRenderer;

@ -1,6 +1,6 @@
package view.listener;
package de.wwwu.awolf.view.listener;
import presenter.Presenter;
import de.wwwu.awolf.presenter.Presenter;
import javax.swing.*;
import java.awt.event.ActionEvent;

@ -1,6 +1,6 @@
package view.listener;
package de.wwwu.awolf.view.listener;
import presenter.Presenter;
import de.wwwu.awolf.presenter.Presenter;
import javax.swing.*;
import javax.swing.filechooser.FileNameExtensionFilter;
@ -45,7 +45,7 @@ public class ExportDataListener implements ActionListener {
if (chooser.showSaveDialog(component) == JFileChooser.APPROVE_OPTION) {
//System.out.println ("Datei "+chooser.getSelectedFile()+ " ausgewählt.");
//Logging.logInfo ("Datei "+chooser.getSelectedFile()+ " ausgewählt.");
file = chooser.getSelectedFile();
String filename = file.getAbsolutePath().contains(".csv") ? file.getAbsolutePath() : file.getAbsolutePath().concat(".csv");
File withExtension = new File(filename);

@ -1,6 +1,6 @@
package view.listener;
package de.wwwu.awolf.view.listener;
import presenter.Presenter;
import de.wwwu.awolf.presenter.Presenter;
import javax.swing.*;
import java.awt.*;

@ -1,6 +1,6 @@
package view.listener;
package de.wwwu.awolf.view.listener;
import presenter.Presenter;
import de.wwwu.awolf.presenter.Presenter;
import javax.swing.*;
import javax.swing.filechooser.FileNameExtensionFilter;
@ -46,7 +46,7 @@ public class ImportDataListener implements ActionListener {
if (chooser.showOpenDialog(component) == JFileChooser.APPROVE_OPTION) {
//System.out.println ("Datei "+chooser.getSelectedFile()+ " ausgewählt.");
//Logging.logInfo ("Datei "+chooser.getSelectedFile()+ " ausgewählt.");
file = chooser.getSelectedFile();
final File input = file;
Thread t = new Thread(() -> presenter.startImport(input));

@ -1,6 +1,6 @@
package view.listener;
package de.wwwu.awolf.view.listener;
import presenter.Presenter;
import de.wwwu.awolf.presenter.Presenter;
import javax.swing.*;
import javax.swing.filechooser.FileNameExtensionFilter;
@ -45,7 +45,7 @@ public class PictureImportListener implements ActionListener {
if (chooser.showOpenDialog(component) == JFileChooser.APPROVE_OPTION) {
//System.out.println ("Datei "+chooser.getSelectedFile()+ " ausgewählt.");
//Logging.logInfo ("Datei "+chooser.getSelectedFile()+ " ausgewählt.");
file = chooser.getSelectedFile();
final File input = file;
Thread t = new Thread(() -> presenter.startPictureDataImport(input));

@ -1,10 +1,10 @@
package view.listener;
package de.wwwu.awolf.view.listener;
import presenter.Presenter;
import view.panels.tabs.LMSPanel;
import view.panels.tabs.RMPanel;
import view.panels.tabs.TSPanel;
import view.panels.tabs.TabPanel;
import de.wwwu.awolf.presenter.Presenter;
import de.wwwu.awolf.view.panels.tabs.LMSPanel;
import de.wwwu.awolf.view.panels.tabs.RMPanel;
import de.wwwu.awolf.view.panels.tabs.TSPanel;
import de.wwwu.awolf.view.panels.tabs.TabPanel;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;

@ -1,4 +1,6 @@
package view.panels;
package de.wwwu.awolf.view.panels;
import de.wwwu.awolf.presenter.util.Logging;
import javax.imageio.ImageIO;
import javax.swing.*;
@ -8,6 +10,7 @@ import javax.swing.text.StyleConstants;
import javax.swing.text.StyledDocument;
import java.awt.*;
import java.io.IOException;
import java.util.Objects;
/**
* Implementierung verschiedener Algorithmen zur Berechnung von Ausgleichsgeraden.
@ -47,16 +50,16 @@ public class AboutPanel extends JPanel {
try {
doc.insertString(0, text, attrs);
} catch (BadLocationException e) {
e.printStackTrace();
Logging.logError(e.getMessage(), e);
}
doc.setParagraphAttributes(0, doc.getLength() - 1, attrs, false);
contentPane.add(this.textArea, BorderLayout.CENTER);
ClassLoader classLoader = getClass().getClassLoader();
try {
image = new ImageIcon(ImageIO.read(classLoader.getResource("wwu.png")).getScaledInstance(300, 87, Image.SCALE_SMOOTH));
image = new ImageIcon(ImageIO.read(Objects.requireNonNull(classLoader.getResource("wwu.png"))).getScaledInstance(300, 87, Image.SCALE_SMOOTH));
} catch (IOException e) {
e.printStackTrace();
Logging.logError(e.getMessage(), e);
}
this.imageContainer = new JLabel(image);
contentPane.add(imageContainer, BorderLayout.NORTH);

@ -1,7 +1,7 @@
package view.panels;
package de.wwwu.awolf.view.panels;
import model.Line;
import model.Point;
import de.wwwu.awolf.model.Line;
import de.wwwu.awolf.model.Point;
import org.jfree.chart.ChartFactory;
import org.jfree.chart.ChartPanel;
import org.jfree.chart.JFreeChart;
@ -20,8 +20,8 @@ import java.awt.event.KeyEvent;
import java.awt.event.KeyListener;
import java.awt.event.MouseWheelEvent;
import java.awt.event.MouseWheelListener;
import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;
/**
* Implementierung verschiedener Algorithmen zur Berechnung von Ausgleichsgeraden.
@ -32,8 +32,8 @@ import java.util.LinkedList;
*/
public class DualityPanel extends JPanel {
private LinkedList<Line> lines;
private LinkedList<Point> points;
private List<Line> lines;
private List<Point> points;
private JFreeChart chart;
private ChartPanel panel;
private XYSeriesCollection dataset;
@ -67,7 +67,7 @@ public class DualityPanel extends JPanel {
* @param ymin minimale y-Koordinate
* @param ymax maximale y-Koordinate
*/
public void setPrameters(LinkedList<Line> lines, ArrayList<Point> points, Double xmin, Double xmax, Double ymin, Double ymax) {
public void setPrameters(List<Line> lines, List<Point> points, Double xmin, Double xmax, Double ymin, Double ymax) {
this.lines = new LinkedList<>(lines);
this.points = new LinkedList<>(points);
this.domainMin = xmin;
@ -192,25 +192,26 @@ public class DualityPanel extends JPanel {
@Override
public void mouseWheelMoved(MouseWheelEvent e) {
Double min;
Double max;
Double val = e.getPreciseWheelRotation() * -1;
double min;
double max;
Double val;
val = e.getPreciseWheelRotation() * -1;
if (ctrlPressed == true) {
//System.out.println("CTRL + ZOOM");
if (ctrlPressed) {
//Logging.logInfo("CTRL + ZOOM");
min = range.getLowerBound();
max = range.getUpperBound();
DateRange dateRangeX = move(val, min, max);
range.setRange(dateRangeX);
} else if (shiftPressed == true) {
//System.out.println("SHIFT + ZOOM");
} else if (shiftPressed) {
//Logging.logInfo("SHIFT + ZOOM");
min = domain.getLowerBound();
max = domain.getUpperBound();
DateRange dateRangeY = move(val, min, max);
domain.setRange(dateRangeY);
} else {
Double x = Double.valueOf(e.getY());
Double y = Double.valueOf(e.getY());
Double x = (double) e.getY();
Double y = (double) e.getY();
if (e.getScrollType() != MouseWheelEvent.WHEEL_UNIT_SCROLL)
return;
if (e.getWheelRotation() < 0)
@ -266,9 +267,9 @@ public class DualityPanel extends JPanel {
int width = chartP.getMaximumDrawWidth() - chartP.getMinimumDrawWidth();
int height = chartP.getMaximumDrawHeight() - chartP.getMinimumDrawWidth();
if (increase) {
chartP.zoomInBoth(width / 2, height / 2);
chartP.zoomInBoth(width * 0.5, height * 0.5);
} else {
chartP.zoomOutBoth(width / 2, height / 2);
chartP.zoomOutBoth(width * 0.5, height * 0.5);
}
}

@ -1,10 +1,10 @@
package view.panels;
package de.wwwu.awolf.view.panels;
import model.Line;
import presenter.Presenter;
import view.MainFrame;
import view.custom.ButtonGroupAtLeastTwo;
import view.custom.ColorColumnRenderer;
import de.wwwu.awolf.model.Line;
import de.wwwu.awolf.presenter.Presenter;
import de.wwwu.awolf.view.MainFrame;
import de.wwwu.awolf.view.custom.ButtonGroupAtLeastTwo;
import de.wwwu.awolf.view.custom.ColorColumnRenderer;
import javax.swing.*;
import javax.swing.border.TitledBorder;
@ -20,6 +20,7 @@ import java.io.File;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.LinkedList;
import java.util.List;
/**
* Created by
@ -32,7 +33,6 @@ public class EvaluationPanel extends JPanel {
private JTable table;
private JTableHeader header;
private JButton start;
private JButton latexExport;
private JButton clearTable;
private JButton exportData;
private JRadioButton evalTypeOne; //1: Alg - N: Data
@ -89,10 +89,8 @@ public class EvaluationPanel extends JPanel {
datasetType = new JComboBox<>(datatypes);
start = new JButton("Start");
latexExport = new JButton("LaTex Export");
clearTable = new JButton("Löschen");
exportData = new JButton("Datenexport");
latexExport.setEnabled(false);
clearTable.setEnabled(false);
exportData.setEnabled(false);
evalTypeOne = new JRadioButton("Algorithmus evaluieren");
@ -142,7 +140,6 @@ public class EvaluationPanel extends JPanel {
buttonPanel.add(start);
buttonPanel.add(clearTable);
buttonPanel.add(exportData);
buttonPanel.add(latexExport);
algorithmPanel.add(lms);
algorithmPanel.add(rm);
@ -211,7 +208,7 @@ public class EvaluationPanel extends JPanel {
alg = checkSelection();
n = (Integer) datasetCountChoice.getSelectedItem();
String datatyp = (String) datasetType.getSelectedItem();
if (datatyp == "Import von CSV-Datei") {
if ("Import von CSV-Datei".equals(datatyp)) {
SwingUtilities.invokeLater(() -> {
File file = null;
JFileChooser chooser = new JFileChooser(FileSystemView.getFileSystemView().getHomeDirectory());
@ -222,7 +219,7 @@ public class EvaluationPanel extends JPanel {
chooser.setFileSelectionMode(JFileChooser.FILES_ONLY);
if (chooser.showOpenDialog(this) == JFileChooser.APPROVE_OPTION) {
//System.out.println ("Datei "+chooser.getSelectedFile()+ " ausgewählt.");
//Logging.logInfo ("Datei "+chooser.getSelectedFile()+ " ausgewählt.");
file = chooser.getSelectedFile();
final File input = file;
Thread t = new Thread(() -> ((Presenter) view.getPresenter()).startEvaluation(type, alg, input));
@ -234,7 +231,6 @@ public class EvaluationPanel extends JPanel {
((Presenter) view.getPresenter()).startEvaluation(type, n, alg, datatyp);
}
clearTable.setEnabled(true);
latexExport.setEnabled(true);
exportData.setEnabled(true);
});
@ -260,27 +256,6 @@ public class EvaluationPanel extends JPanel {
rm.setSelected(true);
});
latexExport.addActionListener(e -> {
SwingUtilities.invokeLater(() -> {
File file = null;
JFileChooser chooser = new JFileChooser(FileSystemView.getFileSystemView().getHomeDirectory());
chooser.setPreferredSize(new Dimension(800, 700));
chooser.setFileFilter(new FileNameExtensionFilter("LaTeX-Datei, (*.tex)", "tex", "text"));
chooser.setMultiSelectionEnabled(false);
chooser.setFileSelectionMode(JFileChooser.FILES_ONLY);
if (chooser.showSaveDialog(this) == JFileChooser.APPROVE_OPTION) {
//System.out.println ("Datei "+chooser.getSelectedFile()+ " ausgewählt.");
file = chooser.getSelectedFile();
String filename = file.getAbsolutePath().contains(".tex") ? file.getAbsolutePath() : file.getAbsolutePath().concat(".tex");
File withExtension = new File(filename);
final File input = withExtension;
((Presenter) view.getPresenter()).startResultExport(model, input);
}
});
});
clearTable.addActionListener(e -> {
SwingUtilities.invokeLater(() -> {
int n = model.getDataVector().size();
@ -289,7 +264,6 @@ public class EvaluationPanel extends JPanel {
currentRowOfTypes--;
}
this.revalidate();
latexExport.setEnabled(false);
clearTable.setEnabled(false);
exportData.setEnabled(false);
});
@ -311,8 +285,7 @@ public class EvaluationPanel extends JPanel {
if (chooser.showOpenDialog(this) == JFileChooser.APPROVE_OPTION) {
file = chooser.getSelectedFile();
String filename = file.getAbsolutePath().contains(".csv") ? file.getAbsolutePath() : file.getAbsolutePath().concat(".csv");
File withExtension = new File(filename);
final File input = withExtension;
final File input = new File(filename);
Thread t = new Thread(() -> ((Presenter) view.getPresenter()).startDatasetExportEvaluation(input));
t.start();
}
@ -363,7 +336,7 @@ public class EvaluationPanel extends JPanel {
*
* @param alg Steigung und y-Achsenabschnitt der Geraden, bestimmt durch die Schätzer
*/
public void drawLines(ArrayList<Double[]> alg) {
public void drawLines(List<Double[]> alg) {
Paint[] color = {Color.ORANGE, Color.RED, Color.MAGENTA};
String[] name = {"LMS", "RM", "TS"};
@ -387,12 +360,12 @@ public class EvaluationPanel extends JPanel {
String[] name = {"LMS", "RM", "TS"};
String[] nName = {"Brute-force LMS", "Brute-force RM", "Brute-force TS"};
Double m = Double.parseDouble(castedResults[0]);
Double b = Double.parseDouble(castedResults[1]);
double m = Double.parseDouble(castedResults[0]);
double b = Double.parseDouble(castedResults[1]);
plotPanel.addLineToPlot(m, b, color[alg], name[alg]);
Double nM = Double.parseDouble(castedResults[2]);
Double nB = Double.parseDouble(castedResults[3]);
double nM = Double.parseDouble(castedResults[2]);
double nB = Double.parseDouble(castedResults[3]);
plotPanel.addLineToPlot(nM, nB, Color.BLACK, nName[alg]);
}
@ -401,7 +374,7 @@ public class EvaluationPanel extends JPanel {
*
* @param points Liste der Geraden
*/
public void setDualPoints(LinkedList<Line> points) {
public void setDualPoints(List<Line> points) {
plotPanel = new PlotPanel();
plotPanel.setBorder(new TitledBorder("Plot"));
splitPane.setRightComponent(plotPanel);

@ -1,4 +1,4 @@
package view.panels;
package de.wwwu.awolf.view.panels;
import javax.swing.*;
import javax.swing.border.TitledBorder;

@ -1,6 +1,7 @@
package view.panels;
package de.wwwu.awolf.view.panels;
import model.Line;
import de.wwwu.awolf.model.Line;
import de.wwwu.awolf.presenter.util.Logging;
import org.jfree.chart.ChartFactory;
import org.jfree.chart.ChartPanel;
import org.jfree.chart.JFreeChart;
@ -13,8 +14,7 @@ import org.jfree.util.ShapeUtilities;
import javax.swing.*;
import java.awt.*;
import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;
/**
* Implementierung verschiedener Algorithmen zur Berechnung von Ausgleichsgeraden.
@ -51,14 +51,15 @@ public class PlotPanel extends JPanel {
*
* @param points Liste der Geraden
*/
public void createPlot(LinkedList<Line> points) {
public void createPlot(List<Line> points) {
if (!points.isEmpty()) {
try {
Thread thread = new Thread(() -> convertData(points));
thread.start();
thread.join();
} catch (InterruptedException e) {
e.printStackTrace();
Logging.logError(e.getMessage(), e);
Thread.currentThread().interrupt();
}
}
//createScatterPlot
@ -150,13 +151,11 @@ public class PlotPanel extends JPanel {
*
* @param points Liste der Geraden
*/
private void convertData(LinkedList<Line> points) {
private void convertData(List<Line> points) {
datapoints = new XYSeriesCollection();
ArrayList<Double> coordinates = new ArrayList<>();
series = new XYSeries("points");
for (Line p : points) {
series.add(p.getM().doubleValue(), p.getB().doubleValue() * (-1));
coordinates.add(p.getM());
series.add(p.getM().doubleValue(), p.getB() * (-1));
}
this.max = series.getMaxX();

@ -1,4 +1,4 @@
package view.panels.tabs;
package de.wwwu.awolf.view.panels.tabs;
import javax.swing.*;
import java.awt.*;

@ -1,4 +1,4 @@
package view.panels.tabs;
package de.wwwu.awolf.view.panels.tabs;
import javax.swing.*;
import java.awt.*;

@ -1,4 +1,4 @@
package view.panels.tabs;
package de.wwwu.awolf.view.panels.tabs;
import javax.swing.*;
import java.awt.*;

@ -1,6 +1,6 @@
package view.panels.tabs;
package de.wwwu.awolf.view.panels.tabs;
import view.panels.PlotPanel;
import de.wwwu.awolf.view.panels.PlotPanel;
import javax.swing.*;
import javax.swing.border.TitledBorder;

@ -1,216 +0,0 @@
package presenter;
import model.LineModel;
import presenter.evaluation.EvaluateAlgorithms;
import presenter.util.IntersectionComputer;
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.
*
* @Author: Armin Wolf
* @Email: a_wolf28@uni-muenster.de
* @Date: 10.09.2017.
*/
public abstract class AbstractPresenter implements Observer {
private final ExecutorService executor;
private LineModel model;
private MainFrame view;
private EvaluateAlgorithms eval;
/**
* Konstruktor
*
* @param model Modell
* @param view View
*/
public AbstractPresenter(LineModel model, MainFrame view) {
this.model = model;
this.view = view;
executor = Executors.newCachedThreadPool();
}
@Override
public void update(Observable o, Object arg) {
String[] result = ((String[]) arg);
String observable = result[0];
switch (observable) {
case "eval-dataset-generated":
SwingUtilities.invokeLater(() -> getView().addEvalDataset(getEval().getData()));
break;
case "eval-d":
SwingUtilities.invokeLater(() -> getView().appendEvalResult(result, Integer.parseInt(result[1]), false));
break;
case "eval-ds":
SwingUtilities.invokeLater(() -> getView().appendEvalResult(result));
break;
case "eval-t":
SwingUtilities.invokeLater(() -> getView().appendEvalResult(result, Integer.parseInt(result[1]), true));
break;
case "lines-res":
SwingUtilities.invokeLater(() -> getView().drawLineResult(result, Integer.parseInt(result[1])));
break;
case "lines-res-mult":
SwingUtilities.invokeLater(() -> getView().drawLineResults(result));
break;
case "lms":
SwingUtilities.invokeLater(() -> {
getView().visualizeLMS(Double.parseDouble(result[1]), Double.parseDouble(result[2]));
//getView().setLmsIsComplete(true);
getView().logHeading("Least Median of Squares");
getView().log("<b>m:</b> " + result[1]);
getView().log("<b>b:</b> " + result[2]);
getView().logSuccess("Berechnung wurde Erfolgreich durchgeführt <hr>");
});
break;
case "rm":
SwingUtilities.invokeLater(() -> {
getView().visualizeRM(Double.parseDouble(result[1]), Double.parseDouble(result[2]));
getView().logHeading("Repeated Median Estimator");
getView().log("<b>m:</b> " + result[1]);
getView().log("<b>b:</b> " + result[2]);
getView().logSuccess("Berechnung wurde Erfolgreich durchgeführt <hr>");
});
break;
case "ts":
SwingUtilities.invokeLater(() -> {
getView().visualizeTS(Double.parseDouble(result[1]), Double.parseDouble(result[2]));
getView().logHeading("Theil-Sen Estimator");
getView().log("<b>m:</b> " + result[1]);
getView().log("<b>b:</b> " + result[2]);
getView().logSuccess("Berechnung wurde Erfolgreich durchgeführt <hr>");
});
break;
case "import":
Double max = Double.parseDouble(result[1]);
Double current = Double.parseDouble(result[2]);
Integer progress = (int) (100 * (current / max));
//100% erreicht
SwingUtilities.invokeLater(() -> {
getView().showImportProgress(progress);
});
break;
case "export":
SwingUtilities.invokeLater(() -> {
getView().logHeading("Export der Daten als CSV");
getView().logSuccess("Export war Erfolgreich");
getView().log(result[1] + "<hr>");
});
break;
case "generator":
SwingUtilities.invokeLater(() -> {
getView().logSuccess("Generierung war Erfolgreich");
getView().log(result[1] + "<hr>");
});
break;
}
}
/**
* Startet das parallele Berechnen der Schnittpunkte der Geraden die im Modell enthalten sind.
*/
private void startIntersectionCalculation() {
try {
Thread thread = new Thread(() -> {
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();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
/**
* Wrapper Methode die das berechnen der Schnittpunkte anstößt und die Ergebnisse(Anzahl der Schnittpunkte)
* visuell darstellt.
*/
protected void computeIntersections() {
Thread t = new Thread(() -> {
long start, end;
start = System.currentTimeMillis();
startIntersectionCalculation();
end = System.currentTimeMillis();
System.out.println("Zeit: " + (end - start) / 1000);
});
t.start();
try {
t.join();
} catch (InterruptedException e) {
e.printStackTrace();
}
//darstellung der Ergebnisse
SwingUtilities.invokeLater(() -> {
getView().enableFunctionality();
getView().getProgressDialog().dispose();
getView().logHeading("Informationen zu dem aktuellen Modell");
getView().log("Anzahl der Geraden: " + getModel().getLines().size() + ".");
getView().log("Anzahl der Schnittpunkte: " + getModel().getNodes().size() + ".");
getView().logSuccess("Import war Erfolgreich! <hr>");
});
}
/**
* @return das zu grunde legende Modell
*/
public LineModel getModel() {
return model;
}
/**
* @param model das zu grunde legende Modell
*/
public void setModel(LineModel model) {
this.model = model;
}
/**
* @return die zu grunde legende View
*/
public MainFrame getView() {
return view;
}
/**
* @param view die zu grunde legende View
*/
public void setView(MainFrame view) {
this.view = view;
}
/**
* @return Evaluation
*/
public EvaluateAlgorithms getEval() {
return eval;
}
/**
* @param eval Evaluation
*/
public void setEval(EvaluateAlgorithms eval) {
this.eval = eval;
}
public ExecutorService getExecutor() {
return executor;
}
}

@ -1,105 +0,0 @@
package presenter.io;
import javax.swing.*;
import javax.swing.table.DefaultTableModel;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileWriter;
import java.io.IOException;
/**
* Implementierung verschiedener Algorithmen zur Berechnung von Ausgleichsgeraden.
*
* @Author: Armin Wolf
* @Email: a_wolf28@uni-muenster.de
* @Date: 08.09.2017.
*/
public class EvalResultLatexExport {
private DefaultTableModel model;
private File file;
/**
* Konstruktor
*
* @param model TableModel aus dem exportiert werden soll
* @param file Datei in die exportiert werden soll
*/
public EvalResultLatexExport(DefaultTableModel model, File file) {
this.model = model;
this.file = file;
}
/**
* Quelle: <url>https://en.wikibooks.org/wiki/LaTeX/Tables</url>
* \begin{tabular}{l*{3}{c}}
* Team & P & W & D & L & F & A & Pts \\\hline
* Manchester United & 6 & 4 & 0 & 2 & 10 & 5 & 12 \\
* Celtic & 6 & 3 & 0 & 3 & 8 & 9 & 9 \\
* Benfica & 6 & 2 & 1 & 3 & 7 & 8 & 7 \\
* FC Copenhagen & 6 & 2 & 1 & 3 & 5 & 8 & 7 \\
* \end{tabular}
*
* @return
*/
private String createOutputData() {
String split = "&";
StringBuilder doc = new StringBuilder();
doc.append("\\begin{tabular}{|l|r|r|r|}" + "\\hline\r\n");
for (int i = 0; i < model.getColumnCount(); i++) {
if (model.getValueAt(0, i).toString() != "" || model.getRowCount() > 5)
doc.append("\\textsc{" + model.getColumnName(i) + "}" + split);
}
doc.deleteCharAt(doc.lastIndexOf(split));
doc.append("\\\\\\hline" + "\r\n");
for (int i = 0; i < model.getRowCount() - 1; i++) {
for (int j = 0; j < model.getColumnCount(); j++) {
if (model.getValueAt(i, j).toString() != "") {
if (j == 0) {
doc.append("\\textbf{" + model.getValueAt(i, j).toString() + "}" + split);
} else {
Double val = Double.parseDouble((String) model.getValueAt(i, j));
doc.append(String.format("%.3f", val) + split);
}
}
}
if (model.getValueAt(i, 0) != "") {
doc.deleteCharAt(doc.lastIndexOf(split));
}
doc.append("\\\\\\hline" + "\r\n");
}
doc.append("\\end{tabular}");
return doc.toString();
}
/**
* das schreiben der Informationen über den Stream in die Datei
*/
public void writeFile() {
FileWriter fileWriter = null;
BufferedWriter bufferedWriter = null;
try {
fileWriter = new FileWriter(file);
bufferedWriter = new BufferedWriter(fileWriter);
bufferedWriter.write(createOutputData());
SwingUtilities.invokeLater(() -> {
JOptionPane.showMessageDialog(null, "Export war Erfolgreich!");
});
} catch (IOException e) {
e.printStackTrace();
} finally {
try {
bufferedWriter.close();
fileWriter.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}

@ -0,0 +1,14 @@
# Root logger option
log4j.rootLogger=INFO, file, stdout
# Direct log messages to a log file
log4j.appender.file=org.apache.log4j.RollingFileAppender
log4j.appender.file.File=D:\\Git\\master-implementierung\\LinearRegressionTool\\log4j\\app.log
log4j.appender.file.MaxFileSize=10MB
log4j.appender.file.MaxBackupIndex=10
log4j.appender.file.layout=org.apache.log4j.PatternLayout
log4j.appender.file.layout.ConversionPattern=%d{yyyy-MM-dd HH:mm:ss} %-5p %c{1}:%L - %m%n
# Direct log messages to stdout
log4j.appender.stdout=org.apache.log4j.ConsoleAppender
log4j.appender.stdout.Target=System.out
log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
log4j.appender.stdout.layout.ConversionPattern=%d{yyyy-MM-dd HH:mm:ss} %-5p %c{1}:%L - %m%n

@ -1,15 +1,15 @@
package presenter.algorithms.advanced;
package de.wwwu.awolf.presenter.algorithms.advanced;
import model.Interval;
import model.Line;
import model.Point;
import de.wwwu.awolf.model.Interval;
import de.wwwu.awolf.model.Line;
import de.wwwu.awolf.model.Point;
import org.junit.Before;
import org.junit.Test;
import presenter.util.IntersectionComputer;
import presenter.util.IntersectionCounter;
import de.wwwu.awolf.presenter.util.IntersectionComputer;
import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;
import static org.junit.Assert.*;
@ -48,7 +48,7 @@ public class LeastMedianOfSquaresEstimatorTest {
public void geEjValues() throws Exception {
Double[] expected = {36d, 50d, 60d, 74d, 108d};
ArrayList<Double> actual = lms.getEjValues(1d);
List<Double> actual = lms.getEjValues(1d);
assertArrayEquals(expected, actual.toArray());
}

@ -1,14 +1,15 @@
package presenter.algorithms.advanced;
package de.wwwu.awolf.presenter.algorithms.advanced;
import model.Line;
import model.Point;
import de.wwwu.awolf.model.Line;
import de.wwwu.awolf.model.Point;
import org.junit.Before;
import org.junit.Test;
import presenter.util.IntersectionComputer;
import de.wwwu.awolf.presenter.util.IntersectionComputer;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.LinkedList;
import java.util.List;
import static org.junit.Assert.*;
@ -30,8 +31,8 @@ public class TheilSenEstimatorTest {
Double[] y = {18d, 26d, 30d, 40d, 70d};
LinkedList<Line> lines = new LinkedList<>();
ArrayList<Point> intersections = new ArrayList<>();
List<Line> lines = new LinkedList<>();
List<Point> intersections = new ArrayList<>();
for (int i = 0; i < 5; i++) {
lines.add(new Line(x[i], y[i]));
@ -55,7 +56,7 @@ public class TheilSenEstimatorTest {
@Test
public void getOpenIntervalElements() throws Exception {
ArrayList<Point> intersectionInInterval = estimator.getOpenIntervalElements(-1.4d, -0.67d);
List<Point> intersectionInInterval = estimator.getOpenIntervalElements(-1.4d, -0.67d);
double[] expected = {-1.375, -1.333, -1.0};
double[] actual = new double[3];
for (int i=0;i<intersectionInInterval.size();i++) {

@ -1,10 +1,10 @@
package presenter.util;
package de.wwwu.awolf.presenter.util;
import org.junit.Before;
import org.junit.Test;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import static org.junit.Assert.*;
@ -28,8 +28,7 @@ public class FastElementSelectorTest {
@Test(expected = IndexOutOfBoundsException.class)
public void testIndexOutOfBoundsException() {
ArrayList emptyList = new ArrayList();
FastElementSelector.randomizedSelect(emptyList, 42);
FastElementSelector.randomizedSelect(Collections.emptyList(), 42);
}
}

@ -1,13 +1,13 @@
package presenter.util;
package de.wwwu.awolf.presenter.util;
import model.Line;
import model.LineModel;
import model.Point;
import de.wwwu.awolf.model.Line;
import de.wwwu.awolf.model.LineModel;
import de.wwwu.awolf.model.Point;
import org.junit.Before;
import org.junit.Test;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import static org.junit.Assert.*;
@ -34,7 +34,7 @@ public class IntersectionComputerTest {
@Test
public void compute() throws Exception {
ArrayList<Point> intersections = intersectionComputer.compute();
List<Point> intersections = intersectionComputer.compute();
double[] expectedX = {4.66, 7.11, 9.39};
double[] expectedY = {4.66, 7.11, 5.52};

@ -1,8 +1,8 @@
package presenter.util;
package de.wwwu.awolf.presenter.util;
import model.Interval;
import model.Line;
import model.LineModel;
import de.wwwu.awolf.model.Interval;
import de.wwwu.awolf.model.Line;
import de.wwwu.awolf.model.LineModel;
import org.junit.Before;
import org.junit.Test;
Loading…
Cancel
Save