FIRST

app.py

@@ -0,0 +1,106 @@
+import gradio as gr
+import cv2
+import numpy as np
+import aiohttp
+import asyncio
+from stripeRemover import StripeRemover
+
+class OCRUI:
+    def __init__(self):
+        self.API_URL = "http://s15.serv00.com:9081/compareAnalyze"
+        self.stripe_remover = StripeRemover()
+
+    def process_image(self, image, method):
+        if image is None:
+            return None
+            
+        try:
+            if method == "Original":
+                return cv2.cvtColor(image, cv2.COLOR_RGB2BGR)
+            elif method == "Fourier":
+                return self.stripe_remover.fourier_method(image)
+            elif method == "Morphological":
+                return self.stripe_remover.morphological_method(image)
+            elif method == "Adaptive":
+                return self.stripe_remover.adaptive_threshold_method(image)
+            elif method == "Enhanced":
+                gray = cv2.cvtColor(image, cv2.COLOR_RGB2GRAY)
+                return self.stripe_remover.enhance_image(gray)
+        except Exception as e:
+            return None
+
+    async def send_to_api(self, image_bytes):
+        async with aiohttp.ClientSession() as session:
+            data = aiohttp.FormData()
+            data.add_field('image', image_bytes, 
+                          filename='image.jpg',
+                          content_type='image/jpeg')
+            data.add_field('model', 'GEMINI')
+            
+            try:
+                async with session.post(self.API_URL, data=data) as response:
+                    return await response.json()
+            except Exception as e:
+                return {"error": str(e)}
+
+    def ocr_process(self, image, task, preprocess_method):
+        if image is None:
+            return "Please upload an image", "No image provided"
+
+        # Preprocess image
+        processed_img = self.process_image(image, preprocess_method)
+        if processed_img is None:
+            return "Image processing failed", "Processing error"
+
+        # Prepare image for API
+        encode_params = [cv2.IMWRITE_JPEG_QUALITY, 50]
+        _, img_bytes = cv2.imencode('.jpg', processed_img, encode_params)
+        
+        # Call API
+        result = asyncio.run(self.send_to_api(img_bytes.tobytes()))
+        
+        if result is None or "error" in result:
+            return "API call failed", "Error calling OCR service"
+            
+        # Format results
+        text_output = f"Task: {task}\nResults:\n{str(result)}"
+        html_output = f"<pre>{text_output}</pre>"
+        
+        return text_output, html_output
+
+def create_ui():
+    ui = OCRUI()
+    
+    with gr.Blocks() as demo:
+        gr.Markdown("# 美宜佳DEMO")
+        
+        with gr.Row():
+            with gr.Column():
+                image_input = gr.Image(type="numpy", label="Input Image")
+                preprocess_dropdown = gr.Dropdown(
+                    choices=["Original", "Fourier", "Morphological", "Adaptive", "Enhanced"],
+                    label="Preprocessing Method",
+                    value="Original"
+                )
+                task_dropdown = gr.Dropdown(
+                    choices=["Plain OCR", "Format OCR", "Box OCR"],
+                    label="OCR Task",
+                    value="Plain OCR"
+                )
+                process_btn = gr.Button("Process Image")
+                
+            with gr.Column():
+                text_output = gr.Textbox(label="OCR Results")
+                html_output = gr.HTML(label="Formatted Results")
+
+        process_btn.click(
+            fn=ui.ocr_process,
+            inputs=[image_input, task_dropdown, preprocess_dropdown],
+            outputs=[text_output, html_output]
+        )
+    
+    return demo
+
+if __name__ == "__main__":
+    demo = create_ui()
+    demo.launch(server_name="0.0.0.0", server_port=7860, share=True)

requirements.txt

@@ -0,0 +1,7 @@
+streamlit>=1.0.0
+torch>=1.8.0
+opencv-python>=4.5.0
+matplotlib>=3.3.0
+numpy>=1.19.0
+aiohttp>=3.8.0
+typing-extensions>=4.0.0

stripeRemover.py

@@ -0,0 +1,121 @@
+import cv2
+import numpy as np
+
+class StripeRemover:
+    def __init__(self):
+        pass
+    
+    def fourier_method(self, image):
+        """傅里叶变换去除条纹"""
+        # 转换为灰度图像
+        if len(image.shape) > 2:
+            gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
+        else:
+            gray = image.copy()
+            
+        # 傅里叶变换
+        dft = cv2.dft(np.float32(gray), flags=cv2.DFT_COMPLEX_OUTPUT)
+        dft_shift = np.fft.fftshift(dft)
+        
+        # 创建掩模
+        rows, cols = gray.shape
+        crow, ccol = rows // 2, cols // 2
+        mask = np.ones((rows, cols, 2), np.uint8)
+        mask[crow-5:crow+5, :] = 0  # 调整带宽以匹配条纹频率
+        
+        # 应用掩模和逆变换
+        fshift = dft_shift * mask
+        f_ishift = np.fft.ifftshift(fshift)
+        img_back = cv2.idft(f_ishift)
+        img_back = cv2.magnitude(img_back[:,:,0], img_back[:,:,1])
+        
+        # 归一化处理
+        img_back = cv2.normalize(img_back, None, 0, 255, cv2.NORM_MINMAX)
+        return np.uint8(img_back)
+    
+    def morphological_method(self, image):
+        """形态学操作去除条纹"""
+        # Convert to grayscale if needed
+        if len(image.shape) > 2:
+            gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
+        else:
+            gray = image.copy()
+            
+        # Create horizontal kernel (adjust size if needed)
+        horizontal_kernel = cv2.getStructuringElement(cv2.MORPH_RECT, (25,1))
+        
+        # Detect lines using morphological operations
+        detected_lines = cv2.morphologyEx(gray, cv2.MORPH_OPEN, horizontal_kernel)
+        
+        # Remove detected lines and normalize
+        result = cv2.subtract(gray, detected_lines)
+        
+        # Normalize and enhance contrast
+        result = cv2.normalize(result, None, 0, 255, cv2.NORM_MINMAX).astype(np.uint8)
+        
+        # Convert back to BGR for display
+        return cv2.cvtColor(result, cv2.COLOR_GRAY2BGR)
+    
+    def adaptive_threshold_method(self, image):
+        """自适应阈值处理"""
+        if len(image.shape) > 2:
+            gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
+        else:
+            gray = image.copy()
+            
+        # 自适应阈值处理
+        thresh = cv2.adaptiveThreshold(gray, 255, 
+                                     cv2.ADAPTIVE_THRESH_GAUSSIAN_C,
+                                     cv2.THRESH_BINARY, 11, 2)
+        
+        # 中值滤波去噪
+        result = cv2.medianBlur(thresh, 3)
+        return result
+    
+    def enhance_image(self, image):
+        """图像增强处理"""
+        # CLAHE对比度增强
+        clahe = cv2.createCLAHE(clipLimit=2.0, tileGridSize=(8,8))
+        enhanced = clahe.apply(image)
+        
+        # 锐化处理
+        kernel = np.array([[-1,-1,-1],
+                         [-1, 9,-1],
+                         [-1,-1,-1]])
+        sharpened = cv2.filter2D(enhanced, -1, kernel)
+        
+        return sharpened
+    
+    def adaptive_enhance(self, image):
+        """自适应阈值 + 图像增强"""
+        thresh_result = self.adaptive_threshold_method(image)
+        return self.enhance_image(thresh_result)
+        
+    def fourier_enhance(self, image):
+        """傅里叶变换 + 图像增强"""
+        fourier_result = self.fourier_method(image)
+        return self.enhance_image(fourier_result)
+        
+    def morphological_enhance(self, image):
+        """形态学操作 + 图像增强"""
+        morph_result = self.morphological_method(image)
+        # Convert BGR to gray for enhance_image
+        gray = cv2.cvtColor(morph_result, cv2.COLOR_BGR2GRAY)
+        enhanced = self.enhance_image(gray)
+        return cv2.cvtColor(enhanced, cv2.COLOR_GRAY2BGR)
+        
+    def adaptive_fourier(self, image):
+        """自适应阈值 + 傅里叶变换"""
+        thresh_result = self.adaptive_threshold_method(image)
+        return self.fourier_method(thresh_result)
+        
+    def morphological_adaptive(self, image):
+        """形态学操作 + 自适应阈值"""
+        morph_result = self.morphological_method(image)
+        gray = cv2.cvtColor(morph_result, cv2.COLOR_BGR2GRAY)
+        return self.adaptive_threshold_method(gray)
+        
+    def fourier_morphological(self, image):
+        """傅里叶变换 + 形态学操作"""
+        fourier_result = self.fourier_method(image)
+        return self.morphological_method(fourier_result)