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.salome-platform.org/ or email : webmaster.salome@opencascade.com
24 // File : SMESH_Filter_i.cxx
25 // Author : Alexey Petrov, OCC
29 #include "SMESH_Filter_i.hxx"
31 #include "SMESH_Gen_i.hxx"
32 #include "SMESH_PythonDump.hxx"
34 #include "SMDS_Mesh.hxx"
35 #include "SMDS_MeshNode.hxx"
36 #include "SMDS_MeshElement.hxx"
38 #include "SMESHDS_Mesh.hxx"
40 #include <LDOM_Document.hxx>
41 #include <LDOM_Element.hxx>
42 #include <LDOM_Node.hxx>
43 #include <LDOMString.hxx>
44 #include <LDOMParser.hxx>
45 #include <LDOM_XmlWriter.hxx>
46 #include <TCollection_HAsciiString.hxx>
47 #include <TColStd_ListIteratorOfListOfInteger.hxx>
48 #include <TColStd_ListOfInteger.hxx>
49 #include <TColStd_ListOfReal.hxx>
50 #include <TColStd_MapOfInteger.hxx>
51 #include <TColStd_SequenceOfHAsciiString.hxx>
52 #include <TColStd_ListIteratorOfListOfReal.hxx>
53 #include <Precision.hxx>
54 #include <BRep_Tool.hxx>
55 #include <TopoDS_Shape.hxx>
57 #include <TopoDS_Face.hxx>
58 #include <Geom_Plane.hxx>
59 #include <Geom_CylindricalSurface.hxx>
60 #include <TopExp_Explorer.hxx>
61 #include <OSD_Path.hxx>
62 #include <OSD_File.hxx>
64 using namespace SMESH;
65 using namespace SMESH::Controls;
71 GetPredicate( Predicate_ptr thePredicate )
73 return DownCast<Predicate_i*>(thePredicate);
80 Description : Predicate for verifying whether entiy belong to
81 specified geometrical support
84 Controls::BelongToGeom::BelongToGeom()
89 void Controls::BelongToGeom::SetMesh( const SMDS_Mesh* theMesh )
91 myMeshDS = dynamic_cast<const SMESHDS_Mesh*>(theMesh);
94 void Controls::BelongToGeom::SetGeom( const TopoDS_Shape& theShape )
99 static bool IsContains( const SMESHDS_Mesh* theMeshDS,
100 const TopoDS_Shape& theShape,
101 const SMDS_MeshElement* theElem,
102 TopAbs_ShapeEnum theFindShapeEnum,
103 TopAbs_ShapeEnum theAvoidShapeEnum = TopAbs_SHAPE )
105 TopExp_Explorer anExp( theShape,theFindShapeEnum,theAvoidShapeEnum );
107 while( anExp.More() )
109 const TopoDS_Shape& aShape = anExp.Current();
110 if( SMESHDS_SubMesh* aSubMesh = theMeshDS->MeshElements( aShape ) ){
111 if( aSubMesh->Contains( theElem ) )
119 bool Controls::BelongToGeom::IsSatisfy( long theId )
121 if ( myMeshDS == 0 || myShape.IsNull() )
124 if( myType == SMDSAbs_Node )
126 if( const SMDS_MeshNode* aNode = myMeshDS->FindNode( theId ) )
128 const SMDS_PositionPtr& aPosition = aNode->GetPosition();
129 SMDS_TypeOfPosition aTypeOfPosition = aPosition->GetTypeOfPosition();
130 switch( aTypeOfPosition )
132 case SMDS_TOP_VERTEX : return IsContains( myMeshDS,myShape,aNode,TopAbs_VERTEX );
133 case SMDS_TOP_EDGE : return IsContains( myMeshDS,myShape,aNode,TopAbs_EDGE );
134 case SMDS_TOP_FACE : return IsContains( myMeshDS,myShape,aNode,TopAbs_FACE );
135 case SMDS_TOP_3DSPACE: return IsContains( myMeshDS,myShape,aNode,TopAbs_SHELL );
141 if( const SMDS_MeshElement* anElem = myMeshDS->FindElement( theId ) )
143 if( myType == SMDSAbs_All )
145 return IsContains( myMeshDS,myShape,anElem,TopAbs_EDGE ) ||
146 IsContains( myMeshDS,myShape,anElem,TopAbs_FACE ) ||
147 IsContains( myMeshDS,myShape,anElem,TopAbs_SHELL )||
148 IsContains( myMeshDS,myShape,anElem,TopAbs_SOLID );
150 else if( myType == anElem->GetType() )
154 case SMDSAbs_Edge : return IsContains( myMeshDS,myShape,anElem,TopAbs_EDGE );
155 case SMDSAbs_Face : return IsContains( myMeshDS,myShape,anElem,TopAbs_FACE );
156 case SMDSAbs_Volume: return IsContains( myMeshDS,myShape,anElem,TopAbs_SHELL )||
157 IsContains( myMeshDS,myShape,anElem,TopAbs_SOLID );
166 void Controls::BelongToGeom::SetType( SMDSAbs_ElementType theType )
171 SMDSAbs_ElementType Controls::BelongToGeom::GetType() const
176 TopoDS_Shape Controls::BelongToGeom::GetShape()
182 Controls::BelongToGeom::
190 Description : Predicate for verifying whether entiy lying or partially lying on
191 specified geometrical support
194 Controls::LyingOnGeom::LyingOnGeom()
199 void Controls::LyingOnGeom::SetMesh( const SMDS_Mesh* theMesh )
201 myMeshDS = dynamic_cast<const SMESHDS_Mesh*>(theMesh);
204 void Controls::LyingOnGeom::SetGeom( const TopoDS_Shape& theShape )
209 bool Controls::LyingOnGeom::IsSatisfy( long theId )
211 if ( myMeshDS == 0 || myShape.IsNull() )
214 if( myType == SMDSAbs_Node )
216 if( const SMDS_MeshNode* aNode = myMeshDS->FindNode( theId ) )
218 const SMDS_PositionPtr& aPosition = aNode->GetPosition();
219 SMDS_TypeOfPosition aTypeOfPosition = aPosition->GetTypeOfPosition();
220 switch( aTypeOfPosition )
222 case SMDS_TOP_VERTEX : return IsContains( myMeshDS,myShape,aNode,TopAbs_VERTEX );
223 case SMDS_TOP_EDGE : return IsContains( myMeshDS,myShape,aNode,TopAbs_EDGE );
224 case SMDS_TOP_FACE : return IsContains( myMeshDS,myShape,aNode,TopAbs_FACE );
225 case SMDS_TOP_3DSPACE: return IsContains( myMeshDS,myShape,aNode,TopAbs_SHELL );
231 if( const SMDS_MeshElement* anElem = myMeshDS->FindElement( theId ) )
233 if( myType == SMDSAbs_All )
235 return Contains( myMeshDS,myShape,anElem,TopAbs_EDGE ) ||
236 Contains( myMeshDS,myShape,anElem,TopAbs_FACE ) ||
237 Contains( myMeshDS,myShape,anElem,TopAbs_SHELL )||
238 Contains( myMeshDS,myShape,anElem,TopAbs_SOLID );
240 else if( myType == anElem->GetType() )
244 case SMDSAbs_Edge : return Contains( myMeshDS,myShape,anElem,TopAbs_EDGE );
245 case SMDSAbs_Face : return Contains( myMeshDS,myShape,anElem,TopAbs_FACE );
246 case SMDSAbs_Volume: return Contains( myMeshDS,myShape,anElem,TopAbs_SHELL )||
247 Contains( myMeshDS,myShape,anElem,TopAbs_SOLID );
256 void Controls::LyingOnGeom::SetType( SMDSAbs_ElementType theType )
261 SMDSAbs_ElementType Controls::LyingOnGeom::GetType() const
266 TopoDS_Shape Controls::LyingOnGeom::GetShape()
272 Controls::LyingOnGeom::
278 bool Controls::LyingOnGeom::Contains( const SMESHDS_Mesh* theMeshDS,
279 const TopoDS_Shape& theShape,
280 const SMDS_MeshElement* theElem,
281 TopAbs_ShapeEnum theFindShapeEnum,
282 TopAbs_ShapeEnum theAvoidShapeEnum )
284 if (IsContains(theMeshDS, theShape, theElem, theFindShapeEnum, theAvoidShapeEnum))
287 TopTools_IndexedMapOfShape aSubShapes;
288 TopExp::MapShapes( theShape, aSubShapes );
290 for (int i = 1; i <= aSubShapes.Extent(); i++)
292 const TopoDS_Shape& aShape = aSubShapes.FindKey(i);
294 if( SMESHDS_SubMesh* aSubMesh = theMeshDS->MeshElements( aShape ) ){
295 if( aSubMesh->Contains( theElem ) )
298 SMDS_NodeIteratorPtr aNodeIt = aSubMesh->GetNodes();
299 while ( aNodeIt->more() )
301 const SMDS_MeshNode* aNode = static_cast<const SMDS_MeshNode*>(aNodeIt->next());
302 SMDS_ElemIteratorPtr anElemIt = aNode->GetInverseElementIterator();
303 while ( anElemIt->more() )
305 const SMDS_MeshElement* anElement = static_cast<const SMDS_MeshElement*>(anElemIt->next());
306 if (anElement == theElem)
322 MeshPtr2SMDSMesh( SMESH_Mesh_ptr theMesh )
324 SMESH_Mesh_i* anImplPtr = DownCast<SMESH_Mesh_i*>(theMesh);
325 return anImplPtr ? anImplPtr->GetImpl().GetMeshDS() : 0;
330 toArray( const TColStd_ListOfInteger& aList )
332 SMESH::long_array_var anArray = new SMESH::long_array;
333 anArray->length( aList.Extent() );
334 TColStd_ListIteratorOfListOfInteger anIter( aList );
336 for( ; anIter.More(); anIter.Next() )
337 anArray[ i++ ] = anIter.Value();
339 return anArray._retn();
344 toArray( const TColStd_ListOfReal& aList )
346 SMESH::double_array_var anArray = new SMESH::double_array;
347 anArray->length( aList.Extent() );
348 TColStd_ListIteratorOfListOfReal anIter( aList );
350 for( ; anIter.More(); anIter.Next() )
351 anArray[ i++ ] = anIter.Value();
353 return anArray._retn();
356 static SMESH::Filter::Criterion createCriterion()
358 SMESH::Filter::Criterion aCriterion;
360 aCriterion.Type = FT_Undefined;
361 aCriterion.Compare = FT_Undefined;
362 aCriterion.Threshold = 0;
363 aCriterion.UnaryOp = FT_Undefined;
364 aCriterion.BinaryOp = FT_Undefined;
365 aCriterion.ThresholdStr = "";
366 aCriterion.ThresholdID = "";
367 aCriterion.Tolerance = Precision::Confusion();
368 aCriterion.TypeOfElement = SMESH::ALL;
369 aCriterion.Precision = -1;
374 static TopoDS_Shape getShapeByName( const char* theName )
378 SMESH_Gen_i* aSMESHGen = SMESH_Gen_i::GetSMESHGen();
379 SALOMEDS::Study_ptr aStudy = aSMESHGen->GetCurrentStudy();
380 if (!CORBA::is_nil(aStudy))
382 SALOMEDS::Study::ListOfSObject_var aList =
383 aStudy->FindObjectByName( theName, "GEOM" );
384 if ( aList->length() > 0 )
386 GEOM::GEOM_Object_var aGeomObj = GEOM::GEOM_Object::_narrow( aList[ 0 ]->GetObject() );
387 if ( !aGeomObj->_is_nil() )
389 GEOM::GEOM_Gen_ptr aGEOMGen = SMESH_Gen_i::GetGeomEngine();
390 TopoDS_Shape aLocShape = aSMESHGen->GetShapeReader()->GetShape( aGEOMGen, aGeomObj );
396 return TopoDS_Shape();
399 static TopoDS_Shape getShapeByID (const char* theID)
401 if (theID != 0 && theID != "") {
402 SMESH_Gen_i* aSMESHGen = SMESH_Gen_i::GetSMESHGen();
403 SALOMEDS::Study_ptr aStudy = aSMESHGen->GetCurrentStudy();
405 SALOMEDS::SObject_var aSObj = aStudy->FindObjectID(theID);
406 SALOMEDS::GenericAttribute_var anAttr;
407 if (!aSObj->_is_nil() && aSObj->FindAttribute(anAttr, "AttributeIOR")) {
408 SALOMEDS::AttributeIOR_var anIOR = SALOMEDS::AttributeIOR::_narrow(anAttr);
409 CORBA::String_var aVal = anIOR->Value();
410 CORBA::Object_var obj = aStudy->ConvertIORToObject(aVal);
411 GEOM::GEOM_Object_var aGeomObj = GEOM::GEOM_Object::_narrow(obj);
413 if (!aGeomObj->_is_nil()) {
414 GEOM::GEOM_Gen_ptr aGEOMGen = SMESH_Gen_i::GetGeomEngine();
415 TopoDS_Shape aLocShape = aSMESHGen->GetShapeReader()->GetShape( aGEOMGen, aGeomObj );
421 return TopoDS_Shape();
424 static char* getShapeNameByID (const char* theID)
428 if (theID != 0 && theID != "") {
429 SMESH_Gen_i* aSMESHGen = SMESH_Gen_i::GetSMESHGen();
430 SALOMEDS::Study_ptr aStudy = aSMESHGen->GetCurrentStudy();
432 //SALOMEDS::SObject_var aSObj = aStudy->FindObjectIOR( theID );
433 SALOMEDS::SObject_var aSObj = aStudy->FindObjectID(theID);
434 SALOMEDS::GenericAttribute_var anAttr;
435 if (!aSObj->_is_nil() && aSObj->FindAttribute(anAttr, "AttributeName")) {
436 SALOMEDS::AttributeName_var aNameAttr = SALOMEDS::AttributeName::_narrow(anAttr);
437 aName = aNameAttr->Value();
451 Description : An abstact class for all functors
453 Functor_i::Functor_i():
454 SALOME::GenericObj_i( SMESH_Gen_i::GetPOA() )
456 PortableServer::ObjectId_var anObjectId =
457 SMESH_Gen_i::GetPOA()->activate_object( this );
460 Functor_i::~Functor_i()
462 //TPythonDump()<<this<<".Destroy()";
465 void Functor_i::SetMesh( SMESH_Mesh_ptr theMesh )
467 myFunctorPtr->SetMesh( MeshPtr2SMDSMesh( theMesh ) );
468 TPythonDump()<<this<<".SetMesh("<<theMesh<<")";
471 ElementType Functor_i::GetElementType()
473 return ( ElementType )myFunctorPtr->GetType();
478 Class : NumericalFunctor_i
479 Description : Base class for numerical functors
481 CORBA::Double NumericalFunctor_i::GetValue( CORBA::Long theId )
483 return myNumericalFunctorPtr->GetValue( theId );
486 void NumericalFunctor_i::SetPrecision( CORBA::Long thePrecision )
488 myNumericalFunctorPtr->SetPrecision( thePrecision );
489 TPythonDump()<<this<<".SetPrecision("<<thePrecision<<")";
492 CORBA::Long NumericalFunctor_i::GetPrecision()
494 return myNumericalFunctorPtr->GetPrecision();
497 Controls::NumericalFunctorPtr NumericalFunctor_i::GetNumericalFunctor()
499 return myNumericalFunctorPtr;
504 Class : SMESH_MinimumAngle
505 Description : Functor for calculation of minimum angle
507 MinimumAngle_i::MinimumAngle_i()
509 myNumericalFunctorPtr.reset( new Controls::MinimumAngle() );
510 myFunctorPtr = myNumericalFunctorPtr;
513 FunctorType MinimumAngle_i::GetFunctorType()
515 return SMESH::FT_MinimumAngle;
521 Description : Functor for calculating aspect ratio
523 AspectRatio_i::AspectRatio_i()
525 myNumericalFunctorPtr.reset( new Controls::AspectRatio() );
526 myFunctorPtr = myNumericalFunctorPtr;
529 FunctorType AspectRatio_i::GetFunctorType()
531 return SMESH::FT_AspectRatio;
536 Class : AspectRatio3D
537 Description : Functor for calculating aspect ratio 3D
539 AspectRatio3D_i::AspectRatio3D_i()
541 myNumericalFunctorPtr.reset( new Controls::AspectRatio3D() );
542 myFunctorPtr = myNumericalFunctorPtr;
545 FunctorType AspectRatio3D_i::GetFunctorType()
547 return SMESH::FT_AspectRatio3D;
553 Description : Functor for calculating warping
555 Warping_i::Warping_i()
557 myNumericalFunctorPtr.reset( new Controls::Warping() );
558 myFunctorPtr = myNumericalFunctorPtr;
561 FunctorType Warping_i::GetFunctorType()
563 return SMESH::FT_Warping;
569 Description : Functor for calculating taper
573 myNumericalFunctorPtr.reset( new Controls::Taper() );
574 myFunctorPtr = myNumericalFunctorPtr;
577 FunctorType Taper_i::GetFunctorType()
579 return SMESH::FT_Taper;
585 Description : Functor for calculating skew in degrees
589 myNumericalFunctorPtr.reset( new Controls::Skew() );
590 myFunctorPtr = myNumericalFunctorPtr;
593 FunctorType Skew_i::GetFunctorType()
595 return SMESH::FT_Skew;
600 Description : Functor for calculating area
604 myNumericalFunctorPtr.reset( new Controls::Area() );
605 myFunctorPtr = myNumericalFunctorPtr;
608 FunctorType Area_i::GetFunctorType()
610 return SMESH::FT_Area;
615 Description : Functor for calculating volume of 3D element
617 Volume3D_i::Volume3D_i()
619 myNumericalFunctorPtr.reset( new Controls::Volume() );
620 myFunctorPtr = myNumericalFunctorPtr;
623 FunctorType Volume3D_i::GetFunctorType()
625 return SMESH::FT_Volume3D;
630 Description : Functor for calculating length off edge
634 myNumericalFunctorPtr.reset( new Controls::Length() );
635 myFunctorPtr = myNumericalFunctorPtr;
638 FunctorType Length_i::GetFunctorType()
640 return SMESH::FT_Length;
645 Description : Functor for calculating length of edge
647 Length2D_i::Length2D_i()
649 myNumericalFunctorPtr.reset( new Controls::Length2D() );
650 myFunctorPtr = myNumericalFunctorPtr;
653 FunctorType Length2D_i::GetFunctorType()
655 return SMESH::FT_Length2D;
658 SMESH::Length2D::Values* Length2D_i::GetValues()
660 INFOS("Length2D_i::GetValues");
661 SMESH::Controls::Length2D::TValues aValues;
662 myLength2DPtr->GetValues( aValues );
664 long i = 0, iEnd = aValues.size();
666 SMESH::Length2D::Values_var aResult = new SMESH::Length2D::Values(iEnd);
668 SMESH::Controls::Length2D::TValues::const_iterator anIter;
669 for ( anIter = aValues.begin() ; anIter != aValues.end(); anIter++, i++ )
671 const SMESH::Controls::Length2D::Value& aVal = *anIter;
672 SMESH::Length2D::Value &aValue = aResult[ i ];
674 aValue.myLength = aVal.myLength;
675 aValue.myPnt1 = aVal.myPntId[ 0 ];
676 aValue.myPnt2 = aVal.myPntId[ 1 ];
679 INFOS("Length2D_i::GetValuess~");
680 return aResult._retn();
684 Class : MultiConnection_i
685 Description : Functor for calculating number of faces conneted to the edge
687 MultiConnection_i::MultiConnection_i()
689 myNumericalFunctorPtr.reset( new Controls::MultiConnection() );
690 myFunctorPtr = myNumericalFunctorPtr;
693 FunctorType MultiConnection_i::GetFunctorType()
695 return SMESH::FT_MultiConnection;
699 Class : MultiConnection2D_i
700 Description : Functor for calculating number of faces conneted to the edge
702 MultiConnection2D_i::MultiConnection2D_i()
704 myNumericalFunctorPtr.reset( new Controls::MultiConnection2D() );
705 myFunctorPtr = myNumericalFunctorPtr;
708 FunctorType MultiConnection2D_i::GetFunctorType()
710 return SMESH::FT_MultiConnection2D;
713 SMESH::MultiConnection2D::Values* MultiConnection2D_i::GetValues()
715 INFOS("MultiConnection2D_i::GetValues");
716 SMESH::Controls::MultiConnection2D::MValues aValues;
717 myMulticonnection2DPtr->GetValues( aValues );
719 long i = 0, iEnd = aValues.size();
721 SMESH::MultiConnection2D::Values_var aResult = new SMESH::MultiConnection2D::Values(iEnd);
723 SMESH::Controls::MultiConnection2D::MValues::const_iterator anIter;
724 for ( anIter = aValues.begin() ; anIter != aValues.end(); anIter++, i++ )
726 const SMESH::Controls::MultiConnection2D::Value& aVal = (*anIter).first;
727 SMESH::MultiConnection2D::Value &aValue = aResult[ i ];
729 aValue.myPnt1 = aVal.myPntId[ 0 ];
730 aValue.myPnt2 = aVal.myPntId[ 1 ];
731 aValue.myNbConnects = (*anIter).second;
734 INFOS("Multiconnection2D_i::GetValuess~");
735 return aResult._retn();
745 Description : Base class for all predicates
747 CORBA::Boolean Predicate_i::IsSatisfy( CORBA::Long theId )
749 return myPredicatePtr->IsSatisfy( theId );
752 Controls::PredicatePtr Predicate_i::GetPredicate()
754 return myPredicatePtr;
758 Class : BadOrientedVolume_i
759 Description : Verify whether a mesh volume is incorrectly oriented from
760 the point of view of MED convention
762 BadOrientedVolume_i::BadOrientedVolume_i()
764 Controls::PredicatePtr control( new Controls::BadOrientedVolume() );
765 myFunctorPtr = myPredicatePtr = control;
768 FunctorType BadOrientedVolume_i::GetFunctorType()
770 return SMESH::FT_BadOrientedVolume;
774 Class : BelongToGeom_i
775 Description : Predicate for selection on geometrical support
777 BelongToGeom_i::BelongToGeom_i()
779 myBelongToGeomPtr.reset( new Controls::BelongToGeom() );
780 myFunctorPtr = myPredicatePtr = myBelongToGeomPtr;
785 BelongToGeom_i::~BelongToGeom_i()
791 void BelongToGeom_i::SetGeom( GEOM::GEOM_Object_ptr theGeom )
793 if ( theGeom->_is_nil() )
795 SMESH_Gen_i* aSMESHGen = SMESH_Gen_i::GetSMESHGen();
796 GEOM::GEOM_Gen_ptr aGEOMGen = SMESH_Gen_i::GetGeomEngine();
797 TopoDS_Shape aLocShape = aSMESHGen->GetShapeReader()->GetShape( aGEOMGen, theGeom );
798 myBelongToGeomPtr->SetGeom( aLocShape );
799 TPythonDump()<<this<<".SetGeom("<<theGeom<<")";
802 void BelongToGeom_i::SetGeom( const TopoDS_Shape& theShape )
804 myBelongToGeomPtr->SetGeom( theShape );
807 void BelongToGeom_i::SetElementType(ElementType theType){
808 myBelongToGeomPtr->SetType(SMDSAbs_ElementType(theType));
809 TPythonDump()<<this<<".SetElementType("<<theType<<")";
812 FunctorType BelongToGeom_i::GetFunctorType()
814 return SMESH::FT_BelongToGeom;
817 void BelongToGeom_i::SetShapeName( const char* theName )
820 myShapeName = strdup( theName );
821 myBelongToGeomPtr->SetGeom( getShapeByName( myShapeName ) );
822 TPythonDump()<<this<<".SetShapeName('"<<theName<<"')";
825 void BelongToGeom_i::SetShape( const char* theID, const char* theName )
828 myShapeName = strdup( theName );
831 myShapeID = strdup( theID );
835 if ( myShapeID && strcmp(myShapeName, getShapeNameByID(myShapeID)) == 0 )
836 myBelongToGeomPtr->SetGeom( getShapeByID(myShapeID) );
838 myBelongToGeomPtr->SetGeom( getShapeByName( myShapeName ) );
841 char* BelongToGeom_i::GetShapeName()
843 return CORBA::string_dup( myShapeName );
846 char* BelongToGeom_i::GetShapeID()
848 return CORBA::string_dup( myShapeID );
852 Class : BelongToSurface_i
853 Description : Predicate for selection on geometrical support
855 BelongToSurface_i::BelongToSurface_i( const Handle(Standard_Type)& theSurfaceType )
857 myElementsOnSurfacePtr.reset( new Controls::ElementsOnSurface() );
858 myFunctorPtr = myPredicatePtr = myElementsOnSurfacePtr;
861 mySurfaceType = theSurfaceType;
864 BelongToSurface_i::~BelongToSurface_i()
870 void BelongToSurface_i::SetSurface( GEOM::GEOM_Object_ptr theGeom, ElementType theType )
872 if ( theGeom->_is_nil() )
874 SMESH_Gen_i* aSMESHGen = SMESH_Gen_i::GetSMESHGen();
875 GEOM::GEOM_Gen_ptr aGEOMGen = SMESH_Gen_i::GetGeomEngine();
876 TopoDS_Shape aLocShape = aSMESHGen->GetShapeReader()->GetShape( aGEOMGen, theGeom );
878 if ( aLocShape.ShapeType() == TopAbs_FACE )
880 Handle(Geom_Surface) aSurf = BRep_Tool::Surface( TopoDS::Face( aLocShape ) );
881 if ( !aSurf.IsNull() && aSurf->DynamicType() == mySurfaceType )
883 myElementsOnSurfacePtr->SetSurface( aLocShape, (SMDSAbs_ElementType)theType );
888 myElementsOnSurfacePtr->SetSurface( TopoDS_Shape(), (SMDSAbs_ElementType)theType );
891 void BelongToSurface_i::SetShapeName( const char* theName, ElementType theType )
894 myShapeName = strdup( theName );
895 myElementsOnSurfacePtr->SetSurface( getShapeByName( myShapeName ), (SMDSAbs_ElementType)theType );
896 TPythonDump()<<this<<".SetShapeName('"<<theName<<"',"<<theType<<")";
899 void BelongToSurface_i::SetShape( const char* theID, const char* theName, ElementType theType )
902 myShapeName = strdup( theName );
905 myShapeID = strdup( theID );
909 if ( myShapeID && strcmp(myShapeName, getShapeNameByID(myShapeID)) == 0 )
910 myElementsOnSurfacePtr->SetSurface( getShapeByID(myShapeID), (SMDSAbs_ElementType)theType );
912 myElementsOnSurfacePtr->SetSurface( getShapeByName( myShapeName ), (SMDSAbs_ElementType)theType );
915 char* BelongToSurface_i::GetShapeName()
917 return CORBA::string_dup( myShapeName );
920 char* BelongToSurface_i::GetShapeID()
922 return CORBA::string_dup( myShapeID );
925 void BelongToSurface_i::SetTolerance( CORBA::Double theToler )
927 myElementsOnSurfacePtr->SetTolerance( theToler );
928 TPythonDump()<<this<<".SetTolerance("<<theToler<<")";
931 CORBA::Double BelongToSurface_i::GetTolerance()
933 return myElementsOnSurfacePtr->GetTolerance();
936 void BelongToSurface_i::SetUseBoundaries( CORBA::Boolean theUseBndRestrictions )
938 myElementsOnSurfacePtr->SetUseBoundaries( theUseBndRestrictions );
939 TPythonDump()<<this<<".SetUseBoundaries( " << theUseBndRestrictions << " )";
942 CORBA::Boolean BelongToSurface_i::GetUseBoundaries()
944 return myElementsOnSurfacePtr->GetUseBoundaries();
949 Class : BelongToPlane_i
950 Description : Verify whether mesh element lie in pointed Geom planar object
953 BelongToPlane_i::BelongToPlane_i()
954 : BelongToSurface_i( STANDARD_TYPE( Geom_Plane ) )
958 void BelongToPlane_i::SetPlane( GEOM::GEOM_Object_ptr theGeom, ElementType theType )
960 BelongToSurface_i::SetSurface( theGeom, theType );
961 TPythonDump()<<this<<".SetPlane("<<theGeom<<","<<theType<<")";
964 FunctorType BelongToPlane_i::GetFunctorType()
966 return FT_BelongToPlane;
970 Class : BelongToCylinder_i
971 Description : Verify whether mesh element lie in pointed Geom planar object
974 BelongToCylinder_i::BelongToCylinder_i()
975 : BelongToSurface_i( STANDARD_TYPE( Geom_CylindricalSurface ) )
979 void BelongToCylinder_i::SetCylinder( GEOM::GEOM_Object_ptr theGeom, ElementType theType )
981 BelongToSurface_i::SetSurface( theGeom, theType );
982 TPythonDump()<<this<<".SetCylinder("<<theGeom<<","<<theType<<")";
985 FunctorType BelongToCylinder_i::GetFunctorType()
987 return FT_BelongToCylinder;
991 Class : BelongToGenSurface_i
992 Description : Verify whether mesh element lie in pointed Geom planar object
995 BelongToGenSurface_i::BelongToGenSurface_i()
996 : BelongToSurface_i( STANDARD_TYPE( Geom_CylindricalSurface ) )
1000 void BelongToGenSurface_i::SetSurface( GEOM::GEOM_Object_ptr theGeom, ElementType theType )
1002 if ( theGeom->_is_nil() )
1004 TopoDS_Shape aLocShape = SMESH_Gen_i::GetSMESHGen()->GeomObjectToShape( theGeom );
1005 if ( !aLocShape.IsNull() && aLocShape.ShapeType() != TopAbs_FACE )
1006 aLocShape.Nullify();
1008 BelongToSurface_i::myElementsOnSurfacePtr->SetSurface( aLocShape, (SMDSAbs_ElementType)theType );
1009 TPythonDump()<<this<<".SetGenSurface("<<theGeom<<","<<theType<<")";
1012 FunctorType BelongToGenSurface_i::GetFunctorType()
1014 return FT_BelongToGenSurface;
1018 Class : LyingOnGeom_i
1019 Description : Predicate for selection on geometrical support
1021 LyingOnGeom_i::LyingOnGeom_i()
1023 myLyingOnGeomPtr.reset( new Controls::LyingOnGeom() );
1024 myFunctorPtr = myPredicatePtr = myLyingOnGeomPtr;
1029 LyingOnGeom_i::~LyingOnGeom_i()
1035 void LyingOnGeom_i::SetGeom( GEOM::GEOM_Object_ptr theGeom )
1037 if ( theGeom->_is_nil() )
1039 SMESH_Gen_i* aSMESHGen = SMESH_Gen_i::GetSMESHGen();
1040 GEOM::GEOM_Gen_ptr aGEOMGen = SMESH_Gen_i::GetGeomEngine();
1041 TopoDS_Shape aLocShape = aSMESHGen->GetShapeReader()->GetShape( aGEOMGen, theGeom );
1042 myLyingOnGeomPtr->SetGeom( aLocShape );
1043 TPythonDump()<<this<<".SetGeom("<<theGeom<<")";
1046 void LyingOnGeom_i::SetGeom( const TopoDS_Shape& theShape )
1048 myLyingOnGeomPtr->SetGeom( theShape );
1051 void LyingOnGeom_i::SetElementType(ElementType theType){
1052 myLyingOnGeomPtr->SetType(SMDSAbs_ElementType(theType));
1053 TPythonDump()<<this<<".SetElementType("<<theType<<")";
1056 FunctorType LyingOnGeom_i::GetFunctorType()
1058 return SMESH::FT_LyingOnGeom;
1061 void LyingOnGeom_i::SetShapeName( const char* theName )
1064 myShapeName = strdup( theName );
1065 myLyingOnGeomPtr->SetGeom( getShapeByName( myShapeName ) );
1066 TPythonDump()<<this<<".SetShapeName('"<<theName<<"')";
1069 void LyingOnGeom_i::SetShape( const char* theID, const char* theName )
1072 myShapeName = strdup( theName );
1075 myShapeID = strdup( theID );
1079 if ( myShapeID && strcmp(myShapeName, getShapeNameByID(myShapeID)) == 0 )
1080 myLyingOnGeomPtr->SetGeom( getShapeByID(myShapeID) );
1082 myLyingOnGeomPtr->SetGeom( getShapeByName( myShapeName ) );
1085 char* LyingOnGeom_i::GetShapeName()
1087 return CORBA::string_dup( myShapeName );
1090 char* LyingOnGeom_i::GetShapeID()
1092 return CORBA::string_dup( myShapeID );
1096 Class : FreeBorders_i
1097 Description : Predicate for free borders
1099 FreeBorders_i::FreeBorders_i()
1101 myPredicatePtr.reset(new Controls::FreeBorders());
1102 myFunctorPtr = myPredicatePtr;
1105 FunctorType FreeBorders_i::GetFunctorType()
1107 return SMESH::FT_FreeBorders;
1112 Description : Predicate for free borders
1114 FreeEdges_i::FreeEdges_i()
1115 : myFreeEdgesPtr( new Controls::FreeEdges() )
1117 myFunctorPtr = myPredicatePtr = myFreeEdgesPtr;
1120 SMESH::FreeEdges::Borders* FreeEdges_i::GetBorders()
1122 INFOS("FreeEdges_i::GetBorders");
1123 SMESH::Controls::FreeEdges::TBorders aBorders;
1124 myFreeEdgesPtr->GetBoreders( aBorders );
1126 long i = 0, iEnd = aBorders.size();
1128 SMESH::FreeEdges::Borders_var aResult = new SMESH::FreeEdges::Borders;
1129 aResult->length(iEnd);
1131 SMESH::Controls::FreeEdges::TBorders::const_iterator anIter;
1132 for ( anIter = aBorders.begin() ; anIter != aBorders.end(); anIter++, i++ )
1134 const SMESH::Controls::FreeEdges::Border& aBord = *anIter;
1135 SMESH::FreeEdges::Border &aBorder = aResult[ i ];
1137 aBorder.myElemId = aBord.myElemId;
1138 aBorder.myPnt1 = aBord.myPntId[ 0 ];
1139 aBorder.myPnt2 = aBord.myPntId[ 1 ];
1142 INFOS("FreeEdges_i::GetBorders~");
1143 return aResult._retn();
1146 FunctorType FreeEdges_i::GetFunctorType()
1148 return SMESH::FT_FreeEdges;
1152 Class : RangeOfIds_i
1153 Description : Predicate for Range of Ids.
1154 Range may be specified with two ways.
1155 1. Using AddToRange method
1156 2. With SetRangeStr method. Parameter of this method is a string
1157 like as "1,2,3,50-60,63,67,70-"
1160 RangeOfIds_i::RangeOfIds_i()
1162 myRangeOfIdsPtr.reset( new Controls::RangeOfIds() );
1163 myFunctorPtr = myPredicatePtr = myRangeOfIdsPtr;
1166 void RangeOfIds_i::SetRange( const SMESH::long_array& theIds )
1168 CORBA::Long iEnd = theIds.length();
1169 for ( CORBA::Long i = 0; i < iEnd; i++ )
1170 myRangeOfIdsPtr->AddToRange( theIds[ i ] );
1171 TPythonDump()<<this<<".SetRange("<<theIds<<")";
1174 CORBA::Boolean RangeOfIds_i::SetRangeStr( const char* theRange )
1176 TPythonDump()<<this<<".SetRangeStr('"<<theRange<<"')";
1177 return myRangeOfIdsPtr->SetRangeStr(
1178 TCollection_AsciiString( (Standard_CString)theRange ) );
1181 char* RangeOfIds_i::GetRangeStr()
1183 TCollection_AsciiString aStr;
1184 myRangeOfIdsPtr->GetRangeStr( aStr );
1185 return CORBA::string_dup( aStr.ToCString() );
1188 void RangeOfIds_i::SetElementType( ElementType theType )
1190 myRangeOfIdsPtr->SetType( SMDSAbs_ElementType( theType ) );
1191 TPythonDump()<<this<<".SetElementType("<<theType<<")";
1194 FunctorType RangeOfIds_i::GetFunctorType()
1196 return SMESH::FT_RangeOfIds;
1200 Class : Comparator_i
1201 Description : Base class for comparators
1203 Comparator_i::Comparator_i():
1204 myNumericalFunctor( NULL )
1207 Comparator_i::~Comparator_i()
1209 if ( myNumericalFunctor )
1210 myNumericalFunctor->Destroy();
1213 void Comparator_i::SetMargin( CORBA::Double theValue )
1215 myComparatorPtr->SetMargin( theValue );
1216 TPythonDump()<<this<<".SetMargin("<<theValue<<")";
1219 CORBA::Double Comparator_i::GetMargin()
1221 return myComparatorPtr->GetMargin();
1224 void Comparator_i::SetNumFunctor( NumericalFunctor_ptr theFunct )
1226 if ( myNumericalFunctor )
1227 myNumericalFunctor->Destroy();
1229 myNumericalFunctor = DownCast<NumericalFunctor_i*>(theFunct);
1231 if ( myNumericalFunctor )
1233 myComparatorPtr->SetNumFunctor( myNumericalFunctor->GetNumericalFunctor() );
1234 myNumericalFunctor->Register();
1235 TPythonDump()<<this<<".SetNumFunctor("<<myNumericalFunctor<<")";
1239 Controls::ComparatorPtr Comparator_i::GetComparator()
1241 return myComparatorPtr;
1244 NumericalFunctor_i* Comparator_i::GetNumFunctor_i()
1246 return myNumericalFunctor;
1252 Description : Comparator "<"
1254 LessThan_i::LessThan_i()
1256 myComparatorPtr.reset( new Controls::LessThan() );
1257 myFunctorPtr = myPredicatePtr = myComparatorPtr;
1260 FunctorType LessThan_i::GetFunctorType()
1262 return SMESH::FT_LessThan;
1268 Description : Comparator ">"
1270 MoreThan_i::MoreThan_i()
1272 myComparatorPtr.reset( new Controls::MoreThan() );
1273 myFunctorPtr = myPredicatePtr = myComparatorPtr;
1276 FunctorType MoreThan_i::GetFunctorType()
1278 return SMESH::FT_MoreThan;
1284 Description : Comparator "="
1286 EqualTo_i::EqualTo_i()
1287 : myEqualToPtr( new Controls::EqualTo() )
1289 myFunctorPtr = myPredicatePtr = myComparatorPtr = myEqualToPtr;
1292 void EqualTo_i::SetTolerance( CORBA::Double theToler )
1294 myEqualToPtr->SetTolerance( theToler );
1295 TPythonDump()<<this<<".SetTolerance("<<theToler<<")";
1298 CORBA::Double EqualTo_i::GetTolerance()
1300 return myEqualToPtr->GetTolerance();
1303 FunctorType EqualTo_i::GetFunctorType()
1305 return SMESH::FT_EqualTo;
1309 Class : LogicalNOT_i
1310 Description : Logical NOT predicate
1312 LogicalNOT_i::LogicalNOT_i()
1313 : myPredicate( NULL ),
1314 myLogicalNOTPtr( new Controls::LogicalNOT() )
1316 myFunctorPtr = myPredicatePtr = myLogicalNOTPtr;
1319 LogicalNOT_i::~LogicalNOT_i()
1322 myPredicate->Destroy();
1325 void LogicalNOT_i::SetPredicate( Predicate_ptr thePredicate )
1328 myPredicate->Destroy();
1330 myPredicate = SMESH::GetPredicate(thePredicate);
1333 myLogicalNOTPtr->SetPredicate(myPredicate->GetPredicate());
1334 myPredicate->Register();
1335 TPythonDump()<<this<<".SetPredicate("<<myPredicate<<")";
1339 FunctorType LogicalNOT_i::GetFunctorType()
1341 return SMESH::FT_LogicalNOT;
1344 Predicate_i* LogicalNOT_i::GetPredicate_i()
1351 Class : LogicalBinary_i
1352 Description : Base class for binary logical predicate
1354 LogicalBinary_i::LogicalBinary_i()
1355 : myPredicate1( NULL ),
1356 myPredicate2( NULL )
1359 LogicalBinary_i::~LogicalBinary_i()
1362 myPredicate1->Destroy();
1365 myPredicate2->Destroy();
1368 void LogicalBinary_i::SetMesh( SMESH_Mesh_ptr theMesh )
1371 myPredicate1->SetMesh( theMesh );
1374 myPredicate2->SetMesh( theMesh );
1377 void LogicalBinary_i::SetPredicate1( Predicate_ptr thePredicate )
1380 myPredicate1->Destroy();
1382 myPredicate1 = SMESH::GetPredicate(thePredicate);
1384 if ( myPredicate1 ){
1385 myLogicalBinaryPtr->SetPredicate1(myPredicate1->GetPredicate());
1386 myPredicate1->Register();
1387 TPythonDump()<<this<<".SetPredicate1("<<myPredicate1<<")";
1391 void LogicalBinary_i::SetPredicate2( Predicate_ptr thePredicate )
1394 myPredicate2->Destroy();
1396 myPredicate2 = SMESH::GetPredicate(thePredicate);
1398 if ( myPredicate2 ){
1399 myLogicalBinaryPtr->SetPredicate2(myPredicate2->GetPredicate());
1400 myPredicate2->Register();
1401 TPythonDump()<<this<<".SetPredicate2("<<myPredicate2<<")";
1405 Controls::LogicalBinaryPtr LogicalBinary_i::GetLogicalBinary()
1407 return myLogicalBinaryPtr;
1410 Predicate_i* LogicalBinary_i::GetPredicate1_i()
1412 return myPredicate1;
1414 Predicate_i* LogicalBinary_i::GetPredicate2_i()
1416 return myPredicate2;
1421 Class : LogicalAND_i
1422 Description : Logical AND
1424 LogicalAND_i::LogicalAND_i()
1426 myLogicalBinaryPtr.reset( new Controls::LogicalAND() );
1427 myFunctorPtr = myPredicatePtr = myLogicalBinaryPtr;
1430 FunctorType LogicalAND_i::GetFunctorType()
1432 return SMESH::FT_LogicalAND;
1438 Description : Logical OR
1440 LogicalOR_i::LogicalOR_i()
1442 myLogicalBinaryPtr.reset( new Controls::LogicalOR() );
1443 myFunctorPtr = myPredicatePtr = myLogicalBinaryPtr;
1446 FunctorType LogicalOR_i::GetFunctorType()
1448 return SMESH::FT_LogicalOR;
1456 FilterManager_i::FilterManager_i()
1457 : SALOME::GenericObj_i( SMESH_Gen_i::GetPOA() )
1459 PortableServer::ObjectId_var anObjectId =
1460 SMESH_Gen_i::GetPOA()->activate_object( this );
1464 FilterManager_i::~FilterManager_i()
1466 //TPythonDump()<<this<<".Destroy()";
1470 MinimumAngle_ptr FilterManager_i::CreateMinimumAngle()
1472 SMESH::MinimumAngle_i* aServant = new SMESH::MinimumAngle_i();
1473 SMESH::MinimumAngle_var anObj = aServant->_this();
1474 TPythonDump()<<aServant<<" = "<<this<<".CreateMinimumAngle()";
1475 return anObj._retn();
1479 AspectRatio_ptr FilterManager_i::CreateAspectRatio()
1481 SMESH::AspectRatio_i* aServant = new SMESH::AspectRatio_i();
1482 SMESH::AspectRatio_var anObj = aServant->_this();
1483 TPythonDump()<<aServant<<" = "<<this<<".CreateAspectRatio()";
1484 return anObj._retn();
1488 AspectRatio3D_ptr FilterManager_i::CreateAspectRatio3D()
1490 SMESH::AspectRatio3D_i* aServant = new SMESH::AspectRatio3D_i();
1491 SMESH::AspectRatio3D_var anObj = aServant->_this();
1492 TPythonDump()<<aServant<<" = "<<this<<".CreateAspectRatio3D()";
1493 return anObj._retn();
1497 Warping_ptr FilterManager_i::CreateWarping()
1499 SMESH::Warping_i* aServant = new SMESH::Warping_i();
1500 SMESH::Warping_var anObj = aServant->_this();
1501 TPythonDump()<<aServant<<" = "<<this<<".CreateWarping()";
1502 return anObj._retn();
1506 Taper_ptr FilterManager_i::CreateTaper()
1508 SMESH::Taper_i* aServant = new SMESH::Taper_i();
1509 SMESH::Taper_var anObj = aServant->_this();
1510 TPythonDump()<<aServant<<" = "<<this<<".CreateTaper()";
1511 return anObj._retn();
1515 Skew_ptr FilterManager_i::CreateSkew()
1517 SMESH::Skew_i* aServant = new SMESH::Skew_i();
1518 SMESH::Skew_var anObj = aServant->_this();
1519 TPythonDump()<<aServant<<" = "<<this<<".CreateSkew()";
1520 return anObj._retn();
1524 Area_ptr FilterManager_i::CreateArea()
1526 SMESH::Area_i* aServant = new SMESH::Area_i();
1527 SMESH::Area_var anObj = aServant->_this();
1528 TPythonDump()<<aServant<<" = "<<this<<".CreateArea()";
1529 return anObj._retn();
1533 Volume3D_ptr FilterManager_i::CreateVolume3D()
1535 SMESH::Volume3D_i* aServant = new SMESH::Volume3D_i();
1536 SMESH::Volume3D_var anObj = aServant->_this();
1537 TPythonDump()<<aServant<<" = "<<this<<".CreateVolume3D()";
1538 return anObj._retn();
1542 Length_ptr FilterManager_i::CreateLength()
1544 SMESH::Length_i* aServant = new SMESH::Length_i();
1545 SMESH::Length_var anObj = aServant->_this();
1546 TPythonDump()<<aServant<<" = "<<this<<".CreateLength()";
1547 return anObj._retn();
1550 Length2D_ptr FilterManager_i::CreateLength2D()
1552 SMESH::Length2D_i* aServant = new SMESH::Length2D_i();
1553 SMESH::Length2D_var anObj = aServant->_this();
1554 TPythonDump()<<aServant<<" = "<<this<<".CreateLength2D()";
1555 return anObj._retn();
1558 MultiConnection_ptr FilterManager_i::CreateMultiConnection()
1560 SMESH::MultiConnection_i* aServant = new SMESH::MultiConnection_i();
1561 SMESH::MultiConnection_var anObj = aServant->_this();
1562 TPythonDump()<<aServant<<" = "<<this<<".CreateMultiConnection()";
1563 return anObj._retn();
1566 MultiConnection2D_ptr FilterManager_i::CreateMultiConnection2D()
1568 SMESH::MultiConnection2D_i* aServant = new SMESH::MultiConnection2D_i();
1569 SMESH::MultiConnection2D_var anObj = aServant->_this();
1570 TPythonDump()<<aServant<<" = "<<this<<".CreateMultiConnection2D()";
1571 return anObj._retn();
1574 BelongToGeom_ptr FilterManager_i::CreateBelongToGeom()
1576 SMESH::BelongToGeom_i* aServant = new SMESH::BelongToGeom_i();
1577 SMESH::BelongToGeom_var anObj = aServant->_this();
1578 TPythonDump()<<aServant<<" = "<<this<<".CreateBelongToGeom()";
1579 return anObj._retn();
1582 BelongToPlane_ptr FilterManager_i::CreateBelongToPlane()
1584 SMESH::BelongToPlane_i* aServant = new SMESH::BelongToPlane_i();
1585 SMESH::BelongToPlane_var anObj = aServant->_this();
1586 TPythonDump()<<aServant<<" = "<<this<<".CreateBelongToPlane()";
1587 return anObj._retn();
1590 BelongToCylinder_ptr FilterManager_i::CreateBelongToCylinder()
1592 SMESH::BelongToCylinder_i* aServant = new SMESH::BelongToCylinder_i();
1593 SMESH::BelongToCylinder_var anObj = aServant->_this();
1594 TPythonDump()<<aServant<<" = "<<this<<".CreateBelongToCylinder()";
1595 return anObj._retn();
1598 BelongToGenSurface_ptr FilterManager_i::CreateBelongToGenSurface()
1600 SMESH::BelongToGenSurface_i* aServant = new SMESH::BelongToGenSurface_i();
1601 SMESH::BelongToGenSurface_var anObj = aServant->_this();
1602 TPythonDump()<<aServant<<" = "<<this<<".CreateBelongToGenSurface()";
1603 return anObj._retn();
1606 LyingOnGeom_ptr FilterManager_i::CreateLyingOnGeom()
1608 SMESH::LyingOnGeom_i* aServant = new SMESH::LyingOnGeom_i();
1609 SMESH::LyingOnGeom_var anObj = aServant->_this();
1610 TPythonDump()<<aServant<<" = "<<this<<".CreateLyingOnGeom()";
1611 return anObj._retn();
1614 FreeBorders_ptr FilterManager_i::CreateFreeBorders()
1616 SMESH::FreeBorders_i* aServant = new SMESH::FreeBorders_i();
1617 SMESH::FreeBorders_var anObj = aServant->_this();
1618 TPythonDump()<<aServant<<" = "<<this<<".CreateFreeBorders()";
1619 return anObj._retn();
1622 FreeEdges_ptr FilterManager_i::CreateFreeEdges()
1624 SMESH::FreeEdges_i* aServant = new SMESH::FreeEdges_i();
1625 SMESH::FreeEdges_var anObj = aServant->_this();
1626 TPythonDump()<<aServant<<" = "<<this<<".CreateFreeEdges()";
1627 return anObj._retn();
1630 RangeOfIds_ptr FilterManager_i::CreateRangeOfIds()
1632 SMESH::RangeOfIds_i* aServant = new SMESH::RangeOfIds_i();
1633 SMESH::RangeOfIds_var anObj = aServant->_this();
1634 TPythonDump()<<aServant<<" = "<<this<<".CreateRangeOfIds()";
1635 return anObj._retn();
1638 BadOrientedVolume_ptr FilterManager_i::CreateBadOrientedVolume()
1640 SMESH::BadOrientedVolume_i* aServant = new SMESH::BadOrientedVolume_i();
1641 SMESH::BadOrientedVolume_var anObj = aServant->_this();
1642 TPythonDump()<<aServant<<" = "<<this<<".CreateBadOrientedVolume()";
1643 return anObj._retn();
1646 LessThan_ptr FilterManager_i::CreateLessThan()
1648 SMESH::LessThan_i* aServant = new SMESH::LessThan_i();
1649 SMESH::LessThan_var anObj = aServant->_this();
1650 TPythonDump()<<aServant<<" = "<<this<<".CreateLessThan()";
1651 return anObj._retn();
1655 MoreThan_ptr FilterManager_i::CreateMoreThan()
1657 SMESH::MoreThan_i* aServant = new SMESH::MoreThan_i();
1658 SMESH::MoreThan_var anObj = aServant->_this();
1659 TPythonDump()<<aServant<<" = "<<this<<".CreateMoreThan()";
1660 return anObj._retn();
1663 EqualTo_ptr FilterManager_i::CreateEqualTo()
1665 SMESH::EqualTo_i* aServant = new SMESH::EqualTo_i();
1666 SMESH::EqualTo_var anObj = aServant->_this();
1667 TPythonDump()<<aServant<<" = "<<this<<".CreateEqualTo()";
1668 return anObj._retn();
1672 LogicalNOT_ptr FilterManager_i::CreateLogicalNOT()
1674 SMESH::LogicalNOT_i* aServant = new SMESH::LogicalNOT_i();
1675 SMESH::LogicalNOT_var anObj = aServant->_this();
1676 TPythonDump()<<aServant<<" = "<<this<<".CreateLogicalNOT()";
1677 return anObj._retn();
1681 LogicalAND_ptr FilterManager_i::CreateLogicalAND()
1683 SMESH::LogicalAND_i* aServant = new SMESH::LogicalAND_i();
1684 SMESH::LogicalAND_var anObj = aServant->_this();
1685 TPythonDump()<<aServant<<" = "<<this<<".CreateLogicalAND()";
1686 return anObj._retn();
1690 LogicalOR_ptr FilterManager_i::CreateLogicalOR()
1692 SMESH::LogicalOR_i* aServant = new SMESH::LogicalOR_i();
1693 SMESH::LogicalOR_var anObj = aServant->_this();
1694 TPythonDump()<<aServant<<" = "<<this<<".CreateLogicalOR()";
1695 return anObj._retn();
1698 Filter_ptr FilterManager_i::CreateFilter()
1700 SMESH::Filter_i* aServant = new SMESH::Filter_i();
1701 SMESH::Filter_var anObj = aServant->_this();
1702 TPythonDump()<<aServant<<" = "<<this<<".CreateFilter()";
1703 return anObj._retn();
1706 FilterLibrary_ptr FilterManager_i::LoadLibrary( const char* aFileName )
1708 SMESH::FilterLibrary_i* aServant = new SMESH::FilterLibrary_i( aFileName );
1709 SMESH::FilterLibrary_var anObj = aServant->_this();
1710 TPythonDump()<<aServant<<" = "<<this<<".LoadLibrary("<<aFileName<<")";
1711 return anObj._retn();
1714 FilterLibrary_ptr FilterManager_i::CreateLibrary()
1716 SMESH::FilterLibrary_i* aServant = new SMESH::FilterLibrary_i();
1717 SMESH::FilterLibrary_var anObj = aServant->_this();
1718 TPythonDump()<<aServant<<" = "<<this<<".CreateLibrary()";
1719 return anObj._retn();
1722 CORBA::Boolean FilterManager_i::DeleteLibrary( const char* aFileName )
1724 TPythonDump()<<this<<".DeleteLibrary("<<aFileName<<")";
1725 return remove( aFileName ) ? false : true;
1728 //=============================================================================
1730 * SMESH_Gen_i::CreateFilterManager
1732 * Create filter manager
1734 //=============================================================================
1736 SMESH::FilterManager_ptr SMESH_Gen_i::CreateFilterManager()
1738 SMESH::FilterManager_i* aFilter = new SMESH::FilterManager_i();
1739 SMESH::FilterManager_var anObj = aFilter->_this();
1740 return anObj._retn();
1748 //=======================================================================
1749 // name : Filter_i::Filter_i
1750 // Purpose : Constructor
1751 //=======================================================================
1752 Filter_i::Filter_i()
1753 : myPredicate( NULL )
1756 //=======================================================================
1757 // name : Filter_i::~Filter_i
1758 // Purpose : Destructor
1759 //=======================================================================
1760 Filter_i::~Filter_i()
1763 myPredicate->Destroy();
1765 if(!CORBA::is_nil(myMesh))
1768 //TPythonDump()<<this<<".Destroy()";
1771 //=======================================================================
1772 // name : Filter_i::SetPredicate
1773 // Purpose : Set predicate
1774 //=======================================================================
1775 void Filter_i::SetPredicate( Predicate_ptr thePredicate )
1778 myPredicate->Destroy();
1780 myPredicate = SMESH::GetPredicate(thePredicate);
1784 myFilter.SetPredicate( myPredicate->GetPredicate() );
1785 myPredicate->Register();
1786 TPythonDump()<<this<<".SetPredicate("<<myPredicate<<")";
1790 //=======================================================================
1791 // name : Filter_i::GetElementType
1792 // Purpose : Get entity type
1793 //=======================================================================
1794 SMESH::ElementType Filter_i::GetElementType()
1796 return myPredicate != 0 ? myPredicate->GetElementType() : SMESH::ALL;
1799 //=======================================================================
1800 // name : Filter_i::SetMesh
1801 // Purpose : Set mesh
1802 //=======================================================================
1805 SetMesh( SMESH_Mesh_ptr theMesh )
1807 if(!CORBA::is_nil(theMesh))
1808 theMesh->Register();
1810 if(!CORBA::is_nil(myMesh))
1814 TPythonDump()<<this<<".SetMesh("<<theMesh<<")";
1821 return GetElementsId(myMesh);
1824 //=======================================================================
1825 // name : Filter_i::GetElementsId
1826 // Purpose : Get ids of entities
1827 //=======================================================================
1830 GetElementsId( Predicate_i* thePredicate,
1831 const SMDS_Mesh* theMesh,
1832 Controls::Filter::TIdSequence& theSequence )
1834 Controls::Filter::GetElementsId(theMesh,thePredicate->GetPredicate(),theSequence);
1839 GetElementsId( Predicate_i* thePredicate,
1840 SMESH_Mesh_ptr theMesh,
1841 Controls::Filter::TIdSequence& theSequence )
1843 if(const SMDS_Mesh* aMesh = MeshPtr2SMDSMesh(theMesh))
1844 Controls::Filter::GetElementsId(aMesh,thePredicate->GetPredicate(),theSequence);
1849 GetElementsId( SMESH_Mesh_ptr theMesh )
1851 SMESH::long_array_var anArray = new SMESH::long_array;
1852 if(!CORBA::is_nil(theMesh)){
1853 Controls::Filter::TIdSequence aSequence;
1854 GetElementsId(myPredicate,theMesh,aSequence);
1855 long i = 0, iEnd = aSequence.size();
1856 anArray->length( iEnd );
1857 for ( ; i < iEnd; i++ )
1858 anArray[ i ] = aSequence[i];
1860 return anArray._retn();
1863 //=======================================================================
1864 // name : getCriteria
1865 // Purpose : Retrieve criterions from predicate
1866 //=======================================================================
1867 static inline bool getCriteria( Predicate_i* thePred,
1868 SMESH::Filter::Criteria_out theCriteria )
1870 int aFType = thePred->GetFunctorType();
1874 case FT_FreeBorders:
1877 CORBA::ULong i = theCriteria->length();
1878 theCriteria->length( i + 1 );
1880 theCriteria[ i ] = createCriterion();
1882 theCriteria[ i ].Type = aFType;
1883 theCriteria[ i ].TypeOfElement = thePred->GetElementType();
1886 case FT_BelongToGeom:
1888 BelongToGeom_i* aPred = dynamic_cast<BelongToGeom_i*>( thePred );
1890 CORBA::ULong i = theCriteria->length();
1891 theCriteria->length( i + 1 );
1893 theCriteria[ i ] = createCriterion();
1895 theCriteria[ i ].Type = FT_BelongToGeom;
1896 theCriteria[ i ].ThresholdStr = aPred->GetShapeName();
1897 theCriteria[ i ].ThresholdID = aPred->GetShapeID();
1898 theCriteria[ i ].TypeOfElement = aPred->GetElementType();
1902 case FT_BelongToPlane:
1903 case FT_BelongToCylinder:
1904 case FT_BelongToGenSurface:
1906 BelongToSurface_i* aPred = dynamic_cast<BelongToSurface_i*>( thePred );
1908 CORBA::ULong i = theCriteria->length();
1909 theCriteria->length( i + 1 );
1911 theCriteria[ i ] = createCriterion();
1913 theCriteria[ i ].Type = aFType;
1914 theCriteria[ i ].ThresholdStr = aPred->GetShapeName();
1915 theCriteria[ i ].ThresholdID = aPred->GetShapeID();
1916 theCriteria[ i ].TypeOfElement = aPred->GetElementType();
1917 theCriteria[ i ].Tolerance = aPred->GetTolerance();
1921 case FT_LyingOnGeom:
1923 LyingOnGeom_i* aPred = dynamic_cast<LyingOnGeom_i*>( thePred );
1925 CORBA::ULong i = theCriteria->length();
1926 theCriteria->length( i + 1 );
1928 theCriteria[ i ] = createCriterion();
1930 theCriteria[ i ].Type = FT_LyingOnGeom;
1931 theCriteria[ i ].ThresholdStr = aPred->GetShapeName();
1932 theCriteria[ i ].ThresholdID = aPred->GetShapeID();
1933 theCriteria[ i ].TypeOfElement = aPred->GetElementType();
1939 RangeOfIds_i* aPred = dynamic_cast<RangeOfIds_i*>( thePred );
1941 CORBA::ULong i = theCriteria->length();
1942 theCriteria->length( i + 1 );
1944 theCriteria[ i ] = createCriterion();
1946 theCriteria[ i ].Type = FT_RangeOfIds;
1947 theCriteria[ i ].ThresholdStr = aPred->GetRangeStr();
1948 theCriteria[ i ].TypeOfElement = aPred->GetElementType();
1952 case FT_BadOrientedVolume:
1954 BadOrientedVolume_i* aPred = dynamic_cast<BadOrientedVolume_i*>( thePred );
1956 CORBA::ULong i = theCriteria->length();
1957 theCriteria->length( i + 1 );
1959 theCriteria[ i ] = createCriterion();
1961 theCriteria[ i ].Type = FT_BadOrientedVolume;
1962 theCriteria[ i ].TypeOfElement = aPred->GetElementType();
1970 Comparator_i* aCompar = dynamic_cast<Comparator_i*>( thePred );
1972 CORBA::ULong i = theCriteria->length();
1973 theCriteria->length( i + 1 );
1975 theCriteria[ i ] = createCriterion();
1977 theCriteria[ i ].Type = aCompar->GetNumFunctor_i()->GetFunctorType();
1978 theCriteria[ i ].Compare = aFType;
1979 theCriteria[ i ].Threshold = aCompar->GetMargin();
1980 theCriteria[ i ].TypeOfElement = aCompar->GetElementType();
1982 if ( aFType == FT_EqualTo )
1984 EqualTo_i* aCompar = dynamic_cast<EqualTo_i*>( thePred );
1985 theCriteria[ i ].Tolerance = aCompar->GetTolerance();
1992 Predicate_i* aPred = ( dynamic_cast<LogicalNOT_i*>( thePred ) )->GetPredicate_i();
1993 getCriteria( aPred, theCriteria );
1994 theCriteria[ theCriteria->length() - 1 ].UnaryOp = FT_LogicalNOT;
2001 Predicate_i* aPred1 = ( dynamic_cast<LogicalBinary_i*>( thePred ) )->GetPredicate1_i();
2002 Predicate_i* aPred2 = ( dynamic_cast<LogicalBinary_i*>( thePred ) )->GetPredicate2_i();
2003 if ( !getCriteria( aPred1, theCriteria ) )
2005 theCriteria[ theCriteria->length() - 1 ].BinaryOp = aFType;
2006 return getCriteria( aPred2, theCriteria );
2016 //=======================================================================
2017 // name : Filter_i::GetCriteria
2018 // Purpose : Retrieve criterions from predicate
2019 //=======================================================================
2020 CORBA::Boolean Filter_i::GetCriteria( SMESH::Filter::Criteria_out theCriteria )
2022 theCriteria = new SMESH::Filter::Criteria;
2023 return myPredicate != 0 ? getCriteria( myPredicate, theCriteria ) : true;
2026 //=======================================================================
2027 // name : Filter_i::SetCriteria
2028 // Purpose : Create new predicate and set criterions in it
2029 //=======================================================================
2030 CORBA::Boolean Filter_i::SetCriteria( const SMESH::Filter::Criteria& theCriteria )
2032 if ( myPredicate != 0 )
2033 myPredicate->Destroy();
2035 SMESH::FilterManager_i* aFilter = new SMESH::FilterManager_i();
2036 FilterManager_ptr aFilterMgr = aFilter->_this();
2038 // CREATE two lists ( PREDICATES and LOG OP )
2041 TPythonDump()<<"aCriteria = []";
2042 std::list<SMESH::Predicate_ptr> aPredicates;
2043 std::list<int> aBinaries;
2044 for ( int i = 0, n = theCriteria.length(); i < n; i++ )
2046 int aCriterion = theCriteria[ i ].Type;
2047 int aCompare = theCriteria[ i ].Compare;
2048 double aThreshold = theCriteria[ i ].Threshold;
2049 const char* aThresholdStr = theCriteria[ i ].ThresholdStr;
2050 const char* aThresholdID = theCriteria[ i ].ThresholdID;
2051 int aUnary = theCriteria[ i ].UnaryOp;
2052 int aBinary = theCriteria[ i ].BinaryOp;
2053 double aTolerance = theCriteria[ i ].Tolerance;
2054 ElementType aTypeOfElem = theCriteria[ i ].TypeOfElement;
2055 long aPrecision = theCriteria[ i ].Precision;
2057 TPythonDump() << "aCriterion = SMESH.Filter.Criterion(" << aCriterion << "," << aCompare
2058 << "," << aThreshold << ",'" << aThresholdStr << "',salome.ObjectToID("
2059 << aThresholdID << ")," << aUnary << "," << aBinary << "," << aTolerance
2060 << "," << aTypeOfElem << "," << aPrecision << ")";
2062 SMESH::Predicate_ptr aPredicate = SMESH::Predicate::_nil();
2063 SMESH::NumericalFunctor_ptr aFunctor = SMESH::NumericalFunctor::_nil();
2065 switch ( aCriterion )
2069 case SMESH::FT_MultiConnection:
2070 aFunctor = aFilterMgr->CreateMultiConnection();
2072 case SMESH::FT_MultiConnection2D:
2073 aFunctor = aFilterMgr->CreateMultiConnection2D();
2075 case SMESH::FT_Length:
2076 aFunctor = aFilterMgr->CreateLength();
2078 case SMESH::FT_Length2D:
2079 aFunctor = aFilterMgr->CreateLength2D();
2081 case SMESH::FT_AspectRatio:
2082 aFunctor = aFilterMgr->CreateAspectRatio();
2084 case SMESH::FT_AspectRatio3D:
2085 aFunctor = aFilterMgr->CreateAspectRatio3D();
2087 case SMESH::FT_Warping:
2088 aFunctor = aFilterMgr->CreateWarping();
2090 case SMESH::FT_MinimumAngle:
2091 aFunctor = aFilterMgr->CreateMinimumAngle();
2093 case SMESH::FT_Taper:
2094 aFunctor = aFilterMgr->CreateTaper();
2096 case SMESH::FT_Skew:
2097 aFunctor = aFilterMgr->CreateSkew();
2099 case SMESH::FT_Area:
2100 aFunctor = aFilterMgr->CreateArea();
2102 case SMESH::FT_Volume3D:
2103 aFunctor = aFilterMgr->CreateVolume3D();
2108 case SMESH::FT_FreeBorders:
2109 aPredicate = aFilterMgr->CreateFreeBorders();
2111 case SMESH::FT_FreeEdges:
2112 aPredicate = aFilterMgr->CreateFreeEdges();
2114 case SMESH::FT_BelongToGeom:
2116 SMESH::BelongToGeom_ptr tmpPred = aFilterMgr->CreateBelongToGeom();
2117 tmpPred->SetElementType( aTypeOfElem );
2118 tmpPred->SetShape( aThresholdID, aThresholdStr );
2119 aPredicate = tmpPred;
2122 case SMESH::FT_BelongToPlane:
2123 case SMESH::FT_BelongToCylinder:
2124 case SMESH::FT_BelongToGenSurface:
2126 SMESH::BelongToSurface_ptr tmpPred;
2127 switch ( aCriterion ) {
2128 case SMESH::FT_BelongToPlane:
2129 tmpPred = aFilterMgr->CreateBelongToPlane(); break;
2130 case SMESH::FT_BelongToCylinder:
2131 tmpPred = aFilterMgr->CreateBelongToCylinder(); break;
2133 tmpPred = aFilterMgr->CreateBelongToGenSurface();
2135 tmpPred->SetShape( aThresholdID, aThresholdStr, aTypeOfElem );
2136 tmpPred->SetTolerance( aTolerance );
2137 aPredicate = tmpPred;
2140 case SMESH::FT_LyingOnGeom:
2142 SMESH::LyingOnGeom_ptr tmpPred = aFilterMgr->CreateLyingOnGeom();
2143 tmpPred->SetElementType( aTypeOfElem );
2144 tmpPred->SetShape( aThresholdID, aThresholdStr );
2145 aPredicate = tmpPred;
2148 case SMESH::FT_RangeOfIds:
2150 SMESH::RangeOfIds_ptr tmpPred = aFilterMgr->CreateRangeOfIds();
2151 tmpPred->SetRangeStr( aThresholdStr );
2152 tmpPred->SetElementType( aTypeOfElem );
2153 aPredicate = tmpPred;
2156 case SMESH::FT_BadOrientedVolume:
2158 aPredicate = aFilterMgr->CreateBadOrientedVolume();
2167 if ( !aFunctor->_is_nil() && aPredicate->_is_nil() )
2169 SMESH::Comparator_ptr aComparator = SMESH::Comparator::_nil();
2171 if ( aCompare == SMESH::FT_LessThan )
2172 aComparator = aFilterMgr->CreateLessThan();
2173 else if ( aCompare == SMESH::FT_MoreThan )
2174 aComparator = aFilterMgr->CreateMoreThan();
2175 else if ( aCompare == SMESH::FT_EqualTo )
2176 aComparator = aFilterMgr->CreateEqualTo();
2180 aComparator->SetNumFunctor( aFunctor );
2181 aComparator->SetMargin( aThreshold );
2183 if ( aCompare == FT_EqualTo )
2185 SMESH::EqualTo_var anEqualTo = SMESH::EqualTo::_narrow( aComparator );
2186 anEqualTo->SetTolerance( aTolerance );
2189 aPredicate = aComparator;
2191 aFunctor->SetPrecision( aPrecision );
2195 if ( aUnary == FT_LogicalNOT )
2197 SMESH::LogicalNOT_ptr aNotPred = aFilterMgr->CreateLogicalNOT();
2198 aNotPred->SetPredicate( aPredicate );
2199 aPredicate = aNotPred;
2203 aPredicates.push_back( aPredicate );
2204 aBinaries.push_back( aBinary );
2205 TPythonDump()<<"aCriteria.append(aCriterion)";
2208 TPythonDump()<<this<<".SetCriteria(aCriteria)";
2210 // CREATE ONE PREDICATE FROM PREVIOUSLY CREATED MAP
2212 // combine all "AND" operations
2214 std::list<SMESH::Predicate_ptr> aResList;
2216 std::list<SMESH::Predicate_ptr>::iterator aPredIter;
2217 std::list<int>::iterator aBinaryIter;
2219 SMESH::Predicate_ptr aPrevPredicate = SMESH::Predicate::_nil();
2220 int aPrevBinary = SMESH::FT_Undefined;
2222 for ( aPredIter = aPredicates.begin(), aBinaryIter = aBinaries.begin();
2223 aPredIter != aPredicates.end() && aBinaryIter != aBinaries.end();
2224 ++aPredIter, ++aBinaryIter )
2226 int aCurrBinary = *aBinaryIter;
2228 SMESH::Predicate_ptr aCurrPred = SMESH::Predicate::_nil();
2230 if ( aPrevBinary == SMESH::FT_LogicalAND )
2233 SMESH::LogicalBinary_ptr aBinaryPred = aFilterMgr->CreateLogicalAND();
2234 aBinaryPred->SetPredicate1( aPrevPredicate );
2235 aBinaryPred->SetPredicate2( *aPredIter );
2236 aCurrPred = aBinaryPred;
2239 aCurrPred = *aPredIter;
2241 if ( aCurrBinary != SMESH::FT_LogicalAND )
2242 aResList.push_back( aCurrPred );
2244 aPrevPredicate = aCurrPred;
2245 aPrevBinary = aCurrBinary;
2248 // combine all "OR" operations
2250 SMESH::Predicate_ptr aResPredicate = SMESH::Predicate::_nil();
2252 if ( aResList.size() == 1 )
2253 aResPredicate = *aResList.begin();
2254 else if ( aResList.size() > 1 )
2256 std::list<SMESH::Predicate_ptr>::iterator anIter = aResList.begin();
2257 aResPredicate = *anIter;
2259 for ( ; anIter != aResList.end(); ++anIter )
2261 SMESH::LogicalBinary_ptr aBinaryPred = aFilterMgr->CreateLogicalOR();
2262 aBinaryPred->SetPredicate1( aResPredicate );
2263 aBinaryPred->SetPredicate2( *anIter );
2264 aResPredicate = aBinaryPred;
2268 SetPredicate( aResPredicate );
2270 return !aResPredicate->_is_nil();
2273 //=======================================================================
2274 // name : Filter_i::GetPredicate_i
2275 // Purpose : Get implementation of predicate
2276 //=======================================================================
2277 Predicate_i* Filter_i::GetPredicate_i()
2282 //=======================================================================
2283 // name : Filter_i::GetPredicate
2284 // Purpose : Get predicate
2285 //=======================================================================
2286 Predicate_ptr Filter_i::GetPredicate()
2288 if ( myPredicate == 0 )
2289 return SMESH::Predicate::_nil();
2292 SMESH::Predicate_var anObj = myPredicate->_this();
2293 return anObj._retn();
2301 #define ATTR_TYPE "type"
2302 #define ATTR_COMPARE "compare"
2303 #define ATTR_THRESHOLD "threshold"
2304 #define ATTR_UNARY "unary"
2305 #define ATTR_BINARY "binary"
2306 #define ATTR_THRESHOLD_STR "threshold_str"
2307 #define ATTR_TOLERANCE "tolerance"
2308 #define ATTR_ELEMENT_TYPE "ElementType"
2310 //=======================================================================
2312 // Purpose : Convert bool to LDOMString
2313 //=======================================================================
2314 static inline LDOMString toString( CORBA::Boolean val )
2316 return val ? "logical not" : "";
2319 //=======================================================================
2321 // Purpose : Convert LDOMString to bool
2322 //=======================================================================
2323 static inline bool toBool( const LDOMString& theStr )
2325 return theStr.equals( "logical not" );
2328 //=======================================================================
2330 // Purpose : Convert double to LDOMString
2331 //=======================================================================
2332 static inline LDOMString toString( CORBA::Double val )
2335 sprintf( a, "%e", val );
2336 return LDOMString( a );
2339 //=======================================================================
2341 // Purpose : Convert LDOMString to double
2342 //=======================================================================
2343 static inline double toDouble( const LDOMString& theStr )
2345 return atof( theStr.GetString() );
2348 //=======================================================================
2350 // Purpose : Convert functor type to LDOMString
2351 //=======================================================================
2352 static inline LDOMString toString( CORBA::Long theType )
2356 case FT_AspectRatio : return "Aspect ratio";
2357 case FT_Warping : return "Warping";
2358 case FT_MinimumAngle : return "Minimum angle";
2359 case FT_Taper : return "Taper";
2360 case FT_Skew : return "Skew";
2361 case FT_Area : return "Area";
2362 case FT_Volume3D : return "Volume3D";
2363 case FT_BelongToGeom : return "Belong to Geom";
2364 case FT_BelongToPlane : return "Belong to Plane";
2365 case FT_BelongToCylinder: return "Belong to Cylinder";
2366 case FT_BelongToGenSurface: return "Belong to Generic Surface";
2367 case FT_LyingOnGeom : return "Lying on Geom";
2368 case FT_BadOrientedVolume: return "Bad Oriented Volume";
2369 case FT_RangeOfIds : return "Range of IDs";
2370 case FT_FreeBorders : return "Free borders";
2371 case FT_FreeEdges : return "Free edges";
2372 case FT_MultiConnection : return "Borders at multi-connections";
2373 case FT_MultiConnection2D: return "Borders at multi-connections 2D";
2374 case FT_Length : return "Length";
2375 case FT_Length2D : return "Length2D";
2376 case FT_LessThan : return "Less than";
2377 case FT_MoreThan : return "More than";
2378 case FT_EqualTo : return "Equal to";
2379 case FT_LogicalNOT : return "Not";
2380 case FT_LogicalAND : return "And";
2381 case FT_LogicalOR : return "Or";
2382 case FT_Undefined : return "";
2383 default : return "";
2387 //=======================================================================
2388 // name : toFunctorType
2389 // Purpose : Convert LDOMString to functor type
2390 //=======================================================================
2391 static inline SMESH::FunctorType toFunctorType( const LDOMString& theStr )
2393 if ( theStr.equals( "Aspect ratio" ) ) return FT_AspectRatio;
2394 else if ( theStr.equals( "Warping" ) ) return FT_Warping;
2395 else if ( theStr.equals( "Minimum angle" ) ) return FT_MinimumAngle;
2396 else if ( theStr.equals( "Taper" ) ) return FT_Taper;
2397 else if ( theStr.equals( "Skew" ) ) return FT_Skew;
2398 else if ( theStr.equals( "Area" ) ) return FT_Area;
2399 else if ( theStr.equals( "Volume3D" ) ) return FT_Volume3D;
2400 else if ( theStr.equals( "Belong to Geom" ) ) return FT_BelongToGeom;
2401 else if ( theStr.equals( "Belong to Plane" ) ) return FT_BelongToPlane;
2402 else if ( theStr.equals( "Belong to Cylinder" ) ) return FT_BelongToCylinder;
2403 else if ( theStr.equals( "Belong to Generic Surface" ) ) return FT_BelongToGenSurface;
2404 else if ( theStr.equals( "Lying on Geom" ) ) return FT_LyingOnGeom;
2405 else if ( theStr.equals( "Free borders" ) ) return FT_FreeBorders;
2406 else if ( theStr.equals( "Free edges" ) ) return FT_FreeEdges;
2407 else if ( theStr.equals( "Borders at multi-connections" ) ) return FT_MultiConnection;
2408 // else if ( theStr.equals( "Borders at multi-connections 2D" ) ) return FT_MultiConnection2D;
2409 else if ( theStr.equals( "Length" ) ) return FT_Length;
2410 // else if ( theStr.equals( "Length2D" ) ) return FT_Length2D;
2411 else if ( theStr.equals( "Range of IDs" ) ) return FT_RangeOfIds;
2412 else if ( theStr.equals( "Bad Oriented Volume" ) ) return FT_BadOrientedVolume;
2413 else if ( theStr.equals( "Less than" ) ) return FT_LessThan;
2414 else if ( theStr.equals( "More than" ) ) return FT_MoreThan;
2415 else if ( theStr.equals( "Equal to" ) ) return FT_EqualTo;
2416 else if ( theStr.equals( "Not" ) ) return FT_LogicalNOT;
2417 else if ( theStr.equals( "And" ) ) return FT_LogicalAND;
2418 else if ( theStr.equals( "Or" ) ) return FT_LogicalOR;
2419 else if ( theStr.equals( "" ) ) return FT_Undefined;
2420 else return FT_Undefined;
2423 //=======================================================================
2424 // name : toFunctorType
2425 // Purpose : Convert LDOMString to value of ElementType enumeration
2426 //=======================================================================
2427 static inline SMESH::ElementType toElementType( const LDOMString& theStr )
2429 if ( theStr.equals( "NODE" ) ) return SMESH::NODE;
2430 else if ( theStr.equals( "EDGE" ) ) return SMESH::EDGE;
2431 else if ( theStr.equals( "FACE" ) ) return SMESH::FACE;
2432 else if ( theStr.equals( "VOLUME" ) ) return SMESH::VOLUME;
2433 else return SMESH::ALL;
2436 //=======================================================================
2438 // Purpose : Convert ElementType to string
2439 //=======================================================================
2440 static inline LDOMString toString( const SMESH::ElementType theType )
2444 case SMESH::NODE : return "NODE";
2445 case SMESH::EDGE : return "EDGE";
2446 case SMESH::FACE : return "FACE";
2447 case SMESH::VOLUME : return "VOLUME";
2448 case SMESH::ALL : return "ALL";
2449 default : return "";
2453 //=======================================================================
2454 // name : findFilter
2455 // Purpose : Find filter in document
2456 //=======================================================================
2457 static LDOM_Element findFilter( const char* theFilterName,
2458 const LDOM_Document& theDoc,
2459 LDOM_Node* theParent = 0 )
2461 LDOM_Element aRootElement = theDoc.getDocumentElement();
2462 if ( aRootElement.isNull() || !aRootElement.hasChildNodes() )
2463 return LDOM_Element();
2465 for ( LDOM_Node aTypeNode = aRootElement.getFirstChild();
2466 !aTypeNode.isNull(); aTypeNode = aTypeNode.getNextSibling() )
2468 for ( LDOM_Node aFilter = aTypeNode.getFirstChild();
2469 !aFilter.isNull(); aFilter = aFilter.getNextSibling() )
2471 LDOM_Element* anElem = ( LDOM_Element* )&aFilter;
2472 if ( anElem->getTagName().equals( LDOMString( "filter" ) ) &&
2473 anElem->getAttribute( "name" ).equals( LDOMString( theFilterName ) ) )
2475 if ( theParent != 0 )
2476 *theParent = aTypeNode;
2477 return (LDOM_Element&)aFilter;
2481 return LDOM_Element();
2484 //=======================================================================
2485 // name : getSectionName
2486 // Purpose : Get name of section of filters
2487 //=======================================================================
2488 static const char* getSectionName( const ElementType theType )
2492 case SMESH::NODE : return "Filters for nodes";
2493 case SMESH::EDGE : return "Filters for edges";
2494 case SMESH::FACE : return "Filters for faces";
2495 case SMESH::VOLUME : return "Filters for volumes";
2496 case SMESH::ALL : return "Filters for elements";
2497 default : return "";
2501 //=======================================================================
2502 // name : getSection
2503 // Purpose : Create section for filters corresponding to the entity type
2504 //=======================================================================
2505 static LDOM_Node getSection( const ElementType theType,
2506 LDOM_Document& theDoc,
2507 const bool toCreate = false )
2509 LDOM_Element aRootElement = theDoc.getDocumentElement();
2510 if ( aRootElement.isNull() )
2514 bool anExist = false;
2515 const char* aSectionName = getSectionName( theType );
2516 if ( strcmp( aSectionName, "" ) == 0 )
2519 LDOM_NodeList aSections = theDoc.getElementsByTagName( "section" );
2521 for ( int i = 0, n = aSections.getLength(); i < n; i++ )
2523 aNode = aSections.item( i );
2524 LDOM_Element& anItem = ( LDOM_Element& )aNode;
2525 if ( anItem.getAttribute( "name" ).equals( LDOMString( aSectionName ) ) )
2532 // Create new section if necessary
2537 LDOM_Element aNewItem = theDoc.createElement( "section" );
2538 aNewItem.setAttribute( "name", aSectionName );
2539 aRootElement.appendChild( aNewItem );
2549 //=======================================================================
2550 // name : createFilterItem
2551 // Purpose : Create filter item or LDOM document
2552 //=======================================================================
2553 static LDOM_Element createFilterItem( const char* theName,
2554 SMESH::Filter_ptr theFilter,
2555 LDOM_Document& theDoc )
2557 // create new filter in document
2558 LDOM_Element aFilterItem = theDoc.createElement( "filter" );
2559 aFilterItem.setAttribute( "name", theName );
2561 // save filter criterions
2562 SMESH::Filter::Criteria_var aCriteria = new SMESH::Filter::Criteria;
2564 if ( !theFilter->GetCriteria( aCriteria ) )
2565 return LDOM_Element();
2567 for ( CORBA::ULong i = 0, n = aCriteria->length(); i < n; i++ )
2569 LDOM_Element aCriterionItem = theDoc.createElement( "criterion" );
2571 aCriterionItem.setAttribute( ATTR_TYPE , toString( aCriteria[ i ].Type) );
2572 aCriterionItem.setAttribute( ATTR_COMPARE , toString( aCriteria[ i ].Compare ) );
2573 aCriterionItem.setAttribute( ATTR_THRESHOLD , toString( aCriteria[ i ].Threshold ) );
2574 aCriterionItem.setAttribute( ATTR_UNARY , toString( aCriteria[ i ].UnaryOp ) );
2575 aCriterionItem.setAttribute( ATTR_BINARY , toString( aCriteria[ i ].BinaryOp ) );
2577 aCriterionItem.setAttribute( ATTR_THRESHOLD_STR, (const char*)aCriteria[ i ].ThresholdStr );
2578 aCriterionItem.setAttribute( ATTR_TOLERANCE , toString( aCriteria[ i ].Tolerance ) );
2579 aCriterionItem.setAttribute( ATTR_ELEMENT_TYPE ,
2580 toString( (SMESH::ElementType)aCriteria[ i ].TypeOfElement ) );
2582 aFilterItem.appendChild( aCriterionItem );
2588 //=======================================================================
2589 // name : FilterLibrary_i::FilterLibrary_i
2590 // Purpose : Constructor
2591 //=======================================================================
2592 FilterLibrary_i::FilterLibrary_i( const char* theFileName )
2594 myFileName = strdup( theFileName );
2595 SMESH::FilterManager_i* aFilterMgr = new SMESH::FilterManager_i();
2596 myFilterMgr = aFilterMgr->_this();
2600 // Try to use existing library file
2601 bool anExists = false;
2602 if ( !aParser.parse( myFileName ) )
2604 myDoc = aParser.getDocument();
2607 // Create a new XML document if it doesn't exist
2609 myDoc = LDOM_Document::createDocument( LDOMString() );
2611 LDOM_Element aRootElement = myDoc.getDocumentElement();
2612 if ( aRootElement.isNull() )
2614 // If the existing document is empty --> try to create a new one
2616 myDoc = LDOM_Document::createDocument( LDOMString() );
2620 //=======================================================================
2621 // name : FilterLibrary_i::FilterLibrary_i
2622 // Purpose : Constructor
2623 //=======================================================================
2624 FilterLibrary_i::FilterLibrary_i()
2627 SMESH::FilterManager_i* aFilter = new SMESH::FilterManager_i();
2628 myFilterMgr = aFilter->_this();
2630 myDoc = LDOM_Document::createDocument( LDOMString() );
2633 FilterLibrary_i::~FilterLibrary_i()
2636 //TPythonDump()<<this<<".Destroy()";
2639 //=======================================================================
2640 // name : FilterLibrary_i::Copy
2641 // Purpose : Create filter and initialize it with values from library
2642 //=======================================================================
2643 Filter_ptr FilterLibrary_i::Copy( const char* theFilterName )
2645 Filter_ptr aRes = Filter::_nil();
2646 LDOM_Node aFilter = findFilter( theFilterName, myDoc );
2648 if ( aFilter.isNull() )
2651 std::list<SMESH::Filter::Criterion> aCriteria;
2653 for ( LDOM_Node aCritNode = aFilter.getFirstChild();
2654 !aCritNode.isNull() ; aCritNode = aCritNode.getNextSibling() )
2656 LDOM_Element* aCrit = (LDOM_Element*)&aCritNode;
2658 const char* aTypeStr = aCrit->getAttribute( ATTR_TYPE ).GetString();
2659 const char* aCompareStr = aCrit->getAttribute( ATTR_COMPARE ).GetString();
2660 const char* aUnaryStr = aCrit->getAttribute( ATTR_UNARY ).GetString();
2661 const char* aBinaryStr = aCrit->getAttribute( ATTR_BINARY ).GetString();
2662 const char* anElemTypeStr = aCrit->getAttribute( ATTR_ELEMENT_TYPE ).GetString();
2664 SMESH::Filter::Criterion aCriterion = createCriterion();
2666 aCriterion.Type = toFunctorType( aTypeStr );
2667 aCriterion.Compare = toFunctorType( aCompareStr );
2668 aCriterion.UnaryOp = toFunctorType( aUnaryStr );
2669 aCriterion.BinaryOp = toFunctorType( aBinaryStr );
2671 aCriterion.TypeOfElement = toElementType( anElemTypeStr );
2673 LDOMString str = aCrit->getAttribute( ATTR_THRESHOLD );
2675 aCriterion.Threshold = str.Type() == LDOMBasicString::LDOM_Integer && str.GetInteger( val )
2676 ? val : atof( str.GetString() );
2678 str = aCrit->getAttribute( ATTR_TOLERANCE );
2679 aCriterion.Tolerance = str.Type() == LDOMBasicString::LDOM_Integer && str.GetInteger( val )
2680 ? val : atof( str.GetString() );
2682 str = aCrit->getAttribute( ATTR_THRESHOLD_STR );
2683 if ( str.Type() == LDOMBasicString::LDOM_Integer && str.GetInteger( val ) )
2686 sprintf( a, "%d", val );
2687 aCriterion.ThresholdStr = strdup( a );
2690 aCriterion.ThresholdStr = str.GetString();
2692 aCriteria.push_back( aCriterion );
2695 SMESH::Filter::Criteria_var aCriteriaVar = new SMESH::Filter::Criteria;
2696 aCriteriaVar->length( aCriteria.size() );
2699 std::list<SMESH::Filter::Criterion>::iterator anIter = aCriteria.begin();
2701 for( ; anIter != aCriteria.end(); ++anIter )
2702 aCriteriaVar[ i++ ] = *anIter;
2704 aRes = myFilterMgr->CreateFilter();
2705 aRes->SetCriteria( aCriteriaVar.inout() );
2707 TPythonDump()<<this<<".Copy('"<<theFilterName<<"')";
2712 //=======================================================================
2713 // name : FilterLibrary_i::SetFileName
2714 // Purpose : Set file name for library
2715 //=======================================================================
2716 void FilterLibrary_i::SetFileName( const char* theFileName )
2719 myFileName = strdup( theFileName );
2720 TPythonDump()<<this<<".SetFileName('"<<theFileName<<"')";
2723 //=======================================================================
2724 // name : FilterLibrary_i::GetFileName
2725 // Purpose : Get file name of library
2726 //=======================================================================
2727 char* FilterLibrary_i::GetFileName()
2729 return CORBA::string_dup( myFileName );
2732 //=======================================================================
2733 // name : FilterLibrary_i::Add
2734 // Purpose : Add new filter to library
2735 //=======================================================================
2736 CORBA::Boolean FilterLibrary_i::Add( const char* theFilterName, Filter_ptr theFilter )
2738 // if filter already in library or entry filter is null do nothing
2739 LDOM_Node aFilterNode = findFilter( theFilterName, myDoc );
2740 if ( !aFilterNode.isNull() || theFilter->_is_nil() )
2743 // get section corresponding to the filter type
2744 ElementType anEntType = theFilter->GetElementType();
2746 LDOM_Node aSection = getSection( anEntType, myDoc, true );
2747 if ( aSection.isNull() )
2750 // create filter item
2751 LDOM_Element aFilterItem = createFilterItem( theFilterName, theFilter, myDoc );
2752 if ( aFilterItem.isNull() )
2756 aSection.appendChild( aFilterItem );
2757 if(Filter_i* aFilter = DownCast<Filter_i*>(theFilter))
2758 TPythonDump()<<this<<".Add('"<<theFilterName<<"',"<<aFilter<<")";
2763 //=======================================================================
2764 // name : FilterLibrary_i::Add
2765 // Purpose : Add new filter to library
2766 //=======================================================================
2767 CORBA::Boolean FilterLibrary_i::AddEmpty( const char* theFilterName, ElementType theType )
2769 // if filter already in library or entry filter is null do nothing
2770 LDOM_Node aFilterNode = findFilter( theFilterName, myDoc );
2771 if ( !aFilterNode.isNull() )
2774 LDOM_Node aSection = getSection( theType, myDoc, true );
2775 if ( aSection.isNull() )
2778 // create filter item
2779 Filter_var aFilter = myFilterMgr->CreateFilter();
2781 LDOM_Element aFilterItem = createFilterItem( theFilterName, aFilter, myDoc );
2782 if ( aFilterItem.isNull() )
2786 aSection.appendChild( aFilterItem );
2787 TPythonDump()<<this<<".AddEmpty('"<<theFilterName<<"',"<<theType<<")";
2792 //=======================================================================
2793 // name : FilterLibrary_i::Delete
2794 // Purpose : Delete filter from library
2795 //=======================================================================
2796 CORBA::Boolean FilterLibrary_i::Delete ( const char* theFilterName )
2798 LDOM_Node aParentNode;
2799 LDOM_Node aFilterNode = findFilter( theFilterName, myDoc, &aParentNode );
2800 if ( aFilterNode.isNull() || aParentNode.isNull() )
2803 aParentNode.removeChild( aFilterNode );
2804 TPythonDump()<<this<<".Delete('"<<theFilterName<<"')";
2808 //=======================================================================
2809 // name : FilterLibrary_i::Replace
2810 // Purpose : Replace existing filter with entry filter.
2811 // IMPORTANT : If filter does not exist it is not created
2812 //=======================================================================
2813 CORBA::Boolean FilterLibrary_i::Replace( const char* theFilterName,
2814 const char* theNewName,
2815 Filter_ptr theFilter )
2817 LDOM_Element aFilterItem = findFilter( theFilterName, myDoc );
2818 if ( aFilterItem.isNull() || theFilter->_is_nil() )
2821 LDOM_Element aNewItem = createFilterItem( theNewName, theFilter, myDoc );
2822 if ( aNewItem.isNull() )
2826 aFilterItem.ReplaceElement( aNewItem );
2827 if(Filter_i* aFilter = DownCast<Filter_i*>(theFilter))
2828 TPythonDump()<<this<<".Replace('"<<theFilterName<<"',"<<theNewName<<"',"<<aFilter<<")";
2833 //=======================================================================
2834 // name : FilterLibrary_i::Save
2835 // Purpose : Save library on disk
2836 //=======================================================================
2837 CORBA::Boolean FilterLibrary_i::Save()
2839 if ( myFileName == 0 || strlen( myFileName ) == 0 )
2842 FILE* aOutFile = fopen( myFileName, "wt" );
2846 LDOM_XmlWriter aWriter( aOutFile );
2847 aWriter.SetIndentation( 2 );
2851 TPythonDump()<<this<<".Save()";
2855 //=======================================================================
2856 // name : FilterLibrary_i::SaveAs
2857 // Purpose : Save library on disk
2858 //=======================================================================
2859 CORBA::Boolean FilterLibrary_i::SaveAs( const char* aFileName )
2861 myFileName = strdup ( aFileName );
2862 TPythonDump()<<this<<".SaveAs('"<<aFileName<<"')";
2866 //=======================================================================
2867 // name : FilterLibrary_i::IsPresent
2868 // Purpose : Verify whether filter is in library
2869 //=======================================================================
2870 CORBA::Boolean FilterLibrary_i::IsPresent( const char* theFilterName )
2872 return !findFilter( theFilterName, myDoc ).isNull();
2875 //=======================================================================
2876 // name : FilterLibrary_i::NbFilters
2877 // Purpose : Return amount of filters in library
2878 //=======================================================================
2879 CORBA::Long FilterLibrary_i::NbFilters( ElementType theType )
2881 string_array_var aNames = GetNames( theType );
2882 return aNames->length();
2885 //=======================================================================
2886 // name : FilterLibrary_i::GetNames
2887 // Purpose : Get names of filters from library
2888 //=======================================================================
2889 string_array* FilterLibrary_i::GetNames( ElementType theType )
2891 string_array_var anArray = new string_array;
2892 TColStd_SequenceOfHAsciiString aSeq;
2894 LDOM_Node aSection = getSection( theType, myDoc, false );
2896 if ( !aSection.isNull() )
2898 for ( LDOM_Node aFilter = aSection.getFirstChild();
2899 !aFilter.isNull(); aFilter = aFilter.getNextSibling() )
2901 LDOM_Element& anElem = ( LDOM_Element& )aFilter;
2902 aSeq.Append( new TCollection_HAsciiString(
2903 (Standard_CString)anElem.getAttribute( "name" ).GetString() ) );
2907 anArray->length( aSeq.Length() );
2908 for ( int i = 1, n = aSeq.Length(); i <= n; i++ )
2909 anArray[ i - 1 ] = CORBA::string_dup( aSeq( i )->ToCString() );
2911 return anArray._retn();
2914 //=======================================================================
2915 // name : FilterLibrary_i::GetAllNames
2916 // Purpose : Get names of filters from library
2917 //=======================================================================
2918 string_array* FilterLibrary_i::GetAllNames()
2920 string_array_var aResArray = new string_array;
2921 for ( int type = SMESH::ALL; type <= SMESH::VOLUME; type++ )
2923 SMESH::string_array_var aNames = GetNames( (SMESH::ElementType)type );
2925 int aPrevLength = aResArray->length();
2926 aResArray->length( aPrevLength + aNames->length() );
2927 for ( int i = 0, n = aNames->length(); i < n; i++ )
2928 aResArray[ aPrevLength + i ] = aNames[ i ];
2931 return aResArray._retn();