Upload 7 files

README.md

@@ -1,19 +1,76 @@
----
-title: DesignIA
-emoji: 🚀
-colorFrom: red
-colorTo: red
-sdk: docker
-app_port: 8501
-tags:
-- streamlit
-pinned: false
-short_description: Streamlit template space
----
-
-# Welcome to Streamlit!
-
-Edit `/src/streamlit_app.py` to customize this app to your heart's desire. :heart:
-
-If you have any questions, checkout our [documentation](https://docs.streamlit.io) and [community
-forums](https://discuss.streamlit.io).
+# DesignIA - Recomendador de Muebles Inteligente
+
+DesignIA es una aplicación inteligente que te ayuda a diseñar tu salón ideal. A partir de una imagen panorámica (360°) de tu habitación vacía, la aplicación detecta automáticamente la geometría del espacio (paredes, puertas, ventanas) y te sugiere una distribución óptima de muebles, recomendándote productos reales de IKEA que se ajustan a tu estilo y presupuesto.
+
+## Características
+
+*   **Escaneo de Habitación 3D**: Utiliza **HorizonNet** para detectar la estructura de la habitación a partir de una sola imagen panorámica.
+*   **Diseño Automático**: Algoritmos de optimización espacial para colocar muebles respetando zonas de paso y distancias de visualización (TV-Sofá).
+*   **Recomendación Estilística**: Un modelo basado en **BERT** analiza el estilo de los muebles para sugerir combinaciones coherentes.
+*   **Visualización Interactiva**: Visualiza tu futuro salón en 3D directamente en el navegador.
+*   **Presupuesto Ajustable**: Define cuánto quieres gastar y la IA buscará la mejor combinación calidad/precio.
+
+## Requisitos Previos
+
+Debido al uso de modelos de Inteligencia Artificial avanzados, este proyecto requiere descargar archivos de gran tamaño.
+
+1.  **Python 3.8+**
+2.  **Git LFS (Large File Storage)**: Imprescindible para descargar los modelos de IA.
+    *   Instalación: [https://git-lfs.com/](https://git-lfs.com/)
+    *   O ejecuta: `git lfs install`
+
+## Instalación
+
+1.  **Clonar el repositorio**
+    Asegúrate de tener Git LFS instalado antes de clonar.
+    ```bash
+    git lfs install
+    git clone https://github.com/agerhund/DesignIA.git
+    cd DesignIA
+    ```
+    *Nota: La descarga puede tardar unos minutos debido a los modelos (~1.7 GB).*
+
+2.  **Crear un entorno virtual (Recomendado)**
+    ```bash
+    python -m venv venv
+    # En Windows:
+    venv\Scripts\activate
+    # En Mac/Linux:
+    source venv/bin/activate
+    ```
+
+3.  **Instalar dependencias**
+    ```bash
+    pip install -r requirements.txt
+    ```
+
+## Ejecución
+
+Para iniciar la aplicación web localmente:
+
+```bash
+streamlit run app.py
+```
+
+La aplicación se abrirá automáticamente en tu navegador (usualmente en `http://localhost:8501`).
+
+## Notas sobre el Rendimiento
+
+*   **Memoria RAM**: Se recomienda disponer de al menos **8 GB de RAM**, ya que los modelos de visión y lenguaje se cargan en memoria.
+*   **GPU**: Si dispones de una GPU NVIDIA (CUDA) o un Mac con chip M-series (MPS), la aplicación intentará usarla para acelerar la detección. De lo contrario, funcionará en CPU (más lento).
+*   **Streamlit Cloud**: Es posible que esta aplicación **no funcione** en la capa gratuita de Streamlit Cloud debido a las limitaciones de memoria y almacenamiento (los modelos exceden el límite habitual). Se recomienda ejecutar en local o en un servidor con mayores recursos.
+
+## Estructura del Proyecto
+
+*   `app.py`: Punto de entrada de la aplicación Streamlit.
+*   `logic.py`: Lógica principal (IA, geometría, recomendación).
+*   `models/`: Contiene los pesos de los modelos (HorizonNet y BERT Encoder).
+*   `data/`: Base de datos de muebles (CSV).
+*   `horizonnet/`: Código fuente del modelo de visión computacional.
+
+## Autor
+
+**Andrés Gerlotti Slusnys**
+Máster de Data Science, Business Analytics y Big Data
+Universidad Complutense de Madrid
+© 2025

app.py

@@ -0,0 +1,404 @@
+import streamlit as st
+import pandas as pd
+import numpy as np
+from PIL import Image
+import os
+
+# Importar la lógica principal del proyecto
+import logic
+
+# --- CONFIGURACIÓN INICIAL DE LA PÁGINA ---
+st.set_page_config(page_title="DesignIA - Recomendador de Muebles inteligente", layout="wide")
+
+# --- CARGAR ESTILOS CSS ---
+def cargar_estilo():
+    """Define y aplica estilos CSS para la UI de Streamlit."""
+    st.markdown("""
+        <style>
+        /* Ocultar elementos de sistema de Streamlit */
+        #MainMenu {visibility: hidden;}
+        footer {visibility: hidden;}
+        header {visibility: hidden;}
+        
+        /* Estilo de Botones (Azul IKEA) */
+        div.stButton > button:first-child {
+            background-color: #0051ba; 
+            color: white; 
+            border-radius: 8px; 
+            font-weight: bold; 
+            border: none; 
+            padding: 0.5rem 1rem;
+        }
+        div.stButton > button:first-child:hover { 
+            background-color: #003e8f; 
+            border: none; 
+        }
+        
+        /* Estilo de las Tarjetas de Producto */
+        .product-card {
+            background-color: white; 
+            padding: 15px; 
+            border-radius: 10px;
+            box-shadow: 0 2px 5px rgba(0,0,0,0.05); 
+            margin-bottom: 15px; 
+            border: 1px solid #eee;
+            color: black !important; /* Forzar texto negro dentro de la tarjeta blanca */
+        }
+        </style>
+    """, unsafe_allow_html=True)
+
+cargar_estilo()
+
+# --- CONSTANTES Y RUTAS DE RECURSOS ---
+# Rutas relativas para despliegue
+csv_path = "data/furniture_data.csv"
+model_path = "models/bert_style_encoder.pth"
+horizon_path = "models/horizonnet_model.pth"
+cache_path = "vectores_cache.pkl" # Se generará en el directorio de trabajo
+
+# --- SIDEBAR: INFORMACIÓN DEL PROYECTO ---
+with st.sidebar:
+    st.title("DesignIA - Asistente de Diseño")
+    st.markdown("---")
+    st.markdown("**Trabajo de fin de Máster**")
+    st.caption("Máster de Data Science, Business Analytics y Big Data")
+    st.caption("Universidad Complutense de Madrid")
+    st.markdown("---")
+    st.markdown("Desarrollado por **Andrés Gerlotti Slusnys**")
+    st.markdown("© 2025")
+    
+    # Indicador de estado para debugging
+    with st.expander("Estado del Sistema", expanded=False):
+        st.success("Motor Gráfico: Activo")
+        st.success("Modelo NLP: Cargado")
+        if os.path.exists(horizon_path):
+            st.success("HorizonNet: Conectado")
+        else:
+            st.error("HorizonNet: No encontrado")
+
+    # Sección de Ejemplos
+    st.markdown("---")
+    st.subheader("📸 Imágenes de Ejemplo")
+    st.caption("Descarga estas imágenes para probar la app:")
+    
+    examples_dir = os.path.join(os.path.dirname(__file__), "examples")
+    if os.path.exists(examples_dir):
+        example_files = [f for f in os.listdir(examples_dir) if f.endswith(('.jpg', '.png'))]
+        example_files.sort()
+        
+        selected_example = st.selectbox("Selecciona un ejemplo:", example_files)
+        
+        if selected_example:
+            file_path = os.path.join(examples_dir, selected_example)
+            with open(file_path, "rb") as file:
+                btn = st.download_button(
+                    label="⬇️ Descargar Imagen",
+                    data=file,
+                    file_name=selected_example,
+                    mime="image/jpeg"
+                )
+            
+            # Mostrar miniatura
+            st.image(file_path, caption="Vista previa", use_container_width=True)
+    else:
+        st.info("No hay ejemplos disponibles.")
+
+# --- INICIALIZACIÓN DEL ESTADO DE SESIÓN ---
+if 'stage' not in st.session_state: st.session_state.stage = 0
+if 'room_data' not in st.session_state: st.session_state.room_data = None
+if 'muebles_df' not in st.session_state: st.session_state.muebles_df = None
+if 'data_manager' not in st.session_state: st.session_state.data_manager = None
+
+# --- 1. CARGA DE DATOS Y MODELOS (Cacheado) ---
+@st.cache_resource
+def init_backend(csv, cache, model):
+    """Inicializa DataManager y carga/genera el DataFrame de muebles."""
+    dm = logic.DataManager(csv, cache, model)
+    df = dm.cargar_datos()
+    return dm, df
+
+try:
+    if st.session_state.data_manager is None:
+        with st.spinner("Cargando base de datos de muebles y modelos IA..."):
+            dm, df = init_backend(csv_path, cache_path, model_path)
+            st.session_state.data_manager = dm
+            st.session_state.muebles_df = df
+    st.sidebar.success(f"Base de datos cargada: {len(st.session_state.muebles_df)} items")
+except Exception as e:
+    st.error(f"Error cargando datos: {e}")
+    st.stop()
+
+# --- INTERFAZ PRINCIPAL ---
+st.title("Recomendador de Muebles Inteligente")
+st.markdown("Sube una panorámica, detecta el espacio y obtén el diseño ideal según tu presupuesto.")
+
+# --- PASO 1: CARGA DE IMAGEN Y DETECCIÓN ---
+st.header("1. Escaneo de Habitación")
+uploaded_file = st.file_uploader("Sube tu imagen panorámica (360)", type=['jpg', 'png', 'jpeg'])
+
+if uploaded_file is not None:
+    image = Image.open(uploaded_file)
+    st.image(image, caption='Imagen subida', use_container_width=True)
+    
+    if st.button("Analizar la habitación"):
+        with st.spinner("Detectando la geometría..."):
+            # Guardar temporalmente la imagen para que la librería pueda leerla
+            with open("temp_pano.jpg", "wb") as f:
+                f.write(uploaded_file.getbuffer())
+            
+            # Instanciar y ejecutar el detector de layout (HorizonNet)
+            try:
+                detector = logic.RoomLayoutDetector(horizon_path)
+                room_data = detector.detect_layout("temp_pano.jpg")
+                
+                # Validación de datos y manejo de fallos
+                if room_data is None or not isinstance(room_data, dict) or 'width' not in room_data:
+                    st.error("**Detección fallida.** El modelo de Computer Vision no pudo extraer las dimensiones ni los obstáculos. Asegúrate de que el modelo HorizonNet está configurado y funcionando correctamente.")
+                    st.session_state.room_data = None
+                    st.session_state.stage = 0
+                else:
+                    st.session_state.room_data = room_data
+                    st.session_state.stage = 1
+                    st.success("Análisis completado")
+
+                    # Mostrar resultado de la detección de HorizonNet
+                    st.header("Resultado del análisis visual")
+                    annotated_image = logic.dibujar_layout_sobre_imagen("temp_pano.jpg", room_data)
+                    st.image(annotated_image, caption='Análisis de HorizonNet (Vértices, Puertas y Ventanas)', use_container_width=True)
+                
+            except Exception as e:
+                st.error(f"Error en detección: {e}. Revisa la configuración del modelo HorizonNet.")
+                st.session_state.stage = 0
+
+# --- PASO 2: VERIFICACIÓN Y EDICIÓN DE GEOMETRÍA/OBSTÁCULOS ---
+if st.session_state.stage >= 1 and st.session_state.room_data:
+    st.header("2. Verificación de Geometría")
+    
+    # Mostrar dimensiones detectadas
+    w_m = st.session_state.room_data.get('width', 0.0)
+    l_m = st.session_state.room_data.get('length', 0.0)
+    
+    col1, col2 = st.columns(2)
+    with col1:
+        st.metric("Ancho (m)", f"{w_m:.2f}")
+    with col2:
+        st.metric("Largo (m)", f"{l_m:.2f}")
+    
+    # Mostrar el diagrama de planta
+    st.subheader("Planta de la habitación")
+    floor_plan_fig = logic.generar_diagrama_planta(st.session_state.room_data)
+    st.pyplot(floor_plan_fig)
+    
+    # Formulario para añadir puertas y ventanas manualmente
+    st.subheader("Añadir puertas y ventanas manualmente")
+    
+    polygon_points = st.session_state.room_data.get('polygon_points', [])
+    num_walls = len(polygon_points) if polygon_points is not None else 0
+    
+    if num_walls > 0:
+        col_a, col_b, col_c, col_d = st.columns(4)
+        
+        with col_a:
+            wall_options = [f"Pared {i+1}" for i in range(num_walls)]
+            selected_wall = st.selectbox("Seleccionar Pared", wall_options, key="wall_select")
+            wall_idx = int(selected_wall.split()[1]) - 1
+        
+        with col_b:
+            obstacle_type = st.radio("Tipo", ["Puerta", "Ventana"], key="obs_type")
+        
+        with col_c:
+            # Posición normalizada [0.0, 1.0]
+            position_pct = st.number_input("Posición (%)", min_value=0.0, max_value=100.0, value=50.0, step=5.0, key="obs_pos")
+        
+        with col_d:
+            width_m = st.number_input("Ancho (m)", min_value=0.1, max_value=5.0, value=0.9, step=0.1, key="obs_width")
+        
+        if st.button("Añadir elemento"):
+            # Los datos de centro están normalizados
+            new_obstacle = {
+                'center': [position_pct / 100.0, wall_idx / max(1, num_walls)],
+                'width': width_m
+            }
+            
+            if obstacle_type == "Puerta":
+                st.session_state.room_data['doors'].append(new_obstacle)
+            else:
+                st.session_state.room_data['windows'].append(new_obstacle)
+            
+            st.success(f"{obstacle_type} añadida a {selected_wall}")
+            st.rerun()
+    else:
+        st.warning("No se detectaron paredes en el polígono.")
+    
+    # Editor de datos para modificar obstáculos detectados/añadidos
+    st.subheader("Editar elementos (puertas y ventanas)")
+    st.info("Ajusta las coordenadas de los obstáculos. Los valores X/Y están normalizados [0.0, 1.0].")
+
+    # Preparar datos para st.data_editor
+    doors_data = []
+    for i, d in enumerate(st.session_state.room_data.get('doors', [])):
+        center_y = d['center'][1] if len(d['center']) > 1 else 0 
+        doors_data.append({"ID": f"P{i}", "Tipo": "Puerta", "Centro X (Norm.)": d['center'][0], "Centro Y (Norm.)": center_y, "Ancho (m)": d['width']})
+    
+    windows_data = []
+    for i, w in enumerate(st.session_state.room_data.get('windows', [])):
+        center_y = w['center'][1] if len(w['center']) > 1 else 0
+        windows_data.append({"ID": f"V{i}", "Tipo": "Ventana", "Centro X (Norm.)": w['center'][0], "Centro Y (Norm.)": center_y, "Ancho (m)": w['width']})
+
+    all_obstacles = doors_data + windows_data
+    df_obs = pd.DataFrame(all_obstacles)
+    
+    col_config = {
+        "Centro X (Norm.)": st.column_config.NumberColumn("Centro X (Norm.)", help="Posición horizontal normalizada [0.0, 1.0]", format="%.2f"),
+        "Centro Y (Norm.)": st.column_config.NumberColumn("Centro Y (Norm.)", help="Posición vertical normalizada [0.0, 1.0]", format="%.2f"),
+        "Ancho (m)": st.column_config.NumberColumn("Ancho (m)", help="Ancho del obstáculo en metros", format="%.2f"),
+    }
+    
+    edited_df = st.data_editor(df_obs, num_rows="dynamic", use_container_width=True, column_config=col_config)
+
+    if st.button("Confirmar geometría"):
+        # Reconstruir el diccionario room_data a partir del DataFrame editado
+        new_doors = []
+        new_windows = []
+        for index, row in edited_df.iterrows():
+            obj = {'center': [row['Centro X (Norm.)'], row['Centro Y (Norm.)']], 'width': row['Ancho (m)']}
+            if row['Tipo'] == 'Puerta': new_doors.append(obj)
+            else: new_windows.append(obj)
+            
+        st.session_state.room_data['doors'] = new_doors
+        st.session_state.room_data['windows'] = new_windows
+        st.session_state.stage = 2
+        st.rerun()
+
+# --- PASO 3: PRESUPUESTO Y GENERACIÓN DE LAYOUT/RECOMENDACIÓN ---
+if st.session_state.stage >= 2:
+    st.header("3. Presupuesto y generación")
+    
+    presupuesto = st.number_input("Presupuesto Máximo (€)", min_value=100.0, value=1000.0, step=100.0)
+    
+    if st.button("Generar diseño"):
+        # Convertir dimensiones de m a cm para el LayoutEngine
+        w_cm = st.session_state.room_data.get('width', 0.0) * 100
+        l_cm = st.session_state.room_data.get('length', 0.0) * 100
+        
+        if w_cm < 200 or l_cm < 200:
+            st.error("Las dimensiones de la habitación son demasiado pequeñas (mínimo 2x2m) o no fueron capturadas correctamente.")
+        else:
+            with st.spinner("Calculando distribución óptima y seleccionando muebles..."):
+                # 1. Inicializar motores
+                layout_engine = logic.LayoutEngine(st.session_state.data_manager.dimensiones_promedio)
+                recommender = logic.Recommender(st.session_state.muebles_df)
+                
+                # 2. Sugerir el pack de muebles base
+                pack_sugerido = layout_engine.sugerir_pack(w_cm, l_cm)
+                
+                # 3. Convertir obstáculos a polígonos para el motor
+                obs_layout = layout_engine.convertir_obstaculos(
+                    st.session_state.room_data, 
+                    w_cm, l_cm, 
+                    polygon_points=st.session_state.room_data.get('polygon_points')
+                )
+                
+                # 4. Generar el Layout
+                layout_plan, constraints, log_msgs = layout_engine.generar_layout(
+                    w_cm, l_cm, 
+                    pack_sugerido, 
+                    obs_layout,
+                    polygon_points=st.session_state.room_data.get('polygon_points')
+                )
+
+                # Mostrar Log de Generación
+                with st.expander("📝 Detalles de la Generación del Layout", expanded=False):
+                    for msg in log_msgs:
+                        if "✅" in msg: st.success(msg)
+                        elif "❌" in msg: st.error(msg)
+                        elif "⚠️" in msg: st.warning(msg)
+                        else: st.text(msg)
+                
+                if not layout_plan:
+                    st.error("No se pudo generar una distribución válida para este espacio (demasiado pequeño o muchos obstáculos).")
+                else:
+                    # 5. Recomendar productos (Knapsack para optimización de precio/estilo)
+                    # Las 'constraints' se definen por los muebles que el layout PUDO colocar
+                    best_combo = recommender.buscar_combinacion(constraints, presupuesto, top_n=1)
+                    
+                    if not best_combo:
+                        st.error("No se encontraron muebles que se ajusten al presupuesto y restricciones.")
+                    else:
+                        st.session_state.result_layout = layout_plan
+                        st.session_state.result_items = best_combo[0]['items']
+                        st.session_state.result_total = best_combo[0]['precio_total']
+                        st.session_state.result_score = best_combo[0]['score']
+                        st.session_state.stage = 3
+
+# --- PASO 4: RESULTADOS Y VISUALIZACIÓN FINAL ---
+if st.session_state.stage == 3:
+    st.divider()
+    st.header("Tu salón ideal")
+    
+    # --- VISUALIZACIÓN 3D Interactiva (Plotly) ---
+    st.subheader("Visualización 3D Interactiva")
+    
+    # Generar la figura 3D
+    fig_plotly = logic.generar_figura_3d_plotly(
+        st.session_state.result_layout, 
+        st.session_state.room_data,
+        st.session_state.result_items
+    )
+    
+    # Renderizar la figura de Plotly
+    st.plotly_chart(fig_plotly, use_container_width=True, theme="streamlit")
+    
+    st.info("💡 Usa el ratón: Clic izquierdo para rotar, rueda para zoom.")
+        
+    st.divider()
+
+    # --- LISTA DE COMPRA ---
+    st.subheader("Lista de Compra")
+    
+    # Totales y Score de Diseño
+    c_tot1, c_tot2 = st.columns([2, 1])
+    with c_tot1:
+        st.markdown("### Total Estimado")
+        st.caption(f"Score de Diseño (Estilo + Puntuación Base): {st.session_state.result_score:.2f}/1.0")
+    with c_tot2:
+        st.markdown(f"### {st.session_state.result_total:.2f}€")
+    
+    st.markdown("---")
+    
+    # Listado de productos
+    for item in st.session_state.result_items:
+        with st.container():
+            c_img, c_info, c_price, c_link = st.columns([1, 2, 1, 1])
+            
+            url = f"https://www.ikea.com/es/es/p/{item.get('Enlace_producto', '')}-{item.get('ID', '')}"
+            img_src = item.get('Imagen_principal', '')
+            nombre = item['Nombre']
+            tipo = item['Tipo_mueble']
+            precio = float(item['Precio'])
+            
+            with c_img:
+                if img_src:
+                    st.image(img_src, width=150)
+                else:
+                    st.text("Sin imagen")
+            
+            with c_info:
+                st.subheader(nombre)
+                st.caption(tipo)
+                st.text(item.get('Descripcion', '')[:100] + '...')
+            
+            with c_price:
+                st.markdown(f"### {precio:.2f} €")
+            
+            with c_link:
+                st.link_button("Ver en IKEA", url)
+            
+            st.divider()
+    
+    if st.button("Reiniciar"):
+        for key in ['room_data', 'result_layout', 'result_items', 'result_total', 'result_score']:
+            if key in st.session_state:
+                del st.session_state[key]
+        st.session_state.stage = 0
+        st.rerun()

generate_cache.py

@@ -0,0 +1,22 @@
+import os
+import sys
+import logic
+
+# Configurar rutas
+base_dir = os.path.dirname(__file__)
+csv_path = os.path.join(base_dir, "data", "furniture_data.csv")
+model_path = os.path.join(base_dir, "models", "bert_style_encoder.pth")
+cache_path = os.path.join(base_dir, "vectores_cache.pkl")
+
+print("Iniciando generación de caché...")
+print(f"CSV: {csv_path}")
+print(f"Modelo: {model_path}")
+
+# Inicializar DataManager
+dm = logic.DataManager(csv_path, cache_path, model_path)
+
+# Esto forzará la generación y guardado del pickle
+df = dm.cargar_datos()
+
+print(f"Caché generado exitosamente en: {cache_path}")
+print(f"Total items: {len(df)}")

logic.py

@@ -0,0 +1,1470 @@
+import pandas as pd
+import numpy as np
+import os
+import itertools
+import pickle
+import torch
+import torch.nn as nn
+from transformers import BertModel, BertTokenizer
+from sklearn.metrics.pairwise import cosine_similarity
+import matplotlib.pyplot as plt
+from shapely.geometry import Polygon, LineString, Point
+from tqdm import tqdm
+import sys
+from PIL import Image, ImageDraw
+import plotly.graph_objects as go
+import pywavefront
+
+# --- CONFIGURACIÓN DE RUTAS EXTERNAS ---
+# En despliegue, HorizonNet está en un subdirectorio local
+HORIZON_NET_PATH = os.path.join(os.path.dirname(__file__), 'horizonnet')
+MODEL_DIR = os.path.join(os.path.dirname(__file__), 'modelos_3D')
+
+if HORIZON_NET_PATH not in sys.path:
+    sys.path.append(HORIZON_NET_PATH)
+
+try:
+    # Importar desde el paquete local horizonnet
+    from horizonnet.model import HorizonNet
+    from horizonnet.inference import inference
+    from horizonnet.misc import utils
+except ImportError as e:
+    print(f"Error al importar HorizonNet desde {HORIZON_NET_PATH}")
+    print(f"Detalle: {e}")
+    # Definición de clase MOCK para evitar un crash de la aplicación
+    class RoomLayoutDetector:
+        def __init__(self, model_path): 
+            print("RoomLayoutDetector en modo MOCK (Error de importación)")
+        def detect_layout(self, img_path): return None
+
+# ==========================================
+# CLASE DE DETECCIÓN DE LAYOUT (HorizonNet)
+# ==========================================
+class RoomLayoutDetector:
+    """
+    Clase para la detección de geometría de habitación (floor/ceiling boundaries)
+    y corners a partir de una imagen panorámica 360 usando HorizonNet.
+    """
+    def __init__(self, model_path):
+        # Utiliza MPS (Metal Performance Shaders) si está disponible en M4
+        self.device = torch.device('cpu') 
+        if torch.backends.mps.is_available():
+            self.device = torch.device('mps')
+        
+        print(f"Cargando modelo desde: {model_path} en {self.device}")
+        try:
+            self.net = utils.load_trained_model(HorizonNet, model_path).to(self.device)
+            self.net.eval()
+        except Exception as e:
+            print(f"Error cargando modelo: {e}")
+            self.net = None
+
+    def detect_layout(self, img_path):
+        """Ejecuta la inferencia de HorizonNet y escala los resultados a metros."""
+        if self.net is None: return None
+        
+        # 1. Preprocesar imagen
+        try:
+            img_pil = Image.open(img_path)
+            if img_pil.size != (1024, 512):
+                img_pil = img_pil.resize((1024, 512), Image.BICUBIC)
+            img_ori = np.array(img_pil)[..., :3].transpose([2, 0, 1]).copy()
+            x = torch.FloatTensor([img_ori / 255])
+            
+            # 2. Inferencia
+            with torch.no_grad():
+                cor_id, z0, z1, vis_out = inference(
+                    net=self.net, x=x, device=self.device,
+                    flip=False, rotate=[], visualize=False,
+                    force_cuboid=False, force_raw=False,
+                    min_v=None, r=0.05
+                )
+            
+            # 3. Procesar resultados: Obtener polígono del suelo
+            uv = [[float(u), float(v)] for u, v in cor_id]
+            floor_points = self._uv_to_floor_polygon(uv, z0, z1)
+            
+            # 4. Calcular dimensiones y escalar a metros
+            min_x, min_y = floor_points.min(axis=0)
+            max_x, max_y = floor_points.max(axis=0)
+            ancho_bbox = max_x - min_x
+            largo_bbox = max_y - min_y
+            altura_unidades = abs(z1 - z0)
+            
+            # Factor de escala: Se asume altura de cámara de 1.6m (z0)
+            ALTURA_CAMARA = 1.6
+            factor_escala = ALTURA_CAMARA / z0
+            
+            ancho_m = ancho_bbox * factor_escala
+            largo_m = largo_bbox * factor_escala
+            altura_m = altura_unidades * factor_escala
+            
+            # Escalar puntos para visualización 3D y normalizar para 2D (planta)
+            floor_points_scaled = floor_points * factor_escala
+            # Para la planta 2D, normalizamos para que empiece en (0,0) y esté en metros
+            floor_points_norm = (floor_points_scaled - [floor_points_scaled[:,0].min(), floor_points_scaled[:,1].min()])
+            
+            # Obtener datos raw para la visualización de la detección
+            x_tensor = x.to(self.device)
+            y_bon_, y_cor_ = self.net(x_tensor)
+            y_bon_ = y_bon_.cpu().detach().numpy()[0]
+            y_cor_ = torch.sigmoid(y_cor_).cpu().detach().numpy()[0, 0]
+            
+            return {
+                'width': ancho_m,
+                'length': largo_m,
+                'height': altura_m,
+                'doors': [], 'windows': [], # Estos deberían ser inferidos en tu versión completa
+                'y_bon': y_bon_, 'y_cor': y_cor_,
+                'polygon_points': floor_points_norm.tolist(), 
+                'polygon_points_raw': floor_points_scaled.tolist(), 
+                'factor_escala': factor_escala
+            }
+            
+        except Exception as e:
+            print(f"Error en inferencia: {e}")
+            import traceback
+            traceback.print_exc()
+            return None
+
+    def _uv_to_floor_polygon(self, uv, z0, z1):
+        """Convierte los puntos uv (coordenadas de la imagen) en coordenadas (x,y) del plano del suelo."""
+        floor_points = []
+        for i in range(0, len(uv), 2):
+            u = uv[i][0]
+            v_floor = uv[i+1][1]
+            lon = (u - 0.5) * 2 * np.pi
+            lat = (0.5 - v_floor) * np.pi
+            # Fórmula de proyección esférica
+            r = abs(z0 / np.tan(lat)) if np.tan(lat) != 0 else 0
+            x = r * np.cos(lon)
+            y = r * np.sin(lon)
+            floor_points.append([x, y])
+        return np.array(floor_points)
+
+# ==========================================
+# 1. MODELO DE ESTILO (Encoder basado en BERT)
+# ==========================================
+class StyleEncoder(nn.Module):
+    """
+    Encoder de estilo basado en BERT para generar un vector de embedding
+    a partir de la descripción de un mueble.
+    """
+    def __init__(self, n_dims=128):
+        super(StyleEncoder, self).__init__()
+        self.bert = BertModel.from_pretrained('bert-base-multilingual-cased')
+        self.fc = nn.Linear(self.bert.config.hidden_size, n_dims)
+        
+    def forward(self, input_ids, attention_mask):
+        bert_output = self.bert(input_ids=input_ids, attention_mask=attention_mask)
+        pooler_output = bert_output[1] # Vector [CLS]
+        vector_estilo = self.fc(pooler_output)
+        return vector_estilo
+
+# ==========================================
+# 2. GESTOR DE DATOS Y CARGA
+# ==========================================
+class DataManager:
+    """Gestiona la carga de la base de datos, la vectorización y el cacheo."""
+    def __init__(self, csv_path, vectors_cache_path, bert_model_path):
+        self.csv_path = csv_path
+        self.cache_path = vectors_cache_path
+        self.bert_model_path = bert_model_path
+        self.df_muebles = None
+        self.dimensiones_promedio = {}
+        
+        # Tipos de muebles relevantes para el layout del salón
+        self.muebles_a_usar = [
+            'Sofás', 'Sillones', 'Muebles de salón',
+            'Mesas bajas de salón, de centro y auxiliares',
+            'Estanterías y librerías'
+        ]
+
+    def cargar_datos(self):
+        """Carga los vectores desde caché o los genera usando el StyleEncoder."""
+        if os.path.exists(self.cache_path):
+            print(f"Cargando caché de: {self.cache_path}")
+            with open(self.cache_path, 'rb') as f:
+                self.df_muebles = pickle.load(f)
+        else:
+            print("Generando vectores (esto puede tardar)...")
+            self._generar_vectores()
+        
+        # Filtrar sofás excesivamente grandes (> 300cm) que rompen el layout en habitaciones normales
+        if self.df_muebles is not None:
+            self.df_muebles = self.df_muebles[~((self.df_muebles['Tipo_mueble'] == 'Sofás') & (self.df_muebles['Ancho'] > 300))]
+        
+        # Pre-procesar columnas de dimensiones para asegurar que son numéricas y válidas
+        if self.df_muebles is not None:
+            cols_dim = ['Ancho', 'Largo', 'Altura']
+            for col in cols_dim:
+                self.df_muebles[col] = pd.to_numeric(self.df_muebles[col], errors='coerce')
+                self.df_muebles.loc[self.df_muebles[col] <= 0, col] = np.nan
+
+        # Calcular dimensiones promedio por categoría
+        if self.df_muebles is not None:
+            avg_df = self.df_muebles.groupby('Tipo_mueble')[['Ancho', 'Largo']].mean()
+            self.dimensiones_promedio = avg_df.to_dict('index')
+            
+            # Normalizar claves a minúsculas para evitar errores de key y aplicar lógica de negocio
+            processed_dims = {}
+            for k, v in self.dimensiones_promedio.items():
+                ancho = round(v.get('Ancho', 100.0), 1)
+                largo = round(v.get('Largo', 50.0), 1)
+
+                # Correcciones de lógica de negocio o datos faltantes (en cm)
+                if k == 'Sofás':
+                    if largo < 50: largo = 90.0
+                if k == 'Sillones':
+                    if largo < 40: largo = ancho if ancho >= 40 else 70.0
+                
+                processed_dims[k] = {'ancho': ancho, 'largo': largo}
+            self.dimensiones_promedio = processed_dims
+
+        # Imputar valores faltantes o inválidos en el DataFrame con los promedios calculados
+        if self.df_muebles is not None:
+            for tipo, dims in self.dimensiones_promedio.items():
+                mask_tipo = self.df_muebles['Tipo_mueble'] == tipo
+                
+                # Imputar Ancho
+                mask_invalid_w = mask_tipo & (self.df_muebles['Ancho'].isna())
+                if mask_invalid_w.any():
+                    self.df_muebles.loc[mask_invalid_w, 'Ancho'] = dims['ancho']
+                    
+                # Imputar Largo
+                mask_invalid_l = mask_tipo & (self.df_muebles['Largo'].isna() | (self.df_muebles['Largo'] <= 0))
+                if mask_invalid_l.any():
+                    self.df_muebles.loc[mask_invalid_l, 'Largo'] = dims['largo']
+                    
+                # Imputar Altura (opcional, pero bueno para consistencia)
+                # mask_invalid_h = mask_tipo & (self.df_muebles['Altura'].isna() | (self.df_muebles['Altura'] <= 0))
+                # if mask_invalid_h.any():
+                #    self.df_muebles.loc[mask_invalid_h, 'Altura'] = 60 # Valor por defecto seguro
+
+        return self.df_muebles
+
+    def _generar_vectores(self, n_dims=128):
+        """Procesa el CSV y genera el vector de estilo para cada mueble."""
+        if not os.path.exists(self.csv_path):
+            raise FileNotFoundError(f"No se encuentra el CSV en {self.csv_path}")
+            
+        df = pd.read_csv(self.csv_path)
+        df_filtrado = df[df['Tipo_mueble'].isin(self.muebles_a_usar)].copy()
+        
+        # Carga modelo BERT
+        device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
+        model = StyleEncoder(n_dims=n_dims).to(device)
+        
+        if os.path.exists(self.bert_model_path):
+            model.load_state_dict(torch.load(self.bert_model_path, map_location=device))
+        else:
+            print("ADVERTENCIA: No se encontraron pesos del modelo BERT, usando aleatorios.")
+
+        tokenizer = BertTokenizer.from_pretrained('bert-base-multilingual-cased')
+        model.eval()
+        
+        df_filtrado['text_data'] = df_filtrado['Nombre'].fillna('') + ' ' + df_filtrado['Descripcion'].fillna('')
+        generated_vectors = []
+        
+        with torch.no_grad():
+            for text in tqdm(df_filtrado['text_data'], desc="Vectorizando"):
+                tokens = tokenizer(text, padding='max_length', truncation=True, max_length=64, return_tensors='pt')
+                input_ids = tokens['input_ids'].to(device)
+                attention_mask = tokens['attention_mask'].to(device)
+                vector = model(input_ids, attention_mask)
+                generated_vectors.append(vector.cpu().detach().numpy().flatten())
+        
+        df_filtrado['vector_estilo'] = generated_vectors
+        df_filtrado['vector_estilo'] = df_filtrado['vector_estilo'].apply(lambda x: np.array(x))
+        
+        self.df_muebles = df_filtrado
+        # Guardar caché
+        try:
+            with open(self.cache_path, 'wb') as f:
+                pickle.dump(self.df_muebles, f)
+        except Exception as e:
+            print(f"Advertencia: No se pudo guardar la caché de vectores: {e}")
+
+
+    def _calcular_dimensiones_promedio(self):
+        """Calcula el ancho y largo promedio por Tipo_mueble."""
+        if self.df_muebles is None: return
+        
+        cols = ['Ancho', 'Largo', 'Altura']
+        for col in cols:
+            self.df_muebles[col] = pd.to_numeric(self.df_muebles[col], errors='coerce')
+            # Reemplazar valores <= 0 con NaN para no afectar el promedio
+            self.df_muebles.loc[self.df_muebles[col] <= 0, col] = np.nan
+            
+        avg_df = self.df_muebles.groupby('Tipo_mueble')[cols].mean()
+        
+        self.dimensiones_promedio = {}
+        for tipo, row in avg_df.iterrows():
+            self.dimensiones_promedio[tipo] = {
+                'nombre': tipo,
+                'ancho': round(row['Ancho'], 1) if not pd.isna(row['Ancho']) else 100.0,
+                'largo': round(row['Largo'], 1) if not pd.isna(row['Largo']) else 50.0
+            }
+        
+        # Correcciones de lógica de negocio o datos faltantes (en cm)
+        if 'Sofás' in self.dimensiones_promedio:
+            if self.dimensiones_promedio['Sofás']['largo'] < 50: self.dimensiones_promedio['Sofás']['largo'] = 90.0
+        if 'Sillones' in self.dimensiones_promedio:
+             if self.dimensiones_promedio['Sillones']['largo'] < 40:
+                 self.dimensiones_promedio['Sillones']['largo'] = self.dimensiones_promedio['Sillones']['ancho'] if self.dimensiones_promedio['Sillones']['ancho'] >= 40 else 70.0
+
+# ==========================================
+# 3. MOTOR DE LAYOUT (Lógica Espacial y de Colocación)
+# ==========================================
+class LayoutEngine:
+    """Implementa la lógica de colocación de muebles, restricciones espaciales y colisiones."""
+    def __init__(self, dimensiones_promedio):
+        self.dim_promedio = dimensiones_promedio
+        self.config = {
+            'pasillo_minimo': 90, # cm
+            'margen_pared': 10, # cm
+            'margen_obstaculo': 20, # cm
+            'distancia_tv_sofa': 280 # cm (distancia ideal)
+        }
+
+    def sugerir_pack(self, ancho_cm, largo_cm):
+        """Sugiere un conjunto de muebles base según el área de la habitación."""
+        area = (ancho_cm * largo_cm) / 10000.0
+        # Definición de tipos de mueble base
+        pack = [{'tipo': 'Muebles de salón'}, {'tipo': 'Mesas bajas de salón, de centro y auxiliares'}, {'tipo': 'Sofás'}]
+        # Añadir complejidad según el tamaño de la sala
+        if area > 16.0: pack.insert(0, {'tipo': 'Sillones'})
+        if area > 22.0: pack.insert(0, {'tipo': 'Estanterías y librerías'})
+        return pack
+
+    def convertir_obstaculos(self, obstaculos_dict, ancho_hab, largo_hab, polygon_points):
+        """Convierte los obstáculos detectados (puertas/ventanas) en polígonos Shapely con margen de seguridad."""
+        obs_polys = []
+        num_walls = len(polygon_points)
+        
+        todos_obs = []
+        for d in obstaculos_dict.get('doors', []): d['type'] = 'door'; todos_obs.append(d)
+        for w in obstaculos_dict.get('windows', []): w['type'] = 'window'; todos_obs.append(w)
+
+        for obs in todos_obs:
+            # Lógica para mapear la posición normalizada (0-1) a un polígono en CM
+            w_idx = int(round(obs['center'][1] * num_walls)) % num_walls
+            p1 = np.array(polygon_points[w_idx]) * 100
+            p2 = np.array(polygon_points[(w_idx + 1) % num_walls]) * 100
+            
+            vec_pared = p2 - p1
+            len_pared = np.linalg.norm(vec_pared)
+            unit_pared = vec_pared / len_pared
+            
+            # Centro del obstáculo a lo largo de la pared
+            center_pt = p1 + vec_pared * obs['center'][0]
+            width = obs['width'] * 100
+            depth = 250 if obs['type'] == 'door' else 30 # Profundidad de la zona de exclusión (250cm = ~1.25m dentro de la habitación)
+            
+            # Vector normal a la pared
+            normal = np.array([-unit_pared[1], unit_pared[0]])
+            
+            # Definir las esquinas del polígono de exclusión (con margen)
+            c1 = center_pt - unit_pared * (width/2) - normal * (depth/2)
+            c2 = center_pt + unit_pared * (width/2) - normal * (depth/2)
+            c3 = center_pt + unit_pared * (width/2) + normal * (depth/2)
+            c4 = center_pt - unit_pared * (width/2) + normal * (depth/2)
+            
+            poly = Polygon([c1, c2, c3, c4])
+            obs_polys.append({'poly': poly, 'tipo': obs['type']})
+            
+        return obs_polys
+
+    def _get_poly_from_rect(self, x, y, w, l, angle_rad):
+        """Genera un Polygon de Shapely rotado a partir del centro (x, y), dimensiones (w, l) y ángulo."""
+        cx, cy = x, y
+        dx = w / 2
+        dy = l / 2
+        
+        corners = [
+            (dx, dy), (-dx, dy), (-dx, -dy), (dx, -dy)
+        ]
+        
+        new_corners = []
+        c_cos = np.cos(angle_rad)
+        c_sin = np.sin(angle_rad)
+        
+        for px, py in corners:
+            nx = px * c_cos - py * c_sin + cx
+            ny = px * c_sin + py * c_cos + cy
+            new_corners.append((nx, ny))
+            
+        return Polygon(new_corners)
+
+    def _check_collision(self, candidate_poly, room_poly, placed_items, obstacles):
+        """Verifica si el polígono candidato colisiona con la pared, ítems colocados u obstáculos."""
+        # 1. Dentro de la habitación (con margen de pared)
+        buffered_room = room_poly.buffer(-self.config['margen_pared'])
+        if not buffered_room.contains(candidate_poly):
+            # print(f"DEBUG: Colisión con PARED. Poly fuera del buffer.")
+            # print(f"  Room Buffer Bounds: {buffered_room.bounds}")
+            # print(f"  Candidate Bounds: {candidate_poly.bounds}")
+            return False
+        
+        # 2. Colisión con items ya colocados
+        for item in placed_items:
+            # Usar un buffer de 10cm para asegurar un pequeño espacio entre muebles
+            if candidate_poly.buffer(10).intersects(item['poly']): 
+                # print(f"DEBUG: Colisión con ITEM {item['tipo']}.")
+                return False
+                
+        # 3. Colisión con obstáculos (con margen)
+        for obs in obstacles:
+            if candidate_poly.intersects(obs['poly']):
+                # print(f"DEBUG: Colisión con OBSTÁCULO {obs['tipo']}.")
+                return False
+                
+        return True
+
+    def _scan_wall(self, p1, p2, item_dim, room_poly, placed, obstacles, align_dist=None, align_target=None):
+        """Barre una pared específica buscando la primera ubicación válida para un mueble."""
+        vec = p2 - p1
+        wall_len = np.linalg.norm(vec)
+        unit_vec = vec / wall_len
+        
+        normal = np.array([-unit_vec[1], unit_vec[0]])
+        
+        # Verificar que la normal apunta al interior de la habitación
+        centroid = np.array(room_poly.centroid.coords[0])
+        mid_wall = (p1 + p2) / 2
+        if np.dot(centroid - mid_wall, normal) < 0:
+            normal = -normal 
+
+        w_item = item_dim['ancho']
+        l_item = item_dim['largo']
+        angle = np.arctan2(unit_vec[1], unit_vec[0])
+        
+        # Distancia del centro del mueble a la pared (para pegar a la pared)
+        dist_from_wall = self.config['margen_pared'] + l_item/2 
+        if align_dist: dist_from_wall = align_dist
+        
+        step = 20 # cm
+        margin_side = self.config['margen_pared'] + w_item/2
+        
+        range_start = margin_side
+        range_end = wall_len - margin_side
+        
+        if range_end < range_start: return []
+        
+        candidates = list(np.arange(range_start, range_end, step))
+        # Asegurar que el centro de la pared está en los candidatos
+        mid_dist = wall_len / 2
+        if range_start <= mid_dist <= range_end:
+            candidates.append(mid_dist)
+        # Ordenar para probar primero el centro? No necesariamente, pero ayuda.
+        candidates = sorted(list(set(candidates)))
+        
+        if align_target is not None:
+            # Lógica para alinear con un objeto existente
+            v_target = np.array([align_target['x'], align_target['y']]) - p1
+            proj_dist = np.dot(v_target, unit_vec)
+            candidates = [proj_dist] 
+            
+        valid_candidates = []
+        for dist_along in candidates:
+            center = p1 + unit_vec * dist_along + normal * dist_from_wall
+            cand_poly = self._get_poly_from_rect(center[0], center[1], w_item, l_item, angle)
+            
+            if self._check_collision(cand_poly, room_poly, placed, obstacles):
+                valid_candidates.append({
+                    'x': center[0], 'y': center[1], 
+                    'ancho': w_item, 'largo': l_item,
+                    'angle': angle, 
+                    'tipo': item_dim['nombre'],
+                    'poly': cand_poly
+                })
+        return valid_candidates
+
+    def generar_layout(self, ancho_hab, largo_hab, pack_sugerido, obs_layout, polygon_points=None):
+        """Genera el layout buscando una configuración TV-Sofá válida y añadiendo la mesa de centro."""
+        # setup básico
+        layout = []
+        constraints = []
+        log = []
+        final_layout_objs = []
+        
+        if not polygon_points:
+            # Usar un rectángulo simple si no hay polígono
+            polygon_points = [[0,0], [ancho_hab/100, 0], [ancho_hab/100, largo_hab/100], [0, largo_hab/100]]
+
+        poly_pts_cm = np.array(polygon_points) * 100
+        room_poly = Polygon(poly_pts_cm)
+        num_walls = len(poly_pts_cm)
+        
+        # Dimensiones promedio de los dos muebles clave
+        d_tv = self.dim_promedio.get('Muebles de salón', {'ancho': 120, 'largo': 40})
+        d_tv['nombre'] = 'Muebles de salón'
+        d_sofa = self.dim_promedio.get('Sofás', {'ancho': 200, 'largo': 90})
+        d_sofa['nombre'] = 'Sofás'
+        
+        # Estrategia de reintento con tamaños reducidos
+        attempt_configs = [
+            {'scale': 1.0, 'desc': 'Standard'},
+            {'scale': 0.8, 'desc': 'Compact'}
+        ]
+        
+        best_overall_score = -1
+        best_overall_layout = []
+        
+        for config in attempt_configs:
+            scale = config['scale']
+            # Aplicar escala a las dimensiones temporales para este intento
+            current_d_tv = d_tv.copy()
+            current_d_tv['ancho'] *= scale
+            current_d_tv['largo'] *= scale
+            
+            current_d_sofa = d_sofa.copy()
+            current_d_sofa['ancho'] *= scale
+            current_d_sofa['largo'] *= scale
+            
+            log.append(f"🔄 Intentando generación con modo {config['desc']} (Escala {scale})")
+            
+            best_score = -1
+            best_layout = []
+            
+            # Iterar sobre todas las paredes para encontrar la mejor ubicación para el binomio TV-Sofá
+            for i in range(num_walls):
+                p1 = poly_pts_cm[i]
+                p2 = poly_pts_cm[(i+1)%num_walls]
+                
+                # 1. Intentar poner Mueble de Salón (TV) en la pared
+                # Ahora devuelve una lista de candidatos
+                tv_candidates = self._scan_wall(p1, p2, current_d_tv, room_poly, [], obs_layout)
+                
+                for tv_pos in tv_candidates:
+                    current_layout = [tv_pos]
+                    
+                    # Calcular la normal del TV
+                    vec_pared = p2 - p1
+                    unit_vec_pared = vec_pared / np.linalg.norm(vec_pared)
+                    normal_base = np.array([-unit_vec_pared[1], unit_vec_pared[0]])
+                    
+                    centroid = np.array(room_poly.centroid.coords[0])
+                    mid_wall = (p1 + p2) / 2
+                    
+                    # Asegurar que la normal apunta al centro (adentro)
+                    if np.linalg.norm((mid_wall + normal_base) - centroid) > np.linalg.norm((mid_wall - normal_base) - centroid):
+                        tv_normal = -normal_base
+                    else:
+                        tv_normal = normal_base
+    
+                    # 2. Calcular dónde estaría el sofá y proyectar un rayo
+                    tv_center_pt = Point(tv_pos['x'], tv_pos['y'])
+                    ray_end_np = np.array([tv_pos['x'], tv_pos['y']]) + tv_normal * max(ancho_hab, largo_hab) * 100 
+                    ray = LineString([tv_center_pt, (ray_end_np[0], ray_end_np[1])])
+                    
+                    intersection = ray.intersection(room_poly.boundary)
+                    
+                    distancia_pared_opuesta = 9999
+                    
+                    if not intersection.is_empty:
+                        if intersection.geom_type == 'Point':
+                            d = tv_center_pt.distance(intersection)
+                            if d > 50: distancia_pared_opuesta = d
+                        elif intersection.geom_type == 'MultiPoint':
+                            for pt in intersection.geoms:
+                                d = tv_center_pt.distance(pt)
+                                if d > 50 and d < distancia_pared_opuesta:
+                                    distancia_pared_opuesta = d
+    
+                    dist_ideal = self.config['distancia_tv_sofa']
+                    fondo_sofa = current_d_sofa['largo']
+                    
+                    # Calcular el espacio libre entre la parte trasera del sofá y la pared
+                    espacio_detras = distancia_pared_opuesta - (tv_pos['largo']/2 + dist_ideal + fondo_sofa/2)
+                    
+                    dist_sofa_desde_tv = dist_ideal
+                    
+                    if distancia_pared_opuesta < (tv_pos['largo']/2 + dist_ideal + fondo_sofa + self.config['margen_pared']):
+                        # Si la habitación es demasiado pequeña, pega el sofá a la pared trasera
+                        # Corrección: No restar tv_pos['largo']/2 porque la distancia es desde el centro de la TV
+                        dist_sofa_desde_tv = distancia_pared_opuesta - fondo_sofa/2 - self.config['margen_pared']
+                        log_msg = f"✅ Sofá ajustado a pared (Espacio insuficiente para ideal)"
+                    elif espacio_detras < 100: # Aumentado a 100cm. Si sobra menos de 1m, pégalo atrás.
+                        # Corrección: Añadir 5cm extra de margen para asegurar que el polígono esté DENTRO del buffer de la habitación
+                        dist_sofa_desde_tv = distancia_pared_opuesta - fondo_sofa/2 - self.config['margen_pared'] - 5.0
+                        log_msg = f"✅ Sofá ajustado a pared (Evitar espacio muerto de {espacio_detras:.0f}cm)"
+                    else:
+                        # Posicionamiento ideal frente a TV
+                        dist_sofa_desde_tv = dist_ideal + tv_pos['largo']/2 + fondo_sofa/2
+                        log_msg = "✅ Sofá en isla"
+    
+    
+                    # Intentar colocar el sofá con "nudge" (empujoncitos) SOLO frontal para mantener alineación
+                    sofa_placed = False
+                    # Nudge frontal: 0 a 30cm
+                    for nudge in [0, 5, 10, 15, 20, 25, 30]:
+                        current_dist = dist_sofa_desde_tv - nudge
+                        
+                        sofa_center_np = np.array([tv_pos['x'], tv_pos['y']]) + tv_normal * current_dist
+                        sofa_poly = self._get_poly_from_rect(sofa_center_np[0], sofa_center_np[1], current_d_sofa['ancho'], current_d_sofa['largo'], tv_pos['angle'])
+                        
+                        sofa_cand = {
+                            'x': sofa_center_np[0], 'y': sofa_center_np[1],
+                            'ancho': current_d_sofa['ancho'], 'largo': current_d_sofa['largo'],
+                            'angle': tv_pos['angle'], 'tipo': 'Sofás', 'poly': sofa_poly
+                        }
+                        
+                        if self._check_collision(sofa_poly, room_poly, [tv_pos], obs_layout):
+                            current_layout.append(sofa_cand)
+                            score = 100 - nudge 
+                            if score > best_score:
+                                best_score = score
+                                best_layout = current_layout
+                                log.append(f"{log_msg} (Nudge={nudge}cm)")
+                                sofa_placed = True
+                            break 
+                    
+                    if sofa_placed:
+                        break # Romper el loop de TV candidates si ya encontramos un layout válido
+                    else:
+                        log.append(f"❌ Sofá colisiona tras intentos. DistBase={dist_sofa_desde_tv:.1f}")
+                        # print(f"DEBUG: Fallo Sofá. Dist={dist_sofa_desde_tv:.1f}. Wall={i}")
+            
+            if best_layout:
+                best_overall_layout = best_layout
+                best_overall_score = best_score
+                break # Si encontramos un layout válido con esta escala, nos quedamos con él
+        
+        best_layout = best_overall_layout # Restaurar para el resto del código
+
+        if best_layout:
+            # 2. Convertir layout a formato final y generar restricciones
+            for item in best_layout:
+                final_layout_objs.append({
+                    'x': item['x'], 'y': item['y'], 
+                    'ancho': item['ancho'], 'largo': item['largo'],
+                    'angle': item['angle'], 'tipo': item['tipo']
+                })
+                # Definir la restricción dimensional
+                constraints.append({'tipo': item['tipo'], 'max_ancho': item['ancho']*1.2, 'max_largo': item['largo']*1.2})
+            
+            # 3. Colocación condicional de Mesa de Centro
+            tv = best_layout[0]
+            sofa = best_layout[1]
+
+            # Calcular la distancia libre entre TV y Sofá
+            dist_centros = np.linalg.norm(np.array([tv['x'], tv['y']]) - np.array([sofa['x'], sofa['y']]))
+            depth_tv = tv['largo']
+            depth_sofa = sofa['largo']
+            
+            espacio_libre = dist_centros - (depth_tv / 2) - (depth_sofa / 2)
+
+            profundidad_mesa = self.dim_promedio.get('Mesas bajas de salón, de centro y auxiliares', {'largo': 60})['largo']
+            pasillo_minimo = 60 # cm para circular alrededor
+
+            if espacio_libre >= (profundidad_mesa + pasillo_minimo):
+                mid_x = (tv['x'] + sofa['x']) / 2
+                mid_y = (tv['y'] + sofa['y']) / 2
+                
+                final_layout_objs.append({
+                    'x': mid_x, 'y': mid_y, 
+                    'ancho': 100, 'largo': profundidad_mesa, # Usamos ancho y largo genérico
+                    'angle': tv['angle'],
+                    'tipo': 'Mesas bajas de salón, de centro y auxiliares'
+                })
+                constraints.append({'tipo': 'Mesas bajas de salón, de centro y auxiliares'})
+            else:
+                log.append(f"⚠️ Mesa de centro omitida: Espacio libre ({espacio_libre:.0f}cm) insuficiente para mesa + paso.")
+
+        else:
+            log.append("No se encontró distribución válida TV-Sofá. Distribución fallida.")
+            
+        return final_layout_objs, constraints, log
+
+# ==========================================
+# 4. MOTOR DE RECOMENDACIÓN (Knapsack/Estilo)
+# ==========================================
+class Recommender:
+    """Implementa el algoritmo de selección de productos para maximizar el Score/Coherencia dentro del presupuesto."""
+    def __init__(self, df_data):
+        self.df = df_data
+
+    def _coherencia(self, vectores):
+        """Calcula la coherencia de estilo promedio (Similitud Coseno) entre los vectores de estilo de los muebles."""
+        if len(vectores) < 2: return 1.0
+        mat = cosine_similarity(np.array(vectores))
+        # Promedio de la similitud entre todos los pares (triángulo superior)
+        indices = np.triu_indices_from(mat, k=1)
+        return float(np.mean(mat[indices])) if indices[0].size > 0 else 1.0
+
+    def buscar_combinacion(self, constraints, presupuesto, top_n=1):
+        """
+        Algoritmo Knapsack de fuerza bruta optimizada. 
+        Busca la mejor combinación de productos que cumpla restricciones dimensionales y presupuestarias, 
+        maximizando el score total (Score Base + Coherencia de Estilo).
+        """
+        listas_candidatos = []
+        
+        for const in constraints:
+            tipo = const['tipo']
+            max_w = const.get('max_ancho', 9999)
+            max_l = const.get('max_largo', 9999)
+            
+            # Filtro dimensional 
+            pool = self.df[self.df['Tipo_mueble'] == tipo]
+            # Permite rotación (Ancho <= Max_W y Largo <= Max_L) o (Ancho <= Max_L y Largo <= Max_W)
+            fits = pool[((pool['Ancho'] <= max_w) & (pool['Largo'] <= max_l)) | 
+                        ((pool['Ancho'] <= max_l) & (pool['Largo'] <= max_w))]
+            
+            if fits.empty: fits = pool # Si no hay que cumplen, toma la lista completa
+            
+            # ESTRATEGIA HÍBRIDA:
+            # Seleccionar los top 5 por Score (Calidad) Y los top 5 más baratos (Presupuesto)
+            # para asegurar que tenemos opciones viables si el presupuesto es bajo.
+            
+            top_score = fits.sort_values('Score', ascending=False).head(5)
+            top_cheap = fits.sort_values('Precio', ascending=True).head(5)
+            top_expensive = fits.sort_values('Precio', ascending=False).head(5)
+            
+            # Combinar y eliminar duplicados (usando ID para evitar error con numpy arrays)
+            candidates_df = pd.concat([top_score, top_cheap, top_expensive]).drop_duplicates(subset='ID')
+            
+            candidatos = candidates_df.to_dict('records')
+            listas_candidatos.append(candidatos)
+
+        if not listas_candidatos: return []
+
+        validas = []
+        for combo in itertools.product(*listas_candidatos):
+            precio = sum(x['Precio'] for x in combo)
+            if precio <= presupuesto:
+                score_base = np.mean([x['Score'] for x in combo])
+                vectores = [x['vector_estilo'] for x in combo]
+                coherencia = self._coherencia(vectores)
+                
+                # Score Final: 
+                # 40% Score Base (Calidad/Popularidad) 
+                # 40% Coherencia (Estilo)
+                # 20% Aprovechamiento de Presupuesto (Reward por usar el presupuesto disponible)
+                budget_utilization = precio / presupuesto
+                
+                final_score = 0.4 * score_base + 0.4 * coherencia + 0.2 * budget_utilization
+                
+                validas.append({
+                    'items': combo,
+                    'precio_total': precio,
+                    'score': final_score
+                })
+        
+        validas.sort(key=lambda x: x['score'], reverse=True)
+        return validas[:top_n]
+
+# ==========================================
+# 5. VISUALIZADORES (PLANTAS 2D y 3D con OBJs)
+# ==========================================
+
+def get_segment_properties(p1, p2):
+    """Calcula longitud, punto central y ángulo de un segmento 2D."""
+    p1 = np.array(p1)
+    p2 = np.array(p2)
+    
+    dx = p2[0] - p1[0]
+    dy = p2[1] - p1[1]
+    length = np.sqrt(dx**2 + dy**2)
+    midpoint_x = (p1[0] + p2[0]) / 2
+    midpoint_y = (p1[1] + p2[1]) / 2
+    angle = np.arctan2(dy, dx) 
+    return length, midpoint_x, midpoint_y, angle
+
+
+def read_kenney_obj(obj_path):
+    """
+    Lee archivos OBJ simples (como los de Kenney) extrayendo solo vértices (v) y caras (f).
+    Retorna (vertices_list, faces_list).
+    """
+    vertices = []
+    faces = []
+    
+    # --- DEBUG: Comprobar lectura de archivo ---
+    print(f"\n--- DEBUG: Leyendo manualmente: {obj_path} ---")
+    v_count = 0
+    f_count = 0
+    
+    try:
+        # Nota: El error podría ser la codificación. Usamos 'utf-8' o 'latin-1'
+        with open(obj_path, 'r', encoding='latin-1') as f: 
+            for line in f:
+                parts = line.strip().split()
+                if not parts:
+                    continue
+                
+                prefix = parts[0]
+                
+                if prefix == 'v':
+                    # Vértices: 'v x y z'
+                    try:
+                        vertices.append([float(parts[1]), float(parts[2]), float(parts[3])])
+                        v_count += 1
+                    except ValueError:
+                        print(f"DEBUG: Vértice inválido en {obj_name}: {line.strip()}")
+                
+                elif prefix == 'f':
+                    # Caras: 'f v/vt/vn v/vt/vn v/vt/vn ...'
+                    try:
+                        face_indices = []
+                        for part in parts[1:]:
+                            v_index = int(part.split('/')[0])
+                            face_indices.append(v_index - 1) 
+                        faces.append(face_indices)
+                        f_count += 1
+                    except ValueError:
+                        print(f"DEBUG: Cara inválida en {obj_name}: {line.strip()}")
+                        
+    except FileNotFoundError:
+        print(f"DEBUG: Archivo no encontrado en la ruta de {obj_path}")
+        return [], []
+    except Exception as e:
+        print(f"DEBUG: Error inesperado de E/S: {e}")
+        return [], []
+
+    # --- DEBUG: Reporte final de la lectura ---
+    print(f"DEBUG RESULTADO: Vértices leídos (v): {v_count}")
+    print(f"DEBUG RESULTADO: Caras leídas (f): {f_count}")
+    print(f"---------------------------------------------")
+        
+    return vertices, faces
+
+
+def load_and_transform_mesh(obj_name, w, l, h, cx, cy, angle, base_z=0, rotation_offset=0):
+    """
+    Carga un modelo .obj usando el parser manual, lo escala de forma NO UNIFORME 
+    para encajar en (w, l, h), y lo rota/traslada a la posición.
+    """
+    obj_path = os.path.join(MODEL_DIR, obj_name)
+    
+    if not os.path.exists(obj_path):
+        print(f"!!! ERROR MODELO 3D: '{obj_name}' no encontrado en {MODEL_DIR}")
+        return None, None, None, None, None, None
+        
+    # --- 1. CARGA USANDO PARSER MANUAL ---
+    vertices, faces_indices_list = read_kenney_obj(obj_path)
+    
+    if not vertices:
+        print(f"!!! ERROR MODELO 3D: Modelo '{obj_name}' sin datos 3D después del parseo.")
+        return None, None, None, None, None, None
+        
+    vertices_np = np.array(vertices, dtype=np.float32).reshape(-1, 3)
+    
+    # --- 2. PREPARAR CARAS PARA PLOTLY ---
+    i_faces, j_faces, k_faces = [], [], []
+    
+    for face in faces_indices_list:
+        if len(face) == 3:
+            i_faces.append(face[0])
+            j_faces.append(face[1])
+            k_faces.append(face[2])
+        elif len(face) == 4:
+            i_faces.extend([face[0], face[0]])
+            j_faces.extend([face[1], face[2]])
+            k_faces.extend([face[2], face[3]])
+            
+    if not i_faces:
+        print(f"!!! ERROR MODELO 3D: Modelo '{obj_name}' sin caras válidas para Plotly.")
+        return None, None, None, None, None, None
+
+    # --- 3. TRANSFORMAR VÉRTICES (ESCALADO NO UNIFORME) ---
+    
+    # 3.0. CORRECCIÓN CRÍTICA DE ORIENTACIÓN (Rotación 90° sobre X)
+    # Rota el modelo de Kenney (que suele tener Y=Arriba, Z=Profundidad) a
+    # la convención de tu sistema (Z=Arriba, Y=Profundidad).
+    
+    # Matriz de rotación 90° sobre eje X (Rotar Y a Z, Z a -Y)
+    R_X = np.array([
+        [1, 0, 0],
+        [0, 0, -1],
+        [0, 1, 0]
+    ])
+    vertices_np = vertices_np @ R_X.T # Aplicamos la rotación BASE
+
+    # 3.1. Encontrar el Bounding Box (para escalado) - ¡Usando los vértices rotados!
+    min_x, max_x = vertices_np[:, 0].min(), vertices_np[:, 0].max()
+    min_y, max_y = vertices_np[:, 1].min(), vertices_np[:, 1].max()
+    min_z, max_z = vertices_np[:, 2].min(), vertices_np[:, 2].max()
+    
+    bbox_w = max_x - min_x
+    bbox_l = max_y - min_y
+    bbox_h = max_z - min_z
+    
+    # 3.2. Calcular Factor de Escala NO UNIFORME
+    # Evitar división por cero
+    scale_x = w / bbox_w if bbox_w > 0 else 1.0
+    scale_y = l / bbox_l if bbox_l > 0 else 1.0
+    scale_z = h / bbox_h if bbox_h > 0 else 1.0
+
+    # 3.3. Trasladar al origen (centrar en XY y base en Z=0)
+    center_x_base = (min_x + max_x) / 2
+    center_y_base = (min_y + max_y) / 2
+    
+    # Trasladar el centro y mover la base al plano Z=0
+    transformed_v = vertices_np - np.array([center_x_base, center_y_base, min_z]) 
+
+    # 3.4. Aplicar Escala No Uniforme
+    transformed_v[:, 0] *= scale_x
+    transformed_v[:, 1] *= scale_y
+    transformed_v[:, 2] *= scale_z
+    
+    # --- 4. APLICAR ROTACIÓN Y TRASLACIÓN FINAL ---
+    
+    # Aplicar Rotación del Layout (en el eje Z) + Offset
+    final_angle = angle + rotation_offset
+    c_cos = np.cos(final_angle)
+    c_sin = np.sin(final_angle)
+    rot_matrix = np.array([[c_cos, -c_sin], [c_sin, c_cos]])
+    transformed_v[:, :2] = transformed_v[:, :2] @ rot_matrix.T
+
+    # Aplicar Traslación Final
+    transformed_v[:, 0] += cx
+    transformed_v[:, 1] += cy
+    transformed_v[:, 2] += base_z
+
+    x_coords, y_coords, z_coords = transformed_v[:, 0], transformed_v[:, 1], transformed_v[:, 2]
+    
+    return x_coords, y_coords, z_coords, i_faces, j_faces, k_faces
+
+def dibujar_layout_sobre_imagen(img_path, room_data):
+    """
+    Dibuja las predicciones de HorizonNet (líneas de floor/ceiling y corners)
+    sobre la imagen panorámica para visualización de la detección.
+    """
+    try:
+        # Cargar imagen y redimensionar a 1024x512
+        img = Image.open(img_path).convert("RGB")
+        img = img.resize((1024, 512), Image.LANCZOS)
+        img_array = np.array(img)
+        
+        # Verificar que tenemos los datos raw del modelo
+        if 'y_bon' not in room_data or 'y_cor' not in room_data:
+            draw = ImageDraw.Draw(img)
+            draw.text((10, 10), "Sin datos de visualización raw", fill=(255, 0, 0))
+            return img
+        
+        y_bon = room_data['y_bon']  # [2, 1024] en radianes
+        y_cor = room_data['y_cor']  # [1024] probabilidades [0,1]
+        
+        # Convertir boundary de radianes a píxeles 
+        y_bon_pix = ((y_bon / np.pi + 0.5) * 512).round().astype(int)
+        y_bon_pix[0] = np.clip(y_bon_pix[0], 0, 511)  # ceiling
+        y_bon_pix[1] = np.clip(y_bon_pix[1], 0, 511)  # floor
+        
+        # Crear visualización
+        img_vis = (img_array * 0.5).astype(np.uint8)  # Oscurecer imagen un poco
+        
+        # Dibujar las líneas de ceiling y floor (verde)
+        for x in range(1024):
+            img_vis[y_bon_pix[0][x], x] = [0, 255, 0]  # Verde para ceiling
+            img_vis[y_bon_pix[1][x], x] = [0, 255, 0]  # Verde para floor
+            
+        # Dibujar probabilidades de corner como barra en la parte superior
+        cor_height = 30  
+        gt_cor = np.zeros((cor_height, 1024, 3), np.uint8)
+        gt_cor[:] = (y_cor[None, :, None] * 255).astype(np.uint8)  # Escala de grises
+        
+        separator = np.ones((3, 1024, 3), np.uint8) * 255
+        
+        # Concatenar: corner heatmap + separador + imagen con boundaries
+        final_vis = np.concatenate([gt_cor, separator, img_vis], axis=0)
+        
+        return Image.fromarray(final_vis)
+        
+    except Exception as e:
+        print(f"Error al dibujar layout: {e}")
+        import traceback
+        traceback.print_exc()
+        # En caso de error, devuelve la imagen original
+        return Image.open(img_path).convert("RGB")
+
+
+def generar_figura_3d_plotly(layout_plan, room_data, items_recomendados, altura_pared=250):
+    """
+    Genera visualización 3D interactiva, usando modelos .OBJ para estructura y muebles.
+    Si un OBJ no carga, el elemento es OMITIDO.
+    """
+    if not layout_plan:
+        return go.Figure()
+
+    # --- Mapeo y Constantes ---
+    WALL_COLOR = '#bdbdbd' 
+    CORNER_COLOR = '#6d6d6d' 
+    DOOR_COLOR = '#8d6e63' 
+    WINDOW_COLOR = '#d4e6f1' 
+    WALL_H = altura_pared 
+    WALL_DEPTH_CM = 10 # Profundidad de la pared a renderizar en 3D
+
+    MODEL_MAP = {
+        'Sofás': 'loungeSofa.obj',
+        'Sillones': 'loungeChair.obj', 
+        'Mesas bajas de salón, de centro y auxiliares': 'tableCoffee.obj',
+        'Muebles de salón': 'cabinetTelevision.obj',
+        'Estanterías y librerías': 'bookcaseOpen.obj' 
+    }
+    
+    OBSTACLE_MAP = {
+        # w y l representan las dimensiones del OBJ
+        'door': {'obj': 'wallDoorway.obj', 'color': DOOR_COLOR, 'height': 200, 'v_offset': 0, 'w': WALL_DEPTH_CM, 'l': 0}, 
+        'window': {'obj': 'wallWindow.obj', 'color': WINDOW_COLOR, 'height': 120, 'v_offset': 100, 'w': WALL_DEPTH_CM, 'l': 0}
+    }
+
+    pool_items = {}
+    if items_recomendados:
+        for it in items_recomendados: 
+            pool_items.setdefault(it['Tipo_mueble'], []).append(it)
+
+    colores = {
+        'Sofás': '#7f8c8d', 'Muebles de salón': '#95a5a6', 
+        'Mesas bajas de salón, de centro y auxiliares': '#d6bfa9', 
+        'Sillones': '#5d6d7e', 'Estanterías y librerías': '#ecf0f1' 
+    }
+    
+    polygon_points = room_data.get('polygon_points', [])
+    poly_pts_cm = np.array(polygon_points) * 100 
+    data = []
+
+    # --- FASE 1: DIBUJAR ESTRUCTURA DE LA HABITACIÓN (PAREDES Y OBSTÁCULOS) ---
+    if len(poly_pts_cm) > 1:
+        num_walls = len(poly_pts_cm)
+        all_obstacles = room_data.get('doors', []) + room_data.get('windows', [])
+
+        for i in range(num_walls):
+            p1 = poly_pts_cm[i]
+            p2 = poly_pts_cm[(i+1) % num_walls]
+            
+            length, cx_seg, cy_seg, angle = get_segment_properties(p1, p2)
+            
+            # Identificar obstáculos en esta pared (índice i) y ordenarlos
+            wall_obstacles = []
+            for obs in all_obstacles:
+                # Nota: obs['center'][1] es el índice normalizado de pared (0 a 1)
+                wall_idx_obs = int(round(obs['center'][1] * num_walls)) % num_walls 
+                if wall_idx_obs == i:
+                    obs['type'] = 'door' if 'doors' in room_data and obs in room_data['doors'] else 'window'
+                    wall_obstacles.append(obs)
+            wall_obstacles.sort(key=lambda x: x['center'][0]) # Ordenar por posición a lo largo de la pared
+
+            # Definir segmentos de pared a dibujar
+            segments_to_draw = []
+            current_start_pct = 0.0 
+            
+            for obs in wall_obstacles:
+                center_pct = obs['center'][0]
+                width_m = obs['width']
+                width_pct = (width_m * 100) / length 
+                
+                obs_start_pct = max(0.0, center_pct - width_pct / 2)
+                obs_end_pct = min(1.0, center_pct + width_pct / 2)
+                
+                # Segmento de pared antes del obstáculo (pared vacía)
+                if obs_start_pct > current_start_pct:
+                    segments_to_draw.append({'type': 'wall', 'start': current_start_pct, 'end': obs_start_pct})
+                
+                # Segmento de obstáculo
+                segments_to_draw.append({'type': obs['type'], 'start': obs_start_pct, 'end': obs_end_pct, 'w': width_m * 100})
+                
+                current_start_pct = obs_end_pct
+                
+            # Segmento de pared final (pared vacía)
+            if current_start_pct < 1.0:
+                segments_to_draw.append({'type': 'wall', 'start': current_start_pct, 'end': 1.0})
+            
+            # --- DIBUJAR LOS SEGMENTOS CON OBJS ---
+            
+            for seg in segments_to_draw:
+                seg_start_cm = seg['start'] * length
+                seg_end_cm = seg['end'] * length
+                seg_len = seg_end_cm - seg_start_cm
+                
+                if seg_len < 1: continue 
+
+                # Recalcular centro y ángulo para el subsegmento
+                seg_mid_x = p1[0] + (seg['start'] + seg['end']) / 2 * (p2[0] - p1[0])
+                seg_mid_y = p1[1] + (seg['start'] + seg['end']) / 2 * (p2[1] - p1[1])
+
+                # Configuración del modelo
+                if seg['type'] == 'wall':
+                    obj_file = 'wall.obj'
+                    color = WALL_COLOR
+                    h_val = WALL_H
+                    z_base = 0
+                    w_seg = seg_len # El largo del segmento es el ANCHO (X) del OBJ
+                    l_seg = WALL_DEPTH_CM # La profundidad de la pared es el LARGO (Y) del OBJ
+                else: 
+                    obs_data = OBSTACLE_MAP[seg['type']]
+                    obj_file = obs_data['obj']
+                    color = obs_data['color']
+                    h_val = obs_data['height']
+                    z_base = obs_data['v_offset']
+                    w_seg = seg_len
+                    l_seg = WALL_DEPTH_CM 
+                
+                # Cargar y transformar el OBJ
+                
+                # Lista de elementos a dibujar en este segmento (puede ser múltiple para ventanas/puertas)
+                sub_elements = []
+                
+                if seg['type'] == 'wall':
+                    sub_elements.append({
+                        'obj': 'wall.obj', 'color': WALL_COLOR, 
+                        'h': WALL_H, 'z': 0, 
+                        'w': seg_len, 'l': WALL_DEPTH_CM,
+                        'name': 'Pared'
+                    })
+                else: 
+                    obs_data = OBSTACLE_MAP[seg['type']]
+                    
+                    # 1. El Obstáculo en sí
+                    sub_elements.append({
+                        'obj': obs_data['obj'], 'color': obs_data['color'],
+                        'h': obs_data['height'], 'z': obs_data['v_offset'],
+                        'w': seg_len, 'l': WALL_DEPTH_CM,
+                        'name': seg['type'].title()
+                    })
+                    
+                    # 2. Relleno SUPERIOR (Dintel) - Si hay espacio hasta el techo
+                    top_gap = WALL_H - (obs_data['v_offset'] + obs_data['height'])
+                    if top_gap > 1:
+                        sub_elements.append({
+                            'obj': 'wall.obj', 'color': WALL_COLOR,
+                            'h': top_gap, 'z': obs_data['v_offset'] + obs_data['height'],
+                            'w': seg_len, 'l': WALL_DEPTH_CM,
+                            'name': 'Muro Superior'
+                        })
+                        
+                    # 3. Relleno INFERIOR (Antepecho) - Si el obstáculo no empieza en el suelo
+                    bottom_gap = obs_data['v_offset']
+                    if bottom_gap > 1:
+                        sub_elements.append({
+                            'obj': 'wall.obj', 'color': WALL_COLOR,
+                            'h': bottom_gap, 'z': 0,
+                            'w': seg_len, 'l': WALL_DEPTH_CM,
+                            'name': 'Muro Inferior'
+                        })
+
+                # Renderizar todos los sub-elementos del segmento
+                for el in sub_elements:
+                    x_seg, y_seg, z_seg, i_seg, j_seg, k_seg = load_and_transform_mesh(
+                        el['obj'], w=el['w'], l=el['l'], h=el['h'], 
+                        cx=seg_mid_x, cy=seg_mid_y, angle=angle, base_z=el['z']
+                    )
+                    
+                    if x_seg is not None:
+                        data.append(go.Mesh3d(
+                            x=x_seg, y=y_seg, z=z_seg, i=i_seg, j=j_seg, k=k_seg,
+                            color=el['color'], opacity=1.0, flatshading=True,
+                            name=f'{el["name"]} P{i}', showlegend=(seg['type']!='wall' and el['name'] == seg['type'].title())
+                        ))
+                    else:
+                        print(f"!!! FALLO DE CARGA: Omisión de {el['name']} en pared {i}.")
+            
+            # 5. ESQUINA (wallCorner.obj) - Se dibuja en el vértice P1
+            if i == 0 or True: # Dibujar esquina en cada vértice para cerrar bien
+                # Nota: Dibujamos esquina en P1 (inicio del segmento)
+                x_c, y_c, z_c, i_c, j_c, k_c = load_and_transform_mesh(
+                    'wallCorner.obj', w=WALL_DEPTH_CM, l=WALL_DEPTH_CM, h=WALL_H, 
+                    cx=p1[0], cy=p1[1], angle=angle
+                )
+                
+                if x_c is not None:
+                    data.append(go.Mesh3d(
+                        x=x_c, y=y_c, z=z_c, i=i_c, j=i_c, k=i_c, 
+                        color=CORNER_COLOR, opacity=1.0, flatshading=True,
+                        name=f'Esquina {i}', showlegend=False
+                    ))
+
+
+    # --- FASE 2: DIBUJAR SUELO ---
+    # Usar un fill poly simple. Convertir a (X, Y, Z) para Plotly
+    x_floor = poly_pts_cm[:, 0]
+    y_floor = poly_pts_cm[:, 1]
+    z_floor = np.zeros_like(x_floor)
+
+    # Crear caras del suelo (convexhull)
+    from scipy.spatial import ConvexHull
+    try:
+        hull = ConvexHull(np.array([x_floor, y_floor]).T)
+        i_f, j_f, k_f = hull.simplices.T
+    except: # Fails if points are collinear or too few
+        i_f, j_f, k_f = [], [], []
+
+    suelo_trace = go.Mesh3d(
+        x=x_floor, y=y_floor, z=z_floor,
+        i=i_f, j=j_f, k=k_f,
+        color='#fafafa', opacity=1, name='Suelo', hoverinfo='skip'
+    )
+    data.append(suelo_trace)
+
+    # --- FASE 3: DIBUJAR MUEBLES (OBJ o OMISIÓN) ---
+    for mueble in layout_plan:
+        tipo = mueble['tipo']
+        obj_file = MODEL_MAP.get(tipo)
+        # Buscar la info real del mueble seleccionado
+        info_real = pool_items.get(tipo, [{}])[0] if tipo in pool_items else {}
+            
+        nombre_display = info_real.get('Nombre', tipo)
+        precio = info_real.get('Precio', '?')
+        desc = info_real.get('Descripcion', '')[:60]
+        
+        hover_text = (
+            f"<b>TIPO:</b> {tipo}<br>"
+            f"<b>MODELO:</b> {nombre_display}<br>"
+            f"<b>PRECIO:</b> {precio}€<br>"
+            f"<i>{desc}...</i>"
+        )
+        
+        try:
+            h_val = float(info_real.get('Altura', 60))
+            if np.isnan(h_val) or h_val <= 0: h_val = 60
+        except: h_val = 60
+
+        w_m = mueble['ancho']
+        l_m = mueble['largo']
+        
+        # Rotación extra para sofás (suelen venir mirando hacia atrás)
+        rot_offset = np.pi if tipo == 'Sofás' else 0
+        
+        # Lógica específica para detectar Sofás en L (Chaise Longue / Rinconera)
+        if tipo == 'Sofás':
+            keywords_l_shape = ['chaise', 'esquina', 'rincon', 'l-shaped', 'modular', 'l shape']
+            text_to_search = (nombre_display + " " + desc).lower()
+            if any(k in text_to_search for k in keywords_l_shape):
+                obj_file = 'loungeDesignSofaCorner.obj'
+                # Ajuste de rotación específico para este modelo si es necesario (a veces los modelos de esquina tienen otra orientación)
+                # Por ahora mantenemos la rotación de sofá estándar (pi) o ajustamos si el usuario reporta algo raro.
+                # rot_offset = np.pi
+
+        if obj_file:
+            x_m, y_m, z_m, i_m, j_m, k_m = load_and_transform_mesh(
+                obj_file, w=w_m, l=l_m, h=h_val,
+                cx=mueble['x'], cy=mueble['y'], angle=mueble['angle'],
+                rotation_offset=rot_offset
+            )
+
+            if x_m is not None:
+                traces = [go.Mesh3d(
+                    x=x_m, y=y_m, z=z_m, i=i_m, j=j_m, k=k_m,
+                    color=colores.get(tipo, '#95a5a6'), opacity=1.0, flatshading=True,
+                    name=nombre_display, hoverinfo='text', text=hover_text,
+                    lighting=dict(ambient=0.6, diffuse=0.8), showlegend=True
+                )]
+                data.extend(traces)
+            else:
+                # Fallo de carga: OMITIR
+                print(f"!!! FALLO DE CARGA/RENDERIZADO: {tipo} ({nombre_display}). Modelo OBJ no usado.")
+                continue 
+        else:
+            # Omisión si no hay OBJ mapeado
+            print(f"!!! OMISIÓN: No hay OBJ mapeado para el tipo: {tipo}. Saltando renderizado.")
+            continue
+
+    # --- CONFIGURACIÓN FINAL ---
+    max_dim = np.max(poly_pts_cm, axis=0) if poly_pts_cm.size > 0 else [500, 500]
+
+    layout = go.Layout(
+        title="Diseño 3D (Interactúa con el ratón)",
+        showlegend=True,
+        scene=dict(
+            xaxis=dict(visible=False), yaxis=dict(visible=False), zaxis=dict(visible=False),
+            aspectmode='data', # Usar 'data' para que los ejes sean proporcionales a los valores reales
+            aspectratio=None, 
+            bgcolor='white',
+            camera=dict(eye=dict(x=2.0, y=2.0, z=2.0)) # Zoom out inicial
+        ),
+        margin=dict(r=0, l=0, b=0, t=30),
+        height=600 
+    )
+    
+    return go.Figure(data=data, layout=layout)
+
+
+def generar_diagrama_planta(room_data):
+    """Genera un diagrama de planta 2D de la habitación con paredes, puertas y ventanas."""
+    try:
+        # --- 1. CONFIGURACIÓN DE ESTILO ---
+        COLORS = {
+            'bg': '#1C4E80', # Azul oscuro de fondo
+            'line': '#ffffff', # Blanco para líneas
+            'hole': '#1C4E80', # Mismo color que el fondo para "borrar" la pared
+            'grid': '#ffffff',
+            'text': '#ffffff'
+        }
+
+        WALL_WIDTH = 6
+        HOLE_WIDTH = 8
+        ELEM_WIDTH = 1.5
+
+        fig, ax = plt.subplots(figsize=(12, 8))
+        fig.patch.set_facecolor(COLORS['bg'])
+        ax.set_facecolor(COLORS['bg'])
+        
+        polygon_points = room_data.get('polygon_points', None)
+        if polygon_points is None or len(polygon_points) < 3:
+            ax.text(0.5, 0.5, "ERROR: Polígono de habitación inválido", color=COLORS['text'], ha='center')
+            return fig
+        
+        polygon_m = np.array(polygon_points)
+        centroid = np.mean(polygon_m, axis=0) 
+        
+        # A. Forzar proporción real (1 metro visual = 1 metro dato)
+        ax.set_aspect('equal', adjustable='box') 
+        
+        # B. Calcular límites enteros para asegurar que el grid cae en el metro exacto
+        min_x, min_y = np.min(polygon_m, axis=0)
+        max_x, max_y = np.max(polygon_m, axis=0)
+        
+        # Márgenes de 1 metro extra alrededor
+        start_x = np.floor(min_x - 1)
+        end_x = np.ceil(max_x + 1)
+        start_y = np.floor(min_y - 1)
+        end_y = np.ceil(max_y + 1)
+        
+        ax.set_xlim(start_x, end_x)
+        ax.set_ylim(start_y, end_y)
+        
+        # C. Definir ticks explícitamente cada 1.0 unidades (1 metro)
+        xticks = np.arange(start_x, end_x + 1, 1.0)
+        yticks = np.arange(start_y, end_y + 1, 1.0)
+        
+        ax.set_xticks(xticks)
+        ax.set_yticks(yticks)
+        
+        # Grid muy sutil
+        ax.grid(True, color=COLORS['grid'], linestyle=':', linewidth=0.5, alpha=0.2)
+        ax.set_xticklabels([]); ax.set_yticklabels([])
+        ax.tick_params(length=0)
+        
+        # --- Helper: Datos de Muro (Necesario aquí para Doors/Windows) ---
+        num_walls = len(polygon_m)
+        def get_wall_data(idx, pct):
+            idx = idx % num_walls
+            p1, p2 = polygon_m[idx], polygon_m[(idx + 1) % num_walls]
+            vec = p2 - p1
+            L_wall = np.linalg.norm(vec)
+            if L_wall == 0: return None
+            unit = vec / L_wall
+            center_on_wall = p1 + vec * (pct / 100.0)
+            
+            # Vector normal hacia adentro
+            n1 = np.array([-unit[1], unit[0]])
+            # Comprobar si n1 apunta hacia el centroide
+            if np.linalg.norm((center_on_wall + n1) - centroid) > np.linalg.norm((center_on_wall - n1) - centroid):
+                normal_in = -n1
+            else:
+                normal_in = n1
+            return center_on_wall, unit, normal_in
+
+        # --- 3. DIBUJAR PAREDES ---
+        polygon_closed = np.vstack([polygon_m, polygon_m[0]])
+        
+        # Relleno muy sutil del suelo
+        ax.fill(polygon_closed[:, 0], polygon_closed[:, 1], color=COLORS['line'], alpha=0.05, zorder=1)
+        
+        # EL MURO GRUESO
+        ax.plot(polygon_closed[:, 0], polygon_closed[:, 1], 
+               color=COLORS['line'], linewidth=WALL_WIDTH, zorder=2, solid_capstyle='round')
+
+
+        # --- 4. PUERTAS (Hueco + Hoja + Arco) ---
+        for d in room_data.get('doors', []):
+            # Obtener índice de pared y posición porcentual a lo largo de esa pared
+            wall_idx = int(round(d['center'][1] * num_walls)) % num_walls
+            pos_pct = d['center'][0] * 100 # a cm
+            
+            info = get_wall_data(wall_idx, pos_pct)
+            if not info: continue
+            center, unit, normal_in = info
+            w = d['width'] # ancho de la puerta en metros
+            
+            # A. HUECO (Borrar muro)
+            h_s = center - unit * (w/2)
+            h_e = center + unit * (w/2)
+            ax.plot([h_s[0], h_e[0]], [h_s[1], h_e[1]], 
+                   color=COLORS['hole'], linewidth=HOLE_WIDTH, zorder=5) 
+            
+            # B. HOJA
+            hinge = h_s
+            tip = hinge + normal_in * w
+            ax.plot([hinge[0], tip[0]], [hinge[1], tip[1]], 
+                   color=COLORS['line'], linewidth=ELEM_WIDTH, zorder=6)
+            
+            # C. ARCO (Interpolado)
+            arc_pts = []
+            start_angle = np.arctan2(unit[1], unit[0])
+            
+            # Crear la rotación desde el vector 'unit' al vector 'normal_in'
+            for t in np.linspace(0, 1, 15):
+                angle_interp = t * (np.pi/2)
+                # Aplicar rotación al vector 'unit'
+                v_rot = unit * np.cos(angle_interp) + normal_in * np.sin(angle_interp)
+                pt = hinge + v_rot * w
+                arc_pts.append(pt)
+            arc_pts = np.array(arc_pts)
+            ax.plot(arc_pts[:, 0], arc_pts[:, 1], 
+                   color=COLORS['line'], linestyle=':', linewidth=1, zorder=6)
+
+        # --- 5. VENTANAS (Hueco + Rectángulo vacío) ---
+        for w_obj in room_data.get('windows', []):
+            wall_idx = int(round(w_obj['center'][1] * num_walls)) % num_walls
+            pos_pct = w_obj['center'][0] * 100
+            
+            info = get_wall_data(wall_idx, pos_pct)
+            if not info: continue
+            center, unit, normal_in = info
+            w = w_obj['width'] # ancho de la ventana en metros
+            
+            # A. HUECO (Borrar muro grueso)
+            h_s = center - unit * (w/2); h_e = center + unit * (w/2)
+            ax.plot([h_s[0], h_e[0]], [h_s[1], h_e[1]], 
+                   color=COLORS['hole'], linewidth=HOLE_WIDTH, zorder=5)
+            
+            # B. MARCO RECTANGULAR (Sin relleno)
+            frame_depth = 0.1 # 10 cm de profundidad de marco (en metros)
+        
+            # 4 Esquinas del rectángulo
+            c1 = h_s - normal_in * (frame_depth/2)
+            c2 = h_e - normal_in * (frame_depth/2)
+            c3 = h_e + normal_in * (frame_depth/2)
+            c4 = h_s + normal_in * (frame_depth/2)
+            
+            # Dibujar perímetro (c1->c2->c3->c4->c1)
+            rect_x = [c1[0], c2[0], c3[0], c4[0], c1[0]]
+            rect_y = [c1[1], c2[1], c3[1], c4[1], c1[1]]
+            
+            ax.plot(rect_x, rect_y, color=COLORS['line'], linewidth=ELEM_WIDTH, zorder=6)
+
+        # --- 6. ETIQUETAS Y LEYENDA ---
+        legend_items = []
+        for i in range(num_walls):
+            p1, p2 = polygon_m[i], polygon_m[(i + 1) % num_walls]
+            mid = (p1 + p2) / 2
+            
+            # Vector hacia afuera para etiqueta
+            vec_out = mid - centroid
+            vec_out = vec_out / np.linalg.norm(vec_out)
+            text_pos = mid + vec_out * 0.5 # 50cm afuera para no tocar el muro grueso
+            
+            L = np.linalg.norm(p2 - p1)
+            legend_items.append(f"P{i+1}: {L:.2f} m")
+            
+            ax.text(text_pos[0], text_pos[1], f"P{i+1}", color=COLORS['bg'], fontsize=8, fontweight='bold',
+                   ha='center', va='center', zorder=10,
+                   bbox=dict(boxstyle='circle,pad=0.2', fc='white', ec='none'))
+            
+        plt.subplots_adjust(right=0.70)
+        
+        info_text = "HABITACIÓN\n(Grid 1x1m)\n\n" + "\n".join(legend_items)
+        
+        fig.text(0.72, 0.5, info_text, fontsize=10, color=COLORS['text'], 
+                fontfamily='monospace', va='center',
+                bbox=dict(boxstyle='square,pad=1', fc=COLORS['hole'], ec=COLORS['line']))
+
+        return fig
+
+    except Exception as e:
+        print(f"Error planta: {e}")
+        import traceback
+        traceback.print_exc()
+        return plt.figure()

packages.txt

@@ -0,0 +1 @@
+libgl1

requirements.txt

@@ -1,3 +1,15 @@
-altair
+streamlit
 pandas
-streamlit
+numpy
+Pillow
+torch
+torchvision
+transformers
+scikit-learn
+matplotlib
+shapely
+tqdm
+plotly
+pywavefront
+scipy
+opencv-python-headless

vectores_cache.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:ead8295d791f946f9ddb61bcfdcbe1b1a447c1307dfffd1eefb1d80dda0f20b0
+size 1090945