honeybee-radiance 1.66.190__py3-none-any.whl

honeybee_radiance/cli/view.py

@@ -0,0 +1,261 @@
+"""honeybee radiance view commands."""
+import click
+import sys
+import os
+import logging
+import re
+import json
+import shutil
+
+from honeybee_radiance_command.rpict import Rpict, RpictOptions
+from honeybee_radiance_command.pcompos import Pcompos
+from honeybee_radiance_command.pfilt import Pfilt
+from honeybee_radiance_command.getinfo import Getinfo
+
+from honeybee_radiance.view import View
+from honeybee_radiance.config import folders
+
+_logger = logging.getLogger(__name__)
+
+
+@click.group(help='Commands for generating and modifying views.')
+def view():
+    pass
+
+
+@view.command('split-count')
+@click.argument(
+    'view-info-file',
+    type=click.Path(exists=True, file_okay=True, dir_okay=False, resolve_path=True)
+)
+@click.argument('cpu-count', type=int)
+@click.option(
+    '--output-file', '-f', help='Optional file to output the integer for the number '
+    'of times to split the view. By default this will be printed to stdout',
+    type=click.File('w'), default='-', show_default=True
+)
+def split_count_from_cpu_count(view_info_file, cpu_count, output_file):
+    """Get the number of times to split each view in a model using a CPU count.
+
+    \b
+    Args:
+        view_info_file: Input view info file.
+        cpu_count: Number of processes that will be used to run
+            the simulations in parallel.
+    """
+    try:
+        with open(view_info_file) as inf:
+            view_count = len(json.load(inf))
+        opt_split = int(cpu_count / view_count)
+        opt_split = 1 if opt_split == 0 else opt_split
+        output_file.write(str(opt_split))
+    except Exception:
+        _logger.exception('Failed to compute the view split-count from cpu-count.')
+        sys.exit(1)
+    else:
+        sys.exit(0)
+
+
+@view.command('split')
+@click.argument(
+    'view', type=click.Path(
+        exists=True, file_okay=True, dir_okay=False, resolve_path=True)
+)
+@click.argument('count', type=int)
+@click.option(
+    '--skip-overture/--overture', ' /-o', help='Flag to note whether an ambient '
+    'file (.amb) should be generated for an overture calculation before the view is '
+    'split into smaller views. The .amb file will have the same name as the view-file. '
+    'With an overture calculation, the ambient file (aka ambient cache) is first '
+    'populated with values. Thereby ensuring that - when reused to create an image - '
+    'Radiance uses interpolation between already calculated values rather than less '
+    'reliable extrapolation. The overture calculation has comparatively small '
+    'computation time to full rendering but is single core can become time '
+    'consuming in situations with very high numbers of rendering multiprocessors.',
+    default=True, show_default=True
+)
+@click.option(
+    '--resolution', '-r', default=None, type=int, show_default=True,
+    help='An optional integer for the maximum dimension of the image in pixels. '
+    'Specifying a value here will automatically lower the input --count to ensure '
+    'the resulting images can be combined to meet this dimension. If unspecified, '
+    'the --count will always be respected and the resulting images might not be '
+    'combine-able to meet a specific target dimension.'
+)
+@click.option(
+    '--octree', '-oct', help='Octree file for the overture calculation. This must be '
+    'specified when the overture is not skipped.', default=None, show_default=True,
+    type=click.Path(file_okay=True, dir_okay=False, resolve_path=True)
+)
+@click.option(
+    '--rad-params', '-rp', help='Radiance parameters for the overture calculation. '
+    'If unspecified, default rpict paramters will be used.'
+)
+@click.option(
+    '--folder', '-f', help='Output folder.', default='.', show_default=True,
+    type=click.Path(file_okay=False, dir_okay=True, resolve_path=True)
+)
+@click.option(
+    '--log-file', '-log', help='Optional log file to output the name of the newly'
+    ' created views. By default the list will be printed out to stdout',
+    type=click.File('w'), default='-'
+)
+def split_view(view, count, resolution, skip_overture, octree, rad_params,
+               folder, log_file):
+    """Split a radiance view file into smaller views based on count.
+
+    \b
+    Args:
+        view: Full path to input sensor view file.
+        count: Maximum number of sensors in new files. The number will be rounded to
+            closest round number for each file. For example if the input file has 21
+            sensors and input count is set to 5 this command will generate 4 files where
+            the first three files will have 5 sensors and the last file will have 6.
+    """
+    try:
+        # correct the count to meet the target resolution
+        if resolution is not None and resolution % count != 0:
+            while resolution % count != 0:
+                count = count - 1
+
+        # split the view into smaller views
+        view_obj = View.from_file(view)
+        views = view_obj.grid(y_div_count=count)
+        views_info = []
+        for c, v in enumerate(views):
+            name = '%s_%04d' % (view_obj.identifier, c)
+            path = '%s.vf' % name
+            full_path = os.path.join(folder, path)
+            v.to_file(folder, path, mkdir=True)
+            views_info.append({
+                'name': name,
+                'path': path,
+                'full_path': full_path
+            })
+
+        # create the ambient cache file if specified
+        amb_file = os.path.join(folder, os.path.basename(view).replace('.vf', '.amb'))
+        if not skip_overture:
+            options = RpictOptions()
+            if rad_params:
+                options.update_from_string(rad_params.strip())
+            # overwrite default image size to be small for the ambient cache (64 x 64)
+            options.x = 64
+            options.y = 64
+            options.af = amb_file
+
+            # create command and run it to get the .amb file
+            assert octree is not None, \
+                'Octree  must be specified for an overture calculation.'
+            out_file = os.path.join(
+                folder, os.path.basename(view).replace('.vf', '.unf'))
+            rpict = Rpict(options=options, output=out_file, octree=octree, view=view)
+            env = None
+            if folders.env != {}:
+                env = folders.env
+            env = dict(os.environ, **env) if env else None
+            rpict.run(env=env)
+            os.remove(out_file)
+
+        # record all of the view files that were generated
+        log_file.write(json.dumps(views_info))
+    except Exception:
+        _logger.exception('Failed to split view file.')
+        sys.exit(1)
+    else:
+        sys.exit(0)
+
+
+@view.command('merge')
+@click.argument('input-folder', type=click.Path(
+    file_okay=False, dir_okay=True, resolve_path=True))
+@click.argument('base-name', type=str)
+@click.argument('extension', default='.unf', type=str)
+@click.option('--view', '-vf', type=click.Path(
+        exists=False, file_okay=True, dir_okay=False, resolve_path=True),
+        help='Full path to the original view file.'
+)
+@click.option(
+    '--scale-factor', '-s', default=1, type=float, show_default=True,
+    help='A number that will be used to scale the dimensions of the output image '
+    'as it is filtered for anti-aliasing.'
+)
+@click.option('--folder', '-f', help='Optional output folder.',
+              default='.', show_default=True)
+@click.option('--name', '-n', help='Optional output filename. Default is base-name.')
+def merge_view(input_folder, base_name, extension, view, scale_factor, folder, name):
+    """Merge several radiance HDR image files into a single file.
+
+    This command will also perform an anti-aliasing operation on the output and
+    replace the view information in the header of the merged file if a single .vf
+    file is found within the root of the input-folder.
+
+    \b
+    Args:
+        input_folder: Input folder.
+        base_name: File base name. All of the files must start with base name and
+            continue with _ and an integer values.
+        extension: File extension. [Default: .unf]
+    """
+    try:
+        # view is an optional input. Make sure we can handle the case that the view
+        # file doesn't exist
+        view = None if (view and not os.path.isfile(view)) else view
+
+        # get all of the files in the folder with the given extension
+        pattern = r'{}_\d+{}'.format(base_name, extension)
+        images = sorted(f for f in os.listdir(input_folder) if re.match(pattern, f))
+        if len(images) == 0:
+            raise ValueError('Found no files to merge.')
+        name = name or base_name
+
+        # get the new dir name as view name might be group/name
+        dirname = os.path.dirname(os.path.normpath(os.path.join(folder, name)))
+        if dirname and not os.path.exists(dirname):
+            os.makedirs(dirname)
+        temp_output = os.path.join(dirname, name + '_temp.HDR')
+        output_file = os.path.join(dirname, name + '.HDR')
+
+        # set up the pcompos command
+        in_dirname = os.path.normpath(input_folder)
+        pcompos = Pcompos(output=temp_output)
+        pcompos.input = [os.path.join(in_dirname, img) for img in images]
+        pcompos.options.a = 1
+
+        # setup the pfilt command to perform anti-aliasing on the output
+        pfilt = Pfilt(input=temp_output)
+        pfilt.options.r = 0.6
+        if scale_factor != 1:
+            pfilt.options.x = '/{}'.format(scale_factor)
+            pfilt.options.y = '/{}'.format(scale_factor)
+
+        # search for a single .vf in the folder and, if it's found, grab the info
+        views = sorted(f for f in os.listdir(input_folder) if f.endswith('.vf'))
+        if view and len(views) != 1:
+            view_obj = View.from_file(view)
+            getinfo = Getinfo(output=output_file)
+            getinfo.options.a = 'VIEW= {}'.format(view_obj)
+            pfilt.pipe_to = getinfo
+        elif len(views) == 1:  # replace the header with the info in the view
+            view_obj = View.from_file(os.path.join(input_folder, views[0]))
+            getinfo = Getinfo(output=output_file)
+            getinfo.options.a = 'VIEW= {}'.format(view_obj)
+            pfilt.pipe_to = getinfo
+        else:  # just let the output of pfilt be the final output
+            pfilt.output = output_file
+
+        # run the commands in series
+        env = None
+        if folders.env != {}:
+            env = folders.env
+        env = dict(os.environ, **env) if env else None
+        pcompos.run(env)
+        try:
+            pfilt.run(env)
+        except RuntimeError:  # the image was too bright or dark; just use pcompos output
+            shutil.copyfile(temp_output, output_file)
+    except Exception:
+        _logger.exception('Failed to merge image files.')
+        sys.exit(1)
+    else:
+        sys.exit(0)

honeybee_radiance/cli/viewfactor.py

@@ -0,0 +1,347 @@
+"""Commands to compute view factors to geometry."""
+import click
+import os
+import sys
+import logging
+import math
+from itertools import islice
+
+from honeybee_radiance.config import folders
+from honeybee_radiance.geometry import Polygon
+from honeybee_radiance.modifier.material import Plastic
+
+from honeybee_radiance_command.oconv import Oconv
+from honeybee_radiance_command.rcontrib import Rcontrib, RcontribOptions
+from honeybee_radiance_command._command_util import run_command
+
+from honeybee.model import Model
+from honeybee.facetype import AirBoundary
+from honeybee.boundarycondition import Surface
+from ladybug.futil import preparedir
+
+_logger = logging.getLogger(__name__)
+
+
+@click.group(help='Commands to compute view factors to geometry.')
+def view_factor():
+    pass
+
+
+@view_factor.command('modifiers')
+@click.argument('model-file', type=click.Path(
+    exists=True, file_okay=True, dir_okay=False, resolve_path=True))
+@click.option(
+    '--exclude-sky/--include-sky', ' /-s',
+    help='Flag to note whether a sky dome should be included in the resulting octree. '
+    'The inclusion of the sky dome enables the sky view to be computed in the '
+    'resulting calculation.', default=True, show_default=True
+)
+@click.option(
+    '--exclude-ground/--include-ground', ' /-g',
+    help='Flag to note whether a ground dome should be included in the resulting octree.'
+    ' The inclusion of the ground dome enables the ground view to be computed in the '
+    'resulting calculation.', default=True, show_default=True
+)
+@click.option(
+    '--individual-shades/--grouped-shades', ' /-shd',
+    help='Flag to note whether the shade geometries should be included in the '
+    'list of modifiers. Note that they are still included in the resulting octree '
+    'but are just excluded from the list of modifiers.', default=True, show_default=True
+)
+@click.option(
+    '--triangulate/--skip-triangulate', ' /-t', help='Flag to note whether '
+    'the Apertures and Doors of the output model should be triangulated if '
+    'they have more than 4 vertices. This triangulation is necessary to '
+    'align a model with EnergyPlus results since E+ cannot accept sub-faces '
+    'with more than 4 vertices.', default=True
+)
+@click.option(
+    '--folder', default='.', help='Output folder into which the modifier and '
+    'octree files will be written.'
+)
+@click.option(
+    '--name', default='scene', help='File name, which will be used for both the '
+    'modifiers and the octree.'
+)
+def create_view_factor_modifiers(
+        model_file, exclude_sky, exclude_ground, individual_shades, triangulate,
+        folder, name):
+    """Translate a Model into an Octree and corresponding modifier list for view factors.
+
+    \b
+    Args:
+        model_file: Full path to a Model JSON file (HBJSON) or a Model pkl (HBpkl) file.
+    """
+    try:
+        # create the directory if it's not there
+        if not os.path.isdir(folder):
+            preparedir(folder)
+
+        # load the model and ensure the properties align with the energy model
+        model = Model.from_file(model_file)
+        original_units = None
+        if model.units != 'Meters':
+            original_units = model.units
+            model.convert_to_units('Meters')
+        for room in model.rooms:
+            room.remove_colinear_vertices_envelope(
+                tolerance=0.01, delete_degenerate=True)
+        if original_units is not None:
+            model.convert_to_units(original_units)
+
+        # triangulate the sub-faces if requested
+        if triangulate:
+            apertures, parents_to_edit = model.triangulated_apertures()
+            for tri_aps, edit_infos in zip(apertures, parents_to_edit):
+                if len(edit_infos) == 3:
+                    for room in model._rooms:
+                        if room.identifier == edit_infos[2]:
+                            break
+                    for face in room._faces:
+                        if face.identifier == edit_infos[1]:
+                            break
+                    for i, ap in enumerate(face._apertures):
+                        if ap.identifier == edit_infos[0]:
+                            break
+                    face._apertures.pop(i)  # remove the aperture to replace
+                    face._apertures.extend(tri_aps)
+            doors, parents_to_edit = model.triangulated_doors()
+            for tri_drs, edit_infos in zip(doors, parents_to_edit):
+                if len(edit_infos) == 3:
+                    for room in model._rooms:
+                        if room.identifier == edit_infos[2]:
+                            break
+                    for face in room._faces:
+                        if face.identifier == edit_infos[1]:
+                            break
+                    for i, dr in enumerate(face._doors):
+                        if dr.identifier == edit_infos[0]:
+                            break
+                    face._doors.pop(i)  # remove the doors to replace
+                    face._doors.extend(tri_drs)
+
+        # set values to be used throughout the modifier assignment
+        offset = model.tolerance * -1
+        white_plastic = Plastic('white_plastic', 1, 1, 1)
+        geo_strs, mod_strs, mod_names = [], [], []
+
+        def _add_geo_and_modifier(hb_obj):
+            """Add a honeybee object to the geometry and modifier strings."""
+            mod_name = '%s_mod' % hb_obj.identifier
+            mod_names.append(mod_name)
+            white_plastic.identifier = mod_name
+            rad_poly = Polygon(hb_obj.identifier, hb_obj.vertices, white_plastic)
+            geo_strs.append(rad_poly.to_radiance(False, False, False))
+            mod_strs.append(white_plastic.to_radiance(True, False, False))
+
+        # loop through all geometry in the model and get radiance strings
+        for room in model.rooms:
+            for face in room.faces:
+                if not isinstance(face.type, AirBoundary):
+                    if isinstance(face.boundary_condition, Surface):
+                        face.move(face.normal * offset)
+                    _add_geo_and_modifier(face)
+                for ap in face.apertures:
+                    _add_geo_and_modifier(ap)
+                for dr in face.doors:
+                    _add_geo_and_modifier(dr)
+        all_shades = model.shades + model._orphaned_faces + \
+            model._orphaned_apertures + model._orphaned_doors
+        if individual_shades:
+            for shade in all_shades:
+                _add_geo_and_modifier(shade)
+            for shade_mesh in model.shade_meshes:
+                shd_id = shade_mesh.identifier
+                str_vertices = tuple(tuple(str(v) for v in pt.to_array())
+                                    for pt in shade_mesh.vertices)
+                for fi, f_geo in enumerate(shade_mesh.faces):
+                    coords = tuple(v for pt in f_geo for v in str_vertices[pt])
+                    poly_id = '{}_{}'.format(shd_id, fi)
+                    mod_name = '%s_mod' % poly_id
+                    mod_names.append(mod_name)
+                    white_plastic.identifier = mod_name
+                    base_geo = white_plastic.identifier + ' polygon {} 0 0 {} {}'
+                    geo_str = base_geo.format(poly_id, len(coords), ' '.join(coords))
+                    geo_strs.append(geo_str)
+                    mod_strs.append(white_plastic.to_radiance(True, False, False))
+        else:
+            white_plastic.identifier = 'shade_plastic_mod'
+            mod_names.append(white_plastic.identifier)
+            mod_strs.append(white_plastic.to_radiance(True, False, False))
+            for shade in all_shades:
+                rad_poly = Polygon(shade.identifier, shade.vertices, white_plastic)
+                geo_strs.append(rad_poly.to_radiance(False, False, False))
+            for shade_mesh in model.shade_meshes:
+                shade_mesh.properties.radiance.modifier = white_plastic
+                base_geo = white_plastic.identifier + ' polygon {} 0 0 {} {}'
+                shd_id = shade_mesh.identifier
+                str_vertices = tuple(tuple(str(v) for v in pt.to_array())
+                                    for pt in shade_mesh.vertices)
+                for fi, f_geo in enumerate(shade_mesh.faces):
+                    coords = tuple(v for pt in f_geo for v in str_vertices[pt])
+                    poly_id = '{}_{}'.format(shd_id, fi)
+                    geo_str = base_geo.format(poly_id, len(coords), ' '.join(coords))
+                    geo_strs.append(geo_str)
+
+        # add the ground and sky domes if requested
+        if not exclude_sky:
+            mod_names.append('sky_glow_mod')
+            mod_strs.append('void glow sky_glow_mod 0 0 4 1 1 1 0')
+            geo_strs.append('sky_glow_mod source sky_dome 0 0 4 0 0 1 180')
+        if not exclude_ground:
+            mod_names.append('ground_glow_mod')
+            mod_strs.append('void glow ground_glow_mod 0 0 4 1 1 1 0')
+            geo_strs.append('ground_glow_mod source ground_dome 0 0 4 0 0 -1 180')
+
+        # write the radiance strings to the output folder
+        geo_file = os.path.join(folder, '{}.rad'.format(name))
+        mod_file = os.path.join(folder, '{}.mod'.format(name))
+        oct_file = os.path.join(folder, '{}.oct'.format(name))
+        with open(geo_file, 'w') as gf:
+            gf.write('\n\n'.join(mod_strs + geo_strs))
+        with open(mod_file, 'w') as mf:
+            mf.write('\n'.join(mod_names))
+
+        # use the radiance files to create an octree
+        cmd = Oconv(output=oct_file, inputs=[geo_file])
+        cmd.options.f = True
+        run_command(cmd.to_radiance(), env=folders.env)
+    except Exception as e:
+        _logger.exception('Model translation failed.\n{}'.format(e))
+        sys.exit(1)
+    else:
+        sys.exit(0)
+
+
+@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, which will be used for the '
+    'rebuilt sensor-grid, the matrix and the resulting CSV with view factors.'
+)
+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.
+
+    \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 -fa - -c .333 .333 .334'.format(cmd)
+        cmd = '{}  | getinfo - > "{}"'.format(cmd, mtx_file.replace('\\', '/'))
+        run_command(cmd, env=folders.env)
+
+        # load the resulting matrix and process the results into view factors
+        view_fac_mtx = []
+        with open(mtx_file) as mtx_data:
+            while True:
+                sens_lines = list(islice(mtx_data, ray_count))
+                if not sens_lines:
+                    break
+                sens_mtx = ((float(v) for v in ln.strip().split()) for ln in sens_lines)
+                s_facs = []
+                for sens_facs in zip(*sens_mtx):
+                    s_facs.append(sum(sens_facs) / (math.pi * ray_count))
+                view_fac_mtx.append(s_facs)
+
+        # write the final view factors into a CSV file
+        view_file = os.path.join(folder, '{}.csv'.format(name))
+        with open(view_file, 'w') as v_file:
+            for facs in view_fac_mtx:
+                v_file.write(','.join((str(v) for v in facs)) + '\n')
+    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/config.json

@@ -0,0 +1,6 @@
+{
+    "__comment__": "Add full paths to folders (eg. C:/Radiance/bin).",
+    "radiance_path": "",
+    "standards_data_folder": "",
+    "defaults_file": ""
+}