Major table extraction quality overhaul

- Replace Tesseract with EasyOCR for cell text (much better Cyrillic support)
- Add OpenCV line detection fallback when Table Transformer misses rows/columns
- Use adaptive threshold (Gaussian) instead of Otsu for better screenshot handling
- Add grid cleanup: remove empty rows and columns
- Increase padding from 2px to 3px, CLAHE clipLimit from 1.5 to 2.0
- Better reading order: sort by y then x coordinates

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

backend/ocr/table.py

@@ -1,4 +1,4 @@
-"""Table extraction using Microsoft Table Transformer."""
+"""Table extraction using Microsoft Table Transformer + EasyOCR."""
 import numpy as np
 import cv2
 import torch
@@ -9,7 +9,7 @@ from backend.models.schemas import TableRegion
 
 
 class TableTransformerEngine:
-    """Extract tables from document images using Table Transformer."""
+    """Extract tables from document images using Table Transformer + EasyOCR."""
 
     MODEL_NAME = "microsoft/table-transformer-structure-recognition"
 
@@ -20,6 +20,13 @@ class TableTransformerEngine:
             self.MODEL_NAME
         ).to(self.device)
         self.model.eval()
+        self._easyocr = None
+
+    def _get_easyocr(self):
+        if self._easyocr is None:
+            import easyocr
+            self._easyocr = easyocr.Reader(['ru', 'en'], gpu=False, verbose=False)
+        return self._easyocr
 
     def detect_tables(self, image: Image.Image) -> list[dict]:
         """Detect table regions in image."""
@@ -58,14 +65,49 @@ class TableTransformerEngine:
     ) -> list[list[str]]:
         """Extract cell data from a cropped table region.
 
-        Table Transformer returns column and row bounding boxes.
-        We compute cell positions as intersections of columns x rows.
+        Uses Table Transformer for structure detection and EasyOCR for text.
+        Falls back to line-based detection if model misses rows/columns.
         """
-        from backend.ocr.tesseract import TesseractEngine
-
         x, y, w, h = table_bbox
         cropped = image.crop((x, y, x + w, y + h))
 
+        # Try model-based detection first
+        columns, rows = self._detect_structure(cropped)
+
+        if not columns or not rows:
+            # Fallback: detect lines using OpenCV
+            columns, rows = self._detect_lines(cropped)
+
+        if not columns or not rows:
+            # Final fallback: horizontal projection
+            return self._fallback_extract(cropped)
+
+        # Sort and deduplicate
+        columns.sort(key=lambda b: b[0])
+        rows.sort(key=lambda b: b[1])
+        columns = self._merge_overlapping(columns, axis=0)
+        rows = self._merge_overlapping(rows, axis=1)
+
+        # Extract text from each cell
+        easyocr = self._get_easyocr()
+        grid = []
+        for row_box in rows:
+            ry1, ry2 = int(row_box[1]), int(row_box[3])
+            row_texts = []
+            for col_box in columns:
+                cx1, cx2 = int(col_box[0]), int(col_box[2])
+                cell_img = cropped.crop((cx1, ry1, cx2, ry2))
+                text = self._extract_cell_text(cell_img, easyocr)
+                row_texts.append(text)
+            grid.append(row_texts)
+
+        # Post-process: remove empty rows/columns
+        grid = self._clean_grid(grid)
+
+        return grid
+
+    def _detect_structure(self, cropped: Image.Image):
+        """Detect rows and columns using Table Transformer."""
         inputs = self.processor(images=cropped, return_tensors="pt")
         inputs = {k: v.to(self.device) for k, v in inputs.items()}
 
@@ -91,41 +133,87 @@ class TableTransformerEngine:
             elif label.item() == 2:  # row
                 rows.append(box.tolist())
 
-        if not columns or not rows:
-            return self._fallback_extract(cropped)
+        return columns, rows
 
-        # Sort columns left-to-right, rows top-to-bottom
-        columns.sort(key=lambda b: b[0])
-        rows.sort(key=lambda b: b[1])
+    def _detect_lines(self, cropped: Image.Image):
+        """Fallback: detect table structure using OpenCV line detection."""
+        arr = np.array(cropped)
+        if len(arr.shape) == 3:
+            gray = cv2.cvtColor(arr, cv2.COLOR_RGB2GRAY)
+        else:
+            gray = arr
 
-        # Deduplicate overlapping columns/rows
-        columns = self._merge_overlapping(columns, axis=0)
-        rows = self._merge_overlapping(rows, axis=1)
+        # Adaptive threshold for better line detection
+        binary = cv2.adaptiveThreshold(
+            gray, 255, cv2.ADAPTIVE_THRESH_GAUSSIAN_C,
+            cv2.THRESH_BINARY_INV, 11, 2
+        )
 
-        tesseract = TesseractEngine()
-        grid = []
-        for row_box in rows:
-            ry1, ry2 = int(row_box[1]), int(row_box[3])
-            row_texts = []
-            for col_box in columns:
-                cx1, cx2 = int(col_box[0]), int(col_box[2])
-                cell_img = cropped.crop((cx1, ry1, cx2, ry2))
-                text = self._extract_cell_text(cell_img, tesseract)
-                row_texts.append(text)
-            grid.append(row_texts)
+        h, w = binary.shape
 
-        return grid
+        # Detect horizontal lines
+        horizontal_kernel = cv2.getStructuringElement(cv2.MORPH_RECT, (40, 1))
+        horizontal = cv2.morphologyEx(binary, cv2.MORPH_OPEN, horizontal_kernel, iterations=2)
 
-    def _extract_cell_text(
-        self,
-        cell_img: Image.Image,
-        tesseract,
-    ) -> str:
-        """Extract text from a single table cell with preprocessing."""
+        # Detect vertical lines
+        vertical_kernel = cv2.getStructuringElement(cv2.MORPH_RECT, (1, 40))
+        vertical = cv2.morphologyEx(binary, cv2.MORPH_OPEN, vertical_kernel, iterations=2)
+
+        columns = []
+        rows = []
+
+        # Extract horizontal line positions as row boundaries
+        h_coords = np.where(np.sum(horizontal, axis=1) > w * 0.1)[0]
+        if len(h_coords) > 0:
+            # Cluster nearby horizontal lines
+            row_bounds = [int(h_coords[0])]
+            for i in range(1, len(h_coords)):
+                if h_coords[i] - h_coords[i - 1] > 10:
+                    row_bounds.append(int(h_coords[i]))
+            # Create row boxes between consecutive lines
+            for i in range(len(row_bounds) - 1):
+                y1, y2 = row_bounds[i], row_bounds[i + 1]
+                if y2 - y1 > 5:
+                    rows.append([0, y1, w, y2])
+
+        # Extract vertical line positions as column boundaries
+        v_coords = np.where(np.sum(vertical, axis=0) > h * 0.1)[0]
+        if len(v_coords) > 0:
+            col_bounds = [int(v_coords[0])]
+            for i in range(1, len(v_coords)):
+                if v_coords[i] - v_coords[i - 1] > 10:
+                    col_bounds.append(int(v_coords[i]))
+            for i in range(len(col_bounds) - 1):
+                x1, x2 = col_bounds[i], col_bounds[i + 1]
+                if x2 - x1 > 5:
+                    columns.append([x1, 0, x2, h])
+
+        return columns, rows
+
+    def _extract_cell_text(self, cell_img: Image.Image, easyocr) -> str:
+        """Extract text from a single table cell using EasyOCR."""
         processed = self._preprocess_cell_image(cell_img)
-        # PSM 6 = uniform block of text (best for table cells)
-        text, _ = tesseract.extract_text_psm(processed, psm=6)
-        return text.strip()
+        arr = np.array(processed)
+
+        # CLAHE for contrast enhancement
+        if len(arr.shape) == 3:
+            gray = cv2.cvtColor(arr, cv2.COLOR_RGB2GRAY)
+        else:
+            gray = arr
+        clahe = cv2.createCLAHE(clipLimit=2.0, tileGridSize=(8, 8))
+        enhanced = clahe.apply(gray)
+
+        # EasyOCR with detail=1 to get bounding boxes
+        result = easyocr.readtext(enhanced, detail=1, paragraph=False)
+
+        if not result:
+            return ""
+
+        # Sort by y-coordinate then x-coordinate for proper reading order
+        result.sort(key=lambda r: (r[0][0][1] // 10 * 10, r[0][0][0]))
+
+        texts = [r[1] for r in result]
+        return " ".join(texts).strip()
 
     def _preprocess_cell_image(self, image: Image.Image) -> Image.Image:
         """Preprocess a cell image for better OCR."""
@@ -135,18 +223,19 @@ class TableTransformerEngine:
         else:
             gray = arr
 
-        # Add 2px padding to avoid cutting text at borders
-        gray = cv2.copyMakeBorder(gray, 2, 2, 2, 2, cv2.BORDER_CONSTANT, value=255)
+        # Add padding to avoid cutting text at borders
+        gray = cv2.copyMakeBorder(gray, 3, 3, 3, 3, cv2.BORDER_CONSTANT, value=255)
 
-        # Otsu binarization
-        _, binary = cv2.threshold(
-            gray, 0, 255, cv2.THRESH_BINARY + cv2.THRESH_OTSU
+        # Adaptive threshold — works better than Otsu for screenshots
+        binary = cv2.adaptiveThreshold(
+            gray, 255, cv2.ADAPTIVE_THRESH_GAUSSIAN_C,
+            cv2.THRESH_BINARY, 11, 2
         )
 
         # Upscale if cell is too small
         h, w = binary.shape
-        if h < 30 or w < 30:
-            scale = max(30 / h, 30 / w, 2.0)
+        if h < 25 or w < 25:
+            scale = max(25 / h, 25 / w, 2.0)
             binary = cv2.resize(
                 binary,
                 (int(w * scale), int(h * scale)),
@@ -187,28 +276,28 @@ class TableTransformerEngine:
 
         return merged
 
-    def _cluster_cells_into_rows(
-        self,
-        cells: list[list[float]],
-        threshold: float,
-    ) -> list[list[list[float]]]:
-        """Cluster cell boxes into rows based on Y coordinate."""
-        rows = []
-        current_row = []
-        last_y = None
+    def _clean_grid(self, grid: list[list[str]]) -> list[list[str]]:
+        """Remove empty rows and columns from the grid."""
+        if not grid:
+            return grid
 
-        for cell in sorted(cells, key=lambda c: c[1]):
-            if last_y is None or abs(cell[1] - last_y) < threshold:
-                current_row.append(cell)
-            else:
-                rows.append(sorted(current_row, key=lambda c: c[0]))
-                current_row = [cell]
-            last_y = cell[1]
+        # Remove completely empty rows
+        grid = [row for row in grid if any(cell.strip() for cell in row)]
 
-        if current_row:
-            rows.append(sorted(current_row, key=lambda c: c[0]))
+        if not grid:
+            return grid
 
-        return rows
+        # Remove completely empty columns
+        n_cols = max(len(row) for row in grid)
+        non_empty_cols = []
+        for c in range(n_cols):
+            if any(row[c].strip() if c < len(row) else "" for row in grid):
+                non_empty_cols.append(c)
+
+        if non_empty_cols:
+            grid = [[row[c] if c < len(row) else "" for c in non_empty_cols] for row in grid]
+
+        return grid
 
     def _fallback_extract(self, image: Image.Image) -> list[list[str]]:
         """Fallback: split image by horizontal projection."""
@@ -218,8 +307,8 @@ class TableTransformerEngine:
         white_rows = np.where(row_projection > threshold)[0]
 
         if len(white_rows) < 2:
-            from backend.ocr.tesseract import TesseractEngine
-            text, _ = TesseractEngine().extract_text(image)
+            easyocr = self._get_easyocr()
+            text = self._extract_cell_text(image, easyocr)
             return [[text]]
 
         row_bands = []
@@ -230,13 +319,11 @@ class TableTransformerEngine:
                 start = white_rows[i]
         row_bands.append((start, white_rows[-1]))
 
-        from backend.ocr.tesseract import TesseractEngine
-        tesseract = TesseractEngine()
+        easyocr = self._get_easyocr()
         grid = []
-
         for y1, y2 in row_bands:
             row_img = image.crop((0, int(y1), image.width, int(y2)))
-            text, _ = tesseract.extract_text(row_img)
+            text = self._extract_cell_text(row_img, easyocr)
             cols = text.split()
             grid.append(cols)