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

setiastro/saspro/remove_stars.py

@@ -136,154 +136,82 @@ def _mtf_params_unlinked(img_rgb01: np.ndarray,
     Works on float32 data assumed in [0,1].
     Returns dict with arrays: {'s': (C,), 'm': (C,), 'h': (C,)}.
     """
-    x = np.asarray(img_rgb01, dtype=np.float32)
-    # Force 3 channels internally (Siril expects 1 or 3; we always give it 3 here)
-    if x.ndim == 2:
-        x = np.stack([x] * 3, axis=-1)
-    elif x.ndim == 3 and x.shape[2] == 1:
-        x = np.repeat(x, 3, axis=2)
-
-    C = x.shape[2]
-    s = np.zeros(C, dtype=np.float32)
-    m = np.zeros(C, dtype=np.float32)
-    h = np.zeros(C, dtype=np.float32)
-
-    med = np.zeros(C, dtype=np.float32)
-    mad = np.zeros(C, dtype=np.float32)
-    inverted_flags = np.zeros(C, dtype=bool)
-
-    # --- stats per channel (Siril: median / normValue, mad / normValue * MAD_NORM) ---
-    # Here normValue == 1.0 because we're already in [0,1]
-    for c in range(C):
-        ch = x[..., c].astype(np.float32, copy=False)
-        med_c = float(np.median(ch))
-        mad_raw = float(np.median(np.abs(ch - med_c)))
-        mad_c = mad_raw * _MAD_NORM
-        if mad_c == 0.0:
-            mad_c = 0.001
-
-        med[c] = med_c
-        mad[c] = mad_c
-        if med_c > 0.5:
-            inverted_flags[c] = True
-
-    inverted_channels = int(inverted_flags.sum())
-
-    # --- Main branch (non-inverted dominant) ---
-    if inverted_channels < C:
-        for c in range(C):
-            median = float(med[c])
-            mad_c = float(mad[c])
-
-            c0 = median + shadows_clipping * mad_c
-            if c0 < 0.0:
-                c0 = 0.0
-            # Siril: m2 = median - c0; midtones = MTF(m2, target_bg, 0,1)
-            m2 = median - c0
-            mid = float(_mtf_scalar(m2, targetbg, 0.0, 1.0))
-
-            s[c] = c0
-            m[c] = mid
-            h[c] = 1.0
-
-    # --- Inverted channel branch ---
-    else:
-        for c in range(C):
-            median = float(med[c])
-            mad_c = float(mad[c])
-
-            c1 = median - shadows_clipping * mad_c
-            if c1 > 1.0:
-                c1 = 1.0
-            m2 = c1 - median
-            mid = 1.0 - float(_mtf_scalar(m2, targetbg, 0.0, 1.0))
-
-            s[c] = 0.0
-            m[c] = mid
-            h[c] = c1
-
-    return {"s": s, "m": m, "h": h}
-
-
-def _apply_mtf_unlinked_rgb(img_rgb01: np.ndarray, p: dict) -> np.ndarray:
     """
-    Apply per-channel MTF exactly. p from _mtf_params_unlinked.
+    Siril-style per-channel MTF parameter estimation, matching
+    find_unlinked_midtones_balance_default() / find_unlinked_midtones_balance().
+
+    Works on float32 data assumed in [0,1].
+    Returns dict with arrays: {'s': (C,), 'm': (C,), 'h': (C,)}.
     """
     x = np.asarray(img_rgb01, dtype=np.float32)
+    
+    # Analyze input shape to handle mono efficiently
     if x.ndim == 2:
-        x = np.stack([x]*3, axis=-1)
+        # (H, W) -> treat as single channel
+        x_in = x[..., None] # Virtual 3D (H,W,1)
+        C_in = 1
     elif x.ndim == 3 and x.shape[2] == 1:
-        x = np.repeat(x, 3, axis=2)
-
-    out = np.empty_like(x, dtype=np.float32)
-    for c in range(x.shape[2]):
-        out[..., c] = _mtf_apply(x[..., c], float(p["s"][c]), float(p["m"][c]), float(p["h"][c]))
-    return np.clip(out, 0.0, 1.0)
-
-
-def _invert_mtf_unlinked_rgb(img_rgb01: np.ndarray, p: dict) -> np.ndarray:
-    """
-    Exact analytic inverse per channel (uses same s/m/h arrays).
-    """
-    y = np.asarray(img_rgb01, dtype=np.float32)
-    if y.ndim == 2:
-        y = np.stack([y]*3, axis=-1)
-    elif y.ndim == 3 and y.shape[2] == 1:
-        y = np.repeat(y, 3, axis=2)
-
-    out = np.empty_like(y, dtype=np.float32)
-    for c in range(y.shape[2]):
-        out[..., c] = _mtf_inverse(y[..., c], float(p["s"][c]), float(p["m"][c]), float(p["h"][c]))
-    return np.clip(out, 0.0, 1.0)
-
-def _stat_stretch_rgb(img: np.ndarray,
-                      lo_pct: float = 0.25,
-                      hi_pct: float = 99.75) -> tuple[np.ndarray, dict]:
-    """
-    Make sure img is RGB float32 in [0,1], stretch each channel to [0,1]
-    using percentiles. Returns (stretched_img, params) where params can be
-    fed to _stat_unstretch_rgb() to invert exactly.
-    """
-    was_single = (img.ndim == 2) or (img.ndim == 3 and img.shape[2] == 1)
-    if was_single:
-        img = np.stack([img] * 3, axis=-1)
-
-    x = img.astype(np.float32, copy=False)
-    out = np.empty_like(x, dtype=np.float32)
-    lo_vals, hi_vals = [], []
+        x_in = x
+        C_in = 1
+    else:
+        x_in = x
+        C_in = x.shape[2]
+
+    # Vectorized stats calculation on actual data only
+    med = np.median(x_in, axis=(0, 1)).astype(np.float32) # shape (C_in,)
+    
+    # MAD requires centered abs diff
+    diff = np.abs(x_in - med.reshape(1, 1, C_in))
+    mad_raw = np.median(diff, axis=(0, 1)).astype(np.float32) # shape (C_in,)
+    
+    mad = mad_raw * _MAD_NORM
+    mad[mad == 0] = 0.001
+
+    inverted_flags = (med > 0.5)
+    # If mono, we just check the one channel. If RGB, we check all.
+    # Logic below assumes we return 3-channel params s,m,h even for mono input (broadcasted).
+    
+    # To match original behavior which always returned 3-element arrays for s,m,h:
+    # We will compute s_in, m_in, h_in for the input channels, then broadcast to 3.
+    
+    s_in = np.zeros(C_in, dtype=np.float32)
+    m_in = np.zeros(C_in, dtype=np.float32)
+    h_in = np.zeros(C_in, dtype=np.float32)
+
+    # We iterate C_in times (1 or 3)
+    for c in range(C_in):
+        is_inv = inverted_flags[c]
+        md = med[c]
+        md_dev = mad[c]
+        
+        if not is_inv:
+            # Normal
+            c0 = max(md + shadows_clipping * md_dev, 0.0)
+            m2 = md - c0
+            
+            s_in[c] = c0
+            m_in[c] = float(_mtf_scalar(m2, targetbg, 0.0, 1.0))
+            h_in[c] = 1.0
+        else:
+            # Inverted
+            c1 = min(md - shadows_clipping * md_dev, 1.0)
+            m2 = c1 - md
+            
+            s_in[c] = 0.0
+            m_in[c] = 1.0 - float(_mtf_scalar(m2, targetbg, 0.0, 1.0))
+            h_in[c] = c1
+
+    # Broadcast to 3 channels if needed
+    if C_in == 1:
+        s = np.repeat(s_in, 3)
+        m = np.repeat(m_in, 3)
+        h = np.repeat(h_in, 3)
+    else:
+        s = s_in
+        m = m_in
+        h = h_in
 
-    for c in range(3):
-        ch = x[..., c]
-        lo = float(np.percentile(ch, lo_pct))
-        hi = float(np.percentile(ch, hi_pct))
-        if not np.isfinite(lo): lo = 0.0
-        if not np.isfinite(hi): hi = 1.0
-        if hi - lo < 1e-6:
-            hi = lo + 1e-6
-        lo_vals.append(lo); hi_vals.append(hi)
-        out[..., c] = (ch - lo) / (hi - lo)
-
-    out = np.clip(out, 0.0, 1.0)
-    params = {"lo": lo_vals, "hi": hi_vals, "was_single": was_single}
-    return out, params
-
-
-def _stat_unstretch_rgb(img: np.ndarray, params: dict) -> np.ndarray:
-    """
-    Inverse of _stat_stretch_rgb. Expects img RGB float32 [0,1].
-    """
-    lo = np.asarray(params["lo"], dtype=np.float32)
-    hi = np.asarray(params["hi"], dtype=np.float32)
-    out = img.astype(np.float32, copy=True)
-    for c in range(3):
-        out[..., c] = out[..., c] * (hi[c] - lo[c]) + lo[c]
-    out = np.clip(out, 0.0, 1.0)
-    if params.get("was_single", False):
-        out = out.mean(axis=2, keepdims=False)  # back to single channel if needed
-        # StarNet needs RGB during processing; we keep RGB after removal for consistency.
-        # If you want to return mono to the doc when the source was mono, do it at the very end.
-        out = np.stack([out] * 3, axis=-1)
-    return out
+    return {"s": s, "m": m, "h": h}
 
 def _mtf_scalar(x: float, m: float, lo: float = 0.0, hi: float = 1.0) -> float:
     """
@@ -324,6 +252,36 @@ def _mtf_scalar(x: float, m: float, lo: float = 0.0, hi: float = 1.0) -> float:
     return float(y)
 
 
+def _apply_mtf_unlinked_rgb(img_rgb01: np.ndarray, p: dict) -> np.ndarray:
+    """
+    Apply per-channel MTF exactly. p from _mtf_params_unlinked.
+    """
+    x = np.asarray(img_rgb01, dtype=np.float32)
+    if x.ndim == 2:
+        x = np.stack([x]*3, axis=-1)
+    elif x.ndim == 3 and x.shape[2] == 1:
+        x = np.repeat(x, 3, axis=2)
+
+    out = np.empty_like(x, dtype=np.float32)
+    for c in range(x.shape[2]):
+        out[..., c] = _mtf_apply(x[..., c], float(p["s"][c]), float(p["m"][c]), float(p["h"][c]))
+    return np.clip(out, 0.0, 1.0)
+
+
+def _invert_mtf_unlinked_rgb(img_rgb01: np.ndarray, p: dict) -> np.ndarray:
+    """
+    Exact analytic inverse per channel (uses same s/m/h arrays).
+    """
+    y = np.asarray(img_rgb01, dtype=np.float32)
+    if y.ndim == 2:
+        y = np.stack([y]*3, axis=-1)
+    elif y.ndim == 3 and y.shape[2] == 1:
+        y = np.repeat(y, 3, axis=2)
+
+    out = np.empty_like(y, dtype=np.float32)
+    for c in range(y.shape[2]):
+        out[..., c] = _mtf_inverse(y[..., c], float(p["s"][c]), float(p["m"][c]), float(p["h"][c]))
+    return np.clip(out, 0.0, 1.0)
 # ------------------------------------------------------------
 # Settings helper
 # ------------------------------------------------------------
@@ -370,24 +328,28 @@ def starnet_starless_from_array(arr_rgb01: np.ndarray, settings, *, tmp_prefix="
     in_path  = os.path.join(workdir, f"{tmp_prefix}_in.tif")
     out_path = os.path.join(workdir, f"{tmp_prefix}_out.tif")
 
-    # --- Normalize input shape and safe values ---
-    x = arr
-    if x.ndim == 2:
-        x = np.stack([x] * 3, axis=-1)
-    elif x.ndim == 3 and x.shape[2] == 1:
-        x = np.repeat(x, 3, axis=2)
-    x = np.nan_to_num(x, nan=0.0, posinf=0.0, neginf=0.0).astype(np.float32, copy=False)
+    # --- Normalize input shape (virtual) and safe values ---
+    x_in = np.asarray(arr, dtype=np.float32)
+
+    # If (H,W,1), collapse to (H,W) so mono flows cleanly
+    if x_in.ndim == 3 and x_in.shape[2] == 1:
+        x_in = x_in[..., 0]
+
+    # sanitize
+    x_in = np.nan_to_num(x_in, nan=0.0, posinf=0.0, neginf=0.0).astype(np.float32, copy=False)
 
     # Preserve original numeric scale if users pass >1.0
-    xmax = float(np.max(x)) if x.size else 1.0
+    xmax = float(np.max(x_in)) if x_in.size else 1.0
     scale_factor = xmax if xmax > 1.01 else 1.0
-    xin = (x / scale_factor) if scale_factor > 1.0 else x
+
+    xin = (x_in / scale_factor) if scale_factor > 1.0 else x_in
     xin = np.clip(xin, 0.0, 1.0)
 
     # --- Siril-style unlinked MTF params + pre-stretch ---
     mtf_params = _mtf_params_unlinked(xin, shadows_clipping=-2.8, targetbg=0.25)
     x_for_starnet = _apply_mtf_unlinked_rgb(xin, mtf_params).astype(np.float32, copy=False)
 
+
     # --- Write 16-bit TIFF for StarNet ---
     save_image(
         x_for_starnet, in_path,
@@ -662,18 +624,19 @@ def _run_starnet(main, doc):
             )
     except Exception:
         pass    
-    # --- Ensure RGB float32 in safe range
+    # --- Ensure RGB float32 in safe range (without expanding yet)
+    # Starnet needs RGB eventually, but we can compute stats/normalization on mono
     src = np.asarray(doc.image)
-    if src.ndim == 2:
-        processing_image = np.stack([src]*3, axis=-1)
-    elif src.ndim == 3 and src.shape[2] == 1:
-        processing_image = np.repeat(src, 3, axis=2)
+    if src.ndim == 3 and src.shape[2] == 1:
+        # standardizing shape is cheap
+        processing_image = src[..., 0]
     else:
         processing_image = src
+        
     processing_image = np.nan_to_num(processing_image.astype(np.float32, copy=False),
                                      nan=0.0, posinf=0.0, neginf=0.0)
 
-    # --- Scale normalization if >1.0 (same reason as before: 16-bit export safety)
+    # --- Scale normalization if >1.0
     scale_factor = float(np.max(processing_image))
     if scale_factor > 1.0:
         processing_norm = processing_image / scale_factor
@@ -1027,11 +990,10 @@ def _run_darkstar(main, doc):
         pass
 
     # --- Build processing image (RGB float32, normalized) ---
+    # DarkStar needs RGB, but we can delay expansion until save
     src = np.asarray(doc.image)
-    if src.ndim == 2:
-        processing_image = np.stack([src] * 3, axis=-1)
-    elif src.ndim == 3 and src.shape[2] == 1:
-        processing_image = np.repeat(src, 3, axis=2)
+    if src.ndim == 3 and src.shape[2] == 1:
+        processing_image = src[..., 0]
     else:
         processing_image = src
 
@@ -1088,8 +1050,20 @@ def _run_darkstar(main, doc):
     # --- Save pre-stretched image as 32-bit float TIFF for DarkStar ---
     in_path = os.path.join(input_dir, "imagetoremovestars.tif")
     try:
+        # Check if we need to expand on-the-fly for DarkStar (it expects RGB input)
+        # If img_for_darkstar is mono, save_image might save mono.
+        # "is_mono=False" flag to save_image hints we want RGB.
+        # If the array is 2D, save_image might still save mono unless we feed it 3D.
+        # For safety with DarkStar, we create the 3D view now if needed.
+        
+        to_save = img_for_darkstar
+        if to_save.ndim == 2:
+            to_save = np.stack([to_save]*3, axis=-1)
+        elif to_save.ndim == 3 and to_save.shape[2] == 1:
+            to_save = np.repeat(to_save, 3, axis=2)
+            
         save_image(
-            img_for_darkstar,
+            to_save,
             in_path,
             original_format="tif",
             bit_depth="32-bit floating point",

setiastro/saspro/resources.py

@@ -469,9 +469,16 @@ def _init_legacy_paths():
 _legacy = _init_legacy_paths()
 globals().update(_legacy)
 
+
+# Background for startup
+background_startup_path = os.path.join(_get_base_path(), 'images', 'Background_startup.jpg')
+_legacy['background_startup_path'] = background_startup_path
+
 # Export list for `from setiastro.saspro.resources import *`
 __all__ = [
     'Icons', 'Resources', 
     'get_icons', 'get_resources',
     'get_icon_path', 'get_data_path',
+    'background_startup_path',
 ] + list(_legacy.keys())
+

setiastro/saspro/rgb_combination.py

@@ -44,6 +44,7 @@ class RGBCombinationDialogPro(QDialog):
         super().__init__(parent)
         self.setWindowTitle(self.tr("RGB Combination"))
         self.setWindowFlag(Qt.WindowType.Window, True)
+        self.setWindowModality(Qt.WindowModality.NonModal)
         self.setModal(False)
         #self.setAttribute(Qt.WidgetAttribute.WA_DeleteOnClose, True)
         self._list_open_docs = list_open_docs_fn or (lambda: [])

setiastro/saspro/rgbalign.py

@@ -324,15 +324,12 @@ class RGBAlignWorker(QThread):
     def _warp_channel(self, ch: np.ndarray, kind: str, X, ref_shape):
         H, W = ref_shape[:2]
         if kind == "affine":
-            if cv2 is None:
-                return ch
+            # Just assume cv2 is available (standard dependency) for perf
             A = np.asarray(X, dtype=np.float32).reshape(2, 3)
             return cv2.warpAffine(ch, A, (W, H), flags=cv2.INTER_LANCZOS4,
                                   borderMode=cv2.BORDER_CONSTANT, borderValue=0)
 
         if kind == "homography":
-            if cv2 is None:
-                return ch
             Hm = np.asarray(X, dtype=np.float32).reshape(3, 3)
             return cv2.warpPerspective(ch, Hm, (W, H), flags=cv2.INTER_LANCZOS4,
                                        borderMode=cv2.BORDER_CONSTANT, borderValue=0)
@@ -350,6 +347,9 @@ class RGBAlignDialog(QDialog):
     def __init__(self, parent=None, document=None):
         super().__init__(parent)
         self.setWindowTitle(self.tr("RGB Align"))
+        self.setWindowFlag(Qt.WindowType.Window, True)
+        self.setWindowModality(Qt.WindowModality.NonModal)
+        self.setModal(False)
         self.parent = parent
         # document could be a view; try to unwrap
         self.doc_view = document

setiastro/saspro/save_options.py

@@ -20,6 +20,7 @@ class SaveOptionsDialog(QDialog):
         super().__init__(parent)
         self.setWindowTitle(self.tr("Save Options"))
         self.setWindowFlag(Qt.WindowType.Window, True)
+        self.setWindowModality(Qt.WindowModality.NonModal)
         self.setModal(False)
         #self.setAttribute(Qt.WidgetAttribute.WA_DeleteOnClose, True)
 

setiastro/saspro/sfcc.py

@@ -346,6 +346,9 @@ class SFCCDialog(QDialog):
     def __init__(self, doc_manager, sasp_data_path, parent=None):
         super().__init__(parent)
         self.setWindowTitle(self.tr("Spectral Flux Color Calibration"))
+        self.setWindowFlag(Qt.WindowType.Window, True)
+        self.setWindowModality(Qt.WindowModality.NonModal)
+        self.setModal(False)
         self.setMinimumSize(800, 600)
 
         self.doc_manager = doc_manager
@@ -1155,18 +1158,56 @@ class SFCCDialog(QDialog):
         diag_meas_BG, diag_exp_BG = [], []
         enriched = []
 
+        # --- Optimization: Pre-calculate integrals for unique templates ---
+        unique_simbad_types = set(m["template"] for m in raw_matches)
+        
+        # Map simbad_type -> pickles_template_name
+        simbad_to_pickles = {}
+        pickles_templates_needed = set()
+        
+        for sp in unique_simbad_types:
+            cands = pickles_match_for_simbad(sp, getattr(self, "pickles_templates", []))
+            if cands:
+                pickles_name = cands[0]
+                simbad_to_pickles[sp] = pickles_name
+                pickles_templates_needed.add(pickles_name)
+
+        # Pre-calc integrals for each unique Pickles template
+        # Cache structure: template_name -> (S_sr, S_sg, S_sb)
+        template_integrals = {}
+
+        # Cache for load_sed to avoid re-reading even across different calls if desired, 
+        # but here we just optimize the loop.
+        
+        for pname in pickles_templates_needed:
+            try:
+                wl_s, fl_s = load_sed(pname)
+                fs_i = np.interp(wl_grid, wl_s, fl_s, left=0., right=0.)
+                
+                S_sr = np.trapezoid(fs_i * T_sys_R, x=wl_grid)
+                S_sg = np.trapezoid(fs_i * T_sys_G, x=wl_grid)
+                S_sb = np.trapezoid(fs_i * T_sys_B, x=wl_grid)
+                
+                template_integrals[pname] = (S_sr, S_sg, S_sb)
+            except Exception as e:
+                print(f"[SFCC] Warning: failed to load/integrate template {pname}: {e}")
+
+        # --- Main Match Loop ---
         for m in raw_matches:
             xi, yi, sp = m["x_pix"], m["y_pix"], m["template"]
             Rm = float(base[yi, xi, 0]); Gm = float(base[yi, xi, 1]); Bm = float(base[yi, xi, 2])
             if Gm <= 0: continue
 
-            cands = pickles_match_for_simbad(sp, getattr(self, "pickles_templates", []))
-            if not cands: continue
-            wl_s, fl_s = load_sed(cands[0])
-            fs_i = np.interp(wl_grid, wl_s, fl_s, left=0., right=0.)
-            S_sr = np.trapezoid(fs_i * T_sys_R, x=wl_grid)
-            S_sg = np.trapezoid(fs_i * T_sys_G, x=wl_grid)
-            S_sb = np.trapezoid(fs_i * T_sys_B, x=wl_grid)
+            # 1. Resolve Simbad -> Pickles
+            pname = simbad_to_pickles.get(sp)
+            if not pname: continue
+            
+            # 2. Retrieve pre-calced integrals
+            integrals = template_integrals.get(pname)
+            if not integrals: continue
+            
+            S_sr, S_sg, S_sb = integrals
+            
             if S_sg <= 0: continue
 
             exp_RG = S_sr / S_sg; exp_BG = S_sb / S_sg
@@ -1180,7 +1221,8 @@ class SFCCDialog(QDialog):
                 "S_star_R": S_sr, "S_star_G": S_sg, "S_star_B": S_sb,
                 "exp_RG": exp_RG, "exp_BG": exp_BG
             })
-        self._last_matched = enriched  # <-- missing in SASpro
+            
+        self._last_matched = enriched
         diag_meas_RG = np.array(diag_meas_RG); diag_exp_RG = np.array(diag_exp_RG)
         diag_meas_BG = np.array(diag_meas_BG); diag_exp_BG = np.array(diag_exp_BG)
         if diag_meas_RG.size == 0 or diag_meas_BG.size == 0:

setiastro/saspro/signature_insert.py

@@ -363,6 +363,9 @@ class SignatureInsertDialogPro(QDialog):
     def __init__(self, parent, doc, icon: QIcon | None = None):
         super().__init__(parent)
         self.setWindowTitle(self.tr("Signature / Insert"))
+        self.setWindowFlag(Qt.WindowType.Window, True)
+        self.setWindowModality(Qt.WindowModality.NonModal)
+        self.setModal(False)
         if icon:
             try: self.setWindowIcon(icon)
             except Exception as e: