Create app.py

app.py

@@ -0,0 +1,126 @@
+```python
+
+import torch
+import numpy as np
+from PIL import Image
+import gradio as gr
+import trimesh
+from gsplat import GaussianModel, render
+
+class Persistent3DCortex:
+    def __init__(self, grid_size=32):
+        self.grid_size = grid_size
+        self.n_voxels = grid_size ** 3
+        # For a fast demo, we'll skip the full GaussianModel init
+        # self.gaussian_model = GaussianModel(sh_degree=3)
+        
+        # Initialize with esolang density (Piet-inspired)
+        # This is our 3D grid of information
+        self.colors = torch.rand(self.n_voxels, 3)
+        self.positions = torch.rand(self.n_voxels, 3) * 2 - 1
+        self.scales = torch.ones(self.n_voxels, 3) * 0.05
+        self.opacities = torch.ones(self.n_voxels) * 0.5
+        
+        # Simple NCA update net (8k params)
+        self.nca_net = torch.nn.Sequential(
+            torch.nn.Linear(48, 128),
+            torch.nn.ReLU(),
+            torch.nn.Linear(128, 16)
+        )
+    
+    def evolve_with_nca(self, target_image, steps=100):
+        """Evolve grid using NCA rules to match the target image"""
+        for step in range(steps):
+            # Perception: Sobel gradients for neighborhood info
+            grad_x = self._sobel_gradient(axis=0)
+            grad_y = self._sobel_gradient(axis=1)
+            grad_z = self._sobel_gradient(axis=2)
+            
+            # ML update (simulates analog in-memory processing)
+            perception = torch.cat([
+                self.colors, grad_x, grad_y, grad_z
+            ], dim=1)
+            
+            delta = self.nca_net(perception)
+            self.colors = torch.clamp(self.colors + delta[:, :3], 0, 1)
+            
+            # Stochastic mask (a random 50% of voxels don't update)
+            mask = torch.rand(self.n_voxels) > 0.5
+            self.colors[mask] = self.colors[mask].detach()
+    
+    def _sobel_gradient(self, axis):
+        """Calculate spatial gradients (simulates neighborhood perception)"""
+        sobel_kernel = torch.tensor([[-1, 0, 1], [-2, 0, 2], [-1, 0, 1]])
+        # Reshape for 3D convolution
+        color_grid = self.colors.reshape(1, 1, self.grid_size, self.grid_size, self.grid_size)
+        kernel_grid = sobel_kernel.reshape(1, 1, 3, 3, 3)
+        # Apply convolution
+        return torch.conv3d(color_grid, kernel_grid, padding=1).flatten()
+    
+    def export_to_3d(self):
+        """Convert evolved grid to 3D mesh using a simple threshold method"""
+        threshold = 0.5
+        vertices, faces = [], []
+        
+        # A simple marching cubes approximation
+        for i in range(self.grid_size - 1):
+            for j in range(self.grid_size - 1):
+                for k in range(self.grid_size - 1):
+                    idx = i * self.grid_size**2 + j * self.grid_size + k
+                    if self.colors[idx].mean() > threshold:
+                        # Add a simple cube geometry for this voxel
+                        v_offset = len(vertices)
+                        vertices.extend([
+                            [i, j, k], [i+1, j, k], [i+1, j+1, k], [i, j+1, k],
+                            [i, j, k+1], [i+1, j, k+1], [i+1, j+1, k+1], [i, j+1, k+1]
+                        ])
+                        faces.extend([
+                            [v_offset, v_offset+1, v_offset+2], 
+                            [v_offset, v_offset+2, v_offset+3]
+                        ])
+        
+        mesh = trimesh.Trimesh(vertices=vertices, faces=faces)
+        return mesh.export('output.obj')
+
+# --- This is the Gradio Interface ---
+
+# Create one instance of our cortex
+cortex = Persistent3DCortex(grid_size=32)
+
+def process_input(image, prompt):
+    """The function that runs when the user clicks submit"""
+    print(f"User prompt: {prompt}") # Helpful for debugging
+    
+    # Adapt target based on prompt (simplified for demoe)
+    # Here, we could use an LLM or a text-image model to adjust the target image
+    
+    if "smooth" in prompt.lower():
+        step_count = 150
+    elif "blocky" in prompt.lower():
+        step_count = 50
+    else:
+        step_count = 100
+        
+    # Evolve with NCA
+    img_tensor = torch.tensor(np.array(image) / 255.0).float()
+    cortex.evolve_with_nca(img_tensor, steps=step_count)
+    
+    # Export result
+    obj_file = cortex.export_to_3d()
+    
+    # Return the file path to the user and a success message
+    return 'output.obj', f"Persistent 3D cortex generated in {step_count} steps based on your: '{prompt}'!"
+
+# Define the interface
+demo = gr.Interface(
+    fn=process_input,
+    inputs=[gr.Image(type="pil", label="Upload an Image"), gr.Textbox(lines=1, label="Prompt")],
+    outputs=[gr.File(label="Download your 3D Model (.obj)"), gr.Text(label="Status")],
+    title="Persistent 3D Cortex Demo",
+    description="Upload an image and describe what you want. Watch a persistent, evolving 3D 'brain' generate a 3D model from your input!"
+)
+
+# This is the only line needed to run the app on Hugging Face
+demo.launch()
+
+```python