compas-threejs 1.0.1__py3-none-any.whl

compas_threejs/__init__.py

@@ -0,0 +1,8 @@
+"""COMPAS ThreeJS - A lightweight Three.js viewer for COMPAS using Protobuf."""
+
+__version__ = "1.0.1"
+__author__ = "Eric Gozzi, Nicolas Benjamin Boscoboinik"
+__email__ = "eric.gozzi@arch.ethz.ch"
+__license__ = "MIT"
+
+__all__ = ["__version__", "__author__", "__email__", "__license__"]

compas_threejs/lights/__init__.py

@@ -0,0 +1,15 @@
+from .ambientlight import AmbientLight
+from .pointlight import PointLight
+from .rectlight import RectLight
+from .sky import Sky
+from .spotlight import SpotLight
+from .sunlight import Sunlight
+
+__all__ = [
+    "PointLight",
+    "SpotLight",
+    "RectLight",
+    "Sunlight",
+    "Sky",
+    "AmbientLight",
+]

compas_threejs/lights/ambientlight.py

@@ -0,0 +1,19 @@
+import uuid
+
+from compas.colors import Color
+
+
+class AmbientLight:
+    def __init__(self, color: Color = Color.white(), intensity: float = 500):
+        self.color = color
+        self.intensity = intensity
+        self.guid = str(uuid.uuid4())
+
+    def as_dict(self) -> dict:
+        return {
+            "dispatch": "light",
+            "type": "ambient_light",
+            "guid": self.guid,
+            "color": self.color.hex,
+            "intensity": self.intensity,
+        }

compas_threejs/lights/light.py

@@ -0,0 +1,11 @@
+from abc import ABC
+from abc import abstractmethod
+
+
+class Light(ABC):
+    def __init__(self, **kwargs):
+        self.attributes = kwargs
+
+    @abstractmethod
+    def as_dict(self):
+        raise NotImplementedError

compas_threejs/lights/pointlight.py

@@ -0,0 +1,76 @@
+from uuid import uuid4
+
+from compas.colors import Color
+from compas.geometry import Point
+
+from .light import Light
+
+
+class PointLight(Light):
+    """
+
+    Constructs a new PointLight instance.
+
+    Parameters
+    ----------
+    color : int | Color | str, optional
+        The color of the light. Can be specified as an integer, a Color object, or a string.
+        Default is 0xffffff (white).
+
+    intensity : float, optional
+        The intensity or strength of the light, measured in candela (cd).
+        Default is 1.
+
+    distance : float, optional
+        The maximum range of the light. A value of 0 indicates no limit.
+        Default is 0.
+
+    decay : float, optional
+        The rate at which the light diminishes over distance.
+        Default is 2.
+
+    """
+
+    def __init__(
+        self,
+        point: Point = Point(0, 0, 0),
+        color: Color = Color.white(),
+        intensity: float = 100,
+        distance: float = 0,
+        decay: float = 2,
+        helper: bool = False,
+        **kwargs,
+    ):
+        super().__init__(**kwargs)
+        self.point = point
+        self.color = color
+        self.intensity = intensity
+        self.distance = distance
+        self.decay = decay
+        self.helper = helper
+        self.guid = str(uuid4())
+
+    def as_dict(self) -> dict:
+        return {
+            "dispatch": "light",
+            "type": "point_light",
+            "x": self.point.x,
+            "y": self.point.y,
+            "z": self.point.z,
+            "color": self.color.hex,
+            "intensity": self.intensity,
+            "distance": self.distance,
+            "decay": self.decay,
+            "helper": self.helper,
+            "guid": self.guid,
+        }
+
+    @property
+    def color(self) -> Color:
+        return self._color
+
+    @color.setter
+    def color(self, value: Color):
+        if not isinstance(value, Color):
+            raise TypeError("color must be an instance of Color")
+        self._color = value

compas_threejs/lights/rectlight.py

@@ -0,0 +1,73 @@
+import uuid
+
+from compas.colors import Color
+from compas.geometry import Point
+
+from .light import Light
+
+
+class RectLight(Light):
+    """
+    A rectangular light source.
+
+    The `RectLight` class represents a light source with a rectangular shape,
+    defined by its position, target direction, color, intensity, width, and height.
+
+    Attributes
+    ----------
+    point : :class:`compas.geometry.Point`
+        The position of the light source in 3D space. Defaults to the origin (0, 0, 0).
+    target : :class:`compas.geometry.Point`
+        The target point that the light is directed towards. Defaults to (0, -1, 0).
+    color : :class:`compas.colors.Color`
+        The color of the light. Defaults to white.
+    intensity : float
+        The intensity of the light. Defaults to 1.
+    width : float
+        The width of the rectangular light source. Defaults to 10.
+    height : float
+        The height of the rectangular light source. Defaults to 10.
+    helper : bool
+        Whether to display a helper visualization for the light. Defaults to False.
+    guid : str
+        A unique identifier for the light instance, automatically generated.
+    """
+
+    def __init__(
+        self,
+        point: Point = Point(0, 0, 0),
+        target: Point = Point(0, -1, 0),
+        color: Color = Color.white(),
+        intensity: float = 1,
+        width: float = 10,
+        height: float = 10,
+        helper: bool = False,
+        **kwargs,
+    ):
+        super().__init__(**kwargs)
+        self.point = point
+        self.target = target
+        self.color = color
+        self.intensity = intensity
+        self.width = width
+        self.height = height
+        self.helper = helper
+        self.guid = str(uuid.uuid4())
+
+    def as_dict(self) -> dict:
+        return {
+            "dispatch": "light",
+            "type": "rect_light",
+            "x": self.point.x,
+            "y": self.point.y,
+            "z": self.point.z,
+            "tx": self.target.x,
+            "ty": self.target.y,
+            "tz": self.target.z,
+            "color": self.color.hex,
+            "intensity": self.intensity,
+            "width": self.width,
+            "height": self.height,
+            "helper": self.helper,
+            "guid": self.guid,
+        }

compas_threejs/lights/sky.py

@@ -0,0 +1,57 @@
+import uuid
+
+from .light import Light
+
+
+class Sky(Light):
+    """
+    The Sky class represents a type of light source that simulates the sky's appearance
+    based on various atmospheric parameters.
+
+    Attributes:
+        turbidity (float): The amount of particles in the atmosphere that scatter light.
+                           Higher values result in a hazier sky. Default is 5.
+        rayleigh (float): The scattering coefficient for Rayleigh scattering, which affects
+                          the sky's blue color intensity. Default is 0.15.
+        mie_coefficient (float): The scattering coefficient for Mie scattering, which affects
+                                 the appearance of haze and fog. Default is 0.002.
+        mie_directional_g (float): The anisotropy factor for Mie scattering, controlling the
+                                   directionality of scattered light. Default is 0.95.
+        azimuth (float): The horizontal angle of the sun in degrees, measured clockwise from
+                         the north. Default is 45.
+        elevation (float): The vertical angle of the sun in degrees, measured from the horizon.
+                           Default is 20.
+        guid (str): A unique identifier for the Sky instance, generated automatically.
+    """
+
+    def __init__(
+        self,
+        turbidity: float = 5,
+        rayleigh: float = 0.15,
+        mie_coefficient: float = 0.002,
+        mie_directional_g: float = 0.95,
+        azimuth: float = 45,
+        elevation: float = 20,
+        **kwargs,
+    ):
+        super().__init__(**kwargs)
+        self.turbidity = turbidity
+        self.rayleigh = rayleigh
+        self.mie_coefficient = mie_coefficient
+        self.mie_directional_g = mie_directional_g
+        self.azimuth = azimuth
+        self.elevation = elevation
+        self.guid = str(uuid.uuid4())
+
+    def as_dict(self) -> dict:
+        return {
+            "dispatch": "light",
+            "type": "sky",
+            "turbidity": self.turbidity,
+            "rayleigh": self.rayleigh,
+            "mie_coefficient": self.mie_coefficient,
+            "mie_directional_g": self.mie_directional_g,
+            "azimuth": self.azimuth,
+            "elevation": self.elevation,
+            "guid": self.guid,
+        }

compas_threejs/lights/spotlight.py

@@ -0,0 +1,143 @@
+import math
+import uuid
+
+from compas.colors import Color
+from compas.geometry import Point
+
+
+class SpotLight:
+    """
+    A class representing a spotlight in a 3D environment.
+
+    The SpotLight class defines a light source that emits light in a specific direction
+    with a conical shape. It includes properties for position, target, color, intensity,
+    distance, angle, penumbra, and decay, among others.
+
+    Attributes
+    ----------
+        point: Point
+            The position of the spotlight in 3D space.
+        target: Point
+            The target point that the spotlight is directed towards.
+        color: Color
+            The color of the light emitted by the spotlight.
+        intensity: float
+            The brightness of the light. Must be non-negative.
+        distance: float
+            The maximum range of the light. Must be non-negative.
+        angle: float
+            The angle of the spotlight's cone in radians. Must be between 0 and π/2.
+        penumbra: float
+            The softness of the spotlight's edge. Must be between 0 and 1.
+        decay: float
+            The rate at which the light intensity decreases over distance. Must be non-negative.
+        helper: bool
+            Whether to display a helper visualization for the spotlight.
+        guid: str
+            A unique identifier for the spotlight instance.
+    """
+
+    def __init__(
+        self,
+        point: Point = Point(0, 0, 0),
+        target: Point = Point(0, 0, -1),
+        color: Color = Color.white(),
+        intensity: float = 100,
+        distance: float = 0,
+        angle: float = math.pi / 7,
+        penumbra: float = 0,
+        decay: float = 1,
+        helper: bool = False,
+        **kwargs,
+    ):
+        super().__init__(**kwargs)
+        self.point = point
+        self.target = target
+        self.color = color
+        self.intensity = intensity
+        self.distance = distance
+        self.angle = angle
+        self.penumbra = penumbra
+        self.decay = decay
+        self.helper = helper
+        self.guid = str(uuid.uuid4())
+
+    def as_dict(self) -> dict:
+        return {
+            "dispatch": "light",
+            "type": "spot_light",
+            "x": self.point.x,
+            "y": self.point.y,
+            "z": self.point.z,
+            "tx": self.target.x,
+            "ty": self.target.y,
+            "tz": self.target.z,
+            "color": self.color.hex,
+            "intensity": self.intensity,
+            "distance": self.distance,
+            "angle": self.angle,
+            "penumbra": self.penumbra,
+            "decay": self.decay,
+            "helper": self.helper,
+            "guid": self.guid,
+        }
+
+    @property
+    def color(self) -> Color:
+        return self._color
+
+    @color.setter
+    def color(self, value: Color):
+        if not isinstance(value, Color):
+            raise TypeError("color must be an instance of Color")
+        self._color = value
+
+    @property
+    def intensity(self) -> float:
+        return self._intensity
+
+    @intensity.setter
+    def intensity(self, value: float):
+        if value < 0:
+            raise ValueError("Intensity must be non-negative.")
+        self._intensity = value
+
+    @property
+    def distance(self) -> float:
+        return self._distance
+
+    @distance.setter
+    def distance(self, value: float):
+        if value < 0:
+            raise ValueError("Distance must be non-negative.")
+        self._distance = value
+
+    @property
+    def angle(self) -> float:
+        return self._angle
+
+    @angle.setter
+    def angle(self, value: float):
+        if not (0 < value <= math.pi / 2):
+            raise ValueError("Angle must be between 0 and π/2 radians.")
+        self._angle = value
+
+    @property
+    def penumbra(self) -> float:
+        return self._penumbra
+
+    @penumbra.setter
+    def penumbra(self, value: float):
+        if not (0 <= value <= 1):
+            raise ValueError("Penumbra must be between 0 and 1.")
+        self._penumbra = value
+
+    @property
+    def decay(self) -> float:
+        return self._decay
+
+    @decay.setter
+    def decay(self, value: float):
+        if value < 0:
+            raise ValueError("Decay must be non-negative.")
+        self._decay = value

compas_threejs/lights/sunlight.py

@@ -0,0 +1,72 @@
+import uuid
+
+from compas.colors import Color
+from compas.geometry import Point
+from compas.geometry import Vector
+
+from .light import Light
+
+
+class Sunlight(Light):
+    """
+    A class representing sunlight in a 3D scene.
+
+    The Sunlight class is a type of light source that simulates sunlight. It is defined
+    by its color, position, direction, intensity, and an optional helper for visualization.
+
+    Attributes
+    ----------
+    color : :class:`compas.colors.Color`
+        The color of the sunlight. Defaults to white.
+    point : :class:`compas.geometry.Point`
+        The position of the sunlight source in 3D space. Defaults to the origin (0, 0, 0).
+    direction : :class:`compas.geometry.Vector`
+        The direction vector of the sunlight. Defaults to (-1, -1, -1).
+    intensity : float
+        The intensity of the sunlight. Defaults to 500.
+    helper : bool
+        A flag indicating whether a helper visualization is enabled. Defaults to False.
+    guid : str
+        A unique identifier for the sunlight instance, automatically generated.
+    """
+
+    def __init__(
+        self,
+        color: Color = Color.white(),
+        point: Point = Point(0, 0, 0),
+        direction: Vector = Vector(-1, -1, -1),
+        intensity: float = 500,
+        helper: bool = False,
+        **kwargs,
+    ):
+        super().__init__(**kwargs)
+        self.color = color
+        self.point = point
+        self.direction = direction
+        self.intensity = intensity
+        self.helper = helper
+        self.guid = str(uuid.uuid4())
+
+    @property
+    def target(self) -> Point:
+        return Point(
+            self.point.x + self.direction.x,
+            self.point.y + self.direction.y,
+            self.point.z + self.direction.z,
+        )
+
+    def as_dict(self) -> dict:
+        return {
+            "dispatch": "light",
+            "type": "sunlight",
+            "color": self.color.hex,
+            "x": self.point.x,
+            "y": self.point.y,
+            "z": self.point.z,
+            "tx": self.target.x,
+            "ty": self.target.y,
+            "tz": self.target.z,
+            "intensity": self.intensity,
+            "helper": self.helper,
+            "guid": self.guid,
+        }

compas_threejs/materials/__init__.py

@@ -0,0 +1,6 @@
+from .line_material import LineMaterial
+from .material import Material
+from .physical_material import PhysicalMaterial
+from .point_material import PointMaterial
+
+__all__ = ["Material", "LineMaterial", "PhysicalMaterial", "PointMaterial"]

compas_threejs/materials/generic_material.py

@@ -0,0 +1,11 @@
+from abc import ABC
+from abc import abstractmethod
+
+
+class GenericMaterial(ABC):
+    def __init__(self, **kwargs):
+        self.attributes = kwargs
+
+    @abstractmethod
+    def as_dict(self):
+        raise NotImplementedError

compas_threejs/materials/line_material.py

@@ -0,0 +1,30 @@
+from uuid import uuid4
+
+from compas.colors import Color
+
+from .generic_material import GenericMaterial
+
+
+class LineMaterial(GenericMaterial):
+    """
+    Represents the material properties for rendering lines in a 3D scene.
+
+    Parameters
+    ----------
+    color : Color, optional
+        The color of the line. Default is blue.
+    """
+
+    def __init__(self, color: Color = Color.blue(), linewidth: int = 2):
+        self.color = color
+        self._geometry_guid = ""
+        self.guid = str(uuid4())
+
+    def as_dict(self) -> dict:
+        return {
+            "dispatch": "material",
+            "type": "line_material",
+            "geometry_guid": self._geometry_guid,
+            "color": self.color.hex,
+            "guid": self.guid,
+        }

compas_threejs/materials/material.py

@@ -0,0 +1,161 @@
+from uuid import uuid4
+
+from compas.colors import Color
+
+from .generic_material import GenericMaterial
+
+
+class Material(GenericMaterial):
+    """
+    Represents the standard material properties for a 3D object.
+
+    Parameters
+    ----------
+    color : Color, optional
+        The base color of the material. Default is white.
+    metalness : float, optional
+        The metalness of the material, between 0 and 1. Default is 0 (non-metallic).
+    roughness : float, optional
+        The roughness of the material, between 0 and 1. Default is 1 (fully rough).
+    emissive : Color, optional
+        The emissive color of the material. Default is black (no emission).
+    emissive_intensity : float, optional
+        The intensity of the emissive color. Default is 0 (no emission).
+    flat_shading : bool, optional
+        Whether to use flat shading. Default is False (smooth shading).
+    wireframe : bool, optional
+        Whether to render the material as a wireframe. Default is False (solid rendering).
+    """
+
+    def __init__(
+        self,
+        color: Color = Color.white(),
+        metalness: float = 0,
+        roughness: float = 1,
+        emissive: Color = Color.black(),
+        emissive_intensity: float = 0,
+        flat_shading: bool = False,
+        wireframe: bool = False,
+        transparent: bool = False,
+        opacity: float = 1,
+        **kwargs,
+    ):
+        super().__init__(**kwargs)
+        self.color = color
+        self.metalness = metalness
+        self.roughness = roughness
+        self.emissive = emissive
+        self.emissive_intensity = emissive_intensity
+        self.flat_shading = flat_shading
+        self.wireframe = wireframe
+        self._geometry_guid = ""
+        self.transparent = transparent
+        self.opacity = opacity
+        self.guid = str(uuid4())
+
+    def as_dict(self) -> dict:
+        return {
+            "dispatch": "material",
+            "type": "standard_material",
+            "geometry_guid": self._geometry_guid,
+            "color": self.color.hex,
+            "metalness": self.metalness,
+            "roughness": self.roughness,
+            "emissive": self.emissive.hex,
+            "emissive_intensity": self.emissive_intensity,
+            "flat_shading": self.flat_shading,
+            "wireframe": self.wireframe,
+            "transparent": self.transparent,
+            "opacity": self.opacity,
+            "guid": self.guid,
+        }
+
+    @property
+    def color(self) -> Color:
+        return self._color
+
+    @color.setter
+    def color(self, value: Color):
+        if not isinstance(value, Color):
+            raise TypeError("color must be an instance of Color")
+        self._color = value
+
+    @property
+    def emissive(self) -> Color:
+        return self._emissive
+
+    @emissive.setter
+    def emissive(self, value: Color):
+        if not isinstance(value, Color):
+            raise TypeError("emissive must be an instance of Color")
+        self._emissive = value
+
+    @property
+    def metalness(self) -> float:
+        return self._metalness
+
+    @metalness.setter
+    def metalness(self, value: float):
+        if not (0 <= value <= 1):
+            raise ValueError("metalness must be between 0 and 1")
+        self._metalness = value
+
+    @property
+    def roughness(self) -> float:
+        return self._roughness
+
+    @roughness.setter
+    def roughness(self, value: float):
+        if not (0 <= value <= 1):
+            raise ValueError("roughness must be between 0 and 1")
+        self._roughness = value
+
+    @property
+    def emissive_intensity(self) -> float:
+        return self._emissive_intensity
+
+    @emissive_intensity.setter
+    def emissive_intensity(self, value: float):
+        if value < 0:
+            raise ValueError("emissive_intensity must be non-negative")
+        self._emissive_intensity = value
+
+    @property
+    def flat_shading(self) -> bool:
+        return self._flat_shading
+
+    @flat_shading.setter
+    def flat_shading(self, value: bool):
+        if not isinstance(value, bool):
+            raise TypeError("flat_shading must be a boolean")
+        self._flat_shading = value
+
+    @property
+    def wireframe(self) -> bool:
+        return self._wireframe
+
+    @wireframe.setter
+    def wireframe(self, value: bool):
+        if not isinstance(value, bool):
+            raise TypeError("wireframe must be a boolean")
+        self._wireframe = value
+
+    @property
+    def transparent(self) -> bool:
+        return self._transparent
+
+    @transparent.setter
+    def transparent(self, value: bool):
+        if not isinstance(value, bool):
+            raise TypeError("transparent must be a boolean")
+        self._transparent = value
+
+    @property
+    def opacity(self) -> float:
+        return self._opacity
+
+    @opacity.setter
+    def opacity(self, value: float):
+        if not (0 <= value <= 1):
+            raise ValueError("opacity must be between 0 and 1")
+        self._opacity = value