Mathesis Wiki

Diese Seite ist nicht editierbar. Sie können den Quelltext sehen, jedoch nicht verändern. Kontaktieren Sie den Administrator, wenn Sie glauben, dass hier ein Fehler vorliegt.
----

====== Zehnter Arbeitstermin ======
**14.02.2020**

[[ws1920:update_03|<<]] | [[ws1920:scutoids|Home]]

[Lukas] Heute habe ich versucht, eine neue Funktion zur Modellierung der Zellwände zu schreiben, sodass diese nicht mehr quick and dirty generiert wird, sondern sauber und ordentlich alle Seiten miteinander verbunden werden.
Meine Idee war, alle Punkte der Fläche durch Geraden zu verbinden, auf Schnittpunkte zu testen und dann alle Geraden zu löschen, die sich schneiden. Dann iteriere ich über die verbleibenden Geraden und hangel mich praktisch einmal im Kreis an diesen entlang, um die richtige Reihenfolge der Eckpunkte zu erlangen. Hat dies geklappt, wir eine Face mit den vertecies in der entsprechenden Reihenfolge generiert. 

Code Einzeltest:

<code python>
import bpy
import numpy as np
import random

#   soll jetzt die richtige Reihenfolge auswählen und dann das 
#   entsprechende Polygon ausgeben

#   muss nicht testen, ob die Punkte in einer Ebene liegen, da
#   dies auf jeden Fall der Fall ist.

class Gerade(object):
    ov = (0,0,0)
    rv = (0,0,0)
    kreuzt = False
    kerne = [0,0]
    
    def __init__(self,ov,rv,kerne):
        self.ov = ov
        self.rv = rv
        self.kerne = kerne
    
    def punktAn(self,k):
        punkt = np.add(self.ov,(self.rv[0]*k,self.rv[1]*k,self.rv[2]*k))
        return punkt

def generateObj(name, verts, faces, loc = np.array([0,0,0]), col = ( 1.0, 1.0, 1.0, 1.0 )):
    mymesh = bpy.data.meshes.new(name)
    myobject = bpy.data.objects.new(name,mymesh)
         
    mymat = bpy.data.materials.new("Mesh_mat")
    mymat.diffuse_color = col
    mymesh.materials.append(mymat)
    
    myobject.location = loc 
    bpy.context.collection.objects.link(myobject)

    mymesh.from_pydata(verts,[],faces)
    mymesh.update(calc_edges=True)
    
def zeichnePunkt(pos, name = "Punkt"):
    verts = [(0.1,0.1,0.1),(-0.1,0.1,0.1),(-0.1,-0.1,0.1),(0.1,-0.1,0.1)
            ,(0.1,0.1,-0.1),(-0.1,0.1,-0.1),(-0.1,-0.1,-0.1),(0.1,-0.1,-0.1)]
    faces = [(0,1,2,3),(4,5,6,7),(0,1,5,4),(1,2,6,5),(2,3,7,6),(3,0,4,7)]
    generateObj(name,verts,faces,pos)
    
def schnittTest(g1,g2):
    a = [[g2.rv[0],-g1.rv[0]],[g2.rv[1],-g1.rv[1]]]
    b = [[g1.ov[0]-g2.ov[0]],[g1.ov[1]-g2.ov[1]]]
    
    c = [[g2.rv[2],-g1.rv[2]],[g2.rv[1],-g1.rv[1]]]
    d = [[g1.ov[2]-g2.ov[2]],[g1.ov[1]-g2.ov[1]]]
    
    e = [[g2.rv[2],-g1.rv[2]],[g2.rv[0],-g1.rv[0]]]
    f = [[g1.ov[2]-g2.ov[2]],[g1.ov[0]-g2.ov[0]]]
    
    #print("Det :",np.linalg.det(a))
    if (np.linalg.det(a) != 0):
        return np.linalg.solve(a,b)[0][0]
    elif (np.linalg.det(c) != 0):
        print(">>     ERGEBNIS")
        return np.linalg.solve(c,d)[0][0]
    elif (np.linalg.det(e) != 0):
        print(">>     SINBEGRE")
        return np.linalg.solve(e,f)[0][0]
    else: return None

def swap(liste):
    if (len(liste) == 2):
        zw = liste[0]
        liste[0] = liste[1]
        liste[1] = zw
        return liste
    else: return None

def genMesh(liste):
    #   alle Möglichen Geraden berechnen und in eine Liste speichern
    if (len(liste) > 2):
        gerListe = []
        for i in range(0, len(liste)):
            for j in range(i+1, len(liste)):
                gerListe.append(Gerade(liste[i], liste[j]-liste[i], [i,j]))

    #   alle kreuzenden markieren
        for i in range(0, len(gerListe)):
            for j in range(i+1, len(gerListe)):
                z = schnittTest(gerListe[i], gerListe[j])
                print(z)
                if (z != None):
                    if (z < 1 and z > 0):
                        gerListe[i].kreuzt = True
                        gerListe[j].kreuzt = True

    #   alle markierten löschen
        i = 0
        while (i < len(gerListe)):
            if (gerListe[i].kreuzt == True):
                del gerListe[i]
                i = i-1
            else: i = i+1

    #   erste gerade der Liste auswählen, von Gerade zu gerade springen und
    #   die Indices speichern
        face = []
        
        for i in range(0, len(gerListe)):
            if (len(face) > 0):
                if (gerListe[i].kerne[0] in face):
                    swap(gerListe[i].kerne)
            face.append(gerListe[i].kerne[0])
        print(face)
        for i in range(0, len(gerListe)):
            print(gerListe[i].kerne)
        
        face = []
        
        #swap(gerListe[1].kerne)
        #gerListe.append(gerListe[1])
        #del gerListe[1]
        
        for i in range(0, len(gerListe)):
            print("Gerade",i,"Kerne",gerListe[i].kerne)
        
        current = 0
        while (True):
            face.append(gerListe[current].kerne[0])
            if (gerListe[current].kerne[1] != gerListe[0].kerne[0]):
                for i in range(0, len(gerListe)):
                    if (gerListe[current].kerne[1] == gerListe[i].kerne[0]):
                        current = i
                        break
            else: break
        print(face)
        
        generateObj("Fläche", liste, [face])
    
    
    
    
    
    
#   CODE


#   Punkte einlesen
#liste = [np.array([1,0,0]), np.array([1,4,0]), np.array([2,3.6,0]), np.array([3,3,0]), np.array([4,2,0]), np.array([0,2,0]), np.array([4,1,0]), np.array([2,0,0])]
liste = [np.array([0,0,1]), np.array([0,2,0]), np.array([0,-2,1]), np.array([0,-3,-2]), np.array([0,-5,-1]), np.array([0,-5,0])]
for i in range(0, len(liste)):
    zeichnePunkt(liste[i])

genMesh(liste)
</code>


Dies funktioniert zwar im Einzeltest super, leider nicht in der Implementation in das komplette Programm. Vielleicht liegen hier die vertecies nicht genau in der Fläche, sodass eine Endlosschleife entsteht. Dem könnte ich entgegenwirken, indem ich die Geraden aus der Liste lösche, sobald ich mich einmal an ihnen entlang gehangelt habe?
Mathesis Wiki

Benutzer-Werkzeuge

Webseiten-Werkzeuge

Seiten-Werkzeuge
