Download app.py from sd4m/Nsav2: direct link, hf CLI and curl.
- Browser
- Download file 17.1 kB
-
https://huggingface.co/spaces/sd4m/Nsav2/resolve/main/app.py
- Command line
-
hf download hf://spaces/sd4m/Nsav2/app.py
-
curl -L -o app.py https://huggingface.co/spaces/sd4m/Nsav2/resolve/main/app.py
17.1 kB
| # MARS-LOOP Interactive Demo (Gradio + Plotly) | |
| # -------------------------------------------------- | |
| # Features: | |
| # - Hero section with big rotating Mars + "Iniciemos simulación" button | |
| # - Slide 1: Jezero-like crater with blue trash points and an orange bot | |
| # The bot collects points following an AI-optimized route (k-means sorting + 2-opt path) | |
| # - Slide 2: "Inside the robot" process animation (Sort -> Shred+Wash -> Pelletize -> Mix -> Form/Print) | |
| # with live KPIs (mass recovery, water recovery, crew time) | |
| # - Slide 3: Clean crater "after" view | |
| # | |
| # Dependencies: gradio, plotly, numpy, pandas | |
| # Run: pip install gradio plotly numpy pandas | |
| # python app.py | |
| # | |
| # This file is self-contained (no external images needed). | |
| import math | |
| import numpy as np | |
| import pandas as pd | |
| import plotly.graph_objects as go | |
| import gradio as gr | |
| from dataclasses import dataclass | |
| # -------------------------- | |
| # Helpers: simple k-means | |
| # -------------------------- | |
| def kmeans(X, k=3, iters=15, seed=42): | |
| rng = np.random.RandomState(seed) | |
| # choose random points as initial centroids | |
| idx = rng.choice(len(X), size=k, replace=False) | |
| C = X[idx].copy() | |
| for _ in range(iters): | |
| # assign | |
| d = ((X[:, None, :] - C[None, :, :]) ** 2).sum(axis=2) # (n,k) | |
| labels = d.argmin(axis=1) | |
| # update | |
| for j in range(k): | |
| pts = X[labels == j] | |
| if len(pts) > 0: | |
| C[j] = pts.mean(axis=0) | |
| return labels, C | |
| # -------------------------- | |
| # Helpers: route optimization | |
| # -------------------------- | |
| def nn_route(points): | |
| """Nearest-neighbor heuristic route through all points (returns indices order).""" | |
| n = len(points) | |
| if n == 0: | |
| return [] | |
| remaining = set(range(n)) | |
| order = [0] | |
| remaining.remove(0) | |
| while remaining: | |
| last = order[-1] | |
| # choose nearest | |
| best = min(remaining, key=lambda j: np.linalg.norm(points[j] - points[last])) | |
| order.append(best) | |
| remaining.remove(best) | |
| return order | |
| def two_opt(points, order, iters=100): | |
| """2-opt improvement on an existing route order.""" | |
| n = len(order) | |
| if n < 4: | |
| return order | |
| def route_len(ordr): | |
| return sum(np.linalg.norm(points[ordr[i]] - points[ordr[(i+1) % n]]) for i in range(n-1)) | |
| best = order[:] | |
| best_len = route_len(best) | |
| improved = True | |
| loops = 0 | |
| while improved and loops < iters: | |
| improved = False | |
| loops += 1 | |
| for i in range(1, n-2): | |
| for k in range(i+1, n-1): | |
| new_order = best[:i] + best[i:k+1][::-1] + best[k+1:] | |
| new_len = route_len(new_order) | |
| if new_len < best_len: | |
| best, best_len = new_order, new_len | |
| improved = True | |
| if not improved: | |
| break | |
| return best | |
| # -------------------------- | |
| # Data classes | |
| # -------------------------- | |
| class Scenario: | |
| seed: int | |
| points: np.ndarray # (n,2) trash points | |
| labels: np.ndarray # material classes per point | |
| order: list # route visiting order | |
| unit_mass: float # kg per trash item | |
| # KPIs | |
| batch_mass: float | |
| water_used: float | |
| water_recov: float | |
| water_loss: float | |
| useful_mass: float | |
| metals_reuse: float | |
| mass_recovery_pct: float | |
| crew_time_min: float | |
| # -------------------------- | |
| # Scenario generation | |
| # -------------------------- | |
| def generate_scenario(n_points=60, seed=42, crater_radius=20.0): | |
| rng = np.random.RandomState(seed) | |
| # Sample points in an ellipse/valley to evoke crater | |
| theta = rng.uniform(0, 2*np.pi, size=n_points) | |
| r = crater_radius * np.sqrt(rng.uniform(0, 1, size=n_points)) # denser center | |
| # elliptical distortion | |
| a, b = 1.0, 0.65 | |
| x = a * r * np.cos(theta) | |
| y = b * r * np.sin(theta) - 2.5 # slight offset | |
| P = np.stack([x, y], axis=1) | |
| # Fake spectral features by mixing position + random | |
| f1 = (x - x.min()) / (x.max() - x.min() + 1e-6) | |
| f2 = (y - y.min()) / (y.max() - y.min() + 1e-6) | |
| f3 = rng.beta(2, 5, size=n_points) # polymer-likeness | |
| X = np.stack([f1, f2, f3], axis=1) | |
| labels, _ = kmeans(X, k=3, iters=20, seed=seed) | |
| # Route planning on points (AI optimizer) | |
| order = two_opt(P, nn_route(P)) | |
| # KPI model (toy but consistent) | |
| unit_mass = 1.8 # kg per trash item (avg packaging/textile piece) | |
| batch_mass = n_points * unit_mass | |
| # water use per kg + recovery | |
| water_perkg = 0.7 | |
| water_used = water_perkg * batch_mass | |
| water_recovery = 0.93 | |
| water_recov = water_used * water_recovery | |
| water_loss = water_used - water_recov | |
| # mass conversion to useful composite including regolith (r=0.3), efficiencies product | |
| eff = 0.95 * 0.97 * 0.96 * 0.95 * 0.95 | |
| polymer_mass_after = batch_mass * eff | |
| # regolith fraction in final (r) | |
| rfrac = 0.30 | |
| final_mass = polymer_mass_after / (1 - rfrac) * 0.98 # 2% trim loss fudge | |
| metals_reuse = 12.0 # kg available as frames reuse, constant per batch | |
| useful_mass = final_mass | |
| mass_recovery_pct = (useful_mass + metals_reuse) / batch_mass * 100.0 | |
| # crew time estimation | |
| crew_time = max(6.0, 8.0 + 0.04 * batch_mass) | |
| return Scenario( | |
| seed=seed, points=P, labels=labels, order=order, unit_mass=unit_mass, | |
| batch_mass=batch_mass, water_used=water_used, water_recov=water_recov, water_loss=water_loss, | |
| useful_mass=useful_mass, metals_reuse=metals_reuse, mass_recovery_pct=mass_recovery_pct, | |
| crew_time_min=crew_time | |
| ) | |
| # -------------------------- | |
| # Figures | |
| # -------------------------- | |
| def hero_html(): | |
| # Rotating planet built with pure CSS (no external image) | |
| # Large, soft gradients evoke the Red Planet. | |
| return gr.HTML( | |
| ''' | |
| <style> | |
| .hero-wrap{height:78vh;display:flex;flex-direction:column;align-items:center;justify-content:center;background:#12090a;} | |
| .mars{ | |
| width: 420px; height: 420px; border-radius:50%; | |
| background: radial-gradient( circle at 35% 30%, | |
| #ffb199 0%, #e06045 35%, #b63a27 55%, #5a1e16 75%, #2a1010 100% ); | |
| box-shadow: 0 0 80px rgba(255,90,50,0.35), inset -30px -40px 80px rgba(0,0,0,0.6); | |
| position: relative; animation: spin 18s linear infinite; | |
| } | |
| .mars:before{ | |
| content:""; position:absolute; inset:0; border-radius:50%; | |
| background: radial-gradient(circle at 70% 65%, rgba(255,255,255,0.12), rgba(0,0,0,0) 40%); | |
| filter: blur(1px); | |
| } | |
| @keyframes spin{ from{transform: rotate(0deg)} to{transform: rotate(360deg)} } | |
| h1{font-size:48px; letter-spacing:10px; color:#ffe6df; margin:28px 0 6px; font-weight:300;} | |
| .sub{color:#ffb8a9; letter-spacing:4px; margin-bottom:22px;} | |
| .btn-start{ | |
| background:#e06045; color:#170d0d; border:none; padding:14px 26px; border-radius:999px; | |
| font-weight:700; letter-spacing:1px; cursor:pointer; transition: all .2s ease; | |
| } | |
| .btn-start:hover{ transform: translateY(-1px); filter: brightness(1.05); } | |
| </style> | |
| <div class="hero-wrap"> | |
| <div class="mars"></div> | |
| <h1>MARTE</h1> | |
| <div class="sub">PLANETA ROJO</div> | |
| <button id="start-sim" class="btn-start">Iniciemos simulación</button> | |
| <script> | |
| // Bridge click to Gradio event by triggering a hidden button if exists | |
| setTimeout(()=>{ | |
| const btn = document.querySelector('button.sr-only-start'); | |
| const real = document.getElementById('start-sim'); | |
| if(btn && real){ real.onclick = ()=> btn.click(); } | |
| }, 500); | |
| </script> | |
| </div> | |
| ''' | |
| ) | |
| def crater_animation(scn: Scenario, show_classes=True): | |
| P = scn.points | |
| labels = scn.labels | |
| order = scn.order | |
| # Colors by class | |
| palette = np.array(["deepskyblue", "dodgerblue", "lightskyblue"]) if show_classes else np.array(["deepskyblue"]*3) | |
| colors = palette[labels] | |
| # Robot initial pos at first point | |
| fig = go.Figure() | |
| # crater / landscape (stylized) | |
| t = np.linspace(0, 2*np.pi, 200) | |
| a, b = 22, 14 | |
| fig.add_trace(go.Scatter(x=a*np.cos(t), y=b*np.sin(t)-2.5, mode="lines", line=dict(width=2), name="Crater Edge", opacity=0.25)) | |
| # trash points initial | |
| fig.add_trace(go.Scatter(x=P[:,0], y=P[:,1], mode="markers", | |
| marker=dict(size=9, color=colors, opacity=0.95, line=dict(width=0)), | |
| name="Trash")) | |
| # robot | |
| start = P[order[0]] | |
| fig.add_trace(go.Scatter(x=[start[0]], y=[start[1]], mode="markers", | |
| marker=dict(size=18, color="orange", symbol="triangle-up"), name="Bot")) | |
| frames = [] | |
| # Animate visiting each point (3 substeps per edge) | |
| sub = 3 | |
| trash_opacity = np.ones(len(P)) * 0.95 | |
| bx, by = start[0], start[1] | |
| for idx in range(1, len(order)): | |
| p0 = P[order[idx-1]] | |
| p1 = P[order[idx]] | |
| for s in range(sub): | |
| tfrac = (s+1)/sub | |
| x = p0[0]*(1-tfrac) + p1[0]*tfrac | |
| y = p0[1]*(1-tfrac) + p1[1]*tfrac | |
| frames.append(go.Frame(data=[ | |
| # crater edge again | |
| go.Scatter(x=a*np.cos(t), y=b*np.sin(t)-2.5, mode="lines", line=dict(width=2), opacity=0.25, showlegend=False), | |
| # trash with current opacity | |
| go.Scatter(x=P[:,0], y=P[:,1], mode="markers", | |
| marker=dict(size=9, color=colors, opacity=trash_opacity, line=dict(width=0)), showlegend=False), | |
| # bot position | |
| go.Scatter(x=[x], y=[y], mode="markers", marker=dict(size=18, color="orange", symbol="triangle-up"), showlegend=False) | |
| ])) | |
| # when arriving, mark this point as collected (fade it) | |
| trash_opacity[order[idx]] = 0.1 | |
| fig.update(frames=frames) | |
| fig.update_layout( | |
| title="Jezero Crater • Trash Collection", | |
| xaxis=dict(visible=False), yaxis=dict(visible=False, scaleanchor="x", scaleratio=1), | |
| height=520, plot_bgcolor="rgba(18,9,10,1)", paper_bgcolor="rgba(18,9,10,1)", | |
| font=dict(color="#ffe6df"), | |
| updatemenus=[dict(type="buttons", x=0.02, y=0.96, buttons=[ | |
| dict(label="Play", method="animate", args=[None]), | |
| dict(label="Pause", method="animate", | |
| args=[[None], {"mode":"immediate","frame":{"duration":0,"redraw":False}, | |
| "transition":{"duration":0}}]) | |
| ])], | |
| showlegend=False | |
| ) | |
| return fig | |
| def process_animation(scn: Scenario): | |
| stages = ["SORT", "SHRED+WASH", "PELLETIZE", "MIX (REGOLITH)", "FORM/PRINT"] | |
| x = [0, 1, 2, 3, 4] | |
| y = [0]*5 | |
| # Base layout | |
| fig = go.Figure() | |
| # boxes | |
| for i, s in enumerate(stages): | |
| fig.add_trace(go.Scatter( | |
| x=[i], y=[0], mode="markers+text", | |
| marker=dict(size=140, symbol="square", color="#2b1a1a", line=dict(color="#623a35", width=2)), | |
| text=[s], textfont=dict(color="#ffb8a9"), textposition="middle center", showlegend=False | |
| )) | |
| # progress dot (animated) | |
| frames = [] | |
| nframes = 60 | |
| for f in range(nframes): | |
| idx = int((f / nframes) * len(stages)) | |
| idx = min(idx, len(stages)-1) | |
| frames.append(go.Frame(data=[ | |
| go.Scatter(x=[i for i in x], y=[0]*5, mode="markers+text", | |
| marker=dict(size=140, symbol="square", color=["#3e2321" if j<=idx else "#2b1a1a" for j in range(5)], | |
| line=dict(color="#623a35", width=2)), | |
| text=stages, textfont=dict(color="#ffb8a9"), textposition="middle center", showlegend=False), | |
| go.Scatter(x=[idx], y=[0.55], mode="markers", marker=dict(size=18, color="orange", symbol="triangle-up"), showlegend=False) | |
| ])) | |
| # KPIs as annotations | |
| kp = scn | |
| ann = [ | |
| dict(x=0, y=-0.9, text=f"Batch waste: {kp.batch_mass:.1f} kg", showarrow=False, font=dict(color="#ffe6df")), | |
| dict(x=1, y=-0.9, text=f"Water used: {kp.water_used:.1f} L • Recovered: {kp.water_recov:.1f} L", showarrow=False, font=dict(color="#ffe6df")), | |
| dict(x=2, y=-0.9, text=f"Useful composite: {kp.useful_mass:.1f} kg", showarrow=False, font=dict(color="#ffe6df")), | |
| dict(x=3, y=-0.9, text=f"Metals → reuse: {kp.metals_reuse:.1f} kg", showarrow=False, font=dict(color="#ffe6df")), | |
| dict(x=4, y=-0.9, text=f"Mass recovery: {kp.mass_recovery_pct:.1f}% • Crew time ≤ {kp.crew_time_min:.0f} min", showarrow=False, font=dict(color="#ffe6df")), | |
| ] | |
| fig.update(frames=frames) | |
| fig.update_layout( | |
| title="Inside the Bot • MARS-LOOP Process", | |
| xaxis=dict(visible=False, range=[-0.5, 4.5]), | |
| yaxis=dict(visible=False, range=[-1.2, 1.2]), | |
| height=420, plot_bgcolor="rgba(18,9,10,1)", paper_bgcolor="rgba(18,9,10,1)", | |
| font=dict(color="#ffe6df"), | |
| updatemenus=[dict(type="buttons", x=0.02, y=0.96, buttons=[ | |
| dict(label="Play", method="animate", args=[None]), | |
| dict(label="Pause", method="animate", | |
| args=[[None], {"mode":"immediate","frame":{"duration":0,"redraw":False}, | |
| "transition":{"duration":0}}]) | |
| ])], | |
| annotations=ann | |
| ) | |
| return fig | |
| def clean_crater(P): | |
| # stylized empty crater | |
| fig = go.Figure() | |
| t = np.linspace(0, 2*np.pi, 200) | |
| a, b = 22, 14 | |
| fig.add_trace(go.Scatter(x=a*np.cos(t), y=b*np.sin(t)-2.5, mode="lines", | |
| line=dict(width=2), opacity=0.28, name="Crater")) | |
| fig.add_annotation(x=0, y=0, text="Área limpia ✅", showarrow=False, font=dict(size=28, color="#b4ffb4")) | |
| fig.update_layout( | |
| title="Jezero Crater • After Cleaning", | |
| xaxis=dict(visible=False), yaxis=dict(visible=False, scaleanchor="x", scaleratio=1), | |
| height=520, plot_bgcolor="rgba(18,9,10,1)", paper_bgcolor="rgba(18,9,10,1)", | |
| font=dict(color="#ffe6df"), showlegend=False | |
| ) | |
| return fig | |
| # -------------------------- | |
| # Gradio App | |
| # -------------------------- | |
| with gr.Blocks(title="MARS-LOOP Interactive", theme=gr.themes.Soft(primary_hue="red")) as demo: | |
| gr.HTML("<style> .gradio-container {max-width: 980px !important;} </style>") | |
| state_scn = gr.State() # Scenario object | |
| state_slide = gr.State(0) | |
| # HERO | |
| hero = hero_html() | |
| hidden_start_bridge = gr.Button("Iniciar", visible=False, elem_classes=["sr-only-start"]) | |
| # SLIDE 1 | |
| with gr.Group(visible=False) as slide1: | |
| gr.Markdown("### 🏜️ Simulación: Jezero Crater (detección y recolección de desechos)") | |
| with gr.Row(): | |
| show_classes = gr.Checkbox(value=True, label="Mostrar clasificación automática de materiales (IA)") | |
| seed_in = gr.Slider(1, 9999, value=42, step=1, label="Semilla") | |
| regen = gr.Button("🔄 Regenerar escenario") | |
| crater_plot = gr.Plot() | |
| next1 = gr.Button("Siguiente ➜ Proceso interno") | |
| # SLIDE 2 | |
| with gr.Group(visible=False) as slide2: | |
| gr.Markdown("### ⚙️ Proceso dentro del robot (MARS-LOOP)") | |
| process_plot = gr.Plot() | |
| next2 = gr.Button("Siguiente ➜ Cráter limpio") | |
| # SLIDE 3 | |
| with gr.Group(visible=False) as slide3: | |
| gr.Markdown("### ✅ Resultado: Cráter limpio") | |
| clean_plot = gr.Plot() | |
| reset = gr.Button("Reiniciar") | |
| # ------------------ | |
| # Callbacks | |
| # ------------------ | |
| def on_start(): | |
| scn = generate_scenario(seed=42) | |
| fig = crater_animation(scn, show_classes=True) | |
| return ( | |
| gr.update(visible=False), # hide hero | |
| gr.update(visible=True), # show slide1 | |
| scn, 1, # state scenario + slide | |
| gr.update(value=fig) # crater plot | |
| ) | |
| def on_regen(seed, show): | |
| scn = generate_scenario(seed=int(seed)) | |
| fig = crater_animation(scn, show_classes=bool(show)) | |
| return scn, gr.update(value=fig) | |
| def go_next1(scn: Scenario): | |
| fig = process_animation(scn) | |
| return gr.update(visible=False), gr.update(visible=True), gr.update(value=fig), 2 | |
| def go_next2(scn: Scenario): | |
| fig = clean_crater(scn.points) | |
| return gr.update(visible=False), gr.update(visible=True), gr.update(value=fig), 3 | |
| def on_reset(): | |
| return gr.update(visible=False), gr.update(visible=False), gr.update(visible=True), 0 | |
| # wire | |
| hidden_start_bridge.click(on_start, outputs=[hero, slide1, state_scn, state_slide, crater_plot]) | |
| regen.click(on_regen, inputs=[seed_in, show_classes], outputs=[state_scn, crater_plot]) | |
| next1.click(go_next1, inputs=[state_scn], outputs=[slide1, slide2, process_plot, state_slide]) | |
| next2.click(go_next2, inputs=[state_scn], outputs=[slide2, slide3, clean_plot, state_slide]) | |
| reset.click(on_reset, outputs=[slide3, slide2, hero, state_slide]) | |
| if __name__ == "__main__": | |
| demo.launch() | |