setiastrosuitepro 1.7.3__py3-none-any.whl → 1.7.4__py3-none-any.whl

setiastro/saspro/ops/settings.py

@@ -96,8 +96,8 @@ class SettingsDialog(QDialog):
         self.sp_min_alt = QDoubleSpinBox(); self.sp_min_alt.setRange(0.0, 90.0);  self.sp_min_alt.setDecimals(1)
         self.sp_obj_limit = QSpinBox(); self.sp_obj_limit.setRange(1, 1000)
 
-        self.chk_autostretch_16bit = QCheckBox(self.tr("High-quality autostretch (16-bit; better gradients)"))
-        self.chk_autostretch_16bit.setToolTip(self.tr("Compute autostretch on a 16-bit histogram (smoother gradients)."))
+        self.chk_autostretch_24bit = QCheckBox(self.tr("High-quality autostretch (24-bit; better gradients)"))
+        self.chk_autostretch_24bit.setToolTip(self.tr("Compute autostretch on a 24-bit histogram (smoother gradients)."))
 
         self.slider_bg_opacity = QSlider(Qt.Orientation.Horizontal)
         self.slider_bg_opacity.setRange(0, 100)
@@ -178,7 +178,7 @@ class SettingsDialog(QDialog):
 
         # ---- Display (moved under Theme) ----
         left_col.addRow(QLabel(self.tr("<b>Display</b>")))
-        left_col.addRow(self.chk_autostretch_16bit)
+        left_col.addRow(self.chk_autostretch_24bit)
         left_col.addRow(self.tr("Background Opacity:"), w_bg_opacity)
         left_col.addRow(self.tr("Background Image:"), w_bg_image)
 
@@ -296,8 +296,8 @@ class SettingsDialog(QDialog):
         self.sp_obj_limit.setValue(self.settings.value("object_limit", 100, type=int))
         
         # Display
-        self.chk_autostretch_16bit.setChecked(
-            self.settings.value("display/autostretch_16bit", True, type=bool)
+        self.chk_autostretch_24bit.setChecked(
+            self.settings.value("display/autostretch_24bit", True, type=bool)
         )
         
         current_opacity = self.settings.value("display/bg_opacity", 50, type=int)
@@ -464,7 +464,7 @@ class SettingsDialog(QDialog):
         # Updates + Display
         self.settings.setValue("updates/check_on_startup", self.chk_updates_startup.isChecked())
         self.settings.setValue("updates/url", self.le_updates_url.text().strip())
-        self.settings.setValue("display/autostretch_16bit", self.chk_autostretch_16bit.isChecked())
+        self.settings.setValue("display/autostretch_24bit", self.chk_autostretch_24bit.isChecked())
 
         # Custom background: persist the chosen path (empty -> remove)
         bg_path = (self.le_bg_path.text() or "").strip()

setiastro/saspro/pixelmath.py

@@ -1179,7 +1179,7 @@ class PixelMathDialogPro(QDialog):
                     target_median=float(getattr(self, "_as_target", 0.25)),
                     linked=bool(getattr(self, "_as_linked", True)),
                     sigma=float(getattr(self, "_as_sigma", 3.0)),
-                    use_16bit=bool(getattr(self, "_as_16bit", True)),
+                    use_24bit=bool(getattr(self, "_as_24bit", True)),
                 )
 
             self._set_preview_image(out)

setiastro/saspro/planetprojection.py

@@ -1022,152 +1022,261 @@ def export_planet_sphere_html(
 
     return html, out_path
 
+
 def export_pseudo_surface_html(
     rgb: np.ndarray,
     out_path: str | None = None,
     *,
-    title: str = "Pseudo Surface (Height from Brightness)",
-    # mesh size control (trade quality vs HTML size)
+    title: str = "Pseudo Surface (Point Cloud)",
     max_dim: int = 420,
-    # height controls
-    z_scale: float = 0.35,     # relative to min(W,H) after downsample
+    z_scale: float = 0.35,
     depth_gamma: float = 1.15,
     blur_sigma: float = 1.2,
     invert: bool = False,
-    # NEW: make depth coherent (kills spikes)
-    block: int = 10,           # 10 => 10x10 pixel average height
-    block_blur_sigma: float = 0.6,  # tiny blur after block for step edges
-    # NEW: safety cap so browsers don't melt if someone cranks max_dim
-    max_vertices: int = 220_000,     # ~470x470 grid
+    block: int = 10,
+    block_blur_sigma: float = 0.6,
+    max_vertices: int = 250_000,
+    point_size: float = 1.6,
+
+    # height source(s)
+    height_from: str = "brightness",      # "brightness" | "color" | "dual"
+
+    # how points are COLORED (from dropdown)
+    color_mode: str = "brightness",       # "brightness" | "depth" | "dual"
+    depth_colorscale: str = "Turbo",
+    depth_opacity: float = 0.55,
+    depth_point_size: float | None = None,
+
+    # Dual height controls (saturation-height layer)
+    sat_opacity: float = 0.45,
+    sat_point_size: float | None = None,
+
+    # Optional: reduce saturation-height noise in dark background
+    sat_luma_gate: float = 0.02,
+    sat_luma_soft: float = 0.18,
 ):
     """
-    Interactive Plotly Mesh3d of a displaced heightfield:
-      - XY is image plane
-      - Z is derived from luminance (pseudo surface)
-      - Vertex colors come from RGB
+    Interactive Plotly Scatter3d point cloud.
+
+    Z (height_from):
+      • "brightness": luminance-derived height
+      • "color":      saturation-derived height
+      • "dual":       overlays TWO clouds (brightness-height + saturation-height)
 
-    Uses image-style coordinates: +x right, +y down.
+    Coloring (color_mode) is ALWAYS honored, even for dual heights:
+      • "brightness": RGB image colors
+      • "depth":      colormap by height
+      • "dual":       RGB + depth overlay (per height cloud)
     """
     import os
     import numpy as np
+    import cv2
     import plotly.graph_objects as go
 
     x = np.asarray(rgb)
     if x.ndim != 3 or x.shape[2] < 3:
         raise ValueError("export_pseudo_surface_html expects RGB image (H,W,3).")
 
+    # normalize mode strings
+    cmode = (color_mode or "brightness").strip().lower()
+    if cmode not in ("brightness", "depth", "dual"):
+        cmode = "brightness"
+
+    hmode = (height_from or "brightness").strip().lower()
+    if hmode not in ("brightness", "color", "dual"):
+        hmode = "brightness"
+
     # ---- float01 ----
     if x.dtype == np.uint8:
         img01 = x[..., :3].astype(np.float32) / 255.0
     elif x.dtype == np.uint16:
         img01 = x[..., :3].astype(np.float32) / 65535.0
     else:
-        img01 = x[..., :3].astype(np.float32, copy=False)
-        img01 = np.clip(img01, 0.0, 1.0)
+        img01 = np.clip(x[..., :3].astype(np.float32, copy=False), 0.0, 1.0)
 
     H, W = img01.shape[:2]
 
-    # ---- downsample for mesh size ----
-    # clamp requested max_dim (prevents accidental 2k exports)
-    max_dim = int(np.clip(max_dim, 128, 900))
-
+    # ---- downsample ----
+    max_dim = int(np.clip(max_dim, 128, 2048))
     s = float(max_dim) / float(max(H, W))
     if s < 1.0:
         newW = max(64, int(round(W * s)))
         newH = max(64, int(round(H * s)))
-        img01_ds = cv2.resize(img01, (newW, newH), interpolation=cv2.INTER_AREA)
-    else:
-        img01_ds = img01
+        img01 = cv2.resize(img01, (newW, newH), interpolation=cv2.INTER_AREA)
 
-    hH, hW = img01_ds.shape[:2]
+    hH, hW = img01.shape[:2]
 
-    # ---- safety: cap vertex count (triangles scale ~2*(H-1)*(W-1)) ----
+    # ---- vertex cap ----
+    max_vertices = int(max(10_000, max_vertices))
     if hH * hW > max_vertices:
         scale = np.sqrt(float(max_vertices) / float(hH * hW))
         newW = max(64, int(round(hW * scale)))
         newH = max(64, int(round(hH * scale)))
-        img01_ds = cv2.resize(img01_ds, (newW, newH), interpolation=cv2.INTER_AREA)
-        hH, hW = img01_ds.shape[:2]
-
-    # ---- build height map from luminance ----
-    lum = (0.299 * img01_ds[..., 0] + 0.587 * img01_ds[..., 1] + 0.114 * img01_ds[..., 2]).astype(np.float32)
+        img01 = cv2.resize(img01, (newW, newH), interpolation=cv2.INTER_AREA)
+        hH, hW = img01.shape[:2]
+
+    # ---- helpers ----
+    def _robust01(base: np.ndarray) -> np.ndarray:
+        base = base.astype(np.float32, copy=False)
+        p_lo = float(np.percentile(base, 1.0))
+        p_hi = float(np.percentile(base, 99.5))
+        h = np.clip((base - p_lo) / max(p_hi - p_lo, 1e-9), 0.0, 1.0)
+
+        if invert:
+            h = 1.0 - h
+
+        # coherence smoothing
+        b = max(1, int(block))
+        if b > 1:
+            h = cv2.blur(h, (b, b), borderType=cv2.BORDER_REFLECT101)
+
+        if block_blur_sigma and block_blur_sigma > 0:
+            h = cv2.GaussianBlur(h, (0, 0), float(block_blur_sigma))
+
+        if blur_sigma and blur_sigma > 0:
+            h = cv2.GaussianBlur(h, (0, 0), float(blur_sigma))
+
+        h = np.clip(h, 0.0, 1.0) ** max(1e-3, float(depth_gamma))
+        return h.astype(np.float32)
+
+    # luminance (also used for saturation gating)
+    lum = (0.299 * img01[..., 0] + 0.587 * img01[..., 1] + 0.114 * img01[..., 2]).astype(np.float32)
+    h01_lum = _robust01(lum)
+
+    # saturation
+    hsv = cv2.cvtColor(img01.astype(np.float32), cv2.COLOR_RGB2HSV)
+    sat = hsv[..., 1].astype(np.float32)
+    h01_sat = _robust01(sat)
+
+    # Optional: suppress sat-height in very dark background
+    if sat_luma_soft and sat_luma_soft > 0:
+        gate = float(sat_luma_gate)
+        soft = float(sat_luma_soft)
+        wgt = np.clip((lum - gate) / max(soft, 1e-6), 0.0, 1.0).astype(np.float32)
+        h01_sat = h01_sat * wgt
+
+    # ---- depth scaling ----
+    zmax = 0.5 * float(min(hH, hW)) * float(z_scale)
+    Z_lum = ((h01_lum * 2.0) - 1.0) * zmax
+    Z_sat = ((h01_sat * 2.0) - 1.0) * zmax
+
+    # ---- XY grid ----
+    yy, xx = np.mgrid[0:hH, 0:hW]
+    X = (xx - (hW - 1) * 0.5).reshape(-1)
+    Y = (yy - (hH - 1) * 0.5).reshape(-1)
 
-    # Robust normalize (keep your existing behavior)
-    p_lo = float(np.percentile(lum, 1.0))
-    p_hi = float(np.percentile(lum, 99.5))
-    if p_hi <= p_lo + 1e-9:
-        h01 = np.clip(lum, 0.0, 1.0)
-    else:
-        h01 = (lum - p_lo) / (p_hi - p_lo)
-        h01 = np.clip(h01, 0.0, 1.0)
+    Zlum = Z_lum.reshape(-1)
+    Zsat = Z_sat.reshape(-1)
 
-    if invert:
-        h01 = 1.0 - h01
+    # ---- RGB strings ----
+    rgb_u8 = np.clip(img01.reshape(-1, 3) * 255.0, 0, 255).astype(np.uint8)
+    rgb_strings = [f"rgb({r},{g},{b})" for r, g, b in rgb_u8]
 
-    # ---- NEW: block smoothing to make depth coherent like wiggle ----
-    # each block shares one height value (10x10 average by default)
-    b = int(max(1, block))
-    if b > 1:
-        # cv2.blur is a fast box filter (mean filter)
-        h01 = cv2.blur(h01, (b, b), borderType=cv2.BORDER_REFLECT101)
+    traces: list = []
 
-    # optional tiny blur after blocking to soften terraces
-    if block_blur_sigma and block_blur_sigma > 0:
-        h01 = cv2.GaussianBlur(h01, (0, 0), float(block_blur_sigma))
+    # sizes / opacities per cloud
+    ps_lum = float(point_size)
+    ps_sat = float(sat_point_size) if sat_point_size is not None else float(point_size) * 1.05
+    op_lum = 0.95
+    op_sat = float(np.clip(sat_opacity, 0.05, 1.0))
 
-    # your existing smooth (kept; you can set blur_sigma=0 if you want)
-    if blur_sigma and blur_sigma > 0:
-        h01 = cv2.GaussianBlur(h01, (0, 0), float(blur_sigma))
+    dps = float(depth_point_size) if depth_point_size is not None else float(point_size)
 
-    # gamma shape
-    g = float(max(1e-3, depth_gamma))
-    h01 = np.clip(h01, 0.0, 1.0) ** g
+    def _add_cloud(
+        *,
+        name_prefix: str,
+        Z: np.ndarray,
+        size_rgb: float,
+        size_depth: float,
+        op_rgb: float,
+        op_depth: float,
+    ):
+        """
+        Add traces for a single height cloud, honoring cmode.
+        """
+        if cmode in ("brightness", "dual"):
+            traces.append(
+                go.Scatter3d(
+                    x=X, y=Y, z=Z,
+                    mode="markers",
+                    marker=dict(
+                        size=float(size_rgb),
+                        color=rgb_strings,
+                        opacity=1.0 if cmode == "brightness" else float(op_rgb),
+                    ),
+                    hoverinfo="skip",
+                    name=f"{name_prefix} (RGB)" if cmode != "brightness" else f"{name_prefix}",
+                )
+            )
 
-    # centered displacement [-1,+1]
-    h = (h01 * 2.0 - 1.0).astype(np.float32)
+        if cmode in ("depth", "dual"):
+            traces.append(
+                go.Scatter3d(
+                    x=X, y=Y, z=Z,
+                    mode="markers",
+                    marker=dict(
+                        size=float(size_depth),
+                        color=Z,  # numeric -> colorscale
+                        colorscale=depth_colorscale,
+                        cmin=float(Z.min()),
+                        cmax=float(Z.max()),
+                        opacity=1.0 if cmode == "depth" else float(op_depth),
+                        showscale=(cmode == "depth"),
+                        colorbar=dict(
+                            title="Depth",
+                            thickness=14,
+                            len=0.6,
+                        ) if cmode == "depth" else None,
+                    ),
+                    hoverinfo="skip",
+                    name=f"{name_prefix} (Depth)" if cmode != "depth" else f"{name_prefix}",
+                )
+            )
 
-    # Z scale in pixels-ish
-    zmax = float(min(hH, hW)) * float(z_scale)
-    z = h * zmax
+    if hmode == "brightness":
+        _add_cloud(
+            name_prefix="Brightness Height",
+            Z=Zlum,
+            size_rgb=ps_lum,
+            size_depth=dps,
+            op_rgb=0.95,
+            op_depth=depth_opacity,
+        )
+        show_legend = (cmode == "dual")
+
+    elif hmode == "color":
+        _add_cloud(
+            name_prefix="Color Height",
+            Z=Zsat,
+            size_rgb=ps_lum,     # reuse point_size for single-mode
+            size_depth=dps,
+            op_rgb=0.95,
+            op_depth=depth_opacity,
+        )
+        show_legend = (cmode == "dual")
 
-    # ---- mesh vertices ----
-    yy, xx = np.mgrid[0:hH, 0:hW].astype(np.float32)
-    X = (xx - (hW - 1) * 0.5).reshape(-1)
-    Y = (yy - (hH - 1) * 0.5).reshape(-1)
-    Z = z.reshape(-1)
-
-    # vertex colors
-    cols = np.clip(img01_ds.reshape(-1, 3) * 255.0, 0, 255).astype(np.uint8)
-    alpha = np.full((cols.shape[0], 1), 255, dtype=np.uint8)
-    vcol = np.concatenate([cols, alpha], axis=1)
-
-    # ---- triangles (vectorized) ----
-    grid = np.arange(hH * hW, dtype=np.int32).reshape(hH, hW)
-    p00 = grid[:-1, :-1].ravel()
-    p01 = grid[:-1,  1:].ravel()
-    p10 = grid[ 1:, :-1].ravel()
-    p11 = grid[ 1:,  1:].ravel()
-
-    I = np.concatenate([p00, p00]).astype(np.int32)
-    J = np.concatenate([p10, p11]).astype(np.int32)
-    K = np.concatenate([p11, p01]).astype(np.int32)
-
-    mesh = go.Mesh3d(
-        x=X, y=Y, z=Z,
-        i=I, j=J, k=K,
-        vertexcolor=vcol,
-        flatshading=False,
-        lighting=dict(
-            ambient=0.55, diffuse=0.85, specular=0.20,
-            roughness=0.95, fresnel=0.10
-        ),
-        lightposition=dict(x=2, y=1, z=3),
-        hoverinfo="skip",
-        name="PseudoSurface",
-        showscale=False,
-    )
+    else:
+        # dual heights: add BOTH clouds, each honoring cmode
+        _add_cloud(
+            name_prefix="Brightness Height",
+            Z=Zlum,
+            size_rgb=ps_lum,
+            size_depth=dps,
+            op_rgb=op_lum,
+            op_depth=depth_opacity,
+        )
+        _add_cloud(
+            name_prefix="Color Height",
+            Z=Zsat,
+            size_rgb=ps_sat,
+            size_depth=dps,
+            op_rgb=op_sat,
+            op_depth=min(1.0, depth_opacity * 0.85),  # slightly softer overlay feels nicer
+        )
+        show_legend = True  # dual heights should show what’s what
 
-    fig = go.Figure(data=[mesh])
+    # ---- figure ----
+    fig = go.Figure(data=traces)
     fig.update_layout(
         title=title,
         margin=dict(l=0, r=0, b=0, t=40),
@@ -1178,20 +1287,26 @@ def export_pseudo_surface_html(
             zaxis=dict(visible=False),
             bgcolor="black",
             camera=dict(
-                eye=dict(x=0.0, y=-1.6, z=1.2),
+                eye=dict(x=0.0, y=-1.6, z=1.0),
                 up=dict(x=0.0, y=-1.0, z=0.0),
             ),
         ),
         paper_bgcolor="black",
         plot_bgcolor="black",
-        showlegend=False,
+        showlegend=bool(show_legend),
+        legend=dict(
+            bgcolor="rgba(0,0,0,0)",
+            font=dict(color="white"),
+        ),
     )
 
     html = fig.to_html(include_plotlyjs="cdn", full_html=True)
     if out_path is None:
-        out_path = os.path.expanduser("~/pseudo_surface.html")
+        out_path = os.path.expanduser("~/pseudo_surface_pointcloud.html")
+
     return html, out_path
 
+
 def deproject_galaxy_topdown_u8(
     roi01: np.ndarray,  # float32 [0..1], (H,W,3)
     cx0: float, cy0: float,
@@ -1251,7 +1366,7 @@ class PlanetProjectionDialog(QDialog):
         self.setMinimumSize(520, 520)
 
         self.resize(560, 640)        
-        self.setWindowTitle("Planet Projection — Stereo / Wiggle")
+        self.setWindowTitle("3D Projection")
         self.setModal(False)
         self.parent = parent
         self.doc = document
@@ -1317,7 +1432,7 @@ class PlanetProjectionDialog(QDialog):
             "Stereo (Cross-eye)  R | L",
             "Wiggle stereo (toggle L/R)",
             "Anaglyph (Red/Cyan 3D Glasses)",
-            "Interactive 3D Sphere (HTML)",
+            "Interactive 3D (HTML)",
             "Galaxy Polar View (Top-Down)",
         ])
         form.addRow("Output:", self.cmb_mode)
@@ -1398,6 +1513,61 @@ class PlanetProjectionDialog(QDialog):
         self.chk_ps_invert.setChecked(True)
         ps_form.addRow("", self.chk_ps_invert)
 
+
+        # Pseudo-surface 3D coloring mode (how points are COLORED)
+        self.cmb_ps_3d_mode = QComboBox(self)
+        self.cmb_ps_3d_mode.addItems([
+            "Brightness (RGB)",
+            "Depth (Height Colormap)",
+            "Dual (RGB + Depth)",
+        ])
+        self.cmb_ps_3d_mode.setToolTip(
+            "3D point cloud coloring:\n"
+            "• Brightness: points colored from the image (RGB)\n"
+            "• Depth: points colored by height (colormap)\n"
+            "• Dual: overlays RGB + depth coloring"
+        )
+        ps_form.addRow("3D Color Mode:", self.cmb_ps_3d_mode)
+
+        # Height-from (what drives HEIGHT / Z)
+        self.cmb_ps_height_from = QComboBox(self)
+        self.cmb_ps_height_from.addItems([
+            "Brightness (Luminance)",
+            "Color Intensity (Saturation)",
+            "Dual (Brightness + Color)",
+        ])
+        self.cmb_ps_height_from.setToolTip(
+            "What drives the HEIGHT (Z) of the 3D point cloud:\n"
+            "• Brightness: luminance-derived height\n"
+            "• Color Intensity: saturation/chroma-derived height\n"
+            "• Dual: overlays TWO clouds (brightness height + saturation height)\n\n"
+            "Tip: Dual gives nebulae \"bulk\" even where brightness is flatter."
+        )
+        ps_form.addRow("Height From:", self.cmb_ps_height_from)
+
+        # Max points (vertex cap)
+        self.spin_ps_max_points = QSpinBox(self)
+        self.spin_ps_max_points.setRange(50_000, 900_000)   # tune if you want
+        self.spin_ps_max_points.setSingleStep(50_000)
+        self.spin_ps_max_points.setValue(250_000)           # good default
+        self.spin_ps_max_points.setToolTip(
+            "Maximum number of points used in the 3D plot.\n"
+            "Higher = more detail but heavier in the browser."
+        )
+        ps_form.addRow("Max Points:", self.spin_ps_max_points)
+
+        # Dual saturation cloud opacity (only used when Height From == Dual)
+        self.spin_ps_sat_opacity = QDoubleSpinBox(self)
+        self.spin_ps_sat_opacity.setRange(0.05, 1.0)
+        self.spin_ps_sat_opacity.setSingleStep(0.05)
+        self.spin_ps_sat_opacity.setValue(0.45)
+        self.spin_ps_sat_opacity.setToolTip(
+            "Opacity of the saturation-height cloud when Height From is Dual.\n"
+            "Lower = subtle bulk; higher = more pronounced volume."
+        )
+        ps_form.addRow("Dual Sat Opacity:", self.spin_ps_sat_opacity)
+
+        # (Keep your existing)
         form.addRow(ps_box)
 
         self.chk_auto_roi = QCheckBox("Auto ROI from planet centroid (green channel)")
@@ -1921,15 +2091,50 @@ class PlanetProjectionDialog(QDialog):
 
             if mode == 4:
                 try:
+                    # color mode (how points are colored)
+                    idx = int(self.cmb_ps_3d_mode.currentIndex()) if hasattr(self, "cmb_ps_3d_mode") else 0
+                    color_mode = ("brightness", "depth", "dual")[max(0, min(2, idx))]
+
+                    # height source (what drives Z)
+                    hidx = int(self.cmb_ps_height_from.currentIndex()) if hasattr(self, "cmb_ps_height_from") else 0
+                    height_from = ("brightness", "color", "dual")[max(0, min(2, hidx))]
+
+                    # cap
+                    max_pts = int(self.spin_ps_max_points.value()) if hasattr(self, "spin_ps_max_points") else 250_000
+
+                    # dual saturation opacity (only used in height_from="dual")
+                    sat_opacity = float(self.spin_ps_sat_opacity.value()) if hasattr(self, "spin_ps_sat_opacity") else 0.45
+
+                    # title
+                    if height_from == "brightness":
+                        ht = "Brightness Height"
+                    elif height_from == "color":
+                        ht = "Color Intensity Height"
+                    else:
+                        ht = "Dual Height (Brightness + Color)"
+
                     html, default_path = export_pseudo_surface_html(
                         roi,
                         out_path=None,
-                        title="Pseudo Surface (Height from Brightness)",
+                        title=f"Pseudo Surface ({ht})",
                         max_dim=2048,
                         z_scale=0.35,
                         depth_gamma=float(self.spin_ps_gamma.value()),
                         blur_sigma=float(self.spin_ps_blur.value()),
-                        invert=not bool(self.chk_ps_invert.isChecked()),
+                        invert=bool(self.chk_ps_invert.isChecked()),
+                        block=10,
+                        block_blur_sigma=0.6,
+                        max_vertices=max_pts,
+                        point_size=1.6,
+                        height_from=height_from,          # "brightness" | "color" | "dual"
+                        color_mode=color_mode,            # "brightness" | "depth" | "dual"
+                        depth_colorscale="Turbo",
+                        depth_opacity=0.55,
+                        depth_point_size=1.9,
+                        sat_opacity=sat_opacity,          # used in height_from="dual"
+                        sat_point_size=1.75,              # slightly different size looks great
+                        sat_luma_gate=0.02,               # suppress color-noise in very dark background
+                        sat_luma_soft=0.18,               # soft knee range
                     )
 
                     fn, _ = QFileDialog.getSaveFileName(
@@ -3180,7 +3385,7 @@ class PlanetProjectionPreviewDialog(QDialog):
     """
     def __init__(self, parent=None):
         super().__init__(parent)
-        self.setWindowTitle("Planet Projection — Preview")
+        self.setWindowTitle("3D Projection — Preview")
         self.setModal(False)
         self._img_zoom = 1.0      # content zoom (1.0 = full view)
         self._img_pan_x = 0.0     # in source pixels, relative to center

setiastro/saspro/sfcc.py

@@ -20,6 +20,12 @@ from datetime import datetime
 from typing import List, Tuple, Optional
 
 import numpy as np
+
+try:
+    _trapz = np.trapezoid
+except AttributeError:
+    _trapz = np.trapz
+
 import numpy.ma as ma
 import pandas as pd
 
@@ -313,8 +319,8 @@ class SaspViewer(QMainWindow):
             for color in ("red","green","blue"):
                 data = rgb_data[color]
                 if data is not None:
-                    S_star = np.trapezoid(data["response"], x=common_wl)
-                    S_veg  = np.trapezoid(fl_veg_c * data["T_sys"], x=common_wl)
+                    S_star = _trapz(data["response"], x=common_wl)
+                    S_veg  = _trapz(fl_veg_c * data["T_sys"], x=common_wl)
                     if S_veg>0 and S_star>0:
                         mag = -2.5 * np.log10(S_star / S_veg)
                         mag_texts.append(f"{color[0].upper()}→{data['filter_name']}: {mag:.2f}")
@@ -1485,9 +1491,9 @@ class SFCCDialog(QDialog):
         wl_ref, fl_ref = load_sed(ref_sed_name)
         fr_i = np.interp(wl_grid, wl_ref, fl_ref, left=0.0, right=0.0)
 
-        S_ref_R = np.trapezoid(fr_i * T_sys_R, x=wl_grid)
-        S_ref_G = np.trapezoid(fr_i * T_sys_G, x=wl_grid)
-        S_ref_B = np.trapezoid(fr_i * T_sys_B, x=wl_grid)
+        S_ref_R = _trapz(fr_i * T_sys_R, x=wl_grid)
+        S_ref_G = _trapz(fr_i * T_sys_G, x=wl_grid)
+        S_ref_B = _trapz(fr_i * T_sys_B, x=wl_grid)
 
         diag_meas_RG, diag_exp_RG = [], []
         diag_meas_BG, diag_exp_BG = [], []
@@ -1510,9 +1516,9 @@ class SFCCDialog(QDialog):
             try:
                 wl_s, fl_s = load_sed(pname)
                 fs_i = np.interp(wl_grid, wl_s, fl_s, left=0.0, right=0.0)
-                S_sr = np.trapezoid(fs_i * T_sys_R, x=wl_grid)
-                S_sg = np.trapezoid(fs_i * T_sys_G, x=wl_grid)
-                S_sb = np.trapezoid(fs_i * T_sys_B, x=wl_grid)
+                S_sr = _trapz(fs_i * T_sys_R, x=wl_grid)
+                S_sg = _trapz(fs_i * T_sys_G, x=wl_grid)
+                S_sb = _trapz(fs_i * T_sys_B, x=wl_grid)
                 template_integrals[pname] = (S_sr, S_sg, S_sb)
             except Exception as e:
                 print(f"[SFCC] Warning: failed to load/integrate template {pname}: {e}")