Merge branch 'main' into dev/reduce

- added ClusterVector::empty() to check if the vector is empty
- Fixed generation of missing docs for ClusterVector

RELEASE.md

@@ -6,6 +6,7 @@
 Features:
 
 - Cluster finder now works with 5x5, 7x7 and 9x9 clusters
+- Added ClusterVector::empty() member
 
 
 ### 2025.05.22
@@ -17,6 +18,7 @@ Features:
 Bugfixes:
 
 - Fixed crash when opening raw files with large number of data files
+- Fixed reading RawFiles with ROI fully excluding some sub files. 
 
 
 

docs/CMakeLists.txt

@@ -45,12 +45,3 @@ add_custom_target(
     COMMENT "Generating documentation with Sphinx"
 )
 
-add_custom_target(
-    rst
-    COMMAND ${SPHINX_EXECUTABLE} -a -b html
-    -Dbreathe_projects.aare=${CMAKE_CURRENT_BINARY_DIR}/xml
-    -c "${SPHINX_BUILD}"
-    ${SPHINX_BUILD}/src 
-    ${SPHINX_BUILD}/html
-    COMMENT "Generating documentation with Sphinx"
-)

docs/Doxyfile.in

@@ -886,7 +886,7 @@ EXCLUDE_SYMLINKS       = NO
 # Note that the wildcards are matched against the file with absolute path, so to
 # exclude all test directories for example use the pattern */test/*
 
-EXCLUDE_PATTERNS       = */docs/* */tests/* */python/* */manual */slsDetectorServers/* */libs/* */integrationTests *README* */slsDetectorGui/* */ctbGui/* */slsDetectorCalibration/* *TobiSchluter*
+EXCLUDE_PATTERNS       = *build* */docs/* */tests/* *.test.cpp* */python/* */manual */slsDetectorServers/* */libs/* */integrationTests *README* *_deps* *TobiSchluter*
 
 # The EXCLUDE_SYMBOLS tag can be used to specify one or more symbol names
 # (namespaces, classes, functions, etc.) that should be excluded from the

docs/src/ClusterVector.rst

@@ -3,4 +3,13 @@ ClusterVector
 
 .. doxygenclass:: aare::ClusterVector
    :members:
-   :undoc-members:
+   :undoc-members:
+   :private-members:
+
+
+
+.. doxygenclass:: aare::ClusterVector< Cluster< T, ClusterSizeX, ClusterSizeY, CoordType > > 
+   :members:
+   :undoc-members:
+   :private-members:
+   

docs/src/Workflow.rst

@@ -37,7 +37,7 @@ unfamiliar steps.
 
 
 Checklists for deployment
-~~~~~~~~~~~~~~~~~~
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 **Feature:**
 

include/aare/Cluster.hpp

@@ -74,6 +74,110 @@ struct Cluster {
     }
 };
 
+template<typename T>
+Cluster<T, 2, 2, uint16_t> reduce_3x3_to_2x2(const Cluster<T, 3, 3, uint16_t> &c) {
+    Cluster<T, 2, 2, uint16_t> result;
+    
+    auto [s, i] = c.max_sum_2x2();
+    switch (i) {
+        case 0:
+            result.x = c.x-1;
+            result.y = c.y+1;
+            result.data = {c.data[0], c.data[1], c.data[3], c.data[4]};
+            break;
+        case 1:
+            result.x = c.x;
+            result.y = c.y + 1;
+            result.data = {c.data[1], c.data[2], c.data[4], c.data[5]};
+            break;
+        case 2:
+            result.x = c.x -1;
+            result.y = c.y;
+            result.data = {c.data[3], c.data[4], c.data[6], c.data[7]};
+            break;
+        case 3:
+            result.x = c.x;
+            result.y = c.y;
+            result.data = {c.data[4], c.data[5], c.data[7], c.data[8]};
+            break;
+    }
+
+    // do some stuff
+    return result;
+}
+
+template<typename T>
+Cluster<T, 3, 3, uint16_t> reduce_5x5_to_3x3(const Cluster<T, 5, 5, uint16_t> &c) {
+    Cluster<T, 3, 3, uint16_t> result;
+
+    // Reduce the 5x5 cluster to a 3x3 cluster by selecting the 3x3 block with the highest sum
+    std::array<T, 9> sum_3x3_subclusters;
+
+    //Write out the sums in the hope that the compiler can optimize this
+    sum_3x3_subclusters[0] = c.data[0] + c.data[1] + c.data[2] + c.data[5] + c.data[6] + c.data[7] + c.data[10] + c.data[11] + c.data[12];
+    sum_3x3_subclusters[1] = c.data[1] + c.data[2] + c.data[3] + c.data[6] + c.data[7] + c.data[8] + c.data[11] + c.data[12] + c.data[13];
+    sum_3x3_subclusters[2] = c.data[2] + c.data[3] + c.data[4] + c.data[7] + c.data[8] + c.data[9] + c.data[12] + c.data[13] + c.data[14];
+    sum_3x3_subclusters[3] = c.data[5] + c.data[6] + c.data[7] + c.data[10] + c.data[11] + c.data[12] + c.data[15] + c.data[16] + c.data[17];
+    sum_3x3_subclusters[4] = c.data[6] + c.data[7] + c.data[8] + c.data[11] + c.data[12] + c.data[13] + c.data[16] + c.data[17] + c.data[18];
+    sum_3x3_subclusters[5] = c.data[7] + c.data[8] + c.data[9] + c.data[12] + c.data[13] + c.data[14] + c.data[17] + c.data[18] + c.data[19];
+    sum_3x3_subclusters[6] = c.data[10] + c.data[11] + c.data[12] + c.data[15] + c.data[16] + c.data[17] + c.data[20] + c.data[21] + c.data[22];
+    sum_3x3_subclusters[7] = c.data[11] + c.data[12] + c.data[13] + c.data[16] + c.data[17] + c.data[18] + c.data[21] + c.data[22] + c.data[23];
+    sum_3x3_subclusters[8] = c.data[12] + c.data[13] + c.data[14] + c.data[17] + c.data[18] + c.data[19] + c.data[22] + c.data[23] + c.data[24];
+
+    auto index = std::max_element(sum_3x3_subclusters.begin(), sum_3x3_subclusters.end()) - sum_3x3_subclusters.begin();
+
+    switch (index) {
+        case 0:
+            result.x = c.x - 1;
+            result.y = c.y + 1;
+            result.data = {c.data[0], c.data[1], c.data[2], c.data[5], c.data[6], c.data[7], c.data[10], c.data[11], c.data[12]};
+            break;
+        case 1:
+            result.x = c.x;
+            result.y = c.y + 1;
+            result.data = {c.data[1], c.data[2], c.data[3], c.data[6], c.data[7], c.data[8], c.data[11], c.data[12], c.data[13]};
+            break;
+        case 2:
+            result.x = c.x + 1;
+            result.y = c.y + 1;
+            result.data = {c.data[2], c.data[3], c.data[4], c.data[7], c.data[8], c.data[9], c.data[12], c.data[13], c.data[14]};
+            break;
+        case 3:
+            result.x = c.x - 1;
+            result.y = c.y;
+            result.data = {c.data[5], c.data[6], c.data[7], c.data[10], c.data[11], c.data[12], c.data[15], c.data[16], c.data[17]};
+            break;
+        case 4:
+            result.x = c.x + 1;
+            result.y = c.y;
+            result.data = {c.data[6], c.data[7], c.data[8], c.data[11], c.data[12], c.data[13], c.data[16], c.data[17], c.data[18]};
+            break;
+        case 5:
+            result.x = c.x + 1;
+            result.y = c.y;
+            result.data = {c.data[7], c.data[8], c.data[9], c.data[12], c.data[13], c.data[14], c.data[17], c.data[18], c.data[19]};
+            break;
+        case 6:
+            result.x = c.x + 1;
+            result.y = c.y -1;
+            result.data = {c.data[10], c.data[11], c.data[12], c.data[15], c.data[16], c.data[17], c.data[20], c.data[21], c.data[22]};
+            break;
+        case 7:
+            result.x = c.x + 1;
+            result.y = c.y-1;
+            result.data = {c.data[11], c.data[12], c.data[13], c.data[16], c.data[17], c.data[18], c.data[21], c.data[22], c.data[23]};
+            break;
+        case 8:
+            result.x = c.x + 1;
+            result.y = c.y-1;
+            result.data = {c.data[12], c.data[13], c.data[14], c.data[17], c.data[18], c.data[19], c.data[22], c.data[23], c.data[24]};
+            break;
+    }
+
+    // do some stuff
+    return result;
+}
+
 // Type Traits for is_cluster_type
 template <typename T>
 struct is_cluster : std::false_type {}; // Default case: Not a Cluster

include/aare/ClusterFile.hpp

@@ -14,7 +14,7 @@
 namespace aare {
 
 /*
-Binary cluster file. Expects data to be layed out as:
+Binary cluster file. Expects data to be laid out as:
 int32_t frame_number
 uint32_t number_of_clusters
 int16_t x, int16_t y, int32_t data[9] x number_of_clusters

include/aare/ClusterVector.hpp

@@ -32,7 +32,8 @@ class ClusterVector; // Forward declaration
  */
 template <typename T, uint8_t ClusterSizeX, uint8_t ClusterSizeY,
           typename CoordType>
-class ClusterVector<Cluster<T, ClusterSizeX, ClusterSizeY, CoordType>> {
+class ClusterVector<Cluster<T, ClusterSizeX, ClusterSizeY, CoordType>> 
+{
 
     std::vector<Cluster<T, ClusterSizeX, ClusterSizeY, CoordType>> m_data{};
     int32_t m_frame_number{0}; // TODO! Check frame number size and type
@@ -122,6 +123,11 @@ class ClusterVector<Cluster<T, ClusterSizeX, ClusterSizeY, CoordType>> {
      */
     size_t size() const { return m_data.size(); }
 
+    /**
+     * @brief Check if the vector is empty
+     */
+    bool empty() const { return m_data.empty(); }
+
     uint8_t cluster_size_x() const { return ClusterSizeX; }
 
     uint8_t cluster_size_y() const { return ClusterSizeY; }
@@ -167,4 +173,22 @@ class ClusterVector<Cluster<T, ClusterSizeX, ClusterSizeY, CoordType>> {
     }
 };
 
+template<typename T>
+ClusterVector<Cluster<T, 2, 2, uint16_t>> reduce_3x3_to_2x2(const ClusterVector<Cluster<T, 3, 3, uint16_t>> &cv) {
+    ClusterVector<Cluster<T, 2, 2, uint16_t>> result;
+    for (const auto &c : cv) {
+        result.push_back(reduce_3x3_to_2x2(c));
+    }
+    return result;
+}
+
+template<typename T>
+ClusterVector<Cluster<T, 3, 3, uint16_t>> reduce_5x5_to_3x3(const ClusterVector<Cluster<T, 5, 5, uint16_t>> &cv) {
+    ClusterVector<Cluster<T, 3, 3, uint16_t>> result;
+    for (const auto &c : cv) {
+        result.push_back(reduce_5x5_to_3x3(c));
+    }
+    return result;
+}
+
 } // namespace aare

include/aare/NDArray.hpp

@@ -33,7 +33,7 @@ class NDArray : public ArrayExpr<NDArray<T, Ndim>, Ndim> {
      * @brief Default constructor. Will construct an empty NDArray.
      *
      */
-    NDArray() : shape_(), strides_(c_strides<Ndim>(shape_)), data_(nullptr) {};
+    NDArray() : shape_(), strides_(c_strides<Ndim>(shape_)), data_(nullptr){};
 
     /**
      * @brief Construct a new NDArray object with a given shape.
@@ -380,7 +380,6 @@ NDArray<T, Ndim> NDArray<T, Ndim>::operator*(const T &value) {
     result *= value;
     return result;
 }
-
 // template <typename T, ssize_t Ndim> void NDArray<T, Ndim>::Print() {
 //     if (shape_[0] < 20 && shape_[1] < 20)
 //         Print_all();
@@ -423,7 +422,7 @@ template <typename T, ssize_t Ndim>
 void save(NDArray<T, Ndim> &img, std::string &pathname) {
     std::ofstream f;
     f.open(pathname, std::ios::binary);
-    f.write(reinterpret_cast<char *>(img.buffer()), img.size() * sizeof(T));
+    f.write(img.buffer(), img.size() * sizeof(T));
     f.close();
 }
 
@@ -433,39 +432,9 @@ NDArray<T, Ndim> load(const std::string &pathname,
     NDArray<T, Ndim> img{shape};
     std::ifstream f;
     f.open(pathname, std::ios::binary);
-    f.read(reinterpret_cast<char *>(img.buffer()), img.size() * sizeof(T));
+    f.read(img.buffer(), img.size() * sizeof(T));
     f.close();
     return img;
 }
 
-template <typename T, ssize_t Ndim = 1>
-NDArray<T, Ndim> load_non_binary_file(const std::string &filename,
-                                      const std::array<ssize_t, Ndim> shape) {
-    std::string word;
-    NDArray<T, Ndim> array(shape);
-
-    try {
-        std::ifstream file(filename, std::ios_base::in);
-        if (!file.good()) {
-            throw std::logic_error("file does not exist");
-        }
-
-        std::stringstream file_buffer;
-        file_buffer << file.rdbuf();
-
-        ssize_t counter = 0;
-        while (file_buffer >> word && counter < array.size()) {
-            array[counter] = static_cast<T>(
-                std::stod(word)); // TODO change for different Types
-            ++counter;
-        }
-
-        file.close();
-    } catch (const std::exception &e) {
-        std::cerr << "Error: " << e.what() << std::endl;
-    }
-
-    return array;
-}
-
 } // namespace aare

include/aare/NDView.hpp

@@ -6,7 +6,6 @@
 #include <array>
 #include <cassert>
 #include <cstdint>
-#include <fstream>
 #include <functional>
 #include <iomanip>
 #include <iostream>
@@ -68,20 +67,13 @@ class NDView : public ArrayExpr<NDView<T, Ndim>, Ndim> {
           size_(std::accumulate(std::begin(shape), std::end(shape), 1,
                                 std::multiplies<>())) {}
 
-    // NDView(T *buffer, const std::vector<ssize_t> &shape)
-    //     : buffer_(buffer),
-    //     strides_(c_strides<Ndim>(make_array<Ndim>(shape))),
-    //     shape_(make_array<Ndim>(shape)),
-    //       size_(std::accumulate(std::begin(shape), std::end(shape), 1,
-    //       std::multiplies<>())) {}
-
     template <typename... Ix>
     std::enable_if_t<sizeof...(Ix) == Ndim, T &> operator()(Ix... index) {
         return buffer_[element_offset(strides_, index...)];
     }
 
     template <typename... Ix>
-    std::enable_if_t<sizeof...(Ix) == Ndim, T &> operator()(Ix... index) const {
+    const std::enable_if_t<sizeof...(Ix) == Ndim, T &> operator()(Ix... index) const {
         return buffer_[element_offset(strides_, index...)];
     }
 
@@ -93,33 +85,23 @@ class NDView : public ArrayExpr<NDView<T, Ndim>, Ndim> {
     T *end() { return buffer_ + size_; }
     T const *begin() const { return buffer_; }
     T const *end() const { return buffer_ + size_; }
-    T &operator()(ssize_t i) const { return buffer_[i]; }
-    T &operator[](ssize_t i) const { return buffer_[i]; }
+    T &operator()(ssize_t i)  { return buffer_[i]; }
+    T &operator[](ssize_t i)  { return buffer_[i]; }
+    const T &operator()(ssize_t i) const { return buffer_[i]; }
+    const T &operator[](ssize_t i) const { return buffer_[i]; }
 
     bool operator==(const NDView &other) const {
         if (size_ != other.size_)
             return false;
-        for (uint64_t i = 0; i != size_; ++i) {
+        if (shape_ != other.shape_)
+            return false;
+        for (size_t i = 0; i != size_; ++i) {
             if (buffer_[i] != other.buffer_[i])
                 return false;
         }
         return true;
     }
 
-    bool equals(const NDView<T, Ndim> &other, const T tolerance) const {
-        if (shape_ != other.shape_)
-            return false;
-
-        using SignedT = typename make_signed<T>::type;
-
-        for (uint32_t i = 0; i != size_; ++i)
-            if (std::abs(static_cast<SignedT>(buffer_[i]) -
-                         static_cast<SignedT>(other.buffer_[i])) > tolerance)
-                return false;
-
-        return true;
-    }
-
     NDView &operator+=(const T val) { return elemenwise(val, std::plus<T>()); }
     NDView &operator-=(const T val) { return elemenwise(val, std::minus<T>()); }
     NDView &operator*=(const T val) {
@@ -172,6 +154,7 @@ class NDView : public ArrayExpr<NDView<T, Ndim>, Ndim> {
     auto shape(ssize_t i) const { return shape_[i]; }
 
     T *data() { return buffer_; }
+    const T *data() const { return buffer_; }
     void print_all() const;
 
   private:
@@ -195,6 +178,7 @@ class NDView : public ArrayExpr<NDView<T, Ndim>, Ndim> {
         return *this;
     }
 };
+
 template <typename T, ssize_t Ndim> void NDView<T, Ndim>::print_all() const {
     for (auto row = 0; row < shape_[0]; ++row) {
         for (auto col = 0; col < shape_[1]; ++col) {
@@ -221,12 +205,4 @@ template <typename T> NDView<T, 1> make_view(std::vector<T> &vec) {
     return NDView<T, 1>(vec.data(), {static_cast<ssize_t>(vec.size())});
 }
 
-template <typename T, ssize_t Ndim>
-void save(NDView<T, Ndim> img, const std::string &pathname) {
-    std::ofstream f;
-    f.open(pathname, std::ios::binary);
-    f.write(reinterpret_cast<char *>(img.data()), img.size() * sizeof(T));
-    f.close();
-}
-
 } // namespace aare

include/aare/defs.hpp

@@ -9,7 +9,6 @@
 #include <stdexcept>
 #include <string>
 #include <string_view>
-#include <type_traits>
 #include <variant>
 #include <vector>
 
@@ -232,12 +231,4 @@ template <> FrameDiscardPolicy StringTo(const std::string & /*mode*/);
 
 using DataTypeVariants = std::variant<uint16_t, uint32_t>;
 
-template <typename T, bool = std::is_integral_v<T>> struct make_signed {
-    using type = T;
-};
-
-template <typename T> struct make_signed<T, true> {
-    using type = std::make_signed_t<T>;
-};
-
 } // namespace aare

python/src/bind_ClusterVector.hpp

@@ -104,4 +104,14 @@ void define_ClusterVector(py::module &m, const std::string &typestr) {
           });
 }
 
+void define_reduction(py::module &m) {
+    m.def("reduce_3x3_to_2x2", [](const ClusterVector<Cluster<int, 3, 3, uint16_t>> &cv) {
+        return new ClusterVector<Cluster<int, 2, 2, uint16_t>>(reduce_3x3_to_2x2(cv));
+        // return new ClusterVector<Cluster<int, 3, 3>>();
+    })
+    .def("reduce_5x5_to_3x3", [](const ClusterVector<Cluster<int, 5, 5, uint16_t>> &cv) {
+        return new ClusterVector<Cluster<int, 3, 3, uint16_t>>(reduce_5x5_to_3x3(cv));
+    });
+}
+
 #pragma GCC diagnostic pop

python/src/module.cpp

@@ -81,4 +81,8 @@ PYBIND11_MODULE(_aare, m) {
     DEFINE_CLUSTER_BINDINGS(int, 9, 9, uint16_t, i);
     DEFINE_CLUSTER_BINDINGS(double, 9, 9, uint16_t, d);
     DEFINE_CLUSTER_BINDINGS(float, 9, 9, uint16_t, f);
+
+
+    define_reduction(m);
+
 }

src/ClusterVector.test.cpp

@@ -7,9 +7,21 @@
 
 using aare::Cluster;
 using aare::ClusterVector;
+using C1 = Cluster<int32_t, 2, 2>;
+
+
+TEST_CASE("A newly created ClusterVector is empty") {
+    ClusterVector<C1> cv(4);
+    REQUIRE(cv.empty());
+}
+
+TEST_CASE("After pushing back one element the ClusterVector is not empty") {
+    ClusterVector<C1> cv(4);
+    cv.push_back(C1{1, 2, {3, 4}});
+    REQUIRE(!cv.empty());
+}
 
 TEST_CASE("item_size return the size of the cluster stored") {
-    using C1 = Cluster<int32_t, 2, 2>;
     ClusterVector<C1> cv(4);
     CHECK(cv.item_size() == sizeof(C1));
 
@@ -43,8 +55,7 @@ TEST_CASE("item_size return the size of the cluster stored") {
     CHECK(cv7.item_size() == sizeof(C7));
 }
 
-TEST_CASE("ClusterVector 2x2 int32_t capacity 4, push back then read",
-          "[.ClusterVector]") {
+TEST_CASE("ClusterVector 2x2 int32_t capacity 4, push back then read") {
 
     ClusterVector<Cluster<int32_t, 2, 2>> cv(4);
     REQUIRE(cv.capacity() == 4);
@@ -70,7 +81,7 @@ TEST_CASE("ClusterVector 2x2 int32_t capacity 4, push back then read",
     }
 }
 
-TEST_CASE("Summing 3x1 clusters of int64", "[.ClusterVector]") {
+TEST_CASE("Summing 3x1 clusters of int64") {
     ClusterVector<Cluster<int32_t, 3, 1>> cv(2);
     REQUIRE(cv.capacity() == 2);
     REQUIRE(cv.size() == 0);
@@ -102,7 +113,7 @@ TEST_CASE("Summing 3x1 clusters of int64", "[.ClusterVector]") {
     */
 }
 
-TEST_CASE("Storing floats", "[.ClusterVector]") {
+TEST_CASE("Storing floats") {
     ClusterVector<Cluster<float, 2, 4>> cv(10);
     REQUIRE(cv.capacity() == 10);
     REQUIRE(cv.size() == 0);
@@ -129,7 +140,7 @@ TEST_CASE("Storing floats", "[.ClusterVector]") {
     */
 }
 
-TEST_CASE("Push back more than initial capacity", "[.ClusterVector]") {
+TEST_CASE("Push back more than initial capacity") {
 
     ClusterVector<Cluster<int32_t, 2, 2>> cv(2);
     auto initial_data = cv.data();
@@ -162,8 +173,7 @@ TEST_CASE("Push back more than initial capacity", "[.ClusterVector]") {
     REQUIRE(initial_data != cv.data());
 }
 
-TEST_CASE("Concatenate two cluster vectors where the first has enough capacity",
-          "[.ClusterVector]") {
+TEST_CASE("Concatenate two cluster vectors where the first has enough capacity") {
     ClusterVector<Cluster<int32_t, 2, 2>> cv1(12);
     Cluster<int32_t, 2, 2> c1 = {1, 2, {3, 4, 5, 6}};
     cv1.push_back(c1);
@@ -192,8 +202,7 @@ TEST_CASE("Concatenate two cluster vectors where the first has enough capacity",
     REQUIRE(ptr[3].y == 17);
 }
 
-TEST_CASE("Concatenate two cluster vectors where we need to allocate",
-          "[.ClusterVector]") {
+TEST_CASE("Concatenate two cluster vectors where we need to allocate") {
     ClusterVector<Cluster<int32_t, 2, 2>> cv1(2);
     Cluster<int32_t, 2, 2> c1 = {1, 2, {3, 4, 5, 6}};
     cv1.push_back(c1);
@@ -229,7 +238,7 @@ struct ClusterTestData {
     std::vector<int64_t> index_map_y;
 };
 
-TEST_CASE("Gain Map Calculation Index Map", "[.ClusterVector][.gain_map]") {
+TEST_CASE("Gain Map Calculation Index Map") {
 
     auto clustertestdata = GENERATE(
         ClusterTestData{3,

src/NDView.test.cpp

@@ -21,6 +21,57 @@ TEST_CASE("Element reference 1D") {
     }
 }
 
+
+TEST_CASE("Assign elements through () and []") {
+    std::vector<int> vec;
+    for (int i = 0; i != 10; ++i) {
+        vec.push_back(i);
+    }
+    NDView<int, 1> data(vec.data(), Shape<1>{10});
+    REQUIRE(vec.size() == static_cast<size_t>(data.size()));
+    
+    data[3] = 187;
+    data(4) = 512;
+
+
+    REQUIRE(data(0) == 0);
+    REQUIRE(data[0] == 0);
+    REQUIRE(data(1) == 1);
+    REQUIRE(data[1] == 1);
+    REQUIRE(data(2) == 2);
+    REQUIRE(data[2] == 2);
+    REQUIRE(data(3) == 187);
+    REQUIRE(data[3] == 187);
+    REQUIRE(data(4) == 512);
+    REQUIRE(data[4] == 512);
+    REQUIRE(data(5) == 5);
+    REQUIRE(data[5] == 5);
+    REQUIRE(data(6) == 6);
+    REQUIRE(data[6] == 6);
+    REQUIRE(data(7) == 7);
+    REQUIRE(data[7] == 7);
+    REQUIRE(data(8) == 8);
+    REQUIRE(data[8] == 8);
+    REQUIRE(data(9) == 9);
+    REQUIRE(data[9] == 9);
+
+
+}
+
+TEST_CASE("Element reference 1D with a const NDView") {
+    std::vector<int> vec;
+    for (int i = 0; i != 10; ++i) {
+        vec.push_back(i);
+    }
+    const NDView<int, 1> data(vec.data(), Shape<1>{10});
+    REQUIRE(vec.size() == static_cast<size_t>(data.size()));
+    for (int i = 0; i != 10; ++i) {
+        REQUIRE(data(i) == vec[i]);
+        REQUIRE(data[i] == vec[i]);
+    }
+}
+
+
 TEST_CASE("Element reference 2D") {
     std::vector<int> vec(12);
     std::iota(vec.begin(), vec.end(), 0);
@@ -56,7 +107,7 @@ TEST_CASE("Element reference 3D") {
     }
 }
 
-TEST_CASE("Plus and miuns with single value") {
+TEST_CASE("Plus and minus with single value") {
     std::vector<int> vec(12);
     std::iota(vec.begin(), vec.end(), 0);
     NDView<int, 2> data(vec.data(), Shape<2>{3, 4});
@@ -137,16 +188,9 @@ TEST_CASE("iterators") {
     }
 }
 
-// TEST_CASE("shape from vector") {
-//     std::vector<int> vec;
-//     for (int i = 0; i != 12; ++i) {
-//         vec.push_back(i);
-//     }
-//     std::vector<ssize_t> shape{3, 4};
-//     NDView<int, 2> data(vec.data(), shape);
-// }
 
-TEST_CASE("divide with another span") {
+
+TEST_CASE("divide with another NDView") {
     std::vector<int> vec0{9, 12, 3};
     std::vector<int> vec1{3, 2, 1};
     std::vector<int> result{3, 6, 3};
@@ -183,6 +227,30 @@ TEST_CASE("compare two views") {
     REQUIRE((view1 == view2));
 }
 
+TEST_CASE("Compare two views with different size"){
+    std::vector<int> vec1(12);
+    std::iota(vec1.begin(), vec1.end(), 0);
+    NDView<int, 2> view1(vec1.data(), Shape<2>{3, 4});
+
+    std::vector<int> vec2(8);
+    std::iota(vec2.begin(), vec2.end(), 0);
+    NDView<int, 2> view2(vec2.data(), Shape<2>{2, 4});
+
+    REQUIRE_FALSE(view1 == view2);
+}
+
+TEST_CASE("Compare two views with same size but different shape"){
+    std::vector<int> vec1(12);
+    std::iota(vec1.begin(), vec1.end(), 0);
+    NDView<int, 2> view1(vec1.data(), Shape<2>{3, 4});
+
+    std::vector<int> vec2(12);
+    std::iota(vec2.begin(), vec2.end(), 0);
+    NDView<int, 2> view2(vec2.data(), Shape<2>{2, 6});
+
+    REQUIRE_FALSE(view1 == view2);
+}
+
 TEST_CASE("Create a view over a vector") {
     std::vector<int> vec(12);
     std::iota(vec.begin(), vec.end(), 0);