def cut_building_volumes(terrain_section_breps, bldg_section_breps): """ input: list of lists of extruded terrain breps and section breps. first level of list is section heights, second level is breps. output: the new terrain breps """ #boolean problem is caused by non-manifold error. need to scale the B_breps prior to booleaning. new_terrain_section_breps = [] for i, brep_level in enumerate(terrain_section_breps): new_level_terrain_section_breps = [] for A_brep in brep_level: #rs.ObjectLayer(A_brep,"s10") #debug B_breps = rs.CopyObjects(bldg_section_breps[i]) #[rs.ObjectLayer(B_brep,"s11") for B_brep in B_breps] #debug boolean_result = rs.BooleanDifference([A_brep], B_breps, False) if boolean_result: c = [rs.CopyObject(x) for x in boolean_result] rs.DeleteObjects(boolean_result) new_level_terrain_section_breps.extend(c) else: new_level_terrain_section_breps.append(rs.CopyObject(A_brep)) #print new_level_terrain_section_breps rs.DeleteObjects(A_brep) rs.DeleteObjects(B_breps) rs.DeleteObjects(B_breps) #possibly not needed rs.DeleteObjects(boolean_result) #rs.ObjectLayer(new_level_terrain_section_breps,"s3") new_terrain_section_breps.append(new_level_terrain_section_breps) return new_terrain_section_breps
def main(): # first, select objects in three orthogonal planes xs = rs.GetObjects("select X objects", filter=16) # polysurface ys = rs.GetObjects("select Y objects", filter=16) zs = rs.GetObjects("select Z objects", filter=16) subdivisions = rs.GetInteger(message="enter subdivisions (odd)", number=5, minimum=2, maximum=None) for positive, negative, hidden in ((xs, ys, zs), (xs, zs, ys), (ys, zs, xs)): rs.HideObjects(hidden) make_fingers(positive, negative, subdivisions) rs.ShowObjects(hidden) # each time make_fingers is run, it fills guid_to_difference # with more fingers to subtract. # after all the fingers are subtracted at once for guid, objs in guid_to_difference.items(): if objs: rs.BooleanDifference(guid, objs)
def perform_subtraction(): # each time make_fingers is run, it fills guid_to_difference # with more fingers to subtract. # after all the fingers are subtracted at once for guid, objs in guid_to_difference.items(): print guid, len(objs) rs.BooleanDifference(guid, objs)
def subtrackCubeFrom(self, curid, pts, height): btmSuf = rs.AddSrfPt(pts) extrudeLine = rs.AddLine(pts[0],map(sum, zip(pts[0],[0,0,height]))) suf = rs.ExtrudeSurface(btmSuf, extrudeLine, True) newid = rs.BooleanDifference(curid,suf,True) rs.DeleteObjects([btmSuf,extrudeLine,suf]) return newid
def addHallWall(self, roomids, corners, corners2, thickness, height): outWallCrv = rs.AddPolyline(corners) inWallCrv = rs.AddPolyline(corners2) #inWallCrv = rs.OffsetCurve(outWallCrv, [20,14,0], thickness, [0,0,1], CurveOffsetCornerStyle.Sharp) outExtrudeLine = rs.AddLine(corners[0],map(sum, zip(corners[0],[0,0,height]))) outBtmSuf = rs.AddPlanarSrf(outWallCrv)[0] outWall = rs.ExtrudeSurface(outBtmSuf, outExtrudeLine, True) inExtrudeLine = rs.AddLine(corners[0],map(sum, zip(corners[0],[0,0,height-thickness]))) inBtmSuf = rs.AddPlanarSrf(inWallCrv)[0] inWall = rs.ExtrudeSurface(inBtmSuf, inExtrudeLine, True) hallway = rs.BooleanDifference(outWall,inWall,True) rs.DeleteObjects([outWallCrv,inWallCrv,outExtrudeLine,outBtmSuf,outWall,inExtrudeLine,inBtmSuf,inWall]) newroomids = list(roomids) for roomid in roomids: newhallway = rs.BooleanDifference(hallway, roomid,False) newroomid = rs.BooleanDifference(roomid, hallway,False) newroomids.append(newroomid) rs.DeleteObject(hallway) rs.DeleteObject(roomid) hallway = newhallway return hallway
def main(): to_delete = [] rs.ProjectOsnaps(False) positive_object = rs.GetObject("select positive object", 16) negative_object = rs.GetObject("select negative object", 16) rs.HideObject(negative_object) polysurface, face = GetSubSurface("select tenon surface") to_delete.append(face) normal = rs.VectorUnitize(rs.SurfaceNormal(face, (0.5, 0.5))) plane = rs.PlaneFromNormal(rs.EvaluateSurface(face, 0.5, 0.5), normal) rs.ViewCPlane(plane=plane) rs.ProjectOsnaps(True) tenon_rects = rs.GetObjects(message="select tenon curves", filter=4) tenon_faces = [] for rect in tenon_rects: tenon_faces.append(rs.AddPlanarSrf(rect)[0]) rs.ShowObject(negative_object) rs.ProjectOsnaps(False) height_pt = rs.GetPoint("enter height point") # compule a vector normal to plane of the desired height extrude_vec_a = rs.EvaluateSurface(face, 0.5, 0.5) dist = rs.DistanceToPlane(plane, height_pt) extrude_vec_b = [dist * el for el in normal] extrude_vec_b = rs.VectorAdd(extrude_vec_a, extrude_vec_b) extrude_curve = rs.AddCurve((extrude_vec_a, extrude_vec_b)) to_delete.append(extrude_curve) tenons = [] for tenon_face in tenon_faces: tenon = rs.ExtrudeSurface(tenon_face, extrude_curve) tenons.append(tenon) rs.BooleanUnion([positive_object] + tenons, delete_input=False) rs.BooleanDifference([negative_object], tenons, delete_input=False) to_delete.append(positive_object) to_delete.append(negative_object) rs.DeleteObjects(to_delete) rs.DeleteObjects(tenon_faces) rs.DeleteObjects(tenons)
def get_frame_brep(outline_srf, border_thickness, thickness): """get the frame brep. This is a solid that is booleaned with the slices of terrain to make a border when border mode is on.""" edge_crvs = rs.DuplicateEdgeCurves(outline_srf) outline_crv = rs.JoinCurves(edge_crvs) pt, _ = rs.CurveAreaCentroid(outline_crv) inner_crv = rs.OffsetCurve(outline_crv, pt, border_thickness, [0, 0, 1]) rs.MoveObjects([outline_crv, inner_crv], [0, 0, thickness * 2]) path_line = rs.AddLine([0, 0, 0], [0, 0, -thickness * 4]) inner_brep = rs.ExtrudeCurve(inner_crv, path_line) outer_brep = rs.ExtrudeCurve(outline_crv, path_line) rs.CapPlanarHoles(inner_brep) rs.CapPlanarHoles(outer_brep) frame_brep = rs.BooleanDifference([outer_brep], [inner_brep]) rs.DeleteObjects([outline_crv, inner_crv]) rs.DeleteObjects(edge_crvs) rs.DeleteObject(path_line) return frame_brep
def SplitGeometry(objs, plane, dir=1): global diffRadius circle = Rhino.Geometry.Circle(plane, diffRadius) negShape = Rhino.Geometry.Cylinder(circle, diffRadius * dir) negShapeBrep = negShape.ToBrep(True, True) negShapeGeo = sc.doc.Objects.AddBrep(negShapeBrep) visibleGeometry = [] for obj in objs: if rs.IsBrep(obj): if rs.IsPolysurfaceClosed(obj): resultObjs = rs.BooleanDifference(obj, negShapeGeo, False) if resultObjs is None: visibleGeometry.append(obj) elif len(resultObjs) < 1: visibleGeometry.append(obj) else: for each in resultObjs: visibleGeometry.append(each) else: resultObjs = rs.SplitBrep(obj, negShapeGeo) if resultObjs is None: visibleGeometry.append(obj) elif len(resultObjs) < 1: visibleGeometry.append(obj) else: for each in resultObjs: if IsAbovePlane(each, plane.OriginZ): if dir == -1: visibleGeometry.append(each) else: rs.DeleteObject(each) else: if dir == 1: visibleGeometry.append(each) else: rs.DeleteObject(each) rs.DeleteObject(negShapeGeo) return visibleGeometry
(newPtCoord[0]+xnum,newPtCoord[1]+ynum,newPtCoord[2]),(newPtCoord[0],newPtCoord[1]+ynum,newPtCoord[2]),\ (newPtCoord[0],newPtCoord[1],newPtCoord[2]+znum),(newPtCoord[0]+xnum,newPtCoord[1],\ newPtCoord[2]+znum),(newPtCoord[0]+xnum,newPtCoord[1]+ynum,newPtCoord[2]+znum),\ (newPtCoord[0],newPtCoord[1]+ynum,newPtCoord[2]+znum)]) pts.append(newPt) boxes.append(newboxArray) #for each new box created, boolean difference the previous box #newObject = rs.BooleanIntersection(boxes[i-1],boxes[i],delete_input=False) if i == 1: intersectTrue = rs.IntersectBreps(boxes[i - 1], boxes[i]) if intersectTrue: newObject = rs.BooleanDifference(boxes[i - 1], boxes[i], delete_input=False) else: print "No Intersection" else: intersectTrue = rs.IntersectBreps(newObject, boxes[i]) if intersectTrue: newObject = rs.BooleanDifference(newObject, boxes[i], delete_input=False) else: print "nothing" #newObject = boxes[i] #rs.DeleteObject(boxes[i])
def main(): global inner_curves, outer_curves, curve_coords # save for later orig_hidden_objects = rs.HiddenObjects() # we put reference points in the dogbone-ref layer, so create it if it doesn't exist rs.AddLayer("dogbone-ref") panel, face = getsubsurface.GetSubSurface("select dogbone face") diameter = rs.GetReal("enter cutter diameter", number=0.25) diameter = diameter * 1.1 rs.EnableRedraw(False) # compute the plane normal = rs.VectorUnitize(rs.SurfaceNormal(face, (0.5, 0.5))) plane = rs.PlaneFromNormal(rs.EvaluateSurface(face, 0.5, 0.5), normal) rs.ViewCPlane(plane=plane) rs.ProjectOsnaps(True) outer_curves = rs.DuplicateSurfaceBorder(face, 1) inner_curves = rs.DuplicateSurfaceBorder(face, 2) # make a dict mapping each curve to the coords in that curve curve_coords = dict() for curve in outer_curves + inner_curves: coords = rs.CurvePoints(curve)[:-1] curve_coords[curve] = coords # make a dict mapping each curve to the z component of its cross product at each index curve_cross_zs = dict() for curve, coords in curve_coords.items(): proj_coords = [rs.SurfaceClosestPoint(face, coord) for coord in coords] cross_zs = [] for idx in range(len(proj_coords)): triplet = [ proj_coords[(idx + 1) % len(proj_coords)], proj_coords[idx], proj_coords[(idx - 1) % len(proj_coords)] ] v0 = (triplet[1][0] - triplet[0][0], triplet[1][1] - triplet[0][1], 0) v1 = (triplet[2][0] - triplet[1][0], triplet[2][1] - triplet[1][1], 0) cross_z = rs.VectorCrossProduct(v0, v1)[2] cross_zs.append(cross_z) curve_cross_zs[curve] = cross_zs points = [] bones = [] temp_points = [] rs.EnableRedraw(True) while True: coord = rs.GetPoint("select corner") if coord is None: break try: curve, idx = get_curve_and_idx_for_coord(coord) point = rs.AddPoint(coord) rs.ObjectColor(point, (255, 0, 0)) temp_points.append(point) bones.append((curve, idx)) except ValueError: print "invalid curve point" continue rs.EnableRedraw(False) rs.DeleteObjects(temp_points) # try to automatically identify dogbone points if user selected none if len(bones) == 0: for curve, coords in curve_coords.items(): proj_coords = [ rs.SurfaceClosestPoint(face, coord) for coord in coords ] for idx in range(len(proj_coords)): triplet = [ proj_coords[(idx + 1) % len(proj_coords)], proj_coords[idx], proj_coords[(idx - 1) % len(proj_coords)] ] if curve_cross_zs[curve][idx] > 0: bones.append((curve, idx)) # make the bones extrusions = [] for bone in bones: curve, idx = bone coords = curve_coords[curve] point = rs.AddPoint(coords[idx]) rs.ObjectLayer(point, "dogbone-ref") triplet = [ coords[(idx + 1) % len(coords)], coords[idx], coords[(idx - 1) % len(coords)], ] angle = rs.Angle2( (triplet[1], triplet[0]), (triplet[1], triplet[2]), ) angle = angle[0] # This is a hacky method to determine the handedness of the curve # the cross product SHOULD have worked here, but for some reason # it did not. v0 = triplet[2][0] - triplet[1][0], triplet[2][1] - triplet[1][1], 0 v1 = triplet[1][0] - triplet[0][0], triplet[1][1] - triplet[0][1], 0 _angle = math.degrees( math.atan2(v0[1], v0[0]) - math.atan2(v1[1], v1[0])) while _angle > 180: _angle -= 360 while _angle < -180: _angle += 360 if math.copysign(1, angle) != math.copysign(1, _angle): angle -= 180 point = rs.VectorAdd( triplet[1], rs.VectorRotate( 0.5 * diameter * rs.VectorUnitize(rs.VectorSubtract(triplet[2], triplet[1])), angle / 2, (0, 0, 1))) circle = rs.AddCircle((point.X, point.Y, -10), diameter / 2.0) circle_srf = rs.AddPlanarSrf(circle) p0 = (point.X, point.Y, -10) p1 = (point.X, point.Y, 10) line = rs.AddLine(p0, p1) extrusion = rs.ExtrudeSurface(circle_srf, line) extrusions.append(extrusion) rs.DeleteObjects([circle, circle_srf, line]) rs.BooleanDifference([panel], extrusions, delete_input=True) rs.DeleteObject(panel) rs.DeleteObjects(extrusions) rs.DeleteObjects(points) rs.DeleteObjects(inner_curves) rs.DeleteObjects(outer_curves) rs.DeleteObject(face) rs.ShowObject(rs.AllObjects()) rs.HideObjects(orig_hidden_objects) rs.EnableRedraw(True)
def piece(layers, maxScale): curves = [] initialRadii = [] results = [] for i in range(count): initialRadii.append(random.uniform(minScale * maxScale, maxScale)) # outerExtrusions outerExtrusions = [] radii = initialRadii[:] for layer in range(layers): height = layer * layerHeight smooth(radii, smoothAmount) shrink(radii, outerReduce) scale(radii, random.uniform(1 - wiggle, 1 + wiggle)) scale(radii, upwardsShaping(layer / (layers - 1))) vertices = [] for i in range(count): theta = 2 * math.pi * i / count vertices.append((math.sin(theta) * radii[i], math.cos(theta) * radii[i], height)) vertices.append(vertices[0]) curve = rs.AddCurve(vertices, 5) curves.append(curve) if complete: extrusion = rs.ExtrudeCurveStraight(curve, (0, 0, 0), (0, 0, layerHeight)) rs.CapPlanarHoles(extrusion) outerExtrusions.append(extrusion) if not hollow: results.append(extrusion) if hollow: for i in range(shrinkPasses): shrink(radii, innerReduce) # innerExtrusions for layer in range(layers): actualLayer = layers - layer - 1 height = actualLayer * layerHeight smooth(radii, smoothAmount) shrink(radii, innerReduce) vertices = [] for i in range(count): theta = 2 * math.pi * i / count vertices.append((math.sin(theta) * radii[i], math.cos(theta) * radii[i], height)) vertices.append(vertices[0]) curve = rs.AddCurve(vertices, 5) curves.append(curve) if complete: extrusion = rs.ExtrudeCurveStraight(curve, (0, 0, 0), (0, 0, layerHeight)) rs.CapPlanarHoles(extrusion) result = rs.BooleanDifference(outerExtrusions[actualLayer], extrusion) results.append(result) if downwards: radii = initialRadii[:] for layer in range(downwardsLayers): height = -(layer + 1) * layerHeight smooth(radii, smoothAmount) shrink(radii, downwardsReduce) scale(radii, random.uniform(1 - wiggle, 1 + wiggle)) scale(radii, downwardsShaping(layer / (downwardsLayers - 1))) vertices = [] for i in range(count): theta = 2 * math.pi * i / count vertices.append((math.sin(theta) * radii[i], math.cos(theta) * radii[i], height)) vertices.append(vertices[0]) curve = rs.AddCurve(vertices, 5) curves.append(curve) if complete: extrusion = rs.ExtrudeCurveStraight(curve, (0, 0, 0), (0, 0, layerHeight)) rs.CapPlanarHoles(extrusion) outerExtrusions.append(extrusion) if not hollow: results.append(extrusion) if buildScaffolding: scaffoldBase = rs.AddRectangle( (-scaffoldSide / 2, -scaffoldSide / 2, 0), scaffoldSide, scaffoldSide) scaffold = rs.ExtrudeCurveStraight(scaffoldBase, (0, 0, 0), (0, 0, (layers - 1) * layerHeight)) rs.CapPlanarHoles(scaffold) rs.DeleteObject(scaffoldBase) results.append(scaffold) if complete: rs.DeleteObjects(curves) rs.AddObjectsToGroup(results, rs.AddGroup()) return results else: rs.AddObjectsToGroup(curves, rs.AddGroup()) return curves
def convertLayers( objs, material_thickness ): invalid_layers =[] # first find relevant layers layers = [] volumes = [] subtracts = [] # sort objects for obj in objs: layer_name = rs.ObjectLayer(obj) # todo's # - add Clamex m = re.search( '(\d.\d.\d)\s'+ # '.+(Pocket|Engrave|Inner contour|Outer contour|Drill|Saw-X|Saw-Y|Clamex horizontaal|Clamex verticaal).+'+ '.+(Pocket|Engrave|Inner contour|Outer contour|Drill|Saw-X|Saw-Y|Clamex horizontaal).+'+ '((?<=\s\+)\d+\.?\d*|(?<=\s)d\d+\.?\d*)' , layer_name) if m and len(m.groups()) == 3: tool_id = m.group(1) operation = m.group(2) z_pos = m.group(3) if operation == 'Outer contour': volume = makeExtrusions(m, obj, material_thickness) if volume: volumes.append(volume) elif operation == "Pocket" or operation == 'Pocket' or operation=='Drill': pocket = createPockets(m, obj) if pocket: subtracts.append(pocket ) elif operation == 'Engrave': pocket = makeEngraves(m, obj) if pocket: subtracts.append(pocket ) else: invalid_layers.append(layer_name) # rs.CopyObjects(subtracts) myset = set(invalid_layers) msg = 'layers could not be processed:\n' for layer in myset: msg += '- ' + layer + "\n" # rs.MessageBox(msg) part = None if len(subtracts)> 0: part = rs.BooleanDifference(volumes, subtracts, False) rs.DeleteObjects(volumes) else: part = volumes if part: return part, subtracts else: rs.MessageBox('part could not be created')
)) layer1 = rss.BooleanUnion( quad_rotate_object( extrude_crv_along_line( beam_path, beam_origin, (0, BEAM_WIDTH, 0) ))) if ADD_JUNCTION: # Original `base` is deleted during the boolean union, re-binding name `base` for later reference. base = rss.BooleanUnion( base + quad_rotate_object( rss.AddCylinder((CORE_RADIUS, 0, PLANE_HEIGHT), 3, 0.8) )) diff = rss.BooleanDifference(layer1, base, delete_input=False) rss.DeleteObject(layer1) layer1 = diff if REMOVE_DRAFT: rss.DeleteObject(beam_path) # Part 2: Layer 2 PLANE_HEIGHT = 75 BEAM_LENGTH = 80 BEAM_HALF_LENGTH = BEAM_LENGTH / 2 if BUILD_TARGET == 'all' or 'layer2' in BUILD_TARGET: beam_origin = (CORE_RADIUS, BEAM_HALF_LENGTH, PLANE_HEIGHT)
# if nghd['name'] != 'Central Oakland': # continue # uncomment the above to try out one nghd border_points = nghd['border'] curve = rs.AddPolyline(border_points) surface = rs.AddPlanarSrf(curve) extrusion_line = rs.AddLine((0,0,0), (0,0,3)) solid = rs.ExtrudeSurface(surface, extrusion_line) rs.DeleteObjects([curve, surface, extrusion_line]) for pipe in nghd['pipes']: p0 = pipe[0] p1 = pipe[1] pipe_line = rs.AddLine((p0[0], p0[1], -.5), (p1[0], p1[1], 3.5)) pipe = rs.AddPipe(pipe_line, 0, 0.5, cap=2) rs.DeleteObject(pipe_line) new_solid = None try: new_solid = rs.BooleanDifference([solid], [pipe]) except: print "a boolean difference failed in " + nghd['name'] rs.DeleteObject(pipe) continue if new_solid == None: rs.DeleteObject(pipe) continue # boolean difference failed, just skip one pipe else: solid = new_solid
def main(): # get objects to export objs = rs.GetObjects("select objects to Make3d", 0, True, True) if not objs: print "make3d aborted"; return defaults = { 'material_thickness':18 } defaults = getDefaultValues(defaults, 'TNM_make3d') material_thickness = rs.GetReal("Material Thickness", number=defaults['material_thickness']) storeDefaultValues('TNM_make3d', {'material_thickness':material_thickness} ) rs.EnableRedraw(False) checkPos(objs) set_volumes = [] set_subtracts = [] fail_objects =[] for obj in objs: if rs.IsBlockInstance(obj): # get content copy = rs.CopyObject(obj) content = ce.explodeBlock( [copy] ) # filter objects to only curves and points copies = ce.filterObjects(content) copies = ce.joinCurves(copies) # copies = ce.joinCurves(copies) ce.simplify(copies) volumes, subtracts = convertToVolumes(copies, material_thickness) parts = volumes for subtract in subtracts: if rs.IsPolysurface(parts[0]) and rs.IsPolysurface(subtract) and rs.IsPolysurfaceClosed(parts[0]) and rs.IsPolysurfaceClosed(subtract): # print parts # print subtract temp_parts = rs.BooleanDifference(parts, [subtract], False) if temp_parts: print 'subtract success' rs.DeleteObjects(parts) rs.DeleteObject(subtract) parts = temp_parts else: print 'boolean differce failed on: %s' % subtract fail_objects.append(subtract) else: print 'boolean differce failed on: %s' % subtract fail_objects.append(subtract) # addResultToBlock(obj, result) else: # add warning message collision check print obj rs.UnselectAllObjects() rs.SelectObjects(fail_objects) intersect = None # for i, volume in enumerate(set_volumes): # for j, subtracts in enumerate(set_subtracts): # if(i != j): # print rs.ObjectLayer(volume) # intersect = rs.BooleanIntersection(rs.CopyObject(volume), subtracts, False) # if intersect: # rs.SelectObjects(intersect) # rs.DeleteObjects(subtracts) if intersect: rs.MessageBox("ERROR") rs.DeleteObjects(copies) ce.redraw()
def make_hinge(num_knuckles, knuckle_height, knuckle_radius, thickness, leaf_length, gap, add_vents): origin = [0, 0, 0] hinge_height = num_knuckles * knuckle_height ###################################################################### # Make pin with caps cap_radius = knuckle_radius - 0.5 * thickness - gap cap_height = thickness cap_bottom = rs.AddCylinder(origin, cap_height, cap_radius) cap_top = rs.AddCylinder([0, 0, hinge_height - cap_height], cap_height, cap_radius) pin_radius = knuckle_radius - (gap + thickness) pin = rs.AddCylinder(origin, hinge_height, pin_radius) pin = rs.BooleanUnion([pin, cap_bottom, cap_top]) ###################################################################### # Make knuckle and holes right_knuckle = rs.AddCylinder(origin, hinge_height, knuckle_radius) knuckle_pin_hole = rs.AddCylinder(origin, hinge_height, knuckle_radius - thickness) knuckle_bottom_hole = rs.AddCylinder(origin, cap_height + gap, cap_radius + gap) knuckle_top_hole = rs.AddCylinder([0, 0, hinge_height - cap_height - gap], cap_height + gap, cap_radius + gap) ###################################################################### # Make leaves right_p0 = (0, knuckle_radius, 0) right_p1 = (leaf_length, knuckle_radius - thickness, hinge_height) right_leaf = rs.AddBox(mz.box_verts_from_corners(right_p0, right_p1)) right_leaf = rs.BooleanUnion([right_knuckle, right_leaf]) right_leaf, = rs.BooleanDifference( [right_leaf], [knuckle_pin_hole, knuckle_bottom_hole, knuckle_top_hole]) mirror_leaf = rs.XformMirror(origin, (1, 0, 0)) left_leaf = rs.TransformObject(right_leaf, mirror_leaf, True) ###################################################################### # Cut out alternating knuckles z0 = 0 sz = knuckle_radius + gap left_boxes = [] right_boxes = [] vent_height = knuckle_height - 4 * thickness for stage in range(num_knuckles): z1 = z0 + knuckle_height if stage == 0: cur_z0 = z0 else: cur_z0 = z0 - 0.5 * gap if stage == num_knuckles - 1: cur_z1 = z1 else: cur_z1 = z1 + 0.5 * gap knuckle_box = rs.AddBox( mz.box_verts_from_corners((-sz, -sz, cur_z0), (sz, sz, cur_z1))) if stage % 2 == 0: left_boxes.append(knuckle_box) else: right_boxes.append(knuckle_box) if add_vents: zmid = z0 + 0.5 * knuckle_height za = zmid - 0.5 * vent_height zb = zmid + 0.5 * vent_height mid_box = rs.AddBox( mz.box_verts_from_corners((-sz, -pin_radius - gap, za), (sz, pin_radius + gap, zb))) if stage % 2 == 0: right_boxes.append(mid_box) else: left_boxes.append(mid_box) z0 += knuckle_height left_leaf, = rs.BooleanDifference([left_leaf], left_boxes) right_leaf, = rs.BooleanDifference([right_leaf], right_boxes) rs.SelectObjects([left_leaf, right_leaf, pin]) rs.Command('MergeAllFaces')
def main(): rectangle = rs.GetObject("Select rectangle to create mortise and tenon from", rs.filter.curve, True, True) errorCheck = curveErrorCheck(rectangle) if errorCheck == True: return lines = rs.ExplodeCurves(rectangle) errorCheck = lineErrorCheck(lines) if errorCheck == True: return face = rs.GetObject("Select tenon surface", rs.filter.surface, False, True, None, True) length = rs.GetReal("Enter tenon length", number=None) if length and length != 0: x = 0 else: print "Failed....No length was entered" return depth = rs.GetReal("Enter mortise depth", number=length+0.05) if depth and depth != 0: x = 0 else: print "Failed....No depth was entered" return fit = rs.GetReal("Enter mortise fit", number=0.01) line1 = rs.AddLine(rs.CurveStartPoint(lines[0]),rs.CurveEndPoint(lines[0])) line2 = rs.AddLine(rs.CurveStartPoint(lines[1]),rs.CurveEndPoint(lines[1])) line3 = rs.AddLine(rs.CurveStartPoint(lines[2]),rs.CurveEndPoint(lines[2])) line4 = rs.AddLine(rs.CurveStartPoint(lines[3]),rs.CurveEndPoint(lines[3])) rs.DeleteObjects(lines) lines = line1, line2, line3, line4 if rs.CurveLength(lines[0]) > rs.CurveLength(lines[1]): smallside = rs.CurveLength(lines[1]) longside1 = lines[0] longside2 = lines[2] else: smallside = rs.CurveLength(lines[0]) longside1 = lines[1] longside2 = lines[3] filletRadius = smallside/2 fillet1 = rs.CurveFilletPoints (lines[0], lines[1]) fillet2 = rs.CurveFilletPoints (lines[1], lines[2]) fillet3 = rs.CurveFilletPoints (lines[2], lines[3]) fillet4 = rs.CurveFilletPoints (lines[3], lines[0]) arc1 = rs.AddFilletCurve(lines[0],lines[1], radius = filletRadius) arc2 = rs.AddFilletCurve(lines[1],lines[2], radius = filletRadius) arc3 = rs.AddFilletCurve(lines[2],lines[3], radius = filletRadius) arc4 = rs.AddFilletCurve(lines[3],lines[0], radius = filletRadius) arcs = arc1, arc2, arc3, arc4 arcs = rs.JoinCurves(arcs) arcEnd1 = rs.CurveEndPoint(arcs[0]) arcStart1 = rs.CurveStartPoint(arcs[0]) arcEnd2 = rs.CurveEndPoint(arcs[1]) arcStart2 = rs.CurveStartPoint(arcs[1]) if rs.Distance(arcEnd1, arcEnd2) > rs.Distance(arcEnd1,arcStart2): temp = arcEnd2 arcEnd2 = arcStart2 arcStart2 = temp line1 = rs.AddLine(arcEnd1, arcEnd2) line2 = rs.AddLine(arcStart1, arcStart2) curves = line1, arcs[0], arcs[1], line2 tenonOut = rs.JoinCurves(curves) tenonSurf = rs.AddPlanarSrf(tenonOut) point = rs.SurfacePoints(face) param = rs.SurfaceClosestPoint(face, point[0]) normal = rs.SurfaceNormal(face, param) normal = normal * length vect = rs.AddLine( arcEnd1, arcEnd1 + normal ) tenon = rs.ExtrudeSurface(tenonSurf, vect, cap=True) rs.DeleteObjects(curves) arcs = arc1, arc2, arc3, arc4 rs.DeleteObjects(arcs) rs.DeleteObject(rectangle) rs.ExtendCurveLength(longside1, 0, 0, fit) rs.ExtendCurveLength(longside1, 0, 1, fit) rs.ExtendCurveLength(longside2, 0, 0, fit) rs.ExtendCurveLength(longside2, 0, 1, fit) if rs.Distance(rs.CurveEndPoint(longside1), rs.CurveEndPoint(longside2)) < rs.Distance(rs.CurveStartPoint(longside1), rs.CurveEndPoint(longside2)): line1Start = rs.CurveEndPoint(longside1) line1End = rs.CurveEndPoint(longside2) line2Start = rs.CurveStartPoint(longside1) line2End = rs.CurveStartPoint(longside2) else: line1Start = rs.CurveStartPoint(longside1) line1End = rs.CurveEndPoint(longside2) line2Start = rs.CurveEndPoint(longside1) line2End = rs.CurveStartPoint(longside2) shortside1 = rs.AddLine(line1Start, line1End) shortside2 = rs.AddLine(line2Start, line2End) arc1 = rs.AddFilletCurve(longside1, shortside1, radius = filletRadius) arc2 = rs.AddFilletCurve(shortside1, longside2, radius = filletRadius) arc3 = rs.AddFilletCurve(longside2, shortside2, radius = filletRadius) arc4 = rs.AddFilletCurve(shortside2, longside1, radius = filletRadius) arcs = arc1, arc2, arc3, arc4 arcs = rs.JoinCurves(arcs) arcEnd1 = rs.CurveEndPoint(arcs[0]) arcStart1 = rs.CurveStartPoint(arcs[0]) arcEnd2 = rs.CurveEndPoint(arcs[1]) arcStart2 = rs.CurveStartPoint(arcs[1]) if rs.Distance(arcEnd1, arcEnd2) > rs.Distance(arcEnd1,arcStart2): temp = arcEnd2 arcEnd2 = arcStart2 arcStart2 = temp line1 = rs.AddLine(arcEnd1, arcEnd2) line2 = rs.AddLine(arcStart1, arcStart2) curves = line1, arcs[0], arcs[1], line2 mortiseOut = rs.JoinCurves(curves) mortiseSurf = rs.AddPlanarSrf(mortiseOut) param = rs.SurfaceClosestPoint(face, point[0]) normal = rs.SurfaceNormal(face, param) normal = normal * depth vect = rs.AddLine( arcEnd1, arcEnd1 + normal ) mortise = rs.ExtrudeSurface(mortiseSurf, vect, cap=True) rs.DeleteObject(shortside1) rs.DeleteObject(shortside2) rs.DeleteObject(mortiseOut) rs.DeleteObject(mortiseSurf) rs.DeleteObjects(curves) rs.DeleteObjects(lines) arcs = arc1, arc2, arc3, arc4 rs.DeleteObjects(arcs) rs.DeleteObject(rectangle) rs.DeleteObject(tenonOut) rs.DeleteObject(tenonSurf) mortiseSide = rs.GetObject("Select part to mortise", rs.filter.polysurface, False, False) tenonSide = rs.GetObject("Select part to tenon", rs.filter.polysurface, False, False) tenonUnion = tenonSide, tenon rs.BooleanDifference(mortiseSide, mortise, delete_input = True) rs.BooleanUnion(tenonUnion, delete_input = True) return
def cut_frame_from_brep(brep, frame): bdiff = rs.BooleanDifference(brep, frame, False) if bdiff: rs.DeleteObject(brep) brep = bdiff return brep
def rc_terraincut2(b_obj, building_guids, etching_guids): join_dist = 0 if str(b_obj.ObjectType) != "Brep": b_geo = extrusion_to_brep(b_obj.Geometry) else: b_geo = b_obj.Geometry outline_crv = get_surface_outline(b_geo) #wrh.add_curves_to_layer(outline_crv,1) #extrude down the topography surface in order to take sections bool_merged = Rhino.Geometry.Brep.MergeCoplanarFaces(b_geo, D_TOL) extruded_srf_id = extrude_down_srf(wrh.docobj_to_guid(b_obj)) extruded_srf = rs.coercebrep(extruded_srf_id) #get planes for sectioning. planes = get_section_planes(b_geo, THICKNESS) #get the section curves and the section srfs #rs.Redraw() section_srfs = [] for i, plane in enumerate(planes): #print i #if first level, get brep outline if i > 0: plane_sections = get_section(extruded_srf, plane) else: plane_sections = outline_crv ###DEBUG STARTS#### current_level_srfs = [] for crv in plane_sections: closed = crv.IsClosed if not closed: dist = rs.Distance(crv.PointAtStart, crv.PointAtEnd) res = crv.MakeClosed(dist * 2) join_dist = dist if dist > join_dist else join_dist if res == False: return 0 new_brep = Rhino.Geometry.Brep.CreatePlanarBreps(crv)[0] current_level_srfs.append(new_brep) #new_brep_added = doc.Objects.AddBrep(new_brep) #rs.ObjectLayer(new_brep_added,"s15") ###DEBUG ENDS### section_srfs.append(current_level_srfs) rs.DeleteObject(extruded_srf_id) #get extrusions of section srfs extruded_section_breps = [] boolean_section_breps = [] frame_base_surface = None for i, brep_level in enumerate(section_srfs): extruded_breps = [] for brep in brep_level: srf_added = wrh.add_brep_to_layer(brep, LCUT_IND[2]) if i == 0: frame_base_surface = rs.CopyObject(srf_added) extruded_breps.append(rs.ExtrudeSurface(srf_added, SHORT_GUIDE)) rs.DeleteObject(srf_added) extruded_section_breps.append(extruded_breps) #rs.Redraw() #make voids for existing buildings building_breps = building_guids bldg_subtraction_breps = get_building_booleans(building_breps, planes) if bldg_subtraction_breps: extruded_section_breps = cut_building_volumes(extruded_section_breps, bldg_subtraction_breps) [rs.DeleteObjects(x) for x in bldg_subtraction_breps] #purge the building breps num_divisions = len(section_srfs) frame_brep = get_frame_brep(frame_base_surface, BORDER_THICKNESS, THICKNESS * num_divisions) rs.DeleteObject(frame_base_surface) #boolean out the features final_breps = [] for i, brep_level in enumerate(extruded_section_breps): boolean_level_ind = i + 2 final_level_breps = [] if boolean_level_ind < len(extruded_section_breps): for A_brep in brep_level: final_brep = None B_breps = [] for B_srf in section_srfs[boolean_level_ind]: B_breps.append(rs.ExtrudeSurface(B_srf, LONG_GUIDE)) #truncate the B_breps if BORDER_BOOL: B_breps = [ cut_frame_from_brep(b, frame_brep) for b in B_breps ] #rs.AddLayer("debug6",[50,200,50]) #debug #rs.ObjectLayer(B_breps,"debug6") #handle a bug creating lists of lists sometimes. if isinstance(B_breps[0], (list, )): B_breps = B_breps[0] boolean_result = rs.BooleanDifference([A_brep], B_breps, False) rs.DeleteObjects(B_breps) if boolean_result: final_brep = boolean_result else: final_brep = rs.CopyObjects([A_brep]) rs.DeleteObjects([A_brep]) #rs.ObjectLayer(B_breps,"debug6") #rs.AddLayer("s11",[200,200,50]) #debug #rs.ObjectLayer(final_brep,"s11") #debug final_level_breps.extend(final_brep) else: #rs.ObjectLayer(A_brep,"s11") final_level_breps.extend(brep_level) final_breps.append(final_level_breps) #get the final surfaces by iterating through the final section breps and extracting the top faces. final_srfs = [] for i, breplevel in enumerate(final_breps): final_srfs_level = [] for brep in breplevel: xsrf = wge.get_extreme_srf(rs.coercebrep(brep), 5) final_srfs_level.append( doc.Objects.Add(xsrf[0].DuplicateFace( False))) #must properly type the faces #rs.ObjectLayer(final_srfs_level,"s4") final_srfs.append(final_srfs_level) [rs.DeleteObjects(x) for x in final_breps] #DEBUG #project etching layers to final srfs final_srfs.reverse() #get the boundary curves main_curves = [] guide_curves = [] etch_curves = [] for i, srflevel in enumerate(final_srfs): main_curves_level = [] guide_curves_level = [] etch_curves_level = [] for srf in srflevel: sb = rs.DuplicateSurfaceBorder(srf) sb_outer = rs.DuplicateSurfaceBorder(srf, 1) if sb: main_curves_level.extend(sb) if i < len(final_srfs) - 1 and sb_outer: p = rs.ProjectCurveToSurface(sb_outer, final_srfs[i + 1], [0, 0, -1]) if p: guide_curves_level.extend(p) rs.DeleteObject(sb_outer) if sb_outer: rs.DeleteObject(sb_outer) #refactor... etch_curves_level = project_etching(etching_guids, srflevel) etch_curves.append(etch_curves_level) main_curves.append(main_curves_level) guide_curves.append(guide_curves_level) flat_srf_list = [item for sublist in final_srfs for item in sublist] etch_curves.reverse() main_curves.reverse() guide_curves.reverse() bb = rs.BoundingBox(b_geo) layout_dist = rs.Distance(bb[0], bb[3]) + LASER_GAP preview_dist = rs.Distance(bb[0], bb[1]) + LASER_GAP movement_range = [(i + 1) * layout_dist for i in xrange(len(main_curves))] for i, level_list in enumerate(main_curves): cp_main = rs.CurvePlane(level_list[0]) rs.MoveObjects(level_list, [0, movement_range[i], -cp_main.OriginZ]) if etch_curves[i]: rs.MoveObjects(etch_curves[i], [0, movement_range[i], -cp_main.OriginZ]) if i > 0: cp_guide = rs.CurvePlane(guide_curves[i][0]) rs.MoveObjects(guide_curves[i], [0, movement_range[i - 1], -cp_guide.OriginZ]) main_curves = [item for sublist in main_curves for item in sublist] guide_curves = [item for sublist in guide_curves for item in sublist] etch_curves = [item for sublist in etch_curves for item in sublist] preview_geo = [item for sublist in final_srfs for item in sublist] rs.MoveObjects(preview_geo, [preview_dist, 0, 0]) #close the boundary curves cb_crvs = [] for c in guide_curves: if not rs.IsCurveClosed(c): if rs.IsCurveClosable(c, D_TOL): cb_curves.append(rs.CloseCurve(rs.CopyObject(c))) else: cb_crvs.append(rs.CopyObject(c)) etch_curves = wge.trim_boundary(etch_curves, cb_crvs, D_TOL) rs.DeleteObjects(cb_crvs) rs.DeleteObject(frame_brep) rs.ObjectLayer(main_curves, "XXX_LCUT_01-CUT") rs.ObjectLayer(guide_curves, "XXX_LCUT_03-LSCORE") rs.ObjectLayer(etch_curves, "XXX_LCUT_04-ENGRAVE") rs.ObjectLayer(preview_geo, "XXX_LCUT_00-GUIDES") if join_dist > 0: s = "Had to force-close gaps up to a distance of " + str(join_dist) Rhino.RhinoApp.WriteLine(s) return 1