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.

# -*- 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()

[Hung] Code für Normieren von Vektoren

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)

[Lukas] punktAufLinie - Methode 18.12.2019

#   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