python in rhino

[mia_lu]

Hallo (:

Ich bin Architekturstudentin, dieses Semester haben wir einen Kurs zu Python gehabt. Leider liegt mir das Skripten nicht wirklich (: und jetzt wollte ich fragen ob mir jemand bei meiner finalen Abgabe helfen möchte. Wir haben mit Rhino gearbeitet und es geht darum ein Gebäude in Venedig nach zu modellieren. Ich wäre sehr dankbar fall sich wer finden lässt der mir das script schreibt. Selbstverständlich gegen Bezahlung.
hier noch codes von anderen studenten

Code: Alles auswählen

import rhinoscriptsyntax as rs
import random as rand

allObj = rs.AllObjects()
rs.DeleteObjects(allObj)
rs.EnableRedraw(False)

# erstes Geschoss

def make_fenster(level, spalte, width, height):
    faktor = 10
    point_list = ((0,0,0),(width,0,0),(width,0,height),(0,0,height),(0,0,0))
    fenster_obj = rs.AddPolyline(point_list)
    rs.MoveObject(fenster_obj, (level*faktor,0, spalte*faktor+1))
    plane = rs.WorldXYPlane()
    plane = rs.RotatePlane(plane,  90.0, [0,1,0])

for level in range(11):
    for spalte in range(1):
        if (6 > level) :
            make_fenster(level,spalte,8,6)
        elif(level > 6):
            make_fenster(level,spalte,8,6)

# Tuere

def make_tuere(level, spalte, width, height):
    faktor = 10
    point_list = ((0,0,0),(width,0,0),(width,0,height),(0,0,height),(0,0,0))
    fenster_obj = rs.AddPolyline(point_list)
    rs.MoveObject(fenster_obj, (level*faktor+61.5,0, spalte*faktor))
    plane = rs.WorldXYPlane()
    plane = rs.RotatePlane(plane,  90.0, [0,1,0])

for level in range (1):
    for spalte in range(1):
        if spalte < 7:
            make_tuere(level,spalte,5,10)

# zweites Geschoss
    
def make_fenster2(level, spalte, width, height):
    faktor = 10
    point_list = ((0,0,0),(width,0,0),(width,0,height),(0,0,height),(0,0,0))
    fenster_obj = rs.AddPolyline(point_list)
    rs.MoveObject(fenster_obj, (level*faktor,0, spalte*faktor))
    plane = rs.WorldXYPlane()
    plane = rs.RotatePlane(plane,  90.0, [1,0,0])
    kreisbogen = rs.AddArc( plane, 1.5, 180.0  )
    rs.MoveObject(kreisbogen, (width/2, 0, height))
    rs.MoveObject(kreisbogen, (level*faktor,0, spalte*faktor))
    rs.JoinCurves((fenster_obj,kreisbogen)) 
    
for level in range(11):
    for spalte in range(2):
        if ((1 == spalte and level == 0)+(level == 2 and spalte == 1)+(level >= 7 and spalte == 1)+(level == 1 and spalte == 1)+(level == 4 and spalte == 1)+(level == 5 and spalte == 1)) :
            make_fenster2(level,spalte,3,4)

# drittes Geschoss

def make_fenster3(level, spalte, width, height):
    faktor = 10
    point_list = ((0,0,0),(width,0,0),(width,0,height),(0,0,height),(0,0,0))
    fenster_obj = rs.AddPolyline(point_list)
    rs.MoveObject(fenster_obj, (level*faktor,0, spalte*faktor))
    plane = rs.WorldXYPlane()
    plane = rs.RotatePlane(plane,  90.0, [1,0,0])
    kreisbogen = rs.AddArc( plane, 2.5 , 180.0  )
    rs.MoveObject(kreisbogen, (width/2, 0, height))
    rs.MoveObject(kreisbogen, (level*faktor,0, spalte*faktor))
    rs.JoinCurves((fenster_obj,kreisbogen)) 
    
for level in range(11):
    for spalte in range(3):
        if ((2 == spalte and level == 0)+(level == 2 and spalte == 2)+(level == 8 and spalte == 2)+(level == 10 and spalte == 2)):
            make_fenster3(level,spalte,5,8)
            
def make_fenster4(level, spalte, width, height):
    faktor = 5
    point_list = ((0,0,0),(width,0,0),(width,0,height),(0,0,height),(0,0,0))
    fenster_obj = rs.AddPolyline(point_list)
    rs.MoveObject(fenster_obj, (level*faktor+37.5,0, spalte*5))
    plane = rs.WorldXYPlane()
    plane = rs.RotatePlane(plane,  90.0, [1,0,0])
    kreisbogen = rs.AddArc( plane, 2.5 , 180.0  )
    rs.MoveObject(kreisbogen, (width/2, 0, height))
    rs.MoveObject(kreisbogen, (level*faktor+37.5,0, spalte*5))
    rs.JoinCurves((fenster_obj,kreisbogen)) 
    
for level in range (6):
    for spalte in range(5):
        if spalte == 4:
            make_fenster4(level,spalte,5,8)

# viertes Geschoss
            
def make_fenster5(level, spalte, width, height):
    faktor = 10
    point_list = ((0,0,0),(width,0,0),(width,0,height),(0,0,height),(0,0,0))
    fenster_obj = rs.AddPolyline(point_list)
    rs.MoveObject(fenster_obj, (level*faktor,0, spalte*faktor))
    plane = rs.WorldXYPlane()
    plane = rs.RotatePlane(plane,  90.0, [1,0,0])
    kreisbogen = rs.AddArc( plane, 2.5 , 180.0  )
    rs.MoveObject(kreisbogen, (width/2, 0, height))
    rs.MoveObject(kreisbogen, (level*faktor,0, spalte*faktor))
    rs.JoinCurves((fenster_obj,kreisbogen)) 
    
for level in range(11):
    for spalte in range(5):
        if ((4 == spalte and level == 0)+(level == 2 and spalte == 4)+(level == 8 and spalte == 4)+(level == 10 and spalte == 4)):
            make_fenster5(level,spalte,5,8)
            
            
def make_fenster6(level, spalte, width, height):
    faktor = 5
    point_list = ((0,0,0),(width,0,0),(width,0,height),(0,0,height),(0,0,0))
    fenster_obj = rs.AddPolyline(point_list)
    rs.MoveObject(fenster_obj, (level*faktor+32.5,0, spalte*10))
    plane = rs.WorldXYPlane()
    plane = rs.RotatePlane(plane,  90.0, [1,0,0])
    kreisbogen = rs.AddArc( plane, 2.5 , 180.0  )
    rs.MoveObject(kreisbogen, (width/2, 0, height))
    rs.MoveObject(kreisbogen, (level*faktor+32.5,0, spalte*10))
    rs.JoinCurves((fenster_obj,kreisbogen)) 
    
for level in range (8):
    for spalte in range(5):
        if spalte == 4:
            make_fenster6(level,spalte,5,8)
            
# aufsatz

def make_aufsatz(level, spalte, width, height):
    faktor = 10
    point_list = ((0,0,0),(width,0,0),(width,0,height),(0,0,height),(0,0,0))
    point_list_dreieck = ((0,0,0),(1.5,0,3),(3,0,0),(0,0,0))
    fenster_obj = rs.AddPolyline(point_list)
    rs.MoveObject(fenster_obj, (level*faktor,0, spalte*faktor))
    plane = rs.WorldXYPlane()
    plane = rs.RotatePlane(plane,  90.0, [0,1,0])
    dreieck = rs.AddPolyline(point_list_dreieck)
    rs.MoveObject(dreieck, (width/2, 0, height))
    rs.MoveObject(dreieck, (level*faktor-1.5,0, spalte*10))
    rs.JoinCurves((fenster_obj,dreieck)) 

for level in range (11):
    for spalte in range(11):
        if (spalte == 6 and level == 0)+(spalte == 6 and  level == 3)+(spalte == 6 and  level == 7)+(spalte == 6 and  level == 10):
            make_aufsatz(level,spalte,3,4)
            
# Wand

def make_wand(level, spalte, width, height):
    faktor = 0
    point_list = ((0,0,0),(width,0,0),(width,0,height),(0,0,height),(0,0,0))
    fenster_obj = rs.AddPolyline(point_list)
    rs.MoveObject(fenster_obj, (level*faktor-4,0, spalte*faktor))
    plane = rs.WorldXYPlane()
    plane = rs.RotatePlane(plane,  90.0, [0,1,0])

make_wand(level,spalte,115,60)

der nächste schritt wäre aus dem 2d ein 3d zu machen
so wie hier

Code: Alles auswählen

# campanile venedig Markusturm in Venedig 98,6 Meter hoch

# import Rhino Commands
import rhinoscriptsyntax as rs
import random as ran

# delete everything and start from scratch
allobjs = rs.AllObjects()
rs.DeleteObjects(allobjs)

# der glockenturm baut sich von unten nach oben aus 4 haupt-bauteilen auf

# 1. schafft        (1 hohe box)
# 2. glockenhaus    (4 breite Ecksaeulen dazwischen doppelsaeulen)
# 3. aufbau         (1 box)
# 4. dach           (1 Pyramide)


# 1.1 schafft:          4 Eckpilaster dazwischen pilaster mir rundboegen oben verunden
# 2.1 glockenhaus:      4 Eckpilaster dazwischen pilaster die mit boegen verbunden werden

# 5. Deco           (Gesims abschluss am Schaft/Glockenhaus/Aufbau)
# 5.1 DecoDetails    (Gesimse an allen Saeulen/Pilastern)


##############################################################################
# campanile variables
##############################################################################
z = 96.2                         # z = Turmhoehe 96.2 oeiginalhoehe
x = z/5                          # x = Turmbreite
y = z/4                          # y = Turmtiefe

rx = x/1.17                        # rx = ruecksprung Aufbau in X richtung                        
ry = y/1.17                        # ry = ruecksprung Aufbau in Y richtung

#-----------------------------------------------------------------
A = 3                           # A = Module size (distance between columns)
B = A/3                         # B = Distance of columns to end of plate
thick = 1                    # thickness of all slabs
hgt = 10                       # height of room
xcol = 4                        # columns in x direction 
ycol = 4                        # columns in y direction
levels = 0                      # number of floor plates
f_height = 1                  # f_height = foundation height
f_size = 1                    # f_size = foundation edge size
##############################################################################
# derived values:
##############################################################################
center_pt = [A*(xcol-1)/2,A*(ycol-1)/2, f_height]  # insertion point of floor plate
p_width = A*(xcol-1)+2*B                    # width of floor plate (x)
p_length = A*(ycol-1) + f_size              # length of floor plate (y)

# function to create a box
def make_box(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, (-xsize/2,-ysize/2,0))
    rs.MoveObject(box, insertion)
    return(box)
    
# funktion pilaster feld
def make_pilaster (x=5.0,f_size=0.8,f_height=0.5, xcol=2, ycol=2):
    pilaster =[]
    for i in range(4):
            pilaster.append(make_box([x,y,0], f_size, f_size, f_height))
    return(pilaster)

# values fur saulen
offs = 1
n_x = 2
n_y = 8
s_breite = 1.5
s_tiefe = 0.5

pos_saule = list()
pos_Eck_saule = []

rs.EnableRedraw(False)

# mach mir die saulen im Schafft!

for i in range(1, n_x+1):
    pos_saule.append([x/2-offs-(x-2*offs)/(n_x+1)*i, y/2+s_tiefe/2, 0])
    pos_saule.append([x/2-offs-(x-2*offs)/(n_x+1)*i, -y/2-s_tiefe/2, 0])

for i in range(1, n_y+1):
    pos_saule.append([x/2+s_tiefe/2, y/2-offs-(y-2*offs)/(n_y+1)*i, 0])
    pos_saule.append([-x/2-s_tiefe/2, y/2-offs-(y-2*offs)/(n_y+1)*i, 0])
    
for pos in pos_saule[2*n_x:]:
    make_box(pos,s_tiefe,s_breite,z/1.8)

for pos in pos_saule[:2*n_x]:
    make_box(pos,s_breite,s_tiefe,z/1.8)

# und die ecksaulen

pos_es = [[-x/2,-y/2,0], [-x/2,y/2,0], [x/2,-y/2,0], [x/2,y/2,0]]

for eck in pos_es:
    make_box(eck,s_breite+s_tiefe,s_breite+s_tiefe,z/1.8)
    ecken = make_box
    rs.MoveObject(ecken, (5,5,0))




# function to create a field of columns
def make_columns(A=5.0, level=0.7, thick=0.2, hgt=3.0, xcol=2, ycol=2):
    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)



# function to create a pyramide
def make_roof(insertion=[0,0,0],xsize=10,ysize=10,zsize=10):
    pyramide_pt = [(0,0,0), (xsize,0,0), (xsize,ysize,0), (0,ysize,0), (0,0,0)]
    pyramide = rs.AddPolyline(pyramide_pt)
    point = xsize/2,ysize/2,z/4.3
    pyramide_obj = rs.ExtrudeCurvePoint(pyramide, point)
    
    rs.CapPlanarHoles(pyramide_obj)
    rs.MoveObject(pyramide_obj, (-xsize/2,-ysize/2,0))
    rs.MoveObject(pyramide_obj, insertion)
    rs.DeleteObjects(pyramide)




# 1. schafft
make_box([0,0,0],x,y,z/1.8)

# 2. glockenhaus
make_box([0,0,z/1.8],x,y,z/10)

# 3. aufbau
make_box([0,0,z/1.8+z/10],rx,ry,z/10)

# 4. dach
make_roof([0,0,z/1.8+z/10+z/10],rx,ry,z/4.3)








"""
# building dom-ino
f_list=[]           # list of foundations
c_list=[]           # list of columns
p_list=[]           # list of plates
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))
    p_list.append(make_box(center_pt, p_width, p_length, thick))
"""
"""
rs.AddLayer("foundation")
rs.LayerColor("foundation", (220,60,60))
rs.ObjectLayer(f_list,"foundation")
rs.AddLayer("columns")
rs.LayerColor("columns", (60,220,60))
rs.ObjectLayer(c_list,"columns")
rs.AddLayer("plates")
rs.LayerColor("plates", (60,60,220))
rs.ObjectLayer(p_list,"plates")
"""
rs.EnableRedraw(True)

[__deets__]

Ich würde versuchen Hilfe bei Kommilitonen zu finden. Der Grund ist einfach: kaum einer hier, wenn überhaupt, hat Rhino. Und ohne das geht es nun mal nicht.

[noisefloor]

Hallo,

Rhino= Rhine3D (https://www.rhino3d.com/de/). Könntest du das Gebäude manuell = mit Maus und Tastatur zeichnen?

Gruß, noisefloor

[__deets__]

@noisefloor: ich denke nicht, dass sie das vom Hand machen soll. Genauso wenig wie einer hier die üblichen Fibonacci Zahlen etc einfach von Hand ausliefern soll

[noisefloor]

Hallo,

@__deets__:

ich denke nicht, dass sie das vom Hand machen soll.

Das ist schon klar. Aber: wenn sie das von Hand zeichnen könnte, dann ist die Programmierung IMHO ziemlich leicht umsetzen, weil das Python-Skript 1:1 die Schritte abbildet, die man auch manuell mit Maus und Tastatur macht.

Ich habe eine alter Version von Rhino3D, die zwar skriptfähig ist, aber nicht via Python. Die Bedienung von Rhino3D hat sich in den letzten Version aber nicht geändert.

Gruß, noisefloor

[__deets__]

Das halte ich für eine gewagte These, dass man sich da durch die Modellierung ein Verständnis für die API und Python im allgemeinen erarbeitet. Sonst wäre jeder Häkler ein guter Programmierer.

[__blackjack__]

@__deets__: Die These hat ja auch keiner aufgestellt. Die Frage ob sie das von Hand machen kann entspricht der üblichen Frage, die wir hier ja auch oft stellen wie jemand eine Rechnung oder einen Algorithmus denn ohne Rechner, mit Stift und Papier aufschreiben würde, oder mal auf dem Papier etwas Schrittweise ausprobieren soll um drauf zu kommen wo der Fehler ist. Denn wenn man das nicht ohne Rechner ausdrücken/nachvollziehen kann, wird das mit Rechner auch nicht klappen.

Und wenn man das dann ohne Python mal gemacht hat, dann kann man schauen wie man das in Python ausdrückt. Es reicht nicht aus das per Hand machen zu können, ist aber eine notwendige Vorraussetzung und wenn es eine Skripting-API ist, die die Aktionen in der GUI mehr oder weniger 1:1 abbildet, und danach sieht es hier aus, reicht das immerhin schon mal um ein Skript schreiben zu können, was aus einer Makroaufzeichnungsfunktion heraus fallen könnte.

Da wird es dann keine Punkte für geben, weil alle Zahlen hart kodiert wären und viel redundanter Code da stehen würde. Also braucht's noch ein Grundlagentutorial — Rechenoperationen, Variablen, Grunddatentypen, Entscheidungen, Wiederholungen, Parametrisieren von Code, also so alles bis einschliesslich Funktionen, und dann sollte man da eigentlich zumindest hässliche, aber funktionierende, Skripte hin bekommen. Also das was da von anderen Studenten gezeigt wurde.

[__deets__]

Ich finde schon, das diese These aufgestellt wurde. Und das sie nicht viel mit der Realität zu tun hat. Wenn ich 3D modelliere, dann arbeite ich genau NICHT mit solchen absoluten Zahlen wie zb der Breite & dann einer Verschiebung um die Breite. Sondern um zb zwei gleiche Säulenbögen nebeneinander zu positionieren, dupliziere ich einen, und nutze ein Verschiebungstool, das den linken Schulter Punkt des einen an den Rechten des anderen platziert. Eine intuitive und einfache GUI-Operation, die nichts mit einem algorithmischen Ansatz für diese Aufgabe zu tun hat. Da wäre das ein ziemlicher Mindfuck, um zb eine Selektions-API für Punkte zu diesem Zweck zu benutzen.

Natürlich bildet die API viele oder alle der Operationen der Software ab, die zu kennen, ist sicher eine Voraussetzung. Aber noch lange nicht hinreichend.

[noisefloor]

Hallo,

Ich finde schon, das diese These aufgestellt wurde.

Finde ich auch nicht.

Es ist schon so gemeint, wie __blackjack__ es schon geschrieben hat: wenn man keine Ahnung von Rhino3D und dessen Möglichkeiten hat (=damit nicht zumindest ein bisschen Zeichnen kann), dann wird das mit der API auch sehr schwer - selbst, wenn man Python gut könnte.

In wie weit der obige Code alle Möglichkeiten von Rhino3D ausnutzt oder ob das einfach quick and dirty works for me ist kann ich nicht beurteilen. Und was die pythonischen Ansprüche des Kursleiters für die Architekten ist können wir alle nicht beurteilen.

Gruß, noisefloor