setiastrosuitepro 1.6.7__py3-none-any.whl → 1.7.0__py3-none-any.whl

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)
@@ -579,19 +582,29 @@ class MultiscaleDecompDialog(QDialog):
 
     # ---------- Preview plumbing ----------
     def _spinner_on(self):
-        if getattr(self, "busy_spinner", None) is None:
+        if getattr(self, "_closing", False):
+            return
+        try:
+            sp = getattr(self, "busy_spinner", None)
+            if sp is None:
+                return
+            sp.setVisible(True)
+            mv = getattr(self, "_busy_movie", None)
+            if mv is not None and mv.state() != QMovie.MovieState.Running:
+                mv.start()
+        except RuntimeError:
             return
-        self.busy_spinner.setVisible(True)
-        if getattr(self, "_busy_movie", None) is not None:
-            if self._busy_movie.state() != QMovie.MovieState.Running:
-                self._busy_movie.start()
 
     def _spinner_off(self):
-        if getattr(self, "busy_spinner", None) is None:
+        try:
+            sp = getattr(self, "busy_spinner", None)
+            mv = getattr(self, "_busy_movie", None)
+            if mv is not None:
+                mv.stop()
+            if sp is not None:
+                sp.setVisible(False)
+        except RuntimeError:
             return
-        if getattr(self, "_busy_movie", None) is not None:
-            self._busy_movie.stop()
-        self.busy_spinner.setVisible(False)
 
 
     def _show_busy_overlay(self):
@@ -623,11 +636,13 @@ class MultiscaleDecompDialog(QDialog):
         self._schedule_preview()
 
     def _schedule_preview(self):
-        # generic “something changed” entry point
+        if getattr(self, "_closing", False):
+            return
         self._preview_timer.start(60)
 
     def _schedule_roi_preview(self):
-        # view changed (scroll/zoom/pan) — still debounced
+        if getattr(self, "_closing", False):
+            return
         self._preview_timer.start(60)
 
     def _connect_viewport_signals(self):
@@ -736,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,
@@ -744,6 +762,7 @@ class MultiscaleDecompDialog(QDialog):
                 cfg.amount,
                 cfg.denoise,
                 sigma,
+                layer_index=i,
                 mode=mode,
             )
             return i, out
@@ -764,8 +783,15 @@ class MultiscaleDecompDialog(QDialog):
         return tuned, residual
 
     def _rebuild_preview(self):
+        if getattr(self, "_closing", False):
+            return
         self._spinner_on()
-        QApplication.processEvents()
+        QTimer.singleShot(0, self._rebuild_preview_impl)
+
+    def _rebuild_preview_impl(self):
+        if getattr(self, "_closing", False):
+            return
+
         #self._begin_busy()
         try:
             # ROI preview can't work until we have *some* pixmap in the scene to derive visible rects from.
@@ -1245,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:
@@ -1749,3 +1781,19 @@ class _MultiScaleDecompPresetDialog(QDialog):
             "linked_rgb": bool(self.cb_linked.isChecked()),
             "layers_cfg": out_layers,
         }
+def closeEvent(self, ev):
+    self._closing = True
+    try:
+        if hasattr(self, "_preview_timer"):
+            self._preview_timer.stop()
+        if hasattr(self, "_busy_show_timer"):
+            self._busy_show_timer.stop()
+        # Optional: disconnect scrollbars to stop ROI scheduling
+        try:
+            self.view.horizontalScrollBar().valueChanged.disconnect(self._schedule_roi_preview)
+            self.view.verticalScrollBar().valueChanged.disconnect(self._schedule_roi_preview)
+        except Exception:
+            pass
+    except Exception:
+        pass
+    super().closeEvent(ev)