honeybee-radiance-postprocess 0.4.418__py2.py3-none-any.whl → 0.4.420__py2.py3-none-any.whl

honeybee_radiance_postprocess/cli/abnt.py

@@ -61,66 +61,133 @@ def abnt_nbr_15575(
             file is used to extract the center points of the sensor grids. It is
             a requirement that the sensor grids have Meshes.
     """
-    def find_surrounding_points(x, y, x_coords, y_coords):
-        """Find the four nearest points and return the minimum and maximum
-        x and y values."""
-        # calculate Euclidean distances
-        distances = np.sqrt((x_coords - x)**2 + (y_coords - y)**2)
-        # get the four nearest points
-        if len(distances) < 4:
-            # if the grid for some reason has less than four sensors
-            nearest_indices = np.argsort(distances)[:len(distances)]
+    def find_surrounding_points(points, values, new_point):
+        """Find the four surrounding points for bilinear interpolation.
+        
+        Args:
+            points: 2D array of points, shape.
+            values: 1D array of values at the points.
+            new_point: 1D array of the point to interpolate.
+        
+        Returns:
+            tuple: (surrounding_points, surrounding_values) and their counts.
+        """
+        x, y = new_point
+        lower_left = None
+        upper_left = None
+        lower_right = None
+        upper_right = None
+
+        for i, (px, py) in enumerate(points):
+            if px <= x and py <= y:
+                if lower_left is None or (px >= lower_left[0] and py >= lower_left[1]):
+                    lower_left = (px, py, values[i])
+            if px <= x and py >= y:
+                if upper_left is None or (px >= upper_left[0] and py <= upper_left[1]):
+                    upper_left = (px, py, values[i])
+            if px >= x and py >= y:
+                if upper_right is None or (px <= upper_right[0] and py <= upper_right[1]):
+                    upper_right = (px, py, values[i])
+            if px >= x and py <= y:
+                if lower_right is None or (px <= lower_right[0] and py >= lower_right[1]):
+                    lower_right = (px, py, values[i])
+
+        surrounding_points = []
+        surrounding_values = []
+        if lower_left:
+            surrounding_points.append(lower_left[:2])
+            surrounding_values.append(lower_left[2])
+        if upper_left:
+            surrounding_points.append(upper_left[:2])
+            surrounding_values.append(upper_left[2])
+        if upper_right:
+            surrounding_points.append(upper_right[:2])
+            surrounding_values.append(upper_right[2])
+        if lower_right:
+            surrounding_points.append(lower_right[:2])
+            surrounding_values.append(lower_right[2])
+
+        return np.array(surrounding_points), np.array(surrounding_values)
+
+    def bilinear_interpolate(surrounding_points, surrounding_values, new_point):
+        """Perform bilinear interpolation given four surrounding points.
+        
+        Args:
+            surrounding_points: 2D array of points.
+            surrounding_values: 1D array of values at the points.
+            new_point: 1D array of the point to interpolate.
+        
+        Returns:
+            Interpolated value at the new_point.
+        """
+        x1, y1 = surrounding_points[0]
+        x2, y2 = surrounding_points[2]
+        x, y = new_point
+
+        fQ11 = surrounding_values[0]
+        fQ21 = surrounding_values[3]
+        fQ12 = surrounding_values[1]
+        fQ22 = surrounding_values[2]
+
+        interpolated_value = (
+            fQ11 * (x2 - x) * (y2 - y) +
+            fQ21 * (x - x1) * (y2 - y) +
+            fQ12 * (x2 - x) * (y - y1) +
+            fQ22 * (x - x1) * (y - y1)
+        ) / ((x2 - x1) * (y2 - y1))
+
+        return interpolated_value
+
+    def inverse_distance_weighting(points, values, new_point, n_nearest=4):
+        """Perform inverse distance weighting interpolation.
+        
+        Args:
+            points: 2D array of points.
+            values: 1D array of values at the points
+            new_point: 1D array of the point to interpolate.
+            n_nearest: Number of nearest points to consider for interpolation.
+        
+        Returns:
+            Interpolated value at the new_point.
+        """
+        distances = np.linalg.norm(points - new_point, axis=1)
+        nearest_indices = np.argsort(distances)[:min(n_nearest, len(points))]
+
+        nearest_values = values[nearest_indices]
+        nearest_distances = distances[nearest_indices]
+
+        if np.any(nearest_distances == 0):
+            # if the new point coincides with an existing point, return its value
+            return nearest_values[nearest_distances == 0][0]
+
+        weights = 1 / nearest_distances
+        weights /= weights.sum() # normalize weights
+        return np.dot(weights, nearest_values)
+
+    def perform_interpolation(x, y, x_coords, y_coords, pit_values):
+        points = np.column_stack((x_coords, y_coords))
+        values = np.array(pit_values)
+        new_point = np.array([x, y])
+
+        surrounding_points, surrounding_values = \
+            find_surrounding_points(points, values, new_point)
+
+        if len(surrounding_points) == 4:
+            interpolated_value = \
+                bilinear_interpolate(surrounding_points,
+                                     surrounding_values, new_point)
         else:
-            nearest_indices = np.argsort(distances)[:4]
-        x_values = x_coords[nearest_indices]
-        y_values = y_coords[nearest_indices]
-        x1, x2 = min(x_values), max(x_values)
-        y1, y2 = min(y_values), max(y_values)
-
-        return x1, x2, y1, y2
-
-    def get_value(x, y, x_coords, y_coords, values):
-        tolerance = 0.001
-        index = np.where((np.abs(x_coords - x) <= tolerance) & (np.abs(y_coords - y) <= tolerance))
-        return values[index][0]
-
-    def perform_interpolation(x, y, x_coords, y_caoords, pit_values):
-        x1, x2, y1, y2 = find_surrounding_points(x, y, x_coords, y_coords)
-
-        # extract the illuminance values at the surrounding points
-        f_Q11 = get_value(x1, y1, x_coords, y_coords, pit_values) # bottom-left
-        f_Q21 = get_value(x2, y1, x_coords, y_coords, pit_values) # bottom-right
-        f_Q12 = get_value(x1, y2, x_coords, y_coords, pit_values) # top-left
-        f_Q22 = get_value(x2, y2, x_coords, y_coords, pit_values) # top-right
-
-        # edge cases
-        if x == x1 and y == y1:
-            f_xy = f_Q11
-        elif x == x2 and y == y1:
-            f_xy = f_Q21
-        elif x == x1 and y == y2:
-            f_xy = f_Q12
-        elif x == x2 and y == y2:
-            f_xy = f_Q22
-        elif x1 == x2:
-            # linear interpolation in y direction
-            f_xy = f_Q11 + (f_Q12 - f_Q11) * (y - y1) / (y2 - y1)
-        elif y1 == y2:
-            # linear interpolation in x direction
-            f_xy = f_Q11 + (f_Q21 - f_Q11) * (x - x1) / (x2 - x1)
-        else:
-            # perform bilinear interpolation
-            f_xy = (f_Q11 * (x2 - x) * (y2 - y) +
-                    f_Q21 * (x - x1) * (y2 - y) +
-                    f_Q12 * (x2 - x) * (y - y1) +
-                    f_Q22 * (x - x1) * (y - y1)) / ((x2 - x1) * (y2 - y1))
+            interpolated_value = \
+                inverse_distance_weighting(
+                    points, values, new_point, n_nearest=4)
 
-        return f_xy
+        return interpolated_value
 
     try:
         folder = Path(folder)
         hb_model: Model = Model.from_file(model_file)
-        grouped_rooms, floor_heights = Room.group_by_floor_height(hb_model.rooms)
+        grouped_rooms, floor_heights = Room.group_by_floor_height(
+            hb_model.rooms)
 
         # pick the first group >= to ground level
         for gr, fh in zip(grouped_rooms, floor_heights):
@@ -157,14 +224,20 @@ def abnt_nbr_15575(
             sub_output = []
             for grid_info in grids_info:
                 pit_values = \
-                    np.loadtxt(res_folder.joinpath(f'{grid_info["full_id"]}.res'))
+                    np.loadtxt(res_folder.joinpath(
+                        f'{grid_info["full_id"]}.res'))
                 sensor_grid = sg_full_identifier[grid_info['full_id']]
                 sensor_points = np.array(
-                    [[sensor.pos[0], sensor.pos[1]] for sensor in sensor_grid.sensors])
+                    [[sensor.pos[0], sensor.pos[1], sensor.pos[2]]
+                     for sensor in sensor_grid.sensors]
+                )
 
                 x_coords = sensor_points[:, 0]
                 y_coords = sensor_points[:, 1]
-                room = hb_model.rooms_by_identifier([sensor_grid.room_identifier])[0]
+                z_coords = sensor_points[:, 2]
+
+                room = hb_model.rooms_by_identifier(
+                    [sensor_grid.room_identifier])[0]
 
                 pof_sensor_grid = \
                     pof_sensor_grids.get(grid_info['full_id'], None)
@@ -175,25 +248,30 @@ def abnt_nbr_15575(
                             room.horizontal_floor_boundaries(), 0.05
                         )[0]
                         if floor_face.is_convex:
-                            pof_sensor_grids[grid_info['full_id']] = \
-                                floor_face.centroid + Vector3D(0, 0, 0.75)
+                            centroid = floor_face.centroid
                         else:
-                            pof_sensor_grids[grid_info['full_id']] = \
-                                floor_face.pole_of_inaccessibility(0.01) + Vector3D(0, 0, 0.75)
+                            centroid = floor_face.pole_of_inaccessibility(0.01)
+                        dz = np.mean(z_coords) - centroid.z
+                        pof_sensor_grids[grid_info['full_id']] = \
+                            centroid + Vector3D(0, 0, dz)
                     else:
-                        faces_3d = [Face3D(face_vertices) for face_vertices in sensor_grid.mesh.face_vertices]
-                        face_3d_union = Face3D.join_coplanar_faces(faces_3d, 0.05)
+                        faces_3d = [
+                            Face3D(face_vertices) for face_vertices in sensor_grid.mesh.face_vertices]
+                        face_3d_union = Face3D.join_coplanar_faces(
+                            faces_3d, 0.05)
                         assert len(face_3d_union) == 1
                         if face_3d_union[0].is_convex:
                             centroid = face_3d_union[0].centroid
                             pof_sensor_grids[grid_info['full_id']] = centroid
                         else:
-                            pof = face_3d_union[0].pole_of_inaccessibility(0.01)
+                            pof = face_3d_union[0].pole_of_inaccessibility(
+                                0.01)
                             pof_sensor_grids[grid_info['full_id']] = pof
 
                 x = pof_sensor_grids[grid_info['full_id']].x
                 y = pof_sensor_grids[grid_info['full_id']].y
-                f_xy = perform_interpolation(x, y, x_coords, y_coords, pit_values)
+                f_xy = perform_interpolation(
+                    x, y, x_coords, y_coords, pit_values)
 
                 if room in ground_level_rooms:
                     minimo = 48
@@ -204,7 +282,7 @@ def abnt_nbr_15575(
                     level = 'Superior'
                 elif f_xy >= 90:
                     level = 'Intermediário'
-                elif f_xy >= minimo: # add check for ground floor (48 lux)
+                elif f_xy >= minimo:  # add check for ground floor (48 lux)
                     level = 'Mínimo'
                 else:
                     level = 'Não atende'
@@ -232,19 +310,23 @@ def abnt_nbr_15575(
                     }
                 )
 
-                conditions = [pit_values >= 120, pit_values >= 90, pit_values >= 60, pit_values < 60]
+                conditions = [pit_values >= 120, pit_values >=
+                              90, pit_values >= 60, pit_values < 60]
                 conditions_values = [3, 2, 1, 0]
                 illuminance_level = np.select(conditions, conditions_values)
 
-                ill_level_file = illuminance_levels_folder.joinpath(_subfolder, f'{grid_info["full_id"]}.res')
+                ill_level_file = illuminance_levels_folder.joinpath(
+                    _subfolder, f'{grid_info["full_id"]}.res')
                 ill_level_file.parent.mkdir(parents=True, exist_ok=True)
                 np.savetxt(ill_level_file, illuminance_level, fmt='%d')
 
-                grids_info_file = illuminance_levels_folder.joinpath(_subfolder, 'grids_info.json')
+                grids_info_file = illuminance_levels_folder.joinpath(
+                    _subfolder, 'grids_info.json')
                 grids_info_file.write_text(json.dumps(grids_info, indent=2))
 
                 vis_data = metric_info_dict[_subfolder]
-                vis_metadata_file = illuminance_levels_folder.joinpath(_subfolder, 'vis_metadata.json')
+                vis_metadata_file = illuminance_levels_folder.joinpath(
+                    _subfolder, 'vis_metadata.json')
                 vis_metadata_file.write_text(json.dumps(vis_data, indent=4))
 
             summary_output[_subfolder] = sub_output

{honeybee_radiance_postprocess-0.4.418.dist-info → honeybee_radiance_postprocess-0.4.420.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: honeybee-radiance-postprocess
-Version: 0.4.418
+Version: 0.4.420
 Summary: Postprocessing of Radiance results and matrices
 Home-page: https://github.com/ladybug-tools/honeybee-radiance-postprocess
 Author: Ladybug Tools
@@ -13,7 +13,7 @@ Classifier: License :: OSI Approved :: GNU General Public License v3 (GPLv3)
 Classifier: Operating System :: OS Independent
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: honeybee-radiance (==1.66.93)
+Requires-Dist: honeybee-radiance (==1.66.94)
 Requires-Dist: numpy (>=1.21.6)
 
 [![Build Status](https://github.com/ladybug-tools/honeybee-radiance-postprocess/actions/workflows/ci.yaml/badge.svg)](https://github.com/ladybug-tools/honeybee-radiance-postprocess/actions)

{honeybee_radiance_postprocess-0.4.418.dist-info → honeybee_radiance_postprocess-0.4.420.dist-info}/RECORD

@@ -15,7 +15,7 @@ honeybee_radiance_postprocess/type_hints.py,sha256=4R0kZgacQrqzoh8Tq7f8MVzUDzynV
 honeybee_radiance_postprocess/util.py,sha256=-J5k1dhvyYJkb42jvTS_xxtokfGbmcucVPXdMWU1jUk,5098
 honeybee_radiance_postprocess/vis_metadata.py,sha256=7ywIgdiuNKcctxifhpy7-Q2oaSX2ngQBeA0Kh7q1Gg0,1780
 honeybee_radiance_postprocess/cli/__init__.py,sha256=PVfwkuPFl4TnvQt8ovVm01JK0Alon81BaY-0tshAXyg,795
-honeybee_radiance_postprocess/cli/abnt.py,sha256=IEJdGi4fkLD75C833CVpk5WimMm7PVMGYV3QBNgVOGE,12785
+honeybee_radiance_postprocess/cli/abnt.py,sha256=GNLmVVrEQ-1oKr5ZmBllY-KODhgJPjLVidQ_dQMcpFk,15537
 honeybee_radiance_postprocess/cli/grid.py,sha256=6peLEAPVe-iw05_wdRpFruZLqO8myvC-_QT5W1q5sk8,10677
 honeybee_radiance_postprocess/cli/leed.py,sha256=QBR6AMJJWuZ0TevyMi2tXCWMLdS-ZSqtVTZDgqxwa7M,3112
 honeybee_radiance_postprocess/cli/mtxop.py,sha256=UZJnjNpPjDmShy1-Mxos4H2vTUqk_yP3ZyaC1_LLFeI,5015
@@ -29,9 +29,9 @@ honeybee_radiance_postprocess/results/__init__.py,sha256=1agBQbfT4Tf8KqSZzlfKYX8
 honeybee_radiance_postprocess/results/annual_daylight.py,sha256=ohysFt4OWlWUn_IvM6pjmiQcRTq_x5b998Iv0pw8AEQ,34964
 honeybee_radiance_postprocess/results/annual_irradiance.py,sha256=5zwrr4MNeHUebbSRpSBbscPOZUs2AHmYCQfIIbdYImY,8298
 honeybee_radiance_postprocess/results/results.py,sha256=GwyjIYljaCShx1b6NlYUBcU_gHhckmLcCMNrQ6HVDdE,53507
-honeybee_radiance_postprocess-0.4.418.dist-info/LICENSE,sha256=hIahDEOTzuHCU5J2nd07LWwkLW7Hko4UFO__ffsvB-8,34523
-honeybee_radiance_postprocess-0.4.418.dist-info/METADATA,sha256=EaZPDjNDUhsc3qgyqLJI1oLDJd010yi0yY0x3egJcdg,2245
-honeybee_radiance_postprocess-0.4.418.dist-info/WHEEL,sha256=unfA4MOaH0icIyIA5oH6E2sn2Hq5zKtLlHsWapZGwes,110
-honeybee_radiance_postprocess-0.4.418.dist-info/entry_points.txt,sha256=gFtVPx6UItXt27GfEZZO00eOZChJJEL6JwGSAB_O3rs,96
-honeybee_radiance_postprocess-0.4.418.dist-info/top_level.txt,sha256=4-sFbzy7ewP2EDqJV3jeFlAFx7SuxtoBBELWaKAnLdA,30
-honeybee_radiance_postprocess-0.4.418.dist-info/RECORD,,
+honeybee_radiance_postprocess-0.4.420.dist-info/LICENSE,sha256=hIahDEOTzuHCU5J2nd07LWwkLW7Hko4UFO__ffsvB-8,34523
+honeybee_radiance_postprocess-0.4.420.dist-info/METADATA,sha256=Wk_YuV0iIsxYoLMUY9gpJYNHZoed872Ej9o86dNQNDU,2245
+honeybee_radiance_postprocess-0.4.420.dist-info/WHEEL,sha256=unfA4MOaH0icIyIA5oH6E2sn2Hq5zKtLlHsWapZGwes,110
+honeybee_radiance_postprocess-0.4.420.dist-info/entry_points.txt,sha256=gFtVPx6UItXt27GfEZZO00eOZChJJEL6JwGSAB_O3rs,96
+honeybee_radiance_postprocess-0.4.420.dist-info/top_level.txt,sha256=4-sFbzy7ewP2EDqJV3jeFlAFx7SuxtoBBELWaKAnLdA,30
+honeybee_radiance_postprocess-0.4.420.dist-info/RECORD,,