mirror of
https://github.com/wiltodelta/remove-ai-watermarks.git
synced 2026-08-09 23:50:40 +02:00
Victor KuznetsovandClaude Opus 5
78d9e81d0f
The visible-mark path had grown three copies of one ladder sweep, four
near-identical `detect` arms, and four hand-rolled `footprint_mask` overrides;
mark knowledge sat in five hand-maintained tables across three modules; and the
flagship `all`/`batch` pipeline existed only in cli.py, written twice with
divergent behavior.
Detection is now one measurement. `_ladder_best` replaces the three sweeps,
`_scan`/`_verdict` replace the four arms, and the winning box travels to the
mask on `TextMarkDetection.match_box` instead of being swept a second time.
`detect_both` returns the strict and relaxed verdicts from one scan, which
halves the arbiter's perception cost (260 -> 130 matchTemplate calls on a 2048²
image, verdicts identical field for field). A per-mark demotion goes in the new
`_post_gate` hook, never in a `detect` override -- an override is invisible to
the single-pass path, which is how the RunningHub and Yuanbao anchor gates
briefly stopped applying.
Everything about a mark is now one registry row: product, label regime, the
platform sentence `identify` reports, the metadata signals that confirm it, and
its TC260 producer codes. `identify._VISIBLE_MARK_PLATFORM`, the signal mapping
in `api.visible_provenance`, `_PRODUCT_OF` and the pill veto are derived from
those rows.
`api.remove_all` / `api.remove_batch` are the library form of the `all` and
`batch` commands; the CLI is a wrapper that owns console text and exit codes.
Progress is a `(stage, detail)` pair of stable tokens, so the CLI keys its
wording off structure rather than parsing the library's prose back.
Two intentional behavior changes, both verified against a recorded 811-image
sample of detector verdicts, removal-mask hashes, arbiter decisions and
`identify` reports:
* A TC260 label now relaxes the vendor its `ContentProducer` names rather than
ByteDance's pair on every China-AIGC image. 333 of 811 samples move; on 185
of them the previously relaxed pair was simply the wrong vendor, and the
mark actually present never reached the relaxed gate its own
`provenance_ncc_factor` was calibrated for.
* A confident LibLibAI detection suppresses the Jimeng pill, like every other
TC260 product's mark. It was registered alongside RunningHub and Baidu, both
of which were added to the hand-written veto list, and it was not. 1 sample
moves, and it is exactly the co-firing case.
Nothing else in that record changes: detector verdicts, mask hashes and
`identify` verdicts are byte-identical, and all 200 calibration constants are
untouched.
Also: `aigc_label` and friends plus `extract_c2pa_info` are memoized on
(path, mtime_ns, size) -- size because this package rewrites in place; the
native TC260 container readers route on magic bytes instead of the file
extension, so a mislabeled AVI or FLV is no longer invisible; `identify` shares
one pixel decode between the DWT-DCT and visible stages (TrustMark keeps its own
Pillow decode, which is not substitutable); and the six `stabilize_*` video
wrappers collapse into one policy table.
Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
103 lines
4.3 KiB
Python
103 lines
4.3 KiB
Python
"""Samsung Galaxy AI visible watermark detector/localizer.
|
|
|
|
Samsung's on-device Generative AI photo edits burn a visible "✦ Contenuti generati
|
|
dall'AI" wordmark into the bottom-LEFT corner (the Italian locale variant calibrated
|
|
here; the string is locale-specific -- DETECTION only matches this locale's silhouette,
|
|
so other locales are not yet detected, though the fill mask itself is locale-agnostic).
|
|
It is a faint, near-white semi-transparent overlay, the same overlay class as the
|
|
Doubao/Jimeng marks but bottom-left.
|
|
|
|
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 shares
|
|
:class:`remove_ai_watermarks._text_mark_engine.TextMarkEngine` and
|
|
supplies only Samsung's tuned :class:`TextMarkConfig` (bottom-LEFT corner, a lower glyph
|
|
luma since the mark is faint, ``assets/samsung_alpha.png`` -- the detection silhouette,
|
|
solved from the flat captures by ``scripts/visible_alpha_solve.py``). Samsung Galaxy AI
|
|
edits are also caught by C2PA + the ``genAIType`` marker, so this is the visible-mark
|
|
*removal* path; it also feeds ``identify`` as the medium-confidence ``visible_samsung``
|
|
signal via the registry.
|
|
"""
|
|
# 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, TextMarkEngine
|
|
|
|
if TYPE_CHECKING:
|
|
from numpy.typing import NDArray
|
|
|
|
# Locate geometry as a fraction of image WIDTH (mark scales with width, bottom-LEFT).
|
|
WM_WIDTH_FRAC = 0.40
|
|
WM_HEIGHT_FRAC = 0.060
|
|
MARGIN_LEFT_FRAC = 0.004
|
|
MARGIN_BOTTOM_FRAC = 0.002
|
|
|
|
# Glyph appearance: a light, low-saturation gray. LOGO_MIN_LUMA is lower than Jimeng's
|
|
# because the mark is faint (peak alpha ~0.38), so on a mid/dark background its glyph
|
|
# luma is lower; a white-paper document is still left untouched.
|
|
MAX_SATURATION = 55
|
|
LOGO_MIN_LUMA = 110
|
|
TOPHAT_DELTA = 8
|
|
|
|
# Shape-consistent detection. Threshold 0.40; real marks ~0.79, and Doubao/Jimeng score
|
|
# 0.0 here (and Samsung 0.0 on theirs) -- no cross-fire (the corner also differs).
|
|
DETECT_MIN_COVERAGE = 0.01
|
|
DETECT_NCC_THRESHOLD = 0.40
|
|
|
|
# Detection-silhouette geometry, solved by scripts/visible_alpha_solve.py from the flat
|
|
# gray capture (native width 1086). Real photos are ~2958 wide, so the captured glyph is
|
|
# upscaled; width-scale + NCC-align sizes the silhouette for the detection match (removal
|
|
# is the template-free glyph-bbox footprint mask).
|
|
_ALPHA_NATIVE_WIDTH = 1086
|
|
_ALPHA_WIDTH_FRAC = 0.3195 # asset width / image width -- sizes the detection silhouette
|
|
_ALPHA_HEIGHT_FRAC = 0.0378
|
|
|
|
_CONFIG = TextMarkConfig(
|
|
name="Samsung Galaxy AI",
|
|
asset_name="samsung_alpha.png",
|
|
corner="bl",
|
|
margin_floor=2,
|
|
width_frac=WM_WIDTH_FRAC,
|
|
height_frac=WM_HEIGHT_FRAC,
|
|
margin_x_frac=MARGIN_LEFT_FRAC,
|
|
margin_bottom_frac=MARGIN_BOTTOM_FRAC,
|
|
max_saturation=MAX_SATURATION,
|
|
logo_min_luma=LOGO_MIN_LUMA,
|
|
tophat_delta=TOPHAT_DELTA,
|
|
morph_open_size=3,
|
|
detect_min_coverage=DETECT_MIN_COVERAGE,
|
|
detect_ncc_threshold=DETECT_NCC_THRESHOLD,
|
|
alpha_width_frac=_ALPHA_WIDTH_FRAC,
|
|
alpha_height_frac=_ALPHA_HEIGHT_FRAC,
|
|
min_gw=16,
|
|
)
|
|
|
|
|
|
def _alpha_template() -> NDArray[Any] | None:
|
|
"""The bundled Samsung alpha template (float [0,1]), or None."""
|
|
return _text_mark_engine.load_alpha_template(_CONFIG.asset_name)
|
|
|
|
|
|
def _glyph_silhouette() -> NDArray[Any] | None:
|
|
"""Binary "Contenuti generati dall'AI" silhouette (255 = glyph), 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 Samsung glyph silhouette against ``box_mask``."""
|
|
return _text_mark_engine.template_match_score(box_mask, scale_base, _CONFIG)
|
|
|
|
|
|
class SamsungEngine(TextMarkEngine):
|
|
"""Detect/localize the visible Samsung Galaxy AI text mark (locate -> mask; mask feeds the fill)."""
|
|
|
|
def __init__(self) -> None:
|
|
super().__init__(_CONFIG)
|