honeybee-radiance-postprocess 0.4.417__py2.py3-none-any.whl → 0.4.419__py2.py3-none-any.whl

honeybee_radiance_postprocess/cli/__init__.py

@@ -1,6 +1,5 @@
 """Modules for post-processing simulation outputs."""
 import click
-import logging
 
 from honeybee.cli import main
 from .grid import grid
@@ -8,9 +7,7 @@ from .mtxop import mtxop
 from .postprocess import post_process
 from .schedule import schedule
 from .translate import translate
-
-
-_logger = logging.getLogger(__name__)
+from .viewfactor import view_factor
 
 
 # command group for all postprocess extension commands.
@@ -26,6 +23,7 @@ postprocess.add_command(mtxop)
 postprocess.add_command(post_process, name='post-process')
 postprocess.add_command(schedule)
 postprocess.add_command(translate)
+postprocess.add_command(view_factor)
 
 # add postprocess sub-commands to honeybee CLI
 main.add_command(postprocess)

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/cli/viewfactor.py

@@ -0,0 +1,150 @@
+"""Commands to compute view factors to geometry."""
+import click
+import os
+import sys
+import logging
+import math
+import numpy as np
+
+from honeybee_radiance.config import folders
+
+from honeybee_radiance_command.rcontrib import Rcontrib, RcontribOptions
+from honeybee_radiance_command._command_util import run_command
+
+from ladybug.futil import preparedir
+
+from honeybee_radiance_postprocess.reader import binary_to_array
+
+_logger = logging.getLogger(__name__)
+
+
+@click.group(help='Commands to compute view factors to geometry.')
+def view_factor():
+    pass
+
+
+@view_factor.command('contrib')
+@click.argument(
+    'octree', type=click.Path(exists=True, file_okay=True, resolve_path=True)
+)
+@click.argument(
+    'sensor-grid', type=click.Path(exists=True, file_okay=True, resolve_path=True)
+)
+@click.argument(
+    'modifiers', type=click.Path(exists=True, file_okay=True, resolve_path=True)
+)
+@click.option(
+    '--ray-count', type=click.INT, default=6, show_default=True,
+    help='The number of rays to be equally distributed over a sphere to compute '
+    'the view factor for each of the input sensors.'
+)
+@click.option(
+    '--rad-params', show_default=True, help='Radiance parameters.'
+)
+@click.option(
+    '--rad-params-locked', show_default=True, help='Protected Radiance parameters. '
+    'These values will overwrite user input rad parameters.'
+)
+@click.option(
+    '--folder', default='.', help='Output folder into which the modifier and '
+    'octree files will be written.'
+)
+@click.option(
+    '--name', default='view_factor', help='File name of the view factor file.'
+)
+def rcontrib_command_with_view_postprocess(
+        octree, sensor_grid, modifiers, ray_count, rad_params, rad_params_locked,
+        folder, name
+):
+    """Run rcontrib to get spherical view factors from a sensor grid.
+
+    This command is similar to the one in honeybee-radiance, but the
+    post-processing is using NumPy.
+
+    \b
+    Args:
+        octree: Path to octree file.
+        sensor-grid: Path to sensor grid file.
+        modifiers: Path to modifiers file.
+    """
+    try:
+        # create the directory if it's not there
+        if not os.path.isdir(folder):
+            preparedir(folder)
+
+        # generate the ray vectors to be used in the view factor calculation
+        if ray_count == 6:
+            rays = ((1, 0, 0), (0, 1, 0), (0, 0, 1), (-1, 0, 0), (0, -1, 0), (0, 0, -1))
+        else:
+            rays = _fibonacci_spiral(ray_count)
+        ray_str = [' {} {} {}\n'.format(*ray) for ray in rays]
+
+        # create a new .pts file with the view vectors
+        ray_file = os.path.abspath(os.path.join(folder, '{}.pts'.format(name)))
+        total_rays = 0
+        with open(sensor_grid) as sg_file:
+            with open(ray_file, 'w') as r_file:
+                for line in sg_file:
+                    for ray in ray_str:
+                        try:
+                            r_file.write(' '.join(line.split()[:3]) + ray)
+                            total_rays += 1
+                        except Exception:
+                            pass  # we are at the end of the file
+
+        # set up the Rcontrib options
+        options = RcontribOptions()
+        if rad_params:  # parse input radiance parameters
+            options.update_from_string(rad_params.strip())
+        if rad_params_locked:  # overwrite input values with protected ones
+            options.update_from_string(rad_params_locked.strip())
+        # overwrite specific options that would otherwise break the command
+        options.M = modifiers
+        options.update_from_string('-I -V- -y {}'.format(total_rays))
+
+        # create the rcontrib command and run it
+        mtx_file = os.path.abspath(os.path.join(folder, '{}.mtx'.format(name)))
+        rcontrib = Rcontrib(options=options, octree=octree, sensors=ray_file)
+        cmd = rcontrib.to_radiance().replace('\\', '/')
+        cmd = '{} | rmtxop -ff - -c .333 .333 .334 > "{}"'.format(cmd, mtx_file.replace('\\', '/'))
+        run_command(cmd, env=folders.env)
+
+        # load the resulting matrix and process the results into view factors
+        array = binary_to_array(mtx_file)
+        view_fac_mtx = []
+        for i in range(0, len(array), ray_count):
+            sens_chunk = array[i:i+ray_count]
+            s_facs = np.sum(sens_chunk, axis=0) / (math.pi * ray_count)
+            view_fac_mtx.append(s_facs)
+
+        np.save(os.path.join(folder, '{}'.format(name)), view_fac_mtx)
+
+    except Exception:
+        _logger.exception('Failed to compute view factor contributions.')
+        sys.exit(1)
+    else:
+        sys.exit(0)
+
+
+def _fibonacci_spiral(point_count=24):
+    """Get points distributed uniformly across a unit spherical surface.
+
+    Args:
+        point_count: Integer for the number of points to be distributed.
+
+    Returns:
+        List of tuple, each with 3 values representing the XYZ coordinates of
+        the points that were generated.
+    """
+    points = []
+    phi = math.pi * (3. - math.sqrt(5.))
+
+    for i in range(point_count):
+        y = 1 - (i / float(point_count - 1)) * 2
+        radius = math.sqrt(1 - y * y)
+        theta = phi * i
+        x = math.cos(theta) * radius
+        z = math.sin(theta) * radius
+        points.append((x, y, z))
+
+    return points

{honeybee_radiance_postprocess-0.4.417.dist-info → honeybee_radiance_postprocess-0.4.419.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: honeybee-radiance-postprocess
-Version: 0.4.417
+Version: 0.4.419
 Summary: Postprocessing of Radiance results and matrices
 Home-page: https://github.com/ladybug-tools/honeybee-radiance-postprocess
 Author: Ladybug Tools

{honeybee_radiance_postprocess-0.4.417.dist-info → honeybee_radiance_postprocess-0.4.419.dist-info}/RECORD

@@ -14,8 +14,8 @@ honeybee_radiance_postprocess/reader.py,sha256=6myKzfGC1pO8zPixg1kKrKjPihHabTKUh
 honeybee_radiance_postprocess/type_hints.py,sha256=4R0kZgacQrqzoh8Tq7f8MVzUDzynV-C_jlh80UV6GPE,1122
 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=4RkpR91GPXWatDE4I_27ce-N4FwolQoO6WO7H24DMXE,777
-honeybee_radiance_postprocess/cli/abnt.py,sha256=IEJdGi4fkLD75C833CVpk5WimMm7PVMGYV3QBNgVOGE,12785
+honeybee_radiance_postprocess/cli/__init__.py,sha256=PVfwkuPFl4TnvQt8ovVm01JK0Alon81BaY-0tshAXyg,795
+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
@@ -24,13 +24,14 @@ honeybee_radiance_postprocess/cli/schedule.py,sha256=6uIy98Co4zm-ZRcELo4Lfx_aN3l
 honeybee_radiance_postprocess/cli/translate.py,sha256=18zkcGeRZALJ5Z82NEB3XZ-iEX2cHyneobGWV-IXWE0,6789
 honeybee_radiance_postprocess/cli/two_phase.py,sha256=xA6ayPv26DM5fuMkLhBMYGklf_j5ymowmncwJGXRgo8,7034
 honeybee_radiance_postprocess/cli/util.py,sha256=Be9cGmYhcV2W37ma6SgQPCWCpWLLLlroxRYN_l58kY0,4077
+honeybee_radiance_postprocess/cli/viewfactor.py,sha256=kU36YRzLya5PReYREjTfw3zOcWKHYZjVlVclyuR7Cqk,5245
 honeybee_radiance_postprocess/results/__init__.py,sha256=1agBQbfT4Tf8KqSZzlfKYX8MeZryY4jJ1KB4HWqaDDk,182
 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.417.dist-info/LICENSE,sha256=hIahDEOTzuHCU5J2nd07LWwkLW7Hko4UFO__ffsvB-8,34523
-honeybee_radiance_postprocess-0.4.417.dist-info/METADATA,sha256=HqKdr7FnplUd51XeDU0Co6q-fpeI928ntRVJto3e5vA,2245
-honeybee_radiance_postprocess-0.4.417.dist-info/WHEEL,sha256=unfA4MOaH0icIyIA5oH6E2sn2Hq5zKtLlHsWapZGwes,110
-honeybee_radiance_postprocess-0.4.417.dist-info/entry_points.txt,sha256=gFtVPx6UItXt27GfEZZO00eOZChJJEL6JwGSAB_O3rs,96
-honeybee_radiance_postprocess-0.4.417.dist-info/top_level.txt,sha256=4-sFbzy7ewP2EDqJV3jeFlAFx7SuxtoBBELWaKAnLdA,30
-honeybee_radiance_postprocess-0.4.417.dist-info/RECORD,,
+honeybee_radiance_postprocess-0.4.419.dist-info/LICENSE,sha256=hIahDEOTzuHCU5J2nd07LWwkLW7Hko4UFO__ffsvB-8,34523
+honeybee_radiance_postprocess-0.4.419.dist-info/METADATA,sha256=T_Z-_o7VPTM0_PzjEIrSnpQ_OnAo8NjMPup9sQ3ccmE,2245
+honeybee_radiance_postprocess-0.4.419.dist-info/WHEEL,sha256=unfA4MOaH0icIyIA5oH6E2sn2Hq5zKtLlHsWapZGwes,110
+honeybee_radiance_postprocess-0.4.419.dist-info/entry_points.txt,sha256=gFtVPx6UItXt27GfEZZO00eOZChJJEL6JwGSAB_O3rs,96
+honeybee_radiance_postprocess-0.4.419.dist-info/top_level.txt,sha256=4-sFbzy7ewP2EDqJV3jeFlAFx7SuxtoBBELWaKAnLdA,30
+honeybee_radiance_postprocess-0.4.419.dist-info/RECORD,,