Initial GSSI reading functionality (#112)

Author: erikmannerfelt

Cargo.lock

@@ -1,6 +1,6 @@
 [package]
 name = "ridal"
-version = "0.5.1"
+version = "0.5.2"
 edition = "2021"
 readme = "README.md"
 description="Speeding up Ground Penetrating Radar (GPR) processing"

Cargo.toml

@@ -15,7 +15,7 @@ A near-term goal of Ridal is to enable easy conversion between formats, such as
 
 
 Much of the functionality has been inspired from the projects [RGPR](https://github.com/emanuelhuber/RGPR) and [ImpDAR](https://github.com/dlilien/ImpDAR); both of which are more mature projects.
-For example, Ridal currently only works on Malå (.rd3) and pulseEKKO (.dt1) radar formats.
+For example, Ridal currently only works on Malå (.rd3), GSSI (.dzt) and pulseEKKO (.dt1) radar formats.
 For many uses, these will more likely be the tools for you!
 
 ![Image of a glacier radargram](https://raw.githubusercontent.com/erikmannerfelt/ridal/v0.5.0/images/kroppbreen_rgm.webp)

README.md

@@ -29,7 +29,7 @@ rustPlatform.buildRustPackage {
   cargoLock.lockFile = ./Cargo.lock;
 
   buildNoDefaultFeatures = true;
-  buildFeatures = ["cli"];
+  buildFeatures = [ "cli" ];
 
   nativeBuildInputs = with pkgs; [
     pkg-config

default.nix

@@ -4,6 +4,7 @@ use std::path::{Path, PathBuf};
 pub enum FormatKind {
     Ramac,
     PulseEkko,
+    Gssi,
 }
 
 #[derive(Debug, Clone, serde::Serialize)]
@@ -64,6 +65,19 @@ pub fn all_formats() -> Vec<FormatInfo> {
                 coordinates: ".gp2",
             },
         },
+        FormatInfo {
+            name: "gssi",
+            description: "GSSI DZT/DZG format",
+            capabilities: FormatCapabilities {
+                read: true,
+                write: false,
+            },
+            files: FormatFiles {
+                header: ".DZT",
+                data: ".DZT",
+                coordinates: ".DZG",
+            },
+        },
     ]
 }
 
@@ -77,9 +91,37 @@ pub fn format_info(kind: FormatKind) -> FormatInfo {
             .into_iter()
             .find(|fmt| fmt.name == "pulseekko")
             .unwrap(),
+        FormatKind::Gssi => all_formats()
+            .into_iter()
+            .find(|fmt| fmt.name == "gssi")
+            .unwrap(),
     }
 }
 
+pub fn find_neighbor_case_insensitive(base: &Path, target_extension: &str) -> Option<PathBuf> {
+    let parent = base.parent().unwrap_or_else(|| Path::new("."));
+    let stem = base.file_stem().or_else(|| base.file_name())?.to_str()?;
+    let target_extension = target_extension.trim_start_matches('.');
+
+    std::fs::read_dir(parent)
+        .ok()?
+        .filter_map(|entry| entry.ok().map(|entry| entry.path()))
+        .find(|path| {
+            path.file_stem()
+                .and_then(|s| s.to_str())
+                .is_some_and(|s| s.eq_ignore_ascii_case(stem))
+                && path
+                    .extension()
+                    .and_then(|s| s.to_str())
+                    .is_some_and(|ext| ext.eq_ignore_ascii_case(target_extension))
+        })
+}
+
+fn resolve_sidecar(base: &Path, target_extension: &str) -> PathBuf {
+    find_neighbor_case_insensitive(base, target_extension)
+        .unwrap_or_else(|| base.with_extension(target_extension))
+}
+
 pub fn resolve_input(input: &Path) -> Result<ResolvedInput, String> {
     let ext = input
         .extension()
@@ -90,60 +132,90 @@ pub fn resolve_input(input: &Path) -> Result<ResolvedInput, String> {
         Some("rad") => Ok(ResolvedInput {
             input: input.to_path_buf(),
             kind: FormatKind::Ramac,
-            header: input.to_path_buf(),
-            data: input.with_extension("rd3"),
-            coordinates: input.with_extension("cor"),
+            header: resolve_sidecar(input, "rad"),
+            data: resolve_sidecar(input, "rd3"),
+            coordinates: resolve_sidecar(input, "cor"),
         }),
         Some("rd3") | Some("cor") => Ok(ResolvedInput {
             input: input.to_path_buf(),
             kind: FormatKind::Ramac,
-            header: input.with_extension("rad"),
-            data: input.with_extension("rd3"),
-            coordinates: input.with_extension("cor"),
+            header: resolve_sidecar(input, "rad"),
+            data: resolve_sidecar(input, "rd3"),
+            coordinates: resolve_sidecar(input, "cor"),
         }),
         Some("hd") => Ok(ResolvedInput {
             input: input.to_path_buf(),
             kind: FormatKind::PulseEkko,
-            header: input.to_path_buf(),
-            data: input.with_extension("dt1"),
-            coordinates: input.with_extension("gp2"),
+            header: resolve_sidecar(input, "hd"),
+            data: resolve_sidecar(input, "dt1"),
+            coordinates: resolve_sidecar(input, "gp2"),
         }),
         Some("dt1") | Some("gp2") => Ok(ResolvedInput {
             input: input.to_path_buf(),
             kind: FormatKind::PulseEkko,
-            header: input.with_extension("hd"),
-            data: input.with_extension("dt1"),
-            coordinates: input.with_extension("gp2"),
+            header: resolve_sidecar(input, "hd"),
+            data: resolve_sidecar(input, "dt1"),
+            coordinates: resolve_sidecar(input, "gp2"),
+        }),
+        Some("dzt") | Some("dzg") | Some("dzx") => Ok(ResolvedInput {
+            input: input.to_path_buf(),
+            kind: FormatKind::Gssi,
+            header: resolve_sidecar(input, "dzt"),
+            data: resolve_sidecar(input, "dzt"),
+            coordinates: resolve_sidecar(input, "dzg"),
         }),
         Some(other) => Err(format!(
-            "Unsupported input extension '.{other}' for {:?}. Supported formats are RAMAC (.rad/.rd3/.cor) and pulseEKKO (.hd/.dt1/.gp2).",
+            "Unsupported input extension '.{other}' for {:?}. Supported formats are RAMAC (.rad/.rd3/.cor), pulseEKKO (.hd/.dt1/.gp2), and GSSI (.dzt/.dzg/.dzx).",
             input
         )),
         None => {
-            let ramac = input.with_extension("rad");
-            let pulseekko = input.with_extension("hd");
-            match (ramac.is_file(), pulseekko.is_file()) {
-                (true, false) => Ok(ResolvedInput {
+            let ramac = find_neighbor_case_insensitive(input, "rad");
+            let pulseekko = find_neighbor_case_insensitive(input, "hd");
+            let gssi = find_neighbor_case_insensitive(input, "dzt");
+            match (ramac, pulseekko, gssi) {
+                (Some(ramac), None, None) => Ok(ResolvedInput {
                     input: input.to_path_buf(),
                     kind: FormatKind::Ramac,
                     header: ramac.clone(),
-                    data: ramac.with_extension("rd3"),
-                    coordinates: ramac.with_extension("cor"),
+                    data: resolve_sidecar(&ramac, "rd3"),
+                    coordinates: resolve_sidecar(&ramac, "cor"),
                 }),
-                (false, true) => Ok(ResolvedInput {
+                (None, Some(pulseekko), None) => Ok(ResolvedInput {
                     input: input.to_path_buf(),
                     kind: FormatKind::PulseEkko,
                     header: pulseekko.clone(),
-                    data: pulseekko.with_extension("dt1"),
-                    coordinates: pulseekko.with_extension("gp2"),
+                    data: resolve_sidecar(&pulseekko, "dt1"),
+                    coordinates: resolve_sidecar(&pulseekko, "gp2"),
+                }),
+                (None, None, Some(gssi)) => Ok(ResolvedInput {
+                    input: input.to_path_buf(),
+                    kind: FormatKind::Gssi,
+                    header: gssi.clone(),
+                    data: gssi.clone(),
+                    coordinates: resolve_sidecar(&gssi, "dzg"),
                 }),
-                (true, true) => Err(format!(
+                (Some(ramac), Some(pulseekko), None) => Err(format!(
                     "Ambiguous extension-less input {:?}: both {:?} and {:?} exist.",
                     input, ramac, pulseekko
                 )),
-                (false, false) => Err(format!(
-                    "Could not infer format for extension-less input {:?}. Tried {:?} and {:?}.",
-                    input, ramac, pulseekko
+                (Some(ramac), None, Some(gssi)) => Err(format!(
+                    "Ambiguous extension-less input {:?}: both {:?} and {:?} exist.",
+                    input, ramac, gssi
+                )),
+                (None, Some(pulseekko), Some(gssi)) => Err(format!(
+                    "Ambiguous extension-less input {:?}: both {:?} and {:?} exist.",
+                    input, pulseekko, gssi
+                )),
+                (Some(ramac), Some(pulseekko), Some(gssi)) => Err(format!(
+                    "Ambiguous extension-less input {:?}: {:?}, {:?}, and {:?} exist.",
+                    input, ramac, pulseekko, gssi
+                )),
+                (None, None, None) => Err(format!(
+                    "Could not infer format for extension-less input {:?}. Tried {:?}, {:?}, and {:?}.",
+                    input,
+                    input.with_extension("rad"),
+                    input.with_extension("hd"),
+                    input.with_extension("dzt")
                 )),
             }
         }
@@ -160,7 +232,14 @@ mod tests {
             .into_iter()
             .map(|fmt| fmt.name.to_string())
             .collect::<Vec<String>>();
-        assert_eq!(names, vec!["ramac".to_string(), "pulseekko".to_string()]);
+        assert_eq!(
+            names,
+            vec![
+                "ramac".to_string(),
+                "pulseekko".to_string(),
+                "gssi".to_string()
+            ]
+        );
     }
 
     #[test]
@@ -186,4 +265,43 @@ mod tests {
         assert_eq!(resolved.kind, FormatKind::PulseEkko);
         assert_eq!(resolved.header, PathBuf::from("line01.hd"));
     }
+
+    #[test]
+    fn test_resolve_gssi_extensions() {
+        let resolved = resolve_input(Path::new("line01.dzt")).unwrap();
+        assert_eq!(resolved.kind, FormatKind::Gssi);
+        assert_eq!(resolved.data, PathBuf::from("line01.dzt"));
+        assert_eq!(resolved.coordinates, PathBuf::from("line01.dzg"));
+
+        let resolved = resolve_input(Path::new("line01.dzg")).unwrap();
+        assert_eq!(resolved.kind, FormatKind::Gssi);
+        assert_eq!(resolved.header, PathBuf::from("line01.dzt"));
+    }
+
+    #[test]
+    fn test_resolve_case_insensitive_sidecars() {
+        let temp_dir = tempfile::tempdir().unwrap();
+        let rad = temp_dir.path().join("LINE01.RAD");
+        let rd3 = temp_dir.path().join("LINE01.RD3");
+        let cor = temp_dir.path().join("LINE01.COR");
+        std::fs::write(&rad, "").unwrap();
+        std::fs::write(&rd3, "").unwrap();
+        std::fs::write(&cor, "").unwrap();
+
+        let resolved = resolve_input(&temp_dir.path().join("LINE01")).unwrap();
+        assert_eq!(resolved.kind, FormatKind::Ramac);
+        assert_eq!(resolved.header, rad);
+        assert_eq!(resolved.data, rd3);
+        assert_eq!(resolved.coordinates, cor);
+
+        let dzt = temp_dir.path().join("TRACK.DZT");
+        let dzg = temp_dir.path().join("TRACK.DZG");
+        std::fs::write(&dzt, "").unwrap();
+        std::fs::write(&dzg, "").unwrap();
+
+        let resolved = resolve_input(&temp_dir.path().join("TRACK")).unwrap();
+        assert_eq!(resolved.kind, FormatKind::Gssi);
+        assert_eq!(resolved.header, dzt);
+        assert_eq!(resolved.coordinates, dzg);
+    }
 }

src/formats.rs

@@ -55,7 +55,9 @@ impl GPRMeta {
     /// # Arguments
     /// - `projected_crs`: The CRS to project coordinates into
     pub fn find_cor(&self, projected_crs: Option<&String>) -> Result<GPRLocation, Box<dyn Error>> {
-        io::load_cor(&self.data_filepath.with_extension("cor"), projected_crs)
+        let cor = crate::formats::find_neighbor_case_insensitive(&self.data_filepath, "cor")
+            .unwrap_or_else(|| self.data_filepath.with_extension("cor"));
+        io::load_cor(&cor, projected_crs)
     }
 }
 
@@ -740,15 +742,19 @@ impl GPR {
         metadata: GPRMeta,
     ) -> Result<GPR, Box<dyn Error>> {
         let data = match metadata.data_filepath.extension().and_then(|s| s.to_str()) {
-            Some("rd3") => Ok(io::load_rd3(
+            Some(ext) if ext.eq_ignore_ascii_case("rd3") => Ok(io::load_rd3(
                 &metadata.data_filepath,
                 metadata.samples as usize,
             )?),
-            Some("dt1") => Ok(io::load_pe_dt1(
+            Some(ext) if ext.eq_ignore_ascii_case("dt1") => Ok(io::load_pe_dt1(
                 &metadata.data_filepath,
                 metadata.samples as usize,
                 metadata.last_trace as usize,
             )?),
+            Some(ext) if ext.eq_ignore_ascii_case("dzt") => Ok(io::load_dzt(
+                &metadata.data_filepath,
+                metadata.samples as usize,
+            )?),
             _ => Err(format!("Unknown filetype: {:?}", metadata.data_filepath)),
         }?;
 
@@ -1817,6 +1823,17 @@ fn load_meta_and_location(
             let location = io::load_pe_gp2(&resolved.coordinates, crs)?;
             (meta, location)
         }
+        FormatKind::Gssi => {
+            if cor_path.is_some() {
+                return Err("The --cor option is only supported for RAMAC inputs.".into());
+            }
+            if !resolved.header.is_file() {
+                return Err(format!("File not found: {:?}", resolved.header).into());
+            }
+            let meta = io::load_gssi_dzt(&resolved.header, medium_velocity, override_antenna_mhz)?;
+            let location = io::load_gssi_dzg(&resolved.coordinates, crs)?;
+            (meta, location)
+        }
     };
 
     if let Some(dem_path) = dem_path {
@@ -2201,6 +2218,16 @@ fn load_single_gpr_for_grouping(
                 },
             )?
         }
+        FormatKind::Gssi => {
+            io::load_gssi_dzt(&resolved.header, medium_velocity, override_antenna_mhz).map_err(
+                |e| {
+                    format!(
+                        "Failed to load GSSI header '{}': {e}",
+                        resolved.header.display()
+                    )
+                },
+            )?
+        }
     };
 
     let mut location = if let Some(cor_override) = &cor_path {
@@ -2223,6 +2250,11 @@ fn load_single_gpr_for_grouping(
                 io::load_pe_gp2(gp2, crs.as_ref())
                     .map_err(|e| format!("Failed to load .gp2 '{}': {e}", gp2.display()))?
             }
+            FormatKind::Gssi => {
+                let dzg = &resolved.coordinates;
+                io::load_gssi_dzg(dzg, crs.as_ref())
+                    .map_err(|e| format!("Failed to load .dzg '{}': {e}", dzg.display()))?
+            }
         }
     };