_impl = NULL;
_gen_i = gen_i;
_id = _idGenerator++;
+ _nbInvalidHypos= -1;
_editor = NULL;
_previewEditor = NULL;
_preMeshInfo = NULL;
if (geomClient->Find(S, aIOR)) {
geomClient->RemoveShapeFromBuffer(aIOR);
}
+ // clear buffer also for sub-groups
+ const std::set<SMESHDS_GroupBase*>& groups = _impl->GetMeshDS()->GetGroups();
+ std::set<SMESHDS_GroupBase*>::const_iterator g = groups.begin();
+ for (; g != groups.end(); ++g)
+ if (const SMESHDS_GroupOnGeom* group = dynamic_cast<SMESHDS_GroupOnGeom*>(*g))
+ {
+ const TopoDS_Shape& s = group->GetShape();
+ if (geomClient->Find(s, aIOR))
+ geomClient->RemoveShapeFromBuffer(aIOR);
+ }
+
+ // update the reference to theNewGeom (needed for correct execution of a dumped python script)
+ SMESH::SMESH_Mesh_var me = _this();
+ SALOMEDS::SObject_wrap aSO = _gen_i->ObjectToSObject( me );
+ CORBA::String_var entry = theNewGeom->GetStudyEntry();
+ if ( !aSO->_is_nil() )
+ {
+ SALOMEDS::SObject_wrap aShapeRefSO;
+ if ( aSO->FindSubObject( _gen_i->GetRefOnShapeTag(), aShapeRefSO.inout() ))
+ {
+ SALOMEDS::SObject_wrap aShapeSO = _gen_i->getStudyServant()->FindObjectID( entry );
+ SALOMEDS::StudyBuilder_var builder = _gen_i->getStudyServant()->NewBuilder();
+ builder->Addreference( aShapeRefSO, aShapeSO );
+ }
+ }
// re-assign global hypotheses to the new shape
_mainShapeTick = -1;
CheckGeomModif( true );
+
+ TPythonDump() << "SHAPERSTUDY.breakLinkForSubElements(salome.ObjectToSObject("
+ << me <<".GetMesh()), " << entry.in() << ")";
+
+ TPythonDump() << me << ".ReplaceShape( " << entry.in() << " )";
+
}
//================================================================================
if ( _preMeshInfo )
_preMeshInfo->ForgetOrLoad();
+ const int prevNbMeshEnt = _impl->NbNodes() + _impl->GetMeshDS()->NbElements();
+
std::string error;
SMESH_Hypothesis::Hypothesis_Status status = addHypothesis( aSubShape, anHyp, &error );
anErrorText = error.c_str();
if ( !SMESH_Hypothesis::IsStatusFatal(status) )
{
_gen_i->AddHypothesisToShape( mesh, aSubShape, anHyp );
- _gen_i->UpdateIcons( mesh );
+
+ int newNbMeshEnt = _impl->NbNodes() + _impl->GetMeshDS()->NbElements();
+ if ( newNbMeshEnt != prevNbMeshEnt )
+ _gen_i->UpdateIcons( mesh );
}
if(MYDEBUG) MESSAGE( " AddHypothesis(): status = " << status );
if ( groupSO->_is_nil() )
return;
// group indices
- GEOM::GEOM_Gen_var geomGen = _gen_i->GetGeomEngine( theGeomObj );
- GEOM::GEOM_IGroupOperations_ptr groupOp = geomGen->GetIGroupOperations();
- GEOM::ListOfLong_var ids = groupOp->GetObjects( theGeomObj );
+ GEOM::GEOM_Gen_var geomGen = _gen_i->GetGeomEngine( theGeomObj );
+ GEOM::GEOM_IGroupOperations_wrap groupOp = geomGen->GetIGroupOperations();
+ GEOM::ListOfLong_var ids = groupOp->GetObjects( theGeomObj );
// store data
_geomGroupData.push_back( TGeomGroupData() );
TopoDS_Shape SMESH_Mesh_i::newGroupShape( TGeomGroupData & groupData, int how )
{
TopoDS_Shape newShape;
+ SALOMEDS::SObject_wrap groupSO;
if ( how == IS_BREAK_LINK )
{
SALOMEDS::SObject_wrap meshSO = _gen_i->ObjectToSObject( groupData._smeshObject );
- SALOMEDS::SObject_wrap geomRefSO, geomSO;
+ SALOMEDS::SObject_wrap geomRefSO;
if ( !meshSO->_is_nil() &&
- meshSO->FindSubObject( SMESH::Tag_RefOnShape, geomRefSO.inout() ) &&
- geomRefSO->ReferencedObject( geomSO.inout() ))
+ meshSO->FindSubObject( SMESH::Tag_RefOnShape, geomRefSO.inout() ))
{
- CORBA::Object_var geomObj = _gen_i->SObjectToObject( geomSO );
- GEOM::GEOM_Object_var geom = GEOM::GEOM_Object::_narrow( geomObj );
- newShape = _gen_i->GeomObjectToShape( geom );
+ geomRefSO->ReferencedObject( groupSO.inout() );
}
}
else
{
// get geom group
- SALOMEDS::SObject_wrap groupSO = SMESH_Gen_i::getStudyServant()->FindObjectID( groupData._groupEntry.c_str() );
- if ( !groupSO->_is_nil() )
+ groupSO = _gen_i->getStudyServant()->FindObjectID( groupData._groupEntry.c_str() );
+ }
+
+ if ( groupSO->_is_nil() )
+ return newShape;
+
+ CORBA::Object_var groupObj = _gen_i->SObjectToObject( groupSO );
+ GEOM::GEOM_Object_var geomGroup = GEOM::GEOM_Object::_narrow( groupObj );
+ if ( geomGroup->_is_nil() )
+ return newShape;
+
+ // get indices of group items
+ set<int> curIndices;
+ GEOM::GEOM_Gen_var geomGen = _gen_i->GetGeomEngine( geomGroup );
+ GEOM::GEOM_IGroupOperations_wrap groupOp = geomGen->GetIGroupOperations();
+ GEOM::ListOfLong_var ids = groupOp->GetObjects( geomGroup );
+ for ( CORBA::ULong i = 0; i < ids->length(); ++i )
+ curIndices.insert( ids[i] );
+
+ bool sameIndices = ( groupData._indices == curIndices );
+ if ( how == ONLY_IF_CHANGED && sameIndices )
+ return newShape; // group not changed
+
+ newShape = _gen_i->GeomObjectToShape( geomGroup );
+
+ if ( !newShape.IsNull() && ids->length() > 0 )
+ {
+ if ( !sameIndices || !_impl->GetMeshDS()->IsGroupOfSubShapes( newShape ))
{
- CORBA::Object_var groupObj = _gen_i->SObjectToObject( groupSO );
- if ( CORBA::is_nil( groupObj )) return newShape;
- GEOM::GEOM_Object_var geomGroup = GEOM::GEOM_Object::_narrow( groupObj );
-
- // get indices of group items
- set<int> curIndices;
- GEOM::GEOM_Gen_var geomGen = _gen_i->GetGeomEngine( geomGroup );
- GEOM::GEOM_IGroupOperations_ptr groupOp = geomGen->GetIGroupOperations();
- GEOM::ListOfLong_var ids = groupOp->GetObjects( geomGroup );
- for ( CORBA::ULong i = 0; i < ids->length(); ++i )
- curIndices.insert( ids[i] );
-
- if ( how == ONLY_IF_CHANGED && groupData._indices == curIndices )
- return newShape; // group not changed
-
- // update data
- groupData._indices = curIndices;
-
- GEOM_Client* geomClient = _gen_i->GetShapeReader();
- if ( !geomClient ) return newShape;
+ GEOM_Client* geomClient = _gen_i->GetShapeReader();
CORBA::String_var groupIOR = geomGen->GetStringFromIOR( geomGroup );
geomClient->RemoveShapeFromBuffer( groupIOR.in() );
newShape = _gen_i->GeomObjectToShape( geomGroup );
}
}
- if ( newShape.IsNull() ) {
+ else
+ {
// geom group becomes empty - return empty compound
TopoDS_Compound compound;
BRep_Builder().MakeCompound(compound);
newShape = compound;
}
+
+ // update data
+ CORBA::String_var entry = geomGroup->GetStudyEntry();
+ groupData._groupEntry = entry.in();
+ groupData._indices = curIndices;
+
return newShape;
}
if ( !geomClient ) return;
GEOM::GEOM_Gen_var geomGen = _gen_i->GetGeomEngine( mainGO );
if ( geomGen->_is_nil() ) return;
+ CORBA::String_var geomComponentType = geomGen->ComponentDataType();
+ bool isShaper = ( strcmp( geomComponentType.in(), "SHAPERSTUDY" ) == 0 );
CORBA::String_var ior = geomGen->GetStringFromIOR( mainGO );
geomClient->RemoveShapeFromBuffer( ior.in() );
if ( _preMeshInfo )
_preMeshInfo->ForgetAllData();
- _impl->Clear();
+
+ if ( isBreakLink || !isShaper )
+ _impl->Clear();
TopoDS_Shape newShape = _gen_i->GeomObjectToShape( mainGO );
if ( newShape.IsNull() )
return;
SMESHDS_Mesh * meshDS = _impl->GetMeshDS();
- // store data of groups on geometry
+ // store data of groups on geometry including new TopoDS_Shape's
std::vector< TGroupOnGeomData > groupsData;
const std::set<SMESHDS_GroupBase*>& groups = meshDS->GetGroups();
groupsData.reserve( groups.size() );
geom = gog->GetShape();
}
}
- if ( !geom->_is_nil() )
+ if ( old2newShapeMap.IsBound( group->GetShape() ))
{
- CORBA::String_var ior = geomGen->GetStringFromIOR( geom );
- geomClient->RemoveShapeFromBuffer( ior.in() );
- groupsData.back()._shape = _gen_i->GeomObjectToShape( geom );
- old2newShapeMap.Bind( group->GetShape(), groupsData.back()._shape );
+ groupsData.back()._shape = old2newShapeMap( group->GetShape() );
}
- else if ( old2newShapeMap.IsBound( group->GetShape() ))
+ else if ( !geom->_is_nil() )
{
- groupsData.back()._shape = old2newShapeMap( group->GetShape() );
+ groupsData.back()._shape = _gen_i->GeomObjectToShape( geom );
+ if ( meshDS->ShapeToIndex( groupsData.back()._shape ) > 0 )
+ {
+ CORBA::String_var ior = geomGen->GetStringFromIOR( geom );
+ geomClient->RemoveShapeFromBuffer( ior.in() );
+ groupsData.back()._shape = _gen_i->GeomObjectToShape( geom );
+ }
+ old2newShapeMap.Bind( group->GetShape(), groupsData.back()._shape );
}
+
}
}
// store assigned hypotheses
ids2Hyps.push_back( make_pair( meshDS->ShapeToIndex( s ), hyps ));
}
- std::map< std::set<int>, int > ii2iMap; // group sub-ids to group id in SMESHDS
+ std::multimap< std::set<int>, int > ii2iMap; // group sub-ids to group id in SMESHDS
// count shapes excluding compounds corresponding to geom groups
int oldNbSubShapes = meshDS->MaxShapeIndex();
}
// re-add shapes (compounds) of geom groups
+ typedef std::map< std::vector< int >, TGeomGroupData* > TIndices2GroupData;
+ TIndices2GroupData ii2grData;
+ std::vector< int > ii;
std::map< int, int > old2newIDs; // group IDs
- std::list<TGeomGroupData>::iterator data = _geomGroupData.begin();
- for ( ; data != _geomGroupData.end(); ++data )
+ std::list<TGeomGroupData>::iterator dataIt = _geomGroupData.begin();
+ for ( ; dataIt != _geomGroupData.end(); ++dataIt )
{
+ TGeomGroupData* data = &(*dataIt);
+ ii.reserve( data->_indices.size() );
+ ii.assign( data->_indices.begin(), data->_indices.end() );
+ TIndices2GroupData::iterator ii2gd = ii2grData.insert( std::make_pair( ii, data )).first;
+ if ( ii2gd->second != data )
+ {
+ data->_groupEntry = ii2gd->second->_groupEntry;
+ data->_indices = ii2gd->second->_indices;
+ continue;
+ }
+ const int oldNbSub = data->_indices.size();
+ const int soleOldID = oldNbSub == 1 ? *data->_indices.begin() : 0;
int oldID = 0;
- std::map< std::set<int>, int >::iterator ii2i = ii2iMap.find( data->_indices );
+ std::multimap< std::set<int>, int >::iterator ii2i = ii2iMap.find( data->_indices );
if ( ii2i != ii2iMap.end() )
+ {
oldID = ii2i->second;
+ ii2iMap.erase( ii2i );
+ }
+ if ( !oldID && oldNbSub == 1 )
+ oldID = soleOldID;
+ if ( old2newIDs.count( oldID ))
+ continue;
+
+ int how = ( isBreakLink || !sameTopology ) ? IS_BREAK_LINK : MAIN_TRANSFORMED;
+ newShape = newGroupShape( *data, how );
- TopoDS_Shape newShape = newGroupShape( *data, isBreakLink ? IS_BREAK_LINK : MAIN_TRANSFORMED );
if ( !newShape.IsNull() )
{
- if ( meshDS->ShapeToIndex( newShape ) > 0 ) // a group reduced to one sub-shape
+ if ( oldNbSub > 1 && meshDS->ShapeToIndex( newShape ) > 0 ) // group reduced to one sub-shape
{
TopoDS_Compound compound;
BRep_Builder().MakeCompound( compound );
newShape = compound;
}
int newID = _impl->GetSubMesh( newShape )->GetId();
- if ( oldID && oldID != newID )
+ if ( oldID /*&& oldID != newID*/ )
old2newIDs.insert( std::make_pair( oldID, newID ));
+ if ( oldNbSub == 1 )
+ old2newIDs.insert( std::make_pair( soleOldID, newID ));
}
}
// re-assign hypotheses
for ( size_t i = 0; i < ids2Hyps.size(); ++i )
{
- if ( !sameTopology && ids2Hyps[i].first != 1 )
- continue; // assign only global hypos
int sID = ids2Hyps[i].first;
std::map< int, int >::iterator o2n = old2newIDs.find( sID );
if ( o2n != old2newIDs.end() )
sID = o2n->second;
+ else if ( !sameTopology && sID != 1 )
+ continue;
const TopoDS_Shape& s = meshDS->IndexToShape( sID );
- const THypList& hyps = ids2Hyps[i].second;
+ if ( s.IsNull() )
+ continue;
+ const THypList& hyps = ids2Hyps[i].second;
THypList::const_iterator h = hyps.begin();
for ( ; h != hyps.end(); ++h )
_impl->AddHypothesis( s, (*h)->GetID() );
}
- if ( !sameTopology )
- {
- // remove invalid study sub-objects
- CheckGeomGroupModif();
- }
- else
{
// restore groups on geometry
for ( size_t i = 0; i < groupsData.size(); ++i )
g->GetGroupDS()->SetColor( data._color );
}
- std::map< int, int >::iterator o2n = old2newIDs.begin();
- for ( ; o2n != old2newIDs.end(); ++o2n )
+ if ( !sameTopology )
{
- int newID = o2n->second, oldID = o2n->first;
- if ( !_mapSubMesh.count( oldID ))
- continue;
- _mapSubMesh [ newID ] = _impl->GetSubMeshContaining( newID );
- _mapSubMesh_i [ newID ] = _mapSubMesh_i [ oldID ];
- _mapSubMeshIor[ newID ] = _mapSubMeshIor[ oldID ];
- _mapSubMesh. erase(oldID);
- _mapSubMesh_i. erase(oldID);
- _mapSubMeshIor.erase(oldID);
- _mapSubMesh_i [ newID ]->changeLocalId( newID );
+ std::map< int, int >::iterator o2n = old2newIDs.begin();
+ for ( ; o2n != old2newIDs.end(); ++o2n )
+ {
+ int newID = o2n->second, oldID = o2n->first;
+ if ( newID == oldID || !_mapSubMesh.count( oldID ))
+ continue;
+ if ( newID > 0 )
+ {
+ _mapSubMesh [ newID ] = _impl->GetSubMeshContaining( newID );
+ _mapSubMesh_i [ newID ] = _mapSubMesh_i [ oldID ];
+ _mapSubMeshIor[ newID ] = _mapSubMeshIor[ oldID ];
+ }
+ _mapSubMesh. erase(oldID);
+ _mapSubMesh_i. erase(oldID);
+ _mapSubMeshIor.erase(oldID);
+ if ( newID > 0 )
+ _mapSubMesh_i [ newID ]->changeLocalId( newID );
+ }
}
// update _mapSubMesh
i_sm->second = _impl->GetSubMesh( meshDS->IndexToShape( i_sm->first ));
}
- _gen_i->UpdateIcons( SMESH::SMESH_Mesh_var( _this() ));
+ if ( !sameTopology )
+ {
+ // remove invalid study sub-objects
+ CheckGeomGroupModif();
+ }
+
+ _gen_i->UpdateIcons( me );
- if ( !isBreakLink )
+ if ( !isBreakLink && isShaper )
{
SALOMEDS::SObject_wrap meshSO = _gen_i->ObjectToSObject( me );
if ( !meshSO->_is_nil() )
{
SMESH::SMESH_GroupBase_ptr group = i_gr->second;
++i_gr;
- SALOMEDS::SObject_wrap groupSO = _gen_i->ObjectToSObject( group ), refSO;
+ SALOMEDS::SObject_wrap groupSO = _gen_i->ObjectToSObject( group ), refSO, geomSO;
SMESH::SMESH_GroupOnGeom_var onGeom = SMESH::SMESH_GroupOnGeom::_narrow ( group );
SMESH::SMESH_GroupOnFilter_var onFilt = SMESH::SMESH_GroupOnFilter::_narrow( group );
bool isValidGeom = false;
if ( !onGeom->_is_nil() )
{
- isValidGeom = ( ! GEOM::GEOM_Object_var( onGeom->GetShape() )->_is_nil() );
+ isValidGeom = ( ! GEOM::GEOM_Object_var( onGeom->GetShape() )->_is_nil() &&
+ ! groupSO->_is_nil() &&
+ groupSO->FindSubObject( SMESH::Tag_RefOnShape, refSO.inout() ) &&
+ refSO->ReferencedObject( geomSO.inout() ) &&
+ ! geomSO->_is_nil());
+ isValidGeom = ( isValidGeom && !CORBA::is_nil( CORBA::Object_var( geomSO->GetObject() )));
}
else if ( !onFilt->_is_nil() )
{
SMESH_Mesh_i* _mesh;
TCallUp_i(SMESH_Mesh_i* mesh):_mesh(mesh) {}
virtual void RemoveGroup (const int theGroupID) { _mesh->removeGroup( theGroupID ); }
- virtual void HypothesisModified (int theHypID) { _mesh->onHypothesisModified( theHypID ); }
+ virtual void HypothesisModified( int hypID,
+ bool updIcons) { _mesh->onHypothesisModified( hypID,
+ updIcons ); }
virtual void Load () { _mesh->Load(); }
+ virtual bool IsLoaded() { return _mesh->IsLoaded(); }
};
}
//================================================================================
/*!
- * \brief callback from _impl to forget not loaded mesh data (issue 0021208)
+ * \brief callback from _impl to
+ * 1) forget not loaded mesh data (issue 0021208)
+ * 2) mark hypothesis as valid
*/
//================================================================================
-void SMESH_Mesh_i::onHypothesisModified(int theHypID)
+void SMESH_Mesh_i::onHypothesisModified(int theHypID, bool theUpdateIcons)
{
if ( _preMeshInfo )
_preMeshInfo->ForgetOrLoad();
- SMESH::SMESH_Mesh_var mesh = _this();
- _gen_i->UpdateIcons( mesh );
+ if ( theUpdateIcons )
+ {
+ SMESH::SMESH_Mesh_var mesh = _this();
+ _gen_i->UpdateIcons( mesh );
+ }
- // mark a hypothesis as valid after edition
- SALOMEDS::SComponent_wrap smeshComp = _gen_i->PublishComponent();
- SALOMEDS::SObject_wrap hypRoot;
- if ( !smeshComp->_is_nil() &&
- smeshComp->FindSubObject( _gen_i->GetHypothesisRootTag(), hypRoot.inout() ))
+ if ( _nbInvalidHypos != 0 )
{
- SALOMEDS::ChildIterator_wrap anIter = _gen_i->getStudyServant()->NewChildIterator( hypRoot );
- for ( ; anIter->More(); anIter->Next() )
+ // mark a hypothesis as valid after edition
+ int nbInvalid = 0;
+ SALOMEDS::SComponent_wrap smeshComp = _gen_i->PublishComponent();
+ SALOMEDS::SObject_wrap hypRoot;
+ if ( !smeshComp->_is_nil() &&
+ smeshComp->FindSubObject( _gen_i->GetHypothesisRootTag(), hypRoot.inout() ))
{
- SALOMEDS::SObject_wrap hypSO = anIter->Value();
- CORBA::Object_var obj = _gen_i->SObjectToObject( hypSO );
- SMESH::SMESH_Hypothesis_var hyp = SMESH::SMESH_Hypothesis::_narrow( obj );
- if ( !hyp->_is_nil() && hyp->GetId() == theHypID )
- _gen_i->HighLightInvalid( hyp, false );
+ SALOMEDS::ChildIterator_wrap anIter = _gen_i->getStudyServant()->NewChildIterator( hypRoot );
+ for ( ; anIter->More(); anIter->Next() )
+ {
+ SALOMEDS::SObject_wrap hypSO = anIter->Value();
+ CORBA::Object_var obj = _gen_i->SObjectToObject( hypSO );
+ SMESH::SMESH_Hypothesis_var hyp = SMESH::SMESH_Hypothesis::_narrow( obj );
+ if ( !hyp->_is_nil() && hyp->GetId() == theHypID )
+ _gen_i->HighLightInvalid( hyp, false );
+ else
+ nbInvalid += _gen_i->IsInvalid( hypSO );
+ }
}
+ _nbInvalidHypos = nbInvalid;
}
}
