def CalcRevealDims(_phpp_window_obj, RevealShaderObjs_input, SideIntersectionSurface, Side_OriginPt, Side_Direction):
#Test shading objects for their edge points
Side_IntersectionCurve = []
Side_IntersectionPoints = []
for i in range(len(RevealShaderObjs_input)): #This is the list of shading objects to filter
if ghc.BrepXBrep(RevealShaderObjs_input[i], SideIntersectionSurface).curves != None:
Side_IntersectionCurve.append(ghc.BrepXBrep(RevealShaderObjs_input[i], SideIntersectionSurface).curves)
for i in range(len(Side_IntersectionCurve)):
for k in range(len(ghc.ControlPoints(Side_IntersectionCurve[i]).points)):
Side_IntersectionPoints.append(ghc.ControlPoints(Side_IntersectionCurve[i]).points[k])
#Find the top/closets point for each of the objects that could possibly shade
Side_KeyPoints = []
Side_Rays = []
Side_Angles = []
for i in range(len(Side_IntersectionPoints)):
if Side_OriginPt != Side_IntersectionPoints[i]:
Ray = ghc.Vector2Pt(Side_OriginPt, Side_IntersectionPoints[i], False).vector
Angle = math.degrees(ghc.Angle(_phpp_window_obj.surface_normal, Ray).angle)
if Angle < 89.9:
Side_Rays.append(Ray)
Side_Angles.append(float(Angle))
Side_KeyPoints.append(Side_IntersectionPoints[i])
Side_KeyPoint = Side_KeyPoints[Side_Angles.index(min(Side_Angles))]
Side_KeyRay = Side_Rays[Side_Angles.index(min(Side_Angles))]
#use the Key point found to calculte the Distances for the PHPP Shading Calculator
Side_Hypot = ghc.Length(ghc.Line(Side_OriginPt, Side_KeyPoint))
Deg = (ghc.Angle(Side_Direction, Side_KeyRay).angle) #note this is in Radians
Side_o_reveal = math.sin(Deg) * Side_Hypot
Side_d_reveal = math.sqrt(Side_Hypot**2 - Side_o_reveal**2)
Side_CheckLine = ghc.Line(Side_OriginPt, Side_KeyPoint)
return [Side_o_reveal, Side_d_reveal, Side_CheckLine]
def get_footprint(_surfaces):
# Finds the 'footprint' of the building for 'Primary Energy Renewable' reference
# 1) Re-build the Opaque Surfaces
# 2) Join all the surface 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 edges onto the new Plane
# 7) Split a surface using the edges, combine back into a single surface
Footprint = namedtuple('Footprint',
['Footprint_surface', 'Footprint_area'])
#----- Build brep
surfaces = (from_face3d(surface.Srfc) for surface in _surfaces)
bldg_mass = ghc.BrepJoin(surfaces).breps
bldg_mass = ghc.BoundaryVolume(bldg_mass)
if not bldg_mass:
return Footprint(None, 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]
#------- Projection Plane
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)
#------- Project Edges onto Projection Plane
projected_edges = []
for edge in ghc.DeconstructBrep(bldg_mass).edges:
projected_edges.append(ghc.Transform(edge, matrix))
#------- Split the projection surface using the curves
l1 = ghc.Line(rect_pts[0], rect_pts[1])
l2 = ghc.Line(rect_pts[0], rect_pts[2])
max_length = max(ghc.Length(l1), ghc.Length(l2))
projection_surface = ghc.Polygon(projection_plane2, max_length * 100, 4,
0).polygon
projected_surfaces = ghc.SurfaceSplit(projection_surface, projected_edges)
#------- Remove the biggest surface from the set(the background srfc)
projected_surfaces.sort(key=lambda x: x.GetArea())
projected_surfaces.pop(-1)
#------- Join the new srfcs back together into a single one
unioned_NURB = ghc.RegionUnion(projected_surfaces)
unioned_surface = ghc.BoundarySurfaces(unioned_NURB)
return Footprint(unioned_surface, unioned_surface.GetArea())
def RunScript(self, AS, CL):
# Initialize outputs
S = []
TS = CL
W = []
CS = []
# Set defaults if no values are provided
D = 1000
# Iterate over each test segment
for seg in CL:
# Extend line to threshold width
midpt, TT, t = ghc.EvaluateLength(seg, 0.5, True)
SS, E = ghc.EndPoints(seg)
V, L = ghc.Vector2Pt(midpt, SS, False)
vect = ghc.Amplitude(V, D/2)
G1, X = ghc.Move(midpt, vect)
G2, X = ghc.Move(midpt, -vect)
test_line = ghc.Line(G1, G2)
# Rotate test line 90 degrees
test_line, X = ghc.Rotate(test_line, math.pi/2, midpt)
# Check for intersection
srf_intersection = checkIntersection(test_line, AS, midpt, D)
# Store results
CS.append(srf_intersection)
W.append(ghc.Length(srf_intersection))
# Return outputs
return TS, W, CS
def createGCLines(pointsOfView, vertex):
lines = [gc.Line(a, b) for a in pointsOfView for b in vertex]
return lines
b_pos_x = [] # y方向に架かるブリッジが配置されるコアの配置位置を格納
b_pos_y = [] # x方向に架かるブリッジが配置されるコアの配置位置を格納
bridge_x = [] # 生成されたブリッジ（y方向）を格納
bridge_y = [] # 生成されたブリッジ（x方向）を格納
# Step 1にて生成されたコアの配置パターンからブリッジ生成に関する情報の取得
for i in range(0, len(pos)):
for ii in range(0, len(pos)):
# Step1で生成されたコア配置間の距離が2スパン以内の組合せに対して実行
if i != ii and gh.Distance(pos[i], pos[ii]) <= span * 2:
# y座標が等しいコアの組合せに対して実行（x方向に架かるブリッジの生成情報の取得）
if pos[i][1] == pos[ii][1]:
# wにてコア間の距離を取得,cにてコアとコアの中心位置を取得
w = gh.Distance(pos[i], pos[ii])
c = gh.DivideCurve(gh.Line(pos[i], pos[ii]), 2).points[1]
pair = [c, w]
if pair not in b_pos_x:
b_pos_x.append(pair)
# x座標が等しいコアの組合せに対して実行（y方向に架かるのブリッジ生成情報の取得）
if pos[i][0] == pos[ii][0]:
#wにてコア間の距離を取得, cにてコアとコアの中心位置を取得
w = gh.Distance(pos[i], pos[ii])
c = gh.DivideCurve(gh.Line(pos[i], pos[ii]), 2).points[1]
pair = [c, w]
if pair not in b_pos_y:
b_pos_y.append(pair)
# x方向に架かるブリッジの生成
for i in range(0, len(b_pos_x)):
#b_zにて低いブリッジの断面方向配置位置を生成, yz_posにて低いブリッジを生成するための基点生成
) and plane == "3d": #(drx[nj]*dry[nj]!=0 or dry[nj]*drz[nj]!=0 or drx[nj]*drz[nj]!=0) :
if drx[nj] * dry[nj] * drz[nj] != 0:
isuv[n] = 0
if (case == 1) and plane == "xy":
if drx[nj] * dry[nj] != 0:
isuv[n] = 0
if (case == 1) and plane == "yz":
if dry[nj] * drz[nj] != 0:
isuv[n] = 0
if (case == 1) and plane == "xz":
if drx[nj] * drz[nj] != 0:
isuv[n] = 0
nel = 0
l = 0
for l in range(n):
l += 1
i1[l] = indv1[l]
i2[l] = indv2[l]
if isuv[l] == 1:
nel += 1
indv1[nel] = i1[l]
indv2[nel] = i2[l]
k0 = int(indv1[nel])
k1 = int(indv2[nel])
linemake = gh.Line(pointdata[k0], pointdata[k1])
linedata.Add(linemake)
a = indv1
b = indv2
def find_overhang_shading(_phpp_window_obj, _shadingGeom, _extents=99):
# Figure out the glass surface (inset a bit) and then
# find the origin point for all the subsequent shading calcs (top, middle)
glzgCenter = ghc.Area(_phpp_window_obj.glazing_surface).centroid
glazingEdges = _phpp_window_obj._get_edges_in_order( _phpp_window_obj.glazing_surface )
glazingTopEdge = from_linesegment3d(glazingEdges.Top)
ShadingOrigin = ghc.CurveMiddle(glazingTopEdge)
# In order to also work for windows which are not vertical, find the
# 'direction' from the glazing origin and the top/middle ege point
UpVector = ghc.Vector2Pt(glzgCenter, ShadingOrigin, True).vector
#-----------------------------------------------------------------------
# First, need to filter the scene to find the objects that are 'above'
# the window. Create a 'test plane' that is _extents (99m) tall and 0.5m past the wall surface, test if
# any objects intersect that plane. If so, add them to the set of things
# test in the next step
depth = float(_phpp_window_obj.install_depth) + 0.5
edge1 = ghc.LineSDL(ShadingOrigin, UpVector, _extents)
edge2 = ghc.LineSDL(ShadingOrigin, _phpp_window_obj.surface_normal, depth)
intersectionTestPlane = ghc.SumSurface(edge1, edge2)
OverhangShadingObjs = (x for x in _shadingGeom
if ghc.BrepXBrep(intersectionTestPlane, x).curves != None)
#-----------------------------------------------------------------------
# Using the filtered set of shading objects, find the 'edges' of shading
# geom and then decide where the maximums shading point is
# Create a new 'test' plane coming off the origin (99m in both directions this time).
# Test to find any intersection shading objs and all their crvs/points with this plane
HorizontalLine = ghc.LineSDL(ShadingOrigin, _phpp_window_obj.surface_normal, _extents)
VerticalLine = ghc.LineSDL(ShadingOrigin, UpVector, _extents)
IntersectionSurface = ghc.SumSurface(HorizontalLine, VerticalLine)
IntersectionCurves = (ghc.BrepXBrep(obj, IntersectionSurface).curves
for obj in OverhangShadingObjs
if ghc.BrepXBrep(obj, IntersectionSurface).curves != None)
IntersectionPointsList = (ghc.ControlPoints(crv).points for crv in IntersectionCurves)
IntersectionPoints = (pt for list_of_pts in IntersectionPointsList for pt in list_of_pts)
#-----------------------------------------------------------------------
# If there are any intersection Points found, choose the right one to use to calc shading....
# Find the top/closets point for each of the objects that could possibly shade
smallest_angle_found = 2 * math.pi
key_point = None
for pt in IntersectionPoints:
if pt == None:
continue
# Protect against Zero-Length error
ray = ghc.Vector2Pt(ShadingOrigin, pt, False).vector
if ray.Length < 0.001:
continue
this_ray_angle = ghc.Angle(_phpp_window_obj.surface_normal , ray).angle
if this_ray_angle < 0.001:
continue
if this_ray_angle <= smallest_angle_found:
smallest_angle_found = this_ray_angle
key_point = pt
#-----------------------------------------------------------------------
# Use the 'key point' found to deliver the Height and Distance for the PHPP Shading Calculator
if not key_point:
d_over = None
o_over = None
CheckLine = VerticalLine
else:
d_over = key_point.Z - ShadingOrigin.Z # Vertical distance
Hypot = ghc.Length(ghc.Line(ShadingOrigin, key_point)) # Hypot
o_over = math.sqrt(Hypot**2 - d_over**2) # Horizontal distance
CheckLine = ghc.Line(ShadingOrigin, key_point)
return d_over, o_over, CheckLine
def find_horizon_shading(_phpp_window_obj, _shadingGeom, _extents=99):
"""
Arguments:
_phpp_winddow_obj: The PHPP_Window object to calcualte the values for
_shadingGeom: (list) A list of possible shading objects to test against
_extents: (float) A number (m) to limit the shading search to. Default = 99m
Returns:
h_hori: Distance (m) out from the glazing surface of any horizontal shading objects found
d_hori: Distance (m) up from the base of the window to the top of any horizontal shading objects found
"""
surface_normal = _phpp_window_obj.surface_normal
#-----------------------------------------------------------------------
# Find Starting Point
glazingEdges = _phpp_window_obj._get_edges_in_order( _phpp_window_obj.glazing_surface )
glazingBottomEdge = glazingEdges.Bottom
ShadingOrigin = ghc.CurveMiddle( from_linesegment3d(glazingBottomEdge) )
UpVector = ghc.VectorXYZ(0,0,1).vector
#-----------------------------------------------------------------------
# Find if there are any shading objects and if so put them in a list
HorizonShading = []
HorizontalLine = ghc.LineSDL(ShadingOrigin, surface_normal, _extents)
VerticalLine = ghc.LineSDL(ShadingOrigin, UpVector, _extents)
for shadingObj in _shadingGeom:
if ghc.BrepXCurve(shadingObj, HorizontalLine).points != None:
HorizonShading.append( shadingObj )
#-----------------------------------------------------------------------
# Find any intersection Curves with the shading objects
IntersectionSurface = ghc.SumSurface(HorizontalLine, VerticalLine)
IntersectionCurve = []
IntersectionPoints = []
for shadingObj in HorizonShading:
if ghc.BrepXBrep(shadingObj, IntersectionSurface).curves != None:
IntersectionCurve.append(ghc.BrepXBrep(shadingObj, IntersectionSurface))
for pnt in IntersectionCurve:
IntersectionPoints.append(ghc.ControlPoints(pnt).points)
#-----------------------------------------------------------------------
# Run the "Top-Corner-Finder" if there are any intersecting objects...
if len(IntersectionPoints) != 0:
# Find the top/closets point for each of the objects that could possibly shade
KeyPoints = []
for pnt in IntersectionPoints:
Rays = []
Angles = []
if pnt:
for k in range(len(pnt)):
Rays.append(ghc.Vector2Pt(ShadingOrigin,pnt[k], False).vector)
Angles.append(ghc.Angle(surface_normal , Rays[k]).angle)
KeyPoints.append(pnt[Angles.index(max(Angles))])
# Find the relevant highest / closest point
Rays = []
Angles = []
for i in range(len(KeyPoints)):
Rays.append(ghc.Vector2Pt(surface_normal, KeyPoints[i], False).vector)
Angles.append(ghc.Angle(surface_normal, Rays[i]).angle)
KeyPoint = KeyPoints[Angles.index(max(Angles))]
# Use the point it finds to deliver the Height and Distance for the PHPP Shading Calculator
h_hori = KeyPoint.Z - ShadingOrigin.Z #Vertical distance
Hypot = ghc.Length(ghc.Line(ShadingOrigin, KeyPoint))
d_hori = math.sqrt(Hypot**2 - h_hori**2)
CheckLine = ghc.Line(ShadingOrigin, KeyPoint)
else:
h_hori = None
d_hori = None
CheckLine = HorizontalLine
return h_hori, d_hori, CheckLine
def fractal(depth, x1, y1, z1, x2, y2, z2, length, anglerec, angle, lvariation,
aran, lran, anglerech, angleh, branches, verticality, gchance,
depthstart, radtolen, radchng, mngon, polygon, branch_cluster):
#test if depth>0
if depth:
#defining random angle variation and length variation
arn = random.uniform(-angle / 100 * aran, angle / 100 * aran)
lrn = random.uniform(-length / 100 * lran, length / 100 * lran)
if hrandom == True:
#defining horizontal rotation angles
ahor = random.sample(range(0, 360), branches)
#removing numbers within tolerance
ahr = rs.CullDuplicateNumbers(ahor, angleh)
#in a 360 fashion
if ahr[0] + 360 - angleh < ahr[-1]:
del ahr[0]
else:
#generating evenly distributed angles
ahr = range(0, 360 + 1, 360 // branches)[:-1]
#previous branch vector
vecst = rg.Point3d(x1, y1, z1)
vecend = rg.Point3d(x2, y2, z2)
movevec = ghc.Vector2Pt(vecst, vecend,
True)[0] #returns vector and it's length
#perpendicular vector
rotplane3 = ghc.PlaneNormal(
vecend, movevec) #creates plane perpendicular to vector
plns = ghc.DeconstructPlane(rotplane3) #origin, x, y, z
rotplane = ghc.ConstructPlane(
plns[2], plns[1], plns[3]
) #constructing new plane switching x and y planes to make perpendicular
#generating perpendicular vector
vecperp = ghc.Rotate(movevec, radians(90), rotplane)[0]
#generating vector amplitudes
leny = (length + lrn) * sin(
radians((anglerec + arn) * (1 - (verticality**depth))))
lenz = (length + lrn) * cos(radians(anglerec + arn))
ampy = ghc.Amplitude(vecperp, leny)
ampz = ghc.Amplitude(movevec, lenz)
#changing branch length dependant on branch depth
length = length * lvariation
#building points
endpoint1 = ghc.Move(
vecend, ampz)[0] #returns moved object and transformation data
endpoint = ghc.Move(
endpoint1, ampy)[0] #returns moved object and transformation data
#rotating point in a cone fashion
rotpoint = ghc.Rotate3D(
endpoint, radians(anglerech), vecend,
movevec)[0] #returns rotated geometry and transformation data
#building line between points
linegeo = rg.Line(vecend, rotpoint)
#defining recursion depth
key = depthstart + 1 - depth
#building geometry
pln = ghc.PlaneNormal(rotpoint,
linegeo) #returns a plane perp to a vector
radius = length * (radchng**(key)) / radtolen
#reduce details with each branch, but not less than 3
splits = 3 if mngon - key + 1 <= 3 else mngon - key + 1
polygonend = ghc.Polygon(pln, radius, splits,
0)[0] #returns a polygon and its perimeter
#aligning curves for loft creation
crvst = ghc.EndPoints(polygon)[0]
pntcld = ghc.Discontinuity(polygonend,
1) #returns points and point parameters
#finind seam point
closest_point = ghc.ClosestPoint(
crvst, pntcld[0]
) #returns closest point, closest point index, distance between closest points
seampnt = pntcld[1][closest_point[1]]
polygonend = ghc.Seam(polygonend, seampnt)
lcurves = [polygon, polygonend]
#building geometry
geo = ghc.ExtrudePoint(
polygon, rotpoint
) if depth == 1 and splits == 3 else rg.Brep.CreateFromLoft(
lcurves, rg.Point3d.Unset, rg.Point3d.Unset, rg.LoftType.Normal,
False)[0] #if last branch than make a pyramid
#make solid
geocapped = ghc.CapHoles(geo)
#building a dict of geo with depth as key, and geo as values
pgons.update(
{branch_cluster: [geocapped]}) if branch_cluster not in pgons.keys(
) else pgons[branch_cluster].append(geocapped)
branchesout.append(geocapped)
#setting coords for next branch
x1 = x2
y1 = y2
z1 = z2
#getting xyz from rotated point
x2 = rg.Point3d(rotpoint)[0]
y2 = rg.Point3d(rotpoint)[1]
z2 = rg.Point3d(rotpoint)[2]
#setting base polygon for next branch
polygon = polygonend
#filling dict with branch clusters
cluster.append(cluster[-1] + 1)
branch_cluster = cluster[-1]
#calling function with different angle parameter for branch splitting, calling as many branches as spread within tolerance
if depth != 1:
for aa in ahr:
if (
(random.randint(40, 99) / 100)**depth
) < gchance or depth == depthstart + 1: #or added to prevent blank trees
fractal(depth - 1, x1, y1, z1, x2, y2, z2, length, angle,
angle, lvariation, aran, lran, aa, angleh,
branches, verticality, gchance, depthstart,
radtolen, radchng, mngon, polygon, branch_cluster)
#leaf logic
if depth <= leavesdepth and leavesperbranch > 0 and maxleaves > 0:
#vector for leaf growth spread
leafpntvec = ghc.Vector2Pt(vecend, rotpoint, True)[0]
#setting leaf growth position on last barnch, leafpnt list
lastbranchlength = ghc.Length(linegeo)
leaves_list = [lastbranchlength]
[
leaves_list.append(lengthparam)
for lengthparam in random.sample(
range(0, int(lastbranchlength)), leavesperbranch - 1)
] if leavesperbranch > 1 else None
for leafpnt in leaves_list:
leafamp = ghc.Amplitude(leafpntvec, leafpnt)
leafpoint = ghc.Move(vecend, leafamp)[0]
#plane for leaf generation
linetocenter = ghc.Line(stpntbase, leafpoint)
planetocenter = ghc.PlaneNormal(leafpoint, linetocenter)
#create an imaginary circle with leaflen radius and populate it with points for random leaf generation
leafgenerationcircle = ghc.CircleCNR(leafpoint, linetocenter,
leaflen)
circlesurf = ghc.BoundarySurfaces(leafgenerationcircle)
leafcnt = random.randint(0, maxleaves)
if leafcnt > 0:
leafendpnts = ghc.PopulateGeometry(circlesurf, leafcnt,
random.randint(1, 500))
def leafgenerator(point):
#random z move
zmove = rg.Vector3d(0, 0, 1)
moveamp = random.uniform(-leaflen / 3, leaflen / 5)
ampzmove = ghc.Amplitude(zmove, moveamp)
llendpnt = ghc.Move(point, ampzmove)[0]
#setting a leaf centerline vector
leafvector = ghc.Vector2Pt(leafpoint, llendpnt,
True)[0]
#defining leaf center point as avarage of st and end pnts
midpnt = ghc.Average([leafpoint, llendpnt])
#generating perpendicular vector
vecperpleaf = ghc.Rotate(leafvector, radians(90),
planetocenter)[0]
leafperpamp = ghc.Amplitude(
vecperpleaf,
random.uniform((leafwidth / 2) / 5 * 4,
(leafwidth / 2) / 5 * 6))
#moving mid point to both sides
midpnt1 = ghc.Move(midpnt, leafperpamp)[0]
midpnt2 = ghc.Move(midpnt, -leafperpamp)[0]
#leaf geo
leafgeo = rg.NurbsSurface.CreateFromCorners(
leafpoint, midpnt1, llendpnt, midpnt2)
leaves.append(leafgeo)
#iterate over random number of generated points if list, else generate for one point
[leafgenerator(pp) for pp in leafendpnts] if isinstance(
leafendpnts, list) else leafgenerator(leafendpnts)