setiastrosuitepro 1.7.1.post2__py3-none-any.whl → 1.7.3__py3-none-any.whl

setiastro/saspro/_generated/build_info.py

@@ -1,3 +1,3 @@
 # Auto-generated at build time. Do not edit.
-BUILD_TIMESTAMP = "2026-01-15T16:55:53Z"
-APP_VERSION = "1.7.1.post2"
+BUILD_TIMESTAMP = "2026-01-20T16:24:15Z"
+APP_VERSION = "1.7.3"

setiastro/saspro/doc_manager.py

@@ -2276,6 +2276,7 @@ class DocManager(QObject):
         bit_depth: str | None = None,
         *,
         bit_depth_override: str | None = None,
+        jpeg_quality: int | None = None,   # <-- NEW
     ):
         """
         Save the given ImageDocument to 'path'.
@@ -2289,7 +2290,8 @@ class DocManager(QObject):
         ext = _normalize_ext(os.path.splitext(path)[1])
         img = doc.image
         meta = doc.metadata or {}
-
+        if jpeg_quality is not None:
+            meta["jpeg_quality"] = int(jpeg_quality)
         # ── MASSIVE DEBUG: show everything we know coming in ───────────────
         debug_dump_metadata_print(meta, context="save_document: BEFORE HEADER PICK")
 
@@ -2359,6 +2361,7 @@ class DocManager(QObject):
             image_meta=meta.get("image_meta"),
             file_meta=meta.get("file_meta"),
             wcs_header=meta.get("wcs_header"),
+            jpeg_quality=jpeg_quality,
         )
 
         # ── Update metadata in memory to match what we just wrote ─────────

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
@@ -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()
@@ -4280,6 +4296,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)

setiastro/saspro/gui/mixins/file_mixin.py

@@ -216,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

@@ -207,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)

setiastro/saspro/gui/mixins/toolbar_mixin.py

@@ -36,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
@@ -307,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)
@@ -1195,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"))
@@ -1439,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)

setiastro/saspro/imageops/serloader.py

@@ -10,6 +10,7 @@ from typing import Optional, Tuple, Dict, List, Sequence, Union, Callable
 from collections import OrderedDict
 import numpy as np
 import time
+from PyQt6 import sip
 
 import cv2
 
@@ -115,6 +116,20 @@ def _bytes_per_sample(pixel_depth_bits: int) -> int:
 def _is_bayer(color_name: str) -> bool:
     return color_name in BAYER_NAMES
 
+def _roi_unrotate_180(roi: Tuple[int, int, int, int], W: int, H: int) -> Tuple[int, int, int, int]:
+    """
+    Convert an ROI specified in *post-rot180/display coords* into *raw/pre-rot coords*.
+    """
+    x, y, w, h = [int(v) for v in roi]
+    x2 = x + w
+    y2 = y + h
+
+    x_raw = int(W - x2)
+    y_raw = int(H - y2)
+
+    return (x_raw, y_raw, int(w), int(h))
+
+
 def _rot180(img: np.ndarray) -> np.ndarray:
     # Works for mono (H,W) and RGB(A) (H,W,C)
     return img[::-1, ::-1].copy()
@@ -847,7 +862,9 @@ class SERReader:
 
         # ROI (apply before debayer; for Bayer enforce even-even origin)
         if roi is not None:
-            x, y, w, h = [int(v) for v in roi]
+            # ✅ roi is specified in DISPLAY coords (post-rot180)
+            x, y, w, h = _roi_unrotate_180(roi, meta.width, meta.height)
+
             x = max(0, min(meta.width - 1, x))
             y = max(0, min(meta.height - 1, y))
             w = max(1, min(meta.width - x, w))
@@ -862,7 +879,6 @@ class SERReader:
 
         # --- SER global orientation fix (rotate 180) ---
         img = _rot180(img)
-
         # Convert BGR->RGB if needed
         if color_name == "BGR" and img.ndim == 3 and img.shape[2] >= 3:
             img = img[..., ::-1].copy()
@@ -1075,15 +1091,16 @@ class AVIReader(PlanetaryFrameSource):
 
         # ROI first (but if we are going to debayer mosaic, ROI origin must be even-even)
         if roi is not None:
-            x, y, w, h = [int(v) for v in roi]
             H, W = frame.shape[:2]
+
+            # ✅ roi is specified in DISPLAY coords (post-rot180)
+            x, y, w, h = _roi_unrotate_180(roi, W, H)
+
             x = max(0, min(W - 1, x))
             y = max(0, min(H - 1, y))
             w = max(1, min(W - x, w))
             h = max(1, min(H - y, h))
 
-            # If user explicitly requests debayering, preserve Bayer phase
-            # (even-even origin) exactly like SER
             if debayer and user_pat is not None:
                 x, y = _roi_evenize_for_bayer(x, y)
                 w = max(1, min(W - x, w))
@@ -1160,13 +1177,45 @@ class AVIReader(PlanetaryFrameSource):
 
 def _imread_any(path: str) -> np.ndarray:
     """
-    Read PNG/JPG/TIF/etc into numpy.
-    Tries cv2 first (fast), falls back to PIL.
+    Read PNG/JPG/TIF/FITS/etc into numpy.
     Returns:
-      - grayscale: (H,W) uint8/uint16
-      - color:     (H,W,3) uint8/uint16 in RGB (we normalize to RGB)
+      - grayscale: (H,W)
+      - color:     (H,W,3) in RGB when applicable
     """
     p = os.fspath(path)
+    ext = os.path.splitext(p)[1].lower()
+
+    # ---- FITS / FIT ----
+    if ext in (".fit", ".fits"):
+        try:
+            from astropy.io import fits
+
+            data = fits.getdata(p, memmap=False)
+            if data is None:
+                raise ValueError("Empty FITS data.")
+
+            arr = np.asarray(data)
+
+            # Common shapes:
+            # (H,W) -> mono
+            # (C,H,W) -> convert to (H,W,C)
+            # (H,W,C) -> already fine
+            if arr.ndim == 3:
+                # If first axis is small (1/3/4), assume CHW
+                if arr.shape[0] in (1, 3, 4) and arr.shape[1] > 8 and arr.shape[2] > 8:
+                    arr = np.moveaxis(arr, 0, -1)  # CHW -> HWC
+
+                # If now HWC and has alpha, drop it
+                if arr.shape[-1] >= 4:
+                    arr = arr[..., :3]
+
+                # If single channel, squeeze
+                if arr.shape[-1] == 1:
+                    arr = arr[..., 0]
+
+            return arr
+        except Exception as e:
+            raise RuntimeError(f"Failed to read FITS: {p}\n{e}")
 
     # Prefer cv2 if available
     if cv2 is not None:
@@ -1194,6 +1243,47 @@ def _imread_any(path: str) -> np.ndarray:
     im = im.convert("RGB")
     return np.array(im)
 
+def _to_float01_robust(img: np.ndarray) -> np.ndarray:
+    """
+    Robust float01 conversion for preview:
+    - uint8/uint16/int types scale by dtype max
+    - float types:
+        * if already ~[0,1], keep
+        * else percentile-scale (0.1..99.9) to [0,1]
+    Works for mono or RGB arrays.
+    """
+    a = np.asarray(img)
+
+    if a.dtype == np.uint8:
+        return a.astype(np.float32) / 255.0
+    if a.dtype == np.uint16:
+        return a.astype(np.float32) / 65535.0
+    if np.issubdtype(a.dtype, np.integer):
+        info = np.iinfo(a.dtype)
+        denom = float(info.max) if info.max > 0 else 1.0
+        return (a.astype(np.float32) / denom).clip(0.0, 1.0)
+
+    # float path
+    f = a.astype(np.float32, copy=False)
+
+    # If it already looks like [0,1], don’t mess with it
+    mn = float(np.nanmin(f))
+    mx = float(np.nanmax(f))
+    if (mn >= -1e-3) and (mx <= 1.0 + 1e-3):
+        return np.clip(f, 0.0, 1.0)
+
+    # Percentile scale (planetary-friendly)
+    lo = float(np.nanpercentile(f, 0.1))
+    hi = float(np.nanpercentile(f, 99.9))
+    if not np.isfinite(lo) or not np.isfinite(hi) or hi <= lo + 1e-12:
+        # fallback to min/max
+        lo, hi = mn, mx
+        if not np.isfinite(lo) or not np.isfinite(hi) or hi <= lo + 1e-12:
+            return np.zeros_like(f, dtype=np.float32)
+
+    out = (f - lo) / (hi - lo)
+    return np.clip(out, 0.0, 1.0)
+
 
 def _infer_bit_depth(arr: np.ndarray) -> int:
     if arr.dtype == np.uint16:
@@ -1295,13 +1385,7 @@ class ImageSequenceReader(PlanetaryFrameSource):
 
         # Normalize to float01
         if to_float01:
-            if img.dtype == np.uint8:
-                img = img.astype(np.float32) / 255.0
-            elif img.dtype == np.uint16:
-                img = img.astype(np.float32) / 65535.0
-            else:
-                img = img.astype(np.float32)
-                img = np.clip(img, 0.0, 1.0)
+            img = _to_float01_robust(img)
 
         self._cache.put(key, img)
         return img
@@ -1339,7 +1423,7 @@ def open_planetary_source(
         return AVIReader(path, cache_items=cache_items)
 
     # If user passes a single image, treat it as a 1-frame sequence
-    if ext in (".png", ".tif", ".tiff", ".jpg", ".jpeg", ".bmp", ".webp"):
+    if ext in (".png", ".tif", ".tiff", ".jpg", ".jpeg", ".bmp", ".webp", ".fit", ".fits"):
         return ImageSequenceReader([path], cache_items=cache_items)
 
     raise ValueError(f"Unsupported input: {path}")

setiastro/saspro/layers.py

@@ -1,6 +1,6 @@
 # pro/layers.py
 from __future__ import annotations
-from dataclasses import dataclass
+from dataclasses import dataclass, field
 from typing import Optional, List
 import numpy as np
 
@@ -20,6 +20,17 @@ BLEND_MODES = [
     "Sigmoid",
 ]
 
+
+@dataclass
+class LayerTransform:
+    tx: float = 0.0
+    ty: float = 0.0
+    rot_deg: float = 0.0
+    sx: float = 1.0
+    sy: float = 1.0
+    pivot_x: float | None = None
+    pivot_y: float | None = None
+
 @dataclass
 class ImageLayer:
     name: str
@@ -33,7 +44,8 @@ class ImageLayer:
     mask_invert: bool = False
     mask_feather: float = 0.0
     mask_use_luma: bool = False
-
+    transform: LayerTransform = field(default_factory=LayerTransform)
+    selected: bool = False  # optional, or store selected layer elsewhere
     sigmoid_center: float = 0.5
     sigmoid_strength: float = 10.0
 
@@ -63,6 +75,127 @@ def _resize_like(src: np.ndarray, tgt_shape_hw: tuple[int, int]) -> np.ndarray:
     xi = (np.linspace(0, Ws - 1, Wt)).astype(np.int32)
     return src[yi][:, xi, ...] if src.ndim == 3 else src[yi][:, xi]
 
+def _affine_matrix_from_transform(t: LayerTransform, H: int, W: int) -> np.ndarray:
+    """
+    Returns 3x3 matrix mapping source -> destination in pixel coords.
+    We will invert it when sampling (dest -> src).
+    """
+    tx, ty = float(t.tx), float(t.ty)
+    sx, sy = float(t.sx), float(t.sy)
+    th = np.deg2rad(float(t.rot_deg))
+
+    # Default pivot: image center in pixel coords
+    px = (W - 1) * 0.5 if t.pivot_x is None else float(t.pivot_x)
+    py = (H - 1) * 0.5 if t.pivot_y is None else float(t.pivot_y)
+
+    c = float(np.cos(th))
+    s = float(np.sin(th))
+
+    # Build: T(tx,ty) * T(pivot) * R * S * T(-pivot)
+    T1 = np.array([[1, 0, -px],
+                   [0, 1, -py],
+                   [0, 0,  1]], dtype=np.float32)
+
+    S  = np.array([[sx, 0,  0],
+                   [0, sy,  0],
+                   [0,  0,  1]], dtype=np.float32)
+
+    R  = np.array([[ c, -s, 0],
+                   [ s,  c, 0],
+                   [ 0,  0, 1]], dtype=np.float32)
+
+    T2 = np.array([[1, 0, px],
+                   [0, 1, py],
+                   [0, 0,  1]], dtype=np.float32)
+
+    Tt = np.array([[1, 0, tx],
+                   [0, 1, ty],
+                   [0, 0,  1]], dtype=np.float32)
+
+    M = (Tt @ T2 @ R @ S @ T1).astype(np.float32, copy=False)
+    return M
+
+
+def _warp_affine_nearest(src: np.ndarray, out_hw: tuple[int, int], M_src_to_dst: np.ndarray,
+                         *, fill: float = 0.0) -> np.ndarray:
+    """
+    Nearest-neighbor warp without deps.
+    src: (Hs,Ws) or (Hs,Ws,C)
+    out: (Ht,Wt) or (Ht,Wt,C)
+    M_src_to_dst: 3x3 matrix mapping src -> dst.
+    We sample by inverting: src = inv(M) * dst.
+    """
+    Ht, Wt = int(out_hw[0]), int(out_hw[1])
+    Hs, Ws = int(src.shape[0]), int(src.shape[1])
+
+    if src.ndim == 2:
+        C = None
+    else:
+        C = int(src.shape[2])
+
+    # Compute inverse mapping
+    try:
+        Minv = np.linalg.inv(M_src_to_dst).astype(np.float32, copy=False)
+    except np.linalg.LinAlgError:
+        # Singular matrix (e.g. sx=0). Return fill.
+        if C is None:
+            return np.full((Ht, Wt), fill, dtype=src.dtype)
+        return np.full((Ht, Wt, C), fill, dtype=src.dtype)
+
+    # Build destination grid
+    yy, xx = np.mgrid[0:Ht, 0:Wt]
+    ones = np.ones_like(xx, dtype=np.float32)
+
+    # (3, Ht*Wt)
+    dst = np.stack([xx.astype(np.float32), yy.astype(np.float32), ones], axis=0).reshape(3, -1)
+    src_xyw = (Minv @ dst)
+
+    xs = np.rint(src_xyw[0]).astype(np.int32)
+    ys = np.rint(src_xyw[1]).astype(np.int32)
+
+    valid = (xs >= 0) & (xs < Ws) & (ys >= 0) & (ys < Hs)
+
+    if C is None:
+        out = np.full((Ht * Wt,), fill, dtype=src.dtype)
+        out[valid] = src[ys[valid], xs[valid]]
+        return out.reshape(Ht, Wt)
+
+    out = np.full((Ht * Wt, C), fill, dtype=src.dtype)
+    out[valid] = src[ys[valid], xs[valid], :]
+    return out.reshape(Ht, Wt, C)
+
+
+def _apply_transform_to_layer_image(img01_3c: np.ndarray, t: LayerTransform, H: int, W: int) -> np.ndarray:
+    """
+    img01_3c is float32 [0..1], shape (Hs,Ws,3).
+    Returns float32 [0..1], shape (H,W,3) transformed into base canvas size.
+    """
+    M = _affine_matrix_from_transform(t, img01_3c.shape[0], img01_3c.shape[1])
+
+    # IMPORTANT:
+    # Your transform parameters (tx,ty,pivot) are in *layer pixel space*.
+    # We want to composite in base space (H,W).
+    #
+    # Since you already resize layers to (H,W) before compositing, easiest is:
+    # 1) resize to (H,W)
+    # 2) build transform using H,W
+    # 3) warp in that same canvas
+    #
+    # So caller should pass already-resized (H,W,3) and we rebuild M with H,W.
+    M = _affine_matrix_from_transform(t, H, W)
+    warped = _warp_affine_nearest(img01_3c, (H, W), M, fill=0.0).astype(np.float32, copy=False)
+    return np.clip(warped, 0.0, 1.0)
+
+def _apply_transform_to_mask(mask01: np.ndarray, t: LayerTransform, H: int, W: int) -> np.ndarray:
+    m = np.clip(mask01.astype(np.float32, copy=False), 0.0, 1.0)
+    if m.ndim != 2:
+        m = m[..., 0] if (m.ndim == 3 and m.shape[2] == 1) else m
+    m = _resize_like(m, (H, W))
+    M = _affine_matrix_from_transform(t, H, W)
+    warped = _warp_affine_nearest(m, (H, W), M, fill=0.0).astype(np.float32, copy=False)
+    return np.clip(warped, 0.0, 1.0)
+
+
 def _luminance01(img: np.ndarray) -> np.ndarray:
     a = _float01(img)
     a = _ensure_3c(a)
@@ -172,41 +305,84 @@ def _apply_mode(base: np.ndarray, src: np.ndarray, layer: ImageLayer) -> np.ndar
 
 
 def composite_stack(base_img: np.ndarray, layers: List[ImageLayer]) -> np.ndarray:
+    """
+    Composite a base image with a stack of ImageLayer objects.
+
+    Notes:
+    - Works in float32 [0..1] internally.
+    - Ensures 3-channel output.
+    - Applies per-layer transform (translate/rotate/scale about pivot) in canvas space
+      AFTER resizing the layer to the base canvas (H,W).
+    - Applies the SAME transform to the layer's mask (if present) so alpha lines up.
+    """
     if base_img is None:
         return None
-    out = _float01(base_img)
-    out = _ensure_3c(out)
 
-    H, W = out.shape[0], out.shape[1]
+    out = _ensure_3c(_float01(base_img))
+    H, W = int(out.shape[0]), int(out.shape[1])
 
     # iterate bottom → top so the top-most layer renders last
     for L in reversed(layers or []):
-        if not L.visible:
+        if not getattr(L, "visible", True):
             continue
+
+        # ----- fetch source pixels -----
         src = getattr(L, "pixels", None)
         if src is None:
             src_doc = getattr(L, "src_doc", None)
             src = getattr(src_doc, "image", None) if src_doc is not None else None
         if src is None:
             continue
+
+        # ----- normalize to float01 + 3 channels + canvas size -----
         s = _ensure_3c(_float01(src))
         s = _resize_like(s, (H, W))
 
+        # ----- apply layer transform in canvas space -----
+        t = getattr(L, "transform", None)
+        if t is not None:
+            try:
+                s = _apply_transform_to_layer_image(s, t, H, W)
+            except Exception:
+                # If transform fails for any reason, fall back to untransformed
+                pass
+
+        # ----- validate blend mode -----
         if getattr(L, "mode", None) not in BLEND_MODES:
             L.mode = "Normal"
 
+        # ----- blend result (still full-strength; opacity/mask applied after) -----
         blended = _apply_mode(out, s, L)
 
-        alpha = float(L.opacity if 0.0 <= L.opacity <= 1.0 else 1.0)
-        if L.mask_doc is not None:
-            m = _mask_from_doc(L.mask_doc, use_luma=bool(L.mask_use_luma))
+        # ----- compute alpha -----
+        try:
+            alpha = float(getattr(L, "opacity", 1.0))
+        except Exception:
+            alpha = 1.0
+        if not (0.0 <= alpha <= 1.0):
+            alpha = 1.0
+
+        # ----- optional mask (transformed to match the layer) -----
+        if getattr(L, "mask_doc", None) is not None:
+            m = _mask_from_doc(L.mask_doc, use_luma=bool(getattr(L, "mask_use_luma", False)))
             if m is not None:
                 m = _resize_like(m, (H, W))
-                if L.mask_invert:
+
+                # Apply SAME transform to mask so it stays registered with the layer pixels
+                if t is not None:
+                    try:
+                        m = _apply_transform_to_mask(m, t, H, W)
+                    except Exception:
+                        pass
+
+                if getattr(L, "mask_invert", False):
                     m = 1.0 - m
+
                 alpha_map = np.clip(alpha * m, 0.0, 1.0)[..., None]
                 out = out * (1.0 - alpha_map) + blended * alpha_map
                 continue
+
+        # ----- no mask: uniform opacity -----
         out = out * (1.0 - alpha) + blended * alpha
 
     return out