diff --git a/CMakeLists.txt b/CMakeLists.txt
index 67b4f47663..37e316435c 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -539,7 +539,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
index 49f0b6a850..2650e6d8e6 100644
--- 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
index 814ebbccf1..3188fef91a 100644
--- 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
index b6826a32b5..710e72251e 100644
--- 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
index fb38a33fe6..882f12b106 100644
--- 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
index 47417ea3d5..7d5154d296 100644
--- 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
index 99b7d50039..9d51a4233d 100644
--- 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
index 33f7559ad6..398e28ac24 100644
--- 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,8 +690,8 @@ 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);
@@ -679,9 +699,12 @@ It cannot be resized.
   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
index c5ab28a751..71b55800fe 100644
--- 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,
diff --git a/modules/python/bindings/include/core/image_conversions.hpp b/modules/python/bindings/include/core/image_conversions.hpp
index 3cc971490f..423d9c80d3 100644
--- a/modules/python/bindings/include/core/image_conversions.hpp
+++ b/modules/python/bindings/include/core/image_conversions.hpp
@@ -116,7 +116,7 @@ struct SimpleConversionStruct
   unsigned int srcBytesPerPixel;
   unsigned int destBytesPerPixel;
 
-  void add_conversion_binding(py::class_<vpImageConvert, std::shared_ptr<vpImageConvert>> &pyImageConvert)
+  void add_conversion_binding(py::class_<VISP_NAMESPACE_ADDRESSING vpImageConvert, std::shared_ptr<VISP_NAMESPACE_ADDRESSING vpImageConvert>> &pyImageConvert)
   {
 
     pyImageConvert.def_static(name.c_str(), [*this](py::array_t<unsigned char, py::array::c_style> &src,
@@ -142,7 +142,7 @@ struct SimpleConversionStruct<ConversionFunction2DWithFlip>
   unsigned int srcBytesPerPixel;
   unsigned int destBytesPerPixel;
 
-  void add_conversion_binding(py::class_<vpImageConvert, std::shared_ptr<vpImageConvert>> &pyImageConvert)
+  void add_conversion_binding(py::class_<VISP_NAMESPACE_ADDRESSING vpImageConvert, std::shared_ptr<VISP_NAMESPACE_ADDRESSING vpImageConvert>> &pyImageConvert)
   {
     pyImageConvert.def_static(name.c_str(), [*this](py::array_t<unsigned char, py::array::c_style> &src,
                                                     py::array_t<unsigned char, py::array::c_style> &dest, bool flip) {
@@ -167,7 +167,7 @@ struct SimpleConversionStruct<ConversionFunction2DWithFlipAndNThreads>
   unsigned int srcBytesPerPixel;
   unsigned int destBytesPerPixel;
 
-  void add_conversion_binding(py::class_<vpImageConvert, std::shared_ptr<vpImageConvert>> &pyImageConvert)
+  void add_conversion_binding(py::class_<VISP_NAMESPACE_ADDRESSING vpImageConvert, std::shared_ptr<VISP_NAMESPACE_ADDRESSING vpImageConvert>> &pyImageConvert)
   {
     pyImageConvert.def_static(name.c_str(), [*this](py::array_t<unsigned char, py::array::c_style> &src,
                                                     py::array_t<unsigned char, py::array::c_style> &dest, bool flip, unsigned int threads) {
@@ -192,7 +192,7 @@ struct SimpleConversionStruct<ConversionFunction2DWithNThreads>
   unsigned int srcBytesPerPixel;
   unsigned int destBytesPerPixel;
 
-  void add_conversion_binding(py::class_<vpImageConvert, std::shared_ptr<vpImageConvert>> &pyImageConvert)
+  void add_conversion_binding(py::class_<VISP_NAMESPACE_ADDRESSING vpImageConvert, std::shared_ptr<VISP_NAMESPACE_ADDRESSING vpImageConvert>> &pyImageConvert)
   {
     pyImageConvert.def_static(name.c_str(), [*this](py::array_t<unsigned char, py::array::c_style> &src,
                                                     py::array_t<unsigned char, py::array::c_style> &dest, unsigned int threads) {
@@ -218,7 +218,7 @@ struct ConversionFromYUVLike
 
   unsigned int destBytesPerPixel;
 
-  void add_conversion_binding(py::class_<vpImageConvert, std::shared_ptr<vpImageConvert>> &pyImageConvert)
+  void add_conversion_binding(py::class_<VISP_NAMESPACE_ADDRESSING vpImageConvert, std::shared_ptr<VISP_NAMESPACE_ADDRESSING vpImageConvert>> &pyImageConvert)
   {
     pyImageConvert.def_static(name.c_str(), [this](py::array_t<unsigned char, py::array::c_style> &src,
                                                    py::array_t<unsigned char, py::array::c_style> &dest) {
@@ -294,7 +294,7 @@ void rgb_or_rgba_to_hsv_verification(const py::buffer_info &bufsrc, const py::bu
   }
 }
 
-void add_hsv_double_to_rgb_or_rgba_binding(py::class_<vpImageConvert, std::shared_ptr<vpImageConvert>> &pyImageConvert,
+void add_hsv_double_to_rgb_or_rgba_binding(py::class_<VISP_NAMESPACE_ADDRESSING vpImageConvert, std::shared_ptr<VISP_NAMESPACE_ADDRESSING vpImageConvert>> &pyImageConvert,
                                     void (*fn)(const double *, const double *, const double *, unsigned char *, unsigned int), const char *name, const unsigned destBytes)
 {
   pyImageConvert.def_static(name, [fn, destBytes](py::array_t<double, py::array::c_style> &src,
@@ -313,7 +313,7 @@ void add_hsv_double_to_rgb_or_rgba_binding(py::class_<vpImageConvert, std::share
   }, "Convert from HSV Planes (as a 3 x H x W array) to a an RGB/RGBA array (as an H x W x 3 or H x W x 4 array)", py::arg("hsv"), py::arg("rgb"));
 }
 
-void add_hsv_uchar_to_rgb_or_rgba_binding(py::class_<vpImageConvert, std::shared_ptr<vpImageConvert>> &pyImageConvert,
+void add_hsv_uchar_to_rgb_or_rgba_binding(py::class_<VISP_NAMESPACE_ADDRESSING vpImageConvert, std::shared_ptr<VISP_NAMESPACE_ADDRESSING vpImageConvert>> &pyImageConvert,
                                     void (*fn)(const unsigned char *, const unsigned char *, const unsigned char *, unsigned char *, unsigned int, bool), const char *name, const unsigned destBytes)
 {
   pyImageConvert.def_static(name, [fn, destBytes](py::array_t<unsigned char, py::array::c_style> &src,
@@ -332,7 +332,7 @@ void add_hsv_uchar_to_rgb_or_rgba_binding(py::class_<vpImageConvert, std::shared
   }, "Convert from HSV Planes (as a 3 x H x W array) to a an RGB/RGBA array (as an H x W x 3 or H x W x 4 array)", py::arg("hsv"), py::arg("rgb"), py::arg("h_full") = true);
 }
 
-void add_rgb_or_rgba_uchar_to_hsv_binding(py::class_<vpImageConvert, std::shared_ptr<vpImageConvert>> &pyImageConvert,
+void add_rgb_or_rgba_uchar_to_hsv_binding(py::class_<VISP_NAMESPACE_ADDRESSING vpImageConvert, std::shared_ptr<VISP_NAMESPACE_ADDRESSING vpImageConvert>> &pyImageConvert,
                                     void (*fn)(const unsigned char *, unsigned char *, unsigned char *, unsigned char *, unsigned int, bool), const char *name, const unsigned destBytes)
 {
   pyImageConvert.def_static(name, [fn, destBytes](py::array_t<unsigned char, py::array::c_style> &src,
@@ -352,7 +352,7 @@ void add_rgb_or_rgba_uchar_to_hsv_binding(py::class_<vpImageConvert, std::shared
   }, "Convert from HSV Planes (as a 3 x H x W array) to a an RGB/RGBA array (as an H x W x 3 or H x W x 4 array)", py::arg("rgb"), py::arg("hsv"), py::arg("h_full") = true);
 }
 
-void add_rgb_or_rgba_double_to_hsv_binding(py::class_<vpImageConvert, std::shared_ptr<vpImageConvert>> &pyImageConvert,
+void add_rgb_or_rgba_double_to_hsv_binding(py::class_<VISP_NAMESPACE_ADDRESSING vpImageConvert, std::shared_ptr<VISP_NAMESPACE_ADDRESSING vpImageConvert>> &pyImageConvert,
                                     void (*fn)(const unsigned char *, double *, double *, double *, unsigned int), const char *name, const unsigned destBytes)
 {
   pyImageConvert.def_static(name, [fn, destBytes](py::array_t<unsigned char, py::array::c_style> &src,
@@ -373,7 +373,7 @@ void add_rgb_or_rgba_double_to_hsv_binding(py::class_<vpImageConvert, std::share
 
 /* Demosaicing implem */
 template <class DataType>
-void add_demosaic_to_rgba_fn(py::class_<vpImageConvert, std::shared_ptr<vpImageConvert>> &pyImageConvert, void (*fn)(const DataType *, DataType *, unsigned int, unsigned int, unsigned int), const char *name)
+void add_demosaic_to_rgba_fn(py::class_<VISP_NAMESPACE_ADDRESSING vpImageConvert, std::shared_ptr<VISP_NAMESPACE_ADDRESSING vpImageConvert>> &pyImageConvert, void (*fn)(const DataType *, DataType *, unsigned int, unsigned int, unsigned int), const char *name)
 {
   pyImageConvert.def_static(name, [fn](py::array_t<DataType, py::array::c_style> &src,
                                        py::array_t<DataType, py::array::c_style> &dest,
@@ -407,8 +407,11 @@ void add_demosaic_to_rgba_fn(py::class_<vpImageConvert, std::shared_ptr<vpImageC
 
 }
 
-void bindings_vpImageConvert(py::class_<vpImageConvert, std::shared_ptr<vpImageConvert>> &pyImageConvert)
+void bindings_vpImageConvert(py::class_<VISP_NAMESPACE_ADDRESSING vpImageConvert, std::shared_ptr<VISP_NAMESPACE_ADDRESSING vpImageConvert>> &pyImageConvert)
 {
+#ifdef ENABLE_VISP_NAMESPACE
+  using namespace VISP_NAMESPACE_NAME;
+#endif
   // Simple conversions where the size input is a single argument
   {
     std::vector<SimpleConversionStruct<ConversionFunction1D>> conversions = {
diff --git a/modules/python/bindings/include/core/images.hpp b/modules/python/bindings/include/core/images.hpp
index 7c2606a4af..e834981514 100644
--- a/modules/python/bindings/include/core/images.hpp
+++ b/modules/python/bindings/include/core/images.hpp
@@ -53,8 +53,12 @@ const char *numpy_fn_doc_image = R"doc(
  * Image 2D indexing
  */
 template<typename T, typename NpRep>
-void define_get_item_2d_image(py::class_<vpImage<T>, std::shared_ptr<vpImage<T>>> &pyClass)
+void define_get_item_2d_image(py::class_<VISP_NAMESPACE_ADDRESSING vpImage<T>, std::shared_ptr<VISP_NAMESPACE_ADDRESSING vpImage<T>>> &pyClass)
 {
+#ifdef ENABLE_VISP_NAMESPACE
+  using namespace VISP_NAMESPACE_NAME;
+#endif
+
   pyClass.def("__getitem__", [](const vpImage<T> &self, std::pair<int, int> pair) -> T {
     int i = pair.first, j = pair.second;
     const int rows = (int)self.getRows(), cols = (int)self.getCols();
@@ -97,8 +101,11 @@ void define_get_item_2d_image(py::class_<vpImage<T>, std::shared_ptr<vpImage<T>>
  * Image 2D indexing
  */
 template<typename T, typename NpRep>
-void define_set_item_2d_image(py::class_<vpImage<T>, std::shared_ptr<vpImage<T>>> &pyClass, unsigned int componentsPerPixel)
+void define_set_item_2d_image(py::class_<VISP_NAMESPACE_ADDRESSING vpImage<T>, std::shared_ptr<VISP_NAMESPACE_ADDRESSING vpImage<T>>> &pyClass, unsigned int componentsPerPixel)
 {
+#ifdef ENABLE_VISP_NAMESPACE
+  using namespace VISP_NAMESPACE_NAME;
+#endif
   pyClass.def("__setitem__", [](vpImage<T> &self, std::pair<int, int> pair, const T &value) {
     int i = pair.first, j = pair.second;
     const int rows = (int)self.getRows(), cols = (int)self.getCols();
@@ -260,8 +267,11 @@ void define_set_item_2d_image(py::class_<vpImage<T>, std::shared_ptr<vpImage<T>>
    */
 template<typename T>
 typename std::enable_if<std::is_fundamental<T>::value, void>::type
-bindings_vpImage(py::class_<vpImage<T>, std::shared_ptr<vpImage<T>>> &pyImage)
+bindings_vpImage(py::class_<VISP_NAMESPACE_ADDRESSING vpImage<T>, std::shared_ptr<VISP_NAMESPACE_ADDRESSING vpImage<T>>> &pyImage)
 {
+#ifdef ENABLE_VISP_NAMESPACE
+  using namespace VISP_NAMESPACE_NAME;
+#endif
   pyImage.def_buffer([](vpImage<T> &image) -> py::buffer_info {
     return make_array_buffer<T, 2>(image.bitmap, { image.getHeight(), image.getWidth() }, false);
   });
@@ -300,9 +310,12 @@ Construct an image by **copying** a 2D numpy array.
 }
 
 template<typename T>
-typename std::enable_if<std::is_same<vpRGBa, T>::value, void>::type
-bindings_vpImage(py::class_<vpImage<T>, std::shared_ptr<vpImage<T>>> &pyImage)
+typename std::enable_if<std::is_same<VISP_NAMESPACE_ADDRESSING vpRGBa, T>::value, void>::type
+bindings_vpImage(py::class_<VISP_NAMESPACE_ADDRESSING vpImage<T>, std::shared_ptr<VISP_NAMESPACE_ADDRESSING vpImage<T>>> &pyImage)
 {
+#ifdef ENABLE_VISP_NAMESPACE
+  using namespace VISP_NAMESPACE_NAME;
+#endif
   using NpRep = unsigned char;
   static_assert(sizeof(T) == 4 * sizeof(NpRep));
   pyImage.def_buffer([](vpImage<T> &image) -> py::buffer_info {
@@ -346,9 +359,12 @@ where the 4 denotes the red, green, blue and alpha components of the image.
 
 }
 template<typename T>
-typename std::enable_if<std::is_same<vpRGBf, T>::value, void>::type
-bindings_vpImage(py::class_<vpImage<T>, std::shared_ptr<vpImage<T>>> &pyImage)
+typename std::enable_if<std::is_same<VISP_NAMESPACE_ADDRESSING vpRGBf, T>::value, void>::type
+bindings_vpImage(py::class_<VISP_NAMESPACE_ADDRESSING vpImage<T>, std::shared_ptr<VISP_NAMESPACE_ADDRESSING vpImage<T>>> &pyImage)
 {
+#ifdef ENABLE_VISP_NAMESPACE
+  using namespace VISP_NAMESPACE_NAME;
+#endif
   using NpRep = float;
   static_assert(sizeof(T) == 3 * sizeof(NpRep));
   pyImage.def_buffer([](vpImage<T> &image) -> py::buffer_info {
diff --git a/modules/python/bindings/include/core/pixel_meter.hpp b/modules/python/bindings/include/core/pixel_meter.hpp
index 9d3bfb0c67..ee389c6546 100644
--- a/modules/python/bindings/include/core/pixel_meter.hpp
+++ b/modules/python/bindings/include/core/pixel_meter.hpp
@@ -44,8 +44,11 @@
 
 #include "core/utils.hpp"
 
-void bindings_vpPixelMeterConversion(py::class_<vpPixelMeterConversion, std::shared_ptr<vpPixelMeterConversion>> &pyPM)
+void bindings_vpPixelMeterConversion(py::class_<VISP_NAMESPACE_ADDRESSING vpPixelMeterConversion, std::shared_ptr<VISP_NAMESPACE_ADDRESSING vpPixelMeterConversion>> &pyPM)
 {
+#ifdef ENABLE_VISP_NAMESPACE
+  using namespace VISP_NAMESPACE_NAME;
+#endif
   pyPM.def_static("convertPoints", [](const vpCameraParameters &cam, const py::array_t<double> &us, const py::array_t<double> &vs) {
     py::buffer_info bufu = us.request(), bufv = vs.request();
     if (bufu.ndim != bufv.ndim || bufu.shape != bufv.shape) {
@@ -107,8 +110,11 @@ Example usage:
 )doc", py::arg("cam"), py::arg("us"), py::arg("vs"));
 }
 
-void bindings_vpMeterPixelConversion(py::class_<vpMeterPixelConversion, std::shared_ptr<vpMeterPixelConversion>> &pyMP)
+void bindings_vpMeterPixelConversion(py::class_<VISP_NAMESPACE_ADDRESSING vpMeterPixelConversion, std::shared_ptr<VISP_NAMESPACE_ADDRESSING vpMeterPixelConversion>> &pyMP)
 {
+#ifdef ENABLE_VISP_NAMESPACE
+  using namespace VISP_NAMESPACE_NAME;
+#endif
   pyMP.def_static("convertPoints", [](const vpCameraParameters &cam, const py::array_t<double> &xs, const py::array_t<double> &ys) {
     py::buffer_info bufx = xs.request(), bufy = ys.request();
     if (bufx.ndim != bufy.ndim || bufx.shape != bufy.shape) {
diff --git a/modules/python/bindings/include/detection.hpp b/modules/python/bindings/include/detection.hpp
index 92719c0651..56cb7b44a3 100644
--- a/modules/python/bindings/include/detection.hpp
+++ b/modules/python/bindings/include/detection.hpp
@@ -48,8 +48,12 @@
 
 namespace py = pybind11;
 
-void bindings_vpDetectorAprilTag(py::class_<vpDetectorAprilTag, std::shared_ptr<vpDetectorAprilTag>, vpDetectorBase> &pyAprilTag)
+void bindings_vpDetectorAprilTag(py::class_<VISP_NAMESPACE_ADDRESSING vpDetectorAprilTag, std::shared_ptr<VISP_NAMESPACE_ADDRESSING vpDetectorAprilTag>, VISP_NAMESPACE_ADDRESSING vpDetectorBase> &pyAprilTag)
 {
+#ifdef ENABLE_VISP_NAMESPACE
+  using namespace VISP_NAMESPACE_NAME;
+#endif
+
   pyAprilTag.def("detect",
    [](vpDetectorAprilTag &self, const vpImage<unsigned char> &I, double tagSize, const vpCameraParameters &cam) -> std::tuple<bool, std::vector<vpHomogeneousMatrix>> {
      std::vector<vpHomogeneousMatrix> cMos;
diff --git a/modules/python/bindings/include/mbt.hpp b/modules/python/bindings/include/mbt.hpp
index 203f53ad11..bb9d9e58ae 100644
--- a/modules/python/bindings/include/mbt.hpp
+++ b/modules/python/bindings/include/mbt.hpp
@@ -42,8 +42,12 @@
 
 namespace py = pybind11;
 
-void bindings_vpMbGenericTracker(py::class_<vpMbGenericTracker, std::shared_ptr<vpMbGenericTracker>, vpMbTracker> &pyMbGenericTracker)
+void bindings_vpMbGenericTracker(py::class_<VISP_NAMESPACE_ADDRESSING vpMbGenericTracker, std::shared_ptr<VISP_NAMESPACE_ADDRESSING vpMbGenericTracker>, VISP_NAMESPACE_ADDRESSING vpMbTracker> &pyMbGenericTracker)
 {
+#ifdef ENABLE_VISP_NAMESPACE
+  using namespace VISP_NAMESPACE_NAME;
+#endif
+
   pyMbGenericTracker.def("track", [](vpMbGenericTracker &self, std::map<std::string, const vpImage<unsigned char> *> &mapOfImages,
                                      std::map<std::string, py::array_t<double, py::array::c_style>> &mapOfPointClouds) {
                                        std::map<std::string, unsigned int> mapOfWidths, mapOfHeights;
diff --git a/modules/python/bindings/include/rbt/drift.hpp b/modules/python/bindings/include/rbt/drift.hpp
index c2f67ce692..527394b933 100644
--- a/modules/python/bindings/include/rbt/drift.hpp
+++ b/modules/python/bindings/include/rbt/drift.hpp
@@ -6,14 +6,14 @@
 #include <pybind11/pybind11.h>
 
 
-class TrampolineRBDriftDetector : public vpRBDriftDetector
+class TrampolineRBDriftDetector : public VISP_NAMESPACE_ADDRESSING vpRBDriftDetector
 {
 public:
   using vpRBDriftDetector::vpRBDriftDetector;
 
   TrampolineRBDriftDetector() : vpRBDriftDetector() { }
 
-  virtual void update(const vpRBFeatureTrackerInput &previousFrame, const vpRBFeatureTrackerInput &frame, const vpHomogeneousMatrix &cTo, const vpHomogeneousMatrix &cprevTo) VP_OVERRIDE
+  virtual void update(const VISP_NAMESPACE_ADDRESSING vpRBFeatureTrackerInput &previousFrame, const VISP_NAMESPACE_ADDRESSING vpRBFeatureTrackerInput &frame, const VISP_NAMESPACE_ADDRESSING vpHomogeneousMatrix &cTo, const VISP_NAMESPACE_ADDRESSING vpHomogeneousMatrix &cprevTo) VP_OVERRIDE
   {
     pybind11::gil_scoped_acquire gil;  // Acquire the GIL while in this scope.
     // Try to look up the overridden method on the Python side.
@@ -24,7 +24,7 @@ class TrampolineRBDriftDetector : public vpRBDriftDetector
     }
   }
 
-  virtual double score(const vpRBFeatureTrackerInput &frame, const vpHomogeneousMatrix &cTo) VP_OVERRIDE
+  virtual double score(const VISP_NAMESPACE_ADDRESSING vpRBFeatureTrackerInput &frame, const VISP_NAMESPACE_ADDRESSING vpHomogeneousMatrix &cTo) VP_OVERRIDE
   {
     pybind11::gil_scoped_acquire gil;  // Acquire the GIL while in this scope.
     // Try to look up the overridden method on the Python side.
@@ -63,11 +63,11 @@ class TrampolineRBDriftDetector : public vpRBDriftDetector
       );
   }
 
-  virtual void display(const vpImage<vpRGBa> &I) VP_OVERRIDE
+  virtual void display(const VISP_NAMESPACE_ADDRESSING vpImage<VISP_NAMESPACE_ADDRESSING vpRGBa> &I) VP_OVERRIDE
   {
     PYBIND11_OVERRIDE_PURE(
       void,                   /* Return type */
-      vpRBDriftDetector,      /* Parent class */
+      VISP_NAMESPACE_ADDRESSING vpRBDriftDetector,      /* Parent class */
       display,                /* Name of function in C++ (must match Python name) */
       I
     );
diff --git a/modules/python/bindings/include/rbt/feature_tracker.hpp b/modules/python/bindings/include/rbt/feature_tracker.hpp
index 9b00c66780..4939dec8ae 100644
--- a/modules/python/bindings/include/rbt/feature_tracker.hpp
+++ b/modules/python/bindings/include/rbt/feature_tracker.hpp
@@ -35,10 +35,10 @@
 #include <pybind11/pybind11.h>
 
 
-class TrampolineRBFeatureTracker : public vpRBFeatureTracker
+class TrampolineRBFeatureTracker : public VISP_NAMESPACE_ADDRESSING vpRBFeatureTracker
 {
 public:
-  using vpRBFeatureTracker::vpRBFeatureTracker;
+  using VISP_NAMESPACE_ADDRESSING vpRBFeatureTracker::vpRBFeatureTracker;
 
   TrampolineRBFeatureTracker() : vpRBFeatureTracker() { }
 
@@ -69,7 +69,7 @@ class TrampolineRBFeatureTracker : public vpRBFeatureTracker
       );
   }
 
-  virtual void onTrackingIterStart(const vpRBFeatureTrackerInput &frame, const vpHomogeneousMatrix &cMo) VP_OVERRIDE
+  virtual void onTrackingIterStart(const VISP_NAMESPACE_ADDRESSING vpRBFeatureTrackerInput &frame, const VISP_NAMESPACE_ADDRESSING vpHomogeneousMatrix &cMo) VP_OVERRIDE
   {
     PYBIND11_OVERRIDE_PURE(
       void,           /* Return type */
@@ -80,7 +80,7 @@ class TrampolineRBFeatureTracker : public vpRBFeatureTracker
     );
   }
 
-  virtual void onTrackingIterEnd(const vpHomogeneousMatrix &cMo) VP_OVERRIDE
+  virtual void onTrackingIterEnd(const VISP_NAMESPACE_ADDRESSING vpHomogeneousMatrix &cMo) VP_OVERRIDE
   {
     PYBIND11_OVERRIDE_PURE(
       void,           /* Return type */
@@ -90,7 +90,7 @@ class TrampolineRBFeatureTracker : public vpRBFeatureTracker
     );
   }
 
-  virtual void extractFeatures(const vpRBFeatureTrackerInput &frame, const vpRBFeatureTrackerInput &previousFrame, const vpHomogeneousMatrix &cMo)
+  virtual void extractFeatures(const VISP_NAMESPACE_ADDRESSING vpRBFeatureTrackerInput &frame, const VISP_NAMESPACE_ADDRESSING vpRBFeatureTrackerInput &previousFrame, const VISP_NAMESPACE_ADDRESSING vpHomogeneousMatrix &cMo)
     VP_OVERRIDE
   {
     pybind11::gil_scoped_acquire gil;  // Acquire the GIL while in this scope.
@@ -102,7 +102,7 @@ class TrampolineRBFeatureTracker : public vpRBFeatureTracker
     }
   }
 
-    virtual void trackFeatures(const vpRBFeatureTrackerInput &frame, const vpRBFeatureTrackerInput &previousFrame, const vpHomogeneousMatrix &cMo)
+    virtual void trackFeatures(const VISP_NAMESPACE_ADDRESSING vpRBFeatureTrackerInput &frame, const VISP_NAMESPACE_ADDRESSING vpRBFeatureTrackerInput &previousFrame, const VISP_NAMESPACE_ADDRESSING vpHomogeneousMatrix &cMo)
     VP_OVERRIDE
   {
     pybind11::gil_scoped_acquire gil;  // Acquire the GIL while in this scope.
@@ -114,7 +114,7 @@ class TrampolineRBFeatureTracker : public vpRBFeatureTracker
     }
   }
 
-    virtual void initVVS(const vpRBFeatureTrackerInput &frame, const vpRBFeatureTrackerInput &previousFrame, const vpHomogeneousMatrix &cMo) VP_OVERRIDE
+    virtual void initVVS(const VISP_NAMESPACE_ADDRESSING vpRBFeatureTrackerInput &frame, const VISP_NAMESPACE_ADDRESSING vpRBFeatureTrackerInput &previousFrame, const VISP_NAMESPACE_ADDRESSING vpHomogeneousMatrix &cMo) VP_OVERRIDE
   {
     pybind11::gil_scoped_acquire gil;  // Acquire the GIL while in this scope.
     // Try to look up the overridden method on the Python side.
@@ -125,7 +125,7 @@ class TrampolineRBFeatureTracker : public vpRBFeatureTracker
     }
   }
 
-  virtual void computeVVSIter(const vpRBFeatureTrackerInput &frame, const vpHomogeneousMatrix &cMo, unsigned int iteration) VP_OVERRIDE
+  virtual void computeVVSIter(const VISP_NAMESPACE_ADDRESSING vpRBFeatureTrackerInput &frame, const VISP_NAMESPACE_ADDRESSING vpHomogeneousMatrix &cMo, unsigned int iteration) VP_OVERRIDE
   {
     pybind11::gil_scoped_acquire gil;  // Acquire the GIL while in this scope.
     // Try to look up the overridden method on the Python side.
@@ -145,7 +145,7 @@ class TrampolineRBFeatureTracker : public vpRBFeatureTracker
       );
   }
 
-  virtual void display(const vpCameraParameters &cam, const vpImage<unsigned char> &I, const vpImage<vpRGBa> &IRGB, const vpImage<unsigned char> &depth) const VP_OVERRIDE
+  virtual void display(const VISP_NAMESPACE_ADDRESSING vpCameraParameters &cam, const VISP_NAMESPACE_ADDRESSING vpImage<unsigned char> &I, const VISP_NAMESPACE_ADDRESSING vpImage<VISP_NAMESPACE_ADDRESSING vpRGBa> &IRGB, const VISP_NAMESPACE_ADDRESSING vpImage<unsigned char> &depth) const VP_OVERRIDE
   {
     pybind11::gil_scoped_acquire gil;  // Acquire the GIL while in this scope.
     // Try to look up the overridden method on the Python side.
@@ -156,10 +156,10 @@ class TrampolineRBFeatureTracker : public vpRBFeatureTracker
     }
   }
 
-  virtual const vpMatrix getCovariance() const VP_OVERRIDE
+  virtual const VISP_NAMESPACE_ADDRESSING vpMatrix getCovariance() const VP_OVERRIDE
   {
     PYBIND11_OVERRIDE(
-      vpMatrix,           /* Return type */
+      VISP_NAMESPACE_ADDRESSING vpMatrix,           /* Return type */
       vpRBFeatureTracker,     /* Parent class */
       getCovariance,       /* Name of function in C++ (must match Python name) */
 
@@ -186,19 +186,19 @@ class TrampolineRBFeatureTracker : public vpRBFeatureTracker
     );
   }
 
-  virtual vpMatrix getLTL() const VP_OVERRIDE
+  virtual VISP_NAMESPACE_ADDRESSING vpMatrix getLTL() const VP_OVERRIDE
   {
     PYBIND11_OVERRIDE(
-      vpMatrix,           /* Return type */
+      VISP_NAMESPACE_ADDRESSING vpMatrix,           /* Return type */
       vpRBFeatureTracker,     /* Parent class */
       getLTL,
       );
   }
 
-  virtual vpColVector getLTR() const VP_OVERRIDE
+  virtual VISP_NAMESPACE_ADDRESSING vpColVector getLTR() const VP_OVERRIDE
   {
     PYBIND11_OVERRIDE(
-      vpColVector,           /* Return type */
+      VISP_NAMESPACE_ADDRESSING vpColVector,           /* Return type */
       vpRBFeatureTracker,     /* Parent class */
       getLTR,      /* Name of function in C++ (must match Python name) */
       );
diff --git a/modules/python/bindings/include/rbt/mask.hpp b/modules/python/bindings/include/rbt/mask.hpp
index 6d96faffee..eaec4bfcee 100644
--- a/modules/python/bindings/include/rbt/mask.hpp
+++ b/modules/python/bindings/include/rbt/mask.hpp
@@ -7,16 +7,16 @@
 #include <pybind11/pybind11.h>
 
 
-class TrampolineObjectMask : public vpObjectMask
+class TrampolineObjectMask : public VISP_NAMESPACE_ADDRESSING vpObjectMask
 {
 public:
   using vpObjectMask::vpObjectMask;
 
   TrampolineObjectMask() : vpObjectMask() { }
 
-  virtual void updateMask(const vpRBFeatureTrackerInput &frame,
-                          const vpRBFeatureTrackerInput &previousFrame,
-                          vpImage<float> &mask) VP_OVERRIDE
+  virtual void updateMask(const VISP_NAMESPACE_ADDRESSING vpRBFeatureTrackerInput &frame,
+                          const VISP_NAMESPACE_ADDRESSING vpRBFeatureTrackerInput &previousFrame,
+                          VISP_NAMESPACE_ADDRESSING vpImage<float> &mask) VP_OVERRIDE
   {
     pybind11::gil_scoped_acquire gil;  // Acquire the GIL while in this scope.
     // Try to look up the overridden method on the Python side.
@@ -26,7 +26,7 @@ class TrampolineObjectMask : public vpObjectMask
     }
   }
 
-  virtual void display(const vpImage<float> &mask, vpImage<unsigned char> &Imask) const VP_OVERRIDE
+  virtual void display(const VISP_NAMESPACE_ADDRESSING vpImage<float> &mask, VISP_NAMESPACE_ADDRESSING vpImage<unsigned char> &Imask) const VP_OVERRIDE
   {
     PYBIND11_OVERRIDE(
       void,             /* Return type */
diff --git a/modules/python/bindings/include/rbt/vo.hpp b/modules/python/bindings/include/rbt/vo.hpp
index a5c8eceabf..9f30de0c92 100644
--- a/modules/python/bindings/include/rbt/vo.hpp
+++ b/modules/python/bindings/include/rbt/vo.hpp
@@ -5,14 +5,14 @@
 #include <visp3/rbt/vpRBVisualOdometry.h>
 #include <pybind11/pybind11.h>
 
-class TrampolineRBVisualOdometry : public vpRBVisualOdometry
+class TrampolineRBVisualOdometry : public VISP_NAMESPACE_ADDRESSING vpRBVisualOdometry
 {
 public:
   using vpRBVisualOdometry::vpRBVisualOdometry;
 
   TrampolineRBVisualOdometry() : vpRBVisualOdometry() { }
 
-  virtual void compute(const vpRBFeatureTrackerInput &frame, const vpRBFeatureTrackerInput &previousFrame) VP_OVERRIDE
+  virtual void compute(const VISP_NAMESPACE_ADDRESSING vpRBFeatureTrackerInput &frame, const VISP_NAMESPACE_ADDRESSING vpRBFeatureTrackerInput &previousFrame) VP_OVERRIDE
   {
     pybind11::gil_scoped_acquire gil;  // Acquire the GIL while in this scope.
     // Try to look up the overridden method on the Python side.
@@ -23,20 +23,20 @@ class TrampolineRBVisualOdometry : public vpRBVisualOdometry
     }
   }
 
-  virtual vpHomogeneousMatrix getCameraMotion() const VP_OVERRIDE
+  virtual VISP_NAMESPACE_ADDRESSING vpHomogeneousMatrix getCameraMotion() const VP_OVERRIDE
   {
     PYBIND11_OVERRIDE_PURE(
-      vpHomogeneousMatrix,           /* Return type */
+      VISP_NAMESPACE_ADDRESSING vpHomogeneousMatrix,           /* Return type */
       vpRBVisualOdometry,     /* Parent class */
       getCameraMotion,       /* Name of function in C++ (must match Python name) */
 
       );
   }
 
-  virtual vpHomogeneousMatrix getCameraPose() const VP_OVERRIDE
+  virtual VISP_NAMESPACE_ADDRESSING vpHomogeneousMatrix getCameraPose() const VP_OVERRIDE
   {
     PYBIND11_OVERRIDE_PURE(
-      vpHomogeneousMatrix,           /* Return type */
+      VISP_NAMESPACE_ADDRESSING vpHomogeneousMatrix,           /* Return type */
       vpRBVisualOdometry,     /* Parent class */
       getCameraPose,       /* Name of function in C++ (must match Python name) */
 
diff --git a/modules/python/bindings/include/vision.hpp b/modules/python/bindings/include/vision.hpp
index 4485787ee6..825a75497b 100644
--- a/modules/python/bindings/include/vision.hpp
+++ b/modules/python/bindings/include/vision.hpp
@@ -44,8 +44,12 @@
 
 namespace py = pybind11;
 
-void bindings_vpPose(py::class_<vpPose, std::shared_ptr<vpPose>> &pyPose)
+void bindings_vpPose(py::class_<VISP_NAMESPACE_ADDRESSING vpPose, std::shared_ptr<VISP_NAMESPACE_ADDRESSING vpPose>> &pyPose)
 {
+#ifdef ENABLE_VISP_NAMESPACE
+  using namespace VISP_NAMESPACE_NAME;
+#endif
+
   pyPose.def("computePose",
    [](vpPose &self, vpPose::vpPoseMethodType method, vpHomogeneousMatrix &cMo) -> bool {
      return self.computePose(method, cMo);
diff --git a/modules/python/bindings/include/visual_features.hpp b/modules/python/bindings/include/visual_features.hpp
index 019eca8d6a..1ad2665d3c 100644
--- a/modules/python/bindings/include/visual_features.hpp
+++ b/modules/python/bindings/include/visual_features.hpp
@@ -39,7 +39,7 @@
 #include <pybind11/pybind11.h>
 
 
-class TrampolineBasicFeature : public vpBasicFeature
+class TrampolineBasicFeature : public VISP_NAMESPACE_ADDRESSING vpBasicFeature
 {
 public:
   using vpBasicFeature::vpBasicFeature;
@@ -48,8 +48,8 @@ class TrampolineBasicFeature : public vpBasicFeature
   TrampolineBasicFeature(const vpBasicFeature &f) : vpBasicFeature(f) { }
 
 
-  virtual void display(const vpCameraParameters &cam, const vpImage<unsigned char> &I,
-                         const vpColor &color = vpColor::green, unsigned int thickness = 1) const VP_OVERRIDE
+  virtual void display(const VISP_NAMESPACE_ADDRESSING vpCameraParameters &cam, const VISP_NAMESPACE_ADDRESSING vpImage<unsigned char> &I,
+                         const VISP_NAMESPACE_ADDRESSING vpColor &color = VISP_NAMESPACE_ADDRESSING vpColor::green, unsigned int thickness = 1) const VP_OVERRIDE
   {
     PYBIND11_OVERRIDE_PURE(
       void,           /* Return type */
@@ -58,7 +58,7 @@ class TrampolineBasicFeature : public vpBasicFeature
       cam, I, color, thickness
     );
   }
-  virtual void display(const vpCameraParameters &cam, const vpImage<vpRGBa> &I, const vpColor &color = vpColor::green,
+  virtual void display(const VISP_NAMESPACE_ADDRESSING vpCameraParameters &cam, const VISP_NAMESPACE_ADDRESSING vpImage<VISP_NAMESPACE_ADDRESSING vpRGBa> &I, const VISP_NAMESPACE_ADDRESSING vpColor &color = VISP_NAMESPACE_ADDRESSING vpColor::green,
                        unsigned int thickness = 1) const VP_OVERRIDE
   {
     PYBIND11_OVERRIDE_PURE(
@@ -78,10 +78,10 @@ class TrampolineBasicFeature : public vpBasicFeature
       );
   }
 
-  virtual vpColVector error(const vpBasicFeature &s_star, unsigned int select = FEATURE_ALL) VP_OVERRIDE
+  virtual VISP_NAMESPACE_ADDRESSING vpColVector error(const vpBasicFeature &s_star, unsigned int select = FEATURE_ALL) VP_OVERRIDE
   {
     PYBIND11_OVERRIDE(
-      vpColVector,           /* Return type */
+      VISP_NAMESPACE_ADDRESSING vpColVector,           /* Return type */
       vpBasicFeature,     /* Parent class */
       error,        /* Name of function in C++ (must match Python name) */
       s_star,              /* Argument(s) */
@@ -90,10 +90,10 @@ class TrampolineBasicFeature : public vpBasicFeature
   }
 
 
-  virtual vpMatrix interaction(unsigned int select = FEATURE_ALL) VP_OVERRIDE
+  virtual VISP_NAMESPACE_ADDRESSING vpMatrix interaction(unsigned int select = FEATURE_ALL) VP_OVERRIDE
   {
     PYBIND11_OVERRIDE_PURE(
-      vpMatrix,           /* Return type */
+      VISP_NAMESPACE_ADDRESSING vpMatrix,           /* Return type */
       vpBasicFeature,     /* Parent class */
       interaction,        /* Name of function in C++ (must match Python name) */
       select              /* Argument(s) */
diff --git a/modules/python/generator/visp_python_bindgen/generator.py b/modules/python/generator/visp_python_bindgen/generator.py
index eb4c3ea7e0..c26ad30730 100644
--- a/modules/python/generator/visp_python_bindgen/generator.py
+++ b/modules/python/generator/visp_python_bindgen/generator.py
@@ -78,6 +78,9 @@ def main_str(submodule_fn_declarations, submodule_fn_calls):
 #include <visp3/core/vpConfig.h>
 #include <pybind11/pybind11.h>
 namespace py = pybind11;
+#ifdef ENABLE_VISP_NAMESPACE
+using namespace VISP_NAMESPACE_NAME;
+#endif
 {submodule_fn_declarations}
 
 PYBIND11_MODULE(_visp, m)
diff --git a/modules/python/generator/visp_python_bindgen/submodule.py b/modules/python/generator/visp_python_bindgen/submodule.py
index c7e85534ed..27b082be1e 100644
--- a/modules/python/generator/visp_python_bindgen/submodule.py
+++ b/modules/python/generator/visp_python_bindgen/submodule.py
@@ -174,6 +174,9 @@ def generate(self) -> None:
 {includes_str}
 
 namespace py = pybind11;
+#ifdef ENABLE_VISP_NAMESPACE
+using namespace VISP_NAMESPACE_NAME;
+#endif
 
 {publicists}
 
diff --git a/modules/tracker/rbt/src/core/vpRBConvergenceMetric.cpp b/modules/tracker/rbt/src/core/vpRBConvergenceMetric.cpp
index 268565fd36..70b75cd51a 100644
--- a/modules/tracker/rbt/src/core/vpRBConvergenceMetric.cpp
+++ b/modules/tracker/rbt/src/core/vpRBConvergenceMetric.cpp
@@ -33,6 +33,7 @@
 #ifdef VISP_HAVE_NLOHMANN_JSON
 #include VISP_NLOHMANN_JSON(json_fwd.hpp)
 
+BEGIN_VISP_NAMESPACE
 std::shared_ptr<vpRBConvergenceMetric> vpRBConvergenceMetric::loadFromJSON(const nlohmann::json &j)
 {
   const std::string key = j.at("type");
@@ -51,6 +52,8 @@ std::shared_ptr<vpRBConvergenceMetric> vpRBConvergenceMetric::loadFromJSON(const
   throw vpException(vpException::badValue, "Tried to parse an incorrect convergence metric type: %s", key.c_str());
 
 }
+#else
+BEGIN_VISP_NAMESPACE
 #endif
 
 
@@ -132,3 +135,4 @@ double vpRBConvergenceReprojectionMetric::operator()(const vpCameraParameters &c
   }
   return error / static_cast<double>(uv1.getRows());
 }
+END_VISP_NAMESPACE