honeybee-radiance 1.66.190__py3-none-any.whl

honeybee_radiance/properties/shademesh.py

@@ -0,0 +1,116 @@
+# coding=utf-8
+"""ShadeMesh Radiance Properties."""
+from ._base import _RadianceProperties
+from ..modifier import Modifier
+from ..lib.modifiers import generic_context
+from ..lib.modifiersets import generic_modifier_set_visible
+
+
+class ShadeMeshRadianceProperties(_RadianceProperties):
+    """Radiance Properties for Honeybee ShadeMesh.
+
+    Args:
+        host: A honeybee_core ShadeMesh object that hosts these properties.
+        modifier: A Honeybee Radiance Modifier object for the shade mesh. If None,
+            it will be set by the default generic ModifierSet.
+        modifier_blk: A Honeybee Radiance Modifier object to be used for this
+            shade mesh in direct solar simulations and in isolation studies (assessing
+            the contribution of individual Apertures). If None, this will be
+            a completely black material if the Shade's modifier is opaque and
+            will be equal to the modifier if the Shade's modifier is non-opaque.
+
+    Properties:
+        * host
+        * modifier
+        * modifier_blk
+        * is_opaque
+        * is_modifier_set_on_object
+        * is_blk_overridden
+    """
+
+    __slots__ = ()
+
+    def __init__(self, host, modifier=None, modifier_blk=None):
+        """Initialize ShadeMesh radiance properties."""
+        _RadianceProperties.__init__(self, host, modifier, modifier_blk)
+
+    @property
+    def modifier(self):
+        """Get or set the ShadeMesh modifier.
+
+        If the modifier is not set on the shade-level, then it will be the
+        generic context material or the generic exterior shade modifier if it
+        is not detached.
+        """
+        if self._modifier:  # set by user
+            return self._modifier
+        return generic_context if self._host.is_detached else \
+            generic_modifier_set_visible.shade_set.exterior_modifier
+
+    @modifier.setter
+    def modifier(self, value):
+        if value is not None:
+            assert isinstance(value, Modifier), \
+                'Expected Radiance Modifier for ShadeMesh. Got {}'.format(type(value))
+            value.lock()  # lock editing in case modifier has multiple references
+        self._modifier = value
+
+    @classmethod
+    def from_dict(cls, data, host):
+        """Create ShadeMeshRadianceProperties from a dictionary.
+
+        Note that the dictionary must be a non-abridged version for this
+        classmethod to work.
+
+        Args:
+            data: A dictionary representation of ShadeMeshRadianceProperties with the
+                format below.
+            host: A ShadeMesh object that hosts these properties.
+
+        .. code-block:: python
+
+            {
+            'type': 'ShadeMeshRadianceProperties',
+            'modifier': {},  # A Honeybee Radiance Modifier dictionary
+            'modifier_blk': {}  # A Honeybee Radiance Modifier dictionary
+            }
+        """
+        assert data['type'] == 'ShadeMeshRadianceProperties', \
+            'Expected ShadeMeshRadianceProperties. Got {}.'.format(data['type'])
+        new_prop = cls(host)
+        return cls._restore_modifiers_from_dict(new_prop, data)
+
+    def apply_properties_from_dict(self, abridged_data, modifiers):
+        """Apply properties from a ShadeMeshRadiancePropertiesAbridged dictionary.
+
+        Args:
+            abridged_data: A ShadeMeshRadiancePropertiesAbridged dictionary (typically
+                coming from a Model) with the format below.
+            modifiers: A dictionary of modifiers with modifier identifiers as keys,
+                which will be used to re-assign modifiers.
+
+        .. code-block:: python
+
+            {
+            'type': 'ShadeMeshRadiancePropertiesAbridged',
+            'modifier': str,  # A Honeybee Radiance Modifier identifier
+            'modifier_blk': str  # A Honeybee Radiance Modifier identifier
+            }
+        """
+        self._apply_modifiers_from_dict(abridged_data, modifiers)
+
+    def to_dict(self, abridged=False):
+        """Return radiance properties as a dictionary.
+
+        Args:
+            abridged: Boolean to note whether the full dictionary describing the
+                object should be returned (False) or just an abridged version (True).
+                Default: False.
+        """
+        base = {'radiance': {}}
+        base['radiance']['type'] = 'ShadeMeshRadianceProperties' if not \
+            abridged else 'ShadeMeshRadiancePropertiesAbridged'
+        return self._add_modifiers_to_dict(base, abridged)
+
+    def __repr__(self):
+        return 'ShadeMesh Radiance Properties:\n host: {}'.format(self.host.identifier)

honeybee_radiance/putil.py

@@ -0,0 +1,44 @@
+"""Primitive utility functions."""
+from honeybee_radiance.mutil import modifier_class_from_type_string
+import honeybee_radiance.geometry as geometry
+from honeybee_radiance.primitive import Primitive
+
+
+def primitive_class_from_type_string(type_string):
+    """Get the class of any primitive using its 'type' string.
+
+    Note that this function returns the class itself and not a class instance.
+
+    Args:
+        type_string: Text for the name of a primitive module/class. This should
+            usually be lowercase and should be the same as the 'type' key used
+            in the dictionary representation of the primitive.
+    """
+    if type_string in Primitive.GEOMETRYTYPES:
+        target_module = geometry
+    else:
+        try:
+            return modifier_class_from_type_string(type_string)
+        except ValueError:
+            raise NotImplementedError(
+                'Honeybee currently does not support %s' % type_string)
+    class_name = type_string.capitalize()
+    return getattr(target_module, class_name)
+
+
+def dict_to_primitive(pdict):
+    """Convert a dictionary representation of any primitive to a class instance.
+
+    The returned object will have the correct class type and will not be the
+    generic Primitive base class. Note that this function is recursive and will
+    re-serialize modifiers of modifiers.
+
+    Args:
+        pdict: A dictionary of any Radiance Primitive (Geometry or Modifier).
+    """
+    primitive_class = primitive_class_from_type_string(pdict['type'])
+
+    if 'values' in pdict:
+        return primitive_class.from_primitive_dict(pdict)
+    else:
+        return primitive_class.from_dict(pdict)

honeybee_radiance/reader.py

@@ -0,0 +1,214 @@
+"""A collection of auxiliary functions for working with radiance files and objects."""
+import re
+import os
+
+
+# TODO: Add support for comments [#] and commands [!]
+def parse_from_string(full_string):
+    """Separate a Radiance file string into multiple strings for each object.
+
+    Args:
+        full_string: Radiance data as a single string. The string can be multiline.
+
+    Returns:
+        A list of strings. Each string represents a different Radiance primitive
+        (geometry or modifier). Comments [#] and commands [!] are excluded.
+    """
+    raw_rad_objects = re.findall(
+        r'^\s*([^0-9].*(\s*[\d.-]+.*)*)',
+        full_string,
+        re.MULTILINE)
+
+    rad_objects = (' '.join(radiance_object[0].split())
+                   for radiance_object in raw_rad_objects)
+
+    filtered_objects = tuple(rad_object for rad_object in rad_objects
+                             if rad_object and rad_object[0] not in ['#', '!'])
+
+    return filtered_objects
+
+
+def parse_from_file(file_path):
+    """Parse a Radiance file.
+
+    This function breaks down the file into a list of radiance objects as separate
+    strings.
+
+    Args:
+        file_path: Path to Radiance file
+
+    Returns:
+        A list of strings. Each string represents a different Radiance object.
+
+    Usage:
+
+    .. code-block:: python
+
+        rad_obj_strs = parse_from_file('some_file.rad')
+    """
+
+    assert os.path.isfile(file_path), "Can't find %s." % file_path
+
+    with open(file_path, "r") as rad_file:
+        return parse_from_string(rad_file.read())
+
+
+def string_to_dicts(string):
+    """Convert a radiance string to a list of primitive dictionaries.
+
+    These primitive dictionaries can be seralized to honeybee-radiance Python
+    objects using the from_primitive_dict methods on all primitive classes.
+
+    If the primitive modifier is not void or the primitive has other dependencies,
+    the dependency must also be part of the input string and this method will
+    ensure that the dependent output dictionaries are correctly nested so that
+    they can be correctly serialized.
+
+    Returns:
+        A list of dictionaries.
+    """
+    def find_object(target, index):
+        for o_count, other_obj in enumerate(objects[:-(index + 1)]):
+            if other_obj['identifier'] == target:
+                return o_count, other_obj
+
+    input_objects = parse_from_string(string)
+
+    if not input_objects:
+        raise ValueError(
+            '{} includes no radiance objects.'.format(string)
+        )
+
+    # break down each object and convert it to a dict
+    objects = [string_to_dict(inp) for inp in input_objects]
+
+    # start from the last material and try to find dependencies if any)
+    rev_objects = list(reversed(objects))
+    remove_index = []
+    for count, obj in enumerate(rev_objects):
+
+        if obj['modifier'] != 'void':
+            # try to find it in objects and add replace it
+            try:
+                o_count, other_obj = find_object(obj['modifier'], count)
+            except TypeError:
+                # didn't find any
+                raise ValueError(
+                    'Failed to find "{}" modifier for "{}" in input string'.format(
+                        obj['modifier'], obj['identifier']
+                    )
+                )
+            else:
+                objects[-(count + 1)]['modifier'] = other_obj
+                remove_index.append(o_count)
+
+        if len(obj['values'][0]) != 0:
+            for value in obj['values'][0]:
+                if '(' in value or '"' in value:
+                    continue
+                # search for dependencies
+                try:
+                    o_count, other_obj = find_object(value, count)
+                except TypeError:
+                    # didn't find any
+                    pass
+                else:
+                    objects[-(count + 1)]['dependencies'].append(other_obj)
+                    remove_index.append(o_count)
+
+    if remove_index:
+        return [obj for index, obj in enumerate(objects) if index not in remove_index]
+    else:
+        return objects
+
+
+# pattern one handles whitespaces inside ( )
+# pattern two handles whitespaces inside " "
+# I assume someone who knows re better than I do can do this in a single run!
+split_pattern_one = re.compile(r"\s+(?=[^(\")]*(?:\(|$))")
+split_pattern_two = re.compile(r"\s+(?=[^()]*(?:\"\w))")
+
+
+def string_to_dict(string):
+    """Get a single Radiance string object as a primitive dictionary."""
+    data = [
+        d for dt in re.split(split_pattern_one, string)
+        for d in re.split(split_pattern_one, str(dt))
+    ]
+
+    modifier, primitive_type, identifier = data[:3]
+    base_data = data[3:]
+
+    count_1 = int(base_data[0])
+    count_2 = int(base_data[count_1 + 1])
+    count_3 = int(base_data[count_1 + count_2 + 2])
+
+    l1 = [] if count_1 == 0 else base_data[1: count_1 + 1]
+    l2 = [] if count_2 == 0 \
+        else base_data[count_1 + 2: count_1 + count_2 + 2]
+    l3 = [] if count_3 == 0 \
+        else base_data[count_1 + count_2 + 3: count_1 + count_2 + count_3 + 3]
+
+    return {
+        'modifier': modifier,
+        'type': primitive_type,
+        'identifier': identifier,
+        'values': [l1, l2, l3],
+        'dependencies': []
+    }
+
+
+def parse_header(filepath):
+    """Return radiance file header if exist.
+
+    This method returns all the lines between `#?RADIANCE` and `FORMAT=*` and number of
+    header lines including the white line after last header line.
+
+    Args:
+        filepath: Full path to Radiance file.
+
+    Returns:
+        line_count, header as a single multiline string
+    """
+    try:
+        inf = open(filepath, 'r', encoding='utf-8')
+    except:
+        # python 2
+        inf = open(filepath, 'r')
+    try:
+        first_line = next(inf)
+        if first_line[:10] != '#?RADIANCE':
+            raise ValueError(
+                'File with Radiance header must start with #?RADIANCE '
+                'not {}.'.format(first_line)
+                )
+        header_lines = [first_line]
+        for line in inf:
+            header_lines.append(line)
+            if line[:7] == 'FORMAT=':
+                break
+        return len(header_lines) + 1, '\n'.join(header_lines)
+    finally:
+        inf.close()
+
+
+def sensor_count_from_file(filepath):
+    """Return sensor count of a sensor grid file.
+
+    This function returns the sensor count of a sensor grid file. Comments [#] and
+    empty lines will not be counted.
+
+    Args:
+        filepath: Full path to Radiance pts file.
+
+    Returns:
+        sensor_count
+    """
+    sensor_count = 0
+    with open(filepath, 'r') as pts_file:
+        for l in pts_file:
+            if not l.strip() or l[0] == '#':
+                pass
+            else:
+                sensor_count += 1
+    return sensor_count

honeybee_radiance/sensor.py

@@ -0,0 +1,166 @@
+"""A light version of test points."""
+from __future__ import division
+import honeybee.typing as typing
+
+import ladybug_geometry.geometry3d.pointvector as pv
+
+import math
+
+
+class Sensor(object):
+    """A radiance sensor.
+
+    Args:
+        pos: Position of sensor as (x, y, z) (Default: (0, 0, 0)).
+        dir: Direction of sensor as (x, y, z) (Default: (0, 0, 1)).
+
+    Properties:
+        * pos
+        * dir
+
+    """
+    __slots__ = ('_pos', '_dir')
+
+    def __init__(self, pos=None, dir=None):
+        """Create a sensor."""
+        self.pos = pos
+        self.dir = dir
+
+    @classmethod
+    def from_dict(cls, sensor_dict):
+        """Create a sensor from dictionary.
+
+        .. code-block:: python
+
+            {
+            'pos': [0, 0, 0],  # array of 3 numbers for the sensor position
+            'dir': [0, 0, 1]  # array of 3 numbers for the sensor direction
+            }
+        """
+        pos = sensor_dict['pos'] if 'pos' in sensor_dict else None
+        direct = sensor_dict['dir'] if 'dir' in sensor_dict else None
+        return cls(pos, direct)
+
+    @classmethod
+    def from_raw_values(cls, x=0, y=0, z=0, dx=0, dy=0, dz=1):
+        """Create a sensor from 6 values.
+
+        x, y, z are the position of the point and dx, dy and dz is the direction.
+        """
+        return cls((x, y, z), (dx, dy, dz))
+
+    @property
+    def pos(self):
+        """Get or set the position of the sensor as a tuple of 3 (x, y, z) numbers."""
+        return self._pos
+
+    @pos.setter
+    def pos(self, value):
+        self._pos = typing.tuple_with_length(value) if value is not None else (0, 0, 0)
+
+    @property
+    def dir(self):
+        """Get or set the dir of the sensor as a tuple of 3 (x, y, z) numbers."""
+        return self._dir
+
+    @dir.setter
+    def dir(self, value):
+        self._dir = typing.tuple_with_length(value) if value is not None else (0, 0, 1)
+
+    def move(self, moving_vec):
+        """Move this sensor along a vector.
+
+        Args:
+            moving_vec: A ladybug_geometry Vector3D with the direction and distance
+                to move the sensor.
+        """
+        self.pos = tuple(pv.Point3D(*self.pos).move(moving_vec))
+
+    def rotate(self, axis, angle, origin):
+        """Rotate this sensor by a certain angle around an axis and origin.
+
+        Args:
+            axis: Rotation axis as a Vector3D.
+            angle: An angle for rotation in degrees.
+            origin: A ladybug_geometry Point3D for the origin around which the
+                object will be rotated.
+        """
+        rad_angle = math.radians(angle)
+        self.pos = tuple(pv.Point3D(*self.pos).rotate(axis, rad_angle, origin))
+        self.dir = tuple(pv.Vector3D(*self.dir).rotate(axis, rad_angle))
+
+    def rotate_xy(self, angle, origin):
+        """Rotate this sensor counterclockwise in the world XY plane by a certain angle.
+
+        Args:
+            angle: An angle in degrees.
+            origin: A ladybug_geometry Point3D for the origin around which the
+                object will be rotated.
+        """
+        rad_angle = math.radians(angle)
+        self.pos = tuple(pv.Point3D(*self.pos).rotate_xy(rad_angle, origin))
+        self.dir = tuple(pv.Vector3D(*self.dir).rotate_xy(rad_angle))
+
+    def reflect(self, plane):
+        """Reflect this sensor across a plane.
+
+        Args:
+            plane: A ladybug_geometry Plane across which the object will
+                be reflected.
+        """
+        self.pos = tuple(pv.Point3D(*self.pos).reflect(plane.n, plane.o))
+        self.dir = tuple(pv.Vector3D(*self.dir).reflect(plane.n))
+
+    def scale(self, factor, origin=None):
+        """Scale this sensor by a factor from an origin point.
+
+        Args:
+            factor: A number representing how much the object should be scaled.
+            origin: A ladybug_geometry Point3D representing the origin from which
+                to scale. If None, it will be scaled from the World origin (0, 0, 0).
+        """
+        self.pos = tuple(pv.Point3D(*self.pos).scale(factor, origin))
+
+    def duplicate(self):
+        """Duplicate the sensor."""
+        return Sensor(self.pos, self.dir)
+
+    def ToString(self):
+        """Overwrite .NET ToString."""
+        return self.__repr__()
+
+    def to_radiance(self):
+        """Return Radiance string for a test point."""
+        return '%s %s' % (
+            ' '.join(str(v) for v in self.pos),
+            ' '.join(str(v) for v in self.dir)
+        )
+
+    def to_dict(self):
+        """Get the sensor as a dictionary.
+
+        .. code-block:: python
+
+            {
+            'pos': [0, 0, 0],  # array of 3 numbers for the sensor position
+            'dir': [0, 0, 1]  # array of 3 numbers for the sensor direction
+            }
+        """
+        return {'pos': self.pos, 'dir': self.dir}
+
+    def __key(self):
+        """A tuple based on the object properties, useful for hashing."""
+        return (hash(self.pos), hash(self.dir))
+
+    def __hash__(self):
+        return hash(self.__key())
+
+    def __eq__(self, other):
+        return isinstance(other, Sensor) and self.__key() == other.__key()
+
+    def __ne__(self, value):
+        return not self.__eq__(value)
+
+    def __repr__(self):
+        """Get the string representation of the sensor grid."""
+        return self.to_radiance()