detectors/aare
25
0
Fork 0
mirror of https://github.com/slsdetectorgroup/aare.git synced 2025-06-06 12:50:40 +02:00
Code Issues Actions Packages Releases Activity

moved pd to double

Browse Source
This commit is contained in:
froejdh_e 2025-01-07 15:01:43 +01:00
parent d07da42745
commit acdce8454b
1 changed files with 62 additions and 59 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

121
python/src/cluster.hpp
View File

@ -10,7 +10,7 @@
#include <pybind11/stl.h> #include <pybind11/stl.h>
namespace py = pybind11; namespace py = pybind11;
using pd_type = float; using pd_type = double;
template <typename T> template <typename T>
void define_cluster_vector(py::module &m, const std::string &typestr) { void define_cluster_vector(py::module &m, const std::string &typestr) {
@ -21,90 +21,93 @@ void define_cluster_vector(py::module &m, const std::string &typestr) {
.def("element_offset", .def("element_offset",
py::overload_cast<>(&ClusterVector<T>::element_offset, py::const_)) py::overload_cast<>(&ClusterVector<T>::element_offset, py::const_))
.def_property_readonly("fmt", .def_property_readonly("fmt",
[typestr](ClusterVector<T> &self) { [typestr](ClusterVector<T> &self) {
return fmt::format( return fmt::format(
self.fmt_base(), self.cluster_size_x(), self.fmt_base(), self.cluster_size_x(),
self.cluster_size_y(), typestr); self.cluster_size_y(), typestr);
})
.def("sum",
[](ClusterVector<T> &self) {
auto *vec = new std::vector<T>(self.sum());
return return_vector(vec);
}) })
.def("sum", [](ClusterVector<T> &self) {
auto *vec = new std::vector<T>(self.sum());
return return_vector(vec);
})
.def_buffer([typestr](ClusterVector<T> &self) -> py::buffer_info { .def_buffer([typestr](ClusterVector<T> &self) -> py::buffer_info {
return py::buffer_info( return py::buffer_info(
self.data(), /* Pointer to buffer */ self.data(), /* Pointer to buffer */
self.element_offset(), /* Size of one scalar */ self.element_offset(), /* Size of one scalar */
fmt::format(self.fmt_base(), self.cluster_size_x(), fmt::format(self.fmt_base(), self.cluster_size_x(),
self.cluster_size_y(), self.cluster_size_y(),
typestr), /* Format descriptor */ typestr), /* Format descriptor */
1, /* Number of dimensions */ 1, /* Number of dimensions */
{self.size()}, /* Buffer dimensions */ {self.size()}, /* Buffer dimensions */
{self.element_offset()} /* Strides (in bytes) for each index */ {self.element_offset()} /* Strides (in bytes) for each index */
); );
}); });
} }
void define_cluster_finder_bindings(py::module &m) { void define_cluster_finder_bindings(py::module &m) {
py::class_<ClusterFinder<uint16_t, pd_type>>(m, "ClusterFinder") py::class_<ClusterFinder<uint16_t, pd_type>>(m, "ClusterFinder")
.def(py::init<Shape<2>, Shape<2>, pd_type, size_t>(), py::arg("image_size"), .def(py::init<Shape<2>, Shape<2>, pd_type, size_t>(),
py::arg("cluster_size"), py::arg("n_sigma") = 5.0, py::arg("image_size"), py::arg("cluster_size"),
py::arg("capacity") = 1'000'000) py::arg("n_sigma") = 5.0, py::arg("capacity") = 1'000'000)
.def("push_pedestal_frame", .def("push_pedestal_frame",
[](ClusterFinder<uint16_t, pd_type> &self, [](ClusterFinder<uint16_t, pd_type> &self,
py::array_t<uint16_t> frame) { py::array_t<uint16_t> frame) {
auto view = make_view_2d(frame); auto view = make_view_2d(frame);
self.push_pedestal_frame(view); self.push_pedestal_frame(view);
}) })
.def("pedestal", .def_property_readonly("pedestal",
[](ClusterFinder<uint16_t, pd_type> &self) { [](ClusterFinder<uint16_t, pd_type> &self) {
auto pd = new NDArray<pd_type, 2>{}; auto pd = new NDArray<pd_type, 2>{};
*pd = self.pedestal(); *pd = self.pedestal();
return return_image_data(pd); return return_image_data(pd);
}) })
.def("noise", .def_property_readonly("noise",
[](ClusterFinder<uint16_t, pd_type> &self) { [](ClusterFinder<uint16_t, pd_type> &self) {
auto arr = new NDArray<pd_type, 2>{}; auto arr = new NDArray<pd_type, 2>{};
*arr = self.noise(); *arr = self.noise();
return return_image_data(arr); return return_image_data(arr);
}) })
.def("steal_clusters", .def(
[](ClusterFinder<uint16_t, pd_type> &self, bool realloc_same_capacity) { "steal_clusters",
auto v = new ClusterVector<int>(self.steal_clusters(realloc_same_capacity)); [](ClusterFinder<uint16_t, pd_type> &self,
return v; bool realloc_same_capacity) {
}, py::arg("realloc_same_capacity") = false) auto v = new ClusterVector<int>(
.def("find_clusters", self.steal_clusters(realloc_same_capacity));
[](ClusterFinder<uint16_t, pd_type> &self, return v;
py::array_t<uint16_t> frame) { },
auto view = make_view_2d(frame); py::arg("realloc_same_capacity") = false)
self.find_clusters(view); .def("find_clusters", [](ClusterFinder<uint16_t, pd_type> &self,
return; py::array_t<uint16_t> frame) {
}); auto view = make_view_2d(frame);
self.find_clusters(view);
return;
});
m.def("hitmap", [](std::array<size_t, 2> image_size, ClusterVector<int32_t>& cv){ m.def("hitmap",
[](std::array<size_t, 2> image_size, ClusterVector<int32_t> &cv) {
py::array_t<int32_t> hitmap(image_size); py::array_t<int32_t> hitmap(image_size);
auto r = hitmap.mutable_unchecked<2>(); auto r = hitmap.mutable_unchecked<2>();
// Initialize hitmap to 0 // Initialize hitmap to 0
for (py::ssize_t i = 0; i < r.shape(0); i++) for (py::ssize_t i = 0; i < r.shape(0); i++)
for (py::ssize_t j = 0; j < r.shape(1); j++) for (py::ssize_t j = 0; j < r.shape(1); j++)
r(i, j) = 0; r(i, j) = 0;
size_t stride = cv.element_offset(); size_t stride = cv.element_offset();
auto ptr = cv.data(); auto ptr = cv.data();
for(size_t i=0; i<cv.size(); i++){ for (size_t i = 0; i < cv.size(); i++) {
auto x = *reinterpret_cast<int16_t*>(ptr); auto x = *reinterpret_cast<int16_t *>(ptr);
auto y = *reinterpret_cast<int16_t*>(ptr+sizeof(int16_t)); auto y = *reinterpret_cast<int16_t *>(ptr + sizeof(int16_t));
r(y, x) += 1; r(y, x) += 1;
ptr += stride; ptr += stride;
} }
return hitmap; return hitmap;
}); });
define_cluster_vector<int>(m, "i"); define_cluster_vector<int>(m, "i");
define_cluster_vector<double>(m, "d"); define_cluster_vector<double>(m, "d");
define_cluster_vector<float>(m, "f"); define_cluster_vector<float>(m, "f");
py::class_<DynamicCluster>(m, "DynamicCluster", py::buffer_protocol()) py::class_<DynamicCluster>(m, "DynamicCluster", py::buffer_protocol())
.def(py::init<int, int, Dtype>()) .def(py::init<int, int, Dtype>())
.def("size", &DynamicCluster::size) .def("size", &DynamicCluster::size)