Source code for ladybug_geometry.geometry3d.cone

# coding=utf-8
from __future__ import division

from .pointvector import Point3D, Vector3D
from .plane import Plane
from .arc import Arc3D

import math

[docs]class Cone(object): """Cone object. Args: vertex: A Point3D at the tip of the cone. axis: A Vector3D representing the direction and height of the cone. The vector extends from the vertex to the center of the base. angle: An angle in radians representing the half angle between the axis and the surface. Properties: * vertex * axis * angle * height * slant_height * radius * area * volume * min * max * base """ __slots__ = ('_vertex', '_axis', '_angle', '_base', '_min', '_max') def __init__(self, vertex, axis, angle): """Initialize Cone.""" assert isinstance(vertex, Point3D), \ "Expected Point3D. Got {}.".format(type(vertex)) assert isinstance(axis, Vector3D), \ "Expected Vector3D. Got {}.".format(type(axis)) assert angle > 0, 'Cone angle must be greater than 0. Got {}.'.format(angle) self._vertex = vertex self._axis = axis self._angle = angle self._base = None self._min = None self._max = None
[docs] @classmethod def from_dict(cls, data): """Create a Cone from a dictionary. Args: data: A python dictionary in the following format .. code-block:: python { "type": "Cone" "vertex": (10, 0, 0), "axis": (0, 0, 1), "angle": 1.0 } """ return cls(Point3D.from_array(data['vertex']), Vector3D.from_array(data['axis']), data['angle'])
@property def vertex(self): """Vertex of cone.""" return self._vertex @property def axis(self): """Axis of cone.""" return self._axis @property def angle(self): """Angle of cone""" return self._angle @property def height(self): """Height of cone""" return self.axis.magnitude @property def radius(self): """Radius of a cone""" return self.height * math.tan(self.angle) @property def slant_height(self): """Slant height of a cone""" return math.sqrt(self.radius ** 2 + self.height ** 2) @property def area(self): """Surface area of a cone""" return math.pi * self.radius ** 2 + math.pi * self.radius * self.slant_height @property def volume(self): """Volume of a cone""" return 1 / 3 * math.pi * self.radius ** 2 * self.height @property def base(self): """Get an Arc3D representing the circular base of the cone.""" if self._base is None: plane = Plane(self.axis.reverse(), self.vertex + self.axis) self._base = Arc3D(plane, self.radius) return self._base @property def min(self): """A Point3D for the minimum bounding box vertex around this geometry.""" if self._min is None: self._calculate_min_max() return self._min @property def max(self): """A Point3D for the maximum bounding box vertex around this geometry.""" if self._max is None: self._calculate_min_max() return self._max
[docs] def move(self, moving_vec): """Get a cone that has been moved along a vector. Args: moving_vec: A Vector3D with the direction and distance to move the cone. """ return Cone(self.vertex.move(moving_vec), self.axis, self.angle)
[docs] def rotate(self, axis, angle, origin): """Rotate this cone by a certain angle around an axis and origin. Right hand rule applies: If axis has a positive orientation, rotation will be clockwise. If axis has a negative orientation, rotation will be counterclockwise. Args: axis: A Vector3D axis representing the axis of rotation. angle: An angle for rotation in radians. origin: A Point3D for the origin around which the cone will be rotated. """ return Cone(self.vertex.rotate(axis, angle, origin), self.axis.rotate(axis, angle), self.angle)
[docs] def rotate_xy(self, angle, origin): """Get a cone that is rotated counterclockwise in the world XY plane by an angle. Args: angle: An angle for rotation in radians. origin: A Point3D for the origin around which the cone will be rotated. """ return Cone(self.vertex.rotate_xy(angle, origin), self.axis.rotate_xy(angle), self.angle)
[docs] def reflect(self, normal, origin): """Get a cone reflected across a plane with the input normal vector and origin. Args: normal: A Vector3D representing the normal vector for the plane across which the arc will be reflected. THIS VECTOR MUST BE NORMALIZED. origin: A Point3D representing the origin from which to reflect. """ return Cone(self.vertex.reflect(normal, origin), self.axis.reflect(normal), self.angle)
[docs] def scale(self, factor, origin=None): """Scale a cone by a factor from an origin point. Args: factor: A number representing how much the cone should be scaled. origin: A Point3D representing the origin from which to scale. If None, it will be scaled from the World origin (0, 0, 0). """ return Cone(self.vertex.scale(factor, origin), self.axis * factor, self.angle)
[docs] def duplicate(self): """Get a copy of this object.""" return self.__copy__()
[docs] def to_dict(self): """Get Cone as a dictionary.""" return { 'type': 'Cone', 'vertex': self.vertex.to_array(), 'axis': self.axis.to_array(), 'angle': self.angle }
def _calculate_min_max(self): """Calculate maximum and minimum Point3D for this object.""" base = self.base bmn, bmx, ver = base.min, base.max, self.vertex self._min = Point3D(min(bmn.x, ver.x), min(bmn.y, ver.y), min(bmn.z, ver.z)) self._max = Point3D(max(bmx.x, ver.x), max(bmx.y, ver.y), max(bmx.z, ver.z)) def __copy__(self): return Cone(self.vertex, self.axis, self.angle) def __key(self): """A tuple based on the object properties, useful for hashing.""" return (self._vertex, self._axis, self._angle) def __hash__(self): return hash(self.__key()) def __eq__(self, other): return isinstance(other, Cone) and self.__key() == other.__key() def __ne__(self, other): return not self.__eq__(other)
[docs] def ToString(self): """Overwrite .NET ToString.""" return self.__repr__()
def __repr__(self): return 'Cone (vertex {}) (axis {}) (angle {}) (height {})'.\ format(self.vertex, self.axis, self.angle, self.height)