demark 0.0.1__tar.gz

demark-0.0.1/PKG-INFO

@@ -0,0 +1,195 @@
+Metadata-Version: 2.4
+Name: demark
+Version: 0.0.1
+Summary: Automatic image watermark detection and removal toolkit (CV + DL methods)
+Author-email: akino <6130092+cycleuser@users.noreply.github.com>
+License-Expression: GPL-3.0-or-later
+Project-URL: Homepage, https://github.com/cycleuser/demark
+Project-URL: Repository, https://github.com/cycleuser/demark
+Project-URL: Documentation, https://github.com/cycleuser/demark#readme
+Project-URL: Changelog, https://github.com/cycleuser/demark/releases
+Keywords: watermark,watermark-removal,inpainting,image-processing,opencv,lama,alpha-matting,line-art
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Science/Research
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Multimedia :: Graphics :: Editors
+Classifier: Topic :: Scientific/Engineering :: Image Processing
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+Requires-Dist: numpy>=1.24
+Requires-Dist: opencv-python>=4.8
+Requires-Dist: scipy>=1.10
+Requires-Dist: scikit-image>=0.20
+Requires-Dist: Pillow>=10.0
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0; extra == "dev"
+Requires-Dist: ruff; extra == "dev"
+Requires-Dist: mypy; extra == "dev"
+Provides-Extra: deep
+Requires-Dist: torch>=2.0; extra == "deep"
+Requires-Dist: simple-lama-inpainting; extra == "deep"
+Provides-Extra: sd
+Requires-Dist: torch>=2.0; extra == "sd"
+Requires-Dist: diffusers>=0.20; extra == "sd"
+Requires-Dist: transformers>=4.30; extra == "sd"
+
+# DeMark
+
+Automatic image watermark detection and removal toolkit. Multiple methods from classic CV to deep learning, pick what fits your watermark type.
+
+## What it does
+
+Detects watermark regions in images and removes them while preserving underlying content. Ten methods are implemented:
+
+| Method | Type | Best for | Lossless? |
+|--------|------|----------|-----------|
+| `auto` | — | Auto-selects best method | — |
+| `cv_telea` | CV inpaint [6] | Small/thin watermarks | No |
+| `cv_ns` | CV inpaint [7] | Smooth gradients around watermark | No |
+| `fft_notch` | Frequency | Repeating/tiled periodic watermarks | Partial |
+| `color_mask` | CV segmentation | Solid-color text (white on photo) | No |
+| `edge_inpaint` | Edge + inpaint [5] | Text/logos with sharp edges | No |
+| `template` | Template match | Known watermark logo | No |
+| `alpha_invert` | Alpha matting [8] | Known watermark + transparency | **Yes** |
+| `lama` | Deep learning [1] | Large masked regions | No |
+| `sd_inpaint` | Diffusion [2] | Generative content fill | No |
+| `precise` | Alpha inversion + line protection | Semi-transparent text on line art | Partial |
+| `harmonic` | Multi-scale + auto-optimisation | Any scale, self-tuning | Partial |
+
+## What it does NOT do
+
+- No batch GUI — CLI and Python API only. For a GUI, use IOPaint (23k stars) which wraps LaMa.
+- No video watermark removal — for video use ProPainter (sczhou/ProPainter).
+- No invisible/digital watermark removal — those require diffusion-based attacks (see [10]).
+- `alpha_invert` is the only truly lossless method, and it requires the watermark pattern and alpha to be known.
+
+## Requirements
+
+- Python 3.9+
+- OpenCV, NumPy, SciPy, scikit-image, Pillow
+- For deep learning methods: `pip install demark[deep]` (LaMa) or `pip install demark[sd]` (Stable Diffusion)
+
+## Installation
+
+```bash
+# From PyPI
+pip install demark
+
+# Optional deep learning extras (LaMa / Stable Diffusion)
+pip install "demark[deep]"      # LaMa inpainting
+pip install "demark[sd]"        # Stable Diffusion inpainting
+
+# From source
+git clone https://github.com/cycleuser/demark.git
+cd demark
+pip install -e .
+```
+
+## Quick Start
+
+```bash
+# Auto-detect and remove
+demark remove watermarked.jpg clean.jpg
+
+# Use specific method
+demark remove watermarked.jpg clean.jpg --method fft_notch
+
+# Known watermark logo — template matching
+demark remove watermarked.jpg clean.jpg --method template --template logo.png
+
+# Known watermark overlay + alpha — lossless removal
+demark remove watermarked.jpg clean.jpg --method alpha_invert --watermark wm_overlay.png --alpha 0.4
+
+# Scale-adaptive multi-scale + auto-optimisation (works at any scale)
+demark remove watermarked.jpg clean.jpg --method harmonic --bbox 1056 1249 1304 1305
+
+# Just detect the mask
+demark detect watermarked.jpg mask.png
+
+# JSON output
+demark --json remove watermarked.jpg clean.jpg
+```
+
+## Usage
+
+### CLI
+
+```
+demark [-V] [-v] [-o OUTPUT] [--json] [-q] <command> ...
+
+Commands:
+  remove   <input> <output> [--method M] [--mask M.png] [--template T.png]
+                         [--watermark W.png] [--alpha 0.4] [--radius 5]
+  detect   <input> <output> [--method auto|edge|color|otsu]
+  list-methods
+```
+
+### Python API
+
+```python
+from demark import remove_watermark, detect_watermark
+
+# Auto remove
+r = remove_watermark(input_path="wm.jpg", output_path="clean.jpg")
+print(r.success)        # True
+print(r.data["method"]) # "edge_inpaint"
+print(r.data["elapsed"])# 0.123
+
+# Specific method
+r = remove_watermark(
+    input_path="wm.jpg",
+    output_path="clean.jpg",
+    method="fft_notch"
+)
+
+# Detect only
+r = detect_watermark(input_path="wm.jpg", output_path="mask.png")
+print(r.data["coverage"])  # 0.0523
+```
+
+### Agent Integration (OpenAI Function Calling)
+
+```python
+from demark.tools import TOOLS, dispatch
+
+# Pass TOOLS to your LLM's function-calling API
+result = dispatch("demark_remove_watermark", {
+    "input_path": "/data/wm.jpg",
+    "output_path": "/data/clean.jpg",
+    "method": "auto"
+})
+print(result["success"])  # True
+```
+
+## References
+
+| # | Paper | Year | Venue |
+|---|-------|------|-------|
+| [1] | Suvorov et al., "Resolution-robust Large Mask Inpainting with Fourier Convolutions" | 2021 | WACV 2022 |
+| [2] | Rombach et al., "High-Resolution Image Synthesis with Latent Diffusion Models" | 2022 | CVPR |
+| [3] | Liu et al., "WDNet: Watermark-Decomposition Network for Visible Watermark Removal" | 2020 | WACV 2021 |
+| [4] | Cun & Pun, "Split then Refine: Stacked Attention-guided ResUNets for Blind Watermark Removal" | 2020 | AAAI 2021 |
+| [5] | Robinette & Johnson, "Blind Visible Watermark Removal with Morphological Dilation" | 2025 | arXiv:2502.02676 |
+| [6] | Telea, "An Image Inpainting Technique Based on the Fast Marching Method" | 2004 | J. Graphics Tools |
+| [7] | Bertalmio et al., "Navier-Stokes, Fluid Dynamics, and Image and Video Inpainting" | 2001 | CVPR |
+| [8] | Levin et al., "A Closed-Form Solution to Natural Image Matting" | 2006 | IEEE TPAMI |
+| [9] | Huo et al., "WMFormer++: Nested Transformer for Visible Watermark Removal" | 2023 | arXiv:2308.10195 |
+| [10] | "Vanishing Watermarks: Diffusion-Based Image Editing Undermines Robust Invisible Watermarking" | 2026 | arXiv:2602.20680 |
+
+## Development
+
+```bash
+pip install -e ".[dev]"
+pytest tests/test_unified_api.py -v
+ruff check demark/
+```
+
+## License
+
+GPL-3.0

demark-0.0.1/README.md

@@ -0,0 +1,154 @@
+# DeMark
+
+Automatic image watermark detection and removal toolkit. Multiple methods from classic CV to deep learning, pick what fits your watermark type.
+
+## What it does
+
+Detects watermark regions in images and removes them while preserving underlying content. Ten methods are implemented:
+
+| Method | Type | Best for | Lossless? |
+|--------|------|----------|-----------|
+| `auto` | — | Auto-selects best method | — |
+| `cv_telea` | CV inpaint [6] | Small/thin watermarks | No |
+| `cv_ns` | CV inpaint [7] | Smooth gradients around watermark | No |
+| `fft_notch` | Frequency | Repeating/tiled periodic watermarks | Partial |
+| `color_mask` | CV segmentation | Solid-color text (white on photo) | No |
+| `edge_inpaint` | Edge + inpaint [5] | Text/logos with sharp edges | No |
+| `template` | Template match | Known watermark logo | No |
+| `alpha_invert` | Alpha matting [8] | Known watermark + transparency | **Yes** |
+| `lama` | Deep learning [1] | Large masked regions | No |
+| `sd_inpaint` | Diffusion [2] | Generative content fill | No |
+| `precise` | Alpha inversion + line protection | Semi-transparent text on line art | Partial |
+| `harmonic` | Multi-scale + auto-optimisation | Any scale, self-tuning | Partial |
+
+## What it does NOT do
+
+- No batch GUI — CLI and Python API only. For a GUI, use IOPaint (23k stars) which wraps LaMa.
+- No video watermark removal — for video use ProPainter (sczhou/ProPainter).
+- No invisible/digital watermark removal — those require diffusion-based attacks (see [10]).
+- `alpha_invert` is the only truly lossless method, and it requires the watermark pattern and alpha to be known.
+
+## Requirements
+
+- Python 3.9+
+- OpenCV, NumPy, SciPy, scikit-image, Pillow
+- For deep learning methods: `pip install demark[deep]` (LaMa) or `pip install demark[sd]` (Stable Diffusion)
+
+## Installation
+
+```bash
+# From PyPI
+pip install demark
+
+# Optional deep learning extras (LaMa / Stable Diffusion)
+pip install "demark[deep]"      # LaMa inpainting
+pip install "demark[sd]"        # Stable Diffusion inpainting
+
+# From source
+git clone https://github.com/cycleuser/demark.git
+cd demark
+pip install -e .
+```
+
+## Quick Start
+
+```bash
+# Auto-detect and remove
+demark remove watermarked.jpg clean.jpg
+
+# Use specific method
+demark remove watermarked.jpg clean.jpg --method fft_notch
+
+# Known watermark logo — template matching
+demark remove watermarked.jpg clean.jpg --method template --template logo.png
+
+# Known watermark overlay + alpha — lossless removal
+demark remove watermarked.jpg clean.jpg --method alpha_invert --watermark wm_overlay.png --alpha 0.4
+
+# Scale-adaptive multi-scale + auto-optimisation (works at any scale)
+demark remove watermarked.jpg clean.jpg --method harmonic --bbox 1056 1249 1304 1305
+
+# Just detect the mask
+demark detect watermarked.jpg mask.png
+
+# JSON output
+demark --json remove watermarked.jpg clean.jpg
+```
+
+## Usage
+
+### CLI
+
+```
+demark [-V] [-v] [-o OUTPUT] [--json] [-q] <command> ...
+
+Commands:
+  remove   <input> <output> [--method M] [--mask M.png] [--template T.png]
+                         [--watermark W.png] [--alpha 0.4] [--radius 5]
+  detect   <input> <output> [--method auto|edge|color|otsu]
+  list-methods
+```
+
+### Python API
+
+```python
+from demark import remove_watermark, detect_watermark
+
+# Auto remove
+r = remove_watermark(input_path="wm.jpg", output_path="clean.jpg")
+print(r.success)        # True
+print(r.data["method"]) # "edge_inpaint"
+print(r.data["elapsed"])# 0.123
+
+# Specific method
+r = remove_watermark(
+    input_path="wm.jpg",
+    output_path="clean.jpg",
+    method="fft_notch"
+)
+
+# Detect only
+r = detect_watermark(input_path="wm.jpg", output_path="mask.png")
+print(r.data["coverage"])  # 0.0523
+```
+
+### Agent Integration (OpenAI Function Calling)
+
+```python
+from demark.tools import TOOLS, dispatch
+
+# Pass TOOLS to your LLM's function-calling API
+result = dispatch("demark_remove_watermark", {
+    "input_path": "/data/wm.jpg",
+    "output_path": "/data/clean.jpg",
+    "method": "auto"
+})
+print(result["success"])  # True
+```
+
+## References
+
+| # | Paper | Year | Venue |
+|---|-------|------|-------|
+| [1] | Suvorov et al., "Resolution-robust Large Mask Inpainting with Fourier Convolutions" | 2021 | WACV 2022 |
+| [2] | Rombach et al., "High-Resolution Image Synthesis with Latent Diffusion Models" | 2022 | CVPR |
+| [3] | Liu et al., "WDNet: Watermark-Decomposition Network for Visible Watermark Removal" | 2020 | WACV 2021 |
+| [4] | Cun & Pun, "Split then Refine: Stacked Attention-guided ResUNets for Blind Watermark Removal" | 2020 | AAAI 2021 |
+| [5] | Robinette & Johnson, "Blind Visible Watermark Removal with Morphological Dilation" | 2025 | arXiv:2502.02676 |
+| [6] | Telea, "An Image Inpainting Technique Based on the Fast Marching Method" | 2004 | J. Graphics Tools |
+| [7] | Bertalmio et al., "Navier-Stokes, Fluid Dynamics, and Image and Video Inpainting" | 2001 | CVPR |
+| [8] | Levin et al., "A Closed-Form Solution to Natural Image Matting" | 2006 | IEEE TPAMI |
+| [9] | Huo et al., "WMFormer++: Nested Transformer for Visible Watermark Removal" | 2023 | arXiv:2308.10195 |
+| [10] | "Vanishing Watermarks: Diffusion-Based Image Editing Undermines Robust Invisible Watermarking" | 2026 | arXiv:2602.20680 |
+
+## Development
+
+```bash
+pip install -e ".[dev]"
+pytest tests/test_unified_api.py -v
+ruff check demark/
+```
+
+## License
+
+GPL-3.0

demark-0.0.1/demark/__init__.py

@@ -0,0 +1,45 @@
+"""
+DeMark — Automatic image watermark detection and removal toolkit.
+
+Implements multiple methods from classic CV to deep learning, so the user
+can pick whichever suits the watermark type (semi-transparent logo, tiled
+repeating pattern, solid-color text, known template, etc.).
+
+Public API:
+    remove_watermark  — auto-detect + remove (method auto or specified)
+    detect_watermark  — detect watermark mask only
+    Methods enum      — all available removal strategies
+"""
+from __future__ import annotations
+
+from .__version__ import __version__
+
+__all__ = [
+    "__version__",
+    "ToolResult",
+    "remove_watermark",
+    "detect_watermark",
+    "Methods",
+    "harmonic_loss",
+    "coordinate_descent",
+    "grid_search",
+]
+
+
+def __getattr__(name: str):
+    if name == "ToolResult":
+        from .api import ToolResult
+        return ToolResult
+    if name == "remove_watermark":
+        from .api import remove_watermark
+        return remove_watermark
+    if name == "detect_watermark":
+        from .api import detect_watermark
+        return detect_watermark
+    if name == "Methods":
+        from .core import Methods
+        return Methods
+    if name in ("harmonic_loss", "coordinate_descent", "grid_search"):
+        from . import harmonic
+        return getattr(harmonic, name)
+    raise AttributeError(f"module {__name__!r} has no attribute {name!r}")

demark-0.0.1/demark/__main__.py

@@ -0,0 +1,4 @@
+from .cli import main
+
+if __name__ == "__main__":
+    main()

demark-0.0.1/demark/__version__.py

@@ -0,0 +1 @@
+__version__ = "0.0.1"

demark-0.0.1/demark/api.py

@@ -0,0 +1,227 @@
+"""
+Unified Python API for DeMark.
+
+Every function returns ToolResult so callers never need try/except.
+Path inputs accept both str and pathlib.Path.
+"""
+from __future__ import annotations
+
+import os
+import time
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Any, Optional
+
+from .__version__ import __version__
+
+
+@dataclass
+class ToolResult:
+    success: bool
+    data: Any = None
+    error: Optional[str] = None
+    metadata: dict = field(default_factory=dict)
+
+    def to_dict(self) -> dict:
+        return {
+            "success": self.success,
+            "data": self.data,
+            "error": self.error,
+            "metadata": self.metadata,
+        }
+
+
+def remove_watermark(
+    *,
+    input_path: str,
+    output_path: str,
+    method: str = "auto",
+    mask_path: Optional[str] = None,
+    template_path: Optional[str] = None,
+    watermark_path: Optional[str] = None,
+    watermark_text: Optional[str] = None,
+    region: str = "bottom-right",
+    ratio: float = 0.3,
+    alpha: Optional[float] = None,
+    inpaint_radius: int = 5,
+    bbox: Optional[tuple] = None,
+    char_bboxes: Optional[list] = None,
+    scale_levels: int = 3,
+    harmonic_auto: bool = True,
+) -> ToolResult:
+    """Remove watermark from an image and save the result.
+
+    Args:
+        input_path: Path to input image (jpg/png/bmp/webp).
+        output_path: Path to save the de-watermarked image.
+        method: Removal strategy — one of: auto, cv_telea, cv_ns,
+                fft_notch, color_mask, edge_inpaint, template,
+                alpha_invert, lama, sd_inpaint, fuse, background_aware,
+                precise.  ``precise`` requires ``bbox`` (x1,y1,x2,y2).
+        mask_path: Optional pre-made mask image (white=watermark).
+                   If None, DeMark auto-detects.
+        template_path: Path to watermark template image (for method=template).
+        watermark_path: Path to watermark overlay image (for method=alpha_invert).
+        watermark_text: Watermark text content (e.g. "千问AI生成") for text-based
+                       detection. DeMark renders the text and template-matches it.
+        region: Region hint for detection — "bottom-right", "full", "bottom", etc.
+        ratio: Region size fraction (0.3 = bottom 30%).
+        alpha: Alpha transparency value 0-1 (for method=alpha_invert).
+               If None, auto-estimated.
+        inpaint_radius: Inpaint radius in pixels (for CV methods).
+
+    Returns:
+        ToolResult with data={"method": str, "output": str, "elapsed": float}
+        and metadata={"version": str}.
+
+    >>> from demark import remove_watermark
+    >>> r = remove_watermark(input_path="watermarked.jpg", output_path="clean.jpg")
+    >>> r.success
+    True
+    >>> r.data["method"]
+    'edge_inpaint'
+    """
+    try:
+        import cv2
+        import numpy as np
+        from .core import Methods, remove, detect_watermark_smart, detect_auto
+
+        inp = str(Path(input_path).resolve())
+        outp = str(Path(output_path).resolve())
+
+        if not os.path.exists(inp):
+            return ToolResult(success=False, error=f"Input not found: {inp}",
+                              metadata={"version": __version__})
+
+        img = cv2.imread(inp)
+        if img is None:
+            return ToolResult(success=False, error=f"Cannot read image: {inp}",
+                              metadata={"version": __version__})
+
+        mask = None
+        if mask_path and os.path.exists(mask_path):
+            mask = cv2.imread(mask_path, cv2.IMREAD_GRAYSCALE)
+        elif method == "auto" or method in ("cv_telea", "cv_ns", "edge_inpaint",
+                                            "color_mask", "fft_notch"):
+            # smart detection: text-based if watermark_text given, else region
+            mask = detect_watermark_smart(img, watermark_text, region, ratio)
+
+        # build kwargs for the specific method
+        kwargs = {}
+        if method == "template" and template_path:
+            kwargs["template_path"] = template_path
+        if method == "alpha_invert":
+            if watermark_path:
+                kwargs["watermark_img"] = watermark_path
+            if alpha is not None:
+                kwargs["alpha"] = alpha
+        if method in ("cv_telea", "cv_ns", "color_mask", "edge_inpaint", "template"):
+            kwargs["inpaint_radius"] = inpaint_radius
+        if method == "precise":
+            if bbox is None:
+                return ToolResult(success=False,
+                                  error="precise method requires bbox=(x1,y1,x2,y2) pixel coords",
+                                  metadata={"version": __version__})
+            kwargs["bbox"] = bbox
+            if char_bboxes is not None:
+                kwargs["char_bboxes"] = char_bboxes
+        if method == "lama_precise":
+            if bbox is None:
+                return ToolResult(success=False,
+                                  error="lama_precise method requires bbox=(x1,y1,x2,y2) pixel coords",
+                                  metadata={"version": __version__})
+            kwargs["bbox"] = bbox
+        if method == "harmonic":
+            if bbox is None:
+                return ToolResult(success=False,
+                                  error="harmonic method requires bbox=(x1,y1,x2,y2) pixel coords",
+                                  metadata={"version": __version__})
+            kwargs["bbox"] = bbox
+            kwargs["scale_levels"] = scale_levels
+            kwargs["auto"] = harmonic_auto
+
+        try:
+            method_enum = Methods(method)
+        except ValueError:
+            return ToolResult(success=False,
+                              error=f"Unknown method: {method}. Valid: {[m.value for m in Methods]}",
+                              metadata={"version": __version__})
+
+        result = remove(img, method_enum, mask=mask, **kwargs)
+
+        os.makedirs(os.path.dirname(outp) or ".", exist_ok=True)
+        cv2.imwrite(outp, result.image)
+
+        # also save the mask alongside output for inspection
+        mask_out = outp.rsplit(".", 1)[0] + "_mask.png"
+        cv2.imwrite(mask_out, result.mask)
+
+        return ToolResult(
+            success=True,
+            data={
+                "method": result.method,
+                "output": outp,
+                "mask": mask_out,
+                "elapsed": round(result.elapsed, 3),
+            },
+            metadata={"version": __version__, "image_size": img.shape[:2]},
+        )
+    except Exception as e:
+        return ToolResult(success=False, error=str(e),
+                          metadata={"version": __version__})
+
+
+def detect_watermark(
+    *,
+    input_path: str,
+    output_path: str,
+    method: str = "auto",
+) -> ToolResult:
+    """Detect watermark mask and save it as a binary image.
+
+    Args:
+        input_path: Path to input image.
+        output_path: Path to save the mask (white=watermark, black=clean).
+        method: Detection method — auto, edge, color, or otsu.
+
+    Returns:
+        ToolResult with data={"output": str, "coverage": float}.
+
+    >>> from demark import detect_watermark
+    >>> r = detect_watermark(input_path="img.jpg", output_path="mask.png")
+    >>> r.success
+    True
+    >>> r.data["coverage"] < 1.0
+    True
+    """
+    try:
+        import cv2
+        import numpy as np
+        from .core import detect_only
+
+        inp = str(Path(input_path).resolve())
+        outp = str(Path(output_path).resolve())
+
+        if not os.path.exists(inp):
+            return ToolResult(success=False, error=f"Input not found: {inp}",
+                              metadata={"version": __version__})
+
+        img = cv2.imread(inp)
+        if img is None:
+            return ToolResult(success=False, error=f"Cannot read image: {inp}",
+                              metadata={"version": __version__})
+
+        mask = detect_only(img, method)
+        os.makedirs(os.path.dirname(outp) or ".", exist_ok=True)
+        cv2.imwrite(outp, mask)
+
+        coverage = float(np.count_nonzero(mask)) / mask.size
+
+        return ToolResult(
+            success=True,
+            data={"output": outp, "coverage": round(coverage, 4)},
+            metadata={"version": __version__, "image_size": img.shape[:2]},
+        )
+    except Exception as e:
+        return ToolResult(success=False, error=str(e),
+                          metadata={"version": __version__})