Salome HOME
IPAL52868: Confusing error message when computing an imported mesh w/o algo assigned
[modules/smesh.git] / src / SMESH_I / SMESH_Filter_i.cxx
1 // Copyright (C) 2007-2015  CEA/DEN, EDF R&D, OPEN CASCADE
2 //
3 // Copyright (C) 2003-2007  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
4 // CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
5 //
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, or (at your option) any later version.
10 //
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.
15 //
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
19 //
20 // See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
21 //
22
23 //  SMESH SMESH_I : idl implementation based on 'SMESH' unit's calsses
24 //  File   : SMESH_Filter_i.cxx
25 //  Author : Alexey Petrov, OCC
26 //  Module : SMESH
27
28 #include "SMESH_Filter_i.hxx"
29
30 #include "SMDS_ElemIterator.hxx"
31 #include "SMDS_Mesh.hxx"
32 #include "SMDS_MeshElement.hxx"
33 #include "SMDS_MeshNode.hxx"
34 #include "SMESHDS_GroupBase.hxx"
35 #include "SMESHDS_Mesh.hxx"
36 #include "SMESH_Gen_i.hxx"
37 #include "SMESH_Group_i.hxx"
38 #include "SMESH_PythonDump.hxx"
39
40 #include <SALOMEDS_wrap.hxx>
41 #include <GEOM_wrap.hxx>
42
43 #include <BRep_Tool.hxx>
44 #include <Geom_CylindricalSurface.hxx>
45 #include <Geom_Plane.hxx>
46 #include <LDOMParser.hxx>
47 #include <LDOMString.hxx>
48 #include <LDOM_Document.hxx>
49 #include <LDOM_Element.hxx>
50 #include <LDOM_Node.hxx>
51 #include <LDOM_XmlWriter.hxx>
52 #include <Precision.hxx>
53 #include <TColStd_ListIteratorOfListOfInteger.hxx>
54 #include <TColStd_ListIteratorOfListOfReal.hxx>
55 #include <TColStd_ListOfInteger.hxx>
56 #include <TColStd_ListOfReal.hxx>
57 #include <TColStd_SequenceOfHAsciiString.hxx>
58 #include <TCollection_HAsciiString.hxx>
59 #include <TopExp_Explorer.hxx>
60 #include <TopoDS.hxx>
61 #include <TopoDS_Shape.hxx>
62
63 using namespace SMESH;
64 using namespace SMESH::Controls;
65
66
67 namespace SMESH
68 {
69   Predicate_i*
70   GetPredicate( Predicate_ptr thePredicate )
71   {
72     return DownCast<Predicate_i*>(thePredicate);
73   }
74 }
75
76 /*
77                             AUXILIARY METHODS
78 */
79
80 inline
81 const SMDS_Mesh*
82 MeshPtr2SMDSMesh( SMESH_Mesh_ptr theMesh )
83 {
84   SMESH_Mesh_i* anImplPtr = DownCast<SMESH_Mesh_i*>(theMesh);
85   return anImplPtr ? anImplPtr->GetImpl().GetMeshDS() : 0;
86 }
87
88 inline
89 SMESH::long_array*
90 toArray( const TColStd_ListOfInteger& aList )
91 {
92   SMESH::long_array_var anArray = new SMESH::long_array;
93   anArray->length( aList.Extent() );
94   TColStd_ListIteratorOfListOfInteger anIter( aList );
95   int i = 0;
96   for( ; anIter.More(); anIter.Next() )
97     anArray[ i++ ] = anIter.Value();
98
99   return anArray._retn();
100 }
101
102 inline
103 SMESH::double_array*
104 toArray( const TColStd_ListOfReal& aList )
105 {
106   SMESH::double_array_var anArray = new SMESH::double_array;
107   anArray->length( aList.Extent() );
108   TColStd_ListIteratorOfListOfReal anIter( aList );
109   int i = 0;
110   for( ; anIter.More(); anIter.Next() )
111     anArray[ i++ ] = anIter.Value();
112
113   return anArray._retn();
114 }
115
116 static SMESH::Filter::Criterion createCriterion()
117 {
118   SMESH::Filter::Criterion aCriterion;
119
120   aCriterion.Type          = FT_Undefined;
121   aCriterion.Compare       = FT_Undefined;
122   aCriterion.Threshold     = 0;
123   aCriterion.UnaryOp       = FT_Undefined;
124   aCriterion.BinaryOp      = FT_Undefined;
125   aCriterion.ThresholdStr  = "";
126   aCriterion.ThresholdID   = "";
127   aCriterion.Tolerance     = Precision::Confusion();
128   aCriterion.TypeOfElement = SMESH::ALL;
129   aCriterion.Precision     = -1;
130
131   return aCriterion;
132 }
133
134 static TopoDS_Shape getShapeByName( const char* theName )
135 {
136   if ( theName != 0 )
137   {
138     SMESH_Gen_i* aSMESHGen     = SMESH_Gen_i::GetSMESHGen();
139     SALOMEDS::Study_var aStudy = aSMESHGen->GetCurrentStudy();
140     if ( !aStudy->_is_nil() )
141     {
142       SALOMEDS::Study::ListOfSObject_var aList = aStudy->FindObjectByName( theName, "GEOM" );
143       if ( aList->length() > 0 )
144       {
145         CORBA::Object_var        anObj = aList[ 0 ]->GetObject();
146         GEOM::GEOM_Object_var aGeomObj = GEOM::GEOM_Object::_narrow( anObj );
147         TopoDS_Shape             shape = aSMESHGen->GeomObjectToShape( aGeomObj );
148         SALOME::UnRegister( aList ); // UnRegister() objects in aList
149         return shape;
150       }
151     }
152   }
153   return TopoDS_Shape();
154 }
155
156 static TopoDS_Shape getShapeByID (const char* theID)
157 {
158   if ( theID && strlen( theID ) > 0 ) {
159     SMESH_Gen_i*     aSMESHGen = SMESH_Gen_i::GetSMESHGen();
160     SALOMEDS::Study_var aStudy = aSMESHGen->GetCurrentStudy();
161     if ( !aStudy->_is_nil() ) {
162       SALOMEDS::SObject_wrap aSObj = aStudy->FindObjectID(theID);
163       if ( !aSObj->_is_nil() ) {
164         CORBA::Object_var          obj = aSObj->GetObject();
165         GEOM::GEOM_Object_var aGeomObj = GEOM::GEOM_Object::_narrow(obj);
166         return aSMESHGen->GeomObjectToShape( aGeomObj );
167       }
168     }
169   }
170   return TopoDS_Shape();
171 }
172
173 static std::string getShapeNameByID (const char* theID)
174 {
175   if ( theID && strlen( theID ) > 0 ) {
176     SMESH_Gen_i*     aSMESHGen = SMESH_Gen_i::GetSMESHGen();
177     SALOMEDS::Study_var aStudy = aSMESHGen->GetCurrentStudy();
178     if ( !aStudy->_is_nil() ) {
179       SALOMEDS::SObject_wrap aSObj = aStudy->FindObjectID(theID);
180       if ( !aSObj->_is_nil() ) {
181         CORBA::String_var name = aSObj->GetName();
182         return name.in();
183       }
184     }
185   }
186   return "";
187 }
188
189 /*
190                                 FUNCTORS
191 */
192
193 /*
194   Class       : Functor_i
195   Description : An abstact class for all functors
196 */
197 Functor_i::Functor_i():
198   SALOME::GenericObj_i( SMESH_Gen_i::GetPOA() )
199 {
200   //Base class Salome_GenericObject do it inmplicitly by overriding PortableServer::POA_ptr _default_POA() method  
201   //PortableServer::ObjectId_var anObjectId =
202   //  SMESH_Gen_i::GetPOA()->activate_object( this );
203 }
204
205 Functor_i::~Functor_i()
206 {
207   //TPythonDump()<<this<<".UnRegister()";
208 }
209
210 void Functor_i::SetMesh( SMESH_Mesh_ptr theMesh )
211 {
212   myFunctorPtr->SetMesh( MeshPtr2SMDSMesh( theMesh ) );
213   TPythonDump()<<this<<".SetMesh("<<theMesh<<")";
214 }
215
216 ElementType Functor_i::GetElementType()
217 {
218   return ( ElementType )myFunctorPtr->GetType();
219 }
220
221
222 /*
223   Class       : NumericalFunctor_i
224   Description : Base class for numerical functors
225 */
226 CORBA::Double NumericalFunctor_i::GetValue( CORBA::Long theId )
227 {
228   return myNumericalFunctorPtr->GetValue( theId );
229 }
230
231 SMESH::Histogram* NumericalFunctor_i::GetHistogram(CORBA::Short nbIntervals, CORBA::Boolean isLogarithmic)
232 {
233   std::vector<int> nbEvents;
234   std::vector<double> funValues;
235   std::vector<int> elements;
236   myNumericalFunctorPtr->GetHistogram(nbIntervals,nbEvents,funValues,elements,0,isLogarithmic);
237
238   SMESH::Histogram_var histogram = new SMESH::Histogram;
239
240   nbIntervals = CORBA::Short( Min( int( nbEvents.size()),
241                                    int( funValues.size() - 1 )));
242   if ( nbIntervals > 0 )
243   {
244     histogram->length( nbIntervals );
245     for ( int i = 0; i < nbIntervals; ++i )
246     {
247       HistogramRectangle& rect = histogram[i];
248       rect.nbEvents = nbEvents[i];
249       rect.min = funValues[i];
250       rect.max = funValues[i+1];
251     }
252   }
253   return histogram._retn();
254 }
255
256 SMESH::Histogram* NumericalFunctor_i::GetLocalHistogram(CORBA::Short              nbIntervals,
257                                                         CORBA::Boolean            isLogarithmic,
258                                                         SMESH::SMESH_IDSource_ptr object)
259 {
260   SMESH::Histogram_var histogram = new SMESH::Histogram;
261
262   std::vector<int>    nbEvents;
263   std::vector<double> funValues;
264   std::vector<int>    elements;
265
266   SMDS_ElemIteratorPtr elemIt;
267   if ( SMESH::DownCast< SMESH_GroupOnFilter_i* >( object ) ||
268        SMESH::DownCast< SMESH::Filter_i* >( object ))
269   {
270     elemIt = SMESH_Mesh_i::GetElements( object, GetElementType() );
271     if ( !elemIt ) return histogram._retn();
272   }
273   else
274   {
275     SMESH::SMESH_Mesh_var        mesh = object->GetMesh();
276     SMESH::long_array_var  objNbElems = object->GetNbElementsByType();
277     SMESH::long_array_var meshNbElems = mesh->  GetNbElementsByType();
278     if ( meshNbElems[ GetElementType() ] !=
279          objNbElems [ GetElementType() ] )
280     {
281       elements.reserve( objNbElems[ GetElementType() ]);
282       elemIt = SMESH_Mesh_i::GetElements( object, GetElementType() );
283     }
284   }
285   if ( elemIt )
286   {
287     while ( elemIt->more() )
288       elements.push_back( elemIt->next()->GetID() );
289     if ( elements.empty() ) return histogram._retn();
290   }
291
292   myNumericalFunctorPtr->GetHistogram(nbIntervals,nbEvents,funValues,elements,0,isLogarithmic);
293
294   nbIntervals = CORBA::Short( Min( int( nbEvents.size()),
295                                    int( funValues.size() - 1 )));
296   if ( nbIntervals > 0 )
297   {
298     histogram->length( nbIntervals );
299     for ( int i = 0; i < nbIntervals; ++i )
300     {
301       HistogramRectangle& rect = histogram[i];
302       rect.nbEvents = nbEvents[i];
303       rect.min = funValues[i];
304       rect.max = funValues[i+1];
305     }
306   }
307   return histogram._retn();
308 }
309
310 void NumericalFunctor_i::SetPrecision( CORBA::Long thePrecision )
311 {
312   myNumericalFunctorPtr->SetPrecision( thePrecision );
313   TPythonDump()<<this<<".SetPrecision("<<thePrecision<<")";
314 }
315
316 CORBA::Long NumericalFunctor_i::GetPrecision()
317 {
318  return myNumericalFunctorPtr->GetPrecision();
319 }
320
321 Controls::NumericalFunctorPtr NumericalFunctor_i::GetNumericalFunctor()
322 {
323   return myNumericalFunctorPtr;
324 }
325
326
327 /*
328   Class       : SMESH_MinimumAngle
329   Description : Functor for calculation of minimum angle
330 */
331 MinimumAngle_i::MinimumAngle_i()
332 {
333   myNumericalFunctorPtr.reset( new Controls::MinimumAngle() );
334   myFunctorPtr = myNumericalFunctorPtr;
335 }
336
337 FunctorType MinimumAngle_i::GetFunctorType()
338 {
339   return SMESH::FT_MinimumAngle;
340 }
341
342
343 /*
344   Class       : AspectRatio
345   Description : Functor for calculating aspect ratio
346 */
347 AspectRatio_i::AspectRatio_i()
348 {
349   myNumericalFunctorPtr.reset( new Controls::AspectRatio() );
350   myFunctorPtr = myNumericalFunctorPtr;
351 }
352
353 FunctorType AspectRatio_i::GetFunctorType()
354 {
355   return SMESH::FT_AspectRatio;
356 }
357
358
359 /*
360   Class       : AspectRatio3D
361   Description : Functor for calculating aspect ratio 3D
362 */
363 AspectRatio3D_i::AspectRatio3D_i()
364 {
365   myNumericalFunctorPtr.reset( new Controls::AspectRatio3D() );
366   myFunctorPtr = myNumericalFunctorPtr;
367 }
368
369 FunctorType AspectRatio3D_i::GetFunctorType()
370 {
371   return SMESH::FT_AspectRatio3D;
372 }
373
374
375 /*
376   Class       : Warping_i
377   Description : Functor for calculating warping
378 */
379 Warping_i::Warping_i()
380 {
381   myNumericalFunctorPtr.reset( new Controls::Warping() );
382   myFunctorPtr = myNumericalFunctorPtr;
383 }
384
385 FunctorType Warping_i::GetFunctorType()
386 {
387   return SMESH::FT_Warping;
388 }
389
390
391 /*
392   Class       : Taper_i
393   Description : Functor for calculating taper
394 */
395 Taper_i::Taper_i()
396 {
397   myNumericalFunctorPtr.reset( new Controls::Taper() );
398   myFunctorPtr = myNumericalFunctorPtr;
399 }
400
401 FunctorType Taper_i::GetFunctorType()
402 {
403   return SMESH::FT_Taper;
404 }
405
406 /*
407   Class       : Skew_i
408   Description : Functor for calculating skew in degrees
409 */
410 Skew_i::Skew_i()
411 {
412   myNumericalFunctorPtr.reset( new Controls::Skew() );
413   myFunctorPtr = myNumericalFunctorPtr;
414 }
415
416 FunctorType Skew_i::GetFunctorType()
417 {
418   return SMESH::FT_Skew;
419 }
420
421 /*
422   Class       : Area_i
423   Description : Functor for calculating area
424 */
425 Area_i::Area_i()
426 {
427   myNumericalFunctorPtr.reset( new Controls::Area() );
428   myFunctorPtr = myNumericalFunctorPtr;
429 }
430
431 FunctorType Area_i::GetFunctorType()
432 {
433   return SMESH::FT_Area;
434 }
435
436 /*
437   Class       : Volume3D_i
438   Description : Functor for calculating volume of 3D element
439 */
440 Volume3D_i::Volume3D_i()
441 {
442   myNumericalFunctorPtr.reset( new Controls::Volume() );
443   myFunctorPtr = myNumericalFunctorPtr;
444 }
445
446 FunctorType Volume3D_i::GetFunctorType()
447 {
448   return SMESH::FT_Volume3D;
449 }
450
451 /*
452   Class       : MaxElementLength2D_i
453   Description : Functor for calculating maximum length of 2D element
454 */
455 MaxElementLength2D_i::MaxElementLength2D_i()
456 {
457   myNumericalFunctorPtr.reset( new Controls::MaxElementLength2D() );
458   myFunctorPtr = myNumericalFunctorPtr;
459 }
460
461 FunctorType MaxElementLength2D_i::GetFunctorType()
462 {
463   return SMESH::FT_MaxElementLength2D;
464 }
465
466 /*
467   Class       : MaxElementLength3D_i
468   Description : Functor for calculating maximum length of 3D element
469 */
470 MaxElementLength3D_i::MaxElementLength3D_i()
471 {
472   myNumericalFunctorPtr.reset( new Controls::MaxElementLength3D() );
473   myFunctorPtr = myNumericalFunctorPtr;
474 }
475
476 FunctorType MaxElementLength3D_i::GetFunctorType()
477 {
478   return SMESH::FT_MaxElementLength3D;
479 }
480
481 /*
482   Class       : Length_i
483   Description : Functor for calculating length off edge
484 */
485 Length_i::Length_i()
486 {
487   myNumericalFunctorPtr.reset( new Controls::Length() );
488   myFunctorPtr = myNumericalFunctorPtr;
489 }
490
491 FunctorType Length_i::GetFunctorType()
492 {
493   return SMESH::FT_Length;
494 }
495
496 /*
497   Class       : Length2D_i
498   Description : Functor for calculating length of edge
499 */
500 Length2D_i::Length2D_i()
501 {
502   myNumericalFunctorPtr.reset( new Controls::Length2D() );
503   myFunctorPtr = myNumericalFunctorPtr;
504 }
505
506 FunctorType Length2D_i::GetFunctorType()
507 {
508   return SMESH::FT_Length2D;
509 }
510
511 SMESH::Length2D::Values* Length2D_i::GetValues()
512 {
513   SMESH::Controls::Length2D::TValues aValues;
514   (dynamic_cast<SMESH::Controls::Length2D*>(myFunctorPtr.get()))->GetValues( aValues );
515
516   long i = 0, iEnd = aValues.size();
517
518   SMESH::Length2D::Values_var aResult = new SMESH::Length2D::Values(iEnd);
519   aResult->length(iEnd);
520
521   SMESH::Controls::Length2D::TValues::const_iterator anIter;
522   for ( anIter = aValues.begin() ; anIter != aValues.end(); anIter++, i++ )
523   {
524     const SMESH::Controls::Length2D::Value&  aVal = *anIter;
525     SMESH::Length2D::Value &aValue = aResult[ i ];
526
527     aValue.myLength = aVal.myLength;
528     aValue.myPnt1 = aVal.myPntId[ 0 ];
529     aValue.myPnt2 = aVal.myPntId[ 1 ];
530   }
531
532   return aResult._retn();
533 }
534
535 /*
536   Class       : MultiConnection_i
537   Description : Functor for calculating number of faces conneted to the edge
538 */
539 MultiConnection_i::MultiConnection_i()
540 {
541   myNumericalFunctorPtr.reset( new Controls::MultiConnection() );
542   myFunctorPtr = myNumericalFunctorPtr;
543 }
544
545 FunctorType MultiConnection_i::GetFunctorType()
546 {
547   return SMESH::FT_MultiConnection;
548 }
549
550 /*
551   Class       : BallDiameter_i
552   Description : Functor returning diameter of a ball element
553 */
554 BallDiameter_i::BallDiameter_i()
555 {
556   myNumericalFunctorPtr.reset( new Controls::BallDiameter() );
557   myFunctorPtr = myNumericalFunctorPtr;
558 }
559
560 FunctorType BallDiameter_i::GetFunctorType()
561 {
562   return SMESH::FT_BallDiameter;
563 }
564
565 /*
566   Class       : MultiConnection2D_i
567   Description : Functor for calculating number of faces conneted to the edge
568 */
569 MultiConnection2D_i::MultiConnection2D_i()
570 {
571   myNumericalFunctorPtr.reset( new Controls::MultiConnection2D() );
572   myFunctorPtr = myNumericalFunctorPtr;
573 }
574
575 FunctorType MultiConnection2D_i::GetFunctorType()
576 {
577   return SMESH::FT_MultiConnection2D;
578 }
579
580 SMESH::MultiConnection2D::Values* MultiConnection2D_i::GetValues()
581 {
582   SMESH::Controls::MultiConnection2D::MValues aValues;
583   (dynamic_cast<SMESH::Controls::MultiConnection2D*>(myFunctorPtr.get()))->GetValues( aValues );
584   
585   long i = 0, iEnd = aValues.size();
586
587   SMESH::MultiConnection2D::Values_var aResult = new SMESH::MultiConnection2D::Values(iEnd);
588   aResult->length(iEnd);
589
590   SMESH::Controls::MultiConnection2D::MValues::const_iterator anIter;
591   for ( anIter = aValues.begin() ; anIter != aValues.end(); anIter++, i++ )
592   {
593     const SMESH::Controls::MultiConnection2D::Value&  aVal = (*anIter).first;
594     SMESH::MultiConnection2D::Value &aValue = aResult[ i ];
595
596     aValue.myPnt1 = aVal.myPntId[ 0 ];
597     aValue.myPnt2 = aVal.myPntId[ 1 ];
598     aValue.myNbConnects = (*anIter).second;
599   }
600
601   return aResult._retn();
602 }
603
604 /*
605                             PREDICATES
606 */
607
608
609 /*
610   Class       : Predicate_i
611   Description : Base class for all predicates
612 */
613 CORBA::Boolean Predicate_i::IsSatisfy( CORBA::Long theId )
614 {
615   return myPredicatePtr->IsSatisfy( theId );
616 }
617
618 CORBA::Long Predicate_i::NbSatisfying( SMESH::SMESH_IDSource_ptr obj )
619 {
620   SMESH::SMESH_Mesh_var meshVar = obj->GetMesh();
621   const SMDS_Mesh*       meshDS = MeshPtr2SMDSMesh( meshVar );
622   if ( !meshDS )
623     return 0;
624   myPredicatePtr->SetMesh( meshDS );
625
626   SMDSAbs_ElementType elemType = SMDSAbs_ElementType( GetElementType() );
627
628   int nb = 0;
629   SMDS_ElemIteratorPtr elemIt =
630     SMESH::DownCast<SMESH_Mesh_i*>( meshVar )->GetElements( obj, GetElementType() );
631   if ( elemIt )
632     while ( elemIt->more() )
633     {
634       const SMDS_MeshElement* e = elemIt->next();
635       if ( e && e->GetType() == elemType )
636         nb += myPredicatePtr->IsSatisfy( e->GetID() );
637     }
638   return nb;
639 }
640
641 Controls::PredicatePtr Predicate_i::GetPredicate()
642 {
643   return myPredicatePtr;
644 }
645
646 /*
647   Class       : BadOrientedVolume_i
648   Description : Verify whether a mesh volume is incorrectly oriented from
649                 the point of view of MED convention
650 */
651 BadOrientedVolume_i::BadOrientedVolume_i()
652 {
653   Controls::PredicatePtr control( new Controls::BadOrientedVolume() );
654   myFunctorPtr = myPredicatePtr = control;
655 };
656
657 FunctorType BadOrientedVolume_i::GetFunctorType()
658 {
659   return SMESH::FT_BadOrientedVolume;
660 }
661
662 /*
663   Class       : BareBorderVolume_i
664   Description : Verify whether a mesh volume has a free facet without a face on it
665 */
666 BareBorderVolume_i::BareBorderVolume_i()
667 {
668   Controls::PredicatePtr control( new Controls::BareBorderVolume() );
669   myFunctorPtr = myPredicatePtr = control;
670 };
671
672 FunctorType BareBorderVolume_i::GetFunctorType()
673 {
674   return SMESH::FT_BareBorderVolume;
675 }
676
677 /*
678   Class       : BareBorderFace_i
679   Description : Verify whether a mesh face has a free border without an edge on it
680 */
681 BareBorderFace_i::BareBorderFace_i()
682 {
683   Controls::PredicatePtr control( new Controls::BareBorderFace() );
684   myFunctorPtr = myPredicatePtr = control;
685 };
686
687 FunctorType BareBorderFace_i::GetFunctorType()
688 {
689   return SMESH::FT_BareBorderFace;
690 }
691
692 /*
693   Class       : OverConstrainedVolume_i
694   Description : Verify whether a mesh volume has only one facet shared with other volumes
695 */
696 OverConstrainedVolume_i::OverConstrainedVolume_i()
697 {
698   Controls::PredicatePtr control( new Controls::OverConstrainedVolume() );
699   myFunctorPtr = myPredicatePtr = control;
700 };
701
702 FunctorType OverConstrainedVolume_i::GetFunctorType()
703 {
704   return SMESH::FT_OverConstrainedVolume;
705 }
706
707 /*
708   Class       : OverConstrainedFace_i
709   Description : Verify whether a mesh face has only one border shared with other faces
710 */
711 OverConstrainedFace_i::OverConstrainedFace_i()
712 {
713   Controls::PredicatePtr control( new Controls::OverConstrainedFace() );
714   myFunctorPtr = myPredicatePtr = control;
715 };
716
717 FunctorType OverConstrainedFace_i::GetFunctorType()
718 {
719   return SMESH::FT_OverConstrainedFace;
720 }
721
722 /*
723   Class       : BelongToMeshGroup_i
724   Description : Verify whether a mesh element is included into a mesh group
725 */
726 BelongToMeshGroup_i::BelongToMeshGroup_i()
727 {
728   myBelongToMeshGroup = Controls::BelongToMeshGroupPtr( new Controls::BelongToMeshGroup() );
729   myFunctorPtr = myPredicatePtr = myBelongToMeshGroup;
730 }
731
732 BelongToMeshGroup_i::~BelongToMeshGroup_i()
733 {
734   SetGroup( SMESH::SMESH_GroupBase::_nil() );
735 }
736
737 void BelongToMeshGroup_i::SetGroup( SMESH::SMESH_GroupBase_ptr theGroup )
738 {
739   if ( myGroup->_is_equivalent( theGroup ))
740     return;
741
742   if ( ! myGroup->_is_nil() )
743     myGroup->UnRegister();
744
745   myGroup = SMESH_GroupBase::_duplicate( theGroup );
746
747   myBelongToMeshGroup->SetGroup( 0 );
748   if ( SMESH_GroupBase_i* gr_i = SMESH::DownCast< SMESH_GroupBase_i* >( myGroup ))
749   {
750     myBelongToMeshGroup->SetGroup( gr_i->GetGroupDS() );
751     myGroup->Register();
752   }
753 }
754
755 void BelongToMeshGroup_i::SetGroupID( const char* theID ) // IOR or StoreName
756 {
757   myID = theID;
758   if ( strncmp( "IOR:", myID.c_str(), 4 ) == 0 ) // transient mode, no GUI
759   {
760     CORBA::Object_var obj = SMESH_Gen_i::GetORB()->string_to_object( myID.c_str() );
761     SetGroup( SMESH::SMESH_GroupBase::_narrow( obj ));
762   }
763   else if ( strncmp( "0:", myID.c_str(), 2 ) == 0 ) // transient mode + GUI
764   {
765     SMESH_Gen_i* aSMESHGen     = SMESH_Gen_i::GetSMESHGen();
766     SALOMEDS::Study_var aStudy = aSMESHGen->GetCurrentStudy();
767     if ( !aStudy->_is_nil() ) {
768       SALOMEDS::SObject_wrap aSObj = aStudy->FindObjectID( myID.c_str() );
769       if ( !aSObj->_is_nil() ) {
770         CORBA::Object_var obj = aSObj->GetObject();
771         SetGroup( SMESH::SMESH_GroupBase::_narrow( obj ));
772       }
773     }
774   }
775   else if ( !myID.empty() ) // persistent mode
776   {
777     myBelongToMeshGroup->SetStoreName( myID );
778   }
779 }
780
781 std::string BelongToMeshGroup_i::GetGroupID()
782 {
783   if ( myGroup->_is_nil() )
784     SMESH::SMESH_GroupBase_var( GetGroup() );
785
786   if ( !myGroup->_is_nil() )
787     myID = SMESH_Gen_i::GetORB()->object_to_string( myGroup );
788
789   return myID;
790 }
791
792 SMESH::SMESH_GroupBase_ptr BelongToMeshGroup_i::GetGroup()
793 {
794   if ( myGroup->_is_nil() && myBelongToMeshGroup->GetGroup() )
795   {
796     // search for a group in a current study
797     SMESH_Gen_i* aSMESHGen = SMESH_Gen_i::GetSMESHGen();
798     if ( StudyContext*  sc = aSMESHGen->GetCurrentStudyContext() )
799     {
800       int id = 1;
801       std::string ior;
802       while (true)
803       {
804         ior = sc->getIORbyId( id++ );
805         if ( ior.empty() ) break;
806         CORBA::Object_var obj = aSMESHGen->GetORB()->string_to_object( ior.c_str() );
807         if ( SMESH_GroupBase_i* g_i = SMESH::DownCast<SMESH_GroupBase_i*>( obj ))
808           if ( g_i->GetGroupDS() == myBelongToMeshGroup->GetGroup() )
809           {
810             SetGroup( g_i->_this() );
811             break;
812           }
813       }
814     }
815   }
816   return SMESH::SMESH_GroupBase::_duplicate( myGroup );
817 }
818
819 FunctorType BelongToMeshGroup_i::GetFunctorType()
820 {
821   return SMESH::FT_BelongToMeshGroup;
822 }
823
824 /*
825   Class       : BelongToGeom_i
826   Description : Predicate for selection on geometrical support
827 */
828 BelongToGeom_i::BelongToGeom_i()
829 {
830   myBelongToGeomPtr.reset( new Controls::BelongToGeom() );
831   myFunctorPtr = myPredicatePtr = myBelongToGeomPtr;
832   myShapeName = 0;
833   myShapeID   = 0;
834 }
835
836 BelongToGeom_i::~BelongToGeom_i()
837 {
838   CORBA::string_free( myShapeName );
839   CORBA::string_free( myShapeID );
840 }
841
842 void BelongToGeom_i::SetGeom( GEOM::GEOM_Object_ptr theGeom )
843 {
844   if ( theGeom->_is_nil() )
845     return;
846   SMESH_Gen_i* aSMESHGen = SMESH_Gen_i::GetSMESHGen();
847   GEOM::GEOM_Gen_ptr aGEOMGen = SMESH_Gen_i::GetGeomEngine();
848   TopoDS_Shape aLocShape = aSMESHGen->GetShapeReader()->GetShape( aGEOMGen, theGeom );
849   myBelongToGeomPtr->SetGeom( aLocShape );
850   TPythonDump()<<this<<".SetGeom("<<theGeom<<")";
851 }
852
853 void BelongToGeom_i::SetGeom( const TopoDS_Shape& theShape )
854 {
855   myBelongToGeomPtr->SetGeom( theShape );
856 }
857
858 void BelongToGeom_i::SetElementType(ElementType theType)
859 {
860   myBelongToGeomPtr->SetType(SMDSAbs_ElementType(theType));
861   TPythonDump()<<this<<".SetElementType("<<theType<<")";
862 }
863
864 FunctorType BelongToGeom_i::GetFunctorType()
865 {
866   return SMESH::FT_BelongToGeom;
867 }
868
869 void BelongToGeom_i::SetShapeName( const char* theName )
870 {
871   CORBA::string_free( myShapeName );
872   myShapeName = CORBA::string_dup( theName );
873   myBelongToGeomPtr->SetGeom( getShapeByName( myShapeName ) );
874   TPythonDump()<<this<<".SetShapeName('"<<theName<<"')";
875 }
876
877 void BelongToGeom_i::SetShape( const char* theID, const char* theName )
878 {
879   CORBA::string_free( myShapeName );
880   CORBA::string_free( myShapeID );
881   myShapeName = CORBA::string_dup( theName );
882   myShapeID   = CORBA::string_dup( theID );
883   bool hasName = ( theName && theName[0] );
884   bool hasID   = ( theID   && theID[0] );
885
886   TopoDS_Shape S;
887   if ( hasName && hasID )
888   {
889     S = getShapeByID( myShapeID );
890     if ( S.IsNull() )
891       S = getShapeByName( myShapeName );
892   }
893   else
894   {
895     S = hasID ? getShapeByID( myShapeID ) : getShapeByName( myShapeName );
896   }
897   myBelongToGeomPtr->SetGeom( S );
898 }
899
900 char* BelongToGeom_i::GetShapeName()
901 {
902   return CORBA::string_dup( myShapeName );
903 }
904
905 char* BelongToGeom_i::GetShapeID()
906 {
907   return CORBA::string_dup( myShapeID );
908 }
909
910 void BelongToGeom_i::SetTolerance( CORBA::Double theToler )
911 {
912   myBelongToGeomPtr->SetTolerance( theToler );
913   TPythonDump()<<this<<".SetTolerance("<<theToler<<")";
914 }
915
916 CORBA::Double BelongToGeom_i::GetTolerance()
917 {
918   return myBelongToGeomPtr->GetTolerance();
919 }
920
921 /*
922   Class       : BelongToSurface_i
923   Description : Predicate for selection on geometrical support
924 */
925 BelongToSurface_i::BelongToSurface_i( const Handle(Standard_Type)& theSurfaceType )
926 {
927   myElementsOnSurfacePtr.reset( new Controls::ElementsOnSurface() );
928   myFunctorPtr = myPredicatePtr = myElementsOnSurfacePtr;
929   myShapeName = 0;
930   myShapeID   = 0;
931   mySurfaceType = theSurfaceType;
932 }
933
934 BelongToSurface_i::~BelongToSurface_i()
935 {
936   CORBA::string_free( myShapeName );
937   CORBA::string_free( myShapeID );
938 }
939
940 void BelongToSurface_i::SetSurface( GEOM::GEOM_Object_ptr theGeom, ElementType theType )
941 {
942   if ( theGeom->_is_nil() )
943     return;
944   SMESH_Gen_i* aSMESHGen = SMESH_Gen_i::GetSMESHGen();
945   GEOM::GEOM_Gen_ptr aGEOMGen = SMESH_Gen_i::GetGeomEngine();
946   TopoDS_Shape aLocShape = aSMESHGen->GetShapeReader()->GetShape( aGEOMGen, theGeom );
947
948   if ( aLocShape.ShapeType() == TopAbs_FACE )
949   {
950     Handle(Geom_Surface) aSurf = BRep_Tool::Surface( TopoDS::Face( aLocShape ) );
951     if ( !aSurf.IsNull() && aSurf->DynamicType() == mySurfaceType )
952     {
953       myElementsOnSurfacePtr->SetSurface( aLocShape, (SMDSAbs_ElementType)theType );
954       return;
955     }
956   }
957
958   myElementsOnSurfacePtr->SetSurface( TopoDS_Shape(), (SMDSAbs_ElementType)theType );
959 }
960
961 void BelongToSurface_i::SetShapeName( const char* theName, ElementType theType )
962 {
963   CORBA::string_free( myShapeName );
964   myShapeName = CORBA::string_dup( theName );
965   myElementsOnSurfacePtr->SetSurface( getShapeByName( myShapeName ), (SMDSAbs_ElementType)theType );
966   TPythonDump()<<this<<".SetShapeName('"<<theName<<"',"<<theType<<")";
967 }
968
969 void BelongToSurface_i::SetShape( const char* theID,  const char* theName, ElementType theType )
970 {
971   CORBA::string_free( myShapeName );
972   CORBA::string_free( myShapeID );
973   myShapeName = CORBA::string_dup( theName );
974   myShapeID   = CORBA::string_dup( theID );
975   bool hasName = ( theName && theName[0] );
976   bool hasID   = ( theID   && theID[0] );
977
978   TopoDS_Shape S;
979   if ( hasName && hasID )
980   {
981     S = getShapeByID( myShapeID );
982     if ( S.IsNull() )
983       S = getShapeByName( myShapeName );
984   }
985   else
986   {
987     S = hasID ? getShapeByID( myShapeID ) : getShapeByName( myShapeName );
988   }
989   myElementsOnSurfacePtr->SetSurface( S, (SMDSAbs_ElementType)theType );
990 }
991
992 char* BelongToSurface_i::GetShapeName()
993 {
994   return CORBA::string_dup( myShapeName );
995 }
996
997 char* BelongToSurface_i::GetShapeID()
998 {
999   return CORBA::string_dup( myShapeID );
1000 }
1001
1002 void BelongToSurface_i::SetTolerance( CORBA::Double theToler )
1003 {
1004   myElementsOnSurfacePtr->SetTolerance( theToler );
1005   TPythonDump()<<this<<".SetTolerance("<<theToler<<")";
1006 }
1007
1008 CORBA::Double BelongToSurface_i::GetTolerance()
1009 {
1010   return myElementsOnSurfacePtr->GetTolerance();
1011 }
1012
1013 void BelongToSurface_i::SetUseBoundaries( CORBA::Boolean theUseBndRestrictions )
1014 {
1015   myElementsOnSurfacePtr->SetUseBoundaries( theUseBndRestrictions );
1016   TPythonDump()<<this<<".SetUseBoundaries( " << theUseBndRestrictions << " )";
1017 }
1018
1019 CORBA::Boolean BelongToSurface_i::GetUseBoundaries()
1020 {
1021   return myElementsOnSurfacePtr->GetUseBoundaries();
1022 }
1023
1024
1025 /*
1026   Class       : BelongToPlane_i
1027   Description : Verify whether mesh element lie in pointed Geom planar object
1028 */
1029
1030 BelongToPlane_i::BelongToPlane_i()
1031 : BelongToSurface_i( STANDARD_TYPE( Geom_Plane ) )
1032 {
1033 }
1034
1035 void BelongToPlane_i::SetPlane( GEOM::GEOM_Object_ptr theGeom, ElementType theType )
1036 {
1037   BelongToSurface_i::SetSurface( theGeom, theType );
1038   TPythonDump()<<this<<".SetPlane("<<theGeom<<","<<theType<<")";
1039 }
1040
1041 FunctorType BelongToPlane_i::GetFunctorType()
1042 {
1043   return FT_BelongToPlane;
1044 }
1045
1046 /*
1047   Class       : BelongToCylinder_i
1048   Description : Verify whether mesh element lie in pointed Geom planar object
1049 */
1050
1051 BelongToCylinder_i::BelongToCylinder_i()
1052 : BelongToSurface_i( STANDARD_TYPE( Geom_CylindricalSurface ) )
1053 {
1054 }
1055
1056 void BelongToCylinder_i::SetCylinder( GEOM::GEOM_Object_ptr theGeom, ElementType theType )
1057 {
1058   BelongToSurface_i::SetSurface( theGeom, theType );
1059   TPythonDump()<<this<<".SetCylinder("<<theGeom<<","<<theType<<")";
1060 }
1061
1062 FunctorType BelongToCylinder_i::GetFunctorType()
1063 {
1064   return FT_BelongToCylinder;
1065 }
1066
1067 /*
1068   Class       : BelongToGenSurface_i
1069   Description : Verify whether mesh element lie in pointed Geom planar object
1070 */
1071
1072 BelongToGenSurface_i::BelongToGenSurface_i()
1073 : BelongToSurface_i( STANDARD_TYPE( Geom_CylindricalSurface ) )
1074 {
1075 }
1076
1077 void BelongToGenSurface_i::SetSurface( GEOM::GEOM_Object_ptr theGeom, ElementType theType )
1078 {
1079   if ( theGeom->_is_nil() )
1080     return;
1081   TopoDS_Shape aLocShape = SMESH_Gen_i::GetSMESHGen()->GeomObjectToShape( theGeom );
1082   if ( !aLocShape.IsNull() && aLocShape.ShapeType() != TopAbs_FACE )
1083     aLocShape.Nullify();
1084   
1085   BelongToSurface_i::myElementsOnSurfacePtr->SetSurface( aLocShape, (SMDSAbs_ElementType)theType );
1086   TPythonDump()<<this<<".SetGenSurface("<<theGeom<<","<<theType<<")";
1087 }
1088
1089 FunctorType BelongToGenSurface_i::GetFunctorType()
1090 {
1091   return FT_BelongToGenSurface;
1092 }
1093
1094 /*
1095   Class       : LyingOnGeom_i
1096   Description : Predicate for selection on geometrical support
1097 */
1098 LyingOnGeom_i::LyingOnGeom_i()
1099 {
1100   myLyingOnGeomPtr.reset( new Controls::LyingOnGeom() );
1101   myFunctorPtr = myPredicatePtr = myLyingOnGeomPtr;
1102   myShapeName = 0;
1103   myShapeID = 0;
1104 }
1105
1106 LyingOnGeom_i::~LyingOnGeom_i()
1107 {
1108   CORBA::string_free( myShapeName );
1109   CORBA::string_free( myShapeID );
1110 }
1111
1112 void LyingOnGeom_i::SetGeom( GEOM::GEOM_Object_ptr theGeom )
1113 {
1114   if ( theGeom->_is_nil() )
1115     return;
1116   SMESH_Gen_i* aSMESHGen = SMESH_Gen_i::GetSMESHGen();
1117   GEOM::GEOM_Gen_ptr aGEOMGen = SMESH_Gen_i::GetGeomEngine();
1118   TopoDS_Shape aLocShape = aSMESHGen->GetShapeReader()->GetShape( aGEOMGen, theGeom );
1119   myLyingOnGeomPtr->SetGeom( aLocShape );
1120   TPythonDump()<<this<<".SetGeom("<<theGeom<<")";
1121 }
1122
1123 void LyingOnGeom_i::SetGeom( const TopoDS_Shape& theShape )
1124 {
1125   myLyingOnGeomPtr->SetGeom( theShape );
1126 }
1127
1128 void LyingOnGeom_i::SetElementType(ElementType theType){
1129   myLyingOnGeomPtr->SetType(SMDSAbs_ElementType(theType));
1130   TPythonDump()<<this<<".SetElementType("<<theType<<")";
1131 }
1132
1133 FunctorType LyingOnGeom_i::GetFunctorType()
1134 {
1135   return SMESH::FT_LyingOnGeom;
1136 }
1137
1138 void LyingOnGeom_i::SetShapeName( const char* theName )
1139 {
1140   CORBA::string_free( myShapeName );
1141   myShapeName = CORBA::string_dup( theName );
1142   myLyingOnGeomPtr->SetGeom( getShapeByName( myShapeName ) );
1143   TPythonDump()<<this<<".SetShapeName('"<<theName<<"')";
1144 }
1145
1146 void LyingOnGeom_i::SetShape( const char* theID, const char* theName )
1147 {
1148   CORBA::string_free( myShapeName );
1149   CORBA::string_free( myShapeID   );
1150   myShapeName = CORBA::string_dup( theName );
1151   myShapeID   = CORBA::string_dup( theID   );
1152   bool hasName = ( theName && theName[0] );
1153   bool hasID   = ( theID   && theID[0]   );
1154
1155   TopoDS_Shape S;
1156   if ( hasName && hasID )
1157   {
1158     S = getShapeByID( myShapeID );
1159     if ( S.IsNull() )
1160       S = getShapeByName( myShapeName );
1161   }
1162   else
1163   {
1164     S = hasID ? getShapeByID( myShapeID ) : getShapeByName( myShapeName );
1165   }
1166   myLyingOnGeomPtr->SetGeom( S );
1167 }
1168
1169 char* LyingOnGeom_i::GetShapeName()
1170 {
1171   return CORBA::string_dup( myShapeName );
1172 }
1173
1174 char* LyingOnGeom_i::GetShapeID()
1175 {
1176   return CORBA::string_dup( myShapeID );
1177 }
1178
1179 void LyingOnGeom_i::SetTolerance( CORBA::Double theToler )
1180 {
1181   myLyingOnGeomPtr->SetTolerance( theToler );
1182   TPythonDump()<<this<<".SetTolerance("<<theToler<<")";
1183 }
1184
1185 CORBA::Double LyingOnGeom_i::GetTolerance()
1186 {
1187   return myLyingOnGeomPtr->GetTolerance();
1188 }
1189
1190 /*
1191   Class       : FreeBorders_i
1192   Description : Predicate for free borders
1193 */
1194 FreeBorders_i::FreeBorders_i()
1195 {
1196   myPredicatePtr.reset(new Controls::FreeBorders());
1197   myFunctorPtr = myPredicatePtr;
1198 }
1199
1200 FunctorType FreeBorders_i::GetFunctorType()
1201 {
1202   return SMESH::FT_FreeBorders;
1203 }
1204
1205 /*
1206   Class       : FreeEdges_i
1207   Description : Predicate for free borders
1208 */
1209 FreeEdges_i::FreeEdges_i()
1210 : myFreeEdgesPtr( new Controls::FreeEdges() )
1211 {
1212   myFunctorPtr = myPredicatePtr = myFreeEdgesPtr;
1213 }
1214
1215 SMESH::FreeEdges::Borders* FreeEdges_i::GetBorders()
1216 {
1217   SMESH::Controls::FreeEdges::TBorders aBorders;
1218   myFreeEdgesPtr->GetBoreders( aBorders );
1219
1220   long i = 0, iEnd = aBorders.size();
1221
1222   SMESH::FreeEdges::Borders_var aResult = new SMESH::FreeEdges::Borders;
1223   aResult->length(iEnd);
1224
1225   SMESH::Controls::FreeEdges::TBorders::const_iterator anIter;
1226   for ( anIter = aBorders.begin() ; anIter != aBorders.end(); anIter++, i++ )
1227   {
1228     const SMESH::Controls::FreeEdges::Border&  aBord = *anIter;
1229     SMESH::FreeEdges::Border &aBorder = aResult[ i ];
1230
1231     aBorder.myElemId = aBord.myElemId;
1232     aBorder.myPnt1 = aBord.myPntId[ 0 ];
1233     aBorder.myPnt2 = aBord.myPntId[ 1 ];
1234   }
1235   return aResult._retn();
1236 }
1237
1238 FunctorType FreeEdges_i::GetFunctorType()
1239 {
1240   return SMESH::FT_FreeEdges;
1241 }
1242
1243 /*
1244   Class       : FreeFaces_i
1245   Description : Predicate for free faces
1246 */
1247 FreeFaces_i::FreeFaces_i()
1248 {
1249   myPredicatePtr.reset(new Controls::FreeFaces());
1250   myFunctorPtr = myPredicatePtr;
1251 }
1252
1253 FunctorType FreeFaces_i::GetFunctorType()
1254 {
1255   return SMESH::FT_FreeFaces;
1256 }
1257
1258 /*
1259   Class       : FreeNodes_i
1260   Description : Predicate for free nodes
1261 */
1262 FreeNodes_i::FreeNodes_i()
1263 {
1264   myPredicatePtr.reset(new Controls::FreeNodes());
1265   myFunctorPtr = myPredicatePtr;
1266 }
1267
1268 FunctorType FreeNodes_i::GetFunctorType()
1269 {
1270   return SMESH::FT_FreeNodes;
1271 }
1272
1273 /*
1274   Class       : EqualNodes_i
1275   Description : Predicate for Equal nodes
1276 */
1277 EqualNodes_i::EqualNodes_i()
1278 {
1279   myCoincidentNodesPtr.reset(new Controls::CoincidentNodes());
1280   myFunctorPtr = myPredicatePtr = myCoincidentNodesPtr;
1281 }
1282
1283 FunctorType EqualNodes_i::GetFunctorType()
1284 {
1285   return SMESH::FT_EqualNodes;
1286 }
1287
1288 void EqualNodes_i::SetTolerance( double tol )
1289 {
1290   myCoincidentNodesPtr->SetTolerance( tol );
1291 }
1292
1293 double EqualNodes_i::GetTolerance()
1294 {
1295   return myCoincidentNodesPtr->GetTolerance();
1296 }
1297
1298 /*
1299   Class       : EqualEdges_i
1300   Description : Predicate for Equal Edges
1301 */
1302 EqualEdges_i::EqualEdges_i()
1303 {
1304   myPredicatePtr.reset(new Controls::CoincidentElements1D());
1305   myFunctorPtr = myPredicatePtr;
1306 }
1307
1308 FunctorType EqualEdges_i::GetFunctorType()
1309 {
1310   return SMESH::FT_EqualEdges;
1311 }
1312
1313 /*
1314   Class       : EqualFaces_i
1315   Description : Predicate for Equal Faces
1316 */
1317 EqualFaces_i::EqualFaces_i()
1318 {
1319   myPredicatePtr.reset(new Controls::CoincidentElements2D());
1320   myFunctorPtr = myPredicatePtr;
1321 }
1322
1323 FunctorType EqualFaces_i::GetFunctorType()
1324 {
1325   return SMESH::FT_EqualFaces;
1326 }
1327
1328 /*
1329   Class       : EqualVolumes_i
1330   Description : Predicate for Equal Volumes
1331 */
1332 EqualVolumes_i::EqualVolumes_i()
1333 {
1334   myPredicatePtr.reset(new Controls::CoincidentElements3D());
1335   myFunctorPtr = myPredicatePtr;
1336 }
1337
1338 FunctorType EqualVolumes_i::GetFunctorType()
1339 {
1340   return SMESH::FT_EqualVolumes;
1341 }
1342
1343
1344 /*
1345   Class       : RangeOfIds_i
1346   Description : Predicate for Range of Ids.
1347                 Range may be specified with two ways.
1348                 1. Using AddToRange method
1349                 2. With SetRangeStr method. Parameter of this method is a string
1350                    like as "1,2,3,50-60,63,67,70-"
1351 */
1352
1353 RangeOfIds_i::RangeOfIds_i()
1354 {
1355   myRangeOfIdsPtr.reset( new Controls::RangeOfIds() );
1356   myFunctorPtr = myPredicatePtr = myRangeOfIdsPtr;
1357 }
1358
1359 void RangeOfIds_i::SetRange( const SMESH::long_array& theIds )
1360 {
1361   CORBA::Long iEnd = theIds.length();
1362   for ( CORBA::Long i = 0; i < iEnd; i++ )
1363     myRangeOfIdsPtr->AddToRange( theIds[ i ] );
1364   TPythonDump()<<this<<".SetRange("<<theIds<<")";
1365 }
1366
1367 CORBA::Boolean RangeOfIds_i::SetRangeStr( const char* theRange )
1368 {
1369   TPythonDump()<<this<<".SetRangeStr('"<<theRange<<"')";
1370   return myRangeOfIdsPtr->SetRangeStr(
1371     TCollection_AsciiString( (Standard_CString)theRange ) );
1372 }
1373
1374 char* RangeOfIds_i::GetRangeStr()
1375 {
1376   TCollection_AsciiString aStr;
1377   myRangeOfIdsPtr->GetRangeStr( aStr );
1378   return CORBA::string_dup( aStr.ToCString() );
1379 }
1380
1381 void RangeOfIds_i::SetElementType( ElementType theType )
1382 {
1383   myRangeOfIdsPtr->SetType( SMDSAbs_ElementType( theType ) );
1384   TPythonDump()<<this<<".SetElementType("<<theType<<")";
1385 }
1386
1387 FunctorType RangeOfIds_i::GetFunctorType()
1388 {
1389   return SMESH::FT_RangeOfIds;
1390 }
1391
1392 /*
1393   Class       : LinearOrQuadratic_i
1394   Description : Predicate to verify whether a mesh element is linear
1395 */
1396 LinearOrQuadratic_i::LinearOrQuadratic_i()
1397 {
1398   myLinearOrQuadraticPtr.reset(new Controls::LinearOrQuadratic());
1399   myFunctorPtr = myPredicatePtr = myLinearOrQuadraticPtr;
1400 }
1401
1402 void LinearOrQuadratic_i::SetElementType(ElementType theType)
1403 {
1404   myLinearOrQuadraticPtr->SetType(SMDSAbs_ElementType(theType));
1405   TPythonDump()<<this<<".SetElementType("<<theType<<")";
1406 }
1407
1408 FunctorType LinearOrQuadratic_i::GetFunctorType()
1409 {
1410   return SMESH::FT_LinearOrQuadratic;
1411 }
1412
1413 /*
1414   Class       : GroupColor_i
1415   Description : Functor for check color of group to whic mesh element belongs to
1416 */
1417 GroupColor_i::GroupColor_i()
1418 {
1419   myGroupColorPtr.reset(new Controls::GroupColor());
1420   myFunctorPtr = myPredicatePtr = myGroupColorPtr;
1421 }
1422
1423 FunctorType GroupColor_i::GetFunctorType()
1424 {
1425   return SMESH::FT_GroupColor;
1426 }
1427
1428 void GroupColor_i::SetColorStr( const char* theColor )
1429 {
1430   myGroupColorPtr->SetColorStr(
1431     TCollection_AsciiString( (Standard_CString)theColor ) );
1432   TPythonDump()<<this<<".SetColorStr('"<<theColor<<"')";
1433 }
1434
1435 char* GroupColor_i::GetColorStr()
1436 {
1437   TCollection_AsciiString aStr;
1438   myGroupColorPtr->GetColorStr( aStr );
1439   return CORBA::string_dup( aStr.ToCString() );
1440 }
1441
1442 void GroupColor_i::SetElementType(ElementType theType)
1443 {
1444   myGroupColorPtr->SetType(SMDSAbs_ElementType(theType));
1445   TPythonDump()<<this<<".SetElementType("<<theType<<")";
1446 }
1447
1448 /*
1449   Class       : ElemGeomType_i
1450   Description : Predicate check is element has indicated geometry type
1451 */
1452 ElemGeomType_i::ElemGeomType_i()
1453 {
1454   myElemGeomTypePtr.reset(new Controls::ElemGeomType());
1455   myFunctorPtr = myPredicatePtr = myElemGeomTypePtr;
1456 }
1457
1458 void ElemGeomType_i::SetElementType(ElementType theType)
1459 {
1460   myElemGeomTypePtr->SetType(SMDSAbs_ElementType(theType));
1461   TPythonDump()<<this<<".SetElementType("<<theType<<")";
1462 }
1463
1464 void ElemGeomType_i::SetGeometryType(GeometryType theType)
1465 {
1466   myElemGeomTypePtr->SetGeomType(SMDSAbs_GeometryType(theType));
1467   TPythonDump()<<this<<".SetGeometryType("<<theType<<")";
1468 }
1469
1470 GeometryType ElemGeomType_i::GetGeometryType() const
1471 {
1472   return (GeometryType)myElemGeomTypePtr->GetGeomType();
1473 }
1474
1475 FunctorType ElemGeomType_i::GetFunctorType()
1476 {
1477   return SMESH::FT_ElemGeomType;
1478 }
1479
1480 /*
1481   Class       : ElemEntityType_i
1482   Description : Predicate check is element has indicated entity type
1483 */
1484 ElemEntityType_i::ElemEntityType_i()
1485 {
1486   myElemEntityTypePtr.reset(new Controls::ElemEntityType());
1487   myFunctorPtr = myPredicatePtr = myElemEntityTypePtr;
1488 }
1489
1490 void ElemEntityType_i::SetElementType(ElementType theType)
1491 {
1492   myElemEntityTypePtr->SetType(SMDSAbs_ElementType(theType));
1493   TPythonDump()<<this<<".SetElementType("<<theType<<")";
1494 }
1495
1496 void ElemEntityType_i::SetEntityType(EntityType theEntityType)
1497 {
1498   myElemEntityTypePtr->SetElemEntityType(SMDSAbs_EntityType (theEntityType));
1499   TPythonDump()<<this<<".SetEntityType("<<theEntityType<<")";
1500 }
1501 EntityType ElemEntityType_i::GetEntityType() const
1502 {
1503  return (EntityType) myElemEntityTypePtr->GetElemEntityType();
1504 }
1505
1506 FunctorType ElemEntityType_i::GetFunctorType()
1507 {
1508   return SMESH::FT_EntityType;
1509 }
1510
1511 /*
1512   Class       : CoplanarFaces_i
1513   Description : Returns true if a mesh face is a coplanar neighbour to a given one
1514 */
1515 CoplanarFaces_i::CoplanarFaces_i()
1516 {
1517   myCoplanarFacesPtr.reset(new Controls::CoplanarFaces());
1518   myFunctorPtr = myPredicatePtr = myCoplanarFacesPtr;
1519 }
1520
1521 void CoplanarFaces_i::SetFace ( CORBA::Long theFaceID )
1522 {
1523   myCoplanarFacesPtr->SetFace(theFaceID);
1524   TPythonDump()<<this<<".SetFace("<<theFaceID<<")";
1525 }
1526
1527 void CoplanarFaces_i::SetTolerance( CORBA::Double theToler )
1528 {
1529   myCoplanarFacesPtr->SetTolerance(theToler);
1530   TPythonDump()<<this<<".SetTolerance("<<theToler<<")";
1531 }
1532
1533 CORBA::Long CoplanarFaces_i::GetFace () const
1534 {
1535   return myCoplanarFacesPtr->GetFace();
1536 }
1537
1538 char* CoplanarFaces_i::GetFaceAsString () const
1539 {
1540   TCollection_AsciiString str(Standard_Integer(myCoplanarFacesPtr->GetFace()));
1541   return CORBA::string_dup( str.ToCString() );
1542 }
1543
1544 CORBA::Double CoplanarFaces_i::GetTolerance() const
1545 {
1546   return myCoplanarFacesPtr->GetTolerance();
1547 }
1548
1549 FunctorType CoplanarFaces_i::GetFunctorType()
1550 {
1551   return SMESH::FT_CoplanarFaces;
1552 }
1553
1554 /*
1555  * Class       : ConnectedElements_i
1556  * Description : Returns true if an element is connected via other elements to the element
1557  *               located at a given point.
1558  */
1559 ConnectedElements_i::ConnectedElements_i()
1560 {
1561   myConnectedElementsPtr.reset(new Controls::ConnectedElements());
1562   myFunctorPtr = myPredicatePtr = myConnectedElementsPtr;
1563 }
1564
1565 FunctorType ConnectedElements_i::GetFunctorType()
1566 {
1567   return FT_ConnectedElements;
1568 }
1569
1570 void ConnectedElements_i::SetElementType( ElementType theType )
1571 {
1572   myConnectedElementsPtr->SetType( SMDSAbs_ElementType( theType ));
1573   TPythonDump() << this << ".SetElementType( " << theType << " )";
1574 }
1575
1576 void ConnectedElements_i::SetPoint( CORBA::Double x, CORBA::Double y, CORBA::Double z )
1577 {
1578   myConnectedElementsPtr->SetPoint( x,y,z );
1579   myVertexID.clear();
1580   TPythonDump() << this << ".SetPoint( " << x << ", " << y << ", " << z << " )";
1581 }
1582
1583 void ConnectedElements_i::SetVertex( GEOM::GEOM_Object_ptr vertex )
1584   throw (SALOME::SALOME_Exception)
1585 {
1586   TopoDS_Shape shape = SMESH_Gen_i::GetSMESHGen()->GeomObjectToShape( vertex );
1587   if ( shape.IsNull() )
1588     THROW_SALOME_CORBA_EXCEPTION( "ConnectedElements_i::SetVertex(): NULL Vertex",
1589                                   SALOME::BAD_PARAM );
1590
1591   TopExp_Explorer v( shape, TopAbs_VERTEX );
1592   if ( !v.More() )
1593     THROW_SALOME_CORBA_EXCEPTION( "ConnectedElements_i::SetVertex(): empty vertex",
1594                                   SALOME::BAD_PARAM );
1595
1596   gp_Pnt p = BRep_Tool::Pnt( TopoDS::Vertex( v.Current() ));
1597   myConnectedElementsPtr->SetPoint( p.X(), p.Y(), p.Z() );
1598   //
1599   CORBA::String_var id = vertex->GetStudyEntry();
1600   myVertexID = id.in();
1601
1602   TPythonDump() << this << ".SetVertex( " << vertex << " )";
1603 }
1604
1605 void ConnectedElements_i::SetNode ( CORBA::Long nodeID )
1606   throw (SALOME::SALOME_Exception)
1607 {
1608   if ( nodeID < 1 )
1609     THROW_SALOME_CORBA_EXCEPTION( "ConnectedElements_i::SetNode(): nodeID must be > 0",
1610                                   SALOME::BAD_PARAM );
1611
1612   myConnectedElementsPtr->SetNode( nodeID );
1613   myVertexID.clear();
1614   TPythonDump() << this << ".SetNode( " << nodeID << " )";
1615 }
1616
1617 /*!
1618  * \brief This is a comfort method for Filter dialog
1619  */
1620 void ConnectedElements_i::SetThreshold ( const char*                             threshold,
1621                                          SMESH::ConnectedElements::ThresholdType type )
1622   throw (SALOME::SALOME_Exception)
1623 {
1624   if ( !threshold )
1625     THROW_SALOME_CORBA_EXCEPTION( "ConnectedElements_i::SetThreshold(): NULL threshold",
1626                                   SALOME::BAD_PARAM );
1627   switch ( type )
1628   {
1629   case SMESH::ConnectedElements::POINT: // read 3 node coordinates ///////////////////
1630     {
1631       vector< double > xyz;
1632       char* endptr;
1633       do
1634       {
1635         // skip a separator
1636         while ( *threshold &&
1637                 *threshold != '+' &&
1638                 *threshold != '-' &&
1639                 !isdigit( *threshold ))
1640           ++threshold;
1641         if ( !*threshold )
1642           break;
1643         // read a coordinate
1644         xyz.push_back( strtod( threshold, &endptr ));
1645         if ( threshold == endptr )
1646         {
1647           xyz.resize( xyz.size() - 1 );
1648           break;
1649         }
1650         threshold = endptr;
1651       }
1652       while ( xyz.size() < 3 );
1653
1654       if ( xyz.size() < 3 )
1655         THROW_SALOME_CORBA_EXCEPTION
1656           ( "ConnectedElements_i::SetThreshold(): invalid point coordinates", SALOME::BAD_PARAM );
1657
1658       SetPoint( xyz[0], xyz[1], xyz[2] );
1659       break;
1660     }
1661   case SMESH::ConnectedElements::VERTEX: // get a VERTEX by its entry /////////////////
1662     {
1663       SALOMEDS::Study_var study = SMESH_Gen_i::GetSMESHGen()->GetCurrentStudy();
1664       if ( study->_is_nil() )
1665         THROW_SALOME_CORBA_EXCEPTION
1666           ( "ConnectedElements_i::SetThreshold(): NULL current study", SALOME::BAD_PARAM );
1667       SALOMEDS::SObject_wrap sobj = study->FindObjectID( threshold );
1668       if ( sobj->_is_nil() )
1669         THROW_SALOME_CORBA_EXCEPTION
1670           ( "ConnectedElements_i::SetThreshold(): invalid vertex study entry", SALOME::BAD_PARAM );
1671       CORBA::Object_var        obj = sobj->GetObject();
1672       GEOM::GEOM_Object_var vertex = GEOM::GEOM_Object::_narrow( obj );
1673       if ( vertex->_is_nil() )
1674         THROW_SALOME_CORBA_EXCEPTION
1675           ( "ConnectedElements_i::SetThreshold(): no GEOM_Object in SObject", SALOME::BAD_PARAM );
1676       SetVertex( vertex );
1677       break;
1678     }
1679   case SMESH::ConnectedElements::NODE: // read a node ID ////////////////////////////
1680     {
1681       char* endptr;
1682       int id = strtol( threshold, &endptr, 10 );
1683       if ( threshold == endptr )
1684         THROW_SALOME_CORBA_EXCEPTION
1685           ( "ConnectedElements_i::SetThreshold(): invalid node ID", SALOME::BAD_PARAM );
1686       SetNode( id );
1687       break;
1688     }
1689   default:
1690     THROW_SALOME_CORBA_EXCEPTION
1691       ( "ConnectedElements_i::SetThreshold(): invalid ThresholdType", SALOME::BAD_PARAM );
1692   }
1693 }
1694
1695 char* ConnectedElements_i::GetThreshold ( SMESH::ConnectedElements::ThresholdType& type )
1696 {
1697   std::string threshold;
1698   if ( !myVertexID.empty() )
1699   {
1700     threshold = myVertexID;
1701     type      = SMESH::ConnectedElements::VERTEX;
1702   }
1703   else
1704   {
1705     std::vector<double> xyz = myConnectedElementsPtr->GetPoint();
1706     if ( xyz.size() == 3 )
1707     {
1708       threshold = SMESH_Comment( xyz[0] ) << "; " << xyz[1] << "; " << xyz[2];
1709       type      = SMESH::ConnectedElements::POINT;
1710     }
1711     else
1712     {
1713       threshold = SMESH_Comment( myConnectedElementsPtr->GetNode() );
1714       type      = SMESH::ConnectedElements::NODE;
1715     }
1716   }
1717   return CORBA::string_dup( threshold.c_str() );
1718 }
1719
1720 /*
1721   Class       : Comparator_i
1722   Description : Base class for comparators
1723 */
1724 Comparator_i::Comparator_i():
1725   myNumericalFunctor( NULL )
1726 {}
1727
1728 Comparator_i::~Comparator_i()
1729 {
1730   if ( myNumericalFunctor )
1731     myNumericalFunctor->UnRegister();
1732 }
1733
1734 void Comparator_i::SetMargin( CORBA::Double theValue )
1735 {
1736   myComparatorPtr->SetMargin( theValue );
1737   TPythonDump()<<this<<".SetMargin("<<theValue<<")";
1738 }
1739
1740 CORBA::Double Comparator_i::GetMargin()
1741 {
1742   return myComparatorPtr->GetMargin();
1743 }
1744
1745 void Comparator_i::SetNumFunctor( NumericalFunctor_ptr theFunct )
1746 {
1747   if ( myNumericalFunctor )
1748     myNumericalFunctor->UnRegister();
1749
1750   myNumericalFunctor = DownCast<NumericalFunctor_i*>(theFunct);
1751
1752   if ( myNumericalFunctor )
1753   {
1754     myComparatorPtr->SetNumFunctor( myNumericalFunctor->GetNumericalFunctor() );
1755     myNumericalFunctor->Register();
1756     TPythonDump()<<this<<".SetNumFunctor("<<myNumericalFunctor<<")";
1757   }
1758 }
1759
1760 Controls::ComparatorPtr Comparator_i::GetComparator()
1761 {
1762   return myComparatorPtr;
1763 }
1764
1765 NumericalFunctor_i* Comparator_i::GetNumFunctor_i()
1766 {
1767   return myNumericalFunctor;
1768 }
1769
1770
1771 /*
1772   Class       : LessThan_i
1773   Description : Comparator "<"
1774 */
1775 LessThan_i::LessThan_i()
1776 {
1777   myComparatorPtr.reset( new Controls::LessThan() );
1778   myFunctorPtr = myPredicatePtr = myComparatorPtr;
1779 }
1780
1781 FunctorType LessThan_i::GetFunctorType()
1782 {
1783   return SMESH::FT_LessThan;
1784 }
1785
1786
1787 /*
1788   Class       : MoreThan_i
1789   Description : Comparator ">"
1790 */
1791 MoreThan_i::MoreThan_i()
1792 {
1793   myComparatorPtr.reset( new Controls::MoreThan() );
1794   myFunctorPtr = myPredicatePtr = myComparatorPtr;
1795 }
1796
1797 FunctorType MoreThan_i::GetFunctorType()
1798 {
1799   return SMESH::FT_MoreThan;
1800 }
1801
1802
1803 /*
1804   Class       : EqualTo_i
1805   Description : Comparator "="
1806 */
1807 EqualTo_i::EqualTo_i()
1808 : myEqualToPtr( new Controls::EqualTo() )
1809 {
1810   myFunctorPtr = myPredicatePtr = myComparatorPtr = myEqualToPtr;
1811 }
1812
1813 void EqualTo_i::SetTolerance( CORBA::Double theToler )
1814 {
1815   myEqualToPtr->SetTolerance( theToler );
1816   TPythonDump()<<this<<".SetTolerance("<<theToler<<")";
1817 }
1818
1819 CORBA::Double EqualTo_i::GetTolerance()
1820 {
1821   return myEqualToPtr->GetTolerance();
1822 }
1823
1824 FunctorType EqualTo_i::GetFunctorType()
1825 {
1826   return SMESH::FT_EqualTo;
1827 }
1828
1829 /*
1830   Class       : LogicalNOT_i
1831   Description : Logical NOT predicate
1832 */
1833 LogicalNOT_i::LogicalNOT_i()
1834 : myPredicate( NULL ),
1835   myLogicalNOTPtr( new Controls::LogicalNOT() )
1836 {
1837   myFunctorPtr = myPredicatePtr = myLogicalNOTPtr;
1838 }
1839
1840 LogicalNOT_i::~LogicalNOT_i()
1841 {
1842   if ( myPredicate )
1843     myPredicate->UnRegister();
1844 }
1845
1846 void LogicalNOT_i::SetPredicate( Predicate_ptr thePredicate )
1847 {
1848   if ( myPredicate )
1849     myPredicate->UnRegister();
1850
1851   myPredicate = SMESH::GetPredicate(thePredicate);
1852
1853   if ( myPredicate ){
1854     myLogicalNOTPtr->SetPredicate(myPredicate->GetPredicate());
1855     myPredicate->Register();
1856     TPythonDump()<<this<<".SetPredicate("<<myPredicate<<")";
1857   }
1858 }
1859
1860 FunctorType LogicalNOT_i::GetFunctorType()
1861 {
1862   return SMESH::FT_LogicalNOT;
1863 }
1864
1865 Predicate_i* LogicalNOT_i::GetPredicate_i()
1866 {
1867   return myPredicate;
1868 }
1869
1870
1871
1872 /*
1873   Class       : LogicalBinary_i
1874   Description : Base class for binary logical predicate
1875 */
1876 LogicalBinary_i::LogicalBinary_i()
1877 : myPredicate1( NULL ),
1878   myPredicate2( NULL )
1879 {}
1880
1881 LogicalBinary_i::~LogicalBinary_i()
1882 {
1883   if ( myPredicate1 )
1884     myPredicate1->UnRegister();
1885
1886   if ( myPredicate2 )
1887     myPredicate2->UnRegister();
1888 }
1889
1890 void LogicalBinary_i::SetMesh( SMESH_Mesh_ptr theMesh )
1891 {
1892   if ( myPredicate1 )
1893     myPredicate1->SetMesh( theMesh );
1894
1895   if ( myPredicate2 )
1896     myPredicate2->SetMesh( theMesh );
1897 }
1898
1899 void LogicalBinary_i::SetPredicate1( Predicate_ptr thePredicate )
1900 {
1901   if ( myPredicate1 )
1902     myPredicate1->UnRegister();
1903
1904   myPredicate1 = SMESH::GetPredicate(thePredicate);
1905
1906   if ( myPredicate1 ){
1907     myLogicalBinaryPtr->SetPredicate1(myPredicate1->GetPredicate());
1908     myPredicate1->Register();
1909     TPythonDump()<<this<<".SetPredicate1("<<myPredicate1<<")";
1910   }
1911 }
1912
1913 void LogicalBinary_i::SetPredicate2( Predicate_ptr thePredicate )
1914 {
1915   if ( myPredicate2 )
1916     myPredicate2->UnRegister();
1917
1918   myPredicate2 = SMESH::GetPredicate(thePredicate);
1919
1920   if ( myPredicate2 ){
1921     myLogicalBinaryPtr->SetPredicate2(myPredicate2->GetPredicate());
1922     myPredicate2->Register();
1923     TPythonDump()<<this<<".SetPredicate2("<<myPredicate2<<")";
1924   }
1925 }
1926
1927 Controls::LogicalBinaryPtr LogicalBinary_i::GetLogicalBinary()
1928 {
1929   return myLogicalBinaryPtr;
1930 }
1931
1932 Predicate_i* LogicalBinary_i::GetPredicate1_i()
1933 {
1934   return myPredicate1;
1935 }
1936 Predicate_i* LogicalBinary_i::GetPredicate2_i()
1937 {
1938   return myPredicate2;
1939 }
1940
1941
1942 /*
1943   Class       : LogicalAND_i
1944   Description : Logical AND
1945 */
1946 LogicalAND_i::LogicalAND_i()
1947 {
1948   myLogicalBinaryPtr.reset( new Controls::LogicalAND() );
1949   myFunctorPtr = myPredicatePtr = myLogicalBinaryPtr;
1950 }
1951
1952 FunctorType LogicalAND_i::GetFunctorType()
1953 {
1954   return SMESH::FT_LogicalAND;
1955 }
1956
1957
1958 /*
1959   Class       : LogicalOR_i
1960   Description : Logical OR
1961 */
1962 LogicalOR_i::LogicalOR_i()
1963 {
1964   myLogicalBinaryPtr.reset( new Controls::LogicalOR() );
1965   myFunctorPtr = myPredicatePtr = myLogicalBinaryPtr;
1966 }
1967
1968 FunctorType LogicalOR_i::GetFunctorType()
1969 {
1970   return SMESH::FT_LogicalOR;
1971 }
1972
1973
1974 /*
1975                             FILTER MANAGER
1976 */
1977
1978 FilterManager_i::FilterManager_i()
1979 : SALOME::GenericObj_i( SMESH_Gen_i::GetPOA() )
1980 {
1981   //Base class Salome_GenericObject do it inmplicitly by overriding PortableServer::POA_ptr _default_POA() method
1982   //PortableServer::ObjectId_var anObjectId =
1983   //  SMESH_Gen_i::GetPOA()->activate_object( this );
1984 }
1985
1986
1987 FilterManager_i::~FilterManager_i()
1988 {
1989   //TPythonDump()<<this<<".UnRegister()";
1990 }
1991
1992
1993 MinimumAngle_ptr FilterManager_i::CreateMinimumAngle()
1994 {
1995   SMESH::MinimumAngle_i* aServant = new SMESH::MinimumAngle_i();
1996   SMESH::MinimumAngle_var anObj = aServant->_this();
1997   TPythonDump()<<aServant<<" = "<<this<<".CreateMinimumAngle()";
1998   return anObj._retn();
1999 }
2000
2001
2002 AspectRatio_ptr FilterManager_i::CreateAspectRatio()
2003 {
2004   SMESH::AspectRatio_i* aServant = new SMESH::AspectRatio_i();
2005   SMESH::AspectRatio_var anObj = aServant->_this();
2006   TPythonDump()<<aServant<<" = "<<this<<".CreateAspectRatio()";
2007   return anObj._retn();
2008 }
2009
2010
2011 AspectRatio3D_ptr FilterManager_i::CreateAspectRatio3D()
2012 {
2013   SMESH::AspectRatio3D_i* aServant = new SMESH::AspectRatio3D_i();
2014   SMESH::AspectRatio3D_var anObj = aServant->_this();
2015   TPythonDump()<<aServant<<" = "<<this<<".CreateAspectRatio3D()";
2016   return anObj._retn();
2017 }
2018
2019
2020 Warping_ptr FilterManager_i::CreateWarping()
2021 {
2022   SMESH::Warping_i* aServant = new SMESH::Warping_i();
2023   SMESH::Warping_var anObj = aServant->_this();
2024   TPythonDump()<<aServant<<" = "<<this<<".CreateWarping()";
2025   return anObj._retn();
2026 }
2027
2028
2029 Taper_ptr FilterManager_i::CreateTaper()
2030 {
2031   SMESH::Taper_i* aServant = new SMESH::Taper_i();
2032   SMESH::Taper_var anObj = aServant->_this();
2033   TPythonDump()<<aServant<<" = "<<this<<".CreateTaper()";
2034   return anObj._retn();
2035 }
2036
2037
2038 Skew_ptr FilterManager_i::CreateSkew()
2039 {
2040   SMESH::Skew_i* aServant = new SMESH::Skew_i();
2041   SMESH::Skew_var anObj = aServant->_this();
2042   TPythonDump()<<aServant<<" = "<<this<<".CreateSkew()";
2043   return anObj._retn();
2044 }
2045
2046
2047 Area_ptr FilterManager_i::CreateArea()
2048 {
2049   SMESH::Area_i* aServant = new SMESH::Area_i();
2050   SMESH::Area_var anObj = aServant->_this();
2051   TPythonDump()<<aServant<<" = "<<this<<".CreateArea()";
2052   return anObj._retn();
2053 }
2054
2055
2056 Volume3D_ptr FilterManager_i::CreateVolume3D()
2057 {
2058   SMESH::Volume3D_i* aServant = new SMESH::Volume3D_i();
2059   SMESH::Volume3D_var anObj = aServant->_this();
2060   TPythonDump()<<aServant<<" = "<<this<<".CreateVolume3D()";
2061   return anObj._retn();
2062 }
2063
2064
2065 MaxElementLength2D_ptr FilterManager_i::CreateMaxElementLength2D()
2066 {
2067   SMESH::MaxElementLength2D_i* aServant = new SMESH::MaxElementLength2D_i();
2068   SMESH::MaxElementLength2D_var anObj = aServant->_this();
2069   TPythonDump()<<aServant<<" = "<<this<<".CreateMaxElementLength2D()";
2070   return anObj._retn();
2071 }
2072
2073
2074 MaxElementLength3D_ptr FilterManager_i::CreateMaxElementLength3D()
2075 {
2076   SMESH::MaxElementLength3D_i* aServant = new SMESH::MaxElementLength3D_i();
2077   SMESH::MaxElementLength3D_var anObj = aServant->_this();
2078   TPythonDump()<<aServant<<" = "<<this<<".CreateMaxElementLength3D()";
2079   return anObj._retn();
2080 }
2081
2082
2083 Length_ptr FilterManager_i::CreateLength()
2084 {
2085   SMESH::Length_i* aServant = new SMESH::Length_i();
2086   SMESH::Length_var anObj = aServant->_this();
2087   TPythonDump()<<aServant<<" = "<<this<<".CreateLength()";
2088   return anObj._retn();
2089 }
2090
2091 Length2D_ptr FilterManager_i::CreateLength2D()
2092 {
2093   SMESH::Length2D_i* aServant = new SMESH::Length2D_i();
2094   SMESH::Length2D_var anObj = aServant->_this();
2095   TPythonDump()<<aServant<<" = "<<this<<".CreateLength2D()";
2096   return anObj._retn();
2097 }
2098
2099 MultiConnection_ptr FilterManager_i::CreateMultiConnection()
2100 {
2101   SMESH::MultiConnection_i* aServant = new SMESH::MultiConnection_i();
2102   SMESH::MultiConnection_var anObj = aServant->_this();
2103   TPythonDump()<<aServant<<" = "<<this<<".CreateMultiConnection()";
2104   return anObj._retn();
2105 }
2106
2107 MultiConnection2D_ptr FilterManager_i::CreateMultiConnection2D()
2108 {
2109   SMESH::MultiConnection2D_i* aServant = new SMESH::MultiConnection2D_i();
2110   SMESH::MultiConnection2D_var anObj = aServant->_this();
2111   TPythonDump()<<aServant<<" = "<<this<<".CreateMultiConnection2D()";
2112   return anObj._retn();
2113 }
2114
2115 BallDiameter_ptr FilterManager_i::CreateBallDiameter()
2116 {
2117   SMESH::BallDiameter_i* aServant = new SMESH::BallDiameter_i();
2118   SMESH::BallDiameter_var anObj = aServant->_this();
2119   TPythonDump()<<aServant<<" = "<<this<<".CreateBallDiameter()";
2120   return anObj._retn();
2121 }
2122
2123 BelongToMeshGroup_ptr FilterManager_i::CreateBelongToMeshGroup()
2124 {
2125   SMESH::BelongToMeshGroup_i* aServant = new SMESH::BelongToMeshGroup_i();
2126   SMESH::BelongToMeshGroup_var anObj = aServant->_this();
2127   TPythonDump()<<aServant<<" = "<<this<<".CreateBelongToMeshGroup()";
2128   return anObj._retn();
2129 }
2130
2131 BelongToGeom_ptr FilterManager_i::CreateBelongToGeom()
2132 {
2133   SMESH::BelongToGeom_i* aServant = new SMESH::BelongToGeom_i();
2134   SMESH::BelongToGeom_var anObj = aServant->_this();
2135   TPythonDump()<<aServant<<" = "<<this<<".CreateBelongToGeom()";
2136   return anObj._retn();
2137 }
2138
2139 BelongToPlane_ptr FilterManager_i::CreateBelongToPlane()
2140 {
2141   SMESH::BelongToPlane_i* aServant = new SMESH::BelongToPlane_i();
2142   SMESH::BelongToPlane_var anObj = aServant->_this();
2143   TPythonDump()<<aServant<<" = "<<this<<".CreateBelongToPlane()";
2144   return anObj._retn();
2145 }
2146
2147 BelongToCylinder_ptr FilterManager_i::CreateBelongToCylinder()
2148 {
2149   SMESH::BelongToCylinder_i* aServant = new SMESH::BelongToCylinder_i();
2150   SMESH::BelongToCylinder_var anObj = aServant->_this();
2151   TPythonDump()<<aServant<<" = "<<this<<".CreateBelongToCylinder()";
2152   return anObj._retn();
2153 }
2154
2155 BelongToGenSurface_ptr FilterManager_i::CreateBelongToGenSurface()
2156 {
2157   SMESH::BelongToGenSurface_i* aServant = new SMESH::BelongToGenSurface_i();
2158   SMESH::BelongToGenSurface_var anObj = aServant->_this();
2159   TPythonDump()<<aServant<<" = "<<this<<".CreateBelongToGenSurface()";
2160   return anObj._retn();
2161 }
2162
2163 LyingOnGeom_ptr FilterManager_i::CreateLyingOnGeom()
2164 {
2165   SMESH::LyingOnGeom_i* aServant = new SMESH::LyingOnGeom_i();
2166   SMESH::LyingOnGeom_var anObj = aServant->_this();
2167   TPythonDump()<<aServant<<" = "<<this<<".CreateLyingOnGeom()";
2168   return anObj._retn();
2169 }
2170
2171 CoplanarFaces_ptr FilterManager_i::CreateCoplanarFaces()
2172 {
2173   SMESH::CoplanarFaces_i* aServant = new SMESH::CoplanarFaces_i();
2174   SMESH::CoplanarFaces_var anObj = aServant->_this();
2175   TPythonDump()<<aServant<<" = "<<this<<".CreateCoplanarFaces()";
2176   return anObj._retn();
2177 }
2178
2179 ConnectedElements_ptr FilterManager_i::CreateConnectedElements()
2180 {
2181   SMESH::ConnectedElements_i* aServant = new SMESH::ConnectedElements_i();
2182   SMESH::ConnectedElements_var anObj = aServant->_this();
2183   TPythonDump()<<aServant<<" = "<<this<<".CreateConnectedElements()";
2184   return anObj._retn();
2185 }
2186
2187 FreeBorders_ptr FilterManager_i::CreateFreeBorders()
2188 {
2189   SMESH::FreeBorders_i* aServant = new SMESH::FreeBorders_i();
2190   SMESH::FreeBorders_var anObj = aServant->_this();
2191   TPythonDump()<<aServant<<" = "<<this<<".CreateFreeBorders()";
2192   return anObj._retn();
2193 }
2194
2195 FreeEdges_ptr FilterManager_i::CreateFreeEdges()
2196 {
2197   SMESH::FreeEdges_i* aServant = new SMESH::FreeEdges_i();
2198   SMESH::FreeEdges_var anObj = aServant->_this();
2199   TPythonDump()<<aServant<<" = "<<this<<".CreateFreeEdges()";
2200   return anObj._retn();
2201 }
2202
2203 FreeFaces_ptr FilterManager_i::CreateFreeFaces()
2204 {
2205   SMESH::FreeFaces_i* aServant = new SMESH::FreeFaces_i();
2206   SMESH::FreeFaces_var anObj = aServant->_this();
2207   TPythonDump()<<aServant<<" = "<<this<<".CreateFreeFaces()";
2208   return anObj._retn();
2209 }
2210
2211 FreeNodes_ptr FilterManager_i::CreateFreeNodes()
2212 {
2213   SMESH::FreeNodes_i* aServant = new SMESH::FreeNodes_i();
2214   SMESH::FreeNodes_var anObj = aServant->_this();
2215   TPythonDump()<<aServant<<" = "<<this<<".CreateFreeNodes()";
2216   return anObj._retn();
2217 }
2218
2219 EqualNodes_ptr FilterManager_i::CreateEqualNodes()
2220 {
2221   SMESH::EqualNodes_i* aServant = new SMESH::EqualNodes_i();
2222   SMESH::EqualNodes_var anObj = aServant->_this();
2223   TPythonDump()<<aServant<<" = "<<this<<".CreateEqualNodes()";
2224   return anObj._retn();
2225 }
2226
2227 EqualEdges_ptr FilterManager_i::CreateEqualEdges()
2228 {
2229   SMESH::EqualEdges_i* aServant = new SMESH::EqualEdges_i();
2230   SMESH::EqualEdges_var anObj = aServant->_this();
2231   TPythonDump()<<aServant<<" = "<<this<<".CreateEqualEdges()";
2232   return anObj._retn();
2233 }
2234 EqualFaces_ptr FilterManager_i::CreateEqualFaces()
2235 {
2236   SMESH::EqualFaces_i* aServant = new SMESH::EqualFaces_i();
2237   SMESH::EqualFaces_var anObj = aServant->_this();
2238   TPythonDump()<<aServant<<" = "<<this<<".CreateEqualFaces()";
2239   return anObj._retn();
2240 }
2241 EqualVolumes_ptr FilterManager_i::CreateEqualVolumes()
2242 {
2243   SMESH::EqualVolumes_i* aServant = new SMESH::EqualVolumes_i();
2244   SMESH::EqualVolumes_var anObj = aServant->_this();
2245   TPythonDump()<<aServant<<" = "<<this<<".CreateEqualVolumes()";
2246   return anObj._retn();
2247 }
2248
2249 RangeOfIds_ptr FilterManager_i::CreateRangeOfIds()
2250 {
2251   SMESH::RangeOfIds_i* aServant = new SMESH::RangeOfIds_i();
2252   SMESH::RangeOfIds_var anObj = aServant->_this();
2253   TPythonDump()<<aServant<<" = "<<this<<".CreateRangeOfIds()";
2254   return anObj._retn();
2255 }
2256
2257 BadOrientedVolume_ptr FilterManager_i::CreateBadOrientedVolume()
2258 {
2259   SMESH::BadOrientedVolume_i* aServant = new SMESH::BadOrientedVolume_i();
2260   SMESH::BadOrientedVolume_var anObj = aServant->_this();
2261   TPythonDump()<<aServant<<" = "<<this<<".CreateBadOrientedVolume()";
2262   return anObj._retn();
2263 }
2264
2265 BareBorderVolume_ptr FilterManager_i::CreateBareBorderVolume()
2266 {
2267   SMESH::BareBorderVolume_i* aServant = new SMESH::BareBorderVolume_i();
2268   SMESH::BareBorderVolume_var anObj = aServant->_this();
2269   TPythonDump()<<aServant<<" = "<<this<<".CreateBareBorderVolume()";
2270   return anObj._retn();
2271 }
2272
2273 BareBorderFace_ptr FilterManager_i::CreateBareBorderFace()
2274 {
2275   SMESH::BareBorderFace_i* aServant = new SMESH::BareBorderFace_i();
2276   SMESH::BareBorderFace_var anObj = aServant->_this();
2277   TPythonDump()<<aServant<<" = "<<this<<".CreateBareBorderFace()";
2278   return anObj._retn();
2279 }
2280
2281 OverConstrainedVolume_ptr FilterManager_i::CreateOverConstrainedVolume()
2282 {
2283   SMESH::OverConstrainedVolume_i* aServant = new SMESH::OverConstrainedVolume_i();
2284   SMESH::OverConstrainedVolume_var anObj = aServant->_this();
2285   TPythonDump()<<aServant<<" = "<<this<<".CreateOverConstrainedVolume()";
2286   return anObj._retn();
2287 }
2288
2289 OverConstrainedFace_ptr FilterManager_i::CreateOverConstrainedFace()
2290 {
2291   SMESH::OverConstrainedFace_i* aServant = new SMESH::OverConstrainedFace_i();
2292   SMESH::OverConstrainedFace_var anObj = aServant->_this();
2293   TPythonDump()<<aServant<<" = "<<this<<".CreateOverConstrainedFace()";
2294   return anObj._retn();
2295 }
2296
2297 LessThan_ptr FilterManager_i::CreateLessThan()
2298 {
2299   SMESH::LessThan_i* aServant = new SMESH::LessThan_i();
2300   SMESH::LessThan_var anObj = aServant->_this();
2301   TPythonDump()<<aServant<<" = "<<this<<".CreateLessThan()";
2302   return anObj._retn();
2303 }
2304
2305 MoreThan_ptr FilterManager_i::CreateMoreThan()
2306 {
2307   SMESH::MoreThan_i* aServant = new SMESH::MoreThan_i();
2308   SMESH::MoreThan_var anObj = aServant->_this();
2309   TPythonDump()<<aServant<<" = "<<this<<".CreateMoreThan()";
2310   return anObj._retn();
2311 }
2312
2313 EqualTo_ptr FilterManager_i::CreateEqualTo()
2314 {
2315   SMESH::EqualTo_i* aServant = new SMESH::EqualTo_i();
2316   SMESH::EqualTo_var anObj = aServant->_this();
2317   TPythonDump()<<aServant<<" = "<<this<<".CreateEqualTo()";
2318   return anObj._retn();
2319 }
2320
2321 LogicalNOT_ptr FilterManager_i::CreateLogicalNOT()
2322 {
2323   SMESH::LogicalNOT_i* aServant = new SMESH::LogicalNOT_i();
2324   SMESH::LogicalNOT_var anObj = aServant->_this();
2325   TPythonDump()<<aServant<<" = "<<this<<".CreateLogicalNOT()";
2326   return anObj._retn();
2327 }
2328
2329 LogicalAND_ptr FilterManager_i::CreateLogicalAND()
2330 {
2331   SMESH::LogicalAND_i* aServant = new SMESH::LogicalAND_i();
2332   SMESH::LogicalAND_var anObj = aServant->_this();
2333   TPythonDump()<<aServant<<" = "<<this<<".CreateLogicalAND()";
2334   return anObj._retn();
2335 }
2336
2337 LogicalOR_ptr FilterManager_i::CreateLogicalOR()
2338 {
2339   SMESH::LogicalOR_i* aServant = new SMESH::LogicalOR_i();
2340   SMESH::LogicalOR_var anObj = aServant->_this();
2341   TPythonDump()<<aServant<<" = "<<this<<".CreateLogicalOR()";
2342   return anObj._retn();
2343 }
2344
2345 LinearOrQuadratic_ptr FilterManager_i::CreateLinearOrQuadratic()
2346 {
2347   SMESH::LinearOrQuadratic_i* aServant = new SMESH::LinearOrQuadratic_i();
2348   SMESH::LinearOrQuadratic_var anObj = aServant->_this();
2349   TPythonDump()<<aServant<<" = "<<this<<".CreateLinearOrQuadratic()";
2350   return anObj._retn();
2351 }
2352
2353 GroupColor_ptr FilterManager_i::CreateGroupColor()
2354 {
2355   SMESH::GroupColor_i* aServant = new SMESH::GroupColor_i();
2356   SMESH::GroupColor_var anObj = aServant->_this();
2357   TPythonDump()<<aServant<<" = "<<this<<".CreateGroupColor()";
2358   return anObj._retn();
2359 }
2360
2361 ElemGeomType_ptr FilterManager_i::CreateElemGeomType()
2362 {
2363   SMESH::ElemGeomType_i* aServant = new SMESH::ElemGeomType_i();
2364   SMESH::ElemGeomType_var anObj = aServant->_this();
2365   TPythonDump()<<aServant<<" = "<<this<<".CreateElemGeomType()";
2366   return anObj._retn();
2367 }
2368
2369 ElemEntityType_ptr FilterManager_i::CreateElemEntityType()
2370 {
2371   SMESH::ElemEntityType_i* aServant = new SMESH::ElemEntityType_i();
2372   SMESH::ElemEntityType_var anObj = aServant->_this();
2373   TPythonDump()<<aServant<<" = "<<this<<".CreateElemEntityType()";
2374   return anObj._retn();
2375 }
2376
2377 Filter_ptr FilterManager_i::CreateFilter()
2378 {
2379   SMESH::Filter_i* aServant = new SMESH::Filter_i();
2380   SMESH::Filter_var anObj = aServant->_this();
2381   TPythonDump()<<aServant<<" = "<<this<<".CreateFilter()";
2382   return anObj._retn();
2383 }
2384
2385 FilterLibrary_ptr FilterManager_i::LoadLibrary( const char* aFileName )
2386 {
2387   SMESH::FilterLibrary_i* aServant = new SMESH::FilterLibrary_i( aFileName );
2388   SMESH::FilterLibrary_var anObj = aServant->_this();
2389   TPythonDump()<<aServant<<" = "<<this<<".LoadLibrary('"<<aFileName<<"')";
2390   return anObj._retn();
2391 }
2392
2393 FilterLibrary_ptr FilterManager_i::CreateLibrary()
2394 {
2395   SMESH::FilterLibrary_i* aServant = new SMESH::FilterLibrary_i();
2396   SMESH::FilterLibrary_var anObj = aServant->_this();
2397   TPythonDump()<<aServant<<" = "<<this<<".CreateLibrary()";
2398   return anObj._retn();
2399 }
2400
2401 CORBA::Boolean FilterManager_i::DeleteLibrary( const char* aFileName )
2402 {
2403   TPythonDump()<<this<<".DeleteLibrary("<<aFileName<<")";
2404   return remove( aFileName ) ? false : true;
2405 }
2406
2407 //=============================================================================
2408 /*!
2409  *  SMESH_Gen_i::CreateFilterManager
2410  *
2411  *  Create filter manager
2412  */
2413 //=============================================================================
2414
2415 SMESH::FilterManager_ptr SMESH_Gen_i::CreateFilterManager()
2416 {
2417   SMESH::FilterManager_i* aFilter = new SMESH::FilterManager_i();
2418   SMESH::FilterManager_var anObj = aFilter->_this();
2419   return anObj._retn();
2420 }
2421
2422
2423 /*
2424                               FILTER
2425 */
2426
2427 //=======================================================================
2428 // name    : Filter_i::Filter_i
2429 // Purpose : Constructor
2430 //=======================================================================
2431 Filter_i::Filter_i()
2432 : myPredicate( NULL )
2433 {}
2434
2435 //=======================================================================
2436 // name    : Filter_i::~Filter_i
2437 // Purpose : Destructor
2438 //=======================================================================
2439 Filter_i::~Filter_i()
2440 {
2441   if ( myPredicate )
2442     myPredicate->UnRegister();
2443
2444   if(!CORBA::is_nil(myMesh))
2445     myMesh->UnRegister();
2446
2447   myPredicate = 0;
2448   FindBaseObjects();
2449 }
2450
2451 //=======================================================================
2452 // name    : Filter_i::SetPredicate
2453 // Purpose : Set predicate
2454 //=======================================================================
2455 void Filter_i::SetPredicate( Predicate_ptr thePredicate )
2456 {
2457   if ( myPredicate )
2458     myPredicate->UnRegister();
2459
2460   myPredicate = SMESH::GetPredicate(thePredicate);
2461
2462   if ( myPredicate )
2463   {
2464     myFilter.SetPredicate( myPredicate->GetPredicate() );
2465     myPredicate->Register();
2466     if ( const SMDS_Mesh* aMesh = MeshPtr2SMDSMesh(myMesh))
2467       myPredicate->GetPredicate()->SetMesh( aMesh );
2468     TPythonDump()<<this<<".SetPredicate("<<myPredicate<<")";
2469   }
2470   NotifyerAndWaiter::Modified();
2471 }
2472
2473 //=======================================================================
2474 // name    : Filter_i::GetElementType
2475 // Purpose : Get entity type
2476 //=======================================================================
2477 SMESH::ElementType Filter_i::GetElementType()
2478 {
2479   return myPredicate != 0 ? myPredicate->GetElementType() : SMESH::ALL;
2480 }
2481
2482 //=======================================================================
2483 // name    : Filter_i::SetMesh
2484 // Purpose : Set mesh
2485 //=======================================================================
2486 void
2487 Filter_i::
2488 SetMesh( SMESH_Mesh_ptr theMesh )
2489 {
2490   if(!CORBA::is_nil(theMesh))
2491     theMesh->Register();
2492
2493   if(!CORBA::is_nil(myMesh))
2494     myMesh->UnRegister();
2495
2496   myMesh = SMESH_Mesh::_duplicate( theMesh );
2497   TPythonDump()<<this<<".SetMesh("<<theMesh<<")";
2498
2499   if ( myPredicate )
2500     if ( const SMDS_Mesh* aMesh = MeshPtr2SMDSMesh(theMesh))
2501       myPredicate->GetPredicate()->SetMesh( aMesh );
2502 }
2503
2504 SMESH::long_array*
2505 Filter_i::
2506 GetIDs()
2507 {
2508   return GetElementsId(myMesh);
2509 }
2510
2511 //=======================================================================
2512 // name    : Filter_i::GetElementsId
2513 // Purpose : Get ids of entities
2514 //=======================================================================
2515 void
2516 Filter_i::
2517 GetElementsId( Predicate_i* thePredicate,
2518                const SMDS_Mesh* theMesh,
2519                Controls::Filter::TIdSequence& theSequence )
2520 {
2521   if (thePredicate)
2522     Controls::Filter::GetElementsId(theMesh,thePredicate->GetPredicate(),theSequence);
2523 }
2524
2525 void
2526 Filter_i::
2527 GetElementsId( Predicate_i* thePredicate,
2528                SMESH_Mesh_ptr theMesh,
2529                Controls::Filter::TIdSequence& theSequence )
2530 {
2531   if (thePredicate) 
2532     if(const SMDS_Mesh* aMesh = MeshPtr2SMDSMesh(theMesh))
2533       Controls::Filter::GetElementsId(aMesh,thePredicate->GetPredicate(),theSequence);
2534 }
2535
2536 SMESH::long_array*
2537 Filter_i::
2538 GetElementsId( SMESH_Mesh_ptr theMesh )
2539 {
2540   SMESH::long_array_var anArray = new SMESH::long_array;
2541   if(!CORBA::is_nil(theMesh) && myPredicate){
2542     theMesh->Load();
2543     Controls::Filter::TIdSequence aSequence;
2544     GetElementsId(myPredicate,theMesh,aSequence);
2545     long i = 0, iEnd = aSequence.size();
2546     anArray->length( iEnd );
2547     for ( ; i < iEnd; i++ )
2548       anArray[ i ] = aSequence[i];
2549   }
2550   return anArray._retn();
2551 }
2552
2553 //=============================================================================
2554 /*!
2555  * \brief Returns number of mesh elements per each \a EntityType
2556  */
2557 //=============================================================================
2558
2559 SMESH::long_array* ::Filter_i::GetMeshInfo()
2560 {
2561   SMESH::long_array_var aRes = new SMESH::long_array();
2562   aRes->length(SMESH::Entity_Last);
2563   for (int i = 0; i < SMESH::Entity_Last; i++)
2564     aRes[i] = 0;
2565
2566   if ( !CORBA::is_nil(myMesh) && myPredicate )
2567   {
2568     const SMDS_Mesh*  aMesh = MeshPtr2SMDSMesh(myMesh);
2569     SMDS_ElemIteratorPtr it = aMesh->elementsIterator( SMDSAbs_ElementType( GetElementType() ));
2570     while ( it->more() )
2571     {
2572       const SMDS_MeshElement* anElem = it->next();
2573       if ( myPredicate->IsSatisfy( anElem->GetID() ) )
2574         aRes[ anElem->GetEntityType() ]++;
2575     }
2576   }
2577
2578   return aRes._retn();  
2579 }
2580
2581 //=============================================================================
2582 /*!
2583  * \brief Returns number of mesh elements of each \a ElementType
2584  */
2585 //=============================================================================
2586
2587 SMESH::long_array* ::Filter_i::GetNbElementsByType()
2588 {
2589   SMESH::long_array_var aRes = new SMESH::long_array();
2590   aRes->length(SMESH::NB_ELEMENT_TYPES);
2591   for (int i = 0; i < SMESH::NB_ELEMENT_TYPES; i++)
2592     aRes[i] = 0;
2593
2594   if ( !CORBA::is_nil(myMesh) && myPredicate ) {
2595     const SMDS_Mesh*  aMesh = MeshPtr2SMDSMesh(myMesh);
2596     SMDS_ElemIteratorPtr it = aMesh->elementsIterator( SMDSAbs_ElementType( GetElementType() ));
2597     CORBA::Long& nbElems = aRes[ GetElementType() ];
2598     while ( it->more() )
2599     {
2600       const SMDS_MeshElement* anElem = it->next();
2601       if ( myPredicate->IsSatisfy( anElem->GetID() ) )
2602         nbElems++;
2603     }
2604   }
2605
2606   return aRes._retn();  
2607 }
2608
2609
2610 //================================================================================
2611 /*!
2612  * \brief Return GetElementType() within an array
2613  * Implement SMESH_IDSource interface
2614  */
2615 //================================================================================
2616
2617 SMESH::array_of_ElementType* Filter_i::GetTypes()
2618 {
2619   SMESH::array_of_ElementType_var types = new SMESH::array_of_ElementType;
2620
2621   // check if any element passes through the filter
2622   if ( !CORBA::is_nil(myMesh) && myPredicate )
2623   {
2624     const SMDS_Mesh* aMesh = MeshPtr2SMDSMesh(myMesh);
2625     SMDS_ElemIteratorPtr it = aMesh->elementsIterator( SMDSAbs_ElementType( GetElementType() ));
2626     bool satisfies = false;
2627     while ( !satisfies && it->more() )
2628       satisfies = myPredicate->IsSatisfy( it->next()->GetID() );
2629     if ( satisfies ) {
2630       types->length( 1 );
2631       types[0] = GetElementType();
2632     }
2633   }
2634   return types._retn();
2635 }
2636
2637 //=======================================================================
2638 //function : GetMesh
2639 //purpose  : Returns mesh
2640 //=======================================================================
2641
2642 SMESH::SMESH_Mesh_ptr Filter_i::GetMesh()
2643 {
2644   return SMESH_Mesh::_duplicate( myMesh );
2645 }
2646
2647 //=======================================================================
2648 //function : GetVtkUgStream
2649 //purpose  : Return data vtk unstructured grid (not implemented)
2650 //=======================================================================
2651
2652 SALOMEDS::TMPFile* Filter_i::GetVtkUgStream()
2653 {
2654   SALOMEDS::TMPFile_var SeqFile;
2655   return SeqFile._retn();
2656 }
2657 //=======================================================================
2658 // name    : getCriteria
2659 // Purpose : Retrieve criterions from predicate
2660 //=======================================================================
2661 static inline void getPrediacates( Predicate_i*                thePred,
2662                                    std::vector<Predicate_i*> & thePredVec )
2663 {
2664   const int aFType = thePred->GetFunctorType();
2665
2666   switch ( aFType )
2667   {
2668   case FT_LogicalNOT:
2669   {
2670     Predicate_i* aPred = ( dynamic_cast<LogicalNOT_i*>( thePred ) )->GetPredicate_i();
2671     getPrediacates( aPred, thePredVec );
2672     break;
2673   }
2674   case FT_LogicalAND:
2675   case FT_LogicalOR:
2676   {
2677     Predicate_i* aPred1 = ( dynamic_cast<LogicalBinary_i*>( thePred ) )->GetPredicate1_i();
2678     Predicate_i* aPred2 = ( dynamic_cast<LogicalBinary_i*>( thePred ) )->GetPredicate2_i();
2679     getPrediacates( aPred1, thePredVec );
2680     getPrediacates( aPred2, thePredVec );
2681     break;
2682    }
2683   default:;
2684   }
2685   thePredVec.push_back( thePred );
2686 }
2687
2688 //=======================================================================
2689 // name    : getCriteria
2690 // Purpose : Retrieve criterions from predicate
2691 //=======================================================================
2692 static inline bool getCriteria( Predicate_i*                thePred,
2693                                 SMESH::Filter::Criteria_out theCriteria )
2694 {
2695   const int aFType = thePred->GetFunctorType();
2696
2697   switch ( aFType )
2698   {
2699   case FT_LogicalNOT:
2700     {
2701       Predicate_i* aPred = ( dynamic_cast<LogicalNOT_i*>( thePred ) )->GetPredicate_i();
2702       getCriteria( aPred, theCriteria );
2703       theCriteria[ theCriteria->length() - 1 ].UnaryOp = FT_LogicalNOT;
2704     }
2705     return true;
2706
2707   case FT_LogicalAND:
2708   case FT_LogicalOR:
2709     {
2710       Predicate_i* aPred1 = ( dynamic_cast<LogicalBinary_i*>( thePred ) )->GetPredicate1_i();
2711       Predicate_i* aPred2 = ( dynamic_cast<LogicalBinary_i*>( thePred ) )->GetPredicate2_i();
2712       if ( !getCriteria( aPred1, theCriteria ) )
2713         return false;
2714       theCriteria[ theCriteria->length() - 1 ].BinaryOp = aFType;
2715       return getCriteria( aPred2, theCriteria );
2716     }
2717   case FT_Undefined:
2718     return false;
2719   }
2720
2721   // resize theCriteria
2722   CORBA::ULong i = theCriteria->length();
2723   theCriteria->length( i + 1 );
2724   theCriteria[ i ] = createCriterion();
2725
2726   // set members of the added Criterion
2727
2728   theCriteria[ i ].Type = aFType;
2729   theCriteria[ i ].TypeOfElement = thePred->GetElementType();
2730
2731   switch ( aFType )
2732   {
2733   case FT_FreeBorders:
2734   case FT_FreeEdges:
2735   case FT_FreeFaces:
2736   case FT_LinearOrQuadratic:
2737   case FT_FreeNodes:
2738   case FT_EqualEdges:
2739   case FT_EqualFaces:
2740   case FT_EqualVolumes:
2741   case FT_BadOrientedVolume:
2742   case FT_BareBorderVolume:
2743   case FT_BareBorderFace:
2744   case FT_OverConstrainedVolume:
2745   case FT_OverConstrainedFace:
2746     {
2747       return true;
2748     }
2749   case FT_BelongToMeshGroup:
2750     {
2751       BelongToMeshGroup_i* aPred = dynamic_cast<BelongToMeshGroup_i*>( thePred );
2752       SMESH::SMESH_GroupBase_var grp = aPred->GetGroup();
2753       if ( !grp->_is_nil() )
2754       {
2755         theCriteria[ i ].ThresholdStr = grp->GetName();
2756         theCriteria[ i ].ThresholdID  = aPred->GetGroupID().c_str();
2757       }
2758       return true;
2759     }
2760   case FT_BelongToGeom:
2761     {
2762       BelongToGeom_i* aPred = dynamic_cast<BelongToGeom_i*>( thePred );
2763       theCriteria[ i ].ThresholdStr  = aPred->GetShapeName();
2764       theCriteria[ i ].ThresholdID   = aPred->GetShapeID();
2765       theCriteria[ i ].Tolerance     = aPred->GetTolerance();
2766       return true;
2767     }
2768   case FT_BelongToPlane:
2769   case FT_BelongToCylinder:
2770   case FT_BelongToGenSurface:
2771     {
2772       BelongToSurface_i* aPred = dynamic_cast<BelongToSurface_i*>( thePred );
2773       theCriteria[ i ].ThresholdStr  = aPred->GetShapeName();
2774       theCriteria[ i ].ThresholdID   = aPred->GetShapeID();
2775       theCriteria[ i ].Tolerance     = aPred->GetTolerance();
2776       return true;
2777     }
2778   case FT_LyingOnGeom:
2779     {
2780       LyingOnGeom_i* aPred = dynamic_cast<LyingOnGeom_i*>( thePred );
2781       theCriteria[ i ].ThresholdStr  = aPred->GetShapeName();
2782       theCriteria[ i ].ThresholdID   = aPred->GetShapeID();
2783       theCriteria[ i ].Tolerance     = aPred->GetTolerance();
2784       return true;
2785     }
2786   case FT_CoplanarFaces:
2787     {
2788       CoplanarFaces_i* aPred = dynamic_cast<CoplanarFaces_i*>( thePred );
2789       theCriteria[ i ].ThresholdID   = aPred->GetFaceAsString();
2790       theCriteria[ i ].Tolerance     = aPred->GetTolerance();
2791       return true;
2792     }
2793   case FT_ConnectedElements:
2794     {
2795       ConnectedElements_i* aPred = dynamic_cast<ConnectedElements_i*>( thePred );
2796       SMESH::ConnectedElements::ThresholdType type;
2797       CORBA::String_var threshold = aPred->GetThreshold( type );
2798       switch ( type ) {
2799       case SMESH::ConnectedElements::POINT:
2800         theCriteria[ i ].ThresholdStr = threshold; break;
2801       case SMESH::ConnectedElements::VERTEX:
2802         theCriteria[ i ].ThresholdID = threshold; break;
2803       case SMESH::ConnectedElements::NODE:
2804         theCriteria[ i ].Threshold = atof( threshold.in() ); break;
2805       default:;
2806       }
2807       return true;
2808     }
2809   case FT_EqualNodes:
2810     {
2811       EqualNodes_i* aPred = dynamic_cast<EqualNodes_i*>( thePred );
2812       theCriteria[ i ].Tolerance  = aPred->GetTolerance();
2813       return true;
2814     }
2815   case FT_RangeOfIds:
2816     {
2817       RangeOfIds_i* aPred = dynamic_cast<RangeOfIds_i*>( thePred );
2818       theCriteria[ i ].ThresholdStr  = aPred->GetRangeStr();
2819       return true;
2820     }
2821   case FT_LessThan:
2822   case FT_MoreThan:
2823   case FT_EqualTo:
2824     {
2825       Comparator_i* aCompar = dynamic_cast<Comparator_i*>( thePred );
2826       theCriteria[ i ].Type      = aCompar->GetNumFunctor_i()->GetFunctorType();
2827       theCriteria[ i ].Compare   = aFType;
2828       theCriteria[ i ].Threshold = aCompar->GetMargin();
2829       if ( aFType == FT_EqualTo )
2830       {
2831         EqualTo_i* aCompar = dynamic_cast<EqualTo_i*>( thePred );
2832         theCriteria[ i ].Tolerance = aCompar->GetTolerance();
2833       }
2834       return true;
2835     }
2836   case FT_GroupColor:
2837     {
2838       GroupColor_i* aPred = dynamic_cast<GroupColor_i*>( thePred );
2839       theCriteria[ i ].ThresholdStr = aPred->GetColorStr();
2840       return true;
2841     }
2842   case FT_ElemGeomType:
2843     {
2844       ElemGeomType_i* aPred = dynamic_cast<ElemGeomType_i*>( thePred );
2845       theCriteria[ i ].Threshold = (double)aPred->GetGeometryType();
2846       return true;
2847     }
2848   case FT_EntityType:
2849     {
2850       ElemEntityType_i* aPred = dynamic_cast<ElemEntityType_i*>( thePred );
2851       theCriteria[ i ].Threshold = (double)aPred->GetEntityType();
2852       return true;
2853     }
2854   default:
2855     return false;
2856   }
2857 }
2858
2859 //=======================================================================
2860 // name    : Filter_i::GetCriteria
2861 // Purpose : Retrieve criterions from predicate
2862 //=======================================================================
2863 CORBA::Boolean Filter_i::GetCriteria( SMESH::Filter::Criteria_out theCriteria )
2864 {
2865   theCriteria = new SMESH::Filter::Criteria;
2866   return myPredicate != 0 ? getCriteria( myPredicate, theCriteria ) : true;
2867 }
2868
2869 //=======================================================================
2870 // name    : Filter_i::SetCriteria
2871 // Purpose : Create new predicate and set criterions in it
2872 //=======================================================================
2873 CORBA::Boolean Filter_i::SetCriteria( const SMESH::Filter::Criteria& theCriteria )
2874 {
2875   SetPredicate( SMESH::Predicate::_nil() );
2876
2877   SMESH::FilterManager_i* aFilter = new SMESH::FilterManager_i();
2878   FilterManager_ptr aFilterMgr = aFilter->_this();
2879
2880   // CREATE two lists ( PREDICATES  and LOG OP )
2881
2882   // Criterion
2883   TPythonDump()<<"aCriteria = []";
2884   std::list<SMESH::Predicate_ptr> aPredicates;
2885   std::list<int>                  aBinaries;
2886   for ( int i = 0, n = theCriteria.length(); i < n; i++ )
2887   {
2888     int         aCriterion    = theCriteria[ i ].Type;
2889     int         aCompare      = theCriteria[ i ].Compare;
2890     double      aThreshold    = theCriteria[ i ].Threshold;
2891     const char* aThresholdStr = theCriteria[ i ].ThresholdStr;
2892     const char* aThresholdID  = theCriteria[ i ].ThresholdID;
2893     int         aUnary        = theCriteria[ i ].UnaryOp;
2894     int         aBinary       = theCriteria[ i ].BinaryOp;
2895     double      aTolerance    = theCriteria[ i ].Tolerance;
2896     ElementType aTypeOfElem   = theCriteria[ i ].TypeOfElement;
2897     long        aPrecision    = theCriteria[ i ].Precision;
2898
2899     {
2900       TPythonDump pd;
2901       pd << "aCriterion = SMESH.Filter.Criterion("
2902          << aCriterion    << ", "
2903          << aCompare      << ", "
2904          << aThreshold    << ", '"
2905          << aThresholdStr << "', '"
2906          << aThresholdID  << "', "
2907          << aUnary        << ", "
2908          << aBinary       << ", "
2909          << aTolerance    << ", "
2910          << aTypeOfElem   << ", "
2911          << aPrecision    << ")";
2912     }
2913     TPythonDump pd;
2914
2915     SMESH::Predicate_ptr aPredicate = SMESH::Predicate::_nil();
2916     SMESH::NumericalFunctor_ptr aFunctor = SMESH::NumericalFunctor::_nil();
2917
2918     switch ( aCriterion )
2919     {
2920       // Functors
2921
2922       case SMESH::FT_MultiConnection:
2923         aFunctor = aFilterMgr->CreateMultiConnection();
2924         break;
2925       case SMESH::FT_MultiConnection2D:
2926         aFunctor = aFilterMgr->CreateMultiConnection2D();
2927         break;
2928       case SMESH::FT_Length:
2929         aFunctor = aFilterMgr->CreateLength();
2930         break;
2931       case SMESH::FT_Length2D:
2932         aFunctor = aFilterMgr->CreateLength2D();
2933         break;
2934       case SMESH::FT_AspectRatio:
2935         aFunctor = aFilterMgr->CreateAspectRatio();
2936         break;
2937       case SMESH::FT_AspectRatio3D:
2938         aFunctor = aFilterMgr->CreateAspectRatio3D();
2939         break;
2940       case SMESH::FT_Warping:
2941         aFunctor = aFilterMgr->CreateWarping();
2942         break;
2943       case SMESH::FT_MinimumAngle:
2944         aFunctor = aFilterMgr->CreateMinimumAngle();
2945         break;
2946       case SMESH::FT_Taper:
2947         aFunctor = aFilterMgr->CreateTaper();
2948         break;
2949       case SMESH::FT_Skew:
2950         aFunctor = aFilterMgr->CreateSkew();
2951         break;
2952       case SMESH::FT_Area:
2953         aFunctor = aFilterMgr->CreateArea();
2954         break;
2955       case SMESH::FT_Volume3D:
2956         aFunctor = aFilterMgr->CreateVolume3D();
2957         break;
2958       case SMESH::FT_MaxElementLength2D:
2959         aFunctor = aFilterMgr->CreateMaxElementLength2D();
2960         break;
2961       case SMESH::FT_MaxElementLength3D:
2962         aFunctor = aFilterMgr->CreateMaxElementLength3D();
2963         break;
2964       case SMESH::FT_BallDiameter:
2965         aFunctor = aFilterMgr->CreateBallDiameter();
2966         break;
2967
2968       // Predicates
2969
2970       case SMESH::FT_FreeBorders:
2971         aPredicate = aFilterMgr->CreateFreeBorders();
2972         break;
2973       case SMESH::FT_FreeEdges:
2974         aPredicate = aFilterMgr->CreateFreeEdges();
2975         break;
2976       case SMESH::FT_FreeFaces:
2977         aPredicate = aFilterMgr->CreateFreeFaces();
2978         break;
2979       case SMESH::FT_FreeNodes:
2980         aPredicate = aFilterMgr->CreateFreeNodes();
2981         break;
2982       case SMESH::FT_EqualNodes:
2983         {
2984           SMESH::EqualNodes_ptr pred = aFilterMgr->CreateEqualNodes();
2985           pred->SetTolerance( aTolerance );
2986           aPredicate = pred;
2987           break;
2988         }
2989       case SMESH::FT_EqualEdges:
2990         aPredicate = aFilterMgr->CreateEqualEdges();
2991         break;
2992       case SMESH::FT_EqualFaces:
2993         aPredicate = aFilterMgr->CreateEqualFaces();
2994         break;
2995       case SMESH::FT_EqualVolumes:
2996         aPredicate = aFilterMgr->CreateEqualVolumes();
2997         break;
2998       case SMESH::FT_BelongToMeshGroup:
2999         {
3000           SMESH::BelongToMeshGroup_ptr tmpPred = aFilterMgr->CreateBelongToMeshGroup();
3001           tmpPred->SetGroupID( aThresholdID );
3002           aPredicate = tmpPred;
3003         }
3004         break;
3005       case SMESH::FT_BelongToGeom:
3006         {
3007           SMESH::BelongToGeom_ptr tmpPred = aFilterMgr->CreateBelongToGeom();
3008           tmpPred->SetElementType( aTypeOfElem );
3009           tmpPred->SetShape( aThresholdID, aThresholdStr );
3010           tmpPred->SetTolerance( aTolerance );
3011           aPredicate = tmpPred;
3012         }
3013         break;
3014       case SMESH::FT_BelongToPlane:
3015       case SMESH::FT_BelongToCylinder:
3016       case SMESH::FT_BelongToGenSurface:
3017         {
3018           SMESH::BelongToSurface_ptr tmpPred;
3019           switch ( aCriterion ) {
3020           case SMESH::FT_BelongToPlane:
3021             tmpPred = aFilterMgr->CreateBelongToPlane(); break;
3022           case SMESH::FT_BelongToCylinder:
3023             tmpPred = aFilterMgr->CreateBelongToCylinder(); break;
3024           default:
3025             tmpPred = aFilterMgr->CreateBelongToGenSurface();
3026           }
3027           tmpPred->SetShape( aThresholdID, aThresholdStr, aTypeOfElem );
3028           tmpPred->SetTolerance( aTolerance );
3029           aPredicate = tmpPred;
3030         }
3031         break;
3032       case SMESH::FT_LyingOnGeom:
3033         {
3034           SMESH::LyingOnGeom_ptr tmpPred = aFilterMgr->CreateLyingOnGeom();
3035           tmpPred->SetElementType( aTypeOfElem );
3036           tmpPred->SetShape( aThresholdID, aThresholdStr );
3037           tmpPred->SetTolerance( aTolerance );
3038           aPredicate = tmpPred;
3039         }
3040         break;
3041       case SMESH::FT_RangeOfIds:
3042         {
3043           SMESH::RangeOfIds_ptr tmpPred = aFilterMgr->CreateRangeOfIds();
3044           tmpPred->SetRangeStr( aThresholdStr );
3045           tmpPred->SetElementType( aTypeOfElem );
3046           aPredicate = tmpPred;
3047         }
3048         break;
3049       case SMESH::FT_BadOrientedVolume:
3050         {
3051           aPredicate = aFilterMgr->CreateBadOrientedVolume();
3052         }
3053         break;
3054       case SMESH::FT_BareBorderVolume:
3055         {
3056           aPredicate = aFilterMgr->CreateBareBorderVolume();
3057         }
3058         break;
3059       case SMESH::FT_BareBorderFace:
3060         {
3061           aPredicate = aFilterMgr->CreateBareBorderFace();
3062         }
3063         break;
3064       case SMESH::FT_OverConstrainedVolume:
3065         {
3066           aPredicate = aFilterMgr->CreateOverConstrainedVolume();
3067         }
3068         break;
3069       case SMESH::FT_OverConstrainedFace:
3070         {
3071           aPredicate = aFilterMgr->CreateOverConstrainedFace();
3072         }
3073         break;
3074       case SMESH::FT_LinearOrQuadratic:
3075         {
3076           SMESH::LinearOrQuadratic_ptr tmpPred = aFilterMgr->CreateLinearOrQuadratic();
3077           tmpPred->SetElementType( aTypeOfElem );
3078           aPredicate = tmpPred;
3079           break;
3080         }
3081       case SMESH::FT_GroupColor:
3082         {
3083           SMESH::GroupColor_ptr tmpPred = aFilterMgr->CreateGroupColor();
3084           tmpPred->SetElementType( aTypeOfElem );
3085           tmpPred->SetColorStr( aThresholdStr );
3086           aPredicate = tmpPred;
3087           break;
3088         }
3089       case SMESH::FT_ElemGeomType:
3090         {
3091           SMESH::ElemGeomType_ptr tmpPred = aFilterMgr->CreateElemGeomType();
3092           tmpPred->SetElementType( aTypeOfElem );
3093           tmpPred->SetGeometryType( (GeometryType)(int)(aThreshold + 0.5) );
3094           aPredicate = tmpPred;
3095           break;
3096         }
3097       case SMESH::FT_EntityType:
3098         {
3099           SMESH::ElemEntityType_ptr tmpPred = aFilterMgr->CreateElemEntityType();
3100           tmpPred->SetElementType( aTypeOfElem );
3101           tmpPred->SetEntityType( EntityType( (int (aThreshold + 0.5))));
3102           aPredicate = tmpPred;
3103           break;
3104         }
3105       case SMESH::FT_CoplanarFaces:
3106         {
3107           SMESH::CoplanarFaces_ptr tmpPred = aFilterMgr->CreateCoplanarFaces();
3108           tmpPred->SetFace( atol (aThresholdID ));
3109           tmpPred->SetTolerance( aTolerance );
3110           aPredicate = tmpPred;
3111           break;
3112         }
3113       case SMESH::FT_ConnectedElements:
3114         {
3115           SMESH::ConnectedElements_ptr tmpPred = aFilterMgr->CreateConnectedElements();
3116           if ( strlen( aThresholdID ) > 0 ) // shape ID
3117             tmpPred->SetThreshold( aThresholdID, SMESH::ConnectedElements::VERTEX );
3118           else if ( strlen( aThresholdStr ) > 0 ) // point coords
3119             tmpPred->SetThreshold( aThresholdStr, SMESH::ConnectedElements::POINT );
3120           else if ( aThreshold >= 1 )
3121             tmpPred->SetNode( (CORBA::Long) aThreshold ); // node ID
3122           tmpPred->SetElementType( aTypeOfElem );
3123           aPredicate = tmpPred;
3124           break;
3125         }
3126
3127       default:
3128         continue;
3129     }
3130
3131     // Comparator
3132     if ( !aFunctor->_is_nil() && aPredicate->_is_nil() )
3133     {
3134       SMESH::Comparator_ptr aComparator = SMESH::Comparator::_nil();
3135
3136       if ( aCompare == SMESH::FT_LessThan )
3137         aComparator = aFilterMgr->CreateLessThan();
3138       else if ( aCompare == SMESH::FT_MoreThan )
3139         aComparator = aFilterMgr->CreateMoreThan();
3140       else if ( aCompare == SMESH::FT_EqualTo )
3141         aComparator = aFilterMgr->CreateEqualTo();
3142       else
3143         continue;
3144
3145       aComparator->SetNumFunctor( aFunctor );
3146       aComparator->SetMargin( aThreshold );
3147
3148       if ( aCompare == FT_EqualTo )
3149       {
3150         SMESH::EqualTo_var anEqualTo = SMESH::EqualTo::_narrow( aComparator );
3151         anEqualTo->SetTolerance( aTolerance );
3152       }
3153
3154       aPredicate = aComparator;
3155
3156       aFunctor->SetPrecision( aPrecision );
3157     }
3158
3159     // Logical not
3160     if ( aUnary == FT_LogicalNOT )
3161     {
3162       SMESH::LogicalNOT_ptr aNotPred = aFilterMgr->CreateLogicalNOT();
3163       aNotPred->SetPredicate( aPredicate );
3164       aPredicate = aNotPred;
3165     }
3166
3167     // logical op
3168     aPredicates.push_back( aPredicate );
3169     aBinaries.push_back( aBinary );
3170     pd <<"aCriteria.append(aCriterion)";
3171
3172   } // end of for
3173   TPythonDump pd; pd<<this<<".SetCriteria(aCriteria)";
3174
3175   // CREATE ONE PREDICATE FROM PREVIOUSLY CREATED MAP
3176
3177   // combine all "AND" operations
3178
3179   std::list<SMESH::Predicate_ptr> aResList;
3180
3181   std::list<SMESH::Predicate_ptr>::iterator aPredIter;
3182   std::list<int>::iterator                  aBinaryIter;
3183
3184   SMESH::Predicate_ptr aPrevPredicate = SMESH::Predicate::_nil();
3185   int aPrevBinary = SMESH::FT_Undefined;
3186   if ( !aBinaries.empty() )
3187     aBinaries.back() = SMESH::FT_Undefined;
3188
3189   for ( aPredIter = aPredicates.begin(), aBinaryIter = aBinaries.begin();
3190         aPredIter != aPredicates.end() && aBinaryIter != aBinaries.end();
3191         ++aPredIter, ++aBinaryIter )
3192   {
3193     int aCurrBinary = *aBinaryIter;
3194
3195     SMESH::Predicate_ptr aCurrPred = SMESH::Predicate::_nil();
3196
3197     if ( aPrevBinary == SMESH::FT_LogicalAND )
3198     {
3199
3200       SMESH::LogicalBinary_ptr aBinaryPred = aFilterMgr->CreateLogicalAND();
3201       aBinaryPred->SetPredicate1( aPrevPredicate );
3202       aBinaryPred->SetPredicate2( *aPredIter );
3203       aCurrPred = aBinaryPred;
3204     }
3205     else
3206       aCurrPred = *aPredIter;
3207
3208     if ( aCurrBinary != SMESH::FT_LogicalAND )
3209       aResList.push_back( aCurrPred );
3210
3211     aPrevPredicate = aCurrPred;
3212     aPrevBinary = aCurrBinary;
3213   }
3214
3215   // combine all "OR" operations
3216
3217   SMESH::Predicate_ptr aResPredicate = SMESH::Predicate::_nil();
3218
3219   if ( aResList.size() == 1 )
3220     aResPredicate = *aResList.begin();
3221   else if ( aResList.size() > 1 )
3222   {
3223     std::list<SMESH::Predicate_ptr>::iterator anIter = aResList.begin();
3224     aResPredicate = *anIter;
3225     anIter++;
3226     for ( ; anIter != aResList.end(); ++anIter )
3227     {
3228       SMESH::LogicalBinary_ptr aBinaryPred = aFilterMgr->CreateLogicalOR();
3229       aBinaryPred->SetPredicate1( aResPredicate );
3230       aBinaryPred->SetPredicate2( *anIter );
3231       aResPredicate = aBinaryPred;
3232     }
3233   }
3234
3235   SetPredicate( aResPredicate );
3236   if ( !aResPredicate->_is_nil() )
3237     aResPredicate->UnRegister();
3238
3239   return !aResPredicate->_is_nil();
3240 }
3241
3242 //=======================================================================
3243 // name    : Filter_i::GetPredicate_i
3244 // Purpose : Get implementation of predicate
3245 //=======================================================================
3246 Predicate_i* Filter_i::GetPredicate_i()
3247 {
3248   return myPredicate;
3249 }
3250
3251 //=======================================================================
3252 // name    : Filter_i::GetPredicate
3253 // Purpose : Get predicate
3254 //=======================================================================
3255 Predicate_ptr Filter_i::GetPredicate()
3256 {
3257   if ( myPredicate == 0 )
3258     return SMESH::Predicate::_nil();
3259   else
3260   {
3261     SMESH::Predicate_var anObj = myPredicate->_this();
3262     // if ( SMESH::Functor_i* fun = SMESH::DownCast<SMESH::Functor_i*>( anObj ))
3263     //   TPythonDump() << fun << " = " << this << ".GetPredicate()";
3264     return anObj._retn();
3265   }
3266 }
3267
3268 //================================================================================
3269 /*!
3270  * \brief Find groups it depends on
3271  */
3272 //================================================================================
3273
3274 void Filter_i::FindBaseObjects()
3275 {
3276   // release current groups
3277   for ( size_t i = 0; i < myBaseGroups.size(); ++i )
3278     if ( myBaseGroups[i] )
3279     {
3280       myBaseGroups[i]->RemoveModifWaiter( this );
3281       myBaseGroups[i]->UnRegister();
3282     }
3283
3284   // remember new groups
3285   myBaseGroups.clear();
3286   if ( myPredicate )
3287   {
3288     std::vector<Predicate_i*> predicates;
3289     getPrediacates( myPredicate, predicates );
3290     for ( size_t i = 0; i < predicates.size(); ++i )
3291       if ( BelongToMeshGroup_i* bmg = dynamic_cast< BelongToMeshGroup_i* >( predicates[i] ))
3292       {
3293         SMESH::SMESH_GroupBase_var g = bmg->GetGroup();
3294         SMESH_GroupBase_i* g_i = SMESH::DownCast< SMESH_GroupBase_i*>( g );
3295         if ( g_i )
3296         {
3297           g_i->AddModifWaiter( this );
3298           g_i->Register();
3299           myBaseGroups.push_back( g_i );
3300         }
3301       }
3302   }
3303 }
3304
3305 //================================================================================
3306 /*!
3307  * \brief When notified on removal of myBaseGroups[i], remove a reference to a
3308  *        group from a predicate
3309  */
3310 //================================================================================
3311
3312 void Filter_i::OnBaseObjModified(NotifyerAndWaiter* group, bool removed)
3313 {
3314   if ( !removed )
3315     return; // a GroupOnFilter holding this filter is notified automatically
3316
3317   if ( myPredicate )
3318   {
3319     std::vector<Predicate_i*> predicates;
3320     getPrediacates( myPredicate, predicates );
3321     for ( size_t i = 0; i < predicates.size(); ++i )
3322       if ( BelongToMeshGroup_i* bmg = dynamic_cast< BelongToMeshGroup_i* >( predicates[i] ))
3323       {
3324         SMESH::SMESH_GroupBase_var g = bmg->GetGroup();
3325         SMESH_GroupBase_i* g_i = SMESH::DownCast< SMESH_GroupBase_i*>( g );
3326         if ( g_i == group )
3327         {
3328           bmg->SetGroup( SMESH::SMESH_GroupBase::_nil() );
3329           bmg->SetGroupID( "" );
3330         }
3331       }
3332   }
3333
3334   FindBaseObjects(); // release and update myBaseGroups;
3335 }
3336
3337 /*
3338                             FILTER LIBRARY
3339 */
3340
3341 #define ATTR_TYPE          "type"
3342 #define ATTR_COMPARE       "compare"
3343 #define ATTR_THRESHOLD     "threshold"
3344 #define ATTR_UNARY         "unary"
3345 #define ATTR_BINARY        "binary"
3346 #define ATTR_THRESHOLD_STR "threshold_str"
3347 #define ATTR_TOLERANCE     "tolerance"
3348 #define ATTR_ELEMENT_TYPE  "ElementType"
3349
3350 //=======================================================================
3351 // name    : toString
3352 // Purpose : Convert bool&n