Update app.py

app.py

@@ -1,152 +1,171 @@
 import streamlit as st
 import pandas as pd
 import numpy as np
-import plotly.graph_objects as go
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+from torch.utils.data import DataLoader, TensorDataset
 
-# ========== STRUTTURE TARGET =============
-# A scopo illustrativo: dimensioni fisse x,y,z (mm)
+from PIL import Image
+
+# =========================
+# STRUTTURE TARGET (compatibilità)
+# =========================
 strutture_target = {
-    "Dock-Rigenerato": {
-        "max_volume": 250,
-        "max_area": 60,
-        "max_lunghezza": 160,
-        "size": (200,80,60)  # L x W x H in mm
-    },
-    "Oggetto-Vetrina": {
-        "max_volume": 200,
-        "max_area": 80,
-        "max_lunghezza": 130,
-        "size": (150,100,80)
-    },
-    "Tool educativo": {
-        "max_volume": 300,
-        "max_area": 100,
-        "max_lunghezza": 200,
-        "size": (250,120,100)
-    },
+    "Dock-Rigenerato": {"max_volume": 250, "max_area": 60,  "max_lunghezza": 160},
+    "Oggetto-Vetrina": {"max_volume": 200, "max_area": 80,  "max_lunghezza": 130},
+    "Tool educativo":  {"max_volume": 300, "max_area": 100, "max_lunghezza": 200},
 }
 
-def valuta_compat(row, target):
+def valuta_compatibilità(row, target):
     score = 0
-    if row["volume"] <= target["max_volume"]: score += 1
-    if row["area"] <= target["max_area"]: score += 1
-    if row["lunghezza"] <= target["max_lunghezza"]: score += 1
+    if row[0] <= target["max_volume"]:     score += 1
+    if row[1] <= target["max_area"]:       score += 1
+    if row[2] <= target["max_lunghezza"]:  score += 1
     return score
 
-def assegna_struttura(row):
-    punteggi = {k: valuta_compat(row, v) for k, v in strutture_target.items()}
+def assegna_struttura(x):
+    # x = [volume, area, lunghezza, materiale, rigidita, usura]
+    punteggi = {k: valuta_compatibilità(x, v) for k,v in strutture_target.items()}
     best = max(punteggi, key=punteggi.get)
     return best
 
-# ---- FUNZIONE HELPER PER COSTRUIRE I 8 VERTICI DI UN PARALLELEPIPEDO
-def parallelepipedo_vertices(dx, dy, dz, offset=(0,0,0)):
-    """
-    Ritorna la lista di (x,y,z) dei vertici di un parallelepipedo
-    con dimensioni dx, dy, dz e offset.
-    """
-    ox, oy, oz = offset
-    return [
-        (ox,      oy,      oz),
-        (ox+dx,   oy,      oz),
-        (ox+dx,   oy+dy,   oz),
-        (ox,      oy+dy,   oz),
-        (ox,      oy,      oz+dz),
-        (ox+dx,   oy,      oz+dz),
-        (ox+dx,   oy+dy,   oz+dz),
-        (ox,      oy+dy,   oz+dz),
-    ]
-
-# Per disegnare le linee degli spigoli:
-edges = [
-    (0,1),(1,2),(2,3),(3,0),
-    (4,5),(5,6),(6,7),(7,4),
-    (0,4),(1,5),(2,6),(3,7)
-]
-
-def traccia_box(fig, verts, color="blue"):
-    # aggiunge le linee degli edges
-    for (i,j) in edges:
-        x_c = [verts[i][0], verts[j][0]]
-        y_c = [verts[i][1], verts[j][1]]
-        z_c = [verts[i][2], verts[j][2]]
-        fig.add_trace(go.Scatter3d(
-            x=x_c, y=y_c, z=z_c,
-            mode='lines',
-            line=dict(color=color, width=5),
-            showlegend=False
-        ))
-
-# ========== STREAMLIT APP =============
-st.set_page_config(page_title="Weeko EoL - bounding box", layout="wide")
-st.title("✨ WEEKO – OR6.2 Demo: Riutilizzo estetico e bounding box 3D")
-
-st.markdown("**Obiettivo**: dare funzionalità estetica a un oggetto EoL, valutando compatibilità geometrica, e visualizzare box 3D dell'oggetto e della struttura target.")
-
-# 1) Carico foto EoL (opzionale)
-st.subheader("1) Carica una foto del componente EoL")
-foto_file = st.file_uploader("Foto (jpg/png)", type=["jpg","png"])
-if foto_file:
-    st.image(foto_file, caption="Foto componente EoL", use_column_width=True)
-
-# 2) Inserimento dati
-st.subheader("2) Inserisci i dati caratteristici (volume cm³, area cm², lunghezza mm...)")
-volume = st.number_input("Volume (cm³)", 0.0, 500.0, 100.0)
-area = st.number_input("Area (cm²)", 0.0, 300.0, 50.0)
-lung = st.number_input("Lunghezza (mm)", 0.0, 500.0, 120.0)
-mat = st.selectbox("Materiale", ["Plastica", "Metallo", "PCB"])
-rig = st.slider("Rigidità (0=flessibile, 1=rigido)", 0.0, 1.0, 0.5)
-usu = st.slider("Usura (0=nuovo, 1=molto usurato)", 0.0, 1.0, 0.3)
-
-df_eol = pd.DataFrame([{
-    "volume": volume,
-    "area": area,
-    "lunghezza": lung,
-    "materiale": {"Plastica":0,"Metallo":1,"PCB":2}[mat],
-    "rigidita": rig,
-    "usura": usu
-}])
-
-# 3) Calcolo compatibilità e visualizzazione box 3D
-if st.button("Valuta e Visualizza"):
-    best_struttura = assegna_struttura(df_eol.loc[0])
-    st.success(f"Struttura più compatibile: **{best_struttura}**")
-
-    # Logica bounding box per EoL
-    # => semplificazione: supponiamo un parallelepipedo. 
-    # area ~ L * W, volume ~ L * W * H
-    # Se ho lunghezza e area, stimo W = area / lunghezza
-    # e H = volume / (L * W)
-
-    # Attento a zero division:
-    epsilon = 1e-3
-    L_eol = max(lung, epsilon)
-    W_eol = max(area / L_eol, epsilon)
-    H_eol = max(volume / (L_eol * W_eol), epsilon)
-
-    # bounding box EoL
-    offset_eol = (0,0,0)
-    verts_eol = parallelepipedo_vertices(L_eol, W_eol, H_eol, offset_eol)
-
-    # bounding box Struttura
-    box_target = strutture_target[best_struttura]["size"]  # (L, W, H)
-    # Mettiamola a fianco spostando offset di +L_eol + 20
-    offset_tgt = (L_eol + 20, 0, 0)  
-    verts_target = parallelepipedo_vertices(box_target[0], box_target[1], box_target[2], offset_tgt)
-
-    fig = go.Figure()
-    # Aggiunge box EoL in blu
-    traccia_box(fig, verts_eol, color="blue")
-    # Aggiunge box struttura in rosso
-    traccia_box(fig, verts_target, color="red")
-
-    fig.update_layout(
-        width=800, height=600,
-        title="Confronto bounding box: EoL (blu) vs Struttura (rossa)",
-        scene=dict(
-            xaxis_title="X (mm)",
-            yaxis_title="Y (mm)",
-            zaxis_title="Z (mm)",
-        )
-    )
-
-    st.plotly_chart(fig, use_container_width=True)
+# =========================
+# VAE DEFINIZIONE
+# =========================
+class VAE(nn.Module):
+    def __init__(self, input_dim=6, latent_dim=2):
+        super(VAE, self).__init__()
+        self.fc1 = nn.Linear(input_dim, 12)
+        self.fc21 = nn.Linear(12, latent_dim)
+        self.fc22 = nn.Linear(12, latent_dim)
+        self.fc3 = nn.Linear(latent_dim, 12)
+        self.fc4 = nn.Linear(12, input_dim)
+
+    def encode(self, x):
+        h1 = F.relu(self.fc1(x))
+        return self.fc21(h1), self.fc22(h1)
+
+    def reparameterize(self, mu, logvar):
+        std = torch.exp(0.5 * logvar)
+        eps = torch.randn_like(std)
+        return mu + eps * std
+
+    def decode(self, z):
+        h3 = F.relu(self.fc3(z))
+        return self.fc4(h3)
+
+    def forward(self, x):
+        mu, logvar = self.encode(x)
+        z = self.reparameterize(mu, logvar)
+        return self.decode(z), mu, logvar
+
+def vae_loss(recon_x, x, mu, logvar):
+    mse = F.mse_loss(recon_x, x, reduction='sum')
+    kld = -0.5 * torch.sum(1 + logvar - mu.pow(2) - logvar.exp())
+    return mse + kld
+
+# ============== STREAMLIT SETUP ==============
+st.set_page_config(page_title="Weeko AI + Overlay", layout="wide")
+st.title("✨ WEEKO – OR6.3 Demo: AI dimensionale + Overlay Estetico")
+
+tabs = st.tabs(["🧠 AI Dimensionale", "🎨 Overlay Estetico"])
+
+# --------------------------------------------
+# TAB 1: AI Dimensionale (VAE)
+# --------------------------------------------
+with tabs[0]:
+    st.subheader("AI Dimensionale con VAE (6 feature)")
+
+    st.markdown("""
+    **Scenario**: Abbiamo 6 feature: [volume, area, lunghezza, materiale, rigidità, usura].  
+    - Addestriamo al volo un piccolo VAE su dati simulati  
+    - Visualizziamo la ricostruzione e assegniamo a ciascun sample la struttura più compatibile  
+    """)
+
+    if st.button("🏋️ Train VAE su dati dummy"):
+        # 1) Creiamo dataset fittizio
+        torch.manual_seed(42)
+        n = 200
+        volume = torch.randn(n,1)*10 + 50
+        area = torch.randn(n,1)*5 + 20
+        lung = torch.randn(n,1)*30 + 100
+        materiale = torch.randint(0,3,(n,1)).float()
+        rigidita = torch.rand(n,1)
+        usura = torch.rand(n,1)
+        data = torch.cat([volume, area, lung, materiale, rigidita, usura], dim=1)
+
+        dataset = TensorDataset(data)
+        loader = DataLoader(dataset, batch_size=32, shuffle=True)
+
+        # 2) Inizializziamo e train
+        vae = VAE()
+        optimizer = torch.optim.Adam(vae.parameters(), lr=1e-3)
+        n_epochs = 30
+        losses = []
+        for epoch in range(n_epochs):
+            total_loss = 0
+            for (batch,) in loader:
+                optimizer.zero_grad()
+                recon, mu, logvar = vae(batch)
+                loss = vae_loss(recon, batch, mu, logvar)
+                loss.backward()
+                optimizer.step()
+                total_loss += loss.item()
+            losses.append(total_loss)
+
+        st.success("Addestramento completato. Ultimo epoch loss: {:.2f}".format(losses[-1]))
+
+        # 3) Generiamo riconstruction
+        data_np = data.numpy()
+        with torch.no_grad():
+            recon, _, _ = vae(data)
+        recon_np = recon.numpy()
+
+        # 4) Assegniamo struttura a original e ricostruito
+        df = pd.DataFrame(data_np, columns=["volume","area","lunghezza","materiale","rigidita","usura"])
+        df["struttura_compat"] = df.apply(lambda row: assegna_struttura(row.values), axis=1)
+
+        df_rec = pd.DataFrame(recon_np, columns=["volume","area","lunghezza","materiale","rigidita","usura"])
+        df_rec["struttura_compat"] = df_rec.apply(lambda row: assegna_struttura(row.values), axis=1)
+
+        st.write("### Esempio di 10 sample originali (Sx) e ricostruiti (Dx)")
+        joined = pd.concat([
+            df.head(10).round(2),
+            df_rec.head(10).round(2)
+        ], axis=1, keys=["Original","Ricostruito"])
+        st.dataframe(joined)
+
+        st.write("Struttura compatibile (originale) vs (ricostruito):")
+        st.dataframe(pd.DataFrame({
+            "Original": df["struttura_compat"].head(10).values,
+            "Ricostruito": df_rec["struttura_compat"].head(10).values
+        }))
+
+# --------------------------------------------
+# TAB 2: Overlay Estetico
+# --------------------------------------------
+with tabs[1]:
+    st.subheader("Overlay Estetico: Componente EoL su Oggetto Finale")
+
+    st.write("Carica due foto: (1) EoL (es. lamiera), (2) oggetto finale. Regola la trasparenza per un 'effetto wow'.")
+
+    col1, col2 = st.columns(2)
+    with col1:
+        eol_file = st.file_uploader("Foto EoL (jpg/png)", type=["jpg","png"], key="eol_upload")
+    with col2:
+        final_file = st.file_uploader("Oggetto finale (jpg/png)", type=["jpg","png"], key="final_upload")
+
+    if eol_file and final_file:
+        from PIL import Image
+        lamiera_img = Image.open(eol_file).convert("RGBA")
+        oggetto_img = Image.open(final_file).convert("RGBA")
+
+        # ridimensiona la lamiera alle dimensioni dell'oggetto
+        lamiera_img = lamiera_img.resize(oggetto_img.size)
+
+        alpha = st.slider("Trasparenza componente EoL", 0.0, 1.0, 0.5)
+        blended = Image.blend(oggetto_img, lamiera_img, alpha)
+        st.image(blended, caption="Overlay lamiera + oggetto finale", use_column_width=True)
+    else:
+        st.info("Attendi di caricare entrambe le immagini")