clang-format

Author: mgumowsk

src/cpp/py_bindings/py_classification.cpp

@@ -75,16 +75,17 @@ void init_classification(nb::module_& m) {
              [](ClassificationModel& self, const nb::ndarray<>& input) {
                  return self.infer(pyutils::wrap_np_mat(input));
              })
-        .def("infer_batch", [](ClassificationModel& self, const std::vector<nb::ndarray<>> inputs) {
-            std::vector<ImageInputData> input_mats;
-            input_mats.reserve(inputs.size());
+        .def("infer_batch",
+             [](ClassificationModel& self, const std::vector<nb::ndarray<>> inputs) {
+                 std::vector<ImageInputData> input_mats;
+                 input_mats.reserve(inputs.size());
 
-            for (const auto& input : inputs) {
-                input_mats.push_back(pyutils::wrap_np_mat(input));
-            }
+                 for (const auto& input : inputs) {
+                     input_mats.push_back(pyutils::wrap_np_mat(input));
+                 }
 
-            return self.inferBatch(input_mats);
-        })
+                 return self.inferBatch(input_mats);
+             })
         .def_prop_ro_static("__model__", [](nb::object) {
             return ClassificationModel::ModelType;
         });

src/cpp/py_bindings/py_instance_segmentation.cpp

@@ -59,11 +59,8 @@ void init_instance_segmentation(nb::module_& m) {
             return MaskRCNNModel::ModelType;
         });
 
-
     nb::class_<InstanceSegmentationResult, ResultBase>(m, "InstanceSegmentationResult")
-        .def(nb::init<int64_t, std::shared_ptr<MetaData>>(),
-             nb::arg("frameId") = -1,
-             nb::arg("metaData") = nullptr)
+        .def(nb::init<int64_t, std::shared_ptr<MetaData>>(), nb::arg("frameId") = -1, nb::arg("metaData") = nullptr)
         .def_prop_ro(
             "feature_vector",
             [](InstanceSegmentationResult& r) {

src/cpp/py_bindings/py_keypoint_detection.cpp

@@ -59,9 +59,7 @@ void init_keypoint_detection(nb::module_& m) {
         });
 
     nb::class_<KeypointDetectionResult, ResultBase>(m, "KeypointDetectionResult")
-        .def(nb::init<int64_t, std::shared_ptr<MetaData>>(),
-            nb::arg("frameId") = -1,
-            nb::arg("metaData") = nullptr)
+        .def(nb::init<int64_t, std::shared_ptr<MetaData>>(), nb::arg("frameId") = -1, nb::arg("metaData") = nullptr)
         .def_ro("poses", &KeypointDetectionResult::poses);
 
     nb::class_<DetectedKeypoints>(m, "DetectedKeypoints")

src/cpp/py_bindings/py_results.cpp

@@ -10,8 +10,8 @@
 #include <nanobind/stl/unique_ptr.h>
 #include <nanobind/stl/vector.h>
 
-#include "models/segmentation_model.h"
 #include "models/results.h"
+#include "models/segmentation_model.h"
 #include "py_utils.hpp"
 
 namespace pyutils = vision::nanobind::utils;
@@ -40,33 +40,34 @@ void init_segmentation(nb::module_& m) {
              [](SegmentationModel& self, const nb::ndarray<>& input) {
                  return self.infer(pyutils::wrap_np_mat(input));
              })
-        .def("infer_batch", [](SegmentationModel& self, const std::vector<nb::ndarray<>> inputs) {
-            std::vector<ImageInputData> input_mats;
-            input_mats.reserve(inputs.size());
+        .def("infer_batch",
+             [](SegmentationModel& self, const std::vector<nb::ndarray<>> inputs) {
+                 std::vector<ImageInputData> input_mats;
+                 input_mats.reserve(inputs.size());
 
-            for (const auto& input : inputs) {
-                input_mats.push_back(pyutils::wrap_np_mat(input));
-            }
+                 for (const auto& input : inputs) {
+                     input_mats.push_back(pyutils::wrap_np_mat(input));
+                 }
 
-            return self.inferBatch(input_mats);
-        })
-        .def("postprocess", [](SegmentationModel& self, InferenceResult& infResult) {
-            return self.postprocess(infResult);
-        })
+                 return self.inferBatch(input_mats);
+             })
+        .def("postprocess",
+             [](SegmentationModel& self, InferenceResult& infResult) {
+                 return self.postprocess(infResult);
+             })
         .def_prop_ro_static("__model__", [](nb::object) {
             return SegmentationModel::ModelType;
         });
 
     nb::class_<ImageResult, ResultBase>(m, "ImageResult")
-        .def(nb::init<int64_t, std::shared_ptr<MetaData>>(),
-             nb::arg("frameId") = -1,
-             nb::arg("metaData") = nullptr)
+        .def(nb::init<int64_t, std::shared_ptr<MetaData>>(), nb::arg("frameId") = -1, nb::arg("metaData") = nullptr)
         .def_prop_ro(
             "resultImage",
             [](ImageResult& r) {
                 return nb::ndarray<uint8_t, nb::numpy, nb::c_contig>(r.resultImage.data,
-                    {static_cast<size_t>(r.resultImage.rows), static_cast<size_t>(r.resultImage.cols), static_cast<size_t>(r.resultImage.channels())});
+                                                                     {static_cast<size_t>(r.resultImage.rows),
+                                                                      static_cast<size_t>(r.resultImage.cols),
+                                                                      static_cast<size_t>(r.resultImage.channels())});
             },
-            nb::rv_policy::reference_internal
-        );
+            nb::rv_policy::reference_internal);
 }

src/cpp/py_bindings/py_segmentation.cpp

@@ -11,8 +11,7 @@ void init_base_modules(nb::module_& m);
 void init_classification(nb::module_& m);
 void init_segmentation(nb::module_& m);
 void init_instance_segmentation(nb::module_& m);
-void init_keypoint_detection(nb::module_& m); 
-
+void init_keypoint_detection(nb::module_& m);
 
 NB_MODULE(py_model_api, m) {
     m.doc() = "Nanobind binding for OpenVINO Vision API library";