Support evaluation on residuals and Jacobian from pyceres.Problem

_pyceres/core/bindings.h

@@ -3,6 +3,7 @@
 #include "_pyceres/core/callbacks.h"
 #include "_pyceres/core/cost_functions.h"
 #include "_pyceres/core/covariance.h"
+#include "_pyceres/core/crs_matrix.h"
 #include "_pyceres/core/loss_functions.h"
 #include "_pyceres/core/manifold.h"
 #include "_pyceres/core/problem.h"
@@ -17,6 +18,7 @@ void BindCore(py::module& m) {
   BindTypes(m);
   BindCallbacks(m);
   BindCovariance(m);
+  BindCRSMatrix(m);
   BindSolver(m);
   BindLossFunctions(m);
   BindCostFunctions(m);

_pyceres/core/crs_matrix.h

@@ -0,0 +1,43 @@
+#pragma once
+
+#include "_pyceres/core/wrappers.h"
+#include "_pyceres/helpers.h"
+#include "_pyceres/logging.h"
+
+#include <Eigen/Sparse>
+#include <ceres/ceres.h>
+#include <ceres/crs_matrix.h>
+#include <pybind11/pybind11.h>
+
+namespace py = pybind11;
+
+namespace {
+py::tuple ConvertCRSToPyTuple(const ceres::CRSMatrix& crsMatrix) {
+  std::vector<int> rows, cols;
+  std::vector<double> values;
+
+  for (int row = 0; row < crsMatrix.num_rows; ++row) {
+    for (int k = crsMatrix.rows[row]; k < crsMatrix.rows[row + 1]; ++k) {
+      rows.push_back(row);
+      cols.push_back(crsMatrix.cols[k]);
+      values.push_back(crsMatrix.values[k]);
+    }
+  }
+
+  // return as a tuple
+  return py::make_tuple(rows, cols, values);
+}
+}  // namespace
+
+void BindCRSMatrix(py::module& m) {
+  using CRSMatrix = ceres::CRSMatrix;
+  py::class_<CRSMatrix> PyCRSMatrix(m, "CRSMatrix");
+  PyCRSMatrix.def(py::init<>())
+      .def_readonly("num_rows", &CRSMatrix::num_rows)
+      .def_readonly("num_cols", &CRSMatrix::num_cols)
+      .def_readonly("rows", &CRSMatrix::rows)
+      .def_readonly("cols", &CRSMatrix::cols)
+      .def_readonly("values", &CRSMatrix::values)
+      .def("to_tuple",
+           [](CRSMatrix& self) { return ConvertCRSToPyTuple(self); });
+}

_pyceres/core/problem.h

@@ -40,11 +40,17 @@ void BindProblem(py::module& m) {
       .def_readwrite("disable_all_safety_checks",
                      &options::disable_all_safety_checks);
 
-  // TODO: bind Problem::Evaluate
   py::class_<ceres::Problem::EvaluateOptions>(m, "EvaluateOptions")
       .def(py::init<>())
-      // Doesn't make sense to wrap this as you can't see the pointers in python
-      //.def_readwrite("parameter_blocks",&ceres::Problem::EvaluateOptions)
+      .def("set_parameter_blocks",
+           [](ceres::Problem::EvaluateOptions& self,
+              std::vector<py::array_t<double>>& blocks) {
+             self.parameter_blocks.clear();
+             for (auto it = blocks.begin(); it != blocks.end(); ++it) {
+               py::buffer_info info = it->request();
+               self.parameter_blocks.push_back(static_cast<double*>(info.ptr));
+             }
+           })
       .def_readwrite("apply_loss_function",
                      &ceres::Problem::EvaluateOptions::apply_loss_function)
       .def_readwrite("num_threads",
@@ -233,5 +239,23 @@ void BindProblem(py::module& m) {
       .def("remove_residual_block",
            [](ceres::Problem& self, ResidualBlockIDWrapper& residual_block_id) {
              self.RemoveResidualBlock(residual_block_id.id);
-           });
+           })
+      .def(
+          "evaluate_residuals",
+          [](ceres::Problem& self,
+             const ceres::Problem::EvaluateOptions& options) {
+            std::vector<double> residuals;
+            self.Evaluate(options, nullptr, &residuals, nullptr, nullptr);
+            return residuals;
+          },
+          py::arg("options") = ceres::Problem::EvaluateOptions())
+      .def(
+          "evaluate_jacobian",
+          [](ceres::Problem& self,
+             const ceres::Problem::EvaluateOptions& options) {
+            ceres::CRSMatrix jacobian;
+            self.Evaluate(options, nullptr, nullptr, nullptr, &jacobian);
+            return jacobian;
+          },
+          py::arg("options") = ceres::Problem::EvaluateOptions());
 }