Add additional config options to render output

Author: Andrzej Krupka

flow360/__init__.py

@@ -107,16 +107,26 @@
     PointArray,
     PointArray2D,
     Slice,
+)
+from flow360.component.simulation.outputs.output_render_types import (
     RenderCameraConfig,
     RenderLightingConfig,
+    RenderEnvironmentConfig,
+    RenderMaterialConfig,
     AmbientLight,
     DirectionalLight,
     OrthographicProjection,
     PerspectiveProjection,
     StaticCamera,
-    OrbitCamera,
-    SplineCamera,
-    KeyframeCamera
+    AnimatedCamera,
+    Keyframe,
+    SolidBackground,
+    SkyboxBackground,
+    SkyboxTexture,
+    PBRMaterial,
+    FieldMaterial,
+    ColorKey,
+    Transform
 )
 from flow360.component.simulation.outputs.outputs import (
     AeroAcousticOutput,

flow360/component/simulation/outputs/output_entities.py

@@ -1,15 +1,15 @@
 """Output for simulation."""
 
 from abc import ABCMeta
-from typing import Literal, Union, Optional
+from typing import Literal, Union
 
 import pydantic as pd
 
 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, AngleType
-from flow360.component.types import Axis, Vector, Color
+from flow360.component.simulation.unit_system import LengthType
+from flow360.component.types import Axis
 
 
 class _OutputItemBase(Flow360BaseModel):
@@ -178,63 +178,3 @@ 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/output_render_types.py

@@ -0,0 +1,134 @@
+import abc
+from enum import Enum
+from typing import Optional, List, Union, Dict
+
+from flow360.component.simulation.framework.base_model import Flow360BaseModel
+from flow360.component.simulation.unit_system import LengthType, AngleType
+
+import pydantic as pd
+
+from flow360.component.types import Vector, Color
+
+
+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(default=(0, 1, 0), description="Up vector, if not specified assume Y+")
+
+
+class Keyframe(Flow360BaseModel):
+    time: pd.confloat(ge=0) = pd.Field(0)
+    view: StaticCamera = pd.Field()
+
+
+class AnimatedCamera(Flow360BaseModel):
+    keyframes: List[Keyframe] = pd.Field([])
+
+
+AllCameraTypes = Union[StaticCamera, AnimatedCamera]
+
+
+class OrthographicProjection(Flow360BaseModel):
+    type: str = pd.Field(default="orthographic", frozen=True)
+    width: LengthType = pd.Field()
+    near: LengthType = pd.Field()
+    far: LengthType = pd.Field()
+
+
+class PerspectiveProjection(Flow360BaseModel):
+    type: str = pd.Field(default="perspective", frozen=True)
+    fov: AngleType = pd.Field()
+    near: LengthType = pd.Field()
+    far: LengthType = pd.Field()
+
+
+class RenderCameraConfig(Flow360BaseModel):
+    view: AllCameraTypes = pd.Field()
+    projection: Union[OrthographicProjection, PerspectiveProjection] = pd.Field()
+
+
+class AmbientLight(Flow360BaseModel):
+    intensity: float = pd.Field()
+    color: Color = pd.Field()
+
+
+class DirectionalLight(Flow360BaseModel):
+    intensity: float = pd.Field()
+    color: Color = pd.Field()
+    direction: Vector = pd.Field()
+
+
+class RenderLightingConfig(Flow360BaseModel):
+    directional: DirectionalLight = pd.Field()
+    ambient: Optional[AmbientLight] = pd.Field(None)
+
+
+class RenderBackgroundBase(Flow360BaseModel, metaclass=abc.ABCMeta):
+    type: str = pd.Field(default="", frozen=True)
+
+
+class SolidBackground(RenderBackgroundBase):
+    type: str = pd.Field(default="solid", frozen=True)
+    color: Color = pd.Field()
+
+
+class SkyboxTexture(str, Enum):
+    SKY = "sky"
+
+
+class SkyboxBackground(RenderBackgroundBase):
+    type: str = pd.Field(default="skybox", frozen=True)
+    texture: SkyboxTexture = pd.Field(SkyboxTexture.SKY)
+
+
+AllBackgroundTypes = Union[
+    SolidBackground,
+    SkyboxBackground
+]
+
+
+class RenderEnvironmentConfig(Flow360BaseModel):
+    background: AllBackgroundTypes = pd.Field()
+
+
+class RenderMaterialBase(Flow360BaseModel, metaclass=abc.ABCMeta):
+    type: str = pd.Field(default="", frozen=True)
+
+
+class PBRMaterial(RenderMaterialBase):
+    color: Color = pd.Field(default=[255, 255, 255])
+    alpha: float = pd.Field(default=1)
+    roughness: float = pd.Field(default=0.5)
+    f0: Vector = pd.Field(default=(0.03, 0.03, 0.03))
+    type: str = pd.Field(default="pbr", frozen=True)
+
+
+class ColorKey(Flow360BaseModel):
+    color: Color = pd.Field(default=[255, 255, 255])
+    value: pd.confloat(ge=0, le=1) = pd.Field(default=0.5)
+
+
+class FieldMaterial(RenderMaterialBase):
+    alpha: float = pd.Field(default=1)
+    output_field: str = pd.Field(default="")
+    min: float = pd.Field(default=0)
+    max: float = pd.Field(default=0)
+    colormap: List[ColorKey] = pd.Field()
+    type: str = pd.Field(default="field", frozen=True)
+
+
+AllMaterialTypes = Union[
+    PBRMaterial,
+    FieldMaterial
+]
+
+
+class RenderMaterialConfig(Flow360BaseModel):
+    materials: List[AllMaterialTypes] = pd.Field([])
+    mappings: Dict[str, int] = pd.Field({})
+
+
+class Transform(Flow360BaseModel):
+    translation: LengthType.Point = pd.Field(default=[0, 0, 0])
+    rotation: AngleType.Vector = pd.Field(default=[0, 0, 0])
+    scale: Vector = pd.Field(default=[1, 1, 1])

flow360/component/simulation/outputs/outputs.py

@@ -19,7 +19,14 @@
     Point,
     PointArray,
     PointArray2D,
-    Slice, RenderCameraConfig, RenderLightingConfig,
+    Slice
+)
+from flow360.component.simulation.outputs.output_render_types import (
+    RenderCameraConfig,
+    RenderLightingConfig,
+    RenderEnvironmentConfig,
+    RenderMaterialConfig,
+    Transform,
 )
 from flow360.component.simulation.outputs.output_fields import (
     AllFieldNames,
@@ -495,16 +502,21 @@ class RenderOutput(_AnimationSettings):
     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.",
+    isosurfaces: Optional[UniqueItemList[Isosurface]] = pd.Field(None,
+        description="List of :class:`~flow360.Isosurface` entities."
+    )
+    surfaces: Optional[EntityList[Surface]] = pd.Field(None,
+        description="List of of :class:`~flow360.Surface` 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")
+    environment: RenderEnvironmentConfig = pd.Field(description="Environment settings")
+    materials: RenderMaterialConfig = pd.Field(description="Material settings")
+    transform: Optional[Transform] = pd.Field(None, description="Optional model transform to apply to all entities")
     output_type: Literal["RenderOutput"] = pd.Field("RenderOutput", frozen=True)
 
 

flow360/component/simulation/translator/solver_translator.py

@@ -457,6 +457,8 @@ def translate_render_output(output_params: list, injection_function):
     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)
+        environment = render.environment.model_dump(exclude_none=True, exclude_unset=True, by_alias=True)
+        materials = render.materials.model_dump(exclude_none=True, exclude_unset=True, by_alias=True)
 
         translated_output = {
             "animationFrequency": render.frequency,
@@ -467,10 +469,25 @@ def translate_render_output(output_params: list, injection_function):
                 translation_func=translate_output_fields,
                 to_list=False,
                 entity_injection_func=injection_function,
+                entity_list_attribute_name="isosurfaces"
+            ),
+            "surfaces": translate_setting_and_apply_to_all_entities(
+                [render],
+                RenderOutput,
+                translation_func=translate_output_fields,
+                to_list=False,
+                entity_list_attribute_name="surfaces"
             ),
             "camera": remove_units_in_dict(camera),
-            "lighting": remove_units_in_dict(lighting)
+            "lighting": remove_units_in_dict(lighting),
+            "environment": remove_units_in_dict(environment),
+            "materials": remove_units_in_dict(materials),
         }
+
+        if render.transform:
+            transform = render.transform.model_dump(exclude_none=True, exclude_unset=True, by_alias=True)
+            translated_output["transform"] = remove_units_in_dict(transform)
+
         translated_outputs.append(translated_output)
 
     return translated_outputs

flow360/component/simulation/translator/utils.py

@@ -229,6 +229,7 @@ def translate_setting_and_apply_to_all_entities(
     lump_list_of_entities=False,
     use_instance_name_as_key=False,
     use_sub_item_as_key=False,
+    entity_list_attribute_name="entities",
     **kwargs,
 ):
     """
@@ -308,26 +309,28 @@ def translate_setting_and_apply_to_all_entities(
         if k.startswith(entity_injection_prefix)
     }
 
+
+
     # pylint: disable=too-many-nested-blocks
     for obj in obj_list:
         if class_type and is_exact_instance(obj, class_type):
-
             list_of_entities = []
-            if "entities" in obj.__class__.model_fields:
-                if obj.entities is None or (
-                    "stored_entities" in obj.entities.__class__.model_fields
-                    and obj.entities.stored_entities is None
+            if entity_list_attribute_name in obj.__class__.model_fields:
+                entities = getattr(obj, entity_list_attribute_name)
+                if entities is None or (
+                    "stored_entities" in entities.__class__.model_fields
+                    and entities.stored_entities is None
                 ):  # unique item list does not allow None "items" for now.
                     continue
-                if isinstance(obj.entities, EntityList):
+                if isinstance(entities, EntityList):
                     list_of_entities = (
-                        obj.entities.stored_entities
+                        entities.stored_entities
                         if lump_list_of_entities is False
-                        else [obj.entities]
+                        else [entities]
                     )
-                elif isinstance(obj.entities, UniqueItemList):
+                elif isinstance(entities, UniqueItemList):
                     list_of_entities = (
-                        obj.entities.items if lump_list_of_entities is False else [obj.entities]
+                        entities.items if lump_list_of_entities is False else [entities]
                     )
             elif "entity_pairs" in obj.__class__.model_fields:
                 # Note: This is only used in Periodic BC and lump_list_of_entities is not relavant