geometry.hpp

//
// Copyright (c) 2021-2022 INRIA
//
 
#ifndef __pinocchio_python_collision_pool_geometry_hpp__
#define __pinocchio_python_collision_pool_geometry_hpp__
 
#include <boost/python/overloads.hpp>
 
#include <eigenpy/eigen-to-python.hpp>
#include <eigenpy/memory.hpp>
#include <eigenpy/exception.hpp>
 
#include "pinocchio/bindings/python/utils/copyable.hpp"
#include "pinocchio/bindings/python/utils/std-vector.hpp"
 
#include "pinocchio/algorithm/check.hpp"
#include "pinocchio/multibody/pool/geometry.hpp"
 
#if EIGENPY_VERSION_AT_MOST(2, 8, 1)
EIGENPY_DEFINE_STRUCT_ALLOCATOR_SPECIALIZATION(pinocchio::GeometryPool)
#endif
 
namespace pinocchio
{
  namespace python
  {
    namespace bp = boost::python;
 
    template<typename GeometryPool>
    struct GeometryPoolPythonVisitor
    : public bp::def_visitor<GeometryPoolPythonVisitor<GeometryPool>>
    {
 
      typedef typename GeometryPool::Base Base;
      typedef typename GeometryPool::Model Model;
      typedef typename GeometryPool::GeometryModel GeometryModel;
      typedef typename GeometryPool::GeometryData GeometryData;
      typedef typename GeometryPool::GeometryModelVector GeometryModelVector;
      typedef typename GeometryPool::GeometryDataVector GeometryDataVector;
 
      /* --- Exposing C++ API to python through the handler ----------------- */
      template<class PyClass>
      void visit(PyClass & cl) const
      {
        cl.def(bp::init<const Model &, const GeometryModel &, bp::optional<size_t>>(
                 bp::args("self", "model", "geometry_model", "size"), "Default constructor."))
          .def(bp::init<const GeometryPool &>(bp::args("self", "other"), "Copy constructor."))
 
          .def(
            "getGeometryModel",
            (GeometryModel & (GeometryPool::*)(const size_t)) & GeometryPool::getGeometryModel,
            bp::args("self", "index"), "Return a specific geometry model.",
            bp::return_internal_reference<>())
          .def(
            "getGeometryModels",
            (GeometryModelVector & (GeometryPool::*)()) & GeometryPool::getGeometryModels,
            bp::arg("self"), "Returns the geometry model vector.",
            bp::return_internal_reference<>())
 
          .def(
            "getGeometryData",
            (GeometryData & (GeometryPool::*)(const size_t)) & GeometryPool::getGeometryData,
            bp::args("self", "index"), "Return a specific geometry data.",
            bp::return_internal_reference<>())
          .def(
            "getGeometryDatas",
            (GeometryDataVector & (GeometryPool::*)()) & GeometryPool::getGeometryDatas,
            bp::arg("self"), "Returns the geometry data vector.", bp::return_internal_reference<>())
 
          .def(
            "sync", &GeometryPool::sync, bp::args("geometry_model", "geometry_indexes"),
            "Synchronize the internal geometry models with the input geometry for all given "
            "geometry indexes.")
 
          .def(
            "update", (void(GeometryPool::*)(const GeometryData &)) & GeometryPool::update,
            bp::args("self", "geometry_data"),
            "Update all the geometry datas with the input geometry data value.");
      }
 
      static void expose()
      {
 
        bp::class_<GeometryPool, bp::bases<Base>>(
          "GeometryPool",
          "Pool containing a model + a geometry_model and several datas for parallel computations",
          bp::no_init)
          .def(GeometryPoolPythonVisitor())
          .def(CopyableVisitor<GeometryPool>());
 
        StdVectorPythonVisitor<GeometryModelVector>::expose("StdVec_GeometryModel");
        StdVectorPythonVisitor<GeometryDataVector>::expose("StdVec_GeometryData");
      }
    };
  } // namespace python
} // namespace pinocchio
 
#endif // ifnded __pinocchio_python_collision_pool_geometry_hpp__