// SMESH_Mesh method?
map< _pyID, Handle(_pyMesh) >::iterator id_mesh = myMeshes.find( objID );
- if ( id_mesh != myMeshes.end() ) {
+ if ( id_mesh != myMeshes.end() )
+ {
// check for mesh editor object
if ( aCommand->GetMethod() == "GetMeshEditor" ) { // MeshEditor creation
_pyID editorID = aCommand->GetResultValue();
// SMESH_MeshEditor method?
map< _pyID, Handle(_pyMeshEditor) >::iterator id_editor = myMeshEditors.find( objID );
- if ( id_editor != myMeshEditors.end() ) {
+ if ( id_editor != myMeshEditors.end() )
+ {
id_editor->second->Process( aCommand );
TCollection_AsciiString processedCommand = aCommand->GetString();
// some commands of SMESH_MeshEditor create meshes
aCommand->GetString() = processedCommand; // discard changes made by _pyMesh
myMeshes.insert( make_pair( mesh->GetID(), mesh ));
}
+ if ( aCommand->GetMethod() == "MakeBoundaryMesh") {
+ _pyID meshID = aCommand->GetResultValue(0);
+ if ( !myMeshes.count( meshID ) )
+ {
+ Handle(_pyMesh) mesh = new _pyMesh( aCommand, meshID );
+ aCommand->GetString() = processedCommand; // discard changes made by _pyMesh
+ myMeshes.insert( make_pair( meshID, mesh ));
+ }
+ }
return aCommand;
}
// SMESH_Hypothesis method?
// Concatenate( [mesh1, ...], ... )
// CreateHypothesis( theHypType, theLibName )
// Compute( mesh, geom )
+ // Evaluate( mesh, geom )
// mesh creation
TCollection_AsciiString method = theCommand->GetMethod();
myMeshes.insert( make_pair( mesh->GetID(), mesh ));
return;
}
- if ( method == "CreateMeshesFromUNV" || method == "CreateMeshesFromSTL")
+ if ( method == "CreateMeshesFromUNV" || method == "CreateMeshesFromSTL" || method == "CopyMesh" )
{
Handle(_pyMesh) mesh = new _pyMesh( theCommand, theCommand->GetResultValue() );
myMeshes.insert( make_pair( mesh->GetID(), mesh ));
}
}
+ // smeshgen.Evaluate( mesh, geom ) --> mesh.Evaluate(geom)
+ if ( method == "Evaluate" )
+ {
+ const _pyID& meshID = theCommand->GetArg( 1 );
+ map< _pyID, Handle(_pyMesh) >::iterator id_mesh = myMeshes.find( meshID );
+ if ( id_mesh != myMeshes.end() ) {
+ theCommand->SetObject( meshID );
+ _pyID geom = theCommand->GetArg( 2 );
+ theCommand->RemoveArgs();
+ theCommand->SetArg( 1, geom );
+ return;
+ }
+ }
+
// objects erasing creation command if no more it's commands invoked:
// SMESH_Pattern, FilterManager
if ( method == "GetPattern" || method == "CreateFilterManager" ) {
// ----------------------------------------------------------------------
else if ( method == "CreateGroupFromGEOM" ) {// (type, name, grp)
_pyID grp = theCommand->GetArg( 3 );
- if ( sameGroupType( grp, theCommand->GetArg( 1 )) ) { // --> Group(grp)
- theCommand->SetMethod( "Group" );
- theCommand->RemoveArgs();
- theCommand->SetArg( 1, grp );
- }
- else {
+ // VSR 24/12/2010. PAL21106: always use GroupOnGeom() function on dump
+ // next if(){...} section is commented
+ //if ( sameGroupType( grp, theCommand->GetArg( 1 )) ) { // --> Group(grp)
+ // theCommand->SetMethod( "Group" );
+ // theCommand->RemoveArgs();
+ // theCommand->SetArg( 1, grp );
+ //}
+ //else {
_pyID type = theCommand->GetArg( 1 );
_pyID name = theCommand->GetArg( 2 );
theCommand->SetMethod( "GroupOnGeom" );
theCommand->SetArg( 1, grp );
theCommand->SetArg( 2, name );
theCommand->SetArg( 3, type );
- }
+ //}
}
// ----------------------------------------------------------------------
else if ( method == "ExportToMED" || // ExportToMED() --> ExportMED()
void _pyMeshEditor::Process( const Handle(_pyCommand)& theCommand)
{
- // names of SMESH_MeshEditor methods fully equal to methods of class Mesh, so
+ // names of SMESH_MeshEditor methods fully equal to methods of python class Mesh, so
// commands calling this methods are converted to calls of methods of Mesh
static TStringSet sameMethods;
if ( sameMethods.empty() ) {
const char * names[] = {
- "RemoveElements","RemoveNodes","AddNode","Add0DElement","AddEdge","AddFace","AddPolygonalFace",
+ "RemoveElements","RemoveNodes","RemoveOrphanNodes","AddNode","Add0DElement","AddEdge","AddFace","AddPolygonalFace",
"AddVolume","AddPolyhedralVolume","AddPolyhedralVolumeByFaces","MoveNode", "MoveClosestNodeToPoint",
"InverseDiag","DeleteDiag","Reorient","ReorientObject","TriToQuad","SplitQuad","SplitQuadObject",
"BestSplit","Smooth","SmoothObject","SmoothParametric","SmoothParametricObject",
"ConvertToQuadratic","ConvertFromQuadratic","RenumberNodes","RenumberElements",
"RotationSweep","RotationSweepObject","RotationSweepObject1D","RotationSweepObject2D",
"ExtrusionSweep","AdvancedExtrusion","ExtrusionSweepObject","ExtrusionSweepObject1D","ExtrusionSweepObject2D",
- "ExtrusionAlongPath","ExtrusionAlongPathObject","ExtrusionAlongPathObject1D","ExtrusionAlongPathObject2D",
+ "ExtrusionAlongPath","ExtrusionAlongPathObject","ExtrusionAlongPathX",
+ "ExtrusionAlongPathObject1D","ExtrusionAlongPathObject2D",
"Mirror","MirrorObject","Translate","TranslateObject","Rotate","RotateObject",
- "FindCoincidentNodes","FindCoincidentNodesOnPart","MergeNodes","FindEqualElements",
+ "FindCoincidentNodes",/*"FindCoincidentNodesOnPart",*/"MergeNodes","FindEqualElements",
"MergeElements","MergeEqualElements","SewFreeBorders","SewConformFreeBorders",
"SewBorderToSide","SewSideElements","ChangeElemNodes","GetLastCreatedNodes",
"GetLastCreatedElems",
"MirrorMakeMesh","MirrorObjectMakeMesh","TranslateMakeMesh",
- "TranslateObjectMakeMesh","RotateMakeMesh","RotateObjectMakeMesh"
+ "TranslateObjectMakeMesh","RotateMakeMesh","RotateObjectMakeMesh","MakeBoundaryMesh"
,"" }; // <- mark of the end
sameMethods.Insert( names );
}
// names of SMESH_MeshEditor methods which differ from methods of class Mesh
- // only last two arguments
+ // only by last two arguments
static TStringSet diffLastTwoArgsMethods;
- if (diffLastTwoArgsMethods.empty() ){
+ if (diffLastTwoArgsMethods.empty() ) {
const char * names[] = {
"MirrorMakeGroups","MirrorObjectMakeGroups",
"TranslateMakeGroups","TranslateObjectMakeGroups",
diffLastTwoArgsMethods.Insert( names );
}
- if ( sameMethods.Contains( theCommand->GetMethod() )) {
- theCommand->SetObject( myMesh );
-
- // meshes made by *MakeMesh() methods are not wrapped by _pyMesh,
- // so let _pyMesh care of it (TMP?)
-// if ( theCommand->GetMethod().Search("MakeMesh") != -1 )
-// _pyMesh( new _pyCommand( theCommand->GetString(), 0 )); // for theGen->SetAccessorMethod()
- }
- else {
-
+ const TCollection_AsciiString & method = theCommand->GetMethod();
+ bool isPyMeshMethod = sameMethods.Contains( method );
+ if ( !isPyMeshMethod )
+ {
//Replace SMESH_MeshEditor "MakeGroups" functions on the Mesh
//functions with the flag "theMakeGroups = True" like:
//SMESH_MeshEditor.CmdMakeGroups => Mesh.Cmd(...,True)
- int pos = theCommand->GetMethod().Search("MakeGroups");
- if( pos != -1) {
+ int pos = method.Search("MakeGroups");
+ if( pos != -1)
+ {
+ isPyMeshMethod = true;
+
// 1. Remove "MakeGroups" from the Command
TCollection_AsciiString aMethod = theCommand->GetMethod();
int nbArgsToAdd = diffLastTwoArgsMethods.Contains(aMethod) ? 2 : 1;
aMethod.Trunc(pos-1);
theCommand->SetMethod(aMethod);
- // 2. Set Mesh object instead of SMESH_MeshEditor
- theCommand->SetObject( myMesh );
-
- // 3. And add last "True" argument
+ // 2. And add last "True" argument(s)
while(nbArgsToAdd--)
- theCommand->SetArg(theCommand->GetNbArgs()+1,"True ");
+ theCommand->SetArg(theCommand->GetNbArgs()+1,"True");
}
- else {
- // editor creation command is needed only if any editor function is called
- theGen->AddMeshAccessorMethod( theCommand ); // for *Object()
- if ( !myCreationCmdStr.IsEmpty() ) {
- GetCreationCmd()->GetString() = myCreationCmdStr;
- myCreationCmdStr.Clear();
- }
+ }
+
+ // set "ExtrusionAlongPathX()" instead of "ExtrusionAlongPathObjX()"
+ if ( !isPyMeshMethod && method == "ExtrusionAlongPathObjX")
+ {
+ isPyMeshMethod=true;
+ theCommand->SetMethod("ExtrusionAlongPathX");
+ }
+
+ // set "FindCoincidentNodesOnPart()" instead of "FindCoincidentNodesOnPartBut()"
+ if ( !isPyMeshMethod && method == "FindCoincidentNodesOnPartBut")
+ {
+ isPyMeshMethod=true;
+ theCommand->SetMethod("FindCoincidentNodesOnPart");
+ }
+ // DoubleNodeElemGroupNew() -> DoubleNodeElemGroup()
+ // DoubleNodeGroupNew() -> DoubleNodeGroup()
+ // DoubleNodeGroupsNew() -> DoubleNodeGroups()
+ // DoubleNodeElemGroupsNew() -> DoubleNodeElemGroups()
+ if ( !isPyMeshMethod && ( method == "DoubleNodeElemGroupNew" || method == "DoubleNodeElemGroupsNew" ||
+ method == "DoubleNodeGroupNew" || method == "DoubleNodeGroupsNew"))
+ {
+ isPyMeshMethod=true;
+ theCommand->SetMethod( method.SubString( 1, method.Length()-3));
+ theCommand->SetArg(theCommand->GetNbArgs()+1,"True");
+ }
+
+ // meshes made by *MakeMesh() methods are not wrapped by _pyMesh,
+ // so let _pyMesh care of it (TMP?)
+ // if ( theCommand->GetMethod().Search("MakeMesh") != -1 )
+ // _pyMesh( new _pyCommand( theCommand->GetString(), 0 )); // for theGen->SetAccessorMethod()
+ if ( isPyMeshMethod )
+ {
+ theCommand->SetObject( myMesh );
+ }
+ else
+ {
+ // editor creation command is needed only if any editor function is called
+ theGen->AddMeshAccessorMethod( theCommand ); // for *Object()
+ if ( !myCreationCmdStr.IsEmpty() ) {
+ GetCreationCmd()->GetString() = myCreationCmdStr;
+ myCreationCmdStr.Clear();
}
}
}