luminarycloud 0.15.2__py3-none-any.whl → 0.15.4__py3-none-any.whl

luminarycloud/vis/visualization.py

@@ -1,3 +1,4 @@
+# Copyright 2023-2024 Luminary Cloud, Inc. All Rights Reserved.
 import dataclasses as dc
 import io
 import json
@@ -7,23 +8,47 @@ from time import sleep, time
 from typing import Dict, List, Tuple, cast
 
 import luminarycloud._proto.api.v0.luminarycloud.common.common_pb2 as common_pb2
-import requests
 from luminarycloud.params.simulation.physics.fluid.boundary_conditions import Farfield
 from luminarycloud.types import Vector3, Vector3Like
 
 from .._client import get_default_client
 from .._helpers._get_project_id import _get_project_id
+from .._proto.quantity import quantity_pb2 as quantitypb
 from .._proto.api.v0.luminarycloud.vis import vis_pb2
-from ..enum.vis_enums import *
+from ..types import SimulationID, MeshID
+from luminarycloud.enum import (
+    CameraDirection,
+    CameraProjection,
+    RenderStatusType,
+    EntityType,
+    SceneMode,
+    VisQuantity,
+    FieldComponent,
+    Representation,
+    ColorMapPreset,
+)
 from ..exceptions import NotFoundError
 from ..geometry import Geometry, get_geometry
 from ..mesh import Mesh, get_mesh, get_mesh_metadata
 from ..simulation import get_simulation
 from ..solution import Solution
 from ..types.vector3 import _to_vector3
-from .display import ColorMap, ColorMapAppearance, DisplayAttributes, Field
-from .filters import BoxClip, Filter, PlaneClip, Slice, SurfaceStreamlines, SurfaceLIC
+from .display import ColorMap, ColorMapAppearance, DisplayAttributes, Field, DataRange
+from .filters import (
+    BoxClip,
+    Filter,
+    PlaneClip,
+    Slice,
+    SurfaceStreamlines,
+    SurfaceLIC,
+    Threshold,
+    RakeStreamlines,
+    ScaledVectorGlyphs,
+    FixedSizeVectorGlyphs,
+    Isosurface,
+)
 from .interactive_scene import InteractiveScene
+from .vis_util import _InternalToken, _download_file, _get_status
 
 logger = logging.getLogger(__name__)
 
@@ -63,6 +88,18 @@ class DirectionalCamera:
     1.0
     """
 
+    def _from_proto(self, static_ani: vis_pb2.AnimationSettingsStatic) -> None:
+        """Populate this DirectionalCamera from a proto static animation property."""
+        c_typ = static_ani.camera.WhichOneof("specification")
+        if c_typ != "direction":
+            raise TypeError(f"Expected 'direction' camera type, got {c_typ}. ")
+        self.label = static_ani.label if static_ani.label else ""
+        self.direction = CameraDirection(static_ani.camera.direction)
+        self.zoom_in = static_ani.camera.zoom
+        self.width = static_ani.resolution.width
+        self.height = static_ani.resolution.height
+        self.projection = CameraProjection(static_ani.camera.projection)
+
 
 @dc.dataclass
 class LookAtCamera:
@@ -104,11 +141,23 @@ class LookAtCamera:
     scene where pan is used (i.e., control + middle mouse).
     """
 
-
-class _InternalToken:
-    """Marker class to control instantiation access for RenderOutput."""
-
-    pass
+    def _from_proto(self, static_ani: vis_pb2.AnimationSettingsStatic) -> None:
+        """Populate this LookAtCamera from a proto static animation property."""
+        c_typ = static_ani.camera.WhichOneof("specification")
+        if c_typ != "look_at":
+            raise TypeError(f"Expected 'look_at' camera type, got {c_typ}. ")
+        self.label = static_ani.label if static_ani.label else ""
+        self.position = Vector3()
+        self.position._from_proto(static_ani.camera.look_at.position)
+        self.up = Vector3()
+        self.up._from_proto(static_ani.camera.look_at.up)
+        self.look_at = Vector3()
+        self.look_at._from_proto(static_ani.camera.look_at.look_at)
+        self.pan_x = static_ani.camera.look_at.pan.x
+        self.pan_y = static_ani.camera.look_at.pan.y
+        self.width = static_ani.resolution.width
+        self.height = static_ani.resolution.height
+        self.projection = CameraProjection(static_ani.camera.projection)
 
 
 class RenderOutput:
@@ -172,8 +221,7 @@ class RenderOutput:
         self
         """
         self._fail_if_deleted()
-        render = get_render(self._project_id, self._extract_id)
-        self.status = render.status
+        self.status = _get_status(self._project_id, self._extract_id)
         return self
 
     def wait(
@@ -231,23 +279,12 @@ class RenderOutput:
         req.project_id = self._project_id
         res: vis_pb2.DownloadExtractResponse = get_default_client().DownloadExtract(req)
 
-        buffers: List[Tuple["io.BytesIO", str]] = []
-        assert len(res.files) == len(res.labels)
-        for output, label in zip(res.files, res.labels):
-            buffer = io.BytesIO()
-            if output.signed_url:
-                response = requests.get(output.signed_url, stream=True)
-                response.raise_for_status()
-                for chunk in response.iter_content(chunk_size=8192):
-                    buffer.write(chunk)
-            elif output.full_contents:
-                buffer.write(output.full_contents)
-            else:
-                raise Exception("download_image respose contains no data.")
-            # Reset buffer position to the beginning for reading
-            buffer.seek(0)
-            buffers.append((buffer, label))
-        return buffers
+        image_buffers: List[Tuple["io.BytesIO", str]] = []
+        assert len(res.images.files) == len(res.images.labels)
+        for output, label in zip(res.images.files, res.images.labels):
+            buffer = _download_file(output)
+            image_buffers.append((buffer, label))
+        return image_buffers
 
     def save_images(self, file_prefix: str, write_labels: bool = False) -> None:
         """
@@ -437,12 +474,26 @@ class Scene:
 
     def hide_far_field(self) -> None:
         """
-        Hide all far fields surfaces based on simulation parameters. Will work
-        if the entity is a simulation.
+        Hide all far fields surfaces based on simulation parameters. Will only work
+        if the entity is a simulation, otherwise it will raise an error.
         """
 
+        if self._entity_type != EntityType.SIMULATION:
+            raise ValueError(
+                "hide_far_field: This method only works with solutions, not meshes or geometries."
+            )
+
         for boundary_id in self._far_field_boundary_ids:
-            self.surface_visibility(boundary_id, False)
+            if boundary_id in self._surface_ids:
+                self.surface_visibility(boundary_id, False)
+            elif boundary_id in self._tag_ids:
+                self.tag_visibility(boundary_id, False)
+            else:
+                # This should not happen, but if it does, we raise an error.
+                raise ValueError(
+                    f"Internal Error: Boundary id {boundary_id} not found in surface ids {self._surface_ids} "
+                    f"or tag ids {self._tag_ids}"
+                )
 
     def surface_ids(self) -> List[str]:
         """Get a list of all the surface ids associated with the mesh."""
@@ -476,6 +527,7 @@ class Scene:
         if not tag_id in self._tag_ids:
             raise ValueError(f"Id {tag_id} not a known tag id {self._tag_ids}")
         self._surface_visibilities[tag_id] = visible
+        # TODO(matt): unroll the tags for the interactive scene.
 
     def add_filter(self, filter: Filter) -> None:
         """
@@ -580,16 +632,7 @@ class Scene:
             static.resolution.height = camera.height
             req.spec.animation_properties.statics.items.append(static)
 
-        req.spec.global_display_attributes.visible = self.global_display_attrs.visible
-        req.spec.global_display_attributes.representation = (
-            self.global_display_attrs.representation.value
-        )
-        req.spec.global_display_attributes.field.component = (
-            self.global_display_attrs.field.component.value
-        )
-        req.spec.global_display_attributes.field.quantity_typ = (
-            self.global_display_attrs.field.quantity.value
-        )
+        req.spec.global_display_attributes.CopyFrom(self.global_display_attrs._to_proto())
 
         for id, visible in self._surface_visibilities.items():
             attrs = vis_pb2.DisplayAttributes()
@@ -629,6 +672,14 @@ class Scene:
             ):
                 cmap_fields[filter.display_attrs.field] = True
 
+        # Add the global display field as well if visible
+        if (
+            self.auto_color_map_annotations
+            and self.global_display_attrs.field.quantity != VisQuantity.NONE
+            and self.global_display_attrs.visible
+        ):
+            cmap_fields[self.global_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.
@@ -638,7 +689,7 @@ class Scene:
 
         # 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:
+        if self.auto_color_map_annotations and self._entity_type == EntityType.SIMULATION:
             auto_cmaps: List[ColorMap] = []
             for field in cmap_fields:
                 found = False
@@ -808,35 +859,6 @@ class Scene:
         return cloned
 
 
-def get_render(project_id: str, extract_id: str) -> RenderOutput:
-    """
-    Get a previously created set of render outputs by project and extract id.
-
-    .. warning:: This feature is experimental and may change or be removed in the future.
-
-    Parameters
-    ----------
-    project_id : str
-        The project id to of the extract.
-    extract_id: str
-        The id to of the extract.
-
-    """
-    req = vis_pb2.GetExtractRequest()
-    req.extract_id = extract_id
-    req.project_id = project_id
-    res: vis_pb2.GetExtractResponse = get_default_client().GetExtract(req)
-    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 render_output
-
-
 def list_quantities(solution: Solution) -> List[VisQuantity]:
     """
     List the quantity types, including derived quantities, that are available in
@@ -911,6 +933,8 @@ def list_renders(entity: Geometry | Mesh | Solution) -> List[RenderOutput]:
     else:
         raise ValueError(f"Unknown entity type: '{entity_type}' ")
 
+    # We are requesting images not data
+    req.data_only = False
     res: vis_pb2.ListExtractsResponse = get_default_client().ListExtracts(req)
 
     results: List[RenderOutput] = []
@@ -928,3 +952,149 @@ def list_renders(entity: Geometry | Mesh | Solution) -> List[RenderOutput]:
         results.append(result)
 
     return results
+
+
+def _reconstruct(extract_id: str, project_id: str) -> Scene:
+    """
+    This function reconstructs a scene from an extract id and project id. The
+    resulting scene should produce an identical image to the one that was
+    originally rendered. The main use case for this function is to support code
+    generation. Note: the scene will render the same image, but the might not
+    contain the exact same settings.  For example, we auto-generate color maps
+    for all fields used in the global and filter display attributes by default.
+    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.
+    """
+    req = vis_pb2.GetExtractRequest()
+    req.extract_id = extract_id
+    req.project_id = project_id
+    res: vis_pb2.GetExtractSpecResponse = get_default_client().GetExtractSpec(req)
+    if res.spec.data_only:
+        raise ValueError("Error: cannot reconstruct a scene from a data only extract")
+
+    entity = res.spec.entity_type.WhichOneof("entity")
+    if entity == "geometry":
+        geom = get_geometry(res.spec.entity_type.geometry.id)
+        scene = Scene(geom)
+    elif entity == "mesh":
+        mesh_id = MeshID(res.spec.entity_type.mesh.id)
+        mesh = get_mesh(mesh_id)
+        scene = Scene(mesh)
+    elif entity == "simulation":
+        sim_id = SimulationID(res.spec.entity_type.simulation.id)
+        sim = get_simulation(sim_id)
+        sols = sim.list_solutions()
+        found = False
+        for sol in sols:
+            if sol.id == res.spec.entity_type.simulation.solution_id:
+                scene = Scene(sol)
+                found = True
+                break
+        if not found:
+            raise ValueError(f"Error: could not find the solution")
+    else:
+        raise ValueError(f"Error: could not resolve entity type")
+
+    try:
+        _ = scene  # check to see if this is bound
+    except NameError:
+        raise ValueError(f"Error: could not create scene from entity")
+
+    # keep track of filter ids so we connect them later and  keep track of
+    # surface and tag visibilties.
+    filter_ids: List[str] = []
+    for filter in res.spec.filters:
+        filter_ids.append(filter.id)
+        typ = filter.WhichOneof("value")
+        pfilter: Filter | None = None
+        if typ == "clip":
+            c_typ = filter.clip.WhichOneof("clip_function")
+            if c_typ == "box":
+                pfilter = BoxClip("")
+            else:
+                pfilter = PlaneClip("")
+        elif typ == "slice":
+            pfilter = Slice("")
+        elif typ == "streamlines":
+            s_typ = filter.streamlines.WhichOneof("seed_type")
+            if s_typ == "surface":
+                pfilter = SurfaceStreamlines("")
+            elif s_typ == "rake":
+                pfilter = RakeStreamlines("")
+            else:
+                raise ValueError(f"Error: unsupported streamlines seed type {s_typ}")
+        elif typ == "glyph":
+            g_typ = filter.glyph.WhichOneof("glyph_size")
+            if g_typ == "fixed_size_glyphs":
+                pfilter = FixedSizeVectorGlyphs("")
+            else:
+                pfilter = ScaledVectorGlyphs("")
+        elif typ == "surface_lic":
+            pfilter = SurfaceLIC("")
+        elif typ == "threshold":
+            pfilter = Threshold("")
+        elif typ == "contour":
+            pfilter = Isosurface("")
+        else:
+            raise ValueError(f"Error: unknown filter type {typ}")
+
+        assert pfilter is not None, "Internal error: filter type not set"
+        pfilter._from_proto(filter)
+        # Set the display attributes
+        pattrs = DisplayAttributes()
+        attrs = res.spec.display_attributes[pfilter.id]
+        assert attrs is not None, "Internal error: display attributes not set"
+        pfilter.display_attrs._from_proto(attrs)
+        scene.add_filter(pfilter)
+
+    # Connect filters to their parents.
+    for parent_id, children in res.spec.filter_connections.items():
+        parent_filter = next((f for f in scene._filters if f.id == parent_id), None)
+        if parent_filter is not None:
+            for child_id in children.children_id:
+                child_filter = next((f for f in scene._filters if f.id == child_id), None)
+                if child_filter is not None:
+                    child_filter.set_parent(parent_filter)
+                else:
+                    raise ValueError(
+                        f"Error: child filter {child_id} not found in the scene filters"
+                    )
+        else:
+            raise ValueError(f"Error: parent filter {parent_id} not found in the scene filters")
+
+    # scene attributes
+    scene.supersampling = res.spec.supersampling_ratio
+    scene.triad_visible = res.spec.triad_properties.visible
+    scene.axes_grid_visible = res.spec.axes_grid_properties.visible
+    scene.background_color = Vector3(
+        x=res.spec.background_properties.color.r,
+        y=res.spec.background_properties.color.g,
+        z=res.spec.background_properties.color.b,
+    )
+    scene.global_display_attrs._from_proto(res.spec.global_display_attributes)
+
+    for id, attrs in res.spec.display_attributes.items():
+        if id in filter_ids:
+            continue  # Skip filters, we already processed them.
+        if id in scene._surface_ids or id in scene._tag_ids:
+            # We only use visible or not for surfaces. The rest of the
+            # attributes are set in the global display attributes.
+            scene._surface_visibilities[id] = attrs.visible
+
+    for static_ani in res.spec.animation_properties.statics.items:
+        cam_typ = static_ani.camera.WhichOneof("specification")
+        if cam_typ == "direction":
+            cam = DirectionalCamera()
+            cam._from_proto(static_ani)
+            scene.add_camera(cam)
+        else:
+            l_cam = LookAtCamera()
+            l_cam._from_proto(static_ani)
+            scene.add_camera(l_cam)
+
+    # Add color maps
+    for color_map in res.spec.color_maps:
+        cmap = ColorMap()
+        cmap._from_proto(color_map)
+        scene.add_color_map(cmap)
+    return scene

{luminarycloud-0.15.2.dist-info → luminarycloud-0.15.4.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: luminarycloud
-Version: 0.15.2
+Version: 0.15.4
 Summary: Luminary Cloud SDK
 Project-URL: Homepage, https://www.luminarycloud.com/
 Project-URL: Documentation, https://app.luminarycloud.com/docs/api/
@@ -24,9 +24,11 @@ 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
 Provides-Extra: jupyter
 Requires-Dist: luminarycloud-jupyter; extra == 'jupyter'
 Description-Content-Type: text/markdown