Register the Qwen 千问AI生成 visible text mark

Calibrated on the 117-frame TC260-producer cohort (vendor_cohort_harvest +
vendor_mark_calibrate, both committed here): per-mark 2-rung ladder
(0.78, 1.27) for the two measured size modes, fitted locate box (the mark
sits ~0.025 of the short side off the edge; doubao's box clipped the first
glyph), measured template aspect 0.26, gate 0.45 (clean p99 0.301).
Strict-only (the sub-gate band is non-Qwen banners), no rival margin
(0 cross-fires on 400 doubao / 298 jimeng / 286 clean frames).
83/83 real marks detector-clean after cv2 fill.

TextMarkConfig gains a per-mark ladder field; the shipped 3-rung default
is unchanged for every other mark.

src/remove_ai_watermarks/_text_mark_engine.py

@@ -131,6 +131,14 @@ class TextMarkConfig:
     # Which image dimension the mark's size and margins scale with. VENDOR-SPECIFIC,
     # measured, not assumed -- see TextMarkEngine.scale_base. "short" = min(h, w), "width" = w.
     scale_basis: Literal["short", "width"] = "width"
+    # Scale rungs ``_tophat_best`` sweeps (the detection comb). PER-MARK: a vendor
+    # whose stamp sizes do not land on the shared 3-rung comb carries its own ladder
+    # (measured for 千问, whose marks sit in two size modes ~1.6x apart -- one fraction
+    # on 3 rungs covers only ~75% of them). Densifying the SHARED ladder for everyone
+    # was measured and rejected (false fire 2.52% -> 3.05%; see docs/verification-plan.md
+    # B2), so the default stays the shipped 3 rungs and a deviation must be calibrated
+    # per mark on real positives, never ported.
+    ladder: tuple[float, ...] = (0.8, 1.0, 1.25)
     rivals: tuple[str, ...] = ()
     rival_margin: float = 0.10
     # Multiplier applied to detect_ncc_threshold when provenance confirms the vendor.
@@ -345,9 +353,10 @@ class TextMarkEngine:
         """Best TM_CCOEFF_NORMED of a soft template against the continuous response, and
         the ROI-local box (x0, y0, x1, y1) where that best match sits.
 
-        Sweeps a small scale band: the nominal glyph size is derived from the mark's
+        Sweeps the mark's scale ladder: the nominal glyph size is derived from the mark's
         geometry, but a vendor re-rasterization shifts it by a few percent and the
-        continuous response is sharp enough that an exact-size template would miss.
+        continuous response is sharp enough that an exact-size template would miss. The
+        ladder is per-mark (``TextMarkConfig.ladder``), defaulting to the shipped 3 rungs.
 
         Detection and the removal mask BOTH read this one method -- the score gates
         detection, the box bounds the fill. Sharing it is deliberate: the standing rule is
@@ -363,7 +372,7 @@ class TextMarkEngine:
         base = self.scale_base(image)
         best_score = 0.0
         best_box: tuple[int, int, int, int] | None = None
-        for scale in (0.8, 1.0, 1.25):
+        for scale in c.ladder:
             gw = max(c.min_gw, int(c.alpha_width_frac * base * scale))
             gh = max(4, int(c.alpha_height_frac * base * scale))
             if gw >= resp.shape[1] or gh >= resp.shape[0]:

src/remove_ai_watermarks/cli.py

@@ -430,7 +430,7 @@ def _no_visible_mark_exit(source: Path) -> NoReturn:
     """Explain why no visible watermark was removed, then exit non-zero.
 
     The visible registry handles only known visual marks (the Gemini sparkle and
-    the Doubao/Jimeng/Samsung text strips). Most real uploads carry no such mark
+    the Doubao/Jimeng/Qwen/Samsung text strips). Most real uploads carry no such mark
     -- frequently an invisible/metadata watermark instead (e.g. an OpenAI or
     Gemini image whose only signal is C2PA + SynthID). Returning the input
     unchanged with exit 0 reads as success to a caller and re-serves the
@@ -692,7 +692,7 @@ def cmd_visible(
 ) -> None:
     """Remove a known visible AI watermark from an image.
 
-    Finds a known mark in its usual place (Gemini sparkle / Doubao-Jimeng-Samsung
+    Finds a known mark in its usual place (Gemini sparkle / Doubao-Jimeng-Qwen-Samsung
     text) via the watermark registry and removes it by LOCALIZING the mark to a mask
     and filling that mask with the chosen ``--backend`` (auto: best available, LaMa >
     MI-GAN > cv2). ``--mark auto`` removes every detected mark in one

src/remove_ai_watermarks/identify.py

@@ -446,12 +446,13 @@ def _visible_sparkle(image_path: Path, *, image: NDArray[Any] | None = None) ->
 _VISIBLE_MARK_PLATFORM = {
     "doubao": "ByteDance Doubao (visible 豆包AI生成 mark detected)",
     "jimeng": "ByteDance Jimeng / Dreamina (visible 即梦AI mark detected)",
+    "qwen": "Alibaba Tongyi Qianwen (visible 千问AI生成 mark detected)",
     "samsung": "Samsung Galaxy AI (visible 'Contenuti generati dall'AI' mark detected)",
 }
 
 
 def _visible_text_marks(image_path: Path, *, image: NDArray[Any] | None = None) -> list[MarkDetection]:
-    """Detected visible Doubao/Jimeng marks (registry ``MarkDetection`` list).
+    """Detected visible text marks (registry ``MarkDetection`` list).
 
     The Gemini sparkle keeps its own ``_visible_sparkle`` path (file-level
     confidence); these two text marks reuse the registry detectors, which apply

src/remove_ai_watermarks/qwen_engine.py

@@ -0,0 +1,157 @@
+"""Qwen (Tongyi Qianwen, Alibaba) visible watermark detector/localizer.
+
+Qwen stamps its generations with a visible "千问AI生成" text strip in the
+bottom-right corner -- the explicit AIGC label mandated by China's GB 45438-2025
+(the same 6-glyph house style as Doubao's "豆包AI生成": a 2-glyph vendor prefix
+plus the shared `AI生成` tail), preceded by the vendor's tri-lobe logo (not part
+of the detection silhouette -- logos vary between releases, the CJK run is what
+discriminates).
+
+Detection matches the bundled glyph silhouette against the corner; removal is the
+shared **localize -> fill** (the glyph-bbox :meth:`footprint_mask` feeds
+``region_eraser``), NOT reverse-alpha. This module supplies only Qwen's tuned
+:class:`TextMarkConfig` (``assets/qwen_alpha.png`` -- a font-rendered synthetic
+silhouette from ``scripts/render_vendor_silhouettes.py``, never cut from an
+upload). It also feeds ``identify`` as the medium-confidence ``visible_qwen``
+signal via the registry.
+
+EVERY tuned number below was measured on the vendor cohort (117 TC260 carriers
+whose producer USCC 91440101MA9Y9T4H7A names the entity, 2026-07-21; harness
+``scripts/vendor_mark_calibrate.py``), NOT inherited from Doubao:
+
+  * The mark sits in TWO size modes (frac of the short side ~0.124 and ~0.203,
+    ratio 1.64 -- wider than the shared 3-rung ladder's 1.5625 span), so a single
+    fraction on the shared ladder covers ~75% of marks and the rest land in the
+    comb's collapse zone. Qwen therefore carries its OWN 2-rung ladder
+    (``TextMarkConfig.ladder``), one rung centred on each mode; the shared
+    default is untouched for every other mark.
+  * The mark also sits FARTHER off the corner than Doubao's box assumes (right
+    margin ~0.025 vs 0.004 of the short side), so Doubao's locate box clipped the
+    first glyph and collapsed an exact-size template to 0.26; the box fractions
+    below are fitted from the measured absolute mark rects.
+  * ``alpha_height_frac`` comes from the aspect fit at the winning width (p50
+    aspect 0.26), not from the silhouette's own aspect (0.2219) and not from
+    Doubao's ratio.
+  * STRICT ONLY (``provenance_ncc_factor`` 1.0): the score band just below the
+    gate is dominated by non-Qwen banners on same-cohort frames (a 夸克
+    anti-forgery strip at 0.274, a 造点 mark at 0.253), so a provenance-relaxed
+    arm would be mostly false fills. No provenance relaxation exists for this
+    mark.
+  * No rival margin: at the shipped gate the template fires on 0 of 400
+    Doubao-marked frames, 0 of 298 Jimeng-marked frames and 0 of 286 hand-labelled
+    clean frames (the shared tail correlates at ~0.22, far below the gate), while
+    a 0.10 rival margin would have suppressed ~10% of genuine Qwen detections.
+"""
+# 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
+
+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
+
+if TYPE_CHECKING:
+    from pathlib import Path
+
+    from numpy.typing import NDArray
+
+# Locate geometry as a fraction of the image SHORT side (measured basis -- see
+# scale_base). The box is fitted to the measured mark rects: the mark's right
+# margin is ~0.025 of the short side (not Doubao's 0.004), so the box anchor is
+# wider off the corner; width/height cover the big size mode plus NCC slack.
+WM_WIDTH_FRAC = 0.231
+WM_HEIGHT_FRAC = 0.074
+MARGIN_RIGHT_FRAC = 0.0203
+MARGIN_BOTTOM_FRAC = 0.0218
+
+# Glyph appearance: a light, low-saturation gray rendered brighter than the local
+# background (white top-hat), same overlay class as Doubao -- inherited, and
+# harmless because the tophat front-end turns these gates into weights.
+MAX_SATURATION = 55
+LOGO_MIN_LUMA = 150
+TOPHAT_DELTA = 12
+
+DETECT_MIN_COVERAGE = 0.04  # unused by the tophat front-end (kept for config parity)
+# Calibrated 2026-07-21 on the vendor cohort vs 286 hand-labelled clean frames
+# (cohort-contamination-guarded): clean p99 0.301 / max 0.316, and every cohort
+# frame scoring >= 0.45 carries a visible 千问AI生成 mark (86% of the eyeballed
+# visible marks fire, the misses being white-on-near-white contrast losses).
+# 0.45 was picked over 0.32 (identical clean fire) for margin against unseen
+# clean content at zero measured recall cost.
+DETECT_NCC_THRESHOLD = 0.45
+
+# Detection-silhouette geometry (fraction of the short side), fitted on the
+# cohort: the mark's width modes and its aspect (0.26) at the winning width.
+_ALPHA_WIDTH_FRAC = 0.160
+_ALPHA_HEIGHT_FRAC = 0.0416
+
+# The two measured size modes as scale rungs: 0.124 and 0.203 of the short side,
+# expressed against the 0.160 nominal. Measured, not rounded: off-mode rungs drop
+# NCC from ~0.73 to ~0.37 on real marks (the comb), and a 4-rung variant scored
+# strictly worse (the extra rungs cover nothing and the big mode lands 4.6% off
+# its nearest rung).
+_LADDER = (0.78, 1.27)
+
+_CONFIG = TextMarkConfig(
+    name="Qwen",
+    asset_name="qwen_alpha.png",
+    corner="br",
+    margin_floor=4,
+    width_frac=WM_WIDTH_FRAC,
+    height_frac=WM_HEIGHT_FRAC,
+    margin_x_frac=MARGIN_RIGHT_FRAC,
+    margin_bottom_frac=MARGIN_BOTTOM_FRAC,
+    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="tophat",
+    scale_basis="short",  # measured: frac_short CV 0.189 vs width 0.273
+    ladder=_LADDER,
+    alpha_width_frac=_ALPHA_WIDTH_FRAC,
+    alpha_height_frac=_ALPHA_HEIGHT_FRAC,
+    min_gw=8,
+    # STRICT ONLY: the sub-gate band is dominated by non-Qwen banners, so
+    # provenance relaxation is disabled outright (factor 1.0 = never relaxed).
+    provenance_ncc_factor=1.0,
+)
+
+QwenDetection = TextMarkDetection
+
+
+def _alpha_template() -> NDArray[Any] | None:
+    """The bundled Qwen alpha template (float [0,1]), or None."""
+    return _text_mark_engine.load_alpha_template(_CONFIG.asset_name)
+
+
+def _glyph_silhouette() -> NDArray[Any] | None:
+    """Binary "千问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 Qwen glyph silhouette against ``box_mask``."""
+    return _text_mark_engine.template_match_score(box_mask, scale_base, _CONFIG)
+
+
+class QwenEngine(TextMarkEngine):
+    """Detect/localize the visible Qwen "千问AI生成" watermark (locate -> mask; mask feeds the fill)."""
+
+    def __init__(self) -> None:
+        super().__init__(_CONFIG)
+
+
+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

src/remove_ai_watermarks/watermark_registry.py

@@ -20,6 +20,7 @@ Entries:
   - ``gemini`` -- Google Gemini / Nano Banana sparkle, bottom-right.
   - ``doubao`` -- ByteDance Doubao "豆包AI生成" text strip, bottom-right.
   - ``jimeng`` -- ByteDance Jimeng / Dreamina "★ 即梦AI" wordmark, bottom-right.
+  - ``qwen`` -- Alibaba Tongyi Qianwen "千问AI生成" text strip, bottom-right.
   - ``samsung`` -- Samsung Galaxy AI "Contenuti generati dall'AI" strip, bottom-left.
   - ``jimeng_pill`` -- Jimeng-basic "AI生成" pill, top-left (capture-less).
 """
@@ -83,6 +84,7 @@ _PRODUCT_OF: dict[str, str] = {
     "doubao": "doubao",
     "jimeng": "jimeng",
     "jimeng_pill": "jimeng",  # same product as the Jimeng wordmark
+    "qwen": "qwen",
     "samsung": "samsung",
 }
 
@@ -353,6 +355,10 @@ def _engine(key: str) -> Any:
             from remove_ai_watermarks.jimeng_engine import JimengEngine
 
             _engines[key] = JimengEngine()
+        elif key == "qwen":
+            from remove_ai_watermarks.qwen_engine import QwenEngine
+
+            _engines[key] = QwenEngine()
         elif key == "samsung":
             from remove_ai_watermarks.samsung_engine import SamsungEngine
 
@@ -502,6 +508,7 @@ _REGISTRY: tuple[KnownMark, ...] = (
     KnownMark("gemini", "Google Gemini sparkle", "bottom-right", True, _gemini_detect, _gemini_mask),
     _text_mark("doubao", "Doubao 豆包AI生成 text", "bottom-right"),
     _text_mark("jimeng", "Jimeng 即梦AI wordmark", "bottom-right"),
+    _text_mark("qwen", "Qwen 千问AI生成 text", "bottom-right"),
     _text_mark("samsung", "Samsung Galaxy AI text", "bottom-left"),
     KnownMark("jimeng_pill", "Jimeng AI生成 pill", "top-left", True, _pill_detect, _pill_mask, _pill_features),
 )
@@ -580,9 +587,10 @@ def _keep_pill(keys: set[str], *, provenance: frozenset[str], footprint_flat: bo
         so real flat-scene pills (and harmless flat false fires) are cleaned while the
         damaging textured false fires are left untouched.
     A Doubao image is TC260 too but is not Jimeng-basic, so the pill never rides on a
-    Doubao detection. No confirmation at all -> never remove (blocks false fires on
-    non-Jimeng content)."""
-    if "doubao" in keys:
+    Doubao detection; a Qwen image likewise (another vendor's bottom-right mark naming
+    its own product), so a confident Qwen detection suppresses the pill the same way.
+    No confirmation at all -> never remove (blocks false fires on non-Jimeng content)."""
+    if "doubao" in keys or "qwen" in keys:
         return False
     if "jimeng" in keys:
         return True