Register RunningHub, Baidu, and LibLibAI visible marks; park Qingyan and MiniMax (measured)

New engines, each calibrated on its TC260 USCC cohort and validated by a full-corpus sweep (42009 files): - runninghub: top-left corner (new corner="tl"), faint mid-gray text via the new raw-grayscale "gray" detection front-end, anchor-position gate - baidu: text-run-only template (pill is a bright-blob magnet), load-bearing Doubao+Qwen rival margins, corner-extended footprint for the white tag - liblib: bottom-center (new corner="bc"), Arial silhouette (font is the discriminative lever against latin UI text), logo-extended footprint Qingyan parked (no clean-arm separation at any render/box), MiniMax/Hailuo parked (1 visible frame, the xinghui rule); silhouettes kept as starting points.
2026-08-07 14:38:35 +02:00 · 2026-07-22 13:03:03 -07:00
parent ba29eccc45
commit f1a5eecf98
22 changed files with 1233 additions and 23 deletions
@@ -0,0 +1,180 @@
+"""RunningHub visible watermark detector/localizer.
+
+RunningHub (a hosted ComfyUI platform, USCC 91340100MAEB4N8H76) stamps its
+generations with a faint light-gray "RunningHub AI生成" text mark in the
+**top-left** corner -- the China TC260 explicit AIGC label, but placed top-left
+(unlike the GB 45438-2025 house style bottom-right of Doubao/Qwen/Kling) and
+rendered in a mid-gray that the white top-hat front-end suppresses to clean-arm
+levels.
+
+Detection therefore uses the ``gray`` front-end (raw-grayscale silhouette NCC,
+see ``TextMarkConfig.detect_frontend``); removal is the shared **localize ->
+fill** (the detector's best-match box feeds :meth:`footprint_mask` ->
+``region_eraser``). This module supplies only RunningHub's tuned
+:class:`TextMarkConfig` (``assets/runninghub_alpha.png`` -- a font-rendered
+synthetic silhouette from ``scripts/render_vendor_silhouettes.py``, never cut
+from an upload).
+
+EVERY tuned number below was measured on the vendor cohort (73 TC260 carriers
+whose producer USCC names the entity, harvested 2026-07-22 by
+``scripts/vendor_cohort_harvest.py``), NOT inherited from Doubao:
+
+  * Only ~4 of the 73 cohort frames carry a visible mark (the rest are
+    metadata-only TC260 carriers -- the platform labels frames it does not
+    stamp), so recall of visible marks is 4/4 but the cohort fire rate is not
+    a recall estimate. Positions/geometry are consistent across the positives.
+  * The mark's width is ~0.32 of the frame WIDTH (0.319 measured on 832/1080/
+    1536-wide frames) at ~0.008/0.006 x/y margins; the locate box below covers
+    it with NCC slack.
+  * ``alpha_height_frac`` comes from the silhouette aspect (0.128) at the
+    measured width (0.27 * 1.25 rung ~= 0.3375 >= 0.32), per the standing rule
+    that it is measured, not inherited.
+  * STRICT ONLY (``provenance_ncc_factor`` 1.0): raw gray NCC is
+    contrast-DEPENDENT and the sub-gate band of a corner-anchored gray match is
+    unmeasured beyond the clean arm, so no provenance relaxation exists.
+  * Gate 0.34: on 283 hand-labelled clean frames (cohort-contamination-guarded)
+    corner-anchored gray NCC p99 is 0.264 / max 0.304, while the 4 positives
+    score 0.38-0.54. 0.34 sits above the clean max with a small margin; the
+    positives are few, so the margin is deliberately thin on the recall side.
+"""
+# The module-level _alpha_template / _glyph_silhouette / _template_match_score below
+# are thin test-facing shims (imported by tests/), so pyright's src-only pass sees them
+# as unused; the use is cross-module.
+# pyright: reportUnusedFunction=false
+
+from __future__ import annotations
+
+import logging
+from typing import TYPE_CHECKING, Any
+
+from remove_ai_watermarks import _text_mark_engine
+from remove_ai_watermarks._text_mark_engine import TextMarkConfig, TextMarkDetection, TextMarkEngine
+
+logger = logging.getLogger(__name__)
+
+if TYPE_CHECKING:
+    from pathlib import Path
+
+    from numpy.typing import NDArray
+
+# Locate geometry as a fraction of the image WIDTH (the measured basis: every
+# positive is portrait, where width == short side). The mark hugs the top-left
+# corner (~0.008 of width off the left edge, ~0.006 of height off the top).
+WM_WIDTH_FRAC = 0.45
+WM_HEIGHT_FRAC = 0.10
+MARGIN_LEFT_FRAC = 0.002
+MARGIN_TOP_FRAC = 0.002
+
+# Glyph appearance fields are unused by the gray front-end (it never binarizes)
+# and kept only for config parity with the other text marks.
+MAX_SATURATION = 55
+LOGO_MIN_LUMA = 150
+TOPHAT_DELTA = 12
+
+DETECT_MIN_COVERAGE = 0.04  # unused by the gray front-end (kept for config parity)
+# Calibrated 2026-07-22 on the vendor cohort vs 283 hand-labelled clean frames:
+# corner-anchored gray NCC, clean p99 0.264 / max 0.304; positives 0.38-0.54.
+DETECT_NCC_THRESHOLD = 0.34
+
+# Detection-silhouette geometry (fraction of the image width), measured on the
+# positives: mark width is ~0.320 of width on all three frame sizes (266px at 832,
+# 345px at 1080, 491px at 1536), and the NCC is razor-sharp in size (0.537 on-size,
+# 0.223 at +5.6% -- the same comb behaviour Qwen measured), so the nominal sits
+# exactly on the measured size with a TIGHT ladder around it, not the shared 3 rungs
+# (whose nearest rung landed 5.6% off and collapsed the match to 0.22).
+_ALPHA_WIDTH_FRAC = 0.32
+_ALPHA_HEIGHT_FRAC = 0.04
+_LADDER = (0.95, 1.0, 1.05)
+
+_CONFIG = TextMarkConfig(
+    name="RunningHub",
+    asset_name="runninghub_alpha.png",
+    corner="tl",
+    margin_floor=4,
+    width_frac=WM_WIDTH_FRAC,
+    height_frac=WM_HEIGHT_FRAC,
+    margin_x_frac=MARGIN_LEFT_FRAC,
+    margin_bottom_frac=MARGIN_TOP_FRAC,  # top margin for corner="tl"
+    max_saturation=MAX_SATURATION,
+    logo_min_luma=LOGO_MIN_LUMA,
+    tophat_delta=TOPHAT_DELTA,
+    morph_open_size=5,
+    detect_min_coverage=DETECT_MIN_COVERAGE,
+    detect_ncc_threshold=DETECT_NCC_THRESHOLD,
+    detect_frontend="gray",
+    scale_basis="width",  # measured: mark width tracks the frame width (0.32)
+    ladder=_LADDER,
+    alpha_width_frac=_ALPHA_WIDTH_FRAC,
+    alpha_height_frac=_ALPHA_HEIGHT_FRAC,
+    min_gw=8,
+    # STRICT ONLY: contrast-dependent gray NCC; the relaxed band is unmeasured.
+    provenance_ncc_factor=1.0,
+)
+
+RunningHubDetection = TextMarkDetection
+
+
+def _alpha_template() -> NDArray[Any] | None:
+    """The bundled RunningHub alpha template (float [0,1]), or None."""
+    return _text_mark_engine.load_alpha_template(_CONFIG.asset_name)
+
+
+def _glyph_silhouette() -> NDArray[Any] | None:
+    """Binary "RunningHub AI生成" silhouette (255 = glyph) from the alpha map, or None."""
+    return _text_mark_engine.glyph_silhouette(_CONFIG.asset_name)
+
+
+def _template_match_score(box_mask: NDArray[Any], scale_base: int) -> float:
+    """TM_CCOEFF_NORMED of the RunningHub glyph silhouette against ``box_mask``."""
+    return _text_mark_engine.template_match_score(box_mask, scale_base, _CONFIG)
+
+
+class RunningHubEngine(TextMarkEngine):
+    """Detect/localize the visible RunningHub "RunningHub AI生成" mark (top-left; localize -> fill)."""
+
+    def __init__(self) -> None:
+        super().__init__(_CONFIG)
+
+    # Anchor window for the match position, as a fraction of the FRAME: the true
+    # mark hugs the corner (measured x 0.008-0.014, y 0.005-0.007 of the frame on
+    # every cohort positive), while the full-corpus false fires (hair, shelves,
+    # window frames, CJK banners -- 37 of 42009 outside-cohort frames at the 0.34
+    # gate, 2026-07-22 sweep) match off-anchor at x 0.013-0.150 / y 0.009-0.045.
+    # No NCC gate separates them (false max 0.384 vs two positives at 0.381), but
+    # position does: every false fire sits outside this window, every positive
+    # inside. Contrast-dependent raw-gray NCC keys on "some text-like structure
+    # anywhere in the box"; the anchor is what makes it about THIS mark.
+    _ANCHOR_MAX_X = 0.025
+    _ANCHOR_MAX_Y = 0.015
+
+    def detect(self, image: NDArray[Any], *, provenance: bool = False) -> TextMarkDetection:
+        det = super().detect(image, provenance=provenance)
+        if not det.detected:
+            return det
+        loc = self.locate(image)
+        _, box = self._gray_best(image, loc)
+        if box is None:
+            det.detected = False
+            return det
+        h, w = image.shape[:2]
+        ax = (loc.x + box[0]) / w
+        ay = (loc.y + box[1]) / h
+        if ax > self._ANCHOR_MAX_X or ay > self._ANCHOR_MAX_Y:
+            logger.debug(
+                "RunningHub detect: score %.3f but match off-anchor (x=%.3f y=%.3f); demoting.",
+                det.confidence,
+                ax,
+                ay,
+            )
+            det.detected = False
+        return det
+
+
+def load_image_bgr(path: str | Path) -> NDArray[Any]:
+    """Read an image as BGR ndarray (helper for scripts/tests)."""
+    from remove_ai_watermarks import image_io
+
+    img = image_io.imread(path)
+    if img is None:
+        raise FileNotFoundError(f"Failed to read image: {path}")
+    return img