move view() inside frame

.vscode/settings.json

@@ -96,7 +96,8 @@
         "source_location": "cpp",
         "future": "cpp",
         "typeindex": "cpp",
-        "*.in": "c"
+        "*.in": "c",
+        "stdfloat": "cpp"
     },
     "C_Cpp.errorSquiggles": "enabled"
 }

core/include/aare/Frame.hpp

@@ -1,8 +1,10 @@
 #pragma once
+#include "aare/View.hpp"
 #include "aare/defs.hpp"
-#include <memory>
 #include <cstddef>
 #include <cstdint>
+#include <memory>
+#include <vector>
 #include <sys/types.h>
 #include <vector>
 
@@ -16,36 +18,35 @@ class Frame {
     ssize_t m_rows;
     ssize_t m_cols;
     ssize_t m_bitdepth;
-    std::byte* m_data;
-
+    std::byte *m_data;
 
   public:
-    Frame(ssize_t rows, ssize_t cols,ssize_t m_bitdepth);
-    Frame(std::byte *fp, ssize_t rows, ssize_t cols,ssize_t m_bitdepth);
-    std::byte* get(int row, int col);
-    template <typename T>
-    void set(int row, int col,T data);
+    Frame(ssize_t rows, ssize_t cols, ssize_t m_bitdepth);
+    Frame(std::byte *fp, ssize_t rows, ssize_t cols, ssize_t m_bitdepth);
+    std::byte *get(int row, int col);
+    template <typename T> void set(int row, int col, T data);
     // std::vector<std::vector<DataType>> get_array();
-    ssize_t rows() const{
-        return m_rows;
-    }
-    ssize_t cols() const{
-        return m_cols;
-    }
-    ssize_t bitdepth() const{
-        return m_bitdepth;
-    }
-    std::byte* _get_data(){
-        return m_data;
-    }
-    Frame& operator=(Frame& other){
-            m_rows = other.rows();
-            m_cols = other.cols();
-            m_bitdepth = other.bitdepth();
-            m_data = new std::byte[m_rows*m_cols*m_bitdepth/8];
-            std::memcpy(m_data, other.m_data, m_rows*m_cols*m_bitdepth/8);
+    ssize_t rows() const { return m_rows; }
+    ssize_t cols() const { return m_cols; }
+    ssize_t bitdepth() const { return m_bitdepth; }
+    std::byte *_get_data() { return m_data; }
+    Frame &operator=(Frame &other) {
+        m_rows = other.rows();
+        m_cols = other.cols();
+        m_bitdepth = other.bitdepth();
+        m_data = new std::byte[m_rows * m_cols * m_bitdepth / 8];
+        std::memcpy(m_data, other.m_data, m_rows * m_cols * m_bitdepth / 8);
         return *this;
     }
 
+    template <typename T> 
+    View<T> view() {
+        std::vector<ssize_t> shape = {m_rows, m_cols};
+        T* data = reinterpret_cast<T *>(m_data);
+        return View<T>(data, shape);
+    }
+
     ~Frame() { delete[] m_data; }
 };
+
+

core/include/aare/VariableSizeClusterFinder.hpp

@@ -30,12 +30,12 @@ template <typename T> class ClusterFinder {
 
   private:
     const std::array<ssize_t, 2> shape_;
-    DataSpan<T, 2> original_;
+    View<T, 2> original_;
     ImageData<int, 2> labeled_;
     ImageData<int, 2> peripheral_labeled_;
     ImageData<bool, 2> binary_; // over threshold flag
     T threshold_;
-    DataSpan<T, 2> noiseMap;
+    View<T, 2> noiseMap;
     bool use_noise_map = false;
     int peripheralThresholdFactor_ = 5;
     int current_label;
@@ -58,12 +58,12 @@ template <typename T> class ClusterFinder {
 
     ImageData<int, 2> labeled() { return labeled_; }
 
-    void set_noiseMap(DataSpan<T, 2> noise_map) { noiseMap = noise_map; use_noise_map = true; }
+    void set_noiseMap(View<T, 2> noise_map) { noiseMap = noise_map; use_noise_map = true; }
     void set_peripheralThresholdFactor(int factor) { peripheralThresholdFactor_ = factor; }
-    void find_clusters(DataSpan<T, 2> img);
-    void find_clusters_X(DataSpan<T, 2> img);
+    void find_clusters(View<T, 2> img);
+    void find_clusters_X(View<T, 2> img);
     void rec_FillHit(int clusterIndex, int i, int j);
-    void single_pass(DataSpan<T, 2> img);
+    void single_pass(View<T, 2> img);
     void first_pass();
     void second_pass();
     void store_clusters();
@@ -144,7 +144,7 @@ template <typename T> int ClusterFinder<T>::check_neighbours(int i, int j) {
     }
 }
 
-template <typename T> void ClusterFinder<T>::find_clusters(DataSpan<T, 2> img) {
+template <typename T> void ClusterFinder<T>::find_clusters(View<T, 2> img) {
     original_ = img;
     labeled_ = 0;
     peripheral_labeled_ = 0;
@@ -156,7 +156,7 @@ template <typename T> void ClusterFinder<T>::find_clusters(DataSpan<T, 2> img) {
     store_clusters();
 }
 
-template <typename T> void ClusterFinder<T>::find_clusters_X(DataSpan<T, 2> img) {
+template <typename T> void ClusterFinder<T>::find_clusters_X(View<T, 2> img) {
     original_ = img;
     int clusterIndex = 0;
     for (int i = 0; i < shape_[0]; ++i) {
@@ -214,7 +214,7 @@ template <typename T> void ClusterFinder<T>::rec_FillHit(int clusterIndex, int i
     }
 }
 
-template <typename T> void ClusterFinder<T>::single_pass(DataSpan<T, 2> img) {
+template <typename T> void ClusterFinder<T>::single_pass(View<T, 2> img) {
     original_ = img;
     labeled_ = 0;
     current_label = 0;

core/include/aare/View.hpp

@@ -4,7 +4,6 @@
 #include <cassert>
 #include <cstdint>
 #include <numeric>
-#include<aare/Frame.hpp>
 #include <vector>
 
 
@@ -31,18 +30,18 @@ template <ssize_t Ndim> std::array<ssize_t, Ndim> make_array(const std::vector<s
     return arr;
 }
 
-template <typename T, ssize_t Ndim> class DataSpan {
+template <typename T, ssize_t Ndim=2> class View {
   public:
-    DataSpan(){};
+    View(){};
 
-    DataSpan(T* buffer, std::array<ssize_t, Ndim> shape) {
+    View(T* buffer, std::array<ssize_t, Ndim> shape) {
         buffer_ = buffer;
         strides_ = c_strides<Ndim>(shape);
         shape_ = shape;
         size_ = std::accumulate(std::begin(shape), std::end(shape), 1, std::multiplies<ssize_t>());
     }
 
-    DataSpan(T *buffer, const std::vector<ssize_t> &shape) {
+    View(T *buffer, const std::vector<ssize_t> &shape) {
         buffer_ = buffer;
         strides_ = c_strides<Ndim>(make_array<Ndim>(shape));
         shape_ = make_array<Ndim>(shape);
@@ -50,14 +49,6 @@ template <typename T, ssize_t Ndim> class DataSpan {
         
     }
 
-    DataSpan(Frame& frame) {
-        assert(Ndim == 2);
-        buffer_ = reinterpret_cast<T*>(frame._get_data());
-        strides_ = c_strides<Ndim>({frame.rows(), frame.cols()});
-        shape_ = {frame.rows(), frame.cols()};
-        size_ = frame.rows() * frame.cols();
-    }
-
     template <typename... Ix> typename std::enable_if<sizeof...(Ix) == Ndim, T &>::type operator()(Ix... index) {
         return buffer_[element_offset(strides_, index...)];
     }
@@ -68,28 +59,28 @@ template <typename T, ssize_t Ndim> class DataSpan {
 
     ssize_t size() const { return size_; }
 
-    DataSpan(const DataSpan &) = default;
-    DataSpan(DataSpan &&) = default;
+    View(const View &) = default;
+    View(View &&) = default;
 
     T *begin() { return buffer_; }
     T *end() { return buffer_ + size_; }
     T &operator()(ssize_t i) { return buffer_[i]; }
     T &operator[](ssize_t i) { return buffer_[i]; }
 
-    DataSpan &operator+=(const T val) { return elemenwise(val, std::plus<T>()); }
-    DataSpan &operator-=(const T val) { return elemenwise(val, std::minus<T>()); }
-    DataSpan &operator*=(const T val) { return elemenwise(val, std::multiplies<T>()); }
-    DataSpan &operator/=(const T val) { return elemenwise(val, std::divides<T>()); }
+    View &operator+=(const T val) { return elemenwise(val, std::plus<T>()); }
+    View &operator-=(const T val) { return elemenwise(val, std::minus<T>()); }
+    View &operator*=(const T val) { return elemenwise(val, std::multiplies<T>()); }
+    View &operator/=(const T val) { return elemenwise(val, std::divides<T>()); }
 
-    DataSpan &operator/=(const DataSpan &other) { return elemenwise(other, std::divides<T>()); }
+    View &operator/=(const View &other) { return elemenwise(other, std::divides<T>()); }
 
-    DataSpan &operator=(const T val) {
+    View &operator=(const T val) {
         for (auto it = begin(); it != end(); ++it)
             *it = val;
         return *this;
     }
 
-    DataSpan &operator=(const DataSpan &other) {
+    View &operator=(const View &other) {
         shape_ = other.shape_;
         strides_ = other.strides_;
         size_ = other.size_;
@@ -107,13 +98,13 @@ template <typename T, ssize_t Ndim> class DataSpan {
     std::array<ssize_t, Ndim> shape_{};
     ssize_t size_{};
 
-    template <class BinaryOperation> DataSpan &elemenwise(T val, BinaryOperation op) {
+    template <class BinaryOperation> View &elemenwise(T val, BinaryOperation op) {
         for (ssize_t i = 0; i != size_; ++i) {
             buffer_[i] = op(buffer_[i], val);
         }
         return *this;
     }
-    template <class BinaryOperation> DataSpan &elemenwise(const DataSpan &other, BinaryOperation op) {
+    template <class BinaryOperation> View &elemenwise(const View &other, BinaryOperation op) {
         for (ssize_t i = 0; i != size_; ++i) {
             buffer_[i] = op(buffer_[i], other.buffer_[i]);
         }
@@ -121,5 +112,5 @@ template <typename T, ssize_t Ndim> class DataSpan {
     }
 };
 
-template class DataSpan<uint16_t, 2>;
+template class View<uint16_t, 2>;
 

core/test/wrappers.test.cpp

@@ -1,4 +1,4 @@
-#include <aare/DataSpan.hpp>
+#include <aare/View.hpp>
 #include <aare/Frame.hpp>
 #include <catch2/catch_test_macros.hpp>
 #include <cstdint>
@@ -22,20 +22,20 @@ TEST_CASE("Frame") {
     delete[] data;
 }
 
-TEST_CASE("DataSpan") {
+TEST_CASE("View") {
     auto data = new uint16_t[100];
     for (int i = 0; i < 100; i++) {
         data[i] = i;
     }
     SECTION("constructors") {
-        DataSpan<uint16_t, 2> ds(data, std::vector<ssize_t>({10, 10}));
+        View<uint16_t, 2> ds(data, std::vector<ssize_t>({10, 10}));
         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);
-        DataSpan<uint16_t, 2> ds(f);
+        View<uint16_t> ds = f.view<uint16_t>();
         for (int i = 0; i < 100; i++) {
             REQUIRE(ds(i / 10, i % 10) == data[i]);
         }