AttitudeTrajectory¶

use brahe as bh;
use brahe::attitude::Quaternion;
use brahe::frames::{BodyFrame, CelestialFrame, ReferenceFrame};
use brahe::time::{Epoch, TimeSystem};
use brahe::traits::Trajectory;
use brahe::trajectories::{AttitudeState, AttitudeTrajectory};
use nalgebra::Vector3;

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

    // A trajectory relates two frame endpoints: every stored quaternion
    // rotates from frame_a into frame_b.
    let mut traj = AttitudeTrajectory::new(
        ReferenceFrame::from(CelestialFrame::GCRF),
        ReferenceFrame::from(BodyFrame::SCBody(Some("1".to_string()))),
    );

    let epoch = Epoch::from_datetime(2024, 1, 1, 0, 0, 0.0, 0.0, TimeSystem::UTC);
    traj.add(epoch, AttitudeState::new(Quaternion::new(1.0, 0.0, 0.0, 0.0)))
        .unwrap();

    println!("frame_a:   {}", traj.frame_a);
    println!("frame_b:   {}", traj.frame_b);
    println!("States:    {}", traj.len());
    println!("has_rates: {}", traj.has_rates());

    // The first state carries no angular velocity, so every later state must
    // omit it as well. Adding a rate-carrying state to a rate-free trajectory
    // is rejected rather than producing a mixed trajectory.
    let with_rate = AttitudeState::new(Quaternion::new(1.0, 0.0, 0.0, 0.0))
        .with_angular_velocity(Vector3::new(0.0, 0.0, 0.01));
    match traj.add(epoch + 60.0, with_rate) {
        Ok(()) => println!("\nMixed rate accepted"),
        Err(e) => println!("\nMixed rate rejected: {}", e),
    }
}

use brahe as bh;
use brahe::attitude::{Quaternion, ToAttitude};
use brahe::frames::{BodyFrame, CelestialFrame, OrientationProvider, ReferenceFrame};
use brahe::time::{Epoch, TimeSystem};
use brahe::traits::Trajectory;
use brahe::trajectories::{AttitudeInterpolationMethod, AttitudeState, AttitudeTrajectory};

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

    // Two attitude samples 60 seconds apart: a constant-rate rotation of
    // 2 deg/s about the spacecraft Z axis, from 0 to 120 degrees.
    let mut traj = AttitudeTrajectory::new(
        ReferenceFrame::from(CelestialFrame::GCRF),
        ReferenceFrame::from(BodyFrame::SCBody(None)),
    );

    let t0 = Epoch::from_datetime(2024, 1, 1, 0, 0, 0.0, 0.0, TimeSystem::UTC);
    let t1 = t0 + 60.0;
    let q0 = Quaternion::new(1.0, 0.0, 0.0, 0.0);
    let half_angle = 60.0_f64.to_radians();
    let q1 = Quaternion::new(half_angle.cos(), 0.0, 0.0, half_angle.sin());
    traj.add(t0, AttitudeState::new(q0)).unwrap();
    traj.add(t1, AttitudeState::new(q1)).unwrap();

    // Query one third of the way between the two nodes. At the exact
    // midpoint, linear interpolation of a single-axis rotation happens to
    // coincide with slerp, so an off-center query is needed to see them
    // diverge.
    let query = t0 + 20.0;

    traj.set_interpolation_method(AttitudeInterpolationMethod::Slerp);
    let slerp_q = traj.quaternion(query).unwrap();

    traj.set_interpolation_method(AttitudeInterpolationMethod::Linear);
    let linear_q = traj.quaternion(query).unwrap();

    let slerp_angle_deg = slerp_q.to_euler_axis().angle.to_degrees();
    let linear_angle_deg = linear_q.to_euler_axis().angle.to_degrees();

    println!("Query epoch: {} (1/3 of the way from t0 to t1)", query);
    println!("Slerp  rotation angle:  {:.4} deg (exact)", slerp_angle_deg);
    println!(
        "Linear rotation angle:  {:.4} deg (approximate)",
        linear_angle_deg
    );
}

use brahe as bh;
use brahe::attitude::{EulerAngleOrder, Quaternion};
use brahe::frames::{BodyFrame, CelestialFrame, OrientationProvider, ReferenceFrame};
use brahe::time::{Epoch, TimeSystem};
use brahe::traits::Trajectory;
use brahe::trajectories::{AttitudeState, AttitudeTrajectory};
use nalgebra::Vector3;

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

    // Two samples 60 seconds apart, rotating about the spacecraft Z axis at
    // 0.01 rad/s. The rate is carried on both states, so angular_velocity is
    // available alongside the attitude.
    let mut traj = AttitudeTrajectory::new(
        ReferenceFrame::from(CelestialFrame::GCRF),
        ReferenceFrame::from(BodyFrame::SCBody(Some("1".to_string()))),
    );

    let omega = Vector3::new(0.0, 0.0, 0.01);
    let t0 = Epoch::from_datetime(2024, 1, 1, 0, 0, 0.0, 0.0, TimeSystem::UTC);
    let t1 = t0 + 60.0;
    let half_angle = 0.5 * omega[2] * 60.0;
    traj.add(
        t0,
        AttitudeState::new(Quaternion::new(1.0, 0.0, 0.0, 0.0)).with_angular_velocity(omega),
    )
    .unwrap();
    traj.add(
        t1,
        AttitudeState::new(Quaternion::new(half_angle.cos(), 0.0, 0.0, half_angle.sin()))
            .with_angular_velocity(omega),
    )
    .unwrap();

    // Every accessor evaluates the same interpolated attitude and returns it
    // in a different representation.
    let epoch = t0 + 30.0;
    let quaternion = traj.quaternion(epoch).unwrap();
    let angles = traj.euler_angle(epoch, EulerAngleOrder::ZYX).unwrap();
    let axis = traj.euler_axis(epoch).unwrap();
    let matrix = traj.rotation_matrix(epoch).unwrap().to_matrix();
    let rate = traj.angular_velocity(epoch).unwrap().unwrap();

    let q = quaternion.to_vector(true);
    let (start, end) = traj.coverage().unwrap();
    println!("Coverage:    {} to {}", start, end);
    println!("Query epoch: {}", epoch);
    println!(
        "Quaternion:  s {:.6}, v {:.6} {:.6} {:.6}",
        q[0], q[1], q[2], q[3]
    );
    println!(
        "Euler ZYX:   {:.4}, {:.4}, {:.4} deg",
        angles.phi.to_degrees(),
        angles.theta.to_degrees(),
        angles.psi.to_degrees()
    );
    println!(
        "Euler axis:  {:.4} {:.4} {:.4}, angle {:.4} deg",
        axis.axis[0],
        axis.axis[1],
        axis.axis[2],
        axis.angle.to_degrees()
    );
    println!("Rotation matrix:");
    for row in matrix.row_iter() {
        println!("  {:9.6} {:9.6} {:9.6}", row[0], row[1], row[2]);
    }
    println!("Rate:        {:.4} {:.4} {:.4} rad/s", rate[0], rate[1], rate[2]);
}