#include "SMESH_Filter_i.hxx"
#include "SMESH_Gen_i.hxx"
+#include "SMESH_PythonDump.hxx"
#include "SMDS_Mesh.hxx"
#include "SMDS_MeshNode.hxx"
using namespace SMESH;
using namespace SMESH::Controls;
+
+namespace SMESH
+{
+ Predicate_i*
+ GetPredicate( Predicate_ptr thePredicate )
+ {
+ return DownCast<Predicate_i*>(thePredicate);
+ }
+}
+
+
/*
Class : BelongToGeom
Description : Predicate for verifying whether entiy belong to
myType(SMDSAbs_All)
{}
-void Controls::BelongToGeom::SetMesh( SMDS_Mesh* theMesh )
+void Controls::BelongToGeom::SetMesh( const SMDS_Mesh* theMesh )
{
- myMeshDS = dynamic_cast<SMESHDS_Mesh*>(theMesh);
+ myMeshDS = dynamic_cast<const SMESHDS_Mesh*>(theMesh);
}
void Controls::BelongToGeom::SetGeom( const TopoDS_Shape& theShape )
myShape = theShape;
}
-static bool IsContains( SMESHDS_Mesh* theMeshDS,
+static bool IsContains( const SMESHDS_Mesh* theMeshDS,
const TopoDS_Shape& theShape,
const SMDS_MeshElement* theElem,
TopAbs_ShapeEnum theFindShapeEnum,
return myShape;
}
-SMESHDS_Mesh* Controls::BelongToGeom::GetMeshDS()
+const SMESHDS_Mesh*
+Controls::BelongToGeom::
+GetMeshDS() const
{
return myMeshDS;
}
myType(SMDSAbs_All)
{}
-void Controls::LyingOnGeom::SetMesh( SMDS_Mesh* theMesh )
+void Controls::LyingOnGeom::SetMesh( const SMDS_Mesh* theMesh )
{
- myMeshDS = dynamic_cast<SMESHDS_Mesh*>(theMesh);
+ myMeshDS = dynamic_cast<const SMESHDS_Mesh*>(theMesh);
}
void Controls::LyingOnGeom::SetGeom( const TopoDS_Shape& theShape )
return myShape;
}
-SMESHDS_Mesh* Controls::LyingOnGeom::GetMeshDS()
+const SMESHDS_Mesh*
+Controls::LyingOnGeom::
+GetMeshDS() const
{
return myMeshDS;
}
-bool Controls::LyingOnGeom::Contains( SMESHDS_Mesh* theMeshDS,
+bool Controls::LyingOnGeom::Contains( const SMESHDS_Mesh* theMeshDS,
const TopoDS_Shape& theShape,
const SMDS_MeshElement* theElem,
TopAbs_ShapeEnum theFindShapeEnum,
if (IsContains(theMeshDS, theShape, theElem, theFindShapeEnum, theAvoidShapeEnum))
return true;
- if ( SMESHDS_SubMesh* aSubMesh = theMeshDS->MeshElements( theShape ) )
- {
- SMDS_NodeIteratorPtr aNodeIt = aSubMesh->GetNodes();
- while ( aNodeIt->more() )
- {
- const SMDS_MeshNode* aNode = static_cast<const SMDS_MeshNode*>(aNodeIt->next());
- SMDS_ElemIteratorPtr anElemIt = aNode->GetInverseElementIterator();
- while ( anElemIt->more() )
- {
- const SMDS_MeshElement* anElement = static_cast<const SMDS_MeshElement*>(anElemIt->next());
- if (anElement == theElem)
- return true;
- }
- }
- }
+ TopTools_IndexedMapOfShape aSubShapes;
+ TopExp::MapShapes( theShape, aSubShapes );
- TopExp_Explorer anExp( theShape,TopAbs_VERTEX,theAvoidShapeEnum );
-
- while( anExp.More() )
- {
- const TopoDS_Shape& aShape = anExp.Current();
- if( SMESHDS_SubMesh* aSubMesh = theMeshDS->MeshElements( aShape ) ){
- SMDS_NodeIteratorPtr aNodeIt = aSubMesh->GetNodes();
- while ( aNodeIt->more() )
- {
- const SMDS_MeshNode* aNode = static_cast<const SMDS_MeshNode*>(aNodeIt->next());
- SMDS_ElemIteratorPtr anElemIt = aNode->GetInverseElementIterator();
- while ( anElemIt->more() )
- {
- const SMDS_MeshElement* anElement = static_cast<const SMDS_MeshElement*>(anElemIt->next());
- if (anElement == theElem)
- return true;
- }
- }
+ for (int i = 1; i <= aSubShapes.Extent(); i++)
+ {
+ const TopoDS_Shape& aShape = aSubShapes.FindKey(i);
+
+ if( SMESHDS_SubMesh* aSubMesh = theMeshDS->MeshElements( aShape ) ){
+ if( aSubMesh->Contains( theElem ) )
+ return true;
+
+ SMDS_NodeIteratorPtr aNodeIt = aSubMesh->GetNodes();
+ while ( aNodeIt->more() )
+ {
+ const SMDS_MeshNode* aNode = static_cast<const SMDS_MeshNode*>(aNodeIt->next());
+ SMDS_ElemIteratorPtr anElemIt = aNode->GetInverseElementIterator();
+ while ( anElemIt->more() )
+ {
+ const SMDS_MeshElement* anElement = static_cast<const SMDS_MeshElement*>(anElemIt->next());
+ if (anElement == theElem)
+ return true;
+ }
+ }
+ }
}
- anExp.Next();
- }
return false;
}
AUXILIARY METHODS
*/
-static inline SMDS_Mesh* MeshPtr2SMDSMesh( SMESH_Mesh_ptr theMesh )
+inline
+const SMDS_Mesh*
+MeshPtr2SMDSMesh( SMESH_Mesh_ptr theMesh )
{
- SMESH_Mesh_i* anImplPtr =
- dynamic_cast<SMESH_Mesh_i*>( SMESH_Gen_i::GetServant( theMesh ).in() );
+ SMESH_Mesh_i* anImplPtr = DownCast<SMESH_Mesh_i*>(theMesh);
return anImplPtr ? anImplPtr->GetImpl().GetMeshDS() : 0;
}
-static inline SMESH::long_array* toArray( const TColStd_ListOfInteger& aList )
+inline
+SMESH::long_array*
+toArray( const TColStd_ListOfInteger& aList )
{
SMESH::long_array_var anArray = new SMESH::long_array;
anArray->length( aList.Extent() );
return anArray._retn();
}
-static inline SMESH::double_array* toArray( const TColStd_ListOfReal& aList )
+inline
+SMESH::double_array*
+toArray( const TColStd_ListOfReal& aList )
{
SMESH::double_array_var anArray = new SMESH::double_array;
anArray->length( aList.Extent() );
Functor_i::Functor_i():
SALOME::GenericObj_i( SMESH_Gen_i::GetPOA() )
{
- SMESH_Gen_i::GetPOA()->activate_object( this );
+ PortableServer::ObjectId_var anObjectId =
+ SMESH_Gen_i::GetPOA()->activate_object( this );
+}
+
+Functor_i::~Functor_i()
+{
+ TPythonDump()<<this<<".Destroy()";
}
void Functor_i::SetMesh( SMESH_Mesh_ptr theMesh )
{
myFunctorPtr->SetMesh( MeshPtr2SMDSMesh( theMesh ) );
- INFOS("Functor_i::SetMesh~");
+ TPythonDump()<<this<<".SetMesh("<<theMesh<<")";
}
ElementType Functor_i::GetElementType()
void NumericalFunctor_i::SetPrecision( CORBA::Long thePrecision )
{
myNumericalFunctorPtr->SetPrecision( thePrecision );
+ TPythonDump()<<this<<".SetPrecision("<<thePrecision<<")";
}
CORBA::Long NumericalFunctor_i::GetPrecision()
return myPredicatePtr;
}
+/*
+ Class : BadOrientedVolume_i
+ Description : Verify whether a mesh volume is incorrectly oriented from
+ the point of view of MED convention
+*/
+BadOrientedVolume_i::BadOrientedVolume_i()
+{
+ Controls::PredicatePtr control( new Controls::BadOrientedVolume() );
+ myFunctorPtr = myPredicatePtr = control;
+};
+
+FunctorType BadOrientedVolume_i::GetFunctorType()
+{
+ return SMESH::FT_BadOrientedVolume;
+}
/*
Class : BelongToGeom_i
GEOM::GEOM_Gen_var aGEOMGen = SMESH_Gen_i::GetGeomEngine();
TopoDS_Shape aLocShape = aSMESHGen->GetShapeReader()->GetShape( aGEOMGen, theGeom );
myBelongToGeomPtr->SetGeom( aLocShape );
+ TPythonDump()<<this<<".SetGeom("<<theGeom<<")";
}
void BelongToGeom_i::SetGeom( const TopoDS_Shape& theShape )
void BelongToGeom_i::SetElementType(ElementType theType){
myBelongToGeomPtr->SetType(SMDSAbs_ElementType(theType));
+ TPythonDump()<<this<<".SetElementType("<<theType<<")";
}
FunctorType BelongToGeom_i::GetFunctorType()
delete myShapeName;
myShapeName = strdup( theName );
myBelongToGeomPtr->SetGeom( getShapeByName( myShapeName ) );
+ TPythonDump()<<this<<".SetShapeName('"<<theName<<"')";
}
char* BelongToGeom_i::GetShapeName()
}
myElementsOnSurfacePtr->SetSurface( TopoDS_Shape(), (SMDSAbs_ElementType)theType );
+ TPythonDump()<<this<<".SetSurface("<<theGeom<<",'"<<theType<<"')";
}
void BelongToSurface_i::SetShapeName( const char* theName, ElementType theType )
delete myShapeName;
myShapeName = strdup( theName );
myElementsOnSurfacePtr->SetSurface( getShapeByName( myShapeName ), (SMDSAbs_ElementType)theType );
+ TPythonDump()<<this<<".SetShapeName('"<<theName<<"',"<<theType<<")";
}
char* BelongToSurface_i::GetShapeName()
void BelongToSurface_i::SetTolerance( CORBA::Double theToler )
{
myElementsOnSurfacePtr->SetTolerance( theToler );
+ TPythonDump()<<this<<".SetTolerance("<<theToler<<")";
}
CORBA::Double BelongToSurface_i::GetTolerance()
void BelongToPlane_i::SetPlane( GEOM::GEOM_Object_ptr theGeom, ElementType theType )
{
BelongToSurface_i::SetSurface( theGeom, theType );
+ TPythonDump()<<this<<".SetPlane("<<theGeom<<","<<theType<<")";
}
FunctorType BelongToPlane_i::GetFunctorType()
void BelongToCylinder_i::SetCylinder( GEOM::GEOM_Object_ptr theGeom, ElementType theType )
{
BelongToSurface_i::SetSurface( theGeom, theType );
+ TPythonDump()<<this<<".SetCylinder("<<theGeom<<","<<theType<<")";
}
FunctorType BelongToCylinder_i::GetFunctorType()
GEOM::GEOM_Gen_var aGEOMGen = SMESH_Gen_i::GetGeomEngine();
TopoDS_Shape aLocShape = aSMESHGen->GetShapeReader()->GetShape( aGEOMGen, theGeom );
myLyingOnGeomPtr->SetGeom( aLocShape );
+ TPythonDump()<<this<<".SetGeom("<<theGeom<<")";
}
void LyingOnGeom_i::SetGeom( const TopoDS_Shape& theShape )
void LyingOnGeom_i::SetElementType(ElementType theType){
myLyingOnGeomPtr->SetType(SMDSAbs_ElementType(theType));
+ TPythonDump()<<this<<".SetElementType("<<theType<<")";
}
FunctorType LyingOnGeom_i::GetFunctorType()
delete myShapeName;
myShapeName = strdup( theName );
myLyingOnGeomPtr->SetGeom( getShapeByName( myShapeName ) );
+ TPythonDump()<<this<<".SetShapeName('"<<theName<<"')";
}
char* LyingOnGeom_i::GetShapeName()
CORBA::Long iEnd = theIds.length();
for ( CORBA::Long i = 0; i < iEnd; i++ )
myRangeOfIdsPtr->AddToRange( theIds[ i ] );
+ TPythonDump()<<this<<".SetRange("<<theIds<<")";
}
CORBA::Boolean RangeOfIds_i::SetRangeStr( const char* theRange )
{
+ TPythonDump()<<this<<".SetRangeStr('"<<theRange<<"')";
return myRangeOfIdsPtr->SetRangeStr(
TCollection_AsciiString( (Standard_CString)theRange ) );
}
void RangeOfIds_i::SetElementType( ElementType theType )
{
myRangeOfIdsPtr->SetType( SMDSAbs_ElementType( theType ) );
+ TPythonDump()<<this<<".SetElementType("<<theType<<")";
}
FunctorType RangeOfIds_i::GetFunctorType()
void Comparator_i::SetMargin( CORBA::Double theValue )
{
myComparatorPtr->SetMargin( theValue );
+ TPythonDump()<<this<<".SetMargin("<<theValue<<")";
}
CORBA::Double Comparator_i::GetMargin()
if ( myNumericalFunctor )
myNumericalFunctor->Destroy();
- myNumericalFunctor = dynamic_cast<NumericalFunctor_i*>( SMESH_Gen_i::GetServant( theFunct ).in() );
+ myNumericalFunctor = DownCast<NumericalFunctor_i*>(theFunct);
if ( myNumericalFunctor )
{
myComparatorPtr->SetNumFunctor( myNumericalFunctor->GetNumericalFunctor() );
myNumericalFunctor->Register();
+ TPythonDump()<<this<<".SetNumFunctor("<<myNumericalFunctor<<")";
}
}
void EqualTo_i::SetTolerance( CORBA::Double theToler )
{
myEqualToPtr->SetTolerance( theToler );
+ TPythonDump()<<this<<".SetTolerance("<<theToler<<")";
}
CORBA::Double EqualTo_i::GetTolerance()
myPredicate->Destroy();
}
-void LogicalNOT_i::SetPredicate( Predicate_ptr thePred )
+void LogicalNOT_i::SetPredicate( Predicate_ptr thePredicate )
{
if ( myPredicate )
myPredicate->Destroy();
- myPredicate = dynamic_cast<Predicate_i*>( SMESH_Gen_i::GetServant( thePred ).in() );
+ myPredicate = SMESH::GetPredicate(thePredicate);
if ( myPredicate ){
myLogicalNOTPtr->SetPredicate(myPredicate->GetPredicate());
myPredicate->Register();
+ TPythonDump()<<this<<".SetPredicate("<<myPredicate<<")";
}
}
if ( myPredicate1 )
myPredicate1->Destroy();
- myPredicate1 = dynamic_cast<Predicate_i*>( SMESH_Gen_i::GetServant( thePredicate ).in() );
+ myPredicate1 = SMESH::GetPredicate(thePredicate);
if ( myPredicate1 ){
myLogicalBinaryPtr->SetPredicate1(myPredicate1->GetPredicate());
myPredicate1->Register();
+ TPythonDump()<<this<<".SetPredicate1("<<myPredicate1<<")";
}
}
if ( myPredicate2 )
myPredicate2->Destroy();
- myPredicate2 = dynamic_cast<Predicate_i*>( SMESH_Gen_i::GetServant( thePredicate ).in() );
+ myPredicate2 = SMESH::GetPredicate(thePredicate);
if ( myPredicate2 ){
myLogicalBinaryPtr->SetPredicate2(myPredicate2->GetPredicate());
myPredicate2->Register();
+ TPythonDump()<<this<<".SetPredicate2("<<myPredicate2<<")";
}
}
FilterManager_i::FilterManager_i()
: SALOME::GenericObj_i( SMESH_Gen_i::GetPOA() )
{
- SMESH_Gen_i::GetPOA()->activate_object( this );
+ PortableServer::ObjectId_var anObjectId =
+ SMESH_Gen_i::GetPOA()->activate_object( this );
}
+
+FilterManager_i::~FilterManager_i()
+{
+ TPythonDump()<<this<<".Destroy()";
+}
+
+
MinimumAngle_ptr FilterManager_i::CreateMinimumAngle()
{
SMESH::MinimumAngle_i* aServant = new SMESH::MinimumAngle_i();
SMESH::MinimumAngle_var anObj = aServant->_this();
+ TPythonDump()<<aServant<<" = "<<this<<".CreateMinimumAngle()";
return anObj._retn();
}
{
SMESH::AspectRatio_i* aServant = new SMESH::AspectRatio_i();
SMESH::AspectRatio_var anObj = aServant->_this();
+ TPythonDump()<<aServant<<" = "<<this<<".CreateAspectRatio()";
return anObj._retn();
}
{
SMESH::AspectRatio3D_i* aServant = new SMESH::AspectRatio3D_i();
SMESH::AspectRatio3D_var anObj = aServant->_this();
+ TPythonDump()<<aServant<<" = "<<this<<".CreateAspectRatio3D()";
return anObj._retn();
}
{
SMESH::Warping_i* aServant = new SMESH::Warping_i();
SMESH::Warping_var anObj = aServant->_this();
+ TPythonDump()<<aServant<<" = "<<this<<".CreateWarping()";
return anObj._retn();
}
{
SMESH::Taper_i* aServant = new SMESH::Taper_i();
SMESH::Taper_var anObj = aServant->_this();
+ TPythonDump()<<aServant<<" = "<<this<<".CreateTaper()";
return anObj._retn();
}
{
SMESH::Skew_i* aServant = new SMESH::Skew_i();
SMESH::Skew_var anObj = aServant->_this();
+ TPythonDump()<<aServant<<" = "<<this<<".CreateSkew()";
return anObj._retn();
}
{
SMESH::Area_i* aServant = new SMESH::Area_i();
SMESH::Area_var anObj = aServant->_this();
+ TPythonDump()<<aServant<<" = "<<this<<".CreateArea()";
return anObj._retn();
}
{
SMESH::Length_i* aServant = new SMESH::Length_i();
SMESH::Length_var anObj = aServant->_this();
+ TPythonDump()<<aServant<<" = "<<this<<".CreateLength()";
return anObj._retn();
}
{
SMESH::Length2D_i* aServant = new SMESH::Length2D_i();
SMESH::Length2D_var anObj = aServant->_this();
+ TPythonDump()<<aServant<<" = "<<this<<".CreateLength2D()";
return anObj._retn();
}
{
SMESH::MultiConnection_i* aServant = new SMESH::MultiConnection_i();
SMESH::MultiConnection_var anObj = aServant->_this();
+ TPythonDump()<<aServant<<" = "<<this<<".CreateMultiConnection()";
return anObj._retn();
}
{
SMESH::MultiConnection2D_i* aServant = new SMESH::MultiConnection2D_i();
SMESH::MultiConnection2D_var anObj = aServant->_this();
+ TPythonDump()<<aServant<<" = "<<this<<".CreateMultiConnection2D()";
return anObj._retn();
}
{
SMESH::BelongToGeom_i* aServant = new SMESH::BelongToGeom_i();
SMESH::BelongToGeom_var anObj = aServant->_this();
+ TPythonDump()<<aServant<<" = "<<this<<".CreateBelongToGeom()";
return anObj._retn();
}
{
SMESH::BelongToPlane_i* aServant = new SMESH::BelongToPlane_i();
SMESH::BelongToPlane_var anObj = aServant->_this();
+ TPythonDump()<<aServant<<" = "<<this<<".CreateBelongToPlane()";
return anObj._retn();
}
{
SMESH::BelongToCylinder_i* aServant = new SMESH::BelongToCylinder_i();
SMESH::BelongToCylinder_var anObj = aServant->_this();
+ TPythonDump()<<aServant<<" = "<<this<<".CreateBelongToCylinder()";
return anObj._retn();
}
{
SMESH::LyingOnGeom_i* aServant = new SMESH::LyingOnGeom_i();
SMESH::LyingOnGeom_var anObj = aServant->_this();
+ TPythonDump()<<aServant<<" = "<<this<<".CreateLyingOnGeom()";
return anObj._retn();
}
{
SMESH::FreeBorders_i* aServant = new SMESH::FreeBorders_i();
SMESH::FreeBorders_var anObj = aServant->_this();
+ TPythonDump()<<aServant<<" = "<<this<<".CreateFreeBorders()";
return anObj._retn();
}
{
SMESH::FreeEdges_i* aServant = new SMESH::FreeEdges_i();
SMESH::FreeEdges_var anObj = aServant->_this();
+ TPythonDump()<<aServant<<" = "<<this<<".CreateFreeEdges()";
return anObj._retn();
}
{
SMESH::RangeOfIds_i* aServant = new SMESH::RangeOfIds_i();
SMESH::RangeOfIds_var anObj = aServant->_this();
+ TPythonDump()<<aServant<<" = "<<this<<".CreateRangeOfIds()";
+ return anObj._retn();
+}
+
+BadOrientedVolume_ptr FilterManager_i::CreateBadOrientedVolume()
+{
+ SMESH::BadOrientedVolume_i* aServant = new SMESH::BadOrientedVolume_i();
+ SMESH::BadOrientedVolume_var anObj = aServant->_this();
+ TPythonDump()<<aServant<<" = "<<this<<".CreateBadOrientedVolume()";
return anObj._retn();
}
{
SMESH::LessThan_i* aServant = new SMESH::LessThan_i();
SMESH::LessThan_var anObj = aServant->_this();
+ TPythonDump()<<aServant<<" = "<<this<<".CreateLessThan()";
return anObj._retn();
}
{
SMESH::MoreThan_i* aServant = new SMESH::MoreThan_i();
SMESH::MoreThan_var anObj = aServant->_this();
+ TPythonDump()<<aServant<<" = "<<this<<".CreateMoreThan()";
return anObj._retn();
}
{
SMESH::EqualTo_i* aServant = new SMESH::EqualTo_i();
SMESH::EqualTo_var anObj = aServant->_this();
+ TPythonDump()<<aServant<<" = "<<this<<".CreateEqualTo()";
return anObj._retn();
}
{
SMESH::LogicalNOT_i* aServant = new SMESH::LogicalNOT_i();
SMESH::LogicalNOT_var anObj = aServant->_this();
+ TPythonDump()<<aServant<<" = "<<this<<".CreateLogicalNOT()";
return anObj._retn();
}
{
SMESH::LogicalAND_i* aServant = new SMESH::LogicalAND_i();
SMESH::LogicalAND_var anObj = aServant->_this();
+ TPythonDump()<<aServant<<" = "<<this<<".CreateLogicalAND()";
return anObj._retn();
}
{
SMESH::LogicalOR_i* aServant = new SMESH::LogicalOR_i();
SMESH::LogicalOR_var anObj = aServant->_this();
+ TPythonDump()<<aServant<<" = "<<this<<".CreateLogicalOR()";
return anObj._retn();
}
{
SMESH::Filter_i* aServant = new SMESH::Filter_i();
SMESH::Filter_var anObj = aServant->_this();
+ TPythonDump()<<aServant<<" = "<<this<<".CreateFilter()";
return anObj._retn();
}
{
SMESH::FilterLibrary_i* aServant = new SMESH::FilterLibrary_i( aFileName );
SMESH::FilterLibrary_var anObj = aServant->_this();
+ TPythonDump()<<aServant<<" = "<<this<<".LoadLibrary("<<aFileName<<")";
return anObj._retn();
}
{
SMESH::FilterLibrary_i* aServant = new SMESH::FilterLibrary_i();
SMESH::FilterLibrary_var anObj = aServant->_this();
+ TPythonDump()<<aServant<<" = "<<this<<".CreateLibrary()";
return anObj._retn();
}
CORBA::Boolean FilterManager_i::DeleteLibrary( const char* aFileName )
{
+ TPythonDump()<<this<<".DeleteLibrary("<<aFileName<<")";
return remove( aFileName ) ? false : true;
}
{
if ( myPredicate )
myPredicate->Destroy();
+
+ if(!CORBA::is_nil(myMesh))
+ myMesh->Destroy();
+
+ TPythonDump()<<this<<".Destroy()";
}
//=======================================================================
if ( myPredicate )
myPredicate->Destroy();
- myPredicate = dynamic_cast<Predicate_i*>( SMESH_Gen_i::GetServant( thePredicate ).in() );
+ myPredicate = SMESH::GetPredicate(thePredicate);
if ( myPredicate )
{
myFilter.SetPredicate( myPredicate->GetPredicate() );
myPredicate->Register();
+ TPythonDump()<<this<<".SetPredicate("<<myPredicate<<")";
}
}
// name : Filter_i::SetMesh
// Purpose : Set mesh
//=======================================================================
-void Filter_i::SetMesh( SMESH_Mesh_ptr theMesh )
+void
+Filter_i::
+SetMesh( SMESH_Mesh_ptr theMesh )
{
- if ( myPredicate )
- myPredicate->SetMesh( theMesh );
+ if(!CORBA::is_nil(theMesh))
+ theMesh->Register();
+
+ if(!CORBA::is_nil(myMesh))
+ myMesh->Destroy();
+
+ myMesh = theMesh;
+ TPythonDump()<<this<<".SetMesh("<<theMesh<<")";
+}
+
+SMESH::long_array*
+Filter_i::
+GetIDs()
+{
+ return GetElementsId(myMesh);
}
//=======================================================================
// name : Filter_i::GetElementsId
// Purpose : Get ids of entities
//=======================================================================
-SMESH::long_array* Filter_i::GetElementsId( SMESH_Mesh_ptr theMesh )
+void
+Filter_i::
+GetElementsId( Predicate_i* thePredicate,
+ const SMDS_Mesh* theMesh,
+ Controls::Filter::TIdSequence& theSequence )
{
- SMDS_Mesh* aMesh = MeshPtr2SMDSMesh(theMesh);
- Controls::Filter::TIdSequence aSequence = myFilter.GetElementsId(aMesh);
-
- SMESH::long_array_var anArray = new SMESH::long_array;
- long i = 0, iEnd = aSequence.size();
+ Controls::Filter::GetElementsId(theMesh,thePredicate->GetPredicate(),theSequence);
+}
- anArray->length( iEnd );
- for ( ; i < iEnd; i++ )
- anArray[ i ] = aSequence[i];
+void
+Filter_i::
+GetElementsId( Predicate_i* thePredicate,
+ SMESH_Mesh_ptr theMesh,
+ Controls::Filter::TIdSequence& theSequence )
+{
+ if(const SMDS_Mesh* aMesh = MeshPtr2SMDSMesh(theMesh))
+ Controls::Filter::GetElementsId(aMesh,thePredicate->GetPredicate(),theSequence);
+}
+SMESH::long_array*
+Filter_i::
+GetElementsId( SMESH_Mesh_ptr theMesh )
+{
+ SMESH::long_array_var anArray = new SMESH::long_array;
+ if(!CORBA::is_nil(theMesh)){
+ Controls::Filter::TIdSequence aSequence;
+ GetElementsId(myPredicate,theMesh,aSequence);
+ long i = 0, iEnd = aSequence.size();
+ anArray->length( iEnd );
+ for ( ; i < iEnd; i++ )
+ anArray[ i ] = aSequence[i];
+ }
return anArray._retn();
}
theCriteria[ i ].ThresholdStr = aPred->GetRangeStr();
theCriteria[ i ].TypeOfElement = aPred->GetElementType();
+ return true;
+ }
+ case FT_BadOrientedVolume:
+ {
+ BadOrientedVolume_i* aPred = dynamic_cast<BadOrientedVolume_i*>( thePred );
+
+ CORBA::ULong i = theCriteria->length();
+ theCriteria->length( i + 1 );
+
+ theCriteria[ i ] = createCriterion();
+
+ theCriteria[ i ].Type = FT_BadOrientedVolume;
+ theCriteria[ i ].TypeOfElement = aPred->GetElementType();
+
return true;
}
case FT_LessThan:
if ( myPredicate != 0 )
myPredicate->Destroy();
- SMESH::FilterManager_i* aFilter = new SMESH::FilterManager_i();
- FilterManager_ptr aFilterMgr = aFilter->_this();
-
+ SMESH::FilterManager_i* aFilter = new SMESH::FilterManager_i();
+ FilterManager_ptr aFilterMgr = aFilter->_this();
+
// CREATE two lists ( PREDICATES and LOG OP )
// Criterion
+ TPythonDump()<<"aCriteria = []";
std::list<SMESH::Predicate_ptr> aPredicates;
std::list<int> aBinaries;
for ( int i = 0, n = theCriteria.length(); i < n; i++ )
const char* aThresholdStr = theCriteria[ i ].ThresholdStr;
ElementType aTypeOfElem = theCriteria[ i ].TypeOfElement;
long aPrecision = theCriteria[ i ].Precision;
+
+ TPythonDump()<<"aCriteria.append(SMESH.Filter.Criterion("<<
+ aCriterion<<","<<aCompare<<","<<aThreshold<<",'"<<aThresholdStr<<"',"<<
+ aUnary<<","<<aBinary<<","<<aTolerance<<","<<aTypeOfElem<<","<<aPrecision<<"))";
SMESH::Predicate_ptr aPredicate = SMESH::Predicate::_nil();
SMESH::NumericalFunctor_ptr aFunctor = SMESH::NumericalFunctor::_nil();
aPredicate = tmpPred;
}
break;
+ case SMESH::FT_BadOrientedVolume:
+ {
+ aPredicate = aFilterMgr->CreateBadOrientedVolume();
+ }
+ break;
default:
continue;
aBinaries.push_back( aBinary );
} // end of for
+ TPythonDump()<<this<<".SetCriteria(aCriteria)";
// CREATE ONE PREDICATE FROM PREVIOUSLY CREATED MAP
case FT_BelongToPlane : return "Belong to Plane";
case FT_BelongToCylinder: return "Belong to Cylinder";
case FT_LyingOnGeom : return "Lying on Geom";
+ case FT_BadOrientedVolume: return "Bad Oriented Volume";
case FT_RangeOfIds : return "Range of IDs";
case FT_FreeBorders : return "Free borders";
case FT_FreeEdges : return "Free edges";
else if ( theStr.equals( "Length" ) ) return FT_Length;
// else if ( theStr.equals( "Length2D" ) ) return FT_Length2D;
else if ( theStr.equals( "Range of IDs" ) ) return FT_RangeOfIds;
+ else if ( theStr.equals( "Bad Oriented Volume" ) ) return FT_BadOrientedVolume;
else if ( theStr.equals( "Less than" ) ) return FT_LessThan;
else if ( theStr.equals( "More than" ) ) return FT_MoreThan;
else if ( theStr.equals( "Equal to" ) ) return FT_EqualTo;
FilterLibrary_i::~FilterLibrary_i()
{
delete myFileName;
+ TPythonDump()<<this<<".Destroy()";
}
//=======================================================================
//=======================================================================
Filter_ptr FilterLibrary_i::Copy( const char* theFilterName )
{
- Filter_ptr aRes;
+ Filter_ptr aRes = Filter::_nil();
LDOM_Node aFilter = findFilter( theFilterName, myDoc );
if ( aFilter.isNull() )
aRes = myFilterMgr->CreateFilter();
aRes->SetCriteria( aCriteriaVar.inout() );
-
+
+ TPythonDump()<<this<<".Copy('"<<theFilterName<<"')";
+
return aRes;
}
{
delete myFileName;
myFileName = strdup( theFileName );
+ TPythonDump()<<this<<".SetFileName('"<<theFileName<<"')";
}
//=======================================================================
else
{
aSection.appendChild( aFilterItem );
+ if(Filter_i* aFilter = DownCast<Filter_i*>(theFilter))
+ TPythonDump()<<this<<".Add('"<<theFilterName<<"',"<<aFilter<<")";
return true;
}
}
else
{
aSection.appendChild( aFilterItem );
+ TPythonDump()<<this<<".AddEmpty('"<<theFilterName<<"',"<<theType<<")";
return true;
}
}
return false;
aParentNode.removeChild( aFilterNode );
+ TPythonDump()<<this<<".Delete('"<<theFilterName<<"')";
return true;
}
else
{
aFilterItem.ReplaceElement( aNewItem );
+ if(Filter_i* aFilter = DownCast<Filter_i*>(theFilter))
+ TPythonDump()<<this<<".Replace('"<<theFilterName<<"',"<<theNewName<<"',"<<aFilter<<")";
return true;
}
}
aWriter << myDoc;
fclose( aOutFile );
+ TPythonDump()<<this<<".Save()";
return true;
}
CORBA::Boolean FilterLibrary_i::SaveAs( const char* aFileName )
{
myFileName = strdup ( aFileName );
+ TPythonDump()<<this<<".SaveAs('"<<aFileName<<"')";
return Save();
}
