ForkMaster/smesh
1
0
Fork 0
mirror of https://git.salome-platform.org/gitpub/modules/smesh.git synced 2024-12-27 09:50:34 +05:00
Code Issues Packages Projects Releases Wiki Activity

0020976: EDF 1471 SMESH: New ergonomy to display quality controls

Browse Source 
1) New general mechanism to avoid dump of functors not used later as arguments
2) Use the New general mechanism to filters and sub-meshes
3) Erase the 1st incarnation of re-created objects.
A re-created object appears e.g. as follows:
- create a mesh
- remove the mesh
- save and re-open the study
- create another mesh -> ( two meshes have same Entry ) == ( the 1st mesh is re-created )
This commit is contained in:
eap 2013-07-17 14:27:42 +00:00
parent 94ce6f40fc
commit 85aae58ead
2 changed files with 283 additions and 148 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

403
src/SMESH_I/SMESH_2smeshpy.cxx
View File

@ -369,7 +369,8 @@ namespace {
"ExtrusionSweepObject1D","ExtrusionSweepObject1DMakeGroups", "ExtrusionSweepObject1D","ExtrusionSweepObject1DMakeGroups",
"ExtrusionSweepObject2D","ExtrusionSweepObject2DMakeGroups", "ExtrusionSweepObject2D","ExtrusionSweepObject2DMakeGroups",
"Translate","TranslateMakeGroups","TranslateMakeMesh", "Translate","TranslateMakeGroups","TranslateMakeMesh",
"TranslateObject","TranslateObjectMakeGroups", "TranslateObjectMakeMesh" "TranslateObject","TranslateObjectMakeGroups", "TranslateObjectMakeMesh",
"ExtrusionAlongPathX","ExtrusionAlongPathObjX"
,"" }; // <- mark of the end ,"" }; // <- mark of the end
methodsAcceptingList.Insert( methodNames ); methodsAcceptingList.Insert( methodNames );
} }
@ -621,21 +622,31 @@ Handle(_pyCommand) _pyGen::AddCommand( const TCollection_AsciiString& theCommand
// Prevent moving a command creating a sub-mesh to the end of the script // Prevent moving a command creating a sub-mesh to the end of the script
// if the sub-mesh is used in theCommand as argument // if the sub-mesh is used in theCommand as argument
if ( _pySubMesh::CanBeArgOfMethod( aCommand->GetMethod() )) // if ( _pySubMesh::CanBeArgOfMethod( aCommand->GetMethod() ))
{ // {
PlaceSubmeshAfterItsCreation( aCommand ); // PlaceSubmeshAfterItsCreation( aCommand );
} // }
// Method( SMESH.PointStruct(x,y,z) -> Method( [x,y,z] // Method( SMESH.PointStruct(x,y,z)... -> Method( [x,y,z]...
StructToList( aCommand ); StructToList( aCommand );
// not to erase _pySelfEraser's etc. used as args in some commands
std::list< _pyID >::const_iterator id = myKeepAgrCmdsIDs.begin();
for ( ; id != myKeepAgrCmdsIDs.end(); ++id )
if ( *id != objID && theCommand.Search( *id ) > id->Length() )
{
Handle(_pyObject) obj = FindObject( *id );
if ( !obj.IsNull() )
obj->AddArgCmd( aCommand );
}
// Find an object to process theCommand // Find an object to process theCommand
// SMESH_Gen method? // SMESH_Gen method?
if ( objID == this->GetID() || objID == SMESH_2smeshpy::GenName()) if ( objID == this->GetID() || objID == SMESH_2smeshpy::GenName())
{ {
this->Process( aCommand ); this->Process( aCommand );
addFilterUser( aCommand, theGen ); // protect filters from clearing //addFilterUser( aCommand, theGen ); // protect filters from clearing
return aCommand; return aCommand;
} }
@ -656,13 +667,14 @@ Handle(_pyCommand) _pyGen::AddCommand( const TCollection_AsciiString& theCommand
else if ( aCommand->GetMethod() == "GetSubMesh" ) { // SubMesh creation else if ( aCommand->GetMethod() == "GetSubMesh" ) { // SubMesh creation
_pyID subMeshID = aCommand->GetResultValue(); _pyID subMeshID = aCommand->GetResultValue();
Handle(_pySubMesh) subMesh = new _pySubMesh( aCommand ); Handle(_pySubMesh) subMesh = new _pySubMesh( aCommand );
CheckObjectIsReCreated( subMesh );
myObjects.insert( make_pair( subMeshID, subMesh )); myObjects.insert( make_pair( subMeshID, subMesh ));
} }
// Method( mesh.GetIDSource([id1,id2]) -> Method( [id1,id2] // Method( mesh.GetIDSource([id1,id2]) -> Method( [id1,id2]
GetIDSourceToList( aCommand ); GetIDSourceToList( aCommand );
addFilterUser( aCommand, theGen ); // protect filters from clearing //addFilterUser( aCommand, theGen ); // protect filters from clearing
id_mesh->second->Process( aCommand ); id_mesh->second->Process( aCommand );
id_mesh->second->AddProcessedCmd( aCommand ); id_mesh->second->AddProcessedCmd( aCommand );
@ -676,7 +688,7 @@ Handle(_pyCommand) _pyGen::AddCommand( const TCollection_AsciiString& theCommand
// Method( mesh.GetIDSource([id1,id2]) -> Method( [id1,id2] // Method( mesh.GetIDSource([id1,id2]) -> Method( [id1,id2]
GetIDSourceToList( aCommand ); GetIDSourceToList( aCommand );
addFilterUser( aCommand, theGen ); // protect filters from clearing //addFilterUser( aCommand, theGen ); // protect filters from clearing
const TCollection_AsciiString& method = aCommand->GetMethod(); const TCollection_AsciiString& method = aCommand->GetMethod();
@ -716,8 +728,9 @@ Handle(_pyCommand) _pyGen::AddCommand( const TCollection_AsciiString& theCommand
!myMeshes.count( meshID ) && !myMeshes.count( meshID ) &&
aCommand->IsStudyEntry( meshID )) aCommand->IsStudyEntry( meshID ))
{ {
TCollection_AsciiString processedCommand = aCommand->GetString(); _AString processedCommand = aCommand->GetString();
Handle(_pyMesh) mesh = new _pyMesh( aCommand, meshID ); Handle(_pyMesh) mesh = new _pyMesh( aCommand, meshID );
CheckObjectIsReCreated( mesh );
myMeshes.insert( make_pair( meshID, mesh )); myMeshes.insert( make_pair( meshID, mesh ));
aCommand->Clear(); aCommand->Clear();
aCommand->GetString() = processedCommand; // discard changes made by _pyMesh aCommand->GetString() = processedCommand; // discard changes made by _pyMesh
@ -743,13 +756,13 @@ Handle(_pyCommand) _pyGen::AddCommand( const TCollection_AsciiString& theCommand
} // SMESH_MeshEditor methods } // SMESH_MeshEditor methods
// SMESH_Hypothesis method? // SMESH_Hypothesis method?
list< Handle(_pyHypothesis) >::iterator hyp = myHypos.begin(); Handle(_pyHypothesis) hyp = FindHyp( objID );
for ( ; hyp != myHypos.end(); ++hyp ) if ( !hyp.IsNull() && !hyp->IsAlgo() )
if ( !(*hyp)->IsAlgo() && objID == (*hyp)->GetID() ) { {
(*hyp)->Process( aCommand ); hyp->Process( aCommand );
(*hyp)->AddProcessedCmd( aCommand ); hyp->AddProcessedCmd( aCommand );
return aCommand; return aCommand;
} }
// aFilterManager.CreateFilter() ? // aFilterManager.CreateFilter() ?
if ( aCommand->GetMethod() == "CreateFilter" ) if ( aCommand->GetMethod() == "CreateFilter" )
@ -764,6 +777,14 @@ Handle(_pyCommand) _pyGen::AddCommand( const TCollection_AsciiString& theCommand
Handle(_pyObject) filter( new _pyFilter( aCommand, newID )); Handle(_pyObject) filter( new _pyFilter( aCommand, newID ));
AddObject( filter ); AddObject( filter );
} }
// aFreeNodes0x5011f80 = aFilterManager.CreateFreeNodes() ## issue 0020976
else if ( theCommand.Search( "aFilterManager.Create" ) > 0 )
{
// create _pySelfEraser for functors
Handle(_pySelfEraser) functor = new _pySelfEraser( aCommand );
functor->IgnoreOwnCalls(); // to erase if not used as an argument
AddObject( functor );
}
// other object method? // other object method?
map< _pyID, Handle(_pyObject) >::iterator id_obj = myObjects.find( objID ); map< _pyID, Handle(_pyObject) >::iterator id_obj = myObjects.find( objID );
@ -914,7 +935,7 @@ void _pyGen::Process( const Handle(_pyCommand)& theCommand )
if ( method == "CreateMesh" || method == "CreateEmptyMesh") if ( method == "CreateMesh" || method == "CreateEmptyMesh")
{ {
Handle(_pyMesh) mesh = new _pyMesh( theCommand ); Handle(_pyMesh) mesh = new _pyMesh( theCommand );
myMeshes.insert( make_pair( mesh->GetID(), mesh )); AddObject( mesh );
return; return;
} }
if ( method == "CreateMeshesFromUNV" || if ( method == "CreateMeshesFromUNV" ||
@ -922,7 +943,7 @@ void _pyGen::Process( const Handle(_pyCommand)& theCommand )
method == "CopyMesh" ) // command result is a mesh method == "CopyMesh" ) // command result is a mesh
{ {
Handle(_pyMesh) mesh = new _pyMesh( theCommand, theCommand->GetResultValue() ); Handle(_pyMesh) mesh = new _pyMesh( theCommand, theCommand->GetResultValue() );
myMeshes.insert( make_pair( mesh->GetID(), mesh )); AddObject( mesh );
return; return;
} }
if( method == "CreateMeshesFromMED" || if( method == "CreateMeshesFromMED" ||
@ -935,7 +956,7 @@ void _pyGen::Process( const Handle(_pyCommand)& theCommand )
_pyID meshID = theCommand->GetResultValue(ind+1); _pyID meshID = theCommand->GetResultValue(ind+1);
if ( !theCommand->IsStudyEntry( meshID ) ) continue; if ( !theCommand->IsStudyEntry( meshID ) ) continue;
Handle(_pyMesh) mesh = new _pyMesh( theCommand, theCommand->GetResultValue(ind+1)); Handle(_pyMesh) mesh = new _pyMesh( theCommand, theCommand->GetResultValue(ind+1));
myMeshes.insert( make_pair( mesh->GetID(), mesh )); AddObject( mesh );
} }
if ( method == "CreateMeshesFromGMF" ) if ( method == "CreateMeshesFromGMF" )
{ {
@ -953,13 +974,16 @@ void _pyGen::Process( const Handle(_pyCommand)& theCommand )
// issue 199929, remove standard library name (default parameter) // issue 199929, remove standard library name (default parameter)
const TCollection_AsciiString & aLibName = theCommand->GetArg( 2 ); const TCollection_AsciiString & aLibName = theCommand->GetArg( 2 );
if ( aLibName.Search( "StdMeshersEngine" ) != -1 ) { if ( aLibName.Search( "StdMeshersEngine" ) != -1 ) {
// keep first argument // keep the first argument
TCollection_AsciiString arg = theCommand->GetArg( 1 ); TCollection_AsciiString arg = theCommand->GetArg( 1 );
theCommand->RemoveArgs(); theCommand->RemoveArgs();
theCommand->SetArg( 1, arg ); theCommand->SetArg( 1, arg );
} }
myHypos.push_back( _pyHypothesis::NewHypothesis( theCommand )); Handle(_pyHypothesis) hyp = _pyHypothesis::NewHypothesis( theCommand );
CheckObjectIsReCreated( hyp );
myHypos.insert( make_pair( hyp->GetID(), hyp ));
return; return;
} }
@ -996,7 +1020,8 @@ void _pyGen::Process( const Handle(_pyCommand)& theCommand )
// SMESH_Pattern, FilterManager // SMESH_Pattern, FilterManager
if ( method == "GetPattern" || if ( method == "GetPattern" ||
method == "CreateFilterManager" || method == "CreateFilterManager" ||
method == "CreateMeasurements" ) { method == "CreateMeasurements" )
{
Handle(_pyObject) obj = new _pySelfEraser( theCommand ); Handle(_pyObject) obj = new _pySelfEraser( theCommand );
if ( !myObjects.insert( make_pair( obj->GetID(), obj )).second ) if ( !myObjects.insert( make_pair( obj->GetID(), obj )).second )
theCommand->Clear(); // already created theCommand->Clear(); // already created
@ -1009,7 +1034,7 @@ void _pyGen::Process( const Handle(_pyCommand)& theCommand )
theCommand->SetArg( theCommand->GetNbArgs() + 1, "True" ); theCommand->SetArg( theCommand->GetNbArgs() + 1, "True" );
} }
Handle(_pyMesh) mesh = new _pyMesh( theCommand, theCommand->GetResultValue() ); Handle(_pyMesh) mesh = new _pyMesh( theCommand, theCommand->GetResultValue() );
myMeshes.insert( make_pair( mesh->GetID(), mesh )); AddObject( mesh );
AddMeshAccessorMethod( theCommand ); AddMeshAccessorMethod( theCommand );
} }
else if ( method == "SetName" ) // SetName(obj,name) else if ( method == "SetName" ) // SetName(obj,name)
@ -1053,15 +1078,15 @@ void _pyGen::Flush()
map< _pyID, Handle(_pyMesh) >::iterator id_mesh; map< _pyID, Handle(_pyMesh) >::iterator id_mesh;
map< _pyID, Handle(_pyObject) >::iterator id_obj; map< _pyID, Handle(_pyObject) >::iterator id_obj;
list< Handle(_pyHypothesis) >::iterator hyp; map< _pyID, Handle(_pyHypothesis) >::iterator id_hyp;
if ( IsToKeepAllCommands() ) // historical dump if ( IsToKeepAllCommands() ) // historical dump
{ {
// set myIsPublished = true to all objects // set myIsPublished = true to all objects
for ( id_mesh = myMeshes.begin(); id_mesh != myMeshes.end(); ++id_mesh ) for ( id_mesh = myMeshes.begin(); id_mesh != myMeshes.end(); ++id_mesh )
id_mesh->second->SetRemovedFromStudy( false ); id_mesh->second->SetRemovedFromStudy( false );
for ( hyp = myHypos.begin(); hyp != myHypos.end(); ++hyp ) for ( id_hyp = myHypos.begin(); id_hyp != myHypos.end(); ++id_hyp )
(*hyp)->SetRemovedFromStudy( false ); id_hyp->second->SetRemovedFromStudy( false );
for ( id_obj = myObjects.begin(); id_obj != myObjects.end(); ++id_obj ) for ( id_obj = myObjects.begin(); id_obj != myObjects.end(); ++id_obj )
id_obj->second->SetRemovedFromStudy( false ); id_obj->second->SetRemovedFromStudy( false );
} }
@ -1070,9 +1095,9 @@ void _pyGen::Flush()
// let hypotheses find referred objects in order to prevent clearing // let hypotheses find referred objects in order to prevent clearing
// not published referred hyps (it's needed for hyps like "LayerDistribution") // not published referred hyps (it's needed for hyps like "LayerDistribution")
list< Handle(_pyMesh) > fatherMeshes; list< Handle(_pyMesh) > fatherMeshes;
for ( hyp = myHypos.begin(); hyp != myHypos.end(); ++hyp ) for ( id_hyp = myHypos.begin(); id_hyp != myHypos.end(); ++id_hyp )
if ( !hyp->IsNull() ) if ( !id_hyp->second.IsNull() )
(*hyp)->GetReferredMeshesAndGeom( fatherMeshes ); id_hyp->second->GetReferredMeshesAndGeom( fatherMeshes );
} }
// set myIsPublished = false to all objects depending on // set myIsPublished = false to all objects depending on
// meshes built on a removed geometry // meshes built on a removed geometry
@ -1086,12 +1111,12 @@ void _pyGen::Flush()
id_mesh->second->Flush(); id_mesh->second->Flush();
// Flush hyps // Flush hyps
for ( hyp = myHypos.begin(); hyp != myHypos.end(); ++hyp ) for ( id_hyp = myHypos.begin(); id_hyp != myHypos.end(); ++id_hyp )
if ( !hyp->IsNull() ) { if ( !id_hyp->second.IsNull() ) {
(*hyp)->Flush(); id_hyp->second->Flush();
// smeshgen.CreateHypothesis() --> smesh.CreateHypothesis() // smeshgen.CreateHypothesis() --> smesh.CreateHypothesis()
if ( !(*hyp)->IsWrapped() ) if ( !id_hyp->second->IsWrapped() )
(*hyp)->GetCreationCmd()->SetObject( SMESH_2smeshpy::GenName() ); id_hyp->second->GetCreationCmd()->SetObject( SMESH_2smeshpy::GenName() );
} }
// Flush other objects // Flush other objects
@ -1143,10 +1168,10 @@ void _pyGen::ClearCommands()
for ( ; id_mesh != myMeshes.end(); ++id_mesh ) for ( ; id_mesh != myMeshes.end(); ++id_mesh )
id_mesh->second->ClearCommands(); id_mesh->second->ClearCommands();
list< Handle(_pyHypothesis) >::iterator hyp = myHypos.begin(); map< _pyID, Handle(_pyHypothesis) >::iterator id_hyp = myHypos.begin();
for ( ; hyp != myHypos.end(); ++hyp ) for ( ; id_hyp != myHypos.end(); ++id_hyp )
if ( !hyp->IsNull() ) if ( !id_hyp->second.IsNull() )
(*hyp)->ClearCommands(); id_hyp->second->ClearCommands();
map< _pyID, Handle(_pyObject) >::iterator id_obj = myObjects.begin(); map< _pyID, Handle(_pyObject) >::iterator id_obj = myObjects.begin();
for ( ; id_obj != myObjects.end(); ++id_obj ) for ( ; id_obj != myObjects.end(); ++id_obj )
@ -1176,10 +1201,10 @@ void _pyGen::Free()
id_obj->second->Free(); id_obj->second->Free();
myObjects.clear(); myObjects.clear();
list< Handle(_pyHypothesis) >::iterator hyp = myHypos.begin(); map< _pyID, Handle(_pyHypothesis) >::iterator id_hyp = myHypos.begin();
for ( ; hyp != myHypos.end(); ++hyp ) for ( ; id_hyp != myHypos.end(); ++id_hyp )
if ( !hyp->IsNull() ) if ( !id_hyp->second.IsNull() )
(*hyp)->Free(); id_hyp->second->Free();
myHypos.clear(); myHypos.clear();
myFile2ExportedMesh.clear(); myFile2ExportedMesh.clear();
@ -1215,12 +1240,14 @@ bool _pyGen::AddMeshAccessorMethod( Handle(_pyCommand) theCmd ) const
bool _pyGen::AddAlgoAccessorMethod( Handle(_pyCommand) theCmd ) const bool _pyGen::AddAlgoAccessorMethod( Handle(_pyCommand) theCmd ) const
{ {
bool added = false; bool added = false;
list< Handle(_pyHypothesis) >::const_iterator hyp = myHypos.begin(); map< _pyID, Handle(_pyHypothesis) >::const_iterator id_hyp = myHypos.begin();
for ( ; hyp != myHypos.end(); ++hyp ) { for ( ; id_hyp != myHypos.end(); ++id_hyp )
if ( (*hyp)->IsAlgo() && /*(*hyp)->IsWrapped() &&*/ if ( !id_hyp->second.IsNull() &&
theCmd->AddAccessorMethod( (*hyp)->GetID(), (*hyp)->AccessorMethod() )) id_hyp->second->IsAlgo() && /*(*hyp)->IsWrapped() &&*/
theCmd->AddAccessorMethod( id_hyp->second->GetID(),
id_hyp->second->AccessorMethod() ))
added = true; added = true;
}
return added; return added;
} }
@ -1234,19 +1261,20 @@ bool _pyGen::AddAlgoAccessorMethod( Handle(_pyCommand) theCmd ) const
Handle(_pyHypothesis) _pyGen::FindHyp( const _pyID& theHypID ) Handle(_pyHypothesis) _pyGen::FindHyp( const _pyID& theHypID )
{ {
list< Handle(_pyHypothesis) >::iterator hyp = myHypos.begin(); map< _pyID, Handle(_pyHypothesis) >::iterator id_hyp = myHypos.find( theHypID );
for ( ; hyp != myHypos.end(); ++hyp ) if ( id_hyp != myHypos.end() &&
if ( !hyp->IsNull() && theHypID == (*hyp)->GetID() ) !id_hyp->second.IsNull() &&
return *hyp; theHypID == id_hyp->second->GetID() )
return id_hyp->second;
return Handle(_pyHypothesis)(); return Handle(_pyHypothesis)();
} }
//================================================================================ //================================================================================
/*! /*!
* \brief Find algorithm the created algorithm * \brief Find algorithm able to create a hypothesis
* \param theGeom - The shape ID the algorithm was created on * \param theGeom - The shape ID the algorithm was created on
* \param theMesh - The mesh ID that created the algorithm * \param theMesh - The mesh ID that created the algorithm
* \param dim - The algo dimension * \param theHypothesis - The hypothesis the algorithm sould be able to create
* \retval Handle(_pyHypothesis) - The found algo * \retval Handle(_pyHypothesis) - The found algo
*/ */
//================================================================================ //================================================================================
@ -1254,15 +1282,15 @@ Handle(_pyHypothesis) _pyGen::FindHyp( const _pyID& theHypID )
Handle(_pyHypothesis) _pyGen::FindAlgo( const _pyID& theGeom, const _pyID& theMesh, Handle(_pyHypothesis) _pyGen::FindAlgo( const _pyID& theGeom, const _pyID& theMesh,
const Handle(_pyHypothesis)& theHypothesis ) const Handle(_pyHypothesis)& theHypothesis )
{ {
list< Handle(_pyHypothesis) >::iterator hyp = myHypos.begin(); map< _pyID, Handle(_pyHypothesis) >::iterator id_hyp = myHypos.begin();
for ( ; hyp != myHypos.end(); ++hyp ) for ( ; id_hyp != myHypos.end(); ++id_hyp )
if ( !hyp->IsNull() && if ( !id_hyp->second.IsNull() &&
(*hyp)->IsAlgo() && id_hyp->second->IsAlgo() &&
theHypothesis->CanBeCreatedBy( (*hyp)->GetAlgoType() ) && theHypothesis->CanBeCreatedBy( id_hyp->second->GetAlgoType() ) &&
(*hyp)->GetGeom() == theGeom && id_hyp->second->GetGeom() == theGeom &&
(*hyp)->GetMesh() == theMesh ) id_hyp->second->GetMesh() == theMesh )
return *hyp; return id_hyp->second;
return 0; return Handle(_pyHypothesis)();
} }
//================================================================================ //================================================================================
@ -1362,28 +1390,30 @@ void _pyGen::setNeighbourCommand( Handle(_pyCommand)& theCmd,
*/ */
//================================================================================ //================================================================================
void _pyGen::addFilterUser( Handle(_pyCommand)& theCommand, const Handle(_pyObject)& user ) // void _pyGen::addFilterUser( Handle(_pyCommand)& theCommand, const Handle(_pyObject)& user )
{ // {
const char filterPrefix[] = "aFilter0x"; // No more needed after adding _pyObject::myArgCommands
if ( theCommand->GetString().Search( filterPrefix ) < 1 )
return;
for ( int i = theCommand->GetNbArgs(); i > 0; --i ) // const char filterPrefix[] = "aFilter0x";
{ // if ( theCommand->GetString().Search( filterPrefix ) < 1 )
const _AString & arg = theCommand->GetArg( i ); // return;
// NOT TREATED CASE: arg == "[something, aFilter0x36a2f60]"
if ( arg.Search( filterPrefix ) != 1 )
continue;
Handle(_pyFilter) filter = Handle(_pyFilter)::DownCast( FindObject( arg )); // for ( int i = theCommand->GetNbArgs(); i > 0; --i )
if ( !filter.IsNull() ) // {
{ // const _AString & arg = theCommand->GetArg( i );
filter->AddUser( user ); // // NOT TREATED CASE: arg == "[something, aFilter0x36a2f60]"
if ( !filter->GetNewID().IsEmpty() ) // if ( arg.Search( filterPrefix ) != 1 )
theCommand->SetArg( i, filter->GetNewID() ); // continue;
}
} // Handle(_pyFilter) filter = Handle(_pyFilter)::DownCast( FindObject( arg ));
} // if ( !filter.IsNull() )
// {
// filter->AddUser( user );
// if ( !filter->GetNewID().IsEmpty() )
// theCommand->SetArg( i, filter->GetNewID() );
// }
// }
//}
//================================================================================ //================================================================================
/*! /*!
@ -1442,6 +1472,8 @@ void _pyGen::AddObject( Handle(_pyObject)& theObj )
{ {
if ( theObj.IsNull() ) return; if ( theObj.IsNull() ) return;
CheckObjectIsReCreated( theObj );
if ( theObj->IsKind( STANDARD_TYPE( _pyMesh ))) if ( theObj->IsKind( STANDARD_TYPE( _pyMesh )))
myMeshes.insert( make_pair( theObj->GetID(), Handle(_pyMesh)::DownCast( theObj ))); myMeshes.insert( make_pair( theObj->GetID(), Handle(_pyMesh)::DownCast( theObj )));
@ -1452,6 +1484,41 @@ void _pyGen::AddObject( Handle(_pyObject)& theObj )
myObjects.insert( make_pair( theObj->GetID(), theObj )); myObjects.insert( make_pair( theObj->GetID(), theObj ));
} }
//================================================================================
/*!
* \brief Erases an existing object with the same ID. This method should be called
* before storing theObj in _pyGen
*/
//================================================================================
void _pyGen::CheckObjectIsReCreated( Handle(_pyObject)& theObj )
{
if ( theObj.IsNull() || !_pyCommand::IsStudyEntry( theObj->GetID() ))
return;
const bool isHyp = theObj->IsKind( STANDARD_TYPE( _pyHypothesis ));
Handle(_pyObject) existing =
isHyp ? FindHyp( theObj->GetID() ) : FindObject( theObj->GetID() );
if ( !existing.IsNull() && existing != theObj )
{
existing->SetRemovedFromStudy( true );
existing->ClearCommands();
if ( isHyp )
{
if ( myHypos.count( theObj->GetID() ))
myHypos.erase( theObj->GetID() );
}
else if ( myMeshes.count( theObj->GetID() ))
{
myMeshes.erase( theObj->GetID() );
}
else if ( myObjects.count( theObj->GetID() ))
{
myObjects.erase( theObj->GetID() );
}
}
}
//================================================================================ //================================================================================
/*! /*!
* \brief Re-register an object with other ID to make it Process() commands of * \brief Re-register an object with other ID to make it Process() commands of
@ -4047,19 +4114,48 @@ _pyID _pyObject::FatherID(const _pyID & childID)
*/ */
//================================================================================ //================================================================================
_pySelfEraser::_pySelfEraser(const Handle(_pyCommand)& theCreationCmd)
:_pyObject(theCreationCmd), myIgnoreOwnCalls(false)
{
myIsPublished = true; // prevent clearing as a not published
theGen->KeepAgrCmds( GetID() ); // ask to fill myArgCmds
}
//================================================================================
/*!
* \brief SelfEraser erases creation command if no more it's commands invoked
*/
//================================================================================
void _pySelfEraser::Flush() void _pySelfEraser::Flush()
{ {
int nbCalls = GetNbCalls(); bool toErase = false;
if ( nbCalls > 0 ) if ( myIgnoreOwnCalls ) // check if this obj is used as argument
{ {
// ignore cleared commands int nbArgUses = 0;
std::list< Handle(_pyCommand) >& cmds = GetProcessedCmds(); list< Handle(_pyCommand) >::iterator cmd = myArgCmds.begin();
std::list< Handle(_pyCommand) >::const_iterator cmd = cmds.begin(); for ( ; cmd != myArgCmds.end(); ++cmd )
for ( ; cmd != cmds.end(); ++cmd ) nbArgUses += !(*cmd)->IsEmpty();
nbCalls -= (*cmd)->IsEmpty(); toErase = ( nbArgUses < 1 );
}
else
{
int nbCalls = GetNbCalls();
if ( nbCalls > 0 )
{
// ignore cleared commands
std::list< Handle(_pyCommand) >& cmds = GetProcessedCmds();
std::list< Handle(_pyCommand) >::const_iterator cmd = cmds.begin();
for ( ; cmd != cmds.end(); ++cmd )
nbCalls -= (*cmd)->IsEmpty();
}
toErase = ( nbCalls < 1 );
}
if ( toErase )
{
myIsPublished = false;
_pyObject::ClearCommands();
} }
if ( nbCalls < 1 )
GetCreationCmd()->Clear();
} }
//================================================================================ //================================================================================
@ -4072,6 +4168,7 @@ _pySubMesh::_pySubMesh(const Handle(_pyCommand)& theCreationCmd):
_pyObject(theCreationCmd) _pyObject(theCreationCmd)
{ {
myMesh = ObjectToMesh( theGen->FindObject( theCreationCmd->GetObject() )); myMesh = ObjectToMesh( theGen->FindObject( theCreationCmd->GetObject() ));
theGen->KeepAgrCmds( GetID() ); // ask to fill myArgCmds
} }
//================================================================================ //================================================================================
@ -4082,39 +4179,40 @@ _pySubMesh::_pySubMesh(const Handle(_pyCommand)& theCreationCmd):
bool _pySubMesh::CanBeArgOfMethod(const _AString& theMethodName) bool _pySubMesh::CanBeArgOfMethod(const _AString& theMethodName)
{ {
// names of all methods where a sub-mesh can be used as argument return false;
static TStringSet methods; // // names of all methods where a sub-mesh can be used as argument
if ( methods.empty() ) { // static TStringSet methods;
const char * names[] = { // if ( methods.empty() ) {
// methods of SMESH_Gen // const char * names[] = {
"CopyMesh", // // methods of SMESH_Gen
// methods of SMESH_Group // "CopyMesh",
"AddFrom", // // methods of SMESH_Group
// methods of SMESH_Measurements // "AddFrom",
"MinDistance", // // methods of SMESH_Measurements
// methods of SMESH_Mesh // "MinDistance",
"ExportPartToMED","ExportCGNS","ExportPartToDAT","ExportPartToUNV","ExportPartToSTL", // // methods of SMESH_Mesh
"RemoveSubMesh", // "ExportPartToMED","ExportCGNS","ExportPartToDAT","ExportPartToUNV","ExportPartToSTL",
// methods of SMESH_MeshEditor // "RemoveSubMesh",
"ReorientObject","Reorient2D","TriToQuadObject","QuadToTriObject","SplitQuadObject", // // methods of SMESH_MeshEditor
"SplitVolumesIntoTetra","SmoothObject","SmoothParametricObject","ConvertFromQuadraticObject", // "ReorientObject","Reorient2D","TriToQuadObject","QuadToTriObject","SplitQuadObject",
"RotationSweepObject","RotationSweepObjectMakeGroups","RotationSweepObject1D", // "SplitVolumesIntoTetra","SmoothObject","SmoothParametricObject","ConvertFromQuadraticObject",
"RotationSweepObject1DMakeGroups","RotationSweepObject2D","RotationSweepObject2DMakeGroups", // "RotationSweepObject","RotationSweepObjectMakeGroups","RotationSweepObject1D",
"ExtrusionSweepObject","ExtrusionSweepObjectMakeGroups","ExtrusionSweepObject0D", // "RotationSweepObject1DMakeGroups","RotationSweepObject2D","RotationSweepObject2DMakeGroups",
"ExtrusionSweepObject0DMakeGroups","ExtrusionSweepObject1D","ExtrusionSweepObject2D", // "ExtrusionSweepObject","ExtrusionSweepObjectMakeGroups","ExtrusionSweepObject0D",
"ExtrusionSweepObject1DMakeGroups","ExtrusionSweepObject2DMakeGroups", // "ExtrusionSweepObject0DMakeGroups","ExtrusionSweepObject1D","ExtrusionSweepObject2D",
"ExtrusionAlongPathObjX","ExtrusionAlongPathObject","ExtrusionAlongPathObjectMakeGroups", // "ExtrusionSweepObject1DMakeGroups","ExtrusionSweepObject2DMakeGroups",
"ExtrusionAlongPathObject1D","ExtrusionAlongPathObject1DMakeGroups", // "ExtrusionAlongPathObjX","ExtrusionAlongPathObject","ExtrusionAlongPathObjectMakeGroups",
"ExtrusionAlongPathObject2D","ExtrusionAlongPathObject2DMakeGroups","MirrorObject", // "ExtrusionAlongPathObject1D","ExtrusionAlongPathObject1DMakeGroups",
"MirrorObjectMakeGroups","MirrorObjectMakeMesh","TranslateObject","Scale", // "ExtrusionAlongPathObject2D","ExtrusionAlongPathObject2DMakeGroups","MirrorObject",
"TranslateObjectMakeGroups","TranslateObjectMakeMesh","ScaleMakeGroups","ScaleMakeMesh", // "MirrorObjectMakeGroups","MirrorObjectMakeMesh","TranslateObject","Scale",
"RotateObject","RotateObjectMakeGroups","RotateObjectMakeMesh","FindCoincidentNodesOnPart", // "TranslateObjectMakeGroups","TranslateObjectMakeMesh","ScaleMakeGroups","ScaleMakeMesh",
"FindCoincidentNodesOnPartBut","FindEqualElements","FindAmongElementsByPoint", // "RotateObject","RotateObjectMakeGroups","RotateObjectMakeMesh","FindCoincidentNodesOnPart",
"MakeBoundaryMesh","Create0DElementsOnAllNodes", // "FindCoincidentNodesOnPartBut","FindEqualElements","FindAmongElementsByPoint",
"" }; // <- mark of end // "MakeBoundaryMesh","Create0DElementsOnAllNodes",
methods.Insert( names ); // "" }; // <- mark of end
} // methods.Insert( names );
return methods.Contains( theMethodName ); // }
// return methods.Contains( theMethodName );
} }
//================================================================================ //================================================================================
@ -4126,7 +4224,6 @@ bool _pySubMesh::CanBeArgOfMethod(const _AString& theMethodName)
void _pySubMesh::Process( const Handle(_pyCommand)& theCommand ) void _pySubMesh::Process( const Handle(_pyCommand)& theCommand )
{ {
_pyObject::Process(theCommand); // count calls of Process() _pyObject::Process(theCommand); // count calls of Process()
GetCreationCmd()->AddDependantCmd( theCommand );
} }
//================================================================================ //================================================================================
@ -4137,11 +4234,17 @@ void _pySubMesh::Process( const Handle(_pyCommand)& theCommand )
void _pySubMesh::Flush() void _pySubMesh::Flush()
{ {
if ( GetNbCalls() == 0 ) // move to the end of all commands if ( GetNbCalls() == 0 && myArgCmds.empty() ) // move to the end of all commands
theGen->GetLastCommand()->AddDependantCmd( GetCreationCmd() ); theGen->GetLastCommand()->AddDependantCmd( GetCreationCmd() );
else if ( !myCreator.IsNull() ) else if ( !myCreator.IsNull() )
// move to be just after creator // move to be just after creator
myCreator->GetCreationCmd()->AddDependantCmd( GetCreationCmd() ); myCreator->GetCreationCmd()->AddDependantCmd( GetCreationCmd() );
// move sub-mesh usage after creation cmd
list< Handle(_pyCommand) >::iterator cmd = myArgCmds.begin();
for ( ; cmd != myArgCmds.end(); ++cmd )
if ( !(*cmd)->IsEmpty() )
GetCreationCmd()->AddDependantCmd( *cmd );
} }
//================================================================================ //================================================================================
@ -4196,7 +4299,7 @@ _pyGroup::_pyGroup(const Handle(_pyCommand)& theCreationCmd, const _pyID & id)
{ {
if ( !filter->GetNewID().IsEmpty() ) if ( !filter->GetNewID().IsEmpty() )
theCreationCmd->SetArg( 3, filter->GetNewID() ); theCreationCmd->SetArg( 3, filter->GetNewID() );
filter->AddUser( this ); //filter->AddUser( this );
} }
myFilter = filter; myFilter = filter;
} }
@ -4334,8 +4437,8 @@ void _pyGroup::Process( const Handle(_pyCommand)& theCommand)
} }
} }
if ( !filter.IsNull() ) // if ( !filter.IsNull() )
filter->AddUser( this ); // filter->AddUser( this );
theGen->AddMeshAccessorMethod( theCommand ); theGen->AddMeshAccessorMethod( theCommand );
} }
@ -4364,6 +4467,7 @@ void _pyGroup::Flush()
_pyFilter::_pyFilter(const Handle(_pyCommand)& theCreationCmd, const _pyID& newID/*=""*/) _pyFilter::_pyFilter(const Handle(_pyCommand)& theCreationCmd, const _pyID& newID/*=""*/)
:_pyObject(theCreationCmd), myNewID( newID ) :_pyObject(theCreationCmd), myNewID( newID )
{ {
theGen->KeepAgrCmds( GetID() ); // ask to fill myArgCmds
} }
//================================================================================ //================================================================================
@ -4411,13 +4515,31 @@ void _pyFilter::Process( const Handle(_pyCommand)& theCommand)
//================================================================================ //================================================================================
/*! /*!
* \brief Set new filter name to the creation command * \brief Set new filter name to the creation command and to myArgCmds
*/ */
//================================================================================ //================================================================================
void _pyFilter::Flush() void _pyFilter::Flush()
{ {
if ( !myNewID.IsEmpty() && !GetCreationCmd()->IsEmpty() ) if ( myNewID.IsEmpty() ) return;
list< Handle(_pyCommand) >::iterator cmd = myArgCmds.begin();
for ( ; cmd != myArgCmds.end(); ++cmd )
if ( !(*cmd)->IsEmpty() )
{
_AString cmdStr = (*cmd)->GetString();
_AString id = GetID();
int pos = cmdStr.Search( id );
if ( pos > 0 )
{
cmdStr.Remove( pos, id.Length() );
cmdStr.Insert( pos, myNewID );
}
(*cmd)->Clear();
(*cmd)->GetString() = cmdStr;
}
if ( !GetCreationCmd()->IsEmpty() )
GetCreationCmd()->SetResultValue( myNewID ); GetCreationCmd()->SetResultValue( myNewID );
} }
@ -4427,12 +4549,19 @@ void _pyFilter::Flush()
*/ */
//================================================================================ //================================================================================
bool _pyFilter::CanClear() bool _pyObject::CanClear()
{ {
list< Handle(_pyObject) >::iterator obj = myUsers.begin(); if ( !myIsPublished )
for ( ; obj != myUsers.end(); ++obj ) return true;
if ( !(*obj)->CanClear() )
return false; list< Handle(_pyCommand) >::iterator cmd = myArgCmds.begin();
for ( ; cmd != myArgCmds.end(); ++cmd )
if ( !(*cmd)->IsEmpty() )
{
Handle(_pyObject) obj = theGen->FindObject( (*cmd)->GetObject() );
if ( !obj.IsNull() && !obj->CanClear() )
return false;
}
return true; return true;
} }

28
src/SMESH_I/SMESH_2smeshpy.hxx
View File

@ -166,6 +166,7 @@ protected:
_pyID myID; _pyID myID;
Handle(_pyCommand) myCreationCmd; Handle(_pyCommand) myCreationCmd;
std::list< Handle(_pyCommand) > myProcessedCmds; std::list< Handle(_pyCommand) > myProcessedCmds;
std::list< Handle(_pyCommand) > myArgCmds; // where this obj is used as an argument
bool myIsPublished; bool myIsPublished;
void setID(const _pyID& theID); void setID(const _pyID& theID);
@ -182,10 +183,11 @@ public:
void AddProcessedCmd( const Handle(_pyCommand) & cmd ) void AddProcessedCmd( const Handle(_pyCommand) & cmd )
{ if (myProcessedCmds.empty() || myProcessedCmds.back()!=cmd) myProcessedCmds.push_back( cmd );} { if (myProcessedCmds.empty() || myProcessedCmds.back()!=cmd) myProcessedCmds.push_back( cmd );}
std::list< Handle(_pyCommand) >& GetProcessedCmds() { return myProcessedCmds; } std::list< Handle(_pyCommand) >& GetProcessedCmds() { return myProcessedCmds; }
void AddArgCmd( const Handle(_pyCommand) & cmd ) { myArgCmds.push_back( cmd ); }
virtual void Process(const Handle(_pyCommand) & cmd) { AddProcessedCmd(cmd); } virtual void Process(const Handle(_pyCommand) & cmd) { AddProcessedCmd(cmd); }
virtual void Flush() = 0; virtual void Flush() = 0;
virtual const char* AccessorMethod() const; virtual const char* AccessorMethod() const;
virtual bool CanClear() { return !myIsPublished; } virtual bool CanClear();
virtual void ClearCommands(); virtual void ClearCommands();
virtual void Free() {} virtual void Free() {}
@ -228,14 +230,15 @@ public:
const bool theToKeepAllCommands); const bool theToKeepAllCommands);
Handle(_pyCommand) AddCommand( const _AString& theCommand ); Handle(_pyCommand) AddCommand( const _AString& theCommand );
void ExchangeCommands( Handle(_pyCommand) theCmd1, Handle(_pyCommand) theCmd2 ); void ExchangeCommands( Handle(_pyCommand) theCmd1, Handle(_pyCommand) theCmd2 );
void SetCommandAfter( Handle(_pyCommand) theCmd, Handle(_pyCommand) theAfterCmd ); void SetCommandAfter ( Handle(_pyCommand) theCmd, Handle(_pyCommand) theAfterCmd );
void SetCommandBefore( Handle(_pyCommand) theCmd, Handle(_pyCommand) theBeforeCmd ); void SetCommandBefore( Handle(_pyCommand) theCmd, Handle(_pyCommand) theBeforeCmd );
Handle(_pyCommand)& GetLastCommand(); Handle(_pyCommand)& GetLastCommand();
std::list< Handle(_pyCommand) >& GetCommands() { return myCommands; } std::list< Handle(_pyCommand) >& GetCommands() { return myCommands; }
void PlaceSubmeshAfterItsCreation( Handle(_pyCommand) theCmdUsingSubmesh ) const; void PlaceSubmeshAfterItsCreation( Handle(_pyCommand) theCmdUsingSubmesh ) const;
_pyID GenerateNewID( const _pyID& theID ); _pyID GenerateNewID( const _pyID& theID );
void AddObject( Handle(_pyObject)& theObj ); void AddObject( Handle(_pyObject)& theObj );
void CheckObjectIsReCreated( Handle(_pyObject)& theObj );
void SetProxyObject( const _pyID& theID, Handle(_pyObject)& theObj ); void SetProxyObject( const _pyID& theID, Handle(_pyObject)& theObj );
Handle(_pyObject) FindObject( const _pyID& theObjID ) const; Handle(_pyObject) FindObject( const _pyID& theObjID ) const;
Handle(_pySubMesh) FindSubMesh( const _pyID& theSubMeshID ); Handle(_pySubMesh) FindSubMesh( const _pyID& theSubMeshID );
@ -251,6 +254,7 @@ public:
bool IsGeomObject(const _pyID& theObjID) const; bool IsGeomObject(const _pyID& theObjID) const;
bool IsNotPublished(const _pyID& theObjID) const; bool IsNotPublished(const _pyID& theObjID) const;
void ObjectCreationRemoved(const _pyID& theObjID); void ObjectCreationRemoved(const _pyID& theObjID);
void KeepAgrCmds(const _pyID& theObjID) { myKeepAgrCmdsIDs.push_back( theObjID ); }
bool IsToKeepAllCommands() const { return myToKeepAllCommands; } bool IsToKeepAllCommands() const { return myToKeepAllCommands; }
void AddExportedMesh(const _AString& file, const ExportedMeshData& mesh ) void AddExportedMesh(const _AString& file, const ExportedMeshData& mesh )
{ myFile2ExportedMesh[ file ] = mesh; } { myFile2ExportedMesh[ file ] = mesh; }
@ -268,13 +272,14 @@ private:
void setNeighbourCommand( Handle(_pyCommand)& theCmd, void setNeighbourCommand( Handle(_pyCommand)& theCmd,
Handle(_pyCommand)& theOtherCmd, Handle(_pyCommand)& theOtherCmd,
const bool theIsAfter ); const bool theIsAfter );
void addFilterUser( Handle(_pyCommand)& theCmd, const Handle(_pyObject)& user ); //void addFilterUser( Handle(_pyCommand)& theCmd, const Handle(_pyObject)& user );
private: private:
std::map< _pyID, Handle(_pyMesh) > myMeshes; std::map< _pyID, Handle(_pyMesh) > myMeshes;
std::map< _pyID, Handle(_pyMeshEditor) > myMeshEditors; std::map< _pyID, Handle(_pyMeshEditor) > myMeshEditors;
std::map< _pyID, Handle(_pyObject) > myObjects; std::map< _pyID, Handle(_pyObject) > myObjects;
std::list< Handle(_pyHypothesis) > myHypos; std::map< _pyID, Handle(_pyHypothesis) > myHypos;
std::list< _pyID > myKeepAgrCmdsIDs;
std::list< Handle(_pyCommand) > myCommands; std::list< Handle(_pyCommand) > myCommands;
int myNbCommands; int myNbCommands;
Resource_DataMapOfAsciiStringAsciiString& myID2AccessorMethod; Resource_DataMapOfAsciiStringAsciiString& myID2AccessorMethod;
@ -530,9 +535,10 @@ DEFINE_STANDARD_HANDLE (_pySegmentLengthAroundVertexHyp, _pyHypothesis);
// ------------------------------------------------------------------------------------- // -------------------------------------------------------------------------------------
class _pySelfEraser: public _pyObject class _pySelfEraser: public _pyObject
{ {
bool myIgnoreOwnCalls; // not to erase only if this obj is used as argument
public: public:
_pySelfEraser(const Handle(_pyCommand)& theCreationCmd) _pySelfEraser(const Handle(_pyCommand)& theCreationCmd);
:_pyObject(theCreationCmd) { myIsPublished = true; } void IgnoreOwnCalls() { myIgnoreOwnCalls = true; }
virtual void Flush(); virtual void Flush();
DEFINE_STANDARD_RTTI (_pySelfEraser) DEFINE_STANDARD_RTTI (_pySelfEraser)
@ -567,14 +573,14 @@ public:
class _pyFilter: public _pyObject class _pyFilter: public _pyObject
{ {
_pyID myNewID, myMesh; _pyID myNewID, myMesh;
std::list< Handle(_pyObject) > myUsers; //std::list< Handle(_pyObject) > myUsers;
public: public:
_pyFilter(const Handle(_pyCommand)& theCreationCmd, const _pyID& newID=""); _pyFilter(const Handle(_pyCommand)& theCreationCmd, const _pyID& newID="");
void AddUser( const Handle(_pyObject)& user) { myUsers.push_back( user ); } //void AddUser( const Handle(_pyObject)& user) { myUsers.push_back( user ); }
virtual void Process( const Handle(_pyCommand)& theCommand); virtual void Process( const Handle(_pyCommand)& theCommand);
virtual void Flush(); virtual void Flush();
virtual bool CanClear(); //virtual bool CanClear();
virtual void Free() { myUsers.clear(); } //virtual void Free() { myUsers.clear(); }
const _pyID& GetNewID() const { return myNewID; } const _pyID& GetNewID() const { return myNewID; }
DEFINE_STANDARD_RTTI (_pyFilter) DEFINE_STANDARD_RTTI (_pyFilter)