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

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

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

@@ -161,11 +161,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 +184,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 +253,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 +272,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 +295,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',
@@ -3685,6 +3709,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_core-1.62.12 → honeybee_core-1.63.0}/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 → honeybee_core-1.63.0/honeybee_core.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: honeybee-core
-Version: 1.62.12
+Version: 1.63.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 → honeybee_core-1.63.0}/tests/model_test.py

@@ -379,7 +379,7 @@ def test_model_add_prefix():
 def test_reset_room_ids():
     """Test the reset_room_ids method."""
     model_json = './tests/json/model_with_adiabatic.hbjson'
-    parsed_model = Model.from_hbjson(model_json)
+    parsed_model = Model.from_hbjson(model_json, cleanup_irrational=True)
 
     new_model = parsed_model.duplicate()
     new_model.reset_room_ids()
@@ -390,7 +390,7 @@ def test_reset_room_ids():
 def test_reset_ids():
     """Test the reset_ids method."""
     model_json = './tests/json/model_with_adiabatic.hbjson'
-    parsed_model = Model.from_hbjson(model_json)
+    parsed_model = Model.from_hbjson(model_json, cleanup_irrational=True)
 
     new_model = parsed_model.duplicate()
     new_model.reset_ids(True)
@@ -402,7 +402,7 @@ def test_reset_ids():
 def test_offset_aperture_edges():
     """Test the Face offset_aperture_edges method."""
     model_json = './tests/json/room_for_window_offset.hbjson'
-    parsed_model = Model.from_hbjson(model_json)
+    parsed_model = Model.from_hbjson(model_json, cleanup_irrational=True)
     test_room = parsed_model.rooms[0]
     test_face = test_room[1]
 
@@ -1164,6 +1164,75 @@ def test_from_dict_method_extensions():
     assert isinstance(parsed_model, Model)
 
 
+def test_cleanup_irrational():
+    """Test the cleanup_irrational method during serialization."""
+    room = Room.from_box('TinyHouseZone', 5, 10, 3)
+    south_face = room[3]
+    south_face.apertures_by_ratio(0.4, 0.01)
+    south_face.apertures[0].overhang(0.5, indoor=False)
+    south_face.apertures[0].overhang(0.5, indoor=True)
+    south_face.apertures[0].move_shades(Vector3D(0, 0, -0.5))
+    north_face = room[1]
+    door_verts = [Point3D(2, 10, 0.1), Point3D(1, 10, 0.1),
+                  Point3D(1, 10, 2.5), Point3D(2, 10, 2.5)]
+    aperture_verts = [Point3D(4.5, 10, 1), Point3D(2.5, 10, 1),
+                      Point3D(2.5, 10, 2.5), Point3D(4.5, 10, 2.5)]
+    door = Door('FrontDoor', Face3D(door_verts))
+    north_face.add_door(door)
+    aperture = Aperture('FrontAperture', Face3D(aperture_verts))
+    north_face.add_aperture(aperture)
+
+    model = Model('TinyHouse', [room])
+    model_dict = model.to_dict()
+
+    irrational_dict = {
+        'type': 'Model',
+        'identifier': 'irrational_model',
+        'units': 'Meters',
+        'tolerance': 0.001,
+        'angle_tolerance': 1.0,
+        'properties': model_dict['properties'],
+        'rooms': [
+            model_dict['rooms'][0],
+            {
+                'type': 'Room',
+                'identifier': 'irrational_room',
+                'faces': [
+                    {
+                        'type': 'Face',
+                        'identifier': 'irrational_face',
+                        'face_type': 'Wall',
+                        'geometry': {
+                            'type': 'Face3D',
+                            'boundary': [
+                                (0, 0, 0), (0, 0, 1)
+                            ]
+                        },
+                        'apertures': [
+                            {
+                                'type': 'Aperture',
+                                'identifier': 'irrational_aperture',
+                                'geometry': {
+                                    'type': 'Face3D',
+                                    'boundary': [
+                                        (0, 0, 0.2), (0, 0, 0.8)
+                                    ]
+                                }
+                            }
+                        ]
+                    },
+                ]
+            }
+        ]
+    }
+
+    with pytest.raises(ValueError):
+        Model.from_dict(irrational_dict, cleanup_irrational=False)
+
+    clean_model = Model.from_dict(irrational_dict, cleanup_irrational=True)
+    assert len(clean_model.rooms) == 1
+
+
 def test_comparison_report():
     """Test the comparison_report method."""
     room = Room.from_box('TinyHouseZone', 5, 10, 3)