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

remove templates

Browse Source
This commit is contained in:
Bechir Braham
2024-03-20 13:14:14 +01:00
parent 4da9bc0813
commit cd905e96f3
25 changed files with 223 additions and 200 deletions
Download Patch File Download Diff File Expand all files Collapse all files

5
file_io/include/aare/File.hpp
View File

@ -8,11 +8,10 @@
#include <iostream>
template <DetectorType detector, typename DataType>
class File {
public:
virtual Frame<DataType>* get_frame(size_t frame_number) = 0;
virtual Frame* get_frame(size_t frame_number) = 0;
private:
//comment
@ -34,7 +33,7 @@ class File {
ssize_t rows{};
ssize_t cols{};
uint8_t bitdepth{};
ssize_t bitdepth{};
// File();

9
file_io/include/aare/FileFactory.hpp
View File

@ -1,18 +1,17 @@
#pragma once
#include <filesystem>
#include "aare/File.hpp"
template <DetectorType detector,typename DataType>
class FileFactory{
// Class that will be used to create File objects
// follows the factory pattern
protected:
std::filesystem::path m_fpath;
public:
static FileFactory<detector,DataType>* get_factory(std::filesystem::path);
static FileFactory* get_factory(std::filesystem::path);
// virtual int deleteFile() = 0;
virtual File<detector,DataType>* load_file()=0;//TODO: add option to load all file to memory or keep it on disk
virtual void parse_metadata(File<detector,DataType>*)=0;
virtual void parse_fname(File<detector,DataType>*)=0;
virtual File* load_file()=0;//TODO: add option to load all file to memory or keep it on disk
virtual void parse_metadata(File*)=0;
virtual void parse_fname(File*)=0;
virtual ~FileFactory() = default;

11
file_io/include/aare/FileHandler.hpp
View File

@ -2,22 +2,21 @@
#include "aare/FileFactory.hpp"
#include "aare/File.hpp"
template <DetectorType detector,typename DataType>
class FileHandler{
private:
std::filesystem::path fpath;
FileFactory<detector,DataType>* fileFactory;
File<detector,DataType>* f;
FileFactory* fileFactory;
File* f;
public:
FileHandler<detector,DataType>(std::filesystem::path fname){
FileHandler(std::filesystem::path fname){
this->fpath = fname;
this->fileFactory= FileFactory<detector,DataType>::get_factory(fname);
this->fileFactory= FileFactory::get_factory(fname);
this->f= fileFactory->load_file();
delete fileFactory;
}
Frame<DataType>* get_frame(int index){
Frame* get_frame(int index){
return f->get_frame(index);
}

4
file_io/include/aare/JsonFile.hpp
View File

@ -4,12 +4,12 @@
#include "aare/File.hpp"
template <DetectorType detector, typename DataType> class JsonFile : public File<detector, DataType> {
class JsonFile : public File {
using config = RawFileConfig;
public:
Frame<DataType> *get_frame(size_t frame_number);
Frame *get_frame(size_t frame_number);
int n_subfiles;
std::vector<SubFile *> subfiles;
int subfile_rows, subfile_cols;

13
file_io/include/aare/JsonFileFactory.hpp
View File

@ -1,17 +1,16 @@
#include "aare/FileFactory.hpp"
template <DetectorType detector,typename DataType>
class JsonFileFactory: public FileFactory<detector,DataType>
class JsonFileFactory: public FileFactory
{
private:
/* data */
public:
JsonFileFactory(std::filesystem::path fpath);
File<detector,DataType>* load_file() override;
void parse_metadata(File<detector,DataType>*) override;
void parse_fname(File<detector,DataType>*) override;
void open_subfiles(File<detector,DataType>*);
File* load_file() override;
void parse_metadata(File*) override;
void parse_fname(File*) override;
void open_subfiles(File*);
sls_detector_header read_header(const std::filesystem::path &fname);
void find_geometry(File<detector,DataType>*);
void find_geometry(File*);

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

@ -6,12 +6,12 @@
#include <numeric>
template <DetectorType detector, typename DataType> class NumpyFile : public File<detector, DataType> {
class NumpyFile : public File {
FILE *fp = nullptr;
public:
NumpyFile(std::filesystem::path fname);
Frame<DataType> *get_frame(size_t frame_number) override;
Frame *get_frame(size_t frame_number) override;
header_t header{};
static constexpr std::array<char, 6> magic_str{'\x93', 'N', 'U', 'M', 'P', 'Y'};
uint8_t major_ver_{};

10
file_io/include/aare/NumpyFileFactory.hpp
View File

@ -6,15 +6,15 @@
template <DetectorType detector, typename DataType> class NumpyFileFactory : public FileFactory<detector, DataType> {
class NumpyFileFactory : public FileFactory {
private:
std::ifstream f;
void read_data(File<detector, DataType> *_file);
void read_data(File *_file);
public:
NumpyFileFactory(std::filesystem::path fpath);
void parse_metadata(File<detector, DataType> *_file) override;
File<detector, DataType> *load_file() override;
void parse_fname(File<detector, DataType> *){};
void parse_metadata(File *_file) override;
File *load_file() override;
void parse_fname(File*){};
};

3
file_io/include/aare/RawFileFactory.hpp
View File

@ -1,9 +1,8 @@
#include "aare/File.hpp"
#include <filesystem>
template<DetectorType detector,typename DataType>
class RawFileFactory{
public:
// RawFileFactory();
// ~RawFileFactory();
File<detector,DataType> loadFile(std::filesystem::path fpath);
File loadFile(std::filesystem::path fpath);
};

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

@ -3,20 +3,28 @@
#include <cstdint>
#include <filesystem>
#include <variant>
#include <map>
class SubFile {
protected:
FILE *fp = nullptr;
uint16_t m_bitdepth;
ssize_t m_bitdepth;
std::filesystem::path m_fname;
ssize_t m_rows{};
ssize_t m_cols{};
ssize_t n_frames{};
int m_sub_file_index_{};
// pointer to functions that will read frames
using pfunc = size_t (SubFile::*)(std::byte *);
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},
};
public:
// pointer to a read_impl function. pointer will be set to the appropriate read_impl function in the constructor
size_t (SubFile::*read_impl)(std::byte *buffer) = nullptr;
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);