X-Git-Url: http://git.salome-platform.org/gitweb/?p=modules%2Fsmesh.git;a=blobdiff_plain;f=src%2FSMESH_I%2FSMESH_2smeshpy.cxx;h=4340ab41b8bd7a4a28dc174102638f7354e59b55;hp=ccf63624030fd6a96767b3a0ce79b74a4c8c0c9a;hb=21c57ac1ede30f0bee01db8fbec004e6956eaafe;hpb=9d11375af40826e967ab2c3bcb77d1f9d439c90c diff --git a/src/SMESH_I/SMESH_2smeshpy.cxx b/src/SMESH_I/SMESH_2smeshpy.cxx index ccf636240..4340ab41b 100644 --- a/src/SMESH_I/SMESH_2smeshpy.cxx +++ b/src/SMESH_I/SMESH_2smeshpy.cxx @@ -1,26 +1,25 @@ -// 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 @@ -29,7 +28,7 @@ // File : SMESH_2smeshpy.cxx // Created : Fri Nov 18 13:20:10 2005 // Author : Edward AGAPOV (eap) - +// #include "SMESH_2smeshpy.hxx" #include "utilities.h" @@ -46,6 +45,7 @@ IMPLEMENT_STANDARD_HANDLE (_pyObject ,Standard_Transient); 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); @@ -55,11 +55,13 @@ IMPLEMENT_STANDARD_RTTIEXT(_pyObject ,Standard_Transient); 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; @@ -78,11 +80,40 @@ static TCollection_AsciiString theEmptyString; #undef DUMP_CONVERSION #endif + +namespace { + + //================================================================================ + /*! + * \brief Set of TCollection_AsciiString initialized by C array of C strings + */ + //================================================================================ + + struct TStringSet: public set + { + /*! + * \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 */ //================================================================================ @@ -104,7 +135,7 @@ SMESH_2smeshpy::ConvertScript(const TCollection_AsciiString& theScript, // 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; @@ -121,7 +152,7 @@ SMESH_2smeshpy::ConvertScript(const TCollection_AsciiString& theScript, 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"; @@ -151,6 +182,17 @@ _pyGen::_pyGen(Resource_DataMapOfAsciiStringAsciiString& theEntry2AccessorMethod 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 @@ -158,45 +200,64 @@ _pyGen::_pyGen(Resource_DataMapOfAsciiStringAsciiString& theEntry2AccessorMethod */ //================================================================================ -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)) @@ -216,6 +277,7 @@ void _pyGen::AddCommand( const TCollection_AsciiString& theCommand) aCommand->GetString() += tmpCmd.GetString(); } } + return aCommand; } //================================================================================ @@ -229,25 +291,41 @@ void _pyGen::Process( const Handle(_pyCommand)& theCommand ) { // 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;indGetNbResultValues();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 ); @@ -260,7 +338,7 @@ void _pyGen::Process( const Handle(_pyCommand)& theCommand ) } // leave only one smeshgen.GetPattern() in the script - if ( theCommand->GetMethod() == "GetPattern" ) { + if ( method == "GetPattern" ) { if ( myHasPattern ) { theCommand->Clear(); return; @@ -268,8 +346,35 @@ void _pyGen::Process( const Handle(_pyCommand)& theCommand ) 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() ); } //================================================================================ @@ -297,7 +402,7 @@ void _pyGen::Flush() //================================================================================ /*! - * \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 */ @@ -305,17 +410,18 @@ void _pyGen::Flush() 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 */ @@ -323,13 +429,14 @@ bool _pyGen::AddMeshAccessorMethod( Handle(_pyCommand) theCmd ) const 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; } //================================================================================ @@ -360,13 +467,13 @@ Handle(_pyHypothesis) _pyGen::FindHyp( const _pyID& theHypID ) //================================================================================ 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; @@ -408,7 +515,9 @@ void _pyGen::ExchangeCommands( Handle(_pyCommand) theCmd1, Handle(_pyCommand) th 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<::iterator pos; pos = find( myCommands.begin(), myCommands.end(), theCmd ); myCommands.erase( pos ); @@ -458,7 +567,7 @@ static bool sameGroupType( const _pyID& grpID, 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() ); @@ -501,17 +610,36 @@ static bool sameGroupType( const _pyID& grpID, */ //================================================================================ -_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 @@ -521,7 +649,8 @@ _pyMesh::_pyMesh(const Handle(_pyCommand) theCreationCmd): 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) @@ -529,21 +658,16 @@ void _pyMesh::Process( const Handle(_pyCommand)& theCommand ) // --> 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 @@ -555,6 +679,7 @@ void _pyMesh::Process( const Handle(_pyCommand)& theCommand ) hyp->SetMesh( this->GetID() ); } } + // ---------------------------------------------------------------------- else if ( method == "CreateGroupFromGEOM" ) {// (type, name, grp) _pyID grp = theCommand->GetArg( 3 ); if ( sameGroupType( grp, theCommand->GetArg( 1 )) ) { // --> Group(grp) @@ -566,16 +691,18 @@ void _pyMesh::Process( const Handle(_pyCommand)& theCommand ) 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; @@ -594,32 +721,57 @@ void _pyMesh::Process( const Handle(_pyCommand)& theCommand ) } } 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_ = 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() ); } //================================================================================ @@ -637,19 +789,19 @@ void _pyMesh::Flush() 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 ); @@ -664,13 +816,13 @@ void _pyMesh::Flush() } } } - 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 ); } } @@ -679,31 +831,27 @@ void _pyMesh::Flush() 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 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(); @@ -713,6 +861,102 @@ void _pyMesh::Flush() (*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 @@ -723,7 +967,7 @@ void _pyMesh::Flush() _pyHypothesis::_pyHypothesis(const Handle(_pyCommand)& theCreationCmd): _pyObject( theCreationCmd ) { - myDim = myIsAlgo = /*myIsLocal = */myIsWrapped = myIsConverted = false; + myIsAlgo = myIsWrapped = /*myIsConverted = myIsLocal = myDim = */false; } //================================================================================ @@ -754,131 +998,166 @@ Handle(_pyHypothesis) _pyHypothesis::NewHypothesis( const Handle(_pyCommand)& th // 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()" 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; @@ -901,39 +1180,38 @@ bool _pyHypothesis::Addition2Creation( const Handle(_pyCommand)& theCmd, 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::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 = .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(); @@ -1137,7 +1415,7 @@ bool _pyLayerDistributionHypo::Addition2Creation( const Handle(_pyCommand)& theA // Convert my creation => me = RadialPrismAlgo.Get3DHypothesis() // find RadialPrism algo created on 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" ); @@ -1228,6 +1506,49 @@ void _pyNumberOfSegmentsHyp::Flush() } } +//================================================================================ +/*! + * \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 , 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 + 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 @@ -1253,15 +1574,10 @@ _pyAlgorithm::_pyAlgorithm(const Handle(_pyCommand)& theCreationCmd) 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; } @@ -1298,6 +1614,23 @@ void _pyCommand::SetBegPos( int thePartIndex, int thePosition ) 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() @@ -1319,6 +1652,54 @@ const TCollection_AsciiString & _pyCommand::GetResultValue() 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() @@ -1332,8 +1713,22 @@ const TCollection_AsciiString & _pyCommand::GetObject() { // 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 ); @@ -1624,27 +2019,32 @@ bool _pyCommand::AddAccessorMethod( _pyID theObjectID, const char* theAcsMethod 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; } //================================================================================ @@ -1658,3 +2058,16 @@ const char* _pyObject::AccessorMethod() const { 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 ""; +}