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

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

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

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

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

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

@@ -15,7 +15,7 @@ Public entry point::
 import importlib
 from typing import Any
 
-__version__ = "0.1.0"
+__version__ = "0.2.1"
 
 # 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.0 → object_remove-0.2.1}/object_remove/cv/orb.py

@@ -31,12 +31,15 @@ def fast_corners(gray: np.ndarray, valid: np.ndarray, threshold: float = 0.06,
                  n_contig: int = 9, border: int = 16) -> List[Tuple[int, int]]:
     """FAST 9 corner detector over valid pixels only.
 
-    The per pixel Python loop scales with total image area, not hole size,
-    so it dominates on large photos. The 4 point compass quick reject (which
-    only needs to prune candidates, not decide corners) is vectorised over
-    the whole interior at once via shifted slices; the expensive full 16
-    point contiguous arc test then runs only on the much smaller surviving
-    candidate set, with identical semantics to the scalar version.
+    Both the 4 point compass quick reject and the full 16 point contiguous
+    arc test are vectorised over the whole interior at once via shifted
+    slices, rather than looping per candidate pixel in Python -- a Python
+    loop there would scale with total image area (not hole size), dominating
+    runtime on large photos. The arc test still needs a loop to walk the 16
+    (+n_contig-1 wrap-around) circle taps and accumulate the longest same
+    sign run, but that loop is a fixed ~24 iterations regardless of image
+    size, with each iteration a single vectorised array op over every
+    interior pixel at once -- identical semantics to the scalar version.
     """
     H, W = gray.shape
     circ = _FAST_CIRCLE
@@ -57,35 +60,26 @@ def fast_corners(gray: np.ndarray, valid: np.ndarray, threshold: float = 0.06,
         reject += (v > hi) | (v < lo)
 
     cand = (reject >= 3) & valid[iy0:iy1, ix0:ix1]
-    cys, cxs = np.nonzero(cand)
-
-    pts: List[Tuple[int, int]] = []
-    for cy, cx in zip(cys, cxs):
-        y, x = int(cy) + iy0, int(cx) + ix0
-        center_val = gray[y, x]
-        chi = center_val + threshold
-        clo = center_val - threshold
-        states = []
-        for dx, dy in circ:
-            v = gray[y + dy, x + dx]
-            states.append(1 if v > chi else (-1 if v < clo else 0))
-        if _has_contiguous(states, n_contig):
-            pts.append((y, x))
-    return pts
-
-
-def _has_contiguous(states: List[int], n: int) -> bool:
-    ext = states + states[:n - 1]
+    if not cand.any():
+        return []
+
+    states = np.empty((len(circ),) + center.shape, dtype=np.int8)
+    for i, (dx, dy) in enumerate(circ):
+        v = shifted(dx, dy)
+        states[i] = np.where(v > hi, 1, np.where(v < lo, -1, 0))
+
+    # circular wrap-around, same as `states + states[:n_contig - 1]` in the
+    # scalar version's per-point list
+    ext = np.concatenate([states, states[:n_contig - 1]], axis=0)
+    found = np.zeros(center.shape, dtype=bool)
     for sgn in (1, -1):
-        run = 0
-        for s in ext:
-            if s == sgn:
-                run += 1
-                if run >= n:
-                    return True
-            else:
-                run = 0
-    return False
+        run = np.zeros(center.shape, dtype=np.int32)
+        for i in range(ext.shape[0]):
+            run = np.where(ext[i] == sgn, run + 1, 0)
+            found |= run >= n_contig
+
+    cys, cxs = np.nonzero(cand & found)
+    return [(int(cy) + iy0, int(cx) + ix0) for cy, cx in zip(cys, cxs)]
 
 
 def _brief_pattern(patch: int = 15, n_bits: int = 256, seed: int = 42) -> np.ndarray:
@@ -97,26 +91,28 @@ _BRIEF = _brief_pattern()
 
 
 def brief_descriptors(gray: np.ndarray, pts: List[Tuple[int, int]]) -> List[Keypoint]:
-    """256 bit BRIEF on a smoothed image, packed into 32 uint8 bytes."""
+    """256 bit BRIEF on a smoothed image, packed into 32 uint8 bytes.
+
+    Bit computation is vectorised across all points *and* all 256 pattern
+    taps at once (one (N, 256) gather + compare + packbits), instead of a
+    per point Python loop each doing its own small array ops -- per call
+    overhead there dominates runtime for images with many keypoints.
+    """
+    if not pts:
+        return []
     sm = gaussian_blur(gray)
     H, W = sm.shape
-    out: List[Keypoint] = []
     pat = _BRIEF
-    # Per point bit computation is vectorised across all 256 pattern taps at
-    # once: the equivalent scalar per bit loop spends almost all its time in
-    # per element np.clip() call overhead (measured ~19x slower than a single
-    # array clip of the same size), which dominates runtime for images with
-    # many keypoints.
+    pys = np.asarray([p[0] for p in pts], dtype=np.int64)[:, None]
+    pxs = np.asarray([p[1] for p in pts], dtype=np.int64)[:, None]
     pax, pay, pbx, pby = pat[:, 0], pat[:, 1], pat[:, 2], pat[:, 3]
-    for (y, x) in pts:
-        ay = np.clip(y + pay, 0, H - 1)
-        ax = np.clip(x + pax, 0, W - 1)
-        by = np.clip(y + pby, 0, H - 1)
-        bx = np.clip(x + pbx, 0, W - 1)
-        bits = (sm[ay, ax] < sm[by, bx]).astype(np.uint8)
-        packed = np.packbits(bits)
-        out.append(Keypoint(y, x, packed))
-    return out
+    ay = np.clip(pys + pay[None, :], 0, H - 1)
+    ax = np.clip(pxs + pax[None, :], 0, W - 1)
+    by = np.clip(pys + pby[None, :], 0, H - 1)
+    bx = np.clip(pxs + pbx[None, :], 0, W - 1)
+    bits = (sm[ay, ax] < sm[by, bx]).astype(np.uint8)  # (N, 256)
+    packed = np.packbits(bits, axis=1)  # (N, 32)
+    return [Keypoint(y, x, packed[i]) for i, (y, x) in enumerate(pts)]
 
 
 def hamming(a: np.ndarray, b: np.ndarray) -> np.ndarray:

{object_remove-0.2.0 → object_remove-0.2.1}/object_remove/fillengines/primary/quad_tree_index.py

@@ -85,8 +85,10 @@ class QuadTreeIndex:
                 yield from self._iter_points(c)
 
     def all_points(self) -> np.ndarray:
-        idx = list(self._iter_points(self.root))
-        return self.coords[idx] if idx else np.empty((0, 2), dtype=np.int64)
+        # every index gets inserted into exactly one leaf at construction
+        # time (see __init__/_insert), so the full point set is always just
+        # self.coords -- no need to walk the tree to reconstruct it.
+        return self.coords
 
     def query_range(self, y0: int, x0: int, y1: int, x1: int) -> np.ndarray:
         """Points whose centre lies in ``[y0,y1) x [x0,x1)``, pruning whole
@@ -122,8 +124,15 @@ class QuadTreeIndex:
                                    ) -> Optional[Tuple[int, int]]:
         coords = self.all_points()
         if used and len(coords):
-            reuse_count = np.array([used.get((int(y), int(x)), 0) for y, x in coords])
-            coords = coords[reuse_count < max_reuse]
+            # linearise (y, x) -> y*W+x so the per-point dict.get in a Python
+            # loop becomes one vectorised membership test against just the
+            # (typically far smaller) set of sources that are actually
+            # over-used, rather than looping over every candidate in Python.
+            W = self.root.x1
+            overused = [k[0] * W + k[1] for k, v in used.items() if v >= max_reuse]
+            if overused:
+                coord_idx = coords[:, 0] * W + coords[:, 1]
+                coords = coords[~np.isin(coord_idx, overused)]
         return _best_match(image, ty, tx, coords, radius, target_valid)
 
 

{object_remove-0.2.0 → object_remove-0.2.1}/object_remove/fillengines/self_similar_shift.py

@@ -72,18 +72,27 @@ def _similar_far_offsets(kps: List[Keypoint], hole_bbox,
 # DP seam carving + transpose trick
 # ==========================================================================
 def min_cost_seam(energy: np.ndarray) -> np.ndarray:
-    """Min cost vertical seam via DP. Returns one column index per row."""
+    """Min cost vertical seam via DP. Returns one column index per row.
+
+    Row y only depends on row y-1, so the DP itself must stay a sequential
+    Python loop over rows; but within a row, each column's 3 way choice
+    (up-left/up/up-right) is independent of its neighbours' choices and is
+    vectorised across the whole row at once (edges padded with +inf so they
+    naturally fall back to the 2 candidate case), instead of an inner
+    per-column Python loop -- same argmin tie-breaking (favours the
+    lower-index candidate) as the scalar version.
+    """
     h, w = energy.shape
     cost = energy.astype(np.float64).copy()
     back = np.zeros((h, w), dtype=np.int32)
+    xs = np.arange(w)
     for y in range(1, h):
-        for x in range(w):
-            xl = max(0, x - 1)
-            xr = min(w - 1, x + 1)
-            choices = cost[y - 1, xl:xr + 1]
-            k = int(np.argmin(choices))
-            back[y, x] = xl + k
-            cost[y, x] += choices[k]
+        prev = cost[y - 1]
+        padded = np.concatenate(([np.inf], prev, [np.inf]))
+        choices = np.stack([padded[0:w], padded[1:w + 1], padded[2:w + 2]])  # (3, w)
+        k = np.argmin(choices, axis=0)
+        back[y] = np.clip(xs + (k - 1), 0, w - 1)
+        cost[y] += choices[k, xs]
     seam = np.zeros(h, dtype=np.int32)
     seam[-1] = int(np.argmin(cost[-1]))
     for y in range(h - 2, -1, -1):
@@ -267,6 +276,12 @@ class SelfSimilarShiftEngine:
         ry0, ry1 = rys.min(), rys.max() + 1
         rx0, rx1 = rxs.min(), rxs.max() + 1
         out = np.zeros((H, W), dtype=bool)
+        # The DP always spans the same fixed row range (ry0:ry1); only the
+        # column bounds change with each row's hole extent. Rows sharing the
+        # same (strip_x0, strip_x1) -- typical for straight-ish hole edges --
+        # would otherwise resolve the identical DP from scratch once per row
+        # just to read off a single seam[yy] value, so cache by those bounds.
+        seam_cache: dict = {}
         for y in range(ry0, ry1):
             hx = np.nonzero(hole[y])[0]
             if hx.size == 0:
@@ -277,9 +292,12 @@ class SelfSimilarShiftEngine:
                 strip_x0, strip_x1 = hx.max() + 1, rx1
             if strip_x1 <= strip_x0:
                 continue
-            strip = diff[ry0:ry1, strip_x0:strip_x1]
-            # cheap per row seam via cumulative min DP done once over the strip
-            seam = min_cost_seam(strip)
+            key = (strip_x0, strip_x1)
+            seam = seam_cache.get(key)
+            if seam is None:
+                strip = diff[ry0:ry1, strip_x0:strip_x1]
+                seam = min_cost_seam(strip)
+                seam_cache[key] = seam
             yy = y - ry0
             cut = strip_x0 + seam[yy]
             if axis == "left":

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

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

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

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