====== Dritter Arbeits-Termin ======
**12.12.2019**

Wir haben heute versucht, die Methode für Schnittpunkte in unser Hauptprogramm zu implementieren, was leider noch nicht funktioniert hat. Es wurden mehrere andere Probleme aufgeworfen, zum Beispiel dass Geraden nicht aus der Geradenliste gelöscht werden, selbst wenn sie als sich schneidend erkannt wurden.
Zu nächster Woche haben wir uns vorgenommen, eine Methode zu schreiben, die testen kann, ob ein Punkt x auf einer Geraden g liegt.

<code python>

# -*- coding: utf-8 -*-
"""
Created on Thu Nov 28 15:22:24 2019

@author: Lukas
"""

import numpy as np
import math
from math import *
import turtle
import random as rn
from scipy.spatial import distance

turtle.speed(100)
turtle.ht()
#

anzahlKerne = 4

class Gerade(object):
    ov = (0,0,0)    #Ortsvektor
    rv = (0,0,0)    #Richtungsvektor
    l = 0;          #Laenge
    





###   Zuerst sollen n mal random punkte (x,y) in einem Feld maxx*maxy generiert werden und einer Liste zugewiesen werden

def generiereKernListe(n,maxx,maxy,abstand):
    
    liste=[]
    for c in range(n):
        x = rn.randint(-maxx,maxx)#rn.uniform(0,maxx)
        y = rn.randint(-maxy,maxy)#rn.uniform(0,maxy)
        
        #if (len(liste) > 0):            
        #    try:
        #        for x in len(liste):
        #            if (distance.euclidean(liste[x],(x,y)) < abstand == True):
        #                print("good")
        #            else:
        #                raise Exception("Fehler")
        #        liste.append((x,y))
        #    except:
        #        x = rn.uniform(0,maxx)
        #        y = rn.uniform(0,maxy)
        #        continue
        #    break
        #else: liste.append((x,y))
        liste.append((x,y))
    return liste

ker = generiereKernListe(anzahlKerne,300,300,0.1)
print("Kerne : ",ker)

###   Zunächst werden Funktionen deklariert, mit deren Hilfe das Programm Linien zwischen den Punkten untersucht

def zeichneLinie(start,ende):
    #   zeichnet eine Linie zwischen start und ende mithilfe einer turtle
    
    turtle.penup()
    turtle.goto(start)
    turtle.pendown()
    turtle.goto(ende)

    
def richtungLinie(start,ende):
    #   gibt den Richtungsvektor von start nach ende aus
    
    richtung  = np.subtract(ende,start)
    return richtung

def schnittTest(g1,g2):
    
    return np.linalg.solve([[g2.rv[0],-g1.rv[0]],[g2.rv[1],-g1.rv[1]]],[[g1.ov[0]-g2.ov[0]],[g1.ov[1]-g2.ov[1]]])

def vektorLänge(v2):     #Wir erwarten Start- und Endpunkt eines Vektors
    #   errechnet die Laenge eines Vektors
    
    v1 = np.array([0,0])
    
    math.sqrt((abs(v1[0]-v2[0])**2)+(abs(v1[1]-v2[1])**2))

def vektorNorm(v):
    return(1/sqrt(v[0]**2+v[1]**2)*v)
    
def punktAufG(p, g):
    return np.roots([g.rv[0],g.ov[0]-p[0]])    

#z = np.zeros(2)
#print(np.array([1,2]))

a = (0,0)
b = (30,30)
c = (50,0)
d = (50,70)

#Linien = [a,b,c,d]

#zeichneLinie(a,b)
#zeichneLinie(c,d)
#print(richtungLinie(c,b))

listeGeraden = []

for i in range(anzahlKerne):
    for k in range(anzahlKerne):
        if (i!=k):
            #zeichneLinie(ker[i],ker[k])
        
            #name = str(i)+" und "+str(k)
            eineGerade = Gerade()
            eineGerade.ov = np.array(ker[i])
            eineGerade.rv = np.subtract(ker[k],ker[i])
            eineGerade.l  = vektorLänge(eineGerade.rv)
            
            listeGeraden.append(eineGerade)
            #print(name)


print(listeGeraden)
print(listeGeraden[0].ov)
print(listeGeraden[0].rv)
print(listeGeraden[0].rv[0])

#print("Gerade 0 und 1 schneiden sich bei",schnittTest(listeGeraden[0],listeGeraden[49]))

counter = 0
schnitt = 0

#testet, welche geraden gelöscht werden sollen
for i in range(0, len(listeGeraden)):
    for k in range(0, len(listeGeraden)):
        counter=counter+1
        
        #   parallele Richtungsvektoren aussortieren MUSS NOCH GEMACHT WERDEN
        #if (vektorNorm(listeGeraden[i].rv) == vektorNorm(listeGeraden[k].rv)):
            
        #    try:
        #        punktAufG(listeGerade[i].ov,listeGeraden[k])
            #   dann testen ob ov des einen auf der anderten gerade liegt
        
        #   Werte der gerade ausgeben
        print("\ni.rv",listeGeraden[i].rv)
        print("i.ov",listeGeraden[i].ov)
        print("k.rv",listeGeraden[k].rv)
        print("k.ov",listeGeraden[k].ov)
        
        #   schneiden sich die Linien?
        z = schnittTest(listeGeraden[i],listeGeraden[k])
        print(z)
        if (z[0]<1 and z[0]>0 and z[1]<1 and z[1]>0):
            schnitt=schnitt+1
            #del listeGeraden[i]   #ACHTUNG: EIGENTLICH SOLL DIE LÄNGERE GELÖSCHT WERDEN
                
                #if (listeGeraden[i].l < listeGeraden[k].l):
                #    del listeGeraden[k]
                #else: del listeGeraden[i]

print(counter, " Schnitte : ", schnitt)

print(listeGeraden)

for i in range(0, len(listeGeraden)):
    zeichneLinie(listeGeraden[i].ov,listeGeraden[i].ov+listeGeraden[i].rv)

#zeichneLinie(ker[0],ker[1])
#zeichneLinie(ker[1],ker[2])
#zeichneLinie(ker[2],ker[0])

#zeichneLinie((10,40),(50,150))




###     das eigentlihe programm






turtle.done()

</code>

[Hung] Code für Normieren von Vektoren

<code python>

import numpy as np
from math import sqrt
v=np.array([3,4])
v1=np.array([4,3])
print(1/sqrt(v[0]**2+v[1]**2)*v)
print(1/sqrt(v1[0]**2+v1[1]**2)*v)

</code>

----

====== Code - Schnipsel ======

[Lukas] punktAufLinie - Methode 
18.12.2019

<code python>

#   liegt punkt p auf der geraden g = o + m*r?

def punktAufLinie(p,o,r):
    if(np.array_equal(p,o)): return True
    elif(np.array_equal(r,[0,0])): return False
    elif(r[1] == 0): 
        a = (p[0]-o[0])/r[0]
        if (o[1]+a*r[1] == p[1]):
            if(a<=1 and a>=0): return True
            else: return False
        else: return False
    else: 
        a = (p[1]-o[1])/r[1]
        if (o[0]+a*r[0] == p[0]):
            if(a<=1 and a >=0): return True
            else: return False
        else: return False

</code>

----