Update app.py

app.py

@@ -1,171 +1,146 @@
 import streamlit as st
 import pandas as pd
-import numpy as np
-import torch
-import torch.nn as nn
-import torch.nn.functional as F
-from torch.utils.data import DataLoader, TensorDataset
+import plotly.graph_objects as go
 
-from PIL import Image
-
-# =========================
-# STRUTTURE TARGET (compatibilità)
-# =========================
+# ========== STRUTTURE TARGET ==========
+# Ognuna ha soglie (volume, area, lunghezza) e dimensioni LxWxH per il bounding box dimostrativo
 strutture_target = {
-    "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},
+    "Dock-Rigenerato": {
+        "max_volume": 250,
+        "max_area": 60,
+        "max_lunghezza": 160,
+        "size": (200, 80, 60)  # dimensioni d'esempio (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)
+    },
 }
 
-def valuta_compatibilità(row, target):
+# ========== FUNZIONI COMPATIBILITÀ E BOUNDING BOX ==========
+
+def valuta_compatibilita(eol, target):
+    # eol = dizionario {volume, area, lunghezza} (float)
+    # target = dict con max_volume, max_area, max_lunghezza
     score = 0
-    if row[0] <= target["max_volume"]:     score += 1
-    if row[1] <= target["max_area"]:       score += 1
-    if row[2] <= target["max_lunghezza"]:  score += 1
+    if eol["volume"] <= target["max_volume"]:
+        score += 1
+    if eol["area"] <= target["max_area"]:
+        score += 1
+    if eol["lunghezza"] <= target["max_lunghezza"]:
+        score += 1
     return score
 
-def assegna_struttura(x):
-    # x = [volume, area, lunghezza, materiale, rigidita, usura]
-    punteggi = {k: valuta_compatibilità(x, v) for k,v in strutture_target.items()}
+def assegna_struttura(eol):
+    punteggi = {}
+    for nome, tdict in strutture_target.items():
+        punteggi[nome] = valuta_compatibilita(eol, tdict)
+    # Trova la struttura con punteggio più alto
     best = max(punteggi, key=punteggi.get)
     return best
 
-# =========================
-# 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")
+def parallelepipedo_vertices(dx, dy, dz, offset=(0,0,0)):
+    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),
+    ]
+
+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 add_box_to_figure(fig, verts, color="blue"):
+    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 Valutazione Al Contrario", layout="wide")
+st.title("🔧 Weeko EoL – Analisi dimensionale + bounding box 3D")
+
+st.write("Carica una **foto** del tuo componente EoL e inserisci manualmente le sue caratteristiche. \
+L'app troverà la struttura più compatibile e mostrerà un confronto 3D semplificato con bounding box.")
+
+# 1) Carico foto EoL (opzionale)
+foto = st.file_uploader("Carica una foto (opzionale)", type=["jpg","png"])
+if foto:
+    st.image(foto, caption="Foto EoL caricata", use_column_width=True)
+
+st.subheader("Inserisci dati EoL")
+volume = st.number_input("Volume (cm³)", 0.0, 1000.0, 120.0)
+area = st.number_input("Area (cm²)", 0.0, 300.0, 50.0)
+lunghezza = st.number_input("Lunghezza (mm)", 0.0, 500.0, 130.0)
+rigidita = st.slider("Rigidità (0=flessibile, 1=rigido)", 0.0, 1.0, 0.5)
+usura = st.slider("Usura (0=nuovo, 1=molto usurato)", 0.0, 1.0, 0.3)
+materiale_sc = st.selectbox("Materiale", ["Plastica","Metallo","PCB"])
+
+# Quando clicco "Valuta"
+if st.button("Valuta compatibilità e Visualizza 3D"):
+    eol_data = {
+        "volume": volume,
+        "area": area,
+        "lunghezza": lunghezza,
+        "materiale": {"Plastica":0,"Metallo":1,"PCB":2}[materiale_sc],
+        "rigidita": rigidita,
+        "usura": usura
+    }
+
+    best_struttura = assegna_struttura(eol_data)
+    st.success(f"La struttura più compatibile è: **{best_struttura}**")
+
+    # ---- Creiamo bounding box EoL in modo semplificato
+    #    area ~ L * W, volume ~ L * W * H
+    # Se area e lunghezza => W = area / lunghezza
+    # => H = volume / (L * W)
+    # NB: zero-check
+    eps = 1e-6
+    L_eol = max(lunghezza, eps)
+    W_eol = max(area / L_eol, eps)
+    H_eol = max(volume / (L_eol * W_eol), eps)
+
+    offset_eol = (0,0,0)
+    verts_eol = parallelepipedo_vertices(L_eol, W_eol, H_eol, offset_eol)
+
+    # ---- bounding box della struttura target
+    starget = strutture_target[best_struttura]["size"]  # (L, W, H)
+    # Mettiamo un offset di + (L_eol + 20) in X, per vederli affiancati
+    offset_tgt = (L_eol+20, 0, 0)
+    verts_tgt = parallelepipedo_vertices(starget[0], starget[1], starget[2], offset_tgt)
+
+    fig = go.Figure()
+    add_box_to_figure(fig, verts_eol, color="blue")   # EoL box
+    add_box_to_figure(fig, verts_tgt, color="red")    # Struttura box
+    fig.update_layout(
+        width=800, height=600,
+        title="Confronto 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)