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)
