Add 7 vector field visualization cases (ABC, Bernard, twoswirls, crayfish, tornado, supernova100, rti-velocity_slices)

main/{tornado/GS/tornado_gs.pvsm → ABC/GS/abc_glyph.pvsm}

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:975791331869d580901b99607e3c968502b12b4d2d6d17ac48da4ded241479b3
-size 608098
+oid sha256:bd06c014e8cb65fd51ee191eeb970a29dddafc763dfb63e0d546b4d12d4dc53f
+size 351344

main/ABC/GS/abc_glyph.py

@@ -0,0 +1,122 @@
+from paraview.simple import *
+
+# ============= Configuration =============
+INPUT_FILE = '/home/dullpigeon/Desktop/SciVisAgentTask/ABC/abc.raw'
+OUTPUT_IMAGE = '/home/dullpigeon/Desktop/SciVisAgentTask/ABC/abc_glyph.png'
+OUTPUT_STATE = '/home/dullpigeon/Desktop/SciVisAgentTask/ABC/abc_glyph.pvsm'
+IMAGE_SIZE = [1024, 1024]
+
+# ============= Load Data =============
+# ABC flow: 128x128x128, float32, 3 components (vector field)
+reader = ImageReader(FileNames=[INPUT_FILE])
+reader.DataScalarType = 'float'
+reader.DataByteOrder = 'LittleEndian'
+reader.DataExtent = [0, 127, 0, 127, 0, 127]
+reader.FileDimensionality = 3
+reader.NumberOfScalarComponents = 3
+reader.UpdatePipeline()
+
+# ============= Get Data Info =============
+bounds = reader.GetDataInformation().GetBounds()
+center = [(bounds[0]+bounds[1])/2, (bounds[2]+bounds[3])/2, (bounds[4]+bounds[5])/2]
+print(f"Bounds: {bounds}")
+print(f"Center: {center}")
+
+pd = reader.PointData
+array_name = pd.GetArray(0).Name
+print(f"Vector array: '{array_name}', components={pd.GetArray(0).GetNumberOfComponents()}")
+
+# ============= Streamlines =============
+tracer = StreamTracer(Input=reader, SeedType='Point Cloud')
+tracer.Vectors = ['POINTS', array_name]
+tracer.IntegrationDirection = 'BOTH'
+tracer.MaximumStreamlineLength = 150.0
+tracer.SeedType.Center = [73.77097622534964, 63.246234492256846, 71.65486325831273]
+tracer.SeedType.NumberOfPoints = 150
+tracer.SeedType.Radius = 75.0
+tracer.UpdatePipeline()
+
+# ============= Tubes =============
+tube = Tube(Input=tracer)
+tube.Radius = 0.5715767492484302
+tube.NumberofSides = 12
+tube.Capping = 1
+tube.UpdatePipeline()
+
+# ============= Create View =============
+renderView = CreateView('RenderView')
+renderView.ViewSize = IMAGE_SIZE
+renderView.Background = [0.1, 0.1, 0.15]
+
+layout = CreateLayout(name='Layout')
+layout.AssignView(0, renderView)
+
+# ============= Display Reader as Outline =============
+readerDisplay = Show(reader, renderView)
+readerDisplay.Representation = 'Outline'
+ColorBy(readerDisplay, None)
+readerDisplay.DiffuseColor = [0.0, 0.0, 0.0]
+readerDisplay.AmbientColor = [0.0, 0.0, 0.0]
+readerDisplay.Ambient = 0.0
+readerDisplay.Diffuse = 1.0
+readerDisplay.Specular = 1.0
+readerDisplay.SpecularPower = 100.0
+readerDisplay.SpecularColor = [1.0, 1.0, 1.0]
+
+# ============= Display Tubes (Colored by Vorticity) =============
+tubeDisplay = Show(tube, renderView)
+tubeDisplay.Representation = 'Surface'
+
+# Color by Vorticity magnitude
+ColorBy(tubeDisplay, ('POINTS', 'Vorticity', 'Magnitude'))
+
+# Vorticity color transfer function - Cool to Warm
+vorticityLUT = GetColorTransferFunction('Vorticity')
+vorticityLUT.RGBPoints = [
+    0.011427014127020022, 0.231373, 0.298039, 0.752941,
+    0.06627861150384136, 0.865003, 0.865003, 0.865003,
+    0.12113020888066268, 0.705882, 0.0156863, 0.14902
+]
+vorticityLUT.ColorSpace = 'Diverging'
+vorticityLUT.NumberOfTableValues = 256
+
+tubeDisplay.LookupTable = vorticityLUT
+
+# Lighting properties
+tubeDisplay.AmbientColor = [0.2, 0.6, 0.9]
+tubeDisplay.DiffuseColor = [0.2, 0.6, 0.9]
+tubeDisplay.Ambient = 0.1
+tubeDisplay.Diffuse = 0.8
+tubeDisplay.Specular = 0.5
+tubeDisplay.SpecularPower = 40.0
+tubeDisplay.SpecularColor = [1.0, 1.0, 1.0]
+
+# ============= Lighting Setup =============
+renderView.UseLight = True
+renderView.KeyLightWarmth = 0.6
+renderView.KeyLightIntensity = 0.8
+renderView.FillLightWarmth = 0.4
+
+# ============= Camera Setup =============
+renderView.CameraPosition = [-150.9869248398403, 391.7532864870642, 219.6428988217961]
+renderView.CameraFocalPoint = [32.38121308065774, 120.40859825991274, 81.63393818503701]
+renderView.CameraViewUp = [0.23256370029970702, -0.31145477116075004, 0.9213631481799741]
+renderView.CameraViewAngle = 30.0
+renderView.CameraParallelProjection = 0
+
+# ============= Color Bar (Legend) =============
+tubeDisplay.SetScalarBarVisibility(renderView, True)
+colorBar = GetScalarBar(vorticityLUT, renderView)
+colorBar.Title = ''
+colorBar.ComponentTitle = ''
+colorBar.LabelColor = [0.0, 0.0, 0.0]
+colorBar.Visibility = 1
+colorBar.ScalarBarLength = 0.3
+
+# ============= Save =============
+Render(renderView)
+SaveScreenshot(OUTPUT_IMAGE, renderView, ImageResolution=IMAGE_SIZE)
+print(f"Screenshot saved to: {OUTPUT_IMAGE}")
+
+SaveState(OUTPUT_STATE)
+print(f"State saved to: {OUTPUT_STATE}")

main/ABC/data/abc.raw

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:5d6720499d8b23f53f6f0a4c5e1aaa7b91b083e0d9a0882c85482cfa79cddb32
+size 25165824

main/ABC/data/abc.txt

@@ -0,0 +1 @@
+128 128 128

main/ABC/task_description.txt

@@ -0,0 +1,22 @@
+Load the ABC (Arnold-Beltrami-Childress) flow vector field from "ABC/data/abc.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 dark background (RGB: 0.1, 0.1, 0.15). Render at 1024x1024.
+
+Save the paraview state as "ABC/results/{agent_mode}/ABC.pvsm".
+Save the visualization image as "ABC/results/{agent_mode}/ABC.png".
+(Optional, 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.

main/ABC/visualization_goals.txt

@@ -0,0 +1,4 @@
+vision:
+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?

main/{tornado/GS/gs_diagonal_view.png → Bernard/GS/bernard_streamline.pvsm}

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:98bb79780c30dc31b18ba561087a650621e739659e1f6b6b767131df005ea5a0
-size 698978
+oid sha256:8435f88d5b08483d8322d89950aa548a6abff2be841cbc0e800b5e005c3e3f30
+size 582447

main/Bernard/GS/bernard_streamline.py

@@ -0,0 +1,161 @@
+from paraview.simple import *
+
+# ============= Configuration =============
+INPUT_FILE = '/home/dullpigeon/Desktop/SciVisAgentTask/Bernard/bernard.raw'
+OUTPUT_FILE = '/home/dullpigeon/Desktop/SciVisAgentTask/Bernard/bernard_streamline.png'
+IMAGE_SIZE = [1280, 1280]
+
+# ============= Load Data =============
+reader = ImageReader(FileNames=[INPUT_FILE])
+reader.DataScalarType = 'float'
+reader.DataByteOrder = 'LittleEndian'
+reader.DataExtent = [0, 127, 0, 31, 0, 63]
+reader.FileDimensionality = 3
+reader.NumberOfScalarComponents = 3
+reader.DataSpacing = [1.0, 1.0, 1.0]
+reader.DataOrigin = [0.0, 0.0, 0.0]
+reader.UpdatePipeline()
+
+# ============= Create View =============
+renderView = CreateView('RenderView')
+renderView.ViewSize = IMAGE_SIZE
+renderView.Background = [0.329, 0.349, 0.427]
+
+layout = CreateLayout(name='Layout')
+layout.AssignView(0, renderView)
+
+# ============= Common StreamTracer parameters =============
+def create_stream_tracer(seed_center, seed_num_points=100, seed_radius=12.7):
+    tracer = StreamTracer(Input=reader, SeedType='Point Cloud')
+    tracer.Vectors = ['POINTS', 'ImageFile']
+    tracer.IntegrationDirection = 'BOTH'
+    tracer.IntegratorType = 'Runge-Kutta 4-5'
+    tracer.IntegrationStepUnit = 'Cell Length'
+    tracer.InitialStepLength = 0.2
+    tracer.MinimumStepLength = 0.01
+    tracer.MaximumStepLength = 0.5
+    tracer.MaximumSteps = 2000
+    tracer.MaximumStreamlineLength = 127.0
+    tracer.MaximumError = 1e-06
+    tracer.TerminalSpeed = 1e-12
+    tracer.ComputeVorticity = 1
+    tracer.SeedType.Center = seed_center
+    tracer.SeedType.NumberOfPoints = seed_num_points
+    tracer.SeedType.Radius = seed_radius
+    tracer.UpdatePipeline()
+    return tracer
+
+TUBE_RADIUS = 0.3
+
+# ============= StreamTracer #1 (Blue) - upper Z region, left =============
+streamTracer1 = create_stream_tracer([30.69363105646732, 14.606974171411734, 47.98687368903744])
+Hide(streamTracer1, renderView)
+
+tube1 = Tube(Input=streamTracer1)
+tube1.Radius = TUBE_RADIUS
+tube1.NumberofSides = 12
+tube1.UpdatePipeline()
+
+display1 = Show(tube1, renderView)
+display1.Representation = 'Surface'
+ColorBy(display1, None)
+display1.AmbientColor = [0.0, 0.6666666666666666, 1.0]
+display1.DiffuseColor = [0.0, 0.6666666666666666, 1.0]
+display1.Ambient = 0.1
+display1.Diffuse = 0.9
+display1.Specular = 1.0
+display1.SpecularPower = 25.0
+
+# ============= StreamTracer #2 (Orange) - upper Z region, right =============
+streamTracer2 = create_stream_tracer([91.10220497064907, 14.648011311581818, 45.695641513117174])
+Hide(streamTracer2, renderView)
+
+tube2 = Tube(Input=streamTracer2)
+tube2.Radius = TUBE_RADIUS
+tube2.NumberofSides = 12
+tube2.UpdatePipeline()
+
+display2 = Show(tube2, renderView)
+display2.Representation = 'Surface'
+ColorBy(display2, None)
+display2.AmbientColor = [1.0, 0.3333333333333333, 0.0]
+display2.DiffuseColor = [1.0, 0.3333333333333333, 0.0]
+display2.Ambient = 0.1
+display2.Diffuse = 0.9
+display2.Specular = 1.0
+display2.SpecularPower = 25.0
+
+# ============= StreamTracer #3 (Colored by ImageFile) - lower Z region, left =============
+streamTracer3 = create_stream_tracer([31.87023906731507, 12.756683337497686, 15.894907695885063])
+Hide(streamTracer3, renderView)
+
+tube3 = Tube(Input=streamTracer3)
+tube3.Radius = TUBE_RADIUS
+tube3.NumberofSides = 12
+tube3.UpdatePipeline()
+
+display3 = Show(tube3, renderView)
+display3.Representation = 'Surface'
+ColorBy(display3, ('POINTS', 'ImageFile', 'Magnitude'))
+
+imageFileLUT = GetColorTransferFunction('ImageFile')
+imageFileLUT.RGBPoints = [
+    0.0008126780597642342, 0.231373, 0.298039, 0.752941,
+    0.25364943975098625, 0.865003, 0.865003, 0.865003,
+    0.5064862014422082, 0.705882, 0.0156863, 0.14902
+]
+imageFileLUT.ColorSpace = 'Diverging'
+imageFileLUT.NumberOfTableValues = 256
+display3.LookupTable = imageFileLUT
+display3.Ambient = 0.1
+display3.Diffuse = 0.9
+display3.Specular = 1.0
+display3.SpecularPower = 25.0
+
+# ============= StreamTracer #4 (Green) - lower Z region, right =============
+streamTracer4 = create_stream_tracer([92.09277450943044, 10.501538955968837, 15.324680632956035])
+Hide(streamTracer4, renderView)
+
+tube4 = Tube(Input=streamTracer4)
+tube4.Radius = TUBE_RADIUS
+tube4.NumberofSides = 12
+tube4.UpdatePipeline()
+
+display4 = Show(tube4, renderView)
+display4.Representation = 'Surface'
+ColorBy(display4, None)
+display4.AmbientColor = [0.3333333333333333, 0.6666666666666666, 0.0]
+display4.DiffuseColor = [0.3333333333333333, 0.6666666666666666, 0.0]
+display4.Ambient = 0.1
+display4.Diffuse = 0.9
+display4.Specular = 1.0
+display4.SpecularPower = 25.0
+
+# ============= Lighting =============
+renderView.UseLight = True
+renderView.KeyLightWarmth = 0.5
+renderView.KeyLightIntensity = 0.9
+renderView.FillLightWarmth = 0.4
+
+light = AddLight(view=renderView)
+light.Coords = 1  # Headlight
+light.Intensity = 0.5
+
+# ============= Camera Settings =============
+renderView.CameraPosition = [-81.98633122306042, -141.45193378411128, 89.85554690899205]
+renderView.CameraFocalPoint = [65.58071842141872, 26.289083381147567, 28.47827338802388]
+renderView.CameraViewUp = [0.17857755931542532, 0.19572786724332386, 0.9642617161815177]
+renderView.CameraViewAngle = 30.0
+renderView.CameraParallelScale = 72.55859700958943
+
+# ============= No Legend for Bernard =============
+display3.SetScalarBarVisibility(renderView, False)
+
+# ============= Save =============
+Render(renderView)
+SaveScreenshot(OUTPUT_FILE, renderView, ImageResolution=IMAGE_SIZE)
+print(f'Screenshot saved to {OUTPUT_FILE}')
+
+OUTPUT_STATE = '/home/dullpigeon/Desktop/SciVisAgentTask/Bernard/bernard_streamline.pvsm'
+SaveState(OUTPUT_STATE)
+print(f'State saved to {OUTPUT_STATE}')

main/Bernard/data/bernard.raw

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:6581ae4f4d0cc7e67f95113bfc7c6af044e361824a05a08555e9a2f83b1f55aa
+size 3145728

main/Bernard/data/bernard.txt

@@ -0,0 +1 @@
+128 32 64

main/Bernard/task_description.txt

@@ -0,0 +1,22 @@
+Load the Rayleigh-Benard convection vector field from "Bernard/data/bernard.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 paraview state as "Bernard/results/{agent_mode}/Bernard.pvsm".
+Save the visualization image as "Bernard/results/{agent_mode}/Bernard.png".
+(Optional, if use python script) Save the python script as "Bernard/results/{agent_mode}/Bernard.py".
+Do not save any other files, and always save the visualization image.

main/Bernard/visualization_goals.txt

@@ -0,0 +1,4 @@
+vision:
+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?

main/crayfish/GS/crayfish_streamline.pvsm

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:6bb462c5dac0033ce7533c7c2fd98f1b36bfa2da305136c6a5cdfe9aac7f3efb
+size 474241

main/crayfish/GS/crayfish_streamline.py

@@ -0,0 +1,150 @@
+from paraview.simple import *
+
+# ============= Configuration =============
+INPUT_FILE = '/home/dullpigeon/Desktop/SciVisAgentTask/crayfish/crayfish.raw'
+OUTPUT_FILE = '/home/dullpigeon/Desktop/SciVisAgentTask/crayfish/crayfish_streamline.png'
+IMAGE_SIZE = [1280, 1280]
+
+# Data dimensions: 322 x 162 x 119
+DIM_X, DIM_Y, DIM_Z = 322, 162, 119
+MAX_DIM = max(DIM_X, DIM_Y, DIM_Z)
+CENTER = [DIM_X / 2.0, DIM_Y / 2.0, DIM_Z / 2.0]
+
+# ============= Load Data =============
+reader = ImageReader(FileNames=[INPUT_FILE])
+reader.DataScalarType = 'float'
+reader.DataByteOrder = 'LittleEndian'
+reader.DataExtent = [0, DIM_X - 1, 0, DIM_Y - 1, 0, DIM_Z - 1]
+reader.FileDimensionality = 3
+reader.NumberOfScalarComponents = 3
+reader.DataSpacing = [1.0, 1.0, 1.0]
+reader.DataOrigin = [0.0, 0.0, 0.0]
+reader.UpdatePipeline()
+
+# ============= Create View =============
+renderView = CreateView('RenderView')
+renderView.ViewSize = IMAGE_SIZE
+renderView.Background = [0.329, 0.349, 0.427]
+
+layout = CreateLayout(name='Layout')
+layout.AssignView(0, renderView)
+
+# ============= Vorticity Color Map (Cool to Warm) =============
+vorticityLUT = GetColorTransferFunction('Vorticity')
+vorticityLUT.RGBPoints = [
+    0.0, 0.231373, 0.298039, 0.752941,
+    0.02, 0.865003, 0.865003, 0.865003,
+    0.15, 0.705882, 0.0156863, 0.14902
+]
+vorticityLUT.ColorSpace = 'Diverging'
+vorticityLUT.NumberOfTableValues = 256
+
+# ============= StreamTracer #1 (Blue seed region) =============
+streamTracer1 = StreamTracer(Input=reader, SeedType='Point Cloud')
+streamTracer1.Vectors = ['POINTS', 'ImageFile']
+streamTracer1.IntegrationDirection = 'BOTH'
+streamTracer1.IntegratorType = 'Runge-Kutta 4-5'
+streamTracer1.IntegrationStepUnit = 'Cell Length'
+streamTracer1.InitialStepLength = 0.2
+streamTracer1.MinimumStepLength = 0.01
+streamTracer1.MaximumStepLength = 0.5
+streamTracer1.MaximumSteps = 2000
+streamTracer1.MaximumStreamlineLength = float(MAX_DIM)
+streamTracer1.MaximumError = 1e-06
+streamTracer1.TerminalSpeed = 1e-12
+streamTracer1.ComputeVorticity = 1
+streamTracer1.SeedType.Center = [DIM_X / 3.0, 81.0, 59.5]
+streamTracer1.SeedType.NumberOfPoints = 100
+streamTracer1.SeedType.Radius = MAX_DIM * 0.1
+streamTracer1.UpdatePipeline()
+
+Hide(streamTracer1, renderView)
+
+tube1 = Tube(Input=streamTracer1)
+tube1.Radius = 0.5
+tube1.NumberofSides = 12
+tube1.UpdatePipeline()
+
+display1 = Show(tube1, renderView)
+display1.Representation = 'Surface'
+ColorBy(display1, ('POINTS', 'Vorticity', 'Magnitude'))
+display1.LookupTable = vorticityLUT
+display1.RescaleTransferFunctionToDataRange(True)
+display1.Ambient = 0.05
+display1.Diffuse = 1.0
+display1.Specular = 1.0
+display1.SpecularPower = 25.0
+
+# ============= StreamTracer #2 (Orange seed region) =============
+streamTracer2 = StreamTracer(Input=reader, SeedType='Point Cloud')
+streamTracer2.Vectors = ['POINTS', 'ImageFile']
+streamTracer2.IntegrationDirection = 'BOTH'
+streamTracer2.IntegratorType = 'Runge-Kutta 4-5'
+streamTracer2.IntegrationStepUnit = 'Cell Length'
+streamTracer2.InitialStepLength = 0.2
+streamTracer2.MinimumStepLength = 0.01
+streamTracer2.MaximumStepLength = 0.5
+streamTracer2.MaximumSteps = 2000
+streamTracer2.MaximumStreamlineLength = float(MAX_DIM)
+streamTracer2.MaximumError = 1e-06
+streamTracer2.TerminalSpeed = 1e-12
+streamTracer2.ComputeVorticity = 1
+streamTracer2.SeedType.Center = [DIM_X * 2.0 / 3.0, 81.0, 59.5]
+streamTracer2.SeedType.NumberOfPoints = 100
+streamTracer2.SeedType.Radius = MAX_DIM * 0.1
+streamTracer2.UpdatePipeline()
+
+Hide(streamTracer2, renderView)
+
+tube2 = Tube(Input=streamTracer2)
+tube2.Radius = 0.5
+tube2.NumberofSides = 12
+tube2.UpdatePipeline()
+
+display2 = Show(tube2, renderView)
+display2.Representation = 'Surface'
+ColorBy(display2, ('POINTS', 'Vorticity', 'Magnitude'))
+display2.LookupTable = vorticityLUT
+display2.RescaleTransferFunctionToDataRange(True)
+display2.Ambient = 0.05
+display2.Diffuse = 1.0
+display2.Specular = 1.0
+display2.SpecularPower = 25.0
+
+# ============= Re-apply custom colormap after rescale =============
+vorticityLUT.RGBPoints = [
+    0.0, 0.231373, 0.298039, 0.752941,
+    0.02, 0.865003, 0.865003, 0.865003,
+    0.15, 0.705882, 0.0156863, 0.14902
+]
+
+# ============= Outline (black border) =============
+readerDisplay = Show(reader, renderView)
+readerDisplay.Representation = 'Outline'
+ColorBy(readerDisplay, None)
+readerDisplay.DiffuseColor = [0.0, 0.0, 0.0]
+readerDisplay.AmbientColor = [0.0, 0.0, 0.0]
+
+# ============= Camera Settings =============
+renderView.CameraPosition = [435.04, -325.38, 567.82]
+renderView.CameraFocalPoint = [111.64, 202.81, -21.96]
+renderView.CameraViewUp = [-0.099, 0.714, 0.693]
+renderView.CameraViewAngle = 30.0
+
+# ============= Color Bar (Legend) =============
+display1.SetScalarBarVisibility(renderView, True)
+colorBar = GetScalarBar(vorticityLUT, renderView)
+colorBar.Title = ''
+colorBar.ComponentTitle = ''
+colorBar.LabelColor = [0.0, 0.0, 0.0]
+colorBar.Visibility = 1
+colorBar.ScalarBarLength = 0.3
+
+# ============= Save =============
+Render(renderView)
+SaveScreenshot(OUTPUT_FILE, renderView, ImageResolution=IMAGE_SIZE)
+print(f'Screenshot saved to {OUTPUT_FILE}')
+
+OUTPUT_STATE = '/home/dullpigeon/Desktop/SciVisAgentTask/crayfish/crayfish_streamline.pvsm'
+SaveState(OUTPUT_STATE)
+print(f'State saved to {OUTPUT_STATE}')

main/crayfish/data/crayfish.raw

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:d5a3e2e2a07fb55c06f0f4db42b6666a4d5d90c0d7bf23541b0aa0f936194dca
+size 74490192

main/crayfish/data/crayfish.txt

@@ -0,0 +1 @@
+322 162 119

main/crayfish/task_description.txt

@@ -0,0 +1,25 @@
+Load the Crayfish flow vector field from "crayfish/data/crayfish.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 gray-blue background (RGB: 0.329, 0.349, 0.427). Render at 1280x1280.
+
+Save the paraview state as "crayfish/results/{agent_mode}/crayfish.pvsm".
+Save the visualization image as "crayfish/results/{agent_mode}/crayfish.png".
+(Optional, if use python script) Save the python script as "crayfish/results/{agent_mode}/crayfish.py".
+Do not save any other files, and always save the visualization image.

main/crayfish/visualization_goals.txt

@@ -0,0 +1,5 @@
+vision:
+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?
+

main/rti-velocity_slices/GS/rti-velocity_slices_gs.pvsm

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:e91e7ad9a7d960469a42a364054287a81c358d64f6a0f22694fc5c31ad8ac2db
-size 512614
+oid sha256:0258bfad7702e78d7a86ef9dbe27e2928f06f437c3eea190aed7f9e20d7e816e
+size 511803

main/rti-velocity_slices/GS/rti-velocity_slices_gs.py

@@ -2,9 +2,9 @@ import os
 from paraview.simple import *
 
 SCRIPT_DIR = os.path.dirname(os.path.abspath(__file__))
-VTI_PATH = os.path.join(SCRIPT_DIR, '..', 'vti_data', 'RTI_velocity_0080.vti')
-OUTPUT_IMG = os.path.join(SCRIPT_DIR, 'gt_image.png')
-OUTPUT_STATE = os.path.join(SCRIPT_DIR, 'gt_state.pvsm')
+VTI_PATH = os.path.join(SCRIPT_DIR, '..', 'data', 'rti-velocity_slices.vti')
+OUTPUT_IMG = os.path.join(SCRIPT_DIR, 'rti-velocity_slices_gs.png')
+OUTPUT_STATE = os.path.join(SCRIPT_DIR, 'rti-velocity_slices_gs.pvsm')
 
 reader = XMLImageDataReader(FileName=[VTI_PATH])
 reader.UpdatePipeline()
@@ -42,11 +42,14 @@ for s in [sliceX, sliceY, sliceZ]:
 magLUT = GetColorTransferFunction('magnitude')
 magLUT.ApplyPreset('Turbo', True)
 
-# Show color bar on last display
+# ============= Color Bar (Legend) =============
 d.SetScalarBarVisibility(renderView, True)
 colorBar = GetScalarBar(magLUT, renderView)
-colorBar.Title = 'Velocity Magnitude'
+colorBar.Title = ''
 colorBar.ComponentTitle = ''
+colorBar.LabelColor = [0.0, 0.0, 0.0]
+colorBar.Visibility = 1
+colorBar.ScalarBarLength = 0.3
 
 renderView.CameraPosition = [200.0, 200.0, 200.0]
 renderView.CameraFocalPoint = [63.5, 63.5, 63.5]

main/rti-velocity_slices/visualization_goals.txt

@@ -1,7 +1,4 @@
-1. Overall Visualization Goal: Does the result match the ground truth three-orthogonal-slice visualization of the RTI velocity field?
-
-2. Slice Patterns: Do all three slices show similar patterns and structures as the ground truth?
-
-3. Slice Positioning: Are the three orthogonal slices positioned and oriented similarly to the ground truth?
-
-4. Color Mapping: Is the color distribution across all slices visually similar to the ground truth?
+vision:
+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?

main/supernova100/GS/supernova100_streamline.pvsm

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:51fe12a1dba96d5d5bbb1c188fee1a73372972a2dbcdbed2333ab28dd4aa76fa
+size 351344

main/supernova100/GS/supernova100_streamline.py

@@ -0,0 +1,236 @@
+# state file generated using paraview version 5.12.1
+import paraview
+paraview.compatibility.major = 5
+paraview.compatibility.minor = 12
+
+#### import the simple module from the paraview
+from paraview.simple import *
+#### disable automatic camera reset on 'Show'
+paraview.simple._DisableFirstRenderCameraReset()
+
+# ----------------------------------------------------------------
+# setup views used in the visualization
+# ----------------------------------------------------------------
+
+# get the material library
+materialLibrary1 = GetMaterialLibrary()
+
+# Create a new 'Render View'
+renderView1 = CreateView('RenderView')
+renderView1.ViewSize = [1280, 1280]
+renderView1.AxesGrid = 'Grid Axes 3D Actor'
+renderView1.CenterOfRotation = [49.448320619761944, 49.504851795732975, 49.49083889275789]
+renderView1.StereoType = 'Crystal Eyes'
+renderView1.CameraPosition = [41.375600380195785, 73.91451257516562, -281.99012820613103]
+renderView1.CameraFocalPoint = [49.448320619761944, 49.504851795732975, 49.49083889275789]
+renderView1.CameraViewUp = [0.013861114479786198, 0.9972285417954958, 0.07309654529324446]
+renderView1.CameraFocalDisk = 1.0
+renderView1.CameraParallelScale = 86.05125369292628
+renderView1.LegendGrid = 'Legend Grid Actor'
+renderView1.BackEnd = 'OSPRay raycaster'
+renderView1.OSPRayMaterialLibrary = materialLibrary1
+
+SetActiveView(None)
+
+# ----------------------------------------------------------------
+# setup view layouts
+# ----------------------------------------------------------------
+
+# create new layout object 'Layout'
+layout = CreateLayout(name='Layout')
+layout.AssignView(0, renderView1)
+layout.SetSize(1280, 1280)
+
+# ----------------------------------------------------------------
+# restore active view
+SetActiveView(renderView1)
+# ----------------------------------------------------------------
+
+# ----------------------------------------------------------------
+# setup the data processing pipelines
+# ----------------------------------------------------------------
+
+# create a new 'Image Reader'
+imageReader1 = ImageReader(registrationName='ImageReader1', FileNames=['/home/dullpigeon/Desktop/SciVisAgentTask/supernova100/supernova100.raw'])
+imageReader1.DataScalarType = 'float'
+imageReader1.DataByteOrder = 'LittleEndian'
+imageReader1.NumberOfScalarComponents = 3
+imageReader1.DataExtent = [0, 99, 0, 99, 0, 99]
+
+# create a new 'Stream Tracer'
+streamTracer1 = StreamTracer(registrationName='StreamTracer1', Input=imageReader1,
+    SeedType='Point Cloud')
+streamTracer1.Vectors = ['POINTS', 'ImageFile']
+streamTracer1.MaximumStreamlineLength = 100.0
+
+# init the 'Point Cloud' selected for 'SeedType'
+streamTracer1.SeedType.Center = [50.0, 50.0, 50.0]
+streamTracer1.SeedType.NumberOfPoints = 200
+streamTracer1.SeedType.Radius = 45.0
+
+# create a new 'Tube'
+tube1 = Tube(registrationName='Tube1', Input=streamTracer1)
+tube1.Scalars = ['POINTS', 'AngularVelocity']
+tube1.Vectors = ['POINTS', 'Normals']
+tube1.NumberofSides = 12
+tube1.Radius = 0.3
+
+# ----------------------------------------------------------------
+# setup the visualization in view 'renderView1'
+# ----------------------------------------------------------------
+
+# show data from tube1
+tube1Display = Show(tube1, renderView1, 'GeometryRepresentation')
+
+# get 2D transfer function for 'Vorticity'
+vorticityTF2D = GetTransferFunction2D('Vorticity')
+
+# get color transfer function/color map for 'Vorticity'
+vorticityLUT = GetColorTransferFunction('Vorticity')
+vorticityLUT.TransferFunction2D = vorticityTF2D
+vorticityLUT.RGBPoints = [0.0, 0.231373, 0.298039, 0.752941, 0.05, 0.865003, 0.865003, 0.865003, 0.5, 0.705882, 0.0156863, 0.14902]
+vorticityLUT.ScalarRangeInitialized = 1.0
+
+# trace defaults for the display properties.
+tube1Display.Representation = 'Surface'
+tube1Display.AmbientColor = [0.996078431372549, 1.0, 0.8431372549019608]
+tube1Display.ColorArrayName = ['POINTS', 'Vorticity']
+tube1Display.DiffuseColor = [0.996078431372549, 1.0, 0.8431372549019608]
+tube1Display.LookupTable = vorticityLUT
+tube1Display.Specular = 1.0
+tube1Display.SpecularPower = 25.0
+tube1Display.Ambient = 0.05
+tube1Display.SelectTCoordArray = 'None'
+tube1Display.SelectNormalArray = 'TubeNormals'
+tube1Display.SelectTangentArray = 'None'
+tube1Display.OSPRayScaleArray = 'ImageFile'
+tube1Display.OSPRayScaleFunction = 'Piecewise Function'
+tube1Display.Assembly = ''
+tube1Display.SelectOrientationVectors = 'Normals'
+tube1Display.ScaleFactor = 9.941288857162
+tube1Display.SelectScaleArray = 'ImageFile'
+tube1Display.GlyphType = 'Arrow'
+tube1Display.GlyphTableIndexArray = 'ImageFile'
+tube1Display.GaussianRadius = 0.4970644428581
+tube1Display.SetScaleArray = ['POINTS', 'ImageFile']
+tube1Display.ScaleTransferFunction = 'Piecewise Function'
+tube1Display.OpacityArray = ['POINTS', 'ImageFile']
+tube1Display.OpacityTransferFunction = 'Piecewise Function'
+tube1Display.DataAxesGrid = 'Grid Axes Representation'
+tube1Display.PolarAxes = 'Polar Axes Representation'
+tube1Display.SelectInputVectors = ['POINTS', 'Normals']
+tube1Display.WriteLog = ''
+
+# init the 'Piecewise Function' selected for 'ScaleTransferFunction'
+tube1Display.ScaleTransferFunction.Points = [-0.9286808371543884, 0.0, 0.5, 0.0, 0.93073570728302, 1.0, 0.5, 0.0]
+
+# init the 'Piecewise Function' selected for 'OpacityTransferFunction'
+tube1Display.OpacityTransferFunction.Points = [-0.9286808371543884, 0.0, 0.5, 0.0, 0.93073570728302, 1.0, 0.5, 0.0]
+
+# show data from imageReader1
+imageReader1Display = Show(imageReader1, renderView1, 'UniformGridRepresentation')
+
+# trace defaults for the display properties.
+imageReader1Display.Representation = 'Outline'
+imageReader1Display.AmbientColor = [0.0, 0.0, 0.0]
+imageReader1Display.ColorArrayName = ['POINTS', '']
+imageReader1Display.DiffuseColor = [0.0, 0.0, 0.0]
+imageReader1Display.SelectTCoordArray = 'None'
+imageReader1Display.SelectNormalArray = 'None'
+imageReader1Display.SelectTangentArray = 'None'
+imageReader1Display.OSPRayScaleArray = 'ImageFile'
+imageReader1Display.OSPRayScaleFunction = 'Piecewise Function'
+imageReader1Display.Assembly = ''
+imageReader1Display.SelectOrientationVectors = 'ImageFile'
+imageReader1Display.ScaleFactor = 9.9
+imageReader1Display.SelectScaleArray = 'ImageFile'
+imageReader1Display.GlyphType = 'Arrow'
+imageReader1Display.GlyphTableIndexArray = 'ImageFile'
+imageReader1Display.GaussianRadius = 0.495
+imageReader1Display.SetScaleArray = ['POINTS', 'ImageFile']
+imageReader1Display.ScaleTransferFunction = 'Piecewise Function'
+imageReader1Display.OpacityArray = ['POINTS', 'ImageFile']
+imageReader1Display.OpacityTransferFunction = 'Piecewise Function'
+imageReader1Display.DataAxesGrid = 'Grid Axes Representation'
+imageReader1Display.PolarAxes = 'Polar Axes Representation'
+imageReader1Display.ScalarOpacityUnitDistance = 1.7320508075688772
+imageReader1Display.OpacityArrayName = ['POINTS', 'ImageFile']
+imageReader1Display.ColorArray2Name = ['POINTS', 'ImageFile']
+imageReader1Display.IsosurfaceValues = [-0.0013266801834106445]
+imageReader1Display.SliceFunction = 'Plane'
+imageReader1Display.Slice = 49
+imageReader1Display.SelectInputVectors = ['POINTS', 'ImageFile']
+imageReader1Display.WriteLog = ''
+
+# init the 'Piecewise Function' selected for 'ScaleTransferFunction'
+imageReader1Display.ScaleTransferFunction.Points = [-1.05519700050354, 0.0, 0.5, 0.0, 1.0525436401367188, 1.0, 0.5, 0.0]
+
+# init the 'Piecewise Function' selected for 'OpacityTransferFunction'
+imageReader1Display.OpacityTransferFunction.Points = [-1.05519700050354, 0.0, 0.5, 0.0, 1.0525436401367188, 1.0, 0.5, 0.0]
+
+# init the 'Plane' selected for 'SliceFunction'
+imageReader1Display.SliceFunction.Origin = [49.5, 49.5, 49.5]
+
+# setup the color legend parameters for each legend in this view
+
+# get color legend/bar for vorticityLUT in view renderView1
+vorticityLUTColorBar = GetScalarBar(vorticityLUT, renderView1)
+vorticityLUTColorBar.Title = ''
+vorticityLUTColorBar.ComponentTitle = ''
+vorticityLUTColorBar.LabelColor = [0.0, 0.0, 0.0]
+vorticityLUTColorBar.ScalarBarLength = 0.3
+
+# set color bar visibility
+vorticityLUTColorBar.Visibility = 1
+
+# show color legend
+tube1Display.SetScalarBarVisibility(renderView1, True)
+
+# ----------------------------------------------------------------
+# setup color maps and opacity maps used in the visualization
+# note: the Get..() functions create a new object, if needed
+# ----------------------------------------------------------------
+
+# get opacity transfer function/opacity map for 'Vorticity'
+vorticityPWF = GetOpacityTransferFunction('Vorticity')
+vorticityPWF.Points = [0.0, 0.0, 0.5, 0.0, 2.1077474082537866, 1.0, 0.5, 0.0]
+vorticityPWF.ScalarRangeInitialized = 1
+
+# ----------------------------------------------------------------
+# setup animation scene, tracks and keyframes
+# note: the Get..() functions create a new object, if needed
+# ----------------------------------------------------------------
+
+# get time animation track
+timeAnimationCue1 = GetTimeTrack()
+
+# initialize the animation scene
+
+# get the time-keeper
+timeKeeper1 = GetTimeKeeper()
+
+# initialize the timekeeper
+
+# initialize the animation track
+
+# get animation scene
+animationScene1 = GetAnimationScene()
+
+# initialize the animation scene
+animationScene1.ViewModules = renderView1
+animationScene1.Cues = timeAnimationCue1
+animationScene1.AnimationTime = 0.0
+
+# ----------------------------------------------------------------
+# restore active source
+SetActiveSource(None)
+# ----------------------------------------------------------------
+
+
+# ============= Render and Save =============
+RenderAllViews()
+SaveScreenshot('/home/dullpigeon/Desktop/SciVisAgentTask/supernova100/supernova100_streamline.png', renderView1, ImageResolution=[1280, 1280])
+print('Screenshot saved')
+
+SaveState('/home/dullpigeon/Desktop/SciVisAgentTask/supernova100/supernova100_streamline.pvsm')
+print('State saved')

main/supernova100/data/supernova100.raw

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:78f980b0038b4341f580778f650751615ffc4639c2d41e3837c1a89537a20046
+size 12000000

main/supernova100/data/supernova100.txt

@@ -0,0 +1 @@
+100 100 100

main/supernova100/task_description.txt

@@ -0,0 +1,27 @@
+Load the Supernova velocity vector field from "supernova100/data/supernova100.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.
+
+Render at 1280x1280.
+
+Save the paraview state as "supernova100/results/{agent_mode}/supernova100.pvsm".
+Save the visualization image as "supernova100/results/{agent_mode}/supernova100.png".
+(Optional, if use python script) Save the python script as "supernova100/results/{agent_mode}/supernova100.py".
+Do not save any other files, and always save the visualization image.

main/supernova100/visualization_goals.txt

@@ -0,0 +1,4 @@
+vision:
+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?

main/tornado/GS/tornado_streamline.pvsm

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:f5197d9590e853faed347fe46454f36cd3ac2317d1a471da35396a22aa09f2fa
+size 572835

main/tornado/GS/tornado_streamline.py

@@ -0,0 +1,350 @@
+# state file generated using paraview version 5.12.1
+import paraview
+paraview.compatibility.major = 5
+paraview.compatibility.minor = 12
+
+#### import the simple module from the paraview
+from paraview.simple import *
+#### disable automatic camera reset on 'Show'
+paraview.simple._DisableFirstRenderCameraReset()
+
+# ----------------------------------------------------------------
+# setup views used in the visualization
+# ----------------------------------------------------------------
+
+# get the material library
+materialLibrary1 = GetMaterialLibrary()
+
+# Create a new 'Render View'
+renderView1 = CreateView('RenderView')
+renderView1.ViewSize = [1287, 991]
+renderView1.AxesGrid = 'Grid Axes 3D Actor'
+renderView1.CenterOfRotation = [31.5, 31.5, 31.5]
+renderView1.StereoType = 'Crystal Eyes'
+renderView1.CameraPosition = [142.00635165079808, -36.455070670229986, 93.9571039660573]
+renderView1.CameraFocalPoint = [31.4999999999997, 31.499999999999897, 31.499999999999904]
+renderView1.CameraViewUp = [-0.35389758983672587, 0.25226015030630783, 0.9006227359306425]
+renderView1.CameraFocalDisk = 1.0
+renderView1.CameraParallelScale = 54.559600438419636
+renderView1.LegendGrid = 'Legend Grid Actor'
+renderView1.UseColorPaletteForBackground = 0
+renderView1.Background = [1.0, 1.0, 1.0]
+renderView1.BackEnd = 'OSPRay raycaster'
+renderView1.OSPRayMaterialLibrary = materialLibrary1
+
+SetActiveView(None)
+
+# ----------------------------------------------------------------
+# setup view layouts
+# ----------------------------------------------------------------
+
+# create new layout object 'Layout #1'
+layout1 = CreateLayout(name='Layout #1')
+layout1.AssignView(0, renderView1)
+layout1.SetSize(1287, 991)
+
+# ----------------------------------------------------------------
+# restore active view
+SetActiveView(renderView1)
+# ----------------------------------------------------------------
+
+# ----------------------------------------------------------------
+# setup the data processing pipelines
+# ----------------------------------------------------------------
+
+# create a new 'Image Reader'
+tornadoraw = ImageReader(registrationName='tornado.raw', FileNames=['/home/dullpigeon/Desktop/SciVisAgentTask/tornado/tornado.raw'])
+tornadoraw.DataScalarType = 'float'
+tornadoraw.DataByteOrder = 'LittleEndian'
+tornadoraw.NumberOfScalarComponents = 3
+tornadoraw.ScalarArrayName = 'Velocity'
+tornadoraw.DataExtent = [0, 63, 0, 63, 0, 63]
+
+# create a new 'Stream Tracer'
+streamTracer1 = StreamTracer(registrationName='StreamTracer1', Input=tornadoraw,
+    SeedType='Point Cloud')
+streamTracer1.Vectors = ['POINTS', 'Velocity']
+streamTracer1.MaximumStreamlineLength = 512.0
+
+# init the 'Point Cloud' selected for 'SeedType'
+streamTracer1.SeedType.Center = [31.5, 31.5, 47.25]
+streamTracer1.SeedType.Radius = 12.6
+
+# create a new 'Tube'
+tube1 = Tube(registrationName='Tube1', Input=streamTracer1)
+tube1.Scalars = ['POINTS', 'AngularVelocity']
+tube1.Vectors = ['POINTS', 'Normals']
+tube1.Radius = 0.25
+
+# create a new 'Glyph'
+glyph1 = Glyph(registrationName='Glyph1', Input=tornadoraw,
+    GlyphType='Arrow')
+glyph1.OrientationArray = ['POINTS', 'Velocity']
+glyph1.ScaleArray = ['POINTS', 'Velocity']
+glyph1.ScaleFactor = 25.0
+glyph1.GlyphTransform = 'Transform2'
+glyph1.MaximumNumberOfSamplePoints = 2500
+
+# init the 'Arrow' selected for 'GlyphType'
+glyph1.GlyphType.TipResolution = 24
+glyph1.GlyphType.TipRadius = 0.08
+glyph1.GlyphType.TipLength = 0.2
+glyph1.GlyphType.ShaftResolution = 8
+
+# create a new 'Outline'
+outline1 = Outline(registrationName='Outline1', Input=tornadoraw)
+
+# ----------------------------------------------------------------
+# setup the visualization in view 'renderView1'
+# ----------------------------------------------------------------
+
+# show data from glyph1
+glyph1Display = Show(glyph1, renderView1, 'GeometryRepresentation')
+
+# get 2D transfer function for 'Velocity'
+velocityTF2D = GetTransferFunction2D('Velocity')
+velocityTF2D.ScalarRangeInitialized = 1
+velocityTF2D.Range = [0.02983434216897271, 0.31328205773514267, 0.0, 1.0]
+
+# get color transfer function/color map for 'Velocity'
+velocityLUT = GetColorTransferFunction('Velocity')
+velocityLUT.TransferFunction2D = velocityTF2D
+velocityLUT.RGBPoints = [0.02983434216897271, 0.23137254902, 0.298039215686, 0.752941176471, 0.16801510751247406, 0.865, 0.865, 0.865, 0.3132820577351427, 0.705882352941, 0.0156862745098, 0.149019607843]
+velocityLUT.ScalarRangeInitialized = 1.0
+
+# trace defaults for the display properties.
+glyph1Display.Representation = 'Surface'
+glyph1Display.ColorArrayName = ['POINTS', 'Velocity']
+glyph1Display.LookupTable = velocityLUT
+glyph1Display.SelectTCoordArray = 'None'
+glyph1Display.SelectNormalArray = 'None'
+glyph1Display.SelectTangentArray = 'None'
+glyph1Display.OSPRayScaleArray = 'Velocity'
+glyph1Display.OSPRayScaleFunction = 'Piecewise Function'
+glyph1Display.Assembly = ''
+glyph1Display.SelectOrientationVectors = 'None'
+glyph1Display.ScaleFactor = 6.3945152282714846
+glyph1Display.SelectScaleArray = 'Velocity'
+glyph1Display.GlyphType = 'Arrow'
+glyph1Display.GlyphTableIndexArray = 'Velocity'
+glyph1Display.GaussianRadius = 0.3197257614135742
+glyph1Display.SetScaleArray = ['POINTS', 'Velocity']
+glyph1Display.ScaleTransferFunction = 'Piecewise Function'
+glyph1Display.OpacityArray = ['POINTS', 'Velocity']
+glyph1Display.OpacityTransferFunction = 'Piecewise Function'
+glyph1Display.DataAxesGrid = 'Grid Axes Representation'
+glyph1Display.PolarAxes = 'Polar Axes Representation'
+glyph1Display.SelectInputVectors = ['POINTS', 'Velocity']
+glyph1Display.WriteLog = ''
+
+# init the 'Piecewise Function' selected for 'ScaleTransferFunction'
+glyph1Display.ScaleTransferFunction.Points = [-0.3067080080509186, 0.0, 0.5, 0.0, 0.29407399892807007, 1.0, 0.5, 0.0]
+
+# init the 'Piecewise Function' selected for 'OpacityTransferFunction'
+glyph1Display.OpacityTransferFunction.Points = [-0.3067080080509186, 0.0, 0.5, 0.0, 0.29407399892807007, 1.0, 0.5, 0.0]
+
+# init the 'Polar Axes Representation' selected for 'PolarAxes'
+glyph1Display.PolarAxes.EnableOverallColor = 0
+glyph1Display.PolarAxes.DeltaRangeMajor = 10.0
+glyph1Display.PolarAxes.DeltaRangeMinor = 5.0
+glyph1Display.PolarAxes.ArcTickMatchesRadialAxes = 0
+
+# show data from streamTracer1
+streamTracer1Display = Show(streamTracer1, renderView1, 'GeometryRepresentation')
+
+# trace defaults for the display properties.
+streamTracer1Display.Representation = 'Surface'
+streamTracer1Display.ColorArrayName = ['POINTS', 'Velocity']
+streamTracer1Display.LookupTable = velocityLUT
+streamTracer1Display.PointSize = 3.0
+streamTracer1Display.LineWidth = 5.0
+streamTracer1Display.RenderLinesAsTubes = 1
+streamTracer1Display.SelectTCoordArray = 'None'
+streamTracer1Display.SelectNormalArray = 'None'
+streamTracer1Display.SelectTangentArray = 'None'
+streamTracer1Display.OSPRayScaleArray = 'Velocity'
+streamTracer1Display.OSPRayScaleFunction = 'Piecewise Function'
+streamTracer1Display.Assembly = ''
+streamTracer1Display.SelectOrientationVectors = 'Normals'
+streamTracer1Display.ScaleFactor = 6.1539682984352115
+streamTracer1Display.SelectScaleArray = 'Velocity'
+streamTracer1Display.GlyphType = 'Arrow'
+streamTracer1Display.GlyphTableIndexArray = 'Velocity'
+streamTracer1Display.GaussianRadius = 0.3076984149217606
+streamTracer1Display.SetScaleArray = ['POINTS', 'Velocity']
+streamTracer1Display.ScaleTransferFunction = 'Piecewise Function'
+streamTracer1Display.OpacityArray = ['POINTS', 'Velocity']
+streamTracer1Display.OpacityTransferFunction = 'Piecewise Function'
+streamTracer1Display.DataAxesGrid = 'Grid Axes Representation'
+streamTracer1Display.PolarAxes = 'Polar Axes Representation'
+streamTracer1Display.SelectInputVectors = ['POINTS', 'Normals']
+streamTracer1Display.WriteLog = ''
+
+# init the 'Piecewise Function' selected for 'ScaleTransferFunction'
+streamTracer1Display.ScaleTransferFunction.Points = [-0.2852635979652405, 0.0, 0.5, 0.0, 0.26630979776382446, 1.0, 0.5, 0.0]
+
+# init the 'Piecewise Function' selected for 'OpacityTransferFunction'
+streamTracer1Display.OpacityTransferFunction.Points = [-0.2852635979652405, 0.0, 0.5, 0.0, 0.26630979776382446, 1.0, 0.5, 0.0]
+
+# init the 'Polar Axes Representation' selected for 'PolarAxes'
+streamTracer1Display.PolarAxes.EnableOverallColor = 0
+streamTracer1Display.PolarAxes.DeltaRangeMajor = 10.0
+streamTracer1Display.PolarAxes.DeltaRangeMinor = 5.0
+streamTracer1Display.PolarAxes.ArcTickMatchesRadialAxes = 0
+
+# show data from outline1
+outline1Display = Show(outline1, renderView1, 'GeometryRepresentation')
+
+# trace defaults for the display properties.
+outline1Display.Representation = 'Surface'
+outline1Display.AmbientColor = [0.0, 0.0, 0.0]
+outline1Display.ColorArrayName = [None, '']
+outline1Display.DiffuseColor = [0.0, 0.0, 0.0]
+outline1Display.SelectTCoordArray = 'None'
+outline1Display.SelectNormalArray = 'None'
+outline1Display.SelectTangentArray = 'None'
+outline1Display.OSPRayScaleFunction = 'Piecewise Function'
+outline1Display.Assembly = ''
+outline1Display.SelectOrientationVectors = 'None'
+outline1Display.ScaleFactor = 6.300000000000001
+outline1Display.SelectScaleArray = 'None'
+outline1Display.GlyphType = 'Arrow'
+outline1Display.GlyphTableIndexArray = 'None'
+outline1Display.GaussianRadius = 0.315
+outline1Display.SetScaleArray = [None, '']
+outline1Display.ScaleTransferFunction = 'Piecewise Function'
+outline1Display.OpacityArray = [None, '']
+outline1Display.OpacityTransferFunction = 'Piecewise Function'
+outline1Display.DataAxesGrid = 'Grid Axes Representation'
+outline1Display.PolarAxes = 'Polar Axes Representation'
+outline1Display.SelectInputVectors = [None, '']
+outline1Display.WriteLog = ''
+
+# init the 'Polar Axes Representation' selected for 'PolarAxes'
+outline1Display.PolarAxes.EnableOverallColor = 0
+outline1Display.PolarAxes.DeltaRangeMajor = 10.0
+outline1Display.PolarAxes.DeltaRangeMinor = 5.0
+outline1Display.PolarAxes.ArcTickMatchesRadialAxes = 0
+
+# show data from tube1
+tube1Display = Show(tube1, renderView1, 'GeometryRepresentation')
+
+# trace defaults for the display properties.
+tube1Display.Representation = 'Surface'
+tube1Display.ColorArrayName = ['POINTS', 'Velocity']
+tube1Display.LookupTable = velocityLUT
+tube1Display.SelectTCoordArray = 'None'
+tube1Display.SelectNormalArray = 'TubeNormals'
+tube1Display.SelectTangentArray = 'None'
+tube1Display.OSPRayScaleArray = 'Velocity'
+tube1Display.OSPRayScaleFunction = 'Piecewise Function'
+tube1Display.Assembly = ''
+tube1Display.SelectOrientationVectors = 'Normals'
+tube1Display.ScaleFactor = 6.237804853916169
+tube1Display.SelectScaleArray = 'Velocity'
+tube1Display.GlyphType = 'Arrow'
+tube1Display.GlyphTableIndexArray = 'Velocity'
+tube1Display.GaussianRadius = 0.3118902426958084
+tube1Display.SetScaleArray = ['POINTS', 'Velocity']
+tube1Display.ScaleTransferFunction = 'Piecewise Function'
+tube1Display.OpacityArray = ['POINTS', 'Velocity']
+tube1Display.OpacityTransferFunction = 'Piecewise Function'
+tube1Display.DataAxesGrid = 'Grid Axes Representation'
+tube1Display.PolarAxes = 'Polar Axes Representation'
+tube1Display.SelectInputVectors = ['POINTS', 'Normals']
+tube1Display.WriteLog = ''
+
+# init the 'Piecewise Function' selected for 'ScaleTransferFunction'
+tube1Display.ScaleTransferFunction.Points = [-0.2852635979652405, 0.0, 0.5, 0.0, 0.26630979776382446, 1.0, 0.5, 0.0]
+
+# init the 'Piecewise Function' selected for 'OpacityTransferFunction'
+tube1Display.OpacityTransferFunction.Points = [-0.2852635979652405, 0.0, 0.5, 0.0, 0.26630979776382446, 1.0, 0.5, 0.0]
+
+# init the 'Polar Axes Representation' selected for 'PolarAxes'
+tube1Display.PolarAxes.EnableOverallColor = 0
+tube1Display.PolarAxes.DeltaRangeMajor = 10.0
+tube1Display.PolarAxes.DeltaRangeMinor = 5.0
+tube1Display.PolarAxes.ArcTickMatchesRadialAxes = 0
+
+# setup the color legend parameters for each legend in this view
+
+# get color legend/bar for velocityLUT in view renderView1
+velocityLUTColorBar = GetScalarBar(velocityLUT, renderView1)
+velocityLUTColorBar.WindowLocation = 'Any Location'
+velocityLUTColorBar.Position = [0.8508873456790124, 0.04661016949152543]
+velocityLUTColorBar.Title = ''
+velocityLUTColorBar.ComponentTitle = ''
+velocityLUTColorBar.TitleColor = [0.0, 0.0, 0.0]
+velocityLUTColorBar.LabelColor = [0.0, 0.0, 0.0]
+velocityLUTColorBar.ScalarBarLength = 0.3300000000000002
+
+# set color bar visibility
+velocityLUTColorBar.Visibility = 1
+
+# show color legend
+glyph1Display.SetScalarBarVisibility(renderView1, True)
+
+# show color legend
+streamTracer1Display.SetScalarBarVisibility(renderView1, True)
+
+# show color legend
+tube1Display.SetScalarBarVisibility(renderView1, True)
+
+# ----------------------------------------------------------------
+# setup color maps and opacity maps used in the visualization
+# note: the Get..() functions create a new object, if needed
+# ----------------------------------------------------------------
+
+# get opacity transfer function/opacity map for 'Velocity'
+velocityPWF = GetOpacityTransferFunction('Velocity')
+velocityPWF.Points = [0.02983434216897271, 0.0, 0.5, 0.0, 0.10185037553310394, 0.0, 0.5, 0.0, 0.10185037553310394, 0.0, 0.5, 0.0, 0.18130171298980713, 0.14189189672470093, 0.5, 0.0, 0.23887702822685242, 0.9076576828956604, 0.5, 0.0, 0.2893661558628082, 0.0, 0.5, 0.0, 0.3132820577351427, 0.0, 0.5, 0.0]
+velocityPWF.ScalarRangeInitialized = 1
+
+# ----------------------------------------------------------------
+# setup animation scene, tracks and keyframes
+# note: the Get..() functions create a new object, if needed
+# ----------------------------------------------------------------
+
+# get time animation track
+timeAnimationCue1 = GetTimeTrack()
+
+# initialize the animation scene
+
+# get the time-keeper
+timeKeeper1 = GetTimeKeeper()
+
+# initialize the timekeeper
+
+# initialize the animation track
+
+# get animation scene
+animationScene1 = GetAnimationScene()
+
+# initialize the animation scene
+animationScene1.ViewModules = renderView1
+animationScene1.Cues = timeAnimationCue1
+animationScene1.AnimationTime = 0.0
+
+# ----------------------------------------------------------------
+# restore active source
+SetActiveSource(None)
+# ----------------------------------------------------------------
+
+# ============= Render and Save =============
+Render()
+
+OUTPUT_IMAGE = "/home/dullpigeon/Desktop/SciVisAgentTask/tornado/tornado_streamline.png"
+OUTPUT_STATE = "/home/dullpigeon/Desktop/SciVisAgentTask/tornado/tornado_streamline.pvsm"
+
+renderView = GetActiveView()
+if renderView is None:
+    views = GetViews()
+    if views:
+        renderView = views[0]
+
+SaveScreenshot(OUTPUT_IMAGE, renderView, ImageResolution=renderView.ViewSize,
+               OverrideColorPalette="WhiteBackground")
+print(f"Screenshot saved to: {OUTPUT_IMAGE}")
+
+SaveState(OUTPUT_STATE)
+print(f"State saved to: {OUTPUT_STATE}")

main/tornado/task_description.txt

@@ -1,19 +1,19 @@
-Task:
-
-Load the tornado dataset from "tornado/data/tornado_64x64x64_float32_scalar3.raw", the information about this dataset:
+Load the Tornado vector field from "tornado/data/tornado.raw", the information about this dataset:
 Tornado (Vector)
 Data Scalar Type: float
-Data Byte Order: little Endian
+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.
 
-Add a “glyph” filter under the tornado data to display velocity glyph, set an appropriate “Scale Factor” so the glyphs are visible.
-
-Then add a “stream tracer” filter under the tornado data to generate streamlines. Choose “Point Cloud” as “Seed Type”, and do not show sphere. Try to figure out the best position to place the critical points and the radius of the sphere for optimal visualization.
+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 “tube” filter under the stream tracer you just created to generate tubes for visualizing the streamlines. Set an appropriate radius. Make the stream tracer invisible and the tube visible. At last, render the streamlines as tubes.
+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.
 
-Please think step by step and make sure to fulfill all the visualization goals mentioned above.
+Add an "Outline" filter to display the dataset bounding box (black).
 
-Finally, save the paraview state as "tornado/results/{agent_mode}/tornado.pvsm"
+Use a white background (RGB: 1.0, 1.0, 1.0).
+Save the paraview state as "tornado/results/{agent_mode}/tornado.pvsm".
+Save the visualization image as "tornado/results/{agent_mode}/tornado.png".
+(Optional, if use python script) Save the python script as "tornado/results/{agent_mode}/tornado.py".
+Do not save any other files, and always save the visualization image.

main/tornado/visualization_goals.txt

@@ -1,7 +1,4 @@
-1. Overall Visualization Goal: How well does the result achieve the overall goal of showing tornado flow patterns with glyphs and streamlines?
-
-2. Glyph Visualization: Does the result show velocity glyphs that are appropriately sized and visible?
-
-3. Streamline Visualization: Does the result show streamlines that follow the flow patterns effectively?
-
-4. Tube Rendering: Are the streamlines rendered as tubes with appropriate thickness?
+vision:
+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?

main/twoswirls/GS/twoswirls_streamsurface.pvsm

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:d00da8282992874067ce3959dc60f9347cef6fa590579b7f108c1a055aa688b8
+size 467600

main/twoswirls/GS/twoswirls_streamsurface.py

@@ -0,0 +1,306 @@
+# state file generated using paraview version 5.12.1
+import paraview
+paraview.compatibility.major = 5
+paraview.compatibility.minor = 12
+
+#### import the simple module from the paraview
+from paraview.simple import *
+#### disable automatic camera reset on 'Show'
+paraview.simple._DisableFirstRenderCameraReset()
+
+# ----------------------------------------------------------------
+# setup views used in the visualization
+# ----------------------------------------------------------------
+
+# get the material library
+materialLibrary1 = GetMaterialLibrary()
+
+# Create a new 'Render View'
+renderView1 = CreateView('RenderView')
+renderView1.ViewSize = [1287, 991]
+renderView1.AxesGrid = 'Grid Axes 3D Actor'
+renderView1.KeyLightWarmth = 0.5
+renderView1.KeyLightIntensity = 0.9
+renderView1.StereoType = 'Crystal Eyes'
+renderView1.CameraPosition = [30.506557822227478, -154.18388926659551, 144.98737090119556]
+renderView1.CameraFocalPoint = [30.506557822227478, 31.5, 30.91251516342163]
+renderView1.CameraViewUp = [0.0, 0.52999894000318, 0.847998304005088]
+renderView1.CameraFocalDisk = 1.0
+renderView1.CameraParallelScale = 56.403303005016504
+renderView1.LegendGrid = 'Legend Grid Actor'
+renderView1.Background = [1.0, 1.0, 1.0]
+renderView1.BackEnd = 'OSPRay raycaster'
+renderView1.OSPRayMaterialLibrary = materialLibrary1
+
+SetActiveView(None)
+
+# ----------------------------------------------------------------
+# setup view layouts
+# ----------------------------------------------------------------
+
+# create new layout object 'Layout'
+layout = CreateLayout(name='Layout')
+layout.AssignView(0, renderView1)
+layout.SetSize(1287, 991)
+
+# ----------------------------------------------------------------
+# restore active view
+SetActiveView(renderView1)
+# ----------------------------------------------------------------
+
+# ----------------------------------------------------------------
+# setup the data processing pipelines
+# ----------------------------------------------------------------
+
+# create a new 'Image Reader'
+imageReader1 = ImageReader(registrationName='ImageReader1', FileNames=['/home/dullpigeon/Desktop/SciVisAgentTask/twoswirls/twoswirls.raw'])
+imageReader1.DataScalarType = 'float'
+imageReader1.DataByteOrder = 'LittleEndian'
+imageReader1.NumberOfScalarComponents = 3
+imageReader1.DataExtent = [0, 63, 0, 63, 0, 63]
+
+# create a new 'Stream Tracer'
+streamTracer1 = StreamTracer(registrationName='StreamTracer1', Input=imageReader1,
+    SeedType='Line')
+streamTracer1.Vectors = ['POINTS', 'ImageFile']
+streamTracer1.MaximumStreamlineLength = 200.0
+
+# init the 'Line' selected for 'SeedType'
+streamTracer1.SeedType.Point1 = [16.0, 10.0, 32.0]
+streamTracer1.SeedType.Point2 = [16.0, 54.0, 32.0]
+streamTracer1.SeedType.Resolution = 25
+
+# create a new 'Stream Tracer'
+streamTracer3 = StreamTracer(registrationName='StreamTracer3', Input=imageReader1,
+    SeedType='Line')
+streamTracer3.Vectors = ['POINTS', 'ImageFile']
+streamTracer3.MaximumStreamlineLength = 200.0
+
+# init the 'Line' selected for 'SeedType'
+streamTracer3.SeedType.Point1 = [48.0, 10.0, 32.0]
+streamTracer3.SeedType.Point2 = [48.0, 54.0, 32.0]
+streamTracer3.SeedType.Resolution = 25
+
+# create a new 'Ribbon'
+ribbon3 = Ribbon(registrationName='Ribbon3', Input=streamTracer3)
+ribbon3.Scalars = ['POINTS', 'IntegrationTime']
+ribbon3.Vectors = ['POINTS', 'Normals']
+ribbon3.Width = 2.5
+
+# create a new 'Stream Tracer'
+streamTracer4 = StreamTracer(registrationName='StreamTracer4', Input=imageReader1,
+    SeedType='Line')
+streamTracer4.Vectors = ['POINTS', 'ImageFile']
+streamTracer4.MaximumStreamlineLength = 200.0
+
+# init the 'Line' selected for 'SeedType'
+streamTracer4.SeedType.Point1 = [44.0, 32.0, 10.0]
+streamTracer4.SeedType.Point2 = [44.0, 32.0, 54.0]
+streamTracer4.SeedType.Resolution = 25
+
+# create a new 'Ribbon'
+ribbon4 = Ribbon(registrationName='Ribbon4', Input=streamTracer4)
+ribbon4.Scalars = ['POINTS', 'IntegrationTime']
+ribbon4.Vectors = ['POINTS', 'Normals']
+ribbon4.Width = 2.5
+
+# create a new 'Stream Tracer'
+streamTracer2 = StreamTracer(registrationName='StreamTracer2', Input=imageReader1,
+    SeedType='Line')
+streamTracer2.Vectors = ['POINTS', 'ImageFile']
+streamTracer2.MaximumStreamlineLength = 200.0
+
+# init the 'Line' selected for 'SeedType'
+streamTracer2.SeedType.Point1 = [20.0, 32.0, 10.0]
+streamTracer2.SeedType.Point2 = [20.0, 32.0, 54.0]
+streamTracer2.SeedType.Resolution = 25
+
+# create a new 'Ribbon'
+ribbon2 = Ribbon(registrationName='Ribbon2', Input=streamTracer2)
+ribbon2.Scalars = ['POINTS', 'IntegrationTime']
+ribbon2.Vectors = ['POINTS', 'Normals']
+ribbon2.Width = 2.5
+
+# create a new 'Ribbon'
+ribbon1 = Ribbon(registrationName='Ribbon1', Input=streamTracer1)
+ribbon1.Scalars = ['POINTS', 'IntegrationTime']
+ribbon1.Vectors = ['POINTS', 'Normals']
+ribbon1.Width = 2.5
+
+# ----------------------------------------------------------------
+# setup the visualization in view 'renderView1'
+# ----------------------------------------------------------------
+
+# show data from ribbon1
+ribbon1Display = Show(ribbon1, renderView1, 'GeometryRepresentation')
+
+# trace defaults for the display properties.
+ribbon1Display.Representation = 'Surface'
+ribbon1Display.AmbientColor = [0.2, 0.7, 0.3]
+ribbon1Display.ColorArrayName = ['POINTS', '']
+ribbon1Display.DiffuseColor = [0.2, 0.7, 0.3]
+ribbon1Display.Opacity = 0.35
+ribbon1Display.Specular = 0.4
+ribbon1Display.SpecularPower = 30.0
+ribbon1Display.Ambient = 0.15
+ribbon1Display.Diffuse = 0.75
+ribbon1Display.SelectTCoordArray = 'None'
+ribbon1Display.SelectNormalArray = 'None'
+ribbon1Display.SelectTangentArray = 'None'
+ribbon1Display.OSPRayScaleArray = 'ImageFile'
+ribbon1Display.OSPRayScaleFunction = 'Piecewise Function'
+ribbon1Display.Assembly = ''
+ribbon1Display.SelectOrientationVectors = 'Normals'
+ribbon1Display.ScaleFactor = 5.75545814037323
+ribbon1Display.SelectScaleArray = 'ImageFile'
+ribbon1Display.GlyphType = 'Arrow'
+ribbon1Display.GlyphTableIndexArray = 'ImageFile'
+ribbon1Display.GaussianRadius = 0.2877729070186615
+ribbon1Display.SetScaleArray = ['POINTS', 'ImageFile']
+ribbon1Display.ScaleTransferFunction = 'Piecewise Function'
+ribbon1Display.OpacityArray = ['POINTS', 'ImageFile']
+ribbon1Display.OpacityTransferFunction = 'Piecewise Function'
+ribbon1Display.DataAxesGrid = 'Grid Axes Representation'
+ribbon1Display.PolarAxes = 'Polar Axes Representation'
+ribbon1Display.SelectInputVectors = ['POINTS', 'Normals']
+ribbon1Display.WriteLog = ''
+
+# init the 'Piecewise Function' selected for 'ScaleTransferFunction'
+ribbon1Display.ScaleTransferFunction.Points = [-0.2651785612106323, 0.0, 0.5, 0.0, 0.4244382977485657, 1.0, 0.5, 0.0]
+
+# init the 'Piecewise Function' selected for 'OpacityTransferFunction'
+ribbon1Display.OpacityTransferFunction.Points = [-0.2651785612106323, 0.0, 0.5, 0.0, 0.4244382977485657, 1.0, 0.5, 0.0]
+
+# show data from ribbon3
+ribbon3Display = Show(ribbon3, renderView1, 'GeometryRepresentation')
+
+# trace defaults for the display properties.
+ribbon3Display.Representation = 'Surface'
+ribbon3Display.AmbientColor = [0.2, 0.4, 0.85]
+ribbon3Display.ColorArrayName = ['POINTS', '']
+ribbon3Display.DiffuseColor = [0.2, 0.4, 0.85]
+ribbon3Display.Opacity = 0.35
+ribbon3Display.Specular = 0.4
+ribbon3Display.SpecularPower = 30.0
+ribbon3Display.Ambient = 0.15
+ribbon3Display.Diffuse = 0.75
+ribbon3Display.SelectTCoordArray = 'None'
+ribbon3Display.SelectNormalArray = 'None'
+ribbon3Display.SelectTangentArray = 'None'
+ribbon3Display.OSPRayScaleArray = 'ImageFile'
+ribbon3Display.OSPRayScaleFunction = 'Piecewise Function'
+ribbon3Display.Assembly = ''
+ribbon3Display.SelectOrientationVectors = 'Normals'
+ribbon3Display.ScaleFactor = 6.492923521995545
+ribbon3Display.SelectScaleArray = 'ImageFile'
+ribbon3Display.GlyphType = 'Arrow'
+ribbon3Display.GlyphTableIndexArray = 'ImageFile'
+ribbon3Display.GaussianRadius = 0.32464617609977725
+ribbon3Display.SetScaleArray = ['POINTS', 'ImageFile']
+ribbon3Display.ScaleTransferFunction = 'Piecewise Function'
+ribbon3Display.OpacityArray = ['POINTS', 'ImageFile']
+ribbon3Display.OpacityTransferFunction = 'Piecewise Function'
+ribbon3Display.DataAxesGrid = 'Grid Axes Representation'
+ribbon3Display.PolarAxes = 'Polar Axes Representation'
+ribbon3Display.SelectInputVectors = ['POINTS', 'Normals']
+ribbon3Display.WriteLog = ''
+
+# init the 'Piecewise Function' selected for 'ScaleTransferFunction'
+ribbon3Display.ScaleTransferFunction.Points = [-0.332985520362854, 0.0, 0.5, 0.0, 0.2668702304363251, 1.0, 0.5, 0.0]
+
+# init the 'Piecewise Function' selected for 'OpacityTransferFunction'
+ribbon3Display.OpacityTransferFunction.Points = [-0.332985520362854, 0.0, 0.5, 0.0, 0.2668702304363251, 1.0, 0.5, 0.0]
+
+# show data from imageReader1
+imageReader1Display = Show(imageReader1, renderView1, 'UniformGridRepresentation')
+
+# trace defaults for the display properties.
+imageReader1Display.Representation = 'Outline'
+imageReader1Display.AmbientColor = [0.0, 0.0, 0.0]
+imageReader1Display.ColorArrayName = ['POINTS', '']
+imageReader1Display.DiffuseColor = [0.0, 0.0, 0.0]
+imageReader1Display.Opacity = 0.3
+imageReader1Display.SelectTCoordArray = 'None'
+imageReader1Display.SelectNormalArray = 'None'
+imageReader1Display.SelectTangentArray = 'None'
+imageReader1Display.OSPRayScaleArray = 'ImageFile'
+imageReader1Display.OSPRayScaleFunction = 'Piecewise Function'
+imageReader1Display.Assembly = ''
+imageReader1Display.SelectOrientationVectors = 'ImageFile'
+imageReader1Display.ScaleFactor = 6.300000000000001
+imageReader1Display.SelectScaleArray = 'ImageFile'
+imageReader1Display.GlyphType = 'Arrow'
+imageReader1Display.GlyphTableIndexArray = 'ImageFile'
+imageReader1Display.GaussianRadius = 0.315
+imageReader1Display.SetScaleArray = ['POINTS', 'ImageFile']
+imageReader1Display.ScaleTransferFunction = 'Piecewise Function'
+imageReader1Display.OpacityArray = ['POINTS', 'ImageFile']
+imageReader1Display.OpacityTransferFunction = 'Piecewise Function'
+imageReader1Display.DataAxesGrid = 'Grid Axes Representation'
+imageReader1Display.PolarAxes = 'Polar Axes Representation'
+imageReader1Display.ScalarOpacityUnitDistance = 1.7320508075688774
+imageReader1Display.OpacityArrayName = ['POINTS', 'ImageFile']
+imageReader1Display.ColorArray2Name = ['POINTS', 'ImageFile']
+imageReader1Display.IsosurfaceValues = [0.036316871643066406]
+imageReader1Display.SliceFunction = 'Plane'
+imageReader1Display.Slice = 31
+imageReader1Display.SelectInputVectors = ['POINTS', 'ImageFile']
+imageReader1Display.WriteLog = ''
+
+# init the 'Piecewise Function' selected for 'ScaleTransferFunction'
+imageReader1Display.ScaleTransferFunction.Points = [-0.3535566031932831, 0.0, 0.5, 0.0, 0.4261903464794159, 1.0, 0.5, 0.0]
+
+# init the 'Piecewise Function' selected for 'OpacityTransferFunction'
+imageReader1Display.OpacityTransferFunction.Points = [-0.3535566031932831, 0.0, 0.5, 0.0, 0.4261903464794159, 1.0, 0.5, 0.0]
+
+# init the 'Plane' selected for 'SliceFunction'
+imageReader1Display.SliceFunction.Origin = [31.5, 31.5, 31.5]
+
+# ----------------------------------------------------------------
+# setup animation scene, tracks and keyframes
+# note: the Get..() functions create a new object, if needed
+# ----------------------------------------------------------------
+
+# get the time-keeper
+timeKeeper1 = GetTimeKeeper()
+
+# initialize the timekeeper
+
+# get time animation track
+timeAnimationCue1 = GetTimeTrack()
+
+# initialize the animation track
+
+# get animation scene
+animationScene1 = GetAnimationScene()
+
+# initialize the animation scene
+animationScene1.ViewModules = renderView1
+animationScene1.Cues = timeAnimationCue1
+animationScene1.AnimationTime = 0.0
+
+# initialize the animation scene
+
+# ----------------------------------------------------------------
+# restore active source
+SetActiveSource(None)
+# ----------------------------------------------------------------
+
+# ============= Render and Save =============
+Render()
+
+OUTPUT_IMAGE = '/home/dullpigeon/Desktop/SciVisAgentTask/twoswirls/twoswirls_streamsurface.png'
+OUTPUT_STATE = '/home/dullpigeon/Desktop/SciVisAgentTask/twoswirls/twoswirls_streamsurface.pvsm'
+
+# Find the render view
+renderView = GetActiveView()
+if renderView is None:
+    views = GetViews()
+    if views:
+        renderView = views[0]
+
+SaveScreenshot(OUTPUT_IMAGE, renderView, ImageResolution=renderView.ViewSize)
+print(f"Screenshot saved to: {OUTPUT_IMAGE}")
+
+SaveState(OUTPUT_STATE)
+print(f"State saved to: {OUTPUT_STATE}")

main/twoswirls/data/twoswirls.raw

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e8401828e1133e1ac2f633b43ba62edfa05298c8e9d001d375cccfea0e638331
+size 3145728

main/twoswirls/data/twoswirls.txt

@@ -0,0 +1,2 @@
+64 64 64
+vector

main/twoswirls/task_description.txt

@@ -0,0 +1,23 @@
+Load the Two Swirls vector field from "twoswirls/data/twoswirls.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 four stream surfaces using "Stream Tracer" filters with "Line" seed type (resolution 25 points each), and apply a "Ribbon" filter (width 2.5) to each:
+- Stream Surface 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 Surface 2: Line seed from [20, 32, 10] to [20, 32, 54]. Ribbon with opacity 0.35.
+- Stream Surface 3: 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.
+- Stream Surface 4: Line seed from [44, 32, 10] to [44, 32, 54]. Ribbon 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).
+Save the paraview state as "twoswirls/results/{agent_mode}/twoswirls.pvsm".
+Save the visualization image as "twoswirls/results/{agent_mode}/twoswirls.png".
+(Optional, if use python script) Save the python script as "twoswirls/results/{agent_mode}/twoswirls.py".
+Do not save any other files, and always save the visualization image.

main/twoswirls/visualization_goals.txt

@@ -0,0 +1,5 @@
+vision:
+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 Surface Shape: Do the ribbon surfaces show wrapped, swirling sheet-like structures similar to the ground truth?
+3. Color and Transparency: Are the stream surfaces rendered with distinct colors (green and blue) and semi-transparency, similar to the ground truth?
+