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

setiastro/saspro/image_combine.py

@@ -91,6 +91,9 @@ class ImageCombineDialog(QDialog):
     def __init__(self, main_window):
         super().__init__(main_window)
         self.setWindowTitle("Image Combine")
+        self.setWindowFlag(Qt.WindowType.Window, True)
+        self.setWindowModality(Qt.WindowModality.NonModal)
+        self.setModal(False)
         self.mw = main_window
         self.dm = getattr(main_window, "doc_manager", None) or getattr(main_window, "dm", None)
         self.zoom = 1.0

setiastro/saspro/image_peeker_pro.py

@@ -1314,6 +1314,9 @@ class ImagePeekerDialogPro(QDialog):
     def __init__(self, parent, document, settings):
         super().__init__(parent)
         self.setWindowTitle(self.tr("Image Peeker"))
+        self.setWindowFlag(Qt.WindowType.Window, True)
+        self.setWindowModality(Qt.WindowModality.NonModal)
+        self.setModal(False)
         self.document = self._coerce_doc(document)   # <- ensure we hold a real doc
         self.settings = settings
         # status / progress line

setiastro/saspro/imageops/stretch.py

@@ -95,19 +95,11 @@ def apply_curves_adjustment(image: np.ndarray,
     xvals, yvals = _calculate_curve_points(target_median, curves_boost)
 
     # Apply the 1D LUT per channel using np.interp (piecewise linear)
-    if img.ndim == 2:
-        flat = img.ravel()
-        out = np.interp(flat, xvals, yvals).reshape(img.shape).astype(np.float32)
-    elif img.ndim == 3 and img.shape[2] in (3, 4):
-        h, w, c = img.shape
-        out = np.empty_like(img, dtype=np.float32)
-        # Apply same curve to each color channel
-        for ch in range(c):
-            flat = img[..., ch].ravel()
-            out[..., ch] = np.interp(flat, xvals, yvals).reshape(h, w)
-    else:
-        # Fallback: just return clamped image
-        out = img
+    # Apply the 1D LUT per channel using np.interp (piecewise linear)
+    # Optimization: np.interp can handle N-D 'x' array directly.
+    # No need to loop over channels or flatten/reshape if we pass the whole array.
+    
+    out = np.interp(img, xvals, yvals).astype(np.float32, copy=False)
 
     return np.clip(out, 0.0, 1.0)
 

setiastro/saspro/isophote.py

@@ -360,6 +360,9 @@ class IsophoteModelerDialog(QDialog):
     def __init__(self, mono_image: np.ndarray, parent: Optional[QWidget] = None,
                  title_hint: Optional[str] = None, image_manager=None, doc_manager=None):
         super().__init__(parent)
+        self.setWindowFlag(Qt.WindowType.Window, True)
+        self.setWindowModality(Qt.WindowModality.NonModal)
+        self.setModal(False)
         self.image_manager = image_manager
         self.doc_manager   = doc_manager
 

setiastro/saspro/legacy/numba_utils.py

@@ -802,39 +802,46 @@ def kappa_sigma_clip_weighted_3d(stack, weights, kappa=2.5, iterations=3):
                 pixel_weights = weights[:]
             else:
                 pixel_weights = weights[:, i, j].copy()
-            # Initialize tracking of indices
-            current_idx = np.empty(num_frames, dtype=np.int64)
-            for f in range(num_frames):
-                current_idx[f] = f
-            current_vals = pixel_values
-            current_w = pixel_weights
-            current_indices = current_idx
+                
+            valid_mask = pixel_values != 0
+            
             med = 0.0
             for _ in range(iterations):
-                if current_vals.size == 0:
+                count = 0
+                for k in range(num_frames):
+                    if valid_mask[k]:
+                        count += 1
+                
+                if count == 0:
                     break
+                    
+                current_vals = pixel_values[valid_mask]
+                
                 med = np.median(current_vals)
                 std = np.std(current_vals)
                 lower_bound = med - kappa * std
                 upper_bound = med + kappa * std
-                valid = (current_vals != 0) & (current_vals >= lower_bound) & (current_vals <= upper_bound)
-                current_vals = current_vals[valid]
-                current_w = current_w[valid]
-                current_indices = current_indices[valid]
-            # Mark rejected: frames not in current_indices are rejected.
+                
+                for k in range(num_frames):
+                    if valid_mask[k]:
+                        val = pixel_values[k]
+                        if val < lower_bound or val > upper_bound:
+                            valid_mask[k] = False
+
             for f in range(num_frames):
-                # Check if f is in current_indices
-                found = False
-                for k in range(current_indices.size):
-                    if current_indices[k] == f:
-                        found = True
-                        break
-                if not found:
-                    rej_mask[f, i, j] = True
-                else:
-                    rej_mask[f, i, j] = False
-            if current_w.size > 0 and current_w.sum() > 0:
-                clipped[i, j] = np.sum(current_vals * current_w) / current_w.sum()
+                rej_mask[f, i, j] = not valid_mask[f]
+                
+            wsum = 0.0
+            vsum = 0.0
+            for k in range(num_frames):
+                if valid_mask[k]:
+                    w = pixel_weights[k]
+                    v = pixel_values[k]
+                    wsum += w
+                    vsum += v * w
+            
+            if wsum > 0:
+                clipped[i, j] = vsum / wsum
             else:
                 clipped[i, j] = med
     return clipped, rej_mask
@@ -859,36 +866,46 @@ def kappa_sigma_clip_weighted_4d(stack, weights, kappa=2.5, iterations=3):
                     pixel_weights = weights[:]
                 else:
                     pixel_weights = weights[:, i, j, c].copy()
-                current_idx = np.empty(num_frames, dtype=np.int64)
-                for f in range(num_frames):
-                    current_idx[f] = f
-                current_vals = pixel_values
-                current_w = pixel_weights
-                current_indices = current_idx
+                
+                valid_mask = pixel_values != 0
+                
                 med = 0.0
                 for _ in range(iterations):
-                    if current_vals.size == 0:
+                    count = 0
+                    for k in range(num_frames):
+                        if valid_mask[k]:
+                            count += 1
+                            
+                    if count == 0:
                         break
+                        
+                    current_vals = pixel_values[valid_mask]
+                    
                     med = np.median(current_vals)
                     std = np.std(current_vals)
                     lower_bound = med - kappa * std
                     upper_bound = med + kappa * std
-                    valid = (current_vals != 0) & (current_vals >= lower_bound) & (current_vals <= upper_bound)
-                    current_vals = current_vals[valid]
-                    current_w = current_w[valid]
-                    current_indices = current_indices[valid]
+                    
+                    for k in range(num_frames):
+                        if valid_mask[k]:
+                            val = pixel_values[k]
+                            if val < lower_bound or val > upper_bound:
+                                valid_mask[k] = False
+
                 for f in range(num_frames):
-                    found = False
-                    for k in range(current_indices.size):
-                        if current_indices[k] == f:
-                            found = True
-                            break
-                    if not found:
-                        rej_mask[f, i, j, c] = True
-                    else:
-                        rej_mask[f, i, j, c] = False
-                if current_w.size > 0 and current_w.sum() > 0:
-                    clipped[i, j, c] = np.sum(current_vals * current_w) / current_w.sum()
+                    rej_mask[f, i, j, c] = not valid_mask[f]
+                
+                wsum = 0.0
+                vsum = 0.0
+                for k in range(num_frames):
+                    if valid_mask[k]:
+                        w = pixel_weights[k]
+                        v = pixel_values[k]
+                        wsum += w
+                        vsum += v * w
+                
+                if wsum > 0:
+                    clipped[i, j, c] = vsum / wsum
                 else:
                     clipped[i, j, c] = med
     return clipped, rej_mask

setiastro/saspro/linear_fit.py

@@ -224,6 +224,9 @@ class LinearFitDialog(QDialog):
     def __init__(self, parent, doc_manager, active_doc):
         super().__init__(parent)
         self.setWindowTitle("Linear Fit")
+        self.setWindowFlag(Qt.WindowType.Window, True)
+        self.setWindowModality(Qt.WindowModality.NonModal)
+        self.setModal(False)
         self.dm = doc_manager
         self.doc = active_doc
         self.worker: Optional[_LinearFitWorker] = None

setiastro/saspro/live_stacking.py

@@ -48,6 +48,9 @@ class LiveStackSettingsDialog(QDialog):
     def __init__(self, parent):
         super().__init__(parent)
         self.setWindowTitle("Live Stack & Culling Settings")
+        self.setWindowFlag(Qt.WindowType.Window, True)
+        self.setWindowModality(Qt.WindowModality.NonModal)
+        self.setModal(False)
 
         # — Live Stack Settings —
         # Bootstrap frames (int)
@@ -290,8 +293,16 @@ def estimate_global_snr(
 
     # 1) Collapse to simple 2D float array (grayscale)
     if stack_image.ndim == 3 and stack_image.shape[2] == 3:
-        # RGB → grayscale by averaging channels
-        gray = stack_image.mean(axis=2).astype(np.float32)
+        try:
+            import cv2
+            # cv2.cvtColor is significantly faster than mean(axis=2)
+            # Assuming RGB input, but even if BGR, for SNR estimation luma difference is negligible
+            gray = cv2.cvtColor(stack_image, cv2.COLOR_RGB2GRAY)
+            if gray.dtype != np.float32:
+                gray = gray.astype(np.float32)
+        except ImportError:
+            # Fallback
+            gray = stack_image.mean(axis=2).astype(np.float32)
     else:
         # Already mono: just cast to float32
         gray = stack_image.astype(np.float32)

setiastro/saspro/mask_creation.py

@@ -555,6 +555,9 @@ class MaskCreationDialog(QDialog):
     def __init__(self, image01: np.ndarray, parent=None, auto_push_on_ok: bool = True):
         super().__init__(parent)
         self.setWindowTitle(self.tr("Mask Creation"))
+        self.setWindowFlag(Qt.WindowType.Window, True)
+        self.setWindowModality(Qt.WindowModality.NonModal)
+        self.setModal(False)
         self.image = np.asarray(image01, dtype=np.float32).copy()
         self.mask: np.ndarray | None = None
         self.live_preview = LivePreviewDialog(self.image, parent=self)

setiastro/saspro/mfdeconv.py

@@ -822,6 +822,11 @@ def _to_luma_local(a: np.ndarray) -> np.ndarray:
         return a
     # (H,W,3) or (3,H,W)
     if a.ndim == 3 and a.shape[-1] == 3:
+        try:
+            import cv2
+            return cv2.cvtColor(a, cv2.COLOR_RGB2GRAY).astype(np.float32, copy=False)
+        except Exception:
+            pass
         r, g, b = a[..., 0], a[..., 1], a[..., 2]
         return (0.2126*r + 0.7152*g + 0.0722*b).astype(np.float32, copy=False)
     if a.ndim == 3 and a.shape[0] == 3:

setiastro/saspro/morphology.py

@@ -46,10 +46,9 @@ def apply_morphology(image: np.ndarray, *, operation: str = "erosion",
 
     if img.ndim == 3 and img.shape[2] == 3:
         u8 = (img * 255.0).astype(np.uint8)
-        ch = cv2.split(u8)
-        ch = [_do(c) for c in ch]
-        out = cv2.merge(ch).astype(np.float32) / 255.0
-        return np.clip(out, 0.0, 1.0)
+        # OpenCV morphology functions handle multi-channel images natively (independent channels)
+        out_u8 = _do(u8)
+        return (out_u8.astype(np.float32) / 255.0).clip(0.0, 1.0)
 
     raise ValueError("Input image must be mono (H,W)/(H,W,1) or RGB (H,W,3).")
 
@@ -92,6 +91,9 @@ class MorphologyDialogPro(QDialog):
     def __init__(self, parent, doc, icon: QIcon | None = None, initial: dict | None = None):
         super().__init__(parent)
         self.setWindowTitle(self.tr("Morphological Operations"))
+        self.setWindowFlag(Qt.WindowType.Window, True)
+        self.setWindowModality(Qt.WindowModality.NonModal)
+        self.setModal(False)
         if icon:
             try: self.setWindowIcon(icon)
             except Exception as e:
@@ -258,10 +260,33 @@ class MorphologyDialogPro(QDialog):
                 pass
             # ────────────────────────────────────────────────────────────
 
-            self.accept()
+            # Dialog stays open so user can apply to other images
+            # Refresh document reference for next operation
+            self._refresh_document_from_active()
         except Exception as e:
             QMessageBox.critical(self, "Morphology", f"Failed to apply:\n{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
+                    # Refresh preview for new document
+                    self.orig = np.clip(np.asarray(new_doc.image, dtype=np.float32), 0.0, 1.0)
+                    disp = self.orig
+                    if disp.ndim == 2: disp = disp[..., None].repeat(3, axis=2)
+                    elif disp.ndim == 3 and disp.shape[2] == 1: disp = disp.repeat(3, axis=2)
+                    self._disp_base = disp
+                    self._update_preview()
+        except Exception:
+            pass
+
 
 
     def _reset(self):