1 // SMESH SMESH_I : idl implementation based on 'SMESH' unit's calsses
3 // Copyright (C) 2003 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
4 // CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
6 // This library is free software; you can redistribute it and/or
7 // modify it under the terms of the GNU Lesser General Public
8 // License as published by the Free Software Foundation; either
9 // version 2.1 of the License.
11 // This library is distributed in the hope that it will be useful,
12 // but WITHOUT ANY WARRANTY; without even the implied warranty of
13 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 // Lesser General Public License for more details.
16 // You should have received a copy of the GNU Lesser General Public
17 // License along with this library; if not, write to the Free Software
18 // Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
20 // See http://www.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org
24 // File : SMESH_Filter_i.cxx
25 // Author : Alexey Petrov, OCC
29 #include "SMESH_Filter_i.hxx"
31 #include "SMESH_Gen_i.hxx"
33 #include "SMDS_Mesh.hxx"
34 #include "SMDS_MeshNode.hxx"
35 #include "SMDS_MeshElement.hxx"
37 #include "SMESHDS_Mesh.hxx"
39 #include <LDOM_Document.hxx>
40 #include <LDOM_Element.hxx>
41 #include <LDOM_Node.hxx>
42 #include <LDOMString.hxx>
43 #include <LDOMParser.hxx>
44 #include <LDOM_XmlWriter.hxx>
45 #include <TCollection_HAsciiString.hxx>
46 #include <TColStd_ListIteratorOfListOfInteger.hxx>
47 #include <TColStd_ListOfInteger.hxx>
48 #include <TColStd_ListOfReal.hxx>
49 #include <TColStd_MapOfInteger.hxx>
50 #include <TColStd_SequenceOfHAsciiString.hxx>
51 #include <TColStd_ListIteratorOfListOfReal.hxx>
52 #include <Precision.hxx>
53 #include <BRep_Tool.hxx>
54 #include <TopoDS_Shape.hxx>
56 #include <TopoDS_Face.hxx>
57 #include <Geom_Plane.hxx>
58 #include <Geom_CylindricalSurface.hxx>
59 #include <TopExp_Explorer.hxx>
60 #include <OSD_Path.hxx>
61 #include <OSD_File.hxx>
63 using namespace SMESH;
64 using namespace SMESH::Controls;
68 Description : Predicate for verifying whether entiy belong to
69 specified geometrical support
72 Controls::BelongToGeom::BelongToGeom()
77 void Controls::BelongToGeom::SetMesh( SMDS_Mesh* theMesh )
79 myMeshDS = dynamic_cast<SMESHDS_Mesh*>(theMesh);
82 void Controls::BelongToGeom::SetGeom( const TopoDS_Shape& theShape )
87 static bool IsContains( SMESHDS_Mesh* theMeshDS,
88 const TopoDS_Shape& theShape,
89 const SMDS_MeshElement* theElem,
90 TopAbs_ShapeEnum theFindShapeEnum,
91 TopAbs_ShapeEnum theAvoidShapeEnum = TopAbs_SHAPE )
93 TopExp_Explorer anExp( theShape,theFindShapeEnum,theAvoidShapeEnum );
97 const TopoDS_Shape& aShape = anExp.Current();
98 if( SMESHDS_SubMesh* aSubMesh = theMeshDS->MeshElements( aShape ) ){
99 if( aSubMesh->Contains( theElem ) )
107 bool Controls::BelongToGeom::IsSatisfy( long theId )
109 if ( myMeshDS == 0 || myShape.IsNull() )
112 if( myType == SMDSAbs_Node )
114 if( const SMDS_MeshNode* aNode = myMeshDS->FindNode( theId ) )
116 const SMDS_PositionPtr& aPosition = aNode->GetPosition();
117 SMDS_TypeOfPosition aTypeOfPosition = aPosition->GetTypeOfPosition();
118 switch( aTypeOfPosition )
120 case SMDS_TOP_VERTEX : return IsContains( myMeshDS,myShape,aNode,TopAbs_VERTEX );
121 case SMDS_TOP_EDGE : return IsContains( myMeshDS,myShape,aNode,TopAbs_EDGE );
122 case SMDS_TOP_FACE : return IsContains( myMeshDS,myShape,aNode,TopAbs_FACE );
123 case SMDS_TOP_3DSPACE: return IsContains( myMeshDS,myShape,aNode,TopAbs_SHELL );
129 if( const SMDS_MeshElement* anElem = myMeshDS->FindElement( theId ) )
131 if( myType == SMDSAbs_All )
133 return IsContains( myMeshDS,myShape,anElem,TopAbs_EDGE ) ||
134 IsContains( myMeshDS,myShape,anElem,TopAbs_FACE ) ||
135 IsContains( myMeshDS,myShape,anElem,TopAbs_SHELL )||
136 IsContains( myMeshDS,myShape,anElem,TopAbs_SOLID );
138 else if( myType == anElem->GetType() )
142 case SMDSAbs_Edge : return IsContains( myMeshDS,myShape,anElem,TopAbs_EDGE );
143 case SMDSAbs_Face : return IsContains( myMeshDS,myShape,anElem,TopAbs_FACE );
144 case SMDSAbs_Volume: return IsContains( myMeshDS,myShape,anElem,TopAbs_SHELL )||
145 IsContains( myMeshDS,myShape,anElem,TopAbs_SOLID );
154 void Controls::BelongToGeom::SetType( SMDSAbs_ElementType theType )
159 SMDSAbs_ElementType Controls::BelongToGeom::GetType() const
164 TopoDS_Shape Controls::BelongToGeom::GetShape()
169 SMESHDS_Mesh* Controls::BelongToGeom::GetMeshDS()
176 Description : Predicate for verifying whether entiy lying or partially lying on
177 specified geometrical support
180 Controls::LyingOnGeom::LyingOnGeom()
185 void Controls::LyingOnGeom::SetMesh( SMDS_Mesh* theMesh )
187 myMeshDS = dynamic_cast<SMESHDS_Mesh*>(theMesh);
190 void Controls::LyingOnGeom::SetGeom( const TopoDS_Shape& theShape )
195 bool Controls::LyingOnGeom::IsSatisfy( long theId )
197 if ( myMeshDS == 0 || myShape.IsNull() )
200 if( myType == SMDSAbs_Node )
202 if( const SMDS_MeshNode* aNode = myMeshDS->FindNode( theId ) )
204 const SMDS_PositionPtr& aPosition = aNode->GetPosition();
205 SMDS_TypeOfPosition aTypeOfPosition = aPosition->GetTypeOfPosition();
206 switch( aTypeOfPosition )
208 case SMDS_TOP_VERTEX : return IsContains( myMeshDS,myShape,aNode,TopAbs_VERTEX );
209 case SMDS_TOP_EDGE : return IsContains( myMeshDS,myShape,aNode,TopAbs_EDGE );
210 case SMDS_TOP_FACE : return IsContains( myMeshDS,myShape,aNode,TopAbs_FACE );
211 case SMDS_TOP_3DSPACE: return IsContains( myMeshDS,myShape,aNode,TopAbs_SHELL );
217 if( const SMDS_MeshElement* anElem = myMeshDS->FindElement( theId ) )
219 if( myType == SMDSAbs_All )
221 return Contains( myMeshDS,myShape,anElem,TopAbs_EDGE ) ||
222 Contains( myMeshDS,myShape,anElem,TopAbs_FACE ) ||
223 Contains( myMeshDS,myShape,anElem,TopAbs_SHELL )||
224 Contains( myMeshDS,myShape,anElem,TopAbs_SOLID );
226 else if( myType == anElem->GetType() )
230 case SMDSAbs_Edge : return Contains( myMeshDS,myShape,anElem,TopAbs_EDGE );
231 case SMDSAbs_Face : return Contains( myMeshDS,myShape,anElem,TopAbs_FACE );
232 case SMDSAbs_Volume: return Contains( myMeshDS,myShape,anElem,TopAbs_SHELL )||
233 Contains( myMeshDS,myShape,anElem,TopAbs_SOLID );
242 void Controls::LyingOnGeom::SetType( SMDSAbs_ElementType theType )
247 SMDSAbs_ElementType Controls::LyingOnGeom::GetType() const
252 TopoDS_Shape Controls::LyingOnGeom::GetShape()
257 SMESHDS_Mesh* Controls::LyingOnGeom::GetMeshDS()
262 bool Controls::LyingOnGeom::Contains( SMESHDS_Mesh* theMeshDS,
263 const TopoDS_Shape& theShape,
264 const SMDS_MeshElement* theElem,
265 TopAbs_ShapeEnum theFindShapeEnum,
266 TopAbs_ShapeEnum theAvoidShapeEnum )
268 if (IsContains(theMeshDS, theShape, theElem, theFindShapeEnum, theAvoidShapeEnum))
271 TopTools_IndexedMapOfShape aSubShapes;
272 TopExp::MapShapes( theShape, aSubShapes );
274 for (int i = 1; i <= aSubShapes.Extent(); i++)
276 const TopoDS_Shape& aShape = aSubShapes.FindKey(i);
278 if( SMESHDS_SubMesh* aSubMesh = theMeshDS->MeshElements( aShape ) ){
279 if( aSubMesh->Contains( theElem ) )
282 SMDS_NodeIteratorPtr aNodeIt = aSubMesh->GetNodes();
283 while ( aNodeIt->more() )
285 const SMDS_MeshNode* aNode = static_cast<const SMDS_MeshNode*>(aNodeIt->next());
286 SMDS_ElemIteratorPtr anElemIt = aNode->GetInverseElementIterator();
287 while ( anElemIt->more() )
289 const SMDS_MeshElement* anElement = static_cast<const SMDS_MeshElement*>(anElemIt->next());
290 if (anElement == theElem)
304 static inline SMDS_Mesh* MeshPtr2SMDSMesh( SMESH_Mesh_ptr theMesh )
306 SMESH_Mesh_i* anImplPtr =
307 dynamic_cast<SMESH_Mesh_i*>( SMESH_Gen_i::GetServant( theMesh ).in() );
308 return anImplPtr ? anImplPtr->GetImpl().GetMeshDS() : 0;
311 static inline SMESH::long_array* toArray( const TColStd_ListOfInteger& aList )
313 SMESH::long_array_var anArray = new SMESH::long_array;
314 anArray->length( aList.Extent() );
315 TColStd_ListIteratorOfListOfInteger anIter( aList );
317 for( ; anIter.More(); anIter.Next() )
318 anArray[ i++ ] = anIter.Value();
320 return anArray._retn();
323 static inline SMESH::double_array* toArray( const TColStd_ListOfReal& aList )
325 SMESH::double_array_var anArray = new SMESH::double_array;
326 anArray->length( aList.Extent() );
327 TColStd_ListIteratorOfListOfReal anIter( aList );
329 for( ; anIter.More(); anIter.Next() )
330 anArray[ i++ ] = anIter.Value();
332 return anArray._retn();
335 static SMESH::Filter::Criterion createCriterion()
337 SMESH::Filter::Criterion aCriterion;
339 aCriterion.Type = FT_Undefined;
340 aCriterion.Compare = FT_Undefined;
341 aCriterion.Threshold = 0;
342 aCriterion.UnaryOp = FT_Undefined;
343 aCriterion.BinaryOp = FT_Undefined;
344 aCriterion.ThresholdStr = "";
345 aCriterion.ThresholdID = "";
346 aCriterion.Tolerance = Precision::Confusion();
347 aCriterion.TypeOfElement = SMESH::ALL;
348 aCriterion.Precision = -1;
353 static TopoDS_Shape getShapeByName( const char* theName )
357 SMESH_Gen_i* aSMESHGen = SMESH_Gen_i::GetSMESHGen();
358 SALOMEDS::Study_ptr aStudy = aSMESHGen->GetCurrentStudy();
361 SALOMEDS::Study::ListOfSObject_var aList =
362 aStudy->FindObjectByName( theName, "GEOM" );
363 if ( aList->length() > 0 )
365 GEOM::GEOM_Object_var aGeomObj = GEOM::GEOM_Object::_narrow( aList[ 0 ]->GetObject() );
366 if ( !aGeomObj->_is_nil() )
368 GEOM::GEOM_Gen_var aGEOMGen = SMESH_Gen_i::GetGeomEngine();
369 TopoDS_Shape aLocShape = aSMESHGen->GetShapeReader()->GetShape( aGEOMGen, aGeomObj );
375 return TopoDS_Shape();
378 static TopoDS_Shape getShapeByID( const char* theID )
380 if ( theID != 0 && theID!="" )
382 SMESH_Gen_i* aSMESHGen = SMESH_Gen_i::GetSMESHGen();
383 SALOMEDS::Study_ptr aStudy = aSMESHGen->GetCurrentStudy();
386 CORBA::Object_var obj = aStudy->ConvertIORToObject(theID);
387 GEOM::GEOM_Object_var aGeomObj = GEOM::GEOM_Object::_narrow( obj );
389 if ( !aGeomObj->_is_nil() )
391 GEOM::GEOM_Gen_var aGEOMGen = SMESH_Gen_i::GetGeomEngine();
392 TopoDS_Shape aLocShape = aSMESHGen->GetShapeReader()->GetShape( aGEOMGen, aGeomObj );
397 return TopoDS_Shape();
400 static char* getShapeNameByID ( const char* theID )
404 if ( theID != 0 && theID!="" )
406 SMESH_Gen_i* aSMESHGen = SMESH_Gen_i::GetSMESHGen();
407 SALOMEDS::Study_ptr aStudy = aSMESHGen->GetCurrentStudy();
410 SALOMEDS::SObject_var aSObj = aStudy->FindObjectIOR( theID );
411 SALOMEDS::GenericAttribute_var anAttr;
412 if ( !aSObj->_is_nil() && aSObj->FindAttribute( anAttr, "AttributeName") )
414 SALOMEDS::AttributeName_var aNameAttr = SALOMEDS::AttributeName::_narrow( anAttr );
415 aName = aNameAttr->Value();
429 Description : An abstact class for all functors
431 Functor_i::Functor_i():
432 SALOME::GenericObj_i( SMESH_Gen_i::GetPOA() )
434 SMESH_Gen_i::GetPOA()->activate_object( this );
437 void Functor_i::SetMesh( SMESH_Mesh_ptr theMesh )
439 myFunctorPtr->SetMesh( MeshPtr2SMDSMesh( theMesh ) );
440 INFOS("Functor_i::SetMesh~");
443 ElementType Functor_i::GetElementType()
445 return ( ElementType )myFunctorPtr->GetType();
450 Class : NumericalFunctor_i
451 Description : Base class for numerical functors
453 CORBA::Double NumericalFunctor_i::GetValue( CORBA::Long theId )
455 return myNumericalFunctorPtr->GetValue( theId );
458 void NumericalFunctor_i::SetPrecision( CORBA::Long thePrecision )
460 myNumericalFunctorPtr->SetPrecision( thePrecision );
463 CORBA::Long NumericalFunctor_i::GetPrecision()
465 return myNumericalFunctorPtr->GetPrecision();
468 Controls::NumericalFunctorPtr NumericalFunctor_i::GetNumericalFunctor()
470 return myNumericalFunctorPtr;
475 Class : SMESH_MinimumAngle
476 Description : Functor for calculation of minimum angle
478 MinimumAngle_i::MinimumAngle_i()
480 myNumericalFunctorPtr.reset( new Controls::MinimumAngle() );
481 myFunctorPtr = myNumericalFunctorPtr;
484 FunctorType MinimumAngle_i::GetFunctorType()
486 return SMESH::FT_MinimumAngle;
492 Description : Functor for calculating aspect ratio
494 AspectRatio_i::AspectRatio_i()
496 myNumericalFunctorPtr.reset( new Controls::AspectRatio() );
497 myFunctorPtr = myNumericalFunctorPtr;
500 FunctorType AspectRatio_i::GetFunctorType()
502 return SMESH::FT_AspectRatio;
507 Class : AspectRatio3D
508 Description : Functor for calculating aspect ratio 3D
510 AspectRatio3D_i::AspectRatio3D_i()
512 myNumericalFunctorPtr.reset( new Controls::AspectRatio3D() );
513 myFunctorPtr = myNumericalFunctorPtr;
516 FunctorType AspectRatio3D_i::GetFunctorType()
518 return SMESH::FT_AspectRatio3D;
524 Description : Functor for calculating warping
526 Warping_i::Warping_i()
528 myNumericalFunctorPtr.reset( new Controls::Warping() );
529 myFunctorPtr = myNumericalFunctorPtr;
532 FunctorType Warping_i::GetFunctorType()
534 return SMESH::FT_Warping;
540 Description : Functor for calculating taper
544 myNumericalFunctorPtr.reset( new Controls::Taper() );
545 myFunctorPtr = myNumericalFunctorPtr;
548 FunctorType Taper_i::GetFunctorType()
550 return SMESH::FT_Taper;
556 Description : Functor for calculating skew in degrees
560 myNumericalFunctorPtr.reset( new Controls::Skew() );
561 myFunctorPtr = myNumericalFunctorPtr;
564 FunctorType Skew_i::GetFunctorType()
566 return SMESH::FT_Skew;
571 Description : Functor for calculating area
575 myNumericalFunctorPtr.reset( new Controls::Area() );
576 myFunctorPtr = myNumericalFunctorPtr;
579 FunctorType Area_i::GetFunctorType()
581 return SMESH::FT_Area;
586 Description : Functor for calculating length off edge
590 myNumericalFunctorPtr.reset( new Controls::Length() );
591 myFunctorPtr = myNumericalFunctorPtr;
594 FunctorType Length_i::GetFunctorType()
596 return SMESH::FT_Length;
601 Description : Functor for calculating length of edge
603 Length2D_i::Length2D_i()
605 myNumericalFunctorPtr.reset( new Controls::Length2D() );
606 myFunctorPtr = myNumericalFunctorPtr;
609 FunctorType Length2D_i::GetFunctorType()
611 return SMESH::FT_Length2D;
614 SMESH::Length2D::Values* Length2D_i::GetValues()
616 INFOS("Length2D_i::GetValues");
617 SMESH::Controls::Length2D::TValues aValues;
618 myLength2DPtr->GetValues( aValues );
620 long i = 0, iEnd = aValues.size();
622 SMESH::Length2D::Values_var aResult = new SMESH::Length2D::Values(iEnd);
624 SMESH::Controls::Length2D::TValues::const_iterator anIter;
625 for ( anIter = aValues.begin() ; anIter != aValues.end(); anIter++, i++ )
627 const SMESH::Controls::Length2D::Value& aVal = *anIter;
628 SMESH::Length2D::Value &aValue = aResult[ i ];
630 aValue.myLength = aVal.myLength;
631 aValue.myPnt1 = aVal.myPntId[ 0 ];
632 aValue.myPnt2 = aVal.myPntId[ 1 ];
636 INFOS("Length2D_i::GetValuess~");
637 return aResult._retn();
641 Class : MultiConnection_i
642 Description : Functor for calculating number of faces conneted to the edge
644 MultiConnection_i::MultiConnection_i()
646 myNumericalFunctorPtr.reset( new Controls::MultiConnection() );
647 myFunctorPtr = myNumericalFunctorPtr;
650 FunctorType MultiConnection_i::GetFunctorType()
652 return SMESH::FT_MultiConnection;
656 Class : MultiConnection2D_i
657 Description : Functor for calculating number of faces conneted to the edge
659 MultiConnection2D_i::MultiConnection2D_i()
661 myNumericalFunctorPtr.reset( new Controls::MultiConnection2D() );
662 myFunctorPtr = myNumericalFunctorPtr;
665 FunctorType MultiConnection2D_i::GetFunctorType()
667 return SMESH::FT_MultiConnection2D;
670 SMESH::MultiConnection2D::Values* MultiConnection2D_i::GetValues()
672 INFOS("MultiConnection2D_i::GetValues");
673 SMESH::Controls::MultiConnection2D::MValues aValues;
674 myMulticonnection2DPtr->GetValues( aValues );
676 long i = 0, iEnd = aValues.size();
678 SMESH::MultiConnection2D::Values_var aResult = new SMESH::MultiConnection2D::Values(iEnd);
680 SMESH::Controls::MultiConnection2D::MValues::const_iterator anIter;
681 for ( anIter = aValues.begin() ; anIter != aValues.end(); anIter++, i++ )
683 const SMESH::Controls::MultiConnection2D::Value& aVal = (*anIter).first;
684 SMESH::MultiConnection2D::Value &aValue = aResult[ i ];
686 aValue.myPnt1 = aVal.myPntId[ 0 ];
687 aValue.myPnt2 = aVal.myPntId[ 1 ];
688 aValue.myNbConnects = (*anIter).second;
692 INFOS("Multiconnection2D_i::GetValuess~");
693 return aResult._retn();
703 Description : Base class for all predicates
705 CORBA::Boolean Predicate_i::IsSatisfy( CORBA::Long theId )
707 return myPredicatePtr->IsSatisfy( theId );
710 Controls::PredicatePtr Predicate_i::GetPredicate()
712 return myPredicatePtr;
716 Class : BadOrientedVolume_i
717 Description : Verify whether a mesh volume is incorrectly oriented from
718 the point of view of MED convention
720 BadOrientedVolume_i::BadOrientedVolume_i()
722 Controls::PredicatePtr control( new Controls::BadOrientedVolume() );
723 myFunctorPtr = myPredicatePtr = control;
726 FunctorType BadOrientedVolume_i::GetFunctorType()
728 return SMESH::FT_BadOrientedVolume;
732 Class : BelongToGeom_i
733 Description : Predicate for selection on geometrical support
735 BelongToGeom_i::BelongToGeom_i()
737 myBelongToGeomPtr.reset( new Controls::BelongToGeom() );
738 myFunctorPtr = myPredicatePtr = myBelongToGeomPtr;
743 BelongToGeom_i::~BelongToGeom_i()
749 void BelongToGeom_i::SetGeom( GEOM::GEOM_Object_ptr theGeom )
751 if ( theGeom->_is_nil() )
753 SMESH_Gen_i* aSMESHGen = SMESH_Gen_i::GetSMESHGen();
754 GEOM::GEOM_Gen_var aGEOMGen = SMESH_Gen_i::GetGeomEngine();
755 TopoDS_Shape aLocShape = aSMESHGen->GetShapeReader()->GetShape( aGEOMGen, theGeom );
756 myBelongToGeomPtr->SetGeom( aLocShape );
759 void BelongToGeom_i::SetGeom( const TopoDS_Shape& theShape )
761 myBelongToGeomPtr->SetGeom( theShape );
764 void BelongToGeom_i::SetElementType(ElementType theType){
765 myBelongToGeomPtr->SetType(SMDSAbs_ElementType(theType));
768 FunctorType BelongToGeom_i::GetFunctorType()
770 return SMESH::FT_BelongToGeom;
773 void BelongToGeom_i::SetShapeName( const char* theName )
776 myShapeName = strdup( theName );
777 myBelongToGeomPtr->SetGeom( getShapeByName( myShapeName ) );
780 void BelongToGeom_i::SetShape( const char* theID, const char* theName )
783 myShapeName = strdup( theName );
786 myShapeID = strdup( theID );
790 if ( myShapeID && strcmp(myShapeName, getShapeNameByID(myShapeID)) == 0 )
791 myBelongToGeomPtr->SetGeom( getShapeByID(myShapeID) );
793 myBelongToGeomPtr->SetGeom( getShapeByName( myShapeName ) );
796 char* BelongToGeom_i::GetShapeName()
798 return CORBA::string_dup( myShapeName );
801 char* BelongToGeom_i::GetShapeID()
803 return CORBA::string_dup( myShapeID );
807 Class : BelongToSurface_i
808 Description : Predicate for selection on geometrical support
810 BelongToSurface_i::BelongToSurface_i( const Handle(Standard_Type)& theSurfaceType )
812 myElementsOnSurfacePtr.reset( new Controls::ElementsOnSurface() );
813 myFunctorPtr = myPredicatePtr = myElementsOnSurfacePtr;
816 mySurfaceType = theSurfaceType;
819 BelongToSurface_i::~BelongToSurface_i()
825 void BelongToSurface_i::SetSurface( GEOM::GEOM_Object_ptr theGeom, ElementType theType )
827 if ( theGeom->_is_nil() )
829 SMESH_Gen_i* aSMESHGen = SMESH_Gen_i::GetSMESHGen();
830 GEOM::GEOM_Gen_var aGEOMGen = SMESH_Gen_i::GetGeomEngine();
831 TopoDS_Shape aLocShape = aSMESHGen->GetShapeReader()->GetShape( aGEOMGen, theGeom );
833 if ( aLocShape.ShapeType() == TopAbs_FACE )
835 Handle(Geom_Surface) aSurf = BRep_Tool::Surface( TopoDS::Face( aLocShape ) );
836 if ( !aSurf.IsNull() && aSurf->DynamicType() == mySurfaceType )
838 myElementsOnSurfacePtr->SetSurface( aLocShape, (SMDSAbs_ElementType)theType );
843 myElementsOnSurfacePtr->SetSurface( TopoDS_Shape(), (SMDSAbs_ElementType)theType );
846 void BelongToSurface_i::SetShapeName( const char* theName, ElementType theType )
849 myShapeName = strdup( theName );
850 myElementsOnSurfacePtr->SetSurface( getShapeByName( myShapeName ), (SMDSAbs_ElementType)theType );
853 void BelongToSurface_i::SetShape( const char* theID, const char* theName, ElementType theType )
856 myShapeName = strdup( theName );
859 myShapeID = strdup( theID );
863 if ( myShapeID && strcmp(myShapeName, getShapeNameByID(myShapeID)) == 0 )
864 myElementsOnSurfacePtr->SetSurface( getShapeByID(myShapeID), (SMDSAbs_ElementType)theType );
866 myElementsOnSurfacePtr->SetSurface( getShapeByName( myShapeName ), (SMDSAbs_ElementType)theType );
869 char* BelongToSurface_i::GetShapeName()
871 return CORBA::string_dup( myShapeName );
874 char* BelongToSurface_i::GetShapeID()
876 return CORBA::string_dup( myShapeID );
879 void BelongToSurface_i::SetTolerance( CORBA::Double theToler )
881 myElementsOnSurfacePtr->SetTolerance( theToler );
884 CORBA::Double BelongToSurface_i::GetTolerance()
886 return myElementsOnSurfacePtr->GetTolerance();
890 Class : BelongToPlane_i
891 Description : Verify whether mesh element lie in pointed Geom planar object
894 BelongToPlane_i::BelongToPlane_i()
895 : BelongToSurface_i( STANDARD_TYPE( Geom_Plane ) )
899 void BelongToPlane_i::SetPlane( GEOM::GEOM_Object_ptr theGeom, ElementType theType )
901 BelongToSurface_i::SetSurface( theGeom, theType );
904 FunctorType BelongToPlane_i::GetFunctorType()
906 return FT_BelongToPlane;
910 Class : BelongToCylinder_i
911 Description : Verify whether mesh element lie in pointed Geom planar object
914 BelongToCylinder_i::BelongToCylinder_i()
915 : BelongToSurface_i( STANDARD_TYPE( Geom_CylindricalSurface ) )
919 void BelongToCylinder_i::SetCylinder( GEOM::GEOM_Object_ptr theGeom, ElementType theType )
921 BelongToSurface_i::SetSurface( theGeom, theType );
924 FunctorType BelongToCylinder_i::GetFunctorType()
926 return FT_BelongToCylinder;
930 Class : LyingOnGeom_i
931 Description : Predicate for selection on geometrical support
933 LyingOnGeom_i::LyingOnGeom_i()
935 myLyingOnGeomPtr.reset( new Controls::LyingOnGeom() );
936 myFunctorPtr = myPredicatePtr = myLyingOnGeomPtr;
941 LyingOnGeom_i::~LyingOnGeom_i()
947 void LyingOnGeom_i::SetGeom( GEOM::GEOM_Object_ptr theGeom )
949 if ( theGeom->_is_nil() )
951 SMESH_Gen_i* aSMESHGen = SMESH_Gen_i::GetSMESHGen();
952 GEOM::GEOM_Gen_var aGEOMGen = SMESH_Gen_i::GetGeomEngine();
953 TopoDS_Shape aLocShape = aSMESHGen->GetShapeReader()->GetShape( aGEOMGen, theGeom );
954 myLyingOnGeomPtr->SetGeom( aLocShape );
957 void LyingOnGeom_i::SetGeom( const TopoDS_Shape& theShape )
959 myLyingOnGeomPtr->SetGeom( theShape );
962 void LyingOnGeom_i::SetElementType(ElementType theType){
963 myLyingOnGeomPtr->SetType(SMDSAbs_ElementType(theType));
966 FunctorType LyingOnGeom_i::GetFunctorType()
968 return SMESH::FT_LyingOnGeom;
971 void LyingOnGeom_i::SetShapeName( const char* theName )
974 myShapeName = strdup( theName );
975 myLyingOnGeomPtr->SetGeom( getShapeByName( myShapeName ) );
978 void LyingOnGeom_i::SetShape( const char* theID, const char* theName )
981 myShapeName = strdup( theName );
984 myShapeID = strdup( theID );
988 if ( myShapeID && strcmp(myShapeName, getShapeNameByID(myShapeID)) == 0 )
989 myLyingOnGeomPtr->SetGeom( getShapeByID(myShapeID) );
991 myLyingOnGeomPtr->SetGeom( getShapeByName( myShapeName ) );
994 char* LyingOnGeom_i::GetShapeName()
996 return CORBA::string_dup( myShapeName );
999 char* LyingOnGeom_i::GetShapeID()
1001 return CORBA::string_dup( myShapeID );
1005 Class : FreeBorders_i
1006 Description : Predicate for free borders
1008 FreeBorders_i::FreeBorders_i()
1010 myPredicatePtr.reset(new Controls::FreeBorders());
1011 myFunctorPtr = myPredicatePtr;
1014 FunctorType FreeBorders_i::GetFunctorType()
1016 return SMESH::FT_FreeBorders;
1021 Description : Predicate for free borders
1023 FreeEdges_i::FreeEdges_i()
1024 : myFreeEdgesPtr( new Controls::FreeEdges() )
1026 myFunctorPtr = myPredicatePtr = myFreeEdgesPtr;
1029 SMESH::FreeEdges::Borders* FreeEdges_i::GetBorders()
1031 INFOS("FreeEdges_i::GetBorders");
1032 SMESH::Controls::FreeEdges::TBorders aBorders;
1033 myFreeEdgesPtr->GetBoreders( aBorders );
1035 long i = 0, iEnd = aBorders.size();
1037 SMESH::FreeEdges::Borders_var aResult = new SMESH::FreeEdges::Borders(iEnd);
1039 SMESH::Controls::FreeEdges::TBorders::const_iterator anIter;
1040 for ( anIter = aBorders.begin() ; anIter != aBorders.end(); anIter++, i++ )
1042 const SMESH::Controls::FreeEdges::Border& aBord = *anIter;
1043 SMESH::FreeEdges::Border &aBorder = aResult[ i ];
1045 aBorder.myElemId = aBord.myElemId;
1046 aBorder.myPnt1 = aBord.myPntId[ 0 ];
1047 aBorder.myPnt2 = aBord.myPntId[ 1 ];
1050 INFOS("FreeEdges_i::GetBorders~");
1051 return aResult._retn();
1054 FunctorType FreeEdges_i::GetFunctorType()
1056 return SMESH::FT_FreeEdges;
1060 Class : RangeOfIds_i
1061 Description : Predicate for Range of Ids.
1062 Range may be specified with two ways.
1063 1. Using AddToRange method
1064 2. With SetRangeStr method. Parameter of this method is a string
1065 like as "1,2,3,50-60,63,67,70-"
1068 RangeOfIds_i::RangeOfIds_i()
1070 myRangeOfIdsPtr.reset( new Controls::RangeOfIds() );
1071 myFunctorPtr = myPredicatePtr = myRangeOfIdsPtr;
1074 void RangeOfIds_i::SetRange( const SMESH::long_array& theIds )
1076 CORBA::Long iEnd = theIds.length();
1077 for ( CORBA::Long i = 0; i < iEnd; i++ )
1078 myRangeOfIdsPtr->AddToRange( theIds[ i ] );
1081 CORBA::Boolean RangeOfIds_i::SetRangeStr( const char* theRange )
1083 return myRangeOfIdsPtr->SetRangeStr(
1084 TCollection_AsciiString( (Standard_CString)theRange ) );
1087 char* RangeOfIds_i::GetRangeStr()
1089 TCollection_AsciiString aStr;
1090 myRangeOfIdsPtr->GetRangeStr( aStr );
1091 return CORBA::string_dup( aStr.ToCString() );
1094 void RangeOfIds_i::SetElementType( ElementType theType )
1096 myRangeOfIdsPtr->SetType( SMDSAbs_ElementType( theType ) );
1099 FunctorType RangeOfIds_i::GetFunctorType()
1101 return SMESH::FT_RangeOfIds;
1105 Class : Comparator_i
1106 Description : Base class for comparators
1108 Comparator_i::Comparator_i():
1109 myNumericalFunctor( NULL )
1112 Comparator_i::~Comparator_i()
1114 if ( myNumericalFunctor )
1115 myNumericalFunctor->Destroy();
1118 void Comparator_i::SetMargin( CORBA::Double theValue )
1120 myComparatorPtr->SetMargin( theValue );
1123 CORBA::Double Comparator_i::GetMargin()
1125 return myComparatorPtr->GetMargin();
1128 void Comparator_i::SetNumFunctor( NumericalFunctor_ptr theFunct )
1130 if ( myNumericalFunctor )
1131 myNumericalFunctor->Destroy();
1133 myNumericalFunctor = dynamic_cast<NumericalFunctor_i*>( SMESH_Gen_i::GetServant( theFunct ).in() );
1135 if ( myNumericalFunctor )
1137 myComparatorPtr->SetNumFunctor( myNumericalFunctor->GetNumericalFunctor() );
1138 myNumericalFunctor->Register();
1142 Controls::ComparatorPtr Comparator_i::GetComparator()
1144 return myComparatorPtr;
1147 NumericalFunctor_i* Comparator_i::GetNumFunctor_i()
1149 return myNumericalFunctor;
1155 Description : Comparator "<"
1157 LessThan_i::LessThan_i()
1159 myComparatorPtr.reset( new Controls::LessThan() );
1160 myFunctorPtr = myPredicatePtr = myComparatorPtr;
1163 FunctorType LessThan_i::GetFunctorType()
1165 return SMESH::FT_LessThan;
1171 Description : Comparator ">"
1173 MoreThan_i::MoreThan_i()
1175 myComparatorPtr.reset( new Controls::MoreThan() );
1176 myFunctorPtr = myPredicatePtr = myComparatorPtr;
1179 FunctorType MoreThan_i::GetFunctorType()
1181 return SMESH::FT_MoreThan;
1187 Description : Comparator "="
1189 EqualTo_i::EqualTo_i()
1190 : myEqualToPtr( new Controls::EqualTo() )
1192 myFunctorPtr = myPredicatePtr = myComparatorPtr = myEqualToPtr;
1195 void EqualTo_i::SetTolerance( CORBA::Double theToler )
1197 myEqualToPtr->SetTolerance( theToler );
1200 CORBA::Double EqualTo_i::GetTolerance()
1202 return myEqualToPtr->GetTolerance();
1205 FunctorType EqualTo_i::GetFunctorType()
1207 return SMESH::FT_EqualTo;
1211 Class : LogicalNOT_i
1212 Description : Logical NOT predicate
1214 LogicalNOT_i::LogicalNOT_i()
1215 : myPredicate( NULL ),
1216 myLogicalNOTPtr( new Controls::LogicalNOT() )
1218 myFunctorPtr = myPredicatePtr = myLogicalNOTPtr;
1221 LogicalNOT_i::~LogicalNOT_i()
1224 myPredicate->Destroy();
1227 void LogicalNOT_i::SetPredicate( Predicate_ptr thePred )
1230 myPredicate->Destroy();
1232 myPredicate = dynamic_cast<Predicate_i*>( SMESH_Gen_i::GetServant( thePred ).in() );
1235 myLogicalNOTPtr->SetPredicate(myPredicate->GetPredicate());
1236 myPredicate->Register();
1240 FunctorType LogicalNOT_i::GetFunctorType()
1242 return SMESH::FT_LogicalNOT;
1245 Predicate_i* LogicalNOT_i::GetPredicate_i()
1252 Class : LogicalBinary_i
1253 Description : Base class for binary logical predicate
1255 LogicalBinary_i::LogicalBinary_i()
1256 : myPredicate1( NULL ),
1257 myPredicate2( NULL )
1260 LogicalBinary_i::~LogicalBinary_i()
1263 myPredicate1->Destroy();
1266 myPredicate2->Destroy();
1269 void LogicalBinary_i::SetMesh( SMESH_Mesh_ptr theMesh )
1272 myPredicate1->SetMesh( theMesh );
1275 myPredicate2->SetMesh( theMesh );
1278 void LogicalBinary_i::SetPredicate1( Predicate_ptr thePredicate )
1281 myPredicate1->Destroy();
1283 myPredicate1 = dynamic_cast<Predicate_i*>( SMESH_Gen_i::GetServant( thePredicate ).in() );
1285 if ( myPredicate1 ){
1286 myLogicalBinaryPtr->SetPredicate1(myPredicate1->GetPredicate());
1287 myPredicate1->Register();
1291 void LogicalBinary_i::SetPredicate2( Predicate_ptr thePredicate )
1294 myPredicate2->Destroy();
1296 myPredicate2 = dynamic_cast<Predicate_i*>( SMESH_Gen_i::GetServant( thePredicate ).in() );
1298 if ( myPredicate2 ){
1299 myLogicalBinaryPtr->SetPredicate2(myPredicate2->GetPredicate());
1300 myPredicate2->Register();
1304 Controls::LogicalBinaryPtr LogicalBinary_i::GetLogicalBinary()
1306 return myLogicalBinaryPtr;
1309 Predicate_i* LogicalBinary_i::GetPredicate1_i()
1311 return myPredicate1;
1313 Predicate_i* LogicalBinary_i::GetPredicate2_i()
1315 return myPredicate2;
1320 Class : LogicalAND_i
1321 Description : Logical AND
1323 LogicalAND_i::LogicalAND_i()
1325 myLogicalBinaryPtr.reset( new Controls::LogicalAND() );
1326 myFunctorPtr = myPredicatePtr = myLogicalBinaryPtr;
1329 FunctorType LogicalAND_i::GetFunctorType()
1331 return SMESH::FT_LogicalAND;
1337 Description : Logical OR
1339 LogicalOR_i::LogicalOR_i()
1341 myLogicalBinaryPtr.reset( new Controls::LogicalOR() );
1342 myFunctorPtr = myPredicatePtr = myLogicalBinaryPtr;
1345 FunctorType LogicalOR_i::GetFunctorType()
1347 return SMESH::FT_LogicalOR;
1355 FilterManager_i::FilterManager_i()
1356 : SALOME::GenericObj_i( SMESH_Gen_i::GetPOA() )
1358 SMESH_Gen_i::GetPOA()->activate_object( this );
1361 MinimumAngle_ptr FilterManager_i::CreateMinimumAngle()
1363 SMESH::MinimumAngle_i* aServant = new SMESH::MinimumAngle_i();
1364 SMESH::MinimumAngle_var anObj = aServant->_this();
1365 return anObj._retn();
1369 AspectRatio_ptr FilterManager_i::CreateAspectRatio()
1371 SMESH::AspectRatio_i* aServant = new SMESH::AspectRatio_i();
1372 SMESH::AspectRatio_var anObj = aServant->_this();
1373 return anObj._retn();
1377 AspectRatio3D_ptr FilterManager_i::CreateAspectRatio3D()
1379 SMESH::AspectRatio3D_i* aServant = new SMESH::AspectRatio3D_i();
1380 SMESH::AspectRatio3D_var anObj = aServant->_this();
1381 return anObj._retn();
1385 Warping_ptr FilterManager_i::CreateWarping()
1387 SMESH::Warping_i* aServant = new SMESH::Warping_i();
1388 SMESH::Warping_var anObj = aServant->_this();
1389 return anObj._retn();
1393 Taper_ptr FilterManager_i::CreateTaper()
1395 SMESH::Taper_i* aServant = new SMESH::Taper_i();
1396 SMESH::Taper_var anObj = aServant->_this();
1397 return anObj._retn();
1401 Skew_ptr FilterManager_i::CreateSkew()
1403 SMESH::Skew_i* aServant = new SMESH::Skew_i();
1404 SMESH::Skew_var anObj = aServant->_this();
1405 return anObj._retn();
1409 Area_ptr FilterManager_i::CreateArea()
1411 SMESH::Area_i* aServant = new SMESH::Area_i();
1412 SMESH::Area_var anObj = aServant->_this();
1413 return anObj._retn();
1417 Length_ptr FilterManager_i::CreateLength()
1419 SMESH::Length_i* aServant = new SMESH::Length_i();
1420 SMESH::Length_var anObj = aServant->_this();
1421 return anObj._retn();
1424 Length2D_ptr FilterManager_i::CreateLength2D()
1426 SMESH::Length2D_i* aServant = new SMESH::Length2D_i();
1427 SMESH::Length2D_var anObj = aServant->_this();
1428 return anObj._retn();
1431 MultiConnection_ptr FilterManager_i::CreateMultiConnection()
1433 SMESH::MultiConnection_i* aServant = new SMESH::MultiConnection_i();
1434 SMESH::MultiConnection_var anObj = aServant->_this();
1435 return anObj._retn();
1438 MultiConnection2D_ptr FilterManager_i::CreateMultiConnection2D()
1440 SMESH::MultiConnection2D_i* aServant = new SMESH::MultiConnection2D_i();
1441 SMESH::MultiConnection2D_var anObj = aServant->_this();
1442 return anObj._retn();
1445 BelongToGeom_ptr FilterManager_i::CreateBelongToGeom()
1447 SMESH::BelongToGeom_i* aServant = new SMESH::BelongToGeom_i();
1448 SMESH::BelongToGeom_var anObj = aServant->_this();
1449 return anObj._retn();
1452 BelongToPlane_ptr FilterManager_i::CreateBelongToPlane()
1454 SMESH::BelongToPlane_i* aServant = new SMESH::BelongToPlane_i();
1455 SMESH::BelongToPlane_var anObj = aServant->_this();
1456 return anObj._retn();
1459 BelongToCylinder_ptr FilterManager_i::CreateBelongToCylinder()
1461 SMESH::BelongToCylinder_i* aServant = new SMESH::BelongToCylinder_i();
1462 SMESH::BelongToCylinder_var anObj = aServant->_this();
1463 return anObj._retn();
1466 LyingOnGeom_ptr FilterManager_i::CreateLyingOnGeom()
1468 SMESH::LyingOnGeom_i* aServant = new SMESH::LyingOnGeom_i();
1469 SMESH::LyingOnGeom_var anObj = aServant->_this();
1470 return anObj._retn();
1473 FreeBorders_ptr FilterManager_i::CreateFreeBorders()
1475 SMESH::FreeBorders_i* aServant = new SMESH::FreeBorders_i();
1476 SMESH::FreeBorders_var anObj = aServant->_this();
1477 return anObj._retn();
1480 FreeEdges_ptr FilterManager_i::CreateFreeEdges()
1482 SMESH::FreeEdges_i* aServant = new SMESH::FreeEdges_i();
1483 SMESH::FreeEdges_var anObj = aServant->_this();
1484 return anObj._retn();
1487 RangeOfIds_ptr FilterManager_i::CreateRangeOfIds()
1489 SMESH::RangeOfIds_i* aServant = new SMESH::RangeOfIds_i();
1490 SMESH::RangeOfIds_var anObj = aServant->_this();
1491 return anObj._retn();
1494 BadOrientedVolume_ptr FilterManager_i::CreateBadOrientedVolume()
1496 SMESH::BadOrientedVolume_i* aServant = new SMESH::BadOrientedVolume_i();
1497 SMESH::BadOrientedVolume_var anObj = aServant->_this();
1498 return anObj._retn();
1501 LessThan_ptr FilterManager_i::CreateLessThan()
1503 SMESH::LessThan_i* aServant = new SMESH::LessThan_i();
1504 SMESH::LessThan_var anObj = aServant->_this();
1505 return anObj._retn();
1509 MoreThan_ptr FilterManager_i::CreateMoreThan()
1511 SMESH::MoreThan_i* aServant = new SMESH::MoreThan_i();
1512 SMESH::MoreThan_var anObj = aServant->_this();
1513 return anObj._retn();
1516 EqualTo_ptr FilterManager_i::CreateEqualTo()
1518 SMESH::EqualTo_i* aServant = new SMESH::EqualTo_i();
1519 SMESH::EqualTo_var anObj = aServant->_this();
1520 return anObj._retn();
1524 LogicalNOT_ptr FilterManager_i::CreateLogicalNOT()
1526 SMESH::LogicalNOT_i* aServant = new SMESH::LogicalNOT_i();
1527 SMESH::LogicalNOT_var anObj = aServant->_this();
1528 return anObj._retn();
1532 LogicalAND_ptr FilterManager_i::CreateLogicalAND()
1534 SMESH::LogicalAND_i* aServant = new SMESH::LogicalAND_i();
1535 SMESH::LogicalAND_var anObj = aServant->_this();
1536 return anObj._retn();
1540 LogicalOR_ptr FilterManager_i::CreateLogicalOR()
1542 SMESH::LogicalOR_i* aServant = new SMESH::LogicalOR_i();
1543 SMESH::LogicalOR_var anObj = aServant->_this();
1544 return anObj._retn();
1547 Filter_ptr FilterManager_i::CreateFilter()
1549 SMESH::Filter_i* aServant = new SMESH::Filter_i();
1550 SMESH::Filter_var anObj = aServant->_this();
1551 return anObj._retn();
1554 FilterLibrary_ptr FilterManager_i::LoadLibrary( const char* aFileName )
1556 SMESH::FilterLibrary_i* aServant = new SMESH::FilterLibrary_i( aFileName );
1557 SMESH::FilterLibrary_var anObj = aServant->_this();
1558 return anObj._retn();
1561 FilterLibrary_ptr FilterManager_i::CreateLibrary()
1563 SMESH::FilterLibrary_i* aServant = new SMESH::FilterLibrary_i();
1564 SMESH::FilterLibrary_var anObj = aServant->_this();
1565 return anObj._retn();
1568 CORBA::Boolean FilterManager_i::DeleteLibrary( const char* aFileName )
1570 return remove( aFileName ) ? false : true;
1573 //=============================================================================
1575 * SMESH_Gen_i::CreateFilterManager
1577 * Create filter manager
1579 //=============================================================================
1581 SMESH::FilterManager_ptr SMESH_Gen_i::CreateFilterManager()
1583 SMESH::FilterManager_i* aFilter = new SMESH::FilterManager_i();
1584 SMESH::FilterManager_var anObj = aFilter->_this();
1585 return anObj._retn();
1593 //=======================================================================
1594 // name : Filter_i::Filter_i
1595 // Purpose : Constructor
1596 //=======================================================================
1597 Filter_i::Filter_i()
1598 : myPredicate( NULL )
1601 //=======================================================================
1602 // name : Filter_i::~Filter_i
1603 // Purpose : Destructor
1604 //=======================================================================
1605 Filter_i::~Filter_i()
1608 myPredicate->Destroy();
1611 //=======================================================================
1612 // name : Filter_i::SetPredicate
1613 // Purpose : Set predicate
1614 //=======================================================================
1615 void Filter_i::SetPredicate( Predicate_ptr thePredicate )
1618 myPredicate->Destroy();
1620 myPredicate = dynamic_cast<Predicate_i*>( SMESH_Gen_i::GetServant( thePredicate ).in() );
1624 myFilter.SetPredicate( myPredicate->GetPredicate() );
1625 myPredicate->Register();
1629 //=======================================================================
1630 // name : Filter_i::GetElementType
1631 // Purpose : Get entity type
1632 //=======================================================================
1633 SMESH::ElementType Filter_i::GetElementType()
1635 return myPredicate != 0 ? myPredicate->GetElementType() : SMESH::ALL;
1638 //=======================================================================
1639 // name : Filter_i::SetMesh
1640 // Purpose : Set mesh
1641 //=======================================================================
1642 void Filter_i::SetMesh( SMESH_Mesh_ptr theMesh )
1645 myPredicate->SetMesh( theMesh );
1648 //=======================================================================
1649 // name : Filter_i::GetElementsId
1650 // Purpose : Get ids of entities
1651 //=======================================================================
1652 SMESH::long_array* Filter_i::GetElementsId( SMESH_Mesh_ptr theMesh )
1654 SMDS_Mesh* aMesh = MeshPtr2SMDSMesh(theMesh);
1655 Controls::Filter::TIdSequence aSequence = myFilter.GetElementsId(aMesh);
1657 SMESH::long_array_var anArray = new SMESH::long_array;
1658 long i = 0, iEnd = aSequence.size();
1660 anArray->length( iEnd );
1661 for ( ; i < iEnd; i++ )
1662 anArray[ i ] = aSequence[i];
1664 return anArray._retn();
1667 //=======================================================================
1668 // name : getCriteria
1669 // Purpose : Retrieve criterions from predicate
1670 //=======================================================================
1671 static inline bool getCriteria( Predicate_i* thePred,
1672 SMESH::Filter::Criteria_out theCriteria )
1674 int aFType = thePred->GetFunctorType();
1678 case FT_FreeBorders:
1681 CORBA::ULong i = theCriteria->length();
1682 theCriteria->length( i + 1 );
1684 theCriteria[ i ] = createCriterion();
1686 theCriteria[ i ].Type = aFType;
1687 theCriteria[ i ].TypeOfElement = thePred->GetElementType();
1690 case FT_BelongToGeom:
1692 BelongToGeom_i* aPred = dynamic_cast<BelongToGeom_i*>( thePred );
1694 CORBA::ULong i = theCriteria->length();
1695 theCriteria->length( i + 1 );
1697 theCriteria[ i ] = createCriterion();
1699 theCriteria[ i ].Type = FT_BelongToGeom;
1700 theCriteria[ i ].ThresholdStr = aPred->GetShapeName();
1701 theCriteria[ i ].ThresholdID = aPred->GetShapeID();
1702 theCriteria[ i ].TypeOfElement = aPred->GetElementType();
1706 case FT_BelongToPlane:
1707 case FT_BelongToCylinder:
1709 BelongToSurface_i* aPred = dynamic_cast<BelongToSurface_i*>( thePred );
1711 CORBA::ULong i = theCriteria->length();
1712 theCriteria->length( i + 1 );
1714 theCriteria[ i ] = createCriterion();
1716 theCriteria[ i ].Type = aFType;
1717 theCriteria[ i ].ThresholdStr = aPred->GetShapeName();
1718 theCriteria[ i ].ThresholdID = aPred->GetShapeID();
1719 theCriteria[ i ].TypeOfElement = aPred->GetElementType();
1720 theCriteria[ i ].Tolerance = aPred->GetTolerance();
1724 case FT_LyingOnGeom:
1726 LyingOnGeom_i* aPred = dynamic_cast<LyingOnGeom_i*>( thePred );
1728 CORBA::ULong i = theCriteria->length();
1729 theCriteria->length( i + 1 );
1731 theCriteria[ i ] = createCriterion();
1733 theCriteria[ i ].Type = FT_LyingOnGeom;
1734 theCriteria[ i ].ThresholdStr = aPred->GetShapeName();
1735 theCriteria[ i ].ThresholdID = aPred->GetShapeID();
1736 theCriteria[ i ].TypeOfElement = aPred->GetElementType();
1742 RangeOfIds_i* aPred = dynamic_cast<RangeOfIds_i*>( thePred );
1744 CORBA::ULong i = theCriteria->length();
1745 theCriteria->length( i + 1 );
1747 theCriteria[ i ] = createCriterion();
1749 theCriteria[ i ].Type = FT_RangeOfIds;
1750 theCriteria[ i ].ThresholdStr = aPred->GetRangeStr();
1751 theCriteria[ i ].TypeOfElement = aPred->GetElementType();
1755 case FT_BadOrientedVolume:
1757 BadOrientedVolume_i* aPred = dynamic_cast<BadOrientedVolume_i*>( thePred );
1759 CORBA::ULong i = theCriteria->length();
1760 theCriteria->length( i + 1 );
1762 theCriteria[ i ] = createCriterion();
1764 theCriteria[ i ].Type = FT_BadOrientedVolume;
1765 theCriteria[ i ].TypeOfElement = aPred->GetElementType();
1773 Comparator_i* aCompar = dynamic_cast<Comparator_i*>( thePred );
1775 CORBA::ULong i = theCriteria->length();
1776 theCriteria->length( i + 1 );
1778 theCriteria[ i ] = createCriterion();
1780 theCriteria[ i ].Type = aCompar->GetNumFunctor_i()->GetFunctorType();
1781 theCriteria[ i ].Compare = aFType;
1782 theCriteria[ i ].Threshold = aCompar->GetMargin();
1783 theCriteria[ i ].TypeOfElement = aCompar->GetElementType();
1785 if ( aFType == FT_EqualTo )
1787 EqualTo_i* aCompar = dynamic_cast<EqualTo_i*>( thePred );
1788 theCriteria[ i ].Tolerance = aCompar->GetTolerance();
1795 Predicate_i* aPred = ( dynamic_cast<LogicalNOT_i*>( thePred ) )->GetPredicate_i();
1796 getCriteria( aPred, theCriteria );
1797 theCriteria[ theCriteria->length() - 1 ].UnaryOp = FT_LogicalNOT;
1804 Predicate_i* aPred1 = ( dynamic_cast<LogicalBinary_i*>( thePred ) )->GetPredicate1_i();
1805 Predicate_i* aPred2 = ( dynamic_cast<LogicalBinary_i*>( thePred ) )->GetPredicate2_i();
1806 if ( !getCriteria( aPred1, theCriteria ) )
1808 theCriteria[ theCriteria->length() - 1 ].BinaryOp = aFType;
1809 return getCriteria( aPred2, theCriteria );
1819 //=======================================================================
1820 // name : Filter_i::GetCriteria
1821 // Purpose : Retrieve criterions from predicate
1822 //=======================================================================
1823 CORBA::Boolean Filter_i::GetCriteria( SMESH::Filter::Criteria_out theCriteria )
1825 theCriteria = new SMESH::Filter::Criteria;
1826 return myPredicate != 0 ? getCriteria( myPredicate, theCriteria ) : true;
1829 //=======================================================================
1830 // name : Filter_i::SetCriteria
1831 // Purpose : Create new predicate and set criterions in it
1832 //=======================================================================
1833 CORBA::Boolean Filter_i::SetCriteria( const SMESH::Filter::Criteria& theCriteria )
1835 if ( myPredicate != 0 )
1836 myPredicate->Destroy();
1838 SMESH::FilterManager_i* aFilter = new SMESH::FilterManager_i();
1839 FilterManager_ptr aFilterMgr = aFilter->_this();
1841 // CREATE two lists ( PREDICATES and LOG OP )
1844 std::list<SMESH::Predicate_ptr> aPredicates;
1845 std::list<int> aBinaries;
1846 for ( int i = 0, n = theCriteria.length(); i < n; i++ )
1848 int aCriterion = theCriteria[ i ].Type;
1849 int aCompare = theCriteria[ i ].Compare;
1850 double aThreshold = theCriteria[ i ].Threshold;
1851 int aUnary = theCriteria[ i ].UnaryOp;
1852 int aBinary = theCriteria[ i ].BinaryOp;
1853 double aTolerance = theCriteria[ i ].Tolerance;
1854 const char* aThresholdStr = theCriteria[ i ].ThresholdStr;
1855 const char* aThresholdID = theCriteria[ i ].ThresholdID;
1856 ElementType aTypeOfElem = theCriteria[ i ].TypeOfElement;
1857 long aPrecision = theCriteria[ i ].Precision;
1859 SMESH::Predicate_ptr aPredicate = SMESH::Predicate::_nil();
1860 SMESH::NumericalFunctor_ptr aFunctor = SMESH::NumericalFunctor::_nil();
1862 switch ( aCriterion )
1866 case SMESH::FT_MultiConnection:
1867 aFunctor = aFilterMgr->CreateMultiConnection();
1869 case SMESH::FT_MultiConnection2D:
1870 aFunctor = aFilterMgr->CreateMultiConnection2D();
1872 case SMESH::FT_Length:
1873 aFunctor = aFilterMgr->CreateLength();
1875 case SMESH::FT_Length2D:
1876 aFunctor = aFilterMgr->CreateLength2D();
1878 case SMESH::FT_AspectRatio:
1879 aFunctor = aFilterMgr->CreateAspectRatio();
1881 case SMESH::FT_AspectRatio3D:
1882 aFunctor = aFilterMgr->CreateAspectRatio3D();
1884 case SMESH::FT_Warping:
1885 aFunctor = aFilterMgr->CreateWarping();
1887 case SMESH::FT_MinimumAngle:
1888 aFunctor = aFilterMgr->CreateMinimumAngle();
1890 case SMESH::FT_Taper:
1891 aFunctor = aFilterMgr->CreateTaper();
1893 case SMESH::FT_Skew:
1894 aFunctor = aFilterMgr->CreateSkew();
1896 case SMESH::FT_Area:
1897 aFunctor = aFilterMgr->CreateArea();
1902 case SMESH::FT_FreeBorders:
1903 aPredicate = aFilterMgr->CreateFreeBorders();
1905 case SMESH::FT_FreeEdges:
1906 aPredicate = aFilterMgr->CreateFreeEdges();
1908 case SMESH::FT_BelongToGeom:
1910 SMESH::BelongToGeom_ptr tmpPred = aFilterMgr->CreateBelongToGeom();
1911 tmpPred->SetElementType( aTypeOfElem );
1912 tmpPred->SetShape( aThresholdID, aThresholdStr );
1913 aPredicate = tmpPred;
1916 case SMESH::FT_BelongToPlane:
1917 case SMESH::FT_BelongToCylinder:
1919 SMESH::BelongToSurface_ptr tmpPred;
1920 if ( aCriterion == SMESH::FT_BelongToPlane )
1921 tmpPred = aFilterMgr->CreateBelongToPlane();
1923 tmpPred = aFilterMgr->CreateBelongToCylinder();
1924 tmpPred->SetShape( aThresholdID, aThresholdStr, aTypeOfElem );
1925 tmpPred->SetTolerance( aTolerance );
1926 aPredicate = tmpPred;
1929 case SMESH::FT_LyingOnGeom:
1931 SMESH::LyingOnGeom_ptr tmpPred = aFilterMgr->CreateLyingOnGeom();
1932 tmpPred->SetElementType( aTypeOfElem );
1933 tmpPred->SetShape( aThresholdID, aThresholdStr );
1934 aPredicate = tmpPred;
1937 case SMESH::FT_RangeOfIds:
1939 SMESH::RangeOfIds_ptr tmpPred = aFilterMgr->CreateRangeOfIds();
1940 tmpPred->SetRangeStr( aThresholdStr );
1941 tmpPred->SetElementType( aTypeOfElem );
1942 aPredicate = tmpPred;
1945 case SMESH::FT_BadOrientedVolume:
1947 aPredicate = aFilterMgr->CreateBadOrientedVolume();
1956 if ( !aFunctor->_is_nil() && aPredicate->_is_nil() )
1958 SMESH::Comparator_ptr aComparator = SMESH::Comparator::_nil();
1960 if ( aCompare == SMESH::FT_LessThan )
1961 aComparator = aFilterMgr->CreateLessThan();
1962 else if ( aCompare == SMESH::FT_MoreThan )
1963 aComparator = aFilterMgr->CreateMoreThan();
1964 else if ( aCompare == SMESH::FT_EqualTo )
1965 aComparator = aFilterMgr->CreateEqualTo();
1969 aComparator->SetNumFunctor( aFunctor );
1970 aComparator->SetMargin( aThreshold );
1972 if ( aCompare == FT_EqualTo )
1974 SMESH::EqualTo_var anEqualTo = SMESH::EqualTo::_narrow( aComparator );
1975 anEqualTo->SetTolerance( aTolerance );
1978 aPredicate = aComparator;
1980 aFunctor->SetPrecision( aPrecision );
1984 if ( aUnary == FT_LogicalNOT )
1986 SMESH::LogicalNOT_ptr aNotPred = aFilterMgr->CreateLogicalNOT();
1987 aNotPred->SetPredicate( aPredicate );
1988 aPredicate = aNotPred;
1992 aPredicates.push_back( aPredicate );
1993 aBinaries.push_back( aBinary );
1997 // CREATE ONE PREDICATE FROM PREVIOUSLY CREATED MAP
1999 // combine all "AND" operations
2001 std::list<SMESH::Predicate_ptr> aResList;
2003 std::list<SMESH::Predicate_ptr>::iterator aPredIter;
2004 std::list<int>::iterator aBinaryIter;
2006 SMESH::Predicate_ptr aPrevPredicate = SMESH::Predicate::_nil();
2007 int aPrevBinary = SMESH::FT_Undefined;
2009 for ( aPredIter = aPredicates.begin(), aBinaryIter = aBinaries.begin();
2010 aPredIter != aPredicates.end() && aBinaryIter != aBinaries.end();
2011 ++aPredIter, ++aBinaryIter )
2013 int aCurrBinary = *aBinaryIter;
2015 SMESH::Predicate_ptr aCurrPred = SMESH::Predicate::_nil();
2017 if ( aPrevBinary == SMESH::FT_LogicalAND )
2020 SMESH::LogicalBinary_ptr aBinaryPred = aFilterMgr->CreateLogicalAND();
2021 aBinaryPred->SetPredicate1( aPrevPredicate );
2022 aBinaryPred->SetPredicate2( *aPredIter );
2023 aCurrPred = aBinaryPred;
2026 aCurrPred = *aPredIter;
2028 if ( aCurrBinary != SMESH::FT_LogicalAND )
2029 aResList.push_back( aCurrPred );
2031 aPrevPredicate = aCurrPred;
2032 aPrevBinary = aCurrBinary;
2035 // combine all "OR" operations
2037 SMESH::Predicate_ptr aResPredicate = SMESH::Predicate::_nil();
2039 if ( aResList.size() == 1 )
2040 aResPredicate = *aResList.begin();
2041 else if ( aResList.size() > 1 )
2043 std::list<SMESH::Predicate_ptr>::iterator anIter = aResList.begin();
2044 aResPredicate = *anIter;
2046 for ( ; anIter != aResList.end(); ++anIter )
2048 SMESH::LogicalBinary_ptr aBinaryPred = aFilterMgr->CreateLogicalOR();
2049 aBinaryPred->SetPredicate1( aResPredicate );
2050 aBinaryPred->SetPredicate2( *anIter );
2051 aResPredicate = aBinaryPred;
2055 SetPredicate( aResPredicate );
2057 return !aResPredicate->_is_nil();
2060 //=======================================================================
2061 // name : Filter_i::GetPredicate_i
2062 // Purpose : Get implementation of predicate
2063 //=======================================================================
2064 Predicate_i* Filter_i::GetPredicate_i()
2069 //=======================================================================
2070 // name : Filter_i::GetPredicate
2071 // Purpose : Get predicate
2072 //=======================================================================
2073 Predicate_ptr Filter_i::GetPredicate()
2075 if ( myPredicate == 0 )
2076 return SMESH::Predicate::_nil();
2079 SMESH::Predicate_var anObj = myPredicate->_this();
2080 return anObj._retn();
2088 #define ATTR_TYPE "type"
2089 #define ATTR_COMPARE "compare"
2090 #define ATTR_THRESHOLD "threshold"
2091 #define ATTR_UNARY "unary"
2092 #define ATTR_BINARY "binary"
2093 #define ATTR_THRESHOLD_STR "threshold_str"
2094 #define ATTR_TOLERANCE "tolerance"
2095 #define ATTR_ELEMENT_TYPE "ElementType"
2097 //=======================================================================
2099 // Purpose : Convert bool to LDOMString
2100 //=======================================================================
2101 static inline LDOMString toString( const bool val )
2103 return val ? "logical not" : "";
2106 //=======================================================================
2108 // Purpose : Convert LDOMString to bool
2109 //=======================================================================
2110 static inline bool toBool( const LDOMString& theStr )
2112 return theStr.equals( "logical not" );
2115 //=======================================================================
2117 // Purpose : Convert double to LDOMString
2118 //=======================================================================
2119 static inline LDOMString toString( const double val )
2122 sprintf( a, "%e", val );
2123 return LDOMString( a );
2126 //=======================================================================
2128 // Purpose : Convert LDOMString to double
2129 //=======================================================================
2130 static inline double toDouble( const LDOMString& theStr )
2132 return atof( theStr.GetString() );
2135 //=======================================================================
2137 // Purpose : Convert functor type to LDOMString
2138 //=======================================================================
2139 static inline LDOMString toString( const long theType )
2143 case FT_AspectRatio : return "Aspect ratio";
2144 case FT_Warping : return "Warping";
2145 case FT_MinimumAngle : return "Minimum angle";
2146 case FT_Taper : return "Taper";
2147 case FT_Skew : return "Skew";
2148 case FT_Area : return "Area";
2149 case FT_BelongToGeom : return "Belong to Geom";
2150 case FT_BelongToPlane : return "Belong to Plane";
2151 case FT_BelongToCylinder: return "Belong to Cylinder";
2152 case FT_LyingOnGeom : return "Lying on Geom";
2153 case FT_BadOrientedVolume: return "Bad Oriented Volume";
2154 case FT_RangeOfIds : return "Range of IDs";
2155 case FT_FreeBorders : return "Free borders";
2156 case FT_FreeEdges : return "Free edges";
2157 case FT_MultiConnection : return "Borders at multi-connections";
2158 case FT_MultiConnection2D: return "Borders at multi-connections 2D";
2159 case FT_Length : return "Length";
2160 case FT_Length2D : return "Length2D";
2161 case FT_LessThan : return "Less than";
2162 case FT_MoreThan : return "More than";
2163 case FT_EqualTo : return "Equal to";
2164 case FT_LogicalNOT : return "Not";
2165 case FT_LogicalAND : return "And";
2166 case FT_LogicalOR : return "Or";
2167 case FT_Undefined : return "";
2168 default : return "";
2172 //=======================================================================
2173 // name : toFunctorType
2174 // Purpose : Convert LDOMString to functor type
2175 //=======================================================================
2176 static inline SMESH::FunctorType toFunctorType( const LDOMString& theStr )
2178 if ( theStr.equals( "Aspect ratio" ) ) return FT_AspectRatio;
2179 else if ( theStr.equals( "Warping" ) ) return FT_Warping;
2180 else if ( theStr.equals( "Minimum angle" ) ) return FT_MinimumAngle;
2181 else if ( theStr.equals( "Taper" ) ) return FT_Taper;
2182 else if ( theStr.equals( "Skew" ) ) return FT_Skew;
2183 else if ( theStr.equals( "Area" ) ) return FT_Area;
2184 else if ( theStr.equals( "Belong to Geom" ) ) return FT_BelongToGeom;
2185 else if ( theStr.equals( "Belong to Plane" ) ) return FT_BelongToPlane;
2186 else if ( theStr.equals( "Belong to Cylinder" ) ) return FT_BelongToCylinder;
2187 else if ( theStr.equals( "Lying on Geom" ) ) return FT_LyingOnGeom;
2188 else if ( theStr.equals( "Free borders" ) ) return FT_FreeBorders;
2189 else if ( theStr.equals( "Free edges" ) ) return FT_FreeEdges;
2190 else if ( theStr.equals( "Borders at multi-connections" ) ) return FT_MultiConnection;
2191 // else if ( theStr.equals( "Borders at multi-connections 2D" ) ) return FT_MultiConnection2D;
2192 else if ( theStr.equals( "Length" ) ) return FT_Length;
2193 // else if ( theStr.equals( "Length2D" ) ) return FT_Length2D;
2194 else if ( theStr.equals( "Range of IDs" ) ) return FT_RangeOfIds;
2195 else if ( theStr.equals( "Bad Oriented Volume" ) ) return FT_BadOrientedVolume;
2196 else if ( theStr.equals( "Less than" ) ) return FT_LessThan;
2197 else if ( theStr.equals( "More than" ) ) return FT_MoreThan;
2198 else if ( theStr.equals( "Equal to" ) ) return FT_EqualTo;
2199 else if ( theStr.equals( "Not" ) ) return FT_LogicalNOT;
2200 else if ( theStr.equals( "And" ) ) return FT_LogicalAND;
2201 else if ( theStr.equals( "Or" ) ) return FT_LogicalOR;
2202 else if ( theStr.equals( "" ) ) return FT_Undefined;
2203 else return FT_Undefined;
2206 //=======================================================================
2207 // name : toFunctorType
2208 // Purpose : Convert LDOMString to value of ElementType enumeration
2209 //=======================================================================
2210 static inline SMESH::ElementType toElementType( const LDOMString& theStr )
2212 if ( theStr.equals( "NODE" ) ) return SMESH::NODE;
2213 else if ( theStr.equals( "EDGE" ) ) return SMESH::EDGE;
2214 else if ( theStr.equals( "FACE" ) ) return SMESH::FACE;
2215 else if ( theStr.equals( "VOLUME" ) ) return SMESH::VOLUME;
2216 else return SMESH::ALL;
2219 //=======================================================================
2221 // Purpose : Convert ElementType to string
2222 //=======================================================================
2223 static inline LDOMString toString( const SMESH::ElementType theType )
2227 case SMESH::NODE : return "NODE";
2228 case SMESH::EDGE : return "EDGE";
2229 case SMESH::FACE : return "FACE";
2230 case SMESH::VOLUME : return "VOLUME";
2231 case SMESH::ALL : return "ALL";
2232 default : return "";
2236 //=======================================================================
2237 // name : findFilter
2238 // Purpose : Find filter in document
2239 //=======================================================================
2240 static LDOM_Element findFilter( const char* theFilterName,
2241 const LDOM_Document& theDoc,
2242 LDOM_Node* theParent = 0 )
2244 LDOM_Element aRootElement = theDoc.getDocumentElement();
2245 if ( aRootElement.isNull() || !aRootElement.hasChildNodes() )
2246 return LDOM_Element();
2248 for ( LDOM_Node aTypeNode = aRootElement.getFirstChild();
2249 !aTypeNode.isNull(); aTypeNode = aTypeNode.getNextSibling() )
2251 for ( LDOM_Node aFilter = aTypeNode.getFirstChild();
2252 !aFilter.isNull(); aFilter = aFilter.getNextSibling() )
2254 LDOM_Element* anElem = ( LDOM_Element* )&aFilter;
2255 if ( anElem->getTagName().equals( LDOMString( "filter" ) ) &&
2256 anElem->getAttribute( "name" ).equals( LDOMString( theFilterName ) ) )
2258 if ( theParent != 0 )
2259 *theParent = aTypeNode;
2260 return (LDOM_Element&)aFilter;
2264 return LDOM_Element();
2267 //=======================================================================
2268 // name : getSectionName
2269 // Purpose : Get name of section of filters
2270 //=======================================================================
2271 static const char* getSectionName( const ElementType theType )
2275 case SMESH::NODE : return "Filters for nodes";
2276 case SMESH::EDGE : return "Filters for edges";
2277 case SMESH::FACE : return "Filters for faces";
2278 case SMESH::VOLUME : return "Filters for volumes";
2279 case SMESH::ALL : return "Filters for elements";
2280 default : return "";
2284 //=======================================================================
2285 // name : getSection
2286 // Purpose : Create section for filters corresponding to the entity type
2287 //=======================================================================
2288 static LDOM_Node getSection( const ElementType theType,
2289 LDOM_Document& theDoc,
2290 const bool toCreate = false )
2292 LDOM_Element aRootElement = theDoc.getDocumentElement();
2293 if ( aRootElement.isNull() )
2297 bool anExist = false;
2298 const char* aSectionName = getSectionName( theType );
2299 if ( strcmp( aSectionName, "" ) == 0 )
2302 LDOM_NodeList aSections = theDoc.getElementsByTagName( "section" );
2304 for ( int i = 0, n = aSections.getLength(); i < n; i++ )
2306 aNode = aSections.item( i );
2307 LDOM_Element& anItem = ( LDOM_Element& )aNode;
2308 if ( anItem.getAttribute( "name" ).equals( LDOMString( aSectionName ) ) )
2315 // Create new section if necessary
2320 LDOM_Element aNewItem = theDoc.createElement( "section" );
2321 aNewItem.setAttribute( "name", aSectionName );
2322 aRootElement.appendChild( aNewItem );
2332 //=======================================================================
2333 // name : createFilterItem
2334 // Purpose : Create filter item or LDOM document
2335 //=======================================================================
2336 static LDOM_Element createFilterItem( const char* theName,
2337 SMESH::Filter_ptr theFilter,
2338 LDOM_Document& theDoc )
2340 // create new filter in document
2341 LDOM_Element aFilterItem = theDoc.createElement( "filter" );
2342 aFilterItem.setAttribute( "name", theName );
2344 // save filter criterions
2345 SMESH::Filter::Criteria_var aCriteria = new SMESH::Filter::Criteria;
2347 if ( !theFilter->GetCriteria( aCriteria ) )
2348 return LDOM_Element();
2350 for ( CORBA::ULong i = 0, n = aCriteria->length(); i < n; i++ )
2352 LDOM_Element aCriterionItem = theDoc.createElement( "criterion" );
2354 aCriterionItem.setAttribute( ATTR_TYPE , toString( aCriteria[ i ].Type ) );
2355 aCriterionItem.setAttribute( ATTR_COMPARE , toString( aCriteria[ i ].Compare ) );
2356 aCriterionItem.setAttribute( ATTR_UNARY , toString( aCriteria[ i ].UnaryOp ) );
2357 aCriterionItem.setAttribute( ATTR_BINARY , toString( aCriteria[ i ].BinaryOp ) );
2359 aCriterionItem.setAttribute( ATTR_THRESHOLD_STR, (const char*)aCriteria[ i ].ThresholdStr );
2360 aCriterionItem.setAttribute( ATTR_TOLERANCE , toString( aCriteria[ i ].Tolerance ) );
2361 aCriterionItem.setAttribute( ATTR_ELEMENT_TYPE ,
2362 toString( (SMESH::ElementType)aCriteria[ i ].TypeOfElement ) );
2364 aFilterItem.appendChild( aCriterionItem );
2370 //=======================================================================
2371 // name : FilterLibrary_i::FilterLibrary_i
2372 // Purpose : Constructor
2373 //=======================================================================
2374 FilterLibrary_i::FilterLibrary_i( const char* theFileName )
2376 myFileName = strdup( theFileName );
2377 SMESH::FilterManager_i* aFilterMgr = new SMESH::FilterManager_i();
2378 myFilterMgr = aFilterMgr->_this();
2382 // Try to use existing library file
2383 bool anExists = false;
2384 if ( !aParser.parse( myFileName ) )
2386 myDoc = aParser.getDocument();
2389 // Create a new XML document if it doesn't exist
2391 myDoc = LDOM_Document::createDocument( LDOMString() );
2393 LDOM_Element aRootElement = myDoc.getDocumentElement();
2394 if ( aRootElement.isNull() )
2396 // If the existing document is empty --> try to create a new one
2398 myDoc = LDOM_Document::createDocument( LDOMString() );
2402 //=======================================================================
2403 // name : FilterLibrary_i::FilterLibrary_i
2404 // Purpose : Constructor
2405 //=======================================================================
2406 FilterLibrary_i::FilterLibrary_i()
2409 SMESH::FilterManager_i* aFilter = new SMESH::FilterManager_i();
2410 myFilterMgr = aFilter->_this();
2412 myDoc = LDOM_Document::createDocument( LDOMString() );
2415 FilterLibrary_i::~FilterLibrary_i()
2420 //=======================================================================
2421 // name : FilterLibrary_i::Copy
2422 // Purpose : Create filter and initialize it with values from library
2423 //=======================================================================
2424 Filter_ptr FilterLibrary_i::Copy( const char* theFilterName )
2427 LDOM_Node aFilter = findFilter( theFilterName, myDoc );
2429 if ( aFilter.isNull() )
2432 std::list<SMESH::Filter::Criterion> aCriteria;
2434 for ( LDOM_Node aCritNode = aFilter.getFirstChild();
2435 !aCritNode.isNull() ; aCritNode = aCritNode.getNextSibling() )
2437 LDOM_Element* aCrit = (LDOM_Element*)&aCritNode;
2439 const char* aTypeStr = aCrit->getAttribute( ATTR_TYPE ).GetString();
2440 const char* aCompareStr = aCrit->getAttribute( ATTR_COMPARE ).GetString();
2441 const char* aUnaryStr = aCrit->getAttribute( ATTR_UNARY ).GetString();
2442 const char* aBinaryStr = aCrit->getAttribute( ATTR_BINARY ).GetString();
2443 const char* anElemTypeStr = aCrit->getAttribute( ATTR_ELEMENT_TYPE ).GetString();
2445 SMESH::Filter::Criterion aCriterion = createCriterion();
2447 aCriterion.Type = toFunctorType( aTypeStr );
2448 aCriterion.Compare = toFunctorType( aCompareStr );
2449 aCriterion.UnaryOp = toFunctorType( aUnaryStr );
2450 aCriterion.BinaryOp = toFunctorType( aBinaryStr );
2452 aCriterion.TypeOfElement = toElementType( anElemTypeStr );
2454 LDOMString str = aCrit->getAttribute( ATTR_THRESHOLD );
2456 aCriterion.Threshold = str.Type() == LDOMBasicString::LDOM_Integer && str.GetInteger( val )
2457 ? val : atof( str.GetString() );
2459 str = aCrit->getAttribute( ATTR_TOLERANCE );
2460 aCriterion.Tolerance = str.Type() == LDOMBasicString::LDOM_Integer && str.GetInteger( val )
2461 ? val : atof( str.GetString() );
2463 str = aCrit->getAttribute( ATTR_THRESHOLD_STR );
2464 if ( str.Type() == LDOMBasicString::LDOM_Integer && str.GetInteger( val ) )
2467 sprintf( a, "%d", val );
2468 aCriterion.ThresholdStr = strdup( a );
2471 aCriterion.ThresholdStr = str.GetString();
2473 aCriteria.push_back( aCriterion );
2476 SMESH::Filter::Criteria_var aCriteriaVar = new SMESH::Filter::Criteria;
2477 aCriteriaVar->length( aCriteria.size() );
2480 std::list<SMESH::Filter::Criterion>::iterator anIter = aCriteria.begin();
2482 for( ; anIter != aCriteria.end(); ++anIter )
2483 aCriteriaVar[ i++ ] = *anIter;
2485 aRes = myFilterMgr->CreateFilter();
2486 aRes->SetCriteria( aCriteriaVar.inout() );
2491 //=======================================================================
2492 // name : FilterLibrary_i::SetFileName
2493 // Purpose : Set file name for library
2494 //=======================================================================
2495 void FilterLibrary_i::SetFileName( const char* theFileName )
2498 myFileName = strdup( theFileName );
2501 //=======================================================================
2502 // name : FilterLibrary_i::GetFileName
2503 // Purpose : Get file name of library
2504 //=======================================================================
2505 char* FilterLibrary_i::GetFileName()
2507 return CORBA::string_dup( myFileName );
2510 //=======================================================================
2511 // name : FilterLibrary_i::Add
2512 // Purpose : Add new filter to library
2513 //=======================================================================
2514 CORBA::Boolean FilterLibrary_i::Add( const char* theFilterName, Filter_ptr theFilter )
2516 // if filter already in library or entry filter is null do nothing
2517 LDOM_Node aFilterNode = findFilter( theFilterName, myDoc );
2518 if ( !aFilterNode.isNull() || theFilter->_is_nil() )
2521 // get section corresponding to the filter type
2522 ElementType anEntType = theFilter->GetElementType();
2524 LDOM_Node aSection = getSection( anEntType, myDoc, true );
2525 if ( aSection.isNull() )
2528 // create filter item
2529 LDOM_Element aFilterItem = createFilterItem( theFilterName, theFilter, myDoc );
2530 if ( aFilterItem.isNull() )
2534 aSection.appendChild( aFilterItem );
2539 //=======================================================================
2540 // name : FilterLibrary_i::Add
2541 // Purpose : Add new filter to library
2542 //=======================================================================
2543 CORBA::Boolean FilterLibrary_i::AddEmpty( const char* theFilterName, ElementType theType )
2545 // if filter already in library or entry filter is null do nothing
2546 LDOM_Node aFilterNode = findFilter( theFilterName, myDoc );
2547 if ( !aFilterNode.isNull() )
2550 LDOM_Node aSection = getSection( theType, myDoc, true );
2551 if ( aSection.isNull() )
2554 // create filter item
2555 Filter_var aFilter = myFilterMgr->CreateFilter();
2557 LDOM_Element aFilterItem = createFilterItem( theFilterName, aFilter, myDoc );
2558 if ( aFilterItem.isNull() )
2562 aSection.appendChild( aFilterItem );
2567 //=======================================================================
2568 // name : FilterLibrary_i::Delete
2569 // Purpose : Delete filter from library
2570 //=======================================================================
2571 CORBA::Boolean FilterLibrary_i::Delete ( const char* theFilterName )
2573 LDOM_Node aParentNode;
2574 LDOM_Node aFilterNode = findFilter( theFilterName, myDoc, &aParentNode );
2575 if ( aFilterNode.isNull() || aParentNode.isNull() )
2578 aParentNode.removeChild( aFilterNode );
2582 //=======================================================================
2583 // name : FilterLibrary_i::Replace
2584 // Purpose : Replace existing filter with entry filter.
2585 // IMPORTANT : If filter does not exist it is not created
2586 //=======================================================================
2587 CORBA::Boolean FilterLibrary_i::Replace( const char* theFilterName,
2588 const char* theNewName,
2589 Filter_ptr theFilter )
2591 LDOM_Element aFilterItem = findFilter( theFilterName, myDoc );
2592 if ( aFilterItem.isNull() || theFilter->_is_nil() )
2595 LDOM_Element aNewItem = createFilterItem( theNewName, theFilter, myDoc );
2596 if ( aNewItem.isNull() )
2600 aFilterItem.ReplaceElement( aNewItem );
2605 //=======================================================================
2606 // name : FilterLibrary_i::Save
2607 // Purpose : Save library on disk
2608 //=======================================================================
2609 CORBA::Boolean FilterLibrary_i::Save()
2611 if ( myFileName == 0 || strlen( myFileName ) == 0 )
2614 FILE* aOutFile = fopen( myFileName, "wt" );
2618 LDOM_XmlWriter aWriter( aOutFile );
2619 aWriter.SetIndentation( 2 );
2626 //=======================================================================
2627 // name : FilterLibrary_i::SaveAs
2628 // Purpose : Save library on disk
2629 //=======================================================================
2630 CORBA::Boolean FilterLibrary_i::SaveAs( const char* aFileName )
2632 myFileName = strdup ( aFileName );
2636 //=======================================================================
2637 // name : FilterLibrary_i::IsPresent
2638 // Purpose : Verify whether filter is in library
2639 //=======================================================================
2640 CORBA::Boolean FilterLibrary_i::IsPresent( const char* theFilterName )
2642 return !findFilter( theFilterName, myDoc ).isNull();
2645 //=======================================================================
2646 // name : FilterLibrary_i::NbFilters
2647 // Purpose : Return amount of filters in library
2648 //=======================================================================
2649 CORBA::Long FilterLibrary_i::NbFilters( ElementType theType )
2651 string_array_var aNames = GetNames( theType );
2652 return aNames->length();
2655 //=======================================================================
2656 // name : FilterLibrary_i::GetNames
2657 // Purpose : Get names of filters from library
2658 //=======================================================================
2659 string_array* FilterLibrary_i::GetNames( ElementType theType )
2661 string_array_var anArray = new string_array;
2662 TColStd_SequenceOfHAsciiString aSeq;
2664 LDOM_Node aSection = getSection( theType, myDoc, false );
2666 if ( !aSection.isNull() )
2668 for ( LDOM_Node aFilter = aSection.getFirstChild();
2669 !aFilter.isNull(); aFilter = aFilter.getNextSibling() )
2671 LDOM_Element& anElem = ( LDOM_Element& )aFilter;
2672 aSeq.Append( new TCollection_HAsciiString(
2673 (Standard_CString)anElem.getAttribute( "name" ).GetString() ) );
2677 anArray->length( aSeq.Length() );
2678 for ( int i = 1, n = aSeq.Length(); i <= n; i++ )
2679 anArray[ i - 1 ] = CORBA::string_dup( aSeq( i )->ToCString() );
2681 return anArray._retn();
2684 //=======================================================================
2685 // name : FilterLibrary_i::GetAllNames
2686 // Purpose : Get names of filters from library
2687 //=======================================================================
2688 string_array* FilterLibrary_i::GetAllNames()
2690 string_array_var aResArray = new string_array;
2691 for ( int type = SMESH::ALL; type <= SMESH::VOLUME; type++ )
2693 SMESH::string_array_var aNames = GetNames( (SMESH::ElementType)type );
2695 int aPrevLength = aResArray->length();
2696 aResArray->length( aPrevLength + aNames->length() );
2697 for ( int i = 0, n = aNames->length(); i < n; i++ )
2698 aResArray[ aPrevLength + i ] = aNames[ i ];
2701 return aResArray._retn();