Compute Progress bar

+  bool DependsOn( const SMESH_subMesh* other ) const;
+  int                   _realComputeCost; // _computeCost depending on presence of needed hypotheses

diff --git a/src/SMESH/SMESH_subMesh.cxx b/src/SMESH/SMESH_subMesh.cxx
index 7b7fc75b9249fb05df5605905086d243a36776e1..483495be5fa4cafabcbf9182920034dcb1f6882c 100644 (file)
--- a/src/SMESH/SMESH_subMesh.cxx
+++ b/src/SMESH/SMESH_subMesh.cxx
@@ -105,6 +105,7 @@ SMESH_subMesh::SMESH_subMesh(int                  Id,
     _computeState = NOT_READY;
   }
   _computeCost = 0; // how costly is to compute this sub-mesh
+  _realComputeCost = 0;
 }
 
 //=============================================================================
@@ -358,13 +359,26 @@ bool SMESH_subMesh::SubMeshesComputed(bool * isFailedToCompute/*=0*/) const
 
 //================================================================================
 /*!
- * \brief Return cost of computing this sub-mesh. The cost depends on the shape type
- * and number of sub-meshes this one DependsOn().
+ * \brief Return cost of computing this sub-mesh. If hypotheses are not well defined,
+ *        zero is returned
  *  \return int - the computation cost in abstract units.
  */
 //================================================================================
 
 int SMESH_subMesh::GetComputeCost() const
+{
+  return _realComputeCost;
+}
+
+//================================================================================
+/*!
+ * \brief Return cost of computing this sub-mesh. The cost depends on the shape type
+ *        and number of sub-meshes this one DependsOn().
+ *  \return int - the computation cost in abstract units.
+ */
+//================================================================================
+
+int SMESH_subMesh::computeCost() const
 {
   if ( !_computeCost )
   {
@@ -378,7 +392,7 @@ int SMESH_subMesh::GetComputeCost() const
     }
     SMESH_subMeshIteratorPtr childIt = getDependsOnIterator(/*includeSelf=*/false);
     while ( childIt->more() )
-      computeCost += childIt->next()->GetComputeCost();
+      computeCost += childIt->next()->computeCost();
 
     ((SMESH_subMesh*)this)->_computeCost = computeCost;
   }
@@ -531,6 +545,23 @@ const map < int, SMESH_subMesh * >& SMESH_subMesh::DependsOn()
   return _mapDepend;
 }
 
+//================================================================================
+/*!
+ * \brief Return a key for SMESH_subMesh::_mapDepend map
+ */
+//================================================================================
+
+namespace {
+  int dependsOnMapKey( const SMESH_subMesh* sm )
+  {
+    int type = sm->GetSubShape().ShapeType();
+    int ordType = 9 - type;               // 2 = Vertex, 8 = CompSolid
+    int cle = sm->GetId();
+    cle += 10000000 * ordType;    // sort map by ordType then index
+    return cle;
+  }
+}
+
 //=============================================================================
 /*!
  * For simple Shapes (solid, face, edge): add subMesh into dependence list.
@@ -540,10 +571,7 @@ const map < int, SMESH_subMesh * >& SMESH_subMesh::DependsOn()
 void SMESH_subMesh::insertDependence(const TopoDS_Shape aSubShape)
 {
   SMESH_subMesh *aSubMesh = _father->GetSubMesh(aSubShape);
-  int type = aSubShape.ShapeType();
-  int ordType = 9 - type;               // 2 = Vertex, 8 = CompSolid
-  int cle = aSubMesh->GetId();
-  cle += 10000000 * ordType;    // sort map by ordType then index
+  int cle = dependsOnMapKey( aSubMesh );
   if ( _mapDepend.find( cle ) == _mapDepend.end())
   {
     _mapDepend[cle] = aSubMesh;
@@ -552,19 +580,28 @@ void SMESH_subMesh::insertDependence(const TopoDS_Shape aSubShape)
   }
 }
 
+//================================================================================
+/*!
+ * \brief Return \c true if \a this sub-mesh depends on \a other
+ */
+//================================================================================
+
+bool SMESH_subMesh::DependsOn( const SMESH_subMesh* other ) const
+{
+  return other ? _mapDepend.count( dependsOnMapKey( other )) : false;
+}
+
 //=============================================================================
 /*!
- *
+ * Return a shape of \a this sub-mesh
  */
 //=============================================================================
 
 const TopoDS_Shape & SMESH_subMesh::GetSubShape() const
 {
-        //MESSAGE("SMESH_subMesh::GetSubShape");
-        return _subShape;
+  return _subShape;
 }
 
-
 //=======================================================================
 //function : CanAddHypothesis
 //purpose  : return true if theHypothesis can be attached to me:
@@ -1104,6 +1141,8 @@ SMESH_Hypothesis::Hypothesis_Status
   if (stateChange || modifiedHyp)
     ComputeStateEngine(MODIF_ALGO_STATE);
 
+  _realComputeCost = ( _algoState == HYP_OK ) ? computeCost() : 0;
+
   return ret;
 }
 
@@ -1492,14 +1531,14 @@ bool SMESH_subMesh::ComputeStateEngine(int event)
           break;
         }
         TopoDS_Shape shape = _subShape;
-        int computeCost = GetComputeCost();
+        algo->SubMeshesToCompute().assign( 1, this );
         // check submeshes needed
         if (_father->HasShapeToMesh() ) {
           bool subComputed = false, subFailed = false;
           if (!algo->OnlyUnaryInput()) {
             if ( event == COMPUTE /*&&
                  ( algo->NeedDiscreteBoundary() || algo->SupportSubmeshes() )*/)
-              shape = getCollection( gen, algo, subComputed, subFailed, computeCost);
+              shape = getCollection( gen, algo, subComputed, subFailed, algo->SubMeshesToCompute());
             else
               subComputed = SubMeshesComputed( & subFailed );
           }
@@ -1532,7 +1571,6 @@ bool SMESH_subMesh::ComputeStateEngine(int event)
           OCC_CATCH_SIGNALS;
 #endif
           algo->InitComputeError();
-          algo->GetComputeCost() = computeCost;
 
           MemoryReserve aMemoryReserve;
           SMDS_Mesh::CheckMemory();
@@ -2062,7 +2100,7 @@ TopoDS_Shape SMESH_subMesh::getCollection(SMESH_Gen * theGen,
                                           SMESH_Algo* theAlgo,
                                           bool &      theSubComputed,
                                           bool &      theSubFailed,
-                                          int  &      theComputeCost)
+                                          std::vector<SMESH_subMesh*>& theSubs)
 {
   theSubComputed = SubMeshesComputed( & theSubFailed );
 
@@ -2082,15 +2120,14 @@ TopoDS_Shape SMESH_subMesh::getCollection(SMESH_Gen * theGen,
   BRep_Builder aBuilder;
   aBuilder.MakeCompound( aCompound );
 
-  theComputeCost = 0;
+  theSubs.clear();
 
   TopExp_Explorer anExplorer( mainShape, _subShape.ShapeType() );
   for ( ; anExplorer.More(); anExplorer.Next() )
   {
     const TopoDS_Shape& S = anExplorer.Current();
     SMESH_subMesh* subMesh = _father->GetSubMesh( S );
-    if ( subMesh->GetComputeState() != NOT_READY )
-      theComputeCost += subMesh->GetComputeCost();
+    theSubs.push_back( subMesh );
     if ( subMesh == this )
     {
       aBuilder.Add( aCompound, S );
@@ -2104,17 +2141,6 @@ TopoDS_Shape SMESH_subMesh::getCollection(SMESH_Gen * theGen,
       if ( !subMesh->SubMeshesComputed() )
         theSubComputed = false;
     }
-    if ( !theAlgo->NeedDiscreteBoundary() )
-    {
-      SMESH_subMeshIteratorPtr smIt = subMesh->getDependsOnIterator(/*includeSelf=*/false);
-      while ( smIt->more() )
-      {
-        SMESH_subMesh* sm = smIt->next();
-        if ( sm->GetComputeState() != NOT_READY &&
-             sm->IsEmpty() )
-          theComputeCost += sm->GetComputeCost();
-      }
-    }
   }
 
   return aCompound;

diff --git a/src/SMESH/SMESH_subMesh.hxx b/src/SMESH/SMESH_subMesh.hxx
index effe550983f892477ae80e8cb51a34ac5079bcef..63ff08d3f8a6077e6902d15d7f1d54446741fe3c 100644 (file)
--- a/src/SMESH/SMESH_subMesh.hxx
+++ b/src/SMESH/SMESH_subMesh.hxx
@@ -80,6 +80,7 @@ class SMESH_EXPORT SMESH_subMesh
   SMESH_Algo* GetAlgo() const;
 
   const std::map < int, SMESH_subMesh * >& DependsOn();
+  bool DependsOn( const SMESH_subMesh* other ) const;
   /*!
    * \brief Return iterator on the sub-meshes this one depends on. By default
    *        most simple sub-meshes go first.
@@ -287,7 +288,7 @@ protected:
                              SMESH_Algo* theAlgo,
                              bool &      theSubComputed,
                              bool &      theSubFailed,
-                             int  &      theComputeCost);
+                             std::vector<SMESH_subMesh*>& theSubs);
   /*!
    * \brief Update compute_state by _computeError
     * \retval bool - false if there are errors
@@ -307,6 +308,7 @@ protected:
                                              const SMESH_Hypothesis * theHyp,
                                              const int                theHypType = 0);
   // 
+  int computeCost() const;
 
 protected:
 
@@ -322,7 +324,8 @@ protected:
   algo_state            _algoState;
   compute_state         _computeState;
   SMESH_ComputeErrorPtr _computeError;
-  int                   _computeCost; // how costly is to compute this sub-mesh
+  int                   _computeCost;     // how costly is to compute this sub-mesh
+  int                   _realComputeCost; // _computeCost depending on presence of needed hypotheses
 
   // allow algo->Compute() if a sub-shape of lower dim is meshed but
   // none mesh entity is bound to it. Eg StdMeshers_CompositeSegment_1D can