refactored a bit

include/aare/Hdf5File.hpp

@@ -9,13 +9,13 @@
 namespace aare {
 
 struct H5Handles {
-  std::string file_name{};
+  std::string file_name;
-  std::string dataset_name{};
+  std::string dataset_name;
   H5::H5File file;
   H5::DataSet dataset;
   H5::DataSpace dataspace;
   H5::DataType datatype;
-  std::unique_ptr<H5::DataSpace> memspace{nullptr};
+  std::unique_ptr<H5::DataSpace> memspace;
   std::vector<hsize_t>dims;
   std::vector<hsize_t> count;
   std::vector<hsize_t> offset;
@@ -26,59 +26,60 @@ struct H5Handles {
     file(fname, H5F_ACC_RDONLY),
     dataset(file.openDataSet(dname)),
     dataspace(dataset.getSpace()),
-    datatype(dataset.getDataType())
+    datatype(dataset.getDataType()) {
-  {
+      intialize_dimensions();
-    // get dimensions
+      initialize_memspace();
-    int rank = dataspace.getSimpleExtentNdims();
-    dims.resize(rank);
-    dataspace.getSimpleExtentDims(dims.data(), nullptr);
-
-    // to slice 1 frame with hyperslab    
-    count.push_back(1);
-    offset.push_back(0);
-
-    // header datasets
-    if (rank == 1) {
-      memspace = std::make_unique<H5::DataSpace>(H5S_SCALAR);
-    }  
-    // header virtual datasets
-    else if (rank == 2) {
-      memspace = std::make_unique<H5::DataSpace>(H5S_SCALAR);
-      count.push_back(1);
-      offset.push_back(0);
-    } 
-    // data dataset
-    else {
-      hsize_t dimsm[2] = {dims[1], dims[2]};
-      memspace = std::make_unique<H5::DataSpace>(2, dimsm);
-      count.push_back(dims[1]);
-      count.push_back(dims[2]);
-      offset.push_back(0);
-      offset.push_back(0);
     }
-  };
 
   void seek(size_t frame_index) {
     if (frame_index >= dims[0]) {
         throw std::runtime_error(LOCATION + "Invalid frame number");
     }
     offset[0] = static_cast<hsize_t>(frame_index);
-  };
+  }
 
-  void get_frame_into(size_t frame_index, std::byte *frame_buffer) {
+  void get_data_into(size_t frame_index, std::byte *frame_buffer) {
     seek(frame_index);
-    //LOG(logDEBUG) << "data offset:" << offset << " count:" << count;
+    //std::cout << "offset:" << offset << " count:" << count << std::endl;
     dataspace.selectHyperslab(H5S_SELECT_SET, count.data(), offset.data());
     dataset.read(frame_buffer, datatype, *memspace, dataspace);
-  };
+  }
 
   void get_header_into(size_t frame_index, int part_index, std::byte *header_buffer) {
     seek(frame_index);
-    offset[1] = part_index;
+    offset[1] = static_cast<hsize_t>(part_index);
-    //LOG(logDEBUG) << "header offset:" << offset << " count:" << count;
+    //std::cout << "offset:" << offset << " count:" << count << std::endl;
     dataspace.selectHyperslab(H5S_SELECT_SET, count.data(), offset.data());
     dataset.read(header_buffer, datatype, *memspace, dataspace);
-  };
+  }
+
+  private:
+  void intialize_dimensions() {
+    int rank = dataspace.getSimpleExtentNdims();
+    dims.resize(rank);
+    dataspace.getSimpleExtentDims(dims.data(), nullptr);
+  }
+
+  void initialize_memspace() {
+    int rank = dataspace.getSimpleExtentNdims();
+    count.clear();
+    offset.clear();
+
+    // header datasets or header virtual datasets
+    if (rank == 1 || rank == 2) {
+      count = std::vector<hsize_t>(rank, 1); // slice 1 value
+      offset = std::vector<hsize_t>(rank, 0);
+      memspace = std::make_unique<H5::DataSpace>(H5S_SCALAR);
+    } else if (rank >= 3) {
+      // data dataset (frame x height x width)
+      count = {1, dims[1], dims[2]};
+      offset = {0, 0, 0};
+      hsize_t dims_image[2] = {dims[1], dims[2]};
+      memspace = std::make_unique<H5::DataSpace>(2, dims_image);
+    } else {
+      throw std::runtime_error(LOCATION + "Invalid rank for dataset: " + std::to_string(rank));
+    }
+  }
 };
 
 /**

src/Hdf5File.cpp

@@ -79,6 +79,8 @@ size_t Hdf5File::bitdepth() const { return m_master.bitdepth(); }
 xy Hdf5File::geometry() { return m_master.geometry(); }
 size_t Hdf5File::n_modules() const { return m_master.n_modules(); }
 Hdf5MasterFile Hdf5File::master() const { return m_master; }
+size_t Hdf5File::bytes_per_pixel() const { return m_master.bitdepth() / 8; }
+
 
 DetectorHeader Hdf5File::read_header(const std::filesystem::path &fname) {
     DetectorHeader h{};
@@ -113,20 +115,6 @@ DetectorHeader Hdf5File::read_header(const std::filesystem::path &fname) {
             LOCATION + "\nCould not to access header datasets in given file.");
     }
 
-
-
-    FILE *fp = fopen(fname.string().c_str(), "r");
-    if (!fp)
-        throw std::runtime_error(
-            fmt::format("Could not open: {} for reading", fname.string()));
-
-    size_t const rc = fread(reinterpret_cast<char *>(&h), sizeof(h), 1, fp);
-    if (rc != 1)
-        throw std::runtime_error(LOCATION + "Could not read header from file");
-    if (fclose(fp)) {
-        throw std::runtime_error(LOCATION + "Could not close file");
-    }
-
     return h;
 }
 
@@ -138,18 +126,15 @@ Frame Hdf5File::get_frame(size_t frame_index) {
     return f;
 }
 
-size_t Hdf5File::bytes_per_pixel() const { return m_master.bitdepth() / 8; }
 
 void Hdf5File::get_frame_into(size_t frame_index, std::byte *frame_buffer,
                               DetectorHeader *header) {
     if (frame_index >= m_master.frames_in_file()) {
         throw std::runtime_error(LOCATION + "Frame number out of range");
     }
-    LOG(logINFOBLUE) << "Reading frame " << frame_index;
     get_data_into(frame_index, frame_buffer);
     if (header) {
         for (size_t part_idx = 0; part_idx != m_master.n_modules(); ++part_idx) {
-            // fmt::print("Reading header for module {}\n", part_idx);
             get_header_into(frame_index, part_idx, header);
             header++;
         }
@@ -157,7 +142,7 @@ void Hdf5File::get_frame_into(size_t frame_index, std::byte *frame_buffer,
 }
 
 void Hdf5File::get_data_into(size_t frame_index, std::byte *frame_buffer) {
-    m_data_file->get_frame_into(frame_index, frame_buffer);
+    m_data_file->get_data_into(frame_index, frame_buffer);
 }
 
 void Hdf5File::get_header_into(size_t frame_index, int part_index, DetectorHeader *header) {
@@ -176,7 +161,7 @@ void Hdf5File::get_header_into(size_t frame_index, int part_index, DetectorHeade
         m_header_files[11]->get_header_into(frame_index, part_index, reinterpret_cast<std::byte *>(&(header->detType)));
         m_header_files[12]->get_header_into(frame_index, part_index, reinterpret_cast<std::byte *>(&(header->version)));
         m_header_files[13]->get_header_into(frame_index, part_index, reinterpret_cast<std::byte *>(&(header->packetMask)));
-        LOG(logDEBUG5) << "Read 1D header for frame " << frame_index;
+        LOG(logDEBUG) << "Read 1D header for frame " << frame_index;
     } catch (const H5::Exception &e) {
         fmt::print("Exception type: {}\n", typeid(e).name());
         e.printErrorStack();