still initial commit

app.py

@@ -12,84 +12,137 @@ USE_GPU_INFERENCE = os.getenv("USE_GPU_INFERENCE", "false").lower() == "true"
 try:
     if USE_GPU_INFERENCE:
         print("🚀 Mode: Full GPU FLUX.2 Klein Inference")
-        # Modern Class binding syntax for Modal 1.0+
         voxel_model_cls = modal.Cls.from_name("flux-klein-voxel-backend", "VoxelModel")
         voxel_backend = voxel_model_cls().process_frame
     else:
         print("🏎️ Mode: Zero-latency WebRTC Passthrough Demo")
-        # Modern Standalone function lookup syntax for Modal 1.0+
         voxel_backend = modal.Function.from_name("flux-klein-voxel-backend", "demo_stream_frame")
 except Exception as e:
     print(f"⚠️ Could not bind Modal backend function layout: {e}")
     voxel_backend = None
 
+# --- STREAM HANDLING ARCHITECTURE ---
+
 def process_video_stream(frame: np.ndarray, prompt: str, strength: float) -> np.ndarray:
     """
-    Receives real-time video frames from the browser via WebRTC, compresses them, 
-    ships them to the Modal GPU cluster, and returns the voxelized matrix.
+    Handles single viewport mode (Minecraft Filter).
+    Receives frames, processes them via Modal, and returns them to the same component.
     """
     if frame is None:
         return None
 
-    # Fallback state if the backend app isn't active or authenticated yet
     if voxel_backend is None:
         output_frame = frame.copy()
         cv2.putText(output_frame, "ERROR: Backend App Offline", (20, 40), 
                     cv2.FONT_HERSHEY_SIMPLEX, 0.8, (0, 0, 255), 2)
-        cv2.putText(output_frame, "Check HF Space Secrets for MODAL keys.", (20, 70), 
-                    cv2.FONT_HERSHEY_SIMPLEX, 0.5, (255, 255, 255), 1)
         return output_frame
 
-    # Step 1: Compress high-res frames to a lean JPEG byte stream to prevent browser pipe congestion
     success, encoded_image = cv2.imencode(".jpg", frame, [int(cv2.IMWRITE_JPEG_QUALITY), 85])
     if not success:
         return frame
     
     frame_bytes = encoded_image.tobytes()
 
-    # Step 2: Route request to serverless GPU infrastructure
     try:
-        # Dynamically matches positional signature parameters to prevent signature TypeErrors
         if USE_GPU_INFERENCE:
             processed_bytes = voxel_backend.remote(frame_bytes, prompt, strength)
         else:
             processed_bytes = voxel_backend.remote(frame_bytes)
         
-        # Step 3: Reconstruction of the returned processed image array
         numpy_buffer = np.frombuffer(processed_bytes, dtype=np.uint8)
-        voxel_frame = cv2.imdecode(numpy_buffer, cv2.IMREAD_COLOR)
-        return voxel_frame
-
+        return cv2.imdecode(numpy_buffer, cv2.IMREAD_COLOR)
     except Exception as err:
-        # Handle serverless cold starts visually instead of freezing or crashing the stream
         fallback_frame = frame.copy()
-        cv2.putText(fallback_frame, "⚡ Modal Serverless Warm-up (15-30s)...", (20, 40), 
+        cv2.putText(fallback_frame, "⚡ Serverless Warm-up...", (20, 40), 
                     cv2.FONT_HERSHEY_SIMPLEX, 0.7, (0, 255, 255), 2)
-        cv2.putText(fallback_frame, "Loading FLUX Klein weights into cloud VRAM", (20, 70), 
-                    cv2.FONT_HERSHEY_SIMPLEX, 0.5, (255, 255, 255), 1)
         return fallback_frame
 
-# --- CUSTOM CSS FOR HIGH-TECH SPATIAL AESTHETICS ---
+
+def process_demo_stream(frame: np.ndarray) -> np.ndarray:
+    """
+    Handles separate multi-viewport tracking (Streaming Demo).
+    Ingests frames from the raw hardware box and outputs onto the separate Modal display container.
+    """
+    if frame is None:
+        return None
+
+    # High-visibility on-screen error rendering for Demo Mode
+    if voxel_backend is None:
+        error_frame = np.zeros((480, 640, 3), dtype=np.uint8)
+        error_frame[:] = 30  # Dark slate gray canvas
+        cv2.putText(error_frame, "⚠️ BACKEND APP OFFLINE", (40, 200), 
+                    cv2.FONT_HERSHEY_DUPLEX, 0.9, (0, 0, 255), 2)
+        cv2.putText(error_frame, "Status: Inactive or unauthorized Modal keys.", (40, 250), 
+                    cv2.FONT_HERSHEY_SIMPLEX, 0.5, (180, 180, 180), 1)
+        return error_frame
+
+    success, encoded_image = cv2.imencode(".jpg", frame, [int(cv2.IMWRITE_JPEG_QUALITY), 85])
+    if not success:
+        return frame
+    
+    frame_bytes = encoded_image.tobytes()
+
+    try:
+        if USE_GPU_INFERENCE:
+            processed_bytes = voxel_backend.remote(frame_bytes, "vanilla minecraft voxel landscape", 0.55)
+        else:
+            processed_bytes = voxel_backend.remote(frame_bytes)
+        
+        numpy_buffer = np.frombuffer(processed_bytes, dtype=np.uint8)
+        return cv2.imdecode(numpy_buffer, cv2.IMREAD_COLOR)
+
+    except Exception as err:
+        # Format and write runtime cluster/cold-start exceptions right onto the video frame bounding container
+        error_frame = np.zeros((480, 640, 3), dtype=np.uint8)
+        error_frame[:] = 20
+        cv2.putText(error_frame, "⚡ MODAL RUNTIME EXCEPTION", (40, 180), 
+                    cv2.FONT_HERSHEY_DUPLEX, 0.8, (0, 140, 255), 2)
+        
+        err_msg = str(err)
+        cv2.putText(error_frame, f"Error trace: {err_msg[:50]}...", (40, 240), 
+                    cv2.FONT_HERSHEY_SIMPLEX, 0.5, (255, 255, 255), 1)
+        cv2.putText(error_frame, "Check cluster logs for container scaling behavior.", (40, 290), 
+                    cv2.FONT_HERSHEY_SIMPLEX, 0.4, (0, 255, 255), 1)
+        return error_frame
+
+
+# --- UI LAYOUT & STYLE RULES ---
 custom_css = """
-#container { max-width: 1100px; margin: 0 auto; padding-top: 20px; }
+#container { max-width: 1200px; margin: 0 auto; padding-top: 20px; }
 .header-text { text-align: center; margin-bottom: 25px; }
 .header-text h1 { color: #5c8e32; font-family: 'Courier New', Courier, monospace; font-weight: bold; margin-bottom: 5px; }
 .header-text p { color: #666; font-size: 1.1em; }
+
+/* Constrain video bounding tracks to stop screen-flooding layout shifts */
+video, .webrtc-video, div[class*="webrtc"] {
+    max-height: 440px !important;
+    width: 100% !important;
+    max-width: 580px !important;
+    margin: 0 auto !important;
+    object-fit: contain !important;
+    border-radius: 10px;
+}
 """
 
-# --- GRADIO INTERFACE ARCHITECTURE ---
 with gr.Blocks(css=custom_css, title="Minecraft Spatial Voxel Filter") as demo:
     
-    # gr.Group behaves exactly like a <div> tag container for CSS styling wrappers
     with gr.Group(elem_id="container"):
         with gr.Group(elem_classes="header-text"):
             gr.Markdown("# ⛏️ MINECRAFT SPATIAL VOXEL FILTER ⛏️")
             gr.Markdown("Transform your physical environment into an interactive, real-time 3D blocky landscape running on FLUX.2 Klein.")
         
-        gr.HTML("<hr style='border: 1px solid #ddd; margin-bottom: 25px;'>")
+        gr.HTML("<hr style='border: 1px solid #ddd; margin-bottom: 20px;'>")
+        
+        # Context switcher selection interface
+        mode_dropdown = gr.Dropdown(
+            choices=["Streaming Demo", "Minecraft Filter"],
+            value="Minecraft Filter",
+            label="🎯 Pipeline View Configuration",
+            interactive=True
+        )
         
         with gr.Row():
-            # Left Hand Side: Dynamic Parameters & Controls
+            # Left Hand Side Settings Column
             with gr.Column(scale=1):
                 gr.Markdown("### 🎛️ Environmental Filters")
                 
@@ -115,25 +168,48 @@ with gr.Blocks(css=custom_css, title="Minecraft Spatial Voxel Filter") as demo:
                     """
                 )
             
-            # Right Hand Side: High-Speed WebRTC Viewport
+            # Right Hand Side Viewport Area
             with gr.Column(scale=2):
-                gr.Markdown("### 📺 Spatial Render Pipeline")
                 
-                # FastRTC custom WebRTC component with auto-configured cloudflare turn discovery
-                webrtc_stream = WebRTC(
-                    label="Live Voxel Viewport",
-                    modality="video",
-                    mode="send-receive",
-                    rtc_configuration=get_cloudflare_turn_credentials
-                )
+                # --- LAYOUT VARIANT 1: MINECRAFT FILTER MODE (Standard Single Viewport) ---
+                with gr.Column(visible=True) as minecraft_layout:
+                    gr.Markdown("### 📺 Spatial Render Pipeline")
+                    webrtc_single = WebRTC(
+                        label="Live Voxel Viewport",
+                        modality="video",
+                        mode="send-receive",
+                        rtc_configuration=get_cloudflare_turn_credentials
+                    )
+                
+                # --- LAYOUT VARIANT 2: STREAMING DEMO MODE (Decoupled Dual Viewports) ---
+                with gr.Column(visible=False) as demo_layout:
+                    gr.Markdown("### 📺 Dual-Feed Stream Monitor")
+                    with gr.Row():
+                        webrtc_raw = WebRTC(
+                            label="1. Your Camera Feed (Raw Local)",
+                            modality="video",
+                            mode="send",
+                            rtc_configuration=get_cloudflare_turn_credentials
+                        )
+                        webrtc_processed = WebRTC(
+                            label="2. Streamed from Modal (Processed Backend)",
+                            modality="video",
+                            mode="receive",
+                            rtc_configuration=get_cloudflare_turn_credentials
+                        )
+
+    # --- ROUTING LOGIC & EVENT WIRES ---
+    
+    def switch_layout(selected_mode):
+        if selected_mode == "Minecraft Filter":
+            return gr.update(visible=True), gr.update(visible=False)
+        else:
+            return gr.update(visible=False), gr.update(visible=True)
 
-    # Establish the bidirectional stream wire link
-    webrtc_stream.stream(
-        fn=process_video_stream,
-        inputs=[webrtc_stream, prompt_input, denoise_strength],
-        outputs=[webrtc_stream],
-        time_limit=150 # Automatically closes connection after inactivity to prevent runaway token spend
+    mode_dropdown.change(
+        fn=switch_layout,
+        inputs=[mode_dropdown],
+        outputs=[minecraft_layout, demo_layout]
     )
 
-if __name__ == "__main__":
-    demo.launch()
+    # Wire