honeybee-core 1.64.2__tar.gz → 1.64.4__tar.gz

{honeybee_core-1.64.2/honeybee_core.egg-info → honeybee_core-1.64.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: honeybee-core
-Version: 1.64.2
+Version: 1.64.4
 Summary: A library to create 3D building geometry for various types of environmental simulation.
 Home-page: https://github.com/ladybug-tools/honeybee-core
 Author: Ladybug Tools

{honeybee_core-1.64.2 → honeybee_core-1.64.4}/honeybee/model.py

@@ -1478,7 +1478,7 @@ class Model(_Base):
             )
         return shades
 
-    def classified_envelope_edges(self, tolerance=None, exclude_coplanar=False):
+    def classified_envelope_edges(self, tolerance=None, exclude_coplanar=True):
         """Get classified edges of this Model's envelope based on Faces they adjoin.
 
         The edges returned by this method will only exist along the exterior
@@ -1490,7 +1490,7 @@ class Model(_Base):
                 considered equivalent. If None, the Model's tolerance will be used.
             exclude_coplanar: Boolean to note whether edges falling between two
                 coplanar Faces in the building envelope should be included
-                in the result (False) or excluded from it (True). (Default: False).
+                in the result (False) or excluded from it (True). (Default: True).
 
         Returns:
             A tuple with eight items where each item is a list containing
@@ -1562,43 +1562,61 @@ class Model(_Base):
             -   window_mullions - Apertures meet one another.
 
             -   door_frames - Doors meet their parent exterior wall or roof.
+
+            -   door_mullions - Doors meet one another.
         """
-        # set up lists to be populated
-        window_frames, window_mullions = [], []
+        # set up variables to be used for all sub_faces
         tol = tolerance if tolerance is not None else self.tolerance
         a_tol = math.radians(angle_tolerance) if angle_tolerance is not None else \
             math.radians(self.angle_tolerance)
         mul_thick = tol if mullion_thickness is None else mullion_thickness
 
+        # get the edges of the sub_faces
+        window_frames, window_mullions = \
+            self._classify_mullions(self.apertures, mul_thick, tol, a_tol)
+        door_frames, door_mullions = \
+            self._classify_mullions(self.doors, mul_thick, tol, a_tol)
+        return window_frames, window_mullions, door_frames, door_mullions
+
+    @staticmethod
+    def _classify_mullions(sub_faces, mul_thick, tol, a_tol):
+        """Organize subface edges depending on whether they are frames or mullions."""
+        sub_face_frames, sub_face_mullions = [], []
         # group the apertures by the plane in which they exist
-        apertures = self.apertures
-        coplanar_dict = {apertures[0].geometry.plane: [apertures[0]]}
-        for ap in apertures[1:]:
-            if isinstance(ap.boundary_condition, Outdoors):
+        coplanar_dict = {}
+        sub_faces = [sf for sf in sub_faces
+                     if isinstance(sf.boundary_condition, Outdoors)]
+        if len(sub_faces) != 0:
+            coplanar_dict = {sub_faces[0].geometry.plane: [sub_faces[0]]}
+            for sf in sub_faces[1:]:
                 for pln, f_list in coplanar_dict.items():
-                    if ap.geometry.plane.is_coplanar_tolerance(pln, tol, a_tol):
-                        f_list.append(ap)
+                    if sf.geometry.plane.is_coplanar_tolerance(pln, tol, a_tol):
+                        f_list.append(sf)
                         break
                 else:  # the first face with this type of plane
-                    coplanar_dict[ap.geometry.plane] = [ap]
+                    coplanar_dict[sf.geometry.plane] = [sf]
 
         # for each group, intersect their edges and extract edges from a Polyface3D
-        for plane, aps in coplanar_dict.items():
+        for plane, sfs in coplanar_dict.items():
             # intersect edges that are close enough to one another within thickness
             polygons = []
-            for ap in aps:
-                pts_2d = [plane.xyz_to_xy(pt) for pt in ap.geometry.boundary]
-                polygons.append(Polygon2D(pts_2d))
+            for sf in sfs:
+                pts_2d = [plane.xyz_to_xy(pt) for pt in sf.geometry.boundary]
+                try:
+                    poly = Polygon2D(pts_2d).remove_colinear_vertices(mul_thick)
+                    polygons.append(poly)
+                except AssertionError:
+                    pass  # too small of a geometry
             polygons = Polygon2D.intersect_polygon_segments(polygons, mul_thick)
             faces = []
             for poly in polygons:
-                faces.append(Face3D([plane.xy_to_xyz(pt) for pt in poly]))
+                faces.append(Face3D([plane.xy_to_xyz(pt) for pt in poly], plane))
             # create a joined Polyface3D and classify the edges
             ap_polyface = Polyface3D.from_faces(faces, mul_thick)
-            window_frames.extend(ap_polyface.naked_edges)
-            window_mullions.extend(ap_polyface.internal_edges)
+            sub_face_frames.extend(ap_polyface.naked_edges)
+            sub_face_mullions.extend(ap_polyface.internal_edges)
 
-        return window_frames, window_mullions, self.exterior_door_edges
+        return sub_face_frames, sub_face_mullions
 
     def add_prefix(self, prefix):
         """Change the identifier of this object and child objects by inserting a prefix.

{honeybee_core-1.64.2 → honeybee_core-1.64.4}/honeybee/room.py

@@ -6,8 +6,8 @@ import re
 import uuid
 
 from ladybug_geometry.geometry2d import Point2D, Vector2D, Polygon2D
-from ladybug_geometry.geometry3d import Point3D, Vector3D, Ray3D, Plane, Face3D, \
-    Mesh3D, Polyface3D
+from ladybug_geometry.geometry3d import Point3D, Vector3D, Ray3D, LineSegment3D, \
+    Plane, Face3D, Mesh3D, Polyface3D
 from ladybug_geometry.bounding import overlapping_bounding_boxes
 from ladybug_geometry_polyskel.polysplit import perimeter_core_subpolygons
 
@@ -640,22 +640,37 @@ class Room(_BaseWithShade):
         exterior_wall_to_wall, roof_ridge, exposed_floor_to_floor = [], [], []
         underground, interior = [], []
 
-        # get all of the edges and map them to room faces
-        edges = self.geometry.internal_edges
+        # get all of the edges in a way that colinear edges are broken down
+        base_edges = list(self.geometry.internal_edges)
+        base_vertices = self.geometry.vertices
+        edges = []
+        for i, edge in enumerate(base_edges):
+            for pt in base_vertices:
+                if edge.distance_to_point(pt) < tolerance and \
+                        not edge.p1.distance_to_point(pt) < tolerance and \
+                        not edge.p2.distance_to_point(pt) < tolerance:
+                    # split the edge in two at the point
+                    base_edges.append(LineSegment3D.from_end_points(edge.p1, pt))
+                    base_edges.append(LineSegment3D.from_end_points(pt, edge.p2))
+                    break
+            else:  # no further subdivision needed
+                edges.append(edge)
+
+        # map the edges to room faces
         edge_faces = [[] for _ in edges]
         for i, edge in enumerate(edges):
             for face in self.faces:
                 if overlapping_bounding_boxes(face.geometry, edge, tolerance):
                     for f_edge in face.geometry.segments:
-                        if edge.distance_to_point(f_edge.p1) < tolerance and \
-                                edge.distance_to_point(f_edge.p2) < tolerance:
+                        if f_edge.distance_to_point(edge.p1) < tolerance and \
+                                f_edge.distance_to_point(edge.p2) < tolerance:
                             edge_faces[i].append(face)
                             break
 
         # classify the edges by analyzing the faces they adjoin
         for edge, faces in zip(edges, edge_faces):
             # first check for cases where the edge should be excluded
-            if len(edge_faces) <= 1:  # not an edge between two faces
+            if len(faces) <= 1:  # not an edge between two faces
                 continue
             if angle_tolerance is not None:
                 ang_tol = math.radians(angle_tolerance)

{honeybee_core-1.64.2 → honeybee_core-1.64.4/honeybee_core.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: honeybee-core
-Version: 1.64.2
+Version: 1.64.4
 Summary: A library to create 3D building geometry for various types of environmental simulation.
 Home-page: https://github.com/ladybug-tools/honeybee-core
 Author: Ladybug Tools