setiastrosuitepro 1.6.12__py3-none-any.whl → 1.7.1.post2__py3-none-any.whl

setiastro/images/TextureClarity.svg

@@ -0,0 +1,56 @@
+<svg width="500" height="500" viewBox="0 0 500 500" xmlns="http://www.w3.org/2000/svg">
+  <defs>
+    <linearGradient id="skyGradient" x1="0%" y1="0%" x2="0%" y2="100%">
+      <stop offset="0%" style="stop-color:#0d0221;stop-opacity:1" />
+      <stop offset="100%" style="stop-color:#2a0e66;stop-opacity:1" />
+    </linearGradient>
+    <linearGradient id="sunGradient" x1="0%" y1="0%" x2="0%" y2="100%">
+      <stop offset="0%" style="stop-color:#ff9a00;stop-opacity:1" />
+      <stop offset="40%" style="stop-color:#ff0055;stop-opacity:1" />
+      <stop offset="100%" style="stop-color:#9900ff;stop-opacity:1" />
+    </linearGradient>
+    <linearGradient id="textGradient" x1="0%" y1="0%" x2="100%" y2="100%">
+      <stop offset="0%" style="stop-color:#00ffff;stop-opacity:1" />
+      <stop offset="100%" style="stop-color:#ff00ff;stop-opacity:1" />
+    </linearGradient>
+    <filter id="neonGlow" x="-50%" y="-50%" width="200%" height="200%">
+      <feGaussianBlur stdDeviation="3.0" result="coloredBlur"/>
+      <feMerge>
+        <feMergeNode in="coloredBlur"/>
+        <feMergeNode in="SourceGraphic"/>
+      </feMerge>
+    </filter>
+  </defs>
+  <rect width="500" height="500" fill="url(#skyGradient)" />
+  <g transform="translate(250, 220)">
+    <circle r="120" fill="url(#sunGradient)" />
+    <rect x="-120" y="20" width="240" height="4" fill="#2a0e66" opacity="0.8" />
+    <rect x="-120" y="35" width="240" height="6" fill="#2a0e66" opacity="0.8" />
+    <rect x="-120" y="52" width="240" height="8" fill="#2a0e66" opacity="0.8" />
+    <rect x="-120" y="72" width="240" height="12" fill="#2a0e66" opacity="0.8" />
+    <rect x="-120" y="96" width="240" height="16" fill="#2a0e66" opacity="0.8" />
+  </g>
+  <g stroke="#ff00ff" stroke-width="2" opacity="0.4">
+    <line x1="0" y1="350" x2="500" y2="350" />
+    <line x1="0" y1="380" x2="500" y2="380" />
+    <line x1="0" y1="420" x2="500" y2="420" />
+    <line x1="0" y1="470" x2="500" y2="470" />
+    <line x1="250" y1="350" x2="250" y2="500" />
+    <line x1="250" y1="350" x2="50" y2="500" />
+    <line x1="250" y1="350" x2="-150" y2="500" />
+    <line x1="250" y1="350" x2="450" y2="500" />
+    <line x1="250" y1="350" x2="650" y2="500" />
+  </g>
+  <g font-family="'Times New Roman', Times, serif" font-weight="bold" font-style="italic" font-size="360" text-anchor="middle">
+    <text x="217" y="390" fill="#00ffff" opacity="0.7">TC</text>
+    <text x="233" y="390" fill="#ff0055" opacity="0.7">TC</text>
+    <text x="225" y="390" fill="url(#textGradient)" stroke="#ffffff" stroke-width="3" filter="url(#neonGlow)">TC</text>
+  </g>
+  <g fill="#ffffff" opacity="0.8">
+    <circle cx="50" cy="50" r="2" />
+    <circle cx="450" cy="80" r="2" />
+    <circle cx="100" cy="150" r="1.5" />
+    <circle cx="400" cy="20" r="1.5" />
+    <path d="M420 120 L422 130 L432 132 L422 134 L420 144 L418 134 L408 132 L418 130 Z" fill="#00ffff" />
+  </g>
+</svg>

setiastro/saspro/_generated/build_info.py

@@ -1,3 +1,3 @@
 # Auto-generated at build time. Do not edit.
-BUILD_TIMESTAMP = "2026-01-07T16:45:00Z"
-APP_VERSION = "1.6.12"
+BUILD_TIMESTAMP = "2026-01-15T16:55:53Z"
+APP_VERSION = "1.7.1.post2"

setiastro/saspro/aberration_ai.py

@@ -7,13 +7,37 @@ import numpy as np
 import sys
 import platform  # add
 import time
+import subprocess
 
 IS_APPLE_ARM = (sys.platform == "darwin" and platform.machine() == "arm64")
 
+def _has_nvidia_gpu() -> bool:
+    """Check if system has an NVIDIA GPU (Linux/Windows)."""
+    try:
+        if platform.system() == "Linux":
+            r = subprocess.run(["nvidia-smi", "-L"], capture_output=True, timeout=2)
+            return "GPU" in (r.stdout.decode("utf-8", errors="ignore") or "")
+        elif platform.system() == "Windows":
+            try:
+                ps = subprocess.run(
+                    ["powershell", "-NoProfile", "-Command",
+                     "(Get-CimInstance Win32_VideoController | Select-Object -ExpandProperty Name) -join ';'"],
+                    capture_output=True, timeout=2
+                )
+                out = (ps.stdout.decode("utf-8", errors="ignore") or "").lower()
+                return "nvidia" in out
+            except Exception:
+                w = subprocess.run(["wmic", "path", "win32_VideoController", "get", "name"],
+                                  capture_output=True, timeout=2)
+                return "nvidia" in (w.stdout.decode("utf-8", errors="ignore") or "").lower()
+    except Exception:
+        pass
+    return False
+
 from PyQt6.QtCore import Qt, QThread, pyqtSignal, QStandardPaths, QSettings
 from PyQt6.QtWidgets import (
     QDialog, QVBoxLayout, QHBoxLayout, QLabel, QPushButton, QFileDialog,
-    QComboBox, QSpinBox, QProgressBar, QMessageBox, QCheckBox, QLineEdit
+    QComboBox, QSpinBox, QProgressBar, QMessageBox, QCheckBox, QLineEdit, QApplication
 )
 from PyQt6.QtGui import QIcon
 from setiastro.saspro.config import Config
@@ -145,10 +169,13 @@ def _restore_output(arr: np.ndarray, channels_last: bool, was_uint16: bool, H: i
         arr = arr[0]                 # (H,W)
     return arr
 
-def run_onnx_tiled(session, img: np.ndarray, patch_size=512, overlap=64, progress_cb=None) -> np.ndarray:
+def run_onnx_tiled(session, img: np.ndarray, patch_size=512, overlap=64,
+                  progress_cb=None, cancel_cb=None) -> np.ndarray:
     """
     session: onnxruntime.InferenceSession
     img: mono (H,W) or RGB (H,W,3) numpy array
+
+    cancel_cb: callable -> bool, return True to cancel
     """
     arr, channels_last, was_uint16 = _prepare_input(img)      # (C,H,W)
     arr, H0, W0 = _pad_C_HW(arr, patch_size)
@@ -168,11 +195,15 @@ def run_onnx_tiled(session, img: np.ndarray, patch_size=512, overlap=64, progres
     for c in range(C):
         for i in hs:
             for j in ws:
-                patch = arr[c:c+1, i:i+patch_size, j:j+patch_size]  # (1, P, P)
+                if cancel_cb and cancel_cb():
+                    raise RuntimeError("Canceled")
+
+                patch = arr[c:c+1, i:i+patch_size, j:j+patch_size]  # (1,P,P)
                 inp = np.ascontiguousarray(patch[np.newaxis, ...], dtype=np.float32)  # (1,1,P,P)
 
                 out_patch = session.run(None, {inp_name: inp})[0]   # (1,1,P,P)
                 out_patch = np.squeeze(out_patch, axis=0)           # (1,P,P)
+
                 out[c:c+1, i:i+patch_size, j:j+patch_size] += out_patch * win
                 wgt[c:c+1, i:i+patch_size, j:j+patch_size] += win
 
@@ -184,7 +215,6 @@ def run_onnx_tiled(session, img: np.ndarray, patch_size=512, overlap=64, progres
     arr = out / wgt
     return _restore_output(arr, channels_last, was_uint16, H0, W0)
 
-
 # ---------- providers ----------
 def pick_providers(auto_gpu=True) -> list[str]:
     """
@@ -248,9 +278,11 @@ def _preserve_border(dst: np.ndarray, src: np.ndarray, px: int = 10) -> np.ndarr
 
 # ---------- worker ----------
 class _ONNXWorker(QThread):
-    progressed = pyqtSignal(int)         # 0..100
-    failed     = pyqtSignal(str)
-    finished_ok= pyqtSignal(np.ndarray)
+    progressed   = pyqtSignal(int)          # 0..100
+    failed       = pyqtSignal(str)
+    finished_ok  = pyqtSignal(np.ndarray)
+    canceled     = pyqtSignal()
+    log_message  = pyqtSignal(str)          # for console logging
 
     def __init__(self, model_path: str, image: np.ndarray, patch: int, overlap: int, providers: list[str]):
         super().__init__()
@@ -260,33 +292,115 @@ class _ONNXWorker(QThread):
         self.overlap = overlap
         self.providers = providers
         self.used_provider = None
+        self._cancel = False  # cooperative flag
+
+    def cancel(self):
+        # Safe to call from UI thread
+        self._cancel = True
+        self.requestInterruption()
+
+    def _is_canceled(self) -> bool:
+        return self._cancel or self.isInterruptionRequested()
 
     def run(self):
         if ort is None:
             self.failed.emit("onnxruntime is not installed.")
             return
+
+        # If canceled before start, exit cleanly
+        if self._is_canceled():
+            self.canceled.emit()
+            return
+
+        # Log available providers for debugging
+        avail_providers = ort.get_available_providers()
+        gpu_providers = [p for p in self.providers if p != "CPUExecutionProvider"]
+        has_nvidia = _has_nvidia_gpu()
+        
+        self.log_message.emit(f"🔍 Available ONNX providers: {', '.join(avail_providers)}")
+        self.log_message.emit(f"🔍 Attempting providers: {', '.join(self.providers)}")
+        print(f"🔍 Available ONNX providers: {', '.join(avail_providers)}")
+        print(f"🔍 Attempting providers: {', '.join(self.providers)}")
+        
+        # Check if NVIDIA GPU is present but CUDA provider is missing
+        if has_nvidia and "CUDAExecutionProvider" not in avail_providers:
+            msg = ("⚠️ GPU NVIDIA détecté mais CUDAExecutionProvider n'est pas disponible.\n"
+                   "   Vous devez installer 'onnxruntime-gpu' au lieu de 'onnxruntime'.\n"
+                   "   Commande: pip uninstall onnxruntime && pip install onnxruntime-gpu")
+            self.log_message.emit(msg)
+            print(msg)
+        
         try:
             sess = ort.InferenceSession(self.model_path, providers=self.providers)
             self.used_provider = (sess.get_providers()[0] if sess.get_providers() else None)
-        except Exception:
+            # Log successful GPU usage
+            if self.used_provider != "CPUExecutionProvider" and gpu_providers:
+                msg = f"✅ Aberration AI: Using GPU provider {self.used_provider}"
+                self.log_message.emit(msg)
+                print(msg)
+            elif has_nvidia and self.used_provider == "CPUExecutionProvider":
+                msg = ("⚠️ GPU NVIDIA détecté mais utilisation du CPU.\n"
+                       "   Installez 'onnxruntime-gpu' pour utiliser le GPU.")
+                self.log_message.emit(msg)
+                print(msg)
+        except Exception as e:
+            # Log the actual error for debugging
+            error_msg = str(e)
+            msg = f"⚠️ Aberration AI: GPU provider failed: {error_msg}"
+            self.log_message.emit(msg)
+            print(msg)
+            self.log_message.emit(f"Available providers: {', '.join(avail_providers)}")
+            print(f"Available providers: {', '.join(avail_providers)}")
+            self.log_message.emit(f"Attempted providers: {', '.join(self.providers)}")
+            print(f"Attempted providers: {', '.join(self.providers)}")
+            
+            # Check if onnxruntime-gpu is installed (CUDA provider should be available if it is)
+            if "CUDAExecutionProvider" in self.providers and "CUDAExecutionProvider" not in avail_providers:
+                if has_nvidia:
+                    msg = ("❌ CUDAExecutionProvider non disponible alors qu'un GPU NVIDIA est présent.\n"
+                           "   Installez 'onnxruntime-gpu': pip uninstall onnxruntime && pip install onnxruntime-gpu")
+                else:
+                    msg = "⚠️ CUDAExecutionProvider not available. You may need to install onnxruntime-gpu instead of onnxruntime."
+                self.log_message.emit(msg)
+                print(msg)
+            
             # fallback CPU if GPU fails
             try:
                 sess = ort.InferenceSession(self.model_path, providers=["CPUExecutionProvider"])
-                self.used_provider = "CPUExecutionProvider"  # NEW
+                self.used_provider = "CPUExecutionProvider"
+                msg = f"⚠️ Aberration AI: Falling back to CPU (GPU initialization failed: {error_msg})"
+                self.log_message.emit(msg)
+                print(msg)
             except Exception as e2:
-                self.failed.emit(f"Failed to init ONNX session:\n{e2}")
+                self.failed.emit(f"Failed to init ONNX session:\nGPU error: {error_msg}\nCPU error: {e2}")
                 return
 
         def cb(frac):
             self.progressed.emit(int(frac * 100))
 
         try:
-            out = run_onnx_tiled(sess, self.image, self.patch, self.overlap, cb)
+            out = run_onnx_tiled(
+                sess,
+                self.image,
+                self.patch,
+                self.overlap,
+                progress_cb=cb,
+                cancel_cb=self._is_canceled,
+            )
         except Exception as e:
-            self.failed.emit(str(e)); return
+            # Normalize cancel
+            msg = str(e) or "Error"
+            if "Canceled" in msg:
+                self.canceled.emit()
+            else:
+                self.failed.emit(msg)
+            return
 
-        self.finished_ok.emit(out)
+        if self._is_canceled():
+            self.canceled.emit()
+            return
 
+        self.finished_ok.emit(out)
 
 # ---------- dialog ----------
 class AberrationAIDialog(QDialog):
@@ -758,6 +872,7 @@ class AberrationAIDialog(QDialog):
         self._worker.failed.connect(self._on_failed)
         self._worker.finished_ok.connect(self._on_ok)
         self._worker.finished.connect(self._on_worker_finished)
+        self._worker.log_message.connect(self._log)  # Connect log messages to console
         self._worker.start()
 
 

setiastro/saspro/aberration_ai_preset.py

@@ -4,7 +4,7 @@ import os
 import time
 import numpy as np
 from PyQt6.QtCore import QTimer
-from PyQt6.QtWidgets import QDialog, QVBoxLayout, QProgressBar, QPushButton, QMessageBox, QFormLayout, QDialogButtonBox, QSpinBox, QCheckBox, QComboBox, QLabel
+from PyQt6.QtWidgets import QDialog, QVBoxLayout, QProgressBar, QPushButton, QMessageBox, QFormLayout, QDialogButtonBox, QSpinBox, QCheckBox, QComboBox, QLabel, QApplication
 
 from PyQt6.QtCore import QSettings
 # reuse everything from the UI module
@@ -91,13 +91,29 @@ def run_aberration_ai_via_preset(main, preset: dict | None = None, doc=None):
     worker = _ONNXWorker(model, img, patch, overlap, providers)
     worker.progressed.connect(bar.setValue)
 
+    def _cancel_clicked():
+        btn.setEnabled(False)
+        btn.setText("Canceling…")
+        worker.cancel()  # <-- SAFE
+        QApplication.processEvents()
+
     def _fail(msg: str):
         try:
             if hasattr(main, "_log"):
                 main._log(f"❌ Aberration AI failed: {msg}")
         except Exception:
             pass
-        QMessageBox.critical(main, "Aberration AI", msg)
+        # If canceled, don't pop an error box
+        if "Canceled" not in (msg or ""):
+            QMessageBox.critical(main, "Aberration AI", msg)
+        dlg.close()
+
+    def _canceled():
+        try:
+            if hasattr(main, "_log"):
+                main._log("⛔ Aberration AI canceled.")
+        except Exception:
+            pass
         dlg.close()
 
     def _ok(out: np.ndarray):
@@ -157,13 +173,23 @@ def run_aberration_ai_via_preset(main, preset: dict | None = None, doc=None):
             dlg.close()
 
     worker.failed.connect(_fail)
+    worker.canceled.connect(_canceled)          # <-- NEW
     worker.finished_ok.connect(_ok)
     worker.finished.connect(lambda: btn.setEnabled(False))
-    btn.clicked.connect(worker.terminate)
+
+    btn.clicked.connect(_cancel_clicked)
+
+    # If user closes dialog via window X, also cancel
+    dlg.rejected.connect(_cancel_clicked)
 
     worker.start()
     dlg.exec()
 
+    # Ensure the worker is not left running after the modal closes
+    if worker.isRunning():
+        worker.cancel()
+        worker.wait(2000)  # don't hang forever; just give it a moment
+
     # clear the guard after a brief tick so downstream signals don’t re-open UI
     def _clear():
         for k in ("_aberration_ai_headless_running", "_aberration_ai_guard"):

setiastro/saspro/astrospike_python.py

@@ -685,9 +685,51 @@ def render_spikes(output: np.ndarray, stars: List[Star], config: SpikeConfig, ct
         
         # Main spikes
         if config.intensity > 0:
-            for i in range(qty):
-                theta = main_angle_rad + (i * (math.pi * 2) / float(qty))
-                ...
+            rainbow_str = config.rainbow_spike_intensity if (config.enable_rainbow and config.rainbow_spikes) else 0
+            for i in range(int(config.quantity)):
+                theta = main_angle_rad + (i * (math.pi * 2) / float(config.quantity))
+                cos_t = math.cos(theta)
+                sin_t = math.sin(theta)
+                
+                start_x = star.x + cos_t * 0.5
+                start_y = star.y + sin_t * 0.5
+                end_x = star.x + cos_t * base_length
+                end_y = star.y + sin_t * base_length
+                
+                # Standard Spike
+                # Base star color, fading to zero alpha
+                c_end = (star.color.r/255.0, star.color.g/255.0, star.color.b/255.0, 0.0)
+                
+                # If rainbow enabled, standard spike is dimmed (matches preview logic)
+                opacity_mult = 0.4 if rainbow_str > 0 else 1.0
+                c_start = (color[0], color[1], color[2], color[3] * opacity_mult)
+                
+                draw_line_gradient(output, start_x, start_y, end_x, end_y,
+                                  c_start, c_end, thickness, config.sharpness)
+                
+                # Rainbow Overlay
+                if rainbow_str > 0:
+                    stops = 10
+                    for s in range(stops):
+                        p1 = s / stops
+                        p2 = (s + 1) / stops
+                        if p1 > config.rainbow_spike_length:
+                            break
+                        
+                        hue = (p1 * 360.0 * config.rainbow_spike_frequency) % 360.0
+                        a_rainbow = min(1.0, config.intensity * rainbow_str * 2.0) * (1.0 - p1)
+                        r_seg, g_seg, b_seg = hsl_to_rgb(hue / 360.0, 0.8, 0.6)
+                        c_seg = (r_seg, g_seg, b_seg, a_rainbow)
+                        
+                        # Calculate segment positions
+                        sx = start_x + (end_x - start_x) * p1
+                        sy = start_y + (end_y - start_y) * p1
+                        ex = start_x + (end_x - start_x) * p2
+                        ey = start_y + (end_y - start_y) * p2
+                        
+                        # Draw rainbow segment with constant color
+                        draw_line_gradient(output, sx, sy, ex, ey,
+                                          c_seg, c_seg, thickness, 1.0)
         
         # Secondary spikes
         if config.secondary_intensity > 0: