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

setiastro/saspro/star_alignment.py

@@ -159,7 +159,7 @@ def _align_prefs(settings: QSettings | None = None) -> dict:
     prefs = {
         "model":       model,                 # "affine" | "homography" | "poly3" | "poly4"
         "max_cp":      _get("max_cp", 250, int),
-        "downsample":  _get("downsample", 2, int),
+        "downsample":  _get("downsample", 3, int),
         "h_reproj":    _get("h_reproj", 3.0, float),
 
         # Star detection / solve limits
@@ -631,7 +631,10 @@ class StellarAlignmentDialog(QDialog):
         self.setWindowFlag(Qt.WindowType.Window, True)
         self.setWindowModality(Qt.WindowModality.NonModal)
         self.setModal(False)
-        #self.setAttribute(Qt.WidgetAttribute.WA_DeleteOnClose, True)
+        try:
+            self.setAttribute(Qt.WidgetAttribute.WA_DeleteOnClose, True)
+        except Exception:
+            pass  # older PyQt6 versions
 
         self.settings = settings
         self.parent_window = parent
@@ -1438,6 +1441,34 @@ class RegistrationWorkerSignals(QObject):
 # Identity transform (2x3)
 IDENTITY_2x3 = np.array([[1, 0, 0], [0, 1, 0]], dtype=np.float64)
 
+def _to3x3_affine(A2x3: np.ndarray) -> np.ndarray:
+    A = np.asarray(A2x3, np.float64).reshape(2,3)
+    return np.vstack([A, [0,0,1]])
+
+def _from3x3_affine(A3: np.ndarray) -> np.ndarray:
+    return np.asarray(A3, np.float64)[:2,:]
+
+def _S(ds: float) -> np.ndarray:
+    ds = float(ds)
+    return np.array([[1.0/ds, 0, 0],
+                     [0, 1.0/ds, 0],
+                     [0, 0, 1]], np.float64)
+
+def lift_affine_2x3_from_ds(A_ds_2x3: np.ndarray, ds: float) -> np.ndarray:
+    S = _S(ds); Si = np.linalg.inv(S)
+    A3_full = Si @ _to3x3_affine(A_ds_2x3) @ S
+    return _from3x3_affine(A3_full)
+
+def downscale_affine_2x3_to_ds(A_full_2x3: np.ndarray, ds: float) -> np.ndarray:
+    S = _S(ds); Si = np.linalg.inv(S)
+    A3_ds = S @ _to3x3_affine(A_full_2x3) @ Si
+    return _from3x3_affine(A3_ds)
+
+def lift_homography_from_ds(H_ds: np.ndarray, ds: float) -> np.ndarray:
+    S = _S(ds); Si = np.linalg.inv(S)
+    return Si @ np.asarray(H_ds, np.float64) @ S
+
+
 def compute_affine_transform_astroalign_cropped(source_img, reference_img,
                                                 scale: float = 1.20,
                                                 limit_stars: int | None = None,
@@ -1879,31 +1910,34 @@ def project_affine_to_similarity(A2x3: np.ndarray) -> np.ndarray:
 def _solve_delta_job(args):
     """
     Worker: compute incremental affine/similarity delta for one frame against the ref preview.
-    args = (orig_path, current_transform_2x3, ref_small, Wref, Href,
-            resample_flag, det_sigma, limit_stars, minarea,
-            model, h_reproj)
+    args =
+      (orig_path, current_transform_2x3,
+       ref_small_ds, Wref_ds, Href_ds,
+       resample_flag, det_sigma, limit_stars, minarea,
+       model, h_reproj, ds)
     """
     try:
         import os
         import numpy as np
         import cv2
-        import sep
         from astropy.io import fits
 
-        (orig_path, current_transform_2x3, ref_small, Wref, Href,
+        (orig_path, current_transform_2x3,
+         ref_small_ds, Wref_ds, Href_ds,
          resample_flag, det_sigma, limit_stars, minarea,
-         model, h_reproj) = args
+         model, h_reproj, ds) = args
+
+        ds = max(1, int(ds))
 
         try:
             cv2.setNumThreads(1)
             try: cv2.ocl.setUseOpenCL(False)
-            except Exception as e:
-                import logging
-                logging.debug(f"Exception suppressed: {type(e).__name__}: {e}")
+            except Exception:
+                pass
         except Exception:
             pass
 
-        # 1) read → gray float32
+        # 1) read → gray float32 (full)
         with fits.open(orig_path, memmap=True) as hdul:
             arr = hdul[0].data
             if arr is None:
@@ -1911,48 +1945,66 @@ def _solve_delta_job(args):
             gray = arr if arr.ndim == 2 else np.mean(arr, axis=2)
             gray = np.nan_to_num(gray, nan=0.0, posinf=0.0, neginf=0.0).astype(np.float32, copy=False)
 
-        # 2) pre-warp to REF size
-        T_prev = np.asarray(current_transform_2x3, np.float32).reshape(2, 3)
-        src_for_match = cv2.warpAffine(
-            gray, T_prev, (Wref, Href),
+        # 2) downsample source to DS space
+        if ds > 1:
+            Wds = max(1, int(gray.shape[1] // ds))
+            Hds = max(1, int(gray.shape[0] // ds))
+            gray_ds = cv2.resize(gray, (Wds, Hds), interpolation=cv2.INTER_AREA)
+        else:
+            gray_ds = gray
+
+        # 3) pre-warp in DS space using downscaled transform
+        T_prev_full = np.asarray(current_transform_2x3, np.float64).reshape(2, 3)
+        T_prev_ds = downscale_affine_2x3_to_ds(T_prev_full, ds).astype(np.float32)
+
+        # Warp DS source into DS ref geometry
+        src_for_match_ds = cv2.warpAffine(
+            gray_ds, T_prev_ds, (int(Wref_ds), int(Href_ds)),
             flags=resample_flag, borderMode=cv2.BORDER_REFLECT_101
         )
 
-        # 3) denoise sparse islands to stabilize AA
-        src_for_match = _suppress_tiny_islands(src_for_match, det_sigma=det_sigma, minarea=minarea)
-        ref_small     = _suppress_tiny_islands(ref_small,     det_sigma=det_sigma, minarea=minarea)
+        # 4) denoise sparse islands in DS space (cheaper)
+        src_for_match_ds = _suppress_tiny_islands(src_for_match_ds, det_sigma=det_sigma, minarea=minarea)
+        ref_for_match_ds = _suppress_tiny_islands(np.asarray(ref_small_ds, np.float32, order="C"),
+                                                  det_sigma=det_sigma, minarea=minarea)
 
-        # 4) AA incremental delta on cropped ref
+        # 5) AA delta solve in DS space
         m = (model or "affine").lower()
         if m in ("no_distortion", "nodistortion"):
             m = "similarity"
 
         if m == "similarity":
-            tform = compute_similarity_transform_astroalign_cropped(
-                src_for_match, ref_small,
+            tform_ds = compute_similarity_transform_astroalign_cropped(
+                src_for_match_ds, ref_for_match_ds,
                 limit_stars=int(limit_stars) if limit_stars is not None else None,
                 det_sigma=float(det_sigma),
                 minarea=int(minarea),
                 h_reproj=float(h_reproj)
             )
         else:
-            tform = compute_affine_transform_astroalign_cropped(
-                src_for_match, ref_small,
+            tform_ds = compute_affine_transform_astroalign_cropped(
+                src_for_match_ds, ref_for_match_ds,
                 limit_stars=int(limit_stars) if limit_stars is not None else None,
                 det_sigma=float(det_sigma),
                 minarea=int(minarea)
             )
 
-        if tform is None:
+        if tform_ds is None:
             return (orig_path, None,
                     f"Astroalign failed for {os.path.basename(orig_path)} – skipping (no transform returned)")
 
-        T_new = np.asarray(tform, np.float64).reshape(2, 3)
-        return (orig_path, T_new, None)
+        # 6) lift DS delta back to full-res coords
+        T_new_full = lift_affine_2x3_from_ds(np.asarray(tform_ds, np.float64).reshape(2, 3), ds)
+
+        return (orig_path, np.asarray(T_new_full, np.float64).reshape(2, 3), None)
 
     except Exception as e:
+        try:
+            base = os.path.basename(args[0]) if args else "<unknown>"
+        except Exception:
+            base = "<unknown>"
         return (args[0] if args else "<unknown>", None,
-                f"Astroalign failed for {os.path.basename(args[0]) if args else '<unknown>'}: {e}")
+                f"Astroalign failed for {base}: {e}")
 
 
 
@@ -2036,7 +2088,7 @@ def _suppress_tiny_islands(img32: np.ndarray, det_sigma: float, minarea: int) ->
 # ─────────────────────────────────────────────────────────────
 def _finalize_write_job(args):
     """
-    Process-safe worker: read full-res, compute/choose model, warp, save.
+    Process-safe worker: read full-res, choose model, warp, save.
     Returns (orig_path, out_path or "", msg, success, drizzle_tuple or None)
     drizzle_tuple = (kind, matrix_or_None)
     """
@@ -2057,17 +2109,19 @@ def _finalize_write_job(args):
     try:
         cv2.setNumThreads(1)
         try: cv2.ocl.setUseOpenCL(False)
-        except Exception as e:
-            import logging
-            logging.debug(f"Exception suppressed: {type(e).__name__}: {e}")
+        except Exception:
+            pass
     except Exception:
         pass
 
     debug_lines = []
     def dbg(s: str):
-        # keep it short-ish; UI emits each line
         debug_lines.append(str(s))
 
+    def _A3(A2x3):
+        A = np.asarray(A2x3, np.float64).reshape(2, 3)
+        return np.vstack([A, [0, 0, 1]])
+
     try:
         # 1) load source (full-res)
         with fits.open(orig_path, memmap=True) as hdul:
@@ -2076,12 +2130,12 @@ def _finalize_write_job(args):
         if img is None:
             return (orig_path, "", f"⚠️ Failed to read {os.path.basename(orig_path)}", False, None)
 
-        # Fix for white images: Normalize integer types to [0,1]
+        # normalize ints
         if img.dtype == np.uint16:
             img = img.astype(np.float32) / 65535.0
         elif img.dtype == np.uint8:
             img = img.astype(np.float32) / 255.0
-        
+
         is_mono = (img.ndim == 2)
         src_gray_full = img if is_mono else np.mean(img, axis=2)
         src_gray_full = np.nan_to_num(src_gray_full, nan=0.0, posinf=0.0, neginf=0.0).astype(np.float32, copy=False)
@@ -2090,40 +2144,61 @@ def _finalize_write_job(args):
 
         Href, Wref = ref_shape
 
-        # 2) load reference via memmap
+        # 2) load reference (full-res) via memmap
         ref2d = np.load(ref_npy_path, mmap_mode="r").astype(np.float32, copy=False)
         if ref2d.shape[:2] != (Href, Wref):
             return (orig_path, "", f"⚠️ Ref shape mismatch for {os.path.basename(orig_path)}", False, None)
 
         base = os.path.basename(orig_path)
 
-        # helper: force affine to similarity (no shear)
-        def _affine_to_similarity(A2x3: np.ndarray) -> np.ndarray:
-            A2x3 = np.asarray(A2x3, np.float64).reshape(2, 3)
-            R = A2x3[:, :2]
-            t = A2x3[:, 2]
-            U, S, Vt = np.linalg.svd(R)
-            rot = U @ Vt
-            if np.linalg.det(rot) < 0:
-                U[:, -1] *= -1
-                rot = U @ Vt
-            s = float((S[0] + S[1]) * 0.5)
-            Rsim = rot * s
-            out = np.zeros((2, 3), dtype=np.float64)
-            out[:, :2] = Rsim
-            out[:, 2] = t
-            return out
-
-        # 3) choose transform
         model = (align_model or "affine").lower()
         if model in ("no_distortion", "nodistortion"):
             model = "similarity"
 
+        # Base (accumulated) affine from refinement
+        A_prev = np.asarray(affine_2x3, np.float64).reshape(2, 3)
+        A_prev3 = _A3(A_prev)
+
+        # Default finalize is just the affine refinement result
         kind = "affine"
-        X = np.asarray(affine_2x3, np.float64).reshape(2, 3)
+        X = A_prev.copy()
 
+        # ---- Non-affine finalize: DS solve + lift, but KEEP affine-as-start ----
         if model != "affine":
-            # ---- AA pairs (adaptive tiling) ----
+            dbg(f"[finalize] base={base} model={model} det_sigma={det_sigma} minarea={minarea} limit_stars={limit_stars}")
+
+            ds = 2  # ✅ keep simple/safe; only DS+lift change requested
+            ds = max(1, int(ds))
+
+            # DS reference
+            if ds > 1:
+                ref_ds = cv2.resize(ref2d, (max(1, Wref // ds), max(1, Href // ds)), interpolation=cv2.INTER_AREA)
+            else:
+                ref_ds = np.ascontiguousarray(ref2d)
+
+            ref_ds = np.ascontiguousarray(ref_ds.astype(np.float32, copy=False))
+            Hds, Wds = ref_ds.shape[:2]
+
+            # DS source
+            if ds > 1:
+                src_ds0 = cv2.resize(src_gray_full, (Wds, Hds), interpolation=cv2.INTER_AREA)
+            else:
+                src_ds0 = cv2.resize(src_gray_full, (Wds, Hds), interpolation=cv2.INTER_AREA) if (src_gray_full.shape[:2] != (Hds, Wds)) else src_gray_full
+
+            src_ds0 = np.ascontiguousarray(src_ds0.astype(np.float32, copy=False))
+
+            # Pre-warp source in DS space using downscaled accumulated affine
+            A_prev_ds = downscale_affine_2x3_to_ds(A_prev, ds).astype(np.float32)
+            src_pre_ds = cv2.warpAffine(
+                src_ds0, A_prev_ds, (Wds, Hds),
+                flags=cv2.INTER_LINEAR, borderMode=cv2.BORDER_REFLECT_101
+            )
+
+            # Optional suppress tiny islands (your existing helper)
+            src_pre_ds = _suppress_tiny_islands(src_pre_ds, det_sigma=float(det_sigma), minarea=int(minarea))
+            ref_ds     = _suppress_tiny_islands(ref_ds,     det_sigma=float(det_sigma), minarea=int(minarea))
+
+            # AA correspondences in DS space: prewarped src vs ref
             max_cp = None
             try:
                 if limit_stars is not None and int(limit_stars) > 0:
@@ -2131,13 +2206,10 @@ def _finalize_write_job(args):
             except Exception:
                 max_cp = None
 
-            dbg(f"[finalize] base={base} model={model} det_sigma={det_sigma} minarea={minarea} limit_stars={limit_stars}")
-
-            AA_SCALE = 0.80  # finalize-only
+            AA_SCALE = 0.80
 
-            # ---- tiles=1 (center crop) ----
             src_xy, tgt_xy, best_P, best_xy0 = _aa_find_pairs_multitile(
-                src_gray_full, ref2d,
+                src_pre_ds, ref_ds,
                 scale=AA_SCALE,
                 tiles=1,
                 det_sigma=float(det_sigma),
@@ -2145,143 +2217,72 @@ def _finalize_write_job(args):
                 max_control_points=max_cp,
                 _dbg=dbg
             )
-
             if src_xy is None or len(src_xy) < 8:
-                dbg("[AA] tiles=1 too few matches")
-                raise RuntimeError("astroalign produced too few matches")
-
-            dbg(f"[AA] tiles=1 matches={len(src_xy)} best_tile_xy0={best_xy0}")
-
-            spread_ok1 = _points_spread_ok(tgt_xy, Wref, Href, _dbg=dbg)
-            dbg(f"[AA] spread_ok(tiles=1)={spread_ok1}")
-
-            # ---- fallback: tiles=5 (corners + center) ----
-            if not spread_ok1:
-                src_xy5, tgt_xy5, best_P5, best_xy0_5 = _aa_find_pairs_multitile(
-                    src_gray_full, ref2d,
-                    scale=AA_SCALE,
-                    tiles=5,  # <-- NEW primary fallback
-                    det_sigma=float(det_sigma),
-                    minarea=int(minarea),
-                    max_control_points=max_cp,
-                    _dbg=dbg
-                )
-
-                if src_xy5 is None or len(src_xy5) < 8:
-                    dbg("[AA] tiles=5 too few matches; keeping tiles=1")
-                else:
-                    dbg(f"[AA] tiles=5 matches={len(src_xy5)} best_tile_xy0={best_xy0_5}")
-                    spread_ok5 = _points_spread_ok(tgt_xy5, Wref, Href, _dbg=dbg)
-                    dbg(f"[AA] spread_ok(tiles=5)={spread_ok5}")
-
-                    # choose tiles=5 if it spreads better OR gives more matches
-                    if spread_ok5 or len(src_xy5) > len(src_xy):
-                        dbg("[AA] switching to tiles=5 result")
-                        src_xy, tgt_xy = src_xy5, tgt_xy5
-                        best_P, best_xy0 = best_P5, best_xy0_5
-                    else:
-                        dbg("[AA] keeping tiles=1 result (tiles=5 not better)")
-
-            # ---- tertiary fallback: tiles=3 grid ----
-            spread_ok_after = _points_spread_ok(tgt_xy, Wref, Href, _dbg=dbg)
-            dbg(f"[AA] spread_ok(after tiles=5 check)={spread_ok_after}")
-
-            if not spread_ok_after:
-                src_xy3, tgt_xy3, best_P3, best_xy0_3 = _aa_find_pairs_multitile(
-                    src_gray_full, ref2d,
-                    scale=AA_SCALE,
-                    tiles=3,
-                    det_sigma=float(det_sigma),
-                    minarea=int(minarea),
-                    max_control_points=max_cp,
-                    _dbg=dbg
-                )
-
-                if src_xy3 is None or len(src_xy3) < 8:
-                    dbg("[AA] tiles=3 too few matches; keeping current result")
-                else:
-                    dbg(f"[AA] tiles=3 matches={len(src_xy3)} best_tile_xy0={best_xy0_3}")
-                    spread_ok3 = _points_spread_ok(tgt_xy3, Wref, Href, _dbg=dbg)
-                    dbg(f"[AA] spread_ok(tiles=3)={spread_ok3}")
-
-                    if spread_ok3 or len(src_xy3) > len(src_xy):
-                        dbg("[AA] switching to tiles=3 result")
-                        src_xy, tgt_xy = src_xy3, tgt_xy3
-                        best_P, best_xy0 = best_P3, best_xy0_3
-                    else:
-                        dbg("[AA] keeping current result (tiles=3 not better)")
-
-            x0, y0 = best_xy0
-            P = np.asarray(best_P, np.float64)
-
-            # ---- base full-ref from best_P + best_xy0 ----
-            if P.shape == (3, 3):
-                base_kind0 = "homography"
-                T  = np.array([[1,0,x0],[0,1,y0],[0,0,1]], dtype=np.float64)
-                base_X0 = T @ P
-            else:
-                base_kind0 = "affine"
-                A3 = np.vstack([P[0:2, :], [0,0,1]])
-                T  = np.array([[1,0,x0],[0,1,y0],[0,0,1]], dtype=np.float64)
-                base_X0 = (T @ A3)[0:2, :]
+                raise RuntimeError("astroalign produced too few matches (finalize)")
 
+            # RANSAC threshold in DS pixels
             hth = float(h_reproj)
 
             if model == "homography":
-                H, inl = cv2.findHomography(src_xy, tgt_xy, cv2.RANSAC, ransacReprojThreshold=hth)
+                # Delta homography maps prewarped -> ref  (both in DS coords)
+                H_delta_ds, inl = cv2.findHomography(src_xy, tgt_xy, cv2.RANSAC, ransacReprojThreshold=hth)
                 ninl = int(inl.sum()) if inl is not None else 0
-                dbg(f"[RANSAC] homography inliers={ninl}/{len(src_xy)} thr={hth}")
+                dbg(f"[RANSAC] homography delta(DS) inliers={ninl}/{len(src_xy)} thr={hth}")
 
-                if H is not None:
-                    kind, X = "homography", np.asarray(H, np.float64)
+                if H_delta_ds is None:
+                    # fallback to just affine refinement
+                    kind, X = "affine", A_prev.copy()
                 else:
-                    kind, X = base_kind0, base_X0
+                    H_delta_full = lift_homography_from_ds(H_delta_ds, ds)
+                    H_final = np.asarray(H_delta_full, np.float64) @ A_prev3
+                    kind, X = "homography", H_final
 
             elif model == "similarity":
-                A, inl = cv2.estimateAffinePartial2D(src_xy, tgt_xy, cv2.RANSAC, ransacReprojThreshold=hth)
+                # Delta similarity (affine partial) maps prewarped -> ref in DS coords
+                A_delta_ds, inl = cv2.estimateAffinePartial2D(
+                    src_xy, tgt_xy, cv2.RANSAC, ransacReprojThreshold=hth
+                )
                 ninl = int(inl.sum()) if inl is not None else 0
-                dbg(f"[RANSAC] similarity inliers={ninl}/{len(src_xy)} thr={hth}")
+                dbg(f"[RANSAC] similarity delta(DS) inliers={ninl}/{len(src_xy)} thr={hth}")
 
-                if A is not None:
-                    kind, X = "similarity", np.asarray(A, np.float64)
+                if A_delta_ds is None:
+                    kind, X = "similarity", _project_to_similarity(A_prev)
                 else:
-                    if base_kind0 == "affine":
-                        kind, X = "similarity", _affine_to_similarity(base_X0)
-                    else:
-                        kind, X = base_kind0, base_X0
-
-            elif model == "affine":
-                kind, X = "affine", np.asarray(affine_2x3, np.float64)
+                    A_delta_full = lift_affine_2x3_from_ds(A_delta_ds, ds)
+                    # Compose delta ∘ prev in affine space
+                    A_final3 = _A3(A_delta_full) @ A_prev3
+                    A_final = A_final3[:2, :]
+                    kind, X = "similarity", _project_to_similarity(A_final)
 
             elif model in ("poly3", "poly4"):
+                # Keep behavior simple: poly fit in FULL coords using pairs from prewarped DS,
+                # then apply as remap on the ORIGINAL image (same as your current poly path).
+                # (If you later want true "poly residual after affine", we can do that safely,
+                # but that is a pattern change beyond DS+lift.)
                 order = 3 if model == "poly3" else 4
-                cx, cy = _fit_poly_xy(src_xy, tgt_xy, order=order)
+                src_full = (np.asarray(src_xy, np.float32) * float(ds)).astype(np.float32)
+                tgt_full = (np.asarray(tgt_xy, np.float32) * float(ds)).astype(np.float32)
+
+                cx, cy = _fit_poly_xy(src_full, tgt_full, order=order)
                 map_x, map_y = _poly_eval_grid(cx, cy, Wref, Href, order=order)
                 kind, X = model, (map_x, map_y)
 
             else:
-                dbg(f"[AA] unknown model '{model}', falling back to base {base_kind0}")
-                kind, X = base_kind0, base_X0
+                # Unknown model -> just write affine refinement
+                kind, X = "affine", A_prev.copy()
 
-        # 4) warp
+        # 4) warp full-res
         Hh, Ww = Href, Wref
 
         if kind in ("affine", "similarity"):
             A = np.asarray(X, np.float64).reshape(2, 3)
-
             if is_mono:
-                aligned = cv2.warpAffine(
-                    img, A, (Ww, Hh),
-                    flags=cv2.INTER_LANCZOS4,
-                    borderMode=cv2.BORDER_CONSTANT, borderValue=0
-                )
+                aligned = cv2.warpAffine(img, A, (Ww, Hh), flags=cv2.INTER_LANCZOS4,
+                                         borderMode=cv2.BORDER_CONSTANT, borderValue=0)
             else:
                 aligned = np.stack([
-                    cv2.warpAffine(
-                        img[..., c], A, (Ww, Hh),
-                        flags=cv2.INTER_LANCZOS4,
-                        borderMode=cv2.BORDER_CONSTANT, borderValue=0
-                    )
+                    cv2.warpAffine(img[..., c], A, (Ww, Hh), flags=cv2.INTER_LANCZOS4,
+                                   borderMode=cv2.BORDER_CONSTANT, borderValue=0)
                     for c in range(img.shape[2])
                 ], axis=2)
 
@@ -2290,34 +2291,27 @@ def _finalize_write_job(args):
 
         elif kind == "homography":
             Hm = np.asarray(X, np.float64).reshape(3, 3)
-
             if is_mono:
-                aligned = cv2.warpPerspective(
-                    img, Hm, (Ww, Hh),
-                    flags=cv2.INTER_LANCZOS4,
-                    borderMode=cv2.BORDER_CONSTANT, borderValue=0
-                )
+                aligned = cv2.warpPerspective(img, Hm, (Ww, Hh), flags=cv2.INTER_LANCZOS4,
+                                              borderMode=cv2.BORDER_CONSTANT, borderValue=0)
             else:
                 aligned = np.stack([
-                    cv2.warpPerspective(
-                        img[..., c], Hm, (Ww, Hh),
-                        flags=cv2.INTER_LANCZOS4,
-                        borderMode=cv2.BORDER_CONSTANT, borderValue=0
-                    )
+                    cv2.warpPerspective(img[..., c], Hm, (Ww, Hh), flags=cv2.INTER_LANCZOS4,
+                                        borderMode=cv2.BORDER_CONSTANT, borderValue=0)
                     for c in range(img.shape[2])
                 ], axis=2)
 
             drizzle_tuple = ("homography", Hm.astype(np.float64))
             warp_label = "homography"
 
-        elif kind in ("poly3","poly4"):
+        elif kind in ("poly3", "poly4"):
             map_x, map_y = X
             if is_mono:
                 aligned = cv2.remap(img, map_x, map_y, cv2.INTER_LANCZOS4,
                                     borderMode=cv2.BORDER_CONSTANT, borderValue=0)
             else:
                 aligned = np.stack([
-                    cv2.remap(img[...,c], map_x, map_y, cv2.INTER_LANCZOS4,
+                    cv2.remap(img[..., c], map_x, map_y, cv2.INTER_LANCZOS4,
                               borderMode=cv2.BORDER_CONSTANT, borderValue=0)
                     for c in range(img.shape[2])
                 ], axis=2)
@@ -2378,14 +2372,10 @@ class StarRegistrationWorker(QRunnable):
 
     def run(self):
         """
-        Affine:
-        - Apply current transform to a preview-sized image
-        - Solve incremental delta vs reference preview
-        - Emit the incremental delta (2x3) keyed by ORIGINAL path
-
-        Non-affine (homography/poly3/4):
-        - This QRunnable does not try to do residuals; it just reports and emits identity.
-            The multi-process residual pass is handled by StarRegistrationThread.
+        Refinement worker ALWAYS computes incremental deltas in affine/similarity space,
+        even if the FINAL requested model is homography/poly3/poly4.
+
+        The final non-affine model (if any) is applied in _finalize_write_job only.
         """
         try:
             _cap_native_threads_once()
@@ -2411,21 +2401,19 @@ class StarRegistrationWorker(QRunnable):
                 return
             Href, Wref = ref_small.shape[:2]
 
-            model = (self.model_name or "affine").lower()
-
-            # --- Non-affine: don't accumulate here; identity + progress line only
-            if model in ("homography", "poly3", "poly4"):
-                self.signals.progress.emit(
-                    f"Residual-only mode for {os.path.basename(self.original_file)} (model={model}); "
-                    "emitting identity transform (handled by thread pass)."
-                )
-                self.signals.result_transform.emit(os.path.normpath(self.original_file), IDENTITY_2x3.copy())
-                self.signals.result.emit(self.original_file)
-                return
+            # ✅ Refinement solve model: always affine or similarity
+            model_req = (self.model_name or "affine").lower()
+            if model_req in ("no_distortion", "nodistortion", "similarity"):
+                refine_model = "similarity"
+            else:
+                refine_model = "affine"  # includes when final requested is homography/poly*
 
-            # --- Affine incremental
             T_prev = np.array(self.current_transform, dtype=np.float32).reshape(2, 3)
-            use_warp = not np.allclose(T_prev, np.array([[1,0,0],[0,1,0]], dtype=np.float32), rtol=1e-5, atol=1e-5)
+            use_warp = not np.allclose(
+                T_prev,
+                np.array([[1, 0, 0], [0, 1, 0]], dtype=np.float32),
+                rtol=1e-5, atol=1e-5
+            )
 
             if use_warp and cv2 is not None:
                 src_for_match = cv2.warpAffine(
@@ -2439,9 +2427,21 @@ class StarRegistrationWorker(QRunnable):
                     src_for_match = gray_small
 
             try:
-                transform = self.compute_affine_transform_astroalign(
-                    src_for_match, ref_small, limit_stars=getattr(self, "limit_stars", None)
-                )
+                if refine_model == "similarity":
+                    transform = compute_similarity_transform_astroalign_cropped(
+                        src_for_match, ref_small,
+                        limit_stars=getattr(self, "limit_stars", None),
+                        det_sigma=getattr(self, "det_sigma", 12.0),
+                        minarea=getattr(self, "minarea", 10),
+                        h_reproj=getattr(self, "h_reproj", 3.0),
+                    )
+                else:
+                    transform = self.compute_affine_transform_astroalign(
+                        src_for_match, ref_small,
+                        limit_stars=getattr(self, "limit_stars", None),
+                        det_sigma=getattr(self, "det_sigma", 12.0),
+                        minarea=getattr(self, "minarea", 10),
+                    )
             except Exception as e:
                 msg = str(e)
                 base = os.path.basename(self.original_file)
@@ -2457,19 +2457,22 @@ class StarRegistrationWorker(QRunnable):
                 return
 
             transform = np.array(transform, dtype=np.float64).reshape(2, 3)
+
+            # Similarity projection safety (no shear)
+            if refine_model == "similarity":
+                transform = _project_to_similarity(transform)
+
             key = os.path.normpath(self.original_file)
             self.signals.result_transform.emit(key, transform)
             self.signals.progress.emit(
                 f"Astroalign delta for {os.path.basename(self.original_file)} "
-                f"(model={self.model_name}): dx={transform[0, 2]:.2f}, dy={transform[1, 2]:.2f}"
+                f"(refine={refine_model}, final={self.model_name}): dx={transform[0,2]:.2f}, dy={transform[1,2]:.2f}"
             )
             self.signals.result.emit(self.original_file)
 
         except Exception as e:
             self.signals.error.emit(f"Error processing {self.original_file}: {e}")
 
-
-
     @staticmethod
     def compute_affine_transform_astroalign(source_img, reference_img,
                                             scale=1.20,
@@ -2619,7 +2622,7 @@ class StarRegistrationThread(QThread):
         self.det_sigma   = float(self.align_prefs.get("det_sigma", 12.0))
         self.limit_stars = int(self.align_prefs.get("limit_stars", 500))
         self.minarea     = int(self.align_prefs.get("minarea", 10))
-        self.downsample = int(self.align_prefs.get("downsample", 2))
+        self.downsample = int(self.align_prefs.get("downsample", 3))
         self.drizzle_xforms = {}  # {orig_norm_path: (kind, matrix)}
 
     @staticmethod
@@ -2969,23 +2972,37 @@ class StarRegistrationThread(QThread):
 
             # ✂️ No DAO/RANSAC: astroalign handles detection internally.
 
-            # Single shared downsampled ref for workers
-            #ds = max(1, int(self.align_prefs.get("downsample", 2)))
-            #if ds > 1:
-            #    new_hw = (max(1, ref2d.shape[1] // ds), max(1, ref2d.shape[0] // ds))  # (W, H)
-            #    ref_small = cv2.resize(ref2d, new_hw, interpolation=cv2.INTER_AREA)
-            #else:
-            #    ref_small = ref2d
-            #self.ref_small = np.ascontiguousarray(ref_small.astype(np.float32))
-            self.ref_small = np.ascontiguousarray(ref2d.astype(np.float32))
+            # --- Build shared ref at full + downsampled solve-res ---
+            self.ref_small_full = np.ascontiguousarray(ref2d.astype(np.float32, copy=False))
+
+            # Use existing preference key you already have: self.downsample
+            # (you load it in __init__: self.downsample = int(self.align_prefs.get("downsample", 2)))
+            ds = max(1, int(self.downsample))
+            self.solve_downsample = ds
+
+            if ds > 1 and cv2 is not None:
+                new_hw = (max(1, ref2d.shape[1] // ds), max(1, ref2d.shape[0] // ds))  # (W, H)
+                ref_ds = cv2.resize(self.ref_small_full, new_hw, interpolation=cv2.INTER_AREA)
+            else:
+                ref_ds = self.ref_small_full
+
+            self.ref_small = self.ref_small_full               # keep existing attribute name (full)
+            self.ref_small_ds = np.ascontiguousarray(ref_ds.astype(np.float32, copy=False))
 
             # Initialize transforms to identity for EVERY original frame
             self.alignment_matrices = {os.path.normpath(f): IDENTITY_2x3.copy() for f in self.original_files}
             self.delta_transforms = {}
 
             # Progress totals (units = number of worker completions across passes)
+            # Progress totals:
+            #   passes = N * passes
+            #   finalize = N
+            N = len(self.original_files)
+            P = max(1, int(self.max_refinement_passes))
+
             self._done = 0
-            self._total = len(self.original_files) * max(1, int(self.max_refinement_passes))
+            self._total = (N * P) + N   # <-- IMPORTANT: include finalize
+            self.progress_step.emit(self._done, self._total)  # optional but helps UI reset immediately
 
             # Registration passes (compute deltas only)
             for pass_idx in range(self.max_refinement_passes):
@@ -3027,109 +3044,30 @@ class StarRegistrationThread(QThread):
     def run_one_registration_pass(self, _ref_stars_unused, _ref_triangles_unused, pass_index):
         _cap_native_threads_once()
         import os
-        import shutil
-        import tempfile
         import cv2
+        import time
 
-        model = (self.align_model or "affine").lower()
-        ref_small = np.ascontiguousarray(self.ref_small.astype(np.float32, copy=False))
-        Href, Wref = ref_small.shape[:2]
+        # Requested final model (used ONLY in finalize)
+        final_model = (self.align_model or "affine").lower()
 
-        # --- Build reverse map: current_path -> original_key (handles bin2-upscale / rewrites)
+        # ✅ Refinement model: affine or similarity only
+        if final_model in ("no_distortion", "nodistortion", "similarity"):
+            refine_model = "similarity"
+        else:
+            refine_model = "affine"
+
+        ref_small_ds = np.ascontiguousarray(self.ref_small_ds.astype(np.float32, copy=False))
+        Href_ds, Wref_ds = ref_small_ds.shape[:2]
+        ds = max(1, int(getattr(self, "solve_downsample", 1)))
+
+        # --- reverse map: current_path -> original_key
         rev_current_to_orig = {}
         for orig_k, curr_p in self.file_key_to_current_path.items():
             rev_current_to_orig[os.path.normpath(curr_p)] = os.path.normpath(orig_k)
 
-        # ---------- NON-AFFINE PATH: residuals-only ----------
-        if model in ("homography", "poly3", "poly4"):
-            work_list = list(self.original_files)
-
-            from concurrent.futures import ProcessPoolExecutor, as_completed
-            procs = max(2, min((os.cpu_count() or 8), 32))
-            self.progress_update.emit(f"Using {procs} processes to measure residuals (model={model}).")
-
-            tmpdir = tempfile.mkdtemp(prefix="sas_resid_")
-            ref_npy = os.path.join(tmpdir, "ref_small.npy")
-            try:
-                np.save(ref_npy, ref_small)
-            except Exception as e:
-                try: shutil.rmtree(tmpdir, ignore_errors=True)
-                except Exception as e:
-                    import logging
-                    logging.debug(f"Exception suppressed: {type(e).__name__}: {e}")
-                self.on_worker_error(f"Failed to persist residual reference: {e}")
-                return False, "Residual pass aborted."
-
-            pass_deltas = []
-            try:
-
-                import time
-
-                jobs = [
-                    (p, ref_npy, model, self.h_reproj, self.det_sigma, self.minarea, self.limit_stars)
-                    for p in work_list
-                ]
-                total = len(jobs)
-                done = 0
-
-                self.progress_update.emit(f"Using {procs} processes to measure residuals (model={model}).")
-                self.progress_step.emit(0, total)
-
-                with _make_executor(procs) as ex:
-                    pending = {ex.submit(_residual_job_worker, j): j[0] for j in jobs}
-                    last_heartbeat = time.monotonic()
-
-                    while pending:
-                        done_set, pending = wait(pending, timeout=0.6, return_when=FIRST_COMPLETED)
-                        # heartbeat if nothing finished for a bit
-                        now = time.monotonic()
-                        if not done_set and (now - last_heartbeat) > 2.0:
-                            self.progress_update.emit(f"… measuring residuals ({done}/{total} done)")
-                            last_heartbeat = now
-
-                        for fut in done_set:
-                            orig_pth = os.path.normpath(pending.pop(fut, "<unknown>")) if fut in pending else "<unknown>"
-                            try:
-                                pth, rms, err = fut.result()
-                            except Exception as e:
-                                pth, rms, err = (orig_pth, float("inf"), f"Worker crashed: {e}")
-
-                            k_orig = os.path.normpath(pth or orig_pth)
-                            if err:
-                                self.on_worker_error(f"Residual measure failed for {os.path.basename(k_orig)}: {err}")
-                                self.delta_transforms[k_orig] = float("inf")
-                            else:
-                                self.delta_transforms[k_orig] = float(rms)
-                                self.progress_update.emit(
-                                    f"[residuals] {os.path.basename(k_orig)} → RMS={rms:.2f}px"
-                                )
-
-                            done += 1
-                            self.progress_step.emit(done, total)
-                            last_heartbeat = now
-
-                for orig in self.original_files:
-                    pass_deltas.append(self.delta_transforms.get(os.path.normpath(orig), float("inf")))
-                self.transform_deltas.append(pass_deltas)
-
-                preview = ", ".join([f"{d:.2f}" if np.isfinite(d) else "∞" for d in pass_deltas[:10]])
-                if len(pass_deltas) > 10:
-                    preview += f" … ({len(pass_deltas)} total)"
-                self.progress_update.emit(f"Pass {pass_index + 1}: residual RMS px [{preview}]")
-
-                aligned_count = sum(1 for d in pass_deltas if np.isfinite(d) and d <= self.shift_tolerance)
-                if aligned_count:
-                    self.progress_update.emit(f"Within tolerance (≤ {self.shift_tolerance:.2f}px): {aligned_count} frame(s)")
-                return True, "Residual pass complete."
-            finally:
-                try: shutil.rmtree(tmpdir, ignore_errors=True)
-                except Exception as e:
-                    import logging
-                    logging.debug(f"Exception suppressed: {type(e).__name__}: {e}")
-
-        # ---------- AFFINE PATH (incremental delta accumulation) ----------
         resample_flag = cv2.INTER_AREA if pass_index == 0 else cv2.INTER_LINEAR
 
+        # Work list: pass 0 all; later passes skip within tolerance
         if pass_index == 0:
             work_list = list(self.original_files)
         else:
@@ -3156,30 +3094,36 @@ class StarRegistrationThread(QThread):
             return True, "Pass complete (nothing to refine)."
 
         procs = max(2, min((os.cpu_count() or 8), 32))
-        self.progress_update.emit(f"Using {procs} processes for stellar alignment (HW={os.cpu_count() or 8}).")
+        self.progress_update.emit(f"Using {procs} processes for stellar alignment (refine={refine_model}).")
 
         timeout_sec = int(self.align_prefs.get("timeout_per_job_sec", 300))
+
         jobs = []
         for orig_key in work_list:
             ok = os.path.normpath(orig_key)
-            current_path = os.path.normpath(self.file_key_to_current_path.get(ok, ok))
+
+            # IMPORTANT: refinement reads ORIGINAL frame (no intermediate saves)
+            current_path = ok
+
             current_transform = self.alignment_matrices.get(ok, IDENTITY_2x3)
+
             jobs.append((
                 current_path,
                 current_transform,
-                ref_small, Wref, Href,
-                resample_flag, float(self.det_sigma), int(self.limit_stars), int(self.minarea),
-                model, float(self.h_reproj)
+                ref_small_ds, int(Wref_ds), int(Href_ds),
+                resample_flag, float(self.det_sigma),
+                int(self.limit_stars) if self.limit_stars is not None else None,
+                int(self.minarea),
+                refine_model, float(self.h_reproj),
+                int(ds)
             ))
 
-        import time
         executor = _make_executor(procs)
-
         try:
             fut_info, pending = {}, set()
             for j in jobs:
                 f = executor.submit(_solve_delta_job, j)
-                fut_info[f] = (time.monotonic(), j[0])  # j[0] = current_path
+                fut_info[f] = (time.monotonic(), j[0])
                 pending.add(f)
 
             while pending:
@@ -3191,7 +3135,7 @@ class StarRegistrationThread(QThread):
                     except Exception as e:
                         curr_path_r, T_new, err = (returned_path or "<unknown>", None, f"Worker crashed: {e}")
 
-                    # Map CURRENT path back to ORIGINAL key for consistent accumulation
+                    # Map back to ORIGINAL key
                     curr_norm = os.path.normpath(curr_path_r)
                     k_orig = rev_current_to_orig.get(curr_norm, curr_norm)
 
@@ -3201,10 +3145,13 @@ class StarRegistrationThread(QThread):
                         continue
 
                     T_new = np.array(T_new, dtype=np.float64).reshape(2, 3)
-                    if model in ("no_distortion", "nodistortion", "similarity"):
-                        T_new = _project_to_similarity(T_new)                    
+
+                    if refine_model == "similarity":
+                        T_new = _project_to_similarity(T_new)
+
                     self.delta_transforms[k_orig] = float(np.hypot(T_new[0, 2], T_new[1, 2]))
 
+                    # Accumulate: T_total = T_new ∘ T_prev
                     T_prev = np.array(self.alignment_matrices.get(k_orig, IDENTITY_2x3), dtype=np.float64).reshape(2, 3)
                     prev_3 = np.vstack([T_prev, [0, 0, 1]])
                     new_3  = np.vstack([T_new,  [0, 0, 1]])
@@ -3212,7 +3159,7 @@ class StarRegistrationThread(QThread):
 
                     self.on_worker_progress(
                         f"Astroalign delta for {os.path.basename(curr_path_r)} "
-                        f"(model={self.align_model}): dx={T_new[0, 2]:.2f}, dy={T_new[1, 2]:.2f}"
+                        f"(refine={refine_model}, final={final_model}): dx={T_new[0,2]:.2f}, dy={T_new[1,2]:.2f}"
                     )
                     self._increment_progress()
 
@@ -3247,7 +3194,7 @@ class StarRegistrationThread(QThread):
                 preview += f" … ({len(pass_deltas)} total)"
             self.progress_update.emit(f"Pass {pass_index + 1} delta shifts: [{preview}]")
             if aligned_count:
-                self.progress_update.emit(f"Skipped (delta < {self.shift_tolerance:.2f}px): {aligned_count} frame(s)")
+                self.progress_update.emit(f"Within tolerance (≤ {self.shift_tolerance:.2f}px): {aligned_count} frame(s)")
             return True, "Pass complete."
         finally:
             try:
@@ -3255,7 +3202,6 @@ class StarRegistrationThread(QThread):
             except Exception:
                 pass
 
-
     def on_worker_result_transform(self, persistent_key, new_transform):
         k = os.path.normpath(persistent_key)
         T_new = np.array(new_transform, dtype=np.float64).reshape(2, 3)
@@ -3396,8 +3342,8 @@ class StarRegistrationThread(QThread):
             A = np.asarray(self.alignment_matrices.get(k, IDENTITY_2x3), dtype=np.float64)
 
             # 👉 If non-affine, we pass identity to make workers solve from scratch
-            if self.align_model.lower() in ("homography", "poly3", "poly4"):
-                A = IDENTITY_2x3.copy()
+            #if self.align_model.lower() in ("homography", "poly3", "poly4"):
+            #    A = IDENTITY_2x3.copy()
 
             jobs.append((
                 orig_path,
@@ -3423,6 +3369,7 @@ class StarRegistrationThread(QThread):
                         orig_path, out_path, msg, success, drizzle = fut.result()
                     except Exception as e:
                         self.progress_update.emit(f"⚠️ Finalize worker crashed: {e}")
+                        self._increment_progress()
                         continue
 
                     if msg:
@@ -3445,6 +3392,7 @@ class StarRegistrationThread(QThread):
                                     self.drizzle_xforms[k] = (str(kind), None)  # poly3/4
                             except Exception:
                                 pass
+                    self._increment_progress()           
         finally:
             try: shutil.rmtree(tmpdir, ignore_errors=True)
             except Exception as e:
@@ -4638,11 +4586,12 @@ def load_api_key():
 class MosaicMasterDialog(QDialog):
     def __init__(self, settings: QSettings, parent=None, image_manager=None,
                  doc_manager=None, wrench_path=None, spinner_path=None,
-                 list_open_docs_fn=None):                                 # ← add param
+                 list_open_docs_fn=None):
         super().__init__(parent)
         self.settings = settings
         self.image_manager = image_manager
         self._docman = doc_manager or getattr(parent, "doc_manager", None)
+
         # same pattern as StellarAlignmentDialog
         if list_open_docs_fn is None:
             cand = getattr(parent, "_list_open_docs", None)
@@ -4654,19 +4603,22 @@ class MosaicMasterDialog(QDialog):
         self.setWindowFlag(Qt.WindowType.Window, True)
         self.setWindowModality(Qt.WindowModality.NonModal)
         self.setModal(False)
+
         self.wrench_path = wrench_path
         self.spinner_path = spinner_path
 
         self.resize(600, 400)
-        self.loaded_images = []  
+        self.loaded_images = []
         self.final_mosaic = None
         self.weight_mosaic = None
         self.wcs_metadata = None  # To store mosaic WCS header
         self.astap_exe = self.settings.value("paths/astap", "", type=str)
+
         # Variables to store stretching parameters:
         self.stretch_original_mins = []
         self.stretch_original_medians = []
         self.was_single_channel = False
+
         self.initUI()
 
     def initUI(self):
@@ -4687,12 +4639,11 @@ class MosaicMasterDialog(QDialog):
         layout.addWidget(instructions)
 
         btn_layout = QHBoxLayout()
-        # Button to add image from disk
+
         add_btn = QPushButton("Add Image")
         add_btn.clicked.connect(self.add_image)
         btn_layout.addWidget(add_btn)
 
-        # New button to add an image from one of the ImageManager slots
         add_from_view_btn = QPushButton("Add from View")
         add_from_view_btn.setToolTip("Add an image from any open View")
         add_from_view_btn.clicked.connect(self.add_image_from_view)
@@ -4714,25 +4665,80 @@ class MosaicMasterDialog(QDialog):
         save_btn.clicked.connect(self.save_mosaic_to_new_view)
         btn_layout.addWidget(save_btn)
 
-        # Add the wrench button for settings.
         wrench_btn = QPushButton()
-        wrench_btn.setIcon(QIcon(self.wrench_path))
+        if self.wrench_path:
+            wrench_btn.setIcon(QIcon(self.wrench_path))
         wrench_btn.setToolTip("Mosaic Settings")
         wrench_btn.clicked.connect(self.openSettings)
         btn_layout.addWidget(wrench_btn)
 
         layout.addLayout(btn_layout)
 
-        # Horizontal sizer for checkboxes.
+        # ------------------------------------------------------------------
+        # Mode checkboxes (mutually exclusive: Seestar vs WCS-only)
+        # ------------------------------------------------------------------
         checkbox_layout = QHBoxLayout()
+
         self.forceBlindCheckBox = QCheckBox("Force Blind Solve (ignore existing WCS)")
         checkbox_layout.addWidget(self.forceBlindCheckBox)
-        # New Seestar Mode checkbox:
+
         self.seestarCheckBox = QCheckBox("Seestar Mode")
-        self.seestarCheckBox.setToolTip("Wwen enabled, images are aligned iteratively using astroalign without plate solving.")
+        self.seestarCheckBox.setToolTip(
+            "When enabled, images are aligned iteratively using astroalign without plate solving."
+        )
         checkbox_layout.addWidget(self.seestarCheckBox)
+
+        self.wcsOnlyCheckBox = QCheckBox("Disable Star Alignment (WCS placement only)")
+        self.wcsOnlyCheckBox.setToolTip(
+            "Skips astroalign + refined alignment.\n"
+            "Panels are only reprojected into the mosaic celestial-sphere frame using WCS, then blended.\n"
+            "Useful when panels have little/no overlap but have valid WCS."
+        )
+        checkbox_layout.addWidget(self.wcsOnlyCheckBox)
+
         layout.addLayout(checkbox_layout)
 
+        # Persisted WCS-only
+        _settings = QSettings("SetiAstro", "SASpro")
+        self.wcsOnlyCheckBox.setChecked(_settings.value("mosaic/wcs_only", False, type=bool))
+
+        # Helpers ----------------------------------------------------------
+        def _set_checked(cb: QCheckBox, checked: bool):
+            cb.blockSignals(True)
+            cb.setChecked(checked)
+            cb.blockSignals(False)
+
+        def _sync_wcs_only_ui():
+            # WCS-only disables transform selection (because refinement is unused)
+            wcs_only = self.wcsOnlyCheckBox.isChecked()
+            if hasattr(self, "transform_combo"):
+                self.transform_combo.setEnabled(not wcs_only)
+                self.transform_combo.setToolTip(
+                    "" if not wcs_only else "Disabled because WCS-only placement is enabled."
+                )
+
+        def _on_seestar_changed(state: int):
+            # If Seestar is turned ON, force WCS-only OFF
+            if self.seestarCheckBox.isChecked():
+                _set_checked(self.wcsOnlyCheckBox, False)
+            _sync_wcs_only_ui()
+
+        def _on_wcs_only_changed(state: int):
+            # Persist setting first (this one is user-visible preference)
+            QSettings("SetiAstro", "SASpro").setValue("mosaic/wcs_only", self.wcsOnlyCheckBox.isChecked())
+
+            # If WCS-only is turned ON, force Seestar OFF
+            if self.wcsOnlyCheckBox.isChecked():
+                _set_checked(self.seestarCheckBox, False)
+            _sync_wcs_only_ui()
+
+        # Wire handlers (NO lambdas, no duplicates)
+        self.seestarCheckBox.stateChanged.connect(_on_seestar_changed)
+        self.wcsOnlyCheckBox.stateChanged.connect(_on_wcs_only_changed)
+
+        # ------------------------------------------------------------------
+        # Other controls
+        # ------------------------------------------------------------------
         self.normalizeCheckBox = QCheckBox("Normalize images (median match)")
         self.normalizeCheckBox.setChecked(True)
         layout.addWidget(self.normalizeCheckBox)
@@ -4756,24 +4762,21 @@ class MosaicMasterDialog(QDialog):
             "Precise — Full WCS: astropy.reproject per channel; slowest, most exact."
         )
 
-        # Persist user choice
-        _settings = QSettings("SetiAstro", "SASpro")
-        _default_mode = _settings.value("mosaic/reproject_mode",
-                                        "Fast — SIP-aware (Exact Remap)")
-        if _default_mode not in [self.reprojectModeCombo.itemText(i) for i in range(self.reprojectModeCombo.count())]:
+        _default_mode = _settings.value("mosaic/reproject_mode", "Fast — SIP-aware (Exact Remap)")
+        valid_modes = [self.reprojectModeCombo.itemText(i) for i in range(self.reprojectModeCombo.count())]
+        if _default_mode not in valid_modes:
             _default_mode = "Fast — SIP-aware (Exact Remap)"
         self.reprojectModeCombo.setCurrentText(_default_mode)
         self.reprojectModeCombo.currentTextChanged.connect(
             lambda t: QSettings("SetiAstro", "SASpro").setValue("mosaic/reproject_mode", t)
         )
 
-        # Add to layout where the old checkbox lived
         row = QHBoxLayout()
         row.addWidget(self.reprojectModeLabel)
         row.addWidget(self.reprojectModeCombo, 1)
         layout.addLayout(row)
 
-
+        # Transform selection
         self.transform_combo = QComboBox()
         self.transform_combo.addItems([
             "Partial Affine Transform",
@@ -4781,11 +4784,14 @@ class MosaicMasterDialog(QDialog):
             "Homography Transform",
             "Polynomial Warp Based Transform"
         ])
-        # Set the default selection to "Affine Transform" (index 1)
         self.transform_combo.setCurrentIndex(1)
         layout.addWidget(QLabel("Select Transformation Method:"))
         layout.addWidget(self.transform_combo)
 
+        # Now that transform_combo exists, apply WCS-only UI state
+        _sync_wcs_only_ui()
+
+        # List + status + spinner
         self.images_list = QListWidget()
         self.images_list.setSelectionMode(self.images_list.SelectionMode.SingleSelection)
         layout.addWidget(self.images_list)
@@ -4795,13 +4801,15 @@ class MosaicMasterDialog(QDialog):
 
         self.spinnerLabel = QLabel(self)
         self.spinnerLabel.setAlignment(Qt.AlignmentFlag.AlignCenter)
-        self.spinnerMovie = QMovie(self.spinner_path)
-        self.spinnerLabel.setMovie(self.spinnerMovie)
-        self.spinnerLabel.hide() 
+        self.spinnerMovie = QMovie(self.spinner_path) if self.spinner_path else None
+        if self.spinnerMovie:
+            self.spinnerLabel.setMovie(self.spinnerMovie)
+        self.spinnerLabel.hide()
         layout.addWidget(self.spinnerLabel)
 
         self.setLayout(layout)
 
+
     def _target_median_from_first(self, items):
         # Pick a stable target (median of first image after safe clipping)
         if not items:
@@ -5348,6 +5356,7 @@ class MosaicMasterDialog(QDialog):
 
     # ---------- Align (Entry Point) ----------
     def align_images(self):
+        # Seestar mode is its own pipeline
         if self.seestarCheckBox.isChecked():
             self.align_images_seestar_mode()
             return
@@ -5358,28 +5367,33 @@ class MosaicMasterDialog(QDialog):
 
         # Show spinner and start animation.
         self.spinnerLabel.show()
-        self.spinnerMovie.start()
+        if self.spinnerMovie:
+            self.spinnerMovie.start()
         QApplication.processEvents()
 
-        # Step 1: Force blind solve if requested.
+        # ------------------------------------------------------------
+        # 1) Plate solve (unless already solved and not forcing blind)
+        # ------------------------------------------------------------
         force_blind = self.forceBlindCheckBox.isChecked()
-        images_to_process = (self.loaded_images if force_blind
-                            else [item for item in self.loaded_images if item.get("wcs") is None])
+        images_to_process = (
+            self.loaded_images if force_blind
+            else [item for item in self.loaded_images if item.get("wcs") is None]
+        )
 
-        # Process each image for plate solving.
         for item in images_to_process:
-            # Check if ASTAP is set.
+            # Ensure ASTAP path (or fall back to blind solve)
             if not self.astap_exe or not os.path.exists(self.astap_exe):
                 executable_filter = "Executables (*.exe);;All Files (*)" if sys.platform.startswith("win") else "Executables (*)"
                 new_path, _ = QFileDialog.getOpenFileName(self, "Select ASTAP Executable", "", executable_filter)
                 if new_path:
                     self._save_astap_exe_to_settings(new_path)
+                    self.astap_exe = new_path
                     QMessageBox.information(self, "Mosaic Master", "ASTAP path updated successfully.")
                 else:
-                    QMessageBox.warning(self, "Mosaic Master", "ASTAP path not provided. Falling back to blind solve.")
+                    self.status_label.setText(f"No ASTAP path; blind solving {item['path']}...")
+                    QApplication.processEvents()
                     solved_header = self.perform_blind_solve(item)
                     if solved_header:
-                        # normalize + build WCS with relax=True so SIP is retained
                         solved_header = self._normalize_wcs_header(solved_header, item["image"].shape)
                         item["wcs"] = self._build_wcs(solved_header, item["image"].shape)
                     continue
@@ -5393,49 +5407,53 @@ class MosaicMasterDialog(QDialog):
                 self.status_label.setText(f"ASTAP failed for {item['path']}. Falling back to blind solve...")
                 QApplication.processEvents()
                 solved_header = self.perform_blind_solve(item)
-            else:
-                self.status_label.setText(f"Plate solve successful using ASTAP for {item['path']}.")
 
             if solved_header:
-                # Single, centralized sanitize → keeps SIP and fixes types
                 solved_header = self._normalize_wcs_header(solved_header, item["image"].shape)
                 item["wcs"] = self._build_wcs(solved_header, item["image"].shape)
             else:
-                print(f"Plate solving failed for {item['path']}.")
+                print(f"[Mosaic] Plate solving failed for {item['path']}.")
 
-        # After processing, get all images with valid WCS.
+        # ------------------------------------------------------------
+        # 2) Gather WCS-valid panels
+        # ------------------------------------------------------------
         wcs_items = [x for x in self.loaded_images if x.get("wcs") is not None]
         if not wcs_items:
-            print("No images have WCS, skipping WCS alignment.")
-            self.spinnerMovie.stop()
+            print("[Mosaic] No images have WCS; cannot build WCS mosaic.")
+            if self.spinnerMovie:
+                self.spinnerMovie.stop()
             self.spinnerLabel.hide()
             return
 
+        # ------------------------------------------------------------
+        # 3) Establish mosaic WCS + output bounding box
+        # ------------------------------------------------------------
+        reference_wcs = self._build_wcs(
+            wcs_items[0]["wcs"].to_header(relax=True),
+            wcs_items[0]["image"].shape
+        ).deepcopy()
 
-        # Use the first image's WCS as reference and compute the mosaic bounding box.
-        # (Rebuild with relax=True just in case, then deepcopy.)
-        reference_wcs = self._build_wcs(wcs_items[0]["wcs"].to_header(relax=True), wcs_items[0]["image"].shape).deepcopy()
         min_x, min_y, max_x, max_y = self.compute_mosaic_bounding_box(wcs_items, reference_wcs)
-        mosaic_width = int(max_x - min_x)
+        mosaic_width  = int(max_x - min_x)
         mosaic_height = int(max_y - min_y)
 
         if mosaic_width < 1 or mosaic_height < 1:
-            print("ERROR: Computed mosaic size is invalid. Check WCS or inputs.")
-            self.spinnerMovie.stop()
+            print("[Mosaic] ERROR: Computed mosaic size invalid. Check WCS/inputs.")
+            if self.spinnerMovie:
+                self.spinnerMovie.stop()
             self.spinnerLabel.hide()
             return
 
-        # Adjust the reference WCS so that (min_x, min_y) becomes (0,0).
         mosaic_wcs = reference_wcs.deepcopy()
         mosaic_wcs.wcs.crpix[0] -= min_x
         mosaic_wcs.wcs.crpix[1] -= min_y
-        # keep SIP in the stored header
         self.wcs_metadata = mosaic_wcs.to_header(relax=True)
 
-        # Set up accumulators.
+        # ------------------------------------------------------------
+        # 4) Allocate accumulators
+        # ------------------------------------------------------------
         is_color = any(not item["is_mono"] for item in wcs_items)
 
-        # stats for optional "unstretch"
         self.stretch_original_mins = []
         self.stretch_original_medians = []
         self.was_single_channel = (not is_color)
@@ -5446,49 +5464,77 @@ class MosaicMasterDialog(QDialog):
             self.final_mosaic, _ = smart_zeros((mosaic_height, mosaic_width), dtype=np.float32)
         self.weight_mosaic, _ = smart_zeros((mosaic_height, mosaic_width), dtype=np.float32)
 
+        # ------------------------------------------------------------
+        # 5) Normalization target — compute ONCE, apply ALWAYS
+        # ------------------------------------------------------------
+        did_normalize = bool(self.normalizeCheckBox.isChecked())
+
+        # IMPORTANT: compute from RAW first panel image, not from dict list in a way that can drift
+        if did_normalize:
+            try:
+                first_raw = wcs_items[0]["image"]
+                self._mosaic_target_median = self._target_median_from_first([{"image": first_raw}])
+            except Exception:
+                # fallback: compute directly
+                a0 = wcs_items[0]["image"].astype(np.float32, copy=False)
+                if a0.ndim == 3:
+                    a0m = np.mean(a0, axis=2)
+                else:
+                    a0m = a0
+                lo = np.percentile(a0m, 1)
+                hi = np.percentile(a0m, 99)
+                self._mosaic_target_median = float(max(np.median(np.clip(a0m, lo, hi)), 1e-6))
+
+            print(f"[Mosaic] normalization target median = {self._mosaic_target_median:.6g}")
+
+        # Reprojection helpers cache
+        if not hasattr(self, "_H_cache"):
+            self._H_cache = {}
+
+        # WCS-only toggle (no star alignment/refinement)
+        wcs_only = bool(getattr(self, "wcsOnlyCheckBox", None) and self.wcsOnlyCheckBox.isChecked())
+
+        # ------------------------------------------------------------
+        # 6) Main loop: normalize -> reproject -> (optional) star align -> accumulate
+        # ------------------------------------------------------------
         first_image = True
+
         for idx, itm in enumerate(wcs_items):
             arr = itm["image"]
+
             self.status_label.setText(f"Mapping {itm['path']} into mosaic frame...")
             QApplication.processEvents()
 
             img_lin = arr.astype(np.float32, copy=False)
 
-            # --- record original stats for optional "unstretch" ---
+            # --- record original stats (pre-normalization) for optional unstretch ---
             mono_for_stats = img_lin if img_lin.ndim == 2 else np.mean(img_lin, axis=2)
             self.stretch_original_mins.append(float(np.min(mono_for_stats)))
             self.stretch_original_medians.append(float(np.median(mono_for_stats)))
 
-            # 1) optional median normalization only
-            if self.normalizeCheckBox.isChecked():
-                target_med = getattr(self, "_mosaic_target_median", None)
-                if target_med is None:
-                    self._mosaic_target_median = self._target_median_from_first(wcs_items)
-                    target_med = self._mosaic_target_median
-                img_lin = self._normalize_linear(img_lin, target_med)
-
-            # 2) Reprojection (3 modes)
-            if not hasattr(self, "_H_cache"):
-                self._H_cache = {}
+            # --- ALWAYS normalize here if enabled (even in WCS-only) ---
+            if did_normalize:
+                img_lin = self._normalize_linear(img_lin, float(self._mosaic_target_median))
 
+            # --- Reprojection mode ---
             mode = self.reprojectModeCombo.currentText()
 
             if mode.startswith("Fast — SIP"):
-                # Exact dense remap (SIP-aware), tiled; keep mono as 2D
                 reprojected = self._warp_via_wcs_remap_exact(
                     img_lin, itm["wcs"], mosaic_wcs, (mosaic_height, mosaic_width), tile=512
-                ).astype(np.float32)
+                ).astype(np.float32, copy=False)
+                reprojected = self._polish_reprojected(reprojected)
                 reproj_red = reprojected[..., 0] if reprojected.ndim == 3 else reprojected
 
             elif mode.startswith("Fast — Homography"):
-                # Single global homography; keep mono as 2D
                 reprojected = self._warp_via_wcs_homography(
                     img_lin, itm["wcs"], mosaic_wcs, (mosaic_height, mosaic_width), H_cache=self._H_cache
-                ).astype(np.float32)
+                ).astype(np.float32, copy=False)
+                reprojected = self._polish_reprojected(reprojected)
                 reproj_red = reprojected[..., 0] if reprojected.ndim == 3 else reprojected
 
             else:
-                # Precise — Full WCS (astropy.reproject); mono stays 2D
+                # Precise — Full WCS
                 if img_lin.ndim == 3:
                     channels = []
                     for c in range(3):
@@ -5498,52 +5544,49 @@ class MosaicMasterDialog(QDialog):
                     reprojected = np.stack(channels, axis=-1)
                     reproj_red = reprojected[..., 0]
                 else:
-                    reproj_red, _ = reproject_interp((img_lin, itm["wcs"]), mosaic_wcs,
-                                                    shape_out=(mosaic_height, mosaic_width))
-                    reprojected = np.nan_to_num(reproj_red, nan=0.0).astype(np.float32)  # 2D mono
-                    # no fake stacking here
-
-            self.status_label.setText(f"WCS map: {itm['path']} processed.")
-            QApplication.processEvents()
-
-            # --- Stellar Alignment ---
-            if not first_image:
-                transform_method = self.transform_combo.currentText()
-                mosaic_gray = (self.final_mosaic if self.final_mosaic.ndim == 2
-                            else np.mean(self.final_mosaic, axis=-1))
-                try:
-                    self.status_label.setText("Computing affine transform with astroalign...")
-                    QApplication.processEvents()
-                    transform_obj, (src_pts, dst_pts) = self._aa_find_transform_with_backoff(reproj_red, mosaic_gray)
-                    transform_matrix = transform_obj.params[0:2, :].astype(np.float32)
-                    self.status_label.setText("Astroalign computed transform successfully.")
-                except Exception as e:
-                    self.status_label.setText(f"Astroalign failed: {e}. Using identity transform.")
-                    transform_matrix = np.eye(2, 3, dtype=np.float32)
+                    rpj, _ = reproject_interp((img_lin, itm["wcs"]), mosaic_wcs,
+                                            shape_out=(mosaic_height, mosaic_width))
+                    reprojected = np.nan_to_num(rpj, nan=0.0).astype(np.float32)
+                    reproj_red = reprojected  # 2D
 
-                A = transform_matrix[:, :2]
-                scale1 = np.linalg.norm(A[:, 0])
-                scale2 = np.linalg.norm(A[:, 1])
-                print(f"Computed affine scales: {scale1:.6f}, {scale2:.6f}")
+            # --- Optional star alignment/refinement (skipped in WCS-only) ---
+            if wcs_only:
+                aligned = reprojected
+                if first_image:
+                    first_image = False
+            else:
+                if first_image:
+                    aligned = reprojected
+                    first_image = False
+                else:
+                    transform_method = self.transform_combo.currentText()
+                    mosaic_gray = (self.final_mosaic if self.final_mosaic.ndim == 2
+                                else np.mean(self.final_mosaic, axis=-1))
 
-                self.status_label.setText("Affine alignment computed. Warping image...")
-                QApplication.processEvents()
-                affine_aligned = cv2.warpAffine(reprojected, transform_matrix, (mosaic_width, mosaic_height),
-                                                flags=cv2.INTER_LANCZOS4)
-                aligned = affine_aligned
+                    try:
+                        self.status_label.setText("Computing affine transform with astroalign...")
+                        QApplication.processEvents()
+                        transform_obj, (src_pts, dst_pts) = self._aa_find_transform_with_backoff(reproj_red, mosaic_gray)
+                        transform_matrix = transform_obj.params[0:2, :].astype(np.float32)
+                    except Exception as e:
+                        self.status_label.setText(f"Astroalign failed: {e}. Using identity transform.")
+                        transform_matrix = np.eye(2, 3, dtype=np.float32)
 
-                if transform_method in ["Homography Transform", "Polynomial Warp Based Transform"]:
-                    self.status_label.setText(f"Starting refined alignment using {transform_method}...")
-                    QApplication.processEvents()
-                    refined_result = self.refined_alignment(affine_aligned, mosaic_gray, method=transform_method)
-                    if refined_result is not None:
-                        aligned, best_inliers2 = refined_result
-                        self.status_label.setText(f"Refined alignment succeeded with {best_inliers2} inliers.")
-                    else:
-                        self.status_label.setText("Refined alignment failed; falling back to affine alignment.")
-            else:
-                aligned = reprojected
-                first_image = False
+                    affine_aligned = cv2.warpAffine(
+                        reprojected, transform_matrix, (mosaic_width, mosaic_height),
+                        flags=cv2.INTER_LANCZOS4
+                    )
+                    aligned = affine_aligned
+
+                    if transform_method in ["Homography Transform", "Polynomial Warp Based Transform"]:
+                        self.status_label.setText(f"Starting refined alignment using {transform_method}...")
+                        QApplication.processEvents()
+                        refined_result = self.refined_alignment(affine_aligned, mosaic_gray, method=transform_method)
+                        if refined_result is not None:
+                            aligned, best_inliers2 = refined_result
+                            self.status_label.setText(f"Refined alignment succeeded with {best_inliers2} inliers.")
+                        else:
+                            self.status_label.setText("Refined alignment failed; falling back to affine alignment.")
 
             # If mosaic is color but aligned is mono, expand for accumulation only
             if is_color and aligned.ndim == 2:
@@ -5551,13 +5594,13 @@ class MosaicMasterDialog(QDialog):
 
             gray_aligned = aligned[..., 0] if aligned.ndim == 3 else aligned
 
-            # Compute weight mask
+            # --- Weight mask ---
             binary_mask = (gray_aligned > 0).astype(np.uint8)
             smooth_mask = cv2.distanceTransform(binary_mask, cv2.DIST_L2, 5)
             smooth_mask = (smooth_mask / np.max(smooth_mask)) if np.max(smooth_mask) > 0 else binary_mask.astype(np.float32)
             smooth_mask = cv2.GaussianBlur(smooth_mask, (15, 15), 0)
 
-            # Accumulate
+            # --- Accumulate ---
             if is_color:
                 self.final_mosaic += aligned * smooth_mask[..., np.newaxis]
             else:
@@ -5567,22 +5610,27 @@ class MosaicMasterDialog(QDialog):
             self.status_label.setText(f"Processed: {itm['path']}")
             QApplication.processEvents()
 
-        # Final blending.
-        nonzero_mask = (self.weight_mosaic > 0)
+        # ------------------------------------------------------------
+        # 7) Final blend
+        # ------------------------------------------------------------
         if is_color:
-            self.final_mosaic = np.where(self.weight_mosaic[..., None] > 0,
-                                        self.final_mosaic / self.weight_mosaic[..., None],
-                                        self.final_mosaic)
+            self.final_mosaic = np.where(
+                self.weight_mosaic[..., None] > 0,
+                self.final_mosaic / np.maximum(self.weight_mosaic[..., None], 1e-12),
+                self.final_mosaic
+            )
         else:
-            self.final_mosaic[nonzero_mask] = self.final_mosaic[nonzero_mask] / self.weight_mosaic[nonzero_mask]
+            nz = (self.weight_mosaic > 0)
+            self.final_mosaic[nz] = self.final_mosaic[nz] / np.maximum(self.weight_mosaic[nz], 1e-12)
 
-        print("WCS + Star Alignment Complete.")
-        self.status_label.setText("WCS + Star Alignment Complete. De-Normalizing Mosaic...")
+        self.status_label.setText("Mosaic built. De-normalizing mosaic...")
+        QApplication.processEvents()
 
-        # Call-guard: only unstretch if we normalized AND we actually recorded stats
-        did_normalize = self.normalizeCheckBox.isChecked()
+        # ------------------------------------------------------------
+        # 8) Optional “unstretch” (your existing logic)
+        # ------------------------------------------------------------
         if (did_normalize and
-            hasattr(self, "_mosaic_target_median") and self._mosaic_target_median > 0 and
+            hasattr(self, "_mosaic_target_median") and float(self._mosaic_target_median) > 0 and
             getattr(self, "stretch_original_medians", None) and len(self.stretch_original_medians) > 0 and
             getattr(self, "stretch_original_mins", None) and len(self.stretch_original_mins) > 0):
             self.final_mosaic = self.unstretch_image(self.final_mosaic)
@@ -5590,16 +5638,37 @@ class MosaicMasterDialog(QDialog):
         self.status_label.setText("Final Mosaic Ready.")
         QApplication.processEvents()
 
-        display_image = (np.stack([self.final_mosaic]*3, axis=-1)
+        display_image = (np.stack([self.final_mosaic] * 3, axis=-1)
                         if self.final_mosaic.ndim == 2 else self.final_mosaic)
         display_image = self._autostretch_if_requested(display_image)
-        MosaicPreviewWindow(display_image, title="Final Mosaic", parent=self,
-                            push_cb=self._push_mosaic_to_new_doc).show()
 
-        self.spinnerMovie.stop()
+        MosaicPreviewWindow(
+            display_image,
+            title=("Final Mosaic (WCS-only)" if wcs_only else "Final Mosaic"),
+            parent=self,
+            push_cb=self._push_mosaic_to_new_doc
+        ).show()
+
+        if self.spinnerMovie:
+            self.spinnerMovie.stop()
         self.spinnerLabel.hide()
         QApplication.processEvents()
+
       
+    def _polish_reprojected(self, img: np.ndarray) -> np.ndarray:
+        # 1) kill NaNs/Infs from reprojection
+        out = np.nan_to_num(img, nan=0.0, posinf=0.0, neginf=0.0).astype(np.float32, copy=False)
+
+        # 2) trim tiny negative ringing
+        out[out < 0] = 0.0
+
+        # 3) optional: zero a 1px border to avoid remap edge seams
+        if out.ndim == 2:
+            out[:1, :] = 0; out[-1:, :] = 0; out[:, :1] = 0; out[:, -1:] = 0
+        else:
+            out[:1, :, :] = 0; out[-1:, :, :] = 0; out[:, :1, :] = 0; out[:, -1:, :] = 0
+
+        return out
 
     def debayer_image(self, image, file_path, header):
         from setiastro.saspro.legacy.numba_utils import debayer_raw_fast, debayer_fits_fast