// 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
+// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
//
//
#include "SMESHDS_Mesh.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 <TCollection_HAsciiString.hxx>
+#include <TopExp.hxx>
+#include <TopExp_Explorer.hxx>
#include <TopoDS.hxx>
#include <TopoDS_Face.hxx>
-#include <Geom_Plane.hxx>
-#include <Geom_CylindricalSurface.hxx>
-#include <TopExp_Explorer.hxx>
-#include <OSD_Path.hxx>
-#include <OSD_File.hxx>
+#include <TopoDS_Shape.hxx>
+#include <TopTools_IndexedMapOfShape.hxx>
using namespace SMESH;
using namespace SMESH::Controls;
/*
Class : BelongToGeom
- Description : Predicate for verifying whether entiy belong to
+ Description : Predicate for verifying whether entity belongs to
specified geometrical support
*/
Controls::BelongToGeom::BelongToGeom()
-: myMeshDS(NULL),
- myType(SMDSAbs_All)
+ : myMeshDS(NULL),
+ myType(SMDSAbs_All),
+ myIsSubshape(false),
+ myTolerance(Precision::Confusion())
{}
void Controls::BelongToGeom::SetMesh( const SMDS_Mesh* theMesh )
{
myMeshDS = dynamic_cast<const SMESHDS_Mesh*>(theMesh);
+ init();
}
void Controls::BelongToGeom::SetGeom( const TopoDS_Shape& theShape )
{
myShape = theShape;
+ init();
+}
+
+static bool IsSubShape (const TopTools_IndexedMapOfShape& theMap,
+ const TopoDS_Shape& theShape)
+{
+ if (theMap.Contains(theShape)) return true;
+
+ if (theShape.ShapeType() == TopAbs_COMPOUND ||
+ theShape.ShapeType() == TopAbs_COMPSOLID)
+ {
+ TopoDS_Iterator anIt (theShape, Standard_True, Standard_True);
+ for (; anIt.More(); anIt.Next())
+ {
+ if (!IsSubShape(theMap, anIt.Value())) {
+ return false;
+ }
+ }
+ return true;
+ }
+
+ return false;
+}
+
+void Controls::BelongToGeom::init()
+{
+ if (!myMeshDS || myShape.IsNull()) return;
+
+ // is subshape of main shape?
+ TopoDS_Shape aMainShape = myMeshDS->ShapeToMesh();
+ if (aMainShape.IsNull()) {
+ myIsSubshape = false;
+ }
+ else {
+ TopTools_IndexedMapOfShape aMap;
+ TopExp::MapShapes(aMainShape, aMap);
+ myIsSubshape = IsSubShape(aMap, myShape);
+ }
+
+ if (!myIsSubshape)
+ {
+ myElementsOnShapePtr.reset(new Controls::ElementsOnShape());
+ myElementsOnShapePtr->SetTolerance(myTolerance);
+ myElementsOnShapePtr->SetAllNodes(true); // belong, while false means "lays on"
+ myElementsOnShapePtr->SetMesh(myMeshDS);
+ myElementsOnShapePtr->SetShape(myShape, myType);
+ }
}
static bool IsContains( const SMESHDS_Mesh* theMeshDS,
return false;
}
-bool Controls::BelongToGeom::IsSatisfy( long theId )
+bool Controls::BelongToGeom::IsSatisfy (long theId)
{
- if ( myMeshDS == 0 || myShape.IsNull() )
+ if (myMeshDS == 0 || myShape.IsNull())
return false;
- if( myType == SMDSAbs_Node )
+ if (!myIsSubshape)
+ {
+ return myElementsOnShapePtr->IsSatisfy(theId);
+ }
+
+ // Case of submesh
+ if (myType == SMDSAbs_Node)
{
if( const SMDS_MeshNode* aNode = myMeshDS->FindNode( theId ) )
{
return false;
}
-void Controls::BelongToGeom::SetType( SMDSAbs_ElementType theType )
+void Controls::BelongToGeom::SetType (SMDSAbs_ElementType theType)
{
myType = theType;
+ init();
}
SMDSAbs_ElementType Controls::BelongToGeom::GetType() const
return myShape;
}
-const SMESHDS_Mesh*
-Controls::BelongToGeom::
-GetMeshDS() const
+const SMESHDS_Mesh* Controls::BelongToGeom::GetMeshDS() const
{
return myMeshDS;
}
+void Controls::BelongToGeom::SetTolerance (double theTolerance)
+{
+ myTolerance = theTolerance;
+ if (!myIsSubshape)
+ init();
+}
+
+double Controls::BelongToGeom::GetTolerance()
+{
+ return myTolerance;
+}
+
/*
Class : LyingOnGeom
Description : Predicate for verifying whether entiy lying or partially lying on
*/
Controls::LyingOnGeom::LyingOnGeom()
-: myMeshDS(NULL),
- myType(SMDSAbs_All)
+ : myMeshDS(NULL),
+ myType(SMDSAbs_All),
+ myIsSubshape(false),
+ myTolerance(Precision::Confusion())
{}
void Controls::LyingOnGeom::SetMesh( const SMDS_Mesh* theMesh )
{
myMeshDS = dynamic_cast<const SMESHDS_Mesh*>(theMesh);
+ init();
}
void Controls::LyingOnGeom::SetGeom( const TopoDS_Shape& theShape )
{
myShape = theShape;
+ init();
+}
+
+void Controls::LyingOnGeom::init()
+{
+ if (!myMeshDS || myShape.IsNull()) return;
+
+ // is subshape of main shape?
+ TopoDS_Shape aMainShape = myMeshDS->ShapeToMesh();
+ if (aMainShape.IsNull()) {
+ myIsSubshape = false;
+ }
+ else {
+ TopTools_IndexedMapOfShape aMap;
+ TopExp::MapShapes(aMainShape, aMap);
+ myIsSubshape = IsSubShape(aMap, myShape);
+ }
+
+ if (!myIsSubshape)
+ {
+ myElementsOnShapePtr.reset(new Controls::ElementsOnShape());
+ myElementsOnShapePtr->SetTolerance(myTolerance);
+ myElementsOnShapePtr->SetAllNodes(false); // lays on, while true means "belong"
+ myElementsOnShapePtr->SetMesh(myMeshDS);
+ myElementsOnShapePtr->SetShape(myShape, myType);
+ }
}
bool Controls::LyingOnGeom::IsSatisfy( long theId )
if ( myMeshDS == 0 || myShape.IsNull() )
return false;
+ if (!myIsSubshape)
+ {
+ return myElementsOnShapePtr->IsSatisfy(theId);
+ }
+
+ // Case of submesh
if( myType == SMDSAbs_Node )
{
if( const SMDS_MeshNode* aNode = myMeshDS->FindNode( theId ) )
void Controls::LyingOnGeom::SetType( SMDSAbs_ElementType theType )
{
myType = theType;
+ init();
}
SMDSAbs_ElementType Controls::LyingOnGeom::GetType() const
return myShape;
}
-const SMESHDS_Mesh*
-Controls::LyingOnGeom::
-GetMeshDS() const
+const SMESHDS_Mesh* Controls::LyingOnGeom::GetMeshDS() const
{
return myMeshDS;
}
+void Controls::LyingOnGeom::SetTolerance (double theTolerance)
+{
+ myTolerance = theTolerance;
+ if (!myIsSubshape)
+ init();
+}
+
+double Controls::LyingOnGeom::GetTolerance()
+{
+ return myTolerance;
+}
+
bool Controls::LyingOnGeom::Contains( const SMESHDS_Mesh* theMeshDS,
const TopoDS_Shape& theShape,
const SMDS_MeshElement* theElem,
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();
+ GEOM::GEOM_Gen_ptr aGEOMGen = SMESH_Gen_i::GetGeomEngine();
TopoDS_Shape aLocShape = aSMESHGen->GetShapeReader()->GetShape( aGEOMGen, aGeomObj );
return aLocShape;
}
return TopoDS_Shape();
}
-static TopoDS_Shape getShapeByID( const char* theID )
+static TopoDS_Shape getShapeByID (const char* theID)
{
- if ( theID != 0 && 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 (aStudy != 0) {
+ SALOMEDS::SObject_var aSObj = aStudy->FindObjectID(theID);
+ SALOMEDS::GenericAttribute_var anAttr;
+ if (!aSObj->_is_nil() && aSObj->FindAttribute(anAttr, "AttributeIOR")) {
+ SALOMEDS::AttributeIOR_var anIOR = SALOMEDS::AttributeIOR::_narrow(anAttr);
+ CORBA::String_var aVal = anIOR->Value();
+ CORBA::Object_var obj = aStudy->ConvertIORToObject(aVal);
+ GEOM::GEOM_Object_var aGeomObj = GEOM::GEOM_Object::_narrow(obj);
- if ( !aGeomObj->_is_nil() )
- {
- GEOM::GEOM_Gen_var aGEOMGen = SMESH_Gen_i::GetGeomEngine();
+ if (!aGeomObj->_is_nil()) {
+ GEOM::GEOM_Gen_ptr aGEOMGen = SMESH_Gen_i::GetGeomEngine();
TopoDS_Shape aLocShape = aSMESHGen->GetShapeReader()->GetShape( aGEOMGen, aGeomObj );
return aLocShape;
}
+ }
}
}
return TopoDS_Shape();
}
-static char* getShapeNameByID ( const char* theID )
+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();
- }
- }
+ 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::SObject_var aSObj = aStudy->FindObjectID(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;
}
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<<".Destroy()";
}
void Functor_i::SetMesh( SMESH_Mesh_ptr theMesh )
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<<")";
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
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 )
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
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<<")";
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
long i = 0, iEnd = aBorders.size();
- SMESH::FreeEdges::Borders_var aResult = new SMESH::FreeEdges::Borders(iEnd);
+ 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++ )
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<<".Destroy()";
}
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();
if(!CORBA::is_nil(myMesh))
myMesh->Destroy();
- TPythonDump()<<this<<".Destroy()";
+ //TPythonDump()<<this<<".Destroy()";
}
//=======================================================================
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){
Controls::Filter::TIdSequence aSequence;
GetElementsId(myPredicate,theMesh,aSequence);
long i = 0, iEnd = aSequence.size();
}
case FT_BelongToPlane:
case FT_BelongToCylinder:
+ case FT_BelongToGenSurface:
{
BelongToSurface_i* aPred = dynamic_cast<BelongToSurface_i*>( thePred );
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;
+ if (aThresholdID)
+ pd << "',salome.ObjectToID(" << aThresholdID
+ << ")," << aUnary << "," << aBinary << "," << aTolerance
+ << "," << aTypeOfElem << "," << aPrecision << ")";
+ else
+ pd << "',''," << aUnary << "," << aBinary << "," << aTolerance
+ << "," << aTypeOfElem << "," << aPrecision << ")";
+ }
SMESH::Predicate_ptr aPredicate = SMESH::Predicate::_nil();
SMESH::NumericalFunctor_ptr aFunctor = SMESH::NumericalFunctor::_nil();
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;
// logical op
aPredicates.push_back( aPredicate );
aBinaries.push_back( aBinary );
+ TPythonDump()<<"aCriteria.append(aCriterion)";
} // end of for
TPythonDump()<<this<<".SetCriteria(aCriteria)";
// 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_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_RangeOfIds : return "Range of IDs";
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;
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()
{
delete myFileName;
- TPythonDump()<<this<<".Destroy()";
+ //TPythonDump()<<this<<".Destroy()";
}
//=======================================================================