Sqm Correction UI

python/PiFinder/camera_interface.py

@@ -381,11 +381,21 @@ def get_image_loop(
                             else:
                                 console_queue.put("CAM: Captured")
 
-                        if command == "capture_exp_sweep":
+                        if command.startswith("capture_exp_sweep"):
                             # Capture exposure sweep - save both RAW and processed images
                             # at different exposures for SQM testing
                             # RAW: 16-bit TIFF to preserve full sensor bit depth
                             # Processed: 8-bit PNG from normal camera.capture() pipeline
+
+                            # Parse reference SQM if provided
+                            reference_sqm = None
+                            if ":" in command:
+                                try:
+                                    reference_sqm = float(command.split(":")[1])
+                                    logger.info(f"Reference SQM: {reference_sqm:.2f}")
+                                except (ValueError, IndexError):
+                                    logger.warning("Invalid reference SQM in command")
+
                             logger.info(
                                 "Starting exposure sweep capture (100 image pairs)"
                             )
@@ -410,19 +420,27 @@ def get_image_loop(
                                 min_exp, max_exp, num_images
                             )
 
-                            # Generate timestamp for this sweep session
-                            timestamp = datetime.datetime.now().strftime(
-                                "%Y%m%d_%H%M%S"
-                            )
+                            # Generate timestamp for this sweep session using GPS time
+                            gps_time = shared_state.datetime()
+                            if gps_time:
+                                timestamp = gps_time.strftime("%Y%m%d_%H%M%S")
+                            else:
+                                # Fallback to Pi time if GPS not available
+                                timestamp = datetime.datetime.now().strftime("%Y%m%d_%H%M%S")
+                                logger.warning("GPS time not available, using Pi system time for sweep directory name")
 
                             # Create sweep directory
-                            sweep_dir = f"{utils.data_dir}/captures/sweep_{timestamp}"
-                            os.makedirs(sweep_dir, exist_ok=True)
+                            from pathlib import Path
+                            sweep_dir = Path(f"{utils.data_dir}/captures/sweep_{timestamp}")
+                            sweep_dir.mkdir(parents=True, exist_ok=True)
 
                             logger.info(f"Saving sweep to: {sweep_dir}")
-                            console_queue.put(f"CAM: {num_images} image pairs")
+                            console_queue.put("CAM: Starting sweep...")
 
                             for i, exp_us in enumerate(sweep_exposures, 1):
+                                # Update progress at start of each capture
+                                console_queue.put(f"CAM: Sweep {i}/{num_images}")
+
                                 # Set exposure
                                 self.exposure_time = exp_us
                                 self.set_camera_config(self.exposure_time, self.gain)
@@ -439,19 +457,14 @@ def get_image_loop(
                                 # Now capture both processed and RAW images with correct exposure
                                 exp_ms = exp_us / 1000
 
-                                # Save processed PNG (8-bit, from camera.capture())
-                                processed_filename = f"{sweep_dir}/img_{i:03d}_{exp_ms:.2f}ms_processed.png"
-                                self.capture_file(processed_filename)
+                                # Save processed 8-bit PNG (same as production capture() method)
+                                processed_filename = sweep_dir / f"img_{i:03d}_{exp_ms:.2f}ms_processed.png"
+                                processed_img = self.capture()  # Returns 8-bit PIL Image
+                                processed_img.save(str(processed_filename))
 
                                 # Save RAW TIFF (16-bit, from camera.capture_raw_file())
-                                raw_filename = (
-                                    f"{sweep_dir}/img_{i:03d}_{exp_ms:.2f}ms_raw.tiff"
-                                )
-                                self.capture_raw_file(raw_filename)
-
-                                # Update console every 10 images to avoid spam
-                                if i % 10 == 0 or i == num_images:
-                                    console_queue.put(f"CAM: Sweep {i}/{num_images}")
+                                raw_filename = sweep_dir / f"img_{i:03d}_{exp_ms:.2f}ms_raw.tiff"
+                                self.capture_raw_file(str(raw_filename))
 
                                 logger.debug(
                                     f"Captured sweep images {i}/{num_images}: {exp_ms:.2f}ms (PNG+TIFF)"
@@ -463,6 +476,54 @@ def get_image_loop(
                             self._auto_exposure_enabled = original_ae_enabled
                             self.set_camera_config(self.exposure_time, self.gain)
 
+                            # Save sweep metadata (GPS time, location, altitude)
+                            logger.info("Starting sweep metadata save...")
+                            try:
+                                from PiFinder.sqm.save_sweep_metadata import (
+                                    save_sweep_metadata,
+                                )
+
+                                # Get GPS datetime (not Pi time)
+                                gps_datetime = shared_state.datetime()
+                                logger.debug(f"GPS datetime: {gps_datetime}")
+
+                                # Get observer location
+                                location = shared_state.location()
+                                logger.debug(f"Location: lat={location.lat}, lon={location.lon}, alt={location.altitude}")
+
+                                # Get current solve with RA/Dec/Alt/Az
+                                solve_state = shared_state.solution()
+                                ra_deg = None
+                                dec_deg = None
+                                altitude_deg = None
+                                azimuth_deg = None
+
+                                if solve_state:
+                                    ra_deg = solve_state.get("RA")
+                                    dec_deg = solve_state.get("Dec")
+                                    altitude_deg = solve_state.get("Alt")
+                                    azimuth_deg = solve_state.get("Az")
+                                    logger.debug(f"Solve: RA={ra_deg}, Dec={dec_deg}, Alt={altitude_deg}, Az={azimuth_deg}")
+
+                                # Save metadata
+                                logger.info(f"Calling save_sweep_metadata for {sweep_dir}")
+                                save_sweep_metadata(
+                                    sweep_dir=sweep_dir,
+                                    observer_lat=location.lat,
+                                    observer_lon=location.lon,
+                                    observer_altitude_m=location.altitude,
+                                    gps_datetime=gps_datetime.isoformat() if gps_datetime else None,
+                                    reference_sqm=reference_sqm,
+                                    ra_deg=ra_deg,
+                                    dec_deg=dec_deg,
+                                    altitude_deg=altitude_deg,
+                                    azimuth_deg=azimuth_deg,
+                                    notes=f"Exposure sweep: {num_images} images, {min_exp/1000:.1f}-{max_exp/1000:.1f}ms",
+                                )
+                                logger.info(f"Successfully saved sweep metadata to {sweep_dir}/sweep_metadata.json")
+                            except Exception as e:
+                                logger.error(f"Failed to save sweep metadata: {e}", exc_info=True)
+
                             console_queue.put("CAM: Sweep done!")
                             logger.info(
                                 f"Exposure sweep completed: {num_images} image pairs in {sweep_dir}"

python/PiFinder/solver.py

@@ -463,31 +463,95 @@ def solver(
                                 f"RMSE: {solved.get('RMSE', 0):.1f}px"
                             )
 
-                            # See if we are waiting for alignment
-                            if align_ra != 0 and align_dec != 0:
-                                if solved.get("x_target") is not None:
-                                    align_target_pixel = (
-                                        solved["y_target"],
-                                        solved["x_target"],
-                                    )
-                                    logger.debug(f"Align {align_target_pixel=}")
-                                    align_result_queue.put(
-                                        ["aligned", align_target_pixel]
+                            if "matched_centroids" in solution:
+                                # Update SQM for BOTH processed and raw pipelines
+                                # Convert exposure time from microseconds to seconds
+                                exposure_sec = (
+                                    last_image_metadata["exposure_time"] / 1_000_000.0
+                                )
+
+                                update_sqm_dual_pipeline(
+                                    shared_state=shared_state,
+                                    sqm_calculator=sqm_calculator,
+                                    sqm_calculator_raw=sqm_calculator_raw,
+                                    camera_command_queue=camera_command_queue,
+                                    centroids=centroids,
+                                    solution=solution,
+                                    image_processed=np_image,
+                                    exposure_sec=exposure_sec,
+                                    altitude_deg=solved.get("Alt") or 90.0,
+                                    calculation_interval_seconds=SQM_CALCULATION_INTERVAL_SECONDS,
+                                )
+
+                                # Don't clutter printed solution with these fields.
+                                del solution["matched_catID"]
+                                del solution["pattern_centroids"]
+                                del solution["epoch_equinox"]
+                                del solution["epoch_proper_motion"]
+                                del solution["cache_hit_fraction"]
+
+                            solved |= solution
+
+                            total_tetra_time = t_extract + solved["T_solve"]
+                            if total_tetra_time > 1000:
+                                console_queue.put(f"SLV: Long: {total_tetra_time}")
+                                logger.warning("Long solver time: %i", total_tetra_time)
+
+                            if solved["RA"] is not None:
+                                # RA, Dec, Roll at the center of the camera's FoV:
+                                solved["camera_center"]["RA"] = solved["RA"]
+                                solved["camera_center"]["Dec"] = solved["Dec"]
+                                solved["camera_center"]["Roll"] = solved["Roll"]
+
+                                # RA, Dec, Roll at the center of the camera's not imu:
+                                solved["camera_solve"]["RA"] = solved["RA"]
+                                solved["camera_solve"]["Dec"] = solved["Dec"]
+                                solved["camera_solve"]["Roll"] = solved["Roll"]
+                                # RA, Dec, Roll at the target pixel:
+                                solved["RA"] = solved["RA_target"]
+                                solved["Dec"] = solved["Dec_target"]
+                                if last_image_metadata["imu"]:
+                                    solved["imu_pos"] = last_image_metadata["imu"]["pos"]
+                                    solved["imu_quat"] = last_image_metadata["imu"]["quat"]
+                                else:
+                                    solved["imu_pos"] = None
+                                    solved["imu_quat"] = None
+                                solved["solve_time"] = time.time()
+                                solved["cam_solve_time"] = solved["solve_time"]
+                                # Mark successful solve - use same timestamp as last_solve_attempt for comparison
+                                solved["last_solve_success"] = solved["last_solve_attempt"]
+
+                                logger.info(
+                                    f"Solve SUCCESS - {len(centroids)} centroids → "
+                                    f"{solved.get('Matches', 0)} matches, "
+                                    f"RMSE: {solved.get('RMSE', 0):.1f}px"
+                                )
+
+                                # See if we are waiting for alignment
+                                if align_ra != 0 and align_dec != 0:
+                                    if solved.get("x_target") is not None:
+                                        align_target_pixel = (
+                                            solved["y_target"],
+                                            solved["x_target"],
+                                        )
+                                        logger.debug(f"Align {align_target_pixel=}")
+                                        align_result_queue.put(
+                                            ["aligned", align_target_pixel]
                                     )
                                     align_ra = 0
                                     align_dec = 0
                                     solved["x_target"] = None
                                     solved["y_target"] = None
-                        else:
-                            # Centroids found but solve failed - clear Matches
-                            solved["Matches"] = 0
-                            logger.warning(
-                                f"Solve FAILED - {len(centroids)} centroids detected but "
-                                f"pattern match failed (FOV est: 12.0°, max err: 4.0°)"
-                            )
+                            else:
+                                # Centroids found but solve failed - clear Matches
+                                solved["Matches"] = 0
+                                logger.warning(
+                                    f"Solve FAILED - {len(centroids)} centroids detected but "
+                                    f"pattern match failed (FOV est: 12.0°, max err: 4.0°)"
+                                )
 
-                        # Always push to queue after every solve attempt (success or failure)
-                        solver_queue.put(solved)
+                            # Always push to queue after every solve attempt (success or failure)
+                            solver_queue.put(solved)
                     except Exception as e:
                         # If solve attempt fails, still send update with Matches=0
                         # so auto-exposure can continue running

python/PiFinder/sqm/noise_floor.py

@@ -354,12 +354,12 @@ def load_calibration(self) -> bool:
             True if calibration was loaded successfully, False otherwise
         """
         try:
-            # Load from ~/PiFinder_data/sqm_calibration.json
+            # Load from ~/PiFinder_data/sqm_calibration_{camera_type}.json
             data_dir = Path.home() / "PiFinder_data"
-            calibration_file = data_dir / "sqm_calibration.json"
+            calibration_file = data_dir / f"sqm_calibration_{self.camera_type}.json"
 
             if not calibration_file.exists():
-                logger.info("No saved calibration found, using default profile")
+                logger.info(f"No saved calibration found for {self.camera_type}, using default profile")
                 return False
 
             with open(calibration_file, "r") as f:
@@ -410,11 +410,11 @@ def save_calibration(
                 "timestamp": time.time(),
             }
 
-            # Save to ~/PiFinder_data/sqm_calibration.json
+            # Save to ~/PiFinder_data/sqm_calibration_{camera_type}.json
             data_dir = Path.home() / "PiFinder_data"
             data_dir.mkdir(exist_ok=True)
 
-            calibration_file = data_dir / "sqm_calibration.json"
+            calibration_file = data_dir / f"sqm_calibration_{self.camera_type}.json"
             with open(calibration_file, "w") as f:
                 json.dump(calibration_data, f, indent=2)
 

python/PiFinder/sqm/save_sweep_metadata.py

@@ -0,0 +1,103 @@
+"""
+Helper to save sweep metadata during capture.
+Add this to your sweep capture code.
+"""
+
+import json
+import logging
+from pathlib import Path
+from datetime import datetime
+from typing import Optional, Dict, Any
+import pytz
+
+logger = logging.getLogger("SweepMetadata")
+
+
+def save_sweep_metadata(
+    sweep_dir: Path,
+    observer_lat: float,
+    observer_lon: float,
+    observer_altitude_m: Optional[float] = None,
+    gps_datetime: Optional[str] = None,
+    reference_sqm: Optional[float] = None,
+    ra_deg: Optional[float] = None,
+    dec_deg: Optional[float] = None,
+    altitude_deg: Optional[float] = None,
+    azimuth_deg: Optional[float] = None,
+    notes: str = ""
+):
+    """
+    Save metadata file in sweep directory.
+
+    Call this during sweep capture to save observation details.
+
+    Args:
+        sweep_dir: Path to sweep directory
+        observer_lat: Observer latitude in degrees
+        observer_lon: Observer longitude in degrees
+        observer_altitude_m: Observer altitude in meters (optional)
+        gps_datetime: GPS datetime as ISO string (optional)
+        reference_sqm: Reference SQM value from external meter (optional)
+        ra_deg: Right Ascension from solver (optional)
+        dec_deg: Declination from solver (optional)
+        altitude_deg: Altitude angle above horizon in degrees (optional)
+        azimuth_deg: Azimuth angle in degrees (optional)
+        notes: Any additional notes
+    """
+    metadata: Dict[str, Any] = {
+        'timestamp': gps_datetime if gps_datetime else datetime.now(pytz.timezone('Europe/Brussels')).isoformat(),
+        'observer': {
+            'latitude_deg': observer_lat,
+            'longitude_deg': observer_lon,
+        },
+        'sweep_directory': str(sweep_dir),
+    }
+
+    if observer_altitude_m is not None:
+        metadata['observer']['altitude_m'] = observer_altitude_m
+
+    if reference_sqm is not None:
+        metadata['reference_sqm'] = reference_sqm
+
+    if ra_deg is not None and dec_deg is not None:
+        metadata['coordinates'] = {
+            'ra_deg': ra_deg,
+            'dec_deg': dec_deg,
+        }
+        if altitude_deg is not None:
+            metadata['coordinates']['altitude_deg'] = altitude_deg
+        if azimuth_deg is not None:
+            metadata['coordinates']['azimuth_deg'] = azimuth_deg
+
+    if notes:
+        metadata['notes'] = notes
+
+    # Save to JSON file
+    metadata_file = sweep_dir / 'sweep_metadata.json'
+    logger.info(f"Writing metadata to: {metadata_file}")
+
+    try:
+        with open(metadata_file, 'w') as f:
+            json.dump(metadata, f, indent=2)
+        logger.info(f"Successfully saved metadata to {metadata_file}")
+    except Exception as e:
+        logger.error(f"Failed to write metadata file: {e}")
+        raise
+
+    return metadata_file
+
+
+# Example usage - add this to your sweep capture code:
+if __name__ == "__main__":
+    from pathlib import Path
+
+    # Example: Save metadata during sweep
+    sweep_dir = Path("../test_images/sweep/sweep_20251116_132256_187sqm")
+
+    save_sweep_metadata(
+        sweep_dir=sweep_dir,
+        observer_lat=50.8503,  # Brussels
+        observer_lon=4.3517,
+        reference_sqm=18.7,
+        notes="Diaphragm fully open, clear sky"
+    )