Merge pull request #1290 from maharshi-gor/analyze-snapshot-tests

MNT: Added analyze-snapshot test cases.

Author: skoudoro

docs/examples/viz_solar_system.py

@@ -279,4 +279,4 @@ def update_playback_logic(show_manager_obj=None):
 
     showm.start()
 
-showm.snapshot("viz_solar_system_animation.png")
+showm.snapshot(fname="viz_solar_system_animation.png")

fury/__init__.pyi

@@ -154,6 +154,7 @@ from .colormap import (
     _xyz2rgb as _xyz2rgb,
     boys2rgb as boys2rgb,
     cc as cc,
+    colors_to_uint8 as colors_to_uint8,
     #     colormap_lookup_table as colormap_lookup_table,
     create_colormap as create_colormap,
     distinguishable_colormap as distinguishable_colormap,

fury/actor/tests/_helpers.py

@@ -6,6 +6,122 @@
 
 from fury import actor, window
 
+# --- Shared real inputs for visibility/snapshot tests -----------------------
+
+CENTERS = np.array([[0.0, 0.0, 0.0]], dtype=np.float32)
+LINES = [np.array([[0, 0, 0], [1, 1, 1], [2, 0, 0]], dtype=np.float32)]
+
+
+def gradient_image(n=64):
+    """A non-uniform 2D image so the rendered frame is never flat."""
+    ramp = np.linspace(0.0, 1.0, n, dtype=np.float32)
+    return np.outer(ramp, ramp)
+
+
+def scalar_volume(n=32):
+    """A non-uniform 3D scalar volume (deterministic)."""
+    x, y, z = np.mgrid[0:n, 0:n, 0:n]
+    return ((x + y + z) % 17).astype(np.float32)
+
+
+def roi_volume(n=20):
+    """A binary volume with a solid central cube (for contour actors)."""
+    data = np.zeros((n, n, n), dtype=np.float32)
+    data[5:15, 5:15, 5:15] = 1.0
+    return data
+
+
+def label_volume(n=20):
+    """A labeled volume with one nonzero region."""
+    data = np.zeros((n, n, n), dtype=int)
+    data[5:15, 5:15, 5:15] = 1
+    return data
+
+
+def peak_dirs(n=8):
+    """A (X, Y, Z, 3, 3) field of unit peak directions."""
+    dirs = np.zeros((n, n, n, 3, 3), dtype=np.float32)
+    dirs[..., 0, :] = (1.0, 0.0, 0.0)
+    dirs[..., 1, :] = (0.0, 1.0, 0.0)
+    dirs[..., 2, :] = (0.0, 0.0, 1.0)
+    return dirs
+
+
+def vector_field_data(n=8):
+    """A (X, Y, Z, 3) field of unit vectors."""
+    field = np.zeros((n, n, n, 3), dtype=np.float32)
+    field[...] = (1.0, 0.0, 0.0)
+    return field
+
+
+def sph_coeffs(n=4, ncoeff=15):
+    """SH coefficients with only the l=0 term -> isotropic visible glyphs."""
+    coeffs = np.zeros((n, n, n, ncoeff), dtype=np.float32)
+    coeffs[..., 0] = 1.0
+    return coeffs
+
+
+def triangle_mesh():
+    """A single-triangle (vertices, faces) pair for surface actors."""
+    verts = np.array([[0, 0, 0], [1, 0, 0], [0, 1, 0]], dtype=np.float32)
+    faces = np.array([[0, 1, 2]], dtype=np.int32)
+    return verts, faces
+
+
+# The full set of renderable actors keyed by id. Each value is a factory that
+# builds a fresh actor (with real inputs) on every call.
+ACTOR_FACTORIES = {
+    # Planar / polyhedron / curved mesh primitives (centers only).
+    "square": lambda: actor.square(CENTERS),
+    "triangle": lambda: actor.triangle(CENTERS),
+    "star": lambda: actor.star(CENTERS),
+    "disk": lambda: actor.disk(CENTERS),
+    "ring": lambda: actor.ring(CENTERS),
+    "box": lambda: actor.box(CENTERS),
+    "tetrahedron": lambda: actor.tetrahedron(CENTERS),
+    "icosahedron": lambda: actor.icosahedron(CENTERS),
+    "triangularprism": lambda: actor.triangularprism(CENTERS),
+    "pentagonalprism": lambda: actor.pentagonalprism(CENTERS),
+    "octagonalprism": lambda: actor.octagonalprism(CENTERS),
+    "rhombicuboctahedron": lambda: actor.rhombicuboctahedron(CENTERS),
+    "frustum": lambda: actor.frustum(CENTERS),
+    "superquadric": lambda: actor.superquadric(CENTERS),
+    "cylinder": lambda: actor.cylinder(CENTERS),
+    "cone": lambda: actor.cone(CENTERS),
+    "arrow": lambda: actor.arrow(CENTERS),
+    "sphere": lambda: actor.sphere(CENTERS),
+    "ellipsoid": lambda: actor.ellipsoid(CENTERS),
+    # Points / billboards.
+    "point": lambda: actor.point(CENTERS),
+    "marker": lambda: actor.marker(CENTERS),
+    "billboard": lambda: actor.billboard(CENTERS),
+    "billboard_sphere": lambda: actor.billboard_sphere(CENTERS),
+    # Axes (no required args).
+    "axes": lambda: actor.axes(),
+    # Text / image.
+    "text": lambda: actor.text("FURY"),
+    "image": lambda: actor.image(gradient_image()),
+    # Line / streamline family.
+    "line": lambda: actor.line(LINES),
+    "streamlines": lambda: actor.streamlines(LINES),
+    "streamtube": lambda: actor.streamtube(LINES),
+    "line_projection": lambda: actor.line_projection(LINES),
+    # Surface.
+    "surface": lambda: actor.surface(*triangle_mesh()),
+    # Volume / field / glyph slicers (return single actors or groups; both are
+    # hidden by setting ``.visible`` on the returned object).
+    "data_slicer": lambda: actor.data_slicer(scalar_volume()),
+    "volume_slicer": lambda: actor.volume_slicer(scalar_volume()),
+    "peaks_slicer": lambda: actor.peaks_slicer(peak_dirs()),
+    "vector_field": lambda: actor.vector_field(vector_field_data()),
+    "vector_field_slicer": lambda: actor.vector_field_slicer(vector_field_data()),
+    "sph_glyph": lambda: actor.sph_glyph(sph_coeffs()),
+    # Contours (need a solid block to produce geometry).
+    "contour_from_volume": lambda: actor.contour_from_volume(roi_volume()),
+    "contour_from_roi": lambda: actor.contour_from_roi(roi_volume()),
+    "contour_from_label": lambda: actor.contour_from_label(label_volume()),
+}
+
 
 def random_png(width, height):
     """
@@ -55,43 +171,42 @@ def validate_actors(actor_type="actor_name", prim_count=1, **kwargs):
     if actor_type == "line":
         return
 
-    fname = f"{actor_type}_test.png"
-    window.snapshot(scene=scene, fname=fname)
-
-    img = Image.open(fname)
-    img_array = np.array(img)
-
-    mean_r, mean_g, mean_b, _mean_a = np.mean(
-        img_array.reshape(-1, img_array.shape[2]), axis=0
-    )
+    # Default material: the actor renders and red dominates the image.
+    arr = window.snapshot(scene=scene, fname=None, return_array=True)
+    report = window.analyze_snapshot(arr, find_objects=True)
+    assert report.objects >= 1
 
+    mean_r, mean_g, mean_b, _mean_a = np.mean(arr.reshape(-1, arr.shape[2]), axis=0)
     assert mean_r > mean_b and mean_r > mean_g
+    assert 0 < mean_r < 255
 
-    middle_pixel = img_array[img_array.shape[0] // 2, img_array.shape[1] // 2]
-    r, g, b, a = middle_pixel
-    assert r > g and r > b
-    assert g == b
+    # Hidden: nothing renders.
+    get_actor.visible = False
+    report = window.analyze_snapshot(
+        window.snapshot(scene=scene, fname=None, return_array=True), find_objects=True
+    )
+    assert report.objects == 0
     scene.remove(get_actor)
 
+    # Basic (flat) material: exact red is present, then absent once hidden.
     typ_actor_1 = getattr(actor, actor_type)
     get_actor_1 = typ_actor_1(**{**kwargs, "material": "basic"})
     scene.add(get_actor_1)
-    fname_1 = f"{actor_type}_test_1.png"
-    window.snapshot(scene=scene, fname=fname_1)
-    img = Image.open(fname_1)
-    img_array = np.array(img)
 
-    mean_r, mean_g, mean_b, _mean_a = np.mean(
-        img_array.reshape(-1, img_array.shape[2]), axis=0
+    report = window.analyze_snapshot(
+        window.snapshot(scene=scene, fname=None, return_array=True),
+        colors=(255, 0, 0),
+        find_objects=True,
     )
-
-    assert mean_r > mean_b and mean_r > mean_g
-    assert 0 < mean_r < 255
-    assert mean_g == 0 and mean_b == 0
-
-    middle_pixel = img_array[img_array.shape[0] // 2, img_array.shape[1] // 2]
-    r, g, b, a = middle_pixel
-    assert r > g and r > b
-    assert g == 0 and b == 0
-    assert r == 255
+    assert report.objects >= 1
+    assert report.colors_found == [True]
+
+    get_actor_1.visible = False
+    report = window.analyze_snapshot(
+        window.snapshot(scene=scene, fname=None, return_array=True),
+        colors=(255, 0, 0),
+        find_objects=True,
+    )
+    assert report.objects == 0
+    assert report.colors_found == [False]
     scene.remove(get_actor_1)

fury/actor/tests/test_billboard.py

@@ -4,11 +4,6 @@
 Simple tests for billboard creation and basic rendering functionality.
 """
 
-from __future__ import annotations
-
-import os
-import tempfile
-
 import numpy as np
 import numpy.testing as npt
 
@@ -72,9 +67,7 @@ def test_basic_billboard(interactive: bool = False):
         window.show([bb_render])
 
     # Test snapshot creation
-    tmp_fd, tmp_file = tempfile.mkstemp(suffix="_bb.png")
-    os.close(tmp_fd)
-    arr = window.snapshot(scene=scene, fname=tmp_file, return_array=True)
+    arr = window.snapshot(scene=scene, fname=None, return_array=True)
 
     # Basic checks: array exists and has expected shape
     assert arr is not None
@@ -85,8 +78,6 @@ def test_basic_billboard(interactive: bool = False):
     _assert_red_visible(arr)
 
     scene.clear()
-    if tmp_file and os.path.exists(tmp_file):
-        os.remove(tmp_file)
 
 
 def test_billboard_camera_facing():
@@ -101,9 +92,7 @@ def test_billboard_camera_facing():
     scene.add(bb)
 
     # Test from default camera position
-    tmp_fd1, tmp_file1 = tempfile.mkstemp(suffix="_bb_front.png")
-    os.close(tmp_fd1)
-    arr1 = window.snapshot(scene=scene, fname=tmp_file1, return_array=True)
+    arr1 = window.snapshot(scene=scene, fname=None, return_array=True)
 
     # Billboard should be visible from front view
     data1 = np.asarray(arr1)
@@ -119,11 +108,7 @@ def test_billboard_camera_facing():
     assert arr1 is not None
     assert green_pixels1 > 0, "Billboard should be visible with green pixels"
 
-    # Cleanup
     scene.clear()
-    for tmp_file in [tmp_file1]:
-        if tmp_file and os.path.exists(tmp_file):
-            os.remove(tmp_file)
 
 
 def test_rectangular_billboards():
@@ -200,8 +185,7 @@ def test_billboard_sphere(interactive: bool = False):
     if interactive:  # pragma: no cover
         window.show(scene)
 
-    tmp_file = tempfile.mktemp(suffix="_bbs.png")
-    arr = window.snapshot(scene=scene, fname=tmp_file, return_array=True)
+    arr = window.snapshot(scene=scene, fname=None, return_array=True)
     assert arr is not None
     _assert_red_visible(arr)
 
@@ -212,8 +196,6 @@ def test_billboard_sphere(interactive: bool = False):
     assert positive_red.max() > positive_red.min()
 
     scene.clear()
-    if tmp_file and os.path.exists(tmp_file):
-        os.remove(tmp_file)
 
 
 def _assert_red_visible(image):
@@ -276,7 +258,7 @@ def test_billboard_bounding_box_camera_framing():
     )
     scene.add(bb)
 
-    arr = window.snapshot(scene=scene, return_array=True)
+    arr = window.snapshot(scene=scene, fname=None, return_array=True)
     assert arr is not None
 
     _assert_red_visible(arr)

fury/actor/tests/test_core.py

@@ -1,4 +1,3 @@
-from PIL import Image
 import numpy as np
 import pytest
 
@@ -181,13 +180,10 @@ def test_axes():
 
     assert axes_actor.prim_count == 3
 
-    fname = "axes_test.png"
-    window.snapshot(scene=scene, fname=fname)
-    img = Image.open(fname)
-    img_array = np.array(img)
-    mean_r, mean_g, mean_b, _mean_a = np.mean(
-        img_array.reshape(-1, img_array.shape[2]), axis=0
-    )
+    arr = window.snapshot(scene=scene, fname=None, return_array=True)
+    report = window.analyze_snapshot(arr, find_objects=True)
+    assert report.objects >= 1
+    mean_r, mean_g, mean_b, _mean_a = np.mean(arr.reshape(-1, arr.shape[2]), axis=0)
     assert np.isclose(mean_r, mean_g, atol=0.02)
     assert 0 < mean_r < 255
     assert 0 < mean_g < 255
@@ -264,9 +260,7 @@ def test_actor_from_primitive_transparency_visual(sphere_prim):
 
     opaque = actor_from_primitive(vertices, faces, centers, colors=colors)
     scene.add(opaque)
-    fname = "transparency_opaque_test.png"
-    window.snapshot(scene=scene, fname=fname)
-    img_array_op = np.array(Image.open(fname))
+    img_array_op = window.snapshot(scene=scene, fname=None, return_array=True)
     mid = img_array_op[img_array_op.shape[0] // 2, img_array_op.shape[1] // 2]
     assert mid[0] > mid[1] and mid[0] > mid[2]
     scene.remove(opaque)
@@ -275,9 +269,7 @@ def test_actor_from_primitive_transparency_visual(sphere_prim):
         vertices, faces, centers, colors=colors, opacity=0.5
     )
     scene.add(transparent)
-    fname = "transparency_semi_test.png"
-    window.snapshot(scene=scene, fname=fname)
-    img_array_tr = np.array(Image.open(fname))
+    img_array_tr = window.snapshot(scene=scene, fname=None, return_array=True)
     mean_r_tr, mean_g_tr, mean_b_tr, _ = np.mean(
         img_array_tr.reshape(-1, img_array_tr.shape[2]), axis=0
     )

fury/actor/tests/test_curved.py

@@ -1,6 +1,5 @@
 import math
 
-from PIL import Image
 import numpy as np
 import pytest
 
@@ -78,18 +77,14 @@ def test_streamtube():
     tube_actor = actor.streamtube(lines=lines, colors=colors)
     scene.add(tube_actor)
 
-    fname = "streamtube_test.png"
-    window.snapshot(scene=scene, fname=fname)
-    img = Image.open(fname)
-    img_array = np.array(img)
-
-    mean_r, mean_g, mean_b, _ = np.mean(
-        img_array.reshape(-1, img_array.shape[2]), axis=0
-    )
+    arr = window.snapshot(scene=scene, fname=None, return_array=True)
+    report = window.analyze_snapshot(arr, find_objects=True)
+    assert report.objects >= 1
 
+    mean_r, mean_g, mean_b, _ = np.mean(arr.reshape(-1, arr.shape[2]), axis=0)
     assert mean_r > mean_g and mean_r > mean_b
 
-    middle_pixel = img_array[img_array.shape[0] // 2, img_array.shape[1] // 2]
+    middle_pixel = arr[arr.shape[0] // 2, arr.shape[1] // 2]
     r, g, b, a = middle_pixel
     assert r > g and r > b