-// 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_I : idl implementation based on 'SMESH' unit's calsses
-//
// File : SMESH_2smeshpy.cxx
// Created : Fri Nov 18 13:20:10 2005
// Author : Edward AGAPOV (eap)
// 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();
Handle(_pySubMesh) subMesh = new _pySubMesh( aCommand );
myObjects.insert( make_pair( subMeshID, subMesh ));
}
+
id_mesh->second->Process( aCommand );
return aCommand;
}
// 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()
+ else if ( method == "ExportToMED" || // ExportToMED() --> ExportMED()
+ method == "ExportToMEDX" ) { // ExportToMEDX() --> ExportMED()
theCommand->SetMethod( "ExportMED" );
}
// ----------------------------------------------------------------------
// remove hyp from myHypos
myHypos.remove( hyp );
}
+ // check for SubMesh order commands
+ else if ( theCommand->GetMethod() == "GetMeshOrder" ||
+ theCommand->GetMethod() == "SetMeshOrder" ) {
+ // In fact arguments and result values does not support complex containers
+ // such as list of list
+ // So, here we parse it manually
+ // GetMeshOrder
+ //for(int ind = 0, n = theCommand->GetNbResultValues();ind<n;ind++) {
+ // Handle(_pySubMesh) subMesh = theGen->FindSubMesh( theCommand->GetResultValue(ind) );
+ // SetMeshOrder
+ //for(int ind = 0, n = theCommand->GetNbArgs();ind<n;ind++) {
+ // Handle(_pySubMesh) subMesh = theGen->FindSubMesh( theCommand->GetArg(ind) );
+ const bool isArg = theCommand->GetMethod() == "SetMeshOrder";
+ const TCollection_AsciiString& cmdStr = theCommand->GetString();
+ int begPos = (/*isArg ? cmdStr.Search( "(" ) :*/ cmdStr.Search( "[" )) + 1;
+ int endPos = (isArg ? cmdStr.Search( ")" ) : cmdStr.Search( "=" )) - 1;
+ if ( begPos != -1 && begPos < endPos && endPos <= cmdStr.Length() ) {
+ TCollection_AsciiString aSubStr = cmdStr.SubString( begPos, endPos );
+ Standard_Integer index = 1;
+ TCollection_AsciiString anIDStr = aSubStr.Token("\t ,[]", index++);
+ while ( !anIDStr.IsEmpty() ) {
+ Handle(_pySubMesh) subMesh = theGen->FindSubMesh( anIDStr );
+ if ( !subMesh.IsNull() )
+ subMesh->Process( theCommand );
+ anIDStr = aSubStr.Token("\t ,[]", index++);
+ }
+ }
+ }
// add accessor method if necessary
else
{
"GetNodeInverseElements","GetShapeID","GetShapeIDForElem","GetElemNbNodes",
"GetElemNode","IsMediumNode","IsMediumNodeOfAnyElem","ElemNbEdges","ElemNbFaces",
"IsPoly","IsQuadratic","BaryCenter","GetHypothesisList", "SetAutoColor", "GetAutoColor",
- "Clear", "ConvertToStandalone"
+ "Clear", "ConvertToStandalone", "GetMeshOrder", "SetMeshOrder"
,"" }; // <- mark of end
sameMethods.Insert( names );
}
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();
}
}
}
else if ( hypType == "TrianglePreference" ) {
hyp->SetConvMethodAndType( "TrianglePreference", "Quadrangle_2D");
}
+ // RadialQuadrangle_1D2D ----------
+ else if ( hypType == "RadialQuadrangle_1D2D" ) {
+ algo->SetConvMethodAndType( "Quadrangle" , hypType.ToCString());
+ algo->myArgs.Append( "algo=smesh.RADIAL_QUAD" );
+ }
+ else if ( hypType == "NumberOfLayers2D" ) {
+ hyp->SetConvMethodAndType( "NumberOfLayers", "RadialQuadrangle_1D2D");
+ hyp->AddArgMethod( "SetNumberOfLayers" );
+ }
+ else if ( hypType == "LayerDistribution2D" ) {
+ hyp = new _pyLayerDistributionHypo( theCreationCmd, "Get2DHypothesis" );
+ hyp->SetConvMethodAndType( "LayerDistribution", "RadialQuadrangle_1D2D");
+ }
// BLSURF ----------
else if ( hypType == "BLSURF" ) {
algo->SetConvMethodAndType( "Triangle", hypType.ToCString());
hyp->AddArgMethod( "SetNumberOfLayers" );
}
else if ( hypType == "LayerDistribution" ) {
- hyp = new _pyLayerDistributionHypo( theCreationCmd );
+ hyp = new _pyLayerDistributionHypo( theCreationCmd, "Get3DHypothesis" );
hyp->SetConvMethodAndType( "LayerDistribution", "RadialPrism_3D");
}
- if ( algo->IsValid() ) {
- return algo;
- }
- return hyp;
+ return algo->IsValid() ? algo : hyp;
}
//================================================================================
my1dHyp->ClearAllCommands();
}
my1dHyp = hyp1d;
- if ( my1dHyp.IsNull() )
- return; // something wrong :(
-
- // make a new name for 1D hyp = "HypType" + "_Distribution"
- if ( my1dHyp->GetCreationCmd()->GetMethod() == "CreateHypothesis" ) {
- // not yet converted creation cmd
- TCollection_AsciiString hypTypeQuoted = my1dHyp->GetCreationCmd()->GetArg(1);
- TCollection_AsciiString hypType = hypTypeQuoted.SubString( 2, hypTypeQuoted.Length() - 1 );
- newName = hypType + "_Distribution";
- my1dHyp->GetCreationCmd()->SetResultValue( newName );
- }
- else {
- // already converted creation cmd
- newName = my1dHyp->GetCreationCmd()->GetResultValue();
- }
- // as creation of 1D hyp was written later then it's edition,
- // we need to find all it's edition calls and process them
- list< Handle(_pyCommand) >& cmds = theGen->GetCommands();
- list< Handle(_pyCommand) >::iterator cmdIt = cmds.begin();
- for ( ; cmdIt != cmds.end(); ++cmdIt ) {
- const _pyID& objID = (*cmdIt)->GetObject();
- if ( objID == hyp1dID ) {
- my1dHyp->Process( *cmdIt );
- my1dHyp->GetCreationCmd()->AddDependantCmd( *cmdIt );
- ( *cmdIt )->SetObject( newName );
- }
- }
if ( !myArgCommands.empty() )
myArgCommands.front()->Clear();
- theCommand->SetArg( 1, newName );
myArgCommands.push_back( theCommand );
- // copy hyp1d's creation method and args
-// myCreationMethod = hyp1d->GetCreationMethod();
-// myArgs = hyp1d->GetArgs();
-// // make them cleared at conversion
-// myArgCommands = hyp1d->GetArgCommands();
-
-// // to be cleared at convertion only
-// myArgCommands.push_back( theCommand );
}
//================================================================================
_pyID geom = theAdditionCmd->GetArg( 1 );
- my1dHyp->SetMesh( theMesh );
- if ( !my1dHyp->Addition2Creation( theAdditionCmd, theMesh ))
- return false;
+ Handle(_pyHypothesis) algo = theGen->FindAlgo( geom, theMesh, this );
+ if ( !algo.IsNull() )
+ {
+ my1dHyp->SetMesh( theMesh );
+ my1dHyp->SetConvMethodAndType(my1dHyp->GetAlgoCreationMethod().ToCString(),
+ algo->GetAlgoType().ToCString());
+ if ( !my1dHyp->Addition2Creation( theAdditionCmd, theMesh ))
+ return false;
- // clear "SetLayerDistribution()" cmd
- myArgCommands.front()->Clear();
+ // clear "SetLayerDistribution()" cmd
+ myArgCommands.back()->Clear();
- // Convert my creation => me = RadialPrismAlgo.Get3DHypothesis()
+ // Convert my creation => me = RadialPrismAlgo.Get3DHypothesis()
- // find RadialPrism algo created on <geom> for theMesh
- Handle(_pyHypothesis) algo = theGen->FindAlgo( geom, theMesh, this );
- if ( !algo.IsNull() ) {
+ // find RadialPrism algo created on <geom> for theMesh
GetCreationCmd()->SetObject( algo->GetID() );
- GetCreationCmd()->SetMethod( "Get3DHypothesis" );
+ GetCreationCmd()->SetMethod( myAlgoMethod );
GetCreationCmd()->RemoveArgs();
theAdditionCmd->AddDependantCmd( GetCreationCmd() );
myIsWrapped = true;
void _pyLayerDistributionHypo::Flush()
{
- //my1dHyp.Nullify();
- //_pyHypothesis::Flush();
+ // as creation of 1D hyp was written later then it's edition,
+ // we need to find all it's edition calls and process them
+ if ( !my1dHyp.IsNull() )
+ {
+ _pyID hyp1dID = my1dHyp->GetCreationCmd()->GetResultValue();
+
+ // make a new name for 1D hyp = "HypType" + "_Distribution"
+ _pyID newName;
+ if ( my1dHyp->IsWrapped() ) {
+ newName = my1dHyp->GetCreationCmd()->GetMethod();
+ }
+ else {
+ TCollection_AsciiString hypTypeQuoted = my1dHyp->GetCreationCmd()->GetArg(1);
+ newName = hypTypeQuoted.SubString( 2, hypTypeQuoted.Length() - 1 );
+ }
+ newName += "_Distribution";
+ my1dHyp->GetCreationCmd()->SetResultValue( newName );
+
+ list< Handle(_pyCommand) >& cmds = theGen->GetCommands();
+ list< Handle(_pyCommand) >::iterator cmdIt = cmds.begin();
+ for ( ; cmdIt != cmds.end(); ++cmdIt ) {
+ const _pyID& objID = (*cmdIt)->GetObject();
+ if ( objID == hyp1dID ) {
+ my1dHyp->Process( *cmdIt );
+ my1dHyp->GetCreationCmd()->AddDependantCmd( *cmdIt );
+ ( *cmdIt )->SetObject( newName );
+ }
+ }
+ // Set new hyp name to SetLayerDistribution() cmd
+ if ( !myArgCommands.empty() && !myArgCommands.back()->IsEmpty() )
+ myArgCommands.back()->SetArg( 1, newName );
+ }
}
//================================================================================