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

setiastro/saspro/gui/main_window.py

@@ -129,7 +129,7 @@ from PyQt6.QtGui import (QPixmap, QColor, QIcon, QKeySequence, QShortcut,
 
 # ----- QtCore -----
 from PyQt6.QtCore import (Qt, pyqtSignal, QCoreApplication, QTimer, QSize, QSignalBlocker,  QModelIndex, QThread, QUrl, QSettings, QEvent, QByteArray, QObject,
-    QPropertyAnimation, QEasingCurve
+    QPropertyAnimation, QEasingCurve, QElapsedTimer
 )
 
 from PyQt6.QtNetwork import QNetworkAccessManager, QNetworkRequest, QNetworkReply
@@ -168,7 +168,7 @@ except Exception:
 
 
 
-
+_DEBUG_DND_DUP = False
 
 
 
@@ -187,14 +187,14 @@ from setiastro.saspro.resources import (
     platesolve_path, psf_path, supernova_path, starregistration_path,
     stacking_path, pedestal_icon_path, starspike_path, aperture_path,
     jwstpupil_path, signature_icon_path, livestacking_path, hrdiagram_path,
-    convoicon_path, spcc_icon_path, sasp_data_path, exoicon_path, peeker_icon,
+    convoicon_path, spcc_icon_path, sasp_data_path, exoicon_path, peeker_icon,rotatearbitrary_path,
     dse_icon_path, astrobin_filters_csv_path, isophote_path, statstretch_path,
     starstretch_path, curves_path, disk_path, uhs_path, blink_path, ppp_path,
     nbtorgb_path, freqsep_path, contsub_path, halo_path, cosmic_path,
     satellite_path, imagecombine_path, wrench_path, eye_icon_path,multiscale_decomp_path,
     disk_icon_path, nuke_path, hubble_path, collage_path, annotated_path,
     colorwheel_path, font_path, csv_icon_path, spinner_path, wims_path,
-    wimi_path, linearfit_path, debayer_path, aberration_path,
+    wimi_path, linearfit_path, debayer_path, aberration_path, acv_icon_path,
     functionbundles_path, viewbundles_path, selectivecolor_path, rgbalign_path,
     background_path, script_icon_path
 )
@@ -285,6 +285,144 @@ from setiastro.saspro.gui.mixins import (
     ThemeMixin, GeometryMixin, ViewMixin, HeaderMixin, MaskMixin, UpdateMixin
 )
 
+import sys
+import time
+import threading
+import traceback
+from PyQt6.QtCore import QObject, QTimer
+
+class UiStallDetector(QObject):
+    """
+    Detects UI stalls by watching QTimer tick drift.
+    On stall, prints stack traces for all threads using print().
+    (No faulthandler / no fileno() required.)
+    """
+
+    def __init__(self, parent=None, interval_ms: int = 50, threshold_ms: int = 300):
+        super().__init__(parent)
+        self.interval_ms = int(interval_ms)
+        self.threshold_ms = int(threshold_ms)
+        self._last = time.perf_counter()
+        self._stall_seq = 0
+
+        # cooldown state (instance-level)
+        self._last_dump_t = 0.0
+
+        self._timer = QTimer(self)
+        self._timer.setInterval(self.interval_ms)
+        self._timer.timeout.connect(self._tick)
+
+    def start(self):
+        self._last = time.perf_counter()
+        self._timer.start()
+
+    def stop(self):
+        self._timer.stop()
+
+    def _dump_all_threads_print(self):
+        now = time.perf_counter()
+        if now - self._last_dump_t < 2.0:  # 2s cooldown
+            print("[UI STALL] dump skipped (cooldown)", flush=True)
+            return
+        self._last_dump_t = now
+
+        frames = sys._current_frames()
+        main_ident = threading.main_thread().ident
+
+        print("[UI STALL] ===== lightweight dump (all threads) =====", flush=True)
+
+        # Main thread: full stack
+        if main_ident in frames:
+            print("\n--- MainThread (full) ---", flush=True)
+            print("".join(traceback.format_stack(frames[main_ident])), flush=True)
+
+        # Other threads: only top-frame summary
+        for t in threading.enumerate():
+            if t.ident is None or t.ident == main_ident:
+                continue
+            f = frames.get(t.ident)
+            if not f:
+                continue
+            code = f.f_code
+            print(
+                f"--- Thread {t.ident} ({t.name}) top --- {code.co_filename}:{f.f_lineno} in {code.co_name}",
+                flush=True,
+            )
+
+        print("[UI STALL] ===== end lightweight dump =====", flush=True)
+
+    def _tick(self):
+        now = time.perf_counter()
+        elapsed_ms = (now - self._last) * 1000.0
+        self._last = now
+
+        late_ms = elapsed_ms - self.interval_ms
+        if late_ms >= self.threshold_ms:
+            print(f"[UI STALL] tick late by {late_ms:.0f} ms (elapsed={elapsed_ms:.0f} ms)", flush=True)
+            self._dump_all_threads_print()
+
+def _strip_filename_ext(title: str) -> str:
+    t = (title or "").strip()
+    if not t:
+        return t
+    base, ext = os.path.splitext(t)
+    # treat as extension only if it looks like one: .fit .fits .tif .tiff .xisf etc
+    if ext and 1 <= len(ext) <= 10 and all(ch.isalnum() for ch in ext[1:]):
+        return base
+    return t
+
+
+
+_DECOR_GLYPHS = "■●◆▲▪▫•◼◻◾◽🔗"
+
+def normalize_doc_title(s: str) -> str:
+    s = (s or "").strip()
+
+    # remove our textual prefix too
+    if s.startswith("[LINK] "):
+        s = s[len("[LINK] "):].strip()
+
+    # strip common UI decorations if you already have this helper
+    try:
+        s = _strip_ui_decorations(s)
+    except Exception:
+        pass
+
+    # remove any leading decorator glyphs repeatedly: "🔗 ", "■ ", etc.
+    while len(s) >= 2 and s[0] in _DECOR_GLYPHS and s[1] == " ":
+        s = s[2:].lstrip()
+
+    # also remove any stray decorator glyphs that got embedded (rare but happens)
+    s = re.sub(rf"[{re.escape(_DECOR_GLYPHS)}]", "", s).strip()
+
+    return s
+
+_VIEW_SUFFIX_RE = re.compile(r"\s+\[View\s+\d+\]\s*$")
+
+def _normalize_title_for_compare(t: str) -> str:
+    t = (t or "").strip()
+    if not t:
+        return ""
+
+    # strip UI decorations (🔗, ■, etc)
+    try:
+        t = _strip_ui_decorations(t)
+    except Exception:
+        pass
+
+    # strip trailing "[View N]" if present
+    t = _VIEW_SUFFIX_RE.sub("", t).strip()
+
+    # strip filename-like extension
+    try:
+        t = _strip_filename_ext(t)
+    except Exception:
+        # fallback: only strip if it looks like an ext
+        base, ext = os.path.splitext(t)
+        if ext and len(ext) <= 10:
+            t = base
+
+    return t.strip()
 
 class AstroSuiteProMainWindow(
     DockMixin, MenuMixin, ToolbarMixin, FileMixin,
@@ -299,7 +437,8 @@ class AstroSuiteProMainWindow(
         # Prevent white flash: start strictly transparent and force dark bg
         self.setWindowOpacity(0.0)
         self.setStyleSheet("QMainWindow { background-color: #0F0F19; }")
-
+        #self._stall = UiStallDetector(self, interval_ms=50, threshold_ms=250)
+        #self._stall.start()
         # --- Usage Stats ---
         self._session_start_time = time.time()
         self._stats_timer = QTimer(self)
@@ -310,7 +449,7 @@ class AstroSuiteProMainWindow(
         from setiastro.saspro.window_shelf import WindowShelf, MinimizeInterceptor
         from setiastro.saspro.imageops.mdi_snap import MdiSnapController
         from setiastro.saspro.ops.scripts import ScriptManager
-        self._version = "1.6.1"
+        self._version = version
         self._build_timestamp = build_timestamp
         self.setWindowTitle(f"Seti Astro Suite Pro v{self._version}")
         self.resize(1400, 900)
@@ -467,26 +606,23 @@ class AstroSuiteProMainWindow(
         self.mdi.linkViewDropped.connect(self._on_linkview_drop)
 
         self.doc_manager.set_mdi_area(self.mdi)
-
+        # Coalesce undo/redo label refreshes
+        self._undo_redo_refresh_pending = False
+        self._undo_redo_refresh_timer = QTimer(self)
+        self._undo_redo_refresh_timer.setSingleShot(True)
+        self._undo_redo_refresh_timer.timeout.connect(self._do_undo_redo_label_refresh)
         # Keep the toolbar in sync whenever anything relevant changes
-        self.doc_manager.documentAdded.connect(lambda *_: self.update_undo_redo_action_labels())
-        self.doc_manager.documentRemoved.connect(lambda *_: self.update_undo_redo_action_labels())
-        self.doc_manager.imageRegionUpdated.connect(lambda *_: self.update_undo_redo_action_labels())
-        self.doc_manager.previewRepaintRequested.connect(lambda *_: self.update_undo_redo_action_labels())
-
-        # Also refresh when the active subwindow changes
-        try:
-            self.mdi.subWindowActivated.connect(lambda *_: self.update_undo_redo_action_labels())
-        except Exception:
-            pass
-
-        try:
-            QApplication.instance().focusChanged.connect(
-                lambda *_: QTimer.singleShot(0, self.update_undo_redo_action_labels)
-            )
-        except Exception:
-            pass
-
+        self.doc_manager.documentAdded.connect(lambda *_: self._schedule_undo_redo_label_refresh())
+        self.doc_manager.documentRemoved.connect(lambda *_: self._schedule_undo_redo_label_refresh())
+        self.doc_manager.imageRegionUpdated.connect(lambda *_: self._schedule_undo_redo_label_refresh())
+        self.doc_manager.previewRepaintRequested.connect(lambda *_: self._schedule_undo_redo_label_refresh())
+        self.mdi.subWindowActivated.connect(lambda *_: self._schedule_undo_redo_label_refresh())
+
+        # optional: keep, but schedule (or remove entirely)
+        #try:
+        #    QApplication.instance().focusChanged.connect(lambda *_: self._schedule_undo_redo_label_refresh())
+        #except Exception:
+        #    pass
         self.shortcuts.load_shortcuts()
         self._ensure_persistent_names() 
         self._restore_window_placement()
@@ -570,6 +706,22 @@ class AstroSuiteProMainWindow(
 
     # _init_log_dock, _hook_stdout_stderr, and _append_log_text are now in DockMixin
 
+    def _schedule_undo_redo_label_refresh(self):
+        # Coalesce many triggers into one UI update
+        if getattr(self, "_undo_redo_refresh_pending", False):
+            return
+        self._undo_redo_refresh_pending = True
+        # 0ms is fine *if* it’s a real attribute timer (not a local)
+        self._undo_redo_refresh_timer.start(0)
+
+    def _do_undo_redo_label_refresh(self):
+        self._undo_redo_refresh_pending = False
+        try:
+            self.update_undo_redo_action_labels()
+        except Exception:
+            pass
+
+
     def _rebuild_menus_for_language(self):
         """Rebuild menus after language change to apply new translations."""
         try:
@@ -608,7 +760,7 @@ class AstroSuiteProMainWindow(
             doc.changed.connect(self.update_undo_redo_action_labels)
         except Exception:
             pass
-        self.update_undo_redo_action_labels()
+        self._schedule_undo_redo_label_refresh()
 
     def _promote_roi_preview_to_real_doc(self, st: dict, preview_doc) -> None:
         """
@@ -843,7 +995,18 @@ class AstroSuiteProMainWindow(
         dm = self.doc_manager
         doc = None
 
+        if _DEBUG_DND_DUP:
+            import json
+            print("\n[DNDDBG:DROP_ENTER] raw st dict:")
+            try:
+                # st is already a dict here
+                for k in sorted(st.keys()):
+                    print(f"  {k}: {st.get(k)!r}")
+            except Exception as e:
+                print("[DNDDBG:DROP_ENTER] failed printing st:", e)
 
+            # sanity: show which fields are present
+            print("[DNDDBG:DROP_ENTER] has source_view_title?", "source_view_title" in st)
 
         # Prefer *stable* identifiers over the proxy pointer
         uid     = st.get("doc_uid")
@@ -946,7 +1109,21 @@ class AstroSuiteProMainWindow(
             print("[VIEWSTATE_DROP] EXIT (no doc)")
             return
 
-
+        if _DEBUG_DND_DUP:
+            try:
+                dname = doc.display_name() if hasattr(doc, "display_name") else None
+            except Exception:
+                dname = None
+            try:
+                meta = getattr(doc, "metadata", {}) or {}
+            except Exception:
+                meta = {}
+            print("\n[DNDDBG:DOC_RESOLVED]")
+            print("  doc_obj:", doc, "type:", type(doc).__name__, "id:", id(doc))
+            print("  doc.uid:", getattr(doc, "uid", None))
+            print("  doc.display_name():", dname)
+            print("  meta.display_name:", meta.get("display_name"))
+            print("  meta.file_path:", meta.get("file_path"))
 
         # ----------------------------------------
         # 4) Peek at metadata to see if this is a
@@ -1037,34 +1214,35 @@ class AstroSuiteProMainWindow(
         #      copy the view transform.
         # ----------------------------------------
         if force_new:
-            # We're here only if:
-            #  - it's NOT a preview (normal full or promoted ROI), or
-            #  - ROI promotion didn't apply and we fell through.
             base_doc = doc
 
-            # 1) Duplicate the underlying document
-            try:
-                base_name = ""
+            # 1) Prefer the dragged view's title
+            base_name = (st.get("source_view_title") or "").strip()
+
+            # 2) Fallback to document display name
+            if not base_name:
                 try:
                     base_name = base_doc.display_name() or "Untitled"
                 except Exception:
                     base_name = "Untitled"
 
-                try:
-                    base_name = _strip_ui_decorations(base_name)
-                except Exception:
-                    # minimal fallback: remove known glyph prefixes and "Active View: "
-                    while len(base_name) >= 2 and base_name[1] == " " and base_name[0] in "â- â--â--†â-²â-ªâ-«â€¢â--¼â--»â--¾â--½":
-                        base_name = base_name[2:]
-                    if base_name.startswith("Active View: "):
-                        base_name = base_name[len("Active View: "):]
-
-                new_doc = self.docman.duplicate_document(
-                    base_doc, new_name=f"{base_name}_duplicate"
-                )
-            except Exception as e:
-                print("[Main] viewstate_drop: duplicate_document failed, falling back to original doc:", e)
-                new_doc = base_doc  # worst-case: still just reuse
+            # 3) Clean it (strip glyphs / "Active View" / etc.)
+            try:
+                base_name = _strip_ui_decorations(base_name)
+            except Exception:
+                if base_name.startswith("Active View: "):
+                    base_name = base_name[len("Active View: "):]
+
+            if _DEBUG_DND_DUP:
+                print("\n[DNDDBG:NAME_COMPUTE]")
+                print("  st.source_view_title:", (st.get("source_view_title") or "").strip())
+                print("  base_doc.display_name():", (base_doc.display_name() if hasattr(base_doc,"display_name") else None))
+                print("  base_name(after fallbacks/strip):", base_name)
+                print("  new_name passed:", f"{base_name}_duplicate")
+
+            new_doc = self.docman.duplicate_document(
+                base_doc, new_name=f"{base_name}_duplicate"
+            )
 
             # 2) Let doc_manager's documentAdded handler create the subwindow.
             #    We just wait for it to show up and then apply the view state.
@@ -1190,14 +1368,6 @@ class AstroSuiteProMainWindow(
             return False
 
     def _on_document_added(self, doc):
-        # Helpful debug:
-        try:
-            is_table = (getattr(doc, "metadata", {}).get("doc_type") == "table") or \
-                    (hasattr(doc, "rows") and hasattr(doc, "headers"))
-            self._log(f"[documentAdded] {type(doc).__name__}  table={is_table}  name={getattr(doc, 'display_name', lambda:'?')()}")
-        except Exception:
-            pass
-
         self._spawn_subwindow_for(doc)
 
     # --- UI scaffolding ---
@@ -1206,11 +1376,11 @@ class AstroSuiteProMainWindow(
         global_pos = lw.viewport().mapToGlobal(pos)
 
         menu = QMenu(lw)
-        act_copy_selected = menu.addAction("Copy Selected")
-        act_copy_all      = menu.addAction("Copy All")
+        act_copy_selected = menu.addAction(self.tr("Copy Selected"))
+        act_copy_all      = menu.addAction(self.tr("Copy All"))
         menu.addSeparator()
-        act_select_all    = menu.addAction("Select All Lines")
-        act_clear         = menu.addAction("Clear Console")
+        act_select_all    = menu.addAction(self.tr("Select All Lines"))
+        act_clear         = menu.addAction(self.tr("Clear Console"))
 
         action = menu.exec(global_pos)
         if action is None:
@@ -1804,7 +1974,7 @@ class AstroSuiteProMainWindow(
 
             show_view_bundles(self)
         except Exception as e:
-            QMessageBox.warning(self, "View Bundles", f"Open failed:\n{e}")
+            QMessageBox.warning(self, self.tr("View Bundles"), f"Open failed:\n{e}")
 
     def _open_function_bundles(self):
         from setiastro.saspro.function_bundle import show_function_bundles
@@ -1812,7 +1982,7 @@ class AstroSuiteProMainWindow(
 
             show_function_bundles(self)
         except Exception as e:
-            QMessageBox.warning(self, "Function Bundles", f"Open failed:\n{e}")
+            QMessageBox.warning(self, self.tr("Function Bundles"), f"Open failed:\n{e}")
 
     def _open_scripts_folder(self):
         if hasattr(self, "scriptman"):
@@ -1874,43 +2044,43 @@ class AstroSuiteProMainWindow(
         # Manual list (extend anytime). Format: (Gesture, Context, Effect)
         rows = [
             # Command search
-            ("A", "Display Stretch", "Toggle Display Auto-Stretch"),
-            ("Ctrl+I", "Invert", "Invert the Image"),
-            ("Ctrl+Shift+P", "Command Search", "Focus the command search bar; Enter runs first match"),
+            ("A", "Display Stretch", self.tr("Toggle Display Auto-Stretch")),
+            ("Ctrl+I", "Invert", self.tr("Invert the Image")),
+            ("Ctrl+Shift+P", "Command Search", self.tr("Focus the command search bar; Enter runs first match")),
 
             # View Icon
-            ("Drag view -> Off to Canvas", "View", "Duplicate Image"),
-            ("Drag view -> On to Other Image", "View", "Copy Zoom and Pan"),
-            ("Shift+Drag -> On to Other Image", "View", "Apply that image to the other as a mask"), 
-            ("Ctrl+Drag -> On to Other Image", "View", "Copy Astrometric Solution"),            
+            ("Drag view -> Off to Canvas", "View", self.tr("Duplicate Image")),
+            ("Drag view -> On to Other Image", "View", self.tr("Copy Zoom and Pan")),
+            ("Shift+Drag -> On to Other Image", "View", self.tr("Apply that image to the other as a mask")), 
+            ("Ctrl+Drag -> On to Other Image", "View", self.tr("Copy Astrometric Solution")),            
 
             # View zoom
-            ("Ctrl+1", "View", "Zoom to 100% (1:1)"),
-            ("Ctrl+0", "View", "Fit image to current window"),
-            ("Ctrl++", "View", "Zoom In"),
-            ("Ctrl+-", "View", "Zoom Out"),
+            ("Ctrl+1", "View", self.tr("Zoom to 100% (1:1)")),
+            ("Ctrl+0", "View", self.tr("Fit image to current window")),
+            ("Ctrl++", "View", self.tr("Zoom In")),
+            ("Ctrl+-", "View", self.tr("Zoom Out")),
 
             # Window switching
-            ("Ctrl+PgDown", "MDI", "Switch to previously active view"),
-            ("Ctrl+PgUp",   "MDI", "Switch to next active view"),
+            ("Ctrl+PgDown", "MDI", self.tr("Switch to previously active view")),
+            ("Ctrl+PgUp",   "MDI", self.tr("Switch to next active view")),
 
             # Shortcuts canvas + buttons
-            ("Alt+Drag (toolbar button)", "Toolbar", "Create a desktop shortcut for that action"),
-            ("Alt+Drag (shortcut button -> view)", "Shortcuts", "Headless apply the shortcut's command/preset to a view"),
-            ("Ctrl/Shift+Click", "Shortcuts", "Multi-select shortcut buttons"),
-            ("Drag (selection)", "Shortcuts", "Move selected shortcut buttons"),
-            ("Delete / Backspace", "Shortcuts", "Delete selected shortcut buttons"),
-            ("Ctrl+A", "Shortcuts", "Select all shortcut buttons"),
-            ("Double-click empty area", "MDI background", "Open files dialog"),
+            ("Alt+Drag (toolbar button)", "Toolbar", self.tr("Create a desktop shortcut for that action")),
+            ("Alt+Drag (shortcut button -> view)", "Shortcuts", self.tr("Headless apply the shortcut's command/preset to a view")),
+            ("Ctrl/Shift+Click", "Shortcuts", self.tr("Multi-select shortcut buttons")),
+            ("Drag (selection)", "Shortcuts", self.tr("Move selected shortcut buttons")),
+            ("Delete / Backspace", "Shortcuts", self.tr("Delete selected shortcut buttons")),
+            ("Ctrl+A", "Shortcuts", self.tr("Select all shortcut buttons")),
+            ("Double-click empty area", "MDI background", self.tr("Open files dialog")),
 
             # Layers dock
-            ("Drag view -> Layers list", "Layers", "Add dragged view as a new layer (on top)"),
-            ("Shift+Drag mask -> Layers list", "Layers", "Attach dragged image as mask to the selected layer"),
+            ("Drag view -> Layers list", "Layers", self.tr("Add dragged view as a new layer (on top)")),
+            ("Shift+Drag mask -> Layers list", "Layers", self.tr("Attach dragged image as mask to the selected layer")),
 
             # Crop tool
-            ("Click-drag", "Crop Tool", "Draw a crop rectangle"),
-            ("Drag corner handles", "Crop Tool", "Resize crop rectangle"),
-            ("Shift+Drag on box", "Crop Tool", "Rotate crop rectangle"),
+            ("Click-drag", "Crop Tool", self.tr("Draw a crop rectangle")),
+            ("Drag corner handles", "Crop Tool", self.tr("Resize crop rectangle")),
+            ("Shift+Drag on box", "Crop Tool", self.tr("Rotate crop rectangle")),
         ]
         return rows
 
@@ -2027,7 +2197,7 @@ class AstroSuiteProMainWindow(
         if getattr(self, "doc_manager", None) and self.doc_manager._docs:
             if not self._confirm_discard(
                 title=title,
-                msg=(
+                msg=self.tr(
                     "Loading a project will close current views and replace desktop shortcuts.\n"
                     "Continue?"
                 ),
@@ -2490,10 +2660,27 @@ class AstroSuiteProMainWindow(
         return f"{name}{dims}"
 
     def _update_explorer_item_for_doc(self, doc):
-        for i in range(self.explorer.count()):
-            it = self.explorer.item(i)
-            if it.data(Qt.ItemDataRole.UserRole) is doc:
-                it.setText(self._format_explorer_title(doc))
+        # Delegate to DockMixin implementation if present
+        try:
+            return super()._update_explorer_item_for_doc(doc)
+        except Exception:
+            pass
+
+        # Fallback: tree-safe implementation
+        if not hasattr(self, "explorer") or self.explorer is None:
+            return
+        try:
+            n = self.explorer.topLevelItemCount()
+        except Exception:
+            return
+
+        for i in range(n):
+            it = self.explorer.topLevelItem(i)
+            if it.data(0, Qt.ItemDataRole.UserRole) is doc:
+                try:
+                    self._refresh_explorer_row(it, doc)
+                except Exception:
+                    pass
                 return
     #-----------FUNCTIONS----------------
 
@@ -3002,17 +3189,17 @@ class AstroSuiteProMainWindow(
 
         self.convo_window.show()
 
-    
-
     def _apply_extract_luminance_preset_to_doc(self, doc, preset=None):
-
         from PyQt6.QtWidgets import QMessageBox
-        from setiastro.saspro.luminancerecombine import compute_luminance, _LUMA_REC709, _LUMA_REC601, _LUMA_REC2020
-        from setiastro.saspro.headless_utils import normalize_headless_main, unwrap_docproxy
+        from setiastro.saspro.luminancerecombine import (
+            compute_luminance,
+            resolve_luma_profile_weights,
+        )
+        from setiastro.saspro.headless_utils import unwrap_docproxy
+        import numpy as np
 
         doc = unwrap_docproxy(doc)
         p = dict(preset or {})
-        mode = (p.get("mode") or "rec709").lower()
 
         if doc is None or getattr(doc, "image", None) is None:
             QMessageBox.information(self, "Extract Luminance", "No target image.")
@@ -3020,52 +3207,43 @@ class AstroSuiteProMainWindow(
 
         img = np.asarray(doc.image)
 
-        # pick weights
-        if mode == "rec601":
-            w = _LUMA_REC601
-        elif mode == "rec2020":
-            w = _LUMA_REC2020
-        elif mode == "max":
-            w = None
-        else:
-            w = _LUMA_REC709
+        mode = str(p.get("mode", "rec709")).strip()
+        resolved_method, w, profile_name = resolve_luma_profile_weights(mode)
 
-        L = compute_luminance(img, method=mode, weights=w)
+        L = compute_luminance(img, method=resolved_method, weights=w)
 
         dm = getattr(self, "doc_manager", None)
         if dm is None:
-            # headless fallback: just overwrite active doc
             doc.apply_edit(L.astype(np.float32), step_name="Extract Luminance")
             return
 
-        # normal behavior: create a new mono document
+        meta = {
+            "step_name": "Extract Luminance",
+            "luma_method": resolved_method,
+        }
+        if w is not None:
+            meta["luma_weights"] = np.asarray(w, dtype=np.float32).tolist()
+        if profile_name:
+            meta["luma_profile"] = str(profile_name)
+
         try:
+            suffix = f"{profile_name}" if profile_name else resolved_method
             new_doc = dm.create_document_from_array(
                 L.astype(np.float32),
-                name=f"{doc.display_name()} -- Luminance ({mode})",
+                name=f"{doc.display_name()} -- Luminance ({suffix})",
                 is_mono=True,
-                metadata={"step_name":"Extract Luminance", "luma_method":mode}
+                metadata=meta,
             )
             dm.add_document(new_doc)
         except Exception:
-            # safe fallback
             doc.apply_edit(L.astype(np.float32), step_name="Extract Luminance")
 
-
     def _extract_luminance(self, doc=None, preset: dict | None = None):
-        from setiastro.saspro.luminancerecombine import _LUMA_REC709, _LUMA_REC601, _LUMA_REC2020
-        """
-        If doc is None, uses the active subwindow's document.
-        Otherwise, run on the provided doc (for drag-and-drop to a specific view).
-        Creates a new mono document (float32, [0..1]) and spawns a subwindow.
-
-        Preset schema:
-        {
-            "mode": "rec709" | "rec601" | "rec2020" | "max" | "snr" | "equal" | "median",
-            # aliases accepted: method, luma_method, nb_max -> "max", snr_unequal -> "snr"
-        }
-        """
-        # 1) resolve source document
+        from PyQt6.QtWidgets import QMessageBox
+        from PyQt6.QtGui import QIcon
+        from setiastro.saspro.luminancerecombine import compute_luminance, resolve_luma_profile_weights
+
+
         sw = None
         if doc is None:
             sw = self.mdi.activeSubWindow()
@@ -3084,70 +3262,19 @@ class AstroSuiteProMainWindow(
             QMessageBox.information(self, "Extract Luminance", "Luminance extraction requires an RGB image.")
             return
 
-        # 2) normalize to [0,1] float32
-        a = img.astype(np.float32, copy=False)
-        if a.size:
-            m = float(np.nanmax(a))
-            if np.isfinite(m) and m > 1.0:
-                a = a / m
-        a = np.clip(a, 0.0, 1.0)
-
-        # 3) choose luminance method
         p = dict(preset or {})
-        method = str(
+        mode = str(
             p.get("mode",
             p.get("method",
             p.get("luma_method",
                 getattr(self, "luma_method", "rec709"))))
-        ).strip().lower()
-
-        # aliases
-        alias = {
-            "rec.709": "rec709",
-            "rec-709": "rec709",
-            "rgb": "rec709",
-            "k": "rec709",
-            "rec.601": "rec601",
-            "rec-601": "rec601",
-            "rec.2020": "rec2020",
-            "rec-2020": "rec2020",
-            "nb_max": "max",
-            "narrowband": "max",
-            "snr_unequal": "snr",
-            "unequal_noise": "snr",
-        }
-        method = alias.get(method, method)
-
-        # 4) compute luminance per selected method
-        luma_weights = None
-        if method == "rec601":
-            luma_weights = _LUMA_REC601
-            y = np.tensordot(a, _LUMA_REC601, axes=([2],[0]))
-        elif method == "rec2020":
-            luma_weights = _LUMA_REC2020
-            y = np.tensordot(a, _LUMA_REC2020, axes=([2],[0]))
-        elif method == "max":
-            y = a.max(axis=2)
-        elif method == "median":
-            y = np.median(a, axis=2)
-        elif method == "equal":
-            luma_weights = np.array([1/3, 1/3, 1/3], dtype=np.float32)
-            y = a.mean(axis=2)
-        elif method == "snr":
-            from setiastro.saspro.luminancerecombine import _estimate_noise_sigma_per_channel
-            sigma = _estimate_noise_sigma_per_channel(a)
-            w = 1.0 / (sigma[:3]**2 + 1e-12)
-            w = w / w.sum()
-            luma_weights = w.astype(np.float32)
-            y = np.tensordot(a[..., :3], luma_weights, axes=([2],[0]))
-        else:  # "rec709" default
-            method = "rec709"
-            luma_weights = _LUMA_REC709
-            y = np.tensordot(a, _LUMA_REC709, axes=([2],[0]))
-
-        y = np.clip(y.astype(np.float32, copy=False), 0.0, 1.0)
-
-        # 5) metadata & title
+        ).strip()
+
+        resolved_method, w, profile_name = resolve_luma_profile_weights(mode)
+
+        y = compute_luminance(img, method=resolved_method, weights=w)
+
+        # ---- metadata & title ----
         base_meta = {}
         try:
             base_meta = dict(getattr(doc, "metadata", {}) or {})
@@ -3159,13 +3286,16 @@ class AstroSuiteProMainWindow(
             "source": "ExtractLuminance",
             "is_mono": True,
             "bit_depth": "32f",
-            "luma_method": method,
+            "luma_method": resolved_method,
         }
-        if luma_weights is not None:
-            meta["luma_weights"] = np.asarray(luma_weights, dtype=np.float32).tolist()
+        if w is not None:
+            meta["luma_weights"] = np.asarray(w, dtype=np.float32).tolist()
+        if profile_name:
+            meta["luma_profile"] = str(profile_name)
 
         base_title = sw.windowTitle() if sw else (getattr(doc, "title", getattr(doc, "name", "")) or "Untitled")
-        title = f"{base_title} -- Luminance"
+        suffix = f"{profile_name}" if profile_name else resolved_method
+        title = f"{base_title} -- Luminance ({suffix})"
 
         dm = getattr(self, "docman", None)
         if dm is None:
@@ -3193,19 +3323,19 @@ class AstroSuiteProMainWindow(
         except Exception:
             pass
 
-        # ðŸ" Remember for Replay (optional but consistent)
         try:
             remember = getattr(self, "remember_last_headless_command", None) or getattr(self, "_remember_last_headless_command", None)
             if callable(remember):
-                remember("extract_luminance", {"mode": method}, description="Extract Luminance")
+                remember("extract_luminance", {"mode": mode}, description="Extract Luminance")
         except Exception:
             pass
 
         if hasattr(self, "_log"):
-            self._log(f"Extract Luminance ({method}) -> new mono document created.")
+            self._log(f"Extract Luminance ({suffix}) -> new mono document created.")
 
         return new_doc
 
+
     def _subwindow_docs(self):
         docs = []
         for sw in self.mdi.subWindowList():
@@ -4456,6 +4586,48 @@ class AstroSuiteProMainWindow(
         dlg.setAttribute(Qt.WidgetAttribute.WA_DeleteOnClose, True)
         dlg.show()
 
+    def _open_acv_exporter(self):
+        from setiastro.saspro.acv_exporter import AstroCatalogueViewerExporterDialog
+
+        dm = getattr(self, "doc_manager", None) or getattr(self, "docman", None)
+        if dm is None:
+            QMessageBox.information(self, "Astro Catalogue Viewer Exporter", "No document manager available.")
+            return
+
+        sw = self.mdi.activeSubWindow()
+        if not sw:
+            QMessageBox.information(self, "Astro Catalogue Viewer Exporter", "Open an image first.")
+            return
+
+        view = sw.widget()
+        active_doc = None
+
+        # Prefer ROI-aware resolution
+        try:
+            if hasattr(dm, "get_document_for_view"):
+                active_doc = dm.get_document_for_view(view)
+        except Exception:
+            active_doc = None
+
+        # Fallback
+        if active_doc is None:
+            try:
+                active_doc = getattr(view, "document", None)
+            except Exception:
+                active_doc = None
+
+        if active_doc is None or getattr(active_doc, "image", None) is None:
+            QMessageBox.information(self, "Astro Catalogue Viewer Exporter", "No active image.")
+            return
+
+        dlg = AstroCatalogueViewerExporterDialog(self, dm, active_doc)
+        try:
+            dlg.setWindowIcon(QIcon(acv_icon_path))
+        except Exception:
+            pass
+        dlg.show()
+
+
     def _open_linear_fit(self):
         from setiastro.saspro.linear_fit import LinearFitDialog
         dm = getattr(self, "doc_manager", None) or getattr(self, "docman", None)
@@ -4572,12 +4744,6 @@ class AstroSuiteProMainWindow(
         if max_len and len(hist) > max_len:
             del hist[:-max_len]
 
-        # Logging as before
-        try:
-            self._log(f"[Replay] Last action stored: {desc} (command_id={command_id})")
-        except Exception:
-            print(f"[Replay] Last action stored: {desc} (command_id={command_id})")
-
 
 
     def _remember_last_headless_command(self, command_id: str, preset: dict | None = None, description: str = ""):
@@ -4633,17 +4799,6 @@ class AstroSuiteProMainWindow(
         """
         payload = getattr(self, "_last_headless_command", None)
 
-        # DEBUG
-        try:
-            self._log(
-                f"[Replay] replay_last_action_on_subwindow: payload={bool(payload)}, "
-                f"target_sw={id(target_sw) if target_sw else None}"
-            )
-        except Exception:
-            print(
-                f"[Replay] replay_last_action_on_subwindow: payload={bool(payload)}, "
-                f"target_sw={id(target_sw) if target_sw else None}"
-            )
 
         if not payload:
             QMessageBox.information(
@@ -4675,17 +4830,6 @@ class AstroSuiteProMainWindow(
         """
         payload = getattr(self, "_last_headless_command", None) or {}
 
-        # DEBUG
-        try:
-            self._log(
-                f"[Replay] replay_last_action_on_base: payload={bool(payload)}, "
-                f"target_sw={id(target_sw) if target_sw else None}"
-            )
-        except Exception:
-            print(
-                f"[Replay] replay_last_action_on_base: payload={bool(payload)}, "
-                f"target_sw={id(target_sw) if target_sw else None}"
-            )
 
         if not payload:
             QMessageBox.information(
@@ -4711,17 +4855,6 @@ class AstroSuiteProMainWindow(
             QMessageBox.information(self, "Replay Last Action", "No base image to apply the action to.")
             return
 
-        # Small debug about which doc we're hitting
-        try:
-            view = target_sw.widget()
-            cur_doc = getattr(view, "document", None)
-            self._log(
-                f"[Replay] base_doc id={id(base_doc)}, "
-                f"view.document id={id(cur_doc)}, "
-                f"same={base_doc is cur_doc}"
-            )
-        except Exception:
-            pass
 
         # ---- Extract cid + preset from payload (support both old + new schemas) ----
         cid_raw = payload.get("command_id")
@@ -5542,6 +5675,10 @@ class AstroSuiteProMainWindow(
                 "rotate_180": "geom_rotate_180",
                 "geom_rotate_180": "geom_rotate_180",
 
+                "rotate_any": "geom_rotate_any",
+                "rotate_arbitrary": "geom_rotate_any",
+                "geom_rotate_any": "geom_rotate_any",
+
                 "invert": "geom_invert",
                 "geom_invert": "geom_invert",
 
@@ -6542,6 +6679,17 @@ class AstroSuiteProMainWindow(
                 QMessageBox.warning(self, "Rotate 180Â deg", str(e))
             return
 
+        if cid == "geom_rotate_any":
+            try:
+                angle = float(preset.get("angle_deg", preset.get("angle", 0.0)))
+                called = _call_any(["_apply_geom_rot_any_to_doc"], doc, angle_deg=angle)
+                if not called:
+                    raise RuntimeError("No rotate-any apply method found")
+                self._log(f"Rotate ({angle:g}°) applied to '{target_sw.windowTitle()}'")
+            except Exception as e:
+                QMessageBox.warning(self, "Rotate...", str(e))
+            return
+
         if cid == "geom_rescale":
             try:
                 factor = float(preset.get("factor", 1.0))
@@ -7347,7 +7495,7 @@ class AstroSuiteProMainWindow(
             self._search_dock = None
 
         # --- Right-side mini dock with the search box ---
-        self._search_dock = QDockWidget("Command Search", self)
+        self._search_dock = QDockWidget(self.tr("Command Search"), self)
         self._search_dock.setObjectName("CommandSearchDock")
         # âœ... Allow moving/closing like other panels
         self._search_dock.setAllowedAreas(
@@ -7562,7 +7710,7 @@ class AstroSuiteProMainWindow(
             except Exception:
                 pass
 
-            try: self.update_undo_redo_action_labels()
+            try: self._schedule_undo_redo_label_refresh()
             except Exception as e:
                 import logging
                 logging.debug(f"Exception suppressed: {type(e).__name__}: {e}")
@@ -7617,12 +7765,33 @@ class AstroSuiteProMainWindow(
                 pass
 
     def _pretty_title(self, doc, *, linked: bool | None = None) -> str:
-        name = getattr(doc, "display_name", lambda: "Untitled")()
-        name = name.replace("[LINK] ", "").strip()
+        md = (getattr(doc, "metadata", {}) or {})
+
+        # ✅ 1) Prefer explicit display_name (what duplicate/rename intends)
+        name = (md.get("display_name") or "").strip()
+
+        # 2) Fallback to file_path (but only if display_name is missing)
+        if not name:
+            fp = (md.get("file_path") or "").strip()
+            if fp:
+                name = os.path.splitext(os.path.basename(fp))[0]
+
+        # 3) Fallback to doc.display_name()
+        if not name:
+            name = getattr(doc, "display_name", lambda: "Untitled")()
+            name = (name or "Untitled").replace("[LINK] ", "").strip()
+
+            # If it looks like a filename, drop extension
+            base, ext = os.path.splitext(name)
+            if ext and len(ext) <= 10:
+                name = base
+
+        # linked marker logic
         if linked is None:
-            linked = hasattr(doc, "_parent_doc")  # ROI proxy -> linked
+            linked = hasattr(doc, "_parent_doc")
         return f"[LINK] {name}" if linked else name
 
+
     def _build_subwindow_title_for_doc(self, doc) -> str:
         """
         Build a unique, human-friendly title for a QMdiSubWindow
@@ -7690,6 +7859,34 @@ class AstroSuiteProMainWindow(
                 return cand
             n += 1
 
+    
+    def _doc_window_title(self, doc) -> str:
+        md = getattr(doc, "metadata", {}) or {}
+
+        t = (md.get("display_name") or "").strip()
+        if not t:
+            try:
+                t = (doc.display_name() or "").strip()
+            except Exception:
+                t = ""
+
+        if not t:
+            fp = (md.get("file_path") or "").strip()
+            if fp:
+                t = os.path.splitext(os.path.basename(fp))[0]   # ✅ strip ext here too
+
+        t = t or "Untitled"
+
+        # strip glyphs etc
+        try:
+            t = _strip_ui_decorations(t)
+        except Exception:
+            pass
+
+        # ✅ ALWAYS strip filename-like extension at the very end
+        t = _strip_filename_ext(t)
+
+        return t
 
     def _spawn_subwindow_for(self, doc, *, force_new: bool = False):
         """
@@ -7793,10 +7990,7 @@ class AstroSuiteProMainWindow(
         if replay_sig is not None:
             try:
                 replay_sig.connect(self._on_view_replay_last_requested)
-                try:
-                    self._log(f"[Replay] Connected {sig_name_used} for view id={id(view)}")
-                except Exception:
-                    print(f"[Replay] Connected {sig_name_used} for view id={id(view)}")
+
             except Exception as e:
                 try:
                     self._log(f"[Replay] FAILED to connect {sig_name_used} for view id={id(view)}: {e}")
@@ -7804,7 +7998,8 @@ class AstroSuiteProMainWindow(
                     print(f"[Replay] FAILED to connect {sig_name_used} for view id={id(view)}: {e}")
 
         self._hook_preview_awareness(view)
-        base_title = self._pretty_title(doc, linked=False)
+
+        base_title  = self._doc_window_title(doc)      # ✅ use metadata display_name
         final_title = self._unique_window_title(base_title)
 
         # -- 6) Add subwindow and set chrome
@@ -7828,7 +8023,8 @@ class AstroSuiteProMainWindow(
         # We target ~60% of the viewport height, clamped to sane bounds.
         # -------------------------------------------------------------------------
         vp = self.mdi.viewport()
-        area = vp.rect() if vp else self.mdi.rect()
+        # Use viewport geometry in MDI coordinates (NOT viewport-local rect)
+        area = vp.geometry() if vp else self.mdi.contentsRect()
         
         # Determine aspect ratio
         img_w = img_h = None
@@ -7871,7 +8067,7 @@ class AstroSuiteProMainWindow(
         # Smart Cascade: Position relative to the *currently active* window
         # (before we make the new one active).
         # -------------------------------------------------------------------------
-        new_x, new_y = 0, 0
+        new_x, new_y = area.left(), area.top()
         
         # Get dominant/active window *before* we activate the new one
         active = self.mdi.activeSubWindow()
@@ -7894,15 +8090,13 @@ class AstroSuiteProMainWindow(
             except Exception:
                 pass
 
-        # Bounds check: don't let it drift completely off-screen
-        # (allow valid title bar to be visible at least)
-        if (new_x + target_w > area.width() + 50) or (new_y + 50 > area.height()):
-            new_x = 0
-            new_y = 0
-        
-        # Clamp to 0 if negative for some reason
-        new_x = max(0, new_x)
-        new_y = max(0, new_y)
+        # Bounds check: keep titlebar visible and stay inside viewport
+        if (new_x + target_w > area.right() - 10) or (new_y + 40 > area.bottom() - 10):
+            new_x = area.left()
+            new_y = area.top()
+
+        new_x = max(area.left(), new_x)
+        new_y = max(area.top(), new_y)
 
         sw.move(new_x, new_y)
 
@@ -7997,6 +8191,11 @@ class AstroSuiteProMainWindow(
         except Exception:
             pass
 
+        try:
+            self._fix_mdi_titlebar_emboss("#dcdcdc" if self._theme_mode()=="dark" else "#f0f0f0")
+        except Exception:
+            pass
+
         # -- 11) If this is the first window and it's an image, mimic "Cascade Views"
         try:
             if first_window and not is_table:
@@ -8050,7 +8249,7 @@ class AstroSuiteProMainWindow(
         # If no subwindows remain, clear all "active doc" UI bits, including header
         if not self.mdi.subWindowList():
             self.currentDocumentChanged.emit(None)   # drives HeaderViewerDock.set_document(None)
-            self.update_undo_redo_action_labels()
+            self._schedule_undo_redo_label_refresh()
             self._hdr_refresh_timer.start(0)       # belt-and-suspenders for manual widgets
             # If your dock has its own set_document, call it explicitly too
             hv = getattr(self, "header_viewer", None)
@@ -8091,25 +8290,57 @@ class AstroSuiteProMainWindow(
             "autostretch_target": float(getattr(source_view, "autostretch_target", 0.25)),
         }
 
-        # 2) New name (strip UI decorations if any)
-        base_name = ""
+        # 2) New name (normalized: NO decorators like 🔗■●◆▲▪▫•◼◻◾◽)
         try:
-            base_name = base_doc.display_name() or "Untitled"
+            base_name = self._doc_window_title(base_doc)  # might include decorations
         except Exception:
             base_name = "Untitled"
 
+        # Normalize it so uniqueness checks don't miss decorated titles
         try:
-            base_name = _strip_ui_decorations(base_name)
+            base_name = normalize_doc_title(base_name)
+        except Exception:
+            base_name = (base_name or "Untitled").strip()
+
+        # Build a set of existing document names (normalized)
+        existing = set()
+        try:
+            dm = getattr(self, "doc_manager", None) or getattr(self, "docman", None)
+            docs = []
+
+            # Prefer an official accessor if you have one
+            if dm is not None:
+                if hasattr(dm, "documents"):
+                    docs = list(dm.documents())
+                elif hasattr(dm, "_docs"):
+                    docs = list(dm._docs)
+
+            for d in docs:
+                try:
+                    dn = ""
+                    md = getattr(d, "metadata", {}) or {}
+                    dn = (md.get("display_name") or "").strip() or (d.display_name() or "").strip()
+                    dn = normalize_doc_title(dn)
+                    if dn:
+                        existing.add(dn)
+                except Exception:
+                    pass
         except Exception:
-            # minimal fallback: remove our known prefix/glyphs
-            while len(base_name) >= 2 and base_name[1] == " " and base_name[0] in "â- â--â--†â-²â-ªâ-«â€¢â--¼â--»â--¾â--½":
-                base_name = base_name[2:]
-            if base_name.startswith("Active View: "):
-                base_name = base_name[len("Active View: "):]
+            pass
+
+        # Pick a unique duplicate name: base_duplicate, base_duplicate2, ...
+        candidate = f"{base_name}_duplicate"
+        if candidate in existing:
+            n = 2
+            while True:
+                cand = f"{base_name}_duplicate{n}"
+                if cand not in existing:
+                    candidate = cand
+                    break
+                n += 1
 
         # 3) Duplicate the *base* document (not the ROI proxy)
-        #    NOTE: your project uses `self.docman` elsewhere for duplication.
-        new_doc = self.docman.duplicate_document(base_doc, new_name=f"{base_name}_duplicate")
+        new_doc = self.docman.duplicate_document(base_doc, new_name=candidate)
         print(f"  Duplicated document ID {id(base_doc)} -> {id(new_doc)}")
 
         # 4) Ensure the duplicate starts mask-free (so we don't inherit mask UI state)
@@ -8259,26 +8490,21 @@ class AstroSuiteProMainWindow(
 
 
     def _activate_or_open_from_explorer(self, item):
-        doc = item.data(Qt.ItemDataRole.UserRole)
-        base = self._normalize_base_doc(doc)
-
-        # 1) Try to focus an existing view for this base
-        for sw in self.mdi.subWindowList():
-            w = sw.widget()
-            if getattr(w, "base_document", None) is base:
-                try:
-                    sw.show(); w.show()
-                    st = sw.windowState()
-                    if st & Qt.WindowState.WindowMinimized:
-                        sw.setWindowState(st & ~Qt.WindowState.WindowMinimized)
-                    self.mdi.setActiveSubWindow(sw)
-                    sw.raise_()
-                except Exception:
-                    pass
-                return
-
-        # 2) None exists -> open one
-        self._open_subwindow_for_added_doc(base)
+        doc = item.data(0, Qt.ItemDataRole.UserRole)
+        if doc is None:
+            return
+        # you already have logic for this; typically:
+        sw = self._find_subwindow_for_doc(doc)
+        if sw:
+            self.mdi.setActiveSubWindow(sw)
+            sw.show()
+            sw.raise_()
+            return
+        # else open it (if your app supports opening closed docs, otherwise no-op)
+        try:
+            self._open_subwindow_for_added_doc(doc)
+        except Exception:
+            pass
 
     def _set_linked_stretch_from_action(self, checked: bool):
         # persist as the default for *new* views
@@ -8392,16 +8618,20 @@ class AstroSuiteProMainWindow(
 
         # Misc UI refreshes (guarded)
         try:
-            self.update_undo_redo_action_labels()
+            self._schedule_undo_redo_label_refresh()
         except Exception:
             pass
+        #try:
+        #    if hasattr(self, "_hdr_refresh_timer") and self._hdr_refresh_timer is not None:
+        #        self._hdr_refresh_timer.start(0)
+        #except Exception:
+        #    pass
         try:
-            if hasattr(self, "_hdr_refresh_timer") and self._hdr_refresh_timer is not None:
-                self._hdr_refresh_timer.start(0)
+            self._refresh_mask_action_states()
         except Exception:
             pass
         try:
-            self._refresh_mask_action_states()
+            self._fix_mdi_titlebar_emboss("#dcdcdc" if self._theme_mode()=="dark" else "#f0f0f0")
         except Exception:
             pass