Add comprehensive tests for cutout and mesh functionalities

- Introduced `test_cutout.py` to validate cutout pie menu behavior, image lasso options, and mesh detail calculations.
- Added `test_mesh.py` to ensure correct tangent normal rasterization, plane source topology, and depth surface evaluations.
- Created `test_mesh_blender.py` to verify material node groups, tangent baking, and local cutout building from Blender images.
- Implemented tests for handling alpha regions and ensuring geometry nodes maintain expected behavior.

src/anyimage/server/jobs/image_mask.py

@@ -22,10 +22,68 @@ def polygon_bounds(polygon):
     return left, top, right, bottom
 
 
-def create_selection_canvas(input_path, polygon):
+def polygon_selection_mask(image_size, polygon, fill_rule="EVEN_ODD"):
+    """Rasterize a polygon with an explicit fill rule."""
+    import numpy as np
+
+    width, height = (int(value) for value in image_size)
+    points = np.asarray(polygon, dtype=np.float64)
+    if width <= 0 or height <= 0:
+        raise ValueError("The selection canvas has no readable dimensions")
+    if points.ndim != 2 or points.shape[0] < 3 or points.shape[1] != 2:
+        raise ValueError("The selection does not define a valid image region")
+    if not np.isfinite(points).all():
+        raise ValueError("The selection contains invalid image coordinates")
+    if fill_rule not in {"EVEN_ODD", "NONZERO"}:
+        raise ValueError(f"Unknown polygon fill rule: {fill_rule}")
+
+    scanlines = np.arange(height, dtype=np.float64) + 0.5
+    crossings = [[] for _index in range(height)]
+    for start, end in zip(points, np.roll(points, -1, axis=0)):
+        selected = np.flatnonzero(
+            (start[1] > scanlines) != (end[1] > scanlines)
+        )
+        if not len(selected):
+            continue
+        crossing_x = start[0] + (
+            (scanlines[selected] - start[1])
+            * (end[0] - start[0])
+            / (end[1] - start[1])
+        )
+        winding = 1 if end[1] > start[1] else -1
+        for row, value in zip(selected, crossing_x):
+            crossings[int(row)].append((float(value), winding))
+
+    mask = np.zeros((height, width), dtype=bool)
+    for row, values in enumerate(crossings):
+        values.sort()
+        state = 0
+        index = 0
+        while index < len(values):
+            crossing_x = values[index][0]
+            winding = 0
+            count = 0
+            while index < len(values) and values[index][0] == crossing_x:
+                winding += values[index][1]
+                count += 1
+                index += 1
+            state = (
+                state + winding
+                if fill_rule == "NONZERO"
+                else state ^ (count % 2)
+            )
+            if index >= len(values) or state == 0:
+                continue
+            following_x = values[index][0]
+            first = max(0, int(math.ceil(crossing_x - 0.5)))
+            last = min(width, int(math.floor(following_x - 0.5)) + 1)
+            mask[row, first:last] = True
+    return mask
+
+def create_selection_canvas(input_path, polygon, fill_rule="EVEN_ODD"):
     """Create an unbounded selection canvas with transparent black outside."""
     import numpy as np
-    from PIL import Image, ImageDraw
+    from PIL import Image
 
     with Image.open(input_path) as opened_image:
         source = opened_image.convert("RGBA")
@@ -35,9 +93,7 @@ def create_selection_canvas(input_path, polygon):
     canvas = Image.new("RGBA", (right - left, bottom - top), (0, 0, 0, 0))
     canvas.paste(source, (-left, -top))
     relative = [(float(x) - left, float(y) - top) for x, y in polygon]
-    selection = Image.new("L", canvas.size, 0)
-    ImageDraw.Draw(selection).polygon(relative, fill=255)
-    selection_mask = np.asarray(selection, dtype=np.uint8) > 0
+    selection_mask = polygon_selection_mask(canvas.size, relative, fill_rule)
     pixels = np.asarray(canvas, dtype=np.uint8).copy()
     pixels[~selection_mask] = 0
     return Image.fromarray(pixels, mode="RGBA"), selection_mask, (