changed template arguments added tests

python/src/cluster.hpp

@@ -23,10 +23,8 @@ template <typename Type, uint8_t ClusterSizeX, uint8_t ClusterSizeY,
 void define_cluster(py::module &m, const std::string &typestr) {
     auto class_name = fmt::format("Cluster{}", typestr);
 
-    using ClusterType =
-        Cluster<Type, ClusterSizeX, ClusterSizeY, CoordType, void>;
     py::class_<Cluster<Type, ClusterSizeX, ClusterSizeY, CoordType, void>>(
-        m, class_name.c_str())
+        m, class_name.c_str(), py::buffer_protocol())
 
         .def(py::init([](uint8_t x, uint8_t y, py::array_t<Type> data) {
             py::buffer_info buf_info = data.request();
@@ -37,83 +35,57 @@ void define_cluster(py::module &m, const std::string &typestr) {
             std::copy(ptr, ptr + ClusterSizeX * ClusterSizeY,
                       cluster.data); // Copy array contents
             return cluster;
-        }))
+        }));
 
-        //.def(py::init<>())
-        .def_readwrite("x", &ClusterType::x)
-        .def_readwrite("y", &ClusterType::y)
-        .def_property(
-            "data",
-            [](ClusterType &c) -> py::array {
-                return py::array(py::buffer_info(
-                    c.data, sizeof(Type),
-                    py::format_descriptor<Type>::format(), // Type
-                                                           // format
-                    1, // Number of dimensions
-                    {static_cast<ssize_t>(ClusterSizeX *
-                                          ClusterSizeY)}, // Shape (flattened)
-                    {sizeof(Type)} // Stride (step size between elements)
-                    ));
-            },
-            [](ClusterType &c, py::array_t<Type> arr) {
-                py::buffer_info buf_info = arr.request();
-                Type *ptr = static_cast<Type *>(buf_info.ptr);
-                std::copy(ptr, ptr + ClusterSizeX * ClusterSizeY,
-                          c.data); // TODO dont iterate over centers!!!
-            });
+    /*
+    .def_property(
+        "data",
+        [](ClusterType &c) -> py::array {
+            return py::array(py::buffer_info(
+                c.data, sizeof(Type),
+                py::format_descriptor<Type>::format(), // Type
+                                                       // format
+                1, // Number of dimensions
+                {static_cast<ssize_t>(ClusterSizeX *
+                                      ClusterSizeY)}, // Shape (flattened)
+                {sizeof(Type)} // Stride (step size between elements)
+                ));
+        },
+        [](ClusterType &c, py::array_t<Type> arr) {
+            py::buffer_info buf_info = arr.request();
+            Type *ptr = static_cast<Type *>(buf_info.ptr);
+            std::copy(ptr, ptr + ClusterSizeX * ClusterSizeY,
+                      c.data); // TODO dont iterate over centers!!!
+
+        });
+    */
 }
 
 template <typename Type, uint8_t ClusterSizeX, uint8_t ClusterSizeY,
           typename CoordType = uint16_t>
 void define_cluster_vector(py::module &m, const std::string &typestr) {
     using ClusterType =
-        Cluster<Type, ClusterSizeX, ClusterSizeY, uint16_t, void>;
+        Cluster<Type, ClusterSizeX, ClusterSizeY, CoordType, void>;
     auto class_name = fmt::format("ClusterVector_{}", typestr);
 
-    py::class_<ClusterVector<ClusterType>>(m, class_name.c_str(),
-                                           py::buffer_protocol())
+    py::class_<ClusterVector<
+        Cluster<Type, ClusterSizeX, ClusterSizeY, CoordType, void>, void>>(
+        m, class_name.c_str(),
+        py::buffer_protocol())
 
         .def(py::init()) // TODO change!!!
-        /*
-        .def("push_back",
-             [](ClusterVector<ClusterType> &self, ClusterType &cl) {
-                 //  auto view = make_view_2d(data);
-                 self.push_back(cl);
-             })
-        */
-        /*
-        .def(
-            "push_back",
-            [](ClusterVector<ClusterType> &self, py::object obj) {
-                ClusterType &cl = py::cast<ClusterType &>(obj);
-                self.push_back(cl);
-            },
-            py::arg("cluster"))
-        */
 
         .def("push_back",
              [](ClusterVector<ClusterType> &self, const ClusterType &cluster) {
                  self.push_back(cluster);
              })
 
-        //.def("push_back", &ClusterVector<ClusterType>::push_back) //TODO
         // implement push_back
         .def_property_readonly("size", &ClusterVector<ClusterType>::size)
         .def("item_size", &ClusterVector<ClusterType>::item_size)
         .def_property_readonly("fmt",
                                [typestr]() { return fmt_format<ClusterType>; })
-        /*
-        .def("sum",
-             [](ClusterVector<ClusterType> &self) {
-                 auto *vec = new std::vector<T>(self.sum());
-                 return return_vector(vec);
-             })
-        .def("sum_2x2",
-             [](ClusterVector<ClusterType> &self) {
-                 auto *vec = new std::vector<T>(self.sum_2x2());
-                 return return_vector(vec);
-             })
-        */
+
         .def_property_readonly("cluster_size_x",
                                &ClusterVector<ClusterType>::cluster_size_x)
         .def_property_readonly("cluster_size_y",
@@ -135,11 +107,14 @@ void define_cluster_vector(py::module &m, const std::string &typestr) {
             });
 }
 
-template <typename ClusterType>
+template <typename T, uint8_t ClusterSizeX, uint8_t ClusterSizeY,
+          typename CoordType = uint16_t>
 void define_cluster_finder_mt_bindings(py::module &m,
                                        const std::string &typestr) {
     auto class_name = fmt::format("ClusterFinderMT_{}", typestr);
 
+    using ClusterType = Cluster<T, ClusterSizeX, ClusterSizeY, CoordType>;
+
     py::class_<ClusterFinderMT<ClusterType, uint16_t, pd_type>>(
         m, class_name.c_str())
         .def(py::init<Shape<2>, pd_type, size_t, size_t>(),
@@ -185,11 +160,14 @@ void define_cluster_finder_mt_bindings(py::module &m,
             py::arg("thread_index") = 0);
 }
 
-template <typename ClusterType>
+template <typename T, uint8_t ClusterSizeX, uint8_t ClusterSizeY,
+          typename CoordType = uint16_t>
 void define_cluster_collector_bindings(py::module &m,
                                        const std::string &typestr) {
     auto class_name = fmt::format("ClusterCollector_{}", typestr);
 
+    using ClusterType = Cluster<T, ClusterSizeX, ClusterSizeY, CoordType>;
+
     py::class_<ClusterCollector<ClusterType>>(m, class_name.c_str())
         .def(py::init<ClusterFinderMT<ClusterType, uint16_t, double> *>())
         .def("stop", &ClusterCollector<ClusterType>::stop)
@@ -198,26 +176,32 @@ void define_cluster_collector_bindings(py::module &m,
             [](ClusterCollector<ClusterType> &self) {
                 auto v = new std::vector<ClusterVector<ClusterType>>(
                     self.steal_clusters());
-                return v;
+                return v; // TODO change!!!
             },
             py::return_value_policy::take_ownership);
 }
 
-template <typename ClusterType>
+template <typename T, uint8_t ClusterSizeX, uint8_t ClusterSizeY,
+          typename CoordType = uint16_t>
 void define_cluster_file_sink_bindings(py::module &m,
                                        const std::string &typestr) {
     auto class_name = fmt::format("ClusterFileSink_{}", typestr);
 
+    using ClusterType = Cluster<T, ClusterSizeX, ClusterSizeY, CoordType>;
+
     py::class_<ClusterFileSink<ClusterType>>(m, class_name.c_str())
         .def(py::init<ClusterFinderMT<ClusterType, uint16_t, double> *,
                       const std::filesystem::path &>())
         .def("stop", &ClusterFileSink<ClusterType>::stop);
 }
 
-template <typename ClusterType>
+template <typename T, uint8_t ClusterSizeX, uint8_t ClusterSizeY,
+          typename CoordType = uint16_t>
 void define_cluster_finder_bindings(py::module &m, const std::string &typestr) {
     auto class_name = fmt::format("ClusterFinder_{}", typestr);
 
+    using ClusterType = Cluster<T, ClusterSizeX, ClusterSizeY, CoordType>;
+
     py::class_<ClusterFinder<ClusterType, uint16_t, pd_type>>(
         m, class_name.c_str())
         .def(py::init<Shape<2>, pd_type, size_t>(), py::arg("image_size"),
@@ -248,9 +232,9 @@ void define_cluster_finder_bindings(py::module &m, const std::string &typestr) {
             "steal_clusters",
             [](ClusterFinder<ClusterType, uint16_t, pd_type> &self,
                bool realloc_same_capacity) {
-                auto v = new ClusterVector<ClusterType>(
-                    self.steal_clusters(realloc_same_capacity));
-                return v;
+                ClusterVector<ClusterType> clusters =
+                    self.steal_clusters(realloc_same_capacity);
+                return clusters;
             },
             py::arg("realloc_same_capacity") = false)
         .def(

python/src/cluster_file.hpp

@@ -80,7 +80,12 @@ void define_cluster_file_io_bindings(py::module &m,
             }
             return v;
         });
+}
 
+template <typename Type, uint8_t CoordSizeX, uint8_t CoordSizeY,
+          typename CoordType = uint16_t>
+void register_calculate_eta(py::module &m) {
+    using ClusterType = Cluster<Type, CoordSizeX, CoordSizeY, CoordType>;
     m.def("calculate_eta2",
           [](const aare::ClusterVector<ClusterType> &clusters) {
               auto eta2 = new NDArray<double, 2>(calculate_eta2(clusters));

python/src/interpolation.hpp

@@ -9,12 +9,13 @@
 
 namespace py = pybind11;
 
-template <typename ClusterType>
-void register_interpolate(py::class_<aare::Interpolator> &interpolator,
-                          const std::string &typestr) {
-    auto name = fmt::format("interpolate_{}", typestr);
+template <typename Type, uint8_t CoordSizeX, uint8_t CoordSizeY,
+          typename CoordType = uint16_t>
+void register_interpolate(py::class_<aare::Interpolator> &interpolator) {
 
-    interpolator.def(name.c_str(),
+    using ClusterType = Cluster<Type, CoordSizeX, CoordSizeY, CoordType>;
+
+    interpolator.def("interpolate",
                      [](aare::Interpolator &self,
                         const ClusterVector<ClusterType> &clusters) {
                          auto photons = self.interpolate<ClusterType>(clusters);
@@ -50,12 +51,12 @@ void define_interpolation_bindings(py::module &m) {
                 return return_image_data(ptr);
             });
 
-    register_interpolate<Cluster<int, 3, 3>>(interpolator, "Cluster3x3i");
-    register_interpolate<Cluster<float, 3, 3>>(interpolator, "Cluster3x3f");
-    register_interpolate<Cluster<double, 3, 3>>(interpolator, "Cluster3x3d");
-    register_interpolate<Cluster<int, 2, 2>>(interpolator, "Cluster2x2i");
-    register_interpolate<Cluster<float, 2, 2>>(interpolator, "Cluster2x2f");
-    register_interpolate<Cluster<double, 2, 2>>(interpolator, "Cluster2x2d");
+    register_interpolate<int, 3, 3, uint16_t>(interpolator);
+    register_interpolate<float, 3, 3, uint16_t>(interpolator);
+    register_interpolate<double, 3, 3, uint16_t>(interpolator);
+    register_interpolate<int, 2, 2, uint16_t>(interpolator);
+    register_interpolate<float, 2, 2, uint16_t>(interpolator);
+    register_interpolate<double, 2, 2, uint16_t>(interpolator);
 
     // TODO! Evaluate without converting to double
     m.def(

python/src/module.cpp

@@ -43,33 +43,33 @@ PYBIND11_MODULE(_aare, m) {
     define_cluster_vector<double, 2, 2, uint16_t>(m, "Cluster2x2d");
     define_cluster_vector<float, 2, 2, uint16_t>(m, "Cluster2x2f");
 
-    define_cluster_finder_bindings<Cluster<int, 3, 3>>(m, "Cluster3x3i");
-    define_cluster_finder_bindings<Cluster<double, 3, 3>>(m, "Cluster3x3d");
-    define_cluster_finder_bindings<Cluster<float, 3, 3>>(m, "Cluster3x3f");
-    define_cluster_finder_bindings<Cluster<int, 2, 2>>(m, "Cluster2x2i");
-    define_cluster_finder_bindings<Cluster<double, 2, 2>>(m, "Cluster2x2d");
-    define_cluster_finder_bindings<Cluster<float, 2, 2>>(m, "Cluster2x2f");
+    define_cluster_finder_bindings<int, 3, 3, uint16_t>(m, "Cluster3x3i");
+    define_cluster_finder_bindings<double, 3, 3, uint16_t>(m, "Cluster3x3d");
+    define_cluster_finder_bindings<float, 3, 3, uint16_t>(m, "Cluster3x3f");
+    define_cluster_finder_bindings<int, 2, 2, uint16_t>(m, "Cluster2x2i");
+    define_cluster_finder_bindings<double, 2, 2, uint16_t>(m, "Cluster2x2d");
+    define_cluster_finder_bindings<float, 2, 2, uint16_t>(m, "Cluster2x2f");
 
-    define_cluster_finder_mt_bindings<Cluster<int, 3, 3>>(m, "Cluster3x3i");
-    define_cluster_finder_mt_bindings<Cluster<double, 3, 3>>(m, "Cluster3x3d");
-    define_cluster_finder_mt_bindings<Cluster<float, 3, 3>>(m, "Cluster3x3f");
-    define_cluster_finder_mt_bindings<Cluster<int, 2, 2>>(m, "Cluster2x2i");
-    define_cluster_finder_mt_bindings<Cluster<double, 2, 2>>(m, "Cluster2x2d");
-    define_cluster_finder_mt_bindings<Cluster<float, 2, 2>>(m, "Cluster2x2f");
+    define_cluster_finder_mt_bindings<int, 3, 3, uint16_t>(m, "Cluster3x3i");
+    define_cluster_finder_mt_bindings<double, 3, 3, uint16_t>(m, "Cluster3x3d");
+    define_cluster_finder_mt_bindings<float, 3, 3, uint16_t>(m, "Cluster3x3f");
+    define_cluster_finder_mt_bindings<int, 2, 2, uint16_t>(m, "Cluster2x2i");
+    define_cluster_finder_mt_bindings<double, 2, 2, uint16_t>(m, "Cluster2x2d");
+    define_cluster_finder_mt_bindings<float, 2, 2, uint16_t>(m, "Cluster2x2f");
 
-    define_cluster_file_sink_bindings<Cluster<int, 3, 3>>(m, "Cluster3x3i");
-    define_cluster_file_sink_bindings<Cluster<double, 3, 3>>(m, "Cluster3x3d");
-    define_cluster_file_sink_bindings<Cluster<float, 3, 3>>(m, "Cluster3x3f");
-    define_cluster_file_sink_bindings<Cluster<int, 2, 2>>(m, "Cluster2x2i");
-    define_cluster_file_sink_bindings<Cluster<double, 2, 2>>(m, "Cluster2x2d");
-    define_cluster_file_sink_bindings<Cluster<float, 2, 2>>(m, "Cluster2x2f");
+    define_cluster_file_sink_bindings<int, 3, 3, uint16_t>(m, "Cluster3x3i");
+    define_cluster_file_sink_bindings<double, 3, 3, uint16_t>(m, "Cluster3x3d");
+    define_cluster_file_sink_bindings<float, 3, 3, uint16_t>(m, "Cluster3x3f");
+    define_cluster_file_sink_bindings<int, 2, 2, uint16_t>(m, "Cluster2x2i");
+    define_cluster_file_sink_bindings<double, 2, 2, uint16_t>(m, "Cluster2x2d");
+    define_cluster_file_sink_bindings<float, 2, 2, uint16_t>(m, "Cluster2x2f");
 
-    define_cluster_collector_bindings<Cluster<int, 3, 3>>(m, "Cluster3x3i");
-    define_cluster_collector_bindings<Cluster<double, 3, 3>>(m, "Cluster3x3f");
-    define_cluster_collector_bindings<Cluster<float, 3, 3>>(m, "Cluster3x3d");
-    define_cluster_collector_bindings<Cluster<int, 2, 2>>(m, "Cluster2x2i");
-    define_cluster_collector_bindings<Cluster<double, 2, 2>>(m, "Cluster2x2f");
-    define_cluster_collector_bindings<Cluster<float, 2, 2>>(m, "Cluster2x2d");
+    define_cluster_collector_bindings<int, 3, 3, uint16_t>(m, "Cluster3x3i");
+    define_cluster_collector_bindings<double, 3, 3, uint16_t>(m, "Cluster3x3f");
+    define_cluster_collector_bindings<float, 3, 3, uint16_t>(m, "Cluster3x3d");
+    define_cluster_collector_bindings<int, 2, 2, uint16_t>(m, "Cluster2x2i");
+    define_cluster_collector_bindings<double, 2, 2, uint16_t>(m, "Cluster2x2f");
+    define_cluster_collector_bindings<float, 2, 2, uint16_t>(m, "Cluster2x2d");
 
     define_cluster<int, 3, 3, uint16_t>(m, "3x3i");
     define_cluster<float, 3, 3, uint16_t>(m, "3x3f");
@@ -77,4 +77,11 @@ PYBIND11_MODULE(_aare, m) {
     define_cluster<int, 2, 2, uint16_t>(m, "2x2i");
     define_cluster<float, 2, 2, uint16_t>(m, "2x2f");
     define_cluster<double, 2, 2, uint16_t>(m, "2x2d");
+
+    register_calculate_eta<int, 3, 3, uint16_t>(m);
+    register_calculate_eta<float, 3, 3, uint16_t>(m);
+    register_calculate_eta<double, 3, 3, uint16_t>(m);
+    register_calculate_eta<int, 2, 2, uint16_t>(m);
+    register_calculate_eta<float, 2, 2, uint16_t>(m);
+    register_calculate_eta<double, 2, 2, uint16_t>(m);
 }