14.02.2020

<< | Home | Text

Code Einzeltest:

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)