X-Git-Url: http://git.salome-platform.org/gitweb/?p=modules%2Fsmesh.git;a=blobdiff_plain;f=src%2FSMESH%2FSMESH_Gen.cxx;h=7ca0a59fa14bf66169b75b1e78cd6a1cfd4d1c11;hp=2e8a963078a6e67d006db824b98c0e813d38c4bc;hb=b2eb2c3cef7c6fffbcc17e027be5e4d0357a935a;hpb=88b3dbe23b236bd1746405155ae33a76aaf59ecd diff --git a/src/SMESH/SMESH_Gen.cxx b/src/SMESH/SMESH_Gen.cxx index 2e8a96307..7ca0a59fa 100644 --- a/src/SMESH/SMESH_Gen.cxx +++ b/src/SMESH/SMESH_Gen.cxx @@ -1,4 +1,4 @@ -// Copyright (C) 2007-2012 CEA/DEN, EDF R&D, OPEN CASCADE +// Copyright (C) 2007-2016 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 @@ -6,7 +6,7 @@ // This library is free software; you can redistribute it and/or // modify it under the terms of the GNU Lesser General Public // License as published by the Free Software Foundation; either -// version 2.1 of the License. +// version 2.1 of the License, or (at your option) any later version. // // This library is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of @@ -35,6 +35,7 @@ #include "SMDS_MeshNode.hxx" #include "SMESHDS_Document.hxx" #include "SMESH_HypoFilter.hxx" +#include "SMESH_Mesh.hxx" #include "SMESH_MesherHelper.hxx" #include "SMESH_subMesh.hxx" @@ -43,10 +44,11 @@ #include "Utils_ExceptHandlers.hxx" #include +#include #include "memoire.h" -#ifdef WNT +#ifdef WIN32 #include #endif @@ -63,18 +65,12 @@ using namespace std; SMESH_Gen::SMESH_Gen() { - MESSAGE("SMESH_Gen::SMESH_Gen"); - _localId = 0; - _hypId = 0; - _segmentation = _nbSegments = 10; - SMDS_Mesh::_meshList.clear(); - MESSAGE(SMDS_Mesh::_meshList.size()); - //_counters = new counters(100); -#ifdef WITH_SMESH_CANCEL_COMPUTE - _compute_canceled = false; - _sm_current = NULL; -#endif - //vtkDebugLeaks::SetExitError(0); + _localId = 0; + _hypId = 0; + _segmentation = _nbSegments = 10; + SMDS_Mesh::_meshList.clear(); + _compute_canceled = false; + //vtkDebugLeaks::SetExitError(0); } //============================================================================= @@ -85,7 +81,6 @@ SMESH_Gen::SMESH_Gen() SMESH_Gen::~SMESH_Gen() { - MESSAGE("SMESH_Gen::~SMESH_Gen"); std::map < int, StudyContextStruct * >::iterator i_sc = _mapStudyContext.begin(); for ( ; i_sc != _mapStudyContext.end(); ++i_sc ) { @@ -105,7 +100,6 @@ SMESH_Mesh* SMESH_Gen::CreateMesh(int theStudyId, bool theIsEmbeddedMode) throw(SALOME_Exception) { Unexpect aCatch(SalomeException); - MESSAGE("SMESH_Gen::CreateMesh"); // Get studyContext, create it if it does'nt exist, with a SMESHDS_Document StudyContextStruct *aStudyContext = GetStudyContext(theStudyId); @@ -122,20 +116,23 @@ SMESH_Mesh* SMESH_Gen::CreateMesh(int theStudyId, bool theIsEmbeddedMode) } //============================================================================= -/*! +/* * Compute a mesh */ //============================================================================= bool SMESH_Gen::Compute(SMESH_Mesh & aMesh, const TopoDS_Shape & aShape, - const bool anUpward, - const ::MeshDimension aDim, - TSetOfInt* aShapesId) + const int aFlags /*= COMPACT_MESH*/, + const ::MeshDimension aDim /*=::MeshDim_3D*/, + TSetOfInt* aShapesId /*=0*/) { - MESSAGE("SMESH_Gen::Compute"); MEMOSTAT; + const bool aShapeOnly = aFlags & SHAPE_ONLY; + const bool anUpward = aFlags & UPWARD; + const bool aCompactMesh = aFlags & COMPACT_MESH; + bool ret = true; SMESH_subMesh *sm = aMesh.GetSubMesh(aShape); @@ -146,23 +143,33 @@ bool SMESH_Gen::Compute(SMESH_Mesh & aMesh, SMESH_subMeshIteratorPtr smIt; - if ( anUpward ) // is called from below code here + // Fix of Issue 22150. Due to !BLSURF->OnlyUnaryInput(), BLSURF computes edges + // that must be computed by Projection 1D-2D while the Projection asks to compute + // one face only. + SMESH_subMesh::compute_event computeEvent = + aShapeOnly ? SMESH_subMesh::COMPUTE_SUBMESH : SMESH_subMesh::COMPUTE; + if ( !aMesh.HasShapeToMesh() ) + computeEvent = SMESH_subMesh::COMPUTE_NOGEOM; // if several algos and no geometry + + if ( anUpward ) // is called from the below code in this method { - // ----------------------------------------------- - // mesh all the sub-shapes starting from vertices - // ----------------------------------------------- + // =============================================== + // Mesh all the sub-shapes starting from vertices + // =============================================== + smIt = sm->getDependsOnIterator(includeSelf, !complexShapeFirst); while ( smIt->more() ) { SMESH_subMesh* smToCompute = smIt->next(); // do not mesh vertices of a pseudo shape - const TopAbs_ShapeEnum aShType = smToCompute->GetSubShape().ShapeType(); - if ( !aMesh.HasShapeToMesh() && aShType == TopAbs_VERTEX ) + const TopoDS_Shape& shape = smToCompute->GetSubShape(); + const TopAbs_ShapeEnum shapeType = shape.ShapeType(); + if ( !aMesh.HasShapeToMesh() && shapeType == TopAbs_VERTEX ) continue; // check for preview dimension limitations - if ( aShapesId && GetShapeDim( aShType ) > (int)aDim ) + if ( aShapesId && GetShapeDim( shapeType ) > (int)aDim ) { // clear compute state not to show previous compute errors // if preview invoked less dimension less than previous @@ -172,19 +179,16 @@ bool SMESH_Gen::Compute(SMESH_Mesh & aMesh, if (smToCompute->GetComputeState() == SMESH_subMesh::READY_TO_COMPUTE) { -#ifdef WITH_SMESH_CANCEL_COMPUTE if (_compute_canceled) return false; - _sm_current = smToCompute; -#endif - smToCompute->ComputeStateEngine( SMESH_subMesh::COMPUTE ); -#ifdef WITH_SMESH_CANCEL_COMPUTE - _sm_current = NULL; -#endif + setCurrentSubMesh( smToCompute ); + smToCompute->ComputeStateEngine( computeEvent ); + setCurrentSubMesh( NULL ); } - // we check all the submeshes here and detect if any of them failed to compute - if (smToCompute->GetComputeState() == SMESH_subMesh::FAILED_TO_COMPUTE) + // we check all the sub-meshes here and detect if any of them failed to compute + if (smToCompute->GetComputeState() == SMESH_subMesh::FAILED_TO_COMPUTE && + ( shapeType != TopAbs_EDGE || !SMESH_Algo::isDegenerated( TopoDS::Edge( shape )))) ret = false; else if ( aShapesId ) aShapesId->insert( smToCompute->GetId() ); @@ -194,19 +198,23 @@ bool SMESH_Gen::Compute(SMESH_Mesh & aMesh, } else { - // ----------------------------------------------------------------- - // apply algos that DO NOT require Discreteized boundaries and DO NOT - // support submeshes, starting from the most complex shapes - // and collect submeshes with algos that DO support submeshes - // ----------------------------------------------------------------- - list< SMESH_subMesh* > smWithAlgoSupportingSubmeshes; + // ================================================================ + // Apply algos that do NOT require discreteized boundaries + // ("all-dimensional") and do NOT support sub-meshes, starting from + // the most complex shapes and collect sub-meshes with algos that + // DO support sub-meshes + // ================================================================ + + list< SMESH_subMesh* > smWithAlgoSupportingSubmeshes[4]; // for each dim // map to sort sm with same dim algos according to dim of - // the shape the algo assigned to (issue 0021217) + // the shape the algo assigned to (issue 0021217). + // Other issues influenced the algo applying order: + // 21406, 21556, 21893, 20206 multimap< int, SMESH_subMesh* > shDim2sm; multimap< int, SMESH_subMesh* >::reverse_iterator shDim2smIt; TopoDS_Shape algoShape; - int prevShapeDim = -1; + int prevShapeDim = -1, aShapeDim; smIt = sm->getDependsOnIterator(includeSelf, complexShapeFirst); while ( smIt->more() ) @@ -216,14 +224,14 @@ bool SMESH_Gen::Compute(SMESH_Mesh & aMesh, continue; const TopoDS_Shape& aSubShape = smToCompute->GetSubShape(); - int aShapeDim = GetShapeDim( aSubShape ); + aShapeDim = GetShapeDim( aSubShape ); if ( aShapeDim < 1 ) break; // check for preview dimension limitations if ( aShapesId && aShapeDim > (int)aDim ) continue; - SMESH_Algo* algo = GetAlgo( aMesh, aSubShape, &algoShape ); + SMESH_Algo* algo = GetAlgo( smToCompute, &algoShape ); if ( algo && !algo->NeedDiscreteBoundary() ) { if ( algo->SupportSubmeshes() ) @@ -235,9 +243,9 @@ bool SMESH_Gen::Compute(SMESH_Mesh & aMesh, prevShapeDim = aShapeDim; for ( shDim2smIt = shDim2sm.rbegin(); shDim2smIt != shDim2sm.rend(); ++shDim2smIt ) if ( shDim2smIt->first == globalAlgoDim ) - smWithAlgoSupportingSubmeshes.push_back( shDim2smIt->second ); + smWithAlgoSupportingSubmeshes[ aShapeDim ].push_back( shDim2smIt->second ); else - smWithAlgoSupportingSubmeshes.push_front( shDim2smIt->second ); + smWithAlgoSupportingSubmeshes[ aShapeDim ].push_front( shDim2smIt->second ); shDim2sm.clear(); } // add smToCompute to shDim2sm map @@ -256,17 +264,13 @@ bool SMESH_Gen::Compute(SMESH_Mesh & aMesh, } shDim2sm.insert( make_pair( aShapeDim, smToCompute )); } - else + else // Compute w/o support of sub-meshes { -#ifdef WITH_SMESH_CANCEL_COMPUTE if (_compute_canceled) return false; - _sm_current = smToCompute; -#endif - smToCompute->ComputeStateEngine( SMESH_subMesh::COMPUTE ); -#ifdef WITH_SMESH_CANCEL_COMPUTE - _sm_current = NULL; -#endif + setCurrentSubMesh( smToCompute ); + smToCompute->ComputeStateEngine( computeEvent ); + setCurrentSubMesh( NULL ); if ( aShapesId ) aShapesId->insert( smToCompute->GetId() ); } @@ -275,101 +279,103 @@ bool SMESH_Gen::Compute(SMESH_Mesh & aMesh, // reload sub-meshes from shDim2sm into smWithAlgoSupportingSubmeshes for ( shDim2smIt = shDim2sm.rbegin(); shDim2smIt != shDim2sm.rend(); ++shDim2smIt ) if ( shDim2smIt->first == globalAlgoDim ) - smWithAlgoSupportingSubmeshes.push_back( shDim2smIt->second ); + smWithAlgoSupportingSubmeshes[3].push_back( shDim2smIt->second ); else - smWithAlgoSupportingSubmeshes.push_front( shDim2smIt->second ); + smWithAlgoSupportingSubmeshes[0].push_front( shDim2smIt->second ); - // ------------------------------------------------------------ - // sort list of submeshes according to mesh order - // ------------------------------------------------------------ - aMesh.SortByMeshOrder( smWithAlgoSupportingSubmeshes ); + // ====================================================== + // Apply all-dimensional algorithms supporing sub-meshes + // ====================================================== - // ------------------------------------------------------------ - // compute submeshes under shapes with algos that DO NOT require - // Discreteized boundaries and DO support submeshes - // ------------------------------------------------------------ - list< SMESH_subMesh* >::iterator subIt, subEnd; - subIt = smWithAlgoSupportingSubmeshes.begin(); - subEnd = smWithAlgoSupportingSubmeshes.end(); - // start from lower shapes - for ( ; subIt != subEnd; ++subIt ) + std::vector< SMESH_subMesh* > smVec; + for ( aShapeDim = 0; aShapeDim < 4; ++aShapeDim ) { - sm = *subIt; + // ------------------------------------------------ + // sort list of sub-meshes according to mesh order + // ------------------------------------------------ + smVec.assign( smWithAlgoSupportingSubmeshes[ aShapeDim ].begin(), + smWithAlgoSupportingSubmeshes[ aShapeDim ].end() ); + aMesh.SortByMeshOrder( smVec ); + + // ------------------------------------------------------------ + // compute sub-meshes with local uni-dimensional algos under + // sub-meshes with all-dimensional algos + // ------------------------------------------------------------ + // start from lower shapes + for ( size_t i = 0; i < smVec.size(); ++i ) + { + sm = smVec[i]; - // get a shape the algo is assigned to - if ( !GetAlgo( aMesh, sm->GetSubShape(), & algoShape )) - continue; // strange... + // get a shape the algo is assigned to + if ( !GetAlgo( sm, & algoShape )) + continue; // strange... - // look for more local algos - smIt = sm->getDependsOnIterator(!includeSelf, !complexShapeFirst); - while ( smIt->more() ) - { - SMESH_subMesh* smToCompute = smIt->next(); + // look for more local algos + 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; + const TopoDS_Shape& aSubShape = smToCompute->GetSubShape(); + const int aShapeDim = GetShapeDim( aSubShape ); + //if ( aSubShape.ShapeType() == TopAbs_VERTEX ) continue; + if ( aShapeDim < 1 ) continue; - // check for preview dimension limitations - if ( aShapesId && GetShapeDim( aSubShape.ShapeType() ) > (int)aDim ) - continue; - - SMESH_HypoFilter filter( SMESH_HypoFilter::IsAlgo() ); - filter - .And( SMESH_HypoFilter::IsApplicableTo( aSubShape )) - .And( SMESH_HypoFilter::IsMoreLocalThan( algoShape, aMesh )); + // check for preview dimension limitations + if ( aShapesId && GetShapeDim( aSubShape.ShapeType() ) > (int)aDim ) + continue; - if ( SMESH_Algo* subAlgo = (SMESH_Algo*) aMesh.GetHypothesis( aSubShape, filter, true )) { - if ( ! subAlgo->NeedDiscreteBoundary() ) continue; - SMESH_Hypothesis::Hypothesis_Status status; - if ( subAlgo->CheckHypothesis( aMesh, aSubShape, status )) - // mesh a lower smToCompute starting from vertices - Compute( aMesh, aSubShape, /*anUpward=*/true, aDim, aShapesId ); + SMESH_HypoFilter filter( SMESH_HypoFilter::IsAlgo() ); + filter + .And( SMESH_HypoFilter::IsApplicableTo( aSubShape )) + .And( SMESH_HypoFilter::IsMoreLocalThan( algoShape, aMesh )); + + if ( SMESH_Algo* subAlgo = (SMESH_Algo*) aMesh.GetHypothesis( smToCompute, filter, true)) + { + if ( ! subAlgo->NeedDiscreteBoundary() ) continue; + 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 ); + } } } - } - // ---------------------------------------------------------- - // apply the algos that do not require Discreteized boundaries - // ---------------------------------------------------------- - for ( subIt = smWithAlgoSupportingSubmeshes.begin(); subIt != subEnd; ++subIt ) - { - sm = *subIt; - if ( sm->GetComputeState() == SMESH_subMesh::READY_TO_COMPUTE) + // -------------------------------- + // apply the all-dimensional algos + // -------------------------------- + for ( size_t i = 0; i < smVec.size(); ++i ) { - const TopAbs_ShapeEnum aShType = sm->GetSubShape().ShapeType(); - // check for preview dimension limitations - if ( aShapesId && GetShapeDim( aShType ) > (int)aDim ) - continue; + sm = smVec[i]; + if ( sm->GetComputeState() == SMESH_subMesh::READY_TO_COMPUTE) + { + const TopAbs_ShapeEnum shapeType = sm->GetSubShape().ShapeType(); + // check for preview dimension limitations + if ( aShapesId && GetShapeDim( shapeType ) > (int)aDim ) + continue; -#ifdef WITH_SMESH_CANCEL_COMPUTE - if (_compute_canceled) - return false; - _sm_current = sm; -#endif - sm->ComputeStateEngine( SMESH_subMesh::COMPUTE ); -#ifdef WITH_SMESH_CANCEL_COMPUTE - _sm_current = NULL; -#endif - if ( aShapesId ) - aShapesId->insert( sm->GetId() ); + if (_compute_canceled) + return false; + setCurrentSubMesh( sm ); + sm->ComputeStateEngine( computeEvent ); + setCurrentSubMesh( NULL ); + if ( aShapesId ) + aShapesId->insert( sm->GetId() ); + } } - } + } // loop on shape dimensions + // ----------------------------------------------- // mesh the rest sub-shapes starting from vertices // ----------------------------------------------- - ret = Compute( aMesh, aShape, /*anUpward=*/true, aDim, aShapesId ); + ret = Compute( aMesh, aShape, aFlags | UPWARD, aDim, aShapesId ); } - MESSAGE( "VSR - SMESH_Gen::Compute() finished, OK = " << ret); MEMOSTAT; - SMESHDS_Mesh *myMesh = aMesh.GetMeshDS(); - MESSAGE("*** compactMesh after compute"); - myMesh->compactMesh(); - // fix quadratic mesh by bending iternal links near concave boundary - if ( aShape.IsSame( aMesh.GetShapeToMesh() ) && + if ( aCompactMesh && // a final compute + aShape.IsSame( aMesh.GetShapeToMesh() ) && !aShapesId && // not preview ret ) // everything is OK { @@ -379,11 +385,13 @@ bool SMESH_Gen::Compute(SMESH_Mesh & aMesh, aHelper.FixQuadraticElements( sm->GetComputeError() ); } } + + if ( aCompactMesh ) + aMesh.GetMeshDS()->compactMesh(); + return ret; } - -#ifdef WITH_SMESH_CANCEL_COMPUTE //============================================================================= /*! * Prepare Compute a mesh @@ -393,8 +401,9 @@ void SMESH_Gen::PrepareCompute(SMESH_Mesh & aMesh, const TopoDS_Shape & aShape) { _compute_canceled = false; - _sm_current = NULL; + resetCurrentSubMesh(); } + //============================================================================= /*! * Cancel Compute a mesh @@ -404,12 +413,45 @@ void SMESH_Gen::CancelCompute(SMESH_Mesh & aMesh, const TopoDS_Shape & aShape) { _compute_canceled = true; - if(_sm_current) - { - _sm_current->ComputeStateEngine( SMESH_subMesh::COMPUTE_CANCELED ); - } + if ( const SMESH_subMesh* sm = GetCurrentSubMesh() ) + { + const_cast< SMESH_subMesh* >( sm )->ComputeStateEngine( SMESH_subMesh::COMPUTE_CANCELED ); + } + resetCurrentSubMesh(); +} + +//================================================================================ +/*! + * \brief Returns a sub-mesh being currently computed + */ +//================================================================================ + +const SMESH_subMesh* SMESH_Gen::GetCurrentSubMesh() const +{ + return _sm_current.empty() ? 0 : _sm_current.back(); +} + +//================================================================================ +/*! + * \brief Sets a sub-mesh being currently computed. + * + * An algorithm can call Compute() for a sub-shape, hence we keep a stack of sub-meshes + */ +//================================================================================ + +void SMESH_Gen::setCurrentSubMesh(SMESH_subMesh* sm) +{ + if ( sm ) + _sm_current.push_back( sm ); + + else if ( !_sm_current.empty() ) + _sm_current.pop_back(); +} + +void SMESH_Gen::resetCurrentSubMesh() +{ + _sm_current.clear(); } -#endif //============================================================================= /*! @@ -423,8 +465,6 @@ bool SMESH_Gen::Evaluate(SMESH_Mesh & aMesh, const bool anUpward, TSetOfInt* aShapesId) { - MESSAGE("SMESH_Gen::Evaluate"); - bool ret = true; SMESH_subMesh *sm = aMesh.GetSubMesh(aShape); @@ -442,12 +482,12 @@ bool SMESH_Gen::Evaluate(SMESH_Mesh & aMesh, SMESH_subMesh* smToCompute = smIt->next(); // do not mesh vertices of a pseudo shape - const TopAbs_ShapeEnum aShType = smToCompute->GetSubShape().ShapeType(); - //if ( !aMesh.HasShapeToMesh() && aShType == TopAbs_VERTEX ) + const TopAbs_ShapeEnum shapeType = smToCompute->GetSubShape().ShapeType(); + //if ( !aMesh.HasShapeToMesh() && shapeType == TopAbs_VERTEX ) // continue; if ( !aMesh.HasShapeToMesh() ) { - if( aShType == TopAbs_VERTEX || aShType == TopAbs_WIRE || - aShType == TopAbs_SHELL ) + if( shapeType == TopAbs_VERTEX || shapeType == TopAbs_WIRE || + shapeType == TopAbs_SHELL ) continue; } @@ -460,8 +500,8 @@ bool SMESH_Gen::Evaluate(SMESH_Mesh & aMesh, else { // ----------------------------------------------------------------- // apply algos that DO NOT require Discreteized boundaries and DO NOT - // support submeshes, starting from the most complex shapes - // and collect submeshes with algos that DO support submeshes + // support sub-meshes, starting from the most complex shapes + // and collect sub-meshes with algos that DO support sub-meshes // ----------------------------------------------------------------- list< SMESH_subMesh* > smWithAlgoSupportingSubmeshes; smIt = sm->getDependsOnIterator(includeSelf, complexShapeFirst); @@ -471,7 +511,7 @@ bool SMESH_Gen::Evaluate(SMESH_Mesh & aMesh, const int aShapeDim = GetShapeDim( aSubShape ); if ( aShapeDim < 1 ) break; - SMESH_Algo* algo = GetAlgo( aMesh, aSubShape ); + SMESH_Algo* algo = GetAlgo( smToCompute ); if ( algo && !algo->NeedDiscreteBoundary() ) { if ( algo->SupportSubmeshes() ) { smWithAlgoSupportingSubmeshes.push_front( smToCompute ); @@ -487,22 +527,22 @@ bool SMESH_Gen::Evaluate(SMESH_Mesh & aMesh, // ------------------------------------------------------------ // sort list of meshes according to mesh order // ------------------------------------------------------------ - aMesh.SortByMeshOrder( smWithAlgoSupportingSubmeshes ); + std::vector< SMESH_subMesh* > smVec( smWithAlgoSupportingSubmeshes.begin(), + smWithAlgoSupportingSubmeshes.end() ); + aMesh.SortByMeshOrder( smVec ); // ------------------------------------------------------------ - // compute submeshes under shapes with algos that DO NOT require - // Discreteized boundaries and DO support submeshes + // compute sub-meshes under shapes with algos that DO NOT require + // Discreteized boundaries and DO support sub-meshes // ------------------------------------------------------------ - list< SMESH_subMesh* >::iterator subIt, subEnd; - subIt = smWithAlgoSupportingSubmeshes.begin(); - subEnd = smWithAlgoSupportingSubmeshes.end(); // start from lower shapes - for ( ; subIt != subEnd; ++subIt ) { - sm = *subIt; + for ( size_t i = 0; i < smVec.size(); ++i ) + { + sm = smVec[i]; // get a shape the algo is assigned to TopoDS_Shape algoShape; - if ( !GetAlgo( aMesh, sm->GetSubShape(), & algoShape )) + if ( !GetAlgo( sm, & algoShape )) continue; // strange... // look for more local algos @@ -514,14 +554,13 @@ bool SMESH_Gen::Evaluate(SMESH_Mesh & aMesh, const int aShapeDim = GetShapeDim( aSubShape ); if ( aShapeDim < 1 ) continue; - //const TopAbs_ShapeEnum aShType = smToCompute->GetSubShape().ShapeType(); - SMESH_HypoFilter filter( SMESH_HypoFilter::IsAlgo() ); filter .And( SMESH_HypoFilter::IsApplicableTo( aSubShape )) .And( SMESH_HypoFilter::IsMoreLocalThan( algoShape, aMesh )); - if ( SMESH_Algo* subAlgo = (SMESH_Algo*) aMesh.GetHypothesis( aSubShape, filter, true )) { + if ( SMESH_Algo* subAlgo = (SMESH_Algo*) aMesh.GetHypothesis( smToCompute, filter, true )) + { if ( ! subAlgo->NeedDiscreteBoundary() ) continue; SMESH_Hypothesis::Hypothesis_Status status; if ( subAlgo->CheckHypothesis( aMesh, aSubShape, status )) @@ -533,9 +572,9 @@ bool SMESH_Gen::Evaluate(SMESH_Mesh & aMesh, // ---------------------------------------------------------- // apply the algos that do not require Discreteized boundaries // ---------------------------------------------------------- - for ( subIt = smWithAlgoSupportingSubmeshes.begin(); subIt != subEnd; ++subIt ) + for ( size_t i = 0; i < smVec.size(); ++i ) { - sm = *subIt; + sm = smVec[i]; sm->Evaluate(aResMap); if ( aShapesId ) aShapesId->insert( sm->GetId() ); @@ -622,7 +661,9 @@ static bool checkConformIgnoredAlgos(SMESH_Mesh& aMesh, theErrors.back().Set( SMESH_Hypothesis::HYP_NOTCONFORM, algo, false ); } - // sub-algos will be hidden by a local + // sub-algos will be hidden by a local if does not support sub-meshes + if ( algo->SupportSubmeshes() ) + algo = 0; SMESH_subMeshIteratorPtr revItSub = aSubMesh->getDependsOnIterator( /*includeSelf=*/false, /*complexShapeFirst=*/true); bool checkConform2 = false; @@ -659,15 +700,13 @@ static bool checkMissing(SMESH_Gen* aGen, { case TopAbs_EDGE: case TopAbs_FACE: - case TopAbs_SOLID: break; // check this submesh, it can be meshed + case TopAbs_SOLID: break; // check this sub-mesh, it can be meshed default: - return true; // not meshable submesh + return true; // not meshable sub-mesh } if ( aCheckedMap.count( aSubMesh )) return true; - //MESSAGE("=====checkMissing"); - int ret = true; SMESH_Algo* algo = 0; @@ -788,8 +827,6 @@ bool SMESH_Gen::GetAlgoState(SMESH_Mesh& theMesh, const TopoDS_Shape& theShape, list< TAlgoStateError > & theErrors) { - //MESSAGE("SMESH_Gen::CheckAlgoState"); - bool ret = true; bool hasAlgo = false; @@ -867,8 +904,6 @@ bool SMESH_Gen::GetAlgoState(SMESH_Mesh& theMesh, // well defined // ---------------------------------------------------------------- - //MESSAGE( "---info on missing hypothesis and find out if all needed algos are"); - // find max dim of global algo int aTopAlgoDim = 0; for (dim = 3; dim > 0; dim--) @@ -902,9 +937,8 @@ bool SMESH_Gen::GetAlgoState(SMESH_Mesh& theMesh, if ( !hasAlgo ) { ret = false; - INFOS( "None algorithm attached" ); theErrors.push_back( TAlgoStateError() ); - theErrors.back().Set( SMESH_Hypothesis::HYP_MISSING, 1, true ); + theErrors.back().Set( SMESH_Hypothesis::HYP_MISSING, theMesh.HasShapeToMesh() ? 1 : 3, true ); } return ret; @@ -970,7 +1004,7 @@ std::vector< std::string > SMESH_Gen::GetPluginXMLPaths() sep = rootDir[pos]; break; } -#ifdef WNT +#ifdef WIN32 if (sep.empty() ) sep = "\\"; #else if (sep.empty() ) sep = "/"; @@ -985,7 +1019,7 @@ std::vector< std::string > SMESH_Gen::GetPluginXMLPaths() xmlPath += tolower( pluginSubDir[pos] ); xmlPath += sep + plugin + ".xml"; bool fileOK; -#ifdef WNT +#ifdef WIN32 fileOK = (GetFileAttributes(xmlPath.c_str()) != INVALID_FILE_ATTRIBUTES); #else fileOK = (access(xmlPath.c_str(), F_OK) == 0); @@ -1008,14 +1042,32 @@ SMESH_Algo *SMESH_Gen::GetAlgo(SMESH_Mesh & aMesh, const TopoDS_Shape & aShape, TopoDS_Shape* assignedTo) { + return GetAlgo( aMesh.GetSubMesh( aShape ), assignedTo ); +} + +//============================================================================= +/*! + * Finds algo to mesh a sub-mesh. Optionally returns a shape the found algo is bound to + */ +//============================================================================= + +SMESH_Algo *SMESH_Gen::GetAlgo(SMESH_subMesh * aSubMesh, + TopoDS_Shape* assignedTo) +{ + if ( !aSubMesh ) return 0; + + const TopoDS_Shape & aShape = aSubMesh->GetSubShape(); + SMESH_Mesh& aMesh = *aSubMesh->GetFather(); + SMESH_HypoFilter filter( SMESH_HypoFilter::IsAlgo() ); - filter.And( filter.IsApplicableTo( aShape )); + if ( aMesh.HasShapeToMesh() ) + filter.And( filter.IsApplicableTo( aShape )); typedef SMESH_Algo::Features AlgoData; TopoDS_Shape assignedToShape; SMESH_Algo* algo = - (SMESH_Algo*) aMesh.GetHypothesis( aShape, filter, true, &assignedToShape ); + (SMESH_Algo*) aMesh.GetHypothesis( aSubMesh, filter, true, &assignedToShape ); if ( algo && aShape.ShapeType() == TopAbs_FACE && @@ -1030,7 +1082,7 @@ SMESH_Algo *SMESH_Gen::GetAlgo(SMESH_Mesh & aMesh, filter.AndNot( filter.Is( algo )); TopoDS_Shape assignedToShape2; SMESH_Algo* algo2 = - (SMESH_Algo*) aMesh.GetHypothesis( aShape, filter, true, &assignedToShape2 ); + (SMESH_Algo*) aMesh.GetHypothesis( aSubMesh, filter, true, &assignedToShape2 ); if ( algo2 && // algo found !assignedToShape2.IsSame( aMesh.GetShapeToMesh() ) && // algo is local ( SMESH_MesherHelper::GetGroupType( assignedToShape2 ) == // algo of the same level