def test_difference_3D_polys_multi():
# type: () -> None
"""Test for difference_3D_polys with two overlapping regions
This has two shapes in the horizontal plane which overlap in two places.
Fails if the overlapping shapes are not returned as a new polygons.
"""
# surface is already a flat plane with z == 0
s1 = Polygon3D([(0,0,0), (5,0,0), (5,2,0), (0,2,0)]) # counterclockwise
s2 = Polygon3D([(1,1,0), (2,1,0), (2,2,0), (3,2,0),
(3,1,0), (4,1,0), (4,3,0), (1,3,0)]) # counterclockwise
ex_s1 = [Polygon3D([(0,0,0), (5,0,0), (5,2,0), (4,2,0), (4,1,0), (3,1,0),
(3,2,0), (2,2,0), (2,1,0), (1,1,0), (1,2,0), (0,2,0)])]
ex_s2 = [Polygon3D([(1,2,0), (4,2,0), (4,3,0), (1,3,0)])]
expected = [ex_s1, ex_s2]
result = [s1.difference(s2), s2.difference(s1)]
for res, exp in zip(result, expected):
assert len(res) == len(exp)
for r, e in zip(res, exp):
assert r == e
assert s1.difference(s2) == ex_s1
assert s2.difference(s1) == ex_s2
def test_surface_is_clockwise():
# type: () -> None
"""Test if a surface is clockwise as seen from a given point.
"""
poly = Polygon3D(
reversed(
[
Vector3D(0.0, 0.0, 0.0),
Vector3D(1.0, 0.0, 0.0),
Vector3D(1.0, 1.0, 0.0),
Vector3D(0.0, 1.0, 0.0),
]
)
)
poly_inv = Polygon3D(
[
Vector3D(0.0, 0.0, 0.0),
Vector3D(1.0, 0.0, 0.0),
Vector3D(1.0, 1.0, 0.0),
Vector3D(0.0, 1.0, 0.0),
]
)
pt = Vector3D(0.5, 0.5, 1.0) # point above the plane
assert poly.is_clockwise(pt)
assert not poly_inv.is_clockwise(pt)
def test_surface_normal():
# type: () -> None
poly = Polygon3D([Vector3D(0.0, 0.0, 0.0),
Vector3D(1.0, 0.0, 0.0),
Vector3D(1.0, 1.0, 0.0),
Vector3D(0.0, 1.0, 0.0)])
assert list(poly.normal_vector) == [0.0, 0.0, 1.0] # for a horizontal surface
poly = Polygon3D(reversed([Vector3D(0.0, 0.0, 0.0),
Vector3D(1.0, 0.0, 0.0),
Vector3D(1.0, 1.0, 0.0),
Vector3D(0.0, 1.0, 0.0)]))
assert list(poly.normal_vector) == [0.0, 0.0, -1.0] # for a horizontal surface
poly = Polygon3D([Vector3D(0.0, 0.0, 0.0),
Vector3D(2.0, 1.0, 0.0),
Vector3D(4.0, 0.0, 0.0),
Vector3D(4.0, 3.0, 0.0),
Vector3D(2.0, 2.0, 0.0),
Vector3D(0.0, 3.0, 0.0)])
assert list(poly.normal_vector) == [0.0, 0.0, 1.0] # for a horizontal surface
poly = Polygon3D(reversed([Vector3D(0.0, 0.0, 0.0),
Vector3D(2.0, 1.0, 0.0),
Vector3D(4.0, 0.0, 0.0),
Vector3D(4.0, 3.0, 0.0),
Vector3D(2.0, 2.0, 0.0),
Vector3D(0.0, 3.0, 0.0)]))
assert list(poly.normal_vector) == [0.0, 0.0, -1.0] # for a horizontal surface
poly = Polygon3D([[ 1., 1.1, 0.5],
[ 1., 1.1, 0.],
[ 1., 2.1, 0.],
[ 1., 2.1, 0.5]])
assert list(poly.normal_vector) == [1.0, 0.0, 0.0] # for a horizontal surface
def test_difference_3D_polys_single():
# type: () -> None
"""Simplest test for difference_3D_polys
This has two squares in the horizontal plane which overlap in one place.
Fails if the two original polygons do not have the intersection removed.
"""
# surface is already a flat plane with z == 0
s1 = Polygon3D([(0, 2, 0), (2, 2, 0), (2, 0, 0), (0, 0, 0)]) # clockwise
s2 = Polygon3D([(1, 3, 0), (3, 3, 0), (3, 1, 0), (1, 1, 0)]) # clockwise
# clockwise
ex_s1 = [
Polygon3D([(0, 2, 0), (1, 2, 0), (1, 1, 0), (2, 1, 0), (2, 0, 0),
(0, 0, 0)])
]
ex_s2 = [
Polygon3D([(1, 3, 0), (3, 3, 0), (3, 1, 0), (2, 1, 0), (2, 2, 0),
(1, 2, 0)])
]
expected = [ex_s1, ex_s2]
result = [s1.difference(s2), s2.difference(s1)]
assert result[0] == expected[0]
assert result[1] == expected[1]
def test_order_points():
# type: () -> None
polygon = Polygon3D([(0, 0, 0), (0, 1, 1), (1, 1, 1), (1, 0, 0)])
starting_position = "upperleftcorner"
expected = Polygon3D([(1, 1, 1), (1, 0, 0), (0, 0, 0), (0, 1, 1)])
result = polygon.order_points(starting_position)
assert result == expected
assert result[0] == expected[0]
starting_position = "lowerleftcorner"
expected = Polygon3D([(1, 0, 0), (0, 0, 0), (0, 1, 1), (1, 1, 1)])
result = polygon.order_points(starting_position)
assert result == expected
assert result[0] == expected[0]
starting_position = "lowerrightcorner"
expected = Polygon3D([(0, 0, 0), (0, 1, 1), (1, 1, 1), (1, 0, 0)])
result = polygon.order_points(starting_position)
assert result == expected
assert result[0] == expected[0]
starting_position = "upperrightcorner"
expected = Polygon3D([(0, 1, 1), (1, 1, 1), (1, 0, 0), (0, 0, 0)])
result = polygon.order_points(starting_position)
assert result == expected
assert result[0] == expected[0]
def test_union_3D_polys_single():
# type: () -> None
"""Simplest test for union_3D_polys
This has two squares in the horizontal plane which overlap in one place.
Fails if the expected union shape is not returned.
"""
# surface is already a flat plane with z == 0
s1 = Polygon3D([(0, 2, 0), (2, 2, 0), (2, 0, 0), (0, 0, 0)]) # clockwise
s2 = Polygon3D([(1, 3, 0), (3, 3, 0), (3, 1, 0), (1, 1, 0)]) # clockwise
expected = [
Polygon3D([
(0, 0, 0),
(0, 2, 0),
(1, 2, 0),
(1, 3, 0),
(3, 3, 0),
(3, 1, 0),
(2, 1, 0),
(2, 0, 0),
])
] # clockwise
result = s1.union(s2)
for res, exp in zip(result, expected):
assert res == exp
result = s2.union(s1)
for res, exp in zip(result, expected):
assert res == exp
def avg(zone: eppy.bunch_subclass.EpBunch):
"""calculate the zone centroid coordinates"""
x_, y_, z_, dem = 0, 0, 0, 0
from geomeppy.geom.polygons import Polygon3D, Vector3D
from geomeppy.recipes import translate_coords
ggr = zone.theidf.idfobjects["GLOBALGEOMETRYRULES"][0]
for surface in zone.zonesurfaces:
if surface.key.upper() in ["INTERNALMASS", "WINDOWSHADINGCONTROL"]:
pass
else:
dem += 1 # Counter for average calc at return
if ggr.Coordinate_System.lower() == "relative":
# add zone origin to surface coordinates and create
# Polygon3D from updated coords.
zone = zone.theidf.getobject("ZONE", surface.Zone_Name)
poly3d = Polygon3D(surface.coords)
origin = (zone.X_Origin, zone.Y_Origin, zone.Z_Origin)
coords = translate_coords(poly3d, Vector3D(*origin))
poly3d = Polygon3D(coords)
else:
# Polygon3D from surface coords
poly3d = Polygon3D(surface.coords)
x, y, z = poly3d.centroid
x_ += x
y_ += y
z_ += z
return x_ / dem, y_ / dem, z_ / dem
def populate_adjacencies(adjacencies, s1, s2):
# type: (defaultdict, EpBunch, EpBunch) -> defaultdict
"""Update the adjacencies dict with any intersections between two surfaces.
:param adjacencies: Dict to contain lists of adjacent surfaces.
:param s1: Object representing an EnergyPlus surface.
:param s2: Object representing an EnergyPlus surface.
:returns: An updated dict of adjacencies.
"""
poly1 = Polygon3D(s1.coords)
poly2 = Polygon3D(s2.coords)
if not almostequal(abs(poly1.distance), abs(poly2.distance), 4):
return adjacencies
if not almostequal(poly1.normal_vector, poly2.normal_vector, 4):
if not almostequal(poly1.normal_vector, -poly2.normal_vector, 4):
return adjacencies
intersection = poly1.intersect(poly2)
if intersection:
new_surfaces = intersect(poly1, poly2)
new_s1 = [
s for s in new_surfaces
if almostequal(s.normal_vector, poly1.normal_vector, 4)
]
new_s2 = [
s for s in new_surfaces
if almostequal(s.normal_vector, poly2.normal_vector, 4)
]
adjacencies[(s1.key, s1.Name)] += new_s1
adjacencies[(s2.key, s2.Name)] += new_s2
return adjacencies
def test_intersect_no_overlap():
# type: () -> None
# surfaces don't overlap
s1 = Polygon3D([(0, 2, 0), (2, 2, 0), (2, 0, 0), (0, 0, 0)]) # clockwise
s2 = Polygon3D([(2, 3, 0), (3, 3, 0), (3, 1, 0), (2, 1, 0)]) # clockwise
expected = [] # clockwise
result = s1.intersect(s2)
assert result == expected
def populate_adjacencies(s1, s2):
poly1 = Polygon3D(s1.coords)
poly2 = Polygon3D(s2.coords)
if almostequal(abs(poly1.distance), abs(poly2.distance), 3):
if almostequal(poly1.normal_vector,
poly2.normal_vector, 3) or almostequal(
poly1.normal_vector, -poly2.normal_vector, 3):
return True
def test_scale_idf(self, base_idf):
# type: (IDF) -> None
idf1 = base_idf
idf2 = IDF()
idf2.initreadtxt(idf1.idfstr())
idf1.scale(10)
idf1.scale(0.1)
floor1 = Polygon3D(idf1.getsurfaces("floor")[0].coords).normalize_coords(None)
floor2 = Polygon3D(idf2.getsurfaces("floor")[0].coords).normalize_coords(None)
assert almostequal(floor1, floor2)
def test_intersect():
# type: () -> None
poly1 = Polygon3D([(1.0, 2.1, 0.5), (1.0, 2.1, 0.0), (2.0, 2.0, 0.0),
(2.0, 2.0, 0.5)])
poly2 = Polygon3D([(2.5, 1.95, 0.5), (2.5, 1.95, 0.0), (1.5, 2.05, 0.0),
(1.5, 2.05, 0.5)])
intersection = poly1.intersect(poly2)[0]
# view_polygons({'blue': [poly1, poly2], 'red': [intersect]})
assert not is_hole(poly1, intersection)
assert not is_hole(poly2, intersection)
def test_intersect_3D_polys_angled():
# type: () -> None
s1 = Polygon3D([(2.5,1.95,0.5), (2.5,1.95,0), (1.5,2.05,0), (1.5,2.05,0.5)]) # clockwise
s2 = Polygon3D([(1,2.1,0.5), (1,2.1,0), (2,2,0), (2,2,0.5)]) # clockwise
expected = [Polygon3D([(2.0, 2.0, 0.0), (1.5, 2.05, 0.0),
(1.5, 2.05, 0.5),(2.0, 2.0, 0.5)])]
result = s1.intersect(s2)
assert result == expected
def test_three_overlapping(self):
# type: () -> None
"""
__ ___ __ __
| 1| 1 | 3| 3|
|__|_2_|_2|__|
__ ___ __ __
| 1| 2 | 4| 6|
|__|_3_|_5|__|
"""
poly1 = Polygon3D([(0, 1, 0), (0, 0, 0), (2, 0, 0), (2, 1, 0)])
poly2 = Polygon3D([(3, 1, 0), (3, 0, 0), (1, 0, 0), (1, 1, 0)])
poly3 = Polygon3D([(2, 1, 0), (2, 0, 0), (4, 0, 0), (4, 1, 0)])
adjacencies = [(poly1, poly2), (poly2, poly3)]
poly1 = Polygon3D([(0, 1, 0), (0, 0, 0), (1, 0, 0), (1, 1, 0)])
poly2 = Polygon3D([(2, 1, 0), (2, 0, 0), (1, 0, 0), (1, 1, 0)])
poly3 = Polygon3D([(1, 1, 0), (1, 0, 0), (2, 0, 0), (2, 1, 0)])
poly4 = Polygon3D([(2, 1, 0), (2, 0, 0), (3, 0, 0), (3, 1, 0)])
poly5 = Polygon3D([(3, 1, 0), (3, 0, 0), (2, 0, 0), (2, 1, 0)])
poly6 = Polygon3D([(3, 1, 0), (3, 0, 0), (4, 0, 0), (4, 1, 0)])
expected = [poly1, poly2, poly3, poly4, poly5, poly6]
result = intersect(*adjacencies[0])
result.extend(intersect(*adjacencies[1]))
assert len(minimal_set(result)) == len(minimal_set(expected))
for poly in expected:
assert poly in result
def test_align_face_transformations_trapezoid_floor(self):
# type: () -> None
tol = 12 # places
testVertices = Polygon3D([(27.69, 0, 0), (0, 0, 0), (5, 5, 0),
(22.69, 5, 0)])
t = Transformation()._align_face(testVertices)
tempVertices = t._inverse() * testVertices
expectedVertices = Polygon3D([(0, 0, 0), (27.69, 0, 0), (22.69, 5, 0),
(5, 5, 0)])
assert almostequal(tempVertices, expectedVertices, tol)
def test_intersect():
# type: () -> None
poly1 = Polygon3D(
[(1.0, 2.1, 0.5), (1.0, 2.1, 0.0), (2.0, 2.0, 0.0), (2.0, 2.0, 0.5)]
)
poly2 = Polygon3D(
[(2.5, 1.95, 0.5), (2.5, 1.95, 0.0), (1.5, 2.05, 0.0), (1.5, 2.05, 0.5)]
)
intersection = poly1.intersect(poly2)[0]
assert not is_hole(poly1, intersection)
assert not is_hole(poly2, intersection)
def test_unique():
# type: () -> None
poly1 = Polygon3D([(0, 1, 0), (0, 0, 0), (1, 0, 0), (1, 1, 0)])
poly2 = Polygon3D([(1, 1, 0), (1, 0, 0), (0, 0, 0), (0, 1, 0)])
poly3 = Polygon3D([(0, 1, 0), (1, 1, 0), (1, 0, 0), (0, 0, 0)])
assert poly1 != poly2
assert poly2 == poly3
polys = [poly1, poly2, poly3]
unique_polys = unique(polys)
assert len(unique_polys) == 2
for poly in polys:
assert poly in unique_polys
def test_rotate_idf_360(self, base_idf):
# type: (IDF) -> None
idf1 = base_idf
idf2 = IDF()
idf2.initreadtxt(idf1.idfstr())
idf1.rotate(360)
floor1 = Polygon3D(idf1.getsurfaces("floor")[0].coords).normalize_coords(None)
floor2 = Polygon3D(idf2.getsurfaces("floor")[0].coords).normalize_coords(None)
assert almostequal(floor1, floor2)
shade1 = Polygon3D(idf1.getshadingsurfaces()[0].coords).normalize_coords(None)
shade2 = Polygon3D(idf1.getshadingsurfaces()[0].coords).normalize_coords(None)
assert almostequal(shade1, shade2)
def test_break_polygons():
# type: () -> None
poly = Polygon3D([(0,4,0),(0,0,0),(4,0,0),(4,4,0)])
hole = Polygon3D([(1,3,0),(1.5,2,0),(1,1,0),(3,1,0),(3,3,0)])
expected = [
Polygon3D([(0,4,0),(0,0,0),(1,1,0),(1.5,2,0),(1,3,0)]),
Polygon3D([(4,4,0),(0,4,0),(1,3,0),(3,3,0),(3,1,0),(1,1,0),(0,0,0),(4,0,0)])
]
result = break_polygons(poly, hole)
assert result[0] == expected[0]
assert result[1] == expected[1]
def test_double_overlap(self):
# type: () -> None
"""
__________
|__1_______|
| 1 | 2 |1 |
|_2_| |2_|
|__________|
__________
|__1________|
| 2 | 4 | 5 |
|_3_| |_6_|
|___________|
"""
poly1 = Polygon3D([(0, 2, 0), (0, 0, 0), (3, 0, 0), (3, 2, 0)])
poly2 = Polygon3D([(3, 3, 0), (3, 1, 0), (2, 1, 0), (2, 2, 0),
(1, 2, 0), (1, 1, 0), (0, 1, 0), (0, 3, 0)])
adjacencies = [(poly1, poly2)]
poly1 = Polygon3D([(3, 3, 0), (3, 2, 0), (0, 2, 0), (0, 3, 0)])
poly2 = Polygon3D([(0, 2, 0), (0, 1, 0), (1, 1, 0), (1, 2, 0)])
poly3 = Polygon3D([(1, 2, 0), (1, 1, 0), (0, 1, 0), (0, 2, 0)])
poly4 = Polygon3D([(1, 2, 0), (1, 1, 0), (0, 1, 0), (0, 0, 0),
(3, 0, 0), (3, 1, 0), (2, 1, 0), (2, 2, 0)])
poly5 = Polygon3D([(2, 2, 0), (2, 1, 0), (3, 1, 0), (3, 2, 0)])
poly6 = Polygon3D([(3, 2, 0), (3, 1, 0), (2, 1, 0), (2, 2, 0)])
result = intersect(*adjacencies[0])
expected = [poly1, poly2, poly3, poly4, poly5, poly6]
assert len(result) == len(expected)
assert len(result) == len(expected)
for poly in expected:
assert poly in result
def test_is_hole():
# type: () -> None
"""Test if a surface represents a hole in one of the surfaces.
"""
# opposite faces (all touching edges)
poly1 = Polygon3D([(0, 4, 0), (0, 0, 0), (4, 0, 0), (4, 4, 0)])
poly2 = Polygon3D(reversed([(0, 4, 0), (0, 0, 0), (4, 0, 0), (4, 4, 0)]))
intersection = poly1.intersect(poly2)[0]
assert not is_hole(poly1, intersection)
assert not is_hole(poly2, intersection)
# poly2 is within poly1 and reversed (no touching edges)
poly1 = Polygon3D([(0, 4, 0), (0, 0, 0), (4, 0, 0), (4, 4, 0)])
poly2 = Polygon3D(reversed([(1, 3, 0), (1, 1, 0), (3, 1, 0), (3, 3, 0)]))
intersection = poly1.intersect(poly2)[0]
assert is_hole(poly1, intersection)
assert not is_hole(poly2, intersection)
# poly2 is within poly1 and reversed (touches at x=0)
poly1 = Polygon3D([(0, 4, 0), (0, 0, 0), (4, 0, 0), (4, 4, 0)])
poly2 = Polygon3D(reversed([(0, 3, 0), (0, 1, 0), (3, 1, 0), (3, 3, 0)]))
intersection = poly1.intersect(poly2)[0]
assert not is_hole(poly1, intersection)
assert not is_hole(poly2, intersection)
# poly2 overlaps poly1
poly1 = Polygon3D([(1, 4, 0), (1, 0, 0), (5, 0, 0), (5, 4, 0)])
poly2 = Polygon3D(reversed([(0, 3, 0), (0, 1, 0), (3, 1, 0), (3, 3, 0)]))
intersection = poly1.intersect(poly2)[0]
assert not is_hole(poly1, intersection)
assert not is_hole(poly2, intersection)
def test_translate_to_origin(self, base_idf):
# type: () -> None
idf = base_idf
surfaces = getidfsurfaces(idf)
translate(surfaces, (50000, 10000)) # move to x + 50, y + 100
result = Polygon3D(surfaces[0].coords).xs
expected = [50002.0, 50002.0, 50001.0, 50001.0]
assert result == expected
translate_to_origin(idf)
surfaces = getidfsurfaces(idf)
min_x = min(min(Polygon3D(s.coords).xs) for s in surfaces)
min_y = min(min(Polygon3D(s.coords).ys) for s in surfaces)
assert min_x == 0
assert min_y == 0
def test_polygons_not_equal():
# type: () -> None
"""Test the check for equality between polygons.
"""
# different normal vector
poly3d = Polygon3D([(0, 0, 0), (0, 1, 1), (1, 1, 1), (1, 0, 0)])
poly3d_2 = Polygon3D([(0, 0, 2), (0, 1, 2), (1, 1, 2), (1, 0, 2)])
assert poly3d.normal_vector != poly3d_2.normal_vector
assert poly3d != poly3d_2
# different distance
poly3d = Polygon3D([(0, 0, 0), (0, 1, 1), (1, 1, 1), (1, 0, 0)])
poly3d_2 = Polygon3D([(0, 1, 2), (0, 2, 3), (1, 2, 3), (1, 1, 2)])
assert poly3d.normal_vector == poly3d_2.normal_vector
assert poly3d.distance != poly3d_2.distance
assert poly3d != poly3d_2
def test_on_poly_edge():
# type: () -> None
poly = Polygon3D([(0, 4, 0), (0, 0, 0), (4, 0, 0), (4, 4, 0)])
edge1 = Segment(Vector3D(0, 1, 0), Vector3D(0, 2, 0))
edge2 = Segment(Vector3D(1, 1, 0), Vector3D(1, 2, 0))
assert edge1._on_poly_edge(poly)
assert not edge2._on_poly_edge(poly)
def test_identify_inner_ring_polygons():
# type: () -> None
geom = [(
u"POLYGON((528318.562 186087.89,528307.65 186095.1,528303.1 186088.15,528305.59 186086.5,528299.67 186077.17,"
u"528300.85 186075.56,528295.35 186071.9,528294.401 186072.514,528292.8 186073.55,528285.8 186069.2,"
u"528286 186066.5,528286.45 186065.85,528285.854 186065.438,528277.752 186059.839,528275.54 186058.31,"
u"528273.93 186066.89,528273.76 186067.81,528273.45 186069.42,528269.73 186068.72,528267.91 186078.41,"
u"528242.51 186073.65,528242.78 186072.209,528243.49 186068.42,528252.68 186058.13,528255.36 186043.87,"
u"528261.22 186044.97,528266.75 186016.45,528269.25 186016.95,528271 186017.3,528271.2 186016.25,"
u"528277.85 186017.5,528277.25 186020.4,528300.75 186024.85,528301 186023.65,528307.8 186024.95,"
u"528307.7 186025.6,528311.5 186028.5,528310.85 186029.4,528316.7 186033.3,528320.15 186035.55,"
u"528320.7 186034.95,528324.15 186037.25,528325 186036.95,528328.75 186042.7,528327.85 186043.3,"
u"528340.6 186063.2,528342.65 186061.8,528347.25 186068.8,528347.3 186068.9,528318.562 186087.89),"
u"(528306.281 186071.421,528312.36 186075.46,528314.06 186078.02,528314.7 186077.6,528315.98 186076.78,"
u"528311.35 186069.56,528320.79 186063.52,528317.54 186058.45,528318.74 186057.68,528315.04 186051.9,"
u"528318.42 186049.74,528317.5 186048.31,528319.21 186047.21,528317.9 186045.2,528316.6 186043.15,"
u"528302.35 186063.6,528304.4 186065.05,528301.99 186068.57,528306.281 186071.421),"
u"(528294.9 186046.92,528296.47 186044.6,528299.04 186040.78,528298.55 186040.45,528290.62 186038.77,"
u"528289.3 186038.48,528288.33 186043.03,528289.65 186043.28,528287.66 186052.57,528285.16 186052.04,"
u"528284.85 186053.5,528284.1 186054.8,528286.79 186056.63,528287.12 186056.86,528286.6 186057.65,"
u"528287.3 186058.14,528289.45 186055,528291.3 186056.25,528296.85 186048.23,528294.9 186046.92),"
u"(528274.89 186044.69,528277.99 186045.28,528276.9 186051.08,528276.98 186051.1,528278.3 186052,"
u"528280.4 186053.44,528280.72 186052.98,528281.04 186051.33,528278.53 186050.86,528280.42 186041.51,"
u"528282.23 186041.86,528283.17 186037.18,528276.65 186035.8,528274.89 186044.69))",
7.7,
)]
for item in geom:
poly = Polygon3D([]).from_wkt(item[0])
def test_set_coords(self):
# type: () -> None
idf = self.idf
ggr = idf.idfobjects['GLOBALGEOMETRYRULES']
wall = idf.idfobjects['BUILDINGSURFACE:DETAILED'][0]
poly1 = Polygon3D([(0, 1, 0), (0, 0, 0), (1, 0, 0), (1, 1, 0)])
wall.setcoords(poly1, ggr)
def test_polygon_repr():
# type: () -> None
s2D = Polygon2D([(0, 0), (2, 0), (2, 0), (0, 0)]) # vertical
assert eval(repr(s2D)) == s2D
s3D = Polygon3D([(0, 0, 0), (2, 0, 0), (2, 2, 0), (0, 2, 0)]) # vertical
assert eval(repr(s3D)) == s3D
def test_set_coords(self, base_idf):
# type: (IDF) -> None
idf = base_idf
ggr = idf.idfobjects["GLOBALGEOMETRYRULES"]
wall = idf.idfobjects["BUILDINGSURFACE:DETAILED"][0]
poly1 = Polygon3D([(0, 1, 0), (0, 0, 0), (1, 0, 0), (1, 1, 0)])
wall.setcoords(poly1, ggr)
def window_vertices_given_wall(wall, wwr):
# type: (EpBunch, float) -> Polygon3D
"""Calculate window vertices given wall vertices and glazing ratio.
:: For each axis:
1) Translate the axis points so that they are centred around zero
2) Either:
a) Multiply the z dimension by the glazing ratio to shrink it vertically
b) Multiply the x or y dimension by 0.995 to keep inside the surface
3) Translate the axis points back to their original positions
:param wall: The wall to add a window on. We expect each wall to have four vertices.
:param wwr: Window to wall ratio.
:returns: Window vertices bounding a vertical strip midway up the surface.
"""
vertices = wall.coords
average_x = sum([x for x, _y, _z in vertices]) / len(vertices)
average_y = sum([y for _x, y, _z in vertices]) / len(vertices)
average_z = sum([z for _x, _y, z in vertices]) / len(vertices)
# move windows in 0.5% from the edges so they can be drawn in SketchUp
window_points = [[
((x - average_x) * 0.999) + average_x,
((y - average_y) * 0.999) + average_y,
((z - average_z) * wwr) + average_z,
] for x, y, z in vertices]
return Polygon3D(window_points)
def test_basic_shadow_matching(new_idf):
"""
Test with all x-axis at 0
This should avoid any issues with rounding/almost_equals.
"""
try:
ggr = new_idf.idfobjects["GLOBALGEOMETRYRULES"][0]
except IndexError:
ggr = None
wall = new_idf.newidfobject("BUILDINGSURFACE:DETAILED",
Name="A Wall",
Surface_Type="wall")
set_coords(wall, [(0, 0, 0), (0, 1, 0), (0, 1, 1), (0, 0, 1)], ggr)
shadow = new_idf.newidfobject("SHADING:SITE:DETAILED", Name="A Shadow")
set_coords(shadow, [(0, 0, 2), (0, 2, 2), (0, 2, 0), (0, 0, 0)], ggr)
new_idf.intersect_match()
# new_idf.view_model()
walls = [
Polygon3D(w.coords) for w in new_idf.getsurfaces("wall")
if w.Outside_Boundary_Condition == "adiabatic"
]
expected_adiabatic = 1
assert len(walls) == expected_adiabatic
