[src] Update methods signature of computeFractureDirection, computeEndPoints and computeEndPointsNeighboringTriangles to avoid multiple call to GetReadAccessor to the positions

Author: epernod

src/Tearing/BaseTearingEngine.h

@@ -125,16 +125,16 @@ class BaseTearingEngine : public core::DataEngine
 
 	virtual void computeFracturePath() = 0;
 
-	void computeFractureDirection(const Coord principleStressDirection, Coord& fracture_direction);
+	Coord computeFractureDirection(const Coord& principleStressDirection);
 
 	/// <summary>
 	/// compute extremities of fracture Pb and Pc from a start point Pa
 	/// </summary>
 	/// @param Pa - point with maxStress where fracture start
-	/// @param direction - direction of maximum principal stress
+	/// @param fractureDirection - direction of fracture
 	/// @return Pb - one of the extremities of fracture
 	/// @return Pc - one of the extremities of fracture
-	virtual void computeEndPoints(Coord Pa, Coord direction, Coord& Pb, Coord& Pc);
+	virtual void computeEndPoints(const Coord& Pa, const Coord& fractureDirection, Coord& Pb, Coord& Pc);
 
 	/// <summary>
 	/// compute ignored triangle at start of the tearing algo

src/Tearing/BaseTearingEngine.inl

@@ -329,19 +329,20 @@ void BaseTearingEngine<DataTypes>::updateTriangleInformation()
 
 
 template<class DataTypes>
-inline void BaseTearingEngine<DataTypes>::computeFractureDirection(const Coord principleStressDirection,Coord & fracture_direction)
+typename DataTypes::Coord BaseTearingEngine<DataTypes>::computeFractureDirection(const Coord& principleStressDirection)
 {
+    Coord fracture_direction = { 0.0, 0.0, 0.0 };
+
     if (m_maxStressTriangleIndex == InvalidID) {
-        fracture_direction = { 0.0, 0.0, 0.0 };
-        return;
+        return fracture_direction;
     }
 
     const Triangle& VertexIndicies = m_topology->getTriangle(m_maxStressTriangleIndex);
-    constexpr size_t numVertices = 3;
 
-    Index B_id = -1, C_id = -1;
+    Index B_id = sofa::InvalidID;
+    Index C_id = sofa::InvalidID;
 
-    for (unsigned int vertex_id = 0; vertex_id < numVertices; vertex_id++)
+    for (sofa::Index vertex_id = 0; vertex_id < 3; vertex_id++)
     {
         if (VertexIndicies[vertex_id] == m_maxStressVertexIndex)
         {
@@ -356,27 +357,22 @@ inline void BaseTearingEngine<DataTypes>::computeFractureDirection(const Coord p
     Coord B = x[B_id];
     Coord C = x[C_id];
 
-    Coord AB = B - A;
-    Coord AC = C - A;
-
-    Coord triangleNormal = sofa::type::cross(AB,AC);
+    Coord triangleNormal = sofa::type::cross(B - A, C - A);
     fracture_direction = sofa::type::cross(triangleNormal, principleStressDirection);
+
+    return fracture_direction;
 }
 
 
 template <class DataTypes>
-void BaseTearingEngine<DataTypes>::computeEndPoints(
-    Coord Pa,
-    Coord direction,
-    Coord& Pb, Coord& Pc)
+void BaseTearingEngine<DataTypes>::computeEndPoints(const Coord& Pa, const Coord& fractureDirection, Coord& Pb, Coord& Pc)
 {
-    Coord fractureDirection;
-    computeFractureDirection(direction, fractureDirection);
     Real norm_fractureDirection = fractureDirection.norm();
     Pb = Pa + d_fractureMaxLength.getValue() / norm_fractureDirection * fractureDirection;
     Pc = Pa - d_fractureMaxLength.getValue() / norm_fractureDirection * fractureDirection;
 }
 
+
 template <class DataTypes>
 void BaseTearingEngine<DataTypes>::computeTriangleToSkip()
 {

src/Tearing/TearingEngine.h

@@ -81,10 +81,10 @@ class TearingEngine : public BaseTearingEngine<DataTypes>
 	/// computes the extremities of fracture Pb and Pc on the edge of neighboring triangles
 	/// </summary>
 	/// @param Pa - the point where the fracture starts
-	/// @param direction - principle stress direction
+	/// @param fractureDirection - fracture direction
 	/// @return Pb - one of the extremities of fracture
 	/// @return Pc - one of the extremities of fracture
-	bool computeEndPointsNeighboringTriangles(Coord Pa, Coord direction, Coord& Pb, Coord& Pc);
+	bool computeEndPointsNeighboringTriangles(const Coord& Pa, const Coord& fractureDirection, Coord& Pb, Coord& Pc);
 
 	/// <summary>
 	/// computes the extremities of the (normalized) fracture PbPa on the edge of the triangle

src/Tearing/TearingEngine.inl

@@ -94,17 +94,13 @@ inline bool TearingEngine<DataTypes>::computeIntersectionNeighborTriangle(Coord
 }
 
 template<class DataTypes>
-inline bool TearingEngine<DataTypes>::computeEndPointsNeighboringTriangles(Coord Pa, Coord direction, Coord& Pb, Coord& Pc)
+inline bool TearingEngine<DataTypes>::computeEndPointsNeighboringTriangles(const Coord& Pa, const Coord& fractureDirection, Coord& Pb, Coord& Pc)
 {
     bool t_b_ok = false; 
     bool t_c_ok = false;
-    //compute fracture direction perpendicular to the principal stress direction
-    Coord fractureDirection;
-    this->computeFractureDirection(direction, fractureDirection);
 
-    Real norm_fractureDirection = fractureDirection.norm();
-    Coord dir_b = 1.0 / norm_fractureDirection * fractureDirection;
-
+    Coord dir_b = fractureDirection / fractureDirection.norm();
+    
     Real t_b;
     if (computeIntersectionNeighborTriangle(dir_b,Pa, Pb, t_b))
         t_b_ok = true;
@@ -163,33 +159,34 @@ void TearingEngine<DataTypes>::computeFracturePath()
     // frist clear ereything
     this->clearFracturePath();
 
-    if (m_maxStressTriangleIndex != InvalidID) // we have triangle to start and also a vertex id
-    {
-        //Recording the endpoints of the fracture segment
-        helper::ReadAccessor< Data<VecCoord> > x(d_input_positions);
-
-        Coord principalStressDirection = m_triangleInfoTearing[m_maxStressTriangleIndex].principalStressDirection;
-        Coord Pa = x[m_maxStressVertexIndex];      
-        Coord Pb, Pc;
+    if (m_maxStressTriangleIndex == InvalidID) // no candidate to start fracture
+        return;
 
-        if (this->d_fractureMaxLength.getValue() == 0.0) {
-            computeEndPointsNeighboringTriangles(Pa, principalStressDirection, Pb, Pc);
-        }
-        else 
-        {
-            this->computeEndPoints(Pa, principalStressDirection, Pb, Pc);
-        }
+    //Recording the endpoints of the fracture segment
+    helper::ReadAccessor< Data<VecCoord> > x(d_input_positions);
 
-        this->m_fracturePath.ptA = type::Vec3(Pa[0], Pa[1], Pa[2]);
-        this->m_fracturePath.ptB = type::Vec3(Pb[0], Pb[1], Pb[2]);
-        this->m_fracturePath.ptC = type::Vec3(Pc[0], Pc[1], Pc[2]);
-        this->m_fracturePath.triIdA = m_maxStressTriangleIndex;
+    const Coord fractureDirection = this->computeFractureDirection(m_triangleInfoTearing[m_maxStressTriangleIndex].principalStressDirection);
 
-        this->m_tearingAlgo->computeFracturePath(this->m_fracturePath);
-        this->m_stepCounter++;
+    const Coord Pa = x[m_maxStressVertexIndex];
+    Coord Pb, Pc;
 
-        //this->m_tearingAlgo->computeFracturePath(Pa, m_maxStressTriangleIndex, Pb, Pc);
+    if (this->d_fractureMaxLength.getValue() == 0.0) 
+    {
+        this->computeEndPointsNeighboringTriangles(Pa, fractureDirection, Pb, Pc);
+    }
+    else
+    {
+        this->computeEndPoints(Pa, fractureDirection, Pb, Pc); // compute orthogonal fracture using d_fractureMaxLength
     }
+    
+
+    this->m_fracturePath.ptA = type::Vec3(DataTypes::getCPos(Pa));
+    this->m_fracturePath.ptB = type::Vec3(DataTypes::getCPos(Pb));
+    this->m_fracturePath.ptC = type::Vec3(DataTypes::getCPos(Pc));
+    this->m_fracturePath.triIdA = m_maxStressTriangleIndex;
+
+    this->m_tearingAlgo->computeFracturePath(this->m_fracturePath);
+    this->m_stepCounter++;
 }
 
 

src/Tearing/TearingScenarioEngine.h

@@ -77,7 +77,7 @@ class TearingScenarioEngine : public BaseTearingEngine<DataTypes>
 	void algoFracturePath() override;
 	void computeFracturePath() override {};
 
-	void computeEndPoints(Coord Pa, Coord direction, Coord& Pb, Coord& Pc) override;
+	void computeEndPoints(const Coord& Pa, const Coord& fractureDirection, Coord& Pb, Coord& Pc) override;
 
 	/// Value to store scenario fracture path
 	Coord m_Pa, m_Pb, m_Pc;

src/Tearing/TearingScenarioEngine.inl

@@ -106,17 +106,14 @@ inline void TearingScenarioEngine<DataTypes>::computePerpendicular(Coord dir, Co
 }
 
 template <class DataTypes>
-void TearingScenarioEngine<DataTypes>::computeEndPoints(
-    Coord Pa,
-    Coord dir,
-    Coord& Pb, Coord& Pc)
+void TearingScenarioEngine<DataTypes>::computeEndPoints(const Coord& Pa, const Coord& fractureDirection, Coord& Pb, Coord& Pc)
 {
     const Real& alpha = d_startLength.getValue();
 
-    Real norm_dir = dir.norm();
+    Real norm_dir = fractureDirection.norm();
 
-    Pb = Pa + alpha/norm_dir * dir;
-    Pc = Pa - alpha /norm_dir * dir;
+    Pb = Pa + alpha/norm_dir * fractureDirection;
+    Pc = Pa - alpha /norm_dir * fractureDirection;
 }
 
 template <class DataTypes>