################################### ### DM2_w25 # AGruber@tugraz.at ### ### hu_06 UN_headquaters NYC ### CRVs 4 ROLLER.COASTER | SETUP ################################### ############################## import rhinoscriptsyntax as rs import random, time, sys ### sys.path.append("P:/") ### import DM_lib as dm ### dm.reload_lib(dm) ############################## rs.UnitSystem(4) # meters = 4, cm = 3 etc stellt einheiten auf meter um rs.ShowGrid(None, False) # grid > False = off rs.ShowGridAxes(None, True) # y/y/z axen display > False/True = off/on rs.ViewDisplayMode(rs.CurrentView(), "wireframe") rs.Command("cplane w t enter", False) # cPlane World Top dm.PointRadius(displayModeX=0, rad=3, styl=3) # 0 => wireframe | info: (.., verbose=1) dm.PointRadius(displayModeX=1, rad=4, styl=1) # 1 => shaded | info: (.., verbose=1) dm.PointRadius(displayModeX=2, rad=2, styl=0) # 2 => rendered | info: (.., verbose=1) dm.printDisplay(state=False) # nomen est omen rs.EnableRedraw(False) ###_________________________________________# ### basic settings for grid to fit UN_slab # ### # ! no need 2 change ! floors = H = dm.H = 40 # default=40 / incl roof slabs = L = dm.L = 11 # default=11 depth = D = dm.D = 4 # default= 4 / division in building_depth floorHeight = fH = dm.fH = 4.0 # default= 4.0 / 4.0*(H-1) = 156 meters # ############# # get gridCoords L*D*H = 1760 UnoGridCoords = dm.getUnoGridCoords() # get from DM_lib as dm #################___________________________# ####################### ### my little helper: ############### ### gC (get_Coord) im UN_grid ! # def gC(L,D,H): return dm.gC(L,D,H) # definition gc get cord nach laenge tiefe hoehe angabe koordinaten fuer einen dieser punkte berechnen kann # return ist immer der rueckgabewert ##################################### ################## depthVec = dVec = rs.VectorUnitize(rs.VectorSubtract( gC(0, 0, 0), gC(0, 2, 0) )) ## vektor wird normalisiert und hat laenge eins lengthVec = lVec = rs.VectorUnitize(rs.VectorSubtract( gC(0, 0, 0), gC(1, 0, 0) )) #### ################## dm.newEmptyLayer("UNO::setUp", [120,120,140]) if 1: ### SETUP >> dont' exec @ homework ! if 0: rs.AddPoints(UnoGridCoords)### just 4 reference ## zeichnen des referenzrasters if 1: rs.AddPoints(UnoGridCoords) cor = gC(0, 0, 0) rs.AddLine( gC(0, 0, 0), gC(10, 0, 0) ) rs.AddLine( gC(0, 0, 0), gC(0, 3, 0) ) rs.AddLine( gC(0, 0, 0), gC(0, 0, 30) ) rs.ObjectColor(rs.AllObjects()[2], [0, 222, 0] ), rs.CurveArrows(rs.AllObjects()[0], 2) rs.ObjectColor(rs.AllObjects()[1], [222, 0, 0] ), rs.CurveArrows(rs.AllObjects()[1], 2) rs.ObjectColor(rs.AllObjects()[0], [0, 0, 222] ), rs.CurveArrows(rs.AllObjects()[2], 2) rs.ObjectPrintWidth( rs.AllObjects()[0:3], 0.5 ) p0 = gC( 0, 0, 0) p1 = gC( 10, 0, 0) p2 = gC( 10, 3, 0) p3 = gC( 0, 3, 0) unoBaseCoords = [p0, p1, p2, p3, p0] unoBaseCrv = rs.AddCurve( unoBaseCoords, 1) unoTopCoords = [dm.gC( 0, 0, 39), dm.gC( 10, 0, 39), dm.gC( 10, 3, 39), dm.gC( 0, 3, 39), dm.gC( 0, 0, 39), ] unoTopCrv = rs.AddCurve( unoTopCoords, 1) rs.ZoomExtents() if 0: ### long version coords = [] for y in range(11): for z in range(0, 40, 2): ### z== intervall for x in range(0, 4, 3): coords.append( dm.gC(y,x,z) ) rs.AddPoints( coords ) dm.SetObjDisplayModeAllViewports(rs.AddPoints( coords ), displaymodeX=0, verbose=1) if 1: ### smart version / comprehension pnts = rs.AddPoints([ dm.gC(y,x,z) for y in range(11) for z in range(0, 40, 2) for x in range(0, 4, 3) ]) dm.SetObjDisplayModeAllViewports(pnts, displaymodeX=2, verbose=0) ### 2 == rendered #### CAMERA #### set / get camera if 0: print ("ViewNames :"), print (rs.ViewNames()) cam = gC(5, -20, 19.5) tar = gC(5, 0, 19.5) rs.AddLine( cam, tar ) #dm.setCameraTarget( cam, tar, 500.0, 0, 0, 0) dm.setCameraTarget(cam, tar, 50.0, 0, 0, 0) # fuer kameraeinstellunge rs.ViewProjection(view='Perspective', mode=1) ### 1 = parallel, 2 = perspective, 3 = two point perspective dm.getCameraTarget(view=rs.CurrentView(), verbose=1) dm.setCameraTarget( [334.42526127, 493.18649387, 171.88081703], [756.84885751, 592.83573956, 82.0], lens=50.0, rota=0, upVec=[0,0,1] ) # ... danke, andi ! ####################################### ################ HERE YOU GO AS YOU GO: dm.newEmptyLayer("myPROJ", [111,111,111]) ### neuer layer fuer projekt import math ### parameter height = dm.fH * (dm.H -1) # gesamthoehe des gebaeudes radius_building = 18.0 # abstand der rutsche von mittelachse amplitude = 2.5 # wellenfoermige auslenkung turns = 2.5 # wie oft sich kurve um gebaeude dreht segments = 300 # je mehr desto glatter tube_radius = 0.8 # dicke der roehre color_r = [150, 150, 150] # farbe grau ## kontrollkurve geschwungene roehre center_base = gC(5, 1.5, 0) # startpunkt der spirale in gebaeude mitte auf hoehe null center = (center_base[0] + 8.0, center_base[1], center_base[2]) # die fassade wird um acht meter verschoben ## kurve geschwungene spiralbahn points = [] for i in range(segments +1): t = float(i) / segments # wert von null bis eins fuer verlauf der kurve z = t*height ## die hoehe steigt linear angle = t * turns * 2 * math.pi # drehwinkel r_offset = math.sin(t * math.pi *2) * amplitude r_outside = math.cos(t * math.pi * 1.3) * 4.0 r = radius_building + r_offset + r_outside x = center[0] + r * math.cos(angle + math.sin(t*3)*0.2) # fuer wellenform y = center[1] + r * math.sin(angle + math.sin(t*2)*0.2) points.append((x, y, z)) main_curve = rs.AddCurve(points, 3) ### geschwungene kurve wird erzeugt rs.ObjectName(main_curve, "main_spiral") rs.ObjectColor(main_curve, color_r) rings = [] n_rings = 30 n_circle_pts = 20 ### ringe entlang der kurve t0, t1 = rs.CurveDomain(main_curve) ## start und endparamter der kurve for i in range(n_rings): ### dreissig wiederholungen param = t0 + (t1-t0) * i / (n_rings -1) ### gleichmaessige verteilung base_pt = rs.EvaluateCurve(main_curve, param) ### plane = rs.CurvePerpFrame(main_curve, param) ## an jedem abschnitt einen kreis senkrecht zur kurve xdir = rs.VectorUnitize(plane.XAxis) ### definieren der richtungen ydir = rs.VectorUnitize(plane.YAxis) ring_pts = [] ### um jeden punkt wird ein kreis gezogen for j in range(n_circle_pts): a = 2 * math.pi * j / n_circle_pts offset = rs.VectorAdd( rs.VectorScale(xdir, math.cos(a) * tube_radius), rs.VectorScale(ydir, math.sin(a) * tube_radius) ) ring_pts.append(rs.PointAdd(base_pt, offset)) ring_curve = rs.AddPolyline(ring_pts + [ring_pts[0]]) ### verbinden der punkte zu geschlossenem ring rs.ObjectColor(ring_curve, color_r) rings.append(ring_curve) ### kreise werden gespeichert fuer spaetere ausfuehrung von loft for i in range(0, n_rings, 5): ### bei jedem fuenften ring eine verbindung param = t0 + (t1 - t0) *i / (n_rings -1) base_pt = rs.EvaluateCurve(main_curve, param) ## punkt auf der roehre facade_pt = rs.PointAdd(base_pt, (random.uniform(-2,2), -6, -3)) line = rs.AddLine(base_pt, facade_pt) ## zeichnen rs.ObjectColor(line, [180, 180, 180]) ### hellgrau rs.ZoomExtents() ### fuer sichtbarkeit print("spirale") # surface if len(rings) >= 2: tube_srf = rs.AddLoftSrf(rings, start=None, end=None, loft_type=0) ### erzeugt oberflaeche alle ringe werden zu geschlossener flaeche verbunden if tube_srf: rs.ObjectColor(tube_srf, [150, 150, 150]) rs.ObjectName(tube_srf, "tube_surface") ### weiter ergaenzung nummer zwei ################################################################# ################### here u go as u go if len(rings) >= 2: tube_srf = rs.AddLoftSrf(rings, start=None, end=None, loft_type=0) if tube_srf: rs.ObjectColor(tube_srf, [150, 150, 150]) rs.ObjectName(tube_srf, "tube_surface") if 'tube_srf' in globals(): num_layers = 4 scale_step = 1.12 # macht jede Schicht breiter # Mittelpunkt der Roehre bestimmen #### eine box um die roehre wird erzeugt fuer die ausdehnung #### NEUER BEFEHL boundingbox bb = rs.BoundingBox(tube_srf) #### berechnen vom mittelpunkt bbnull unterste ecke bb6 gegenueberliegende oberste ecke ### skalierung um diesen punkt center = ( (bb[0][0] + bb[6][0]) / 2.0, (bb[0][1] + bb[6][1]) / 2.0, (bb[0][2] + bb[6][2]) / 2.0 ) for i in range(1, num_layers + 1): s = scale_step ** i #### auraroehree mystisch aura = rs.ScaleObject( tube_srf, center, [s, s, 1], # in x richtung um faktor s vergroessern in y richtung um faktor s vergroessern in z nicht bleibt gleich copy=True ) ### roehren bekommen hellere farbe dadurch wirken sie verschieden rs.ObjectColor(aura, [150 + i*10, 150 + i*10, 150 + i*10]) rs.ObjectName(aura, "aura_layer_" + str(i)) ### layer ########################################### ### here you go as you go nummer zwei ### erstellen von u profilen fuer fassade ########################################### # parameter u_width = 1.2 # dichte der u profile entlang fassade uno u_depth = 3.0 # offset = 4.0 # abstand der u profile von fassade color_wood = [170, 120, 60] # gesamthoehe von gebaude h_total = dm.fH * (dm.H - 1) # richtungsvektoren vom gebaeude bestehend damit u formen immer parallel zur fassade verlaufen lVec = rs.VectorUnitize(rs.VectorSubtract(gC(1,0,0), gC(0,0,0))) # laengsseite dVec = rs.VectorUnitize(rs.VectorSubtract(gC(0,0,0), gC(0,2,0))) # zVec = [0,0,1] # z richtung fuer hoehe # funktion fuer die erstellung von u profil def add_U_profile(D_index, outward_sign): for L in range(0, 11): # ueber die gesamte laenge der fassade null bis elf # basispunkt base base = gC(L, D_index, 0) # verschiebung nach aussen von fassade base = rs.PointAdd(base, rs.VectorScale(dVec, outward_sign * offset)) # die punkte fuer u p0 = base p1 = rs.PointAdd(base, rs.VectorScale(zVec, h_total)) p2 = rs.PointAdd(p1, rs.VectorScale(dVec, outward_sign * u_depth)) p3 = rs.PointAdd(base, rs.VectorScale(dVec, outward_sign * u_depth)) # innere u form als polylinie U_inner = rs.AddPolyline([p0,p1,p2,p3,p0]) # u form aussen verschieben fuer dicke shift = rs.VectorScale(lVec, u_width) U_outer_pts = [rs.PointAdd(pt, shift) for pt in [p0,p1,p2,p3,p0]] U_outer = rs.AddPolyline(U_outer_pts) # loft fuer die surface zwischen inner und outer u form loft = rs.AddLoftSrf([U_inner, U_outer]) rs.ObjectColor([U_inner, U_outer, loft], color_wood) ## farbe auf alle objekte anwenden ### front side u profile erzeugen add_U_profile(D_index=0, outward_sign=+1) ### back side u profile erzeugen add_U_profile(D_index=3, outward_sign=-1) ########################################### ### bereits vorhandene spirale nach aussen verschieben ########################################### # verschiebt die gesamte spirale um zehn einheiten if 'main_curve' in globals(): shift_spiral = rs.VectorScale(dVec, 10.0) rs.MoveObject(main_curve, shift_spiral) for r in rings: rs.MoveObject(r, shift_spiral) ########################################### print("u profil spirale nach aussen verschoben")