Complete Surya OCR Studio implementation with all features

Features:
- OCR: Text recognition in 90+ languages with RecognitionPredictor
- Text Detection: Line-level detection with DetectionPredictor
- Layout Analysis: Identify document structure with LayoutPredictor
- Table Recognition: Extract tables to Markdown with TableRecPredictor
- LaTeX OCR: Convert equations to LaTeX with TexifyPredictor

Technical:
- Uses new Surya API (FoundationPredictor pattern)
- ZeroGPU support with @spaces.GPU decorators
- Lazy model loading for faster startup
- Modern dark UI with gradient theme
- Comprehensive error handling
- Performance optimizations for batch sizes

README.md

@@ -1,12 +1,58 @@
 ---
-title: Surya OCR
-emoji: 👀
-colorFrom: purple
-colorTo: green
+title: Surya OCR Studio
+emoji: 📄
+colorFrom: green
+colorTo: blue
 sdk: gradio
-sdk_version: 4.41.0
+sdk_version: 5.0.0
 app_file: app.py
 pinned: false
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# Surya OCR Studio
+
+Complete document OCR toolkit supporting 90+ languages with ZeroGPU.
+
+## Features
+
+| Feature | Description |
+|---------|-------------|
+| **OCR** | Text recognition in 90+ languages |
+| **Text Detection** | Line-level text detection |
+| **Layout Analysis** | Identify tables, figures, headers, captions, etc. |
+| **Table Recognition** | Extract table structure to Markdown |
+| **LaTeX OCR** | Convert equation images to LaTeX |
+
+## Usage
+
+### OCR
+1. Upload an image (JPG, PNG, etc.)
+2. Specify language codes (e.g., "en" or "en, pt, es")
+3. Click "Run OCR"
+
+### Table Recognition
+1. Upload an image of a table
+2. Click "Recognize Table"
+3. Get Markdown output
+
+### LaTeX OCR
+1. Upload a cropped equation image
+2. Click "Extract LaTeX"
+3. Copy the LaTeX code
+
+## Supported Languages
+
+English (en), Portuguese (pt), Spanish (es), French (fr), German (de), Italian (it), Dutch (nl), Russian (ru), Chinese (zh), Japanese (ja), Korean (ko), Arabic (ar), Hindi (hi), and 80+ more.
+
+## Model
+
+- [Surya OCR](https://github.com/datalab-to/surya) by datalab-to
+
+## License
+
+- Code: GPL-3.0
+- Model weights: Modified AI Pubs Open Rail-M license (free for research, personal use, and startups under $2M funding/revenue)
+
+## Space by
+
+[@artificialguybr](https://twitter.com/artificialguybr)

app.py

@@ -1,249 +1,622 @@
+"""
+Surya OCR Studio - Complete Implementation
+Features: OCR, Text Detection, Layout Analysis, Table Recognition, LaTeX OCR
+"""
+
 import gradio as gr
+import spaces
 import logging
 import os
 import json
-from PIL import Image, ImageDraw
+from PIL import Image, ImageDraw, ImageFont
+from typing import List, Optional
 import torch
-from surya.ocr import run_ocr
-from surya.detection import batch_text_detection
-from surya.layout import batch_layout_detection
-from surya.ordering import batch_ordering
-from surya.model.detection.model import load_model as load_det_model, load_processor as load_det_processor
-from surya.model.recognition.model import load_model as load_rec_model
-from surya.model.recognition.processor import load_processor as load_rec_processor
+
+# Configure logging
+logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
+logger = logging.getLogger(__name__)
+
+# Performance optimizations for ZeroGPU
+os.environ["RECOGNITION_BATCH_SIZE"] = "64"
+os.environ["DETECTOR_BATCH_SIZE"] = "8"
+os.environ["LAYOUT_BATCH_SIZE"] = "8"
+os.environ["TABLE_REC_BATCH_SIZE"] = "16"
+
+# Surya imports
+from surya.foundation import FoundationPredictor
+from surya.recognition import RecognitionPredictor
+from surya.detection import DetectionPredictor
+from surya.layout import LayoutPredictor
+from surya.table_rec import TableRecPredictor
+from surya.texify import TexifyPredictor
 from surya.settings import settings
-from surya.model.ordering.processor import load_processor as load_order_processor
-from surya.model.ordering.model import load_model as load_order_model
 
-# Configuração do TorchDynamo
-torch._dynamo.config.capture_scalar_outputs = True
+logger.info("Loading Surya models...")
 
-# Configuração de logging
-logging.basicConfig(level=logging.DEBUG, format='%(asctime)s - %(levelname)s - %(message)s')
-logger = logging.getLogger(__name__)
+# Initialize predictors (lazy loading for faster startup)
+_foundation_predictor = None
+_detection_predictor = None
+_recognition_predictor = None
+_layout_predictor = None
+_table_rec_predictor = None
+_texify_predictor = None
+
+def get_foundation_predictor():
+    global _foundation_predictor
+    if _foundation_predictor is None:
+        _foundation_predictor = FoundationPredictor()
+    return _foundation_predictor
+
+def get_detection_predictor():
+    global _detection_predictor
+    if _detection_predictor is None:
+        _detection_predictor = DetectionPredictor()
+    return _detection_predictor
+
+def get_recognition_predictor():
+    global _recognition_predictor
+    if _recognition_predictor is None:
+        _recognition_predictor = RecognitionPredictor(get_foundation_predictor())
+    return _recognition_predictor
+
+def get_layout_predictor():
+    global _layout_predictor
+    if _layout_predictor is None:
+        _layout_predictor = LayoutPredictor(
+            FoundationPredictor(checkpoint=settings.LAYOUT_MODEL_CHECKPOINT)
+        )
+    return _layout_predictor
+
+def get_table_rec_predictor():
+    global _table_rec_predictor
+    if _table_rec_predictor is None:
+        _table_rec_predictor = TableRecPredictor()
+    return _table_rec_predictor
+
+def get_texify_predictor():
+    global _texify_predictor
+    if _texify_predictor is None:
+        _texify_predictor = TexifyPredictor()
+    return _texify_predictor
+
+logger.info("Models will be loaded on first use.")
+
+# Layout labels and colors
+LAYOUT_LABELS = {
+    'Text': '#10B981',        # Green
+    'Title': '#EF4444',       # Red
+    'Section-header': '#F59E0B',  # Amber
+    'Table': '#3B82F6',       # Blue
+    'Figure': '#8B5CF6',      # Purple
+    'Picture': '#8B5CF6',     # Purple
+    'Caption': '#EC4899',     # Pink
+    'Page-header': '#6366F1', # Indigo
+    'Page-footer': '#6366F1', # Indigo
+    'Footnote': '#84CC16',    # Lime
+    'Formula': '#F97316',     # Orange
+    'List-item': '#14B8A6',   # Teal
+    'Form': '#A855F7',        # Fuchsia
+    'Handwriting': '#64748B', # Slate
+    'Table-of-contents': '#0EA5E9',  # Sky
+}
 
-# Configuração de variáveis de ambiente
-logger.info("Configurando variáveis de ambiente para otimização de performance")
-os.environ["RECOGNITION_BATCH_SIZE"] = "512"
-os.environ["DETECTOR_BATCH_SIZE"] = "36"
-os.environ["ORDER_BATCH_SIZE"] = "32"
-os.environ["RECOGNITION_STATIC_CACHE"] = "true"
-
-# Carregamento de modelos
-logger.info("Iniciando carregamento dos modelos...")
-
-try:
-    logger.debug("Carregando modelo e processador de detecção...")
-    det_processor, det_model = load_det_processor(), load_det_model()
-    logger.debug("Modelo e processador de detecção carregados com sucesso")
-except Exception as e:
-    logger.error(f"Erro ao carregar modelo de detecção: {e}")
-    raise
-
-try:
-    logger.debug("Carregando modelo e processador de reconhecimento...")
-    rec_model, rec_processor = load_rec_model(), load_rec_processor()
-    logger.debug("Modelo e processador de reconhecimento carregados com sucesso")
-except Exception as e:
-    logger.error(f"Erro ao carregar modelo de reconhecimento: {e}")
-    raise
-
-try:
-    logger.debug("Carregando modelo e processador de layout...")
-    layout_model = load_det_model(checkpoint=settings.LAYOUT_MODEL_CHECKPOINT)
-    layout_processor = load_det_processor(checkpoint=settings.LAYOUT_MODEL_CHECKPOINT)
-    logger.debug("Modelo e processador de layout carregados com sucesso")
-except Exception as e:
-    logger.error(f"Erro ao carregar modelo de layout: {e}")
-    raise
-
-try:
-    logger.debug("Carregando modelo e processador de ordenação...")
-    order_model = load_order_model()
-    order_processor = load_order_processor()
-    logger.debug("Modelo e processador de ordenação carregados com sucesso")
-except Exception as e:
-    logger.error(f"Erro ao carregar modelo de ordenação: {e}")
-    raise
-
-logger.info("Todos os modelos foram carregados com sucesso")
-
-# Compilação do modelo de reconhecimento
-logger.info("Iniciando compilação do modelo de reconhecimento...")
-try:
-    rec_model.decoder.model = torch.compile(rec_model.decoder.model)
-    logger.info("Compilação do modelo de reconhecimento concluída com sucesso")
-except Exception as e:
-    logger.error(f"Erro durante a compilação do modelo de reconhecimento: {e}")
-    logger.warning("Continuando sem compilação do modelo")
-
-class CustomJSONEncoder(json.JSONEncoder):
-    def default(self, obj):
-        if isinstance(obj, Image.Image):
-            return "Image object (not serializable)"
-        if hasattr(obj, '__dict__'):
-            return {k: self.default(v) for k, v in obj.__dict__.items()}
-        return str(obj)
-
-def serialize_result(result):
-    return json.dumps(result, cls=CustomJSONEncoder, indent=2)
-
-def draw_boxes(image, predictions, color=(255, 0, 0)):
+# Supported languages
+LANGUAGES = {
+    "en": "English", "pt": "Portuguese", "es": "Spanish", "fr": "French",
+    "de": "German", "it": "Italian", "nl": "Dutch", "ru": "Russian",
+    "zh": "Chinese", "ja": "Japanese", "ko": "Korean", "ar": "Arabic",
+    "hi": "Hindi", "bn": "Bengali", "tr": "Turkish", "vi": "Vietnamese",
+    "th": "Thai", "id": "Indonesian", "pl": "Polish", "uk": "Ukrainian",
+    "cs": "Czech", "sv": "Swedish", "da": "Danish", "no": "Norwegian",
+    "fi": "Finnish", "el": "Greek", "he": "Hebrew", "hu": "Hungarian",
+    "ro": "Romanian", "sk": "Slovak", "bg": "Bulgarian", "hr": "Croatian",
+    "sl": "Slovenian", "et": "Estonian", "lv": "Latvian", "lt": "Lithuanian",
+    "fa": "Persian", "ur": "Urdu", "ta": "Tamil", "te": "Telugu",
+    "ml": "Malayalam", "kn": "Kannada", "gu": "Gujarati", "mr": "Marathi",
+    "pa": "Punjabi", "ne": "Nepali", "si": "Sinhala", "my": "Burmese",
+    "km": "Khmer", "lo": "Lao", "ka": "Georgian", "hy": "Armenian",
+}
+
+
+def prepare_image(image) -> Image.Image:
+    """Prepare image for processing"""
+    if isinstance(image, str):
+        image = Image.open(image)
+    elif hasattr(image, 'name'):
+        image = Image.open(image.name)
+    
+    if image.mode != 'RGB':
+        image = image.convert('RGB')
+    return image
+
+
+def draw_text_lines(image, text_lines, color=(0, 255, 0)):
+    """Draw text line bounding boxes"""
     draw = ImageDraw.Draw(image)
-    if isinstance(predictions, list):
-        for pred in predictions:
-            if hasattr(pred, 'bboxes'):
-                for bbox in pred.bboxes:
-                    draw.rectangle(bbox, outline=color, width=2)
-            elif hasattr(pred, 'bbox'):
-                draw.rectangle(pred.bbox, outline=color, width=2)
-            elif hasattr(pred, 'polygon'):
-                draw.polygon(pred.polygon, outline=color, width=2)
-    elif hasattr(predictions, 'bboxes'):
-        for bbox in predictions.bboxes:
-            draw.rectangle(bbox, outline=color, width=2)
+    for line in text_lines:
+        if hasattr(line, 'bbox'):
+            bbox = line.bbox
+            if len(bbox) == 4:
+                draw.rectangle(bbox, outline=color, width=2)
     return image
 
-def ocr_workflow(image, langs):
-    logger.info(f"Iniciando workflow OCR com idiomas: {langs}")
+
+def draw_layout_boxes(image, bboxes):
+    """Draw layout boxes with labels and colors"""
+    draw = ImageDraw.Draw(image)
+    
+    for bbox in bboxes:
+        label = getattr(bbox, 'label', 'Text')
+        color = LAYOUT_LABELS.get(label, '#FFFFFF')
+        
+        # Convert hex to RGB
+        rgb = tuple(int(color.lstrip('#')[i:i+2], 16) for i in (0, 2, 4))
+        
+        box = bbox.bbox if hasattr(bbox, 'bbox') else bbox
+        if len(box) == 4:
+            draw.rectangle(box, outline=rgb, width=2)
+            
+            # Draw label
+            label_text = label.replace('-', ' ').title()
+            draw.text((box[0], box[1] - 12), label_text, fill=rgb)
+    
+    return image
+
+
+def draw_table_cells(image, predictions):
+    """Draw table cells with row/column info"""
+    draw = ImageDraw.Draw(image)
+    
+    # Draw rows in blue
+    for row in predictions.rows:
+        draw.rectangle(row.bbox, outline=(0, 0, 255), width=2)
+    
+    # Draw columns in green
+    for col in predictions.cols:
+        draw.rectangle(col.bbox, outline=(0, 255, 0), width=2)
+    
+    # Draw cells in red
+    for cell in predictions.cells:
+        draw.rectangle(cell.bbox, outline=(255, 0, 0), width=1)
+        # Draw cell text if available
+        if hasattr(cell, 'text') and cell.text:
+            draw.text((cell.bbox[0], cell.bbox[1]), cell.text[:10], fill=(100, 100, 100))
+    
+    return image
+
+
+@spaces.GPU(duration=120)
+def process_ocr(image, languages: str, disable_math: bool = False):
+    """Run OCR on image"""
+    logger.info(f"Running OCR with languages: {languages}")
     try:
-        image = Image.open(image.name)
-        logger.debug(f"Imagem carregada: {image.size}")
-        predictions = run_ocr([image], [langs.split(',')], det_model, det_processor, rec_model, rec_processor)
+        image = prepare_image(image)
+        
+        # Parse languages
+        langs = [l.strip() for l in languages.split(',') if l.strip()]
+        if not langs:
+            langs = ['en']
+        
+        # Get predictors
+        det_pred = get_detection_predictor()
+        rec_pred = get_recognition_predictor()
+        
+        # Run OCR
+        predictions = rec_pred(
+            [image], 
+            det_predictor=det_pred, 
+            langs=[langs],
+            disable_math=disable_math
+        )
         
-        # Draw bounding boxes on the image
-        image_with_boxes = draw_boxes(image.copy(), predictions[0].text_lines)
+        if not predictions or len(predictions) == 0:
+            return "", {}, None
         
-        # Format the OCR results
-        formatted_text = "\n".join([line.text for line in predictions[0].text_lines])
+        pred = predictions[0]
+        
+        # Extract text
+        text_lines = pred.text_lines if hasattr(pred, 'text_lines') else []
+        full_text = "\n".join([line.text for line in text_lines if hasattr(line, 'text')])
+        
+        # Build JSON result
+        result = {
+            "text": full_text,
+            "languages": langs,
+            "num_lines": len(text_lines),
+            "lines": [
+                {
+                    "text": line.text,
+                    "confidence": round(line.confidence, 3) if hasattr(line, 'confidence') else 1.0,
+                    "bbox": list(line.bbox) if hasattr(line, 'bbox') else []
+                }
+                for line in text_lines
+            ]
+        }
+        
+        # Draw bounding boxes
+        img_with_boxes = draw_text_lines(image.copy(), text_lines)
+        
+        return full_text, result, img_with_boxes
         
-        logger.info("Workflow OCR concluído com sucesso")
-        return serialize_result(predictions), image_with_boxes, formatted_text
     except Exception as e:
-        logger.error(f"Erro durante o workflow OCR: {e}")
-        return serialize_result({"error": str(e)}), None, ""
+        logger.error(f"OCR Error: {e}", exc_info=True)
+        return f"Error: {str(e)}", {"error": str(e)}, None
 
-def text_detection_workflow(image):
-    logger.info("Iniciando workflow de detecção de texto")
+
+@spaces.GPU(duration=60)
+def process_detection(image):
+    """Run text detection on image"""
+    logger.info("Running text detection")
     try:
-        image = Image.open(image.name)
-        logger.debug(f"Imagem carregada: {image.size}")
-        predictions = batch_text_detection([image], det_model, det_processor)
-        
-        # Draw bounding boxes on the image
-        image_with_boxes = draw_boxes(image.copy(), predictions)
-        
-        # Convert predictions to a serializable format
-        serializable_predictions = []
-        for pred in predictions:
-            serializable_pred = {
-                'bboxes': [bbox.tolist() if hasattr(bbox, 'tolist') else bbox for bbox in pred.bboxes],
-                'polygons': [poly.tolist() if hasattr(poly, 'tolist') else poly for poly in pred.polygons],
-                'confidences': pred.confidences,
-                'vertical_lines': [line.tolist() if hasattr(line, 'tolist') else line for line in pred.vertical_lines],
-                'image_bbox': pred.image_bbox.tolist() if hasattr(pred.image_bbox, 'tolist') else pred.image_bbox
-            }
-            serializable_predictions.append(serializable_pred)
-        
-        logger.info("Workflow de detecção de texto concluído com sucesso")
-        return serialize_result(serializable_predictions), image_with_boxes
+        image = prepare_image(image)
+        
+        det_pred = get_detection_predictor()
+        predictions = det_pred([image])
+        
+        if not predictions or len(predictions) == 0:
+            return {}, None
+        
+        pred = predictions[0]
+        
+        # Build result
+        result = {
+            "num_lines": len(pred.bboxes) if hasattr(pred, 'bboxes') else 0,
+            "image_size": list(image.size),
+            "bboxes": [
+                {
+                    "bbox": list(bbox.bbox) if hasattr(bbox, 'bbox') else list(bbox),
+                    "confidence": round(bbox.confidence, 3) if hasattr(bbox, 'confidence') else 1.0
+                }
+                for bbox in (pred.bboxes if hasattr(pred, 'bboxes') else [])
+            ]
+        }
+        
+        # Draw boxes
+        img_with_boxes = image.copy()
+        draw = ImageDraw.Draw(img_with_boxes)
+        for bbox in (pred.bboxes if hasattr(pred, 'bboxes') else []):
+            box = bbox.bbox if hasattr(bbox, 'bbox') else bbox
+            draw.rectangle(box, outline=(0, 255, 0), width=2)
+        
+        return result, img_with_boxes
+        
     except Exception as e:
-        logger.error(f"Erro durante o workflow de detecção de texto: {e}")
-        return serialize_result({"error": str(e)}), None
+        logger.error(f"Detection Error: {e}", exc_info=True)
+        return {"error": str(e)}, None
 
-def layout_analysis_workflow(image):
-    logger.info("Iniciando workflow de análise de layout")
+
+@spaces.GPU(duration=60)
+def process_layout(image):
+    """Run layout analysis on image"""
+    logger.info("Running layout analysis")
     try:
-        image = Image.open(image.name)
-        logger.debug(f"Imagem carregada: {image.size}")
-        line_predictions = batch_text_detection([image], det_model, det_processor)
-        logger.debug(f"Detecção de linhas concluída. Número de linhas detectadas: {len(line_predictions[0].bboxes)}")
-        layout_predictions = batch_layout_detection([image], layout_model, layout_processor, line_predictions)
-        
-        # Draw bounding boxes on the image
-        image_with_boxes = draw_boxes(image.copy(), layout_predictions[0], color=(0, 255, 0))
-        
-        # Convert predictions to a serializable format
-        serializable_predictions = []
-        for pred in layout_predictions:
-            serializable_pred = {
-                'bboxes': [
-                    {
-                        'bbox': bbox.bbox.tolist() if hasattr(bbox.bbox, 'tolist') else bbox.bbox,
-                        'polygon': bbox.polygon.tolist() if hasattr(bbox.polygon, 'tolist') else bbox.polygon,
-                        'confidence': bbox.confidence,
-                        'label': bbox.label
-                    } for bbox in pred.bboxes
-                ],
-                'image_bbox': pred.image_bbox.tolist() if hasattr(pred.image_bbox, 'tolist') else pred.image_bbox
-            }
-            serializable_predictions.append(serializable_pred)
-        
-        logger.info("Workflow de análise de layout concluído com sucesso")
-        return serialize_result(serializable_predictions), image_with_boxes
+        image = prepare_image(image)
+        
+        layout_pred = get_layout_predictor()
+        predictions = layout_pred([image])
+        
+        if not predictions or len(predictions) == 0:
+            return {}, None
+        
+        pred = predictions[0]
+        
+        # Count by label
+        label_counts = {}
+        for bbox in (pred.bboxes if hasattr(pred, 'bboxes') else []):
+            label = getattr(bbox, 'label', 'Unknown')
+            label_counts[label] = label_counts.get(label, 0) + 1
+        
+        # Build result
+        result = {
+            "num_elements": len(pred.bboxes) if hasattr(pred, 'bboxes') else 0,
+            "label_counts": label_counts,
+            "elements": [
+                {
+                    "label": getattr(bbox, 'label', 'Unknown'),
+                    "confidence": round(getattr(bbox, 'confidence', 1.0), 3),
+                    "position": getattr(bbox, 'position', -1),
+                    "bbox": list(bbox.bbox) if hasattr(bbox, 'bbox') else []
+                }
+                for bbox in (pred.bboxes if hasattr(pred, 'bboxes') else [])
+            ]
+        }
+        
+        # Draw layout boxes
+        img_with_boxes = draw_layout_boxes(image.copy(), pred.bboxes if hasattr(pred, 'bboxes') else [])
+        
+        return result, img_with_boxes
+        
     except Exception as e:
-        logger.error(f"Erro durante o workflow de análise de layout: {e}")
-        return serialize_result({"error": str(e)}), None
+        logger.error(f"Layout Error: {e}", exc_info=True)
+        return {"error": str(e)}, None
+
 
-def reading_order_workflow(image):
-    logger.info("Iniciando workflow de ordem de leitura")
+@spaces.GPU(duration=90)
+def process_table(image):
+    """Run table recognition on image"""
+    logger.info("Running table recognition")
     try:
-        image = Image.open(image.name)
-        logger.debug(f"Imagem carregada: {image.size}")
-        line_predictions = batch_text_detection([image], det_model, det_processor)
-        logger.debug(f"Detecção de linhas concluída. Número de linhas detectadas: {len(line_predictions[0].bboxes)}")
-        layout_predictions = batch_layout_detection([image], layout_model, layout_processor, line_predictions)
-        logger.debug(f"Análise de layout concluída. Número de elementos de layout: {len(layout_predictions[0].bboxes)}")
-        bboxes = [pred.bbox for pred in layout_predictions[0].bboxes]
-        order_predictions = batch_ordering([image], [bboxes], order_model, order_processor)
-        
-        # Draw bounding boxes on the image
-        image_with_boxes = image.copy()
-        draw = ImageDraw.Draw(image_with_boxes)
-        for i, bbox in enumerate(order_predictions[0].bboxes):
-            draw.rectangle(bbox.bbox, outline=(0, 0, 255), width=2)
-            draw.text((bbox.bbox[0], bbox.bbox[1]), str(bbox.position), fill=(255, 0, 0))
-        
-        logger.info("Workflow de ordem de leitura concluído com sucesso")
-        return serialize_result(order_predictions), image_with_boxes
+        image = prepare_image(image)
+        
+        table_pred = get_table_rec_predictor()
+        predictions = table_pred([image])
+        
+        if not predictions or len(predictions) == 0:
+            return {}, None, ""
+        
+        pred = predictions[0]
+        
+        # Build markdown table
+        md_table = ""
+        if hasattr(pred, 'cells') and pred.cells:
+            # Find max row and col
+            max_row = max(c.row_id for c in pred.cells) if pred.cells else 0
+            max_col = max(c.col_id for c in pred.cells) if pred.cells else 0
+            
+            # Create table data
+            table_data = [["" for _ in range(max_col + 1)] for _ in range(max_row + 1)]
+            
+            for cell in pred.cells:
+                text = getattr(cell, 'text', '')
+                table_data[cell.row_id][cell.col_id] = text
+            
+            # Build markdown
+            md_lines = []
+            for i, row in enumerate(table_data):
+                md_lines.append("| " + " | ".join(row) + " |")
+                if i == 0:
+                    md_lines.append("| " + " | ".join(["---"] * len(row)) + " |")
+            
+            md_table = "\n".join(md_lines)
+        
+        # Build result
+        result = {
+            "num_rows": len(pred.rows) if hasattr(pred, 'rows') else 0,
+            "num_cols": len(pred.cols) if hasattr(pred, 'cols') else 0,
+            "num_cells": len(pred.cells) if hasattr(pred, 'cells') else 0,
+            "rows": [
+                {"row_id": r.row_id, "is_header": getattr(r, 'is_header', False)}
+                for r in (pred.rows if hasattr(pred, 'rows') else [])
+            ],
+            "cols": [
+                {"col_id": c.col_id, "is_header": getattr(c, 'is_header', False)}
+                for c in (pred.cols if hasattr(pred, 'cols') else [])
+            ]
+        }
+        
+        # Draw table cells
+        img_with_boxes = draw_table_cells(image.copy(), pred)
+        
+        return result, img_with_boxes, md_table
+        
+    except Exception as e:
+        logger.error(f"Table Recognition Error: {e}", exc_info=True)
+        return {"error": str(e)}, None, ""
+
+
+@spaces.GPU(duration=60)
+def process_latex(image):
+    """Run LaTeX OCR on image (equation)"""
+    logger.info("Running LaTeX OCR")
+    try:
+        image = prepare_image(image)
+        
+        texify_pred = get_texify_predictor()
+        predictions = texify_pred([image])
+        
+        if not predictions or len(predictions) == 0:
+            return "", {}
+        
+        pred = predictions[0]
+        latex = pred.text if hasattr(pred, 'text') else str(pred)
+        
+        result = {
+            "latex": latex,
+            "markdown": f"$$\n{latex}\n$$"
+        }
+        
+        return latex, result
+        
     except Exception as e:
-        logger.error(f"Erro durante o workflow de ordem de leitura: {e}")
-        return serialize_result({"error": str(e)}), None
+        logger.error(f"LaTeX OCR Error: {e}", exc_info=True)
+        return f"Error: {str(e)}", {"error": str(e)}
+
+
+# ============== GRADIO UI ==============
+
+CSS = """
+@import url('https://fonts.googleapis.com/css2?family=Outfit:wght@300;400;500;600;700;800&family=Fira+Code:wght@400;500&display=swap');
+
+:root {
+    --bg: #0a0f1a;
+    --surf: #0f1629;
+    --card: #151d32;
+    --border: #1e2a45;
+    --border2: #2a3a5a;
+    --green: #10b981;
+    --blue: #3b82f6;
+    --text: #e2e8f0;
+    --muted: #64748b;
+}
+
+body, .gradio-container {
+    background: var(--bg) !important;
+    font-family: 'Outfit', sans-serif !important;
+    color: var(--text) !important;
+}
+
+.gradio-container::before {
+    content: '';
+    position: fixed; inset: 0; pointer-events: none; z-index: 0;
+    background: radial-gradient(ellipse 70% 50% at 50% -10%, rgba(16,185,129,0.08) 0%, transparent 65%);
+}
+
+.app-hero { padding: 40px 0 20px; text-align: center; }
+.app-hero h1 {
+    font-size: 2.8rem; font-weight: 800; letter-spacing: -0.04em;
+    background: linear-gradient(135deg, #10b981, #06b6d4, #3b82f6);
+    -webkit-background-clip: text; -webkit-text-fill-color: transparent;
+    margin-bottom: 8px;
+}
+.app-hero .tagline { color: var(--muted); font-size: 1rem; }
+.pills { display: flex; justify-content: center; gap: 8px; margin-top: 16px; flex-wrap: wrap; }
+.pill {
+    background: var(--card); border: 1px solid var(--border2); border-radius: 100px;
+    padding: 5px 14px; font-size: 0.75rem; color: var(--muted); font-family: 'Fira Code', monospace;
+}
+.pill.green { color: var(--green); border-color: rgba(16,185,129,0.3); }
+
+.tabs button { font-family: 'Outfit', sans-serif !important; font-weight: 500 !important; }
+
+button.primary-btn { 
+    background: linear-gradient(135deg, #10b981, #06b6d4) !important; 
+    border: none !important; color: #000 !important; font-weight: 600 !important;
+    padding: 12px 24px !important;
+}
+
+.output-image img { border-radius: 8px; }
+
+footer { display: none !important; }
+"""
 
-with gr.Blocks(theme=gr.themes.Soft()) as demo:
-    gr.Markdown("# Análise de Documentos com Surya")
+# Language string for the dropdown
+LANGUAGE_OPTIONS = [f"{code} - {name}" for code, name in sorted(LANGUAGES.items(), key=lambda x: x[1])]
+
+with gr.Blocks(theme=gr.themes.Base(), css=CSS, title="Surya OCR Studio") as app:
+    
+    gr.HTML("""
+    <div class="app-hero">
+        <h1>📄 Surya OCR Studio</h1>
+        <p class="tagline">Document OCR · Layout Analysis · Table Recognition · 90+ Languages</p>
+        <div class="pills">
+            <span class="pill green">ZeroGPU ⚡</span>
+            <span class="pill">90+ Languages</span>
+            <span class="pill">Layout Detection</span>
+            <span class="pill">Table Recognition</span>
+            <span class="pill">LaTeX OCR</span>
+        </div>
+    </div>
+    """)
     
-    with gr.Tab("OCR"):
-        gr.Markdown("## Reconhecimento Óptico de Caracteres")
-        with gr.Row():
-            ocr_input = gr.File(label="Carregar Imagem ou PDF")
-            ocr_langs = gr.Textbox(label="Idiomas (separados por vírgula)", value="en")
-        ocr_button = gr.Button("Executar OCR")
-        ocr_output = gr.JSON(label="Resultados OCR")
-        ocr_image = gr.Image(label="Imagem com Bounding Boxes")
-        ocr_text = gr.Textbox(label="Texto Extraído", lines=10)
-        ocr_button.click(ocr_workflow, inputs=[ocr_input, ocr_langs], outputs=[ocr_output, ocr_image, ocr_text])
-
-    with gr.Tab("Detecção de Texto"):
-        gr.Markdown("## Detecção de Linhas de Texto")
-        det_input = gr.File(label="Carregar Imagem ou PDF")
-        det_button = gr.Button("Executar Detecção de Texto")
-        det_output = gr.JSON(label="Resultados da Detecção de Texto")
-        det_image = gr.Image(label="Imagem com Bounding Boxes")
-        det_button.click(text_detection_workflow, inputs=det_input, outputs=[det_output, det_image])
-
-    with gr.Tab("Análise de Layout"):
-        gr.Markdown("## Análise de Layout e Ordem de Leitura")
-        layout_input = gr.File(label="Carregar Imagem ou PDF")
-        layout_button = gr.Button("Executar Análise de Layout")
-        order_button = gr.Button("Determinar Ordem de Leitura")
-        layout_output = gr.JSON(label="Resultados da Análise de Layout")
-        layout_image = gr.Image(label="Imagem com Layout")
-        order_output = gr.JSON(label="Resultados da Ordem de Leitura")
-        order_image = gr.Image(label="Imagem com Ordem de Leitura")
-        layout_button.click(layout_analysis_workflow, inputs=layout_input, outputs=[layout_output, layout_image])
-        order_button.click(reading_order_workflow, inputs=layout_input, outputs=[order_output, order_image])
+    with gr.Tabs() as tabs:
+        
+        # ============ OCR TAB ============
+        with gr.TabItem("📝 OCR"):
+            gr.Markdown("### Optical Character Recognition\nExtract text from images in 90+ languages.")
+            
+            with gr.Row():
+                with gr.Column(scale=2):
+                    ocr_input = gr.Image(label="📄 Upload Image", type="pil", height=400)
+                    
+                    with gr.Row():
+                        ocr_langs = gr.Textbox(
+                            label="Languages (comma-separated codes)",
+                            value="en",
+                            placeholder="en, pt, es, de, fr...",
+                            info="Use language codes: en=English, pt=Portuguese, es=Spanish..."
+                        )
+                        ocr_disable_math = gr.Checkbox(label="Disable math detection", value=False)
+                    
+                    ocr_btn = gr.Button("🚀 Run OCR", variant="primary", elem_classes=["primary-btn"])
+                
+                with gr.Column(scale=3):
+                    ocr_text = gr.Textbox(label="📝 Extracted Text", lines=12, show_copy_button=True)
+                    ocr_json = gr.JSON(label="📊 Detailed Results")
+            
+            ocr_image = gr.Image(label="🖼️ Detected Text Lines", elem_classes=["output-image"])
+            
+            ocr_btn.click(
+                process_ocr,
+                [ocr_input, ocr_langs, ocr_disable_math],
+                [ocr_text, ocr_json, ocr_image]
+            )
+        
+        # ============ TEXT DETECTION TAB ============
+        with gr.TabItem("🔍 Text Detection"):
+            gr.Markdown("### Text Line Detection\nDetect text lines in documents without OCR.")
+            
+            with gr.Row():
+                det_input = gr.Image(label="📄 Upload Image", type="pil", height=400)
+                with gr.Column():
+                    det_json = gr.JSON(label="📊 Detection Results")
+                    det_btn = gr.Button("🔍 Detect Text Lines", variant="primary", elem_classes=["primary-btn"])
+            
+            det_image = gr.Image(label="🖼️ Detected Lines", elem_classes=["output-image"])
+            
+            det_btn.click(process_detection, [det_input], [det_json, det_image])
+        
+        # ============ LAYOUT ANALYSIS TAB ============
+        with gr.TabItem("📊 Layout Analysis"):
+            gr.Markdown("### Document Layout Analysis\nIdentify document structure: titles, tables, figures, etc.")
+            
+            with gr.Row():
+                layout_input = gr.Image(label="📄 Upload Image", type="pil", height=400)
+                with gr.Column():
+                    layout_json = gr.JSON(label="📊 Layout Results")
+                    layout_btn = gr.Button("📊 Analyze Layout", variant="primary", elem_classes=["primary-btn"])
+            
+            layout_image = gr.Image(label="🖼️ Layout Elements", elem_classes=["output-image"])
+            
+            # Legend
+            gr.Markdown("""
+            **Legend:** 
+            🟢 Text | 🔴 Title | 🟡 Section Header | 🔵 Table | 🟣 Figure/Picture | 🩷 Caption | 🔷 Header/Footer
+            """)
+            
+            layout_btn.click(process_layout, [layout_input], [layout_json, layout_image])
+        
+        # ============ TABLE RECOGNITION TAB ============
+        with gr.TabItem("📋 Table Recognition"):
+            gr.Markdown("### Table Recognition\nExtract table structure and convert to Markdown.")
+            
+            with gr.Row():
+                table_input = gr.Image(label="📄 Upload Table Image", type="pil", height=400)
+                with gr.Column():
+                    table_json = gr.JSON(label="📊 Table Structure")
+                    table_btn = gr.Button("📋 Recognize Table", variant="primary", elem_classes=["primary-btn"])
+            
+            table_image = gr.Image(label="🖼️ Table Cells", elem_classes=["output-image"])
+            table_md = gr.Textbox(label="📝 Markdown Output", lines=10, show_copy_button=True)
+            
+            table_btn.click(process_table, [table_input], [table_json, table_image, table_md])
+        
+        # ============ LATEX OCR TAB ============
+        with gr.TabItem("🔢 LaTeX OCR"):
+            gr.Markdown("### LaTeX Equation OCR\nConvert equation images to LaTeX code.\n\n**Tip:** Crop the image to just the equation for best results.")
+            
+            with gr.Row():
+                latex_input = gr.Image(label="📄 Upload Equation Image", type="pil", height=300)
+                with gr.Column():
+                    latex_code = gr.Textbox(label="🔢 LaTeX Code", lines=5, show_copy_button=True)
+                    latex_json = gr.JSON(label="📊 Results")
+                    latex_btn = gr.Button("🔢 Extract LaTeX", variant="primary", elem_classes=["primary-btn"])
+            
+            latex_btn.click(process_latex, [latex_input], [latex_code, latex_json])
+    
+    # ============ FOOTER ============
+    gr.Markdown("""
+    ---
+    
+    ### ℹ️ About Surya OCR
+    
+    | Feature | Description |
+    |---------|-------------|
+    | **OCR** | Text recognition in 90+ languages |
+    | **Detection** | Line-level text detection |
+    | **Layout** | Identify tables, figures, headers, etc. |
+    | **Tables** | Extract table structure to Markdown |
+    | **LaTeX** | Convert equations to LaTeX |
+    
+    **Performance Tips:**
+    - Use higher resolution images for better accuracy
+    - For blurry text, try preprocessing (binarization, deskewing)
+    - Specify correct language codes for best OCR results
+    
+    **Model:** [Surya OCR](https://github.com/datalab-to/surya) by datalab-to  
+    **Space by:** [@artificialguybr](https://twitter.com/artificialguybr)
+    """)
+
 
 if __name__ == "__main__":
-    logger.info("Iniciando aplicativo Gradio...")
-    demo.launch()
+    app.queue(max_size=20)
+    app.launch()

languages.json

@@ -1,95 +0,0 @@
-{
-  "Afrikaans": "af",
-  "Amharic": "am",
-  "Arabic": "ar",
-  "Assamese": "as",
-  "Azerbaijani": "az",
-  "Belarusian": "be",
-  "Bulgarian": "bg",
-  "Bengali": "bn",
-  "Breton": "br",
-  "Bosnian": "bs",
-  "Catalan": "ca",
-  "Czech": "cs",
-  "Welsh": "cy",
-  "Danish": "da",
-  "German": "de",
-  "Greek": "el",
-  "English": "en",
-  "Esperanto": "eo",
-  "Spanish": "es",
-  "Estonian": "et",
-  "Basque": "eu",
-  "Persian": "fa",
-  "Finnish": "fi",
-  "French": "fr",
-  "Western Frisian": "fy",
-  "Irish": "ga",
-  "Scottish Gaelic": "gd",
-  "Galician": "gl",
-  "Gujarati": "gu",
-  "Hausa": "ha",
-  "Hebrew": "he",
-  "Hindi": "hi",
-  "Croatian": "hr",
-  "Hungarian": "hu",
-  "Armenian": "hy",
-  "Indonesian": "id",
-  "Icelandic": "is",
-  "Italian": "it",
-  "Japanese": "ja",
-  "Javanese": "jv",
-  "Georgian": "ka",
-  "Kazakh": "kk",
-  "Khmer": "km",
-  "Kannada": "kn",
-  "Korean": "ko",
-  "Kurdish": "ku",
-  "Kyrgyz": "ky",
-  "Latin": "la",
-  "Lao": "lo",
-  "Lithuanian": "lt",
-  "Latvian": "lv",
-  "Malagasy": "mg",
-  "Macedonian": "mk",
-  "Malayalam": "ml",
-  "Mongolian": "mn",
-  "Marathi": "mr",
-  "Malay": "ms",
-  "Burmese": "my",
-  "Nepali": "ne",
-  "Dutch": "nl",
-  "Norwegian": "no",
-  "Oromo": "om",
-  "Oriya": "or",
-  "Punjabi": "pa",
-  "Polish": "pl",
-  "Pashto": "ps",
-  "Portuguese": "pt",
-  "Romanian": "ro",
-  "Russian": "ru",
-  "Sanskrit": "sa",
-  "Sindhi": "sd",
-  "Sinhala": "si",
-  "Slovak": "sk",
-  "Slovenian": "sl",
-  "Somali": "so",
-  "Albanian": "sq",
-  "Serbian": "sr",
-  "Sundanese": "su",
-  "Swedish": "sv",
-  "Swahili": "sw",
-  "Tamil": "ta",
-  "Telugu": "te",
-  "Thai": "th",
-  "Tagalog": "tl",
-  "Turkish": "tr",
-  "Uyghur": "ug",
-  "Ukrainian": "uk",
-  "Urdu": "ur",
-  "Uzbek": "uz",
-  "Vietnamese": "vi",
-  "Xhosa": "xh",
-  "Yiddish": "yi",
-  "Chinese": "zh"
-}

requirements.txt

@@ -1,3 +1,5 @@
-torch
 surya-ocr
-pillow
+gradio>=4.0.0
+pillow
+torch
+spaces