setiastrosuitepro 1.6.8__tar.gz → 1.6.9__tar.gz

{setiastrosuitepro-1.6.8 → setiastrosuitepro-1.6.9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: setiastrosuitepro
-Version: 1.6.8
+Version: 1.6.9
 Summary: Seti Astro Suite Pro - Advanced astrophotography toolkit for image calibration, stacking, registration, photometry, and visualization
 License: GPL-3.0
 License-File: LICENSE

{setiastrosuitepro-1.6.8 → setiastrosuitepro-1.6.9}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "setiastrosuitepro"
-version = "1.6.8"
+version = "1.6.9"
 description = "Seti Astro Suite Pro - Advanced astrophotography toolkit for image calibration, stacking, registration, photometry, and visualization"
 authors = ["Franklin Marek <info@setiastro.com>"]
 readme = "README.md"

setiastrosuitepro-1.6.9/src/setiastro/saspro/_generated/build_info.py

@@ -0,0 +1,3 @@
+# Auto-generated at build time. Do not edit.
+BUILD_TIMESTAMP = "2026-01-02T21:35:46Z"
+APP_VERSION = "1.6.9"

{setiastrosuitepro-1.6.8 → setiastrosuitepro-1.6.9}/src/setiastro/saspro/blink_comparator_pro.py

@@ -150,7 +150,6 @@ class MetricsPanel(QWidget):
         orig_back = entry.get('orig_background', np.nan)
         return idx, fwhm, ecc, orig_back, star_cnt
 
-
     def compute_all_metrics(self, loaded_images) -> bool:
         """Run SEP over the full list in parallel using threads and cache results.
         Returns True if metrics were computed, False if user declined/canceled.
@@ -163,71 +162,109 @@ class MetricsPanel(QWidget):
             self._threshold_initialized = [False] * 4
             return True
 
+        def _has_metrics(md):
+            try:
+                return md is not None and len(md) == 4 and md[0] is not None and len(md[0]) > 0
+            except Exception:
+                return False
+
         settings = QSettings()
-        show = settings.value("metrics/showWarning", True, type=bool)
-        if show:
+        show_warning = settings.value("metrics/showWarning", True, type=bool)
+
+        if (not show_warning) and (not _has_metrics(getattr(self, "metrics_data", None))):
+            settings.setValue("metrics/showWarning", True)
+            show_warning = True
+
+        # ----------------------------
+        # 1) Optional warning gate
+        # ----------------------------
+        if show_warning:
             msg = QMessageBox(self)
             msg.setWindowTitle(self.tr("Heads-up"))
             msg.setText(self.tr(
                 "This is going to use ALL your CPU cores and the UI may lock up until it finishes.\n\n"
                 "Continue?"
             ))
-            msg.setStandardButtons(QMessageBox.StandardButton.Yes |
-                                QMessageBox.StandardButton.No)
+            msg.setStandardButtons(
+                QMessageBox.StandardButton.Yes | QMessageBox.StandardButton.No
+            )
             cb = QCheckBox(self.tr("Don't show again"), msg)
             msg.setCheckBox(cb)
 
-            if msg.exec() != QMessageBox.StandardButton.Yes:
-                # IMPORTANT: leave caches alone; caller (plot) will clear/return
+            clicked = msg.exec()
+            clicked_yes = (clicked == QMessageBox.StandardButton.Yes)
+
+            if not clicked_yes:
+                # If they said NO, never allow "Don't show again" to lock them out.
+                # Keep the warning enabled so they can opt-in later.
+                if cb.isChecked():
+                    settings.setValue("metrics/showWarning", True)
                 return False
 
+            # They said YES: now it's safe to honor "Don't show again"
             if cb.isChecked():
                 settings.setValue("metrics/showWarning", False)
 
-            # pre-allocate result arrays
-            m0 = np.full(n, np.nan, dtype=np.float32)  # FWHM
-            m1 = np.full(n, np.nan, dtype=np.float32)  # Eccentricity
-            m2 = np.full(n, np.nan, dtype=np.float32)  # Background (cached)
-            m3 = np.full(n, np.nan, dtype=np.float32)  # Star count
-            flags = [e.get('flagged', False) for e in loaded_images]
-
-            # progress dialog
-            prog = QProgressDialog(self.tr("Computing frame metrics…"), self.tr("Cancel"), 0, n, self)
-            prog.setWindowModality(Qt.WindowModality.WindowModal)
-            prog.setMinimumDuration(0)
-            prog.setValue(0)
-            prog.show()
-            QApplication.processEvents()
+        # If show_warning is False, we compute with no prompt.
+
+        # ----------------------------
+        # 2) Allocate result arrays
+        # ----------------------------
+        m0 = np.full(n, np.nan, dtype=np.float32)  # FWHM
+        m1 = np.full(n, np.nan, dtype=np.float32)  # Eccentricity
+        m2 = np.full(n, np.nan, dtype=np.float32)  # Background (cached)
+        m3 = np.full(n, np.nan, dtype=np.float32)  # Star count
+        flags = [e.get('flagged', False) for e in loaded_images]
+
+        # ----------------------------
+        # 3) Progress dialog
+        # ----------------------------
+        prog = QProgressDialog(self.tr("Computing frame metrics…"), self.tr("Cancel"), 0, n, self)
+        prog.setWindowModality(Qt.WindowModality.WindowModal)
+        prog.setMinimumDuration(0)
+        prog.setValue(0)
+        prog.show()
+        QApplication.processEvents()
 
-            workers = min(os.cpu_count() or 1, 60)
-            tasks = [(i, loaded_images[i]) for i in range(n)]
-            done = 0  # <-- FIX: initialize before incrementing
+        workers = min(os.cpu_count() or 1, 60)
+        tasks = [(i, loaded_images[i]) for i in range(n)]
+        done = 0
+        canceled = False
 
-            try:
-                with ThreadPoolExecutor(max_workers=workers) as exe:
-                    futures = {exe.submit(self._compute_one, t): t[0] for t in tasks}
-                    for fut in as_completed(futures):
-                        if prog.wasCanceled():
-                            break
-                        try:
-                            idx, fwhm, ecc, orig_back, star_cnt = fut.result()
-                        except Exception:
-                            # On failure, leave NaNs/sentinels and continue
-                            idx, fwhm, ecc, orig_back, star_cnt = futures[fut], np.nan, np.nan, np.nan, 0
+        try:
+            with ThreadPoolExecutor(max_workers=workers) as exe:
+                futures = {exe.submit(self._compute_one, t): t[0] for t in tasks}
+                for fut in as_completed(futures):
+                    if prog.wasCanceled():
+                        canceled = True
+                        break
+                    try:
+                        idx, fwhm, ecc, orig_back, star_cnt = fut.result()
+                    except Exception:
+                        idx = futures.get(fut, 0)
+                        fwhm, ecc, orig_back, star_cnt = np.nan, np.nan, np.nan, 0
+
+                    if 0 <= idx < n:
                         m0[idx], m1[idx], m2[idx], m3[idx] = fwhm, ecc, orig_back, float(star_cnt)
-                        done += 1
-                        prog.setValue(done)
-                        QApplication.processEvents()
-            finally:
-                prog.close()
 
-            # stash results
-            self._orig_images = loaded_images
-            self.metrics_data = [m0, m1, m2, m3]
-            self.flags = flags
-            self._threshold_initialized = [False] * 4
-            return True
+                    done += 1
+                    prog.setValue(done)
+                    QApplication.processEvents()
+        finally:
+            prog.close()
+
+        if canceled:
+            # IMPORTANT: leave caches alone; caller will clear/return
+            return False
 
+        # ----------------------------
+        # 4) Stash results
+        # ----------------------------
+        self._orig_images = loaded_images
+        self.metrics_data = [m0, m1, m2, m3]
+        self.flags = flags
+        self._threshold_initialized = [False] * 4
+        return True
 
     def plot(self, loaded_images, indices=None):
         """

{setiastrosuitepro-1.6.8 → setiastrosuitepro-1.6.9}/src/setiastro/saspro/crop_dialog_pro.py

@@ -58,7 +58,8 @@ class ResizableRotatableRectItem(QGraphicsRectItem):
         self._rotating = False
         self._angle0 = 0.0
         self._pivot_scene = QPointF()
-
+        self._bounds_scene: QRectF | None = None
+        self._clamp_eps_deg = 0.25  # treat as "unrotated" if |angle| < eps (deg)
         self._grab_pad = 20              # ← extra hit slop in screen px
         self._edge_pad_px = EDGE_GRAB_PX
         self.setZValue(100)             # ← keep above pixmap
@@ -83,7 +84,26 @@ class ResizableRotatableRectItem(QGraphicsRectItem):
         dx = p1.x() - p0.x()
         dy = p1.y() - p0.y()
         return math.hypot(dx, dy)
-
+    def setBoundsSceneRect(self, r: QRectF | None):
+        """Set the scene-rect bounds we should stay within when unrotated."""
+        self._bounds_scene = QRectF(r) if r is not None else None
+
+    def _is_unrotated(self) -> bool:
+        # normalize angle to [-180, 180]
+        a = float(self.rotation()) % 360.0
+        if a > 180.0:
+            a -= 360.0
+        return abs(a) < self._clamp_eps_deg
+
+    def _bounds_local(self) -> QRectF | None:
+        """Bounds rect mapped into the item's local coordinates (only valid when unrotated)."""
+        if self._bounds_scene is None:
+            return None
+        # When unrotated, this is safe and stable.
+        tl = self.mapFromScene(self._bounds_scene.topLeft())
+        br = self.mapFromScene(self._bounds_scene.bottomRight())
+        return QRectF(tl, br).normalized()
+    
     def _edge_under_cursor(self, scene_pos: QPointF) -> Optional[str]:
         """
         Return 'l', 'r', 't', or 'b' if the pointer is near an edge (within px-tolerance),
@@ -218,12 +238,52 @@ class ResizableRotatableRectItem(QGraphicsRectItem):
             QGraphicsItem.GraphicsItemChange.ItemTransformHasChanged,
         ):
             self._sync_handles()
+
+        if change == QGraphicsItem.GraphicsItemChange.ItemPositionChange:
+            if self._bounds_scene is not None and self._is_unrotated():
+                new_pos = QPointF(value)
+
+                # current scene rect of the item (at current pos)
+                sr0 = self.mapRectToScene(self.rect())  # QRectF in scene coords
+
+                # shift it by the delta between proposed pos and current pos
+                d = new_pos - self.pos()
+                sr = sr0.translated(d)
+
+                b = self._bounds_scene
+                dx = 0.0
+                dy = 0.0
+
+                if sr.left() < b.left():
+                    dx = b.left() - sr.left()
+                elif sr.right() > b.right():
+                    dx = b.right() - sr.right()
+
+                if sr.top() < b.top():
+                    dy = b.top() - sr.top()
+                elif sr.bottom() > b.bottom():
+                    dy = b.bottom() - sr.bottom()
+
+                if dx != 0.0 or dy != 0.0:
+                    return new_pos + QPointF(dx, dy)
+
+                return new_pos
+
         return super().itemChange(change, value)
 
     def _resize_via_handle(self, scene_pt: QPointF):
         r = self.rect()
         p = self.mapFromScene(scene_pt)
 
+        # Clamp handle drag to bounds only when unrotated.
+        if self._bounds_scene is not None and self._is_unrotated():
+            bL = self._bounds_local()
+            if bL is not None:
+                # NOTE: bL is in the same local coordinate space as r/p.
+                px = min(max(p.x(), bL.left()),  bL.right())
+                py = min(max(p.y(), bL.top()),   bL.bottom())
+                p = QPointF(px, py)
+
         # Corners
         if   self._active == "tl": r.setTopLeft(p)
         elif self._active == "tr": r.setTopRight(p)
@@ -616,6 +676,7 @@ class CropDialogPro(QDialog):
                 if e.type() == QEvent.Type.MouseMove and self._drawing:
                     r = QRectF(self._origin, scene_pt).normalized()
                     r = self._apply_ar_to_rect(r, live=True, scene_pt=scene_pt)
+                    r = self._clamp_rect_to_pixmap(r)
                     self._draw_live_rect(r)
 
                     # ⬇️ live dims from the temporary rect (axis-aligned TL,TR,BR,BL)
@@ -627,9 +688,12 @@ class CropDialogPro(QDialog):
                     self._drawing = False
                     r = QRectF(self._origin, scene_pt).normalized()
                     r = self._apply_ar_to_rect(r, live=False, scene_pt=scene_pt)
+                    r = self._clamp_rect_to_pixmap(r)
                     self._clear_live_rect()
+
                     self._rect_item = ResizableRotatableRectItem(r)
                     self._rect_item.setZValue(10)
+                    self._rect_item.setBoundsSceneRect(self._bounds_scene_rect())
                     self._rect_item.setFixedAspectRatio(self._current_ar_value())
                     self.scene.addItem(self._rect_item)
 
@@ -715,6 +779,7 @@ class CropDialogPro(QDialog):
         if self._rect_item is None:
             self._rect_item = ResizableRotatableRectItem(r)
             self._rect_item.setZValue(10)
+            self._rect_item.setBoundsSceneRect(self._bounds_scene_rect())
             self.scene.addItem(self._rect_item)
         else:
             self._rect_item.setRotation(0.0)
@@ -758,6 +823,32 @@ class CropDialogPro(QDialog):
         if hasattr(self, "_live_rect") and self._live_rect:
             self.scene.removeItem(self._live_rect); self._live_rect = None
 
+    def _pixmap_scene_rect(self) -> QRectF | None:
+        """Scene rect occupied by the pixmap (image) item."""
+        if not self._pix_item:
+            return None
+        return self._pix_item.mapRectToScene(self._pix_item.boundingRect())
+
+    def _clamp_rect_to_pixmap(self, r: QRectF) -> QRectF:
+        """Intersect an axis-aligned QRectF with the pixmap scene rect."""
+        bounds = self._pixmap_scene_rect()
+        if bounds is None:
+            return r.normalized()
+        rr = r.normalized().intersected(bounds)
+        # avoid empty rects (keep at least 1x1 scene unit)
+        if rr.isNull() or rr.width() <= 1e-6 or rr.height() <= 1e-6:
+            # fallback: clamp to a 1x1 rect at the nearest point inside bounds
+            x = min(max(r.center().x(), bounds.left()),  bounds.right())
+            y = min(max(r.center().y(), bounds.top()),   bounds.bottom())
+            rr = QRectF(x, y, 1.0, 1.0)
+        return rr.normalized()
+
+    def _bounds_scene_rect(self) -> QRectF | None:
+        if not self._pix_item:
+            return None
+        return self._pix_item.mapRectToScene(self._pix_item.boundingRect())
+
+
     # ---------- preview toggles ----------
     def _toggle_autostretch(self):
         self._autostretch_on = not self._autostretch_on
@@ -777,6 +868,7 @@ class CropDialogPro(QDialog):
         r, ang, pos = state
         self._rect_item = ResizableRotatableRectItem(r)
         self._rect_item.setZValue(10)
+        self._rect_item.setBoundsSceneRect(self._bounds_scene_rect())
         self._rect_item.setFixedAspectRatio(self._current_ar_value())
         self._rect_item.setRotation(ang)
         self._rect_item.setPos(pos)
@@ -794,6 +886,7 @@ class CropDialogPro(QDialog):
         r = QRectF(CropDialogPro._prev_rect)
         self._rect_item = ResizableRotatableRectItem(r)
         self._rect_item.setZValue(10)
+        self._rect_item.setBoundsSceneRect(self._bounds_scene_rect())
         self._rect_item.setFixedAspectRatio(self._current_ar_value())
         self._rect_item.setRotation(CropDialogPro._prev_angle)
         self._rect_item.setPos(CropDialogPro._prev_pos)
@@ -812,6 +905,7 @@ class CropDialogPro(QDialog):
         sx, sy = w_img / pm.width(), h_img / pm.height()
         return np.array([pt_scene.x() * sx, pt_scene.y() * sy], dtype=np.float32)
 
+
     def _apply_one(self):
         if not self._rect_item:
             QMessageBox.warning(self, self.tr("No Selection"), self.tr("Draw & finalize a crop first."))

{setiastrosuitepro-1.6.8 → setiastrosuitepro-1.6.9}/src/setiastro/saspro/curve_editor_pro.py

@@ -521,32 +521,6 @@ class CurveEditor(QGraphicsView):
             if ln is not None:
                 ln.setVisible(False)
 
-    def _scene_to_norm_points(self, pts_scene: list[tuple[float,float]]) -> list[tuple[float,float]]:
-        """(x:[0..360], y:[0..360] down) → (x,y in [0..1] up). Ensures endpoints present & strictly increasing x."""
-        out = []
-        lastx = -1e9
-        for (x, y) in sorted(pts_scene, key=lambda t: t[0]):
-            x = float(np.clip(x, 0.0, 360.0))
-            y = float(np.clip(y, 0.0, 360.0))
-            # strictly increasing X
-            if x <= lastx:
-                x = lastx + 1e-3
-            lastx = x
-            out.append((x / 360.0, 1.0 - (y / 360.0)))
-        # ensure endpoints
-        if not any(abs(px - 0.0)  < 1e-6 for px, _ in out): out.insert(0, (0.0, 0.0))
-        if not any(abs(px - 1.0)  < 1e-6 for px, _ in out): out.append((1.0, 1.0))
-        # clamp
-        return [(float(np.clip(x,0,1)), float(np.clip(y,0,1))) for (x,y) in out]
-
-    def _collect_points_norm_from_editor(self) -> list[tuple[float,float]]:
-        """Take endpoints+handles from editor => normalized points."""
-        pts_scene = []
-        for p in (self.editor.end_points + self.editor.control_points):
-            pos = p.scenePos()
-            pts_scene.append((float(pos.x()), float(pos.y())))
-        return self._scene_to_norm_points(pts_scene)
-
 
     def redistributeHandlesByPivot(self, u: float):
         """
@@ -1048,7 +1022,14 @@ class CurvesDialogPro(QDialog):
         self._cdf = None
         self._cdf_bins = 1024
         self._cdf_total = 0
-
+        # Debounce: coalesce rapid curve edits into one rebuild
+        self._curve_debounce_ms = 120  # tweak: 80–200ms feels good
+        self._curve_debounce = QTimer(self)
+        self._curve_debounce.setSingleShot(True)
+        self._curve_debounce.timeout.connect(self._rebuild_preview_from_curve_debounced)
+
+        # Optional: generation counter so stale results can't “win”
+        self._curve_gen = 0
         self._clip_scale = 1.0          # preview→full multiplier
         self._cdf_total_full = 0        # total pixels in full image (H*W)
         self._cdf_total_preview = 0     # total pixels in preview (H*W)
@@ -1220,18 +1201,34 @@ class CurvesDialogPro(QDialog):
 
     def _on_editor_curve_changed(self, _lut8=None):
         """
-        Called on every editor redraw/drag. Persist the currently edited curve
-        into the store, refresh overlays, and do a realtime preview.
+        Called on every editor redraw/drag. Persist points and refresh overlays.
+        Preview rebuild is DEBOUNCED to avoid spamming.
         """
         try:
             self._curves_store[self._current_mode_key] = self._editor_points_norm()
         except Exception:
             pass
-        # show the true shapes of other channels too
+
+        # cheap: overlay redraw is fine every move (or you can debounce this too)
         self._refresh_overlays()
-        # now build from *all* current curves (including the just-edited one)
-        self._quick_preview()
 
+        # expensive: debounce the preview rebuild
+        self._curve_gen += 1
+        self._curve_debounce.start(self._curve_debounce_ms)
+
+    def _rebuild_preview_from_curve_debounced(self):
+        """
+        Runs after the user pauses dragging for _curve_debounce_ms.
+        Only rebuild if we have images loaded.
+        """
+        if self._preview_orig is None and self._preview_img is None:
+            return
+        # If your preview toggle is off, you may want to skip:
+        if not getattr(self, "btn_preview", None) or not self.btn_preview.isChecked():
+            return
+
+        # Do the real work (what you were doing before)
+        self._quick_preview()
 
     def _active_mode_key(self) -> str:
         for b in self.mode_group.buttons():
@@ -1678,29 +1675,53 @@ class CurvesDialogPro(QDialog):
 
     # 1) Put this helper inside CurvesDialogPro (near other helpers)
     def _map_label_xy_to_image_ij(self, x: float, y: float):
-        """Map label-local coords (x,y) to _preview_img pixel (i,j). Returns (ix, iy) or None."""
+        """
+        Map label-local coords (x,y) to _preview_img pixel (ix, iy).
+        Correct even when the pixmap is centered inside a larger label.
+        Returns None if cursor is outside the displayed pixmap area.
+        """
         if self._pix is None:
             return None
+
         pm_disp = self.label.pixmap()
         if pm_disp is None or pm_disp.isNull():
             return None
 
-        src_w = self._pix.width()          # size of the *source* pixmap (preview image)
-        src_h = self._pix.height()
-        disp_w = pm_disp.width()           # size of the *displayed* pixmap on the label
+        # Displayed pixmap size (after zoom)
+        disp_w = pm_disp.width()
         disp_h = pm_disp.height()
-        if src_w <= 0 or src_h <= 0 or disp_w <= 0 or disp_h <= 0:
+
+        # Label may be bigger -> pixmap is centered with margins
+        lbl_w = self.label.width()
+        lbl_h = self.label.height()
+
+        off_x = max(0, (lbl_w - disp_w) // 2)
+        off_y = max(0, (lbl_h - disp_h) // 2)
+
+        # Remove margins: label-local -> pixmap-local
+        px = float(x) - float(off_x)
+        py = float(y) - float(off_y)
+
+        if px < 0 or py < 0 or px >= disp_w or py >= disp_h:
+            return None  # outside actual image area
+
+        # Now convert displayed pixmap pixel -> source preview pixel
+        src_w = self._pix.width()
+        src_h = self._pix.height()
+        if src_w <= 0 or src_h <= 0:
             return None
 
         sx = disp_w / float(src_w)
         sy = disp_h / float(src_h)
 
-        ix = int(x / sx)
-        iy = int(y / sy)
+        ix = int(px / sx)
+        iy = int(py / sy)
+
         if ix < 0 or iy < 0 or ix >= src_w or iy >= src_h:
             return None
         return ix, iy
 
+
     def _scene_to_norm_points(self, pts_scene: list[tuple[float,float]]) -> list[tuple[float,float]]:
         """(x:[0..360], y:[0..360] down) → (x,y in [0..1] up). Ensures endpoints present & strictly increasing x."""
         out = []