setiastrosuitepro 1.7.0.post2__tar.gz → 1.7.2.post1__tar.gz

{setiastrosuitepro-1.7.0.post2 → setiastrosuitepro-1.7.2.post1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: setiastrosuitepro
-Version: 1.7.0.post2
+Version: 1.7.2.post1
 Summary: Seti Astro Suite Pro - Advanced astrophotography toolkit for image calibration, stacking, registration, photometry, and visualization
 License: GPL-3.0
 License-File: LICENSE
@@ -35,8 +35,9 @@ Requires-Dist: numba
 Requires-Dist: numpy
 Requires-Dist: oktopus
 Requires-Dist: onnx
-Requires-Dist: onnxruntime ; sys_platform != "win32"
+Requires-Dist: onnxruntime ; sys_platform != "linux" and sys_platform != "win32"
 Requires-Dist: onnxruntime-directml ; sys_platform == "win32"
+Requires-Dist: onnxruntime-gpu ; sys_platform == "linux"
 Requires-Dist: opencv-python-headless
 Requires-Dist: pandas
 Requires-Dist: photutils

{setiastrosuitepro-1.7.0.post2 → setiastrosuitepro-1.7.2.post1}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "setiastrosuitepro"
-version = "1.7.0.post2"
+version = "1.7.2.post1"
 description = "Seti Astro Suite Pro - Advanced astrophotography toolkit for image calibration, stacking, registration, photometry, and visualization"
 authors = ["Franklin Marek <info@setiastro.com>"]
 readme = "README.md"
@@ -55,15 +55,14 @@ jplephem = "*"
 # performance
 numba = "*"
 
-# neural net
+#neural net
 onnx = "*"
-
-# Choose ONE runtime per platform.
-# - Windows: DirectML (GPU on NVIDIA/AMD/Intel without CUDA hassles)
-onnxruntime-directml = {version="*", markers="sys_platform == 'win32'"}
-
-# - Non-Windows: CPU runtime
-onnxruntime = {version="*", markers="sys_platform != 'win32'"}
+# Use GPU version on Linux, DirectML on Windows, CPU version on macOS/others
+# Note: onnxruntime-gpu includes CUDA support and also provides CPUExecutionProvider as fallback
+# You cannot install both onnxruntime and onnxruntime-gpu simultaneously
+"onnxruntime-gpu" = {version = "*", markers = "sys_platform == 'linux'"}
+"onnxruntime-directml" = {version = "*", markers = "sys_platform == 'win32'"}
+onnxruntime = {version = "*", markers = "sys_platform != 'linux' and sys_platform != 'win32'"}
 
 # image formats & camera raw
 xisf = "*"

setiastrosuitepro-1.7.2.post1/src/setiastro/images/TextureClarity.svg

@@ -0,0 +1,56 @@
+<svg width="500" height="500" viewBox="0 0 500 500" xmlns="http://www.w3.org/2000/svg">
+  <defs>
+    <linearGradient id="skyGradient" x1="0%" y1="0%" x2="0%" y2="100%">
+      <stop offset="0%" style="stop-color:#0d0221;stop-opacity:1" />
+      <stop offset="100%" style="stop-color:#2a0e66;stop-opacity:1" />
+    </linearGradient>
+    <linearGradient id="sunGradient" x1="0%" y1="0%" x2="0%" y2="100%">
+      <stop offset="0%" style="stop-color:#ff9a00;stop-opacity:1" />
+      <stop offset="40%" style="stop-color:#ff0055;stop-opacity:1" />
+      <stop offset="100%" style="stop-color:#9900ff;stop-opacity:1" />
+    </linearGradient>
+    <linearGradient id="textGradient" x1="0%" y1="0%" x2="100%" y2="100%">
+      <stop offset="0%" style="stop-color:#00ffff;stop-opacity:1" />
+      <stop offset="100%" style="stop-color:#ff00ff;stop-opacity:1" />
+    </linearGradient>
+    <filter id="neonGlow" x="-50%" y="-50%" width="200%" height="200%">
+      <feGaussianBlur stdDeviation="3.0" result="coloredBlur"/>
+      <feMerge>
+        <feMergeNode in="coloredBlur"/>
+        <feMergeNode in="SourceGraphic"/>
+      </feMerge>
+    </filter>
+  </defs>
+  <rect width="500" height="500" fill="url(#skyGradient)" />
+  <g transform="translate(250, 220)">
+    <circle r="120" fill="url(#sunGradient)" />
+    <rect x="-120" y="20" width="240" height="4" fill="#2a0e66" opacity="0.8" />
+    <rect x="-120" y="35" width="240" height="6" fill="#2a0e66" opacity="0.8" />
+    <rect x="-120" y="52" width="240" height="8" fill="#2a0e66" opacity="0.8" />
+    <rect x="-120" y="72" width="240" height="12" fill="#2a0e66" opacity="0.8" />
+    <rect x="-120" y="96" width="240" height="16" fill="#2a0e66" opacity="0.8" />
+  </g>
+  <g stroke="#ff00ff" stroke-width="2" opacity="0.4">
+    <line x1="0" y1="350" x2="500" y2="350" />
+    <line x1="0" y1="380" x2="500" y2="380" />
+    <line x1="0" y1="420" x2="500" y2="420" />
+    <line x1="0" y1="470" x2="500" y2="470" />
+    <line x1="250" y1="350" x2="250" y2="500" />
+    <line x1="250" y1="350" x2="50" y2="500" />
+    <line x1="250" y1="350" x2="-150" y2="500" />
+    <line x1="250" y1="350" x2="450" y2="500" />
+    <line x1="250" y1="350" x2="650" y2="500" />
+  </g>
+  <g font-family="'Times New Roman', Times, serif" font-weight="bold" font-style="italic" font-size="360" text-anchor="middle">
+    <text x="217" y="390" fill="#00ffff" opacity="0.7">TC</text>
+    <text x="233" y="390" fill="#ff0055" opacity="0.7">TC</text>
+    <text x="225" y="390" fill="url(#textGradient)" stroke="#ffffff" stroke-width="3" filter="url(#neonGlow)">TC</text>
+  </g>
+  <g fill="#ffffff" opacity="0.8">
+    <circle cx="50" cy="50" r="2" />
+    <circle cx="450" cy="80" r="2" />
+    <circle cx="100" cy="150" r="1.5" />
+    <circle cx="400" cy="20" r="1.5" />
+    <path d="M420 120 L422 130 L432 132 L422 134 L420 144 L418 134 L408 132 L418 130 Z" fill="#00ffff" />
+  </g>
+</svg>

setiastrosuitepro-1.7.2.post1/src/setiastro/saspro/_generated/build_info.py

@@ -0,0 +1,3 @@
+# Auto-generated at build time. Do not edit.
+BUILD_TIMESTAMP = "2026-01-18T18:43:19Z"
+APP_VERSION = "1.7.2.post1"

{setiastrosuitepro-1.7.0.post2 → setiastrosuitepro-1.7.2.post1}/src/setiastro/saspro/aberration_ai.py

@@ -7,9 +7,33 @@ import numpy as np
 import sys
 import platform  # add
 import time
+import subprocess
 
 IS_APPLE_ARM = (sys.platform == "darwin" and platform.machine() == "arm64")
 
+def _has_nvidia_gpu() -> bool:
+    """Check if system has an NVIDIA GPU (Linux/Windows)."""
+    try:
+        if platform.system() == "Linux":
+            r = subprocess.run(["nvidia-smi", "-L"], capture_output=True, timeout=2)
+            return "GPU" in (r.stdout.decode("utf-8", errors="ignore") or "")
+        elif platform.system() == "Windows":
+            try:
+                ps = subprocess.run(
+                    ["powershell", "-NoProfile", "-Command",
+                     "(Get-CimInstance Win32_VideoController | Select-Object -ExpandProperty Name) -join ';'"],
+                    capture_output=True, timeout=2
+                )
+                out = (ps.stdout.decode("utf-8", errors="ignore") or "").lower()
+                return "nvidia" in out
+            except Exception:
+                w = subprocess.run(["wmic", "path", "win32_VideoController", "get", "name"],
+                                  capture_output=True, timeout=2)
+                return "nvidia" in (w.stdout.decode("utf-8", errors="ignore") or "").lower()
+    except Exception:
+        pass
+    return False
+
 from PyQt6.QtCore import Qt, QThread, pyqtSignal, QStandardPaths, QSettings
 from PyQt6.QtWidgets import (
     QDialog, QVBoxLayout, QHBoxLayout, QLabel, QPushButton, QFileDialog,
@@ -258,6 +282,7 @@ class _ONNXWorker(QThread):
     failed       = pyqtSignal(str)
     finished_ok  = pyqtSignal(np.ndarray)
     canceled     = pyqtSignal()
+    log_message  = pyqtSignal(str)          # for console logging
 
     def __init__(self, model_path: str, image: np.ndarray, patch: int, overlap: int, providers: list[str]):
         super().__init__()
@@ -287,16 +312,67 @@ class _ONNXWorker(QThread):
             self.canceled.emit()
             return
 
+        # Log available providers for debugging
+        avail_providers = ort.get_available_providers()
+        gpu_providers = [p for p in self.providers if p != "CPUExecutionProvider"]
+        has_nvidia = _has_nvidia_gpu()
+        
+        self.log_message.emit(f"🔍 Available ONNX providers: {', '.join(avail_providers)}")
+        self.log_message.emit(f"🔍 Attempting providers: {', '.join(self.providers)}")
+        print(f"🔍 Available ONNX providers: {', '.join(avail_providers)}")
+        print(f"🔍 Attempting providers: {', '.join(self.providers)}")
+        
+        # Check if NVIDIA GPU is present but CUDA provider is missing
+        if has_nvidia and "CUDAExecutionProvider" not in avail_providers:
+            msg = ("⚠️ GPU NVIDIA détecté mais CUDAExecutionProvider n'est pas disponible.\n"
+                   "   Vous devez installer 'onnxruntime-gpu' au lieu de 'onnxruntime'.\n"
+                   "   Commande: pip uninstall onnxruntime && pip install onnxruntime-gpu")
+            self.log_message.emit(msg)
+            print(msg)
+        
         try:
             sess = ort.InferenceSession(self.model_path, providers=self.providers)
             self.used_provider = (sess.get_providers()[0] if sess.get_providers() else None)
-        except Exception:
+            # Log successful GPU usage
+            if self.used_provider != "CPUExecutionProvider" and gpu_providers:
+                msg = f"✅ Aberration AI: Using GPU provider {self.used_provider}"
+                self.log_message.emit(msg)
+                print(msg)
+            elif has_nvidia and self.used_provider == "CPUExecutionProvider":
+                msg = ("⚠️ GPU NVIDIA détecté mais utilisation du CPU.\n"
+                       "   Installez 'onnxruntime-gpu' pour utiliser le GPU.")
+                self.log_message.emit(msg)
+                print(msg)
+        except Exception as e:
+            # Log the actual error for debugging
+            error_msg = str(e)
+            msg = f"⚠️ Aberration AI: GPU provider failed: {error_msg}"
+            self.log_message.emit(msg)
+            print(msg)
+            self.log_message.emit(f"Available providers: {', '.join(avail_providers)}")
+            print(f"Available providers: {', '.join(avail_providers)}")
+            self.log_message.emit(f"Attempted providers: {', '.join(self.providers)}")
+            print(f"Attempted providers: {', '.join(self.providers)}")
+            
+            # Check if onnxruntime-gpu is installed (CUDA provider should be available if it is)
+            if "CUDAExecutionProvider" in self.providers and "CUDAExecutionProvider" not in avail_providers:
+                if has_nvidia:
+                    msg = ("❌ CUDAExecutionProvider non disponible alors qu'un GPU NVIDIA est présent.\n"
+                           "   Installez 'onnxruntime-gpu': pip uninstall onnxruntime && pip install onnxruntime-gpu")
+                else:
+                    msg = "⚠️ CUDAExecutionProvider not available. You may need to install onnxruntime-gpu instead of onnxruntime."
+                self.log_message.emit(msg)
+                print(msg)
+            
             # fallback CPU if GPU fails
             try:
                 sess = ort.InferenceSession(self.model_path, providers=["CPUExecutionProvider"])
                 self.used_provider = "CPUExecutionProvider"
+                msg = f"⚠️ Aberration AI: Falling back to CPU (GPU initialization failed: {error_msg})"
+                self.log_message.emit(msg)
+                print(msg)
             except Exception as e2:
-                self.failed.emit(f"Failed to init ONNX session:\n{e2}")
+                self.failed.emit(f"Failed to init ONNX session:\nGPU error: {error_msg}\nCPU error: {e2}")
                 return
 
         def cb(frac):
@@ -796,6 +872,7 @@ class AberrationAIDialog(QDialog):
         self._worker.failed.connect(self._on_failed)
         self._worker.finished_ok.connect(self._on_ok)
         self._worker.finished.connect(self._on_worker_finished)
+        self._worker.log_message.connect(self._log)  # Connect log messages to console
         self._worker.start()
 
 

{setiastrosuitepro-1.7.0.post2 → setiastrosuitepro-1.7.2.post1}/src/setiastro/saspro/astrospike_python.py

@@ -685,9 +685,51 @@ def render_spikes(output: np.ndarray, stars: List[Star], config: SpikeConfig, ct
         
         # Main spikes
         if config.intensity > 0:
-            for i in range(qty):
-                theta = main_angle_rad + (i * (math.pi * 2) / float(qty))
-                ...
+            rainbow_str = config.rainbow_spike_intensity if (config.enable_rainbow and config.rainbow_spikes) else 0
+            for i in range(int(config.quantity)):
+                theta = main_angle_rad + (i * (math.pi * 2) / float(config.quantity))
+                cos_t = math.cos(theta)
+                sin_t = math.sin(theta)
+                
+                start_x = star.x + cos_t * 0.5
+                start_y = star.y + sin_t * 0.5
+                end_x = star.x + cos_t * base_length
+                end_y = star.y + sin_t * base_length
+                
+                # Standard Spike
+                # Base star color, fading to zero alpha
+                c_end = (star.color.r/255.0, star.color.g/255.0, star.color.b/255.0, 0.0)
+                
+                # If rainbow enabled, standard spike is dimmed (matches preview logic)
+                opacity_mult = 0.4 if rainbow_str > 0 else 1.0
+                c_start = (color[0], color[1], color[2], color[3] * opacity_mult)
+                
+                draw_line_gradient(output, start_x, start_y, end_x, end_y,
+                                  c_start, c_end, thickness, config.sharpness)
+                
+                # Rainbow Overlay
+                if rainbow_str > 0:
+                    stops = 10
+                    for s in range(stops):
+                        p1 = s / stops
+                        p2 = (s + 1) / stops
+                        if p1 > config.rainbow_spike_length:
+                            break
+                        
+                        hue = (p1 * 360.0 * config.rainbow_spike_frequency) % 360.0
+                        a_rainbow = min(1.0, config.intensity * rainbow_str * 2.0) * (1.0 - p1)
+                        r_seg, g_seg, b_seg = hsl_to_rgb(hue / 360.0, 0.8, 0.6)
+                        c_seg = (r_seg, g_seg, b_seg, a_rainbow)
+                        
+                        # Calculate segment positions
+                        sx = start_x + (end_x - start_x) * p1
+                        sy = start_y + (end_y - start_y) * p1
+                        ex = start_x + (end_x - start_x) * p2
+                        ey = start_y + (end_y - start_y) * p2
+                        
+                        # Draw rainbow segment with constant color
+                        draw_line_gradient(output, sx, sy, ex, ey,
+                                          c_seg, c_seg, thickness, 1.0)
         
         # Secondary spikes
         if config.secondary_intensity > 0:

{setiastrosuitepro-1.7.0.post2 → setiastrosuitepro-1.7.2.post1}/src/setiastro/saspro/gui/main_window.py

@@ -196,7 +196,7 @@ from setiastro.saspro.resources import (
     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, planetarystacker_path,
-    background_path, script_icon_path
+    background_path, script_icon_path, planetprojection_path,
 )
 
 import faulthandler
@@ -4280,6 +4280,29 @@ class AstroSuiteProMainWindow(
         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)
@@ -4619,9 +4642,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}")
@@ -9114,6 +9144,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()

{setiastrosuitepro-1.7.0.post2 → setiastrosuitepro-1.7.2.post1}/src/setiastro/saspro/gui/mixins/menu_mixin.py

@@ -155,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)
@@ -177,6 +178,7 @@ class MenuMixin:
         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) 
@@ -205,6 +207,7 @@ 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)

{setiastrosuitepro-1.7.0.post2 → setiastrosuitepro-1.7.2.post1}/src/setiastro/saspro/gui/mixins/toolbar_mixin.py

@@ -13,13 +13,14 @@ from PyQt6.QtWidgets import QMenu, QToolButton
 from PyQt6.QtCore import QElapsedTimer
 
 import sys
+import os
 
 if TYPE_CHECKING:
     pass
 
 # Import icon paths - these are needed at runtime
 from setiastro.saspro.resources import (
-    icon_path, green_path, neutral_path, whitebalance_path,
+    icon_path, green_path, neutral_path, whitebalance_path, texture_clarity_path,
     morpho_path, clahe_path, starnet_path, staradd_path, LExtract_path,
     LInsert_path, rgbcombo_path, rgbextract_path, graxperticon_path,
     cropicon_path, openfile_path, abeicon_path, undoicon_path, redoicon_path,
@@ -35,7 +36,7 @@ from setiastro.saspro.resources import (
     nbtorgb_path, freqsep_path, multiscale_decomp_path, contsub_path, halo_path, cosmic_path,
     satellite_path, imagecombine_path, wims_path, wimi_path, linearfit_path,
     debayer_path, aberration_path, functionbundles_path, viewbundles_path, planetarystacker_path,
-    selectivecolor_path, rgbalign_path,
+    selectivecolor_path, rgbalign_path, planetprojection_path,
 )
 
 # Import shortcuts module
@@ -222,6 +223,7 @@ class ToolbarMixin:
         tb_fn.addAction(self.act_wavescale_hdr)
         tb_fn.addAction(self.act_wavescale_de)
         tb_fn.addAction(self.act_clahe)
+        tb_fn.addAction(self.act_texture_clarity)
         tb_fn.addAction(self.act_morphology)
         tb_fn.addAction(self.act_pixelmath)
         tb_fn.addAction(self.act_signature)
@@ -257,6 +259,7 @@ class ToolbarMixin:
         tb_tl.addAction(self.act_ppp)    # Perfect Palette Picker
         tb_tl.addAction(self.act_nbtorgb)
         tb_tl.addAction(self.act_narrowband_normalization)
+        
         tb_tl.addAction(self.act_selective_color)
         tb_tl.addAction(self.act_freqsep)
         tb_tl.addAction(self.act_multiscale_decomp)
@@ -304,6 +307,7 @@ class ToolbarMixin:
         tb_star.addAction(self.act_stacking_suite)
         tb_star.addAction(self.act_live_stacking)
         tb_star.addAction(self.act_planetary_stacker)
+        tb_star.addAction(self.act_planet_projection)
         tb_star.addAction(self.act_plate_solve)
         tb_star.addAction(self.act_star_align)
         tb_star.addAction(self.act_star_register)
@@ -907,6 +911,12 @@ class ToolbarMixin:
         self.act_remove_green.setIconVisibleInMenu(True)
         self.act_remove_green.triggered.connect(self._open_remove_green)
 
+        # Texture and Clarity
+        self.act_texture_clarity = QAction(QIcon(texture_clarity_path), self.tr("Texture and Clarity..."), self)
+        self.act_texture_clarity.setToolTip(self.tr("Enhance texture and clarity using Unsharp Masking"))
+        self.act_texture_clarity.setIconVisibleInMenu(True)
+        self.act_texture_clarity.triggered.connect(self._open_texture_clarity)
+
         self.act_background_neutral = QAction(QIcon(neutral_path), self.tr("Background Neutralization..."), self)
         self.act_background_neutral.setStatusTip(self.tr("Neutralize background color balance using a sampled region"))
         self.act_background_neutral.setIconVisibleInMenu(True)
@@ -1131,10 +1141,7 @@ class ToolbarMixin:
         self.act_narrowband_normalization.setStatusTip(
             self.tr("Normalize HOO/SHO/HSO/HOS (PixelMath port by Bill Blanshan and Mike Cranfield)")
         )
-        self.act_narrowband_normalization.setIconVisibleInMenu(False)
-        self.act_narrowband_normalization.setShortcut(QKeySequence("Ctrl+Alt+Shift+N"))
-        self.act_narrowband_normalization.setShortcutContext(Qt.ShortcutContext.ApplicationShortcut)
-        self.addAction(self.act_narrowband_normalization)
+
         self.act_narrowband_normalization.triggered.connect(self._open_narrowband_normalization_tool)
 
         self.act_nbtorgb = QAction(QIcon(nbtorgb_path), self.tr("NB->RGB Stars..."), self)
@@ -1189,6 +1196,11 @@ class ToolbarMixin:
         self.act_planetary_stacker.setStatusTip(self.tr("Stack SER videos (planetary/solar/lunar)"))
         self.act_planetary_stacker.triggered.connect(self._open_planetary_stacker)
 
+        self.act_planet_projection = QAction(QIcon(planetprojection_path), self.tr("Planetary Projection..."), self)
+        self.act_planet_projection.setIconVisibleInMenu(True)
+        self.act_planet_projection.setStatusTip(self.tr("View your planets with stereographic projection"))
+        self.act_planet_projection.triggered.connect(self._open_planet_projection)
+
         self.act_plate_solve = QAction(QIcon(platesolve_path), self.tr("Plate Solver..."), self)
         self.act_plate_solve.setIconVisibleInMenu(True)
         self.act_plate_solve.setStatusTip(self.tr("Solve WCS/SIP for the active image or a file"))
@@ -1394,6 +1406,7 @@ class ToolbarMixin:
         reg("add_stars", self.act_add_stars)
         reg("pedestal",       self.act_pedestal)
         reg("remove_green",   self.act_remove_green)
+        reg("texture_clarity", self.act_texture_clarity)
         reg("background_neutral", self.act_background_neutral)
         reg("white_balance", self.act_white_balance)
         reg("sfcc",    self.act_sfcc)
@@ -1432,6 +1445,7 @@ class ToolbarMixin:
         reg("image_peeker", self.act_image_peeker)
         reg("live_stacking", self.act_live_stacking)
         reg("stacking_suite", self.act_stacking_suite)
+        reg("planet_projection", self.act_planet_projection)
         reg("supernova_hunter", self.act_supernova_hunter)
         reg("star_spikes", self.act_star_spikes)
         reg("astrospike", self.act_astrospike)