Rot2, Pose2, Point2 now all work fairly well in Python. See Pose2.cpp for examples on method overloading and auto-declarations

python/geometry/Point2.cpp

@@ -4,20 +4,23 @@
 using namespace boost::python;
 using namespace gtsam;
 
-BOOST_PYTHON_FUNCTION_OVERLOADS(equals_overloads, &Point2::equals, 1, 2)
+BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS(print_overloads, Point2::print, 0, 1)
+BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS(equals_overloads, Point2::equals, 1, 2)
+BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS(compose_overloads, Point2::compose, 1, 3)
 
 void exportPoint2(){
 
   class_<Point2>("Point2", init<>())
     .def(init<double, double>())
-    .def("print", &Point2::print)
-    .def("equals", &Point2::equals)
+    .def("print", &Point2::print, print_overloads(args("s")))
+    .def("equals", &Point2::equals, equals_overloads(args("q","tol")))
     .def("inverse", &Point2::inverse)
-    .def("compose", &Point2::compose)
+    .def("compose", &Point2::compose, compose_overloads(args("q", "H1", "H2")))
     .def("between", &Point2::between)
     .def("dim", &Point2::dim)
     .def("retract", &Point2::retract)
     .def("x", &Point2::x)
     .def("y", &Point2::y)
   ;
+
 }

python/geometry/Pose2.cpp

@@ -0,0 +1,72 @@
+#include <boost/python.hpp>
+#include "gtsam/geometry/Pose2.h"
+
+using namespace boost::python;
+using namespace gtsam;
+
+BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS(print_overloads, Pose2::print, 0, 1)
+BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS(equals_overloads, Pose2::equals, 1, 2)
+BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS(compose_overloads, Pose2::compose, 1, 3)
+BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS(between_overloads, Pose2::between, 1, 3)
+BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS(transform_to_overloads, Pose2::transform_to, 1, 3)
+BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS(transform_from_overloads, Pose2::transform_from, 1, 3)
+BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS(bearing_overloads, Pose2::bearing, 1, 3)
+BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS(range_overloads, Pose2::range, 1, 3)
+
+// Manually wrap 
+
+void exportPose2(){
+
+  double (Pose2::*range1)(const Pose2&, boost::optional<Matrix&>, boost::optional<Matrix&>) const
+    = &Pose2::range;
+  double (Pose2::*range2)(const Point2&, boost::optional<Matrix&>, boost::optional<Matrix&>) const
+    = &Pose2::range;
+
+  Rot2 (Pose2::*bearing1)(const Pose2&, boost::optional<Matrix&>, boost::optional<Matrix&>) const
+    = &Pose2::bearing;
+  Rot2 (Pose2::*bearing2)(const Point2&, boost::optional<Matrix&>, boost::optional<Matrix&>) const
+    = &Pose2::bearing;
+
+  class_<Pose2>("Pose2", init<>())
+    .def(init<Pose2>())
+    .def(init<double, double, double>())
+    .def(init<double, Point2>())
+    .def("print", &Pose2::print, print_overloads(args("s")))
+
+    .def("equals", &Pose2::equals, equals_overloads(args("pose","tol")))
+    .def("inverse", &Pose2::inverse)
+    .def("compose", &Pose2::compose, compose_overloads(args("p2", "H1", "H2")))
+    .def("between", &Pose2::between, between_overloads(args("p2", "H1", "H2")))
+    .def("dim", &Pose2::dim)
+    .def("retract", &Pose2::retract)
+
+    .def("transform_to", &Pose2::transform_to, 
+      transform_to_overloads(args("point", "H1", "H2")))
+    .def("transform_from", &Pose2::transform_from, 
+      transform_to_overloads(args("point", "H1", "H2")))
+
+    .def("x", &Pose2::x)
+    .def("y", &Pose2::y)
+    .def("theta", &Pose2::theta)
+    // See documentation on call policy for more information
+    // https://wiki.python.org/moin/boost.python/CallPolicy
+    .def("t", &Pose2::t, return_value_policy<copy_const_reference>())
+    .def("r", &Pose2::r, return_value_policy<copy_const_reference>())
+    .def("translation", &Pose2::translation, return_value_policy<copy_const_reference>())
+    .def("rotation", &Pose2::rotation, return_value_policy<copy_const_reference>())
+
+    .def("bearing", bearing1, bearing_overloads())
+    .def("bearing", bearing2, bearing_overloads())
+
+    // Function overload example
+    .def("range", range1, range_overloads())
+    .def("range", range2, range_overloads())
+
+
+    .def("Expmap", &Pose2::Expmap)
+    .staticmethod("Expmap")
+
+    .def(self * self) // __mult__
+  ;
+
+}

python/geometry/Rot2.cpp

@@ -0,0 +1,48 @@
+#include <boost/python.hpp>
+#include "gtsam/geometry/Rot2.h"
+
+using namespace boost::python;
+using namespace gtsam;
+
+BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS(print_overloads, Rot2::print, 0, 1)
+BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS(equals_overloads, Rot2::equals, 1, 2)
+BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS(compose_overloads, Rot2::compose, 1, 3)
+BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS(relativeBearing_overloads, Rot2::relativeBearing, 1, 3)
+
+void exportRot2(){
+
+  class_<Rot2>("Rot2", init<>())
+    .def(init<double>())
+
+    .def("fromAngle", &Rot2::fromAngle)
+    .staticmethod("fromAngle")
+
+    .def("fromDegrees", &Rot2::fromDegrees)
+    .staticmethod("fromDegrees")
+
+    .def("fromCosSin", &Rot2::fromCosSin)
+    .staticmethod("fromCosSin")
+
+    .def("atan2", &Rot2::atan2)
+    .staticmethod("atan2")
+
+    .def("print", &Rot2::print, print_overloads(args("s")))
+    .def("equals", &Rot2::equals, equals_overloads(args("q","tol")))
+    .def("inverse", &Rot2::inverse)
+    .def("compose", &Rot2::compose, compose_overloads(args("q", "H1", "H2")))
+    .def("between", &Rot2::between)
+    .def("dim", &Rot2::dim)
+    .def("retract", &Rot2::retract)
+
+    .def("Expmap", &Rot2::Expmap)
+    .staticmethod("Expmap")
+
+    .def("theta", &Rot2::theta)
+    .def("degrees", &Rot2::degrees)
+    .def("c", &Rot2::c)
+    .def("s", &Rot2::s)
+
+    .def(self * self) // __mult__
+  ;
+
+}

python/geometry/exportGeometry.cpp

@@ -2,9 +2,12 @@
 #include <boost/cstdint.hpp>
 
 void exportPoint2();
+void exportRot2();
+void exportPose2();
 
 BOOST_PYTHON_MODULE(libgeometry){
   using namespace boost::python;
-
   exportPoint2();
+  exportRot2();
+  exportPose2();
 }