AstroLoom v0.14.3

Añadido

• Compositor de Pila Multicapa Coronal en el Revelador (gui/tab_eclipse.py, gui/dialog_coronal_stack.py, gui/tab_developer.py):

  • Transferencia Directa de Filtros Eclipses $\to$ Revelador: Nuevo flujo y botón «Transferir Pila Coronal al Revelador» en la pestaña de Eclipses, permitiendo enviar la composición completa de filtros astronómicos (NRGF, SWAP, Larson-Sekanina, Steerable G2, NAFE, WOW Bilateral y MGN Multiescala) como capas ráster independientes al Revelador de AstroLoom sin requerir exportaciones intermedias ni software externo.
  • Diálogo Interactivo de Selección de Pila (CoronalStackDialog): Ventana de configuración previa que permite seleccionar qué filtros computar, asignando automáticamente modos de fusión y opacidades iniciales óptimas en orden físico de apilado (NRGF en Trama al 15%, SWAP en Normal al 25%, Larson-Sekanina en Luz Suave al 20%, Steerable G2 en Luz Suave al 20%, NAFE en Luz Suave al 20%, WOW en Luminosidad al 25% y MGN en Luminosidad al 40%).
  • Cálculo Asíncrono no Bloqueante (EclipseCoronalStackWorker): Generación secuencial de todos los filtros seleccionados en un hilo QThread en segundo plano con barra de progreso y cancelación segura sin congelar la interfaz.

• Motor de Capas Ráster Genéricas y Modos de Fusión (core/mask_layers.py, gui/widgets/mask_layers_widget.py, gui/developer/pipeline.py):

  • Nuevo Tipo de Capa Ráster (MASK_TYPE_IMAGE_RASTER): Extensión del motor de capas del Revelador para alojar arrays de imagen ráster arbitrarios (image_data en Float32), permitiendo componer múltiples imágenes y filtros sobre el lienzo base.
  • Arsenal Profesional de Modos de Fusión (Blend Modes): Soporte no destructivo para Normal, Trama (Screen), Luminosidad (Luminosity), Luz Suave (Soft Light), Superponer (Overlay) y Multiplicar (Multiply).
  • Integración de Máscaras y Ajustes por Capa: Las capas ráster incorporan soporte completo de máscara espacial de pincel (brush_mask, pintar y borrar para dosificar el filtro coronal localmente o excluir el limbo lunar), control de opacidad (0–100%), deslizadores de ajuste tonal (exposición, contraste, sombras, luces, balance de blancos) y curva tonal interactiva spline LUT dedicada.
  • Interfaz Ergonómica en el Gestor de Capas: Identidad visual diferenciada con distintivo y bordes en tono ámbar/dorado (#ff9800) para capas ráster, selector desplegable de modo de fusión reactivo y generación automática de miniaturas fotorrealistas.

• Aceleración en Rust Rayon SIMD de Modos de Fusión (astroloom_rs/src/blend.rs, astroloom_rs/src/lib.rs):

  • Kernels nativos multihilo con Rayon (apply_blend_mode_rs) que computan en paralelo las ecuaciones de fusión de píxeles (Normal, Screen, Luminosity con ponderación CIE Rec.709 y corrección de saturación, Soft Light de Pegtop, Overlay y Multiply) con modulación por opacidad y máscara espacial.
  • Rendimiento superior a 60 FPS en composiciones multicapa 4K y 60 MP, con respaldo (fallback) transparente y robusto en NumPy/OpenCV en entornos sin módulo compilado.

• Persistencia Completa de Capas Ráster en Proyectos .devloom (core/project_io.py):

  • Empaquetado multihilo de datos de imagen ráster en formato PNG de 16 bits sin pérdida (rasters/raster_{idx}.png) dentro del archivo ZIP del proyecto, garantizando la preservación íntegra de la composición coronal al guardar (Ctrl+S) y reabrir proyectos.

Corregido

• Estabilidad y Resiliencia en Filtro SWAP Polar (core/eclipse.py):
  • Pre-inicialización de búferes continuos de destino (dst_polar y dst_cart) con saneamiento de memoria np.nan_to_num(..., copy=False) en cv2.warpPolar, erradicando lecturas de basura de memoria, valores NaN y posibles cuelgues en versiones recientes de OpenCV (5.0+).

AstroLoom v0.14.2

Añadido

• Arsenal Completo de Filtros Coronales Científicos para Eclipses (AEL v1.3.2 – v1.4.2) (core/eclipse.py, gui/tab_eclipse.py):

  • Filtro Steerable G2 de Segunda Derivada Orientable (apply_steerable_g2, accumulate_steerable_g2_rs): Basado en Freeman & Adelson (1991) y validado sobre el eclipse de 2026. Calcula el tensor de estructura local suavizado para alinear analíticamente la respuesta direccional a lo largo del ángulo local de los arcos magnéticos y bucles cerrados cerca del limbo, logrando el mismo nivel de microcontraste que los filtros tangenciales pero con más del 50% de reducción de grano aleatorio.
  • Gradiente Rotacional de Larson–Sekanina con Protección Cromática (apply_larson_sekanina, compute_larson_sekanina_rs): Implementación de la formulación astrofísica (Larson & Sekanina 1984) con rotación continua por interpolación cúbica de Keys ($a = -0.5$) libre de artefactos periódicos. Incorpora detección y enmascaramiento automático de excesos de emisión cromosférica $H\alpha$ (compute_red_excess_mask_rs, ratio $R/G > 1.12 \times \text{mediana}$), erradicando las réplicas oscuras "fantasma" a $\pm\Delta\theta$ generadas por protuberancias solares intensas.
  • Filtro SWAP / Misión PROBA2 de la ESA (apply_swap_filter, polar_circular_median_filter_rs): Adaptación del algoritmo desarrollado para el telescopio espacial SWAP (Seaton et al. 2023). Realiza un filtrado de mediana circular polar en ventana angular de $\pm 15^\circ$, compresión radial suave $I / (F + t_0)^{c_0}$ ($c_0 = 0.75$) y normalización por raíz cuarta en $[0.5, 2.0]$. Genera una imagen autónoma de rango dinámico homogéneo que exhibe simultáneamente bucles magnéticos interiores y streamers gigantes exteriores sin necesidad de capas adicionales.
  • Filtro WOW Bilateral Guiado Edge-Aware (apply_wow_edge_aware, paired_b3_step_rs, b3_normalized_rs): Descomposición multiescala à-trous con spline B3 normalizado, ponderación de rango con pares simétricos y cálculo guiado de pesos (AEL 1.3.5 / Issue #4), erradicando la inversión de signo en filamentos tenues y halos en el limbo lunar, acelerado 819× en Rust.
  • Filtro NAFE (Noise Adaptive Fuzzy Equalization) (apply_nafe, nafe_neighbourhood): Ecualización difusa según la formulación de Miloslav Druckmüller (2013) con vecindario de 129 px compuesto por 12 gaussianas diádicas ($\sigma_m = 2^{m/2}$), aceleración mediante convoluciones FFT bidimensionales y compuerta adaptativa de ruido en el eje de intensidad ($12\times$ el ruido medido en corona externa).
  • Normalización de Detalle por Anillos Concéntricos (display_detail_rings, display_detail_rings_rs): Mapeo de microcontraste anillo por anillo en pasos de 2 px radiales en torno al centro solar (mediana y $1.4826 \cdot \text{MAD}$) con suavizado continuo 1D e interpolación sigmoidal $\tanh$. Previene la saturación en blanco o empaste en negro en el limbo solar brillante preservando texturas en toda la corona.
  • Encadenamiento Angular de Anillos Parciales en NRGF (partial_annuli='chain'): Evaluación de perfiles radiales restringida a sectores angulares mutuamente compartidos por anillos contiguos, eliminando saltos de densidad en tomas con Luna descentrada o recortada por el borde del sensor.
  • Fusión HDR con Traspaso Gradual de Exposición (gradual_handover=True): Modulación de los pesos de saturación proporcionalmente a la relación de tiempos $t_i / t_{i-1}$, mitigando la duplicación abrupta de varianza de ruido local y eliminando al 100% los falsos contornos o anillos anulares a lo largo de las isófotas de bracketing.
  • Exportación Nativa a Photoshop PSD Multicapa de 16 Bits (export_coronal_layers_psd): Generación automática de proyectos PSD de 16 bits por canal listos para retoque fino en Photoshop, GIMP o PixInsight, estructurados en capas estandarizadas (Fondo HDR Base, 01 NRGF, 02 WOW Edge-Aware, 09 NAFE, 11 Steerable G2, 15 Larson-Sekanina, 16 SWAP) con sus correspondientes modos de fusión (Normal, Overlay).

• Aceleración en Rust Rayon de Filtros Coronales (astroloom_rs/src/eclipse.rs, astroloom_rs/src/lib.rs):

  • Kernels nativos de alta velocidad añadidos al módulo de extensión:
    • display_detail_rings_rs: Bins anulares y cálculo multihilo de estadísticas radiales.
    • accumulate_steerable_g2_rs: Acumulación analítica del tensor de estructura y segundas derivadas.
    • compute_larson_sekanina_rs: Convolución e interpolación cúbica de Keys ($a = -0.5$) en paralelo.
    • polar_circular_median_filter_rs: Muestreo polar y mediana circular móvil optimizada.
    • compute_red_excess_mask_rs: Detección en paralelo de excesos cromáticos de protuberancias solares.
    • paired_b3_step_rs y b3_normalized_rs: Pasos convolucionales à-trous multiescala en memoria continua.

• Evolución Ergonómica de la Pestaña de Eclipses (gui/tab_eclipse.py):

  • Desplegable de algoritmos reactivo que conmuta dinámicamente los controles pertinentes: deslizador de intensidad para Steerable G2, ángulo $\Delta\theta$ y protección de protuberancias para Larson-Sekanina, ventana angular y $c_0$ para SWAP, $\sigma$ y modo Overlay para NAFE, número de escalas para WOW, y opciones avanzadas para NRGF.
  • Casillas de verificación para activar/desactivar el Traspaso Gradual HDR y la Normalización de Detalle por Anillos.
  • Botón y flujo de exportación directa a PSD Multicapa con diálogo interactivo y ejecución asíncrona mediante EclipseWorker.

Optimizado

• Invarianza de Escala en MGN (combine_mgn_scales_rs):
  • Piso de ruido y corte de varianza adaptados proporcionalmente al rango dinámico del dato flotante (data_scale), solventando variaciones espurias de microcontraste ante diferentes normalizaciones de entrada.
• Consumo de Memoria en Filtrado de Corona:
  • Acumulación in-place y reutilización de búferes contiguos en Rust, manteniendo el procesamiento de fotogramas de 24–60 MP por debajo del umbral de memoria física.

AstroLoom v0.14.1

Añadido

• Puente de Renderizado Directo a Qt sin Copias Intermedias (gui/canvas.py, src/renderer.rs):

  • Motor de renderizado nativo en Rust (render_canvas_frame_rs) que transforma datos f32, u8 y u16 directamente a un búfer contiguo plano de memoria BGRA8888, compatible de forma nativa con QImage(..., QImage.Format_RGB32).
  • Detección y pintado vectorial multihilo con Rayon de alertas de recorte (Clipping Alerts: sombras empastadas en azul #0070ff y altas luces quemadas en rojo #ff1744), eliminando la creación de capas QPixmap separadas.
  • Soporte nativo para Split-View con cortina comparadora Antes/Después (Y) vertical u horizontal en el visor del revelador y zoom directo sub-ventana 1:1 (zoom_rect).
  • Reutilización de búferes continuos preasignados (bytearray) sin recolección de basura (GC), alcanzando más de 160 FPS y una latencia de renderizado de ~6 ms en 4K (3840×2160).
  • Integración fluida en MaskCanvas (gui/canvas.py) y sincronización inmediata en gui/tab_developer.py.

• Poda Integral de Dependencias Externas y Módulos Nativos en Rust:

  • Eliminación Total de pytoshop (src/psd_writer.rs, core/psd_export.py): Escritor nativo multicapa PSD/PSB de 16 y 8 bits en Rust con compresión RLE PackBits paralela por canal y máscaras de capa nativas de Photoshop vinculadas. Exportación PSD entre $8\times$ y $15\times$ más rápida y sin dependencias externas.
  • Eliminación Total de astropy (src/fits_io.rs, core/fits_io.py): Lector y decodificador FITS nativo en Rust con lectura SIMD/Rayon de bloques estándar de 2880 bytes e inversión de endianness Little-Endian ultra-rápida (<15 ms en 60 MP). Módulo puente en Python core/fits_io.py con fallback autónomo en Python puro + NumPy.
  • Eliminación Total de psutil (src/system_info.rs, core/system_info.py): Monitorización directa de memoria RAM física del sistema operativo vía GlobalMemoryStatusEx en Windows y /proc/meminfo en Linux.

• Tiling ONNX de Redes Neuronales y Filtro Guiado O(1) (src/ai_preprocessing.rs):

  • Tiling Multihilo para StarNet++ v2 (prepare_starnet_tiles_rs y assemble_starnet_tiles_rs): Partición multihilo sin GIL en baldosas con margen reflectivo perimetral BORDER_REFLECT, estirado analítico MTF simétrico por canal con cálculo rápido de mediana/MAD por Quickselect, y recomposición paralela por solapamiento con ventana de Hann o recorte central (Center-Crop).
  • Preprocesado de NAFNet Denoise (core/ai_denoise.py): Ventana 2D de Hann analítica (compute_hann_2d_window_rs), cálculo de cuadrícula de coordenadas (get_tile_coords_rs) y acumulación/normalización in-place sin copias intermedias en Python.
  • Filtro Guiado Rápido O(1) (fast_guided_filter_rs): Filtrado guiado en tiempo constante por píxel mediante imágenes integrales de área sumada (SAT) con BORDER_REFLECT_101 para refinamiento milimétrico de máscaras de horizonte y follaje fino en ~21 ms para 1.44 MP.

• Serialización y Deserialización Paralela de Proyectos .devloom (src/project_codec.rs, core/project_io.py):

  • Empaquetado y desempaquetado de sesiones de revelador completas en formato comprimido ZIP mediante compresión multihilo Rayon y códec PNG de 16 bits nativo en Rust, acelerando drásticamente el guardado y la carga de proyectos pesados con capas y máscaras.

• Ingesta Concurrente de Lotes Masivos RAW/TIFF (src/streaming_io.rs, core/stacking.py, gui/tab_stacker.py, gui/tab_startrails.py):

  • Inspección concurrente y asíncrona de cabeceras binarias (TIFF, Nikon NEF, Canon CR2, Sony ARW, Adobe DNG, Olympus ORF, Pentax PEF, FITS, PNG, JPEG) liberando el GIL (scan_raw_batch_metadata_rs).
  • Extracción en microsegundos de dimensiones del sensor, orientación, nivel de negro, balance de blancos, estimación de temperatura de color (K), fabricante, modelo, ISO y tiempo de exposición.
  • Validación automática de tomas corruptas o ilegibles con reporte granular de errores en log sin abortar la sesión.

AstroLoom v0.14.0

Añadido

• Motor Nativo de Cómputo Astrofotográfico en Rust (astroloom_rs):

  • Implementación de la arquitectura híbrida de alto rendimiento: Interfaz Gráfica en Python (PySide6) acoplada a un núcleo de cálculo de bajo nivel en Rust compilado como módulo de extensión nativo (cdylib vía PyO3 0.23, rust-numpy 0.23, rayon 1.10 y nalgebra 0.33).
  • Vectorización SIMD y Paralelismo Multihilo: Todos los kernels numéricos intensivos liberan de forma estricta el GIL (py.allow_threads) y ejecutan en paralelo con Rayon sobre todos los núcleos lógicos de la CPU con optimizaciones AVX2/FMA y lto = "fat".
  • Arquitectura Zero-Copy y Asignación en Pila L1: Sustitución de millones de asignaciones dinámicas en el heap (malloc/free) por buffers estáticos en la pila ([f32; N]) y selección lineal $O(N)$ con Quickselect (slice.select_nth_unstable_by) para medianas y dispersión $MAD$, erradicando cuellos de botella de recolección de basura (GC).
  • Mecanismo Drop-in Fallback Universal: Todos los subsistemas de core/ incorporan autodetección dinámica de astroloom_rs con respaldo transparente y continuo hacia Python/NumPy/Numba en caso de ejecutarse en entornos sin el binario compilado.
  • Paridad Matemática y Validación Numérica: Verificación cruzada exhaustiva contra las implementaciones de referencia de Python en 18 módulos y suites de tests (diferencia máxima $&lt; 10^{-5}$, idéntica a precisión de coma flotante de 32 bits).

• Migración Integral de Módulos Críticos a astroloom_rs:

  • Motor de Apilado Estadístico y Registro Elástico TPS (core/stacking.py, src/stacking.rs):
    • Kernels paralelos kappa_sigma_kernel, percentile_kernel y median_kernel en caché L1: $2.77\times$ más rápidos que Numba LLVM JIT.
    • Solver matricial analítico de placa delgada (Thin-Plate Splines - TPS) y evaluación paralela de mallas de remapado elástico (compute_tps_grid_rs y compute_tps_remap_grid_rs), eliminando dependencias de scipy.interpolate.
  • Calibración Pura CFA Pre-Debayer In-Place (core/stacking.py, src/streaming_io.rs):
    • Calibración de Darks, Flats, Bias y pedestal térmico directamente sobre la matriz uint16 de fotodiodos de LibRaw (calibrate_raw_cfa_inplace_rs) sin crear copias intermedias en float32: 0 bytes de asignación adicional en RAM y una aceleración de $4\times$.
  • Extracción de Gradientes y Neutralización de Fondo RBF (core/background_extraction.py, src/background.rs):
    • Interpolador multiescala 2D multicuádrico inverso (fit_and_eval_rbf_proxy) en Rust sustituyendo a scipy.interpolate.RBFInterpolator.
    • Neutralizador fotométrico fusionado (apply_bg_model_fused): Sustracción/división, modulación de suelo y clamping en una sola pasada de memoria por filas (par_chunks_mut). $15.27\times$ más rápido y reducción de $-1.375\text{ MB}$ de RAM (de 1.650 MB a 274 MB en 24 MP).
  • Compositor de Capas y Pipeline del Revelador (core/mask_layers.py, core/stretch.py, src/developer.rs):
    • Kernel fusionado en paralelo (apply_layer_adjustments_fused): Evalúa transformaciones tonales HSV, balance RGB, EV, sombras, altas luces, curvas LUT y mezcla de capas en una sola pasada por píxel ($1.76\times$ a $3.2\times$ más rápido, $&lt;3\text{ ms}$ en viewport 1080p).
    • Fusión Trama (Screen Blend) de capa de estrellas: $9.84\times$ más rápida que NumPy.
    • Estirado adaptativo automático de cielo Starless (auto_stretch_adaptive_starless_rs) con estimación Quickselect de mediana/MAD y MTF por canal: $5.39\times$ más rápido.
  • Estirado Hiperbólico Generalizado (GHS) y Filtros Ópticos (core/ghs.py, core/orton.py, core/star_diffusion.py, src/developer.rs):
    • Precomputación analítica vectorizada de LUT 1D de 16 bits (65.536 puntos) en microsegundos (compute_ghs_lut_rs) con continuidad $C^1$ en puntos de inflexión LP y HP.
    • Aplicación multihilo de GHS en 2D y 3D (apply_ghs_stretch_rs) con preservación fotométrica de luminancia Rec. 709 sin reservas en heap.
    • Resplandor difuso Orton y Star Mist (compute_orton_glow_source_rs y blend_orton_and_diffusion_rs): Compuerta suave Hermite (smoothstep), supresión de picos estelares y mezcla tonal con protección de máscara de horizonte en una pasada.
  • Deconvolución Óptica Regularizada Richardson-Lucy (core/deconvolution.py, src/deconv.rs):
    • Modelado analítico de PSF 2D Moffat astrofísica con parámetro $\beta$ y elipticidad (generate_moffat_psf_rs) y PSF Gaussiana elíptica rotada (generate_gaussian_psf_rs).
    • Bucle iterativo de Richardson-Lucy en Rust (richardson_lucy_deconv_rs) con convolución espacial reflectiva de alto rendimiento (convolve2d_reflect), ping-pong buffers estáticos, amortiguación Bayesiana de ruido basada en MAD y supresión de halos perimetrales (deringing).
    • Fusión cromática reconstruida en una sola pasada con alcance selectivo ('all', 'stars_only', 'background_only').
  • Detección y Fusión Fotométrica de Meteoros (core/meteors.py, src/meteors.rs):
    • Diferencia positiva $\max(0, \text{curr} - \text{bg})$ y estimación estadística simultánea (media, desviación estándar, mediana y MAD con Quickselect) en un único barrido de memoria.
    • Generación continua subpíxel de máscara de cápsula vectorial ajustada a la trayectoria con desvanecimiento suave Hermite.
    • Fusión en modo Aclarar (Lighten) directamente sobre la caja delimitadora (bounding box) o con inserción homográfica sin alojar matrices intermedias de 288 MB por meteoro.
  • Filtros Coronales de Eclipses HDR (core/eclipse.py, src/eclipse.rs):
    • Filtro NRGF continuo (compute_nrgf_profiles_and_detail_rs, apply_nrgf_continuous_rs): Tablas radiales continuas $\mu(r), \sigma(r)$, estimación de ruido de fondo, compuerta radial suave Hermite y recomposición radiométrica RGB sin matrices 2D de radio ni ordenaciones globales ($9.41\times$ más rápido, pasando de 2.0 s a 0.21 s en 24 MP).
    • Normalización multiescala de Morgan & Druckmüller (MGN) en 6 escalas espaciales (combine_mgn_scales_rs, finalize_mgn_lum_rs) con bucles SIMD acumulando in-place ($2.53\times$ más rápido, eliminando 1.5 GB de matrices intermedias).
    • Detección paralela de protuberancias H-alfa ($R/G &gt; 1.15$), supresión adaptativa de croma según SNR y máscara lunar sin mallas densas.
  • Alineación por Asterismos y Cosido Panorámico (core/panorama.py, src/panorama.rs, src/astrometry.rs):
    • Extracción de asterismos de 4 estrellas (quads) normalizados proyectivamente en microsegundos sin GIL ($49.6\times$ más rápido, de 85.3 ms a 1.72 ms por panel).
    • Árbol k-d 4D nativo en Rust con consulta de bolas euclídeas, acumulador de votos y correspondencias mutuas en $&lt;2\text{ ms}$, sustituyendo a scipy.spatial.cKDTree.
    • Algoritmo $O(H \times W)$ de programación dinámica para recorte de rectángulo máximo inscrito sin bordes negros en $&lt;2\text{ ms}$ para panorámicas gigapíxel de más de 100 MP.
    • Emparejamiento RANSAC de triángulos estelares en Rust devolviendo la homografía directa $H$ en microsegundos.
  • Calibración Fotométrica Gaia (PCC) y Filtros Dual-Band (core/pcc.py, core/dualband.py, src/photometry.rs):
    • Regresor robusto Theil-Sen $O(N^2)$ anclado al estándar solar espectral G2V en microsegundos y aplicación paralela de factores de ganancia cromática.
    • Pipeline Dual-Band fusionado (HOO, SHO Hubble Sintético, Foraxx dinámico y Cannistra) con compensación de diafonía de sensor OSC, boost de [OIII] y atenuación de halos magenta (unpurple).
    • Detección y difusión cromática perimetral para reparación de centros estelares saturados o quemados a blanco (unclip_stars).
  • Filtros Espaciales, Supresión de Banding CMOS y Anti-Halo (core/banding.py, core/masking.py, src/spatial_filters.rs):
    • Supresión de banding CMOS horizontal y vertical en tiempo lineal $O(W)$ in-place con modelado estadístico de fondo y filtrado gaussiano 1D.
    • Fusión cielo/suelo con campo de distancias con signo (SDF), rampa cosenoidal y protección anti-ghosting de árboles en horizonte.
    • Clamping adaptativo de halos de horizonte circunscrito al bounding box perimétrico.
  • Trazas de Estrellas (Startrails) y Adaptación Cromática ICC (core/startrails.py, core/icc_manager.py, core/display_transfer.py, src/streaming_io.rs):
    • Acumulación en streaming SIMD de trazas (Lighten y efecto cometa con curvas lineal/coseno/exponencial).
    • Recuperación cromática estelar en el plano cartesiano $(u = S\cos H, v = S\sin H)$ en tiempo real (~0.4s).
    • Conversión matricial Bradford CIE D65/D50 y curvas TRC gamma en una sola pasada para sRGB, AdobeRGB 1998 y ProPhoto RGB en datos de 16 y 32 bits sin duplicar memoria.
  • Diagnóstico Óptico 3x3 y Cribado de Sesión (core/frame_culling.py, src/astrometry.rs):
    • Evaluación paralela multihilo de FWHM subpíxel, excentricidad (momentos centrales $\mu_{20}, \mu_{02}, \mu_{11}$) y censo estelar en cuadrícula 3x3 para clasificación de curvatura de campo vs sensor tilt.

Corregido

• Sincronización y Persistencia de Diagnóstico de Polvo de Sensor (gui/tab_developer.py):
  • Corrección de sincronización bidireccional entre DeveloperState y panel_dust para parámetros de visualización paso alto (dust_visualize, dust_visualize_threshold), modo de curación y sensibilidad.
  • Invalidación estricta de cachés de pipeline al añadir, mover o eliminar manchas de polvo, previniendo artefactos visuales residuales.
  • Optimización de has_state_changed para ignorar flags efímeros de visualización diagnóstica en el historial de Deshacer/Rehacer.

Mejorado

• Desacoplo de Dependencias Pesadas (scipy / numba):
  • Los subsistemas clave de apilado, RBF y panorámicas ya no dependen obligatoriamente de `sci...

AstroLoom v0.13.1

Añadido

• Detección, Curación y Diagnóstico de Manchas de Polvo de Sensor (core/dust.py y gui/developer/panels/panel_dust.py):
  • Implementación del pipeline clásico no destructivo de detección morfológica de manchas y anillos oscuros de polvo en cielo y fondo plano (detect_dust_spots) mediante diferencia gaussiana normalizada por textura local y filtros de circularidad, relación de aspecto y factor de llenado.
  • Algoritmo de selección inteligente de parche donante (pick_donor_source) que explora 48 posiciones a lo largo de 3 anillos concéntricos (2.4r, 3.2r, 4.2r), evaluando similitud de textura, varianza interna homogénea y prevención estricta de colisiones con manchas vecinas o bordes de encuadre.
  • Motor de curación continua (heal_single_spot / apply_dust_healing) con tres modalidades:
    • Curar (Tonal Seamless): Fusión de textura y gradiente mediante aproximación de Poisson / convolución normalizada sobre retícula con bordes suaves (smoothstep feathering).
    • Inpainting Puro: Reconstrucción fluida de fondo sin requerir parche donante vía Telea.
    • Clonar (Directo): Transferencia directa de píxeles desde la zona de referencia con remapado bilineal subpíxel (cv2.remap).
  • Modo de inspección de alto contraste («Visualizar Manchas» / Visualize Spots, atajo de teclado A): filtro paso alto que resalta en blanco brillante sobre negro hasta las motas más tenues y difusas del sensor, con control de umbral dinámico en tiempo real.
  • Herramientas interactivas en el lienzo (MaskCanvas en gui/canvas.py): colocación manual de manchas con clic izquierdo, arrastre libre para reubicar, eliminación con clic derecho y retículas circulares con cruz central proporcionales al zoom.
  • Integración nativa en el pipeline lineal temprano (gui/developer/pipeline.py), en el estado del revelador (DeveloperState) y en el historial completo de Deshacer (Ctrl+Z) y Rehacer (Ctrl+Y).
• Refinamiento de Bordes por Filtro Cruzado Guiado (core/masking.py:refine_mask_guided_cross / guided_cross):
  • Nuevo algoritmo de filtrado guiado cruzado O(1) con cv2.boxFilter guiado por la luminancia logarítmica de la escena (log1p(255 * L) / log(256)).
  • Imanta con precisión fotométrica los contornos y transiciones de cualquier máscara a las ramas, crestas montañosas, estructuras o siluetas reales del paisaje.
  • Integración en el Gestor de Capas (core/mask_layers.py y gui/widgets/mask_layers_widget.py) con casilla "Refinar Bordes (Guided Cross)", control de intensidad (0% a 100%) y radio adaptativo (0.04 * long_edge).
• Protección de Driver Gráfico contra Cuelgues (Crash Sentinel en core/gpu_backend.py):
  • Patrón centinela de inicialización mediante archivo marcador persistente (gpu-init.marker en AppData/directorio de configuración).
  • Si un fallo o cuelgue irrecuperable a nivel de driver gráfico de bajo nivel (CUDA / OpenCL) cierra abruptamente el proceso, el centinela permanece activo y el siguiente arranque de AstroLoom conmuta automáticamente a modo seguro CPU, evitando bucles de fallos irrecuperables.
  • Métodos de diagnóstico e inspección: is_crash_sentinel_active() y clear_gpu_crash_sentinel().
• Cálculo Fusionado de Histograma en Vivo de 1 Pasada (core/histogram.py):
  • Nuevo motor de histograma de alta velocidad que evalúa simultáneamente los canales R, G, B y Luma Rec.709 ((54*r + 183*g + 19*b) >> 8) en una sola pasada de memoria sin asignaciones intermedias.
  • Aceleración Numba JIT @njit(fastmath=True, nogil=True) con soporte nativo para float32, uint8, uint16 y monocromo, respaldado por un fallback vectorizado eficiente en OpenCV/NumPy.
  • Detección ultrarrápida y unificada de advertencias de recorte (clipping) en sombras puras (0) y altas luces quemadas (255).
  • Rediseño de gui/widgets/live_histogram.py: eliminación de las 4 pasadas independientes con np.histogram, logrando actualizaciones a más de 60 FPS durante la edición.

Corregido

• Garantía Estricta de Monotonicidad en Curvas Tonales:
  • Incorporación de np.maximum.accumulate en core/stretch.py:apply_curve_lut, core/mask_layers.py:compute_curve_lut_from_points y gui/widgets/curve_widget.py.
  • Erradicación de inversiones de pendiente, artefactos de solarización o gradientes negativos accidentales en curvas RGB y capas de ajuste.
• Estabilidad y Jerarquía de Widgets en Secciones Colapsables (CollapsibleSection):
  • Corrección en gui/widgets/collapsible_section.py:setContentLayout para detectar layouts con contenedor existente y delegar a set_content_widget, evitando excepciones o reparenting erróneo en PySide6.

AstroLoom v0.13.0

Añadido

• Extracción y Neutralización de Gradientes de Fondo por Muestreo Interactivo (RBF 2D / DBE / GraXpert):
  • Implementación en core/background_extraction.py del motor de interpolación multiescala 2D con scipy.interpolate.RBFInterpolator (base multicuádrica inversa inverse_multiquadric con regularización de curvatura epsilon=1.0).
  • Detección y generación automática de malla de puntos de ancla en el cielo (generate_sky_sample_points) con exclusión morfológica estricta del terreno terrestre (sky_mask con erosión perimétrica de seguridad de 5 px).
  • Inmunidad estelar completa en el muestreo de fondo mediante estimación de baja intensidad por percentil 15 (np.percentile(patch, 15)) dentro de cada ventana local (box_size).
  • Modelado analítico de superficies polinómicas bidimensionales de Grado 1 (lineal / plano inclinado) y Grado 2 (cuadrático / viñeteo parabólico suave) en extract_background_polynomial.
  • Soporte de dos modos matemáticos de corrección:
    • Sustracción: Para resplandores aditivos de luz (contaminación lumínica dispersa, lunas o crepúsculo).
    • División: Para gradientes ópticos multiplicativos (viñeteo o sombras de sensor).
  • Inmunidad absoluta de la silueta terrestre: preservación al 100% de los píxeles de suelo sin alteraciones, saltos tonales ni halos perimétricos en el horizonte.
  • Integración nativa profunda en el historial de Deshacer (Ctrl+Z) y Rehacer (Ctrl+Y) en gui/tab_developer.py (type: "bg_extract").
• Herramientas de Muestreo de Fondo en el Lienzo (MaskCanvas en gui/canvas.py):
  • Modo interactivo de edición de puntos (bg_sample_mode):
    • Clic izquierdo: Añadir un nuevo punto o hacer clic y arrastrar para reposicionar un punto existente.
    • Clic derecho: Eliminar el punto seleccionado bajo el cursor.
  • Representación visual intuitiva de las cajas de muestra con bordes luminosos y centro con retícula, adaptándose al nivel de zoom (coordenadas normalizadas [0.0, 1.0] inmunes al encuadre o zoom 1:1).
  • Indicador dinámico en tiempo real del recuento de puntos de muestreo en el panel del revelador.
• Recuadro de Color Interactivo (Swatch) y Pipeta de Tinte para Contaminación Lumínica:
  • Incorporación en gui/developer/panels/panel_light_pollution.py de un recuadro visual de color (btn_lp_swatch / lbl_tint_swatch) de 22×22 px junto al selector de tinte, reflejando en tiempo real el color espectral activo (ámbar de sodio, LED cálido, LED frío, blanco neutro o personalizado).
  • Interacción directa con el selector de color del sistema: un clic sobre el recuadro abre QColorDialog para seleccionar o ajustar cualquier color RGB manualmente.
  • Insignia y cursor contextualizados en el lienzo (_draw_eyedropper_badge en gui/canvas.py): la pipeta muestra mensajes dinámicos según el objetivo de la muestra ("Clic: balancear WB", "Clic: punto simetría SP", "Clic: centro cúpula LP", "Clic: muestrear tinte LP", "Clic: seleccionar color").
• Modernización del Sistema de Temas y Chevrons Vectoriales SVG:
  • Creación de iconos vectoriales SVG para flechas de colapso y despliegue (chevron_up.svg, chevron_down.svg, chevron_up_hover.svg, chevron_down_hover.svg, chevron_up_disabled.svg, chevron_down_disabled.svg) en gui/assets/.
  • Integración en gui/theme.py y gui/main_window.py para erradicar el renderizado inconsistente de caracteres Unicode en diferentes versiones de Windows.
  • Refinamiento de estilos de barras de desplazamiento (scrollbars), bordes sutiles y ergonomía de paneles laterales.

Corregido

• Mapeo de Presets Cromáticos de Contaminación Lumínica en el Pipeline:
  • Corrección en gui/developer/pipeline.py de la lista de identificadores de presets (["sodium", "warm_led", "cold_led", "neutral", "custom"]), resolviendo un desajuste crítico que provocaba que todos los presets excepto sodio cayeran al fallback predeterminado de vapor de sodio.
• Sincronización Bidireccional de la Pipeta de Tinte con el Panel Modular:
  • Corrección en gui/tab_developer.py:_on_eyedropper_color_sampled: la captura de tinte ahora invoca self.panel_lp.set_custom_tint(), actualizando correctamente el estado paramétrico, el combo selector y el recuadro de color visual.
  • Muestreo espectral directo desde el búfer lineal previo a la cúpula (_cache_ms_pre_lp_img), asegurando que la muestra capture el balance de blancos real de la toma sin verse falseada por el estirado no lineal posterior.
  • Erradicación del efecto en el que la reducción de contaminación lumínica viraba permanentemente hacia el azul al muestrear colores no amarillos.

Mejorado

• Reorganización Estructural del Flujo de Trabajo en el Revelador:
  • Reordenación pedagógica de las secciones del acordeón en gui/tab_developer.py y paneles modulares:
    1. Paisaje y Máscara de Suelo (Horizonte IA)
    2. Balance de Blancos y Calibración
    3. Gradientes y Contaminación Lumínica
    4. Estirado Tonal y Contraste
    5. Desacoplo Estelar y Fondo
       [Avanzado] Deconvolución Óptica y Enfoque (R-L)
       Máscaras y Capas de Ajuste Local
• Localización Completa (ES / EN):
  • Incorporación de todas las cadenas de interfaz y mensajes de registro para el nuevo motor RBF, cajas de muestreo, modelos polinómicos y herramientas interactivas de gradientes.

AstroLoom v0.12.2

Corregido

• Estabilidad Dimensional de Máscaras y Resolución de IndexError en el Revelador:
  • Corrección en core/masking.py:shift_mask_edge para preservar la profundidad de canales (mask.shape[2]), impidiendo que el desplazamiento perimétrico de máscara reduzca matrices RGB tridimensionales a un único canal (H, W, 1).
  • Normalización dimensional en gui/developer/pipeline.py:apply_developer_pipeline para expandir de forma robusta máscaras 2D o monocanal a 3 canales cuando la imagen de trabajo es RGB.
  • Blindaje con vista 2D de máscara (stretched[mask_2d > 0.5]) en el cálculo de mediana de cielo para el contraste selectivo de fondo starless (contrast_starless), neutralizando fallos de dimensionalidad durante scrubbing interactivo y refresco en zoom 1:1.
  • Normalización 2D segura en gui/tab_developer.py:_compose_active_base al generar mask_3d en exportación y previsualización con zoom 100%.
  • Protección dimensional de entrada análoga en core/banding.py:suppress_cmos_banding, core/starnet_bridge.py:run_starnet y core/starnet_onnx.py:run_starnet_onnx.

AstroLoom v0.12.1

Añadido

• Calibración Fotométrica del Color (PCC Real contra Catálogo Gaia DR3 / Locus Estelar G2V):
  • Implementación en core/pcc.py de fotometría de apertura circular con sustracción de anillo de fondo sobre estrellas no saturadas (detect_stars_photometry).
  • Ajuste de regresión robusta Theil-Sen (fit_theil_sen_pcc) sobre las razones $\log(R/G)$ y $\log(B/G)$ referenciadas a los índices de color del catálogo Gaia $(BP - RP)$.
  • Anclaje fotométrico riguroso al estándar solar espectral G2V ($(BP - RP) = 0.82$) con estimación robusta de locus estelar en modo offline cuando no hay metadatos astrométricos de campo.
  • Aplicación no destructiva de ganancias fotométricas (apply_pcc_gains) que calibra el color físico exacto de las estrellas preservando la neutralidad del fondo cósmico.
  • Integración en el panel de balance de blancos (gui/developer/panels/panel_color_wb.py) con botón de acción Calibración PCC (Gaia), estado dinámico en vivo y botón de restablecimiento.
• Procesado Especializado de Filtros Dual-Band OSC y Paletas de Banda Estrecha:
  • Implementación en core/dualband.py:extract_ha_oiii y apply_dualband_palette de extracción matemática de $H\alpha$ y $[OIII]$ desde sensores de color OSC con compensación de diafonía cromática (crosstalk).
  • Incorporación de 4 paletas astronómicas clásicas y modernas para astrofotografía de emisión:
    • HOO Bicolor: Mapeo natural ($R = H\alpha$, $G/B = [OIII]$).
    • SHO Hubble Sintético: Generación de canal $SII$ sintético ponderado desde $H\alpha$ y composición tricromática con gradiente de contraste.
    • Foraxx Dinámico: Modulación no lineal del canal verde basada en solapamiento de intensidades relativas de $H\alpha$ y $[OIII]$.
    • Cannistra Bicolor: Fusión adaptativa en el canal verde preservando la visibilidad de filamentos débiles de $[OIII]$.
  • Control de ganancia Boost [OIII] paramétrico (0.10x a 3.00x) y sección colapsable dedicada en el Revelador (Paletas Dual-Band y Corrección Estelar).
• Herramientas de Corrección y Reparación Estelar Avanzada:
  • Recuperación de Núcleos Saturados (Unclip Stars): Función unclip_stars en core/dualband.py que calcula las proporciones cromáticas reales en la periferia no saturada del disco estelar y las proyecta hacia el centro sobreexpuesto, erradicando núcleos estelares lavados o quemados a blanco plano.
  • Supresión de Aberración Cromática y Halos Magenta (Unpurple): Algoritmo selectivo en core/dualband.py:unpurple que reduce halos púrpuras y violetas en bordes de estrellas brillantes sin comprometer la nebulosidad legítima de hidrógeno alfa ($H\alpha$).
• Supresión de Ruido Banding CMOS de Sensor (Banding Reduction):
  • Nuevo módulo algorítmico en core/banding.py:suppress_cmos_banding para erradicar patrones de líneas y bandas estructuradas originadas por conversores ADC y raíles de potencia en sensores CMOS a sensibilidades ISO elevadas.
  • Protección de estrellas y nebulosas mediante máscara adaptativa basada en la mediana y desviación absoluta respecto a la mediana (MAD) del fondo.
  • Separación de frecuencias por filtrado paso bajo 1D gaussiano para suprimir exclusivamente el banding de alta frecuencia sin alterar gradientes astronómicos suaves.
  • Controles en el Revelador (panel_starnet.py): deslizador de intensidad (0% a 100%) y selector de orientación (Horizontal, Vertical o Ambos ejes).
• Alineación Elástica No Rígida por Thin Plate Splines (TPS con Remap Lanczos4):
  • Implementación en core/stacking.py:compute_tps_remap_grid de deformación elástica subpíxel por mallas Thin Plate Splines combinada con interpolación cv2.INTER_LANCZOS4.
  • Resuelve la distorsión periférica diferencial en las esquinas generada por rotación de campo en objetivos gran angular y reflectores en modo seguimiento (tracker / cielo profundo).
• Diagnóstico Óptico 3x3 de Campo y Sesión (Curvatura vs Sensor Tilt):
  • Implementación en core/frame_culling.py:compute_3x3_optical_diagnosis de rejilla 3x3 para mapear FWHM y excentricidad en centro, laterales y esquinas del encuadre.
  • Clasificación analítica de anomalías: Curvatura de campo simétrica vs Inclinación de sensor (Sensor Tilt) / flexión mecánica.
  • Diagnóstico individual integrado en el tooltip del badge de calidad de la lista de tomas (FileListRow).
  • Diagnóstico sintético global de sesión (diagnose_session_optics) emitido en el registro del Apilador con recomendaciones de ajuste de backfocus, colimación o espaciado del aplanador.
• Calibración Matemática en Espacio Puro CFA (Pre-Debayer):
  • Soporte en core/stacking.py:load_image_as_float32 para restar el exceso térmico del Master Dark y normalizar por Master Flat directamente sobre los fotositos de la matriz Bayer (CFA) antes de la interpolación de color.

Mejorado

• Ergonomía de Ingesta en el Apilador (Sección 2: Calibración y Tomas):
  • Reubicación de los botones «Añadir Tomas...» y «Limpiar Pestaña» al inicio de la Sección 2 en gui/tab_stacker.py, situándolos en la cabecera directamente encima de las pestañas (Lights, Darks, Flats, Bias, Suelo).
  • Evita que los botones de carga queden desplazados hacia abajo o por debajo de la barra de control de calidad y cribado estelar (culling_bar).
• Robustez de Integración Kappa-Sigma:
  • Ajuste de umbral de máscara a channel_data > -0.5 en los bucles de acumulación en core/stacking.py para prevenir exclusiones indebidas de valores oscuros válidos.
  • Aseguramiento de rango físico [0.0, 1.0] mediante recorte in-place en la salida final apilada (stream_stack_auto).

AstroLoom v0.12.0

Añadido

• Nuevo Módulo Dedicado: Lluvias de Meteoros (gui/tab_meteors.py y core/meteors.py):
  • Detección Algorítmica Acelerada con Numba: Sustracción temporal diferencial continua _numba_positive_diff_and_stats (nogil) y estimación robusta de ruido del cielo (MAD) para procesar cientos de tomas nocturnas a máxima velocidad.
  • Arquitectura Híbrida Rendimiento/Resolución: Escaneo ultra-rápido en binning 2:1 (load_fast_meteor_frame, ~20s para 160+ tomas RAW Nikon NEF, Sony ARW, Canon CR2/CR3, DNG) y composición final con fidelidad nativa al 100% (resolución 1:1) exclusivamente para las tomas seleccionadas.
  • Fusión Fotométrica en Modo Aclarar (Lighten) con Calibración RGB:
    • Estimación robusta del pedestal de cielo por canal RGB (percentil 30) en el entorno local del bólido y en la imagen base, eliminando cualquier dominante de color o alteración cromática.
    • Máscara vectorial en cápsula ajustada al FWHM de la traza con desvanecimiento gaussiano suave y puerta de ruido adaptativa (Noise Gate a 2.0σ).
    • Fusión en modo Aclarar: out_img += mask * max(0.0, patch_calibrado - out_img), erradicando al 100% la acumulación de ruido estocástico, la duplicación/engorde de estrellas y las auras luminosas artificiales.
  • Discriminación Inteligente de Satélites y Falsos Positivos:
    • Persistencia orbital multicuadro: Descarte automático de trazas colineales que continúan a lo largo de 2 o 3 fotogramas consecutivos con el mismo rumbo.
    • Cruces intra-fotograma: Descarte de trazas que se intersectan en la misma exposición (geometría orbital incompatible con meteoroides).
    • Filtro de continuidad de haz: Comprobación de perfil longitudinal (iluminación continua con análisis de huecos oscuros internos) para evitar falsos positivos por alineaciones casuales de estrellas.
  • Discriminación Cromática Adaptativa de Aviones:
    • Evaluación de exceso cromático relativo diferencial $(\Delta R, \Delta G, \Delta B)$ sobre el fondo del cielo local, inmune a fotos subexpuestas o de bajo flujo.
    • Detección de balizas bicolores simultáneas (luces rojas a babor y verdes a estribor) y análisis de estrobos periódicos pulsantes con prominencia de caída entre destellos.
  • Reproyección Homográfica al Radiante Celeste:
    • Cálculo de matrices homográficas $H$ mediante asterismos estelares invariantes y RANSAC (compute_frame_homography_to_ref), compensando la rotación diurna de la Tierra para proyectar cada meteoro a su constelación de origen.
    • Estimación por mínimos cuadrados del punto radiante óptimo e identificación automática de meteoros de la lluvia vs. esporádicos.
  • Galería de Culling y Lienzo Gráfico Interactivo:
    • Tabla interactiva con censo detallado (longitud, ángulo, flujo pico, divergencia respecto al radiante y continuidad de haz).
    • Selección de usuario como verdad absoluta (is_meteor) respetada estrictamente en la composición.
    • Botón de alternancia de visualización [Ver Compuesto] / [Ver Toma] para comparar el compuesto final contra tomas individuales sin perder el resultado.
    • Retículas de resalte vectorial individuales y modo colectivo [👁️ Resaltar Todas], con centrado y zoom 1:1 en el lienzo.
  • Exportación Multicapa PSD (Photoshop 16-bit):
    • Generación nativa de archivos PSD de 16 bits (pytoshop) con cada meteoro en su propia capa independiente en modo Lighten sobre fondo transparente.
    • Optimización por caja delimitadora (Bounding Box): recorte espacial de cada capa al área activa del bólido, reduciendo el tamaño del archivo PSD de más de 2 GB a ~150 MB.
    • Inclusión de vista previa compuesta previa (ImageData) para miniaturas en exploradores.
  • Persistencia de Sesión Completa (.astrometeor):
    • Guardado y restauración de tomas cargadas, toma de referencia, máscara de suelo, candidatos detectados, clasificación y parámetros de fusión.

AstroLoom v0.11.6

Añadido

• Módulo de Panorámicas: Modo Ráfaga y Apilado Previo por Tesela (Burst Stacking):
  • Implementación en core/panorama.py:stack_and_stitch_nightscape_panorama y gui/tab_panorama.py de una canalización integral de 2 fases: pre-apilado multihilo de reducción de ruido en cada panel antes del cosido geométrico final.
  • Modos de agrupación por tesela: selección fija de tomas (2 a 10 tomas por panel) o detección automática temporal por marca de tiempo EXIF (group_panel_paths).
  • Soporte para monturas astronómicas: modo Trípode Fijo (alineación traslacional para suprimir ruido sin deformar el horizonte) y modo Star Tracker (compensación de rotación sidérea y seguimiento estelar).
  • Desacoplamiento inteligente de cielo y suelo mediante auto-máscara IA (compose_sky_ground_with_anti_ghosting): apilado dual por tesela con transición continua en el horizonte y eliminación de estelas fantasma (ghosting).
• Módulo de Panorámicas: Motor de Alineación Guiada por Estrellas (Star Triangle Matching):
  • Nuevo pipeline de registro astronómico en core/panorama.py:
    • Extracción morfológica de estrellas brillantes con filtrado Top-Hat y refinamiento de centroides subpíxel (extract_bright_stars).
    • Construcción de descriptores invariantes de triángulos estelares / asterismos (build_star_triangle_descriptors) basados en ratios métricas de lados y ángulos.
    • Correspondencia espacial acelerada con k-d tree (match_star_triangles) y estimación homográfica robusta RANSAC para coser teselas nocturnas profundas donde algoritmos tradicionales de visión artificial (ORB/SIFT) fallan por falta de textura diurna.
• Módulo de Panorámicas: Compensación Automática de Viñeteo:
  • Estimación estadística en core/panorama.py:estimate_series_vignetting de la caída perimétrica de luz en bordes y esquinas a partir del fondo de cielo de la serie panorámica.
  • Modelado radial de ganancia (apply_vignette_compensation) para ecualizar la iluminación entre fotogramas adyacentes y erradicar bandas oscuras o costuras verticales.
• Módulo de Panorámicas: Control de Curvatura de Arco (Arch Curvature):
  • Control de deformación geométrica vertical en la proyección cilíndrica/esférica para nivelar o acentuar el arco de la Vía Láctea según la composición deseada.
• Módulo de Panorámicas: Persistencia Completa de Sesión (.astropano):
  • Serialización y restauración integral en save_panorama_session y load_panorama_session de paneles activos, modo ráfaga, parámetros de montura, estado de inclusión individual, geometría y ajustes fotométricos.

Corregido

• Eclipses: Prevención de Cierre Abrupto (Crash) por Concurrencia de Workers:
  • Deshabilitación de botones de acción (btn_apply_filters y btn_detect_all) durante la ejecución de la fusión HDR bracketing en gui/tab_eclipse.py.
  • Protección con guardas contra sobreescritura del hilo QThread (EclipseWorker) en ejecución nativa, evitando el fallo de terminación forzada del proceso Qt (QThread: Destroyed while thread is still running).
  • Reactivación coordinada y estilización de estado deshabilitado (QPushButton:disabled) en el botón de filtros coronales.
• Revelador: Ajuste Dimensional y Recorte de Capas StarNet en Zoom 1:1:
  • Corrección en gui/tab_developer.py: recorte espacial coordinado de las capas sin estrellas (image_starless) y sólo estrellas (image_stars) al activar la inspección a resolución nativa del 100%.
  • Escalado y alineación del subrecorte para el caché de reducción de ruido neuronal Starless AI Denoise (_process_starless_base), eliminando desajustes de escala y artefactos de estiramiento en el lienzo.
• Lienzo (Canvas): Desacoplamiento de Interacciones de Paneo y Máscara:
  • Corrección en gui/canvas.py: navegación fluida con barra espaciadora o botón izquierdo del ratón en niveles de zoom elevados, evitando activaciones accidentales del cursor de mano abierta cuando las herramientas de trazado o pincel de máscara están operativas.