inital deployment1

app.py

@@ -1,86 +1,28 @@
 import gradio as gr
 import cv2
-import torch
 import numpy as np
-from diffusers import StableDiffusionPipeline,AutoPipelineForImage2Image,AutoencoderTiny
-from transformers import AutoProcessor, AutoModel, AutoTokenizer
 from PIL import Image
 
-# 
-# 
-# def predict(prompt, frame):
-#     generator = torch.manual_seed(params.seed)
-#     steps = params.steps
-#     strength = params.strength
-#     if int(steps * strength) < 1:
-#         steps = math.ceil(1 / max(0.10, strength))
-# 
-#     prompt = params.prompt
-#     prompt_embeds = None
-#     
-#     results = self.pipe(
-#         image=frame,
-#         prompt_embeds=prompt_embeds,
-#         prompt=prompt,
-#         negative_prompt=params.negative_prompt,
-#         generator=generator,
-#         strength=strength,
-#         num_inference_steps=steps,
-#         guidance_scale=1.1,
-#         width=params.width,
-#         height=params.height,
-#         output_type="pil",
-#         )
-# 
-#     nsfw_content_detected = (
-#         results.nsfw_content_detected[0]
-#         if "nsfw_content_detected" in results
-#         else False
-#     )
-#     if nsfw_content_detected:
-#         return None
-#     result_image = results.images[0]
-# 
-#     return result_image
-# 
-# def process_frame(frame, prompt="A futuristic landscape"):
-#     """Process a single frame using the real-time latent consistency model."""
-#     
-#     # Convert frame to PIL image
-#     image = Image.fromarray(cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)).resize((512, 512))
-#     
-#     # Apply Real-Time Latent Consistency Model
-#     result = realtime_pipe(prompt=prompt, image=image, strength=0.5, guidance_scale=7.5).images[0]
-#     return np.array(result)
-
-def video_stream(prompt):
-    """Captures video feed from webcam and sends to the AI model."""
+def video_stream():
+    """Captures video feed from webcam and outputs the same stream to a different canvas."""
     cap = cv2.VideoCapture(0)
     while cap.isOpened():
         ret, frame = cap.read()
         if not ret:
             break
-        
-        frame = process_frame(frame, prompt)
-        yield frame  # Return processed frame
+        yield frame
     cap.release()
 
-
 # Create Gradio App
 with gr.Blocks() as demo:
-    gr.Markdown("## 🎨 Real-Time AI-Enhanced Webcam using Latent Consistency Model (LCM)")
+    gr.Markdown("## 🎥 Webcam Stream with Output to a Separate Canvas")
     
     with gr.Row():
-        webcam_feed = gr.Camera(streaming=True, label="Live Webcam")
-        processed_image = gr.Image(label="AI-Enhanced Webcam Feed")
+        webcam_feed = gr.Video(label="Live Webcam", streaming=True)
+        canvas_output = gr.Image(label="Canvas - Output Stream")
     
-    with gr.Row():
-        canvas_output = gr.Image(interactive=True, label="Canvas - Processed Image Output")
+    start_button = gr.Button("Start Streaming")
     
-    prompt_input = gr.Textbox(label="Real-Time LCM Prompt", value="A futuristic landscape")
-    start_button = gr.Button("Start Real-Time AI Enhancement")
-    
-    #start_button.click(fn=video_stream, inputs=[prompt_input], outputs=[processed_image, canvas_output])
+    start_button.click(fn=video_stream, inputs=[], outputs=[canvas_output])
 
 demo.launch(share=True)
-

app_new.py

@@ -0,0 +1,50 @@
+import gradio as gr
+import cv2
+import torch
+import numpy as np
+from diffusers import StableDiffusionPipeline
+from PIL import Image
+
+# Load the Real-Time Latent Consistency Model (LCM)
+device = "cuda" if torch.cuda.is_available() else "cpu"
+lcm_pipe = StableDiffusionPipeline.from_pretrained("latent-consistency/lcm-lora-sdv1-5").to(device)
+
+def process_frame(image, prompt="A futuristic landscape", negative_prompt="not blurry"):
+    """Modify the input image using the real-time latent consistency model (LCM)."""
+    image = image.resize((512, 512))
+    result = lcm_pipe(prompt=prompt, negative_prompt=negative_prompt, image=image, num_inference_steps=4, guidance_scale=7.5).images[0]
+    return np.array(result)
+
+def video_stream(prompt, negative_prompt):
+    """Captures video feed from webcam and sends it to LCM in real time."""
+    cap = cv2.VideoCapture(0)
+    while cap.isOpened():
+        ret, frame = cap.read()
+        if not ret:
+            break
+        image = Image.fromarray(cv2.cvtColor(frame, cv2.COLOR_BGR2RGB))
+        frame = process_frame(image, prompt, negative_prompt)
+        yield frame
+    cap.release()
+
+# Create Gradio App
+with gr.Blocks() as demo:
+    gr.Markdown("## 🎨 Real-Time AI-Enhanced Webcam using Latent Consistency Model (LCM)")
+    
+    with gr.Row():
+        webcam_feed = gr.Camera(streaming=True, label="Live Webcam")
+        processed_image = gr.Image(label="AI-Enhanced Webcam Feed")
+    
+    with gr.Row():
+        image_input = gr.Image(type="pil", label="Upload Image for Processing")
+        canvas_output = gr.Image(interactive=True, label="Canvas - Processed Image Output")
+    
+    prompt_input = gr.Textbox(label="Real-Time LCM Prompt", value="A futuristic landscape")
+    negative_prompt_input = gr.Textbox(label="Negative Prompt", value="")
+    start_button = gr.Button("Start Real-Time AI Enhancement")
+    process_button = gr.Button("Process Uploaded Image")
+    
+    start_button.click(fn=video_stream, inputs=[prompt_input, negative_prompt_input], outputs=[processed_image, canvas_output])
+    process_button.click(fn=process_frame, inputs=[image_input, prompt_input, negative_prompt_input], outputs=[canvas_output])
+
+demo.launch(share=True)

appcopy.py

@@ -0,0 +1,86 @@
+import gradio as gr
+import cv2
+import torch
+import numpy as np
+from diffusers import StableDiffusionPipeline,AutoPipelineForImage2Image,AutoencoderTiny
+from transformers import AutoProcessor, AutoModel, AutoTokenizer
+from PIL import Image
+
+# 
+# 
+# def predict(prompt, frame):
+#     generator = torch.manual_seed(params.seed)
+#     steps = params.steps
+#     strength = params.strength
+#     if int(steps * strength) < 1:
+#         steps = math.ceil(1 / max(0.10, strength))
+# 
+#     prompt = params.prompt
+#     prompt_embeds = None
+#     
+#     results = self.pipe(
+#         image=frame,
+#         prompt_embeds=prompt_embeds,
+#         prompt=prompt,
+#         negative_prompt=params.negative_prompt,
+#         generator=generator,
+#         strength=strength,
+#         num_inference_steps=steps,
+#         guidance_scale=1.1,
+#         width=params.width,
+#         height=params.height,
+#         output_type="pil",
+#         )
+# 
+#     nsfw_content_detected = (
+#         results.nsfw_content_detected[0]
+#         if "nsfw_content_detected" in results
+#         else False
+#     )
+#     if nsfw_content_detected:
+#         return None
+#     result_image = results.images[0]
+# 
+#     return result_image
+# 
+# def process_frame(frame, prompt="A futuristic landscape"):
+#     """Process a single frame using the real-time latent consistency model."""
+#     
+#     # Convert frame to PIL image
+#     image = Image.fromarray(cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)).resize((512, 512))
+#     
+#     # Apply Real-Time Latent Consistency Model
+#     result = realtime_pipe(prompt=prompt, image=image, strength=0.5, guidance_scale=7.5).images[0]
+#     return np.array(result)
+
+def video_stream(prompt):
+    """Captures video feed from webcam and sends to the AI model."""
+    cap = cv2.VideoCapture(0)
+    while cap.isOpened():
+        ret, frame = cap.read()
+        if not ret:
+            break
+        
+        frame = process_frame(frame, prompt)
+        yield frame  # Return processed frame
+    cap.release()
+
+
+# Create Gradio App
+with gr.Blocks() as demo:
+    gr.Markdown("## 🎨 Real-Time AI-Enhanced Webcam using Latent Consistency Model (LCM)")
+    
+    with gr.Row():
+        webcam_feed = gr.Camera(streaming=True, label="Live Webcam")
+        processed_image = gr.Image(label="AI-Enhanced Webcam Feed")
+    
+    with gr.Row():
+        canvas_output = gr.Image(interactive=True, label="Canvas - Processed Image Output")
+    
+    prompt_input = gr.Textbox(label="Real-Time LCM Prompt", value="A futuristic landscape")
+    start_button = gr.Button("Start Real-Time AI Enhancement")
+    
+    #start_button.click(fn=video_stream, inputs=[prompt_input], outputs=[processed_image, canvas_output])
+
+demo.launch(share=True)
+