pixedit 0.1.1__py3-none-any.whl

pixedit/__init__.py

@@ -0,0 +1,10 @@
+"""PixEdit, a layered desktop image editor.
+
+Launch the GUI with the ``pix`` console script or ``python -m pixedit``.
+"""
+
+from __future__ import annotations
+
+__version__ = "0.1.1"
+
+__all__ = ["__version__"]

pixedit/__main__.py

@@ -0,0 +1,10 @@
+"""Allow ``python -m pixedit`` in addition to the ``pix`` console script."""
+
+from __future__ import annotations
+
+import sys
+
+from pixedit.cli import main
+
+if __name__ == "__main__":
+    sys.exit(main())

pixedit/adjust.py

@@ -0,0 +1,175 @@
+"""Color adjustments and destructive filters.
+
+Each function returns a new image. Callers intersect with the selection and
+wrap the result in ``MutateLayerCommand``.
+"""
+
+from __future__ import annotations
+
+import numpy as np
+from PIL import Image, ImageFilter
+
+from pixedit.pixels import gaussian_image, pixelate_image
+
+
+def _rgba(image: Image.Image) -> np.ndarray:
+    return np.array(image.convert("RGBA"))
+
+
+def _from_rgb(arr: np.ndarray) -> Image.Image:
+    return Image.fromarray(np.ascontiguousarray(np.clip(np.rint(arr), 0, 255).astype(np.uint8)), "RGBA")
+
+
+def apply_masked(before: Image.Image, after: Image.Image, selection: Image.Image | None) -> Image.Image:
+    """Keep ``before`` outside the selection and ``after`` inside it."""
+    if selection is None:
+        return after
+    original = _rgba(before).astype(np.float32)
+    edited = _rgba(after).astype(np.float32)
+    mask = np.asarray(selection.convert("L")).astype(np.float32) / 255.0
+    if mask.shape != original.shape[:2]:
+        return after
+    mix = mask[..., None]
+    out = edited * mix + original * (1.0 - mix)
+    return _from_rgb(out)
+
+
+def brightness_contrast(image: Image.Image, brightness: float, contrast: float) -> Image.Image:
+    """``brightness`` and ``contrast`` are each -100..100."""
+    arr = _rgba(image).astype(np.float32)
+    factor = (100.0 + float(contrast)) / 100.0
+    shift = float(brightness) / 100.0 * 128.0
+    rgb = (arr[..., :3] - 128.0) * factor + 128.0 + shift
+    arr[..., :3] = np.clip(rgb, 0, 255)
+    return _from_rgb(arr)
+
+
+def levels(
+    image: Image.Image,
+    in_black: float,
+    in_white: float,
+    gamma: float,
+    out_black: float = 0.0,
+    out_white: float = 255.0,
+) -> Image.Image:
+    """A compact levels adjustment: input window, gamma, output window."""
+    arr = _rgba(image).astype(np.float32)
+    span = max(1.0, float(in_white) - float(in_black))
+    rgb = np.clip((arr[..., :3] - float(in_black)) / span, 0.0, 1.0)
+    rgb = np.power(rgb, 1.0 / max(0.05, float(gamma)))
+    rgb = rgb * (float(out_white) - float(out_black)) + float(out_black)
+    arr[..., :3] = np.clip(rgb, 0, 255)
+    return _from_rgb(arr)
+
+
+def _rgb_to_hsv(rgb: np.ndarray) -> tuple[np.ndarray, np.ndarray, np.ndarray]:
+    r, g, b = rgb[..., 0], rgb[..., 1], rgb[..., 2]
+    maxc = np.max(rgb, axis=-1)
+    minc = np.min(rgb, axis=-1)
+    delta = maxc - minc
+    safe = np.where(delta == 0, 1.0, delta)
+    rc = (maxc - r) / safe
+    gc = (maxc - g) / safe
+    bc = (maxc - b) / safe
+    hue = np.zeros_like(maxc)
+    hue = np.where((maxc == r) & (delta > 0), (bc - gc) % 6.0, hue)
+    hue = np.where((maxc == g) & (delta > 0), 2.0 + rc - bc, hue)
+    hue = np.where((maxc == b) & (delta > 0), 4.0 + gc - rc, hue)
+    hue = (hue / 6.0) % 1.0
+    sat = np.where(maxc > 1e-8, delta / np.maximum(maxc, 1e-8), 0.0)
+    return hue, sat, maxc
+
+
+def _hsv_to_rgb(h: np.ndarray, s: np.ndarray, v: np.ndarray) -> np.ndarray:
+    i = np.floor(h * 6.0).astype(np.int32)
+    f = h * 6.0 - i
+    p = v * (1.0 - s)
+    q = v * (1.0 - f * s)
+    t = v * (1.0 - (1.0 - f) * s)
+    i_mod = i % 6
+    r = np.choose(i_mod, [v, q, p, p, t, v])
+    g = np.choose(i_mod, [t, v, v, q, p, p])
+    b = np.choose(i_mod, [p, p, t, v, v, q])
+    return np.stack([r, g, b], axis=-1)
+
+
+def hue_saturation(
+    image: Image.Image,
+    hue_degrees: float = 0.0,
+    saturation: float = 0.0,
+    lightness: float = 0.0,
+) -> Image.Image:
+    """Shift hue (degrees), saturation (-100..100), and value (-100..100)."""
+    arr = _rgba(image).astype(np.float32)
+    rgb = arr[..., :3] / 255.0
+    hue, sat, val = _rgb_to_hsv(rgb)
+    hue = (hue + float(hue_degrees) / 360.0) % 1.0
+    sat = np.clip(sat * (1.0 + float(saturation) / 100.0), 0.0, 1.0)
+    val = np.clip(val + float(lightness) / 100.0, 0.0, 1.0)
+    arr[..., :3] = _hsv_to_rgb(hue, sat, val) * 255.0
+    return _from_rgb(arr)
+
+
+def highlights_shadows(image: Image.Image, highlight: float, shade: float) -> Image.Image:
+    """Push the bright end and the dark end. Each argument is -100..100.
+
+    Positive highlight lightens pixels that are already bright and barely
+    touches dark ones. Positive shade lightens dark pixels and barely touches
+    bright ones. A negative value darkens that end. Midtones barely move.
+    Alpha is left as it was.
+    """
+    arr = _rgba(image).astype(np.float32)
+    rgb = arr[..., :3]
+    luma = (rgb[..., 0] * 0.2126 + rgb[..., 1] * 0.7152 + rgb[..., 2] * 0.0722) / 255.0
+    # Squared weights fall off before the middle, so a highlight slider does
+    # not also lift the shadows.
+    highlight_weight = luma ** 2
+    shade_weight = (1.0 - luma) ** 2
+    rgb = rgb + (float(highlight) / 100.0) * 128.0 * highlight_weight[..., None]
+    rgb = rgb + (float(shade) / 100.0) * 128.0 * shade_weight[..., None]
+    arr[..., :3] = np.clip(rgb, 0, 255)
+    return _from_rgb(arr)
+
+
+def color_grade(
+    image: Image.Image,
+    hue: float = 0.0,
+    saturation: float = 0.0,
+    brightness: float = 0.0,
+    contrast: float = 0.0,
+    highlight: float = 0.0,
+    shade: float = 0.0,
+) -> Image.Image:
+    """One combined grade: hue and saturation, then brightness and contrast, then highlight and shade."""
+    if all(abs(float(value)) < 1e-9 for value in (hue, saturation, brightness, contrast, highlight, shade)):
+        return image.copy()
+    graded = hue_saturation(image, hue_degrees=hue, saturation=saturation, lightness=0.0)
+    graded = brightness_contrast(graded, brightness, contrast)
+    return highlights_shadows(graded, highlight, shade)
+
+
+def desaturate(image: Image.Image) -> Image.Image:
+    arr = _rgba(image).astype(np.float32)
+    luma = arr[..., 0] * 0.2126 + arr[..., 1] * 0.7152 + arr[..., 2] * 0.0722
+    arr[..., 0] = luma
+    arr[..., 1] = luma
+    arr[..., 2] = luma
+    return _from_rgb(arr)
+
+
+def invert(image: Image.Image) -> Image.Image:
+    arr = _rgba(image)
+    arr[..., :3] = 255 - arr[..., :3]
+    return Image.fromarray(arr, "RGBA")
+
+
+def blur(image: Image.Image, radius: float) -> Image.Image:
+    return gaussian_image(image.convert("RGBA"), radius)
+
+
+def sharpen(image: Image.Image) -> Image.Image:
+    return image.convert("RGBA").filter(ImageFilter.UnsharpMask(radius=2, percent=150, threshold=0))
+
+
+def pixelate(image: Image.Image, block: int) -> Image.Image:
+    return pixelate_image(image.convert("RGBA"), block)

pixedit/app.py

@@ -0,0 +1,63 @@
+"""Qt application entry used by the ``pix`` console script."""
+
+from __future__ import annotations
+
+import sys
+from pathlib import Path
+
+from PyQt6.QtGui import QColor, QIcon, QPixmap
+from PyQt6.QtWidgets import QApplication
+
+from pixedit import __version__
+
+
+def _stylesheet() -> str:
+    path = Path(__file__).resolve().parent / "resources" / "style.qss"
+    if path.is_file():
+        return path.read_text(encoding="utf-8")
+    return ""
+
+
+def _icon() -> QIcon:
+    pixmap = QPixmap(32, 32)
+    pixmap.fill(QColor("#143544"))
+    return QIcon(pixmap)
+
+
+def create_app() -> QApplication:
+    app = QApplication.instance() or QApplication(sys.argv)
+    app.setApplicationName("PixEdit")
+    app.setApplicationVersion(__version__)
+    app.setStyle("Fusion")
+    style = _stylesheet()
+    if style:
+        app.setStyleSheet(style)
+    app.setWindowIcon(_icon())
+    return app
+
+
+def run(path: str | None = None) -> int:
+    """Show the editor and enter the Qt event loop."""
+    from pixedit.ui.main_window import MainWindow
+
+    app = create_app()
+    window = MainWindow()
+    window.show()
+    if path:
+        window.open_path(path)
+    return int(app.exec())
+
+
+def check() -> int:
+    """Construct the window offscreen and return. Used by ``pix --check``."""
+    from pixedit.ui.main_window import MainWindow
+
+    app = create_app()
+    window = MainWindow()
+    window.show()
+    app.processEvents()
+    if window.session.document.width < 1 or not window.tool_by_id:
+        return 1
+    window.close()
+    app.processEvents()
+    return 0

pixedit/cli.py

@@ -0,0 +1,135 @@
+"""Console entry point.
+
+``pix`` launches the GUI, the same shape as ``rr`` launching ``rr_app``:
+a short ``[project.scripts]`` command whose ``main`` imports the Qt app only
+after argument parsing, and reports startup failures instead of dying silently.
+"""
+
+from __future__ import annotations
+
+import argparse
+import os
+import sys
+import traceback
+from datetime import datetime
+from pathlib import Path
+
+from pixedit import __version__
+
+
+def _runtime_log_dir() -> Path:
+    if sys.platform == "darwin":
+        return Path.home() / "Library" / "Logs" / "pixedit"
+    return Path.home() / ".pixedit" / "logs"
+
+
+def _write_startup_log(title: str, message: str, exc: BaseException | None = None) -> Path | None:
+    try:
+        log_dir = _runtime_log_dir()
+        log_dir.mkdir(parents=True, exist_ok=True)
+        stamp = datetime.now().strftime("%Y%m%d-%H%M%S")
+        path = log_dir / f"startup-{stamp}.log"
+        lines = [f"{title}\n", f"{message}\n"]
+        if exc is not None:
+            lines.append("\nTraceback:\n")
+            lines.append("".join(traceback.format_exception(exc)))
+        path.write_text("".join(lines), encoding="utf-8")
+        return path
+    except Exception:
+        return None
+
+
+def _missing_dep_hint(mod: str) -> str:
+    return (
+        f"Missing dependency: {mod}\n\n"
+        "From a local checkout:\n"
+        "  python -m venv .venv\n"
+        "  source .venv/bin/activate\n"
+        "  pip install -e .\n"
+    )
+
+
+def _display_available() -> bool:
+    if os.environ.get("QT_QPA_PLATFORM"):
+        return True
+    if sys.platform in {"win32", "darwin"}:
+        return True
+    return bool(os.environ.get("DISPLAY") or os.environ.get("WAYLAND_DISPLAY"))
+
+
+def _parse_args(argv: list[str] | None) -> argparse.Namespace:
+    parser = argparse.ArgumentParser(
+        prog="pix",
+        description="Launch the PixEdit layered image editor.",
+    )
+    parser.add_argument("path", nargs="?", help="Image, PDF, or .pix project to open")
+    parser.add_argument("--version", action="version", version=f"pixedit {__version__}")
+    parser.add_argument(
+        "--check",
+        action="store_true",
+        help="Construct the window and exit. Uses the offscreen Qt platform when needed.",
+    )
+    return parser.parse_args(argv)
+
+
+def main(argv: list[str] | None = None) -> int:
+    # Do not write bytecode into the checkout when the console script starts.
+    sys.dont_write_bytecode = True
+    args = _parse_args(argv)
+
+    if args.check:
+        os.environ.setdefault("QT_QPA_PLATFORM", "offscreen")
+        try:
+            from pixedit.app import check
+        except ModuleNotFoundError as exc:
+            print(_missing_dep_hint(exc.name or "unknown"), file=sys.stderr)
+            return 1
+        try:
+            return int(check())
+        except Exception as exc:
+            log_path = _write_startup_log("PixEdit check failed", "GUI failed to construct.", exc)
+            print(f"PixEdit check failed: {exc}", file=sys.stderr)
+            if log_path:
+                print(f"Details: {log_path}", file=sys.stderr)
+            return 1
+
+    if not _display_available():
+        print(
+            "PixEdit needs a display to open the editor.\n"
+            "On a headless machine, run `pix --check` to construct the UI offscreen,\n"
+            "or `pytest` to exercise the document, layer, and redaction code.",
+            file=sys.stderr,
+        )
+        return 1
+
+    try:
+        from pixedit.app import run
+    except ModuleNotFoundError as exc:
+        message = _missing_dep_hint(exc.name or "unknown")
+        log_path = _write_startup_log("PixEdit failed to start", message, exc)
+        print(message, file=sys.stderr)
+        if log_path:
+            print(f"Details: {log_path}", file=sys.stderr)
+        return 1
+    except Exception as exc:
+        log_path = _write_startup_log("PixEdit failed to initialize", "Unexpected startup error.", exc)
+        print(f"PixEdit failed to initialize: {exc}", file=sys.stderr)
+        if log_path:
+            print(f"Details: {log_path}", file=sys.stderr)
+        return 1
+
+    try:
+        return int(run(args.path) or 0)
+    except KeyboardInterrupt:
+        return 0
+    except Exception as exc:
+        log_path = _write_startup_log("PixEdit crashed on launch", "Unexpected error while starting the GUI.", exc)
+        print(f"PixEdit crashed on launch: {exc}", file=sys.stderr)
+        if log_path:
+            print(f"Details: {log_path}", file=sys.stderr)
+        traceback.print_exc()
+        return 1
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

pixedit/composite.py

@@ -0,0 +1,212 @@
+"""Flatten a document into one RGBA image.
+
+Pipeline for each visible layer, bottom to top:
+
+1. Redaction layers do not draw their own pixels. They take the canvas so
+   far, run the mask effect (pixelate, blur, solid, noise, and the rest),
+   and mix that back through the mask. Source layers underneath stay untouched.
+2. Raster and text layers are blended with a CSS-style "simple alpha
+   compositing" formula (source-over, with the blend mode applied only where
+   both coverages overlap). That keeps Multiply/Screen/Overlay from turning
+   into black when the backdrop is transparent.
+"""
+
+from __future__ import annotations
+
+import numpy as np
+from PIL import Image
+
+from pixedit.model import BLEND_MODES, Document, Layer
+from pixedit.pixels import mask_effect
+
+# geom.place_image is imported lazily inside mask placement to keep import
+# order boring: composite -> model, and geom -> model, neither imports the other
+# at module level for placement helpers defined here.
+
+
+def _blend_color(mode: str, dst: np.ndarray, src: np.ndarray) -> np.ndarray:
+    if mode == "multiply":
+        return src * dst
+    if mode == "screen":
+        return 1.0 - (1.0 - src) * (1.0 - dst)
+    if mode == "overlay":
+        # Overlay is multiply on the dark half of the backdrop and screen on the light half.
+        return np.where(
+            dst < 0.5,
+            2.0 * src * dst,
+            1.0 - 2.0 * (1.0 - src) * (1.0 - dst),
+        )
+    return src
+
+
+def blend_arrays(
+    dst: np.ndarray,
+    src: np.ndarray,
+    opacity: float = 1.0,
+    mode: str = "normal",
+) -> np.ndarray:
+    """Composite ``src`` over ``dst``. Both are float HxWx4 straight alpha, 0..1."""
+    if mode not in BLEND_MODES:
+        mode = "normal"
+    src_a = np.clip(src[..., 3:4] * float(opacity), 0.0, 1.0)
+    dst_a = np.clip(dst[..., 3:4], 0.0, 1.0)
+    src_rgb = src[..., :3]
+    dst_rgb = dst[..., :3]
+    blended = _blend_color(mode, dst_rgb, src_rgb)
+    out_a = src_a + dst_a * (1.0 - src_a)
+    # Where the backdrop is clear, fall back to the source color so blend
+    # modes do not mix against an imaginary black canvas.
+    numer = src_a * (src_rgb * (1.0 - dst_a) + blended * dst_a) + dst_rgb * dst_a * (1.0 - src_a)
+    out_rgb = np.where(out_a > 1e-6, numer / np.maximum(out_a, 1e-6), 0.0)
+    return np.concatenate(
+        [np.clip(out_rgb, 0.0, 1.0), np.clip(out_a, 0.0, 1.0)],
+        axis=-1,
+    ).astype(np.float32)
+
+
+def pil_to_float(image: Image.Image) -> np.ndarray:
+    rgba = image.convert("RGBA")
+    return np.asarray(rgba).astype(np.float32) / 255.0
+
+
+def float_to_pil(array: np.ndarray) -> Image.Image:
+    uint8 = np.clip(np.rint(array * 255.0), 0, 255).astype(np.uint8)
+    return Image.fromarray(np.ascontiguousarray(uint8), "RGBA")
+
+
+def _intersection(
+    ax: int, ay: int, aw: int, ah: int, bw: int, bh: int
+) -> tuple[int, int, int, int, int, int] | None:
+    """Overlap of a placed image (ax, ay, aw, ah) with a canvas of size bw×bh.
+
+    Returns canvas x, y, width, height and the source origin inside the image.
+    """
+    x0 = max(0, ax)
+    y0 = max(0, ay)
+    x1 = min(bw, ax + aw)
+    y1 = min(bh, ay + ah)
+    if x1 <= x0 or y1 <= y0:
+        return None
+    return x0, y0, x1 - x0, y1 - y0, x0 - ax, y0 - ay
+
+
+def blit_layer(canvas: np.ndarray, layer: Layer) -> np.ndarray:
+    image = layer.image
+    overlap = _intersection(layer.x, layer.y, image.width, image.height, canvas.shape[1], canvas.shape[0])
+    if overlap is None or layer.opacity <= 0:
+        return canvas
+    x0, y0, width, height, sx, sy = overlap
+    cropped = image.crop((sx, sy, sx + width, sy + height))
+    src = pil_to_float(cropped)
+    dst = canvas[y0 : y0 + height, x0 : x0 + width]
+    canvas[y0 : y0 + height, x0 : x0 + width] = blend_arrays(dst, src, layer.opacity, layer.blend_mode)
+    return canvas
+
+
+def mask_to_canvas(layer: Layer, width: int, height: int) -> np.ndarray:
+    """Place a redaction mask into a float HxW array covering the document."""
+    full = np.zeros((height, width), dtype=np.float32)
+    if layer.mask is None:
+        return full
+    overlap = _intersection(layer.x, layer.y, layer.mask.width, layer.mask.height, width, height)
+    if overlap is None:
+        return full
+    x0, y0, mw, mh, sx, sy = overlap
+    cropped = layer.mask.crop((sx, sy, sx + mw, sy + mh))
+    full[y0 : y0 + mh, x0 : x0 + mw] = np.asarray(cropped).astype(np.float32) / 255.0
+    return full
+
+
+def apply_redaction(canvas: np.ndarray, layer: Layer) -> np.ndarray:
+    """Mix the mask effect through ``layer``'s mask.
+
+    The effect is computed from the stack *below* this layer, so pixels in
+    earlier layers are not rewritten. Later layers still composite normally
+    and can sit above the mask (annotations, for example).
+    """
+    height, width = canvas.shape[:2]
+    mask = mask_to_canvas(layer, width, height) * float(layer.opacity)
+    if float(mask.max()) <= 0.0:
+        return canvas
+    info = layer.redaction
+    kind = info.kind if info is not None else "pixelate"
+    amount = info.amount if info is not None else 12.0
+    color = info.color if info is not None else (0, 0, 0, 255)
+    seed = info.seed if info is not None else 1
+    effect = mask_effect(canvas, kind, amount, color, seed)
+    mix = mask[..., None]
+    return (effect * mix + canvas * (1.0 - mix)).astype(np.float32)
+
+
+def composite(document: Document) -> Image.Image:
+    """Flatten ``document`` to one RGBA image the size of the canvas."""
+    canvas = np.zeros((document.height, document.width, 4), dtype=np.float32)
+    for layer in document.layers:
+        if not layer.visible or layer.opacity <= 0:
+            continue
+        if layer.kind == "redaction":
+            canvas = apply_redaction(canvas, layer)
+        else:
+            canvas = blit_layer(canvas, layer)
+    return float_to_pil(canvas)
+
+
+def composite_over(document: Document, background: tuple[int, int, int, int]) -> Image.Image:
+    """Flatten onto a solid background. Used by JPEG export."""
+    flat = composite(document)
+    base = Image.new("RGBA", flat.size, background)
+    return Image.alpha_composite(base, flat)
+
+
+def merge_pair(lower: Layer, upper: Layer) -> Layer:
+    """Bake ``upper`` into ``lower`` and return a new Normal raster layer.
+
+    The temporary canvas covers the union of both bitmaps, including pixels
+    that sit outside the document, so a merge does not clip overflow.
+    Redaction is baked by running the normal compositor on just these two
+    layers: the mask still samples only ``lower``, which is the whole stack
+    below the redaction *within this pair*.
+    """
+    from pixedit.model import Layer as LayerCls
+    from pixedit.model import new_id
+
+    def extent(layer: Layer) -> tuple[int, int, int, int]:
+        image = layer.bitmap()
+        return layer.x, layer.y, layer.x + image.width, layer.y + image.height
+
+    boxes = [extent(lower), extent(upper)]
+    min_x = min(box[0] for box in boxes)
+    min_y = min(box[1] for box in boxes)
+    max_x = max(box[2] for box in boxes)
+    max_y = max(box[3] for box in boxes)
+    width = max(1, max_x - min_x)
+    height = max(1, max_y - min_y)
+    a = lower.clone()
+    b = upper.clone()
+    a.x -= min_x
+    a.y -= min_y
+    b.x -= min_x
+    b.y -= min_y
+    temp = Document(width=width, height=height, layers=[a, b])
+    flat = composite(temp)
+    alpha = np.asarray(flat)[..., 3]
+    ys, xs = np.nonzero(alpha > 0)
+    if len(xs) == 0:
+        image = Image.new("RGBA", (1, 1), (0, 0, 0, 0))
+        x = y = 0
+    else:
+        left, top, right, bottom = int(xs.min()), int(ys.min()), int(xs.max()) + 1, int(ys.max()) + 1
+        image = flat.crop((left, top, right, bottom))
+        x = min_x + left
+        y = min_y + top
+    return LayerCls(
+        id=new_id(),
+        name=lower.name,
+        kind="raster",
+        visible=lower.visible,
+        opacity=1.0,
+        blend_mode="normal",
+        image=image,
+        x=x,
+        y=y,
+    )

pixedit/factory.py

@@ -0,0 +1,72 @@
+"""Constructors for the layer kinds the editor creates."""
+
+from __future__ import annotations
+
+import random
+
+from PIL import Image
+
+from pixedit.model import Layer, RedactionInfo, TextInfo, new_id
+from pixedit.textutil import render_text
+
+
+def raster_layer(name: str, image: Image.Image, x: int = 0, y: int = 0) -> Layer:
+    return Layer(
+        id=new_id(),
+        name=name,
+        kind="raster",
+        image=image.convert("RGBA"),
+        x=int(x),
+        y=int(y),
+    )
+
+
+def blank_layer(name: str, width: int, height: int, fill: tuple[int, int, int, int] = (0, 0, 0, 0)) -> Layer:
+    """A document-sized plate (flatten, or an explicit full-canvas fill)."""
+    return raster_layer(name, Image.new("RGBA", (width, height), fill))
+
+
+def empty_raster_layer(name: str) -> Layer:
+    """A content-sized blank layer. Painting grows it around the new marks."""
+    return raster_layer(name, Image.new("RGBA", (1, 1), (0, 0, 0, 0)), 0, 0)
+
+
+def text_layer(name: str, info: TextInfo, x: int, y: int) -> Layer:
+    return Layer(
+        id=new_id(),
+        name=name,
+        kind="text",
+        image=render_text(info),
+        x=int(x),
+        y=int(y),
+        text=info,
+    )
+
+
+def redaction_layer(
+    name: str,
+    mask: Image.Image,
+    kind: str,
+    amount: float,
+    x: int = 0,
+    y: int = 0,
+    color: tuple[int, int, int, int] = (0, 0, 0, 255),
+    seed: int | None = None,
+) -> Layer:
+    if seed is None:
+        seed = random.randrange(1, 2**31)
+    return Layer(
+        id=new_id(),
+        name=name,
+        kind="redaction",
+        image=Image.new("RGBA", (1, 1), (0, 0, 0, 0)),
+        x=int(x),
+        y=int(y),
+        mask=mask.convert("L"),
+        redaction=RedactionInfo(
+            kind=kind,
+            amount=float(amount),
+            color=tuple(int(channel) for channel in color),
+            seed=int(seed),
+        ),
+    )