Merge commit '6600bcec782fc8b6c72871fe6e08bd19a34a4e2b'

[modules/smesh.git] / src / Controls / SMESH_Controls.cxx

diff --git a/src/Controls/SMESH_Controls.cxx b/src/Controls/SMESH_Controls.cxx
index a8a20c46ce1dc98ccb32e59abb7212e61b9343ec..229162e3e92112e81004decd216334b9e7df6920 100644 (file)
--- a/src/Controls/SMESH_Controls.cxx
+++ b/src/Controls/SMESH_Controls.cxx
@@ -1,4 +1,4 @@
-// Copyright (C) 2007-2021  CEA/DEN, EDF R&D, OPEN CASCADE
+// Copyright (C) 2007-2023  CEA, EDF, OPEN CASCADE
 //
 // Copyright (C) 2003-2007  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
 // CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
@@ -2351,6 +2351,70 @@ SMDSAbs_ElementType NodeConnectivityNumber::GetType() const
   return SMDSAbs_Node;
 }
 
+//================================================================================
+/*
+  Class       : ScaledJacobian
+  Description : Functor returning the ScaledJacobian for volumetric elements
+*/
+//================================================================================
+
+double ScaledJacobian::GetValue( long theElementId )
+{  
+  if ( theElementId && myMesh ) {
+    SMDS_VolumeTool aVolumeTool;
+    if ( aVolumeTool.Set( myMesh->FindElement( theElementId )))
+      return aVolumeTool.GetScaledJacobian();
+  }
+  return 0;
+
+  /* 
+  //VTK version not used because lack of implementation for HEXAGONAL_PRISM. 
+  //Several mesh quality measures implemented in vtkMeshQuality can be accessed left here as reference
+  double aVal = 0;
+  myCurrElement = myMesh->FindElement( theElementId );
+  if ( myCurrElement )
+  {
+    VTKCellType cellType      = myCurrElement->GetVtkType();
+    vtkUnstructuredGrid* grid = const_cast<SMDS_Mesh*>( myMesh )->GetGrid();
+    vtkCell* avtkCell         = grid->GetCell( myCurrElement->GetVtkID() );
+    switch ( cellType )
+    {
+      case VTK_QUADRATIC_TETRA:      
+      case VTK_TETRA:
+        aVal = Round( vtkMeshQuality::TetScaledJacobian( avtkCell ));
+        break;
+      case VTK_QUADRATIC_HEXAHEDRON:
+      case VTK_HEXAHEDRON:
+        aVal = Round( vtkMeshQuality::HexScaledJacobian( avtkCell ));
+        break;
+      case VTK_QUADRATIC_WEDGE:
+      case VTK_WEDGE: //Pentahedron
+        aVal = Round( vtkMeshQuality::WedgeScaledJacobian( avtkCell ));
+        break;
+      case VTK_QUADRATIC_PYRAMID:
+      case VTK_PYRAMID:
+        aVal = Round( vtkMeshQuality::PyramidScaledJacobian( avtkCell ));
+        break;
+      case VTK_HEXAGONAL_PRISM:
+      case VTK_POLYHEDRON:
+      default:
+        break;
+    }          
+  }
+  return aVal;
+  */
+}
+
+double ScaledJacobian::GetBadRate( double Value, int /*nbNodes*/ ) const
+{
+  return Value;
+}
+
+SMDSAbs_ElementType ScaledJacobian::GetType() const
+{
+  return SMDSAbs_Volume;
+}
+
 /*
                             PREDICATES
 */
@@ -4343,7 +4407,7 @@ namespace {
 
 struct ElementsOnShape::Classifier
 {
-  Classifier() { mySolidClfr = 0; myFlags = 0; }
+  Classifier(): mySolidClfr(0), myProjFace(0), myProjEdge(0), myFlags(0) { myU = myV = 1e100; }
   ~Classifier();
   void Init(const TopoDS_Shape& s, double tol, const Bnd_B3d* box = 0 );
   bool IsOut(const gp_Pnt& p)        { return SetChecked( true ), (this->*myIsOutFun)( p ); }
@@ -4356,6 +4420,7 @@ struct ElementsOnShape::Classifier
   void SetChecked( bool is ) { is ? SetFlag( theIsCheckedFlag ) : UnsetFlag( theIsCheckedFlag ); }
   void SetFlag  ( int flag ) { myFlags |= flag; }
   void UnsetFlag( int flag ) { myFlags &= ~flag; }
+  void GetParams( double & u, double & v ) const { u = myU; v = myV; }
 
 private:
   bool isOutOfSolid (const gp_Pnt& p);
@@ -4369,13 +4434,14 @@ private:
   TopoDS_Shape prepareSolid( const TopoDS_Shape& theSolid );
 
   bool (Classifier::*          myIsOutFun)(const gp_Pnt& p);
-  BRepClass3d_SolidClassifier* mySolidClfr; // ptr because of a run-time forbidden copy-constructor
+  BRepClass3d_SolidClassifier* mySolidClfr;
   Bnd_B3d                      myBox;
-  GeomAPI_ProjectPointOnSurf   myProjFace;
-  GeomAPI_ProjectPointOnCurve  myProjEdge;
+  GeomAPI_ProjectPointOnSurf*  myProjFace;
+  GeomAPI_ProjectPointOnCurve* myProjEdge;
   gp_Pnt                       myVertexXYZ;
   TopoDS_Shape                 myShape;
   double                       myTol;
+  double                       myU, myV; // result of isOutOfFace() and isOutOfEdge()
   int                          myFlags;
 };
 
@@ -4423,9 +4489,10 @@ Predicate* ElementsOnShape::clone() const
     size += sizeof( myWorkClassifiers[0] ) * myWorkClassifiers.size();
   if ( size > 1e+9 ) // 1G
   {
-#ifdef _DEBUG_
+
+  if (SALOME::VerbosityActivated())
     std::cout << "Avoid ElementsOnShape::clone(), too large: " << size << " bytes " << std::endl;
-#endif
+
     return 0;
   }
 
@@ -4686,6 +4753,7 @@ bool ElementsOnShape::IsSatisfy (const SMDS_MeshNode* node,
           isNodeOut = false;
           if ( okShape )
             *okShape = myWorkClassifiers[i]->Shape();
+          myWorkClassifiers[i]->GetParams( myU, myV );
           break;
         }
     }
@@ -4697,6 +4765,7 @@ bool ElementsOnShape::IsSatisfy (const SMDS_MeshNode* node,
           isNodeOut = false;
           if ( okShape )
             *okShape = myClassifiers[i].Shape();
+          myClassifiers[i].GetParams( myU, myV );
           break;
         }
     }
@@ -4739,7 +4808,8 @@ void ElementsOnShape::Classifier::Init( const TopoDS_Shape& theShape,
     else
     {
       surf->Bounds( u1,u2,v1,v2 );
-      myProjFace.Init(surf, u1,u2, v1,v2, myTol );
+      myProjFace = new GeomAPI_ProjectPointOnSurf;
+      myProjFace->Init( surf, u1,u2, v1,v2, myTol );
       myIsOutFun = & ElementsOnShape::Classifier::isOutOfFace;
     }
     break;
@@ -4752,7 +4822,8 @@ void ElementsOnShape::Classifier::Init( const TopoDS_Shape& theShape,
       myIsOutFun = & ElementsOnShape::Classifier::isOutOfNone;
     else
     {
-      myProjEdge.Init(curve, u1, u2);
+      myProjEdge = new GeomAPI_ProjectPointOnCurve;
+      myProjEdge->Init( curve, u1, u2 );
       myIsOutFun = & ElementsOnShape::Classifier::isOutOfEdge;
     }
     break;
@@ -4802,6 +4873,8 @@ void ElementsOnShape::Classifier::Init( const TopoDS_Shape& theShape,
 ElementsOnShape::Classifier::~Classifier()
 {
   delete mySolidClfr; mySolidClfr = 0;
+  delete myProjFace;  myProjFace = 0;
+  delete myProjEdge;  myProjEdge = 0;
 }
 
 TopoDS_Shape ElementsOnShape::Classifier::prepareSolid( const TopoDS_Shape& theSolid )
@@ -4838,13 +4911,12 @@ bool ElementsOnShape::Classifier::isOutOfBox( const gp_Pnt& p )
 bool ElementsOnShape::Classifier::isOutOfFace( const gp_Pnt& p )
 {
   if ( isOutOfBox( p )) return true;
-  myProjFace.Perform( p );
-  if ( myProjFace.IsDone() && myProjFace.LowerDistance() <= myTol )
+  myProjFace->Perform( p );
+  if ( myProjFace->IsDone() && myProjFace->LowerDistance() <= myTol )
   {
     // check relatively to the face
-    Standard_Real u, v;
-    myProjFace.LowerDistanceParameters(u, v);
-    gp_Pnt2d aProjPnt (u, v);
+    myProjFace->LowerDistanceParameters( myU, myV );
+    gp_Pnt2d aProjPnt( myU, myV );
     BRepClass_FaceClassifier aClsf ( TopoDS::Face( myShape ), aProjPnt, myTol );
     if ( aClsf.State() == TopAbs_IN || aClsf.State() == TopAbs_ON )
       return false;
@@ -4855,8 +4927,11 @@ bool ElementsOnShape::Classifier::isOutOfFace( const gp_Pnt& p )
 bool ElementsOnShape::Classifier::isOutOfEdge( const gp_Pnt& p )
 {
   if ( isOutOfBox( p )) return true;
-  myProjEdge.Perform( p );
-  return ! ( myProjEdge.NbPoints() > 0 && myProjEdge.LowerDistance() <= myTol );
+  myProjEdge->Perform( p );
+  bool isOn = ( myProjEdge->NbPoints() > 0 && myProjEdge->LowerDistance() <= myTol );
+  if ( isOn )
+    myU = myProjEdge->LowerDistanceParameter();
+  return !isOn;
 }
 
 bool ElementsOnShape::Classifier::isOutOfVertex( const gp_Pnt& p )