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

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

setiastro/saspro/layers_dock.py

@@ -8,19 +8,141 @@ from PyQt6.QtCore import Qt, pyqtSignal, QByteArray, QTimer
 from PyQt6.QtWidgets import (
     QDockWidget, QWidget, QVBoxLayout, QHBoxLayout, QLabel, QComboBox,
     QListWidget, QListWidgetItem, QAbstractItemView, QSlider, QCheckBox,
-    QPushButton, QFrame, QMessageBox
+    QPushButton, QFrame, QMessageBox,QDialog, QFormLayout, QDoubleSpinBox, QDialogButtonBox
 )
 from PyQt6.QtGui import QIcon, QDragEnterEvent, QDropEvent, QPixmap, QCursor
 
+from setiastro.saspro.layers import LayerTransform
 from setiastro.saspro.dnd_mime import MIME_VIEWSTATE, MIME_MASK
 from setiastro.saspro.layers import composite_stack, ImageLayer, BLEND_MODES
 
+class _TransformDialog(QDialog):
+    """
+    Live-preview transform dialog.
+    - Updates the layer transform as the user edits values (debounced).
+    - Cancel restores original transform.
+    - OK keeps current previewed transform.
+    """
+    def __init__(self, parent=None, *, t: LayerTransform | None = None,
+                 apply_cb=None, cancel_cb=None, debounce_ms: int = 200):
+        super().__init__(parent)
+        self.setWindowTitle("Layer Transform")
+        self.setModal(True)
+
+        self._apply_cb = apply_cb
+        self._cancel_cb = cancel_cb
+
+        self._t0 = t or LayerTransform()
+        # snapshot original so Cancel can revert even if layer mutated live
+        self._orig = LayerTransform(
+            tx=float(self._t0.tx), ty=float(self._t0.ty),
+            rot_deg=float(self._t0.rot_deg),
+            sx=float(self._t0.sx), sy=float(self._t0.sy),
+            pivot_x=self._t0.pivot_x, pivot_y=self._t0.pivot_y,
+        )
+
+        # debounce timer
+        self._tmr = QTimer(self)
+        self._tmr.setSingleShot(True)
+        self._tmr.timeout.connect(self._apply_live)
+        self._debounce_ms = int(debounce_ms)
+
+        lay = QVBoxLayout(self)
+        form = QFormLayout()
+        lay.addLayout(form)
+
+        def mk_spin(minv, maxv, step, dec, val):
+            s = QDoubleSpinBox(self)
+            s.setRange(minv, maxv)
+            s.setSingleStep(step)
+            s.setDecimals(dec)
+            s.setValue(float(val))
+            return s
+
+        self.tx = mk_spin(-100000, 100000, 1.0, 2, self._t0.tx)
+        self.ty = mk_spin(-100000, 100000, 1.0, 2, self._t0.ty)
+        self.rot = mk_spin(-3600, 3600, 0.1, 3, self._t0.rot_deg)
+        self.sx = mk_spin(0.001, 1000.0, 0.01, 4, self._t0.sx)
+        self.sy = mk_spin(0.001, 1000.0, 0.01, 4, self._t0.sy)
+
+        form.addRow("Translate X (px)", self.tx)
+        form.addRow("Translate Y (px)", self.ty)
+        form.addRow("Rotate (deg)", self.rot)
+        form.addRow("Scale X", self.sx)
+        form.addRow("Scale Y", self.sy)
+
+        # Buttons
+        btns = QDialogButtonBox(
+            QDialogButtonBox.StandardButton.Ok |
+            QDialogButtonBox.StandardButton.Cancel,
+            parent=self
+        )
+        lay.addWidget(btns)
+
+        self.btn_reset = QPushButton("Reset")
+        btns.addButton(self.btn_reset, QDialogButtonBox.ButtonRole.ResetRole)
+
+        btns.accepted.connect(self.accept)
+        btns.rejected.connect(self.reject)
+        self.btn_reset.clicked.connect(self._reset)
+
+        # Any value change triggers debounced live preview
+        for w in (self.tx, self.ty, self.rot, self.sx, self.sy):
+            w.valueChanged.connect(self._schedule_live)
+
+        # Apply initial once so opening dialog matches actual preview
+        self._schedule_live()
+
+    def _reset(self):
+        self.tx.setValue(0.0)
+        self.ty.setValue(0.0)
+        self.rot.setValue(0.0)
+        self.sx.setValue(1.0)
+        self.sy.setValue(1.0)
+        self._schedule_live()
+
+    def _schedule_live(self, *_):
+        # restart debounce
+        self._tmr.start(self._debounce_ms)
+
+    def _current_transform(self) -> LayerTransform:
+        return LayerTransform(
+            tx=float(self.tx.value()),
+            ty=float(self.ty.value()),
+            rot_deg=float(self.rot.value()),
+            sx=float(self.sx.value()),
+            sy=float(self.sy.value()),
+            pivot_x=None,
+            pivot_y=None,
+        )
+
+    def _apply_live(self):
+        if callable(self._apply_cb):
+            self._apply_cb(self._current_transform())
+
+    def reject(self):
+        # Cancel: restore original, then close
+        if callable(self._cancel_cb):
+            self._cancel_cb(self._orig)
+        super().reject()
+
+    def accept(self):
+        # OK: ensure latest values are applied (in case debounce pending)
+        try:
+            if self._tmr.isActive():
+                self._tmr.stop()
+        except Exception:
+            pass
+        self._apply_live()
+        super().accept()
+
 # ---------- Small row widget for a layer ----------
 class _LayerRow(QWidget):
     changed = pyqtSignal()
     requestDelete = pyqtSignal()
     moveUp = pyqtSignal()
     moveDown = pyqtSignal()
+    requestTransform = pyqtSignal()
 
     def __init__(self, name: str, mode: str = "Normal", opacity: float = 1.0,
                  visible: bool = True, parent=None, *, is_base: bool = False):
@@ -41,9 +163,10 @@ class _LayerRow(QWidget):
         self.btn_up = QPushButton("↑"); self.btn_up.setFixedWidth(28)
         self.btn_dn = QPushButton("↓"); self.btn_dn.setFixedWidth(28)
         self.btn_x  = QPushButton("✕"); self.btn_x.setFixedWidth(28)
-
+        self.btn_tf = QPushButton("Transform…")
+        self.btn_tf.setFixedWidth(92)
         r1.addWidget(self.chk); r1.addWidget(self.lbl, 1)
-        r1.addWidget(self.mode); r1.addWidget(QLabel("Opacity")); r1.addWidget(self.sld, 1)
+        r1.addWidget(self.mode); r1.addWidget(QLabel("Opacity")); r1.addWidget(self.sld, 1); r1.addWidget(self.btn_tf)
         r1.addWidget(self.btn_up); r1.addWidget(self.btn_dn); r1.addWidget(self.btn_x)
 
         # row 2: mask controls (hidden for base)
@@ -89,7 +212,7 @@ class _LayerRow(QWidget):
 
         if self._is_base:
             # Base row is informational only
-            for w in (self.chk, self.mode, self.sld, self.btn_up, self.btn_dn, self.btn_x,
+            for w in (self.chk, self.mode, self.sld, self.btn_up, self.btn_tf, self.btn_dn, self.btn_x,
                       self.mask_combo, self.mask_invert, self.btn_clear_mask):
                 w.setEnabled(False)
             self.lbl.setStyleSheet("color: palette(mid);")
@@ -104,6 +227,8 @@ class _LayerRow(QWidget):
             self.btn_up.clicked.connect(self.moveUp.emit)
             self.btn_dn.clicked.connect(self.moveDown.emit)
 
+            self.btn_tf.clicked.connect(self.requestTransform.emit)
+
             # Sigmoid controls emit change + only show for Sigmoid mode
             if self.sig_center is not None:
                 self.sig_center.valueChanged.connect(self._emit)
@@ -116,6 +241,17 @@ class _LayerRow(QWidget):
             # Initial visibility
             self._update_extra_controls(self.mode.currentText())
 
+    def setTransformDirty(self, dirty: bool):
+        if hasattr(self, "btn_tf") and self.btn_tf is not None:
+            self.btn_tf.setText("Transform… *" if dirty else "Transform…")
+
+
+    def _on_transform_clicked(self):
+        # Let the dock handle it; row doesn't own the layer object
+        self.changed.emit()  # (no-op, but keeps pattern)
+        # We'll have the dock connect this via a custom signal (see next step).
+
+
     def _on_mode_changed(self, _idx: int):
         # Update which extra controls are visible
         self._update_extra_controls(self.mode.currentText())
@@ -420,7 +556,12 @@ class LayersDock(QDockWidget):
             it.setSizeHint(roww.sizeHint())
             self.list.addItem(it)
             self.list.setItemWidget(it, roww)
-
+            t = getattr(lyr, "transform", None)
+            dirty = False
+            if t is not None:
+                dirty = (abs(t.tx) > 1e-6 or abs(t.ty) > 1e-6 or abs(t.rot_deg) > 1e-6 or
+                        abs(t.sx - 1.0) > 1e-6 or abs(t.sy - 1.0) > 1e-6)
+            roww.setTransformDirty(dirty)
         base_name = getattr(vw, "_effective_title", None)
         base_name = base_name() if callable(base_name) else "Current View"
         base_label = f"Base • {base_name}"
@@ -545,6 +686,58 @@ class LayersDock(QDockWidget):
         roww.requestDelete.connect(lambda: self._delete_row(roww))
         roww.moveUp.connect(lambda: self._move_row(roww, -1))
         roww.moveDown.connect(lambda: self._move_row(roww, +1))
+        roww.requestTransform.connect(lambda rw=roww: self._edit_transform_for_row(rw))
+
+    def _edit_transform_for_row(self, roww: _LayerRow):
+        vw = self.current_view()
+        if not vw:
+            return
+        idx = self._find_row_index(roww)
+        if idx < 0 or idx >= self._layer_count():
+            return
+
+        lyr = vw._layers[idx]
+
+        # Ensure transform exists
+        t = getattr(lyr, "transform", None)
+        if t is None:
+            t = LayerTransform()
+            lyr.transform = t
+
+        # Helper: apply transform + refresh preview
+        def _apply_t(new_t: LayerTransform):
+            lyr.transform = new_t
+            # update the row star immediately (optional)
+            dirty = (abs(new_t.tx) > 1e-6 or abs(new_t.ty) > 1e-6 or abs(new_t.rot_deg) > 1e-6 or
+                    abs(new_t.sx - 1.0) > 1e-6 or abs(new_t.sy - 1.0) > 1e-6)
+            try:
+                roww.setTransformDirty(dirty)
+            except Exception:
+                pass
+
+            # Live preview refresh
+            vw.apply_layer_stack(vw._layers)
+
+        # Helper: cancel revert
+        def _cancel_revert(orig_t: LayerTransform):
+            lyr.transform = orig_t
+            dirty = (abs(orig_t.tx) > 1e-6 or abs(orig_t.ty) > 1e-6 or abs(orig_t.rot_deg) > 1e-6 or
+                    abs(orig_t.sx - 1.0) > 1e-6 or abs(orig_t.sy - 1.0) > 1e-6)
+            try:
+                roww.setTransformDirty(dirty)
+            except Exception:
+                pass
+            vw.apply_layer_stack(vw._layers)
+
+        dlg = _TransformDialog(
+            self,
+            t=lyr.transform,
+            apply_cb=_apply_t,
+            cancel_cb=_cancel_revert,
+            debounce_ms=200,   # tweak 150–300
+        )
+        dlg.exec()
+
 
     def _apply_list_to_view_debounced(self):
         # restart the timer on every slider tick

setiastro/saspro/legacy/image_manager.py

@@ -2007,7 +2007,8 @@ def save_image(img_array,
                is_mono=False,
                image_meta=None,
                file_meta=None,
-               wcs_header=None):   # 🔥 NEW
+               wcs_header=None, 
+               jpeg_quality: int | None = None):  
     """
     Save an image array to a file in the specified format and bit depth.
     - Robust to mis-ordered positional args (header/bit_depth swap).
@@ -2060,9 +2061,14 @@ def save_image(img_array,
 
         if fmt == "jpg":
             img = Image.fromarray((np.clip(img_array, 0, 1) * 255).astype(np.uint8))
-            # You can pass quality=95, subsampling=0 if you want
-            img.save(filename)
-            print(f"Saved 8-bit JPG image to: {filename}")
+
+            q = 95 if jpeg_quality is None else int(jpeg_quality)
+            q = max(1, min(100, q))
+
+            # subsampling=0 keeps best chroma quality; optimize can reduce size a bit
+            img.save(filename, quality=q, subsampling=0, optimize=True)
+
+            print(f"Saved 8-bit JPG image to: {filename} (quality={q})")
             return
 
         # ---------------------------------------------------------------------

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

setiastro/saspro/live_stacking.py

@@ -1328,7 +1328,23 @@ class LiveStackWindow(QDialog):
                 QApplication.processEvents()
         finally:
             self._poll_busy = False
-            
+
+    def _match_master_to_image(self, master: np.ndarray, img: np.ndarray) -> np.ndarray:
+        """
+        Coerce master (dark/flat) to match img dimensionality.
+        - If img is RGB (H,W,3) and master is mono (H,W), expand to (H,W,1).
+        - If img is mono (H,W) and master is RGB (H,W,3), collapse to mono via mean.
+        """
+        if master is None:
+            return None
+
+        if img.ndim == 3 and master.ndim == 2:
+            return master[..., None]  # (H,W,1) broadcasts to (H,W,3)
+        if img.ndim == 2 and master.ndim == 3:
+            return master.mean(axis=2)  # (H,W)
+        return master
+
+
     def process_frame(self, path):
         if self._should_stop():
             return        
@@ -1422,12 +1438,16 @@ class LiveStackWindow(QDialog):
 
         # ——— 2b) CALIBRATION (once) ————————————————————————
         if self.master_dark is not None:
-            img = img.astype(np.float32) - self.master_dark
+            md = self._match_master_to_image(self.master_dark, img).astype(np.float32, copy=False)
+            img = img.astype(np.float32, copy=False) - md
         # prefer per-filter flat if we’re in mono→color and have one
         if mono_key and mono_key in self.master_flats:
-            img = apply_flat_division_numba(img, self.master_flats[mono_key])
+            mf = self._match_master_to_image(self.master_flats[mono_key], img).astype(np.float32, copy=False)
+            img = apply_flat_division_numba(img, mf)
         elif self.master_flat is not None:
-            img = apply_flat_division_numba(img, self.master_flat)
+            mf = self._match_master_to_image(self.master_flat, img).astype(np.float32, copy=False)
+            img = apply_flat_division_numba(img, mf)
+
 
         if self._should_stop():
             return