eval_cases/paraview/paraview_cases.yaml

# Comprehensive Test Cases for SciVisAgentBench Main Tasks
# This test evaluates the ability to complete specific visualization tasks
# with detailed requirements and evaluation criteria

# Case 1: ABC
- vars:
    question: |
        Load the ABC (Arnold-Beltrami-Childress) flow vector field from "ABC/data/ABC_128x128x128_float32_scalar3.raw", the information about this dataset:
        ABC Flow (Vector)
        Data Scalar Type: float
        Data Byte Order: Little Endian
        Data Extent: 128x128x128
        Number of Scalar Components: 3
        Data loading is very important, make sure you correctly load the dataset according to their features.

        Create streamlines using a "Stream Tracer" filter with "Point Cloud" seed type. Set the seed center to [73.77, 63.25, 71.65], with 150 seed points and a radius of 75.0. Set integration direction to "BOTH" and maximum streamline length to 150.0.

        Add a "Tube" filter on the stream tracer to enhance visualization. Set tube radius to 0.57 with 12 sides.

        Color the tubes by Vorticity magnitude using the 'Cool to Warm (Diverging)' colormap.

        Show the dataset bounding box as an outline.

        Use a white background. Render at 1024x1024.

        Save the visualization image as "ABC/results/{agent_mode}/ABC.png".
        (Optional, but must save if use paraview) Save the paraview state as "ABC/results/{agent_mode}/ABC.pvsm".
        (Optional, but must save if use python script) Save the python script as "ABC/results/{agent_mode}/ABC.py".
        Do not save any other files, and always save the visualization image.
  assert:
    - type: llm-rubric
      subtype: vision
      value: |
          1. Streamline Density: Are the streamline tubes densely distributed throughout the volume, similar to the ground truth?
          2. Color Mapping: Are the tubes colored by vorticity magnitude using a blue-white-red diverging colormap, with a similar color distribution as the ground truth?
          3. Tube Appearance: Do the streamline tubes have a similar thickness and smooth appearance as the ground truth?

# Case 2: argon-bubble
- vars:
    question: |
        Task:
        Load the Argon Bubble dataset from "argon-bubble/data/argon-bubble_128x128x256_float32.vtk".
        Generate a visualization image of the Argon Bubble scalar field dataset with the following visualization settings:
        1) Create volume rendering
        2) Set the opacity transfer function as a ramp function across values of the volumetric data, assigning opacity 0 to value 0 and assigning opacity 1 to value 1.
        3) Set the color transfer function to assign a warm red color [0.71, 0.02, 0.15] to the highest value, a cool color [0.23, 0.29, 0.75] to the lowest value, and a grey color[0.87, 0.87, 0.87] to the midrange value
        4) Set the viewpoint parameters as: [0, 450, 0] to position; [0, 0, -15] to focal point; [0, 0, -1] to camera up direction
        5) Visualization image resolution is 1024x1024. White background. Shade turned off. Volume rendering ray casting sample distance is 0.1
        6) Don't show color/scalar bar or coordinate axes.

        Save the visualization image as "argon-bubble/results/{agent_mode}/argon-bubble.png".
        (Optional, but must save if use paraview) Save the paraview state as "argon-bubble/results/{agent_mode}/argon-bubble.pvsm".
        (Optional, but must save if use pvpython script) Save the python script as "argon-bubble/results/{agent_mode}/argon-bubble.py".
        (Optional, but must save if use VTK) Save the cxx code script as "argon-bubble/results/{agent_mode}/argon-bubble.cxx"
        Do not save any other files, and always save the visualization image.
  assert:
    - type: llm-rubric
      subtype: vision
      value: |
          1. Does the visualization image clearly show the regions of cool, warm, and mild regions?

          2. Does the blueish region show areas with low opacity?

          3. Does the reddish region show areas with high opacity?

# Case 3: Bernard
- vars:
    question: |
        Load the Rayleigh-Benard convection vector field from "Bernard/data/Bernard_128x32x64_float32_scalar3.raw", the information about this dataset:
        Rayleigh-Benard Convection (Vector)
        Data Scalar Type: float
        Data Byte Order: Little Endian
        Data Extent: 128x32x64
        Number of Scalar Components: 3
        Data loading is very important, make sure you correctly load the dataset according to their features.

        Create four streamline sets using "Stream Tracer" filters with "Point Cloud" seed type, each with 100 seed points and radius 12.7:
        - Streamline 1: Seed center at [30.69, 14.61, 47.99]. Apply a "Tube" filter (radius 0.3, 12 sides). Color with solid blue (RGB: 0.0, 0.67, 1.0).
        - Streamline 2: Seed center at [91.10, 14.65, 45.70]. Apply a "Tube" filter (radius 0.3, 12 sides). Color with solid orange (RGB: 1.0, 0.33, 0.0).
        - Streamline 3: Seed center at [31.87, 12.76, 15.89]. Apply a "Tube" filter (radius 0.3, 12 sides). Color by velocity magnitude using the 'Cool to Warm (Diverging)' colormap.
        - Streamline 4: Seed center at [92.09, 10.50, 15.32]. Apply a "Tube" filter (radius 0.3, 12 sides). Color with solid green (RGB: 0.33, 0.67, 0.0).

        In the pipeline browser panel, hide all stream tracers and only show the tube filters.

        Use a gray-blue background (RGB: 0.329, 0.349, 0.427). Render at 1280x1280. Do not show a color bar.

        Save the visualization image as "Bernard/results/{agent_mode}/Bernard.png".
        (Optional, but must save if use paraview) Save the paraview state as "Bernard/results/{agent_mode}/Bernard.pvsm".
        (Optional, but must save if use pvpython script) Save the python script as "Bernard/results/{agent_mode}/Bernard.py".
        Do not save any other files, and always save the visualization image.
  assert:
    - type: llm-rubric
      subtype: vision
      value: |
          1. Streamline Grouping: Are there four visually separate streamline clusters arranged in a 2x2 grid pattern, similar to the ground truth?
          2. Color Assignment: Are the four streamline groups colored in distinct colors (blue, orange, magnitude-mapped, and green), matching the ground truth color scheme?
          3. Convection Cell Structure: Do the streamlines within each group show circular or helical looping patterns characteristic of convection cells?

# Case 4: bonsai
- vars:
    question: |
        Task:

        Load the bonsai dataset from "bonsai/data/bonsai_256x256x256_uint8.raw", the information about this dataset:
        Bonsai (Scalar)
        Data Scalar Type: unsigned char
        Data Byte Order: little Endian
        Data Spacing: 1x1x1
        Data Extent: 256x256x256

        Then visualize it with volume rendering, modify the transfer function and reach the visualization goal as: "A potted tree with brown pot silver branch and golden leaves."

        Please think step by step and make sure to fulfill all the visualization goals mentioned above.

        Use a white background. Render at 1280x1280. Do not show a color bar or coordinate axes.

        Save the visualization image as "bonsai/results/{agent_mode}/bonsai.png".
        (Optional, but must save if use paraview) Save the paraview state as "bonsai/results/{agent_mode}/bonsai.pvsm".
        (Optional, but must save if use pvpython script) Save the python script as "bonsai/results/{agent_mode}/bonsai.py".
        Do not save any other files, and always save the visualization image.
  assert:
    - type: llm-rubric
      subtype: vision
      value: |
          1. Overall Visualization Goal: How well does the result achieve the overall goal of showing a potted tree with the specified colors?

          2. Brown Pot Visualization: Does the result show the pot portion in brown color?

          3. Silver Branch Visualization: Does the result show the branch/trunk portion in silver color?

          4. Golden Leaves Visualization: Does the result show the leaves portion in golden color?

# Case 5: carp
- vars:
    question: |
        Task:

        Load the carp dataset from "carp/data/carp_256x256x512_uint16.raw", the information about this dataset:
        Carp (Scalar)
        Data Scalar Type: unsigned short
        Data Byte Order: little Endian
        Data Spacing: 0.78125x0.390625x1
        Data Extent: 256x256x512

        Instructions:

        1. Load the dataset into ParaView.

        2. Apply volume rendering to visualize the carp skeleton.

        3. Adjust the transfer function to highlight only the bony structures with the original bone color.

        4. Optimize the viewpoint to display the full skeleton, ensuring the head, spine, and fins are all clearly visible in a single frame.

        5. Analyze the visualization and answer the following questions:

        Q1: Which of the following options correctly describes the fins visible in the carp skeleton visualization?
        A. 5 fins: 1 dorsal, 2 pectoral, 2 pelvic
        B. 6 fins: 1 dorsal, 2 pectoral, 2 pelvic, 1 caudal
        C. 7 fins: 1 dorsal, 2 pectoral, 2 pelvic, 1 anal, 1 caudal
        D. 8 fins: 2 dorsal, 2 pectoral, 2 pelvic, 1 anal, 1 caudal

        Q2: Based on the visualization, what is the approximate ratio of skull length to total body length?
        A. ~15%
        B. ~22%
        C. ~30%
        D. ~40%

        6. Use a white background. Find an optimal view. Render at 1280x1280. Do not show a color bar or coordinate axes.

        7. Save your work:
        Save the visualization image as "carp/results/{agent_mode}/carp.png".
        Save the answers to the analysis questions in plain text as "carp/results/{agent_mode}/answers.txt".
        (Optional, but must save if use paraview) Save the paraview state as "carp/results/{agent_mode}/carp.pvsm".
        (Optional, but must save if use pvpython script) Save the python script as "carp/results/{agent_mode}/carp.py".
        (Optional, but must save if use VTK) Save the cxx code script as "carp/results/{agent_mode}/carp.cxx"
        Do not save any other files, and always save the visualization image and the text file.
  assert:
    - type: llm-rubric
      subtype: vision
      value: |
        1. Overall Visualization Goal: Does the result match the ground truth visualization of the carp skeleton?

        2. Bone Visibility: Are the bones clearly visible, similar to the ground truth? Are thin fin rays distinguishable?

        3. Skeletal Structure: Is the entire carp skeleton (head, spine, ribs, fins, tail) visible and similar in appearance to the ground truth?
    - type: llm-rubric
      subtype: text
      value: |
          1. Q1 correct answer: C. 7 fins: 1 dorsal, 2 pectoral, 2 pelvic, 1 anal, 1 caudal

          2. Q2 correct answer: B. ~22%

# Case 6: chameleon_isosurface
- vars:
    question: |
        Task:
        Load the chameleon dataset from "chameleon_isosurface/data/chameleon_isosurface_256x256x256_float32.vtk".
        Generate a visualization image of 2 isosurfaces of the Chameleon scalar field dataset with the following visualization settings:
        1) Create isosurfaces of Iso_1 with a value of 0.12 and Iso_2 with a value of 0.45
        2) Assign RGB color of [0.0, 1.0, 0.0] to Iso_1, and color of [1.0, 1.0, 1.0] to Iso_2
        3) Assign opacity of 0.1 to Iso_1, and opacity of 0.99 to Iso_2
        4) Set the lighting parameter as: 0.1 to Ambient; 0.7 to Diffuse; 0.6 to Specular
        5) Set the viewpoint parameters as: [600, 0, 0] to position; [0, 0, 0] to focal point; [0, -1, 0] to camera up direction
        6) White background
        7) Visualization image resolution is 1024x1024
        8) Don't show color/scalar bar or coordinate axes.

        Save the visualization image as "chameleon_isosurface/results/{agent_mode}/chameleon_isosurface.png".
        (Optional, but must save if use paraview) Save the paraview state as "chameleon_isosurface/results/{agent_mode}/chameleon_isosurface.pvsm".
        (Optional, but must save if use pvpython script) Save the python script as "chameleon_isosurface/results/{agent_mode}/chameleon_isosurface.py".
        (Optional, but must save if use VTK) Save the cxx code script as "chameleon_isosurface/results/{agent_mode}/chameleon_isosurface.cxx"
        Do not save any other files, and always save the visualization image.
  assert:
    - type: llm-rubric
      subtype: vision
      value: |
          1. Does the result present 2 isosurfaces, one showing the inner part of the chameleon and one showing the outer part of the chameleon?

          2. Is the skin of the Chameleon object of green color?

          3. Is the bone of the Chameleon object of white color?

# Case 7: crayfish_streamline
- vars:
    question: |
        Load the Crayfish flow vector field from "crayfish_streamline/data/crayfish_streamline_322x162x119_float32_scalar3.raw", the information about this dataset:
        Crayfish Flow (Vector)
        Data Scalar Type: float
        Data Byte Order: Little Endian
        Data Extent: 322x162x119
        Number of Scalar Components: 3
        Data loading is very important, make sure you correctly load the dataset according to their features.

        Create two streamline sets using "Stream Tracer" filters with "Point Cloud" seed type, each with 100 seed points and radius 32.2:
        - Streamline 1: Seed center at [107.33, 81.0, 59.5]. Apply a "Tube" filter (radius 0.5, 12 sides). Color by Vorticity magnitude using a diverging colormap with the following RGB control points:
          - Value 0.0 -> RGB(0.231, 0.298, 0.753) (blue)
          - Value 0.02 -> RGB(0.865, 0.865, 0.865) (white)
          - Value 0.15 -> RGB(0.706, 0.016, 0.149) (red)
        - Streamline 2: Seed center at [214.67, 81.0, 59.5]. Apply a "Tube" filter (radius 0.5, 12 sides). Color by Vorticity magnitude using the same colormap.

        Show the dataset bounding box as an outline (black).

        In the pipeline browser panel, hide all stream tracers and only show the tube filters and the outline.

        Use a white background. Render at 1280x1280.

        Save the paraview state as "crayfish_streamline/results/{agent_mode}/crayfish_streamline.pvsm".
        Save the visualization image as "crayfish_streamline/results/{agent_mode}/crayfish_streamline.png".
        (Optional, if use python script) Save the python script as "crayfish_streamline/results/{agent_mode}/crayfish_streamline.py".
        Do not save any other files, and always save the visualization image.
  assert:
    - type: llm-rubric
      subtype: vision
      value: |
          1. Overall Visualization Goal: Does the result show streamline tubes colored by vorticity magnitude within a rectangular bounding box, similar to the ground truth?
          2. Streamline Clusters: Are there two distinct clusters matches the ground truth layout?
          3. Color Mapping: Are the tubes colored by vorticity magnitude using a blue-white-red diverging colormap, with a similar distribution as the ground truth?

# Case 8: engine
- vars:
    question: |
        Task:

        Load the vortex dataset from "engine/data/engine_256x256x128_uint8.raw", the information about this dataset:
        engine (Scalar)
        Data Scalar Type: float
        Data Byte Order: little Endian
        Data Extent: 256x256x128
        Number of Scalar Components: 1

        Instructions:

        1. Load the dataset into ParaView.

        2. Apply the volume rendering to visualize the engine dataset

        3. Adjust the transfer function, let the outer part more transparent and the inner part more solid. Use light blue for the outer part and orange for the inner part.

        4. Use a white background. Find an optimal view. Render at 1280x1280. Do not show a color bar or coordinate axes.

        5. Save your work:
        Save the visualization image as "engine/results/{agent_mode}/engine.png".
        (Optional, but must save if use paraview) Save the paraview state as "engine/results/{agent_mode}/engine.pvsm".
        (Optional, but must save if use pvpython script) Save the python script as "engine/results/{agent_mode}/engine.py".
        (Optional, but must save if use VTK) Save the cxx code script as "engine/results/{agent_mode}/engine.cxx"
        Do not save any other files, and always save the visualization image.
  assert:
    - type: llm-rubric
      subtype: vision
      value: |
          1. Overall Visualization Goal: How well does the result use volume rendering to clearly present the internal and external structures of the engine dataset?

          2. Structural Clarity: Does the visualization emphasize depth so that the outer layers do not obscure the inner structures?

          3. Transfer Function Transparency: Is the outer region rendered with higher transparency and the inner region more solid, achieving a clear layering effect?

          4. Transfer Function Color Mapping: Are colors correctly assigned so that the outer part is light blue and the inner part is orange, enhancing structural contrast?

# Case 9: foot
- vars:
    question: |
        Task:

        Load the Foot dataset from "foot/data/foot_256x256x256_uint8.raw", the information about this dataset:
        Foot
        Description: Rotational C-arm x-ray scan of a human foot. Tissue and bone are present in the dataset.
        Data Type: uint8
        Data Byte Order: little Endian
        Data Spacing: 1x1x1
        Data Extent: 256x256x256
        Data loading is very important, make sure you correctly load the dataset according to their features.

        Visualize the anatomical structures:
        1. Apply volume rendering with an X-ray transfer function that distinguishes soft tissues and bones. Bones with darker color, and soft tissue with lighter color.

        2. Analyze the visualization and answer the following questions:

        Q1: Based on the X-ray style volume rendering of the foot dataset, which of the following best describes the visibility of bony structures?
        A. Both the phalanges and metatarsals are fully visible
        B. The phalanges are fully visible, but the metatarsals are only partially visible
        C. The metatarsals are fully visible, but the phalanges are only partially visible
        D. Neither the phalanges nor the metatarsals are clearly visible

        3. Use a white background. Find an optimal view. Render at 1280x1280. Do not show a color bar or coordinate axes.

        4. Save your work:
        Save the visualization image as "foot/results/{agent_mode}/foot.png".
        Save the answers to the analysis questions in plain text as "foot/results/{agent_mode}/answers.txt".
        (Optional, but must save if use paraview) Save the paraview state as "foot/results/{agent_mode}/foot.pvsm".
        (Optional, but must save if use pvpython script) Save the python script as "foot/results/{agent_mode}/foot.py".
        (Optional, but must save if use VTK) Save the cxx code script as "foot/results/{agent_mode}/foot.cxx"
        Do not save any other files, and always save the visualization image and the text file.
  assert:
    - type: llm-rubric
      subtype: vision
      value: |
          1. Overall Goal: Does the visualization effectively distinguish between different tissue types in the foot dataset?

          2. X-ray Appearance: Does the visualization resemble an X-ray (monochrome or grayscale, transparent look, consistent lighting)?
    - type: llm-rubric
      subtype: text
      value: |
          1. Q1 correct answer: B. The phalanges are fully visible, but the metatarsals are only partially visible

# Case 10: lobster
- vars:
    question: |
        Task:

        Load the Lobster dataset from "lobster/data/lobster_301x324x56_uint8.raw", the information about this dataset:
        Lobster
        Description: CT scan of a lobster contained in a block of resin.
        Data Type: uint8
        Data Byte Order: little Endian
        Data Spacing: 1x1x1.4
        Data Extent: 301x324x56
        Data loading is very important, make sure you correctly load the dataset according to their features.

        Visualize the scanned specimen:
        1. Create an isosurface at the specimen boundary, find a proper isovalue to show the whole structure.

        2. Use natural colors appropriate for the specimen (red-orange for lobster)

        3. Analyze the visualization and answer the following questions:

        Q1: Based on the isosurface visualization of the lobster specimen, how many walking legs are visible?
        A. 6 walking legs
        B. 7 walking legs
        C. 8 walking legs
        D. 10 walking legs

        4. Use a white background. Find an optimal view. Render at 1280x1280. Do not show a color bar or coordinate axes.

        5. Save your work:
        Save the visualization image as "lobster/results/{agent_mode}/lobster.png".
        Save the answers to the analysis questions in plain text as "lobster/results/{agent_mode}/answers.txt".
        (Optional, but must save if use paraview) Save the paraview state as "lobster/results/{agent_mode}/lobster.pvsm".
        (Optional, but must save if use pvpython script) Save the python script as "lobster/results/{agent_mode}/lobster.py".
        (Optional, but must save if use VTK) Save the cxx code script as "lobster/results/{agent_mode}/lobster.cxx"
        Do not save any other files, and always save the visualization image and the text file.
  assert:
    - type: llm-rubric
      subtype: vision
      value: |
          1. Overall Goal: Does the visualization clearly show the structure and details of the Lobster?

          2. Boundary Clearity: Are surface details and boundaries of the lobster well-defined?

          3. Correct Color: Is the color of the lobster mimic a real one? (red-orange)
    - type: llm-rubric
      subtype: text
      value: |
          1. Q1 correct answer: B. 7 walking legs

# Case 11: mhd-magfield_streamribbon
- vars:
    question: |
        Load the MHD magnetic field dataset from "mhd-magfield_streamribbon/data/mhd-magfield_streamribbon.vti" (VTI format, 128x128x128 grid with components bx, by, bz).
        Generate a stream ribbon seeded from a line source along the y-axis at x=64, z=64 (from y=20 to y=108), with 30 seed points.
        The stream ribbon should be traced along the magnetic field lines.
        Color the stream ribbon by magnetic field magnitude using the 'Cool to Warm' colormap. Enable surface lighting with specular reflection for better 3D perception.
        Add a color bar labeled 'Magnetic Field Magnitude'.
        Use a white background. Set an isometric camera view. Render at 1024x1024 resolution.
        Save the visualization image as "mhd-magfield_streamribbon/results/{agent_mode}/mhd-magfield_streamribbon.png".
        (Optional, but must save if use paraview) Save the paraview state as "mhd-magfield_streamribbon/results/{agent_mode}/mhd-magfield_streamribbon.pvsm".
        (Optional, but must save if use pvpython script) Save the python script as "mhd-magfield_streamribbon/results/{agent_mode}/mhd-magfield_streamribbon.py".
        (Optional, but must save if use VTK) Save the cxx code script as "mhd-magfield_streamribbon/results/{agent_mode}/mhd-magfield_streamribbon.cxx"
        Do not save any other files, and always save the visualization image.
  assert:
    - type: llm-rubric
      subtype: vision
      value: |
          1. Overall Visualization Goal: Does the result match the ground truth stream ribbon visualization of the MHD magnetic field?

          2. Surface Patterns: Does the stream ribbon show similar flow patterns and structures as the ground truth?

          3. Surface Coverage: Is the spatial extent and shape of the stream ribbon similar to the ground truth?

          4. Color Mapping: Is the color distribution across the surface visually similar to the ground truth?

# Case 12: mhd-turbulence_pathline
- vars:
    question: |
        Load the MHD turbulence velocity field time series "mhd-turbulence_pathline/data/mhd-turbulence_pathline_{timestep}.vti", where "timestep" in {0000, 0010, 0020, 0030, 0040} (5 timesteps, VTI format, 128x128x128 grid each).
        Compute true pathlines by tracking particles through the time-varying velocity field using the ParticlePath filter. Apply TemporalShiftScale (scale=20) and TemporalInterpolator (interval=0.5) to extend particle travel and smooth trajectories.
        Seed 26 points along a line on the z-axis at x=64, y=64 (from z=20 to z=108). Use static seeds with termination time 80.
        Render pathlines as tubes with radius 0.3. Color by velocity magnitude using the 'Viridis (matplotlib)' colormap.
        Add a color bar for velocity magnitude. Use a white background. Set an isometric camera view. Render at 1024x1024.
        Save the visualization image as "mhd-turbulence_pathline/results/{agent_mode}/mhd-turbulence_pathline.png".
        (Optional, but must save if use paraview) Save the paraview state as "mhd-turbulence_pathline/results/{agent_mode}/mhd-turbulence_pathline.pvsm".
        (Optional, but must save if use pvpython script) Save the python script as "mhd-turbulence_pathline/results/{agent_mode}/mhd-turbulence_pathline.py".
        (Optional, but must save if use VTK) Save the cxx code script as "mhd-turbulence_pathline/results/{agent_mode}/mhd-turbulence_pathline.cxx"
        Do not save any other files, and always save the visualization image.
  assert:
    - type: llm-rubric
      subtype: vision
      value: |
          1. Overall Visualization Goal: Does the result match the ground truth pathline visualization of the MHD turbulence velocity field?

          2. Pathline Patterns: Do the pathlines show similar particle trajectories and flow structures as the ground truth?

          3. Pathline Coverage: Is the spatial extent and distribution of pathlines similar to the ground truth?

          4. Color Mapping: Is the color distribution along pathlines visually similar to the ground truth?

# Case 13: mhd-turbulence_pathribbon
- vars:
    question: |
        Load the MHD turbulence velocity field time series "mhd-turbulence_pathribbon/data/mhd-turbulence_pathribbon_{timestep}.vti", where "timestep" in {0000, 0010, 0020, 0030, 0040} (5 timesteps, VTI format, 128x128x128 grid each).
        Compute true pathlines by tracking particles through the time-varying velocity field using the ParticlePath filter. Apply TemporalShiftScale (scale=20) and TemporalInterpolator (interval=0.1) for dense, smooth trajectories.
        Seed 26 points along a line on the z-axis at x=64, y=64 (from z=20 to z=108). Use static seeds with termination time 80.
        Create ribbon surfaces from the pathlines using the Ribbon filter with width 1.5 and a fixed default normal to prevent twisting. Apply Smooth filter (500 iterations) and generate surface normals for smooth shading.
        Set surface opacity to 0.85. Color by velocity magnitude using the 'Cool to Warm' colormap (range 0.1-0.8). Add specular highlights (0.5).
        Add a color bar for velocity magnitude. Use a white background. Set an isometric camera view. Render at 1024x1024.
        Save the visualization image as "mhd-turbulence_pathribbon/results/{agent_mode}/mhd-turbulence_pathribbon.png".
        (Optional, but must save if use paraview) Save the paraview state as "mhd-turbulence_pathribbon/results/{agent_mode}/mhd-turbulence_pathribbon.pvsm".
        (Optional, but must save if use pvpython script) Save the python script as "mhd-turbulence_pathribbon/results/{agent_mode}/mhd-turbulence_pathribbon.py".
        (Optional, but must save if use VTK) Save the cxx code script as "mhd-turbulence_pathribbon/results/{agent_mode}/mhd-turbulence_pathribbon.cxx"
        Do not save any other files, and always save the visualization image.
  assert:
    - type: llm-rubric
      subtype: vision
      value: |
          1. Surface Patterns: Does the path ribbon show similar flow patterns and structures as the ground truth?

          2. Surface Coverage: Is the spatial extent and shape of the path ribbon similar to the ground truth?

          3. Color Mapping: Is the color distribution across the surface visually similar to the ground truth?

# Case 14: mhd-turbulence_streamline
- vars:
    question: |
        Load the MHD turbulence velocity field dataset "mhd-turbulence_streamline/data/mhd-turbulence_streamline.vti" (VTI format, 128x128x128 grid).
        Generate 3D streamlines seeded from a line source along the z-axis at x=64, y=64 (from z=0 to z=127), with 50 seed points.
        Color the streamlines by velocity magnitude using the 'Turbo' colormap. Set streamline tube radius to 0.3 using the Tube filter.
        Add a color bar labeled 'Velocity Magnitude'. Use a white background. Set an isometric camera view. Render at 1024x1024.
        Save the visualization image as "mhd-turbulence_streamline/results/{agent_mode}/mhd-turbulence_streamline.png".
        (Optional, but must save if use paraview) Save the paraview state as "mhd-turbulence_streamline/results/{agent_mode}/mhd-turbulence_streamline.pvsm".
        (Optional, but must save if use pvpython script) Save the python script as "mhd-turbulence_streamline/results/{agent_mode}/mhd-turbulence_streamline.py".
        (Optional, but must save if use VTK) Save the cxx code script as "mhd-turbulence_streamline/results/{agent_mode}/mhd-turbulence_streamline.cxx"
        Do not save any other files, and always save the visualization image.
  assert:
    - type: llm-rubric
      subtype: vision
      value: |
          1. Overall Visualization Goal: Does the result match the ground truth streamline visualization of the MHD turbulence velocity field?

          2. Streamline Patterns: Do the streamlines show similar flow patterns and structures as the ground truth?

          3. Streamline Coverage: Is the spatial distribution and density of streamlines similar to the ground truth?

          4. Color Mapping: Is the color distribution along streamlines visually similar to the ground truth?

# Case 15: miranda
- vars:
    question: |
        Task:
        Load the Rayleigh-Taylor Instability dataset from "miranda/data/miranda_256x256x256_float32.vtk".
        Generate a visualization image of the Rayleigh-Taylor Instability dataset, a time step of a density field in a simulation of the mixing transition in Rayleigh-Taylor instability, with the following visualization settings:
        1) Create volume rendering
        2) Set the opacity transfer function as a ramp function from value 0 to 1 of the volumetric data, assigning opacity 0 to value 0 and assigning opacity 1 to value 1.
        3) Set the color transfer function following the 7 rainbow colors and assign a red color [1.0, 0.0, 0.0] to the highest value, a purple color [0.5, 0.0, 1.0] to the lowest value.
        4) Set the viewpoint parameters as: [650, 650, 650] to position; [128, 128, 128] to focal point; [1, 0, 0] to camera up direction
        5) Volume rendering ray casting sample distance is 0.1
        6) White background
        7) Visualization image resolution is 1024x1024
        8) Don't show color/scalar bar or coordinate axes.
        Save the visualization image as "miranda/results/{agent_mode}/miranda.png".
        (Optional, but must save if use paraview) Save the paraview state as "miranda/results/{agent_mode}/miranda.pvsm".
        (Optional, but must save if use pvpython script) Save the python script as "miranda/results/{agent_mode}/miranda.py".
        (Optional, but must save if use VTK) Save the cxx code script as "miranda/results/{agent_mode}/miranda.cxx"
        Do not save any other files, and always save the visualization image.
  assert:
    - type: llm-rubric
      subtype: vision
      value: |
          1. Does the visualization image clearly show the regions from low to high intensity?

          2. Does the purple region show areas with low opacity?

          3. Does the red region show areas with high opacity?

# Case 16: richtmyer
- vars:
    question: |
        Task:
        Load the Richtmyer dataset from "richtmyer/data/richtmyer_256x256x240_float32.vtk".
        Generate a visualization image of the Richtmyer dataset, Entropy field (timestep 160) of Richtmyer-Meshkov instability simulation, with the following visualization settings:
        1) Create volume rendering
        2) Set the opacity transfer function as a ramp function from value 0.05 to 1 of the volumetric data, assigning opacity 0 to value less than 0.05 and assigning opacity 1 to value 1.
        3) Set the color transfer function following the 7 rainbow colors and assign a red color [1.0, 0.0, 0.0] to the highest value, a purple color [0.5, 0.0, 1.0] to the lowest value.
        4) Visualization image resolution is 1024x1024
        5) Set the viewpoint parameters as: [420, 420, -550] to position; [128, 128, 150] to focal point; [-1, -1, 1] to camera up direction
        6) Turn on the shade and set the ambient, diffuse and specular as 1.0
        7) White background. Volume rendering ray casting sample distance is 0.1
        8) Don't show color/scalar bar or coordinate axes.
        Save the visualization image as "richtmyer/results/{agent_mode}/richtmyer.png".
        (Optional, but must save if use paraview) Save the paraview state as "richtmyer/results/{agent_mode}/richtmyer.pvsm".
        (Optional, but must save if use pvpython script) Save the python script as "richtmyer/results/{agent_mode}/richtmyer.py".
        (Optional, but must save if use VTK) Save the cxx code script as "richtmyer/results/{agent_mode}/richtmyer.cxx"
        Do not save any other files, and always save the visualization image.
  assert:
    - type: llm-rubric
      subtype: vision
      value: |
          1. Does the visualization show a clear surface with peaks and valleys?

          2. Are the peaks highlighted with the reddish color?

          3. Are the valleys highlighted with the bluish color?

# Case 17: rotstrat
- vars:
    question: |
        Task:
        Load the rotstrat dataset from "rotstrat/data/rotstrat_256x256x256_float32.vtk".
        Generate a visualization image of the Rotstrat dataset, temperature field of a direct numerical simulation of rotating stratified turbulence, with the following visualization settings:
        1) Create volume rendering
        2) Set the opacity transfer function as a step function jumping from 0 to 1 at value 0.12
        3) Set the color transfer function to assign a warm red color [0.71, 0.02, 0.15] to the highest value, a cool color [0.23, 0.29, 0.75] to the lowest value, and a grey color[0.87, 0.87, 0.87] to the midrange value
        4) Set the viewpoint parameters as: [800, 128, 128] to position; [0, 128, 128] to focal point; [0, 1, 0] to camera up direction
        5) Volume rendering ray casting sample distance is 0.1
        6) White background
        7) Visualization image resolution is 1024x1024
        8) Don't show color/scalar bar or coordinate axes.
        Save the visualization image as "rotstrat/results/{agent_mode}/rotstrat.png".
        (Optional, but must save if use paraview) Save the paraview state as "rotstrat/results/{agent_mode}/rotstrat.pvsm".
        (Optional, but must save if use pvpython script) Save the python script as "rotstrat/results/{agent_mode}/rotstrat.py".
        (Optional, but must save if use VTK) Save the cxx code script as "rotstrat/results/{agent_mode}/rotstrat.cxx"
        Do not save any other files, and always save the visualization image.
  assert:
    - type: llm-rubric
      subtype: vision
      value: |
          1. Does the visualization image clearly show the shape of turbulence compared to ground truth?

          2. Does the visualization show the shape of a vortex in the upper right part of the image?

          3. Does the visualization show the shape of a vortex in the bottom left corner of the image?

# Case 18: rti-velocity_glyph
- vars:
    question: |
        Load the Rayleigh-Taylor instability velocity field dataset from "rti-velocity_glyph/data/rti-velocity_glyph.vti" (VTI format, 128x128x128 grid).
        Create a slice at y=64 through the volume.
        Place arrow glyphs on the slice, oriented by the velocity vector. Use uniform arrow size (no magnitude scaling, scale factor 3.0).
        Color the arrows by velocity magnitude using the 'Viridis (matplotlib)' colormap. Use a sampling stride of 3.
        Add a color bar labeled 'Velocity Magnitude'.
        Use a white background. Set the camera to view along the negative y-axis. Render at 1024x1024.
        Save the visualization image as "rti-velocity_glyph/results/{agent_mode}/rti-velocity_glyph.png".
        (Optional, but must save if use paraview) Save the paraview state as "rti-velocity_glyph/results/{agent_mode}/rti-velocity_glyph.pvsm".
        (Optional, but must save if use pvpython script) Save the python script as "rti-velocity_glyph/results/{agent_mode}/rti-velocity_glyph.py".
        (Optional, but must save if use VTK) Save the cxx code script as "rti-velocity_glyph/results/{agent_mode}/rti-velocity_glyph.cxx"
        Do not save any other files, and always save the visualization image.
  assert:
    - type: llm-rubric
      subtype: vision
      value: |
          1. Overall Visualization Goal: Does the result match the ground truth glyph visualization of the RTI velocity field?

          2. Glyph Patterns: Do the arrow glyphs show similar orientation and spatial patterns as the ground truth?

          3. Glyph Appearance: Do the glyphs appear with similar uniform sizing as the ground truth?

          4. Color Mapping: Is the color distribution across glyphs visually similar to the ground truth?

# Case 19: rti-velocity_slices
- vars:
    question: |
        Load the Rayleigh-Taylor instability velocity field from "rti-velocity_slices/data/rti-velocity_slices.vti" (VTI format, 128x128x128).
        Create three orthogonal slices: at x=64 (YZ-plane), y=64 (XZ-plane), and z=64 (XY-plane).
        Color all three slices by velocity magnitude using the 'Turbo' colormap.
        Add a color bar labeled 'Velocity Magnitude'.
        Use a white background. Set an isometric camera view that shows all three slices. Render at 1024x1024.
        Save the visualization image as "rti-velocity_slices/results/{agent_mode}/rti-velocity_slices.png".
        (Optional, but must save if use paraview) Save the paraview state as "rti-velocity_slices/results/{agent_mode}/rti-velocity_slices.pvsm".
        (Optional, but must save if use pvpython script) Save the python script as "rti-velocity_slices/results/{agent_mode}/rti-velocity_slices.py".
        (Optional, but must save if use VTK) Save the cxx code script as "rti-velocity_slices/results/{agent_mode}/rti-velocity_slices.cxx"
        Do not save any other files, and always save the visualization image.
  assert:
    - type: llm-rubric
      subtype: vision
      value: |
          1. Slice Count and Orientation: Are there exactly three perpendicular slices (one horizontal XY-plane and two vertical XZ and YZ planes), matching the ground truth arrangement?
          2. Color Mapping: Are the slices colored using a Turbo-like colormap (blue to green to yellow to red) mapped to velocity magnitude, with a similar color distribution as the ground truth?
          3. Mixing Zone Pattern: Does the horizontal (XY) slice show a chaotic, high-velocity-magnitude mixing pattern in its center region, similar to the ground truth?

# Case 20: rti-velocity_streakline
- vars:
    question: |
        Load the Rayleigh–Taylor instability velocity field time series from "rti-velocity_streakline/data/rti-velocity_streakline_{timestep}.nc", where "timestep" in {0030, 0031, 0032, 0033, 0034, 0035, 0036, 0037, 0038, 0039, 0040} (11 timesteps, NetCDF format, 128×128×128 grid each, with separate vx, vy, vz arrays).
        Construct the time-varying velocity field u(x,t) by merging vx, vy, vz into a single vector field named "velocity", and compute the velocity magnitude "magnitude" = |velocity| for coloring.
        Compute streaklines as a discrete approximation of continuous particle injection: continuously release particles from fixed seed points at every sub-timestep into the time-varying velocity field using the StreakLine filter. Apply TemporalShiftScale (scale=20) to extend particle travel time, and apply TemporalInterpolator with a sub-timestep interval of 0.25 (or smaller) to approximate continuous injection over time.
        Seed 26 static points along a line on the z-axis at x=64, y=64 (from z=20 to z=108). Use StaticSeeds=True, ForceReinjectionEveryNSteps=1 (reinjection at every sub-timestep), and set TerminationTime=200.
        Render the resulting streaklines as tubes with radius 0.3. Color the tubes by velocity magnitude ("magnitude") using the 'Cool to Warm (Extended)' colormap. Add a color bar for velocity magnitude.
        Use a white background. Set an isometric camera view and render at 1024×1024.
        Save the visualization image as "rti-velocity_streakline/results/{agent_mode}/rti-velocity_streakline.png".
        (Optional, but must save if use paraview) Save the paraview state as "rti-velocity_streakline/results/{agent_mode}/rti-velocity_streakline.pvsm".
        (Optional, but must save if use pvpython script) Save the python script as "rti-velocity_streakline/results/{agent_mode}/rti-velocity_streakline.py".
        (Optional, but must save if use VTK) Save the cxx code script as "rti-velocity_streakline/results/{agent_mode}/rti-velocity_streakline.cxx"
        Do not save any other files, and always save the visualization image.
  assert:
    - type: llm-rubric
      subtype: vision
      value: |
          1. Streak Line Patterns: Do the streak lines show similar flow patterns and structures as the ground truth?

          2. Streak Line Coverage: Is the spatial extent and distribution of streak lines similar to the ground truth?

          3. Color Mapping: Is the color distribution along streak lines visually similar to the ground truth?

# Case 21: solar-plume
- vars:
    question: |
        Task:

        Load the tornado dataset from "solar-plume/data/solar-plume_126x126x512_float32_scalar3.raw", the information about this dataset:
        solar-plume (Vector)
        Data Scalar Type: float
        Data Byte Order: little Endian
        Data Extent: 126x126x512
        Number of Scalar Components: 3
        Data loading is very important, make sure you correctly load the dataset according to their features.

        Add a "stream tracer" filter under the tornado data to display streamline, set the "Seed type" to "Point Cloud" and set the center of point cloud to 3D position [50, 50, 320] with a radius 30, then hide the point cloud sphere.

        Add a "tube" filter under the "stream tracer" filter to enhance the streamline visualization. Set the radius to 0.5. In the pipeline browser panel, hide everything except the "tube" filter.


        Please think step by step and make sure to fulfill all the visualization goals mentioned above.

        Use a white background. Find an optimal view. Render at 1280x1280. Do not show a color bar or coordinate axes.

        Save the visualization image as "solar-plume/results/{agent_mode}/solar-plume.png".
        (Optional, but must save if use paraview) Save the paraview state as "solar-plume/results/{agent_mode}/solar-plume.pvsm".
        (Optional, but must save if use pvpython script) Save the python script as "solar-plume/results/{agent_mode}/solar-plume.py".
        (Optional, but must save if use VTK) Save the cxx code script as "solar-plume/results/{agent_mode}/solar-plume.cxx"
        Do not save any other files, and always save the visualization image.
  assert:
    - type: llm-rubric
      subtype: vision
      value: |
          1. Overall Visualization Goal: Does the result match the ground truth streamline visualization of solar-plume flow structures?

          2. Streamline Patterns: Do the streamlines show similar flow patterns and structures as the ground truth, particularly in the plume region?

          3. Streamline Coverage: Is the spatial distribution and density of streamlines similar to the ground truth?

          4. Visual Appearance: Do the streamline tubes appear similar in thickness and visibility to the ground truth?

# Case 22: supernova_isosurface
- vars:
    question: |
        Task:

        Load the supernova dataset from "supernova_isosurface/data/supernova_isosurface_256x256x256_float32.raw", the information about this dataset:
        supernova (Scalar)
        Data Scalar Type: float
        Data Byte Order: little Endian
        Data Spacing: 1x1x1
        Data Extent: 256x256x256
        Data loading is very important, make sure you correctly load the dataset according to their features.

        Then visualize it and extract two isosurfaces. One of them use color red, showing areas with low density (isovalue 40 and opacity 0.2), while the other use color light blue, showing areas with high density (isovalue 150 and opacity 0.4).

        Please think step by step and make sure to fulfill all the visualization goals mentioned above. Only make the two isosurfaces visible.

        Use a white background. Find an optimal view. Render at 1280x1280. Do not show a color bar or coordinate axes.

        Save the visualization image as "supernova_isosurface/results/{agent_mode}/supernova_isosurface.png".
        (Optional, but must save if use paraview) Save the paraview state as "supernova_isosurface/results/{agent_mode}/supernova_isosurface.pvsm".
        (Optional, but must save if use pvpython script) Save the python script as "supernova_isosurface/results/{agent_mode}/supernova_isosurface.py".
        (Optional, but must save if use VTK) Save the cxx code script as "supernova_isosurface/results/{agent_mode}/supernova_isosurface.cxx"
        Do not save any other files, and always save the visualization image.
  assert:
    - type: llm-rubric
      subtype: vision
      value: |
          1. Overall Visualization Goal: How well does the result achieve the overall goal of showing the supernova structure with two distinct isosurfaces representing different density regions?

          2. Does the red isosurface show low density areas (outside regions) with lower opacity?

          3. Does the blue isosurface show high density areas (inside regions) with higher opacity?

# Case 23: supernova_streamline
- vars:
    question: |
        Load the Supernova velocity vector field from "supernova_streamline/data/supernova_streamline_100x100x100_float32_scalar3.raw", the information about this dataset:
        Supernova Velocity (Vector)
        Data Scalar Type: float
        Data Byte Order: Little Endian
        Data Extent: 100x100x100
        Number of Scalar Components: 3
        Data loading is very important, make sure you correctly load the dataset according to their features.

        Create streamlines using a "Stream Tracer" filter with "Point Cloud" seed type. Set the seed center to [50, 50, 50], with 200 seed points and a radius of 45.0. Set maximum streamline length to 100.0.

        Add a "Tube" filter on the stream tracer. Set tube radius to 0.3 with 12 sides.

        Color the tubes by Vorticity magnitude using a diverging colormap with the following RGB control points:
        - Value 0.0 -> RGB(0.231, 0.298, 0.753) (blue)
        - Value 0.05 -> RGB(0.865, 0.865, 0.865) (white)
        - Value 0.5 -> RGB(0.706, 0.016, 0.149) (red)

        Show the dataset bounding box as an outline (black).

        In the pipeline browser panel, hide the stream tracer and only show the tube filter and the outline.

        Use a white background. Render at 1280x1280.

        Save the visualization image as "supernova_streamline/results/{agent_mode}/supernova_streamline.png".
        (Optional, but must save if use paraview) Save the paraview state as "supernova_streamline/results/{agent_mode}/supernova_streamline.pvsm".
        (Optional, but must save if use pvpython script) Save the python script as "supernova_streamline/results/{agent_mode}/supernova_streamline.py".
        (Optional, but must save if use VTK) Save the cxx code script as "supernova_streamline/results/{agent_mode}/supernova_streamline.cxx"
        Do not save any other files, and always save the visualization image.
  assert:
    - type: llm-rubric
      subtype: vision
      value: |
          1. Central Structure: Is there a dense, chaotic cluster of streamlines near the center of the volume, matching the ground truth?
          2. Radial Extensions: Are there long, straight streamline tubes extending radially outward from the central region, similar to the ground truth?
          3. Color Mapping: Are the tubes colored by vorticity magnitude using a blue-white-red diverging colormap, with warm colors concentrated near the center and cool colors on the extended lines?

# Case 24: tangaroa_streamribbon
- vars:
    question: |
        Task:

        Load the tangaroa dataset from "tangaroa_streamribbon_300x180x120_float32_scalar3.raw", the information about this dataset:
        tangaroa (Vector)
        Data Scalar Type: float
        Data Byte Order: little Endian
        Data Extent: 300x180x120
        Number of Scalar Components: 3
        Data loading is very important, make sure you correctly load the dataset according to their features.

        Apply "streamline tracer" filter, set the "Seed Type" to point cloud, turn off the "show sphere", set the center to [81.6814, 80.708, 23.5093], and radius to 29.9

        Add "Ribbon" filter to the streamline tracer results and set width to 0.3, set the Display representation to Surface.

        In pipeline browser panel, hide everything except the ribbon filter results.

        Please think step by step and make sure to fulfill all the visualization goals mentioned above.

        Use a white background. Find an optimal view. Render at 1280x1280. Do not show a color bar or coordinate axes.

        Save the visualization image as "tangaroa_streamribbon/results/{agent_mode}/tangaroa_streamribbon.png".
        (Optional, but must save if use paraview) Save the paraview state as "tangaroa_streamribbon/results/{agent_mode}/tangaroa_streamribbon.pvsm".
        (Optional, but must save if use pvpython script) Save the python script as "tangaroa_streamribbon/results/{agent_mode}/tangaroa_streamribbon.py".
        (Optional, but must save if use VTK) Save the cxx code script as "tangaroa_streamribbon/results/{agent_mode}/tangaroa_streamribbon.cxx"
        Do not save any other files, and always save the visualization image.
  assert:
    - type: llm-rubric
      subtype: vision
      value: |
          1. Overall Visualization Goal: Does the result match the ground truth visualization of tangaroa flow structures using ribbon surfaces?

          2. Flow Surface Patterns: Do the ribbon surfaces show similar flow patterns and structures as the ground truth?

          3. Surface Coverage: Is the spatial distribution and coverage of the flow surfaces similar to the ground truth?

          4. Visual Appearance: Do the ribbon surfaces appear similar in width and structure to the ground truth?

# Case 25: tgc-velocity_contour
- vars:
    question: |
        Load the turbulence-gravity-cooling velocity field dataset from "tgc-velocity_contour/data/tgc-velocity_contour.vti" (VTI format, 64x64x64).
        Extract a slice at z=32 and color it by velocity magnitude using 'Viridis (matplotlib)' colormap.
        Also add contour lines of velocity magnitude on the same slice at values [0.3, 0.6, 0.9, 1.2] using the Contour filter on the slice output.
        Display contour lines in white. Add a color bar labeled 'Velocity Magnitude'.
        Light gray background (RGB: 0.9, 0.9, 0.9). Top-down camera. Render at 1024x1024.
        Save the visualization image as "tgc-velocity_contour/results/{agent_mode}/tgc-velocity_contour.png".
        (Optional, but must save if use paraview) Save the paraview state as "tgc-velocity_contour/results/{agent_mode}/tgc-velocity_contour.pvsm".
        (Optional, but must save if use pvpython script) Save the python script as "tgc-velocity_contour/results/{agent_mode}/tgc-velocity_contour.py".
        (Optional, but must save if use VTK) Save the cxx code script as "tgc-velocity_contour/results/{agent_mode}/tgc-velocity_contour.cxx"
        Do not save any other files, and always save the visualization image.
  assert:
    - type: llm-rubric
      subtype: vision
      value: |
          1. Overall Visualization Goal: Does the result match the ground truth slice and contour visualization of the TGC velocity field?

          2. Slice Pattern: Does the colored slice show similar patterns and structures as the ground truth?

          3. Contour Lines: Are the contour lines positioned and shaped similarly to the ground truth?

          4. Color Mapping: Is the color distribution on the slice visually similar to the ground truth?

# Case 26: tornado
- vars:
    question: |
        Load the Tornado vector field from "tornado/data/tornado_64x64x64_float32_scalar3.raw", the information about this dataset:
        Tornado (Vector)
        Data Scalar Type: float
        Data Byte Order: Little Endian
        Data Extent: 64x64x64
        Number of Scalar Components: 3
        Data loading is very important, make sure you correctly load the dataset according to their features.

        Create a streamline visualization using a "Stream Tracer" filter with "Point Cloud" seed type. Set the seed center to [31.5, 31.5, 47.25], radius 12.6, and maximum streamline length to 512.0. Add a "Tube" filter (radius 0.25) on the stream tracer. Color the tubes by Velocity magnitude using the 'Cool to Warm (Diverging)' colormap. Also display the stream tracer directly with line width 5.0 and "Render Lines As Tubes" enabled.

        Add a "Glyph" filter on the original data using Arrow glyph type. Orient arrows by the Velocity vector and scale by Velocity magnitude with a scale factor of 25.0. Set maximum number of sample points to 2500. Color glyphs by Velocity magnitude using the same colormap.

        Add an "Outline" filter to display the dataset bounding box (black).

        Use a white background (RGB: 1.0, 1.0, 1.0). Find an optimal view. Render at 1280x1280. Show both color bar and coordinate axes.
        Save the visualization image as "tornado/results/{agent_mode}/tornado.png".
        (Optional, but must save if use paraview) Save the paraview state as "tornado/results/{agent_mode}/tornado.pvsm".
        (Optional, but must save if use pvpython script) Save the python script as "tornado/results/{agent_mode}/tornado.py".
        (Optional, but must save if use VTK) Save the cxx code script as "tornado/results/{agent_mode}/tornado.cxx"
        Do not save any other files, and always save the visualization image.
  assert:
    - type: llm-rubric
      subtype: vision
      value: |
          1. Vortex Structure: Is a funnel-shaped vortex core visible with streamlines spiraling around a central vertical axis, matching the ground truth?
          2. Glyph Presence: Are arrow glyphs distributed throughout the volume showing velocity direction, similar to the ground truth?
          3. Color Mapping: Are both the streamline tubes and arrow glyphs colored by velocity magnitude using a blue-to-red diverging colormap, matching the ground truth color distribution?

# Case 27: twoswirls_streamribbon
- vars:
    question: |
        Load the Two Swirls vector field from "twoswirls_streamribbon/data/twoswirls_streamribbon_64x64x64_float32_scalar3.raw", the information about this dataset:
        Two Swirls (Vector)
        Data Scalar Type: float
        Data Byte Order: Little Endian
        Data Extent: 64x64x64
        Number of Scalar Components: 3
        Data loading is very important, make sure you correctly load the dataset according to their features.

        Create two stream ribbons using "Stream Tracer" filters with "Line" seed type (resolution 25 points each), and apply a "Ribbon" filter (width 2.5) to each:
        - Stream Ribbon 1: Line seed from [16, 10, 32] to [16, 54, 32]. Ribbon colored solid green (RGB: 0.2, 0.7, 0.3) with opacity 0.35.
        - Stream Ribbon 2: Line seed from [48, 10, 32] to [48, 54, 32]. Ribbon colored solid blue (RGB: 0.2, 0.4, 0.85) with opacity 0.35.


        Show the dataset bounding box as an outline (black, opacity 0.3).

        In the pipeline browser panel, hide all stream tracers and only show the ribbon filters and the outline.

        Use a white background (RGB: 1.0, 1.0, 1.0). Find an optimal view. Render at 1280x1280. Do not show a color bar or coordinate axes.
        Save the visualization image as "twoswirls_streamribbon/results/{agent_mode}/twoswirls_streamribbon.png".
        (Optional, but must save if use paraview) Save the paraview state as "twoswirls_streamribbon/results/{agent_mode}/twoswirls_streamribbon.pvsm".
        (Optional, but must save if use pvpython script) Save the python script as "twoswirls_streamribbon/results/{agent_mode}/twoswirls_streamribbon.py".
        (Optional, but must save if use VTK) Save the cxx code script as "twoswirls_streamribbon/results/{agent_mode}/twoswirls_streamribbon.cxx"
        Do not save any other files, and always save the visualization image.
  assert:
    - type: llm-rubric
      subtype: vision
      value: |
          1. Swirl Separation: Are there two visually distinct swirl structures (one on the left and one on the right), matching the spatial arrangement in the ground truth?
          2. Stream Ribbon Shape: Do the ribbon surfaces show wrapped, swirling sheet-like structures similar to the ground truth?
          3. Color and Transparency: Are the stream ribbons rendered with distinct colors (green and blue) and semi-transparency, similar to the ground truth?

# Case 28: vortex
- vars:
    question: |
        Task:

        Load the vortex dataset from "vortex/data/vortex_128x128x128_float32.raw", the information about this dataset:
        vortex (Scalar)
        Data Scalar Type: float
        Data Byte Order: little Endian
        Data Extent: 128x128x128
        Number of Scalar Components: 1

        Instructions:

        1. Load the dataset into ParaView.

        2. Leverage "contour" filter to achieve iso-surface rendering. In pipeline browser panel, hide everything except the "contour" fileter.

        3. In properties panel of "contour" filter, set isosurface value to -0.2, use Solid Color and set the color as beige.

        4. Enable Ambient occlusion by toggle the "Use Ambient Occlusion" button in the Render Passes.

        5. Add head light with light inspector, set "Coords" as Camera, "Intentsity" to 0.2, Type to "Directional".

        6. Use a white background. Find an optimal view. Render at 1280x1280. Do not show a color bar or coordinate axes.

        7. Save your work:
        Save the visualization image as "vortex/results/{agent_mode}/vortex.png".
        (Optional, but must save if use paraview) Save the paraview state as "vortex/results/{agent_mode}/vortex.pvsm".
        (Optional, but must save if use pvpython script) Save the python script as "vortex/results/{agent_mode}/vortex.py".
        (Optional, but must save if use VTK) Save the cxx code script as "vortex/results/{agent_mode}/vortex.cxx"
        Do not save any other files, and always save the visualization image.
  assert:
    - type: llm-rubric
      subtype: vision
      value: |
          1. Overall Visualization Goal: Does the result match the ground truth isosurface rendering of the vortex scalar field?

          2. Isosurface Structure: Does the isosurface show the same vortex structure and topology as the ground truth?

          3. Surface Appearance: Does the surface color and shading appear similar to the ground truth?

          4. Visualization Clarity: Are the vortex features clearly visible and comparable to the ground truth?

# Case 29: line-plot
- vars:
    question: |
          Read the dataset in the file "line-plot/data/line-plot.ex2", and print the number of components and the range of all the variables.
          Show a default view of the dataset, colored by the variable Pres.
          Create a line plot over all the variables in the dataset, from (0,0,0) to (0,0,10).
          Write the values of the line plot in the file "line-plot/results/{agent_mode}/line-plot.csv", and save a screenshot of the line plot in "line-plot/results/{agent_mode}/line-plot.png".
          (Optional, but must save if use paraview) Save the paraview state as "line-plot/results/{agent_mode}/line-plot.pvsm".
          (Optional, but must save if use python script) Save the python script as "line-plot/results/{agent_mode}/line-plot.py".
          Do not save any other files, and always save the visualization image.

  assert:
    - type: llm-rubric
      subtype: vision
      value: |
          1. Line Visualization Quality: Are multiple distinct lines clearly visible and properly rendered showing the evolution of different variables along the specified path?

          2. Variable Differentiation: Are all dataset variables visually distinguishable through distinct colors or line styles with clear separation between curves?

          3. Axis and Scale Appropriateness: Do the plot axes display appropriate ranges and scaling that effectively show the data trends and variations?

          4. Legend and Readability: Is there a clear legend identifying each variable line with readable labels and proper visual organization?

# Case 30: ml-dvr
- vars:
    question: |
          I would like to use ParaView to visualize a dataset.
          Read in the file named "ml-dvr/data/ml-dvr.vtk".
          Generate a volume rendering using the default transfer function.
          Rotate the view to an isometric direction.
          Save a screenshot of the result in the filename "ml-dvr/results/{agent_mode}/ml-dvr.png".
          The rendered view and saved screenshot should be 1920 x 1080 pixels.
          (Optional, but must save if use paraview) Save the paraview state as "ml-dvr/results/{agent_mode}/ml-dvr.pvsm".
          (Optional, but must save if use python script) Save the python script as "ml-dvr/results/{agent_mode}/ml-dvr.py".
          Do not save any other files, and always save the visualization image.

  assert:
    - type: llm-rubric
      subtype: vision
      value: |
          1. Volume Rendering Quality: Is the volume rendering properly generated with appropriate opacity and color mapping that reveals internal structures?

          2. Transfer Function Application: Does the default transfer function effectively highlight meaningful data features and provide good visual contrast?

          3. Isometric View Setup: Is the visualization displayed from an isometric viewpoint that provides a clear three-dimensional perspective of the volume?

          4. Visual Clarity and Detail: Are the volume details clearly visible with proper lighting and shading that enhances depth perception?

# Case 31: ml-iso
- vars:
    question: |
          Read in the file named "ml-iso/data/ml-iso.vtk", and generate an isosurface of the variable var0 at value 0.5.
          Use a white background color. Save a screenshot of the result, size 1920 x 1080 pixels, in "ml-iso/results/{agent_mode}/ml-iso.png".
          (Optional, but must save if use paraview) Save the paraview state as "ml-iso/results/{agent_mode}/ml-iso.pvsm".
          (Optional, but must save if use python script) Save the python script as "ml-iso/results/{agent_mode}/ml-iso.py".
          Do not save any other files, and always save the visualization image.

  assert:
    - type: llm-rubric
      subtype: vision
      value: |
          1. Isosurface Generation: Is the isosurface properly generated at the specified value (0.5) with correct topology and continuity?

          2. Surface Rendering Quality: Does the isosurface display smooth surfaces with appropriate shading and lighting that reveals the 3D structure?

          3. Geometric Accuracy: Are the surface features geometrically correct and free from artifacts or discontinuities?

          4. Visual Presentation: Is the isosurface clearly visible with good contrast and coloring that enhances the understanding of the data structure?

# Case 32: ml-slice-iso
- vars:
    question: |
          Please generate a ParaView Python script for the following operations.
          Read in the file named "ml-slice-iso/data/ml-slice-iso.vtk".
          Slice the volume in a plane parallel to the y-z plane at x=0.
          Take a contour through the slice at the value 0.5.
          Color the contour red. Use a white background.
          Rotate the view to look at the +x direction.
          Save a screenshot of the result in the filename "ml-slice-iso/results/{agent_mode}/ml-slice-iso.png".
          The rendered view and saved screenshot should be 1920 x 1080 pixels.
          (Optional, but must save if use paraview) Save the paraview state as "ml-slice-iso/results/{agent_mode}/ml-slice-iso.pvsm".
          (Optional, but must save if use python script) Save the python script as "ml-slice-iso/results/{agent_mode}/ml-slice-iso.py".
          Do not save any other files, and always save the visualization image.

  assert:
    - type: llm-rubric
      subtype: vision
      value: |
          1. Slice Generation: Is the y-z plane slice properly generated at x=0 position showing the correct cross-section of the volume?

          2. Contour on Slice: Are the contour lines at value 0.5 correctly extracted from the slice and properly displayed?

          3. Red Color Application: Is the contour visualization properly colored red as specified in the requirements?

          4. View Direction: Is the visualization displayed from the correct +x direction view that provides clear visibility of the slice and contours?

# Case 33: points-surf-clip
- vars:
    question: |
          I would like to use ParaView to visualize a dataset.
          Read in the file named "points-surf-clip/data/points-surf-clip.ex2".
          Generate an 3d Delaunay triangulation of the dataset.
          Clip the data with a y-z plane at x=0, keeping the -x half of the data and removing the +x half.
          Render the image as a wireframe.
          Save a screenshot of the result in the filename "points-surf-clip/results/{agent_mode}/points-surf-clip.png".
          The rendered view and saved screenshot should be 1920 x 1080 pixels. Use a white background color.
          (Optional, but must save if use paraview) Save the paraview state as "points-surf-clip/results/{agent_mode}/points-surf-clip.pvsm".
          (Optional, but must save if use python script) Save the python script as "points-surf-clip/results/{agent_mode}/points-surf-clip.py".
          Do not save any other files, and always save the visualization image.

  assert:
    - type: llm-rubric
      subtype: vision
      value: |
          1. Delaunay Triangulation Quality: Is the 3D Delaunay triangulation properly generated creating a valid mesh structure from the point data?

          2. Clipping Accuracy: Is the mesh correctly clipped by the y-z plane at x=0, with only the -x half of the data remaining visible?

          3. Wireframe Representation: Is the result displayed as a clear wireframe showing the triangulated mesh structure with visible edges?

          4. Geometric Integrity: Does the clipped wireframe maintain proper connectivity and show the expected geometric features without artifacts?

# Case 34: shrink-sphere
- vars:
    question: |
          Create a default sphere and then hide it.
          Create a shrink filter from the sphere.
          Double the sphere's theta resolution.
          Divide the shrink filter's shrink factor in half.
          Extract a wireframe from the sphere.
          Group the shrink filter and wireframe together and show them.
          Save a screenshot of the result in the filename "shrink-sphere/results/{agent_mode}/shrink-sphere.png".
          The rendered view and saved screenshot should be 1920 x 1080 pixels and have a white background.
          (Optional, but must save if use paraview) Save the paraview state as "shrink-sphere/results/{agent_mode}/shrink-sphere.pvsm".
          (Optional, but must save if use python script) Save the python script as "shrink-sphere/results/{agent_mode}/shrink-sphere.py".
          Do not save any other files, and always save the visualization image.

  assert:
    - type: llm-rubric
      subtype: vision
      value: |
          1. Sphere Creation and Resolution: Is the sphere created with doubled theta resolution providing higher geometric detail and smoother curvature?

          2. Shrink Filter Application: Is the shrink filter properly applied with halved shrink factor creating visible separation between mesh elements?

          3. Dual Representation: Are both the wireframe sphere and shrink filter results simultaneously visible and properly grouped together?

          4. Visual Quality: Does the visualization clearly show the contrast between the wireframe structure and the shrunken elements with appropriate white background?

# Case 35: stream-glyph
- vars:
    question: |
          I would like to use ParaView to visualize a dataset.
          Read in the file named "stream-glyph/data/stream-glyph.ex2".
          Trace streamlines of the V data array seeded from a default point cloud.
          Render the streamlines with tubes.
          Add cone glyphs to the streamlines.
          Color the streamlines and glyphs by the Temp data array.
          View the result in the +X direction.
          Save a screenshot of the result in the filename "stream-glyph/results/{agent_mode}/stream-glyph.png".
          The rendered view and saved screenshot should be 1920 x 1080 pixels.
          (Optional, but must save if use paraview) Save the paraview state as "stream-glyph/results/{agent_mode}/stream-glyph.pvsm".
          (Optional, but must save if use python script) Save the python script as "stream-glyph/results/{agent_mode}/stream-glyph.py".
          Do not save any other files, and always save the visualization image.

  assert:
    - type: llm-rubric
      subtype: vision
      value: |
          1. Streamline Generation: Are streamlines properly traced following the V variable flow field with appropriate seeding from the point cloud?

          2. Tube and Glyph Rendering: Are streamlines rendered as tubes with cone glyphs properly attached showing flow direction and magnitude?

          3. Temperature Color Mapping: Are both streamlines and glyphs correctly colored by the Temp variable with appropriate color scaling?

          4. View Configuration: Is the visualization displayed from the correct +x view direction providing clear visibility of the flow patterns and structures?

# Case 36: time-varying
- vars:
    question: |
          Read the dataset in the file "time-varying/data/time-varying.ex2", and color the data by the EQPS variable.
          Viewing in the +y direction, play an animation through the time steps, with visible color bar legend.
          Rescale the data range to last time step, and play the animation again.
          Create a second linked render view to the right of the first, applying a temporal interpolator to the second view.
          Play the animation simultaneously in both views, and save the animation of both views in "time-varying/results/{agent_mode}/time-varying.avi".
          Print the following statistics: average value of EQPS over all locations and all time steps, average value of EQPS over all locations in the first half of the time steps, average value of EQPS over all locations in the even numbered time steps, and variance of EQPS over all locations and all the time steps.
          Save the last frame of the visualization image as "time-varying/results/{agent_mode}/time-varying.png".
          (Optional, but must save if use paraview) Save the paraview state as "time-varying/results/{agent_mode}/time-varying.pvsm".
          (Optional, but must save if use python script) Save the python script as "time-varying/results/{agent_mode}/time-varying.py".
          Do not save any other files, and always save the visualization image.

  assert:
    - type: llm-rubric
      subtype: vision
      value: |
          1. Temporal Animation Quality: Does the animation smoothly progress through all time steps showing the evolution of the EQPS variable over time?

          2. Dual View Configuration: Are both render views properly configured with the second view showing temporal interpolation effects compared to the first?

          3. Color Mapping and Legend: Is the EQPS variable properly color-mapped with an appropriate color bar legend visible throughout the animation?

          4. View Direction and Layout: Is the +y direction view properly set and are both views arranged side-by-side in the correct layout configuration?

# Case 37: chart-opacity
- vars:
    question: |
          Create a wavelet object.
          Create a plot over line chart from the wavelet with three paths: arc_length, Points_Z, and RTData variables with opacity for arc_length 1 and opacity for Points_Z and RTData 0.3.

          Save the visualization image as "chart-opacity/results/{agent_mode}/chart-opacity.png".
          (Optional, but must save if use paraview) Save the paraview state as "chart-opacity/results/{agent_mode}/chart-opacity.pvsm".
          (Optional, but must save if use python script) Save the python script as "chart-opacity/results/{agent_mode}/chart-opacity.py".
          Do not save any other files, and always save the visualization image.

  assert:
    - type: llm-rubric
      subtype: vision
      value: |
          1. Chart Generation: Is the plot over line chart properly created from the wavelet data?

          2. Variable Display: Are arc_length, Points_Z, and RTData variables all correctly plotted, showing all three specified variables and distinguishable in the chart?

          3. Opacity Settings: Is the arc_length variable displayed with full opacity (1.0) while Points_Z and RTData show reduced opacity (0.3)?

          4. Chart Clarity: Does the chart provide clear visualization of the data trends with appropriate axis scaling and readable formatting?

# Case 38: color-blocks
- vars:
    question: |
          I would like to use ParaView to visualize a dataset.
          Set the background to a blue-gray palette.
          Read the file "color-blocks/data/color-blocks.ex2".
          This is a multiblock dataset.
          Color the dataset by the vtkBlockColors field.
          Retrieve the color map for vtkBlockColors.
          Retrieve the opacity transfer function for vtkBlockColors.
          Retrieve the 2D transfer function for vtkBlockColors.
          Set block coloring for the block at /IOSS/element_blocks/block_2 using the variable ACCL on the x component of the points.
          Rescale the block's color and opacity maps to match the current data range of block_2.
          Retrieve the color transfer function for the ACCL variable of block_2.
          Enable the color bar for block_2.
          Apply a cool to warm color preset to the color map for block_2.
          Set the camera to look down the -y direction and to see the entire dataset.
          Save the visualization image as "color-blocks/results/{agent_mode}/color-blocks.png".
          (Optional, but must save if use paraview) Save the paraview state as "color-blocks/results/{agent_mode}/color-blocks.pvsm".
          (Optional, but must save if use python script) Save the python script as "color-blocks/results/{agent_mode}/color-blocks.py".
          Do not save any other files, and always save the visualization image.

  assert:
    - type: llm-rubric
      subtype: vision
      value: |
          1. Block Color Mapping: Is the dataset properly colored by vtkBlockColors field with distinct block visualization?

          2. Individual Block Coloring: Is block_2 correctly colored using the x component of the ACCL variable with appropriate scaling?

          3. Color Transfer Functions: Are the color transfer functions properly applied with cool to warm coloring for the ACCL variable?

          4. View Configuration: Is the dataset displayed from the -y direction with blue-gray background and visible color bar legend?

# Case 39: color-data
- vars:
    question: |
          Create a wavelet object.
          Create a new calculator with the function 'RTData*iHat + ln(RTData)*jHat + coordsZ*kHat'.
          Get a color transfer function/color map and opacity transfer function/opacity map for the result of the calculation, scaling the color and/or opacity maps to the data range.
          For a surface representation, color by the x coordinate of the result using a cool to warm color map, show the color bar/color legend, and save a screenshot of size 1158 x 833 pixels in "color-data/results/{agent_mode}/color-data.png".
          (Optional, but must save if use paraview) Save the paraview state as "color-data/results/{agent_mode}/color-data.pvsm".
          (Optional, but must save if use python script) Save the python script as "color-data/results/{agent_mode}/color-data.py".
          Do not save any other files, and always save the visualization image.

  assert:
    - type: llm-rubric
      subtype: vision
      value: |
          1. Color Transfer Function: Is the color transfer function correctly applied with cool to warm color mapping scaled to the data range?

          2. Surface Coloring: Is the surface representation properly colored by the x coordinate of the calculated result?

          3. Color Bar Display: Is the color bar/legend visible and properly displaying the color mapping scale and values?

# Case 40: export-gltf
- vars:
    question: |
          Create a wavelet object.
          Create a surface rendering of the wavelet object and color by RTData.
          Scale the color map to the data, and don't display the color bar or the orientation axes.
          Export the view to "export-gltf/results/{agent_mode}/ExportedGLTF.gltf".

          Next load the file "export-gltf/results/{agent_mode}/ExportedGLTF.gltf" and display it as a surface.
          Color this object by TEXCOORD_0.
          Scale the color map to the data, and don't display the color bar or the orientation axes.
          Use the 'Cool to Warm' colormap. Set the background color to white.

          Save the visualization image as "export-gltf/results/{agent_mode}/export-gltf.png".
          (Optional, but must save if use paraview) Save the paraview state as "export-gltf/results/{agent_mode}/export-gltf.pvsm".
          (Optional, but must save if use python script) Save the python script as "export-gltf/results/{agent_mode}/export-gltf.py".
          Do not save any other files, and always save the visualization image.

  assert:
    - type: llm-rubric
      subtype: vision
      value: |
          1. GLTF Export Quality: Is the wavelet object properly exported to GLTF format with correct surface representation and RTData coloring?

          2. GLTF Import and Display: Is the exported GLTF file successfully loaded and displayed as a surface with proper geometry?

          3. Texture Coordinate Coloring: Is the imported GLTF object correctly colored by TEXCOORD_0 with Cool to Warm colormap?

          4. Clean Presentation: Are the color bar and orientation axes properly hidden for a clean visualization appearance?

# Case 41: import-gltf
- vars:
    question: |
          Load the "BlueGrayBackground" palette.
          Read the file "import-gltf/data/import-gltf.glb" and import the nodes "/assembly/Axle", "assembly/OuterRing/Torus002", and "assembly/OuterRing/MiddleRing/InnerRing".
          Set the layout size to 300x300 pixels.
          Point the camera in the positive Y direction and zoom to fit.
          Make sure all views are rendered, then save a screenshot to "import-gltf/results/{agent_mode}/import-gltf.png".
          (Optional, but must save if use paraview) Save the paraview state as "import-gltf/results/{agent_mode}/import-gltf.pvsm".
          (Optional, but must save if use python script) Save the python script as "import-gltf/results/{agent_mode}/import-gltf.py".
          Do not save any other files, and always save the visualization image.

  assert:
    - type: llm-rubric
      subtype: vision
      value: |
          1. GLTF Import Success: Are the specified GLTF nodes properly imported and displayed as separate geometric components?

          2. Node Selection: Are all three specified nodes (Axle, Torus002, InnerRing) correctly imported and visible?

          3. Camera Positioning: Is the camera positioned in the positive Y direction with appropriate zoom to fit all imported geometry? Carefully compare the camera position of GT and result images.

          4. Layout Configuration: Is the view properly sized to 300x300 pixels with correct rendering and background palette?

# Case 42: render-histogram
- vars:
    question: |
          Create a wavelet object and render it as a surface colored by RTDATA with a visible color bar.
          Rescale the colors to the data range and use the 'Cool to Warm' color map.

          Next, split the view horizontally to the right and create a histogram view from the wavelet RTDATA.
          Apply the same 'Cool to Warm' color map to the histogram.

          Save a screenshot of both views (wavelet rendering on the left and histogram on the right) in the file "render-histogram/results/{agent_mode}/render-histogram.png".
          (Optional, but must save if use paraview) Save the paraview state as "render-histogram/results/{agent_mode}/render-histogram.pvsm".
          (Optional, but must save if use python script) Save the python script as "render-histogram/results/{agent_mode}/render-histogram.py".
          Do not save any other files, and always save the visualization image.

  assert:
    - type: llm-rubric
      subtype: vision
      value: |
          1. Wavelet Visualization: Is the wavelet object properly rendered with RTDATA coloring and visible color bar?

          2. Split View Layout: Is the view correctly split with the wavelet visualization on the left and histogram on the right?

          3. Histogram Generation: Is the histogram properly generated from RTDATA showing the data distribution?

          4. Color Map Consistency: Are both the wavelet visualization and histogram using the same Cool to Warm color map?

# Case 43: reset-camera-direction
- vars:
    question: |
          Create a Wavelet object, set its representation to "Surface with Edges", and set the camera direction to [0.5, 1, 0.5].
          Save a screenshot to the file "reset-camera-direction/results/{agent_mode}/reset-camera-direction.png".
          (Optional, but must save if use paraview) Save the paraview state as "reset-camera-direction/results/{agent_mode}/reset-camera-direction.pvsm".
          (Optional, but must save if use python script) Save the python script as "reset-camera-direction/results/{agent_mode}/reset-camera-direction.py".
          Do not save any other files, and always save the visualization image.

  assert:
    - type: llm-rubric
      subtype: vision
      value: |
          1. Wavelet Creation: Is the Wavelet object properly created and displayed in the scene?

          2. Surface with Edges Representation: Is the wavelet correctly displayed with "Surface with Edges" representation showing both surface and wireframe?

          3. Camera Direction: Is the camera positioned according to the specified direction vector [0.5, 1, 0.5]?

          4. View Quality: Does the visualization provide a clear view of the wavelet structure from the specified camera angle?

# Case 44: save-transparent
- vars:
    question: |
          I would like to use ParaView to visualize a dataset.
          Create a wavelet object and show it.  Color the rendering by the variable ‘RTData’.
          Render the wavelet as a surface.  Hide the color bar.
          Next, set the layout size to be 300 pixels by 300 pixels.
          Next, move the camera with the following settings.  The camera position should be [30.273897726939246, 40.8733980301544, 43.48927935675712].  The camera view up should be [-0.3634544237682163, 0.7916848767068606, -0.49105594165731975]. The camera parallel scale should be 17.320508075688775.
          Save a screenshot to the file “save-transparent/results/{agent_mode}/save-transparent.png”, set the image resolution to 300x300, and set the background to transparent.
          (Optional, but must save if use paraview) Save the paraview state as “save-transparent/results/{agent_mode}/save-transparent.pvsm”.
          (Optional, but must save if use python script) Save the python script as “save-transparent/results/{agent_mode}/save-transparent.py”.
          Do not save any other files, and always save the visualization image.

  assert:
    - type: llm-rubric
      subtype: vision
      value: |
          1. Object Creation: Is the wavelet object properly created and displayed in the scene? Looking similar to the GT image?

          2. Transparent Background: Is the screenshot saved with a properly transparent background instead of solid color?

# Case 45: subseries-of-time-series
- vars:
    question: |
          Read the file "subseries-of-time-series/data/subseries-of-time-series.ex2". Load two element blocks: the first is called 'Unnamed block ID: 1 Type: HEX', the second is called 'Unnamed block ID: 2 Type: HEX'.
          Next, slice this object with a plane with origin at [0.21706008911132812, 4.0, -5.110947132110596] and normal direction [1.0, 0.0, 0.0]. The plane should have no offset.
          Next, save this time series to a collection of .vtm files. The base file name for the time series is "subseries-of-time-series/results/{agent_mode}/canslices.vtm" and the suffix is '_%d'. Only save time steps with index between 10 and 20 inclusive, counting by 3.
          Next, load the files "subseries-of-time-series/results/{agent_mode}/canslices_10.vtm", "subseries-of-time-series/results/{agent_mode}/canslices_13.vtm", "subseries-of-time-series/results/{agent_mode}/canslices_16.vtm", and "subseries-of-time-series/results/{agent_mode}/canslices_19.vtm" in multi-block format.
          Finally, show the multi-block data set you just loaded.
          Save a screenshot to the file "subseries-of-time-series/results/{agent_mode}/subseries-of-time-series.png".
          (Optional, but must save if use paraview) Save the paraview state as "subseries-of-time-series/results/{agent_mode}/subseries-of-time-series.pvsm".
          (Optional, but must save if use python script) Save the python script as "subseries-of-time-series/results/{agent_mode}/subseries-of-time-series.py".
          Do not save any other files, and always save the visualization image.

  assert:
    - type: llm-rubric
      subtype: vision
      value: |
          1. Data Loading and Block Selection: Are the specified element blocks properly loaded and the slice plane correctly applied?

          2. Multi-block Loading: Are the exported VTM files successfully loaded back as a multi-block dataset?

          3. Final Visualization: Is the multi-block dataset properly displayed showing the sliced geometry from the time series?

# Case 46: write-ply
- vars:
    question: |
          I would like to use ParaView to visualize a dataset.
          Create a wavelet object. Change the view size to 400x400.
          Show the wavelet object and reset the camera to fit the data.
          Next, create a contour of wavelet object from the dataset "RTData".
          The contour should have isosurfaces at the following values: 97.222075, 157.09105, 216.96002500000003, and 276.829.
          Show the contour and color it with the same colormap that is used for coloring "RTData".
          Finally, save the contour in PLY format to the file "write-ply/results/{agent_mode}/PLYWriterData.ply".
          Save the visualization image as "write-ply/results/{agent_mode}/write-ply.png".
          (Optional, but must save if use paraview) Save the paraview state as "write-ply/results/{agent_mode}/write-ply.pvsm".
          (Optional, but must save if use python script) Save the python script as "write-ply/results/{agent_mode}/write-ply.py".
          Do not save any other files, and always save the visualization image.

  assert:
    - type: llm-rubric
      subtype: vision
      value: |
          1. Cube Creation: Is the cube object properly created and displayed with correct geometry?

          2. PLY Import: Is the exported PLY file correctly loaded back into ParaView maintaining geometric fidelity?

          3. Visualization Quality: Does the imported cube display properly with correct surface representation and rendering?

# Case 47: climate
- vars:
    question: |
          I would like to use ParaView to visualize a dataset of ocean currents.
          Read in the file named "climate/data/climate.vtp".
          Apply a calculator filter to compute the following function:
          (-velocity_X*sin(coordsX*0.0174533) + velocity_Y*cos(coordsX*0.0174533)) * iHat + (-velocity_X * sin(coordsY*0.0174533) * cos(coordsX*0.0174533) - velocity_Y * sin(coordsY*0.0174533) * sin(coordsX*0.0174533) + velocity_Z * cos(coordsY*0.0174533)) * jHat + 0*kHat
          Render the computed values using a tube filter with 0.05 as the tube radius.
          Color the tubes by the magnitude of the velocity.
          Light the tubes with the maximum shininess and include normals in the lighting.
          Add cone glyphs to show the direction of the velocity.
          The glyphs are composed of 10 polygons, having a radius 0 0.15, a height of 0.5, and a scaling factor of 0.5.
          View the result in the -z direction.
          Adjust the view so that the tubes occupy the 90% of the image.
          Save a screenshot of the result, 2294 x 1440 pixels, white background, in the filename "climate/results/{agent_mode}/climate.png".
          (Optional, but must save if use paraview) Save the paraview state as "climate/results/{agent_mode}/climate.pvsm".
          (Optional, but must save if use python script) Save the python script as "climate/results/{agent_mode}/climate.py".
          Do not save any other files, and always save the visualization image.

  assert:
    - type: llm-rubric
      subtype: vision
      value: |
          1. Tube Visualization: Are the tubes rendered with correct radius (0.05), colored by velocity magnitude, and proper lighting with maximum shininess?

          2. Cone Glyph Direction: Are the cone glyphs properly configured with specified parameters and showing velocity direction accurately?

          3. View Configuration: Is the visualization displayed from -z direction with appropriate scaling and white background as specified?

# Case 48: materials
- vars:
    question: |
          Compare two datasets in two views side by side each 900 pixels wide x 1400 pixels high.
          Read the dataset "materials/data/materials_prediction.vtr" in the left view and "materials/data/materials_ground_truth.vtr" in the right view.
          In both views, convert the "Intensity" and "Phase" variables from cell to point data.
          In both views, take an isovolume of the "Intensity" variable in the range of [0.2, 1.0], clipped with a plane at (32.0, 32.0, 32.0) and +x normal direction.
          Color both views with the Viridis (matplotlib) color map for the "Phase" variable, scaled to the data range, including a colormap legend in both views.
          Label the left view "NN Prediction" and the right view "Ground Truth".
          Orient the camera to look in the (-1, 0, -1) direction, with the datasets fitting in the views.
          Save the visualization image as "materials/results/{agent_mode}/materials.png".
          (Optional, but must save if use paraview) Save the paraview state as "materials/results/{agent_mode}/materials.pvsm".
          (Optional, but must save if use python script) Save the python script as "materials/results/{agent_mode}/materials.py".
          Do not save any other files, and always save the visualization image.

  assert:
    - type: llm-rubric
      subtype: vision
      value: |
          1. Side-by-Side Comparison: Are both datasets properly displayed in side-by-side views with correct dimensions and labeling?

          2. Data Conversion and Filtering: Are the Intensity and Phase variables correctly converted to point data and isovolume filtering applied?

          3. Clipping and Color Mapping: Is the plane clipping correctly applied and Viridis colormap properly used for Phase variable?

          4. Camera and Layout: Is the camera positioned correctly in (-1, 0, -1) direction with appropriate fitting and legends visible?