[src] Adapted namespace rename in CollisionAlgorithm repository

th-skam · th-skam · commit 918f99cc8d31 · 2025-09-18T17:29:36.000+02:00
diff --git a/src/ConstraintGeometry/BaseConstraint.h b/src/ConstraintGeometry/BaseConstraint.h
@@ -35,16 +35,16 @@ class BaseConstraint : public sofa::core::behavior::BaseLagrangianConstraint{
 /*!
  * \brief The BaseConstraint abstract class is the implementation of sofa's abstract BaseLagrangianConstraint
  */
-template<class FIRST = collisionAlgorithm::BaseProximity, class SECOND = collisionAlgorithm::BaseProximity>
+template<class FIRST = collisionalgorithm::BaseProximity, class SECOND = collisionalgorithm::BaseProximity>
 class TBaseConstraint : public BaseConstraint {
 public:
     SOFA_CLASS(BaseConstraint, sofa::core::behavior::BaseLagrangianConstraint);
 
-    typedef collisionAlgorithm::BaseProximity BaseProximity;
+    typedef collisionalgorithm::BaseProximity BaseProximity;
 
     Data<double> d_drawScale;
     Data<bool> d_draw;
-    Data<collisionAlgorithm::DetectionOutput<FIRST,SECOND> > d_input; // THIS SHOULD BE REPLACED BY A PAIR OF CST PROXIMITY INPUT
+    Data<collisionalgorithm::DetectionOutput<FIRST,SECOND> > d_input; // THIS SHOULD BE REPLACED BY A PAIR OF CST PROXIMITY INPUT
     Data<std::vector<BaseInternalConstraint::SPtr> > d_container;
 
 	TBaseConstraint()
diff --git a/src/ConstraintGeometry/BaseNormalHandler.h b/src/ConstraintGeometry/BaseNormalHandler.h
@@ -12,12 +12,12 @@ namespace sofa ::constraintGeometry {
 /*!
  * \brief The BaseConstraint abstract class is the implementation of sofa's abstract BaseConstraint
  */
-class BaseNormalHandler : public collisionAlgorithm::CollisionComponent {
+class BaseNormalHandler : public collisionalgorithm::CollisionComponent {
 public:
-    SOFA_ABSTRACT_CLASS(BaseNormalHandler, collisionAlgorithm::CollisionComponent);
+    SOFA_ABSTRACT_CLASS(BaseNormalHandler, collisionalgorithm::CollisionComponent);
 
-    typedef collisionAlgorithm::BaseGeometry BaseGeometry;
-    typedef collisionAlgorithm::BaseProximity BaseProximity;
+    typedef collisionalgorithm::BaseGeometry BaseGeometry;
+    typedef collisionalgorithm::BaseProximity BaseProximity;
 
     void init() {
         if (getGeometry()==NULL) {
@@ -46,7 +46,7 @@ class BaseNormalHandler : public collisionAlgorithm::CollisionComponent {
         glDisable(GL_LIGHTING);
         if (color[3] == 0.0) return;
 
-        collisionAlgorithm::Operations::CreateCenterProximity::FUNC operation = collisionAlgorithm::Operations::CreateCenterProximity::Operation::get(getGeometry()->pointBegin());
+        collisionalgorithm::Operations::CreateCenterProximity::FUNC operation = collisionalgorithm::Operations::CreateCenterProximity::Operation::get(getGeometry()->pointBegin());
 
         for (auto it = getGeometry()->pointBegin();it != getGeometry()->end(); it++) {
             auto prox = operation(it->element());
diff --git a/src/ConstraintGeometry/ConstraintDirection.h b/src/ConstraintGeometry/ConstraintDirection.h
@@ -15,7 +15,7 @@ class ConstraintDirection : public sofa::core::objectmodel::BaseObject {
 public:
     SOFA_CLASS(ConstraintDirection, sofa::core::objectmodel::BaseObject);
 
-    typedef collisionAlgorithm::BaseProximity BaseProximity;
+    typedef collisionalgorithm::BaseProximity BaseProximity;
 
     virtual ConstraintNormal createConstraintsNormal(const BaseProximity::SPtr & first, const BaseProximity::SPtr & second) const = 0;
 
diff --git a/src/ConstraintGeometry/ConstraintNormal.h b/src/ConstraintGeometry/ConstraintNormal.h
@@ -14,9 +14,9 @@ namespace sofa::constraintGeometry {
 class ConstraintNormal {
 public:
 
-    typedef collisionAlgorithm::BaseProximity BaseProximity;
-    typedef collisionAlgorithm::BaseBaseProximity FIRST;
-    typedef collisionAlgorithm::BaseBaseProximity SECOND;
+    typedef collisionalgorithm::BaseProximity BaseProximity;
+    typedef collisionalgorithm::BaseBaseProximity FIRST;
+    typedef collisionalgorithm::BaseBaseProximity SECOND;
     typedef std::function<double(const typename FIRST::SPtr &, const typename SECOND::SPtr &, const type::Vec3 &)> ViolationFunction;
 
     static double defaultViolationFunction(const typename FIRST::SPtr & first, const typename SECOND::SPtr & second, const type::Vec3 & normal) {
diff --git a/src/ConstraintGeometry/ConstraintProximity.h b/src/ConstraintGeometry/ConstraintProximity.h
@@ -5,7 +5,7 @@
 
 namespace sofa::constraintGeometry {
 
-class ConstraintProximity : public virtual collisionAlgorithm::BaseBaseProximity {
+class ConstraintProximity : public virtual collisionalgorithm::BaseBaseProximity {
 public:
 
     typedef std::shared_ptr<ConstraintProximity> SPtr;
@@ -100,7 +100,7 @@ class DefaultConstraintProximity : public ConstraintProximity {
 
     typedef std::shared_ptr<DefaultConstraintProximity> SPtr;
 
-    DefaultConstraintProximity(const collisionAlgorithm::BaseProximity::SPtr & p)
+    DefaultConstraintProximity(const collisionalgorithm::BaseProximity::SPtr & p)
     : m_prox(p) {}
 
     sofa::type::Vec3 getPosition(core::VecCoordId v = core::vec_id::write_access::position) const override {
@@ -123,12 +123,12 @@ class DefaultConstraintProximity : public ConstraintProximity {
         return type::Vec3();
     }
 
-    static ConstraintProximity::SPtr create(const collisionAlgorithm::BaseProximity::SPtr & p) {
+    static ConstraintProximity::SPtr create(const collisionalgorithm::BaseProximity::SPtr & p) {
         return ConstraintProximity::SPtr(new DefaultConstraintProximity(p));
     }
 
 protected:
-    collisionAlgorithm::BaseProximity::SPtr m_prox;
+    collisionalgorithm::BaseProximity::SPtr m_prox;
 };
 
 
diff --git a/src/ConstraintGeometry/InternalConstraint.h b/src/ConstraintGeometry/InternalConstraint.h
@@ -30,9 +30,9 @@ class BaseInternalConstraint {
 
     virtual unsigned getPairSize() const = 0;
 
-    virtual collisionAlgorithm::BaseBaseProximity::SPtr getFirstPair(unsigned i) const = 0;
+    virtual collisionalgorithm::BaseBaseProximity::SPtr getFirstPair(unsigned i) const = 0;
 
-    virtual collisionAlgorithm::BaseBaseProximity::SPtr getSecondPair(unsigned i) const = 0;
+    virtual collisionalgorithm::BaseBaseProximity::SPtr getSecondPair(unsigned i) const = 0;
 
     virtual void draw(const core::visual::VisualParams* ,double ) const = 0;
 
@@ -58,10 +58,10 @@ public :
 
     typedef std::shared_ptr<InternalConstraint<FIRST,SECOND>> SPtr;
 
-//    typedef collisionAlgorithm::BaseProximity FIRST;
-//    typedef collisionAlgorithm::BaseProximity SECOND;
+//    typedef collisionalgorithm::BaseProximity FIRST;
+//    typedef collisionalgorithm::BaseProximity SECOND;
 
-    typedef collisionAlgorithm::BaseProximity BaseProximity;
+    typedef collisionalgorithm::BaseProximity BaseProximity;
     typedef std::function<core::behavior::ConstraintResolution*(const BaseInternalConstraint *)> ResolutionCreator;
     typedef std::function<void(const InternalConstraint * ,linearalgebra::BaseVector *)> ViolationFunc;
     typedef std::function<ConstraintNormal(const typename FIRST::SPtr & ,const typename SECOND::SPtr & )> NormalsFunc;
@@ -207,9 +207,9 @@ public :
 
     unsigned getPairSize() const override { return m_pairs.size(); }
 
-    collisionAlgorithm::BaseBaseProximity::SPtr getFirstPair(unsigned i) const override { return m_pairs[i].first; }
+    collisionalgorithm::BaseBaseProximity::SPtr getFirstPair(unsigned i) const override { return m_pairs[i].first; }
 
-    collisionAlgorithm::BaseBaseProximity::SPtr getSecondPair(unsigned i) const override { return m_pairs[i].second; }
+    collisionalgorithm::BaseBaseProximity::SPtr getSecondPair(unsigned i) const override { return m_pairs[i].second; }
 
     const std::vector<std::pair<const typename FIRST::SPtr, const typename SECOND::SPtr>> & getPairs() const {
         return m_pairs;
diff --git a/src/ConstraintGeometry/constraint/ConstraintBilateral.h b/src/ConstraintGeometry/constraint/ConstraintBilateral.h
@@ -6,7 +6,7 @@
 
 namespace sofa::constraintGeometry {
 
-class ConstraintBilateral : public TBaseConstraint<collisionAlgorithm::BaseProximity,collisionAlgorithm::BaseProximity> {
+class ConstraintBilateral : public TBaseConstraint<collisionalgorithm::BaseProximity,collisionalgorithm::BaseProximity> {
 public:
     SOFA_CLASS(ConstraintBilateral , SOFA_TEMPLATE2(TBaseConstraint,BaseProximity,BaseProximity));
 
diff --git a/src/ConstraintGeometry/constraint/ConstraintInsertion.h b/src/ConstraintGeometry/constraint/ConstraintInsertion.h
@@ -6,7 +6,7 @@
 
 namespace sofa::constraintGeometry {
 
-class ConstraintInsertion : public TBaseConstraint<collisionAlgorithm::BaseProximity,collisionAlgorithm::BaseProximity> {
+class ConstraintInsertion : public TBaseConstraint<collisionalgorithm::BaseProximity,collisionalgorithm::BaseProximity> {
 public:
     SOFA_CLASS(ConstraintInsertion , SOFA_TEMPLATE2(TBaseConstraint,BaseProximity,BaseProximity));
 
diff --git a/src/ConstraintGeometry/constraint/ConstraintUnilateral.h b/src/ConstraintGeometry/constraint/ConstraintUnilateral.h
@@ -13,9 +13,9 @@ namespace constraintGeometry {
  * \brief The ConstraintUnilateral class
  * Applies specified algorithm on 'from' and 'dest' geometry
  */
-class ConstraintUnilateral : public TBaseConstraint<collisionAlgorithm::BaseProximity,collisionAlgorithm::BaseProximity> {
+class ConstraintUnilateral : public TBaseConstraint<collisionalgorithm::BaseProximity,collisionalgorithm::BaseProximity> {
 public:
-    SOFA_CLASS(ConstraintUnilateral , SOFA_TEMPLATE2(TBaseConstraint,collisionAlgorithm::BaseProximity,collisionAlgorithm::BaseProximity) );
+    SOFA_CLASS(ConstraintUnilateral , SOFA_TEMPLATE2(TBaseConstraint,collisionalgorithm::BaseProximity,collisionalgorithm::BaseProximity) );
 
     Data<double> d_friction;
     Data<double> d_maxforce0;
diff --git a/src/ConstraintGeometry/normalHandler/EdgeNormalHandler.cpp b/src/ConstraintGeometry/normalHandler/EdgeNormalHandler.cpp
@@ -14,7 +14,7 @@ void registerEdgeNormalHandler(sofa::core::ObjectFactory* factory)
 }
 
 int edge_reg = ConstraintProximityOperation::register_func<EdgeNormalHandler,
-                                                           collisionAlgorithm::EdgeProximity>(
-    &EdgeNormalHandler::buildCstProximity<collisionAlgorithm::EdgeProximity>);
+                                                           collisionalgorithm::EdgeProximity>(
+    &EdgeNormalHandler::buildCstProximity<collisionalgorithm::EdgeProximity>);
 
 }  // namespace sofa::constraintGeometry
diff --git a/src/ConstraintGeometry/normalHandler/EdgeNormalHandler.h b/src/ConstraintGeometry/normalHandler/EdgeNormalHandler.h
@@ -35,7 +35,7 @@ class EdgeNormalHandler : public BaseNormalHandler {
 };
 
 template<>
-type::Vec3 EdgeNormalHandler::getNormal<collisionAlgorithm::EdgeProximity>(const collisionAlgorithm::EdgeProximity::SPtr & prox) {
+type::Vec3 EdgeNormalHandler::getNormal<collisionalgorithm::EdgeProximity>(const collisionalgorithm::EdgeProximity::SPtr & prox) {
     return (prox->element()->getP1()->getPosition() - prox->element()->getP0()->getPosition()).normalized();
 }
 
diff --git a/src/ConstraintGeometry/normalHandler/GouraudTriangleNormalHandler.cpp b/src/ConstraintGeometry/normalHandler/GouraudTriangleNormalHandler.cpp
@@ -13,13 +13,13 @@ void registerGouraudTriangleNormalHandler(sofa::core::ObjectFactory* factory)
 
 int gouraud_reg_tri =
     ConstraintProximityOperation::register_func<GouraudTriangleNormalHandler,
-                                                collisionAlgorithm::TriangleProximity>(
-        &GouraudTriangleNormalHandler::buildCstProximity<collisionAlgorithm::TriangleProximity>);
+                                                collisionalgorithm::TriangleProximity>(
+        &GouraudTriangleNormalHandler::buildCstProximity<collisionalgorithm::TriangleProximity>);
 
 int gouraud_reg_mech = ConstraintProximityOperation::register_func<
     GouraudTriangleNormalHandler,
-    collisionAlgorithm::MechanicalProximity<sofa::defaulttype::Vec3dTypes>>(
+    collisionalgorithm::MechanicalProximity<sofa::defaulttype::Vec3dTypes>>(
     &GouraudTriangleNormalHandler::buildCstProximity<
-        collisionAlgorithm::MechanicalProximity<sofa::defaulttype::Vec3dTypes>>);
+        collisionalgorithm::MechanicalProximity<sofa::defaulttype::Vec3dTypes>>);
 
 }  // namespace sofa::constraintGeometry
diff --git a/src/ConstraintGeometry/normalHandler/GouraudTriangleNormalHandler.h b/src/ConstraintGeometry/normalHandler/GouraudTriangleNormalHandler.h
@@ -36,14 +36,14 @@ class GouraudTriangleNormalHandler : public BaseNormalHandler {
 };
 
 template<>
-inline type::Vec3 GouraudTriangleNormalHandler::getNormal<collisionAlgorithm::TriangleProximity>(const collisionAlgorithm::TriangleProximity::SPtr & prox) {
+inline type::Vec3 GouraudTriangleNormalHandler::getNormal<collisionalgorithm::TriangleProximity>(const collisionalgorithm::TriangleProximity::SPtr & prox) {
     return prox->element()->getTriangleInfo().N;
 }
 
 
 template<>
-inline type::Vec3 GouraudTriangleNormalHandler::getNormal<collisionAlgorithm::MechanicalProximity<sofa::defaulttype::Vec3dTypes>>(const collisionAlgorithm::MechanicalProximity<sofa::defaulttype::Vec3dTypes>::SPtr & prox) {
-    const collisionAlgorithm::PointElement::SPtr & element = prox->getGeometry()->pointElements()[prox->getPId()];
+inline type::Vec3 GouraudTriangleNormalHandler::getNormal<collisionalgorithm::MechanicalProximity<sofa::defaulttype::Vec3dTypes>>(const collisionalgorithm::MechanicalProximity<sofa::defaulttype::Vec3dTypes>::SPtr & prox) {
+    const collisionalgorithm::PointElement::SPtr & element = prox->getGeometry()->pointElements()[prox->getPId()];
 
     type::Vec3 N0_point;
     for (auto it = element->triangleAround().cbegin();it!=element->triangleAround().cend();it++) {
diff --git a/src/ConstraintGeometry/normalHandler/GravityPointNormalHandler.cpp b/src/ConstraintGeometry/normalHandler/GravityPointNormalHandler.cpp
@@ -15,7 +15,7 @@ void registerGravityPointNormalHandler(sofa::core::ObjectFactory* factory)
 
 int gravityPoint_reg =
     ConstraintProximityOperation::register_func<GravityPointNormalHandler,
-                                                collisionAlgorithm::PointProximity>(
-        &GravityPointNormalHandler::buildCstProximity<collisionAlgorithm::PointProximity>);
+                                                collisionalgorithm::PointProximity>(
+        &GravityPointNormalHandler::buildCstProximity<collisionalgorithm::PointProximity>);
 
 }  // namespace sofa::constraintGeometry
diff --git a/src/ConstraintGeometry/normalHandler/GravityPointNormalHandler.h b/src/ConstraintGeometry/normalHandler/GravityPointNormalHandler.h
@@ -12,7 +12,7 @@ class GravityPointNormalHandler : public BaseNormalHandler {
 
     SOFA_CLASS(GravityPointNormalHandler, BaseNormalHandler);
 
-    core::objectmodel::SingleLink<GravityPointNormalHandler,collisionAlgorithm::BaseGeometry,BaseLink::FLAG_STRONGLINK|BaseLink::FLAG_STOREPATH> l_geometry;
+    core::objectmodel::SingleLink<GravityPointNormalHandler,collisionalgorithm::BaseGeometry,BaseLink::FLAG_STRONGLINK|BaseLink::FLAG_STOREPATH> l_geometry;
 
     GravityPointNormalHandler()
     : l_geometry(initLink("geometry","Link to TriangleGeometry")){
@@ -48,7 +48,7 @@ private :
 };
 
 template<>
-inline type::Vec3 GravityPointNormalHandler::getNormal<collisionAlgorithm::PointProximity>(const collisionAlgorithm::PointProximity::SPtr & prox) {
+inline type::Vec3 GravityPointNormalHandler::getNormal<collisionalgorithm::PointProximity>(const collisionalgorithm::PointProximity::SPtr & prox) {
     type::Vec3 N = (prox->getPosition() - m_gcenter).normalized();
     return N;
 }
diff --git a/src/ConstraintGeometry/normalHandler/PhongTriangleNormalHandler.cpp b/src/ConstraintGeometry/normalHandler/PhongTriangleNormalHandler.cpp
@@ -13,13 +13,13 @@ void registerPhongTriangleNormalHandler(sofa::core::ObjectFactory* factory)
 
 int phong_reg_tri =
     ConstraintProximityOperation::register_func<PhongTriangleNormalHandler,
-                                                collisionAlgorithm::TriangleProximity>(
-        &PhongTriangleNormalHandler::buildCstProximity<collisionAlgorithm::TriangleProximity>);
+                                                collisionalgorithm::TriangleProximity>(
+        &PhongTriangleNormalHandler::buildCstProximity<collisionalgorithm::TriangleProximity>);
 
 int phong_reg_mech = ConstraintProximityOperation::register_func<
     PhongTriangleNormalHandler,
-    collisionAlgorithm::MechanicalProximity<sofa::defaulttype::Vec3dTypes>>(
+    collisionalgorithm::MechanicalProximity<sofa::defaulttype::Vec3dTypes>>(
     &PhongTriangleNormalHandler::buildCstProximity<
-        collisionAlgorithm::MechanicalProximity<sofa::defaulttype::Vec3dTypes>>);
+        collisionalgorithm::MechanicalProximity<sofa::defaulttype::Vec3dTypes>>);
 
 }  // namespace sofa::constraintGeometry
diff --git a/src/ConstraintGeometry/normalHandler/PhongTriangleNormalHandler.h b/src/ConstraintGeometry/normalHandler/PhongTriangleNormalHandler.h
@@ -35,12 +35,12 @@ class PhongTriangleNormalHandler : public BaseNormalHandler {
 };
 
 template<>
-inline type::Vec3 PhongTriangleNormalHandler::getNormal<collisionAlgorithm::TriangleProximity>(const collisionAlgorithm::TriangleProximity::SPtr & prox) {
+inline type::Vec3 PhongTriangleNormalHandler::getNormal<collisionalgorithm::TriangleProximity>(const collisionalgorithm::TriangleProximity::SPtr & prox) {
     auto element = prox->element();
 
-    const collisionAlgorithm::BaseProximity::SPtr & p0 = element->pointElements()[0]->getP0();
-    const collisionAlgorithm::BaseProximity::SPtr & p1 = element->pointElements()[1]->getP0();
-    const collisionAlgorithm::BaseProximity::SPtr & p2 = element->pointElements()[2]->getP0();
+    const collisionalgorithm::BaseProximity::SPtr & p0 = element->pointElements()[0]->getP0();
+    const collisionalgorithm::BaseProximity::SPtr & p1 = element->pointElements()[1]->getP0();
+    const collisionalgorithm::BaseProximity::SPtr & p2 = element->pointElements()[2]->getP0();
 
     ConstraintProximityOperation::FUNC operation = ConstraintProximityOperation::get(getTypeInfo(),p0->getTypeInfo());
 
@@ -58,8 +58,8 @@ inline type::Vec3 PhongTriangleNormalHandler::getNormal<collisionAlgorithm::Tria
 
 
 template<>
-inline type::Vec3 PhongTriangleNormalHandler::getNormal<collisionAlgorithm::MechanicalProximity<sofa::defaulttype::Vec3dTypes> >(const collisionAlgorithm::MechanicalProximity<sofa::defaulttype::Vec3dTypes>::SPtr & prox) {
-    const collisionAlgorithm::PointElement::SPtr & element = prox->getGeometry()->pointElements()[prox->getPId()];
+inline type::Vec3 PhongTriangleNormalHandler::getNormal<collisionalgorithm::MechanicalProximity<sofa::defaulttype::Vec3dTypes> >(const collisionalgorithm::MechanicalProximity<sofa::defaulttype::Vec3dTypes>::SPtr & prox) {
+    const collisionalgorithm::PointElement::SPtr & element = prox->getGeometry()->pointElements()[prox->getPId()];
 
     type::Vec3 N0_point;
     for (auto it = element->triangleAround().cbegin();it!=element->triangleAround().cend();it++) {
diff --git a/src/ConstraintGeometry/normalHandler/VectorPointNormalHandler.cpp b/src/ConstraintGeometry/normalHandler/VectorPointNormalHandler.cpp
@@ -13,7 +13,7 @@ void registerVectorPointNormalHandler(sofa::core::ObjectFactory* factory)
 
 int vectorPoint_reg = ConstraintProximityOperation::register_func<
     VectorPointNormalHandler,
-    collisionAlgorithm::MechanicalProximity<sofa::defaulttype::Vec3dTypes> >(
+    collisionalgorithm::MechanicalProximity<sofa::defaulttype::Vec3dTypes> >(
     &VectorPointNormalHandler::buildCstProximity<
-        collisionAlgorithm::MechanicalProximity<sofa::defaulttype::Vec3dTypes> >);
+        collisionalgorithm::MechanicalProximity<sofa::defaulttype::Vec3dTypes> >);
 }  // namespace sofa::constraintGeometry
diff --git a/src/ConstraintGeometry/normalHandler/VectorPointNormalHandler.h b/src/ConstraintGeometry/normalHandler/VectorPointNormalHandler.h
@@ -13,7 +13,7 @@ class VectorPointNormalHandler : public BaseNormalHandler {
     SOFA_CLASS(VectorPointNormalHandler, BaseNormalHandler);
 
     Data<type::vector<type::Vec3> > d_normals;
-    core::objectmodel::SingleLink<VectorPointNormalHandler,collisionAlgorithm::BaseGeometry,BaseLink::FLAG_STRONGLINK|BaseLink::FLAG_STOREPATH> l_geometry;
+    core::objectmodel::SingleLink<VectorPointNormalHandler,collisionalgorithm::BaseGeometry,BaseLink::FLAG_STRONGLINK|BaseLink::FLAG_STOREPATH> l_geometry;
 
     VectorPointNormalHandler()
     : d_normals(initData(&d_normals, "normals", "Vector of normals"))
@@ -37,7 +37,7 @@ class VectorPointNormalHandler : public BaseNormalHandler {
 };
 
 template<>
-inline type::Vec3 VectorPointNormalHandler::getNormal<collisionAlgorithm::MechanicalProximity<sofa::defaulttype::Vec3dTypes>>(const collisionAlgorithm::MechanicalProximity<sofa::defaulttype::Vec3dTypes>::SPtr & prox) {
+inline type::Vec3 VectorPointNormalHandler::getNormal<collisionalgorithm::MechanicalProximity<sofa::defaulttype::Vec3dTypes>>(const collisionalgorithm::MechanicalProximity<sofa::defaulttype::Vec3dTypes>::SPtr & prox) {
     type::Vec3 N;
 
     if (prox->getPId()>=d_normals.getValue().size()) {
diff --git a/src/ConstraintGeometry/operations/ConstraintProximityOperation.h b/src/ConstraintGeometry/operations/ConstraintProximityOperation.h
@@ -8,13 +8,13 @@ namespace sofa::constraintGeometry {
 class BaseNormalHandler;
 
 //Specific operation to find the closest point on a geometry (the code is in the c++ class)
-class ConstraintProximityOperation : public collisionAlgorithm::Operations::GenericOperation2<ConstraintProximityOperation,//operation type
+class ConstraintProximityOperation : public collisionalgorithm::Operations::GenericOperation2<ConstraintProximityOperation,//operation type
                                                                                               ConstraintProximity::SPtr, // default return
-                                                                                              BaseNormalHandler *, collisionAlgorithm::BaseProximity::SPtr // parameters
+                                                                                              BaseNormalHandler *, collisionalgorithm::BaseProximity::SPtr // parameters
                                                                                              > {
 public:
 
-    ConstraintProximity::SPtr defaultFunc(BaseNormalHandler *, collisionAlgorithm::BaseProximity::SPtr ) const override {
+    ConstraintProximity::SPtr defaultFunc(BaseNormalHandler *, collisionalgorithm::BaseProximity::SPtr ) const override {
         return NULL;
     }
 

Original file line number	Diff line number	Diff line change
`@@ -14,7 +14,7 @@ void registerEdgeNormalHandler(sofa::core::ObjectFactory* factory)`
`14`	`14`	`}`
`15`	`15`
`16`	`16`	`int edge_reg = ConstraintProximityOperation::register_func<EdgeNormalHandler,`
`17`		`- collisionAlgorithm::EdgeProximity>(`
`18`		`- &EdgeNormalHandler::buildCstProximity<collisionAlgorithm::EdgeProximity>);`
	`17`	`+ collisionalgorithm::EdgeProximity>(`
	`18`	`+ &EdgeNormalHandler::buildCstProximity<collisionalgorithm::EdgeProximity>);`
`19`	`19`
`20`	`20`	`} // namespace sofa::constraintGeometry`