def findAcceptableRegion(start, end, siteAcceptableRegion,
MinWorkRadiu, MaxWorkRadiu, center):
extend = MaxWorkRadiu * 0.2
tang_vector = start.vectorTo(end)
length = np.sqrt(tang_vector[0]**2 + tang_vector[1]**2)
ux, uy = tang_vector[0] / length, tang_vector[1] / length
# compute the normalized perpendicular vector
vx, vy = -uy, ux
# adjust the direction pointed to feasible region
dir_vector = center.vectorTo(end)
dir_sign = dir_vector[0] * vx + dir_vector[1] * vy
if dir_sign < 0:
vx, vy = -vx, -vy
MaxWorkRadiu = MaxWorkRadiu * 0.8
p1 = Point(start.X + vx * MaxWorkRadiu - ux * extend,
start.Y + vy * MaxWorkRadiu - uy * extend, 0)
p2 = Point(end.X + vx * MaxWorkRadiu + ux * extend,
end.Y + vy * MaxWorkRadiu + uy * extend, 0)
p3 = Point(end.X + vx * MinWorkRadiu + ux * extend,
end.Y + vy * MinWorkRadiu + uy * extend, 0)
p4 = Point(start.X + vx * MinWorkRadiu - ux * extend,
start.Y + vy * MinWorkRadiu - uy * extend, 0)
region = Polygon([(p1.X, p1.Y), (p2.X, p2.Y), (p3.X, p3.Y),
(p4.X, p4.Y)])
Region = region.intersection(siteAcceptableRegion)
return Region
def __ParseBeam(self, beam):
"""Parses info from Revit analytical beam into internal AnalyticalBeam structure"""
aBeam = AnalyticalBeam()
rmp = RevitModelParser
id = beam[rmp.__TagId]
if id:
aBeam.Id = id
aBeam.StartPoint = Point(beam[rmp.__TagStartPoint][0] / rmp.__in2ft,
beam[rmp.__TagStartPoint][1] / rmp.__in2ft,
beam[rmp.__TagStartPoint][2] / rmp.__in2ft)
aBeam.EndPoint = Point(beam[rmp.__TagEndPoint][0] / rmp.__in2ft,
beam[rmp.__TagEndPoint][1] / rmp.__in2ft,
beam[rmp.__TagEndPoint][2] / rmp.__in2ft)
aBeam.CenterPoint = Point(
(aBeam.StartPoint.X + aBeam.EndPoint.X) / 2.0,
(aBeam.StartPoint.Y + aBeam.EndPoint.Y) / 2.0,
(aBeam.StartPoint.Z + aBeam.EndPoint.Z) / 2.0)
aBeam.Length = float(beam[rmp.__TagLength]) / rmp.__in2ft
aBeam.WeightPerLf = float(beam[rmp.__TagWeightPerLf])
aBeam.Weight = aBeam.Length * aBeam.WeightPerLf
aBeam.Depth = beam[rmp.__TagDepth] / rmp.__in2ft
aBeam.MemberProductionProcedure = beam[rmp.__TagAnnotations][
rmp.__TagMemberProductionProcedure]
aBeam.RolledShapes = beam[rmp.__TagAnnotations][rmp.__TagRolledShapes]
aBeam.TopFlangeThickness = beam[
rmp.__TagTopFlangeThickness] / rmp.__in2ft
aBeam.CutLength = beam[rmp.__TagCutLength]
return aBeam
def __ParseCol(self, column):
"""Parses info from Revit analytical column into internal AnalyticalColumn structure"""
aCol = AnalyticalColumn()
rmp = RevitModelParser
id = column[rmp.__TagId]
if id:
aCol.Id = id
aCol.BasePoint = Point(column[rmp.__TagBasePoint][0] / rmp.__in2ft,
column[rmp.__TagBasePoint][1] / rmp.__in2ft,
column[rmp.__TagBasePoint][2] / rmp.__in2ft)
aCol.TopPoint = Point(column[rmp.__TagTopPoint][0] / rmp.__in2ft,
column[rmp.__TagTopPoint][1] / rmp.__in2ft,
column[rmp.__TagTopPoint][2] / rmp.__in2ft)
aCol.CenterPoint = Point((aCol.BasePoint.X + aCol.TopPoint.X) / 2.0,
(aCol.BasePoint.Y + aCol.TopPoint.Y) / 2.0,
(aCol.BasePoint.Z + aCol.TopPoint.Z) / 2.0)
aCol.Length = float(column[rmp.__TagLength]) / rmp.__in2ft
aCol.WeightPerLf = float(column[rmp.__TagWeightPerLf])
aCol.Weight = aCol.Length * aCol.WeightPerLf
aCol.Depth = column[rmp.__TagDepth] / rmp.__in2ft
aCol.MemberProductionProcedure = column[rmp.__TagAnnotations][
rmp.__TagMemberProductionProcedure]
aCol.RolledShapes = column[rmp.__TagAnnotations][rmp.__TagRolledShapes]
aCol.TopFlangeThickness = column[
rmp.__TagTopFlangeThickness] / rmp.__in2ft
return aCol
def __ParseCol(self, column):
"""Parses info from Tekla analytical column into internal AnalyticalColumn structure"""
aCol = AnalyticalColumn()
id = column[TeklaModelParser.__TagId]
if id:
aCol.Id = id
aCol.BasePoint = Point(column[TeklaModelParser.__TagBasePoint][0],
column[TeklaModelParser.__TagBasePoint][1],
column[TeklaModelParser.__TagBasePoint][2])
aCol.TopPoint = Point(column[TeklaModelParser.__TagTopPoint][0],
column[TeklaModelParser.__TagTopPoint][1],
column[TeklaModelParser.__TagTopPoint][2])
aCol.CenterPoint = Point((aCol.BasePoint.X + aCol.TopPoint.X) / 2.0,
(aCol.BasePoint.Y + aCol.TopPoint.Y) / 2.0,
(aCol.BasePoint.Z + aCol.TopPoint.Z) / 2.0)
aCol.Length = float(column[TeklaModelParser.__TagLength])
aCol.WeightPerLf = float(column[TeklaModelParser.__TagWeightPerLf])
aCol.Weight = aCol.Length * aCol.WeightPerLf
return aCol
def __ParseBeam(self, beam):
"""Parses info from Tekla analytical beam into internal AnalyticalBeam structure"""
aBeam = AnalyticalBeam()
id = beam[TeklaModelParser.__TagId]
if id:
aBeam.Id = id
aBeam.StartPoint = Point(beam[TeklaModelParser.__TagStartPoint][0],
beam[TeklaModelParser.__TagStartPoint][1],
beam[TeklaModelParser.__TagStartPoint][2])
aBeam.EndPoint = Point(beam[TeklaModelParser.__TagEndPoint][0],
beam[TeklaModelParser.__TagEndPoint][1],
beam[TeklaModelParser.__TagEndPoint][2])
aBeam.CenterPoint = Point(
(aBeam.StartPoint.X + aBeam.EndPoint.X) / 2.0,
(aBeam.StartPoint.Y + aBeam.EndPoint.Y) / 2.0,
(aBeam.StartPoint.Z + aBeam.EndPoint.Z) / 2.0)
aBeam.Length = float(beam[TeklaModelParser.__TagLength])
aBeam.WeightPerLf = float(beam[TeklaModelParser.__TagWeightPerLf])
aBeam.Weight = aBeam.Length * aBeam.WeightPerLf
return aBeam
def findAcceptableRegion(start, end, center):
extension_factor = 100
tang_vector = start.vectorTo(end)
p1 = Point(start.X + tang_vector[0] * extension_factor,
start.Y + tang_vector[1] * extension_factor, 0)
p2 = Point(end.X - tang_vector[0] * extension_factor,
end.Y - tang_vector[1] * extension_factor, 0)
radius_vector = center.vectorTo(
Point((start.X + end.X) / 2, (start.Y + end.Y) / 2, 0))
p3 = Point(p2.X + radius_vector[0] * extension_factor,
p2.Y + radius_vector[1] * extension_factor, 0)
p4 = Point(p1.X + radius_vector[0] * extension_factor,
p1.Y + radius_vector[1] * extension_factor, 0)
region = Polygon([(p1.X, p1.Y), (p2.X, p2.Y), (p3.X, p3.Y),
(p4.X, p4.Y)])
return region
def PointFromArray(pointJSON):
"""Loads point structure from JSON array"""
x = 0.0
y = 0.0
z = 0.0
if len(pointJSON) > 0:
x = pointJSON[0]
if len(pointJSON) > 1:
y = pointJSON[1]
if len(pointJSON) > 2:
z = pointJSON[2]
return Point(x, y, z)
def __ParseBoundaries(self, placement):
""" Parses boundaries from points """
rmp = RevitModelParser
polygon = []
points = placement[rmp.__TagPoints]
for point in points:
polygon.append(
Point(point[rmp.__TagCorner][0] / rmp.__in2ft,
point[rmp.__TagCorner][1] / rmp.__in2ft,
point[rmp.__TagCorner][2] / rmp.__in2ft))
return polygon
def PointFromXYZ(pointJSON):
"""Loads point structure from XYZ JSON structure"""
ump = UtilsModelParse
x = 0.0
y = 0.0
z = 0.0
x = ump.GetCheckExist(pointJSON, ump.__KeyPointX, 0.0)
if x == 0.0:
x = ump.GetCheckExist(pointJSON, ump.__KeyPointx, 0.0)
y = ump.GetCheckExist(pointJSON, ump.__KeyPointY, 0.0)
if y == 0.0:
y = ump.GetCheckExist(pointJSON, ump.__KeyPointy, 0.0)
z = ump.GetCheckExist(pointJSON, ump.__KeyPointZ, 0.0)
if z == 0.0:
z = ump.GetCheckExist(pointJSON, ump.__KeyPointz, 0.0)
return Point(x, y, z)
def getSupplyPointAndAcceptableLocation(siteAcceptableRegion, Panels,
clusterName, MinWorkRadiu,
MaxWorkRadiu):
import numpy as np
from BLGeometry.PrefabGeometry import Point
from shapely.geometry import Polygon
# return a sudo half-space
def findAcceptableRegion(start, end, siteAcceptableRegion,
MinWorkRadiu, MaxWorkRadiu, center):
extend = MaxWorkRadiu * 0.2
tang_vector = start.vectorTo(end)
length = np.sqrt(tang_vector[0]**2 + tang_vector[1]**2)
ux, uy = tang_vector[0] / length, tang_vector[1] / length
# compute the normalized perpendicular vector
vx, vy = -uy, ux
# adjust the direction pointed to feasible region
dir_vector = center.vectorTo(end)
dir_sign = dir_vector[0] * vx + dir_vector[1] * vy
if dir_sign < 0:
vx, vy = -vx, -vy
MaxWorkRadiu = MaxWorkRadiu * 0.8
p1 = Point(start.X + vx * MaxWorkRadiu - ux * extend,
start.Y + vy * MaxWorkRadiu - uy * extend, 0)
p2 = Point(end.X + vx * MaxWorkRadiu + ux * extend,
end.Y + vy * MaxWorkRadiu + uy * extend, 0)
p3 = Point(end.X + vx * MinWorkRadiu + ux * extend,
end.Y + vy * MinWorkRadiu + uy * extend, 0)
p4 = Point(start.X + vx * MinWorkRadiu - ux * extend,
start.Y + vy * MinWorkRadiu - uy * extend, 0)
region = Polygon([(p1.X, p1.Y), (p2.X, p2.Y), (p3.X, p3.Y),
(p4.X, p4.Y)])
Region = region.intersection(siteAcceptableRegion)
return Region
def plotAcceptableRegion(poly, index):
from matplotlib import pyplot as plt
fig_index = 10 + index
fig = plt.figure(fig_index, figsize=(5, 5), dpi=90)
x, y = poly.exterior.xy
plt.plot(x,
y,
color='#6699cc',
alpha=0.7,
linewidth=3,
solid_capstyle='round',
zorder=2)
plt.fill(x, y, 'g')
plt.xlabel('X')
plt.ylabel('Y')
fig_title = 'feasible region for Wall' + str(index)
plt.title(fig_title)
title_name = str(fig_index) + ".png"
plt.savefig(title_name)
#siteAcceptableRegion=Data.AcceptableRegionForCrane
RawSupplyPoints = []
group_start = []
group_end = []
for i in range(len(clusterName)):
maxX = max([Panels[p].CenterPoint.X for p in clusterName[i]])
maxY = max([Panels[p].CenterPoint.Y for p in clusterName[i]])
minX = min([Panels[p].CenterPoint.X for p in clusterName[i]])
minY = min([Panels[p].CenterPoint.Y for p in clusterName[i]])
x = (maxX + minX) / 2.0
y = (maxY + minY) / 2.0
RawSupplyPoints.append(Point(x, y, 0))
group_start.append(Point(minX, minY, 0))
group_end.append(Point(maxX, maxY, 0))
center_x = np.mean([s.X for s in RawSupplyPoints])
center_y = np.mean([s.Y for s in RawSupplyPoints])
center = Point(center_x, center_y, 0)
# reorder the supply location clockwise
acceptableRegionForEachCraneStop = []
for i in range(len(RawSupplyPoints)):
acceptableRegion = findAcceptableRegion(group_start[i],
group_end[i],
siteAcceptableRegion,
MinWorkRadiu, MaxWorkRadiu,
center)
acceptableRegionForEachCraneStop.append(acceptableRegion)
plotAcceptableRegion(acceptableRegionForEachCraneStop[i], i)
return RawSupplyPoints, acceptableRegionForEachCraneStop
def getTheSupplyLocationOrder(Data, Wall):
import numpy as np
from BLGeometry.PrefabGeometry import Point
from shapely.geometry import Polygon
G = Data.Dependencies
SupplyPosition = Data.SupplyPoints
clusterNames = Data.ClusterNames
siteAcceptableRegion = Data.AcceptableRegionForCrane
def length(v):
return np.sqrt(v[0]**2 + v[1]**2)
def dot_product(v, w):
return v[0] * w[0] + v[1] * w[1]
def determinant(v, w):
return v[0] * w[1] - v[1] * w[0]
def inner_angle(v, w):
cosx = dot_product(v, w) / (length(v) * length(w)) * 0.99999
rad = np.arccos(cosx) # in radians
return rad # returns degrees
def angle_clockwise(A, B):
inner = inner_angle(A, B)
det = determinant(A, B)
if det < 0: #this is a property of the det. If the det < 0 then B is clockwise of A
return inner
else: # if the det > 0 then A is immediately clockwise of B
return 2 * np.pi - inner
""" This function will assign the stop order according to the corresponding
the maximum dependency set size """
newSupplyPosition = []
newClusterNames = {}
maxDependencyInClusters = dict()
# get the maximum dependency set size in each cluster
nodes = set([k for k, v in G.in_degree().items()])
for cn in clusterNames.keys():
cnodes = [n for n in nodes if n in clusterNames[cn]]
maxDependencySetSize = max([
G.node[k][ConstructionOrdering.kAttrNameNodeDependentSetSize]
for k in cnodes
])
maxDependencyInClusters[cn] = maxDependencySetSize
# start point is the one with the largest dependency set
start_index = max(maxDependencyInClusters.keys(),
key=lambda k: maxDependencyInClusters[k])
center_x = np.mean([s.X for s in SupplyPosition])
center_y = np.mean([s.Y for s in SupplyPosition])
center = Point(center_x, center_y, 0)
Angles = []
for i in range(len(SupplyPosition)):
v1 = center.vectorTo(SupplyPosition[start_index])
v2 = center.vectorTo(SupplyPosition[i])
Angles.append(angle_clockwise(v1, v2))
Wall_start = [Wall[i].StartPoint for i in Wall.keys()]
Wall_end = [Wall[i].EndPoint for i in Wall.keys()]
# return a sudo half-space
def findAcceptableRegion(start, end, center):
extension_factor = 100
tang_vector = start.vectorTo(end)
p1 = Point(start.X + tang_vector[0] * extension_factor,
start.Y + tang_vector[1] * extension_factor, 0)
p2 = Point(end.X - tang_vector[0] * extension_factor,
end.Y - tang_vector[1] * extension_factor, 0)
radius_vector = center.vectorTo(
Point((start.X + end.X) / 2, (start.Y + end.Y) / 2, 0))
p3 = Point(p2.X + radius_vector[0] * extension_factor,
p2.Y + radius_vector[1] * extension_factor, 0)
p4 = Point(p1.X + radius_vector[0] * extension_factor,
p1.Y + radius_vector[1] * extension_factor, 0)
region = Polygon([(p1.X, p1.Y), (p2.X, p2.Y), (p3.X, p3.Y),
(p4.X, p4.Y)])
return region
def plotAcceptableRegion(poly, index):
from matplotlib import pyplot as plt
fig_index = 10 + index
fig = plt.figure(fig_index, figsize=(5, 5), dpi=90)
x, y = poly.exterior.xy
plt.plot(x,
y,
color='#6699cc',
alpha=0.7,
linewidth=3,
solid_capstyle='round',
zorder=2)
plt.fill(x, y, 'g')
plt.xlabel('X')
plt.ylabel('Y')
fig_title = 'feasible region for Wall' + str(index)
plt.title(fig_title)
title_name = str(fig_index) + ".png"
plt.savefig(title_name)
# reorder the supply location clockwise
acceptableRegionForEachCraneStop = []
for i in range(len(SupplyPosition)):
index = min(range(len(Angles)), key=lambda k: Angles[k])
Angles[index] = 10000
newSupplyPosition.append(SupplyPosition[index])
newClusterNames[i] = clusterNames[index]
acceptableRegion = findAcceptableRegion(Wall_start[index],
Wall_end[index], center)
acceptableRegion = acceptableRegion.intersection(
siteAcceptableRegion)
acceptableRegionForEachCraneStop.append(acceptableRegion)
plotAcceptableRegion(acceptableRegionForEachCraneStop[i], i)
return acceptableRegionForEachCraneStop, newSupplyPosition, newClusterNames
def __ParseWall(self, curtainWall):
"""Parses info from Revit analytical curtain wall into internal AnalyticalCurtainWall structure"""
rmp = RevitModelParser
wall = AnalyticalCurtainWall()
wall.Id = curtainWall[rmp.__TagId]
wall.StartPoint = Point(
curtainWall[rmp.__TagStartPoint][0] / rmp.__in2ft,
curtainWall[rmp.__TagStartPoint][1] / rmp.__in2ft,
curtainWall[rmp.__TagStartPoint][2] / rmp.__in2ft)
wall.EndPoint = Point(curtainWall[rmp.__TagEndPoint][0] / rmp.__in2ft,
curtainWall[rmp.__TagEndPoint][1] / rmp.__in2ft,
curtainWall[rmp.__TagEndPoint][2] / rmp.__in2ft)
wall.Height = float(curtainWall[rmp.__TagHeight]) / rmp.__in2ft
mullions = curtainWall[rmp.__TagMullions]
for mullion in mullions:
m = AnalyticalMullion()
m.Id = mullion[rmp.__TagId]
m.StartPoint = Point(mullion[rmp.__TagStartPoint][0] / rmp.__in2ft,
mullion[rmp.__TagStartPoint][1] / rmp.__in2ft,
mullion[rmp.__TagStartPoint][2] / rmp.__in2ft)
m.EndPoint = Point(mullion[rmp.__TagEndPoint][0] / rmp.__in2ft,
mullion[rmp.__TagEndPoint][1] / rmp.__in2ft,
mullion[rmp.__TagEndPoint][2] / rmp.__in2ft)
m.Width = mullion[rmp.__TagWidth]
m.Thickness = mullion[rmp.__TagThickness]
wall.AddMullion(m)
panels = curtainWall[rmp.__TagPanels]
for panel in panels:
corners = panel[rmp.__TagCorners]
cornersCount = len(corners)
if cornersCount == 0:
continue
p = AnalyticalPanel()
p.Id = panel[rmp.__TagId]
p.Thickness = panel[rmp.__TagThickness]
for corner in corners:
c = Point(corner[rmp.__TagCorner][0] / rmp.__in2ft,
corner[rmp.__TagCorner][1] / rmp.__in2ft,
corner[rmp.__TagCorner][2] / rmp.__in2ft)
p.AddCorner(c)
panelCorners = p.GetCorners()
# Find centroid
p.CenterPoint = Point(
sum([c.X for c in panelCorners]) / cornersCount,
sum([c.Y for c in panelCorners]) / cornersCount,
sum([c.Z for c in panelCorners]) / cornersCount)
# Get Start and End Points
basePoint1 = max(panelCorners, key=lambda p: p.Z)
basePoint2 = basePoint1
for pnt in panelCorners:
if pnt.Z < basePoint1.Z:
basePoint1, basePoint2 = pnt, basePoint1
elif pnt.Z < basePoint2.Z:
basePoint2 = pnt
if (self.__GetDistance(wall.StartPoint, basePoint1) <
self.__GetDistance(wall.StartPoint, basePoint2)):
p.StartPoint = basePoint1
p.EndPoint = basePoint2
else:
p.StartPoint = basePoint2
p.EndPoint = basePoint1
p.Length = self.__GetDistance(p.EndPoint, p.StartPoint)
p.Weight = p.Length * 10 # ToDo: get real weight
wall.AddPanel(p)
return wall