Add image perspective editing and related tools

- Implemented the Image Perspective tool for editing image corners in Blender.
- Created a new operator `EditImagePerspective` to handle the perspective transformation.
- Added a preview feature for the perspective adjustment.
- Introduced the `ImagePolylineTool` for editing image masks with polylines.
- Developed backend support for Real-ESRGAN model inference, including ONNX integration.
- Added functionality for image masking and background removal.
- Created unit tests for the Real-ESRGAN ONNX model to ensure correct preprocessing and inference.

src/anyimage/server/jobs/image_mask.py

@@ -0,0 +1,134 @@
+import json
+import math
+import time
+
+from .background import remove_image_background
+
+
+def polygon_bounds(polygon):
+    import numpy as np
+
+    points = np.asarray(polygon, dtype=np.float64)
+    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")
+    left = int(math.floor(float(points[:, 0].min())))
+    top = int(math.floor(float(points[:, 1].min())))
+    right = int(math.ceil(float(points[:, 0].max())))
+    bottom = int(math.ceil(float(points[:, 1].max())))
+    if right <= left or bottom <= top:
+        raise ValueError("The selection does not define a valid image region")
+    return left, top, right, bottom
+
+
+def create_selection_canvas(input_path, polygon):
+    """Create an unbounded selection canvas with transparent black outside."""
+    import numpy as np
+    from PIL import Image, ImageDraw
+
+    with Image.open(input_path) as opened_image:
+        source = opened_image.convert("RGBA")
+    left, top, right, bottom = polygon_bounds(polygon)
+    if right <= 0 or bottom <= 0 or left >= source.width or top >= source.height:
+        raise ValueError("The selection does not overlap the source image")
+    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
+    pixels = np.asarray(canvas, dtype=np.uint8).copy()
+    pixels[~selection_mask] = 0
+    return Image.fromarray(pixels, mode="RGBA"), selection_mask, (
+        left,
+        top,
+        right,
+        bottom,
+    )
+
+
+def apply_selection_mask(foreground, selection_mask):
+    """Clear pixels outside the source selection after background removal."""
+    import numpy as np
+    from PIL import Image
+
+    pixels = np.asarray(foreground.convert("RGBA"), dtype=np.uint8).copy()
+    if pixels.shape[:2] != selection_mask.shape:
+        pixels = np.asarray(
+            foreground.convert("RGBA").resize(
+                (selection_mask.shape[1], selection_mask.shape[0]),
+                Image.Resampling.BILINEAR,
+            ),
+            dtype=np.uint8,
+        )
+    pixels[~selection_mask] = 0
+    pixels[pixels[:, :, 3] == 0, :3] = 0
+    return Image.fromarray(pixels, mode="RGBA")
+
+
+def crop_to_alpha(image, bounds):
+    """Crop an RGBA mask image to its nonzero Alpha bounds."""
+    import numpy as np
+    from PIL import Image
+
+    pixels = np.asarray(image.convert("RGBA"), dtype=np.uint8)
+    visible_y, visible_x = np.nonzero(pixels[:, :, 3] > 0)
+    if not len(visible_x):
+        raise ValueError("The selection contains no visible image pixels")
+    content_left = int(visible_x.min())
+    content_top = int(visible_y.min())
+    content_right = int(visible_x.max()) + 1
+    content_bottom = int(visible_y.max()) + 1
+    output = Image.new(
+        "RGBA",
+        (
+            content_right - content_left,
+            content_bottom - content_top,
+        ),
+        (0, 0, 0, 0),
+    )
+    output.paste(image, (-content_left, -content_top))
+    left, top, _right, _bottom = bounds
+    return output, (
+        left + content_left,
+        top + content_top,
+        left + content_right,
+        top + content_bottom,
+    )
+
+
+def run(context, parameters):
+    """Refine a gesture mask with BEN2 and return its source-image bounds."""
+    started = time.perf_counter()
+    context.progress(0.05, "Preparing image selection")
+    context.check_cancelled()
+    output_directory = context.directory
+    output_directory.mkdir(parents=True, exist_ok=True)
+    canvas, selection_mask, bounds = create_selection_canvas(
+        parameters["input"], parameters["polygon"]
+    )
+    selection_path = output_directory / "selection-input.png"
+    canvas.save(selection_path, format="PNG", compress_level=1)
+    model_manager = context.resource("model_manager")
+    context.progress(0.2, f"Loading BEN2 for {parameters['device'].upper()}")
+    foreground, _load_ms, _inference_ms = remove_image_background(
+        selection_path,
+        model_manager.directory(parameters["model"]),
+        parameters["device"],
+        model_manager,
+        context.check_cancelled,
+    )
+    context.check_cancelled()
+    context.progress(0.9, "Applying selection mask")
+    output, bounds = crop_to_alpha(
+        apply_selection_mask(foreground, selection_mask), bounds
+    )
+    output_path = output_directory / "image.png"
+    output.save(output_path, format="PNG", compress_level=1)
+    bounds_path = output_directory / "bounds.json"
+    bounds_path.write_text(json.dumps(bounds, separators=(",", ":")), encoding="utf-8")
+    elapsed_ms = (time.perf_counter() - started) * 1000.0
+    message = f"Image selection refined in {elapsed_ms:.0f} ms"
+    context.progress(1.0, message)
+    return {"image": output_path.name, "bounds": bounds_path.name}