Update app.py

app.py

@@ -5,95 +5,141 @@ import easyocr
 import numpy as np
 import re
 from datetime import datetime
+import traceback
 
-class TableOCRProcessor:
+class StableOCRProcessor:
     def __init__(self):
-        # 初始化 EasyOCR，支持中文和英文
-        self.reader = easyocr.Reader(['ch_tra', 'ch_sim', 'en'], gpu=False)
+        self.reader = None
+        self.initialize_reader()
     
-    def process_table_image(self, image):
-        """專門處理表格圖片的OCR"""
+    def initialize_reader(self):
+        """安全初始化EasyOCR"""
+        try:
+            # 首先嘗試繁體中文+英文
+            self.reader = easyocr.Reader(['ch_tra', 'en'], gpu=False)
+            self.lang_config = "繁體中文 + 英文"
+            print("成功初始化：繁體中文 + 英文")
+        except Exception as e1:
+            try:
+                # 如果失敗，嘗試簡體中文+英文
+                self.reader = easyocr.Reader(['ch_sim', 'en'], gpu=False)
+                self.lang_config = "簡體中文 + 英文"
+                print("成功初始化：簡體中文 + 英文")
+            except Exception as e2:
+                try:
+                    # 如果還是失敗，只使用英文
+                    self.reader = easyocr.Reader(['en'], gpu=False)
+                    self.lang_config = "僅英文"
+                    print("成功初始化：僅英文")
+                except Exception as e3:
+                    print(f"初始化失敗：{e3}")
+                    self.reader = None
+                    self.lang_config = "初始化失敗"
+    
+    def process_image_safely(self, image):
+        """安全處理圖片"""
+        if self.reader is None:
+            return self.create_error_response("OCR引擎初始化失敗")
+        
         try:
             # 確保輸入是PIL Image
             if isinstance(image, np.ndarray):
                 image = Image.fromarray(image)
+            elif image is None:
+                return self.create_error_response("請上傳有效的圖片")
             
-            # 執行OCR
-            results = self.reader.readtext(np.array(image))
+            # 轉換為numpy array
+            img_array = np.array(image)
             
-            # 處理結果並嘗試重建表格結構
-            all_data = []
-            for (bbox, text, confidence) in results:
-                top_left = bbox[0]
-                bottom_right = bbox[2]
-                center_y = (top_left[1] + bottom_right[1]) / 2
-                center_x = (top_left[0] + bottom_right[0]) / 2
-                
-                all_data.append({
-                    '識別文字': text.strip(),
-                    '信心度': round(confidence, 3),
-                    '中心X': int(center_x),
-                    '中心Y': int(center_y),
-                    '左上角X': int(top_left[0]),
-                    '左上角Y': int(top_left[1]),
-                    '右下角X': int(bottom_right[0]),
-                    '右下角Y': int(bottom_right[1]),
-                    '寬度': int(bottom_right[0] - top_left[0]),
-                    '高度': int(bottom_right[1] - top_left[1]),
-                    '文字類型': self.classify_text_detailed(text)
-                })
+            # 執行OCR
+            print("開始執行OCR...")
+            results = self.reader.readtext(img_array)
+            print(f"OCR完成，識別到 {len(results)} 個文字區塊")
             
-            # 創建基本DataFrame
-            df = pd.DataFrame(all_data)
+            # 處理結果
+            processed_data = []
+            for i, (bbox, text, confidence) in enumerate(results):
+                try:
+                    top_left = bbox[0]
+                    bottom_right = bbox[2]
+                    center_y = (top_left[1] + bottom_right[1]) / 2
+                    center_x = (top_left[0] + bottom_right[0]) / 2
+                    
+                    processed_data.append({
+                        '序號': i + 1,
+                        '識別文字': text.strip(),
+                        '信心度': round(float(confidence), 3),
+                        '中心X': int(center_x),
+                        '中心Y': int(center_y),
+                        '左上角X': int(top_left[0]),
+                        '左上角Y': int(top_left[1]),
+                        '右下角X': int(bottom_right[0]),
+                        '右下角Y': int(bottom_right[1]),
+                        '文字類型': self.classify_text(text.strip())
+                    })
+                except Exception as e:
+                    print(f"處理第{i+1}個結果時出錯：{e}")
+                    continue
             
-            if not df.empty:
-                # 按Y座標排序（從上到下），然後按X座標排序（從左到右）
+            # 創建DataFrame
+            if processed_data:
+                df = pd.DataFrame(processed_data)
+                # 按位置排序
                 df = df.sort_values(['中心Y', '中心X']).reset_index(drop=True)
                 
-                # 嘗試重建表格結構
-                table_df = self.reconstruct_table(df)
+                # 嘗試重建表格
+                table_df = self.rebuild_table(df)
+                
+                # 創建摘要
+                summary = self.create_summary(df)
                 
-                return df, table_df, self.create_detailed_summary(df)
+                return df, table_df, summary
             else:
-                empty_table = pd.DataFrame()
-                return df, empty_table, "未識別到任何文字"
+                return self.create_empty_response("未識別到任何文字")
                 
         except Exception as e:
-            error_df = pd.DataFrame([{'錯誤': str(e)}])
-            return error_df, error_df, f"處理過程中發生錯誤: {str(e)}"
+            error_msg = f"處理圖片時發生錯誤：{str(e)}"
+            print(error_msg)
+            print(traceback.format_exc())
+            return self.create_error_response(error_msg)
     
-    def classify_text_detailed(self, text):
-        """詳細分類文字類型"""
-        # 檢查是否為日期格式 (如: 5月26日)
-        if re.search(r'\d+月\d+日', text):
-            return '日期'
-        # 檢查是否為時間格式 (如: 07-15, 16-23)
-        elif re.search(r'\d{2}-\d{2}', text):
-            return '時間範圍'
-        # 檢查是否為純數字
-        elif re.match(r'^\d+$', text):
-            return '純數字'
-        # 檢查是否包含中文姓名（2-4個中文字符）
-        elif re.match(r'^[\u4e00-\u9fff]{2,4}$', text):
-            return '姓名'
-        # 檢查是否為中文+數字組合
-        elif re.search(r'[\u4e00-\u9fff]', text) and re.search(r'\d', text):
-            return '中文+數字'
-        # 檢查是否為純中文
-        elif re.search(r'^[\u4e00-\u9fff]+$', text):
-            return '中文'
-        # 其他情況
-        else:
-            return '其他'
+    def classify_text(self, text):
+        """分類文字類型"""
+        if not text:
+            return '空白'
+        
+        try:
+            # 日期格式 (如: 5月26日)
+            if re.search(r'\d+月\d+日', text):
+                return '日期'
+            # 時間範圍 (如: 07-15)
+            elif re.search(r'\d{2}-\d{2}', text):
+                return '時間'
+            # 純數字
+            elif re.match(r'^\d+$', text):
+                return '數字'
+            # 中文姓名或地名
+            elif re.match(r'^[\u4e00-\u9fff]{2,4}$', text):
+                return '中文名稱'
+            # 包含中文
+            elif re.search(r'[\u4e00-\u9fff]', text):
+                return '中文內容'
+            # 英文字母
+            elif re.match(r'^[a-zA-Z]+$', text):
+                return '英文'
+            else:
+                return '其他'
+        except Exception:
+            return '未知'
     
-    def reconstruct_table(self, df):
-        """嘗試重建表格結構"""
+    def rebuild_table(self, df):
+        """重建表格結構"""
         if df.empty:
             return pd.DataFrame()
         
         try:
-            # 根據Y座標分組，找出可能的行
-            y_threshold = 20  # Y座標差異閾值
+            # 按Y座標分組
+            y_threshold = 30
             rows = []
             current_row = []
             last_y = None
@@ -105,204 +151,210 @@ class TableOCRProcessor:
                     current_row.append(row)
                 else:
                     if current_row:
-                        # 按X座標排序當前行
                         current_row.sort(key=lambda x: x['中心X'])
                         rows.append(current_row)
                     current_row = [row]
                 
                 last_y = current_y
             
-            # 添加最後一行
             if current_row:
                 current_row.sort(key=lambda x: x['中心X'])
                 rows.append(current_row)
             
             # 構建表格
-            max_cols = max(len(row) for row in rows) if rows else 0
+            if not rows:
+                return pd.DataFrame()
+            
+            max_cols = max(len(row) for row in rows)
             table_data = []
             
             for i, row in enumerate(rows):
-                row_data = {'行號': i + 1}
+                row_data = {'行': i + 1}
                 for j, cell in enumerate(row):
-                    col_name = f'列{j+1}'
-                    row_data[col_name] = cell['識別文字']
+                    row_data[f'列{j+1}'] = cell['識別文字']
                 
                 # 填充空列
                 for j in range(len(row), max_cols):
-                    col_name = f'列{j+1}'
-                    row_data[col_name] = ''
+                    row_data[f'列{j+1}'] = ''
                 
                 table_data.append(row_data)
             
             return pd.DataFrame(table_data)
             
         except Exception as e:
-            print(f"重建表格時發生錯誤: {e}")
-            return pd.DataFrame()
+            print(f"重建表格失敗：{e}")
+            return pd.DataFrame([{'錯誤': '表格重建失敗'}])
     
-    def create_detailed_summary(self, df):
-        """創建詳細的識別結果摘要"""
-        if df.empty:
-            return "未識別到任何文字"
-        
-        summary = f"""
-📊 識別結果統計：
-━━━━━━━━━━━━━━━━━━━━━━━━━━
-• 總識別區塊數：{len(df)} 個
-• 平均信心度：{df['信心度'].mean():.3f}
-• 最高信心度：{df['信心度'].max():.3f}
-• 最低信心度：{df['信心度'].min():.3f}
+    def create_summary(self, df):
+        """創建摘要報告"""
+        try:
+            if df.empty:
+                return "未識別到任何內容"
+            
+            avg_confidence = df['信心度'].mean()
+            high_conf = (df['信心度'] >= 0.8).sum()
+            total_count = len(df)
+            
+            summary = f"""
+🔍 OCR識別報告
+═══════════════════════════════════
+📊 基本統計：
+• 語言配置：{self.lang_config}
+• 識別區塊：{total_count} 個
+• 平均信心度：{avg_confidence:.3f}
+• 高信心度區塊：{high_conf} 個 ({high_conf/total_count*100:.1f}%)
 
 📝 文字類型分布：
 """
-        
-        type_counts = df['文字類型'].value_counts()
-        for text_type, count in type_counts.items():
-            percentage = (count / len(df)) * 100
-            summary += f"• {text_type}: {count} 個 ({percentage:.1f}%)\n"
-        
-        # 添加品質評估
-        high_confidence = (df['信心度'] >= 0.8).sum()
-        medium_confidence = ((df['信心度'] >= 0.6) & (df['信心度'] < 0.8)).sum()
-        low_confidence = (df['信心度'] < 0.6).sum()
-        
-        summary += f"""
-🎯 識別品質評估：
-• 高信心度 (≥0.8): {high_confidence} 個
-• 中信心度 (0.6-0.8): {medium_confidence} 個  
-• 低信心度 (<0.6): {low_confidence} 個
-
-💡 處理建議：
-"""
-        if low_confidence > 0:
-            summary += "• 發現低信心度文字，建議檢查原圖品質\n"
-        if df['信心度'].mean() >= 0.8:
-            summary += "• 整體識別品質良好✓\n"
-        else:
-            summary += "• 建議提高圖片解析度或清晰度\n"
+            type_counts = df['文字類型'].value_counts()
+            for text_type, count in type_counts.items():
+                percentage = (count / total_count) * 100
+                summary += f"• {text_type}：{count} 個 ({percentage:.1f}%)\n"
             
-        return summary
+            # 品質評估
+            if avg_confidence >= 0.8:
+                summary += "\n✅ 識別品質：優秀"
+            elif avg_confidence >= 0.6:
+                summary += "\n⚠️ 識別品質：良好"
+            else:
+                summary += "\n❌ 識別品質：需改進"
+            
+            return summary
+            
+        except Exception as e:
+            return f"生成報告時發生錯誤：{str(e)}"
+    
+    def create_error_response(self, error_msg):
+        """創建錯誤響應"""
+        error_df = pd.DataFrame([{'錯誤': error_msg}])
+        return error_df, error_df, f"❌ 錯誤：{error_msg}"
+    
+    def create_empty_response(self, msg):
+        """創建空響應"""
+        empty_df = pd.DataFrame()
+        return empty_df, empty_df, f"ℹ️ {msg}"
 
-def create_advanced_interface():
-    """創建進階版Gradio界面"""
-    processor = TableOCRProcessor()
+def create_stable_interface():
+    """創建穩定的Gradio界面"""
+    processor = StableOCRProcessor()
     
-    def advanced_process(image, confidence_threshold):
-        if image is None:
-            return "請上傳圖片", pd.DataFrame(), pd.DataFrame()
-        
-        df, table_df, summary = processor.process_table_image(image)
-        
-        # 根據信心度閾值過濾結果
-        if not df.empty and 'signal' in df.columns:
-            filtered_df = df[df['信心度'] >= confidence_threshold]
-        else:
-            filtered_df = df
-        
-        return summary, filtered_df, table_df
+    def process_with_error_handling(image, min_confidence):
+        """帶錯誤處理的處理函數"""
+        try:
+            df, table_df, summary = processor.process_image_safely(image)
+            
+            # 應用信心度過濾
+            if not df.empty and '信心度' in df.columns:
+                filtered_df = df[df['信心度'] >= min_confidence].reset_index(drop=True)
+                if len(filtered_df) != len(df):
+                    summary += f"\n\n🔍 已過濾低信心度結果：{len(df) - len(filtered_df)} 個"
+                df = filtered_df
+            
+            return summary, df, table_df
+            
+        except Exception as e:
+            error_msg = f"處��失敗：{str(e)}"
+            error_df = pd.DataFrame([{'錯誤': error_msg}])
+            return error_msg, error_df, error_df
     
-    # 創建Gradio界面
-    with gr.Blocks(title="表格OCR識別系統", theme=gr.themes.Glass()) as demo:
+    # 創建界面
+    with gr.Blocks(title="穩定版中文OCR系統", theme=gr.themes.Soft()) as demo:
         gr.HTML("""
-        <div style="text-align: center; padding: 20px;">
-            <h1>📋 專業表格OCR識別系統</h1>
-            <p style="font-size: 18px; color: #666;">
-                專為表格和結構化文檔設計的OCR識別工具
-            </p>
+        <div style="text-align: center; padding: 20px; background: linear-gradient(90deg, #667eea 0%, #764ba2 100%); color: white; border-radius: 10px; margin-bottom: 20px;">
+            <h1>🔍 穩定版中文OCR識別系統</h1>
+            <p>支持中文表格和文檔的OCR識別，自動容錯處理</p>
         </div>
         """)
         
         with gr.Row():
-            with gr.Column(scale=2):
+            with gr.Column(scale=1):
                 image_input = gr.Image(
-                    label="📤 上傳表格圖片",
+                    label="📤 上傳圖片",
                     type="pil",
-                    height=500
+                    height=400
                 )
                 
-                with gr.Row():
-                    confidence_slider = gr.Slider(
-                        minimum=0.0,
-                        maximum=1.0,
-                        value=0.5,
-                        step=0.1,
-                        label="🎯 信心度閾值",
-                        info="只顯示信心度高於此值的結果"
-                    )
-                    
-                    process_btn = gr.Button(
-                        "🚀 開始識別", 
-                        variant="primary",
-                        size="lg"
-                    )
+                min_confidence = gr.Slider(
+                    minimum=0.0,
+                    maximum=1.0,
+                    value=0.3,
+                    step=0.1,
+                    label="🎯 最低信心度",
+                    info="過濾掉信心度低於此值的結果"
+                )
+                
+                process_btn = gr.Button(
+                    "🚀 開始識別",
+                    variant="primary",
+                    size="lg"
+                )
             
-            with gr.Column(scale=3):
-                summary_output = gr.Textbox(
-                    label="📊 識別統計報告",
-                    lines=15,
-                    max_lines=20
+            with gr.Column(scale=1):
+                summary_text = gr.Textbox(
+                    label="📊 識別報告",
+                    lines=12,
+                    max_lines=15
                 )
         
-        with gr.Tabs():
-            with gr.TabItem("📝 詳細識別結果"):
-                detailed_output = gr.Dataframe(
-                    label="完整OCR結果",
+        with gr.Row():
+            with gr.Column():
+                gr.Markdown("### 📋 詳細識別結果")
+                detail_table = gr.Dataframe(
                     interactive=True,
                     wrap=True,
-                    height=400
+                    height=300
                 )
             
-            with gr.TabItem("📋 重建表格"):
-                table_output = gr.Dataframe(
-                    label="重建的表格結構",
+            with gr.Column():
+                gr.Markdown("### 🔄 重建表格")
+                rebuilt_table = gr.Dataframe(
                     interactive=True,
                     wrap=True,
-                    height=400
+                    height=300
                 )
         
-        # 使用說明
-        with gr.Accordion("📖 使用說明", open=False):
+        # 說明區域
+        with gr.Accordion("💡 使用說明", open=False):
             gr.Markdown("""
-            ### 🔧 功能說明
-            
-            **詳細識別結果**：
-            - 顯示每個識別到的文字區塊的完整信息
-            - 包含位置座標、信心度、文字類型等
-            
-            **重建表格**：
-            - 嘗試根據文字位置重建原始表格結構
-            - 按行列組織數據，便於進一步處理
+            ### 系統特色
+            - ✅ **智能容錯**：自動處理各種錯誤情況
+            - 🔧 **多語言支持**：自動選擇最佳語言配置
+            - 📊 **表格重建**：智能重建原始表格結構
+            - 🎯 **品質控制**：可調整信心度閾值
             
-            **識別統計報告**：
-            - 提供識別品質評估和改進建議
-            - 統計不同類型文字的分布情況
+            ### 使用技巧
+            1. **圖片要求**：清晰、對比度高的圖片效果最佳
+            2. **信心度調整**：降低閾值可獲得更多結果，提高閾值可���得更準確結果
+            3. **表格處理**：系統會自動識別行列結構並重建表格
+            4. **結果導出**：可以複製表格數據到其他應用程序
             
-            ### 💡 使用技巧
-            - 上傳清晰、對比度高的圖片效果更好
-            - 調整信心度閾值可以過濾低質量結果
-            - 可以複製表格數據到Excel等工具中使用
+            ### 支持內容
+            - 中文文字（繁體/簡體）
+            - 英文字母和數字
+            - 日期和時間格式
+            - 表格和結構化數據
             """)
         
         # 綁定事件
         process_btn.click(
-            fn=advanced_process,
-            inputs=[image_input, confidence_slider],
-            outputs=[summary_output, detailed_output, table_output]
+            fn=process_with_error_handling,
+            inputs=[image_input, min_confidence],
+            outputs=[summary_text, detail_table, rebuilt_table]
         )
         
         image_input.change(
-            fn=advanced_process,
-            inputs=[image_input, confidence_slider],
-            outputs=[summary_output, detailed_output, table_output]
+            fn=process_with_error_handling,
+            inputs=[image_input, min_confidence],
+            outputs=[summary_text, detail_table, rebuilt_table]
         )
     
     return demo
 
-# 創建並啟動應用
 if __name__ == "__main__":
-    demo = create_advanced_interface()
+    demo = create_stable_interface()
     demo.launch(
         server_name="0.0.0.0",
         server_port=7860,
-        share=True
+        share=True,
+        show_error=True
     )