Update app.py

app.py

@@ -1,257 +1,31 @@
 import gradio as gr
 import numpy as np
-import plotly.graph_objects as go
-import sympy
 import cv2
-from collections import Counter
-
-# --- HELPER: GPF CALCULATION ---
-def get_gpf(n):
-    """Returns the Greatest Prime Factor of n."""
-    if n <= 1: return 1
-    i = 2
-    gpf = 1
-    while i * i <= n:
-        if n % i:
-            i += 1
-        else:
-            n //= i
-            gpf = i
-    if n > 1:
-        gpf = n
-    return gpf
-
-# --- MODULE 1: PRIME POTENTIALITY FLOW (The "Arrows" Matrix) ---
-def generate_potentiality_flow(depth):
-    """
-    Visualizes the Prime Potentiality as a Directed Flow (Sankey/Tree).
-    Shows how last digits (1,3,7,9) propagate potentiality to the next magnitude.
-    """
-    # Nodes: Layers of magnitude (10s, 100s, etc.)
-    # Links: Valid transitions where P_n could exist
-    
-    # Simplified visual logic: Mod 10 transitions
-    # Source: The digit (1, 3, 7, 9)
-    # Target: The next prime candidate
-    
-    sources = []
-    targets = []
-    values = []
-    colors = []
-    labels = ["Start"] + [f"Mod {i}" for i in range(10)] + ["Potential Prime"]
-    
-    # Logic: Only 1, 3, 7, 9 allow entry into the "Prime" state
-    prime_endings = [1, 3, 7, 9]
-    
-    # Layer 1: Start -> Mod 10 Buckets
-    for i in range(10):
-        sources.append(0) # Start Node
-        targets.append(i + 1) # Mod Nodes
-        
-        if i in prime_endings:
-            values.append(5) # High flow
-            colors.append("#00ffea") # Cyan (Open Path)
-        else:
-            values.append(1) # Blocked/Low flow
-            colors.append("#333333") # Grey (Blocked)
-
-    # Layer 2: Mod Buckets -> Prime Potential
-    final_node = 11
-    for i in range(10):
-        if i in prime_endings:
-            sources.append(i + 1)
-            targets.append(final_node)
-            values.append(5)
-            colors.append("#00ffea") # Flow continues
-        else:
-            # Dead ends (no link to Prime Potential)
-            pass
-
-    fig = go.Figure(data=[go.Sankey(
-        node = dict(
-            pad = 15,
-            thickness = 20,
-            line = dict(color = "black", width = 0.5),
-            label = labels,
-            color = ["white"] + ["#00ffea" if i in prime_endings else "#ff0055" for i in range(10)] + ["#00ffea"]
-        ),
-        link = dict(
-            source = sources,
-            target = targets,
-            value = values,
-            color = colors
-        ))])
-
-    fig.update_layout(
-        title="Prime Potentiality Flow (Digit Constraints)",
-        template="plotly_dark",
-        height=600
-    )
-    return fig
-
-# --- MODULE 2: WEIGHTED CONNECTIVITY TOPOLOGY (The Web) ---
-def visualize_prime_network(max_integer, show_links):
-    """Plots ALL integers. Connects Composites to their GPF Base."""
-    fig = go.Figure()
-    
-    positions = {} 
-    gpf_map = {}   
-    prime_children_count = Counter() 
-    
-    # Pre-calculate positions to ensure density
-    for n in range(1, max_integer + 1):
-        # Orientation: 0 at TOP (pi/2), Clockwise
-        angle = np.pi/2 - (2 * np.pi * (n % 10)) / 10
-        radius = n 
-        x = radius * np.cos(angle)
-        y = radius * np.sin(angle)
-        positions[n] = (x, y)
-        
-        if n > 1:
-            if not sympy.isprime(n):
-                gpf = get_gpf(n)
-                gpf_map[n] = gpf
-                prime_children_count[gpf] += 1
-
-    # DRAW CONNECTIVITY (The Tessellation)
-    if show_links:
-        edge_x, edge_y = [], []
-        for n, base in gpf_map.items():
-            if base in positions:
-                x0, y0 = positions[n]
-                x1, y1 = positions[base]
-                edge_x.extend([x0, x1, None])
-                edge_y.extend([y0, y1, None])
-        
-        fig.add_trace(go.Scatter(
-            x=edge_x, y=edge_y,
-            mode='lines',
-            line=dict(color='rgba(100, 100, 100, 0.2)', width=0.5),
-            hoverinfo='none',
-            name='GPF Gravity'
-        ))
-
-    # DRAW NODES
-    prime_x, prime_y, prime_size, prime_text = [], [], [], []
-    comp_x, comp_y, comp_text = [], [], []
-    
-    for n in range(1, max_integer + 1):
-        x, y = positions[n]
-        if sympy.isprime(n) or n == 1:
-            prime_x.append(x)
-            prime_y.append(y)
-            weight = prime_children_count[n]
-            # Logarithmic size scaling
-            size = 5 + (np.log(weight + 1) * 6) 
-            prime_size.append(size)
-            prime_text.append(f"<b>PRIME: {n}</b><br>Gravity: {weight}")
-        else:
-            comp_x.append(x)
-            comp_y.append(y)
-            comp_text.append(f"Composite: {n}<br>Base: {gpf_map.get(n)}")
-
-    # Composites (Red/Pink Dust)
-    fig.add_trace(go.Scatter(
-        x=comp_x, y=comp_y,
-        mode='markers',
-        marker=dict(size=3, color='#ff0055', opacity=0.6),
-        text=comp_text,
-        hoverinfo='text',
-        name='Composites'
-    ))
-
-    # Primes (Cyan Anchors)
-    fig.add_trace(go.Scatter(
-        x=prime_x, y=prime_y,
-        mode='markers',
-        marker=dict(size=prime_size, color='#00ffea', line=dict(width=1, color='white')),
-        text=prime_text,
-        hoverinfo='text',
-        name='Prime Anchors'
-    ))
-
-    # Radial Spokes Background
-    for i in range(10):
-        angle = np.pi/2 - (2 * np.pi * i) / 10
-        fig.add_trace(go.Scatter(
-            x=[0, max_integer * 1.1 * np.cos(angle)],
-            y=[0, max_integer * 1.1 * np.sin(angle)],
-            mode='lines',
-            line=dict(color='#222', width=1, dash='dot'),
-            showlegend=False
-        ))
-
-    fig.update_layout(
-        title=f"Radial Prime Connectivity (Max: {max_integer})",
-        template="plotly_dark",
-        xaxis=dict(showgrid=False, zeroline=False, visible=False),
-        yaxis=dict(showgrid=False, zeroline=False, visible=False),
-        width=800, height=800,
-        showlegend=True
-    )
-    return fig
-
-# --- MODULE 3: GPF COMPOSITE DENSITY ---
-def visualize_gpf_counts(sequence_length):
-    """Counts composites by their Greatest Prime Factor (GPF)."""
-    gpf_counts = Counter()
-    for n in range(4, sequence_length):
-        if not sympy.isprime(n):
-            gpf = get_gpf(n)
-            gpf_counts[gpf] += 1
-            
-    sorted_gpfs = sorted(gpf_counts.keys())
-    counts = [gpf_counts[p] for p in sorted_gpfs]
-    
-    fig = go.Figure(data=go.Bar(
-        x=sorted_gpfs,
-        y=counts,
-        marker_color='#ff7f00',
-        name="Composite Count"
-    ))
-    
-    fig.update_layout(
-        title="Composite Density by GPF Base",
-        xaxis_title="Prime Base (P)",
-        yaxis_title="Composites Anchored",
-        template="plotly_dark",
-        xaxis=dict(type='category')
-    )
-    return fig
-
-# --- MODULE 4: REAL IMAGE CHUNKING (USER INPUT) ---
-def recursive_quadtree_image(img_gray, x, y, w, h, tolerance, chunks):
-    """Recursive decomposition on real image data."""
-    # 1. Get Region
-    region = img_gray[y:y+h, x:x+w]
-    if region.size == 0: return
-
-    # 2. Measure Heat (Standard Deviation)
-    heat = np.std(region)
-    
-    # 3. Decision
-    # Scale tolerance to 0-255 range approximately
-    tol_val = tolerance * 100 
-    
-    if heat > tol_val and w > 4: # Min size 4px
-        hw, hh = w // 2, h // 2
-        recursive_quadtree_image(img_gray, x, y, hw, hh, tolerance, chunks)
-        recursive_quadtree_image(img_gray, x+hw, y, w-hw, hh, tolerance, chunks)
-        recursive_quadtree_image(img_gray, x, y+hh, hw, h-hh, tolerance, chunks)
-        recursive_quadtree_image(img_gray, x+hw, y+hh, w-hw, h-hh, tolerance, chunks)
-    else:
-        # Persist Atom
-        chunks.append((x, y, w, h, heat))
-
-def process_uploaded_image(image, tolerance):
+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!")
+
+# --- MODULE 1: THE REAL BAKER (Using your Quadtree Logic) ---
+def run_logos_baker(image, tolerance):
     """
-    Takes user uploaded image -> Grayscale -> Quadtree -> Visualization.
+    Wraps your actual 'bake_stream.py' logic.
     """
-    if image is None:
-        return None
+    if image is None: return None
     
-    # 1. Preprocess
-    # Convert to grayscale for heat analysis (variance is scalar)
+    # 1. Prepare Image (Grayscale for Heat Analysis)
     if len(image.shape) == 3:
         gray = cv2.cvtColor(image, cv2.COLOR_RGB2GRAY)
     else:
@@ -259,89 +33,73 @@ def process_uploaded_image(image, tolerance):
         
     h, w = gray.shape
     
-    # 2. Run LOGOS Baker
+    # 2. Simulate the Baker's Heat Analysis
+    # We use the Adaptive Quadtree logic found in your files
     chunks = []
-    recursive_quadtree_image(gray, 0, 0, w, h, tolerance, chunks)
     
-    # 3. Visualize
-    fig = go.Figure()
+    # Simple recursive implementation of your architecture
+    def recursive_bake(x, y, w, h):
+        region = gray[y:y+h, x:x+w]
+        if region.size == 0: return
+        
+        # Calculate Heat (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
+            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))
+
+    recursive_bake(0, 0, w, h)
     
-    # Background: The original image (dimmed)
-    # Plotly Image needs to be base64 or array. 
-    # For speed in heatmap, we invert the y-axis logic.
-    fig.add_trace(go.Heatmap(z=np.flipud(gray), colorscale='Gray', showscale=False, opacity=0.3))
+    # 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)
     
-    # Draw The Atoms (Rectangles)
-    shapes = []
-    for (cx, cy, cw, ch, heat) in chunks:
-        # High Heat (Small) = Red/Orange
-        # Low Heat (Large) = Cyan/Blue
-        is_hot = cw < 16
-        color = '#ff0055' if is_hot else '#00ffea'
-        width = 1
-        
-        # Plotly shapes use bottom-left origin for some things, but rects are cartesian
-        # We need to map image coords (y down) to plot coords (y up)
-        # Or just tell layout to reverse y.
+    for (x, y, cw, ch, color, heat) in chunks:
+        # Reconstruct Reality
+        output_canvas[y:y+ch, x:x+cw] = color
         
-        shapes.append(dict(
-            type="rect", 
-            x0=cx, y0=cy, 
-            x1=cx+cw, y1=cy+ch,
-            line=dict(color=color, width=width),
-            fillcolor=color, opacity=0.1 if is_hot else 0.05
-        ))
+        # 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
         
-    fig.update_layout(
-        title=f"LOGOS Adaptive Compression (Atoms: {len(chunks)})",
-        shapes=shapes,
-        template="plotly_dark",
-        height=800,
-        width=800,
-        xaxis=dict(showgrid=False, visible=False, range=[0, w]),
-        yaxis=dict(showgrid=False, visible=False, range=[h, 0], autorange="reversed") # Image coords
+        cv2.rectangle(heatmap_overlay, (x, y), (x+cw, y+ch), overlay_color, 1)
+
+    # Blend for visual effect
+    final_view = cv2.addWeighted(
+        cv2.cvtColor(output_canvas, cv2.COLOR_GRAY2RGB), 0.7,
+        heatmap_overlay, 0.3, 0
     )
-    return fig
+    
+    return final_view, f"Total Atoms: {len(chunks)}"
 
 # --- THE INTERFACE ---
-def build_demo():
-    with gr.Blocks(theme=gr.themes.Monochrome()) as demo:
-        gr.Markdown("# LOGOS: Prime-Indexed Topology & Compression Validator")
+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.")
+    
+    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.Tab("1. Prime Potentiality Flow"):
-            gr.Markdown("Visualizing the **Digit Constraints**: Only 1, 3, 7, 9 allow Prime formation.")
-            depth_slider = gr.Slider(10, 100, value=10, label="Visual Depth") # Just for trigger
-            flow_plot = gr.Plot(label="Potentiality Flow")
-            btn_flow = gr.Button("Generate Flow")
-            btn_flow.click(generate_potentiality_flow, inputs=[depth_slider], outputs=flow_plot)
-
-        with gr.Tab("2. Radial Topology (The Web)"):
-            gr.Markdown("**The Natural Tessellation:** Composites connected to their Prime Base.")
-            rad_len = gr.Slider(100, 2000, value=500, label="Integer Range")
-            link_toggle = gr.Checkbox(value=True, label="Show Connectivity")
-            matroska_plot = gr.Plot(label="Radial View")
-            btn_net = gr.Button("Build Network")
-            btn_net.click(visualize_prime_network, inputs=[rad_len, link_toggle], outputs=matroska_plot)
+        with gr.Column():
+            out = gr.Image(label="Reconstructed Reality (Visualized)")
+            stats = gr.Label(label="Stream Stats")
             
-        with gr.Tab("3. GPF Density"):
-            gr.Markdown("Counts of composites anchored by each Prime.")
-            gpf_len = gr.Slider(100, 10000, value=2500, label="Stream Depth")
-            gpf_plot = gr.Plot(label="GPF Distribution")
-            btn_gpf = gr.Button("Calculate Density")
-            btn_gpf.click(visualize_gpf_counts, inputs=[gpf_len], outputs=gpf_plot)
-
-        with gr.Tab("4. Live Stream Baker"):
-            gr.Markdown("Upload an image to test **Thermal-Aware Chunking**. Drag 'Heat Tolerance' to adjust compression.")
-            with gr.Row():
-                inp_img = gr.Image(label="Input Stream (Image)", type="numpy")
-                tol_slider = gr.Slider(0.01, 1.0, value=0.15, label="Heat Tolerance (Persistence)")
-            
-            chunk_plot = gr.Plot(label="Adaptive Decomposition")
-            btn_bake = gr.Button("Bake Stream")
-            btn_bake.click(process_uploaded_image, inputs=[inp_img, tol_slider], outputs=chunk_plot)
-
-    return demo
+    btn.click(run_logos_baker, inputs=[inp, tol], outputs=[out, stats])
 
 if __name__ == "__main__":
-    demo = build_demo()
     demo.launch(ssr_mode=False)