Mirror hardened BLLA polygonizer from main repo

CLAHE + Sauvola fallback + median seam + convex-hull recovery + int32 fix.

Co-authored-by: Cursor <cursoragent@cursor.com>

regnetx_infer/serialization/blla_polygonal_environment.py

@@ -23,7 +23,8 @@ from scipy.ndimage import affine_transform, binary_erosion, distance_transform_c
 from shapely.ops import nearest_points, unary_union
 from shapely.validation import explain_validity
 from skimage import draw
-from skimage.filters import sobel
+from skimage.exposure import equalize_adapthist
+from skimage.filters import sobel, threshold_sauvola
 from skimage.transform import AffineTransform, warp
 
 logger = logging.getLogger(__name__)
@@ -286,7 +287,9 @@ def _extract_patch(
         polygon = np.concatenate(([end_points[-1]], upper_seam, [end_points[0]], bottom_seam))
         polygon = geom.Polygon(polygon)
     if not polygon.is_valid:
-        raise Exception(f"Invalid bounding polygon computed: {explain_validity(polygon)}")
+        polygon = geom.MultiPoint(np.concatenate([upper_seam, bottom_seam])).convex_hull
+        if not polygon.is_valid or polygon.is_empty or polygon.geom_type != "Polygon":
+            raise Exception(f"Invalid bounding polygon computed: {explain_validity(polygon)}")
     inter = roi_polygon.intersection(polygon)
     if inter.is_empty:
         raise Exception("ROI ∩ polygon is empty")
@@ -366,8 +369,8 @@ def _calc_roi(line, bounds, baselines, suppl_obj, p_dir):
         )
         env_up.append(_coords_array(upper_limit)[0])
         env_bottom.append(_coords_array(bottom_limit)[0])
-    env_up = np.array(env_up, dtype="uint")
-    env_bottom = np.array(env_bottom, dtype="uint")
+    env_up = np.array(env_up, dtype="int32")
+    env_bottom = np.array(env_bottom, dtype="int32")
     return env_up, env_bottom
 
 
@@ -397,6 +400,7 @@ def calculate_polygonal_environment(
         if suppl_obj is not None:
             suppl_obj = [(np.array(bl) * scale_arr).astype("int").tolist() for bl in suppl_obj]
 
+    im_arr: np.ndarray | None = None
     if im_feats is None:
         assert im is not None
         bounds = np.array(im.size, dtype=float) - 1
@@ -405,6 +409,26 @@ def calculate_polygonal_environment(
     else:
         bounds = np.array(im_feats.shape[::-1], dtype=float) - 1
 
+    # Fallback edge maps (computed lazily on first failure):
+    # 1) CLAHE-enhanced Sobel — helps faded ink with even background
+    # 2) Sauvola-binarized Sobel — helps extreme low-contrast / foxed pages
+    _fallback_cache: dict[str, np.ndarray] = {}
+
+    def _get_fallback_feats() -> list[np.ndarray]:
+        if im_arr is None:
+            return []
+        out: list[np.ndarray] = []
+        if "clahe" not in _fallback_cache:
+            clahe = (equalize_adapthist(im_arr, clip_limit=0.03) * 255).astype(np.uint8)
+            _fallback_cache["clahe"] = gaussian_filter(sobel(clahe), 0.5)
+        out.append(_fallback_cache["clahe"])
+        if "sauvola" not in _fallback_cache:
+            thresh = threshold_sauvola(im_arr, window_size=25)
+            binary = (im_arr < thresh).astype(float)
+            _fallback_cache["sauvola"] = gaussian_filter(sobel(binary), 0.5)
+        out.append(_fallback_cache["sauvola"])
+        return out
+
     polygons: list = []
     if suppl_obj is None:
         suppl_obj = []
@@ -445,6 +469,30 @@ def calculate_polygonal_environment(
                 )
             )
         except Exception as e:
+            # Retry with fallback edge maps (CLAHE, then Sauvola) before giving up
+            recovered = False
+            for fb_feats in _get_fallback_feats():
+                try:
+                    polygons.append(
+                        _extract_patch(
+                            env_up,
+                            env_bottom,
+                            line_arr.astype("int"),
+                            offset_line.astype("int"),
+                            end_points,
+                            p_dir,
+                            topline,
+                            offset,
+                            fb_feats,
+                            bounds,
+                        )
+                    )
+                    recovered = True
+                    break
+                except Exception:
+                    continue
+            if recovered:
+                continue
             if raise_on_error:
                 raise
             logger.warning("Polygonizer failed on line %s: %s", idx, e)

regnetx_infer/serialization/polygon.py

@@ -97,7 +97,7 @@ def _polygon_scale_tuple(polygon_scale: int, page_w: int, page_h: int) -> tuple[
     page already fits within ``polygon_scale`` (we never upscale small pages).
     """
     s = int(polygon_scale)
-    if s <= 0 or max(page_w, page_h) <= s:
+    if s <= 0 or max(page_w, page_h) <= int(s * 1.3):
         return None
     return (s, 0)