Update app.py

app.py

@@ -1,67 +1,59 @@
 import streamlit as st
-from transformers import pipeline
+from paddleocr import PaddleOCR
 from PIL import Image
+import numpy as np
+import re
+from pyngrok import ngrok
+import subprocess
 
-# Load OCR model for extracting text from images
-@st.cache_resource
-def load_ocr_model():
-    return pipeline("image-to-text", model="Salesforce/blip-image-captioning-base")
+# Initialize PaddleOCR
+ocr = PaddleOCR(use_angle_cls=True, lang='en')  # Enable angle classification for better accuracy
 
-# Load text-generation model
-@st.cache_resource
-def load_text_model():
-    return pipeline("text-generation", model="EleutherAI/gpt-neo-1.3B")  # Use a smaller model for better compatibility
+# Streamlit App
+st.title("Real-Time Text Extraction from Images (PaddleOCR)")
+st.markdown("Upload or capture an image to extract text using PaddleOCR.")
 
-# Function to process text with a language model
-def process_with_llm(prompt):
-    try:
-        if len(prompt) > 512:
-            prompt = prompt[:512] + "..."  # Truncate long prompts
-        llm_model = load_text_model()
-        response = llm_model(prompt, max_length=500, do_sample=True, temperature=0.7)
-        if response and len(response) > 0:
-            return response[0]["generated_text"]
-        else:
-            return "No explanation or completion could be generated. Please try again with a different input."
-    except Exception as e:
-        return f"Error generating explanation: {e}"
+# Upload Image
+uploaded_file = st.file_uploader("Upload Image", type=['png', 'jpg', 'jpeg'])
 
-# Streamlit App
-def main():
-    st.title("Image-to-Text with Open-Source Language Models")
-    st.markdown(
-        """
-        **Upload an image**, extract text using an open-source OCR model, 
-        and get explanations or text completions using a GPT-style open-source model.
-        """
-    )
+st.markdown("OR")
+
+# Capture Image
+captured_image = st.camera_input("Capture Image")
+
+image = None  # Placeholder for the image
 
-    uploaded_file = st.file_uploader("Upload an image", type=["png", "jpg", "jpeg"])
+if uploaded_file is not None:
+    # Open and Display the Uploaded Image
+    image = Image.open(uploaded_file)
+    st.image(image, caption="Uploaded Image", use_container_width=True)
+elif captured_image is not None:
+    # Open and Display the Captured Image
+    image = Image.open(captured_image)
+    st.image(image, caption="Captured Image", use_container_width=True)
 
-    if uploaded_file is not None:
-        # Convert uploaded file to a PIL image
+if image is not None:
+    # Convert image to numpy array
+    image_np = np.array(image)
+
+    # Perform OCR with PaddleOCR
+    with st.spinner("Extracting text..."):
         try:
-            image = Image.open(uploaded_file)
-            st.image(image, caption="Uploaded Image", use_column_width=True)
-            st.write("Processing...")
+            # Extract text from the image
+            results = ocr.ocr(image_np, cls=True)
+            extracted_text = " ".join([line[1][0] for line in results[0]])  # Concatenate recognized text
 
-            # Extract text from image
-            ocr_model = load_ocr_model()
-            result = ocr_model(image)
+            # Clean the extracted text: replace tabs or multiple spaces with a single space
+            cleaned_text = re.sub(r'\s+', ' ', extracted_text).strip()
 
-            if len(result) > 0:
-                extracted_text = result[0]["generated_text"]
-                st.write("### Extracted Text:")
-                st.write(f"`{extracted_text}`")  # Display the extracted text in a readable format
+            # Add HTML <br> tags for line breaks after numbers
+            formatted_text = re.sub(r'(\b\d+\b)', r'\1<br>', cleaned_text)
 
-                # Process extracted text with LLM
-                st.write("### Explanation/Completion:")
-                explanation = process_with_llm(extracted_text)
-                st.write(explanation)
-            else:
-                st.error("No text could be extracted. Please try another image.")
-        except Exception as e:
-            st.error(f"Error processing the image: {e}")
+            # Add line breaks for table columns or box-separated text
+            formatted_text = re.sub(r'[\t|]', r'<br>', formatted_text)
 
-if __name__ == "__main__":
-    main()
+            # Display the formatted text with HTML rendering
+            st.subheader("Extracted Text:")
+            st.markdown(formatted_text, unsafe_allow_html=True)  # Use unsafe_allow_html=True to render HTML
+        except Exception as e:
+            st.error(f"Error during text extraction: {e}")