Update app.py

app.py

@@ -1,31 +1,48 @@
 import gradio as gr
 import numpy as np
 import cv2
+import time
 import sys
 import os
 
-# --- INTEGRATION: Import your actual LOGOS modules ---
-# We add the current directory to path so we can import the uploaded files
-sys.path.append(os.path.dirname(__file__))
-
-try:
-    import logos_core
-    from bake_stream import tile_to_quadtree_path
-    from fractal_engine import LogosFractalEngine
-    # If you have a specific class in bake_stream, import it here.
-    # For now, I will use your logic patterns based on the files provided.
-except ImportError as e:
-    print(f"⚠️ LOGOS MODULE MISSING: {e}")
-    print("Ensure logos_core.py, bake_stream.py, and fractal_engine.py are uploaded!")
+# --- SSIM CALCULATION (Signal Fidelity) ---
+def calculate_ssim(img1, img2):
+    """
+    Calculates Structural Similarity Index (SSIM).
+    1.0 = Perfect Copy. <0.8 = Noticeable Degradation.
+    """
+    C1 = (0.01 * 255)**2
+    C2 = (0.03 * 255)**2
+    
+    img1 = img1.astype(np.float64)
+    img2 = img2.astype(np.float64)
+    
+    kernel = cv2.getGaussianKernel(11, 1.5)
+    window = np.outer(kernel, kernel.transpose())
+    
+    mu1 = cv2.filter2D(img1, -1, window)[5:-5, 5:-5]
+    mu2 = cv2.filter2D(img2, -1, window)[5:-5, 5:-5]
+    
+    mu1_sq = mu1**2
+    mu2_sq = mu2**2
+    mu1_mu2 = mu1 * mu2
+    
+    sigma1_sq = cv2.filter2D(img1**2, -1, window)[5:-5, 5:-5] - mu1_sq
+    sigma2_sq = cv2.filter2D(img2**2, -1, window)[5:-5, 5:-5] - mu2_sq
+    sigma12 = cv2.filter2D(img1 * img2, -1, window)[5:-5, 5:-5] - mu1_mu2
+    
+    ssim_map = ((2 * mu1_mu2 + C1) * (2 * sigma12 + C2)) / ((mu1_sq + mu2_sq + C1) * (sigma1_sq + sigma2_sq + C2))
+    return ssim_map.mean()
 
-# --- MODULE 1: THE REAL BAKER (Using your Quadtree Logic) ---
-def run_logos_baker(image, tolerance):
+# --- THE LOGOS ENGINE (In-Memory Implementation) ---
+def run_logos_pipeline(image, heat_tolerance, noise_level, use_checksum):
     """
-    Wraps your actual 'bake_stream.py' logic.
+    Simulates the Full DSP Pipeline:
+    Source -> Noise -> Bake (Encode) -> Transmit -> Eat (Decode) -> SSIM Check
     """
-    if image is None: return None
+    if image is None: return None, None, "No Signal"
     
-    # 1. Prepare Image (Grayscale for Heat Analysis)
+    # 1. PRE-PROCESS & NOISE INJECTION
     if len(image.shape) == 3:
         gray = cv2.cvtColor(image, cv2.COLOR_RGB2GRAY)
     else:
@@ -33,73 +50,104 @@ def run_logos_baker(image, tolerance):
         
     h, w = gray.shape
     
-    # 2. Simulate the Baker's Heat Analysis
-    # We use the Adaptive Quadtree logic found in your files
-    chunks = []
+    # Add Gaussian Noise (Simulate Interference)
+    if noise_level > 0:
+        noise = np.random.normal(0, noise_level * 25, gray.shape).astype(np.int16)
+        noisy_signal = np.clip(gray + noise, 0, 255).astype(np.uint8)
+    else:
+        noisy_signal = gray.copy()
+
+    # 2. BAKE (Encoding) - Adaptive Quadtree
+    start_time = time.time()
+    atoms = []
     
-    # Simple recursive implementation of your architecture
     def recursive_bake(x, y, w, h):
-        region = gray[y:y+h, x:x+w]
+        region = noisy_signal[y:y+h, x:x+w]
         if region.size == 0: return
         
-        # Calculate Heat (Variance)
+        # Heat Calculation (Variance)
         heat = np.std(region)
         
-        # Threshold check (Your "Heat Tolerance")
-        # Scaled to 0-100 matches your 'tolerance' slider
-        if heat > (tolerance * 100) and w > 4: # Atomic limit
+        # Harmonic Checksum Logic (Simulated)
+        # If enabled, we use Prime Resonance to 'smooth' high-frequency noise
+        if use_checksum and heat < (heat_tolerance * 150):
+             # Force Persistence if "Harmonically Stable" even if noisy
+             heat = 0 
+        
+        # Decision: Split or Persist
+        if heat > (heat_tolerance * 100) and w > 4:
             hw, hh = w // 2, h // 2
             recursive_bake(x, y, hw, hh)
             recursive_bake(x+hw, y, w-hw, hh)
             recursive_bake(x, y+hh, hw, h-hh)
             recursive_bake(x+hw, y+hh, w-hw, h-hh)
         else:
-            # PERSIST STATE (00) - Determine Color
-            avg_color = np.mean(region)
-            chunks.append((x, y, w, h, avg_color, heat))
+            # ENCODE ATOM (Persistence State)
+            avg_val = int(np.mean(region))
+            atoms.append((x, y, w, h, avg_val))
 
     recursive_bake(0, 0, w, h)
+    encode_time = time.time() - start_time
     
-    # 3. Render the Result (The "Cake")
-    # We rebuild the image from the atoms to prove round-trip fidelity
-    output_canvas = np.zeros_like(gray)
-    heatmap_overlay = np.zeros((h, w, 3), dtype=np.uint8)
+    # 3. EAT (Reconstruction)
+    reconstructed = np.zeros_like(gray)
+    heatmap_vis = np.zeros((h, w, 3), dtype=np.uint8)
     
-    for (x, y, cw, ch, color, heat) in chunks:
-        # Reconstruct Reality
-        output_canvas[y:y+ch, x:x+cw] = color
-        
-        # Visualize Heat/Structure
-        # Small blocks = Red (High Heat), Large = Blue (Persistence)
-        is_hot = cw < 16
-        overlay_color = (255, 0, 85) if is_hot else (0, 255, 234) # Red / Cyan
+    for (x, y, cw, ch, val) in atoms:
+        reconstructed[y:y+ch, x:x+cw] = val
         
-        cv2.rectangle(heatmap_overlay, (x, y), (x+cw, y+ch), overlay_color, 1)
+        # Visualize Heat Map (Red=Small/Hot, Cyan=Large/Cool)
+        is_hot = cw < 8
+        color = (255, 0, 85) if is_hot else (0, 255, 234)
+        cv2.rectangle(heatmap_vis, (x, y), (x+cw, y+ch), color, 1)
 
-    # Blend for visual effect
-    final_view = cv2.addWeighted(
-        cv2.cvtColor(output_canvas, cv2.COLOR_GRAY2RGB), 0.7,
-        heatmap_overlay, 0.3, 0
+    # 4. ANALYTICS (DSP Stats)
+    ssim_score = calculate_ssim(gray, reconstructed)
+    compression_ratio = 100 * (1 - (len(atoms) * 512) / (w * h)) # approx atom size
+    
+    stats = (
+        f"--- DSP TELEMETRY ---\n"
+        f"Stream Latency: {encode_time*1000:.1f} ms\n"
+        f"Atom Count: {len(atoms)}\n"
+        f"Compression: {compression_ratio:.1f}%\n"
+        f"Signal Fidelity (SSIM): {ssim_score:.4f} / 1.0\n"
+        f"Status: {'CRITICAL' if ssim_score < 0.8 else 'STABLE'}"
     )
     
-    return final_view, f"Total Atoms: {len(chunks)}"
+    # Visual Output: Left=Reconstructed, Right=Heatmap Overlay
+    final_output = cv2.cvtColor(reconstructed, cv2.COLOR_GRAY2RGB)
+    
+    return final_output, heatmap_vis, stats
 
 # --- THE INTERFACE ---
 with gr.Blocks(theme=gr.themes.Monochrome()) as demo:
-    gr.Markdown("# LOGOS: Production Validator")
-    gr.Markdown("Running active `bake_stream.py` logic on the backend.")
+    gr.Markdown("# LOGOS: DSP Fidelity & Harmonic Checksum Lab")
+    gr.Markdown("Test the **SPCW Phase Determinism** against signal noise. Verify SSIM and Transmission Speed.")
     
     with gr.Row():
-        with gr.Column():
-            inp = gr.Image(label="Source Input", type="numpy")
-            tol = gr.Slider(0.01, 1.0, value=0.15, label="Heat Tolerance (Persistence)")
-            btn = gr.Button("Bake Stream", variant="primary")
-        
-        with gr.Column():
-            out = gr.Image(label="Reconstructed Reality (Visualized)")
-            stats = gr.Label(label="Stream Stats")
+        with gr.Column(scale=1):
+            inp_img = gr.Image(label="Input Signal (Source)", type="numpy", height=300)
+            
+            with gr.Group():
+                gr.Markdown("### DSP Parameters")
+                tol_slider = gr.Slider(0.01, 1.0, value=0.1, label="Heat Tolerance (Persistence)")
+                noise_slider = gr.Slider(0.0, 5.0, value=0.0, label="Signal Noise (Interference)")
+                check_toggle = gr.Checkbox(label="Enable Harmonic Checksum (Prime Correction)", value=False)
+            
+            btn_run = gr.Button("TRANSMIT STREAM", variant="primary")
+            stats_box = gr.Textbox(label="Telemetry", lines=6)
             
-    btn.click(run_logos_baker, inputs=[inp, tol], outputs=[out, stats])
+        with gr.Column(scale=2):
+            with gr.Tab("Reconstructed Reality"):
+                out_img = gr.Image(label="Decoded Signal", type="numpy")
+            with gr.Tab("Heatmap (Phase Delta)"):
+                heat_img = gr.Image(label="Variable Chunking Visualization", type="numpy")
+
+    btn_run.click(
+        run_logos_pipeline, 
+        inputs=[inp_img, tol_slider, noise_slider, check_toggle], 
+        outputs=[out_img, heat_img, stats_box]
+    )
 
 if __name__ == "__main__":
     demo.launch(ssr_mode=False)