[Python] Add copyable method to create a raw copy of Spatial classes

[Python] Introduce struct to expose both std::vector and aligned_vector

all: change __se3_* for __pinocchio_* for pragma once

all: change namespace from se3 to pinocchio

The previous se3 namespace is now deprecated but can still be used

all: remove license from files

[bindings][pickling] add support for vector<T> aligned_vector<T> map<T> pickling.
update model and data classes to make their members picklable

[bindings][pickling] 1) fix includes. make picklemap borrow from picklevector

2) use pickle support for rest of data and some more of model vectors

python: add converter from Python list to std::vector or aligned_vector

python: fix issue on GCC related to namespace bp

python: fix namespace issue

python/vector: add conversion tolist for std::vector

python/utils: return by reference when creating list

python/utils: add return of the class for StdVector helpers

python: fix return type

python/pickle: fix pickling of std::map

python: fix potential bug with C++11

python: make the code compliant for casadi bindings

python: fix arg name

python/pickle: fix compatibility issue

Compilation issues with recent version of Boost

python: add copy constructor and method to std::vector

python: expose operator{==,!=} for std::vector

Revert "python: expose operator{==,!=} for std::vector"

This reverts commit 6710dd4758791b3eee1ac444945e7f507aece7f6.

python/utils: update std-vector exposition

python: fix issues with const reference as input argument

python: fix pickling of Pinocchio data structure

copyable.hpp

+//
+// Copyright (c) 2016-2021 CNRS INRIA
+//
+
+#ifndef __pinocchio_python_utils_copyable_hpp__
+#define __pinocchio_python_utils_copyable_hpp__
+
+#include <boost/python.hpp>
+
+namespace pinocchio
+{
+  namespace python
+  {
+    
+    namespace bp = boost::python;
+    
+    ///
+    /// \brief Add the Python method copy to allow a copy of this by calling the copy constructor.
+    ///
+    template<class C>
+    struct CopyableVisitor
+    : public bp::def_visitor< CopyableVisitor<C> >
+    {
+      template<class PyClass>
+      void visit(PyClass & cl) const
+      { cl.def("copy",&copy,bp::arg("self"),"Returns a copy of *this."); }
+      
+    private:
+      static C copy(const C & self) { return C(self); }
+    };
+  } // namespace python
+} // namespace pinocchio
+
+#endif // ifndef __pinocchio_python_utils_copyable_hpp__

pickle-vector.hpp

+//
+// Copyright (c) 2019-2020 CNRS INRIA
+//
+
+#ifndef __pinocchio_python_utils_pickle_vector_hpp__
+#define __pinocchio_python_utils_pickle_vector_hpp__
+
+#include <boost/python.hpp>
+#include <boost/python/tuple.hpp>
+#include <boost/python/stl_iterator.hpp>
+
+namespace pinocchio
+{
+  namespace python
+  {
+    ///
+    /// \brief Create a pickle interface for the std::vector and aligned vector
+    ///
+    /// \tparam VecType Vector Type to pickle
+    ///
+    template<typename VecType>
+    struct PickleVector : boost::python::pickle_suite
+    {
+      static boost::python::tuple getinitargs(const VecType&)
+      { return boost::python::make_tuple(); }
+      
+      static boost::python::tuple getstate(boost::python::object op)
+      {
+        return boost::python::make_tuple(boost::python::list(boost::python::extract<const VecType&>(op)()));
+      }
+      
+      static void setstate(boost::python::object op, boost::python::tuple tup)
+      {
+        if(boost::python::len(tup) > 0)
+        {
+          VecType & o = boost::python::extract<VecType&>(op)();
+          boost::python::stl_input_iterator<typename VecType::value_type> begin(tup[0]), end;
+          while(begin != end)
+          {
+             o.push_back(*begin);
+             ++begin;
+          }
+        }
+      }
+      
+      static bool getstate_manages_dict() { return true; }
+    };
+  }
+}
+
+#endif // ifndef __pinocchio_python_utils_pickle_vector_hpp__

std-aligned-vector.hpp

+//
+// Copyright (c) 2016-2022 CNRS INRIA
+//
+
+#ifndef __pinocchio_python_utils_std_aligned_vector_hpp__
+#define __pinocchio_python_utils_std_aligned_vector_hpp__
+
+#include <boost/python.hpp>
+#include <string>
+
+#include "pinocchio/container/aligned-vector.hpp"
+
+#include "pinocchio/bindings/python/utils/pickle-vector.hpp"
+#include "pinocchio/bindings/python/utils/std-vector.hpp"
+
+namespace pinocchio
+{
+  namespace python
+  {
+    
+    ///
+    /// \brief Expose an container::aligned_vector from a type given as template argument.
+    ///
+    /// \tparam T Type to expose as container::aligned_vector<T>.
+    /// \tparam EnableFromPythonListConverter Enables the conversion from a Python list to a container::aligned_vector<T>.
+    ///
+    /// \sa StdAlignedVectorPythonVisitor
+    ///
+    template<class T, bool NoProxy = false, bool EnableFromPythonListConverter = true>
+    struct StdAlignedVectorPythonVisitor
+    : public ::boost::python::vector_indexing_suite<typename container::aligned_vector<T>,NoProxy, internal::contains_vector_derived_policies<typename container::aligned_vector<T>,NoProxy> >
+    , public StdContainerFromPythonList< container::aligned_vector<T> >
+    {
+      typedef container::aligned_vector<T> vector_type;
+      typedef StdContainerFromPythonList<vector_type,NoProxy> FromPythonListConverter;
+      typedef T value_type;
+      
+      static void expose(const std::string & class_name,
+                         const std::string & doc_string = "")
+      {
+        expose(class_name,doc_string,EmptyPythonVisitor());
+      }
+      
+      template<typename VisitorDerived>
+      static void expose(const std::string & class_name,
+                         const boost::python::def_visitor<VisitorDerived> & visitor)
+      {
+        expose(class_name,"",visitor);
+      }
+      
+      template<typename VisitorDerived>
+      static void expose(const std::string & class_name,
+                         const std::string & doc_string,
+                         const boost::python::def_visitor<VisitorDerived> & visitor)
+      {
+        namespace bp = boost::python;
+        if(!register_symbolic_link_to_registered_type<vector_type>())
+        {
+          bp::class_<vector_type> cl(class_name.c_str(),doc_string.c_str());
+          cl
+          .def(StdAlignedVectorPythonVisitor())
+          
+          .def(bp::init<size_t, const value_type &>(bp::args("self","size","value"),"Constructor from a given size and a given value."))
+          .def(bp::init<const vector_type &>(bp::args("self","other"),"Copy constructor"))
+          
+          .def("tolist",&FromPythonListConverter::tolist,bp::arg("self"),
+               "Returns the aligned_vector as a Python list.")
+          .def(visitor)
+#ifndef PINOCCHIO_PYTHON_NO_SERIALIZATION
+          .def_pickle(PickleVector<vector_type>())
+#endif
+          .def(CopyableVisitor<vector_type>())
+          ;
+          
+          // Register conversion
+          if(EnableFromPythonListConverter)
+            FromPythonListConverter::register_converter();
+        }
+      }
+    };
+  } // namespace python
+} // namespace pinocchio
+
+#endif // ifndef __pinocchio_python_utils_std_aligned_vector_hpp__