irgendwie geändert

U10/OOP_10_HessmannNiehuesPedersen.tex

@@ -0,0 +1,27 @@
+\input{../src/header}											% bindet Header ein (WICHTIG)
+
+\usepackage{svg}
+
+\newcommand{\dozent}{Prof. Dr. Claudia Müller-Birn, Barry Linnert}					% <-- Names des Dozenten eintragen
+\newcommand{\tutor}{Thierry Meurers}						% <-- Name eurer Tutoriun eintragen
+\newcommand{\tutoriumNo}{10}				% <-- Nummer im KVV nachschauen
+\newcommand{\ubungNo}{10}									% <-- Nummer des Übungszettels
+\newcommand{\veranstaltung}{Objektorientierte Programmierung}	% <-- Name der Lehrveranstaltung eintragen
+\newcommand{\semester}{SoSe 17}						% <-- z.B. SoSo 17, WiSe 17/18
+\newcommand{\studenten}{Stefaan Hessmann, Jaap Pedersen, Mark Niehues}			% <-- Hier eure Namen eintragen
+
+% /////////////////////// BEGIN DOKUMENT /////////////////////////
+\begin{document}
+\input{../src/titlepage}										% erstellt die Titelseite
+
+
+\section{Aufgabe 1}
+Auf der nächsten Seite befindet sich ein kleiner (unvolltändiger) Sketch wie das Programm strukturiert sein könnte. Klassen mit ähnlichem Verhalten (eckig, rund) werden zu abstrakten Subclassen der abstrakten oberklasse aller geometrischen Objekte zusammengefasst. Der Figurehandler verwaltet die Objekte. Dort kann ggf. eine GUI implementiert werden. Die Test-Klasse ist wie der Name schon sagt zum Testen da.
+\begin{figure}[htbp]
+    \centering
+    \def\svgwidth{\columnwidth}
+    \input{diagram.pdf_tex}
+\end{figure}
+
+%/////////////////////// END DOKUMENT %/////////////////////////
+\end{document}

U10/src/Dreieck.java

@@ -0,0 +1,9 @@
+/**
+ * Created by jaap on 03.07.17.
+ */
+public class Dreieck extends EckigeFigur {
+    public Dreieck(float[][] coordinates) {
+        super(coordinates);
+    }
+
+}

U10/src/EckigeFigur.java

@@ -0,0 +1,33 @@
+/**
+ * Created by jaap on 03.07.17.
+ */
+public abstract class EckigeFigur extends GeometryBase {
+    private int n_deges;
+    public float[][] coordinates;
+
+    public EckigeFigur(float[][] coordinates) {
+        this.coordinates = coordinates;
+    }
+
+    public void bewegefigur(float[] newPos) {
+        for (float[] coordinate : getCoordinates()) {
+            coordinate[0] += newPos[0];
+            coordinate[1] += newPos[1];
+        }
+    }
+
+    boolean ueberlapp(GeometryBase figure) {
+        if (figure instanceof RundeFigur) {
+            return Utilities.ueberlapptKreisEck((RundeFigur) figure, this);
+        } else if (figure instanceof EckigeFigur) {
+            return Utilities.ueberlapptEckEck((EckigeFigur) figure, this);
+        } else {
+            System.out.println("Nicht unterstützte Figur");
+            return false;
+        }
+    }
+
+    public float[][] getCoordinates() {
+        return coordinates;
+    }
+}

U10/src/FigureHandler.java

@@ -0,0 +1,64 @@
+import java.util.ArrayList;
+
+/**
+ * Organizes Figures
+ */
+public class FigureHandler {
+    private ArrayList<GeometryBase> figures = new ArrayList<>();
+    private int n_kreis = 1;
+    private int n_viereck = 1;
+    private int n_dreieck = 1;
+    private int n_punkt = 1;
+
+
+    public void erstelleKreis(float[] mittelpunkt, float radius){
+        Kreis newKreis = new Kreis(mittelpunkt, radius);
+        newKreis.setName("Kreis"+n_kreis);
+        n_kreis++;
+
+        figures.add(newKreis);
+    }
+
+    public void erstelleViereck(float[][] coordinates){
+        Viereck newViereck = new Viereck(coordinates);
+        newViereck.setName("Viereck"+n_viereck);
+        n_viereck++;
+
+        figures.add(newViereck);
+    }
+
+    public void erstelleDreieick(float[][] coordinates){
+        Dreieck newDreieck = new Dreieck(coordinates);
+        newDreieck.setName("Dreieck"+n_dreieck);
+        n_dreieck++;
+
+        figures.add(newDreieck);
+    }
+
+    public void erstellePunkt(float[] mittlepunkt) {
+        Punkt newPunkt = new Punkt(mittlepunkt);
+        newPunkt.setName("Punkt"+n_punkt);
+        n_punkt++;
+
+        figures.add(newPunkt);
+    }
+
+    public void printList(){
+        for (GeometryBase figure: figures) {
+            System.out.println(figure.getName());
+        }
+    }
+
+    /**
+     * Überprüft ob sich geometrische Objekte überlappen
+     */
+    public void overlaps(){
+        for(int i = 0; i < figures.size(); i++){
+            for(int j = 0; j<i; j++){
+                if(figures.get(i).ueberlapp(figures.get(j))){
+                    System.out.println(figures.get(i).getName()+" überlappt "+figures.get(j).getName());
+                }
+            }
+        }
+    }
+    }

U10/src/GeometryBase.java

@@ -0,0 +1,18 @@
+/**
+ * Created by jaap on 03.07.17.
+ */
+public abstract class GeometryBase {
+    public String name;
+
+    public void setName(String name){
+        this.name = name;
+    }
+
+    public String getName() {
+        return name;
+    }
+
+    abstract void bewegefigur(float[] newPos);
+
+    abstract boolean ueberlapp(GeometryBase figure);
+}

U10/src/Kreis.java

@@ -0,0 +1,10 @@
+/**
+ * Created by jaap on 03.07.17.
+ */
+public class Kreis extends RundeFigur {
+    //constructor
+    public Kreis(float[] mittelpunkt, float radius) {
+        super(mittelpunkt, radius);
+    }
+
+}

U10/src/Punkt.java

@@ -0,0 +1,9 @@
+/**
+ * Created by jaap on 03.07.17.
+ */
+public class Punkt extends RundeFigur {
+    public Punkt(float[] mittelpunkt){
+        super(mittelpunkt, 0);
+    }
+
+}

U10/src/RundeFigur.java

@@ -0,0 +1,38 @@
+/**
+ * Created by jaap on 03.07.17.
+ */
+public abstract class RundeFigur extends GeometryBase {
+    public float[] mittelpunkt;
+    public float radius;
+
+    public float[] getMittelpunkt() {
+        return mittelpunkt;
+    }
+
+    public void setMittelpunkt(float mittelpunkt[]) {
+        this.mittelpunkt = mittelpunkt;
+    }
+
+    public float getRadius() {
+        return radius;
+    }
+
+    public void setRadius(float radius) {
+        this.radius = radius;
+    }
+
+    //Konstruktor
+    public RundeFigur(float[] mittelpunkt, float radius){
+        this.mittelpunkt = mittelpunkt;
+        this.radius = radius;
+    }
+
+    public void bewegefigur(float[] neuermittelpunkt) {
+        setMittelpunkt(neuermittelpunkt);
+    }
+
+    public boolean ueberlapp(GeometryBase figure) {
+        // TO DO
+        return true;
+    }
+}

U10/src/Test.java

@@ -0,0 +1,27 @@
+/**
+ * Basic testing shit
+ */
+public class Test {
+    public static void main(String[] args) {
+        FigureHandler fgh = new FigureHandler();
+
+        // Create some Objects
+        float[][] coordinates = {{1,1}, {2,1}, {3,4}};
+        fgh.erstelleDreieick(coordinates);
+
+        coordinates = new float[][] {{1,1}, {2,1}, {3,4}, {5,6}};
+        fgh.erstelleViereck(coordinates);
+
+        float[] mittelpunkt = {3,3};
+        fgh.erstelleKreis(mittelpunkt, 2);
+
+        float[] punkt = {8,8};
+        fgh.erstellePunkt(punkt);
+
+        // Print List
+        fgh.printList();
+
+        // Check if something overlaps
+        fgh.overlaps();
+    }
+}

U10/src/Utilities.java

@@ -0,0 +1,92 @@
+/**
+ * Created by jaap on 03.07.17.
+ */
+import java.lang.Math;
+public final class Utilities {
+
+    // klasse fuer methode zur Ueberpruefung, ob sich zwei Geometrische Figuren ueberlappen
+
+    public static boolean ueberlapptKreisKreis(RundeFigur A, RundeFigur B){
+        float[]m_a = A.getMittelpunkt();
+        float[]m_b = B.getMittelpunkt();
+        //Berechne den Abstand der Mittelpunkte, wenn kleiner als die Summe der Radien, dann ueberlappen sich die Kreise
+        double abstand = Math.sqrt(Math.pow(m_a[0]-m_b[0],2)+Math.pow(m_a[1]-m_b[1],2));
+        return(abstand <= (A.getRadius()+B.getRadius()));
+    }
+
+    public static boolean ueberlapptKreisEck(RundeFigur A, EckigeFigur B){
+        float[][] ecken = B.getCoordinates();
+        // fuer alle Seitenkanten der Eckigen Figur wird der minimale Abstand zum Mittelpunkt des Kreises berechnet
+        for(int i = 0; i < ecken.length - 1; i++){
+            float[][] tmp_linie = {ecken[i+1], ecken[i]};
+            if(schneidetKreisLinie(A, tmp_linie)){
+                return true;
+            }
+        }
+        return false;
+    }
+
+    public static boolean ueberlapptEckEck(EckigeFigur A, EckigeFigur B){
+
+        return false;
+    }
+
+    private static float[] linieSchneidetLinie(float[][] linieA, float[][] linieB){
+        float[] mUndB1 = mUndB(linieA);
+        float[] mUndB2 = mUndB(linieB);
+        float m1 = mUndB1[0];
+        float b1 = mUndB1[1];
+        float m2 = mUndB2[0];
+        float b2 = mUndB2[1];
+        float xSchnitt = (b2 - b1)/(m1 - m2);
+        float ySchnitt = m1*xSchnitt + b1;
+        float[] Schnittpunkt = {xSchnitt, ySchnitt};
+
+
+        return Schnittpunkt;
+    }
+
+    private static float[] mUndB(float[][] linie){
+        float m = (linie[1][1]-linie[0][1])/(linie[1][0]-linie[0][0]);
+        float b = (linie[0][1] - m*linie[0][0]);
+        float[] mUndB = {m, b};
+        return mUndB;
+    }
+
+    private static boolean schneidetKreisLinie(RundeFigur A, float[][] linie){
+        // berechne Richtungsvektor
+        float[] strecke = {linie[1][0]-linie[0][0], linie[1][1]-linie[0][1]};
+        // Berechne Abstandsvektor vom Mittelpunkt zum Anfangspunkt der Linie
+        float[] b = {linie[0][0]-A.getMittelpunkt()[0], linie[0][1]-A.getMittelpunkt()[1]};
+        // Projiziere b auf die Strecke und normiere auf strecke um minimalsten Abstand zu bekommen,
+        // t entspricht skalierungsfaktor
+        float t = skalarProdukt(strecke,b)/skalarProdukt(strecke,strecke);
+        // wenn t > 1 bzw. t<0 setze t=1 bzw. t=0, damit werden die Endpunkte zur Abstandsberechnung genommen
+        if (t>1){
+            t = (float) 1.0;
+        } else if(t<0){
+            t = (float) 0.0;
+        }
+        float[] naechsterPunkt = {strecke[0]*t+linie[0][0],strecke[1]*t+linie[0][1]};
+        double d =abstand(naechsterPunkt,A.getMittelpunkt());
+        return d<=A.getRadius();
+
+    }
+
+    private static float skalarProdukt(float[] a, float[] b){
+        //helper funktion zur berechnung des Skalarprodukts
+        float sum = 0;
+        for(int i = 0; i < a.length; i++) {
+            sum += a[i] * b[i];}
+        return sum;
+    }
+    private static double abstand(float[] a, float[] b){
+        //helper funktion zur abstandberechnung zwischen zwei Punkten
+        return Math.sqrt(Math.pow(a[0]-b[0],2)+Math.pow(a[1]-b[1],2));
+    }
+}
+
+
+
+
+

U10/src/Viereck.java

@@ -0,0 +1,9 @@
+/**
+ * Created by jaap on 03.07.17.
+ */
+
+public class Viereck extends EckigeFigur {
+    public Viereck(float[][] coordinates) {
+        super(coordinates);
+    }
+}