Update app.py

app.py

@@ -5,12 +5,15 @@ import time
 import streamlit as st
 from PIL import Image
 import torch
-from transformers import AutoProcessor, Qwen2VLForConditionalGeneration, AutoTokenizer, AutoModel
+from transformers import AutoProcessor, Qwen2VLForConditionalGeneration, AutoTokenizer, AutoModel, TrOCRProcessor, VisionEncoderDecoderModel
 from diffusers import StableDiffusionPipeline
 import cv2
 import numpy as np
 import logging
+import asyncio
+import aiofiles
 from io import BytesIO
+import threading
 
 # Logging setup
 logging.basicConfig(level=logging.INFO, format="%(asctime)s - %(levelname)s - %(message)s")
@@ -35,6 +38,8 @@ st.set_page_config(
 # Initialize st.session_state
 if 'captured_images' not in st.session_state:
     st.session_state['captured_images'] = []
+if 'processing' not in st.session_state:
+    st.session_state['processing'] = {}
 
 # Utility Functions
 def generate_filename(sequence, ext="png"):
@@ -55,26 +60,26 @@ def update_gallery():
             with cols[idx % 2]:
                 st.image(Image.open(file), caption=file, use_container_width=True)
 
-# Model Loaders (Simplified, CPU-focused)
+# Model Loaders (Smaller, CPU-focused)
 def load_ocr_qwen2vl():
     model_id = "prithivMLmods/Qwen2-VL-OCR-2B-Instruct"
     processor = AutoProcessor.from_pretrained(model_id, trust_remote_code=True)
     model = Qwen2VLForConditionalGeneration.from_pretrained(model_id, trust_remote_code=True, torch_dtype=torch.float32).to("cpu").eval()
     return processor, model
 
-def load_ocr_got():
-    model_id = "ucaslcl/GOT-OCR2_0"
-    tokenizer = AutoTokenizer.from_pretrained(model_id, trust_remote_code=True)
-    model = AutoModel.from_pretrained(model_id, trust_remote_code=True, torch_dtype=torch.float32).to("cpu").eval()
-    return tokenizer, model
+def load_ocr_trocr():
+    model_id = "microsoft/trocr-small-handwritten"  # Smaller, ~250 MB
+    processor = TrOCRProcessor.from_pretrained(model_id)
+    model = VisionEncoderDecoderModel.from_pretrained(model_id, torch_dtype=torch.float32).to("cpu").eval()
+    return processor, model
 
 def load_image_gen():
-    model_id = "OFA-Sys/small-stable-diffusion-v0"  # Small, CPU-friendly
+    model_id = "OFA-Sys/small-stable-diffusion-v0"  # ~300 MB
     pipeline = StableDiffusionPipeline.from_pretrained(model_id, torch_dtype=torch.float32).to("cpu")
     return pipeline
 
 def load_line_drawer():
-    # Simplified OpenCV-based edge detection (CPU-friendly substitute for Torch Space UNet)
+    # Simplified from your Torch Space (assuming edge detection)
     def edge_detection(image):
         img_np = np.array(image.convert("RGB"))
         gray = cv2.cvtColor(img_np, cv2.COLOR_RGB2GRAY)
@@ -82,6 +87,52 @@ def load_line_drawer():
         return Image.fromarray(edges)
     return edge_detection
 
+# Async Processing Functions
+async def process_ocr(image, prompt, model_name, output_file):
+    start_time = time.time()
+    status = st.empty()
+    status.text(f"Processing {model_name} OCR... (0s)")
+    if model_name == "Qwen2-VL-OCR-2B":
+        processor, model = load_ocr_qwen2vl()
+        inputs = processor(text=prompt, images=image, return_tensors="pt").to("cpu")
+        outputs = model.generate(**inputs, max_new_tokens=1024)
+        text = processor.batch_decode(outputs, skip_special_tokens=True)[0]
+    else:  # TrOCR
+        processor, model = load_ocr_trocr()
+        pixel_values = processor(images=image, return_tensors="pt").pixel_values.to("cpu")
+        outputs = model.generate(pixel_values)
+        text = processor.batch_decode(outputs, skip_special_tokens=True)[0]
+    elapsed = int(time.time() - start_time)
+    status.text(f"{model_name} OCR completed in {elapsed}s!")
+    async with aiofiles.open(output_file, "w") as f:
+        await f.write(text)
+    st.session_state['captured_images'].append(output_file)
+    return text
+
+async def process_image_gen(prompt, output_file):
+    start_time = time.time()
+    status = st.empty()
+    status.text("Processing Image Gen... (0s)")
+    pipeline = load_image_gen()
+    gen_image = pipeline(prompt, num_inference_steps=20).images[0]  # Reduced steps for speed
+    elapsed = int(time.time() - start_time)
+    status.text(f"Image Gen completed in {elapsed}s!")
+    gen_image.save(output_file)
+    st.session_state['captured_images'].append(output_file)
+    return gen_image
+
+async def process_line_drawing(image, output_file):
+    start_time = time.time()
+    status = st.empty()
+    status.text("Processing Line Drawing... (0s)")
+    edge_fn = load_line_drawer()
+    line_drawing = edge_fn(image)
+    elapsed = int(time.time() - start_time)
+    status.text(f"Line Drawing completed in {elapsed}s!")
+    line_drawing.save(output_file)
+    st.session_state['captured_images'].append(output_file)
+    return line_drawing
+
 # Main App
 st.title("AI Vision Titans 🚀 (OCR, Gen, Drawings!)")
 
@@ -101,10 +152,9 @@ tab1, tab2, tab3, tab4 = st.tabs(["Camera Snap 📷", "Test OCR 🔍", "Test Ima
 
 with tab1:
     st.header("Camera Snap 📷")
-    slice_count = st.number_input("Image Slice Count", min_value=1, max_value=20, value=10)
+    st.subheader("Single Capture")
     cols = st.columns(2)
     with cols[0]:
-        st.subheader("Camera 0")
         cam0_img = st.camera_input("Take a picture - Cam 0", key="cam0")
         if cam0_img:
             filename = generate_filename(0)
@@ -115,24 +165,7 @@ with tab1:
                 logger.info(f"Saved snapshot from Camera 0: {filename}")
                 st.session_state['captured_images'].append(filename)
                 update_gallery()
-        if st.button(f"Capture {slice_count} Frames - Cam 0 📸"):
-            st.session_state['cam0_frames'] = []
-            for i in range(slice_count):
-                img = st.camera_input(f"Frame {i} - Cam 0", key=f"cam0_frame_{i}_{time.time()}")
-                if img:
-                    filename = generate_filename(f"0_{i}")
-                    if filename not in st.session_state['captured_images']:
-                        with open(filename, "wb") as f:
-                            f.write(img.getvalue())
-                        st.session_state['cam0_frames'].append(filename)
-                        logger.info(f"Saved frame {i} from Camera 0: {filename}")
-                        time.sleep(1.0 / slice_count)
-            st.session_state['captured_images'].extend([f for f in st.session_state['cam0_frames'] if f not in st.session_state['captured_images']])
-            update_gallery()
-            for frame in st.session_state['cam0_frames']:
-                st.image(Image.open(frame), caption=frame, use_container_width=True)
     with cols[1]:
-        st.subheader("Camera 1")
         cam1_img = st.camera_input("Take a picture - Cam 1", key="cam1")
         if cam1_img:
             filename = generate_filename(1)
@@ -143,22 +176,28 @@ with tab1:
                 logger.info(f"Saved snapshot from Camera 1: {filename}")
                 st.session_state['captured_images'].append(filename)
                 update_gallery()
-        if st.button(f"Capture {slice_count} Frames - Cam 1 📸"):
-            st.session_state['cam1_frames'] = []
-            for i in range(slice_count):
-                img = st.camera_input(f"Frame {i} - Cam 1", key=f"cam1_frame_{i}_{time.time()}")
+
+    st.subheader("Burst Capture")
+    slice_count = st.number_input("Number of Frames", min_value=1, max_value=20, value=10, key="burst_count")
+    if st.button("Start Burst Capture 📸"):
+        st.session_state['burst_frames'] = []
+        placeholder = st.empty()
+        for i in range(slice_count):
+            with placeholder.container():
+                st.write(f"Capturing frame {i+1}/{slice_count}...")
+                img = st.camera_input(f"Frame {i}", key=f"burst_{i}_{time.time()}")
                 if img:
-                    filename = generate_filename(f"1_{i}")
+                    filename = generate_filename(f"burst_{i}")
                     if filename not in st.session_state['captured_images']:
                         with open(filename, "wb") as f:
                             f.write(img.getvalue())
-                        st.session_state['cam1_frames'].append(filename)
-                        logger.info(f"Saved frame {i} from Camera 1: {filename}")
-                        time.sleep(1.0 / slice_count)
-            st.session_state['captured_images'].extend([f for f in st.session_state['cam1_frames'] if f not in st.session_state['captured_images']])
-            update_gallery()
-            for frame in st.session_state['cam1_frames']:
-                st.image(Image.open(frame), caption=frame, use_container_width=True)
+                        st.session_state['burst_frames'].append(filename)
+                        logger.info(f"Saved burst frame {i}: {filename}")
+                        st.image(Image.open(filename), caption=filename, use_container_width=True)
+                    time.sleep(0.5)  # Small delay for visibility
+        st.session_state['captured_images'].extend([f for f in st.session_state['burst_frames'] if f not in st.session_state['captured_images']])
+        update_gallery()
+        placeholder.success(f"Captured {len(st.session_state['burst_frames'])} frames!")
 
 with tab2:
     st.header("Test OCR 🔍")
@@ -167,22 +206,15 @@ with tab2:
         selected_image = st.selectbox("Select Image", captured_images, key="ocr_select")
         image = Image.open(selected_image)
         st.image(image, caption="Input Image", use_container_width=True)
-        ocr_model = st.selectbox("Select OCR Model", ["Qwen2-VL-OCR-2B", "GOT-OCR2_0"], key="ocr_model_select")
+        ocr_model = st.selectbox("Select OCR Model", ["Qwen2-VL-OCR-2B", "TrOCR-Small"], key="ocr_model_select")
         prompt = st.text_area("Prompt", "Extract text from the image", key="ocr_prompt")
         if st.button("Run OCR 🚀", key="ocr_run"):
-            if ocr_model == "Qwen2-VL-OCR-2B":
-                processor, model = load_ocr_qwen2vl()
-                # Simplified input: pass image and text directly
-                inputs = processor(text=prompt, images=image, return_tensors="pt").to("cpu")
-                outputs = model.generate(**inputs, max_new_tokens=1024)
-                text = processor.batch_decode(outputs, skip_special_tokens=True)[0]
-            else:  # GOT-OCR2_0
-                tokenizer, model = load_ocr_got()
-                with open(selected_image, "rb") as f:
-                    img_bytes = f.read()
-                img = Image.open(BytesIO(img_bytes))
-                text = model.chat(tokenizer, img, ocr_type='ocr')
-            st.text_area("OCR Result", text, height=200, key="ocr_result")
+            output_file = generate_filename("ocr_output", "txt")
+            st.session_state['processing']['ocr'] = True
+            result = asyncio.run(process_ocr(image, prompt, ocr_model, output_file))
+            st.text_area("OCR Result", result, height=200, key="ocr_result")
+            st.success(f"OCR output saved to {output_file}")
+            st.session_state['processing']['ocr'] = False
     else:
         st.warning("No images captured yet. Use Camera Snap first!")
 
@@ -195,9 +227,12 @@ with tab3:
         st.image(image, caption="Reference Image", use_container_width=True)
         prompt = st.text_area("Prompt", "Generate a similar superhero image", key="gen_prompt")
         if st.button("Run Image Gen 🚀", key="gen_run"):
-            pipeline = load_image_gen()
-            gen_image = pipeline(prompt, num_inference_steps=50).images[0]
-            st.image(gen_image, caption="Generated Image", use_container_width=True)
+            output_file = generate_filename("gen_output", "png")
+            st.session_state['processing']['gen'] = True
+            result = asyncio.run(process_image_gen(prompt, output_file))
+            st.image(result, caption="Generated Image", use_container_width=True)
+            st.success(f"Image saved to {output_file}")
+            st.session_state['processing']['gen'] = False
     else:
         st.warning("No images captured yet. Use Camera Snap first!")
 
@@ -209,9 +244,12 @@ with tab4:
         image = Image.open(selected_image)
         st.image(image, caption="Input Image", use_container_width=True)
         if st.button("Run Line Drawing 🚀", key="line_run"):
-            edge_fn = load_line_drawer()
-            line_drawing = edge_fn(image)
-            st.image(line_drawing, caption="Line Drawing", use_container_width=True)
+            output_file = generate_filename("line_output", "png")
+            st.session_state['processing']['line'] = True
+            result = asyncio.run(process_line_drawing(image, output_file))
+            st.image(result, caption="Line Drawing", use_container_width=True)
+            st.success(f"Line drawing saved to {output_file}")
+            st.session_state['processing']['line'] = False
     else:
         st.warning("No images captured yet. Use Camera Snap first!")