saving work

.vscode/c_cpp_properties.json

@@ -0,0 +1,17 @@
+{
+    "configurations": [
+        {
+            "name": "Linux",
+            "includePath": [
+                "${workspaceFolder}/**"
+            ],
+            "defines": [],
+            "compilerPath": "/usr/bin/clang",
+            "cStandard": "c17",
+            "cppStandard": "c++17",
+            "intelliSenseMode": "linux-clang-x64",
+            "configurationProvider": "ms-vscode.cmake-tools"
+        }
+    ],
+    "version": 4
+}

.vscode/settings.json

@@ -0,0 +1,57 @@
+{
+    "cmake.configureOnOpen": true,
+    "files.associations": {
+        "stdexcept": "cpp",
+        "cstddef": "cpp",
+        "cctype": "cpp",
+        "clocale": "cpp",
+        "cmath": "cpp",
+        "cstdarg": "cpp",
+        "cstdio": "cpp",
+        "cstdlib": "cpp",
+        "ctime": "cpp",
+        "cwchar": "cpp",
+        "cwctype": "cpp",
+        "array": "cpp",
+        "atomic": "cpp",
+        "bit": "cpp",
+        "*.tcc": "cpp",
+        "codecvt": "cpp",
+        "compare": "cpp",
+        "concepts": "cpp",
+        "cstdint": "cpp",
+        "deque": "cpp",
+        "string": "cpp",
+        "unordered_map": "cpp",
+        "vector": "cpp",
+        "exception": "cpp",
+        "algorithm": "cpp",
+        "functional": "cpp",
+        "iterator": "cpp",
+        "memory": "cpp",
+        "memory_resource": "cpp",
+        "numeric": "cpp",
+        "optional": "cpp",
+        "random": "cpp",
+        "ratio": "cpp",
+        "string_view": "cpp",
+        "system_error": "cpp",
+        "tuple": "cpp",
+        "type_traits": "cpp",
+        "utility": "cpp",
+        "initializer_list": "cpp",
+        "iomanip": "cpp",
+        "iosfwd": "cpp",
+        "iostream": "cpp",
+        "istream": "cpp",
+        "limits": "cpp",
+        "new": "cpp",
+        "numbers": "cpp",
+        "ostream": "cpp",
+        "sstream": "cpp",
+        "streambuf": "cpp",
+        "cinttypes": "cpp",
+        "typeinfo": "cpp",
+        "filesystem": "cpp"
+    }
+}

CMakeLists.txt

@@ -19,7 +19,7 @@ if (CMAKE_BUILD_TYPE STREQUAL "Debug")
     set(OPTIMIZATION_FLAGS "-Og -ggdb3")
 else()
     set(OPTIMIZATION_FLAGS "-O3")
-
+endif()
 set(CMAKE_EXPORT_COMPILE_COMMANDS ON)
 
 option(USE_SANITIZER "Sanitizers for debugging" ON)
@@ -41,9 +41,7 @@ if(DISABLE_WARNINGS)
 endif()
 
 if(USE_SANITIZER)
-    set(OPTIONAL_FLAGS "${OPTIONAL_FLAGS} -fdiagnostics-parseable-fixits -fdiagnostics-generate-patch
-                         -fdiagnostics-show-template-tree -fsanitize=address,undefined -fno-sanitize-recover
-                         -D_FORTIFY_SOURCE=2 -fstack-protector")
+    set(OPTIONAL_FLAGS "${OPTIONAL_FLAGS} -fdiagnostics-parseable-fixits -fdiagnostics-generate-patch -fdiagnostics-show-template-tree -fsanitize=address,undefined,pointer-compare -fno-sanitize-recover -D_FORTIFY_SOURCE=2 -fstack-protector -fno-omit-frame-pointer ")
 endif()
 
 # if(TUNE_LOCAL)
@@ -58,8 +56,6 @@ endif()
 #     # 
 # endif()
 
-if 
-set(CMAKE_CXX_FLAGS  "")
 
 
 #Enable LTO if available
@@ -71,6 +67,9 @@ else()
     message(STATUS "Building without link time optimization")
 endif()
 
+
+set(CMAKE_CXX_FLAGS  "${OPTIONAL_FLAGS} ${OPTIMIZATION_FLAGS}")
+
 add_executable(aare)
 
 add_subdirectory(src)

src/CMakeLists.txt

@@ -1,6 +1,6 @@
 add_subdirectory(file_io)
-add_subdirectory(models)
+add_subdirectory(core)
 add_subdirectory(processing)
 
 target_include_directories(aare PUBLIC ${CMAKE_CURRENT_SOURCE_DIR})
-target_sources(aare PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/main.cpp)
+target_sources(aare PUBLIC ${CMAKE_CURRENT_SOURCE_DIR}/main.cpp)

src/core/CMakeLists.txt

@@ -0,0 +1 @@
+target_include_directories(aare PUBLIC ${CMAKE_CURRENT_SOURCE_DIR}/include)

src/core/Frame.cpp

@@ -0,0 +1,3 @@
+#include "Frame.hpp"
+
+ssize_t Frame::cols() const { return ssize_t(); }

src/core/Frame.hpp

@@ -0,0 +1,24 @@
+#include <cstddef>
+#include <sys/types.h>
+#include <cstdint>
+#include <bits/unique_ptr.h>
+#include <vector>
+#include "defs.hpp"
+
+class Frame{
+
+    ssize_t nrows{};
+    ssize_t ncols{};
+    uint8_t bitdepth_{};
+    std::unique_ptr<std::byte[]> data_{nullptr};
+public:
+    ssize_t rows() const;
+    ssize_t cols() const;
+    image_shape shape() const;
+    uint8_t bits_per_pixel() const;
+    uint8_t bytes_per_pixel() const;
+    size_t total_bytes() const;
+
+
+
+};

src/core/include/defs.hpp

@@ -0,0 +1,13 @@
+#include <array>
+#include <vector>
+#include <sys/types.h>
+
+
+
+
+using image_shape = std::array<ssize_t, 2>;
+using dynamic_shape = std::vector<ssize_t>;
+
+enum class DetectorType { Jungfrau, Eiger, Mythen3, Moench };
+
+enum class TimingMode {Auto, Trigger};

src/file_io/CMakeLists.txt

@@ -0,0 +1,8 @@
+target_include_directories(aare PUBLIC ${CMAKE_CURRENT_SOURCE_DIR})
+set(FILE_IO_SOURCES "File.cpp" "FileFactory.cpp" "RawFileFactory.cpp")
+# append ${CMAKE_CURRENT_SOURCE_DIR} to the list of sources using for loop
+foreach(FILE_IO_SOURCE ${FILE_IO_SOURCES})
+    list(APPEND FILE_IO_SOURCES_WITH_PATH "${CMAKE_CURRENT_SOURCE_DIR}/${FILE_IO_SOURCE}")
+endforeach()
+
+target_sources(aare PRIVATE ${FILE_IO_SOURCES_WITH_PATH})

src/file_io/File.hpp

@@ -0,0 +1,29 @@
+#pragma once
+
+#include <filesystem>
+#include "defs.hpp"
+
+class File
+{
+private:
+    // std::unique_ptr<FileWrapper> fp;
+public:
+    // File();
+    // ~File();
+    size_t total_frames{};
+    ssize_t rows{};
+    ssize_t cols{};
+    uint8_t bitdepth{};
+    DetectorType type{};
+
+    inline size_t bytes_per_frame() const{
+        //TODO: ask if this is correct
+        return rows*cols*bitdepth/8;
+        
+    }
+    inline size_t pixels() const{
+        return rows*cols;
+    }
+    // size_t total_frames();
+
+};

src/file_io/FileFactory.cpp

@@ -0,0 +1,31 @@
+#include "FileFactory.hpp"
+#include "File.hpp"
+#include "RawFileFactory.hpp"
+#include "JsonFileFactory.hpp"
+#include <iostream>
+
+File FileFactory::loadFile(std::filesystem::path fpath){
+    // check if file exists
+    if(!std::filesystem::exists(fpath)){
+        throw std::runtime_error("File does not exist");
+    }
+
+    File ret;
+    // check if extension is raw
+    if(fpath.extension() == ".raw"){
+        std::cout<<"Loading raw file"<<std::endl;
+    }
+    // json
+    else if(fpath.extension() == ".json"){
+        std::cout<<"Loading json file"<<std::endl;
+        JsonFileFactory jff = JsonFileFactory();
+        
+
+    }
+    //check if extension is numpy
+    else if(fpath.extension() == ".npy"){
+        std::cout<<"Loading numpy file"<<std::endl;
+    }
+    // TODO: determine file type
+    return ret ;
+}

src/file_io/FileFactory.hpp

@@ -0,0 +1,12 @@
+#pragma once
+#include <filesystem>
+#include "File.hpp"
+
+class FileFactory{
+    // Class that will be used to create File objects
+    // follows the factory pattern
+public:
+    // virtual File createFile() = 0;
+    // virtual int deleteFile() = 0;
+    File loadFile(std::filesystem::path); //TODO: add option to load all file to memory or keep it on disk
+};

src/file_io/JsonFileFactory.hpp

@@ -0,0 +1,10 @@
+#include "FileFactory.hpp"
+
+class JsonFileFactory: FileFactory
+{
+private:
+    /* data */
+public:
+
+};
+

src/file_io/RawFileFactory.hpp

@@ -0,0 +1,9 @@
+#include "File.hpp"
+#include <filesystem>
+
+class RawFileFactory{
+    public:
+        // RawFileFactory();
+        // ~RawFileFactory();
+        File loadFile(std::filesystem::path fpath);
+};

src/main.cpp

@@ -1,8 +1,10 @@
 // Your First C++ Program
-
 #include <iostream>
+#include "file_io/FileFactory.hpp"
+
 
 int main() {
-    std::cout << "Hello World!";
-    return 0;
+    FileFactory fileFactory=FileFactory();
+    std::filesystem::path p = std::filesystem::current_path();
+    File f = fileFactory.loadFile(p/"test.raw");
 }