setiastrosuitepro 1.6.1.post1__py3-none-any.whl → 1.6.4__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/remove_stars_preset.py

@@ -12,7 +12,7 @@ from setiastro.saspro.legacy.image_manager import save_image, load_image
 # Reuse helpers & plumbing from the interactive module
 from .remove_stars import (
     _ProcThread, _ProcDialog,
-    _stat_stretch_rgb, _stat_unstretch_rgb,
+    _mtf_params_unlinked, _apply_mtf_unlinked_rgb, _invert_mtf_unlinked_rgb,
     _active_mask3_from_doc, _mask_blend_with_doc_mask, _push_as_new_doc,
     _ensure_exec_bit,
 )
@@ -125,24 +125,48 @@ def _run_starnet_headless(main, doc, p):
     processing_image = processing_image.astype(np.float32, copy=False)
 
     is_linear = bool(p.get("linear", True))
-    did_stretch = False
-    stretch_params = None
+    did_stretch = is_linear
+
+    # sanitize + normalize if needed (keep exactly like interactive)
+    processing_image = np.nan_to_num(processing_image, nan=0.0, posinf=0.0, neginf=0.0).astype(np.float32, copy=False)
+
+    scale_factor = float(np.max(processing_image)) if processing_image.size else 1.0
+    processing_norm = (processing_image / scale_factor) if scale_factor > 1.0 else processing_image
+    processing_norm = np.clip(processing_norm, 0.0, 1.0)
+
+    img_for_starnet = processing_norm
+
     if is_linear:
-        processing_image, stretch_params = _stat_stretch_rgb(processing_image)
-        did_stretch = True
-        setattr(main, "_starnet_last_stretch_params", stretch_params)
+        mtf_params = _mtf_params_unlinked(processing_norm, shadows_clipping=-2.8, targetbg=0.25)
+        img_for_starnet = _apply_mtf_unlinked_rgb(processing_norm, mtf_params)
+
+        # stash for inverse step (same keys as interactive)
+        try:
+            setattr(main, "_starnet_stat_meta", {
+                "scheme": "siril_mtf",
+                "s": np.asarray(mtf_params["s"], dtype=np.float32),
+                "m": np.asarray(mtf_params["m"], dtype=np.float32),
+                "h": np.asarray(mtf_params["h"], dtype=np.float32),
+                "scale": float(scale_factor),
+            })
+        except Exception:
+            pass
     else:
-        if hasattr(main, "_starnet_last_stretch_params"):
-            delattr(main, "_starnet_last_stretch_params")
+        try:
+            if hasattr(main, "_starnet_stat_meta"):
+                delattr(main, "_starnet_stat_meta")
+        except Exception:
+            pass
+
 
     starnet_dir = os.path.dirname(exe) or os.getcwd()
     in_path  = os.path.join(starnet_dir, "imagetoremovestars.tif")
     out_path = os.path.join(starnet_dir, "starless.tif")
 
     try:
-        save_image(processing_image, in_path, original_format="tif",
-                   bit_depth="16-bit", original_header=None, is_mono=False,
-                   image_meta=None, file_meta=None)
+        save_image(img_for_starnet, in_path, original_format="tif",
+                bit_depth="16-bit", original_header=None, is_mono=False,
+                image_meta=None, file_meta=None)
     except Exception as e:
         QMessageBox.critical(main, "StarNet", f"Failed to write input TIFF:\n{e}")
         return
@@ -179,12 +203,30 @@ def _finish_starnet(main, doc, rc, dlg, in_path, out_path, did_stretch):
     starless_rgb = starless_rgb.astype(np.float32, copy=False)
 
     if did_stretch:
+        meta = getattr(main, "_starnet_stat_meta", None)
+        if isinstance(meta, dict) and meta.get("scheme") == "siril_mtf":
+            try:
+                p = {
+                    "s": np.asarray(meta.get("s"), dtype=np.float32),
+                    "m": np.asarray(meta.get("m"), dtype=np.float32),
+                    "h": np.asarray(meta.get("h"), dtype=np.float32),
+                }
+                inv = _invert_mtf_unlinked_rgb(starless_rgb, p)
+                sc = float(meta.get("scale", 1.0))
+                if sc > 1.0:
+                    inv *= sc
+                starless_rgb = np.clip(inv, 0.0, 1.0).astype(np.float32, copy=False)
+            except Exception:
+                pass
+
+        # cleanup so it can't leak
         try:
-            params = getattr(main, "_starnet_last_stretch_params", None)
-            if params: starless_rgb = _stat_unstretch_rgb(starless_rgb, params)
+            if hasattr(main, "_starnet_stat_meta"):
+                delattr(main, "_starnet_stat_meta")
         except Exception:
             pass
 
+
     # original as RGB
     orig = np.asarray(doc.image)
     if orig.ndim == 2: original_rgb = np.stack([orig]*3, axis=-1)

setiastro/saspro/resources.py

@@ -123,17 +123,31 @@ def _get_base_path() -> str:
 
 
 def _resource_path(filename: str) -> str:
-    """Get full path to a resource file."""
     base = _get_base_path()
-    
-    # Check if it's an image file - look in images/ subdirectory
-    if filename.endswith(('.png', '.ico', '.gif', '.icns', '.svg')):
-        images_path = os.path.join(base, 'images', filename)
-        if os.path.exists(images_path):
-            return images_path
-    
-    # Fallback to root directory (for data files like .csv, .fits, etc.)
-    return os.path.join(base, filename)
+    fn = filename
+
+    is_img = fn.lower().endswith(('.png','.ico','.gif','.icns','.svg','.jpg','.jpeg','.bmp'))
+    if is_img:
+        candidates = [
+            os.path.join(base, 'images', fn),
+            os.path.join(base, 'setiastro', 'images', fn),
+            os.path.join(base, 'setiastro', 'saspro', 'images', fn),
+        ]
+        for p in candidates:
+            if os.path.exists(p):
+                return p
+
+    # data / other files
+    candidates = [
+        os.path.join(base, fn),
+        os.path.join(base, 'setiastro', fn),
+        os.path.join(base, 'setiastro', 'saspro', fn),
+    ]
+    for p in candidates:
+        if os.path.exists(p):
+            return p
+
+    return os.path.join(base, fn)
 
 
 class Icons:
@@ -210,6 +224,7 @@ class Icons:
     ROTATE_CW = property(lambda self: _resource_path('rotateclockwise.png'))
     ROTATE_CCW = property(lambda self: _resource_path('rotatecounterclockwise.png'))
     ROTATE_180 = property(lambda self: _resource_path('rotate180.png'))
+    ROTATE_ANY      = property(lambda self: _resource_path('rotatearbitrary.png'))
     RESCALE = property(lambda self: _resource_path('rescale.png'))
     
     # Masks
@@ -395,6 +410,7 @@ def _init_legacy_paths():
         'rotateclockwise_path': get_icon_path('rotateclockwise.png'),
         'rotatecounterclockwise_path': get_icon_path('rotatecounterclockwise.png'),
         'rotate180_path': get_icon_path('rotate180.png'),
+        'rotatearbitrary_path': get_icon_path('rotatearbitrary.png'),
         'maskcreate_path': get_icon_path('maskcreate.png'),
         'maskapply_path': get_icon_path('maskapply.png'),
         'maskremove_path': get_icon_path('maskremove.png'),
@@ -469,9 +485,19 @@ def _init_legacy_paths():
 _legacy = _init_legacy_paths()
 globals().update(_legacy)
 
+
+# Background for startup
+background_startup_path = _resource_path('Background_startup.jpg')
+_legacy['background_startup_path'] = background_startup_path
+
+# QML helper
+resource_monitor_qml = _resource_path(os.path.join("qml", "ResourceMonitor.qml"))
+
 # 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)