-// SMESH SMESH_I : idl implementation based on 'SMESH' unit's calsses
+// Copyright (C) 2007-2016 CEA/DEN, EDF R&D, OPEN CASCADE
//
-// Copyright (C) 2003 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
-// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
+// 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.
+// 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, or (at your option) any later version.
//
-// 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.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org
+// 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 classes
// File : SMESH_Filter_i.cxx
// Author : Alexey Petrov, OCC
// Module : SMESH
-
#include "SMESH_Filter_i.hxx"
-#include "SMESH_Gen_i.hxx"
-#include "SMESH_PythonDump.hxx"
-
+#include "SMDS_ElemIterator.hxx"
#include "SMDS_Mesh.hxx"
-#include "SMDS_MeshNode.hxx"
#include "SMDS_MeshElement.hxx"
-
+#include "SMDS_MeshNode.hxx"
+#include "SMESHDS_GroupBase.hxx"
#include "SMESHDS_Mesh.hxx"
+#include "SMESH_Gen_i.hxx"
+#include "SMESH_Group_i.hxx"
+#include "SMESH_PythonDump.hxx"
+#include <SALOMEDS_wrap.hxx>
+#include <GEOM_wrap.hxx>
+
+#include <BRep_Tool.hxx>
+#include <Geom_CylindricalSurface.hxx>
+#include <Geom_Plane.hxx>
+#include <LDOMParser.hxx>
+#include <LDOMString.hxx>
#include <LDOM_Document.hxx>
#include <LDOM_Element.hxx>
#include <LDOM_Node.hxx>
-#include <LDOMString.hxx>
-#include <LDOMParser.hxx>
#include <LDOM_XmlWriter.hxx>
-#include <TCollection_HAsciiString.hxx>
+#include <Precision.hxx>
#include <TColStd_ListIteratorOfListOfInteger.hxx>
+#include <TColStd_ListIteratorOfListOfReal.hxx>
#include <TColStd_ListOfInteger.hxx>
#include <TColStd_ListOfReal.hxx>
-#include <TColStd_MapOfInteger.hxx>
#include <TColStd_SequenceOfHAsciiString.hxx>
-#include <TColStd_ListIteratorOfListOfReal.hxx>
-#include <Precision.hxx>
-#include <BRep_Tool.hxx>
-#include <TopoDS_Shape.hxx>
-#include <TopoDS.hxx>
-#include <TopoDS_Face.hxx>
-#include <Geom_Plane.hxx>
-#include <Geom_CylindricalSurface.hxx>
+#include <TCollection_HAsciiString.hxx>
#include <TopExp_Explorer.hxx>
-#include <OSD_Path.hxx>
-#include <OSD_File.hxx>
+#include <TopoDS.hxx>
+#include <TopoDS_Shape.hxx>
using namespace SMESH;
using namespace SMESH::Controls;
}
}
-
-/*
- Class : BelongToGeom
- Description : Predicate for verifying whether entiy belong to
- specified geometrical support
-*/
-
-Controls::BelongToGeom::BelongToGeom()
-: myMeshDS(NULL),
- myType(SMDSAbs_All)
-{}
-
-void Controls::BelongToGeom::SetMesh( const SMDS_Mesh* theMesh )
-{
- myMeshDS = dynamic_cast<const SMESHDS_Mesh*>(theMesh);
-}
-
-void Controls::BelongToGeom::SetGeom( const TopoDS_Shape& theShape )
-{
- myShape = theShape;
-}
-
-static bool IsContains( const SMESHDS_Mesh* theMeshDS,
- const TopoDS_Shape& theShape,
- const SMDS_MeshElement* theElem,
- TopAbs_ShapeEnum theFindShapeEnum,
- TopAbs_ShapeEnum theAvoidShapeEnum = TopAbs_SHAPE )
-{
- TopExp_Explorer anExp( theShape,theFindShapeEnum,theAvoidShapeEnum );
-
- while( anExp.More() )
- {
- const TopoDS_Shape& aShape = anExp.Current();
- if( SMESHDS_SubMesh* aSubMesh = theMeshDS->MeshElements( aShape ) ){
- if( aSubMesh->Contains( theElem ) )
- return true;
- }
- anExp.Next();
- }
- return false;
-}
-
-bool Controls::BelongToGeom::IsSatisfy( long theId )
-{
- if ( myMeshDS == 0 || myShape.IsNull() )
- return false;
-
- if( myType == SMDSAbs_Node )
- {
- if( const SMDS_MeshNode* aNode = myMeshDS->FindNode( theId ) )
- {
- const SMDS_PositionPtr& aPosition = aNode->GetPosition();
- SMDS_TypeOfPosition aTypeOfPosition = aPosition->GetTypeOfPosition();
- switch( aTypeOfPosition )
- {
- case SMDS_TOP_VERTEX : return IsContains( myMeshDS,myShape,aNode,TopAbs_VERTEX );
- case SMDS_TOP_EDGE : return IsContains( myMeshDS,myShape,aNode,TopAbs_EDGE );
- case SMDS_TOP_FACE : return IsContains( myMeshDS,myShape,aNode,TopAbs_FACE );
- case SMDS_TOP_3DSPACE: return IsContains( myMeshDS,myShape,aNode,TopAbs_SHELL );
- }
- }
- }
- else
- {
- if( const SMDS_MeshElement* anElem = myMeshDS->FindElement( theId ) )
- {
- if( myType == SMDSAbs_All )
- {
- return IsContains( myMeshDS,myShape,anElem,TopAbs_EDGE ) ||
- IsContains( myMeshDS,myShape,anElem,TopAbs_FACE ) ||
- IsContains( myMeshDS,myShape,anElem,TopAbs_SHELL )||
- IsContains( myMeshDS,myShape,anElem,TopAbs_SOLID );
- }
- else if( myType == anElem->GetType() )
- {
- switch( myType )
- {
- case SMDSAbs_Edge : return IsContains( myMeshDS,myShape,anElem,TopAbs_EDGE );
- case SMDSAbs_Face : return IsContains( myMeshDS,myShape,anElem,TopAbs_FACE );
- case SMDSAbs_Volume: return IsContains( myMeshDS,myShape,anElem,TopAbs_SHELL )||
- IsContains( myMeshDS,myShape,anElem,TopAbs_SOLID );
- }
- }
- }
- }
-
- return false;
-}
-
-void Controls::BelongToGeom::SetType( SMDSAbs_ElementType theType )
-{
- myType = theType;
-}
-
-SMDSAbs_ElementType Controls::BelongToGeom::GetType() const
-{
- return myType;
-}
-
-TopoDS_Shape Controls::BelongToGeom::GetShape()
-{
- return myShape;
-}
-
-const SMESHDS_Mesh*
-Controls::BelongToGeom::
-GetMeshDS() const
-{
- return myMeshDS;
-}
-
-/*
- Class : LyingOnGeom
- Description : Predicate for verifying whether entiy lying or partially lying on
- specified geometrical support
-*/
-
-Controls::LyingOnGeom::LyingOnGeom()
-: myMeshDS(NULL),
- myType(SMDSAbs_All)
-{}
-
-void Controls::LyingOnGeom::SetMesh( const SMDS_Mesh* theMesh )
-{
- myMeshDS = dynamic_cast<const SMESHDS_Mesh*>(theMesh);
-}
-
-void Controls::LyingOnGeom::SetGeom( const TopoDS_Shape& theShape )
-{
- myShape = theShape;
-}
-
-bool Controls::LyingOnGeom::IsSatisfy( long theId )
-{
- if ( myMeshDS == 0 || myShape.IsNull() )
- return false;
-
- if( myType == SMDSAbs_Node )
- {
- if( const SMDS_MeshNode* aNode = myMeshDS->FindNode( theId ) )
- {
- const SMDS_PositionPtr& aPosition = aNode->GetPosition();
- SMDS_TypeOfPosition aTypeOfPosition = aPosition->GetTypeOfPosition();
- switch( aTypeOfPosition )
- {
- case SMDS_TOP_VERTEX : return IsContains( myMeshDS,myShape,aNode,TopAbs_VERTEX );
- case SMDS_TOP_EDGE : return IsContains( myMeshDS,myShape,aNode,TopAbs_EDGE );
- case SMDS_TOP_FACE : return IsContains( myMeshDS,myShape,aNode,TopAbs_FACE );
- case SMDS_TOP_3DSPACE: return IsContains( myMeshDS,myShape,aNode,TopAbs_SHELL );
- }
- }
- }
- else
- {
- if( const SMDS_MeshElement* anElem = myMeshDS->FindElement( theId ) )
- {
- if( myType == SMDSAbs_All )
- {
- return Contains( myMeshDS,myShape,anElem,TopAbs_EDGE ) ||
- Contains( myMeshDS,myShape,anElem,TopAbs_FACE ) ||
- Contains( myMeshDS,myShape,anElem,TopAbs_SHELL )||
- Contains( myMeshDS,myShape,anElem,TopAbs_SOLID );
- }
- else if( myType == anElem->GetType() )
- {
- switch( myType )
- {
- case SMDSAbs_Edge : return Contains( myMeshDS,myShape,anElem,TopAbs_EDGE );
- case SMDSAbs_Face : return Contains( myMeshDS,myShape,anElem,TopAbs_FACE );
- case SMDSAbs_Volume: return Contains( myMeshDS,myShape,anElem,TopAbs_SHELL )||
- Contains( myMeshDS,myShape,anElem,TopAbs_SOLID );
- }
- }
- }
- }
-
- return false;
-}
-
-void Controls::LyingOnGeom::SetType( SMDSAbs_ElementType theType )
-{
- myType = theType;
-}
-
-SMDSAbs_ElementType Controls::LyingOnGeom::GetType() const
-{
- return myType;
-}
-
-TopoDS_Shape Controls::LyingOnGeom::GetShape()
-{
- return myShape;
-}
-
-const SMESHDS_Mesh*
-Controls::LyingOnGeom::
-GetMeshDS() const
-{
- return myMeshDS;
-}
-
-bool Controls::LyingOnGeom::Contains( const SMESHDS_Mesh* theMeshDS,
- const TopoDS_Shape& theShape,
- const SMDS_MeshElement* theElem,
- TopAbs_ShapeEnum theFindShapeEnum,
- TopAbs_ShapeEnum theAvoidShapeEnum )
-{
- if (IsContains(theMeshDS, theShape, theElem, theFindShapeEnum, theAvoidShapeEnum))
- return true;
-
- TopTools_IndexedMapOfShape aSubShapes;
- TopExp::MapShapes( theShape, aSubShapes );
-
- 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;
- }
- }
- }
- }
- return false;
-}
-
-
/*
AUXILIARY METHODS
*/
{
if ( theName != 0 )
{
- SMESH_Gen_i* aSMESHGen = SMESH_Gen_i::GetSMESHGen();
- SALOMEDS::Study_ptr aStudy = aSMESHGen->GetCurrentStudy();
- if (!CORBA::is_nil(aStudy))
+ SMESH_Gen_i* aSMESHGen = SMESH_Gen_i::GetSMESHGen();
+ SALOMEDS::Study::ListOfSObject_var aList = SMESH_Gen_i::getStudyServant()->FindObjectByName( theName, "GEOM" );
+ if ( aList->length() > 0 )
{
- SALOMEDS::Study::ListOfSObject_var aList =
- aStudy->FindObjectByName( theName, "GEOM" );
- if ( aList->length() > 0 )
- {
- GEOM::GEOM_Object_var aGeomObj = GEOM::GEOM_Object::_narrow( aList[ 0 ]->GetObject() );
- if ( !aGeomObj->_is_nil() )
- {
- GEOM::GEOM_Gen_var aGEOMGen = SMESH_Gen_i::GetGeomEngine();
- TopoDS_Shape aLocShape = aSMESHGen->GetShapeReader()->GetShape( aGEOMGen, aGeomObj );
- return aLocShape;
- }
- }
+ CORBA::Object_var anObj = aList[ 0 ]->GetObject();
+ GEOM::GEOM_Object_var aGeomObj = GEOM::GEOM_Object::_narrow( anObj );
+ TopoDS_Shape shape = aSMESHGen->GeomObjectToShape( aGeomObj );
+ SALOME::UnRegister( aList ); // UnRegister() objects in aList
+ return shape;
}
}
return TopoDS_Shape();
}
-static TopoDS_Shape getShapeByID( const char* theID )
+static TopoDS_Shape getShapeByID (const char* theID)
{
- if ( theID != 0 && theID!="" )
- {
- SMESH_Gen_i* aSMESHGen = SMESH_Gen_i::GetSMESHGen();
- SALOMEDS::Study_ptr aStudy = aSMESHGen->GetCurrentStudy();
- if ( aStudy != 0 )
- {
- CORBA::Object_var obj = aStudy->ConvertIORToObject(theID);
- GEOM::GEOM_Object_var aGeomObj = GEOM::GEOM_Object::_narrow( obj );
-
- if ( !aGeomObj->_is_nil() )
- {
- GEOM::GEOM_Gen_var aGEOMGen = SMESH_Gen_i::GetGeomEngine();
- TopoDS_Shape aLocShape = aSMESHGen->GetShapeReader()->GetShape( aGEOMGen, aGeomObj );
- return aLocShape;
- }
+ if ( theID && strlen( theID ) > 0 ) {
+ SMESH_Gen_i* aSMESHGen = SMESH_Gen_i::GetSMESHGen();
+ SALOMEDS::SObject_wrap aSObj = SMESH_Gen_i::getStudyServant()->FindObjectID(theID);
+ if ( !aSObj->_is_nil() ) {
+ CORBA::Object_var obj = aSObj->GetObject();
+ GEOM::GEOM_Object_var aGeomObj = GEOM::GEOM_Object::_narrow(obj);
+ return aSMESHGen->GeomObjectToShape( aGeomObj );
}
}
return TopoDS_Shape();
}
-static char* getShapeNameByID ( const char* theID )
-{
- char* aName = "";
-
- if ( theID != 0 && theID!="" )
- {
- SMESH_Gen_i* aSMESHGen = SMESH_Gen_i::GetSMESHGen();
- SALOMEDS::Study_ptr aStudy = aSMESHGen->GetCurrentStudy();
- if ( aStudy != 0 )
- {
- SALOMEDS::SObject_var aSObj = aStudy->FindObjectIOR( theID );
- SALOMEDS::GenericAttribute_var anAttr;
- if ( !aSObj->_is_nil() && aSObj->FindAttribute( anAttr, "AttributeName") )
- {
- SALOMEDS::AttributeName_var aNameAttr = SALOMEDS::AttributeName::_narrow( anAttr );
- aName = aNameAttr->Value();
- }
- }
- }
-
- return aName;
-}
+// static std::string getShapeNameByID (const char* theID)
+// {
+// if ( theID && strlen( theID ) > 0 ) {
+// SALOMEDS::SObject_wrap aSObj = SMESH_Gen_i::getStudyServant()->FindObjectID(theID);
+// if ( !aSObj->_is_nil() ) {
+// CORBA::String_var name = aSObj->GetName();
+// return name.in();
+// }
+// }
+// return "";
+// }
/*
FUNCTORS
/*
Class : Functor_i
- Description : An abstact class for all functors
+ Description : An abstract class for all functors
*/
Functor_i::Functor_i():
SALOME::GenericObj_i( SMESH_Gen_i::GetPOA() )
{
- PortableServer::ObjectId_var anObjectId =
- SMESH_Gen_i::GetPOA()->activate_object( this );
+ //Base class Salome_GenericObject do it inmplicitly by overriding PortableServer::POA_ptr _default_POA() method
+ //PortableServer::ObjectId_var anObjectId =
+ // SMESH_Gen_i::GetPOA()->activate_object( this );
}
Functor_i::~Functor_i()
{
- TPythonDump()<<this<<".Destroy()";
+ //TPythonDump()<<this<<".UnRegister()";
}
void Functor_i::SetMesh( SMESH_Mesh_ptr theMesh )
return myNumericalFunctorPtr->GetValue( theId );
}
+SMESH::Histogram* NumericalFunctor_i::GetHistogram(CORBA::Short nbIntervals, CORBA::Boolean isLogarithmic)
+{
+ std::vector<int> nbEvents;
+ std::vector<double> funValues;
+ std::vector<int> elements;
+ myNumericalFunctorPtr->GetHistogram(nbIntervals,nbEvents,funValues,elements,0,isLogarithmic);
+
+ SMESH::Histogram_var histogram = new SMESH::Histogram;
+
+ nbIntervals = CORBA::Short( Min( int( nbEvents.size()),
+ int( funValues.size() - 1 )));
+ if ( nbIntervals > 0 )
+ {
+ histogram->length( nbIntervals );
+ for ( int i = 0; i < nbIntervals; ++i )
+ {
+ HistogramRectangle& rect = histogram[i];
+ rect.nbEvents = nbEvents[i];
+ rect.min = funValues[i];
+ rect.max = funValues[i+1];
+ }
+ }
+ return histogram._retn();
+}
+
+SMESH::Histogram* NumericalFunctor_i::GetLocalHistogram(CORBA::Short nbIntervals,
+ CORBA::Boolean isLogarithmic,
+ SMESH::SMESH_IDSource_ptr object)
+{
+ SMESH::Histogram_var histogram = new SMESH::Histogram;
+
+ std::vector<int> nbEvents;
+ std::vector<double> funValues;
+ std::vector<int> elements;
+
+ SMDS_ElemIteratorPtr elemIt;
+ if ( SMESH::DownCast< SMESH_GroupOnFilter_i* >( object ) ||
+ SMESH::DownCast< SMESH::Filter_i* >( object ))
+ {
+ elemIt = SMESH_Mesh_i::GetElements( object, GetElementType() );
+ if ( !elemIt ) return histogram._retn();
+ }
+ else
+ {
+ SMESH::SMESH_Mesh_var mesh = object->GetMesh();
+ SMESH::long_array_var objNbElems = object->GetNbElementsByType();
+ SMESH::long_array_var meshNbElems = mesh-> GetNbElementsByType();
+ if ( meshNbElems[ GetElementType() ] !=
+ objNbElems [ GetElementType() ] )
+ {
+ elements.reserve( objNbElems[ GetElementType() ]);
+ elemIt = SMESH_Mesh_i::GetElements( object, GetElementType() );
+ }
+ }
+ if ( elemIt )
+ {
+ while ( elemIt->more() )
+ elements.push_back( elemIt->next()->GetID() );
+ if ( elements.empty() ) return histogram._retn();
+ }
+
+ myNumericalFunctorPtr->GetHistogram(nbIntervals,nbEvents,funValues,elements,0,isLogarithmic);
+
+ nbIntervals = CORBA::Short( Min( int( nbEvents.size()),
+ int( funValues.size() - 1 )));
+ if ( nbIntervals > 0 )
+ {
+ histogram->length( nbIntervals );
+ for ( int i = 0; i < nbIntervals; ++i )
+ {
+ HistogramRectangle& rect = histogram[i];
+ rect.nbEvents = nbEvents[i];
+ rect.min = funValues[i];
+ rect.max = funValues[i+1];
+ }
+ }
+ return histogram._retn();
+}
+
void NumericalFunctor_i::SetPrecision( CORBA::Long thePrecision )
{
myNumericalFunctorPtr->SetPrecision( thePrecision );
return SMESH::FT_Taper;
}
-
/*
Class : Skew_i
Description : Functor for calculating skew in degrees
return SMESH::FT_Volume3D;
}
+/*
+ Class : MaxElementLength2D_i
+ Description : Functor for calculating maximum length of 2D element
+*/
+MaxElementLength2D_i::MaxElementLength2D_i()
+{
+ myNumericalFunctorPtr.reset( new Controls::MaxElementLength2D() );
+ myFunctorPtr = myNumericalFunctorPtr;
+}
+
+FunctorType MaxElementLength2D_i::GetFunctorType()
+{
+ return SMESH::FT_MaxElementLength2D;
+}
+
+/*
+ Class : MaxElementLength3D_i
+ Description : Functor for calculating maximum length of 3D element
+*/
+MaxElementLength3D_i::MaxElementLength3D_i()
+{
+ myNumericalFunctorPtr.reset( new Controls::MaxElementLength3D() );
+ myFunctorPtr = myNumericalFunctorPtr;
+}
+
+FunctorType MaxElementLength3D_i::GetFunctorType()
+{
+ return SMESH::FT_MaxElementLength3D;
+}
+
/*
Class : Length_i
Description : Functor for calculating length off edge
SMESH::Length2D::Values* Length2D_i::GetValues()
{
- INFOS("Length2D_i::GetValues");
SMESH::Controls::Length2D::TValues aValues;
- myLength2DPtr->GetValues( aValues );
+ (dynamic_cast<SMESH::Controls::Length2D*>(myFunctorPtr.get()))->GetValues( aValues );
long i = 0, iEnd = aValues.size();
SMESH::Length2D::Values_var aResult = new SMESH::Length2D::Values(iEnd);
+ aResult->length(iEnd);
SMESH::Controls::Length2D::TValues::const_iterator anIter;
for ( anIter = aValues.begin() ; anIter != aValues.end(); anIter++, i++ )
aValue.myPnt2 = aVal.myPntId[ 1 ];
}
- INFOS("Length2D_i::GetValuess~");
return aResult._retn();
}
+/*
+ Class : Deflection2D_i
+ Description : Functor for calculating distance between a face and geometry
+*/
+Deflection2D_i::Deflection2D_i()
+{
+ myNumericalFunctorPtr.reset( new Controls::Deflection2D() );
+ myFunctorPtr = myNumericalFunctorPtr;
+}
+
+FunctorType Deflection2D_i::GetFunctorType()
+{
+ return SMESH::FT_Deflection2D;
+}
+
/*
Class : MultiConnection_i
Description : Functor for calculating number of faces conneted to the edge
return SMESH::FT_MultiConnection;
}
+/*
+ Class : BallDiameter_i
+ Description : Functor returning diameter of a ball element
+*/
+BallDiameter_i::BallDiameter_i()
+{
+ myNumericalFunctorPtr.reset( new Controls::BallDiameter() );
+ myFunctorPtr = myNumericalFunctorPtr;
+}
+
+FunctorType BallDiameter_i::GetFunctorType()
+{
+ return SMESH::FT_BallDiameter;
+}
+
+/*
+ Class : NodeConnectivityNumber_i
+ Description : Functor returning diameter of a ball element
+*/
+NodeConnectivityNumber_i::NodeConnectivityNumber_i()
+{
+ myNumericalFunctorPtr.reset( new Controls::NodeConnectivityNumber() );
+ myFunctorPtr = myNumericalFunctorPtr;
+}
+
+FunctorType NodeConnectivityNumber_i::GetFunctorType()
+{
+ return SMESH::FT_NodeConnectivityNumber;
+}
+
/*
Class : MultiConnection2D_i
Description : Functor for calculating number of faces conneted to the edge
SMESH::MultiConnection2D::Values* MultiConnection2D_i::GetValues()
{
- INFOS("MultiConnection2D_i::GetValues");
SMESH::Controls::MultiConnection2D::MValues aValues;
- myMulticonnection2DPtr->GetValues( aValues );
-
+ (dynamic_cast<SMESH::Controls::MultiConnection2D*>(myFunctorPtr.get()))->GetValues( aValues );
+
long i = 0, iEnd = aValues.size();
SMESH::MultiConnection2D::Values_var aResult = new SMESH::MultiConnection2D::Values(iEnd);
+ aResult->length(iEnd);
SMESH::Controls::MultiConnection2D::MValues::const_iterator anIter;
for ( anIter = aValues.begin() ; anIter != aValues.end(); anIter++, i++ )
aValue.myNbConnects = (*anIter).second;
}
- INFOS("Multiconnection2D_i::GetValuess~");
return aResult._retn();
}
return myPredicatePtr->IsSatisfy( theId );
}
+CORBA::Long Predicate_i::NbSatisfying( SMESH::SMESH_IDSource_ptr obj )
+{
+ SMESH::SMESH_Mesh_var meshVar = obj->GetMesh();
+ const SMDS_Mesh* meshDS = MeshPtr2SMDSMesh( meshVar );
+ if ( !meshDS )
+ return 0;
+ myPredicatePtr->SetMesh( meshDS );
+
+ SMDSAbs_ElementType elemType = SMDSAbs_ElementType( GetElementType() );
+
+ int nb = 0;
+ SMDS_ElemIteratorPtr elemIt =
+ SMESH::DownCast<SMESH_Mesh_i*>( meshVar )->GetElements( obj, GetElementType() );
+ if ( elemIt )
+ while ( elemIt->more() )
+ {
+ const SMDS_MeshElement* e = elemIt->next();
+ if ( e && e->GetType() == elemType )
+ nb += myPredicatePtr->IsSatisfy( e->GetID() );
+ }
+ return nb;
+}
+
Controls::PredicatePtr Predicate_i::GetPredicate()
{
return myPredicatePtr;
}
/*
- Class : BelongToGeom_i
- Description : Predicate for selection on geometrical support
+ Class : BareBorderVolume_i
+ Description : Verify whether a mesh volume has a free facet without a face on it
*/
-BelongToGeom_i::BelongToGeom_i()
+BareBorderVolume_i::BareBorderVolume_i()
{
- myBelongToGeomPtr.reset( new Controls::BelongToGeom() );
- myFunctorPtr = myPredicatePtr = myBelongToGeomPtr;
- myShapeName = 0;
- myShapeID = 0;
+ Controls::PredicatePtr control( new Controls::BareBorderVolume() );
+ myFunctorPtr = myPredicatePtr = control;
+};
+
+FunctorType BareBorderVolume_i::GetFunctorType()
+{
+ return SMESH::FT_BareBorderVolume;
+}
+
+/*
+ Class : BareBorderFace_i
+ Description : Verify whether a mesh face has a free border without an edge on it
+*/
+BareBorderFace_i::BareBorderFace_i()
+{
+ Controls::PredicatePtr control( new Controls::BareBorderFace() );
+ myFunctorPtr = myPredicatePtr = control;
+};
+
+FunctorType BareBorderFace_i::GetFunctorType()
+{
+ return SMESH::FT_BareBorderFace;
+}
+
+/*
+ Class : OverConstrainedVolume_i
+ Description : Verify whether a mesh volume has only one facet shared with other volumes
+*/
+OverConstrainedVolume_i::OverConstrainedVolume_i()
+{
+ Controls::PredicatePtr control( new Controls::OverConstrainedVolume() );
+ myFunctorPtr = myPredicatePtr = control;
+};
+
+FunctorType OverConstrainedVolume_i::GetFunctorType()
+{
+ return SMESH::FT_OverConstrainedVolume;
+}
+
+/*
+ Class : OverConstrainedFace_i
+ Description : Verify whether a mesh face has only one border shared with other faces
+*/
+OverConstrainedFace_i::OverConstrainedFace_i()
+{
+ Controls::PredicatePtr control( new Controls::OverConstrainedFace() );
+ myFunctorPtr = myPredicatePtr = control;
+};
+
+FunctorType OverConstrainedFace_i::GetFunctorType()
+{
+ return SMESH::FT_OverConstrainedFace;
+}
+
+/*
+ Class : BelongToMeshGroup_i
+ Description : Verify whether a mesh element is included into a mesh group
+*/
+BelongToMeshGroup_i::BelongToMeshGroup_i()
+{
+ myBelongToMeshGroup = Controls::BelongToMeshGroupPtr( new Controls::BelongToMeshGroup() );
+ myFunctorPtr = myPredicatePtr = myBelongToMeshGroup;
+}
+
+BelongToMeshGroup_i::~BelongToMeshGroup_i()
+{
+ SetGroup( SMESH::SMESH_GroupBase::_nil() );
+}
+
+void BelongToMeshGroup_i::SetGroup( SMESH::SMESH_GroupBase_ptr theGroup )
+{
+ if ( myGroup->_is_equivalent( theGroup ))
+ return;
+
+ if ( ! myGroup->_is_nil() )
+ myGroup->UnRegister();
+
+ myGroup = SMESH_GroupBase::_duplicate( theGroup );
+
+ myBelongToMeshGroup->SetGroup( 0 );
+ if ( SMESH_GroupBase_i* gr_i = SMESH::DownCast< SMESH_GroupBase_i* >( myGroup ))
+ {
+ myBelongToMeshGroup->SetGroup( gr_i->GetGroupDS() );
+ myGroup->Register();
+ }
+}
+
+void BelongToMeshGroup_i::SetGroupID( const char* theID ) // IOR or StoreName
+{
+ myID = theID;
+ if ( strncmp( "IOR:", myID.c_str(), 4 ) == 0 ) // transient mode, no GUI
+ {
+ CORBA::Object_var obj = SMESH_Gen_i::GetORB()->string_to_object( myID.c_str() );
+ SetGroup( SMESH::SMESH_GroupBase::_narrow( obj ));
+ }
+ else if ( strncmp( "0:", myID.c_str(), 2 ) == 0 ) // transient mode + GUI
+ {
+ SALOMEDS::SObject_wrap aSObj = SMESH_Gen_i::getStudyServant()->FindObjectID( myID.c_str() );
+ if ( !aSObj->_is_nil() ) {
+ CORBA::Object_var obj = aSObj->GetObject();
+ SetGroup( SMESH::SMESH_GroupBase::_narrow( obj ));
+ }
+ }
+ else if ( !myID.empty() ) // persistent mode
+ {
+ myBelongToMeshGroup->SetStoreName( myID );
+ }
+}
+
+std::string BelongToMeshGroup_i::GetGroupID()
+{
+ if ( myGroup->_is_nil() )
+ SMESH::SMESH_GroupBase_var( GetGroup() );
+
+ if ( !myGroup->_is_nil() )
+ myID = SMESH_Gen_i::GetORB()->object_to_string( myGroup );
+
+ return myID;
+}
+
+SMESH::SMESH_GroupBase_ptr BelongToMeshGroup_i::GetGroup()
+{
+ if ( myGroup->_is_nil() && myBelongToMeshGroup->GetGroup() )
+ {
+ // search for a group in a current study
+ SMESH_Gen_i* aSMESHGen = SMESH_Gen_i::GetSMESHGen();
+ if ( StudyContext* sc = aSMESHGen->GetStudyContext() )
+ {
+ int id = 1;
+ std::string ior;
+ while (true)
+ {
+ ior = sc->getIORbyId( id++ );
+ if ( ior.empty() ) break;
+ CORBA::Object_var obj = aSMESHGen->GetORB()->string_to_object( ior.c_str() );
+ if ( SMESH_GroupBase_i* g_i = SMESH::DownCast<SMESH_GroupBase_i*>( obj ))
+ if ( g_i->GetGroupDS() == myBelongToMeshGroup->GetGroup() )
+ {
+ SetGroup( g_i->_this() );
+ break;
+ }
+ }
+ }
+ }
+ return SMESH::SMESH_GroupBase::_duplicate( myGroup );
+}
+
+FunctorType BelongToMeshGroup_i::GetFunctorType()
+{
+ return SMESH::FT_BelongToMeshGroup;
+}
+
+/*
+ Class : BelongToGeom_i
+ Description : Predicate for selection on geometrical support
+*/
+BelongToGeom_i::BelongToGeom_i()
+{
+ myBelongToGeomPtr.reset( new Controls::BelongToGeom() );
+ myFunctorPtr = myPredicatePtr = myBelongToGeomPtr;
+ myShapeName = 0;
+ myShapeID = 0;
}
BelongToGeom_i::~BelongToGeom_i()
{
- delete myShapeName;
- delete myShapeID;
+ CORBA::string_free( myShapeName );
+ CORBA::string_free( myShapeID );
}
void BelongToGeom_i::SetGeom( GEOM::GEOM_Object_ptr theGeom )
if ( theGeom->_is_nil() )
return;
SMESH_Gen_i* aSMESHGen = SMESH_Gen_i::GetSMESHGen();
- GEOM::GEOM_Gen_var aGEOMGen = SMESH_Gen_i::GetGeomEngine();
+ GEOM::GEOM_Gen_ptr aGEOMGen = SMESH_Gen_i::GetGeomEngine();
TopoDS_Shape aLocShape = aSMESHGen->GetShapeReader()->GetShape( aGEOMGen, theGeom );
myBelongToGeomPtr->SetGeom( aLocShape );
TPythonDump()<<this<<".SetGeom("<<theGeom<<")";
myBelongToGeomPtr->SetGeom( theShape );
}
-void BelongToGeom_i::SetElementType(ElementType theType){
+void BelongToGeom_i::SetElementType(ElementType theType)
+{
myBelongToGeomPtr->SetType(SMDSAbs_ElementType(theType));
TPythonDump()<<this<<".SetElementType("<<theType<<")";
}
void BelongToGeom_i::SetShapeName( const char* theName )
{
- delete myShapeName;
- myShapeName = strdup( theName );
+ CORBA::string_free( myShapeName );
+ myShapeName = CORBA::string_dup( theName );
myBelongToGeomPtr->SetGeom( getShapeByName( myShapeName ) );
TPythonDump()<<this<<".SetShapeName('"<<theName<<"')";
}
void BelongToGeom_i::SetShape( const char* theID, const char* theName )
{
- delete myShapeName;
- myShapeName = strdup( theName );
- delete myShapeID;
- if ( theID )
- myShapeID = strdup( theID );
- else
- myShapeID = 0;
+ CORBA::string_free( myShapeName );
+ CORBA::string_free( myShapeID );
+ myShapeName = CORBA::string_dup( theName );
+ myShapeID = CORBA::string_dup( theID );
+ bool hasName = ( theName && theName[0] );
+ bool hasID = ( theID && theID[0] );
- if ( myShapeID && strcmp(myShapeName, getShapeNameByID(myShapeID)) == 0 )
- myBelongToGeomPtr->SetGeom( getShapeByID(myShapeID) );
+ TopoDS_Shape S;
+ if ( hasName && hasID )
+ {
+ S = getShapeByID( myShapeID );
+ if ( S.IsNull() )
+ S = getShapeByName( myShapeName );
+ }
else
- myBelongToGeomPtr->SetGeom( getShapeByName( myShapeName ) );
+ {
+ S = hasID ? getShapeByID( myShapeID ) : getShapeByName( myShapeName );
+ }
+ myBelongToGeomPtr->SetGeom( S );
}
char* BelongToGeom_i::GetShapeName()
return CORBA::string_dup( myShapeID );
}
+void BelongToGeom_i::SetTolerance( CORBA::Double theToler )
+{
+ myBelongToGeomPtr->SetTolerance( theToler );
+ TPythonDump()<<this<<".SetTolerance("<<theToler<<")";
+}
+
+CORBA::Double BelongToGeom_i::GetTolerance()
+{
+ return myBelongToGeomPtr->GetTolerance();
+}
+
/*
Class : BelongToSurface_i
Description : Predicate for selection on geometrical support
BelongToSurface_i::~BelongToSurface_i()
{
- delete myShapeName;
- delete myShapeID;
+ CORBA::string_free( myShapeName );
+ CORBA::string_free( myShapeID );
}
void BelongToSurface_i::SetSurface( GEOM::GEOM_Object_ptr theGeom, ElementType theType )
if ( theGeom->_is_nil() )
return;
SMESH_Gen_i* aSMESHGen = SMESH_Gen_i::GetSMESHGen();
- GEOM::GEOM_Gen_var aGEOMGen = SMESH_Gen_i::GetGeomEngine();
+ GEOM::GEOM_Gen_ptr aGEOMGen = SMESH_Gen_i::GetGeomEngine();
TopoDS_Shape aLocShape = aSMESHGen->GetShapeReader()->GetShape( aGEOMGen, theGeom );
if ( aLocShape.ShapeType() == TopAbs_FACE )
}
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 );
+ CORBA::string_free( myShapeName );
+ myShapeName = CORBA::string_dup( theName );
myElementsOnSurfacePtr->SetSurface( getShapeByName( myShapeName ), (SMDSAbs_ElementType)theType );
TPythonDump()<<this<<".SetShapeName('"<<theName<<"',"<<theType<<")";
}
void BelongToSurface_i::SetShape( const char* theID, const char* theName, ElementType theType )
{
- delete myShapeName;
- myShapeName = strdup( theName );
- delete myShapeID;
- if ( theID )
- myShapeID = strdup( theID );
- else
- myShapeID = 0;
-
- if ( myShapeID && strcmp(myShapeName, getShapeNameByID(myShapeID)) == 0 )
- myElementsOnSurfacePtr->SetSurface( getShapeByID(myShapeID), (SMDSAbs_ElementType)theType );
+ CORBA::string_free( myShapeName );
+ CORBA::string_free( myShapeID );
+ myShapeName = CORBA::string_dup( theName );
+ myShapeID = CORBA::string_dup( theID );
+ bool hasName = ( theName && theName[0] );
+ bool hasID = ( theID && theID[0] );
+
+ TopoDS_Shape S;
+ if ( hasName && hasID )
+ {
+ S = getShapeByID( myShapeID );
+ if ( S.IsNull() )
+ S = getShapeByName( myShapeName );
+ }
else
- myElementsOnSurfacePtr->SetSurface( getShapeByName( myShapeName ), (SMDSAbs_ElementType)theType );
+ {
+ S = hasID ? getShapeByID( myShapeID ) : getShapeByName( myShapeName );
+ }
+ myElementsOnSurfacePtr->SetSurface( S, (SMDSAbs_ElementType)theType );
}
char* BelongToSurface_i::GetShapeName()
return myElementsOnSurfacePtr->GetTolerance();
}
+void BelongToSurface_i::SetUseBoundaries( CORBA::Boolean theUseBndRestrictions )
+{
+ myElementsOnSurfacePtr->SetUseBoundaries( theUseBndRestrictions );
+ TPythonDump()<<this<<".SetUseBoundaries( " << theUseBndRestrictions << " )";
+}
+
+CORBA::Boolean BelongToSurface_i::GetUseBoundaries()
+{
+ return myElementsOnSurfacePtr->GetUseBoundaries();
+}
+
+
/*
Class : BelongToPlane_i
Description : Verify whether mesh element lie in pointed Geom planar object
return FT_BelongToCylinder;
}
+/*
+ Class : BelongToGenSurface_i
+ Description : Verify whether mesh element lie in pointed Geom planar object
+*/
+
+BelongToGenSurface_i::BelongToGenSurface_i()
+: BelongToSurface_i( STANDARD_TYPE( Geom_CylindricalSurface ) )
+{
+}
+
+void BelongToGenSurface_i::SetSurface( GEOM::GEOM_Object_ptr theGeom, ElementType theType )
+{
+ if ( theGeom->_is_nil() )
+ return;
+ TopoDS_Shape aLocShape = SMESH_Gen_i::GetSMESHGen()->GeomObjectToShape( theGeom );
+ if ( !aLocShape.IsNull() && aLocShape.ShapeType() != TopAbs_FACE )
+ aLocShape.Nullify();
+
+ BelongToSurface_i::myElementsOnSurfacePtr->SetSurface( aLocShape, (SMDSAbs_ElementType)theType );
+ TPythonDump()<<this<<".SetGenSurface("<<theGeom<<","<<theType<<")";
+}
+
+FunctorType BelongToGenSurface_i::GetFunctorType()
+{
+ return FT_BelongToGenSurface;
+}
+
/*
Class : LyingOnGeom_i
Description : Predicate for selection on geometrical support
LyingOnGeom_i::~LyingOnGeom_i()
{
- delete myShapeName;
- delete myShapeID;
+ CORBA::string_free( myShapeName );
+ CORBA::string_free( myShapeID );
}
void LyingOnGeom_i::SetGeom( GEOM::GEOM_Object_ptr theGeom )
if ( theGeom->_is_nil() )
return;
SMESH_Gen_i* aSMESHGen = SMESH_Gen_i::GetSMESHGen();
- GEOM::GEOM_Gen_var aGEOMGen = SMESH_Gen_i::GetGeomEngine();
+ GEOM::GEOM_Gen_ptr aGEOMGen = SMESH_Gen_i::GetGeomEngine();
TopoDS_Shape aLocShape = aSMESHGen->GetShapeReader()->GetShape( aGEOMGen, theGeom );
myLyingOnGeomPtr->SetGeom( aLocShape );
TPythonDump()<<this<<".SetGeom("<<theGeom<<")";
void LyingOnGeom_i::SetShapeName( const char* theName )
{
- delete myShapeName;
- myShapeName = strdup( theName );
+ CORBA::string_free( myShapeName );
+ myShapeName = CORBA::string_dup( theName );
myLyingOnGeomPtr->SetGeom( getShapeByName( myShapeName ) );
TPythonDump()<<this<<".SetShapeName('"<<theName<<"')";
}
void LyingOnGeom_i::SetShape( const char* theID, const char* theName )
{
- delete myShapeName;
- myShapeName = strdup( theName );
- delete myShapeID;
- if ( theID )
- myShapeID = strdup( theID );
- else
- myShapeID = 0;
-
- if ( myShapeID && strcmp(myShapeName, getShapeNameByID(myShapeID)) == 0 )
- myLyingOnGeomPtr->SetGeom( getShapeByID(myShapeID) );
+ CORBA::string_free( myShapeName );
+ CORBA::string_free( myShapeID );
+ myShapeName = CORBA::string_dup( theName );
+ myShapeID = CORBA::string_dup( theID );
+ bool hasName = ( theName && theName[0] );
+ bool hasID = ( theID && theID[0] );
+
+ TopoDS_Shape S;
+ if ( hasName && hasID )
+ {
+ S = getShapeByID( myShapeID );
+ if ( S.IsNull() )
+ S = getShapeByName( myShapeName );
+ }
else
- myLyingOnGeomPtr->SetGeom( getShapeByName( myShapeName ) );
+ {
+ S = hasID ? getShapeByID( myShapeID ) : getShapeByName( myShapeName );
+ }
+ myLyingOnGeomPtr->SetGeom( S );
}
char* LyingOnGeom_i::GetShapeName()
return CORBA::string_dup( myShapeID );
}
+void LyingOnGeom_i::SetTolerance( CORBA::Double theToler )
+{
+ myLyingOnGeomPtr->SetTolerance( theToler );
+ TPythonDump()<<this<<".SetTolerance("<<theToler<<")";
+}
+
+CORBA::Double LyingOnGeom_i::GetTolerance()
+{
+ return myLyingOnGeomPtr->GetTolerance();
+}
+
/*
Class : FreeBorders_i
Description : Predicate for free borders
myFunctorPtr = myPredicatePtr;
}
-FunctorType FreeBorders_i::GetFunctorType()
+FunctorType FreeBorders_i::GetFunctorType()
+{
+ return SMESH::FT_FreeBorders;
+}
+
+/*
+ Class : FreeEdges_i
+ Description : Predicate for free borders
+*/
+FreeEdges_i::FreeEdges_i()
+: myFreeEdgesPtr( new Controls::FreeEdges() )
+{
+ myFunctorPtr = myPredicatePtr = myFreeEdgesPtr;
+}
+
+SMESH::FreeEdges::Borders* FreeEdges_i::GetBorders()
+{
+ SMESH::Controls::FreeEdges::TBorders aBorders;
+ myFreeEdgesPtr->GetBoreders( aBorders );
+
+ long i = 0, iEnd = aBorders.size();
+
+ SMESH::FreeEdges::Borders_var aResult = new SMESH::FreeEdges::Borders;
+ aResult->length(iEnd);
+
+ SMESH::Controls::FreeEdges::TBorders::const_iterator anIter;
+ for ( anIter = aBorders.begin() ; anIter != aBorders.end(); anIter++, i++ )
+ {
+ const SMESH::Controls::FreeEdges::Border& aBord = *anIter;
+ SMESH::FreeEdges::Border &aBorder = aResult[ i ];
+
+ aBorder.myElemId = aBord.myElemId;
+ aBorder.myPnt1 = aBord.myPntId[ 0 ];
+ aBorder.myPnt2 = aBord.myPntId[ 1 ];
+ }
+ return aResult._retn();
+}
+
+FunctorType FreeEdges_i::GetFunctorType()
+{
+ return SMESH::FT_FreeEdges;
+}
+
+/*
+ Class : FreeFaces_i
+ Description : Predicate for free faces
+*/
+FreeFaces_i::FreeFaces_i()
+{
+ myPredicatePtr.reset(new Controls::FreeFaces());
+ myFunctorPtr = myPredicatePtr;
+}
+
+FunctorType FreeFaces_i::GetFunctorType()
+{
+ return SMESH::FT_FreeFaces;
+}
+
+/*
+ Class : FreeNodes_i
+ Description : Predicate for free nodes
+*/
+FreeNodes_i::FreeNodes_i()
+{
+ myPredicatePtr.reset(new Controls::FreeNodes());
+ myFunctorPtr = myPredicatePtr;
+}
+
+FunctorType FreeNodes_i::GetFunctorType()
+{
+ return SMESH::FT_FreeNodes;
+}
+
+/*
+ Class : EqualNodes_i
+ Description : Predicate for Equal nodes
+*/
+EqualNodes_i::EqualNodes_i()
+{
+ myCoincidentNodesPtr.reset(new Controls::CoincidentNodes());
+ myFunctorPtr = myPredicatePtr = myCoincidentNodesPtr;
+}
+
+FunctorType EqualNodes_i::GetFunctorType()
+{
+ return SMESH::FT_EqualNodes;
+}
+
+void EqualNodes_i::SetTolerance( double tol )
+{
+ myCoincidentNodesPtr->SetTolerance( tol );
+}
+
+double EqualNodes_i::GetTolerance()
+{
+ return myCoincidentNodesPtr->GetTolerance();
+}
+
+/*
+ Class : EqualEdges_i
+ Description : Predicate for Equal Edges
+*/
+EqualEdges_i::EqualEdges_i()
+{
+ myPredicatePtr.reset(new Controls::CoincidentElements1D());
+ myFunctorPtr = myPredicatePtr;
+}
+
+FunctorType EqualEdges_i::GetFunctorType()
+{
+ return SMESH::FT_EqualEdges;
+}
+
+/*
+ Class : EqualFaces_i
+ Description : Predicate for Equal Faces
+*/
+EqualFaces_i::EqualFaces_i()
+{
+ myPredicatePtr.reset(new Controls::CoincidentElements2D());
+ myFunctorPtr = myPredicatePtr;
+}
+
+FunctorType EqualFaces_i::GetFunctorType()
+{
+ return SMESH::FT_EqualFaces;
+}
+
+/*
+ Class : EqualVolumes_i
+ Description : Predicate for Equal Volumes
+*/
+EqualVolumes_i::EqualVolumes_i()
+{
+ myPredicatePtr.reset(new Controls::CoincidentElements3D());
+ myFunctorPtr = myPredicatePtr;
+}
+
+FunctorType EqualVolumes_i::GetFunctorType()
+{
+ return SMESH::FT_EqualVolumes;
+}
+
+
+/*
+ Class : RangeOfIds_i
+ Description : Predicate for Range of Ids.
+ Range may be specified with two ways.
+ 1. Using AddToRange method
+ 2. With SetRangeStr method. Parameter of this method is a string
+ like as "1,2,3,50-60,63,67,70-"
+*/
+
+RangeOfIds_i::RangeOfIds_i()
+{
+ myRangeOfIdsPtr.reset( new Controls::RangeOfIds() );
+ myFunctorPtr = myPredicatePtr = myRangeOfIdsPtr;
+}
+
+void RangeOfIds_i::SetRange( const SMESH::long_array& theIds )
+{
+ 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 ) );
+}
+
+char* RangeOfIds_i::GetRangeStr()
+{
+ TCollection_AsciiString aStr;
+ myRangeOfIdsPtr->GetRangeStr( aStr );
+ return CORBA::string_dup( aStr.ToCString() );
+}
+
+void RangeOfIds_i::SetElementType( ElementType theType )
+{
+ myRangeOfIdsPtr->SetType( SMDSAbs_ElementType( theType ) );
+ TPythonDump()<<this<<".SetElementType("<<theType<<")";
+}
+
+FunctorType RangeOfIds_i::GetFunctorType()
+{
+ return SMESH::FT_RangeOfIds;
+}
+
+/*
+ Class : LinearOrQuadratic_i
+ Description : Predicate to verify whether a mesh element is linear
+*/
+LinearOrQuadratic_i::LinearOrQuadratic_i()
+{
+ myLinearOrQuadraticPtr.reset(new Controls::LinearOrQuadratic());
+ myFunctorPtr = myPredicatePtr = myLinearOrQuadraticPtr;
+}
+
+void LinearOrQuadratic_i::SetElementType(ElementType theType)
+{
+ myLinearOrQuadraticPtr->SetType(SMDSAbs_ElementType(theType));
+ TPythonDump()<<this<<".SetElementType("<<theType<<")";
+}
+
+FunctorType LinearOrQuadratic_i::GetFunctorType()
+{
+ return SMESH::FT_LinearOrQuadratic;
+}
+
+/*
+ Class : GroupColor_i
+ Description : Functor for check color of group to which mesh element belongs to
+*/
+GroupColor_i::GroupColor_i()
+{
+ myGroupColorPtr.reset(new Controls::GroupColor());
+ myFunctorPtr = myPredicatePtr = myGroupColorPtr;
+}
+
+FunctorType GroupColor_i::GetFunctorType()
+{
+ return SMESH::FT_GroupColor;
+}
+
+void GroupColor_i::SetColorStr( const char* theColor )
+{
+ myGroupColorPtr->SetColorStr(
+ TCollection_AsciiString( (Standard_CString)theColor ) );
+ TPythonDump()<<this<<".SetColorStr('"<<theColor<<"')";
+}
+
+char* GroupColor_i::GetColorStr()
+{
+ TCollection_AsciiString aStr;
+ myGroupColorPtr->GetColorStr( aStr );
+ return CORBA::string_dup( aStr.ToCString() );
+}
+
+void GroupColor_i::SetElementType(ElementType theType)
+{
+ myGroupColorPtr->SetType(SMDSAbs_ElementType(theType));
+ TPythonDump()<<this<<".SetElementType("<<theType<<")";
+}
+
+/*
+ Class : ElemGeomType_i
+ Description : Predicate check is element has indicated geometry type
+*/
+ElemGeomType_i::ElemGeomType_i()
+{
+ myElemGeomTypePtr.reset(new Controls::ElemGeomType());
+ myFunctorPtr = myPredicatePtr = myElemGeomTypePtr;
+}
+
+void ElemGeomType_i::SetElementType(ElementType theType)
+{
+ myElemGeomTypePtr->SetType(SMDSAbs_ElementType(theType));
+ TPythonDump()<<this<<".SetElementType("<<theType<<")";
+}
+
+void ElemGeomType_i::SetGeometryType(GeometryType theType)
+{
+ myElemGeomTypePtr->SetGeomType(SMDSAbs_GeometryType(theType));
+ TPythonDump()<<this<<".SetGeometryType("<<theType<<")";
+}
+
+GeometryType ElemGeomType_i::GetGeometryType() const
+{
+ return (GeometryType)myElemGeomTypePtr->GetGeomType();
+}
+
+FunctorType ElemGeomType_i::GetFunctorType()
+{
+ return SMESH::FT_ElemGeomType;
+}
+
+/*
+ Class : ElemEntityType_i
+ Description : Predicate check is element has indicated entity type
+*/
+ElemEntityType_i::ElemEntityType_i()
+{
+ myElemEntityTypePtr.reset(new Controls::ElemEntityType());
+ myFunctorPtr = myPredicatePtr = myElemEntityTypePtr;
+}
+
+void ElemEntityType_i::SetElementType(ElementType theType)
+{
+ myElemEntityTypePtr->SetType(SMDSAbs_ElementType(theType));
+ TPythonDump()<<this<<".SetElementType("<<theType<<")";
+}
+
+void ElemEntityType_i::SetEntityType(EntityType theEntityType)
+{
+ myElemEntityTypePtr->SetElemEntityType(SMDSAbs_EntityType (theEntityType));
+ TPythonDump()<<this<<".SetEntityType("<<theEntityType<<")";
+}
+EntityType ElemEntityType_i::GetEntityType() const
+{
+ return (EntityType) myElemEntityTypePtr->GetElemEntityType();
+}
+
+FunctorType ElemEntityType_i::GetFunctorType()
{
- return SMESH::FT_FreeBorders;
+ return SMESH::FT_EntityType;
}
/*
- Class : FreeEdges_i
- Description : Predicate for free borders
+ Class : CoplanarFaces_i
+ Description : Returns true if a mesh face is a coplanar neighbour to a given one
*/
-FreeEdges_i::FreeEdges_i()
-: myFreeEdgesPtr( new Controls::FreeEdges() )
+CoplanarFaces_i::CoplanarFaces_i()
{
- myFunctorPtr = myPredicatePtr = myFreeEdgesPtr;
+ myCoplanarFacesPtr.reset(new Controls::CoplanarFaces());
+ myFunctorPtr = myPredicatePtr = myCoplanarFacesPtr;
}
-SMESH::FreeEdges::Borders* FreeEdges_i::GetBorders()
+void CoplanarFaces_i::SetFace ( CORBA::Long theFaceID )
{
- INFOS("FreeEdges_i::GetBorders");
- SMESH::Controls::FreeEdges::TBorders aBorders;
- myFreeEdgesPtr->GetBoreders( aBorders );
-
- long i = 0, iEnd = aBorders.size();
+ myCoplanarFacesPtr->SetFace(theFaceID);
+ TPythonDump()<<this<<".SetFace("<<theFaceID<<")";
+}
- SMESH::FreeEdges::Borders_var aResult = new SMESH::FreeEdges::Borders(iEnd);
+void CoplanarFaces_i::SetTolerance( CORBA::Double theToler )
+{
+ myCoplanarFacesPtr->SetTolerance(theToler);
+ TPythonDump()<<this<<".SetTolerance("<<theToler<<")";
+}
- SMESH::Controls::FreeEdges::TBorders::const_iterator anIter;
- for ( anIter = aBorders.begin() ; anIter != aBorders.end(); anIter++, i++ )
- {
- const SMESH::Controls::FreeEdges::Border& aBord = *anIter;
- SMESH::FreeEdges::Border &aBorder = aResult[ i ];
+CORBA::Long CoplanarFaces_i::GetFace () const
+{
+ return myCoplanarFacesPtr->GetFace();
+}
- aBorder.myElemId = aBord.myElemId;
- aBorder.myPnt1 = aBord.myPntId[ 0 ];
- aBorder.myPnt2 = aBord.myPntId[ 1 ];
- }
+char* CoplanarFaces_i::GetFaceAsString () const
+{
+ TCollection_AsciiString str(Standard_Integer(myCoplanarFacesPtr->GetFace()));
+ return CORBA::string_dup( str.ToCString() );
+}
- INFOS("FreeEdges_i::GetBorders~");
- return aResult._retn();
+CORBA::Double CoplanarFaces_i::GetTolerance() const
+{
+ return myCoplanarFacesPtr->GetTolerance();
}
-FunctorType FreeEdges_i::GetFunctorType()
+FunctorType CoplanarFaces_i::GetFunctorType()
{
- return SMESH::FT_FreeEdges;
+ return SMESH::FT_CoplanarFaces;
}
/*
- Class : RangeOfIds_i
- Description : Predicate for Range of Ids.
- Range may be specified with two ways.
- 1. Using AddToRange method
- 2. With SetRangeStr method. Parameter of this method is a string
- like as "1,2,3,50-60,63,67,70-"
-*/
+ * Class : ConnectedElements_i
+ * Description : Returns true if an element is connected via other elements to the element
+ * located at a given point.
+ */
+ConnectedElements_i::ConnectedElements_i()
+{
+ myConnectedElementsPtr.reset(new Controls::ConnectedElements());
+ myFunctorPtr = myPredicatePtr = myConnectedElementsPtr;
+}
-RangeOfIds_i::RangeOfIds_i()
+FunctorType ConnectedElements_i::GetFunctorType()
{
- myRangeOfIdsPtr.reset( new Controls::RangeOfIds() );
- myFunctorPtr = myPredicatePtr = myRangeOfIdsPtr;
+ return FT_ConnectedElements;
}
-void RangeOfIds_i::SetRange( const SMESH::long_array& theIds )
+void ConnectedElements_i::SetElementType( ElementType theType )
{
- CORBA::Long iEnd = theIds.length();
- for ( CORBA::Long i = 0; i < iEnd; i++ )
- myRangeOfIdsPtr->AddToRange( theIds[ i ] );
- TPythonDump()<<this<<".SetRange("<<theIds<<")";
+ myConnectedElementsPtr->SetType( SMDSAbs_ElementType( theType ));
+ TPythonDump() << this << ".SetElementType( " << theType << " )";
}
-CORBA::Boolean RangeOfIds_i::SetRangeStr( const char* theRange )
+void ConnectedElements_i::SetPoint( CORBA::Double x, CORBA::Double y, CORBA::Double z )
{
- TPythonDump()<<this<<".SetRangeStr('"<<theRange<<"')";
- return myRangeOfIdsPtr->SetRangeStr(
- TCollection_AsciiString( (Standard_CString)theRange ) );
+ myConnectedElementsPtr->SetPoint( x,y,z );
+ myVertexID.clear();
+ TPythonDump() << this << ".SetPoint( " << x << ", " << y << ", " << z << " )";
}
-char* RangeOfIds_i::GetRangeStr()
+void ConnectedElements_i::SetVertex( GEOM::GEOM_Object_ptr vertex )
+ throw (SALOME::SALOME_Exception)
{
- TCollection_AsciiString aStr;
- myRangeOfIdsPtr->GetRangeStr( aStr );
- return CORBA::string_dup( aStr.ToCString() );
+ TopoDS_Shape shape = SMESH_Gen_i::GetSMESHGen()->GeomObjectToShape( vertex );
+ if ( shape.IsNull() )
+ THROW_SALOME_CORBA_EXCEPTION( "ConnectedElements_i::SetVertex(): NULL Vertex",
+ SALOME::BAD_PARAM );
+
+ TopExp_Explorer v( shape, TopAbs_VERTEX );
+ if ( !v.More() )
+ THROW_SALOME_CORBA_EXCEPTION( "ConnectedElements_i::SetVertex(): empty vertex",
+ SALOME::BAD_PARAM );
+
+ gp_Pnt p = BRep_Tool::Pnt( TopoDS::Vertex( v.Current() ));
+ myConnectedElementsPtr->SetPoint( p.X(), p.Y(), p.Z() );
+ //
+ CORBA::String_var id = vertex->GetStudyEntry();
+ myVertexID = id.in();
+
+ TPythonDump() << this << ".SetVertex( " << vertex << " )";
}
-void RangeOfIds_i::SetElementType( ElementType theType )
+void ConnectedElements_i::SetNode ( CORBA::Long nodeID )
+ throw (SALOME::SALOME_Exception)
{
- myRangeOfIdsPtr->SetType( SMDSAbs_ElementType( theType ) );
- TPythonDump()<<this<<".SetElementType("<<theType<<")";
+ if ( nodeID < 1 )
+ THROW_SALOME_CORBA_EXCEPTION( "ConnectedElements_i::SetNode(): nodeID must be > 0",
+ SALOME::BAD_PARAM );
+
+ myConnectedElementsPtr->SetNode( nodeID );
+ myVertexID.clear();
+ TPythonDump() << this << ".SetNode( " << nodeID << " )";
}
-FunctorType RangeOfIds_i::GetFunctorType()
+/*!
+ * \brief This is a comfort method for Filter dialog
+ */
+void ConnectedElements_i::SetThreshold ( const char* threshold,
+ SMESH::ConnectedElements::ThresholdType type )
+ throw (SALOME::SALOME_Exception)
+{
+ if ( !threshold )
+ THROW_SALOME_CORBA_EXCEPTION( "ConnectedElements_i::SetThreshold(): NULL threshold",
+ SALOME::BAD_PARAM );
+ switch ( type )
+ {
+ case SMESH::ConnectedElements::POINT: // read 3 node coordinates ///////////////////
+ {
+ std::vector< double > xyz;
+ char* endptr;
+ do
+ {
+ // skip a separator
+ while ( *threshold &&
+ *threshold != '+' &&
+ *threshold != '-' &&
+ !isdigit( *threshold ))
+ ++threshold;
+ if ( !*threshold )
+ break;
+ // read a coordinate
+ xyz.push_back( strtod( threshold, &endptr ));
+ if ( threshold == endptr )
+ {
+ xyz.resize( xyz.size() - 1 );
+ break;
+ }
+ threshold = endptr;
+ }
+ while ( xyz.size() < 3 );
+
+ if ( xyz.size() < 3 )
+ THROW_SALOME_CORBA_EXCEPTION
+ ( "ConnectedElements_i::SetThreshold(): invalid point coordinates", SALOME::BAD_PARAM );
+
+ SetPoint( xyz[0], xyz[1], xyz[2] );
+ break;
+ }
+ case SMESH::ConnectedElements::VERTEX: // get a VERTEX by its entry /////////////////
+ {
+ SALOMEDS::SObject_wrap sobj = SMESH_Gen_i::getStudyServant()->FindObjectID( threshold );
+ if ( sobj->_is_nil() )
+ THROW_SALOME_CORBA_EXCEPTION
+ ( "ConnectedElements_i::SetThreshold(): invalid vertex study entry", SALOME::BAD_PARAM );
+ CORBA::Object_var obj = sobj->GetObject();
+ GEOM::GEOM_Object_var vertex = GEOM::GEOM_Object::_narrow( obj );
+ if ( vertex->_is_nil() )
+ THROW_SALOME_CORBA_EXCEPTION
+ ( "ConnectedElements_i::SetThreshold(): no GEOM_Object in SObject", SALOME::BAD_PARAM );
+ SetVertex( vertex );
+ break;
+ }
+ case SMESH::ConnectedElements::NODE: // read a node ID ////////////////////////////
+ {
+ char* endptr;
+ int id = strtol( threshold, &endptr, 10 );
+ if ( threshold == endptr )
+ THROW_SALOME_CORBA_EXCEPTION
+ ( "ConnectedElements_i::SetThreshold(): invalid node ID", SALOME::BAD_PARAM );
+ SetNode( id );
+ break;
+ }
+ default:
+ THROW_SALOME_CORBA_EXCEPTION
+ ( "ConnectedElements_i::SetThreshold(): invalid ThresholdType", SALOME::BAD_PARAM );
+ }
+}
+
+char* ConnectedElements_i::GetThreshold ( SMESH::ConnectedElements::ThresholdType& type )
{
- return SMESH::FT_RangeOfIds;
+ std::string threshold;
+ if ( !myVertexID.empty() )
+ {
+ threshold = myVertexID;
+ type = SMESH::ConnectedElements::VERTEX;
+ }
+ else
+ {
+ std::vector<double> xyz = myConnectedElementsPtr->GetPoint();
+ if ( xyz.size() == 3 )
+ {
+ threshold = SMESH_Comment( xyz[0] ) << "; " << xyz[1] << "; " << xyz[2];
+ type = SMESH::ConnectedElements::POINT;
+ }
+ else
+ {
+ threshold = SMESH_Comment( myConnectedElementsPtr->GetNode() );
+ type = SMESH::ConnectedElements::NODE;
+ }
+ }
+ return CORBA::string_dup( threshold.c_str() );
}
/*
Comparator_i::~Comparator_i()
{
if ( myNumericalFunctor )
- myNumericalFunctor->Destroy();
+ myNumericalFunctor->UnRegister();
}
void Comparator_i::SetMargin( CORBA::Double theValue )
void Comparator_i::SetNumFunctor( NumericalFunctor_ptr theFunct )
{
if ( myNumericalFunctor )
- myNumericalFunctor->Destroy();
+ myNumericalFunctor->UnRegister();
myNumericalFunctor = DownCast<NumericalFunctor_i*>(theFunct);
Class : LogicalNOT_i
Description : Logical NOT predicate
*/
-LogicalNOT_i::LogicalNOT_i()
-: myPredicate( NULL ),
- myLogicalNOTPtr( new Controls::LogicalNOT() )
+LogicalNOT_i::LogicalNOT_i():
+ myLogicalNOTPtr( new Controls::LogicalNOT() ),
+ myPredicate( NULL )
{
myFunctorPtr = myPredicatePtr = myLogicalNOTPtr;
}
LogicalNOT_i::~LogicalNOT_i()
{
if ( myPredicate )
- myPredicate->Destroy();
+ myPredicate->UnRegister();
}
void LogicalNOT_i::SetPredicate( Predicate_ptr thePredicate )
{
if ( myPredicate )
- myPredicate->Destroy();
+ myPredicate->UnRegister();
myPredicate = SMESH::GetPredicate(thePredicate);
}
+
/*
Class : LogicalBinary_i
Description : Base class for binary logical predicate
LogicalBinary_i::~LogicalBinary_i()
{
if ( myPredicate1 )
- myPredicate1->Destroy();
+ myPredicate1->UnRegister();
if ( myPredicate2 )
- myPredicate2->Destroy();
+ myPredicate2->UnRegister();
}
void LogicalBinary_i::SetMesh( SMESH_Mesh_ptr theMesh )
void LogicalBinary_i::SetPredicate1( Predicate_ptr thePredicate )
{
if ( myPredicate1 )
- myPredicate1->Destroy();
+ myPredicate1->UnRegister();
myPredicate1 = SMESH::GetPredicate(thePredicate);
void LogicalBinary_i::SetPredicate2( Predicate_ptr thePredicate )
{
if ( myPredicate2 )
- myPredicate2->Destroy();
+ myPredicate2->UnRegister();
myPredicate2 = SMESH::GetPredicate(thePredicate);
FilterManager_i::FilterManager_i()
: SALOME::GenericObj_i( SMESH_Gen_i::GetPOA() )
{
- PortableServer::ObjectId_var anObjectId =
- SMESH_Gen_i::GetPOA()->activate_object( this );
+ //Base class Salome_GenericObject do it inmplicitly by overriding PortableServer::POA_ptr _default_POA() method
+ //PortableServer::ObjectId_var anObjectId =
+ // SMESH_Gen_i::GetPOA()->activate_object( this );
}
FilterManager_i::~FilterManager_i()
{
- TPythonDump()<<this<<".Destroy()";
+ //TPythonDump()<<this<<".UnRegister()";
}
}
+MaxElementLength2D_ptr FilterManager_i::CreateMaxElementLength2D()
+{
+ SMESH::MaxElementLength2D_i* aServant = new SMESH::MaxElementLength2D_i();
+ SMESH::MaxElementLength2D_var anObj = aServant->_this();
+ TPythonDump()<<aServant<<" = "<<this<<".CreateMaxElementLength2D()";
+ return anObj._retn();
+}
+
+
+MaxElementLength3D_ptr FilterManager_i::CreateMaxElementLength3D()
+{
+ SMESH::MaxElementLength3D_i* aServant = new SMESH::MaxElementLength3D_i();
+ SMESH::MaxElementLength3D_var anObj = aServant->_this();
+ TPythonDump()<<aServant<<" = "<<this<<".CreateMaxElementLength3D()";
+ return anObj._retn();
+}
+
+
Length_ptr FilterManager_i::CreateLength()
{
SMESH::Length_i* aServant = new SMESH::Length_i();
return anObj._retn();
}
+Deflection2D_ptr FilterManager_i::CreateDeflection2D()
+{
+ SMESH::Deflection2D_i* aServant = new SMESH::Deflection2D_i();
+ SMESH::Deflection2D_var anObj = aServant->_this();
+ TPythonDump()<<aServant<<" = "<<this<<".CreateLength2D()";
+ return anObj._retn();
+}
+
MultiConnection_ptr FilterManager_i::CreateMultiConnection()
{
SMESH::MultiConnection_i* aServant = new SMESH::MultiConnection_i();
return anObj._retn();
}
+BallDiameter_ptr FilterManager_i::CreateBallDiameter()
+{
+ SMESH::BallDiameter_i* aServant = new SMESH::BallDiameter_i();
+ SMESH::BallDiameter_var anObj = aServant->_this();
+ TPythonDump()<<aServant<<" = "<<this<<".CreateBallDiameter()";
+ return anObj._retn();
+}
+
+NodeConnectivityNumber_ptr FilterManager_i::CreateNodeConnectivityNumber()
+{
+ SMESH::NodeConnectivityNumber_i* aServant = new SMESH::NodeConnectivityNumber_i();
+ SMESH::NodeConnectivityNumber_var anObj = aServant->_this();
+ TPythonDump()<<aServant<<" = "<<this<<".CreateNodeConnectivityNumber()";
+ return anObj._retn();
+}
+
+BelongToMeshGroup_ptr FilterManager_i::CreateBelongToMeshGroup()
+{
+ SMESH::BelongToMeshGroup_i* aServant = new SMESH::BelongToMeshGroup_i();
+ SMESH::BelongToMeshGroup_var anObj = aServant->_this();
+ TPythonDump()<<aServant<<" = "<<this<<".CreateBelongToMeshGroup()";
+ return anObj._retn();
+}
+
BelongToGeom_ptr FilterManager_i::CreateBelongToGeom()
{
SMESH::BelongToGeom_i* aServant = new SMESH::BelongToGeom_i();
return anObj._retn();
}
+BelongToGenSurface_ptr FilterManager_i::CreateBelongToGenSurface()
+{
+ SMESH::BelongToGenSurface_i* aServant = new SMESH::BelongToGenSurface_i();
+ SMESH::BelongToGenSurface_var anObj = aServant->_this();
+ TPythonDump()<<aServant<<" = "<<this<<".CreateBelongToGenSurface()";
+ return anObj._retn();
+}
+
LyingOnGeom_ptr FilterManager_i::CreateLyingOnGeom()
{
SMESH::LyingOnGeom_i* aServant = new SMESH::LyingOnGeom_i();
return anObj._retn();
}
+CoplanarFaces_ptr FilterManager_i::CreateCoplanarFaces()
+{
+ SMESH::CoplanarFaces_i* aServant = new SMESH::CoplanarFaces_i();
+ SMESH::CoplanarFaces_var anObj = aServant->_this();
+ TPythonDump()<<aServant<<" = "<<this<<".CreateCoplanarFaces()";
+ return anObj._retn();
+}
+
+ConnectedElements_ptr FilterManager_i::CreateConnectedElements()
+{
+ SMESH::ConnectedElements_i* aServant = new SMESH::ConnectedElements_i();
+ SMESH::ConnectedElements_var anObj = aServant->_this();
+ TPythonDump()<<aServant<<" = "<<this<<".CreateConnectedElements()";
+ return anObj._retn();
+}
+
FreeBorders_ptr FilterManager_i::CreateFreeBorders()
{
SMESH::FreeBorders_i* aServant = new SMESH::FreeBorders_i();
return anObj._retn();
}
+FreeFaces_ptr FilterManager_i::CreateFreeFaces()
+{
+ SMESH::FreeFaces_i* aServant = new SMESH::FreeFaces_i();
+ SMESH::FreeFaces_var anObj = aServant->_this();
+ TPythonDump()<<aServant<<" = "<<this<<".CreateFreeFaces()";
+ return anObj._retn();
+}
+
+FreeNodes_ptr FilterManager_i::CreateFreeNodes()
+{
+ SMESH::FreeNodes_i* aServant = new SMESH::FreeNodes_i();
+ SMESH::FreeNodes_var anObj = aServant->_this();
+ TPythonDump()<<aServant<<" = "<<this<<".CreateFreeNodes()";
+ return anObj._retn();
+}
+
+EqualNodes_ptr FilterManager_i::CreateEqualNodes()
+{
+ SMESH::EqualNodes_i* aServant = new SMESH::EqualNodes_i();
+ SMESH::EqualNodes_var anObj = aServant->_this();
+ TPythonDump()<<aServant<<" = "<<this<<".CreateEqualNodes()";
+ return anObj._retn();
+}
+
+EqualEdges_ptr FilterManager_i::CreateEqualEdges()
+{
+ SMESH::EqualEdges_i* aServant = new SMESH::EqualEdges_i();
+ SMESH::EqualEdges_var anObj = aServant->_this();
+ TPythonDump()<<aServant<<" = "<<this<<".CreateEqualEdges()";
+ return anObj._retn();
+}
+EqualFaces_ptr FilterManager_i::CreateEqualFaces()
+{
+ SMESH::EqualFaces_i* aServant = new SMESH::EqualFaces_i();
+ SMESH::EqualFaces_var anObj = aServant->_this();
+ TPythonDump()<<aServant<<" = "<<this<<".CreateEqualFaces()";
+ return anObj._retn();
+}
+EqualVolumes_ptr FilterManager_i::CreateEqualVolumes()
+{
+ SMESH::EqualVolumes_i* aServant = new SMESH::EqualVolumes_i();
+ SMESH::EqualVolumes_var anObj = aServant->_this();
+ TPythonDump()<<aServant<<" = "<<this<<".CreateEqualVolumes()";
+ return anObj._retn();
+}
+
RangeOfIds_ptr FilterManager_i::CreateRangeOfIds()
{
SMESH::RangeOfIds_i* aServant = new SMESH::RangeOfIds_i();
return anObj._retn();
}
+BareBorderVolume_ptr FilterManager_i::CreateBareBorderVolume()
+{
+ SMESH::BareBorderVolume_i* aServant = new SMESH::BareBorderVolume_i();
+ SMESH::BareBorderVolume_var anObj = aServant->_this();
+ TPythonDump()<<aServant<<" = "<<this<<".CreateBareBorderVolume()";
+ return anObj._retn();
+}
+
+BareBorderFace_ptr FilterManager_i::CreateBareBorderFace()
+{
+ SMESH::BareBorderFace_i* aServant = new SMESH::BareBorderFace_i();
+ SMESH::BareBorderFace_var anObj = aServant->_this();
+ TPythonDump()<<aServant<<" = "<<this<<".CreateBareBorderFace()";
+ return anObj._retn();
+}
+
+OverConstrainedVolume_ptr FilterManager_i::CreateOverConstrainedVolume()
+{
+ SMESH::OverConstrainedVolume_i* aServant = new SMESH::OverConstrainedVolume_i();
+ SMESH::OverConstrainedVolume_var anObj = aServant->_this();
+ TPythonDump()<<aServant<<" = "<<this<<".CreateOverConstrainedVolume()";
+ return anObj._retn();
+}
+
+OverConstrainedFace_ptr FilterManager_i::CreateOverConstrainedFace()
+{
+ SMESH::OverConstrainedFace_i* aServant = new SMESH::OverConstrainedFace_i();
+ SMESH::OverConstrainedFace_var anObj = aServant->_this();
+ TPythonDump()<<aServant<<" = "<<this<<".CreateOverConstrainedFace()";
+ return anObj._retn();
+}
+
LessThan_ptr FilterManager_i::CreateLessThan()
{
SMESH::LessThan_i* aServant = new SMESH::LessThan_i();
return anObj._retn();
}
-
MoreThan_ptr FilterManager_i::CreateMoreThan()
{
SMESH::MoreThan_i* aServant = new SMESH::MoreThan_i();
return anObj._retn();
}
-
LogicalNOT_ptr FilterManager_i::CreateLogicalNOT()
{
SMESH::LogicalNOT_i* aServant = new SMESH::LogicalNOT_i();
return anObj._retn();
}
-
LogicalAND_ptr FilterManager_i::CreateLogicalAND()
{
SMESH::LogicalAND_i* aServant = new SMESH::LogicalAND_i();
return anObj._retn();
}
-
LogicalOR_ptr FilterManager_i::CreateLogicalOR()
{
SMESH::LogicalOR_i* aServant = new SMESH::LogicalOR_i();
return anObj._retn();
}
+LinearOrQuadratic_ptr FilterManager_i::CreateLinearOrQuadratic()
+{
+ SMESH::LinearOrQuadratic_i* aServant = new SMESH::LinearOrQuadratic_i();
+ SMESH::LinearOrQuadratic_var anObj = aServant->_this();
+ TPythonDump()<<aServant<<" = "<<this<<".CreateLinearOrQuadratic()";
+ return anObj._retn();
+}
+
+GroupColor_ptr FilterManager_i::CreateGroupColor()
+{
+ SMESH::GroupColor_i* aServant = new SMESH::GroupColor_i();
+ SMESH::GroupColor_var anObj = aServant->_this();
+ TPythonDump()<<aServant<<" = "<<this<<".CreateGroupColor()";
+ return anObj._retn();
+}
+
+ElemGeomType_ptr FilterManager_i::CreateElemGeomType()
+{
+ SMESH::ElemGeomType_i* aServant = new SMESH::ElemGeomType_i();
+ SMESH::ElemGeomType_var anObj = aServant->_this();
+ TPythonDump()<<aServant<<" = "<<this<<".CreateElemGeomType()";
+ return anObj._retn();
+}
+
+ElemEntityType_ptr FilterManager_i::CreateElemEntityType()
+{
+ SMESH::ElemEntityType_i* aServant = new SMESH::ElemEntityType_i();
+ SMESH::ElemEntityType_var anObj = aServant->_this();
+ TPythonDump()<<aServant<<" = "<<this<<".CreateElemEntityType()";
+ return anObj._retn();
+}
+
Filter_ptr FilterManager_i::CreateFilter()
{
SMESH::Filter_i* aServant = new SMESH::Filter_i();
{
SMESH::FilterLibrary_i* aServant = new SMESH::FilterLibrary_i( aFileName );
SMESH::FilterLibrary_var anObj = aServant->_this();
- TPythonDump()<<aServant<<" = "<<this<<".LoadLibrary("<<aFileName<<")";
+ TPythonDump()<<aServant<<" = "<<this<<".LoadLibrary('"<<aFileName<<"')";
return anObj._retn();
}
Filter_i::~Filter_i()
{
if ( myPredicate )
- myPredicate->Destroy();
+ myPredicate->UnRegister();
if(!CORBA::is_nil(myMesh))
- myMesh->Destroy();
+ myMesh->UnRegister();
- TPythonDump()<<this<<".Destroy()";
+ myPredicate = 0;
+ FindBaseObjects();
}
//=======================================================================
void Filter_i::SetPredicate( Predicate_ptr thePredicate )
{
if ( myPredicate )
- myPredicate->Destroy();
+ myPredicate->UnRegister();
myPredicate = SMESH::GetPredicate(thePredicate);
{
myFilter.SetPredicate( myPredicate->GetPredicate() );
myPredicate->Register();
+ if ( const SMDS_Mesh* aMesh = MeshPtr2SMDSMesh(myMesh))
+ myPredicate->GetPredicate()->SetMesh( aMesh );
TPythonDump()<<this<<".SetPredicate("<<myPredicate<<")";
}
+ NotifyerAndWaiter::Modified();
}
//=======================================================================
theMesh->Register();
if(!CORBA::is_nil(myMesh))
- myMesh->Destroy();
+ myMesh->UnRegister();
- myMesh = theMesh;
+ myMesh = SMESH_Mesh::_duplicate( theMesh );
TPythonDump()<<this<<".SetMesh("<<theMesh<<")";
+
+ if ( myPredicate )
+ if ( const SMDS_Mesh* aMesh = MeshPtr2SMDSMesh(theMesh))
+ myPredicate->GetPredicate()->SetMesh( aMesh );
}
SMESH::long_array*
const SMDS_Mesh* theMesh,
Controls::Filter::TIdSequence& theSequence )
{
- Controls::Filter::GetElementsId(theMesh,thePredicate->GetPredicate(),theSequence);
+ if (thePredicate)
+ Controls::Filter::GetElementsId(theMesh,thePredicate->GetPredicate(),theSequence);
}
void
SMESH_Mesh_ptr theMesh,
Controls::Filter::TIdSequence& theSequence )
{
- if(const SMDS_Mesh* aMesh = MeshPtr2SMDSMesh(theMesh))
- Controls::Filter::GetElementsId(aMesh,thePredicate->GetPredicate(),theSequence);
+ if (thePredicate)
+ if(const SMDS_Mesh* aMesh = MeshPtr2SMDSMesh(theMesh))
+ Controls::Filter::GetElementsId(aMesh,thePredicate->GetPredicate(),theSequence);
}
SMESH::long_array*
GetElementsId( SMESH_Mesh_ptr theMesh )
{
SMESH::long_array_var anArray = new SMESH::long_array;
- if(!CORBA::is_nil(theMesh)){
+ if(!CORBA::is_nil(theMesh) && myPredicate){
+ theMesh->Load();
Controls::Filter::TIdSequence aSequence;
GetElementsId(myPredicate,theMesh,aSequence);
long i = 0, iEnd = aSequence.size();
for ( ; i < iEnd; i++ )
anArray[ i ] = aSequence[i];
}
- return anArray._retn();
+ return anArray._retn();
+}
+
+//=============================================================================
+/*!
+ * \brief Returns number of mesh elements per each \a EntityType
+ */
+//=============================================================================
+
+SMESH::long_array* ::Filter_i::GetMeshInfo()
+{
+ SMESH::long_array_var aRes = new SMESH::long_array();
+ aRes->length(SMESH::Entity_Last);
+ for (int i = 0; i < SMESH::Entity_Last; i++)
+ aRes[i] = 0;
+
+ if ( !CORBA::is_nil(myMesh) && myPredicate )
+ {
+ const SMDS_Mesh* aMesh = MeshPtr2SMDSMesh(myMesh);
+ SMDS_ElemIteratorPtr it = aMesh->elementsIterator( SMDSAbs_ElementType( GetElementType() ));
+ while ( it->more() )
+ {
+ const SMDS_MeshElement* anElem = it->next();
+ if ( myPredicate->IsSatisfy( anElem->GetID() ) )
+ aRes[ anElem->GetEntityType() ]++;
+ }
+ }
+
+ return aRes._retn();
+}
+
+//=============================================================================
+/*!
+ * \brief Returns number of mesh elements of each \a ElementType
+ */
+//=============================================================================
+
+SMESH::long_array* ::Filter_i::GetNbElementsByType()
+{
+ SMESH::long_array_var aRes = new SMESH::long_array();
+ aRes->length(SMESH::NB_ELEMENT_TYPES);
+ for (int i = 0; i < SMESH::NB_ELEMENT_TYPES; i++)
+ aRes[i] = 0;
+
+ if ( !CORBA::is_nil(myMesh) && myPredicate ) {
+ const SMDS_Mesh* aMesh = MeshPtr2SMDSMesh(myMesh);
+ SMDS_ElemIteratorPtr it = aMesh->elementsIterator( SMDSAbs_ElementType( GetElementType() ));
+ CORBA::Long& nbElems = aRes[ GetElementType() ];
+ while ( it->more() )
+ {
+ const SMDS_MeshElement* anElem = it->next();
+ if ( myPredicate->IsSatisfy( anElem->GetID() ) )
+ nbElems++;
+ }
+ }
+
+ return aRes._retn();
+}
+
+
+//================================================================================
+/*!
+ * \brief Return GetElementType() within an array
+ * Implement SMESH_IDSource interface
+ */
+//================================================================================
+
+SMESH::array_of_ElementType* Filter_i::GetTypes()
+{
+ SMESH::array_of_ElementType_var types = new SMESH::array_of_ElementType;
+
+ // check if any element passes through the filter
+ if ( !CORBA::is_nil(myMesh) && myPredicate )
+ {
+ const SMDS_Mesh* aMesh = MeshPtr2SMDSMesh(myMesh);
+ SMDS_ElemIteratorPtr it = aMesh->elementsIterator( SMDSAbs_ElementType( GetElementType() ));
+ bool satisfies = false;
+ while ( !satisfies && it->more() )
+ satisfies = myPredicate->IsSatisfy( it->next()->GetID() );
+ if ( satisfies ) {
+ types->length( 1 );
+ types[0] = GetElementType();
+ }
+ }
+ return types._retn();
+}
+
+//=======================================================================
+//function : GetMesh
+//purpose : Returns mesh
+//=======================================================================
+
+SMESH::SMESH_Mesh_ptr Filter_i::GetMesh()
+{
+ return SMESH_Mesh::_duplicate( myMesh );
+}
+
+//=======================================================================
+//function : GetVtkUgStream
+//purpose : Return data vtk unstructured grid (not implemented)
+//=======================================================================
+
+SALOMEDS::TMPFile* Filter_i::GetVtkUgStream()
+{
+ SALOMEDS::TMPFile_var SeqFile;
+ return SeqFile._retn();
+}
+//=======================================================================
+// name : getCriteria
+// Purpose : Retrieve criterions from predicate
+//=======================================================================
+static inline void getPrediacates( Predicate_i* thePred,
+ std::vector<Predicate_i*> & thePredVec )
+{
+ const int aFType = thePred->GetFunctorType();
+
+ switch ( aFType )
+ {
+ case FT_LogicalNOT:
+ {
+ Predicate_i* aPred = ( dynamic_cast<LogicalNOT_i*>( thePred ) )->GetPredicate_i();
+ getPrediacates( aPred, thePredVec );
+ break;
+ }
+ case FT_LogicalAND:
+ case FT_LogicalOR:
+ {
+ Predicate_i* aPred1 = ( dynamic_cast<LogicalBinary_i*>( thePred ) )->GetPredicate1_i();
+ Predicate_i* aPred2 = ( dynamic_cast<LogicalBinary_i*>( thePred ) )->GetPredicate2_i();
+ getPrediacates( aPred1, thePredVec );
+ getPrediacates( aPred2, thePredVec );
+ break;
+ }
+ default:;
+ }
+ thePredVec.push_back( thePred );
}
//=======================================================================
static inline bool getCriteria( Predicate_i* thePred,
SMESH::Filter::Criteria_out theCriteria )
{
- int aFType = thePred->GetFunctorType();
+ const int aFType = thePred->GetFunctorType();
switch ( aFType )
{
- case FT_FreeBorders:
- case FT_FreeEdges:
+ case FT_LogicalNOT:
+ {
+ Predicate_i* aPred = ( dynamic_cast<LogicalNOT_i*>( thePred ) )->GetPredicate_i();
+ getCriteria( aPred, theCriteria );
+ theCriteria[ theCriteria->length() - 1 ].UnaryOp = FT_LogicalNOT;
+ }
+ return true;
+
+ case FT_LogicalAND:
+ case FT_LogicalOR:
{
- CORBA::ULong i = theCriteria->length();
- theCriteria->length( i + 1 );
+ Predicate_i* aPred1 = ( dynamic_cast<LogicalBinary_i*>( thePred ) )->GetPredicate1_i();
+ Predicate_i* aPred2 = ( dynamic_cast<LogicalBinary_i*>( thePred ) )->GetPredicate2_i();
+ if ( !getCriteria( aPred1, theCriteria ) )
+ return false;
+ theCriteria[ theCriteria->length() - 1 ].BinaryOp = aFType;
+ return getCriteria( aPred2, theCriteria );
+ }
+ case FT_Undefined:
+ return false;
+ }
+
+ // resize theCriteria
+ CORBA::ULong i = theCriteria->length();
+ theCriteria->length( i + 1 );
+ theCriteria[ i ] = createCriterion();
+
+ // set members of the added Criterion
- theCriteria[ i ] = createCriterion();
+ theCriteria[ i ].Type = aFType;
+ theCriteria[ i ].TypeOfElement = thePred->GetElementType();
- theCriteria[ i ].Type = aFType;
- theCriteria[ i ].TypeOfElement = thePred->GetElementType();
+ switch ( aFType )
+ {
+ case FT_FreeBorders:
+ case FT_FreeEdges:
+ case FT_FreeFaces:
+ case FT_LinearOrQuadratic:
+ case FT_FreeNodes:
+ case FT_EqualEdges:
+ case FT_EqualFaces:
+ case FT_EqualVolumes:
+ case FT_BadOrientedVolume:
+ case FT_BareBorderVolume:
+ case FT_BareBorderFace:
+ case FT_OverConstrainedVolume:
+ case FT_OverConstrainedFace:
+ {
+ return true;
+ }
+ case FT_BelongToMeshGroup:
+ {
+ BelongToMeshGroup_i* aPred = dynamic_cast<BelongToMeshGroup_i*>( thePred );
+ SMESH::SMESH_GroupBase_var grp = aPred->GetGroup();
+ if ( !grp->_is_nil() )
+ {
+ theCriteria[ i ].ThresholdStr = grp->GetName();
+ theCriteria[ i ].ThresholdID = aPred->GetGroupID().c_str();
+ }
return true;
}
case FT_BelongToGeom:
{
BelongToGeom_i* aPred = dynamic_cast<BelongToGeom_i*>( thePred );
-
- CORBA::ULong i = theCriteria->length();
- theCriteria->length( i + 1 );
-
- theCriteria[ i ] = createCriterion();
-
- theCriteria[ i ].Type = FT_BelongToGeom;
theCriteria[ i ].ThresholdStr = aPred->GetShapeName();
theCriteria[ i ].ThresholdID = aPred->GetShapeID();
- theCriteria[ i ].TypeOfElement = aPred->GetElementType();
-
+ theCriteria[ i ].Tolerance = aPred->GetTolerance();
return true;
}
case FT_BelongToPlane:
case FT_BelongToCylinder:
+ case FT_BelongToGenSurface:
{
BelongToSurface_i* aPred = dynamic_cast<BelongToSurface_i*>( thePred );
-
- CORBA::ULong i = theCriteria->length();
- theCriteria->length( i + 1 );
-
- theCriteria[ i ] = createCriterion();
-
- theCriteria[ i ].Type = aFType;
theCriteria[ i ].ThresholdStr = aPred->GetShapeName();
theCriteria[ i ].ThresholdID = aPred->GetShapeID();
- theCriteria[ i ].TypeOfElement = aPred->GetElementType();
theCriteria[ i ].Tolerance = aPred->GetTolerance();
-
return true;
}
- case FT_LyingOnGeom:
+ case FT_LyingOnGeom:
{
LyingOnGeom_i* aPred = dynamic_cast<LyingOnGeom_i*>( thePred );
-
- CORBA::ULong i = theCriteria->length();
- theCriteria->length( i + 1 );
-
- theCriteria[ i ] = createCriterion();
-
- theCriteria[ i ].Type = FT_LyingOnGeom;
theCriteria[ i ].ThresholdStr = aPred->GetShapeName();
theCriteria[ i ].ThresholdID = aPred->GetShapeID();
- theCriteria[ i ].TypeOfElement = aPred->GetElementType();
-
+ theCriteria[ i ].Tolerance = aPred->GetTolerance();
return true;
}
- case FT_RangeOfIds:
+ case FT_CoplanarFaces:
{
- RangeOfIds_i* aPred = dynamic_cast<RangeOfIds_i*>( thePred );
-
- CORBA::ULong i = theCriteria->length();
- theCriteria->length( i + 1 );
-
- theCriteria[ i ] = createCriterion();
-
- theCriteria[ i ].Type = FT_RangeOfIds;
- theCriteria[ i ].ThresholdStr = aPred->GetRangeStr();
- theCriteria[ i ].TypeOfElement = aPred->GetElementType();
-
+ CoplanarFaces_i* aPred = dynamic_cast<CoplanarFaces_i*>( thePred );
+ theCriteria[ i ].ThresholdID = aPred->GetFaceAsString();
+ theCriteria[ i ].Tolerance = aPred->GetTolerance();
return true;
}
- case FT_BadOrientedVolume:
+ case FT_ConnectedElements:
{
- 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();
-
+ ConnectedElements_i* aPred = dynamic_cast<ConnectedElements_i*>( thePred );
+ SMESH::ConnectedElements::ThresholdType type;
+ CORBA::String_var threshold = aPred->GetThreshold( type );
+ switch ( type ) {
+ case SMESH::ConnectedElements::POINT:
+ theCriteria[ i ].ThresholdStr = threshold; break;
+ case SMESH::ConnectedElements::VERTEX:
+ theCriteria[ i ].ThresholdID = threshold; break;
+ case SMESH::ConnectedElements::NODE:
+ theCriteria[ i ].Threshold = atof( threshold.in() ); break;
+ default:;
+ }
+ return true;
+ }
+ case FT_EqualNodes:
+ {
+ EqualNodes_i* aPred = dynamic_cast<EqualNodes_i*>( thePred );
+ theCriteria[ i ].Tolerance = aPred->GetTolerance();
+ return true;
+ }
+ case FT_RangeOfIds:
+ {
+ RangeOfIds_i* aPred = dynamic_cast<RangeOfIds_i*>( thePred );
+ theCriteria[ i ].ThresholdStr = aPred->GetRangeStr();
return true;
}
case FT_LessThan:
case FT_EqualTo:
{
Comparator_i* aCompar = dynamic_cast<Comparator_i*>( thePred );
-
- CORBA::ULong i = theCriteria->length();
- theCriteria->length( i + 1 );
-
- theCriteria[ i ] = createCriterion();
-
theCriteria[ i ].Type = aCompar->GetNumFunctor_i()->GetFunctorType();
theCriteria[ i ].Compare = aFType;
theCriteria[ i ].Threshold = aCompar->GetMargin();
- theCriteria[ i ].TypeOfElement = aCompar->GetElementType();
-
if ( aFType == FT_EqualTo )
{
EqualTo_i* aCompar = dynamic_cast<EqualTo_i*>( thePred );
theCriteria[ i ].Tolerance = aCompar->GetTolerance();
}
+ return true;
}
- return true;
-
- case FT_LogicalNOT:
+ case FT_GroupColor:
{
- Predicate_i* aPred = ( dynamic_cast<LogicalNOT_i*>( thePred ) )->GetPredicate_i();
- getCriteria( aPred, theCriteria );
- theCriteria[ theCriteria->length() - 1 ].UnaryOp = FT_LogicalNOT;
+ GroupColor_i* aPred = dynamic_cast<GroupColor_i*>( thePred );
+ theCriteria[ i ].ThresholdStr = aPred->GetColorStr();
+ return true;
}
- return true;
-
- case FT_LogicalAND:
- case FT_LogicalOR:
+ case FT_ElemGeomType:
{
- Predicate_i* aPred1 = ( dynamic_cast<LogicalBinary_i*>( thePred ) )->GetPredicate1_i();
- Predicate_i* aPred2 = ( dynamic_cast<LogicalBinary_i*>( thePred ) )->GetPredicate2_i();
- if ( !getCriteria( aPred1, theCriteria ) )
- return false;
- theCriteria[ theCriteria->length() - 1 ].BinaryOp = aFType;
- return getCriteria( aPred2, theCriteria );
+ ElemGeomType_i* aPred = dynamic_cast<ElemGeomType_i*>( thePred );
+ theCriteria[ i ].Threshold = (double)aPred->GetGeometryType();
+ return true;
+ }
+ case FT_EntityType:
+ {
+ ElemEntityType_i* aPred = dynamic_cast<ElemEntityType_i*>( thePred );
+ theCriteria[ i ].Threshold = (double)aPred->GetEntityType();
+ return true;
}
-
- case FT_Undefined:
- return false;
default:
return false;
}
//=======================================================================
CORBA::Boolean Filter_i::SetCriteria( const SMESH::Filter::Criteria& theCriteria )
{
- if ( myPredicate != 0 )
- myPredicate->Destroy();
+ SetPredicate( SMESH::Predicate::_nil() );
SMESH::FilterManager_i* aFilter = new SMESH::FilterManager_i();
FilterManager_ptr aFilterMgr = aFilter->_this();
int aCriterion = theCriteria[ i ].Type;
int aCompare = theCriteria[ i ].Compare;
double aThreshold = theCriteria[ i ].Threshold;
+ const char* aThresholdStr = theCriteria[ i ].ThresholdStr;
+ const char* aThresholdID = theCriteria[ i ].ThresholdID;
int aUnary = theCriteria[ i ].UnaryOp;
int aBinary = theCriteria[ i ].BinaryOp;
double aTolerance = theCriteria[ i ].Tolerance;
- const char* aThresholdStr = theCriteria[ i ].ThresholdStr;
- const char* aThresholdID = theCriteria[ i ].ThresholdID;
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<<"))";
+ {
+ TPythonDump pd;
+ pd << "aCriterion = SMESH.Filter.Criterion("
+ << aCriterion << ", "
+ << aCompare << ", "
+ << aThreshold << ", '"
+ << aThresholdStr << "', '"
+ << aThresholdID << "', "
+ << aUnary << ", "
+ << aBinary << ", "
+ << aTolerance << ", "
+ << aTypeOfElem << ", "
+ << aPrecision << ")";
+ }
+ TPythonDump pd;
SMESH::Predicate_ptr aPredicate = SMESH::Predicate::_nil();
SMESH::NumericalFunctor_ptr aFunctor = SMESH::NumericalFunctor::_nil();
case SMESH::FT_Length2D:
aFunctor = aFilterMgr->CreateLength2D();
break;
+ case SMESH::FT_Deflection2D:
+ aFunctor = aFilterMgr->CreateDeflection2D();
+ break;
case SMESH::FT_AspectRatio:
aFunctor = aFilterMgr->CreateAspectRatio();
break;
case SMESH::FT_Volume3D:
aFunctor = aFilterMgr->CreateVolume3D();
break;
+ case SMESH::FT_MaxElementLength2D:
+ aFunctor = aFilterMgr->CreateMaxElementLength2D();
+ break;
+ case SMESH::FT_MaxElementLength3D:
+ aFunctor = aFilterMgr->CreateMaxElementLength3D();
+ break;
+ case SMESH::FT_BallDiameter:
+ aFunctor = aFilterMgr->CreateBallDiameter();
+ break;
+ case SMESH::FT_NodeConnectivityNumber:
+ aFunctor = aFilterMgr->CreateNodeConnectivityNumber();
+ break;
// Predicates
case SMESH::FT_FreeEdges:
aPredicate = aFilterMgr->CreateFreeEdges();
break;
+ case SMESH::FT_FreeFaces:
+ aPredicate = aFilterMgr->CreateFreeFaces();
+ break;
+ case SMESH::FT_FreeNodes:
+ aPredicate = aFilterMgr->CreateFreeNodes();
+ break;
+ case SMESH::FT_EqualNodes:
+ {
+ SMESH::EqualNodes_ptr pred = aFilterMgr->CreateEqualNodes();
+ pred->SetTolerance( aTolerance );
+ aPredicate = pred;
+ break;
+ }
+ case SMESH::FT_EqualEdges:
+ aPredicate = aFilterMgr->CreateEqualEdges();
+ break;
+ case SMESH::FT_EqualFaces:
+ aPredicate = aFilterMgr->CreateEqualFaces();
+ break;
+ case SMESH::FT_EqualVolumes:
+ aPredicate = aFilterMgr->CreateEqualVolumes();
+ break;
+ case SMESH::FT_BelongToMeshGroup:
+ {
+ SMESH::BelongToMeshGroup_ptr tmpPred = aFilterMgr->CreateBelongToMeshGroup();
+ tmpPred->SetGroupID( aThresholdID );
+ aPredicate = tmpPred;
+ }
+ break;
case SMESH::FT_BelongToGeom:
{
SMESH::BelongToGeom_ptr tmpPred = aFilterMgr->CreateBelongToGeom();
tmpPred->SetElementType( aTypeOfElem );
tmpPred->SetShape( aThresholdID, aThresholdStr );
+ tmpPred->SetTolerance( aTolerance );
aPredicate = tmpPred;
}
break;
case SMESH::FT_BelongToPlane:
case SMESH::FT_BelongToCylinder:
+ case SMESH::FT_BelongToGenSurface:
{
SMESH::BelongToSurface_ptr tmpPred;
- if ( aCriterion == SMESH::FT_BelongToPlane )
- tmpPred = aFilterMgr->CreateBelongToPlane();
- else
- tmpPred = aFilterMgr->CreateBelongToCylinder();
+ switch ( aCriterion ) {
+ case SMESH::FT_BelongToPlane:
+ tmpPred = aFilterMgr->CreateBelongToPlane(); break;
+ case SMESH::FT_BelongToCylinder:
+ tmpPred = aFilterMgr->CreateBelongToCylinder(); break;
+ default:
+ tmpPred = aFilterMgr->CreateBelongToGenSurface();
+ }
tmpPred->SetShape( aThresholdID, aThresholdStr, aTypeOfElem );
tmpPred->SetTolerance( aTolerance );
aPredicate = tmpPred;
{
SMESH::LyingOnGeom_ptr tmpPred = aFilterMgr->CreateLyingOnGeom();
tmpPred->SetElementType( aTypeOfElem );
- tmpPred->SetShape( aThresholdID, aThresholdStr );
+ tmpPred->SetShape( aThresholdID, aThresholdStr );
+ tmpPred->SetTolerance( aTolerance );
aPredicate = tmpPred;
}
break;
aPredicate = aFilterMgr->CreateBadOrientedVolume();
}
break;
+ case SMESH::FT_BareBorderVolume:
+ {
+ aPredicate = aFilterMgr->CreateBareBorderVolume();
+ }
+ break;
+ case SMESH::FT_BareBorderFace:
+ {
+ aPredicate = aFilterMgr->CreateBareBorderFace();
+ }
+ break;
+ case SMESH::FT_OverConstrainedVolume:
+ {
+ aPredicate = aFilterMgr->CreateOverConstrainedVolume();
+ }
+ break;
+ case SMESH::FT_OverConstrainedFace:
+ {
+ aPredicate = aFilterMgr->CreateOverConstrainedFace();
+ }
+ break;
+ case SMESH::FT_LinearOrQuadratic:
+ {
+ SMESH::LinearOrQuadratic_ptr tmpPred = aFilterMgr->CreateLinearOrQuadratic();
+ tmpPred->SetElementType( aTypeOfElem );
+ aPredicate = tmpPred;
+ break;
+ }
+ case SMESH::FT_GroupColor:
+ {
+ SMESH::GroupColor_ptr tmpPred = aFilterMgr->CreateGroupColor();
+ tmpPred->SetElementType( aTypeOfElem );
+ tmpPred->SetColorStr( aThresholdStr );
+ aPredicate = tmpPred;
+ break;
+ }
+ case SMESH::FT_ElemGeomType:
+ {
+ SMESH::ElemGeomType_ptr tmpPred = aFilterMgr->CreateElemGeomType();
+ tmpPred->SetElementType( aTypeOfElem );
+ tmpPred->SetGeometryType( (GeometryType)(int)(aThreshold + 0.5) );
+ aPredicate = tmpPred;
+ break;
+ }
+ case SMESH::FT_EntityType:
+ {
+ SMESH::ElemEntityType_ptr tmpPred = aFilterMgr->CreateElemEntityType();
+ tmpPred->SetElementType( aTypeOfElem );
+ tmpPred->SetEntityType( EntityType( (int (aThreshold + 0.5))));
+ aPredicate = tmpPred;
+ break;
+ }
+ case SMESH::FT_CoplanarFaces:
+ {
+ SMESH::CoplanarFaces_ptr tmpPred = aFilterMgr->CreateCoplanarFaces();
+ tmpPred->SetFace( atol (aThresholdID ));
+ tmpPred->SetTolerance( aTolerance );
+ aPredicate = tmpPred;
+ break;
+ }
+ case SMESH::FT_ConnectedElements:
+ {
+ SMESH::ConnectedElements_ptr tmpPred = aFilterMgr->CreateConnectedElements();
+ if ( strlen( aThresholdID ) > 0 ) // shape ID
+ tmpPred->SetThreshold( aThresholdID, SMESH::ConnectedElements::VERTEX );
+ else if ( strlen( aThresholdStr ) > 0 ) // point coords
+ tmpPred->SetThreshold( aThresholdStr, SMESH::ConnectedElements::POINT );
+ else if ( aThreshold >= 1 )
+ tmpPred->SetNode( (CORBA::Long) aThreshold ); // node ID
+ tmpPred->SetElementType( aTypeOfElem );
+ aPredicate = tmpPred;
+ break;
+ }
default:
continue;
// logical op
aPredicates.push_back( aPredicate );
aBinaries.push_back( aBinary );
+ pd <<"aCriteria.append(aCriterion)";
} // end of for
- TPythonDump()<<this<<".SetCriteria(aCriteria)";
+ TPythonDump pd; pd<<this<<".SetCriteria(aCriteria)";
// CREATE ONE PREDICATE FROM PREVIOUSLY CREATED MAP
SMESH::Predicate_ptr aPrevPredicate = SMESH::Predicate::_nil();
int aPrevBinary = SMESH::FT_Undefined;
+ if ( !aBinaries.empty() )
+ aBinaries.back() = SMESH::FT_Undefined;
for ( aPredIter = aPredicates.begin(), aBinaryIter = aBinaries.begin();
aPredIter != aPredicates.end() && aBinaryIter != aBinaries.end();
}
SetPredicate( aResPredicate );
+ if ( !aResPredicate->_is_nil() )
+ aResPredicate->UnRegister();
return !aResPredicate->_is_nil();
}
else
{
SMESH::Predicate_var anObj = myPredicate->_this();
+ // if ( SMESH::Functor_i* fun = SMESH::DownCast<SMESH::Functor_i*>( anObj ))
+ // TPythonDump() << fun << " = " << this << ".GetPredicate()";
return anObj._retn();
}
}
+//================================================================================
+/*!
+ * \brief Find groups it depends on
+ */
+//================================================================================
+
+void Filter_i::FindBaseObjects()
+{
+ // release current groups
+ for ( size_t i = 0; i < myBaseGroups.size(); ++i )
+ if ( myBaseGroups[i] )
+ {
+ myBaseGroups[i]->RemoveModifWaiter( this );
+ myBaseGroups[i]->UnRegister();
+ }
+
+ // remember new groups
+ myBaseGroups.clear();
+ if ( myPredicate )
+ {
+ std::vector<Predicate_i*> predicates;
+ getPrediacates( myPredicate, predicates );
+ for ( size_t i = 0; i < predicates.size(); ++i )
+ if ( BelongToMeshGroup_i* bmg = dynamic_cast< BelongToMeshGroup_i* >( predicates[i] ))
+ {
+ SMESH::SMESH_GroupBase_var g = bmg->GetGroup();
+ SMESH_GroupBase_i* g_i = SMESH::DownCast< SMESH_GroupBase_i*>( g );
+ if ( g_i )
+ {
+ g_i->AddModifWaiter( this );
+ g_i->Register();
+ myBaseGroups.push_back( g_i );
+ }
+ }
+ }
+}
+
+//================================================================================
+/*!
+ * \brief When notified on removal of myBaseGroups[i], remove a reference to a
+ * group from a predicate
+ */
+//================================================================================
+
+void Filter_i::OnBaseObjModified(NotifyerAndWaiter* group, bool removed)
+{
+ if ( !removed )
+ return; // a GroupOnFilter holding this filter is notified automatically
+
+ if ( myPredicate )
+ {
+ std::vector<Predicate_i*> predicates;
+ getPrediacates( myPredicate, predicates );
+ for ( size_t i = 0; i < predicates.size(); ++i )
+ if ( BelongToMeshGroup_i* bmg = dynamic_cast< BelongToMeshGroup_i* >( predicates[i] ))
+ {
+ SMESH::SMESH_GroupBase_var g = bmg->GetGroup();
+ SMESH_GroupBase_i* g_i = SMESH::DownCast< SMESH_GroupBase_i*>( g );
+ if ( g_i == group )
+ {
+ bmg->SetGroup( SMESH::SMESH_GroupBase::_nil() );
+ bmg->SetGroupID( "" );
+ }
+ }
+ }
+
+ FindBaseObjects(); // release and update myBaseGroups;
+}
+
/*
FILTER LIBRARY
*/
// name : toString
// Purpose : Convert bool to LDOMString
//=======================================================================
-static inline LDOMString toString( const bool val )
+static inline LDOMString toString( CORBA::Boolean val )
{
return val ? "logical not" : "";
}
// name : toString
// Purpose : Convert double to LDOMString
//=======================================================================
-static inline LDOMString toString( const double val )
+static inline LDOMString toString( CORBA::Double val )
{
char a[ 255 ];
sprintf( a, "%e", val );
// name : toString
// Purpose : Convert functor type to LDOMString
//=======================================================================
-static inline LDOMString toString( const long theType )
+static inline LDOMString toString( CORBA::Long theType )
{
switch ( theType )
{
- case FT_AspectRatio : return "Aspect ratio";
- case FT_Warping : return "Warping";
- case FT_MinimumAngle : return "Minimum angle";
- case FT_Taper : return "Taper";
- case FT_Skew : return "Skew";
- case FT_Area : return "Area";
- case FT_Volume3D : return "Volume3D";
- case FT_BelongToGeom : return "Belong to Geom";
- 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";
- case FT_MultiConnection : return "Borders at multi-connections";
- case FT_MultiConnection2D: return "Borders at multi-connections 2D";
- case FT_Length : return "Length";
- case FT_Length2D : return "Length2D";
- case FT_LessThan : return "Less than";
- case FT_MoreThan : return "More than";
- case FT_EqualTo : return "Equal to";
- case FT_LogicalNOT : return "Not";
- case FT_LogicalAND : return "And";
- case FT_LogicalOR : return "Or";
- case FT_Undefined : return "";
- default : return "";
+ case FT_AspectRatio : return "Aspect ratio";
+ case FT_Warping : return "Warping";
+ case FT_MinimumAngle : return "Minimum angle";
+ case FT_Taper : return "Taper";
+ case FT_Skew : return "Skew";
+ case FT_Area : return "Area";
+ case FT_Volume3D : return "Volume3D";
+ case FT_MaxElementLength2D : return "Max element length 2D";
+ case FT_MaxElementLength3D : return "Max element length 3D";
+ case FT_BelongToMeshGroup : return "Belong to Mesh Group";
+ case FT_BelongToGeom : return "Belong to Geom";
+ case FT_BelongToPlane : return "Belong to Plane";
+ case FT_BelongToCylinder : return "Belong to Cylinder";
+ case FT_BelongToGenSurface : return "Belong to Generic Surface";
+ case FT_LyingOnGeom : return "Lying on Geom";
+ case FT_BadOrientedVolume : return "Bad Oriented Volume";
+ case FT_BareBorderVolume : return "Volumes with bare border";
+ case FT_BareBorderFace : return "Faces with bare border";
+ case FT_OverConstrainedVolume : return "Over-constrained Volumes";
+ case FT_OverConstrainedFace : return "Over-constrained Faces";
+ case FT_RangeOfIds : return "Range of IDs";
+ case FT_FreeBorders : return "Free borders";
+ case FT_FreeEdges : return "Free edges";
+ case FT_FreeFaces : return "Free faces";
+ case FT_FreeNodes : return "Free nodes";
+ case FT_EqualNodes : return "Equal nodes";
+ case FT_EqualEdges : return "Equal edges";
+ case FT_EqualFaces : return "Equal faces";
+ case FT_EqualVolumes : return "Equal volumes";
+ case FT_MultiConnection : return "Borders at multi-connections";
+ case FT_MultiConnection2D : return "Borders at multi-connections 2D";
+ case FT_Length : return "Length";
+ case FT_Length2D : return "Length 2D";
+ case FT_Deflection2D : return "Deflection 2D";
+ case FT_LessThan : return "Less than";
+ case FT_MoreThan : return "More than";
+ case FT_EqualTo : return "Equal to";
+ case FT_LogicalNOT : return "Not";
+ case FT_LogicalAND : return "And";
+ case FT_LogicalOR : return "Or";
+ case FT_GroupColor : return "Color of Group";
+ case FT_LinearOrQuadratic : return "Linear or Quadratic";
+ case FT_ElemGeomType : return "Element geometry type";
+ case FT_EntityType : return "Entity type";
+ case FT_Undefined : return "";
+ default : return "";
}
}
else if ( theStr.equals( "Skew" ) ) return FT_Skew;
else if ( theStr.equals( "Area" ) ) return FT_Area;
else if ( theStr.equals( "Volume3D" ) ) return FT_Volume3D;
+ else if ( theStr.equals( "Max element length 2D" ) ) return FT_MaxElementLength2D;
+ else if ( theStr.equals( "Max element length 3D" ) ) return FT_MaxElementLength3D;
+ else if ( theStr.equals( "Belong to Mesh Group" ) ) return FT_BelongToMeshGroup;
else if ( theStr.equals( "Belong to Geom" ) ) return FT_BelongToGeom;
else if ( theStr.equals( "Belong to Plane" ) ) return FT_BelongToPlane;
else if ( theStr.equals( "Belong to Cylinder" ) ) return FT_BelongToCylinder;
+ else if ( theStr.equals( "Belong to Generic Surface" ) ) return FT_BelongToGenSurface;
else if ( theStr.equals( "Lying on Geom" ) ) return FT_LyingOnGeom;
else if ( theStr.equals( "Free borders" ) ) return FT_FreeBorders;
else if ( theStr.equals( "Free edges" ) ) return FT_FreeEdges;
+ else if ( theStr.equals( "Free faces" ) ) return FT_FreeFaces;
+ else if ( theStr.equals( "Free nodes" ) ) return FT_FreeNodes;
+ else if ( theStr.equals( "Equal nodes" ) ) return FT_EqualNodes;
+ else if ( theStr.equals( "Equal edges" ) ) return FT_EqualEdges;
+ else if ( theStr.equals( "Equal faces" ) ) return FT_EqualFaces;
+ else if ( theStr.equals( "Equal volumes" ) ) return FT_EqualVolumes;
else if ( theStr.equals( "Borders at multi-connections" ) ) return FT_MultiConnection;
// else if ( theStr.equals( "Borders at multi-connections 2D" ) ) return FT_MultiConnection2D;
else if ( theStr.equals( "Length" ) ) return FT_Length;
// else if ( theStr.equals( "Length2D" ) ) return FT_Length2D;
+ else if ( theStr.equals( "Deflection" ) ) return FT_Deflection2D;
else if ( theStr.equals( "Range of IDs" ) ) return FT_RangeOfIds;
else if ( theStr.equals( "Bad Oriented Volume" ) ) return FT_BadOrientedVolume;
+ else if ( theStr.equals( "Volumes with bare border" ) ) return FT_BareBorderVolume;
+ else if ( theStr.equals( "Faces with bare border" ) ) return FT_BareBorderFace;
+ else if ( theStr.equals( "Over-constrained Volumes" ) ) return FT_OverConstrainedVolume;
+ else if ( theStr.equals( "Over-constrained Faces" ) ) return FT_OverConstrainedFace;
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;
else if ( theStr.equals( "Not" ) ) return FT_LogicalNOT;
else if ( theStr.equals( "And" ) ) return FT_LogicalAND;
else if ( theStr.equals( "Or" ) ) return FT_LogicalOR;
+ else if ( theStr.equals( "Color of Group" ) ) return FT_GroupColor;
+ else if ( theStr.equals( "Linear or Quadratic" ) ) return FT_LinearOrQuadratic;
+ else if ( theStr.equals( "Element geometry type" ) ) return FT_ElemGeomType;
+ else if ( theStr.equals( "Entity type" ) ) return FT_EntityType;
else if ( theStr.equals( "" ) ) return FT_Undefined;
else return FT_Undefined;
}
for ( CORBA::ULong i = 0, n = aCriteria->length(); i < n; i++ )
{
LDOM_Element aCriterionItem = theDoc.createElement( "criterion" );
-
- aCriterionItem.setAttribute( ATTR_TYPE , toString( aCriteria[ i ].Type ) );
- aCriterionItem.setAttribute( ATTR_COMPARE , toString( aCriteria[ i ].Compare ) );
- aCriterionItem.setAttribute( ATTR_THRESHOLD , toString( aCriteria[ i ].Threshold ) );
- aCriterionItem.setAttribute( ATTR_UNARY , toString( aCriteria[ i ].UnaryOp ) );
- aCriterionItem.setAttribute( ATTR_BINARY , toString( aCriteria[ i ].BinaryOp ) );
+
+ aCriterionItem.setAttribute( ATTR_TYPE , toString( aCriteria[ i ].Type) );
+ aCriterionItem.setAttribute( ATTR_COMPARE , toString( aCriteria[ i ].Compare ) );
+ aCriterionItem.setAttribute( ATTR_THRESHOLD , toString( aCriteria[ i ].Threshold ) );
+ aCriterionItem.setAttribute( ATTR_UNARY , toString( aCriteria[ i ].UnaryOp ) );
+ aCriterionItem.setAttribute( ATTR_BINARY , toString( aCriteria[ i ].BinaryOp ) );
aCriterionItem.setAttribute( ATTR_THRESHOLD_STR, (const char*)aCriteria[ i ].ThresholdStr );
aCriterionItem.setAttribute( ATTR_TOLERANCE , toString( aCriteria[ i ].Tolerance ) );
//=======================================================================
FilterLibrary_i::FilterLibrary_i( const char* theFileName )
{
- myFileName = strdup( theFileName );
+ myFileName = CORBA::string_dup( theFileName );
SMESH::FilterManager_i* aFilterMgr = new SMESH::FilterManager_i();
myFilterMgr = aFilterMgr->_this();
FilterLibrary_i::~FilterLibrary_i()
{
- delete myFileName;
- TPythonDump()<<this<<".Destroy()";
+ CORBA::string_free( myFileName );
+ //TPythonDump()<<this<<".UnRegister()";
}
//=======================================================================
{
char a[ 255 ];
sprintf( a, "%d", val );
- aCriterion.ThresholdStr = strdup( a );
+ aCriterion.ThresholdStr = CORBA::string_dup( a );
}
else
aCriterion.ThresholdStr = str.GetString();
-
+
aCriteria.push_back( aCriterion );
}
//=======================================================================
void FilterLibrary_i::SetFileName( const char* theFileName )
{
- delete myFileName;
- myFileName = strdup( theFileName );
+ CORBA::string_free( myFileName );
+ myFileName = CORBA::string_dup( theFileName );
TPythonDump()<<this<<".SetFileName('"<<theFileName<<"')";
}
{
aFilterItem.ReplaceElement( aNewItem );
if(Filter_i* aFilter = DownCast<Filter_i*>(theFilter))
- TPythonDump()<<this<<".Replace('"<<theFilterName<<"',"<<theNewName<<"',"<<aFilter<<")";
+ TPythonDump()<<this<<".Replace('"<<theFilterName<<"','"<<theNewName<<"',"<<aFilter<<")";
return true;
}
}
if ( myFileName == 0 || strlen( myFileName ) == 0 )
return false;
- FILE* aOutFile = fopen( myFileName, "wt" );
- if ( !aOutFile )
- return false;
+ std::filebuf fb;
+ fb.open( myFileName, std::ios::out );
- LDOM_XmlWriter aWriter( aOutFile );
+ Standard_OStream os( &fb );
+
+ LDOM_XmlWriter aWriter;
aWriter.SetIndentation( 2 );
- aWriter << myDoc;
- fclose( aOutFile );
+ aWriter.Write( os, myDoc );
+ fb.close();
TPythonDump()<<this<<".Save()";
return true;
return aResArray._retn();
}
+
+//================================================================================
+/*!
+ * \brief Return an array of strings corresponding to items of enum FunctorType
+ */
+//================================================================================
+
+static const char** getFunctNames()
+{
+ static const char* functName[] = {
+ // IT's necessary to update this array according to enum FunctorType (SMESH_Filter.idl)
+ // The order is IMPORTANT !!!
+ "FT_AspectRatio",
+ "FT_AspectRatio3D",
+ "FT_Warping",
+ "FT_MinimumAngle",
+ "FT_Taper",
+ "FT_Skew",
+ "FT_Area",
+ "FT_Volume3D",
+ "FT_MaxElementLength2D",
+ "FT_MaxElementLength3D",
+ "FT_FreeBorders",
+ "FT_FreeEdges",
+ "FT_FreeNodes",
+ "FT_FreeFaces",
+ "FT_EqualNodes",
+ "FT_EqualEdges",
+ "FT_EqualFaces",
+ "FT_EqualVolumes",
+ "FT_MultiConnection",
+ "FT_MultiConnection2D",
+ "FT_Length",
+ "FT_Length2D",
+ "FT_Deflection2D",
+ "FT_NodeConnectivityNumber",
+ "FT_BelongToMeshGroup",
+ "FT_BelongToGeom",
+ "FT_BelongToPlane",
+ "FT_BelongToCylinder",
+ "FT_BelongToGenSurface",
+ "FT_LyingOnGeom",
+ "FT_RangeOfIds",
+ "FT_BadOrientedVolume",
+ "FT_BareBorderVolume",
+ "FT_BareBorderFace",
+ "FT_OverConstrainedVolume",
+ "FT_OverConstrainedFace",
+ "FT_LinearOrQuadratic",
+ "FT_GroupColor",
+ "FT_ElemGeomType",
+ "FT_EntityType",
+ "FT_CoplanarFaces",
+ "FT_BallDiameter",
+ "FT_ConnectedElements",
+ "FT_LessThan",
+ "FT_MoreThan",
+ "FT_EqualTo",
+ "FT_LogicalNOT",
+ "FT_LogicalAND",
+ "FT_LogicalOR",
+ "FT_Undefined"};
+
+#ifdef _DEBUG_
+ // check if functName is complete, compilation failure means that enum FunctorType changed
+ const int nbFunctors = sizeof(functName) / sizeof(const char*);
+ int _assert[( nbFunctors == SMESH::FT_Undefined + 1 ) ? 2 : -1 ]; _assert[0]=_assert[1]=0;
+#endif
+
+ return functName;
+}
+
+//================================================================================
+/*!
+ * \brief Return a string corresponding to an item of enum FunctorType
+ */
+//================================================================================
+
+const char* SMESH::FunctorTypeToString(SMESH::FunctorType ft)
+{
+ if ( ft < 0 || ft > SMESH::FT_Undefined )
+ return "FT_Undefined";
+ return getFunctNames()[ ft ];
+}
+
+//================================================================================
+/*!
+ * \brief Converts a string to FunctorType. This is reverse of FunctorTypeToString()
+ */
+//================================================================================
+
+SMESH::FunctorType SMESH::StringToFunctorType(const char* str)
+{
+ std::string name( str + 3 ); // skip "FT_"
+ const char** functNames = getFunctNames();
+ int ft = 0;
+ for ( ; ft < SMESH::FT_Undefined; ++ft )
+ if ( name == ( functNames[ft] + 3 ))
+ break;
+
+ //ASSERT( strcmp( str, FunctorTypeToString( SMESH::FunctorType( ft ))) == 0 );
+
+ return SMESH::FunctorType( ft );
+}
+
+//================================================================================
+/*!
+ * \brief calls OnBaseObjModified(), if who != this, and myWaiters[i]->Modified(who)
+ */
+//================================================================================
+
+void NotifyerAndWaiter::Modified( bool removed, NotifyerAndWaiter* who )
+{
+ if ( who != 0 && who != this )
+ OnBaseObjModified( who, removed );
+ else
+ who = this;
+
+ std::list<NotifyerAndWaiter*> waiters = myWaiters; // myWaiters can be changed by Modified()
+ std::list<NotifyerAndWaiter*>::iterator i = waiters.begin();
+ for ( ; i != waiters.end(); ++i )
+ (*i)->Modified( removed, who );
+}
+
+//================================================================================
+/*!
+ * \brief Stores an object to be notified on change of predicate
+ */
+//================================================================================
+
+void NotifyerAndWaiter::AddModifWaiter( NotifyerAndWaiter* waiter )
+{
+ if ( waiter )
+ myWaiters.push_back( waiter );
+}
+
+//================================================================================
+/*!
+ * \brief Removes an object to be notified on change of predicate
+ */
+//================================================================================
+
+void NotifyerAndWaiter::RemoveModifWaiter( NotifyerAndWaiter* waiter )
+{
+ myWaiters.remove( waiter );
+}
+
+//================================================================================
+/*!
+ * \brief Checks if a waiter is among myWaiters, maybe nested
+ */
+//================================================================================
+
+bool NotifyerAndWaiter::ContainModifWaiter( NotifyerAndWaiter* waiter )
+{
+ bool is = ( waiter == this );
+
+ std::list<NotifyerAndWaiter*>::iterator w = myWaiters.begin();
+ for ( ; !is && w != myWaiters.end(); ++w )
+ is = (*w)->ContainModifWaiter( waiter );
+
+ return is;
+}