Spaces:
Paused
Paused
Download modules/vision/segmenter.py from SamilG2/BACKEND-CheckScan: direct link, hf CLI and curl.
- Browser
- Download file 5.41 kB
-
https://huggingface.co/spaces/SamilG2/BACKEND-CheckScan/resolve/main/modules/vision/segmenter.py
- Command line
-
hf download hf://spaces/SamilG2/BACKEND-CheckScan/modules/vision/segmenter.py
-
curl -L -o segmenter.py https://huggingface.co/spaces/SamilG2/BACKEND-CheckScan/resolve/main/modules/vision/segmenter.py
5.41 kB
| import cv2 | |
| import numpy as np | |
| def _detect_lines(gray_img): | |
| h, w = gray_img.shape | |
| clahe = cv2.createCLAHE(clipLimit=2.0, tileGridSize=(8, 8)) | |
| enhanced = clahe.apply(gray_img) | |
| binary = cv2.adaptiveThreshold(enhanced, 255, cv2.ADAPTIVE_THRESH_GAUSSIAN_C, | |
| cv2.THRESH_BINARY_INV, 11, 8) | |
| h_kernel = cv2.getStructuringElement(cv2.MORPH_RECT, (w // 10, 1)) | |
| h_lines = cv2.dilate(cv2.morphologyEx(binary, cv2.MORPH_OPEN, h_kernel, iterations=2), | |
| None, iterations=1) | |
| v_kernel = cv2.getStructuringElement(cv2.MORPH_RECT, (1, h // 15)) | |
| v_lines = cv2.dilate(cv2.morphologyEx(binary, cv2.MORPH_OPEN, v_kernel, iterations=2), | |
| None, iterations=1) | |
| return h_lines, v_lines | |
| def _extract_peaks(projection, threshold): | |
| above = projection > threshold | |
| positions = [] | |
| in_peak = False | |
| peak_vals = [] | |
| for i in range(len(above)): | |
| if above[i] and not in_peak: | |
| in_peak = True | |
| peak_vals = [i] | |
| elif above[i] and in_peak: | |
| peak_vals.append(i) | |
| elif not above[i] and in_peak: | |
| positions.append(int(np.mean(peak_vals))) | |
| in_peak = False | |
| peak_vals = [] | |
| if in_peak and peak_vals: | |
| positions.append(int(np.mean(peak_vals))) | |
| return positions | |
| def _get_line_positions(line_mask, axis, expected_range=None): | |
| projection = np.sum(line_mask, axis=(1 if axis == 0 else 0)).astype(float) | |
| if projection.max() == 0: | |
| return [] | |
| projection /= projection.max() | |
| best_positions = [] | |
| best_score = float('inf') | |
| for threshold in [0.05, 0.10, 0.15, 0.20, 0.25, 0.30, 0.40, 0.50]: | |
| positions = _extract_peaks(projection, threshold) | |
| if expected_range: | |
| min_exp, max_exp = expected_range | |
| if min_exp <= len(positions) <= max_exp: | |
| return positions | |
| score = abs(len(positions) - (min_exp + max_exp) / 2) | |
| if score < best_score: | |
| best_score = score | |
| best_positions = positions | |
| elif threshold == 0.20: | |
| return positions | |
| return best_positions | |
| def _filter_table_region(h_positions, v_positions): | |
| if len(h_positions) < 3: | |
| return h_positions, v_positions | |
| clean_v = [v_positions[0]] | |
| for i in range(1, len(v_positions)): | |
| if v_positions[i] - clean_v[-1] > 20: | |
| clean_v.append(v_positions[i]) | |
| return h_positions[1:], clean_v | |
| def _extract_cells(img_rect, h_positions, v_positions, content_cols): | |
| cells = [] | |
| for i in range(len(h_positions) - 1): | |
| y1, y2 = h_positions[i], h_positions[i + 1] | |
| for j in content_cols: | |
| x1, x2 = v_positions[j], v_positions[j + 1] | |
| pad_x = max(2, int((x2 - x1) * 0.03)) | |
| pad_y = max(2, int((y2 - y1) * 0.08)) | |
| cell_img = img_rect[y1+pad_y:y2-pad_y, x1+pad_x:x2-pad_x] | |
| if cell_img.size == 0: | |
| continue | |
| cells.append({'image': cell_img, 'row': i, 'col': j}) | |
| return cells | |
| def _assign_move_numbers(cells, col_to_content): | |
| for cell in cells: | |
| cell['col_index'] = col_to_content.get(cell['col'], 0) | |
| rows = sorted(set(c['row'] for c in cells)) | |
| num_rows = len(rows) | |
| row_to_idx = {r: i for i, r in enumerate(rows)} | |
| for cell in cells: | |
| block = cell['col_index'] // 2 | |
| is_black = cell['col_index'] % 2 | |
| row_idx = row_to_idx[cell['row']] | |
| cell['move_number'] = row_idx + 1 + (block * num_rows) | |
| cell['color'] = 'black' if is_black else 'white' | |
| cells.sort(key=lambda c: (c['move_number'], 0 if c['color'] == 'white' else 1)) | |
| return cells | |
| def preprocess_for_trocr(cell_img: np.ndarray) -> np.ndarray | None: | |
| """Convierte una celda a escala de grises 64x384px para TrOCR.""" | |
| gray = cv2.cvtColor(cell_img, cv2.COLOR_BGR2GRAY) if len(cell_img.shape) == 3 else cell_img.copy() | |
| gray = cv2.normalize(gray, None, 0, 255, cv2.NORM_MINMAX) | |
| h, w = gray.shape | |
| if h == 0 or w == 0: | |
| return None | |
| scale = 64 / h | |
| new_w = max(1, int(w * scale)) | |
| resized = cv2.resize(gray, (new_w, 64), interpolation=cv2.INTER_AREA) | |
| canvas = np.full((64, 384), 255, dtype=np.uint8) | |
| canvas[:, :min(new_w, 384)] = resized[:, :384] | |
| return canvas | |
| def segment_scoresheet(img_rect: np.ndarray) -> list[dict]: | |
| """Detecta la cuadricula y extrae celdas de movimientos ordenadas por jugada.""" | |
| gray = cv2.GaussianBlur(cv2.cvtColor(img_rect, cv2.COLOR_BGR2GRAY), (3, 3), 0) | |
| h_lines_mask, v_lines_mask = _detect_lines(gray) | |
| h_positions = _get_line_positions(h_lines_mask, axis=0, expected_range=(21, 27)) | |
| v_positions = _get_line_positions(v_lines_mask, axis=1, expected_range=(7, 13)) | |
| h_positions, v_positions = _filter_table_region(h_positions, v_positions) | |
| col_widths = [v_positions[j+1] - v_positions[j] for j in range(len(v_positions) - 1)] | |
| if not col_widths: | |
| return [] | |
| median_width = np.median(col_widths) | |
| content_cols = [j for j, w in enumerate(col_widths) if w > median_width * 0.5] | |
| col_to_content = {j: idx for idx, j in enumerate(content_cols)} | |
| cells = _extract_cells(img_rect, h_positions, v_positions, content_cols) | |
| cells = _assign_move_numbers(cells, col_to_content) | |
| return cells | |