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

setiastro/saspro/legacy/numba_utils.py

@@ -1,4 +1,4 @@
-#legacy.numba_utils.py
+#src.setiastro.saspro.legacy.numba_utils.py
 import numpy as np
 from numba import njit, prange
 from numba.typed import List

setiastro/saspro/live_stacking.py

@@ -1328,7 +1328,23 @@ class LiveStackWindow(QDialog):
                 QApplication.processEvents()
         finally:
             self._poll_busy = False
-            
+
+    def _match_master_to_image(self, master: np.ndarray, img: np.ndarray) -> np.ndarray:
+        """
+        Coerce master (dark/flat) to match img dimensionality.
+        - If img is RGB (H,W,3) and master is mono (H,W), expand to (H,W,1).
+        - If img is mono (H,W) and master is RGB (H,W,3), collapse to mono via mean.
+        """
+        if master is None:
+            return None
+
+        if img.ndim == 3 and master.ndim == 2:
+            return master[..., None]  # (H,W,1) broadcasts to (H,W,3)
+        if img.ndim == 2 and master.ndim == 3:
+            return master.mean(axis=2)  # (H,W)
+        return master
+
+
     def process_frame(self, path):
         if self._should_stop():
             return        
@@ -1422,12 +1438,16 @@ class LiveStackWindow(QDialog):
 
         # ——— 2b) CALIBRATION (once) ————————————————————————
         if self.master_dark is not None:
-            img = img.astype(np.float32) - self.master_dark
+            md = self._match_master_to_image(self.master_dark, img).astype(np.float32, copy=False)
+            img = img.astype(np.float32, copy=False) - md
         # prefer per-filter flat if we’re in mono→color and have one
         if mono_key and mono_key in self.master_flats:
-            img = apply_flat_division_numba(img, self.master_flats[mono_key])
+            mf = self._match_master_to_image(self.master_flats[mono_key], img).astype(np.float32, copy=False)
+            img = apply_flat_division_numba(img, mf)
         elif self.master_flat is not None:
-            img = apply_flat_division_numba(img, self.master_flat)
+            mf = self._match_master_to_image(self.master_flat, img).astype(np.float32, copy=False)
+            img = apply_flat_division_numba(img, mf)
+
 
         if self._should_stop():
             return

setiastro/saspro/multiscale_decomp.py

@@ -120,37 +120,41 @@ def soft_threshold(x: np.ndarray, t: float):
 def apply_layer_ops(
     w: np.ndarray,
     bias_gain: float,
-    thr_sigma: float,                 # threshold in units of σ
+    thr_sigma: float,
     amount: float,
     denoise_strength: float = 0.0,
     sigma: float | np.ndarray | None = None,
+    layer_index: int | None = None,
     *,
     mode: str = "μ–σ Thresholding",
 ):
     w2 = w
 
-    # Normalize mode to something robust to label wording
     m = (mode or "").strip().lower()
     is_linear = m.startswith("linear")
-
-    # --- Linear mode: strictly linear multiscale transform ---
     if is_linear:
-        # Ignore thresholding and denoise; just apply gain
-        if abs(bias_gain - 1.0) > 1e-6:
-            return w * bias_gain
-        return w
+        return w * bias_gain if abs(bias_gain - 1.0) > 1e-6 else w
 
-    # --- μ–σ Thresholding mode (robust nonlinear) ---
     # 1) Noise reduction step (MMT-style NR)
     if denoise_strength > 0.0:
         if sigma is None:
             sigma = _robust_sigma(w2)
         sigma_f = float(sigma)
-        # 3σ at denoise=1, scaled linearly
-        t_dn = max(0.0, denoise_strength * 3.0 * sigma_f)
+
+        i = int(layer_index or 0)
+
+        # --- SMOOTH scaling option (pick ONE) ---
+        # Option A: linear growth (very controllable)
+        # scale = 1.0 + 0.75 * i
+
+        # Option B: sqrt growth of 2^i (gentle, "natural")
+        scale = (2.0 ** i) ** 0.5   # 1, 1.41, 2, 2.83, 4, ...
+
+        # Base: 3σ at denoise=1 for layer 0, increases by scale
+        t_dn = denoise_strength * 3.0 * scale * sigma_f
+
         if t_dn > 0.0:
             w_dn = soft_threshold(w2, t_dn)
-            # Blend original vs denoised based on denoise_strength
             w2 = (1.0 - denoise_strength) * w2 + denoise_strength * w_dn
 
     # 2) Threshold in σ units + bias shaping
@@ -158,7 +162,7 @@ def apply_layer_ops(
         if sigma is None:
             sigma = _robust_sigma(w2)
         sigma_f = float(sigma)
-        t = thr_sigma * sigma_f         # convert N·σ → absolute threshold
+        t = thr_sigma * sigma_f
         if t > 0.0:
             wt = soft_threshold(w2, t)
             w2 = (1.0 - amount) * w2 + amount * wt
@@ -167,7 +171,6 @@ def apply_layer_ops(
         w2 = w2 * bias_gain
     return w2
 
-
 def _robust_sigma(arr: np.ndarray) -> float:
     """
     Robust per-layer sigma estimate using MAD, fallback to std if needed.
@@ -455,7 +458,7 @@ class MultiscaleDecompDialog(QDialog):
 
         # --- Spin boxes ---
         self.spin_gain = QDoubleSpinBox()
-        self.spin_gain.setRange(0.0, 3.0)
+        self.spin_gain.setRange(0.0, 10.0)
         self.spin_gain.setSingleStep(0.05)
         self.spin_gain.setValue(1.0)
         self.spin_gain.setToolTip(
@@ -491,7 +494,7 @@ class MultiscaleDecompDialog(QDialog):
 
         # --- Sliders (int ranges, mapped to spins) ---
         self.slider_gain = QSlider(Qt.Orientation.Horizontal)
-        self.slider_gain.setRange(0, 300)         # 0..3.00
+        self.slider_gain.setRange(0, 1000)         # 0..10.00
         self.slider_gain.setToolTip(self.spin_gain.toolTip())
 
         self.slider_thr = QSlider(Qt.Orientation.Horizontal)
@@ -748,6 +751,9 @@ class MultiscaleDecompDialog(QDialog):
             cfg = self.cfgs[i]
             if not cfg.enabled:
                 return i, np.zeros_like(w)
+
+            layer_sigma = self.base_sigma * (2 ** i)
+
             sigma = self._layer_noise[i] if self._layer_noise and i < len(self._layer_noise) else None
             out = apply_layer_ops(
                 w,
@@ -756,6 +762,7 @@ class MultiscaleDecompDialog(QDialog):
                 cfg.amount,
                 cfg.denoise,
                 sigma,
+                layer_index=i,
                 mode=mode,
             )
             return i, out
@@ -1264,11 +1271,17 @@ class MultiscaleDecompDialog(QDialog):
             cfg = self.cfgs[i]
             if not cfg.enabled:
                 return i, np.zeros_like(w)
+
+            layer_sigma = base_sigma * (2 ** i)
+
             return i, apply_layer_ops(
                 w, cfg.bias_gain, cfg.thr, cfg.amount, cfg.denoise,
-                layer_noise[i], mode=mode
+                layer_noise[i],
+                layer_index=i,
+                mode=mode
             )
 
+
         tuned = [None] * len(details)
         max_workers = min(os.cpu_count() or 4, len(details) or 1)
         with ThreadPoolExecutor(max_workers=max_workers) as ex: