Update app.py

app.py

@@ -1,9 +1,11 @@
 import gradio as gr
 import os, math, tempfile
 import numpy as np
-from PIL import Image
+from PIL import Image, UnidentifiedImageError
 
-# --- FLC v1.3 Logic Engine (The "Secret Sauce") ---
+# ==========================================
+# FLC v1.3 Logic Engine (The "Secret Sauce")
+# ==========================================
 PHI = (1.0 + 5.0**0.5) / 2.0
 
 def fibonacci_sequence(n):
@@ -46,7 +48,9 @@ def idct_ortho_1d(X):
     V[N+1:] = np.conj(c[1:][::-1])
     return np.fft.ifft(V).real[:N]
 
+# --- Visualization Helpers ---
 def hologram_spectrum_image(zints):
+    # Visualizes the frequency domain data as a 2D spectrum
     z = zints[:262144]; v = np.tanh(z / 32.0)
     theta = (2 * math.pi / (PHI**2)) * np.arange(v.size) + 2.0 * math.pi * (v * 0.25)
     r = 1.0 + 0.35 * np.abs(v)
@@ -58,6 +62,7 @@ def hologram_spectrum_image(zints):
     return (mag * 255).astype(np.uint8)
 
 def bytes_to_fib_spiral_image(data):
+    # Visualizes linear data arranged on a Fibonacci spiral tiling
     arr = np.frombuffer(data, dtype=np.uint8)[:262144]
     fibs = [1, 1]
     while sum(s*s for s in fibs) < arr.size: fibs.append(fibs[-1] + fibs[-2])
@@ -80,72 +85,141 @@ def bytes_to_fib_spiral_image(data):
         idx += take
     return img
 
-# --- Main Demo Logic ---
-def run_demo(input_file, fidelity):
-    with open(input_file.name, "rb") as f:
-        raw_data = f.read()
+# ==========================================
+# Main Processing Logic
+# ==========================================
+def run_demo(input_file_wrapper, fidelity):
+    # Determine input type and prepare data
+    is_image = False
+    orig_pil = None
+    img_dims = None
     
+    try:
+        # Try opening as an image
+        orig_pil = Image.open(input_file_wrapper.name).convert('L') # Convert to grayscale for core engine
+        # Resize large images for demo performance constraint
+        orig_pil.thumbnail((512, 512)) 
+        img_dims = orig_pil.size # (width, height)
+        raw_data = np.array(orig_pil).tobytes()
+        is_image = True
+    except (UnidentifiedImageError, OSError):
+        # Fallback for non-image binary data
+        with open(input_file_wrapper.name, "rb") as f:
+            raw_data = f.read()
+
     orig_size = len(raw_data)
-    q_settings = {"High Compression": 6, "Balanced": 12, "Near-Lossless": 24}
+    
+    # FLC Parameters based on user selection
+    q_settings = {"High Compression (Lossy)": 6, "Balanced": 12, "Near-Lossless": 24}
     n_bands = q_settings[fidelity]
-    step = 0.08 if fidelity == "High Compression" else (0.005 if fidelity == "Balanced" else 0.0001)
+    # Aggressive steps for lower tiers to show visual difference
+    step = 0.15 if fidelity == "High Compression (Lossy)" else (0.01 if fidelity == "Balanced" else 0.0001)
     
-    # Process Data
+    # --- Step 1: Transform & Quantize (Compression Simulation) ---
+    # Normalize data to range [-1, 1]
     x = (np.frombuffer(raw_data, dtype=np.uint8).astype(float) - 127.5) / 127.5
     block_len = 1024
-    X = np.pad(x, (0, (-x.size) % block_len)).reshape(-1, block_len)
+    pad_len = (-x.size) % block_len
+    X = np.pad(x, (0, pad_len)).reshape(-1, block_len)
     
+    # Forward DCT
     C = np.array([dct_ortho_1d(b) for b in X])
+    # Determine Fibonacci bands
     bnds = fibonacci_frequency_boundaries(block_len, n_bands)
+    # Quantize using Phi-scaling
     Q = np.zeros_like(C, dtype=np.int32)
     for bi in range(len(bnds)-1):
         Q[:, bnds[bi]:bnds[bi+1]] = np.round(C[:, bnds[bi]:bnds[bi+1]] / (step * (PHI**bi)))
     
-    # Estimate Compressed size (Simulated)
-    # Using 1.2 as a conservative overhead for Fibonacci entropy coding
-    compressed_size = int(np.count_nonzero(Q) * 1.2)
-    ratio = compressed_size / orig_size
+    # Simulated compressed size estimate (entropy estimate)
+    compressed_size_est = int(np.count_nonzero(Q) * 1.5) + 512 # base overhead
+    ratio = compressed_size_est / orig_size
 
-    # Generate Progressive Reconstruction GIF
+    # --- Step 2: Progressive Reconstruction (Animation) ---
     frames = []
+    final_recon_data = None
+
+    # Iterate through bands to create progressive frames
     for t in range(1, n_bands + 1):
+        # Partial quantization buffer
         Q_p = np.zeros_like(Q)
         for bi in range(t): Q_p[:, bnds[bi]:bnds[bi+1]] = Q[:, bnds[bi]:bnds[bi+1]]
+        
+        # Dequantize back to coefficients
         C_p = np.zeros_like(Q_p, dtype=float)
         for bi in range(len(bnds)-1):
             C_p[:, bnds[bi]:bnds[bi+1]] = Q_p[:, bnds[bi]:bnds[bi+1]] * (step * (PHI**bi))
         
-        recon = np.clip((np.array([idct_ortho_1d(B) for B in C_p]).flatten()[:orig_size] * 127.5) + 127.5, 0, 255).astype(np.uint8)
+        # Inverse DCT and denormalize
+        recon_1d = np.clip((np.array([idct_ortho_1d(B) for B in C_p]).flatten()[:orig_size] * 127.5) + 127.5, 0, 255).astype(np.uint8)
         
-        h_img = Image.fromarray(hologram_spectrum_image(Q_p.flatten())).resize((256, 256))
-        s_img = Image.fromarray(bytes_to_fib_spiral_image(recon.tobytes())).resize((256, 256))
+        if t == n_bands:
+             final_recon_data = recon_1d
+
+        # Create visualization frames
+        h_img = Image.fromarray(hologram_spectrum_image(Q_p.flatten())).resize((256, 256)).convert("RGB")
+        s_img = Image.fromarray(bytes_to_fib_spiral_image(recon_1d.tobytes())).resize((256, 256)).convert("RGB")
         
+        # Combine into one frame
         frame = Image.new("RGB", (512, 280), (15, 15, 25))
         frame.paste(h_img, (0, 12)); frame.paste(s_img, (256, 12))
         frames.append(frame)
 
+    # Save animation
     gif_path = tempfile.mktemp(suffix=".gif")
-    frames[0].save(gif_path, save_all=True, append_images=frames[1:], duration=150, loop=0)
+    frames[0].save(gif_path, save_all=True, append_images=frames[1:], duration=120, loop=0)
     
-    stats = f"Original: {orig_size} bytes\nCompressed: ~{compressed_size} bytes\nRatio: {ratio:.2%}"
-    return gif_path, stats
+    stats = f"Original Size: {orig_size:,} bytes\nSimulated Compressed Size: ~{compressed_size_est:,} bytes\ncompression Ratio: {ratio:.2%}"
+
+    # --- Step 3: Prepare Final Comparison Images ---
+    recon_pil = None
+    if is_image and final_recon_data is not None:
+        # Reshape 1D reconstructed data back to 2D image dimensions
+        recon_pil = Image.fromarray(final_recon_data.reshape((img_dims[1], img_dims[0])))
+
+    # Return results based on input type
+    if is_image:
+        return gif_path, stats, orig_pil, recon_pil
+    else:
+        # If not an image, return None for image image components so they don't display weirdly
+        return gif_path, stats, None, None
 
-# --- Gradio UI Layout ---
-with gr.Blocks(title="FLC v1.3 | Unified Fibonacci Demo") as demo:
+
+# ==========================================
+# Gradio UI Layout
+# ==========================================
+with gr.Blocks(title="FLC v1.3 | Unified Fibonacci Demo", theme=gr.themes.Soft(primary_hue="amber", neutral_hue="slate")) as demo:
     gr.Markdown("# 🌀 Fibonacci Lattice Compression (FLC)")
-    gr.Markdown("Transforming binary data into spectral holograms using the Golden Ratio.")
+    gr.Markdown("Upload an image to see the **Golden Ratio** compress data and reconstruct it progressively.")
     
     with gr.Row():
-        with gr.Column():
-            file_input = gr.File(label="Upload File (Image/Data)")
-            radio_input = gr.Radio(["High Compression", "Balanced", "Near-Lossless"], value="Balanced", label="Fidelity Tier")
-            run_btn = gr.Button("🚀 Execute Holographic Unzip")
-        
-        with gr.Column():
-            gif_output = gr.Image(label="Progressive Reconstruction Sequence")
-            stats_output = gr.Textbox(label="Compression Metrics", interactive=False)
+        with gr.Column(scale=1):
+            with gr.Group():
+                file_input = gr.File(label="1. Upload Input (Image recommended)", file_count="single")
+                radio_input = gr.Radio(["High Compression (Lossy)", "Balanced", "Near-Lossless"], value="Balanced", label="2. Select Fidelity Tier")
+                run_btn = gr.Button("🚀 Run Holographic Compression", variant="primary")
+            
+            stats_output = gr.Textbox(label="Compression Metrics", interactive=False, lines=4)
+
+        with gr.Column(scale=2):
+            gr.Markdown("### 🎞️ Progressive Reconstruction Animation")
+            gr.Markdown("_Left: Frequency Hologram filling up. Right: Data organizing into Fibonacci Spiral._")
+            gif_output = gr.Image(label="Animation Sequence", show_label=False)
+
+    gr.Markdown("---")
+    gr.Markdown("### 🔍 Visual Verification: Original vs. Reconstructed")
+    gr.Markdown("_Determine if the 'Secret Sauce' maintained enough quality at the chosen compression tier._")
+    
+    with gr.Row():
+        orig_image_output = gr.Image(label="Original Input (Grayscale)", type="pil", interactive=False)
+        recon_image_output = gr.Image(label="Final Decompressed Result", type="pil", interactive=False)
 
-    run_btn.click(fn=run_demo, inputs=[file_input, radio_input], outputs=[gif_output, stats_output])
+    # Define the action
+    run_btn.click(
+        fn=run_demo,
+        inputs=[file_input, radio_input],
+        outputs=[gif_output, stats_output, orig_image_output, recon_image_output]
+    )
 
 if __name__ == "__main__":
     demo.launch()