Update app.py

app.py

@@ -9,11 +9,10 @@ import threading
 from queue import Queue
 import zipfile
 from datetime import datetime
-import matplotlib.pyplot as plt
+
 import matplotlib
-matplotlib.use('Agg')  # 使用非交互式后端
-from io import BytesIO
-import base64
+matplotlib.use('Agg')
+import matplotlib.pyplot as plt
 
 from detection_ocr import DetectionOCR
 from repair_head import RepairHead
@@ -35,21 +34,18 @@ _semantic = None
 def get_ocr():
     global _ocr
     if _ocr is None:
-        print("[INIT] Loading DetectionOCR")
         _ocr = DetectionOCR(device=DEVICE)
     return _ocr
 
 def get_repair():
     global _repair
     if _repair is None:
-        print("[INIT] Loading RepairHead (CPU)")
         _repair = RepairHead(device="cpu")
     return _repair
 
 def get_semantic():
     global _semantic
     if _semantic is None:
-        print("[INIT] Loading Semantic Evaluation Pipeline")
         _semantic = SemanticEvaluationPipeline(
             base_model="Qwen/Qwen2.5-Math-1.5B-Instruct",
             lora_dir=None,
@@ -66,10 +62,6 @@ def wrap_equation(expr: str) -> str:
     expr = expr.strip()
     if any(expr.startswith(f"\\begin{{{e}}}") for e in KNOWN_ENV):
         return expr
-    if expr.startswith("$$") and expr.endswith("$$"):
-        return expr
-    if expr.startswith("\\[") and expr.endswith("\\]"):
-        return expr
     return f"\\begin{{equation}}\n{expr}\n\\end{{equation}}"
 
 def is_reasonable(expr: str) -> bool:
@@ -77,820 +69,248 @@ def is_reasonable(expr: str) -> bool:
         return False
     if expr.lower() in ["noise", "error"]:
         return False
-    if len(expr) < 3 or len(expr) > 2000:
-        return False
-    return True
+    return 3 <= len(expr) <= 2000
 
 def save_progress_log(outdir: Path, stage: str, content: str):
-    """Save progress logs to files"""
     log_file = outdir / f"{stage}_log.txt"
     with open(log_file, "a", encoding="utf-8") as f:
-        timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
-        f.write(f"[{timestamp}] {content}\n")
+        f.write(f"[{datetime.now()}] {content}\n")
+
+# ============================================================
+# Formula Rendering (FIXED: no usetex)
+# ============================================================
+def render_formula_to_image(formula: str, output_path: Path):
+    try:
+        fig, ax = plt.subplots(figsize=(8, 2))
+        ax.text(
+            0.5, 0.5,
+            f"${formula}$",          # mathtext
+            ha='center', va='center',
+            fontsize=16
+        )
+        ax.axis('off')
+        plt.tight_layout()
+        plt.savefig(output_path, dpi=150, bbox_inches='tight', pad_inches=0.1)
+        plt.close(fig)
+        return True
+    except Exception as e:
+        print("[Render Error]", e)
+        return False
 
+# ============================================================
+# Visualization PDF (ASCII SAFE)
+# ============================================================
 def create_visualization_pdf(outdir: Path, repaired_data: dict, semantic_results: list):
-    """创建可视化PDF，按页面顺序显示公式"""
     try:
         from fpdf import FPDF
-        import matplotlib.pyplot as plt
-        import matplotlib
-        matplotlib.use('Agg')
-        from io import BytesIO
-        import base64
-        
+
         pdf = FPDF()
         pdf.set_auto_page_break(auto=True, margin=15)
-        
-        # 添加标题页
         pdf.add_page()
-        pdf.set_font('Arial', 'B', 16)
-        pdf.cell(0, 10, 'PDF Formula Processing Results', 0, 1, 'C')
-        pdf.ln(10)
-        
-        pdf.set_font('Arial', '', 12)
-        pdf.cell(0, 10, f'Generated: {datetime.now().strftime("%Y-%m-%d %H:%M:%S")}', 0, 1, 'C')
-        pdf.ln(20)
-        
-        # 按页面处理
-        page_keys = sorted(repaired_data.keys(), key=lambda x: int(re.search(r'page_(\d+)', x).group(1)) if re.search(r'page_(\d+)', x) else 0)
-        
-        for page_key in page_keys:
-            formulas = repaired_data[page_key]
-            valid_formulas = [f for f in formulas if f['repaired'] not in ['noise', 'error']]
-            
-            if not valid_formulas:
+        pdf.set_font("Arial", size=14)
+        pdf.cell(0, 10, "PDF Formula Processing Results", ln=1, align="C")
+        pdf.ln(5)
+
+        def page_num(k):
+            m = re.search(r'page_(\d+)', k)
+            return int(m.group(1)) if m else 0
+
+        for page in sorted(repaired_data.keys(), key=page_num):
+            formulas = repaired_data[page]
+            valid = [f for f in formulas if f["repaired"] not in ["noise", "error"]]
+            if not valid:
                 continue
-            
+
             pdf.add_page()
-            pdf.set_font('Arial', 'B', 14)
-            pdf.cell(0, 10, f'{page_key.upper()}', 0, 1, 'L')
-            pdf.ln(5)
-            
-            for idx, formula_data in enumerate(valid_formulas[:20]):  # 每页最多20个公式
-                formula = formula_data['repaired']
-                original = formula_data['raw_latex'][:100] + "..." if len(formula_data['raw_latex']) > 100 else formula_data['raw_latex']
-                
-                # 添加公式信息
-                pdf.set_font('Arial', 'I', 10)
-                pdf.cell(0, 5, f'Formula {idx+1}:', 0, 1, 'L')
-                
-                pdf.set_font('Courier', '', 8)
-                pdf.multi_cell(0, 4, f'Original: {original}', 0, 'L')
-                pdf.multi_cell(0, 4, f'Repaired: {formula[:100]}{"..." if len(formula) > 100 else ""}', 0, 'L')
-                
-                # 查找对应的语义结果
-                sem_result = None
-                for sem in semantic_results:
-                    if sem.get('original_formula') == formula_data['raw_latex'] or sem.get('fixed_formula') == formula:
-                        sem_result = sem
-                        break
-                
-                if sem_result:
-                    verdict = sem_result.get('semantic_verdict', 'unknown')
-                    confidence = sem_result.get('confidence', 0)
-                    pdf.set_font('Arial', '', 9)
-                    pdf.cell(0, 5, f'Verdict: {verdict} (Confidence: {confidence:.2f})', 0, 1, 'L')
-                
-                pdf.ln(2)
-                
-                # 每5个公式后添加分隔线
-                if (idx + 1) % 5 == 0 and idx + 1 < len(valid_formulas):
-                    pdf.line(10, pdf.get_y(), 200, pdf.get_y())
-                    pdf.ln(5)
-        
-        # 添加统计页
-        pdf.add_page()
-        pdf.set_font('Arial', 'B', 16)
-        pdf.cell(0, 10, 'Processing Statistics', 0, 1, 'C')
-        pdf.ln(10)
-        
-        total_pages = len(repaired_data)
-        total_formulas = sum(len(page_data) for page_data in repaired_data.values())
-        valid_formulas = sum(len([f for f in page_data if f['repaired'] not in ['noise', 'error']]) 
-                           for page_data in repaired_data.values())
-        
-        stats = [
-            ("Total Pages Processed", str(total_pages)),
-            ("Total Formulas Detected", str(total_formulas)),
-            ("Valid Formulas Repaired", str(valid_formulas)),
-            ("Semantic Evaluations", str(len(semantic_results))),
-        ]
-        
-        pdf.set_font('Arial', '', 12)
-        for label, value in stats:
-            pdf.cell(90, 8, f'{label}:', 0, 0, 'R')
-            pdf.set_font('Arial', 'B', 12)
-            pdf.cell(0, 8, f' {value}', 0, 1, 'L')
-            pdf.set_font('Arial', '', 12)
-            pdf.ln(2)
-        
-        # 保存PDF
-        pdf_path = outdir / "visualization_report.pdf"
-        pdf.output(str(pdf_path))
-        
-        return pdf_path
-        
-    except Exception as e:
-        print(f"Error creating visualization PDF: {e}")
-        return None
+            pdf.set_font("Arial", "B", 12)
+            pdf.cell(0, 8, page, ln=1)
 
-def render_formula_to_image(formula: str, output_path: Path):
-    """将LaTeX公式渲染为图像"""
-    try:
-        import matplotlib.pyplot as plt
-        import matplotlib
-        matplotlib.use('Agg')
-        from matplotlib import rcParams
-        
-        # 配置matplotlib使用LaTeX
-        rcParams['text.usetex'] = True
-        rcParams['font.family'] = 'serif'
-        rcParams['font.size'] = 14
-        
-        # 创建图形
-        fig, ax = plt.subplots(figsize=(8, 2))
-        ax.text(0.5, 0.5, f'${formula}$', 
-                fontsize=16, 
-                ha='center', 
-                va='center',
-                usetex=True)
-        
-        ax.axis('off')
-        plt.tight_layout()
-        
-        # 保存图像
-        plt.savefig(str(output_path), dpi=150, bbox_inches='tight', pad_inches=0.1)
-        plt.close(fig)
-        
-        return True
+            pdf.set_font("Courier", size=8)
+            for i, f in enumerate(valid[:20]):
+                pdf.multi_cell(0, 4, f"[{i+1}] {f['repaired'][:200]}")
+                pdf.ln(1)
+
+        out = outdir / "visualization_report.pdf"
+        pdf.output(str(out))
+        return out
     except Exception as e:
-        print(f"Error rendering formula: {e}")
-        # 如果LaTeX渲染失败，使用文本模式
-        try:
-            fig, ax = plt.subplots(figsize=(8, 2))
-            ax.text(0.5, 0.5, formula, 
-                    fontsize=14, 
-                    ha='center', 
-                    va='center',
-                    fontfamily='monospace',
-                    wrap=True)
-            
-            ax.axis('off')
-            plt.tight_layout()
-            plt.savefig(str(output_path), dpi=150, bbox_inches='tight', pad_inches=0.1)
-            plt.close(fig)
-            return True
-        except Exception as e2:
-            print(f"Fallback rendering also failed: {e2}")
-            return False
-
-def create_formula_images(outdir: Path, repaired_data: dict):
-    """为所有公式创建图像文件"""
-    images_dir = outdir / "formula_images"
-    images_dir.mkdir(exist_ok=True)
-    
-    image_paths = []
-    
-    for page_idx, (page, formulas) in enumerate(repaired_data.items()):
-        page_images_dir = images_dir / page
-        page_images_dir.mkdir(exist_ok=True)
-        
-        for idx, formula_data in enumerate(formulas):
-            if formula_data['repaired'] in ['noise', 'error']:
-                continue
-            
-            formula = formula_data['repaired']
-            image_path = page_images_dir / f"formula_{idx+1}.png"
-            
-            if render_formula_to_image(formula, image_path):
-                image_paths.append({
-                    'page': page,
-                    'formula_idx': idx + 1,
-                    'formula': formula,
-                    'image_path': str(image_path),
-                    'relative_path': f"{page}/formula_{idx+1}.png"
-                })
-    
-    # 创建索引文件
-    if image_paths:
-        index_path = images_dir / "index.json"
-        with open(index_path, 'w', encoding='utf-8') as f:
-            json.dump(image_paths, f, indent=2, ensure_ascii=False)
-    
-    return image_paths
+        print("[PDF Error]", e)
+        return None
 
 # ============================================================
-# Stream Manager for Real-time Updates
+# Stream Manager
 # ============================================================
 class StreamManager:
-    """Manage real-time streaming to multiple outputs"""
     def __init__(self):
         self.ocr_queue = Queue()
         self.repair_queue = Queue()
         self.semantic_queue = Queue()
         self.summary_queue = Queue()
-        
-    def ocr_stream(self, message: str):
-        self.ocr_queue.put(message)
-        if hasattr(self, 'current_outdir'):
-            save_progress_log(self.current_outdir, "ocr", message)
-        
-    def repair_stream(self, message: str):
-        self.repair_queue.put(message)
-        if hasattr(self, 'current_outdir'):
-            save_progress_log(self.current_outdir, "repair", message)
-        
-    def semantic_stream(self, message: str):
-        self.semantic_queue.put(message)
-        if hasattr(self, 'current_outdir'):
-            save_progress_log(self.current_outdir, "semantic", message)
-        
-    def summary_stream(self, message: str):
-        self.summary_queue.put(message)
-        if hasattr(self, 'current_outdir'):
-            save_progress_log(self.current_outdir, "summary", message)
-        
+        self.current_outdir = None
+
     def set_output_dir(self, outdir: Path):
         self.current_outdir = outdir
 
+    def _push(self, q: Queue, stage: str, msg: str):
+        q.put(msg)
+        if self.current_outdir:
+            save_progress_log(self.current_outdir, stage, msg)
+
+    def ocr_stream(self, msg): self._push(self.ocr_queue, "ocr", msg)
+    def repair_stream(self, msg): self._push(self.repair_queue, "repair", msg)
+    def semantic_stream(self, msg): self._push(self.semantic_queue, "semantic", msg)
+    def summary_stream(self, msg): self._push(self.summary_queue, "summary", msg)
+
 # ============================================================
-# Main Processing Pipeline
+# Main Pipeline
 # ============================================================
 def process_pipeline(pdf_file, stream_mgr: StreamManager):
-    """Main processing pipeline with streaming to different outputs"""
-    
-    if pdf_file is None:
-        stream_mgr.summary_stream("❌ No PDF uploaded.")
-        return None, None, None, None, None, None, []
-    
-    try:
-        # Create output directory
-        timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
-        tmpdir = Path(tempfile.mkdtemp(prefix=f"pdf_pipeline_{timestamp}_"))
-        outdir = tmpdir / "output"
-        outdir.mkdir(exist_ok=True)
-        
-        stream_mgr.set_output_dir(outdir)
-        
-        stream_mgr.summary_stream(f"📁 Output directory: {outdir}")
-        stream_mgr.summary_stream("=" * 60)
-        
-        # ============ STAGE 1: OCR ============
-        stream_mgr.ocr_stream("🚀 STAGE 1: OCR Detection Started")
-        stream_mgr.ocr_stream("Loading OCR model...")
-        
-        ocr = get_ocr()
-        stream_mgr.ocr_stream("Processing PDF pages...")
-        
-        ocr.process_pdf(pdf_file, output_dir=outdir)
-        
-        stream_mgr.ocr_stream("✅ OCR Processing Completed")
-        stream_mgr.summary_stream("✓ Stage 1: OCR completed")
-        
-        # ============ STAGE 2: Merge Results ============
-        stream_mgr.ocr_stream("\n🔄 Merging page results...")
-        
-        merged = {}
-        page_files = sorted(outdir.glob("page_*_results.json"))
-        
-        if not page_files:
-            stream_mgr.ocr_stream("❌ No page results found!")
-            stream_mgr.summary_stream("❌ Error: No page results found")
-            return None, None, None, None, None, None, []
-        
-        for p in page_files:
-            m = re.search(r"(page_\d+)_results\.json", p.name)
-            if not m:
-                continue
-            page = m.group(1)
+
+    timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+    outdir = Path(tempfile.mkdtemp(prefix=f"pdf_pipeline_{timestamp}_"))
+    stream_mgr.set_output_dir(outdir)
+
+    # ---------- OCR ----------
+    stream_mgr.ocr_stream("Starting OCR...")
+    ocr = get_ocr()
+    ocr.process_pdf(pdf_file, output_dir=outdir)
+
+    merged = {}
+    for p in sorted(outdir.glob("page_*_results.json")):
+        page = p.stem.replace("_results", "")
+        data = json.loads(p.read_text("utf-8"))
+        merged[page] = data.get("formulas", [])
+
+    # ---------- Repair ----------
+    stream_mgr.repair_stream("Starting Repair...")
+    repair = get_repair()
+
+    repaired_all = {}
+    repaired_eqs = []
+
+    for page, formulas in merged.items():
+        repaired_all[page] = []
+        for f in formulas:
+            raw = f.get("raw_latex", "")
             try:
-                data = json.loads(p.read_text("utf-8"))
-                formulas = data.get("formulas", [])
-                merged[page] = {
-                    "formulas": formulas,
-                    "total": len(formulas)
-                }
-                stream_mgr.ocr_stream(f"  {page}: {len(formulas)} formulas")
-            except Exception as e:
-                stream_mgr.ocr_stream(f"  ⚠️ Error loading {page}: {str(e)}")
-                merged[page] = {"formulas": [], "total": 0}
-        
-        # Save overall OCR results
-        overall_json = outdir / "overall_ocr_results.json"
-        overall_json.write_text(json.dumps(merged, indent=2), "utf-8")
-        
-        stream_mgr.ocr_stream(f"✅ Saved: {overall_json.name}")
-        stream_mgr.summary_stream(f"✓ Stage 2: Merged {len(merged)} pages")
-        
-        # ============ STAGE 3: Repair Formulas ============
-        stream_mgr.repair_stream("🔧 STAGE 3: LaTeX Repair Started")
-        stream_mgr.repair_stream("Loading Repair model...")
-        
-        repair = get_repair()
-        
-        repaired_all = {}
-        repaired_eqs = []
-        total_formulas = sum(v["total"] for v in merged.values())
-        
-        stream_mgr.repair_stream(f"Total formulas to repair: {total_formulas}")
-        stream_mgr.repair_stream("=" * 40)
-        
-        processed = 0
-        for page, content in merged.items():
-            stream_mgr.repair_stream(f"\n📄 Processing {page}:")
-            repaired_all[page] = []
-            
-            for i, fm in enumerate(content["formulas"]):
-                processed += 1
-                raw = fm.get("raw_latex", "")
-                
-                # Show progress every 5 formulas or first/last
-                if processed <= 5 or processed >= total_formulas - 5 or processed % 10 == 0:
-                    raw_preview = raw[:100] + "..." if len(raw) > 100 else raw
-                    stream_mgr.repair_stream(f"  [{processed}/{total_formulas}] {raw_preview}")
-                
-                try:
-                    repaired = repair.repair(raw)
-                    
-                    if is_reasonable(repaired):
-                        repaired_all[page].append({
-                            "raw_latex": raw,
-                            "repaired": repaired
-                        })
-                        repaired_eqs.append(repaired)
-                        if processed <= 3:  # Show first few repairs
-                            stream_mgr.repair_stream(f"    → {repaired[:80]}...")
-                    else:
-                        repaired_all[page].append({
-                            "raw_latex": raw,
-                            "repaired": "noise"
-                        })
-                except Exception as e:
+                fixed = repair.repair(raw)
+                if is_reasonable(fixed):
                     repaired_all[page].append({
                         "raw_latex": raw,
-                        "repaired": f"error: {str(e)}"
+                        "repaired": fixed
                     })
-                    stream_mgr.repair_stream(f"    ⚠️ Error: {str(e)}")
-        
-        # Save repaired results
-        repaired_json = outdir / "overall_ocr_repaired.json"
-        repaired_json.write_text(json.dumps(repaired_all, indent=2), "utf-8")
-        
-        stream_mgr.repair_stream(f"\n✅ Repair completed: {len(repaired_eqs)} valid formulas")
-        stream_mgr.summary_stream(f"✓ Stage 3: Repaired {len(repaired_eqs)}/{total_formulas} formulas")
-        
-        # ============ STAGE 4: Semantic Evaluation ============
-        stream_mgr.semantic_stream("🧠 STAGE 4: Semantic Evaluation Started")
-        stream_mgr.semantic_stream("Loading Semantic model...")
-        
-        semantic = get_semantic()
-        
-        semantic_results = []
-        stream_mgr.semantic_stream(f"Evaluating {len(repaired_eqs)} formulas...")
-        stream_mgr.semantic_stream("=" * 40)
-        
-        for i, eq in enumerate(repaired_eqs):
-            try:
-                # Show progress
-                if i < 3 or i >= len(repaired_eqs) - 3 or i % 5 == 0:
-                    eq_preview = eq[:80] + "..." if len(eq) > 80 else eq
-                    stream_mgr.semantic_stream(f"[{i+1}/{len(repaired_eqs)}] {eq_preview}")
-                
-                res = semantic.evaluate_formula(eq)
-                res['original_formula'] = eq  # 添加原始公式
-                semantic_results.append(res)
-                
-                # Show verdict for first few
-                if i < 5:
-                    stream_mgr.semantic_stream(f"    Verdict: {res.get('semantic_verdict', 'unknown')}")
-                    stream_mgr.semantic_stream(f"    Confidence: {res.get('confidence', 0):.2f}")
-                
+                    repaired_eqs.append((raw, fixed))
+                else:
+                    repaired_all[page].append({"raw_latex": raw, "repaired": "noise"})
             except Exception as e:
-                stream_mgr.semantic_stream(f"⚠️ Error evaluating formula {i+1}: {str(e)}")
-                semantic_results.append({
-                    'original_formula': eq,
-                    'error': str(e),
-                    'semantic_verdict': 'evaluation_error',
-                    'confidence': 0.0
-                })
-        
-        # Save semantic results
-        semantic_json = outdir / "semantic_results.json"
-        semantic_json.write_text(json.dumps(semantic_results, indent=2), "utf-8")
-        
-        stream_mgr.semantic_stream(f"\n✅ Semantic evaluation completed: {len(semantic_results)} formulas")
-        stream_mgr.summary_stream(f"✓ Stage 4: Semantically evaluated {len(semantic_results)} formulas")
-        
-        # ============ STAGE 5: Generate Visualization Files ============
-        stream_mgr.summary_stream("\n📊 Generating visualization files...")
-        
-        # 1. Generate LaTeX file
-        merge_tex = outdir / "merge.tex"
-        with merge_tex.open("w", encoding="utf-8") as f:
-            f.write("\\documentclass{article}\n")
-            f.write("\\usepackage{amsmath, amssymb, bm}\n")
-            f.write("\\begin{document}\n\n")
-            f.write("% Auto-generated from PDF formula extraction pipeline\n")
-            f.write("% Generated on: " + datetime.now().strftime("%Y-%m-%d %H:%M:%S") + "\n\n")
-            for eq in repaired_eqs:
-                f.write(wrap_equation(eq) + "\n\n")
-            f.write("\\end{document}\n")
-        
-        stream_mgr.summary_stream("✓ Generated LaTeX file")
-        
-        # 2. Create visualization PDF
-        stream_mgr.summary_stream("Creating visualization PDF...")
-        visualization_pdf = create_visualization_pdf(outdir, repaired_all, semantic_results)
-        
-        if visualization_pdf and visualization_pdf.exists():
-            stream_mgr.summary_stream(f"✓ Created visualization PDF: {visualization_pdf.name}")
-        else:
-            stream_mgr.summary_stream("⚠️ Could not create visualization PDF")
-            visualization_pdf = None
-        
-        # 3. Create formula images
-        stream_mgr.summary_stream("Rendering formula images...")
-        formula_images = create_formula_images(outdir, repaired_all)
-        
-        if formula_images:
-            # Create zip of formula images
-            images_zip = outdir / "formula_images.zip"
-            with zipfile.ZipFile(images_zip, 'w') as zf:
-                for img_info in formula_images:
-                    img_path = Path(img_info['image_path'])
-                    if img_path.exists():
-                        zf.write(img_path, img_info['relative_path'])
-            
-            stream_mgr.summary_stream(f"✓ Created {len(formula_images)} formula images")
-        else:
-            images_zip = None
-            stream_mgr.summary_stream("⚠️ No formula images created")
-        
-        # ============ STAGE 6: Generate Statistics ============
-        stats = {
-            "total_pages": len(merged),
-            "total_formulas": total_formulas,
-            "repaired_formulas": len(repaired_eqs),
-            "semantic_evaluated": len(semantic_results),
-            "output_directory": str(outdir),
-            "processing_time": datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
-            "formula_images_count": len(formula_images) if formula_images else 0
-        }
-        
-        stats_json = outdir / "processing_stats.json"
-        stats_json.write_text(json.dumps(stats, indent=2), "utf-8")
-        
-        # Final summary
-        stream_mgr.summary_stream("=" * 60)
-        stream_mgr.summary_stream("🎉 PROCESSING COMPLETED SUCCESSFULLY!")
-        stream_mgr.summary_stream("=" * 60)
-        stream_mgr.summary_stream(f"📊 SUMMARY STATISTICS:")
-        stream_mgr.summary_stream(f"  • Pages processed: {len(merged)}")
-        stream_mgr.summary_stream(f"  • Formulas detected: {total_formulas}")
-        stream_mgr.summary_stream(f"  • Formulas repaired: {len(repaired_eqs)}")
-        stream_mgr.summary_stream(f"  • Formulas evaluated: {len(semantic_results)}")
-        stream_mgr.summary_stream(f"  • Formula images: {len(formula_images) if formula_images else 0}")
-        stream_mgr.summary_stream(f"  • Output directory: {outdir}")
-        stream_mgr.summary_stream("=" * 60)
-        stream_mgr.summary_stream("📁 Generated files:")
-        stream_mgr.summary_stream(f"  1. {overall_json.name} - OCR results")
-        stream_mgr.summary_stream(f"  2. {repaired_json.name} - Repaired formulas")
-        stream_mgr.summary_stream(f"  3. {semantic_json.name} - Semantic evaluation")
-        stream_mgr.summary_stream(f"  4. {merge_tex.name} - Combined LaTeX")
-        if visualization_pdf:
-            stream_mgr.summary_stream(f"  5. {visualization_pdf.name} - Visualization PDF")
-        if images_zip:
-            stream_mgr.summary_stream(f"  6. {images_zip.name} - Formula images")
-        stream_mgr.summary_stream(f"  7. {stats_json.name} - Processing statistics")
-        stream_mgr.summary_stream("=" * 60)
-        
-        return overall_json, repaired_json, semantic_json, merge_tex, visualization_pdf, images_zip, semantic_results
-        
-    except Exception as e:
-        import traceback
-        error_msg = f" CRITICAL ERROR:\n{str(e)}\n\nTraceback:\n{traceback.format_exc()}"
-        stream_mgr.summary_stream(error_msg)
-        return None, None, None, None, None, None, []
+                repaired_all[page].append({"raw_latex": raw, "repaired": "error"})
+
+    # ---------- Semantic ----------
+    stream_mgr.semantic_stream("Starting Semantic Evaluation...")
+    semantic = get_semantic()
+
+    semantic_results = []
+    for raw, fixed in repaired_eqs:
+        try:
+            res = semantic.evaluate_formula(fixed)
+            res["raw_latex"] = raw          # <<< FIX
+            res["repaired_latex"] = fixed   # <<< FIX
+            semantic_results.append(res)
+        except Exception as e:
+            semantic_results.append({
+                "raw_latex": raw,
+                "repaired_latex": fixed,
+                "semantic_verdict": "error",
+                "confidence": 0.0
+            })
+
+    # ---------- Save ----------
+    (outdir / "repaired.json").write_text(json.dumps(repaired_all, indent=2), "utf-8")
+    (outdir / "semantic.json").write_text(json.dumps(semantic_results, indent=2), "utf-8")
+
+    tex = outdir / "merge.tex"
+    with tex.open("w", encoding="utf-8") as f:
+        f.write("\\documentclass{article}\n\\usepackage{amsmath}\n\\begin{document}\n")
+        for _, eq in repaired_eqs:
+            f.write(wrap_equation(eq) + "\n\n")
+        f.write("\\end{document}")
+
+    pdf = create_visualization_pdf(outdir, repaired_all, semantic_results)
+
+    return outdir, tex, pdf, semantic_results
 
 # ============================================================
-# Simplified Streaming Handler
+# Streaming Wrapper
 # ============================================================
 def process_with_streaming(pdf_file):
-    """Simplified streaming handler without threading issues"""
-    if not pdf_file:
-        yield "", "", "", "❌ No PDF uploaded", "Error", None, None, None, None, None, None, []
-        return
-    
-    # Initialize stream manager
+
     stream_mgr = StreamManager()
-    
-    # Initialize result variables
-    result_container = {
-        'overall_json': None,
-        'repaired_json': None,
-        'semantic_json': None,
-        'merge_tex': None,
-        'visualization_pdf': None,
-        'images_zip': None,
-        'sem_results': []
-    }
-    
-    # Process function
-    def run_processing():
-        """Run the pipeline and store results"""
-        results = process_pipeline(pdf_file, stream_mgr)
-        if results:
-            result_container['overall_json'] = results[0]
-            result_container['repaired_json'] = results[1]
-            result_container['semantic_json'] = results[2]
-            result_container['merge_tex'] = results[3]
-            result_container['visualization_pdf'] = results[4]
-            result_container['images_zip'] = results[5]
-            result_container['sem_results'] = results[6]
-    
-    # Start processing in a thread
-    process_thread = threading.Thread(target=run_processing)
-    process_thread.start()
-    
-    # Initialize log contents
-    ocr_log_content = ""
-    repair_log_content = ""
-    semantic_log_content = ""
-    summary_log_content = ""
-    
-    # Stream updates while processing
-    last_update = time.time()
-    while process_thread.is_alive():
-        # Collect new messages
-        while not stream_mgr.ocr_queue.empty():
-            ocr_log_content += stream_mgr.ocr_queue.get() + "\n"
-        
-        while not stream_mgr.repair_queue.empty():
-            repair_log_content += stream_mgr.repair_queue.get() + "\n"
-        
-        while not stream_mgr.semantic_queue.empty():
-            semantic_log_content += stream_mgr.semantic_queue.get() + "\n"
-        
-        while not stream_mgr.summary_queue.empty():
-            summary_log_content += stream_mgr.summary_queue.get() + "\n"
-        
-        # Update UI periodically
-        current_time = time.time()
-        if current_time - last_update > 0.1:
-            yield (
-                ocr_log_content[-5000:],  # Limit size
-                repair_log_content[-5000:],
-                semantic_log_content[-5000:],
-                summary_log_content[-5000:],
-                "Processing...",
-                None, None, None, None, None, None, []
-            )
-            last_update = current_time
-        
-        time.sleep(0.05)
-    
-    # Wait for thread to complete
-    process_thread.join()
-    
-    # Collect any remaining messages
-    while not stream_mgr.ocr_queue.empty():
-        ocr_log_content += stream_mgr.ocr_queue.get() + "\n"
-    
-    while not stream_mgr.repair_queue.empty():
-        repair_log_content += stream_mgr.repair_queue.get() + "\n"
-    
-    while not stream_mgr.semantic_queue.empty():
-        semantic_log_content += stream_mgr.semantic_queue.get() + "\n"
-    
-    while not stream_mgr.summary_queue.empty():
-        summary_log_content += stream_mgr.summary_queue.get() + "\n"
-    
-    # Prepare download files
-    ocr_file = str(result_container['overall_json']) if result_container['overall_json'] else None
-    repair_file = str(result_container['repaired_json']) if result_container['repaired_json'] else None
-    semantic_file = str(result_container['semantic_json']) if result_container['semantic_json'] else None
-    tex_file = str(result_container['merge_tex']) if result_container['merge_tex'] else None
-    pdf_file_dl = str(result_container['visualization_pdf']) if result_container['visualization_pdf'] else None
-    images_file = str(result_container['images_zip']) if result_container['images_zip'] else None
-    
-    # Final update
+    result = {}
+
+    def runner():
+        out = process_pipeline(pdf_file, stream_mgr)
+        result["data"] = out
+
+    t = threading.Thread(target=runner)
+    t.start()
+
+    logs = {"ocr": "", "repair": "", "semantic": "", "summary": ""}
+
+    while t.is_alive():
+        for k, q in [
+            ("ocr", stream_mgr.ocr_queue),
+            ("repair", stream_mgr.repair_queue),
+            ("semantic", stream_mgr.semantic_queue),
+            ("summary", stream_mgr.summary_queue),
+        ]:
+            while not q.empty():
+                logs[k] += q.get() + "\n"
+
+        yield (
+            logs["ocr"][-5000:],
+            logs["repair"][-5000:],
+            logs["semantic"][-5000:],
+            logs["summary"][-5000:],
+            "Processing...",
+            None, None, None
+        )
+        time.sleep(0.1)
+
+    outdir, tex, pdf, sem = result["data"]
+
     yield (
-        ocr_log_content[-10000:],
-        repair_log_content[-10000:],
-        semantic_log_content[-10000:],
-        summary_log_content[-10000:],
+        logs["ocr"],
+        logs["repair"],
+        logs["semantic"],
+        logs["summary"],
         "Completed",
-        ocr_file,
-        repair_file,
-        semantic_file,
-        tex_file,
-        pdf_file_dl,
-        images_file,
-        result_container['sem_results']
+        str(tex),
+        str(pdf) if pdf else None,
+        sem
     )
 
 # ============================================================
-# Gradio UI with Multi-Stream Display
+# Gradio UI（基本不动）
 # ============================================================
-with gr.Blocks(title="PDF2TEX Formula", theme=gr.themes.Soft()) as demo:
-    gr.Markdown("""
-    # 📘 PDF2TEX Formula Pipeline
-    **A Lightweight Pipeline for Extracting and Repairing Mathematical Formulas from Raw PDFs**
-    """)
-    
-    # Input Section
-    with gr.Row():
-        with gr.Column(scale=1):
-            gr.Markdown("### Upload PDF")
-            pdf_input = gr.File(
-                label="Upload PDF File",
-                file_types=[".pdf"],
-                height=100
-            )
-            
-            with gr.Row():
-                run_btn = gr.Button("Start Processing", variant="primary", size="lg")
-                clear_btn = gr.Button("Clear All", variant="secondary")
-            
-            gr.Markdown("### Processing Status")
-            status_text = gr.Textbox(
-                label="Current Status",
-                value="Ready",
-                interactive=False
-            )
-    
-    # Multi-Stream Display Section
-    gr.Markdown("### 🎯 Real-time Processing Logs")
-    
-    with gr.Tabs():
-        with gr.TabItem("📄 OCR Process"):
-            ocr_log = gr.Textbox(
-                label="OCR Stage Log",
-                lines=15,
-                interactive=False,
-                autoscroll=True
-            )
-        
-        with gr.TabItem("🔧 Repair Process"):
-            repair_log = gr.Textbox(
-                label="Repair Stage Log",
-                lines=15,
-                interactive=False,
-                autoscroll=True
-            )
-        
-        with gr.TabItem("🧠 Semantic Process"):
-            semantic_log = gr.Textbox(
-                label="Semantic Stage Log",
-                lines=15,
-                interactive=False,
-                autoscroll=True
-            )
-        
-        with gr.TabItem("📊 Summary"):
-            summary_log = gr.Textbox(
-                label="Processing Summary",
-                lines=20,
-                interactive=False,
-                autoscroll=True
-            )
-    
-    # Results Download Section
-    gr.Markdown("### 📥 Download Results")
-    
-    with gr.Row():
-        with gr.Column(scale=1):
-            ocr_json_dl = gr.File(label="OCR Results (JSON)", visible=True)
-            repaired_json_dl = gr.File(label="Repaired Formulas (JSON)", visible=True)
-        
-        with gr.Column(scale=1):
-            semantic_json_dl = gr.File(label="Semantic Results (JSON)", visible=True)
-            merge_tex_dl = gr.File(label="Combined LaTeX (.tex)", visible=True)
-    
-    with gr.Row():
-        with gr.Column(scale=1):
-            visualization_pdf_dl = gr.File(label="Visualization PDF", visible=True)
-        
-        with gr.Column(scale=1):
-            formula_images_dl = gr.File(label="Formula Images (.zip)", visible=True)
-    
-    # Hidden state for semantic results
-    semantic_state = gr.State([])
-    
-    # Formula Preview Section
-    gr.Markdown("### 🔍 Formula Preview")
-    
-    with gr.Row():
-        formula_idx = gr.Number(
-            label="Formula Index",
-            minimum=0,
-            maximum=1000,
-            step=1,
-            precision=0,
-            value=0
-        )
-        preview_btn = gr.Button("Preview Formula", variant="secondary")
-    
-    formula_preview = gr.Image(label="Formula Visualization", height=200)
-    formula_info = gr.JSON(label="Formula Details")
-    
-    # Preview function
-    def preview_formula(idx, sem_results):
-        if not sem_results or idx < 0 or idx >= len(sem_results):
-            return None, {}
-        
-        result = sem_results[int(idx)]
-        
-        # Try to find the formula image
-        formula = result.get('original_formula', '')
-        if formula:
-            # Create temporary image
-            temp_dir = Path(tempfile.mkdtemp())
-            img_path = temp_dir / f"formula_{idx}.png"
-            
-            if render_formula_to_image(formula, img_path) and img_path.exists():
-                return str(img_path), result
-            else:
-                # If rendering fails, return empty
-                return None, result
-        
-        return None, result
-    
-    # Clear function
-    def clear_all():
-        return [
-            None,  # pdf_input
-            "",    # ocr_log
-            "",    # repair_log
-            "",    # semantic_log
-            "",    # summary_log
-            "Ready",  # status_text
-            None,  # ocr_json_dl
-            None,  # repaired_json_dl
-            None,  # semantic_json_dl
-            None,  # merge_tex_dl
-            None,  # visualization_pdf_dl
-            None,  # formula_images_dl
-            [],    # semantic_state
-            0,     # formula_idx
-            None,  # formula_preview
-            {}     # formula_info
-        ]
-    
-    # Connect events
-    outputs = [
-        ocr_log,
-        repair_log,
-        semantic_log,
-        summary_log,
-        status_text,
-        ocr_json_dl,
-        repaired_json_dl,
-        semantic_json_dl,
-        merge_tex_dl,
-        visualization_pdf_dl,
-        formula_images_dl,
-        semantic_state
-    ]
-    
-    run_btn.click(
-        fn=process_with_streaming,
-        inputs=[pdf_input],
-        outputs=outputs
-    )
-    
-    preview_btn.click(
-        fn=preview_formula,
-        inputs=[formula_idx, semantic_state],
-        outputs=[formula_preview, formula_info]
-    )
-    
-    clear_btn.click(
-        fn=clear_all,
-        outputs=outputs + [formula_idx, formula_preview, formula_info]
+with gr.Blocks(title="PDF2TEX Formula") as demo:
+    pdf_input = gr.File(file_types=[".pdf"])
+    run = gr.Button("Run")
+
+    ocr_log = gr.Textbox(lines=10)
+    repair_log = gr.Textbox(lines=10)
+    semantic_log = gr.Textbox(lines=10)
+    summary_log = gr.Textbox(lines=10)
+    status = gr.Textbox()
+
+    tex_dl = gr.File()
+    pdf_dl = gr.File()
+    sem_state = gr.State([])
+
+    run.click(
+        process_with_streaming,
+        pdf_input,
+        [ocr_log, repair_log, semantic_log, summary_log, status, tex_dl, pdf_dl, sem_state]
     )
 
-# ============================================================
-# Main Execution
-# ============================================================
 if __name__ == "__main__":
-    print("=" * 60)
-    print("PDF Formula Processing Pipeline - Visualization Version")
-    print(f"Device: {DEVICE}")
-    print("=" * 60)
-    
-    # Install required packages if missing
-    try:
-        import fpdf
-    except ImportError:
-        print("Installing fpdf for PDF generation...")
-        import subprocess
-        subprocess.run(["pip", "install", "fpdf"])
-    
-    demo.queue().launch(
-        server_name="0.0.0.0",
-        server_port=7860,
-        share=False,
-        debug=False,
-        show_error=True
-    )
+    demo.queue().launch(server_name="0.0.0.0", server_port=7860)