Update app.py

app.py

@@ -5,13 +5,15 @@ import time
 import sys
 import os
 from pathlib import Path
-import streamlit as st
-from PIL import Image, ImageTk
+from PIL import Image
 import tempfile
 import io
 import threading
 import tkinter as tk
 from tkinter import filedialog, Label, Button, Frame
+from shiny import App, render, ui, reactive
+from shiny.types import ImgData
+import base64
 
 # Constants
 MODEL_DIR = "models"
@@ -22,7 +24,7 @@ def parse_args():
     parser.add_argument('--garment', type=str, help='Path to garment image')
     parser.add_argument('--webcam', type=int, default=0, help='Webcam index to use')
     parser.add_argument('--resolution', type=str, default='640x480', help='Camera resolution')
-    parser.add_argument('--streamlit', action='store_true', help='Run in Streamlit mode')
+    parser.add_argument('--shiny', action='store_true', help='Run in Shiny mode')
     parser.add_argument('--tkinter', action='store_true', help='Run with Tkinter UI')
     return parser.parse_args()
 
@@ -498,12 +500,12 @@ class GarmentProcessor:
 class AdvancedVirtualTryOn:
     """Main class for the virtual try-on system"""
     
-    def __init__(self, garment_path, camera_index=0, resolution="640x480", streamlit_mode=False):
+    def __init__(self, garment_path, camera_index=0, resolution="640x480", shiny_mode=False):
         # Parse resolution
         width, height = map(int, resolution.split('x'))
         
-        # Set Streamlit mode
-        self.streamlit_mode = streamlit_mode
+        # Set Shiny mode
+        self.shiny_mode = shiny_mode
         
         # Initialize components
         self.pose_estimator = HumanPoseEstimator()
@@ -512,8 +514,8 @@ class AdvancedVirtualTryOn:
         # Load garment
         self.garment = self.garment_processor.load_garment(garment_path)
         
-        # Initialize camera if not in Streamlit mode
-        if not streamlit_mode:
+        # Initialize camera if not in Shiny mode
+        if not shiny_mode:
             self.camera = cv2.VideoCapture(camera_index)
             self.camera.set(cv2.CAP_PROP_FRAME_WIDTH, width)
             self.camera.set(cv2.CAP_PROP_FRAME_HEIGHT, height)
@@ -544,7 +546,7 @@ class AdvancedVirtualTryOn:
         self.last_keypoints = None
         
         print("Advanced Virtual Try-On initialized.")
-        if not streamlit_mode:
+        if not shiny_mode:
             print("Starting camera feed...")
     
     def update_fps(self):
@@ -709,7 +711,7 @@ class AdvancedVirtualTryOn:
                    1, (0, 255, 0), 2, cv2.LINE_AA)
         
         # Display current garment fit parameters
-        if self.show_controls and not self.streamlit_mode:
+        if self.show_controls and not self.shiny_mode:
             # Display fitting instructions
             instructions = [
                 "Controls:",
@@ -726,7 +728,7 @@ class AdvancedVirtualTryOn:
                 cv2.putText(frame, line, (10, y_pos), cv2.FONT_HERSHEY_SIMPLEX, 
                            0.5, (0, 255, 0), 1, cv2.LINE_AA)
                 y_pos += 25
-        elif not self.streamlit_mode:
+        elif not self.shiny_mode:
             cv2.putText(frame, "Press 'c' for controls", (10, 70), 
                        cv2.FONT_HERSHEY_SIMPLEX, 0.7, (0, 255, 0), 1, cv2.LINE_AA)
         
@@ -734,8 +736,8 @@ class AdvancedVirtualTryOn:
 
     def run(self):
         """Main application loop"""
-        if self.streamlit_mode:
-            print("Streamlit mode is active. The main loop will be controlled by the Streamlit app.")
+        if self.shiny_mode:
+            print("Shiny mode is active. The main loop will be controlled by the Shiny app.")
             return
             
         print("Advanced Virtual Try-On started. Press 'q' to quit, 'd' to toggle debug mode.")
@@ -822,7 +824,7 @@ class AdvancedVirtualTryOn:
     
     def clean_up(self):
         """Clean up resources"""
-        if hasattr(self, 'camera') and not self.streamlit_mode and self.camera.isOpened():
+        if hasattr(self, 'camera') and not self.shiny_mode and self.camera.isOpened():
             self.camera.release()
         cv2.destroyAllWindows()
         print("Application closed.")
@@ -1078,137 +1080,167 @@ def run_tkinter_app(webcam_index=0, resolution="640x480"):
     ui = TkinterUI(webcam_index, resolution)
     ui.start()
 
-def run_streamlit_app():
-    """Run the application in Streamlit mode"""
-    st.set_page_config(page_title="Virtual Try-On", page_icon="👕", layout="wide")
-    
-    st.title("Advanced Virtual Try-On")
-    st.subheader("Try on clothing virtually using your webcam")
-    
-    # Sidebar for uploading garment and adjustments
-    with st.sidebar:
-        st.header("Settings")
-        uploaded_garment = st.file_uploader("Upload a garment image (with transparent background)", type=["png", "jpg", "jpeg"])
-        
-        st.subheader("Fitting Adjustments")
-        width_scale = st.slider("Width Scale", 0.8, 3.0, 1.2, 0.1)
-        height_scale = st.slider("Height Scale", 0.6, 2.0, 1.1, 0.1)
-        collar_position = st.slider("Collar Position", 0.05, 0.3, 0.2, 0.01)
-        
-        debug_mode = st.checkbox("Show Skeleton", value=False)
-        
-        st.info("For best results, use a garment image with a transparent background.")
-    
-    # Main content
-    col1, col2 = st.columns(2)
-    
-    # If no garment uploaded, show sample garments
-    if uploaded_garment is None:
-        with col1:
-            st.warning("Please upload a garment image to begin")
-            st.write("No garment image uploaded. Here's how it works:")
-            st.write("1. Upload a garment image with transparent background")
-            st.write("2. Position yourself in front of the camera")
-            st.write("3. Adjust the fit using the controls in the sidebar")
-            
-            # Example garment placeholder
-            st.image("https://i.imgur.com/JFP0rja.png", caption="Example garment (upload your own)")
-            
-        with col2:
-            # Camera placeholder
-            st.write("Camera feed will appear here")
-            placeholder = st.empty()
-            placeholder.image(np.zeros((480, 640, 3), dtype=np.uint8), channels="BGR", caption="Webcam feed will appear here")
-        
-        return
-    
-    # Save uploaded garment to temp file
-    temp_garment_file = None
-    if uploaded_garment is not None:
-        temp_garment_file = tempfile.NamedTemporaryFile(delete=False, suffix=".png")
-        temp_garment_file.write(uploaded_garment.getvalue())
-        temp_garment_file.close()
-    
-    # Initialize the application with the uploaded garment
-    try:
-        app = AdvancedVirtualTryOn(temp_garment_file.name, 0, "640x480", streamlit_mode=True)
-        
-        # Set parameters from sliders
-        app.width_scale = width_scale
-        app.height_scale = height_scale
-        app.collar_position = collar_position
-        app.debug_mode = debug_mode
-        
-        # Show the garment
-        with col1:
-            st.subheader("Garment:")
-            garment_display = cv2.cvtColor(app.garment, cv2.COLOR_BGRA2RGBA)
-            st.image(garment_display, caption="Your uploaded garment")
-        
-        # Start webcam
-        with col2:
-            st.subheader("Virtual Try-On:")
-            webcam_placeholder = st.empty()
-            
-            cap = cv2.VideoCapture(0)
-            cap.set(cv2.CAP_PROP_FRAME_WIDTH, 640)
-            cap.set(cv2.CAP_PROP_FRAME_HEIGHT, 480)
+def run_shiny_app():
+    """Run the application in Shiny mode"""
+    app_ui = ui.page_fluid(
+        ui.tags.head(
+            ui.tags.title("Advanced Virtual Try-On"),
+            ui.tags.style("""
+                .container { max-width: 1200px; }
+                .row { margin-bottom: 20px; }
+                .col-md-6 { padding: 10px; }
+                .well { background-color: #f8f9fa; padding: 15px; border-radius: 5px; }
+                .form-group { margin-bottom: 15px; }
+                .control-label { font-weight: bold; }
+                .img-preview { max-width: 100%; height: auto; }
+            """)
+        ),
+        ui.div(
+            {"class": "container"},
+            ui.h1("Advanced Virtual Try-On"),
+            ui.p("Try on clothing virtually using your webcam"),
             
-            # Check if webcam opened successfully
-            if not cap.isOpened():
-                st.error("Could not open webcam. Please check your camera connection.")
+            ui.div(
+                {"class": "row"},
+                ui.div(
+                    {"class": "col-md-6"},
+                    ui.div(
+                        {"class": "well"},
+                        ui.h3("Settings"),
+                        ui.input_file("garment_upload", "Upload Garment Image", 
+                                    accept=[".png", ".jpg", ".jpeg"]),
+                        ui.div(
+                            {"class": "form-group"},
+                            ui.input_slider("width_scale", "Width Scale", 
+                                          min=0.8, max=3.0, value=1.2, step=0.1),
+                            ui.input_slider("height_scale", "Height Scale", 
+                                          min=0.6, max=2.0, value=1.1, step=0.1),
+                            ui.input_slider("collar_position", "Collar Position", 
+                                          min=0.05, max=0.3, value=0.2, step=0.01),
+                            ui.input_checkbox("debug_mode", "Show Skeleton", value=False)
+                        ),
+                        ui.div(
+                            {"class": "form-group"},
+                            ui.input_action_button("start_button", "Start Try-On", 
+                                                 class_="btn-primary"),
+                            ui.input_action_button("stop_button", "Stop", 
+                                                 class_="btn-danger")
+                        )
+                    )
+                ),
+                ui.div(
+                    {"class": "col-md-6"},
+                    ui.div(
+                        {"class": "well"},
+                        ui.h3("Preview"),
+                        ui.output_image("garment_preview"),
+                        ui.h3("Live Try-On"),
+                        ui.output_image("webcam_feed")
+                    )
+                )
+            )
+        )
+    )
+
+    def server(input, output, session):
+        # Initialize reactive values
+        app = reactive.Value(None)
+        is_running = reactive.Value(False)
+        temp_garment_file = reactive.Value(None)
+        
+        @reactive.Effect
+        @reactive.event(input.garment_upload)
+        def handle_garment_upload():
+            if input.garment_upload() is not None:
+                # Save uploaded file to temp
+                temp_file = tempfile.NamedTemporaryFile(delete=False, suffix=".png")
+                temp_file.write(input.garment_upload()["datapath"])
+                temp_file.close()
+                temp_garment_file.set(temp_file.name)
+        
+        @reactive.Effect
+        @reactive.event(input.start_button)
+        def start_tryon():
+            if not temp_garment_file.get():
+                ui.notification_show("Please upload a garment first", type="warning")
                 return
             
-            stop_button = st.button("Stop")
-            
-            while not stop_button:
-                success, frame = cap.read()
-                if not success:
-                    st.error("Failed to capture frame from webcam")
-                    break
-                
-                # Process the frame
-                processed_frame = app.process_frame(frame)
-                
-                # Convert BGR to RGB for Streamlit
-                processed_frame_rgb = cv2.cvtColor(processed_frame, cv2.COLOR_BGR2RGB)
-                
-                # Display the processed frame
-                webcam_placeholder.image(processed_frame_rgb, channels="RGB", caption="Live Try-On")
-                
-                # Check if stop button was pressed
-                if stop_button:
-                    break
-                
-                # Small sleep to reduce CPU usage
-                time.sleep(0.01)
-                
-                # Recheck the stop button status
-                stop_button = st.button("Stop")
-            
-            # Clean up
-            cap.release()
-            
-    except Exception as e:
-        st.error(f"Error: {e}")
-        if 'app' in locals():
-            app.clean_up()
+            if not is_running.get():
+                try:
+                    app.set(AdvancedVirtualTryOn(
+                        temp_garment_file.get(),
+                        0,
+                        "640x480",
+                        shiny_mode=True
+                    ))
+                    is_running.set(True)
+                    ui.notification_show("Try-on started", type="success")
+                except Exception as e:
+                    ui.notification_show(f"Error starting try-on: {e}", type="error")
+        
+        @reactive.Effect
+        @reactive.event(input.stop_button)
+        def stop_tryon():
+            if is_running.get():
+                if app.get():
+                    app.get().clean_up()
+                is_running.set(False)
+                ui.notification_show("Try-on stopped", type="info")
+        
+        @output
+        @render.image
+        def garment_preview():
+            if temp_garment_file.get():
+                img = Image.open(temp_garment_file.get())
+                # Convert to base64
+                buffered = io.BytesIO()
+                img.save(buffered, format="PNG")
+                img_str = base64.b64encode(buffered.getvalue()).decode()
+                return ImgData(src=f"data:image/png;base64,{img_str}")
+            return None
+        
+        @output
+        @render.image
+        def webcam_feed():
+            if is_running.get() and app.get():
+                try:
+                    # Get frame from camera
+                    ret, frame = app.get().camera.read()
+                    if ret:
+                        # Process the frame
+                        processed = app.get().process_frame(frame)
+                        
+                        # Convert to PIL Image
+                        img = Image.fromarray(cv2.cvtColor(processed, cv2.COLOR_BGR2RGB))
+                        
+                        # Convert to base64
+                        buffered = io.BytesIO()
+                        img.save(buffered, format="JPEG")
+                        img_str = base64.b64encode(buffered.getvalue()).decode()
+                        return ImgData(src=f"data:image/jpeg;base64,{img_str}")
+                except Exception as e:
+                    ui.notification_show(f"Error processing frame: {e}", type="error")
+            return None
+        
+        # Update app parameters when sliders change
+        @reactive.Effect
+        def update_params():
+            if app.get():
+                app.get().width_scale = input.width_scale()
+                app.get().height_scale = input.height_scale()
+                app.get().collar_position = input.collar_position()
+                app.get().debug_mode = input.debug_mode()
     
-    finally:
-        # Remove temporary file
-        if temp_garment_file:
-            try:
-                os.unlink(temp_garment_file.name)
-            except:
-                pass
+    return App(app_ui, server)
 
 def main():
     args = parse_args()
     try:
         # Check which mode to run in
-        if args.streamlit:
-            run_streamlit_app()
-        elif args.tkinter or (not args.garment and not args.streamlit):
+        if args.shiny:
+            app = run_shiny_app()
+            app.run(host="0.0.0.0", port=8000)
+        elif args.tkinter or (not args.garment and not args.shiny):
             # Use tkinter by default if no garment is specified
             run_tkinter_app(args.webcam, args.resolution)
         else: