Added basic data models for render output

Author: Andrzej Krupka

flow360/component/simulation/outputs/output_entities.py

@@ -8,7 +8,7 @@
 from flow360.component.simulation.framework.base_model import Flow360BaseModel
 from flow360.component.simulation.framework.entity_base import EntityBase, generate_uuid
 from flow360.component.simulation.outputs.output_fields import IsoSurfaceFieldNames
-from flow360.component.simulation.unit_system import LengthType
+from flow360.component.simulation.unit_system import AngleType, LengthType
 from flow360.component.simulation.user_code.core.types import (
     Expression,
     UnytQuantity,
@@ -21,7 +21,7 @@
     solver_variable_to_user_variable,
 )
 from flow360.component.simulation.user_code.core.utils import is_runtime_expression
-from flow360.component.types import Axis
+from flow360.component.types import Axis, Color, Vector
 
 
 class _OutputItemBase(Flow360BaseModel):
@@ -289,3 +289,63 @@ class PointArray2D(_PointEntityBase):
     v_axis_vector: LengthType.Axis = pd.Field(description="The scaled v-axis of the parallelogram.")
     u_number_of_points: int = pd.Field(ge=2, description="The number of points along the u axis.")
     v_number_of_points: int = pd.Field(ge=2, description="The number of points along the v axis.")
+
+
+# Linear interpolation between keyframes
+class KeyframeCamera(Flow360BaseModel):
+    pass
+
+
+# Follow a cubic spline curve
+class SplineCamera(Flow360BaseModel):
+    pass
+
+
+# Orbit a point (start and end points specified in spherical coordinates)
+class OrbitCamera(Flow360BaseModel):
+    pass
+
+
+# Static camera setup in Cartesian coordinates
+class StaticCamera(Flow360BaseModel):
+    position: LengthType.Point = pd.Field(description="Position of the camera in the scene")
+    target: LengthType.Point = pd.Field(description="Target point of the camera")
+    up: Optional[Vector] = pd.Field((0, 1, 0), description="Up vector, if not specified assume Y+")
+
+
+# Ortho projection, parallel lines stay parallel
+class OrthographicProjection(Flow360BaseModel):
+    width: LengthType = pd.Field()
+    near: LengthType = pd.Field()
+    far: LengthType = pd.Field()
+
+
+# Perspective projection
+class PerspectiveProjection(Flow360BaseModel):
+    fov: AngleType = pd.Field()
+    near: LengthType = pd.Field()
+    far: LengthType = pd.Field()
+
+
+# Only basic static camera with ortho projection supported currently
+class RenderCameraConfig(Flow360BaseModel):
+    view: StaticCamera = pd.Field()
+    projection: OrthographicProjection = pd.Field()
+
+
+# Ambient light, added by default to all pixels in the scene, simulates global illumination
+class AmbientLight(Flow360BaseModel):
+    intensity: float = pd.Field()
+    color: Color = pd.Field()
+
+
+# Ambient light, added by default to all pixels in the scene, simulates global illumination
+class DirectionalLight(Flow360BaseModel):
+    intensity: float = pd.Field()
+    color: Color = pd.Field()
+    direction: Vector = pd.Field()
+
+
+class RenderLightingConfig(Flow360BaseModel):
+    ambient: AmbientLight = pd.Field()
+    directional: DirectionalLight = pd.Field()

flow360/component/simulation/outputs/outputs.py

@@ -21,6 +21,8 @@
     Point,
     PointArray,
     PointArray2D,
+    RenderCameraConfig,
+    RenderLightingConfig,
     Slice,
 )
 from flow360.component.simulation.outputs.output_fields import (
@@ -665,6 +667,49 @@ def allow_only_simulation_surfaces_or_imported_surfaces(cls, value):
         return value
 
 
+class RenderOutput(_AnimationSettings):
+    """
+
+    :class:`RenderOutput` class for backend rendered output settings.
+
+    Example
+    -------
+
+    Define the :class:`RenderOutput` of :code:`qcriterion` on two isosurfaces:
+
+    >>> fl.RenderOutput(
+    ...     isosurfaces=[
+    ...         fl.Isosurface(
+    ...             name="Isosurface_T_0.1",
+    ...             iso_value=0.1,
+    ...             field="T",
+    ...         ),
+    ...         fl.Isosurface(
+    ...             name="Isosurface_p_0.5",
+    ...             iso_value=0.5,
+    ...             field="p",
+    ...         ),
+    ...     ],
+    ...     output_field="qcriterion",
+    ... )
+
+    ====
+    """
+
+    name: Optional[str] = pd.Field("Render output", description="Name of the `IsosurfaceOutput`.")
+    entities: UniqueItemList[Isosurface] = pd.Field(
+        alias="isosurfaces",
+        description="List of :class:`~flow360.Isosurface` entities.",
+    )
+    output_fields: UniqueItemList[Union[CommonFieldNames, str]] = pd.Field(
+        description="List of output variables. Including "
+        ":ref:`universal output variables<UniversalVariablesV2>` and :class:`UserDefinedField`."
+    )
+    camera: RenderCameraConfig = pd.Field(description="Camera settings")
+    lighting: RenderLightingConfig = pd.Field(description="Lighting settings")
+    output_type: Literal["RenderOutput"] = pd.Field("RenderOutput", frozen=True)
+
+
 class ProbeOutput(_OutputBase):
     """
     :class:`ProbeOutput` class for setting output data probed at monitor points.
@@ -1293,6 +1338,7 @@ class TimeAverageStreamlineOutput(StreamlineOutput):
         AeroAcousticOutput,
         StreamlineOutput,
         TimeAverageStreamlineOutput,
+        RenderOutput,
     ],
     pd.Field(discriminator="output_type"),
 ]

flow360/component/simulation/translator/solver_translator.py

@@ -66,6 +66,7 @@
     IsosurfaceOutput,
     MonitorOutputType,
     ProbeOutput,
+    RenderOutput,
     Slice,
     SliceOutput,
     StreamlineOutput,
@@ -102,6 +103,7 @@
 from flow360.component.simulation.translator.utils import (
     _get_key_name,
     convert_tuples_to_lists,
+    get_all_entries_of_type,
     get_global_setting_from_first_instance,
     has_instance_in_list,
     inline_expressions_in_dict,
@@ -110,6 +112,7 @@
     replace_dict_key,
     translate_setting_and_apply_to_all_entities,
     translate_value_or_expression_object,
+    update_dict_recursively,
 )
 from flow360.component.simulation.unit_system import LengthType
 from flow360.component.simulation.user_code.core.types import (
@@ -190,10 +193,11 @@ def init_output_base(obj_list, class_type: Type, is_average: bool):
         class_type,
         "output_format",
     )
-    assert output_format is not None
-    if output_format == "both":
-        output_format = "paraview,tecplot"
-    base["outputFormat"] = output_format
+    if not no_format:
+        assert output_format is not None
+        if output_format == "both":
+            output_format = "paraview,tecplot"
+        base["outputFormat"] = output_format
 
     if is_average:
         base = init_average_output(base, obj_list, class_type)
@@ -382,6 +386,14 @@ def get_monitor_locations(entities: EntityList):
     return monitor_locations
 
 
+def inject_render_info(entity: Isosurface):
+    """inject entity info"""
+    return {
+        "surfaceField": entity.field,
+        "surfaceFieldMagnitude": entity.iso_value,
+    }
+
+
 def inject_probe_info(entity: EntityList):
     """inject entity info"""
 
@@ -565,6 +577,35 @@ def translate_isosurface_output(
     return translated_output
 
 
+def translate_render_output(output_params: list, injection_function):
+    """Translate render output settings."""
+
+    renders = get_all_entries_of_type(output_params, RenderOutput)
+
+    translated_outputs = []
+
+    for render in renders:
+        camera = render.camera.model_dump(exclude_none=True, exclude_unset=True, by_alias=True)
+        lighting = render.lighting.model_dump(exclude_none=True, exclude_unset=True, by_alias=True)
+
+        translated_output = {
+            "animationFrequency": render.frequency,
+            "animationFrequencyOffset": render.frequency_offset,
+            "isoSurfaces": translate_setting_and_apply_to_all_entities(
+                [render],
+                RenderOutput,
+                translation_func=translate_output_fields,
+                to_list=False,
+                entity_injection_func=injection_function,
+            ),
+            "camera": remove_units_in_dict(camera),
+            "lighting": remove_units_in_dict(lighting),
+        }
+        translated_outputs.append(translated_output)
+
+    return translated_outputs
+
+
 def translate_surface_slice_output(
     output_params: list,
     output_class: Union[SurfaceSliceOutput],
@@ -924,7 +965,11 @@ def translate_output(input_params: SimulationParams, translated: dict):
         if imported_surface_output_configs["surfaces"]:
             translated["timeAverageImportedSurfaceOutput"] = imported_surface_output_configs
 
-    ##:: Step6: Get translated["monitorOutput"]
+    ##:: Step6: Get translated["renderOutput"]
+    if has_instance_in_list(outputs, RenderOutput):
+        translated["renderOutput"] = translate_render_output(outputs, inject_isosurface_info)
+
+    ##:: Step7: Get translated["monitorOutput"]
     probe_output = {}
     probe_output_average = {}
     integral_output = {}
@@ -946,7 +991,7 @@ def translate_output(input_params: SimulationParams, translated: dict):
     if probe_output or integral_output:
         translated["monitorOutput"] = merge_monitor_output(probe_output, integral_output)
 
-    ##:: Step6.1: Get translated["surfaceMonitorOutput"]
+    ##:: Step7.1: Get translated["surfaceMonitorOutput"]
     surface_monitor_output = {}
     surface_monitor_output_average = {}
     if has_instance_in_list(outputs, SurfaceProbeOutput):
@@ -968,17 +1013,17 @@ def translate_output(input_params: SimulationParams, translated: dict):
             surface_monitor_output, surface_monitor_output_average
         )
 
-    ##:: Step6: Get translated["surfaceSliceOutput"]
+    ##:: Step8: Get translated["surfaceSliceOutput"]
     surface_slice_output = {}
     if has_instance_in_list(outputs, SurfaceSliceOutput):
         surface_slice_output = translate_surface_slice_output(outputs, SurfaceSliceOutput)
         translated["surfaceSliceOutput"] = surface_slice_output
 
-    ##:: Step7: Get translated["aeroacousticOutput"]
+    ##:: Step9: Get translated["aeroacousticOutput"]
     if has_instance_in_list(outputs, AeroAcousticOutput):
         translated["aeroacousticOutput"] = translate_acoustic_output(outputs)
 
-    ##:: Step8: Get translated["streamlineOutput"]
+    ##:: Step10: Get translated["streamlineOutput"]
     if has_instance_in_list(outputs, StreamlineOutput):
         translated["streamlineOutput"] = translate_streamline_output(outputs, StreamlineOutput)
 
@@ -987,15 +1032,15 @@ def translate_output(input_params: SimulationParams, translated: dict):
             outputs, TimeAverageStreamlineOutput
         )
 
-    ##:: Step9: Get translated["importedSurfaceIntegralOutput"]
+    ##:: Step11: Get translated["importedSurfaceIntegralOutput"]
     if has_instance_in_list(outputs, SurfaceIntegralOutput):
         imported_surface_integral_output_configs = translate_imported_surface_integral_output(
             outputs,
         )
         if imported_surface_integral_output_configs["surfaces"]:
             translated["importedSurfaceIntegralOutput"] = imported_surface_integral_output_configs
 
-    ##:: Step10: Sort all "output_fields" everywhere
+    ##:: Step12: Sort all "output_fields" everywhere
     # Recursively sort all "outputFields" lists in the translated dict
     def _sort_output_fields_in_dict(d):
         if isinstance(d, dict):

flow360/component/simulation/translator/utils.py

@@ -8,6 +8,7 @@
 from typing import Union
 
 import numpy as np
+import pydantic as pd
 import unyt as u
 
 from flow360.component.simulation.framework.base_model import snake_to_camel
@@ -220,6 +221,17 @@ def getattr_by_path(obj, path: Union[str, list], *args):
     return obj
 
 
+def get_all_entries_of_type(obj_list: list, class_type: type[pd.BaseModel]):
+    entries = []
+
+    if obj_list is not None:
+        for obj in obj_list:
+            if is_exact_instance(obj, class_type):
+                entries.append(obj)
+
+    return entries
+
+
 def get_global_setting_from_first_instance(
     obj_list: list,
     class_type,

flow360/component/types.py

@@ -14,6 +14,7 @@
 List2D = List[List[float]]
 # we use tuple for fixed length lists, beacause List is a mutable, variable length structure
 Coordinate = Tuple[float, float, float]
+Color = Tuple[int, int, int]
 
 
 class Vector(Coordinate):

tests/simulation/translator/test_solver_translator.py

@@ -58,16 +58,24 @@
     ThermalState,
 )
 from flow360.component.simulation.outputs.output_entities import (
+    AmbientLight,
+    DirectionalLight,
+    Isosurface,
+    OrthographicProjection,
     Point,
     PointArray,
     PointArray2D,
+    RenderCameraConfig,
+    RenderLightingConfig,
     Slice,
+    StaticCamera,
 )
 from flow360.component.simulation.outputs.outputs import (
     Isosurface,
     IsosurfaceOutput,
     MovingStatistic,
     ProbeOutput,
+    RenderOutput,
     SliceOutput,
     StreamlineOutput,
     SurfaceIntegralOutput,
@@ -181,6 +189,7 @@ def get_om6Wing_tutorial_param():
     my_wall = Surface(name="1")
     my_symmetry_plane = Surface(name="2")
     my_freestream = Surface(name="3")
+    my_isosurface = Isosurface(name="iso", field="Mach", iso_value=0.5)
     with SI_unit_system:
         param = SimulationParams(
             reference_geometry=ReferenceGeometry(
@@ -244,6 +253,20 @@ def get_om6Wing_tutorial_param():
                     output_format="paraview",
                     output_fields=["Cp"],
                 ),
+                RenderOutput(
+                    entities=[my_isosurface],
+                    output_fields=["qcriterion"],
+                    camera=RenderCameraConfig(
+                        view=StaticCamera(position=(20, 20, 20), target=(0, 0, 0)),
+                        projection=OrthographicProjection(width=30, near=0.01, far=100),
+                    ),
+                    lighting=RenderLightingConfig(
+                        ambient=AmbientLight(intensity=0.4, color=(255, 255, 255)),
+                        directional=DirectionalLight(
+                            intensity=1.5, color=(255, 255, 255), direction=(-1.0, -1.0, -1.0)
+                        ),
+                    ),
+                ),
             ],
         )
     return param