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

setiastro/saspro/star_alignment.py

@@ -24,6 +24,7 @@ def _make_executor(max_workers: int):
     #     return ProcessPoolExecutor(max_workers=max_workers)
     return ThreadPoolExecutor(max_workers=max_workers)
 
+
 import gc  # For explicit memory cleanup after heavy operations
 import os as _os
 import threading as _threading
@@ -286,8 +287,18 @@ def _warp_like_ref(target_img: np.ndarray, M_2x3: np.ndarray, ref_shape_hw: tupl
         return cv2.warpAffine(target_img, M_2x3, (W, H),
                                flags=cv2.INTER_LANCZOS4, borderMode=cv2.BORDER_CONSTANT, borderValue=0)
     
+    # Optimization: If standard RGB/BGR (3 channels) or 4 channels, OpenCV handles it natively.
+    # Note: OpenCV warpAffine support n-channel images, but typically 1, 3, or 4.
+    C = target_img.shape[2]
+    if C <= 4:
+         if not target_img.flags['C_CONTIGUOUS']:
+             target_img = np.ascontiguousarray(target_img)
+         return cv2.warpAffine(target_img, M_2x3, (W, H),
+                               flags=cv2.INTER_LANCZOS4, borderMode=cv2.BORDER_CONSTANT, borderValue=0)
+
+    # Fallback for >4 channels (e.g. hyperspectral or special stacks)
     chs = []
-    for i in range(target_img.shape[2]):
+    for i in range(C):
         ch = target_img[..., i]
         if not ch.flags['C_CONTIGUOUS']:
             ch = np.ascontiguousarray(ch)
@@ -618,6 +629,7 @@ class StellarAlignmentDialog(QDialog):
         super().__init__(parent)
         self.setWindowTitle("Stellar Alignment")
         self.setWindowFlag(Qt.WindowType.Window, True)
+        self.setWindowModality(Qt.WindowModality.NonModal)
         self.setModal(False)
         #self.setAttribute(Qt.WidgetAttribute.WA_DeleteOnClose, True)
 
@@ -4639,6 +4651,9 @@ class MosaicMasterDialog(QDialog):
             self._list_open_docs_fn = list_open_docs_fn
 
         self.setWindowTitle("Mosaic Master")
+        self.setWindowFlag(Qt.WindowType.Window, True)
+        self.setWindowModality(Qt.WindowModality.NonModal)
+        self.setModal(False)
         self.wrench_path = wrench_path
         self.spinner_path = spinner_path
 

setiastro/saspro/star_spikes.py

@@ -1,7 +1,7 @@
 # pro/tools/star_spikes.py
 from __future__ import annotations
 import numpy as np
-
+import math
 from PyQt6.QtCore import Qt
 from PyQt6.QtWidgets import (QDialog, QVBoxLayout, QHBoxLayout, QLabel, QPushButton, QSplitter, QSizePolicy, QWidget, QApplication,
                              QFormLayout, QGroupBox, QDoubleSpinBox, QSpinBox, 
@@ -50,6 +50,9 @@ class StarSpikesDialogPro(QDialog):
                  spinner_path: str | None = None):
         super().__init__(parent)
         self.setWindowTitle(self.tr("Diffraction Spikes"))
+        self.setWindowFlag(Qt.WindowType.Window, True)
+        self.setWindowModality(Qt.WindowModality.NonModal)
+        self.setModal(False)
         self.docman = doc_manager
         self.doc = initial_doc or (self.docman.get_active_document() if self.docman else None)
         self.jwstpupil_path = jwstpupil_path
@@ -381,6 +384,13 @@ class StarSpikesDialogPro(QDialog):
         shrink_max = self.advanced["shrink_max"]
         color_boost = self.color_boost.value()
 
+        # Try OpenCV for faster zoom/blur
+        try:
+            import cv2
+            _HAS_CV2 = True
+        except ImportError:
+            _HAS_CV2 = False
+
         from concurrent.futures import ThreadPoolExecutor, as_completed
         def star_runner(x, y, flux, a, b):
             brightness = np.clip(np.log1p(flux)/8.0, 0.1, 3.0)
@@ -388,39 +398,79 @@ class StarSpikesDialogPro(QDialog):
             tile_size  = min(tile_size, 768)
             tile_size += tile_size % 2
             pad = tile_size // 2
-            if not (pad <= x < W - pad and pad <= y < H - pad):
+
+            # Guard against fully out-of-bounds, but allow partial overlaps
+            if not (0 <= x < W and 0 <= y < H):
                 return None
 
+            # Measure star color
             r_ratio, g_ratio, b_ratio = self._measure_star_color(img, x, y, sampling_radius=3)
+            
+            # Extract PSF tiles
             tile_r = self._extract_center_tile(psf_r, tile_size) * brightness * r_ratio * color_boost
             tile_g = self._extract_center_tile(psf_g, tile_size) * brightness * g_ratio * color_boost
             tile_b = self._extract_center_tile(psf_b, tile_size) * brightness * b_ratio * color_boost
 
+            # Boost/Shrink
             b_scale, s_factor = self._boost_shrink_from_flux(flux, self.flux_min.value(), flux_max,
                                                              bscale_min, bscale_max, shrink_min, shrink_max)
-            final_r = self._shrink_and_boost(tile_r, b_scale, s_factor)
-            final_g = self._shrink_and_boost(tile_g, b_scale, s_factor)
-            final_b = self._shrink_and_boost(tile_b, b_scale, s_factor)
-
-            new_size = final_r.shape[0]
-            pad_new  = new_size // 2
-            y0, y1   = y - pad_new, y - pad_new + new_size
-            x0, x1   = x - pad_new, x - pad_new + new_size
-            if (y0 < 0 or y1 > H or x0 < 0 or x1 > W):
-                return None
 
-            part = np.zeros((H, W, 3), dtype=np.float32)
-            part[y0:y1, x0:x1, 0] = final_r
-            part[y0:y1, x0:x1, 1] = final_g
-            part[y0:y1, x0:x1, 2] = final_b
-            return part
+            # --- Fast Resize (Zoom) ---
+            def _fast_zoom(arr, z):
+                if z == 1.0: return arr
+                if _HAS_CV2:
+                     h, w = arr.shape
+                     nw, nh = int(round(w * z)), int(round(h * z))
+                     if nw <= 0 or nh <= 0: return np.zeros((2,2), dtype=np.float32)
+                     return cv2.resize(arr, (nw, nh), interpolation=cv2.INTER_LINEAR)
+                else:
+                    return ndi.zoom(arr, z, order=1)
+
+            final_r = np.clip(_fast_zoom(tile_r * b_scale, 1.0/s_factor), 0.0, 1.0)
+            final_g = np.clip(_fast_zoom(tile_g * b_scale, 1.0/s_factor), 0.0, 1.0)
+            final_b = np.clip(_fast_zoom(tile_b * b_scale, 1.0/s_factor), 0.0, 1.0)
+
+            # --- Return Patch Data (y, x, patch) ---
+            new_h, new_w = final_r.shape
+            
+            # Coords of the *patch top-left* relative to the image
+            # The star is at (x,y), and the patch center is approx (new_w//2, new_h//2)
+            # We want to center the patch on the star.
+            py0 = y - (new_h // 2)
+            px0 = x - (new_w // 2)
+            
+            # Combine channels
+            patch = np.dstack((final_r, final_g, final_b)).astype(np.float32)
+            return (int(py0), int(px0), patch)
 
         with ThreadPoolExecutor() as ex:
             futs = [ex.submit(star_runner, *s) for s in stars]
             for f in as_completed(futs):
-                part = f.result()
-                if part is not None:
-                    canvas += part
+                res = f.result()
+                if res is None:
+                    continue
+                
+                py0, px0, patch = res
+                ph, pw, _ = patch.shape
+                
+                # Calculate intersection with canvas
+                y_start = max(0, py0)
+                y_end   = min(H, py0 + ph)
+                x_start = max(0, px0)
+                x_end   = min(W, px0 + pw)
+                
+                # If no overlap, skip
+                if y_start >= y_end or x_start >= x_end:
+                    continue
+
+                # Offsets into the patch
+                patch_y_start = y_start - py0
+                patch_y_end   = patch_y_start + (y_end - y_start)
+                patch_x_start = x_start - px0
+                patch_x_end   = patch_x_start + (x_end - x_start)
+
+                # Add to canvas
+                canvas[y_start:y_end, x_start:x_end] += patch[patch_y_start:patch_y_end, patch_x_start:patch_x_end]
 
         self.status.setText("Compositing…")
         QApplication.processEvents()
@@ -543,14 +593,56 @@ class StarSpikesDialogPro(QDialog):
         return img
 
     def _simulate_psf(self, pupil, wavelength_scale=1.0, blur_sigma=1.0):
-        sp = gaussian_filter(pupil, sigma=0.1 * wavelength_scale)
+        # Try to use OpenCV for speed
+        if getattr(self, "_cv2_checked", False):
+            has_cv2 = True
+            import cv2
+        else:
+            try:
+                import cv2
+                has_cv2 = True
+            except ImportError:
+                has_cv2 = False
+            self._cv2_checked = has_cv2
+
+        if has_cv2:
+            # Gaussian blur on pupil
+            # kernel size usually ~6*sigma, must be odd
+            k_pupil = int(math.ceil(6 * (0.1 * wavelength_scale))) | 1
+            sp = cv2.GaussianBlur(pupil, (k_pupil, k_pupil), 0.1 * wavelength_scale)
+        else:
+            sp = gaussian_filter(pupil, sigma=0.1 * wavelength_scale)
+        
         fft = np.fft.fftshift(np.fft.fft2(np.fft.ifftshift(sp)))
         intensity = np.abs(fft)**2
         intensity /= (intensity.max() + 1e-8)
-        blurred = gaussian_filter(intensity, sigma=blur_sigma)
+        
+        if has_cv2 and blur_sigma > 0:
+            k_blur = int(math.ceil(6 * blur_sigma)) | 1
+            blurred = cv2.GaussianBlur(intensity, (k_blur, k_blur), blur_sigma)
+        else:
+            blurred = gaussian_filter(intensity, sigma=blur_sigma)
+            
         psf = blurred / max(blurred.max(), 1e-8)
+        
         if wavelength_scale != 1.0:
-            psf = ndi.zoom(psf, zoom=wavelength_scale, order=1)
+            if has_cv2:
+                h, w = psf.shape
+                # Zoom uses size, NOT scale factor in resize(..., dsize=(w,h))
+                # wavelength_scale > 1 => zoom in => crop middle? or simply scale?
+                # The original used ndi.zoom(psf, zoom=wavelength_scale).
+                # New size:
+                nw, nh = int(round(w * wavelength_scale)), int(round(h * wavelength_scale))
+                if nw > 0 and nh > 0:
+                    scaled = cv2.resize(psf, (nw, nh), interpolation=cv2.INTER_LINEAR)
+                    # We might need to crop back to original size or pad?
+                    # ndi.zoom changes the array size.
+                    # The simulator seems to assume we handle whatever size comes out?
+                    # Let's check _extract_center_tile usage.
+                    psf = scaled
+            else:
+                 psf = ndi.zoom(psf, zoom=wavelength_scale, order=1)
+            
             psf /= psf.max() + 1e-12
         return psf
 
@@ -591,15 +683,7 @@ class StarSpikesDialogPro(QDialog):
                 stars.append((int(obj['x']), int(obj['y']), float(flux), float(a), float(b)))
         return stars
 
-    @staticmethod
-    def _shrink_and_boost(tile, brightness_scale=2.0, shrink_factor=1.5):
-        tile = np.clip(tile * float(brightness_scale), 0.0, 1.0)
-        in_sz = tile.shape[0]
-        out_sz = int(in_sz // float(shrink_factor))
-        out_sz += out_sz % 2
-        if out_sz <= 0: out_sz = 2
-        z = out_sz / float(in_sz)
-        return np.clip(ndi.zoom(tile, z, order=1), 0.0, 1.0)
+    # _shrink_and_boost removed (replaced by inline _fast_zoom for performance)
 
     @staticmethod
     def _boost_shrink_from_flux(flux, flux_min, flux_max, bmin, bmax, smin, smax):

setiastro/saspro/star_stretch.py

@@ -127,8 +127,16 @@ class StarStretchDialog(QDialog):
     def __init__(self, parent, document):
         super().__init__(parent)
         self.setWindowTitle(self.tr("Star Stretch"))
+        self.setWindowFlag(Qt.WindowType.Window, True)
+        self.setWindowModality(Qt.WindowModality.NonModal)
+        self.setModal(False)
+        self._main = parent
         self.doc = document
         self._preview: np.ndarray | None = None
+
+        # Connect to active document change signal
+        if hasattr(self._main, "currentDocumentChanged"):
+            self._main.currentDocumentChanged.connect(self._on_active_doc_changed)
         self._pix: QPixmap | None = None
         self._zoom = 0.25
         self._panning = False
@@ -225,6 +233,15 @@ class StarStretchDialog(QDialog):
         # initialize preview with current doc image
         self._update_preview_pix(self.doc.image)
 
+    # --- 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._preview = None
+        self._update_preview_pix(self.doc.image)
+
     # --- UI change handlers ---
     def _on_stretch_changed(self, v: int):
         self.lbl_st.setText(f"Stretch Amount: {v/100.0:.2f}")
@@ -325,7 +342,27 @@ class StarStretchDialog(QDialog):
         except Exception as e:
             QMessageBox.critical(self, "Apply failed", str(e))
             return
-        self.accept()
+        
+        # Dialog stays open so user can apply to other images
+        # Refresh document reference for next operation
+        self._refresh_document_from_active()
+
+    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._find_main_window()
+            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 for new document
+                    self._preview = None
+                    self._compute_and_show_preview()
+        except Exception:
+            pass
 
 
     # --- preview rendering ---

setiastro/saspro/stat_stretch.py

@@ -25,13 +25,18 @@ class StatisticalStretchDialog(QDialog):
         # --- IMPORTANT: avoid “attached modal” behavior on some Linux WMs ---
         # Make this a proper top-level window (tool-style) rather than an attached sheet.
         self.setWindowFlag(Qt.WindowType.Window, True)
-        # Block the app if you want, but don't use WindowModal
-        self.setWindowModality(Qt.WindowModality.ApplicationModal)
+        # Non-modal: allow user to switch between images while dialog is open
+        self.setWindowModality(Qt.WindowModality.NonModal)
         # Don’t let the generic modal flag override the explicit modality
         self.setModal(False)
 
+        self._main = parent
         self.doc = document
         self._last_preview = None
+
+        # Connect to active document change signal
+        if hasattr(self._main, "currentDocumentChanged"):
+            self._main.currentDocumentChanged.connect(self._on_active_doc_changed)
         self._panning = False
         self._pan_last = None  # QPoint
         self._preview_scale = 1.0       # NEW: zoom factor for preview
@@ -329,6 +334,14 @@ class StatisticalStretchDialog(QDialog):
         self._preview_qimg = qimg
         self._apply_current_zoom() 
 
+    # ----- 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._populate_initial_preview()
+
     # ----- slots -----
     def _populate_initial_preview(self):
         # show the current (unstretched) image as baseline
@@ -433,12 +446,31 @@ class StatisticalStretchDialog(QDialog):
                 # optional debug
                 print("Statistical Stretch: replay recording suppressed for this apply()")
 
-            self.accept()
+            # Dialog stays open so user can apply to other images
+            # Update the document reference to reflect the now-active document
+            self._refresh_document_from_active()
 
 
         except Exception as e:
             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._last_preview = None
+                    self._preview_qimg = None
+        except Exception:
+            pass
+
 
     def _update_preview_scaled(self):
         if self._preview_qimg is None:

setiastro/saspro/subwindow.py

@@ -371,7 +371,8 @@ class ImageSubWindow(QWidget):
         # pixel readout live-probe state
         self._space_down = False
         self._readout_dragging = False
-        self._last_readout = None
+        # Pinch gesture state (macOS trackpad)
+        self._gesture_zoom_start = None
         self.setFocusPolicy(Qt.FocusPolicy.StrongFocus)
 
         # Title (doc/view) sync
@@ -484,6 +485,7 @@ class ImageSubWindow(QWidget):
 
         self.scroll = QScrollArea(full_host)
         self.scroll.setWidgetResizable(False)
+        self.scroll.setAlignment(Qt.AlignmentFlag.AlignCenter)        
         self.label = QLabel(alignment=Qt.AlignmentFlag.AlignCenter)
         self.scroll.setWidget(self.label)
         self.scroll.viewport().setMouseTracking(True)
@@ -2526,6 +2528,43 @@ class ImageSubWindow(QWidget):
             p = p.parent()
         return p
 
+    def event(self, e):
+        """Override event() to handle native macOS gestures (pinch zoom)."""
+        # Handle native gestures (macOS trackpad pinch zoom)
+        if e.type() == QEvent.Type.NativeGesture:
+            gesture_type = e.gestureType()
+
+            if gesture_type == Qt.NativeGestureType.BeginNativeGesture:
+                # Start of pinch gesture - store initial scale
+                self._gesture_zoom_start = self.scale
+                e.accept()
+                return True
+
+            elif gesture_type == Qt.NativeGestureType.ZoomNativeGesture:
+                # Ongoing pinch zoom - value() is cumulative scale factor
+                # Typical values: -0.5 to +0.5 for moderate pinches
+                zoom_delta = e.value()
+
+                # Convert delta to zoom factor
+                # Use smaller multiplier for smoother feel (0.5x damping)
+                factor = 1.0 + (zoom_delta * 0.5)
+
+                # Apply incremental zoom
+                self._zoom_at_anchor(factor)
+                e.accept()
+                return True
+
+            elif gesture_type == Qt.NativeGestureType.EndNativeGesture:
+                # End of pinch gesture - cleanup
+                self._gesture_zoom_start = None
+                e.accept()
+                return True
+
+        # Let parent handle all other events
+        return super().event(e)
+
+
+
     def eventFilter(self, obj, ev):
         is_on_view = (obj is self.label) or (obj is self.scroll.viewport())
 
@@ -2557,7 +2596,29 @@ class ImageSubWindow(QWidget):
         # 1) Ctrl + wheel → zoom
         if ev.type() == QEvent.Type.Wheel:
             if ev.modifiers() & Qt.KeyboardModifier.ControlModifier:
-                factor = 1.25 if ev.angleDelta().y() > 0 else 1/1.25
+                # Try pixelDelta first (macOS trackpad gives smooth values)
+                dy = ev.pixelDelta().y()
+
+                if dy != 0:
+                    # Smooth trackpad scrolling: use smaller base factor
+                    # Scale proportionally to delta magnitude for natural feel
+                    # Typical trackpad deltas are 1-10 pixels per event
+                    abs_dy = abs(dy)
+                    if abs_dy <= 3:
+                        base_factor = 1.01  # Very gentle for tiny movements
+                    elif abs_dy <= 10:
+                        base_factor = 1.02  # Gentle for small movements
+                    else:
+                        base_factor = 1.03  # Moderate for larger gestures
+
+                    factor = base_factor if dy > 0 else 1/base_factor
+                else:
+                    # Traditional mouse wheel: use angleDelta with moderate factor
+                    dy = ev.angleDelta().y()
+                    if dy == 0:
+                        return True
+                    # Use 1.15 for mouse wheel (gentler than original 1.25)
+                    factor = 1.15 if dy > 0 else 1/1.15
                 self._zoom_at_anchor(factor)
                 return True
             return False

setiastro/saspro/supernovaasteroidhunter.py

@@ -362,6 +362,9 @@ class SupernovaAsteroidHunterDialog(QDialog):
                  supernova_path=None, wrench_path=None, spinner_path=None):
         super().__init__(parent)
         self.setWindowTitle(self.tr("Supernova / Asteroid Hunter"))
+        self.setWindowFlag(Qt.WindowType.Window, True)
+        self.setWindowModality(Qt.WindowModality.NonModal)
+        self.setModal(False)
         if supernova_path:
             self.setWindowIcon(QIcon(supernova_path))
         # keep icon path for previews