honeybee-radiance 1.66.190__py3-none-any.whl

honeybee_radiance/geometry/cylinder.py

@@ -0,0 +1,197 @@
+"""Radiance Cylinder.
+
+http://radsite.lbl.gov/radiance/refer/ray.html#Cylinder
+"""
+from .geometrybase import Geometry
+import honeybee.typing as typing
+
+
+class Cylinder(Geometry):
+    """Radiance Cylinder.
+
+    A cylinder is like a cone, but its starting and ending radii are equal.
+
+    .. code-block:: shell
+
+        mod cylinder id
+        0
+        0
+        7
+                x0      y0      z0
+                x1      y1      z1
+                rad
+
+    Args:
+        identifier: Text string for a unique Geometry ID. Must not contain spaces
+            or special characters. This will be used to identify the object across
+            a model and in the exported Radiance files.
+        center_pt_start: Cylinder start center point as (x, y, z)
+            (Default: (0, 0 ,0)).
+        center_pt_end: Cylinder end center point as (x, y, z) (Default: (0, 0 ,10)).
+        radius: Cylinder start radius as a number (Default: 10).
+        modifier: Geometry modifier (Default: None).
+        dependencies: A list of primitives that this primitive depends on. This
+            argument is only useful for defining advanced primitives where the
+            primitive is defined based on other primitives. (Default: [])
+
+    Properties:
+        * identifier
+        * display_name
+        * center_pt_start
+        * center_pt_end
+        * radius
+        * values
+        * modifier
+        * dependencies
+    """
+    __slots__ = ('_center_pt_start', '_center_pt_end', '_radius')
+
+    def __init__(self, identifier, center_pt_start=None, center_pt_end=None, radius=10,
+                 modifier=None, dependencies=None):
+        """Radiance Cylinder."""
+        Geometry.__init__(self, identifier, modifier=modifier, dependencies=dependencies)
+        self.center_pt_start = center_pt_start or (0, 0, 0)
+        self.center_pt_end = center_pt_end or (0, 0, 10)
+        self.radius = radius if radius is not None else 10
+        self._update_values()
+
+    def _update_values(self):
+        """update value dictionaries."""
+        self._values[2] = \
+            [self.center_pt_start[0], self.center_pt_start[1], self.center_pt_start[2],
+             self.center_pt_end[0], self.center_pt_end[1], self.center_pt_end[2],
+             self.radius]
+
+    @property
+    def center_pt_start(self):
+        """Cone start center point as (x, y, z). Default is (0, 0 ,0)."""
+        return self._center_pt_start
+
+    @center_pt_start.setter
+    def center_pt_start(self, value):
+        self._center_pt_start = tuple(float(v) for v in value)
+        assert len(self._center_pt_start) == 3, \
+            'Radiance Cylinder center point must have 3 values for (x, y, z).'
+
+    @property
+    def radius(self):
+        """Cone start radius as a number. Default is 10."""
+        return self._radius
+
+    @radius.setter
+    def radius(self, value):
+        self._radius = typing.float_positive(value)
+
+    @property
+    def center_pt_end(self):
+        """Cone end center point as (x, y, z), Default is (0, 0 ,10)."""
+        return self._center_pt_end
+
+    @center_pt_end.setter
+    def center_pt_end(self, value):
+        self._center_pt_end = tuple(float(v) for v in value)
+        assert len(self._center_pt_end) == 3, \
+            'Radiance Cylinder center point must have 3 values for (x, y, z).'
+
+    @classmethod
+    def from_primitive_dict(cls, primitive_dict):
+        """Initialize a Cylinder from a primitive dict.
+
+        Args:
+            data: A dictionary in the format below.
+
+        .. code-block:: python
+
+            {
+            "modifier": {},  # primitive modifier (Default: None)
+            "type": "cylinder",  # primitive type
+            "identifier": "",  # primitive identifier
+            "display_name": "",  # primitive display name
+            "values": [],  # values
+            "dependencies": []
+            }
+        """
+        assert 'type' in primitive_dict, 'Input dictionary is missing "type".'
+        if primitive_dict['type'] != cls.__name__.lower():
+            raise ValueError(
+                'Type must be %s not %s.' % (cls.__name__.lower(), primitive_dict['type'])
+            )
+
+        modifier, dependencies = cls.filter_dict_input(primitive_dict)
+        values = primitive_dict['values'][2]
+
+        cls_ = cls(
+            identifier=primitive_dict['identifier'],
+            center_pt_start=values[0:3],
+            center_pt_end=values[3:6],
+            radius=values[6],
+            modifier=modifier,
+            dependencies=dependencies
+        )
+        if 'display_name' in primitive_dict and primitive_dict['display_name'] is not None:
+            cls_.display_name = primitive_dict['display_name']
+
+        # this might look redundant but it is NOT. see glass for explanation.
+        cls_.values = primitive_dict['values']
+        return cls_
+
+    @classmethod
+    def from_dict(cls, data):
+        """Initialize a Cylinder from a dictionary.
+
+        Args:
+            data: A dictionary in the format below.
+
+        .. code-block:: python
+
+            {
+            "type": "cylinder",  # Geometry type
+            "modifier": {} ,
+            "identifier": "",  # Geometry identifer
+            "display_name": "",  # Geometry display name
+            "center_pt_start": (0, 0, 0),
+            "center_pt_end": (0, 0, 10),
+            "radius": float,
+            "dependencies": []
+            }
+        """
+        assert 'type' in data, 'Input dictionary is missing "type".'
+        if data['type'] != cls.__name__.lower():
+            raise ValueError(
+                'Type must be %s not %s.' % (cls.__name__.lower(),
+                    data['type'])
+            )
+        modifier, dependencies = cls.filter_dict_input(data)
+
+        new_obj = cls(identifier=data["identifier"],
+                      center_pt_start=(data["center_pt_start"]),
+                      center_pt_end=(data["center_pt_end"]),
+                      radius=data["radius"],
+                      modifier=modifier,
+                      dependencies=dependencies)
+        if 'display_name' in data and data['display_name'] is not None:
+            new_obj.display_name = data['display_name']
+        return new_obj
+
+    def to_dict(self):
+        """Translate this object to a dictionary."""
+        base = {
+            "modifier": self.modifier.to_dict(),
+            "type": self.__class__.__name__.lower(),
+            "identifier": self.identifier,
+            "center_pt_start": self.center_pt_start,
+            "radius": self.radius,
+            "center_pt_end": self.center_pt_end,
+            'dependencies': [dp.to_dict() for dp in self.dependencies]
+        }
+        if self._display_name is not None:
+            base['display_name'] = self.display_name
+        return base
+
+    def __copy__(self):
+        mod, depend = self._dup_mod_and_depend()
+        new_obj = self.__class__(
+            self.identifier, self.center_pt_start, self.center_pt_end, self.radius,
+            mod, depend)
+        new_obj._display_name = self._display_name
+        return new_obj

honeybee_radiance/geometry/geometrybase.py

@@ -0,0 +1,37 @@
+"""Base Radiance Geometry class (e.g polygon, sphere, source, etc.).
+
+Radiance supports a number of native geometry primitives. The one that is most
+commonly used to represent planar geometry is a Polygon but many of the other
+geometry primitives can be used to specify simple types of curved geometry with
+a fraction of the file size, memory, and computational power needed to support
+a planar approximation of curved geometry. More information on Radiance geometry
+Primitives can be found at:
+
+https://floyd.lbl.gov/radiance/refer/ray.html#Surfaces
+"""
+from ..primitive import Primitive
+
+
+class Geometry(Primitive):
+    """Base class for Radiance geometries.
+
+    Properties:
+        * identifier
+        * display_name
+        * values
+        * modifier
+        * dependencies
+        * is_geometry
+        * is_modifier
+        * is_material
+        * is_texture
+        * is_pattern
+        * is_mixture
+        * is_opaque
+"""
+    __slots__ = ()
+
+    @property
+    def is_geometry(self):
+        """Get a boolean noting whether this object is a Radiance geometry."""
+        return True

honeybee_radiance/geometry/instance.py

@@ -0,0 +1,40 @@
+"""Radiance Transfunc Instance.
+
+http://radsite.lbl.gov/radiance/refer/ray.html#Instance
+"""
+from .geometrybase import Geometry
+
+
+# TODO(): Implement the class. It's currently creates this geometry as generic Radiance
+# geometry
+class Instance(Geometry):
+    """Radiance Instance.
+
+    An instance is a compound surface, given by the contents of an octree file (created
+    by oconv).
+
+    .. code-block:: shell
+
+        mod instance id
+        1+ octree transform
+        0
+        0
+
+    If the modifier is "void", then surfaces will use the modifiers given in the original
+    description. Otherwise, the modifier specified is used in their place. The transform
+    moves the octree to the desired location in the scene. Multiple instances using the
+    same octree take little extra memory, hence very complex descriptions can be rendered
+    using this primitive.
+
+    There are a number of important limitations to be aware of when using instances.
+    First, the scene description used to generate the octree must stand on its own,
+    without referring to modifiers in the parent description. This is necessary for
+    oconv to create the octree. Second, light sources in the octree will not be
+    incorporated correctly in the calculation, and they are not recommended. Finally,
+    there is no advantage (other than convenience) to using a single instance of an
+    octree, or an octree containing only a few surfaces. An xform command on the
+    subordinate description is preferred in such cases.
+    """
+    __slots__ = ()
+
+    pass

honeybee_radiance/geometry/mesh.py

@@ -0,0 +1,38 @@
+"""Radiance Transfunc Mesh.
+
+http://radsite.lbl.gov/radiance/refer/ray.html#Mesh
+"""
+from .geometrybase import Geometry
+
+
+# TODO(): Implement the class. It's currently creates this geometry as generic Radiance
+# geometry
+class Mesh(Geometry):
+    """Radiance Mesh.
+
+    A mesh is a compound surface, made up of many triangles and an octree data structure
+    to accelerate ray intersection. It is typically converted from a Wavefront .OBJ file
+    using the obj2mesh program.
+
+    .. code-block:: shell
+
+        mod mesh id
+        1+ meshfile transform
+        0
+        0
+
+    If the modifier is "void", then surfaces will use the modifiers given in the original
+    mesh description. Otherwise, the modifier specified is used in their place. The
+    transform moves the mesh to the desired location in the scene. Multiple instances
+    using the same meshfile take little extra memory, and the compiled mesh itself takes
+    much less space than individual polygons would. In the case of an unsmoothed mesh,
+    using the mesh primitive reduces memory requirements by a factor of 30 relative to
+    individual triangles. If a mesh has smoothed surfaces, we save a factor of 50 or
+    more, permitting very detailed geometries that would otherwise exhaust the available
+    memory. In addition, the mesh primitive can have associated (u,v) coordinates for
+    pattern and texture mapping. These are made available to function files via the Lu
+    and Lv variables.
+    """
+    __slots__ = ()
+
+    pass

honeybee_radiance/geometry/polygon.py

@@ -0,0 +1,174 @@
+"""Radiance Polygon.
+
+http://radsite.lbl.gov/radiance/refer/ray.html#Polygon
+"""
+from .geometrybase import Geometry
+
+
+class Polygon(Geometry):
+    """Radiance Polygon.
+
+    A polygon is given by a list of three-dimensional vertices, which are ordered
+    counter-clockwise as viewed from the front side (into the surface normal). The last
+    vertex is automatically connected to the first. Holes are represented in polygons as
+    interior vertices connected to the outer perimeter by coincident edges (seams).
+
+    .. code-block:: shell
+
+        mod polygon id
+        0
+        0
+        3n
+                x1      y1      z1
+                x2      y2      z2
+                ...
+                xn      yn      zn
+
+    Args:
+        identifier: Text string for a unique Geometry ID. Must not contain spaces
+            or special characters. This will be used to identify the object across
+            a model and in the exported Radiance files.
+        vertices: Minimum of three arrays, each with 3 (x, y, z) values for
+            vertices that make up the polygon. Vertices must be ordered
+            counter-clockwise as viewed from the front side. The last vertex is
+            assumed to be connected to the first.
+        modifier: Geometry modifier (Default: None).
+        dependencies: A list of primitives that this primitive depends on. This
+            argument is only useful for defining advanced primitives where the
+            primitive is defined based on other primitives. (Default: [])
+
+    Properties:
+        * identifier
+        * display_name
+        * vertices
+        * modifier
+        * dependencies
+        * values
+
+    Usage:
+
+    .. code-block:: python
+
+        polygon = Polygon("test_polygon", [(0, 0, 10), (10, 0, 10), (10, 0, 0)])
+        print(polygon)
+    """
+    __slots__ = ('_vertices',)
+
+    def __init__(self, identifier, vertices, modifier=None, dependencies=None):
+        """Radiance Polygon."""
+        Geometry.__init__(self, identifier, modifier=modifier, dependencies=dependencies)
+        self.vertices = vertices
+        self._update_values()
+
+    def _update_values(self):
+        """update values dictionary."""
+        self._values[2] = [v for pt in self.vertices for v in pt]
+
+    @property
+    def vertices(self):
+        """List of Polygon vertices."""
+        return self._vertices
+
+    @vertices.setter
+    def vertices(self, vertices):
+        self._vertices = tuple(tuple(float(v) for v in pt) for pt in vertices)
+        assert len(self._vertices) > 2, 'Number of polygon vertices must be 3 or more.'
+        for vert in self._vertices:
+            assert len(vert) == 3, 'Polygon vertices must have 3 values for (x, y, z).'
+
+    @classmethod
+    def from_primitive_dict(cls, primitive_dict):
+        """Initialize a Polygon from a primitive dict.
+
+        Args:
+            data: A dictionary in the format below.
+
+        .. code-block:: python
+
+            {
+            "modifier": {},  # primitive modifier (Default: None)
+            "type": "polygon",  # primitive type
+            "identifier": "",  # primitive identifier
+            "display_name": "",  # primitive display name
+            "values": [],  # values
+            "dependencies": []
+            }
+        """
+        assert 'type' in primitive_dict, 'Input dictionary is missing "type".'
+        if primitive_dict['type'] != cls.__name__.lower():
+            raise ValueError(
+                'Type must be %s not %s.' % (cls.__name__.lower(), primitive_dict['type'])
+            )
+
+        modifier, dependencies = cls.filter_dict_input(primitive_dict)
+        vertices_xyz = primitive_dict['values'][2]
+        assert len(vertices_xyz) % 3 == 0, \
+            'Number of coordinates must be divisible by 3.' \
+            ' Invalid length: [%d].' % len(vertices_xyz)
+
+        cls_ = cls(
+            identifier=primitive_dict['identifier'],
+            vertices=(vertices_xyz[i:i + 3] for i in range(0, len(vertices_xyz), 3)),
+            modifier=modifier,
+            dependencies=dependencies
+        )
+        if 'display_name' in primitive_dict and primitive_dict['display_name'] is not None:
+            cls_.display_name = primitive_dict['display_name']
+
+        # this might look redundant but it is NOT. see glass for explanation.
+        cls_.values = primitive_dict['values']
+        return cls_
+
+    @classmethod
+    def from_dict(cls, data):
+        """Initialize a Polygon from a dictionary.
+
+        Args:
+            data: A dictionary in the format below.
+
+        .. code-block:: python
+
+            {
+            "type": "polygon",  # Geometry type
+            "modifier": {} ,
+            "identifier": "",  # Geometry identifier
+            "display_name": "",  # Geometry display name
+            "vertices": [(0, 0, 10), (10, 0, 10), (10, 0, 0)],
+            "dependencies": []
+            }
+        """
+        assert 'type' in data, 'Input dictionary is missing "type".'
+        if data['type'] != cls.__name__.lower():
+            raise ValueError(
+                'Type must be %s not %s.' % (cls.__name__.lower(), data['type'])
+            )
+        modifier, dependencies = cls.filter_dict_input(data)
+
+        new_obj = cls(
+            identifier=data["identifier"],
+            vertices=data["vertices"],
+            modifier=modifier,
+            dependencies=dependencies
+        )
+        if 'display_name' in data and data['display_name'] is not None:
+            new_obj.display_name = data['display_name']
+        return new_obj
+
+    def to_dict(self):
+        """Translate this object to a dictionary."""
+        base = {
+            "modifier": self.modifier.to_dict(),
+            "type": self.__class__.__name__.lower(),
+            "identifier": self.identifier,
+            "vertices": self.vertices,
+            'dependencies': [dp.to_dict() for dp in self.dependencies]
+        }
+        if self._display_name is not None:
+            base['display_name'] = self.display_name
+        return base
+
+    def __copy__(self):
+        mod, depend = self._dup_mod_and_depend()
+        new_obj = self.__class__(self.identifier, self.vertices, mod, depend)
+        new_obj._display_name = self._display_name
+        return new_obj