-----
====== Code: Arbeitstermin 03 ======
**12.12.2019**
[[ws1920:cd_02|<<]] | [[ws1920:scutoids|Home]] | [[ws1920:arbeitstermin_03|Text]] | [[ws1920:cd_04|>>]]
Aktuelle Programmversion
# -*- 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)
----
====== Code - Schnipsel ======
[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
----