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} {:>7} {:>8} {:>6} {:>6} {:>6} {:>7}",
        "FILE", "DET", "KEPT", "FWHM", "ECC", "SNR", "HFR", "SNR_dB", "SNR_W", "PSF_SIG", "W", "H", "R²", "TRAIL?"
    );
    println!("{}", "-".repeat(125));

    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.2} {:>7.3} {:>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_db,
                    r.snr_weight,
                    r.psf_signal,
                    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!("  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

Analyze only the brightest N stars.

pub fn without_gaussian_fit(self) -> Self

Use fast windowed-moments instead of Gaussian fit for FWHM (less accurate but faster).

pub fn with_background_mesh(self, cell_size: usize) -> Self

Enable mesh-grid background estimation with given cell size (handles gradients).

pub fn without_debayer(self) -> Self

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

pub fn with_max_eccentricity(self, ecc: f32) -> Self

Reject stars with eccentricity above this threshold (filters elongated objects/trails). Default: 0.5. Set to 1.0 to disable.

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_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} {:>7} {:>8} {:>6} {:>6} {:>6} {:>7}",
        "FILE", "DET", "KEPT", "FWHM", "ECC", "SNR", "HFR", "SNR_dB", "SNR_W", "PSF_SIG", "W", "H", "R²", "TRAIL?"
    );
    println!("{}", "-".repeat(125));

    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.2} {:>7.3} {:>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_db,
                    r.snr_weight,
                    r.psf_signal,
                    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!("  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.

Trait Implementations

impl Default for ImageAnalyzer

fn default() -> Self

Returns the “default value” for a type.