setiastrosuitepro 1.6.2__py3-none-any.whl → 1.6.12__py3-none-any.whl

setiastro/saspro/whitebalance.py

@@ -88,7 +88,7 @@ def plot_star_color_ratios_comparison(raw_pixels: np.ndarray, after_pixels: np.n
 
     plt.suptitle("Star Color Ratios with RGB Mapping", fontsize=14)
     plt.tight_layout()
-    plt.show()
+    plt.show(block=False)
 
 def apply_manual_white_balance(img: np.ndarray, r_gain: float, g_gain: float, b_gain: float) -> np.ndarray:
     """Simple per-channel gain, clipped to [0,1]."""
@@ -184,6 +184,30 @@ def apply_white_balance_to_doc(doc, preset: Optional[Dict] = None):
         step_name="White Balance",
     )
 
+def apply_pivot_gain(img: np.ndarray, med: np.ndarray, gains: np.ndarray) -> np.ndarray:
+    # img: HxWx3 float32 in [0,1]
+    med3 = med.reshape(1, 1, 3).astype(np.float32)
+    g3   = gains.reshape(1, 1, 3).astype(np.float32)
+
+    # pivot around median; do not scale negative deltas
+    d = img - med3
+    d = np.maximum(d, 0.0)
+    out = d * g3 + med3
+    return np.clip(out, 0.0, 1.0).astype(np.float32, copy=False)
+
+def smoothstep(edge0, edge1, x):
+    t = np.clip((x - edge0) / (edge1 - edge0 + 1e-12), 0.0, 1.0)
+    return t * t * (3.0 - 2.0 * t)
+
+def apply_soft_protect(img: np.ndarray, out_pivot: np.ndarray, k: float = 0.02) -> np.ndarray:
+    # luminance-based fade-in above median luminance
+    L = 0.2126*img[...,0] + 0.7152*img[...,1] + 0.0722*img[...,2]
+    Lm = float(np.median(L))
+    w = smoothstep(Lm, Lm + k, L).astype(np.float32)
+    w3 = w[..., None]
+    out = img * (1.0 - w3) + out_pivot * w3
+    return np.clip(out, 0.0, 1.0).astype(np.float32, copy=False)
+
 
 # -------------------------
 # Interactive dialog (UI)
@@ -193,16 +217,23 @@ class WhiteBalanceDialog(QDialog):
         super().__init__(parent)
         self._main = parent
         self.doc = doc
-
-        # Connect to active document change signal
+        self._active_doc_conn = False
         if hasattr(self._main, "currentDocumentChanged"):
-            self._main.currentDocumentChanged.connect(self._on_active_doc_changed)
+            try:
+                self._main.currentDocumentChanged.connect(self._on_active_doc_changed)
+                self._active_doc_conn = True
+            except Exception:
+                self._active_doc_conn = False
         if icon:
             self.setWindowIcon(icon)
         self.setWindowTitle(self.tr("White Balance"))
         self.setWindowFlag(Qt.WindowType.Window, True)
         self.setWindowModality(Qt.WindowModality.NonModal)
         self.setModal(False)
+        try:
+            self.setAttribute(Qt.WidgetAttribute.WA_DeleteOnClose, True)
+        except Exception:
+            pass  # older PyQt6 versions        
         self.resize(900, 600)
 
         self._build_ui()
@@ -213,6 +244,8 @@ class WhiteBalanceDialog(QDialog):
         self._update_mode_widgets()
         # kick off a first detection preview
         QTimer.singleShot(200, self._update_star_preview)
+        self.finished.connect(lambda *_: self._cleanup())
+
 
     # ---- UI construction ------------------------------------------------
     def _build_ui(self):
@@ -327,11 +360,16 @@ class WhiteBalanceDialog(QDialog):
             )
             self.star_count.setText(self.tr("Detected {0} stars.").format(count))
             # to pixmap
-            h, w, _ = overlay.shape
-            qimg = QImage((overlay * 255).astype(np.uint8).data, w, h, 3 * w, QImage.Format.Format_RGB888)
-            pm = QPixmap.fromImage(qimg).scaled(self.preview.width(), self.preview.height(),
-                                                Qt.AspectRatioMode.KeepAspectRatio,
-                                                Qt.TransformationMode.SmoothTransformation)
+            overlay8 = np.ascontiguousarray(np.clip(overlay * 255.0, 0, 255).astype(np.uint8))
+            h, w, _ = overlay8.shape
+            qimg = QImage(overlay8.data, w, h, 3 * w, QImage.Format.Format_RGB888)
+
+            # Make sure the numpy buffer stays alive until QPixmap is created
+            pm = QPixmap.fromImage(qimg.copy()).scaled(
+                self.preview.width(), self.preview.height(),
+                Qt.AspectRatioMode.KeepAspectRatio,
+                Qt.TransformationMode.SmoothTransformation
+            )
             self.preview.setPixmap(pm)
         except Exception as e:
             self.star_count.setText(self.tr("Detection failed."))
@@ -394,7 +432,8 @@ class WhiteBalanceDialog(QDialog):
                 # Use the headless helper so doc metadata is consistent
                 apply_white_balance_to_doc(self.doc, preset)
                 # Dialog stays open - refresh document for next operation
-                self._refresh_document_from_active()
+                self._finish_and_close()
+                return
 
             elif mode == "Auto":
                 preset = {"mode": "auto"}
@@ -404,7 +443,8 @@ class WhiteBalanceDialog(QDialog):
 
                 apply_white_balance_to_doc(self.doc, preset)
                 # Dialog stays open - refresh document for next operation
-                self._refresh_document_from_active()
+                self._finish_and_close()
+                return
 
             else:  # --- Star-Based: compute here so we can plot like SASv2 ---
                 thr   = float(self.thr_slider.value())
@@ -472,7 +512,8 @@ class WhiteBalanceDialog(QDialog):
                     self.tr("Star-Based WB applied.\nDetected {0} stars.").format(int(star_count)),
                 )
                 # Dialog stays open - refresh document for next operation
-                self._refresh_document_from_active()
+                self._finish_and_close()
+                return
 
         except Exception as e:
             QMessageBox.critical(self, self.tr("White Balance"), self.tr("Failed to apply White Balance:\n{0}").format(e))
@@ -490,3 +531,34 @@ class WhiteBalanceDialog(QDialog):
                     self.doc = new_doc
         except Exception:
             pass
+
+    def _finish_and_close(self):
+        """
+        Close this dialog after a successful apply.
+        Use accept() so it behaves like a successful completion.
+        """
+        try:
+            self.accept()
+        except Exception:
+            self.close()
+
+    def _cleanup(self):
+        # Disconnect active-doc signal so the main window doesn't keep us alive
+        try:
+            if self._active_doc_conn and hasattr(self._main, "currentDocumentChanged"):
+                self._main.currentDocumentChanged.disconnect(self._on_active_doc_changed)
+        except Exception:
+            pass
+        self._active_doc_conn = False
+
+        # Stop debounce timer
+        try:
+            if getattr(self, "_debounce", None) is not None:
+                self._debounce.stop()
+        except Exception:
+            pass
+
+
+    def closeEvent(self, ev):
+        self._cleanup()
+        super().closeEvent(ev)

setiastro/saspro/widgets/common_utilities.py

@@ -1,3 +1,4 @@
+#src/setiastro/saspro/widgets/common_utilities.py
 """
 Common UI utilities and shared components.
 
@@ -220,32 +221,38 @@ _strip_ui_decorations = strip_ui_decorations
 # ---------------------------------------------------------------------------
 
 def install_crash_handlers(app: 'QApplication') -> None:
-    """
-    Install global crash and exception handlers for the application.
-    
-    Sets up:
-    1. faulthandler for hard crashes (segfaults) → saspro_crash.log
-    2. sys.excepthook for uncaught main thread exceptions
-    3. threading.excepthook for uncaught background thread exceptions
-    
-    All exceptions are logged and displayed in a dialog to the user.
-    
-    Args:
-        app: The QApplication instance
-        
-    Example:
-        app = QApplication(sys.argv)
-        install_crash_handlers(app)
-    """
     import faulthandler
-    
-    # 1) Hard crashes (segfaults, access violations) → saspro_crash.log
+    import tempfile
+    from pathlib import Path
+
+    def _get_crash_log_path() -> str:
+        try:
+            if hasattr(sys, "_MEIPASS"):
+                if sys.platform.startswith("win"):
+                    log_dir = Path(os.path.expandvars("%APPDATA%")) / "SetiAstroSuitePro" / "logs"
+                elif sys.platform.startswith("darwin"):
+                    log_dir = Path.home() / "Library" / "Logs" / "SetiAstroSuitePro"
+                else:
+                    log_dir = Path.home() / ".local" / "share" / "SetiAstroSuitePro" / "logs"
+            else:
+                # dev fallback
+                log_dir = Path("logs")
+
+            log_dir.mkdir(parents=True, exist_ok=True)
+            return str(log_dir / "saspro_crash.log")
+        except Exception:
+            return str(Path(tempfile.gettempdir()) / "saspro_crash.log")
+
+    # 1) Hard crashes → saspro_crash.log
     try:
-        _crash_log = open("saspro_crash.log", "w", encoding="utf-8", errors="replace")
+        crash_path = _get_crash_log_path()
+        _crash_log = open(crash_path, "a", encoding="utf-8", errors="replace")
         faulthandler.enable(file=_crash_log, all_threads=True)
         atexit.register(_crash_log.close)
+        logging.info("Faulthandler crash log: %s", crash_path)
     except Exception:
         logging.exception("Failed to enable faulthandler")
+
     
     def _show_dialog(title: str, head: str, details: str) -> None:
         """Show error dialog marshaled to main thread."""
@@ -261,7 +268,7 @@ def install_crash_handlers(app: 'QApplication') -> None:
             m.setStandardButtons(QMessageBox.StandardButton.Ok)
             m.exec()
         QTimer.singleShot(0, _ui)
-    
+
     # 2) Any uncaught exception on the main thread
     def _excepthook(exc_type, exc_value, exc_tb):
         tb = "".join(traceback.format_exception(exc_type, exc_value, exc_tb))

setiastro/saspro/widgets/minigame/game.js

@@ -9,7 +9,7 @@ const ctx = canvas.getContext('2d');
 // --- CONSTANTS ---
 const GAME_WIDTH = 800;
 const GAME_HEIGHT = 600;
-const FPS = 60;
+const FPS = 48; // Reduced to 80% speed (Original 60)
 const DT = 1 / FPS;
 
 const COLORS = {
@@ -971,14 +971,19 @@ function updateHUD() {
 
 // Game Loop
 let lastTimeMs = 0;
+const FRAME_INTERVAL = 1000 / FPS;
+
 function loop(timestamp) {
-    const dt = timestamp - lastTimeMs;
-    lastTimeMs = timestamp;
+    requestAnimationFrame(loop);
 
-    Game.update();
-    Game.draw();
+    if (!lastTimeMs) lastTimeMs = timestamp;
+    const elapsed = timestamp - lastTimeMs;
 
-    requestAnimationFrame(loop);
+    if (elapsed > FRAME_INTERVAL) {
+        lastTimeMs = timestamp - (elapsed % FRAME_INTERVAL);
+        Game.update();
+        Game.draw();
+    }
 }
 
 // Start

setiastro/saspro/widgets/resource_monitor.py

@@ -5,93 +5,122 @@ import psutil
 from PyQt6.QtCore import Qt, QUrl, QTimer, QObject, pyqtProperty, pyqtSignal, QThread
 from PyQt6.QtWidgets import QWidget, QVBoxLayout, QFrame
 from PyQt6.QtQuickWidgets import QQuickWidget
-
+import time
+import subprocess
 from setiastro.saspro.memory_utils import get_memory_usage_mb
 from setiastro.saspro.resources import _get_base_path
 
+
 class GPUWorker(QThread):
-    """Background worker to monitor GPU without blocking the UI."""
     resultReady = pyqtSignal(float)
 
     def __init__(self, has_nvidia: bool, parent=None):
         super().__init__(parent)
         self._has_nvidia = has_nvidia
-        self._last_val = 0.0
+
+        # cache + throttle (Windows PowerShell is expensive)
+        self._last_win_poll = 0.0
+        self._cached_win_val = 0.0
+
+        self._last_emit = 0.0
+        self._last_emitted_val = None
+
+    def _startupinfo_hidden(self):
+        if os.name != "nt":
+            return None
+        si = subprocess.STARTUPINFO()
+        si.dwFlags |= subprocess.STARTF_USESHOWWINDOW
+        si.wShowWindow = 0
+        return si
 
     def _get_windows_gpu_load(self) -> float:
-        if os.name != 'nt':
+        if os.name != "nt":
             return 0.0
+
+        now = time.monotonic()
+
+        # THROTTLE: run this at most once every 1.5 seconds
+        if (now - self._last_win_poll) < 1.5:
+            return self._cached_win_val
+
+        self._last_win_poll = now
+
         try:
-            import subprocess
-            # Aggregation logic to match Task Manager:
-            # 1. Group by unique engine (Adapter LUID + Engine Type/Index).
-            # 2. Sum utilization of all processes sharing that engine.
-            # 3. Take the Maximum of these sums as the overall GPU load.
-            # Aggregation logic to match Task Manager:
-            # 1. Group by unique engine (Adapter LUID + Engine Type/Index).
-            # 2. Sum utilization of all processes sharing that engine.
-            # 3. Take the Maximum of these sums as the overall GPU load.
-            cmd = (
-                "powershell -NoProfile -ExecutionPolicy Bypass -Command \""
-                "$groups = Get-CimInstance Win32_PerfFormattedData_GPUPerformanceCounters_GPUEngine -ErrorAction SilentlyContinue | "
-                "Group-Object -Property { $_.Name -replace '^pid_\\d+_', '' }; "
-                "$res_list = $groups | ForEach-Object { ($_.Group | Measure-Object -Property UtilizationPercentage -Sum).Sum }; "
-                "$max_val = ($res_list | Measure-Object -Maximum).Maximum; "
-                "if ($max_val) { [math]::Round($max_val, 1) } else { 0 }\""
+            # Use explicit powershell.exe and make it non-interactive + hidden
+            cmd = [
+                "powershell.exe",
+                "-NoProfile",
+                "-NonInteractive",
+                "-ExecutionPolicy", "Bypass",
+                "-Command",
+                (
+                    "$x = Get-CimInstance Win32_PerfFormattedData_GPUPerformanceCounters_GPUEngine "
+                    "-ErrorAction SilentlyContinue; "
+                    "if (-not $x) { 0 } else { "
+                    "  $m = ($x | Measure-Object -Property UtilizationPercentage -Maximum).Maximum; "
+                    "  if ($m) { [math]::Round([double]$m, 1) } else { 0 } "
+                    "}"
+                ),
+            ]
+
+            out = subprocess.check_output(
+                cmd,
+                startupinfo=self._startupinfo_hidden(),
+                timeout=2.0,               # IMPORTANT: don’t allow 5s hangs
+                stderr=subprocess.DEVNULL,  # keep it quiet
             )
-            startupinfo = subprocess.STARTUPINFO()
-            startupinfo.dwFlags |= subprocess.STARTF_USESHOWWINDOW
-            startupinfo.wShowWindow = 0 
-            
-            out = subprocess.check_output(cmd, startupinfo=startupinfo, timeout=5.0)
-            val_str = out.decode("utf-8").strip()
-            
-            if not val_str: return 0.0
-            return float(val_str.replace(",", "."))
+            val_str = out.decode("utf-8", errors="ignore").strip()
+
+            val = float(val_str.replace(",", ".")) if val_str else 0.0
+            self._cached_win_val = val
+            return val
         except Exception:
-            return 0.0
+            # keep last known value instead of spamming 0.0
+            return self._cached_win_val
 
     def _get_gpu_load(self) -> float:
         nv_val = 0.0
         win_val = 0.0
-        
-        # 1. Check NVIDIA (Discrete)
+
+        # NVIDIA (fast, keep it)
         if self._has_nvidia:
             try:
-                import subprocess
-                startupinfo = None
-                if os.name == 'nt':
-                    startupinfo = subprocess.STARTUPINFO()
-                    startupinfo.dwFlags |= subprocess.STARTF_USESHOWWINDOW
-                    startupinfo.wShowWindow = 0 
-
                 out = subprocess.check_output(
                     ["nvidia-smi", "--query-gpu=utilization.gpu", "--format=csv,noheader,nounits"],
-                    startupinfo=startupinfo,
-                    timeout=0.6
+                    startupinfo=self._startupinfo_hidden(),
+                    timeout=0.6,
+                    stderr=subprocess.DEVNULL,
                 )
-                line = out.decode("utf-8").strip().split('\n')[0]
+                line = out.decode("utf-8", errors="ignore").strip().split("\n")[0]
                 nv_val = float(line)
             except Exception:
-                pass 
-        
-        # 2. Check Universal (Integrated)
-        if os.name == 'nt':
+                pass
+
+        # Windows integrated (slow, throttled)
+        if os.name == "nt":
             win_val = self._get_windows_gpu_load()
-            
+
         return max(nv_val, win_val)
 
     def run(self):
         while not self.isInterruptionRequested():
             try:
                 val = self._get_gpu_load()
-                self.resultReady.emit(val)
-                # Sleep between measurements. 250ms as requested.
-                # Note: PowerShell queries might take longer than 250ms, 
-                # but this loop will run as fast as the hardware allows without blocking UI.
+
+                # Optional: emit only if value changed a bit, or once per 250ms max
+                now = time.monotonic()
+                if (
+                    self._last_emitted_val is None
+                    or abs(val - self._last_emitted_val) >= 1.0
+                    or (now - self._last_emit) >= 0.5
+                ):
+                    self._last_emit = now
+                    self._last_emitted_val = val
+                    self.resultReady.emit(val)
+
                 self.msleep(250)
             except Exception:
-                self.msleep(1000) # Error backoff on failure
+                self.msleep(1000)
 
 class ResourceBackend(QObject):
     """Backend logic for the QML Resource Monitor."""
@@ -197,6 +226,7 @@ class SystemMonitorWidget(QQuickWidget):
         self.setAttribute(Qt.WidgetAttribute.WA_AlwaysStackOnTop, False)
         self.setAttribute(Qt.WidgetAttribute.WA_TranslucentBackground, True)
         self.setClearColor(Qt.GlobalColor.transparent)
+        self._qml_push_pending = False
 
         # Connect Backend
         self.backend = ResourceBackend(self)
@@ -218,16 +248,23 @@ class SystemMonitorWidget(QQuickWidget):
         # Let's re-write the QML loading part to use a safer 'initialProperties' approach or just signal/slots.
         #
         # EASIEST: QML binds to `root.cpuUsage`. Python sets `root.cpuUsage`.
-        
-        self.backend.cpuChanged.connect(self._push_data_to_qml)
-        self.backend.ramChanged.connect(self._push_data_to_qml)
-        self.backend.gpuChanged.connect(self._push_data_to_qml)
-        self.backend.appRamChanged.connect(self._push_data_to_qml)
+
         
         # Load QML
         qml_path = os.path.join(_get_base_path(), "qml", "ResourceMonitor.qml")
         self.setSource(QUrl.fromLocalFile(qml_path))
 
+    def _schedule_qml_push(self):
+        if self._qml_push_pending:
+            return
+        self._qml_push_pending = True
+        QTimer.singleShot(0, self._push_data_to_qml_coalesced)
+
+    def _push_data_to_qml_coalesced(self):
+        self._qml_push_pending = False
+        self._push_data_to_qml()
+
+
     def _push_data_to_qml(self):
         root = self.rootObject()
         if root:
@@ -235,3 +272,42 @@ class SystemMonitorWidget(QQuickWidget):
             root.setProperty("ramUsage", self.backend.ramUsage)
             root.setProperty("gpuUsage", self.backend.gpuUsage)
             root.setProperty("appRamString", self.backend.appRamString)
+
+    # --- Drag & Drop Support ---
+    def mousePressEvent(self, event):
+        if event.button() == Qt.MouseButton.LeftButton:
+            # Wayland-friendly: ask compositor to move the window
+            wh = self.windowHandle()
+            if wh is not None:
+                try:
+                    # Works best for frameless overlays on Wayland
+                    wh.startSystemMove()
+                    event.accept()
+                    return
+                except Exception:
+                    pass
+
+            # Fallback (Windows/X11): manual move tracking
+            self._drag_start_pos = event.globalPosition().toPoint() - self.frameGeometry().topLeft()
+            event.accept()
+            return
+
+        super().mousePressEvent(event)
+
+    def mouseMoveEvent(self, event):
+        if event.buttons() & Qt.MouseButton.LeftButton:
+            if hasattr(self, "_drag_start_pos"):
+                self.move(event.globalPosition().toPoint() - self._drag_start_pos)
+                event.accept()
+        else:
+            super().mouseMoveEvent(event)
+
+    def mouseReleaseEvent(self, event):
+        if event.button() == Qt.MouseButton.LeftButton:
+            from PyQt6.QtCore import QSettings
+            settings = QSettings("SetiAstro", "SetiAstroSuitePro")
+            pos = self.pos()
+            settings.setValue("ui/resource_monitor_pos_x", pos.x())
+            settings.setValue("ui/resource_monitor_pos_y", pos.y())
+            event.accept()
+        super().mouseReleaseEvent(event)

setiastro/saspro/widgets/spinboxes.py

@@ -37,7 +37,7 @@ class CustomSpinBox(QWidget):
         self.minimum = minimum
         self.maximum = maximum
         self.step = step
-        self._value = initial
+        self._value = int(initial)
 
         # Line edit for value display/entry
         self.lineEdit = QLineEdit(str(initial))
@@ -77,14 +77,13 @@ class CustomSpinBox(QWidget):
 
         self._update_button_states()
 
-    @property
     def value(self) -> int:
-        """Get the current value."""
-        return self._value
+        """Qt-style getter."""
+        return int(self._value)
 
     def setValue(self, val: int) -> None:
-        """Set the value, clamping to min/max."""
-        val = max(self.minimum, min(self.maximum, val))
+        val = int(val)
+        val = max(int(self.minimum), min(int(self.maximum), val))
         if val != self._value:
             self._value = val
             self.lineEdit.setText(str(val))
@@ -134,8 +133,16 @@ class CustomSpinBox(QWidget):
         """Decrease value by step."""
         self.setValue(self._value - self.step)
 
+    def value(self) -> int:
+        """
+        Qt-compatible getter (QSpinBox uses value()).
+
+        Note: we also have @property value for convenience,
+        but code that expects QSpinBox calls value().
+        """
+        return self._value
+
     def _update_button_states(self) -> None:
-        """Enable/disable buttons at limits."""
         self.upButton.setEnabled(self._value < self.maximum)
         self.downButton.setEnabled(self._value > self.minimum)
 
@@ -166,7 +173,7 @@ class CustomDoubleSpinBox(QWidget):
         self.maximum = maximum
         self.step = step
         self.decimals = decimals
-        self._value = initial
+        self._value = float(initial)
 
         # Line edit for value display/entry
         self.lineEdit = QLineEdit(f"{initial:.{decimals}f}")
@@ -206,14 +213,13 @@ class CustomDoubleSpinBox(QWidget):
 
         self._update_button_states()
 
-    @property
     def value(self) -> float:
-        """Get the current value."""
-        return self._value
+        """Qt-style getter."""
+        return float(self._value)
 
     def setValue(self, val: float) -> None:
-        """Set the value, clamping to min/max."""
-        val = max(self.minimum, min(self.maximum, val))
+        val = float(val)
+        val = max(float(self.minimum), min(float(self.maximum), val))
         if abs(val - self._value) > 1e-10:
             self._value = val
             self.lineEdit.setText(f"{val:.{self.decimals}f}")
@@ -228,6 +234,15 @@ class CustomDoubleSpinBox(QWidget):
             self.setValue(minimum)
         self._update_button_states()
 
+    def value(self) -> float:
+        """
+        Qt-compatible getter (QDoubleSpinBox uses value()).
+
+        Note: we also have @property value for convenience,
+        but code that expects QDoubleSpinBox calls value().
+        """
+        return self._value
+
     def setMaximum(self, maximum: float) -> None:
         """Set the maximum value."""
         self.maximum = maximum