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"TIPO: {tipo}
"
f"MODELO: {nombre_display}
"
f"PRECIO: {precio}€
"
f"{desc}..."
)
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()