lagadic · olivier-roussel · Mar 2, 2026 · Mar 2, 2026 · Mar 2, 2026 · Mar 2, 2026
diff --git a/CMakeLists.txt b/CMakeLists.txt
@@ -544,7 +544,7 @@ VP_OPTION(ENABLE_TEST_WITHOUT_DISPLAY      "" "" "Don't use display feature when
 VP_OPTION(ENABLE_FULL_DOC      "" "" "Build doc with internal classes that are by default not part of the doc" "" OFF)
 
 # Allow introduction of "visp" namespace. By default disabled to keep compat with previous versions
-VP_OPTION(ENABLE_VISP_NAMESPACE "" "" "Enable visp namespace" "" OFF)
+VP_OPTION(ENABLE_VISP_NAMESPACE "" "" "Enable visp namespace" "" ON)
 # Allow introduction of "explicit" keyword. By default disabled to keep compat with previous versions
 VP_OPTION(ENABLE_EXPLICIT_KEYWORD "" "" "Enable c++ explicit keyword" "" OFF)
 # Enable the vpImageTools::warp() methods

diff --git a/modules/ar/include/visp3/ar/vpPanda3DFrameworkManager.h b/modules/ar/include/visp3/ar/vpPanda3DFrameworkManager.h
@@ -38,9 +38,9 @@
 #include <pandaFramework.h>
 #include <pandaSystem.h>
 
+BEGIN_VISP_NAMESPACE
 class vpPanda3DBaseRenderer;
 
-BEGIN_VISP_NAMESPACE
 /**
  * \ingroup group_ar_renderer_panda3d
  *

diff --git a/modules/core/include/visp3/core/vpImageTools.h b/modules/core/include/visp3/core/vpImageTools.h
@@ -1528,9 +1528,10 @@ inline void vpImageTools::resize(const vpImage<vpRGBa> &I, vpImage<vpRGBa> &Ires
 }
 #endif
 
+END_VISP_NAMESPACE
+
 #ifdef ENABLE_IMAGE_TOOLS_WARP
 #include <visp3/core/vpImageTools_warp.h>
 #endif
 
-END_VISP_NAMESPACE
 #endif
diff --git a/modules/core/include/visp3/core/vpImageTools_warp.h b/modules/core/include/visp3/core/vpImageTools_warp.h
@@ -37,6 +37,7 @@
 // Warning: this file shouldn't be included by the user. Internal usage only to reduce length of vpImage.h
 #include <visp3/core/vpImageTools.h>
 
+BEGIN_VISP_NAMESPACE
 /*!
   Apply a warping (affine or perspective) transformation to an image.
 
@@ -730,5 +731,6 @@ inline void vpImageTools::warpLinear(const vpImage<vpRGBa> &src, const vpMatrix
     }
   }
 }
+END_VISP_NAMESPACE
 
 #endif
diff --git a/modules/core/include/visp3/core/vpMunkres.h b/modules/core/include/visp3/core/vpMunkres.h
@@ -69,8 +69,9 @@ class VISP_EXPORT vpMunkres
   static std::vector<std::pair<unsigned int, unsigned int> > run(std::vector<std::vector<Type> > costs);
 
 private:
-  enum ZERO_T : unsigned int;
-  enum STEP_T : unsigned int;
+  enum ZERO_T : unsigned int { NA = 0, STARRED = 1, PRIMED = 2 };
+
+  enum STEP_T : unsigned int { ENTRY = 0, ONE = 1, TWO = 2, THREE = 3, FOUR = 4, FIVE = 5, SIX = 6, DONE };
 
   // Init
   template <typename Type> static void padCostMatrix(std::vector<std::vector<Type> > &costs);
@@ -116,10 +117,6 @@ class VISP_EXPORT vpMunkres
   static constexpr auto ZeroEpsilon { 1e-6 };
 };
 
-enum vpMunkres::ZERO_T : unsigned int { NA = 0, STARRED = 1, PRIMED = 2 };
-
-enum vpMunkres::STEP_T : unsigned int { ENTRY = 0, ONE = 1, TWO = 2, THREE = 3, FOUR = 4, FIVE = 5, SIX = 6, DONE };
-
 /*!
  * Ensure that the cost matrix is square by the addition of dummy rows/columns.
  *

diff --git a/modules/gui/include/visp3/gui/vpD3DRenderer.h b/modules/gui/include/visp3/gui/vpD3DRenderer.h
@@ -204,9 +204,9 @@ class VISP_EXPORT vpD3DRenderer : public vpWin32Renderer
 
   unsigned int supPowerOf2(unsigned int n);
 };
+END_VISP_NAMESPACE
 #endif
 
-END_VISP_NAMESPACE
 
 #endif
 #endif
diff --git a/modules/python/bindings/include/blob.hpp b/modules/python/bindings/include/blob.hpp
@@ -43,8 +43,12 @@
 
 namespace py = pybind11;
 
-void bindings_vpDot2(py::class_<vpDot2, std::shared_ptr<vpDot2>, vpTracker> &pyDot2)
+void bindings_vpDot2(py::class_<VISP_NAMESPACE_ADDRESSING vpDot2, std::shared_ptr<VISP_NAMESPACE_ADDRESSING vpDot2>, VISP_NAMESPACE_ADDRESSING vpTracker> &pyDot2)
 {
+#ifdef ENABLE_VISP_NAMESPACE
+  using namespace VISP_NAMESPACE_NAME;
+#endif
+
   pyDot2.def_static("defineDots", [](std::vector<vpDot2> &dots,
                                      const std::string &dotFile,
                                      vpImage<unsigned char> &I,

diff --git a/modules/python/bindings/include/core/arrays.hpp b/modules/python/bindings/include/core/arrays.hpp
@@ -55,50 +55,50 @@
 template<typename T> py::buffer_info get_buffer_info(T &) = delete;
 template<typename T,
   template <typename> class Array,
-  typename std::enable_if<std::is_same<vpArray2D<T>, Array<T>>::value, bool>::type = true>
+  typename std::enable_if<std::is_same<VISP_NAMESPACE_ADDRESSING vpArray2D<T>, Array<T>>::value, bool>::type = true>
 py::buffer_info get_buffer_info(Array<T> &array)
 {
   return make_array_buffer<T, 2>(array.data, { array.getRows(), array.getCols() }, false);
 }
 
 template<>
-py::buffer_info get_buffer_info(vpMatrix &array)
+py::buffer_info get_buffer_info(VISP_NAMESPACE_ADDRESSING vpMatrix &array)
 {
   return make_array_buffer<double, 2>(array.data, { array.getRows(), array.getCols() }, false);
 }
 
 template<>
-py::buffer_info get_buffer_info(vpColVector &array)
+py::buffer_info get_buffer_info(VISP_NAMESPACE_ADDRESSING vpColVector &array)
 {
   return make_array_buffer<double, 1>(array.data, { array.getRows() }, false);
 }
 template<>
-py::buffer_info get_buffer_info(vpRowVector &array)
+py::buffer_info get_buffer_info(VISP_NAMESPACE_ADDRESSING vpRowVector &array)
 {
   return make_array_buffer<double, 1>(array.data, { array.getCols() }, false);
 }
 template<>
-py::buffer_info get_buffer_info(vpTranslationVector &array)
+py::buffer_info get_buffer_info(VISP_NAMESPACE_ADDRESSING vpTranslationVector &array)
 {
   return make_array_buffer<double, 1>(array.data, { 3 }, false);
 }
 template<>
-py::buffer_info get_buffer_info(vpPoseVector &array)
+py::buffer_info get_buffer_info(VISP_NAMESPACE_ADDRESSING vpPoseVector &array)
 {
   return make_array_buffer<double, 1>(array.data, { 6 }, false);
 }
 template<>
-py::buffer_info get_buffer_info(vpRotationVector &array)
+py::buffer_info get_buffer_info(VISP_NAMESPACE_ADDRESSING vpRotationVector &array)
 {
   return make_array_buffer<double, 1>(array.data, { array.getRows() }, false);
 }
 template<>
-py::buffer_info get_buffer_info(vpRotationMatrix &array)
+py::buffer_info get_buffer_info(VISP_NAMESPACE_ADDRESSING vpRotationMatrix &array)
 {
   return make_array_buffer<double, 2>(array.data, { array.getRows(), array.getCols() }, true);
 }
 template<>
-py::buffer_info get_buffer_info(vpHomogeneousMatrix &array)
+py::buffer_info get_buffer_info(VISP_NAMESPACE_ADDRESSING vpHomogeneousMatrix &array)
 {
   return make_array_buffer<double, 2>(array.data, { array.getRows(), array.getCols() }, true);
 }
@@ -419,8 +419,11 @@ const char *numpy_fn_doc_nonwritable = R"doc(
 )doc";
 
 template<typename T>
-void bindings_vpArray2D(py::class_<vpArray2D<T>, std::shared_ptr<vpArray2D<T>>> &pyArray2D)
+void bindings_vpArray2D(py::class_<VISP_NAMESPACE_ADDRESSING vpArray2D<T>, std::shared_ptr<VISP_NAMESPACE_ADDRESSING vpArray2D<T>>> &pyArray2D)
 {
+#ifdef ENABLE_VISP_NAMESPACE
+  using namespace VISP_NAMESPACE_NAME;
+#endif
   pyArray2D.def_buffer(&get_buffer_info<T, vpArray2D>);
 
   pyArray2D.def("numpy", [](vpArray2D<T> &self) -> np_array_cf<T> {
@@ -453,14 +456,17 @@ It cannot be resized.
 
 )doc", py::arg("np_array"), py::keep_alive<0, 1>());
 
-  define_get_item_2d_array<py::class_<vpArray2D<T>, std::shared_ptr<vpArray2D<T>>>, vpArray2D<T>, T>(pyArray2D);
-  define_set_item_2d_array<py::class_<vpArray2D<T>, std::shared_ptr<vpArray2D<T>>>, vpArray2D<T>, T>(pyArray2D);
+  define_get_item_2d_array<py::class_< vpArray2D<T>, std::shared_ptr< vpArray2D<T>>>, vpArray2D<T>, T>(pyArray2D);
+  define_set_item_2d_array<py::class_< vpArray2D<T>, std::shared_ptr< vpArray2D<T>>>, vpArray2D<T>, T>(pyArray2D);
 
 }
 
-void bindings_vpMatrix(py::class_<vpMatrix, std::shared_ptr<vpMatrix>, vpArray2D<double>> &pyMatrix)
+void bindings_vpMatrix(py::class_<VISP_NAMESPACE_ADDRESSING vpMatrix, std::shared_ptr<VISP_NAMESPACE_ADDRESSING vpMatrix>, VISP_NAMESPACE_ADDRESSING vpArray2D<double>> &pyMatrix)
 {
-  pyMatrix.def_buffer(&get_buffer_info<vpMatrix>);
+#ifdef ENABLE_VISP_NAMESPACE
+  using namespace VISP_NAMESPACE_NAME;
+#endif
+  pyMatrix.def_buffer(&get_buffer_info< vpMatrix>);
 
   pyMatrix.def("numpy", [](vpMatrix &self) -> np_array_cf<double> {
     return py::cast(self).cast<np_array_cf<double>>();
@@ -497,15 +503,17 @@ It cannot be resized.
   add_print_helper(pyMatrix, &vpMatrix::matlabPrint, "strMatlab", matlab_str_help);
   add_cpp_print_helper(pyMatrix, &vpMatrix::cppPrint);
 
-  define_get_item_2d_array<py::class_<vpMatrix, std::shared_ptr<vpMatrix>, vpArray2D<double>>, vpMatrix, double>(pyMatrix);
-  define_set_item_2d_array<py::class_<vpMatrix, std::shared_ptr<vpMatrix>, vpArray2D<double>>, vpMatrix, double>(pyMatrix);
+  define_get_item_2d_array<py::class_< vpMatrix, std::shared_ptr< vpMatrix>, vpArray2D<double>>, vpMatrix, double>(pyMatrix);
+  define_set_item_2d_array<py::class_< vpMatrix, std::shared_ptr< vpMatrix>, vpArray2D<double>>, vpMatrix, double>(pyMatrix);
 }
 
 
-void bindings_vpRotationMatrix(py::class_<vpRotationMatrix, std::shared_ptr<vpRotationMatrix>, vpArray2D<double>> &pyRotationMatrix)
+void bindings_vpRotationMatrix(py::class_<VISP_NAMESPACE_ADDRESSING vpRotationMatrix, std::shared_ptr<VISP_NAMESPACE_ADDRESSING vpRotationMatrix>, VISP_NAMESPACE_ADDRESSING vpArray2D<double>> &pyRotationMatrix)
 {
-
-  pyRotationMatrix.def_buffer(&get_buffer_info<vpRotationMatrix>);
+#ifdef ENABLE_VISP_NAMESPACE
+  using namespace VISP_NAMESPACE_NAME;
+#endif
+  pyRotationMatrix.def_buffer(&get_buffer_info< vpRotationMatrix>);
   pyRotationMatrix.def("numpy", [](vpRotationMatrix &self) -> np_array_cf<double> {
     return py::cast(self).cast<np_array_cf<double>>();
   }, numpy_fn_doc_nonwritable, py::keep_alive<0, 1>());
@@ -531,12 +539,15 @@ If it is not a rotation matrix, an exception will be raised.
 :param np_array: The numpy 1D array to copy.
 
 )doc", py::arg("np_array"));
-  define_get_item_2d_array<py::class_<vpRotationMatrix, std::shared_ptr<vpRotationMatrix>, vpArray2D<double>>, vpRotationMatrix, double>(pyRotationMatrix);
+  define_get_item_2d_array<py::class_< vpRotationMatrix, std::shared_ptr< vpRotationMatrix>, vpArray2D<double>>, vpRotationMatrix, double>(pyRotationMatrix);
 }
 
-void bindings_vpHomogeneousMatrix(py::class_<vpHomogeneousMatrix, std::shared_ptr<vpHomogeneousMatrix>, vpArray2D<double>> &pyHomogeneousMatrix)
+void bindings_vpHomogeneousMatrix(py::class_<VISP_NAMESPACE_ADDRESSING vpHomogeneousMatrix, std::shared_ptr<VISP_NAMESPACE_ADDRESSING vpHomogeneousMatrix>, VISP_NAMESPACE_ADDRESSING vpArray2D<double>> &pyHomogeneousMatrix)
 {
-  pyHomogeneousMatrix.def_buffer(get_buffer_info<vpHomogeneousMatrix>);
+#ifdef ENABLE_VISP_NAMESPACE
+  using namespace VISP_NAMESPACE_NAME;
+#endif
+  pyHomogeneousMatrix.def_buffer(get_buffer_info< vpHomogeneousMatrix>);
   pyHomogeneousMatrix.def("numpy", [](vpHomogeneousMatrix &self) -> np_array_cf<double> {
     return py::cast(self).cast<np_array_cf<double>>();
   }, numpy_fn_doc_nonwritable, py::keep_alive<0, 1>());
@@ -563,14 +574,17 @@ If it is not a homogeneous matrix, an exception will be raised.
 :param np_array: The numpy 1D array to copy.
 
 )doc", py::arg("np_array"));
-  define_get_item_2d_array<py::class_<vpHomogeneousMatrix, std::shared_ptr<vpHomogeneousMatrix>, vpArray2D<double>>, vpHomogeneousMatrix, double>(pyHomogeneousMatrix);
+  define_get_item_2d_array<py::class_< vpHomogeneousMatrix, std::shared_ptr< vpHomogeneousMatrix>, vpArray2D<double>>, vpHomogeneousMatrix, double>(pyHomogeneousMatrix);
 }
 
 
 
-void bindings_vpTranslationVector(py::class_<vpTranslationVector, std::shared_ptr<vpTranslationVector>, vpArray2D<double>> &pyTranslationVector)
+void bindings_vpTranslationVector(py::class_<VISP_NAMESPACE_ADDRESSING vpTranslationVector, std::shared_ptr<VISP_NAMESPACE_ADDRESSING vpTranslationVector>, VISP_NAMESPACE_ADDRESSING vpArray2D<double>> &pyTranslationVector)
 {
-  pyTranslationVector.def_buffer(&get_buffer_info<vpTranslationVector>);
+#ifdef ENABLE_VISP_NAMESPACE
+  using namespace VISP_NAMESPACE_NAME;
+#endif
+  pyTranslationVector.def_buffer(&get_buffer_info< vpTranslationVector>);
 
   pyTranslationVector.def("numpy", [](vpTranslationVector &self) -> np_array_cf<double> {
     return py::cast(self).cast<np_array_cf<double>>();
@@ -589,14 +603,17 @@ Construct a Translation vector by **copying** a 1D numpy array of size 3.
 :param np_array: The numpy 1D array to copy.
 
 )doc", py::arg("np_array"));
-  define_get_item_1d_array<py::class_<vpTranslationVector, std::shared_ptr<vpTranslationVector>, vpArray2D<double>>, vpTranslationVector, double>(pyTranslationVector);
-  define_set_item_1d_array<py::class_<vpTranslationVector, std::shared_ptr<vpTranslationVector>, vpArray2D<double>>, vpTranslationVector, double>(pyTranslationVector);
+  define_get_item_1d_array<py::class_< vpTranslationVector, std::shared_ptr< vpTranslationVector>, vpArray2D<double>>, vpTranslationVector, double>(pyTranslationVector);
+  define_set_item_1d_array<py::class_< vpTranslationVector, std::shared_ptr< vpTranslationVector>, vpArray2D<double>>, vpTranslationVector, double>(pyTranslationVector);
 }
 
 
-void bindings_vpColVector(py::class_<vpColVector, std::shared_ptr<vpColVector>, vpArray2D<double>> &pyColVector)
+void bindings_vpColVector(py::class_<VISP_NAMESPACE_ADDRESSING vpColVector, std::shared_ptr<VISP_NAMESPACE_ADDRESSING vpColVector>, VISP_NAMESPACE_ADDRESSING vpArray2D<double>> &pyColVector)
 {
-  pyColVector.def_buffer(&get_buffer_info<vpColVector>);
+#ifdef ENABLE_VISP_NAMESPACE
+  using namespace VISP_NAMESPACE_NAME;
+#endif
+  pyColVector.def_buffer(&get_buffer_info< vpColVector>);
 
   pyColVector.def("numpy", [](vpColVector &self) -> np_array_cf<double> {
     return py::cast(self).cast<np_array_cf<double>>();
@@ -628,8 +645,8 @@ It cannot be resized.
 
 )doc", py::arg("np_array"), py::keep_alive<0, 1>());
 
-  define_get_item_1d_array<py::class_<vpColVector, std::shared_ptr<vpColVector>, vpArray2D<double>>, vpColVector, double>(pyColVector);
-  define_set_item_1d_array<py::class_<vpColVector, std::shared_ptr<vpColVector>, vpArray2D<double>>, vpColVector, double>(pyColVector);
+  define_get_item_1d_array<py::class_< vpColVector, std::shared_ptr< vpColVector>, vpArray2D<double>>, vpColVector, double>(pyColVector);
+  define_set_item_1d_array<py::class_< vpColVector, std::shared_ptr< vpColVector>, vpArray2D<double>>, vpColVector, double>(pyColVector);
 
   add_print_helper(pyColVector, &vpColVector::csvPrint, "strCsv", csv_str_help);
   add_print_helper(pyColVector, &vpColVector::maplePrint, "strMaple", maple_str_help);
@@ -638,11 +655,14 @@ It cannot be resized.
 
 }
 
-void bindings_vpRowVector(py::class_<vpRowVector, std::shared_ptr<vpRowVector>, vpArray2D<double>> &pyRowVector)
+void bindings_vpRowVector(py::class_<VISP_NAMESPACE_ADDRESSING vpRowVector, std::shared_ptr<VISP_NAMESPACE_ADDRESSING vpRowVector>, VISP_NAMESPACE_ADDRESSING vpArray2D<double>> &pyRowVector)
 {
-  pyRowVector.def_buffer(&get_buffer_info<vpRowVector>);
+#ifdef ENABLE_VISP_NAMESPACE
+  using namespace VISP_NAMESPACE_NAME;
+#endif
+  pyRowVector.def_buffer(&get_buffer_info< vpRowVector>);
   pyRowVector.def("numpy", [](vpRowVector &self) -> np_array_cf<double> {
-    return np_array_cf<double>(get_buffer_info<vpRowVector>(self), py::cast(self));
+    return np_array_cf<double>(get_buffer_info< vpRowVector>(self), py::cast(self));
   }, numpy_fn_doc_writable, py::keep_alive<0, 1>());
   pyRowVector.def(py::init([](np_array_cf<double> np_array) {
     verify_array_shape_and_dims(np_array, 1, "ViSP row vector");
@@ -670,18 +690,21 @@ It cannot be resized.
 
 )doc", py::arg("np_array"), py::keep_alive<0, 1>());
 
-  define_get_item_1d_array<py::class_<vpRowVector, std::shared_ptr<vpRowVector>, vpArray2D<double>>, vpRowVector, double>(pyRowVector);
-  define_set_item_1d_array<py::class_<vpRowVector, std::shared_ptr<vpRowVector>, vpArray2D<double>>, vpRowVector, double>(pyRowVector);
+  define_get_item_1d_array<py::class_< vpRowVector, std::shared_ptr< vpRowVector>, vpArray2D<double>>, vpRowVector, double>(pyRowVector);
+  define_set_item_1d_array<py::class_< vpRowVector, std::shared_ptr< vpRowVector>, vpArray2D<double>>, vpRowVector, double>(pyRowVector);
 
   add_print_helper(pyRowVector, &vpRowVector::csvPrint, "strCsv", csv_str_help);
   add_print_helper(pyRowVector, &vpRowVector::maplePrint, "strMaple", maple_str_help);
   add_print_helper(pyRowVector, &vpRowVector::matlabPrint, "strMatlab", matlab_str_help);
   add_cpp_print_helper(pyRowVector, &vpRowVector::cppPrint);
 }
 
-void bindings_vpPoseVector(py::class_<vpPoseVector, std::shared_ptr<vpPoseVector>, vpArray2D<double>> &pyPoseVector)
+void bindings_vpPoseVector(py::class_<VISP_NAMESPACE_ADDRESSING vpPoseVector, std::shared_ptr<VISP_NAMESPACE_ADDRESSING vpPoseVector>, VISP_NAMESPACE_ADDRESSING vpArray2D<double>> &pyPoseVector)
 {
-  pyPoseVector.def_buffer(&get_buffer_info<vpPoseVector>);
+#ifdef ENABLE_VISP_NAMESPACE
+  using namespace VISP_NAMESPACE_NAME;
+#endif
+  pyPoseVector.def_buffer(&get_buffer_info< vpPoseVector>);
 
   pyPoseVector.def("numpy", [](vpPoseVector &self) -> np_array_cf<double> {
     return py::cast(self).cast<np_array_cf<double>>();
@@ -699,12 +722,16 @@ Construct a pose vector by **copying** a 1D numpy array.
 :param np_array: The numpy 1D array to copy.
 
 )doc", py::arg("np_array"));
-  define_get_item_1d_array<py::class_<vpPoseVector, std::shared_ptr<vpPoseVector>, vpArray2D<double>>, vpPoseVector, double>(pyPoseVector);
-  define_set_item_1d_array<py::class_<vpPoseVector, std::shared_ptr<vpPoseVector>, vpArray2D<double>>, vpPoseVector, double>(pyPoseVector);
+  define_get_item_1d_array<py::class_< vpPoseVector, std::shared_ptr< vpPoseVector>, vpArray2D<double>>, vpPoseVector, double>(pyPoseVector);
+  define_set_item_1d_array<py::class_< vpPoseVector, std::shared_ptr< vpPoseVector>, vpArray2D<double>>, vpPoseVector, double>(pyPoseVector);
 }
 
-void bindings_vpRotationVector(py::class_<vpRotationVector, std::shared_ptr<vpRotationVector>, vpArray2D<double>> &pyRotationVector)
+void bindings_vpRotationVector(py::class_<VISP_NAMESPACE_ADDRESSING vpRotationVector, std::shared_ptr<VISP_NAMESPACE_ADDRESSING vpRotationVector>, VISP_NAMESPACE_ADDRESSING vpArray2D<double>> &pyRotationVector)
 {
+#ifdef ENABLE_VISP_NAMESPACE
+  using namespace VISP_NAMESPACE_NAME;
+#endif
+
   pyRotationVector.def_buffer(&get_buffer_info<vpRotationVector>);
 
   pyRotationVector.def("numpy", [](vpRotationVector &self) -> np_array_cf<double> {
@@ -723,8 +750,8 @@ Construct a rotaiton vector by **copying** a 1D numpy array.
 :param np_array: The numpy 1D array to copy.
 
 )doc", py::arg("np_array"));
-  define_get_item_1d_array<py::class_<vpRotationVector, std::shared_ptr<vpRotationVector>, vpArray2D<double>>, vpPoseVector, double>(pyRotationVector);
-  define_set_item_1d_array<py::class_<vpRotationVector, std::shared_ptr<vpRotationVector>, vpArray2D<double>>, vpPoseVector, double>(pyRotationVector);
+  define_get_item_1d_array<py::class_< vpRotationVector, std::shared_ptr< vpRotationVector>, vpArray2D<double>>, vpPoseVector, double>(pyRotationVector);
+  define_set_item_1d_array<py::class_< vpRotationVector, std::shared_ptr< vpRotationVector>, vpArray2D<double>>, vpPoseVector, double>(pyRotationVector);
 }
 
 

diff --git a/modules/python/bindings/include/core/display.hpp b/modules/python/bindings/include/core/display.hpp
@@ -43,9 +43,11 @@
 
 namespace py = pybind11;
 
-void bindings_vpDisplay(py::class_<vpDisplay, std::shared_ptr<vpDisplay>> &pyDisplay)
+void bindings_vpDisplay(py::class_<VISP_NAMESPACE_ADDRESSING vpDisplay, std::shared_ptr<VISP_NAMESPACE_ADDRESSING vpDisplay>> &pyDisplay)
 {
-
+#ifdef ENABLE_VISP_NAMESPACE
+  using namespace VISP_NAMESPACE_NAME;
+#endif
   pyDisplay.def_static("displayCrosses",
   [](const vpImage<vpRGBa> &I,
      const py::array_t<int, py::array::c_style> &is,