-// SMESH SMESH_I : idl implementation based on 'SMESH' unit's calsses
+// Copyright (C) 2007-2008 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
+//
+// This library is free software; you can redistribute it and/or
+// modify it under the terms of the GNU Lesser General Public
+// License as published by the Free Software Foundation; either
+// version 2.1 of the License.
//
-// Copyright (C) 2003 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
-// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
-//
-// This library is free software; you can redistribute it and/or
-// modify it under the terms of the GNU Lesser General Public
-// License as published by the Free Software Foundation; either
-// version 2.1 of the License.
-//
-// This library is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
-// Lesser General Public License for more details.
-//
-// You should have received a copy of the GNU Lesser General Public
-// License along with this library; if not, write to the Free Software
-// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
-//
-// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+// Lesser General Public License for more details.
//
+// You should have received a copy of the GNU Lesser General Public
+// License along with this library; if not, write to the Free Software
+// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
//
+// 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_2D_Algo_i.hxx
// Author : Paul RASCLE, EDF
// Module : SMESH
// File : SMESH_2smeshpy.cxx
// Created : Fri Nov 18 13:20:10 2005
// Author : Edward AGAPOV (eap)
-
+//
#include "SMESH_2smeshpy.hxx"
#include "utilities.h"
IMPLEMENT_STANDARD_HANDLE (_pyCommand ,Standard_Transient);
IMPLEMENT_STANDARD_HANDLE (_pyGen ,_pyObject);
IMPLEMENT_STANDARD_HANDLE (_pyMesh ,_pyObject);
+IMPLEMENT_STANDARD_HANDLE (_pyMeshEditor ,_pyObject);
IMPLEMENT_STANDARD_HANDLE (_pyHypothesis ,_pyObject);
IMPLEMENT_STANDARD_HANDLE (_pyAlgorithm ,_pyHypothesis);
IMPLEMENT_STANDARD_HANDLE (_pyComplexParamHypo,_pyHypothesis);
IMPLEMENT_STANDARD_RTTIEXT(_pyCommand ,Standard_Transient);
IMPLEMENT_STANDARD_RTTIEXT(_pyGen ,_pyObject);
IMPLEMENT_STANDARD_RTTIEXT(_pyMesh ,_pyObject);
+IMPLEMENT_STANDARD_RTTIEXT(_pyMeshEditor ,_pyObject);
IMPLEMENT_STANDARD_RTTIEXT(_pyHypothesis ,_pyObject);
IMPLEMENT_STANDARD_RTTIEXT(_pyAlgorithm ,_pyHypothesis);
IMPLEMENT_STANDARD_RTTIEXT(_pyComplexParamHypo,_pyHypothesis);
IMPLEMENT_STANDARD_RTTIEXT(_pyNumberOfSegmentsHyp,_pyHypothesis);
IMPLEMENT_STANDARD_RTTIEXT(_pyLayerDistributionHypo,_pyHypothesis);
+IMPLEMENT_STANDARD_RTTIEXT(_pySegmentLengthAroundVertexHyp,_pyHypothesis);
using namespace std;
using SMESH::TPythonDump;
#undef DUMP_CONVERSION
#endif
+
+namespace {
+
+ //================================================================================
+ /*!
+ * \brief Set of TCollection_AsciiString initialized by C array of C strings
+ */
+ //================================================================================
+
+ struct TStringSet: public set<TCollection_AsciiString>
+ {
+ /*!
+ * \brief Filling. The last string must be ""
+ */
+ void Insert(const char* names[]) {
+ for ( int i = 0; names[i][0] ; ++i )
+ insert( (char*) names[i] );
+ }
+ /*!
+ * \brief Check if a string is in
+ */
+ bool Contains(const TCollection_AsciiString& name ) {
+ return find( name ) != end();
+ }
+ };
+}
+
//================================================================================
/*!
* \brief Convert python script using commands of smesh.py
* \param theScript - Input script
* \retval TCollection_AsciiString - Convertion result
+ *
+ * Class SMESH_2smeshpy declared in SMESH_PythonDump.hxx
*/
//================================================================================
// finish conversion
theGen->Flush();
#ifdef DUMP_CONVERSION
- cout << endl << " ######## RESULT ######## " << endl<< endl;
+ MESSAGE_BEGIN ( std::endl << " ######## RESULT ######## " << std::endl<< std::endl );
#endif
// reorder commands after conversion
list< Handle(_pyCommand) >::iterator cmd;
for ( cmd = theGen->GetCommands().begin(); cmd != theGen->GetCommands().end(); ++cmd )
{
#ifdef DUMP_CONVERSION
- cout << "## COM " << (*cmd)->GetOrderNb() << ": "<< (*cmd)->GetString() << endl;
+ MESSAGE_ADD ( "## COM " << (*cmd)->GetOrderNb() << ": "<< (*cmd)->GetString() << std::endl );
#endif
if ( !(*cmd)->IsEmpty() ) {
aScript += "\n";
GetCreationCmd()->GetString() += "=";
}
+//================================================================================
+/*!
+ * \brief name of SMESH_Gen in smesh.py
+ */
+//================================================================================
+
+const char* _pyGen::AccessorMethod() const
+{
+ return SMESH_2smeshpy::GenName();
+}
+
//================================================================================
/*!
* \brief Convert a command using a specific converter
*/
//================================================================================
-void _pyGen::AddCommand( const TCollection_AsciiString& theCommand)
+Handle(_pyCommand) _pyGen::AddCommand( const TCollection_AsciiString& theCommand)
{
// store theCommand in the sequence
myCommands.push_back( new _pyCommand( theCommand, ++myNbCommands ));
Handle(_pyCommand) aCommand = myCommands.back();
#ifdef DUMP_CONVERSION
- cout << "## COM " << myNbCommands << ": "<< aCommand->GetString() << endl;
+ MESSAGE ( "## COM " << myNbCommands << ": "<< aCommand->GetString() );
#endif
_pyID objID = aCommand->GetObject();
if ( objID.IsEmpty() )
- return;
+ return aCommand;
// SMESH_Gen method?
if ( objID == this->GetID() ) {
this->Process( aCommand );
- return;
+ return aCommand;
}
// SMESH_Mesh method?
map< _pyID, Handle(_pyMesh) >::iterator id_mesh = myMeshes.find( objID );
if ( id_mesh != myMeshes.end() ) {
+ if ( aCommand->GetMethod() == "GetMeshEditor" ) { // MeshEditor creation
+ _pyID editorID = aCommand->GetResultValue();
+ Handle(_pyMeshEditor) editor = new _pyMeshEditor( aCommand );
+ myMeshEditors.insert( make_pair( editorID, editor ));
+ return aCommand;
+ }
id_mesh->second->Process( aCommand );
- return;
+ return aCommand;
+ }
+ // SMESH_MeshEditor method?
+ map< _pyID, Handle(_pyMeshEditor) >::iterator id_editor = myMeshEditors.find( objID );
+ if ( id_editor != myMeshEditors.end() ) {
+ id_editor->second->Process( aCommand );
+ TCollection_AsciiString processedCommand = aCommand->GetString();
+ // some commands of SMESH_MeshEditor create meshes
+ if ( aCommand->GetMethod().Search("MakeMesh") != -1 ) {
+ Handle(_pyMesh) mesh = new _pyMesh( aCommand, aCommand->GetResultValue() );
+ aCommand->GetString() = processedCommand; // discard changes made by _pyMesh
+ myMeshes.insert( make_pair( mesh->GetID(), mesh ));
+ }
+ return aCommand;
}
// SMESH_Hypothesis method?
list< Handle(_pyHypothesis) >::iterator hyp = myHypos.begin();
for ( ; hyp != myHypos.end(); ++hyp )
if ( !(*hyp)->IsAlgo() && objID == (*hyp)->GetID() ) {
(*hyp)->Process( aCommand );
- return;
+ return aCommand;
}
// Add access to a wrapped mesh
AddMeshAccessorMethod( aCommand );
// Add access to a wrapped algorithm
- AddAlgoAccessorMethod( aCommand );
+ // AddAlgoAccessorMethod( aCommand ); // ??? what if algo won't be wrapped at all ???
// PAL12227. PythonDump was not updated at proper time; result is
// aCriteria.append(SMESH.Filter.Criterion(17,26,0,'L1',26,25,1e-07,SMESH.EDGE,-1))
aCommand->GetString() += tmpCmd.GetString();
}
}
+ return aCommand;
}
//================================================================================
{
// there are methods to convert:
// CreateMesh( shape )
+ // Concatenate( [mesh1, ...], ... )
// CreateHypothesis( theHypType, theLibName )
// Compute( mesh, geom )
-
- if ( theCommand->GetMethod() == "CreateMesh" )
+ // mesh creation
+ TCollection_AsciiString method = theCommand->GetMethod();
+ if ( method == "CreateMesh" || method == "CreateEmptyMesh")
{
Handle(_pyMesh) mesh = new _pyMesh( theCommand );
myMeshes.insert( make_pair( mesh->GetID(), mesh ));
return;
}
+ if ( method == "CreateMeshesFromUNV" || method == "CreateMeshesFromSTL")
+ {
+ Handle(_pyMesh) mesh = new _pyMesh( theCommand, theCommand->GetResultValue() );
+ myMeshes.insert( make_pair( mesh->GetID(), mesh ));
+ return;
+ }
+ if( method == "CreateMeshesFromMED")
+ {
+ for(int ind = 0;ind<theCommand->GetNbResultValues();ind++)
+ {
+ Handle(_pyMesh) mesh = new _pyMesh( theCommand, theCommand->GetResultValue(ind));
+ myMeshes.insert( make_pair( theCommand->GetResultValue(ind), mesh ));
+ }
+ }
// CreateHypothesis()
- if ( theCommand->GetMethod() == "CreateHypothesis" )
+ if ( method == "CreateHypothesis" )
{
myHypos.push_back( _pyHypothesis::NewHypothesis( theCommand ));
return;
}
// smeshgen.Compute( mesh, geom ) --> mesh.Compute()
- if ( theCommand->GetMethod() == "Compute" )
+ if ( method == "Compute" )
{
const _pyID& meshID = theCommand->GetArg( 1 );
map< _pyID, Handle(_pyMesh) >::iterator id_mesh = myMeshes.find( meshID );
}
// leave only one smeshgen.GetPattern() in the script
- if ( theCommand->GetMethod() == "GetPattern" ) {
+ if ( method == "GetPattern" ) {
if ( myHasPattern ) {
theCommand->Clear();
return;
myHasPattern = true;
}
- // smeshgen.Method() --> smesh.smesh.Method()
- theCommand->SetObject( SMESH_2smeshpy::GenName() );
+ // Concatenate( [mesh1, ...], ... )
+ if ( method == "Concatenate" || method == "ConcatenateWithGroups")
+ {
+ if ( method == "ConcatenateWithGroups" ) {
+ theCommand->SetMethod( "Concatenate" );
+ theCommand->SetArg( theCommand->GetNbArgs() + 1, "True" );
+ }
+ Handle(_pyMesh) mesh = new _pyMesh( theCommand, theCommand->GetResultValue() );
+ myMeshes.insert( make_pair( mesh->GetID(), mesh ));
+ AddMeshAccessorMethod( theCommand );
+ }
+
+ // Replace name of SMESH_Gen
+
+ // names of SMESH_Gen methods fully equal to methods defined in smesh.py
+ static TStringSet smeshpyMethods;
+ if ( smeshpyMethods.empty() ) {
+ const char * names[] =
+ { "SetEmbeddedMode","IsEmbeddedMode","SetCurrentStudy","GetCurrentStudy",
+ "GetPattern","GetSubShapesId",
+ "" }; // <- mark of array end
+ smeshpyMethods.Insert( names );
+ }
+ if ( smeshpyMethods.Contains( theCommand->GetMethod() ))
+ // smeshgen.Method() --> smesh.Method()
+ theCommand->SetObject( SMESH_2smeshpy::SmeshpyName() );
+ else
+ // smeshgen.Method() --> smesh.smesh.Method()
+ theCommand->SetObject( SMESH_2smeshpy::GenName() );
}
//================================================================================
//================================================================================
/*!
- * \brief Add access method to mesh that is object or arg
+ * \brief Add access method to mesh that is an argument
* \param theCmd - command to add access method
* \retval bool - true if added
*/
bool _pyGen::AddMeshAccessorMethod( Handle(_pyCommand) theCmd ) const
{
+ bool added = false;
map< _pyID, Handle(_pyMesh) >::const_iterator id_mesh = myMeshes.begin();
for ( ; id_mesh != myMeshes.end(); ++id_mesh ) {
if ( theCmd->AddAccessorMethod( id_mesh->first, id_mesh->second->AccessorMethod() ))
- return true;
+ added = true;
}
- return false;
+ return added;
}
//================================================================================
/*!
- * \brief Add access method to algo that is object or arg
+ * \brief Add access method to algo that is an object or an argument
* \param theCmd - command to add access method
* \retval bool - true if added
*/
bool _pyGen::AddAlgoAccessorMethod( Handle(_pyCommand) theCmd ) const
{
+ bool added = false;
list< Handle(_pyHypothesis) >::const_iterator hyp = myHypos.begin();
for ( ; hyp != myHypos.end(); ++hyp ) {
- if ( (*hyp)->IsAlgo() &&
+ if ( (*hyp)->IsAlgo() && /*(*hyp)->IsWrapped() &&*/
theCmd->AddAccessorMethod( (*hyp)->GetID(), (*hyp)->AccessorMethod() ))
- return true;
+ added = true;
}
- return false;
+ return added;
}
//================================================================================
//================================================================================
Handle(_pyHypothesis) _pyGen::FindAlgo( const _pyID& theGeom, const _pyID& theMesh,
- const TCollection_AsciiString& theAlgoType )
+ const Handle(_pyHypothesis)& theHypothesis )
{
list< Handle(_pyHypothesis) >::iterator hyp = myHypos.begin();
for ( ; hyp != myHypos.end(); ++hyp )
if ( !hyp->IsNull() &&
(*hyp)->IsAlgo() &&
- (*hyp)->GetType() == theAlgoType &&
+ theHypothesis->CanBeCreatedBy( (*hyp)->GetAlgoType() ) &&
(*hyp)->GetGeom() == theGeom &&
(*hyp)->GetMesh() == theMesh )
return *hyp;
void _pyGen::SetCommandAfter( Handle(_pyCommand) theCmd, Handle(_pyCommand) theAfterCmd )
{
-// cout << "SET\t" << theCmd->GetString() << endl << "AFTER\t" << theAfterCmd->GetString() << endl << endl;
+#ifdef _DEBUG_
+//cout << "SET\t" << theAfterCmd->GetString() << endl << "BEFORE\t" << theCmd->GetString() << endl<<endl;
+#endif
list< Handle(_pyCommand) >::iterator pos;
pos = find( myCommands.begin(), myCommands.end(), theCmd );
myCommands.erase( pos );
case GEOM::SOLID:
case GEOM::SHELL: type = SMESH::VOLUME; break;
case GEOM::COMPOUND: {
- GEOM::GEOM_Gen_var aGeomGen = SMESH_Gen_i::GetSMESHGen()->GetGeomEngine();
+ GEOM::GEOM_Gen_ptr aGeomGen = SMESH_Gen_i::GetSMESHGen()->GetGeomEngine();
if ( !aGeomGen->_is_nil() ) {
GEOM::GEOM_IGroupOperations_var aGrpOp =
aGeomGen->GetIGroupOperations( study->StudyId() );
*/
//================================================================================
-_pyMesh::_pyMesh(const Handle(_pyCommand) theCreationCmd):
- _pyObject(theCreationCmd), myHasEditor(false)
+_pyMesh::_pyMesh(const Handle(_pyCommand) theCreationCmd)
+ : _pyObject(theCreationCmd), myHasEditor(false)
{
// convert my creation command
Handle(_pyCommand) creationCmd = GetCreationCmd();
- creationCmd->SetObject( SMESH_2smeshpy::SmeshpyName() );
+ //TCollection_AsciiString str = creationCmd->GetMethod();
+// if(str != "CreateMeshesFromUNV" &&
+// str != "CreateMeshesFromMED" &&
+// str != "CreateMeshesFromSTL")
+ creationCmd->SetObject( SMESH_2smeshpy::SmeshpyName() );
creationCmd->SetMethod( "Mesh" );
theGen->SetAccessorMethod( GetID(), "GetMesh()" );
}
+//================================================================================
+/*!
+ * \brief
+ * \param theCreationCmd -
+ */
+//================================================================================
+_pyMesh::_pyMesh(const Handle(_pyCommand) theCreationCmd, const TCollection_AsciiString& id):
+ _pyObject(theCreationCmd), myHasEditor(false)
+{
+ // convert my creation command
+ Handle(_pyCommand) creationCmd = GetCreationCmd();
+ creationCmd->SetObject( SMESH_2smeshpy::SmeshpyName() );
+ theGen->SetAccessorMethod( id, "GetMesh()" );
+}
+
//================================================================================
/*!
* \brief Convert a IDL API command of SMESH::Mesh to a method call of python Mesh
void _pyMesh::Process( const Handle(_pyCommand)& theCommand )
{
- // smesh.py wraps the following methods:
+ // some methods of SMESH_Mesh interface needs special conversion
+ // to methods of Mesh python class
//
// 1. GetSubMesh(geom, name) + AddHypothesis(geom, algo)
// --> in Mesh_Algorithm.Create(mesh, geom, hypo, so)
// --> in Mesh_Algorithm.Hypothesis(hyp, args, so)
// 3. CreateGroupFromGEOM(type, name, grp)
// --> in Mesh.Group(grp, name="")
- // 4. ExportToMED(f, opt, version)
- // --> in Mesh.ExportToMED( f, version, opt=0 )
- // 5. ExportMED(f, opt)
- // --> in Mesh.ExportMED( f,opt=0 )
- // 6. ExportDAT(f)
- // --> in Mesh.ExportDAT( f )
- // 7. ExportUNV(f)
- // --> in Mesh.ExportUNV(f)
- // 8. ExportSTL(f, ascii)
- // --> in Mesh.ExportSTL(f, ascii=1)
+ // 4. ExportToMED(f, auto_groups, version)
+ // --> in Mesh.ExportMED( f, auto_groups, version )
+ // 5. etc
const TCollection_AsciiString method = theCommand->GetMethod();
+ // ----------------------------------------------------------------------
if ( method == "GetSubMesh" ) {
mySubmeshes.push_back( theCommand );
}
+ // ----------------------------------------------------------------------
else if ( method == "AddHypothesis" ) { // mesh.AddHypothesis(geom, HYPO )
myAddHypCmds.push_back( theCommand );
// set mesh to hypo
hyp->SetMesh( this->GetID() );
}
}
+ // ----------------------------------------------------------------------
else if ( method == "CreateGroupFromGEOM" ) {// (type, name, grp)
_pyID grp = theCommand->GetArg( 3 );
if ( sameGroupType( grp, theCommand->GetArg( 1 )) ) { // --> Group(grp)
AddMeshAccess( theCommand );
}
}
- else if ( method == "ExportToMED" ) {//(f, opt, version)
- // --> (f, version, opt)
- _pyID opt = theCommand->GetArg( 2 );
- _pyID ver = theCommand->GetArg( 3 );
- theCommand->SetArg( 2, ver );
- theCommand->SetArg( 3, opt );
+ // ----------------------------------------------------------------------
+ else if ( method == "ExportToMED" ) { // ExportToMED() --> ExportMED()
+ theCommand->SetMethod( "ExportMED" );
}
+ // ----------------------------------------------------------------------
+ else if ( method == "CreateGroup" ) { // CreateGroup() --> CreateEmptyGroup()
+ theCommand->SetMethod( "CreateEmptyGroup" );
+ }
+ // ----------------------------------------------------------------------
else if ( method == "RemoveHypothesis" ) // (geom, hyp)
{
- const _pyID & hypID = theCommand->GetArg( 2 );
+ _pyID hypID = theCommand->GetArg( 2 );
// check if this mesh still has corresponding addition command
bool hasAddCmd = false;
}
}
Handle(_pyHypothesis) hyp = theGen->FindHyp( hypID );
- if ( ! hasAddCmd ) { // hypo addition already wrapped
- // access to wrapped mesh
- AddMeshAccess( theCommand );
- // access to wrapped algo
- if ( !hyp.IsNull() && hyp->IsAlgo() && hyp->IsWrapped() )
- theCommand->SetArg( 2, theCommand->GetArg( 2 ) + ".GetAlgorithm()" );
+ if ( ! hasAddCmd && hypID.Length() != 0 ) { // hypo addition already wrapped
+ // RemoveHypothesis(geom, hyp) --> RemoveHypothesis( hyp, geom=0 )
+ _pyID geom = theCommand->GetArg( 1 );
+ theCommand->RemoveArgs();
+ theCommand->SetArg( 1, hypID );
+ if ( geom != GetGeom() )
+ theCommand->SetArg( 2, geom );
}
// remove hyp from myHypos
myHypos.remove( hyp );
}
-
- // leave only one " mesh_editor_<nb> = mesh.GetMeshEditor()"
- else if ( theCommand->GetMethod() == "GetMeshEditor")
+ // add accessor method if necessary
+ else
{
- if ( myHasEditor )
- theCommand->Clear();
- else
+ if ( NeedMeshAccess( theCommand ))
+ // apply theCommand to the mesh wrapped by smeshpy mesh
AddMeshAccess( theCommand );
- myHasEditor = true;
}
+}
- // apply theCommand to the mesh wrapped by smeshpy mesh
- else
- {
- AddMeshAccess( theCommand );
- }
+//================================================================================
+/*!
+ * \brief Return True if addition of accesor method is needed
+ */
+//================================================================================
+
+bool _pyMesh::NeedMeshAccess( const Handle(_pyCommand)& theCommand )
+{
+ // names of SMESH_Mesh methods fully equal to methods of class Mesh, so
+ // no conversion is needed for them at all:
+ static TStringSet sameMethods;
+ if ( sameMethods.empty() ) {
+ const char * names[] =
+ { "ExportDAT","ExportUNV","ExportSTL", "RemoveGroup","RemoveGroupWithContents",
+ "GetGroups","UnionGroups","IntersectGroups","CutGroups","GetLog","GetId","ClearLog",
+ "GetStudyId","HasDuplicatedGroupNamesMED","GetMEDMesh","NbNodes","NbElements",
+ "NbEdges","NbEdgesOfOrder","NbFaces","NbFacesOfOrder","NbTriangles",
+ "NbTrianglesOfOrder","NbQuadrangles","NbQuadranglesOfOrder","NbPolygons","NbVolumes",
+ "NbVolumesOfOrder","NbTetras","NbTetrasOfOrder","NbHexas","NbHexasOfOrder",
+ "NbPyramids","NbPyramidsOfOrder","NbPrisms","NbPrismsOfOrder","NbPolyhedrons",
+ "NbSubMesh","GetElementsId","GetElementsByType","GetNodesId","GetElementType",
+ "GetSubMeshElementsId","GetSubMeshNodesId","GetSubMeshElementType","Dump","GetNodeXYZ",
+ "GetNodeInverseElements","GetShapeID","GetShapeIDForElem","GetElemNbNodes",
+ "GetElemNode","IsMediumNode","IsMediumNodeOfAnyElem","ElemNbEdges","ElemNbFaces",
+ "IsPoly","IsQuadratic","BaryCenter","GetHypothesisList", "SetAutoColor", "GetAutoColor",
+ "Clear"
+ ,"" }; // <- mark of end
+ sameMethods.Insert( names );
+ }
+
+ return !sameMethods.Contains( theCommand->GetMethod() );
}
//================================================================================
for ( cmd = myAddHypCmds.begin(); cmd != myAddHypCmds.end(); ++cmd )
{
Handle(_pyCommand) addCmd = *cmd;
- const _pyID& algoID = addCmd->GetArg( 2 );
+ _pyID algoID = addCmd->GetArg( 2 );
Handle(_pyHypothesis) algo = theGen->FindHyp( algoID );
if ( algo.IsNull() || !algo->IsAlgo() )
continue;
// try to convert
_pyID geom = addCmd->GetArg( 1 );
+ bool isLocalAlgo = ( geom != GetGeom() );
if ( algo->Addition2Creation( addCmd, this->GetID() )) // OK
{
// wrapped algo is created atfer mesh creation
GetCreationCmd()->AddDependantCmd( addCmd );
- if ( geom != GetGeom() ) // local algo
- {
+ if ( isLocalAlgo ) {
// mesh.AddHypothesis(geom, ALGO ) --> mesh.AlgoMethod(geom)
addCmd->SetArg( addCmd->GetNbArgs() + 1,
TCollection_AsciiString( "geom=" ) + geom );
}
}
}
- else // ALGO was already created
+ else // KO - ALGO was already created
{
- // mesh.AddHypothesis(geom, ALGO ) --> mesh.GetMesh().AddHypothesis(geom, ALGO )
- AddMeshAccess( addCmd );
- // mesh.GetMesh().AddHypothesis(geom, ALGO ) ->
- // mesh.GetMesh().AddHypothesis(geom, ALGO.GetAlgorithm() )
- addCmd->SetArg( 2, addCmd->GetArg( 2 ) + ".GetAlgorithm()" );
+ // mesh.AddHypothesis(geom, ALGO) --> mesh.AddHypothesis(ALGO, geom=0)
+ addCmd->RemoveArgs();
+ addCmd->SetArg( 1, algoID );
+ if ( isLocalAlgo )
+ addCmd->SetArg( 2, geom );
}
}
for ( cmd = myAddHypCmds.begin(); cmd != myAddHypCmds.end(); ++cmd )
{
Handle(_pyCommand) addCmd = *cmd;
- const _pyID& hypID = addCmd->GetArg( 2 );
+ _pyID hypID = addCmd->GetArg( 2 );
Handle(_pyHypothesis) hyp = theGen->FindHyp( hypID );
if ( hyp.IsNull() || hyp->IsAlgo() )
continue;
- const _pyID& geom = addCmd->GetArg( 1 );
- // find algo created on <geom> for this mesh
- Handle(_pyHypothesis) algo = theGen->FindAlgo( geom, this->GetID(), hyp->GetType() );
- //_pyID algoID = algo.IsNull() ? "" : algo->GetID();
- if ( !algo.IsNull() && hyp->Addition2Creation( addCmd, this->GetID() )) // OK
- {
- addCmd->SetObject( algo->GetID() );
- algo->GetCreationCmd()->AddDependantCmd( addCmd );
- }
- else
- {
- AddMeshAccess( addCmd );
+ bool converted = hyp->Addition2Creation( addCmd, this->GetID() );
+ if ( !converted ) {
+ // mesh.AddHypothesis(geom, HYP) --> mesh.AddHypothesis(HYP, geom=0)
+ _pyID geom = addCmd->GetArg( 1 );
+ addCmd->RemoveArgs();
+ addCmd->SetArg( 1, hypID );
+ if ( geom != GetGeom() )
+ addCmd->SetArg( 2, geom );
}
}
// sm = mesh.GetSubMesh(geom, name) --> sm = mesh.GetMesh().GetSubMesh(geom, name)
- for ( cmd = mySubmeshes.begin(); cmd != mySubmeshes.end(); ++cmd ) {
- Handle(_pyCommand) subCmd = *cmd;
- if ( subCmd->GetNbArgs() > 0 )
- AddMeshAccess( subCmd );
- }
+// for ( cmd = mySubmeshes.begin(); cmd != mySubmeshes.end(); ++cmd ) {
+// Handle(_pyCommand) subCmd = *cmd;
+// if ( subCmd->GetNbArgs() > 0 )
+// AddMeshAccess( subCmd );
+// }
myAddHypCmds.clear();
mySubmeshes.clear();
(*hyp)->Flush();
}
+//================================================================================
+/*!
+ * \brief MeshEditor convert its commands to ones of mesh
+ */
+//================================================================================
+
+_pyMeshEditor::_pyMeshEditor(const Handle(_pyCommand)& theCreationCmd):
+ _pyObject( theCreationCmd )
+{
+ myMesh = theCreationCmd->GetObject();
+ myCreationCmdStr = theCreationCmd->GetString();
+ theCreationCmd->Clear();
+}
+
+//================================================================================
+/*!
+ * \brief convert its commands to ones of mesh
+ */
+//================================================================================
+
+void _pyMeshEditor::Process( const Handle(_pyCommand)& theCommand)
+{
+ // names of SMESH_MeshEditor methods fully equal to methods of 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","AddEdge","AddFace","AddPolygonalFace",
+ "AddVolume","AddPolyhedralVolume","AddPolyhedralVolumeByFaces","MoveNode",
+ "InverseDiag","DeleteDiag","Reorient","ReorientObject","SplitQuad","SplitQuadObject",
+ "BestSplit","Smooth","SmoothObject","SmoothParametric","SmoothParametricObject",
+ "ConvertToQuadratic","ConvertFromQuadratic","RenumberNodes","RenumberElements",
+ "RotationSweep","RotationSweepObject","ExtrusionSweep","AdvancedExtrusion",
+ "ExtrusionSweepObject","ExtrusionSweepObject1D","ExtrusionSweepObject2D","Mirror",
+ "MirrorObject","Translate","TranslateObject","Rotate","RotateObject",
+ "FindCoincidentNodes","FindCoincidentNodesOnPart","MergeNodes","FindEqualElements",
+ "MergeElements","MergeEqualElements","SewFreeBorders","SewConformFreeBorders",
+ "SewBorderToSide","SewSideElements","ChangeElemNodes","GetLastCreatedNodes",
+ "GetLastCreatedElems",
+ "MirrorMakeMesh","MirrorObjectMakeMesh","TranslateMakeMesh",
+ "TranslateObjectMakeMesh","RotateMakeMesh","RotateObjectMakeMesh"
+ ,"" }; // <- mark of the end
+ sameMethods.Insert( names );
+ }
+
+ // names of SMESH_MeshEditor methods which differ from methods of class Mesh
+ // only last two arguments
+ static TStringSet diffLastTwoArgsMethods;
+ if (diffLastTwoArgsMethods.empty() ){
+ const char * names[] = {
+ "MirrorMakeGroups","MirrorObjectMakeGroups",
+ "TranslateMakeGroups","TranslateObjectMakeGroups",
+ "RotateMakeGroups","RotateObjectMakeGroups",
+ ""};// <- mark of the end
+ 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 {
+
+ //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) {
+ // 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
+ while(nbArgsToAdd--)
+ 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();
+ }
+ }
+ }
+}
+
//================================================================================
/*!
* \brief _pyHypothesis constructor
_pyHypothesis::_pyHypothesis(const Handle(_pyCommand)& theCreationCmd):
_pyObject( theCreationCmd )
{
- myDim = myIsAlgo = /*myIsLocal = */myIsWrapped = myIsConverted = false;
+ myIsAlgo = myIsWrapped = /*myIsConverted = myIsLocal = myDim = */false;
}
//================================================================================
// 1D Regular_1D ----------
if ( hypType == "Regular_1D" ) {
- algo->SetDimMethodType( 1, "Segment");
+ // set mesh's method creating algo,
+ // i.e. convertion result will be "regular1d = Mesh.Segment()",
+ // and set hypType by which algo creating a hypothesis is searched for
+ algo->SetConvMethodAndType("Segment", hypType.ToCString());
+ }
+ else if ( hypType == "CompositeSegment_1D" ) {
+ algo->SetConvMethodAndType("Segment", "Regular_1D");
+ algo->myArgs.Append( "algo=smesh.COMPOSITE");
}
else if ( hypType == "LocalLength" ) {
- hyp->SetDimMethodType( 1, "LocalLength", "Regular_1D");
+ // set algo's method creating hyp, and algo type
+ hyp->SetConvMethodAndType( "LocalLength", "Regular_1D");
+ // set method whose 1 arg will become the 1-st arg of hyp creation command
+ // i.e. convertion result will be "locallength = regular1d.LocalLength(<arg of SetLength()>)"
hyp->AddArgMethod( "SetLength" );
}
else if ( hypType == "NumberOfSegments" ) {
hyp = new _pyNumberOfSegmentsHyp( theCreationCmd );
- hyp->SetDimMethodType( 1, "NumberOfSegments", "Regular_1D");
+ hyp->SetConvMethodAndType( "NumberOfSegments", "Regular_1D");
+ // arg of SetNumberOfSegments() will become the 1-st arg of hyp creation command
hyp->AddArgMethod( "SetNumberOfSegments" );
+ // arg of SetScaleFactor() will become the 2-nd arg of hyp creation command
hyp->AddArgMethod( "SetScaleFactor" );
}
else if ( hypType == "Arithmetic1D" ) {
hyp = new _pyComplexParamHypo( theCreationCmd );
- hyp->SetDimMethodType( 1, "Arithmetic1D", "Regular_1D");
+ hyp->SetConvMethodAndType( "Arithmetic1D", "Regular_1D");
}
else if ( hypType == "StartEndLength" ) {
hyp = new _pyComplexParamHypo( theCreationCmd );
- hyp->SetDimMethodType( 1, "StartEndLength", "Regular_1D");
+ hyp->SetConvMethodAndType( "StartEndLength", "Regular_1D");
}
else if ( hypType == "Deflection1D" ) {
- hyp->SetDimMethodType( 1, "Deflection1D", "Regular_1D");
+ hyp->SetConvMethodAndType( "Deflection1D", "Regular_1D");
hyp->AddArgMethod( "SetDeflection" );
}
else if ( hypType == "Propagation" ) {
- hyp->SetDimMethodType( 1, "Propagation", "Regular_1D");
+ hyp->SetConvMethodAndType( "Propagation", "Regular_1D");
}
else if ( hypType == "QuadraticMesh" ) {
- hyp->SetDimMethodType( 1, "QuadraticMesh", "Regular_1D");
+ hyp->SetConvMethodAndType( "QuadraticMesh", "Regular_1D");
}
else if ( hypType == "AutomaticLength" ) {
- hyp->SetDimMethodType( 1, "AutomaticLength", "Regular_1D");
+ hyp->SetConvMethodAndType( "AutomaticLength", "Regular_1D");
hyp->AddArgMethod( "SetFineness");
}
+ else if ( hypType == "SegmentLengthAroundVertex" ) {
+ hyp = new _pySegmentLengthAroundVertexHyp( theCreationCmd );
+ hyp->SetConvMethodAndType( "LengthNearVertex", "Regular_1D" );
+ hyp->AddArgMethod( "SetLength" );
+ }
// 1D Python_1D ----------
else if ( hypType == "Python_1D" ) {
- algo->SetDimMethodType( 1, "Segment");
+ algo->SetConvMethodAndType( "Segment", hypType.ToCString());
algo->myArgs.Append( "algo=smesh.PYTHON");
}
else if ( hypType == "PythonSplit1D" ) {
- hyp->SetDimMethodType( 1, "PythonSplit1D", "Python_1D");
+ hyp->SetConvMethodAndType( "PythonSplit1D", "Python_1D");
hyp->AddArgMethod( "SetNumberOfSegments");
hyp->AddArgMethod( "SetPythonLog10RatioFunction");
}
- // 2D ----------
- else if ( hypType == "MEFISTO_2D" ) {
- algo->SetDimMethodType( 2, "Triangle");
+ // MEFISTO_2D ----------
+ else if ( hypType == "MEFISTO_2D" ) { // MEFISTO_2D
+ algo->SetConvMethodAndType( "Triangle", hypType.ToCString());
}
else if ( hypType == "MaxElementArea" ) {
- hyp->SetDimMethodType( 2, "MaxElementArea", "MEFISTO_2D");
+ hyp->SetConvMethodAndType( "MaxElementArea", "MEFISTO_2D");
+ hyp->SetConvMethodAndType( "MaxElementArea", "NETGEN_2D_ONLY");
hyp->AddArgMethod( "SetMaxElementArea");
}
else if ( hypType == "LengthFromEdges" ) {
- hyp->SetDimMethodType( 2, "LengthFromEdges", "MEFISTO_2D");
+ hyp->SetConvMethodAndType( "LengthFromEdges", "MEFISTO_2D");
+ hyp->SetConvMethodAndType( "LengthFromEdges", "NETGEN_2D_ONLY");
}
+ // Quadrangle_2D ----------
else if ( hypType == "Quadrangle_2D" ) {
- algo->SetDimMethodType( 2, "Quadrangle" );
+ algo->SetConvMethodAndType( "Quadrangle" , hypType.ToCString());
}
else if ( hypType == "QuadranglePreference" ) {
- hyp->SetDimMethodType( 2, "QuadranglePreference", "Quadrangle_2D");
- }
- // 3D ----------
- else if ( hypType == "NETGEN_3D") {
- algo->SetDimMethodType( 3, "Tetrahedron" );
+ hyp->SetConvMethodAndType( "QuadranglePreference", "Quadrangle_2D");
+ hyp->SetConvMethodAndType( "QuadranglePreference", "NETGEN_2D_ONLY");
+ }
+ else if ( hypType == "TrianglePreference" ) {
+ hyp->SetConvMethodAndType( "TrianglePreference", "Quadrangle_2D");
+ }
+ // NETGEN ----------
+// else if ( hypType == "NETGEN_2D") { // 1D-2D
+// algo->SetConvMethodAndType( "Triangle" , hypType.ToCString());
+// algo->myArgs.Append( "algo=smesh.NETGEN" );
+// }
+ else if ( hypType == "NETGEN_2D_ONLY") { // 2D
+ algo->SetConvMethodAndType( "Triangle" , hypType.ToCString());
+ algo->myArgs.Append( "algo=smesh.NETGEN_2D" );
+ }
+ else if ( hypType == "NETGEN_3D") { // 3D
+ algo->SetConvMethodAndType( "Tetrahedron" , hypType.ToCString());
algo->myArgs.Append( "algo=smesh.NETGEN" );
}
else if ( hypType == "MaxElementVolume") {
- hyp->SetDimMethodType( 3, "MaxElementVolume", "NETGEN_3D");
+ hyp->SetConvMethodAndType( "MaxElementVolume", "NETGEN_3D");
hyp->AddArgMethod( "SetMaxElementVolume" );
}
+ // GHS3D_3D ----------
else if ( hypType == "GHS3D_3D" ) {
- algo->SetDimMethodType( 3, "Tetrahedron");
+ algo->SetConvMethodAndType( "Tetrahedron", hypType.ToCString());
algo->myArgs.Append( "algo=smesh.GHS3D" );
}
+ // Hexa_3D ---------
else if ( hypType == "Hexa_3D" ) {
- algo->SetDimMethodType( 3, "Hexahedron");
+ algo->SetConvMethodAndType( "Hexahedron", hypType.ToCString());
}
- // Repetitive ---------
+ // Repetitive Projection_1D ---------
else if ( hypType == "Projection_1D" ) {
- algo->SetDimMethodType( 1, "Projection1D");
+ algo->SetConvMethodAndType( "Projection1D", hypType.ToCString());
}
else if ( hypType == "ProjectionSource1D" ) {
- hyp->SetDimMethodType( 1, "SourceEdge", "Projection_1D");
+ hyp->SetConvMethodAndType( "SourceEdge", "Projection_1D");
hyp->AddArgMethod( "SetSourceEdge");
hyp->AddArgMethod( "SetSourceMesh");
+ // 2 args of SetVertexAssociation() will become the 3-th and 4-th args of hyp creation command
hyp->AddArgMethod( "SetVertexAssociation", 2 );
}
+ // Projection_2D ---------
else if ( hypType == "Projection_2D" ) {
- algo->SetDimMethodType( 2, "Projection2D");
+ algo->SetConvMethodAndType( "Projection2D", hypType.ToCString());
}
else if ( hypType == "ProjectionSource2D" ) {
- hyp->SetDimMethodType( 2, "SourceFace", "Projection_2D");
+ hyp->SetConvMethodAndType( "SourceFace", "Projection_2D");
hyp->AddArgMethod( "SetSourceFace");
hyp->AddArgMethod( "SetSourceMesh");
hyp->AddArgMethod( "SetVertexAssociation", 4 );
}
+ // Projection_3D ---------
else if ( hypType == "Projection_3D" ) {
- algo->SetDimMethodType( 3, "Projection3D");
+ algo->SetConvMethodAndType( "Projection3D", hypType.ToCString());
}
else if ( hypType == "ProjectionSource3D" ) {
- hyp->SetDimMethodType( 3, "SourceShape3D", "Projection_3D");
+ hyp->SetConvMethodAndType( "SourceShape3D", "Projection_3D");
hyp->AddArgMethod( "SetSource3DShape");
hyp->AddArgMethod( "SetSourceMesh");
hyp->AddArgMethod( "SetVertexAssociation", 4 );
}
+ // Prism_3D ---------
else if ( hypType == "Prism_3D" ) {
- algo->SetDimMethodType( 3, "Prism");
+ algo->SetConvMethodAndType( "Prism", hypType.ToCString());
}
+ // RadialPrism_3D ---------
else if ( hypType == "RadialPrism_3D" ) {
- algo->SetDimMethodType( 3, "Prism");
+ algo->SetConvMethodAndType( "Prism", hypType.ToCString());
}
else if ( hypType == "NumberOfLayers" ) {
- hyp->SetDimMethodType( 3, "NumberOfLayers", "RadialPrism_3D");
+ hyp->SetConvMethodAndType( "NumberOfLayers", "RadialPrism_3D");
hyp->AddArgMethod( "SetNumberOfLayers" );
}
else if ( hypType == "LayerDistribution" ) {
hyp = new _pyLayerDistributionHypo( theCreationCmd );
- hyp->SetDimMethodType( 3, "LayerDistribution", "RadialPrism_3D");
-// hyp->AddArgMethod( "SetSource3DShape");
-// hyp->AddArgMethod( "SetSourceMesh");
-// hyp->AddArgMethod( "SetVertexAssociation", 4 );
+ hyp->SetConvMethodAndType( "LayerDistribution", "RadialPrism_3D");
}
- if ( algo->GetDim() ) {
- algo->myType = hypType;
+ if ( algo->IsValid() ) {
return algo;
}
return hyp;
if ( !IsWrappable( theMesh ))
return false;
- myIsWrapped = true;
-
- if ( myIsWrapped )
- {
- // mesh.AddHypothesis(geom,hyp) --> hyp = theMesh.myCreationMethod(args)
- theCmd->SetResultValue( GetID() );
- theCmd->SetObject( theMesh );
- theCmd->SetMethod( myCreationMethod );
- // set args
- theCmd->RemoveArgs();
- for ( int i = 1; i <= myArgs.Length(); ++i ) {
- if ( !myArgs( i ).IsEmpty() )
- theCmd->SetArg( i, myArgs( i ));
- else
- theCmd->SetArg( i, "[]");
- }
- // set a new creation command
- GetCreationCmd()->Clear();
- SetCreationCmd( theCmd );
+ myGeom = theCmd->GetArg( 1 );
- // clear commands setting arg values
- list < Handle(_pyCommand) >::iterator argCmd = myArgCommands.begin();
- for ( ; argCmd != myArgCommands.end(); ++argCmd )
- (*argCmd)->Clear();
+ Handle(_pyHypothesis) algo;
+ if ( !IsAlgo() ) {
+ // find algo created on myGeom in theMesh
+ algo = theGen->FindAlgo( myGeom, theMesh, this );
+ if ( algo.IsNull() )
+ return false;
+ algo->GetCreationCmd()->AddDependantCmd( theCmd );
}
- else
- {
-// // set arg commands after hypo creation
-// list<Handle(_pyCommand)>::iterator argCmd = myArgCommands.begin();
-// for ( ; argCmd != myArgCommands.end(); ++argCmd )
-// if ( !(*argCmd)->IsEmpty() && GetCommandNb() > (*argCmd)->GetOrderNb() )
-// theGen->ExchangeCommands( GetCreationCmd(), *argCmd );
+ myIsWrapped = true;
+
+ // mesh.AddHypothesis(geom,hyp) --> hyp = <theMesh or algo>.myCreationMethod(args)
+ theCmd->SetResultValue( GetID() );
+ theCmd->SetObject( IsAlgo() ? theMesh : algo->GetID());
+ theCmd->SetMethod( IsAlgo() ? GetAlgoCreationMethod() : GetCreationMethod( algo->GetAlgoType() ));
+ // set args
+ theCmd->RemoveArgs();
+ for ( int i = 1; i <= myArgs.Length(); ++i ) {
+ if ( !myArgs( i ).IsEmpty() )
+ theCmd->SetArg( i, myArgs( i ));
+ else
+ theCmd->SetArg( i, "[]");
}
+ // set a new creation command
+ GetCreationCmd()->Clear();
+ SetCreationCmd( theCmd );
+
+ // clear commands setting arg values
+ list < Handle(_pyCommand) >::iterator argCmd = myArgCommands.begin();
+ for ( ; argCmd != myArgCommands.end(); ++argCmd )
+ (*argCmd)->Clear();
// set unknown arg commands after hypo creation
Handle(_pyCommand) afterCmd = myIsWrapped ? theCmd : GetCreationCmd();
// Convert my creation => me = RadialPrismAlgo.Get3DHypothesis()
// find RadialPrism algo created on <geom> for theMesh
- Handle(_pyHypothesis) algo = theGen->FindAlgo( geom, theMesh, this->GetType() );
+ Handle(_pyHypothesis) algo = theGen->FindAlgo( geom, theMesh, this );
if ( !algo.IsNull() ) {
GetCreationCmd()->SetObject( algo->GetID() );
GetCreationCmd()->SetMethod( "Get3DHypothesis" );
}
}
+//================================================================================
+/*!
+ * \brief Convert the command adding "SegmentLengthAroundVertex" to mesh
+ * into regular1D.LengthNearVertex( length, vertex )
+ * \param theCmd - The command like mesh.AddHypothesis( vertex, SegmentLengthAroundVertex )
+ * \param theMesh - The mesh needing this hypo
+ * \retval bool - false if the command cant be converted
+ */
+//================================================================================
+
+bool _pySegmentLengthAroundVertexHyp::Addition2Creation( const Handle(_pyCommand)& theCmd,
+ const _pyID& theMeshID)
+{
+ if ( IsWrappable( theMeshID )) {
+
+ _pyID vertex = theCmd->GetArg( 1 );
+
+ // the problem here is that segment algo will not be found
+ // by pyHypothesis::Addition2Creation() for <vertex>, so we try to find
+ // geometry where segment algorithm is assigned
+ Handle(_pyHypothesis) algo;
+ _pyID geom = vertex;
+ while ( algo.IsNull() && !geom.IsEmpty()) {
+ // try to find geom as a father of <vertex>
+ geom = FatherID( geom );
+ algo = theGen->FindAlgo( geom, theMeshID, this );
+ }
+ if ( algo.IsNull() )
+ return false; // also possible to find geom as brother of veretex...
+ // set geom instead of vertex
+ theCmd->SetArg( 1, geom );
+
+ // set vertex as a second arg
+ if ( myArgs.Length() < 1) myArgs.Append( "1" ); // :(
+ myArgs.Append( vertex );
+
+ // mesh.AddHypothesis(vertex, SegmentLengthAroundVertex) -->
+ // theMeshID.LengthNearVertex( length, vertex )
+ return _pyHypothesis::Addition2Creation( theCmd, theMeshID );
+ }
+ return false;
+}
+
//================================================================================
/*!
* \brief _pyAlgorithm constructor
bool _pyAlgorithm::Addition2Creation( const Handle(_pyCommand)& theCmd,
const _pyID& theMeshID)
{
- if ( IsWrappable( theMeshID )) {
-
- myGeom = theCmd->GetArg( 1 );
-
- // mesh.AddHypothesis(geom,algo) --> theMeshID.myCreationMethod()
- if ( _pyHypothesis::Addition2Creation( theCmd, theMeshID )) {
- theGen->SetAccessorMethod( GetID(), "GetAlgorithm()" );
- return true;
- }
+ // mesh.AddHypothesis(geom,algo) --> theMeshID.myCreationMethod()
+ if ( _pyHypothesis::Addition2Creation( theCmd, theMeshID )) {
+ theGen->SetAccessorMethod( GetID(), "GetAlgorithm()" );
+ return true;
}
return false;
}
myBegPos( thePartIndex ) = thePosition;
}
+//================================================================================
+/*!
+ * \brief Returns whitespace symbols at the line beginning
+ * \retval TCollection_AsciiString - result
+ */
+//================================================================================
+
+TCollection_AsciiString _pyCommand::GetIndentation()
+{
+ int end = 1;
+ if ( GetBegPos( RESULT_IND ) == UNKNOWN )
+ GetWord( myString, end, true );
+ else
+ end = GetBegPos( RESULT_IND );
+ return myString.SubString( 1, end - 1 );
+}
+
//================================================================================
/*!
* \brief Return substring of python command looking like ResultValue = Obj.Meth()
return myRes;
}
+//================================================================================
+/*!
+ * \brief Return number of python command result value ResultValue = Obj.Meth()
+ * \retval const int
+ */
+//================================================================================
+
+const int _pyCommand::GetNbResultValues()
+{
+ int begPos = 1;
+ int Nb=0;
+ int endPos = myString.Location( "=", 1, Length() );
+ TCollection_AsciiString str = "";
+ while ( begPos < endPos) {
+ str = GetWord( myString, begPos, true );
+ begPos = begPos+ str.Length();
+ Nb++;
+ }
+ return (Nb-1);
+}
+
+
+//================================================================================
+/*!
+ * \brief Return substring of python command looking like
+ * ResultValue1 , ResultValue1,... = Obj.Meth() with res index
+ * \retval const TCollection_AsciiString & - ResultValue with res index substring
+ */
+//================================================================================
+const TCollection_AsciiString & _pyCommand::GetResultValue(int res)
+{
+ int begPos = 1;
+ int Nb=0;
+ int endPos = myString.Location( "=", 1, Length() );
+ while ( begPos < endPos) {
+ myRes = GetWord( myString, begPos, true );
+ begPos = begPos + myRes.Length();
+ Nb++;
+ if(res == Nb){
+ myRes.RemoveAll('[');myRes.RemoveAll(']');
+ return myRes;
+ }
+ if(Nb>res)
+ break;
+ }
+ return theEmptyString;
+}
+
//================================================================================
/*!
* \brief Return substring of python command looking like ResVal = Object.Meth()
{
// beginning
int begPos = GetBegPos( RESULT_IND ) + myRes.Length();
- if ( begPos < 1 )
+ if ( begPos < 1 ) {
begPos = myString.Location( "=", 1, Length() ) + 1;
+ // is '=' in the string argument (for example, name) or not
+ int nb1 = 0; // number of ' character at the left of =
+ int nb2 = 0; // number of " character at the left of =
+ for ( int i = 1; i < begPos-1; i++ ) {
+ if ( IsEqual(myString.Value( i ), "'" ) )
+ nb1 += 1;
+ else if ( IsEqual( myString.Value( i ), '"' ) )
+ nb2 += 1;
+ }
+ // if number of ' or " is not divisible by 2,
+ // then get an object at the start of the command
+ if ( nb1 % 2 != 0 || nb2 % 2 != 0 )
+ begPos = 1;
+ }
// store
myObj = GetWord( myString, begPos, true );
SetBegPos( OBJECT_IND, begPos );
int beg = GetBegPos( OBJECT_IND );
if ( beg < 1 || beg > Length() )
return false;
+ bool added = false;
while (( beg = myString.Location( theObjectID, beg, Length() )))
{
// check that theObjectID is not just a part of a longer ID
int afterEnd = beg + theObjectID.Length();
Standard_Character c = myString.Value( afterEnd );
if ( !isalnum( c ) && c != ':' ) {
- // insertion
- int oldLen = Length();
- myString.Insert( afterEnd, (char*) theAcsMethod );
- myString.Insert( afterEnd, "." );
- // update starting positions of the parts following the modified one
- int posDelta = Length() - oldLen;
- for ( int i = 1; i <= myBegPos.Length(); ++i ) {
- if ( myBegPos( i ) > afterEnd )
- myBegPos( i ) += posDelta;
+ // check if accessor method already present
+ if ( c != '.' ||
+ myString.Location( (char*) theAcsMethod, afterEnd, Length() ) != afterEnd+1) {
+ // insertion
+ int oldLen = Length();
+ myString.Insert( afterEnd, (char*) theAcsMethod );
+ myString.Insert( afterEnd, "." );
+ // update starting positions of the parts following the modified one
+ int posDelta = Length() - oldLen;
+ for ( int i = 1; i <= myBegPos.Length(); ++i ) {
+ if ( myBegPos( i ) > afterEnd )
+ myBegPos( i ) += posDelta;
+ }
+ added = true;
}
- return true;
}
beg = afterEnd; // is a part - next search
}
- return false;
+ return added;
}
//================================================================================
{
return 0;
}
+//================================================================================
+/*!
+ * \brief Return ID of a father
+ */
+//================================================================================
+
+_pyID _pyObject::FatherID(const _pyID & childID)
+{
+ int colPos = childID.SearchFromEnd(':');
+ if ( colPos > 0 )
+ return childID.SubString( 1, colPos-1 );
+ return "";
+}
