Unterschiede

Hier werden die Unterschiede zwischen zwei Versionen gezeigt.

--- ws1920:cd_03 [2020/03/25 16:57]
Zetraeder angelegt
+++ ws1920:cd_03 [2020/03/25 16:57] (aktuell)
Zetraeder
@@ Zeile 2: / Zeile 2: @@
 ====== Code: Arbeitstermin 03 ======
-**19.12.2019**
+**12.12.2019**
 [[ws1920:cd_02|<<]] | [[ws1920:scutoids|Home]] | [[ws1920:arbeitstermin_03|Text]] | [[ws1920:cd_04|>>]]
 Aktuelle Programmversion
+<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
+.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>
+----

Mathesis Wiki

Benutzer-Werkzeuge

Webseiten-Werkzeuge

Unterschiede

Seiten-Werkzeuge