import rhinoscriptsyntax as rs import random as ran # Delete all objects in the scene allobjs = rs.AllObjects() rs.DeleteObjects(allobjs) rs.EnableRedraw(False) # Define dimensions A = 5 B = A / 3 thick = 0.2 hgt = 2.7 xcol = 3 ycol = 4 levels = 3 f_height = 0.5 f_size = 0.8 center_pt = [A * (xcol - 1) / 2, A * (ycol - 1) / 2, f_height] # Center point of the foundation slab p_width = A * (xcol - 1) + 2 * B # Width of the foundation slab p_length = A * (ycol - 1) + f_size # Length of the foundation slab # Function to create a box at the center point 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 # Function to create a podium (elevated platform) at the corner point 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 the foundations (base slabs) def make_foundations(A=A, f_size=f_size, f_height=f_height, xcol=xcol, ycol=ycol): 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 # Function to create the columns def make_columns(A=A, level=0.7, thick=thick, hgt=hgt, xcol=xcol, ycol=ycol): 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 the stairs 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[-1][1], pointlist[-1][2] - thick]) pointlist.append([pointlist[0][0], pointlist[-1][1], pointlist[0][2] - thick]) pointlist.append([pointlist[0][0], pointlist[-1][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) rs.DeleteObjects((s_outline, path)) return hull # Function to build the Domino-style structure 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 foundations c_list = [] # List of columns p_list = [] # List of floor slabs 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)) level = f_height + thick + (levels - 1) * (hgt + thick) ################################################################## # Calculate stair values 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 ################################################################### # Step parameters tt = 0.3 # Step size s_width = 1.2 # Stair width pod_w = B # Depth of landing start = [pod_w, -(s_width * 2 + f_size / 2), f_height + thick] # Start point of stair stair_1 = [] for i in range(levels): start[2] = f_height + thick + i * (thick + hgt) # Set the z-coordinate at each iteration if i == levels - 1: # Last landing stair_1.append(make_podest([start[0] - pod_w, start[1] + s_width, start[2] - thick], pod_w, s_width, thick)) else: stair_1.append(make_podest([start[0] - pod_w, start[1], start[2] - thick], pod_w, s_width * 2, thick)) stair_1.append(make_stair(start, th, tt, int(steps / 2), thick, s_width)) stair_1.append(make_podest([start[0] + (steps / 2) * tt, start[1], start[2] + (steps / 2) * th - thick], pod_w, s_width * 2, thick)) stair_1.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_1 (f_list, c_list, p_list, stair_1) = make_domino() # Add layers and assign colors rs.AddLayer("Foundation") rs.LayerColor("Foundation", (220, 60, 60)) rs.ObjectLayer(f_list, "Foundation") rs.AddLayer("Column") rs.LayerColor("Column", (60, 220, 6)) rs.ObjectLayer(c_list, "Column") rs.AddLayer("Slabs") rs.LayerColor("Slabs", (60, 60, 220)) rs.ObjectLayer(p_list, "Slabs") # Function to create lamella facade def create_lamella_facade(A=A, xcol=xcol, ycol=ycol, thick=0.1, f_height=f_height, levels=levels, gap=0.3): lamellas = [] lamella_width = 0.2 x_start = -B y_start = -f_size / 2 z_start = 0 # Facade starts at the bottom of the first foundation # Calculate the height of the top of the last floor slab and add the overhang last_floor_height = f_height + (levels - 1) * (thick + hgt) # Top of the last floor slab lamella_height = last_floor_height + 2 * f_height # Facade should extend an additional f_height # Define the specific area to skip (first podium position) staircase_x_min = B # Adjusted based on the podium's approximate x-position staircase_x_max = staircase_x_min + 1.2 # Width of the podium's area to skip num_lamellas_x = int((A * (xcol - 1) + 2 * B) / (lamella_width + gap)) num_lamellas_y = int((A * (ycol - 1) + f_size) / (lamella_width + gap)) # Front Side (Staircase Side) - Skip lamellae overlapping the first podium only for i in range(num_lamellas_x): x_pos = x_start + i * (lamella_width + gap) if not (staircase_x_min <= x_pos <= staircase_x_max): # Exclude lamellae in the range of the first podium lamellas.append(make_box([x_pos, y_start, z_start], lamella_width, thick, lamella_height)) # Back Side for i in range(num_lamellas_x): x_pos = x_start + i * (lamella_width + gap) lamellas.append(make_box([x_pos, y_start + (A * (ycol - 1) + f_size), z_start], lamella_width, thick, lamella_height)) # Left and Right Sides for j in range(num_lamellas_y): y_pos = y_start + j * (lamella_width + gap) lamellas.append(make_box([x_start, y_pos, z_start], thick, lamella_width, lamella_height)) lamellas.append(make_box([x_start + (A * (xcol - 1) + 2 * B), y_pos, z_start], thick, lamella_width, lamella_height)) return lamellas # Call the facade creation function lamella_facade = create_lamella_facade() # Add layer for the lamella facade rs.AddLayer("Facade", (150, 150, 150)) rs.ObjectLayer(lamella_facade, "Facade") def add_optional_stair(f_list, c_list, p_list, stair_1, lamella_facade, A=A, B=B, xcol=xcol, ycol=ycol, thick=thick, hgt=hgt, levels=levels, f_height=f_height, f_size=f_size): # Check if xcol or ycol is greater than 7 if xcol > 7 or ycol > 7: # Step 1: Calculate the 2D center of the building building_center_x = A * (xcol - 1) + B # Center of the building in X (considering B for offset) building_center_y = A * (ycol - 1) + f_size # Center of the building in Y (considering f_size) # Step 2: Calculate the starting position for the staircase # The staircase will start from the center and move right stair_start_x = building_center_x + (A * (xcol - 1) + B - building_center_x) # Move to the right side of the center stair_start_y = building_center_y / 2 # Positioning along the Y-axis (middle of the right side) # Adjust the X-position by shifting it to the left (negative X) by twice the podium thickness stair_start_x -= 2 * thick # Move the staircase left by twice the thickness of a podium # Step 3: Duplicate and rotate the stair by 90 degrees stair_copy = [] for s in stair_1: # Copy and rotate the existing stair by 90 degrees copied_stair = rs.CopyObject(s) rs.RotateObject(copied_stair, [0, 0, 0], 90) # Rotate by 90 degrees rs.MoveObject(copied_stair, [stair_start_x, stair_start_y, 0]) # Move it to the right side stair_copy.append(copied_stair) # Return the new stairs added to the right side return stair_copy else: return [] # Call the function to add the optional stairs if needed optional_stairs = add_optional_stair(f_list, c_list, p_list, stair_1, lamella_facade) # If new stairs were added, append them to the original stair list if optional_stairs: stair_1.extend(optional_stairs) # Add the optional stairs to a new layer for visibility rs.AddLayer("OptionalStair") rs.LayerColor("OptionalStair", (200, 100, 50)) # Color for optional stairs (orange) rs.ObjectLayer(optional_stairs, "OptionalStair") """ import math num_copies = 20 min_distance = 25 area_range = 250 # Function to duplicate building in random positions within a larger area and ensure they do not overlap def duplicate_building_randomly(f_list, c_list, p_list, stair_1, lamella_facade, num_copies=num_copies, min_distance=min_distance, area_range=area_range): building_parts = f_list + c_list + p_list + stair_1 + lamella_facade positions = [] # Track positions to avoid overlaps for _ in range(num_copies): valid_position = False while not valid_position: # Generate random x, y coordinates within the area range x_offset = ran.uniform(-area_range, area_range) y_offset = ran.uniform(-area_range, area_range) turn = ran.uniform(0, 180) offset = [x_offset, y_offset, 0] # z = 0 for ground level placement # Check if this position is far enough from all previous positions valid_position = all( math.sqrt((x_offset - pos[0])**2 + (y_offset - pos[1])**2) >= min_distance for pos in positions) # If valid, add to positions list and copy the building parts positions.append((x_offset, y_offset)) rs.CopyObjects(building_parts, offset) rs.RotateObjects(building_parts, [0, 0, 0], turn) # Duplicate the building x times at random positions within a large area, ensuring no overlap duplicate_building_randomly(f_list, c_list, p_list, stair_1, lamella_facade, num_copies=num_copies, min_distance=min_distance, area_range=area_range) """ # Enable redraw to update view rs.EnableRedraw(True)