object-remove 0.2.1__tar.gz → 0.2.2__tar.gz

{object_remove-0.2.1 → object_remove-0.2.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: object-remove
-Version: 0.2.1
+Version: 0.2.2
 Summary: From-scratch reference implementation of a tiered on-device object-removal pipeline, CPU and GPU
 Author: shalaga44
 License-Expression: MIT
@@ -31,7 +31,7 @@ Dynamic: license-file
 
 # object_remove
 
-[![PyPI](https://img.shields.io/pypi/v/object-remove.svg)](https://pypi.org/project/object-remove/0.2.1/)
+[![PyPI](https://img.shields.io/pypi/v/object-remove.svg)](https://pypi.org/project/object-remove/)
 
 A from scratch implementation of an on device object removal pipeline (see
 [`docs/ARCHITECTURE.md`](docs/ARCHITECTURE.md) for the full design): a

{object_remove-0.2.1 → object_remove-0.2.2}/README.md

@@ -1,6 +1,6 @@
 # object_remove
 
-[![PyPI](https://img.shields.io/pypi/v/object-remove.svg)](https://pypi.org/project/object-remove/0.2.1/)
+[![PyPI](https://img.shields.io/pypi/v/object-remove.svg)](https://pypi.org/project/object-remove/)
 
 A from scratch implementation of an on device object removal pipeline (see
 [`docs/ARCHITECTURE.md`](docs/ARCHITECTURE.md) for the full design): a

{object_remove-0.2.1 → object_remove-0.2.2}/object_remove/__init__.py

@@ -15,7 +15,7 @@ Public entry point::
 import importlib
 from typing import Any
 
-__version__ = "0.2.1"
+__version__ = "0.2.2"
 
 # Lazy attribute map: name maps to (submodule, attribute). Loaded on first access so
 # importing any subpackage never eagerly drags in the whole tree.

{object_remove-0.2.1 → object_remove-0.2.2}/object_remove/effects/perspective_correction.py

@@ -99,6 +99,25 @@ def _bilinear_sample(image: np.ndarray, xs: np.ndarray, ys: np.ndarray) -> np.nd
     return out
 
 
+def bilinear_resize(image: np.ndarray, out_shape: Tuple[int, int]) -> np.ndarray:
+    """Plain bilinear resize to ``out_shape`` (oh, ow) -- pixel-center mapping
+    with clamped borders, not a homography warp. Shared by callers that need
+    an arbitrary-scale resize (e.g. the selection enhancer's pyramid blur)
+    without duplicating the bilinear-sample math."""
+    ih, iw = image.shape[:2]
+    oh, ow = out_shape
+    yy, xx = np.mgrid[0:oh, 0:ow]
+    src_x = np.clip((xx.astype(np.float64) + 0.5) * (iw / ow) - 0.5, 0.0, iw - 1)
+    src_y = np.clip((yy.astype(np.float64) + 0.5) * (ih / oh) - 0.5, 0.0, ih - 1)
+    img = image.astype(np.float64)
+    squeeze = img.ndim == 2
+    if squeeze:
+        img = img[:, :, None]
+    sampled = _bilinear_sample(img, src_x.ravel(), src_y.ravel())
+    sampled = sampled.reshape(oh, ow, -1)
+    return sampled[:, :, 0] if squeeze else sampled
+
+
 def map_image(image: np.ndarray, H: np.ndarray, out_shape: Tuple[int, int]) -> np.ndarray:
     """Warp ``image`` through ``H`` (src -> dst) into an image of
     ``out_shape``, via inverse mapping + bilinear sampling."""

{object_remove-0.2.1 → object_remove-0.2.2}/object_remove/fillengines/primary/patch_grid_solver_gpu.py

@@ -52,6 +52,37 @@ def _gather_windows(field: torch.Tensor, centers: torch.Tensor, r: int) -> torch
     return field[ys, xs]
 
 
+def _local_src_mask(source_coords: torch.Tensor, base_mask: torch.Tensor,
+                    layer_centers: torch.Tensor, margin0: int, cap: int) -> torch.Tensor:
+    """Restrict `base_mask` (already reuse-filtered) to a spatial window
+    around this layer's own centres, doubling the window until it actually
+    contains a candidate (or giving up at `cap` and returning `base_mask`
+    unrestricted). Nearby sources are always at least as good a match as far
+    ones for real photos, so this changes only which near-tied candidate wins
+    - not whether a good one is found.
+
+    Without this, every layer's (T, S) search scans every valid pixel in the
+    whole image (`_best_sources_batch` below), which is fine for a small hole
+    but is the dominant cost for a thick one: a hole this solver treats as
+    ``H`` boundary-distance layers deep (see `_hole_layers`) does that full
+    scan ``H`` times, and a hole a few hundred pixels thick (e.g. a wide,
+    mostly-flat padding bar) turns into a multi-minute solve on a search that
+    only ever needed its own neighbourhood."""
+    cy0 = int(layer_centers[:, 0].min())
+    cy1 = int(layer_centers[:, 0].max())
+    cx0 = int(layer_centers[:, 1].min())
+    cx1 = int(layer_centers[:, 1].max())
+    margin = margin0
+    while margin < cap:
+        spatial = ((source_coords[:, 0] >= cy0 - margin) & (source_coords[:, 0] <= cy1 + margin) &
+                  (source_coords[:, 1] >= cx0 - margin) & (source_coords[:, 1] <= cx1 + margin))
+        combined = base_mask & spatial
+        if combined.any():
+            return combined
+        margin *= 2
+    return base_mask
+
+
 def _best_sources_batch(working: torch.Tensor, known: torch.Tensor,
                         target_centers: torch.Tensor, source_coords: torch.Tensor,
                         src_mask: torch.Tensor, r: int):
@@ -136,6 +167,8 @@ class TorchPrimaryFillEngineImpl:
         records: List[PatchCopyRecord] = []
         total = max(1, len(centers_np))
         processed = 0
+        local_margin0 = max(4 * r, 16)
+        local_cap = max(H, W)
 
         for layer_id in np.unique(center_layers):
             if cancel is not None and cancel():
@@ -144,6 +177,8 @@ class TorchPrimaryFillEngineImpl:
             layer_centers = centers[idx]
 
             src_mask = reuse_count < self.max_reuse
+            src_mask = _local_src_mask(source_coords, src_mask, layer_centers,
+                                       local_margin0, local_cap)
             best_idx, best_dist = _best_sources_batch(
                 working, known, layer_centers, source_coords, src_mask, r)
 

object_remove-0.2.2/object_remove/mask/connected_components.py

@@ -0,0 +1,142 @@
+"""Connected component labelling.
+
+Labelling is a from scratch run-length union find (no
+``scipy.ndimage.label``): each row is decomposed into contiguous True runs,
+union-find operates over runs rather than individual pixels (a filled region
+has orders of magnitude fewer runs than pixels), and the final label write
+back is one vectorized numpy slice assignment per run. The per region
+*extraction* step is fanned out across a bounded thread pool so splitting a
+selection into its components stays fast on large masks.
+"""
+
+from __future__ import annotations
+
+from concurrent.futures import ThreadPoolExecutor
+from typing import Dict, List, Tuple
+
+import numpy as np
+
+
+class _UnionFind:
+    __slots__ = ("parent",)
+
+    def __init__(self, n: int):
+        self.parent = list(range(n))
+
+    def find(self, x: int) -> int:
+        root = x
+        while self.parent[root] != root:
+            root = self.parent[root]
+        while self.parent[x] != root:
+            self.parent[x], x = root, self.parent[x]
+        return root
+
+    def union(self, a: int, b: int) -> None:
+        ra, rb = self.find(a), self.find(b)
+        if ra != rb:
+            self.parent[max(ra, rb)] = min(ra, rb)
+
+
+def _row_runs(mask: np.ndarray) -> List[List[Tuple[int, int]]]:
+    """Per-row list of inclusive ``(start, end)`` True-run spans."""
+    h = mask.shape[0]
+    runs: List[List[Tuple[int, int]]] = []
+    for y in range(h):
+        row = mask[y]
+        if not row.any():
+            runs.append([])
+            continue
+        idx = np.flatnonzero(np.diff(np.concatenate(([0], row.view(np.int8), [0]))))
+        runs.append([(int(a), int(b) - 1) for a, b in zip(idx[0::2], idx[1::2])])
+    return runs
+
+
+def _label_dense(mask: np.ndarray, connectivity: int) -> Tuple[np.ndarray, int]:
+    """Run-based labelling over an already-cropped-to-content array."""
+    h, w = mask.shape
+    labels = np.zeros((h, w), dtype=np.int32)
+    row_runs = _row_runs(mask)
+
+    run_id: List[List[int]] = []
+    next_id = 0
+    for runs in row_runs:
+        run_id.append(list(range(next_id, next_id + len(runs))))
+        next_id += len(runs)
+    if next_id == 0:
+        return labels, 0
+    uf = _UnionFind(next_id)
+
+    diag = connectivity == 8
+    for y in range(1, h):
+        prev_runs, cur_runs = row_runs[y - 1], row_runs[y]
+        if not prev_runs or not cur_runs:
+            continue
+        i = j = 0
+        while i < len(prev_runs) and j < len(cur_runs):
+            p0, p1 = prev_runs[i]
+            c0, c1 = cur_runs[j]
+            touches = (p0 <= c1 + 1 and c0 <= p1 + 1) if diag else (p0 <= c1 and c0 <= p1)
+            if touches:
+                uf.union(run_id[y - 1][i], run_id[y][j])
+            if p1 < c1:
+                i += 1
+            else:
+                j += 1
+
+    remap: Dict[int, int] = {}
+    count = 0
+    for y, runs in enumerate(row_runs):
+        for j, (x0, x1) in enumerate(runs):
+            root = uf.find(run_id[y][j])
+            lab = remap.get(root)
+            if lab is None:
+                count += 1
+                lab = count
+                remap[root] = lab
+            labels[y, x0:x1 + 1] = lab
+    return labels, count
+
+
+def label_components(mask: np.ndarray, connectivity: int = 8) -> Tuple[np.ndarray, int]:
+    """Run-length union find labelling. Returns (labels, count).
+
+    ``labels`` is int32, 0 = background, 1..count = components. Cropped to
+    the mask's bounding box internally (a selection is usually a small
+    region of a much larger canvas) before labelling, then placed back.
+    """
+    mask = np.ascontiguousarray(mask > 0)
+    h, w = mask.shape
+    labels = np.zeros((h, w), dtype=np.int32)
+    if not mask.any():
+        return labels, 0
+    row_any = np.flatnonzero(mask.any(axis=1))
+    col_any = np.flatnonzero(mask.any(axis=0))
+    y0, y1 = int(row_any[0]), int(row_any[-1])
+    x0, x1 = int(col_any[0]), int(col_any[-1])
+    sub_labels, count = _label_dense(mask[y0:y1 + 1, x0:x1 + 1], connectivity)
+    labels[y0:y1 + 1, x0:x1 + 1] = sub_labels
+    return labels, count
+
+
+def split_components(mask: np.ndarray, max_selections: int = 0,
+                     min_area: int = 1, workers: int = 4) -> List[np.ndarray]:
+    """Split a mask into per component boolean masks.
+
+    Extraction is fanned across a bounded worker pool. ``max_selections`` (>0)
+    keeps only the largest N components; ``min_area`` drops specks.
+    """
+    labels, n = label_components(mask)
+    if n == 0:
+        return []
+
+    def extract(lab: int) -> np.ndarray:
+        return labels == lab
+
+    with ThreadPoolExecutor(max_workers=max(1, workers)) as ex:
+        comps = list(ex.map(extract, range(1, n + 1)))
+
+    comps = [c for c in comps if int(c.sum()) >= min_area]
+    comps.sort(key=lambda c: int(c.sum()), reverse=True)
+    if max_selections and max_selections > 0:
+        comps = comps[:max_selections]
+    return comps

object_remove-0.2.2/object_remove/mask/scanline_selection.py

@@ -0,0 +1,123 @@
+"""Scanline/run-length selection model.
+
+A selection is a list of rows, each holding a sorted list of
+non-overlapping, non-adjacent inclusive ``(start, end)`` column spans.
+``add_region`` inserts a span via binary search and absorbs any spans that
+overlap or touch it. This is the data structure ``SelectionEnhancer.
+process_selection`` uses for the 15%-85% object-separation overlap gate.
+"""
+
+from __future__ import annotations
+
+import bisect
+from typing import List, Tuple
+
+import numpy as np
+
+Span = Tuple[int, int]
+
+
+class ScanlineSelection:
+    """Run-length selection over a fixed ``(height, width)`` canvas."""
+
+    def __init__(self, height: int, width: int):
+        self.height = height
+        self.width = width
+        self.rows: List[List[Span]] = [[] for _ in range(height)]
+
+    def add_region(self, row: int, x0: int, x1: int) -> None:
+        """Insert inclusive span ``[x0, x1]`` into ``row``, merging with any
+        overlapping or adjacent existing spans."""
+        if row < 0 or row >= self.height or x1 < x0:
+            return
+        x0 = max(0, x0)
+        x1 = min(self.width - 1, x1)
+        if x1 < x0:
+            return
+        spans = self.rows[row]
+        starts = [s[0] for s in spans]
+        idx = bisect.bisect_left(starts, x0)
+        j = idx
+        while j > 0 and spans[j - 1][1] >= x0 - 1:
+            j -= 1
+        k = idx
+        while k < len(spans) and spans[k][0] <= x1 + 1:
+            k += 1
+        new_start, new_end = x0, x1
+        if j < k:
+            new_start = min(new_start, spans[j][0])
+            new_end = max(new_end, spans[k - 1][1])
+        spans[j:k] = [(new_start, new_end)]
+
+    @classmethod
+    def from_mask(cls, mask: np.ndarray) -> "ScanlineSelection":
+        h, w = mask.shape
+        sel = cls(h, w)
+        mask = mask > 0
+        for y in range(h):
+            row = mask[y]
+            if not row.any():
+                continue
+            idx = np.flatnonzero(np.diff(np.concatenate(([0], row.view(np.int8), [0]))))
+            spans = [(int(a), int(b) - 1) for a, b in zip(idx[0::2], idx[1::2])]
+            sel.rows[y] = spans
+        return sel
+
+    def to_mask(self) -> np.ndarray:
+        mask = np.zeros((self.height, self.width), dtype=bool)
+        for y, spans in enumerate(self.rows):
+            for x0, x1 in spans:
+                mask[y, x0:x1 + 1] = True
+        return mask
+
+    def intersect(self, other: "ScanlineSelection") -> "ScanlineSelection":
+        """Per-row interval intersection."""
+        out = ScanlineSelection(self.height, self.width)
+        for y in range(min(self.height, other.height)):
+            a, b = self.rows[y], other.rows[y]
+            i = j = 0
+            result: List[Span] = []
+            while i < len(a) and j < len(b):
+                lo = max(a[i][0], b[j][0])
+                hi = min(a[i][1], b[j][1])
+                if lo <= hi:
+                    result.append((lo, hi))
+                if a[i][1] < b[j][1]:
+                    i += 1
+                else:
+                    j += 1
+            out.rows[y] = result
+        return out
+
+    def difference(self, other: "ScanlineSelection") -> "ScanlineSelection":
+        """Per-row interval subtraction: ``self`` minus ``other``."""
+        out = ScanlineSelection(self.height, self.width)
+        for y in range(self.height):
+            a = self.rows[y]
+            b = other.rows[y] if y < other.height else []
+            result: List[Span] = []
+            for x0, x1 in a:
+                cur = x0
+                for bx0, bx1 in b:
+                    if bx1 < cur or bx0 > x1:
+                        continue
+                    if bx0 > cur:
+                        result.append((cur, min(bx0 - 1, x1)))
+                    cur = max(cur, bx1 + 1)
+                    if cur > x1:
+                        break
+                if cur <= x1:
+                    result.append((cur, x1))
+            out.rows[y] = result
+        return out
+
+    def total_length(self) -> int:
+        return sum(x1 - x0 + 1 for spans in self.rows for x0, x1 in spans)
+
+    def row_overlap_ratio(self, other: "ScanlineSelection") -> float:
+        """Percentage of ``self``'s covered columns also covered by
+        ``other`` (used by the 15%-85% object-separation gate)."""
+        total = self.total_length()
+        if total == 0:
+            return 0.0
+        return self.intersect(other).total_length() / total * 100.0

object_remove-0.2.2/object_remove/mask/selection_enhancer.py

@@ -0,0 +1,253 @@
+"""Selection refinement operations.
+
+* ``denoise_and_smooth`` — jaggy edge cleanup via morphological open/close,
+  iteration count knob only.
+* ``soften`` — feathering, ``radius`` + ``iterations`` knobs, returns a *soft*
+  (float) mask, a distinct operation from denoise.
+* ``split_into_selections`` — threaded connected component split (delegates to
+  :mod:`connected_components`).
+* ``split_touching_objects`` — explicit object separation, a distinct entry
+  point from the quick split above.
+* ``exclude_region`` / ``erode_by_radius`` — carve a forbidden area out of a
+  selection, and per sub selection erosion.
+* ``process_selection`` — full refinement pipeline: mesh thickness estimate,
+  resolution scaled smoothing, gated object separation, boundary-bridge
+  softening.
+"""
+
+from __future__ import annotations
+
+from typing import List, Optional
+
+import numpy as np
+
+from .connected_components import split_components, label_components
+from .polygon_selection import PolygonSelection
+from .brush_rasterizer import BrushRasterizer
+from .scanline_selection import ScanlineSelection
+from ..effects.perspective_correction import bilinear_resize
+
+
+def _binary_dilate(mask: np.ndarray, iterations: int = 1) -> np.ndarray:
+    m = mask.copy()
+    for _ in range(iterations):
+        out = m.copy()
+        out[1:, :] |= m[:-1, :]
+        out[:-1, :] |= m[1:, :]
+        out[:, 1:] |= m[:, :-1]
+        out[:, :-1] |= m[:, 1:]
+        m = out
+    return m
+
+
+def _binary_erode(mask: np.ndarray, iterations: int = 1) -> np.ndarray:
+    m = mask.copy()
+    for _ in range(iterations):
+        out = m.copy()
+        out[1:, :] &= m[:-1, :]
+        out[:-1, :] &= m[1:, :]
+        out[:, 1:] &= m[:, :-1]
+        out[:, :-1] &= m[:, 1:]
+        # treat outside as empty, so borders erode away
+        out[0, :] &= m[0, :]
+        m = out
+    return m
+
+
+def _box_blur(img: np.ndarray, radius: int) -> np.ndarray:
+    """Separable box blur via cumulative sums (float input/output)."""
+    if radius <= 0:
+        return img
+    pad = radius
+    win = 2 * radius + 1
+    padded = np.pad(img, pad, mode="edge")
+    # horizontal sliding window mean (returns width back to original W)
+    cs = np.cumsum(padded, axis=1)
+    cs = np.pad(cs, ((0, 0), (1, 0)), mode="constant")
+    padded = (cs[:, win:] - cs[:, :-win]) / win
+    # vertical sliding window mean (returns height back to original H)
+    cs = np.cumsum(padded, axis=0)
+    cs = np.pad(cs, ((1, 0), (0, 0)), mode="constant")
+    padded = (cs[win:, :] - cs[:-win, :]) / win
+    return padded
+
+
+class SelectionEnhancer:
+    """Refinement operations over boolean/soft masks."""
+
+    def denoise_and_smooth(self, mask: np.ndarray, iterations: int = 1) -> np.ndarray:
+        """Morphological open then close — removes specks and fills pinholes.
+
+        Iteration count knob only (distinct from :meth:`soften`).
+        """
+        m = mask > 0
+        for _ in range(max(1, iterations)):
+            m = _binary_dilate(_binary_erode(m))  # open
+            m = _binary_erode(_binary_dilate(m))  # close
+        return m
+
+    def soften(self, mask: np.ndarray, radius: float = 3.0,
+               iterations: int = 1) -> np.ndarray:
+        """Feather the mask edge; returns a soft float mask in [0, 1].
+
+        ``radius`` + ``iterations`` knobs — a different operation from
+        denoise. Repeated box blur approximates a Gaussian feather.
+        """
+        soft = (mask > 0).astype(np.float32)
+        r = max(1, int(round(radius)))
+        for _ in range(max(1, iterations)):
+            soft = _box_blur(soft, r).astype(np.float32)
+        return np.clip(soft, 0.0, 1.0)
+
+    def erode_by_radius(self, mask: np.ndarray, radius: int = 1) -> np.ndarray:
+        """Erode the mask edge inward by ``radius``."""
+        return _binary_erode(mask > 0, iterations=max(1, radius))
+
+    def split_into_selections(self, mask: np.ndarray, max_selections: int = 0,
+                              min_area: int = 1, workers: int = 4) -> List[np.ndarray]:
+        """Split into sub selections across a bounded worker pool."""
+        return split_components(mask, max_selections=max_selections,
+                                min_area=min_area, workers=workers)
+
+    def split_touching_objects(self, mask: np.ndarray, min_area: int = 1) -> List[np.ndarray]:
+        """Explicit object separation, a distinct entry point from the quick
+        split above.
+
+        Separates touching but thin connections with an erosion before
+        labelling, then dilates each object back to its original extent (a
+        watershed lite).
+        """
+        core = _binary_erode(mask > 0, iterations=1)
+        comps = split_components(core, min_area=min_area)
+        result = []
+        for c in comps:
+            grown = _binary_dilate(c, iterations=1) & (mask > 0)
+            result.append(grown)
+        return result
+
+    def exclude_region(self, mask: np.ndarray, forbidden: np.ndarray) -> np.ndarray:
+        """Remove a forbidden region from a selection.
+
+        The forbidden mask marks pixels that must never be edited or used
+        as a fill source.
+        """
+        return (mask > 0) & ~(forbidden > 0)
+
+    def estimate_thickness(self, mask: np.ndarray) -> int:
+        """How "thick" the selection is, 0..30ish.
+
+        Resamples the selection at ``scale = min(4000 / max(H, W), 1.0)`` and
+        reads back the max antialiased coverage byte; a thin sliver loses
+        coverage under downsampling while a solid blob stays near 255.
+        """
+        h, w = mask.shape
+        max_dim = max(h, w)
+        if max_dim == 0:
+            return 0
+        scale = min(4000.0 / max_dim, 1.0)
+        new_h = max(1, int(round(h * scale)))
+        new_w = max(1, int(round(w * scale)))
+        coverage = bilinear_resize((mask > 0).astype(np.float64), (new_h, new_w))
+        max_byte = float(coverage.max()) * 255.0 if coverage.size else 0.0
+        return int(max_byte / 8.5)
+
+    def _pyramid_smooth(self, mask: np.ndarray, levels: int) -> np.ndarray:
+        """``levels`` rounds of halving-downsample then upsample-back via
+        bilinear resize, thresholded back to boolean -- a cheap mip-chain
+        blur that scales with selection size instead of a fixed kernel."""
+        h, w = mask.shape
+        sizes = [(h, w)]
+        cur_h, cur_w = h, w
+        for _ in range(max(1, levels)):
+            cur_h = max(1, cur_h // 2)
+            cur_w = max(1, cur_w // 2)
+            sizes.append((cur_h, cur_w))
+        img = (mask > 0).astype(np.float64)
+        for size in sizes[1:]:
+            img = bilinear_resize(img, size)
+        for size in reversed(sizes[:-1]):
+            img = bilinear_resize(img, size)
+        return img > 0.5
+
+    def separate_objects(self, mask: np.ndarray, thickness: int) -> List[np.ndarray]:
+        """Erode-then-relabel object separation (watershed-lite), dropping
+        slivers whose area is under 15% of their own bounding-box area."""
+        radius = max(1, thickness // 10)
+        core = _binary_erode(mask > 0, iterations=radius)
+        comps = split_components(core, min_area=1)
+        result: List[np.ndarray] = []
+        for comp in comps:
+            grown = _binary_dilate(comp, iterations=radius) & (mask > 0)
+            area = int(grown.sum())
+            if area == 0:
+                continue
+            ys, xs = np.nonzero(grown)
+            bbox_area = int(ys.max() - ys.min() + 1) * int(xs.max() - xs.min() + 1)
+            if bbox_area * 0.15 > area:
+                continue
+            result.append(grown)
+        return result
+
+    def soften_by_boundary_bridge(self, mask: np.ndarray, radius: float,
+                                  iterations: int, thickness: int) -> np.ndarray:
+        """Soften by bridging, not by feathering: between every pair of
+        *different* fragments, paints a capsule stroke across their nearest
+        boundary points whenever that gap is within
+        ``min(thickness * 0.01 * radius, 51.0)`` pixels -- reuniting pieces
+        the earlier erosion-based separation split too eagerly, while gaps
+        wider than the threshold are left as genuinely separate objects."""
+        h, w = mask.shape
+        threshold = min(thickness * 0.01 * radius, 51.0)
+        out = (mask > 0).copy()
+        labels, n = label_components(out)
+        if n < 2:
+            return out
+        br = BrushRasterizer(w, h)
+        stroke_radius = max(1.0, float(iterations))
+        boundaries = [PolygonSelection.from_mask(labels == lab).boundary_points()
+                     for lab in range(1, n + 1)]
+        for i in range(n):
+            pts_i = boundaries[i]
+            if len(pts_i) == 0:
+                continue
+            for j in range(i + 1, n):
+                pts_j = boundaries[j]
+                if len(pts_j) == 0:
+                    continue
+                d = np.hypot(pts_i[:, None, 0] - pts_j[None, :, 0],
+                            pts_i[:, None, 1] - pts_j[None, :, 1])
+                flat_idx = int(np.argmin(d))
+                a_idx, b_idx = np.unravel_index(flat_idx, d.shape)
+                if d[a_idx, b_idx] <= threshold:
+                    p1, p2 = pts_i[a_idx], pts_j[b_idx]
+                    out |= br.stamp_stroke([tuple(map(float, p1)), tuple(map(float, p2))],
+                                          radius=stroke_radius)
+        return out
+
+    def process_selection(self, mask: np.ndarray, radius: float = 3.0,
+                          iterations: int = 1,
+                          forbidden: Optional[np.ndarray] = None) -> np.ndarray:
+        """Full refinement pipeline: estimate thickness, denoise/smooth using
+        it, conditionally separate touching objects (only kept if their
+        per-row overlap with the smoothed selection is between 15% and 85%),
+        then soften by boundary bridging."""
+        mask_bool = mask > 0
+        if not mask_bool.any():
+            return mask_bool
+        thickness = self.estimate_thickness(mask_bool)
+        levels = 3 if thickness <= 8 else 4
+        smoothed = self._pyramid_smooth(mask_bool, levels)
+        objects = self.separate_objects(smoothed, thickness)
+        working = smoothed
+        if objects:
+            union = np.zeros_like(smoothed)
+            for comp in objects:
+                union |= comp
+            ratio = ScanlineSelection.from_mask(smoothed).row_overlap_ratio(
+                ScanlineSelection.from_mask(union))
+            if 15.0 <= ratio <= 85.0:
+                working = union
+        soft = self.soften_by_boundary_bridge(working, radius, iterations, thickness)
+        if forbidden is not None:
+            soft = self.exclude_region(soft, forbidden)
+        return soft

{object_remove-0.2.1 → object_remove-0.2.2}/object_remove/pipeline/remove_object_job.py

@@ -105,7 +105,7 @@ class RemoveObjectJob:
             # Smooth jagged edges, but never drop user selected pixels — eroding
             # the mask would leave slivers of the object unremoved. Union back
             # with the original selection so refinement can only grow coverage.
-            hole = self._enh.denoise_and_smooth(hole, iterations=1) | (mask > 0)
+            hole = self._enh.process_selection(hole, radius=3.0, iterations=1) | (mask > 0)
         if not hole.any():
             return JobResult(self.image.copy(), tier, stages=stages)
 

{object_remove-0.2.1 → object_remove-0.2.2}/object_remove.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: object-remove
-Version: 0.2.1
+Version: 0.2.2
 Summary: From-scratch reference implementation of a tiered on-device object-removal pipeline, CPU and GPU
 Author: shalaga44
 License-Expression: MIT
@@ -31,7 +31,7 @@ Dynamic: license-file
 
 # object_remove
 
-[![PyPI](https://img.shields.io/pypi/v/object-remove.svg)](https://pypi.org/project/object-remove/0.2.1/)
+[![PyPI](https://img.shields.io/pypi/v/object-remove.svg)](https://pypi.org/project/object-remove/)
 
 A from scratch implementation of an on device object removal pipeline (see
 [`docs/ARCHITECTURE.md`](docs/ARCHITECTURE.md) for the full design): a

{object_remove-0.2.1 → object_remove-0.2.2}/object_remove.egg-info/SOURCES.txt

@@ -47,6 +47,7 @@ object_remove/mask/auto_select.py
 object_remove/mask/brush_rasterizer.py
 object_remove/mask/connected_components.py
 object_remove/mask/polygon_selection.py
+object_remove/mask/scanline_selection.py
 object_remove/mask/selection_enhancer.py
 object_remove/pipeline/__init__.py
 object_remove/pipeline/remove_object_job.py

{object_remove-0.2.1 → object_remove-0.2.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "object-remove"
-version = "0.2.1"
+version = "0.2.2"
 description = "From-scratch reference implementation of a tiered on-device object-removal pipeline, CPU and GPU"
 readme = "README.md"
 license = "MIT"