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

luminarycloud/vis/display.py

@@ -1,5 +1,6 @@
 import dataclasses as dc
 from ..enum.vis_enums import *
+from typing import Tuple, Optional
 
 
 @dc.dataclass
@@ -10,17 +11,18 @@ class Field:
 
     .. warning:: This feature is experimental and may change or be removed in the future.
 
-    Attribues:
-    ----------
-    quantity : VisQuantity
-        The quantity to color by.
-    component : FieldComponent
-        The component of the field to use, applicable to vector fields. If the field is a
-        scalar, use the default X component.
     """
 
     quantity: VisQuantity = VisQuantity.ABSOLUTE_PRESSURE
+    """The quantity to color by."""
     component: FieldComponent = FieldComponent.X
+    """
+    The component of the field to use, applicable to vector fields. If the field is a
+    scalar, use the default X component.
+    """
+
+    def __hash__(self) -> int:
+        return hash((self.quantity, self.component))
 
 
 @dc.dataclass
@@ -31,25 +33,23 @@ class DisplayAttributes:
 
     .. warning:: This feature is experimental and may change or be removed in the future.
 
-    Attributes:
-    ----------
-    visible : bool
-        If the object is visible or not. Default: True
-    opacity : float
-        How opaque the object is. This is a normalized number between
-        0 (i.e., fully transparent) and 1 (i.e., fully opaque). Default: 1
-    field : Field
-        What field quantity/component to color by, if applicable.
-    representation : Representation
-        how the object is represented in the scene (e.g., surface, surface with
-        edges, wireframe or points). Default: surface.
     """
 
     visible: bool = True
+    """If the object is visible or not. Default: True"""
     # TODO(matt): opacity not hooked up yet.
     opacity: float = 1.0
+    """
+    How opaque the object is. This is a normalized number between
+    0 (i.e., fully transparent) and 1 (i.e., fully opaque). Default: 1
+    """
     field: Field = dc.field(default_factory=Field)
+    """What field quantity/component to color by, if applicable."""
     representation: Representation = Representation.SURFACE
+    """
+    how the object is represented in the scene (e.g., surface, surface with
+    edges, wireframe or points). Default: surface.
+    """
 
     def _to_proto(self) -> vis_pb2.DisplayAttributes:
         attrs = vis_pb2.DisplayAttributes()
@@ -69,61 +69,100 @@ class DataRange:
 
     .. warning:: This feature is experimental and may change or be removed in the future.
 
-    Attributes:
-    -----------
-    min_value : float
-        The minimum value of the range.
-    max_value : float
-        The maximum value of the range.
     """
 
     min_value: float = float("inf")
+    """The minimum value of the range."""
     max_value: float = float("-inf")
+    """The maximum value of the range."""
 
     def is_valid(self) -> bool:
         return self.max_value >= self.min_value
 
 
+@dc.dataclass
+class ColorMapAppearance:
+    """
+    ColorMapAppearance controls how the color maps appear in the image, including
+    visibility, position and size.
+
+    The width, height, and the lower left position of the color map are
+    specified in normalized device coordinates. These are values in the [0,1]
+    range. For example, the lower left hand coordinate of the image is [0,0], and the
+    top right coordinate of the image is [1,1].
+
+    .. warning:: This feature is experimental and may change or be removed in the future.
+
+    """
+
+    visible: bool = True
+    """Controls if the color map is displayed or not. Default: True"""
+    width: float = 0.034
+    """The width of the color map in normalized device coordinates. Default: 0.034"""
+    height: float = 0.146
+    """The height of the color map in normalized device coordinates. Default: 0.146"""
+    text_size: int = 36
+    """The text size for the color map legend in pixels. Default: 36"""
+    lower_left_x: float = 0.8
+    """
+    The lower left x position of the color map in normalized device
+    coordinates. Default: 0.8
+    """
+    lower_left_y: float = 0.8
+    """
+    The lower left y position of the color map in normalized device
+    coordinates. Default: 0.8
+    """
+
+
 @dc.dataclass
 class ColorMap:
     """
     The color map allows user control over how field values are mapped to
-    colors.  Color maps are assigned to fields (e.g., the quantity
-    and component) and not individual display attributes. This means that there
-    can only ever be one color map per field/component combination (e.g.,
-    velocity-magnitude or velocity-x). Any display attribute in the scene
-    (i.e., filter display attributes or global display attributes) that maps to
-    this color map will be color in the same manner.
+    colors. Color maps are assigned to fields (e.g., the quantity and component)
+    and not individual display attributes. This means that there can only ever
+    be one color map per field/component combination (e.g., velocity-magnitude
+    or velocity-x). Any display attribute in the scene (i.e., filter display
+    attributes or global display attributes) that maps to this color map will be
+    color in the same manner.
 
     .. warning:: This feature is experimental and may change or be removed in the future.
 
-    Attributes
-    ----------
-    field : Field
-        The field and component this color map applies to.
-    preset : ColorMapPreset
-        The color map preset to use. This defines the colors used in the color
-        map. Default is 'JET'.
-    data_range : DataRange
-        An optional data range to use for the color map. The user must explicity
-        set the data ranges. If not set explicitly, the fields global data range
-        is used. For comparing multiple results, either with different solutions
-        in the same simulation or with different simulations, its highly
-        recommended that a range is provided so the color scales are the same
-        between the resulting images. Default: is an invalid data range.
-    discretize : bool
-        Use discrete color bins instead of a continuous range. When True,
-        'n_colors' indicates how many discrete bins to use. Default: False.
-    n_colors : int
-        How many discrete bins to use when discretize is True. Valid n_colors
-        values are [1, 256]. Default: 8.
     """
 
     field: Field = dc.field(default_factory=Field)
+    """The field and component this color map applies to."""
     preset: ColorMapPreset = ColorMapPreset.JET
+    """
+    The color map preset to use. This defines the colors used in the color
+    map. Default is 'JET'.
+    """
     data_range: DataRange = dc.field(default_factory=DataRange)
+    """
+    An optional data range to use for the color map. The user must explicity
+    set the data ranges. If not set explicitly, the fields global data range
+    is used. For comparing multiple results, either with different solutions
+    in the same simulation or with different simulations, its highly
+    recommended that a range is provided so the color scales are the same
+    between the resulting images. Default: is an invalid data range.
+    """
     discretize: bool = False
+    """
+    Use discrete color bins instead of a continuous range. When True,
+    'n_colors' indicates how many discrete bins to use. Default: False.
+    """
     n_colors: int = 8
+    """
+    How many discrete bins to use when discretize is True. Valid n_colors
+    values are [1, 256]. Default: 8.
+    """
+    appearance: Optional[ColorMapAppearance] = None
+    """
+    This attribute controls how the color map annotation appears in the image, including
+    location, size, and visibility. When the scene is set to automatic color maps, these
+    attributes are automatically populated unless overridden. When setting the appearance,
+    the user is responsible for setting all values.
+    """
 
     def _to_proto(self) -> vis_pb2.ColorMap:
         res: vis_pb2.ColorMap = vis_pb2.ColorMap()
@@ -135,4 +174,15 @@ class ColorMap:
         if self.data_range.is_valid():
             res.range.max = self.data_range.max_value
             res.range.min = self.data_range.min_value
+
+        if not self.appearance:
+            res.visible = True
+        elif not isinstance(self.appearance, ColorMapAppearance):
+            raise TypeError(f"Expected 'ColorMapAppearance', got {type(self.appearance).__name__}")
+        else:
+            res.visible = self.appearance.visible
+            res.width = self.appearance.width
+            res.height = self.appearance.height
+            res.lower_left_anchor_location.x = self.appearance.lower_left_x
+            res.lower_left_anchor_location.y = self.appearance.lower_left_y
         return res

luminarycloud/vis/filters.py

@@ -6,6 +6,8 @@ from abc import ABC, abstractmethod
 import string, random, math
 import dataclasses as dc
 from .display import Field, DisplayAttributes
+from ..enum.vis_enums import StreamlineDirection, SurfaceStreamlineMode
+from typing import List, Any, cast
 
 
 def generate_id(prefix: str) -> str:
@@ -19,38 +21,32 @@ class Plane:
 
     .. warning:: This feature is experimental and may change or be removed in the future.
 
-    Attributes:
-    -----------
-    origin : Vector3
-        A point defined on the plane. Default: [0,0,0].
-    normal : Vector3
-        The vector orthogonal to the  plane. Default: [0,1,0]
     """
 
     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.
 
-    Attributes:
-    -----------
-    center: Vector3
-        A point defined at the center of the box. Default: [0,0,0].
-    lengths: Vector3
-        The the legnths of each side of the box. Default: [1,1,1]
-    angles: Vector3
-        The rotation of the box specified in Euler angles (degrees) and applied
-        in XYZ ordering. Default: [0,0,0]
     """
 
     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]
+    """
 
 
 class Filter(ABC):
@@ -59,17 +55,52 @@ class Filter(ABC):
     is responsible for providing a _to_proto method to convert to a filter
     protobuf.
 
+    Attributes
+    ----------
+    id: str
+        A automatically generated uniqiue filter id.
+
     .. warning:: This feature is experimental and may change or be removed in the future.
     """
 
     def __init__(self, id: str) -> None:
         self.display_attrs = DisplayAttributes()
         self.id = id
+        self._parent_id: str = ""
 
     @abstractmethod
     def _to_proto(self) -> vis_pb2.Filter:
         pass
 
+    def set_parent(self, filter: Any) -> None:
+        """
+        Set this filter's parent filter. This controls what data the filter uses
+        as input.  Filters can be chained into a DAG. If no parent is set, then
+        this filter uses the original dataset.
+
+        Parameters
+        ----------
+        filter: Filter
+            The filter to use as the parent.
+        """
+        if not isinstance(filter, Filter):
+            raise TypeError(f"Expected 'Filter', got {type(filter).__name__}")
+        f = cast(Filter, filter)
+        self._parent_id = f.id
+
+    def reset_parent(self) -> None:
+        """
+        Reset the parent of this filter to the original dataset.
+        """
+        self._parent_id = ""
+
+    def get_parent_id(self) -> str:
+        """
+        Returns the filter's parent id. An empty string will be returned if
+        there is no parent.
+        """
+        return self._parent_id
+
 
 class Slice(Filter):
     """
@@ -84,6 +115,10 @@ class Slice(Filter):
         The slice plane.
     name : str
         A user provided name for the filter.
+    project_vectors: bool
+        When true, vector fields will be projected onto the plane of the slice. This is often
+        useful for visualizing vector fields by removing the vector components in the normal
+        direction of the plane. Default: False
     display_attrs : DisplayAttributes
         Specifies this filter's appearance.
     """
@@ -124,6 +159,55 @@ class Slice(Filter):
         return vis_filter
 
 
+class Isosurface(Filter):
+    """
+    Isosurface is used to evaluate scalar fields at constant values, known as
+    isovalues. In volumes, isosurface produces surfaces, and in surfaces,
+    isosurface produces lines (isolines). Isosurface is also known as contouring
+    and as level-sets.
+
+    .. warning:: This feature is experimental and may change or be removed in the future.
+
+    Attributes:
+    -----------
+    field: Field
+        The scalar field to evaluate.
+    isovalues: List[float]
+        A list of isovalues to evaluate.
+    name : str
+        A user provided name for the filter.
+    display_attrs : DisplayAttributes
+        Specifies this filter's appearance.
+    """
+
+    def __init__(self, name: str) -> None:
+        super().__init__(generate_id("contour-"))
+        self.isovalues: List[float] = []
+        self.field: Field = Field()
+        self.name = name
+
+    def _to_proto(self) -> vis_pb2.Filter:
+        if not isinstance(self.isovalues, List):
+            raise TypeError(f"Expected 'List', got {type(self.isovalues).__name__}")
+
+        if not all(isinstance(x, (int, float)) for x in self.isovalues):
+            raise TypeError("Isosurface: all isovalues must be numbers")
+        if len(self.isovalues) == 0:
+            raise ValueError("Isosurface: isovalue must be non-empty")
+
+        if self.field.quantity == VisQuantity.NONE:
+            raise ValueError("Isosurface: field can't be None")
+
+        vis_filter = vis_pb2.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
+        for val in self.isovalues:
+            vis_filter.contour.iso_values.append(val)
+        return vis_filter
+
+
 class PlaneClip(Filter):
     """
     Clip the dataset using a plane. Cells in the direction of the plane normal
@@ -412,3 +496,288 @@ class Threshold(Filter):
         vis_filter.threshold.invert = self.invert
         vis_filter.threshold.strict = self.strict
         return vis_filter
+
+
+class Streamlines(Filter):
+    """
+    Streanlines is the base class for all the streamlines filters. Full doc strings
+    found in derived classes.
+
+    .. warning:: This feature is experimental and may change or be removed in the future.
+
+    Attributes:
+    -----------
+    name : str
+        A user provided name for the filter.
+    display_attrs : DisplayAttributes
+        Specifies this filter's appearance.
+    """
+
+    def __init__(self, name: str) -> None:
+        super().__init__(generate_id("streamlines-"))
+        self.name: str = name
+        self.n_streamlines: int = 100
+        self.max_length: float = 10
+        self.direction: StreamlineDirection = StreamlineDirection.FORWARD
+        self.field: Field = Field()
+        self.field.quantity = VisQuantity.VELOCITY
+
+
+class RakeStreamlines(Streamlines):
+    """
+    Streamlines is a vector field visualization technique that integrates
+    massless particles through a vector field forming curves. Streamlines are
+    used to visualize and analyze fluid flow patterns (e.g., the velocity
+    field), helping to understand how the fluid moves. Streamlines
+    can be use used to visualize any vector field contained in the solution.
+
+    RakeStreamlines generates seed particles evenly spaced along a line defined
+    by specified start and end points. RakeStreamlines only work with volume
+    data.
+
+    .. warning:: This feature is experimental and may change or be removed in the future.
+
+    Attributes:
+    -----------
+    n_streamlines : int
+        The number of seed particles to place on the rake. Default: 100
+    max_length: float
+        The maximum path length of the particle in meters. Default: 10
+    field: Field
+        The vector field to used for the particle advection. Default: Velocity
+    start: Vector3Like
+        The start point of the rake. Default: [0,0,0].
+    end: Vector3Like
+        The end point point of the rake. Default: [1,0,0].
+    name : str
+        A user provided name for the filter.
+    display_attrs : DisplayAttributes
+        Specifies this filter's appearance.
+    """
+
+    def __init__(self, name: str) -> None:
+        super().__init__(name)
+        self.start: Vector3Like = dc.field(default_factory=lambda: Vector3(x=0, y=0, z=0))
+        self.end: Vector3Like = dc.field(default_factory=lambda: Vector3(x=1, y=0, z=0))
+
+    def _to_proto(self) -> vis_pb2.Filter:
+        # Type checking
+        if not isinstance(self.n_streamlines, int):
+            raise TypeError(f"Expected 'int', got {type(self.n_streamlines).__name__}")
+        if not isinstance(self.max_length, (float, int)):
+            raise TypeError(f"Expected 'float or int', got {type(self.max_length).__name__}")
+        if not isinstance(self.field, Field):
+            raise TypeError(f"Expected 'Field', got {type(self.field).__name__}")
+
+        vis_filter = vis_pb2.Filter()
+        vis_filter.id = self.id
+        vis_filter.name = self.name
+        vis_filter.streamlines.n_streamlines = self.n_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())
+        vis_filter.streamlines.field.quantity_typ = self.field.quantity.value
+        return vis_filter
+
+
+class SurfaceStreamlines(Streamlines):
+    """
+    Streamlines is a vector field visualization technique that integrates
+    massless particles through a vector field forming curves. Streamlines are
+    used to visualize and analyze fluid flow patterns (e.g., the velocity
+    field), helping to understand how the fluid moves. Streamlines
+    can be use used to visualize any vector field contained in the solution.
+
+
+    Surface streamlines has two different modes:
+        - ADVECT_ON_SURFACE: constrain particles to the surfaces of the mesh.
+        - ADVECT_IN_VOLUME: use surface points to seed volumetric streamlines.
+
+    The advection mode also effects what fields can be used. For example, velocity is zero
+    on walls, so when useing ADVECT_ON_SURFACE use a field that has non-zero
+    values such as wall shear stress.
+
+    Example use cases for ADVECT_IN_VOLUME:
+        - placing seeds on an inlet surface and integrating in the forwared direction.
+        - placing seeds on an outlet surface and integrating in the backward direction.
+        - placing seeds on the tires of a car or on the wing of an airplane.
+
+    Example use cases for ADVECT_ON_SURFACE:
+        - Understanding forces on walls such as wall shear stress.
+
+    .. warning:: This feature is experimental and may change or be removed in the future.
+
+    Attributes:
+    -----------
+    mode: SurfaceStreamlinesMode
+        Specifies whether to advect particles on the surface or in the volume.
+        Default: ADVECT_IN_VOLUME
+    sampling_rate : int
+        Specifies how frequently to place seeds on the surface points. A
+        sampling rate of 1 means that a seed particle will be placed at every
+        point on the surfaces. A sampling rate of 10 means that are paced at
+        every 10th point. The value must be a integer greater than 1. Default:
+        100.
+    offset: float
+        User provided offset. Particles placed directly on the surface have a
+        chance of leaving the volume immediately. Set the offset to place seed
+        particles further into the volume based on the surface normal.  Default: 0.0
+    max_length: float
+        The maximum path length of the particle in meters. Default: 10
+    field: Field
+        The vector field to used for the particle advection. Default: Velocity
+    name : str
+        A user provided name for the filter.
+    display_attrs : DisplayAttributes
+        Specifies this filter's appearance.
+    """
+
+    def __init__(self, name: str) -> None:
+        super().__init__(name)
+        self.offset: float = 0.0
+        self._surface_names: List[str] = []
+        self.sampling_rate = 100
+        self.mode: SurfaceStreamlineMode = SurfaceStreamlineMode.ADVECT_IN_VOLUME
+
+    def add_surface(self, id: str) -> None:
+        """
+        Add a surface to generate seed points from.
+
+        Parameters
+        ----------
+        id: str
+            A surface id or a tag id.
+        """
+        if not isinstance(id, str):
+            raise TypeError(f"Expected 'str', got {type(id).__name__}")
+        self._surface_names.append(id)
+
+    def _surfaces(self) -> List[str]:
+        """
+        Returns the current list of surfaces.
+        """
+        return self._surface_names
+
+    def _to_proto(self) -> vis_pb2.Filter:
+        # Type checking
+        if not isinstance(self.n_streamlines, int):
+            raise TypeError(f"Expected 'int', got {type(self.n_streamlines).__name__}")
+        if not isinstance(self.max_length, (float, int)):
+            raise TypeError(f"Expected 'float or int', got {type(self.max_length).__name__}")
+        if not isinstance(self.offset, (float, int)):
+            raise TypeError(f"Expected 'float or int', got {type(self.offset).__name__}")
+        if not isinstance(self.field, Field):
+            raise TypeError(f"Expected 'Field', got {type(self.field).__name__}")
+        if not isinstance(self.mode, SurfaceStreamlineMode):
+            raise TypeError(f"Expected 'SurfaceStreamlinesMode', got {type(self.mode).__name__}")
+
+        vis_filter = vis_pb2.Filter()
+        vis_filter.id = self.id
+        vis_filter.name = self.name
+        vis_filter.streamlines.max_length = self.max_length
+        vis_filter.streamlines.surface.offset = self.offset
+        project = False
+        # Prevent common mistakes that cause confusion.
+        if self.mode == SurfaceStreamlineMode.ADVECT_ON_SURFACE:
+            if self.field.quantity == VisQuantity.VELOCITY:
+                raise ValueError(
+                    "SurfacesStreamines: velocity is 0 on surfaces and will produce no data"
+                )
+            project = True
+        elif self.field.quantity == VisQuantity.WALL_SHEAR_STRESS:
+            raise ValueError(
+                "SurfacesStreamines: wall shear stress is 0 in the volume and will produce no data "
+            )
+
+        vis_filter.streamlines.surface.project_on_surface = project
+        if len(self._surface_names) == 0:
+            raise ValueError("SurfaceStreamlines: need at least one surfaces specified.")
+        for id in self._surface_names:
+            vis_filter.streamlines.surface.surface_names.append(id)
+        vis_filter.streamlines.field.quantity_typ = self.field.quantity.value
+        return vis_filter
+
+
+class SurfaceLIC(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.
+
+    The input is a list of surfaces. If none are specified, all are used. The
+    surface LIC outputs grey scale colors on the specified surfaces. When the
+    display attributes quantity is not None, the field colors are blended with
+    the grey scale colors.
+
+    Note: surface LIC computes on the same surfaces of the solution. If the surfaces in
+    the global display attributes are not hidden, the surface LIC will not be visible since
+    the existing surfaces are occluding it.
+
+    .. warning:: This feature is experimental and may change or be removed in the future.
+
+    Attributes:
+    -----------
+    field: Field
+        Specifies the field used to advect particles for the surface LIC.
+        Default: WALL_SHEER_STRESS
+    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
+    """
+
+    def __init__(self, name: str) -> None:
+        super().__init__(generate_id("surface-lic-"))
+        self.name = name
+        self.contrast: float = 1.0
+        self._surface_names: List[str] = []
+        self.field: Field = Field()
+        self.field.quantity = VisQuantity.WALL_SHEAR_STRESS
+
+    def add_surface(self, id: str) -> None:
+        """
+        Add a surface to generate compute the surface LIC on. Adding no
+        surfaces indicates that all surfaces will be used.
+
+        Parameters
+        ----------
+        id: str
+            A surface id or a tag id.
+        """
+        if not isinstance(id, str):
+            raise TypeError(f"Expected 'str', got {type(id).__name__}")
+        self._surface_names.append(id)
+
+    def _surfaces(self) -> List[str]:
+        """
+        Returns the current list of surfaces.
+        """
+        return self._surface_names
+
+    def _to_proto(self) -> vis_pb2.Filter:
+        vis_filter = vis_pb2.Filter()
+        vis_filter.id = self.id
+        vis_filter.name = self.name
+        # Prevent common mistakes that cause confusion. The only current option
+        # is to be on a surface, so no velocity.
+        if not isinstance(self.field, Field):
+            raise TypeError(f"Expected 'Field', got {type(self.field).__name__}")
+        if self.field.quantity == VisQuantity.VELOCITY:
+            raise ValueError("SurfaceLIC: velocity is 0 on surfaces 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("SurfaceLIC: contrast must be between 0.2 and 3.0")
+
+        for id in self._surface_names:
+            vis_filter.surface_lic.geometry.surface_names.append(id)
+        if len(self._surface_names) == 0:
+            # we need to make sure that the geometry is populated.
+            geometry = vis_pb2.SurfaceLICGeomtery()
+            vis_filter.surface_lic.geometry.CopyFrom(geometry)
+
+        vis_filter.surface_lic.field.quantity_typ = self.field.quantity.value
+        vis_filter.surface_lic.contrast = self.contrast
+        return vis_filter