Spaces:
Running
Running
| from __future__ import annotations | |
| from dataclasses import dataclass | |
| import numpy as np | |
| from features import _ensure_ink_true, binarize | |
| class GlyphSegment: | |
| bbox: tuple[int, int, int, int] | |
| image: np.ndarray | |
| def _true_runs(values: np.ndarray) -> list[tuple[int, int]]: | |
| padded = np.pad(np.asarray(values, dtype=np.int8), (1, 1)) | |
| changes = np.flatnonzero(np.diff(padded)) | |
| return [(int(start), int(end)) for start, end in changes.reshape(-1, 2)] | |
| def _tight_bbox(mask: np.ndarray) -> tuple[int, int, int, int] | None: | |
| ys, xs = np.where(mask) | |
| if not len(xs): | |
| return None | |
| return int(xs.min()), int(ys.min()), int(xs.max()) + 1, int(ys.max()) + 1 | |
| def _projection_boundaries( | |
| projection: np.ndarray, | |
| orthogonal_extent: int, | |
| max_characters: int, | |
| ) -> list[int]: | |
| extent = int(len(projection)) | |
| if extent < 2: | |
| return [] | |
| # A real gap between glyph cells is normally much wider than an internal | |
| # one- or two-pixel opening. Permit a tiny amount of antialiasing/noise in | |
| # an otherwise blank column or row. | |
| blank_threshold = max(0, int(round(orthogonal_extent * 0.015))) | |
| minimum_gap = max(2, int(round(orthogonal_extent * 0.06))) | |
| boundaries = [ | |
| (start + end) // 2 | |
| for start, end in _true_runs(projection <= blank_threshold) | |
| if start > 0 and end < extent and end - start >= minimum_gap | |
| ] | |
| if boundaries: | |
| return boundaries[: max(0, max_characters - 1)] | |
| # Touching glyphs may have no completely blank divider. If the ink block | |
| # is clearly wider/taller than one square Tangut cell, look near expected | |
| # cell boundaries for the lowest-ink projection instead. | |
| estimated = min(max_characters, max(1, int(round(extent / max(orthogonal_extent, 1))))) | |
| if estimated < 2 or extent < orthogonal_extent * 1.35: | |
| return [] | |
| cell = extent / estimated | |
| minimum_cell = max(2, int(round(cell * 0.55))) | |
| chosen: list[int] = [] | |
| for index in range(1, estimated): | |
| target = cell * index | |
| radius = max(2, int(round(cell * 0.22))) | |
| low = max(minimum_cell, int(round(target)) - radius) | |
| high = min(extent - minimum_cell, int(round(target)) + radius) | |
| if high <= low: | |
| continue | |
| candidates = np.arange(low, high + 1) | |
| best = min( | |
| candidates, | |
| key=lambda value: (float(projection[value]), abs(float(value) - target)), | |
| ) | |
| if not chosen or best - chosen[-1] >= minimum_cell: | |
| chosen.append(int(best)) | |
| return chosen | |
| def segment_glyphs( | |
| gray: np.ndarray, | |
| direction: str = "auto", | |
| max_characters: int = 32, | |
| ) -> tuple[str, list[GlyphSegment]]: | |
| image = np.asarray(gray) | |
| if image.ndim != 2: | |
| raise ValueError("Sequence segmentation expects a two-dimensional grayscale image.") | |
| if image.size == 0 or int(image.max()) == int(image.min()): | |
| return "horizontal", [] | |
| mask = _ensure_ink_true(binarize(image, min_size=2)) | |
| overall = _tight_bbox(mask) | |
| if overall is None: | |
| return "horizontal", [] | |
| left, top, right, bottom = overall | |
| width = right - left | |
| height = bottom - top | |
| if direction == "auto": | |
| resolved_direction = "horizontal" if width >= height else "vertical" | |
| elif direction in {"horizontal", "vertical"}: | |
| resolved_direction = direction | |
| else: | |
| raise ValueError("direction must be 'auto', 'horizontal', or 'vertical'.") | |
| tight_mask = mask[top:bottom, left:right] | |
| if resolved_direction == "horizontal": | |
| projection = tight_mask.sum(axis=0) | |
| relative_boundaries = _projection_boundaries(projection, height, max_characters) | |
| boundaries = [left, *(left + value for value in relative_boundaries), right] | |
| regions = [(boundaries[i], top, boundaries[i + 1], bottom) for i in range(len(boundaries) - 1)] | |
| else: | |
| projection = tight_mask.sum(axis=1) | |
| relative_boundaries = _projection_boundaries(projection, width, max_characters) | |
| boundaries = [top, *(top + value for value in relative_boundaries), bottom] | |
| regions = [(left, boundaries[i], right, boundaries[i + 1]) for i in range(len(boundaries) - 1)] | |
| minimum_ink = max(4, int(round(mask.sum() * 0.005))) | |
| segments: list[GlyphSegment] = [] | |
| for x0, y0, x1, y1 in regions: | |
| region_mask = mask[y0:y1, x0:x1] | |
| if int(region_mask.sum()) < minimum_ink: | |
| continue | |
| local = _tight_bbox(region_mask) | |
| if local is None: | |
| continue | |
| lx0, ly0, lx1, ly1 = local | |
| box = (x0 + lx0, y0 + ly0, x0 + lx1, y0 + ly1) | |
| bx0, by0, bx1, by1 = box | |
| segments.append(GlyphSegment(box, image[by0:by1, bx0:bx1].copy())) | |
| return resolved_direction, segments | |