import rhinoscriptsyntax as rs # Importiert die RhinoScriptSyntax-Bibliothek import random as ran # Importiert die Random-Bibliothek zur Erzeugung zufaelliger Werte import flipped_classroom_lib as fc # Importiert eine benutzerdefinierte Bibliothek fuer spezielle Funktionen reload(fc) # Laedt die benutzerdefinierte Bibliothek neu rs.DeleteObjects(rs.AllObjects()) # Loescht alle Objekte aus der Rhino-Umgebung ############################################################### # Your Panel functions... ############################################################### def my_panel(points, scale): #rs.AddSrfPt(points) # Default-Flaeche erstellen (P0,P1,P2,P3) = points # Punkte der Flaeche benennen rs.AddLine(P0,P2) # Erste Diagonale zeichnen d_cen1 = rs.VectorDivide(rs.VectorAdd(P0,P2),2) # Mittelpunkt der ersten Diagonale berechnen rs.AddPoint(d_cen1) # Punkt am Mittelpunkt der ersten Diagonale einfuegen rs.AddLine(P1,P3) # Zweite Diagonale zeichnen d_cen2 = rs.VectorDivide(rs.VectorAdd(P1,P3),2) # Mittelpunkt der zweiten Diagonale berechnen rs.AddPoint(d_cen2) # Punkt am Mittelpunkt der zweiten Diagonale einfuegen center_pt = rs.VectorDivide(rs.VectorAdd(d_cen1,d_cen2),2) # Mittelpunkt zwischen den Diagonalzentren berechnen rs.AddPoint(center_pt) # Punkt am Zentrum der Flaeche einfuegen if not(rs.PointCompare(d_cen1,d_cen2)): # Ueberpruefen, ob die beiden Diagonalzentren unterschiedlich sind rs.AddLine(d_cen1,d_cen2) # Linie zwischen den Diagonalzentren zeichnen # Vektoren fuer das Kreuzprodukt vorbereiten, um die Normale zu erhalten vec1 = rs.VectorSubtract(P0, center_pt) vec2 = rs.VectorSubtract(center_pt, P3) normal = rs.VectorCrossProduct(vec1, vec2) # Flaechennormale im Zentrum berechnen u_normal = rs.VectorUnitize(normal) # Normalenvektor normieren (Laenge 1) su_normal = rs.VectorScale(u_normal, scale) # Normalisierten Normalenvektor skalieren normal_pt = rs.VectorAdd(center_pt, su_normal) # Punkt an der Spitze des Normalenvektors berechnen rs.AddPoint(normal_pt) # Punkt an der Spitze des Normalenvektors einfuegen rs.AddLine(center_pt, normal_pt) # Linie zur Darstellung des Normalenvektors zeichnen # Pyramide erstellen rs.AddSrfPt([P0, normal_pt, P1]) # Dreieckige Flaeche erstellen rs.AddSrfPt([P1, normal_pt, P2]) # Dreieckige Flaeche erstellen rs.AddSrfPt([P2, normal_pt, P3]) # Dreieckige Flaeche erstellen rs.AddSrfPt([P3, normal_pt, P0]) # Dreieckige Flaeche erstellen def my_panel_frame(points, scale, offset): (P0,P1,P2,P3) = points # Punkte der Flaeche benennen pline = rs.AddPolyline([P0,P1,P2,P3,P0]) # Geschlossene Polylinie erstellen d_cen1 = rs.VectorDivide(rs.VectorAdd(P0,P2),2) # Mittelpunkt der ersten Diagonale berechnen d_cen2 = rs.VectorDivide(rs.VectorAdd(P1,P3),2) # Mittelpunkt der zweiten Diagonale berechnen center_pt = rs.VectorDivide(rs.VectorAdd(d_cen1,d_cen2),2) # Mittelpunkt zwischen den Diagonalzentrumpunkte berechnen #prepare vectors for cross product to get normal vec1 = rs.VectorSubtract(P0, center_pt) vec2 = rs.VectorSubtract(center_pt, P3) normal = rs.VectorCrossProduct(vec1, vec2) # Flaeche im Zentrum berechnen u_normal = rs.VectorUnitize(normal) # Normalenvektor (Laenge 1) su_normal = rs.VectorScale(u_normal, scale) # Normalenvektor skalieren normal_pt = rs.VectorAdd(center_pt, su_normal) # Punkt an der Spitze des Normalenvektors berechnen rs.AddPoint(normal_pt) # Punkt an der Spitze des Normalenvektors einfuegen rs.AddLine(center_pt, normal_pt) # Linie zur Darstellung des Normalenvektors zeichnen off_l = rs.OffsetCurve(pline, center_pt, offset, u_normal) # Versatzkurve erstellen, Orientierung kann variieren #off_l = rs.ScaleObject(pline, center_pt, [scale,scale,scale], copy=True) s_points = rs.CurvePoints(off_l) # Punkte der Versatzkurve abrufen # Vorderseite des Rahmens erstellen rs.AddSrfPt([P0, s_points[0],s_points[1], P1]) # Erste Rahmenseite erstellen rs.AddSrfPt([P1, s_points[1],s_points[2], P2]) # Zweite Rahmenseite erstellen rs.AddSrfPt([P2, s_points[2],s_points[3], P3]) # Dritte Rahmenseite erstellen rs.AddSrfPt([P3, s_points[3],s_points[0], P0]) # Vierte Rahmenseite erstellen off_l_s = rs.CopyObject(off_l, su_normal) # Versatzkurve entlang des Normalenvektors verschieben ss_points = rs.CurvePoints(off_l_s) # Punkte der verschobenen Versatzkurve abrufen rs.AddSrfPt([ss_points[0], s_points[0],s_points[1], ss_points[1]]) # Rahmenseite erstellen rs.AddSrfPt([ss_points[1], s_points[1],s_points[2], ss_points[2]]) # Rahmenseite erstellen rs.AddSrfPt([ss_points[2], s_points[2],s_points[3], ss_points[3]]) # Rahmenseite erstellen rs.AddSrfPt([ss_points[3], s_points[3],s_points[0], ss_points[0]]) # Rahmenseite erstellen """ def my_panel_grid(points, split): (P0,P1,P2,P3) = points # Punkte der Flaeche benennen L_L = rs.AddLine(P0,P3) # Erste Diagonale zeichnen R_L = rs.AddLine(P1,P2) # Zweite Diagonale zeichnen v_lines = [L_L, R_L] # Liste mit Diagonalen edge_pts = [] # Liste fuer Randpunkte for e in v_lines: rs.RebuildCurve(e, 1, split) # Kurve rekonstruieren mit bestimmter Segmentanzahl edge_pts.extend(rs.CurvePoints(e)) # Punkte der Diagonalen abrufen und speichern grid_pts = [] # Liste fuer Gitterpunkte for i in range (split): hline = rs.AddLine(edge_pts[i], edge_pts[i+split]) # Horizontale Linie zwischen Punkten erstellen rs.RebuildCurve(hline, 1, split) # Linie rekonstruieren edge_pts.extend(rs.CurvePoints(hline)) # Punkte der horizontalen Linie abrufen for i,p in enumerate(grid_pts): rs.AddPoint(p) # Punkt fuer jedes Gitterfeld einfuegen #cmd = "-Dot {} {} _Enter ".format(i,p) #rs.Command(cmd, False) """ ###################### rs.EnableRedraw(False) # Deaktiviert das Redraw, um die Leistung zu verbessern quad = [[0,0,0], [10,0,0], [10,0,12], [0,0,12]] # Beispielhafte Definition einer quadratischen Flaeche quad = [[0,0,0], [10,4,0], [10,4,12], [0,0,12]] # Beispielhafte Definition einer quadratischen Flaeche quad = [[0,0,0], [10,0,0], [10,2,12], [0,2,12]] # Beispielhafte Definition einer quadratischen Flaeche quad = [[0,0,0], [10,0,0], [8,2,12], [2,2,12]] # Beispielhafte Definition einer quadratischen Flaeche quad = [[0,0,0], [10,2,0], [10,-2,12], [0,2,10]] # Beispielhafte Definition einer quadratischen Flaeche #result_list = fc.PEF_single_face(quad) # Ergebnis fuer eine einzelne Flaeche generieren #result_list = fc.PEF_face(6, 11, 8.0, 5.0, 30) # Ergebnis fuer mehrere Flaechen generieren #result_list = fc.PEF_face_w(6, 10, 1.0, 5.0, 30, 1.0) # Ergebnis fuer ein spezifisches Muster generieren result_list = fc.PEF_pantheon() # Ergebnis fuer ein Pantheon-Muster generieren p_list = result_list[0] # Punktliste, enthaelt einzelne Punkte e_list = result_list[1] # Horizontale Kantenliste, enthaelt Listen mit zwei Punkten ve_list = result_list[2] # Vertikale Kantenliste, enthaelt Listen mit zwei Punkten f_list = result_list[3] # Flaechenliste, enthaelt Listen mit vier Punkten (Quads) zcol = result_list[4] # Anzahl der Ebenen von Flaechen xcol = result_list[5] # Anzahl der Flaechen pro Ebene print " there are " + str(len(p_list)) + " points and " + str(len(f_list)) + " faces on " + str(zcol) + " levels, "+str(xcol)+" per level!" # Statusmeldung mit Anzahl der Punkte und Flaechen """ #def my_panel_grid if 1: for i in range(zcol): for j in range(xcol): points = f_list[i*xcol+j] my_panel(points, scale=ran.uniform(1.5, 2.7)) #my_panel_frame(f_list[i+xcol+j], 8) rs.AddSrfPt(f_list[i*xcol+j]) """ if 1: for i in range(zcol): for j in range(xcol): points = f_list[i*xcol+j] # Punkte der aktuellen Flaeche abrufen scale = ran.uniform(-6.3, 1.5) # Zufaelligen Skalierungsfaktor generieren my_panel_frame(f_list[i*xcol+j], 0.8, 0.4) # Rahmenpanel erstellen rs.AddSrfPt(f_list[i*xcol+j]) if 1: for line in e_list: mline = rs.AddLine(line[0], line[1]) # Linie erstellen rs.AddPipe(mline, 0, 0.8, cap=2) # Rohr um Linie erstellen for line in ve_list: mline = rs.AddLine(line[0], line[1]) # Linie erstellen rs.AddPipe(mline, 0, 0.4, cap=2) # Rohr um Linie erstellen if 1: # Letzte Reihe der Pantheon-Decke ist flach for i in range(zcol): for j in range(xcol): if i != zcol-1: points = f_list[i*xcol+j] # Punkte der aktuellen Flaeche abrufen scale = ran.uniform(10.5,-10.1) # Zufaellige Skalierung generieren my_panel(f_list[i*xcol+j], scale) # Panel erstellen else: rs.AddSrfPt(f_list[i*xcol+j]) # Flaeche erstellen delobjs = rs.ObjectsByType(1) + rs.ObjectsByType(4) rs.DeleteObjects(delobjs) rs.EnableRedraw(True) # Redraw aktivieren, um die Aenderungen anzuzeigen