Program Listing for File geometry-data.hpp
↰ Return to documentation for file (include/pinocchio/bindings/python/multibody/geometry-data.hpp
)
//
// Copyright (c) 2015-2021 CNRS INRIA
//
#ifndef __pinocchio_python_geometry_data_hpp__
#define __pinocchio_python_geometry_data_hpp__
#include <eigenpy/memory.hpp>
#include "pinocchio/serialization/geometry.hpp"
#include "pinocchio/bindings/python/utils/printable.hpp"
#include "pinocchio/bindings/python/utils/copyable.hpp"
#include "pinocchio/bindings/python/utils/deprecation.hpp"
#include "pinocchio/bindings/python/utils/std-vector.hpp"
#include "pinocchio/bindings/python/serialization/serializable.hpp"
#if EIGENPY_VERSION_AT_MOST(2,8,1)
EIGENPY_DEFINE_STRUCT_ALLOCATOR_SPECIALIZATION(pinocchio::GeometryData)
#endif
namespace pinocchio
{
namespace python
{
namespace bp = boost::python;
/* --- COLLISION PAIR --------------------------------------------------- */
/* --- COLLISION PAIR --------------------------------------------------- */
/* --- COLLISION PAIR --------------------------------------------------- */
struct CollisionPairPythonVisitor
: public boost::python::def_visitor<CollisionPairPythonVisitor>
{
static void expose()
{
bp::class_<CollisionPair> ("CollisionPair",
"Pair of ordered index defining a pair of collisions",
bp::no_init)
.def(bp::init<>
(bp::args("self"),
"Empty constructor."))
.def(bp::init<const GeomIndex &, const GeomIndex &>
(bp::args("self","index1", "index2"),
"Initializer of collision pair."))
.def(PrintableVisitor<CollisionPair>())
.def(CopyableVisitor<CollisionPair>())
.def(bp::self == bp::self)
.def(bp::self != bp::self)
.def_readwrite("first",&CollisionPair::first)
.def_readwrite("second",&CollisionPair::second);
StdVectorPythonVisitor<CollisionPair>::expose("StdVec_CollisionPair");
serialize< std::vector<CollisionPair> >();
}
}; // struct CollisionPairPythonVisitor
struct GeometryDataPythonVisitor
: public boost::python::def_visitor< GeometryDataPythonVisitor >
{
/* --- Exposing C++ API to python through the handler ----------------- */
template<class PyClass>
void visit(PyClass& cl) const
{
cl
.def(bp::init<GeometryModel>(bp::args("self","geometry_model"),
"Default constructor from a given GeometryModel"))
.def_readonly("oMg",
&GeometryData::oMg,
"Vector of collision objects placement relative to the world frame.\n"
"note: These quantities have to be updated by calling updateGeometryPlacements.")
.def_readonly("activeCollisionPairs",
&GeometryData::activeCollisionPairs,
"Vector of active CollisionPairs")
#ifdef PINOCCHIO_WITH_HPP_FCL
.def_readonly("distanceRequests",
&GeometryData::distanceRequests,
"Defines which information should be computed by FCL for distance computations")
.def_readonly("distanceResults",
&GeometryData::distanceResults,
"Vector of distance results.")
.def_readonly("collisionRequests",
&GeometryData::collisionRequests,
"Defines which information should be computed by FCL for collision computations.\n\n"
"Note: it is possible to define a security_margin and a break_distance for a collision request.\n"
"Most likely, for robotics application, these thresholds will be different for each collision pairs\n"
"(e.g. the two hands can have a large security margin while the two hips cannot.)")
.def_readonly("collisionResults",
&GeometryData::collisionResults,
"Vector of collision results.")
.def_readonly("radius",
&GeometryData::radius,
"Vector of radius of bodies, i.e. the distance between the further point of the geometry object from the joint center.\n"
"note: This radius information might be usuful in continuous collision checking")
#endif // PINOCCHIO_WITH_HPP_FCL
.def("fillInnerOuterObjectMaps",
&GeometryData::fillInnerOuterObjectMaps,
bp::args("self","geometry_model"),
"Fill inner and outer objects maps")
.def("activateCollisionPair",
static_cast<void (GeometryData::*)(const PairIndex)>(&GeometryData::activateCollisionPair),
bp::args("self","pair_id"),
"Activate the collsion pair pair_id in geomModel.collisionPairs if it exists.\n"
"note: Only active pairs are check for collision and distance computations.")
.def("setGeometryCollisionStatus",
&GeometryData::setGeometryCollisionStatus,
bp::args("self","geom_model","geom_id","enable_collision"),
"Enable or disable collision for the given geometry given by its geometry id with all the other geometries registered in the list of collision pairs.")
.def("setActiveCollisionPairs",
&GeometryData::setActiveCollisionPairs,
setActiveCollisionPairs_overload(bp::args("self","geometry_model","collision_map","upper"),
"Set the collision pair association from a given input array.\n"
"Each entry of the input matrix defines the activation of a given collision pair."))
.def("deactivateCollisionPair",
&GeometryData::deactivateCollisionPair,
bp::args("self","pair_id"),
"Deactivate the collsion pair pair_id in geomModel.collisionPairs if it exists.")
.def("deactivateAllCollisionPairs",
&GeometryData::deactivateAllCollisionPairs,
bp::args("self"),
"Deactivate all collision pairs.")
#ifdef PINOCCHIO_WITH_HPP_FCL
.def("setSecurityMargins",
&GeometryData::setSecurityMargins,
setSecurityMargins_overload(bp::args("self","geometry_model","security_margin_map","upper"),
"Set the security margin of all the collision request in a row, according to the values stored in the associative map."))
#endif // PINOCCHIO_WITH_HPP_FCL
.def(bp::self == bp::self)
.def(bp::self != bp::self)
;
}
/* --- Expose --------------------------------------------------------- */
static void expose()
{
bp::class_<GeometryData>("GeometryData",
"Geometry data linked to a Geometry Model and a Data struct.",
bp::no_init)
.def(GeometryDataPythonVisitor())
.def(PrintableVisitor<GeometryData>())
.def(CopyableVisitor<GeometryData>())
.def(SerializableVisitor<GeometryData>())
;
}
protected:
BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS(setActiveCollisionPairs_overload,GeometryData::setActiveCollisionPairs,2,3)
BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS(setSecurityMargins_overload,GeometryData::setSecurityMargins,2,3)
};
}} // namespace pinocchio::python
#endif // ifndef __pinocchio_python_geometry_data_hpp__