Upload folder using huggingface_hub

Dockerfile

@@ -0,0 +1,9 @@
+FROM python:3.10
+WORKDIR /code
+COPY packages.txt .
+RUN apt-get update && xargs -a packages.txt apt-get install -y
+COPY requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+COPY . .
+EXPOSE 7860
+CMD ["streamlit", "run", "app.py", "--server.port", "7860", "--server.address", "0.0.0.0"]

app.py

@@ -0,0 +1,718 @@
+import streamlit as st
+import fitz  # PyMuPDF
+import cv2
+import numpy as np
+import io
+import math
+from PIL import Image
+import time
+import os
+
+# WICHTIG: torch MUSS vor paddleocr importiert werden unter Windows
+import torch
+from paddleocr import PaddleOCR
+
+from google import genai
+from google.genai import types
+from pydantic import BaseModel
+
+# --- 1. Strukturierter Output definieren (Pydantic) ---
+class OCRResult(BaseModel):
+    transcriptions: list[str]
+
+class BoundingBox(BaseModel):
+    box_2d: list[int]
+    label: str
+
+api_key = "AQ.Ab8RN6K7DUqbPAcdRwV1Y-xYSH4qZOwvnUsmi1330DwbiWVSOg"
+
+# Cache die Modelle, damit sie nur bei Bedarf und nur einmal geladen werden
+@st.cache_resource
+def get_paddle_ocr():
+    return PaddleOCR(use_angle_cls=True, lang='de', show_log=False)
+
+@st.cache_resource
+def get_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
+        processor = TrOCRProcessor.from_pretrained(onnx_path)
+        model = ORTModelForVision2Seq.from_pretrained(onnx_path, provider="DMLExecutionProvider")
+        return processor, model
+    else:
+        from transformers import TrOCRProcessor, VisionEncoderDecoderModel
+        processor = TrOCRProcessor.from_pretrained('microsoft/trocr-base-handwritten')
+        model = VisionEncoderDecoderModel.from_pretrained('microsoft/trocr-base-handwritten')
+        return processor, 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:
+        # Keine Lücken -> Zeilenweises sortieren (top to bottom, left to right)
+        return sorted(boxes_with_data, key=lambda b: (b[0][1], b[0][0]))
+        
+    if max_v_gap > max_h_gap: # Spaltentrennung bevorzugen, wenn die vertikale Lücke größer ist
+        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)
+            
+    # Fallback
+    return sorted(boxes_with_data, key=lambda b: (b[0][1], b[0][0]))
+
+def main():
+    st.set_page_config(page_title="Multi-Mode Math OCR", page_icon="⚙️")
+    st.title("⚙️ Multi-Mode OCR System")
+    
+    st.info("Wähle unten deinen bevorzugten OCR-Modus aus. Jeder Modus hat seine eigenen Stärken in Bezug auf Geschwindigkeit und Ausrichtungspräzision.")
+
+    mode = st.radio(
+        "Wähle den Verarbeitungsmodus:",
+        ["Schnell (Gemini Full-Page)", "Präzise (Hybrid: PaddleOCR + Gemini)", "Lokal Deep (PaddleOCR + TrOCR)"],
+        index=0,
+        help="Schnell: Nimmt die ganze Seite auf einmal. Präzise: Zerschneidet die Seite für perfekte schräge Ausrichtung. Lokal: Ohne Cloud, nutzt lokales Modell (Microsoft)."
+    )
+
+    # Datei-Upload
+    uploaded_file = st.file_uploader("Ziehe dein PDF hierhin oder klicke zum Auswählen", type=["pdf"])
+
+    if uploaded_file is not None:
+        if st.button("🚀 OCR Starten"):
+            status_text = st.empty()
+            progress_bar = st.progress(0)
+
+            try:
+                # 1. API Clients und KI Modelle bedarfsgerecht laden
+                if "Gemini" in mode:
+                    client = genai.Client(api_key=api_key)
+                
+                if "PaddleOCR" in mode:
+                    status_text.text("Lade PaddleOCR Modell (Geometrie-KI)...")
+                    paddle_ocr = get_paddle_ocr()
+                    
+                if "Lokal Deep" in mode:
+                    status_text.text("Lade TrOCR Modell (Microsoft Deep Handwriting)... Dies kann einen Moment dauern.")
+                    trocr_processor, trocr_model = get_trocr()
+
+                # PDF laden
+                pdf_bytes = uploaded_file.read()
+                doc = fitz.open(stream=pdf_bytes, filetype="pdf")
+
+                for page_num in range(len(doc)):
+                    status_text.text(f"Verarbeite Seite {page_num + 1} von {len(doc)} (Modus: {mode})...")
+                    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 überarbeitet: Formeln als einzeilige mathematische Strings!
+                        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 = 5
+                        for attempt in range(max_retries):
+                            try:
+                                response = client.models.generate_content(
+                                    model='gemini-2.5-flash',
+                                    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)
+                                if ("503" in error_msg or "429" in error_msg) and attempt < max_retries - 1:
+                                    import re
+                                    wait_time = 45
+                                    match = re.search(r"'retryDelay':\s*'(\d+(?:\.\d+)?)s'", error_msg)
+                                    if match:
+                                        wait_time = int(float(match.group(1))) + 5
+                                    status_text.text(f"⚠️ API-Limit (Free Tier) erreicht. Warte {wait_time} Sekunden... (Versuch {attempt+2}/{max_retries})")
+                                    time.sleep(wait_time)
+                                else:
+                                    raise e
+
+                        if 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() == "." or text.strip() == "...":
+                                    continue
+
+                                x0, y0, x1, y1 = coords
+                                rect = fitz.Rect(x0, y0, x1, y1)
+
+                                text_length = fitz.get_text_length(text, fontname="helv", fontsize=1)
+                                if text_length > 0:
+                                    fontsize = rect.width / text_length
+                                    fontsize = min(fontsize, rect.height * 1.5)
+                                else:
+                                    fontsize = rect.height
+
+                                if fontsize <= 0:
+                                    continue
+
+                                y_baseline = rect.y1 + (descender * fontsize)
+                                point = fitz.Point(rect.x0, y_baseline)
+
+                                try:
+                                    page.insert_text(point, text, fontsize=fontsize, fontname="helv", render_mode=3)
+                                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)
+                                        except Exception:
+                                            pass
+
+                        # 5 Sekunden Pause, da Gemini extrem schnell ist und sonst das 15 RPM Limit knackt
+                        if page_num < len(doc) - 1:
+                            status_text.text(f"Seite {page_num + 1} fertig. Pausiere kurz (5s) wegen Free-Tier Limit...")
+                            time.sleep(5)
+
+                    # ==========================================
+                    # 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)
+
+                        status_text.text(f"Seite {page_num + 1}: PaddleOCR Geometry Analyse...")
+                        result = paddle_ocr.ocr(img_np, cls=True)
+                        paddle_boxes = [(line[0], line[1][0]) for line in result[0]] if result and result[0] else []
+                        
+                        status_text.text(f"Seite {page_num + 1}: Gemini Semantic Analyse...")
+                        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 = 5
+                        for attempt in range(max_retries):
+                            try:
+                                response = client.models.generate_content(
+                                    model='gemini-2.5-flash',
+                                    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)
+                                if ("503" in error_msg or "429" in error_msg) and attempt < max_retries - 1:
+                                    import re
+                                    wait_time = 45
+                                    match = re.search(r"'retryDelay':\s*'(\d+(?:\.\d+)?)s'", error_msg)
+                                    if match:
+                                        wait_time = int(float(match.group(1))) + 5
+                                    status_text.text(f"⚠️ API-Limit (Free Tier) erreicht. Warte {wait_time} Sekunden... (Versuch {attempt+2}/{max_retries})")
+                                    time.sleep(wait_time)
+                                else:
+                                    raise e
+
+                        if response.parsed:
+                            boxes_with_data = []
+                            for g_box in response.parsed:
+                                g_text = g_box.label
+                                if not g_text.strip() or g_text.strip() in [".", "..."]: continue
+                                
+                                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_rect = fitz.Rect(x0, y0, x1, y1)
+                                g_rects = []
+                                for g_box in response.parsed:
+                                    ymin, xmin, ymax, xmax = g_box.box_2d if not isinstance(g_box, dict) else 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
+                                            
+                                    # Weise der Paddle-Box der Gemini-Box zu, die sie am meisten überdeckt
+                                    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 if not isinstance(g_box, dict) else 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]))
+                                            
+                                        g_lines = [line.strip() for line in g_text.split('\n') if line.strip()]
+                                        
+                                        # Cluster paddle boxes that are on the same vertical line (y-threshold)
+                                        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']
+                                                # Threshold: Wenn die y-Zentren nah beieinander liegen (z.B. < 10 Pixel / zoom), gehören sie zur gleichen Zeile
+                                                if abs(y_center - c_y_center) < (10 / zoom):
+                                                    cluster['boxes'].append(pb_tuple)
+                                                    # Update cluster center
+                                                    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]})
+                                                
+                                        # Sortiere Boxen innerhalb jedes Clusters von links nach rechts
+                                        for cluster in clustered_p_boxes:
+                                            cluster['boxes'].sort(key=lambda b: min(p[0] for p in b[0]))
+                                            
+                                        # Ist es ein mehrzeiliger mathematischer Bruch?
+                                        # Brüche erkennt man daran, dass Gemini sie einzeilig ausgibt, 
+                                        # aber PaddleOCR mehrere vertikale Zeilen (Zähler, Nenner) gefunden hat.
+                                        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:
+                                            # Word-Count-Alignment
+                                            g_words = g_text.split()
+                                            word_idx = 0
+                                            
+                                            for c_idx, cluster in enumerate(clustered_p_boxes):
+                                                cluster_boxes = cluster['boxes']
+                                                
+                                                # Wie viele Wörter hat diese PaddleOCR-Reihe im Original?
+                                                cluster_word_count = sum(max(1, len(pt.split())) for pb, pt in cluster_boxes)
+                                                
+                                                # Entsprechende Anzahl Wörter von Gemini nehmen
+                                                chunk = g_words[word_idx : word_idx + cluster_word_count]
+                                                line_text = " ".join(chunk)
+                                                word_idx += cluster_word_count
+                                                
+                                                # Falls es die letzte Reihe ist, alle restlichen Wörter dranhängen (Sicherheit)
+                                                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:
+                                                    # Verschmelze horizontale Boxen (z.B. Bulletpoint + Text) präzise
+                                                    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:
+                                            # Es ist ein Bruch / Formel! Präzise Rotations-Geometrie für verschmolzene Boxen berechnen
+                                            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])
+                                                
+                                            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)]
+                                            
+                                            # Formeln werden zu einer einzigen Zeile abgeflacht, um das Zerstückeln zu verhindern
+                                            flat_text = g_text.replace('\n', '  ')
+                                            boxes_with_data.append((coords, (flat_text, pdf_baseline, box_width_pdf, box_height_pdf, angle_deg)))
+                                    else:
+                                        # Fallback
+                                        ymin, xmin, ymax, xmax = g_box.box_2d if not isinstance(g_box, dict) else 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
+                                
+                                text_length = fitz.get_text_length(text, fontname="helv", fontsize=1)
+                                if text_length > 0:
+                                    fontsize = box_width_pdf / text_length
+                                    fontsize = min(fontsize, box_height_pdf * 1.8)
+                                else:
+                                    fontsize = box_height_pdf
+                                    
+                                if fontsize <= 0: continue
+                                
+                                matrix = 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 < len(doc) - 1:
+                            status_text.text(f"Seite {page_num + 1} fertig. Pausiere kurz (5s)...")
+                            time.sleep(5)
+
+                    # ==========================================
+                    # MODUS 3: Lokal Deep (TrOCR)
+                    # ==========================================
+                    elif mode == "Lokal Deep (PaddleOCR + TrOCR)":
+                        zoom = 3.0 # Im alten Skript war der Zoom 3.0 für bessere Quali
+                        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)
+
+                        status_text.text(f"Seite {page_num + 1}: PaddleOCR Layout Analyse...")
+                        result = paddle_ocr.ocr(img_np, cls=True)
+                        
+                        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 = []
+                        
+                        # First pass: crop all images
+                        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])) # PaddleOCR Fallback-Text speichern
+                        
+                        # Batch Processing mit TrOCR
+                        BATCH_SIZE = 4 
+                        results = []
+                        
+                        status_text.text(f"Seite {page_num + 1}: TrOCR liest {len(crops)} Text-Schnipsel...")
+                        
+                        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"TrOCR batch failed, using fallback. Error: {e}")
+                                    
+                            results.extend(batch_texts)
+
+                        # Ins PDF stempeln
+                        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))
+                            
+                            # Vektor von unten (p3) nach oben (p0)
+                            dx_up = p0[0] - p3[0]
+                            dy_up = p0[1] - p3[1]
+                            
+                            font = fitz.Font("helv")
+                            shift_factor = -font.descender # ca. 0.2
+                            
+                            # Baseline-Punkt berechnen (leicht nach oben verschoben)
+                            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
+                            
+                            text_length = fitz.get_text_length(text, fontname="helv", fontsize=1)
+                            if text_length > 0:
+                                fontsize = box_width_pdf / text_length
+                                fontsize = min(fontsize, box_height_pdf * 1.5)
+                            else:
+                                fontsize = box_height_pdf
+                                
+                            if fontsize <= 0: continue
+                                
+                            matrix = 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
+
+                    progress_bar.progress((page_num + 1) / len(doc))
+
+                status_text.text("🎉 Verarbeitung komplett! PDF wird generiert...")
+                
+                out_bytes = doc.tobytes()
+                
+                st.success(f"Fertig! Dein PDF ({mode}) steht zum Download bereit.")
+                st.download_button(
+                    label="📥 Fertiges PDF herunterladen",
+                    data=out_bytes,
+                    file_name=f"searchable_{uploaded_file.name}",
+                    mime="application/pdf"
+                )
+
+            except Exception as e:
+                st.error(f"❌ Es ist ein Fehler aufgetreten: {e}")
+
+if __name__ == "__main__":
+    main()

packages.txt

@@ -0,0 +1,3 @@
+libgl1-mesa-glx
+libglib2.0-0
+libgomp1

requirements.txt

@@ -0,0 +1,12 @@
+streamlit
+PyMuPDF
+opencv-python-headless
+numpy
+Pillow
+paddlepaddle
+paddleocr
+google-genai
+pydantic
+torch
+transformers
+optimum