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

setiastro/saspro/imageops/starbasedwhitebalance.py

@@ -30,10 +30,10 @@ cached_star_sources: Optional[np.ndarray] = None
 cached_flux_radii: Optional[np.ndarray] = None
 
 
-def _tone_preserve_bg_neutralize(rgb: np.ndarray) -> np.ndarray:
+def _tone_preserve_bg_neutralize(rgb: np.ndarray, *, return_pivot: bool = False):
     """
     Neutralize background using the darkest grid patch in a tone-preserving way.
-    Operates in-place on a copy; returns the neutralized image (float32 [0,1]).
+    Returns float32 RGB in [0,1]. If return_pivot, also returns the patch median (pivot).
     """
     h, w = rgb.shape[:2]
     patch_size = 10
@@ -56,12 +56,15 @@ def _tone_preserve_bg_neutralize(rgb: np.ndarray) -> np.ndarray:
     out = rgb.copy()
     if best is not None:
         avg = float(np.mean(best))
-        # “tone-preserving” shift+scale channel-wise toward avg
         for c in range(3):
             diff = float(best[c] - avg)
             denom = (1.0 - diff) if abs(1.0 - diff) > 1e-8 else 1e-8
             out[:, :, c] = np.clip((out[:, :, c] - diff) / denom, 0.0, 1.0)
-    return out
+
+    if return_pivot:
+        pivot = best.astype(np.float32) if best is not None else np.median(rgb, axis=(0, 1)).astype(np.float32)
+        return out.astype(np.float32, copy=False), pivot
+    return out.astype(np.float32, copy=False)
 
 
 def apply_star_based_white_balance(
@@ -73,38 +76,16 @@ def apply_star_based_white_balance(
 ) -> Tuple[np.ndarray, int, np.ndarray, np.ndarray, np.ndarray] | Tuple[np.ndarray, int, np.ndarray]:
     """
     Star-based white balance with background neutralization and an RGB overlay of detected stars.
-
-    Parameters
-    ----------
-    image : np.ndarray
-        RGB image (any dtype). Assumed RGB ordering.
-    threshold : float
-        SExtractor detection threshold (in background sigma).
-    autostretch : bool
-        If True, overlay is built from an autostretched view for visibility.
-    reuse_cached_sources : bool
-        If True, reuses star positions measured on a previous call (same scene).
-    return_star_colors : bool
-        If True, also returns (raw_star_pixels, after_star_pixels).
-
-    Returns
-    -------
-    balanced_rgb : float32 RGB in [0,1]
-    star_count   : int
-    overlay_rgb  : float32 RGB in [0,1] with star ellipses drawn
-    (optional) raw_star_pixels : (N,3) float array, colors sampled from ORIGINAL image
-    (optional) after_star_pixels : (N,3) float array, colors sampled after WB
+    (Correct version: does NOT crush data below the pivot.)
     """
     if image.ndim != 3 or image.shape[2] != 3:
         raise ValueError("apply_star_based_white_balance: input must be an RGB image (H,W,3).")
 
-    # 0) normalize
     img_rgb = _to_float01(image)
 
-    # 1) first background neutralization (tone-preserving)
-    bg_neutral = _tone_preserve_bg_neutralize(img_rgb)
+    # 1) background neutralization + pivot (per-channel medians of darkest patch)
+    bg_neutral, pivot = _tone_preserve_bg_neutralize(img_rgb, return_pivot=True)
 
-    # 2) detect / reuse star positions
     if sep is None:
         raise ImportError(
             "apply_star_based_white_balance requires the 'sep' package. "
@@ -135,7 +116,6 @@ def apply_star_based_white_balance(
         cached_star_sources = sources
         cached_flux_radii = r
 
-    # filter: small-ish, star-like
     mask = (r > 0) & (r <= 10)
     sources = sources[mask]
     r = r[mask]
@@ -143,15 +123,14 @@ def apply_star_based_white_balance(
         raise ValueError("All detected sources were rejected as non-stellar (too large).")
 
     h, w = gray.shape
-    # raw colors from ORIGINAL image - optimized vectorized extraction
     xs = sources["x"].astype(np.int32)
     ys = sources["y"].astype(np.int32)
     valid = (xs >= 0) & (xs < w) & (ys >= 0) & (ys < h)
+
     raw_star_pixels = img_rgb[ys[valid], xs[valid], :]
 
-    # 3) build overlay (autostretched if requested) and draw ellipses
+    # overlay
     disp = stretch_color_image(bg_neutral.copy(), 0.25) if autostretch else bg_neutral.copy()
-
     if cv2 is not None:
         overlay_bgr = cv2.cvtColor((disp * 255).astype(np.uint8), cv2.COLOR_RGB2BGR)
         for i in range(len(sources)):
@@ -160,41 +139,35 @@ def apply_star_based_white_balance(
             theta_deg = float(sources["theta"][i] * 180.0 / np.pi)
             center = (int(round(cx)), int(round(cy)))
             axes = (max(1, int(round(3 * a))), max(1, int(round(3 * b))))
-            # red ellipse in BGR
             cv2.ellipse(overlay_bgr, center, axes, angle=theta_deg, startAngle=0, endAngle=360,
                         color=(0, 0, 255), thickness=1)
         overlay_rgb = cv2.cvtColor(overlay_bgr, cv2.COLOR_BGR2RGB).astype(np.float32) / 255.0
     else:
-        # fallback: no ellipses, just the display image
         overlay_rgb = disp.astype(np.float32, copy=False)
 
-    # 4) compute WB scale using star colors sampled on bg_neutral image
-    # Optimized: vectorized extraction instead of Python loop (10-50x faster)
-    xs = sources["x"].astype(np.int32)
-    ys = sources["y"].astype(np.int32)
-    valid_mask = (xs >= 0) & (xs < w) & (ys >= 0) & (ys < h)
-    
+    # star pixels for WB
+    valid_mask = valid
     if not np.any(valid_mask):
         raise ValueError("No stellar samples available for white balance.")
-    
+
     star_pixels = bg_neutral[ys[valid_mask], xs[valid_mask], :].astype(np.float32)
     avg_color = np.mean(star_pixels, axis=0)
     max_val = float(np.max(avg_color))
-    # protect against divide-by-zero
     avg_color = np.where(avg_color <= 1e-8, 1e-8, avg_color)
-    scaling = max_val / avg_color
+    scaling = (max_val / avg_color).astype(np.float32)  # (3,)
 
-    balanced = (bg_neutral * scaling.reshape((1, 1, 3))).clip(0.0, 1.0)
+    # ✅ Correct median-locked WB (NO hard floor)
+    m = pivot.reshape((1, 1, 3)).astype(np.float32)
+    g = scaling.reshape((1, 1, 3)).astype(np.float32)
 
-    # 5) second background neutralization pass on balanced image
-    balanced = _tone_preserve_bg_neutralize(balanced)
+    balanced = (bg_neutral.astype(np.float32) - m) * g + m
+    balanced = np.clip(balanced, 0.0, 1.0).astype(np.float32, copy=False)
 
-    # 6) collect after-WB star samples - optimized vectorized extraction
     after_star_pixels = balanced[ys[valid_mask], xs[valid_mask], :]
 
     if return_star_colors:
         return (
-            balanced.astype(np.float32, copy=False),
+            balanced,
             int(len(star_pixels)),
             overlay_rgb.astype(np.float32, copy=False),
             np.asarray(raw_star_pixels, dtype=np.float32),
@@ -202,9 +175,7 @@ def apply_star_based_white_balance(
         )
 
     return (
-        balanced.astype(np.float32, copy=False),
+        balanced,
         int(len(star_pixels)),
         overlay_rgb.astype(np.float32, copy=False),
     )
-
-

setiastro/saspro/imageops/stretch.py

@@ -504,6 +504,7 @@ def stretch_color_image(image: np.ndarray,
                         hdr_knee: float = 0.75,
                         luma_only: bool = False,
                         luma_mode: str = "rec709",
+                        luma_blend: float = 1.0, 
                         high_range: bool = False,
                         highrange_pedestal: float = 0.001,
                         highrange_soft_ceil_pct: float = 99.0,
@@ -536,17 +537,64 @@ def stretch_color_image(image: np.ndarray,
 
     sig = float(blackpoint_sigma)
 
-    # ----- LUMA ONLY PATH -----
+    # ----- LUMA ONLY PATH (now with optional blending) -----
     if luma_only:
+        b = float(np.clip(luma_blend, 0.0, 1.0))
+
+        # --- A) Normal linked RGB stretch (same settings, but NOT luma-only) ---
+        # Force linked=True here (matches "normal linked stretch" expectation)
+        # We compute this first so b=0 is fast-ish if you later optimize.
+        if no_black_clip:
+            bp = float(img.min())
+            med_img = float(np.median(img))
+        else:
+            bp, med_img = _compute_blackpoint_sigma(img, sig)
+
+        denom = max(1.0 - bp, 1e-12)
+        med_rescaled = (med_img - bp) / denom
+
+        linked_out = numba_color_linked_from_img(img, bp, denom, float(med_rescaled), float(target_median))
+
+        if apply_curves:
+            linked_out = apply_curves_adjustment(linked_out, float(target_median), float(curves_boost))
+
+        if hdr_compress and hdr_amount > 0.0:
+            linked_out = hdr_compress_color_luminance(
+                linked_out,
+                amount=float(hdr_amount),
+                knee=float(hdr_knee),
+                luma_mode="rec709",
+            )
+
+        if high_range:
+            linked_out = _high_range_rescale_and_softclip(
+                linked_out,
+                target_bg=float(target_median),
+                pedestal=float(highrange_pedestal),
+                soft_ceil_pct=float(highrange_soft_ceil_pct),
+                hard_ceil_pct=float(highrange_hard_ceil_pct),
+                floor_sigma=float(blackpoint_sigma),
+                softclip_threshold=float(highrange_softclip_threshold),
+                softclip_rolloff=float(highrange_softclip_rolloff),
+            )
+
+        if normalize:
+            mx = float(linked_out.max())
+            if mx > 0:
+                linked_out = linked_out / mx
+
+        linked_out = np.clip(linked_out, 0.0, 1.0).astype(np.float32, copy=False)
+
+        # Short-circuit if blend is 0 (pure linked)
+        if b <= 0.0:
+            return linked_out
+
+        # --- B) Your existing luma-only recombine stretch ---
         resolved_method, w, _profile_name = resolve_luma_profile_weights(luma_mode)
 
-        # For snr mode, compute_luminance may require noise_sigma; your module supports that,
-        # but for stretch we can keep it simple: treat snr as normal rec709 unless you want
-        # to plumb sigma estimation here too.
-        # If you DO want snr weights, we can reuse _estimate_noise_sigma_per_channel.
         ns = None
         if resolved_method == "snr":
-            ns = _estimate_noise_sigma_per_channel(img)  # expects ~[0..1] float
+            ns = _estimate_noise_sigma_per_channel(img)
         L = compute_luminance(img, method=resolved_method, weights=w, noise_sigma=ns)
 
         Ls = stretch_mono_image(
@@ -556,23 +604,22 @@ def stretch_color_image(image: np.ndarray,
             apply_curves=apply_curves,
             curves_boost=curves_boost,
             blackpoint_sigma=sig,
+            no_black_clip=no_black_clip,
             hdr_compress=False,
             hdr_amount=0.0,
             hdr_knee=hdr_knee,
-            high_range=False,  # do high_range after recombine
+            high_range=False,
         )
 
         if hdr_compress and hdr_amount > 0.0:
             Ls = hdr_compress_highlights(Ls, float(hdr_amount), knee=float(hdr_knee))
 
-        # Choose actual RGB weights for recombine
         if w is not None and np.asarray(w).size == 3:
             rw = np.asarray(w, dtype=np.float32)
             s = float(rw.sum())
             if s > 0:
                 rw = rw / s
         else:
-            # If resolver returns None for standard modes, fall back
             if resolved_method == "rec601":
                 rw = np.array([0.2990, 0.5870, 0.1140], dtype=np.float32)
             elif resolved_method == "rec2020":
@@ -580,17 +627,17 @@ def stretch_color_image(image: np.ndarray,
             else:
                 rw = np.array([0.2126, 0.7152, 0.0722], dtype=np.float32)
 
-        out = recombine_luminance_linear_scale(
+        luma_out = recombine_luminance_linear_scale(
             img,
             Ls,
             weights=rw,
             blend=1.0,
-            highlight_soft_knee=0.0,  # separate from HDR; keep 0 unless you want extra protection
+            highlight_soft_knee=0.0,
         )
 
         if high_range:
-            out = _high_range_rescale_and_softclip(
-                out,
+            luma_out = _high_range_rescale_and_softclip(
+                luma_out,
                 target_bg=float(target_median),
                 pedestal=float(highrange_pedestal),
                 soft_ceil_pct=float(highrange_soft_ceil_pct),
@@ -601,10 +648,14 @@ def stretch_color_image(image: np.ndarray,
             )
 
         if normalize:
-            mx = float(out.max())
+            mx = float(luma_out.max())
             if mx > 0:
-                out = out / mx
+                luma_out = luma_out / mx
+
+        luma_out = np.clip(luma_out, 0.0, 1.0).astype(np.float32, copy=False)
 
+        # --- Final blend: exactly “blend two separate stretched images” ---
+        out = (1.0 - b) * linked_out + b * luma_out
         return np.clip(out, 0.0, 1.0).astype(np.float32, copy=False)
 
     # ----- NORMAL RGB PATH -----

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
@@ -407,43 +407,7 @@ def normalize_flat_cfa_inplace(flat2d: np.ndarray, pattern: str, *, combine_gree
     flat2d[flat2d == 0] = 1.0
     return flat2d
 
-@njit(parallel=True, fastmath=True)
-def apply_flat_division_numba_2d(image, master_flat, master_bias=None):
-    """
-    Mono version: image.shape == (H,W)
-    """
-    if master_bias is not None:
-        master_flat = master_flat - master_bias
-        image = image - master_bias
-
-    median_flat = np.mean(master_flat)
-    height, width = image.shape
-
-    for y in prange(height):
-        for x in range(width):
-            image[y, x] /= (master_flat[y, x] / median_flat)
-
-    return image
-
-
-@njit(parallel=True, fastmath=True)
-def apply_flat_division_numba_3d(image, master_flat, master_bias=None):
-    """
-    Color version: image.shape == (H,W,C)
-    """
-    if master_bias is not None:
-        master_flat = master_flat - master_bias
-        image = image - master_bias
-
-    median_flat = np.mean(master_flat)
-    height, width, channels = image.shape
-
-    for y in prange(height):
-        for x in range(width):
-            for c in range(channels):
-                image[y, x, c] /= (master_flat[y, x, c] / median_flat)
 
-    return image
 
 @njit(parallel=True, fastmath=True)
 def _flat_div_2d(img, flat):
@@ -563,24 +527,37 @@ def apply_flat_division_numba_bayer_2d(image, master_flat, med4, pat_id):
     Bayer-aware mono division. image/master_flat are (H,W).
     med4 is [R,G1,G2,B] for that master_flat, pat_id in {0..3}.
     """
+    # parity index = (row&1)*2 + (col&1)
+    # med4 index order: 0=R, 1=G1, 2=G2, 3=B
+
+    # tables map parity_index -> med4 index
+    # parity_index: 0:(0,0) 1:(0,1) 2:(1,0) 3:(1,1)
+    if pat_id == 0:      # RGGB:  (0,0)R (0,1)G1 (1,0)G2 (1,1)B
+        t0, t1, t2, t3 = 0, 1, 2, 3
+    elif pat_id == 1:    # BGGR:  (0,0)B (0,1)G1 (1,0)G2 (1,1)R
+        t0, t1, t2, t3 = 3, 1, 2, 0
+    elif pat_id == 2:    # GRBG:  (0,0)G1 (0,1)R (1,0)B (1,1)G2
+        t0, t1, t2, t3 = 1, 0, 3, 2
+    else:                # GBRG:  (0,0)G1 (0,1)B (1,0)R (1,1)G2
+        t0, t1, t2, t3 = 1, 3, 0, 2
+
     H, W = image.shape
     for y in prange(H):
         y1 = y & 1
         for x in range(W):
             x1 = x & 1
-
-            # map parity->plane index
-            if pat_id == 0:      # RGGB: (0,0)R (0,1)G1 (1,0)G2 (1,1)B
-                pi = 0 if (y1==0 and x1==0) else 1 if (y1==0 and x1==1) else 2 if (y1==1 and x1==0) else 3
-            elif pat_id == 1:    # BGGR
-                pi = 3 if (y1==1 and x1==1) else 1 if (y1==0 and x1==1) else 2 if (y1==1 and x1==0) else 0
-            elif pat_id == 2:    # GRBG
-                pi = 1 if (y1==0 and x1==0) else 0 if (y1==0 and x1==1) else 3 if (y1==1 and x1==0) else 2
-            else:                # GBRG
-                pi = 1 if (y1==0 and x1==0) else 3 if (y1==0 and x1==1) else 0 if (y1==1 and x1==0) else 2
+            p = (y1 << 1) | x1  # 0..3
+            if p == 0:
+                pi = t0
+            elif p == 1:
+                pi = t1
+            elif p == 2:
+                pi = t2
+            else:
+                pi = t3
 
             denom = master_flat[y, x] / med4[pi]
-            if denom == 0.0 or not np.isfinite(denom):
+            if denom == 0.0 or (not np.isfinite(denom)):
                 denom = 1.0
             image[y, x] /= denom
     return image

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: