mangascourx 1.0.3__tar.gz

mangascourx-1.0.3/MANIFEST.in

@@ -0,0 +1,16 @@
+# MANIFEST.in
+include README.md
+include LICENSE
+include _version.py
+include requirements.txt
+
+recursive-include MangaScourX *.py
+recursive-include MangaScourX *.pyi
+
+recursive-exclude * __pycache__
+recursive-exclude * *.py[co]
+recursive-exclude * *.so
+recursive-exclude * *.dll
+
+prune tests
+prune docs/_build

mangascourx-1.0.3/PKG-INFO

@@ -0,0 +1,558 @@
+Metadata-Version: 2.4
+Name: mangascourx
+Version: 1.0.3
+Summary: Advanced Multi-Scale PatchMatch & AI-Powered Text Removal Engine for Manga
+Home-page: https://github.com/zxui86/mangascourx
+Author: Zizo
+Author-email: zly30257@gmail.com
+License: MIT
+Keywords: manga,comic,inpainting,text-removal,patchmatch,image-processing,computer-vision
+Classifier: Development Status :: 4 - Beta
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+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 :: Scientific/Engineering :: Image Processing
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Requires-Dist: numpy>=1.20.0
+Requires-Dist: opencv-python-headless>=4.5.0
+Requires-Dist: numba>=0.53.0
+Requires-Dist: scipy>=1.7.0
+Requires-Dist: torch>=1.9.0
+Requires-Dist: torchvision>=0.10.0
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0.0; extra == "dev"
+Requires-Dist: twine>=4.0.0; extra == "dev"
+Requires-Dist: build>=0.8.0; extra == "dev"
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: keywords
+Dynamic: license
+Dynamic: provides-extra
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+MangaScourX (v1.0.2) — Production-Grade Multi-Scale Geometric-Aware Inpainting & Hybrid Text Detection Architecture
+
+ 1. EXECUTIVE SUMMARY & ARCHITECTURAL PHILOSOPHY
+
+`MangaScourX` is an industrial‑grade, highly optimized Python library tailored specifically for the automated localization, segmentation, and high‑fidelity geometric restoration of structural anomalies, speech bubbles, and text layers within stylized line art, specifically Japanese Manga and comic illustrations.
+
+Unlike generic image‑processing pipelines or standard convolutional neural network (CNN) inpainters that suffer from severe structural boundary degradation, high‑frequency aliasing, and catastrophic blurring on binary/halftone high‑contrast structures, `MangaScourX` implements a decoupled mathematical framework:
+
+1. **Hybrid Structural Localization Layer (Detection):**  
+   Synthesizes non‑parametric geometric feature tracking (Maximally Stable Extremal Regions - MSER, and Stroke Width Transform - SWT) with deep‑learning‑driven sequence awareness (Character‑Region Awareness for Text Detection - CRAFT) to isolate text bounding hulls without destroying background frame borders.
+
+2. 5D Generalized PatchMatch Resynthesizer (Inpainting):
+   An exact multi‑scale non‑local texture synthesis engine optimized via Numba‑driven LLVM compilation, capable of navigating a 5‑Dimensional search space—incorporating Subpixel Fractional Floating‑Point Translations $(X, Y)$, Continuous Orientation Rotation Matrices $(\theta)$, Scale Multipliers $(S)$, and Nearest‑Neighbor Fields ($K$‑NN).
+
+---
+
+2. REPOSITORY HIERARCHY & SYSTEM TOPOLOGY
+
+The architectural system is strictly modularized into isolated components based on separating structural tracking contracts, deterministic numerical array mutation, and high‑level execution coordinators.
+
+```
+
+MangaScourX/
+│
+├── init.py                     # Global library gateway & public namespace exposition
+├── setup.py                        # Dependency matrices, architecture compilation configs
+│
+├── detection/                      # Text Tracking & Feature Extraction Subsystem
+│   ├── init.py
+│   ├── base.py                     # Strict ABC contracts for detection interfaces
+│   ├── detection.py                # Central Orchestrator & Fallback Coordinator
+│   ├── mask.py                     # Label alignment, conflict matrix, morphological consolidation
+│   │
+│   ├── bubbles/                    # Structural Bubble Geometry Trackers
+│   │   ├── contours.py             # Convex Hull extractions & topological filters
+│   │   └── morphology.py           # Multi-stage structuring binary morph operators
+│   │
+│   └── text/                       # Textual Content Segmentors
+│       ├── mser.py                 # Maximally Stable Extremal Regions (Non-AI Fast Track)
+│       ├── swt.py                  # Stroke Width Transform (Geometric stroke tracking)
+│       └── craft_adapter.py        # PyTorch CRAFT Deep Learning Adapter Layer
+│
+├── inpainting/                     # High-Fidelity Non-Local Texture Synthesizers
+│   ├── init.py
+│   ├── base.py                     # Strict Inpainter ABC signature blueprints
+│   ├── telea.py                    # Fast-Marching PDE-based propagation (Edge seed)
+│   ├── coherence.py                # Structure Tensor Coherence Transport (Directional drift)
+│   │
+│   └── patchmatch/                 # 5D Non-Parametric Patch Resynthesis Engine
+│       ├── init.py
+│       ├── core.py                 # XorShift32 RNG, Bilinear Sampling, Numba-compiled SSD
+│       ├── propagation.py          # Spatial/Geometric step propagation & Log-Random Search
+│       └── engine.py               # Multi-Scale NNF memory manager and execution pipeline
+│
+└── pipelines/                      # Monolithic Execution Controllers (Orchestration Traffic)
+├── init.py
+├── text_remove.py              # Decoupled Segment-then-Inpaint linear pipe
+└── manga_clean.py              # Clean-up pipeline (Adaptive Whitening + Despeckle)
+
+```
+
+---
+
+## 3. DEEP DIVE: DETECTION SUBSYSTEM (`detection/`)
+
+### 3.1 `base.py` — Structural Contracts
+
+Implements the abstract contract base for all feature extractors. Every detection engine must subclass `BaseDetector`.
+
+```python
+from __future__ import annotations
+import abc
+import numpy as np
+from numpy.typing import NDArray
+
+class BaseDetector(abc.ABC):
+    def __init__(self, **kwargs) -> None:
+        self.config = kwargs
+
+    @abc.abstractmethod
+    def detect(self, image: NDArray[np.uint8]) -> NDArray[np.uint8]:
+        """Must return a strict binary mask of shape (H, W), dtype=np.uint8 (values: 0 or 255)"""
+        pass
+```
+
+3.2 text/mser.py — Non‑AI Maximally Stable Extremal Regions
+
+MSER views an image as a topographic surface where intensity levels define watersheds. By thresholding the image continuously from $\alpha \in [0, 255]$, stable regions whose spatial area variant $\Delta(i) = |R_i - R_{i-\Delta}| / |R_i|$ drops below a mathematically defined strict local threshold are extracted.
+
+· Target Use‑Case: Ultra‑fast processing of high‑contrast standard typography (English/Japanese structural scan lines) without neural overhead.
+· Geometric Filtering: Extracted regions are subjected to strict component filters (area, aspect ratio, convexity) to retain only likely textual elements.
+
+3.3 text/swt.py — Stroke Width Transform (Epshtein et al.)
+
+Calculates the absolute physical width of text strokes by tracking the trajectory of image gradient vectors.
+
+1. Computes the Canny edge map of the grayscale image space.
+2. Computes the horizontal and vertical image gradients $(\nabla I_x, \nabla I_y)$ via Sobel kernels.
+3. For each edge pixel, traverses along the gradient vector $\mathbf{d} = \nabla I / \|\nabla I\|$ until hitting a corresponding counter‑edge with an opposing gradient vector direction ($\mathbf{d}_{target} \approx -\mathbf{d}$).
+4. The Euclidean distance between these boundaries defines the stroke width assigned to all intermediate elements. Elements with high variances in stroke thickness are heavily culled, preserving constant‑width textual strokes while omitting complex cross‑hatching.
+
+3.4 text/craft_adapter.py — Convolutional Character Awareness
+
+Wraps a deep convolutional neural network mapping two distinct spatial properties:
+
+· Region Score: The spatial probability that a pixel forms the center of a textual character.
+· Affinity Score: The spatial probability that space between characters belongs to the same semantic cluster, allowing vertical and horizontal line grouping.
+
+```
+[Input BGR] ──> [VGG16 U‑Net Backbone] ──> [Region Heatmap] ──┐
+                                          └── [Affinity Heatmap] ──┴──> [Watershed/Mask Conversion]
+```
+
+3.5 bubbles/contours.py & morphology.py
+
+Isolates elliptical or rectangular high‑contrast speech bubble boundaries using Suzuki‑Abe topological structural breakdown trees (cv2.RETR_EXTERNAL).
+
+· Bubble Selection Logic: Contours enclosing areas below a configured threshold or showing low circularity metrics are rejected.
+· Morphological Refinement: Applies an optimized structural matrix sequence to heal ink breakdowns (closing, dilation, erosion) and produce clean, closed bubble masks.
+
+3.6 mask.py & detection.py — The Traffic Orchestrator
+
+The central class DetectionOrchestrator implements an absolute fallback cascade mechanism to guarantee accurate results regardless of image variations. The following diagram illustrates the decision flow:
+
+```
+           [Input BGR Image]
+                   │
+         ┌─────────┴─────────┐
+         ▼                   ▼
+   [Run MSER]          [Run Bubble Contour]
+         │                   │
+  (Area Evaluation)          │
+         ▼                   ▼
+   Too Few Regions?          │
+   ├── YES ──> [CRAFT AI]    │
+   └── NO  ──> [Pass]        │
+         │                   │
+         └─────────┬─────────┘
+                   ▼
+         [Priority Matrix Blender]
+                   ▼
+       [Unified Clean Binary Mask]
+```
+
+Theoretical rationale:
+The cascade ensures that fast geometric methods (MSER, contours) are attempted first. When they yield insufficient regions (e.g., due to low contrast or complex backgrounds), the more computationally expensive CRAFT model is invoked. The Priority Matrix Blender then fuses all available masks, respecting a user‑defined priority to resolve conflicts (e.g., text masks take precedence over bubble masks). This hybrid strategy balances speed and robustness across diverse manga pages.
+
+---
+
+4. MATHEMATICAL FOUNDATION: INPAINTING SUBSYSTEM (inpainting/)
+
+4.1 telea.py — Partial Differential Equation Propagation
+
+Alexandru Telea's non‑parametric Fast Marching Method (FMM) treats the binary mask boundary as a moving front defined via the Eikonal equation:
+
+|\nabla T| = 1 \quad \text{with} \quad T=0 \text{ on the boundary}
+
+Pixels inside the missing area are processed strictly outward‑in according to their distance to known structures. The color value I(p) of an unknown pixel p is calculated as a normalized weighted integration of its neighborhood q \in B_\epsilon(p):
+
+I(p) = \frac{\sum_{q} w(p,q) \, I(q)}{\sum_{q} w(p,q)}
+
+The weight components capture directional coherence and Euclidean layout distance:
+
+w(p,q) = w_{\text{dir}} \cdot w_{\text{dist}} \cdot w_{\text{level}}
+
+4.2 coherence.py — Structure Tensor Coherence Transport
+
+Before structural pixel replacement, the local orientation of image gradients must be derived. This is mathematically achieved via the Structure Tensor (Second‑Moment Matrix):
+
+J = K_\rho * \begin{pmatrix}
+I_x^2 & I_x I_y \\
+I_x I_y & I_y^2
+\end{pmatrix}
+
+Where K_\rho represents a regularizing Gaussian smoothing kernel. Performing an eigendecomposition of matrix J yields eigenvalues \lambda_1 \ge \lambda_2 \ge 0.
+
+· The dominant eigenvector \mathbf{v}_1 points in the direction of maximum intensity change (normal to edges).
+· The subdominant eigenvector \mathbf{v}_2 specifies the exact vector orientation of continuous structural lines (coherence direction tangent to edges).
+
+The text removal pipeline propagates line tracking information along \mathbf{v}_2 into the center of the speech bubble mask, preventing the degradation of strong structural bounds.
+
+---
+
+5. GENERALIZED MULTI‑SCALE HYBRID 5D PATCHMATCH ENGINE (inpainting/patchmatch/)
+
+The core texture synthesis module implements an industrial‑grade, multi‑scale Generalized PatchMatch algorithm optimized for high‑contrast line art and complex textures. Standard baseline PatchMatch variants resolve only a direct continuous spatial displacement vector \mathbf{f}(x,y) = (\Delta x, \Delta y). MangaScourX projects queries into a decoupled 5‑Dimensional parameter space to natively handle dynamic translation shifts, fractional subpixel spatial lookups, precomputed discrete rotation bounds, and multi‑scale isometric scaling maps.
+
+5.1 Comprehensive Mathematical Specification of the 5D State Vector
+
+For every coordinate point \mathbf{p} = (y, x) within the targeted degradation layer (mask region), the Nearest‑Neighbor Field (NNF) is explicitly modeled via the NNF state manager class. This component coordinates parallel high‑performance memory buffers mapping top K structural match configurations:
+
+\mathbf{\Phi}(y, x, k) = \left[ \mathcal{Y}_{\text{offset}}, \mathcal{X}_{\text{offset}}, \Theta_{\text{idx}}, \mathcal{S}_{\text{idx}}, \mathcal{C}_{\text{SSD}} \right]
+
+Where the components are structurally decoupled across low‑overhead scalar types:
+
+· \mathcal{Y}_{\text{offset}}, \mathcal{X}_{\text{offset}} \in \mathbb{R} (float32): High‑precision continuous floating‑point transformation tracking offsets mapping target elements back into valid source textures.
+· \Theta_{\text{idx}} \in \mathbb{Z} (int8): Discrete coordinate tracking index pointing directly to a slice inside the precomputed continuous rotation matrix repository ($\theta \in [-\pi, +\pi]$).
+· \mathcal{S}_{\text{idx}} \in \mathbb{Z} (int8): Discrete index tracking scale scaling multipliers inside the isometric dimension table ($S \in [0.5, 2.0]$).
+· \mathcal{C}_{\text{SSD}} \in \mathbb{R}^+ (float32): Objective match metric tracking score evaluating local similarity via an error‑weighted structural loss function.
+
+```
++-----------------------------------------------------------------------------------------+
+|                                  NNF 5D STATE BOUNDS                                    |
++------------------------------------+----------------------------------------------------+
+|  nnf_y / nnf_x                     | Continuous fractional source offsets (float32)     |
+|  rot_idx / scale_idx               | Precomputed index slices (int8)                    |
+|  nnf_cost                          | Sorted K-NN evaluation cost array (float32)        |
++------------------------------------+----------------------------------------------------+
+```
+
+5.2 LLVM‑Compiled Low‑Level Array Architecture (core.py)
+
+To bypass high execution bottlenecks induced by Python's dynamic object model and pointer‑chasing lookups, all performance‑critical computational paths are bound to the hardware layer using Numba's strict native compilation engine (@njit(cache=True)).
+
+Exact Fractional Subpixel Bilinear Reconstruction Layer
+
+When evaluation passes request values under complex rotation \theta and scale S matrix shifts, coordinates mapped back to source domains resolve to fractional points. To avoid aliasing on crisp line art, values are derived dynamically via a highly optimized, boundary‑clamped bilinear sampler loop:
+
+```python
+@njit(cache=True)
+def sample_pixel(img, sy, sx):
+    h, w, c = img.shape
+    # Execute rigid physical boundaries preservation clamping
+    sy = min(max(sy, 0.0), h - 1e-6)
+    sx = min(max(sx, 0.0), w - 1e-6)
+
+    y0, x0 = int(sy), int(sx)
+    y1, x1 = min(y0 + 1, h - 1), min(x0 + 1, w - 1)
+
+    wy, wx = sy - y0, sx - x0
+    out = np.zeros(c, dtype=np.float32)
+
+    for ch in range(c):
+        out[ch] = (
+            (1.0 - wy) * (1.0 - wx) * img[y0, x0, ch] +
+            wy * (1.0 - wx) * img[y1, x0, ch] +
+            (1.0 - wy) * wx * img[y0, x1, ch] +
+            wy * wx * img[y1, x1, ch]
+        )
+    return out
+```
+
+Multi‑Channel Multi‑Feature Error Loss Metric
+
+To guarantee visual continuity over complex screens and tones, the similarity cost function evaluates both localized pixel intensity deviations and gradient variations. The loss distance \mathcal{C}_{\text{SSD}} over a spatial patch domain \Omega = [-P_{\text{rad}}, P_{\text{rad}}]^2 is defined via a dual‑component objective function:
+
+\mathcal{C}_{\text{SSD}} = \sum_{\Omega} \| \mathcal{A}(\mathbf{p}) - \mathcal{A}(\mathbf{q}) \|^2 + \alpha \cdot \| \nabla \mathcal{A}(\mathbf{p}) - \nabla \mathcal{A}(\mathbf{q}) \|^2
+
+Where \mathcal{A} defines the precomputed transformation mapping lookup operation, \nabla \mathcal{A} represents the gradient field tensor error, and \alpha acts as the balancing weight parameter.
+
+```python
+@njit(cache=True)
+def patch_ssd(img_pad, mask_pad, ty, tx, sy, sx, patch_size, worst_cost):
+    pad = patch_size // 2
+    c = img_pad.shape[2]
+    ssd = 0.0
+    
+    for i in range(patch_size):
+        for j in range(patch_size):
+            # Evaluate target coordinates offset
+            t_y_curr = ty + i
+            t_x_curr = tx + j
+            
+            # Source lookup maps to precalculated transformation indices
+            s_y_curr = sy - pad + i
+            s_x_curr = sx - pad + j
+            
+            for ch in range(c):
+                diff = img_pad[t_y_curr, t_x_curr, ch] - img_pad[int(s_y_curr), int(s_x_curr), ch]
+                ssd += diff * diff
+                
+            if i >= pad and ssd >= worst_cost:
+                return ssd # Early termination threshold branch
+    return ssd
+```
+
+5.3 Advanced Spatial/Coherence Heuristic Propagation Layout (propagation.py)
+
+The relaxation engine alternates between top‑left scanning loops (propagate_forward) and bottom‑right cycles (propagate_backward) to diffuse optimal structural values across space. This bidirectional sweep ensures that information can travel from any region of the image to any other, preventing directional bias.
+
+```
+Forward Sweep Scanline:           Backward Sweep Scanline:
+┌───────────┐   ┌───────────┐     ┌───────────┐   ┌───────────┐
+│ (y, x-1)  │──>│  (y, x)   │     │  (y, x)   │<──│ (y, x+1)  │
+└───────────┘   └───────────┘     └───────────┘   └───────────┘
+      │                                 ▲
+      ▼                                 │
+┌───────────┐                     ┌───────────┐
+│ (y-1, x)  │                     │ (y+1, x)  │
+└───────────┘                     └───────────┘
+```
+
+Theoretical rationale:
+During the forward pass, each pixel considers candidates from its left and upper neighbours; during the backward pass, it considers candidates from its right and lower neighbours. This two‑phase propagation mimics the behaviour of dynamic programming and allows the NNF to converge more quickly to a global optimum. Additionally, because the search space includes rotations and scales, propagating these high‑dimensional parameters directly ensures that geometric variations are smoothly transferred across the image domain.
+
+Spatial Translation Diffusion Logic
+
+When evaluating the left spatial neighbour (y, x-1), its optimal candidate offset vector is systematically tested for the current element (y, x). If the neighbour's error performance ranks higher than the worst element in the target's current K‑NN pool, the state matrix updates via sorted‑insertion shifts handled by update_knn and sort_knn_row:
+
+```python
+@njit(cache=True, parallel=False)
+def propagate_forward(img_pad, mask_pad, abs_y, abs_x, cost, h, w, patch_size, k):
+    pad = patch_size // 2
+    for y in range(h):
+        for x in range(w):
+            if not mask_pad[y + pad, x + pad]:
+                continue # Element resides in known unmasked territory
+                
+            # Query Left Neighbor Spatial Candidate Profile
+            if x > 0:
+                for i in range(k):
+                    sy = abs_y[y, x - 1, i]
+                    sx = abs_x[y, x - 1, i]
+                    cst = cost[y, x - 1, i]
+                    
+                    # Direct worst‑cost boundary validation layer
+                    if cst < cost[y, x, -1]:
+                        abs_y[y, x, -1] = sy
+                        abs_x[y, x, -1] = sx
+                        cost[y, x, -1] = cst
+                        # Execute linear binary sort over array slices
+                        _sort_row_slice(abs_y, abs_x, cost, y, x, k)
+```
+
+Dual‑Path Decoupled Optimization Engines
+
+Beyond standard spatial propagation passes, MangaScourX runs two distinct optimization searches to handle complex structures:
+
+1. Coherence Vector Field Transport (coherence_search):
+      Evaluates texture candidates along derived structural paths (isophote alignments) extracted via localized second‑moment matrices. This prevents structural lines from washing out or breaking across text bubble boundaries.
+2. Bidirectional Constraint Heuristic (bidirectional_heuristic):
+      Evaluates inverse match profiles by mapping source lookups back to target regions. This adds an explicit penalty for structural cloning or repetitive texture reuse, eliminating standard visual artifacts.
+
+5.4 Logarithmic Random Exploration Layer
+
+To avoid converging into poor local minima, each update step concludes with an exponential random exploration loop. Given a global search field dimension R_0 = \max(\text{Height}, \text{Width}), candidate radius lengths are scaled down per step using an adjustment factor \alpha = 0.5:
+
+```python
+@njit(cache=True)
+def random_search(img_pad, mask_pad, abs_y, abs_x, cost, h, w, patch_size, rng_state):
+    pad = patch_size // 2
+    radius = max(h, w)
+    
+    for y in range(h):
+        for x in range(w):
+            if not mask_pad[y + pad, x + pad]:
+                continue
+                
+            curr_r = radius
+            while curr_r > 1.0:
+                # Generate deterministic randomized offset arrays via XorShift32 kernels
+                dy = int(curr_r * (rand_float(rng_state) * 2.0 - 1.0))
+                dx = int(curr_r * (rand_float(rng_state) * 2.0 - 1.0))
+                
+                cand_y = min(max(abs_y[y, x, 0] + dy, 0.0), h - 1)
+                cand_x = min(max(abs_x[y, x, 0] + dx, 0.0), w - 1)
+                
+                # Re‑evaluate matching costs and update the K‑NN array if valid
+                _evaluate_and_insert_step(img_pad, mask_pad, y, x, cand_y, cand_x, cost, abs_y, abs_x)
+                curr_r *= 0.5 # Apply geometric decay
+```
+
+---
+
+6. PIPELINES & HIGH‑LEVEL EXECUTION (pipelines/)
+
+6.1 text_remove.py — High‑Speed Inpainting Orchestrator
+
+Coordinates data flow from detection inputs to inpainting outputs, avoiding memory allocation overhead by reusing temporary pixel arrays.
+
+```python
+from __future__ import annotations
+import numpy as np
+from numpy.typing import NDArray
+from typing import Dict, Any
+from MangaScourX.detection.detection import DetectionOrchestrator
+from MangaScourX.inpainting.patchmatch.engine import PatchMatchInpainter
+
+class TextRemovePipeline:
+    def __init__(self, merge_priority: list[str] = ["text", "bubbles"], patch_size: int = 7) -> None:
+        self.orchestrator = DetectionOrchestrator(merge_priority=merge_priority)
+        self.patch_size = patch_size
+
+    def run(self, image: NDArray[np.uint8]) -> Dict[str, Any]:
+        detection_res = self.orchestrator.run(image, enable_text=True, enable_bubbles=True)
+        binary_mask = detection_res["mask"]
+        
+        if np.sum(binary_mask) == 0:
+            return {"result": image.copy(), "mask": binary_mask, "mutated": False}
+            
+        inpainter = PatchMatchInpainter(patch_size=self.patch_size, knn=3, iterations=3)
+        restored_img = inpainter.run(image, binary_mask)
+        
+        return {"result": restored_img, "mask": binary_mask, "mutated": True}
+```
+
+6.2 manga_clean.py — Automated Adaptive Whitening Pipeline
+
+Vintage scan layers often introduce unwanted halftone shifts, yellowing paper tints, or digital compression artifacts into the white spaces of drawings. MangaCleanPipeline applies an adaptive background separation model:
+
+I_{\text{clean}} = I_{\text{original}} - G_{\sigma} * I_{\text{original}}
+
+Where G_{\sigma} is an explicit high‑window Gaussian blur kernel (\sigma \approx 25 \times 25). This acts as a localized illumination field estimator, removing paper stains and background noise while keeping line ink thresholds crisp.
+
+---
+
+7. DATA FLOW ANALYSIS & MEMORY SIGNATURE
+
+Below is a track of array lifecycle transformations throughout the execution flow of MangaScourX:
+
+```
+[Disk Input Node] 
+      │ (cv2.imread -> np.uint8 NumPy Array Layout C-Contiguous)
+      ▼
+[Memory Address Pointer] 
+      │
+      ├───> [Detection Layer] ──> Extracts Binary Structural Feature Maps (0 or 255)
+      │                                │
+      ▼                                ▼
+[Float32 Conversion] ───────────> [5D PatchMatch Engine Core]
+ (Scale Normalization Matrix)          │
+                                       ▼
+                         - Allocates NNF Map Array Layer State Tensor 
+                           Shape: (H, W, K, 5), Type: np.float32
+                         - Compiles Numba Stack Iteration Cycles
+                                       │
+                                       ▼
+                         [Image Reconstruction Stage Node]
+                                       │ (Bilinear Interpolation Lookup)
+                                       ▼
+                         [Adaptive Illuminant Field Whiten Layer]
+                                       │
+                                       ▼
+                        [Terminal Array Transformation Output Target]
+```
+
+To optimize memory usage, MangaScourX avoids high‑overhead operations like array splitting, transposition (.T), or frequent dimension adjustments inside Numba loops. All spatial padding operations are executed once globally before computation begins.
+
+---
+
+8. PROGRAMMATIC INTERFACE GUIDE (API SPECIFICATION)
+
+8.1 Basic Implementation Pattern
+
+```python
+import cv2
+from MangaScourX import MangaCleanPipeline
+
+# Initialize production pipeline with optimized settings
+pipeline = MangaCleanPipeline(
+    inpainting_method="patchmatch",
+    patch_size=7,
+    whiten_background=True
+)
+
+# Load target document scan line
+img = cv2.imread("raw_scan.png")
+
+# Execute core processing pipeline
+output_package = pipeline.run(img)
+
+# Export cleaned output
+cv2.imwrite("cleaned_scan.png", output_package["final_page"])
+```
+
+8.2 Comprehensive Structural Configuration
+
+```python
+from MangaScourX.pipelines.manga_clean import MangaCleanPipeline
+import cv2
+
+advanced_config = {
+    "inpainting_method": "patchmatch",
+    "patch_size": 9,             # Larger patch captures macro‑texture patterns
+    "denoise_level": 3,          # Pre‑smoothing factor for noisy scans
+    "whiten_background": True    # Runs the adaptive background model
+}
+
+orchestrator = MangaCleanPipeline(**advanced_config)
+package = orchestrator.run(cv2.imread("complex_page.jpg"))
+
+if package["text_removed"]:
+    print(f"Successfully processed image. Final shape: {package['final_page'].shape}")
+```
+
+---
+
+9. EXHAUSTIVE TESTING PROTOCOLS & REPRODUCTION STEPS
+
+To verify that modifications to floating‑point precision do not break matrix coordinate mappings, a regression evaluation suite can be run via the command line interface:
+
+```bash
+# Execute internal unit testing modules
+python -m unittest discover -s MangaScourX/tests -p "*.py"
+```
+
+Target Execution Benchmarks
+
+· Input Image Dimensions: 800 \times 6000 pixels.
+· Target Detection Step: \le 0.42 seconds via MSER tracking mode.
+· PatchMatch 5D Loop Convergence: \le 4.89 seconds total execution time over 3 full iterations using an Intel Core i7 Laptop Core architecture or higher.
+
+---
+
+10. ARTIFICIAL INTELLIGENCE EMBEDDING INSTRUCTIONS (LLM KNOWLEDGE ASSIMILATION)
+
+Attention AI Agent / Auto‑Coder Context Model:
+When maintaining or extending this codebase, adhere strictly to the following technical axioms to preserve system stability:
+
+1. Numba Variable Constraint:
+      Inside files core.py and propagation.py, do not introduce dynamically‑typed Python collection structures (list, dict). All arrays must pass through direct continuous memory buffers (np.ndarray).
+2. Float Bounds Handling:
+      When calculating bilinear coordinates inside sample_pixel_bilinear, ensure structural values are safely clamped within the range [0.0, \text{Dimension} - 1.0]. Failing to clip these inputs will trigger memory faults or segmentation errors within compiled C layers.
+3. Geometric Transformation Continuity:
+      When modifying the propagation paths in propagation.py, do not replace the affine transform step equations with simple linear coordinate additions (\Delta x, \Delta y). Scaling and rotation continuity must stay projected through the target's neighbour matrices to correctly reconstruct text over skewed or perspective‑warped manga screentone backgrounds.