-// Copyright (C) 2007-2016 CEA/DEN, EDF R&D, OPEN CASCADE
+// Copyright (C) 2007-2024 CEA, EDF, OPEN CASCADE
//
// Copyright (C) 2003-2007 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
#include <SALOMEDS_wrap.hxx>
#include <utilities.h>
+#include <Basics_OCCTVersion.hxx>
#include <Resource_DataMapOfAsciiStringAsciiString.hxx>
+#if OCC_VERSION_LARGE < 0x07050000
#include <Resource_DataMapIteratorOfDataMapOfAsciiStringAsciiString.hxx>
+#endif
#include "SMESH_Gen_i.hxx"
/* SALOME headers that include CORBA headers that include windows.h
#include <unistd.h>
#endif
-OCCT_IMPLEMENT_STANDARD_RTTIEXT(_pyObject ,Standard_Transient);
-OCCT_IMPLEMENT_STANDARD_RTTIEXT(_pyCommand ,Standard_Transient);
-OCCT_IMPLEMENT_STANDARD_RTTIEXT(_pyHypothesisReader,Standard_Transient);
-OCCT_IMPLEMENT_STANDARD_RTTIEXT(_pyGen ,_pyObject);
-OCCT_IMPLEMENT_STANDARD_RTTIEXT(_pyMesh ,_pyObject);
-OCCT_IMPLEMENT_STANDARD_RTTIEXT(_pySubMesh ,_pyObject);
-OCCT_IMPLEMENT_STANDARD_RTTIEXT(_pyMeshEditor ,_pyObject);
-OCCT_IMPLEMENT_STANDARD_RTTIEXT(_pyHypothesis ,_pyObject);
-OCCT_IMPLEMENT_STANDARD_RTTIEXT(_pySelfEraser ,_pyObject);
-OCCT_IMPLEMENT_STANDARD_RTTIEXT(_pyGroup ,_pyObject);
-OCCT_IMPLEMENT_STANDARD_RTTIEXT(_pyFilter ,_pyObject);
-OCCT_IMPLEMENT_STANDARD_RTTIEXT(_pyAlgorithm ,_pyHypothesis);
-OCCT_IMPLEMENT_STANDARD_RTTIEXT(_pyComplexParamHypo,_pyHypothesis);
-OCCT_IMPLEMENT_STANDARD_RTTIEXT(_pyNumberOfSegmentsHyp,_pyHypothesis);
-OCCT_IMPLEMENT_STANDARD_RTTIEXT(_pyLayerDistributionHypo,_pyHypothesis);
-OCCT_IMPLEMENT_STANDARD_RTTIEXT(_pySegmentLengthAroundVertexHyp,_pyHypothesis);
+IMPLEMENT_STANDARD_RTTIEXT(_pyObject ,Standard_Transient)
+IMPLEMENT_STANDARD_RTTIEXT(_pyCommand ,Standard_Transient)
+IMPLEMENT_STANDARD_RTTIEXT(_pyHypothesisReader,Standard_Transient)
+IMPLEMENT_STANDARD_RTTIEXT(_pyGen ,_pyObject)
+IMPLEMENT_STANDARD_RTTIEXT(_pyMesh ,_pyObject)
+IMPLEMENT_STANDARD_RTTIEXT(_pySubMesh ,_pyObject)
+IMPLEMENT_STANDARD_RTTIEXT(_pyMeshEditor ,_pyObject)
+IMPLEMENT_STANDARD_RTTIEXT(_pyHypothesis ,_pyObject)
+IMPLEMENT_STANDARD_RTTIEXT(_pySelfEraser ,_pyObject)
+IMPLEMENT_STANDARD_RTTIEXT(_pyGroup ,_pyObject)
+IMPLEMENT_STANDARD_RTTIEXT(_pyFilter ,_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;
/*!
* \brief Container of commands into which the initial script is split.
- * It also contains data coresponding to SMESH_Gen contents
+ * It also contains data corresponding to SMESH_Gen contents
*/
static Handle(_pyGen) theGen;
// - FT_BelongToMeshGroup = 22
// v 8.1.0: FT_Undefined == 48, new items:
// - FT_NodeConnectivityNumber= 22
+ // v 8.5.0: FT_Undefined == 49, new items:
+ // - FT_Deflection2D = 22
+ // v 9.3.0: FT_Undefined == 50, new items:
+ // - FT_Length3D = 22
+ // v 9.12.0: FT_Undefined == 51, new items:
+ // - FT_ScaledJacobian = 8
+ // v 9.12.0: FT_Undefined == 52, new items:
+ // - FT_Warping3D = 4
//
// It's necessary to continue recording this history and to fill
// undef2newItems (see below) accordingly.
undef2newItems[ 46 ].push_back( 39 );
undef2newItems[ 47 ].push_back( 22 );
undef2newItems[ 48 ].push_back( 22 );
+ undef2newItems[ 49 ].push_back( 22 );
+ undef2newItems[ 50 ].push_back( 22 );
+ undef2newItems[ 51 ].push_back( 8 );
+ undef2newItems[ 52 ].push_back( 4 );
ASSERT( undef2newItems.rbegin()->first == SMESH::FT_Undefined );
}
//================================================================================
/*!
* \brief Replaces "SMESH.PointStruct(x,y,z)" and "SMESH.DirStruct( SMESH.PointStruct(x,y,z))"
- * arguments of a given command by a list "[x,y,z]" if the list is accesible
+ * arguments of a given command by a list "[x,y,z]" if the list is accessible
* type of argument.
*/
//================================================================================
//================================================================================
/*!
* \brief Replaces "mesh.GetIDSource([id1,id2])" argument of a given command by
- * a list "[id1,id2]" if the list is an accesible type of argument.
+ * a list "[id1,id2]" if the list is an accessible type of argument.
*/
//================================================================================
}
}
}
+
+ bool _FilterArg( const _AString& theArg )
+ {
+ static std::list<_AString> filteredArgs;
+ static bool initialized = false;
+ if ( !initialized ) {
+ initialized = true;
+ filteredArgs.push_back( "SMESH.MED_V2_1" );
+ filteredArgs.push_back( "SMESH.MED_V2_2" );
+ }
+ return std::find( filteredArgs.begin(), filteredArgs.end(), theArg ) != filteredArgs.end();
+ }
}
//================================================================================
Resource_DataMapOfAsciiStringAsciiString& theEntry2AccessorMethod,
Resource_DataMapOfAsciiStringAsciiString& theObjectNames,
std::set< TCollection_AsciiString >& theRemovedObjIDs,
- SALOMEDS::Study_ptr& theStudy,
const bool theToKeepAllCommands)
{
std::list< TCollection_AsciiString >::iterator lineIt;
theGen = new _pyGen( theEntry2AccessorMethod,
theObjectNames,
theRemovedObjIDs,
- theStudy,
theToKeepAllCommands );
for ( lineIt = theScriptLines.begin(); lineIt != theScriptLines.end(); ++lineIt )
MESSAGE_BEGIN ( std::endl << " ######## RESULT ######## " << std::endl<< std::endl );
#endif
- // clean commmands of removed objects depending on myIsPublished flag
+ // clean commands of removed objects depending on myIsPublished flag
theGen->ClearCommands();
// reorder commands after conversion
set<_pyID> createdObjects;
createdObjects.insert( "smeshBuilder" );
createdObjects.insert( "smesh" );
- createdObjects.insert( "theStudy" );
for ( cmd = theGen->GetCommands().begin(); cmd != theGen->GetCommands().end(); ++cmd )
{
#ifdef DUMP_CONVERSION
_pyGen::_pyGen(Resource_DataMapOfAsciiStringAsciiString& theEntry2AccessorMethod,
Resource_DataMapOfAsciiStringAsciiString& theObjectNames,
std::set< TCollection_AsciiString >& theRemovedObjIDs,
- SALOMEDS::Study_ptr& theStudy,
const bool theToKeepAllCommands)
: _pyObject( new _pyCommand( "", 0 )),
myNbCommands( 0 ),
myRemovedObjIDs( theRemovedObjIDs ),
myNbFilters( 0 ),
myToKeepAllCommands( theToKeepAllCommands ),
- myStudy( SALOMEDS::Study::_duplicate( theStudy )),
- myGeomIDNb(0), myGeomIDIndex(-1)
+ myGeomIDNb(0), myGeomIDIndex(-1),
+ myShaperIDNb(0), myShaperIDIndex(-1)
{
// make that GetID() to return TPythonDump::SMESHGenName()
GetCreationCmd()->Clear();
GetCreationCmd()->GetString() += "=";
// Find 1st digit of study entry by which a GEOM object differs from a SMESH object
- if ( !theObjectNames.IsEmpty() && !CORBA::is_nil( theStudy ))
+ if (!theObjectNames.IsEmpty())
{
- // find a GEOM entry
- _pyID geomID;
- SALOMEDS::SComponent_wrap geomComp = theStudy->FindComponent("GEOM");
- if ( geomComp->_is_nil() ) return;
- CORBA::String_var entry = geomComp->GetID();
- geomID = entry.in();
-
- // find a SMESH entry
- _pyID smeshID;
- Resource_DataMapIteratorOfDataMapOfAsciiStringAsciiString e2n( theObjectNames );
- for ( ; e2n.More() && smeshID.IsEmpty(); e2n.Next() )
- if ( _pyCommand::IsStudyEntry( e2n.Key() ))
- smeshID = e2n.Key();
-
- // find 1st difference between smeshID and geomID
- if ( !geomID.IsEmpty() && !smeshID.IsEmpty() )
- for ( int i = 1; i <= geomID.Length() && i <= smeshID.Length(); ++i )
- if ( geomID.Value( i ) != smeshID.Value( i ))
- {
- myGeomIDNb = geomID.Value( i );
- myGeomIDIndex = i;
- }
+ // find a GEOM (aPass == 0) and SHAPERSTUDY (aPass == 1) entries
+ for(int aPass = 0; aPass < 2; aPass++) {
+ _pyID geomID;
+ SALOMEDS::SComponent_wrap geomComp = SMESH_Gen_i::GetSMESHGen()->getStudyServant()->
+ FindComponent(aPass == 0 ? "GEOM" : "SHAPERSTUDY");
+ if (geomComp->_is_nil()) continue;
+ CORBA::String_var entry = geomComp->GetID();
+ geomID = entry.in();
+
+ // find a SMESH entry
+ _pyID smeshID;
+ Resource_DataMapIteratorOfDataMapOfAsciiStringAsciiString e2n(theObjectNames);
+ for (; e2n.More() && smeshID.IsEmpty(); e2n.Next())
+ if (_pyCommand::IsStudyEntry(e2n.Key()))
+ smeshID = e2n.Key();
+
+ // find 1st difference between smeshID and geomID
+ if (!geomID.IsEmpty() && !smeshID.IsEmpty())
+ for (int i = 1; i <= geomID.Length() && i <= smeshID.Length(); ++i)
+ if (geomID.Value(i) != smeshID.Value(i))
+ {
+ if (aPass == 0) {
+ myGeomIDNb = geomID.Value(i);
+ myGeomIDIndex = i;
+ } else {
+ myShaperIDNb = geomID.Value(i);
+ myShaperIDIndex = i;
+ }
+ }
+ }
}
}
//================================================================================
/*!
* \brief Convert a command using a specific converter
- * \param theCommand - the command to convert
+ * \param theCommand - the command to convert
*/
//================================================================================
if ( objID == this->GetID() || objID == SMESH_2smeshpy::GenName())
{
this->Process( aCommand );
+
//addFilterUser( aCommand, theGen ); // protect filters from clearing
return aCommand;
}
meshID = aCommand->GetResultValue();
else if ( method == "MakeBoundaryMesh")
meshID = aCommand->GetResultValue(1);
- else if ( method == "MakeBoundaryElements")
+ else if ( method == "MakeBoundaryElements" || method == "MakeBoundaryOfEachElement" )
meshID = aCommand->GetResultValue(2);
- if ( method.Search("MakeGroups") != -1 ||
- method == "ExtrusionAlongPathX" ||
- method == "ExtrusionAlongPathObjX" ||
- method == "DoubleNodeGroupNew" ||
- method == "DoubleNodeGroupsNew" ||
- method == "DoubleNodeElemGroupNew" ||
- method == "DoubleNodeElemGroupsNew"||
- method == "DoubleNodeElemGroup2New"||
- method == "DoubleNodeElemGroups2New"
+ if ( method.Search("MakeGroups") != -1 ||
+ method == "ExtrusionAlongPathX" ||
+ method == "ExtrusionAlongPathObjX" ||
+ method == "DoubleNodeGroupNew" ||
+ method == "DoubleNodeGroupsNew" ||
+ method == "DoubleNodeElemGroupNew" ||
+ method == "DoubleNodeElemGroupsNew" ||
+ method == "DoubleNodeElemGroup2New" ||
+ method == "DoubleNodeElemGroups2New" ||
+ method == "AffectedElemGroupsInRegion"
)
groups = aCommand->GetResultValue();
else if ( method == "MakeBoundaryMesh" )
groups = aCommand->GetResultValue(2);
- else if ( method == "MakeBoundaryElements")
+ else if ( method == "MakeBoundaryElements" || method == "MakeBoundaryOfEachElement" )
groups = aCommand->GetResultValue(3);
else if ( method == "Create0DElementsOnAllNodes" &&
aCommand->GetArg(2).Length() > 2 ) // group name != ''
aCommand->GetString() += tmpCmd.GetString();
}
// IMP issue 0021014
- // set GetCriterion(elementType,CritType,Compare,Treshold,UnaryOp,BinaryOp,Tolerance)
- // 1 2 3 4 5 6 7
+ // set GetCriterion(elementType,CritType,Compare,Threshold,UnaryOp,BinaryOp,Tolerance)
+ // 1 2 3 4 5 6 7
// instead of "SMESH.Filter.Criterion(
// Type,Compare,Threshold,ThresholdStr,ThresholdID,UnaryOp,BinaryOp,Tolerance,TypeOfElement,Precision)
// 1 2 3 4 5 6 7 8 9 10
"Geom_POLYHEDRA", "Geom_BALL" };
if ( -1 < iGeom && iGeom < nbTypes )
Threshold = SMESH + types[ iGeom ];
-#ifdef _DEBUG_
- // is types complete? (compilation failure mains that enum GeometryType changed)
- int _asrt[( sizeof(types) / sizeof(const char*) == nbTypes ) ? 2 : -1 ]; _asrt[0]=_asrt[1];
-#endif
+
+ if (SALOME::VerbosityActivated())
+ {
+ // is types complete? (compilation failure means that enum GeometryType changed)
+ static_assert( sizeof(types) / sizeof(const char*) == nbTypes,
+ "Update names of GeometryType's!!!" );
+ }
}
if (Type == "SMESH.FT_EntityType")
{
"Entity_Polygon", "Entity_Quad_Polygon", "Entity_Tetra", "Entity_Quad_Tetra",
"Entity_Pyramid", "Entity_Quad_Pyramid",
"Entity_Hexa", "Entity_Quad_Hexa", "Entity_TriQuad_Hexa",
- "Entity_Penta", "Entity_Quad_Penta", "Entity_Hexagonal_Prism",
+ "Entity_Penta", "Entity_Quad_Penta", "Entity_BiQuad_Penta", "Entity_Hexagonal_Prism",
"Entity_Polyhedra", "Entity_Quad_Polyhedra", "Entity_Ball" };
if ( -1 < iGeom && iGeom < nbTypes )
Threshold = SMESH + types[ iGeom ];
-#ifdef _DEBUG_
- // is 'types' complete? (compilation failure mains that enum EntityType changed)
- int _asrt[( sizeof(types) / sizeof(const char*) == nbTypes ) ? 2 : -1 ]; _asrt[0]=_asrt[1];
-#endif
+
+ if (SALOME::VerbosityActivated())
+ {
+ // is 'types' complete? (compilation failure means that enum EntityType changed)
+ static_assert( sizeof(types) / sizeof(const char*) == nbTypes,
+ "Update names of EntityType's!!!" );
+ }
}
}
if ( ThresholdID.Length() != 2 ) // neither '' nor ""
//================================================================================
/*!
* \brief Convert the command or remember it for later conversion
- * \param theCommand - The python command calling a method of SMESH_Gen
+ * \param theCommand - The python command calling a method of SMESH_Gen
*/
//================================================================================
// Concatenate( [mesh1, ...], ... )
// CreateHypothesis( theHypType, theLibName )
// Compute( mesh, geom )
+ // CheckCompute( mesh )
// Evaluate( mesh, geom )
// mesh creation
TCollection_AsciiString method = theCommand->GetMethod();
{
Handle(_pyMesh) mesh = new _pyMesh( theCommand );
AddObject( mesh );
+ // set mesh name
+ _pyID id = mesh->GetID(), comma("'");
+ if ( myObjectNames.IsBound( id ))
+ theCommand->SetArg( theCommand->GetNbArgs() + 1,
+ comma + myObjectNames( id ) + comma);
return;
}
if ( method == "CreateMeshesFromUNV" ||
method == "CreateMeshesFromSTL" ||
+ method == "CreateDualMesh" ||
method == "CopyMesh" ) // command result is a mesh
{
Handle(_pyMesh) mesh = new _pyMesh( theCommand, theCommand->GetResultValue() );
AddObject( mesh );
return;
}
- if( method == "CreateMeshesFromMED" ||
- method == "CreateMeshesFromSAUV"||
- method == "CreateMeshesFromCGNS" ||
- method == "CreateMeshesFromGMF" ) // command result is ( [mesh1,mesh2], status )
+ if ( method == "CreateMeshesFromMED" ||
+ method == "CreateMeshesFromCGNS" ||
+ method == "CreateMeshesFromGMF" ) // command result is ( [mesh1,mesh2], status )
{
std::list< _pyID > meshIDs = theCommand->GetStudyEntries( theCommand->GetResultValue() );
std::list< _pyID >::iterator meshID = meshIDs.begin();
theCommand->SetArg( 1, file );
}
}
+ if ( method == "CopyMeshWithGeom" )
+ {
+ std::list< _pyID > entries = theCommand->GetStudyEntries( theCommand->GetResultValue() );
+ Handle(_pyMesh) mesh = new _pyMesh( theCommand, entries.front() );
+ AddObject( mesh );
+ }
// CreateHypothesis()
if ( method == "CreateHypothesis" )
}
}
+ // smeshgen.CheckCompute( mesh ) --> mesh.CheckCompute()
+ if ( method == "CheckCompute" )
+ {
+ const _pyID& meshID = theCommand->GetArg( 1 );
+ map< _pyID, Handle(_pyMesh) >::iterator id_mesh = myMeshes.find( meshID );
+ if ( id_mesh != myMeshes.end() ) {
+ theCommand->SetObject( meshID );
+ theCommand->RemoveArgs();
+ id_mesh->second->Process( theCommand );
+ id_mesh->second->AddProcessedCmd( theCommand );
+ return;
+ }
+ }
+
+
// smeshgen.Evaluate( mesh, geom ) --> mesh.Evaluate(geom)
if ( method == "Evaluate" )
{
// Concatenate( [mesh1, ...], ... )
else if ( method == "Concatenate" || method == "ConcatenateWithGroups")
{
+ // OLD IDL: ( meshes, uniteGroups, toMerge, tol )
+ // IDL: ( meshes, uniteGroups, toMerge, tol, meshToAppendTo )
+ // PY: ( meshes, uniteGroups, toMerge, tol, allGroups=False, name="", meshToAppendTo=None )
+ _pyID appendMesh = theCommand->GetArg( 5 );
if ( method == "ConcatenateWithGroups" ) {
theCommand->SetMethod( "Concatenate" );
- theCommand->SetArg( theCommand->GetNbArgs() + 1, "True" );
+ theCommand->SetArg( 5, "True" );
+ }
+ else {
+ theCommand->SetArg( 5, "False" );
+ }
+ if ( !appendMesh.IsEmpty() && appendMesh != "None" )
+ {
+ appendMesh.Insert( 1, "meshToAppendTo=" );
+ theCommand->SetArg( theCommand->GetNbArgs() + 1, appendMesh );
}
Handle(_pyMesh) mesh = new _pyMesh( theCommand, theCommand->GetResultValue() );
AddObject( mesh );
static TStringSet smeshpyMethods;
if ( smeshpyMethods.empty() ) {
const char * names[] =
- { "SetEmbeddedMode","IsEmbeddedMode","SetCurrentStudy","GetCurrentStudy",
+ { "SetEmbeddedMode","IsEmbeddedMode","UpdateStudy","GetStudy",
"GetPattern","GetSubShapesId",
"" }; // <- mark of array end
smeshpyMethods.Insert( names );
*/
//================================================================================
-void _pyGen::PlaceSubmeshAfterItsCreation( Handle(_pyCommand) theCmdUsingSubmesh ) const
+void _pyGen::PlaceSubmeshAfterItsCreation( Handle(_pyCommand) /*theCmdUsingSubmesh*/ ) const
{
// map< _pyID, Handle(_pyObject) >::const_iterator id_obj = myObjects.begin();
// for ( ; id_obj != myObjects.end(); ++id_obj )
//================================================================================
/*!
- * \brief Clean commmands of removed objects depending on myIsPublished flag
+ * \brief Clean commands of removed objects depending on myIsPublished flag
*/
//================================================================================
//================================================================================
/*!
* \brief Add access method to mesh that is an argument
- * \param theCmd - command to add access method
- * \retval bool - true if added
+ * \param theCmd - command to add access method
+ * \retval bool - true if added
*/
//================================================================================
//================================================================================
/*!
* \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
+ * \param theCmd - command to add access method
+ * \retval bool - true if added
*/
//================================================================================
//================================================================================
/*!
* \brief Find hypothesis by ID (entry)
- * \param theHypID - The hypothesis ID
- * \retval Handle(_pyHypothesis) - The found hypothesis
+ * \param theHypID - The hypothesis ID
+ * \retval Handle(_pyHypothesis) - The found hypothesis
*/
//================================================================================
//================================================================================
/*!
* \brief Find algorithm able to create a hypothesis
- * \param theGeom - The shape ID the algorithm was created on
- * \param theMesh - The mesh ID that created the algorithm
- * \param theHypothesis - The hypothesis the algorithm should be able to create
- * \retval Handle(_pyHypothesis) - The found algo
+ * \param theGeom - The shape ID the algorithm was created on
+ * \param theMesh - The mesh ID that created the algorithm
+ * \param theHypothesis - The hypothesis the algorithm should be able to create
+ * \retval Handle(_pyHypothesis) - The found algo
*/
//================================================================================
//================================================================================
/*!
* \brief Find subMesh by ID (entry)
- * \param theSubMeshID - The subMesh ID
- * \retval Handle(_pySubMesh) - The found subMesh
+ * \param theSubMeshID - The subMesh ID
+ * \retval Handle(_pySubMesh) - The found subMesh
*/
//================================================================================
//================================================================================
/*!
* \brief Change order of commands in the script
- * \param theCmd1 - One command
- * \param theCmd2 - Another command
+ * \param theCmd1 - One command
+ * \param theCmd2 - Another command
*/
//================================================================================
int nb1 = theCmd1->GetOrderNb();
theCmd1->SetOrderNb( theCmd2->GetOrderNb() );
theCmd2->SetOrderNb( nb1 );
-// cout << "BECOME " << theCmd1->GetOrderNb() << "\t" << theCmd1->GetString() << endl
-// << "BECOME " << theCmd2->GetOrderNb() << "\t" << theCmd2->GetString() << endl << endl;
+ // cout << "BECOME " << theCmd1->GetOrderNb() << "\t" << theCmd1->GetString() << endl
+ // << "BECOME " << theCmd2->GetOrderNb() << "\t" << theCmd2->GetString() << endl << endl;
}
//================================================================================
/*!
* \brief Set one command after the other
- * \param theCmd - Command to move
- * \param theAfterCmd - Command ater which to insert the first one
+ * \param theCmd - Command to move
+ * \param theAfterCmd - Command ater which to insert the first one
*/
//================================================================================
//================================================================================
/*!
* \brief Set one command before the other
- * \param theCmd - Command to move
- * \param theBeforeCmd - Command before which to insert the first one
+ * \param theCmd - Command to move
+ * \param theBeforeCmd - Command before which to insert the first one
*/
//================================================================================
//================================================================================
/*!
* \brief Set one command before or after the other
- * \param theCmd - Command to move
- * \param theOtherCmd - Command ater or before which to insert the first one
+ * \param theCmd - Command to move
+ * \param theOtherCmd - Command ater or before which to insert the first one
*/
//================================================================================
// void _pyGen::addFilterUser( Handle(_pyCommand)& theCommand, const Handle(_pyObject)& user )
// {
- // No more needed after adding _pyObject::myArgCommands
+// No more needed after adding _pyObject::myArgCommands
// const char filterPrefix[] = "aFilter0x";
// if ( theCommand->GetString().Search( filterPrefix ) < 1 )
//================================================================================
/*!
* \brief Set command be last in list of commands
- * \param theCmd - Command to be last
+ * \param theCmd - Command to be last
*/
//================================================================================
//================================================================================
/*!
* \brief Set method to access to object wrapped with python class
- * \param theID - The wrapped object entry
- * \param theMethod - The accessor method
+ * \param theID - The wrapped object entry
+ * \param theMethod - The accessor method
*/
//================================================================================
//================================================================================
/*!
* \brief Generated new ID for object and assign with existing name
- * \param theID - ID of existing object
+ * \param theID - ID of existing object
*/
//================================================================================
}
else if ( theObj->IsKind( STANDARD_TYPE( _pyMeshEditor ))) {
add = myMeshEditors.insert( make_pair( theObj->GetID(),
- Handle(_pyMeshEditor)::DownCast( theObj ))).second;
+ Handle(_pyMeshEditor)::DownCast( theObj ))).second;
}
else {
add = myObjects.insert( make_pair( theObj->GetID(), theObj )).second;
bool _pyGen::IsGeomObject(const _pyID& theObjID) const
{
- if ( myGeomIDNb )
- {
- return ( myGeomIDIndex <= theObjID.Length() &&
- int( theObjID.Value( myGeomIDIndex )) == myGeomIDNb &&
- _pyCommand::IsStudyEntry( theObjID ));
- }
- return false;
+ bool isGeom = myGeomIDNb && myGeomIDIndex <= theObjID.Length() &&
+ int( theObjID.Value( myGeomIDIndex )) == myGeomIDNb;
+ bool isShaper = myShaperIDNb && myShaperIDIndex <= theObjID.Length() &&
+ int( theObjID.Value( myShaperIDIndex )) == myShaperIDNb;
+ return ((isGeom || isShaper) && _pyCommand::IsStudyEntry( theObjID ));
}
//================================================================================
// either the SMESH object is not in study or it is a GEOM object
if ( IsGeomObject( theObjID ))
{
- SALOMEDS::SObject_wrap so = myStudy->FindObjectID( theObjID.ToCString() );
+ SALOMEDS::SObject_wrap so = SMESH_Gen_i::GetSMESHGen()->getStudyServant()->FindObjectID( theObjID.ToCString() );
if ( so->_is_nil() ) return true;
CORBA::Object_var obj = so->GetObject();
return CORBA::is_nil( obj );
}
else if ( theCreationCmd->GetMethod().Search("MakeMesh") != -1 ||
theCreationCmd->GetMethod() == "MakeBoundaryMesh" ||
- theCreationCmd->GetMethod() == "MakeBoundaryElements" )
+ theCreationCmd->GetMethod() == "MakeBoundaryElements" ||
+ theCreationCmd->GetMethod() == "MakeBoundaryOfEachElement" )
{
// this mesh depends on a source mesh
// (theCreationCmd is already Process()ed by _pyMeshEditor)
const _pyID& meshID = theCreationCmd->GetObject();
addFatherMesh( meshID );
}
-
+
// convert my creation command
Handle(_pyCommand) creationCmd = GetCreationCmd();
creationCmd->SetObject( SMESH_2smeshpy::SmeshpyName() );
//================================================================================
/*!
* \brief Convert an IDL API command of SMESH::SMESH_Mesh to a method call of python Mesh
- * \param theCommand - Engine method called for this mesh
+ * \param theCommand - Engine method called for this mesh
*/
//================================================================================
void _pyMesh::Process( const Handle(_pyCommand)& theCommand )
{
- // some methods of SMESH_Mesh interface needs special conversion
+ // some methods of SMESH_Mesh interface need special conversion
// to methods of Mesh python class
//
// 1. GetSubMesh(geom, name) + AddHypothesis(geom, algo)
}
Flush();
}
+ // in snapshot mode, clear the previous CheckCompute()
+ else if ( method == "CheckCompute" )
+ {
+ if ( !theGen->IsToKeepAllCommands() ) // !historical
+ {
+ if ( !myLastCheckCmd.IsNull() )
+ {
+ // check if the previously computed mesh has been edited,
+ // if so then we do not clear the previous Compute()
+ bool toClear = true;
+ list< Handle(_pyMeshEditor)>::iterator e = myEditors.begin();
+ for ( ; e != myEditors.end() && toClear; ++e )
+ {
+ list< Handle(_pyCommand)>& cmds = (*e)->GetProcessedCmds();
+ list< Handle(_pyCommand) >::reverse_iterator cmd = cmds.rbegin();
+ if ( cmd != cmds.rend() &&
+ (*cmd)->GetOrderNb() > myLastCheckCmd->GetOrderNb() )
+ toClear = false;
+ }
+ if ( toClear )
+ myLastCheckCmd->Clear();
+ }
+ myLastCheckCmd = theCommand;
+ }
+ }
// ----------------------------------------------------------------------
else if ( method == "Clear" ) // in snapshot mode, clear all previous commands
{
if ( !obj->CanClear() )
allGroupsRemoved = false;
}
- if ( nbGroupsBefore == myGroups.size() ) // no new _pyGroup created
+ if ( nbGroupsBefore == myGroups.size() && !obj.IsNull() ) // no new _pyGroup created
obj->AddProcessedCmd( theCommand ); // to clear theCommand if all groups are removed
if ( !allGroupsRemoved && !theGen->IsToKeepAllCommands() )
// if GetGroups() is just after Compute(), this can mean that the groups
// were created by some algorithm and hence Compute() should not be discarded
std::list< Handle(_pyCommand) >& cmdList = theGen->GetCommands();
- std::list< Handle(_pyCommand) >::iterator cmd = cmdList.begin();
+ std::list< Handle(_pyCommand) >::reverse_iterator cmd = cmdList.rbegin();
while ( (*cmd)->GetMethod() == "GetGroups" )
++cmd;
if ( myLastComputeCmd == (*cmd))
// ----------------------------------------------------------------------
else if ( theCommand->MethodStartsFrom( "Export" ))
{
- if ( method == "ExportToMED" || // ExportToMED() --> ExportMED()
- method == "ExportToMEDX" ) // ExportToMEDX() --> ExportMED()
+ if ( method == "ExportToMED" || // ExportToMED() --> ExportMED()
+ method == "ExportToMEDX" || // ExportToMEDX() --> ExportMED()
+ method == "ExportMED" )
{
theCommand->SetMethod( "ExportMED" );
- if ( theCommand->GetNbArgs() == 5 )
+ // filter out deprecated version parameter
+ vector< _AString > args;
+ for ( int i = 1; i <= theCommand->GetNbArgs(); i++ ) {
+ if ( !_FilterArg( theCommand->GetArg( i ) ) )
+ args.push_back( theCommand->GetArg( i ) );
+ }
+ theCommand->RemoveArgs();
+ for ( unsigned int i = 0; i < args.size(); i++ )
+ theCommand->SetArg( i+1, args[i] );
+ if ( theCommand->GetNbArgs() == 4 )
{
// ExportToMEDX(...,autoDimension) -> ExportToMEDX(...,meshPart=None,autoDimension)
- _AString autoDimension = theCommand->GetArg( 5 );
- theCommand->SetArg( 5, "None" );
- theCommand->SetArg( 6, autoDimension );
+ _AString autoDimension = theCommand->GetArg( 4 );
+ theCommand->SetArg( 4, "None" );
+ theCommand->SetArg( 5, autoDimension );
}
}
else if ( method == "ExportCGNS" )
TCollection_AsciiString newMethod = method;
newMethod.Remove( /*where=*/7, /*howmany=*/6 );
theCommand->SetMethod( newMethod );
- // make the 1st arg be the last one (or last but three for ExportMED())
- _pyID partID = theCommand->GetArg( 1 );
- int nbArgs = theCommand->GetNbArgs() - 3 * (newMethod == "ExportMED");
- for ( int i = 2; i <= nbArgs; ++i )
- theCommand->SetArg( i-1, theCommand->GetArg( i ));
- theCommand->SetArg( nbArgs, partID );
+ // replace version parameter by minor
+ std::list< _AString > args;
+ for ( int i = 1; i <= theCommand->GetNbArgs(); i++ ) {
+ if ( _FilterArg( theCommand->GetArg( i )))
+ args.push_back( "minor=0");
+ else
+ args.push_back( theCommand->GetArg( i ));
+ }
+ // check the 1st arg meshPart, it must be SMESH_IDSource
+ _AString meshPart = args.front();
+ if ( _pyCommand::IsStudyEntry( meshPart ) ||
+ meshPart.Search( "Filter" ) > 0 ||
+ meshPart.Search( "GetIDSource" ) > 0 ||
+ meshPart.Search( "meshPart" ) > 0 )
+ {
+ // set the 1st arg meshPart
+ // - to 5th place for ExportMED command
+ // - to last place for the rest commands
+ std::list< _AString >::iterator newPos = args.end();
+ if ( newMethod == "ExportMED" )
+ std::advance( newPos = args.begin(), 5 );
+ args.splice( newPos, args, args.begin() );
+ }
+ std::list< _AString >::iterator a = args.begin();
+ for ( unsigned int i = 1; a != args.end(); ++i, ++a )
+ theCommand->SetArg( i, *a );
}
// remember file name
theGen->AddExportedMesh( theCommand->GetArg( 1 ),
else if ( method == "GetMeshOrder" || method == "SetMeshOrder" )
{
// make commands GetSubMesh() returning sub-meshes be before using sub-meshes
- // by GetMeshOrder() and SetMeshOrder(), since by defalut GetSubMesh()
+ // by GetMeshOrder() and SetMeshOrder(), since by default GetSubMesh()
// commands are moved at the end of the script
TCollection_AsciiString subIDs =
( method == "SetMeshOrder" ) ? theCommand->GetArg(1) : theCommand->GetResultValue();
static TStringSet sameMethods;
if ( sameMethods.empty() ) {
const char * names[] =
- { "ExportDAT","ExportUNV","ExportSTL","ExportSAUV", "RemoveGroup","RemoveGroupWithContents",
+ { "ExportDAT","ExportUNV","ExportSTL", "RemoveGroup","RemoveGroupWithContents",
"GetGroups","UnionGroups","IntersectGroups","CutGroups","CreateDimGroup","GetLog","GetId",
- "ClearLog","GetStudyId","HasDuplicatedGroupNamesMED","GetMEDMesh","NbNodes","NbElements",
+ "ClearLog","HasDuplicatedGroupNamesMED","GetMEDMesh","NbNodes","NbElements",
"NbEdges","NbEdgesOfOrder","NbFaces","NbFacesOfOrder","NbTriangles",
"NbTrianglesOfOrder","NbQuadrangles","NbQuadranglesOfOrder","NbPolygons","NbVolumes",
"NbVolumesOfOrder","NbTetras","NbTetrasOfOrder","NbHexas","NbHexasOfOrder",
"GetElemNode","IsMediumNode","IsMediumNodeOfAnyElem","ElemNbEdges","ElemNbFaces",
"GetElemFaceNodes", "GetFaceNormal", "FindElementByNodes",
"IsPoly","IsQuadratic","BaryCenter","GetHypothesisList", "SetAutoColor", "GetAutoColor",
- "Clear", "ConvertToStandalone", "GetMeshOrder", "SetMeshOrder"
+ "Clear", "ConvertToStandalone", "GetMeshOrder", "SetMeshOrder",
+ "SetNbThreads", "CheckCompute"
,"" }; // <- mark of end
sameMethods.Insert( names );
}
list < Handle(_pyCommand) >::iterator cmd;
// try to convert algo addition like this:
- // mesh.AddHypothesis(geom, ALGO ) --> ALGO = mesh.Algo()
+ // mesh.AddHypothesis( geom, ALGO ) --> ALGO = mesh.Algo()
for ( cmd = myAddHypCmds.begin(); cmd != myAddHypCmds.end(); ++cmd )
{
Handle(_pyCommand) addCmd = *cmd;
list< Handle(_pySubMesh) >::iterator sm = mySubmeshes.begin();
for ( ; sm != mySubmeshes.end(); ++sm )
(*sm)->ClearCommands();
-
+
list< Handle(_pyGroup) >::iterator gr = myGroups.begin();
for ( ; gr != myGroups.end(); ++gr )
(*gr)->ClearCommands();
static TStringSet sameMethods;
if ( sameMethods.empty() ) {
const char * names[] = {
- "RemoveElements","RemoveNodes","RemoveOrphanNodes",
+ "RemoveElements","RemoveNodes","RemoveOrphanNodes","RemoveNodeWithReconnection",
"AddNode","Add0DElement","AddEdge","AddFace","AddPolygonalFace","AddBall",
- "AddVolume","AddPolyhedralVolume","AddPolyhedralVolumeByFaces",
- "MoveNode", "MoveClosestNodeToPoint",
- "InverseDiag","DeleteDiag","Reorient","ReorientObject","Reorient2DBy3D",
+ "AddVolume","AddPolyhedralVolume","AddPolyhedralVolumeByFaces","AddNodeOnSegment",
+ "MoveNode", "MoveClosestNodeToPoint","InverseDiag","DeleteDiag","AddNodeOnFace",
+ "Reorient","ReorientObject","Reorient2DBy3D","Reorient2DByNeighbours",
"TriToQuad","TriToQuadObject", "QuadTo4Tri", "SplitQuad","SplitQuadObject",
"BestSplit","Smooth","SmoothObject","SmoothParametric","SmoothParametricObject",
"ConvertToQuadratic","ConvertFromQuadratic","RenumberNodes","RenumberElements",
"ExtrusionByNormal", "ExtrusionSweepObject2D","ExtrusionAlongPath","ExtrusionAlongPathObject",
"ExtrusionAlongPathX","ExtrusionAlongPathObject1D","ExtrusionAlongPathObject2D",
"ExtrusionSweepObjects","RotationSweepObjects","ExtrusionAlongPathObjects",
- "Mirror","MirrorObject","Translate","TranslateObject","Rotate","RotateObject",
- "FindCoincidentNodes","MergeNodes","FindEqualElements",
+ "Mirror","MirrorObject","Translate","TranslateObject","Rotate","RotateObject","Offset",
+ "FindCoincidentNodes","MergeNodes","FindEqualElements","FillHole",
"MergeElements","MergeEqualElements","SewFreeBorders","SewConformFreeBorders",
"FindCoincidentFreeBorders", "SewCoincidentFreeBorders",
"SewBorderToSide","SewSideElements","ChangeElemNodes","GetLastCreatedNodes",
- "GetLastCreatedElems",
+ "GetLastCreatedElems", "FaceGroupsSeparatedByEdges",
"MirrorMakeMesh","MirrorObjectMakeMesh","TranslateMakeMesh","TranslateObjectMakeMesh",
"Scale","ScaleMakeMesh","RotateMakeMesh","RotateObjectMakeMesh","MakeBoundaryMesh",
- "MakeBoundaryElements", "SplitVolumesIntoTetra","SplitHexahedraIntoPrisms",
+ "MakeBoundaryElements", "MakeBoundaryOfEachElement", "SplitVolumesIntoTetra","SplitHexahedraIntoPrisms",
"DoubleElements","DoubleNodes","DoubleNode","DoubleNodeGroup","DoubleNodeGroups",
- "DoubleNodeElem","DoubleNodeElemInRegion","DoubleNodeElemGroup",
+ "DoubleNodeElem","DoubleNodeElemInRegion","DoubleNodeElemGroup","AffectedElemGroupsInRegion",
"DoubleNodeElemGroupInRegion","DoubleNodeElemGroups","DoubleNodeElemGroupsInRegion",
"DoubleNodesOnGroupBoundaries","CreateFlatElementsOnFacesGroups","CreateHoleSkin"
,"" }; // <- mark of the end
// 1. Remove "MakeGroups" from the Command
TCollection_AsciiString aMethod = theCommand->GetMethod();
int nbArgsToAdd = diffLastTwoArgsMethods.Contains(aMethod) ? 2 : 1;
-
+
if(is0DmethObj)
pos = pos-2; //Remove "0D" from the Command too
aMethod.Trunc(pos-1);
//================================================================================
/*!
* \brief _pyHypothesis constructor
- * \param theCreationCmd -
+ * \param theCreationCmd -
*/
//================================================================================
//================================================================================
/*!
* \brief Creates algorithm or hypothesis
- * \param theCreationCmd - The engine command creating a hypothesis
- * \retval Handle(_pyHypothesis) - Result _pyHypothesis
+ * \param theCreationCmd - The engine command creating a hypothesis
+ * \retval Handle(_pyHypothesis) - Result _pyHypothesis
*/
//================================================================================
//================================================================================
/*!
* \brief Convert the command adding a hypothesis to mesh into a smesh command
- * \param theCmd - The command like mesh.AddHypothesis( geom, hypo )
- * \param theAlgo - The algo that can create this hypo
- * \retval bool - false if the command can't be converted
+ * \param theCmd - The command like mesh.AddHypothesis( geom, hypo )
+ * \param theAlgo - The algo that can create this hypo
+ * \retval bool - false if the command can't be converted
*/
//================================================================================
//================================================================================
/*!
* \brief Remember hypothesis parameter values
- * \param theCommand - The called hypothesis method
+ * \param theCommand - The called hypothesis method
*/
//================================================================================
// parameters are discriminated by method name
_AString method = theCommand->GetMethod();
if ( myAccumulativeMethods.count( method ))
- return; // this method adds values and not override the previus value
+ return; // this method adds values and not override the previous value
// discriminate commands setting different parameters via one method
// by passing parameter names like e.g. SetOption("size", "0.2")
//================================================================================
/*!
- * \brief Return true if a setting parameter command ha been used to compute mesh
+ * \brief Return true if a setting parameter command has been used to compute mesh
*/
//================================================================================
continue;
// check if a cmd is a sole command setting its parameter;
// don't use method name for search as it can change
- map<TCollection_AsciiString, list<Handle(_pyCommand)> >::iterator
- m2cmds = myMeth2Commands.begin();
+ map<_AString, list<Handle(_pyCommand)> >::iterator m2cmds = myMeth2Commands.begin();
for ( ; m2cmds != myMeth2Commands.end(); ++m2cmds )
{
list< Handle(_pyCommand)>& cmds = m2cmds->second;
//================================================================================
/*!
* \brief Remember hypothesis parameter values
- * \param theCommand - The called hypothesis method
+ * \param theCommand - The called hypothesis method
*/
//================================================================================
{
CreationMethod& crMethod = type2meth->second;
while ( (int) crMethod.myArgs.size() < i+1 )
- crMethod.myArgs.push_back( "[]" );
- crMethod.myArgs[ i ] = theCommand->GetArg( 1 ); // arg value
+ crMethod.myArgs.push_back( "[]" );
+ crMethod.myArgs[ i ] = theCommand->GetArg( 1 ); // arg value
}
myArgCommands.push_back( theCommand );
}
//================================================================================
/*!
* \brief Convert methods of 1D hypotheses to my own methods
- * \param theCommand - The called hypothesis method
+ * \param theCommand - The called hypothesis method
*/
//================================================================================
//================================================================================
/*!
* \brief
- * \param theAdditionCmd - command to be converted
- * \param theMesh - mesh instance
- * \retval bool - status
+ * \param theAdditionCmd - command to be converted
+ * \param theMesh - mesh instance
+ * \retval bool - status
*/
//================================================================================
list< Handle(_pyCommand) >::iterator cmd = myArgCommands.begin();
_pyID prevNewName;
for ( cmd = myArgCommands.begin(); cmd != myArgCommands.end(); ++cmd )
- {
+ {
const _pyID& hyp1dID = (*cmd)->GetArg( 1 );
if ( hyp1dID.IsEmpty() ) continue;
}
newName += "_Distribution";
prevNewName = newName;
-
+
hyp1d->GetCreationCmd()->SetResultValue( newName );
}
list< Handle(_pyCommand) >& cmds = theGen->GetCommands();
//================================================================================
/*!
* \brief additionally to Addition2Creation, clears SetDistrType() command
- * \param theCmd - AddHypothesis() command
- * \param theMesh - mesh to which a hypothesis is added
- * \retval bool - conversion result
+ * \param theCmd - AddHypothesis() command
+ * \param theMesh - mesh to which a hypothesis is added
+ * \retval bool - conversion result
*/
//================================================================================
/*!
* \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 can't be converted
+ * \param theCmd - The command like mesh.AddHypothesis( vertex, SegmentLengthAroundVertex )
+ * \param theMesh - The mesh needing this hypo
+ * \retval bool - false if the command can't be converted
*/
//================================================================================
//================================================================================
/*!
* \brief _pyAlgorithm constructor
- * \param theCreationCmd - The command like "algo = smeshgen.CreateHypothesis(type,lib)"
+ * \param theCreationCmd - The command like "algo = smeshgen.CreateHypothesis(type,lib)"
*/
//================================================================================
//================================================================================
/*!
* \brief Convert the command adding an algorithm to mesh
- * \param theCmd - The command like mesh.AddHypothesis( geom, algo )
- * \param theMesh - The mesh needing this algo
- * \retval bool - false if the command can't be converted
+ * \param theCmd - The command like mesh.AddHypothesis( geom, algo )
+ * \param theMesh - The mesh needing this algo
+ * \retval bool - false if the command can't be converted
*/
//================================================================================
//================================================================================
/*!
* \brief Return starting position of a part of python command
- * \param thePartIndex - The index of command part
- * \retval int - Part position
+ * \param thePartIndex - The index of command part
+ * \retval int - Part position
*/
//================================================================================
//================================================================================
/*!
* \brief Store starting position of a part of python command
- * \param thePartIndex - The index of command part
- * \param thePosition - Part position
+ * \param thePartIndex - The index of command part
+ * \param thePosition - Part position
*/
//================================================================================
//================================================================================
/*!
* \brief Returns whitespace symbols at the line beginning
- * \retval TCollection_AsciiString - result
+ * \retval TCollection_AsciiString - result
*/
//================================================================================
//================================================================================
/*!
* \brief Return substring of python command looking like ResultValue = Obj.Meth()
- * \retval const TCollection_AsciiString & - ResultValue substring
+ * \retval const TCollection_AsciiString & - ResultValue substring
*/
//================================================================================
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 ( myString.Value( i )=='\'' )
- nb1 += 1;
- else if ( myString.Value( i )=='"' )
- nb2 += 1;
- }
- // if number of ' or " is not divisible by 2,
+ int nb[4] = { 0, 0, 0, 0 }; // number of '"() character at the left of =
+ for ( int i = 1; i < begPos-1; i++ )
+ switch ( myString.Value( i )) {
+ case '\'': nb[0]++; break;
+ case '"' : nb[1]++; break;
+ case '(' : nb[2]++; break;
+ case ')' : nb[3]++; break;
+ }
+ // if = is inside a string or a list
// then get an object at the start of the command
- if ( nb1 % 2 != 0 || nb2 % 2 != 0 )
+ if ( nb[0] % 2 != 0 || nb[1] % 2 != 0 || nb[2] != nb[3])
begPos = 1;
}
else {
//================================================================================
/*!
* \brief Return substring of python command looking like ResVal = Obj.Method()
- * \retval const TCollection_AsciiString & - Method substring
+ * \retval const TCollection_AsciiString & - Method substring
*/
//================================================================================
{
if ( GetMethod().IsEmpty() )
return false;
+ if ( myString.StartsWith("#") )
+ return false;
+ if ( myString.StartsWith("SHAPERSTUDY") ) // skip shaperstudy specific dump string analysis
+ return false;
const char* s = myString.ToCString() + GetBegPos( METHOD_IND ) + myMeth.Length() - 1;
return ( s[0] == '(' || s[1] == '(' );
}
//================================================================================
/*!
* \brief Return substring of python command looking like ResVal = Obj.Meth(Arg1,...)
- * \retval const TCollection_AsciiString & - Arg<index> substring
+ * \retval const TCollection_AsciiString & - Arg<index> substring
*/
//================================================================================
if ( pos == UNKNOWN )
{
pos = GetBegPos( METHOD_IND ) + myMeth.Length();
- if ( pos < 1 )
+ if ( pos < 1 && Length() >= 4 )
pos = myString.Location( "(", 4, Length() ); // 4 = strlen("b.c(")
}
return pos;
//================================================================================
/*!
* \brief Check if char is a word part
- * \param c - The character to check
- * \retval bool - The check result
+ * \param c - The character to check
+ * \retval bool - The check result
*/
//================================================================================
//================================================================================
/*!
* \brief Looks for a word in the string and returns word's beginning
- * \param theString - The input string
- * \param theStartPos - The position to start the search, returning word's beginning
- * \param theForward - The search direction
- * \retval TCollection_AsciiString - The found word
+ * \param theString - The input string
+ * \param theStartPos - The position to start the search, returning word's beginning
+ * \param theForward - The search direction
+ * \retval TCollection_AsciiString - The found word
*/
//================================================================================
}
theStartPos = beg;
//cout << theString << " ---- " << beg << " - " << end << endl;
+ if ( end > theString.Length() )
+ {
+ theStartPos = EMPTY;
+ return theEmptyString;
+ }
return theString.SubString( beg, end );
}
//================================================================================
/*!
- * \brief Finds entries in a sting
+ * \brief Finds entries in a string
*/
//================================================================================
//================================================================================
/*!
* \brief Look for position where not space char is
- * \param theString - The string
- * \param thePos - The position to search from and which returns result
- * \retval bool - false if there are only space after thePos in theString
+ * \param theString - The string
+ * \param thePos - The position to search from and which returns result
+ * \retval bool - false if there are only space after thePos in theString
*/
//================================================================================
//================================================================================
/*!
* \brief Modify a part of the command
- * \param thePartIndex - The index of the part
- * \param thePart - The new part string
- * \param theOldPart - The old part
+ * \param thePartIndex - The index of the part
+ * \param thePart - The new part string
+ * \param theOldPart - The old part
*/
//================================================================================
void _pyCommand::SetPart(int thePartIndex, const TCollection_AsciiString& thePart,
- TCollection_AsciiString& theOldPart)
+ TCollection_AsciiString& theOldPart)
{
int pos = GetBegPos( thePartIndex );
if ( pos <= Length() && theOldPart != thePart)
//================================================================================
/*!
- * \brief Set agrument
- * \param index - The argument index, it counts from 1
- * \param theArg - The argument string
+ * \brief Set argument
+ * \param index - The argument index, it counts from 1
+ * \param theArg - The argument string
*/
//================================================================================
//================================================================================
/*!
* \brief Insert accessor method after theObjectID
- * \param theObjectID - id of the accessed object
- * \param theAcsMethod - name of the method giving access to the object
- * \retval bool - false if theObjectID is not found in the command string
+ * \param theObjectID - id of the accessed object
+ * \param theAcsMethod - name of the method giving access to the object
+ * \retval bool - false if theObjectID is not found in the command string
*/
//================================================================================
//================================================================================
/*!
* \brief Return method name giving access to an interaface object wrapped by python class
- * \retval const char* - method name
+ * \retval const char* - method name
*/
//================================================================================
*/
//================================================================================
-bool _pySubMesh::CanBeArgOfMethod(const _AString& theMethodName)
+bool _pySubMesh::CanBeArgOfMethod(const _AString& /*theMethodName*/)
{
return false;
-// // names of all methods where a sub-mesh can be used as argument
-// static TStringSet methods;
-// if ( methods.empty() ) {
-// const char * names[] = {
-// // methods of SMESH_Gen
-// "CopyMesh",
-// // methods of SMESH_Group
-// "AddFrom",
-// // methods of SMESH_Measurements
-// "MinDistance",
-// // methods of SMESH_Mesh
-// "ExportPartToMED","ExportCGNS","ExportPartToDAT","ExportPartToUNV","ExportPartToSTL",
-// "RemoveSubMesh",
-// // methods of SMESH_MeshEditor
-// "ReorientObject","Reorient2D","TriToQuadObject","QuadToTriObject","SplitQuadObject",
-// "SplitVolumesIntoTetra","SmoothObject","SmoothParametricObject","ConvertFromQuadraticObject",
-// "RotationSweepObject","RotationSweepObjectMakeGroups","RotationSweepObject1D",
-// "RotationSweepObject1DMakeGroups","RotationSweepObject2D","RotationSweepObject2DMakeGroups",
-// "ExtrusionSweepObject","ExtrusionSweepObjectMakeGroups","ExtrusionSweepObject0D",
-// "ExtrusionSweepObject0DMakeGroups","ExtrusionSweepObject1D","ExtrusionSweepObject2D",
-// "ExtrusionSweepObject1DMakeGroups","ExtrusionSweepObject2DMakeGroups",
-// "ExtrusionAlongPathObjX","ExtrusionAlongPathObject","ExtrusionAlongPathObjectMakeGroups",
-// "ExtrusionAlongPathObject1D","ExtrusionAlongPathObject1DMakeGroups",
-// "ExtrusionAlongPathObject2D","ExtrusionAlongPathObject2DMakeGroups","MirrorObject",
-// "MirrorObjectMakeGroups","MirrorObjectMakeMesh","TranslateObject","Scale",
-// "TranslateObjectMakeGroups","TranslateObjectMakeMesh","ScaleMakeGroups","ScaleMakeMesh",
-// "RotateObject","RotateObjectMakeGroups","RotateObjectMakeMesh","FindCoincidentNodesOnPart",
-// "FindCoincidentNodesOnPartBut","FindEqualElements","FindAmongElementsByPoint",
-// "MakeBoundaryMesh","Create0DElementsOnAllNodes",
-// "" }; // <- mark of end
-// methods.Insert( names );
-// }
-// return methods.Contains( theMethodName );
+ // names of all methods where a sub-mesh can be used as argument
+ // static TStringSet methods;
+ // if ( methods.empty() ) {
+ // const char * names[] = {
+ // // methods of SMESH_Gen
+ // "CopyMesh",
+ // // methods of SMESH_Group
+ // "AddFrom",
+ // // methods of SMESH_Measurements
+ // "MinDistance",
+ // // methods of SMESH_Mesh
+ // "ExportPartToMED","ExportCGNS","ExportPartToDAT","ExportPartToUNV","ExportPartToSTL",
+ // "RemoveSubMesh",
+ // // methods of SMESH_MeshEditor
+ // "ReorientObject","Reorient2D","TriToQuadObject","QuadToTriObject","SplitQuadObject",
+ // "SplitVolumesIntoTetra","SmoothObject","SmoothParametricObject","ConvertFromQuadraticObject",
+ // "RotationSweepObject","RotationSweepObjectMakeGroups","RotationSweepObject1D",
+ // "RotationSweepObject1DMakeGroups","RotationSweepObject2D","RotationSweepObject2DMakeGroups",
+ // "ExtrusionSweepObject","ExtrusionSweepObjectMakeGroups","ExtrusionSweepObject0D",
+ // "ExtrusionSweepObject0DMakeGroups","ExtrusionSweepObject1D","ExtrusionSweepObject2D",
+ // "ExtrusionSweepObject1DMakeGroups","ExtrusionSweepObject2DMakeGroups",
+ // "ExtrusionAlongPathObjX","ExtrusionAlongPathObject","ExtrusionAlongPathObjectMakeGroups",
+ // "ExtrusionAlongPathObject1D","ExtrusionAlongPathObject1DMakeGroups",
+ // "ExtrusionAlongPathObject2D","ExtrusionAlongPathObject2DMakeGroups","MirrorObject",
+ // "MirrorObjectMakeGroups","MirrorObjectMakeMesh","TranslateObject","Scale",
+ // "TranslateObjectMakeGroups","TranslateObjectMakeMesh","ScaleMakeGroups","ScaleMakeMesh",
+ // "RotateObject","RotateObjectMakeGroups","RotateObjectMakeMesh","FindCoincidentNodesOnPart",
+ // "FindCoincidentNodesOnPartBut","FindEqualElements","FindAmongElementsByPoint",
+ // "MakeBoundaryMesh","Create0DElementsOnAllNodes",
+ // "" }; // <- mark of end
+ // methods.Insert( names );
+ // }
+ // return methods.Contains( theMethodName );
}
//================================================================================
//}
//else {
// ------------------------->>>>> GroupOnGeom( geom, name, typ )
- _pyID type = theCreationCmd->GetArg( 1 );
- _pyID name = theCreationCmd->GetArg( 2 );
- theCreationCmd->SetMethod( "GroupOnGeom" );
- theCreationCmd->RemoveArgs();
- theCreationCmd->SetArg( 1, geom );
- theCreationCmd->SetArg( 2, name );
- theCreationCmd->SetArg( 3, type );
+ _pyID type = theCreationCmd->GetArg( 1 );
+ _pyID name = theCreationCmd->GetArg( 2 );
+ theCreationCmd->SetMethod( "GroupOnGeom" );
+ theCreationCmd->RemoveArgs();
+ theCreationCmd->SetArg( 1, geom );
+ theCreationCmd->SetArg( 2, name );
+ theCreationCmd->SetArg( 3, type );
//}
}
else if ( method == "CreateGroupFromFilter" )
//================================================================================
/*!
- * \brief Check if "[ group1, group2 ] = mesh.GetGroups()" creation command
+ * \brief Check if "[ group1, group2 ] = mesh.GetGroups()" creation command
* can be cleared
*/
//================================================================================
if ( !myNewID.IsEmpty() )
theCommand->SetObject( myNewID );
-
+
// Convert the following set of commands into smesh.GetFilterFromCriteria(criteria)
// aFilter0x2aaab0487080 = aFilterManager.CreateFilter()
// aFilter0x2aaab0487080.SetCriteria(aCriteria)
void _pyFilter::Flush()
{
if ( myNewID.IsEmpty() ) return;
-
+
list< Handle(_pyCommand) >::iterator cmd = myArgCmds.begin();
for ( ; cmd != myArgCmds.end(); ++cmd )
if ( !(*cmd)->IsEmpty() )
// ...
// dim="2">
// <python-wrap>
- // <accumulative-methods>
+ // <accumulative-methods>
// SetEnforcedVertex,
// SetEnforcedVertexNamed
// </accumulative-methods>
const int minPrefixSize = 4;
// count "smaller" strings with the same prefix
- std::list< _AString >::iterator itLess = itStr; --itLess;
int nbLess = 0;
- for ( ; itLess != _strings.end(); --itLess )
+ std::list< _AString >::iterator itLess = itStr;
+ while ( itLess != _strings.begin() )
+ {
+ --itLess;
if ( strncmp( str, itLess->ToCString(), minPrefixSize ) == 0 )
++nbLess;
else
+ {
+ ++itLess;
break;
- ++itLess;
+ }
+ }
+ // itLess points to the 1st string with same prefix
+
// count "greater" strings with the same prefix
- std::list< _AString >::iterator itMore = itStr;
int nbMore = 0;
+ std::list< _AString >::iterator itMore = itStr;
for ( ; itMore != _strings.end(); ++itMore )
if ( strncmp( str, itMore->ToCString(), minPrefixSize ) == 0 )
++nbMore;
else
break;
- --itMore;
+ // itMore points to the 1st string with greater prefix
+
if ( nbLess + nbMore > 1 ) // ------- ADD a NEW CHILD FAMILY -------------
{
- // look for a maximal prefix length
- // int lessPrefSize = 3, morePrefSize = 3;
- // if ( nbLess > 0 )
- // while( itLess->ToCString()[ lessPrefSize ] == str[ lessPrefSize ] )
- // ++lessPrefSize;
- // if ( nbMore > 0 )
- // while ( itMore->ToCString()[ morePrefSize ] == str[ morePrefSize ] )
- // ++morePrefSize;
- // int prefixSize = 3;
- // if ( nbLess == 0 )
- // prefixSize = morePrefSize;
- // else if ( nbMore == 0 )
- // prefixSize = lessPrefSize;
- // else
- // prefixSize = Min( lessPrefSize, morePrefSize );
int prefixSize = minPrefixSize;
_AString newPrefix ( str, prefixSize );
for ( ; nbMore > 0; --nbMore, ++itStr )
newSubFam._strings.push_back( itStr->ToCString() + prefixSize );
- _strings.erase( itLess, ++itMore );
+ _strings.erase( itLess, itMore );
}
- else // to few string to make a family fot them
+ else // too few string to make a family for them
{
_strings.insert( itStr, str );
}
if (( len = itSub->isIn( str + itSub->_prefix.Length() )) >= 0 )
return itSub->_prefix.Length() + len;
}
- else if ( cmp > 0 )
+ else if ( cmp < 0 )
break;
}
if ( !_strings.empty() )
