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

setiastro/qml/ResourceMonitor.qml

@@ -0,0 +1,126 @@
+import QtQuick 2.15
+import QtQuick.Controls 2.15
+import QtQuick.Layouts 1.15
+
+Rectangle {
+    id: root
+    // Wider to fit 3 gauges + spacing
+    width: 200
+    height: 60
+    // 50% opacity black
+    color: "#80000000"
+    radius: 30
+    border.color: "#555"
+    border.width: 1
+
+    property double cpuUsage: 0.0
+    property double ramUsage: 0.0
+    property double gpuUsage: 0.0
+    property double appRamUsage: 0.0
+    property string appRamString: "0 MB"
+
+        // Helper component for gauges
+        component MiniGauge: Item {
+            Layout.preferredWidth: 40
+            Layout.preferredHeight: 40
+            property string label: ""
+            property color barColor: "#0f0"
+            property double value: 0
+            
+            // Trigger repaint when value changes
+            onValueChanged: if (gaugeCanvas) gaugeCanvas.requestPaint()
+
+            Canvas {
+                id: gaugeCanvas
+                anchors.fill: parent
+                antialiasing: true
+                onPaint: {
+                    var ctx = getContext("2d");
+                    var cx = width / 2;
+                    var cy = height / 2;
+                    var r = (width / 2) - 3;
+                    
+                    ctx.reset();
+                    
+                    // Track
+                    ctx.beginPath();
+                    ctx.arc(cx, cy, r, 0, 2*Math.PI);
+                    ctx.lineWidth = 4;
+                    ctx.strokeStyle = "#444";
+                    ctx.stroke();
+
+                    // Value Arc
+                    // start at -90 deg (top)
+                    var start = -Math.PI/2;
+                    var end = start + (value/100 * 2*Math.PI);
+                    
+                    ctx.beginPath();
+                    ctx.arc(cx, cy, r, start, end);
+                    ctx.lineWidth = 4;
+                    ctx.lineCap = "round";
+                    ctx.strokeStyle = barColor;
+                    ctx.stroke();
+                }
+            }
+            
+            // Numeric Percent in center
+            Text {
+                anchors.centerIn: parent
+                text: Math.round(value) + "%"
+                font.pixelSize: 10
+                font.bold: true
+                color: "#fff"
+            }
+        }
+
+    RowLayout {
+        anchors.centerIn: parent
+        spacing: 15
+
+        // --- CPU ---
+        ColumnLayout {
+            spacing: 2
+            MiniGauge {
+                value: root.cpuUsage
+                // Dynamic color
+                barColor: root.cpuUsage > 80 ? "#ff4444" : (root.cpuUsage > 50 ? "#ffbb33" : "#00C851")
+            }
+            Text { 
+                Layout.alignment: Qt.AlignHCenter 
+                text: "CPU" 
+                color: "#aaaaaa" 
+                font.pixelSize: 9
+            }
+        }
+
+        // --- RAM ---
+        ColumnLayout {
+            spacing: 2
+            MiniGauge {
+                value: root.ramUsage
+                barColor: "#33b5e5"
+            }
+            Text { 
+                Layout.alignment: Qt.AlignHCenter 
+                text: "RAM" 
+                color: "#aaaaaa" 
+                font.pixelSize: 9
+            }
+        }
+
+        // --- GPU ---
+        ColumnLayout {
+            spacing: 2
+            MiniGauge {
+                value: root.gpuUsage
+                barColor: "#aa66cc"
+            }
+            Text { 
+                Layout.alignment: Qt.AlignHCenter 
+                text: "GPU" 
+                color: "#aaaaaa" 
+                font.pixelSize: 9
+            }
+        }
+    }
+}

setiastro/saspro/__main__.py

@@ -38,6 +38,8 @@ _splash_initialized = False
 from setiastro.saspro.versioning import get_app_version
 _EARLY_VERSION = get_app_version("setiastrosuitepro")
 
+VERSION = _EARLY_VERSION
+
 def _init_splash():
     """Initialize the splash screen. Safe to call multiple times."""
     global _splash, _app, _splash_initialized
@@ -47,7 +49,8 @@ def _init_splash():
     
     # Minimal imports for splash screen
     from PyQt6.QtWidgets import QApplication, QWidget
-    from PyQt6.QtCore import Qt, QCoreApplication, QRect
+    from PyQt6.QtCore import Qt, QCoreApplication, QRect, QPropertyAnimation, QEasingCurve
+    import time
     from PyQt6.QtGui import QGuiApplication, QIcon, QPixmap, QColor, QPainter, QFont, QLinearGradient
     
 
@@ -129,13 +132,20 @@ def _init_splash():
 
     # NEW: Prefer centralized resources resolver
     try:
-        from setiastro.saspro.resources import icon_path
+        from setiastro.saspro.resources import icon_path, background_startup_path
         _early_icon_path = icon_path
         if not os.path.exists(_early_icon_path):
             # fall back to legacy search if for some reason this is missing
             _early_icon_path = _find_icon_path()
+        
+        # Load startup background path
+        _startup_bg_path = background_startup_path
+        if not os.path.exists(_startup_bg_path):
+             _startup_bg_path = None
+             
     except Exception:
         _early_icon_path = _find_icon_path()
+        _startup_bg_path = None
 
     
     # =========================================================================
@@ -177,6 +187,11 @@ def _init_splash():
             # Load and scale logo
             self.logo_pixmap = self._load_logo(logo_path)
             
+            # Load background image
+            self.bg_image_pixmap = QPixmap()
+            if _startup_bg_path:
+                self.bg_image_pixmap = QPixmap(_startup_bg_path)
+
             # Fonts
             self.title_font = QFont("Segoe UI", 28, QFont.Weight.Bold)
             self.subtitle_font = QFont("Segoe UI", 11)
@@ -215,15 +230,42 @@ def _init_splash():
                 _app.processEvents()
         
         def setProgress(self, value: int):
-            """Update progress (0-100)."""
-            self.progress_value = max(0, min(100, value))
+            """Update progress (0-100) with smooth animation."""
+            target = max(0, min(100, value))
+            start = self.progress_value
+            
+            # If jumping backwards or small change, just set it
+            if target <= start or (target - start) < 1:
+                self.progress_value = target
+                self.repaint()
+                if _app: _app.processEvents()
+                return
+
+            # Animate forward
+            steps = 15  # number of frames for the slide
+            # We want the total slide to take ~100-150ms max to feel responsive but smooth
+            dt = 0.005  # 5ms per frame
+            
+            for i in range(1, steps + 1):
+                # Ease out interpolator
+                t = i / steps
+                # Quadratic ease out: f(t) = -t*(t-2)
+                factor = -t * (t - 2)
+                
+                cur = start + (target - start) * factor
+                self.progress_value = cur
+                self.repaint()
+                if _app: _app.processEvents()
+                time.sleep(dt)
+
+            self.progress_value = target
             self.repaint()
             if _app:
                 _app.processEvents()
         
         def setBuildInfo(self, version: str, build: str):
             """Update version and build info once available."""
-            self._version = version
+            self._version = _EARLY_VERSION
             self._build = build
             self.repaint()
         
@@ -242,6 +284,45 @@ def _init_splash():
             gradient.setColorAt(1.0, QColor(10, 10, 20))
             painter.fillRect(0, 0, w, h, gradient)
             
+            # --- Background Image (Centered with Fade Out) ---
+            if not self.bg_image_pixmap.isNull():
+                # Create a temporary pixmap to handle the masking
+                temp = QPixmap(w, h)
+                temp.fill(Qt.GlobalColor.transparent)
+                
+                ptmp = QPainter(temp)
+                ptmp.setRenderHint(QPainter.RenderHint.Antialiasing)
+                ptmp.setRenderHint(QPainter.RenderHint.SmoothPixmapTransform)
+                
+                # Scale image to cover the entire splash screen
+                scaled = self.bg_image_pixmap.scaled(
+                    w, h, 
+                    Qt.AspectRatioMode.KeepAspectRatioByExpanding, 
+                    Qt.TransformationMode.SmoothTransformation
+                )
+                
+                # Center the image
+                sx = (w - scaled.width()) // 2
+                sy = (h - scaled.height()) // 2
+                ptmp.drawPixmap(sx, sy, scaled)
+                
+                # Apply Fade Out Mask (Gradient Alpha)
+                ptmp.setCompositionMode(QPainter.CompositionMode.CompositionMode_DestinationIn)
+                fade_gradient = QLinearGradient(0, 0, 0, h)
+                # Keep top half fully visible (subject to global opacity)
+                fade_gradient.setColorAt(0.0, QColor(0, 0, 0, 255)) 
+                fade_gradient.setColorAt(0.5, QColor(0, 0, 0, 255)) 
+                # Fade out completely at the bottom
+                fade_gradient.setColorAt(1.0, QColor(0, 0, 0, 0))   
+                ptmp.fillRect(0, 0, w, h, fade_gradient)
+                ptmp.end()
+                
+                # Draw combined result with 50% opacity
+                painter.save()
+                painter.setOpacity(0.25)
+                painter.drawPixmap(0, 0, temp)
+                painter.restore()
+
             # --- Subtle border ---
             painter.setPen(QColor(60, 60, 80))
             painter.drawRect(0, 0, w - 1, h - 1)
@@ -312,20 +393,52 @@ def _init_splash():
             self.hide()
             self.close()
             self.deleteLater()
+
+        def start_fade_out(self):
+            """Smoothly fade out the splash screen."""
+            self._anim = QPropertyAnimation(self, b"windowOpacity")
+            self._anim.setDuration(1000)
+            self._anim.setStartValue(1.0)
+            self._anim.setEndValue(0.0)
+            self._anim.setEasingCurve(QEasingCurve.Type.OutQuad)
+            self._anim.finished.connect(self.finish)
+            self._anim.start()
     
+        def start_fade_in(self):
+            """Smoothly fade in the splash screen."""
+            self.setWindowOpacity(0.0)
+            self._anim = QPropertyAnimation(self, b"windowOpacity")
+            self._anim.setDuration(800)
+            self._anim.setStartValue(0.0)
+            self._anim.setEndValue(1.0)
+            self._anim.setEasingCurve(QEasingCurve.Type.InQuad)
+            self._anim.start()
+
     # --- Show splash IMMEDIATELY ---
     _splash = _EarlySplash(_early_icon_path)
+    _splash.start_fade_in()
     _splash.show()
+    
+    # Block briefly to allow fade-in to progress smoothly before heavy imports start
+    # We use a busy loop with processEvents to keep the UI responsive during fade
+    t_start = time.time()
+    while time.time() - t_start < 0.85:  # slightly longer than animation
+        _app.processEvents()
+        if _splash.windowOpacity() >= 0.99:
+            break
+        time.sleep(0.01)
+
     _splash.setMessage(QCoreApplication.translate("Splash", "Initializing Python runtime..."))
     _splash.setProgress(2)
     _app.processEvents()
     
     # Load translation BEFORE any other widgets are created
     try:
-        from setiastro.saspro.i18n import load_language
-        load_language(app=_app)
-    except Exception:
-        pass  # Translations not critical - continue without them
+        from setiastro.saspro.i18n import load_language, get_translations_dir
+        ok = load_language(app=_app)
+    except Exception as e:
+        print("i18n load failed:", repr(e))
+
     
     _splash_initialized = True
 
@@ -516,7 +629,8 @@ from PyQt6.QtGui import (QPixmap, QColor, QIcon, QKeySequence, QShortcut, QGuiAp
 )
 
 # ----- QtCore -----
-from PyQt6.QtCore import (Qt, pyqtSignal, QCoreApplication, QTimer, QSize, QSignalBlocker, QModelIndex, QThread, QUrl, QSettings, QEvent, QByteArray, QObject
+from PyQt6.QtCore import (Qt, pyqtSignal, QCoreApplication, QTimer, QSize, QSignalBlocker, QModelIndex, QThread, QUrl, QSettings, QEvent, QByteArray, QObject,
+    QPropertyAnimation, QEasingCurve
 )
 
 from PyQt6.QtNetwork import QNetworkAccessManager, QNetworkRequest, QNetworkReply
@@ -529,8 +643,6 @@ except Exception:
     BUILD_TIMESTAMP = "dev"
 
 
-from setiastro.saspro.versioning import get_app_version
-VERSION = get_app_version("setiastrosuitepro")
 
 _update_splash(QCoreApplication.translate("Splash", "Loading resources..."), 50)
 
@@ -747,7 +859,33 @@ def main():
         if _splash:
             _splash.setMessage(QCoreApplication.translate("Splash", "Showing main window..."))
             _splash.setProgress(95)
+        
+        # --- Smooth Transition: App Fade In + Splash Fade Out ---
+        # MITIGATION: Prevent "White Flash" on startup
+        # 1. Force a dark background immediately so if opacity lags, it's dark not white
+        win.setStyleSheet("QMainWindow { background-color: #0F0F19; }") 
+        # 2. Ensure native window handle exists so setWindowOpacity works immediately
+        win.winId()
+        # 3. Set opacity to 0
+        win.setWindowOpacity(0.0)
+        
         win.show()
+        
+        # 1. Animate Main Window Fade In
+        anim_app = QPropertyAnimation(win, b"windowOpacity")
+        anim_app.setDuration(1200)
+        anim_app.setStartValue(0.0)
+        anim_app.setEndValue(1.0)
+        anim_app.setEasingCurve(QEasingCurve.Type.OutQuad)
+        
+        # Cleanup temp stylesheet upon completion to avoid interfering with ThemeMixin
+        def _on_fade_in_finished():
+            win.setStyleSheet("")
+            if hasattr(win, "on_fade_in_complete"):
+                win.on_fade_in_complete()
+            
+        anim_app.finished.connect(_on_fade_in_finished)
+        anim_app.start()
 
         # Start background Numba warmup after UI is visible
         try:
@@ -761,18 +899,16 @@ def main():
             _splash.setProgress(100)
             _app.processEvents()
             
-            # Small delay to show "Ready!" before closing
+            # Small delay to ensure "Ready!" is seen briefly before fade starts
             import time
-            time.sleep(0.3)
-            _app.processEvents()
-
-            # Ensure the splash cannot resurrect later:
-            try:
-                _splash.finish()
-            finally:
-                _splash.hide()
-                _splash.close()
-                _splash.deleteLater()
+            time.sleep(0.1)
+            
+            # 2. Animate Splash Fade Out
+            # Note: We do NOT use finish() directly here. The animation calls it when done.
+            _splash.start_fade_out()
+            
+            # NOTE: We keep a reference to _splash (global) so it doesn't get GC'd during animation.
+            # It will deleteLater() itself.
         
         if BUILD_TIMESTAMP == "dev":
             build_label = "running from local source code"

setiastro/saspro/_generated/build_info.py

@@ -1,2 +1,3 @@
 # Auto-generated at build time. Do not edit.
-BUILD_TIMESTAMP = "2025-12-18T23:29:54Z"
+BUILD_TIMESTAMP = "2025-12-22T00:35:11Z"
+APP_VERSION = "1.6.2"

setiastro/saspro/abe.py

@@ -75,15 +75,28 @@ def _fit_poly_on_small(small: np.ndarray, points: np.ndarray, degree: int, patch
 
     if small.ndim == 3 and small.shape[2] == 3:
         bg_small = np.zeros_like(small, dtype=np.float32)
+        
+        # Batch collect samples: (num_samples, 3)
+        # We need N samples. z will be list of (3,) arrays
+        
+        # Pre-allocate Z: (N, 3)
+        Z = np.zeros((len(xs), 3), dtype=np.float32)
+        
+        for k, (x, y) in enumerate(zip(xs, ys)):
+            x0, x1 = max(0, x - half), min(W, x + half + 1)
+            y0, y1 = max(0, y - half), min(H, y + half + 1)
+            # Efficiently compute median for all channels in this patch
+            patch = small[y0:y1, x0:x1, :]
+            Z[k] = np.median(patch, axis=(0, 1))
+
+        # Solve once: A is (N, terms), Z is (N, 3) -> coeffs is (terms, 3)
+        coeffs_all, *_ = np.linalg.lstsq(A, Z, rcond=None)
+        
+        # Evaluate per channel
         for c in range(3):
-            z = []
-            for x, y in zip(xs, ys):
-                x0, x1 = max(0, x - half), min(W, x + half + 1)
-                y0, y1 = max(0, y - half), min(H, y + half + 1)
-                z.append(np.median(small[y0:y1, x0:x1, c]))
-            z = np.asarray(z, dtype=np.float32)
-            coeffs, *_ = np.linalg.lstsq(A, z, rcond=None)
-            bg_small[..., c] = evaluate_polynomial(H, W, coeffs.astype(np.float32), degree)
+            # coeffs_all[:, c] gives the terms for channel c
+            bg_small[..., c] = evaluate_polynomial(H, W, coeffs_all[:, c].astype(np.float32), degree)
+            
         return bg_small
     else:
         z = []
@@ -475,13 +488,18 @@ class ABEDialog(QDialog):
 
         # IMPORTANT: avoid “attached modal sheet” behavior on some Linux WMs
         self.setWindowFlag(Qt.WindowType.Window, True)
-        # keep it blocking if you want, but as a top-level window
-        self.setWindowModality(Qt.WindowModality.ApplicationModal)
+        # Non-modal: allow user to switch between images while dialog is open
+        self.setWindowModality(Qt.WindowModality.NonModal)
         self.setModal(False)
         #self.setAttribute(Qt.WidgetAttribute.WA_DeleteOnClose, True)
 
+        self._main = parent
         self.doc = document
 
+        # Connect to active document change signal
+        if hasattr(self._main, "currentDocumentChanged"):
+            self._main.currentDocumentChanged.connect(self._on_active_doc_changed)
+
         self._preview_scale = 1.0
         self._preview_qimg = None
         self._last_preview = None  # backing ndarray for QImage lifetime
@@ -612,6 +630,17 @@ class ABEDialog(QDialog):
         bar.addWidget(self.btn_autostr)
         return bar
 
+    # ----- active document change -----
+    def _on_active_doc_changed(self, doc):
+        """Called when user clicks a different image window."""
+        if doc is None or getattr(doc, "image", None) is None:
+            return
+        self.doc = doc
+        self._polygons.clear()
+        self._drawing_poly = None
+        self._preview_source_f01 = None
+        self._populate_initial_preview()
+
     # ----- data helpers -----
     def _get_source_float(self) -> np.ndarray | None:
         src = np.asarray(self.doc.image)
@@ -813,12 +842,34 @@ class ABEDialog(QDialog):
                 pass
 
             self._set_status("Done")
-            self.accept()
+            # Dialog stays open so user can apply to other images
+            # Refresh to use the now-active document for next operation
+            self._refresh_document_from_active()
 
         except Exception as e:
             self._set_status("Error")
             QMessageBox.critical(self, "Apply failed", str(e))
 
+    def _refresh_document_from_active(self):
+        """
+        Refresh the dialog's document reference to the currently active document.
+        This allows reusing the same dialog on different images.
+        """
+        try:
+            main = self.parent()
+            if main and hasattr(main, "_active_doc"):
+                new_doc = main._active_doc()
+                if new_doc is not None and new_doc is not self.doc:
+                    self.doc = new_doc
+                    # Reset preview state for new document
+                    self._preview_source_f01 = None
+                    self._last_preview = None
+                    self._preview_qimg = None
+                    # Clear polygons since they were for old image
+                    self._clear_polys()
+        except Exception:
+            pass
+
 
     # ----- exclusion polygons & mask -----
     def _clear_polys(self):

setiastro/saspro/aberration_ai.py

@@ -298,8 +298,8 @@ class AberrationAIDialog(QDialog):
 
         # Normalize window behavior across platforms
         self.setWindowFlag(Qt.WindowType.Window, True)
-        # This is a “big operation” tool; app-modal is usually fine here
-        self.setWindowModality(Qt.WindowModality.ApplicationModal)
+        # Non-modal: allow user to switch between images while dialog is open
+        self.setWindowModality(Qt.WindowModality.NonModal)
         self.setModal(False)
         #self.setAttribute(Qt.WidgetAttribute.WA_DeleteOnClose, True)
 
@@ -680,7 +680,7 @@ class AberrationAIDialog(QDialog):
         )
 
         self.progress.setValue(100)
-        self.accept()
+        # Dialog stays open so user can apply to other images
 
     def _on_worker_finished(self):
         # If dialog is already gone, this method is never called because the receiver (self)

setiastro/saspro/add_stars.py

@@ -227,7 +227,8 @@ class AddStarsDialog(QDialog):
         self.setWindowTitle(self.tr("Add Stars to Image"))
 
         self.setWindowFlag(Qt.WindowType.Window, True)
-        self.setWindowModality(Qt.WindowModality.ApplicationModal)
+        # Non-modal: allow user to switch between images while dialog is open
+        self.setWindowModality(Qt.WindowModality.NonModal)
         self.setModal(False)
         #self.setAttribute(Qt.WidgetAttribute.WA_DeleteOnClose, True)
 
@@ -574,7 +575,9 @@ class AddStarsDialog(QDialog):
 
         # Emit (target_doc, blended_image)
         self.stars_added.emit(target_doc, self.blended_image.astype(np.float32, copy=False))
-        self.accept()
+        # Dialog stays open so user can apply to other images
+        # Refresh combo boxes for next operation
+        self._populate_doc_combos()
 
 
     # Ensure initial fit once shown

setiastro/saspro/astrobin_exporter.py

@@ -997,6 +997,9 @@ class AstrobinExporterDialog(QDialog):
     def __init__(self, parent=None, offline_filters_csv: Optional[str] = None):
         super().__init__(parent)
         self.setWindowTitle(self.tr("AstroBin Exporter"))
+        self.setWindowFlag(Qt.WindowType.Window, True)
+        self.setWindowModality(Qt.WindowModality.NonModal)
+        self.setModal(False)
         self.resize(980, 640)
         v = QVBoxLayout(self)
         self.tab = AstrobinExportTab(self, offline_filters_csv=offline_filters_csv)

setiastro/saspro/astrospike_python.py

@@ -1040,7 +1040,9 @@ class AstroSpikeWindow(QDialog):
     def __init__(self, image_data_255: np.ndarray, image_data_float: np.ndarray, ctx):
         super().__init__()
         self.setWindowTitle("AstroSpike - Star Diffraction Spikes")
-        self.setModal(True)
+        self.setWindowFlag(Qt.WindowType.Window, True)
+        self.setWindowModality(Qt.WindowModality.NonModal)
+        self.setModal(False)
         
         self.ctx = ctx
         self.image_data = image_data_255  # uint8 for detection

setiastro/saspro/autostretch.py

@@ -180,8 +180,10 @@ def autostretch(
         lut = _compute_lut_from_sample(lum, target_median, sigma, maxv)
 
         out = np.empty_like(u, dtype=np.float32)
-        for c in range(min(3, C)):
-            out[..., c] = lut[u[..., c]]
+        # Vectorized LUT application: apply to all RGB channels at once
+        # lut is 1D array of float32; u[..., :3] selects RGB indices
+        out[..., :3] = lut[u[..., :3]]       
+        
         if C > 3:  # pass-through non-RGB channels
             out[..., 3:] = u[..., 3:] / float(maxv)
         return out