luminarycloud 0.16.2__py3-none-any.whl → 0.18.0__py3-none-any.whl

luminarycloud/vis/interactive_inference.py

@@ -0,0 +1,153 @@
+# Copyright 2025 Luminary Cloud, Inc. All Rights Reserved.
+import json
+from .._proto.api.v0.luminarycloud.vis import vis_pb2
+from .display import DisplayAttributes
+from luminarycloud.enum.vis_enums import SceneMode, VisQuantity, Representation, FieldComponent
+from luminarycloud.vis import Field
+from typing import TYPE_CHECKING
+import luminarycloud.enum.quantity_type as quantity_type
+from .interactive_scene import InteractiveScene
+
+from .._proto.api.v0.luminarycloud.vis import vis_pb2
+
+if TYPE_CHECKING:
+    from .visualization import Scene, LookAtCamera, DirectionalCamera, ColorMap
+    from ..geometry import Geometry
+    from ..mesh import Mesh
+    from ..solution import Solution
+
+try:
+    import luminarycloud_jupyter as lcj
+
+    if TYPE_CHECKING:
+        from luminarycloud_jupyter import InteractiveLCVisWidget, LCVisPlaneWidget
+except ImportError:
+    lcj = None
+
+
+_SOURCE_FILTER_ID = "___LC_SOURCE_FILTER___"
+
+# Global workspace state configuration
+# We use this to provide a constructed context to the LCVis widget so that we can visualize
+# the surface inference results.
+WORKSPACE_STATE_CONFIG = {
+    "connections": {_SOURCE_FILTER_ID: []},
+    "filters": [
+        {
+            "id": _SOURCE_FILTER_ID,
+            "name": "LcMeshSource",
+            "params": {
+                "fvm_params": "",
+                "url": "dummy",
+            },
+        }
+    ],
+    "workspace_params": {"edge_mode": "boundary"},
+}
+
+
+class InteractiveInference(InteractiveScene):
+    """
+    The InteractiveInference acts as the bridge between the RenderData and
+    the Jupyter widget, handling checking if we have the widget package
+    before passing calls to the widget to handle it being an optional
+    dependency
+    """
+
+    def __init__(self, signed_url: str, mode: SceneMode = SceneMode.INLINE) -> None:
+        # Initialize the widget directly without calling parent constructor
+        # since we don't have a real Scene object and override set_scene anyway
+        if not lcj:
+            raise ImportError(
+                "Interactive visualization requires luminarycloud[jupyter] to be installed"
+            )
+        self.widget = lcj.LCVisWidget(scene_mode=mode)
+        self._scene = None  # Not used in InteractiveInference
+
+        # Do inference-specific setup
+        self.set_signed_url(signed_url, False)
+        # Known quantities written by inference
+        self._valid_quantities = [
+            VisQuantity.NONE,
+            VisQuantity.PRESSURE,
+            VisQuantity.WALL_SHEAR_STRESS,
+        ]
+
+    def set_signed_url(self, signed_url: str, isComparator: bool) -> None:
+        # TODO(matt): we could make isCompartor an index so we could compare
+        # more than two scenes at once.
+
+        # Import here to avoid circular import issue
+        from .visualization import LookAtCamera
+
+        WORKSPACE_STATE_CONFIG["filters"][0]["params"]["url"] = signed_url
+        resp = vis_pb2.GetRenderDataUrlsResponse()
+        resp.urls.filter_ids.append(_SOURCE_FILTER_ID)
+        file = resp.urls.data_files.add()
+        file.signed_url = signed_url
+        resp.urls.data_files.append(file)
+        resp.workspace_state = json.dumps(WORKSPACE_STATE_CONFIG)
+
+        self.widget.set_workspace_state(resp, isComparator)
+
+        self.reset_camera()
+        self.widget.set_flat_shading(True)
+
+    def get_field_range(self, quantity: VisQuantity) -> list[float]:
+        """
+        Get the field range for a given quantity.
+        """
+        if quantity not in self._valid_quantities:
+            raise ValueError(
+                f"Invalid field quantity: {quantity}. Valid quantities are: {self._valid_quantities}"
+            )
+        return self.widget.get_field_range(quantity)
+
+    def set_display_field(self, field: Field) -> None:
+        if field.quantity not in self._valid_quantities:
+            raise ValueError(
+                f"Invalid field quantity: {field.quantity}. Valid quantities are: {self._valid_quantities}"
+            )
+        if not quantity_type._is_vector(field.quantity):
+            # We normally handle this on the backend, but we are sending this directly
+            # to lcvis, so we need to make sure scalars are set to the X component
+            field.component = FieldComponent.X
+        attrs = DisplayAttributes()
+        attrs.field = field
+        attrs.visible = True
+        attrs.representation = Representation.SURFACE
+        self.widget.set_display_attributes(_SOURCE_FILTER_ID, attrs)
+
+    def get_field_ranges(self) -> dict[str, list[float]]:
+        """
+        Get the field ranges from the widget.
+        """
+        return self.widget.field_data_map
+
+    def set_color_map(self, color_map: "ColorMap") -> None:
+        if color_map.field.quantity not in self._valid_quantities:
+            raise ValueError(
+                f"Invalid field quantity: {color_map.field.quantity}. Valid quantities are: {self._valid_quantities}"
+            )
+        if not quantity_type._is_vector(color_map.field.quantity):
+            # We normally handle this on the backend, but we are sending this directly
+            # to lcvis, so we need to make sure scalars are set to the X component
+            color_map.field.component = FieldComponent.X
+        super().set_color_map(color_map)
+
+    def set_scene(self, scene: "Scene", isComparator: bool = False) -> None:
+        """
+        InteractiveInference does not support setting scenes.
+        Use set_signed_url() instead to load inference data.
+        """
+        raise NotImplementedError(
+            "InteractiveInference does not support set_scene(). Use set_signed_url() to load inference data."
+        )
+
+    def compare(self, entity) -> None:
+        """
+        InteractiveInference does not support scene comparison.
+        """
+        raise NotImplementedError(
+            "InteractiveInference does not support compare(). This feature is only available for InteractiveScene."
+        )

luminarycloud/vis/interactive_scene.py

@@ -8,13 +8,16 @@ from typing import TYPE_CHECKING, cast, Union
 from .._proto.api.v0.luminarycloud.vis import vis_pb2
 
 if TYPE_CHECKING:
-    from .visualization import Scene, LookAtCamera, ColorMap
+    from .visualization import Scene, LookAtCamera, DirectionalCamera, ColorMap
     from ..geometry import Geometry
     from ..mesh import Mesh
     from ..solution import Solution
 
 try:
     import luminarycloud_jupyter as lcj
+
+    if TYPE_CHECKING:
+        from luminarycloud_jupyter import InteractiveLCVisWidget, LCVisPlaneWidget
 except ImportError:
     lcj = None
 
@@ -105,7 +108,7 @@ class InteractiveScene:
         # is moved there. Matt: this would be a lot of work. The current vis service
         # call used in the backend doesn't use the streaming version. Further, there is
         # a lot of extra code to manage the streaming callbacks.
-        self.widget.set_workspace_state(scene, resp, isComparator)
+        self.widget.set_workspace_state(resp, isComparator)
 
         # Sync display attributes and visibilities for surfaces
         self.set_display_attributes(_SOURCE_FILTER_ID, scene.global_display_attrs)
@@ -115,21 +118,16 @@ class InteractiveScene:
         for f in scene._filters:
             self.set_display_attributes(f.id, f.display_attrs)
 
-        # Find and apply the first look at camera, if any, in the scene
-        set_camera = False
-        for c in scene._cameras:
-            if not isinstance(c, LookAtCamera):
-                continue
-            set_camera = True
-            self.set_camera(c)
-
         # Set any color maps we have. TODO(matt): only a few attributes are connected atm.
         for color_map in scene._color_maps:
             self.set_color_map(color_map)
 
+        # Apply the first camera, if any, in the scene
         # If we don't have an initial camera to use, reset the camera after loading
         # the workspace state
-        if not set_camera:
+        if len(scene._cameras) > 0:
+            self.set_camera(scene._cameras[0])
+        else:
             self.reset_camera()
 
     def set_surface_visibility(self, surface_id: str, visible: bool) -> None:
@@ -144,11 +142,26 @@ class InteractiveScene:
     def reset_camera(self) -> None:
         self.widget.reset_camera()
 
-    def set_camera(self, camera: "LookAtCamera") -> None:
-        self.widget.camera_pan = [camera.pan_x, camera.pan_y]
-        self.widget.camera_position = [camera.position[0], camera.position[1], camera.position[2]]
-        self.widget.camera_look_at = [camera.look_at[0], camera.look_at[1], camera.look_at[2]]
-        self.widget.camera_up = [camera.up[0], camera.up[1], camera.up[2]]
+    def set_camera(self, camera: "LookAtCamera | DirectionalCamera") -> None:
+        # Import here to avoid circular import issue
+        from .visualization import LookAtCamera
+
+        # Clear any prev camera state
+        self.widget.camera_position = []
+        self.widget.camera_look_at = []
+        self.widget.camera_up = []
+        self.widget.camera_pan = []
+        if isinstance(camera, LookAtCamera):
+            self.widget.camera_position = [
+                camera.position[0],
+                camera.position[1],
+                camera.position[2],
+            ]
+            self.widget.camera_look_at = [camera.look_at[0], camera.look_at[1], camera.look_at[2]]
+            self.widget.camera_up = [camera.up[0], camera.up[1], camera.up[2]]
+            self.widget.camera_pan = [camera.pan_x, camera.pan_y, 0]
+        else:
+            self.widget.set_camera_orientation(camera.direction)
 
     def set_color_map(self, color_map: "ColorMap") -> None:
         self.widget.set_color_map(color_map)
@@ -170,6 +183,12 @@ class InteractiveScene:
     def set_triad_visible(self, visible: bool) -> None:
         self.widget.set_triad_visible(visible)
 
+    def add_plane_widget(self) -> "LCVisPlaneWidget":
+        return self.widget.add_plane_widget()
+
+    def delete_widget(self, widget: "InteractiveLCVisWidget") -> None:
+        self.widget.delete_widget(widget)
+
     def compare(self, entity: Union["Geometry", "Mesh", "Solution"]) -> None:
         # The entity can be a Geometry, Mesh, or Solution and is checked by the
         # clone method. This can raise error if the scenes are incompatiable.

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,26 @@ 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)
+
+    def __repr__(self) -> str:
+        return self._to_code_helper(obj_name="plane")
+
 
 @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 +55,71 @@ 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)
+
+    def __repr__(self) -> str:
+        return self._to_code_helper(obj_name="box")
+
+
+@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
+
+    def __repr__(self) -> str:
+        return self._to_code_helper(obj_name="aabb")

luminarycloud/vis/visualization.py

@@ -99,6 +99,9 @@ class DirectionalCamera(CodeRepr):
         self.height = static_ani.resolution.height
         self.projection = CameraProjection(static_ani.camera.projection)
 
+    def __repr__(self) -> str:
+        return self._to_code_helper(obj_name="camera")
+
 
 @dc.dataclass
 class LookAtCamera(CodeRepr):
@@ -158,6 +161,9 @@ class LookAtCamera(CodeRepr):
         self.height = static_ani.resolution.height
         self.projection = CameraProjection(static_ani.camera.projection)
 
+    def __repr__(self) -> str:
+        return self._to_code_helper(obj_name="camera")
+
 
 class RenderOutput:
     """
@@ -855,7 +861,9 @@ class Scene(CodeRepr):
                 raise ValueError(f"Scene.clone: id {id} not present in tags or surface ids")
         return cloned
 
-    def to_code(self, obj_name: str, hide_defaults: bool = True) -> str:
+    def to_code(
+        self, obj_name: str, hide_defaults: bool = True, clean_color_maps: bool = True
+    ) -> str:
         """
         This function will produce a code string that reproduces the scene
         in its current state.
@@ -865,7 +873,12 @@ class Scene(CodeRepr):
         obj_name: str
             the object name of the scene.
         hide_defaults: bool, optional
-            If True, the code will make a best effort not include default values for attributes.
+            If True, the code will make a best effort not to include default values
+            for attributes. Default: True
+        clean_color_maps: bool, optional
+            If True, the code will not include color maps that are not used in
+            the scene. Additionally, this will remove the appearance so they are
+            automatically placed in the image. Default: True.
         """
         imports = "import luminarycloud as lc\n"
         imports += "import luminarycloud.vis as vis\n"
@@ -876,6 +889,7 @@ class Scene(CodeRepr):
         imports += "    CameraProjection,\n"
         imports += "    CameraDirection,\n"
         imports += "    RenderStatusType,\n"
+        imports += "    ExtractStatusType,\n"
         imports += "    Representation,\n"
         imports += "    VisQuantity,\n"
         imports += "    StreamlineDirection,\n"
@@ -967,15 +981,28 @@ class Scene(CodeRepr):
                 if filter._parent_id != "":
                     code += f"{ids_to_obj_name[filter.id]}.set_parent({ids_to_obj_name[filter._parent_id]})\n"
         code += "\n"
+        cmap_code = ""
         if len(self._color_maps) != 0:
             cmap_count = 0
-            code += "# Add color maps\n"
+            cmap_code += "# Add color maps\n"
             for color_map in self._color_maps:
+                if clean_color_maps and color_map.appearance is not None:
+                    # When using UI code gen, the UI state contains color maps
+                    # for every variable including ones that are not visible. We
+                    # optionally clean them up here.
+                    if not color_map.appearance.visible:
+                        # If cleaning up color maps, don't include ones that are not visible.
+                        continue
+                    # Remove the appearance so the auto-placement logic takes over.
+                    color_map.appearance = None
+
                 cmap_name = f"color_map{cmap_count}"
-                code += color_map._to_code_helper(cmap_name, hide_defaults=hide_defaults)
-                code += f"scene.add_color_map({cmap_name})\n"
+                cmap_code += color_map._to_code_helper(cmap_name, hide_defaults=hide_defaults)
+                cmap_code += f"scene.add_color_map({cmap_name})\n"
                 cmap_count += 1
-                code += "\n"
+                cmap_code += "\n"
+            if cmap_count > 0:
+                code += cmap_code
 
         imports += "\n"
         # The code gen is very verbose, so we can do some string replacements
@@ -1005,6 +1032,15 @@ class Scene(CodeRepr):
         ]
         code = "\n".join(filtered_lines)
 
+        # Now add the methods to render and save the images.
+        code += "\n"
+        code += "render_output = scene.render_images(name='my image', description='Longer description')\n"
+        code += "status = render_output.wait()\n"
+        code += "if status == RenderStatusType.COMPLETED:\n"
+        code += "   render_output.save_images('image_prefix')\n"
+        code += "else:\n"
+        code += "   print('Rendering failed', status)\n"
+
         return imports + code
 
 
@@ -1114,6 +1150,11 @@ def _spec_to_scene(spec: vis_pb2.ExtractSpec) -> Scene:
     When we get the extract back, we don't know if it was auto-generated or not.
     Thus, the resulting color maps will be much more verbose than the original.
     """
+
+    # SDK code gen from the UI will not have this set and could be a mix of data
+    # extracts and scene filters. We will skip processing data extracts in this
+    # code and do a best effort. In the UI, they still have a scene and we need to
+    # produce it.
     if spec.data_only:
         raise ValueError("Error: cannot reconstruct a scene from a data only extract")
 
@@ -1180,6 +1221,9 @@ def _spec_to_scene(spec: vis_pb2.ExtractSpec) -> Scene:
             pfilter = Threshold("")
         elif typ == "contour":
             pfilter = Isosurface("")
+        elif typ == "line_sample" or typ == "intersection_curve":
+            # Theses are data extracts and will be handled separately.
+            continue
         else:
             raise ValueError(f"Error: unknown filter type {typ}")
 

luminarycloud/volume_selection.py

@@ -3,7 +3,7 @@ from __future__ import annotations
 
 import logging
 from os import PathLike
-from typing import Iterable, Iterator, Optional, TYPE_CHECKING
+from typing import TYPE_CHECKING, Iterable, Iterator, Optional
 from uuid import uuid4
 
 from luminarycloud._helpers import util
@@ -12,6 +12,7 @@ from luminarycloud._proto.api.v0.luminarycloud.geometry import (
     geometry_pb2 as geometrypb,
 )
 from luminarycloud._proto.upload import upload_pb2 as uploadpb
+from luminarycloud.types.adfloat import _from_ad_proto, _to_ad_proto
 
 from ._client import get_default_client
 from ._proto.base import base_pb2 as basepb
@@ -124,7 +125,6 @@ class VolumeSelection:
         cad_file_path: PathLike,
         *,
         scaling: float = 1.0,
-        force_discrete: bool = False,
         feature_name: str = "Import CAD",
     ) -> None:
         """
@@ -136,8 +136,6 @@ class VolumeSelection:
             The path to the CAD file to import.
         scaling : float
             The scaling factor to apply to the CAD file.
-        force_discrete : bool
-            Whether to force the CAD file to be imported as a discrete mesh.
         feature_name : str
             The name of the feature. This is not a tag name.
         """
@@ -160,8 +158,7 @@ class VolumeSelection:
         feature.import_geometry.CopyFrom(
             gpb.ImportGeometry(
                 geometry_url=cad_url,
-                scaling=scaling,
-                force_discrete=force_discrete,
+                scaling=_to_ad_proto(scaling),
             )
         )
         self.__create_feature(feature)

{luminarycloud-0.16.2.dist-info → luminarycloud-0.18.0.dist-info}/METADATA

@@ -1,34 +1,34 @@
 Metadata-Version: 2.4
 Name: luminarycloud
-Version: 0.16.2
+Version: 0.18.0
 Summary: Luminary Cloud SDK
 Project-URL: Homepage, https://www.luminarycloud.com/
 Project-URL: Documentation, https://app.luminarycloud.com/docs/api/
 Author-email: "Luminary Cloud Inc." <support@luminarycloud.com>
 Keywords: Luminary Cloud,SDK
 Requires-Python: >=3.10
-Requires-Dist: google-crc32c~=1.6.0
-Requires-Dist: googleapis-common-protos~=1.58
-Requires-Dist: grpcio-status~=1.51
-Requires-Dist: grpcio-tools~=1.51
-Requires-Dist: grpcio~=1.51
-Requires-Dist: importlib-metadata~=6.0.0
+Requires-Dist: google-crc32c~=1.7
+Requires-Dist: googleapis-common-protos~=1.70
+Requires-Dist: grpcio-status~=1.65
+Requires-Dist: grpcio-tools~=1.65
+Requires-Dist: grpcio~=1.65
+Requires-Dist: importlib-metadata~=8.7
 Requires-Dist: opentelemetry-api~=1.25
 Requires-Dist: opentelemetry-exporter-otlp-proto-common~=1.25
 Requires-Dist: opentelemetry-exporter-otlp-proto-http~=1.25
-Requires-Dist: opentelemetry-instrumentation-grpc~=0.46b0
-Requires-Dist: opentelemetry-instrumentation~=0.46b0
+Requires-Dist: opentelemetry-instrumentation-grpc~=0.55b1
+Requires-Dist: opentelemetry-instrumentation~=0.55b1
 Requires-Dist: opentelemetry-proto~=1.25
 Requires-Dist: opentelemetry-sdk~=1.25
-Requires-Dist: opentelemetry-semantic-conventions~=0.46b0
-Requires-Dist: protobuf~=4.21
-Requires-Dist: pyjwt~=2.6
-Requires-Dist: python-dotenv~=1.0.0
-Requires-Dist: pyyaml~=6.0.2
-Requires-Dist: requests~=2.28
-Requires-Dist: waitress~=3.0.1
-Requires-Dist: werkzeug~=3.0.1
-Requires-Dist: zstandard
+Requires-Dist: opentelemetry-semantic-conventions~=0.55b1
+Requires-Dist: protobuf~=5.29
+Requires-Dist: pyjwt~=2.10
+Requires-Dist: python-dotenv~=1.1
+Requires-Dist: pyyaml~=6.0
+Requires-Dist: requests~=2.32
+Requires-Dist: waitress~=3.0
+Requires-Dist: werkzeug~=3.1
+Requires-Dist: zstandard~=0.23
 Provides-Extra: jupyter
 Requires-Dist: luminarycloud-jupyter; extra == 'jupyter'
 Description-Content-Type: text/markdown