-// Copyright (C) 2007-2016 CEA/DEN, EDF R&D, OPEN CASCADE
+// Copyright (C) 2007-2020 CEA/DEN, EDF R&D, OPEN CASCADE
//
// Copyright (C) 2003-2007 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
using namespace std;
+// Environment variable separator
+#ifdef WIN32
+ #define env_sep ';'
+#else
+ #define env_sep ':'
+#endif
+
+namespace
+{
+ // a structure used to nullify SMESH_Gen field of SMESH_Hypothesis,
+ // which is needed for SMESH_Hypothesis not deleted before ~SMESH_Gen()
+ struct _Hyp : public SMESH_Hypothesis
+ {
+ void NullifyGen()
+ {
+ _gen = 0;
+ }
+ };
+
+ //================================================================================
+ /*!
+ * \brief Fill a map of shapes with all sub-shape of a sub-mesh
+ */
+ //================================================================================
+
+ TopTools_IndexedMapOfShape * fillAllowed( SMESH_subMesh* sm,
+ const bool toFill,
+ TopTools_IndexedMapOfShape * allowedSub )
+ {
+ if ( !toFill || !allowedSub )
+ {
+ return nullptr;
+ }
+ if ( allowedSub->IsEmpty() )
+ {
+ allowedSub->ReSize( sm->DependsOn().size() + 1 );
+ allowedSub->Add( sm->GetSubShape() );
+ for ( const auto & key_sm : sm->DependsOn() )
+ allowedSub->Add( key_sm.second->GetSubShape() );
+ }
+ return allowedSub;
+ }
+}
+
//=============================================================================
/*!
* Constructor
_compute_canceled = false;
}
-namespace
-{
- // a structure used to nullify SMESH_Gen field of SMESH_Hypothesis,
- // which is needed for SMESH_Hypothesis not deleted before ~SMESH_Gen()
- struct _Hyp : public SMESH_Hypothesis
- {
- void NullifyGen()
- {
- _gen = 0;
- }
- };
-}
-
//=============================================================================
/*!
* Destructor
SMESH_Gen::~SMESH_Gen()
{
- std::map < int, SMESH_Hypothesis * >::iterator i_hyp = _studyContext->mapHypothesis.begin();
- for ( ; i_hyp != _studyContext->mapHypothesis.end(); ++i_hyp )
- {
- if ( _Hyp* h = static_cast< _Hyp*>( i_hyp->second ))
- h->NullifyGen();
- }
+ std::map < int, SMESH_Hypothesis * >::iterator i_hyp = _studyContext->mapHypothesis.begin();
+ for ( ; i_hyp != _studyContext->mapHypothesis.end(); ++i_hyp )
+ {
+ if ( _Hyp* h = static_cast< _Hyp*>( i_hyp->second ))
+ h->NullifyGen();
+ }
delete _studyContext->myDocument;
delete _studyContext;
}
//=============================================================================
SMESH_Mesh* SMESH_Gen::CreateMesh(bool theIsEmbeddedMode)
- throw(SALOME_Exception)
{
Unexpect aCatch(SalomeException);
*/
//=============================================================================
-bool SMESH_Gen::Compute(SMESH_Mesh & aMesh,
- const TopoDS_Shape & aShape,
- const int aFlags /*= COMPACT_MESH*/,
- const ::MeshDimension aDim /*=::MeshDim_3D*/,
- TSetOfInt* aShapesId /*=0*/)
+bool SMESH_Gen::Compute(SMESH_Mesh & aMesh,
+ const TopoDS_Shape & aShape,
+ const int aFlags /*= COMPACT_MESH*/,
+ const ::MeshDimension aDim /*=::MeshDim_3D*/,
+ TSetOfInt* aShapesId /*=0*/,
+ TopTools_IndexedMapOfShape* anAllowedSubShapes/*=0*/)
{
MEMOSTAT;
bool ret = true;
- SMESH_subMesh *sm = aMesh.GetSubMesh(aShape);
+ SMESH_subMesh *sm, *shapeSM = aMesh.GetSubMesh(aShape);
const bool includeSelf = true;
const bool complexShapeFirst = true;
if ( !aMesh.HasShapeToMesh() )
computeEvent = SMESH_subMesh::COMPUTE_NOGEOM; // if several algos and no geometry
+ TopTools_IndexedMapOfShape *allowedSubShapes = anAllowedSubShapes, allowedSub;
+ if ( aShapeOnly && !allowedSubShapes )
+ allowedSubShapes = &allowedSub;
+
if ( anUpward ) // is called from the below code in this method
{
// ===============================================
// Mesh all the sub-shapes starting from vertices
// ===============================================
- smIt = sm->getDependsOnIterator(includeSelf, !complexShapeFirst);
+ smIt = shapeSM->getDependsOnIterator(includeSelf, !complexShapeFirst);
while ( smIt->more() )
{
SMESH_subMesh* smToCompute = smIt->next();
{
if (_compute_canceled)
return false;
+ smToCompute->SetAllowedSubShapes( fillAllowed( shapeSM, aShapeOnly, allowedSubShapes ));
setCurrentSubMesh( smToCompute );
smToCompute->ComputeStateEngine( computeEvent );
- setCurrentSubMesh( NULL );
+ setCurrentSubMesh( nullptr );
+ smToCompute->SetAllowedSubShapes( nullptr );
}
// we check all the sub-meshes here and detect if any of them failed to compute
TopoDS_Shape algoShape;
int prevShapeDim = -1, aShapeDim;
- smIt = sm->getDependsOnIterator(includeSelf, complexShapeFirst);
+ smIt = shapeSM->getDependsOnIterator(includeSelf, complexShapeFirst);
while ( smIt->more() )
{
SMESH_subMesh* smToCompute = smIt->next();
{
if (_compute_canceled)
return false;
+ smToCompute->SetAllowedSubShapes( fillAllowed( shapeSM, aShapeOnly, allowedSubShapes ));
setCurrentSubMesh( smToCompute );
smToCompute->ComputeStateEngine( computeEvent );
- setCurrentSubMesh( NULL );
+ setCurrentSubMesh( nullptr );
+ smToCompute->SetAllowedSubShapes( nullptr );
if ( aShapesId )
aShapesId->insert( smToCompute->GetId() );
}
std::vector< SMESH_subMesh* > smVec;
for ( aShapeDim = 0; aShapeDim < 4; ++aShapeDim )
+ smVec.insert( smVec.end(),
+ smWithAlgoSupportingSubmeshes[aShapeDim].begin(),
+ smWithAlgoSupportingSubmeshes[aShapeDim].end() );
{
// ------------------------------------------------
// sort list of sub-meshes according to mesh order
// ------------------------------------------------
- smVec.assign( smWithAlgoSupportingSubmeshes[ aShapeDim ].begin(),
- smWithAlgoSupportingSubmeshes[ aShapeDim ].end() );
aMesh.SortByMeshOrder( smVec );
// ------------------------------------------------------------
for ( size_t i = 0; i < smVec.size(); ++i )
{
sm = smVec[i];
+ if ( sm->GetComputeState() != SMESH_subMesh::READY_TO_COMPUTE)
+ continue;
+
+ const TopAbs_ShapeEnum shapeType = sm->GetSubShape().ShapeType();
// get a shape the algo is assigned to
if ( !GetAlgo( sm, & algoShape ))
continue; // strange...
// look for more local algos
- smIt = sm->getDependsOnIterator(!includeSelf, !complexShapeFirst);
+ if ( SMESH_subMesh* algoSM = aMesh.GetSubMesh( algoShape ))
+ smIt = algoSM->getDependsOnIterator(!includeSelf, !complexShapeFirst);
+ else
+ smIt = sm->getDependsOnIterator(!includeSelf, !complexShapeFirst);
+
while ( smIt->more() )
{
SMESH_subMesh* smToCompute = smIt->next();
const TopoDS_Shape& aSubShape = smToCompute->GetSubShape();
const int aShapeDim = GetShapeDim( aSubShape );
- //if ( aSubShape.ShapeType() == TopAbs_VERTEX ) continue;
- if ( aShapeDim < 1 ) continue;
+ if ( aShapeDim < 1 || aSubShape.ShapeType() == shapeType )
+ continue;
// check for preview dimension limitations
if ( aShapesId && GetShapeDim( aSubShape.ShapeType() ) > (int)aDim )
if ( SMESH_Algo* subAlgo = (SMESH_Algo*) aMesh.GetHypothesis( smToCompute, filter, true))
{
if ( ! subAlgo->NeedDiscreteBoundary() ) continue;
+ TopTools_IndexedMapOfShape* localAllowed = allowedSubShapes;
+ if ( localAllowed && localAllowed->IsEmpty() )
+ localAllowed = 0; // prevent fillAllowed() with aSubShape
+
SMESH_Hypothesis::Hypothesis_Status status;
if ( subAlgo->CheckHypothesis( aMesh, aSubShape, status ))
// mesh a lower smToCompute starting from vertices
- Compute( aMesh, aSubShape, aFlags | SHAPE_ONLY_UPWARD, aDim, aShapesId );
- // Compute( aMesh, aSubShape, aShapeOnly, /*anUpward=*/true, aDim, aShapesId );
+ Compute( aMesh, aSubShape, aFlags | SHAPE_ONLY_UPWARD, aDim, aShapesId, localAllowed );
}
}
- }
- // --------------------------------
- // apply the all-dimensional algos
- // --------------------------------
- for ( size_t i = 0; i < smVec.size(); ++i )
- {
- sm = smVec[i];
- if ( sm->GetComputeState() == SMESH_subMesh::READY_TO_COMPUTE)
+ // --------------------------------
+ // apply the all-dimensional algo
+ // --------------------------------
{
- const TopAbs_ShapeEnum shapeType = sm->GetSubShape().ShapeType();
+ if (_compute_canceled)
+ return false;
// check for preview dimension limitations
if ( aShapesId && GetShapeDim( shapeType ) > (int)aDim )
continue;
-
- if (_compute_canceled)
- return false;
+ sm->SetAllowedSubShapes( fillAllowed( shapeSM, aShapeOnly, allowedSubShapes ));
setCurrentSubMesh( sm );
sm->ComputeStateEngine( computeEvent );
setCurrentSubMesh( NULL );
+ sm->SetAllowedSubShapes( nullptr );
if ( aShapesId )
aShapesId->insert( sm->GetId() );
}
}
- } // loop on shape dimensions
+ }
// -----------------------------------------------
// mesh the rest sub-shapes starting from vertices
// -----------------------------------------------
- ret = Compute( aMesh, aShape, aFlags | UPWARD, aDim, aShapesId );
+ ret = Compute( aMesh, aShape, aFlags | UPWARD, aDim, aShapesId, allowedSubShapes );
}
MEMOSTAT;
SMESH_MesherHelper aHelper( aMesh );
if ( aHelper.IsQuadraticMesh() != SMESH_MesherHelper::LINEAR )
{
- aHelper.FixQuadraticElements( sm->GetComputeError() );
+ aHelper.FixQuadraticElements( shapeSM->GetComputeError() );
}
}
* Prepare Compute a mesh
*/
//=============================================================================
-void SMESH_Gen::PrepareCompute(SMESH_Mesh & aMesh,
- const TopoDS_Shape & aShape)
+void SMESH_Gen::PrepareCompute(SMESH_Mesh & /*aMesh*/,
+ const TopoDS_Shape & /*aShape*/)
{
_compute_canceled = false;
resetCurrentSubMesh();
* Cancel Compute a mesh
*/
//=============================================================================
-void SMESH_Gen::CancelCompute(SMESH_Mesh & aMesh,
- const TopoDS_Shape & aShape)
+void SMESH_Gen::CancelCompute(SMESH_Mesh & /*aMesh*/,
+ const TopoDS_Shape & /*aShape*/)
{
_compute_canceled = true;
if ( const SMESH_subMesh* sm = GetCurrentSubMesh() )
while ( from < meshers.size() )
{
// cut off plugin name
- pos = meshers.find( ':', from );
+ pos = meshers.find( env_sep, from );
if ( pos != string::npos )
plugin = meshers.substr( from, pos-from );
else
}
// get a separator from rootDir
- for ( pos = strlen( rootDir )-1; pos >= 0 && sep.empty(); --pos )
- if ( rootDir[pos] == '/' || rootDir[pos] == '\\' )
+ for ( int i = strlen( rootDir )-1; i >= 0 && sep.empty(); --i )
+ if ( rootDir[i] == '/' || rootDir[i] == '\\' )
{
- sep = rootDir[pos];
+ sep = rootDir[i];
break;
}
#ifdef WIN32
xmlPath += sep + plugin + ".xml";
bool fileOK;
#ifdef WIN32
-#ifdef UNICODE
- const wchar_t* path = Kernel_Utils::decode_s(xmlPath);
-#else
- const char* path = xmlPath.c_str();
-#endif
+ #ifdef UNICODE
+ const wchar_t* path = Kernel_Utils::decode_s(xmlPath);
+ #else
+ const char* path = xmlPath.c_str();
+ #endif
+
fileOK = (GetFileAttributes(path) != INVALID_FILE_ATTRIBUTES);
-#ifdef UNICODE
- delete path;
-#endif
+
+ #ifdef UNICODE
+ delete path;
+ #endif
+
#else
fileOK = (access(xmlPath.c_str(), F_OK) == 0);
#endif