honeybee-core 1.62.12__py3-none-any.whl → 1.64.0__py3-none-any.whl

honeybee/aperture.py

@@ -94,13 +94,6 @@ class Aperture(_BaseWithShade):
             assert data['type'] == 'Aperture', 'Expected Aperture dictionary. ' \
                 'Got {}.'.format(data['type'])
 
-            # remove any invalid holes from the geometry
-            geo_dict = data['geometry']
-            if 'holes' in geo_dict and geo_dict['holes'] is not None:
-                for i, hole_list in enumerate(geo_dict['holes']):
-                    if len(hole_list) < 3:
-                        geo_dict['holes'].pop(i)
-
             # serialize the aperture
             is_operable = data['is_operable'] if 'is_operable' in data else False
             if data['boundary_condition']['type'] == 'Outdoors':

honeybee/door.py

@@ -96,13 +96,6 @@ class Door(_BaseWithShade):
             assert data['type'] == 'Door', 'Expected Door dictionary. ' \
                 'Got {}.'.format(data['type'])
 
-            # remove any invalid holes from the geometry
-            geo_dict = data['geometry']
-            if 'holes' in geo_dict and geo_dict['holes'] is not None:
-                for i, hole_list in enumerate(geo_dict['holes']):
-                    if len(hole_list) < 3:
-                        geo_dict['holes'].pop(i)
-
             # serialize the door
             is_glass = data['is_glass'] if 'is_glass' in data else False
             if data['boundary_condition']['type'] == 'Outdoors':

honeybee/face.py

@@ -133,13 +133,6 @@ class Face(_BaseWithShade):
             assert data['type'] == 'Face', 'Expected Face dictionary. ' \
                 'Got {}.'.format(data['type'])
 
-            # remove any invalid holes from the geometry
-            geo_dict = data['geometry']
-            if 'holes' in geo_dict and geo_dict['holes'] is not None:
-                for i, hole_list in enumerate(geo_dict['holes']):
-                    if len(hole_list) < 3:
-                        geo_dict['holes'].pop(i)
-
             # first serialize it with an outdoor boundary condition
             face_type = face_types.by_name(data['face_type'])
             face = cls(data['identifier'], Face3D.from_dict(data['geometry']),

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
     """
@@ -161,11 +173,16 @@ class Model(_Base):
         self._properties = ModelProperties(self)
 
     @classmethod
-    def from_dict(cls, data):
+    def from_dict(cls, data, cleanup_irrational=False):
         """Initialize a Model from a dictionary.
 
         Args:
             data: A dictionary representation of a Model object.
+            cleanup_irrational: Boolean to note whether common types of irrational
+                objects should be cleaned or removed from the dictionary before
+                serializing the model to Python. Typical cases that are removed
+                this way include Face3Ds with fewer than 3 vertices, Rooms that
+                have no Face geometry, etc. (Default: False).
         """
         # check the type of dictionary
         assert data['type'] == 'Model', 'Expected Model dictionary. ' \
@@ -179,6 +196,10 @@ class Model(_Base):
         angle_tol = 1.0 if 'angle_tolerance' not in data or \
             data['angle_tolerance'] is None else data['angle_tolerance']
 
+        # clean the irrational objects out if requested
+        if cleanup_irrational:
+            cls.clean_irrational_geometry(data)
+
         # import all of the geometry
         rooms = None  # import rooms
         if 'rooms' in data and data['rooms'] is not None:
@@ -244,11 +265,16 @@ class Model(_Base):
         return model
 
     @classmethod
-    def from_file(cls, hb_file):
+    def from_file(cls, hb_file, cleanup_irrational=False):
         """Initialize a Model from a HBJSON or HBpkl file, auto-sensing the type.
 
         Args:
             hb_file: Path to either a HBJSON or HBpkl file.
+            cleanup_irrational: Boolean to note whether common types of irrational
+                objects should be cleaned or removed from the dictionary before
+                serializing the model to Python. Typical cases that are removed
+                this way include Face3Ds with fewer than 3 vertices, Rooms that
+                have no Face geometry, etc. (Default: False).
         """
         # sense the file type from the first character to avoid maxing memory with JSON
         # this is needed since queenbee overwrites all file extensions
@@ -258,15 +284,20 @@ class Model(_Base):
         is_json = True if first_char == '{' or second_char == '{' else False
         # load the file using either HBJSON pathway or HBpkl
         if is_json:
-            return cls.from_hbjson(hb_file)
-        return cls.from_hbpkl(hb_file)
+            return cls.from_hbjson(hb_file, cleanup_irrational)
+        return cls.from_hbpkl(hb_file, cleanup_irrational)
 
     @classmethod
-    def from_hbjson(cls, hbjson_file):
+    def from_hbjson(cls, hbjson_file, cleanup_irrational=False):
         """Initialize a Model from a HBJSON file.
 
         Args:
             hbjson_file: Path to HBJSON file.
+            cleanup_irrational: Boolean to note whether common types of irrational
+                objects should be cleaned or removed from the dictionary before
+                serializing the model to Python. Typical cases that are removed
+                this way include Face3Ds with fewer than 3 vertices, Rooms that
+                have no Face geometry, etc. (Default: False).
         """
         assert os.path.isfile(hbjson_file), 'Failed to find %s' % hbjson_file
         with io.open(hbjson_file, encoding='utf-8') as inf:
@@ -276,19 +307,24 @@ class Model(_Base):
             if second_char == '{':
                 inf.read(1)
             data = json.load(inf)
-        return cls.from_dict(data)
+        return cls.from_dict(data, cleanup_irrational)
 
     @classmethod
-    def from_hbpkl(cls, hbpkl_file):
+    def from_hbpkl(cls, hbpkl_file, cleanup_irrational=False):
         """Initialize a Model from a HBpkl file.
 
         Args:
             hbpkl_file: Path to HBpkl file.
+            cleanup_irrational: Boolean to note whether common types of irrational
+                objects should be cleaned or removed from the dictionary before
+                serializing the model to Python. Typical cases that are removed
+                this way include Face3Ds with fewer than 3 vertices, Rooms that
+                have no Face geometry, etc. (Default: False).
         """
         assert os.path.isfile(hbpkl_file), 'Failed to find %s' % hbpkl_file
         with open(hbpkl_file, 'rb') as inf:
             data = pickle.load(inf)
-        return cls.from_dict(data)
+        return cls.from_dict(data, cleanup_irrational)
 
     @classmethod
     def from_stl(cls, file_path, geometry_to_faces=False, units='Meters',
@@ -990,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.
@@ -1354,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.
 
@@ -3685,6 +3864,97 @@ class Model(_Base):
                 out_dict['valid'] = False
             return json.dumps(out_dict, indent=4)
 
+    @staticmethod
+    def clean_irrational_geometry(model_dict):
+        """Remove irrational geometry objects from a honeybee Model dictionary.
+
+        This can be useful to run prior to serializing the Model object from a
+        dictionary if it was produced from a source other than the Python
+        core libraries, in which case the dictionary is necessarily rational
+        and serializable. This is because not all honeybee-schema bindings
+        enforce fundamental definitions of geometry types upon initialization
+        of the geometry objects, leading to exceptions when an attempt is made
+        to serialize them to Python. Furthermore, it is possible that the honeybee
+        Model dictionary did not originate from any schema bindings at all, in
+        which case it is highly recommended that this method be run.
+
+        Typical irrational geometry cases that are removed by this method include.
+
+            * Apertures/Doors with less than 3 vertices or holes less than 3 vertices.
+            * Faces with less than 3 vertices or holes with less than 3 vertices.
+            * Rooms that have no Face geometry.
+            * Shade Face3Ds with less than 3 vertices or holes with less than 3 vertices.
+            * ShadeMesh Mesh3Ds with no faces or faces with less than 3 vertices.
+        """
+        # clean all of the Room geometry in the model dictionary
+        if 'rooms' in model_dict and model_dict['rooms'] is not None:
+            for ri in range(len(model_dict['rooms']) - 1, -1, -1):
+                r_dict = model_dict['rooms'][ri]
+                # clean all of the Face geometry
+                Model._clean_irrational_geo_with_shade(r_dict['faces'])
+                for f_dict in r_dict['faces']:
+                    # clean all of the Aperture/Door geometry
+                    if 'apertures' in f_dict and f_dict['apertures'] is not None:
+                        Model._clean_irrational_geo_with_shade(f_dict['apertures'])
+                    if 'doors' in f_dict and f_dict['doors'] is not None:
+                        Model._clean_irrational_geo_with_shade(f_dict['doors'])
+                # clean the assigned shade geometry
+                if 'outdoor_shades' in r_dict and r_dict['outdoor_shades'] is not None:
+                    Model._clean_irrational_face3ds(r_dict['outdoor_shades'])
+                if 'indoor_shades' in r_dict and r_dict['indoor_shades'] is not None:
+                    Model._clean_irrational_face3ds(r_dict['indoor_shades'])
+                if len(r_dict['faces']) == 0:  # the entire Room is irrational
+                    model_dict['rooms'].pop(ri)
+        # clean all of the orphaned geometry in the model dictionary
+        if 'orphaned_faces' in model_dict and model_dict['orphaned_faces'] is not None:
+            Model._clean_irrational_geo_with_shade(model_dict['orphaned_faces'])
+        if 'orphaned_apertures' in model_dict and \
+                model_dict['orphaned_apertures'] is not None:
+            Model._clean_irrational_geo_with_shade(model_dict['orphaned_apertures'])
+        if 'orphaned_doors' in model_dict and model_dict['orphaned_doors'] is not None:
+            Model._clean_irrational_geo_with_shade(model_dict['orphaned_doors'])
+        if 'orphaned_shades' in model_dict and model_dict['orphaned_shades'] is not None:
+            Model._clean_irrational_face3ds(model_dict['orphaned_shades'])
+        # clean all of the shade mesh geometry in the model dictionary
+        if 'shade_meshes' in model_dict and model_dict['shade_meshes'] is not None:
+            for smi in range(len(model_dict['shade_meshes']) - 1, -1, -1):
+                sm_dict = model_dict['shade_meshes'][smi]['geometry']
+                for mfi in range(len(sm_dict['faces']) - 1, -1, -1):
+                    mf = sm_dict['faces'][mfi]
+                    if len(mf) not in (3, 4):
+                        sm_dict['faces'].pop(mfi)
+                    else:
+                        for ind in mf:
+                            try:
+                                sm_dict['vertices'][ind]
+                            except IndexError:
+                                sm_dict['faces'].pop(mfi)
+                                break
+                if len(sm_dict['faces']) == 0:
+                    model_dict['shade_meshes'].pop(smi)
+
+    @staticmethod
+    def _clean_irrational_geo_with_shade(geo_obj_dicts):
+        """Clean irrational Face3Ds out of a list of honeybee geometry objects."""
+        Model._clean_irrational_face3ds(geo_obj_dicts)
+        for f_dict in geo_obj_dicts:
+            if 'outdoor_shades' in f_dict and f_dict['outdoor_shades'] is not None:
+                Model._clean_irrational_face3ds(f_dict['outdoor_shades'])
+            if 'indoor_shades' in f_dict and f_dict['indoor_shades'] is not None:
+                Model._clean_irrational_face3ds(f_dict['indoor_shades'])
+
+    @staticmethod
+    def _clean_irrational_face3ds(geo_obj_dicts):
+        """Clean irrational Face3Ds out of a list of honeybee geometry objects."""
+        for fi in range(len(geo_obj_dicts) - 1, -1, -1):
+            f_dict = geo_obj_dicts[fi]
+            face_3d = f_dict['geometry']
+            if len(face_3d['boundary']) < 3:
+                geo_obj_dicts.pop(fi)
+                continue
+            elif 'holes' in face_3d:
+                face_3d['holes'] = [h for h in face_3d['holes'] if len(h) >= 3]
+
     @staticmethod
     def conversion_factor_to_meters(units):
         """Get the conversion factor to meters based on input units.

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/shade.py

@@ -86,16 +86,9 @@ class Shade(_Base):
             assert data['type'] == 'Shade', 'Expected Shade dictionary. ' \
                 'Got {}.'.format(data['type'])
 
-            # remove any invalid holes from the geometry
-            geo_dict = data['geometry']
-            if 'holes' in geo_dict and geo_dict['holes'] is not None:
-                for i, hole_list in enumerate(geo_dict['holes']):
-                    if len(hole_list) < 3:
-                        geo_dict['holes'].pop(i)
-
             # serialize the dictionary to an object
-            is_detached = data['is_detached'] if 'is_detached' in data else False
-            shade = cls(data['identifier'], Face3D.from_dict(geo_dict), is_detached)
+            is_det = data['is_detached'] if 'is_detached' in data else False
+            shade = cls(data['identifier'], Face3D.from_dict(data['geometry']), is_det)
             if 'display_name' in data and data['display_name'] is not None:
                 shade.display_name = data['display_name']
             if 'user_data' in data and data['user_data'] is not None:

{honeybee_core-1.62.12.dist-info → honeybee_core-1.64.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: honeybee-core
-Version: 1.62.12
+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.62.12.dist-info → honeybee_core-1.64.0.dist-info}/RECORD

@@ -4,24 +4,24 @@ honeybee/_base.py,sha256=11TweR_0YJFv5ma1ttN2bs6FW_RlC3hNTjhhjvqXDB0,13181
 honeybee/_basewithshade.py,sha256=SXCWZ-4do6_Z-bZpVFidUINbylVyjwpkY2TIJE28Vuw,12943
 honeybee/_lockable.py,sha256=jmTVsXEWmYyEHpL3WsQZ_ItGOVVlJht1z3NFn07DIp0,3707
 honeybee/altnumber.py,sha256=nVXIvji9YDpy_I37oG41-rkPDx5QLplW9B2RYRCNeoA,1002
-honeybee/aperture.py,sha256=MheeMEaIDtilVu37sCeov-Rw5N_cnd2dvH-zAvxns0g,45838
+honeybee/aperture.py,sha256=Kegu9rPZtRhezwsJwqVz74jxepoTmGnzzLJ3D1xUfmc,45512
 honeybee/boundarycondition.py,sha256=ys3kgMqgeJDBMLpXwSgwNBwvKMRz-LbCtLiL9tiOXS0,13777
 honeybee/checkdup.py,sha256=8q5p4tD3S4dl69jcURQhppeajJ_pYXRBlA48zTOoAGI,8221
 honeybee/colorobj.py,sha256=jhJmTBcLayFKSniW5ASo2-XMKFsW-RBUJilc9v-33ik,13349
 honeybee/config.json,sha256=GAFduJOXTlNcPM4M0fMkSXom5Cb7XZAMYQis2WsNaq0,167
 honeybee/config.py,sha256=auH_ooOyqMKAeBZxUc2NGUehUcYg8SHya98b5hfNlvM,13836
 honeybee/dictutil.py,sha256=cOqkhgJSQ3MviIkqOPv8MRb-N-BeDv07cVcNg7w7nLY,1992
-honeybee/door.py,sha256=XWMb9CL5aZoIisVyzE29uF8k4usfNvl0A0FzrKxFVmc,31732
+honeybee/door.py,sha256=HiMBdT07_KjaGdasT2MvUdDl6XjOM7lhr-DxEy_0oZE,31406
 honeybee/extensionutil.py,sha256=DDQYhM7tFD3avRSCOjwTzLqX9ldUxl5GzY79V3_sATE,9644
-honeybee/face.py,sha256=j8ud3d-8Z8RvDomeiyYTqalu5czgiCMb08Xue_tFRGo,112287
+honeybee/face.py,sha256=BOL2tlFLErxY27euixVWFzL1z-xtABtzvMmLIpzMqcE,111961
 honeybee/facetype.py,sha256=vCtWZKHp21RH-Yzs8zsHJHuFhJvczNh0yFl8wDe_RWY,4489
 honeybee/logutil.py,sha256=2gn-6RcWqFLvwdFzBHPqUwFqTj_R3iwHKALrl-2eL7M,2564
-honeybee/model.py,sha256=WzquyG8denJ5pX-ZiAyXKp1cRXFuIFih-fT7BqiRWL4,181757
+honeybee/model.py,sha256=RgD5JsxESt1JjmFanJZ4Vu5gQAHTXLMmtP5R0M9vL2Q,195385
 honeybee/orientation.py,sha256=GogGblASW9OU-fobfDaQ7w5yRbEAFdJJuHwg2fadhKI,5046
 honeybee/properties.py,sha256=ok976fbUdXzLDR2XiPNf8Q5ejfOM-PArqm5CVUbFiCc,34316
-honeybee/room.py,sha256=ec8DIebXfAc9A4f5oVcKCrF-ZR0loFvNgB1AZ7sXkw8,163195
+honeybee/room.py,sha256=ZrjABLErBTdTHcDRvPdt4W8-0REyPjQLtnu0rnrML0U,168284
 honeybee/search.py,sha256=KOIeQjYdj0yhRWPmF5kiFiH8Ei0WbzuiU-capnwYVeM,5060
-honeybee/shade.py,sha256=HwLkOqvPpluLMXzicWXmKl4fMVJHmkqqehntT69e00Q,21026
+honeybee/shade.py,sha256=2zuW1lR5wfe-UyAosuCX-3tII6CKONq7wt8Ac_jXU6c,20698
 honeybee/shademesh.py,sha256=oldugnwhu-ibX9f0hfxpO-DvgM8U7S-dYwUjBSVzo4g,13273
 honeybee/typing.py,sha256=E8-HrCB9cSoqhFR6zcFXhrAlQRAFw_sxHGdobB8Lre8,20051
 honeybee/units.py,sha256=_qG_G5b9hdqjpyVOpGdIYCB6k8VKYjcxSJn1St-7Xjc,3204
@@ -40,9 +40,9 @@ honeybee/writer/model.py,sha256=N7F_jksf-5TrdVecuxTaFWxnPVFLmQs7k8g27TsdB7Q,177
 honeybee/writer/room.py,sha256=kFghgStTU1SEJSLigXB0VjOWhZtgs4uXuAqdwd4yRQo,174
 honeybee/writer/shade.py,sha256=EpgX-vMc-s21TnMvNWvWTKyT8iAnxu1nFVXzjY1oyF8,177
 honeybee/writer/shademesh.py,sha256=Y41bLogJ7dwpvMe5cAWVRDRVqJEwo9e5hFJQjlt6UX8,189
-honeybee_core-1.62.12.dist-info/licenses/LICENSE,sha256=hIahDEOTzuHCU5J2nd07LWwkLW7Hko4UFO__ffsvB-8,34523
-honeybee_core-1.62.12.dist-info/METADATA,sha256=iEGta_mCYJAxA0h2_6GCyt8pRkfzV99UE3vR10Nrvyc,3730
-honeybee_core-1.62.12.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-honeybee_core-1.62.12.dist-info/entry_points.txt,sha256=r3YqOm40goBroH3ccUhpwQjvTwu10JWLd0HIRHI1J8E,47
-honeybee_core-1.62.12.dist-info/top_level.txt,sha256=8ve7puCRLUA9XDEGc1Mcs-UX9sFjpPV8MeTaIMwQ_Tg,9
-honeybee_core-1.62.12.dist-info/RECORD,,
+honeybee_core-1.64.0.dist-info/licenses/LICENSE,sha256=hIahDEOTzuHCU5J2nd07LWwkLW7Hko4UFO__ffsvB-8,34523
+honeybee_core-1.64.0.dist-info/METADATA,sha256=RlL15eO292imJELxLIkC81hR94wrn3_qeGxIxqEGGiM,3729
+honeybee_core-1.64.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+honeybee_core-1.64.0.dist-info/entry_points.txt,sha256=r3YqOm40goBroH3ccUhpwQjvTwu10JWLd0HIRHI1J8E,47
+honeybee_core-1.64.0.dist-info/top_level.txt,sha256=8ve7puCRLUA9XDEGc1Mcs-UX9sFjpPV8MeTaIMwQ_Tg,9
+honeybee_core-1.64.0.dist-info/RECORD,,