Progress bar

src/NETGENPlugin/NETGENPlugin_NETGEN_2D_ONLY.cxx

@@ -128,7 +128,7 @@ bool NETGENPlugin_NETGEN_2D_ONLY::CheckHypothesis (SMESH_Mesh&         aMesh,
   _hypMaxElementArea = 0;
   _hypLengthFromEdges = 0;
   _hypQuadranglePreference = 0;
-  _isSurfaceMeshing = true;
+  _progressByTic = -1;
 
   const list<const SMESHDS_Hypothesis*>& hyps = GetUsedHypothesis(aMesh, aShape, false);
 
@@ -386,25 +386,25 @@ void NETGENPlugin_NETGEN_2D_ONLY::CancelCompute()
 double NETGENPlugin_NETGEN_2D_ONLY::GetProgress() const
 {
   const char* task1 = "Surface meshing";
-  const char* task2 = "Optimizing surface";
+  //const char* task2 = "Optimizing surface";
-  double res = 0;
+  double& progress = const_cast<NETGENPlugin_NETGEN_2D_ONLY*>( this )->_progress;
-  if ( _isSurfaceMeshing &&
+  if ( _progressByTic < 0. &&
        strncmp( netgen::multithread.task, task1, 3 ) == 0 )
   {
-    res = 0.3 * SMESH_Algo::GetProgressByTic(); // [0, 0.3]
+    progress = Min( 0.25, SMESH_Algo::GetProgressByTic() ); // [0, 0.25]
   }
   else //if ( strncmp( netgen::multithread.task, task2, 3 ) == 0)
   {
-    if ( _isSurfaceMeshing )
+    if ( _progressByTic < 0 )
     {
       NETGENPlugin_NETGEN_2D_ONLY* me = (NETGENPlugin_NETGEN_2D_ONLY*) this;
-      me->_isSurfaceMeshing = false;
+      me->_progressByTic = 0.25 / _progressTic;
-      me->_progressTic = 0; // to re-start GetProgressByTic() from 0.
     }
-    res = 0.3 + 0.7 * SMESH_Algo::GetProgressByTic(); // [0.3, 1.]
+    const_cast<NETGENPlugin_NETGEN_2D_ONLY*>( this )->_progressTic++;
+    progress = Max( progress, _progressByTic * _progressTic );
   }
-  //cout << netgen::multithread.task << " " <<res << endl;
+  //cout << netgen::multithread.task << " " << _progressTic << endl;
-  return res;
+  return Min( progress, 0.99 );
 }
 
 //=============================================================================

src/NETGENPlugin/NETGENPlugin_NETGEN_2D_ONLY.hxx

@@ -65,7 +65,7 @@ protected:
   const SMESHDS_Hypothesis*              _hypQuadranglePreference;
   const NETGENPlugin_Hypothesis_2D*      _hypParameters;
 
-  bool                                   _isSurfaceMeshing;
+  double                                 _progressByTic;
 };
 
 #endif

src/NETGENPlugin/NETGENPlugin_NETGEN_3D.cxx

@@ -143,7 +143,7 @@ bool NETGENPlugin_NETGEN_3D::CheckHypothesis (SMESH_Mesh&         aMesh,
   // for correct work of GetProgress():
   netgen::multithread.percent = 0.;
   netgen::multithread.task = "Volume meshing";
-  _optimizationStarted = false;
+  _progressByTic = -1.;
 
   list<const SMESHDS_Hypothesis*>::const_iterator itl;
   const SMESHDS_Hypothesis* theHyp;
@@ -191,6 +191,7 @@ bool NETGENPlugin_NETGEN_3D::Compute(SMESH_Mesh&         aMesh,
                                      const TopoDS_Shape& aShape)
 {
   netgen::multithread.terminate = 0;
+  _progressByTic = -1.;
   
   SMESHDS_Mesh* meshDS = aMesh.GetMeshDS();
 
@@ -493,6 +494,7 @@ bool NETGENPlugin_NETGEN_3D::Compute(SMESH_Mesh&         aMesh,
   const int invalid_ID = -1;
 
   netgen::multithread.terminate = 0;
+  _progressByTic = -1.;
 
   SMESH_MesherHelper::MType MeshType = aHelper->IsQuadraticMesh();
   if ( MeshType == SMESH_MesherHelper::COMP )
@@ -591,18 +593,24 @@ double NETGENPlugin_NETGEN_3D::GetProgress() const
   double res;
   const char* volMeshing = "Volume meshing";
   const char* dlnMeshing = "Delaunay meshing";
-  if ( !_optimizationStarted &&
+  const double meshingRatio = 0.15;
+  const_cast<NETGENPlugin_NETGEN_3D*>( this )->_progressTic++;
+
+  if ( _progressByTic < 0. &&
        ( strncmp( netgen::multithread.task, dlnMeshing, 3 ) == 0 ||
          strncmp( netgen::multithread.task, volMeshing, 3 ) == 0 ))
   {
-    res = 0.001 + 0.5 * netgen::multithread.percent / 100.; // [0., 0.5]
+    res = 0.001 + meshingRatio * netgen::multithread.percent / 100.;
+    //cout << netgen::multithread.task << " " <<_progressTic << "-" << netgen::multithread.percent << endl;
   }
   else // different otimizations
   {
-    ((NETGENPlugin_NETGEN_3D*)this)->_optimizationStarted = true;
+    if ( _progressByTic < 0. )
-    res = 0.5 + 0.5 * SMESH_Algo::GetProgressByTic(); // [0.5, 1.]
+      ((NETGENPlugin_NETGEN_3D*)this)->_progressByTic = meshingRatio / _progressTic;
+    res = _progressByTic * _progressTic;
+    //cout << netgen::multithread.task << " " << _progressTic << " " << res << endl;
   }
-  return res;
+  return Min ( res, 0.98 );
 }
 
 //=============================================================================

src/NETGENPlugin/NETGENPlugin_NETGEN_3D.hxx

@@ -77,7 +77,7 @@ class NETGENPLUGIN_EXPORT NETGENPlugin_NETGEN_3D: public SMESH_3D_Algo
   const NETGENPlugin_Hypothesis *    _hypParameters;
   const StdMeshers_MaxElementVolume* _hypMaxElementVolume;
   const StdMeshers_ViscousLayers*    _viscousLayersHyp;
-  bool                               _optimizationStarted;
+  double                             _progressByTic;
 };
 
 #endif