def UpdateAreaTag():
objs = rs.GetObjects('Select area tags to update', preselect = True)
if objs is None: return
successfulObjsRun = 0
failedObjsRun = 0
for obj in objs:
try:
host = rs.GetUserText(obj, 'hostGUID')
if host is None:
print "Could not find associated geometry"
return None
#Get number of dec places
text = rs.TextObjectText(obj)
splitText = text.Split(" ")
numberString = splitText[0]
units = splitText[-1]
try:
decPlaces = len(numberString.Split(".")[1])
except:
decPlaces = 0
#Get area
if rs.UnitSystem() == 8:
area = rs.Area(rs.coerceguid(host))*0.0069444444444444
areaText = utils.RoundNumber(area, decPlaces) + " " + units
else:
print "WARNING: Your units are not in inches"
area = rs.Area(rs.coerceguid(host))
areaText = area + ' ' + rs.UnitSystemName(False, True, True)
rs.TextObjectText(obj, areaText)
successfulObjsRun += 1
except:
failedObjsRun += 1
print "Tag failed"
utils.SaveFunctionData('Drawing-Update Area Tag', [__version__, successfulObjsRun, failedObjsRun])
return successfulObjsRun
def ColorBySize():
try:
objs = rs.GetObjects("Select objects to color",
1073815613,
preselect=True)
if objs is None: return
print "Select First Color"
firstColor = rs.GetColor()
if firstColor is None: return
print "Select Second Color"
secondColor = rs.GetColor(firstColor)
if secondColor is None: return
rs.EnableRedraw(False)
colorLine = rs.AddLine(firstColor, secondColor)
areas = []
for obj in objs:
if rs.IsCurve(obj):
if rs.IsCurveClosed(obj):
areas.append(rs.CurveArea(obj)[0])
else:
areas.append(rs.CurveLength(obj))
elif rs.IsSurface(obj):
areas.append(rs.SurfaceArea(obj)[0])
elif rs.IsPolysurface(obj):
if rs.IsPolysurfaceClosed(obj):
areas.append(rs.SurfaceVolume(obj)[0])
elif rs.IsHatch(obj):
areas.append(rs.Area(obj))
else:
print "Only curves, hatches, and surfaces supported"
return
newAreas = list(areas)
objAreas = zip(newAreas, objs)
objAreas.sort()
objSorted = [objs for newAreas, objs in objAreas]
areas.sort()
normalParams = utils.RemapList(areas, 0, 1)
colors = []
for t in normalParams:
param = rs.CurveParameter(colorLine, t)
colors.append(rs.EvaluateCurve(colorLine, param))
for i, obj in enumerate(objSorted):
rs.ObjectColor(obj, (colors[i].X, colors[i].Y, colors[i].Z))
rs.DeleteObject(colorLine)
rs.EnableRedraw(True)
return True
except:
return False
def ReturnObjectOutline(objects):
listOfObjOutlines = []
for id in objects:
for t in id:
# check if closed curve
if rs.IsCurveClosed(t):
if rs.Area(t) > 1000:
listOfObjOutlines.append(t)
break
return listOfObjOutlines
def get_area(objs):
area = 0
for obj in objs:
areaObjExp = rs.ExplodeHatch(obj)
try:
area += rs.Area(areaObjExp)
except:
print("Object not a solid hatch")
rs.DeleteObject(areaObjExp)
rs.EnableRedraw(True)
rs.DeleteObject(areaObjExp)
return area
def calcFootprint(_zoneObjs, _opaqueSurfaces):
# Finds the 'footprint' of the building for 'Primary Energy Renewable' reference
# 1) Re-build the zone Breps
# 2) Join all the zone Breps into a single brep
# 3) Find the 'box' for the single joined brep
# 4) Find the lowest Z points on the box, offset another 10 units 'down'
# 5) Make a new Plane at this new location
# 6) Projects the brep onto the new Plane
#-----
zoneBreps = []
for zone in _zoneObjs:
zoneSurfaces = []
for srfc in _opaqueSurfaces:
if srfc.HostZoneName == zone.ZoneName:
zoneSurfaces.append(ghc.BoundarySurfaces(srfc.Boundary))
zoneBrep = ghc.BrepJoin(zoneSurfaces).breps
zoneBreps.append(zoneBrep)
bldg_mass = ghc.SolidUnion(zoneBreps)
if bldg_mass == None:
return None
#------- Find Corners, Find 'bottom' (lowest Z)
bldg_mass_corners = [v for v in ghc.BoxCorners(bldg_mass)]
bldg_mass_corners.sort(reverse=False, key=lambda point3D: point3D.Z)
rect_pts = bldg_mass_corners[0:3]
#------- Project Brep to Footprint
projection_plane1 = ghc.Plane3Pt(rect_pts[0], rect_pts[1], rect_pts[2])
projection_plane2 = ghc.Move(projection_plane1, ghc.UnitZ(-10)).geometry
matrix = rs.XformPlanarProjection(projection_plane2)
footprint_srfc = rs.TransformObjects(bldg_mass, matrix, copy=True)
footprint_area = rs.Area(footprint_srfc)
#------- Output
Footprint = namedtuple('Footprint',
['Footprint_surface', 'Footprint_area'])
fp = Footprint(footprint_srfc, footprint_area)
return fp
def createBlock(self):
splitSrfs = us.util.splitSrfwCrvs(self.srfGuid, self.roadTrims, True)
if (splitSrfs == None):
return False
listToSort = []
for srf in splitSrfs:
listToSort.append([srf, rs.Area(srf)])
sortedList = sorted(listToSort, key=lambda srf: srf[1], reverse=True)
shrk = rs.ShrinkTrimmedSurface(sortedList[0][0])
self.blockSrf = sortedList[0][0]
for x in range(1, sortedList.Count):
sc.doc.Objects.Delete(sortedList[x][0], True)
self.cleanup()
def getArea(input):
return rs.Area(input)
outputLevels.extend(sorted(L_Levels))
# Build Area Table for population
for level in outputLevels:
if requestType == False:
areasTable[level] = {x: [0] for x in list(hatchnames)}
else:
areasTable[level] = {x: [] for x in list(hatchnames)}
#get all the hatches in the document
allHatch = rs.ObjectsByType(65536)
for hatch in allHatch:
if getLayerType(hatch):
if requestType == False:
areasTable[getParent(hatch)][getLayerType(hatch)][0] += rs.Area(
hatch)
else:
if getLayerType(hatch) == "RESIDENTIAL":
areasTable[getParent(hatch)][getLayerType(hatch)].append(
rs.Area(hatch))
if requestType == True: hatchnames = ["RESIDENTIAL"]
outputList = "Level, " + ",".join(hatchnames) + "\n\n"
for lev in reversed(outputLevels):
max_list = 0
for hlev in hatchnames:
if len(areasTable[lev][hlev]) > max_list:
max_list = len(areasTable[lev][hlev])
for row in range(max_list):
outputList += lev + ","
def AreaTag(obj, decPlaces):
try:
rhsrf = rs.coercesurface(obj)
if rs.IsCurve(obj):
if rs.IsCurvePlanar(obj) == False:
return [0, False]
if rs.IsCurveClosed(obj) == False:
return [0, False]
#get area
if rs.UnitSystem() == 8:
if rs.IsCurve(obj):
area = rs.CurveArea(obj)[0]*0.0069444444444444
else:
area = rs.Area(obj)*0.0069444444444444
areaText = utils.RoundNumber(area, decPlaces) + " SF"
else:
print "WARNING: Your units are not in inches"
area = rs.CurveArea(obj)[0]
areaText = area + ' ' + rs.UnitSystemName(False, True, True)
#add annotation style
dimStyle = sc.doc.DimStyles.FindName('PCPA_12')
###########################################################################
#CURVES
if rs.IsCurve(obj):
if utils.IsRectangle(obj)[0]:
#RECTANGLES
srf = rs.AddPlanarSrf(obj)
plane = HorizPlaneFromSurface(srf)
rs.DeleteObject(srf)
else:
#OTHER CURVES
srf = rs.AddPlanarSrf(obj)
plane = HorizPlaneFromSurface(srf)
rs.DeleteObject(srf)
###########################################################################
#HATCHES
elif rs.IsHatch(obj):
rhobj = rs.coercegeometry(obj)
boundaryCrvs = []
crvs = rhobj.Get3dCurves(False)
for crv in crvs:
boundaryCrvs.append(crv)
for crv in rhobj.Get3dCurves(True):
boundaryCrvs.append(crv)
srf = sc.doc.Objects.AddBrep(rc.Geometry.Brep.CreatePlanarBreps(boundaryCrvs)[0])
plane = HorizPlaneFromSurface(srf)
rs.DeleteObject(srf)
###########################################################################
#SURFACES
elif rs.IsSurface(obj):
plane = HorizPlaneFromSurface(obj)
###########################################################################
#OTHER/ERROR
else:
pts = rs.BoundingBox(obj)
centerPoint = (pts[0] + pts[6]) / 2
if dimStyle is not None:
textHeight = dimStyle.TextHeight
areaTag = rs.AddText(areaText, plane, height = textHeight, justification = 131074)
else:
areaTag = rs.AddText(areaText, plane, height = 1, justification = 131074)
#Change layers
hostLayer = layers.AddLayerByNumber(8103, False)
rs.ObjectLayer(areaTag, layers.GetLayerNameByNumber(8103))
return [area, True, areaTag]
except:
return [0, False]
import rhinoscriptsyntax as rs
import trkRhinoPy as trp
# walls = rs.GetObjects("Select solids", rs.filter.polysurface, preselect=True)
blk = rs.GetObject("Select blocks", rs.filter.instance, preselect=True)
objects = rs.BlockObjects(blk)
map(lambda x: rs.Area(x), objects)
# rs.EnableRedraw(False)
# trp.redefineBlockScale(blk)
# rs.EnableRedraw(True)
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)
