def delResult(self): for i in self.req_obj: srf = i.getSrf() try: rs.DeleteObjects(srf) except: try: rs.DeleteObjects(srf) except: pass int_poly = i.getReqPoly() try: rs.DeleteObjects(int_poly) except: try: rs.DeleteObject(int_poly) except: pass bound_poly = i.getGenPoly() try: rs.DeleteObjects(bound_poly) except: try: rs.DeleteObject(bound_poly) except: pass
def setSensorLocation(): projectedPtList = [] # Select boundary surface boundarySrf = rs.GetObject("Select surface for making boundary", rs.filter.surface) # For making location point with grid direction = (0, 0, 100) plane = rs.MoveObject(boundarySrf, direction) # Dividing surface to points ptList = ArrayPointsOnSurface(plane) # point projection projectedSrf = rs.GetObject("Select surface for projection", rs.filter.surface) for point in ptList: pointsOnModel = rs.ProjectPointToSurface(point, projectedSrf, (0, 0, 1)) projectedPt = rs.AddPoint(pointsOnModel[0][0], pointsOnModel[0][1], pointsOnModel[0][2]) projectedPtList.append(projectedPt) rs.DeleteObjects(plane) rs.DeleteObjects(ptList) return projectedPtList
def unionAllCurves(Curves): res = [] for curveCount in range(0, len(Curves), 2): try: sc.doc = rc.RhinoDoc.ActiveDoc #change target document rs.EnableRedraw(False) guid1 = sc.doc.Objects.AddCurve(Curves[curveCount]) guid2 = sc.doc.Objects.AddCurve(Curves[curveCount + 1]) all = rs.CurveBooleanUnion([guid1, guid2]) rs.DeleteObjects(guid1) rs.DeleteObjects(guid2) if all: a = [rs.coercegeometry(a) for a in all] for g in a: g.EnsurePrivateCopy() #must ensure copy if we delete from doc rs.DeleteObjects(all) sc.doc = ghdoc #put back document rs.EnableRedraw() if a == None: a = [Curves[curveCount], Curves[curveCount + 1]] except: rs.DeleteObjects(guid1) sc.doc = ghdoc #put back document rs.EnableRedraw() a = [Curves[curveCount]] if a: res.extend(a) return res
def SplitObject(solid, cSrf): preInnerSrf = rs.CopyObject(cSrf) innerSrfs = rs.TrimBrep(preInnerSrf, solid) if not innerSrfs: rs.DeleteObject(preInnerSrf) return [solid] solids = [] solids.append(solid) for srf in innerSrfs: newSolids = [] for obj in solids: splitObjs = rs.SplitBrep(obj, srf, True) if not splitObjs: newSolids.append(obj) else: for sObj in splitObjs: toJoin = [sObj, srf] newSolids.append(rs.JoinSurfaces(toJoin)) rs.DeleteObjects(splitObjs) solids = newSolids rs.DeleteObjects(innerSrfs) return solids
def recSplit(self, iniPts, counter=0): p=iniPts vertical=False if(rs.Distance(p[0],p[1])>rs.Distance(p[0],p[3])): vertical=True if(vertical==True): p0,p1=self.verSplit(iniPts) else: p0,p1=self.horSplit(iniPts) poly0=rs.AddPolyline(p0) poly1=rs.AddPolyline(p1) counter+=1 if(counter<3): pts0=self.getIntxCrv(poly0) pts1=self.getIntxCrv(poly1) rs.DeleteObjects([poly0,poly1]) self.recSplit(pts0,counter) self.recSplit(pts1,counter) else: intxCrv0=rs.CurveBooleanIntersection(self.SITECRV,poly0) intxCrv1=rs.CurveBooleanIntersection(self.SITECRV,poly1) for i in intxCrv0: self.FPOLY.append(i) for i in intxCrv1: self.FPOLY.append(i) rs.DeleteObjects([poly0,poly1]) rs.DeleteObject(self.crv)
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 divideSrfToPattern(srf, facadeType): top, bot, verts = getSrfTopBotVertCrvs(srf) if bot is None: print('bot is None exit') return None if not rs.IsCurve(bot): print('bot is not Curve exit') return None if len(verts) < 1: print('len(verts)<1') return None if not rs.IsCurve(verts[0]): print('verts[0] is not a curve') return None p0 = rs.CurveStartPoint(verts[0]) p1 = rs.CurveEndPoint(verts[0]) if p1[2] > p0[2]: vect = p1 - p0 else: vect = p0 - p1 print(vect) rs.EnableRedraw(False) m = meshExtrudeCrvToPattern(bot, facadeType, vect) rs.DeleteObjects([top, bot]) rs.DeleteObjects(verts) rs.EnableRedraw(True) return m
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 createcurvaturegraph(): curve_ids = rs.GetObjects("Curves for curvature graph", 4, False, True, True) if not curve_ids: return samples = 10 scale = 1.0 preview = [] while True: rs.EnableRedraw(False) for p in preview: rs.DeleteObjects(p) preview = [] for id in curve_ids: cg = addcurvaturegraph(id, samples, scale) preview.append(cg) rs.EnableRedraw(True) result = rs.GetString("Curvature settings", "Accept", ("Samples", "Scale", "Accept")) if not result: for p in preview: rs.DeleteObjects(p) break result = result.upper() if result == "ACCEPT": break elif result == "SAMPLES": numsamples = rs.GetInteger("Number of samples per knot-span", samples, 3, 100) if numsamples: samples = numsamples elif result == "SCALE": sc = rs.GetReal("Scale of the graph", scale, 0.01, 1000.0) if sc: scale = sc
def teardown(cfg): print("teardown") cfg['view'].Close() """ activate_display_mode(cfg['view_restore']['disp_mode'], cfg) cfg['view'].Maximized = cfg['view_restore']['maximized'] cfg['view'].Size = cfg['view_restore']['size'] """ if 'pad_obj_ids' in cfg and cfg['pad_obj_ids']: print("... deleting padding objects") rs.DeleteObjects(cfg['pad_obj_ids']) if 'tmp_obj_ids' in cfg and cfg['tmp_obj_ids']: print("... deleting xformed objects") rs.DeleteObjects(cfg['tmp_obj_ids']) if 'rot_group' in cfg and cfg['rot_group']: print("... rotating objects back to their starting position") rxf = rs.XformRotation2(-cfg['tot_rot'], (0, 0, 1), cfg['rot_group']['bbox'].Center) rs.TransformObjects(cfg['rot_group']['obj_ids'], rxf) show_all_groups(cfg) sc.doc.RenderSettings = cfg['render_settings'] for mode in cfg['display_modes'].keys(): if mode == 'rndr': continue if not Rhino.Display.DisplayModeDescription.DeleteDiplayMode( cfg['display_modes'][mode].Id): print( "Temporary display mode {} was not deleted. Consider removing this yourself." .format(cfg['display_modes'][mode].EnglishName)) delete_residual_display_modes() return
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 sweepSec(crv, plane, vec): rect = profileXform(rectFrame(), plane, vec) sweep = rs.AddSweep1(crv, rect, closed=True) sweep = rs.CapPlanarHoles(sweep) if rect: rs.DeleteObjects(rect) if crv: rs.DeleteObjects(crv) return sweep
def squareSect(crv,width,height): sections=[] divPts=rs.DivideCurve(crv,10) keep=True for i in range(len(divPts)): param=rs.CurveClosestPoint(crv,divPts[i]) tan=rs.CurveTangent(crv,param) plane=rs.PlaneFromNormal(divPts[i],tan) sect=rs.AddRectangle(plane,width,height) cpt=rs.CurveAreaCentroid(sect)[0] vec=rs.VectorCreate(divPts[i],cpt) sect=rs.MoveObject(sect,vec) if i>0: if testAlign(sect,oldSect)==False: sect=align(sect,oldSect,divPts[i],tan) oldSect=sect sections.append(sect) branch=rs.AddLoftSrf(sections,None,None,2,0,0,False) edges=rs.DuplicateEdgeCurves(branch) if width>height: testVal=height else: testVal=width for i in range(len(edges)): testPt=rs.CurveMidPoint(edges[i]) for j in range(len(edges)): param=rs.CurveClosestPoint(edges[j],testPt) pt=rs.EvaluateCurve(edges[j],param) if rs.Distance(pt,testPt)<testVal/6: keep=False rs.DeleteObjects(sections) rs.DeleteObjects(edges) return branch
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 sweepSec(crv, plane, vec): # rs.AddPlaneSurface( plane, 1, 1 ) rect = profile2(plane, vec) sweep = rs.AddSweep1(crv, rect, closed=True) sweep = rs.CapPlanarHoles(sweep) if rect: rs.DeleteObjects(rect) if crv: rs.DeleteObjects(crv) return sweep
def makeBrep(srf): point1 = rs.EvaluateSurface(srf, 0, 0) vec = rs.CreateVector(0, 0, height) point2 = rs.CopyObject(point1, vec) line = rs.AddLine(point1, point2) brep = rs.ExtrudeSurface(srf, line) if point2: rs.DeleteObjects(point2) if line: rs.DeleteObjects(line) return brep
def process_floor(in_objects, floor_outline, outline_cut_height=None): """function used to process an individual floor. input: in_objects: the internal curves and breps selected for this floor floor_outline: the outline brep for the envelope outline_cut_height: height to cut at. output: (crv,[crv]) crv: the offset boundary curve for the floor [crv]: the internal curves for the floor pt: lower-left reference point bdims = bounding dims of this floor """ #classify the inputs in_crvs, in_breps = brep_or_crv(in_objects) #get list of crvs to project brep_sections = [] for b in in_breps: cut_height = wge.get_brep_height(b) / 2 pcurves = wge.get_brep_plan_cut(rs.coercebrep(b), cut_height, D_TOL) brep_sections.extend(pcurves) b_section_guids = wru.add_curves_to_layer(brep_sections, LCUT_INDICES[0]) in_crvs.extend(b_section_guids) #get the outline brep curve if not outline_cut_height: outline_cut_height = wge.get_brep_height(floor_outline) floor_outline_crvs = wge.get_brep_plan_cut(rs.coercebrep(floor_outline), outline_cut_height, D_TOL) floor_outline_crvs = wru.add_curves_to_layer(floor_outline_crvs, LCUT_INDICES[1]) #get bounding info for the floor outline bb = rs.BoundingBox(floor_outline) corner = bb[0] bdims = wge.get_bounding_dims(floor_outline) proj_srf = rs.AddSrfPt([bb[0], bb[1], bb[2], bb[3]]) internal_crvs = rs.ProjectCurveToSurface(in_crvs, proj_srf, [0, 0, -1]) if in_crvs else [] offset_floor_crv = rs.ProjectCurveToSurface(floor_outline_crvs, proj_srf, [0, 0, -1]) #rs.DeleteObjects(in_crvs) rs.DeleteObjects(floor_outline_crvs) rs.DeleteObject(proj_srf) out_floor_crvs = rs.coercecurve(offset_floor_crv) out_internal_crvs = [rs.coercecurve(x) for x in internal_crvs] rs.DeleteObject(offset_floor_crv) rs.DeleteObjects(internal_crvs) rs.DeleteObjects(b_section_guids) #TODO: make sure objects are being deleted return out_floor_crvs, out_internal_crvs, corner, bdims
def setPlanarBaseSurface(self): ''' set surface that is planar surface this surface will be made from additiveObj this surface will be used in offsetNonPlanarSurface() ''' explodedSurfaces = rs.ExplodePolysurfaces(self.additiveObj) editPoint = [] if len(explodedSurfaces) is 0: meshed = rhino.Geometry.Mesh.CreateFromBrep( rs.coercebrep(self.additiveObj)) editPoint = rs.MeshVertices(meshed[0]) else: for i in explodedSurfaces: meshed = rhino.Geometry.Mesh.CreateFromBrep(rs.coercebrep(i)) vertices = rs.MeshVertices(meshed[0]) editPoint.extend(vertices) rs.DeleteObjects(explodedSurfaces) xValues = [i[0] for i in editPoint] yValues = [i[1] for i in editPoint] xValues.sort() yValues.sort() xMin = xValues[0] xMax = xValues[-1] yMin = yValues[0] yMax = yValues[-1] lineForSur = [] lineForSur.append(rs.AddLine((xMin, yMin, 0), (xMax, yMin, 0))) lineForSur.append(rs.AddLine((xMax, yMin, 0), (xMax, yMax, 0))) lineForSur.append(rs.AddLine((xMax, yMax, 0), (xMin, yMax, 0))) lineForSur.append(rs.AddLine((xMin, yMax, 0), (xMin, yMin, 0))) joinedCurve = rs.JoinCurves(lineForSur) rs.DeleteObjects(lineForSur) curveForSur = rs.OffsetCurve(joinedCurve, (0, 0, 1), 20) if len(curveForSur) > 1: curveForSur = rs.OffsetCurve(joinedCurve, (0, 0, 1), -20) self.basePlanarSurface = rs.AddPlanarSrf(curveForSur) rs.DeleteObjects(curveForSur) if self.basePlanarSurface is None: return False return True
def mapping(discretization_spacing, surface_guid, curve_features_guids = [], point_features_guids = []): """Creates planar polylines from the boundaries of a NURBS surface, NURBS curves and point on the NURBS surface by using the UV parameterisation with a user-input discretisation spacing. Parameters ---------- discretization_spacing: real Spacing value for discretisation of NURBS surface borders and curves into polylines. surface: Rhino surface guid Untrimmed or trimmed Rhino NURBS surface. curve_features: Rhino curve guid Rhino NURBS curve on the surface. point_features: Rhino point guid Rhino point on the surface. Returns ------- output: list Planar parameterised geometrical output: boundary, holes, polyline features and point features. Raises ------ - """ boundaries = surface_borders(surface_guid, border_type = 1) boundary_polylines = [curve_discretisation(boundary, discretization_spacing) for boundary in boundaries] uv_boundary_polylines = [[rs.SurfaceClosestPoint(surface_guid, vertex) for vertex in rs.PolylineVertices(boundary_polyline)] for boundary_polyline in boundary_polylines] planar_boundary_polylines = [[[u, v, 0] for u, v in uv_boundary_polyline] for uv_boundary_polyline in uv_boundary_polylines] planar_boundary_polyline = [] for polyline in planar_boundary_polylines: planar_boundary_polyline += polyline[: -1] planar_boundary_polyline.append(planar_boundary_polyline[0]) rs.DeleteObjects(boundaries) rs.DeleteObjects(boundary_polylines) holes = surface_borders(surface_guid, border_type = 2) if len(holes) > 1: holes = rs.JoinCurves(holes, delete_input = True) hole_polylines = [curve_discretisation(hole, discretization_spacing) for hole in holes] uv_hole_polylines = [[rs.SurfaceClosestPoint(surface_guid, vertex) for vertex in rs.PolylineVertices(hole_polyline)] for hole_polyline in hole_polylines] planar_hole_polylines = [[[u, v, 0] for u, v in hole] for hole in uv_hole_polylines] rs.DeleteObjects(holes) rs.DeleteObjects(hole_polylines) polyline_features = [curve_discretisation(curve_features_guid, discretization_spacing) for curve_features_guid in curve_features_guids] uv_polyline_features = [[rs.SurfaceClosestPoint(surface_guid, vertex) for vertex in rs.PolylineVertices(polyline_feature)] for polyline_feature in polyline_features] planar_polyline_features = [[[u, v, 0] for u, v in feature] for feature in uv_polyline_features] rs.DeleteObjects(polyline_features) uv_point_features = [rs.SurfaceClosestPoint(surface_guid, point) for point in point_features_guids] planar_point_features = [[u, v, 0] for u, v in uv_point_features] return planar_boundary_polyline, planar_hole_polylines, planar_polyline_features, planar_point_features
def makeWall(obj): rs.EnableRedraw(False) shape = wallProfile(obj) railCurve = addRail(shape) wall = rs.ExtrudeSurface(shape, railCurve) rs.DeleteObjects(shape) rs.DeleteObjects(railCurve) rs.EnableRedraw(False) return wall
def get_cut_curve(self): if self.compensation == 0: return rs.CopyObject(self.nurbs_curve) offset_distance = self.general_input["cut_diam"] * 0.5 scl_obj = rs.ScaleObject(self.nurbs_curve, self.point, (1.2, 1.2, 1), True) offset_points = rs.BoundingBox(scl_obj) rs.DeleteObject(scl_obj) offset_point_a = offset_points[0] offset_point_b = self.point if not rs.PointInPlanarClosedCurve(self.point, self.nurbs_curve): offset_point_b = self.find_point_in_curve(self.nurbs_curve) offset_a = rs.OffsetCurve(self.nurbs_curve, offset_point_a, offset_distance, None, 2) offset_b = rs.OffsetCurve(self.nurbs_curve, offset_point_b, offset_distance, None, 2) #Revisa si el offset no genero curvas separadas y si es el caso asigna la curva original como offset comparativo if not offset_a or len(offset_a) != 1: self.log.append( "offset error: el cortador no cabe en una de las curvas, se reemplazo con la curva original." ) if offset_a: rs.DeleteObjects(offset_a) offset_a = rs.CopyObject(self.nurbs_curve) if not offset_b or len(offset_b) != 1: self.log.append( "offset error: el cortador no cabe en una de las curvas, se reemplazo con la curva original." ) if offset_b: rs.DeleteObjects(offset_b) offset_b = rs.CopyObject(self.nurbs_curve) #Revisa el area para saber cual es el offset interno o externo if rs.CurveArea(offset_a) < rs.CurveArea(offset_b): in_offset = offset_a out_offset = offset_b else: in_offset = offset_b out_offset = offset_a #Responde dependiendo que compensacion se necesita if self.compensation == 1: rs.DeleteObject(in_offset) return out_offset elif self.compensation == -1: rs.DeleteObject(out_offset) return in_offset else: rs.DeleteObject(in_offset) rs.DeleteObject(out_offset) return None
def throwNode(nodes,speed,stickRange,passParams,resizeThreshold): boundRadius = passParams[0] bGeom = passParams[1] #sFactor = passParams[2] #print passParams[2] #assumes time steps of 1 startPos = getBoundaryPos(boundRadius); endPos = getBoundaryPos(boundRadius); direction = rs.VectorSubtract(endPos,startPos) direction = rs.VectorUnitize(direction) vel = rs.VectorScale(direction,speed); currentPos = rs.VectorAdd(startPos,vel) previewGeom = [] isTravelling = True while(isTravelling): scriptcontext.escape_test() #hit escape to quit NOT WORKING time.sleep(0.01*10**-7) for o in previewGeom: rs.DeleteObjects(o) dist = rs.VectorLength(currentPos) #distance to origin #check if particle went out of bounds if(dist>boundRadius): isTravelling = False else: previewGeom.append(drawPos(currentPos,stickRange)) for i in range(len(nodes)): n = nodes[i] if(inStickRange(currentPos,n,stickRange)): #GOT STUCK! add a new node at that position newNode = node(currentPos,i,.08) #parent is idx of node stuck too newNode.increaseRadius(.01, nodes) nodes.append(newNode) #rNodes.append(rs.AddPoint(currentPos)) if(math.fabs(boundRadius-dist) <= resizeThreshold): #print "boundRadius should resize" rs.DeleteObjects(bGeom) boundRadius += resizeThreshold/2 #arbitrary bGeom = rs.AddCircle([0,0,0],boundRadius) passParams[0] = boundRadius passParams[1] = bGeom isTravelling = False for o in previewGeom: rs.DeleteObjects(o) break currentPos = rs.VectorAdd(currentPos,vel) Rhino.RhinoApp.Wait() return passParams
def checkPos(objs): # if ok, start export copies = rs.CopyObjects( objs) copies = ce.explodeBlock( copies ) # filter objects to only curves and points copies = filterObjects(copies) if not ce.checkCurvePosition(copies): rs.DeleteObjects(copies) return False rs.DeleteObjects(copies)
def OnFormClosed(self, sender, e): generatedStair = rs.ObjectsByName( "GdC9V&^a^rGZZNgiWFH&aTRQLLscu*9AZCmhk8t2!a") generatedHandrail = rs.ObjectsByName( "qe7g&G5LzXEvbudtPT8xCxQbisusFVqCPqMsiHK2jc") rs.DeleteObjects(rs.ObjectsByName( "xAbJgNV6^bz6azN&6E$Q^WeX$Dd^vygCz5z7Hmynb5")) rs.DeleteObjects(rs.ObjectsByName("BC6#DT5LCQX*#8r97Tquf5gNF")) if generatedStair: rs.DeleteObject(generatedStair) if generatedHandrail: rs.DeleteObjects(generatedHandrail) self.Close(False)
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 RemoveFromBlock(): block = rs.GetObject("Select Block to extract objects from", rs.filter.instance, preselect=True) if not block: return blockName = rs.BlockInstanceName(block) objref = rs.coercerhinoobject(block) idef = objref.InstanceDefinition idefIndex = idef.Index XformBlock = rs.BlockInstanceXform(block) blockObjects = rs.BlockObjects(blockName) blockInstanceObjects = rs.TransformObjects(blockObjects, XformBlock, True) objs = rs.GetObjects("Select Objects to extract from Block", objects=blockInstanceObjects) if not objs: rs.DeleteObjects(blockInstanceObjects) return keep = [] #List to keep in block delete = [] #list to delete from block and add to doc rs.EnableRedraw(False) for object in blockInstanceObjects: if object in objs: delete.append(object) else: keep.append(object) if rs.IsBlockReference(blockName): print "Block is referenced from file; unable to modify block" rs.DeleteObjects(keep) return rs.TransformObjects(keep, rs.XformInverse(XformBlock), False) newGeometry = [] newAttributes = [] for object in keep: newGeometry.append(rs.coercegeometry(object)) ref = Rhino.DocObjects.ObjRef(object) attr = ref.Object().Attributes newAttributes.append(attr) InstanceDefinitionTable = sc.doc.ActiveDoc.InstanceDefinitions InstanceDefinitionTable.ModifyGeometry(idefIndex, newGeometry, newAttributes) rs.DeleteObjects(keep) rs.EnableRedraw(True)
def curvy_stairs(curve, start_pt, end_pt, stair_width, steps, plinth_lst, bannister_lst): ref = rs.OffsetCurve( curve, [1, 0, 0], stair_width) # create the second curve to guide the stair ref_pts = [n * 1 / steps for n in range(steps + 1) ] # guide points to divide up the curve left_pts = [rs.EvaluateCurve(curve, t) for t in ref_pts] # guide points on input curve right_pts = [rs.EvaluateCurve(ref, t) for t in ref_pts] #guide points on the offset curve height = end_pt[2] - start_pt[2] #stair height rise = [0, 0, height / steps] # a vector for i in range(steps): #draw rise v_ver = [ left_pts[i], right_pts[i], rs.PointAdd(right_pts[i], rise), rs.PointAdd(left_pts[i], rise) ] rs.AddSrfPt(v_ver) #draw run v_hori = [v_ver[3], v_ver[2], right_pts[i + 1], left_pts[i + 1]] rs.AddSrfPt(v_hori) #draw sides s1 = rs.AddLine(left_pts[i], rs.PointAdd(left_pts[i], rise)) s2 = rs.AddLine(rs.PointAdd(left_pts[i], rise), left_pts[i + 1]) s3 = rs.AddSubCrv(curve, rs.CurveClosestPoint(curve, left_pts[i]), rs.CurveClosestPoint(curve, left_pts[i + 1])) rs.AddEdgeSrf([s1, s2, s3]) rs.DeleteObjects([s1, s2, s3]) s1 = rs.AddLine(right_pts[i], rs.PointAdd(right_pts[i], rise)) s2 = rs.AddLine(rs.PointAdd(right_pts[i], rise), right_pts[i + 1]) s3 = rs.AddSubCrv(ref, rs.CurveClosestPoint(ref, right_pts[i]), rs.CurveClosestPoint(ref, right_pts[i + 1])) rs.AddEdgeSrf([s1, s2, s3]) rs.DeleteObjects([s1, s2, s3]) s1 = rs.AddLine(left_pts[0], right_pts[0]) s2 = rs.AddLine(left_pts[-1], right_pts[-1]) rs.AddEdgeSrf([s1, curve, s2, ref]) rs.DeleteObjects([s1, s2]) if plinth_lst[0]: curvy_plinth(curve, ref, stair_width, plinth_lst) if bannister_lst[0]: curvy_bannister(curve, ref, stair_width, bannister_lst)
def editing_symmetry(coarse_pseudo_quad_mesh): """Edit the symmetry of a pattern via Conway operators. Parameters ---------- coarse_pseudo_quad_mesh : CoarsePseudoQuadMesh The pattern to edit. """ conway_operators = { 'conway_seed', 'conway_dual', 'conway_join', 'conway_ambo', 'conway_kis', 'conway_needle', 'conway_zip', 'conway_truncate', 'conway_ortho', 'conway_expand', 'conway_gyro', 'conway_snub', 'conway_meta', 'conway_bevel' } conway = {operator[7:]: operator for operator in conway_operators} while True: rs.EnableRedraw(False) artist = rhino_artist.MeshArtist( coarse_pseudo_quad_mesh.get_polygonal_mesh()) guid = artist.draw_mesh() rs.EnableRedraw(True) operator = rs.GetString('Conway operator?', strings=conway.keys() + ['exit']) if operator is None or operator == 'exit': if type(guid) == list: rs.DeleteObjects(guid) else: rs.DeleteObject(guid) return coarse_pseudo_quad_mesh.get_polygonal_mesh() elif operator == 'seed': coarse_pseudo_quad_mesh.set_polygonal_mesh( coarse_pseudo_quad_mesh.get_quad_mesh().copy()) elif operator in conway and conway[operator] in globals() and str( conway[operator])[:6] == 'conway': coarse_pseudo_quad_mesh.set_polygonal_mesh( globals()[conway[operator]]( coarse_pseudo_quad_mesh.get_polygonal_mesh())) if type(guid) == list: rs.DeleteObjects(guid) else: rs.DeleteObject(guid)
def main(): objs = rs.VisibleObjects() cutLevel = 12 rs.EnableRedraw(False) objsCopy = rs.CopyObjects(objs) splitModel(objsCopy, cutLevel) makePlan() rs.DeleteObjects(rs.ObjectsByGroup("Above")) rs.DeleteObjects(rs.ObjectsByGroup("Below")) cutAtPlan(cutLevel, False) rs.Command('_SelDupAll _delete') cutAtPlan(cutLevel, True) rs.Command('_SelDup _delete') rs.EnableRedraw(True)
def rebuildBrep(obj): srfs = rs.ExplodePolysurfaces(obj) crvs = map(rebuildSrfCrv, srfs) rs.DeleteObjects(srfs) newSrfs = map(rs.AddPlanarSrf, crvs) # newSrfs = rs.AddPlanarSrf(crvs) rs.DeleteObjects(crvs) newbrep = rs.JoinSurfaces(newSrfs, delete_input=True) try: copySourceLayer(newbrep, obj) copySourceData(newbrep, obj) except: pass rs.DeleteObject(obj)