def proof_placement(self, checkbuildspace=True): # color objects self.correctplacement = True print 'Moving to zero level' for obj in self.objIds: BB = rs.BoundingBox(obj) rs.MoveObject(obj, [0, 0, -BB[0][2]]) BB = rs.BoundingBox(obj) if checkbuildspace: print 'Checking positioning' for point in BB: if point[0] < 0 or point[0] > 241: rs.ObjectColor(obj, (255, 0, 0)) self.correctplacement = False break else: rs.ObjectColor(obj, (0, 255, 0)) if point[1] < 0 or point[1] > 209: rs.ObjectColor(obj, (255, 0, 0)) self.correctplacement = False break else: rs.ObjectColor(obj, (0, 255, 0)) if point[2] < 0 or point[2] > 205: rs.ObjectColor(obj, (255, 0, 0)) self.correctplacement = False break else: rs.ObjectColor(obj, (0, 255, 0))
def GetPointDynamicDrawFuncHide(sender, args): obj_all = rs.VisibleObjects() rs.HideObjects(obj_all) cursPos = rs.GetCursorPos() viewSize = rs.ViewSize() stepSize = int(viewSize[1] / _NUM_LAYER) obj_Layer1 = 'Layer: 000001 Wall1' obj_Layer2 = 'Layer: 000002 Wall1' settings = Rhino.DocObjects.ObjectEnumeratorSettings() settings.HiddenObjects = True settings.NameFilter = obj_Layer1 ids_L1 = [rhobj.Id for rhobj in scriptcontext.doc.Objects.GetObjectList(settings)] settings.NameFilter = obj_Layer2 ids_L2 = [rhobj.Id for rhobj in scriptcontext.doc.Objects.GetObjectList(settings)] z_L1 = rs.BoundingBox(ids_L1[0])[0][2] z_L2 = rs.BoundingBox(ids_L2[0])[0][2] zVal = viewSize[1] - cursPos[3][1] z_level = int(zVal / stepSize) segmentList = ['Wall', 'DenseInfill', 'SparseInfill', 'Brim', 'Skirt', 'Support'] zero_str = '000000' settings = ObjectEnumeratorSettings() settings.HiddenObjects = True for segment in segmentList: i = 0 while 1: i += 1 obj_LayerZ = str('Layer: ' + zero_str[:-len(str(z_level))] + str(z_level) + ' ' + segment + str(i)) try: settings.NameFilter = obj_LayerZ ids_LZ = [rhobj.Id for rhobj in scriptcontext.doc.Objects.GetObjectList(settings)] if len(ids_LZ) == 0: break # rs.SelectObject(ids_LZ) rs.ShowObject(ids_LZ) except: print 'not found' args.Display.DrawDot(args.CurrentPoint, 'Layer ' + str(z_level) + ' - Distance ' + str(z_L2 - z_L1) + ' mm') Rhino.Display.RhinoView.Redraw(scriptcontext.doc.Views.ActiveView) Rhino.RhinoApp.Wait()
def splitModel(objs, cutLevel): point = Rhino.Geometry.Point3d(0,0,cutLevel) belowDir = rs.AddLine(point, [0,0,-9999]) aboveDir = rs.AddLine(point, [0,0,9999]) circle = rs.AddCircle(point, 9999) circleSrf = rs.AddPlanarSrf(circle) aboveGroup = rs.AddGroup("Above") belowGroup = rs.AddGroup("Below") for obj in objs: ptBtm = rs.BoundingBox(obj)[0] ptTop = rs.BoundingBox(obj)[6] if ptBtm[2]>cutLevel: intersecting = False rs.AddObjectToGroup(obj, "Above") #print "Object Above" elif ptTop[2]<cutLevel: intersecting = False rs.AddObjectToGroup(obj, "Below") #print "Object Below" else: intersecting = True if intersecting: if rs.IsBrep(obj): closed = False if rs.IsPolysurfaceClosed(obj): closed = True try: copy = rs.CopyObject(obj) splitSrfs = rs.SplitBrep(obj, circleSrf, True) for splitSrf in splitSrfs: #print "looping" if closed: rs.CapPlanarHoles(splitSrf) rs.MatchObjectAttributes(splitSrf, copy) ptBtm = rs.BoundingBox(splitSrf)[0] ptTop = rs.BoundingBox(splitSrf)[6] mdPtZ = (ptBtm[2] + ptTop[2]) / 2 if mdPtZ>cutLevel: rs.AddObjectToGroup(splitSrf, "Above") else: rs.AddObjectToGroup(splitSrf, "Below") rs.DeleteObject(copy) rs.DeleteObject(obj) except: None if rs.IsBlockInstance(obj): contents = rs.ExplodeBlockInstance(obj) for content in contents: objs.append(content) rs.DeleteObject(belowDir) rs.DeleteObject(aboveDir) rs.DeleteObject(circle) rs.DeleteObject(circleSrf)
def findHOffset(prevCrv, currentCrv): #The offset is equal to the width of the previous footprint's bounding box plus 1/8 of the width of the current footprint's bounding box. Returns the x-transformation amount. prevBox = rs.BoundingBox(prevCrv, in_world_coords=True) currentBox = rs.BoundingBox(currentCrv, in_world_coords=True) prevSpacing = rs.Distance(prevBox[0], prevBox[1]) currentSpacing = rs.Distance(currentBox[0], currentBox[1]) currentSpacing = currentSpacing * 0.25 offset = prevSpacing + currentSpacing return offset
def nesting(self): auto_nesting = True if len(self.objIds) > 1: print 'Checking intersections' # proof if objects have intersections bBoxCo = [] for obj, i in zip(self.objIds, range(len(self.objIds))): bBoxCo.append(rs.BoundingBox(obj)) for obj, i in zip(self.objIds, range(len(self.objIds))): rs.ObjectColor(obj, (0, 255, 0)) objIds_tmp = copy.deepcopy(self.objIds) objIds_tmp.remove(obj) for objCompare in objIds_tmp: intersect = rs.MeshMeshIntersection(obj, objCompare) if intersect is not None: rs.ObjectColor(obj, (255, 0, 0)) rs.ObjectColor(objCompare, (255, 0, 0)) self.correctplacement = False if auto_nesting: BB = rs.BoundingBox(obj) BBComp = rs.BoundingBox(objCompare) xmin_BB = BB[0][0] xmax_BB = BB[1][0] ymin_BB = BB[0][1] ymax_BB = BB[3][1] xmin_BBComp = BBComp[0][0] xmax_BBComp = BBComp[1][0] ymin_BBComp = BBComp[0][1] ymax_BBComp = BBComp[3][1] if xmin_BBComp >= xmin_BB and xmin_BBComp <= xmax_BB: print 'Correcting x value' # x_delta_to_min = xmin_BBComp - xmin_BB x_delta_to_max = xmin_BBComp - xmax_BB rs.MoveObject(objCompare, [abs(x_delta_to_max), 0, 0]) if xmax_BBComp >= xmin_BB and xmax_BBComp <= xmax_BB: print 'Correcting xvalue 2' if ymin_BBComp >= ymin_BB and ymin_BBComp <= ymax_BB: print 'Correcting y value' # y_delta_to_min = ymin_BBComp - ymin_BB y_delta_to_max = ymin_BBComp - ymax_BB rs.MoveObject(objCompare, [0, abs(y_delta_to_max), 0]) if ymax_BBComp >= ymin_BB and ymax_BBComp <= ymax_BB: print 'Correcting y value 2'
def main(): objs = rs.GetObjects("Select Objects to Number", preselect = True) if objs is None: return pts = [] for obj in objs: pt0 = rs.BoundingBox(obj)[0] pt2 = rs.BoundingBox(obj)[2] centerPt = rs.PointDivide(rs.PointAdd(pt0, pt2), 2) pts.append(centerPt) sortedPts = proximityPts(pts,0) addNumberTag(sortedPts, objs) print len(sortedPts)
def duplicateAndRotate(): obj_ids = rs.GetObjects("Select object(s) to duplicate and rotate", 0, True, True) if obj_ids is None: return box = rs.BoundingBox(obj_ids) if not isinstance(box, list): return origin = rs.PointDivide(rs.PointAdd(box[0], box[6]), 2) endpt = rs.GetPoint("To point") ndups = rs.GetInteger("Number of duplications") maxd = rs.GetReal("Max Distance") translation = rs.VectorCreate(endpt, origin) for i in range(0, ndups, 1): xr = random() if random() < 0.5 else -1 * random() yr = random() if random() < 0.5 else -1 * random() zr = random() if random() < 0.5 else -1 * random() newpt = [xr * maxd, yr * maxd, zr * maxd] translation1 = rs.VectorCreate(endpt, newpt) translation2 = rs.VectorCreate(translation1, origin) copied_obj_ids = rs.CopyObjects(obj_ids, translation2) xyp = rs.WorldXYPlane() rs.RotateObjects(copied_obj_ids, newpt, random() * 360, xyp[0]) rs.RotateObjects(copied_obj_ids, newpt, random() * 360, xyp[1]) rs.RotateObjects(copied_obj_ids, newpt, random() * 360, xyp[2])
def main(): counts = [0, 0, 0] spacings = [10, 10, 10] rotations = [0, 0, 0] counts[0] = rs.GetInteger("number in x direction", minimum=1) # counts[1] = rs.GetInteger("number in y direction", minimum=1) # counts[2] = rs.GetInteger("number in z direction", minimum=1) spacings[0] = rs.GetReal("x spacing") # spacings[1] = rs.GetReal("y spacing") # spacings[2] = rs.GetReal("z spacing") rotations[0] = rs.GetReal("rotation of each object along x axis") # rotations[1] = rs.GetReal("y spacing") # rotations[2] = rs.GetReal("z spacing") print "count", counts print "spacing", spacings print "rotation", rotations for ix in range(counts[0]): newobj = rs.CopyObject(obj, [spacings[0] * ix, 0, 0]) bbox = rs.BoundingBox(newobj) if bbox: centroid = rs.PointSubtract(bbox[0], bbox[6]) print bbox[6], bbox[0] print centroid rs.AddPoint(centroid) else: print "no bbox"
def brepOrExtrusionOfBlock_ShadedPick(rdInstRef, ptPicked, planeCam): """Create intersecting line that passes through the actual picked point. Its vector is that of the camera view. The line extends to the bounding box of the block instance.""" vector = rg.Vector3d.Negate(planeCam.ZAxis) ptOnCameraPlane = planeCam.ClosestPoint(ptPicked) pts_bbox = rs.BoundingBox(rdInstRef.Id) bbox = rg.BoundingBox(pts_bbox[0], pts_bbox[6]) rgLine = rg.Line(ptOnCameraPlane, vector, 1.) rgLine.ExtendThroughBox(bbox) rgLineCrv = rg.LineCurve(rgLine) rgBreps_Intrsct, pts_Intrsct_All = ( brepsOrExtrusionsAndPtsInBlockInstThatIntrsctLine( rdInstRef, rgLineCrv)) rgObj_Nearest = pt_Nearest = None for i, pts_Intrsct in enumerate(pts_Intrsct_All): for pt_Intrsct in pts_Intrsct: fDistPtToPlane = ptOnCameraPlane.DistanceTo(pt_Intrsct) if pt_Nearest is None or fDistPtToPlane < fDistPtToPlane_Min: rgObj_Nearest = rgBreps_Intrsct[i] pt_Nearest = pt_Intrsct fDistPtToPlane_Min = fDistPtToPlane return rgObj_Nearest, pt_Nearest
def genHalfPlanes(site_crv, int_crv): B = rs.BoundingBox(site_crv) polyBB = rs.AddPolyline([B[0], B[1], B[2], B[3], B[0]]) diagB = 2 * rs.Distance(B[0], B[2]) rays = [] int_pts = rs.CurvePoints(int_crv) bsp_tree = [] bsp_tree.append(site_crv) for i in range(len(int_pts) - 1): a = int_pts[i] b = int_pts[i + 1] m = [(a[0] + b[0]) / 2, (a[1] + b[1]) / 2, 0] p = [ m[0] + (a[0] - m[0]) * diagB / (rs.Distance(a, m)), m[1] + (a[1] - m[1]) * diagB / (rs.Distance(a, m)), 0 ] q = [ m[0] + (b[0] - m[0]) * diagB / (rs.Distance(b, m)), m[1] + (b[1] - m[1]) * diagB / (rs.Distance(b, m)), 0 ] u = [q[0] - p[0], q[1] - p[1], 0] v = [-u[1], u[0], 0] r = [p[0] + v[0], p[1] + v[1], 0] s = [q[0] + v[0], q[1] + v[1], 0] w = [u[1], -u[0], 0] R = [p[0] + w[0], p[1] + w[1], 0] S = [q[0] + w[0], q[1] + w[1], 0] polyA = rs.AddPolyline([p, q, s, r, p]) polyB = rs.AddPolyline([p, q, S, R, p]) used_crv = [] new_crv = [] for bsp_crv in bsp_tree: sum = 0 try: crvA = rs.CurveBooleanIntersection(bsp_crv, polyA) new_crv.append(crvA) sum += 1 except: pass try: crvB = rs.CurveBooleanIntersection(bsp_crv, polyB) new_crv.append(crvB) sum += 1 except: pass if (sum > 0): used_crv.append(bsp_crv) for crv in new_crv: bsp_tree.append(crv) for crv in used_crv: bsp_tree.remove(crv) rs.DeleteObject(crv) rs.DeleteObject(polyA) rs.DeleteObject(polyB) rs.DeleteObject(polyBB) return bsp_tree
def transformMatrix(): obj_ids = rs.GetObjects("Select object(s) from which to create matrix", 0, True, True) if obj_ids is None: return box = rs.BoundingBox(obj_ids) if not isinstance(box, list): return origin = rs.PointDivide(rs.PointAdd(box[0], box[6]), 2) endpt = rs.GetPoint("To point") newpt = [1, 1, 1] translation1 = rs.VectorCreate(endpt, newpt) translation2 = rs.VectorCreate(translation1, origin) copied_obj_ids = rs.CopyObjects(obj_ids, translation2) for obj in copied_obj_ids: matrix = [] degrees = 90.0 # Some angle radians = math.radians(degrees) c = math.cos(radians) s = math.sin(radians) matrix.append([c, -s, 0, 0]) matrix.append([s, c, 0, 0]) matrix.append([0, 0, 1, 0]) matrix.append([0, 0, 0, 1]) pprint.pprint(matrix) rs.ScaleObject(obj, newpt, [3, 1, -9]) plane = rs.ViewCPlane() pprint.pprint(plane) rs.RotateObject(obj, newpt, uniform(0, 360), plane.XAxis) rs.RotateObject(obj, newpt, uniform(0, 360), plane.YAxis) rs.RotateObject(obj, newpt, uniform(0, 360), plane.ZAxis)
def calculateWidth(files): global box_width for filename in files: join_string = str(input_directory + filename) combined_string = '!_Import ' + '"' + join_string + '"' rs.Command(combined_string) objs = rs.LastCreatedObjects(select=False)[0] bounding_pts = rs.BoundingBox([objs], view_or_plane=rs.WorldXYPlane()) maxX = 0 minX = 0 minY = 0 minZ = 0 for pt in bounding_pts: if pt[0] < minX: minX = pt[0] if pt[0] > maxX: maxX = pt[0] if pt[1] < minY: minY = pt[1] if pt[2] < minZ: minZ = pt[2] if abs(maxX - minX) > box_width: box_width = abs(maxX - minX) rs.DeleteObject(objs)
def get_bounding_dims(brep): """return bounding box x,y,z dims for a brep or many breps""" bb = rs.BoundingBox(brep) Dimensions = namedtuple('Dimensions', 'X Y Z') dims = Dimensions(rs.Distance(bb[0], bb[1]), rs.Distance(bb[0], bb[3]), rs.Distance(bb[0], bb[4])) return dims
def construct_mesh_center(points): meshes = [] ### calc center point bbox = rs.BoundingBox(points) line = rs.AddLine(bbox[0], bbox[6]) c = rs.CurveMidPoint(line) ### set new point list points.append(c) ### c_index = len(points) - 1 # print(c_index) for j in xrange(len(points) - 1): if j < (len(points) - 2): vertex_ = [(c_index, int(j), int(j) + 1, int(j) + 1)] # print(vertex_) m = rs.AddMesh(points, vertex_) meshes.append(m) else: vertex_ = [(c_index, int(j), 0, 0)] # print(vertex_) m = rs.AddMesh(points, vertex_) meshes.append(m) mesh_joined = rs.JoinMeshes(meshes) return mesh_joined
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 AddTag(obj, text, color): box = rs.BoundingBox(obj) mid = (box[0] + box[-2])/2 tag = rs.AddTextDot(text, mid) rs.SetUserText(obj, 'tag', text) rs.ObjectColor(obj, color) group = rs.AddGroup() rs.AddObjectsToGroup([obj, tag], group)
def nameTag(obj): roomName = rs.ObjectName(obj) try: text = str(roomName) pt0 = rs.BoundingBox(obj)[0] pt2 = rs.BoundingBox(obj)[2] pt = rs.PointDivide(rs.PointAdd(pt0, pt2), 2) areaTag = rs.AddText(text, pt, 1, justification=131074) except: print "Object has no name" return parentLayer = rs.ParentLayer(rs.ObjectLayer(obj)) hostLayer = rs.AddLayer("ANNO_NAME", (128, 128, 128), parent=parentLayer) rs.ObjectLayer(areaTag, hostLayer) return None
def AddBlockName(obj): name = rs.BlockInstanceName(obj) pt = rs.BlockInstanceInsertPoint(obj) bb = rs.BoundingBox(obj) text = rs.AddText(name, (bb[0] + bb[6]) / 2) rs.SetUserText(text, 'tag', 'label') group = rs.AddGroup() rs.AddObjectsToGroup([obj, text], group)
def getBounds( r, c ): bb = rs.BoundingBox(c) w = abs(bb[0].X - bb[1].X) h = abs(bb[0].Y - bb[2].Y) if r: return "width=\"%f\" height=\"%f\"" %(h + pad*2,w + pad*2) else: return "width=\"%f\" height=\"%f\"" %(w + pad*2,h + pad*2)
def meetsLength(len, startCrv, endCrv): objects = [startCrv, endCrv] boundingBox = rs.BoundingBox(objects, in_world_coords=True) curLen = rs.Distance(boundingBox[0], boundingBox[1]) if curLen >= len: return True else: return False
def main(): objs = rs.GetObjects() for obj in objs: pts = rs.BoundingBox(obj) ctrPt = (pts[0] + pts[2]) / 2 RandomRotate(obj, ctrPt, 0, 360) RandomScaling(obj, ctrPt, .8, 1.2)
def DropBlockToSurface(): try: obj = rs.GetObjects('Select Objects', rs.filter.curve | rs.filter.instance | rs.filter.mesh | rs.filter.surface | rs.filter.subd | rs.filter.light | rs.filter.polysurface, preselect=True) srf = rs.GetObject('Select Surface') if obj: if srf: rs.EnableRedraw(False) # Check if srf is a mesh, if so convert to Nurb isMesh = rs.IsMesh(srf) if isMesh == True: srf = rs.MeshToNurb(srf) # For each object send test rays up and down in Z coord # Move each object to the ray test that hits a srf for i in obj: bndBox = rs.BoundingBox(i) pt1 = bndBox[0] pt2 = bndBox[2] crv = rs.AddLine(pt1, pt2) if crv: midcrv = rs.CurveMidPoint(crv) rs.DeleteObject(crv) ray_pt_up = rs.ShootRay(srf, midcrv, (0, 0, 1), reflections=1) ray_pt_down = rs.ShootRay(srf, midcrv, (0, 0, -1), reflections=1) if ray_pt_up: vector = rs.VectorCreate(ray_pt_up[1], midcrv) rs.MoveObject(i, vector) if ray_pt_down: vector = rs.VectorCreate(ray_pt_down[1], midcrv) rs.MoveObject(i, vector) # deleate any created srf if isMesh == True: rs.DeleteObject(srf) rs.EnableRedraw(True) except: print("Failed to execute") rs.EnableRedraw(True) return
def testDuplications(): print("\n testDuplications commands \n") obj_ids = rs.GetObjects( "Select object(s) from which to create the rectangular matrix", 0, True, True) if obj_ids is None: return box = rs.BoundingBox(obj_ids) if not isinstance(box, list): return origin = rs.PointDivide(rs.PointAdd(box[0], box[6]), 2) nXdups = rs.GetInteger("Duplications X", 1, 1) rXdups = rs.GetReal("Duplications X rand", 0, 0, 100) / 100 nYdups = rs.GetInteger("Duplications Y", 1, 1) rYdups = rs.GetReal("Duplications Y rand", 0, 0, 100) / 100 nZdups = rs.GetInteger("Duplications Z", 1, 1) rZdups = rs.GetReal("Duplications Z rand", 0, 0, 100) / 100 rKeep = 1 - rs.GetReal("Percent to erase", 0, 0, 100) / 100 endpt = rs.GetPoint("To point") calc_val_real = lambda val, rand: val + random.uniform( -rand * val, rand * val) calc_val_int = lambda val, rand: val + int( round(random.uniform(-rand * val, rand * val))) xspace = 3 yspace = 3 zspace = 3 xdups = calc_val_int(nXdups, rXdups) ydups = calc_val_int(nYdups, rYdups) zdups = calc_val_int(nZdups, rZdups) translations = [] # Copy Points with Spacing for k in range(zdups): for j in range(ydups): for i in range(xdups): newpt = [ origin[0] + i * xspace, origin[1] + j * yspace, origin[2] + k * zspace ] translations = translations + [rs.VectorCreate(endpt, newpt)] nObjs = len(translations) print(nObjs) objs_to_keep = random.sample(range(nObjs), int(round(nObjs * rKeep))) translations = [translations[i] for i in objs_to_keep] copied_objs = [] for tr in translations: copied_objs = copied_objs + rs.CopyObjects(obj_ids, tr)
def IsAbovePlane(obj, elevation): pts = rs.BoundingBox(obj) lowestCoord = pts[0][2] highestCoord = pts[-1][2] centerPtZ = (lowestCoord + highestCoord) / 2 if centerPtZ > elevation: return True else: return False
def get_bounding_rectangle(self): ''' Assuming the island is planar, gets the four points bounding the current representation of the island. BoundingBox returns a list of 8 points. This returns the first four (the base of the box) ''' full_box = rs.BoundingBox(self.get_perimeter_geometry(), view_or_plane=island_plane) return full_box[0:4]
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 createSectionBox(obj): box = rs.BoundingBox(obj) bb = rs.AddBox(box) faces = rs.ExplodePolysurfaces(bb) faces = [rs.FlipSurface(x) for x in faces] planes = [getSrfFrame(x) for x in faces] clips = [rs.AddClippingPlane(x, 1000, 1000) for x in planes] group = rs.AddGroup() rs.AddObjectsToGroup(clips, group) return clips
def AddDotToObjCtr(objIDs, text, transfer=True): #adds a dot to object(s) bounding box center and groups dot with object(s) bb = rs.BoundingBox(objIDs) if bb: dotID = rs.AddTextDot(text, (bb[0] + bb[6]) / 2) if transfer: TransferColorLayer(dotID, objIDs[0]) objIDs.append(dotID) group = rs.AddGroup() test = rs.AddObjectsToGroup(objIDs, group) return dotID
def testArrangement(sortedCurves, factor): totalBox = rs.BoundingBox(sortedCurves) sqrtSource = rs.Distance(totalBox[0], totalBox[1]) minLength = sqrtSource**0.5 minLength = minLength**factor def meetsLength(len, startCrv, endCrv): objects = [startCrv, endCrv] boundingBox = rs.BoundingBox(objects, in_world_coords=True) curLen = rs.Distance(boundingBox[0], boundingBox[1]) if curLen >= len: return True else: return False #Then, defining a list of the resulting lists. listOfLists = [] s = 0 #"Start" e = 0 #"End" #Loop that splits the list into smaller lists. while True: if (s + e) == len(sortedCurves) or s == len(sortedCurves): listOfLists.append(sortedCurves[s:s + e]) break elif meetsLength(minLength, sortedCurves[s], sortedCurves[s + e]) == True: listOfLists.append(sortedCurves[s:s + e]) s = s + e e = 1 continue else: e += 1 continue #Now to move them vertically. First, like with the horizontal movement, we need to create a function that finds the vertical offset between each line. def findVOffset(curCrv): currentBox = rs.BoundingBox(curCrv, in_world_coords=True) vHeight = rs.Distance(currentBox[0], currentBox[3]) offset = vHeight * 1.125 offset = 0 - offset return offset #And to move them. for i in range(len(listOfLists)): if i == len(listOfLists) - 1: break else: rs.MoveObject( listOfLists[i + 1], rs.VectorCreate(findAnchorPoint(listOfLists[i]), findAnchorPoint(listOfLists[i + 1]))) rs.MoveObject(listOfLists[i + 1], (0, findVOffset(listOfLists[i + 1]), 0))
def getLowestPoint(obj): box = rs.BoundingBox(obj) min = 1e20 lowest = None if box: for i, point in enumerate(box): if point.Z < min: min = point.Z lowest = point return lowest