Star Catalogs¶

#[allow(unused_imports)]
use brahe as bh;
use bh::datasets::star_catalogs;
use bh::datasets::star_catalogs::StarRecord;

fn main() {
    // Download the Hipparcos catalog (cached permanently after the first download)
    let hipparcos = star_catalogs::get_hipparcos_catalog(None).unwrap();
    println!("Loaded {} Hipparcos records", hipparcos.len());

    // Filter to naked-eye-bright stars (Vmag < 5.2)
    let bright = hipparcos.filter_by_magnitude(5.2);
    println!("Stars brighter than Vmag 5.2: {}", bright.len());

    // Sort by magnitude and print the 5 brightest names
    let mut records = bright.records().to_vec();
    records.sort_by(|a, b| a.vmag.partial_cmp(&b.vmag).unwrap());

    println!("\n5 brightest stars:");
    for r in records.iter().take(5) {
        println!(
            "  {}: Vmag={:.2}",
            r.name().unwrap_or_else(|| r.id()),
            r.vmag.unwrap()
        );
    }

    let df = bright.to_dataframe().unwrap();
    let head = df.head(Some(5));
    println!("\nDataFrame head shape: {:?}", head.shape());
    println!("Columns: {:?}", head.get_column_names());
}

#[allow(unused_imports)]
use brahe as bh;
use bh::datasets::star_catalogs;
use bh::datasets::star_catalogs::StarRecord;

fn main() {
    // Download the FK5 catalog (cached permanently after the first download)
    let fk5 = star_catalogs::get_fk5_catalog(None).unwrap();
    println!("Loaded {} FK5 records", fk5.len());

    // Look up a specific star by its FK5 running number
    let rec = fk5.get_by_id(699).unwrap();
    let vmag_str = rec
        .vmag
        .map(|v| format!("{:.2}", v))
        .unwrap_or_else(|| "N/A".to_string());
    println!(
        "FK5 699: {}, ra={:.4} deg, dec={:.4} deg, vmag={}",
        rec.name().unwrap_or_else(|| rec.id()),
        rec.ra,
        rec.dec,
        vmag_str
    );

    // Magnitude filter: keeps vmag <= max_mag (smaller/more negative is brighter)
    let bright = fk5.filter_by_magnitude(3.0);
    println!("Stars brighter than Vmag 3.0: {}", bright.len());

    // Cone search around a right ascension/declination, in degrees
    let nearby = fk5.filter_by_cone(101.28, -16.72, 5.0, bh::AngleFormat::Degrees);
    println!("Stars within 5 deg of (101.28, -16.72): {}", nearby.len());

    // Chained: bright stars within 5 degrees of a target (filter methods
    // return a new catalog instance, so the original catalog is never
    // modified)
    let bright_nearby =
        fk5.filter_by_magnitude(3.0)
            .filter_by_cone(101.28, -16.72, 5.0, bh::AngleFormat::Degrees);
    println!("Bright stars within 5 deg of target: {}", bright_nearby.len());
    for r in bright_nearby.records() {
        println!("  {}: Vmag={:.2}", r.name().unwrap_or_else(|| r.id()), r.vmag.unwrap());
    }
}

#[allow(unused_imports)]
use brahe as bh;
use bh::datasets::star_catalogs;

fn main() {
    let hipparcos = star_catalogs::get_hipparcos_catalog(None).unwrap();

    let df = hipparcos.to_dataframe().unwrap();
    println!("DataFrame shape: {:?}", df.shape());
    println!("Columns: {:?}", df.get_column_names());

    // The `polars` dependency here is built with only the `lazy` feature and
    // isn't itself a nameable crate for this example, so filter with the
    // catalog's own `filter_by_magnitude` before exporting, rather than the
    // Python example's Polars-level `.str.contains()` expression.
    let bright = hipparcos.filter_by_magnitude(4.0);
    let bright_df = bright.to_dataframe().unwrap();
    println!("Stars brighter than Vmag 4.0: {}", bright_df.height());
}

#[allow(unused_imports)]
use brahe as bh;
use bh::datasets::star_catalogs;
use bh::datasets::star_catalogs::StarRecord;

fn main() {
    let hipparcos = star_catalogs::get_hipparcos_catalog(None).unwrap();

    // Magnitude filter: keeps vmag <= max_mag (smaller/more negative is brighter)
    let bright = hipparcos.filter_by_magnitude(2.0);
    println!("Stars brighter than Vmag 2.0: {}", bright.len());

    // Cone search around Sirius' catalog position, in degrees
    let nearby = bright.filter_by_cone(101.28, -16.72, 5.0, bh::AngleFormat::Degrees);
    println!("Bright stars within 5 deg of Sirius: {}", nearby.len());
    for r in nearby.records() {
        println!("  {}: Vmag={:.2}", r.name().unwrap_or_else(|| r.id()), r.vmag.unwrap());
    }

    // Propagate Sirius (HIP 32349) to a future epoch using radec_at_epoch
    // (same proper-motion transformation as apply_proper_motion, applied
    // directly to a catalog record)
    let sirius = hipparcos.get_by_id(32349).unwrap();
    let epc = bh::Epoch::from_datetime(2030, 1, 1, 0, 0, 0.0, 0.0, bh::TimeSystem::UTC);
    let (ra, dec) = sirius.radec_at_epoch(epc, bh::AngleFormat::Degrees);
    println!("\nSirius at J2030.0:   RA={:.6} deg, Dec={:.6} deg", ra, dec);
    println!(
        "Sirius at J1991.25:  RA={:.6} deg, Dec={:.6} deg",
        sirius.ra, sirius.dec
    );
}

#[allow(unused_imports)]
use brahe as bh;
use bh::datasets::star_catalogs;
use bh::datasets::star_catalogs::StarRecord;
use nalgebra as na;

fn main() {
    bh::initialize_eop().unwrap();

    // Download FK5 and look up a star by its running number
    let fk5 = star_catalogs::get_fk5_catalog(None).unwrap();
    let rec = fk5.get_by_id(699).unwrap();
    println!("FK5 699: {}", rec.name().unwrap_or_else(|| rec.id()));
    println!(
        "  Catalog (EME2000) position, J2000.0: RA={:.6} deg, Dec={:.6} deg",
        rec.ra, rec.dec
    );

    // Propagate the catalog position to the observation epoch with proper
    // motion. The FK5 axes are fixed and do not depend on the position epoch,
    // so the propagated (ra, dec) is still expressed on the EME2000 axes.
    let epc = bh::Epoch::from_datetime(2024, 3, 20, 12, 0, 0.0, 0.0, bh::TimeSystem::UTC);
    let (ra, dec) = rec.radec_at_epoch(epc, bh::AngleFormat::Degrees);
    println!("  Propagated to epoch:                 RA={ra:.6} deg, Dec={dec:.6} deg");

    // Direction as a unit vector on the EME2000 axes ...
    let u_eme2000 =
        bh::position_radec_to_inertial(na::Vector3::new(ra, dec, 1.0), bh::AngleFormat::Degrees);

    // ... rotated onto the GCRF/ICRS axes the IAU 2006/2000A transforms expect.
    let u_gcrf = bh::position_eme2000_to_gcrf(u_eme2000);

    // The frame bias is a small (~23 mas) but non-zero rotation.
    let sep_rad = u_eme2000.cross(&u_gcrf).norm().atan2(u_eme2000.dot(&u_gcrf));
    println!(
        "\nEME2000 -> GCRF frame-bias shift: {:.2} mas",
        sep_rad.to_degrees() * 3.6e6
    );

    // The GCRF direction can now be rotated into the Earth-fixed (ITRF) frame
    // with the IAU 2006/2000A CIO-based transform (e.g. for a topocentric
    // pointing).
    let u_itrf = bh::rotation_eci_to_ecef(epc) * u_gcrf;
    println!(
        "GCRF unit vector: [{:.6}, {:.6}, {:.6}]",
        u_gcrf[0], u_gcrf[1], u_gcrf[2]
    );
    println!(
        "ITRF unit vector: [{:.6}, {:.6}, {:.6}]",
        u_itrf[0], u_itrf[1], u_itrf[2]
    );
}