ClusterFinder

python/aare/__init__.py

@@ -2,4 +2,5 @@
 from . import _aare
 
 from ._aare import VarClusterFinder, File, RawMasterFile
+from ._aare import Pedestal, ClusterFinder
 from .CtbRawFile import CtbRawFile

python/examples/play.py

@@ -27,5 +27,18 @@ fpath = Path('/Users/erik/data/Moench03old/test_034_irradiated_noise_g4_hg_expti
 #     for header, image in f:
 #         print(f'Frame number: {header["frameNumber"]}')
 
-m = aare.RawMasterFile(fpath)
-f = aare.File(fpath)
+# m = aare.RawMasterFile(fpath)
+f = aare.File(fpath)
+
+
+
+cf = aare.ClusterFinder((400,400),(3,3))
+
+for i in range(100):
+    cf.push_pedestal_frame(f.read_frame())
+
+
+f.seek(0)
+pd = f.read_n(100).mean(axis=0)
+
+clusters = cf.find_clusters_without_threshold(f.read_frame())

python/src/cluster.hpp

@@ -0,0 +1,52 @@
+#include "aare/ClusterFinder.hpp"
+#include "aare/NDView.hpp"
+#include "aare/Pedestal.hpp"
+#include "np_helper.hpp"
+
+#include <cstdint>
+#include <filesystem>
+#include <pybind11/pybind11.h>
+#include <pybind11/stl.h>
+
+namespace py = pybind11;
+
+void define_cluster_finder_bindings(py::module &m) {
+    py::class_<ClusterFinder<uint16_t, double>>(m, "ClusterFinder")
+        .def(py::init<Shape<2>, Shape<2>>())
+        .def("push_pedestal_frame",
+             [](ClusterFinder<uint16_t, double> &self,
+                py::array_t<uint16_t> frame) {
+                 auto view = make_view_2d(frame);
+                 self.push_pedestal_frame(view);
+             })
+        .def("pedestal",
+             [](ClusterFinder<uint16_t, double> &self) {
+                 auto m = new NDArray<double, 2>{};
+                 *m = self.pedestal();
+                 return return_image_data(m);
+             })
+        .def("find_clusters_without_threshold",
+             [](ClusterFinder<uint16_t, double> &self,
+                py::array_t<uint16_t> frame) {
+                 auto view = make_view_2d(frame);
+                 auto clusters = self.find_clusters_without_threshold(view);
+                 return clusters;
+             });
+
+    py::class_<Cluster>(m, "Cluster", py::buffer_protocol())
+        .def(py::init<int, int, Dtype>())
+        .def("size", &Cluster::size)
+        .def("begin", &Cluster::begin)
+        .def("end", &Cluster::end)
+        .def_readwrite("x", &Cluster::x)
+        .def_readwrite("y", &Cluster::y)
+        .def_buffer([](Cluster &c) -> py::buffer_info {
+            return py::buffer_info(c.data(), c.dt.bytes(), c.dt.format_descr(),
+                                   1, {c.size()}, {c.dt.bytes()});
+        })
+
+        .def("__repr__", [](const Cluster &a) {
+            return "<Cluster: x: " + std::to_string(a.x) +
+                   ", y: " + std::to_string(a.y) + ">";
+        });
+}

python/src/module.cpp

@@ -2,6 +2,8 @@
 #include "file.hpp"
 #include "var_cluster.hpp"
 #include "pixel_map.hpp"
+#include "pedestal.hpp"
+#include "cluster.hpp"
 
 //Pybind stuff
 #include <pybind11/pybind11.h>
@@ -13,4 +15,7 @@ PYBIND11_MODULE(_aare, m) {
     define_file_io_bindings(m);
     define_var_cluster_finder_bindings(m);
     define_pixel_map_bindings(m);
+    define_pedestal_bindings<double>(m, "Pedestal");
+    define_pedestal_bindings<float>(m, "Pedestal_float32");
+    define_cluster_finder_bindings(m);
 }

python/src/pedestal.hpp

@@ -0,0 +1,47 @@
+
+#include "aare/Pedestal.hpp"
+#include "np_helper.hpp"
+
+#include <cstdint>
+#include <filesystem>
+#include <pybind11/pybind11.h>
+#include <pybind11/stl.h>
+
+namespace py = pybind11;
+
+template <typename SUM_TYPE> void define_pedestal_bindings(py::module &m, const std::string &name) {
+    py::class_<Pedestal<SUM_TYPE>>(m, name.c_str())
+        .def(py::init<int, int, int>())
+        .def(py::init<int, int>())
+        .def("mean",
+             [](Pedestal<SUM_TYPE> &self) {
+                 auto m = new NDArray<SUM_TYPE, 2>{};
+                 *m = self.mean();
+                 return return_image_data(m);
+             })
+        .def("variance", [](Pedestal<SUM_TYPE> &self) {
+            auto m = new NDArray<SUM_TYPE, 2>{};
+            *m = self.variance();
+            return return_image_data(m);
+        })
+        .def("std", [](Pedestal<SUM_TYPE> &self) {
+            auto m = new NDArray<SUM_TYPE, 2>{};
+            *m = self.std();
+            return return_image_data(m);
+        })
+        .def("clear", py::overload_cast<>(&Pedestal<SUM_TYPE>::clear))
+        .def_property_readonly("rows", &Pedestal<SUM_TYPE>::rows)
+        .def_property_readonly("cols", &Pedestal<SUM_TYPE>::cols)
+        .def_property_readonly("n_samples", &Pedestal<SUM_TYPE>::n_samples)
+        .def_property_readonly("sum", &Pedestal<SUM_TYPE>::get_sum)
+        .def_property_readonly("sum2", &Pedestal<SUM_TYPE>::get_sum2)
+        .def("clone",
+             [&](Pedestal<SUM_TYPE> &pedestal) {
+                 return Pedestal<SUM_TYPE>(pedestal);
+             })
+        //TODO! add push for other data types
+        .def("push", [](Pedestal<SUM_TYPE> &pedestal, py::array_t<uint16_t> &f) {
+            auto v = make_view_2d(f);
+            pedestal.push(v);
+        });
+}