Merge pull request #22 from rtk-rs/release

release v1.3

Author: gwbres

Cargo.toml

@@ -41,7 +41,7 @@ thiserror = "2"
 itertools = "0.14"
 anise = { version = "0.6", optional = true }
 gnss-rs = { version = "2.4.0", features = ["serde"] }
-gnss-qc-traits = { version = "0.2.0", optional = true }
+gnss-qc-traits = { version = "0.3.1", optional = true }
 hifitime = { version = "4.1", features = ["serde", "std"] }
 
 flate2 = { version = "1", optional = true, default-features = false, features = ["zlib"] }

src/entry.rs

@@ -174,17 +174,19 @@ impl SP3Entry {
         let mut formatted = format!(
             "P{}{}{}{}",
             sv,
-            CoordsFormatter::new(self.position_km.0),
-            CoordsFormatter::new(self.position_km.1),
-            CoordsFormatter::new(self.position_km.2),
+            CoordsFormatter::coordinates(self.position_km.0),
+            CoordsFormatter::coordinates(self.position_km.1),
+            CoordsFormatter::coordinates(self.position_km.2),
         );
 
         if let Some(value) = self.clock_us {
-            formatted.push_str(&format!("{}", CoordsFormatter::new(value)));
+            formatted.push_str(&format!("{}", CoordsFormatter::coordinates(value)));
         } else {
-            formatted.push_str("                            ");
+            formatted.push_str("              ");
         }
 
+        formatted.push_str("              "); // deviations not handled yet
+
         if self.clock_event {
             formatted.push('E');
         } else {
@@ -214,13 +216,13 @@ impl SP3Entry {
             formatted.push_str(&format!(
                 "\nV{}{}{}{}",
                 sv,
-                CoordsFormatter::new(vel_x_km),
-                CoordsFormatter::new(vel_y_km),
-                CoordsFormatter::new(vel_z_km),
+                CoordsFormatter::coordinates(vel_x_km),
+                CoordsFormatter::coordinates(vel_y_km),
+                CoordsFormatter::coordinates(vel_z_km),
             ));
 
             if let Some(drift_ns) = self.clock_drift_ns {
-                formatted.push_str(&format!("{}", CoordsFormatter::new(drift_ns)));
+                formatted.push_str(&format!("{}", CoordsFormatter::coordinates(drift_ns)));
             }
         }
 
@@ -553,6 +555,7 @@ VG01 -22859.768469  -8524.538983 -15063.229095\n",
                 "PG01  15402.861499  21607.418873   -992.500669
 VG01 -22859.768469  -8524.538983 -15063.229095     -3.292980\n",
             );
+
             let mut buf = BufWriter::new(Utf8Buffer::new(1024));
 
             data.format(g01, &mut buf).unwrap_or_else(|e| {
@@ -565,4 +568,34 @@ VG01 -22859.768469  -8524.538983 -15063.229095     -3.292980\n",
             assert_eq!(formatted, expected);
         }
     }
+
+    #[test]
+    fn sp3_d_predicted_entry_formatting() {
+        let g01 = SV::from_str("G01").unwrap();
+
+        let entry = SP3Entry {
+            position_km: (-22335.782004, -14656.280389, -1218.238499),
+            velocity_km_s: None,
+            predicted_clock: true,
+            predicted_orbit: true,
+            maneuver: true,
+            clock_event: true,
+            clock_us: Some(-176.397152),
+            clock_drift_ns: None,
+        };
+
+        let mut buf = BufWriter::new(Utf8Buffer::new(1024));
+
+        entry.format(g01, &mut buf).unwrap_or_else(|e| {
+            panic!("SP3/data formatting issue: {}", e);
+        });
+
+        let formatted = buf.into_inner().unwrap();
+        let formatted = formatted.to_ascii_utf8();
+
+        assert_eq!(
+            formatted,
+            "PG01 -22335.782004 -14656.280389  -1218.238499   -176.397152              EP  MP\n"
+        );
+    }
 }

src/formatting.rs

@@ -21,19 +21,35 @@ pub(crate) struct CoordsFormatter {
 }
 
 impl CoordsFormatter {
-    pub fn new(value: f64) -> Self {
+    pub fn coordinates(value: f64) -> Self {
         Self {
             value,
             width: 13,
             precision: 6,
         }
     }
+
+    pub fn fractional_mjd(value: f64) -> Self {
+        Self {
+            value,
+            width: 15,
+            precision: 13,
+        }
+    }
 }
 
 impl std::fmt::Display for CoordsFormatter {
     fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
         let value = self.value;
-        let sign_str = if value.is_sign_positive() { " " } else { "" };
+        let sign_str = if self.precision == 13 {
+            ""
+        } else {
+            if value.is_sign_positive() {
+                " "
+            } else {
+                ""
+            }
+        };
 
         let formatted = if value.is_sign_positive() {
             format!(
@@ -83,7 +99,7 @@ impl SP3 {
             //     ss,
             //     nanos / 10
             // )?;
-            writeln!(writer, "*  {}", formatter,)?;
+            writeln!(writer, "*  {}", formatter)?;
 
             for key in self
                 .data

src/header/line2.rs

@@ -1,7 +1,7 @@
 //! header line #2 helpers
 use std::io::{BufWriter, Write};
 
-use crate::{prelude::Duration, FormattingError, ParsingError};
+use crate::{formatting::CoordsFormatter, prelude::Duration, FormattingError, ParsingError};
 
 pub(crate) fn is_header_line2(content: &str) -> bool {
     content.starts_with("##")
@@ -81,14 +81,14 @@ impl Line2 {
 
         write!(
             w,
-            "##{:5} {:6}.{:08} {:5}.{:08} {:05} {:0.13}",
+            "##{:5} {:6}.{:08} {:5}.{:08} {:05} {}",
             self.week,
             week_seconds,
             week_nanos / 10,
             dt_seconds,
             dt_nanos / 10,
             self.mjd_fract.0,
-            self.mjd_fract.1,
+            CoordsFormatter::fractional_mjd(self.mjd_fract.1),
         )?;
 
         Ok(())

src/parsing.rs

@@ -151,7 +151,6 @@ impl SP3 {
                 if pc_count == 0 {
                     header.constellation = Constellation::from_str(line[3..5].trim())?;
                     timescale = TimeScale::from_str(line[9..12].trim())?;
-
                     header.timescale = timescale;
                 }
 

src/position.rs

@@ -186,4 +186,25 @@ mod test {
             assert_eq!(entry.orbit_prediction, orbit_prediction);
         }
     }
+
+    #[test]
+    fn sp3_d_predicted_position() {
+        let g01 = SV::from_str("G01").unwrap();
+
+        let content =
+            "PG01 -22335.782004 -14656.280389  -1218.238499   -176.397152 10  9 11 102 EP  MP";
+
+        let position = PositionEntry::from_str(content).unwrap_or_else(|e| {
+            panic!("Failed to parse predicted state \"{}\": {}", content, e);
+        });
+
+        assert_eq!(position.sv, g01);
+        assert_eq!(position.x_km, -22335.782004);
+        assert_eq!(position.y_km, -14656.280389);
+        assert_eq!(position.z_km, -1218.238499);
+        assert!(position.clock_event);
+        assert!(position.clock_prediction);
+        assert!(position.maneuver);
+        assert!(position.orbit_prediction);
+    }
 }