mise à jour

src/SMESHGUI/SMESHGUI_AddMeshElementDlg.cxx

@@ -217,6 +217,7 @@ namespace SMESH
     void SetBallPosition(SMESH_Actor* theActor,TVTKIds& theIds, double theDiameter)
     {
       vtkUnstructuredGrid *aGrid = theActor->GetUnstructuredGrid();
+      myBallPolyData->SetPoints(NULL);
       myBallPolyData->Reset();
       myBallPolyData->DeleteCells();
       myBallPolyData->SetPoints(aGrid->GetPoints());

src/SMESHUtils/SMESH_ControlPnt.cxx

@@ -58,9 +58,10 @@ namespace SMESHUtils
                           const double& theSize,
                           std::vector<ControlPnt>& thePoints );
 
-  std::vector<gp_Pnt> computePointsForSplitting( const gp_Pnt& p1,
+  void computePointsForSplitting( const gp_Pnt& p1,
                                   const gp_Pnt& p2,
-                                                 const gp_Pnt& p3 );
+                                  const gp_Pnt& p3,
+                                  gp_Pnt midPoints[3]);
   gp_Pnt tangencyPoint(const gp_Pnt& p1,
                        const gp_Pnt& p2,
                        const gp_Pnt& Center);
@@ -164,8 +165,7 @@ void SMESHUtils::createPointsSampleFromFace( const TopoDS_Face&       theFace,
 
   // Get triangles
   int nbTriangles = aTri->NbTriangles();
-  Poly_Array1OfTriangle triangles(1,nbTriangles);
+  const Poly_Array1OfTriangle& triangles = aTri->Triangles();
-  triangles=aTri->Triangles();
 
   // GetNodes
   int nbNodes = aTri->NbNodes();
@@ -173,9 +173,10 @@ void SMESHUtils::createPointsSampleFromFace( const TopoDS_Face&       theFace,
   nodes = aTri->Nodes();
 
   // Iterate on triangles and subdivide them
+  thePoints.reserve( thePoints.size() + nbTriangles );
   for ( int i = 1; i <= nbTriangles; i++ )
   {
-    Poly_Triangle aTriangle = triangles.Value(i);
+    const Poly_Triangle& aTriangle = triangles.Value(i);
     gp_Pnt p1 = nodes.Value(aTriangle.Value(1));
     gp_Pnt p2 = nodes.Value(aTriangle.Value(2));
     gp_Pnt p3 = nodes.Value(aTriangle.Value(3));
@@ -221,10 +222,8 @@ void SMESHUtils::createPointsSampleFromSolid( const TopoDS_Solid&      theSolid,
 
       // Step2 : for each face of theSolid:
       std::set<double> intersections;
-      std::set<double>::iterator it = intersections.begin();
 
-      TopExp_Explorer Ex;
+      for ( TopExp_Explorer Ex( theSolid, TopAbs_FACE ); Ex.More(); Ex.Next() )
-      for (Ex.Init(theSolid,TopAbs_FACE); Ex.More(); Ex.Next())
       {
         // check if there is an intersection
         IntCurvesFace_Intersector anIntersector(TopoDS::Face(Ex.Current()), Precision::Confusion());
@@ -234,11 +233,11 @@ void SMESHUtils::createPointsSampleFromSolid( const TopoDS_Solid&      theSolid,
         int nbPoints = anIntersector.NbPnt();
         for ( int i = 0 ; i < nbPoints; i++ )
         {
-          it = intersections.insert( it, anIntersector.WParameter(i+1) );
+          intersections.insert( anIntersector.WParameter(i+1) );
         }
       }
       // Step3 : go through the line chunk by chunk
-      if ( intersections.begin() != intersections.end() )
+      if ( intersections.size() > 1 )
       {
         std::set<double>::iterator intersectionsIterator=intersections.begin();
         double first = *intersectionsIterator;
@@ -254,9 +253,9 @@ void SMESHUtils::createPointsSampleFromSolid( const TopoDS_Solid&      theSolid,
             double localStep = (second -first) / ceil( (second - first) / step );
             for ( double z = Zmin + first; z < Zmin + second; z = z + localStep )
             {
-              thePoints.push_back(ControlPnt( x, y, z, theSize ));
+              thePoints.emplace_back( x, y, z, theSize );
             }
-            thePoints.push_back(ControlPnt( x, y, Zmin + second, theSize ));
+            thePoints.emplace_back( x, y, Zmin + second, theSize );
           }
           first = second;
           innerPoints = !innerPoints;
@@ -292,41 +291,41 @@ void SMESHUtils::subdivideTriangle( const gp_Pnt& p1,
 
   double threshold = sqrt( 3. ) * theSize;
 
-  if ( (p1.Distance(p2) > threshold ||
+  if ( p1.Distance(p2) > threshold ||
        p2.Distance(p3) > threshold ||
-        p3.Distance(p1) > threshold))
+       p3.Distance(p1) > threshold )
+    try
     {
-    std::vector<gp_Pnt> midPoints = computePointsForSplitting(p1, p2, p3);
+      gp_Pnt midPoints[3];
+      computePointsForSplitting( p1, p2, p3, midPoints );
 
       subdivideTriangle( midPoints[0], midPoints[1], midPoints[2], theSize, thePoints );
       subdivideTriangle( midPoints[0], p2, midPoints[1], theSize, thePoints );
       subdivideTriangle( midPoints[2], midPoints[1], p3, theSize, thePoints );
       subdivideTriangle( p1, midPoints[0], midPoints[2], theSize, thePoints );
+      return;
     }
-  else
+    catch (...)
     {
-    double x = (p1.X() + p2.X() + p3.X()) / 3 ;
-    double y = (p1.Y() + p2.Y() + p3.Y()) / 3 ;
-    double z = (p1.Z() + p2.Z() + p3.Z()) / 3 ;
-
-    ControlPnt massCenter( x ,y ,z, theSize );
-    thePoints.push_back( massCenter );
     }
+
+  gp_Pnt massCenter = ( p1.XYZ() + p2.XYZ() + p3.XYZ() ) / 3.;
+  thePoints.emplace_back( massCenter, theSize );
 }
 
 //================================================================================
 /*!
  * \brief Returns the appropriate points for splitting a triangle
- * \brief the tangency points of the incircle are used in order to have mostly
+ * the tangency points of the incircle are used in order to have mostly
- * \brief well-shaped sub-triangles
+ * well-shaped sub-triangles
  */
 //================================================================================
 
-std::vector<gp_Pnt> SMESHUtils::computePointsForSplitting( const gp_Pnt& p1,
+void SMESHUtils::computePointsForSplitting( const gp_Pnt& p1,
                                             const gp_Pnt& p2,
-                                                           const gp_Pnt& p3 )
+                                            const gp_Pnt& p3,
+                                            gp_Pnt midPoints[3])
 {
-  std::vector<gp_Pnt> midPoints;
   //Change coordinates
   gp_Trsf Trsf_1;            // Identity transformation
   gp_Ax3 reference_system(gp::Origin(), gp::DZ(), gp::DX());   // OXY
@@ -359,15 +358,11 @@ std::vector<gp_Pnt> SMESHUtils::computePointsForSplitting( const gp_Pnt& p1,
   gp_Pnt T2 = tangencyPoint( B, C, Center);
   gp_Pnt T3 = tangencyPoint( C, A, Center);
 
-  gp_Pnt p1_2 = T1.Transformed(Trsf_1.Inverted());
+  midPoints[0] = T1.Transformed(Trsf_1.Inverted());
-  gp_Pnt p2_3 = T2.Transformed(Trsf_1.Inverted());
+  midPoints[1] = T2.Transformed(Trsf_1.Inverted());
-  gp_Pnt p3_1 = T3.Transformed(Trsf_1.Inverted());
+  midPoints[2] = T3.Transformed(Trsf_1.Inverted());
 
-  midPoints.push_back(p1_2);
+  return;
-  midPoints.push_back(p2_3);
-  midPoints.push_back(p3_1);
-
-  return midPoints;
 }
 
 //================================================================================

src/SMESHUtils/SMESH_ControlPnt.hxx

@@ -42,11 +42,9 @@ namespace SMESHUtils
   {
     ControlPnt()
       : gp_Pnt(), size(0) {}
-    ControlPnt( const gp_Pnt& aPnt, double theSize)
+    ControlPnt( const gp_Pnt& aPnt, double theSize=0)
       : gp_Pnt( aPnt ), size( theSize ) {}
-    ControlPnt(double theX,double theY,double theZ)
+    ControlPnt(double theX,double theY,double theZ, double theSize=0)
-      : gp_Pnt(theX, theY, theZ), size(0) {}
-    ControlPnt(double theX,double theY,double theZ, double theSize)
       : gp_Pnt(theX, theY, theZ), size( theSize ) {}
 
     double Size() const { return size; };

src/SMESH_I/SMESH_Mesh_i.cxx

@@ -6426,7 +6426,7 @@ class SMESH_DimHyp
   int _dim;    //!< a dimension the algo can build (concurrent dimension)
   int _ownDim; //!< dimension of shape of _subMesh (>=_dim)
   TopTools_MapOfShape  _shapeMap; //!< [sub-]shapes of dimension == _dim
-  SMESH_subMesh*      _subMesh;
+  const SMESH_subMesh* _subMesh;
   list<const SMESHDS_Hypothesis*> _hypotheses; //!< algo is first, then its parameters
 
   //-----------------------------------------------------------------------------
@@ -6440,7 +6440,7 @@ class SMESH_DimHyp
                const int            theDim,
                const TopoDS_Shape&  theShape)
   {
-    _subMesh = (SMESH_subMesh*)theSubMesh;
+    _subMesh = theSubMesh;
     SetShape( theDim, theShape );
   }
 
@@ -6571,7 +6571,8 @@ void addDimHypInstance(const int                               theDim,
        theAlgo->NeedLowerHyps( theDim )) // IPAL54678
     return;
   TDimHypList& listOfdimHyp = theDimHypListArr[theDim];
-  if ( listOfdimHyp.empty() || listOfdimHyp.back()->_subMesh != theSubMesh ) {
+  if ( listOfdimHyp.empty() || listOfdimHyp.back()->_subMesh != theSubMesh )
+  {
     SMESH_DimHyp* dimHyp = new SMESH_DimHyp( theSubMesh, theDim, theShape );
     dimHyp->_hypotheses.push_front(theAlgo);
     listOfdimHyp.push_back( dimHyp );
@@ -6627,7 +6628,8 @@ void unionLists(TListOfInt&       theListOfId,
                 const int         theIndx )
 {
   TListOfListOfInt::iterator it = theListOfListOfId.begin();
-  for ( int i = 0; it != theListOfListOfId.end(); it++, i++ ) {
+  for ( int i = 0; it != theListOfListOfId.end(); it++, i++ )
+  {
     if ( i < theIndx )
       continue; //skip already treated lists
     // check if other list has any same submesh object
@@ -6750,7 +6752,7 @@ TListOfListOfInt SMESH_Mesh_i::findConcurrentSubMeshes()
 {
   TListOfListOfInt anOrder;
   ::SMESH_Mesh& mesh = GetImpl();
-  {
+
   // collect submeshes and detect concurrent algorithms and hypothesises
   TDimHypList dimHypListArr[4]; // dimHyp list for each shape dimension
 
@@ -6791,11 +6793,13 @@ TListOfListOfInt SMESH_Mesh_i::findConcurrentSubMeshes()
   } // end iterations on submesh
 
     // iterate on created dimension-hypotheses and check for concurrents
-    for ( int i = 0; i < 4; i++ ) {
+  for ( int i = 0; i < 4; i++ )
+  {
     const TDimHypList& listOfDimHyp = dimHypListArr[i];
     // check for concurrents in own and other dimensions (step-by-step)
     TDimHypList::const_iterator dhIt = listOfDimHyp.begin();
-      for ( ; dhIt != listOfDimHyp.end(); dhIt++ ) {
+    for ( ; dhIt != listOfDimHyp.end(); dhIt++ )
+    {
       const SMESH_DimHyp* dimHyp = *dhIt;
       TDimHypList listOfConcurr;
       set<int>    setOfConcurrIds;
@@ -6803,7 +6807,8 @@ TListOfListOfInt SMESH_Mesh_i::findConcurrentSubMeshes()
       for ( int j = i; j < 4; j++ )
         findConcurrents( dimHyp, dimHypListArr[j], listOfConcurr, setOfConcurrIds );
       // check if any concurrents found
-        if ( listOfConcurr.size() > 0 ) {
+      if ( listOfConcurr.size() > 0 )
+      {
         // add own submesh to list of concurrent
         addInOrderOfPriority( dimHyp, listOfConcurr );
         list<int> listOfConcurrIds;
@@ -6825,7 +6830,6 @@ TListOfListOfInt SMESH_Mesh_i::findConcurrentSubMeshes()
   TListOfListOfInt::iterator listIt = anOrder.begin();
   for(; listIt != anOrder.end(); listIt++, listIndx++ )
     unionLists( *listIt,  anOrder, listIndx + 1 );
-  }
 
   return anOrder;
 }
@@ -6913,7 +6917,8 @@ void SMESH_Mesh_i::convertMeshOrder (const TListOfListOfInt&     theIdsOrder,
   theResOrder.length(nbSet);
   TListOfListOfInt::const_iterator it = theIdsOrder.begin();
   int listIndx = 0;
-  for( ; it != theIdsOrder.end(); it++ ) {
+  for( ; it != theIdsOrder.end(); it++ )
+  {
     // translate submesh identificators into submesh objects
     //  takeing into account real number of concurrent lists
     const TListOfInt& aSubOrder = (*it);
@@ -6926,7 +6931,8 @@ void SMESH_Mesh_i::convertMeshOrder (const TListOfListOfInt&     theIdsOrder,
     aResSubSet->length(aSubOrder.size());
     TListOfInt::const_iterator subIt = aSubOrder.begin();
     int j;
-    for( j = 0; subIt != aSubOrder.end(); subIt++ ) {
+    for( j = 0; subIt != aSubOrder.end(); subIt++ )
+    {
       if ( _mapSubMeshIor.find(*subIt) == _mapSubMeshIor.end() )
         continue;
       SMESH::SMESH_subMesh_var subMesh =