added variable cluster finder

include/aare/VarClusterFinder.hpp

@@ -49,7 +49,7 @@ template <typename T> class VarClusterFinder {
     int check_neighbours(int i, int j);
 
   public:
-    VarClusterFinder(image_shape shape, T threshold)
+    VarClusterFinder(Shape<2> shape, T threshold)
         : shape_(shape), labeled_(shape, 0), peripheral_labeled_(shape, 0), binary_(shape), threshold_(threshold) {
         hits.reserve(2000);
     }

python/aare/__init__.py

@@ -1,2 +1,3 @@
 # Make the compiled classes that live in _aare available from aare.
-from ._aare import File
+from ._aare import File
+from ._aare import VarClusterFinder

python/src/module.cpp

@@ -1,5 +1,6 @@
 
 #include "file.hpp"
+#include "var_cluster.hpp"
 
 #include <pybind11/pybind11.h>
 #include <pybind11/stl.h>
@@ -11,4 +12,5 @@ PYBIND11_MODULE(_aare, m) {
 
 
     define_file_io_bindings(m);
+    define_var_cluster_finder_bindings(m);
 }

python/src/np_helper.hpp

@@ -7,36 +7,37 @@
 
 #include "aare/Frame.hpp"
 #include "aare/NDArray.hpp"
+#include "aare/NDView.hpp"
 
 namespace py = pybind11;
 
 // Pass image data back to python as a numpy array
-// template <typename T, ssize_t Ndim>
-// py::array return_image_data(pl::ImageData<T, Ndim> *image) {
+template <typename T, int64_t Ndim>
+py::array return_image_data(aare::NDArray<T, Ndim> *image) {
 
-//     py::capsule free_when_done(image, [](void *f) {
-//         pl::ImageData<T, Ndim> *foo =
-//             reinterpret_cast<pl::ImageData<T, Ndim> *>(f);
-//         delete foo;
-//     });
+    py::capsule free_when_done(image, [](void *f) {
+        aare::NDArray<T, Ndim> *foo =
+            reinterpret_cast<aare::NDArray<T, Ndim> *>(f);
+        delete foo;
+    });
 
-//     return py::array_t<T>(
-//         image->shape(),        // shape
-//         image->byte_strides(), // C-style contiguous strides for double
-//         image->data(),         // the data pointer
-//         free_when_done);       // numpy array references this parent
-// }
+    return py::array_t<T>(
+        image->shape(),        // shape
+        image->byte_strides(), // C-style contiguous strides for double
+        image->data(),         // the data pointer
+        free_when_done);       // numpy array references this parent
+}
 
-// template <typename T> py::array return_vector(std::vector<T> *vec) {
-//     py::capsule free_when_done(vec, [](void *f) {
-//         std::vector<T> *foo = reinterpret_cast<std::vector<T> *>(f);
-//         delete foo;
-//     });
-//     return py::array_t<T>({vec->size()}, // shape
-//                           {sizeof(T)}, // C-style contiguous strides for double
-//                           vec->data(), // the data pointer
-//                           free_when_done); // numpy array references this parent
-// }
+template <typename T> py::array return_vector(std::vector<T> *vec) {
+    py::capsule free_when_done(vec, [](void *f) {
+        std::vector<T> *foo = reinterpret_cast<std::vector<T> *>(f);
+        delete foo;
+    });
+    return py::array_t<T>({vec->size()}, // shape
+                          {sizeof(T)}, // C-style contiguous strides for double
+                          vec->data(), // the data pointer
+                          free_when_done); // numpy array references this parent
+}
 
 // template <typename Reader> py::array do_read(Reader &r, size_t n_frames) {
 //     py::array image;
@@ -62,54 +63,54 @@ namespace py = pybind11;
 //     return image;
 // }
 
-py::array return_frame(pl::Frame *ptr) {
-    py::capsule free_when_done(ptr, [](void *f) {
-        pl::Frame *foo = reinterpret_cast<pl::Frame *>(f);
-        delete foo;
-    });
+// py::array return_frame(pl::Frame *ptr) {
+//     py::capsule free_when_done(ptr, [](void *f) {
+//         pl::Frame *foo = reinterpret_cast<pl::Frame *>(f);
+//         delete foo;
+//     });
 
-    const uint8_t item_size = ptr->bytes_per_pixel();
-    std::vector<ssize_t> shape;
-    for (auto val : ptr->shape())
-        if (val > 1)
-            shape.push_back(val);
-
-    std::vector<ssize_t> strides;
-    if (shape.size() == 1)
-        strides.push_back(item_size);
-    else if (shape.size() == 2) {
-        strides.push_back(item_size * shape[1]);
-        strides.push_back(item_size);
-    }
-
-    if (item_size == 1)
-        return py::array_t<uint8_t>(
-            shape, strides,
-            reinterpret_cast<uint8_t *>(ptr->data()), free_when_done);
-    else if (item_size == 2)
-        return py::array_t<uint16_t>(shape, strides,
-                                     reinterpret_cast<uint16_t *>(ptr->data()),
-                                     free_when_done);
-    else if (item_size == 4)
-        return py::array_t<uint32_t>(shape, strides,
-                                     reinterpret_cast<uint32_t *>(ptr->data()),
-                                     free_when_done);
-    return {};
-}
+//     const uint8_t item_size = ptr->bytes_per_pixel();
+//     std::vector<ssize_t> shape;
+//     for (auto val : ptr->shape())
+//         if (val > 1)
+//             shape.push_back(val);
+
+//     std::vector<ssize_t> strides;
+//     if (shape.size() == 1)
+//         strides.push_back(item_size);
+//     else if (shape.size() == 2) {
+//         strides.push_back(item_size * shape[1]);
+//         strides.push_back(item_size);
+//     }
+
+//     if (item_size == 1)
+//         return py::array_t<uint8_t>(
+//             shape, strides,
+//             reinterpret_cast<uint8_t *>(ptr->data()), free_when_done);
+//     else if (item_size == 2)
+//         return py::array_t<uint16_t>(shape, strides,
+//                                      reinterpret_cast<uint16_t *>(ptr->data()),
+//                                      free_when_done);
+//     else if (item_size == 4)
+//         return py::array_t<uint32_t>(shape, strides,
+//                                      reinterpret_cast<uint32_t *>(ptr->data()),
+//                                      free_when_done);
+//     return {};
+// }
 
 // todo rewrite generic
 template <class T, int Flags> auto get_shape_3d(py::array_t<T, Flags> arr) {
-    return pl::Shape<3>{arr.shape(0), arr.shape(1), arr.shape(2)};
+    return aare::Shape<3>{arr.shape(0), arr.shape(1), arr.shape(2)};
 }
 
-template <class T, int Flags> auto make_span_3d(py::array_t<T, Flags> arr) {
-    return pl::DataSpan<T, 3>(arr.mutable_data(), get_shape_3d<T, Flags>(arr));
+template <class T, int Flags> auto make_view_3d(py::array_t<T, Flags> arr) {
+    return aare::NDView<T, 3>(arr.mutable_data(), get_shape_3d<T, Flags>(arr));
 }
 
 template <class T, int Flags> auto get_shape_2d(py::array_t<T, Flags> arr) {
-    return pl::Shape<2>{arr.shape(0), arr.shape(1)};
+    return aare::Shape<2>{arr.shape(0), arr.shape(1)};
 }
 
-template <class T, int Flags> auto make_span_2d(py::array_t<T, Flags> arr) {
-    return pl::DataSpan<T, 2>(arr.mutable_data(), get_shape_2d<T, Flags>(arr));
+template <class T, int Flags> auto make_view_2d(py::array_t<T, Flags> arr) {
+    return aare::NDView<T, 2>(arr.mutable_data(), get_shape_2d<T, Flags>(arr));
 }

python/src/var_cluster.hpp

@@ -0,0 +1,43 @@
+#include "aare/VarClusterFinder.hpp"
+#include "np_helper.hpp"
+// #include "aare/defs.hpp"
+// #include "aare/fClusterFileV2.hpp"
+
+#include <cstdint>
+// #include <filesystem>
+#include <pybind11/numpy.h>
+// #include <pybind11/iostream.h>
+#include <pybind11/pybind11.h>
+#include <pybind11/stl.h>
+// #include <pybind11/stl/filesystem.h>
+// #include <string>
+
+
+namespace py = pybind11;
+using namespace::aare;
+
+
+void define_var_cluster_finder_bindings(py::module &m) {
+    py::class_<VarClusterFinder<double>>(m, "VarClusterFinder")
+        .def(py::init<Shape<2>, double>())
+        .def("labeled",
+             [](VarClusterFinder<double> &self) {
+                 auto ptr = new NDArray<int, 2>(self.labeled());
+                 return return_image_data(ptr);
+             })
+        .def("find_clusters",
+             [](VarClusterFinder<double> &self,
+                py::array_t<double, py::array::c_style | py::array::forcecast>
+                    img) {
+                 auto view = make_view_2d(img);
+                 self.find_clusters(view);
+             })
+        .def("steal_hits",
+             [](VarClusterFinder<double> &self) {
+                 auto ptr = new std::vector<VarClusterFinder<double>::Hit>(
+                     self.steal_hits());
+                 return return_vector(ptr);
+             })
+        .def("total_clusters", &VarClusterFinder<double>::total_clusters);
+
+}