honeybee-core 1.63.0__tar.gz → 1.64.0__tar.gz

{honeybee_core-1.63.0/honeybee_core.egg-info → honeybee_core-1.64.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: honeybee-core
-Version: 1.63.0
+Version: 1.64.0
 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.63.0 → honeybee_core-1.64.0}/honeybee/model.py

@@ -107,6 +107,18 @@ class Model(_Base):
         * exterior_skylight_aperture_area
         * min
         * max
+        * roof_to_exterior_edges
+        * slab_to_exterior_edges
+        * exposed_floor_to_exterior_wall_edges
+        * exterior_wall_to_wall_edges
+        * roof_ridge_edges
+        * exposed_floor_to_floor_edges
+        * underground_edges
+        * interior_edges
+        * exterior_aperture_edges
+        * exterior_door_edges
+        * exterior_aperture_edges
+        * exterior_door_edges
         * top_level_dict
         * user_data
     """
@@ -1014,6 +1026,92 @@ class Model(_Base):
         """Get a Point3D for the max bounding box vertex in the XY plane."""
         return self._calculate_max(self._all_objects())
 
+    @property
+    def roof_to_exterior_edges(self):
+        """Get LineSegment3Ds where roofs meet exterior walls (or floors).
+
+        Note that both the roof Face and the wall/floor Face must be next to one
+        another in the model's outer envelope and have outdoor boundary conditions for
+        the edge to show up in this list.
+        """
+        return self.classified_envelope_edges()[0]
+
+    @property
+    def slab_to_exterior_edges(self):
+        """Get LineSegment3Ds where ground floor slabs meet exterior walls or roofs.
+
+        Note that the floor Face must have a ground boundary condition and the wall or
+        roof Face must have an outdoor boundary condition for the edge between the
+        two Faces to show up in this list.
+        """
+        return self.classified_envelope_edges()[1]
+
+    @property
+    def exposed_floor_to_exterior_wall_edges(self):
+        """Get LineSegment3Ds where exposed floors meet exterior walls.
+
+        Note that both the wall Face and the floor Face must be next to one
+        another in the model's outer envelope and have outdoor boundary conditions for
+        the edge to show up in this list.
+        """
+        return self.classified_envelope_edges()[2]
+
+    @property
+    def exterior_wall_to_wall_edges(self):
+        """Get LineSegment3Ds where exterior walls meet one another.
+
+        Note that both wall Faces must be next to one another in the model's
+        outer envelope and have outdoor boundary conditions for the edge to
+        show up in this list.
+        """
+        return self.classified_envelope_edges()[3]
+
+    @property
+    def roof_ridge_edges(self):
+        """Get a list of LineSegment3D where exterior roofs meet one another.
+
+        Note that both roof Faces must be next to one another in the model's
+        outer envelope and have outdoor boundary conditions for the edge to
+        show up in this list.
+        """
+        return self.classified_envelope_edges()[4]
+
+    @property
+    def exposed_floor_to_floor_edges(self):
+        """Get LineSegment3Ds where exposed floors meet one another.
+
+        Note that both floor Faces must be next to one another in the model's
+        outer envelope and have outdoor boundary conditions for the edge to
+        show up in this list.
+        """
+        return self.classified_envelope_edges()[5]
+
+    @property
+    def underground_edges(self):
+        """Get a list of LineSegment3D where underground Faces meet one another.
+
+        Note that both Faces must be next to one another in the model's outer envelope
+        and have ground boundary conditions for the edge to show up in this list.
+        """
+        return self.classified_envelope_edges()[6]
+
+    @property
+    def exterior_aperture_edges(self):
+        """Get a list of LineSegment3D for the borders around room exterior apertures.
+        """
+        edges = []
+        for room in self.rooms:
+            edges.extend(room.exterior_aperture_edges)
+        return edges
+
+    @property
+    def exterior_door_edges(self):
+        """Get a list of LineSegment3D for the borders around room exterior doors."""
+        edges = []
+        for room in self.rooms:
+            edges.extend(room.exterior_door_edges)
+        return edges
+
     @property
     def top_level_dict(self):
         """Get dictionary of top-level model objects with identifiers as the keys.
@@ -1378,6 +1476,63 @@ class Model(_Base):
             )
         return shades
 
+    def classified_envelope_edges(self, tolerance=None, exclude_coplanar=False):
+        """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
+        envelope of the Model's Rooms as defined by the contiguous volume across
+        all Room interior adjacencies.
+
+        Args:
+            tolerance: The maximum difference between point values for them to be
+                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).
+
+        Returns:
+            A tuple with eight items where each item is a list containing
+            LineSegment3D adjoining different types of Faces.
+
+            -   roof_to_exterior - Roofs meet exterior walls or floors.
+
+            -   slab_to_exterior - Ground floor slabs meet exterior walls or roofs.
+
+            -   exposed_floor_to_exterior_wall - Exposed floors meet exterior walls.
+
+            -   exterior_wall_to_wall - Exterior walls meet.
+
+            -   roof_ridge - Exterior roofs meet.
+
+            -   exposed_floor_to_floor - Exposed floors meet.
+
+            -   underground - Underground faces meet.
+        """
+        # set up lists to be populated
+        roof_to_exterior, slab_to_exterior, exposed_floor_to_exterior_wall = [], [], []
+        exterior_wall_to_wall, roof_ridge, exposed_floor_to_floor = [], [], []
+        underground, interior = [], []
+        tol = tolerance if tolerance else self.tolerance
+        ang_tol = self.angle_tolerance if exclude_coplanar else None
+
+        # join all of the rooms in the model across their adjacencies
+        merged_rooms = Room.join_adjacent_rooms(self.rooms, tol)
+        for room in merged_rooms:
+            rf_to_ext, slb_to_ext, ex_flr_to_ext, ext_wl_to_wl, rf_ridge, \
+                ex_flr_to_flr, under_gnd, inter = room.classified_edges(tol, ang_tol)
+            roof_to_exterior.extend(rf_to_ext)
+            slab_to_exterior.extend(slb_to_ext)
+            exposed_floor_to_exterior_wall.extend(ex_flr_to_ext)
+            exterior_wall_to_wall.extend(ext_wl_to_wl)
+            roof_ridge.extend(rf_ridge)
+            exposed_floor_to_floor.extend(ex_flr_to_flr)
+            underground.extend(under_gnd)
+            interior.extend(inter)
+
+        # return the classified edges
+        return roof_to_exterior, slab_to_exterior, exposed_floor_to_exterior_wall, \
+            exterior_wall_to_wall, roof_ridge, exposed_floor_to_floor, underground
+
     def add_prefix(self, prefix):
         """Change the identifier of this object and child objects by inserting a prefix.
 

{honeybee_core-1.63.0 → honeybee_core-1.64.0}/honeybee/room.py

@@ -8,6 +8,7 @@ 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.bounding import overlapping_bounding_boxes
 from ladybug_geometry_polyskel.polysplit import perimeter_core_subpolygons
 
 import honeybee.writer.room as writer
@@ -71,6 +72,8 @@ class Room(_BaseWithShade):
         * center
         * min
         * max
+        * exterior_aperture_edges
+        * exterior_door_edges
         * volume
         * floor_area
         * exposed_area
@@ -430,6 +433,24 @@ class Room(_BaseWithShade):
         all_geo.extend(self._faces)
         return self._calculate_max(all_geo)
 
+    @property
+    def exterior_aperture_edges(self):
+        """Get a list of LineSegment3D for the borders around exterior apertures."""
+        edges = []
+        for ap in self.apertures:
+            if isinstance(ap.boundary_condition, Outdoors):
+                edges.extend(ap.geometry.segments)
+        return edges
+
+    @property
+    def exterior_door_edges(self):
+        """Get a list of LineSegment3D for the borders around exterior doors."""
+        edges = []
+        for dr in self.doors:
+            if isinstance(dr.boundary_condition, Outdoors):
+                edges.extend(dr.geometry.segments)
+        return edges
+
     @property
     def volume(self):
         """Get the volume of the room.
@@ -584,101 +605,92 @@ class Room(_BaseWithShade):
                 areas += face.area
         return orientations / areas if areas != 0 else None
 
-    def add_prefix(self, prefix):
-        """Change the identifier of this object and child objects by inserting a prefix.
-
-        This is particularly useful in workflows where you duplicate and edit
-        a starting object and then want to combine it with the original object
-        into one Model (like making a model of repeated rooms) since all objects
-        within a Model must have unique identifiers.
+    def classified_edges(self, tolerance=0.01, angle_tolerance=None):
+        """Get classified edges of this Room's Polyface3D based on Faces they adjoin.
 
         Args:
-            prefix: Text that will be inserted at the start of this object's
-                (and child objects') identifier and display_name. It is recommended
-                that this prefix be short to avoid maxing out the 100 allowable
-                characters for honeybee identifiers.
-        """
-        self._identifier = clean_string('{}_{}'.format(prefix, self.identifier))
-        self.display_name = '{}_{}'.format(prefix, self.display_name)
-        self.properties.add_prefix(prefix)
-        for face in self._faces:
-            face.add_prefix(prefix)
-        self._add_prefix_shades(prefix)
+            tolerance: The maximum difference between point values for them to be
+                considered equivalent. (Default: 0.01, suitable for objects in meters).
+            angle_tolerance: An optional value in degrees, which can be used to
+                exclude edges falling between coplanar Faces. If None, edges falling
+                between coplanar Faces will be included. (Default: None).
 
-    def rename_by_attribute(
-        self, format_str='{story} - {display_name}'
-    ):
-        """Set the display name of this Room using a format string with Room attributes.
+        Returns:
+            A tuple with eight items where each item is a list containing
+            LineSegment3D adjoining different types of Faces.
 
-        Args:
-            format_str: Text string for the pattern with which the Room will be
-                renamed. Any property on this class may be used (eg. story)
-                and each property should be put in curly brackets. Nested
-                properties can be specified by using "." to denote nesting levels
-                (eg. properties.energy.program_type.display_name). Functions that
-                return string outputs can also be passed here as long as these
-                functions defaults specified for all arguments.
-        """
-        matches = re.findall(r'{([^}]*)}', format_str)
-        attributes = [get_attr_nested(self, m) for m in matches]
-        for attr_name, attr_val in zip(matches, attributes):
-            format_str = format_str.replace('{{{}}}'.format(attr_name), attr_val)
-        self.display_name = format_str
-        return format_str
+            -   roof_to_exterior - Roofs meet exterior walls or floors.
 
-    def rename_faces_by_attribute(
-        self,
-        format_str='{parent.display_name} - {gbxml_type} - {cardinal_direction}'
-    ):
-        """Set the display name for all of this Room's faces using a format string.
+            -   slab_to_exterior - Ground floor slabs meet exterior walls or roofs.
 
-        Args:
-            format_str: Text string for the pattern with which the faces will be
-                renamed. Any property of the Face class may be used (eg. gbxml_str)
-                and each property should be put in curly brackets. Nested
-                properties can be specified by using "." to denote nesting levels
-                (eg. properties.energy.construction.display_name). Functions that
-                return string outputs can also be passed here as long as these
-                functions defaults specified for all arguments.
-        """
-        for face in self.faces:
-            face.rename_by_attribute(format_str)
+            -   exposed_floor_to_exterior_wall - Exposed floors meet exterior walls.
 
-    def rename_apertures_by_attribute(
-        self,
-        format_str='{parent.parent.display_name} - {gbxml_type} - {cardinal_direction}'
-    ):
-        """Set the display name for all of this Room's apertures using a format string.
+            -   exterior_wall_to_wall - Exterior walls meet.
 
-        Args:
-            format_str: Text string for the pattern with which the apertures will be
-                renamed. Any property on the Aperture class may be used (eg. gbxml_str)
-                and each property should be put in curly brackets. Nested
-                properties can be specified by using "." to denote nesting levels
-                (eg. properties.energy.construction.display_name). Functions that
-                return string outputs can also be passed here as long as these
-                functions defaults specified for all arguments.
-        """
-        for ap in self.apertures:
-            ap.rename_by_attribute(format_str)
+            -   roof_ridge - Exterior roofs meet.
 
-    def rename_doors_by_attribute(
-        self,
-        format_str='{parent.parent.display_name} - {energyplus_type} - {cardinal_direction}'
-    ):
-        """Set the display name for all of this Room's doors using a format string.
+            -   exposed_floor_to_floor - Exposed floors meet.
 
-        Args:
-            format_str: Text string for the pattern with which the doors will be
-                renamed. Any property on the Door class may be used (eg. gbxml_str)
-                and each property should be put in curly brackets. Nested
-                properties can be specified by using "." to denote nesting levels
-                (eg. properties.energy.construction.display_name). Functions that
-                return string outputs can also be passed here as long as these
-                functions defaults specified for all arguments.
+            -   underground - Underground faces meet.
+
+            -   interior - Interior faces meet.
         """
-        for dr in self.doors:
-            dr.rename_by_attribute(format_str)
+        # set up lists to be populated
+        roof_to_exterior, slab_to_exterior, exposed_floor_to_exterior_wall = [], [], []
+        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
+        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:
+                            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
+                continue
+            if angle_tolerance is not None:
+                ang_tol = math.radians(angle_tolerance)
+                base_normal = faces[0].normal
+                if all(f.normal.angle(base_normal) < ang_tol for f in faces[1:]):
+                    continue
+
+            # then check for which category the edge should go into
+            ext_faces = [f for f in faces if isinstance(f.boundary_condition, Outdoors)
+                         and not isinstance(f.type, AirBoundary)]
+            if len(ext_faces) >= 2:  # some type of exterior edge
+                if all(isinstance(f.type, Wall) for f in ext_faces):
+                    exterior_wall_to_wall.append(edge)
+                elif all(isinstance(f.type, RoofCeiling) for f in ext_faces):
+                    roof_ridge.append(edge)
+                elif all(isinstance(f.type, Floor) for f in ext_faces):
+                    exposed_floor_to_floor.append(edge)
+                elif any(isinstance(f.type, RoofCeiling) for f in ext_faces):
+                    roof_to_exterior.append(edge)
+                elif any(isinstance(f.type, Floor) for f in ext_faces):
+                    exposed_floor_to_exterior_wall.append(edge)
+            else:
+                gnd_faces = [f for f in faces if isinstance(f.boundary_condition, Ground)
+                             and not isinstance(f.type, AirBoundary)]
+                if len(ext_faces) >= 1 and len(gnd_faces) >= 1:
+                    slab_to_exterior.append(edge)
+                elif len(gnd_faces) >= 2:  # some type of underground edge
+                    underground.append(edge)
+                else:  # some type of interior edge
+                    interior.append(edge)
+
+        # return the classified edges
+        return roof_to_exterior, slab_to_exterior, exposed_floor_to_exterior_wall, \
+            exterior_wall_to_wall, roof_ridge, exposed_floor_to_floor, \
+            underground, interior
 
     def horizontal_boundary(self, match_walls=False, tolerance=0.01):
         """Get a Face3D representing the horizontal boundary around the Room.
@@ -774,6 +786,102 @@ class Room(_BaseWithShade):
             return self._match_walls_to_horizontal_faces(horiz_bound, tolerance)
         return horiz_bound
 
+    def add_prefix(self, prefix):
+        """Change the identifier of this object and child objects by inserting a prefix.
+
+        This is particularly useful in workflows where you duplicate and edit
+        a starting object and then want to combine it with the original object
+        into one Model (like making a model of repeated rooms) since all objects
+        within a Model must have unique identifiers.
+
+        Args:
+            prefix: Text that will be inserted at the start of this object's
+                (and child objects') identifier and display_name. It is recommended
+                that this prefix be short to avoid maxing out the 100 allowable
+                characters for honeybee identifiers.
+        """
+        self._identifier = clean_string('{}_{}'.format(prefix, self.identifier))
+        self.display_name = '{}_{}'.format(prefix, self.display_name)
+        self.properties.add_prefix(prefix)
+        for face in self._faces:
+            face.add_prefix(prefix)
+        self._add_prefix_shades(prefix)
+
+    def rename_by_attribute(
+        self, format_str='{story} - {display_name}'
+    ):
+        """Set the display name of this Room using a format string with Room attributes.
+
+        Args:
+            format_str: Text string for the pattern with which the Room will be
+                renamed. Any property on this class may be used (eg. story)
+                and each property should be put in curly brackets. Nested
+                properties can be specified by using "." to denote nesting levels
+                (eg. properties.energy.program_type.display_name). Functions that
+                return string outputs can also be passed here as long as these
+                functions defaults specified for all arguments.
+        """
+        matches = re.findall(r'{([^}]*)}', format_str)
+        attributes = [get_attr_nested(self, m) for m in matches]
+        for attr_name, attr_val in zip(matches, attributes):
+            format_str = format_str.replace('{{{}}}'.format(attr_name), attr_val)
+        self.display_name = format_str
+        return format_str
+
+    def rename_faces_by_attribute(
+        self,
+        format_str='{parent.display_name} - {gbxml_type} - {cardinal_direction}'
+    ):
+        """Set the display name for all of this Room's faces using a format string.
+
+        Args:
+            format_str: Text string for the pattern with which the faces will be
+                renamed. Any property of the Face class may be used (eg. gbxml_str)
+                and each property should be put in curly brackets. Nested
+                properties can be specified by using "." to denote nesting levels
+                (eg. properties.energy.construction.display_name). Functions that
+                return string outputs can also be passed here as long as these
+                functions defaults specified for all arguments.
+        """
+        for face in self.faces:
+            face.rename_by_attribute(format_str)
+
+    def rename_apertures_by_attribute(
+        self,
+        format_str='{parent.parent.display_name} - {gbxml_type} - {cardinal_direction}'
+    ):
+        """Set the display name for all of this Room's apertures using a format string.
+
+        Args:
+            format_str: Text string for the pattern with which the apertures will be
+                renamed. Any property on the Aperture class may be used (eg. gbxml_str)
+                and each property should be put in curly brackets. Nested
+                properties can be specified by using "." to denote nesting levels
+                (eg. properties.energy.construction.display_name). Functions that
+                return string outputs can also be passed here as long as these
+                functions defaults specified for all arguments.
+        """
+        for ap in self.apertures:
+            ap.rename_by_attribute(format_str)
+
+    def rename_doors_by_attribute(
+        self,
+        format_str='{parent.parent.display_name} - {energyplus_type} - {cardinal_direction}'
+    ):
+        """Set the display name for all of this Room's doors using a format string.
+
+        Args:
+            format_str: Text string for the pattern with which the doors will be
+                renamed. Any property on the Door class may be used (eg. gbxml_str)
+                and each property should be put in curly brackets. Nested
+                properties can be specified by using "." to denote nesting levels
+                (eg. properties.energy.construction.display_name). Functions that
+                return string outputs can also be passed here as long as these
+                functions defaults specified for all arguments.
+        """
+        for dr in self.doors:
+            dr.rename_by_attribute(format_str)
+
     def remove_indoor_furniture(self):
         """Remove all indoor furniture assigned to this Room.
 

{honeybee_core-1.63.0 → honeybee_core-1.64.0/honeybee_core.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: honeybee-core
-Version: 1.63.0
+Version: 1.64.0
 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