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

setiastro/saspro/isophote.py

@@ -363,6 +363,10 @@ class IsophoteModelerDialog(QDialog):
         self.setWindowFlag(Qt.WindowType.Window, True)
         self.setWindowModality(Qt.WindowModality.NonModal)
         self.setModal(False)
+        try:
+            self.setAttribute(Qt.WidgetAttribute.WA_DeleteOnClose, True)
+        except Exception:
+            pass  # older PyQt6 versions        
         self.image_manager = image_manager
         self.doc_manager   = doc_manager
 

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/image_manager.py

@@ -986,6 +986,124 @@ def _fill_hdr_from_raw_metadata(raw, hdr: fits.Header | None = None) -> fits.Hea
 
 from astropy.wcs import WCS
 
+import ast
+
+def _coerce_fits_value(v):
+    if v is None:
+        return None
+    if isinstance(v, (int, float, bool)):
+        return v
+    s = str(v).strip()
+
+    # PixInsight T/F
+    if s in ("T", "TRUE", "True", "true"):
+        return True
+    if s in ("F", "FALSE", "False", "false"):
+        return False
+
+    # int?
+    try:
+        if s.isdigit() or (s.startswith(("+", "-")) and s[1:].isdigit()):
+            return int(s)
+    except Exception:
+        pass
+
+    # float? (handles 8.9669e+03 etc)
+    try:
+        return float(s)
+    except Exception:
+        pass
+
+    # strip quotes
+    if len(s) >= 2 and s[0] == s[-1] and s[0] in ("'", '"'):
+        s = s[1:-1]
+    return s
+
+
+def xisf_fits_header_from_meta(image_meta: dict, file_meta: dict | None = None) -> fits.Header:
+    """
+    Robustly extract FITSKeywords from XISF wrappers matching your real structure.
+
+    Handles:
+      - image_meta["FITSKeywords"]
+      - image_meta["xisf_meta"]["FITSKeywords"]
+      - image_meta["xisf_meta"] as a stringified dict containing FITSKeywords
+      - file_meta FITSKeywords (only fills missing keys)
+    """
+    hdr = fits.Header()
+
+    def _get_kw_dict(meta: dict):
+        if not isinstance(meta, dict):
+            return None
+
+        # direct
+        kw = meta.get("FITSKeywords")
+        if isinstance(kw, dict):
+            return kw
+
+        # nested dict
+        xm = meta.get("xisf_meta")
+        if isinstance(xm, dict):
+            kw = xm.get("FITSKeywords")
+            if isinstance(kw, dict):
+                return kw
+
+        # stringified dict
+        if isinstance(xm, str) and "FITSKeywords" in xm:
+            try:
+                xm2 = ast.literal_eval(xm)
+                if isinstance(xm2, dict) and isinstance(xm2.get("FITSKeywords"), dict):
+                    return xm2["FITSKeywords"]
+            except Exception:
+                pass
+
+        return None
+
+    def _apply_kw_dict(kw: dict, only_missing: bool):
+        for key, entries in kw.items():
+            try:
+                k = str(key).strip()
+                if not k:
+                    continue
+                if only_missing and (k in hdr):
+                    continue
+
+                # your structure: KEY: [ {"value": "...", "comment": "..."} ]
+                val = None
+                com = None
+                if isinstance(entries, list) and entries:
+                    e0 = entries[0]
+                    if isinstance(e0, dict):
+                        val = _coerce_fits_value(e0.get("value"))
+                        com = e0.get("comment")
+                    else:
+                        val = _coerce_fits_value(e0)
+                elif isinstance(entries, dict):
+                    val = _coerce_fits_value(entries.get("value"))
+                    com = entries.get("comment")
+                else:
+                    val = _coerce_fits_value(entries)
+
+                if com is not None:
+                    hdr[k] = (val, str(com))
+                else:
+                    hdr[k] = val
+            except Exception:
+                pass
+
+    # First: image-level FITSKeywords (authoritative)
+    kw_img = _get_kw_dict(image_meta) or {}
+    if isinstance(kw_img, dict):
+        _apply_kw_dict(kw_img, only_missing=False)
+
+    # Then: file-level FITSKeywords (fill gaps only)
+    kw_file = _get_kw_dict(file_meta or {}) or {}
+    if isinstance(kw_file, dict):
+        _apply_kw_dict(kw_file, only_missing=True)
+
+    return hdr
+
+
 def attach_wcs_to_metadata(meta: dict, hdr: fits.Header | dict | None) -> dict:
     """
     If hdr contains WCS, create an astropy.wcs.WCS and stash in metadata.
@@ -1378,7 +1496,7 @@ def load_image(filename, max_retries=3, wait_seconds=3, return_metadata: bool =
 
                 # ─── Build FITS header from PixInsight XISFProperties ─────────────────
                 # ─── Build FITS header from XISFProperties, then fallback to FITSKeywords & Pixel‐Scale ─────────────────
-                props = image_meta.get('XISFProperties', {})
+
                 def _dump_astrometric_keys(props, image_meta, file_meta):
                     print("🔎 [XISF] XISFProperties AstrometricSolution-related keys:")
                     for k in sorted(props.keys()):
@@ -1395,31 +1513,47 @@ def load_image(filename, max_retries=3, wait_seconds=3, return_metadata: bool =
 
                     _dump_fk(image_meta, "image_meta")
                     _dump_fk(file_meta, "file_meta")          
-                #_dump_astrometric_keys(props, image_meta, file_meta)          
-                hdr   = fits.Header()
-                _filled = set()
+                # Build base header from FITSKeywords (typed) first
+                hdr = xisf_fits_header_from_meta(image_meta, file_meta)   # your new helper
+                _filled = set(hdr.keys())
+
+                # Now get XISFProperties (for PI grids + fallback)
+                props = (image_meta.get("XISFProperties", {}) or
+                        file_meta.get("XISFProperties", {}) or {})
+                #_filled = set()
 
-                # 1) PixInsight astrometric solution
+                # 1) PixInsight astrometric solution (fallback only)
+                # 1) PixInsight astrometric solution (fallback only)
                 try:
-                    im0, im1 = props['PCL:AstrometricSolution:ReferenceImageCoordinates']['value']
-                    w0,  w1  = props['PCL:AstrometricSolution:ReferenceCelestialCoordinates']['value']
-                    hdr['CRPIX1'], hdr['CRPIX2'] = float(im0), float(im1)
-                    hdr['CRVAL1'], hdr['CRVAL2'] = float(w0), float(w1)
-                    hdr['CTYPE1'], hdr['CTYPE2'] = 'RA---TAN-SIP','DEC--TAN-SIP'
-                    _filled |= {'CRPIX1','CRPIX2','CRVAL1','CRVAL2','CTYPE1','CTYPE2'}
-                    print("🔷 Injected CRPIX/CRVAL from XISFProperties")
+                    if not all(k in hdr for k in ("CRPIX1","CRPIX2","CRVAL1","CRVAL2")):
+                        ref_img = props['PCL:AstrometricSolution:ReferenceImageCoordinates']['value']
+                        ref_sky = props['PCL:AstrometricSolution:ReferenceCelestialCoordinates']['value']
+
+                        # Some files store extra values; only first two are CRPIX/CRVAL
+                        im0, im1 = float(ref_img[0]), float(ref_img[1])
+                        w0,  w1  = float(ref_sky[0]), float(ref_sky[1])
+
+                        hdr['CRPIX1'], hdr['CRPIX2'] = im0, im1
+                        hdr['CRVAL1'], hdr['CRVAL2'] = w0, w1
+                        hdr.setdefault('CTYPE1', 'RA---TAN-SIP')
+                        hdr.setdefault('CTYPE2', 'DEC--TAN-SIP')
+                        _filled |= {'CRPIX1','CRPIX2','CRVAL1','CRVAL2','CTYPE1','CTYPE2'}
+                        print("🔷 Injected CRPIX/CRVAL from XISFProperties (fallback)")
                 except KeyError:
-                    print("⚠️ Missing reference coords in XISFProperties")
+                    pass
+                except Exception as e:
+                    print(f"⚠️ XISFProperties CRPIX/CRVAL parse failed; skipping. Reason: {e}")
 
-                # 2) CD matrix
+                # 2) CD matrix (fallback only)
                 try:
-                    lin = np.asarray(props['PCL:AstrometricSolution:LinearTransformationMatrix']['value'], float)
-                    hdr['CD1_1'], hdr['CD1_2'] = lin[0,0], lin[0,1]
-                    hdr['CD2_1'], hdr['CD2_2'] = lin[1,0], lin[1,1]
-                    _filled |= {'CD1_1','CD1_2','CD2_1','CD2_2'}
-                    print("🔷 Injected CD matrix from XISFProperties")
+                    if not all(k in hdr for k in ("CD1_1","CD1_2","CD2_1","CD2_2")):
+                        lin = np.asarray(props['PCL:AstrometricSolution:LinearTransformationMatrix']['value'], float)
+                        hdr['CD1_1'], hdr['CD1_2'] = float(lin[0,0]), float(lin[0,1])
+                        hdr['CD2_1'], hdr['CD2_2'] = float(lin[1,0]), float(lin[1,1])
+                        _filled |= {'CD1_1','CD1_2','CD2_1','CD2_2'}
+                        print("🔷 Injected CD matrix from XISFProperties (fallback)")
                 except KeyError:
-                    print("⚠️ Missing CD matrix in XISFProperties")
+                    pass
 
                 # 3) SIP polynomial fitting  (CORRECTED for PI ImageToNative grids)
                 def _try_inject_sip_from_fitskeywords(hdr, image_meta, file_meta):

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):