""" Pyramid trim strip V1 - "plain" (Blender bpy) - standalone. The plainest member of the trim strip family: a flat 2mm-thick backing slab with just a straight raised rail down each long edge - no braid between them. Same footprint/print setup as the other variants, this is the "no ornament" baseline - see runes/rune_panel_v1_plain.py, which plays the same role for the rune panels. One of a family of border motifs for the same strip footprint - see _v2_studs.py, _v3_fishbone_spine.py, _v4_braid_2strand.py, and _v5_braid_3strand.py for the others. Cut to length/mitred by hand after printing - a generic straight trim strip, not tied to any specific piece or angle, reusable across the board's various straight trim runs wherever this border motif fits. Sized to the Anycubic Photon Mono 2's 143 x 89mm plate: strip length 140mm (down the plate's long axis, ~3mm margin off the true 143mm edge), strip width 16mm (well inside the 89mm short axis). Direct-to-plate, no supports - same shallow emboss-on-flat-back logic as the rune panels. Run: Blender -> Scripting workspace -> Open this file -> Alt+P """ import bpy import bmesh import math import mathutils import os # ============================================================ # CONFIG # ============================================================ EXPORT_DIR = "/Users/mannil/Desktop/studio-m/TSONS/pyramid/trim/output/v1_plain" EXPORT_STL = True RENDER_IMAGES = True RENDER_DIR = os.path.join(EXPORT_DIR, "renders") RENDER_RESOLUTION = (1600, 900) RENDER_ANGLES = { "front": (0.0, -1.0, 0.15), "side": (1.0, -0.1, 0.15), "top": (0.001, -0.3, 1.0), "iso": (0.6, -1.0, 0.6), } # Strip (X=length, Y=thickness, Z=width, pre-flatten - see # build_and_export_strip). X is the length axis to match build_border_solid, # which builds along local X (length) / local Z (width) - the same # (cx, cz)=(X, Z) convention add_box uses throughout. STRIP_W = 16.0 STRIP_D = 2.0 STRIP_L = 140.0 # Border: one straight rail down each long edge, RAIL_OUTER_INSET (1.0mm, # same as the rune panel borders) in from the true edge. No braid between # them - the 14mm channel stays flat. RAIL_OUTER_INSET = 1.0 RAIL_WIDTH = 0.6 BORDER_EMBOSS_HEIGHT = 0.8 BORDER_EMBED_DEPTH = 0.6 # Chamfer on all 12 slab edges - same reasoning as the rune panels: softens # the raw-slab look, and once laid flat for printing gives a scraper # something to wedge under on the bottom perimeter. Must stay clear of # where the rail starts (RAIL_OUTER_INSET - RAIL_WIDTH/2 = 0.7mm from the # true edge) so the bevel doesn't eat into the flat area the rail unions # onto. BOX_BEVEL_WIDTH = 0.4 BOX_BEVEL_SEGMENTS = 3 # ============================================================ # HELPERS # ============================================================ def clear_scene(): bpy.ops.object.select_all(action='SELECT') bpy.ops.object.delete() for block in list(bpy.data.meshes): bpy.data.meshes.remove(block) def apply_boolean(target, cutter, operation): mod = target.modifiers.new("Bool", 'BOOLEAN') mod.object = cutter mod.operation = operation mod.solver = 'EXACT' bpy.context.view_layer.objects.active = target bpy.ops.object.modifier_apply(modifier=mod.name) bpy.data.objects.remove(cutter, do_unlink=True) def frame_and_angle_view(): """Point the 3D viewport at a 3/4 angle on everything in the scene and zoom to fit - a dead flat front-on view of an emboss shows no foreshortening/shading, so straight-on is close to the worst angle to inspect it from.""" bpy.ops.object.select_all(action='DESELECT') mesh_objects = [o for o in bpy.context.scene.objects if o.type == 'MESH'] for obj in mesh_objects: obj.select_set(True) if mesh_objects: bpy.context.view_layer.objects.active = mesh_objects[0] for window in bpy.context.window_manager.windows: for area in window.screen.areas: if area.type != 'VIEW_3D': continue region = next((r for r in area.regions if r.type == 'WINDOW'), None) if region is None: continue with bpy.context.temp_override(window=window, area=area, region=region): bpy.ops.view3d.view_axis(type='FRONT') bpy.ops.view3d.view_orbit(angle=math.radians(-35), type='ORBITLEFT') bpy.ops.view3d.view_orbit(angle=math.radians(20), type='ORBITUP') bpy.ops.view3d.view_selected() return def compute_scene_bounds(): xs, ys, zs = [], [], [] for obj in bpy.context.scene.objects: if obj.type != 'MESH': continue for corner in obj.bound_box: world_corner = obj.matrix_world @ mathutils.Vector(corner) xs.append(world_corner.x) ys.append(world_corner.y) zs.append(world_corner.z) if not xs: return mathutils.Vector((0.0, 0.0, 0.0)), 10.0 center = mathutils.Vector(( (min(xs) + max(xs)) / 2, (min(ys) + max(ys)) / 2, (min(zs) + max(zs)) / 2, )) size = max(max(xs) - min(xs), max(ys) - min(ys), max(zs) - min(zs)) return center, size def setup_camera_and_light(center): cam_data = bpy.data.cameras.new("RenderCam") cam_obj = bpy.data.objects.new("RenderCam", cam_data) bpy.context.collection.objects.link(cam_obj) target = bpy.data.objects.new("RenderTarget", None) target.location = center bpy.context.collection.objects.link(target) track = cam_obj.constraints.new(type='TRACK_TO') track.target = target track.track_axis = 'TRACK_NEGATIVE_Z' track.up_axis = 'UP_Y' light_data = bpy.data.lights.new("RenderSun", type='SUN') light_data.energy = 3.0 light_obj = bpy.data.objects.new("RenderSun", light_data) light_obj.rotation_euler = (math.radians(55), 0.0, math.radians(35)) bpy.context.collection.objects.link(light_obj) bpy.context.scene.camera = cam_obj return cam_obj def render_angles(center, size): os.makedirs(RENDER_DIR, exist_ok=True) cam_obj = setup_camera_and_light(center) scene = bpy.context.scene try: scene.render.engine = 'BLENDER_EEVEE_NEXT' except TypeError: scene.render.engine = 'BLENDER_EEVEE' scene.render.resolution_x = RENDER_RESOLUTION[0] scene.render.resolution_y = RENDER_RESOLUTION[1] distance = size * 1.8 for name, direction in RENDER_ANGLES.items(): cam_obj.location = center + mathutils.Vector(direction).normalized() * distance scene.render.filepath = os.path.join(RENDER_DIR, f"{name}.png") bpy.ops.render.render(write_still=True) print(f"Rendered {scene.render.filepath}") def export_stl(obj, filename): bpy.ops.object.select_all(action='DESELECT') obj.select_set(True) bpy.context.view_layer.objects.active = obj path = os.path.join(EXPORT_DIR, filename) bpy.ops.wm.stl_export(filepath=path, export_selected_objects=True) print(f"Exported {path}") def add_box(bm, cx, cz, w, h, depth, angle_deg=0.0): """Appends a single axis-aligned (or Y-rotated) box into the given bmesh - width/height in local X/Z, `depth` in local Y (straddling Y=0).""" mat = (mathutils.Matrix.Translation((cx, 0.0, cz)) @ mathutils.Matrix.Rotation(math.radians(angle_deg), 4, 'Y') @ mathutils.Matrix.Diagonal(mathutils.Vector((w, depth, h, 1.0)))) bmesh.ops.create_cube(bm, size=1.0, matrix=mat) def bevel_box_edges(obj, width, segments): bm = bmesh.new() bm.from_mesh(obj.data) bmesh.ops.bevel( bm, geom=bm.edges[:], offset=width, offset_type='OFFSET', segments=segments, affect='EDGES', clamp_overlap=True, ) bm.to_mesh(obj.data) bm.free() def make_box_object(cx, cz, w, h, angle_deg, depth, name): bm = bmesh.new() add_box(bm, cx, cz, w, h, depth, angle_deg) mesh = bpy.data.meshes.new(name) bm.to_mesh(mesh) bm.free() obj = bpy.data.objects.new(name, mesh) bpy.context.collection.objects.link(obj) return obj def build_border_solid(strip_w, strip_l, depth): """Border: just the two straight rails, one down each long edge, at +-(strip_w/2 - RAIL_OUTER_INSET). No braid - flat channel between.""" rail_z = strip_w / 2 - RAIL_OUTER_INSET rail_a = make_box_object(0.0, rail_z, strip_l, RAIL_WIDTH, 0.0, depth, "rail_a") rail_b = make_box_object(0.0, -rail_z, strip_l, RAIL_WIDTH, 0.0, depth, "rail_b") apply_boolean(rail_a, rail_b, 'UNION') return rail_a def build_and_export_strip(): bpy.ops.mesh.primitive_cube_add(size=1) box = bpy.context.object box.name = "trim_plain" box.scale = (STRIP_L, STRIP_D, STRIP_W) bpy.ops.object.transform_apply(scale=True, location=False, rotation=False) bevel_box_edges(box, BOX_BEVEL_WIDTH, BOX_BEVEL_SEGMENTS) border_depth = BORDER_EMBOSS_HEIGHT + BORDER_EMBED_DEPTH border = build_border_solid(STRIP_W, STRIP_L, border_depth) # Box front face is at y=-STRIP_D/2 (outward normal -Y). The border # solid is built symmetric around its own local Y=0, so shift it in -Y # until its far edge stands proud past the front face by # BORDER_EMBOSS_HEIGHT and its near edge is buried BORDER_EMBED_DEPTH # past the surface (avoids a flush/coincident union boundary). border.location.y = -STRIP_D / 2 + (BORDER_EMBED_DEPTH - BORDER_EMBOSS_HEIGHT) / 2 apply_boolean(box, border, 'UNION') # Lie flat for direct-to-plate resin printing: local Y (thickness) -> # world -Z (down, on the plate), local Z (STRIP_W, the strip's width) # -> world Y; local X (STRIP_L, the strip's long axis) stays world X. box.rotation_euler.x = math.radians(-90) bpy.ops.object.select_all(action='DESELECT') box.select_set(True) bpy.context.view_layer.objects.active = box bpy.ops.object.transform_apply(location=False, rotation=True, scale=False) if EXPORT_STL: export_stl(box, f"{box.name}.stl") return box # ============================================================ # MAIN # ============================================================ def main(): os.makedirs(EXPORT_DIR, exist_ok=True) clear_scene() build_and_export_strip() if RENDER_IMAGES: center, size = compute_scene_bounds() render_angles(center, size) frame_and_angle_view() print(f"Done. Strip exported to {EXPORT_DIR}") if __name__ == "__main__": main()