luminarycloud 0.15.5__py3-none-any.whl → 0.16.1__py3-none-any.whl

luminarycloud/vis/filters.py

@@ -15,9 +15,10 @@ from .display import Field, DisplayAttributes
 from typing import List, Any, cast
 from .primitives import Box, Plane
 from .vis_util import generate_id
+from .._helpers._code_representation import CodeRepr
 
 
-class Filter(ABC):
+class Filter(ABC, CodeRepr):
     """
     This is the base class for all filters. Each derived filter class
     is responsible for providing a _to_proto method to convert to a filter
@@ -95,7 +96,7 @@ class Slice(Filter):
         Specifies this filter's appearance.
     """
 
-    def __init__(self, name: str) -> None:
+    def __init__(self, name: str = "") -> None:
         super().__init__(generate_id("slice-"))
         self._plane = Plane()
         self._project_vectors: bool = False
@@ -166,7 +167,7 @@ class Isosurface(Filter):
         Specifies this filter's appearance.
     """
 
-    def __init__(self, name: str) -> None:
+    def __init__(self, name: str = "") -> None:
         super().__init__(generate_id("contour-"))
         self.isovalues: List[float] = []
         self.field: Field = Field()
@@ -233,11 +234,9 @@ class PlaneClip(Filter):
         are removed. Default: False
     """
 
-    def __init__(self, name: str) -> None:
+    def __init__(self, name: str = "") -> None:
         super().__init__(generate_id("planeClip-"))
         self._plane: Plane = Plane()
-        # TODO(matt): We could make this a prop to that is unsettable. Or we could
-        # not use ids and force that the filter names are unique.
         self.name = name
         self.inverted: bool = False
 
@@ -296,7 +295,7 @@ class BoxClip(Filter):
         Default : False
     """
 
-    def __init__(self, name: str) -> None:
+    def __init__(self, name: str = "") -> None:
         super().__init__(generate_id("boxClip-"))
         self._box: Box = Box()
         self.name = name
@@ -358,17 +357,11 @@ class VectorGlyphs(Filter):
 
     """
 
-    def __init__(self, name: str) -> None:
+    def __init__(self, name: str = "") -> None:
         super().__init__(generate_id("vector-"))
         self.name: str = name
-        # TODO(matt): we should be able to help set some reasonable defaults bases
-        # on the mesh size (i.e., number of points) and bounds (the default glyph size).
-        # The scene has accesss to this theoretically. Perhaps the scene class can be used
-        # as a factory.
         self._sampling_rate: int = 500
-        self.field: Field = Field()
-        # TODO(matt): we should only allow vectors somehow
-        self.field.quantity = VisQuantity.VELOCITY
+        self.quantity: VisQuantity = VisQuantity.VELOCITY
 
     @property
     def sampling_rate(self) -> int:
@@ -403,11 +396,11 @@ class FixedSizeVectorGlyphs(VectorGlyphs):
         The size in world units (meters) of the glyphs.
     display_attrs (DisplayAttributes)
         Specifies this filters appearance.
-    field: Field
+    quantity: VisQuantity
         The vector field to use for glyph generation. Default: Velocity
     """
 
-    def __init__(self, name: str) -> None:
+    def __init__(self, name: str = "") -> None:
         super().__init__(name)
         self.size: float = 1.0
 
@@ -418,10 +411,10 @@ class FixedSizeVectorGlyphs(VectorGlyphs):
         vis_filter.glyph.fixed_size_glyphs = self.size
         vis_filter.glyph.n_glyphs = self.sampling_rate
         vis_filter.glyph.sampling_mode = vis_pb2.GLYPH_SAMPLING_MODE_EVERY_NTH
-        if not quantity_type._is_vector(self.field.quantity):
+        if not quantity_type._is_vector(self.quantity):
             raise ValueError("FixedSizeVectorGlyphs: field must be a vector type")
-        vis_filter.glyph.field.quantity_typ = self.field.quantity.value
-        vis_filter.glyph.field.component = self.field.component.value
+        vis_filter.glyph.field.quantity_typ = self.quantity.value
+        vis_filter.glyph.field.component = vis_pb2.Field.COMPONENT_UNSPECIFIED
         return vis_filter
 
     def _from_proto(self, filter: vis_pb2.Filter) -> None:
@@ -436,8 +429,7 @@ class FixedSizeVectorGlyphs(VectorGlyphs):
         self.n_glyphs = filter.glyph.n_glyphs
         self.size = filter.glyph.fixed_size_glyphs
         self.sampling_rate = filter.glyph.n_glyphs
-        self.field.quantity = VisQuantity(filter.glyph.field.quantity_typ)
-        self.field.component = FieldComponent(filter.glyph.field.component)
+        self.quantity = VisQuantity(filter.glyph.field.quantity_typ)
 
 
 class ScaledVectorGlyphs(VectorGlyphs):
@@ -464,11 +456,11 @@ class ScaledVectorGlyphs(VectorGlyphs):
         0.5 and the scale is 2 then the resulting world space size is 1 meter. Default: 1.
     display_attrs (DisplayAttributes)
         Specifies this filters appearance.
-    field: Field
+    quantity: VisQuantity
         The vector field to use for glyph generation. Default: Velocity
     """
 
-    def __init__(self, name: str) -> None:
+    def __init__(self, name: str = "") -> None:
         super().__init__(name)
         self.scale: float = 1.0
 
@@ -479,10 +471,10 @@ class ScaledVectorGlyphs(VectorGlyphs):
         vis_filter.glyph.glyph_scale_size = self.scale
         vis_filter.glyph.n_glyphs = self.sampling_rate
         vis_filter.glyph.sampling_mode = vis_pb2.GLYPH_SAMPLING_MODE_EVERY_NTH
-        if not quantity_type._is_vector(self.field.quantity):
+        if not quantity_type._is_vector(self.quantity):
             raise ValueError("ScaledVectorGyph: field must be a vector type")
-        vis_filter.glyph.field.quantity_typ = self.field.quantity.value
-        vis_filter.glyph.field.component = self.field.component.value
+        vis_filter.glyph.field.quantity_typ = self.quantity.value
+        vis_filter.glyph.field.component = vis_pb2.Field.COMPONENT_UNSPECIFIED
         return vis_filter
 
     def _from_proto(self, filter: vis_pb2.Filter) -> None:
@@ -497,8 +489,7 @@ class ScaledVectorGlyphs(VectorGlyphs):
         self.n_glyphs = filter.glyph.n_glyphs
         self.scale = filter.glyph.glyph_scale_size
         self.sampling_rate = filter.glyph.n_glyphs
-        self.field.quantity = VisQuantity(filter.glyph.field.quantity_typ)
-        self.field.component = FieldComponent(filter.glyph.field.component)
+        self.quantity = VisQuantity(filter.glyph.field.quantity_typ)
 
 
 class Threshold(Filter):
@@ -533,7 +524,7 @@ class Threshold(Filter):
         Specifies this filter's appearance.
     """
 
-    def __init__(self, name: str) -> None:
+    def __init__(self, name: str = "") -> None:
         super().__init__(generate_id("threshold-"))
         self.field: Field = Field()
         self.min_value: float = 0.0
@@ -610,14 +601,13 @@ class Streamlines(Filter):
         Specifies this filter's appearance.
     """
 
-    def __init__(self, name: str) -> None:
+    def __init__(self, name: str = "") -> None:
         super().__init__(generate_id("streamlines-"))
         self.name: str = name
         self.n_streamlines: int = 100
         self.max_length: float = 10
         self.direction: StreamlineDirection = StreamlineDirection.FORWARD
-        self.field: Field = Field()
-        self.field.quantity = VisQuantity.VELOCITY
+        self.quantity: VisQuantity = VisQuantity.VELOCITY
 
 
 class RakeStreamlines(Streamlines):
@@ -640,8 +630,8 @@ class RakeStreamlines(Streamlines):
         The number of seed particles to place on the rake. Default: 100
     max_length: float
         The maximum path length of the particle in meters. Default: 10
-    field: Field
-        The vector field to used for the particle advection. Default: Velocity
+    quantity: VisQuantity
+        The vector field to use for the particle advection. Default: Velocity
     start: Vector3Like
         The start point of the rake. Default: [0,0,0].
     end: Vector3Like
@@ -652,10 +642,10 @@ class RakeStreamlines(Streamlines):
         Specifies this filter's appearance.
     """
 
-    def __init__(self, name: str) -> None:
+    def __init__(self, name: str = "") -> None:
         super().__init__(name)
-        self.start: Vector3Like = dc.field(default_factory=lambda: Vector3(x=0, y=0, z=0))
-        self.end: Vector3Like = dc.field(default_factory=lambda: Vector3(x=1, y=0, z=0))
+        self.start: Vector3Like = Vector3(x=0, y=0, z=0)
+        self.end: Vector3Like = Vector3(x=1, y=0, z=0)
 
     def _to_proto(self) -> vis_pb2.Filter:
         # Type checking
@@ -663,8 +653,8 @@ class RakeStreamlines(Streamlines):
             raise TypeError(f"Expected 'int', got {type(self.n_streamlines).__name__}")
         if not isinstance(self.max_length, (float, int)):
             raise TypeError(f"Expected 'float or int', got {type(self.max_length).__name__}")
-        if not isinstance(self.field, Field):
-            raise TypeError(f"Expected 'Field', got {type(self.field).__name__}")
+        if not isinstance(self.quantity, VisQuantity):
+            raise TypeError(f"Expected 'VisQuantity', got {type(self.quantity).__name__}")
 
         vis_filter = vis_pb2.Filter()
         vis_filter.id = self.id
@@ -673,9 +663,9 @@ class RakeStreamlines(Streamlines):
         vis_filter.streamlines.max_length = self.max_length
         vis_filter.streamlines.rake.start.CopyFrom(_to_vector3(self.start)._to_proto())
         vis_filter.streamlines.rake.end.CopyFrom(_to_vector3(self.end)._to_proto())
-        if not quantity_type._is_vector(self.field.quantity):
+        if not quantity_type._is_vector(self.quantity):
             raise ValueError("RakeStreamlines: field must be a vector type")
-        vis_filter.streamlines.field.quantity_typ = self.field.quantity.value
+        vis_filter.streamlines.field.quantity_typ = self.quantity.value
         return vis_filter
 
     def _from_proto(self, filter: vis_pb2.Filter) -> None:
@@ -694,7 +684,131 @@ class RakeStreamlines(Streamlines):
         self.start._from_proto(filter.streamlines.rake.start)
         self.end = Vector3()
         self.end._from_proto(filter.streamlines.rake.end)
-        self.field.quantity = VisQuantity(filter.streamlines.field.quantity_typ)
+        self.quantity = VisQuantity(filter.streamlines.field.quantity_typ)
+
+
+class GridStreamlines(Streamlines):
+    """
+    Streamlines is a vector field visualization technique that integrates
+    massless particles through a vector field forming curves. Streamlines are
+    used to visualize and analyze fluid flow patterns (e.g., the velocity
+    field), helping to understand how the fluid moves. Streamlines
+    can be use used to visualize any vector field contained in the solution.
+
+    GridStreamlines generates seed particles arranged in a 2D grid pattern
+    inside the volume. GridStreamlines only work with volume data.
+
+    The grid is defined by a center point and two vectors that define the u
+    (rake_direction) and v (seed_direction) directions of the grid. It's
+    recommended that the rake_direction and seed_direction vectors are
+    orthogonal to each other, but it's not required. Rakes (sets of seed
+    particles) are generated in the rake_direction. Seed particles are
+    distributed along the seed_direction. The rake spacing controls the distance
+    between the rakes, and the seed spacing controls the distance between the
+    seed particles along the rake.
+
+    For example, if the rake vector is [1,0,0] and the seed vector is [0,1,0],
+    then the rakes will be generated in the x direction and the seed particles
+    will be generated in the y direction. Lets say we want to create a grid of
+    of 4x4 particles that is 8 meters wide and 2 meters tall. The rake spacing
+    would be 2 meters / 4 = 0.5 meters, and the seed spacing would be 8 meters /
+    4 = 2 meters.
+
+    .. warning:: This feature is experimental and may change or be removed in the future.
+
+    Attributes:
+    -----------
+    max_length: float
+        The maximum path length of the particle in meters. Default: 10
+    quantity: VisQuantity
+        The vector field to use for the particle advection. Default: Velocity
+    rake_direction: Vector3Like
+        The vector defining the u direction of the grid along which the rakes are placed.
+        Default: [1,0,0].
+    seed_direction: Vector3Like
+        The vector defining the v direction of the grid along which the seed particles are placed.
+        Default: [0,1,0].
+    center: Vector3Like
+        The center point of the grid. Default: [0,0,0].
+    rake_res: int
+        The number of rake lines to generate in the u direction. Default: 2.
+    seed_res: int
+        The number of seed particles to generate in the v direction. Default: 10.
+    rake_spacing: float
+        The spacing between the rake lines in meters. Default: 0.5.
+    seed_spacing: float
+        The spacing between the seed particles in meters. Default: 0.1.
+    name : str
+        A user provided name for the filter.
+    display_attrs : DisplayAttributes
+        Specifies this filter's appearance.
+    """
+
+    def __init__(self, name: str = "") -> None:
+        super().__init__(name)
+        self.rake_direction: Vector3Like = Vector3(x=1, y=0, z=0)
+        self.seed_direction: Vector3Like = Vector3(x=0, y=1, z=0)
+        self.center: Vector3Like = Vector3(x=0, y=0, z=0)
+        self.rake_res: int = 2
+        self.seed_res: int = 10
+        self.rake_spacing: float = 0.5
+        self.seed_spacing: float = 0.1
+
+    def _to_proto(self) -> vis_pb2.Filter:
+        # Type checking
+        if not isinstance(self.max_length, (float, int)):
+            raise TypeError(f"Expected 'float or int', got {type(self.max_length).__name__}")
+        if not isinstance(self.quantity, VisQuantity):
+            raise TypeError(f"Expected 'VisQuantity', got {type(self.quantity).__name__}")
+        if not isinstance(self.rake_res, int):
+            raise TypeError(f"Expected 'int', got {type(self.rake_res).__name__}")
+        if not isinstance(self.seed_res, int):
+            raise TypeError(f"Expected 'int', got {type(self.seed_res).__name__}")
+        if not isinstance(self.rake_spacing, (float, int)):
+            raise TypeError(f"Expected 'float or int', got {type(self.rake_spacing).__name__}")
+        if not isinstance(self.seed_spacing, (float, int)):
+            raise TypeError(f"Expected 'float or int', got {type(self.seed_spacing).__name__}")
+
+        vis_filter = vis_pb2.Filter()
+        vis_filter.id = self.id
+        vis_filter.name = self.name
+        vis_filter.streamlines.max_length = self.max_length
+        vis_filter.streamlines.grid.center.CopyFrom(_to_vector3(self.center)._to_proto())
+        vis_filter.streamlines.grid.u_vec.CopyFrom(_to_vector3(self.rake_direction)._to_proto())
+        vis_filter.streamlines.grid.v_vec.CopyFrom(_to_vector3(self.seed_direction)._to_proto())
+        vis_filter.streamlines.grid.rake_res = self.rake_res
+        vis_filter.streamlines.grid.seed_res = self.seed_res
+        vis_filter.streamlines.grid.rake_spacing = self.rake_spacing
+        vis_filter.streamlines.grid.seed_spacing = self.seed_spacing
+
+        if not quantity_type._is_vector(self.quantity):
+            raise ValueError("GridStreamlines: field must be a vector type")
+        vis_filter.streamlines.field.quantity_typ = self.quantity.value
+        return vis_filter
+
+    def _from_proto(self, filter: vis_pb2.Filter) -> None:
+        typ = filter.WhichOneof("value")
+        if typ != "streamlines":
+            raise TypeError(f"Expected 'streamlines', got {typ}")
+        s_typ = filter.streamlines.WhichOneof("seed_type")
+        if s_typ != "grid":
+            raise TypeError(f"Expected 'grid streamlines', got {s_typ}")
+        self.id = filter.id
+        self.name = filter.name
+        self.n_streamlines = filter.streamlines.n_streamlines
+        self.max_length = filter.streamlines.max_length
+
+        self.center = Vector3()
+        self.center._from_proto(filter.streamlines.grid.center)
+        self.rake_direction = Vector3()
+        self.rake_direction._from_proto(filter.streamlines.grid.u_vec)
+        self.seed_direction = Vector3()
+        self.seed_direction._from_proto(filter.streamlines.grid.v_vec)
+        self.rake_res = filter.streamlines.grid.rake_res
+        self.seed_res = filter.streamlines.grid.seed_res
+        self.rake_spacing = filter.streamlines.grid.rake_spacing
+        self.seed_spacing = filter.streamlines.grid.seed_spacing
+        self.quantity = VisQuantity(filter.streamlines.field.quantity_typ)
 
 
 class SurfaceStreamlines(Streamlines):
@@ -741,15 +855,15 @@ class SurfaceStreamlines(Streamlines):
         particles further into the volume based on the surface normal.  Default: 0.0
     max_length: float
         The maximum path length of the particle in meters. Default: 10
-    field: Field
-        The vector field to used for the particle advection. Default: Velocity
+    quantity: VisQuantity
+        The vector field to use for the particle advection. Default: Velocity
     name : str
         A user provided name for the filter.
     display_attrs : DisplayAttributes
         Specifies this filter's appearance.
     """
 
-    def __init__(self, name: str) -> None:
+    def __init__(self, name: str = "") -> None:
         super().__init__(name)
         self.offset: float = 0.0
         self._surface_names: List[str] = []
@@ -783,8 +897,8 @@ class SurfaceStreamlines(Streamlines):
             raise TypeError(f"Expected 'float or int', got {type(self.max_length).__name__}")
         if not isinstance(self.offset, (float, int)):
             raise TypeError(f"Expected 'float or int', got {type(self.offset).__name__}")
-        if not isinstance(self.field, Field):
-            raise TypeError(f"Expected 'Field', got {type(self.field).__name__}")
+        if not isinstance(self.quantity, VisQuantity):
+            raise TypeError(f"Expected 'VisQuantity', got {type(self.quantity).__name__}")
         if not isinstance(self.mode, SurfaceStreamlineMode):
             raise TypeError(f"Expected 'SurfaceStreamlinesMode', got {type(self.mode).__name__}")
 
@@ -796,12 +910,12 @@ class SurfaceStreamlines(Streamlines):
         project = False
         # Prevent common mistakes that cause confusion.
         if self.mode == SurfaceStreamlineMode.ADVECT_ON_SURFACE:
-            if self.field.quantity == VisQuantity.VELOCITY:
+            if self.quantity == VisQuantity.VELOCITY:
                 raise ValueError(
                     "SurfacesStreamines: velocity is 0 on surfaces and will produce no data"
                 )
             project = True
-        elif self.field.quantity == VisQuantity.WALL_SHEAR_STRESS:
+        elif self.quantity == VisQuantity.WALL_SHEAR_STRESS:
             raise ValueError(
                 "SurfacesStreamines: wall shear stress is 0 in the volume and will produce no data "
             )
@@ -811,10 +925,9 @@ class SurfaceStreamlines(Streamlines):
             raise ValueError("SurfaceStreamlines: need at least one surfaces specified.")
         for id in self._surface_names:
             vis_filter.streamlines.surface.surface_names.append(id)
-        if not quantity_type._is_vector(self.field.quantity):
-            raise ValueError("SurfaceStreamlines: field must be a vector type")
-        vis_filter.streamlines.field.component = self.field.component.value
-        vis_filter.streamlines.field.quantity_typ = self.field.quantity.value
+        if not quantity_type._is_vector(self.quantity):
+            raise ValueError("SurfaceStreamlines: quantity must be a vector type")
+        vis_filter.streamlines.field.quantity_typ = self.quantity.value
         return vis_filter
 
     def _from_proto(self, filter: vis_pb2.Filter) -> None:
@@ -831,7 +944,15 @@ class SurfaceStreamlines(Streamlines):
         self._surface_names.clear()
         for s in filter.streamlines.surface.surface_names:
             self._surface_names.append(s)
-        self.field.quantity = VisQuantity(filter.streamlines.field.quantity_typ)
+        self.quantity = VisQuantity(filter.streamlines.field.quantity_typ)
+
+    def _to_code(self, hide_defaults: bool = True, use_tmp_objs: bool = True) -> str:
+        code = super()._to_code(hide_defaults=hide_defaults)
+        # We need to explicity write the code for the surfaces since its
+        # technically a private variable.
+        for s in self._surface_names:
+            code += f".add_surface('{s}')\n"
+        return code
 
 
 class SurfaceLIC(Filter):
@@ -855,7 +976,7 @@ class SurfaceLIC(Filter):
 
     Attributes:
     -----------
-    field: Field
+    quantity: VisQuantity
         Specifies the field used to advect particles for the surface LIC.
         Default: WALL_SHEER_STRESS
     contrast: float
@@ -864,13 +985,12 @@ class SurfaceLIC(Filter):
         higher values mean more contrast. Default: 1
     """
 
-    def __init__(self, name: str) -> None:
+    def __init__(self, name: str = "") -> None:
         super().__init__(generate_id("surface-lic-"))
         self.name = name
         self.contrast: float = 1.0
         self._surface_names: List[str] = []
-        self.field: Field = Field()
-        self.field.quantity = VisQuantity.WALL_SHEAR_STRESS
+        self.quantity: VisQuantity = VisQuantity.WALL_SHEAR_STRESS
 
     def add_surface(self, id: str) -> None:
         """
@@ -898,9 +1018,9 @@ class SurfaceLIC(Filter):
         vis_filter.name = self.name
         # Prevent common mistakes that cause confusion. The only current option
         # is to be on a surface, so no velocity.
-        if not isinstance(self.field, Field):
-            raise TypeError(f"Expected 'Field', got {type(self.field).__name__}")
-        if self.field.quantity == VisQuantity.VELOCITY:
+        if not isinstance(self.quantity, VisQuantity):
+            raise TypeError(f"Expected 'VisQuantity', got {type(self.quantity).__name__}")
+        if self.quantity == VisQuantity.VELOCITY:
             raise ValueError("SurfaceLIC: velocity is 0 on surfaces and will produce no data")
         if not isinstance(self.contrast, (int, float)):
             raise TypeError(f"Expected 'int or float', got {type(self.contrast).__name__}")
@@ -914,7 +1034,7 @@ class SurfaceLIC(Filter):
             geometry = vis_pb2.SurfaceLICGeomtery()
             vis_filter.surface_lic.geometry.CopyFrom(geometry)
 
-        vis_filter.surface_lic.field.quantity_typ = self.field.quantity.value
+        vis_filter.surface_lic.field.quantity_typ = self.quantity.value
         vis_filter.surface_lic.contrast = self.contrast
         return vis_filter
 
@@ -932,7 +1052,46 @@ class SurfaceLIC(Filter):
         self._surface_names = []
         for s in filter.surface_lic.geometry.surface_names:
             self._surface_names.append(s)
-        if not quantity_type._is_vector(self.field.quantity):
-            raise ValueError("SurfaceLIC: field must be a vector type")
-        self.field.quantity = VisQuantity(filter.surface_lic.field.quantity_typ)
-        self.field.component = FieldComponent(filter.surface_lic.field.component)
+        if not quantity_type._is_vector(self.quantity):
+            raise ValueError("SurfaceLIC: quantity must be a vector type")
+        self.quantity = VisQuantity(filter.surface_lic.field.quantity_typ)
+
+    def _to_code(self, hide_defaults: bool = True, use_tmp_objs: bool = True) -> str:
+        code = super()._to_code(hide_defaults=hide_defaults)
+        # We need to explicity write the code for the surfaces since its
+        # technically a private variable.
+        for s in self._surface_names:
+            code += f".add_surface('{s}')\n"
+        return code
+
+
+def _filter_to_obj_name(filter: Filter) -> str:
+    """
+    Helper function to convert a filter to a code object name used in code gen.
+    """
+    if not isinstance(filter, Filter):
+        raise TypeError(f"Expected 'Filter', got {type(filter).__name__}")
+    if isinstance(filter, Slice):
+        return "slice"
+    elif isinstance(filter, Isosurface):
+        return "isosurface"
+    elif isinstance(filter, PlaneClip):
+        return "plane_clip"
+    elif isinstance(filter, BoxClip):
+        return "box_clip"
+    elif isinstance(filter, FixedSizeVectorGlyphs):
+        return "fixed_size_vector_glyphs"
+    elif isinstance(filter, ScaledVectorGlyphs):
+        return "scaled_vector_glyphs"
+    elif isinstance(filter, Threshold):
+        return "threshold"
+    elif isinstance(filter, RakeStreamlines):
+        return "rake_streamlines"
+    elif isinstance(filter, GridStreamlines):
+        return "grid_streamlines"
+    elif isinstance(filter, SurfaceStreamlines):
+        return "surface_streamlines"
+    elif isinstance(filter, SurfaceLIC):
+        return "surface_lic"
+    else:
+        raise TypeError(f"Unknown filter type: {type(filter).__name__}")

luminarycloud/vis/primitives.py

@@ -1,10 +1,11 @@
 # Copyright 2023-2024 Luminary Cloud, Inc. All Rights Reserved.
 import dataclasses as dc
 from luminarycloud.types import Vector3, Vector3Like
+from .._helpers._code_representation import CodeRepr
 
 
 @dc.dataclass
-class Plane:
+class Plane(CodeRepr):
     """
     This class defines a plane.
 
@@ -19,7 +20,7 @@ class Plane:
 
 
 @dc.dataclass
-class Box:
+class Box(CodeRepr):
     """
     This class defines a box used for filter such as box clip.