icrdr/AnyImage
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

feat(cutout): implement boundary padding for cutout textures

Browse Source 
- Introduced a new `Boundary Padding` preference in the Cutout Tool with a default of 2 px and a configurable range of 1-4 px.
- Updated the Cutout client to establish inward mapping from the final Mask, sampling in a fixed direction and processing independent material RGBA and Depth.
- Enhanced the handling of RGBA and Depth during cutout operations, ensuring proper mapping and preservation of source data.
- Added tests to validate the new boundary padding functionality and its integration with existing cutout processes.

feat(geometry): remove overall mesh smoothing from geometry nodes

- Removed the `Smooth` input from several geometry node groups to eliminate unnecessary overall mesh smoothing.
- Retained `Smooth Weight` for depth nodes while removing it from Cutout and Relief Plane nodes.
- Ensured that boundary, normal, and fill smoothing behaviors remain intact and consistent.
- Updated tests and documentation to reflect the changes in node interfaces and behaviors.

feat(normals): scale tangent normals with depth

- Reused the existing `o_normal_reduction` attribute to adjust Tangent Normal strength based on the geometry's `Depth Scale`.
- Ensured that Tangent Normal strength is consistent with the geometry depth, preserving full strength for materials that do not provide the attribute.
- Updated tests to verify the correct behavior of normal strength adjustments in both Tangent and Object Space.
This commit is contained in:
马南
2026-09-15 00:40:24 +08:00
parent ab282e4fdf
commit 591e62085a
93 changed files with 1915 additions and 2851 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
tests/tools/nodes/test_arrangement.py
View File

@@ -98,8 +98,8 @@ def _surface(node_group):
image.pixels.foreach_set(pixels.ravel())
values = {"Subdivide": 1, "Thickness": 0.2, "Depth Image": image,
"Uniform Scale": 1.0, "Reference Depth": 2.5, "Depth Scale": 0.8,
"Smooth": 1, "Normal Smooth": 2, "Depth Split": 0.25,
"Depth Offset": 0.5}
"Normal Smooth": 2, "Depth Split": 0.25,
"Offset": 0.5}
mode = None
for item in node_group.interface.items_tree:
if item.item_type != "SOCKET" or item.in_out != "INPUT":

2
tests/tools/nodes/test_boundary_depth.py
View File

@@ -78,7 +78,7 @@ def test_cutout_fine_outline_smooths_only_within_boundary_band():
obj, set_value = surface(step=0, resolution=8)
yy, xx = np.mgrid[:32, :64]
alpha = ((xx - 32)**2 / 27**2 + (yy - 16)**2 / 13**2 < 1).astype(float)
points, faces, _, _ = build_mesh(alpha, 3, .9)
points, faces, _, _, _ = build_mesh(alpha, 3, .9)
obj.data.clear_geometry()
obj.data.from_pydata([(x / 32, y / 32, 0) for x, y in points], [], faces.tolist())
uv = obj.data.uv_layers.get("UVMap") or obj.data.uv_layers.new(name="UVMap")

10
tests/tools/nodes/test_boundary_smoothing.py
View File

@@ -52,7 +52,8 @@ def edge_band(faces, seeds, rings=2):
return selected
def test_cutout_split_and_outline_use_distinct_influence():
@pytest.mark.parametrize(("outline_scale", "expected_outline"), [(0.1, 0.1), (1.0, 1.0)])
def test_split_gets_full_influence_and_outline_uses_configured_scale(outline_scale, expected_outline):
bpy.ops.wm.read_factory_settings(use_empty=True)
points, faces, split = [], [], []
for side in range(2):
@@ -87,7 +88,10 @@ def test_cutout_split_and_outline_use_distinct_influence():
store.data_type, store.domain = "FLOAT", "POINT"
store.inputs["Name"].default_value = "test_influence"
group.links.new(source.outputs["Geometry"], store.inputs["Geometry"])
group.links.new(cut_boundary_influence(group, split_attribute.outputs["Attribute"]), store.inputs["Value"])
group.links.new(
cut_boundary_influence(group, split_attribute.outputs["Attribute"], outline_scale=outline_scale),
store.inputs["Value"],
)
output = group.nodes.new("NodeGroupOutput")
group.links.new(store.outputs["Geometry"], output.inputs["Geometry"])
obj.modifiers.new("Boundary influence", "NODES").node_group = group
@@ -97,7 +101,7 @@ def test_cutout_split_and_outline_use_distinct_influence():
influence = np.array([value.value for value in result.attributes["test_influence"].data])
finally:
evaluated_obj.to_mesh_clear()
np.testing.assert_allclose(influence[4 * 5], 0.1, atol=1e-6)
np.testing.assert_allclose(influence[4 * 5], expected_outline, atol=1e-6)
np.testing.assert_allclose(influence[4 * 5 + 4], 1.0, atol=1e-6)
np.testing.assert_allclose(influence[4], 1.0, atol=1e-6)

38
tests/tools/nodes/test_cutout_symmetry.py
View File

@@ -62,7 +62,7 @@ def symmetry(request):
cutout, mirror = setters
mirror('Fill Smooth', 0)
for name, value in [('Depth Image', image), ('Reference Depth', 1.45),
('Depth Split', 0), ('Boundary Smooth', 0), ('Smooth', 0), ('Depth Axis', 0)]:
('Depth Split', 0), ('Boundary Smooth', 0), ('Depth Axis', 0)]:
cutout(name, value)
yield obj, cutout, mirror
bpy.ops.wm.read_factory_settings(use_empty=True)
@@ -84,7 +84,7 @@ def test_zero_thickness_matches_original_projected(symmetry, mode):
cutout('Mode', mode)
baseline = json.loads((Path(__file__).parent / 'fixtures/projected_symmetry.json').read_text())
for case in baseline['cases']:
mirror('Symmetry Direction', case['direction'])
mirror('Direction', case['direction'])
mirror('Fill Sides', case['filled'])
points, faces = evaluated(obj)
expected = np.array(case['points'])
@@ -99,7 +99,7 @@ def test_completed_geometry_is_mirrored_and_closed(symmetry, mode, smooth):
obj, cutout, mirror = symmetry
cutout('Mode', mode)
cutout('Thickness', .2 if mode else .6, 'DISTANCE' if mode else 'NONE')
mirror('Symmetry Direction', (.3, -.2, 1))
mirror('Direction', (.3, -.2, 1))
mirror('Fill Smooth', smooth)
points, faces = evaluated(obj)
assert len(points) and np.isfinite(points).all()
@@ -150,25 +150,47 @@ def test_fill_smoothing_preserves_surfaces_and_only_moves_wall_interiors(symmetr
def test_direction_offset_and_empty_geometry(symmetry):
obj, _, mirror = symmetry
mirror('Depth Offset', 2.)
mirror('Symmetry Direction', (.3, -.2, 1))
mirror('Offset', 2.)
mirror('Direction', (.3, -.2, 1))
original, original_faces = evaluated(obj)
mirror('Depth Offset', 2.2)
mirror('Offset', 2.2)
points, faces = evaluated(obj)
assert faces == original_faces
np.testing.assert_allclose(points[:, :2], original[:, :2], atol=1e-6)
np.testing.assert_allclose(abs(points[:, 2]) - abs(original[:, 2]), .2, atol=1e-6)
mirror('Depth Offset', -10.)
mirror('Offset', -10.)
points, faces = evaluated(obj)
assert not len(points) and not faces
def test_symmetry_scale_uses_aligned_axis(symmetry):
obj, _, mirror = symmetry
mirror('Direction', (.3, -.2, 1))
mirror('Offset', .5)
mirror('Fill Sides', False)
original, original_faces = evaluated(obj)
mirror('Scale', 2)
points, faces = evaluated(obj)
assert faces == original_faces
np.testing.assert_allclose(points[:, :2], original[:, :2], atol=1e-6)
np.testing.assert_allclose(points[:, 2], original[:, 2] * 2, atol=1e-6)
def test_symmetry_interface_and_cutout_defaults(symmetry):
obj, _, _ = symmetry
inputs = [item for item in obj.modifiers[1].node_group.interface.items_tree
if item.item_type == 'SOCKET' and item.in_out == 'INPUT']
assert [item.name for item in inputs] == ['Geometry', 'Symmetry Direction', 'Depth Offset', 'Fill Sides', 'Fill Smooth']
assert [item.name for item in inputs] == [
'Geometry', 'Direction', 'Offset', 'Scale', 'Fill Sides', 'Fill Smooth',
]
assert inputs[3].default_value == 1
assert (inputs[2].min_value, inputs[2].max_value) == (-10, 10)
assert (inputs[3].min_value, inputs[3].max_value) == (0, 2)
assert inputs[-1].default_value == 2 and inputs[-2].default_value is True
assert (inputs[-1].min_value, inputs[-1].max_value) == (0, 16)
assert inputs[-1].parent == inputs[-2].parent
assert inputs[-1].parent.name == 'Options'
assert inputs[-1].parent.default_closed is True
thickness = [item for item in obj.modifiers[0].node_group.interface.items_tree
if item.item_type == 'SOCKET' and item.name == 'Thickness']
assert len(thickness) == 2 and all(item.default_value == 0 for item in thickness)

2
tests/tools/nodes/test_cutouts.py
View File

@@ -26,7 +26,7 @@ def test_depth_axis_is_visible_in_options(shape, source):
assert axis.default_value == "-Z"
assert "Inward Axis" not in inputs
options = [item.name for item in inputs.values() if item.parent == axis.parent]
predecessor = "Smooth Weight" if shape == "SOLID" else "Reference Depth"
predecessor = "Cleanup Threshold" if shape == "SOLID" else "Reference Depth"
assert options[options.index(predecessor) + 1] == "Depth Axis"
if shape == "SOLID":
assert not any(item.item_type == "PANEL" and item.name == "Data" for item in group.interface.items_tree)

134
tests/tools/nodes/test_depth_relief_planes.py
View File

@@ -5,10 +5,11 @@ import bpy
import numpy as np
import pytest
from anyimage.operators.cutout_tool.shape import NORMAL_REDUCTION_ATTRIBUTE_NAME
from tests.support.planes import surface, relief, evaluated
@pytest.mark.parametrize("subdivide", [0, 1, 3])
@pytest.mark.parametrize("subdivide", [0, 3])
def test_zero_depth_matches_plane_geometry_and_uv(surface, subdivide):
obj, set_value, plane, inputs, _ = surface
set_value("Subdivide", subdivide)
@@ -30,7 +31,7 @@ def test_zero_depth_matches_plane_geometry_and_uv(surface, subdivide):
assert projected[3:5] == regular[3:5]
@pytest.mark.parametrize("strength", [0, 0.5, 1, 2])
@pytest.mark.parametrize("strength", [0, 2])
def test_camera_projection_and_reference_depth(surface, strength):
obj, set_value, _, _, _ = surface
base = evaluated(obj)
@@ -51,6 +52,21 @@ def test_camera_projection_and_reference_depth(surface, strength):
np.tile((0, 0, 0.5 * strength), (len(shifted), 1)), atol=1e-6)
@pytest.mark.parametrize("depth_scale", [0.0, 2.0])
def test_relief_depth_scale_sets_normal_reduction(relief, depth_scale):
obj, set_value, *_ = relief
set_value("Depth Scale", depth_scale)
result = obj.evaluated_get(bpy.context.evaluated_depsgraph_get())
mesh = result.to_mesh()
try:
values = np.array([
value.value for value in mesh.attributes[NORMAL_REDUCTION_ATTRIBUTE_NAME].data
])
finally:
result.to_mesh_clear()
np.testing.assert_allclose(values, 1.0 - depth_scale)
@pytest.mark.parametrize("thickness", [0.000001, 0.2, 2.0])
def test_shell_keeps_front_and_closes_rectangular_boundary(surface, thickness):
obj, set_value, _, _, _ = surface
@@ -140,7 +156,7 @@ def test_relief_reads_z_and_keeps_the_base(relief, thickness):
assert obj.modifiers[0][inputs["Thickness"].identifier] == pytest.approx(thickness)
@pytest.mark.parametrize("reference", [0.5, 1.25, 2.0])
@pytest.mark.parametrize("reference", [0.5, 2.0])
def test_zero_thickness_relief_keeps_far_depth_at_object_space_zero(relief, reference):
obj, set_value, _, _, _ = relief
base = evaluated(obj)
@@ -156,6 +172,67 @@ def test_zero_thickness_relief_keeps_far_depth_at_object_space_zero(relief, refe
np.testing.assert_array_equal(result[2], base[2])
@pytest.mark.parametrize("reference", [0.0, 0.9])
def test_relief_far_depth_stops_at_thickness_height(relief, reference):
obj, set_value, _, _, image = relief
pixels = np.ones((8, 16, 4), dtype=np.float32)
pixels[..., 2] = 2.0
image.pixels.foreach_set(pixels.ravel())
image.update()
set_value("Uniform Scale", 0.5)
set_value("Reference Depth", reference)
set_value("Depth Scale", 2.0)
set_value("Thickness", 0.4)
points = evaluated(obj)[0]
assert points[:, 2].min() == pytest.approx(0.0)
assert points[:, 2].max() == pytest.approx(0.4)
def test_relief_offset_corrects_reference_before_direction_and_scale(relief):
obj, set_value, _, _, image = relief
pixels = np.ones((8, 16, 4), dtype=np.float32)
pixels[..., 2] = 2.0
image.pixels.foreach_set(pixels.ravel())
image.update()
set_value("Uniform Scale", 0.5)
set_value("Reference Depth", 1.0)
set_value("Depth Direction", (0.2, -0.1, 1.0))
set_value("Thickness", 0.0)
set_value("Depth Scale", 1.5)
set_value("Depth Offset", 1.0)
raised = evaluated(obj)[0]
set_value("Depth Offset", 0.5)
lowered = evaluated(obj)[0]
np.testing.assert_allclose(raised[:, 2] - lowered[:, 2], 0.75, atol=1e-6)
@pytest.mark.parametrize("offset", [-1.0, 1.0])
def test_zero_depth_scale_keeps_relief_at_depth_zero(relief, offset):
obj, set_value, _, _, _ = relief
set_value("Thickness", 0.4)
set_value("Depth Offset", offset)
set_value("Depth Scale", 0.0)
points = evaluated(obj)[0]
assert points[:, 2].min() == pytest.approx(0.0)
assert points[:, 2].max() == pytest.approx(0.4)
def test_negative_relief_offset_is_clamped_at_depth_zero(relief):
obj, set_value, _, _, image = relief
pixels = np.ones((8, 16, 4), dtype=np.float32)
pixels[..., 2] = 1.0
image.pixels.foreach_set(pixels.ravel())
image.update()
set_value("Uniform Scale", 1.0)
set_value("Reference Depth", 1.0)
set_value("Depth Offset", -0.5)
set_value("Depth Scale", 1.0)
set_value("Thickness", 0.3)
points = evaluated(obj)[0]
assert points[:, 2].min() == pytest.approx(0.0)
assert points[:, 2].max() == pytest.approx(0.3)
def test_curved_shell_smooths_normals_without_shrinking_thickness(surface):
from scipy.spatial import cKDTree
@@ -219,32 +296,6 @@ def test_relief_direction_adjusts_depth_and_keeps_base(relief, thickness, direct
np.testing.assert_array_equal(result[2], base[2])
@pytest.mark.parametrize("thickness", [0.0, 0.4])
def test_relief_smooth_preserves_topology_uv_and_materials(relief, thickness):
obj, set_value, _, _, image = relief
pixels = np.asarray(image.pixels[:], dtype=np.float32).reshape(8, 16, 4)
pixels[..., 2] += (np.arange(16) % 2) * 0.5
image.pixels.foreach_set(pixels.ravel())
image.update()
set_value("Thickness", thickness)
set_value("Reference Depth", 2.0)
set_value("Depth Scale", 1.0)
set_value("Depth Direction", (0.1, -0.1, 1))
base = evaluated(obj)
set_value("Smooth", 3)
result = evaluated(obj)
assert np.isfinite(result[0]).all()
assert np.max(abs(result[0] - base[0])) > 1e-4
assert result[1] == base[1]
np.testing.assert_array_equal(result[2], base[2])
assert result[3:] == base[3:]
set_value("Smooth Weight", 0.0)
np.testing.assert_allclose(evaluated(obj)[0], base[0], atol=1e-6)
set_value("Smooth Weight", 1.0)
set_value("Smooth", 0)
np.testing.assert_allclose(evaluated(obj)[0], base[0], atol=1e-6)
@pytest.mark.parametrize("pattern,threshold", [
("valid", 1.0), ("invalid", 0.0), ("invalid", 0.9),
("partial", 0.4), ("partial", 0.9), ("half", 0.9), ("stripe", 0.9),
@@ -299,28 +350,3 @@ def test_valid_only_precedes_closed_shell_generation(surface):
edges = Counter(tuple(sorted((a, b))) for face in faces for a, b in zip(face, (*face[1:], face[0])))
assert set(edges.values()) == {2}
assert np.isfinite(points).all() and np.isfinite(uv).all()
@pytest.mark.parametrize("thickness", [0.0, 0.2])
def test_depth_smooth_changes_positions_and_preserves_topology(surface, thickness):
obj, set_value, _, _, depth_image = surface
pixels = np.asarray(depth_image.pixels[:], dtype=np.float32).reshape(8, 16, 4)
pixels[..., 2] += (np.arange(16) % 2) * 0.3
pixels[:, :4, 3] = 0
depth_image.pixels.foreach_set(pixels.ravel())
depth_image.update()
set_value("Depth Scale", 1.0)
set_value("Thickness", thickness)
base = evaluated(obj)
set_value("Smooth", 3)
smoothed = evaluated(obj)
assert smoothed[1] == base[1]
np.testing.assert_allclose(smoothed[2], base[2])
assert smoothed[3:5] == base[3:5]
assert np.isfinite(smoothed[0]).all()
assert not np.allclose(smoothed[0], base[0])
set_value("Smooth Weight", 0.0)
np.testing.assert_allclose(evaluated(obj)[0], base[0], atol=1e-6)
set_value("Smooth Weight", 1.0)
set_value("Smooth", 0)
np.testing.assert_allclose(evaluated(obj)[0], base[0], atol=1e-6)

56
tests/tools/nodes/test_depth_strip_cleanup.py
View File

@@ -64,23 +64,8 @@ def test_quad_strips_and_corners_are_classified_once(cells, expected, offset, re
assert cleaned_faces(vertices, faces) == expected
@pytest.mark.parametrize("count", [3, 5, 6])
def test_non_quad_faces_are_preserved(count):
angles = np.linspace(0, 2 * np.pi, count, endpoint=False)
vertices = [(np.cos(a), np.sin(a), 0) for a in angles]
assert cleaned_faces(vertices, [tuple(range(count))]) == {0}
def test_nonmanifold_edge_is_not_a_boundary():
vertices = [(0, 0, 0), (1, 0, 0), (1, 1, 0), (0, 1, 0),
(2, 0, 0), (1, 2, 0), (0, 2, 1), (-1, 0, 0)]
faces = [(0, 1, 2, 3), (2, 1, 4), (3, 2, 5), (2, 3, 6), (0, 3, 7)]
assert cleaned_faces(vertices, faces) == set(range(5))
@pytest.mark.parametrize("width, height, expected", [(1, 1, 0), (5, 1, 0), (2, 2, 8), (3, 3, 18)])
@pytest.mark.parametrize("reverse", [False, True])
def test_triangle_pairs_remove_strips_and_preserve_surface_corners(width, height, expected, reverse):
@pytest.mark.parametrize("width,height,expected", [(2, 2, 8), (3, 3, 18)])
def test_triangle_pairs_remove_strips_and_preserve_surface_corners(width, height, expected):
vertices = [(x, y, 0) for y in range(height + 1) for x in range(width + 1)]
faces = []
for y in range(height):
@@ -89,36 +74,11 @@ def test_triangle_pairs_remove_strips_and_preserve_surface_corners(width, height
b, c, d = a + 1, a + width + 2, a + width + 1
faces.extend([(a, b, c), (a, c, d)])
# Reverse alternate faces to test matching by vertex identity, not winding.
if reverse:
faces = [face[::-1] if i % 2 else face[1:] + face[:1] for i, face in enumerate(faces)]
faces = [face[::-1] if i % 2 else face[1:] + face[:1] for i, face in enumerate(faces)]
result = cleaned_faces(vertices, faces, triangles=True)
assert len(result) == expected
def test_isolated_triangle_is_removed_only_for_cutout():
vertices = [(0, 0, 0), (1, 0, 0), (0, 1, 0)]
assert cleaned_faces(vertices, [(0, 1, 2)], triangles=True) == set()
assert cleaned_faces(vertices, [(0, 1, 2)]) == {0}
def test_triangle_pair_requires_a_manifold_shared_edge():
vertices = [(0, 0, 0), (1, 0, 0), (.5, 1, 0), (.5, -1, 0), (.5, 0, 1)]
faces = [(0, 1, 2), (1, 0, 3), (0, 1, 4)]
assert cleaned_faces(vertices, faces, triangles=True) == {0, 1, 2}
def test_triangle_pair_requires_four_distinct_vertices():
vertices = [(0, 0, 0), (1, 0, 0), (0, 1, 0)]
assert cleaned_faces(vertices, [(0, 1, 2), (2, 1, 0)], triangles=True) == {0, 1}
def test_triangle_cleanup_marks_both_faces_without_recursive_peeling():
vertices = [(0, 0, 0), (2, 0, 0), (1, 2, 0), (1, -2, 0),
(3, 2, 0), (-1, 2, 0), (-1, -1, 0)]
faces = [(0, 1, 2), (1, 0, 3), (2, 1, 4), (0, 2, 5), (3, 0, 6)]
assert cleaned_faces(vertices, faces, triangles=True) == {0, 2, 3}
@pytest.mark.parametrize("kind", ["plane", "cutout"])
def test_strips_are_removed_before_projection_and_closed_thickness(kind):
from tests.support.depth_surface import surface, evaluated, assert_closed, component_count
@@ -144,15 +104,11 @@ def test_strips_are_removed_before_projection_and_closed_thickness(kind):
assert len(faces) == 4 and len(vertices) == 9
assert component_count(faces) == 1
set_value("Thickness", 0.2)
before_smooth, shell = evaluated(obj)
vertices, shell = evaluated(obj)
assert len(shell) == 16
assert_closed(shell)
set_value("Smooth", 2)
after_smooth, smooth_shell = evaluated(obj)
assert smooth_shell == shell
assert np.isfinite(after_smooth).all()
assert_closed(smooth_shell)
assert component_count(smooth_shell) == 1
assert np.isfinite(vertices).all()
assert component_count(shell) == 1
set_value("Thickness", 0.0)
assert len(evaluated(obj)[1]) == 4

12
tests/tools/nodes/test_depth_surface_split.py
View File

@@ -62,7 +62,7 @@ def test_surface_caps_and_segmented_walls_are_connected(thickness, split):
assert cKDTree(coords).query(front)[0].max() < 1e-5
@pytest.mark.parametrize("size", [0.01, 1.0, 100.0])
@pytest.mark.parametrize("size", [0.01, 100.0])
def test_split_mapping_and_uniform_scale(size):
obj, set_value = surface(step=2.0, size=size)
# The normalized ray jump crosses the threshold only at full strength.
@@ -99,7 +99,7 @@ def test_cleanup_keeps_split_parts_of_a_large_source_island():
assert len(evaluated(obj)[1]) == 0
@pytest.mark.parametrize("depth_scale", [0.0, 0.25, 1.0, 2.0, 4.0])
@pytest.mark.parametrize("depth_scale", [0.0, 2.0])
def test_split_topology_uses_depth_before_display_scaling(depth_scale):
obj, set_value = surface(step=4.0)
set_value("Depth Split", 0.5)
@@ -111,11 +111,10 @@ def test_split_topology_uses_depth_before_display_scaling(depth_scale):
np.testing.assert_allclose(coords[:, 2], original[:, 2] * depth_scale, atol=1e-6)
def test_full_wrapper_smooth_keeps_closed_shell():
def test_full_wrapper_keeps_closed_shell():
obj, set_value = surface(wrapper=True)
set_value("Depth Split", 0.5)
set_value("Thickness", 0.2)
set_value("Smooth", 2)
coords, faces = evaluated(obj)
assert np.isfinite(coords).all()
assert_closed(faces)
@@ -169,7 +168,7 @@ def test_shell_source_indices_cross_identity_grid_rows():
assert_closed(faces)
@pytest.mark.parametrize("resolution", [1, 2, 4])
@pytest.mark.parametrize("resolution", [1, 4])
def test_planar_depth_preserves_blocks_and_cleans_single_face_width(resolution):
obj, set_value = surface(step=0.0, resolution=resolution)
original, original_faces = evaluated(obj)
@@ -232,7 +231,6 @@ def test_temporary_fields_are_removed_and_user_attributes_survive(thickness, spl
value.value = 0.75
set_value("Depth Split", split)
set_value("Thickness", thickness)
set_value("Smooth", 2)
result = obj.evaluated_get(bpy.context.evaluated_depsgraph_get())
mesh = result.to_mesh()
try:
@@ -294,7 +292,7 @@ def test_triangle_corner_weights_do_not_open_sloped_side_walls():
assert component_count(faces) == 2
@pytest.mark.parametrize("resolution", [1, 2, 4])
@pytest.mark.parametrize("resolution", [1, 4])
def test_relative_distance_slope_has_density_independent_selection(resolution):
obj, set_value = surface(step=0.0, resolution=resolution)
output_split_mesh(obj)

13
tests/tools/nodes/test_image_depth_panorama.py
View File

@@ -49,7 +49,7 @@ def evaluated(obj):
result.to_mesh_clear()
@pytest.mark.parametrize("subdivide", [0, 2, 4])
@pytest.mark.parametrize("subdivide", [0, 4])
def test_quad_sphere_topology_and_radial_endpoints(subdivide):
obj, set_value = panorama(subdivide=subdivide)
inputs = [s for s in obj.modifiers[0].node_group.interface.items_tree if s.item_type == "SOCKET" and s.in_out == "INPUT"]
@@ -124,7 +124,7 @@ def test_invalid_distance_removes_faces_between_valid_and_invalid_regions(sky_al
np.testing.assert_allclose(np.linalg.norm(evaluated(obj)[0], axis=1), 1, atol=1e-5)
def test_controls_smoothing_and_material_slot_inheritance():
def test_controls_and_material_slot_inheritance():
obj, set_value = panorama()
group = obj.modifiers[0].node_group
inputs = {s.name: s for s in group.interface.items_tree if s.item_type == "SOCKET" and s.in_out == "INPUT"}
@@ -138,15 +138,6 @@ def test_controls_smoothing_and_material_slot_inheritance():
obj.data.from_pydata([(0, 0, 0)], [], [])
material = bpy.data.materials.new("Slot Material")
obj.data.materials.append(material)
set_value("Smooth", 0)
original = evaluated(obj)
set_value("Smooth", 2)
smoothed = evaluated(obj)
assert smoothed[1] == original[1]
assert np.max(abs(smoothed[0] - original[0])) > 1e-4
np.testing.assert_array_equal(smoothed[2], original[2])
set_value("Smooth Weight", 0)
np.testing.assert_allclose(evaluated(obj)[0], original[0], atol=1e-6)
for name in ("First Slot", "Replacement Slot"):
current = bpy.data.materials.new(name)
obj.data.materials[0] = current

61
tests/tools/nodes/test_image_layer.py
View File

@@ -1,4 +1,3 @@
import bpy
import numpy as np
import pytest
@@ -17,35 +16,19 @@ def test_alpha_curve_preserves_endpoints_and_suppresses_soft_edges(image_layer):
"Color", "Alpha", "Normal", "Bump Scale", "Alpha Fix",
"Normal Scale", "Object Space",
]
panels = [item for item in image_layer.interface.items_tree if item.item_type == "PANEL"]
assert len(panels) == 1
assert panels[0].name == "Options" and panels[0].default_closed
assert [item.name for item in panels[0].interface_items] == ["Alpha Fix", "Normal Scale", "Object Space"]
strength = inputs["Alpha Fix"]
assert (strength.default_value, strength.min_value, strength.max_value) == (0, 0, 1)
assert strength.subtype == "FACTOR"
output = next(node for node in image_layer.nodes if node.type == "GROUP_OUTPUT")
curve = output.inputs["Alpha"].links[0].from_node
assert curve.type == "CURVE_FLOAT"
assert curve.inputs["Value"].links[0].from_socket.name == "Alpha"
assert curve.inputs["Factor"].links[0].from_socket.name == "Alpha Fix"
mapping = curve.mapping
np.testing.assert_allclose(
[point.location[:] for point in mapping.curves[0].points],
[(0, 0), (0.8, 0), (0.925, 0.925), (1, 1)],
atol=1e-6,
)
samples = np.array([
mapping.evaluate(mapping.curves[0], float(alpha))
for alpha in np.linspace(0, 1, 1001)
])
np.testing.assert_allclose(samples[:801], 0, atol=3e-4)
assert samples[-1] == pytest.approx(1)
assert np.all(np.diff(samples) >= -1e-6)
assert np.all((samples >= 0) & (samples <= 1))
assert mapping.evaluate(mapping.curves[0], 0.85) == pytest.approx(0.1593, abs=1e-3)
assert mapping.evaluate(mapping.curves[0], 0.925) == pytest.approx(0.925, abs=5e-4)
assert all(socket.is_linked or socket.hide for node in image_layer.nodes for socket in node.outputs)
def test_depth_layer_keeps_foreground_alpha_threshold(image_layer):
@@ -55,47 +38,3 @@ def test_depth_layer_keeps_foreground_alpha_threshold(image_layer):
assert threshold.operation == "GREATER_THAN"
assert threshold.inputs[1].default_value == 0.5
assert threshold.inputs[0].links[0].from_socket.name == "Alpha"
def test_alpha_adjustment_shader_blends_curve_strength(image_layer, tmp_path):
scene = bpy.context.scene
scene.render.engine = "CYCLES"
scene.cycles.device = "CPU"
scene.cycles.samples = 1
scene.cycles.use_denoising = False
scene.render.resolution_x = 96
scene.render.resolution_y = 32
scene.render.resolution_percentage = 100
scene.render.image_settings.file_format = "OPEN_EXR"
scene.render.image_settings.color_depth = "32"
scene.render.filepath = str(tmp_path / "alpha-strength.exr")
bpy.ops.object.camera_add(location=(0, 0, 5))
camera = bpy.context.object
camera.data.type = "ORTHO"
camera.data.ortho_scale = 3
scene.camera = camera
for index, factor in enumerate((0, 0.5, 1)):
bpy.ops.mesh.primitive_plane_add(size=1, location=(index - 1, 0, 0))
result = bpy.data.materials.new(f"Alpha {factor}")
result.use_nodes = True
nodes = result.node_tree.nodes
nodes.clear()
layer = nodes.new("ShaderNodeGroup")
layer.node_tree = image_layer
layer.inputs["Alpha"].default_value = 0.9
layer.inputs["Alpha Fix"].default_value = factor
emission = nodes.new("ShaderNodeEmission")
output = nodes.new("ShaderNodeOutputMaterial")
result.node_tree.links.new(layer.outputs["Alpha"], emission.inputs["Color"])
result.node_tree.links.new(emission.outputs[0], output.inputs["Surface"])
bpy.context.object.data.materials.append(result)
bpy.ops.render.render(write_still=True)
rendered = bpy.data.images.load(scene.render.filepath, check_existing=False)
try:
pixels = np.array(rendered.pixels[:]).reshape(32, 96, 4)
values = pixels[16, [16, 48, 80], 0]
assert values[0] == pytest.approx(0.9, abs=1e-4)
assert values[2] == pytest.approx(0.77396, abs=1e-3)
assert values[1] == pytest.approx((values[0] + values[2]) / 2, abs=1e-4)
finally:
bpy.data.images.remove(rendered)

66
tests/tools/nodes/test_inventory.py
View File

@@ -18,18 +18,22 @@ def test_saved_parameter_descriptions_match_definitions():
parameters = {
"O Image Plane": {"Subdivide"},
"O Image Depth Plane": {
"Subdivide", "Thickness", "Depth Split", "Smooth", "Smooth Weight",
"Subdivide", "Thickness", "Depth Split", "Smooth Weight",
"Depth Mask", "Mask Threshold", "Boundary Smooth",
},
"O Image Relief Plane": {"Subdivide", "Thickness", "Smooth", "Smooth Weight"},
"O Image Cutout": {"Thickness", "Smooth", "Smooth Weight"},
"O Image Relief Plane": {
"Subdivide", "Thickness", "Depth Direction", "Depth Offset",
},
"O Image Cutout": {"Thickness"},
"O Image Depth Cutout": {
"Thickness", "Depth Split", "Smooth", "Smooth Weight",
"Thickness", "Depth Split", "Smooth Weight",
"Boundary Smooth", "Normal Smooth", "Front Inflation",
},
"O Image Cutout Symmetry": {"Symmetry Direction", "Depth Offset", "Fill Sides", "Fill Smooth"},
"O Image Cutout Symmetry": {
"Direction", "Offset", "Scale", "Fill Sides", "Fill Smooth",
},
"O Image Depth Panorama": {
"Subdivide", "Depth Scale", "Depth Split", "Smooth", "Smooth Weight",
"Subdivide", "Depth Scale", "Depth Split", "Smooth Weight",
"Depth Mask", "Mask Threshold", "Boundary Smooth", "Invalid Distance",
},
"O Image Layer": {"Alpha Fix", "Normal Scale", "Bump Scale", "Object Space"},
@@ -48,18 +52,54 @@ def test_saved_parameter_descriptions_match_definitions():
]
assert {item.name for item in sockets} == parameters[group.name]
assert all(item.description for item in sockets), group.name
input_names = {
item.name for item in group.interface.items_tree
if item.item_type == "SOCKET" and item.in_out == "INPUT"
}
input_items = [
item for item in group.interface.items_tree
if item.item_type == "SOCKET" and item.in_out == "INPUT"
]
if group.name in {
"O Image Cutout", "O Image Depth Cutout", "O Image Depth Plane",
"O Image Depth Panorama", "O Image Relief Plane",
}:
assert "Smooth" not in input_names
if group.name in {"O Image Cutout", "O Image Relief Plane"}:
assert "Smooth Weight" not in input_names
if group.name in {"O Image Depth Plane", "O Image Depth Cutout"}:
boundary = next(item for item in sockets if item.name == "Boundary Smooth")
assert boundary.default_value == 4
assert boundary.min_value == 0
assert boundary.max_value == 16
assert boundary.parent.name == "Options"
if group.name == "O Image Depth Plane":
depth_scale = next(item for item in input_items if item.name == "Depth Scale")
assert (depth_scale.min_value, depth_scale.max_value) == (0.0, 2.0)
if group.name == "O Image Depth Panorama":
defaults = {item.name: item.default_value for item in sockets
if item.name in {"Subdivide", "Depth Split", "Boundary Smooth"}}
assert defaults == pytest.approx({
"Subdivide": 8, "Depth Split": 0.1, "Boundary Smooth": 2,
})
boundary = next(item for item in input_items if item.name == "Boundary Smooth")
assert (boundary.min_value, boundary.max_value) == (0, 16)
if group.name == "O Image Relief Plane":
names = [item.name for item in group.interface.items_tree
if item.item_type == "SOCKET" and item.in_out == "INPUT"]
start = names.index("Thickness")
assert names[start:start + 4] == [
"Thickness", "Depth Direction", "Depth Offset", "Depth Scale",
]
thickness = next(item for item in sockets if item.name == "Thickness")
direction = next(item for item in sockets if item.name == "Depth Direction")
offset = next(item for item in sockets if item.name == "Depth Offset")
assert offset.default_value == pytest.approx(1.0)
assert (offset.min_value, offset.max_value) == (-10.0, 10.0)
assert offset.subtype == "DISTANCE"
assert direction.parent == thickness.parent == offset.parent
depth_scale = next(item for item in input_items if item.name == "Depth Scale")
assert (depth_scale.min_value, depth_scale.max_value) == (0.0, 2.0)
if "Depth Mask" in parameters[group.name]:
names = [item.name for item in group.interface.items_tree
if item.item_type == "SOCKET" and item.in_out == "INPUT"]
@@ -71,8 +111,15 @@ def test_saved_parameter_descriptions_match_definitions():
assert [item.name for item in mode.enum_items] == ["Balloon", "Shell"]
thickness = [item.description for item in sockets if item.name == "Thickness"]
assert len(thickness) == 2 and len(set(thickness)) == 2
thicknesses = [item for item in input_items if item.name == "Thickness"]
balloon = next(item for item in thicknesses if item.subtype == "NONE")
shell = next(item for item in thicknesses if item.subtype == "DISTANCE")
assert (balloon.min_value, balloon.max_value) == (0.0, 2.0)
assert (shell.min_value, shell.max_value) == (0.0, 1.0)
if group.name == "O Image Depth Cutout":
assert all(item.default_value == 0 for item in sockets if item.name == "Thickness")
depth_scale = next(item for item in input_items if item.name == "Depth Scale")
assert (depth_scale.min_value, depth_scale.max_value) == (0.0, 2.0)
assert not {"Outline Depth Fix", "Center Smooth", "Center Subdivide", "Show Center"} & {
item.name for item in group.interface.items_tree if item.item_type == "SOCKET"
}
@@ -83,6 +130,13 @@ def test_saved_parameter_descriptions_match_definitions():
assert normal_smooth.min_value == 16
assert normal_smooth.max_value == 512
assert normal_smooth.parent.name == "Options"
if group.name == "O Image Cutout Symmetry":
offset = next(item for item in input_items if item.name == "Offset")
scale = next(item for item in input_items if item.name == "Scale")
fill_smooth = next(item for item in input_items if item.name == "Fill Smooth")
assert (offset.min_value, offset.max_value) == (-10.0, 10.0)
assert (scale.min_value, scale.max_value) == (0.0, 2.0)
assert (fill_smooth.min_value, fill_smooth.max_value) == (0, 16)
result[group.name] = [
(item.identifier, item.name, item.description) for item in sockets
]

14
tests/tools/nodes/test_normal_scale.py
View File

@@ -16,7 +16,7 @@ def test_normal_scale_preserves_missing_and_zero_weights(image_layer, engine, do
scene.cycles.device = 'CPU'
scene.cycles.samples = 1
scene.cycles.use_denoising = False
scene.render.resolution_x, scene.render.resolution_y = 256, 64
scene.render.resolution_x, scene.render.resolution_y = 320, 64
scene.render.resolution_percentage = 100
scene.render.image_settings.file_format = 'OPEN_EXR'
scene.render.image_settings.color_depth = '32'
@@ -24,14 +24,14 @@ def test_normal_scale_preserves_missing_and_zero_weights(image_layer, engine, do
bpy.ops.object.camera_add(location=(0, 0, 10))
scene.camera = bpy.context.object
scene.camera.data.type = 'ORTHO'
scene.camera.data.ortho_scale = 8
scene.camera.data.ortho_scale = 10
for mode_index, space in enumerate(('TANGENT', 'OBJECT')):
shared = None
for weight_index, weight in enumerate((None, 0.0, 0.4, 1.0)):
column = mode_index * 4 + weight_index
for weight_index, weight in enumerate((None, 0.0, 0.4, 1.0, 2.0)):
column = mode_index * 5 + weight_index
for reference in (False, True):
bpy.ops.mesh.primitive_plane_add(
size=.8, location=(column - 3.5, .5 if reference else -.5, 0),
size=.8, location=(column - 4.5, .5 if reference else -.5, 0),
)
obj = bpy.context.object
obj.data.uv_layers.active.name = 'UVMap'
@@ -71,8 +71,8 @@ def test_normal_scale_preserves_missing_and_zero_weights(image_layer, engine, do
bpy.ops.render.render(write_still=True)
rendered = bpy.data.images.load(scene.render.filepath, check_existing=False)
try:
pixels = np.array(rendered.pixels[:]).reshape(64, 256, 4)
columns = np.arange(8) * 32 + 16
pixels = np.array(rendered.pixels[:]).reshape(64, 320, 4)
columns = np.arange(10) * 32 + 16
np.testing.assert_allclose(pixels[16, columns, :3], pixels[48, columns, :3], atol=2e-4)
assert np.linalg.norm(pixels[16, 16, :3] - pixels[16, 48, :3]) > .01
finally: