-// Copyright (C) 2007-2008 CEA/DEN, EDF R&D, OPEN CASCADE
+// Copyright (C) 2007-2010 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
//
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
+
// SMESH SMESH : implementaion of SMESH idl descriptions
// File : SMESH_Mesh.cxx
// Author : Paul RASCLE, EDF
#include "Utils_ExceptHandlers.hxx"
+using namespace std;
+
// maximum stored group name length in MED file
#define MAX_MED_GROUP_NAME_LENGTH 80
_myMeshDS = theDocument->GetMesh(_idDoc);
_isShapeToMesh = false;
_isAutoColor = false;
+ _isModified = false;
_shapeDiagonal = 0.0;
+ _rmGroupCallUp = 0;
_myMeshDS->ShapeToMesh( PseudoShape() );
}
sm->ComputeStateEngine( SMESH_subMesh::MESH_ENTITY_REMOVED );
// delete groups
- std::map < int, SMESH_Group * >::iterator itg;
+ map < int, SMESH_Group * >::iterator itg;
for (itg = _mapGroup.begin(); itg != _mapGroup.end(); itg++) {
SMESH_Group *aGroup = (*itg).second;
delete aGroup;
}
_mapGroup.clear();
+
+ if ( _rmGroupCallUp) delete _rmGroupCallUp;
+ _rmGroupCallUp = 0;
}
//=============================================================================
{
// removal of a shape to mesh, delete objects referring to sub-shapes:
// - sub-meshes
- std::map <int, SMESH_subMesh *>::iterator i_sm = _mapSubMesh.begin();
+ map <int, SMESH_subMesh *>::iterator i_sm = _mapSubMesh.begin();
for ( ; i_sm != _mapSubMesh.end(); ++i_sm )
delete i_sm->second;
_mapSubMesh.clear();
// - groups on geometry
- std::map <int, SMESH_Group *>::iterator i_gr = _mapGroup.begin();
+ map <int, SMESH_Group *>::iterator i_gr = _mapGroup.begin();
while ( i_gr != _mapGroup.end() ) {
if ( dynamic_cast<SMESHDS_GroupOnGeom*>( i_gr->second->GetGroupDS() )) {
_myMeshDS->RemoveGroup( i_gr->second->GetGroupDS() );
_shapeDiagonal = 0.0;
_myMeshDS->ShapeToMesh( PseudoShape() );
}
+ _isModified = false;
}
//=======================================================================
_myMeshDS->ClearMesh();
// update compute state of submeshes
- if ( SMESH_subMesh *sm = GetSubMeshContaining( GetShapeToMesh() ) ) {
- SMESH_subMeshIteratorPtr smIt = sm->getDependsOnIterator(/*includeSelf=*/true,
- /*complexShapeFirst=*/false);
- while ( smIt->more() ) {
- sm = smIt->next();
- sm->ComputeStateEngine( SMESH_subMesh::CHECK_COMPUTE_STATE );
- }
+ if ( SMESH_subMesh *sm = GetSubMeshContaining( GetShapeToMesh() ) )
+ {
+ sm->ComputeStateEngine( SMESH_subMesh::CHECK_COMPUTE_STATE );
+ sm->ComputeSubMeshStateEngine( SMESH_subMesh::CHECK_COMPUTE_STATE );
+ sm->ComputeStateEngine( SMESH_subMesh::CLEAN ); // for event listeners (issue 0020918)
+ sm->ComputeSubMeshStateEngine( SMESH_subMesh::CLEAN );
}
-
-// // clear sub-meshes; get ready to re-compute as a side-effect
-
-// if ( SMESH_subMesh *sm = GetSubMeshContaining( GetShapeToMesh() ) )
-// {
-// SMESH_subMeshIteratorPtr smIt = sm->getDependsOnIterator(/*includeSelf=*/true,
-// /*complexShapeFirst=*/false);
-// while ( smIt->more() )
-// {
-// sm = smIt->next();
-// TopAbs_ShapeEnum shapeType = sm->GetSubShape().ShapeType();
-// if ( shapeType == TopAbs_VERTEX || shapeType < TopAbs_SOLID )
-// // all other shapes depends on vertices so they are already cleaned
-// sm->ComputeStateEngine( SMESH_subMesh::CLEAN );
-// // to recompute even if failed
-// sm->ComputeStateEngine( SMESH_subMesh::CHECK_COMPUTE_STATE );
-// }
-// }
-
-// // clear entities not on sub-meshes
-
-// SMDS_VolumeIteratorPtr vIt = _myMeshDS->volumesIterator();
-// while ( vIt->more() )
-// _myMeshDS->RemoveFreeElement( vIt->next(), 0 );
-
-// SMDS_FaceIteratorPtr fIt = _myMeshDS->facesIterator();
-// while ( fIt->more() )
-// _myMeshDS->RemoveFreeElement( fIt->next(), 0 );
-
-// SMDS_EdgeIteratorPtr eIt = _myMeshDS->edgesIterator();
-// while ( eIt->more() )
-// _myMeshDS->RemoveFreeElement( eIt->next(), 0 );
-
-// SMDS_NodeIteratorPtr nIt = _myMeshDS->nodesIterator();
-// while ( nIt->more() ) {
-// const SMDS_MeshNode * node = nIt->next();
-// if ( node->NbInverseElements() == 0 )
-// _myMeshDS->RemoveFreeNode( node, 0 );
-// else
-// _myMeshDS->RemoveNode(node);
-// }
+ _isModified = false;
}
//=======================================================================
aGroup->InitSubGroupsIterator();
while (aGroup->MoreSubGroups()) {
SMDS_MeshGroup* aSubGroup = (SMDS_MeshGroup*) aGroup->NextSubGroup();
- std::string aName = aGroupNames[aSubGroup];
+ string aName = aGroupNames[aSubGroup];
int aId;
SMESH_Group* aSMESHGroup = AddGroup( aSubGroup->GetType(), aName.c_str(), aId );
}
// Reading groups (sub-meshes are out of scope of MED import functionality)
- std::list<TNameAndType> aGroupNames = myReader.GetGroupNamesAndTypes();
+ list<TNameAndType> aGroupNames = myReader.GetGroupNamesAndTypes();
if(MYDEBUG) MESSAGE("MEDToMesh - Nb groups = "<<aGroupNames.size());
int anId;
- std::list<TNameAndType>::iterator name_type = aGroupNames.begin();
+ list<TNameAndType>::iterator name_type = aGroupNames.begin();
for ( ; name_type != aGroupNames.end(); name_type++ ) {
SMESH_Group* aGroup = AddGroup( name_type->second, name_type->first.c_str(), anId );
if ( aGroup ) {
// NotConformAllowed can be only global
if ( !isGlobalHyp )
{
+ // NOTE: this is not a correct way to check a name of hypothesis,
+ // there should be an attribute of hypothesis saying that it can/can't
+ // be global/local
string hypName = anHyp->GetName();
if ( hypName == "NotConformAllowed" )
{
if (ret2 > ret)
ret = ret2;
- // check concurent hypotheses on ansestors
+ // check concurent hypotheses on ancestors
if (ret < SMESH_Hypothesis::HYP_CONCURENT && !isGlobalHyp )
{
SMESH_subMeshIteratorPtr smIt = subMesh->getDependsOnIterator(false,false);
}
}
}
+ HasModificationsToDiscard(); // to reset _isModified flag if a mesh becomes empty
if(MYDEBUG) subMesh->DumpAlgoState(true);
- SCRUTE(ret);
+ if(MYDEBUG) SCRUTE(ret);
return ret;
}
throw SALOME_Exception(LOCALIZED("hypothesis does not exist"));
SMESH_Hypothesis *anHyp = sc->mapHypothesis[anHypId];
- int hypType = anHyp->GetType();
- if(MYDEBUG) SCRUTE(hypType);
+ if(MYDEBUG) {
+ int hypType = anHyp->GetType();
+ SCRUTE(hypType);
+ }
// shape
if (ret2 > ret) // more severe
ret = ret2;
- // check concurent hypotheses on ansestors
+ // check concurent hypotheses on ancestors
if (ret < SMESH_Hypothesis::HYP_CONCURENT && !IsMainShape( aSubShape ) )
{
SMESH_subMeshIteratorPtr smIt = subMesh->getDependsOnIterator(false,false);
}
}
}
-
+
+ HasModificationsToDiscard(); // to reset _isModified flag if mesh become empty
+
if(MYDEBUG) subMesh->DumpAlgoState(true);
if(MYDEBUG) SCRUTE(ret);
return ret;
*/
//=============================================================================
-const std::list<const SMESHDS_Hypothesis*>&
+const list<const SMESHDS_Hypothesis*>&
SMESH_Mesh::GetHypothesisList(const TopoDS_Shape & aSubShape) const
throw(SALOME_Exception)
{
TopoDS_Shape* assignedTo) const
{
{
- const std::list<const SMESHDS_Hypothesis*>& hypList = _myMeshDS->GetHypothesis(aSubShape);
- std::list<const SMESHDS_Hypothesis*>::const_iterator hyp = hypList.begin();
+ const list<const SMESHDS_Hypothesis*>& hypList = _myMeshDS->GetHypothesis(aSubShape);
+ list<const SMESHDS_Hypothesis*>::const_iterator hyp = hypList.begin();
for ( ; hyp != hypList.end(); hyp++ ) {
const SMESH_Hypothesis * h = cSMESH_Hyp( *hyp );
if ( aFilter.IsOk( h, aSubShape)) {
if ( andAncestors )
{
// user sorted submeshes of ancestors, according to stored submesh priority
- const std::list<SMESH_subMesh*> smList = getAncestorsSubMeshes( aSubShape );
- std::list<SMESH_subMesh*>::const_iterator smIt = smList.begin();
+ const list<SMESH_subMesh*> smList = getAncestorsSubMeshes( aSubShape );
+ list<SMESH_subMesh*>::const_iterator smIt = smList.begin();
for ( ; smIt != smList.end(); smIt++ )
{
const TopoDS_Shape& curSh = (*smIt)->GetSubShape();
- const std::list<const SMESHDS_Hypothesis*>& hypList = _myMeshDS->GetHypothesis(curSh);
- std::list<const SMESHDS_Hypothesis*>::const_iterator hyp = hypList.begin();
+ const list<const SMESHDS_Hypothesis*>& hypList = _myMeshDS->GetHypothesis(curSh);
+ list<const SMESHDS_Hypothesis*>::const_iterator hyp = hypList.begin();
for ( ; hyp != hypList.end(); hyp++ ) {
const SMESH_Hypothesis * h = cSMESH_Hyp( *hyp );
if (aFilter.IsOk( h, curSh )) {
bool mainHypFound = false;
// fill in hypTypes
- std::list<const SMESHDS_Hypothesis*>::const_iterator hyp;
+ list<const SMESHDS_Hypothesis*>::const_iterator hyp;
for ( hyp = aHypList.begin(); hyp != aHypList.end(); hyp++ ) {
if ( hypTypes.insert( (*hyp)->GetName() ).second )
nbHyps++;
// get hypos from aSubShape
{
- const std::list<const SMESHDS_Hypothesis*>& hypList = _myMeshDS->GetHypothesis(aSubShape);
+ const list<const SMESHDS_Hypothesis*>& hypList = _myMeshDS->GetHypothesis(aSubShape);
for ( hyp = hypList.begin(); hyp != hypList.end(); hyp++ )
if ( aFilter.IsOk (cSMESH_Hyp( *hyp ), aSubShape) &&
( cSMESH_Hyp(*hyp)->IsAuxiliary() || !mainHypFound ) &&
TopTools_MapOfShape map;
// user sorted submeshes of ancestors, according to stored submesh priority
- const std::list<SMESH_subMesh*> smList = getAncestorsSubMeshes( aSubShape );
- std::list<SMESH_subMesh*>::const_iterator smIt = smList.begin();
+ const list<SMESH_subMesh*> smList = getAncestorsSubMeshes( aSubShape );
+ list<SMESH_subMesh*>::const_iterator smIt = smList.begin();
for ( ; smIt != smList.end(); smIt++ )
{
const TopoDS_Shape& curSh = (*smIt)->GetSubShape();
if ( !map.Add( curSh ))
continue;
- const std::list<const SMESHDS_Hypothesis*>& hypList = _myMeshDS->GetHypothesis(curSh);
+ const list<const SMESHDS_Hypothesis*>& hypList = _myMeshDS->GetHypothesis(curSh);
for ( hyp = hypList.begin(); hyp != hypList.end(); hyp++ )
if (aFilter.IsOk( cSMESH_Hyp( *hyp ), curSh ) &&
( cSMESH_Hyp(*hyp)->IsAuxiliary() || !mainHypFound ) &&
*/
//=============================================================================
-const std::list<SMESHDS_Command*> & SMESH_Mesh::GetLog() throw(SALOME_Exception)
+const list<SMESHDS_Command*> & SMESH_Mesh::GetLog() throw(SALOME_Exception)
{
Unexpect aCatch(SalomeException);
if(MYDEBUG) MESSAGE("SMESH_Mesh::GetLog");
*/
//================================================================================
-std::list<SMESH_subMesh*>
+list<SMESH_subMesh*>
SMESH_Mesh::GetGroupSubMeshesContaining(const TopoDS_Shape & aSubShape) const
throw(SALOME_Exception)
{
Unexpect aCatch(SalomeException);
- std::list<SMESH_subMesh*> found;
+ list<SMESH_subMesh*> found;
SMESH_subMesh * subMesh = GetSubMeshContaining(aSubShape);
if ( !subMesh )
return found;
// submeshes of groups have max IDs, so search from the map end
- std::map<int, SMESH_subMesh *>::const_reverse_iterator i_sm;
+ map<int, SMESH_subMesh *>::const_reverse_iterator i_sm;
for ( i_sm = _mapSubMesh.rbegin(); i_sm != _mapSubMesh.rend(); ++i_sm) {
SMESHDS_SubMesh * ds = i_sm->second->GetSubMeshDS();
if ( ds && ds->IsComplexSubmesh() ) {
}
}
}
+ HasModificationsToDiscard(); // to reset _isModified flag if mesh becomes empty
}
//=============================================================================
return _isAutoColor;
}
+//=======================================================================
+//function : SetIsModified
+//purpose : Set the flag meaning that the mesh has been edited "manually"
+//=======================================================================
+
+void SMESH_Mesh::SetIsModified(bool isModified)
+{
+ _isModified = isModified;
+
+ if ( _isModified )
+ // check if mesh becomes empty as result of modification
+ HasModificationsToDiscard();
+}
+
+//=======================================================================
+//function : HasModificationsToDiscard
+//purpose : Return true if the mesh has been edited since a total re-compute
+// and those modifications may prevent successful partial re-compute.
+// As a side effect reset _isModified flag if mesh is empty
+//issue : 0020693
+//=======================================================================
+
+bool SMESH_Mesh::HasModificationsToDiscard() const
+{
+ if ( ! _isModified )
+ return false;
+
+ // return true if there the next Compute() will be partial and
+ // existing but changed elements may prevent successful re-compute
+ bool hasComputed = false, hasNotComputed = false;
+ map <int, SMESH_subMesh*>::const_iterator i_sm = _mapSubMesh.begin();
+ for ( ; i_sm != _mapSubMesh.end() ; ++i_sm )
+ switch ( i_sm->second->GetSubShape().ShapeType() )
+ {
+ case TopAbs_EDGE:
+ case TopAbs_FACE:
+ case TopAbs_SOLID:
+ if ( i_sm->second->IsMeshComputed() )
+ hasComputed = true;
+ else
+ hasNotComputed = true;
+ if ( hasComputed && hasNotComputed)
+ return true;
+ }
+
+ if ( !hasComputed )
+ const_cast<SMESH_Mesh*>(this)->_isModified = false;
+
+ return false;
+}
+
//=============================================================================
/*! Export* methods.
* To store mesh contents on disk in different formats.
bool SMESH_Mesh::HasDuplicatedGroupNamesMED()
{
- set<string> aGroupNames;
- for ( std::map<int, SMESH_Group*>::iterator it = _mapGroup.begin(); it != _mapGroup.end(); it++ ) {
+ //set<string> aGroupNames; // Corrected for Mantis issue 0020028
+ map< SMDSAbs_ElementType, set<string> > aGroupNames;
+ for ( map<int, SMESH_Group*>::iterator it = _mapGroup.begin(); it != _mapGroup.end(); it++ )
+ {
SMESH_Group* aGroup = it->second;
- std::string aGroupName = aGroup->GetName();
+ SMDSAbs_ElementType aType = aGroup->GetGroupDS()->GetType();
+ string aGroupName = aGroup->GetName();
aGroupName.resize(MAX_MED_GROUP_NAME_LENGTH);
- if (!aGroupNames.insert(aGroupName).second)
+ if (!aGroupNames[aType].insert(aGroupName).second)
return true;
}
}
// Pass groups to writer. Provide unique group names.
- set<string> aGroupNames;
+ //set<string> aGroupNames; // Corrected for Mantis issue 0020028
+ map< SMDSAbs_ElementType, set<string> > aGroupNames;
char aString [256];
int maxNbIter = 10000; // to guarantee cycle finish
- for ( std::map<int, SMESH_Group*>::iterator it = _mapGroup.begin(); it != _mapGroup.end(); it++ ) {
+ for ( map<int, SMESH_Group*>::iterator it = _mapGroup.begin(); it != _mapGroup.end(); it++ ) {
SMESH_Group* aGroup = it->second;
SMESHDS_GroupBase* aGroupDS = aGroup->GetGroupDS();
if ( aGroupDS ) {
+ SMDSAbs_ElementType aType = aGroupDS->GetType();
string aGroupName0 = aGroup->GetName();
aGroupName0.resize(MAX_MED_GROUP_NAME_LENGTH);
string aGroupName = aGroupName0;
- for (int i = 1; !aGroupNames.insert(aGroupName).second && i < maxNbIter; i++) {
+ for (int i = 1; !aGroupNames[aType].insert(aGroupName).second && i < maxNbIter; i++) {
sprintf(&aString[0], "GR_%d_%s", i, aGroupName0.c_str());
aGroupName = aString;
aGroupName.resize(MAX_MED_GROUP_NAME_LENGTH);
myWriter.SetMeshId(_idDoc);
// myWriter.SetGroups(_mapGroup);
- for ( std::map<int, SMESH_Group*>::iterator it = _mapGroup.begin(); it != _mapGroup.end(); it++ ) {
+ for ( map<int, SMESH_Group*>::iterator it = _mapGroup.begin(); it != _mapGroup.end(); it++ ) {
SMESH_Group* aGroup = it->second;
SMESHDS_GroupBase* aGroupDS = aGroup->GetGroupDS();
if ( aGroupDS ) {
- std::string aGroupName = aGroup->GetName();
+ string aGroupName = aGroup->GetName();
aGroupDS->SetStoreName( aGroupName.c_str() );
myWriter.AddGroup( aGroupDS );
}
*/
//=============================================================================
-std::list<int> SMESH_Mesh::GetGroupIds() const
+list<int> SMESH_Mesh::GetGroupIds() const
{
- std::list<int> anIds;
- for ( std::map<int, SMESH_Group*>::const_iterator it = _mapGroup.begin(); it != _mapGroup.end(); it++ )
+ list<int> anIds;
+ for ( map<int, SMESH_Group*>::const_iterator it = _mapGroup.begin(); it != _mapGroup.end(); it++ )
anIds.push_back( it->first );
return anIds;
}
+//================================================================================
+/*!
+ * \brief Set a caller of RemoveGroup() at level of CORBA API implementation.
+ * The set upCaller will be deleted by SMESH_Mesh
+ */
+//================================================================================
+
+void SMESH_Mesh::SetRemoveGroupCallUp( TRmGroupCallUp* upCaller )
+{
+ if ( _rmGroupCallUp ) delete _rmGroupCallUp;
+ _rmGroupCallUp = upCaller;
+}
//=============================================================================
/*!
*/
//=============================================================================
-void SMESH_Mesh::RemoveGroup (const int theGroupID)
+bool SMESH_Mesh::RemoveGroup (const int theGroupID)
{
if (_mapGroup.find(theGroupID) == _mapGroup.end())
- return;
+ return false;
GetMeshDS()->RemoveGroup( _mapGroup[theGroupID]->GetGroupDS() );
delete _mapGroup[theGroupID];
_mapGroup.erase (theGroupID);
+ if (_rmGroupCallUp)
+ _rmGroupCallUp->RemoveGroup( theGroupID );
+ return true;
}
//=======================================================================
save << clause << ".1) Number of " << orderStr << " triangles: \t" << nb3 << endl;
save << clause << ".2) Number of " << orderStr << " quadrangles:\t" << nb4 << endl;
if ( nb3 + nb4 != NbFaces(order) ) {
- std::map<int,int> myFaceMap;
+ map<int,int> myFaceMap;
SMDS_FaceIteratorPtr itFaces=_myMeshDS->facesIterator();
while( itFaces->more( ) ) {
int nbNodes = itFaces->next()->NbNodes();
save << clause << ".3) Number of " << orderStr << " prisms: \t" << nb6 << endl;
save << clause << ".4) Number of " << orderStr << " pyramids:\t" << nb5 << endl;
if ( nb8 + nb4 + nb5 + nb6 != NbVolumes(order) ) {
- std::map<int,int> myVolumesMap;
+ map<int,int> myVolumesMap;
SMDS_VolumeIteratorPtr itVolumes=_myMeshDS->volumesIterator();
while( itVolumes->more( ) ) {
int nbNodes = itVolumes->next()->NbNodes();
SMESH_Group* SMESH_Mesh::ConvertToStandalone ( int theGroupID )
{
SMESH_Group* aGroup = 0;
- std::map < int, SMESH_Group * >::iterator itg = _mapGroup.find( theGroupID );
+ map < int, SMESH_Group * >::iterator itg = _mapGroup.find( theGroupID );
if ( itg == _mapGroup.end() )
return aGroup;
//=============================================================================
/*!
- * \brief fillAncestorsMap
+ * \brief fill _mapAncestors
*/
//=============================================================================
void SMESH_Mesh::fillAncestorsMap(const TopoDS_Shape& theShape)
{
- // fill _mapAncestors
+
int desType, ancType;
- for ( desType = TopAbs_VERTEX; desType > TopAbs_COMPOUND; desType-- )
- for ( ancType = desType - 1; ancType >= TopAbs_COMPOUND; ancType-- )
- TopExp::MapShapesAndAncestors ( theShape,
- (TopAbs_ShapeEnum) desType,
- (TopAbs_ShapeEnum) ancType,
- _mapAncestors );
+ if ( !theShape.IsSame( GetShapeToMesh()) && theShape.ShapeType() == TopAbs_COMPOUND )
+ {
+ // a geom group is added. Insert it into lists of ancestors before
+ // the first ancestor more complex than group members
+ int memberType = TopoDS_Iterator( theShape ).Value().ShapeType();
+ for ( desType = TopAbs_VERTEX; desType >= memberType; desType-- )
+ for (TopExp_Explorer des( theShape, TopAbs_ShapeEnum( desType )); des.More(); des.Next())
+ {
+ if ( !_mapAncestors.Contains( des.Current() )) continue;// issue 0020982
+ TopTools_ListOfShape& ancList = _mapAncestors.ChangeFromKey( des.Current() );
+ TopTools_ListIteratorOfListOfShape ancIt (ancList);
+ while ( ancIt.More() && ancIt.Value().ShapeType() >= memberType )
+ ancIt.Next();
+ if ( ancIt.More() )
+ ancList.InsertBefore( theShape, ancIt );
+ }
+ }
+ {
+ for ( desType = TopAbs_VERTEX; desType > TopAbs_COMPOUND; desType-- )
+ for ( ancType = desType - 1; ancType >= TopAbs_COMPOUND; ancType-- )
+ TopExp::MapShapesAndAncestors ( theShape,
+ (TopAbs_ShapeEnum) desType,
+ (TopAbs_ShapeEnum) ancType,
+ _mapAncestors );
+ }
}
//=============================================================================
*/
//=============================================================================
-bool SMESH_Mesh::SortByMeshOrder(std::list<SMESH_subMesh*>& theListToSort) const
+bool SMESH_Mesh::SortByMeshOrder(list<SMESH_subMesh*>& theListToSort) const
{
if ( !_mySubMeshOrder.size() || theListToSort.size() < 2)
return true;
bool res = false;
- std::list<SMESH_subMesh*> onlyOrderedList;
+ list<SMESH_subMesh*> onlyOrderedList;
// collect all ordered submeshes in one list as pointers
+ // and get their positions within theListToSort
+ typedef list<SMESH_subMesh*>::iterator TPosInList;
+ map< int, TPosInList > sortedPos;
+ TPosInList smBeg = theListToSort.begin(), smEnd = theListToSort.end();
TListOfListOfInt::const_iterator listIddIt = _mySubMeshOrder.begin();
for( ; listIddIt != _mySubMeshOrder.end(); listIddIt++) {
const TListOfInt& listOfId = *listIddIt;
TListOfInt::const_iterator idIt = listOfId.begin();
for ( ; idIt != listOfId.end(); idIt++ ) {
- map <int, SMESH_subMesh *>::const_iterator i_sm = _mapSubMesh.find(*idIt);
- if ( i_sm != _mapSubMesh.end() )
- onlyOrderedList.push_back(i_sm->second);
+ if ( SMESH_subMesh * sm = GetSubMeshContaining( *idIt )) {
+ TPosInList smPos = find( smBeg, smEnd, sm );
+ if ( smPos != smEnd ) {
+ onlyOrderedList.push_back( sm );
+ sortedPos[ distance( smBeg, smPos )] = smPos;
+ }
+ }
}
}
- if (!onlyOrderedList.size())
+ if (onlyOrderedList.size() < 2)
return res;
+ res = true;
- std::list<SMESH_subMesh*>::iterator onlyBIt = onlyOrderedList.begin();
- std::list<SMESH_subMesh*>::iterator onlyEIt = onlyOrderedList.end();
+ list<SMESH_subMesh*>::iterator onlyBIt = onlyOrderedList.begin();
+ list<SMESH_subMesh*>::iterator onlyEIt = onlyOrderedList.end();
- // check positions where ordered submeshes should be in result list
- std::set<int> setOfPos; // remember positions of in set
- std::list<SMESH_subMesh*>::const_iterator smIt = theListToSort.begin();
- int i = 0;
- for( ; smIt != theListToSort.end(); i++, smIt++ )
- if ( find( onlyBIt, onlyEIt, *smIt ) != onlyEIt )
- setOfPos.insert(i);
-
- if ( !setOfPos.size() )
- return res;
+ // iterates on ordered submeshes and insert them in detected positions
+ map< int, TPosInList >::iterator i_pos = sortedPos.begin();
+ for ( ; onlyBIt != onlyEIt; ++onlyBIt, ++i_pos )
+ *(i_pos->second) = *onlyBIt;
- // new list of all submeshes to be sorted
- std::list<SMESH_subMesh*> aNewList;
- // iterates on submeshes and insert ordered in detected positions
- for ( i = 0, smIt = theListToSort.begin(); smIt != theListToSort.end(); i++, smIt++ )
- if ( setOfPos.find( i ) != setOfPos.end() &&
- onlyBIt != onlyEIt ) { // position of ordered submesh detected
- aNewList.push_back( *onlyBIt ); // ordered submesh
- onlyBIt++;
- }
- else
- aNewList.push_back( *smIt ); // other submesh from list
-
- theListToSort = aNewList;
return res;
}
*/
//=============================================================================
-std::list<SMESH_subMesh*> SMESH_Mesh::getAncestorsSubMeshes
+list<SMESH_subMesh*> SMESH_Mesh::getAncestorsSubMeshes
(const TopoDS_Shape& theSubShape) const
{
- std::list<SMESH_subMesh*> listOfSubMesh;
+ list<SMESH_subMesh*> listOfSubMesh;
TopTools_ListIteratorOfListOfShape it( GetAncestors( theSubShape ));
- for (; it.More(); it.Next() ) {
- int index = _myMeshDS->ShapeToIndex(it.Value());
- map <int, SMESH_subMesh *>::const_iterator i_sm = _mapSubMesh.find(index);
- if (i_sm != _mapSubMesh.end())
- listOfSubMesh.push_back(i_sm->second);
- }
+ for (; it.More(); it.Next() )
+ if ( SMESH_subMesh* sm = GetSubMeshContaining( it.Value() ))
+ listOfSubMesh.push_back(sm);
// sort submeshes according to stored mesh order
SortByMeshOrder( listOfSubMesh );
