setiastrosuitepro 1.6.0__py3-none-any.whl → 1.6.4.post1__py3-none-any.whl

setiastro/saspro/nbtorgb_stars.py

@@ -220,7 +220,10 @@ class NBtoRGBStars(QWidget):
             if img.ndim == 3: img = img[...,0]
             setattr(self, which.lower(), self._as_float01(img))
         else:  # OSC
-            if img.ndim == 2: img = np.stack([img]*3, axis=-1)
+            # Optimization: Store mono OSC as-is (2D) to save memory
+            # The combine step will handle expansion.
+            if img.ndim == 3 and img.shape[2] == 1:
+                img = img[..., 0]
             setattr(self, which.lower(), self._as_float01(img))
 
         setattr(self, f"_file_{which.lower()}", path)
@@ -309,7 +312,14 @@ class NBtoRGBStars(QWidget):
             raise ValueError(f"Channel sizes differ: {set(shapes)}")
 
         if self.osc is not None:
-            r = self.osc[...,0]; g = self.osc[...,1]; b = self.osc[...,2]
+            if self.osc.ndim == 2:
+                r = self.osc; g = self.osc; b = self.osc
+            elif self.osc.ndim == 3 and self.osc.shape[2] >= 3:
+                r = self.osc[...,0]; g = self.osc[...,1]; b = self.osc[...,2]
+            else:
+                 # fallback for unexpected shapes (e.g. 3D but 1-channel)
+                 r = self.osc.squeeze(); g = r; b = r
+
             sii = self.sii if self.sii is not None else r
             ha  = self.ha  if self.ha  is not None else r
             oiii= self.oiii if self.oiii is not None else b

setiastro/saspro/numba_utils.py

@@ -1,4 +1,4 @@
-import numpy as np
+import numpy as np
 from numba import njit, prange
 import cv2 
 import math
@@ -584,39 +584,55 @@ def kappa_sigma_clip_weighted_3d(stack, weights, kappa=2.5, iterations=3):
                 pixel_weights = weights[:]
             else:
                 pixel_weights = weights[:, i, j].copy()
-            # Initialize tracking of indices
-            current_idx = np.empty(num_frames, dtype=np.int64)
-            for f in range(num_frames):
-                current_idx[f] = f
-            current_vals = pixel_values
-            current_w = pixel_weights
-            current_indices = current_idx
+                
+            # Use boolean mask instead of tracking indices
+            valid_mask = pixel_values != 0
+            
             med = 0.0
             for _ in range(iterations):
-                if current_vals.size == 0:
+                # Count valid pixels
+                count = 0
+                for k in range(num_frames):
+                    if valid_mask[k]:
+                        count += 1
+                
+                if count == 0:
                     break
+                    
+                # Extract valid values for stats (this allocation is unavoidable but smaller/temp)
+                # In numba this usually lowers to efficient code if we avoid 'np.empty' overhead inside loops
+                # but pure mask operations are often faster.
+                # However, for median/std we need the compacted array.
+                current_vals = pixel_values[valid_mask]
+                
                 med = np.median(current_vals)
                 std = np.std(current_vals)
                 lower_bound = med - kappa * std
                 upper_bound = med + kappa * std
-                valid = (current_vals != 0) & (current_vals >= lower_bound) & (current_vals <= upper_bound)
-                current_vals = current_vals[valid]
-                current_w = current_w[valid]
-                current_indices = current_indices[valid]
-            # Mark rejected: frames not in current_indices are rejected.
+                
+                # Update mask: must be valid AND within bounds
+                for k in range(num_frames):
+                    if valid_mask[k]:
+                        val = pixel_values[k]
+                        if val < lower_bound or val > upper_bound:
+                            valid_mask[k] = False
+
+            # Fill rejection mask
             for f in range(num_frames):
-                # Check if f is in current_indices
-                found = False
-                for k in range(current_indices.size):
-                    if current_indices[k] == f:
-                        found = True
-                        break
-                if not found:
-                    rej_mask[f, i, j] = True
-                else:
-                    rej_mask[f, i, j] = False
-            if current_w.size > 0 and current_w.sum() > 0:
-                clipped[i, j] = np.sum(current_vals * current_w) / current_w.sum()
+                rej_mask[f, i, j] = not valid_mask[f]
+                
+            # Compute weighted mean of final valid pixels
+            wsum = 0.0
+            vsum = 0.0
+            for k in range(num_frames):
+                if valid_mask[k]:
+                    w = pixel_weights[k]
+                    v = pixel_values[k]
+                    wsum += w
+                    vsum += v * w
+            
+            if wsum > 0:
+                clipped[i, j] = vsum / wsum
             else:
                 clipped[i, j] = med
     return clipped, rej_mask
@@ -641,36 +657,46 @@ def kappa_sigma_clip_weighted_4d(stack, weights, kappa=2.5, iterations=3):
                     pixel_weights = weights[:]
                 else:
                     pixel_weights = weights[:, i, j, c].copy()
-                current_idx = np.empty(num_frames, dtype=np.int64)
-                for f in range(num_frames):
-                    current_idx[f] = f
-                current_vals = pixel_values
-                current_w = pixel_weights
-                current_indices = current_idx
+                
+                valid_mask = pixel_values != 0
+                
                 med = 0.0
                 for _ in range(iterations):
-                    if current_vals.size == 0:
+                    count = 0
+                    for k in range(num_frames):
+                        if valid_mask[k]:
+                            count += 1
+                    
+                    if count == 0:
                         break
+                    
+                    current_vals = pixel_values[valid_mask]
+                    
                     med = np.median(current_vals)
                     std = np.std(current_vals)
                     lower_bound = med - kappa * std
                     upper_bound = med + kappa * std
-                    valid = (current_vals != 0) & (current_vals >= lower_bound) & (current_vals <= upper_bound)
-                    current_vals = current_vals[valid]
-                    current_w = current_w[valid]
-                    current_indices = current_indices[valid]
+                    
+                    for k in range(num_frames):
+                        if valid_mask[k]:
+                            val = pixel_values[k]
+                            if val < lower_bound or val > upper_bound:
+                                valid_mask[k] = False
+
                 for f in range(num_frames):
-                    found = False
-                    for k in range(current_indices.size):
-                        if current_indices[k] == f:
-                            found = True
-                            break
-                    if not found:
-                        rej_mask[f, i, j, c] = True
-                    else:
-                        rej_mask[f, i, j, c] = False
-                if current_w.size > 0 and current_w.sum() > 0:
-                    clipped[i, j, c] = np.sum(current_vals * current_w) / current_w.sum()
+                    rej_mask[f, i, j, c] = not valid_mask[f]
+                
+                wsum = 0.0
+                vsum = 0.0
+                for k in range(num_frames):
+                    if valid_mask[k]:
+                        w = pixel_weights[k]
+                        v = pixel_values[k]
+                        wsum += w
+                        vsum += v * w
+
+                if wsum > 0:
+                    clipped[i, j, c] = vsum / wsum
                 else:
                     clipped[i, j, c] = med
     return clipped, rej_mask
@@ -3042,3 +3068,78 @@ def fast_star_detect(image,
         return np.empty((0,2), dtype=np.float32)
     else:
         return np.array(star_positions, dtype=np.float32)
+
+
+@njit(fastmath=True, cache=True)
+def gradient_descent_to_dim_spot_numba(gray_small, start_x, start_y, patch_size):
+    """
+    Numba implementation of _gradient_descent_to_dim_spot.
+    Walks to the local minimum (median-of-patch) around (start_x, start_y).
+    gray_small: 2D float32 array
+    """
+    H, W = gray_small.shape
+    half = patch_size // 2
+    
+    cx = int(min(max(start_x, 0), W - 1))
+    cy = int(min(max(start_y, 0), H - 1))
+
+    # Helper to compute patch median manually or efficiently
+    # Numba supports np.median on arrays, but slicing inside a loop can be costly.
+    # However, for small patches (e.g. 15x15), it should be okay.
+    
+    for _ in range(60):
+        # Current value
+        x0 = max(0, cx - half)
+        x1 = min(W, cx + half + 1)
+        y0 = max(0, cy - half)
+        y1 = min(H, cy + half + 1)
+        sub = gray_small[y0:y1, x0:x1].flatten()
+        if sub.size == 0:
+            cur_val = 1e9 # Should not happen
+        else:
+            cur_val = np.median(sub)
+
+        best_x, best_y = cx, cy
+        best_val = cur_val
+        
+        # 3x3 search
+        changed = False
+        
+        # Unroll for strict 3x3 neighborhood
+        for dy in range(-1, 2):
+            for dx in range(-1, 2):
+                if dx == 0 and dy == 0:
+                    continue
+                
+                nx = cx + dx
+                ny = cy + dy
+                
+                if nx < 0 or ny < 0 or nx >= W or ny >= H:
+                    continue
+                
+                # Compute median for neighbor
+                nx0 = max(0, nx - half)
+                nx1 = min(W, nx + half + 1)
+                ny0 = max(0, ny - half)
+                ny1 = min(H, ny + half + 1)
+                
+                # In Numba, median on a slice creates a copy.
+                # For small patches this is acceptable given the huge speedup vs Python interpreter overhead.
+                n_sub = gray_small[ny0:ny1, nx0:nx1].flatten()
+                if n_sub.size == 0:
+                    val = 1e9
+                else:
+                    val = np.median(n_sub)
+                
+                if val < best_val:
+                    best_val = val
+                    best_x = nx
+                    best_y = ny
+                    changed = True
+        
+        if not changed:
+            break
+            
+        cx, cy = best_x, best_y
+        
+    return cx, cy

setiastro/saspro/ops/scripts.py

@@ -644,13 +644,33 @@ class ScriptManager(QObject):
 
     # ---- loading ----
     def load_registry(self):
-        migrate_old_scripts_if_needed() 
+        """
+        Discover scripts recursively under SASpro/scripts, load them, and build registry.
+        Skips __pycache__, hidden/underscore-prefixed files, and __init__.py.
+        """
+        migrate_old_scripts_if_needed()
         scripts_dir = get_scripts_dir()
         self.registry = []
 
-        for path in sorted(scripts_dir.glob("*.py")):
+        try:
+            candidates = sorted(scripts_dir.rglob("*.py"))
+        except Exception:
+            candidates = []
+
+        for path in candidates:
+            # Skip pycache anywhere in path
+            parts_l = {p.lower() for p in path.parts}
+            if "__pycache__" in parts_l:
+                continue
+
+            # Skip hidden/private python files and package init
+            if path.name == "__init__.py":
+                continue
+            if path.name.startswith((".", "_")):
+                continue
+
             try:
-                entry = self._load_one_script(path)
+                entry = self._load_one_script(path, scripts_dir)
                 if entry:
                     self.registry.append(entry)
             except Exception:
@@ -658,8 +678,18 @@ class ScriptManager(QObject):
 
         self._log(f"[Scripts] Loaded {len(self.registry)} script(s) from {scripts_dir}")
 
-    def _load_one_script(self, path: Path) -> ScriptEntry | None:
-        # Make a unique module name so reload actually reloads
+
+    def _load_one_script(self, path: Path, scripts_root: Path) -> ScriptEntry | None:
+        """
+        Load a single user script from disk.
+
+        - Creates a unique module name based on mtime so reload picks up changes.
+        - Imports module.
+        - Determines stable script_id (prefer SCRIPT_ID in module, else persisted id).
+        - Pulls metadata: SCRIPT_NAME/GROUP/SHORTCUT.
+        Group defaults to relative folder under scripts_root.
+        """
+        # Unique module name so reloading actually re-imports
         try:
             mtime_ns = path.stat().st_mtime_ns
         except Exception:
@@ -671,7 +701,8 @@ class ScriptManager(QObject):
             return None
 
         mod = importlib.util.module_from_spec(spec)
-        script_id = self._script_id_for_path(path, mod)
+
+        # Import module first (so SCRIPT_ID / metadata exists)
         try:
             spec.loader.exec_module(mod)  # type: ignore
         except Exception:
@@ -687,7 +718,7 @@ class ScriptManager(QObject):
             self._log(f"[Scripts] {path.name} has no run(ctx) or main(ctx); skipping.")
             return None
 
-        # ---- metadata: allow CAPS or lowercase ----
+        # ---- helper: allow CAPS or lowercase ----
         def _pick(*names, default=None):
             for n in names:
                 if hasattr(mod, n):
@@ -695,11 +726,23 @@ class ScriptManager(QObject):
             return default
 
         name = _pick("SCRIPT_NAME", "script_name", default=path.stem)
-        group = _pick("SCRIPT_GROUP", "script_group", default="")
+
+        # Prefer explicit group; else derive group from relative folder
+        group = _pick("SCRIPT_GROUP", "script_group", default=None)
+        if group is None or not str(group).strip():
+            try:
+                rel_parent = path.parent.relative_to(scripts_root)
+                group = "" if str(rel_parent) in ("", ".") else rel_parent.as_posix()
+            except Exception:
+                group = ""
+
         shortcut = _pick("SCRIPT_SHORTCUT", "script_shortcut", default=None)
 
+        # Stable script id (prefer explicit SCRIPT_ID; else persisted by rel-path)
+        script_id = self._script_id_for_path(path, scripts_root, mod)
+
         entry = ScriptEntry(
-            script_id=script_id,
+            script_id=str(script_id),
             path=path,
             name=str(name),
             group=str(group or ""),
@@ -710,6 +753,7 @@ class ScriptManager(QObject):
         return entry
 
 
+
     # ---- menu wiring ----
     def rebuild_menu(self, menu_scripts):
         """
@@ -1394,15 +1438,31 @@ def run(ctx):
             self._log(f"[Scripts] Failed to write sample script:\n{traceback.format_exc()}")
 
 
-    def _script_id_for_path(self, path: Path, mod) -> str:
-        # 1) Prefer explicit SCRIPT_ID in the script file (best, survives renames)
-        sid = getattr(mod, "SCRIPT_ID", None) or getattr(mod, "script_id", None)
-        if isinstance(sid, str) and sid.strip():
-            return sid.strip()
+    def _script_id_for_path(self, path: Path, scripts_root: Path, mod=None) -> str:
+        """
+        Determine a stable script_id.
+
+        Priority:
+        1) SCRIPT_ID / script_id defined in the script (best; survives renames/moves)
+        2) Persisted id in QSettings keyed by *relative path inside scripts_root*
+            (stable across machines if folder structure is same)
+
+        NOTE: We intentionally DO NOT key by absolute path.
+        """
+        # 1) Prefer explicit SCRIPT_ID in the script file (best)
+        if mod is not None:
+            sid = getattr(mod, "SCRIPT_ID", None) or getattr(mod, "script_id", None)
+            if isinstance(sid, str) and sid.strip():
+                return sid.strip()
+
+        # 2) Persist per-relative-path (not absolute)
+        try:
+            rel = path.relative_to(scripts_root).as_posix()
+        except Exception:
+            rel = path.as_posix()
 
-        # 2) Fallback: persist per-path in QSettings (ok for existing scripts)
         s = QSettings()
-        key = f"Scripts/ids/{str(path)}"
+        key = f"Scripts/ids_rel/{rel}"
         sid = s.value(key, "", type=str) or ""
         if sid:
             return sid
@@ -1410,4 +1470,4 @@ def run(ctx):
         sid = uuid.uuid4().hex
         s.setValue(key, sid)
         s.sync()
-        return sid
+        return sid