Struct ImageAnalyzer 

pub struct ImageAnalyzer { /* private fields */ }

Image analyzer with builder pattern.

Implementations

impl ImageAnalyzer

pub fn new() -> Self

Examples found in repository

examples/analyze_batch.rs (line 28)

fn main() {
    let dir = "tests/no_trails";
    let mut files: Vec<_> = std::fs::read_dir(dir)
        .unwrap()
        .filter_map(|e| e.ok())
        .filter(|e| e.path().extension().map_or(false, |ext| ext == "fits"))
        .map(|e| e.path())
        .collect();
    files.sort();

    println!(
        "{:<12} {:>5} {:>5} {:>6} {:>6} {:>6} {:>6} {:>7} {:>8} {:>8} {:>6} {:>6} {:>6} {:>7}",
        "FILE", "DET", "KEPT", "FWHM", "ECC", "SNR", "HFR", "SNR_W", "PSF_SIG", "FR_SNR", "W", "H", "R²", "TRAIL?"
    );
    println!("{}", "-".repeat(124));

    for path in &files {
        let name = path.file_name().unwrap().to_str().unwrap();
        // Extract short name (frame number)
        let short = if let Some(pos) = name.rfind('_') {
            &name[pos + 1..name.len() - 5] // strip .fits
        } else {
            &name[..name.len().min(12)]
        };

        let analyzer = ImageAnalyzer::new();
        match analyzer.analyze(path) {
            Ok(r) => {
                println!(
                    "{:<12} {:>5} {:>5} {:>6.2} {:>6.3} {:>6.1} {:>6.2} {:>7.3} {:>8.1} {:>8.1} {:>6} {:>6} {:>6.3} {:>7}",
                    short,
                    r.stars_detected,
                    r.stars.len(),
                    r.median_fwhm,
                    r.median_eccentricity,
                    r.median_snr,
                    r.median_hfr,
                    r.snr_weight,
                    r.psf_signal,
                    r.frame_snr,
                    r.width,
                    r.height,
                    r.trail_r_squared,
                    if r.possibly_trailed { "YES" } else { "no" },
                );
            }
            Err(e) => {
                println!("{:<12} ERROR: {}", short, e);
            }
        }
    }
}

examples/trail_test.rs (line 8)

fn analyze_file(label: &str, path: &str) {
    println!("━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━");
    println!("{label}");
    println!("━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━");

    let analyzer = ImageAnalyzer::new();
    let r = analyzer.analyze(path).unwrap();

    println!("  Stars detected:       {}", r.stars_detected);
    println!("  Stars after filter:   {}", r.stars.len());
    println!("  Median FWHM:          {:.3}", r.median_fwhm);
    println!("  Median eccentricity:  {:.3}", r.median_eccentricity);
    println!("  Median SNR:           {:.1}", r.median_snr);
    println!("  PSF signal:           {:.1}", r.psf_signal);
    println!("  Frame SNR:            {:.1}", r.frame_snr);
    println!("  Trail R²:             {:.4}", r.trail_r_squared);
    println!("  Possibly trailed:     {}", r.possibly_trailed);

    // Show theta distribution
    let n = r.stars.len();
    if n >= 5 {
        let mut thetas: Vec<f32> = r.stars.iter().map(|s| s.theta.to_degrees()).collect();
        thetas.sort_by(|a, b| a.total_cmp(b));

        let (sum_cos, sum_sin) = r.stars.iter().fold((0.0f64, 0.0f64), |(sc, ss), s| {
            let a = 2.0 * s.theta as f64;
            (sc + a.cos(), ss + a.sin())
        });
        let mean_theta = (sum_sin.atan2(sum_cos) * 0.5).to_degrees();

        println!("\n  Theta ({} measured stars):", n);
        println!("    Mean theta:   {mean_theta:.1}deg");
        println!(
            "    min={:.1}  p25={:.1}  median={:.1}  p75={:.1}  max={:.1}",
            thetas[0],
            thetas[n / 4],
            thetas[n / 2],
            thetas[3 * n / 4],
            thetas[n - 1]
        );
    }

    if !r.stars.is_empty() {
        println!("\n  Top 5 stars:");
        for (i, s) in r.stars.iter().take(5).enumerate() {
            println!(
                "    #{}: ecc={:.3} theta={:.1}deg fwhm={:.2} peak={:.0}",
                i + 1,
                s.eccentricity,
                s.theta.to_degrees(),
                s.fwhm,
                s.peak
            );
        }
    }
    println!();
}

pub fn with_detection_sigma(self, sigma: f32) -> Self

Star detection threshold in σ above background.

pub fn with_min_star_area(self, area: usize) -> Self

Reject connected components with fewer pixels than this (filters hot pixels).

pub fn with_max_star_area(self, area: usize) -> Self

Reject connected components with more pixels than this (filters galaxies/nebulae).

pub fn with_saturation_fraction(self, frac: f32) -> Self

Reject stars with peak > fraction × 65535 (saturated).

pub fn with_max_stars(self, n: usize) -> Self

Keep only the brightest N stars in the returned result.

pub fn without_debayer(self) -> Self

Skip debayering for OSC images (less accurate but faster).

pub fn with_trail_threshold(self, threshold: f32) -> Self

Set the R² threshold for trail detection. Images with Rayleigh R² above this are flagged as possibly trailed. Default: 0.5. Lower values are more aggressive (more false positives).

pub fn with_optics(self, focal_length_mm: f64, pixel_size_um: f64) -> Self

Set optics parameters for arcsecond-based measurements. focal_length_mm: telescope focal length in millimeters. pixel_size_um: camera pixel size in micrometers. When both are set, FWHM and HFR are reported in arcseconds alongside pixels.

pub fn with_mrs_layers(self, layers: usize) -> Self

Set MRS wavelet noise layers for noise estimation. Default: 0 (fast MAD noise from mesh-grid cell sigmas). Set to 1-6 for MRS wavelet noise (more robust against nebulosity/gradients, ~200ms slower per frame). 4 is the recommended MRS setting.

pub fn with_measure_cap(self, n: usize) -> Self

Max stars to PSF-fit for statistics. Default 2000. Stars are sorted by flux (brightest first) before capping. Set to 0 to measure all detected stars (catalog export mode).

pub fn with_fit_max_iter(self, n: usize) -> Self

LM max iterations for pass-2 measurement fits. Default 25. Calibration pass always uses 50 iterations.

pub fn with_fit_tolerance(self, tol: f64) -> Self

LM convergence tolerance for pass-2 measurement fits. Default 1e-4. Calibration pass always uses 1e-6.

pub fn with_fit_max_rejects(self, n: usize) -> Self

Consecutive LM step rejects before early bailout. Default 5.

pub fn with_thread_pool(self, pool: Arc<ThreadPool>) -> Self

Use a custom rayon thread pool.

pub fn analyze<P: AsRef<Path>>(&self, path: P) -> Result<AnalysisResult>

Analyze a FITS or XISF image file.

Examples found in repository

examples/analyze_batch.rs (line 29)

fn main() {
    let dir = "tests/no_trails";
    let mut files: Vec<_> = std::fs::read_dir(dir)
        .unwrap()
        .filter_map(|e| e.ok())
        .filter(|e| e.path().extension().map_or(false, |ext| ext == "fits"))
        .map(|e| e.path())
        .collect();
    files.sort();

    println!(
        "{:<12} {:>5} {:>5} {:>6} {:>6} {:>6} {:>6} {:>7} {:>8} {:>8} {:>6} {:>6} {:>6} {:>7}",
        "FILE", "DET", "KEPT", "FWHM", "ECC", "SNR", "HFR", "SNR_W", "PSF_SIG", "FR_SNR", "W", "H", "R²", "TRAIL?"
    );
    println!("{}", "-".repeat(124));

    for path in &files {
        let name = path.file_name().unwrap().to_str().unwrap();
        // Extract short name (frame number)
        let short = if let Some(pos) = name.rfind('_') {
            &name[pos + 1..name.len() - 5] // strip .fits
        } else {
            &name[..name.len().min(12)]
        };

        let analyzer = ImageAnalyzer::new();
        match analyzer.analyze(path) {
            Ok(r) => {
                println!(
                    "{:<12} {:>5} {:>5} {:>6.2} {:>6.3} {:>6.1} {:>6.2} {:>7.3} {:>8.1} {:>8.1} {:>6} {:>6} {:>6.3} {:>7}",
                    short,
                    r.stars_detected,
                    r.stars.len(),
                    r.median_fwhm,
                    r.median_eccentricity,
                    r.median_snr,
                    r.median_hfr,
                    r.snr_weight,
                    r.psf_signal,
                    r.frame_snr,
                    r.width,
                    r.height,
                    r.trail_r_squared,
                    if r.possibly_trailed { "YES" } else { "no" },
                );
            }
            Err(e) => {
                println!("{:<12} ERROR: {}", short, e);
            }
        }
    }
}

examples/trail_test.rs (line 9)

fn analyze_file(label: &str, path: &str) {
    println!("━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━");
    println!("{label}");
    println!("━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━");

    let analyzer = ImageAnalyzer::new();
    let r = analyzer.analyze(path).unwrap();

    println!("  Stars detected:       {}", r.stars_detected);
    println!("  Stars after filter:   {}", r.stars.len());
    println!("  Median FWHM:          {:.3}", r.median_fwhm);
    println!("  Median eccentricity:  {:.3}", r.median_eccentricity);
    println!("  Median SNR:           {:.1}", r.median_snr);
    println!("  PSF signal:           {:.1}", r.psf_signal);
    println!("  Frame SNR:            {:.1}", r.frame_snr);
    println!("  Trail R²:             {:.4}", r.trail_r_squared);
    println!("  Possibly trailed:     {}", r.possibly_trailed);

    // Show theta distribution
    let n = r.stars.len();
    if n >= 5 {
        let mut thetas: Vec<f32> = r.stars.iter().map(|s| s.theta.to_degrees()).collect();
        thetas.sort_by(|a, b| a.total_cmp(b));

        let (sum_cos, sum_sin) = r.stars.iter().fold((0.0f64, 0.0f64), |(sc, ss), s| {
            let a = 2.0 * s.theta as f64;
            (sc + a.cos(), ss + a.sin())
        });
        let mean_theta = (sum_sin.atan2(sum_cos) * 0.5).to_degrees();

        println!("\n  Theta ({} measured stars):", n);
        println!("    Mean theta:   {mean_theta:.1}deg");
        println!(
            "    min={:.1}  p25={:.1}  median={:.1}  p75={:.1}  max={:.1}",
            thetas[0],
            thetas[n / 4],
            thetas[n / 2],
            thetas[3 * n / 4],
            thetas[n - 1]
        );
    }

    if !r.stars.is_empty() {
        println!("\n  Top 5 stars:");
        for (i, s) in r.stars.iter().take(5).enumerate() {
            println!(
                "    #{}: ecc={:.3} theta={:.1}deg fwhm={:.2} peak={:.0}",
                i + 1,
                s.eccentricity,
                s.theta.to_degrees(),
                s.fwhm,
                s.peak
            );
        }
    }
    println!();
}

pub fn analyze_data( &self, data: &[f32], width: usize, height: usize, channels: usize, ) -> Result<AnalysisResult>

Analyze pre-loaded f32 pixel data.

data: planar f32 pixel data (for 3-channel: RRRGGGBBB layout). width: image width. height: image height. channels: 1 for mono, 3 for RGB.

pub fn analyze_raw( &self, meta: &ImageMetadata, pixels: &PixelData, ) -> Result<AnalysisResult>

Analyze pre-read raw pixel data (skips file I/O).

Accepts ImageMetadata and borrows PixelData, handling u16→f32 conversion and green-channel interpolation for OSC images internally.

pub fn analyze_batch<P, F>( &self, paths: &[P], concurrency: usize, progress: F, ) -> Vec<(PathBuf, Result<AnalysisResult>)>

where P: AsRef<Path> + Sync, F: Fn(usize, usize, &Path) + Send + Sync,

Analyze multiple images in parallel.

concurrency controls how many frames are analyzed simultaneously. progress is called after each frame completes with (completed, total, path). Returns results in approximate completion order.

Trait Implementations

impl Default for ImageAnalyzer

fn default() -> Self

Returns the “default value” for a type.