setiastrosuitepro 1.6.7__py3-none-any.whl → 1.7.0__py3-none-any.whl

setiastro/saspro/layers.py

@@ -23,18 +23,19 @@ BLEND_MODES = [
 @dataclass
 class ImageLayer:
     name: str
-    src_doc: object                         # ImageDocument
+    src_doc: Optional[object] = None          # ImageDocument (can be None for baked raster)
+    pixels: Optional[np.ndarray] = None       # NEW: baked raster pixels in float32 or any dtype
+
     visible: bool = True
-    opacity: float = 1.0                    # 0..1
-    mode: str = "Normal"                    # one of BLEND_MODES
-    mask_doc: Optional[object] = None       # ImageDocument whose active mask we read
+    opacity: float = 1.0
+    mode: str = "Normal"
+    mask_doc: Optional[object] = None
     mask_invert: bool = False
-    mask_feather: float = 0.0               # (reserved)
+    mask_feather: float = 0.0
     mask_use_luma: bool = False
 
-    # Sigmoid blend parameters
-    sigmoid_center: float = 0.5             # where transition happens (0..1)
-    sigmoid_strength: float = 10.0          # steepness of the curve
+    sigmoid_center: float = 0.5
+    sigmoid_strength: float = 10.0
 
 def _float01(arr: np.ndarray) -> np.ndarray:
     a = np.asarray(arr)
@@ -182,7 +183,10 @@ def composite_stack(base_img: np.ndarray, layers: List[ImageLayer]) -> np.ndarra
     for L in reversed(layers or []):
         if not L.visible:
             continue
-        src = getattr(L.src_doc, "image", None)
+        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
         s = _ensure_3c(_float01(src))

setiastro/saspro/layers_dock.py

@@ -212,19 +212,29 @@ class LayersDock(QDockWidget):
         top.addWidget(self.view_combo, 1)
 
         self.list = QListWidget()
-        self.list.setSelectionMode(QAbstractItemView.SelectionMode.SingleSelection)
+        self.list.setSelectionMode(QAbstractItemView.SelectionMode.ExtendedSelection)
         self.list.setAlternatingRowColors(True)
         v.addWidget(self.list, 1)
 
         # buttons
         row = QHBoxLayout(); v.addLayout(row)
+
         self.btn_clear = QPushButton("Clear All Layers")
-        self.btn_merge = QPushButton("Merge Layers and Push to View")
+
+        self.btn_merge = QPushButton("Merge → Push to View")
         self.btn_merge.setToolTip("Flatten the visible layers into the current view and add an undo step.")
+
+        self.btn_merge_new = QPushButton("Merge → New Document")
+        self.btn_merge_new.setToolTip("Flatten the visible layers into a new document (does not modify the base view).")
+
+        self.btn_merge_sel = QPushButton("Merge Selected → Single Layer")
+        self.btn_merge_sel.setToolTip("Merge the selected layers into one raster layer (Photoshop-style).")
+
         row.addWidget(self.btn_merge)
+        row.addWidget(self.btn_merge_new)
+        row.addWidget(self.btn_merge_sel)
         row.addStretch(1)
         row.addWidget(self.btn_clear)
-
         self.setWidget(w)
 
         # dnd (accept drops from views)
@@ -240,6 +250,8 @@ class LayersDock(QDockWidget):
         self.docman.documentRemoved.connect(lambda _d: self._refresh_views())
 
         self.btn_merge.clicked.connect(self._merge_and_push)
+        self.btn_merge_new.clicked.connect(self._merge_to_new_doc)
+        self.btn_merge_sel.clicked.connect(self._merge_selected_to_single_layer)
 
         # initial
         self._refresh_views()
@@ -420,8 +432,107 @@ class LayersDock(QDockWidget):
         has_layers = bool(getattr(vw, "_layers", []))
         self.btn_merge.setEnabled(has_layers)
         self.btn_clear.setEnabled(has_layers)
+        if hasattr(self, "btn_merge_new"):
+            self.btn_merge_new.setEnabled(has_layers)    
+        has_layers = bool(getattr(vw, "_layers", []))
+        self.btn_merge_sel.setEnabled(has_layers)
         self._refresh_row_heights()
 
+    def _selected_layer_indices(self) -> list[int]:
+        vw = self.current_view()
+        if not vw:
+            return []
+        n = len(getattr(vw, "_layers", []) or [])
+        idxs = []
+        for it in self.list.selectedItems():
+            r = self.list.row(it)
+            if 0 <= r < n:
+                idxs.append(r)
+        idxs = sorted(set(idxs))
+        return idxs
+
+    def _render_stack(self, base_img: np.ndarray, layers: list[ImageLayer]) -> np.ndarray:
+        # composite_stack already respects visibility/opacity/modes/masks
+        out = composite_stack(base_img, layers)
+        return out if out is not None else base_img
+
+    def _open_baked_layer_doc(self, base_doc, arr: np.ndarray, title: str):
+        dm = getattr(self.mw, "docman", None)
+        if not dm or not hasattr(dm, "open_array"):
+            return None
+        meta = dict(getattr(base_doc, "metadata", {}) or {})
+        meta.update({
+            "bit_depth": "32-bit floating point",
+            "is_mono": (arr.ndim == 2 or (arr.ndim == 3 and arr.shape[-1] == 1)),
+            "source": "Layers Merge Selected",
+        })
+        return dm.open_array(arr.astype(np.float32, copy=False), metadata=meta, title=title)
+
+    def _merge_selected_to_single_layer(self):
+        vw = self.current_view()
+        if not vw:
+            return
+
+        layers = list(getattr(vw, "_layers", []) or [])
+        if not layers:
+            QMessageBox.information(self, "Layers", "There are no layers to merge.")
+            return
+
+        sel = self._selected_layer_indices()
+        if len(sel) < 2:
+            QMessageBox.information(self, "Layers", "Select two or more layers to merge.")
+            return
+
+        try:
+            base_doc = getattr(vw, "document", None)
+            if base_doc is None or getattr(base_doc, "image", None) is None:
+                QMessageBox.warning(self, "Layers", "No base image available for this view.")
+                return
+            base_img = base_doc.image
+
+            i0, i1 = sel[0], sel[-1]
+
+            # IMPORTANT ASSUMPTION (matches your UI order):
+            # vw._layers is top-to-bottom in the list, and "below" means larger index.
+            layers_above = layers[:i0]
+            layers_sel   = layers[i0:i1+1]
+            layers_below = layers[i1+1:]
+
+            # 1) Render what exists directly under the selected range
+            under = self._render_stack(base_img, layers_below)
+
+            # 2) Render selected layers on top of that "under" image
+            baked = self._render_stack(under, layers_sel)
+
+
+            # 3) Create a baked raster layer (NO new document)
+            merged_layer = ImageLayer(
+                name=f"Merged ({len(layers_sel)})",
+                src_doc=None,
+                pixels=baked.astype(np.float32, copy=False),
+                visible=True,
+                opacity=1.0,
+                mode="Normal",
+            )
+
+            # Keep masks off by default; you can also decide to inherit the topmost mask
+            merged_layer.mask_doc = None
+            merged_layer.mask_use_luma = True
+            merged_layer.mask_invert = False
+
+            new_layers = layers_above + [merged_layer] + layers_below
+            vw._layers = new_layers
+
+            vw._reinstall_layer_watchers()
+            self._rebuild_list()
+            vw.apply_layer_stack(vw._layers)
+
+            QMessageBox.information(self, "Layers", f"Merged {len(layers_sel)} layers into a single layer.")
+        except Exception as ex:
+            print("[LayersDock] merge_selected error:", ex)
+            QMessageBox.critical(self, "Layers", f"Merge Selected failed:\n{ex}")
+
+
     def _layer_count(self) -> int:
         vw = self.current_view()
         return len(getattr(vw, "_layers", [])) if vw else 0
@@ -712,3 +823,72 @@ class LayersDock(QDockWidget):
             print("[LayersDock] merge error:", ex)
             QMessageBox.critical(self, "Layers", f"Merge failed:\n{ex}")
 
+    def _merge_to_new_doc(self):
+        vw = self.current_view()
+        if not vw:
+            return
+
+        layers = list(getattr(vw, "_layers", []) or [])
+        if not layers:
+            QMessageBox.information(self, "Layers", "There are no layers to merge.")
+            return
+
+        try:
+            base_doc = getattr(vw, "document", None)
+            if base_doc is None or getattr(base_doc, "image", None) is None:
+                QMessageBox.warning(self, "Layers", "No base image available for this view.")
+                return
+
+            base_img = base_doc.image
+            merged = composite_stack(base_img, layers)
+            if merged is None:
+                QMessageBox.warning(self, "Layers", "Composite failed (empty result).")
+                return
+
+            # Push as a new document (same pattern as stars-only)
+            self._push_merged_as_new_doc(base_doc, merged)
+
+            QMessageBox.information(self, "Layers",
+                                    "Merged visible layers and created a new document.")
+        except Exception as ex:
+            print("[LayersDock] merge_to_new_doc error:", ex)
+            QMessageBox.critical(self, "Layers", f"Merge failed:\n{ex}")
+
+    def _push_merged_as_new_doc(self, base_doc, arr: np.ndarray):
+        dm = getattr(self.mw, "docman", None)
+        if not dm or not hasattr(dm, "open_array"):
+            return
+
+        # Derive a friendly title based on the *view title* if possible
+        title = None
+        try:
+            # Use current view title (respects per-view rename)
+            vw = self.current_view()
+            if vw and hasattr(vw, "_effective_title"):
+                base = (vw._effective_title() or "").strip()
+            else:
+                base = ""
+
+            if not base:
+                dn = getattr(base_doc, "display_name", None)
+                base = dn() if callable(dn) else (dn or "Untitled")
+
+            suffix = "_merged"
+            title = base if base.endswith(suffix) else f"{base}{suffix}"
+        except Exception:
+            title = "Merged Layers"
+
+        try:
+            meta = dict(getattr(base_doc, "metadata", {}) or {})
+            meta.update({
+                "bit_depth": "32-bit floating point",
+                "is_mono": (arr.ndim == 2 or (arr.ndim == 3 and arr.shape[-1] == 1)),
+                "source": "Layers Merge",
+                "step_name": "Layers Merge",
+            })
+
+            newdoc = dm.open_array(arr.astype(np.float32, copy=False), metadata=meta, title=title)
+            if hasattr(self.mw, "_spawn_subwindow_for"):
+                self.mw._spawn_subwindow_for(newdoc)
+        except Exception as ex:
+            print("[LayersDock] _push_merged_as_new_doc error:", ex)

setiastro/saspro/legacy/numba_utils.py

@@ -1,4 +1,4 @@
-#legacy.numba_utils.py
+#src.setiastro.saspro.legacy.numba_utils.py
 import numpy as np
 from numba import njit, prange
 from numba.typed import List
@@ -407,43 +407,7 @@ def normalize_flat_cfa_inplace(flat2d: np.ndarray, pattern: str, *, combine_gree
     flat2d[flat2d == 0] = 1.0
     return flat2d
 
-@njit(parallel=True, fastmath=True)
-def apply_flat_division_numba_2d(image, master_flat, master_bias=None):
-    """
-    Mono version: image.shape == (H,W)
-    """
-    if master_bias is not None:
-        master_flat = master_flat - master_bias
-        image = image - master_bias
-
-    median_flat = np.mean(master_flat)
-    height, width = image.shape
-
-    for y in prange(height):
-        for x in range(width):
-            image[y, x] /= (master_flat[y, x] / median_flat)
-
-    return image
-
-
-@njit(parallel=True, fastmath=True)
-def apply_flat_division_numba_3d(image, master_flat, master_bias=None):
-    """
-    Color version: image.shape == (H,W,C)
-    """
-    if master_bias is not None:
-        master_flat = master_flat - master_bias
-        image = image - master_bias
 
-    median_flat = np.mean(master_flat)
-    height, width, channels = image.shape
-
-    for y in prange(height):
-        for x in range(width):
-            for c in range(channels):
-                image[y, x, c] /= (master_flat[y, x, c] / median_flat)
-
-    return image
 
 @njit(parallel=True, fastmath=True)
 def _flat_div_2d(img, flat):
@@ -563,24 +527,37 @@ def apply_flat_division_numba_bayer_2d(image, master_flat, med4, pat_id):
     Bayer-aware mono division. image/master_flat are (H,W).
     med4 is [R,G1,G2,B] for that master_flat, pat_id in {0..3}.
     """
+    # parity index = (row&1)*2 + (col&1)
+    # med4 index order: 0=R, 1=G1, 2=G2, 3=B
+
+    # tables map parity_index -> med4 index
+    # parity_index: 0:(0,0) 1:(0,1) 2:(1,0) 3:(1,1)
+    if pat_id == 0:      # RGGB:  (0,0)R (0,1)G1 (1,0)G2 (1,1)B
+        t0, t1, t2, t3 = 0, 1, 2, 3
+    elif pat_id == 1:    # BGGR:  (0,0)B (0,1)G1 (1,0)G2 (1,1)R
+        t0, t1, t2, t3 = 3, 1, 2, 0
+    elif pat_id == 2:    # GRBG:  (0,0)G1 (0,1)R (1,0)B (1,1)G2
+        t0, t1, t2, t3 = 1, 0, 3, 2
+    else:                # GBRG:  (0,0)G1 (0,1)B (1,0)R (1,1)G2
+        t0, t1, t2, t3 = 1, 3, 0, 2
+
     H, W = image.shape
     for y in prange(H):
         y1 = y & 1
         for x in range(W):
             x1 = x & 1
-
-            # map parity->plane index
-            if pat_id == 0:      # RGGB: (0,0)R (0,1)G1 (1,0)G2 (1,1)B
-                pi = 0 if (y1==0 and x1==0) else 1 if (y1==0 and x1==1) else 2 if (y1==1 and x1==0) else 3
-            elif pat_id == 1:    # BGGR
-                pi = 3 if (y1==1 and x1==1) else 1 if (y1==0 and x1==1) else 2 if (y1==1 and x1==0) else 0
-            elif pat_id == 2:    # GRBG
-                pi = 1 if (y1==0 and x1==0) else 0 if (y1==0 and x1==1) else 3 if (y1==1 and x1==0) else 2
-            else:                # GBRG
-                pi = 1 if (y1==0 and x1==0) else 3 if (y1==0 and x1==1) else 0 if (y1==1 and x1==0) else 2
+            p = (y1 << 1) | x1  # 0..3
+            if p == 0:
+                pi = t0
+            elif p == 1:
+                pi = t1
+            elif p == 2:
+                pi = t2
+            else:
+                pi = t3
 
             denom = master_flat[y, x] / med4[pi]
-            if denom == 0.0 or not np.isfinite(denom):
+            if denom == 0.0 or (not np.isfinite(denom)):
                 denom = 1.0
             image[y, x] /= denom
     return image
@@ -2790,7 +2767,50 @@ def evaluate_polynomial(H: int, W: int, coeffs: np.ndarray, degree: int) -> np.n
     A_full = build_poly_terms(xx.ravel(), yy.ravel(), degree)
     return (A_full @ coeffs).reshape(H, W)
 
+@njit(parallel=True, fastmath=True)
+def numba_mono_from_img(img, bp, denom, median_rescaled, target_median):
+    H, W = img.shape
+    out = np.empty_like(img)
+    for y in prange(H):
+        for x in range(W):
+            r = (img[y, x] - bp) / denom
+            numer = (median_rescaled - 1.0) * target_median * r
+            denom2 = median_rescaled * (target_median + r - 1.0) - target_median * r
+            if abs(denom2) < 1e-12:
+                denom2 = 1e-12
+            out[y, x] = numer / denom2
+    return out
 
+@njit(parallel=True, fastmath=True)
+def numba_color_linked_from_img(img, bp, denom, median_rescaled, target_median):
+    H, W, C = img.shape
+    out = np.empty_like(img)
+    for y in prange(H):
+        for x in range(W):
+            for c in range(C):
+                r = (img[y, x, c] - bp) / denom
+                numer = (median_rescaled - 1.0) * target_median * r
+                denom2 = median_rescaled * (target_median + r - 1.0) - target_median * r
+                if abs(denom2) < 1e-12:
+                    denom2 = 1e-12
+                out[y, x, c] = numer / denom2
+    return out
+
+@njit(parallel=True, fastmath=True)
+def numba_color_unlinked_from_img(img, bp3, denom3, meds_rescaled3, target_median):
+    H, W, C = img.shape
+    out = np.empty_like(img)
+    for y in prange(H):
+        for x in range(W):
+            for c in range(C):
+                r = (img[y, x, c] - bp3[c]) / denom3[c]
+                med = meds_rescaled3[c]
+                numer = (med - 1.0) * target_median * r
+                denom2 = med * (target_median + r - 1.0) - target_median * r
+                if abs(denom2) < 1e-12:
+                    denom2 = 1e-12
+                out[y, x, c] = numer / denom2
+    return out
 
 @njit(parallel=True, fastmath=True)
 def numba_mono_final_formula(rescaled, median_rescaled, target_median):