diff --git a/CMakeLists.txt b/CMakeLists.txt
index e88ea74..11411b5 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -13,7 +13,7 @@ find_package(SofaFramework REQUIRED)
 find_package(SofaGeneral REQUIRED)
 find_package(SofaGui REQUIRED)
 
-find_package(OpenCV 3.0 REQUIRED)
+find_package(OpenCV REQUIRED)
 find_package(SofaCV REQUIRED)
 
 include_directories(${OpenCV_INCLUDE_DIRS})
@@ -150,7 +150,7 @@ set(SOURCE_FILES
   src/ImageProcessing/utils/AddCam.h
   )
 
-set(${PROJECT_NAME}_LIBRARIES SofaCore SofaSimulationCommon SofaConstraint ${OpenCV_LIBRARIES} SofaCV)
+set(${PROJECT_NAME}_LIBRARIES SofaCore SofaSimulationCommon SofaConstraint Sofa.GL ${OpenCV_LIBRARIES} SofaCV)
 
 set(CMAKE_INCLUDE_CURRENT_DIR ON)
 
diff --git a/src/ImageProcessing/camera/calib/CalibLoader.h b/src/ImageProcessing/camera/calib/CalibLoader.h
index 2ed6f8a..d68acb6 100644
--- a/src/ImageProcessing/camera/calib/CalibLoader.h
+++ b/src/ImageProcessing/camera/calib/CalibLoader.h
@@ -38,39 +38,39 @@ class SOFA_IMAGEPROCESSING_API CalibLoader : public ImplicitDataEngine
   struct CalibData
   {
     CalibData() {}
-    CalibData(const sofa::defaulttype::Matrix3& _K1,
-              const sofa::defaulttype::Matrix3& _R1,
-              const sofa::defaulttype::Vector3& _T1,
+    CalibData(const sofa::type::Matrix3& _K1,
+              const sofa::type::Matrix3& _R1,
+              const sofa::type::Vector3& _T1,
               const sofa::helper::vector<double>& _delta1,
-              const sofa::defaulttype::Vec2i _imSize1, double _error1,
-              const sofa::defaulttype::Matrix3& _K2,
-              const sofa::defaulttype::Matrix3& _R2,
-              const sofa::defaulttype::Vector3& _T2,
+              const sofa::type::Vec2i _imSize1, double _error1,
+              const sofa::type::Matrix3& _K2,
+              const sofa::type::Matrix3& _R2,
+              const sofa::type::Vector3& _T2,
               const sofa::helper::vector<double>& _delta2,
-              const sofa::defaulttype::Vec2i _imSize2, double _error2,
-              const sofa::defaulttype::Matrix3& _Rs,
-              const sofa::defaulttype::Vector3& _Ts,
-              const sofa::defaulttype::Matrix3& _F,
-              const sofa::defaulttype::Matrix3& _E, double _totalError);
-
-    sofa::defaulttype::Vec2i imSize1;
-    sofa::defaulttype::Matrix3 K1;
-    sofa::defaulttype::Matrix3 R1;
-    sofa::defaulttype::Vector3 T1;
+              const sofa::type::Vec2i _imSize2, double _error2,
+              const sofa::type::Matrix3& _Rs,
+              const sofa::type::Vector3& _Ts,
+              const sofa::type::Matrix3& _F,
+              const sofa::type::Matrix3& _E, double _totalError);
+
+    sofa::type::Vec2i imSize1;
+    sofa::type::Matrix3 K1;
+    sofa::type::Matrix3 R1;
+    sofa::type::Vector3 T1;
     sofa::helper::vector<double> delta1;
     double error1;
 
-    sofa::defaulttype::Vec2i imSize2;
-    sofa::defaulttype::Matrix3 K2;
-    sofa::defaulttype::Matrix3 R2;
-    sofa::defaulttype::Vector3 T2;
+    sofa::type::Vec2i imSize2;
+    sofa::type::Matrix3 K2;
+    sofa::type::Matrix3 R2;
+    sofa::type::Vector3 T2;
     sofa::helper::vector<double> delta2;
     double error2;
 
-    sofa::defaulttype::Matrix3 Rs;
-    sofa::defaulttype::Vector3 Ts;
-    sofa::defaulttype::Matrix3 F;
-    sofa::defaulttype::Matrix3 E;
+    sofa::type::Matrix3 Rs;
+    sofa::type::Vector3 Ts;
+    sofa::type::Matrix3 F;
+    sofa::type::Matrix3 E;
     double totalError;
   };
 
@@ -92,24 +92,24 @@ class SOFA_IMAGEPROCESSING_API CalibLoader : public ImplicitDataEngine
   bool m_isStereo;
   bool m_isInitialized;
 
-  sofa::Data<sofa::defaulttype::Vec2i> d_imSize1;
-  sofa::Data<sofa::defaulttype::Matrix3> d_K1;
-  sofa::Data<sofa::defaulttype::Matrix3> d_R1;
-  sofa::Data<sofa::defaulttype::Vector3> d_T1;
+  sofa::Data<sofa::type::Vec2i> d_imSize1;
+  sofa::Data<sofa::type::Matrix3> d_K1;
+  sofa::Data<sofa::type::Matrix3> d_R1;
+  sofa::Data<sofa::type::Vector3> d_T1;
   sofa::Data<sofa::helper::vector<double> > d_delta1;
   sofa::Data<double> d_error1;
 
-  sofa::Data<sofa::defaulttype::Vec2i> d_imSize2;
-  sofa::Data<sofa::defaulttype::Matrix3> d_K2;
-  sofa::Data<sofa::defaulttype::Matrix3> d_R2;
-  sofa::Data<sofa::defaulttype::Vector3> d_T2;
+  sofa::Data<sofa::type::Vec2i> d_imSize2;
+  sofa::Data<sofa::type::Matrix3> d_K2;
+  sofa::Data<sofa::type::Matrix3> d_R2;
+  sofa::Data<sofa::type::Vector3> d_T2;
   sofa::Data<sofa::helper::vector<double> > d_delta2;
   sofa::Data<double> d_error2;
 
-  sofa::Data<sofa::defaulttype::Matrix3> d_Rs;
-  sofa::Data<sofa::defaulttype::Vector3> d_Ts;
-  sofa::Data<sofa::defaulttype::Matrix3> d_F;
-  sofa::Data<sofa::defaulttype::Matrix3> d_E;
+  sofa::Data<sofa::type::Matrix3> d_Rs;
+  sofa::Data<sofa::type::Vector3> d_Ts;
+  sofa::Data<sofa::type::Matrix3> d_F;
+  sofa::Data<sofa::type::Matrix3> d_E;
   sofa::Data<double> d_totalError;
 
  protected:
diff --git a/src/ImageProcessing/camera/common/CalibratedCamera.cpp b/src/ImageProcessing/camera/common/CalibratedCamera.cpp
index 3c78b57..8217206 100644
--- a/src/ImageProcessing/camera/common/CalibratedCamera.cpp
+++ b/src/ImageProcessing/camera/common/CalibratedCamera.cpp
@@ -209,8 +209,7 @@ void CalibratedCamera::computeBBox(const sofa::core::ExecParams *params, bool)
       if (p[c] < minBBox[c]) minBBox[c] = p[c];
     }
   }
-  this->f_bbox.setValue(
-      params, sofa::defaulttype::TBoundingBox<double>(minBBox, maxBBox));
+  this->f_bbox.setValue(sofa::defaulttype::TBoundingBox<double>(minBBox, maxBBox));
 }
 
 }  // namespace cam
diff --git a/src/ImageProcessing/camera/common/CameraSettings.cpp b/src/ImageProcessing/camera/common/CameraSettings.cpp
index f26c466..e918759 100644
--- a/src/ImageProcessing/camera/common/CameraSettings.cpp
+++ b/src/ImageProcessing/camera/common/CameraSettings.cpp
@@ -18,7 +18,7 @@ int CameraSettingsClass =
         "transformations")
         .add<CameraSettings>();
 
-sofa::defaulttype::Vector2 CameraSettings::get2DFrom3DPosition(
+sofa::type::Vector2 CameraSettings::get2DFrom3DPosition(
     const Vector3& pt)
 {
   const Mat3x4d& M = d_M.getValue();
@@ -29,7 +29,7 @@ sofa::defaulttype::Vector2 CameraSettings::get2DFrom3DPosition(
   return Vector2(rx, ry) * 1.0 / rz;
 }
 
-sofa::defaulttype::Vector3 CameraSettings::get3DFrom2DPosition(double x,
+sofa::type::Vector3 CameraSettings::get3DFrom2DPosition(double x,
                                                                double y,
                                                                double f)
 {
@@ -46,7 +46,7 @@ sofa::defaulttype::Vector3 CameraSettings::get3DFrom2DPosition(double x,
   return R.transposed() * (point3D - t);
 }
 
-sofa::defaulttype::Vector3 CameraSettings::get3DFrom2DPosition(const Vector2& p,
+sofa::type::Vector3 CameraSettings::get3DFrom2DPosition(const Vector2& p,
                                                                double f)
 {
   return get3DFrom2DPosition(p[0], p[1], f);
@@ -72,7 +72,7 @@ void CameraSettings::getCornersPosition(Vector3& p1, Vector3& p2, Vector3& p3,
   p4 = get3DFrom2DPosition(0, h, f);
 }
 
-const sofa::defaulttype::Mat3x4d& CameraSettings::getProjectionMatrix() const
+const sofa::type::Mat3x4d& CameraSettings::getProjectionMatrix() const
 {
   return d_M.getValue();
 }
@@ -86,7 +86,7 @@ void CameraSettings::setProjectionMatrix(const Mat3x4d& M)
   recalculate3DCorners();
 }
 
-const sofa::defaulttype::Matrix3& CameraSettings::getIntrinsicCameraMatrix()
+const sofa::type::Matrix3& CameraSettings::getIntrinsicCameraMatrix()
     const
 {
   return d_K.getValue();
@@ -104,13 +104,13 @@ void CameraSettings::setIntrinsicCameraMatrix(const Matrix3& K, bool update)
   recalculate3DCorners();
 }
 
-const sofa::helper::vector<double>& CameraSettings::getDistortionCoefficients()
+const sofa::type::vector<double>& CameraSettings::getDistortionCoefficients()
     const
 {
   return d_distCoefs.getValue();
 }
 void CameraSettings::setDistortionCoefficients(
-    const sofa::helper::vector<double>& distCoefs)
+    const sofa::type::vector<double>& distCoefs)
 {
   // Nothing to do, distortion coefficients are not (yet?) taken into account in
   // OpenGL
@@ -119,7 +119,7 @@ void CameraSettings::setDistortionCoefficients(
   recalculate3DCorners();
 }
 
-const sofa::defaulttype::Matrix3& CameraSettings::getRotationMatrix() const
+const sofa::type::Matrix3& CameraSettings::getRotationMatrix() const
 {
   return d_R.getValue();
 }
@@ -136,7 +136,7 @@ void CameraSettings::setRotationMatrix(const Matrix3& R, bool update)
   recalculate3DCorners();
 }
 
-const sofa::defaulttype::Vector3& CameraSettings::getPosition() const
+const sofa::type::Vector3& CameraSettings::getPosition() const
 {
   return d_t.getValue();
 }
@@ -153,7 +153,7 @@ void CameraSettings::setPosition(const Vector3& t, bool update)
   recalculate3DCorners();
 }
 
-const sofa::defaulttype::Vec2i& CameraSettings::getImageSize() const
+const sofa::type::Vec2i& CameraSettings::getImageSize() const
 {
   return d_imageSize.getValue();
 }
@@ -168,7 +168,7 @@ void CameraSettings::setImageSize(const Vec2i& imgSize, bool update)
 
   recalculate3DCorners();
 }
-const sofa::defaulttype::Matrix4& CameraSettings::getGLProjection() const
+const sofa::type::Matrix4& CameraSettings::getGLProjection() const
 {
   return d_glProjection.getValue();
 }
@@ -180,7 +180,7 @@ void CameraSettings::setGLProjection(const Matrix4& glProjection)
 
   recalculate3DCorners();
 }
-const sofa::defaulttype::Matrix4& CameraSettings::getGLModelview() const
+const sofa::type::Matrix4& CameraSettings::getGLModelview() const
 {
   return d_glModelview.getValue();
 }
@@ -193,7 +193,7 @@ void CameraSettings::setGLModelview(const Matrix4& glModelview)
   recalculate3DCorners();
 }
 
-const sofa::defaulttype::Vec<4, int>& CameraSettings::getGLViewport() const
+const sofa::type::Vec<4, int>& CameraSettings::getGLViewport() const
 {
   return d_glViewport.getValue();
 }
@@ -204,7 +204,7 @@ void CameraSettings::setGLViewport(const Vector4& glViewport)
   recalculate3DCorners();
 }
 
-const sofa::defaulttype::Vector2& CameraSettings::getGLZClip() const
+const sofa::type::Vector2& CameraSettings::getGLZClip() const
 {
   return d_zClip.getValue();
 }
@@ -215,7 +215,7 @@ void CameraSettings::setGLZClip(const Vector2& zClip)
 
   recalculate3DCorners();
 }
-const sofa::defaulttype::Quat& CameraSettings::getOrientation() const
+const sofa::type::Quaternion& CameraSettings::getOrientation() const
 {
   return d_orientation.getValue();
 }
@@ -231,7 +231,7 @@ void CameraSettings::setOrientation(const Quat& orientation)
   recalculate3DCorners();
 }
 
-const sofa::defaulttype::Matrix3& CameraSettings::get2DScaleMatrix() const
+const sofa::type::Matrix3& CameraSettings::get2DScaleMatrix() const
 {
   return d_scale2D.getValue();
 }
@@ -252,7 +252,7 @@ void CameraSettings::setFocalDistance(double f)
   recalculate3DCorners();
 }
 
-const sofa::defaulttype::Matrix3& CameraSettings::get2DTranslationMatrix() const
+const sofa::type::Matrix3& CameraSettings::get2DTranslationMatrix() const
 {
   return d_translate2D.getValue();
 }
@@ -265,7 +265,7 @@ void CameraSettings::set2DTranslationMatrix(const Matrix3& translation2D)
   recalculate3DCorners();
 }
 
-const sofa::helper::vector<sofa::defaulttype::Vector3>&
+const sofa::type::vector<sofa::type::Vector3>&
 CameraSettings::getCorners() const
 {
   return d_3DCorners.getValue();
@@ -559,7 +559,7 @@ void CameraSettings::recalculate3DCorners()
   Vector3 p1, p2, p3, p4;
   this->getCornersPosition(p1, p2, p3, p4,
                            (d_f.getValue() != -1) ? (d_f.getValue()) : (1.0f));
-  sofa::helper::vector<Vector3>& corners3D = *d_3DCorners.beginEdit();
+  sofa::type::vector<Vector3>& corners3D = *d_3DCorners.beginEdit();
   corners3D.clear();
   corners3D.push_back(p1);
   corners3D.push_back(p2);
@@ -569,16 +569,16 @@ void CameraSettings::recalculate3DCorners()
 }
 
 /// Projects a point p on a plane defined by a Point A and a normal n
-sofa::defaulttype::Vector3 orthoProj(const sofa::defaulttype::Vector3& p,
-                                     const sofa::defaulttype::Vector3& A,
-                                     const sofa::defaulttype::Vector3& n)
+sofa::type::Vector3 orthoProj(const sofa::type::Vector3& p,
+                                     const sofa::type::Vector3& A,
+                                     const sofa::type::Vector3& n)
 {
   double lambda = ((A * n) - (p * n)) / (n * n);
   return p + lambda * n;
 }
 
-double length(const sofa::defaulttype::Vector3& a,
-              const sofa::defaulttype::Vector3& b)
+double length(const sofa::type::Vector3& a,
+              const sofa::type::Vector3& b)
 {
   return sqrt((a.x() - b.x()) * (a.x() - b.x()) +
               (a.y() - b.y()) * (a.y() - b.y()) +
@@ -732,8 +732,8 @@ void CameraSettings::buildFromKRT()
   decomposeCV();
   composeM();
   composeGL();
-  sofa::defaulttype::Matrix3 rot;
-  sofa::defaulttype::Quat q = getOrientation();
+  sofa::type::Matrix3 rot;
+  sofa::type::Quat q = getOrientation();
   q.toMatrix(rot);
 
   Vector3 camPos = getPosition();
diff --git a/src/ImageProcessing/camera/common/CameraSettings.h b/src/ImageProcessing/camera/common/CameraSettings.h
index c63b197..8bff5cd 100644
--- a/src/ImageProcessing/camera/common/CameraSettings.h
+++ b/src/ImageProcessing/camera/common/CameraSettings.h
@@ -5,13 +5,13 @@
 
 #include <SofaCV/SofaCV.h>
 
-#include <sofa/core/visual/DrawToolGL.h>
+#include <sofa/gl/DrawToolGL.h>
 #include <sofa/core/visual/VisualManager.h>
 #include <sofa/core/visual/VisualParams.h>
+#include <sofa/helper/gl/Transformation.h>
 #include <sofa/defaulttype/RigidTypes.h>
 #include <sofa/helper/OptionsGroup.h>
-#include <sofa/helper/gl/Transformation.h>
-#include <sofa/helper/gl/template.h>
+#include <sofa/gl/template.h>
 #include <sofa/helper/system/gl.h>
 #include <sofa/helper/system/glu.h>
 
@@ -39,15 +39,15 @@ class SOFA_IMAGEPROCESSING_API CameraSettings : public ImplicitDataEngine
 {
  public:
   typedef sofa::defaulttype::RigidTypes::Coord Rigid;
-  typedef sofa::defaulttype::Vector2 Vector2;
-  typedef sofa::defaulttype::Vector3 Vector3;
-  typedef sofa::defaulttype::Vec<4, int> Vector4;
-  typedef sofa::defaulttype::Vec<2, int> Vec2i;
-  typedef sofa::defaulttype::Vec<5, double> Vector5;
-  typedef sofa::defaulttype::Mat3x4d Mat3x4d;
-  typedef sofa::defaulttype::Matrix4 Matrix4;
-  typedef sofa::defaulttype::Matrix3 Matrix3;
-  typedef sofa::defaulttype::Quat Quat;
+  typedef sofa::type::Vector2 Vector2;
+  typedef sofa::type::Vector3 Vector3;
+  typedef sofa::type::Vec<4, int> Vector4;
+  typedef sofa::type::Vec<2, int> Vec2i;
+  typedef sofa::type::Vec<5, double> Vector5;
+  typedef sofa::type::Mat3x4d Mat3x4d;
+  typedef sofa::type::Matrix4 Matrix4;
+  typedef sofa::type::Matrix3 Matrix3;
+  typedef sofa::type::Quaternion Quat;
 
  public:
   SOFA_CLASS(CameraSettings, ImplicitDataEngine);
@@ -118,9 +118,9 @@ class SOFA_IMAGEPROCESSING_API CameraSettings : public ImplicitDataEngine
   void setIntrinsicCameraMatrix(const Matrix3& K, bool update = true);
 
   /// returns the distortion coefficients
-  const sofa::helper::vector<double>& getDistortionCoefficients() const;
+  const sofa::type::vector<double>& getDistortionCoefficients() const;
   /// sets the distortion coefficients
-  void setDistortionCoefficients(const sofa::helper::vector<double>& distCoefs);
+  void setDistortionCoefficients(const sofa::type::vector<double>& distCoefs);
 
   /// returns the rotation matrix R expressed in the world frame
   const Matrix3& getRotationMatrix() const;
@@ -178,7 +178,7 @@ class SOFA_IMAGEPROCESSING_API CameraSettings : public ImplicitDataEngine
   void set2DTranslationMatrix(const Matrix3& translation2DMat);
 
   /// returns the corners of the image plane at the current focale distance
-  const sofa::helper::vector<sofa::defaulttype::Vector3>& getCorners() const;
+  const sofa::type::vector<sofa::type::Vector3>& getCorners() const;
 
   /// returns the axis skew parameter (Always 0 in this implementation)
   double getAxisSkew() const;
@@ -195,7 +195,7 @@ class SOFA_IMAGEPROCESSING_API CameraSettings : public ImplicitDataEngine
   sofa::Data<double> d_f;             ///< Focal distance
   sofa::Data<Matrix3> d_translate2D;  ///< 2D translation matrix (u0 v0)
   sofa::Data<Matrix3> d_scale2D;  ///< 2D scale matrix (focal opening, fx, fy)
-  sofa::Data<sofa::helper::vector<double> >
+  sofa::Data<sofa::type::vector<double> >
       d_distCoefs;          ///< camera's distortion coefficients if any
   sofa::Data<Mat3x4d> d_M;  ///< 3x4 global projection matrix
   sofa::Data<Matrix3> d_K;  ///< 3x3 Intrinsic Matrix
@@ -211,7 +211,7 @@ class SOFA_IMAGEPROCESSING_API CameraSettings : public ImplicitDataEngine
   sofa::Data<Vector4> d_glViewport;  ///< OpenGL's viewport
   sofa::Data<Vector2> d_zClip;       ///< zNear, zFar
 
-  sofa::Data<sofa::helper::vector<sofa::defaulttype::Vector3> >
+  sofa::Data<sofa::type::vector<sofa::type::Vector3> >
       d_3DCorners;  ///< [OUTPUT] 3D positions of the Image plane's corners
   sofa::Data<Vector3> d_upVector;  ///< camera's up vector
 
diff --git a/src/ImageProcessing/camera/control/LinesOfSightConstraintManager.cpp b/src/ImageProcessing/camera/control/LinesOfSightConstraintManager.cpp
index 83b3584..3e5e692 100644
--- a/src/ImageProcessing/camera/control/LinesOfSightConstraintManager.cpp
+++ b/src/ImageProcessing/camera/control/LinesOfSightConstraintManager.cpp
@@ -1,7 +1,7 @@
 #include "LinesOfSightConstraintManager.inl"
 
 #include <sofa/core/ObjectFactory.h>
-#include <sofa/defaulttype/Vec3Types.h>
+#include <sofa/defaulttype/VecTypes.h>
 
 namespace sofacv
 {
@@ -13,10 +13,7 @@ SOFA_DECL_CLASS(LOSConstraintManager)
 
 int LOSConstraintManagerClass =
     sofa::core::RegisterObject("Lines of sight Constraint Manager")
-        .add<LOSConstraintManager<sofa::defaulttype::Vec3dTypes> >(true)
-#ifdef SOFA_FLOAT
-        .add<LOSConstraintManager<sofa::defaulttype::Vec3fTypes> >()
-#endif  // SOFA_FLOAT
+        .add<LOSConstraintManager<sofa::defaulttype::Vec3Types> >(true)
     ;
 
 template <class DataTypes>
diff --git a/src/ImageProcessing/features/Detectors.cpp b/src/ImageProcessing/features/Detectors.cpp
index ea0184e..5b73a40 100644
--- a/src/ImageProcessing/features/Detectors.cpp
+++ b/src/ImageProcessing/features/Detectors.cpp
@@ -302,7 +302,7 @@ void FASTDetector::enable(bool show)
   {
     m_detector = cv::FastFeatureDetector::create(
         threshold.getValue(), nonmaxsuppression.getValue(),
-        int(type.getValue().getSelectedId()));
+        cv::FastFeatureDetector::DetectorType(type.getValue().getSelectedId()));
     m_obj->addInput(&threshold);
     m_obj->addInput(&nonmaxsuppression);
     m_obj->addInput(&type);
@@ -463,7 +463,7 @@ void ORBDetector::enable(bool show)
     m_detector = cv::ORB::create(
         nFeatures.getValue(), scaleFactor.getValue(), nLevels.getValue(),
         edgeThreshold.getValue(), firstLevel.getValue(), WTA_K.getValue(),
-        int(scoreType.getValue().getSelectedId()), patchSize.getValue(),
+        cv::ORB::ScoreType(scoreType.getValue().getSelectedId()), patchSize.getValue(),
         fastThreshold.getValue());
     m_obj->addInput(&nFeatures);
     m_obj->addInput(&scaleFactor);
@@ -575,7 +575,7 @@ void KAZEDetector::enable(bool show)
     m_detector = cv::KAZE::create(extended.getValue(), upright.getValue(),
                                   threshold.getValue(), octaves.getValue(),
                                   sublevels.getValue(),
-                                  int(diffusivity.getValue().getSelectedId()));
+                                  cv::KAZE::DiffusivityType(diffusivity.getValue().getSelectedId()));
     m_obj->addInput(&extended);
     m_obj->addInput(&upright);
     m_obj->addInput(&threshold);
@@ -648,10 +648,10 @@ void AKAZEDetector::enable(bool show)
   if (show)
   {
     m_detector = cv::AKAZE::create(
-        int(descriptorType.getValue().getSelectedId()),
+        cv::AKAZE::DescriptorType(descriptorType.getValue().getSelectedId()),
         descriptorSize.getValue(), descriptorChannels.getValue(),
         threshold.getValue(), octaves.getValue(), sublevels.getValue(),
-        int(diffusivity.getValue().getSelectedId()));
+        cv::KAZE::DiffusivityType(diffusivity.getValue().getSelectedId()));
     m_obj->addInput(&descriptorType);
     m_obj->addInput(&descriptorSize);
     m_obj->addInput(&descriptorChannels);
diff --git a/src/ImageProcessing/features/FeatureDetector.cpp b/src/ImageProcessing/features/FeatureDetector.cpp
index 1d1d354..f528547 100644
--- a/src/ImageProcessing/features/FeatureDetector.cpp
+++ b/src/ImageProcessing/features/FeatureDetector.cpp
@@ -194,9 +194,9 @@ void FeatureDetector::applyFilter(const cv::Mat& in, cv::Mat& out, bool debug)
     }
     if (_in.channels() == 1)
     {
-      cv::cvtColor(_in, _in, CV_GRAY2BGR);
+      cv::cvtColor(_in, _in, cv::COLOR_GRAY2BGR);
     }
-    cv::drawKeypoints(_in, _v, _in, cv::Scalar(0, 255, 0), 1);
+    cv::drawKeypoints(_in, _v, _in, cv::Scalar(0, 255, 0), cv::DrawMatchesFlags::DRAW_OVER_OUTIMG);
     out = _in.clone();
   }
   else
diff --git a/src/ImageProcessing/features/MatchingConstraints.cpp b/src/ImageProcessing/features/MatchingConstraints.cpp
index e9e4d04..0e35842 100644
--- a/src/ImageProcessing/features/MatchingConstraints.cpp
+++ b/src/ImageProcessing/features/MatchingConstraints.cpp
@@ -360,7 +360,7 @@ void MatchingConstraints::applyFilter(const cv::Mat& in, cv::Mat& out, bool)
     if (out.channels() == 1)
     {
       std::cout << "converting from grayscale to BGR" << std::endl;
-      cv::cvtColor(out, out, CV_GRAY2BGR);
+      cv::cvtColor(out, out, cv::COLOR_GRAY2BGR);
     }
   }
 
diff --git a/src/ImageProcessing/features/OpticalFlow.cpp b/src/ImageProcessing/features/OpticalFlow.cpp
index 1bc466d..ef036db 100644
--- a/src/ImageProcessing/features/OpticalFlow.cpp
+++ b/src/ImageProcessing/features/OpticalFlow.cpp
@@ -1,13 +1,14 @@
 #include "OpticalFlow.h"
 #include <opencv2/imgproc.hpp>
 #include <opencv2/video.hpp>
+#include <opencv2/core/core_c.h>
 
 namespace sofacv
 {
 namespace features
 {
 OpticalFlow::OpticalFlow()
-    : d_winSize(initData(&d_winSize, sofa::defaulttype::Vec2i(21, 21),
+    : d_winSize(initData(&d_winSize, sofa::type::Vec2i(21, 21),
                          "win_size", "")),
       d_maxLevel(initData(&d_maxLevel, 3, "max_level", "")),
       d_criteria_type(initData(&d_criteria_type,
@@ -61,7 +62,7 @@ void OpticalFlow::applyFilter(const cv::Mat& in, cv::Mat& out, bool)
     if (d_points_in.getValue().empty()) return;
     m_pts_in.reserve(d_points_in.getValue().size());
     m_pts_in.clear();
-    for (const sofa::defaulttype::Vec2d& pt : d_points_in.getValue())
+    for (const sofa::type::Vec2d& pt : d_points_in.getValue())
       m_pts_in.push_back(cv::Point2f(pt.x(), pt.y()));
 
     // copy in in out
@@ -72,21 +73,21 @@ void OpticalFlow::applyFilter(const cv::Mat& in, cv::Mat& out, bool)
 
   // IF THE TRACKER HAS BEEN STARTED:
   if (in.type() != CV_8UC1)
-    cv::cvtColor(in, gray, CV_BGRA2GRAY);
+    cv::cvtColor(in, gray, cv::COLOR_BGRA2GRAY);
   else
     gray = in;
 
   if (d_img2.isSet())
   {
     if (d_img2.getValue().type() != CV_8UC1)
-      cv::cvtColor(d_img2.getValue(), m_prev, CV_BGRA2GRAY);
+      cv::cvtColor(d_img2.getValue(), m_prev, cv::COLOR_BGRA2GRAY);
     else
       m_prev = d_img2.getValue();
     // set prev_points to the current input
     if (d_points_in.getValue().empty()) return;
     m_pts_in.reserve(d_points_in.getValue().size());
     m_pts_in.clear();
-    for (const sofa::defaulttype::Vec2d& pt : d_points_in.getValue())
+    for (const sofa::type::Vec2d& pt : d_points_in.getValue())
       m_pts_in.push_back(cv::Point2f(pt.x(), pt.y()));
   }
   // If it's the first step of the optical flow:
@@ -117,9 +118,9 @@ void OpticalFlow::applyFilter(const cv::Mat& in, cv::Mat& out, bool)
                            winSize, d_maxLevel.getValue(), tc,
                            d_flags.getValue(), d_minEigThresh.getValue());
 
-  sofa::helper::vector<sofa::defaulttype::Vec2d> points_out =
+  sofa::helper::vector<sofa::type::Vec2d> points_out =
       d_points_out.getValue();
-  sofa::helper::vector<sofa::defaulttype::Vec2d> points_in =
+  sofa::helper::vector<sofa::type::Vec2d> points_in =
       d_points_in.getValue();
   points_out.clear();
   points_in.clear();
@@ -128,8 +129,8 @@ void OpticalFlow::applyFilter(const cv::Mat& in, cv::Mat& out, bool)
     cv::Point2f ptPrev, ptNext;
     ptPrev = m_pts_in[i];
     ptNext = m_pts_out[i];
-    points_out.push_back(sofa::defaulttype::Vec2d(ptNext.x, ptNext.y));
-    points_in.push_back(sofa::defaulttype::Vec2d(ptPrev.x, ptPrev.y));
+    points_out.push_back(sofa::type::Vec2d(ptNext.x, ptNext.y));
+    points_in.push_back(sofa::type::Vec2d(ptPrev.x, ptPrev.y));
   }
   d_status_out.setValue(status);
   d_error_out.setValue(error);
@@ -154,7 +155,7 @@ void OpticalFlow::applyFilter(const cv::Mat& in, cv::Mat& out, bool)
   if (d_outputImage.getValue())
   {
     cv::Mat visu;
-    cv::cvtColor(gray, gray, CV_GRAY2BGR);
+    cv::cvtColor(gray, gray, cv::COLOR_GRAY2BGR);
     m_prev.copyTo(visu);
     cv::Mat zero = cv::Mat::zeros(visu.rows, visu.cols, visu.type());
     for (int i = 0; i < visu.cols; ++i)
diff --git a/src/ImageProcessing/features/PointPicker2D.cpp b/src/ImageProcessing/features/PointPicker2D.cpp
index 381e458..3d09229 100644
--- a/src/ImageProcessing/features/PointPicker2D.cpp
+++ b/src/ImageProcessing/features/PointPicker2D.cpp
@@ -81,7 +81,7 @@ void PointPicker2D::doUpdate()
       d_points_out.setValue(d_points_in.getValue());
       return;
   }
-  sofa::helper::vector<sofa::defaulttype::Vec2i>* points =
+  sofa::helper::vector<sofa::type::Vec2i>* points =
       d_points_out.beginWriteOnly();
   points->clear();
   if (!m_pointList.empty())
@@ -89,7 +89,7 @@ void PointPicker2D::doUpdate()
     std::cout << std::endl << std::endl;
     for (const cv::Point2f& pt : m_pointList)
     {
-      points->push_back(sofa::defaulttype::Vec2i(int(pt.x), int(pt.y)));
+      points->push_back(sofa::type::Vec2i(int(pt.x), int(pt.y)));
       std::cout << pt.x << " " << pt.y << " ";
     }
     std::cout << std::endl << std::endl;
@@ -101,7 +101,7 @@ void PointPicker2D::applyFilter(const cv::Mat& in, cv::Mat& out, bool)
 {
   if (in.empty()) return;
   if (in.channels() == 1)
-    cv::cvtColor(in, out, CV_GRAY2BGR);
+    cv::cvtColor(in, out, cv::COLOR_GRAY2BGR);
   else
     in.copyTo(out);
 
@@ -146,7 +146,7 @@ void PointPicker2D::computeEpipolarLines()
     std::vector<cv::Point2f> points(m_pointList.begin(), m_pointList.end());
     cv::computeCorrespondEpilines(points, d_whichImage.getValue(), F, lines);
     for (const cv::Vec3f& pt : lines)
-      epilines.push_back(sofa::defaulttype::Vec3f(pt.val));
+      epilines.push_back(sofa::type::Vec3f(pt.val));
   }
 #ifndef SOFACV_NEW_GUI_ENABLED
   m_picker->refreshDebugWindow();
diff --git a/src/ImageProcessing/imgproc/CannyFilter.cpp b/src/ImageProcessing/imgproc/CannyFilter.cpp
index 0fe4012..42b6ab4 100644
--- a/src/ImageProcessing/imgproc/CannyFilter.cpp
+++ b/src/ImageProcessing/imgproc/CannyFilter.cpp
@@ -52,9 +52,9 @@ void CannyFilter::applyFilter(const cv::Mat &in, cv::Mat &out, bool)
 
   cv::Mat img_gray;
   if (in.type() == CV_8UC4)
-    cv::cvtColor(in, img_gray, CV_BGRA2GRAY);
+    cv::cvtColor(in, img_gray, cv::COLOR_BGRA2GRAY);
   else if (in.type() == CV_8UC3)
-    cv::cvtColor(in, img_gray, CV_BGR2GRAY);
+    cv::cvtColor(in, img_gray, cv::COLOR_BGR2GRAY);
   else
     img_gray = in.clone();