399 lines
14 KiB
Python
399 lines
14 KiB
Python
import sys
|
|
from types import ModuleType, SimpleNamespace
|
|
from unittest.mock import Mock, patch
|
|
from tests.support.blender import BlenderTestCase
|
|
|
|
|
|
class MaskToolTest(BlenderTestCase):
|
|
def test_selection_mask_keeps_nonzero_winding_overlap(self):
|
|
path = (
|
|
(1, 1),
|
|
(7, 1),
|
|
(7, 7),
|
|
(1, 7),
|
|
(1, 1),
|
|
(4, 1),
|
|
(10, 1),
|
|
(10, 7),
|
|
(4, 7),
|
|
(4, 1),
|
|
(1, 1),
|
|
)
|
|
|
|
selection = self.image_selection.rasterize_selection_path(
|
|
(12, 9),
|
|
self.image_selection.SelectionPath(points=path),
|
|
).full_values((12, 9))
|
|
|
|
self.assertTrue(selection[3, 5])
|
|
|
|
triangles = self.image_interaction.preview_fill_geometry(path)[0]
|
|
preview_area = sum(
|
|
abs(
|
|
self.image_interaction._triangle_cross(
|
|
triangles[index],
|
|
triangles[index + 1],
|
|
triangles[index + 2],
|
|
)
|
|
)
|
|
* 0.5
|
|
for index in range(0, len(triangles), 3)
|
|
)
|
|
|
|
self.assertAlmostEqual(preview_area, 54.0)
|
|
|
|
|
|
def test_mask_freezes_scene_settings_on_invoke(self):
|
|
settings = SimpleNamespace(
|
|
mask_gesture="BRUSH",
|
|
mask_mode="EXTEND",
|
|
mask_radius=64,
|
|
)
|
|
context = SimpleNamespace(scene=SimpleNamespace(anyimage_settings=settings))
|
|
operator = SimpleNamespace(gesture="LASSO", mode="SET", radius=25)
|
|
|
|
self.edit_mask.EditImageAlpha._read_gesture_settings(operator, context)
|
|
|
|
self.assertEqual(operator.gesture, "BRUSH")
|
|
self.assertEqual(operator.mode, "EXTEND")
|
|
self.assertEqual(operator.radius, 64)
|
|
|
|
|
|
def test_mask_and_rectify_start_after_an_empty_pick(self):
|
|
source = SimpleNamespace(
|
|
name="Source",
|
|
data=SimpleNamespace(size=(8, 6)),
|
|
matrix_world="matrix",
|
|
)
|
|
area = SimpleNamespace(as_pointer=lambda: 1, tag_redraw=Mock())
|
|
region = SimpleNamespace(as_pointer=lambda: 2, width=100, height=80)
|
|
window_manager = SimpleNamespace(
|
|
modal_handler_add=Mock(),
|
|
event_timer_add=Mock(return_value="timer"),
|
|
)
|
|
context = SimpleNamespace(
|
|
area=area,
|
|
region=region,
|
|
window=object(),
|
|
window_manager=window_manager,
|
|
workspace=SimpleNamespace(status_text_set=Mock()),
|
|
scene=SimpleNamespace(
|
|
anyimage_settings=SimpleNamespace(
|
|
mask_gesture="LASSO",
|
|
mask_mode="SUBTRACT",
|
|
mask_radius=25,
|
|
)
|
|
),
|
|
)
|
|
event = SimpleNamespace(
|
|
mouse_region_x=12,
|
|
mouse_region_y=18,
|
|
value="PRESS",
|
|
)
|
|
previous_space = getattr(self.fake_bpy.types, "SpaceView3D", None)
|
|
self.fake_bpy.types.SpaceView3D = SimpleNamespace(
|
|
draw_handler_add=Mock(return_value="handler")
|
|
)
|
|
try:
|
|
with (
|
|
patch.object(
|
|
self.image_interaction,
|
|
"resolve_image_edit_click",
|
|
return_value=(source, True),
|
|
),
|
|
patch.object(
|
|
self.image_interaction,
|
|
"is_animated_image",
|
|
return_value=False,
|
|
),
|
|
patch.object(
|
|
self.image_interaction,
|
|
"serialize_matrix",
|
|
return_value="serialized",
|
|
),
|
|
):
|
|
mask = self.edit_mask.EditImageAlpha()
|
|
mask.report = Mock()
|
|
self.assertEqual(mask.invoke(context, event), {"RUNNING_MODAL"})
|
|
self.assertEqual(mask._path, [(12.0, 18.0)])
|
|
|
|
with (
|
|
patch.object(
|
|
self.rectify,
|
|
"resolve_image_edit_click",
|
|
return_value=(source, True),
|
|
),
|
|
patch.object(
|
|
self.rectify,
|
|
"is_animated_image",
|
|
return_value=False,
|
|
),
|
|
patch.object(
|
|
self.rectify,
|
|
"serialize_matrix",
|
|
return_value="serialized",
|
|
),
|
|
):
|
|
rectify = self.rectify.RectifyImagePerspective()
|
|
rectify.report = Mock()
|
|
self.assertEqual(rectify.invoke(context, event), {"RUNNING_MODAL"})
|
|
self.assertEqual(rectify._points, [(12.0, 18.0)])
|
|
finally:
|
|
if previous_space is None:
|
|
del self.fake_bpy.types.SpaceView3D
|
|
else:
|
|
self.fake_bpy.types.SpaceView3D = previous_space
|
|
|
|
|
|
def test_mask_and_rectify_cancel_without_an_active_image(self):
|
|
context = SimpleNamespace(
|
|
scene=SimpleNamespace(
|
|
anyimage_settings=SimpleNamespace(
|
|
mask_gesture="LASSO",
|
|
mask_mode="SUBTRACT",
|
|
mask_radius=25,
|
|
)
|
|
)
|
|
)
|
|
event = SimpleNamespace()
|
|
|
|
with patch.object(
|
|
self.image_interaction,
|
|
"resolve_image_edit_click",
|
|
return_value=(None, False),
|
|
):
|
|
mask = self.edit_mask.EditImageAlpha()
|
|
mask.report = Mock()
|
|
self.assertEqual(mask.invoke(context, event), {"CANCELLED"})
|
|
with patch.object(
|
|
self.rectify,
|
|
"resolve_image_edit_click",
|
|
return_value=(None, False),
|
|
):
|
|
rectify = self.rectify.RectifyImagePerspective()
|
|
rectify.report = Mock()
|
|
self.assertEqual(rectify.invoke(context, event), {"CANCELLED"})
|
|
|
|
|
|
def test_image_mask_fill_triangulates_a_concave_polygon_without_overlap(self):
|
|
polygon = (
|
|
(0, 0),
|
|
(4, 0),
|
|
(4, 4),
|
|
(3, 4),
|
|
(3, 1),
|
|
(1, 1),
|
|
(1, 4),
|
|
(0, 4),
|
|
)
|
|
triangles = self.image_interaction.triangulated_polygon_vertices(polygon)
|
|
area = sum(
|
|
abs(
|
|
self.image_interaction._triangle_cross(
|
|
triangles[index],
|
|
triangles[index + 1],
|
|
triangles[index + 2],
|
|
)
|
|
)
|
|
* 0.5
|
|
for index in range(0, len(triangles), 3)
|
|
)
|
|
|
|
self.assertEqual(len(triangles), 18)
|
|
self.assertAlmostEqual(area, 10.0)
|
|
|
|
|
|
def test_image_mask_fill_uses_blender_geometry_without_stopping_the_draw(self):
|
|
mathutils = ModuleType("mathutils")
|
|
mathutils.Vector = lambda values: values
|
|
mathutils.geometry = SimpleNamespace(
|
|
tessellate_polygon=lambda _loops: (
|
|
((0.0, 0.0, 0.0), (2.0, 0.0, 0.0), (0.0, 2.0, 0.0)),
|
|
)
|
|
)
|
|
with patch.dict(sys.modules, {"mathutils": mathutils}):
|
|
triangles = self.image_interaction.triangulated_polygon_vertices(
|
|
((0, 0), (2, 0), (0, 2))
|
|
)
|
|
|
|
self.assertEqual(
|
|
triangles,
|
|
((0.0, 0.0), (2.0, 0.0), (0.0, 2.0)),
|
|
)
|
|
|
|
|
|
def test_image_mask_fill_falls_back_when_blender_tessellation_rejects_path(self):
|
|
mathutils = ModuleType("mathutils")
|
|
mathutils.Vector = lambda values: values
|
|
mathutils.geometry = SimpleNamespace(
|
|
tessellate_polygon=lambda _loops: (_ for _ in ()).throw(TypeError())
|
|
)
|
|
with patch.dict(sys.modules, {"mathutils": mathutils}):
|
|
triangles = self.image_interaction.triangulated_polygon_vertices(
|
|
((0, 0), (2, 0), (0, 2))
|
|
)
|
|
|
|
self.assertEqual(len(triangles), 3)
|
|
|
|
|
|
def test_image_mask_preview_fills_a_self_intersecting_lasso(self):
|
|
polygon = ((0, 0), (4, 4), (0, 4), (4, 0))
|
|
triangles = self.image_interaction.preview_fill_geometry(polygon)[0]
|
|
area = sum(
|
|
abs(
|
|
self.image_interaction._triangle_cross(
|
|
triangles[index],
|
|
triangles[index + 1],
|
|
triangles[index + 2],
|
|
)
|
|
)
|
|
* 0.5
|
|
for index in range(0, len(triangles), 3)
|
|
)
|
|
|
|
self.assertTrue(triangles)
|
|
self.assertAlmostEqual(area, 8.0)
|
|
|
|
|
|
def test_image_mask_preview_detects_only_actual_self_intersections(self):
|
|
self.assertTrue(
|
|
self.image_interaction.polygon_self_intersects(
|
|
((0, 0), (4, 4), (0, 4), (4, 0))
|
|
)
|
|
)
|
|
self.assertFalse(
|
|
self.image_interaction.polygon_self_intersects(
|
|
((0, 0), (4, 0), (2, 2), (4, 4), (0, 4))
|
|
)
|
|
)
|
|
|
|
|
|
def test_mask_alpha_modes_preserve_rgb_and_canvas(self):
|
|
import numpy as np
|
|
|
|
source = np.zeros((2, 3, 4), dtype=np.float32)
|
|
source[:, :, :3] = np.asarray((0.2, 0.4, 0.6), dtype=np.float32)
|
|
source[:, :, 3] = np.asarray(((0.2, 0.5, 0.8), (1.0, 0.4, 0.0)))
|
|
mask = self.image_selection.SelectionMask(
|
|
np.asarray(((0.25, 1.0), (0.5, 0.75)), dtype=np.float32),
|
|
(1, 0, 3, 2),
|
|
)
|
|
full_mask = mask.full_values((3, 2))
|
|
expected_alpha = {
|
|
"SET": source[:, :, 3] * full_mask,
|
|
"EXTEND": np.maximum(source[:, :, 3], full_mask),
|
|
"SUBTRACT": source[:, :, 3] * (1.0 - full_mask),
|
|
}
|
|
|
|
for mode, expected in expected_alpha.items():
|
|
with self.subTest(mode=mode):
|
|
pixels = self.edit_mask.apply_alpha_mask(source, mask, mode)
|
|
result = np.flipud(pixels.reshape(source.shape))
|
|
np.testing.assert_allclose(result[:, :, :3], source[:, :, :3])
|
|
np.testing.assert_allclose(result[:, :, 3], expected)
|
|
|
|
|
|
def test_mask_brush_stroke_is_circular_and_continuous(self):
|
|
import numpy as np
|
|
|
|
single = self.edit_mask.rasterize_brush_path(
|
|
(120, 50),
|
|
((20, 25),),
|
|
10,
|
|
lambda path: path,
|
|
)
|
|
stroke = self.edit_mask.rasterize_brush_path(
|
|
(120, 50),
|
|
((20, 25), (100, 25)),
|
|
10,
|
|
lambda path: path,
|
|
)
|
|
single_values = single.full_values((120, 50))
|
|
stroke_values = stroke.full_values((120, 50))
|
|
|
|
self.assertGreater(single_values[25, 20], 0.9)
|
|
self.assertEqual(single_values[0, 0], 0.0)
|
|
self.assertTrue(np.all(stroke_values[25, 20:101] > 0.9))
|
|
|
|
|
|
def test_mask_brush_clips_bounds_and_projects_screen_radius(self):
|
|
clipped = self.edit_mask.rasterize_brush_path(
|
|
(80, 40),
|
|
((0, 0),),
|
|
10,
|
|
lambda path: path,
|
|
)
|
|
projected = self.edit_mask.rasterize_brush_path(
|
|
(160, 80),
|
|
((30, 30),),
|
|
10,
|
|
lambda path: tuple((x * 2.0, y * 0.5) for x, y in path),
|
|
)
|
|
|
|
self.assertEqual(clipped.bounds[:2], (0, 0))
|
|
projected_width = projected.bounds[2] - projected.bounds[0]
|
|
projected_height = projected.bounds[3] - projected.bounds[1]
|
|
self.assertGreater(projected_width, projected_height * 3)
|
|
|
|
|
|
def test_mask_brush_round_turn_stays_inside_the_radius(self):
|
|
polygons = self.image_interaction.brush_footprint_polygons(
|
|
((10.0, 10.0), (30.0, 10.0), (15.0, 11.0)),
|
|
5.0,
|
|
)
|
|
bands = self.image_interaction.scanline_union_bands(polygons)
|
|
center_band = next(
|
|
band for band in bands if band[0] <= 10.0 < band[1]
|
|
)
|
|
|
|
self.assertTrue(
|
|
all(len(intervals) == 1 for _bottom, _top, intervals in bands if intervals)
|
|
)
|
|
self.assertEqual(len(center_band[2]), 1)
|
|
sample_y = (center_band[0] + center_band[1]) / 2
|
|
half_width = (25 - (sample_y - 10) ** 2) ** 0.5
|
|
self.assertAlmostEqual(center_band[2][0][0], 10 - half_width, delta=0.03)
|
|
self.assertAlmostEqual(center_band[2][0][1], 30 + half_width, delta=0.03)
|
|
|
|
|
|
def test_mask_brush_self_intersection_uses_non_zero_winding(self):
|
|
selection_mask = self.edit_mask.rasterize_brush_path(
|
|
(80, 80),
|
|
((15, 15), (65, 65), (15, 65), (65, 15)),
|
|
6,
|
|
lambda path: path,
|
|
)
|
|
|
|
values = selection_mask.full_values((80, 80))
|
|
self.assertGreater(values[40, 40], 0.9)
|
|
|
|
|
|
def test_mask_brush_path_builds_one_coverage_after_release(self):
|
|
import numpy as np
|
|
|
|
selection_mask = self.edit_mask.rasterize_brush_path(
|
|
(80, 40),
|
|
((10, 20), (70, 20)),
|
|
6,
|
|
lambda path: path,
|
|
)
|
|
|
|
full = selection_mask.full_values((80, 40))
|
|
self.assertTrue(np.all(full[20, 10:71] > 0.9))
|
|
self.assertLess(selection_mask.bounds[0], 10)
|
|
self.assertGreater(selection_mask.bounds[2], 70)
|
|
|
|
|
|
def test_image_lasso_does_not_add_stationary_or_nearly_collinear_points(self):
|
|
path = [(0.0, 0.0)]
|
|
samples = list(path)
|
|
|
|
self.assertFalse(self.image_interaction.append_lasso_point(path, (0.0, 0.0), samples))
|
|
self.assertEqual(path, [(0.0, 0.0)])
|
|
self.assertTrue(self.image_interaction.append_lasso_point(path, (3.0, 0.0), samples))
|
|
self.assertTrue(self.image_interaction.append_lasso_point(path, (6.0, 0.2), samples))
|
|
self.assertEqual(len(path), 2)
|
|
self.assertEqual(path[-1], (6.0, 0.2))
|
|
self.assertTrue(self.image_interaction.append_lasso_point(path, (6.0, 4.0), samples))
|
|
self.assertEqual(len(path), 3)
|