detectors/aare
25
0
Fork 0
mirror of https://github.com/slsdetectorgroup/aare.git synced 2025-06-12 15:27:13 +02:00
Code Issues Actions Packages Releases Activity

fix file test issues

Browse Source
This commit is contained in:
Bechir
2024-03-28 12:40:20 +01:00
parent 6e8cf179c7
commit 04cbe9924e
12 changed files with 190 additions and 193 deletions
Download Patch File Download Diff File Expand all files Collapse all files

6
file_io/include/aare/NumpyFile.hpp
View File

@ -20,9 +20,9 @@ class NumpyFile : public FileInterface {
void seek(size_t frame_number) override { this->current_frame = frame_number; }
size_t tell() override { return this->current_frame; }
size_t total_frames() const override { return header.shape[0]; }
ssize_t rows()const override { return header.shape[1]; }
ssize_t cols()const override { return header.shape[2]; }
ssize_t bitdepth()const override { return header.dtype.itemsize; }
ssize_t rows() const override { return header.shape[1]; }
ssize_t cols() const override { return header.shape[2]; }
ssize_t bitdepth() const override { return header.dtype.itemsize; }
NumpyFile(std::filesystem::path fname);
header_t header{};

18
file_io/include/aare/SubFile.hpp
View File

@ -2,8 +2,8 @@
#include "aare/defs.hpp"
#include <cstdint>
#include <filesystem>
#include <variant>
#include <map>
#include <variant>
class SubFile {
protected:
@ -19,20 +19,21 @@ class SubFile {
std::map<std::pair<DetectorType, int>, pfunc> read_impl_map = {
{{DetectorType::Moench, 16}, &SubFile::read_impl_reorder<uint16_t>},
{{DetectorType::Jungfrau, 16}, &SubFile::read_impl_normal},
{{DetectorType::ChipTestBoard,16}, &SubFile::read_impl_normal},
{{DetectorType::Mythen3, 32}, &SubFile::read_impl_normal}
};
{{DetectorType::ChipTestBoard, 16}, &SubFile::read_impl_normal},
{{DetectorType::Mythen3, 32}, &SubFile::read_impl_normal},
{{DetectorType::Eiger, 32}, &SubFile::read_impl_normal},
{{DetectorType::Eiger, 16}, &SubFile::read_impl_normal}
};
public:
// pointer to a read_impl function. pointer will be set to the appropriate read_impl function in the constructor
pfunc read_impl = nullptr;
size_t read_impl_normal(std::byte *buffer);
template <typename DataType> size_t read_impl_flip(std::byte *buffer);
template <typename DataType> size_t read_impl_reorder(std::byte *buffer);
template <typename DataType> size_t read_impl_flip(std::byte *buffer);
template <typename DataType> size_t read_impl_reorder(std::byte *buffer);
SubFile(std::filesystem::path fname,DetectorType detector, ssize_t rows, ssize_t cols, uint16_t bitdepth);
SubFile(std::filesystem::path fname, DetectorType detector, ssize_t rows, ssize_t cols, uint16_t bitdepth);
size_t get_part(std::byte *buffer, int frame_number);
size_t frame_number(int frame_index);
@ -40,5 +41,4 @@ class SubFile {
// TODO: define the inlines as variables and assign them in constructor
inline size_t bytes_per_part() { return (m_bitdepth / 8) * m_rows * m_cols; }
inline size_t pixels_per_part() { return m_rows * m_cols; }
};

2
file_io/src/File.cpp
View File

@ -10,7 +10,7 @@ File::File(std::filesystem::path fname, std::string mode) {
}
Frame File::read() { return file_impl->read(); }
size_t File::total_frames() const { return file_impl->m_total_frames; }
size_t File::total_frames() const { return file_impl->total_frames(); }
std::vector<Frame> File::read(size_t n_frames) { return file_impl->read(n_frames); }
void File::read_into(std::byte *image_buf) { file_impl->read_into(image_buf); }
void File::read_into(std::byte *image_buf, size_t n_frames) { file_impl->read_into(image_buf, n_frames); }

6
file_io/src/FileFactory.cpp
View File

@ -13,16 +13,16 @@ FileFactory *FileFactory::get_factory(std::filesystem::path fpath) {
}
if (fpath.extension() == ".raw" || fpath.extension() == ".json"){
aare::logger::info("Loading",fpath.extension(),"file");
aare::logger::debug("Loading",fpath.extension(),"file");
return new RawFileFactory(fpath);
}
if (fpath.extension() == ".raw" || fpath.extension() == ".json"){
aare::logger::info("Loading",fpath.extension(),"file");
aare::logger::debug("Loading",fpath.extension(),"file");
return new RawFileFactory(fpath);
}
// check if extension is numpy
else if (fpath.extension() == ".npy") {
aare::logger::info("Loading numpy file");
aare::logger::debug("Loading numpy file");
return new NumpyFileFactory(fpath);
}

15
file_io/src/NumpyFileFactory.cpp
View File

@ -1,10 +1,8 @@
#include "aare/NumpyFileFactory.hpp"
#include "aare/NumpyHelpers.hpp"
NumpyFileFactory::NumpyFileFactory(std::filesystem::path fpath) {
this->m_fpath = fpath;
}
NumpyFileFactory::NumpyFileFactory(std::filesystem::path fpath) { this->m_fpath = fpath; }
void NumpyFileFactory::parse_metadata(FileInterface *_file) {
auto file = dynamic_cast<NumpyFile*>(_file);
auto file = dynamic_cast<NumpyFile *>(_file);
// open ifsteam to file
f = std::ifstream(file->m_fname, std::ios::binary);
// check if file exists
@ -46,7 +44,7 @@ void NumpyFileFactory::parse_metadata(FileInterface *_file) {
// parse header
std::vector<std::string> keys{"descr", "fortran_order", "shape"};
std::cout << "original header: " << '"' << header << '"' << std::endl;
aare::logger::debug("original header: \"header\"");
auto dict_map = parse_dict(header, keys);
if (dict_map.size() == 0)
@ -72,11 +70,8 @@ void NumpyFileFactory::parse_metadata(FileInterface *_file) {
file->header = {dtype, fortran_order, shape};
}
NumpyFile* NumpyFileFactory::load_file() {
NumpyFile* file = new NumpyFile(this->m_fpath);
NumpyFile *NumpyFileFactory::load_file() {
NumpyFile *file = new NumpyFile(this->m_fpath);
parse_metadata(file);
std::cout << "parsed header: " << file->header.to_string() << std::endl;
return file;
};

1
file_io/src/RawFileFactory.cpp
View File

@ -87,7 +87,6 @@ void RawFileFactory::parse_json_metadata(RawFile *file) {
json j;
ifs >> j;
double v = j["Version"];
std::cout << "Version: " << v << std::endl;
file->version = fmt::format("{:.1f}", v);
file->m_type = StringTo<DetectorType>(j["Detector Type"].get<std::string>());
file->timing_mode = StringTo<TimingMode>(j["Timing Mode"].get<std::string>());

5
file_io/src/SubFile.cpp
View File

@ -10,7 +10,8 @@ SubFile::SubFile(std::filesystem::path fname, DetectorType detector, ssize_t row
this->m_bitdepth = bitdepth;
this->n_frames = std::filesystem::file_size(fname) / (sizeof(sls_detector_header) + rows * cols * bitdepth / 8);
if (read_impl_map.find({detector, bitdepth}) == read_impl_map.end()) {
throw std::runtime_error(LOCATION + "Unsupported detector/bitdepth combination");
auto error_msg = LOCATION + "No read_impl function found for detector: " + toString(detector) + " and bitdepth: " + std::to_string(bitdepth);
throw std::runtime_error(error_msg);
}
this->read_impl = read_impl_map.at({detector, bitdepth});
}
@ -88,7 +89,7 @@ size_t SubFile::frame_number(int frame_index) {
FILE *fp = fopen(this->m_fname.c_str(), "r");
if (!fp)
throw std::runtime_error(fmt::format("Could not open: {} for reading", m_fname.c_str()));
fseek(fp, (sizeof(sls_detector_header) + bytes_per_part()) * frame_index, SEEK_SET);
size_t rc = fread(reinterpret_cast<char *>(&h), sizeof(h), 1, fp);
fclose(fp);
if (rc != 1)

49
file_io/test/RawFile.test.cpp
View File

@ -1,10 +1,13 @@
#include "aare/File.hpp"
#include "aare/utils/logger.hpp"
#include <catch2/catch_test_macros.hpp>
#include <filesystem>
#include "aare/File.hpp"
#include "test_config.hpp"
TEST_CASE("Read number of frames from a jungfrau raw file"){
TEST_CASE("Read number of frames from a jungfrau raw file") {
auto fpath = test_data_path() / "jungfrau" / "jungfrau_single_master_0.json";
REQUIRE(std::filesystem::exists(fpath));
@ -12,53 +15,52 @@ TEST_CASE("Read number of frames from a jungfrau raw file"){
REQUIRE(f.total_frames() == 10);
}
TEST_CASE("Read frame numbers from a jungfrau raw file"){
TEST_CASE("Read frame numbers from a jungfrau raw file") {
auto fpath = test_data_path() / "jungfrau" / "jungfrau_single_master_0.json";
REQUIRE(std::filesystem::exists(fpath));
File f(fpath, "r");
//we know this file has 10 frames with frame numbers 1 to 10
//f0 1,2,3
//f1 4,5,6
//f2 7,8,9
//f3 10
for (size_t i = 0; i < 10; i++){
CHECK(f.frame_number(i) == i+1);
// we know this file has 10 frames with frame numbers 1 to 10
// f0 1,2,3
// f1 4,5,6
// f2 7,8,9
// f3 10
for (size_t i = 0; i < 10; i++) {
CHECK(f.frame_number(i) == i + 1);
}
}
TEST_CASE("Read data from a jungfrau 500k single port raw file"){
TEST_CASE("Read data from a jungfrau 500k single port raw file") {
auto fpath = test_data_path() / "jungfrau" / "jungfrau_single_master_0.json";
REQUIRE(std::filesystem::exists(fpath));
File f(fpath, "r");
//we know this file has 10 frames with pixel 0,0 being: 2123, 2051, 2109, 2117, 2089, 2095, 2072, 2126, 2097, 2102
// we know this file has 10 frames with pixel 0,0 being: 2123, 2051, 2109, 2117, 2089, 2095, 2072, 2126, 2097, 2102
std::vector<uint16_t> pixel_0_0 = {2123, 2051, 2109, 2117, 2089, 2095, 2072, 2126, 2097, 2102};
for (size_t i = 0; i < 10; i++){
for (size_t i = 0; i < 10; i++) {
auto frame = f.read();
CHECK(frame.rows() == 512);
CHECK(frame.cols() == 1024);
CHECK(frame.view<uint16_t>()(0,0) == pixel_0_0[i]);
CHECK(frame.view<uint16_t>()(0, 0) == pixel_0_0[i]);
}
}
TEST_CASE("Read frame numbers from a raw file"){
TEST_CASE("Read frame numbers from a raw file") {
auto fpath = test_data_path() / "eiger" / "eiger_500k_16bit_master_0.json";
REQUIRE(std::filesystem::exists(fpath));
//we know this file has 3 frames with frame numbers 14, 15, 16
// we know this file has 3 frames with frame numbers 14, 15, 16
std::vector<size_t> frame_numbers = {14, 15, 16};
File f(fpath, "r");
for (size_t i = 0; i < 3; i++){
for (size_t i = 0; i < 3; i++) {
CHECK(f.frame_number(i) == frame_numbers[i]);
}
}
TEST_CASE("Compare reading from a numpy file with a raw file"){
TEST_CASE("Compare reading from a numpy file with a raw file") {
auto fpath_raw = test_data_path() / "jungfrau" / "jungfrau_single_master_0.json";
REQUIRE(std::filesystem::exists(fpath_raw));
@ -71,10 +73,9 @@ TEST_CASE("Compare reading from a numpy file with a raw file"){
CHECK(raw.total_frames() == 10);
CHECK(npy.total_frames() == 10);
for (size_t i=0; i<10; ++i){
for (size_t i = 0; i < 10; ++i) {
auto raw_frame = raw.read();
auto npy_frame = npy.read();
auto npy_frame = npy.read();
CHECK(raw_frame.view<uint16_t>() == npy_frame.view<uint16_t>());
}
}