Added examples for datasets

Update #318

examples/hdfgroup/H5D/CMakeLists.txt

@@ -12,4 +12,19 @@ add_executable(h5ex_d_compact h5ex_d_compact.cpp)
 target_link_libraries(h5ex_d_compact h5cpp)
 
 add_executable(h5ex_d_fillval h5ex_d_fillval.cpp)
-target_link_libraries(h5ex_d_fillval h5cpp)
+target_link_libraries(h5ex_d_fillval h5cpp)
+
+add_executable(h5ex_d_hyper h5ex_d_hyper.cpp)
+target_link_libraries(h5ex_d_hyper h5cpp)
+
+add_executable(h5ex_d_rdwr h5ex_d_rdwr.cpp)
+target_link_libraries(h5ex_d_rdwr h5cpp)
+
+add_executable(h5ex_d_shuffle h5ex_d_shuffle.cpp)
+target_link_libraries(h5ex_d_shuffle h5cpp)
+
+add_executable(h5ex_d_transform h5ex_d_transform.cpp)
+target_link_libraries(h5ex_d_transform h5cpp)
+
+add_executable(h5ex_d_unlimadd h5ex_d_unlimadd.cpp)
+target_link_libraries(h5ex_d_unlimadd h5cpp)

examples/hdfgroup/H5D/h5ex_d_gzip.cpp

@@ -0,0 +1,181 @@
+/************************************************************
+
+  This example shows how to read and write data to a dataset
+  using gzip compression (also called zlib or deflate).  The
+  program first checks if gzip compression is available,
+  then if it is it writes integers to a dataset using gzip,
+  then closes the file.  Next, it reopens the file, reads
+  back the data, and outputs the type of compression and the
+  maximum value in the dataset to the screen.
+
+  This file is intended for use with HDF5 Library version 1.8
+
+ ************************************************************/
+
+#include "hdf5.h"
+#include <stdio.h>
+#include <stdlib.h>
+
+#define FILE            "h5ex_d_gzip.h5"
+#define DATASET         "DS1"
+#define DIM0            32
+#define DIM1            64
+#define CHUNK0          4
+#define CHUNK1          8
+
+int
+main (void)
+{
+    hid_t           file, space, dset, dcpl;    /* Handles */
+    herr_t          status;
+    htri_t          avail;
+    H5Z_filter_t    filter_type;
+    hsize_t         dims[2] = {DIM0, DIM1},
+                    chunk[2] = {CHUNK0, CHUNK1};
+    size_t          nelmts;
+    unsigned int    flags,
+                    filter_info;
+    int             wdata[DIM0][DIM1],          /* Write buffer */
+                    rdata[DIM0][DIM1],          /* Read buffer */
+                    max,
+                    i, j;
+
+    /*
+     * Check if gzip compression is available and can be used for both
+     * compression and decompression.  Normally we do not perform error
+     * checking in these examples for the sake of clarity, but in this
+     * case we will make an exception because this filter is an
+     * optional part of the hdf5 library.
+     */
+    avail = H5Zfilter_avail(H5Z_FILTER_DEFLATE);
+    if (!avail) {
+        printf ("gzip filter not available.\n");
+        return 1;
+    }
+    status = H5Zget_filter_info (H5Z_FILTER_DEFLATE, &filter_info);
+    if ( !(filter_info & H5Z_FILTER_CONFIG_ENCODE_ENABLED) ||
+                !(filter_info & H5Z_FILTER_CONFIG_DECODE_ENABLED) ) {
+        printf ("gzip filter not available for encoding and decoding.\n");
+        return 1;
+    }
+
+    /*
+     * Initialize data.
+     */
+    for (i=0; i<DIM0; i++)
+        for (j=0; j<DIM1; j++)
+            wdata[i][j] = i * j - j;
+
+    /*
+     * Create a new file using the default properties.
+     */
+    file = H5Fcreate (FILE, H5F_ACC_TRUNC, H5P_DEFAULT, H5P_DEFAULT);
+
+    /*
+     * Create dataspace.  Setting maximum size to NULL sets the maximum
+     * size to be the current size.
+     */
+    space = H5Screate_simple (2, dims, NULL);
+
+    /*
+     * Create the dataset creation property list, add the gzip
+     * compression filter and set the chunk size.
+     */
+    dcpl = H5Pcreate (H5P_DATASET_CREATE);
+    status = H5Pset_deflate (dcpl, 9);
+    status = H5Pset_chunk (dcpl, 2, chunk);
+
+    /*
+     * Create the dataset.
+     */
+    dset = H5Dcreate (file, DATASET, H5T_STD_I32LE, space, H5P_DEFAULT, dcpl,
+                H5P_DEFAULT);
+
+    /*
+     * Write the data to the dataset.
+     */
+    status = H5Dwrite (dset, H5T_NATIVE_INT, H5S_ALL, H5S_ALL, H5P_DEFAULT,
+                wdata[0]);
+
+    /*
+     * Close and release resources.
+     */
+    status = H5Pclose (dcpl);
+    status = H5Dclose (dset);
+    status = H5Sclose (space);
+    status = H5Fclose (file);
+
+
+    /*
+     * Now we begin the read section of this example.
+     */
+
+    /*
+     * Open file and dataset using the default properties.
+     */
+    file = H5Fopen (FILE, H5F_ACC_RDONLY, H5P_DEFAULT);
+    dset = H5Dopen (file, DATASET, H5P_DEFAULT);
+
+    /*
+     * Retrieve dataset creation property list.
+     */
+    dcpl = H5Dget_create_plist (dset);
+
+    /*
+     * Retrieve and print the filter type.  Here we only retrieve the
+     * first filter because we know that we only added one filter.
+     */
+    nelmts = 0;
+    filter_type = H5Pget_filter (dcpl, 0, &flags, &nelmts, NULL, 0, NULL,
+                &filter_info);
+    printf ("Filter type is: ");
+    switch (filter_type) {
+        case H5Z_FILTER_DEFLATE:
+            printf ("H5Z_FILTER_DEFLATE\n");
+            break;
+        case H5Z_FILTER_SHUFFLE:
+            printf ("H5Z_FILTER_SHUFFLE\n");
+            break;
+        case H5Z_FILTER_FLETCHER32:
+            printf ("H5Z_FILTER_FLETCHER32\n");
+            break;
+        case H5Z_FILTER_SZIP:
+            printf ("H5Z_FILTER_SZIP\n");
+            break;
+        case H5Z_FILTER_NBIT:
+            printf ("H5Z_FILTER_NBIT\n");
+            break;
+        case H5Z_FILTER_SCALEOFFSET:
+            printf ("H5Z_FILTER_SCALEOFFSET\n");
+    }
+
+    /*
+     * Read the data using the default properties.
+     */
+    status = H5Dread (dset, H5T_NATIVE_INT, H5S_ALL, H5S_ALL, H5P_DEFAULT,
+                rdata[0]);
+
+    /*
+     * Find the maximum value in the dataset, to verify that it was
+     * read correctly.
+     */
+    max = rdata[0][0];
+    for (i=0; i<DIM0; i++)
+        for (j=0; j<DIM1; j++)
+            if (max < rdata[i][j])
+                max = rdata[i][j];
+
+    /*
+     * Print the maximum value.
+     */
+    printf ("Maximum value in %s is: %d\n", DATASET, max);
+
+    /*
+     * Close and release resources.
+     */
+    status = H5Pclose (dcpl);
+    status = H5Dclose (dset);
+    status = H5Fclose (file);
+
+    return 0;
+}

examples/hdfgroup/H5D/h5ex_d_hyper.cpp

@@ -0,0 +1,113 @@
+/************************************************************
+
+  This example shows how to read and write data to a
+  dataset by hyberslabs.  The program first writes integers
+  in a hyperslab selection to a dataset with dataspace
+  dimensions of DIM0xDIM1, then closes the file.  Next, it
+  reopens the file, reads back the data, and outputs it to
+  the screen.  Finally it reads the data again using a
+  different hyperslab selection, and outputs the result to
+  the screen.
+
+  This file is intended for use with HDF5 Library version 1.8
+
+ ************************************************************/
+
+#include <h5cpp/hdf5.hpp>
+#include "matrix_hdf5.hpp"
+#include <algorithm>
+
+#define FILE            "h5ex_d_hyper.h5"
+#define DATASET         "DS1"
+#define DIM0            6
+#define DIM1            8
+
+using Int32Matrix = Matrix<int32_t,DIM0,DIM1>;
+using namespace hdf5;
+
+void write ()
+{
+  Int32Matrix wdata;
+  std::fill (wdata.begin (), wdata.end (), 1);
+
+  // Print the data to the screen.
+  std::cout << "Original Data:" << std::endl;
+  std::cout << wdata << std::endl;
+
+  // Create a new file using the default properties.
+  file::File file = file::create (FILE, file::AccessFlags::TRUNCATE);
+
+  // Create dataspace.  Setting maximum size to NULL sets the maximum
+  // size to be the current size.
+  dataspace::Simple space ({ DIM0, DIM1 });
+
+  // Create the dataset.  We will use all default properties for this
+  // example.
+  node::Dataset dset (file.root (), DATASET, datatype::create<int32_t> (),
+                      space);
+
+  // Define and select the first part of the hyperslab selection.
+  dataspace::Hyperslab hyperslab1 (  { 0, 0 },  //offset
+                                     { 2, 2 },  //block
+                                     { 2, 3 },  //count
+                                     { 3, 3 }); //stride
+
+  // Define and select the second part of the hyperslab selection.
+  dataspace::Hyperslab hyperslab2 (  { 0, 0 },  //offset
+                                     { 1, 1 },  //block
+                                     { 2, 3 },  //count
+                                     { 3, 3 }); //stride
+
+  //apply the hyperslabs to the dataspace
+  space.selection (dataspace::SelectionOperation::SET, hyperslab1);
+  space.selection (dataspace::SelectionOperation::NOTB, hyperslab2);
+
+
+  //Write the data to the dataset.
+  dset.write (wdata, datatype::create (wdata), space,
+              space);
+}
+
+void read()
+{
+  // Open file and dataset using the default properties.
+  file::File file = file::open(FILE,file::AccessFlags::READONLY);
+  node::Dataset dset = file.root().nodes[DATASET];
+
+
+  // Read the data using the default properties.
+  Int32Matrix rdata;
+  dset.read(rdata);
+
+  // Output the data to the screen.
+
+  std::cout<<"Data as written to disk by hyberslabs:"<<std::endl;
+  std::cout<<rdata<<std::endl;
+
+  // Initialize the read array.
+  std::fill(rdata.begin(),rdata.end(),0);
+
+  // Define and select the hyperslab to use for reading.
+  dataspace::Dataspace space = dset.dataspace();
+  dataspace::Hyperslab hyperslab( {0,1},   // offset
+                                  {2,3},   // block
+                                  {2,2},   // count
+                                  {4,4});  // stride
+  space.selection(dataspace::SelectionOperation::SET,hyperslab);
+
+  // Read the data using the previously defined hyperslab.
+  dset.read(rdata,datatype::create(rdata),space,space);
+
+  // Output the data to the screen.
+  std::cout<<"Data as read from disk by hyperslab:"<<std::endl;
+  std::cout<<rdata<<std::endl;
+}
+
+int
+main (void)
+{
+  write();
+  read();
+
+  return 0;
+}

examples/hdfgroup/H5D/h5ex_d_rdwr.cpp

@@ -0,0 +1,75 @@
+/************************************************************
+
+  This example shows how to read and write data to a
+  dataset.  The program first writes integers to a dataset
+  with dataspace dimensions of DIM0xDIM1, then closes the
+  file.  Next, it reopens the file, reads back the data, and
+  outputs it to the screen.
+
+  This file is intended for use with HDF5 Library version 1.8
+
+ ************************************************************/
+
+#include <h5cpp/hdf5.hpp>
+#include "matrix_hdf5.hpp"
+
+#define FILE            "h5ex_d_rdwr.h5"
+#define DATASET         "DS1"
+#define DIM0            4
+#define DIM1            7
+
+using Int32Matrix = Matrix<int32_t,DIM0,DIM1>;
+using namespace hdf5;
+
+void write()
+{
+  Int32Matrix wdata;
+
+  // Initialize data.
+  for (int32_t i = 0; i < DIM0; i++)
+    for (int32_t j = 0; j < DIM1; j++)
+      wdata (i, j) = i * j - j;
+
+
+  // Create a new file using the default properties.
+  file::File file = file::create (FILE, file::AccessFlags::TRUNCATE);
+
+  // Create dataspace.  Setting maximum size to NULL sets the maximum
+  // size to be the current size.
+  dataspace::Simple space ({ DIM0, DIM1 });
+
+
+  // Create the dataset.  We will use all default properties for this
+  // example.
+  std::cout<<"Data to write:"<<std::endl;
+  std::cout<<wdata<<std::endl;
+  node::Dataset dset (file.root(), DATASET, datatype::create (wdata), space);
+
+
+  // Write the data to the dataset.
+  dset.write(wdata);
+}
+
+void read()
+{
+  // Open file and dataset using the default properties.
+  file::File file = file::open (FILE, file::AccessFlags::READONLY);
+  node::Dataset dset = file.root().nodes[DATASET];
+
+  // Read the data using the default properties.
+  Int32Matrix rdata;
+  dset.read(rdata);
+
+  // Output the data to the screen.
+  std::cout<<DATASET<<std::endl;
+  std::cout<<rdata<<std::endl;
+}
+
+int
+main (void)
+{
+  write();
+  read();
+
+  return 0;
+}