remove unused code

Author: normanrz

matlab/rust/wkw_init/Cargo.toml

@@ -4,9 +4,6 @@ version = "1.4.0"
 authors = ["Alessandro Motta <[email protected]>"]
 build = "build.rs"
 
-[dependencies.wkwrap]
-path = "../../../rust"
-
 [dependencies.wkw_mex]
 path = "../wkw_mex"
 

matlab/rust/wkw_load/src/lib.rs

@@ -62,7 +62,6 @@ mex_function!(nlhs, lhs, nrhs, rhs, {
             bbox_start, bbox_shape, array_shape
         ));
     }
-    println!("{:?} {:?}", bbox_start, bbox_shape);
     let subset = zarrs_result_to_str_error(ArraySubset::new_with_start_shape(
         bbox_start.clone(),
         bbox_shape.clone(),
@@ -89,8 +88,6 @@ mex_function!(nlhs, lhs, nrhs, rhs, {
     let data_all = zarrs_result_to_str_error(array.retrieve_array_subset(&subset))?;
     let zarr_buf = zarrs_result_to_str_error(data_all.into_fixed())?.into_owned(); // in c-order
 
-    println!("zarr_buf: {:?}", zarr_buf);
-
     let mat_arr = create_numeric_array(&bbox_shape, mat_class, MxComplexity::Real)?;
 
     copy_as_fortran_order(&zarr_buf, mat_arr, &bbox_shape, type_size)?;

matlab/rust/wkw_mex/src/lib.rs

@@ -2,11 +2,9 @@ extern crate libc;
 extern crate wkwrap;
 
 mod ffi;
-mod util;
 mod macros;
-mod wkw;
+mod util;
 
 pub use ffi::*;
 pub use macros::*;
 pub use util::*;
-pub use wkw::*;

matlab/rust/wkw_mex/src/util.rs

@@ -17,31 +17,6 @@ pub fn as_nat(f: f64) -> Result<u64> {
     }
 }
 
-pub fn as_log2(f: f64) -> Result<u8> {
-    let i = as_nat(f)?;
-
-    match i & (i - 1) == 0 {
-        true => Ok(i.trailing_zeros() as u8),
-        false => Err("Input must be a power of two".to_string()),
-    }
-}
-
-pub fn str_slice_to_mx_class_id(class_id: &str) -> Result<MxClassId> {
-    match class_id {
-        "uint8" => Ok(MxClassId::Uint8),
-        "uint16" => Ok(MxClassId::Uint16),
-        "uint32" => Ok(MxClassId::Uint32),
-        "uint64" => Ok(MxClassId::Uint64),
-        "single" => Ok(MxClassId::Single),
-        "double" => Ok(MxClassId::Double),
-        "int8" => Ok(MxClassId::Int8),
-        "int16" => Ok(MxClassId::Int16),
-        "int32" => Ok(MxClassId::Int32),
-        "int64" => Ok(MxClassId::Int64),
-        _ => Err("Unknown MxClassId name".to_string()),
-    }
-}
-
 pub fn mx_array_to_str<'a>(pm: MxArray) -> Result<&'a str> {
     let pm_ptr = unsafe { mxArrayToUTF8String(pm) };
 
@@ -76,15 +51,6 @@ pub fn mx_array_to_f64_slice<'a>(pm: MxArray) -> Result<&'a [f64]> {
     }
 }
 
-pub fn mx_array_to_f64(pm: MxArray) -> Result<f64> {
-    let pm_slice = mx_array_to_f64_slice(pm)?;
-
-    match pm_slice.len() {
-        1 => Ok(pm_slice[0]),
-        _ => Err("MxArray contains an invalid number of doubles".to_string()),
-    }
-}
-
 pub fn mx_array_to_u8_slice<'a>(pm: MxArray) -> Result<&'a [u8]> {
     let numel = unsafe { mxGetNumberOfElements(pm) };
     let elem_size = unsafe { mxGetElementSize(pm) };
@@ -221,3 +187,57 @@ pub fn copy_as_fortran_order(
 
     Ok(())
 }
+
+fn f64_slice_to_vec(buf: &[f64]) -> Result<Vec<u64>> {
+    buf.iter()
+        .map(|x| as_nat(*x).or(Err("Invalid value".to_string())))
+        .collect()
+}
+
+pub fn mx_array_to_bbox(pm: MxArray, ndim: usize) -> Result<(Vec<u64>, Vec<u64>)> {
+    let buf = mx_array_to_f64_slice(pm)?;
+
+    // verify shape of array
+    let input_arg_shape = mx_array_size_to_usize_slice(pm);
+    if input_arg_shape != &[ndim, 2] {
+        return Err(format!(
+            "Bounding box has invalid shape. Needs to be [{}, 2]. Got {:?}.",
+            ndim, input_arg_shape
+        ));
+    }
+
+    let bbox_min_f64 = &buf[0..ndim];
+    let bbox_max_f64 = &buf[ndim..(ndim * 2)];
+    let bbox_min = f64_slice_to_vec(bbox_min_f64)
+        .or(Err(format!("Invalid lower bound. Got {:?}.", bbox_min_f64)))?;
+    let bbox_max = f64_slice_to_vec(bbox_max_f64)
+        .or(Err(format!("Invalid upper bound. Got {:?}.", bbox_max_f64)))?;
+
+    if bbox_min
+        .iter()
+        .zip(bbox_max.iter())
+        .any(|(min_x, max_x)| min_x >= max_x)
+    {
+        return Err(format!(
+            "Bounding box has invalid shape. Got min={:?}, max={:?}.",
+            bbox_min, bbox_max
+        ));
+    }
+
+    let bbox_shape: Vec<u64> = bbox_min
+        .iter()
+        .zip(bbox_max.iter())
+        .map(|(min_x, max_x)| max_x - min_x)
+        .collect();
+
+    let bbox_min = bbox_min.iter().map(|x| x - 1).collect();
+
+    if bbox_shape.iter().any(|x| *x < 1) {
+        return Err(format!(
+            "Bounding box has invalid shape. Got {:?}.",
+            bbox_shape
+        ));
+    }
+
+    Ok((bbox_min, bbox_shape))
+}