IdentificacionIA/fision1.py

import os
import cv2
import numpy as np
import time
import threading
from queue import Queue
from ultralytics import YOLO
import warnings
import json
import math

os.environ['TF_CPP_MIN_LOG_LEVEL'] = '3'
os.environ['CUDA_VISIBLE_DEVICES'] = '-1'
os.environ["OPENCV_FFMPEG_CAPTURE_OPTIONS"] = "rtsp_transport;tcp|flags;low_delay"
os.environ['QT_LOGGING_RULES'] = '*=false'
os.environ['OPENCV_LOG_LEVEL'] = 'ERROR'
warnings.filterwarnings("ignore")

# 1. IMPORTAMOS LIBRERÍAS DE SMARTSOFT
import seguimiento2
from seguimiento2 import GlobalMemory, CamManager, FUENTE, es_humano_valido
from reconocimiento import app, gestionar_vectores, buscar_mejor_match, hilo_bienvenida

# 2. VARIABLES GLOBALES DE COMUNICACIÓN CON LA INTERFAZ
COLA_ROSTROS = Queue(maxsize=4) 
IA_LOCK = threading.Lock() 

MOTOR_ACTIVO = False
PAGINA_ACTUAL = 0
CAMS_POR_PANTALLA = 4
CAMARA_MAXIMIZADA = None
TELEMETRIA = {'fps': 0.0, 'ids_activos': 0}
FRAME_MOSAICO = None
NUEVAS_ALERTAS = []

def obtener_ultimo_frame():
    global FRAME_MOSAICO
    return FRAME_MOSAICO

print("\nIniciando carga de base de datos biométrica...")
BASE_DATOS_ROSTROS = gestionar_vectores(actualizar=True)

def crear_mosaico(tiles):
    if not tiles: return np.zeros((270, 480, 3), dtype=np.uint8)
    n = len(tiles)
    if n == 1: return tiles[0]
    
    cols = math.ceil(math.sqrt(n))
    rows = math.ceil(n / cols)

    h, w, c = tiles[0].shape
    mosaico = np.zeros((rows * h, cols * w, c), dtype=np.uint8)

    for i, tile in enumerate(tiles):
        r = i // cols
        c_idx = i % cols
        mosaico[r*h:(r+1)*h, c_idx*w:(c_idx+1)*w] = tile
        
    return mosaico

def procesar_rostro_async(roi_cabeza, gid, cam_id, global_mem, trk):
    try:
        if roi_cabeza is None or roi_cabeza.size == 0: return
        with IA_LOCK: faces = app.get(roi_cabeza)
        if len(faces) == 0: return

        face = max(faces, key=lambda f: (f.bbox[2] - f.bbox[0]) * (f.bbox[3] - f.bbox[1]))
        box = face.bbox.astype(int)
        w_f, h_f = box[2] - box[0], box[3] - box[1]

        if w_f < 20 or h_f < 20: return 

        emb = np.array(face.normed_embedding, dtype=np.float32)
        genero_detectado = "Man" if face.sex == "M" else "Woman"

        h_roi, w_roi = roi_cabeza.shape[:2]
        m_x, m_y_top, m_y_bot = int(w_f * 0.50), int(h_f * 0.50), int(h_f * 0.70)
        y1, y2 = max(0, box[1] - m_y_top), min(h_roi, box[3] + m_y_bot)
        x1, x2 = max(0, box[0] - m_x), min(w_roi, box[2] + m_x)
        rostro_puro = roi_cabeza[y1:y2, x1:x2]

        area_rostro = w_f * h_f
        es_mejor_rostro_camara = False
        llave_camara = f"{gid}_cam{cam_id}"
        
        with global_mem.lock:
            if not hasattr(global_mem, 'mejores_rostros'): global_mem.mejores_rostros = {}
            mejor_area_actual = global_mem.mejores_rostros.get(llave_camara, {}).get('area', 0)
            if area_rostro > mejor_area_actual:
                global_mem.mejores_rostros[llave_camara] = {'area': area_rostro, 'ts': time.time()}
                es_mejor_rostro_camara = True

        ruta_dir = os.path.join("cache_nombres", "auditoria_caras")
        os.makedirs(ruta_dir, exist_ok=True)
        fecha_hoy = time.strftime('%Y-%m-%d')

        if BASE_DATOS_ROSTROS: mejor_match, max_sim = buscar_mejor_match(emb, BASE_DATOS_ROSTROS)
        else: mejor_match, max_sim = None, 0.0

        with global_mem.lock:
            datos_id = global_mem.db.get(gid)
            if not datos_id: return
            nombre_actual = datos_id.get('nombre')

            # ─────────────────────────────────────────────────────────────
            # ⚡ SISTEMA DE VOTACIÓN DUAL (Estricto para nuevos, Tolerante para VIPs)
            # ─────────────────────────────────────────────────────────────
            puntos_voto = 0
            es_vip_confirmado = (nombre_actual and nombre_actual != "Desconocido")

            if es_vip_confirmado:
                # Si OSNet ya lo rastrea, somos muy tolerantes con los ángulos
                if max_sim >= 0.40: puntos_voto = 3
                elif max_sim >= 0.25: puntos_voto = 2
                elif max_sim >= 0.18: puntos_voto = 1
            else:
                # Si es un Desconocido, exigimos muchísima claridad para bautizarlo
                if max_sim >= 0.50: puntos_voto = 3
                elif max_sim >= 0.42: puntos_voto = 2
                elif max_sim >= 0.38: puntos_voto = 1
                # Si saca 0.31 (como tu falso Jesus Eduardo), saca 0 puntos y se va a Alertas ROJAS.

            # 🧠 SISTEMA DE AUTO-APRENDIZAJE (Doble Llave)
            if es_vip_confirmado and mejor_match:
                nombre_limpio = mejor_match.split('_')[0]
                if nombre_actual == nombre_limpio and 0.18 <= max_sim < 0.45:
                    ahora = time.time()
                    if (ahora - datos_id.get('ultimo_aprendizaje', 0)) > 10.0 and rostro_puro.size > 0:
                        ruta_ap = "db_aprendida"
                        os.makedirs(ruta_ap, exist_ok=True)
                        nombre_archivo = f"{nombre_limpio}_auto_{int(ahora)}.jpg"
                        cv2.imwrite(os.path.join(ruta_ap, nombre_archivo), rostro_puro)
                        BASE_DATOS_ROSTROS[nombre_archivo] = emb
                        datos_id['ultimo_aprendizaje'] = ahora
                        print(f" 🧠 [APRENDIZAJE] Cam {cam_id}: Nuevo ángulo de {nombre_limpio} aprendido! (Sim: {max_sim:.2f})")
                        puntos_voto = 3 

            # --- CASO A: LA IA DUDA ---
            if puntos_voto == 0 or not mejor_match:
                if nombre_actual and nombre_actual != "Desconocido":
                    datos_id['votos_nombre'] = datos_id.get('votos_nombre', 0) - 1
                    if datos_id['votos_nombre'] <= 0:
                        datos_id['nombre'] = "Desconocido"
                        datos_id['votos_nombre'] = 0
                        print(f" [CORRECCIÓN] IA duda del ID {gid}. Pierde el nombre '{nombre_actual}'.")
                else:
                    datos_id['nombre'] = "Desconocido"
                    if es_mejor_rostro_camara and rostro_puro.size > 0:
                        cv2.imwrite(os.path.join(ruta_dir, f"{gid}_cam{cam_id}_{fecha_hoy}.jpg"), rostro_puro)
                        import fision1
                        fision1.NUEVAS_ALERTAS.append((gid, cam_id, rostro_puro))
                return

            nombre_limpio = mejor_match.split('_')[0]

            # --- CASO B: CONFLICTO (Evita que alguien más robe tu nombre) ---
            if nombre_actual and nombre_actual != "Desconocido" and nombre_actual != nombre_limpio:
                datos_id['votos_nombre'] = datos_id.get('votos_nombre', 0) - puntos_voto
                if datos_id['votos_nombre'] <= 0:
                    datos_id['nombre'] = "Desconocido"
                    datos_id['votos_nombre'] = 0
                    print(f" [CORRECCIÓN] Conflicto facial en ID {gid}. Revertido a Desconocido.")
                return

            # --- CASO C: CONFIRMACIÓN Y BAUTIZO ---
            if es_mejor_rostro_camara and rostro_puro.size > 0:
                cv2.imwrite(os.path.join(ruta_dir, f"{nombre_limpio}_cam{cam_id}_{fecha_hoy}.jpg"), rostro_puro)

            if nombre_actual == nombre_limpio:
                datos_id['votos_nombre'] = min(5, datos_id.get('votos_nombre', 0) + puntos_voto)
                return

            votos = datos_id.get('votos_nombre', 0) + puntos_voto
            datos_id['votos_nombre'] = votos
            
            if votos >= 3:
                id_veterano = None
                for gid_mem, data_mem in global_mem.db.items():
                    if data_mem.get('nombre') == nombre_limpio and gid_mem != gid:
                        id_veterano = gid_mem
                        break

                if id_veterano is not None:
                    print(f" [FUSIÓN] ArcFace une clon {gid} al original {nombre_limpio} (ID {id_veterano}).")
                    datos_id['fusionado_con'] = id_veterano
                    trk.gid = id_veterano
                    global_mem.db[id_veterano]['ts'] = time.time()
                else:
                    datos_id['nombre'] = nombre_limpio
                    print(f" [BAUTIZO VIP] Cam {cam_id}: ID {gid} es {nombre_limpio} ({max_sim*100:.1f}%)")
                    
                    threading.Thread(
                        target=global_mem.registrar_movimiento, 
                        args=(nombre_limpio, cam_id, cam_id, 0.0, gid), 
                        daemon=True
                    ).start()
                    
                    if str(cam_id) == "7":
                        ahora = time.time()
                        info_saludo = global_mem.ultimos_saludos.get(nombre_limpio, {})
                        if (ahora - info_saludo.get('timestamp', 0)) > 30:
                            global_mem.guardar_saludo(nombre_limpio)
                            threading.Thread(target=hilo_bienvenida, args=(nombre_limpio, genero_detectado), daemon=True).start()

    except Exception as e: 
        print(f" [ERROR ARCFACE] ID {gid}: {str(e)}")
    finally: 
        trk.procesando_rostro = False

def worker_rostros(global_mem):
    while True:
        roi_cabeza, gid, cam_id, trk = COLA_ROSTROS.get()
        procesar_rostro_async(roi_cabeza, gid, cam_id, global_mem, trk)
        COLA_ROSTROS.task_done()

class CamStream:
    def __init__(self, url, cam_id):
        self.url = url
        self.cam_id = str(cam_id)
        self.cap = cv2.VideoCapture(url)
        self.cap.set(cv2.CAP_PROP_BUFFERSIZE, 1)
        self.q = Queue(maxsize=1)
        self.stopped = False
        self.is_alive = True
        self.fallos = 0
        
        # Pantalla de muerte con el número de cámara
        self.frame_error = np.zeros((270, 480, 3), dtype=np.uint8)
        cv2.putText(self.frame_error, f"CAM {self.cam_id} OFFLINE", (110, 135), cv2.FONT_HERSHEY_SIMPLEX, 1.2, (0, 0, 255), 3)

        threading.Thread(target=self._run, daemon=True).start()

    def _run(self):
        while not self.stopped:
            ret, f = self.cap.read()
            if not ret:
                if self.stopped: break
                self.is_alive = False
                self.fallos += 1
                
                # Liberamos el socket inmediatamente para que el DVR respire
                if self.cap: self.cap.release()
                
                wait_time = min(30, 2 ** self.fallos)
                print(f" [ALERTA] Cam {self.cam_id} caída. Reintentando en {wait_time}s...")
                
                # Espera fraccionada para no bloquear la orden de cierre del usuario
                for _ in range(wait_time * 10):
                    if self.stopped: break
                    time.sleep(0.1)
                
                if self.stopped: break
                
                self.cap = cv2.VideoCapture(self.url)
                self.cap.set(cv2.CAP_PROP_BUFFERSIZE, 1)
                continue
            
            if self.fallos > 0:
                print(f" [INFO] Cam {self.cam_id} RECUPERADA exitosamente.")
            
            self.fallos = 0
            self.is_alive = True
            
            if self.q.full():
                try: self.q.get_nowait()
                except Exception: pass
            self.q.put(f)

        # La memoria C++ se libera DENTRO de su propio hilo.
        if self.cap:
            self.cap.release()

    @property
    def frame(self):
        if not self.is_alive: return self.frame_error.copy()
        try: return self.q.get(timeout=0.5)
        except Exception: return self.frame_error.copy()

    def stop(self): 
        self.stopped = True

def dibujar_track_fusion(frame_show, trk, global_mem):
    try: x1, y1, x2, y2 = map(int, trk.box)
    except Exception: return
    
    nombre_str = ""
    if trk.gid is not None:
        with global_mem.lock:
            nombre = global_mem.db.get(trk.gid, {}).get('nombre')
            if nombre: nombre_str = f" [{nombre}]"

    if trk.gid is None: color, label = (150, 150, 150), f"?{trk.local_id}"        
    elif nombre_str: color, label = (255, 0, 255), f"ID:{trk.gid}{nombre_str}" 
    # ⚡ AQUÍ ESTÁ EL NARANJA DE REGRESO
    elif getattr(trk, 'origen_global', False): color, label = (0, 165, 255), f"ID:{trk.gid} [re-id]" 
    elif getattr(trk, 'en_grupo', False): color, label = (0, 0, 255), f"ID:{trk.gid} [grp]"
    else: color, label = (0, 255, 0), f"ID:{trk.gid}"
    
    cv2.rectangle(frame_show, (x1, y1), (x2, y2), color, 2)
    (tw, th), _ = cv2.getTextSize(label, FUENTE, 0.55, 1)
    cv2.rectangle(frame_show, (x1, y1-th-6), (x1+tw+2, y1), color, -1)
    cv2.putText(frame_show, label, (x1+1, y1-4), FUENTE, 0.55, (0,0,0), 1)

def main():
    # ⚡ FIX: RESTAURADOS LOS NOMBRES ORIGINALES (FRAME_MOSAICO) PARA QUE LA INTERFAZ RECIBA EL VIDEO
    global MOTOR_ACTIVO, PAGINA_ACTUAL, CAMS_POR_PANTALLA, FRAME_MOSAICO, CAMARA_MAXIMIZADA, TELEMETRIA
    print("\n=== Motor IA Iniciado (Control fision1) ===")
    
    config_data = {}
    if os.path.exists("config.json"):
        try:
            with open("config.json", 'r') as f: config_data = json.load(f)
        except Exception: pass

    ip_dvr = config_data.get("dvr_ip", "192.168.1.244")
    usr = config_data.get("dvr_user", "admin")
    pwd = config_data.get("dvr_pass", "TCA200503")
    sec_str = config_data.get("secuencia_total", "2, 1, 7, 5, 8, 4, 3, 6")
    ign_str = config_data.get("ignoradas", "2, 4")

    SECUENCIA_TOTAL = [x.strip() for x in sec_str.split(",") if x.strip()]
    IGNORADAS = [x.strip() for x in ign_str.split(",") if x.strip()]
    URLS = [f"rtsp://{usr}:{pwd}@{ip_dvr}:554/Streaming/Channels/{c}02" for c in SECUENCIA_TOTAL]
    
    camaras_activas = [c for c in SECUENCIA_TOTAL if c not in IGNORADAS]

    model = YOLO("yolov8n-pose.pt") 
    global_mem = GlobalMemory()
    managers = {str(c): CamManager(c, global_mem) for c in camaras_activas}
    
    # ⚡ FIX: Enviamos el URL y el cam_id al CamStream modificado
    cams = [CamStream(u, c) for u, c in zip(URLS, SECUENCIA_TOTAL)]
    
    threading.Thread(target=worker_rostros, args=(global_mem,), daemon=True).start()

    idx = 0
    ultimo_guardado = time.time()
    ultimo_auto_merge = time.time()
    MOTOR_ACTIVO = True
    
    try:
        while MOTOR_ACTIVO:
            now = time.time()
            tiles_pagina_actual = []
            cam_ia_actual = camaras_activas[idx % len(camaras_activas)] if camaras_activas else None
            
            try: cams_pantalla = int(CAMS_POR_PANTALLA)
            except: cams_pantalla = 4
            inicio_slice = PAGINA_ACTUAL * cams_pantalla
            fin_slice = inicio_slice + cams_pantalla

            for i, cam_obj in enumerate(cams):
                cid = str(SECUENCIA_TOTAL[i])
                frame = cam_obj.frame
                
                if frame is None or not getattr(cam_obj, 'is_alive', True):
                    frame_err = np.zeros((270, 480, 3), np.uint8)
                    cv2.putText(frame_err, f"CAM {cid} OFFLINE", (120, 135), FUENTE, 1.0, (0,0,255), 2)
                    if inicio_slice <= i < fin_slice: tiles_pagina_actual.append(frame_err)
                    continue
                    
                frame_show = cv2.resize(frame.copy(), (480, 270))
                
                if cid in IGNORADAS:
                    cv2.putText(frame_show, f"CAM {cid} [MODO VISOR - Sin IA]", (10, 28), FUENTE, 0.7, (150, 150, 150), 2)
                    if inicio_slice <= i < fin_slice: tiles_pagina_actual.append(frame_show)
                    continue
                
                boxes, confs, keypoints = [], [], []
                turno_activo = (cid == cam_ia_actual)
                
                if turno_activo:
                    res = model.predict(frame_show, conf=0.45, iou=0.40, classes=[0], verbose=False, imgsz=480, device='cpu')
                    if res[0].boxes:
                        raw_boxes = res[0].boxes.xyxy.cpu().numpy().tolist()
                        raw_confs = res[0].boxes.conf.cpu().numpy().tolist()
                        raw_kpts  = res[0].keypoints.data.cpu().numpy().tolist() if res[0].keypoints is not None else []

                        for d_idx, (box, conf) in enumerate(zip(raw_boxes, raw_confs)):
                            kpt_persona = raw_kpts[d_idx] if d_idx < len(raw_kpts) else None
                            if es_humano_valido(kpt_persona, box, conf):
                                boxes.append(box)
                                confs.append(conf)
                                keypoints.append(kpt_persona)

                tracks = managers[cid].update(boxes, confs, keypoints, frame_show, frame, now, turno_activo)
                
                for trk in tracks:
                    if getattr(trk, 'time_since_update', 1) <= 2: 
                        # ⚡ SOLUCIÓN PARTE 2B: El cuadro naranja durará 5 segundos reales
                        if trk.gid is not None:
                            with global_mem.lock:
                                ts_cruce = global_mem.db.get(trk.gid, {}).get('ts_cruce', 0)
                                if (now - ts_cruce) < 5.0:
                                    trk.origen_global = True
                                else:
                                    trk.origen_global = False

                        dibujar_track_fusion(frame_show, trk, global_mem)
                        
                        # ⚡ SOLUCIÓN PARTE 1: GARANTIZAR EL ENCUADRE DEL ROSTRO
                        if turno_activo and trk.gid is not None and not getattr(trk, 'procesando_rostro', False):
                            ultimo_envio = getattr(trk, 'ultimo_rostro_enviado', 0)
                            if (now - ultimo_envio) > 0.7: 
                                try:
                                    x1, y1, x2, y2 = trk.box
                                    h_r, w_r = frame.shape[:2]
                                    e_x, e_y = w_r / 480.0, h_r / 270.0
                                    h_b, w_b = y2 - y1, x2 - x1
                                    
                                    # Bajamos al 50% de la caja de YOLO para asegurar que entre la barbilla
                                    # y ampliamos el margen horizontal a 25% por si la persona va girando.
                                    y_exp = max(0, int(y1*e_y - h_b*e_y*0.20))
                                    y_cab = min(h_r, int(y1*e_y + h_b*e_y*0.50)) 
                                    x_izq = max(0, int(x1*e_x - w_b*e_x*0.25))
                                    x_der = min(w_r, int(x2*e_x + w_b*e_x*0.25))
                                    
                                    roi = frame[y_exp:y_cab, x_izq:x_der].copy()
                                    
                                    # Bajamos la exigencia de 60x60 a 40x40 para atrapar rostros lejanos
                                    if roi.size > 0 and roi.shape[0] >= 40 and roi.shape[1] >= 40:
                                        if not COLA_ROSTROS.full():
                                            trk.ultimo_rostro_enviado = now 
                                            trk.procesando_rostro = True    
                                            COLA_ROSTROS.put((roi, trk.gid, cid, trk), block=False)
                                            # DEBUG OBLIGATORIO: Te avisa visualmente que sí capturó la foto y la mandó a la fila
                                            print(f" [CÁMARA] Cam {cid} envió foto de ID {trk.gid} a la IA Facial.")
                                except Exception as e: 
                                    print(f" [ERROR DE RECORTE] {e}")

                if turno_activo: cv2.circle(frame_show, (460, 20), 6, (0, 0, 255), -1)
                con_id = sum(1 for t in tracks if getattr(t, 'gid', None) and getattr(t, 'time_since_update', 1) == 0)
                cv2.putText(frame_show, f"CAM {cid} [{con_id} ID]", (10, 28), FUENTE, 0.7, (255, 255, 255), 2)
                
                if inicio_slice <= i < fin_slice:
                    tiles_pagina_actual.append(frame_show)
                
            # ⚡ RENDERIZADO CORREGIDO: RESTAURADO "FRAME_MOSAICO"
            if CAMARA_MAXIMIZADA is not None:
                idx_cam = SECUENCIA_TOTAL.index(str(CAMARA_MAXIMIZADA)) if str(CAMARA_MAXIMIZADA) in SECUENCIA_TOTAL else 0
                frame_max = cams[idx_cam].frame
                if frame_max is not None:
                    mosaico = cv2.resize(frame_max, (1280, 720))
                    cv2.putText(mosaico, f"MODO ZOOM - CAM {CAMARA_MAXIMIZADA}", (20, 40), FUENTE, 1, (0,255,0), 3)
                    FRAME_MOSAICO = mosaico
                else:
                    FRAME_MOSAICO = crear_mosaico(tiles_pagina_actual)
            else:
                FRAME_MOSAICO = crear_mosaico(tiles_pagina_actual)

            tiempo_ciclo = time.time() - now
            fps_actual = 1.0 / (tiempo_ciclo + 1e-6)
            TELEMETRIA['fps'] = (TELEMETRIA['fps'] * 0.9) + (fps_actual * 0.1)
            TELEMETRIA['ids_activos'] = len(global_mem.db)

            if now - ultimo_auto_merge > 2.0:
                global_mem.consolidar_clones()
                ultimo_auto_merge = now
            
            if now - ultimo_guardado > 30:
                global_mem.guardar_memoria()
                ultimo_guardado = now

            idx += 1
            time.sleep(0.01)
            
    finally:
        print("Apagando conexiones de cámara de forma segura...")
        for cam in cams:
            cam.stop() 
        global_mem.guardar_memoria()
        print("Motor IA Detenido y Memoria Guardada.")


"""import os
os.environ['TF_CPP_MIN_LOG_LEVEL'] = '3'
os.environ['CUDA_VISIBLE_DEVICES'] = '-1'
os.environ["OPENCV_FFMPEG_CAPTURE_OPTIONS"] = "rtsp_transport;tcp|stimeout;3000000"

# Silenciamos a OpenCV y Qt
os.environ['QT_LOGGING_RULES'] = '*=false'
os.environ['OPENCV_LOG_LEVEL'] = 'ERROR'
import cv2
import numpy as np
import time
import threading
from queue import Queue
from ultralytics import YOLO
import warnings
import json
import math

warnings.filterwarnings("ignore")

# ──────────────────────────────────────────────────────────────────────────────
#  1. IMPORTAMOS NUESTROS MÓDULOS 
# ──────────────────────────────────────────────────────────────────────────────
import seguimiento2
from seguimiento2 import GlobalMemory, CamManager, FUENTE, es_humano_valido

from reconocimiento import (
    app,  
    gestionar_vectores,
    buscar_mejor_match,
    hilo_bienvenida
)

# ──────────────────────────────────────────────────────────────────────────────
#  2. PROTECCIONES MULTIHILO E INICIALIZACIÓN
# ──────────────────────────────────────────────────────────────────────────────
COLA_ROSTROS = Queue(maxsize=4) 
IA_LOCK = threading.Lock() 

PAGINA_ACTUAL = 0
CAMS_POR_PANTALLA = 4
CAMARA_MAXIMIZADA = None
TELEMETRIA = {'fps': 0.0, 'ids_activos': 0}
FRAME_MOSAICO = None

def obtener_ultimo_frame():
    global FRAME_MOSAICO
    return FRAME_MOSAICO

print("\nIniciando carga de base de datos...")
BASE_DATOS_ROSTROS = gestionar_vectores(actualizar=True)

# ──────────────────────────────────────────────────────────────────────────────
#  FUNCIÓN: MOSAICO DINÁMICO
# ──────────────────────────────────────────────────────────────────────────────
def crear_mosaico(tiles):
    if not tiles: return None
    n = len(tiles)
    if n == 1: return tiles[0]
    
    if n <= 4: cols, rows = 2, 2
    elif n <= 6: cols, rows = 3, 2
    elif n <= 8: cols, rows = 4, 2
    elif n <= 9: cols, rows = 3, 3
    else:
        cols = math.ceil(math.sqrt(n))
        rows = math.ceil(n / cols)

    h, w, c = tiles[0].shape
    mosaico = np.zeros((rows * h, cols * w, c), dtype=np.uint8)

    for i, tile in enumerate(tiles):
        r = i // cols
        c_idx = i % cols
        mosaico[r*h:(r+1)*h, c_idx*w:(c_idx+1)*w] = tile
        
    return mosaico

# ──────────────────────────────────────────────────────────────────────────────
#  3. MOTOR ASÍNCRONO CON INSIGHTFACE
# ──────────────────────────────────────────────────────────────────────────────
def procesar_rostro_async(roi_cabeza, gid, cam_id, global_mem, trk):
    try:
        if not BASE_DATOS_ROSTROS or roi_cabeza.size == 0: return

        with IA_LOCK:
            faces = app.get(roi_cabeza)

        if len(faces) == 0: return

        face = max(faces, key=lambda f: (f.bbox[2] - f.bbox[0]) * (f.bbox[3] - f.bbox[1]))
        w_rostro, h_rostro = face.bbox[2] - face.bbox[0], face.bbox[3] - face.bbox[1]

        if w_rostro < 25 or h_rostro < 25 or (w_rostro / h_rostro) < 0.30:
            return

        emb = np.array(face.normed_embedding, dtype=np.float32)
        genero_detectado = "Man" if face.sex == "M" else "Woman"

        mejor_match, max_sim = buscar_mejor_match(emb, BASE_DATOS_ROSTROS)
        
        if max_sim < 0.23:
            return 

        print(f"[DEBUG CAM {cam_id}] InsightFace: {mejor_match} al {max_sim:.2f}")

        if max_sim >= 0.23 and mejor_match:
            nombre_limpio = mejor_match.split('_')[0]
            id_definitivo = gid 

            with global_mem.lock:
                datos_id = global_mem.db.get(gid)
                if not datos_id: return
                
                dueno_actual = datos_id.get('nombre')
                candidato_actual = datos_id.get('candidato_nombre')

                if max_sim >= 0.42:   puntos = 3
                elif max_sim >= 0.30: puntos = 2
                elif max_sim >= 0.23: puntos = 1
                else:                 puntos = 0

                if puntos == 0: return

                if dueno_actual is not None and dueno_actual != nombre_limpio:
                    datos_id['dudas_identidad'] = datos_id.get('dudas_identidad', 0) + puntos
                    strikes = datos_id['dudas_identidad']
                    
                    if strikes >= 2:
                        print(f"[REBELIÓN] 2 Strikes superados en Cam {cam_id}. Destronando a {dueno_actual} a favor de {nombre_limpio}.")
                        datos_id['nombre'] = None
                        datos_id['firma_ema'] = None 
                        dueno_actual = None 
                    else:
                        print(f"[DUDA] Strike 1 en Cam {cam_id}: Se parece a {nombre_limpio}. Vigilando de cerca a {dueno_actual}.")
                        datos_id['candidato_nombre'] = nombre_limpio
                        datos_id['votos_nombre'] = 1
                        return

                datos_id['dudas_identidad'] = 0  

                if candidato_actual == nombre_limpio:
                    datos_id['votos_nombre'] += puntos
                else:
                    datos_id['candidato_nombre'] = nombre_limpio
                    datos_id['votos_nombre'] = puntos
                
                votos_finales = datos_id['votos_nombre'] 

                if votos_finales >= 2: 
                    
                    clon_activo = False
                    for gid_activo, data_activo in global_mem.db.items():
                        if gid_activo != gid and data_activo.get('nombre') == nombre_limpio:
                            if (time.time() - data_activo.get('ts', 0)) < 2.0:
                                print(f"[BLOQUEO BAUTIZO] Cam {cam_id}: {nombre_limpio} ya está activo en el ID {gid_activo}.")
                                clon_activo = True
                                break
                    if clon_activo:
                        return

                    id_veterano = None
                    sim_cuerpo = 0.0
                    from scipy.spatial.distance import cosine
                    
                    for gid_mem, data_mem in global_mem.db.items():
                        if data_mem.get('nombre') == nombre_limpio and gid_mem != gid:
                            id_veterano = gid_mem
                            ema_vet = data_mem.get('ema')
                            ema_act = datos_id.get('ema')
                            if ema_vet and ema_act and 'deep' in ema_vet and 'deep' in ema_act:
                                sim_cuerpo = 1.0 - cosine(ema_act['deep'], ema_vet['deep'])
                            break
                            
                    if id_veterano is not None:
                        if sim_cuerpo < 0.60:
                            print(f" [FALSO POSITIVO] Cam {cam_id}: InsightFace detectó a {nombre_limpio}, pero su cuerpo NO coincide (Sim: {sim_cuerpo:.2f}). Rechazado.")
                            datos_id['votos_nombre'] = 0
                            datos_id['candidato_nombre'] = None
                            return
                        else:
                            print(f" [FUSIÓN FACIAL] Cam {cam_id}: Asignando la identidad de {nombre_limpio} (ID {id_veterano}) al tracker actual (Sim: {sim_cuerpo:.2f}).")
                            datos_id['fusionado_con'] = id_veterano
                            trk.gid = id_veterano
                            id_definitivo = id_veterano
                            
                    else:
                        if dueno_actual is None:
                            datos_id['nombre'] = nombre_limpio
                            datos_id['confianza_bautizo'] = max_sim * 100
                            datos_id['intentos_bautizo'] = votos_finales
                            print(f"[BAUTIZO] Cam {cam_id}: ID {gid} confirmado como {nombre_limpio} ({max_sim*100:.1f}%)")
                            
                    global_mem.db[id_definitivo]['ts'] = time.time()
                    
                    if str(cam_id) == "7" and nombre_limpio:
                        ahora = time.time()
                        TIEMPO_COOLDOWN = 30 
                        
                        info_saludo = global_mem.ultimos_saludos.get(nombre_limpio, {})
                        ultimo_ts = info_saludo.get('timestamp', 0) if isinstance(info_saludo, dict) else 0

                        if (ahora - ultimo_ts) > TIEMPO_COOLDOWN:
                            global_mem.guardar_saludo(nombre_limpio)
                            genero_oficial = genero_detectado
                            try:
                                ruta_gen = os.path.join("cache_nombres", "generos.json")
                                if os.path.exists(ruta_gen):
                                    with open(ruta_gen, 'r') as f:
                                        dic_gen = json.load(f)
                                        if nombre_limpio in dic_gen:
                                            genero_oficial = dic_gen[nombre_limpio]
                            except Exception: pass
                            
                            print(f" [AUDIO] Cam {cam_id}: {nombre_limpio} reconocido. Saludando...")
                            threading.Thread(target=hilo_bienvenida, args=(nombre_limpio, genero_oficial), daemon=True).start()
            
            if max_sim > 0.50 and votos_finales >= 2:
                global_mem.confirmar_firma_vip(id_definitivo, time.time())

    except Exception as e:
        print(f" Error en InsightFace asíncrono: {e}")
    finally:
        trk.procesando_rostro = False

def worker_rostros(global_mem):
    while True:
        roi_cabeza, gid, cam_id, trk = COLA_ROSTROS.get()
        procesar_rostro_async(roi_cabeza, gid, cam_id, global_mem, trk)
        COLA_ROSTROS.task_done()

# ──────────────────────────────────────────────────────────────────────────────
#  4. LECTURA DE VIDEO CONTINUA Y PURA
# ──────────────────────────────────────────────────────────────────────────────
class CamStream:
    def __init__(self, url):
        self.url = url
        self.cap = cv2.VideoCapture(url)
        # Buffer ultra-pequeño para que siempre se lea el cuadro más fresco, evitando retrasos
        self.cap.set(cv2.CAP_PROP_BUFFERSIZE, 2)
        self.frame = None
        threading.Thread(target=self._run, daemon=True).start()
        
    def _run(self):
        while True:
            ret, f = self.cap.read()
            if ret:
                self.frame = f
            else: 
                time.sleep(1)
                self.cap.open(self.url)

def dibujar_track_fusion(frame_show, trk, global_mem):
    try: x1, y1, x2, y2 = map(int, trk.box)
    except Exception: return
    
    nombre_str = ""
    if trk.gid is not None:
        with global_mem.lock:
            nombre = global_mem.db.get(trk.gid, {}).get('nombre')
            if nombre: nombre_str = f" [{nombre}]"

    if trk.gid is None: color, label = (150, 150, 150), f"?{trk.local_id}"        
    elif nombre_str: color, label = (255, 0, 255), f"ID:{trk.gid}{nombre_str}" 
    elif getattr(trk, 'en_grupo', False): color, label = (0, 0, 255), f"ID:{trk.gid} [grp]"
    elif getattr(trk, 'aprendiendo', False): color, label = (255, 255, 0), f"ID:{trk.gid} [++]" 
    elif getattr(trk, 'origen_global', False): color, label = (0, 165, 255), f"ID:{trk.gid} [re-id]"
    else: color, label = (0, 255, 0), f"ID:{trk.gid}"
    
    cv2.rectangle(frame_show, (x1, y1), (x2, y2), color, 2)
    (tw, th), _ = cv2.getTextSize(label, FUENTE, 0.55, 1)
    cv2.rectangle(frame_show, (x1, y1-th-6), (x1+tw+2, y1), color, -1)
    cv2.putText(frame_show, label, (x1+1, y1-4), FUENTE, 0.55, (0,0,0), 1)

def main(modo_interfaz=True):
    print("\nIniciando Motor de IA...")
    
    config_data = {}
    if os.path.exists("config.json"):
        try:
            with open("config.json", 'r') as f: config_data = json.load(f)
        except Exception as e: print(f"Error cargando config: {e}")

    ip_dvr = config_data.get("dvr_ip", "192.168.1.244")
    usr = config_data.get("dvr_user", "admin")
    pwd = config_data.get("dvr_pass", "TCA200503")
    sec_str = config_data.get("secuencia_total", "2, 1, 7, 5, 8, 4, 3, 6")
    ign_str = config_data.get("ignoradas", "2, 4")
    vecinos_str = config_data.get("vecinos", "{}")

    SECUENCIA_TOTAL = [x.strip() for x in sec_str.split(",") if x.strip()]
    IGNORADAS = [x.strip() for x in ign_str.split(",") if x.strip()]
    URLS = [f"rtsp://{usr}:{pwd}@{ip_dvr}:554/Streaming/Channels/{c}02" for c in SECUENCIA_TOTAL]
    
    try: seguimiento2.VECINOS = json.loads(vecinos_str)
    except: pass
    
    camaras_activas = [c for c in SECUENCIA_TOTAL if c not in IGNORADAS]

    model = YOLO("yolov8n-pose.pt") 
    global_mem = GlobalMemory()
    
    managers = {str(c): CamManager(c, global_mem) for c in camaras_activas}
    cams = [CamStream(u) for u in URLS]
    
    threading.Thread(target=worker_rostros, args=(global_mem,), daemon=True).start()

    idx = 0
    ultimo_guardado = time.time()
    
    while True:
        now = time.time()
        tiles = []
        cam_ia_actual = camaras_activas[idx % len(camaras_activas)] if camaras_activas else None
        
        # ⚡ 1. CALCULAMOS QUÉ CÁMARAS VAN EN ESTA PÁGINA
        try: cams_pantalla = int(CAMS_POR_PANTALLA)
        except: cams_pantalla = 4
        inicio_slice = PAGINA_ACTUAL * cams_pantalla
        fin_slice = inicio_slice + cams_pantalla
        
        if now - ultimo_guardado > 15:
            try:
                global_mem.guardar_memoria()
                ultimo_guardado = now
            except: pass
        
        for i, cam_obj in enumerate(cams):
            cid = str(SECUENCIA_TOTAL[i])
            frame = cam_obj.frame
            
            if frame is None:
                # Solo rellenamos de negro si la cámara apagada pertenece a la página actual
                if inicio_slice <= i < fin_slice:
                    tiles.append(np.zeros((270, 480, 3), np.uint8))
                continue
                
            frame_show = cv2.resize(frame.copy(), (480, 270))
            
            if cid in IGNORADAS:
                cv2.putText(frame_show, f"CAM {cid} [MODO VISOR - Sin IA]", (10, 28), FUENTE, 0.7, (150, 150, 150), 2)
                # ⚡ FILTRO: Solo agregar al mosaico si es de esta página
                if inicio_slice <= i < fin_slice:
                    tiles.append(frame_show)
                continue
            
            boxes, confs, keypoints = [], [], []
            turno_activo = (cid == cam_ia_actual)
            
            if turno_activo:
                res = model.predict(frame_show, conf=0.45, iou=0.40, classes=[0], verbose=False, imgsz=480, device='cpu')
                if res[0].boxes:
                    raw_boxes = res[0].boxes.xyxy.cpu().numpy().tolist()
                    raw_confs = res[0].boxes.conf.cpu().numpy().tolist()
                    raw_kpts  = res[0].keypoints.data.cpu().numpy().tolist() if res[0].keypoints is not None else []

                    for d_idx, (box, conf) in enumerate(zip(raw_boxes, raw_confs)):
                        kpt_persona = raw_kpts[d_idx] if d_idx < len(raw_kpts) else None
                        if es_humano_valido(kpt_persona, box, conf):
                            boxes.append(box)
                            confs.append(conf)
                            keypoints.append(kpt_persona)

                    ESQUELETO = [(0,1), (0,2), (1,3), (2,4), (5,6), (5,7), (7,9), (6,8), (8,10), 
                                 (5,11), (6,12), (11,12), (11,13), (13,15), (12,14), (14,16)]
                    
                    for persona_kpts in keypoints: 
                        for union in ESQUELETO:
                            p1, p2 = persona_kpts[union[0]], persona_kpts[union[1]]
                            if p1[2] > 0.40 and p2[2] > 0.40: 
                                pt1 = (int(p1[0]), int(p1[1]))
                                pt2 = (int(p2[0]), int(p2[1]))
                                cv2.line(frame_show, pt1, pt2, (255, 0, 255), 2)
                        for kx, ky, kconf in persona_kpts:
                            if kconf > 0.40:
                                cv2.circle(frame_show, (int(kx), int(ky)), 3, (0, 255, 255), -1)
                    
            tracks = managers[cid].update(boxes, confs, keypoints, frame_show, frame, now, turno_activo)
            
            for trk in tracks:
                if getattr(trk, 'time_since_update', 1) <= 2: 
                    dibujar_track_fusion(frame_show, trk, global_mem)
                    
                    if turno_activo and trk.gid is not None and not getattr(trk, 'procesando_rostro', False):
                        with global_mem.lock:
                            votos_actuales = global_mem.db.get(trk.gid, {}).get('votos_nombre', 0)
                            
                        ultimo_envio = getattr(trk, 'ultimo_rostro_enviado', 0)
                        tiempo_espera = 1.3 if votos_actuales >= 3 else 0.5
                            
                        if (now - ultimo_envio) < tiempo_espera: continue

                        x1, y1, x2, y2 = trk.box
                        h_real, w_real = frame.shape[:2]
                        escala_x = w_real / 480.0; escala_y = h_real / 270.0
                        h_box = y2 - y1
                        
                        y_exp = max(0, y1 - h_box * 0.15)
                        y_cab = min(270, y1 + h_box * 0.50)
                        
                        roi_recortado = frame[
                            int(y_exp * escala_y) : int(y_cab * escala_y),
                            int(max(0, x1) * escala_x) : int(min(480, x2) * escala_x)
                        ].copy()

                        if roi_recortado.size > 0 and roi_recortado.shape[0] >= 30 and roi_recortado.shape[1] >= 30:
                            gray = cv2.cvtColor(roi_recortado, cv2.COLOR_BGR2GRAY)
                            nitidez = cv2.Laplacian(gray, cv2.CV_64F).var()
                            
                            if nitidez > 12.0:
                                if not COLA_ROSTROS.full() and COLA_ROSTROS.qsize() < 2:
                                    trk.ultimo_rostro_enviado = now 
                                    trk.procesando_rostro = True    
                                    COLA_ROSTROS.put((roi_recortado, trk.gid, cid, trk), block=False)
                            else:
                                trk.ultimo_intento_cara = time.time() - 0.5

            if turno_activo: cv2.circle(frame_show, (460, 20), 6, (0, 0, 255), -1)
            
            con_id = sum(1 for t in tracks if t.gid and getattr(t, 'time_since_update', 1) == 0)
            cv2.putText(frame_show, f"CAM {cid} [{con_id} ID]", (10, 28), FUENTE, 0.7, (255, 255, 255), 2)
            
            # ⚡ FILTRO CRÍTICO: Solo añadimos el frame al mosaico si pertenece a la página activa
            if inicio_slice <= i < fin_slice:
                tiles.append(frame_show)
            
        # ⚡ 2. RENDERIZADO ASÍNCRONO DEL MOSAICO (Soporta Zoom y Paginación)
        global FRAME_MOSAICO
        if CAMARA_MAXIMIZADA is not None:
            idx_cam = SECUENCIA_TOTAL.index(str(CAMARA_MAXIMIZADA)) if str(CAMARA_MAXIMIZADA) in SECUENCIA_TOTAL else 0
            frame_max = cams[idx_cam].frame
            if frame_max is not None:
                mosaico = cv2.resize(frame_max, (1280, 720))
                cv2.putText(mosaico, f"MODO ZOOM - CAM {CAMARA_MAXIMIZADA}", (20, 40), FUENTE, 1, (0,255,0), 3)
                FRAME_MOSAICO = mosaico
            else:
                FRAME_MOSAICO = crear_mosaico(tiles)
        else:
            FRAME_MOSAICO = crear_mosaico(tiles)

        # ⚡ 3. CÁLCULO DE TELEMETRÍA PARA EL HUD DE LA INTERFAZ
        tiempo_ciclo = time.time() - now
        fps_actual = 1.0 / (tiempo_ciclo + 1e-6)
        TELEMETRIA['fps'] = (TELEMETRIA['fps'] * 0.9) + (fps_actual * 0.1)
        TELEMETRIA['ids_activos'] = len(global_mem.db)

        idx += 1
        time.sleep(0.01)

if __name__ == "__main__":
    main(modo_interfaz=False)"""