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

luminarycloud/vis/data_extraction.py

@@ -4,7 +4,7 @@ import csv
 import json
 from .vis_util import _download_file, _InternalToken, generate_id, _get_status
 from ..enum import ExtractStatusType, EntityType
-from typing import List, Tuple, cast, Union
+from typing import Tuple, cast, Union
 from abc import ABC, abstractmethod
 from .._proto.api.v0.luminarycloud.vis import vis_pb2
 from .primitives import Plane
@@ -12,19 +12,22 @@ from ..types.vector3 import _to_vector3, Vector3Like, Vector3
 from .._client import get_default_client
 import logging
 from ..solution import Solution
-from ..geometry import Geometry, get_geometry
+from ..geometry import Geometry
 from ..mesh import Mesh, get_mesh, get_mesh_metadata
 from ..simulation import get_simulation
 from .._helpers._get_project_id import _get_project_id
 from .display import DisplayAttributes
 from time import sleep, time
 from luminarycloud.params.simulation.physics.fluid.boundary_conditions import Farfield
-from ..exceptions import NotFoundError
+from .._helpers._code_representation import CodeRepr
+from ..types import SimulationID
+from collections import defaultdict
+
 
 logger = logging.getLogger(__name__)
 
 
-class DataExtract(ABC):
+class DataExtract(ABC, CodeRepr):
     """
     This is the base class for all data extracts. Each derived extract class
     is responsible for providing a _to_proto method to convert to a filter
@@ -65,10 +68,10 @@ class IntersectionCurve(DataExtract):
         A user provided name for the filter.
     """
 
-    def __init__(self, name: str) -> None:
+    def __init__(self, name: str = "") -> None:
         super().__init__(generate_id("intersection-curve"))
         self.name = name
-        self._surface_names: List[str] = []
+        self._surface_names: list[str] = []
         self._plane = Plane()
         self.label: str = ""
 
@@ -98,7 +101,7 @@ class IntersectionCurve(DataExtract):
             raise TypeError(f"Expected 'str', got {type(id).__name__}")
         self._surface_names.append(id)
 
-    def _surfaces(self) -> List[str]:
+    def _surfaces(self) -> list[str]:
         """
         Returns the current list of surfaces.
         """
@@ -113,14 +116,25 @@ class IntersectionCurve(DataExtract):
         for id in self._surface_names:
             vis_filter.intersection_curve.surfaces.append(id)
 
-        vis_filter.intersection_curve.plane.origin.CopyFrom(
-            _to_vector3(self.plane.origin)._to_proto()
-        )
-        vis_filter.intersection_curve.plane.normal.CopyFrom(
-            _to_vector3(self.plane.normal)._to_proto()
-        )
+        vis_filter.intersection_curve.plane.CopyFrom(self._plane._to_proto())
         return vis_filter
 
+    def _from_proto(self, vis_filter: vis_pb2.Filter) -> None:
+        self.id = vis_filter.id
+        self.name = vis_filter.name
+        self.label = vis_filter.intersection_curve.label
+        self._surface_names = list(vis_filter.intersection_curve.surfaces)
+        self._plane = Plane()
+        self._plane._from_proto(vis_filter.intersection_curve.plane)
+
+    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 LineSample(DataExtract):
     """
@@ -144,7 +158,7 @@ class LineSample(DataExtract):
         A user provided name for the filter.
     """
 
-    def __init__(self, name: str) -> None:
+    def __init__(self, name: str = "") -> None:
         super().__init__(generate_id("line-sample"))
         self.name = name
         self.start: Vector3Like = Vector3(x=0, y=0, z=0)
@@ -160,6 +174,15 @@ class LineSample(DataExtract):
         vis_filter.line_sample.end.CopyFrom(_to_vector3(self.end)._to_proto())
         return vis_filter
 
+    def _from_proto(self, vis_filter: vis_pb2.Filter) -> None:
+        self.id = vis_filter.id
+        self.name = vis_filter.name
+        self.label = vis_filter.line_sample.label
+        self.start = Vector3()
+        self.start._from_proto(vis_filter.line_sample.start)
+        self.end = Vector3()
+        self.end._from_proto(vis_filter.line_sample.end)
+
 
 class ExtractOutput:
     """
@@ -261,7 +284,7 @@ class ExtractOutput:
                 raise TimeoutError
             sleep(max(-1, min(interval_seconds, deadline - time())))
 
-    def download_data(self) -> List[Tuple[List[List[Union[str, int, float]]], str]]:
+    def download_data(self) -> list[Tuple[list[list[Union[str, int, float]]], str]]:
         """
         Downloads the resulting data into memory. This is useful
         for plotting data in notebooks.  If that status is not complete, an
@@ -285,7 +308,7 @@ class ExtractOutput:
         req.project_id = self._project_id
         res: vis_pb2.DownloadExtractResponse = get_default_client().DownloadExtract(req)
 
-        csv_files: List[Tuple[List[List[Union[str, int, float]]], str]] = []
+        csv_files: list[Tuple[list[list[Union[str, int, float]]], str]] = []
         if res.HasField("line_data"):
             compressed_buffer = _download_file(res.line_data)
             dctx = zstd.ZstdDecompressor()
@@ -300,7 +323,7 @@ class ExtractOutput:
             ids = line_data.lines.keys()
             # Each filter(id) produces a set of tables, one per line segment.
             for id in ids:
-                header: List[Union[str, float, int]] = []
+                header: list[Union[str, float, int]] = []
                 tables = line_data.lines[id]
                 # One table per line segment. First, figure out the
                 # shape of the data and validate what we expect.
@@ -321,15 +344,15 @@ class ExtractOutput:
                     assert n_rows * n_cols == len(table.record[0].entry)
                 assert len(header) != 0
                 assert n_cols != 0
-                rows: List[List[Union[str, float, int]]] = []
+                rows: list[list[Union[str, float, int]]] = []
                 rows.append(header)
                 for curve_id, table in enumerate(tables.lines_table):
                     n_rows = len(table.axis[0].coordinate)
-                    new_rows: List[List[Union[str, float, int]]] = []
+                    new_rows: list[list[Union[str, float, int]]] = []
                     idx = 0
                     # The the shape of the values are in row-major ordering.
                     for r in range(n_rows):
-                        row: List[Union[str, float, int]] = []
+                        row: list[Union[str, float, int]] = []
                         for c in range(n_cols):
                             row.append(table.record[0].entry[idx].adfloat.value)
                             idx += 1
@@ -363,7 +386,7 @@ class ExtractOutput:
             raise ValueError("file_prefix must be non-empty")
 
         csv_files = self.download_data()
-        names_labels: List[Tuple[str, str]] = []
+        names_labels: list[Tuple[str, str]] = []
         counter = 0
         for csv_file in csv_files:
             output_file = f"{file_prefix}_{counter}.csv"
@@ -390,6 +413,20 @@ class ExtractOutput:
         self._deleted = True
 
 
+def _data_extract_to_obj_name(extract: DataExtract) -> str:
+    """
+    Helper function to convert a filter to a code object name used in code gen.
+    """
+    if not isinstance(extract, DataExtract):
+        raise TypeError(f"Expected 'DataExtract', got {type(extract).__name__}")
+    if isinstance(extract, LineSample):
+        return "line_sample"
+    elif isinstance(extract, IntersectionCurve):
+        return "intersection_curve"
+    else:
+        raise TypeError(f"Unknown data extract type: {type(extract).__name__}")
+
+
 class DataExtractor:
     """
     I extract data from solutions.
@@ -403,7 +440,7 @@ class DataExtractor:
             raise TypeError(f"Expected Solution got {type(solution).__name__}")
         self._solution: Solution = solution
         self._entity_type: EntityType = EntityType.SIMULATION
-        self._extracts: List[DataExtract] = []
+        self._extracts: list[DataExtract] = []
 
         # Meshes that are directly uploaded will not have tags.
         self._has_tags: bool = True
@@ -426,18 +463,18 @@ class DataExtractor:
         else:
             geom = geo_ver.geometry()
 
-        self._surface_ids: List[str] = []
+        self._surface_ids: list[str] = []
         for zone in mesh_meta.zones:
             for bound in zone.boundaries:
                 self._surface_ids.append(bound.name)
 
-        self._tag_ids: List[str] = []
+        self._tag_ids: list[str] = []
         if geom and self._has_tags:
             tags = geom.list_tags()
             for tag in tags:
                 self._tag_ids.append(tag.id)
 
-        self.far_field_boundary_ids: List[str] = []
+        self.far_field_boundary_ids: list[str] = []
 
         # Find all the far field surfaces if we can get the params.
         params = simulation.get_parameters()
@@ -448,12 +485,12 @@ class DataExtractor:
                         for bc_surface in bc.surfaces:
                             self.far_field_boundary_ids.append(bc_surface)
 
-    def _validate_surfaces_and_tags(self, ids: List[str]) -> List[str]:
+    def _validate_surfaces_and_tags(self, ids: list[str]) -> list[str]:
         """
         Validate a list of ids as either tags or ids. Returns a list of invalid ids. If the
         length of the list is zero, the input list is valid.
         """
-        bad_ids: List[str] = []
+        bad_ids: list[str] = []
         for id in ids:
             if id in self._tag_ids:
                 continue
@@ -461,11 +498,11 @@ class DataExtractor:
                 bad_ids.append(id)
         return bad_ids
 
-    def surface_ids(self) -> List[str]:
+    def surface_ids(self) -> list[str]:
         """Get a list of all the surface ids associated with the solution."""
         return self._surface_ids
 
-    def tag_ids(self) -> List[str]:
+    def tag_ids(self) -> list[str]:
         """Get a list of all the tag ids associated with the solution."""
         return self._tag_ids
 
@@ -531,8 +568,97 @@ class DataExtractor:
         )
         return extract_output
 
+    def to_code(self, obj_name: str, include_imports: bool, hide_defaults: bool = True) -> str:
+        """
+        This function will produce a code string that reproduces the data extractor
+        in its current state.
 
-def list_data_extracts(solution: Solution) -> List[ExtractOutput]:
+        Parameters
+        ----------
+        obj_name: str
+            the object name of the scene.
+        include_imports: bool
+            If True, the code will include the necessary imports to run the code. This will be
+            set to false if generating scene code as well, since the imports overlap.
+        hide_defaults: bool, optional
+            If True, the code will make a best effort not include default values for attributes.
+        """
+        if len(self._extracts) == 0:
+            # If we don't have any extracts, we don't need to generate any code.
+            return ""
+
+        imports: str = ""
+        if include_imports:
+            imports += "import luminarycloud as lc\n"
+            imports += "import luminarycloud.vis as vis\n"
+            imports += "from luminarycloud.types import Vector3\n"
+            imports += "from luminarycloud.enum import ExtractStatusType\n"
+
+        # This isn't technically needed, but I think its useful.
+        code = "\n# Find the entity to build the scene from\n"
+        code += f"simulation = lc.get_simulation('{self._solution.simulation_id}')\n"
+        code += "for sol in simulation.list_solutions():\n"
+        code += f"    if sol.id == '{self._solution.id}':\n"
+        code += f"        solution = sol\n"
+        code += f"        break\n"
+        code += "data_extractor = vis.DataExtractor(solution)\n"
+        code += "\n"
+
+        code += "\n"
+        # We can have many of the same type of filter so we need to track how
+        # many times we have seen a filter type to create the object name.
+        name_map: defaultdict[str, int] = defaultdict(int)
+        # Filters can be connected so we need to track what the ids are so we
+        # can connected them.
+        ids_to_obj_name: dict[str, str] = {}
+        for extract in self._extracts:
+            # Name objects numerically: slice0, slice1, etc.
+            name = _data_extract_to_obj_name(extract)
+            obj_name = f"{name}{name_map[obj_name]}"
+            name_map[obj_name] += 1
+            ids_to_obj_name[extract.id] = obj_name
+            code += extract._to_code_helper(obj_name, hide_defaults=hide_defaults)
+            code += f"data_extractor.add_data_extract({obj_name})\n"
+            code += "\n"
+
+        if include_imports:
+            imports += "\n"
+        # The code gen is very verbose, so we can do some string replacements
+        # since we are importing the luminarycloud.vis package.
+        cleanup_list: list[str] = [
+            "luminarycloud.vis.data_extraction",
+        ]
+        for cleanup in cleanup_list:
+            code = code.replace(cleanup, "vis")
+        # Many classes initialize the attributes, so we don't need to explicitly
+        # creat new objects for them. Additionally, its easier to do this here than
+        # in the individual classes.
+        remove_list: list[str] = [
+            "vis.DataRange()",
+            "luminarycloud.vis.primitives.Plane()",
+            "luminarycloud.vis.primitives.Box()",
+        ]
+        # Remove entire lines containing any remove_list item
+        code_lines = code.splitlines()
+        filtered_lines = [
+            line
+            for line in code_lines
+            if not any(remove_item in line for remove_item in remove_list)
+        ]
+        code = "\n".join(filtered_lines)
+
+        code += "\n"
+        code += "extract_output = extractor.create_extracts(name='extract data', description='lonerg description')\n"
+        code += "status = extract_output.wait()\n"
+        code += "if status == ExtractStatusType.COMPLETED:\n"
+        code += "    extract_output.save_files('data_extracts_prefix', True)\n"
+        code += "else:\n"
+        code += "    print('Data extraction failed ', status)\n"
+
+        return imports + code
+
+
+def list_data_extracts(solution: Solution) -> list[ExtractOutput]:
     """
     Lists all previously created data extract associated with a project and a solution.
 
@@ -567,7 +693,7 @@ def list_data_extracts(solution: Solution) -> List[ExtractOutput]:
     req.data_only = True
     res: vis_pb2.ListExtractsResponse = get_default_client().ListExtracts(req)
 
-    results: List[ExtractOutput] = []
+    results: list[ExtractOutput] = []
     for extract in res.extracts:
         result = ExtractOutput(_InternalToken())
         result._set_data(
@@ -582,3 +708,47 @@ def list_data_extracts(solution: Solution) -> List[ExtractOutput]:
         results.append(result)
 
     return results
+
+
+def _spec_to_data_extractor(spec: vis_pb2.ExtractSpec) -> DataExtractor:
+    entity = spec.entity_type.WhichOneof("entity")
+    if entity == "simulation":
+        sim_id = SimulationID(spec.entity_type.simulation.id)
+        sim = get_simulation(sim_id)
+        sols = sim.list_solutions()
+        found = False
+        for sol in sols:
+            if sol.id == spec.entity_type.simulation.solution_id:
+                extractor = DataExtractor(sol)
+                found = True
+                break
+        if not found:
+            raise ValueError("Error: could not find the solution")
+    else:
+        raise ValueError("Error: only solutions are supported for data extraction")
+
+    try:
+        _ = extractor  # check to see if this is bound
+    except NameError:
+        raise ValueError(f"Error: could not create scene from entity")
+
+    filter_ids: list[str] = []
+    for filter in spec.filters:
+        filter_ids.append(filter.id)
+        typ = filter.WhichOneof("value")
+        pfilter: DataExtract | None = None
+        if typ == "line_sample":
+            pfilter = LineSample("")
+        elif typ == "intersection_curve":
+            pfilter = IntersectionCurve("")
+        else:
+            # Don't complain about vis filters that are not data extracts.
+            # If the extractor has no filters, it will return an empty string
+            # from the to_code path.
+            continue
+
+        assert pfilter is not None, "Internal error: filter type not set"
+        pfilter._from_proto(filter)
+        extractor.add_data_extract(pfilter)
+
+    return extractor

luminarycloud/vis/filters.py

@@ -9,11 +9,9 @@ from luminarycloud.enum import (
 import luminarycloud.enum.quantity_type as quantity_type
 from .._proto.api.v0.luminarycloud.vis import vis_pb2
 from abc import ABC, abstractmethod
-import math
-import dataclasses as dc
 from .display import Field, DisplayAttributes
 from typing import List, Any, cast
-from .primitives import Box, Plane
+from .primitives import Box, Plane, AABB
 from .vis_util import generate_id
 from .._helpers._code_representation import CodeRepr
 
@@ -126,8 +124,7 @@ class Slice(Filter):
         vis_filter = vis_pb2.Filter()
         vis_filter.id = self.id
         vis_filter.name = self.name
-        vis_filter.slice.plane.origin.CopyFrom(_to_vector3(self.plane.origin)._to_proto())
-        vis_filter.slice.plane.normal.CopyFrom(_to_vector3(self.plane.normal)._to_proto())
+        vis_filter.slice.plane.CopyFrom(self.plane._to_proto())
         vis_filter.slice.project_vectors = self.project_vectors
         return vis_filter
 
@@ -138,12 +135,8 @@ class Slice(Filter):
         self.id = filter.id
         self.name = filter.name
         self.project_vectors = filter.slice.project_vectors
-        origin = Vector3()
-        origin._from_proto(filter.slice.plane.origin)
-        self.plane.origin = origin
-        normal = Vector3()
-        normal._from_proto(filter.slice.plane.normal)
-        self.plane.normal = normal
+        self.plane = Plane()
+        self.plane._from_proto(filter.slice.plane)
 
 
 class Isosurface(Filter):
@@ -254,8 +247,7 @@ class PlaneClip(Filter):
         vis_filter = vis_pb2.Filter()
         vis_filter.id = self.id
         vis_filter.name = self.name
-        vis_filter.clip.plane.origin.CopyFrom(_to_vector3(self.plane.origin)._to_proto())
-        vis_filter.clip.plane.normal.CopyFrom(_to_vector3(self.plane.normal)._to_proto())
+        vis_filter.clip.plane.CopyFrom(self.plane._to_proto())
         vis_filter.clip.inverted = self.inverted
         return vis_filter
 
@@ -268,10 +260,8 @@ class PlaneClip(Filter):
             raise TypeError(f"Expected 'plane clip', got {clip_typ}")
         self.id = filter.id
         self.name = filter.name
-        self.plane.normal = Vector3()
-        self.plane.normal._from_proto(filter.clip.plane.normal)
-        self.plane.origin = Vector3()
-        self.plane.origin._from_proto(filter.clip.plane.origin)
+        self.plane = Plane()
+        self.plane._from_proto(filter.clip.plane)
         self.inverted = filter.clip.inverted
 
 
@@ -315,14 +305,7 @@ class BoxClip(Filter):
         vis_filter = vis_pb2.Filter()
         vis_filter.id = self.id
         vis_filter.name = self.name
-        vis_filter.clip.box.center.CopyFrom(_to_vector3(self.box.center)._to_proto())
-        vis_filter.clip.box.lengths.CopyFrom(_to_vector3(self.box.lengths)._to_proto())
-        # The api interface is in degrees but the backend needs radians
-        radians = _to_vector3(self.box.angles)
-        radians.x = radians.x * (math.pi / 180)
-        radians.y = radians.y * (math.pi / 180)
-        radians.z = radians.z * (math.pi / 180)
-        vis_filter.clip.box.angles.CopyFrom(radians._to_proto())
+        vis_filter.clip.box.CopyFrom(self.box._to_proto())
         vis_filter.clip.inverted = self.inverted
         return vis_filter
 
@@ -335,16 +318,8 @@ class BoxClip(Filter):
             raise TypeError(f"Expected 'box', got {clip_typ}")
         self.id = filter.id
         self.name = filter.name
-        self.box.center = Vector3()
-        self.box.center._from_proto(filter.clip.box.center)
-        self.box.lengths = Vector3()
-        self.box.lengths._from_proto(filter.clip.box.lengths)
-        self.box.angles = Vector3()
-        self.box.angles._from_proto(filter.clip.box.angles)
-        # Backend units are radians, convert back to degrees
-        self.box.angles.x = self.box.angles.x * (180 / math.pi)
-        self.box.angles.y = self.box.angles.y * (180 / math.pi)
-        self.box.angles.z = self.box.angles.z * (180 / math.pi)
+        self.box = Box()
+        self.box._from_proto(filter.clip.box)
         self.inverted = filter.clip.inverted
 
 
@@ -1065,6 +1040,88 @@ class SurfaceLIC(Filter):
         return code
 
 
+class SurfaceLICPlane(Filter):
+    """
+    A Surface Line Integral Convolution (LIC) filter is used to depict the flow
+    direction and structure of vector fields (such as velocity) on surfaces. It
+    enhances the perception of complex flow patterns by convolving noise
+    textures along streamlines, making it easier to visually interpret the
+    behavior of fluid flow on boundaries or surfaces in a simulation.
+
+    This filter extracts a plane clipped by an axis-aligned bounding box (AABB) from
+    the volume solution and computes the surface LIC on the plane.
+    The surface LIC outputs the values as grayscale colors on the specified
+    plane. When the display attributes quantity is not None, the field colors
+    are blended with the grayscale colors.
+
+    .. warning:: This feature is experimental and may change or be removed in the future.
+
+    Attributes:
+    -----------
+    quantity: VisQuantity
+        Specifies the field used to advect particles for the surface LIC.
+        Default: VELOCITY
+    contrast: float
+        Contrast controls the contrast of the resuting surface LIC. Valid values
+        are in the [0.2, 3.0] range. Lower values means less contrast and
+        higher values mean more contrast. Default: 1
+    plane: Plane
+        The plane to extract from the volume solution.
+    clip_box: AABB
+        The axis-aligned bounding box (AABB) to clip the plane with. This is
+        useful to limit the area of the plane to a specific region of interest.
+    """
+
+    def __init__(self, name: str = "") -> None:
+        super().__init__(generate_id("surface-lic-"))
+        self.name = name
+        self.contrast: float = 1.0
+        self.quantity: VisQuantity = VisQuantity.VELOCITY
+        self.plane: Plane = Plane()
+        self.clip_box: AABB = AABB()
+
+    def _to_proto(self) -> vis_pb2.Filter:
+        vis_filter = vis_pb2.Filter()
+        vis_filter.id = self.id
+        vis_filter.name = self.name
+        if not isinstance(self.quantity, VisQuantity):
+            raise TypeError(f"Expected 'VisQuantity', got {type(self.quantity).__name__}")
+        if self.quantity == VisQuantity.WALL_SHEAR_STRESS:
+            raise ValueError(
+                "SurfaceLICPlane: wall shear stress is 0 in the volume and will produce no data"
+            )
+        if not isinstance(self.contrast, (int, float)):
+            raise TypeError(f"Expected 'int or float', got {type(self.contrast).__name__}")
+        if self.contrast < 0.2 or self.contrast > 3.0:
+            raise ValueError("SurfaceLICPlane: contrast must be between 0.2 and 3.0")
+        if not isinstance(self.plane, Plane):
+            raise TypeError(f"Expected 'Plane', got {type(self.plane).__name__}")
+        if not isinstance(self.clip_box, AABB):
+            raise TypeError(f"Expected 'AABB', got {type(self.clip_box).__name__}")
+
+        vis_filter.surface_lic.plane.plane.CopyFrom(self.plane._to_proto())
+        vis_filter.surface_lic.plane.clip_box.CopyFrom(self.clip_box._to_proto())
+        vis_filter.surface_lic.field.quantity_typ = self.quantity.value
+        vis_filter.surface_lic.contrast = self.contrast
+        return vis_filter
+
+    def _from_proto(self, filter: vis_pb2.Filter) -> None:
+        typ = filter.WhichOneof("value")
+        if typ != "surface_lic":
+            raise TypeError(f"Expected 'surface lic', got {typ}")
+        l_typ = filter.surface_lic.WhichOneof("lic_type")
+        if l_typ != "plane":
+            raise TypeError(f"Expected 'plane', got {l_typ}")
+        self.id = filter.id
+        self.name = filter.name
+        self.contrast = filter.surface_lic.contrast
+        self.plane._from_proto(filter.surface_lic.plane.plane)
+        self.clip_box._from_proto(filter.surface_lic.plane.clip_box)
+        if not quantity_type._is_vector(self.quantity):
+            raise ValueError("SurfaceLICPlane: quantity must be a vector type")
+        self.quantity = VisQuantity(filter.surface_lic.field.quantity_typ)
+
+
 def _filter_to_obj_name(filter: Filter) -> str:
     """
     Helper function to convert a filter to a code object name used in code gen.
@@ -1093,5 +1150,7 @@ def _filter_to_obj_name(filter: Filter) -> str:
         return "surface_streamlines"
     elif isinstance(filter, SurfaceLIC):
         return "surface_lic"
+    elif isinstance(filter, SurfaceLICPlane):
+        return "surface_lic_plane"
     else:
         raise TypeError(f"Unknown filter type: {type(filter).__name__}")

luminarycloud/vis/primitives.py

@@ -2,6 +2,9 @@
 import dataclasses as dc
 from luminarycloud.types import Vector3, Vector3Like
 from .._helpers._code_representation import CodeRepr
+from .._proto.api.v0.luminarycloud.vis import vis_pb2
+from ..types.vector3 import _to_vector3
+import math
 
 
 @dc.dataclass
@@ -18,11 +21,23 @@ class Plane(CodeRepr):
     normal: Vector3Like = dc.field(default_factory=lambda: Vector3(x=1, y=0, z=0))
     """The vector orthogonal to the  plane. Default: [0,1,0]"""
 
+    def _to_proto(self) -> vis_pb2.Plane:
+        plane = vis_pb2.Plane()
+        plane.origin.CopyFrom(_to_vector3(self.origin)._to_proto())
+        plane.normal.CopyFrom(_to_vector3(self.normal)._to_proto())
+        return plane
+
+    def _from_proto(self, proto: vis_pb2.Plane) -> None:
+        self.origin = Vector3()
+        self.origin._from_proto(proto.origin)
+        self.normal = Vector3()
+        self.normal._from_proto(proto.normal)
+
 
 @dc.dataclass
 class Box(CodeRepr):
     """
-    This class defines a box used for filter such as box clip.
+    This class defines a box used for filters such as box clip.
 
     .. warning:: This feature is experimental and may change or be removed in the future.
 
@@ -37,3 +52,65 @@ class Box(CodeRepr):
     The rotation of the box specified in Euler angles (degrees) and applied
     in XYZ ordering. Default: [0,0,0]
     """
+
+    def _to_proto(self) -> vis_pb2.Box:
+        box = vis_pb2.Box()
+        box.center.CopyFrom(_to_vector3(self.center)._to_proto())
+        box.lengths.CopyFrom(_to_vector3(self.lengths)._to_proto())
+        # The api interface is in degrees but the backend needs radians
+        radians = _to_vector3(self.angles)
+        radians.x = radians.x * (math.pi / 180)
+        radians.y = radians.y * (math.pi / 180)
+        radians.z = radians.z * (math.pi / 180)
+        box.angles.CopyFrom(radians._to_proto())
+        return box
+
+    def _from_proto(self, proto: vis_pb2.Box) -> None:
+        center = Vector3()
+        center._from_proto(proto.center)
+        self.center = center
+        lengths = Vector3()
+        lengths._from_proto(proto.lengths)
+        self.lengths = lengths
+        self.angles = Vector3()
+        # Backend units are radians, convert back to degrees
+        self.angles.x = proto.angles.x * (180 / math.pi)
+        self.angles.y = proto.angles.y * (180 / math.pi)
+        self.angles.z = proto.angles.z * (180 / math.pi)
+
+
+@dc.dataclass
+class AABB(CodeRepr):
+    """
+    This class defines an axis-aligned bounding box used for filters such as SurfaceLICPlane.
+
+    .. warning:: This feature is experimental and may change or be removed in the future.
+
+    """
+
+    min: Vector3Like = dc.field(default_factory=lambda: Vector3(x=0, y=0, z=0))
+    """The min point of the axis-aligned box. Default: [0,0,0]."""
+    max: Vector3Like = dc.field(default_factory=lambda: Vector3(x=1, y=1, z=1))
+    """The max point of the axis-aligned box. Default: [1,1,1]."""
+
+    def is_valid(self) -> bool:
+        """
+        Check if the AABB is valid. An AABB is valid if min is less than max in all dimensions.
+        """
+        min = _to_vector3(self.min)
+        max = _to_vector3(self.max)
+        return min.x <= max.x and min.y <= max.y and min.z <= max.z
+
+    def _to_proto(self) -> vis_pb2.AABB:
+        aabb = vis_pb2.AABB()
+        aabb.min.CopyFrom(_to_vector3(self.min)._to_proto())
+        aabb.max.CopyFrom(_to_vector3(self.max)._to_proto())
+        return aabb
+
+    def _from_proto(self, proto: vis_pb2.AABB) -> None:
+        min_point = Vector3()
+        min_point._from_proto(proto.min)
+        self.min = min_point
+        max_point = Vector3()
+        max_point._from_proto(proto.max)
+        self.max = max_point