def __init__(self, vertices, edges, surface): self.size = 0 self.carParkNum = 0 # vertices self.vertices = vertices # Result from solve() self.result = [] # Boundary of the site (4 edges in this version) self.edges = edges # Surface of the site self.surface = surface # Center point of the site surface self.center = rs.SurfaceAreaCentroid(surface)[0] # List of unit vectors that pointing from self.edges for offset self.offsetDirection = [] # List of max offset length as a bound self.maxOffsetLength = self.getMaxOffsetLength() # self.siteWidth = siteWidth self.edgeDirection()
def scaleY(): objs = rs.GetObjects() if objs: for obj in objs: if obj: objCen = rs.SurfaceAreaCentroid(obj) if objCen: objCenPoint = rs.AddPoint(objCen[0]) rs.ScaleObject(obj, objCenPoint, (1, 2, 1)) rs.DeleteObject(objCenPoint)
def _findWindowPlane(self, _srfcs): """ Takes in a set of surfaces, returns a list of their Centroids in 'order' Assess the surface normal of the group of surfaces and attempts to figuere out the 'order' of the srfcs when viewed from 'outside' (according to the surface normal) and orders the centroids from left--->right """ setXs = [] setYs = [] setZs = [] Centroids = [] for srfc in _srfcs: windowBrep = rs.coercebrep(srfc) surfaceList = windowBrep.Surfaces for eachSurface in surfaceList: srfcCentroid = rs.SurfaceAreaCentroid(eachSurface)[0] b, u, v = eachSurface.ClosestPoint(srfcCentroid) srfcNormal = eachSurface.NormalAt(u, v) setXs.append(srfcNormal.X) setYs.append(srfcNormal.Y) setZs.append(srfcNormal.Z) Centroids.append(srfcCentroid) # Find the average Normal Vector of the set px = sum(setXs) / len(setXs) py = sum(setYs) / len(setYs) pz = sum(setZs) / len(setZs) avgNormalVec = Rhino.Geometry.Point3d(px, py, pz) # Find a line through all the points and its midpoint fitLine = rs.LineFitFromPoints(Centroids) # Find the Midpoint of the Line midX = (fitLine.From.X + fitLine.To.X) / 2 midY = (fitLine.From.Y + fitLine.To.Y) / 2 midZ = (fitLine.From.Z + fitLine.To.Z) / 2 lineMidpoint = Rhino.Geometry.Point3d(midX, midY, midZ) # Rotate new Plane to match the window avg newAvgWindowPlane = rs.CreatePlane(lineMidpoint, avgNormalVec, [0, 0, 1]) finalPlane = rs.RotatePlane(newAvgWindowPlane, 90, [0, 0, 1]) # Plot the window Centroids onto the selection Set Plane centroidsReMaped = [] for eachCent in Centroids: centroidsReMaped.append(finalPlane.RemapToPlaneSpace(eachCent)) # Return a list of the new Centroids remapped onto the Set's Plane return centroidsReMaped
def extrude(r): if rh.IsCurve(r): return db.AddSurface( geo.Surface.CreateExtrusion(db.Find(r).Geometry, vec)) else: c = rh.SurfaceAreaCentroid(r)[0] curve = rh.AddLine(c, c + vec) brep = _brep_from_id(r) c = db.Find(curve).Geometry r = single_ref_or_union([ db.AddBrep(face.CreateExtrusion(c, True)) for face in brep.Faces ]) rh.DeleteObject(curve) return r
def FaceCamera(): try: frames = rs.GetObjects("Select Picture Frames", filter=8, preselect=True) # rotate surfaces around z axis towards camera point if frames: rs.EnableRedraw(False) cam = rs.ViewCamera() camz = (cam.X, cam.Y, 0) angle = 1 for i in frames: angle = 1 while angle >= 1: # get mid point of surface and move to z 0 pointmid = rs.SurfaceAreaCentroid(i) pointmidz = (pointmid[0].X, pointmid[0].Y, 0) # Get center UV of surface domainU = rs.SurfaceDomain(i, 0) domainV = rs.SurfaceDomain(i, 1) u = domainU[1] / 2.0 v = domainV[1] / 2.0 # Get normal vector of surface and cam vector vec1 = rs.SurfaceNormal(i, (u, v)) vec1 = vec1.X, vec1.Y, 0 vec2 = rs.VectorCreate(camz, pointmidz) # find angle difference between the two vectors angle = rs.VectorAngle(vec1, vec2) angle = round(angle) # Rotate Object rs.RotateObject(i, pointmidz, angle) continue rs.EnableRedraw(True) except: print("Failed to execute") rs.EnableRedraw(True) return
def SplitAndKeep(self, object, cutting, index, axis=1): objects = rs.SplitBrep(object, cutting, True) # sort split object parts by centroid y meta = [(i, rs.SurfaceAreaCentroid(objects[i])[0][axis]) for i in range(len(objects))] meta.sort(key=lambda iy: iy[1]) # delete other parts try: exclusion = set(index) except TypeError: exclusion = set() exclusion.add(index) results = [] for i in range(len(meta)): object = objects[meta[i][0]] if i not in exclusion: rs.DeleteObject(object) else: results.append(object) return results[0] if len(results) == 1 else results
def __init__(self, vertices, edges, surface): # vertices self.vertices = vertices # Boundary of the site (4 edges in this version) self.edges = edges # Surface of the site self.surface = surface # Center point of the site surface self.center = rs.SurfaceAreaCentroid(surface)[0] # List of unit vectors that pointing from self.edges for offset self.offsetDirection = [] # List of max offset length as a bound self.maxOffsetLength = self.getMaxOffsetLength() self.appendEdgeDirection()
def get_building_booleans(building_breps, planes): """make slices of the building that will be booleaneddifferenced out of the terrain slices.""" if not building_breps: return None bldg_intersection_boolean_breps = [] bldg_intersection_breps = [] sections = [] #get the sections organized by level for i, plane in enumerate(planes): sections_level = [] for b in building_breps: plane_sections = get_section(rs.coercebrep(b), plane) if not plane_sections: continue else: sections_level.append(plane_sections) sections.append(sections_level) #extrude the sections organized by level boolean_breps = [] for i, level in enumerate(sections): boolean_breps_level = [] for section in level: pb = Rhino.Geometry.Brep.CreatePlanarBreps(section) pb = pb[0] srf_added = wrh.add_brep_to_layer(pb, LCUT_IND[4]) b = rs.ExtrudeSurface(srf_added, SHORT_GUIDE) centroid, _ = rs.SurfaceAreaCentroid(b) b = rs.ScaleObject(b, centroid, [1.0, 1.0, 1.5]) #rs.ObjectLayer(b,"s7") boolean_breps_level.append(b) rs.DeleteObject(srf_added) boolean_breps.append(boolean_breps_level) return boolean_breps
def rc_collapse_box(): go = Rhino.Input.Custom.GetObject() go.GeometryFilter = Rhino.DocObjects.ObjectType.Brep default_KeepLayer = sc.sticky["KeepLayer"] if sc.sticky.has_key( "KeepLayer") else False default_IgnoreOpen = sc.sticky["IgnoreOpen"] if sc.sticky.has_key( "IgnoreOpen") else False opt_KeepLayer = Rhino.Input.Custom.OptionToggle(default_KeepLayer, "No", "Yes") opt_IgnoreOpen = Rhino.Input.Custom.OptionToggle(default_IgnoreOpen, "No", "Yes") go.SetCommandPrompt("Select Breps") go.AddOptionToggle("KeepLayer", opt_KeepLayer) go.AddOptionToggle("IgnoreOpenBreps", opt_IgnoreOpen) go.GroupSelect = True go.SubObjectSelect = False go.AcceptEnterWhenDone(True) go.AcceptNothing(True) go.EnableClearObjectsOnEntry(False) go.EnableUnselectObjectsOnExit(False) go.GroupSelect = True go.SubObjectSelect = False go.DeselectAllBeforePostSelect = False res = None bHavePreselectedObjects = True while True: res = go.GetMultiple(1, 0) if res == Rhino.Input.GetResult.Option: go.EnablePreSelect(False, True) continue #If not correct elif res != Rhino.Input.GetResult.Object: rs.Redraw() print "No breps were selected!" return Rhino.Commands.Result.Cancel if go.ObjectsWerePreselected: rs.Redraw() bHavePreselectedObjects = True go.EnablePreSelect(False, True) continue break OPT_IGNORE_OPEN = opt_IgnoreOpen.CurrentValue OPT_KEEP_LAYER = opt_KeepLayer.CurrentValue sticky["IgnoreOpen"] = OPT_IGNORE_OPEN sticky["KeepLayer"] = OPT_KEEP_LAYER rs.EnableRedraw(False) input_breps = [] for i in xrange(go.ObjectCount): b_obj = go.Object(i).Object() input_breps.append(b_obj.Id) current_cplane = sc.doc.Views.ActiveView.ActiveViewport.GetConstructionPlane( ) temp_cplane = current_cplane.Plane current_cplane.Plane = rs.WorldXYPlane() solid_brep_count = 0 for brep in input_breps: if not rs.IsObjectSolid(brep): solid_brep_count += 1 if OPT_IGNORE_OPEN: continue if OPT_KEEP_LAYER: brep_layer = rs.ObjectLayer(rs.coerceguid(brep)) exploded = rs.ExplodePolysurfaces(brep, True) remaining_srfs = [] for srf in exploded: norm = rs.SurfaceNormal(srf, [0.5, 0.5]) if 10 > rs.VectorAngle(norm, [0, 0, 1]) or 10 > rs.VectorAngle( norm, [0, 0, -1]): rs.DeleteObject(srf) else: remaining_srfs.append(srf) areas = [rs.SurfaceArea(s) for s in remaining_srfs] areas = [x[0] for x in areas] srfs, areas = zip( *sorted(zip(remaining_srfs, areas), key=lambda x: x[1])) pt1, _ = rs.SurfaceAreaCentroid(srfs[-1]) pt2, _ = rs.SurfaceAreaCentroid(srfs[-2]) vect = rs.VectorCreate(pt2, pt1) vect = rs.VectorDivide(vect, 2) rs.MoveObject(srfs[-1], vect) if OPT_KEEP_LAYER: rs.ObjectLayer(srfs[-1], brep_layer) rs.SelectObjects(srfs[-1]) rs.DeleteObjects(srfs[:-1]) rs.EnableRedraw(True) rs.Redraw() current_cplane.Plane = temp_cplane if solid_brep_count > 0: outcome = " and were not collapsed." if OPT_IGNORE_OPEN else " and may have been flattened incorrectly. Check input geometry." report = str(solid_brep_count) + " brep(s) were not closed" + outcome print report
print(type(srfs[0])) print(srfs[0]) seq = [x * dist + dist for x in range(count)] intervals = [(x - dist, x) for x in seq] def groupByPosition(pairs): # values = set(map(lambda x:x[1], pairs)) newpairs = [[y for y in pairs if min(x) < y[1] < max(x)] for x in intervals] # print newpairs return sorted(newpairs, key=lambda x: x[0][1]) srfpairs = [[x, rs.SurfaceAreaCentroid(x)[0][axis], str(x)] for x in srfs] print(srfpairs[0]) # grouped = groupByPosition(srfpairs) # Intervals = th.list_to_tree(intervals) b = th.list_to_tree(groupByPosition(srfpairs)) a = srfs """[summary] """ # from ghpythonlib.componentbase import executingcomponent as component # import Grasshopper, GhPython
def alingBlock(block_a, block_b, model_inside): """ Scale box to the correct dimentions Align box a and what is inside to box b The dimention of the box is expected to be equal lenght :param block_a: :param block_b: block to align block_a to :param model_inside: models inside block_a """ # Find center of box_a exp_a = rs.ExplodePolysurfaces(block_a) cen_a = Vector3d(0, 0, 0) for exp in exp_a: cen_a += rs.SurfaceAreaCentroid(exp)[0] cen_a /= 6.0 # Find center of box_b exp_b = rs.ExplodePolysurfaces(block_b) cen_b = Vector3d(0, 0, 0) for exp in exp_b: cen_b += rs.SurfaceAreaCentroid(exp)[0] cen_b /= 6.0 # Find side Lenght c = rs.DuplicateEdgeCurves(exp_a[0]) L = float(rs.CurveLength(c[0])) def sqrt_length(a, b, c): return math.sqrt(a * a + b * b + c * c) def create_matrix(a, b, c, d): M = [[a[0], a[1], a[2], d[0]], [b[0], b[1], b[2], d[1]], [c[0], c[1], c[2], d[2]], [0, 0, 0, 1]] return M # find basic function of box_a basic_0 = cen_a - rs.SurfaceAreaCentroid(exp_a[0])[0] basic_0 /= sqrt_length(basic_0[0], basic_0[1], basic_0[2]) basic_1 = rs.SurfaceAreaCentroid(exp_a[1])[0] - cen_a basic_1 /= sqrt_length(basic_1[0], basic_1[1], basic_1[2]) basic_2 = cen_a - rs.SurfaceAreaCentroid(exp_a[4])[0] basic_2 /= sqrt_length(basic_2[0], basic_2[1], basic_2[2]) # create tranformation matrix M = create_matrix(basic_0, basic_1, basic_2, [0, 0, 0]) # scale rs.ScaleObjects([block_a] + model_inside, cen_a, [200 / L, 200 / L, 200 / L]) # move to [0,0,0] rs.MoveObjects([block_a] + model_inside, -cen_a) # rotate rs.TransformObjects([block_a] + model_inside, M) # move to object rs.MoveObjects([block_a] + model_inside, cen_b) rs.DeleteObjects(exp_a) rs.DeleteObjects(exp_b) rs.DeleteObjects(c)
import System.Guid as Guid import Grasshopper as gh seq = [x * dist + dist for x in range(count)] intervals = [(x - dist, x) for x in seq] def groupByPosition(pairs): # values = set(map(lambda x:x[1], pairs)) newpairs = [[y for y in pairs if min(x) < y[1] < max(x)] for x in intervals] # print newpairs return sorted(newpairs, key=lambda x:x[0][1]) guidlist = [] sc.doc = rc.RhinoDoc.ActiveDoc srfpairs = [[x, rs.SurfaceAreaCentroid(x)[0][axis], rs.ObjectLayer(x)] for x in guids] sc.doc = ghdoc b = th.list_to_tree(groupByPosition(srfpairs)) a = srfs """[summary] """ # import rhinoscriptsyntax as rs # import System.Guid as Guid # import Rhino
uDomain = rs.SurfaceDomain(idSurface, 0) vDomain = rs.SurfaceDomain(idSurface, 1) # get size int from domain & / by intended count = increment between surfaces uStep = (uDomain[1] - uDomain[0]) / intCount vStep = (vDomain[1] - vDomain[0]) / intCount #print uStep #print vStep rs.EnableRedraw(False) # loop through size of surface by step increment in both u & v directions for u in rs.frange(uDomain[0], uDomain[1], uStep): for v in rs.frange(vDomain[0], vDomain[1], vStep): pt = rs.EvaluateSurface(idSurface, u, v) # get points at each domain step if rs.Distance(pt, rs.BrepClosestPoint(idSurface, pt)[0]) < 0.1: srfFrame = rs.SurfaceFrame( idSurface, [u, v]) # create ref plane at each division point newPlane = rs.AddPlaneSurface( srfFrame, 1.0, 1.0) # create surface at each ref plane # add height guideline from plane's origin to "ceiling" centerPt = rs.SurfaceAreaCentroid( newPlane) # locate center of each new plane limit = 10 # set "ceiling" endPt = limit - centerPt[0][ 2] # access z coordinate with the tuple rs.AddLine(centerPt[0], rs.PointAdd(centerPt[0], (0, 0, endPt))) rs.EnableRedraw(True) # refresh viewport at one time only
def getOrderedGeom(_geomList): """ Takes in a list of geometry (brep) and 'orders' it left->right. Used to order window surfaces or similar for naming 0...1...2...etc... Make sure the surface normals are all pointing 'out' for this to work properly. """ setXs = [] setYs = [] setZs = [] Centroids = [] CentroidsX = [] #Go through all the selected window geometry, get the information needed for i in range(len(_geomList)): # Get the surface normal for each window windowBrep = rs.coercebrep(_geomList[i]) surfaceList = windowBrep.Surfaces for eachSurface in surfaceList: srfcCentroid = rs.SurfaceAreaCentroid(eachSurface)[0] b, u, v = eachSurface.ClosestPoint(srfcCentroid) srfcNormal = eachSurface.NormalAt(u, v) setXs.append(srfcNormal.X) setYs.append(srfcNormal.Y) setZs.append(srfcNormal.Z) Centroids.append(srfcCentroid) CentroidsX.append(srfcCentroid.X) # Find the average Normal Vector of the set px = sum(setXs) / len(setXs) py = sum(setYs) / len(setYs) pz = sum(setZs) / len(setZs) avgNormalVec = Rhino.Geometry.Point3d(px, py, pz) # Find a line through all the points and its midpoint #print Centroids fitLine = rs.LineFitFromPoints(Centroids) newLine = Rhino.Geometry.Line(fitLine.From, fitLine.To) # Find the Midpoint of the Line #rs.CurveMidPoint(newLine) #Not working.... midX = (fitLine.From.X + fitLine.To.X) / 2 midY = (fitLine.From.Y + fitLine.To.Y) / 2 midZ = (fitLine.From.Z + fitLine.To.Z) / 2 lineMidpoint = Rhino.Geometry.Point3d(midX, midY, midZ) # New Plane newAvgWindowPlane = rs.CreatePlane(lineMidpoint, avgNormalVec, [0, 0, 1]) # Rotate new Plane to match the window finalPlane = rs.RotatePlane(newAvgWindowPlane, 90, [0, 0, 1]) # Plot the window Centroids onto the selection Set Plane centroidsReMaped = [] for eachCent in Centroids: centroidsReMaped.append(finalPlane.RemapToPlaneSpace(eachCent)) # Sort the original geometry, now using the ordered centroids as key return [x for _, x in sorted(zip(centroidsReMaped, _geom))]
def outbox(self, gap): #DEFINE BASE SLICE------------> rec_lr = rs.AddRectangle(rs.WorldYZPlane(), self.data[0], self.data[1]) srf_lr = rs.AddPlanarSrf(rec_lr) rec_lr = rs.MoveObject( rec_lr, rs.VectorCreate(ZERO, rs.SurfaceAreaCentroid(srf_lr)[0])) rs.DeleteObject(srf_lr) rec_lr = cutrec(2, rec_lr, gap) srf_lr = rs.AddPlanarSrf(rec_lr) rs.DeleteObjects(rec_lr) ### CANNOT USE WORLDZX()----------> xz = rs.PlaneFromFrame([0, 0, 0], [1, 0, 0], [0, 0, 1]) rec_fk = rs.AddRectangle(xz, self.data[2], self.data[3]) ###<------------- srf_fk = rs.AddPlanarSrf(rec_fk) rec_fk = rs.MoveObject( rec_fk, rs.VectorCreate(ZERO, rs.SurfaceAreaCentroid(srf_fk)[0])) rs.DeleteObject(srf_fk) rec_fk = cutrec(2, rec_fk, gap) srf_fk = rs.AddPlanarSrf(rec_fk) rs.DeleteObjects(rec_fk) rec_tb = rs.AddRectangle(rs.WorldXYPlane(), self.data[5], self.data[4]) srf_tb = rs.AddPlanarSrf(rec_tb) rec_tb = rs.MoveObject( rec_tb, rs.VectorCreate(ZERO, rs.SurfaceAreaCentroid(srf_tb)[0])) rs.DeleteObject(srf_tb) rec_tb = cutrec(1, rec_tb, 0) srf_tb = rs.AddPlanarSrf(rec_tb) rs.DeleteObject(rec_tb) #CONSTRUCT THE BOX--------------------> srfs = [] srfs.append(rs.CopyObject(srf_tb, [0, 0, self.data[3] / 2.0])) srfs.append(rs.CopyObject(srf_tb, [0, 0, self.data[3] / (-2.0)])) srfs.append(rs.CopyObject(srf_fk, [0, self.data[0] / 2.0, 0])) srfs.append( rs.MirrorObject( rs.CopyObject(srf_fk, [0, self.data[0] / (-2.0), 0]), [0, 1, 0], [0, 0, 1])) srfs.append(rs.CopyObject(srf_lr, [self.data[5] / (-2.0), 0, 0])) srfs.append( rs.MirrorObject( rs.CopyObject(srf_lr, [self.data[5] / (2.0), 0, 0]), [1, 0, 0], [0, 0, 1])) bele = [] for srf in srfs: extvec = rs.VectorCreate(ZERO, rs.SurfaceAreaCentroid(srf)[0]) max, sign, loc = 0, -1, 0 for i in range(len(extvec)): if abs(extvec[i]) > max: max = abs(extvec[i]) sign = extvec[i] loc = i if loc == 0: line = rs.AddLine( ZERO, rs.VectorScale(rs.VectorUnitize([sign, 0, 0]), cut2)) bele.append(rs.ExtrudeSurface(srf, line)) elif loc == 1: line = rs.AddLine( ZERO, rs.VectorScale(rs.VectorUnitize([0, sign, 0]), cut2)) bele.append(rs.ExtrudeSurface(srf, line)) elif loc == 2: line = rs.AddLine( ZERO, rs.VectorScale(rs.VectorUnitize([0, 0, sign]), cut2)) bele.append(rs.ExtrudeSurface(srf, line)) rs.DeleteObject(line) rs.DeleteObjects(srfs) rs.DeleteObjects([srf_lr, srf_fk, srf_tb]) return bele
def rev(Ge, Lis, Src, div): udiv = div vdiv = div Pt_L = Lis[0][0] srf = [] FirstRay = [] SecondRay = [] First_RefPoint = [] drawray = [] Reverb = [] for i in Ge: srf.append(i[0]) sph = (rs.AddSphere(Src[1], Src[2])) Src_pt = (Src[1]) u = rs.SurfaceDomain(sph, 0) v = rs.SurfaceDomain(sph, 1) pts = [] for i in range(0, udiv + 1, 1): for j in range(0, vdiv + 1, 1): pt = (i / udiv, j / vdiv, 0) sphP = rs.SurfaceParameter(sph, pt) newpt = rs.EvaluateSurface(sph, sphP[0], sphP[1]) pts.append(rs.AddPoint(newpt)) Dir = [] for p in pts: Dir.append(rs.VectorCreate(p, Src_pt)) Reflexion = [] for d in Dir: Reflexion.append(rs.ShootRay(srf, Src_pt, d, reflections=4)) Project = [] for v in Reflexion: Cl_Pt = [] Ray_v = [] try: Project.append(v[1]) Ray_v.append(rs.AddPolyline(v)) except: pass for u in Ray_v: pt_on = rs.CurveClosestPoint(u, Pt_L) cl = rs.EvaluateCurve(u, pt_on) Dicl = (rs.Distance(Pt_L, cl)) if Dicl <= ((Lis[0])[3]): try: First_RefPoint = rs.CurveClosestPoint(u, v[1]) Second_RefPoint = rs.CurveClosestPoint(u, v[2]) endc = ((rs.CurveClosestPoint( u, (rs.CurveEndPoint(u))))) if pt_on > Second_RefPoint: SecondRay.append(pt_on / endc * (rs.CurveLength(u))) drawray.append(u) elif pt_on > First_RefPoint: FirstRay.append(pt_on / endc * (rs.CurveLength(u))) except: pass box = rs.AddBox(rs.BoundingBox(Project)) boxarea = round((rs.SurfaceArea(box)[0]), 2) Cube = [] Cube.append(box) surfacetorev = [] for s in srf: ptons = [] for p in Project: if rs.Distance((rs.BrepClosestPoint(s, p)[0]), p) < 0.1: ptons.append(p) if len(ptons) > 0: surfacetorev.append(s) surfaceab = [] for x in Ge: if x[0] in surfacetorev: surfaceab.append(x[2]) SrfandAb = [(surfacetorev[i], surfaceab[i]) for i in range(0, len(surfacetorev))] bbox = box box = round(((rs.SurfaceVolume(box))[0]), 1) srfvol = [] srfvolex = [] absvol = [] srfarea = [] srfrev = [] areaabs = [] surfacecenter = [] absidx = [] absvoltot = [] for i in SrfandAb: if rs.SurfaceVolume(i[0]) > 0: srfvol.append(i[0]) absvol.append(i[1]) else: srfarea.append((rs.SurfaceArea(i[0]))[0]) absvoltot.append(i[1]) srfvolex = rs.ExplodePolysurfaces(srfvol) for i in srfvolex: ptonsrf = [] usefulsrf = [] for p in Project: if rs.Distance((rs.BrepClosestPoint(i, p)[0]), p) < 0.01: ptonsrf.append(p) usefulsrf.append(i) if len(ptonsrf) > 0: srfarea.append(rs.SurfaceArea(i)[0]) srfrev.append(i) for i in srfrev: surfacecenter.append(rs.SurfaceAreaCentroid(i)[0]) for b in srfvol: for i in surfacecenter: if rs.Distance((rs.BrepClosestPoint(b, i)[0]), i) < 0.01: absidx.append(srfvol.index(b)) for i in absidx: absvoltot.append(absvol[i]) try: areaabs = [ srfarea[i] * (absvoltot[i]) for i in range(0, len(absvoltot)) ] except: raise Exception( 'One source must be too deep inside a geometry, try to get it out or to move it a little bit !' ) Builtareaabs = 0 for i in areaabs: Builtareaabs += i BuiltArea = 0 for i in srfarea: BuiltArea += i BuiltArea = round(BuiltArea, 2) EmptyArea = 2 * (round(boxarea - BuiltArea, 2)) if EmptyArea < 0: EmptyArea = 0 TR = 1000 * (0.16 * box) / (Builtareaabs + (EmptyArea * 1)) FRValue = 0 for f in FirstRay: FV = ((((Lis[0])[3]) * 15) / f) FRValue += FV if FRValue >= 125: FRValue = 125 SRValue = 0 for s in SecondRay: SV = ((((Lis[0])[3]) * 20) / s) SRValue += SV if SRValue > 125: SRValue = 125 Reverb.append(round(FRValue)) Reverb.append(round(SRValue)) Reverb.append(round(TR, 2)) return Reverb
def RunCommand(is_interactive): rs.EnableRedraw(False) defaultName = '' areaObj = rs.GetObject("Select Object:", filter=65536, preselect=True) areaName = rs.ObjectName(areaObj) if not areaName: defaultName = rs.ObjectLayer(areaObj).split("-")[-1].replace("_", " ") print("default", defaultName) areaName = rs.GetString( "Enter name of area to be displayed", defaultName, ["RETAIL", "RESIDENTIAL", "AMENITY", "BOH", "LOBBY"]) else: areaName = areaName.upper() #areaName = areaName.replace(" ", "\n") nameOffset = 20 nameTextSize = 50 areaTextSize = 40 scale = rs.GetReal("Scale for text (.5 for towers)", 1) nameOffset = nameOffset * scale nameTextSize = nameTextSize * scale areaTextSize = areaTextSize * scale areaObjExp = rs.ExplodeHatch(areaObj) try: area = rs.Area(areaObjExp) except: print("Object not a solid hatch") rs.DeleteObject(areaObjExp) area = area * (rs.UnitScale(9))**2 area = int(area) area = "{:,} SF".format(area) areaCenter = rs.SurfaceAreaCentroid(areaObjExp)[0] rs.DeleteObject(areaObjExp) areaCenter = rs.PointAdd(areaCenter, (0, ((nameOffset + areaTextSize) / -2), 0)) nameCenter = rs.PointAdd(areaCenter, (0, nameOffset + nameTextSize, 0)) print(nameCenter, areaCenter) areaText = rs.AddText(area, areaCenter, areaTextSize, justification=2) nameText = rs.AddText(areaName, nameCenter, nameTextSize, justification=2) textBounds = rs.BoundingBox(areaText) textBoundary = rs.AddPolyline(textBounds[0:5]) nameTextHeight = rs.Distance( rs.BoundingBox(nameText)[2], rs.BoundingBox(nameText)[1]) print("AreaNameHeight", nameTextHeight) textBorder = rs.OffsetCurve(textBoundary, (0, 0, 0), 5 * scale, style=1) rs.DeleteObject(textBoundary) rs.ObjectName(nameText, "Name Text") rs.ObjectName(areaText, "Area Text") rs.ObjectName(textBorder, "Text Border") parent = rs.ParentLayer(rs.ObjectLayer(areaObj)) rs.ObjectLayer(nameText, parent + "::A-ANNO-NOTE") rs.ObjectLayer(areaText, parent + "::A-ANNO-NOTE") rs.ObjectLayer(textBorder, parent + "::A-ANNO-NOTE") areasGroup = rs.AddGroup() rs.AddObjectsToGroup([areaText, nameText, textBorder], areasGroup) rs.SelectObjects(rs.ObjectsByGroup(areasGroup)) rs.EnableRedraw(True)