WIP

include/aare/RawFile.hpp

@@ -3,7 +3,7 @@
 #include "aare/RawMasterFile.hpp"
 #include "aare/Frame.hpp"
 #include "aare/NDArray.hpp" //for pixel map
-#include "aare/SubFile.hpp"
+#include "aare/RawSubFile.hpp"
 
 #include <optional>
 
@@ -32,8 +32,9 @@ class RawFile : public FileInterface {
     size_t n_subfiles{}; //f0,f1...fn
     size_t n_subfile_parts{}; // d0,d1...dn
     //TODO! move to vector of SubFile instead of pointers
-    std::vector<std::vector<SubFile *>> subfiles; //subfiles[f0,f1...fn][d0,d1...dn]
+    std::vector<std::vector<RawSubFile *>> subfiles; //subfiles[f0,f1...fn][d0,d1...dn]
     std::vector<xy> positions;
+    std::vector<ModuleGeometry> m_module_pixel_0;
     ModuleConfig cfg{0, 0};
 
     RawMasterFile m_master;
@@ -57,6 +58,10 @@ class RawFile : public FileInterface {
     std::vector<Frame> read_n(size_t n_frames) override;
     void read_into(std::byte *image_buf) override;
     void read_into(std::byte *image_buf, size_t n_frames) override;
+
+    //TODO! do we need to adapt the API? 
+    void read_into(std::byte *image_buf, DetectorHeader *header);
+
     size_t frame_number(size_t frame_index) override;
     size_t bytes_per_frame() override;
     size_t pixels_per_frame() override;
@@ -66,7 +71,9 @@ class RawFile : public FileInterface {
     size_t rows() const override;
     size_t cols() const override;
     size_t bitdepth() const override;
+    size_t bytes_per_pixel() const;
     xy geometry();
+    size_t n_mod() const;
 
     DetectorType detector_type() const override;
 
@@ -84,7 +91,7 @@ class RawFile : public FileInterface {
      * @param frame_number frame number to read
      * @param image_buf buffer to store the frame
      */
-    void get_frame_into(size_t frame_index, std::byte *frame_buffer);
+    void get_frame_into(size_t frame_index, std::byte *frame_buffer, DetectorHeader *header = nullptr);
 
     /**
      * @brief get the frame at the given frame index
@@ -102,7 +109,7 @@ class RawFile : public FileInterface {
      */
     static DetectorHeader read_header(const std::filesystem::path &fname);
 
-
+    void update_geometry_with_roi();
     int find_number_of_subfiles();
     void open_subfiles();
     void find_geometry();

include/aare/RawMasterFile.hpp

@@ -63,6 +63,9 @@ struct ROI{
   size_t xmax{};
   size_t ymin{};
   size_t ymax{};
+
+  size_t height() const { return ymax - ymin; }
+  size_t width() const { return xmax - xmin; }
 };
 
 /**

include/aare/RawSubFile.hpp

@@ -0,0 +1,69 @@
+#pragma once
+#include "aare/Frame.hpp"
+#include "aare/defs.hpp"
+
+#include <cstdint>
+#include <filesystem>
+#include <map>
+#include <optional>
+
+namespace aare {
+
+/**
+ * @brief Class to read a singe subfile written in .raw format. Used from RawFile to read
+ * the entire detector. Can be used directly to read part of the image.
+ */
+class RawSubFile {
+  protected:
+    std::ifstream m_file;
+    size_t m_bitdepth;
+    std::filesystem::path m_fname;
+    size_t m_rows{};
+    size_t m_cols{};
+    size_t m_bytes_per_frame{};
+    size_t n_frames{};
+ 
+    DetectorType m_detector_type;
+    std::optional<NDArray<ssize_t, 2>> pixel_map;
+
+  public:
+    /**
+     * @brief SubFile constructor
+     * @param fname path to the subfile
+     * @param detector detector type
+     * @param rows number of rows in the subfile
+     * @param cols number of columns in the subfile
+     * @param bitdepth bitdepth of the subfile
+     * @throws std::invalid_argument if the detector,type pair is not supported
+     */
+    RawSubFile(const std::filesystem::path &fname, DetectorType detector,
+               size_t rows, size_t cols, size_t bitdepth);
+
+    ~RawSubFile() = default;
+    /**
+     * @brief Seek to the given frame number
+     * @note Puts the file pointer at the start of the header, not the start of the data
+     * @param frame_index frame position in file to seek to
+     * @throws std::runtime_error if the frame number is out of range
+     */
+    void seek(size_t frame_index);
+    size_t tell();
+
+    void read_into(std::byte *image_buf, DetectorHeader *header = nullptr);
+    void get_part(std::byte *buffer, size_t frame_index);
+    
+    void read_header(DetectorHeader *header);
+    
+    size_t rows() const;
+    size_t cols() const;
+    
+    size_t frame_number(size_t frame_index);
+
+    size_t bytes_per_frame() const { return m_bytes_per_frame; }
+    size_t pixels_per_frame() const { return m_rows * m_cols; }
+    size_t bytes_per_pixel() const { return m_bitdepth / 8; }
+
+
+};
+
+} // namespace aare

include/aare/SubFile.hpp

@@ -1,82 +0,0 @@
-#pragma once
-#include "aare/Frame.hpp"
-#include "aare/defs.hpp"
-
-#include <cstdint>
-#include <filesystem>
-#include <map>
-#include <optional>
-
-
-namespace aare {
-
-/**
- * @brief Class to read a subfile from a RawFile
- */
-class SubFile {
-  protected:
-    FILE *fp = nullptr;
-    size_t m_bitdepth;
-    std::filesystem::path m_fname;
-    size_t m_rows{};
-    size_t m_cols{};
-    std::string m_mode;
-    size_t n_frames{};
-    int m_sub_file_index_{};
-    DetectorType m_detector_type;
-    std::optional<NDArray<ssize_t, 2>> pixel_map;
-
-
-  public:
-    /**
-     * @brief SubFile constructor
-     * @param fname path to the subfile
-     * @param detector detector type
-     * @param rows number of rows in the subfile
-     * @param cols number of columns in the subfile
-     * @param bitdepth bitdepth of the subfile
-     * @throws std::invalid_argument if the detector,type pair is not supported
-     */
-    SubFile(const std::filesystem::path &fname, DetectorType detector, size_t rows, size_t cols, size_t bitdepth,
-            const std::string &mode = "r");
-
-    /**
-     * @brief read the subfile into a buffer
-     * @param buffer pointer to the buffer to read the data into
-     * @return number of bytes read
-     */
-    size_t read_impl_normal(std::byte *buffer);
-
-    /**
-     * @brief read the subfile into a buffer with the bytes flipped
-     * @param buffer pointer to the buffer to read the data into
-     * @return number of bytes read
-     */
-    template <typename DataType> size_t read_impl_flip(std::byte *buffer);
-
-    /**
-     * @brief read the subfile into a buffer with the bytes reordered
-     * @param buffer pointer to the buffer to read the data into
-     * @return number of bytes read
-     */
-    template <typename DataType> size_t read_impl_reorder(std::byte *buffer);
-
-    /**
-     * @brief read the subfile into a buffer with the bytes reordered and flipped
-     * @param buffer pointer to the buffer to read the data into
-     * @param frame_number frame number to read
-     * @return number of bytes read
-     */
-    size_t get_part(std::byte *buffer, size_t frame_index);
-    size_t frame_number(size_t frame_index);
-
-
-    size_t bytes_per_part() const { return (m_bitdepth / 8) * m_rows * m_cols; }
-    size_t pixels_per_part() const { return m_rows * m_cols; }
-
-    ~SubFile();
-
-
-};
-
-} // namespace aare

include/aare/defs.hpp

@@ -14,6 +14,11 @@
 #include <variant>
 #include <vector>
 
+
+
+
+
+
 /**
  * @brief LOCATION macro to get the current location in the code
  */
@@ -21,8 +26,23 @@
     std::string(__FILE__) + std::string(":") + std::to_string(__LINE__) +      \
         ":" + std::string(__func__) + ":"
 
+
+#ifdef AARE_CUSTOM_ASSERT
+#define AARE_ASSERT(expr)\
+    if (expr)\
+        {}\
+    else\
+        aare::assert_failed(LOCATION + " Assertion failed: " + #expr + "\n");
+#else
+#define AARE_ASSERT(cond)\
+    do { (void)sizeof(cond); } while(0)
+#endif
+
+
 namespace aare {
 
+void assert_failed(const std::string &msg);
+
 class Cluster {
   public:
     int cluster_sizeX;
@@ -164,6 +184,14 @@ template <typename T> struct t_xy {
 };
 using xy = t_xy<uint32_t>;
 
+
+struct ModuleGeometry{
+    int x{};
+    int y{};
+    int height{};
+    int width{};
+};
+
 using dynamic_shape = std::vector<int64_t>;
 
 //TODO! Can we uniform enums between the libraries?