setiastrosuitepro 1.6.12__py3-none-any.whl → 1.7.3__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, QElapsedTimer
+    QPropertyAnimation, QEasingCurve, QElapsedTimer, QPoint
 )
 
 from PyQt6.QtNetwork import QNetworkAccessManager, QNetworkRequest, QNetworkReply
@@ -193,10 +193,10 @@ from setiastro.saspro.resources import (
     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,
+    colorwheel_path, font_path, csv_icon_path, spinner_path, wims_path, narrowbandnormalization_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
+    functionbundles_path, viewbundles_path, selectivecolor_path, rgbalign_path, planetarystacker_path,
+    background_path, script_icon_path, planetprojection_path,
 )
 
 import faulthandler
@@ -435,7 +435,23 @@ class AstroSuiteProMainWindow(
                  version: str = "dev", build_timestamp: str = "dev"):
         super().__init__(parent)
         # Prevent white flash: start strictly transparent and force dark bg
-        self.setWindowOpacity(0.0)
+        from PyQt6.QtGui import QGuiApplication
+
+        def _is_wayland() -> bool:
+            try:
+                plat = (QGuiApplication.platformName() or "").lower()
+                if "wayland" in plat:
+                    return True
+            except Exception:
+                pass
+            # fallback env checks
+            return bool(os.environ.get("WAYLAND_DISPLAY")) and not bool(os.environ.get("DISPLAY"))
+
+        # Prevent white flash: start strictly transparent and force dark bg
+        if not _is_wayland():
+            self.setWindowOpacity(0.0)
+        self.setStyleSheet("QMainWindow { background-color: #0F0F19; }")
+
         self.setStyleSheet("QMainWindow { background-color: #0F0F19; }")
         #self._stall = UiStallDetector(self, interval_ms=50, threshold_ms=250)
         #self._stall.start()
@@ -604,7 +620,10 @@ class AstroSuiteProMainWindow(
         self.docman.documentAdded.connect(self._on_document_added)
         self.mdi.viewStateDropped.connect(self._on_mdi_viewstate_drop)
         self.mdi.linkViewDropped.connect(self._on_linkview_drop)
-
+        self._mdi_open_batch = 0
+        self._mdi_place_mode = "cascade"   # or "tile"
+        self._mdi_next_pos = None          # QPoint in MDI coords
+        self._mdi_cascade_step = 28
         self.doc_manager.set_mdi_area(self.mdi)
         # Coalesce undo/redo label refreshes
         self._undo_redo_refresh_pending = False
@@ -3905,6 +3924,19 @@ class AstroSuiteProMainWindow(
 
         dlg.show()
 
+    def _open_narrowband_normalization_tool(self):
+        # Correct module import
+        from setiastro.saspro.narrowband_normalization import NarrowbandNormalization
+
+        w = NarrowbandNormalization(doc_manager=self.docman, parent=self)
+        w.setAttribute(Qt.WidgetAttribute.WA_DeleteOnClose, True)
+        w.setWindowTitle("Narrowband Normalization")
+        try:
+            w.setWindowIcon(QIcon(narrowbandnormalization_path))
+        except Exception:
+            pass
+        w.show()
+
     def _open_ppp_tool(self):
         from setiastro.saspro.perfect_palette_picker import PerfectPalettePicker
         w = PerfectPalettePicker(doc_manager=self.docman)  # parent gives access to _spawn_subwindow_for
@@ -4256,6 +4288,37 @@ class AstroSuiteProMainWindow(
         dlg.setWindowIcon(QIcon(livestacking_path))
         dlg.show()
 
+    def _open_planetary_stacker(self):
+        # import locally to avoid startup cost / circular imports
+        from setiastro.saspro.serviewer import SERViewer
+        dlg = SERViewer(self)
+        dlg.setWindowFlag(Qt.WindowType.Window, True)
+        dlg.setWindowIcon(QIcon(planetarystacker_path))        
+        dlg.show()
+
+    def _open_planet_projection(self):
+        from setiastro.saspro.planetprojection import PlanetProjectionDialog
+        sw = self.mdi.activeSubWindow()
+        if not sw:
+            QMessageBox.information(self, "No image", "Open an image first.")
+            return
+
+        view = sw.widget()
+        doc = self.doc_manager.get_document_for_view(view)
+
+        dlg = PlanetProjectionDialog(self, doc)
+        try:
+            # dlg.setWindowIcon(QIcon(planetprojection_path))
+            pass
+        except Exception:
+            pass
+        dlg.resize(980, 720)
+        dlg.setWindowFlag(Qt.WindowType.Window, True)
+        dlg.setWindowIcon(QIcon(planetprojection_path))         
+        dlg.show()
+        self._log("Functions: opened Planet Projection.")
+
+
     def _open_stacking_suite(self):
         # Reuse if we already have one
         dlg = getattr(self, "_stacking_suite", None)
@@ -4299,6 +4362,202 @@ class AstroSuiteProMainWindow(
             except Exception:
                 pass
 
+    def _convert_mono_to_rgb_active(self):
+        """
+        Convert active mono document to RGB by duplicating the channel.
+        Updates the active document in-place (undoable).
+        """
+        dm = getattr(self, "docman", None)
+        if dm is None:
+            return
+
+        try:
+            doc = dm.get_active_document()
+        except Exception:
+            doc = None
+        if doc is None:
+            return
+
+        img = getattr(doc, "image", None)
+        if img is None:
+            return
+
+        import numpy as np
+
+        x = np.asarray(img)
+
+        # Already RGB?
+        if x.ndim == 3 and x.shape[-1] == 3:
+            try:
+                name = getattr(doc, "display_name", lambda: None)() or getattr(doc, "name", "") or "Active"
+            except Exception:
+                name = "Active"
+            if hasattr(self, "_log"):
+                self._log(f"Mono → RGB: '{name}' is already RGB (shape={getattr(x,'shape',None)}).")
+            return
+
+        # Determine what we're converting FROM
+        src_desc = "unknown"
+        if x.ndim == 2:
+            mono = x
+            src_desc = "mono (H×W)"
+        elif x.ndim == 3 and x.shape[-1] == 1:
+            mono = x[..., 0]
+            src_desc = "mono (H×W×1)"
+        else:
+            # Unknown format (e.g., multi-channel >3)
+            try:
+                name = getattr(doc, "display_name", lambda: None)() or getattr(doc, "name", "") or "Active"
+            except Exception:
+                name = "Active"
+            if hasattr(self, "_log"):
+                self._log(f"Mono → RGB: '{name}' not convertible (shape={getattr(x,'shape',None)}).")
+            return
+
+        before_shape = getattr(x, "shape", None)
+        before_dtype = getattr(x, "dtype", None)
+
+        mono = mono.astype(np.float32, copy=False)
+        rgb = np.stack([mono, mono, mono], axis=-1)
+
+        # metadata: preserve existing, but force "not mono"
+        try:
+            md = dict(getattr(doc, "metadata", None) or {})
+        except Exception:
+            md = {}
+
+        md["is_mono"] = False
+        md["color_model"] = "RGB"
+        md["channels"] = 3
+        md["source"] = (md.get("source") or "Edit")
+
+        # If you track op params for history explorer
+        md["__op_params__"] = {
+            "op": "mono_to_rgb",
+            "mode": "triplicate",
+            "from": str(src_desc),
+            "from_shape": tuple(before_shape) if before_shape is not None else None,
+            "to_shape": tuple(rgb.shape),
+        }
+
+        # name for logging
+        try:
+            name = getattr(doc, "display_name", lambda: None)() or getattr(doc, "name", "") or "Active"
+        except Exception:
+            name = "Active"
+
+        try:
+            dm.update_active_document(
+                rgb,
+                metadata=md,
+                step_name="Mono → RGB",
+                doc=doc,  # explicit is safer
+            )
+
+            if hasattr(self, "_log"):
+                self._log(
+                    f"Mono → RGB: '{name}' converted {src_desc} "
+                    f"(shape={before_shape}, dtype={before_dtype}) → "
+                    f"RGB (shape={rgb.shape}, dtype={rgb.dtype})."
+                )
+
+        except Exception:
+            import traceback
+            try:
+                from PyQt6.QtWidgets import QMessageBox
+                QMessageBox.critical(self, "Mono → RGB", traceback.format_exc())
+            except Exception:
+                pass
+
+    def _swap_rb_active(self):
+        """
+        Swap R and B channels in the active RGB document (undoable).
+        Intended for debayer/channel-order mismatches.
+        """
+        dm = getattr(self, "docman", None)
+        if dm is None:
+            return
+
+        try:
+            doc = dm.get_active_document()
+        except Exception:
+            doc = None
+        if doc is None:
+            return
+
+        img = getattr(doc, "image", None)
+        if img is None:
+            return
+
+        import numpy as np
+        x = np.asarray(img)
+
+        # Must be RGB
+        if not (x.ndim == 3 and x.shape[-1] == 3):
+            try:
+                name = getattr(doc, "display_name", lambda: None)() or getattr(doc, "name", "") or "Active"
+            except Exception:
+                name = "Active"
+
+            if hasattr(self, "_log"):
+                self._log(f"Swap R/B: '{name}' is not RGB (shape={getattr(x,'shape',None)}).")
+            return
+
+        before_shape = x.shape
+        before_dtype = x.dtype
+
+        # swap channels without changing dtype
+        # (copy is safest so we don't mutate shared views)
+        out = x.copy()
+        out[..., 0], out[..., 2] = x[..., 2], x[..., 0]
+
+        # metadata: preserve existing, but annotate operation
+        try:
+            md = dict(getattr(doc, "metadata", None) or {})
+        except Exception:
+            md = {}
+
+        md["color_model"] = md.get("color_model", "RGB")
+        md["channels"] = 3
+        md["is_mono"] = False
+        md["source"] = (md.get("source") or "Edit")
+
+        # If you track op params for history explorer
+        md["__op_params__"] = {
+            "op": "swap_rb",
+            "from_shape": tuple(before_shape),
+            "to_shape": tuple(out.shape),
+            "dtype": str(before_dtype),
+        }
+
+        try:
+            name = getattr(doc, "display_name", lambda: None)() or getattr(doc, "name", "") or "Active"
+        except Exception:
+            name = "Active"
+
+        try:
+            dm.update_active_document(
+                out,
+                metadata=md,
+                step_name="Swap R ↔ B",
+                doc=doc,
+            )
+
+            if hasattr(self, "_log"):
+                self._log(
+                    f"Swap R/B: '{name}' swapped channels "
+                    f"(shape={before_shape}, dtype={before_dtype})."
+                )
+
+        except Exception:
+            import traceback
+            try:
+                from PyQt6.QtWidgets import QMessageBox
+                QMessageBox.critical(self, "Swap R/B", traceback.format_exc())
+            except Exception:
+                pass
+
+
     def _on_stackingsuite_relaunch(self, old_dir: str, new_dir: str):
         # Optional: respond to dialog's relaunch request
         try:
@@ -4399,9 +4658,16 @@ class AstroSuiteProMainWindow(
         # Create a callback to set the image back to the document
         def set_image_callback(image_data, step_name):
             """Apply the result image back to the active document."""
-            if active_doc and hasattr(active_doc, "set_image"):
+            if active_doc and hasattr(active_doc, "apply_edit"):
                 print(f"[AstroSpike] Setting image back to document, shape: {image_data.shape}")
-                # Pass metadata as empty dict and step_name separately
+                # Use apply_edit for proper undo/redo integration
+                meta = {
+                    "step_name": step_name,
+                    "astrospike": True
+                }
+                active_doc.apply_edit(image_data.astype(np.float32, copy=False), metadata=meta, step_name=step_name)
+            elif active_doc and hasattr(active_doc, "set_image"):
+                print(f"[AstroSpike] Setting image via set_image, shape: {image_data.shape}")
                 active_doc.set_image(image_data, metadata={}, step_name=step_name)
             elif active_doc and hasattr(active_doc, "image"):
                 print(f"[AstroSpike] Setting image directly, shape: {image_data.shape}")
@@ -7888,6 +8154,43 @@ class AstroSuiteProMainWindow(
 
         return t
 
+    def _mdi_begin_open_batch(self, mode: str = "cascade"):
+        self._mdi_open_batch += 1
+        self._mdi_place_mode = mode or "cascade"
+        self._mdi_next_pos = None
+
+    def _mdi_end_open_batch(self):
+        self._mdi_open_batch = max(0, self._mdi_open_batch - 1)
+        if self._mdi_open_batch == 0:
+            self._mdi_next_pos = None
+
+    def _mdi_compute_initial_pos(self) -> QPoint:
+        area = (self.mdi.viewport().geometry() if self.mdi.viewport() else self.mdi.contentsRect())
+        # Put first window a bit inset so titlebars don’t clip
+        return QPoint(area.left() + 18, area.top() + 18)
+
+    def _mdi_place_subwindow(self, sw, target_w: int, target_h: int):
+        """Deterministic placement. Uses a stable cursor during batch opens."""
+        vp = self.mdi.viewport()
+        area = vp.geometry() if vp else self.mdi.contentsRect()
+
+        if self._mdi_next_pos is None:
+            self._mdi_next_pos = self._mdi_compute_initial_pos()
+
+        x = self._mdi_next_pos.x()
+        y = self._mdi_next_pos.y()
+
+        # keep inside viewport; reset when we hit edge
+        if (x + target_w > area.right() - 10) or (y + 40 > area.bottom() - 10):
+            x = area.left() + 18
+            y = area.top() + 18
+
+        sw.move(x, y)
+
+        # advance cursor
+        step = int(self._mdi_cascade_step)
+        self._mdi_next_pos = QPoint(x + step, y + step)
+
     def _spawn_subwindow_for(self, doc, *, force_new: bool = False):
         """
         Open a subwindow for `doc`. If one already exists and force_new=False,
@@ -8061,52 +8364,22 @@ class AstroSuiteProMainWindow(
         target_h = max(200, target_h)
 
         sw.resize(target_w, target_h)
-        sw.showNormal()  # CRITICAL: clears any "maximized" flag from previous active window
+        sw.showNormal()  # clears any "maximized" flag from previous active window
 
-        # -------------------------------------------------------------------------
-        # Smart Cascade: Position relative to the *currently active* window
-        # (before we make the new one active).
-        # -------------------------------------------------------------------------
-        new_x, new_y = area.left(), area.top()
-        
-        # Get dominant/active window *before* we activate the new one
-        active = self.mdi.activeSubWindow()
-        if active and active.isVisible() and not (active.windowState() & Qt.WindowState.WindowMinimized):
-            # Cascade from the active window
-            geo = active.geometry()
-            new_x = geo.x() + 30
-            new_y = geo.y() + 30
-        else:
-            # Fallback: try to find the "last added" visible window to cascade from
-            # (useful if active is None but windows exist)
-            try:
-                subs = [s for s in self.mdi.subWindowList() if s.isVisible() and s is not sw]
-                if subs:
-                    # simplistic "last created" might be at end of list
-                    last = subs[-1]
-                    geo = last.geometry()
-                    new_x = geo.x() + 30
-                    new_y = geo.y() + 30
+        # Deterministic placement (batch-aware)
+        try:
+            self._mdi_place_subwindow(sw, target_w, target_h)
+        except Exception:
+            # absolute fallback: top-left-ish
+            try:
+                sw.move(area.left() + 18, area.top() + 18)
             except Exception:
                 pass
 
-        # 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)
-
-        # ❌ removed the "fill MDI viewport" block - we *don't* want full-monitor first window
-
         # Show / activate
         sw.show()
         sw.raise_()
         self.mdi.setActiveSubWindow(sw)
-        # (no second setWindowTitle() here)
 
         # Optional minimize/restore interceptor
         if hasattr(self, "_minimize_interceptor"):
@@ -8887,6 +9160,13 @@ class AstroSuiteProMainWindow(
 
         super().keyPressEvent(event)
 
+    def _open_texture_clarity(self):
+        try:
+            from setiastro.saspro.texture_clarity import open_texture_clarity_dialog
+            open_texture_clarity_dialog(self)
+        except Exception as e:
+            print(f"Error opening Texture & Clarity: {e}")
+
     def _update_usage_stats(self):
         try:
             now = time.time()

setiastro/saspro/gui/mixins/file_mixin.py

@@ -7,7 +7,7 @@ import os
 from typing import TYPE_CHECKING
 
 from PyQt6.QtCore import Qt
-from PyQt6.QtWidgets import QFileDialog, QMessageBox, QProgressDialog
+from PyQt6.QtWidgets import QFileDialog, QMessageBox, QProgressDialog, QApplication
 
 if TYPE_CHECKING:
     pass
@@ -85,7 +85,6 @@ class FileMixin:
         self._save_recent_lists()
         if hasattr(self, "_rebuild_recent_menus"):
             self._rebuild_recent_menus()
-# Extracted FILE methods
 
     def open_files(self):
         # One-stop "All Supported" plus focused groups the user can switch to
@@ -114,21 +113,41 @@ class FileMixin:
         except Exception:
             pass
 
-        # open each path (doc_manager should emit documentAdded; no manual spawn)
-        for p in paths:
-            try:
-                doc = self.docman.open_path(p)   # this emits documentAdded
-                self._log(f"Opened: {p}")
-                self._add_recent_image(p)        # âœ... track in MRU
-                
-                # Increment statistics
+        # ---- BEGIN batch open (stable placement) ----
+        try:
+            self._mdi_begin_open_batch(mode="cascade")
+        except Exception:
+            pass
+
+        QApplication.setOverrideCursor(Qt.CursorShape.WaitCursor)
+        try:
+            # open each path (doc_manager should emit documentAdded; no manual spawn)
+            for p in paths:
                 try:
-                    count = self.settings.value("stats/opened_images_count", 0, type=int)
-                    self.settings.setValue("stats/opened_images_count", count + 1)
-                except Exception:
-                    pass
-            except Exception as e:
-                QMessageBox.warning(self, self.tr("Open failed"), f"{p}\n\n{e}")
+                    _ = self.docman.open_path(p)   # emits documentAdded; spawn will happen
+                    self._log(f"Opened: {p}")
+                    self._add_recent_image(p)      # track MRU
+
+                    # Increment statistics
+                    try:
+                        count = self.settings.value("stats/opened_images_count", 0, type=int)
+                        self.settings.setValue("stats/opened_images_count", count + 1)
+                    except Exception:
+                        pass
+
+                    # Let Qt paint newly spawned subwindows as we go
+                    QApplication.processEvents()
+
+                except Exception as e:
+                    QMessageBox.warning(self, self.tr("Open failed"), f"{p}\n\n{e}")
+                    QApplication.processEvents()
+        finally:
+            QApplication.restoreOverrideCursor()
+            try:
+                self._mdi_end_open_batch()
+            except Exception:
+                pass
+
 
     def save_active(self):
         from setiastro.saspro.main_helpers import (
@@ -197,14 +216,18 @@ class FileMixin:
         # --- Bit depth selection ----------------------------------------
         from setiastro.saspro.save_options import SaveOptionsDialog
         current_bd = doc.metadata.get("bit_depth")
-        dlg = SaveOptionsDialog(self, ext_norm, current_bd)
+        current_jq = (doc.metadata or {}).get("jpeg_quality", None)
+
+        dlg = SaveOptionsDialog(self, ext_norm, current_bd, current_jpeg_quality=current_jq)
         if dlg.exec() != dlg.DialogCode.Accepted:
             return
+
         chosen_bd = dlg.selected_bit_depth()
+        chosen_jq = dlg.selected_jpeg_quality()
 
         # --- Save & remember folder ----------------------------------------
         try:
-            self.docman.save_document(doc, path, bit_depth_override=chosen_bd)
+            self.docman.save_document(doc, path, bit_depth_override=chosen_bd, jpeg_quality=chosen_jq)
             self._log(f"Saved: {path} ({chosen_bd})")
             self.settings.setValue("paths/last_save_dir", os.path.dirname(path))
         except Exception as e:

setiastro/saspro/gui/mixins/menu_mixin.py

@@ -121,6 +121,10 @@ class MenuMixin:
         m_edit = mb.addMenu(self.tr("&Edit"))
         m_edit.addAction(self.act_undo)
         m_edit.addAction(self.act_redo)
+        m_edit.addSeparator()
+        m_edit.addAction(self.act_mono_to_rgb)
+        m_edit.addAction(self.act_swap_rb)  
+
 
         # Functions
         m_fn = mb.addMenu(self.tr("&Functions"))
@@ -151,6 +155,7 @@ class MenuMixin:
         m_fn.addAction(self.act_signature)
         m_fn.addAction(self.act_star_stretch)
         m_fn.addAction(self.act_stat_stretch)
+        m_fn.addAction(self.act_texture_clarity)
         m_fn.addAction(self.act_wavescale_de)
         m_fn.addAction(self.act_wavescale_hdr)
         m_fn.addAction(self.act_white_balance)
@@ -170,8 +175,10 @@ class MenuMixin:
         m_tools.addAction(self.act_freqsep)
         m_tools.addAction(self.act_image_combine)
         m_tools.addAction(self.act_multiscale_decomp)
+        m_tools.addAction(self.act_narrowband_normalization)
         m_tools.addAction(self.act_nbtorgb)
         m_tools.addAction(self.act_ppp)
+        
         m_tools.addAction(self.act_selective_color)
         m_tools.addSeparator()
         m_tools.addAction(self.act_view_bundles) 
@@ -200,6 +207,8 @@ class MenuMixin:
         m_star.addAction(self.act_isophote)
         m_star.addAction(self.act_live_stacking)
         m_star.addAction(self.act_mosaic_master)
+        m_star.addAction(self.act_planet_projection)
+        m_star.addAction(self.act_planetary_stacker)
         m_star.addAction(self.act_plate_solve)
         m_star.addAction(self.act_psf_viewer)
         m_star.addAction(self.act_rgb_align)