Timestep control TimeAnimation

[cyweco]

Hi guys,

For my CFD post processing, I'm trying to build a animation visualisation app for my simulations which also shows the motion and loading graphs.
I got a webpage running according to the examples (trame/examples/07_paraview) as well as loading the free surface files (copy pasted a pvpython macro, see figure). However, the page does not give me any control over the timeline of the animation. I am trying to follow the trame examples from trame/examples/07_paraview/TimeAnimation/app.py but running that app does not show any data (let alone time control).

I was wondering if there are any other examples or documentation where I can figure out how to implement this.

Here is the app script if there are any other tips:

"""
Trame-based interactive visualization for simulation post-processing.
"""

import os
import json
import asyncio
from trame.app import get_server
from trame.widgets import vuetify, paraview
from trame.ui.vuetify import SinglePageLayout
from trame.widgets.paraview import VtkRemoteLocalView


import paraview as pv
import paraview.util as pv_util
from paraview import simple
# from paraview.simple import *
# from paraview.simple import ResetSession
simple.ResetSession()

# -----------------------------------------------------------------------------
# Trame setup
# -----------------------------------------------------------------------------

server = get_server(client_type="vue2")
state, ctrl = server.state, server.controller

# -----------------------------------------------------------------------------
# Load simulation data 
# -----------------------------------------------------------------------------

animation_scene = simple.GetAnimationScene()
time_keeper = animation_scene.TimeKeeper


metadata = None
time_values = []
representation = None

def load_data(**kwargs):
    global time_values, representation
    # CLI
    args, _ = server.cli.parse_known_args()
    full_path = os.path.abspath(args.data)
    base_path = os.path.dirname(full_path)
    files = []
    reader_props = {}

    with open(full_path, "r") as f:
        metadata = json.load(f)
        reader_props = metadata.get("reader_properties", {})
        fields = metadata.get("fields", [])
        for name in metadata.get("files", []):
            files.append(os.path.join(base_path, name))

    reader = simple.OpenDataFile(files)
    for key, value in reader_props.items():
        reader.GetProperty(key).SetData(value)

    reader.UpdatePipeline()
    representation = simple.Show(reader, view)
    time_values = list(time_keeper.TimestepValues)

    update_color_by(0, fields, "remote")
    state.time_value = time_values[0]
    state.times = len(time_values) - 1
    state.fields = fields

    simple.ResetCamera()
    view.CenterOfRotation = view.CameraFocalPoint
    update_view("local")

# -----------------------------------------------------------------------------
# ParaView pipeline setup
# -----------------------------------------------------------------------------

# Create a render view
view = simple.GetRenderView()
view.UseColorPaletteForBackground = 0
view.Background = [0.8, 0.8, 0.8]
view.OrientationAxesVisibility = 0

# sim_path = "/mnt/data/CFD/production/KCS_hull_in_out/hull_drag_u2.2ms/test3_dp0.03_out/surface/Surface_0000.vtk"
sim_path = "/mnt/data/CFD/production/KCS_hull_in_out/hull_drag_u2.2ms/test3_dp0.03_out"
# /surface/Surface_0000.vtk

# FloatingFiles= paraview.util.Glob(path = sim_path+"/boundary/MotionFloating_*.vtk")
surfaceFiles= pv_util.Glob(path = f'{sim_path}/surface/Surface_*.vtk')
# print(f'files at {sim_path}',surfaceFiles)


# create a new 'Legacy VTK Reader'
surface_vtk = simple.LegacyVTKReader(registrationName='Surface_0000.vtk*', FileNames=surfaceFiles)
surface_Display = simple.Show(surface_vtk, view, 'GeometryRepresentation')
surface_Display.Representation = 'Surface'
surface_Display.SetScalarBarVisibility(view, True)


# get color transfer function/color map for 'Vel'
velLUT = simple.GetColorTransferFunction('Vel')

# get opacity transfer function/opacity map for 'Vel'
velPWF = simple.GetOpacityTransferFunction('Vel')
# Rescale transfer function
velLUT.RescaleTransferFunction(8.967239679996725e-05, 4.786917242841232)




# show color bar/color legend
view.ResetCamera(False, 0.9)
# renderView1.ResetCamera(False, 0.9)

# update the view to ensure updated data information
# view.Update()
# view = simple.Render()




# -----------------------------------------------------------------------------
# Callbacks
# -----------------------------------------------------------------------------

@state.change("active_array")
def update_color_by(active_array, fields, viewMode="remote", **kwargs):
    if len(fields) == 0:
        return

    array = fields[active_array]
    simple.ColorBy(surface_Display, (array.get("location"), array.get("text")))
    surface_Display.RescaleTransferFunctionToDataRange(True, False)
    name = pv.make_name_valid(array.get("text"))
    lut = simple.GetColorTransferFunction(name)
    pwf = simple.GetOpacityTransferFunction(name)
    _min, _max = array.get("range")
    lut.RescaleTransferFunction(_min, _max)
    pwf.RescaleTransferFunction(_min, _max)
    update_view(viewMode)


@state.change("time")
def update_time(time, viewMode, **kwargs):
    if len(time_values) == 0:
        return

    if time >= len(time_values):
        time = 0
        state.time = time
    time_value = time_values[time]
    time_keeper.Time = time_value
    state.time_value = time_value
    update_view(viewMode)


# @state.change("play")
# @asynchronous.task
# async def update_play(**kwargs):
#     while state.play:
#         with state:
#             state.time += 1
#             update_time(state.time, state.viewMode)

#         await asyncio.sleep(0.1)


@state.change("viewMode")
def update_view(viewMode, **kwargs):
    ctrl.view_update_image()
    if viewMode == "local":
        ctrl.view_update_geometry()


# -----------------------------------------------------------------------------
# GUI
# -----------------------------------------------------------------------------

state.trame__title = "Simulation Post-Processing"

with SinglePageLayout(server) as layout:
    layout.title.set_text("Post-Processing Visualization")
    layout.icon.click = ctrl.view_reset_camera

    with layout.toolbar:
        vuetify.VSpacer()
        vuetify.VSlider(
            v_model=("opacity", 0.2),
            min=0,
            max=1,
            step=0.1,
            label="Surface Opacity",
            dense=True,
            hide_details=True,
            style="max-width: 300px",
        )
        vuetify.VBtn(icon=True, click=ctrl.view_reset_camera, children=[vuetify.VIcon("mdi-crop-free")])

    with layout.content:
        with vuetify.VContainer(fluid=True, classes="pa-0 fill-height"):
            # html_view = VtkRemoteLocalView(view)

            # ctrl.view_update = html_view.update
            # ctrl.view_reset_camera = html_view.reset_camera


            html_view = VtkRemoteLocalView(view)
            ctrl.view_update = html_view.update
            ctrl.view_update_image = html_view.update_image        
            ctrl.view_update_geometry = html_view.update_geometry 
            ctrl.view_reset_camera = html_view.reset_camera



    state.play = False  # init




# -----------------------------------------------------------------------------
# Main
# -----------------------------------------------------------------------------

if __name__ == "__main__":
    server.start()

[jourdain]

Is the question on how to make a slider or how to control time in ParaView from Python?

[jourdain]

Ok now that I've read your code, I can see you removed the slider that was driving the time. If you put it back into your UI, you should be able to drive the time interactively since you still have the code that will update ParaView time.

[cyweco]

Thanks, I've placed the slider back in like in the app.py script. I can see a slider now but it does not actually run though the simulation, it just shows the vtk's of the first timestep:

I've tried to put the Paraview pipeline inside the load_data() function but this gives me a whole lot of other issues. I'm not sure if this is an issue within the callback part or if there is an issue in recognizing the timesteps from the data loading. if there is some documentation on this you could refer me to, that would be great!

import os
import json
import asyncio
from trame.app import get_server
from trame.widgets import vuetify, paraview
from trame.ui.vuetify import SinglePageLayout
from trame.widgets.paraview import VtkRemoteLocalView


import paraview as pv
import paraview.util as pv_util
from paraview import simple
# from paraview.simple import *
# from paraview.simple import ResetSession
simple.ResetSession()

# -----------------------------------------------------------------------------
# Trame setup
# -----------------------------------------------------------------------------

server = get_server(client_type="vue2")
state, ctrl = server.state, server.controller

# -----------------------------------------------------------------------------
# Load simulation data 
# -----------------------------------------------------------------------------

animation_scene = simple.GetAnimationScene()
time_keeper = animation_scene.TimeKeeper
sim_path = '/mnt/data/CFD/production/kaizen_pto/study_k1_waves3D_h1.75m_T5.5s_d6m/run_mDBC_v1_dp0.05_out'


metadata = None
time_values = []
representation = None

def load_data(**kwargs):
    global time_values, representation, sim_path
    # CLI
    args, _ = server.cli.parse_known_args()
    full_path = os.path.abspath(args.data)
    base_path = os.path.dirname(full_path)
    files = []
    reader_props = {}

    with open(full_path, "r") as f:
        metadata = json.load(f)
        reader_props = metadata.get("reader_properties", {})
        fields = metadata.get("fields", [])
        for name in metadata.get("files", []):
            files.append(os.path.join(base_path, name))

    reader = simple.OpenDataFile(files)
    for key, value in reader_props.items():
        reader.GetProperty(key).SetData(value)



    reader.UpdatePipeline()
    representation = simple.Show(reader, view)
    time_values = list(time_keeper.TimestepValues)

    update_color_by(0, fields, "remote")
    state.time_value = time_values[0]
    state.times = len(time_values) - 1
    state.fields = fields

    simple.ResetCamera()
    view.CenterOfRotation = view.CameraFocalPoint
    update_view("local")

    # return view
# -----------------------------------------------------------------------------
# ParaView pipeline setup
# -----------------------------------------------------------------------------

# get animation scene
animationScene1 = simple.GetAnimationScene()
# get active view
renderView1 = simple.GetActiveViewOrCreate('RenderView')

# get layout
layout1 = simple.GetLayout()
# layout/tab size in pixels
# layout1.SetSize(1207, 523)

#-----------------------------------
# current camera placement for renderView1
renderView1.InteractionMode = '3D'
renderView1.CameraPosition = [17, -25, 13]
renderView1.CameraFocalPoint = [3, 1, -2.5]
renderView1.CameraViewUp = [-0.2, 0.4, 1]
renderView1.CameraParallelScale = 1.0

# Floating Body______________________________________________________

FloatingFiles= pv_util.Glob(path = sim_path+"/boundary/WEC_*.vtk")                                # get data files    
motionFloating_0000vtk = simple.LegacyVTKReader(registrationName='WEC_0000.vtk*', FileNames=FloatingFiles)     # create a new 'Legacy VTK Reader'
motionFloating_0000vtkDisplay = simple.Show(motionFloating_0000vtk, renderView1, 'GeometryRepresentation')     # show data in view

simple.ColorBy(motionFloating_0000vtkDisplay, None)            # turn off scalar coloring
mkLUT = simple.GetColorTransferFunction('Mk')                  # get color transfer function/color map for 'Mk'        
simple.HideScalarBarIfNotNeeded(mkLUT, renderView1)            # Hide the scalar bar for this color map if no visible data is colored by it.
motionFloating_0000vtkDisplay.AmbientColor = [1.0, 0.6666666666666666, 0.0]        # change solid color
motionFloating_0000vtkDisplay.DiffuseColor = [1.0, 0.6666666666666666, 0.0]

# Mooring ______________________________________________________

MooringFiles= pv_util.Glob(path = sim_path+"/MooringsVtk/MooringsLines_*.vtk")                            # get data files
mooringsLines_0000vtk = simple.LegacyVTKReader(registrationName='MooringsLines_0000.vtk*', FileNames=MooringFiles)     # create a new 'Legacy VTK Reader'
mooringsLines_0000vtkDisplay = simple.Show(mooringsLines_0000vtk, renderView1, 'GeometryRepresentation')               # show data in view
mooringsLines_0000vtkDisplay = simple.GetDisplayProperties(mooringsLines_0000vtk, view=renderView1)                    # get display properties

lineLUT = simple.GetColorTransferFunction('Line')          # get color transfer function/color map for 'Line'
lineLUT.InterpretValuesAsCategories = 1             # Properties modified on lineLUT
lineLUT.AnnotationsInitialized = 1
linePWF = simple.GetOpacityTransferFunction('Line')        # get opacity transfer function/opacity map for 'Line' 
lineTF2D = simple.GetTransferFunction2D('Line')            # get 2D transfer function for 'Line'

# Properties modified on lineLUT
lineLUT.Annotations = ['0', '0', '1', '1', '2', '2', '3', '3', '4', '4', '5', '5']
lineLUT.IndexedColors = [1.0, 1.0, 1.0, 1.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 1.0, 1.0, 1.0, 0.0, 1.0, 0.0, 1.0]
lineLUT.IndexedOpacities = [1.0, 1.0, 1.0, 1.0, 1.0, 1.0]
lineLUT.EnableOpacityMapping = 1

# Surface ______________________________________________________

SurfaceFiles= pv_util.Glob(path = sim_path+"/surface/Surface_*.vtk")
surface_0000vtk = simple.LegacyVTKReader(registrationName='Surface_0000.vtk*', FileNames=SurfaceFiles)     # create a new 'Legacy VTK Reader'
surface_0000vtkDisplay = simple.Show(surface_0000vtk, renderView1, 'GeometryRepresentation')               # show data in view
surface_0000vtkDisplay = simple.GetDisplayProperties(surface_0000vtk, view=renderView1)                    # get display properties


surface_0000vtkDisplay.Opacity = 0.4                     # set opacity

velLUT = simple.GetColorTransferFunction('Vel')            # get color transfer function/color map for 'Vel'
velPWF = simple.GetOpacityTransferFunction('Vel')          # get opacity transfer function/opacity map for 'Vel'
velTF2D = simple.GetTransferFunction2D('Vel')              # get 2D transfer function for 'Vel'
velLUT.RescaleTransferFunction(0.0, 1.5)            # Rescale transfer function
velPWF.RescaleTransferFunction(0.0, 1.5)            # Rescale transfer function
velTF2D.RescaleTransferFunction(0.0, 1.5, 0.0, 1.0) # Rescale 2D transfer function


surface_0000vtkDisplay.SetScalarBarVisibility(renderView1, True)        # show color bar/color legend

annotateTimeFilter1 = simple.AnnotateTimeFilter(registrationName='AnnotateTimeFilter1', Input=surface_0000vtk)     # create a new 'Annotate Time Filter'
annotateTimeFilter1.Format = 'Time: {time:.2f} s '      # Properties modified on annotateTimeFilter1
annotateTimeFilter1.Scale = 0.02                        # Properties modified on annotateTimeFilter1   
annotateTimeFilter1Display = simple.Show(annotateTimeFilter1, renderView1, 'TextSourceRepresentation')     # show data in view


# ctrl.on_server_ready.add(load_data)

# -----------------------------------------------------------------------------
# Callbacks
# -----------------------------------------------------------------------------

@state.change("active_array")
def update_color_by(active_array, fields, viewMode="remote", **kwargs):
    if len(fields) == 0:
        return

    array = fields[active_array]
    simple.ColorBy(surface_0000vtkDisplay, (array.get("location"), array.get("text")))
    surface_0000vtkDisplay.RescaleTransferFunctionToDataRange(True, False)
    name = pv.make_name_valid(array.get("text"))
    lut = simple.GetColorTransferFunction(name)
    pwf = simple.GetOpacityTransferFunction(name)
    _min, _max = array.get("range")
    lut.RescaleTransferFunction(_min, _max)
    pwf.RescaleTransferFunction(_min, _max)
    update_view(viewMode)


@state.change("time")
def update_time(time, viewMode, **kwargs):
    if len(time_values) == 0:
        return

    if time >= len(time_values):
        time = 0
        state.time = time
    time_value = time_values[time]
    time_keeper.Time = time_value
    state.time_value = time_value
    update_view(viewMode)


# @state.change("play")
# @asynchronous.task
# async def update_play(**kwargs):
#     while state.play:
#         with state:
#             state.time += 1
#             update_time(state.time, state.viewMode)

#         await asyncio.sleep(0.1)


@state.change("viewMode")
def update_view(viewMode, **kwargs):
    ctrl.view_update_image()
    if viewMode == "local":
        ctrl.view_update_geometry()


# -----------------------------------------------------------------------------
# GUI
# -----------------------------------------------------------------------------

state.trame__title = "Simulation Post-Processing"

with SinglePageLayout(server) as layout:
    layout.title.set_text("Post-Processing Visualization")
    layout.icon.click = ctrl.view_reset_camera

    with layout.toolbar:
        vuetify.VSpacer()
        vuetify.VSelect(
            v_model=("active_array", 0),
            items=("fields", []),
            style="max-width: 200px",
            hide_details=True,
            dense=True,
        )
        vuetify.VTextField(
            v_model=("time_value", 0),
            disabled=True,
            hide_details=True,
            dense=True,
            style="max-width: 200px",
            classes="mx-2",
        )
        vuetify.VSlider(
            v_model=("time", 0),
            min=0,
            max=("times", 1),
            hide_details=True,
            dense=True,
            style="max-width: 200px",
        )

        vuetify.VCheckbox(
            v_model=("play", False),
            off_icon="mdi-play",
            on_icon="mdi-stop",
            hide_details=True,
            dense=True,
            classes="mx-2",
        )

        with vuetify.VBtn(icon=True, click=ctrl.view_reset_camera):
            vuetify.VIcon("mdi-crop-free")

        vuetify.VCheckbox(
            v_model=("viewMode", "remote"),
            true_value="remote",
            false_value="local",
            off_icon="mdi-rotate-3d",
            on_icon="mdi-video-image",
            hide_details=True,
            dense=True,
            classes="mx-2",
        )

        vuetify.VProgressLinear(
            indeterminate=True,
            absolute=True,
            bottom=True,
            active=("trame__busy",),
        )


    with layout.content:
        with vuetify.VContainer(fluid=True, classes="pa-0 fill-height"):
            html_view = VtkRemoteLocalView(renderView1)
            ctrl.view_update = html_view.update
            ctrl.view_update_image = html_view.update_image        
            ctrl.view_update_geometry = html_view.update_geometry 
            ctrl.view_reset_camera = html_view.reset_camera


# -----------------------------------------------------------------------------
# Main
# -----------------------------------------------------------------------------

if __name__ == "__main__":
    server.start()

[jourdain]

If you need professional support don't hesitate to reach out to Kitware.