| """Composites the placed (and signature-augmented) RGBA signature layer onto the document. |
| |
| Implements the blend modes and realism passes required by the spec: multiply |
| blend, darken blend, alpha blend, configurable ink opacity, feathering |
| (alpha-edge softening), a slight blur to match scan resolution, sensor/scan |
| noise, and anti-aliasing. |
| """ |
|
|
| from __future__ import annotations |
|
|
| from dataclasses import dataclass |
|
|
| import cv2 |
| import numpy as np |
|
|
| from src.config.schema import RenderingConfig |
| from src.utils.logging_utils import get_logger |
| from src.utils.random_utils import SeedManager, resolve_scalar_or_range |
|
|
| logger = get_logger(__name__) |
|
|
|
|
| @dataclass |
| class RenderResult: |
| """The blended document image plus the resolved rendering parameters.""" |
|
|
| image: np.ndarray |
| blend_mode: str |
| ink_opacity: float |
| blur_sigma: float |
| feather_px: float |
| scanner_noise: float |
|
|
|
|
| class Renderer: |
| """Blends a signature RGBA layer onto a document canvas with configurable realism. |
| |
| Example: |
| >>> renderer = Renderer(cfg.rendering) |
| >>> result = renderer.blend(document_rgb, signature_layer_rgba, seed_manager) |
| """ |
|
|
| def __init__(self, config: RenderingConfig) -> None: |
| self.config = config |
|
|
| def blend( |
| self, document_rgb: np.ndarray, signature_layer_rgba: np.ndarray, seed_manager: SeedManager, |
| ) -> RenderResult: |
| """Blend the signature layer onto the document and return the composited image. |
| |
| Args: |
| document_rgb: The scanned document canvas, ``(H, W, 3)`` uint8. |
| signature_layer_rgba: A full-canvas-sized RGBA layer (as produced |
| by :class:`~src.placement.placement_engine.PlacementEngine`, |
| after any signature-level augmentation), transparent outside |
| the signature. |
| seed_manager: Per-sample deterministic RNG provider. |
| |
| Returns: |
| A :class:`RenderResult` with the composited uint8 RGB image and |
| the resolved rendering parameters (for metadata export). |
| """ |
| cfg = self.config |
| rng = seed_manager.numpy_rng("rendering") |
|
|
| ink_opacity = resolve_scalar_or_range(cfg.ink_opacity, rng) |
| blur_sigma = resolve_scalar_or_range(cfg.blur_sigma, rng) |
| feather_px = resolve_scalar_or_range(cfg.feather_px, rng) |
| scanner_noise = resolve_scalar_or_range(cfg.scanner_noise, rng) |
|
|
| layer = signature_layer_rgba.astype(np.float32) |
| if feather_px > 0: |
| layer[:, :, 3] = cv2.GaussianBlur(layer[:, :, 3], (0, 0), sigmaX=feather_px) |
| if blur_sigma > 0: |
| layer = cv2.GaussianBlur(layer, (0, 0), sigmaX=blur_sigma) |
|
|
| sig_rgb = layer[:, :, :3] |
| alpha = np.clip(layer[:, :, 3] / 255.0, 0.0, 1.0) * float(np.clip(ink_opacity, 0.0, 1.0)) |
| alpha3 = alpha[:, :, None] |
|
|
| base = document_rgb.astype(np.float32) |
|
|
| if cfg.blend_mode == "multiply": |
| blended_pixel = base * (sig_rgb / 255.0) |
| elif cfg.blend_mode == "darken": |
| blended_pixel = np.minimum(base, sig_rgb) |
| else: |
| blended_pixel = sig_rgb |
|
|
| composited = base * (1 - alpha3) + blended_pixel * alpha3 |
|
|
| if scanner_noise > 0: |
| noise = rng.normal(0.0, scanner_noise * 255.0, size=composited.shape).astype(np.float32) |
| composited += noise |
|
|
| if cfg.anti_alias: |
| composited = cv2.GaussianBlur(composited, (0, 0), sigmaX=0.3) |
|
|
| out = np.clip(composited, 0, 255).astype(np.uint8) |
|
|
| return RenderResult( |
| image=out, blend_mode=cfg.blend_mode, ink_opacity=round(ink_opacity, 4), |
| blur_sigma=round(blur_sigma, 4), feather_px=round(feather_px, 4), |
| scanner_noise=round(scanner_noise, 4), |
| ) |
|
|
