From e33e6546b09be3f254d1eddf125c0ff5ff473794 Mon Sep 17 00:00:00 2001
From: Bechir <bechir.brahem420@gmail.com>
Date: Thu, 21 Mar 2024 11:47:37 +0100
Subject: [PATCH 1/3] add ImageData

---
 core/include/aare/Frame.hpp                   |   7 +-
 core/include/aare/Image.hpp                   | 429 ++++++++++++++++++
 .../aare/VariableSizeClusterFinder.hpp        |  10 +-
 core/test/wrappers.test.cpp                   |  30 +-
 4 files changed, 465 insertions(+), 11 deletions(-)
 create mode 100644 core/include/aare/Image.hpp

diff --git a/core/include/aare/Frame.hpp b/core/include/aare/Frame.hpp
index 27e1709..69b9792 100644
--- a/core/include/aare/Frame.hpp
+++ b/core/include/aare/Frame.hpp
@@ -1,5 +1,5 @@
 #pragma once
-#include "aare/View.hpp"
+#include "aare/Image.hpp"
 #include "aare/defs.hpp"
 #include <cstddef>
 #include <cstdint>
@@ -46,6 +46,11 @@ class Frame {
         return View<T>(data, shape);
     }
 
+    template <typename T>
+    Image<T> image() {
+        return Image<T>(this->view<T>());
+    }
+
     ~Frame() { delete[] m_data; }
 };
 
diff --git a/core/include/aare/Image.hpp b/core/include/aare/Image.hpp
new file mode 100644
index 0000000..54deddf
--- /dev/null
+++ b/core/include/aare/Image.hpp
@@ -0,0 +1,429 @@
+#pragma once
+/*
+Container holding image data, or a time series of image data in contigious
+memory.
+
+
+TODO! Add expression templates for operators
+
+*/
+#include "aare/View.hpp"
+
+#include <algorithm>
+#include <array>
+#include <cmath>
+#include <fmt/format.h>
+#include <fstream>
+#include <iomanip>
+#include <iostream>
+#include <numeric>
+
+
+template <typename T, ssize_t Ndim = 2> class Image {
+  public:
+    Image()
+        : shape_(), strides_(c_strides<Ndim>(shape_)), size_(0),
+          data_(nullptr){};
+
+    explicit Image(std::array<ssize_t, Ndim> shape)
+        : shape_(shape), strides_(c_strides<Ndim>(shape_)),
+          size_(std::accumulate(shape_.begin(), shape_.end(), 1,
+                                std::multiplies<ssize_t>())),
+          data_(new T[size_]){};
+
+    Image(std::array<ssize_t, Ndim> shape, T value) : Image(shape) {
+        this->operator=(value);
+    }
+
+    /* When constructing from a View we need to copy the data since
+    Image expect to own its data, and span is just a view*/
+    Image(View<T, Ndim> span):Image(span.shape()){
+        std::copy(span.begin(), span.end(), begin());
+        // fmt::print("Image(View<T, Ndim> span)\n");
+    }
+
+    // Move constructor
+    Image(Image &&other)
+        : shape_(other.shape_), strides_(c_strides<Ndim>(shape_)),
+          size_(other.size_), data_(nullptr) {
+        data_ = other.data_;
+        other.reset();
+        // fmt::print("Image(Image &&other)\n");
+    }
+
+    // Copy constructor
+    Image(const Image &other)
+        : shape_(other.shape_), strides_(c_strides<Ndim>(shape_)),
+          size_(other.size_), data_(new T[size_]) {
+        std::copy(other.data_, other.data_ + size_, data_);
+        // fmt::print("Image(const Image &other)\n");
+    }
+
+    ~Image() {
+        delete[] data_;
+    }
+
+    auto begin() { return data_; }
+    auto end() { return data_ + size_; }
+
+    using value_type =  T;
+
+    Image &operator=(Image &&other);      // Move assign
+    Image &operator=(const Image &other); // Copy assign
+
+    Image operator+(const Image &other);
+    Image &operator+=(const Image &other);
+    Image operator-(const Image &other);
+    Image &operator-=(const Image &other);
+    Image operator*(const Image &other);
+    Image &operator*=(const Image &other);
+    Image operator/(const Image &other);
+    // Image& operator/=(const Image& other);
+    template <typename V>
+    Image &operator/=(const Image<V, Ndim> &other) {
+        // check shape
+        if (shape_ == other.shape()) {
+            for (int i = 0; i < size_; ++i) {
+                data_[i] /= other(i);
+            }
+            return *this;
+        } else {
+            throw(std::runtime_error("Shape of Image must match"));
+        }
+    }
+
+    Image<bool, Ndim> operator>(const Image &other);
+
+    bool operator==(const Image &other) const;
+    bool operator!=(const Image &other) const;
+
+    Image &operator=(const T &);
+    Image &operator+=(const T &);
+    Image operator+(const T &);
+    Image &operator-=(const T &);
+    Image operator-(const T &);
+    Image &operator*=(const T &);
+    Image operator*(const T &);
+    Image &operator/=(const T &);
+    Image operator/(const T &);
+
+    Image &operator&=(const T &);
+
+    void sqrt() {
+        for (int i = 0; i < size_; ++i) {
+            data_[i] = std::sqrt(data_[i]);
+        }
+    }
+
+    Image &operator++(); // pre inc
+
+    template <typename... Ix>
+    typename std::enable_if<sizeof...(Ix) == Ndim, T &>::type
+    operator()(Ix... index) {
+        return data_[element_offset(strides_, index...)];
+    }
+
+    template <typename... Ix>
+    typename std::enable_if<sizeof...(Ix) == Ndim, T &>::type
+    operator()(Ix... index) const{
+        return data_[element_offset(strides_, index...)];
+    }
+
+
+    template <typename... Ix>
+    typename std::enable_if<sizeof...(Ix) == Ndim, T>::type value(Ix... index) {
+        return data_[element_offset(strides_, index...)];
+    }
+
+    T &operator()(int i) { return data_[i]; }
+    const T &operator()(int i) const { return data_[i]; }
+
+    T *data() { return data_; }
+    std::byte *buffer() { return reinterpret_cast<std::byte *>(data_); }
+    ssize_t size() const { return size_; }
+    size_t total_bytes() const {return size_*sizeof(T);}
+    std::array<ssize_t, Ndim> shape() const noexcept { return shape_; }
+    ssize_t shape(ssize_t i) const noexcept { return shape_[i]; }
+    std::array<ssize_t, Ndim> strides() const noexcept { return strides_; }
+    std::array<ssize_t, Ndim> byte_strides() const noexcept {
+        auto byte_strides = strides_;
+        for (auto &val : byte_strides)
+            val *= sizeof(T);
+        return byte_strides;
+        // return strides_;
+    }
+
+    View<T, Ndim> span() const { return View<T, Ndim>{data_, shape_}; }
+
+    void Print();
+    void Print_all();
+    void Print_some();
+
+    void reset() {
+        data_ = nullptr;
+        size_ = 0;
+        std::fill(shape_.begin(), shape_.end(), 0);
+        std::fill(strides_.begin(), strides_.end(), 0);
+    }
+
+  private:
+    std::array<ssize_t, Ndim> shape_;
+    std::array<ssize_t, Ndim> strides_;
+    ssize_t size_;
+    T *data_;
+};
+
+// Move assign
+template <typename T, ssize_t Ndim>
+Image<T, Ndim> &Image<T, Ndim>::operator=(Image<T, Ndim> &&other) {
+    if (this != &other) {
+        delete[] data_;
+        data_ = other.data_;
+        shape_ = other.shape_;
+        size_ = other.size_;
+        strides_ = other.strides_;
+        other.reset();
+    }
+    return *this;
+}
+
+template <typename T, ssize_t Ndim>
+Image<T, Ndim> Image<T, Ndim>::operator+(const Image &other) {
+    Image result(*this);
+    result += other;
+    return result;
+}
+template <typename T, ssize_t Ndim>
+Image<T, Ndim> &
+Image<T, Ndim>::operator+=(const Image<T, Ndim> &other) {
+    // check shape
+    if (shape_ == other.shape_) {
+        for (int i = 0; i < size_; ++i) {
+            data_[i] += other.data_[i];
+        }
+        return *this;
+    } else {
+        throw(std::runtime_error("Shape of ImageDatas must match"));
+    }
+}
+
+template <typename T, ssize_t Ndim>
+Image<T, Ndim> Image<T, Ndim>::operator-(const Image &other) {
+    Image result{*this};
+    result -= other;
+    return result;
+}
+
+template <typename T, ssize_t Ndim>
+Image<T, Ndim> &
+Image<T, Ndim>::operator-=(const Image<T, Ndim> &other) {
+    // check shape
+    if (shape_ == other.shape_) {
+        for (int i = 0; i < size_; ++i) {
+            data_[i] -= other.data_[i];
+        }
+        return *this;
+    } else {
+        throw(std::runtime_error("Shape of ImageDatas must match"));
+    }
+}
+template <typename T, ssize_t Ndim>
+Image<T, Ndim> Image<T, Ndim>::operator*(const Image &other) {
+    Image result = *this;
+    result *= other;
+    return result;
+}
+
+template <typename T, ssize_t Ndim>
+Image<T, Ndim> &
+Image<T, Ndim>::operator*=(const Image<T, Ndim> &other) {
+    // check shape
+    if (shape_ == other.shape_) {
+        for (int i = 0; i < size_; ++i) {
+            data_[i] *= other.data_[i];
+        }
+        return *this;
+    } else {
+        throw(std::runtime_error("Shape of ImageDatas must match"));
+    }
+}
+
+template <typename T, ssize_t Ndim>
+Image<T, Ndim> Image<T, Ndim>::operator/(const Image &other) {
+    Image result = *this;
+    result /= other;
+    return result;
+}
+
+template <typename T, ssize_t Ndim>
+Image<T, Ndim> &Image<T, Ndim>::operator&=(const T &mask) {
+    for (auto it = begin(); it != end(); ++it)
+        *it &= mask;
+    return *this;
+}
+
+// template <typename T, ssize_t Ndim>
+// Image<T, Ndim>& Image<T, Ndim>::operator/=(const Image<T, Ndim>&
+// other)
+// {
+//     //check shape
+//     if (shape_ == other.shape_) {
+//         for (int i = 0; i < size_; ++i) {
+//             data_[i] /= other.data_[i];
+//         }
+//         return *this;
+//     } else {
+//         throw(std::runtime_error("Shape of ImageDatas must match"));
+//     }
+// }
+
+template <typename T, ssize_t Ndim>
+Image<bool, Ndim> Image<T, Ndim>::operator>(const Image &other) {
+    if (shape_ == other.shape_) {
+        Image<bool> result{shape_};
+        for (int i = 0; i < size_; ++i) {
+            result(i) = (data_[i] > other.data_[i]);
+        }
+        return result;
+    } else {
+        throw(std::runtime_error("Shape of ImageDatas must match"));
+    }
+}
+
+template <typename T, ssize_t Ndim>
+Image<T, Ndim> &
+Image<T, Ndim>::operator=(const Image<T, Ndim> &other) {
+    if (this != &other) {
+        delete[] data_;
+        shape_ = other.shape_;
+        strides_ = other.strides_;
+        size_ = other.size_;
+        data_ = new T[size_];
+        std::copy(other.data_, other.data_ + size_, data_);
+    }
+    return *this;
+}
+
+template <typename T, ssize_t Ndim>
+bool Image<T, Ndim>::operator==(const Image<T, Ndim> &other) const {
+    if (shape_ != other.shape_)
+        return false;
+
+    for (int i = 0; i != size_; ++i)
+        if (data_[i] != other.data_[i])
+            return false;
+
+    return true;
+}
+
+template <typename T, ssize_t Ndim>
+bool Image<T, Ndim>::operator!=(const Image<T, Ndim> &other) const {
+    return !((*this) == other);
+}
+template <typename T, ssize_t Ndim>
+Image<T, Ndim> &Image<T, Ndim>::operator++() {
+    for (int i = 0; i < size_; ++i)
+        data_[i] += 1;
+    return *this;
+}
+template <typename T, ssize_t Ndim>
+Image<T, Ndim> &Image<T, Ndim>::operator=(const T &value) {
+    std::fill_n(data_, size_, value);
+    return *this;
+}
+
+template <typename T, ssize_t Ndim>
+Image<T, Ndim> &Image<T, Ndim>::operator+=(const T &value) {
+    for (int i = 0; i < size_; ++i)
+        data_[i] += value;
+    return *this;
+}
+
+template <typename T, ssize_t Ndim>
+Image<T, Ndim> Image<T, Ndim>::operator+(const T &value) {
+    Image result = *this;
+    result += value;
+    return result;
+}
+template <typename T, ssize_t Ndim>
+Image<T, Ndim> &Image<T, Ndim>::operator-=(const T &value) {
+    for (int i = 0; i < size_; ++i)
+        data_[i] -= value;
+    return *this;
+}
+template <typename T, ssize_t Ndim>
+Image<T, Ndim> Image<T, Ndim>::operator-(const T &value) {
+    Image result = *this;
+    result -= value;
+    return result;
+}
+
+template <typename T, ssize_t Ndim>
+Image<T, Ndim> &Image<T, Ndim>::operator/=(const T &value) {
+    for (int i = 0; i < size_; ++i)
+        data_[i] /= value;
+    return *this;
+}
+template <typename T, ssize_t Ndim>
+Image<T, Ndim> Image<T, Ndim>::operator/(const T &value) {
+    Image result = *this;
+    result /= value;
+    return result;
+}
+template <typename T, ssize_t Ndim>
+Image<T, Ndim> &Image<T, Ndim>::operator*=(const T &value) {
+    for (int i = 0; i < size_; ++i)
+        data_[i] *= value;
+    return *this;
+}
+template <typename T, ssize_t Ndim>
+Image<T, Ndim> Image<T, Ndim>::operator*(const T &value) {
+    Image result = *this;
+    result *= value;
+    return result;
+}
+template <typename T, ssize_t Ndim> void Image<T, Ndim>::Print() {
+    if (shape_[0] < 20 && shape_[1] < 20)
+        Print_all();
+    else
+        Print_some();
+}
+template <typename T, ssize_t Ndim> void Image<T, Ndim>::Print_all() {
+    for (auto row = 0; row < shape_[0]; ++row) {
+        for (auto col = 0; col < shape_[1]; ++col) {
+            std::cout << std::setw(3);
+            std::cout << (*this)(row, col) << " ";
+        }
+        std::cout << "\n";
+    }
+}
+template <typename T, ssize_t Ndim> void Image<T, Ndim>::Print_some() {
+    for (auto row = 0; row < 5; ++row) {
+        for (auto col = 0; col < 5; ++col) {
+            std::cout << std::setw(7);
+            std::cout << (*this)(row, col) << " ";
+        }
+        std::cout << "\n";
+    }
+}
+
+template <typename T, ssize_t Ndim>
+void save(Image<T, Ndim> &img, std::string pathname) {
+    std::ofstream f;
+    f.open(pathname, std::ios::binary);
+    f.write(img.buffer(), img.size() * sizeof(T));
+    f.close();
+}
+
+template <typename T, ssize_t Ndim>
+Image<T, Ndim> load(const std::string &pathname,
+                        std::array<ssize_t, Ndim> shape) {
+    Image<T, Ndim> img{shape};
+    std::ifstream f;
+    f.open(pathname, std::ios::binary);
+    f.read(img.buffer(), img.size() * sizeof(T));
+    f.close();
+    return img;
+}
+
+
diff --git a/core/include/aare/VariableSizeClusterFinder.hpp b/core/include/aare/VariableSizeClusterFinder.hpp
index af3fd7a..953cd87 100644
--- a/core/include/aare/VariableSizeClusterFinder.hpp
+++ b/core/include/aare/VariableSizeClusterFinder.hpp
@@ -6,7 +6,7 @@
 #include <vector>
 
 
-#include "aare/ImageData.hpp"
+#include "aare/Image.hpp"
 
 const int MAX_CLUSTER_SIZE = 200;
 namespace pl {
@@ -31,9 +31,9 @@ template <typename T> class ClusterFinder {
   private:
     const std::array<ssize_t, 2> shape_;
     View<T, 2> original_;
-    ImageData<int, 2> labeled_;
-    ImageData<int, 2> peripheral_labeled_;
-    ImageData<bool, 2> binary_; // over threshold flag
+    Image<int, 2> labeled_;
+    Image<int, 2> peripheral_labeled_;
+    Image<bool, 2> binary_; // over threshold flag
     T threshold_;
     View<T, 2> noiseMap;
     bool use_noise_map = false;
@@ -56,7 +56,7 @@ template <typename T> class ClusterFinder {
         hits.reserve(2000);
     }
 
-    ImageData<int, 2> labeled() { return labeled_; }
+    Image<int, 2> labeled() { return labeled_; }
 
     void set_noiseMap(View<T, 2> noise_map) { noiseMap = noise_map; use_noise_map = true; }
     void set_peripheralThresholdFactor(int factor) { peripheralThresholdFactor_ = factor; }
diff --git a/core/test/wrappers.test.cpp b/core/test/wrappers.test.cpp
index e2983c3..2ffd267 100644
--- a/core/test/wrappers.test.cpp
+++ b/core/test/wrappers.test.cpp
@@ -1,5 +1,5 @@
-#include <aare/View.hpp>
 #include <aare/Frame.hpp>
+#include <aare/View.hpp>
 #include <catch2/catch_test_macros.hpp>
 #include <cstdint>
 
@@ -33,17 +33,37 @@ TEST_CASE("View") {
             REQUIRE(ds(i / 10, i % 10) == data[i]);
         }
     }
+    // SECTION("from Frame") {
+    //     Frame f(reinterpret_cast<std::byte *>(data), 10, 10, 16);
+    //     View<uint16_t> ds = f.view<uint16_t>();
+    //     for (int i = 0; i < 100; i++) {
+    //         REQUIRE(ds(i / 10, i % 10) == data[i]);
+    //     }
+
+    //     f.set(0, 0, (uint16_t)44);
+    //     REQUIRE((uint16_t)*f.get(0, 0) == 44); // check that set worked
+    //     REQUIRE(ds(0, 0) == 44);               // check that ds is updated
+    //     REQUIRE(data[0] == 0);                 // check that data is not updated
+    // }
+    delete[] data;
+}
+
+TEST_CASE("Image") {
+    auto data = new uint16_t[100];
+    for (int i = 0; i < 100; i++) {
+        data[i] = i;
+    }
     SECTION("from Frame") {
         Frame f(reinterpret_cast<std::byte *>(data), 10, 10, 16);
-        View<uint16_t> ds = f.view<uint16_t>();
+        Image<uint16_t> img = f.image<uint16_t>();
         for (int i = 0; i < 100; i++) {
-            REQUIRE(ds(i / 10, i % 10) == data[i]);
+            REQUIRE(img(i / 10, i % 10) == data[i]);
         }
 
         f.set(0, 0, (uint16_t)44);
         REQUIRE((uint16_t)*f.get(0, 0) == 44); // check that set worked
-        REQUIRE(ds(0, 0) == 44);// check that ds is updated
-        REQUIRE(data[0] == 0); // check that data is not updated
+        REQUIRE(img(0, 0) == 0);               // check that ds is updated
+        REQUIRE(data[0] == 0);                 // check that data is not updated
     }
     delete[] data;
 }
\ No newline at end of file

From 4ff2e18c6a8d8ba687cd31c84fa5f0bc916f21af Mon Sep 17 00:00:00 2001
From: Bechir <bechir.brahem420@gmail.com>
Date: Thu, 21 Mar 2024 16:17:00 +0100
Subject: [PATCH 2/3] change image to NDArray

---
 core/include/aare/Frame.hpp                   |   6 +-
 core/include/aare/{Image.hpp => NDArray.hpp}  | 168 +++++++++---------
 .../aare/VariableSizeClusterFinder.hpp        |  10 +-
 core/test/wrappers.test.cpp                   |  28 +--
 data/jungfrau_double_master_0.json            |   2 +-
 data/jungfrau_single_master_0.json            |   2 +-
 data/m3_master_0.json                         |   2 +-
 7 files changed, 109 insertions(+), 109 deletions(-)
 rename core/include/aare/{Image.hpp => NDArray.hpp} (65%)

diff --git a/core/include/aare/Frame.hpp b/core/include/aare/Frame.hpp
index 5e08b22..b6e8446 100644
--- a/core/include/aare/Frame.hpp
+++ b/core/include/aare/Frame.hpp
@@ -1,5 +1,5 @@
 #pragma once
-#include "aare/Image.hpp"
+#include "aare/NDArray.hpp"
 #include "aare/defs.hpp"
 #include <cstddef>
 #include <cstdint>
@@ -47,8 +47,8 @@ class Frame {
     }
 
     template <typename T>
-    Image<T> image() {
-        return Image<T>(this->view<T>());
+    NDArray<T> image() {
+        return NDArray<T>(this->view<T>());
     }
 
     ~Frame() { delete[] m_data; }
diff --git a/core/include/aare/Image.hpp b/core/include/aare/NDArray.hpp
similarity index 65%
rename from core/include/aare/Image.hpp
rename to core/include/aare/NDArray.hpp
index 54deddf..fb3378a 100644
--- a/core/include/aare/Image.hpp
+++ b/core/include/aare/NDArray.hpp
@@ -7,7 +7,7 @@ memory.
 TODO! Add expression templates for operators
 
 */
-#include "aare/View.hpp"
+#include "aare/NDView.hpp"
 
 #include <algorithm>
 #include <array>
@@ -19,47 +19,47 @@ TODO! Add expression templates for operators
 #include <numeric>
 
 
-template <typename T, ssize_t Ndim = 2> class Image {
+template <typename T, ssize_t Ndim = 2> class NDArray {
   public:
-    Image()
+    NDArray()
         : shape_(), strides_(c_strides<Ndim>(shape_)), size_(0),
           data_(nullptr){};
 
-    explicit Image(std::array<ssize_t, Ndim> shape)
+    explicit NDArray(std::array<ssize_t, Ndim> shape)
         : shape_(shape), strides_(c_strides<Ndim>(shape_)),
           size_(std::accumulate(shape_.begin(), shape_.end(), 1,
                                 std::multiplies<ssize_t>())),
           data_(new T[size_]){};
 
-    Image(std::array<ssize_t, Ndim> shape, T value) : Image(shape) {
+    NDArray(std::array<ssize_t, Ndim> shape, T value) : NDArray(shape) {
         this->operator=(value);
     }
 
-    /* When constructing from a View we need to copy the data since
-    Image expect to own its data, and span is just a view*/
-    Image(View<T, Ndim> span):Image(span.shape()){
+    /* When constructing from a NDView we need to copy the data since
+    NDArray expect to own its data, and span is just a view*/
+    NDArray(NDView<T, Ndim> span):NDArray(span.shape()){
         std::copy(span.begin(), span.end(), begin());
-        // fmt::print("Image(View<T, Ndim> span)\n");
+        // fmt::print("NDArray(NDView<T, Ndim> span)\n");
     }
 
     // Move constructor
-    Image(Image &&other)
+    NDArray(NDArray &&other)
         : shape_(other.shape_), strides_(c_strides<Ndim>(shape_)),
           size_(other.size_), data_(nullptr) {
         data_ = other.data_;
         other.reset();
-        // fmt::print("Image(Image &&other)\n");
+        // fmt::print("NDArray(NDArray &&other)\n");
     }
 
     // Copy constructor
-    Image(const Image &other)
+    NDArray(const NDArray &other)
         : shape_(other.shape_), strides_(c_strides<Ndim>(shape_)),
           size_(other.size_), data_(new T[size_]) {
         std::copy(other.data_, other.data_ + size_, data_);
-        // fmt::print("Image(const Image &other)\n");
+        // fmt::print("NDArray(const NDArray &other)\n");
     }
 
-    ~Image() {
+    ~NDArray() {
         delete[] data_;
     }
 
@@ -68,19 +68,19 @@ template <typename T, ssize_t Ndim = 2> class Image {
 
     using value_type =  T;
 
-    Image &operator=(Image &&other);      // Move assign
-    Image &operator=(const Image &other); // Copy assign
+    NDArray &operator=(NDArray &&other);      // Move assign
+    NDArray &operator=(const NDArray &other); // Copy assign
 
-    Image operator+(const Image &other);
-    Image &operator+=(const Image &other);
-    Image operator-(const Image &other);
-    Image &operator-=(const Image &other);
-    Image operator*(const Image &other);
-    Image &operator*=(const Image &other);
-    Image operator/(const Image &other);
-    // Image& operator/=(const Image& other);
+    NDArray operator+(const NDArray &other);
+    NDArray &operator+=(const NDArray &other);
+    NDArray operator-(const NDArray &other);
+    NDArray &operator-=(const NDArray &other);
+    NDArray operator*(const NDArray &other);
+    NDArray &operator*=(const NDArray &other);
+    NDArray operator/(const NDArray &other);
+    // NDArray& operator/=(const NDArray& other);
     template <typename V>
-    Image &operator/=(const Image<V, Ndim> &other) {
+    NDArray &operator/=(const NDArray<V, Ndim> &other) {
         // check shape
         if (shape_ == other.shape()) {
             for (int i = 0; i < size_; ++i) {
@@ -88,26 +88,26 @@ template <typename T, ssize_t Ndim = 2> class Image {
             }
             return *this;
         } else {
-            throw(std::runtime_error("Shape of Image must match"));
+            throw(std::runtime_error("Shape of NDArray must match"));
         }
     }
 
-    Image<bool, Ndim> operator>(const Image &other);
+    NDArray<bool, Ndim> operator>(const NDArray &other);
 
-    bool operator==(const Image &other) const;
-    bool operator!=(const Image &other) const;
+    bool operator==(const NDArray &other) const;
+    bool operator!=(const NDArray &other) const;
 
-    Image &operator=(const T &);
-    Image &operator+=(const T &);
-    Image operator+(const T &);
-    Image &operator-=(const T &);
-    Image operator-(const T &);
-    Image &operator*=(const T &);
-    Image operator*(const T &);
-    Image &operator/=(const T &);
-    Image operator/(const T &);
+    NDArray &operator=(const T &);
+    NDArray &operator+=(const T &);
+    NDArray operator+(const T &);
+    NDArray &operator-=(const T &);
+    NDArray operator-(const T &);
+    NDArray &operator*=(const T &);
+    NDArray operator*(const T &);
+    NDArray &operator/=(const T &);
+    NDArray operator/(const T &);
 
-    Image &operator&=(const T &);
+    NDArray &operator&=(const T &);
 
     void sqrt() {
         for (int i = 0; i < size_; ++i) {
@@ -115,7 +115,7 @@ template <typename T, ssize_t Ndim = 2> class Image {
         }
     }
 
-    Image &operator++(); // pre inc
+    NDArray &operator++(); // pre inc
 
     template <typename... Ix>
     typename std::enable_if<sizeof...(Ix) == Ndim, T &>::type
@@ -153,7 +153,7 @@ template <typename T, ssize_t Ndim = 2> class Image {
         // return strides_;
     }
 
-    View<T, Ndim> span() const { return View<T, Ndim>{data_, shape_}; }
+    NDView<T, Ndim> span() const { return NDView<T, Ndim>{data_, shape_}; }
 
     void Print();
     void Print_all();
@@ -175,7 +175,7 @@ template <typename T, ssize_t Ndim = 2> class Image {
 
 // Move assign
 template <typename T, ssize_t Ndim>
-Image<T, Ndim> &Image<T, Ndim>::operator=(Image<T, Ndim> &&other) {
+NDArray<T, Ndim> &NDArray<T, Ndim>::operator=(NDArray<T, Ndim> &&other) {
     if (this != &other) {
         delete[] data_;
         data_ = other.data_;
@@ -188,14 +188,14 @@ Image<T, Ndim> &Image<T, Ndim>::operator=(Image<T, Ndim> &&other) {
 }
 
 template <typename T, ssize_t Ndim>
-Image<T, Ndim> Image<T, Ndim>::operator+(const Image &other) {
-    Image result(*this);
+NDArray<T, Ndim> NDArray<T, Ndim>::operator+(const NDArray &other) {
+    NDArray result(*this);
     result += other;
     return result;
 }
 template <typename T, ssize_t Ndim>
-Image<T, Ndim> &
-Image<T, Ndim>::operator+=(const Image<T, Ndim> &other) {
+NDArray<T, Ndim> &
+NDArray<T, Ndim>::operator+=(const NDArray<T, Ndim> &other) {
     // check shape
     if (shape_ == other.shape_) {
         for (int i = 0; i < size_; ++i) {
@@ -208,15 +208,15 @@ Image<T, Ndim>::operator+=(const Image<T, Ndim> &other) {
 }
 
 template <typename T, ssize_t Ndim>
-Image<T, Ndim> Image<T, Ndim>::operator-(const Image &other) {
-    Image result{*this};
+NDArray<T, Ndim> NDArray<T, Ndim>::operator-(const NDArray &other) {
+    NDArray result{*this};
     result -= other;
     return result;
 }
 
 template <typename T, ssize_t Ndim>
-Image<T, Ndim> &
-Image<T, Ndim>::operator-=(const Image<T, Ndim> &other) {
+NDArray<T, Ndim> &
+NDArray<T, Ndim>::operator-=(const NDArray<T, Ndim> &other) {
     // check shape
     if (shape_ == other.shape_) {
         for (int i = 0; i < size_; ++i) {
@@ -228,15 +228,15 @@ Image<T, Ndim>::operator-=(const Image<T, Ndim> &other) {
     }
 }
 template <typename T, ssize_t Ndim>
-Image<T, Ndim> Image<T, Ndim>::operator*(const Image &other) {
-    Image result = *this;
+NDArray<T, Ndim> NDArray<T, Ndim>::operator*(const NDArray &other) {
+    NDArray result = *this;
     result *= other;
     return result;
 }
 
 template <typename T, ssize_t Ndim>
-Image<T, Ndim> &
-Image<T, Ndim>::operator*=(const Image<T, Ndim> &other) {
+NDArray<T, Ndim> &
+NDArray<T, Ndim>::operator*=(const NDArray<T, Ndim> &other) {
     // check shape
     if (shape_ == other.shape_) {
         for (int i = 0; i < size_; ++i) {
@@ -249,21 +249,21 @@ Image<T, Ndim>::operator*=(const Image<T, Ndim> &other) {
 }
 
 template <typename T, ssize_t Ndim>
-Image<T, Ndim> Image<T, Ndim>::operator/(const Image &other) {
-    Image result = *this;
+NDArray<T, Ndim> NDArray<T, Ndim>::operator/(const NDArray &other) {
+    NDArray result = *this;
     result /= other;
     return result;
 }
 
 template <typename T, ssize_t Ndim>
-Image<T, Ndim> &Image<T, Ndim>::operator&=(const T &mask) {
+NDArray<T, Ndim> &NDArray<T, Ndim>::operator&=(const T &mask) {
     for (auto it = begin(); it != end(); ++it)
         *it &= mask;
     return *this;
 }
 
 // template <typename T, ssize_t Ndim>
-// Image<T, Ndim>& Image<T, Ndim>::operator/=(const Image<T, Ndim>&
+// NDArray<T, Ndim>& NDArray<T, Ndim>::operator/=(const NDArray<T, Ndim>&
 // other)
 // {
 //     //check shape
@@ -278,9 +278,9 @@ Image<T, Ndim> &Image<T, Ndim>::operator&=(const T &mask) {
 // }
 
 template <typename T, ssize_t Ndim>
-Image<bool, Ndim> Image<T, Ndim>::operator>(const Image &other) {
+NDArray<bool, Ndim> NDArray<T, Ndim>::operator>(const NDArray &other) {
     if (shape_ == other.shape_) {
-        Image<bool> result{shape_};
+        NDArray<bool> result{shape_};
         for (int i = 0; i < size_; ++i) {
             result(i) = (data_[i] > other.data_[i]);
         }
@@ -291,8 +291,8 @@ Image<bool, Ndim> Image<T, Ndim>::operator>(const Image &other) {
 }
 
 template <typename T, ssize_t Ndim>
-Image<T, Ndim> &
-Image<T, Ndim>::operator=(const Image<T, Ndim> &other) {
+NDArray<T, Ndim> &
+NDArray<T, Ndim>::operator=(const NDArray<T, Ndim> &other) {
     if (this != &other) {
         delete[] data_;
         shape_ = other.shape_;
@@ -305,7 +305,7 @@ Image<T, Ndim>::operator=(const Image<T, Ndim> &other) {
 }
 
 template <typename T, ssize_t Ndim>
-bool Image<T, Ndim>::operator==(const Image<T, Ndim> &other) const {
+bool NDArray<T, Ndim>::operator==(const NDArray<T, Ndim> &other) const {
     if (shape_ != other.shape_)
         return false;
 
@@ -317,78 +317,78 @@ bool Image<T, Ndim>::operator==(const Image<T, Ndim> &other) const {
 }
 
 template <typename T, ssize_t Ndim>
-bool Image<T, Ndim>::operator!=(const Image<T, Ndim> &other) const {
+bool NDArray<T, Ndim>::operator!=(const NDArray<T, Ndim> &other) const {
     return !((*this) == other);
 }
 template <typename T, ssize_t Ndim>
-Image<T, Ndim> &Image<T, Ndim>::operator++() {
+NDArray<T, Ndim> &NDArray<T, Ndim>::operator++() {
     for (int i = 0; i < size_; ++i)
         data_[i] += 1;
     return *this;
 }
 template <typename T, ssize_t Ndim>
-Image<T, Ndim> &Image<T, Ndim>::operator=(const T &value) {
+NDArray<T, Ndim> &NDArray<T, Ndim>::operator=(const T &value) {
     std::fill_n(data_, size_, value);
     return *this;
 }
 
 template <typename T, ssize_t Ndim>
-Image<T, Ndim> &Image<T, Ndim>::operator+=(const T &value) {
+NDArray<T, Ndim> &NDArray<T, Ndim>::operator+=(const T &value) {
     for (int i = 0; i < size_; ++i)
         data_[i] += value;
     return *this;
 }
 
 template <typename T, ssize_t Ndim>
-Image<T, Ndim> Image<T, Ndim>::operator+(const T &value) {
-    Image result = *this;
+NDArray<T, Ndim> NDArray<T, Ndim>::operator+(const T &value) {
+    NDArray result = *this;
     result += value;
     return result;
 }
 template <typename T, ssize_t Ndim>
-Image<T, Ndim> &Image<T, Ndim>::operator-=(const T &value) {
+NDArray<T, Ndim> &NDArray<T, Ndim>::operator-=(const T &value) {
     for (int i = 0; i < size_; ++i)
         data_[i] -= value;
     return *this;
 }
 template <typename T, ssize_t Ndim>
-Image<T, Ndim> Image<T, Ndim>::operator-(const T &value) {
-    Image result = *this;
+NDArray<T, Ndim> NDArray<T, Ndim>::operator-(const T &value) {
+    NDArray result = *this;
     result -= value;
     return result;
 }
 
 template <typename T, ssize_t Ndim>
-Image<T, Ndim> &Image<T, Ndim>::operator/=(const T &value) {
+NDArray<T, Ndim> &NDArray<T, Ndim>::operator/=(const T &value) {
     for (int i = 0; i < size_; ++i)
         data_[i] /= value;
     return *this;
 }
 template <typename T, ssize_t Ndim>
-Image<T, Ndim> Image<T, Ndim>::operator/(const T &value) {
-    Image result = *this;
+NDArray<T, Ndim> NDArray<T, Ndim>::operator/(const T &value) {
+    NDArray result = *this;
     result /= value;
     return result;
 }
 template <typename T, ssize_t Ndim>
-Image<T, Ndim> &Image<T, Ndim>::operator*=(const T &value) {
+NDArray<T, Ndim> &NDArray<T, Ndim>::operator*=(const T &value) {
     for (int i = 0; i < size_; ++i)
         data_[i] *= value;
     return *this;
 }
 template <typename T, ssize_t Ndim>
-Image<T, Ndim> Image<T, Ndim>::operator*(const T &value) {
-    Image result = *this;
+NDArray<T, Ndim> NDArray<T, Ndim>::operator*(const T &value) {
+    NDArray result = *this;
     result *= value;
     return result;
 }
-template <typename T, ssize_t Ndim> void Image<T, Ndim>::Print() {
+template <typename T, ssize_t Ndim> void NDArray<T, Ndim>::Print() {
     if (shape_[0] < 20 && shape_[1] < 20)
         Print_all();
     else
         Print_some();
 }
-template <typename T, ssize_t Ndim> void Image<T, Ndim>::Print_all() {
+template <typename T, ssize_t Ndim> void NDArray<T, Ndim>::Print_all() {
     for (auto row = 0; row < shape_[0]; ++row) {
         for (auto col = 0; col < shape_[1]; ++col) {
             std::cout << std::setw(3);
@@ -397,7 +397,7 @@ template <typename T, ssize_t Ndim> void Image<T, Ndim>::Print_all() {
         std::cout << "\n";
     }
 }
-template <typename T, ssize_t Ndim> void Image<T, Ndim>::Print_some() {
+template <typename T, ssize_t Ndim> void NDArray<T, Ndim>::Print_some() {
     for (auto row = 0; row < 5; ++row) {
         for (auto col = 0; col < 5; ++col) {
             std::cout << std::setw(7);
@@ -408,7 +408,7 @@ template <typename T, ssize_t Ndim> void Image<T, Ndim>::Print_some() {
 }
 
 template <typename T, ssize_t Ndim>
-void save(Image<T, Ndim> &img, std::string pathname) {
+void save(NDArray<T, Ndim> &img, std::string pathname) {
     std::ofstream f;
     f.open(pathname, std::ios::binary);
     f.write(img.buffer(), img.size() * sizeof(T));
@@ -416,9 +416,9 @@ void save(Image<T, Ndim> &img, std::string pathname) {
 }
 
 template <typename T, ssize_t Ndim>
-Image<T, Ndim> load(const std::string &pathname,
+NDArray<T, Ndim> load(const std::string &pathname,
                         std::array<ssize_t, Ndim> shape) {
-    Image<T, Ndim> img{shape};
+    NDArray<T, Ndim> img{shape};
     std::ifstream f;
     f.open(pathname, std::ios::binary);
     f.read(img.buffer(), img.size() * sizeof(T));
diff --git a/core/include/aare/VariableSizeClusterFinder.hpp b/core/include/aare/VariableSizeClusterFinder.hpp
index 89d8269..dcf95f0 100644
--- a/core/include/aare/VariableSizeClusterFinder.hpp
+++ b/core/include/aare/VariableSizeClusterFinder.hpp
@@ -6,7 +6,7 @@
 #include <vector>
 
 
-#include "aare/Image.hpp"
+#include "aare/NDArray.hpp"
 
 const int MAX_CLUSTER_SIZE = 200;
 namespace pl {
@@ -31,9 +31,9 @@ template <typename T> class ClusterFinder {
   private:
     const std::array<ssize_t, 2> shape_;
     NDView<T, 2> original_;
-    Image<int, 2> labeled_;
-    Image<int, 2> peripheral_labeled_;
-    Image<bool, 2> binary_; // over threshold flag
+    NDArray<int, 2> labeled_;
+    NDArray<int, 2> peripheral_labeled_;
+    NDArray<bool, 2> binary_; // over threshold flag
     T threshold_;
     NDView<T, 2> noiseMap;
     bool use_noise_map = false;
@@ -56,7 +56,7 @@ template <typename T> class ClusterFinder {
         hits.reserve(2000);
     }
 
-    Image<int, 2> labeled() { return labeled_; }
+    NDArray<int, 2> labeled() { return labeled_; }
 
     void set_noiseMap(NDView<T, 2> noise_map) { noiseMap = noise_map; use_noise_map = true; }
     void set_peripheralThresholdFactor(int factor) { peripheralThresholdFactor_ = factor; }
diff --git a/core/test/wrappers.test.cpp b/core/test/wrappers.test.cpp
index adeeb2b..ae0f12e 100644
--- a/core/test/wrappers.test.cpp
+++ b/core/test/wrappers.test.cpp
@@ -1,6 +1,6 @@
 #include <aare/NDView.hpp>
 #include <aare/Frame.hpp>
-#include <aare/View.hpp>
+#include <aare/NDView.hpp>
 #include <catch2/catch_test_macros.hpp>
 #include <cstdint>
 
@@ -34,29 +34,29 @@ TEST_CASE("NDView") {
             REQUIRE(ds(i / 10, i % 10) == data[i]);
         }
     }
-    // SECTION("from Frame") {
-    //     Frame f(reinterpret_cast<std::byte *>(data), 10, 10, 16);
-    //     View<uint16_t> ds = f.view<uint16_t>();
-    //     for (int i = 0; i < 100; i++) {
-    //         REQUIRE(ds(i / 10, i % 10) == data[i]);
-    //     }
+    SECTION("from Frame") {
+        Frame f(reinterpret_cast<std::byte *>(data), 10, 10, 16);
+        NDView<uint16_t> ds = f.view<uint16_t>();
+        for (int i = 0; i < 100; i++) {
+            REQUIRE(ds(i / 10, i % 10) == data[i]);
+        }
 
-    //     f.set(0, 0, (uint16_t)44);
-    //     REQUIRE((uint16_t)*f.get(0, 0) == 44); // check that set worked
-    //     REQUIRE(ds(0, 0) == 44);               // check that ds is updated
-    //     REQUIRE(data[0] == 0);                 // check that data is not updated
-    // }
+        f.set(0, 0, (uint16_t)44);
+        REQUIRE((uint16_t)*f.get(0, 0) == 44); // check that set worked
+        REQUIRE(ds(0, 0) == 44);               // check that ds is updated
+        REQUIRE(data[0] == 0);                 // check that data is not updated
+    }
     delete[] data;
 }
 
-TEST_CASE("Image") {
+TEST_CASE("NDArray") {
     auto data = new uint16_t[100];
     for (int i = 0; i < 100; i++) {
         data[i] = i;
     }
     SECTION("from Frame") {
         Frame f(reinterpret_cast<std::byte *>(data), 10, 10, 16);
-        Image<uint16_t> img = f.image<uint16_t>();
+        NDArray<uint16_t> img = f.image<uint16_t>();
         for (int i = 0; i < 100; i++) {
             REQUIRE(img(i / 10, i % 10) == data[i]);
         }
diff --git a/data/jungfrau_double_master_0.json b/data/jungfrau_double_master_0.json
index e6a80e3..12f4395 100644
--- a/data/jungfrau_double_master_0.json
+++ b/data/jungfrau_double_master_0.json
@@ -7,7 +7,7 @@
         "x": 1,
         "y": 2
     },
-    "Image Size in bytes": 524288,
+    "NDArray Size in bytes": 524288,
     "Pixels": {
         "x": 1024,
         "y": 256
diff --git a/data/jungfrau_single_master_0.json b/data/jungfrau_single_master_0.json
index 547081a..44f5f96 100644
--- a/data/jungfrau_single_master_0.json
+++ b/data/jungfrau_single_master_0.json
@@ -7,7 +7,7 @@
         "x": 1,
         "y": 1
     },
-    "Image Size in bytes": 1048576,
+    "NDArray Size in bytes": 1048576,
     "Pixels": {
         "x": 1024,
         "y": 512
diff --git a/data/m3_master_0.json b/data/m3_master_0.json
index f6b4f31..c629f98 100644
--- a/data/m3_master_0.json
+++ b/data/m3_master_0.json
@@ -7,7 +7,7 @@
         "x": 1,
         "y": 1
     },
-    "Image Size in bytes": 15360,
+    "NDArray Size in bytes": 15360,
     "Pixels": {
         "x": 3840,
         "y": 1

From 136829f70a1088e62d7a61118d9ef39585577472 Mon Sep 17 00:00:00 2001
From: Bechir <bechir.brahem420@gmail.com>
Date: Thu, 21 Mar 2024 16:30:04 +0100
Subject: [PATCH 3/3] fix wrong changes

---
 data/jungfrau_double_master_0.json | 2 +-
 data/jungfrau_single_master_0.json | 2 +-
 data/m3_master_0.json              | 2 +-
 3 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/data/jungfrau_double_master_0.json b/data/jungfrau_double_master_0.json
index 12f4395..e6a80e3 100644
--- a/data/jungfrau_double_master_0.json
+++ b/data/jungfrau_double_master_0.json
@@ -7,7 +7,7 @@
         "x": 1,
         "y": 2
     },
-    "NDArray Size in bytes": 524288,
+    "Image Size in bytes": 524288,
     "Pixels": {
         "x": 1024,
         "y": 256
diff --git a/data/jungfrau_single_master_0.json b/data/jungfrau_single_master_0.json
index 44f5f96..547081a 100644
--- a/data/jungfrau_single_master_0.json
+++ b/data/jungfrau_single_master_0.json
@@ -7,7 +7,7 @@
         "x": 1,
         "y": 1
     },
-    "NDArray Size in bytes": 1048576,
+    "Image Size in bytes": 1048576,
     "Pixels": {
         "x": 1024,
         "y": 512
diff --git a/data/m3_master_0.json b/data/m3_master_0.json
index c629f98..f6b4f31 100644
--- a/data/m3_master_0.json
+++ b/data/m3_master_0.json
@@ -7,7 +7,7 @@
         "x": 1,
         "y": 1
     },
-    "NDArray Size in bytes": 15360,
+    "Image Size in bytes": 15360,
     "Pixels": {
         "x": 3840,
         "y": 1