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

luminarycloud/vis/filters.py

@@ -1,51 +1,20 @@
 from luminarycloud.types import Vector3, Vector3Like
 from ..types.vector3 import _to_vector3
-from luminarycloud.enum import VisQuantity, StreamlineDirection, SurfaceStreamlineMode
+from luminarycloud.enum import (
+    VisQuantity,
+    StreamlineDirection,
+    SurfaceStreamlineMode,
+    FieldComponent,
+)
+import luminarycloud.enum.quantity_type as quantity_type
 from .._proto.api.v0.luminarycloud.vis import vis_pb2
 from abc import ABC, abstractmethod
-import string, random, math
+import math
 import dataclasses as dc
 from .display import Field, DisplayAttributes
 from typing import List, Any, cast
-
-
-def generate_id(prefix: str) -> str:
-    return prefix + "".join(random.choices(string.ascii_lowercase, k=24))
-
-
-@dc.dataclass
-class Plane:
-    """
-    This class defines a plane.
-
-    .. warning:: This feature is experimental and may change or be removed in the future.
-
-    """
-
-    origin: Vector3Like = dc.field(default_factory=lambda: Vector3(x=0, y=0, z=0))
-    """A point defined on the plane. Default: [0,0,0]."""
-    normal: Vector3Like = dc.field(default_factory=lambda: Vector3(x=1, y=0, z=0))
-    """The vector orthogonal to the  plane. Default: [0,1,0]"""
-
-
-@dc.dataclass
-class Box:
-    """
-    This class defines a box used for filter such as box clip.
-
-    .. warning:: This feature is experimental and may change or be removed in the future.
-
-    """
-
-    center: Vector3Like = dc.field(default_factory=lambda: Vector3(x=0, y=0, z=0))
-    """A point defined at the center of the box. Default: [0,0,0]."""
-    lengths: Vector3Like = dc.field(default_factory=lambda: Vector3(x=1, y=1, z=1))
-    """The the legnths of each side of the box. Default: [1,1,1]"""
-    angles: Vector3Like = dc.field(default_factory=lambda: Vector3(x=0, y=0, z=0))
-    """
-    The rotation of the box specified in Euler angles (degrees) and applied
-    in XYZ ordering. Default: [0,0,0]
-    """
+from .primitives import Box, Plane
+from .vis_util import generate_id
 
 
 class Filter(ABC):
@@ -71,6 +40,10 @@ class Filter(ABC):
     def _to_proto(self) -> vis_pb2.Filter:
         pass
 
+    @abstractmethod
+    def _from_proto(self, filter: vis_pb2.Filter) -> None:
+        pass
+
     def set_parent(self, filter: Any) -> None:
         """
         Set this filter's parent filter. This controls what data the filter uses
@@ -157,6 +130,20 @@ class Slice(Filter):
         vis_filter.slice.project_vectors = self.project_vectors
         return vis_filter
 
+    def _from_proto(self, filter: vis_pb2.Filter) -> None:
+        typ = filter.WhichOneof("value")
+        if typ != "slice":
+            raise TypeError(f"Expected 'slice', got {typ}")
+        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
+
 
 class Isosurface(Filter):
     """
@@ -201,11 +188,30 @@ class Isosurface(Filter):
         vis_filter.id = self.id
         vis_filter.name = self.name
         vis_filter.contour.field.quantity_typ = self.field.quantity.value
-        vis_filter.contour.field.component = self.field.component.value
+        if not quantity_type._is_vector(self.field.quantity):
+            vis_filter.contour.field.component = vis_pb2.Field.COMPONENT_UNSPECIFIED
+        else:
+            vis_filter.contour.field.component = self.field.component.value
         for val in self.isovalues:
             vis_filter.contour.iso_values.append(val)
         return vis_filter
 
+    def _from_proto(self, filter: vis_pb2.Filter) -> None:
+        typ = filter.WhichOneof("value")
+        if typ != "contour":
+            raise TypeError(f"Expected 'contour', got {typ}")
+        self.id = filter.id
+        self.name = filter.name
+        self.field.quantity = VisQuantity(filter.contour.field.quantity_typ)
+        if not quantity_type._is_vector(self.field.quantity):
+            # This is a scalar so just set the component to magnitude which is the default.
+            self.field.component = FieldComponent.MAGNITUDE
+        else:
+            self.field.component = FieldComponent(filter.contour.field.component)
+        self.isovalues.clear()
+        for val in filter.contour.iso_values:
+            self.isovalues.append(val)
+
 
 class PlaneClip(Filter):
     """
@@ -254,6 +260,21 @@ class PlaneClip(Filter):
         vis_filter.clip.inverted = self.inverted
         return vis_filter
 
+    def _from_proto(self, filter: vis_pb2.Filter) -> None:
+        typ = filter.WhichOneof("value")
+        if typ != "clip":
+            raise TypeError(f"Expected 'clip', got {typ}")
+        clip_typ = filter.clip.WhichOneof("clip_function")
+        if clip_typ != "plane":
+            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.inverted = filter.clip.inverted
+
 
 class BoxClip(Filter):
     """
@@ -306,6 +327,27 @@ class BoxClip(Filter):
         vis_filter.clip.inverted = self.inverted
         return vis_filter
 
+    def _from_proto(self, filter: vis_pb2.Filter) -> None:
+        typ = filter.WhichOneof("value")
+        if typ != "clip":
+            raise TypeError(f"Expected 'clip', got {typ}")
+        clip_typ = filter.clip.WhichOneof("clip_function")
+        if clip_typ != "box":
+            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.inverted = filter.clip.inverted
+
 
 class VectorGlyphs(Filter):
     """
@@ -376,10 +418,27 @@ class FixedSizeVectorGlyphs(VectorGlyphs):
         vis_filter.glyph.fixed_size_glyphs = self.size
         vis_filter.glyph.n_glyphs = self.sampling_rate
         vis_filter.glyph.sampling_mode = vis_pb2.GLYPH_SAMPLING_MODE_EVERY_NTH
+        if not quantity_type._is_vector(self.field.quantity):
+            raise ValueError("FixedSizeVectorGlyphs: field must be a vector type")
         vis_filter.glyph.field.quantity_typ = self.field.quantity.value
         vis_filter.glyph.field.component = self.field.component.value
         return vis_filter
 
+    def _from_proto(self, filter: vis_pb2.Filter) -> None:
+        typ = filter.WhichOneof("value")
+        if typ != "glyph":
+            raise TypeError(f"Expected 'glyph', got {typ}")
+        glyph_typ = filter.glyph.WhichOneof("glyph_size")
+        if glyph_typ != "fixed_size_glyphs":
+            raise TypeError(f"Expected 'fixed size', got {typ}")
+        self.id = filter.id
+        self.name = filter.name
+        self.n_glyphs = filter.glyph.n_glyphs
+        self.size = filter.glyph.fixed_size_glyphs
+        self.sampling_rate = filter.glyph.n_glyphs
+        self.field.quantity = VisQuantity(filter.glyph.field.quantity_typ)
+        self.field.component = FieldComponent(filter.glyph.field.component)
+
 
 class ScaledVectorGlyphs(VectorGlyphs):
     """
@@ -420,10 +479,27 @@ class ScaledVectorGlyphs(VectorGlyphs):
         vis_filter.glyph.glyph_scale_size = self.scale
         vis_filter.glyph.n_glyphs = self.sampling_rate
         vis_filter.glyph.sampling_mode = vis_pb2.GLYPH_SAMPLING_MODE_EVERY_NTH
+        if not quantity_type._is_vector(self.field.quantity):
+            raise ValueError("ScaledVectorGyph: field must be a vector type")
         vis_filter.glyph.field.quantity_typ = self.field.quantity.value
         vis_filter.glyph.field.component = self.field.component.value
         return vis_filter
 
+    def _from_proto(self, filter: vis_pb2.Filter) -> None:
+        typ = filter.WhichOneof("value")
+        if typ != "glyph":
+            raise TypeError(f"Expected 'glyph', got {typ}")
+        glyph_typ = filter.glyph.WhichOneof("glyph_size")
+        if glyph_typ != "glyph_scale_size":
+            raise TypeError(f"Expected 'scaled size', got {typ}")
+        self.id = filter.id
+        self.name = filter.name
+        self.n_glyphs = filter.glyph.n_glyphs
+        self.scale = filter.glyph.glyph_scale_size
+        self.sampling_rate = filter.glyph.n_glyphs
+        self.field.quantity = VisQuantity(filter.glyph.field.quantity_typ)
+        self.field.component = FieldComponent(filter.glyph.field.component)
+
 
 class Threshold(Filter):
     """
@@ -490,12 +566,34 @@ class Threshold(Filter):
         vis_filter.threshold.range.min = self.min_value
         vis_filter.threshold.range.max = self.max_value
         vis_filter.threshold.field.quantity_typ = self.field.quantity.value
+        if not quantity_type._is_vector(self.field.quantity):
+            vis_filter.threshold.field.component = vis_pb2.Field.COMPONENT_UNSPECIFIED
+        else:
+            vis_filter.threshold.field.component = self.field.component.value
         vis_filter.threshold.field.component = self.field.component.value
         vis_filter.threshold.smooth = self.smooth
         vis_filter.threshold.invert = self.invert
         vis_filter.threshold.strict = self.strict
         return vis_filter
 
+    def _from_proto(self, filter: vis_pb2.Filter) -> None:
+        typ = filter.WhichOneof("value")
+        if typ != "threshold":
+            raise TypeError(f"Expected 'threshold', got {typ}")
+        self.id = filter.id
+        self.name = filter.name
+        self.min_value = filter.threshold.range.min
+        self.max_value = filter.threshold.range.max
+        self.smooth = filter.threshold.smooth
+        self.invert = filter.threshold.invert
+        self.strict = filter.threshold.strict
+        self.field.quantity = VisQuantity(filter.threshold.field.quantity_typ)
+        if not quantity_type._is_vector(self.field.quantity):
+            # This is a scalar so just set the component to magnitude which is the default.
+            self.field.component = FieldComponent.MAGNITUDE
+        else:
+            self.field.component = FieldComponent(filter.threshold.field.component)
+
 
 class Streamlines(Filter):
     """
@@ -575,9 +673,29 @@ class RakeStreamlines(Streamlines):
         vis_filter.streamlines.max_length = self.max_length
         vis_filter.streamlines.rake.start.CopyFrom(_to_vector3(self.start)._to_proto())
         vis_filter.streamlines.rake.end.CopyFrom(_to_vector3(self.end)._to_proto())
+        if not quantity_type._is_vector(self.field.quantity):
+            raise ValueError("RakeStreamlines: field must be a vector type")
         vis_filter.streamlines.field.quantity_typ = self.field.quantity.value
         return vis_filter
 
+    def _from_proto(self, filter: vis_pb2.Filter) -> None:
+        typ = filter.WhichOneof("value")
+        if typ != "streamlines":
+            raise TypeError(f"Expected 'streamlines', got {typ}")
+        s_typ = filter.streamlines.WhichOneof("seed_type")
+        if s_typ != "rake":
+            raise TypeError(f"Expected 'rake streamlines', got {s_typ}")
+        self.id = filter.id
+        self.name = filter.name
+        self.n_streamlines = filter.streamlines.n_streamlines
+        self.max_length = filter.streamlines.max_length
+
+        self.start = Vector3()
+        self.start._from_proto(filter.streamlines.rake.start)
+        self.end = Vector3()
+        self.end._from_proto(filter.streamlines.rake.end)
+        self.field.quantity = VisQuantity(filter.streamlines.field.quantity_typ)
+
 
 class SurfaceStreamlines(Streamlines):
     """
@@ -693,9 +811,28 @@ class SurfaceStreamlines(Streamlines):
             raise ValueError("SurfaceStreamlines: need at least one surfaces specified.")
         for id in self._surface_names:
             vis_filter.streamlines.surface.surface_names.append(id)
+        if not quantity_type._is_vector(self.field.quantity):
+            raise ValueError("SurfaceStreamlines: field must be a vector type")
+        vis_filter.streamlines.field.component = self.field.component.value
         vis_filter.streamlines.field.quantity_typ = self.field.quantity.value
         return vis_filter
 
+    def _from_proto(self, filter: vis_pb2.Filter) -> None:
+        typ = filter.WhichOneof("value")
+        if typ != "streamlines":
+            raise TypeError(f"Expected 'streamlines', got {typ}")
+        s_typ = filter.streamlines.WhichOneof("seed_type")
+        if s_typ != "surface":
+            raise TypeError(f"Expected 'surface streamlines', got {s_typ}")
+        self.id = filter.id
+        self.name = filter.name
+        self.max_length = filter.streamlines.max_length
+        self.offset = filter.streamlines.surface.offset
+        self._surface_names.clear()
+        for s in filter.streamlines.surface.surface_names:
+            self._surface_names.append(s)
+        self.field.quantity = VisQuantity(filter.streamlines.field.quantity_typ)
+
 
 class SurfaceLIC(Filter):
     """
@@ -737,7 +874,7 @@ class SurfaceLIC(Filter):
 
     def add_surface(self, id: str) -> None:
         """
-        Add a surface to generate compute the surface LIC on. Adding no
+        Add a surface to compute the surface LIC on. Adding no
         surfaces indicates that all surfaces will be used.
 
         Parameters
@@ -780,3 +917,22 @@ class SurfaceLIC(Filter):
         vis_filter.surface_lic.field.quantity_typ = self.field.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 != "geometry":
+            # there is only one type of surface lic currently.
+            raise TypeError(f"Expected geometry', got {l_typ}")
+        self.id = filter.id
+        self.name = filter.name
+        self.contrast = filter.surface_lic.contrast
+        self._surface_names = []
+        for s in filter.surface_lic.geometry.surface_names:
+            self._surface_names.append(s)
+        if not quantity_type._is_vector(self.field.quantity):
+            raise ValueError("SurfaceLIC: field must be a vector type")
+        self.field.quantity = VisQuantity(filter.surface_lic.field.quantity_typ)
+        self.field.component = FieldComponent(filter.surface_lic.field.component)

luminarycloud/vis/interactive_scene.py

@@ -1,3 +1,4 @@
+# Copyright 2023-2024 Luminary Cloud, Inc. All Rights Reserved.
 from .display import DisplayAttributes
 from .filters import SurfaceStreamlines, Filter, SurfaceLIC
 from .._client import get_default_client

luminarycloud/vis/primitives.py

@@ -0,0 +1,38 @@
+# Copyright 2023-2024 Luminary Cloud, Inc. All Rights Reserved.
+import dataclasses as dc
+from luminarycloud.types import Vector3, Vector3Like
+
+
+@dc.dataclass
+class Plane:
+    """
+    This class defines a plane.
+
+    .. warning:: This feature is experimental and may change or be removed in the future.
+
+    """
+
+    origin: Vector3Like = dc.field(default_factory=lambda: Vector3(x=0, y=0, z=0))
+    """A point defined on the plane. Default: [0,0,0]."""
+    normal: Vector3Like = dc.field(default_factory=lambda: Vector3(x=1, y=0, z=0))
+    """The vector orthogonal to the  plane. Default: [0,1,0]"""
+
+
+@dc.dataclass
+class Box:
+    """
+    This class defines a box used for filter such as box clip.
+
+    .. warning:: This feature is experimental and may change or be removed in the future.
+
+    """
+
+    center: Vector3Like = dc.field(default_factory=lambda: Vector3(x=0, y=0, z=0))
+    """A point defined at the center of the box. Default: [0,0,0]."""
+    lengths: Vector3Like = dc.field(default_factory=lambda: Vector3(x=1, y=1, z=1))
+    """The the legnths of each side of the box. Default: [1,1,1]"""
+    angles: Vector3Like = dc.field(default_factory=lambda: Vector3(x=0, y=0, z=0))
+    """
+    The rotation of the box specified in Euler angles (degrees) and applied
+    in XYZ ordering. Default: [0,0,0]
+    """

luminarycloud/vis/vis_util.py

@@ -0,0 +1,56 @@
+# Copyright 2023-2024 Luminary Cloud, Inc. All Rights Reserved.
+import io
+import requests
+import string, random
+import luminarycloud._proto.api.v0.luminarycloud.common.common_pb2 as common_pb2
+from ..enum.vis_enums import RenderStatusType, VisQuantity
+from .._proto.api.v0.luminarycloud.vis import vis_pb2
+from .._client import get_default_client
+
+
+def generate_id(prefix: str) -> str:
+    return prefix + "".join(random.choices(string.ascii_lowercase, k=24))
+
+
+class _InternalToken:
+    """Marker class to control instantiation access for vis outputs."""
+
+    pass
+
+
+def _download_file(file: common_pb2.File) -> "io.BytesIO":
+    buffer = io.BytesIO()
+    if file.signed_url:
+        response = requests.get(file.signed_url, stream=True)
+        response.raise_for_status()
+        for chunk in response.iter_content(chunk_size=8192):
+            buffer.write(chunk)
+    elif file.full_contents:
+        buffer.write(file.full_contents)
+    else:
+        raise Exception("file respose contains no data.")
+    # Reset buffer position to the beginning for reading
+    buffer.seek(0)
+    return buffer
+
+
+def _get_status(project_id: str, extract_id: str) -> RenderStatusType:
+    """
+    Get a previously created set of render outputs by project and extract id. This
+    can be used by both extracts and images since the status type is just an alias.
+
+    .. 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)
+    return RenderStatusType(res.extract.status)