Simplify some vector type conversions

Author: w1th0utnam3

splashsurf_lib/src/io/bgeo_format.rs

@@ -2,7 +2,7 @@
 
 use crate::io::io_utils::IteratorExt;
 use crate::mesh::{AttributeData, MeshAttribute};
-use crate::{Real, io::io_utils};
+use crate::{Real, RealConvert, io::io_utils};
 use anyhow::{Context, anyhow};
 use flate2::Compression;
 use flate2::read::GzDecoder;
@@ -47,13 +47,7 @@ pub fn particles_from_bgeo_file<R: Real>(
     // Convert the array storage into individual vectors
     let positions: Vec<_> = position_storage
         .chunks(3)
-        .map(|p| {
-            Vector3::new(
-                R::from_f32(p[0]).unwrap(),
-                R::from_f32(p[1]).unwrap(),
-                R::from_f32(p[2]).unwrap(),
-            )
-        })
+        .map(|p| Vector3::new(p[0], p[1], p[2]).try_convert().unwrap())
         .collect();
 
     Ok(positions)

splashsurf_lib/src/io/obj_format.rs

@@ -3,7 +3,7 @@
 use crate::mesh::{
     AttributeData, CellConnectivity, Mesh3d, MeshAttribute, MeshWithData, TriMesh3d,
 };
-use crate::{Real, io::io_utils, profile};
+use crate::{Real, RealConvert, io::io_utils, profile};
 use anyhow::Context;
 use nalgebra::Vector3;
 use std::fs;
@@ -82,10 +82,12 @@ pub fn surface_mesh_from_obj<R: Real, P: AsRef<Path>>(
 
     let buffer_to_vec3 = |buffer: &[&str]| -> Result<Vector3<R>, anyhow::Error> {
         Ok(Vector3::new(
-            R::from_f64(f64::from_str(buffer[0])?).unwrap(),
-            R::from_f64(f64::from_str(buffer[1])?).unwrap(),
-            R::from_f64(f64::from_str(buffer[2])?).unwrap(),
-        ))
+            f64::from_str(buffer[0])?,
+            f64::from_str(buffer[1])?,
+            f64::from_str(buffer[2])?,
+        )
+        .try_convert()
+        .unwrap())
     };
 
     let mut outer_buffer: Vec<&'static str> = Vec::new();

splashsurf_lib/src/io/ply_format.rs

@@ -4,7 +4,7 @@ use crate::io::io_utils::IteratorExt;
 use crate::mesh::{
     AttributeData, CellConnectivity, Mesh3d, MeshAttribute, MeshWithData, TriMesh3d,
 };
-use crate::{Real, profile};
+use crate::{Real, RealConvert, profile};
 use anyhow::{Context, anyhow};
 use nalgebra::Vector3;
 use num_traits::ToPrimitive;
@@ -53,11 +53,9 @@ fn parse_particles_from_ply<R: Real>(
             );
 
             let v = match vertex {
-                (Property::Float(x), Property::Float(y), Property::Float(z)) => Vector3::new(
-                    R::from_f32(*x).unwrap(),
-                    R::from_f32(*y).unwrap(),
-                    R::from_f32(*z).unwrap(),
-                ),
+                (Property::Float(x), Property::Float(y), Property::Float(z)) => {
+                    Vector3::new(*x, *y, *z).try_convert().unwrap()
+                }
                 _ => {
                     return Err(anyhow!(
                         "Vertex properties have wrong PLY data type (expected float)"
@@ -102,11 +100,9 @@ fn parse_mesh_from_ply<R: Real>(
     let mut vertices = Vec::with_capacity(vertices_normals.len());
 
     let load_vec3_property = |vertex: (&Property, &Property, &Property)| match vertex {
-        (Property::Float(x), Property::Float(y), Property::Float(z)) => Ok(Vector3::new(
-            R::from_f32(*x).unwrap(),
-            R::from_f32(*y).unwrap(),
-            R::from_f32(*z).unwrap(),
-        )),
+        (Property::Float(x), Property::Float(y), Property::Float(z)) => {
+            Ok(Vector3::new(*x, *y, *z).try_convert().unwrap())
+        }
         _ => Err(anyhow!(
             "Vertex properties have wrong PLY data type (expected float)"
         )),

splashsurf_lib/src/io/xyz_format.rs

@@ -1,6 +1,6 @@
 //! Helper functions for the binary `.xyz` float coordinate format
 
-use crate::Real;
+use crate::{Real, RealConvert};
 use anyhow::Context;
 use nalgebra::Vector3;
 use std::fs::File;
@@ -30,11 +30,7 @@ pub fn particles_from_xyz<R: Real, P: AsRef<Path>>(
         let x = f32::from_ne_bytes(get_four_bytes(&buffer, 0));
         let y = f32::from_ne_bytes(get_four_bytes(&buffer, 4));
         let z = f32::from_ne_bytes(get_four_bytes(&buffer, 8));
-        particles.push(Vector3::new(
-            R::from_f32(x).unwrap(),
-            R::from_f32(y).unwrap(),
-            R::from_f32(z).unwrap(),
-        ));
+        particles.push(Vector3::new(x, y, z).try_convert().unwrap());
     }
 
     Ok(particles)