import rhinoscriptsyntax as rs import random as ran # Alle Objekte löschen und von vorne beginnen allobjs = rs.AllObjects() rs.DeleteObjects(allobjs) def create_surface_and_circles(): # Parameter für die Rechteckfläche rect_width = 100 # Breite des Rechtecks rect_height = 50 # Höhe des Rechtecks rect_z = 26 # Z-Höhe der Fläche # Parameter für die Kreise num_circles = 6 min_circle_radius = 5 max_circle_radius = 10 # Rechteckfläche erstellen corner1 = [0, 0, rect_z] corner2 = [rect_width, rect_height, rect_z] rectangle = rs.AddRectangle(rs.WorldXYPlane(), rect_width, rect_height) rs.MoveObject(rectangle, [0, 0, rect_z]) # Rechteck in eine Surface umwandeln surface = rs.AddPlanarSrf(rectangle) if not surface: print("Fehler beim Erstellen der Surface.") return surface = surface[0] # Die Surface-ID # Surface rebuilden und Grids aktivieren rs.RebuildSurface(surface, degree=(2, 2), pointcount=(15, 10)) rs.EnableObjectGrips(surface, enable=True) print("Surface erfolgreich erstellt und unterteilt auf Höhe {rect_z} mit dichterem Grid.") # Neues Rechteck 5 Einheiten höher erstellen new_rect_z = rect_z + 5 # Neues Rechteck 5 Einheiten höher new_rectangle = rs.AddRectangle(rs.WorldXYPlane(), rect_width, rect_height) rs.MoveObject(new_rectangle, [0, 0, new_rect_z]) # Verschieben des neuen Rechtecks print("Neues Rechteck erfolgreich um 5 Einheiten höher versetzt, auf Höhe {new_rect_z}.") # Rechteck in eine Surface umwandeln new_surface = rs.AddPlanarSrf(new_rectangle) if not new_surface: print("Fehler beim Erstellen der neuen Surface.") return new_surface = new_surface[0] # Die neue Surface-ID print("Neue Surface auf Höhe {new_rect_z} erfolgreich erstellt.") # Rebuild die neue Surface rs.RebuildSurface(new_surface, degree=(2, 2), pointcount=(15, 10)) # Rebuild der neuen Surface print("Neue Surface erfolgreich rebuilt.") # Erstelle die Seitenflächen (Verbindung zwischen den beiden Oberflächen) create_vertical_sides(surface, new_surface) # Kreise erstellen circles = [] inner_circles = [] for _ in range(num_circles): placed = False while not placed: # Zufällige Position innerhalb des Rechtecks x = ran.uniform(0 + max_circle_radius, rect_width - max_circle_radius) y = ran.uniform(0 + max_circle_radius, rect_height - max_circle_radius) center = [x, y, 0] # Zufälliger Radius radius = ran.uniform(min_circle_radius, max_circle_radius) # Prüfen, ob der Kreis andere Kreise nicht überschneidet valid = True for circle in circles: other_center = rs.CircleCenterPoint(circle) other_radius = rs.CircleRadius(circle) distance = rs.Distance(center, other_center) if distance < radius + other_radius: valid = False break # Wenn gültig, Kreis erstellen if valid: outer_circle = rs.AddCircle(center, radius) circles.append(outer_circle) placed = True print("Äußerer Kreis erstellt: Zentrum={center}, Radius={radius}") # Inneren Kreis erstellen inner_radius = radius / 2 inner_circle = rs.AddCircle(center, inner_radius) inner_circles.append(inner_circle) print("Innerer Kreis erstellt: Zentrum={center}, Radius={inner_radius}") print("{len(circles)} äußere und {len(inner_circles)} innere Kreise erfolgreich erstellt.") # Wenden Sie die Funktion an, um die Grips innerhalb der Kreise nach unten zu verschieben select_points_over_circles(surface, circles) rs.EnableObjectGrips(surface, enable=False) # Am Ende die Kreise löschen if circles: # Sicherstellen, dass die Liste nicht leer ist for circle in circles: rs.DeleteObject(circle) if inner_circles: # Sicherstellen, dass die Liste nicht leer ist for inner_circle in inner_circles: rs.DeleteObject(inner_circle) print("Alle äußeren und inneren Kreise wurden gelöscht.") return surface, new_surface, circles, inner_circles def create_additional_rectangles_with_curves(): # Erstelle 10 Rechtecke mit einem Abstand von 2 cm in Y-Richtung und gruppiere sie num_rectangles = 26 additional_width = 105 # Breite in X-Richtung additional_height = 45 # Höhe in Z-Richtung initial_position = [0, 0, -10] # Startpunkt des ersten Rechtecks y_spacing = 2 # Abstand zwischen den Rechtecken in Y-Richtung # Liste für Rechteck-Kurven und alle Linien, die später zusammengefügt werden rectangles = [] all_lines = [] # Hier wird die Liste korrekt definiert for i in range(num_rectangles): # Berechne die Position für das aktuelle Rechteck position = [ initial_position[0], initial_position[1] + i * y_spacing, # Verschiebung in Y-Richtung initial_position[2] ] # Punkte für die Rechteckkurve points = [ [position[0], position[1], position[2]], # Untere linke Ecke [position[0] + additional_width, position[1], position[2]], # Untere rechte Ecke [position[0] + additional_width, position[1], position[2] + additional_height], # Obere rechte Ecke [position[0], position[1], position[2] + additional_height], # Obere linke Ecke [position[0], position[1], position[2]] # Zurück zum Startpunkt ] # Erstelle die Kurve additional_curve = rs.AddCurve(points, degree=1) # Degree 1 für gerade Linien if not additional_curve: print("Fehler beim Erstellen der Kurve für Rechteck {i + 1}.") continue # Füge die Kurve der Rechteckliste hinzu rectangles.append(additional_curve) print("Rechteck mit Kurve {i + 1} erfolgreich erstellt.") # Gruppiere die Rechtecke if rectangles: group_name = rs.AddGroup("AdditionalRectanglesGroup") rs.AddObjectsToGroup(rectangles, group_name) print("Alle {len(rectangles)} Rechtecke erfolgreich gruppiert unter '{group_name}'.") # Projiziere die Rechtecke auf die Surface projected_rectangles = [] if rectangles and surface: for rectangle in rectangles: projected_rectangle = rs.ProjectCurveToSurface(rectangle, surface, [0, 0, 1]) # Projektion entlang Z-Achse projected_rectangles.append(projected_rectangle) if projected_rectangle: for curve in projected_rectangle: # Versuchen, die projizierte Kurve zu schließen if rs.IsCurve(curve) and not rs.IsCurveClosed(curve): rs.CloseCurve(curve) # Schließt die Kurve, falls sie offen ist print("Projizierte Kurve geschlossen.") # Jetzt fügen wir eine 1 cm lange Linie an den Endpunkten der projizierten Rechtecke hinzu for curve in projected_rectangle: # Abrufen der Endpunkte der projizierten Kurve start_point = rs.CurveStartPoint(curve) end_point = rs.CurveEndPoint(curve) # Erstelle eine Linie in Z-Richtung von beiden Endpunkten line_start = [start_point[0], start_point[1], start_point[2] + 1] # 1 cm nach oben line_end = [end_point[0], end_point[1], end_point[2] + 1] # 1 cm nach oben # Linien erstellen vertical_line_1 = rs.AddLine(start_point, line_start) vertical_line_2 = rs.AddLine(end_point, line_end) connection_line = rs.AddLine(line_start, line_end) joind_curve=rs.JoinCurves((vertical_line_1,vertical_line_2,connection_line),True) if joind_curve: print("Vertikale Linie an Startpunkt erstellt: {line_start}") all_lines.append(joind_curve) # Zur Liste der Linien hinzufügen else: print("Fehler beim Erstellen der vertikalen Linie an Startpunkt: {line_start}") print(len(all_lines)) print(len(projected_rectangles)) # Alle projizierten Rechtecke und Linien in all_lines einfügen if all_lines and projected_rectangles: all_lines.extend(projected_rectangles) # Füge die projizierten Rechtecke zu den Linien hinzu # Verbinde alle Linien mit JoinCurves joined_lines = rs.JoinCurves(all_lines, delete_input=True) # Löscht die originalen Kurven, wenn sie verbunden wurden if joined_lines: print("Alle Linien und projizierten Rechtecke erfolgreich verbunden.") else: print("Fehler beim Verbinden der Linien und projizierten Rechtecke.") for rectangle in joined_lines: # Extrudiere das Rechteck entlang der y-Achse um 0,5 Einheiten extrusion_vector = [0, 0.5, 0] # Extrusion um 0,5 Einheiten in y-Richtung crv_str=rs.CurveStartPoint(rectangle) extruded_rectangle = rs.ExtrudeCurveStraight(rectangle, crv_str, [crv_str[0],crv_str[1]+0.5,crv_str[2]]) rs.CapPlanarHoles(extruded_rectangle) if extruded_rectangle: print("Projiziertes Rechteck erfolgreich um 0,5 Einheiten extrudiert.") else: print("Fehler beim Extrudieren des projizierten Rechtecks.") # Lösche die ursprünglichen Rechtecke for rect in rectangles: if rs.IsObject(rect): rs.DeleteObject(rect) print("Rechteck {rect} erfolgreich gelöscht.") def add_rectangles_along_x_axis(): # Basisrechteckpunkte base_points = [ [0, 0, -10], # Startpunkt (unten links) [0, 60, -10], # Punkt in Y-Richtung [0, 60, 45], # Punkt in Y- und Z-Richtung [0, 0, 45], # Punkt in Z-Richtung [0, 0, 0] # Zurück zum Startpunkt ] num_rectangles = 50 # Anzahl der Rechtecke spacing = 2 # Abstand entlang der X-Achse # Rechteckkurven erstellen rectangles = [] for i in range(num_rectangles): # Verschiebung entlang der X-Achse berechnen offset = [i * spacing, 0, 0] # Punkte des Rechtecks verschieben shifted_points = [[p[0] + offset[0], p[1] + offset[1], p[2] + offset[2]] for p in base_points] # Rechteckkurve erstellen rectangle_curve = rs.AddCurve(shifted_points, degree=1) # Degree 1 für gerade Linien if rectangle_curve: rectangles.append(rectangle_curve) print("Rechteck {i + 1} erstellt bei X-Verschiebung: {offset[0]} cm.") else: print("Fehler beim Erstellen von Rechteck {i + 1}.") # Rechtecke gruppieren if rectangles: group_name = rs.AddGroup("RectanglesAlongXAxis") rs.AddObjectsToGroup(rectangles, group_name) print("Alle {len(rectangles)} Rechtecke erfolgreich gruppiert unter '{group_name}'.") # Projiziere die Rechtecke auf die Surface projected_rectangles = [] if rectangles and surface: for rectangle in rectangles: projected_rectangle = rs.ProjectCurveToSurface(rectangle, surface, [0, 0, 1]) # Projektion entlang Z-Achse projected_rectangles.append(projected_rectangle) if projected_rectangle: for curve in projected_rectangle: # Versuchen, die projizierte Kurve zu schließen if rs.IsCurve(curve) and not rs.IsCurveClosed(curve): rs.CloseCurve(curve) # Schließt die Kurve, falls sie offen ist print("Projizierte Kurve geschlossen.") # Hier werden die Linien an Start- und Endpunkten hinzugefügt if rs.IsCurve(curve): start_point = rs.CurveStartPoint(curve) end_point = rs.CurveEndPoint(curve) # Linie am Startpunkt in Z-Richtung hinzufügen start_line = rs.AddLine( start_point, [start_point[0], start_point[1], start_point[2] + 1] ) # Linie am Endpunkt in Z-Richtung hinzufügen end_line = rs.AddLine( end_point, [end_point[0], end_point[1], end_point[2] + 1] ) # Linie zwischen den 1-cm-Linien verbinden if start_line and end_line: # Punkt am Ende der Start-Linie und der End-Linie start_top = [start_point[0], start_point[1], start_point[2] + 1] end_top = [end_point[0], end_point[1], end_point[2] + 1] # Linie zwischen den oberen Punkten erstellen connecting_line = rs.AddLine(start_top, end_top) if connecting_line: print("Verbindungslinie zwischen den 1-cm-Linien hinzugefügt.") if start_line and end_line: print("Linien in Z-Richtung an Start- und Endpunkt hinzugefügt.") joind_curve_2 =rs.JoinCurves((start_line,end_line,connecting_line,projected_rectangle),True) # Hier wird die Kurve extrudiert if joind_curve_2: extrusion = rs.ExtrudeCurveStraight( joind_curve_2, [0, 0, 0], # Startpunkt der Extrusion [0.5, 0, 0] # Endpunkt der Extrusion (0.5 cm in X-Richtung) ) if extrusion: print("Kurve erfolgreich um 0.5 cm in X-Richtung extrudiert.") rs.CapPlanarHoles(extrusion) print("Insgesamt {len(projected_rectangles)} projizierte Rechtecke verarbeitet.") # Löschen der ursprünglichen Rechtecke nach der Verarbeitung if rectangles: for rectangle in rectangles: rs.DeleteObject(rectangle) print("Alle {len(rectangles)} ursprünglichen Rechtecke wurden gelöscht.") def create_vertical_sides(surface1, surface2): # Erstellt die vertikalen Seitenflächen, die zwischen den beiden Oberflächen entstehen. if not rs.IsSurface(surface1) or not rs.IsSurface(surface2): print("Mindestens eine der Oberflächen ist ungültig.") return # Abrufen der Eckpunkte der Oberflächen edges1 = rs.DuplicateEdgeCurves(surface1) edges2 = rs.DuplicateEdgeCurves(surface2) if not edges1 or not edges2: print("Fehler beim Abrufen der Kanten der Oberflächen.") return # Kanten verbinden (Verbindungslinien erstellen) und Flächen generieren for i in range(4): # Es gibt 4 Kantenpaare (4 vertikale Seiten) edge1 = edges1[i] edge2 = edges2[i] # Endpunkte der Kanten abrufen start1 = rs.CurveStartPoint(edge1) start2 = rs.CurveStartPoint(edge2) end1 = rs.CurveEndPoint(edge1) end2 = rs.CurveEndPoint(edge2) # Verschiebe die Punkte um 1 cm in Z-Richtung start1 = rs.PointAdd(start1, [0, 0, 1]) # 1 cm nach oben in Z-Richtung start2 = rs.PointAdd(start2, [0, 0, 1]) end1 = rs.PointAdd(end1, [0, 0, 1]) end2 = rs.PointAdd(end2, [0, 0, 1]) # Erstelle vier Flächen zwischen den Kantenpaaren side_surface_1 = rs.AddSrfPt([start1, start2, end2, end1]) if side_surface_1: print("Seitenfläche {i+1} erfolgreich erstellt.") print("Alle vertikalen Seitenflächen erfolgreich erstellt.") def select_points_over_circles(surface, circles): #Diese Funktion verschiebt die Steuerpunkte der Oberfläche, die innerhalb der Kreise liegen, nach unten if not rs.IsSurface(surface): print("Die übergebene Oberfläche ist ungültig.") return # Alle Steuerpunkte der Oberfläche abrufen points = rs.SurfaceEditPoints(surface) if not points: print("Keine Steuerpunkte gefunden.") return selected_grip_indices = [] # Steuerpunkte prüfen, ob sie innerhalb eines Kreises liegen for point in points: point_2d = [point[0], point[1], 0] # Z auf 0 setzen für 2D-Prüfung for circle in circles: center = rs.CircleCenterPoint(circle) radius = rs.CircleRadius(circle) distance = rs.Distance(point_2d, center) if distance <= radius: selected_grip_indices.append(points.index(point)) break # Steuerpunkte verschieben rs.EnableObjectGrips(surface, True) # Griffe aktivieren moved_points = 0 for grip_index in selected_grip_indices: # Aktuelle Position des Griffs abrufen current_location = rs.ObjectGripLocation(surface, grip_index) if current_location: # Neue Position berechnen (35 Einheiten nach unten) new_location = [current_location[0], current_location[1], current_location[2] - 35] rs.ObjectGripLocation(surface, grip_index, new_location) moved_points += 1 print("{moved_points} Steuerpunkte wurden ausgewählt und um 35 Einheiten nach unten verschoben.") # Skript ausführen if __name__ == "__main__": surface, new_surface, circles, _ = create_surface_and_circles() create_additional_rectangles_with_curves() # Originale Rechtecke add_rectangles_along_x_axis() # Rechtecke entlang der X-Achse hinzufügen # Fläche zwischen den Waffeln löschen rs.DeleteObject(surface)