import rhinoscriptsyntax as rs import random as ran allobjs = rs.AllObjects() # Alle Objekte in einer Variable speichern rs.DeleteObjects(allobjs) # Alle vorhandenen Objekte loeschen und neu anfangen """ xsize = 8 #xside length of box ysize = 12 #yside length of box zsize = 5 #zside length of box #create a box corners = [[0,0,0], [xsize,0,0], [xsize,ysize,0], [0,ysize,0], [0,0,zsize], [xsize,0,zsize], [xsize,ysize,zsize], [0,ysize,zsize]] rs.AddBox(corners) def make_box(intertion=[0,0,0], xsize=10, ysize=10, zsize=10): #create a box corners = [[0,0,0], [xsize,0,0], [xsize,ysize,0], [0,ysize,0], [0,0,zsize], [xsize,0,zsize], [xsize,ysize,zsize], [0,ysize,zsize]] box=rs.AddBox(corners) rs.MoveObject(box, insertion) #make_box(6,9,10) make_box([10,-3,0],6,9,10) """ ############# #domino variables ### A = 5 # Modulgroesse (Abstand zwischen den Saeulen) B = A / 3 # Abstand ueber die Gebaeudelinie hinaus thick = 0.2 # Dicke der Saeulen hgt = 10 # Hoehe der Raeume xcol = 3 # Anzahl der Saeulenreihen (X-Richtung) ycol = 4 # Anzahl der Saeulenreihen (Y-Richtung) levels = 10 # Anzahl der Ebenen f_height = 0.5 # Hoehe der Fundamente f_size = 0.8 # Groesse der Fundamente ############## #derived values/Abgeleitete Werte: #################### center_pt = [A*(xcol-1)/2, A*(ycol-1)/2, f_height] # Mittelpunkt der Bodenplatte p_width = A*(xcol-1)+2*B # Breite der Bodenplatte (x-Richtung) p_length = A*(ycol-1) + f_size # Laenge der Bodenplatte (y-Richtung) rs.EnableRedraw(False) def make_box(insertion=[0,0,0],xsize=10,ysize=10,zsize=10): # Funktion zum Erstellen einer Box #create a box (Eckpunkte der Box definieren) corners = [[0,0,0], [xsize,0,0], [xsize,ysize,0], [0,ysize,0], [0,0,zsize], [xsize,0,zsize], [xsize,ysize,zsize], [0,ysize,zsize]] box=rs.AddBox(corners) # Box erstellen rs.MoveObject(box, (-xsize/2, -ysize/2, 0)) # Box in die Mitte verschieben rs.MoveObject(box, insertion) # Box an die gewuenschte Position verschieben return(box) #function to create box at cornerpoint/ Funktion, um Podeste zu erstellen def make_podest(insertion=[0,0,0],xsize=10, ysize=10, zsize=10): corners=[[0,0,0],[xsize,0,0],[xsize,ysize,0],[0,ysize,0], [0,0,zsize], [xsize,0,zsize], [xsize,ysize,zsize], [0,ysize,zsize]] box=rs.AddBox(corners) rs.MoveObject(box, insertion) return(box) #function to create a field of foundations/# Funktion, um ein Fundament-Feld zu erstellen def make_foundations(A=5.0, f_size=0.8, f_height=0.5, xcol=2, ycol=3): fns =[] for i in range(xcol): for j in range(ycol): fns.append(make_box([i*A, j*A, 0], f_size, f_size, f_height)) return(fns) #Erstellt ein Feld von Fundamenten. Die Schleifen platzieren die Fundamente basierend auf den X- und Y-Spalten, wobei die Module durch den Parameter A bestimmt werden #function to create a field of columns/Funktion, um Saeulen zu erstellen def make_columns(A=5.0, level=0.7, thick=0.2, hgt=3.0, xcol=2, ycol=3): cls =[] for i in range(xcol): for j in range(ycol): cls.append(make_box([i*A, j*A, level], thick, thick, hgt)) return(cls) #Aehnlich wie bei den Fundamenten werden hier Saeulen erstellt und in einem regelmaessigen Raster platziert. Die Saeulen werden um eine bestimmte Hoehe (level) verschoben # Funktion, um einen Bogen zu erstellen def make_arc(insertion, rad, thick, hgt, orientation): segs=[] segs.append(rs.AddArc([0,0,0], rad, 180)) # Halbkreis segs.append(rs.AddArc([0,0,0], rad-thick, 180)) # Innenhalbkreis segs.append(rs.AddLine([rad,0,0], [rad-thick,0,0])) # Verbindungslinie segs.append(rs.AddLine([-(rad-thick),0,0], [-rad,0,0])) crv = rs.JoinCurves(segs, delete_input=True) # Kurve verbinden path = rs.AddLine([0,0,0], [0,0,hgt]) # Extrusionspfad arc = rs.ExtrudeCurve(crv, path) # Extrudieren rs.CapPlanarHoles(arc) # Flaechen schliessen rs.DeleteObject(crv) rs.DeleteObject(path) rs.RotateObject(arc, [0,0,0], orientation) # Rotieren rs.MoveObject(arc, insertion) # Verschieben return(arc) # Funktion, um eine Terrasse zu erstellen def make_terrace(A=5.0,level=0.7, thick=0.2, hgt=3.0, xcol=2, ycol=3): cls=[] for i in range(xcol-1): for j in range(ycol-1): ori = ran.randint(0,6) if ori<4: orientation= ori*90 cls.append(make_arc([i*A+A/2,j*A+A/2,level], A/2, thick, hgt, orientation)) return(cls) #function to create stair/Funktion, um eine Treppe zu erstellen def make_stair(start, th, tt, steps, thick, s_width): pointlist=[start] for i in range(steps): pointlist.append([pointlist[-1][0],pointlist[-1][1],pointlist[-1][2]+th]) pointlist.append([pointlist[-1][0]+tt,pointlist[-1][1],pointlist[-1][2]]) pointlist.append([pointlist[-1][0],pointlist[0][1],pointlist[-1][2]-thick]) pointlist.append([pointlist[0][0],pointlist[0][1],pointlist[0][2]-thick]) pointlist.append([pointlist[0][0],pointlist[0][1],pointlist[0][2]]) s_outline=rs.AddPolyline(pointlist) path=rs.AddLine(start,[start[0],start[1]+s_width,start[2]]) hull=rs.ExtrudeCurve(s_outline, path) rs.CapPlanarHoles(hull) return(hull) #rs.EnableRedraw(False) #building dom-ino/Funktion, um die gesamte Domino-Struktur zu bauen def make_domino(A=A, B=B, thick=thick, hgt=hgt, levels=levels, xcol=xcol, ycol=ycol, f_height=f_height, f_size=f_size): f_list =[] #list of fudantions/Fundamente c_list =[] #list of columns/Saeulen p_list =[] #list of plates/Platten for i in range (levels): center_pt[2]= f_height + i*(thick+hgt) level= f_height + thick + (i-1)*(hgt+thick) if i==0: f_list = make_foundations(A, f_size, f_height, xcol, ycol) else: c_list.extend(make_columns(A, level, thick, hgt, xcol, ycol)) c_list.extend(make_terrace(A, level, thick, hgt, xcol, ycol)) # damit in mehreren Stockwerken Bogen sind (terrace) p_list.append(make_box(center_pt, p_width, p_length, thick)) level=f_height + thick + (levels-1)*(hgt+thick) c_list.extend(make_terrace(A, level, thick, hgt, xcol, ycol)) #Es werden mehrere Ebenen (Stockwerke) des Dom-ino-Systems erstellt. #In der ersten Ebene werden die Fundamente erstellt. Ab der zweiten Ebene werden Saeulen #hinzugefuegt, und auf jeder Ebene wird eine Bodenplatte (eine Box) positioniert. #calculate stair values/Treppe erstellen ############################# steps=int((hgt+thick)/0.17) if steps%2: steps=steps-1 th=(hgt+thick)/steps if(th>0.19): steps=steps+2 th=(hgt+thick)/steps #stair parameters######################################## tt=0.3 #step size s_width=1.2 #s_width = stair width pod_w=B #pod_w = depth of landing start=[pod_w,-(s_width*2+f_size/2), f_height+thick] #startpoint of stair #loop to create starcase stair_l=[] for i in range(levels): start[2]=f_height+thick+i*(thick+hgt) #z-Wert bei jedes Iteration neu gesetzt if i==levels-1: #letztes podes stair_l.append(make_podest([start[0]-pod_w,start[1]+s_width,start[2]-thick],pod_w,s_width,thick)) #sonderpodest else: stair_l.append(make_podest([start[0]-pod_w,start[1],start[2]-thick],pod_w,s_width*2,thick)) stair_l.append(make_stair(start, th, tt, int(steps/2), thick, s_width)) stair_l.append(make_podest([start[0]+(steps/2)*tt,start[1],start[2]+(steps/2)*th-thick],pod_w,s_width*2,thick)) stair_l.append(make_stair([start[0]+(steps/2)*tt,start[1]+s_width,start[2]+(steps/2)*th], th, -tt, int(steps/2), thick, s_width)) return(f_list, c_list, p_list, stair_l) # Erstelle das Domino-Gebaeude (f_list, c_list, p_list, stair_l)=make_domino() #damit man bei foundation, columns und plates eine Farbe bestimmen bei den Layers rs.AddLayer("foundation") rs.LayerColor("foundation", (220,60,160)) rs.ObjectLayer(f_list,"foundation") rs.AddLayer("columns") rs.LayerColor("columns", (145,100,200)) rs.ObjectLayer(c_list,"columns") rs.AddLayer("plates") rs.LayerColor("plates", (180,60,180)) rs.ObjectLayer(p_list,"plates") #Weist die erstellten Objekte dem entsprechenden Layer zu. #rs.AddLayer("stair") #rs.LayerColor("stair", (200,100,150)) #rs.ObjectLayer(c_list,"stair") # #rs.AddLayer("terrace") #rs.LayerColor("terrace", (220,50,160)) #rs.ObjectLayer(c_list,"terrace") print f_list print c_list print p_list # allgemeine Variablen fuer die Dimensionen und Abstaende der Fassadenelemente depth = 0.3 # Tiefe der vertikalen Linien der Fassade width = 0.1 # Breite der vertikalen Linien der Fassade dis = 0.5 # Horizontaler Abstand zwischen den vertikalen Linien vertical_spacing = 0.8 # Vertikaler Abstand (wird hier jedoch nicht verwendet) # Funktion zur Erstellung der Fassaden def make_facade(insertion=[0, 0, 0], depth=depth, width=width, height=(levels-1)*(hgt+thick), dist=dis): facade_l = [] # Liste, die alle Boxen der Fassade speichert # Berechnung der Anzahl der vertikalen Linien entlang der Fassadenlaenge lines_num = int(p_length // dist) + 1 # Offset in X-Richtung (Positionierung relativ zur Hauptstruktur) offsetset = -B # Schleife, die alle Fassadenlinien erzeugt for i in range(lines_num): # Berechnung der Y-Position jedes Elements, basierend auf dem Abstand 'dist' y_position = i * dist - f_size / 2 # Erstellung eines Fassadenelements (Box) und Hinzufuegen zur Liste # Die Position der Box wird durch 'insertion' und die berechnete Y-Position definiert facade_l.append(make_box([insertion[0], y_position, f_height], depth, width, height)) # Rueckgabe der Liste mit allen erstellten Fassadenelementen return facade_l # Erstellung der Fassaden fuer beide Seiten der Struktur # Fassade fuer die linke Seite der Struktur facade_2 = make_facade(insertion=[-B, 0, 0]) # Fassade fuer die rechte Seite der Struktur # Hier wird die Position relativ zur rechten Kante der Struktur berechnet facade_3 = make_facade(insertion=[A * (xcol - 1) + B, 0, 0]) #make_domino() #for i in range(7): rotate wie das progamm moechte und sucht die punkte auch aus # xran= ran.randint(0,200) # yran= ran.randint(0,200) # angle= ran.uniform(0,180) # (f_list, c_list, p_list, stair_l)=make_domino() # rs.RotateObjects(f_list + c_list + p_list + stair_l, (0,0,0), angle) # rs.MoveObjects(f_list + c_list + p_list + stair_l,(xran,yran,0)) #for i in range(1): # pt=rs.GetPoint() # angle= rs.GetAngle(pt,) # (f_list, c_list, p_list, stair_l)=make_domino() # rs.RotateObjects(f_list + c_list + p_list + stair_l, pt, angle) # rs.MoveObjects(f_list + c_list + p_list + stair_l,(pt)) # brauch man nichtmy_c = rs.AddLine((0,0,0), (200,30,0)) my_c = rs.AddCurve([[0,0,0],[100,200,0],[200,-200,0],[300,200,0],[500,-300,0],[800,100,0]],3) pts = rs.DivideCurve(my_c,6,True,True) #Anzahl an Punkten wird hier mehr oder weniger gemacht for p in pts: (f_list, c_list, p_list, stair_l)=make_domino() # rs.MoveObject(f_list + c_list + p_list + stair_l,(-bsize/2,-bsize/2,0)) #zentrum der punkte sind die boxen rs.MoveObject(f_list + c_list + p_list + stair_l, p) rs.EnableRedraw(True)