setiastrosuitepro 1.6.2.post1__py3-none-any.whl

setiastro/saspro/convo_preset.py

@@ -0,0 +1,414 @@
+# pro/convo_preset.py
+from __future__ import annotations
+from typing import Optional, Tuple
+import numpy as np
+
+from PyQt6.QtWidgets import (
+    QDialog, QFormLayout, QDialogButtonBox, QVBoxLayout, QHBoxLayout,
+    QLabel, QComboBox, QCheckBox
+)
+from PyQt6.QtCore import Qt
+
+# Reuse widgets/utilities from convo.py
+from .convo import (
+    ConvoDeconvoDialog, FloatSliderWithEdit,
+    make_elliptical_gaussian_psf, van_cittert_deconv, larson_sekanina
+)
+
+# ---------------------------- Preset Editor Dialog ----------------------------
+class ConvoPresetDialog(QDialog):
+    """
+    One dialog for all Convo/Deconvo presets (including TV).
+    Produces a JSON-safe dict you can stash on a shortcut.
+    """
+    def __init__(self, parent=None, initial: dict | None = None):
+        super().__init__(parent)
+        self.setWindowTitle("Convolution / Deconvolution — Preset")
+        p = dict(initial or {})
+        op = p.get("op", "convolution")
+
+        root = QVBoxLayout(self)
+
+        # --- top: operation selector ---
+        op_row = QHBoxLayout()
+        op_row.addWidget(QLabel("Operation:"))
+        self.op_combo = QComboBox()
+        self.op_combo.addItems(["convolution", "deconvolution", "tv"])
+        self.op_combo.setCurrentText(op if op in ("convolution", "deconvolution", "tv") else "convolution")
+        op_row.addWidget(self.op_combo); op_row.addStretch()
+        root.addLayout(op_row)
+
+        # --- stacked parameter forms (we'll toggle visibility) ---
+        self.form_conv = QFormLayout()
+        self.conv_radius   = FloatSliderWithEdit(minimum=0.1, maximum=200.0, step=0.1, initial=float(p.get("radius", 5.0)), suffix=" px")
+        self.conv_kurtosis = FloatSliderWithEdit(minimum=0.1, maximum=10.0,  step=0.1, initial=float(p.get("kurtosis", 2.0)), suffix="σ")
+        self.conv_aspect   = FloatSliderWithEdit(minimum=0.1, maximum=10.0,  step=0.1, initial=float(p.get("aspect", 1.0)))
+        self.conv_rotation = FloatSliderWithEdit(minimum=0.0, maximum=360.0, step=1.0, initial=float(p.get("rotation", 0.0)), suffix="°")
+        self.conv_strength = FloatSliderWithEdit(minimum=0.0, maximum=1.0,   step=0.01, initial=float(p.get("strength", 1.0)))
+        self.form_conv.addRow("Radius:", self.conv_radius)
+        self.form_conv.addRow("Kurtosis (σ):", self.conv_kurtosis)
+        self.form_conv.addRow("Aspect Ratio:", self.conv_aspect)
+        self.form_conv.addRow("Rotation:", self.conv_rotation)
+        self.form_conv.addRow("Strength:", self.conv_strength)
+
+        self.form_deconv = QFormLayout()
+        self.deconv_algo = QComboBox()
+        self.deconv_algo.addItems(["Richardson-Lucy", "Wiener", "Larson-Sekanina", "Van Cittert"])
+        self.deconv_algo.setCurrentText(p.get("algo", "Richardson-Lucy"))
+        self.form_deconv.addRow("Algorithm:", self.deconv_algo)
+
+        # RL/Wiener PSF params
+        self.psf_radius   = FloatSliderWithEdit(minimum=0.1, maximum=100.0, step=0.1, initial=float(p.get("psf_radius", 3.0)), suffix=" px")
+        self.psf_kurtosis = FloatSliderWithEdit(minimum=0.1, maximum=10.0,  step=0.1, initial=float(p.get("psf_kurtosis", 2.0)), suffix="σ")
+        self.psf_aspect   = FloatSliderWithEdit(minimum=0.1, maximum=10.0,  step=0.1, initial=float(p.get("psf_aspect", 1.0)))
+        self.psf_rot      = FloatSliderWithEdit(minimum=0.0, maximum=360.0, step=1.0,   initial=float(p.get("psf_rotation", 0.0)), suffix="°")
+        self.form_deconv.addRow("PSF Radius:", self.psf_radius)
+        self.form_deconv.addRow("PSF Kurtosis:", self.psf_kurtosis)
+        self.form_deconv.addRow("PSF Aspect:", self.psf_aspect)
+        self.form_deconv.addRow("PSF Rotation:", self.psf_rot)
+
+        # RL options
+        self.rl_iter      = FloatSliderWithEdit(minimum=1, maximum=200, step=1, initial=float(p.get("rl_iter", 30)))
+        self.rl_reg       = QComboBox(); self.rl_reg.addItems(["None (Plain R–L)", "Tikhonov (L2)", "Total Variation (TV)"])
+        self.rl_reg.setCurrentText(p.get("rl_reg", "None (Plain R–L)"))
+        self.rl_clip      = QCheckBox("De-ring (bilateral)"); self.rl_clip.setChecked(bool(p.get("rl_dering", True)))
+        self.rl_l_only    = QCheckBox("L* only"); self.rl_l_only.setChecked(bool(p.get("luminance_only", True)))
+        self.form_deconv.addRow("RL Iterations:", self.rl_iter)
+        self.form_deconv.addRow("RL Regularization:", self.rl_reg)
+        self.form_deconv.addRow("", self.rl_clip)
+        self.form_deconv.addRow("", self.rl_l_only)
+
+        # Wiener options
+        self.wiener_nsr   = FloatSliderWithEdit(minimum=0.0, maximum=1.0, step=0.001, initial=float(p.get("wiener_nsr", 0.01)))
+        self.wiener_reg   = QComboBox(); self.wiener_reg.addItems(["None (Classical Wiener)", "Tikhonov (L2)"])
+        self.wiener_reg.setCurrentText(p.get("wiener_reg", "None (Classical Wiener)"))
+        self.wiener_dering= QCheckBox("De-ring pass"); self.wiener_dering.setChecked(bool(p.get("wiener_dering", True)))
+        self.form_deconv.addRow("Wiener NSR:", self.wiener_nsr)
+        self.form_deconv.addRow("Wiener Regularization:", self.wiener_reg)
+        self.form_deconv.addRow("", self.wiener_dering)
+
+        # Larson–Sekanina
+        self.ls_rstep     = FloatSliderWithEdit(minimum=0.0, maximum=50.0, step=0.1, initial=float(p.get("ls_rstep", 0.0)), suffix=" px")
+        self.ls_astep     = FloatSliderWithEdit(minimum=0.1, maximum=360.0, step=0.1, initial=float(p.get("ls_astep", 1.0)), suffix="°")
+        self.ls_operator  = QComboBox(); self.ls_operator.addItems(["Divide", "Subtract"]); self.ls_operator.setCurrentText(p.get("ls_operator", "Divide"))
+        self.ls_blend     = QComboBox(); self.ls_blend.addItems(["SoftLight", "Screen"]);   self.ls_blend.setCurrentText(p.get("ls_blend", "SoftLight"))
+        self.form_deconv.addRow("LS Radial Step:", self.ls_rstep)
+        self.form_deconv.addRow("LS Angular Step:", self.ls_astep)
+        self.form_deconv.addRow("LS Operator:", self.ls_operator)
+        self.form_deconv.addRow("Blend:", self.ls_blend)
+
+        # Van Cittert
+        self.vc_iter      = FloatSliderWithEdit(minimum=1, maximum=1000, step=1, initial=float(p.get("vc_iter", 10)))
+        self.vc_relax     = FloatSliderWithEdit(minimum=0.0, maximum=1.0, step=0.01, initial=float(p.get("vc_relax", 0.0)))
+        self.form_deconv.addRow("VC Iterations:", self.vc_iter)
+        self.form_deconv.addRow("VC Relaxation:", self.vc_relax)
+
+        # Strength (applies to all ops)
+        self.deconv_strength = FloatSliderWithEdit(minimum=0.0, maximum=1.0, step=0.01, initial=float(p.get("strength", 1.0)))
+        self.form_deconv.addRow("Strength:", self.deconv_strength)
+
+        # TV Denoise
+        self.form_tv = QFormLayout()
+        self.tv_weight = FloatSliderWithEdit(minimum=0.0, maximum=1.0, step=0.01, initial=float(p.get("tv_weight", 0.10)))
+        self.tv_iter   = FloatSliderWithEdit(minimum=1, maximum=100, step=1, initial=float(p.get("tv_iter", 10)))
+        self.tv_multi  = QCheckBox("Multi-channel"); self.tv_multi.setChecked(bool(p.get("tv_multichannel", True)))
+        self.tv_strength = FloatSliderWithEdit(minimum=0.0, maximum=1.0, step=0.01, initial=float(p.get("strength", 1.0)))
+        self.form_tv.addRow("TV Weight:", self.tv_weight)
+        self.form_tv.addRow("TV Iterations:", self.tv_iter)
+        self.form_tv.addRow("", self.tv_multi)
+        self.form_tv.addRow("Strength:", self.tv_strength)
+
+        # containers to show/hide
+        self.box_conv = _wrap_form(self.form_conv)
+        self.box_decv = _wrap_form(self.form_deconv)
+        self.box_tv   = _wrap_form(self.form_tv)
+        root.addWidget(self.box_conv)
+        root.addWidget(self.box_decv)
+        root.addWidget(self.box_tv)
+
+        def _toggle():
+            v = self.op_combo.currentText()
+            self.box_conv.setVisible(v == "convolution")
+            self.box_decv.setVisible(v == "deconvolution")
+            self.box_tv.setVisible(v == "tv")
+        self.op_combo.currentTextChanged.connect(lambda _: _toggle())
+        _toggle()
+
+        # buttons
+        btns = QDialogButtonBox(QDialogButtonBox.StandardButton.Ok | QDialogButtonBox.StandardButton.Cancel, parent=self)
+        btns.accepted.connect(self.accept); btns.rejected.connect(self.reject)
+        root.addWidget(btns)
+
+    def result_dict(self) -> dict:
+        op = self.op_combo.currentText()
+        if op == "convolution":
+            return {
+                "op": "convolution",
+                "radius": self.conv_radius.value(),
+                "kurtosis": self.conv_kurtosis.value(),
+                "aspect": self.conv_aspect.value(),
+                "rotation": self.conv_rotation.value(),
+                "strength": self.conv_strength.value(),
+            }
+        if op == "deconvolution":
+            return {
+                "op": "deconvolution",
+                "algo": self.deconv_algo.currentText(),
+                "psf_radius": self.psf_radius.value(),
+                "psf_kurtosis": self.psf_kurtosis.value(),
+                "psf_aspect": self.psf_aspect.value(),
+                "psf_rotation": self.psf_rot.value(),
+                "rl_iter": self.rl_iter.value(),
+                "rl_reg": self.rl_reg.currentText(),
+                "rl_dering": bool(self.rl_clip.isChecked()),
+                "luminance_only": bool(self.rl_l_only.isChecked()),
+                "wiener_nsr": self.wiener_nsr.value(),
+                "wiener_reg": self.wiener_reg.currentText(),
+                "wiener_dering": bool(self.wiener_dering.isChecked()),
+                "ls_rstep": self.ls_rstep.value(),
+                "ls_astep": self.ls_astep.value(),
+                "ls_operator": self.ls_operator.currentText(),
+                "ls_blend": self.ls_blend.currentText(),
+                "vc_iter": self.vc_iter.value(),
+                "vc_relax": self.vc_relax.value(),
+                "strength": self.deconv_strength.value(),
+                # optional center for LS (x,y) — if omitted we’ll use image center
+                # "center": [x, y],
+            }
+        # tv
+        return {
+            "op": "tv",
+            "tv_weight": self.tv_weight.value(),
+            "tv_iter": int(self.tv_iter.value()),
+            "tv_multichannel": bool(self.tv_multi.isChecked()),
+            "strength": self.tv_strength.value(),
+        }
+
+
+def _wrap_form(form: QFormLayout):
+    from PyQt6.QtWidgets import QWidget, QVBoxLayout
+    w = QWidget(); l = QVBoxLayout(w); l.setContentsMargins(0,0,0,0); l.addLayout(form)
+    return w
+
+
+# ---------------------------- Headless Apply ----------------------------
+def apply_convo_via_preset(main_window, doc, preset: dict):
+    """
+    Headless executor for Convolution/Deconvolution/TV using the same kernels/flows
+    as the dialog. Applies result to `doc` via doc_manager.
+    """
+    import numpy as np
+    from skimage.color import rgb2lab, lab2rgb
+    from skimage.restoration import denoise_tv_chambolle
+
+    dm = getattr(main_window, "doc_manager", None) or getattr(main_window, "dm", None)
+    if dm is None or doc is None or getattr(doc, "image", None) is None:
+        return
+
+    # ⚠️ You can keep or drop this; it no longer matters for the apply step.
+    try:
+        if hasattr(dm, "set_active_document"):
+            dm.set_active_document(doc)
+    except Exception:
+        pass
+
+    img = np.asarray(doc.image).astype(np.float32, copy=False)
+    p = dict(preset or {})
+    op = p.get("op", "convolution")
+
+    # Create a dialog instance to reuse its helpers (no UI shown)
+    d = ConvoDeconvoDialog(doc_manager=dm, parent=main_window)
+
+    def _blend(a, b, s):
+        s = float(max(0.0, min(1.0, s)))
+        return np.clip(b * s + a * (1.0 - s), 0.0, 1.0).astype(np.float32)
+
+    if op == "convolution":
+        psf = make_elliptical_gaussian_psf(
+            float(p.get("radius", 5.0)),
+            float(p.get("kurtosis", 2.0)),
+            float(p.get("aspect", 1.0)),
+            float(p.get("rotation", 0.0)),
+        ).astype(np.float32)
+        out = d._convolve_color(img, psf)
+        out = _blend(img, out, float(p.get("strength", 1.0)))
+
+    elif op == "deconvolution":
+        algo = p.get("algo", "Richardson-Lucy")
+        if algo in ("Richardson-Lucy", "Wiener"):
+            psf = make_elliptical_gaussian_psf(
+                float(p.get("psf_radius", 3.0)),
+                float(p.get("psf_kurtosis", 2.0)),
+                float(p.get("psf_aspect", 1.0)),
+                float(p.get("psf_rotation", 0.0)),
+            ).astype(np.float32)
+
+        if algo == "Richardson-Lucy":
+            iters = int(round(float(p.get("rl_iter", 30))))
+            reg   = p.get("rl_reg", "None (Plain R–L)")
+            clipf = bool(p.get("rl_dering", True))
+            lum_only = bool(p.get("luminance_only", True))
+            if lum_only and img.ndim == 3 and img.shape[2] == 3:
+                lab = rgb2lab(img); L = (lab[...,0] / 100.0).astype(np.float32)
+                Ld = d._richardson_lucy_color(L, psf, iterations=iters, reg_type=reg, clip_flag=clipf)
+                lab[...,0] = np.clip(Ld * 100.0, 0.0, 100.0)
+                tmp = lab2rgb(lab.astype(np.float32)).astype(np.float32)
+                out = np.clip(tmp, 0.0, 1.0)
+            else:
+                out = d._richardson_lucy_color(img, psf, iterations=iters, reg_type=reg, clip_flag=clipf)
+            out = _blend(img, out, float(p.get("strength", 1.0)))
+
+        elif algo == "Wiener":
+            nsr   = float(p.get("wiener_nsr", 0.01))
+            reg   = p.get("wiener_reg", "None (Classical Wiener)")
+            dering= bool(p.get("wiener_dering", True))
+            lum_only = bool(p.get("luminance_only", True))
+            if lum_only and img.ndim == 3 and img.shape[2] == 3:
+                lab = rgb2lab(img); L = (lab[...,0] / 100.0).astype(np.float32)
+                Ld = d._wiener_deconv_with_kernel(L, psf, nsr, reg, dering)
+                lab[...,0] = np.clip(Ld * 100.0, 0.0, 100.0)
+                tmp = lab2rgb(lab.astype(np.float32)).astype(np.float32)
+                out = np.clip(tmp, 0.0, 1.0)
+            else:
+                out = d._wiener_deconv_with_kernel(img, psf, nsr, reg, dering)
+                out = np.clip(out, 0.0, 1.0)
+            out = _blend(img, out, float(p.get("strength", 1.0)))
+
+
+        elif algo == "Larson-Sekanina":
+            H, W = img.shape[:2]
+            cxy = p.get("center", [W/2, H/2])
+            cx = float(cxy[0]); cy = float(cxy[1])
+
+            B = larson_sekanina(
+                image=img,
+                center=(cy, cx),  # (y,x)
+                radial_step=float(p.get("ls_rstep", 0.0)),
+                angular_step_deg=float(p.get("ls_astep", 1.0)),
+                operator=p.get("ls_operator", "Divide")
+            )
+
+            A = img
+            if A.ndim == 3 and A.shape[2] == 3:
+                # ✅ FIX: repeat into channel axis
+                B_rgb = np.repeat(B[..., None], 3, axis=2)
+                A_rgb = A
+            else:
+                B_rgb = B[..., None]
+                A_rgb = A[..., None]
+
+            blend_mode = p.get("ls_blend", "SoftLight")
+            if blend_mode == "Screen":
+                C = (A_rgb + B_rgb - (A_rgb * B_rgb))
+            else:  # SoftLight
+                C = (1 - 2 * B_rgb) * (A_rgb ** 2) + 2 * B_rgb * A_rgb
+
+            out = np.clip(C, 0.0, 1.0)
+            out = out[..., 0] if img.ndim == 2 else out
+            out = _blend(img, out, float(p.get("strength", 1.0)))
+
+        elif algo == "Van Cittert":
+            iters = int(round(float(p.get("vc_iter", 10))))
+            relax = float(p.get("vc_relax", 0.0))
+            if img.ndim == 3 and img.shape[2] == 3:
+                out = np.stack([van_cittert_deconv(img[...,c], iters, relax) for c in range(3)], axis=2).astype(np.float32)
+            else:
+                out = van_cittert_deconv(img, iters, relax).astype(np.float32)
+            out = np.clip(out, 0.0, 1.0)
+            out = _blend(img, out, float(p.get("strength", 1.0)))
+        else:
+            return  # unknown algo
+
+    elif op == "tv":
+        from skimage.restoration import denoise_tv_chambolle
+        weight = float(p.get("tv_weight", 0.10))
+        max_iter = int(p.get("tv_iter", 10))
+        multich = bool(p.get("tv_multichannel", True))
+        if img.ndim == 3 and multich:
+            out = denoise_tv_chambolle(img.astype(np.float32), weight=weight, max_num_iter=max_iter, channel_axis=-1).astype(np.float32)
+        elif img.ndim == 3 and img.shape[2] == 3:
+            chans = [denoise_tv_chambolle(img[...,c].astype(np.float32), weight=weight, max_num_iter=max_iter, channel_axis=None) for c in range(3)]
+            out = np.stack(chans, axis=2).astype(np.float32)
+        else:
+            out = denoise_tv_chambolle(img.astype(np.float32), weight=weight, max_num_iter=max_iter, channel_axis=None).astype(np.float32)
+        out = _blend(img, np.clip(out, 0.0, 1.0), float(p.get("strength", 1.0)))
+
+    else:
+        return
+
+    meta = dict(getattr(doc, "metadata", {}) or {})
+    meta["source"] = "ConvoDeconvo"
+
+    try:
+        if hasattr(doc, "apply_edit"):
+            # Let Document handle full vs ROI, history, etc.
+            doc.apply_edit(
+                out.astype(np.float32, copy=False),
+                metadata=meta,
+                step_name="Convo/Deconvo (preset)",
+            )
+        else:
+            # Fallback for legacy paths
+            if hasattr(dm, "set_active_document"):
+                dm.set_active_document(doc)
+            dm.update_active_document(
+                out.astype(np.float32, copy=False),
+                metadata=meta,
+                step_name="Convo/Deconvo (preset)",
+            )
+    except Exception:
+        # Re-raise so replay_last_action_on_base can show the warning
+        raise
+
+def run_convo_via_preset(main, doc_or_preset=None, preset: dict | None = None, *, target_doc=None):
+    """
+    Headless Convo/Deconvo/TV entrypoint for CommandSpec + Replay.
+
+    Supports BOTH call shapes:
+      1) New CommandRunner shape:
+            run_convo_via_preset(main, target_doc, preset)
+      2) Legacy shape:
+            run_convo_via_preset(main, preset_dict, target_doc=doc)
+            run_convo_via_preset(main, preset_dict)
+    """
+
+    from PyQt6.QtWidgets import QMessageBox
+
+    # ---- Interpret arguments for backward compat / new executor ----
+    if preset is None and isinstance(doc_or_preset, dict):
+        # Legacy: (main, preset_dict, target_doc=?)
+        p = dict(doc_or_preset or {})
+        doc = target_doc
+    else:
+        # New executor: (main, doc, preset_dict)
+        p = dict(preset or {})
+        doc = target_doc if target_doc is not None else doc_or_preset
+
+    # Resolve active doc if still None
+    if doc is None:
+        d = getattr(main, "_active_doc", None)
+        doc = d() if callable(d) else d
+
+    if doc is None or getattr(doc, "image", None) is None:
+        QMessageBox.warning(main, "Convolution / Deconvolution", "Load an image first.")
+        return
+
+    # ---- Record for Replay ----
+    try:
+        remember = getattr(main, "remember_last_headless_command", None)
+        if remember is None:
+            remember = getattr(main, "_remember_last_headless_command", None)
+
+        if callable(remember):
+            # IMPORTANT: store canonical id that exists in registry
+            remember("convo", p, description="Convolution / Deconvolution")
+        else:
+            setattr(main, "_last_headless_command", {
+                "command_id": "convo",
+                "preset": dict(p),
+            })
+    except Exception:
+        pass
+
+    apply_convo_via_preset(main, doc, p)
+

setiastro/saspro/copyastro.py

@@ -0,0 +1,190 @@
+# pro/copyastro.py
+# pro/m_header.py
+from __future__ import annotations
+from PyQt6.QtCore import Qt
+from PyQt6.QtWidgets import (
+    QDialog, QVBoxLayout, QHBoxLayout, QLabel, QComboBox,
+    QPushButton, QMessageBox, QCheckBox, QMdiSubWindow
+)
+
+class CopyAstrometryDialog(QDialog):
+    """
+    Modeless picker that copies the WCS/SIP solution from a source doc
+    into the target doc (explicitly passed active view).
+    """
+    def __init__(self, parent=None, target=None):
+        super().__init__(parent)
+        self.setWindowTitle("Copy Astrometric Solution")
+        self.setWindowFlag(Qt.WindowType.Window, True)
+        self.setWindowModality(Qt.WindowModality.NonModal)
+        self.setModal(False)
+        self.setMinimumWidth(420)
+
+        self._mw = parent
+        self._dm = getattr(parent, "doc_manager", None) or getattr(parent, "docman", None)
+
+        # --- resolve target doc from the passed-in active subwindow/view/doc
+        self._tgt = self._doc_from_target(target)
+        if self._tgt is None:
+            # fallback to active doc helpers, just in case
+            try:
+                self._tgt = self._dm.get_active_document() if self._dm else None
+            except Exception:
+                self._tgt = None
+            if self._tgt is None and hasattr(parent, "_active_doc"):
+                try:
+                    self._tgt = parent._active_doc()
+                except Exception:
+                    pass
+
+        lay = QVBoxLayout(self)
+
+        tgt_name = getattr(self._tgt, "display_name", lambda: None)() or "Active View"
+        lay.addWidget(QLabel(f"Target: <b>{tgt_name}</b>"))
+
+        lay.addWidget(QLabel("Choose a source image that already has a WCS/SIP solution:"))
+        self.combo = QComboBox(self)
+        lay.addWidget(self.combo)
+
+        self.chk_ignore_sip = QCheckBox("Ignore SIP terms (copy TAN only)")
+        self.chk_ignore_sip.setChecked(False)
+        lay.addWidget(self.chk_ignore_sip)
+
+        row = QHBoxLayout(); row.addStretch(1)
+        self.btn_copy = QPushButton("Copy")
+        self.btn_close = QPushButton("Close")
+        row.addWidget(self.btn_copy); row.addWidget(self.btn_close)
+        lay.addLayout(row)
+
+        self.btn_copy.clicked.connect(self._do_copy)
+        self.btn_close.clicked.connect(self.close)
+
+        self._candidates = []  # list[(doc, name, wcs_dict)]
+        self._load_sources()
+
+    # --- helpers --------------------------------------------------------
+    def _doc_from_target(self, target):
+        """Accept QMdiSubWindow, ImageSubWindow, or ImageDocument."""
+        try:
+            if target is None:
+                return None
+            # QMdiSubWindow → widget() → .document
+            if isinstance(target, QMdiSubWindow):
+                w = target.widget()
+                return getattr(w, "document", None)
+            # ImageSubWindow-like
+            if hasattr(target, "document"):
+                return getattr(target, "document", None)
+            # Already a document
+            if hasattr(target, "image") and hasattr(target, "metadata"):
+                return target
+        except Exception:
+            pass
+        return None
+
+    def _extract_wcs_dict_for(self, doc):
+        # Prefer the MW helper you already have (returns a flat dict of FITS cards)
+        if hasattr(self._mw, "_extract_wcs_dict"):
+            try:
+                d = self._mw._extract_wcs_dict(doc)
+                if d: return dict(d)
+            except Exception:
+                pass
+
+        # Fallback: read from original_header
+        meta = getattr(doc, "metadata", {}) or {}
+        hdr  = meta.get("original_header") or {}
+        try:
+            keys = [str(k).upper() for k in getattr(hdr, "keys", lambda: hdr.keys())()]
+            if "CRVAL1" in keys and "CRVAL2" in keys:
+                return {k: hdr[k] for k in getattr(hdr, "keys", lambda: hdr.keys())()}
+        except Exception:
+            pass
+        return {}
+
+    def _load_sources(self):
+        self.combo.clear()
+        self._candidates.clear()
+
+        if not self._dm or not self._tgt:
+            self.combo.addItem("No target image.")
+            self.btn_copy.setEnabled(False)
+            return
+
+        try:
+            docs = self._dm.all_documents()
+        except Exception:
+            docs = []
+
+        found_any = False
+        for d in docs:
+            if d is self._tgt:
+                continue
+            w = self._extract_wcs_dict_for(d)
+            if not w:
+                continue
+            name = getattr(d, "display_name", lambda: None)() or (getattr(d, "metadata", {}).get("file_path") or "Untitled")
+            # hint text (RA/Dec)
+            ra, dec = w.get("CRVAL1"), w.get("CRVAL2")
+            hint = f"  (RA={ra:.5f}, Dec={dec:.5f})" if isinstance(ra, (int, float)) and isinstance(dec, (int, float)) else ""
+            self.combo.addItem(name + hint)
+            self._candidates.append((d, name, w))
+            found_any = True
+
+        if not found_any:
+            self.combo.addItem("No other images with WCS found")
+            self.btn_copy.setEnabled(False)
+
+    # --- action ---------------------------------------------------------
+    def _do_copy(self):
+        if self._tgt is None:
+            QMessageBox.information(self, "Copy Astrometry", "No target image.")
+            return
+
+        idx = self.combo.currentIndex()
+        if idx < 0 or idx >= len(self._candidates):
+            return
+
+        _, src_name, wcs = self._candidates[idx]
+
+        # Optionally strip SIP → TAN only
+        if self.chk_ignore_sip.isChecked():
+            wcs = {
+                k: v for k, v in wcs.items()
+                if not str(k).upper().startswith(("A_", "B_", "AP_", "BP_"))
+                and str(k).upper() not in {"A_ORDER", "B_ORDER", "AP_ORDER", "BP_ORDER"}
+            }
+            # enforce TAN
+            c1 = str(wcs.get("CTYPE1", "RA---TAN"))
+            c2 = str(wcs.get("CTYPE2", "DEC--TAN"))
+            if c1.endswith("-SIP"): wcs["CTYPE1"] = "RA---TAN"
+            if c2.endswith("-SIP"): wcs["CTYPE2"] = "DEC--TAN"
+
+        ok = False
+        if hasattr(self._mw, "_apply_wcs_dict_to_doc"):
+            try:
+                ok = bool(self._mw._apply_wcs_dict_to_doc(self._tgt, dict(wcs)))
+            except Exception:
+                ok = False
+
+        if not ok:
+            QMessageBox.warning(self, "Copy Astrometry", "Failed to apply astrometric solution.")
+            return
+
+        # refresh header dock + listeners immediately
+        try:
+            if hasattr(self._mw, "_refresh_header_viewer"):
+                self._mw._refresh_header_viewer(self._tgt)
+            if hasattr(self._mw, "currentDocumentChanged"):
+                self._mw.currentDocumentChanged.emit(self._tgt)
+        except Exception:
+            pass
+
+        try:
+            tgt_name = getattr(self._tgt, "display_name", lambda: None)() or "Target"
+            QMessageBox.information(self, "Copy Astrometry",
+                                    f"Copied solution from “{src_name}” to “{tgt_name}”.")
+        except Exception:
+            pass
+
+        self.close()