Merge pull request #27 from pmarks/pmarks/fix-slices

Some fixes for slice API

Author: aldanor

hdf5-rs/src/hl/container.rs

@@ -56,8 +56,9 @@ impl<'a> Reader<'a> {
     }
 
     /// Reads a slice of an n-dimensional array.
-    /// If the array has a fixed number of dimensions, it must match the dimensionality of
-    /// dataset. Use the multi-dimensional slice macro `s![]` from `ndarray` to conveniently create
+    /// If the dimensionality `D` has a fixed number of dimensions, it must match the dimensionality of
+    /// the slice, after singleton dimensions are dropped. 
+    /// Use the multi-dimensional slice macro `s![]` from `ndarray` to conveniently create
     /// a multidimensional slice.
     pub fn read_slice<T, S, D>(&self, slice: &SliceInfo<S, D>) -> Result<Array<T, D>>
     where
@@ -68,10 +69,6 @@ impl<'a> Reader<'a> {
         ensure!(!self.obj.is_attr(), "slicing cannot be used on attribute datasets");
 
         let shape = self.obj.get_shape()?;
-        if let Some(ndim) = D::NDIM {
-            let obj_ndim = shape.ndim();
-            ensure!(obj_ndim == ndim, "ndim mismatch: expected {}, got {}", ndim, obj_ndim);
-        }
 
         let slice_s: &[SliceOrIndex] = slice.as_ref();
         let slice_dim = slice_s.len();
@@ -86,7 +83,14 @@ impl<'a> Reader<'a> {
         }
 
         if shape.ndim() == 0 {
-            // Fall back to a simple read for the scalar case, slicing has no effect
+            // Check that return dimensionality is 0.
+            if let Some(ndim) = D::NDIM {
+                let obj_ndim = 0;
+                ensure!(obj_ndim == ndim, "ndim mismatch: slice outputs dims {}, output type dims {}", obj_ndim, ndim);
+            }
+
+            // Fall back to a simple read for the scalar case
+            // Slicing has no effect
             self.read()
         } else {
             let fspace = self.obj.space()?;
@@ -102,6 +106,14 @@ impl<'a> Reader<'a> {
                 })
                 .collect();
 
+            // *Output* dimensionality must match the reduced shape,
+            // (i.e. dimensionality after singleton 'SliceOrIndex::Index'
+            // axes are dropped.
+            if let Some(ndim) = D::NDIM {
+                let obj_ndim = reduced_shape.len();
+                ensure!(obj_ndim == ndim, "ndim mismatch: slice outputs dims {}, output type dims {}", obj_ndim, ndim);
+            }
+
             let mspace = Dataspace::try_new(&out_shape, false)?;
             let size = out_shape.iter().product();
             let mut vec = Vec::with_capacity(size);
@@ -149,9 +161,8 @@ impl<'a> Reader<'a> {
     }
 
     /// Reads the given `slice` of the dataset into a 1-dimensional array.
-    ///
-    /// The dataset must be 1-dimensional.
-    pub fn read_slice_1d<T, S>(&self, slice: &SliceInfo<S, Ix1>) -> Result<Array1<T>>
+    /// The slice must yield a 1-dimensional result.
+    pub fn read_slice_1d<T, S>(&self, slice: &SliceInfo<S, ndarray::Ix1>) -> Result<Array1<T>>
     where
         T: H5Type,
         S: AsRef<[SliceOrIndex]>,
@@ -166,10 +177,10 @@ impl<'a> Reader<'a> {
         self.read()
     }
 
+
     /// Reads the given `slice` of the dataset into a 2-dimensional array.
-    ///
-    /// The dataset must be 2-dimensional.
-    pub fn read_slice_2d<T, S>(&self, slice: &SliceInfo<S, Ix2>) -> Result<Array2<T>>
+    /// The slice must yield a 2-dimensional result.
+    pub fn read_slice_2d<T, S>(&self, slice: &SliceInfo<S, ndarray::Ix2>) -> Result<Array2<T>>
     where
         T: H5Type,
         S: AsRef<[SliceOrIndex]>,
@@ -251,11 +262,6 @@ impl<'a> Writer<'a> {
         ensure!(!self.obj.is_attr(), "slicing cannot be used on attribute datasets");
 
         let shape = self.obj.get_shape()?;
-        if let Some(ndim) = D::NDIM {
-            let obj_ndim = shape.ndim();
-            ensure!(obj_ndim == ndim, "ndim mismatch: expected {}, got {}", ndim, obj_ndim);
-        }
-
         let slice_s: &[SliceOrIndex] = slice.as_ref();
         let slice_dim = slice_s.len();
         if shape.ndim() != slice_dim {
@@ -490,18 +496,52 @@ impl Container {
         self.as_reader().read_1d()
     }
 
+    /// Reads the given `slice` of the dataset into a 1-dimensional array.
+    /// The slice must yield a 1-dimensional result.
+    pub fn read_slice_1d<T, S>(&self, slice: &SliceInfo<S, ndarray::Ix1>) -> Result<Array1<T>>
+    where
+        T: H5Type,
+        S: AsRef<[SliceOrIndex]>,
+    {
+        self.as_reader().read_slice_1d(slice)
+    }
+
     /// Reads a dataset/attribute into a 2-dimensional array.
     ///
     /// The dataset/attribute must be 2-dimensional.
     pub fn read_2d<T: H5Type>(&self) -> Result<Array2<T>> {
         self.as_reader().read_2d()
     }
 
+    /// Reads the given `slice` of the dataset into a 1-dimensional array.
+    /// The slice must yield a 2-dimensional result.
+    pub fn read_slice_2d<T, S>(&self, slice: &SliceInfo<S, ndarray::Ix2>) -> Result<Array2<T>>
+    where
+        T: H5Type,
+        S: AsRef<[SliceOrIndex]>,
+    {
+        self.as_reader().read_slice_2d(slice)
+    }
+
     /// Reads a dataset/attribute into an array with dynamic number of dimensions.
     pub fn read_dyn<T: H5Type>(&self) -> Result<ArrayD<T>> {
         self.as_reader().read_dyn()
     }
 
+    /// Reads a slice of an n-dimensional array.
+    /// If the dimensionality `D` has a fixed number of dimensions, it must match the dimensionality of
+    /// the slice, after singleton dimensions are dropped. 
+    /// Use the multi-dimensional slice macro `s![]` from `ndarray` to conveniently create
+    /// a multidimensional slice.
+    pub fn read_slice<T, S, D>(&self, slice: &SliceInfo<S, D>) -> Result<Array<T, D>>
+    where
+        T: H5Type,
+        S: AsRef<[SliceOrIndex]>,
+        D: ndarray::Dimension,
+    {
+        self.as_reader().read_slice(slice)
+    }
+
     /// Reads a scalar dataset/attribute.
     pub fn read_scalar<T: H5Type>(&self) -> Result<T> {
         self.as_reader().read_scalar()
@@ -533,6 +573,21 @@ impl Container {
         self.as_writer().write_raw(arr)
     }
 
+    /// Writes all data from the array `arr` into the given `slice` of the target dataset.
+    /// The shape of `arr` must match the shape the set of elements included in the slice.
+    /// If the array has a fixed number of dimensions, it must match the dimensionality of
+    /// dataset. Use the multi-dimensional slice macro `s![]` from `ndarray` to conveniently create
+    /// a multidimensional slice.
+    pub fn write_slice<'b, A, T, S, D>(&self, arr: A, slice: &SliceInfo<S, D>) -> Result<()>
+    where
+        A: Into<ArrayView<'b, T, D>>,
+        T: H5Type,
+        S: AsRef<[SliceOrIndex]>,
+        D: ndarray::Dimension,
+    {
+        self.as_writer().write_slice(arr, slice)
+    }
+
     /// Writes a scalar dataset/attribute.
     pub fn write_scalar<T: H5Type>(&self, val: &T) -> Result<()> {
         self.as_writer().write_scalar(val)

hdf5-rs/src/hl/space.rs

@@ -56,10 +56,8 @@ impl Dataspace {
     /// Select a slice (known as a 'hyperslab' in HDF5 terminology) of the Dataspace.
     /// Returns the shape of array that is capable of holding the resulting slice.
     /// Useful when you want to read a subset of a dataset.
-    pub fn select_slice<T, D>(&self, slice: &SliceInfo<T, D>) -> Result<Vec<Ix>>
-    where
-        T: AsRef<[SliceOrIndex]>,
-        D: ndarray::Dimension,
+    pub fn select_slice<S>(&self, slice: S) -> Result<Vec<Ix>>
+    where S: AsRef<[SliceOrIndex]>
     {
         let shape = self.dims();
         let ss: &[SliceOrIndex] = slice.as_ref();

hdf5-rs/tests/test_dataset.rs

@@ -1,6 +1,6 @@
 use std::fmt;
 
-use ndarray::{ArrayD, IxDyn, SliceInfo};
+use ndarray::{s, Array1, Array2, ArrayD, IxDyn, SliceInfo};
 use rand::prelude::{Rng, SeedableRng, SmallRng};
 
 use hdf5_types::TypeDescriptor;
@@ -40,7 +40,7 @@ where
 }
 
 fn test_read_slice<T, R>(
-    rng: &mut R, ds: &h5::Dataset, arr: &ArrayD<T>, _ndim: usize,
+    rng: &mut R, ds: &h5::Dataset, arr: &ArrayD<T>, ndim: usize,
 ) -> h5::Result<()>
 where
     T: h5::H5Type + fmt::Debug + PartialEq + Gen,
@@ -81,6 +81,24 @@ where
     let bad_sliced_read: h5::Result<ArrayD<T>> = dsr.read_slice(&bad_slice);
     assert!(bad_sliced_read.is_err());
 
+    // Tests for dimension-dropping slices with static dimensionality.
+    if ndim == 2 && shape[0] > 0 && shape[1] > 0 {
+        let v: Array1<T> = dsr.read_slice_1d(s![0, ..])?;
+        assert_eq!(shape[1], v.shape()[0]);
+
+        let v: Array1<T> = dsr.read_slice_1d(s![.., 0])?;
+        assert_eq!(shape[0], v.shape()[0]);
+    } 
+
+    if ndim == 3 && shape[0] > 0 && shape[1] > 0 && shape[2] > 0 {
+        let v: Array2<T> = dsr.read_slice_2d(s![0, .., ..])?;
+        assert_eq!(shape[1], v.shape()[0]);
+        assert_eq!(shape[2], v.shape()[1]);
+
+        let v: Array1<T> = dsr.read_slice_1d(s![0, 0, ..])?;
+        assert_eq!(shape[2], v.shape()[0]);
+    } 
+
     Ok(())
 }