honeybee-grasshopper-radiance 1.35.1__py3-none-any.whl

honeybee_grasshopper_radiance/src/HB False Color.py

@@ -0,0 +1,246 @@
+# This file is part of Honeybee.
+#
+# Copyright (c) 2025, Ladybug Tools.
+# You should have received a copy of the GNU Affero General Public License
+# along with Honeybee; If not, see <http://www.gnu.org/licenses/>.
+# 
+# @license AGPL-3.0-or-later <https://spdx.org/licenses/AGPL-3.0-or-later>
+
+"""
+Convert a High Dynamic Range (HDR) image file into a falsecolor version of itself.
+-
+
+    Args:
+        _hdr: Path to a High Dynamic Range (HDR) image file.
+        max_: A number to set the upper boundary of the legend. The default is
+            dictated based on the legend_unit_.
+        seg_count_: An interger representing the number of steps between the
+            high and low boundary of the legend. The default is set to 10
+            and any custom values input in here should always be greater
+            than or equal to 2.
+        legend_height_: An integer for the height of the legend in pixels. Set to 0
+            to completely remove the legend from the output. (Default: 200).
+        legend_width_: An integer for the width of the legend in pixels. Set to 0
+            to completely remove the legend from the output. (Default: 100).
+        legend_unit_: Text for the unit of the legend. If unspecified, an attempt will
+            be made to sense the metric from the input image file. Typical examples
+            include lux, W/m2, cd/m2, w/sr-m2.
+        conversion_: Number for the conversion factor (aka. multiplier) for the results.
+            The default is either 1 or 179 depending on whether the image is for
+            radiance or irradiance to luminance or illuminance, respectively.
+        contour_lines_: Set to True ro render the image with colored contour lines.
+        logarithmic_: Number of decades to use with a logarithmic legend scale.
+            Decades are the number of intervals of 10 below the maximum scale. If
+            unspecified, a linear scale is used.
+        extrema_: Set to True to cause extrema points to be printed on the brightest
+            and darkest pixels of the input picture.
+        mask_: A boolen to note whether pixels with a value of zero should be masked in
+            black. (Default: False).
+        color_palette_: Optional interger or text to change the color palette.
+            Choose from the following.
+                * 0 = def - default colors
+                * 1 = pm3d -  a variation of the default colors
+                * 2 = spec - the old spectral mapping
+                * 3 = hot - a thermal scale
+
+    Returns:
+        hdr: Path to the resulting falsecolor HDR file. This can be plugged into the
+            Ladybug "Image Viewer" component to preview the image. It can also
+            be plugged into the "HB HDR to GIF" component to get a GIF image
+            that is more portable and easily previewed by different software.
+"""
+
+ghenv.Component.Name = 'HB False Color'
+ghenv.Component.NickName = 'FalseColor'
+ghenv.Component.Message = '1.9.0'
+ghenv.Component.Category = 'HB-Radiance'
+ghenv.Component.SubCategory = '4 :: Results'
+ghenv.Component.AdditionalHelpFromDocStrings = '3'
+
+import os
+import subprocess
+import re
+
+try:  # import honeybee_radiance_command dependencies
+    from honeybee_radiance_command.falsecolor import Falsecolor
+    from honeybee_radiance_command.pcomb import Pcomb
+except ImportError as e:
+    raise ImportError('\nFailed to import honeybee_radiance_command:\n\t{}'.format(e))
+
+try:  # import honeybee_radiance dependencies
+    from honeybee_radiance.config import folders as rad_folders
+except ImportError as e:
+    raise ImportError('\nFailed to import honeybee_radiance:\n\t{}'.format(e))
+
+try:  # import ladybug_rhino dependencies
+    from ladybug_rhino.grasshopper import all_required_inputs
+except ImportError as e:
+    raise ImportError('\nFailed to import ladybug_rhino:\n\t{}'.format(e))
+
+# check the Radiance date of the installed radiance
+try:  # import lbt_recipes dependencies
+    from lbt_recipes.version import check_radiance_date
+except ImportError as e:
+    raise ImportError('\nFailed to import lbt_recipes:\n\t{}'.format(e))
+check_radiance_date()
+
+
+def sense_metric_from_hdr(hdr_path):
+    """Sense the metric/units of a given HDR file from its properties.
+
+    Args:
+        hdr_path: The path to an HDR image file
+
+    Returns:
+        Text for the units of the file (either 'lux', 'W/m2', 'cd/m2', 'W/sr-m2')
+    """
+    with open(hdr_path, 'r') as hdr_file:
+        for lineCount, line in enumerate(hdr_file):
+            if lineCount < 10:
+                low_line = line.strip().lower()
+                if low_line.startswith('oconv') and low_line.endswith('.sky'):
+                    return 'W/sr-m2'  # this is an image of a sky
+                if low_line.startswith('rpict'):
+                    if line.find('_irradiance.vf') > -1:
+                        return 'W/m2'
+                    if line.find('_radiance.vf') > -1:
+                        return 'W/sr-m2'
+                    if line.find('-i') > -1 and not line.find('-i-') > -1:
+                        return 'lux'
+            else:  # we have passed the header of the file
+                return 'cd/m2'  # luminance
+
+
+def is_fisheye(hdr_path):
+    """Sense whether a given HDR file is a fisheye.
+
+    Args:
+        hdr_path: The path to an HDR image file
+
+    Returns:
+        Text for the units of the file (either 'lux', 'W/m2', 'cd/m2', 'W/sr-m2')
+    """
+    with open(hdr_path, 'r') as hdr_file:
+        for lineCount, line in enumerate(hdr_file):
+            if lineCount < 10:
+                if '-vth' in line:
+                    return True
+            else:
+                return False
+
+def get_dimensions(img_dim):
+    """Get integers for the dimensions of an image from the pcomb stdout.
+
+    Args:
+        img_dim: Text string that is returned from the pcomb function
+
+    Returns:
+        Two integers for the dimensions of the HDR image
+    """
+    dimensions = []
+    for d in ['+X', '-Y']:
+        regex = r'\%s\s+(\d+)' % d
+        matches = re.finditer(regex, img_dim, re.MULTILINE)
+        try:
+            dim = next(matches).groups()[0]
+            dimensions.append(int(dim))
+        except Exception:
+            pass
+    if len(dimensions) == 1:  # it is likely a sky-generated image
+        dimensions.append(int(dim))
+
+    return dimensions
+
+
+if all_required_inputs(ghenv.Component):
+    # set up the paths for the various files used in translation
+    img_dir = os.path.dirname(_hdr)
+    input_image = os.path.basename(_hdr)
+    new_image = input_image.lower().replace('.hdr', '_falsecolor.HDR')
+    hdr = os.path.join(img_dir, new_image)
+
+    # set default properties
+    seg_count_ = seg_count_ if seg_count_ is not None else 10
+    if legend_unit_ is None:
+        legend_unit_ = sense_metric_from_hdr(_hdr)
+    if conversion_ is None:
+        if legend_unit_ in ('W/sr-m2', 'W/m2'):
+            conversion_ = 1
+        else:
+            conversion_ = 179
+    if max_ is None:  # get the max value by running pextrem
+        pextrem_exe = os.path.join(rad_folders.radbin_path, 'pextrem.exe') if \
+            os.name == 'nt' else os.path.join(rad_folders.radbin_path, 'pextrem')
+        use_shell = True if os.name == 'nt' else False
+        cmds = [pextrem_exe, '-o', _hdr]
+        process = subprocess.Popen(cmds, stdout=subprocess.PIPE, shell=use_shell)
+        stdout = process.communicate()
+        max_rgb = stdout[0].split('\n')[1]
+        max_ = (sum([float(x) for x in max_rgb.split(' ')[2:]]) / 3) * conversion_
+        if legend_unit_ == 'W/sr-m2' and max_ > 200:  # sun pixel overpowering image
+            max_ = max_ / 50000
+        max_ = str(round(max_, 1)) if max_ >= 0.1 else str(max_)
+
+    # create the command to run falsecolor
+    mask = True if mask_ and is_fisheye(_hdr) else False
+    out_img = new_image if not mask else input_image.lower().replace('.hdr', '_fc_temp.HDR')
+    falsecolor = Falsecolor(input=input_image, output=out_img)
+    falsecolor.options.s = max_
+    falsecolor.options.n = seg_count_
+    falsecolor.options.l = legend_unit_
+    falsecolor.options.m = conversion_
+    if contour_lines_:
+        falsecolor.options.cl = True
+        falsecolor.options.p = input_image
+    if extrema_:
+        falsecolor.options.e = True
+    if logarithmic_:
+        falsecolor.options.log = logarithmic_
+    if legend_height_ is not None:
+        falsecolor.options.lh = legend_height_
+    if legend_width_ is not None:
+        falsecolor.options.lw = legend_width_
+    if color_palette_:
+        PALETTE_DICT = {
+            '0': 'def',
+            '1': 'pm3d',
+            '2': 'spec',
+            '3': 'hot',
+            'def': 'def',
+            'pm3d': 'pm3d',
+            'spec': 'spec',
+            'hot': 'hot'
+        }
+        falsecolor.options.pal = PALETTE_DICT[color_palette_]
+
+    # run the falsecolor command
+    env = None
+    if rad_folders.env != {}:
+        env = rad_folders.env
+    env = dict(os.environ, **env) if env else None
+    falsecolor.run(env, cwd=img_dir)
+
+    # if we should maske, then run an additional pcomb command
+    if mask:
+        # get the dimensions of the image
+        getinfo_exe = os.path.join(rad_folders.radbin_path, 'getinfo.exe') if \
+            os.name == 'nt' else os.path.join(rad_folders.radbin_path, 'getinfo')
+        cmds = [getinfo_exe, '-d', _hdr]
+        use_shell = True if os.name == 'nt' else False
+        process = subprocess.Popen(cmds, stdout=subprocess.PIPE, shell=use_shell)
+        stdout = process.communicate()
+        img_dim = stdout[0]
+        x, y = get_dimensions(img_dim)
+
+        # mask the image
+        xw = legend_width_ if legend_width_ is not None else 100
+        lh = int(legend_height_ * 1.17) if legend_height_ is not None else (200 * 1.17)
+        yw = lh - y if lh - y > 0 else 0
+        expression = 's(x):x*x;' \
+            'm=if((xmax-{0})*(ymax-{1})/4-s(x-{0}-(xmax-{0})/2)-s(y-(ymax-{1})/2),1,if({0}-x,1,0));' \
+            'ro=m*ri(1);' \
+            'go=m*gi(1);' \
+            'bo=m*bi(1)'.format(xw, yw)
+        pcomb = Pcomb(input=out_img, output=new_image)
+        pcomb.options.e = '"{}"'.format(expression)
+        pcomb.run(env, cwd=img_dir)

honeybee_grasshopper_radiance/src/HB Get Dynamic Groups.py

@@ -0,0 +1,57 @@
+# Honeybee: A Plugin for Environmental Analysis (GPL)
+# This file is part of Honeybee.
+#
+# Copyright (c) 2025, Ladybug Tools.
+# You should have received a copy of the GNU Affero General Public License
+# along with Honeybee; If not, see <http://www.gnu.org/licenses/>.
+# 
+# @license AGPL-3.0-or-later <https://spdx.org/licenses/AGPL-3.0-or-later>
+
+"""
+Get all of the Dynamic Radiance Groups assigned to a Model.
+-
+
+    Args:
+        _model: A Honeybee Model for which dynamic groups will be output.
+
+    Returns:
+        group_ids: The identifiers of the dynamic groups assigned to the Model.
+        group_aps: A data tree of Dynamic Apertures in the Model. Each branch of the
+            tree represents a different Dynamic Aperture Group and corresponds to
+            the group_ids above. The data tree can be exploded with the native
+            Grasshopper "Explod Tree" component to assign schedules to each
+            Dynamic Group for postprocessing.
+"""
+
+ghenv.Component.Name = 'HB Get Dynamic Groups'
+ghenv.Component.NickName = 'GetDyn'
+ghenv.Component.Message = '1.9.0'
+ghenv.Component.Category = 'HB-Radiance'
+ghenv.Component.SubCategory = '0 :: Basic Properties'
+ghenv.Component.AdditionalHelpFromDocStrings = '0'
+
+try:  # import core honeybee dependencies
+    from honeybee.model import Model
+except ImportError as e:
+    raise ImportError('\nFailed to import honeybee:\n\t{}'.format(e))
+
+try:  # import ladybug_rhino dependencies
+    from ladybug_rhino.grasshopper import all_required_inputs, list_to_data_tree
+except ImportError as e:
+    raise ImportError('\nFailed to import ladybug_rhino:\n\t{}'.format(e))
+
+
+if all_required_inputs(ghenv.Component):
+    assert isinstance(_model, Model), \
+        'Expected Honeybee Model. Got {}.'.format(type(_model))
+    # get the dynamic group objects
+    groups = _model.properties.radiance.dynamic_subface_groups
+    groups.sort(key=lambda x: x.identifier)
+
+    # get the group attributes
+    group_ids, group_aps = [], []
+    for group in groups:
+        group_ids.append([group.identifier])
+        group_aps.append(group.dynamic_objects)
+    group_ids = list_to_data_tree(group_ids)
+    group_aps = list_to_data_tree(group_aps)

honeybee_grasshopper_radiance/src/HB Get Grids and Views.py

@@ -0,0 +1,82 @@
+# Honeybee: A Plugin for Environmental Analysis (GPL)
+# This file is part of Honeybee.
+#
+# Copyright (c) 2025, Ladybug Tools.
+# You should have received a copy of the GNU Affero General Public License
+# along with Honeybee; If not, see <http://www.gnu.org/licenses/>.
+# 
+# @license AGPL-3.0-or-later <https://spdx.org/licenses/AGPL-3.0-or-later>
+
+"""
+Get Radiance Sensor Grids and/or Views from a Honeybee Model and visualize them
+in the Rhino scene.
+-
+
+    Args:
+        _model: A Honeybee Model for which grids and views will be output.
+        view_filter_: Text for a view identifer or a pattern to filter the views of the
+            model that are output. For instance, `first_floor_*` will simulate
+            only the views that have an identifier that starts with `first_floor_`.
+            By default, all views in the model will be output.
+        grid_filter_: Text for a grid identifer or a pattern to filter the sensor grids of
+            the model that are output. For instance, first_floor_* will simulate
+            only the sensor grids that have an identifier that starts with
+            first_floor_. By default, all grids in the model will be output.
+
+    Returns:
+        views: A list of Honeybee-Radiance Views that are assigned to the
+            input _model.
+        grids: A list of Honeybee-Radiance SensorGrids that are assigned to
+            the input _model.
+        points: The points that are at the center of each grid cell.
+        meshes: Mesh for each sensor grid, which can be passed to the "LB Spatial
+            Heatmap" component.
+"""
+
+ghenv.Component.Name = 'HB Get Grids and Views'
+ghenv.Component.NickName = 'GetGridsViews'
+ghenv.Component.Message = '1.9.0'
+ghenv.Component.Category = 'HB-Radiance'
+ghenv.Component.SubCategory = '0 :: Basic Properties'
+ghenv.Component.AdditionalHelpFromDocStrings = '5'
+
+try:  # import core ladybug_geometry dependencies
+    from ladybug_geometry.geometry3d.pointvector import Point3D
+except ImportError as e:
+    raise ImportError('\nFailed to import ladybug_geometry:\n\t{}'.format(e))
+
+try:  # import core honeybee dependencies
+    from honeybee.model import Model
+except ImportError as e:
+    raise ImportError('\nFailed to import honeybee:\n\t{}'.format(e))
+
+try:  # import honeybee_radiance dependencies
+    from honeybee_radiance.writer import _filter_by_pattern
+except ImportError as e:
+    raise ImportError('\nFailed to import honeybee_radiance:\n\t{}'.format(e))
+
+try:  # import ladybug_rhino dependencies
+    from ladybug_rhino.fromgeometry import from_point3d, from_mesh3d
+    from ladybug_rhino.grasshopper import all_required_inputs, list_to_data_tree
+except ImportError as e:
+    raise ImportError('\nFailed to import ladybug_rhino:\n\t{}'.format(e))
+
+
+if all_required_inputs(ghenv.Component):
+    assert isinstance(_model, Model), \
+        'Expected Honeybee Model. Got {}.'.format(type(_model))
+    # get the honeybee-radiance objects
+    views = _model.properties.radiance.views
+    if view_filter_ is not None:
+        views = _filter_by_pattern(views, view_filter_)
+    grids = _model.properties.radiance.sensor_grids
+    if grid_filter_ is not None:
+        grids = _filter_by_pattern(grids, grid_filter_)
+
+    # get the visualizable attributes
+    points = [[from_point3d(Point3D.from_array(s.pos)) for s in sg] for sg in grids]
+    points = list_to_data_tree(points)
+    meshes = []
+    for grid in grids:
+        if grid.mesh is not None:
+            meshes.append(from_mesh3d(grid.mesh))

honeybee_grasshopper_radiance/src/HB Glare Postprocess.py

@@ -0,0 +1,225 @@
+# This file is part of Honeybee.
+#
+# Copyright (c) 2025, Ladybug Tools.
+# You should have received a copy of the GNU Affero General Public License
+# along with Honeybee; If not, see <http://www.gnu.org/licenses/>.
+# 
+# @license AGPL-3.0-or-later <https://spdx.org/licenses/AGPL-3.0-or-later>
+
+"""
+Perform glare post-processing on a hemisphical fisheye HDR image file.
+_
+Glare post-processing includes calcuating Daylight Glare Probability (DGP) as
+well as other glare indexes (DGI, UGR, VCP, CGI, UDP).
+_
+This component is using the `evalglare` function for glare calculations., which
+is developed by J. Wienold at Fraunhofer ISE. More information on evalglare
+can be found here:
+https://www.radiance-online.org/learning/documentation/manual-pages/pdfs/evalglare.pdf/view
+_
+For more information about the metrics used to evaluate glare, see here:
+http://web.mit.edu/tito_/www/Projects/Glare/GlareRecommendationsForPractice.html
+
+-
+    Args:
+        _hdr: Path to a hemisphical fisheye High Dynamic Range (HDR) image file. This can be
+            obtained from the "HB Point-In-Time View-Based" recipe component. Due
+            to runtime reasons of the evalglare code, the input HDR image should
+            be smaller than 1500 x 1500 pixels. The recommended size is 1000 x 1000
+            pixels, the minimum recommended size is 800 x 800 pixels.
+        task_pos_: An optional task position as a 2D point or string formatted as "X, Y".
+            The X and Y coordinates of this point must be numbers between 0 and 1
+            and correspond to fraction of the image width and height where the
+            task position lies. If no task position is provided, the glare will
+            be valuated for the entire scene of the image.
+        task_angle_: An number between 0 and 180 for the task position opening angle
+            in degrees. This angle indicates how widely the peripheral vision
+            is engaged for the task. (Default: 30).
+        hide_task_: Boolean to note whether the task area should be hidden in the
+            output check_hdr.
+
+    Returns:
+        DGP: Daylight Glare Probability (DGP) as a number between 0 and 1. The DGP
+            describes the fraction of persons disturbed by glare, where 0 is no
+            one disturbed and 1 is everyone. Values lower than 0.2 are out of the
+            range of the user assessment tests, where the program is based on and
+            should be interpreted carefully.
+        category: Text for the category of glare discomfort. It will be one of the
+            following.
+                * Imperceptible Glare [0.35 > DGP]
+                * Perceptible Glare [0.4 > DGP >= 0.35]
+                * Disturbing Glare [0.45 > DGP >= 0.4]
+                * Intolerable Glare [DGP >= 0.45] 
+        glare_indices: A list of various glare indices ordered as follows.
+                * Daylight Glare Index (DGI)
+                * Unified Glare Rating (UGR)
+                * Visual Comfort Probability (VCP)
+                * CIE Glare Index (CGI)
+                * Veiling Luminance (Lveil)
+        check_hdr: Path to a HDR image produced from the glare study. The image will
+            use randomly-assigned colors to indicate different sources of glare
+            in the image. It will also show a circular region for the task area
+            unless hide_task_ has been set to True.
+"""
+
+ghenv.Component.Name = 'HB Glare Postprocess'
+ghenv.Component.NickName = 'Glare'
+ghenv.Component.Message = '1.9.0'
+ghenv.Component.Category = 'HB-Radiance'
+ghenv.Component.SubCategory = '4 :: Results'
+ghenv.Component.AdditionalHelpFromDocStrings = '3'
+
+import os
+import subprocess
+import math
+import re
+
+try:  # import honeybee_radiance dependencies
+    from honeybee_radiance.config import folders as rad_folders
+except ImportError as e:
+    raise ImportError('\nFailed to import honeybee_radiance:\n\t{}'.format(e))
+
+try:  # import ladybug_rhino dependencies
+    from ladybug_rhino.grasshopper import all_required_inputs, give_warning
+except ImportError as e:
+    raise ImportError('\nFailed to import ladybug_rhino:\n\t{}'.format(e))
+
+# check the Radiance date of the installed radiance
+try:  # import lbt_recipes dependencies
+    from lbt_recipes.version import check_radiance_date
+except ImportError as e:
+    raise ImportError('\nFailed to import lbt_recipes:\n\t{}'.format(e))
+check_radiance_date()
+
+
+def check_hdr_luminance_and_fisheye(hdr_path):
+    """Check that a given HDR file is a fisheye image for visible luminance.
+
+    A ValueError is raised if the image is not for luminance or if the image is
+    not clearly a hemispheical fisheye.
+
+    Args:
+        hdr_path: The path to an HDR image file.
+    """
+    msg = 'Connected _hdr image must be for luminance. Got "{}".'
+    projection = '-vth'
+    with open(hdr_path, 'r') as hdr_file:
+        for lineCount, line in enumerate(hdr_file):
+            if lineCount < 200:
+                low_line = line.strip().lower()
+                if low_line.startswith('rpict'):
+                    if line.find('_irradiance.vf') > -1:
+                        raise ValueError(msg.format('irradiance'))
+                    if line.find('_radiance.vf') > -1:
+                        raise ValueError(msg.format('radiance'))
+                    if line.find('-i') > -1 and not line.find('-i-') > -1:
+                        raise ValueError(msg.format('illuminance'))
+                elif low_line.startswith('view='):
+                    if line.find('-vth') > -1:
+                        projection = '-vth'
+                    elif line.find('-vta') > -1:
+                        projection = '-vta'
+                    else:
+                        raise ValueError(
+                            'Connected _hdr image is not a fisheye projection.\n'
+                            'Make sure the view type of the image is 1(h) or 4(a).')
+                elif 'pcond -h' in low_line:
+                    raise ValueError(
+                        'Connected _hdr image has had the exposure adjusted on it.\n'
+                        'Make sure adj_expos_ has been set to False in previous steps.')
+            else:  # no need to check the rest of the document
+                break
+    return projection
+
+def check_hdr_dimensions(hdr_path):
+    """Check that a given HDR file has dimensions suitable for evalglare.
+
+    A warning is raised if the image is not 1000x1000 pixels and a ValueError is
+    raised if the image is completely outside the accptable ragne from 800x800
+    to 1500x1500 pixels.
+
+    Args:
+        hdr_path: The path to an HDR image file.
+    """
+    # get the path the the getinfo command
+    getinfo_exe = os.path.join(rad_folders.radbin_path, 'getinfo.exe') if \
+        os.name == 'nt' else os.path.join(rad_folders.radbin_path, 'getinfo')
+
+    # run the getinfo command in a manner that lets us obtain the result
+    cmds = [getinfo_exe, '-d', hdr_path]
+    use_shell = True if os.name == 'nt' else False
+    process = subprocess.Popen(cmds, stdout=subprocess.PIPE, shell=use_shell)
+    stdout = process.communicate()
+    img_dim = stdout[0]
+
+    def get_dimensions(img_dim):
+        dimensions = []
+        for d in ['+X', '-Y']:
+            regex = r'\%s\s+(\d+)' % d
+            matches = re.finditer(regex, img_dim, re.MULTILINE)
+            dim = next(matches).groups()[0]
+            dimensions.append(int(dim))
+        return dimensions
+    # check the X and Y dimensions of the image
+    x, y = get_dimensions(img_dim)
+
+    msg = 'Recommended _hdr image dimensions for glare analysis should be \n' \
+        '{} {} x {} pixels. Got {} x {}.'
+    if x < 800 or y < 800:
+        give_warning(ghenv.Component, msg.format('at least', 800, 800, x, y))
+    elif x > 1500 or y > 1500:
+        give_warning(ghenv.Component, msg.format('no greater than', 1500, 1500, x, y))
+    return x, y
+
+
+def dgp_comfort_category(dgp):
+    """Get text for the glare comfort category given a DGP value."""
+    if dgp < 0.35:
+        return 'Imperceptible Glare'
+    elif dgp < 0.40:
+        return 'Perceptible Glare'
+    elif dgp < 0.45:
+        return 'Disturbing Glare'
+    else:
+        return 'Intolerable Glare'
+
+
+if all_required_inputs(ghenv.Component):
+    # check the input image to ensure it meets the criteria
+    projection = check_hdr_luminance_and_fisheye(_hdr)
+    width, height = check_hdr_dimensions(_hdr)
+
+    # get the path the the evalglare command and setup the check image argument
+    evalglare_exe = os.path.join(rad_folders.radbin_path, 'evalglare.exe') if \
+        os.name == 'nt' else os.path.join(rad_folders.radbin_path, 'evalglare')
+    img_dir = os.path.dirname(_hdr)
+    input_image = os.path.basename(_hdr)
+    new_image = input_image.lower().replace('.hdr', '_check.HDR')
+    check_hdr = os.path.join(img_dir, new_image)
+    cmds = [evalglare_exe, '-c', check_hdr]
+
+    # since pcomp is used to merge images, the input usually doesn't have view information
+    # add default view information for hemispheical fish-eye camera
+    cmds.extend([projection, '-vv', '180', '-vh', '180'])
+
+    # process the task position and add the input HDR
+    if task_pos_:
+        uv_pt = [float(val) for val in task_pos_.split(',')]
+        assert 0 <= uv_pt[0] <= 1 and 0 <= uv_pt[1] <= 1, 'Task position X and Y ' \
+            'coordinates must be between 0 and 1.'
+        angle = math.radians(task_angle_) if task_angle_ is not None else math.radians(30)
+        task_opt = '-t' if hide_task_ else '-T'
+        cmds.extend(
+            [task_opt, str(int(uv_pt[0] * width)), str(int(uv_pt[1] * height)), str(angle)])
+    cmds.append(_hdr)
+
+    # run the evalglare command in a manner that lets us obtain the stdout result
+    use_shell = True if os.name == 'nt' else False
+    process = subprocess.Popen(cmds, stdout=subprocess.PIPE, shell=use_shell)
+    stdout = process.communicate()
+
+    # process the stdout result into the component outputs
+    glare_result = stdout[0].split(':')[-1].strip()
+    glare_indices = [float(val) for val in glare_result.split(' ')]
+    DGP = glare_indices.pop(0)
+    category = dgp_comfort_category(DGP)

honeybee_grasshopper_radiance/src/HB Glass Modifier 3.py

@@ -0,0 +1,62 @@
+# Honeybee: A Plugin for Environmental Analysis (GPL)
+# This file is part of Honeybee.
+#
+# Copyright (c) 2025, Ladybug Tools.
+# You should have received a copy of the GNU Affero General Public License
+# along with Honeybee; If not, see <http://www.gnu.org/licenses/>.
+# 
+# @license AGPL-3.0-or-later <https://spdx.org/licenses/AGPL-3.0-or-later>
+
+"""
+Create an glass radiance modifier from a red, green, and blue transmittances
+-
+
+    Args:
+        _name_: Text to set the name for the modifier and to be incorporated into
+            a unique modifier identifier.
+        _r_trans: A number between 0 and 1 for the transmittance of the red
+            channel. (Default: 0).
+        _g_trans: A number between 0 and 1 for the transmittance of the green
+            channel. (Default: 0).
+        _b_trans: A number between 0 and 1 for the transmittance of the blue
+            channel. (Default: 0).
+        _refract_: Index of refraction. Typical values are 1.52 for float
+            glass and 1.4 for ETFE. If None, Radiance will default to using 1.52
+            for glass (Default: None).
+
+    Returns:
+        modifier: A glass modifier that can be assigned to a Honeybee geometry or
+            Modifier Sets.
+"""
+
+ghenv.Component.Name = 'HB Glass Modifier 3'
+ghenv.Component.NickName = 'GlassMod3'
+ghenv.Component.Message = '1.9.0'
+ghenv.Component.Category = 'HB-Radiance'
+ghenv.Component.SubCategory = '1 :: Modifiers'
+ghenv.Component.AdditionalHelpFromDocStrings = '0'
+
+try:  # import the core honeybee dependencies
+    from honeybee.typing import clean_rad_string, clean_and_id_rad_string
+except ImportError as e:
+    raise ImportError('\nFailed to import honeybee:\n\t{}'.format(e))
+
+try:  # import the honeybee-radiance dependencies
+    from honeybee_radiance.modifier.material import Glass
+except ImportError as e:
+    raise ImportError('\nFailed to import honeybee_radiance:\n\t{}'.format(e))
+
+try:  # import ladybug_rhino dependencies
+    from ladybug_rhino.grasshopper import all_required_inputs
+except ImportError as e:
+    raise ImportError('\nFailed to import ladybug_rhino:\n\t{}'.format(e))
+
+
+if all_required_inputs(ghenv.Component):
+    name = clean_and_id_rad_string('GlassMaterial') if _name_ is None else \
+        clean_rad_string(_name_)
+
+    # create the modifier
+    modifier = Glass.from_transmittance(name, _r_trans, _g_trans, _b_trans, _refract_)
+    if _name_ is not None:
+        modifier.display_name = _name_