def isShareEdge(srf1, srf2): border1 = rs.DuplicateSurfaceBorder(srf1) border2 = rs.DuplicateSurfaceBorder(srf2) edges1 = rs.ExplodeCurves(border1, True) edges2 = rs.ExplodeCurves(border2, True) shareMid = [] threshold = 0.001 flag = False for e1 in edges1: for e2 in edges2: mid1 = rs.CurveMidPoint(e1) mid2 = rs.CurveMidPoint(e2) if rs.Distance(mid1, mid2) < threshold: s1 = rs.CurveStartPoint(e1) s2 = rs.CurveStartPoint(e2) e1 = rs.CurveEndPoint(e1) e2 = rs.CurveEndPoint(e2) if rs.Distance(s1, s1) < threshold: flag = True break if rs.Distance(s1, e1) < threshold: flag = True break rs.DeleteObjects(edges1) rs.DeleteObjects(edges2) return flag
def wallProfile(polySrf): if polySrf: offsets = [] border = rs.DuplicateSurfaceBorder(polySrf) rs.SimplifyCurve(border) offsets.append(rs.OffsetCurve(border, [0, 0, 0], width / 2)) faces = rs.ExplodePolysurfaces(polySrf, False) faceborders = [rs.DuplicateSurfaceBorder(face) for face in faces] rs.DeleteObjects(faces) for faceborder in faceborders: rs.SimplifyCurve(faceborder) centroid = rs.CurveAreaCentroid(faceborder) offsets.append(rs.OffsetCurve(faceborder, centroid[0], width / 2)) rs.DeleteObjects(faceborders) srf = rs.AddPlanarSrf(offsets) rs.DeleteObjects(border) rs.DeleteObjects(offsets) return srf
def unroll(self): x = 0 for i in range(len(self.srfList)): g = rs.AddGroup() s, p = rs.UnrollSurface(self.srfList[i], False, self.unrollList[i]) s = rs.JoinSurfaces(s, True) p = rs.MoveObjects(p, [x, self.name * 10, 0]) s = rs.MoveObject(s, [x, self.name * 10, 0]) b = rs.DuplicateSurfaceBorder(s, 1) rs.ObjectLayer(b, "cut") rs.AddObjectsToGroup(b, g) rs.AddObjectsToGroup(p, g) bb = rs.BoundingBox(s) x += fabs(bb[0].X - bb[1].X) + 1 t = rs.AddText( str(self.name) + "-" + str(i), util.averagePt(rs.CurvePoints(b)), 0.3) t = util.makeEngravingFont(t) rs.AddObjectsToGroup(t, g) rs.DeleteObjects(s)
def makeFace(srfs): srfsJoined = rs.JoinSurfaces(srfs, True) boundaryCrv = rs.DuplicateSurfaceBorder(srfsJoined) srf = rs.AddPlanarSrf(boundaryCrv) rs.DeleteObjects(boundaryCrv) rs.DeleteObject(srfsJoined) rs.DeleteObjects(srfs) return srf
def getSrfHLimit(srf): boundary=rs.DuplicateSurfaceBorder(srf) pts=srf.CurveEditPoints(boundary) zs=[] for p in pts:zs.append(p[2]) zs.sort() top=zs[-1] bot=zs[0] return bot,top
def extframe(srf): crv = rs.DuplicateSurfaceBorder(srf, type=1) point = rs.EvaluateCurve(crv, 0) parameter = rs.SurfaceClosestPoint(srf, point) plane = rs.SurfaceFrame(srf, parameter) direction = rs.CurveTangent(crv, 0) newplane = rs.PlaneFromNormal(point, direction, plane.ZAxis) frame = sweepSec(crv, newplane, vec1) if crv: rs.DeleteObjects(crv) return frame
def isHorizontalUpSrf(srf,tolerance=TOLERANCE): boundary=rs.DuplicateSurfaceBorder(srf) if type(boundary is list):boundary=boundary[0] sp=rs.CurveStartPoint(boundary) uv=rs.SurfaceClosestPoint(srf,sp) normal=rs.SurfaceNormal(srf,uv) normal=rs.VectorUnitize(normal) nz=normal[2] rs.DeleteObject(boundary) if abs(nz-1)<tolerance:return True return False
def get_ref_pts(ref_obj, srf_num, indexes): obj_copy = rs.CopyObject(ref_obj) all_srf = rs.ExplodePolysurfaces(obj_copy) ref_srf = rs.DuplicateSurfaceBorder(all_srf[srf_num]) ref_lines = rs.ExplodeCurves(ref_srf) ref_points = [ rs.CurveEndPoint(ref_lines[indexes[0]]), rs.CurveEndPoint(ref_lines[indexes[1]]), rs.CurveEndPoint(ref_lines[indexes[2]]) ] return ref_points
def __init__(self, srfGUID): self.GUID = srfGUID self.borderGUID = rs.DuplicateSurfaceBorder(srfGUID) self.srfGeo = rs.coercesurface(srfGUID) self.brep = self.srfGeo.ToBrep() self.edgeCrvs = self.brep.DuplicateEdgeCurves() self.border = rg.Curve.JoinCurves( self.edgeCrvs )[0] self.nurbsCrv = self.border.ToNurbsCurve() amp = rg.AreaMassProperties.Compute(self.nurbsCrv, us.util.tol() ) self.Centroid = amp .Centroid self.Area = amp.Area
def getVertSrf(srfs): vertSrfs = [] for f in srfs: edges = rs.ExplodeCurves(rs.DuplicateSurfaceBorder(f), True) for e in edges: p1 = rs.CurveStartPoint(e) p2 = rs.CurveEndPoint(e) if p1[0] == p2[0] and p1[1] == p2[1]: vertSrfs.append(f) rs.DeleteObjects(edges) break rs.DeleteObjects(edges) return vertSrfs
def isHorizonalSrf(srf,return_dir=False,tolerance=TOLERANCE): boundary=rs.DuplicateSurfaceBorder(srf) if type(boundary is list):boundary=boundary[0] sp=rs.CurveStartPoint(boundary) uv=rs.SurfaceClosestPoint(srf,sp) normal=rs.SurfaceNormal(srf,uv) normal=rs.VectorUnitize(normal) direct=normal[2] nz=abs(normal[2]) rs.DeleteObject(boundary) if abs(nz-1)<tolerance: if return_dir:return True,direct return True if return_dir:return False,direct return False
def sweep_path_profile(path, profile, rotation, scale): if rh.IsCurve(profile): return single_ref_or_union( sweep_path_curve(path, profile, rotation, scale)) elif rh.IsSurface(profile): o_refs, i_refs = ([ solid_sweep_path_curve(path, border, rotation, scale) for border in rh.DuplicateSurfaceBorder(profile, i) ] for i in (1, 2)) if i_refs == []: return single_ref_or_union(o_refs) else: return subtract_refs(single_ref_or_union(o_refs), single_ref_or_union(i_refs)) else: raise RuntimeError('Continue this')
def splitIrregularPolygon(srf): boundary=rs.DuplicateSurfaceBorder(srf) if type(boundary) is list: crvs=rs.ExplodeCurves(boundary[0],False) rs.DeleteObjects(boundary) else :crvs=rs.ExplodeCurves(boundary,True) hors=[] for c in crvs: if isHorizontal(c): hors.append(c) pts=[] #print('hors=',hors) for c in hors: p=rs.CurveStartPoint(c) pts.append(p) rs.DeleteObjects(crvs)# #print('from splitIrregularPoly ',pts) return splitSrfVerticallyByPts(srf,pts)
def extframe(srf, vec): frames = [] crv = rs.DuplicateSurfaceBorder(srf, type=1) rs.SimplifyCurve(crv) domain = rs.CurveDomain(crv) param = (domain[0] + domain[1]) / 2.0 rs.CurveSeam(crv, param) point = rs.EvaluateCurve(crv, 0) parameter = rs.SurfaceClosestPoint(srf, point) plane = rs.SurfaceFrame(srf, parameter) direction = rs.CurveTangent(crv, 0) newplane = rs.PlaneFromNormal(point, direction, plane.ZAxis) frame.append(sweepSec(crv, newplane, vec)) if crv: rs.DeleteObjects(crv) return frames
def WindowFrame(): surf_int_edge_all = rs.DuplicateSurfaceBorder(surf[1], type=2) print len(surf_int_edge_all) window_frame_all = [] for item in range(0, len(surf_int_edge_all), 1): surf_int_edge = surf_int_edge_all[item] surf_int_edge = rs.ExplodeCurves(surf_int_edge, True) trans1 = rs.XformTranslation((0, 0, 2 * ipThick)) trans2 = rs.XformTranslation((0, 0, -2 * ipThick)) point_1 = rs.CurveStartPoint(surf_int_edge[0]) point_2 = rs.CurveStartPoint(surf_int_edge[1]) point_3 = rs.CurveStartPoint(surf_int_edge[2]) point_4 = rs.CurveStartPoint(surf_int_edge[3]) point_5 = rs.PointTransform(point_1, trans1) point_6 = rs.PointTransform(point_2, trans1) point_7 = rs.PointTransform(point_3, trans1) point_8 = rs.PointTransform(point_4, trans1) point_1 = rs.PointTransform(point_1, trans2) point_2 = rs.PointTransform(point_2, trans2) point_3 = rs.PointTransform(point_3, trans2) point_4 = rs.PointTransform(point_4, trans2) frame_points = [] frame_points.append(point_1) frame_points.append(point_2) frame_points.append(point_3) frame_points.append(point_4) frame_points.append(point_5) frame_points.append(point_6) frame_points.append(point_7) frame_points.append(point_8) window_frame = rs.AddBox(frame_points) window_frame_all.append(window_frame) return window_frame_all
def saveSurfaceBorders(): surfaces = rs.GetObjects('select surfaces', 8) filename = rs.SaveFileName() vI = 1 file = open(filename, "w") for surface in surfaces: layername = rs.ObjectLayer(surface) border = rs.DuplicateSurfaceBorder(surface) pts = rs.CurvePoints(border) pts = pts[:-1] indexes = [] for point in pts: file.write(getVertexString(point)) indexes.append(vI) vI += 1 file.write(getFaceStringComment(indexes, layername)) # file.write(getFaceString(indexes)) rs.DeleteObject(border) file.close() return
def borders(self, type=1): """Duplicate the borders of the surface. Parameters ---------- type : {0, 1, 2} The type of border. * 0: All borders * 1: The exterior borders. * 2: The interior borders. Returns ------- list The GUIDs of the extracted border curves. """ border = rs.DuplicateSurfaceBorder(self.guid, type=type) curves = rs.ExplodeCurves(border, delete_input=True) return curves
def getSrfTopBotVertCrvs(srf): tolerance = 0.0001 #borders=rs.DuplicateSurfaceBorder(srf,1) borders = rs.DuplicateSurfaceBorder(srf) crvs = rs.ExplodeCurves(borders) hor_crvs = [] ver_crvs = [] trash = [] for c in crvs: start = rs.CurveStartPoint(c) end = rs.CurveEndPoint(c) # print('checking z of end points:',start[2],end[2]) if abs(start[2] - end[2]) < tolerance: hor_crvs.append(c) elif abs(start[1] - end[1]) < tolerance and abs(start[0] - end[0]) < tolerance: ver_crvs.append(c) else: trash.append(c) # print('hor_crvs len:',len(hor_crvs)) hor_crvs = rs.JoinCurves(hor_crvs, True) bot = None top = None if len(hor_crvs) == 2: s1 = rs.CurveStartPoint(hor_crvs[0]) s2 = rs.CurveStartPoint(hor_crvs[1]) if s1[2] > s2[2]: bot = hor_crvs[1] top = hor_crvs[0] else: bot = hor_crvs[0] top = hor_crvs[1] rs.DeleteObjects(borders) rs.DeleteObjects(trash) return top, bot, ver_crvs
def create_slots(array, partIndex): """ Creates half-lap slots for a given part with its intersecting neighbors. Returns a list of tuples with part index and slot curve.""" numItems = len(array) if partIndex >= numItems: return "part index outside of array" part = array[partIndex] intersections = find_neighbor_intersections(array, partIndex) boundary = rs.DuplicateSurfaceBorder(part) slots = [] ## check intersections with the part's boundary to determine joint case ## rs.CurveCurveIntersection returns case specific lists see F1 help. for line in intersections: if len(line) == 1: return intersectTest = rs.CurveCurveIntersection(line[1], boundary) ## Case 1: slot is floating in part boundary (Only works in some cases) if intersectTest == None: slots.append((partIndex, line[1])) ## Case 2: intersection coincedent along an edge and can't be slotted elif intersectTest[0][0] == 2: print "no slot needed" ## Case 3: part and neighbor have a valid connection and slot is drawn else: ## create Current Part slot startPoint = intersectTest[0][1] endPoint = evaluateCrv(line[1], .5) slot = rs.AddLine(startPoint, endPoint) slots.append((partIndex, slot)) ## create neighbor slot testPoint = rs.CurveEndPoint(line[1]) distance = rs.Distance(startPoint, testPoint) if distance != 0: startPoint = testPoint else: startPoint = rs.CurveStartPoint(line[1]) slot = rs.AddLine(startPoint, endPoint) slots.append((line[0], slot)) return slots
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)
hatch_scale = rs.HatchScale(hatch) # Make hatch solid so we able to explode it and get surface instead if hatch_pattern != "Solid": rs.HatchPattern(hatch, "Solid") dup_border_surface = [] dup_border_surface.append(rs.ExplodeHatch(hatch)[0]) rs.SurfaceIsocurveDensity(dup_border_surface, 100) selected_objects.append(dup_border_surface) reduced_selected_objects = reduce(operator.add, selected_objects) rs.SelectObjects(reduced_selected_objects) rs.HideObject(hatch) rs.Command("_Trim") trimmed_surface = rs.LastCreatedObjects() new_borders = [] if trimmed_surface: for surface in trimmed_surface: new_borders.append(rs.DuplicateSurfaceBorder(surface)) selected_objects.append(new_borders) # Keep trimming lines but everything else will be deleted further selected_objects.remove(trim_lines) new_hatches = rs.AddHatches(new_borders, hatch_pattern, hatch_scale, hatch_rotation) rs.MatchObjectAttributes(new_hatches, hatch) rs.ShowObject(new_hatches) rs.DeleteObjects(trimmed_surface) else: print("No trimmed surfaces was created.") else: print("No hatches was selected.")
def Ramp_HeightSlope(path, width, slope): #Variables rampThickness = 6 handrailOffset = 3 handrailRadius = 1.5 handrailHeight = 34 if width < 36: width = 36 width = width + (handrailOffset * 2) comments = '' handrailCenterlineOffset = (handrailOffset - handrailRadius / 2) rs.SimplifyCurve(path) runs = MakeRampRuns(path, width) if slope > .05: runData = CheckRunLengths(runs) runs = runData[0] comments += runData[1] runGeo = [] hdrls = [] finalHandrails = [] vertMove = (0, 0, 0) for run in runs: length = rs.Distance(rs.CurveStartPoint(run[0]), rs.CurveStartPoint(run[1])) stHeight = vertMove vertMove = (0, 0, length * slope) rs.MoveObject(run[-1], vertMove) rs.MoveObjects(run, stHeight) vertMove = rs.VectorAdd(stHeight, vertMove) srf = rs.AddLoftSrf(run) norm = rs.SurfaceNormal(srf[0], [.5, .5]) if norm.Z < 0: rs.FlipSurface(srf[0], True) runGeo.append(srf[0]) else: runGeo.append(srf[0]) hdrls.append(MakeHandrailFromRuns(run, handrailCenterlineOffset)) rs.DeleteObjects(run) #Get highest and lowest lines landingEdges = [] for run in runGeo: curves = rs.DuplicateEdgeCurves(run) highestIndex = None highestValue = -999999 lowestIndex = None lowestValue = 999999 for i, curve in enumerate(curves): crvZ = rs.CurveMidPoint(curve)[2] if crvZ < lowestValue: lowestIndex = i lowestValue = crvZ if crvZ > highestValue: highestIndex = i highestValue = crvZ lowestEdge = rs.CopyObject(curves[lowestIndex]) highestEdge = rs.CopyObject(curves[highestIndex]) landingEdges.append(lowestEdge) rs.ReverseCurve(highestEdge) landingEdges.append(highestEdge) rs.DeleteObjects(curves) comments += 'Total ramp height {}"\n'.format(str(highestValue)) #Make Landings landingGeos = MakeRampLandings(landingEdges, handrailCenterlineOffset) landings = landingGeos[0] hdrls += landingGeos[1] allHandrails = [] for hdrl in hdrls: for each in hdrl: allHandrails.append(each) longRails = rs.JoinCurves(allHandrails, True) #Handrail Extension for rail in longRails: stPt = rs.CurveStartPoint(rail) stVec = rs.CurveTangent(rail, 0) stVecProj = rs.VectorScale( rs.VectorReverse(rs.VectorUnitize((stVec[0], stVec[1], 0))), 12) endPt = rs.CurveEndPoint(rail) endParam = rs.CurveClosestPoint(rail, endPt) endVec = rs.CurveTangent(rail, endParam) endVecProj = rs.VectorScale( rs.VectorUnitize((endVec[0], endVec[1], 0)), 12) stPtTemp = rs.CurveStartPoint(rail) endPtTemp = rs.CurveEndPoint(rail) stPtOffset = rs.MoveObject(stPtTemp, stVecProj) endPtOffset = rs.MoveObject(endPtTemp, endVecProj) stProj = rs.AddLine(stPt, stPtOffset) endProj = rs.AddLine(endPt, endPtOffset) finalHandrails.append(rs.JoinCurves([stProj, rail, endProj], True)[0]) rs.DeleteObject(stPtOffset) rs.DeleteObject(endPtOffset) #Move handrails up for rail in finalHandrails: rs.MoveObject(rail, (0, 0, handrailHeight)) #Make solid geometry topSurface = rs.JoinSurfaces(runGeo + landings, True) if topSurface is None: topSurface = runGeo btmSurface = rs.CopyObject(topSurface, (0, 0, -rampThickness)) edgeCurves = rs.DuplicateSurfaceBorder(topSurface) extrusionLine = rs.AddLine((0, 0, 0), (0, 0, -rampThickness)) extrusionGeo = rs.ExtrudeCurve(edgeCurves, extrusionLine) rs.DeleteObject(extrusionLine) rs.DeleteObject(edgeCurves) finalGeo = rs.JoinSurfaces([topSurface, btmSurface, extrusionGeo], True) #rs.EnableRedraw(True) #print "A" if slope <= .05: rs.DeleteObjects(finalHandrails) return [finalGeo, comments] else: return [finalGeo, comments, finalHandrails]
import rhinoscriptsyntax as rs import scriptcontext as sc import Rhino as rh viste = rs.ViewNames() for viewport in viste: rs.ViewDisplayMode(viewport, "Shaded") diametro = 1 brep = rs.GetObjects("dammi un solido", 16) brepexp = rs.ExplodePolysurfaces(brep) surface = rs.GetObject("dammi la superficie", 8) surf_edge = rs.DuplicateSurfaceBorder(surface, 1) new_surface = rs.CopyObject(surface, (0, 0, 0)) uv = [] temp_edge = rs.ExplodeCurves(surf_edge, False) list_evpt = [] for i in temp_edge: evpt = rs.CurveMidPoint(i) print evpt list_evpt.append(evpt) for i in list_evpt: bord = rs.SurfaceClosestPoint(new_surface, i) uv.append(bord) for i in uv: rs.ExtendSurface(new_surface, i, diametro * 10) edge = rs.OffsetCurveOnSurface(surf_edge, new_surface, -diametro) print edge if rs.CurveLength(edge) < rs.CurveLength(surf_edge): rs.DeleteObject(edge)
def surface_borders(surface, border_type=0): border = rs.DuplicateSurfaceBorder(surface, border_type) curves = rs.ExplodeCurves(border, delete_input=True) return curves
def rebuildSrfCrv(obj): crv = rs.DuplicateSurfaceBorder(obj, type=0) map(lambda x: rs.SimplifyCurve(x), crv) return crv
if abs(start[1]-end[1])<tolerance and abs(start[0]-end[0])<tolerance: return True return False def isHorizontal(crv,tolerance=0.0001): start=rs.CurveStartPoint(c) end=rs.CurveEndPoint(c) if abs(start[2]-end[2])<tolerance: return True return False objs=rs.ObjectsByLayer('GENMASSING') srf=objs[0] print(srf) boundary=rs.DuplicateSurfaceBorder(srf) pts=rs.CurveEditPoints(boundary) # rs.AddPoints(pts) crvs=rs.ExplodeCurves(boundary,True) hors=[] for c in crvs: if isHorizontal(c): hors.append(c) up=(0,0,100000000) cutters=[] for c in hors: p=rs.CurveStartPoint(c) start=rs.VectorSubtract(p,up) end=rs.VectorAdd(p,up) l=rs.AddLine(start,end)
def stairHeight(route, width=48, height=120): """ Makes a stair to specified height. input: route(pline), width (num), height(num) returns: Geo """ try: rs.EnableRedraw(False) rs.SimplifyCurve(route) if route is None: print("ERROR: No path selected") return if (rs.UnitSystem() == 2): #if mm maxRiserHeight = 180 thickness = 200 if (rs.UnitSystem() == 4): #if m maxRiserHeight = .180 thickness = .200 if (rs.UnitSystem() == 8): #if in" maxRiserHeight = 7 thickness = 9 negativeBoo = False if (height < 0): #if the stair negativeBoo = True landingEdges = [] landings = [] segments = rs.ExplodeCurves(route) if len(segments) < 1: segments = [rs.CopyObject(route)] landingHeight = [] geometry = [] #Check that all segments are lines for i in range(0, len(segments)): if not (rs.IsLine(segments[i])): print( "ERROR: This function only accepts lines. No arcs or nurb curves." ) rs.DeleteObjects(segments) return #first landing edge norm = rs.VectorRotate(rs.CurveTangent(segments[0], 0), 90, [0, 0, 1]) norm = rs.VectorScale(rs.VectorUnitize(norm), width / 2) side1Pt = rs.VectorAdd(rs.CurveStartPoint(segments[0]), norm) side2Pt = rs.VectorAdd(rs.CurveStartPoint(segments[0]), -norm) landingEdges.append(rs.AddLine(side1Pt, side2Pt)) #middle landing edges for i in range(0, len(segments) - 1): edgeList, landing = rampIntersection(segments[i], segments[i + 1], width) landingEdges.append(edgeList[0]) landingEdges.append(edgeList[1]) landings.append(landing) #last landing edge norm = rs.VectorRotate( rs.CurveTangent(segments[-1], rs.CurveParameter(segments[-1], 1)), 90, [0, 0, 1]) norm = rs.VectorScale(rs.VectorUnitize(norm), width / 2) side1Pt = rs.VectorAdd(rs.CurveEndPoint(segments[-1]), norm) side2Pt = rs.VectorAdd(rs.CurveEndPoint(segments[-1]), -norm) landingEdges.append(rs.AddLine(side1Pt, side2Pt)) #Add risers riserCrvs = [] treadVecs = [] numRisersPerRun = [] numRisers = abs(int(math.ceil(height / maxRiserHeight))) risersSoFar = 0 totalRun = getTotalRun(landingEdges) optTreadDepth = totalRun / (numRisers - 1) #2R+T = 635 riserHeight = height / numRisers if (negativeBoo): curRiserHeight = 0 else: curRiserHeight = riserHeight for i in range(0, len(landingEdges), 2): #find numRisers in each run a = rs.CurveMidPoint(landingEdges[i]) b = rs.CurveMidPoint(landingEdges[i + 1]) runDist = rs.Distance(a, b) numRisersThisRun = int(round((runDist / optTreadDepth), 0)) if (numRisersThisRun == 0): numRisersThisRun = 1 if (i == len(landingEdges) - 2): #if last run, add the rest of the risers numRisersThisRun = numRisers - risersSoFar else: risersSoFar = risersSoFar + numRisersThisRun numRisersPerRun.append(numRisersThisRun) #Create Risers on Plan for i in range(0, len(landingEdges), 2): run = [] a = rs.CurveMidPoint(landingEdges[i]) b = rs.CurveMidPoint(landingEdges[i + 1]) centerStringer = rs.AddLine(a, b) runDist = rs.Distance(a, b) numRisersThisRun = numRisersPerRun[int(i / 2)] #risers in this run tarPts = rs.DivideCurve(centerStringer, numRisersThisRun, create_points=False) rs.DeleteObject(centerStringer) for j in range(0, numRisersThisRun + 1): if (j == 0): treadVecs.append(rs.VectorCreate(tarPts[0], tarPts[1])) transVec = rs.VectorCreate(tarPts[0], tarPts[j]) run.append(rs.CopyObject(landingEdges[i], -transVec)) riserCrvs.append(run) print('Flight {0} has {1} risers: {3}" tall, Treads: {2}" deep'. format( int(i / 2) + 1, numRisersThisRun, rs.VectorLength(treadVecs[int(i / 2)]), riserHeight)) #Move riser edges vertically for i in range(0, len(riserCrvs)): triangles = [] if (negativeBoo): for j in range(0, len(riserCrvs[i]) - 1): #if stairs descending rs.MoveObject( riserCrvs[i][j], rs.VectorAdd([0, 0, curRiserHeight], -treadVecs[i])) riserGeo = rs.ExtrudeCurveStraight(riserCrvs[i][j], [0, 0, 0], [0, 0, riserHeight]) treadGeo = rs.ExtrudeCurveStraight(riserCrvs[i][j], [0, 0, 0], treadVecs[i]) stPt = rs.AddPoint(rs.CurveStartPoint(riserCrvs[i][j])) pt1 = rs.CopyObject( stPt, [0, 0, riserHeight]) #first riser in run pt2 = rs.CopyObject(stPt, treadVecs[i]) #last riser in run triCrv = rs.AddPolyline([stPt, pt1, pt2, stPt]) triangles.append(rs.AddPlanarSrf(triCrv)) geometry.append(riserGeo) #riser geometry.append(treadGeo) #tread curRiserHeight = curRiserHeight + riserHeight rs.MoveObject(riserCrvs[i][j], treadVecs[i]) #cleanup rs.DeleteObject(triCrv) rs.DeleteObject(stPt) rs.DeleteObject(pt1) rs.DeleteObject(pt2) else: for j in range(0, len(riserCrvs[i]) - 1): #if stairs ascend rs.MoveObject(riserCrvs[i][j], [0, 0, curRiserHeight]) stPt = rs.AddPoint(rs.CurveStartPoint(riserCrvs[i][j])) pt1 = rs.CopyObject( stPt, [0, 0, -riserHeight]) #first riser in run pt2 = rs.CopyObject(stPt, -treadVecs[i]) #last riser in run triCrv = rs.AddPolyline([stPt, pt1, pt2, stPt]) triangles.append(rs.AddPlanarSrf(triCrv)) riserGeo = rs.ExtrudeCurveStraight(riserCrvs[i][j], [0, 0, 0], [0, 0, -riserHeight]) treadGeo = rs.ExtrudeCurveStraight(riserCrvs[i][j], [0, 0, 0], -treadVecs[i]) geometry.append(riserGeo) #riser geometry.append(treadGeo) #tread curRiserHeight = curRiserHeight + riserHeight #cleanup rs.DeleteObject(triCrv) rs.DeleteObject(stPt) rs.DeleteObject(pt1) rs.DeleteObject(pt2) #Make Stringer if (negativeBoo): firstStartPt = rs.AddPoint(rs.CurveStartPoint(riserCrvs[i][0])) lastStartPt = rs.AddPoint(rs.CurveStartPoint(riserCrvs[i][-2])) #rs.MoveObject(firstStartPt, [0,0,riserHeight]) #first riser in run rs.MoveObject(lastStartPt, -treadVecs[i]) #last riser in run rs.MoveObject(lastStartPt, [0, 0, riserHeight]) #last riser in run else: firstStartPt = rs.AddPoint(rs.CurveStartPoint(riserCrvs[i][0])) lastStartPt = rs.AddPoint(rs.CurveStartPoint(riserCrvs[i][-2])) rs.MoveObject(firstStartPt, [0, 0, -riserHeight]) #first riser in run rs.MoveObject(lastStartPt, -treadVecs[i]) #last riser in run stringerCrv = rs.AddLine(firstStartPt, lastStartPt) stringerSrf = rs.ExtrudeCurveStraight(stringerCrv, [0, 0, 0], [0, 0, -thickness]) triangles.append(stringerSrf) stringer = makeFace(triangles) stringerVec = rs.VectorCreate(rs.CurveEndPoint(riserCrvs[i][0]), rs.CurveStartPoint(riserCrvs[i][0])) underside = rs.ExtrudeCurveStraight( stringerCrv, rs.CurveStartPoint(riserCrvs[i][0]), rs.CurveEndPoint(riserCrvs[i][0])) geometry.append(rs.MoveObject(underside, [0, 0, -thickness])) geometry.append(rs.CopyObject(stringer, stringerVec)) geometry.append(stringer) #cleanup rs.DeleteObject(firstStartPt) rs.DeleteObject(lastStartPt) rs.DeleteObject(stringerCrv) rs.DeleteObject(stringerSrf) #Move Landings lastLandingHeight = 0 for i in range(0, len(segments) - 1): landingHeight = lastLandingHeight + numRisersPerRun[i] * riserHeight rs.MoveObject(landings[i], [0, 0, landingHeight]) landingTopSrf = rs.AddPlanarSrf(landings[i]) landingBtmSrf = rs.CopyObject(landingTopSrf, [0, 0, -thickness]) geometry.append(landingTopSrf) geometry.append(landingBtmSrf) lastLandingHeight = landingHeight landingEdgesToEx = rs.ExplodeCurves(landings[i]) geometry.append( rs.ExtrudeCurveStraight(landingEdgesToEx[1], [0, 0, 0], [0, 0, -thickness])) geometry.append( rs.ExtrudeCurveStraight(landingEdgesToEx[2], [0, 0, 0], [0, 0, -thickness])) rs.DeleteObjects(landingEdgesToEx) #Create final geometry joinedGeo = rs.JoinSurfaces(geometry, True) holes = rs.DuplicateSurfaceBorder(joinedGeo) cap = rs.AddPlanarSrf(holes) newGeo = rs.ExplodePolysurfaces(joinedGeo, True) for i in cap: newGeo.append(i) FinalGeo = rs.JoinSurfaces(newGeo, True) #cleanup try: rs.DeleteObjects(segments) except: rs.DeleteObject(segments) rs.DeleteObjects(holes) rs.DeleteObjects(landings) rs.DeleteObjects(landingEdges) for i in riserCrvs: rs.DeleteObjects(i) rs.EnableRedraw(True) return FinalGeo except: print "Error" return None
def hatch_3d(): objs = rs.GetObjects("Select surfaces to hatch", rs.filter.surface, select=True) for obj in objs: rs.DuplicateSurfaceBorder(obj, type=1)
def borders(self): """""" border = rs.DuplicateSurfaceBorder(self.guid, type=1) curves = rs.ExplodeCurves(border, delete_input=True) return curves
def hatchFromSrf(srf): border = rs.DuplicateSurfaceBorder(srf, type=0) hatch = rs.AddHatches(border, "SOLID") rs.DeleteObjects(border) return hatch