Head

GCC Code Coverage Report

Directory:	./		Exec	Total	Coverage
File:	src/matrix/operator-python-module-py.cc	Lines:	84	89	94.4 %
Date:	2023-03-13 12:09:37	Branches:	16	32	50.0 %


#include "dynamic-graph/python/module.hh"
#include "operator.hh"

namespace dg = dynamicgraph;
namespace dgs = dynamicgraph::sot;
namespace bp = boost::python;

typedef bp::return_value_policy<bp::reference_existing_object>
    reference_existing_object;

template <typename Operator>
void exposeUnaryOp() {
  typedef dgs::UnaryOp<Operator> O_t;
  dg::python::exposeEntity<O_t, bp::bases<dg::Entity>,
                           dg::python::AddCommands>()
      .def_readonly("sin", &O_t::SIN)
      .def_readonly("sout", &O_t::SOUT);
}

template <typename Operator>
void exposeBinaryOp() {
  typedef dgs::BinaryOp<Operator> O_t;
  dg::python::exposeEntity<O_t, bp::bases<dg::Entity>,
                           dg::python::AddCommands>()
      .def_readonly("sin1", &O_t::SIN1)
      .def_readonly("sin2", &O_t::SIN2)
      .def_readonly("sout", &O_t::SOUT);
}

template <typename Operator>
auto exposeVariadicOpBase() {
  typedef dgs::VariadicOp<Operator> O_t;
  typedef typename O_t::Base B_t;
  return dg::python::exposeEntity<O_t, bp::bases<dg::Entity>,
                                  dg::python::AddCommands>()
      .def_readonly("sout", &O_t::SOUT)
      .def("sin", &B_t::getSignalIn, reference_existing_object())
      .add_property("n_sin", &B_t::getSignalNumber, &B_t::setSignalNumber,
                    "the number of input signal.")

      .def("setSignalNumber", &B_t::setSignalNumber,
           "set the number of input signal.", bp::arg("size"))
      .def("getSignalNumber", &B_t::getSignalNumber,
           "get the number of input signal.", bp::arg("size"));
}

template <typename Operator>
struct exposeVariadicOpImpl {
  static void run() { exposeVariadicOpBase<Operator>(); }
};

template <typename T>
struct exposeVariadicOpImpl<dgs::AdderVariadic<T> > {
  static void run() {
    typedef dgs::VariadicOp<dgs::AdderVariadic<T> > E_t;
    exposeVariadicOpBase<dgs::AdderVariadic<T> >().add_property(
        "coeffs", +[](E_t &e) { return e.op.coeffs; },
        +[](E_t &e, const dg::Vector &c) { e.op.setCoeffs(c); },
        "the multipliers.");
  }
};

template <typename Operator>
void exposeVariadicOp() {
  exposeVariadicOpImpl<Operator>::run();
}

BOOST_PYTHON_MODULE(wrap) {
  using namespace dynamicgraph;
  using namespace dynamicgraph::sot;

  exposeUnaryOp<VectorSelecter>();
  exposeUnaryOp<VectorComponent>();
  exposeUnaryOp<MatrixSelector>();
  exposeUnaryOp<MatrixColumnSelector>();
  exposeUnaryOp<MatrixTranspose>();
  exposeUnaryOp<Diagonalizer>();

  /* ---------------------------------------------------------------------- */
  /* --- INVERSION -------------------------------------------------------- */
  /* ---------------------------------------------------------------------- */
  exposeUnaryOp<Inverser<Matrix> >();
  exposeUnaryOp<Inverser<MatrixHomogeneous> >();
  exposeUnaryOp<Inverser<MatrixTwist> >();
  exposeUnaryOp<Normalize>();
  exposeUnaryOp<InverserRotation>();
  exposeUnaryOp<InverserQuaternion>();

  /* ----------------------------------------------------------------------- */
  /* --- SE3/SO3 conversions ----------------------------------------------- */
  /* ----------------------------------------------------------------------- */

  exposeUnaryOp<SkewSymToVector>();
  exposeUnaryOp<PoseUThetaToMatrixHomo>();
  exposeUnaryOp<MatrixHomoToPoseUTheta>();
  exposeUnaryOp<MatrixHomoToSE3Vector>();
  exposeUnaryOp<SE3VectorToMatrixHomo>();
  exposeUnaryOp<PoseQuaternionToMatrixHomo>();
  exposeUnaryOp<MatrixHomoToPoseQuaternion>();
  exposeUnaryOp<MatrixHomoToPoseRollPitchYaw>();
  exposeUnaryOp<PoseRollPitchYawToMatrixHomo>();
  exposeUnaryOp<PoseRollPitchYawToPoseUTheta>();
  exposeUnaryOp<HomoToMatrix>();
  exposeUnaryOp<MatrixToHomo>();
  exposeUnaryOp<HomoToTwist>();
  exposeUnaryOp<HomoToRotation>();
  exposeUnaryOp<MatrixHomoToPose>();
  exposeUnaryOp<RPYToMatrix>();
  exposeUnaryOp<MatrixToRPY>();
  exposeUnaryOp<RPYToQuaternion>();
  exposeUnaryOp<QuaternionToRPY>();
  exposeUnaryOp<QuaternionToMatrix>();
  exposeUnaryOp<MatrixToQuaternion>();
  exposeUnaryOp<MatrixToUTheta>();
  exposeUnaryOp<UThetaToQuaternion>();

  /* --- MULTIPLICATION --------------------------------------------------- */

  exposeBinaryOp<Multiplier_double_vector>();
  exposeBinaryOp<Multiplier_matrix_vector>();
  exposeBinaryOp<Multiplier_matrixHomo_vector>();
  exposeBinaryOp<Multiplier_matrixTwist_vector>();

  /* --- SUBSTRACTION ----------------------------------------------------- */
  exposeBinaryOp<Substraction<dynamicgraph::Matrix> >();
  exposeBinaryOp<Substraction<dynamicgraph::Vector> >();
  exposeBinaryOp<Substraction<double> >();

  /* --- STACK ------------------------------------------------------------ */
  exposeBinaryOp<VectorStack>();

  /* ---------------------------------------------------------------------- */
  exposeBinaryOp<Composer>();

  /* --- CONVOLUTION PRODUCT ---------------------------------------------- */
  exposeBinaryOp<ConvolutionTemporal>();

  /* --- BOOLEAN REDUCTION ------------------------------------------------ */
  exposeBinaryOp<Comparison<double> >();
  exposeBinaryOp<MatrixComparison<Vector> >();

  exposeBinaryOp<WeightedAdder<dynamicgraph::Matrix> >();
  exposeBinaryOp<WeightedAdder<dynamicgraph::Vector> >();
  exposeBinaryOp<WeightedAdder<double> >();

  /* --- VectorMix ------------------------------------------------------------
   */
  exposeVariadicOp<VectorMix>();

  /* --- ADDITION --------------------------------------------------------- */
  exposeVariadicOp<AdderVariadic<Matrix> >();
  exposeVariadicOp<AdderVariadic<Vector> >();
  exposeVariadicOp<AdderVariadic<double> >();

  /* --- MULTIPLICATION --------------------------------------------------- */
  exposeVariadicOp<Multiplier<Matrix> >();
  exposeVariadicOp<Multiplier<Vector> >();
  exposeVariadicOp<Multiplier<MatrixRotation> >();
  exposeVariadicOp<Multiplier<MatrixHomogeneous> >();
  exposeVariadicOp<Multiplier<MatrixTwist> >();
  exposeVariadicOp<Multiplier<VectorQuaternion> >();
  exposeVariadicOp<Multiplier<double> >();

  /* --- BOOLEAN --------------------------------------------------------- */
  exposeVariadicOp<BoolOp<0> >();
  exposeVariadicOp<BoolOp<1> >();
}


Generated by: GCOVR (Version 4.2)

Line	Branch	Exec	Source
1			#include "dynamic-graph/python/module.hh"
2			#include "operator.hh"
3
4			namespace dg = dynamicgraph;
5			namespace dgs = dynamicgraph::sot;
6			namespace bp = boost::python;
7
8			typedef bp::return_value_policy<bp::reference_existing_object>
9			reference_existing_object;
10
11			template <typename Operator>
12		70	void exposeUnaryOp() {
13			typedef dgs::UnaryOp<Operator> O_t;
14			dg::python::exposeEntity<O_t, bp::bases<dg::Entity>,
15			dg::python::AddCommands>()
16			.def_readonly("sin", &O_t::SIN)
17	✓✗✓✗	70	.def_readonly("sout", &O_t::SOUT);
18		70	}
19
20			template <typename Operator>
21		30	void exposeBinaryOp() {
22			typedef dgs::BinaryOp<Operator> O_t;
23			dg::python::exposeEntity<O_t, bp::bases<dg::Entity>,
24			dg::python::AddCommands>()
25			.def_readonly("sin1", &O_t::SIN1)
26	✓✗	30	.def_readonly("sin2", &O_t::SIN2)
27	✓✗✓✗	30	.def_readonly("sout", &O_t::SOUT);
28		30	}
29
30			template <typename Operator>
31		26	auto exposeVariadicOpBase() {
32			typedef dgs::VariadicOp<Operator> O_t;
33			typedef typename O_t::Base B_t;
34			return dg::python::exposeEntity<O_t, bp::bases<dg::Entity>,
35			dg::python::AddCommands>()
36			.def_readonly("sout", &O_t::SOUT)
37	✓✗	52	.def("sin", &B_t::getSignalIn, reference_existing_object())
38			.add_property("n_sin", &B_t::getSignalNumber, &B_t::setSignalNumber,
39			"the number of input signal.")
40
41	✓✗	26	.def("setSignalNumber", &B_t::setSignalNumber,
42			"set the number of input signal.", bp::arg("size"))
43	✓✗✓✗	52	.def("getSignalNumber", &B_t::getSignalNumber,
44	✓✗✓✗ ✓✗✓✗	52	"get the number of input signal.", bp::arg("size"));
45			}
46
47			template <typename Operator>
48			struct exposeVariadicOpImpl {
49		20	static void run() { exposeVariadicOpBase<Operator>(); }
50			};
51
52			template <typename T>
53			struct exposeVariadicOpImpl<dgs::AdderVariadic<T> > {
54		6	static void run() {
55			typedef dgs::VariadicOp<dgs::AdderVariadic<T> > E_t;
56	✓✗	6	exposeVariadicOpBase<dgs::AdderVariadic<T> >().add_property(
57			"coeffs", +[](E_t &e) { return e.op.coeffs; },
58			+[](E_t &e, const dg::Vector &c) { e.op.setCoeffs(c); },
59			"the multipliers.");
60		6	}
61			};
62
63			template <typename Operator>
64		26	void exposeVariadicOp() {
65		26	exposeVariadicOpImpl<Operator>::run();
66		26	}
67
68	✓✗✓✗	4	BOOST_PYTHON_MODULE(wrap) {
69			using namespace dynamicgraph;
70			using namespace dynamicgraph::sot;
71
72		2	exposeUnaryOp<VectorSelecter>();
73		2	exposeUnaryOp<VectorComponent>();
74		2	exposeUnaryOp<MatrixSelector>();
75		2	exposeUnaryOp<MatrixColumnSelector>();
76		2	exposeUnaryOp<MatrixTranspose>();
77		2	exposeUnaryOp<Diagonalizer>();
78
79			/* ---------------------------------------------------------------------- */
80			/* --- INVERSION -------------------------------------------------------- */
81			/* ---------------------------------------------------------------------- */
82		2	exposeUnaryOp<Inverser<Matrix> >();
83		2	exposeUnaryOp<Inverser<MatrixHomogeneous> >();
84		2	exposeUnaryOp<Inverser<MatrixTwist> >();
85		2	exposeUnaryOp<Normalize>();
86		2	exposeUnaryOp<InverserRotation>();
87		2	exposeUnaryOp<InverserQuaternion>();
88
89			/* ----------------------------------------------------------------------- */
90			/* --- SE3/SO3 conversions ----------------------------------------------- */
91			/* ----------------------------------------------------------------------- */
92
93		2	exposeUnaryOp<SkewSymToVector>();
94		2	exposeUnaryOp<PoseUThetaToMatrixHomo>();
95		2	exposeUnaryOp<MatrixHomoToPoseUTheta>();
96		2	exposeUnaryOp<MatrixHomoToSE3Vector>();
97		2	exposeUnaryOp<SE3VectorToMatrixHomo>();
98		2	exposeUnaryOp<PoseQuaternionToMatrixHomo>();
99		2	exposeUnaryOp<MatrixHomoToPoseQuaternion>();
100		2	exposeUnaryOp<MatrixHomoToPoseRollPitchYaw>();
101		2	exposeUnaryOp<PoseRollPitchYawToMatrixHomo>();
102		2	exposeUnaryOp<PoseRollPitchYawToPoseUTheta>();
103		2	exposeUnaryOp<HomoToMatrix>();
104		2	exposeUnaryOp<MatrixToHomo>();
105		2	exposeUnaryOp<HomoToTwist>();
106		2	exposeUnaryOp<HomoToRotation>();
107		2	exposeUnaryOp<MatrixHomoToPose>();
108		2	exposeUnaryOp<RPYToMatrix>();
109		2	exposeUnaryOp<MatrixToRPY>();
110		2	exposeUnaryOp<RPYToQuaternion>();
111		2	exposeUnaryOp<QuaternionToRPY>();
112		2	exposeUnaryOp<QuaternionToMatrix>();
113		2	exposeUnaryOp<MatrixToQuaternion>();
114		2	exposeUnaryOp<MatrixToUTheta>();
115		2	exposeUnaryOp<UThetaToQuaternion>();
116
117			/* --- MULTIPLICATION --------------------------------------------------- */
118
119		2	exposeBinaryOp<Multiplier_double_vector>();
120		2	exposeBinaryOp<Multiplier_matrix_vector>();
121		2	exposeBinaryOp<Multiplier_matrixHomo_vector>();
122		2	exposeBinaryOp<Multiplier_matrixTwist_vector>();
123
124			/* --- SUBSTRACTION ----------------------------------------------------- */
125		2	exposeBinaryOp<Substraction<dynamicgraph::Matrix> >();
126		2	exposeBinaryOp<Substraction<dynamicgraph::Vector> >();
127		2	exposeBinaryOp<Substraction<double> >();
128
129			/* --- STACK ------------------------------------------------------------ */
130		2	exposeBinaryOp<VectorStack>();
131
132			/* ---------------------------------------------------------------------- */
133		2	exposeBinaryOp<Composer>();
134
135			/* --- CONVOLUTION PRODUCT ---------------------------------------------- */
136		2	exposeBinaryOp<ConvolutionTemporal>();
137
138			/* --- BOOLEAN REDUCTION ------------------------------------------------ */
139		2	exposeBinaryOp<Comparison<double> >();
140		2	exposeBinaryOp<MatrixComparison<Vector> >();
141
142		2	exposeBinaryOp<WeightedAdder<dynamicgraph::Matrix> >();
143		2	exposeBinaryOp<WeightedAdder<dynamicgraph::Vector> >();
144		2	exposeBinaryOp<WeightedAdder<double> >();
145
146			/* --- VectorMix ------------------------------------------------------------
147			*/
148		2	exposeVariadicOp<VectorMix>();
149
150			/* --- ADDITION --------------------------------------------------------- */
151		2	exposeVariadicOp<AdderVariadic<Matrix> >();
152		2	exposeVariadicOp<AdderVariadic<Vector> >();
153		2	exposeVariadicOp<AdderVariadic<double> >();
154
155			/* --- MULTIPLICATION --------------------------------------------------- */
156		2	exposeVariadicOp<Multiplier<Matrix> >();
157		2	exposeVariadicOp<Multiplier<Vector> >();
158		2	exposeVariadicOp<Multiplier<MatrixRotation> >();
159		2	exposeVariadicOp<Multiplier<MatrixHomogeneous> >();
160		2	exposeVariadicOp<Multiplier<MatrixTwist> >();
161		2	exposeVariadicOp<Multiplier<VectorQuaternion> >();
162		2	exposeVariadicOp<Multiplier<double> >();
163
164			/* --- BOOLEAN --------------------------------------------------------- */
165		2	exposeVariadicOp<BoolOp<0> >();
166		2	exposeVariadicOp<BoolOp<1> >();
167		2	}