18.03.2020

Home | Code | >>

[Lukas] Sondierung der Lage: es werden bereits Zellen korrekt generiert, leider werden immer noch drei große Codeblöcke benötigt:

1. Es sollen Zellwände (Polygone in einer Ebene) sauber generiert werden, also nicht wie vorher beschrieben aus mehreren Dreiecken zusammengstückelt werden, sondern als eine Fläche erstellt werden. [geschafft]
2. Zusammengehörige Flächen sollen zu kompletten Zellen gemerged werden, sodass zum Schluss ein Konstrukt ausgegeben wird, das nur noch aus kompletten Zellen besteht, anstatt aus einem Haufen einzelner Zellwände
3. Dieses Gebilde soll durch ein Analyse-Programm untersucht werden können. Ziel ist es, nach Durchlauf dieses Programmes Scutoids in einer auffälligen Farbe einzufärben und einen Prozentanteil auszugeben.

Fall gegen Ende des Blocktermines der Code funktioniert, werden wir hoffentlich noch genügend Zeit haben, einige Testreihen durchzuführen und die Scutoids in verschiedenen Konstellationen zu generieren und die entsprechenden Daten auszuwerten. Das Endprodukt wäre dann eine Auswertung dieser Daten innerhalb diser Doku.

[UPDATE 18:32 Uhr] Nach langem hin und her präsentiere ich nun einen Code, der endlich ein sauberes Polygon aus einer gegeben, unsortierten Vertex-Liste generieren kann.

#   this script is going to create a polygon out of a random set of points
 
import numpy as np
import bpy    
 
def radianBetweenVectors(v1, v2, n):  
    #   berechnet den Zwischenwinkel zweier Vektoren unter Beachtung eines Normalenwinkels
    #   (später wird für n die Flächennormale der Zellwand eingesetzt, welche die Verbindung der
    #   beiden Knotenpunkte ist, zwischen denen sich die Zellwand befindet).
 
    a = v1[0]*v2[0] + v1[1]*v2[1] + v1[2]*v2[2]
    b = v1[0]*v2[1]*n[2] + v2[0]*n[1]*v1[2] + n[0]*v1[1]*v2[2] - v1[2]*v2[1]*n[0] - v2[2]*n[1]*v1[0] - n[2]*v1[1]*v2[0]
 
    rad = np.arctan2(b, a)
    if (rad < 0): rad = (2*np.pi) +rad
 
    deg = rad*180/np.pi
 
    #print(">> v02", rad, deg, "\n")
    return deg
 
 
def polySortListNEW(v_list, normal):
    #   soll eine Liste von Punkten im Kreis herum links herum anordnen
 
    #   falls es ein Dreieck ist, ist die Reihenfolge egal
    if (len(v_list) == 3):
        return v_list
 
    #   Startvariablen werden gesetzt
    geordnet = []
 
    start = v_list[0]
    aktu = start
    vv = np.subtract(v_list[0], v_list[1])  #   Vergleichswinkel, der zufällig gewählt wird (zeigt immer aus dem Kreis raus)
 
    geordnet.append(start)
 
    while True:
        print(">>", aktu)
 
        #   loop start values
        min_angle = 360        
        min_stelle = 0
 
        #   suche nach nächstem Punkt
        for v in range(0, len(v_list)):
            if (aktu[0] != v_list[v][0] or aktu[1] != v_list[v][1] or aktu[2] != v_list[v][2]):            
                dir = np.subtract(v_list[v], aktu)
                deg = radianBetweenVectors(vv, dir, normal)            #np.array([0,0,1]))
 
                if (deg < min_angle): 
                    min_angle = deg
                    min_stelle = v        
 
        geordnet.append(v_list[min_stelle])
        vv = np.subtract(v_list[min_stelle], aktu)
 
        aktu = v_list[min_stelle]        
        print("  >", aktu)
 
        if (aktu[0] == start[0] and aktu[1] == start[1] and aktu[2] == start[2]): break
 
    return geordnet
 
 
def genPoly(liste, normal):
    #   sortiert die gegebene Vertecie- Liste im Kreis herum und erstellt dann daraus eine saubere Fläche.
 
    geordnet = polySortListNEW(liste, normal)
    f = []
 
    for i in range(0, len(geordnet)):
        f.append(i)
 
    facelist = []
    facelist.append(f)
 
    generateObj("Poly", geordnet, facelist)
 
 
def generateObj(name, verts, faces, loc = np.array([0,0,0]), col = ( 1.0, 1.0, 1.0, 1.0 )):
    #   generiert ein Objekt mit den Übergebenen Parametern (Name, Eckpunkte, Seiten)
 
    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)
 
 
 
#   kleine Testcode: aus den gegebenen Vertex-Punkten wird automatisch ein einflächiges Polygon kreiert.
liste = [np.array([1,0,-2]), np.array([-1.5,0,-1]), np.array([-1,0,2]), np.array([1.5,0,1]), np.array([2,0,-1])]
genPoly(liste, np.array([0,-1,0]))