luminarycloud 0.13.0__py3-none-any.whl → 0.14.0__py3-none-any.whl

luminarycloud/vis/interactive_scene.py

@@ -1,16 +1,15 @@
+from .display import DisplayAttributes
+from .filters import SurfaceStreamlines, Filter
 from .._client import get_default_client
-from ..enum.vis_enums import EntityType
-from typing import TYPE_CHECKING
+from ..enum.vis_enums import EntityType, SceneMode
+from typing import TYPE_CHECKING, cast
 
-import luminarycloud._proto.api.v0.luminarycloud.vis.vis_pb2 as vispb
+from .._proto.api.v0.luminarycloud.vis import vis_pb2
 
 if TYPE_CHECKING:
     from .visualization import Scene, LookAtCamera
-    import requests
 
 try:
-    # we need requests for downloading render data
-    import requests
     import luminarycloud_jupyter as lcj
 except ImportError:
     lcj = None
@@ -26,16 +25,23 @@ class InteractiveScene:
 
     # Using the type causes a circular import error, not sure on best way to resolve.
     # I do want to keep this in a separate file
-    def __init__(self, scene: "Scene") -> None:
-        if not lcj or not requests:
+    def __init__(self, scene: "Scene", mode: SceneMode) -> None:
+        if not lcj:
             raise ImportError("InteractiveScene requires luminarycloud[jupyter] to be installed")
-        # TODO (will): not sure on how to suppress the unbound var warnings from pyright
-        # but we won't have this be unbound b/c of the decorator check
-        self.widget = lcj.LCVisWidget()
+        self.widget = lcj.LCVisWidget(scene_mode=mode)
+        self.set_scene(scene)
 
+    def _ipython_display_(self) -> None:
+        """
+        When the InteractiveScene is shown in Jupyter we show the underlying widget
+        to run the widget's frontend code
+        """
+        self.widget._ipython_display_()
+
+    def set_scene(self, scene: "Scene") -> None:
         # Display the initial scene we've been given
         # Submit request for the render data URLs we need
-        req = vispb.GetRenderDataUrlsRequest()
+        req = vis_pb2.GetRenderDataUrlsRequest()
         req.project_id = scene._project_id
         if scene._entity_type == EntityType.SIMULATION:
             req.entity.simulation.id = scene._solution.simulation_id
@@ -50,20 +56,34 @@ class InteractiveScene:
                 f"Expected Solution, Mesh or Geometry in Scene, got {scene._entity_type}"
             )
 
-        # TODO later make this a separate method to load the scene URLs
-        # TODO: would be nice to report filter execution progress
+        # Validate filter connections and filter params.
+        # we don't care about validating anything else that the Scene checks in _create_request
+        # for now. We could unify this code more later.
+        scene._validate_filter_connections()
+        for filter in scene._filters:
+            if isinstance(filter, SurfaceStreamlines):
+                # Validate surfaces names
+                streamlines = cast(SurfaceStreamlines, filter)
+                bad_ids = scene._validate_surfaces_and_tags(streamlines._surface_names)
+                if len(bad_ids) != 0:
+                    raise ValueError(f"SurfaceStreamlines has invalid surfaces: {bad_ids}")
+
+            if isinstance(filter, Filter):
+                vis_filter: vis_pb2.Filter = filter._to_proto()
+                req.filters.append(vis_filter)
+            else:
+                raise TypeError(f"Expected 'filter', got {type(filter).__name__}")
+            if filter.get_parent_id():
+                req.filter_connections[filter.get_parent_id()].children_id.append(filter.id)
+
+        # TODO: would be nice to show execution progress of the workspace here,
+        # some inline progress bar in the notebook
         resp = get_default_client().GetRenderDataUrls(req)
 
         # TODO: would be nice to print/report some download progress info
-        render_data = requests.get(resp.urls.data_files[0].signed_url)
-        self.widget.data = render_data.content
-
-    def _ipython_display_(self) -> None:
-        """
-        When the InteractiveScene is shown in Jupyter we show the underlying widget
-        to run the widget's frontend code
-        """
-        self.widget._ipython_display_()
+        # This can be done on the app frontend side now that the download
+        # is moved there.
+        self.widget.set_workspace_state(scene, resp)
 
     def set_surface_visibility(self, surface_id: str, visible: bool) -> None:
         self.widget.set_surface_visibility(surface_id, visible)
@@ -71,6 +91,9 @@ class InteractiveScene:
     def set_surface_color(self, surface_id: str, color: list[float]) -> None:
         self.widget.set_surface_color(surface_id, color)
 
+    def set_display_attributes(self, object_id: str, attrs: DisplayAttributes) -> None:
+        self.widget.set_display_attributes(object_id, attrs)
+
     def reset_camera(self) -> None:
         self.widget.reset_camera()
 

luminarycloud/vis/visualization.py

@@ -1,4 +1,5 @@
 from .._proto.api.v0.luminarycloud.vis import vis_pb2
+import luminarycloud._proto.api.v0.luminarycloud.common.common_pb2 as common_pb2
 from .._client import get_default_client
 from ..solution import Solution
 from ..mesh import get_mesh_metadata, Mesh, get_mesh
@@ -6,8 +7,8 @@ from ..geometry import Geometry, get_geometry, Tag
 from ..enum.vis_enums import *
 from ..enum.quantity_type import QuantityType
 from ..simulation import get_simulation
-from .display import DisplayAttributes, ColorMap
-from .filters import Filter, PlaneClip, Slice, BoxClip
+from .display import DisplayAttributes, ColorMap, Field, ColorMapAppearance
+from .filters import Filter, PlaneClip, Slice, BoxClip, SurfaceStreamlines
 from luminarycloud.types import Vector3, Vector3Like
 from ..types.vector3 import _to_vector3
 from .._helpers._get_project_id import _get_project_id
@@ -16,7 +17,7 @@ from .interactive_scene import InteractiveScene
 import io
 import json
 from luminarycloud._proto.client import simulation_pb2 as clientpb
-from typing import List, Tuple, cast, Union
+from typing import List, Tuple, cast, Union, Dict
 import requests
 from time import time, sleep
 import logging
@@ -25,6 +26,10 @@ import dataclasses as dc
 logger = logging.getLogger(__name__)
 
 
+def _is_valid_color(obj: common_pb2.Vector3) -> bool:
+    return all(0 <= getattr(obj, attr) <= 1 for attr in ["x", "y", "z"])
+
+
 @dc.dataclass
 class DirectionalCamera:
     """
@@ -34,29 +39,20 @@ class DirectionalCamera:
 
     .. warning:: This feature is experimental and may change or be removed in the future.
 
-    Attributes:
-    -----------
-    name : str
-        A user defined name for the camera.
-    direction : CameraDirection
-        The orientation of the camera. Default: X_POSITIVE
-    projection : CameraProjection
-        The type of projection used for the camera. Default: ORTHOGRAPHIC
-    label: str
-        A user defined label to help distinguish between multiple images.
-        Default: ""
-    width: int
-        The width of the output image in pixels. Default: 1024
-    height: int
-        The height of the output image in pixels. Default: 1024
     """
 
     name: str = "default directional camera"
+    """ A user defined name for the camera. """
     direction: CameraDirection = CameraDirection.X_POSITIVE
+    """ The orientation of the camera. Default: X_POSITIVE """
     projection: CameraProjection = CameraProjection.ORTHOGRAPHIC
+    """ The type of projection used for the camera. Default: ORTHOGRAPHIC """
     label: str = ""
+    """A user defined label to help distinguish between multiple images."""
     width: int = 1024
+    """The width of the output image in pixels. Default: 1024"""
     height: int = 1024
+    """The height of the output image in pixels. Default: 1024"""
 
 
 @dc.dataclass
@@ -68,39 +64,39 @@ class LookAtCamera:
 
     .. warning:: This feature is experimental and may change or be removed in the future.
 
-    Attributes:
-    -----------
-    look_at: Vector3
-        The point the camera is looking at. Default (0,0,0)
-    position: Vector3
-        The position of the camera. Default (0,1,0)
-    up: Vector3
-        The up vector for the camera. Default (0,0,1)
-    projection : CameraProjection
-        The type of projection used for the camera. Default: ORTHOGRAPHIC
-    label: str
-        A user defined label to help distinguish between multiple images. Default: ""
-    width: int
-        The width of the output image in pixels. Default: 1024
-    height: int
-        The height of the output image in pixels. Default: 1024
     """
 
     look_at: Vector3Like = dc.field(default_factory=lambda: Vector3(x=0, y=0, z=0))
+    """ The point the camera is looking at. Default (0,0,0) """
     position: Vector3Like = dc.field(default_factory=lambda: Vector3(x=0, y=1, z=0))
+    """ The position of the camera. Default (0,1,0) """
     up: Vector3Like = dc.field(default_factory=lambda: Vector3(x=0, y=0, z=1))
+    """ The up vector for the camera. Default (0,0,1) """
     projection: CameraProjection = CameraProjection.ORTHOGRAPHIC
+    """ The type of projection used for the camera. Default: ORTHOGRAPHIC """
     label: str = ""
+    """ A user defined label to help distinguish between multiple images. Default: "" """
     width: int = 1024
+    """ The width of the output image in pixels. Default: 1024 """
     height: int = 1024
+    """ The height of the output image in pixels. Default: 1024 """
+
+
+class _InternalToken:
+    """Marker class to control instantiation access for RenderOutput."""
+
+    pass
 
 
 class RenderOutput:
     """
-    The render output represents the request to render images from a geometry, mesh or
-    solution. The operation exectutes asyncronously, so the caller must check
-    the status of the image extract. If the status is completed, then the
-    resuling image is available for download.
+    The render output represents the request to render images from a geometry,
+    mesh or solution, and is contructed by the Scene class. The operation
+    exectutes asyncronously, so the caller must check the status of the image
+    extract. If the status is completed, then the resuling image is available
+    for download.
+
+    .. warning:: This class should not be directly instantiated by users.
 
     .. warning:: This feature is experimental and may change or be removed in the future.
 
@@ -120,17 +116,27 @@ class RenderOutput:
         Internal flag to track if the extract has been deleted.
     """
 
-    def __init__(
-        self, extract_id: str, project_id: str, name: str, desciption: str, status: RenderStatusType
-    ):
+    def __init__(self, factory_token: _InternalToken):
+        if not isinstance(factory_token, _InternalToken):
+            raise ValueError("This class can only be constructed through the Scene class")
+
         # TODO(matt): We could make all of these read only.
-        self._extract_id: str = extract_id
-        self._project_id: str = project_id
-        self.status: RenderStatusType = status
-        self.name: str = name
-        self.description: str = desciption
+        self._extract_id: str = ""
+        self._project_id: str = ""
+        self.status: RenderStatusType = RenderStatusType.INVALID
+        self.name: str = ""
+        self.description: str = ""
         self._deleted = False
 
+    def _set_data(
+        self, extract_id: str, project_id: str, name: str, desciption: str, status: RenderStatusType
+    ) -> None:
+        self._extract_id = extract_id
+        self._project_id = project_id
+        self.status = status
+        self.name = name
+        self.description = desciption
+
     def __repr__(self) -> str:
         return f"RenderOutput(Id: {self._extract_id} status: {self.status})"
 
@@ -275,13 +281,13 @@ class Scene:
     with what "entity" you want to visualize: a solution, a mesh, or
     a geometry.
 
-    global display attributes: The global display attributes control the default
+    Global display attributes: The global display attributes control the default
     appearance of all the surfaces (i.e. boundaries). Attributes include visibitiy,
     what fields are displayed on the surfaces (if applicable), and representation
     (e.g., surface, surface with edges, ...).
 
-    Individaul surface visibities can be overidden to hide/show specific surfaces.
-    Additionally, if the scene is contructed around a simulation, a helper method is
+    Individual surface visibilities can be overidden to hide/show specific surfaces.
+    Additionally, if the scene is constructed around a simulation, a helper method is
     provided to automatically hide surfaces associated with far fields.
 
     .. warning:: This feature is experimental and may change or be removed in the future.
@@ -292,9 +298,32 @@ class Scene:
         These attributes apply to all the surfaces in the
         geometry/mesh/solution. Individual surface visibilities can be
         overridden with the 'surface_visibility' function.
+    triad_visible: bool
+        This value controls whether the triad is visible or not in the rendered
+        images.  Default: True
+    background_color: Vector3Like
+        This value controls then scene background color. These are rgb values in
+        the range [0,1] for each component.  Default: [0,0,0]
+    axes_grid_visible: bool
+        This values controls whether the axes grid is visible or not in the
+        rendered images. Default: False
+    auto_color_map_annotations: bool
+        This values controls whether we automatically generate color map
+        annotations for all fields used in global and filter display attributes.
+        When False, only color maps explicitly added by the user appear in the
+        images. Default: True
+    supersampling: int
+        Supersampling controls anti-aliasing in output images. A value of 1 means no supersampling.
+        A value of 2 means we internally render at 2x the image resolution and downsample the image
+        to the requested resolution. Valid values are between 1 and 8. Default: 2
     """
 
     def __init__(self, entity: Geometry | Mesh | Solution):
+        self.triad_visible: bool = True
+        self.axes_grid_visible: bool = True
+        self.background_color: Vector3 = Vector3(x=0, y=0, z=0)
+        self.auto_color_map_annotations = True
+        self.supersampling: int = 2
         # Global display attrs
         self.global_display_attrs = DisplayAttributes()
         self._filters: List[Filter] = []
@@ -347,7 +376,7 @@ class Scene:
         elif self._entity_type == EntityType.MESH:
             mesh_meta = get_mesh_metadata(self._mesh.id)
             try:
-                geom = get_geometry(self._mesh.geometry_version().id)
+                geom = get_geometry(self._mesh.geometry_version().geometry_id)
             except NotFoundError:
                 self._has_tags = False
             except Exception as e:
@@ -469,6 +498,35 @@ class Scene:
             )
         self._cameras.append(camera)
 
+    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] = []
+        for id in ids:
+            if id in self._tag_ids:
+                continue
+            if id not in self._surface_ids:
+                bad_ids.append(id)
+        return bad_ids
+
+    def _validate_filter_connections(self) -> None:
+        """
+        Validate that the filters have valid connections.
+        """
+        filter_ids: List[str] = []
+        for filter in self._filters:
+            filter_ids.append(filter.id)
+
+        for filter in self._filters:
+            parent_id = filter.get_parent_id()
+            if not parent_id:
+                # Using the root when we have an empty string
+                continue
+            if parent_id not in filter_ids:
+                raise ValueError(f"Filter {filter.id} parent {parent_id} not present in filters")
+
     def _create_request(self, name: str, description: str) -> vis_pb2.CreateExtractRequest:
         req = vis_pb2.CreateExtractRequest()
         if len(self._cameras) == 0:
@@ -512,18 +570,104 @@ class Scene:
             attrs.field.quantity_typ = quantitypb.INVALID_QUANTITY_TYPE
             req.spec.display_attributes[id].CopyFrom(attrs)
 
+        self._validate_filter_connections()
+        cmap_fields: Dict[Field, bool] = {}
         for filter in self._filters:
+            if isinstance(filter, SurfaceStreamlines):
+                # Validate surfaces names
+                streamlines = cast(SurfaceStreamlines, filter)
+                bad_ids = self._validate_surfaces_and_tags(streamlines._surface_names)
+                if len(bad_ids) != 0:
+                    raise ValueError(f"SurfaceStreamlines has invalid surfaces: {bad_ids}")
+
             if isinstance(filter, Filter):
                 vis_filter: vis_pb2.Filter = filter._to_proto()
                 req.spec.filters.append(vis_filter)
                 req.spec.display_attributes[filter.id].CopyFrom(filter.display_attrs._to_proto())
             else:
                 raise TypeError(f"Expected 'filter', got {type(filter).__name__}")
+            if filter.get_parent_id():
+                req.spec.filter_connections[filter.get_parent_id()].children_id.append(filter.id)
+            if (
+                self.auto_color_map_annotations
+                and filter.display_attrs.field.quantity != VisQuantity.NONE
+                and filter.display_attrs.visible
+            ):
+                cmap_fields[filter.display_attrs.field] = True
 
         for cmap in self._color_maps:
+            if self.auto_color_map_annotations and not cmap.appearance:
+                # Defer color map processing to the auto color annotation.
+                continue
             color_map: vis_pb2.ColorMap = cmap._to_proto()
             req.spec.color_maps.append(color_map)
 
+        # Add the automated color maps if enabled. If we don't specify them
+        # in the proto, the annotations will not appear in the image.
+        if self.auto_color_map_annotations:
+            auto_cmaps: List[ColorMap] = []
+            for field in cmap_fields:
+                found = False
+                # Make sure we don't have an explicit color map for this field.
+                for cmap in self._color_maps:
+                    if field == cmap.field:
+                        found = True
+                if not found:
+                    default_cmap = ColorMap()
+                    default_cmap.field = field
+                    default_cmap.appearance = ColorMapAppearance()
+                    auto_cmaps.append(default_cmap)
+            for cmap in self._color_maps:
+                if not cmap.appearance:
+                    # Include any color maps with no appearance set. We skipped
+                    # processing them above
+                    cmap.appearance = ColorMapAppearance()
+                    auto_cmaps.append(cmap)
+            if len(auto_cmaps) != 0:
+                # These are all default contructed, so they all have the same dimentions.
+                # All the coordinates are in normalized device space.
+                assert auto_cmaps[0].appearance != None
+                appearance = cast(ColorMapAppearance, auto_cmaps[0].appearance)
+                width = appearance.width
+                height = appearance.height
+                x_padding = 0.05
+                y_padding = 0.05
+                # Placing them on the right side.
+                lower_left_x = 1.0 - width - x_padding
+                lower_left_y = 1.0 - height - y_padding
+                for cmap in auto_cmaps:
+                    assert cmap.appearance != None
+                    cmap_appearance = cast(ColorMapAppearance, cmap.appearance)
+                    cmap_appearance.lower_left_x = lower_left_x
+                    cmap_appearance.lower_left_y = lower_left_y
+                    lower_left_y = lower_left_y - height - y_padding
+                    if lower_left_y < 0:
+                        lower_left_y = 0
+                    color_map_proto: vis_pb2.ColorMap = cmap._to_proto()
+                    req.spec.color_maps.append(color_map_proto)
+
+        if not isinstance(self.triad_visible, bool):
+            raise TypeError(f"Expected 'bool', got {type(self.triad_visible).__name__}")
+        req.spec.triad_properties.visible = self.triad_visible
+
+        if not isinstance(self.axes_grid_visible, bool):
+            raise TypeError(f"Expected 'bool', got {type(self.axes_grid_visible).__name__}")
+        req.spec.axes_grid_properties.visible = self.axes_grid_visible
+
+        bg_color = _to_vector3(self.background_color)._to_proto()
+        if not _is_valid_color(bg_color):
+            raise ValueError(f"Background color is not in the range [0,1]: {bg_color}")
+        req.spec.background_properties.color.r = bg_color.x
+        req.spec.background_properties.color.g = bg_color.y
+        req.spec.background_properties.color.b = bg_color.z
+        req.spec.background_properties.color.a = 1
+
+        if not isinstance(self.supersampling, int):
+            raise TypeError(f"Expected 'int', got {type(self.supersampling).__name__}")
+        if self.supersampling < 1 or self.supersampling > 8:
+            raise ValueError(f"Supersampling value is not in the range [1,8]: {self.supersampling}")
+        req.spec.supersampling_ratio = self.supersampling
+
         req.project_id = self._project_id
         if self._entity_type == EntityType.SIMULATION:
             req.spec.entity_type.simulation.id = self._solution.simulation_id
@@ -552,22 +696,24 @@ class Scene:
         req: vis_pb2.CreateExtractRequest = self._create_request(name=name, description=description)
         res: vis_pb2.CreateExtractResponse = get_default_client().CreateExtract(req)
         logger.info("Successfully submitted 'render_images' request")
-        return RenderOutput(
+        render_output = RenderOutput(_InternalToken())
+        render_output._set_data(
             extract_id=res.extract.extract_id,
             project_id=self._project_id,
             name=name,
             desciption=description,
             status=RenderStatusType(res.extract.status),
         )
+        return render_output
 
-    def interact(self) -> InteractiveScene:
+    def interact(self, scene_mode: SceneMode = SceneMode.SIDE_PANEL) -> InteractiveScene:
         """
         Start an interactive display of the scene, when running inside LuminaryCloud's
         AI Notebook environment or Jupyter Lab. The returned object must be displayed
         in the notebook to display the interactive visualization. This requires that
         the luminarycloud package was installed with the optional jupyter feature.
         """
-        self._interactive_scene = InteractiveScene(self)
+        self._interactive_scene = InteractiveScene(self, mode=scene_mode)
         return self._interactive_scene
 
 
@@ -589,14 +735,15 @@ def get_render(project_id: str, extract_id: str) -> RenderOutput:
     req.extract_id = extract_id
     req.project_id = project_id
     res: vis_pb2.GetExtractResponse = get_default_client().GetExtract(req)
-    output = RenderOutput(
+    render_output = RenderOutput(_InternalToken())
+    render_output._set_data(
         extract_id=extract_id,
         project_id=project_id,
         name=res.extract.name,
         desciption=res.extract.description,
         status=RenderStatusType(res.extract.status),
     )
-    return output
+    return render_output
 
 
 def list_quantities(solution: Solution) -> List[VisQuantity]:
@@ -677,15 +824,14 @@ def list_renders(entity: Geometry | Mesh | Solution) -> List[RenderOutput]:
 
     results: List[RenderOutput] = []
     for extract in res.extracts:
-        result = RenderOutput(
+        result = RenderOutput(_InternalToken())
+        result._set_data(
             extract_id=extract.extract_id,
             project_id=extract.project_id,
             name=extract.name,
             desciption=extract.description,
             status=RenderStatusType(extract.status),
         )
-
-        # TODO(matt): the List extracts request is giving us nil for the status.
         # This need to be fixed on the backend, but manually refreshing works for now.
         result.refresh()
         results.append(result)

{luminarycloud-0.13.0.dist-info → luminarycloud-0.14.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: luminarycloud
-Version: 0.13.0
+Version: 0.14.0
 Summary: Luminary Cloud SDK
 Project-URL: Homepage, https://www.luminarycloud.com/
 Project-URL: Documentation, https://app.luminarycloud.com/docs/api/
@@ -29,7 +29,6 @@ Requires-Dist: waitress~=3.0.1
 Requires-Dist: werkzeug~=3.0.1
 Provides-Extra: jupyter
 Requires-Dist: luminarycloud-jupyter; extra == 'jupyter'
-Requires-Dist: requests; extra == 'jupyter'
 Description-Content-Type: text/markdown
 
 Luminary Cloud's Python Software Development Kit (SDK) allows you to access many of the features within our platform programmatically (i.e. without needing to go through the graphical user interface in your browser).