Upload folder using huggingface_hub

Dockerfile

@@ -6,4 +6,4 @@ COPY requirements.txt .
 RUN pip install --no-cache-dir -r requirements.txt
 COPY . .
 EXPOSE 7860
-CMD ["streamlit", "run", "app.py"]
+CMD ["python", "gradio_api.py"]

gradio_api.py

@@ -0,0 +1,677 @@
+import os
+import cv2
+import numpy as np
+import math
+import time
+import gc
+import torch
+import fitz  # PyMuPDF
+from PIL import Image
+import gradio as gr
+from paddleocr import PaddleOCR
+from google import genai
+from google.genai import types
+from pydantic import BaseModel
+
+# --- 1. Structured Output Definitions ---
+class BoundingBox(BaseModel):
+    box_2d: list[int]
+    label: str
+
+# API Key configuration
+API_KEY = os.environ.get("GEMINI_API_KEY", "AQ.Ab8RN6K7DUqbPAcdRwV1Y-xYSH4qZOwvnUsmi1330DwbiWVSOg")
+
+# Caching models for reuse
+_PADDLE_OCR = None
+def get_paddle_ocr():
+    global _PADDLE_OCR
+    if _PADDLE_OCR is None:
+        print("[API] Initializing PaddleOCR...")
+        _PADDLE_OCR = PaddleOCR(use_angle_cls=True, lang='de')
+    return _PADDLE_OCR
+
+_TROCR_PROCESSOR = None
+_TROCR_MODEL = None
+def get_trocr():
+    global _TROCR_PROCESSOR, _TROCR_MODEL
+    if _TROCR_PROCESSOR is None or _TROCR_MODEL is None:
+        print("[API] Initializing TrOCR...")
+        import logging as transformers_logging
+        transformers_logging.getLogger("transformers").setLevel(transformers_logging.ERROR)
+        
+        onnx_path = "trocr_onnx"
+        if os.path.exists(onnx_path):
+            from transformers import TrOCRProcessor
+            from optimum.onnxruntime import ORTModelForVision2Seq
+            _TROCR_PROCESSOR = TrOCRProcessor.from_pretrained(onnx_path)
+            _TROCR_MODEL = ORTModelForVision2Seq.from_pretrained(onnx_path, provider="CPUExecutionProvider")
+        else:
+            from transformers import TrOCRProcessor, VisionEncoderDecoderModel
+            _TROCR_PROCESSOR = TrOCRProcessor.from_pretrained('microsoft/trocr-base-handwritten')
+            _TROCR_MODEL = VisionEncoderDecoderModel.from_pretrained('microsoft/trocr-base-handwritten')
+    return _TROCR_PROCESSOR, _TROCR_MODEL
+
+def recursive_xy_cut(boxes_with_data):
+    if len(boxes_with_data) <= 1:
+        return boxes_with_data
+        
+    gap_threshold = 5  # Mindestabstand
+    
+    # 1. Horizontale Lücken berechnen
+    y_intervals = sorted([(b[0][1], b[0][3]) for b in boxes_with_data])
+    max_h_gap = 0
+    h_gap_y = None
+    max_y = y_intervals[0][1]
+    for i in range(1, len(y_intervals)):
+        if y_intervals[i][0] > max_y:
+            gap = y_intervals[i][0] - max_y
+            if gap > max_h_gap and gap > gap_threshold:
+                max_h_gap = gap
+                h_gap_y = (max_y + y_intervals[i][0]) / 2
+        max_y = max(max_y, y_intervals[i][1])
+        
+    # 2. Vertikale Lücken berechnen
+    x_intervals = sorted([(b[0][0], b[0][2]) for b in boxes_with_data])
+    max_v_gap = 0
+    v_gap_x = None
+    max_x = x_intervals[0][1]
+    for i in range(1, len(x_intervals)):
+        if x_intervals[i][0] > max_x:
+            gap = x_intervals[i][0] - max_x
+            if gap > max_v_gap and gap > gap_threshold:
+                max_v_gap = gap
+                v_gap_x = (max_x + x_intervals[i][0]) / 2
+        max_x = max(max_x, x_intervals[i][1])
+        
+    # 3. Entlang der GRÖSSTEN Lücke schneiden!
+    if max_h_gap == 0 and max_v_gap == 0:
+        return sorted(boxes_with_data, key=lambda b: (b[0][1], b[0][0]))
+        
+    if max_v_gap > max_h_gap:
+        left_boxes = [b for b in boxes_with_data if (b[0][0]+b[0][2])/2 < v_gap_x]
+        right_boxes = [b for b in boxes_with_data if b not in left_boxes]
+        if len(left_boxes) > 0 and len(right_boxes) > 0:
+            return recursive_xy_cut(left_boxes) + recursive_xy_cut(right_boxes)
+    
+    if h_gap_y is not None:
+        top_boxes = [b for b in boxes_with_data if (b[0][1]+b[0][3])/2 < h_gap_y]
+        bottom_boxes = [b for b in boxes_with_data if b not in top_boxes]
+        if len(top_boxes) > 0 and len(bottom_boxes) > 0:
+            return recursive_xy_cut(top_boxes) + recursive_xy_cut(bottom_boxes)
+            
+    return sorted(boxes_with_data, key=lambda b: (b[0][1], b[0][0]))
+
+def process_pdf(input_file_path, mode, progress=gr.Progress()):
+    if not input_file_path:
+        raise gr.Error("Bitte lade ein PDF hoch.")
+
+    print(f"[API] Processing {input_file_path} in mode: {mode}")
+    progress(0, desc="Initialisiere Datei und Modelle...")
+
+    # Load required clients and models
+    client = None
+    if "Gemini" in mode:
+        client = genai.Client(api_key=API_KEY)
+    
+    paddle_ocr = None
+    if "PaddleOCR" in mode:
+        paddle_ocr = get_paddle_ocr()
+        
+    trocr_processor, trocr_model = None, None
+    if "Lokal Deep" in mode:
+        trocr_processor, trocr_model = get_trocr()
+
+    # Load PDF
+    doc = fitz.open(input_file_path)
+    num_pages = len(doc)
+    
+    output_filename = f"searchable_{os.path.basename(input_file_path)}"
+    output_path = os.path.join(os.path.dirname(input_file_path), output_filename)
+
+    for page_num in range(num_pages):
+        progress((page_num) / num_pages, desc=f"Verarbeite Seite {page_num + 1} von {num_pages}...")
+        page = doc.load_page(page_num)
+
+        # ==========================================
+        # MODUS 1: Schnell (Gemini Full-Page)
+        # ==========================================
+        if mode == "Schnell (Gemini Full-Page)":
+            zoom = 150 / 72
+            mat = fitz.Matrix(zoom, zoom)
+            pix = page.get_pixmap(matrix=mat)
+            img_bytes = pix.tobytes("png")
+
+            prompt = """Du bist ein extrem präzises OCR-System für mathematische Vorlesungsskripte.
+Extrahiere absolut JEDEN Text (sowohl handgeschrieben als auch Maschinenschrift / gedruckten Text). 
+Verpasse kein einziges mathematisches Symbol, keinen Bruch und keinen Index.
+WICHTIG FÜR FORMELN: Wandle ALLE mathematischen Formeln zwingend in eine saubere, einzeilige und logisch lesbare Schreibweise um! 
+- Nutze Klammern und Schrägstriche für Brüche: (A)/(B)
+- Nutze '^' für Exponenten und '_' für Indizes: x^(SV), q_BM
+- Nutze korrekte Unicode-Sonderzeichen für alles andere: Wurzeln (√), Integrale (∫), Summen (∑), griechische Buchstaben (α, β, γ, μ) etc.
+- ACHTUNG BEI EINHEITEN: Wenn Einheiten in eckigen Klammern [...] neben einer Formel stehen, behalte die eckigen Klammern UNBEDINGT bei! Füge KEIN Multiplikationszeichen '*' dazwischen ein. Einheiten sind reine Beschriftungen, keine Faktoren!
+- Versuche NICHT, das optische 2D-Layout von Formeln mit mehrzeiligen Leerzeichen nachzuahmen!
+Fasse zusammenhängende Sätze, Absätze oder komplette mathematische Formeln in EINER GEMEINSAMEN BoundingBox zusammen. 
+Zerstückele Formeln oder Brüche NICHT in Einzelteile! Eine komplette Formel = Eine BoundingBox.
+Ignoriere Hintergrundmuster wie Punktraster komplett.
+Gib für jeden Textblock/jede Formel eine BoundingBox zurück. box_2d ist [ymin, xmin, ymax, xmax] von 0 bis 1000."""
+
+            max_retries = 10
+            current_model = 'gemini-3.1-flash-lite'
+            response = None
+            for attempt in range(max_retries):
+                try:
+                    response = client.models.generate_content(
+                        model=current_model,
+                        contents=[prompt, types.Part.from_bytes(data=img_bytes, mime_type='image/png')],
+                        config=types.GenerateContentConfig(
+                            response_mime_type="application/json",
+                            response_schema=list[BoundingBox],
+                            temperature=0.0
+                        )
+                    )
+                    break
+                except Exception as e:
+                    error_msg = str(e)
+                    is_retriable = any(code in error_msg for code in ["503", "429", "500", "502", "504", "Quota", "exhausted"])
+                    if is_retriable and attempt < max_retries - 1:
+                        import re
+                        wait_time = 5
+                        match = re.search(r"'retryDelay':\s*'(\d+(?:\.\d+)?)s'", error_msg)
+                        if match:
+                            wait_time = int(float(match.group(1))) + 5
+                        if "503" in error_msg or "unavailable" in error_msg.lower():
+                            current_model = 'gemini-2.5-flash'
+                        print(f"[API] API error. Waiting {wait_time}s... (Attempt {attempt+1}/{max_retries})")
+                        time.sleep(wait_time)
+                    else:
+                        raise e
+
+            if response and response.parsed:
+                font = fitz.Font("helv")
+                descender = font.descender
+
+                boxes_with_data = []
+                for box in response.parsed:
+                    ymin, xmin, ymax, xmax = box.box_2d
+                    x0 = (xmin / 1000) * page.rect.width
+                    y0 = (ymin / 1000) * page.rect.height
+                    x1 = (xmax / 1000) * page.rect.width
+                    y1 = (ymax / 1000) * page.rect.height
+                    boxes_with_data.append(([x0, y0, x1, y1], box))
+
+                sorted_data = recursive_xy_cut(boxes_with_data)
+
+                for coords, box in sorted_data:
+                    text = box.label
+                    if not text.strip() or text.strip() in [".", "..."]:
+                        continue
+
+                    x0, y0, x1, y1 = coords
+                    rect = fitz.Rect(x0, y0, x1, y1)
+
+                    fontsize = rect.height
+                    text_length = fitz.get_text_length(text, fontname="helv", fontsize=fontsize)
+                    scale_x = rect.width / text_length if text_length > 0 else 1.0
+                    
+                    y_baseline = rect.y1 + (descender * fontsize)
+                    point = fitz.Point(rect.x0, y_baseline)
+                    matrix = fitz.Matrix(scale_x, 1.0)
+
+                    try:
+                        page.insert_text(point, text, fontsize=fontsize, fontname="helv", render_mode=3, morph=(point, matrix))
+                    except ValueError:
+                        clean_text = text.encode("latin-1", "ignore").decode("latin-1")
+                        if clean_text.strip():
+                            try:
+                                page.insert_text(point, clean_text, fontsize=fontsize, fontname="helv", render_mode=3, morph=(point, matrix))
+                            except Exception:
+                                pass
+
+            if page_num < num_pages - 1:
+                time.sleep(1)
+            gc.collect()
+
+        # ==========================================
+        # MODUS 2: Präzise (True Hybrid OCR)
+        # ==========================================
+        elif mode == "Präzise (Hybrid: PaddleOCR + Gemini)":
+            zoom = 150 / 72
+            mat = fitz.Matrix(zoom, zoom)
+            pix = page.get_pixmap(matrix=mat)
+            img_bytes = pix.tobytes("png")
+            
+            img_np = np.frombuffer(pix.samples, dtype=np.uint8).reshape(pix.h, pix.w, pix.n)
+            if pix.n == 4:
+                img_np = cv2.cvtColor(img_np, cv2.COLOR_RGBA2BGR)
+            else:
+                img_np = cv2.cvtColor(img_np, cv2.COLOR_RGB2BGR)
+
+            result = paddle_ocr.ocr(img_np)
+            paddle_boxes = [(line[0], line[1][0]) for line in result[0]] if result and result[0] else []
+            
+            prompt = """Du bist ein extrem präzises OCR-System für mathematische Vorlesungsskripte.
+Extrahiere absolut JEDEN Text (sowohl handgeschrieben als auch Maschinenschrift / gedruckten Text). 
+Verpasse kein einziges mathematisches Symbol, keinen Bruch und keinen Index.
+WICHTIG FÜR FORMELN: Wandle ALLE mathematischen Formeln zwingend in eine saubere, einzeilige und logisch lesbare Schreibweise um! 
+- Nutze Klammern und Schrägstriche für Brüche: (A)/(B)
+- Nutze '^' für Exponenten und '_' für Indizes: x^(SV), q_BM
+- Nutze korrekte Unicode-Sonderzeichen für alles andere: Wurzeln (√), Integrale (∫), Summen (∑), griechische Buchstaben (α, β, γ, μ) etc.
+- ACHTUNG BEI EINHEITEN: Wenn Einheiten in eckigen Klammern [...] neben einer Formel stehen, behalte die eckigen Klammern UNBEDINGT bei! Füge KEIN Multiplikationszeichen '*' dazwischen ein. Einheiten sind reine Beschriftungen, keine Faktoren!
+- Versuche NICHT, das optische 2D-Layout von Formeln mit mehrzeiligen Leerzeichen nachzuahmen!
+WICHTIG FÜR DAS LAYOUT (ABSOLUT KRITISCH!): 
+1. NORMALE TEXTZEILEN: Du MUSST für JEDE physische Textzeile im Bild eine EIGENE, separate BoundingBox erstellen!
+   - Es ist STRENGSTENS VERBOTEN, mehrere Zeilen zu einem Absatz zusammenzufassen!
+   - Auch wenn eine Textzeile Variablen (wie f_A) enthält, ist sie eine normale Zeile und darf NICHT mit der Zeile darunter zusammengefasst werden.
+2. MEHRZEILIGE BRÜCHE: NUR WIRKLICHE mehrzeilige Formeln (Zähler über Nenner) MÜSSEN in EINER gemeinsamen BoundingBox zusammengefasst werden.
+Ignoriere Hintergrundmuster wie Punktraster komplett.
+Gib für jeden Textblock/jede Formel eine BoundingBox zurück. box_2d ist [ymin, xmin, ymax, xmax] von 0 bis 1000."""
+
+            max_retries = 10
+            current_model = 'gemini-3.1-flash-lite'
+            response = None
+            for attempt in range(max_retries):
+                try:
+                    response = client.models.generate_content(
+                        model=current_model,
+                        contents=[prompt, types.Part.from_bytes(data=img_bytes, mime_type='image/png')],
+                        config=types.GenerateContentConfig(
+                            response_mime_type="application/json",
+                            response_schema=list[BoundingBox],
+                            temperature=0.0
+                        )
+                    )
+                    break
+                except Exception as e:
+                    error_msg = str(e)
+                    is_retriable = any(code in error_msg for code in ["503", "429", "500", "502", "504", "Quota", "exhausted"])
+                    if is_retriable and attempt < max_retries - 1:
+                        import re
+                        wait_time = 5
+                        match = re.search(r"'retryDelay':\s*'(\d+(?:\.\d+)?)s'", error_msg)
+                        if match:
+                            wait_time = int(float(match.group(1))) + 5
+                        if "503" in error_msg or "unavailable" in error_msg.lower():
+                            current_model = 'gemini-2.5-flash'
+                        print(f"[API] API error. Waiting {wait_time}s... (Attempt {attempt+1}/{max_retries})")
+                        time.sleep(wait_time)
+                    else:
+                        raise e
+
+            if response and response.parsed:
+                boxes_with_data = []
+                g_rects = []
+                for g_box in response.parsed:
+                    ymin, xmin, ymax, xmax = g_box.box_2d
+                    x0 = (xmin / 1000) * page.rect.width
+                    y0 = (ymin / 1000) * page.rect.height
+                    x1 = (xmax / 1000) * page.rect.width
+                    y1 = (ymax / 1000) * page.rect.height
+                    g_rects.append(fitz.Rect(x0, y0, x1, y1))
+                    
+                assigned_p_boxes_per_g_idx = {i: [] for i in range(len(response.parsed))}
+                
+                for pb_data in paddle_boxes:
+                    p_box, p_text = pb_data
+                    p_xmin = min(p[0] for p in p_box) / zoom
+                    p_ymin = min(p[1] for p in p_box) / zoom
+                    p_xmax = max(p[0] for p in p_box) / zoom
+                    p_ymax = max(p[1] for p in p_box) / zoom
+                    p_rect = fitz.Rect(p_xmin, p_ymin, p_xmax, p_ymax)
+                    
+                    best_g_idx = -1
+                    max_overlap = 0
+                    for idx, g_rect in enumerate(g_rects):
+                        overlap = g_rect.intersect(p_rect).get_area()
+                        if overlap > max_overlap:
+                            max_overlap = overlap
+                            best_g_idx = idx
+                            
+                    if best_g_idx != -1 and max_overlap > 0.1 * p_rect.get_area():
+                        assigned_p_boxes_per_g_idx[best_g_idx].append(pb_data)
+                        
+                for idx, g_box in enumerate(response.parsed):
+                    g_text = g_box.label
+                    assigned_p_boxes = assigned_p_boxes_per_g_idx[idx]
+                    
+                    if assigned_p_boxes:
+                        assigned_p_boxes.sort(key=lambda b: min(p[1] for p in b[0]))
+                        
+                        clustered_p_boxes = []
+                        for pb_tuple in assigned_p_boxes:
+                            pb, pt = pb_tuple
+                            y_center = (min(p[1] for p in pb) + max(p[1] for p in pb)) / 2
+                            
+                            added_to_cluster = False
+                            for cluster in clustered_p_boxes:
+                                c_y_center = cluster['y_center']
+                                if abs(y_center - c_y_center) < (10 / zoom):
+                                    cluster['boxes'].append(pb_tuple)
+                                    all_y = [min(p[1] for b in cluster['boxes'] for p in b[0]), max(p[1] for b in cluster['boxes'] for p in b[0])]
+                                    cluster['y_center'] = sum(all_y) / 2
+                                    added_to_cluster = True
+                                    break
+                                    
+                            if not added_to_cluster:
+                                clustered_p_boxes.append({'y_center': y_center, 'boxes': [pb_tuple]})
+                                
+                        for cluster in clustered_p_boxes:
+                            cluster['boxes'].sort(key=lambda b: min(p[0] for p in b[0]))
+                            
+                        math_chars = sum(1 for c in g_text if c in ['=', '/', '^', '[', ']'])
+                        is_formula = (math_chars >= 4 and "=" in g_text)
+                        
+                        if not is_formula:
+                            g_words = g_text.split()
+                            word_idx = 0
+                            
+                            for c_idx, cluster in enumerate(clustered_p_boxes):
+                                cluster_boxes = cluster['boxes']
+                                cluster_word_count = sum(max(1, len(pt.split())) for pb, pt in cluster_boxes)
+                                chunk = g_words[word_idx : word_idx + cluster_word_count]
+                                line_text = " ".join(chunk)
+                                word_idx += cluster_word_count
+                                
+                                if c_idx == len(clustered_p_boxes) - 1 and word_idx < len(g_words):
+                                    if line_text:
+                                        line_text += " "
+                                    line_text += " ".join(g_words[word_idx:])
+                                    
+                                if not line_text.strip():
+                                    continue
+                                
+                                if len(cluster_boxes) == 1:
+                                    pb, pt = cluster_boxes[0]
+                                    p0 = [pb[0][0]/zoom, pb[0][1]/zoom]
+                                    p1 = [pb[1][0]/zoom, pb[1][1]/zoom]
+                                    p2 = [pb[2][0]/zoom, pb[2][1]/zoom]
+                                    p3 = [pb[3][0]/zoom, pb[3][1]/zoom]
+                                    
+                                    dx = p1[0] - p0[0]
+                                    dy = p1[1] - p0[1]
+                                    dx_up = p0[0] - p3[0]
+                                    dy_up = p0[1] - p3[1]
+                                    angle_rad = math.atan2(dy, dx) if (dx != 0 or dy != 0) else 0
+                                    angle_deg = math.degrees(angle_rad)
+                                else:
+                                    total_dx, total_dy = 0, 0
+                                    all_points = []
+                                    for pb, pt in cluster_boxes:
+                                        total_dx += pb[1][0] - pb[0][0]
+                                        total_dy += pb[1][1] - pb[0][1]
+                                        for p in pb:
+                                            all_points.append((p[0]/zoom, p[1]/zoom))
+                                            
+                                    angle_rad = math.atan2(total_dy, total_dx) if (total_dx != 0 or total_dy != 0) else 0
+                                    angle_deg = math.degrees(angle_rad)
+                                    
+                                    cos_a = math.cos(-angle_rad)
+                                    sin_a = math.sin(-angle_rad)
+                                    
+                                    local_points = []
+                                    for px, py in all_points:
+                                        lx = px * cos_a - py * sin_a
+                                        ly = px * sin_a + py * cos_a
+                                        local_points.append((lx, ly))
+                                        
+                                    min_lx = min(p[0] for p in local_points)
+                                    max_lx = max(p[0] for p in local_points)
+                                    min_ly = min(p[1] for p in local_points)
+                                    max_ly = max(p[1] for p in local_points)
+                                    
+                                    lp0, lp1, lp2, lp3 = (min_lx, min_ly), (max_lx, min_ly), (max_lx, max_ly), (min_lx, max_ly)
+                                    
+                                    cos_inv = math.cos(angle_rad)
+                                    sin_inv = math.sin(angle_rad)
+                                    
+                                    merged_box = []
+                                    for lx, ly in [lp0, lp1, lp2, lp3]:
+                                        gx = lx * cos_inv - ly * sin_inv
+                                        gy = lx * sin_inv + ly * cos_inv
+                                        merged_box.append([gx, gy])
+                                        
+                                    p0, p1, p2, p3 = merged_box
+                                    dx = p1[0] - p0[0]
+                                    dy = p1[1] - p0[1]
+                                    dx_up = p0[0] - p3[0]
+                                    dy_up = p0[1] - p3[1]
+                                    
+                                box_width_pdf = math.hypot(dx, dy)
+                                box_height_pdf = math.hypot(dx_up, dy_up)
+                                
+                                font = fitz.Font("helv")
+                                shift_factor = -font.descender
+                                base_x = p3[0] + dx_up * shift_factor
+                                base_y = p3[1] + dy_up * shift_factor
+                                pdf_baseline = fitz.Point(base_x, base_y)
+                                
+                                merged_points = [p0, p1, p2, p3]
+                                coords = [min(p[0] for p in merged_points), min(p[1] for p in merged_points), max(p[0] for p in merged_points), max(p[1] for p in merged_points)]
+                                boxes_with_data.append((coords, ('text', line_text, pdf_baseline, box_width_pdf, box_height_pdf, angle_deg)))
+                        else:
+                            total_dx, total_dy = 0, 0
+                            all_points = []
+                            for pb, pt in assigned_p_boxes:
+                                total_dx += pb[1][0] - pb[0][0]
+                                total_dy += pb[1][1] - pb[0][1]
+                                for p in pb:
+                                    all_points.append((p[0]/zoom, p[1]/zoom))
+                                    
+                            angle_rad = math.atan2(total_dy, total_dx) if (total_dx != 0 or total_dy != 0) else 0
+                            angle_deg = math.degrees(angle_rad)
+                            
+                            cos_a = math.cos(-angle_rad)
+                            sin_a = math.sin(-angle_rad)
+                            
+                            local_points = []
+                            for px, py in all_points:
+                                lx = px * cos_a - py * sin_a
+                                ly = px * sin_a + py * cos_a
+                                local_points.append((lx, ly))
+                                
+                            min_lx = min(p[0] for p in local_points)
+                            max_lx = max(p[0] for p in local_points)
+                            min_ly = min(p[1] for p in local_points)
+                            max_ly = max(p[1] for p in local_points)
+                            
+                            lp0, lp1, lp2, lp3 = (min_lx, min_ly), (max_lx, min_ly), (max_lx, max_ly), (min_lx, max_ly)
+                            
+                            cos_inv = math.cos(angle_rad)
+                            sin_inv = math.sin(angle_rad)
+                            
+                            merged_box = []
+                            for lx, ly in [lp0, lp1, lp2, lp3]:
+                                gx = lx * cos_inv - ly * sin_inv
+                                gy = lx * sin_inv + ly * cos_inv
+                                merged_box.append([gx, gy])
+                                
+                            p0, p1, p2, p3 = merged_box
+                            dx = p1[0] - p0[0]
+                            dy = p1[1] - p0[1]
+                            dx_up = p0[0] - p3[0]
+                            dy_up = p0[1] - p3[1]
+                            
+                            box_width_pdf = math.hypot(dx, dy)
+                            box_height_pdf = math.hypot(dx_up, dy_up)
+                            
+                            font = fitz.Font("helv")
+                            shift_factor = -font.descender
+                            base_x = p3[0] + dx_up * shift_factor
+                            base_y = p3[1] + dy_up * shift_factor
+                            pdf_baseline = fitz.Point(base_x, base_y)
+                            
+                            coords = [min(p[0] for p in merged_box), min(p[1] for p in merged_box), max(p[0] for p in merged_box), max(p[1] for p in merged_box)]
+                            flat_text = g_text.replace('\n', '  ')
+                            boxes_with_data.append((coords, (flat_text, pdf_baseline, box_width_pdf, box_height_pdf, angle_deg)))
+                    else:
+                        ymin, xmin, ymax, xmax = g_box.box_2d
+                        x0 = (xmin / 1000) * page.rect.width
+                        y0 = (ymin / 1000) * page.rect.height
+                        x1 = (xmax / 1000) * page.rect.width
+                        y1 = (ymax / 1000) * page.rect.height
+                        pdf_baseline = fitz.Point(x0, y1 - (y1-y0)*0.2)
+                        boxes_with_data.append(([x0, y0, x1, y1], (g_text.replace('\n', '  '), pdf_baseline, x1-x0, y1-y0, 0)))
+
+                sorted_data = recursive_xy_cut(boxes_with_data)
+                
+                for coords, data in sorted_data:
+                    if len(data) == 5:
+                        text, pdf_baseline, box_width_pdf, box_height_pdf, angle_deg = data
+                    elif len(data) == 6:
+                        _, text, pdf_baseline, box_width_pdf, box_height_pdf, angle_deg = data
+                    else:
+                        continue
+                    
+                    fontsize = box_height_pdf
+                    text_length = fitz.get_text_length(text, fontname="helv", fontsize=fontsize)
+                    scale_x = box_width_pdf / text_length if text_length > 0 else 1.0
+                    
+                    matrix = fitz.Matrix(scale_x, 1.0) * fitz.Matrix(-angle_deg)
+                    try:
+                        page.insert_text(pdf_baseline, text, fontsize=fontsize, fontname="helv", render_mode=3, morph=(pdf_baseline, matrix))
+                    except ValueError:
+                        clean_text = text.encode("latin-1", "ignore").decode("latin-1")
+                        if clean_text.strip():
+                            try:
+                                page.insert_text(pdf_baseline, clean_text, fontsize=fontsize, fontname="helv", render_mode=3, morph=(pdf_baseline, matrix))
+                            except Exception:
+                                pass
+                                
+            if page_num < num_pages - 1:
+                time.sleep(1)
+            gc.collect()
+
+        # ==========================================
+        # MODUS 3: Lokal Deep (TrOCR)
+        # ==========================================
+        elif mode == "Lokal Deep (PaddleOCR + TrOCR)":
+            zoom = 3.0
+            mat = fitz.Matrix(zoom, zoom)
+            pix = page.get_pixmap(matrix=mat)
+            
+            img_np = np.frombuffer(pix.samples, dtype=np.uint8).reshape(pix.h, pix.w, pix.n)
+            if pix.n == 4:
+                img_np = cv2.cvtColor(img_np, cv2.COLOR_RGBA2BGR)
+            else:
+                img_np = cv2.cvtColor(img_np, cv2.COLOR_RGB2BGR)
+
+            result = paddle_ocr.ocr(img_np)
+            
+            if not result or not result[0]:
+                continue
+                
+            page_data = result[0]
+            valid_lines = [l for l in page_data if l]
+            crops = []
+            valid_boxes = []
+            
+            for line in valid_lines:
+                box = line[0]
+                x_coords = [int(p[0]) for p in box]
+                y_coords = [int(p[1]) for p in box]
+                x_min, x_max = max(0, min(x_coords) - 2), min(img_np.shape[1], max(x_coords) + 2)
+                y_min, y_max = max(0, min(y_coords) - 2), min(img_np.shape[0], max(y_coords) + 2)
+                
+                crop_img = img_np[y_min:y_max, x_min:x_max]
+                if crop_img.size > 0:
+                    crop_rgb = cv2.cvtColor(crop_img, cv2.COLOR_BGR2RGB)
+                    crops.append(Image.fromarray(crop_rgb))
+                    valid_boxes.append((box, line[1][0]))
+            
+            BATCH_SIZE = 4 
+            results = []
+            
+            for b_idx in range(0, len(crops), BATCH_SIZE):
+                batch_crops = crops[b_idx:b_idx+BATCH_SIZE]
+                batch_fallbacks = [vb[1] for vb in valid_boxes[b_idx:b_idx+BATCH_SIZE]]
+                batch_texts = list(batch_fallbacks)
+                
+                if batch_crops:
+                    try:
+                        pixel_values = trocr_processor(batch_crops, return_tensors="pt").pixel_values
+                        generated_ids = trocr_model.generate(pixel_values, max_new_tokens=30)
+                        texts = trocr_processor.batch_decode(generated_ids, skip_special_tokens=True)
+                        for map_idx, txt in enumerate(texts):
+                            batch_texts[map_idx] = txt
+                    except Exception as e:
+                        print(f"[API] TrOCR batch failed, using fallback: {e}")
+                        
+                results.extend(batch_texts)
+
+            boxes_with_data = []
+            for idx, text in enumerate(results):
+                if not text.strip(): continue
+                box = valid_boxes[idx][0]
+                xmin = min(p[0] for p in box)
+                ymin = min(p[1] for p in box)
+                xmax = max(p[0] for p in box)
+                ymax = max(p[1] for p in box)
+                boxes_with_data.append(([xmin, ymin, xmax, ymax], (box, text)))
+                
+            sorted_data = recursive_xy_cut(boxes_with_data)
+            
+            for coords, (box, text) in sorted_data:
+                p0, p1, p2, p3 = box
+                dx = p1[0] - p0[0]
+                dy = p1[1] - p0[1]
+                angle_deg = math.degrees(math.atan2(dy, dx))
+                
+                dx_up = p0[0] - p3[0]
+                dy_up = p0[1] - p3[1]
+                
+                font = fitz.Font("helv")
+                shift_factor = -font.descender
+                
+                base_x = p3[0] + dx_up * shift_factor
+                base_y = p3[1] + dy_up * shift_factor
+                
+                pdf_baseline = fitz.Point(base_x / zoom, base_y / zoom)
+                box_width_pdf = math.hypot(dx, dy) / zoom
+                box_height_pdf = math.hypot(dx_up, dy_up) / zoom
+                
+                fontsize = box_height_pdf
+                text_length = fitz.get_text_length(text, fontname="helv", fontsize=fontsize)
+                scale_x = box_width_pdf / text_length if text_length > 0 else 1.0
+                
+                matrix = fitz.Matrix(scale_x, 1.0) * fitz.Matrix(-angle_deg)
+                try:
+                    page.insert_text(pdf_baseline, text, fontsize=fontsize, fontname="helv", render_mode=3, morph=(pdf_baseline, matrix))
+                except ValueError:
+                    clean_text = text.encode("latin-1", "ignore").decode("latin-1")
+                    if clean_text.strip():
+                        try:
+                            page.insert_text(pdf_baseline, clean_text, fontsize=fontsize, fontname="helv", render_mode=3, morph=(pdf_baseline, matrix))
+                        except Exception:
+                            pass
+
+    doc.save(output_path)
+    doc.close()
+    progress(1.0, desc="Fertig! PDF erfolgreich generiert.")
+    print(f"[API] Searchable PDF saved to {output_path}")
+    return output_path
+
+# Gradio Interface
+with gr.Blocks(title="OCR app API & Web Interface") as demo:
+    gr.Markdown("# 📄 Multi-Mode OCR API & Web UI")
+    gr.Markdown("Wähle eine PDF-Datei und einen Modus, um ein durchsuchbares PDF zu generieren. Dieser Space kann auch programmgesteuert aufgerufen werden.")
+    
+    with gr.Row():
+        with gr.Column():
+            file_input = gr.File(label="PDF Datei hochladen", file_types=[".pdf"])
+            mode_input = gr.Radio(
+                choices=["Schnell (Gemini Full-Page)", "Präzise (Hybrid: PaddleOCR + Gemini)", "Lokal Deep (PaddleOCR + TrOCR)"],
+                value="Schnell (Gemini Full-Page)",
+                label="OCR Modus"
+            )
+            btn = gr.Button("🚀 OCR starten", variant="primary")
+        
+        with gr.Column():
+            file_output = gr.File(label="Durchsuchbares PDF herunterladen")
+            
+    btn.click(
+        fn=process_pdf,
+        inputs=[file_input, mode_input],
+        outputs=file_output
+    )
+
+if __name__ == "__main__":
+    demo.queue().launch(server_name="0.0.0.0", server_port=7860)

requirements.txt

@@ -10,3 +10,5 @@ pydantic
 torch
 transformers
 optimum
+gradio
+gradio_client