demark 0.0.1__py3-none-any.whl

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/__main__.py

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

demark/__version__.py

@@ -0,0 +1 @@
+__version__ = "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__})

demark/cli.py

@@ -0,0 +1,188 @@
+"""
+CLI for DeMark with unified flags and remove/detect subcommands.
+"""
+from __future__ import annotations
+
+import argparse
+import json
+import logging
+import sys
+
+from .__version__ import __version__
+
+log = logging.getLogger("demark")
+
+
+def build_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(
+        prog="demark",
+        description="Automatic image watermark detection and removal toolkit.",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog="""
+Examples:
+  demark remove watermarked.jpg clean.jpg
+  demark remove watermarked.jpg clean.jpg --method fft_notch
+  demark remove watermarked.jpg clean.jpg --method template --template logo.png
+  demark remove watermarked.jpg clean.jpg --method alpha_invert --watermark wm.png --alpha 0.4
+  demark detect watermarked.jpg mask.png
+  demark --json remove watermarked.jpg clean.jpg
+""",
+    )
+    parser.add_argument("-V", "--version", action="version", version=f"demark {__version__}")
+    parser.add_argument("-v", "--verbose", action="store_true", help="Verbose output")
+    parser.add_argument("-o", "--output", type=str, default=None, help="Output path (for JSON results)")
+    parser.add_argument("--json", action="store_true", dest="json_output", help="Output results as JSON")
+    parser.add_argument("-q", "--quiet", action="store_true", help="Suppress non-essential output")
+
+    subparsers = parser.add_subparsers(dest="command", required=True)
+
+    rm_p = subparsers.add_parser("remove", help="Remove watermark from image")
+    rm_p.add_argument("input", help="Input image path")
+    rm_p.add_argument("output", help="Output image path")
+    rm_p.add_argument("--method", type=str, default="auto",
+                      choices=[m.value for m in __import__("demark.core", fromlist=["Methods"]).Methods],
+                      help="Removal method (default: auto)")
+    rm_p.add_argument("--mask", type=str, default=None, help="Pre-made mask image (white=watermark)")
+    rm_p.add_argument("--template", type=str, default=None, help="Watermark template image (for method=template)")
+    rm_p.add_argument("--watermark", type=str, default=None, help="Watermark overlay image (for method=alpha_invert)")
+    rm_p.add_argument("--region", type=str, default="bottom-right",
+                      choices=["bottom-right", "bottom-left", "top-right", "top-left", "bottom", "top", "full"],
+                      help="Region to detect watermark in (default: bottom-right)")
+    rm_p.add_argument("--ratio", type=float, default=0.3, help="Region size fraction (default 0.3)")
+    rm_p.add_argument("--bbox", type=int, nargs=4, default=None,
+                      metavar=("X1","Y1","X2","Y2"),
+                      help="Precise pixel bbox for --method precise (e.g. 1056 1249 1304 1305)")
+    rm_p.add_argument("--watermark-text", type=str, default="千问AI生成",
+                      help="Watermark text content (default: 千问AI生成)")
+    rm_p.add_argument("--char-widths", type=int, nargs='+', default=None,
+                      metavar="W",
+                      help="Width in pixels of each character, e.g. --char-widths 50 48 35 12 48 48")
+    rm_p.add_argument("--alpha", type=float, default=None, help="Alpha transparency 0-1 (for method=alpha_invert)")
+    rm_p.add_argument("--radius", type=int, default=5, help="Inpaint radius in pixels (default 5)")
+    rm_p.add_argument("--scale-levels", type=int, default=3,
+                      help="Pyramid levels for method=harmonic (default 3; 1 disables multi-scale)")
+    rm_p.add_argument("--no-harmonic-auto", action="store_true",
+                      help="Disable auto-optimisation for method=harmonic (uses v57 defaults)")
+
+    det_p = subparsers.add_parser("detect", help="Detect watermark mask only")
+    det_p.add_argument("input", help="Input image path")
+    det_p.add_argument("output", help="Output mask path")
+    det_p.add_argument("--method", type=str, default="auto",
+                       choices=["auto", "edge", "color", "otsu"],
+                       help="Detection method (default: auto)")
+
+    subparsers.add_parser("list-methods", help="List all available removal methods")
+
+    return parser
+
+
+def setup_logging(verbose: bool, quiet: bool):
+    level = logging.WARNING if quiet else (logging.DEBUG if verbose else logging.INFO)
+    logging.basicConfig(level=level, format="%(levelname)s: %(message)s")
+
+
+def main():
+    parser = build_parser()
+    args = parser.parse_args()
+    setup_logging(args.verbose, args.quiet)
+
+    from . import api
+    from .core import Methods
+
+    try:
+        if args.command == "remove":
+            # Auto-build char_bboxes from --watermark-text + --char-widths (if precise)
+            char_bboxes = None
+            if args.method in ("precise", "lama_precise") and args.bbox and args.watermark_text:
+                bx1, by1, bx2, by2 = args.bbox
+                if args.char_widths and len(args.char_widths) == len(args.watermark_text):
+                    xs = bx1
+                    char_bboxes = []
+                    for w in args.char_widths:
+                        char_bboxes.append((xs, by1, xs + w, by2))
+                        xs += w
+                else:
+                    defaults = {"千问AI生成": [50, 48, 35, 12, 48, 48]}
+                    if args.watermark_text in defaults:
+                        xs = bx1
+                        char_bboxes = []
+                        for w in defaults[args.watermark_text]:
+                            char_bboxes.append((xs, by1, xs + w, by2))
+                            xs += w
+            result = api.remove_watermark(
+                input_path=args.input,
+                output_path=args.output,
+                method=args.method,
+                mask_path=args.mask,
+                template_path=args.template,
+                watermark_path=args.watermark,
+                watermark_text=args.watermark_text,
+                region=args.region,
+                ratio=args.ratio,
+                alpha=args.alpha,
+                inpaint_radius=args.radius,
+                bbox=tuple(args.bbox) if args.bbox else None,
+                char_bboxes=char_bboxes,
+                scale_levels=args.scale_levels,
+                harmonic_auto=not args.no_harmonic_auto,
+            )
+        elif args.command == "detect":
+            result = api.detect_watermark(
+                input_path=args.input,
+                output_path=args.output,
+                method=args.method,
+            )
+        elif args.command == "list-methods":
+            methods_info = []
+            for m in Methods:
+                desc = {
+                    "auto": "Auto-detect + best method selection",
+                    "cv_telea": "OpenCV Telea fast-marching inpaint [6]",
+                    "cv_ns": "OpenCV Navier-Stokes inpaint [7]",
+                    "fft_notch": "FFT notch filtering for repeating watermarks",
+                    "color_mask": "HSV color segmentation + inpaint",
+                    "edge_inpaint": "Canny edge + morphological dilation + inpaint [5]",
+                    "template": "Template matching for known watermark + inpaint",
+                    "alpha_invert": "Alpha matting inversion (lossless if W+alpha known) [8]",
+                    "lama": "LaMa deep learning inpainting [1]",
+                    "sd_inpaint": "Stable Diffusion inpainting (generative fill)",
+                    "fuse": "Multi-method fusion + iterative optimization (best quality)",
+                    "precise": "Column-interp background + alpha-inversion (needs --bbox)",
+                    "harmonic": "Scale-adaptive multi-scale + reference-free auto-optimisation (needs --bbox)",
+                }
+                methods_info.append(f"  {m.value:15s} — {desc.get(m.value, '')}")
+            print("\n".join(methods_info))
+            sys.exit(0)
+        else:
+            parser.print_help()
+            sys.exit(2)
+
+        if args.json_output:
+            print(json.dumps(result.to_dict(), ensure_ascii=False, indent=2))
+        elif result.success:
+            if args.command == "remove":
+                d = result.data
+                print(f"Removed watermark ({d['method']}) → {d['output']}")
+                print(f"  Mask: {d['mask']}")
+                print(f"  Time: {d['elapsed']}s")
+            elif args.command == "detect":
+                d = result.data
+                print(f"Detected mask → {d['output']}")
+                print(f"  Coverage: {d['coverage']*100:.1f}%")
+        else:
+            print(f"Error: {result.error}", file=sys.stderr)
+            sys.exit(1)
+
+        if args.output and result.success and args.json_output:
+            with open(args.output, "w") as f:
+                json.dump(result.to_dict(), f, ensure_ascii=False, indent=2)
+
+        sys.exit(0)
+    except KeyboardInterrupt:
+        sys.exit(1)
+    except Exception as e:
+        if args.json_output:
+            print(json.dumps({"success": False, "error": str(e)}, ensure_ascii=False))
+        else:
+            print(f"Error: {e}", file=sys.stderr)
+        sys.exit(1)