pla-analysis 0.1.4__py3-none-any.whl

pla_analysis/__init__.py

@@ -0,0 +1,5 @@
+__version__ = "0.1.4"
+
+# Esto permite usar: pla_analysis.body3d.analyze(...)
+from . import body3d
+from . import tensile

pla_analysis/body3d.py

@@ -0,0 +1,409 @@
+import cv2
+import numpy as np
+import matplotlib.pyplot as plt
+import os
+import shutil
+import tempfile
+from pathlib import Path
+
+class BodyTracker:
+    """
+    Clase interna para realizar el seguimiento del punto negro en los frames.
+    """
+    def __init__(self, frames_folder):
+        self.frames_folder = frames_folder
+        self.frames = sorted(
+            [f for f in os.listdir(frames_folder) if f.endswith(('.tif', '.png', '.jpg'))]
+        )
+        if not self.frames:
+            raise ValueError(f"No se encontraron imágenes en '{frames_folder}'")
+
+        self.escala_px_mm = None
+        self.roi = None
+        self.umbral = 127
+        self.desplazamientos = []
+        # Para dibujar la estela del movimiento
+        self.trayectoria = [] 
+        
+        # Para el reporte comparativo
+        self.img_inicio = None
+        self.img_max_desp = None
+        self.max_desp_registrado = 0.0
+
+    def configurar_escala_interactiva(self):
+        """Abre interfaz gráfica para calibrar escala."""
+        primer_frame = os.path.join(self.frames_folder, self.frames[0])
+        img = cv2.imread(primer_frame, cv2.IMREAD_GRAYSCALE)
+        
+        # Guardamos imagen inicial para el reporte
+        self.img_inicio = img.copy()
+        
+        img_clean = cv2.cvtColor(img, cv2.COLOR_GRAY2BGR)
+        img_display = img_clean.copy()
+        
+        puntos = []
+        nombre_ventana = 'Calibracion: Click Inicio y Fin (r=Reset, ENTER=Confirmar)'
+
+        def click_event(event, x, y, flags, params):
+            if event == cv2.EVENT_LBUTTONDOWN:
+                if len(puntos) >= 2:
+                    puntos.clear()
+                    img_display[:] = img_clean[:] 
+                
+                puntos.append((x, y))
+                cv2.circle(img_display, (x, y), 5, (0, 255, 0), -1)
+                
+                if len(puntos) == 2:
+                    cv2.line(img_display, puntos[0], puntos[1], (0, 255, 0), 2)
+                
+                cv2.imshow(nombre_ventana, img_display)
+
+        print("Selecciona dos puntos para la escala.")
+        cv2.namedWindow(nombre_ventana)
+        cv2.setMouseCallback(nombre_ventana, click_event)
+        cv2.imshow(nombre_ventana, img_display)
+        
+        while True:
+            key = cv2.waitKey(1) & 0xFF
+            if key == ord('r'):
+                puntos.clear()
+                img_display[:] = img_clean[:]
+                cv2.imshow(nombre_ventana, img_display)
+            elif key == 13: # ENTER
+                if len(puntos) == 2: break
+                else: print("Necesitas 2 puntos.")
+        
+        cv2.destroyAllWindows()
+
+        dist_px = np.sqrt((puntos[1][0] - puntos[0][0])**2 + (puntos[1][1] - puntos[0][1])**2)
+        print(f"Distancia en píxeles: {dist_px:.2f}")
+        
+        while True:
+            try:
+                entrada = input(f"¿Cuántos mm son esos {dist_px:.2f} px en la realidad?: ")
+                dist_real = float(entrada)
+                if dist_real <= 0: continue
+                break
+            except ValueError:
+                print("Introduce un número válido.")
+            
+        self.escala_px_mm = dist_px / dist_real
+        return self.escala_px_mm
+
+    def seleccionar_roi_interactiva(self):
+        """Abre interfaz para seleccionar ROI."""
+        primer_frame = os.path.join(self.frames_folder, self.frames[0])
+        img = cv2.imread(primer_frame, cv2.IMREAD_GRAYSCALE)
+        
+        print("Selecciona la región de interés a analizar y pulsa ENTER")
+        try:
+            roi = cv2.selectROI('Selecciona la region de interes', img, showCrosshair=True)
+        finally:
+            cv2.destroyAllWindows()
+        
+        if roi[2] == 0 or roi[3] == 0:
+            raise ValueError("Región no válida.")
+        self.roi = roi
+        return roi
+
+    def calibrar_umbral_interactivo(self):
+        """Abre interfaz con slider para umbral."""
+        primer_frame = os.path.join(self.frames_folder, self.frames[0])
+        img = cv2.imread(primer_frame, cv2.IMREAD_GRAYSCALE)
+        x, y, w, h = self.roi
+        img_roi = img[y:y+h, x:x+w]
+
+        def nada(x): pass
+
+        ventana_umbral = 'Ajuste Blanco y Negro (ENTER para confirmar)'
+        cv2.namedWindow(ventana_umbral)
+        cv2.createTrackbar('Umbral', ventana_umbral, self.umbral, 255, nada)
+        
+        print("Ajusta el umbral hasta aislar el punto negro y pulsa ENTER")
+        while True:
+            u = cv2.getTrackbarPos('Umbral', ventana_umbral)
+            self.umbral = u
+            _, th = cv2.threshold(img_roi, u, 255, cv2.THRESH_BINARY)
+            cv2.imshow(ventana_umbral, th)
+            if cv2.waitKey(1) & 0xFF == 13: break
+        
+        cv2.destroyAllWindows()
+        return self.umbral
+
+    def _dibujar_dashboard(self, frame_bgr, desplazamiento_actual, frame_idx):
+        h_video, w_video = frame_bgr.shape[:2]
+        ancho_panel = 500
+        fondo_color = (245, 245, 245)
+        panel = np.ones((h_video, ancho_panel, 3), dtype=np.uint8)
+        panel[:] = fondo_color
+        
+        # --- HEADER ---
+        altura_header = 140
+        cv2.rectangle(panel, (0, 0), (ancho_panel, altura_header), (230, 230, 230), -1)
+        cv2.line(panel, (0, altura_header), (ancho_panel, altura_header), (180, 180, 180), 1)
+
+        texto_disp = f"{desplazamiento_actual:.3f} mm" if desplazamiento_actual is not None else "--"
+        
+        cv2.putText(panel, "Analisis en Tiempo Real", (20, 35), cv2.FONT_HERSHEY_SIMPLEX, 0.6, (80, 80, 80), 1, cv2.LINE_AA)
+        cv2.putText(panel, "Desplazamiento horizontal:", (20, 70), cv2.FONT_HERSHEY_SIMPLEX, 0.5, (100, 100, 100), 1, cv2.LINE_AA)
+        cv2.putText(panel, texto_disp, (20, 110), cv2.FONT_HERSHEY_SIMPLEX, 1.2, (0, 0, 150), 2, cv2.LINE_AA)
+        
+        progreso = frame_idx / len(self.frames)
+        w_barra = ancho_panel - 40
+        cv2.rectangle(panel, (20, 125), (20 + w_barra, 130), (200, 200, 200), -1)
+        cv2.rectangle(panel, (20, 125), (20 + int(w_barra * progreso), 130), (0, 180, 0), -1)
+
+        # --- GRÁFICA ---
+        datos_validos = [d for d in self.desplazamientos if d is not None]
+        
+        if len(datos_validos) > 1:
+            margen_x = 40
+            margen_y_inf = 40
+            y_inicio_grafica = altura_header + 20 
+            h_grafica = h_video - y_inicio_grafica - margen_y_inf
+            w_grafica = ancho_panel - 2 * margen_x
+            
+            min_val = min(datos_validos)
+            max_val = max(datos_validos)
+            
+            # Estabilización
+            if abs(max_val - min_val) < 1.0:
+                centro = (max_val + min_val) / 2
+                min_val = centro - 0.5
+                max_val = centro + 0.5
+            
+            span = max_val - min_val
+            min_val -= span * 0.1
+            max_val += span * 0.1
+            rango_val = max_val - min_val
+
+            puntos_plot = []
+            total_frames = len(self.frames)
+            
+            for i, val in enumerate(datos_validos):
+                px = int(margen_x + (i / total_frames) * w_grafica)
+                val_norm = (val - min_val) / rango_val
+                py = int((y_inicio_grafica + h_grafica) - (val_norm * h_grafica))
+                puntos_plot.append((px, py))
+            
+            color_ejes = (100, 100, 100)
+            cv2.line(panel, (margen_x, y_inicio_grafica), (margen_x, h_video - margen_y_inf), color_ejes, 1)
+            cv2.line(panel, (margen_x, h_video - margen_y_inf), (ancho_panel - margen_x, h_video - margen_y_inf), color_ejes, 1)
+
+            if len(puntos_plot) > 1:
+                cv2.polylines(panel, [np.array(puntos_plot)], False, (200, 50, 0), 2, cv2.LINE_AA)
+            
+            if puntos_plot:
+                cv2.circle(panel, puntos_plot[-1], 4, (0, 0, 255), -1, cv2.LINE_AA)
+
+        return np.hstack((frame_bgr, panel))
+
+    def procesar(self, guardar_video=False, nombre_video_salida="resultado_analisis.mp4"):
+        x, y, w, h = self.roi
+        pos_inicial_x = None
+
+        print(f"Procesando {len(self.frames)} frames...")
+        cv2.namedWindow("Analisis en Vivo", cv2.WINDOW_NORMAL)
+        
+        video_writer = None
+        
+        # Reiniciar para este análisis
+        self.img_max_desp = self.img_inicio.copy() # Por defecto
+        self.max_desp_registrado = 0.0
+        
+        for idx, frame_name in enumerate(self.frames):
+            path = os.path.join(self.frames_folder, frame_name)
+            img = cv2.imread(path, cv2.IMREAD_GRAYSCALE)
+            frame_vis = cv2.cvtColor(img, cv2.COLOR_GRAY2BGR)
+            
+            # --- Detección ---
+            img_roi = img[y:y+h, x:x+w]
+            _, img_bin = cv2.threshold(img_roi, self.umbral, 255, cv2.THRESH_BINARY)
+            img_inv = cv2.bitwise_not(img_bin)
+            
+            M = cv2.moments(img_inv)
+            desp_mm = None
+            
+            if M["m00"] != 0:
+                cx_global = x + int(M["m10"] / M["m00"])
+                cy_global = y + int(M["m01"] / M["m00"])
+                
+                # Guardar trayectoria (Estela)
+                self.trayectoria.append((cx_global, cy_global))
+                
+                # Visualización
+                cv2.rectangle(frame_vis, (x, y), (x+w, y+h), (0, 255, 0), 2)
+                
+                # Dibujar Estela (Línea amarilla)
+                if len(self.trayectoria) > 1:
+                    cv2.polylines(frame_vis, [np.array(self.trayectoria)], False, (0, 255, 255), 1, cv2.LINE_AA)
+                
+                cv2.circle(frame_vis, (cx_global, cy_global), 5, (0, 0, 255), -1)
+                
+                if pos_inicial_x is None:
+                    pos_inicial_x = cx_global
+                    desp_mm = 0.0
+                else:
+                    desp_px = cx_global - pos_inicial_x
+                    desp_mm = desp_px / self.escala_px_mm
+                    
+                    # Chequear si este es el frame de máximo desplazamiento absoluto
+                    if abs(desp_mm) > abs(self.max_desp_registrado):
+                        self.max_desp_registrado = desp_mm
+                        self.img_max_desp = img.copy() # Guardar foto original en B/N
+            else:
+                cv2.rectangle(frame_vis, (x, y), (x+w, y+h), (0, 0, 255), 2)
+                cv2.putText(frame_vis, "LOST", (x, y-10), cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0,0,255), 2)
+            
+            self.desplazamientos.append(desp_mm)
+
+            # --- Dashboard ---
+            dashboard = self._dibujar_dashboard(frame_vis, desp_mm, idx)
+            cv2.imshow("Analisis en Vivo", dashboard)
+            
+            # --- Grabar ---
+            if guardar_video:
+                if video_writer is None:
+                    h_dash, w_dash = dashboard.shape[:2]
+                    fourcc = cv2.VideoWriter_fourcc(*'mp4v') 
+                    video_writer = cv2.VideoWriter(nombre_video_salida, fourcc, 25.0, (w_dash, h_dash))
+                video_writer.write(dashboard)
+
+            if cv2.waitKey(1) & 0xFF == ord('q'):
+                print("\nAnálisis interrumpido.")
+                break
+        
+        if video_writer:
+            video_writer.release()
+            print(f"Video guardado como: {nombre_video_salida}")
+
+        cv2.destroyAllWindows()
+        return self.desplazamientos
+
+    def generar_reporte_comparativo(self, save_path="resultado_comparacion.png"):
+        """Genera una imagen resumen con Inicio vs Máximo Desplazamiento."""
+        if self.img_inicio is None or self.img_max_desp is None:
+            return
+
+        print("Generando reporte comparativo...")
+        
+        # Crear figura de Matplotlib
+        fig = plt.figure(figsize=(12, 6))
+        gs = fig.add_gridspec(1, 3) # 1 fila, 3 columnas
+
+        # 1. Imagen Inicio
+        ax1 = fig.add_subplot(gs[0, 0])
+        ax1.imshow(self.img_inicio, cmap='gray')
+        ax1.set_title("Inicio (0 mm)")
+        ax1.axis('off')
+        # Dibujar recuadro de ROI referencia
+        if self.roi:
+            x, y, w, h = self.roi
+            rect = plt.Rectangle((x, y), w, h, linewidth=2, edgecolor='g', facecolor='none')
+            ax1.add_patch(rect)
+
+        # 2. Imagen Máximo
+        ax2 = fig.add_subplot(gs[0, 1])
+        ax2.imshow(self.img_max_desp, cmap='gray')
+        ax2.set_title(f"Desplazamiento horizontal máximo\n({self.max_desp_registrado:.2f} mm)")
+        ax2.axis('off')
+        if self.roi:
+            x, y, w, h = self.roi
+            # ROI en rojo para el máximo
+            rect = plt.Rectangle((x, y), w, h, linewidth=2, edgecolor='r', facecolor='none')
+            ax2.add_patch(rect)
+
+        # 3. Gráfica Final
+        ax3 = fig.add_subplot(gs[0, 2])
+        validos = [d for d in self.desplazamientos if d is not None]
+        if validos:
+            ax3.plot(validos, color='blue', label='Desplazamiento')
+            ax3.axhline(self.max_desp_registrado, color='red', linestyle='--', alpha=0.7)
+            ax3.set_title("Evolución Temporal")
+            ax3.set_xlabel("Frames")
+            ax3.set_ylabel("Desplazamiento (mm)")
+            ax3.grid(True, alpha=0.3)
+        
+        plt.tight_layout()
+        plt.savefig(save_path, dpi=150)
+        plt.close()
+        print(f"Reporte guardado como: {save_path}")
+
+
+def _extraer_frames_a_temp(video_path, temp_dir):
+    if not os.path.exists(video_path):
+        raise FileNotFoundError(f"Video no encontrado: {video_path}")
+    cap = cv2.VideoCapture(video_path)
+    if not cap.isOpened():
+        raise IOError("No se pudo abrir el video.")
+    print(f"Extrayendo frames del video completo...")
+    count = 0
+    while True:
+        ret, frame = cap.read()
+        if not ret: break
+        gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
+        filename = os.path.join(temp_dir, f"frame_{count:06d}.tif")
+        cv2.imwrite(filename, gray)
+        count += 1
+    cap.release()
+    print(f"\nTotal frames extraídos: {count}")
+    return count
+
+def analyze(video_path, plot_result=True, save_video=True):
+    """
+    Función principal.
+    """
+    temp_dir = tempfile.mkdtemp(prefix="pla_body3d_")
+    
+    try:
+        num_frames = _extraer_frames_a_temp(video_path, temp_dir)
+        if num_frames == 0: return None
+
+        tracker = BodyTracker(temp_dir)
+        tracker.configurar_escala_interactiva()
+        tracker.seleccionar_roi_interactiva()
+        tracker.calibrar_umbral_interactivo()
+        
+        # Procesar y Grabar
+        desplazamientos = tracker.procesar(guardar_video=save_video, nombre_video_salida="resultado_video.mp4")
+        
+        # Generar Reporte Comparativo (Visual)
+        tracker.generar_reporte_comparativo("reporte_comparativo.png")
+        
+        validos = [d for d in desplazamientos if d is not None]
+        if not validos: return {}
+            
+        max_disp_izq = min(validos)
+        max_disp_abs = max(validos, key=abs)
+        
+        results = {
+            "max_displacement_left": max_disp_izq,
+            "max_displacement_absolute": max_disp_abs,
+            "raw_data": desplazamientos,
+            "total_frames": num_frames
+        }
+
+        print(f"\nDesplazamiento horizontal máximo: {max_disp_izq:.4f} mm")
+
+        if plot_result:
+            plt.figure(figsize=(10, 5))
+            plt.plot(desplazamientos, label="Desplazamiento")
+            plt.axhline(max_disp_izq, color='r', linestyle='--', label=f"Max: {max_disp_izq:.2f}mm")
+            plt.title("Resultado Final: Análisis de desplazamiento horizontal")
+            plt.xlabel("Frame")
+            plt.ylabel("Desplazamiento (mm)")
+            plt.legend()
+            plt.grid(True, alpha=0.3)
+            plt.show()
+
+        return results
+
+    except Exception as e:
+        print(f"Error durante el análisis: {e}")
+        import traceback
+        traceback.print_exc() 
+        return None
+        
+    finally:
+        if os.path.exists(temp_dir):
+            shutil.rmtree(temp_dir)

pla_analysis/tensile.py

@@ -0,0 +1,287 @@
+import cv2
+import numpy as np
+import matplotlib.pyplot as plt
+import os
+
+class TensileOpticalTracker:
+    """
+    Clase especializada en detectar líneas de extensómetro en una secuencia de imágenes.
+    """
+    def __init__(self, frames_folder, l0_mm=35.0, a0_mm2=15.0):
+        self.frames_folder = frames_folder
+        self.l0_mm = l0_mm
+        self.a0_mm2 = a0_mm2
+        
+        # Validar que es una carpeta
+        if not os.path.isdir(frames_folder):
+            raise ValueError(f"La ruta '{frames_folder}' no es un directorio válido.")
+
+        # Cargar imágenes ordenadas
+        self.frames = sorted(
+            [f for f in os.listdir(frames_folder) if f.lower().endswith(('.tif', '.tiff', '.png', '.jpg', '.jpeg', '.bmp'))]
+        )
+        
+        if not self.frames:
+            raise ValueError(f"No se encontraron imágenes válidas en '{frames_folder}'")
+
+        self.roi = None
+        self.px_per_mm = None
+        self.desplazamientos = []
+        self.binary_threshold = 90
+
+    def seleccionar_roi_interactiva(self):
+        """
+        Permite seleccionar el ROI. Si la imagen es gigante, la reduce visualmente
+        para que quepa en la pantalla, pero guarda las coordenadas originales.
+        """
+        first_frame_path = os.path.join(self.frames_folder, self.frames[0])
+        img = cv2.imread(first_frame_path)
+        
+        if img is None:
+            raise ValueError(f"No se pudo leer la imagen: {first_frame_path}")
+
+        print("Selecciona el recuadro que contenga AMBAS líneas")
+        
+        # --- LÓGICA DE REDIMENSIONADO INTELIGENTE ---
+        alto_pantalla_objetivo = 800  # Altura cómoda para cualquier monitor
+        h_orig, w_orig = img.shape[:2]
+        factor_escala = 1.0
+        
+        img_mostrar = img
+        
+        # Si la imagen es muy alta, la reducimos para la selección
+        if h_orig > alto_pantalla_objetivo:
+            factor_escala = alto_pantalla_objetivo / h_orig
+            nuevo_ancho = int(w_orig * factor_escala)
+            nuevo_alto = int(h_orig * factor_escala)
+            img_mostrar = cv2.resize(img, (nuevo_ancho, nuevo_alto))
+
+        try:
+            # Seleccionamos sobre la imagen (posiblemente reducida)
+            roi_temp = cv2.selectROI("Selecciona la region de interes y pulsa ENTER", img_mostrar, showCrosshair=True)
+        finally:
+            cv2.destroyAllWindows()
+            cv2.waitKey(1)
+        
+        if roi_temp[2] == 0 or roi_temp[3] == 0:
+            raise ValueError("Region de interes inválida (ancho o alto es 0).")
+            
+        # --- RESTAURAR COORDENADAS ORIGINALES ---
+        # Si redujimos la imagen, tenemos que "agrandar" el ROI seleccionado
+        # para que coincida con la imagen original de alta calidad.
+        if factor_escala != 1.0:
+            x = int(roi_temp[0] / factor_escala)
+            y = int(roi_temp[1] / factor_escala)
+            w = int(roi_temp[2] / factor_escala)
+            h = int(roi_temp[3] / factor_escala)
+            self.roi = (x, y, w, h)
+        else:
+            self.roi = roi_temp
+            
+        return self.roi
+
+    def _medir_distancia_en_frame(self, img_gray):
+        """Calcula distancia y posiciones de líneas."""
+        x, y, w, h = self.roi
+        crop = img_gray[y:y+h, x:x+w]
+        
+        # Binarizar (invertido: fondo blanco -> negro, líneas negras -> blancas)
+        _, binary = cv2.threshold(crop, self.binary_threshold, 255, cv2.THRESH_BINARY_INV)
+        proyeccion_y = np.sum(binary, axis=1)
+        
+        # Umbral de detección (40% del ancho)
+        umbral_pixels = w * 255 * 0.40 
+        filas_con_linea = np.where(proyeccion_y > umbral_pixels)[0]
+        
+        if filas_con_linea.size < 2:
+            return None, None, None
+            
+        top_y_local = filas_con_linea[0]
+        bottom_y_local = filas_con_linea[-1]
+        
+        dist = bottom_y_local - top_y_local
+        # Retornar coordenadas globales para dibujar
+        return dist, (y + top_y_local), (y + bottom_y_local)
+
+    def _dibujar_dashboard(self, frame_bgr, desplazamiento_actual, frame_idx):
+        """Visualización en vivo con GRÁFICA GRANDE."""
+        h_video, w_video = frame_bgr.shape[:2]
+        
+        # Si el video es GIGANTE (4K), la gráfica de 800px se verá pequeña.
+        # Ajustamos el ancho del panel relativo al video (minimo 800px)
+        ancho_panel = max(800, int(w_video * 0.4)) 
+        
+        panel = np.ones((h_video, ancho_panel, 3), dtype=np.uint8) * 245 
+        
+        # --- HEADER ---
+        altura_header = 120
+        cv2.rectangle(panel, (0, 0), (ancho_panel, altura_header), (230, 230, 230), -1)
+        cv2.line(panel, (0, altura_header), (ancho_panel, altura_header), (180, 180, 180), 1)
+
+        texto_disp = f"{desplazamiento_actual:.3f} mm" if desplazamiento_actual is not None else "--"
+        
+        # Escalar fuente según resolución
+        font_scale_title = 0.8 if h_video < 1000 else 1.5
+        font_scale_val = 1.2 if h_video < 1000 else 2.5
+        
+        cv2.putText(panel, "Tensile Analysis Live", (20, 40 if h_video < 1000 else 80), 
+                    cv2.FONT_HERSHEY_SIMPLEX, font_scale_title, (80, 80, 80), 2, cv2.LINE_AA)
+        cv2.putText(panel, f"Elongacion: {texto_disp}", (20, 90 if h_video < 1000 else 180), 
+                    cv2.FONT_HERSHEY_SIMPLEX, font_scale_val, (0, 100, 0), 2, cv2.LINE_AA)
+        
+        # --- GRÁFICA ---
+        datos_validos = [d for d in self.desplazamientos if d is not None]
+        
+        if len(datos_validos) > 1:
+            margen_x = 50
+            margen_y_inf = 50
+            y_inicio = altura_header + 30
+            h_graf = h_video - y_inicio - margen_y_inf
+            w_graf = ancho_panel - 2 * margen_x
+            
+            min_v = min(datos_validos)
+            max_v = max(datos_validos)
+            
+            if abs(max_v - min_v) < 0.1:
+                centro = (max_v + min_v) / 2
+                min_v = centro - 0.05
+                max_v = centro + 0.05
+                
+            span = max_v - min_v
+            min_v -= span * 0.1
+            max_v += span * 0.1
+            rango = max_v - min_v
+            
+            puntos = []
+            total = len(self.frames)
+            for i, val in enumerate(datos_validos):
+                px = int(margen_x + (i / total) * w_graf)
+                norm = (val - min_v) / rango
+                py = int((y_inicio + h_graf) - (norm * h_graf))
+                puntos.append((px, py))
+            
+            color_eje = (100,100,100)
+            thickness_graph = 3 if h_video < 1000 else 6
+            
+            cv2.line(panel, (margen_x, y_inicio), (margen_x, h_video - margen_y_inf), color_eje, 2)
+            cv2.line(panel, (margen_x, h_video - margen_y_inf), (ancho_panel - margen_x, h_video - margen_y_inf), color_eje, 2)
+            
+            if len(puntos) > 1:
+                cv2.polylines(panel, [np.array(puntos)], False, (200, 0, 0), thickness_graph, cv2.LINE_AA)
+                
+            if puntos:
+                cv2.circle(panel, puntos[-1], thickness_graph * 2, (0, 0, 255), -1, cv2.LINE_AA)
+
+        return np.hstack((frame_bgr, panel))
+
+    def procesar(self):
+        """Bucle principal."""
+        print(f"Procesando {len(self.frames)} frames desde: {self.frames_folder}")
+        
+        # Creamos ventana resizable
+        cv2.namedWindow("Tensile Analysis Live", cv2.WINDOW_NORMAL)
+        
+        # Opcional: Si la imagen original es 4K, la ventana se abrirá gigante.
+        # Forzamos que la ventana empiece con un tamaño razonable (ej. 1280x720)
+        # El usuario luego puede maximizarla si quiere.
+        cv2.resizeWindow("Tensile Analysis Live", 1280, 720)
+        
+        x, y, w, h = self.roi
+        
+        # --- FASE 1: CALIBRACIÓN ---
+        temps_calib = []
+        for i in range(min(5, len(self.frames))):
+            p = os.path.join(self.frames_folder, self.frames[i])
+            im = cv2.imread(p, cv2.IMREAD_GRAYSCALE)
+            d, _, _ = self._medir_distancia_en_frame(im)
+            if d is not None: temps_calib.append(d)
+        
+        if not temps_calib:
+            raise ValueError("No se detectaron líneas al inicio para calibrar.")
+            
+        dist_inicial_px = np.mean(temps_calib)
+        self.px_per_mm = dist_inicial_px / self.l0_mm
+
+        # --- FASE 2: ANÁLISIS ---
+        for idx, frame_name in enumerate(self.frames):
+            path = os.path.join(self.frames_folder, frame_name)
+            img = cv2.imread(path, cv2.IMREAD_GRAYSCALE)
+            frame_vis = cv2.cvtColor(img, cv2.COLOR_GRAY2BGR)
+            
+            dist_px, y_top, y_bot = self._medir_distancia_en_frame(img)
+            desp_mm = None
+            
+            cv2.rectangle(frame_vis, (x, y), (x+w, y+h), (0, 255, 0), 1)
+            
+            if dist_px is not None:
+                cv2.line(frame_vis, (x, y_top), (x+w, y_top), (0, 0, 255), 2)
+                cv2.line(frame_vis, (x, y_bot), (x+w, y_bot), (0, 0, 255), 2)
+                
+                longitud_actual_mm = dist_px / self.px_per_mm
+                desp_mm = longitud_actual_mm - self.l0_mm
+            else:
+                if self.desplazamientos:
+                    desp_mm = self.desplazamientos[-1]
+                cv2.putText(frame_vis, "LOST", (x, y-5), cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0,0,255), 1)
+
+            self.desplazamientos.append(desp_mm)
+
+            dashboard = self._dibujar_dashboard(frame_vis, desp_mm, idx)
+            cv2.imshow("Tensile Analysis Live", dashboard)
+            
+            if cv2.waitKey(1) & 0xFF == ord('q'):
+                print("Interrumpido por usuario.")
+                break
+        
+        cv2.destroyAllWindows()
+        return self.desplazamientos
+
+
+def analyze(frames_folder, l0_mm=35.0, a0_mm2=15.0):
+    """
+    Función principal.
+    """
+    try:
+        tracker = TensileOpticalTracker(frames_folder, l0_mm=l0_mm, a0_mm2=a0_mm2)
+        tracker.seleccionar_roi_interactiva()
+        
+        desplazamientos_lista = tracker.procesar()
+        
+        # Limpieza de datos
+        desplazamientos_arr = np.array(
+            [d if d is not None else np.nan for d in desplazamientos_lista], 
+            dtype=np.float64
+        )
+        
+        if np.all(np.isnan(desplazamientos_arr)):
+            max_disp = 0.0
+            print("No se detectó movimiento válido en ningún frame.")
+        else:
+            max_disp = np.nanmax(desplazamientos_arr)
+        
+        results = {
+            "displacement_mm": desplazamientos_lista,
+            "max_displacement": max_disp,
+            "parameters": {"l0": l0_mm, "a0": a0_mm2}
+        }
+        
+        print(f" Desplazamiento Máximo: {max_disp:.4f} mm")
+        
+        plt.figure(figsize=(10, 6))
+        plt.plot(desplazamientos_arr, color='navy', linewidth=2, label='Extensómetro Óptico')
+        plt.axhline(max_disp, color='red', linestyle='--', alpha=0.5, label=f'Max: {max_disp:.2f} mm')
+        plt.title(f"Gráfica Final (L0={l0_mm}mm)")
+        plt.xlabel("Frame")
+        plt.ylabel("Elongación [mm]")
+        plt.legend()
+        plt.grid(True, alpha=0.3)
+        print("Mostrando gráfica final (cierre la ventana para terminar)...")
+        plt.show()
+
+        return results
+
+    except Exception as e:
+        print(f"Error durante el análisis: {e}")
+        import traceback
+        traceback.print_exc()
+        return None

pla_analysis-0.1.4.dist-info/METADATA

@@ -0,0 +1,154 @@
+Metadata-Version: 2.4
+Name: pla_analysis
+Version: 0.1.4
+Summary: A computer vision library for automated analysis of tensile and flexion mechanical tests.
+Author-email: Haritz Aseguinolaza <haritz.aseguinolaza@alumni.mondragon.edu>, Aimar Seco <aimar.seco@alumni.mondragon.edu>, Aratz Zabala <aratz.zabala@alumni.mondragon.edu>, Aitor Otzerin <aitor.otzerin@alumni.mondragon.edu>
+License: MIT License
+        
+        Copyright (c) 2026 Haritz Aseguinolaza, Aimar Seco, Aratz Zabala, Aitor Otzerin
+        
+        Permission is hereby granted, free of charge, to any person obtaining a copy
+        of this software and associated documentation files (the "Software"), to deal
+        in the Software without restriction, including without limitation the rights
+        to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+        copies of the Software, and to permit persons to whom the Software is
+        furnished to do so, subject to the following conditions:
+        
+        The above copyright notice and this permission notice shall be included in all
+        copies or substantial portions of the Software.
+        
+        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+        IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+        FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+        AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+        LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+        OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+        SOFTWARE.
+Keywords: computer-vision,mechanical-engineering,tensile-test,flexion-test,optical-tracking,displacement-measurement,opencv,material-science,extensometer,automation
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: opencv-python
+Requires-Dist: numpy
+Requires-Dist: matplotlib
+Dynamic: license-file
+
+# PLA Analysis Library
+
+![Version](https://img.shields.io/pypi/v/pla_analysis)
+![Python](https://img.shields.io/badge/python-3.7%2B-blue)
+![License](https://img.shields.io/badge/license-MIT-green)
+
+**pla_analysis** is a computer vision library designed for the automation and analysis of mechanical tests. This tool allows for the extraction of precise quantitative data (displacement, elongation) from video recordings or image sequences, eliminating the need for physical contact sensors.
+
+## Installation
+
+You can install the library directly from PyPI:
+
+```bash
+pip install pla_analysis
+```
+
+## Usage Guide
+
+The library is divided into two specialized modules according to the type of mechanical test. The operation of each is detailed below.
+
+---
+
+### 1. Tensile Module (Optical Extensometry)
+
+This module automates elongation measurement in tensile tests by tracking two physical marks on the specimen.
+
+#### Input Requirements
+* **Input:** A folder (directory) containing the image sequence (frames) of the test ordered chronologically.
+* **Specimen:** Must have **two horizontal black lines** marked on a clear background.
+
+#### Example Code
+
+```python
+import pla_analysis
+
+# Path to the folder containing the images .jpg/.tif/.png
+frames_folder = "C:/path/to/my_tensile_frames"
+
+# Run analysis
+# l0_mm: Real initial distance between the two lines (Default: 35.0 mm)
+# a0_mm2: Cross-sectional area of the specimen (Default: 15.0 mm^2)
+pla_analysis.tensile.analyze(frames_folder, l0_mm=35.0, a0_mm2=15.0)
+```
+
+#### Interactive Workflow
+
+1.  **ROI (Region of Interest) Selection:**
+    Upon running the code, the first frame will open. You must draw a box with the mouse that meets two vital conditions:
+    * **Must contain BOTH black lines.**
+    * Must have some **vertical clearance** (towards the direction the specimen stretches) to avoid losing the lines during the test.
+    * **Efficiency:** Try to adjust the width horizontally to the specimen. Selecting an unnecessarily large region will increase computational cost and could slow down the analysis.
+
+2.  **Live Analysis:**
+    The program will process the sequence showing a dashboard with line detection and the elongation graph generating frame by frame.
+
+3.  **Results:**
+    Upon completion, the maximum displacement will be shown in the terminal, and a window will open with the detailed final graph of `Elongation (mm) vs Frames`.
+
+---
+
+### 2. Body3D Module (Flexion Tracking)
+
+Designed to track the displacement of a specific point (centroid) in flexion tests or rigid body motion.
+
+#### Experiment Preparation (Important)
+To ensure proper computer vision performance, the input video must meet the following criteria:
+* **Contrast:** The specimen must be light (white) and the background also white or very light.
+* **Marker:** Draw a **single black or dark blue dot** on the area you wish to analyze.
+* **Editing:** It is recommended to crop the video beforehand to eliminate dead time at the start or end. The less "filler" the video has, the faster and more accurate the analysis will be.
+
+#### Example Code
+
+```python
+import pla_analysis
+
+# Path to the video file (.mp4, .avi, etc.)
+video_path = "C:/path/to/flexion_test.mp4"
+
+# save_video=True will generate an .mp4 file with the visual result overlaid
+pla_analysis.body3d.analyze(video_path, save_video=True)
+```
+
+#### Interactive Workflow
+
+1.  **Scale Calibration:**
+    The system needs to transform pixels to millimeters.
+    * Click on **two points** on the image whose real distance you know (e.g., the width of the specimen).
+    * Enter the real distance in millimeters in the terminal (e.g., `10.5`).
+
+2.  **ROI Selection:**
+    Select a box enclosing the area where the black dot will move. Ensure sufficient **clearance** so the dot does not exit the frame during maximum flexion.
+
+3.  **Threshold Adjustment:**
+    A window with a slider will appear.
+    * Move the bar until **only the black dot** is visible in black and the rest of the image appears totally white.
+    * Press `ENTER` to confirm.
+
+4.  **Results and Export:**
+    The system will automatically generate in your execution folder:
+    * `resultado_analisis.mp4`: Live dashboard video.
+    * `reporte_comparativo.png`: Static image comparing the initial state (rest) vs. maximum displacement.
+
+---
+
+## Authors
+
+Project developed by students from Mondragon Unibertsitatea:
+
+* **Haritz Aseguinolaza**
+* **Aimar Seco**
+* **Aratz Zabala**
+* **Aitor Otzerin**
+
+## License
+
+This project is distributed under the MIT license. See the `LICENSE` file for more information.

pla_analysis-0.1.4.dist-info/RECORD

@@ -0,0 +1,8 @@
+pla_analysis/__init__.py,sha256=2aMzgSVTZ6in-L46X0zfx8E2yyOVLZiQAlssMCziUgg,123
+pla_analysis/body3d.py,sha256=KMzxcPai8GYlrMm-sNYocsNx7zDBZlFwGVjPD6-_NRY,16354
+pla_analysis/tensile.py,sha256=YLQKJGrvIuCAenXPZTVmo5B5arM5fqNS_4W4gPTaye0,11730
+pla_analysis-0.1.4.dist-info/licenses/LICENSE,sha256=hHAbC2z6st-nvwl3q0wvEhTVjztzkJ-qcMoHJGaKfT0,1136
+pla_analysis-0.1.4.dist-info/METADATA,sha256=oN4SdSS9oDRsGf8S5nfDTG7DNUKnQyXqCnUeT1r3TTE,6889
+pla_analysis-0.1.4.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+pla_analysis-0.1.4.dist-info/top_level.txt,sha256=szlh8wdcmAlpkGCzYGc1IsxjQNkpVTwWUe04MylhNTI,13
+pla_analysis-0.1.4.dist-info/RECORD,,

pla_analysis-0.1.4.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.9.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

pla_analysis-0.1.4.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Haritz Aseguinolaza, Aimar Seco, Aratz Zabala, Aitor Otzerin
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

pla_analysis-0.1.4.dist-info/top_level.txt

@@ -0,0 +1 @@
+pla_analysis