X-Git-Url: http://git.salome-platform.org/gitweb/?a=blobdiff_plain;f=src%2FSMESH%2FSMESH_subMesh.cxx;h=dd93a999fae7da7ed86e4e26c4c8bc17d0b50715;hb=1bc504bf901039d3cf41d8f1a65f1f955579cf34;hp=89e9e26849c2c05059b035d7c5687237a1127177;hpb=e4737e85f0da6d3f90fd08f6be1c2825195fe16f;p=modules%2Fsmesh.git diff --git a/src/SMESH/SMESH_subMesh.cxx b/src/SMESH/SMESH_subMesh.cxx index 89e9e2684..dd93a999f 100644 --- a/src/SMESH/SMESH_subMesh.cxx +++ b/src/SMESH/SMESH_subMesh.cxx @@ -32,16 +32,21 @@ using namespace std; #include "SMESH_Mesh.hxx" #include "SMESH_Hypothesis.hxx" #include "SMESH_Algo.hxx" +#include "SMESH_HypoFilter.hxx" + #include "utilities.h" #include "OpUtil.hxx" +#include + #include -#include +#include +#include #include #include +#include + #include -#include -#include #ifdef _DEBUG_ #include @@ -461,34 +466,31 @@ bool SMESH_subMesh::CanAddHypothesis(const SMESH_Hypothesis* theHypothesis) cons //======================================================================= //function : IsApplicableHypotesis -//purpose : return true if theHypothesis can be used to mesh me: -// its shape type is checked +//purpose : //======================================================================= -bool SMESH_subMesh::IsApplicableHypotesis(const SMESH_Hypothesis* theHypothesis) const +bool SMESH_subMesh::IsApplicableHypotesis(const SMESH_Hypothesis* theHypothesis, + const TopAbs_ShapeEnum theShapeType) { if ( theHypothesis->GetType() > SMESHDS_Hypothesis::PARAM_ALGO) // algorithm - return ( theHypothesis->GetShapeType() & (1<< _subShape.ShapeType())); + return ( theHypothesis->GetShapeType() & (1<< theShapeType)); // hypothesis - switch ( _subShape.ShapeType() ) { - case TopAbs_EDGE: - case TopAbs_FACE: - case TopAbs_SHELL: - case TopAbs_SOLID: { - int aHypDim = theHypothesis->GetDim(); - int aShapeDim = SMESH_Gen::GetShapeDim(_subShape); - return ( aHypDim == aShapeDim ); - } + int aShapeDim = 100; + switch ( theShapeType ) { + case TopAbs_EDGE: aShapeDim = 1; break; + case TopAbs_FACE: aShapeDim = 2; break; + case TopAbs_SHELL:aShapeDim = 3; break; + case TopAbs_SOLID:aShapeDim = 3; break; // case TopAbs_VERTEX: // case TopAbs_WIRE: // case TopAbs_COMPSOLID: // case TopAbs_COMPOUND: - default:; + default: return false; } - return false; + return ( theHypothesis->GetDim() == aShapeDim ); } //============================================================================= @@ -504,11 +506,12 @@ SMESH_Hypothesis::Hypothesis_Status //SCRUTE(_algoState); //SCRUTE(event); - SMESH_Hypothesis::Hypothesis_Status aux_ret, ret = SMESH_Hypothesis::HYP_OK; - // **** les retour des evenement shape sont significatifs // (add ou remove fait ou non) // le retour des evenement father n'indiquent pas que add ou remove fait + + SMESH_Hypothesis::Hypothesis_Status aux_ret, ret = SMESH_Hypothesis::HYP_OK; + int dim = SMESH_Gen::GetShapeDim(_subShape); if (dim < 1) @@ -550,6 +553,44 @@ SMESH_Hypothesis::Hypothesis_Status if ( !_meshDS->AddHypothesis(_subShape, anHyp)) return SMESH_Hypothesis::HYP_ALREADY_EXIST; + + // Serve Propagation of 1D hypothesis + if (event == ADD_HYP) { + bool isPropagationOk = true; + string hypName = anHyp->GetName(); + + if (hypName == "Propagation") { + TopExp_Explorer exp (_subShape, TopAbs_EDGE); + TopTools_MapOfShape aMap; + for (; exp.More(); exp.Next()) { + if (aMap.Add(exp.Current())) { + if (!_father->BuildPropagationChain(exp.Current())) { + isPropagationOk = false; + } + } + } + } + else if (anHyp->GetDim() == 1) { // Only 1D hypothesis can be propagated + TopExp_Explorer exp (_subShape, TopAbs_EDGE); + TopTools_MapOfShape aMap; + for (; exp.More(); exp.Next()) { + if (aMap.Add(exp.Current())) { + TopoDS_Shape aMainEdge; + if (_father->IsPropagatedHypothesis(exp.Current(), aMainEdge)) { + isPropagationOk = _father->RebuildPropagationChains(); + } else if (_father->IsPropagationHypothesis(exp.Current())) { + isPropagationOk = _father->BuildPropagationChain(exp.Current()); + } else { + } + } + } + } else { + } + + if (!isPropagationOk && ret < SMESH_Hypothesis::HYP_CONCURENT) { + ret = SMESH_Hypothesis::HYP_CONCURENT; + } + } // Serve Propagation of 1D hypothesis } // -------------------------- @@ -559,6 +600,38 @@ SMESH_Hypothesis::Hypothesis_Status { if (!_meshDS->RemoveHypothesis(_subShape, anHyp)) return SMESH_Hypothesis::HYP_OK; // nothing changes + + // Serve Propagation of 1D hypothesis + if (event == REMOVE_HYP) + { + bool isPropagationOk = true; + SMESH_HypoFilter propagFilter( SMESH_HypoFilter::HasName( "Propagation" )); + if ( propagFilter.IsOk( anHyp, _subShape )) + { + TopExp_Explorer exp (_subShape, TopAbs_EDGE); + TopTools_MapOfShape aMap; + for (; exp.More(); exp.Next()) { + if (aMap.Add(exp.Current()) && + !_father->GetHypothesis( exp.Current(), propagFilter, true )) { + // no more Propagation on the current edge + if (!_father->RemovePropagationChain(exp.Current())) { + return SMESH_Hypothesis::HYP_UNKNOWN_FATAL; + } + } + } + // rebuild propagation chains, because removing one + // chain can resolve concurention, existing before + isPropagationOk = _father->RebuildPropagationChains(); + } + else if (anHyp->GetDim() == 1) // Only 1D hypothesis can be propagated + { + isPropagationOk = _father->RebuildPropagationChains(); + } + + if (!isPropagationOk && ret < SMESH_Hypothesis::HYP_CONCURENT) { + ret = SMESH_Hypothesis::HYP_CONCURENT; + } + } // Serve Propagation of 1D hypothesis } // ------------------ @@ -719,20 +792,17 @@ SMESH_Hypothesis::Hypothesis_Status ASSERT(algo); if (!algo->CheckHypothesis((*_father),_subShape, ret )) { - MESSAGE("two applying algo on the same shape not allowed"); - _meshDS->RemoveHypothesis(_subShape, anHyp); if ( !SMESH_Hypothesis::IsStatusFatal( ret )) // ret should be fatal: anHyp was not added ret = SMESH_Hypothesis::HYP_INCOMPATIBLE; } - else if (SMESH_Hypothesis::IsStatusFatal( ret )) - { - _meshDS->RemoveHypothesis(_subShape, anHyp); - } else if (!_father->IsUsedHypothesis( anHyp, _subShape )) + ret = SMESH_Hypothesis::HYP_INCOMPATIBLE; + + if (SMESH_Hypothesis::IsStatusFatal( ret )) { + MESSAGE("do not add extra hypothesis"); _meshDS->RemoveHypothesis(_subShape, anHyp); - ret = SMESH_Hypothesis::HYP_INCOMPATIBLE; } else { @@ -742,11 +812,19 @@ SMESH_Hypothesis::Hypothesis_Status } case ADD_ALGO: { //already existing algo : on father ? SMESH_Algo* algo = gen->GetAlgo((*_father), _subShape); - if ( algo->CheckHypothesis((*_father),_subShape, aux_ret )) - SetAlgoState(HYP_OK); + if ( algo->CheckHypothesis((*_father),_subShape, aux_ret )) { + // check if algo changes + SMESH_HypoFilter f; + f.Init( SMESH_HypoFilter::IsAlgo() ); + f.And( SMESH_HypoFilter::IsApplicableTo( _subShape )); + f.AndNot( SMESH_HypoFilter::Is( algo )); + const SMESH_Hypothesis * prevAlgo = _father->GetHypothesis( _subShape, f, true ); + if (prevAlgo && + string(algo->GetName()) != string(prevAlgo->GetName()) ) + modifiedHyp = true; + } else SetAlgoState(MISSING_HYP); - modifiedHyp = true; break; } case REMOVE_HYP: { @@ -767,13 +845,13 @@ SMESH_Hypothesis::Hypothesis_Status } else { - if ( algo->CheckHypothesis((*_father),_subShape, aux_ret )) - SetAlgoState(HYP_OK); + if ( algo->CheckHypothesis((*_father),_subShape, aux_ret )) { + // check if algo remains + if ( anHyp != algo && strcmp( anHyp->GetName(), algo->GetName()) ) + modifiedHyp = true; + } else SetAlgoState(MISSING_HYP); - // check if same algo remains - if ( anHyp != algo && strcmp( anHyp->GetName(), algo->GetName()) ) - modifiedHyp = true; } break; } @@ -782,7 +860,6 @@ SMESH_Hypothesis::Hypothesis_Status ASSERT(algo); if ( algo->CheckHypothesis((*_father),_subShape, aux_ret )) { - SetAlgoState(HYP_OK); if (_father->IsUsedHypothesis( anHyp, _subShape )) // new Hyp modifiedHyp = true; } @@ -790,27 +867,35 @@ SMESH_Hypothesis::Hypothesis_Status SetAlgoState(MISSING_HYP); break; } - case ADD_FATHER_ALGO: { // a new algo on father + case ADD_FATHER_ALGO: { SMESH_Algo* algo = gen->GetAlgo((*_father), _subShape); - if ( algo == anHyp ) { - if ( algo->CheckHypothesis((*_father),_subShape, aux_ret )) - SetAlgoState(HYP_OK); + if ( algo == anHyp ) { // a new algo on father + if ( algo->CheckHypothesis((*_father),_subShape, aux_ret )) { + // check if algo changes + SMESH_HypoFilter f; + f.Init( SMESH_HypoFilter::IsAlgo() ); + f.And( SMESH_HypoFilter::IsApplicableTo( _subShape )); + f.AndNot( SMESH_HypoFilter::Is( algo )); + const SMESH_Hypothesis* prevAlgo = _father->GetHypothesis( _subShape, f, true ); + if (prevAlgo && + string(algo->GetName()) != string(prevAlgo->GetName()) ) + modifiedHyp = true; + } else SetAlgoState(MISSING_HYP); - modifiedHyp = true; } break; } case REMOVE_FATHER_HYP: { SMESH_Algo* algo = gen->GetAlgo((*_father), _subShape); ASSERT(algo); - if ( algo->CheckHypothesis((*_father),_subShape, aux_ret )) - SetAlgoState(HYP_OK); + if ( algo->CheckHypothesis((*_father),_subShape, aux_ret )) { + // is there the same local hyp or maybe a new father algo applied? + if ( !GetSimilarAttached( _subShape, anHyp ) ) + modifiedHyp = true; + } else SetAlgoState(MISSING_HYP); - // is there the same local hyp or maybe a new father algo applied? - if ( !GetSimilarAttached( _subShape, anHyp ) ) - modifiedHyp = true; break; } case REMOVE_FATHER_ALGO: { @@ -821,13 +906,13 @@ SMESH_Hypothesis::Hypothesis_Status } else { - if ( algo->CheckHypothesis((*_father),_subShape, aux_ret )) - SetAlgoState(HYP_OK); + if ( algo->CheckHypothesis((*_father),_subShape, aux_ret )) { + // check if algo changes + if ( string(algo->GetName()) != string( anHyp->GetName()) ) + modifiedHyp = true; + } else SetAlgoState(MISSING_HYP); - // is there the same local algo or maybe a new father algo applied? - if ( !GetSimilarAttached( _subShape, anHyp )) - modifiedHyp = true; } break; } @@ -843,22 +928,9 @@ SMESH_Hypothesis::Hypothesis_Status ASSERT(0); break; } - // ---------------------------------------- - // check concurent hypotheses on ansestors - // ---------------------------------------- - if (ret < SMESH_Hypothesis::HYP_CONCURENT && - (event == ADD_FATHER_HYP || - event == ADD_FATHER_ALGO || - event == REMOVE_FATHER_HYP || - event == REMOVE_FATHER_ALGO || - event == REMOVE_ALGO || - event == REMOVE_HYP)) - { - ret = CheckConcurentHypothesis( anHyp->GetType() ); - } if ((_algoState != oldAlgoState) || modifiedHyp) - int retc = ComputeStateEngine(MODIF_ALGO_STATE); + ComputeStateEngine(MODIF_ALGO_STATE); return ret; } @@ -883,7 +955,7 @@ bool SMESH_subMesh::IsConform(const SMESH_Algo* theAlgo) SMESH_Gen* gen =_father->GetGen(); // only local algo is to be checked - if ( gen->IsGlobalAlgo( theAlgo, *_father )) + if ( gen->IsGlobalHypothesis( theAlgo, *_father )) return true; // check algo attached to adjacent shapes @@ -906,7 +978,7 @@ bool SMESH_subMesh::IsConform(const SMESH_Algo* theAlgo) if (algo && //algo != theAlgo && !algo->NeedDescretBoundary() /*&& - !gen->IsGlobalAlgo( algo, *_father )*/) + !gen->IsGlobalHypothesis( algo, *_father )*/) return false; // NOT CONFORM MESH WILL BE PRODUCED } } @@ -975,7 +1047,7 @@ void SMESH_subMesh::CleanDependsOn() for (its = dependson.begin(); its != dependson.end(); its++) { SMESH_subMesh *sm = (*its).second; - SCRUTE((*its).first); + //SCRUTE((*its).first); sm->ComputeStateEngine(CLEAN); } } @@ -1425,21 +1497,21 @@ void SMESH_subMesh::UpdateDependantsState(const compute_event theEvent) void SMESH_subMesh::CleanDependants() { - //MESSAGE("SMESH_subMesh::CleanDependants: shape type " << _subShape.ShapeType() ); - TopTools_ListIteratorOfListOfShape it( _father->GetAncestors( _subShape )); for (; it.More(); it.Next()) { const TopoDS_Shape& ancestor = it.Value(); - //MESSAGE("ancestor shape type " << ancestor.ShapeType() ); - SMESH_subMesh *aSubMesh = _father->GetSubMeshContaining(ancestor); - if (aSubMesh) - aSubMesh->ComputeStateEngine(CLEANDEP); + // PAL8021. do not go upper than SOLID, else ComputeStateEngine(CLEANDEP) + // will erase mesh on other shapes in a compound + if ( ancestor.ShapeType() >= TopAbs_SOLID ) { + SMESH_subMesh *aSubMesh = _father->GetSubMeshContaining(ancestor); + if (aSubMesh) + aSubMesh->ComputeStateEngine(CLEANDEP); + } } ComputeStateEngine(CLEAN); } - //============================================================================= /*! * @@ -1477,7 +1549,7 @@ static void removeSubMesh( SMESHDS_Mesh * meshDS, const TopoDS_Shape& subShape) void SMESH_subMesh::RemoveSubMeshElementsAndNodes() { - SCRUTE(_subShape.ShapeType()); + //SCRUTE(_subShape.ShapeType()); removeSubMesh( _meshDS, _subShape ); @@ -1586,28 +1658,16 @@ const SMESH_Hypothesis* SMESH_subMesh::GetSimilarAttached(const TopoDS_Shape& const SMESH_Hypothesis * theHyp, const int theHypType) { - const list& aHypList = - _father->GetHypothesisList( theShape ); - list::const_iterator it = aHypList.begin(); - for ( ; it != aHypList.end(); it++ ) - { - const SMESH_Hypothesis* hyp = static_cast< const SMESH_Hypothesis *>( *it ); - if ( theHyp ) - { - // find similar - if (hyp != theHyp && - hyp->GetType() == theHyp->GetType() && - hyp->GetDim() == theHyp->GetDim()) - return hyp; - } - else - { - if ( hyp->GetType() == theHypType && IsApplicableHypotesis( hyp )) - return hyp; - } + SMESH_HypoFilter filter; + filter.Init( SMESH_HypoFilter::HasType( theHyp ? theHyp->GetType() : theHypType )); + if ( theHyp ) { + filter.And( SMESH_HypoFilter::HasDim( theHyp->GetDim() )); + filter.AndNot( SMESH_HypoFilter::Is( theHyp )); } + else + filter.And( SMESH_HypoFilter::IsApplicableTo( theShape )); - return 0; + return _father->GetHypothesis( theShape, filter, false ); } //=======================================================================