Update app.py

app.py

@@ -4,357 +4,382 @@ from PIL import Image
 import easyocr
 import numpy as np
 import re
-from datetime import datetime
 import traceback
 
-class StableOCRProcessor:
+class FinalOCRProcessor:
     def __init__(self):
         self.reader = None
+        self.lang_config = "未初始化"
         self.initialize_reader()
     
     def initialize_reader(self):
         """安全初始化EasyOCR"""
-        try:
-            # 首先嘗試繁體中文+英文
-            self.reader = easyocr.Reader(['ch_tra', 'en'], gpu=False)
-            self.lang_config = "繁體中文 + 英文"
-            print("成功初始化：繁體中文 + 英文")
-        except Exception as e1:
+        print("正在初始化OCR引擎...")
+        
+        # 嘗試不同的語言配置
+        configs = [
+            (['ch_tra', 'en'], "繁體中文+英文"),
+            (['ch_sim', 'en'], "簡體中文+英文"), 
+            (['en'], "僅英文")
+        ]
+        
+        for lang_list, description in configs:
             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 = "初始化失敗"
+                print(f"嘗試配置：{description}")
+                self.reader = easyocr.Reader(lang_list, gpu=False)
+                self.lang_config = description
+                print(f"✓ 成功初始化：{description}")
+                return
+            except Exception as e:
+                print(f"✗ 配置 {description} 失敗：{str(e)}")
+                continue
+        
+        print("❌ 所有配置都失敗了")
+        self.reader = None
+        self.lang_config = "初始化失敗"
     
-    def process_image_safely(self, image):
-        """安全處理圖片"""
+    def process_image(self, image):
+        """處理圖片的主要函數"""
         if self.reader is None:
-            return self.create_error_response("OCR引擎初始化失敗")
+            return self.create_error_result("OCR引擎未正確初始化")
+        
+        if image is None:
+            return self.create_error_result("請上傳圖片")
         
         try:
-            # 確保輸入是PIL Image
+            # 轉換圖片格式
             if isinstance(image, np.ndarray):
-                image = Image.fromarray(image)
-            elif image is None:
-                return self.create_error_response("請上傳有效的圖片")
+                img_array = image
+            else:
+                img_array = np.array(image)
             
-            # 轉換為numpy array
-            img_array = np.array(image)
+            print("開始OCR識別...")
             
             # 執行OCR
-            print("開始執行OCR...")
             results = self.reader.readtext(img_array)
-            print(f"OCR完成，識別到 {len(results)} 個文字區塊")
             
-            # 處理結果
-            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
+            print(f"識別完成，找到 {len(results)} 個文字區塊")
             
-            # 創建DataFrame
-            if processed_data:
-                df = pd.DataFrame(processed_data)
-                # 按位置排序
-                df = df.sort_values(['中心Y', '中心X']).reset_index(drop=True)
-                
-                # 嘗試重建表格
-                table_df = self.rebuild_table(df)
+            if not results:
+                return self.create_empty_result("圖片中未找到任何文字")
+            
+            # 處理OCR結果
+            data_list = []
+            for i, (bbox, text, confidence) in enumerate(results):
+                # 計算位置信息
+                x_coords = [point[0] for point in bbox]
+                y_coords = [point[1] for point in bbox]
                 
-                # 創建摘要
-                summary = self.create_summary(df)
-                
-                return df, table_df, summary
-            else:
-                return self.create_empty_response("未識別到任何文字")
+                left = int(min(x_coords))
+                right = int(max(x_coords))
+                top = int(min(y_coords))
+                bottom = int(max(y_coords))
+                center_x = int((left + right) / 2)
+                center_y = int((top + bottom) / 2)
                 
+                data_list.append({
+                    '序號': i + 1,
+                    '識別文字': text.strip(),
+                    '信心度': round(float(confidence), 3),
+                    '中心X': center_x,
+                    '中心Y': center_y,
+                    '左': left,
+                    '上': top,
+                    '右': right,
+                    '下': bottom,
+                    '寬度': right - left,
+                    '高度': bottom - top,
+                    '類型': self.get_text_type(text.strip())
+                })
+            
+            # 創建DataFrame並排序
+            df = pd.DataFrame(data_list)
+            df = df.sort_values(['中心Y', '中心X']).reset_index(drop=True)
+            
+            # 重新編號
+            df['序號'] = range(1, len(df) + 1)
+            
+            # 生成摘要
+            summary = self.generate_summary(df)
+            
+            # 嘗試重建表格
+            table_df = self.reconstruct_table(df)
+            
+            return df, table_df, summary
+            
         except Exception as e:
-            error_msg = f"處理圖片時發生錯誤：{str(e)}"
+            error_msg = f"處理圖片時出錯：{str(e)}"
             print(error_msg)
             print(traceback.format_exc())
-            return self.create_error_response(error_msg)
+            return self.create_error_result(error_msg)
     
-    def classify_text(self, text):
-        """分類文字類型"""
+    def get_text_type(self, text):
+        """判斷文字類型"""
         if not text:
-            return '空白'
+            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 '未知'
+        # 日期格式
+        if re.search(r'\d+月\d+日', text):
+            return "日期"
+        
+        # 時間格式
+        if re.search(r'\d{1,2}[-:]\d{1,2}', text):
+            return "時間"
+        
+        # 純數字
+        if re.match(r'^\d+$', text):
+            return "數字"
+        
+        # 中文姓名或詞語
+        if re.match(r'^[\u4e00-\u9fff]{1,6}$', text):
+            return "中文"
+        
+        # 包含中文的混合內容
+        if re.search(r'[\u4e00-\u9fff]', text):
+            return "中文混合"
+        
+        # 英文
+        if re.match(r'^[a-zA-Z\s]+$', text):
+            return "英文"
+        
+        return "其他"
     
-    def rebuild_table(self, df):
+    def generate_summary(self, df):
+        """生成識別摘要"""
+        if df.empty:
+            return "沒有識別到任何內容"
+        
+        total = len(df)
+        avg_conf = df['信心度'].mean()
+        high_conf = (df['信心度'] >= 0.8).sum()
+        
+        summary = f"""🔍 OCR識別報告
+{'='*40}
+📊 基本統計
+• 引擎配置：{self.lang_config}
+• 識別區塊：{total} 個
+• 平均信心度：{avg_conf:.3f}
+• 高信心度區塊：{high_conf} 個 ({high_conf/total*100:.1f}%)
+
+📝 文字類型統計
+"""
+        
+        # 統計各類型數量
+        type_counts = df['類型'].value_counts()
+        for text_type, count in type_counts.items():
+            percentage = count / total * 100
+            summary += f"• {text_type}：{count} 個 ({percentage:.1f}%)\n"
+        
+        # 品質評估
+        if avg_conf >= 0.8:
+            quality = "優秀 ✅"
+        elif avg_conf >= 0.6:
+            quality = "良好 ⚠️"
+        else:
+            quality = "待改進 ❌"
+        
+        summary += f"\n🎯 整體品質：{quality}"
+        
+        return summary
+    
+    def reconstruct_table(self, df):
         """重建表格結構"""
         if df.empty:
             return pd.DataFrame()
         
         try:
-            # 按Y座標分組
-            y_threshold = 30
+            # 按Y座標分組形成行
             rows = []
+            sorted_df = df.sort_values('中心Y')
+            
             current_row = []
             last_y = None
+            y_threshold = 25  # Y座標閾值
             
-            for _, row in df.iterrows():
-                current_y = row['中心Y']
-                
-                if last_y is None or abs(current_y - last_y) <= y_threshold:
-                    current_row.append(row)
+            for _, item in sorted_df.iterrows():
+                if last_y is None or abs(item['中心Y'] - last_y) <= y_threshold:
+                    current_row.append(item)
                 else:
                     if current_row:
+                        # 按X座標排序
                         current_row.sort(key=lambda x: x['中心X'])
                         rows.append(current_row)
-                    current_row = [row]
-                
-                last_y = current_y
+                    current_row = [item]
+                last_y = item['中心Y']
             
+            # 添加最後一行
             if current_row:
                 current_row.sort(key=lambda x: x['中心X'])
                 rows.append(current_row)
             
-            # 構建表格
             if not rows:
                 return pd.DataFrame()
             
-            max_cols = max(len(row) for row in rows)
+            # 構建表格數據
             table_data = []
+            max_cols = max(len(row) for row in rows)
             
-            for i, row in enumerate(rows):
-                row_data = {'行': i + 1}
-                for j, cell in enumerate(row):
-                    row_data[f'列{j+1}'] = cell['識別文字']
+            for row_idx, row_items in enumerate(rows):
+                row_dict = {'行號': row_idx + 1}
+                
+                for col_idx, item in enumerate(row_items):
+                    col_name = f'第{col_idx + 1}列'
+                    row_dict[col_name] = item['識別文字']
                 
                 # 填充空列
-                for j in range(len(row), max_cols):
-                    row_data[f'列{j+1}'] = ''
+                for col_idx in range(len(row_items), max_cols):
+                    col_name = f'第{col_idx + 1}列'
+                    row_dict[col_name] = ""
                 
-                table_data.append(row_data)
+                table_data.append(row_dict)
             
             return pd.DataFrame(table_data)
             
         except Exception as e:
             print(f"重建表格失敗：{e}")
-            return pd.DataFrame([{'錯誤': '表格重建失敗'}])
+            return pd.DataFrame([{"錯誤": "表格重建失敗"}])
     
-    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 / total_count) * 100
-                summary += f"• {text_type}：{count} 個 ({percentage:.1f}%)\n"
-            
-            # 品質評估
-            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_error_result(self, message):
+        """創建錯誤結果"""
+        error_df = pd.DataFrame([{"錯誤信息": message}])
+        return error_df, error_df, f"❌ {message}"
     
-    def create_empty_response(self, msg):
-        """創建空響應"""
+    def create_empty_result(self, message):
+        """創建空結果"""
         empty_df = pd.DataFrame()
-        return empty_df, empty_df, f"ℹ️ {msg}"
+        return empty_df, empty_df, f"ℹ️ {message}"
 
-def create_stable_interface():
-    """創建穩定的Gradio界面"""
-    processor = StableOCRProcessor()
+def main():
+    """主函數，創建Gradio應用"""
     
-    def process_with_error_handling(image, min_confidence):
-        """帶錯誤處理的處理函數"""
+    # 初始化處理器
+    processor = FinalOCRProcessor()
+    
+    def process_image_wrapper(image, min_confidence):
+        """包裝處理函數"""
         try:
-            df, table_df, summary = processor.process_image_safely(image)
+            # 處理圖片
+            df, table_df, summary = processor.process_image(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
+                original_count = len(df)
+                df = df[df['信心度'] >= min_confidence].reset_index(drop=True)
+                filtered_count = len(df)
+                
+                if filtered_count < original_count:
+                    summary += f"\n\n🔍 信心度過濾：保留 {filtered_count}/{original_count} 個結果"
             
             return summary, df, table_df
             
         except Exception as e:
             error_msg = f"處理失敗：{str(e)}"
-            error_df = pd.DataFrame([{'錯誤': error_msg}])
+            error_df = pd.DataFrame([{"錯誤": error_msg}])
             return error_msg, error_df, error_df
     
-    # 創建界面
-    with gr.Blocks(title="穩定版中文OCR系統", theme=gr.themes.Soft()) as demo:
+    # 創建Gradio界面
+    with gr.Blocks(
+        title="中文OCR識別系統",
+        theme=gr.themes.Default()
+    ) as app:
+        
+        # 標題和說明
         gr.HTML("""
-        <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 style="text-align: center; padding: 20px; background: #f0f2f6; border-radius: 10px; margin-bottom: 20px;">
+            <h1 style="color: #1f2937; margin-bottom: 10px;">🔍 中文OCR識別系統</h1>
+            <p style="color: #6b7280; font-size: 16px;">
+                支持中文、英文、數字識別，自動重建表格結構
+            </p>
         </div>
         """)
         
+        # 主要操作區域
         with gr.Row():
+            # 左側：圖片上傳和控制
             with gr.Column(scale=1):
                 image_input = gr.Image(
                     label="📤 上傳圖片",
-                    type="pil",
-                    height=400
+                    type="pil"
                 )
                 
-                min_confidence = gr.Slider(
+                confidence_slider = gr.Slider(
                     minimum=0.0,
                     maximum=1.0,
                     value=0.3,
                     step=0.1,
-                    label="🎯 最低信心度",
-                    info="過濾掉信心度低於此值的結果"
+                    label="🎯 最低信心度閾值"
                 )
                 
-                process_btn = gr.Button(
+                process_button = gr.Button(
                     "🚀 開始識別",
-                    variant="primary",
-                    size="lg"
+                    variant="primary"
                 )
             
+            # 右側：摘要報告
             with gr.Column(scale=1):
-                summary_text = gr.Textbox(
+                summary_output = gr.Textbox(
                     label="📊 識別報告",
-                    lines=12,
-                    max_lines=15
+                    lines=15,
+                    max_lines=20
                 )
         
+        # 結果展示區域
         with gr.Row():
             with gr.Column():
                 gr.Markdown("### 📋 詳細識別結果")
-                detail_table = gr.Dataframe(
-                    interactive=True,
-                    wrap=True,
-                    height=300
+                detail_output = gr.Dataframe(
+                    label="所有識別的文字內容",
+                    interactive=True
                 )
             
             with gr.Column():
                 gr.Markdown("### 🔄 重建表格")
-                rebuilt_table = gr.Dataframe(
-                    interactive=True,
-                    wrap=True,
-                    height=300
+                table_output = gr.Dataframe(
+                    label="按表格結構重新組織的數據",
+                    interactive=True
                 )
         
-        # 說明區域
-        with gr.Accordion("💡 使用說明", open=False):
+        # 使用說明
+        with gr.Accordion("📖 使用說明", open=False):
             gr.Markdown("""
-            ### 系統特色
-            - ✅ **智能容錯**：自動處理各種錯誤情況
-            - 🔧 **多語言支持**：自動選擇最佳語言配置
-            - 📊 **表格重建**：智能重建原始表格結構
-            - 🎯 **品質控制**：可調整信心度閾值
+            ### 🚀 快速開始
+            1. **上傳圖片**：點擊上傳包含文字的圖片
+            2. **調整參數**：設置最低信心度（建議0.3-0.7）
+            3. **開始識別**：點擊按鈕或直接上傳圖片自動處理
+            4. **查看結果**：在兩個表格中查看識別結果
             
-            ### 使用技巧
-            1. **圖片要求**：清晰、對比度高的圖片效果最佳
-            2. **信心度調整**：降低閾值可獲得更多結果，提高閾值可獲得更準確結果
-            3. **表格處理**：系統會自動識別行列結構並重建表格
-            4. **結果導出**：可以複製表格數據到其他應用程序
+            ### 📊 結果說明
+            - **詳細識別結果**：每個文字區塊的完整信息
+            - **重建表格**：嘗試還原原始表格的行列結構
+            - **識別報告**：統計信息和品質評估
             
-            ### 支持內容
-            - 中文文字（繁體/簡體）
-            - 英文字母和數字
-            - 日期和時間格式
-            - 表格和結構化數據
+            ### 💡 優化建議
+            - 使用清晰、高對比度的圖片
+            - 確保文字大小適中（不要太小）
+            - 避免圖片傾斜或變形
+            - 調整信心度閾值獲得最佳結果
             """)
         
         # 綁定事件
-        process_btn.click(
-            fn=process_with_error_handling,
-            inputs=[image_input, min_confidence],
-            outputs=[summary_text, detail_table, rebuilt_table]
+        process_button.click(
+            fn=process_image_wrapper,
+            inputs=[image_input, confidence_slider],
+            outputs=[summary_output, detail_output, table_output]
         )
         
+        # 圖片上傳時自動處理
         image_input.change(
-            fn=process_with_error_handling,
-            inputs=[image_input, min_confidence],
-            outputs=[summary_text, detail_table, rebuilt_table]
+            fn=process_image_wrapper,
+            inputs=[image_input, confidence_slider],
+            outputs=[summary_output, detail_output, table_output]
         )
     
-    return demo
+    return app
 
 if __name__ == "__main__":
-    demo = create_stable_interface()
-    demo.launch(
+    app = main()
+    app.launch(
         server_name="0.0.0.0",
         server_port=7860,
-        share=True,
-        show_error=True
+        share=True
     )