src/SMESH_I/SMESH_Filter_i.cxx

   1 // Copyright (C) 2007-2012  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.
  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 //  SMESH SMESH_I : idl implementation based on 'SMESH' unit's calsses
  23 //  File   : SMESH_Filter_i.cxx
  24 //  Author : Alexey Petrov, OCC
  25 //  Module : SMESH
  26
  27 #include "SMESH_Filter_i.hxx"
  28
  29 #include "SMDS_ElemIterator.hxx"
  30 #include "SMDS_Mesh.hxx"
  31 #include "SMDS_MeshElement.hxx"
  32 #include "SMDS_MeshNode.hxx"
  33 #include "SMESHDS_Mesh.hxx"
  34 #include "SMESH_Gen_i.hxx"
  35 #include "SMESH_PythonDump.hxx"
  36
  37 #include <SALOMEDS_wrap.hxx>
  38
  39 #include <BRep_Tool.hxx>
  40 #include <Geom_CylindricalSurface.hxx>
  41 #include <Geom_Plane.hxx>
  42 #include <LDOMParser.hxx>
  43 #include <LDOMString.hxx>
  44 #include <LDOM_Document.hxx>
  45 #include <LDOM_Element.hxx>
  46 #include <LDOM_Node.hxx>
  47 #include <LDOM_XmlWriter.hxx>
  48 #include <Precision.hxx>
  49 #include <TColStd_ListIteratorOfListOfInteger.hxx>
  50 #include <TColStd_ListIteratorOfListOfReal.hxx>
  51 #include <TColStd_ListOfInteger.hxx>
  52 #include <TColStd_ListOfReal.hxx>
  53 #include <TColStd_SequenceOfHAsciiString.hxx>
  54 #include <TCollection_HAsciiString.hxx>
  55 #include <TopExp.hxx>
  56 #include <TopExp_Explorer.hxx>
  57 #include <TopoDS.hxx>
  58 #include <TopoDS_Face.hxx>
  59 #include <TopoDS_Shape.hxx>
  60 #include <TopTools_IndexedMapOfShape.hxx>
  61
  62 using namespace SMESH;
  63 using namespace SMESH::Controls;
  64
  65
  66 namespace SMESH
  67 {
  68   Predicate_i*
  69   GetPredicate( Predicate_ptr thePredicate )
  70   {
  71     return DownCast<Predicate_i*>(thePredicate);
  72   }
  73 }
  74
  75
  76 /*
  77   Class       : BelongToGeom
  78   Description : Predicate for verifying whether entity belongs to
  79                 specified geometrical support
  80 */
  81
  82 Controls::BelongToGeom::BelongToGeom()
  83   : myMeshDS(NULL),
  84     myType(SMDSAbs_All),
  85     myIsSubshape(false),
  86     myTolerance(Precision::Confusion())
  87 {}
  88
  89 void Controls::BelongToGeom::SetMesh( const SMDS_Mesh* theMesh )
  90 {
  91   myMeshDS = dynamic_cast<const SMESHDS_Mesh*>(theMesh);
  92   init();
  93 }
  94
  95 void Controls::BelongToGeom::SetGeom( const TopoDS_Shape& theShape )
  96 {
  97   myShape = theShape;
  98   init();
  99 }
 100
 101 static bool IsSubShape (const TopTools_IndexedMapOfShape& theMap,
 102                         const TopoDS_Shape& theShape)
 103 {
 104   if (theMap.Contains(theShape)) return true;
 105
 106   if (theShape.ShapeType() == TopAbs_COMPOUND ||
 107       theShape.ShapeType() == TopAbs_COMPSOLID)
 108   {
 109     TopoDS_Iterator anIt (theShape, Standard_True, Standard_True);
 110     for (; anIt.More(); anIt.Next())
 111     {
 112       if (!IsSubShape(theMap, anIt.Value())) {
 113         return false;
 114       }
 115     }
 116     return true;
 117   }
 118
 119   return false;
 120 }
 121
 122 void Controls::BelongToGeom::init()
 123 {
 124   if (!myMeshDS || myShape.IsNull()) return;
 125
 126   // is sub-shape of main shape?
 127   TopoDS_Shape aMainShape = myMeshDS->ShapeToMesh();
 128   if (aMainShape.IsNull()) {
 129     myIsSubshape = false;
 130   }
 131   else {
 132     TopTools_IndexedMapOfShape aMap;
 133     TopExp::MapShapes(aMainShape, aMap);
 134     myIsSubshape = IsSubShape(aMap, myShape);
 135   }
 136
 137   if (!myIsSubshape)
 138   {
 139     myElementsOnShapePtr.reset(new Controls::ElementsOnShape());
 140     myElementsOnShapePtr->SetTolerance(myTolerance);
 141     myElementsOnShapePtr->SetAllNodes(true); // belong, while false means "lays on"
 142     myElementsOnShapePtr->SetMesh(myMeshDS);
 143     myElementsOnShapePtr->SetShape(myShape, myType);
 144   }
 145 }
 146
 147 static bool IsContains( const SMESHDS_Mesh*     theMeshDS,
 148                         const TopoDS_Shape&     theShape,
 149                         const SMDS_MeshElement* theElem,
 150                         TopAbs_ShapeEnum        theFindShapeEnum,
 151                         TopAbs_ShapeEnum        theAvoidShapeEnum = TopAbs_SHAPE )
 152 {
 153   TopExp_Explorer anExp( theShape,theFindShapeEnum,theAvoidShapeEnum );
 154
 155   while( anExp.More() )
 156   {
 157     const TopoDS_Shape& aShape = anExp.Current();
 158     if( SMESHDS_SubMesh* aSubMesh = theMeshDS->MeshElements( aShape ) ){
 159       if( aSubMesh->Contains( theElem ) )
 160         return true;
 161     }
 162     anExp.Next();
 163   }
 164   return false;
 165 }
 166
 167 bool Controls::BelongToGeom::IsSatisfy (long theId)
 168 {
 169   if (myMeshDS == 0 || myShape.IsNull())
 170     return false;
 171
 172   if (!myIsSubshape)
 173   {
 174     return myElementsOnShapePtr->IsSatisfy(theId);
 175   }
 176
 177   // Case of submesh
 178   if (myType == SMDSAbs_Node)
 179   {
 180     if( const SMDS_MeshNode* aNode = myMeshDS->FindNode( theId ) )
 181     {
 182       const SMDS_PositionPtr& aPosition = aNode->GetPosition();
 183       SMDS_TypeOfPosition aTypeOfPosition = aPosition->GetTypeOfPosition();
 184       switch( aTypeOfPosition )
 185       {
 186       case SMDS_TOP_VERTEX : return IsContains( myMeshDS,myShape,aNode,TopAbs_VERTEX );
 187       case SMDS_TOP_EDGE   : return IsContains( myMeshDS,myShape,aNode,TopAbs_EDGE );
 188       case SMDS_TOP_FACE   : return IsContains( myMeshDS,myShape,aNode,TopAbs_FACE );
 189       case SMDS_TOP_3DSPACE: return IsContains( myMeshDS,myShape,aNode,TopAbs_SHELL );
 190       }
 191     }
 192   }
 193   else
 194   {
 195     if( const SMDS_MeshElement* anElem = myMeshDS->FindElement( theId ) )
 196     {
 197       if( myType == SMDSAbs_All )
 198       {
 199         return IsContains( myMeshDS,myShape,anElem,TopAbs_EDGE ) ||
 200                IsContains( myMeshDS,myShape,anElem,TopAbs_FACE ) ||
 201                IsContains( myMeshDS,myShape,anElem,TopAbs_SHELL )||
 202                IsContains( myMeshDS,myShape,anElem,TopAbs_SOLID );
 203       }
 204       else if( myType == anElem->GetType() )
 205       {
 206         switch( myType )
 207         {
 208         case SMDSAbs_Edge  : return IsContains( myMeshDS,myShape,anElem,TopAbs_EDGE );
 209         case SMDSAbs_Face  : return IsContains( myMeshDS,myShape,anElem,TopAbs_FACE );
 210         case SMDSAbs_Volume: return IsContains( myMeshDS,myShape,anElem,TopAbs_SHELL )||
 211                                     IsContains( myMeshDS,myShape,anElem,TopAbs_SOLID );
 212         }
 213       }
 214     }
 215   }
 216
 217   return false;
 218 }
 219
 220 void Controls::BelongToGeom::SetType (SMDSAbs_ElementType theType)
 221 {
 222   myType = theType;
 223   init();
 224 }
 225
 226 SMDSAbs_ElementType Controls::BelongToGeom::GetType() const
 227 {
 228   return myType;
 229 }
 230
 231 TopoDS_Shape Controls::BelongToGeom::GetShape()
 232 {
 233   return myShape;
 234 }
 235
 236 const SMESHDS_Mesh* Controls::BelongToGeom::GetMeshDS() const
 237 {
 238   return myMeshDS;
 239 }
 240
 241 void Controls::BelongToGeom::SetTolerance (double theTolerance)
 242 {
 243   myTolerance = theTolerance;
 244   if (!myIsSubshape)
 245     init();
 246 }
 247
 248 double Controls::BelongToGeom::GetTolerance()
 249 {
 250   return myTolerance;
 251 }
 252
 253 /*
 254   Class       : LyingOnGeom
 255   Description : Predicate for verifying whether entiy lying or partially lying on
 256                 specified geometrical support
 257 */
 258
 259 Controls::LyingOnGeom::LyingOnGeom()
 260   : myMeshDS(NULL),
 261     myType(SMDSAbs_All),
 262     myIsSubshape(false),
 263     myTolerance(Precision::Confusion())
 264 {}
 265
 266 void Controls::LyingOnGeom::SetMesh( const SMDS_Mesh* theMesh )
 267 {
 268   myMeshDS = dynamic_cast<const SMESHDS_Mesh*>(theMesh);
 269   init();
 270 }
 271
 272 void Controls::LyingOnGeom::SetGeom( const TopoDS_Shape& theShape )
 273 {
 274   myShape = theShape;
 275   init();
 276 }
 277
 278 void Controls::LyingOnGeom::init()
 279 {
 280   if (!myMeshDS || myShape.IsNull()) return;
 281
 282   // is sub-shape of main shape?
 283   TopoDS_Shape aMainShape = myMeshDS->ShapeToMesh();
 284   if (aMainShape.IsNull()) {
 285     myIsSubshape = false;
 286   }
 287   else {
 288     TopTools_IndexedMapOfShape aMap;
 289     TopExp::MapShapes(aMainShape, aMap);
 290     myIsSubshape = IsSubShape(aMap, myShape);
 291   }
 292
 293   if (!myIsSubshape)
 294   {
 295     myElementsOnShapePtr.reset(new Controls::ElementsOnShape());
 296     myElementsOnShapePtr->SetTolerance(myTolerance);
 297     myElementsOnShapePtr->SetAllNodes(false); // lays on, while true means "belong"
 298     myElementsOnShapePtr->SetMesh(myMeshDS);
 299     myElementsOnShapePtr->SetShape(myShape, myType);
 300   }
 301 }
 302
 303 bool Controls::LyingOnGeom::IsSatisfy( long theId )
 304 {
 305   if ( myMeshDS == 0 || myShape.IsNull() )
 306     return false;
 307
 308   if (!myIsSubshape)
 309   {
 310     return myElementsOnShapePtr->IsSatisfy(theId);
 311   }
 312
 313   // Case of submesh
 314   if( myType == SMDSAbs_Node )
 315   {
 316     if( const SMDS_MeshNode* aNode = myMeshDS->FindNode( theId ) )
 317     {
 318       const SMDS_PositionPtr& aPosition = aNode->GetPosition();
 319       SMDS_TypeOfPosition aTypeOfPosition = aPosition->GetTypeOfPosition();
 320       switch( aTypeOfPosition )
 321       {
 322       case SMDS_TOP_VERTEX : return IsContains( myMeshDS,myShape,aNode,TopAbs_VERTEX );
 323       case SMDS_TOP_EDGE   : return IsContains( myMeshDS,myShape,aNode,TopAbs_EDGE );
 324       case SMDS_TOP_FACE   : return IsContains( myMeshDS,myShape,aNode,TopAbs_FACE );
 325       case SMDS_TOP_3DSPACE: return IsContains( myMeshDS,myShape,aNode,TopAbs_SHELL );
 326       }
 327     }
 328   }
 329   else
 330   {
 331     if( const SMDS_MeshElement* anElem = myMeshDS->FindElement( theId ) )
 332     {
 333       if( myType == SMDSAbs_All )
 334       {
 335         return Contains( myMeshDS,myShape,anElem,TopAbs_EDGE ) ||
 336                Contains( myMeshDS,myShape,anElem,TopAbs_FACE ) ||
 337                Contains( myMeshDS,myShape,anElem,TopAbs_SHELL )||
 338                Contains( myMeshDS,myShape,anElem,TopAbs_SOLID );
 339       }
 340       else if( myType == anElem->GetType() )
 341       {
 342         switch( myType )
 343         {
 344         case SMDSAbs_Edge  : return Contains( myMeshDS,myShape,anElem,TopAbs_EDGE );
 345         case SMDSAbs_Face  : return Contains( myMeshDS,myShape,anElem,TopAbs_FACE );
 346         case SMDSAbs_Volume: return Contains( myMeshDS,myShape,anElem,TopAbs_SHELL )||
 347                                     Contains( myMeshDS,myShape,anElem,TopAbs_SOLID );
 348         }
 349       }
 350     }
 351   }
 352
 353   return false;
 354 }
 355
 356 void Controls::LyingOnGeom::SetType( SMDSAbs_ElementType theType )
 357 {
 358   myType = theType;
 359   init();
 360 }
 361
 362 SMDSAbs_ElementType Controls::LyingOnGeom::GetType() const
 363 {
 364   return myType;
 365 }
 366
 367 TopoDS_Shape Controls::LyingOnGeom::GetShape()
 368 {
 369   return myShape;
 370 }
 371
 372 const SMESHDS_Mesh* Controls::LyingOnGeom::GetMeshDS() const
 373 {
 374   return myMeshDS;
 375 }
 376
 377 void Controls::LyingOnGeom::SetTolerance (double theTolerance)
 378 {
 379   myTolerance = theTolerance;
 380   if (!myIsSubshape)
 381     init();
 382 }
 383
 384 double Controls::LyingOnGeom::GetTolerance()
 385 {
 386   return myTolerance;
 387 }
 388
 389 bool Controls::LyingOnGeom::Contains( const SMESHDS_Mesh*     theMeshDS,
 390                                       const TopoDS_Shape&     theShape,
 391                                       const SMDS_MeshElement* theElem,
 392                                       TopAbs_ShapeEnum        theFindShapeEnum,
 393                                       TopAbs_ShapeEnum        theAvoidShapeEnum )
 394 {
 395   if (IsContains(theMeshDS, theShape, theElem, theFindShapeEnum, theAvoidShapeEnum))
 396     return true;
 397
 398   TopTools_IndexedMapOfShape aSubShapes;
 399   TopExp::MapShapes( theShape, aSubShapes );
 400
 401   for (int i = 1; i <= aSubShapes.Extent(); i++)
 402   {
 403     const TopoDS_Shape& aShape = aSubShapes.FindKey(i);
 404
 405     if( SMESHDS_SubMesh* aSubMesh = theMeshDS->MeshElements( aShape ) ){
 406       if( aSubMesh->Contains( theElem ) )
 407         return true;
 408
 409       SMDS_NodeIteratorPtr aNodeIt = aSubMesh->GetNodes();
 410       while ( aNodeIt->more() )
 411       {
 412         const SMDS_MeshNode* aNode = static_cast<const SMDS_MeshNode*>(aNodeIt->next());
 413         SMDS_ElemIteratorPtr anElemIt = aNode->GetInverseElementIterator();
 414         while ( anElemIt->more() )
 415         {
 416           const SMDS_MeshElement* anElement = static_cast<const SMDS_MeshElement*>(anElemIt->next());
 417           if (anElement == theElem)
 418             return true;
 419         }
 420       }
 421     }
 422   }
 423   return false;
 424 }
 425
 426
 427 /*
 428                             AUXILIARY METHODS
 429 */
 430
 431 inline
 432 const SMDS_Mesh*
 433 MeshPtr2SMDSMesh( SMESH_Mesh_ptr theMesh )
 434 {
 435   SMESH_Mesh_i* anImplPtr = DownCast<SMESH_Mesh_i*>(theMesh);
 436   return anImplPtr ? anImplPtr->GetImpl().GetMeshDS() : 0;
 437 }
 438
 439 inline
 440 SMESH::long_array*
 441 toArray( const TColStd_ListOfInteger& aList )
 442 {
 443   SMESH::long_array_var anArray = new SMESH::long_array;
 444   anArray->length( aList.Extent() );
 445   TColStd_ListIteratorOfListOfInteger anIter( aList );
 446   int i = 0;
 447   for( ; anIter.More(); anIter.Next() )
 448     anArray[ i++ ] = anIter.Value();
 449
 450   return anArray._retn();
 451 }
 452
 453 inline
 454 SMESH::double_array*
 455 toArray( const TColStd_ListOfReal& aList )
 456 {
 457   SMESH::double_array_var anArray = new SMESH::double_array;
 458   anArray->length( aList.Extent() );
 459   TColStd_ListIteratorOfListOfReal anIter( aList );
 460   int i = 0;
 461   for( ; anIter.More(); anIter.Next() )
 462     anArray[ i++ ] = anIter.Value();
 463
 464   return anArray._retn();
 465 }
 466
 467 static SMESH::Filter::Criterion createCriterion()
 468 {
 469   SMESH::Filter::Criterion aCriterion;
 470
 471   aCriterion.Type          = FT_Undefined;
 472   aCriterion.Compare       = FT_Undefined;
 473   aCriterion.Threshold     = 0;
 474   aCriterion.UnaryOp       = FT_Undefined;
 475   aCriterion.BinaryOp      = FT_Undefined;
 476   aCriterion.ThresholdStr  = "";
 477   aCriterion.ThresholdID   = "";
 478   aCriterion.Tolerance     = Precision::Confusion();
 479   aCriterion.TypeOfElement = SMESH::ALL;
 480   aCriterion.Precision     = -1;
 481
 482   return aCriterion;
 483 }
 484
 485 static TopoDS_Shape getShapeByName( const char* theName )
 486 {
 487   if ( theName != 0 )
 488   {
 489     SMESH_Gen_i* aSMESHGen     = SMESH_Gen_i::GetSMESHGen();
 490     SALOMEDS::Study_var aStudy = aSMESHGen->GetCurrentStudy();
 491     if ( !aStudy->_is_nil() )
 492     {
 493       SALOMEDS::Study::ListOfSObject_var aList = aStudy->FindObjectByName( theName, "GEOM" );
 494       if ( aList->length() > 0 )
 495       {
 496         CORBA::Object_var        anObj = aList[ 0 ]->GetObject();
 497         GEOM::GEOM_Object_var aGeomObj = GEOM::GEOM_Object::_narrow( anObj );
 498         TopoDS_Shape             shape = aSMESHGen->GeomObjectToShape( aGeomObj );
 499         SALOME::UnRegister( aList ); // UnRegister() objects in aList
 500         return shape;
 501       }
 502     }
 503   }
 504   return TopoDS_Shape();
 505 }
 506
 507 static TopoDS_Shape getShapeByID (const char* theID)
 508 {
 509   if ( theID && strlen( theID ) > 0 ) {
 510     SMESH_Gen_i*     aSMESHGen = SMESH_Gen_i::GetSMESHGen();
 511     SALOMEDS::Study_var aStudy = aSMESHGen->GetCurrentStudy();
 512     if ( !aStudy->_is_nil() ) {
 513       SALOMEDS::SObject_wrap aSObj = aStudy->FindObjectID(theID);
 514       if ( !aSObj->_is_nil() ) {
 515         CORBA::Object_var          obj = aSObj->GetObject();
 516         GEOM::GEOM_Object_var aGeomObj = GEOM::GEOM_Object::_narrow(obj);
 517         return aSMESHGen->GeomObjectToShape( aGeomObj );
 518       }
 519     }
 520   }
 521   return TopoDS_Shape();
 522 }
 523
 524 static std::string getShapeNameByID (const char* theID)
 525 {
 526   if ( theID && strlen( theID ) > 0 ) {
 527     SMESH_Gen_i*     aSMESHGen = SMESH_Gen_i::GetSMESHGen();
 528     SALOMEDS::Study_var aStudy = aSMESHGen->GetCurrentStudy();
 529     if ( !aStudy->_is_nil() ) {
 530       SALOMEDS::SObject_wrap aSObj = aStudy->FindObjectID(theID);
 531       if ( !aSObj->_is_nil() ) {
 532         CORBA::String_var name = aSObj->GetName();
 533         return name.in();
 534       }
 535     }
 536   }
 537   return "";
 538 }
 539
 540 /*
 541                                 FUNCTORS
 542 */
 543
 544 /*
 545   Class       : Functor_i
 546   Description : An abstact class for all functors
 547 */
 548 Functor_i::Functor_i():
 549   SALOME::GenericObj_i( SMESH_Gen_i::GetPOA() )
 550 {
 551   //Base class Salome_GenericObject do it inmplicitly by overriding PortableServer::POA_ptr _default_POA() method
 552   //PortableServer::ObjectId_var anObjectId =
 553   //  SMESH_Gen_i::GetPOA()->activate_object( this );
 554 }
 555
 556 Functor_i::~Functor_i()
 557 {
 558   //TPythonDump()<<this<<".UnRegister()";
 559 }
 560
 561 void Functor_i::SetMesh( SMESH_Mesh_ptr theMesh )
 562 {
 563   myFunctorPtr->SetMesh( MeshPtr2SMDSMesh( theMesh ) );
 564   TPythonDump()<<this<<".SetMesh("<<theMesh<<")";
 565 }
 566
 567 ElementType Functor_i::GetElementType()
 568 {
 569   return ( ElementType )myFunctorPtr->GetType();
 570 }
 571
 572
 573 /*
 574   Class       : NumericalFunctor_i
 575   Description : Base class for numerical functors
 576 */
 577 CORBA::Double NumericalFunctor_i::GetValue( CORBA::Long theId )
 578 {
 579   return myNumericalFunctorPtr->GetValue( theId );
 580 }
 581
 582 SMESH::Histogram* NumericalFunctor_i::GetHistogram(CORBA::Short nbIntervals, CORBA::Boolean isLogarithmic)
 583 {
 584   std::vector<int> nbEvents;
 585   std::vector<double> funValues;
 586   std::vector<int> elements;
 587   myNumericalFunctorPtr->GetHistogram(nbIntervals,nbEvents,funValues,elements,0,isLogarithmic);
 588
 589 #ifdef WIN32
 590   nbIntervals = CORBA::Short( min( nbEvents.size(), funValues.size() - 1));
 591 #else
 592   nbIntervals = CORBA::Short( std::min( nbEvents.size(), funValues.size() - 1));
 593 #endif
 594   SMESH::Histogram_var histogram = new SMESH::Histogram;
 595   if ( nbIntervals > 0 )
 596   {
 597     histogram->length( nbIntervals );
 598     for ( int i = 0; i < nbIntervals; ++i )
 599     {
 600       HistogramRectangle& rect = histogram[i];
 601       rect.nbEvents = nbEvents[i];
 602       rect.min = funValues[i];
 603       rect.max = funValues[i+1];
 604     }
 605   }
 606   return histogram._retn();
 607 }
 608
 609 void NumericalFunctor_i::SetPrecision( CORBA::Long thePrecision )
 610 {
 611   myNumericalFunctorPtr->SetPrecision( thePrecision );
 612   TPythonDump()<<this<<".SetPrecision("<<thePrecision<<")";
 613 }
 614
 615 CORBA::Long NumericalFunctor_i::GetPrecision()
 616 {
 617  return myNumericalFunctorPtr->GetPrecision();
 618 }
 619
 620 Controls::NumericalFunctorPtr NumericalFunctor_i::GetNumericalFunctor()
 621 {
 622   return myNumericalFunctorPtr;
 623 }
 624
 625
 626 /*
 627   Class       : SMESH_MinimumAngle
 628   Description : Functor for calculation of minimum angle
 629 */
 630 MinimumAngle_i::MinimumAngle_i()
 631 {
 632   myNumericalFunctorPtr.reset( new Controls::MinimumAngle() );
 633   myFunctorPtr = myNumericalFunctorPtr;
 634 }
 635
 636 FunctorType MinimumAngle_i::GetFunctorType()
 637 {
 638   return SMESH::FT_MinimumAngle;
 639 }
 640
 641
 642 /*
 643   Class       : AspectRatio
 644   Description : Functor for calculating aspect ratio
 645 */
 646 AspectRatio_i::AspectRatio_i()
 647 {
 648   myNumericalFunctorPtr.reset( new Controls::AspectRatio() );
 649   myFunctorPtr = myNumericalFunctorPtr;
 650 }
 651
 652 FunctorType AspectRatio_i::GetFunctorType()
 653 {
 654   return SMESH::FT_AspectRatio;
 655 }
 656
 657
 658 /*
 659   Class       : AspectRatio3D
 660   Description : Functor for calculating aspect ratio 3D
 661 */
 662 AspectRatio3D_i::AspectRatio3D_i()
 663 {
 664   myNumericalFunctorPtr.reset( new Controls::AspectRatio3D() );
 665   myFunctorPtr = myNumericalFunctorPtr;
 666 }
 667
 668 FunctorType AspectRatio3D_i::GetFunctorType()
 669 {
 670   return SMESH::FT_AspectRatio3D;
 671 }
 672
 673
 674 /*
 675   Class       : Warping_i
 676   Description : Functor for calculating warping
 677 */
 678 Warping_i::Warping_i()
 679 {
 680   myNumericalFunctorPtr.reset( new Controls::Warping() );
 681   myFunctorPtr = myNumericalFunctorPtr;
 682 }
 683
 684 FunctorType Warping_i::GetFunctorType()
 685 {
 686   return SMESH::FT_Warping;
 687 }
 688
 689
 690 /*
 691   Class       : Taper_i
 692   Description : Functor for calculating taper
 693 */
 694 Taper_i::Taper_i()
 695 {
 696   myNumericalFunctorPtr.reset( new Controls::Taper() );
 697   myFunctorPtr = myNumericalFunctorPtr;
 698 }
 699
 700 FunctorType Taper_i::GetFunctorType()
 701 {
 702   return SMESH::FT_Taper;
 703 }
 704
 705 /*
 706   Class       : Skew_i
 707   Description : Functor for calculating skew in degrees
 708 */
 709 Skew_i::Skew_i()
 710 {
 711   myNumericalFunctorPtr.reset( new Controls::Skew() );
 712   myFunctorPtr = myNumericalFunctorPtr;
 713 }
 714
 715 FunctorType Skew_i::GetFunctorType()
 716 {
 717   return SMESH::FT_Skew;
 718 }
 719
 720 /*
 721   Class       : Area_i
 722   Description : Functor for calculating area
 723 */
 724 Area_i::Area_i()
 725 {
 726   myNumericalFunctorPtr.reset( new Controls::Area() );
 727   myFunctorPtr = myNumericalFunctorPtr;
 728 }
 729
 730 FunctorType Area_i::GetFunctorType()
 731 {
 732   return SMESH::FT_Area;
 733 }
 734
 735 /*
 736   Class       : Volume3D_i
 737   Description : Functor for calculating volume of 3D element
 738 */
 739 Volume3D_i::Volume3D_i()
 740 {
 741   myNumericalFunctorPtr.reset( new Controls::Volume() );
 742   myFunctorPtr = myNumericalFunctorPtr;
 743 }
 744
 745 FunctorType Volume3D_i::GetFunctorType()
 746 {
 747   return SMESH::FT_Volume3D;
 748 }
 749
 750 /*
 751   Class       : MaxElementLength2D_i
 752   Description : Functor for calculating maximum length of 2D element
 753 */
 754 MaxElementLength2D_i::MaxElementLength2D_i()
 755 {
 756   myNumericalFunctorPtr.reset( new Controls::MaxElementLength2D() );
 757   myFunctorPtr = myNumericalFunctorPtr;
 758 }
 759
 760 FunctorType MaxElementLength2D_i::GetFunctorType()
 761 {
 762   return SMESH::FT_MaxElementLength2D;
 763 }
 764
 765 /*
 766   Class       : MaxElementLength3D_i
 767   Description : Functor for calculating maximum length of 3D element
 768 */
 769 MaxElementLength3D_i::MaxElementLength3D_i()
 770 {
 771   myNumericalFunctorPtr.reset( new Controls::MaxElementLength3D() );
 772   myFunctorPtr = myNumericalFunctorPtr;
 773 }
 774
 775 FunctorType MaxElementLength3D_i::GetFunctorType()
 776 {
 777   return SMESH::FT_MaxElementLength3D;
 778 }
 779
 780 /*
 781   Class       : Length_i
 782   Description : Functor for calculating length off edge
 783 */
 784 Length_i::Length_i()
 785 {
 786   myNumericalFunctorPtr.reset( new Controls::Length() );
 787   myFunctorPtr = myNumericalFunctorPtr;
 788 }
 789
 790 FunctorType Length_i::GetFunctorType()
 791 {
 792   return SMESH::FT_Length;
 793 }
 794
 795 /*
 796   Class       : Length2D_i
 797   Description : Functor for calculating length of edge
 798 */
 799 Length2D_i::Length2D_i()
 800 {
 801   myNumericalFunctorPtr.reset( new Controls::Length2D() );
 802   myFunctorPtr = myNumericalFunctorPtr;
 803 }
 804
 805 FunctorType Length2D_i::GetFunctorType()
 806 {
 807   return SMESH::FT_Length2D;
 808 }
 809
 810 SMESH::Length2D::Values* Length2D_i::GetValues()
 811 {
 812   INFOS("Length2D_i::GetValues");
 813   SMESH::Controls::Length2D::TValues aValues;
 814   (dynamic_cast<SMESH::Controls::Length2D*>(myFunctorPtr.get()))->GetValues( aValues );
 815
 816   long i = 0, iEnd = aValues.size();
 817
 818   SMESH::Length2D::Values_var aResult = new SMESH::Length2D::Values(iEnd);
 819   aResult->length(iEnd);
 820
 821   SMESH::Controls::Length2D::TValues::const_iterator anIter;
 822   for ( anIter = aValues.begin() ; anIter != aValues.end(); anIter++, i++ )
 823   {
 824     const SMESH::Controls::Length2D::Value&  aVal = *anIter;
 825     SMESH::Length2D::Value &aValue = aResult[ i ];
 826
 827     aValue.myLength = aVal.myLength;
 828     aValue.myPnt1 = aVal.myPntId[ 0 ];
 829     aValue.myPnt2 = aVal.myPntId[ 1 ];
 830   }
 831
 832   INFOS("Length2D_i::GetValuess~");
 833   return aResult._retn();
 834 }
 835
 836 /*
 837   Class       : MultiConnection_i
 838   Description : Functor for calculating number of faces conneted to the edge
 839 */
 840 MultiConnection_i::MultiConnection_i()
 841 {
 842   myNumericalFunctorPtr.reset( new Controls::MultiConnection() );
 843   myFunctorPtr = myNumericalFunctorPtr;
 844 }
 845
 846 FunctorType MultiConnection_i::GetFunctorType()
 847 {
 848   return SMESH::FT_MultiConnection;
 849 }
 850
 851 /*
 852   Class       : BallDiameter_i
 853   Description : Functor returning diameter of a ball element
 854 */
 855 BallDiameter_i::BallDiameter_i()
 856 {
 857   myNumericalFunctorPtr.reset( new Controls::BallDiameter() );
 858   myFunctorPtr = myNumericalFunctorPtr;
 859 }
 860
 861 FunctorType BallDiameter_i::GetFunctorType()
 862 {
 863   return SMESH::FT_BallDiameter;
 864 }
 865
 866 /*
 867   Class       : MultiConnection2D_i
 868   Description : Functor for calculating number of faces conneted to the edge
 869 */
 870 MultiConnection2D_i::MultiConnection2D_i()
 871 {
 872   myNumericalFunctorPtr.reset( new Controls::MultiConnection2D() );
 873   myFunctorPtr = myNumericalFunctorPtr;
 874 }
 875
 876 FunctorType MultiConnection2D_i::GetFunctorType()
 877 {
 878   return SMESH::FT_MultiConnection2D;
 879 }
 880
 881 SMESH::MultiConnection2D::Values* MultiConnection2D_i::GetValues()
 882 {
 883   INFOS("MultiConnection2D_i::GetValues");
 884   SMESH::Controls::MultiConnection2D::MValues aValues;
 885   (dynamic_cast<SMESH::Controls::MultiConnection2D*>(myFunctorPtr.get()))->GetValues( aValues );
 886
 887   long i = 0, iEnd = aValues.size();
 888
 889   SMESH::MultiConnection2D::Values_var aResult = new SMESH::MultiConnection2D::Values(iEnd);
 890   aResult->length(iEnd);
 891
 892   SMESH::Controls::MultiConnection2D::MValues::const_iterator anIter;
 893   for ( anIter = aValues.begin() ; anIter != aValues.end(); anIter++, i++ )
 894   {
 895     const SMESH::Controls::MultiConnection2D::Value&  aVal = (*anIter).first;
 896     SMESH::MultiConnection2D::Value &aValue = aResult[ i ];
 897
 898     aValue.myPnt1 = aVal.myPntId[ 0 ];
 899     aValue.myPnt2 = aVal.myPntId[ 1 ];
 900     aValue.myNbConnects = (*anIter).second;
 901   }
 902
 903   INFOS("Multiconnection2D_i::GetValuess~");
 904   return aResult._retn();
 905 }
 906
 907 /*
 908                             PREDICATES
 909 */
 910
 911
 912 /*
 913   Class       : Predicate_i
 914   Description : Base class for all predicates
 915 */
 916 CORBA::Boolean Predicate_i::IsSatisfy( CORBA::Long theId )
 917 {
 918   return myPredicatePtr->IsSatisfy( theId );
 919 }
 920
 921 Controls::PredicatePtr Predicate_i::GetPredicate()
 922 {
 923   return myPredicatePtr;
 924 }
 925
 926 /*
 927   Class       : BadOrientedVolume_i
 928   Description : Verify whether a mesh volume is incorrectly oriented from
 929                 the point of view of MED convention
 930 */
 931 BadOrientedVolume_i::BadOrientedVolume_i()
 932 {
 933   Controls::PredicatePtr control( new Controls::BadOrientedVolume() );
 934   myFunctorPtr = myPredicatePtr = control;
 935 };
 936
 937 FunctorType BadOrientedVolume_i::GetFunctorType()
 938 {
 939   return SMESH::FT_BadOrientedVolume;
 940 }
 941
 942 /*
 943   Class       : BareBorderVolume_i
 944   Description : Verify whether a mesh volume has a free facet without a face on it
 945 */
 946 BareBorderVolume_i::BareBorderVolume_i()
 947 {
 948   Controls::PredicatePtr control( new Controls::BareBorderVolume() );
 949   myFunctorPtr = myPredicatePtr = control;
 950 };
 951
 952 FunctorType BareBorderVolume_i::GetFunctorType()
 953 {
 954   return SMESH::FT_BareBorderVolume;
 955 }
 956
 957 /*
 958   Class       : BareBorderFace_i
 959   Description : Verify whether a mesh face has a free border without an edge on it
 960 */
 961 BareBorderFace_i::BareBorderFace_i()
 962 {
 963   Controls::PredicatePtr control( new Controls::BareBorderFace() );
 964   myFunctorPtr = myPredicatePtr = control;
 965 };
 966
 967 FunctorType BareBorderFace_i::GetFunctorType()
 968 {
 969   return SMESH::FT_BareBorderFace;
 970 }
 971
 972 /*
 973   Class       : OverConstrainedVolume_i
 974   Description : Verify whether a mesh volume has only one facet shared with other volumes
 975 */
 976 OverConstrainedVolume_i::OverConstrainedVolume_i()
 977 {
 978   Controls::PredicatePtr control( new Controls::OverConstrainedVolume() );
 979   myFunctorPtr = myPredicatePtr = control;
 980 };
 981
 982 FunctorType OverConstrainedVolume_i::GetFunctorType()
 983 {
 984   return SMESH::FT_OverConstrainedVolume;
 985 }
 986
 987 /*
 988   Class       : OverConstrainedFace_i
 989   Description : Verify whether a mesh face has only one border shared with other faces
 990 */
 991 OverConstrainedFace_i::OverConstrainedFace_i()
 992 {
 993   Controls::PredicatePtr control( new Controls::OverConstrainedFace() );
 994   myFunctorPtr = myPredicatePtr = control;
 995 };
 996
 997 FunctorType OverConstrainedFace_i::GetFunctorType()
 998 {
 999   return SMESH::FT_OverConstrainedFace;
1000 }
1001
1002 /*
1003   Class       : BelongToGeom_i
1004   Description : Predicate for selection on geometrical support
1005 */
1006 BelongToGeom_i::BelongToGeom_i()
1007 {
1008   myBelongToGeomPtr.reset( new Controls::BelongToGeom() );
1009   myFunctorPtr = myPredicatePtr = myBelongToGeomPtr;
1010   myShapeName = 0;
1011   myShapeID   = 0;
1012 }
1013
1014 BelongToGeom_i::~BelongToGeom_i()
1015 {
1016   delete myShapeName;
1017   delete myShapeID;
1018 }
1019
1020 void BelongToGeom_i::SetGeom( GEOM::GEOM_Object_ptr theGeom )
1021 {
1022   if ( theGeom->_is_nil() )
1023     return;
1024   SMESH_Gen_i* aSMESHGen = SMESH_Gen_i::GetSMESHGen();
1025   GEOM::GEOM_Gen_ptr aGEOMGen = SMESH_Gen_i::GetGeomEngine();
1026   TopoDS_Shape aLocShape = aSMESHGen->GetShapeReader()->GetShape( aGEOMGen, theGeom );
1027   myBelongToGeomPtr->SetGeom( aLocShape );
1028   TPythonDump()<<this<<".SetGeom("<<theGeom<<")";
1029 }
1030
1031 void BelongToGeom_i::SetGeom( const TopoDS_Shape& theShape )
1032 {
1033   myBelongToGeomPtr->SetGeom( theShape );
1034 }
1035
1036 void BelongToGeom_i::SetElementType(ElementType theType){
1037   myBelongToGeomPtr->SetType(SMDSAbs_ElementType(theType));
1038   TPythonDump()<<this<<".SetElementType("<<theType<<")";
1039 }
1040
1041 FunctorType BelongToGeom_i::GetFunctorType()
1042 {
1043   return SMESH::FT_BelongToGeom;
1044 }
1045
1046 void BelongToGeom_i::SetShapeName( const char* theName )
1047 {
1048   delete myShapeName;
1049   myShapeName = strdup( theName );
1050   myBelongToGeomPtr->SetGeom( getShapeByName( myShapeName ) );
1051   TPythonDump()<<this<<".SetShapeName('"<<theName<<"')";
1052 }
1053
1054 void BelongToGeom_i::SetShape( const char* theID, const char* theName )
1055 {
1056   delete myShapeName;
1057   myShapeName = strdup( theName );
1058   delete myShapeID;
1059   if ( theID )
1060     myShapeID = strdup( theID );
1061   else
1062     myShapeID = 0;
1063
1064   if ( myShapeID && myShapeName == getShapeNameByID(myShapeID))
1065     myBelongToGeomPtr->SetGeom( getShapeByID(myShapeID) );
1066   else
1067     myBelongToGeomPtr->SetGeom( getShapeByName( myShapeName ) );
1068 }
1069
1070 char* BelongToGeom_i::GetShapeName()
1071 {
1072   return CORBA::string_dup( myShapeName );
1073 }
1074
1075 char* BelongToGeom_i::GetShapeID()
1076 {
1077   return CORBA::string_dup( myShapeID );
1078 }
1079
1080 void BelongToGeom_i::SetTolerance( CORBA::Double theToler )
1081 {
1082   myBelongToGeomPtr->SetTolerance( theToler );
1083   TPythonDump()<<this<<".SetTolerance("<<theToler<<")";
1084 }
1085
1086 CORBA::Double BelongToGeom_i::GetTolerance()
1087 {
1088   return myBelongToGeomPtr->GetTolerance();
1089 }
1090
1091 /*
1092   Class       : BelongToSurface_i
1093   Description : Predicate for selection on geometrical support
1094 */
1095 BelongToSurface_i::BelongToSurface_i( const Handle(Standard_Type)& theSurfaceType )
1096 {
1097   myElementsOnSurfacePtr.reset( new Controls::ElementsOnSurface() );
1098   myFunctorPtr = myPredicatePtr = myElementsOnSurfacePtr;
1099   myShapeName = 0;
1100   myShapeID   = 0;
1101   mySurfaceType = theSurfaceType;
1102 }
1103
1104 BelongToSurface_i::~BelongToSurface_i()
1105 {
1106   delete myShapeName;
1107   delete myShapeID;
1108 }
1109
1110 void BelongToSurface_i::SetSurface( GEOM::GEOM_Object_ptr theGeom, ElementType theType )
1111 {
1112   if ( theGeom->_is_nil() )
1113     return;
1114   SMESH_Gen_i* aSMESHGen = SMESH_Gen_i::GetSMESHGen();
1115   GEOM::GEOM_Gen_ptr aGEOMGen = SMESH_Gen_i::GetGeomEngine();
1116   TopoDS_Shape aLocShape = aSMESHGen->GetShapeReader()->GetShape( aGEOMGen, theGeom );
1117
1118   if ( aLocShape.ShapeType() == TopAbs_FACE )
1119   {
1120     Handle(Geom_Surface) aSurf = BRep_Tool::Surface( TopoDS::Face( aLocShape ) );
1121     if ( !aSurf.IsNull() && aSurf->DynamicType() == mySurfaceType )
1122     {
1123       myElementsOnSurfacePtr->SetSurface( aLocShape, (SMDSAbs_ElementType)theType );
1124       return;
1125     }
1126   }
1127
1128   myElementsOnSurfacePtr->SetSurface( TopoDS_Shape(), (SMDSAbs_ElementType)theType );
1129 }
1130
1131 void BelongToSurface_i::SetShapeName( const char* theName, ElementType theType )
1132 {
1133   delete myShapeName;
1134   myShapeName = strdup( theName );
1135   myElementsOnSurfacePtr->SetSurface( getShapeByName( myShapeName ), (SMDSAbs_ElementType)theType );
1136   TPythonDump()<<this<<".SetShapeName('"<<theName<<"',"<<theType<<")";
1137 }
1138
1139 void BelongToSurface_i::SetShape( const char* theID,  const char* theName, ElementType theType )
1140 {
1141   delete myShapeName;
1142   myShapeName = strdup( theName );
1143   delete myShapeID;
1144   if ( theID )
1145     myShapeID = strdup( theID );
1146   else
1147     myShapeID = 0;
1148
1149   if ( myShapeID && myShapeName == getShapeNameByID(myShapeID))
1150     myElementsOnSurfacePtr->SetSurface( getShapeByID(myShapeID), (SMDSAbs_ElementType)theType );
1151   else
1152     myElementsOnSurfacePtr->SetSurface( getShapeByName( myShapeName ), (SMDSAbs_ElementType)theType );
1153 }
1154
1155 char* BelongToSurface_i::GetShapeName()
1156 {
1157   return CORBA::string_dup( myShapeName );
1158 }
1159
1160 char* BelongToSurface_i::GetShapeID()
1161 {
1162   return CORBA::string_dup( myShapeID );
1163 }
1164
1165 void BelongToSurface_i::SetTolerance( CORBA::Double theToler )
1166 {
1167   myElementsOnSurfacePtr->SetTolerance( theToler );
1168   TPythonDump()<<this<<".SetTolerance("<<theToler<<")";
1169 }
1170
1171 CORBA::Double BelongToSurface_i::GetTolerance()
1172 {
1173   return myElementsOnSurfacePtr->GetTolerance();
1174 }
1175
1176 void BelongToSurface_i::SetUseBoundaries( CORBA::Boolean theUseBndRestrictions )
1177 {
1178   myElementsOnSurfacePtr->SetUseBoundaries( theUseBndRestrictions );
1179   TPythonDump()<<this<<".SetUseBoundaries( " << theUseBndRestrictions << " )";
1180 }
1181
1182 CORBA::Boolean BelongToSurface_i::GetUseBoundaries()
1183 {
1184   return myElementsOnSurfacePtr->GetUseBoundaries();
1185 }
1186
1187
1188 /*
1189   Class       : BelongToPlane_i
1190   Description : Verify whether mesh element lie in pointed Geom planar object
1191 */
1192
1193 BelongToPlane_i::BelongToPlane_i()
1194 : BelongToSurface_i( STANDARD_TYPE( Geom_Plane ) )
1195 {
1196 }
1197
1198 void BelongToPlane_i::SetPlane( GEOM::GEOM_Object_ptr theGeom, ElementType theType )
1199 {
1200   BelongToSurface_i::SetSurface( theGeom, theType );
1201   TPythonDump()<<this<<".SetPlane("<<theGeom<<","<<theType<<")";
1202 }
1203
1204 FunctorType BelongToPlane_i::GetFunctorType()
1205 {
1206   return FT_BelongToPlane;
1207 }
1208
1209 /*
1210   Class       : BelongToCylinder_i
1211   Description : Verify whether mesh element lie in pointed Geom planar object
1212 */
1213
1214 BelongToCylinder_i::BelongToCylinder_i()
1215 : BelongToSurface_i( STANDARD_TYPE( Geom_CylindricalSurface ) )
1216 {
1217 }
1218
1219 void BelongToCylinder_i::SetCylinder( GEOM::GEOM_Object_ptr theGeom, ElementType theType )
1220 {
1221   BelongToSurface_i::SetSurface( theGeom, theType );
1222   TPythonDump()<<this<<".SetCylinder("<<theGeom<<","<<theType<<")";
1223 }
1224
1225 FunctorType BelongToCylinder_i::GetFunctorType()
1226 {
1227   return FT_BelongToCylinder;
1228 }
1229
1230 /*
1231   Class       : BelongToGenSurface_i
1232   Description : Verify whether mesh element lie in pointed Geom planar object
1233 */
1234
1235 BelongToGenSurface_i::BelongToGenSurface_i()
1236 : BelongToSurface_i( STANDARD_TYPE( Geom_CylindricalSurface ) )
1237 {
1238 }
1239
1240 void BelongToGenSurface_i::SetSurface( GEOM::GEOM_Object_ptr theGeom, ElementType theType )
1241 {
1242   if ( theGeom->_is_nil() )
1243     return;
1244   TopoDS_Shape aLocShape = SMESH_Gen_i::GetSMESHGen()->GeomObjectToShape( theGeom );
1245   if ( !aLocShape.IsNull() && aLocShape.ShapeType() != TopAbs_FACE )
1246     aLocShape.Nullify();
1247
1248   BelongToSurface_i::myElementsOnSurfacePtr->SetSurface( aLocShape, (SMDSAbs_ElementType)theType );
1249   TPythonDump()<<this<<".SetGenSurface("<<theGeom<<","<<theType<<")";
1250 }
1251
1252 FunctorType BelongToGenSurface_i::GetFunctorType()
1253 {
1254   return FT_BelongToGenSurface;
1255 }
1256
1257 /*
1258   Class       : LyingOnGeom_i
1259   Description : Predicate for selection on geometrical support
1260 */
1261 LyingOnGeom_i::LyingOnGeom_i()
1262 {
1263   myLyingOnGeomPtr.reset( new Controls::LyingOnGeom() );
1264   myFunctorPtr = myPredicatePtr = myLyingOnGeomPtr;
1265   myShapeName = 0;
1266   myShapeID = 0;
1267 }
1268
1269 LyingOnGeom_i::~LyingOnGeom_i()
1270 {
1271   delete myShapeName;
1272   delete myShapeID;
1273 }
1274
1275 void LyingOnGeom_i::SetGeom( GEOM::GEOM_Object_ptr theGeom )
1276 {
1277   if ( theGeom->_is_nil() )
1278     return;
1279   SMESH_Gen_i* aSMESHGen = SMESH_Gen_i::GetSMESHGen();
1280   GEOM::GEOM_Gen_ptr aGEOMGen = SMESH_Gen_i::GetGeomEngine();
1281   TopoDS_Shape aLocShape = aSMESHGen->GetShapeReader()->GetShape( aGEOMGen, theGeom );
1282   myLyingOnGeomPtr->SetGeom( aLocShape );
1283   TPythonDump()<<this<<".SetGeom("<<theGeom<<")";
1284 }
1285
1286 void LyingOnGeom_i::SetGeom( const TopoDS_Shape& theShape )
1287 {
1288   myLyingOnGeomPtr->SetGeom( theShape );
1289 }
1290
1291 void LyingOnGeom_i::SetElementType(ElementType theType){
1292   myLyingOnGeomPtr->SetType(SMDSAbs_ElementType(theType));
1293   TPythonDump()<<this<<".SetElementType("<<theType<<")";
1294 }
1295
1296 FunctorType LyingOnGeom_i::GetFunctorType()
1297 {
1298   return SMESH::FT_LyingOnGeom;
1299 }
1300
1301 void LyingOnGeom_i::SetShapeName( const char* theName )
1302 {
1303   delete myShapeName;
1304   myShapeName = strdup( theName );
1305   myLyingOnGeomPtr->SetGeom( getShapeByName( myShapeName ) );
1306   TPythonDump()<<this<<".SetShapeName('"<<theName<<"')";
1307 }
1308
1309 void LyingOnGeom_i::SetShape( const char* theID, const char* theName )
1310 {
1311   delete myShapeName;
1312   myShapeName = strdup( theName );
1313   delete myShapeID;
1314   if ( theID )
1315     myShapeID = strdup( theID );
1316   else
1317     myShapeID = 0;
1318
1319   if ( myShapeID && myShapeName == getShapeNameByID(myShapeID))
1320     myLyingOnGeomPtr->SetGeom( getShapeByID(myShapeID) );
1321   else
1322     myLyingOnGeomPtr->SetGeom( getShapeByName( myShapeName ) );
1323 }
1324
1325 char* LyingOnGeom_i::GetShapeName()
1326 {
1327   return CORBA::string_dup( myShapeName );
1328 }
1329
1330 char* LyingOnGeom_i::GetShapeID()
1331 {
1332   return CORBA::string_dup( myShapeID );
1333 }
1334
1335 void LyingOnGeom_i::SetTolerance( CORBA::Double theToler )
1336 {
1337   myLyingOnGeomPtr->SetTolerance( theToler );
1338   TPythonDump()<<this<<".SetTolerance("<<theToler<<")";
1339 }
1340
1341 CORBA::Double LyingOnGeom_i::GetTolerance()
1342 {
1343   return myLyingOnGeomPtr->GetTolerance();
1344 }
1345
1346 /*
1347   Class       : FreeBorders_i
1348   Description : Predicate for free borders
1349 */
1350 FreeBorders_i::FreeBorders_i()
1351 {
1352   myPredicatePtr.reset(new Controls::FreeBorders());
1353   myFunctorPtr = myPredicatePtr;
1354 }
1355
1356 FunctorType FreeBorders_i::GetFunctorType()
1357 {
1358   return SMESH::FT_FreeBorders;
1359 }
1360
1361 /*
1362   Class       : FreeEdges_i
1363   Description : Predicate for free borders
1364 */
1365 FreeEdges_i::FreeEdges_i()
1366 : myFreeEdgesPtr( new Controls::FreeEdges() )
1367 {
1368   myFunctorPtr = myPredicatePtr = myFreeEdgesPtr;
1369 }
1370
1371 SMESH::FreeEdges::Borders* FreeEdges_i::GetBorders()
1372 {
1373   INFOS("FreeEdges_i::GetBorders");
1374   SMESH::Controls::FreeEdges::TBorders aBorders;
1375   myFreeEdgesPtr->GetBoreders( aBorders );
1376
1377   long i = 0, iEnd = aBorders.size();
1378
1379   SMESH::FreeEdges::Borders_var aResult = new SMESH::FreeEdges::Borders;
1380   aResult->length(iEnd);
1381
1382   SMESH::Controls::FreeEdges::TBorders::const_iterator anIter;
1383   for ( anIter = aBorders.begin() ; anIter != aBorders.end(); anIter++, i++ )
1384   {
1385     const SMESH::Controls::FreeEdges::Border&  aBord = *anIter;
1386     SMESH::FreeEdges::Border &aBorder = aResult[ i ];
1387
1388     aBorder.myElemId = aBord.myElemId;
1389     aBorder.myPnt1 = aBord.myPntId[ 0 ];
1390     aBorder.myPnt2 = aBord.myPntId[ 1 ];
1391   }
1392
1393   INFOS("FreeEdges_i::GetBorders~");
1394   return aResult._retn();
1395 }
1396
1397 FunctorType FreeEdges_i::GetFunctorType()
1398 {
1399   return SMESH::FT_FreeEdges;
1400 }
1401
1402 /*
1403   Class       : FreeFaces_i
1404   Description : Predicate for free faces
1405 */
1406 FreeFaces_i::FreeFaces_i()
1407 {
1408   myPredicatePtr.reset(new Controls::FreeFaces());
1409   myFunctorPtr = myPredicatePtr;
1410 }
1411
1412 FunctorType FreeFaces_i::GetFunctorType()
1413 {
1414   return SMESH::FT_FreeFaces;
1415 }
1416
1417 /*
1418   Class       : FreeNodes_i
1419   Description : Predicate for free nodes
1420 */
1421 FreeNodes_i::FreeNodes_i()
1422 {
1423   myPredicatePtr.reset(new Controls::FreeNodes());
1424   myFunctorPtr = myPredicatePtr;
1425 }
1426
1427 FunctorType FreeNodes_i::GetFunctorType()
1428 {
1429   return SMESH::FT_FreeNodes;
1430 }
1431
1432 /*
1433   Class       : EqualNodes_i
1434   Description : Predicate for Equal nodes
1435 */
1436 EqualNodes_i::EqualNodes_i()
1437 {
1438   myCoincidentNodesPtr.reset(new Controls::CoincidentNodes());
1439   myFunctorPtr = myPredicatePtr = myCoincidentNodesPtr;
1440 }
1441
1442 FunctorType EqualNodes_i::GetFunctorType()
1443 {
1444   return SMESH::FT_EqualNodes;
1445 }
1446
1447 void EqualNodes_i::SetTolerance( double tol )
1448 {
1449   myCoincidentNodesPtr->SetTolerance( tol );
1450 }
1451
1452 double EqualNodes_i::GetTolerance()
1453 {
1454   return myCoincidentNodesPtr->GetTolerance();
1455 }
1456
1457 /*
1458   Class       : EqualEdges_i
1459   Description : Predicate for Equal Edges
1460 */
1461 EqualEdges_i::EqualEdges_i()
1462 {
1463   myPredicatePtr.reset(new Controls::CoincidentElements1D());
1464   myFunctorPtr = myPredicatePtr;
1465 }
1466
1467 FunctorType EqualEdges_i::GetFunctorType()
1468 {
1469   return SMESH::FT_EqualEdges;
1470 }
1471
1472 /*
1473   Class       : EqualFaces_i
1474   Description : Predicate for Equal Faces
1475 */
1476 EqualFaces_i::EqualFaces_i()
1477 {
1478   myPredicatePtr.reset(new Controls::CoincidentElements2D());
1479   myFunctorPtr = myPredicatePtr;
1480 }
1481
1482 FunctorType EqualFaces_i::GetFunctorType()
1483 {
1484   return SMESH::FT_EqualFaces;
1485 }
1486
1487 /*
1488   Class       : EqualVolumes_i
1489   Description : Predicate for Equal Volumes
1490 */
1491 EqualVolumes_i::EqualVolumes_i()
1492 {
1493   myPredicatePtr.reset(new Controls::CoincidentElements3D());
1494   myFunctorPtr = myPredicatePtr;
1495 }
1496
1497 FunctorType EqualVolumes_i::GetFunctorType()
1498 {
1499   return SMESH::FT_EqualVolumes;
1500 }
1501
1502
1503 /*
1504   Class       : RangeOfIds_i
1505   Description : Predicate for Range of Ids.
1506                 Range may be specified with two ways.
1507                 1. Using AddToRange method
1508                 2. With SetRangeStr method. Parameter of this method is a string
1509                    like as "1,2,3,50-60,63,67,70-"
1510 */
1511
1512 RangeOfIds_i::RangeOfIds_i()
1513 {
1514   myRangeOfIdsPtr.reset( new Controls::RangeOfIds() );
1515   myFunctorPtr = myPredicatePtr = myRangeOfIdsPtr;
1516 }
1517
1518 void RangeOfIds_i::SetRange( const SMESH::long_array& theIds )
1519 {
1520   CORBA::Long iEnd = theIds.length();
1521   for ( CORBA::Long i = 0; i < iEnd; i++ )
1522     myRangeOfIdsPtr->AddToRange( theIds[ i ] );
1523   TPythonDump()<<this<<".SetRange("<<theIds<<")";
1524 }
1525
1526 CORBA::Boolean RangeOfIds_i::SetRangeStr( const char* theRange )
1527 {
1528   TPythonDump()<<this<<".SetRangeStr('"<<theRange<<"')";
1529   return myRangeOfIdsPtr->SetRangeStr(
1530     TCollection_AsciiString( (Standard_CString)theRange ) );
1531 }
1532
1533 char* RangeOfIds_i::GetRangeStr()
1534 {
1535   TCollection_AsciiString aStr;
1536   myRangeOfIdsPtr->GetRangeStr( aStr );
1537   return CORBA::string_dup( aStr.ToCString() );
1538 }
1539
1540 void RangeOfIds_i::SetElementType( ElementType theType )
1541 {
1542   myRangeOfIdsPtr->SetType( SMDSAbs_ElementType( theType ) );
1543   TPythonDump()<<this<<".SetElementType("<<theType<<")";
1544 }
1545
1546 FunctorType RangeOfIds_i::GetFunctorType()
1547 {
1548   return SMESH::FT_RangeOfIds;
1549 }
1550
1551 /*
1552   Class       : LinearOrQuadratic_i
1553   Description : Predicate to verify whether a mesh element is linear
1554 */
1555 LinearOrQuadratic_i::LinearOrQuadratic_i()
1556 {
1557   myLinearOrQuadraticPtr.reset(new Controls::LinearOrQuadratic());
1558   myFunctorPtr = myPredicatePtr = myLinearOrQuadraticPtr;
1559 }
1560
1561 void LinearOrQuadratic_i::SetElementType(ElementType theType)
1562 {
1563   myLinearOrQuadraticPtr->SetType(SMDSAbs_ElementType(theType));
1564   TPythonDump()<<this<<".SetElementType("<<theType<<")";
1565 }
1566
1567 FunctorType LinearOrQuadratic_i::GetFunctorType()
1568 {
1569   return SMESH::FT_LinearOrQuadratic;
1570 }
1571
1572 /*
1573   Class       : GroupColor_i
1574   Description : Functor for check color of group to whic mesh element belongs to
1575 */
1576 GroupColor_i::GroupColor_i()
1577 {
1578   myGroupColorPtr.reset(new Controls::GroupColor());
1579   myFunctorPtr = myPredicatePtr = myGroupColorPtr;
1580 }
1581
1582 FunctorType GroupColor_i::GetFunctorType()
1583 {
1584   return SMESH::FT_GroupColor;
1585 }
1586
1587 void GroupColor_i::SetColorStr( const char* theColor )
1588 {
1589   myGroupColorPtr->SetColorStr(
1590     TCollection_AsciiString( (Standard_CString)theColor ) );
1591   TPythonDump()<<this<<".SetColorStr('"<<theColor<<"')";
1592 }
1593
1594 char* GroupColor_i::GetColorStr()
1595 {
1596   TCollection_AsciiString aStr;
1597   myGroupColorPtr->GetColorStr( aStr );
1598   return CORBA::string_dup( aStr.ToCString() );
1599 }
1600
1601 void GroupColor_i::SetElementType(ElementType theType)
1602 {
1603   myGroupColorPtr->SetType(SMDSAbs_ElementType(theType));
1604   TPythonDump()<<this<<".SetElementType("<<theType<<")";
1605 }
1606
1607 /*
1608   Class       : ElemGeomType_i
1609   Description : Predicate check is element has indicated geometry type
1610 */
1611 ElemGeomType_i::ElemGeomType_i()
1612 {
1613   myElemGeomTypePtr.reset(new Controls::ElemGeomType());
1614   myFunctorPtr = myPredicatePtr = myElemGeomTypePtr;
1615 }
1616
1617 void ElemGeomType_i::SetElementType(ElementType theType)
1618 {
1619   myElemGeomTypePtr->SetType(SMDSAbs_ElementType(theType));
1620   TPythonDump()<<this<<".SetElementType("<<theType<<")";
1621 }
1622
1623 void ElemGeomType_i::SetGeometryType(GeometryType theType)
1624 {
1625   myElemGeomTypePtr->SetGeomType(SMDSAbs_GeometryType(theType));
1626   TPythonDump()<<this<<".SetGeometryType("<<theType<<")";
1627 }
1628
1629 GeometryType ElemGeomType_i::GetGeometryType() const
1630 {
1631   return (GeometryType)myElemGeomTypePtr->GetGeomType();
1632 }
1633
1634 FunctorType ElemGeomType_i::GetFunctorType()
1635 {
1636   return SMESH::FT_ElemGeomType;
1637 }
1638
1639 /*
1640   Class       : ElemEntityType_i
1641   Description : Predicate check is element has indicated entity type
1642 */
1643 ElemEntityType_i::ElemEntityType_i()
1644 {
1645   myElemEntityTypePtr.reset(new Controls::ElemEntityType());
1646   myFunctorPtr = myPredicatePtr = myElemEntityTypePtr;
1647 }
1648
1649 void ElemEntityType_i::SetElementType(ElementType theType)
1650 {
1651   myElemEntityTypePtr->SetType(SMDSAbs_ElementType(theType));
1652   TPythonDump()<<this<<".SetElementType("<<theType<<")";
1653 }
1654
1655 void ElemEntityType_i::SetEntityType(EntityType theEntityType)
1656 {
1657   myElemEntityTypePtr->SetElemEntityType(SMDSAbs_EntityType (theEntityType));
1658   TPythonDump()<<this<<".SetEntityType("<<theEntityType<<")";
1659 }
1660 EntityType ElemEntityType_i::GetEntityType() const
1661 {
1662  return (EntityType) myElemEntityTypePtr->GetElemEntityType();
1663 }
1664
1665 FunctorType ElemEntityType_i::GetFunctorType()
1666 {
1667   return SMESH::FT_EntityType;
1668 }
1669
1670 /*
1671   Class       : CoplanarFaces_i
1672   Description : Returns true if a mesh face is a coplanar neighbour to a given one
1673 */
1674 CoplanarFaces_i::CoplanarFaces_i()
1675 {
1676   myCoplanarFacesPtr.reset(new Controls::CoplanarFaces());
1677   myFunctorPtr = myPredicatePtr = myCoplanarFacesPtr;
1678 }
1679
1680 void CoplanarFaces_i::SetFace ( CORBA::Long theFaceID )
1681 {
1682   myCoplanarFacesPtr->SetFace(theFaceID);
1683   TPythonDump()<<this<<".SetFace("<<theFaceID<<")";
1684 }
1685
1686 void CoplanarFaces_i::SetTolerance( CORBA::Double theToler )
1687 {
1688   myCoplanarFacesPtr->SetTolerance(theToler);
1689   TPythonDump()<<this<<".SetTolerance("<<theToler<<")";
1690 }
1691
1692 CORBA::Long CoplanarFaces_i::GetFace () const
1693 {
1694   return myCoplanarFacesPtr->GetFace();
1695 }
1696
1697 char* CoplanarFaces_i::GetFaceAsString () const
1698 {
1699   TCollection_AsciiString str(Standard_Integer(myCoplanarFacesPtr->GetFace()));
1700   return CORBA::string_dup( str.ToCString() );
1701 }
1702
1703 CORBA::Double CoplanarFaces_i::GetTolerance() const
1704 {
1705   return myCoplanarFacesPtr->GetTolerance();
1706 }
1707
1708 FunctorType CoplanarFaces_i::GetFunctorType()
1709 {
1710   return SMESH::FT_CoplanarFaces;
1711 }
1712
1713 /*
1714   Class       : Comparator_i
1715   Description : Base class for comparators
1716 */
1717 Comparator_i::Comparator_i():
1718   myNumericalFunctor( NULL )
1719 {}
1720
1721 Comparator_i::~Comparator_i()
1722 {
1723   if ( myNumericalFunctor )
1724     myNumericalFunctor->UnRegister();
1725 }
1726
1727 void Comparator_i::SetMargin( CORBA::Double theValue )
1728 {
1729   myComparatorPtr->SetMargin( theValue );
1730   TPythonDump()<<this<<".SetMargin("<<theValue<<")";
1731 }
1732
1733 CORBA::Double Comparator_i::GetMargin()
1734 {
1735   return myComparatorPtr->GetMargin();
1736 }
1737
1738 void Comparator_i::SetNumFunctor( NumericalFunctor_ptr theFunct )
1739 {
1740   if ( myNumericalFunctor )
1741     myNumericalFunctor->UnRegister();
1742
1743   myNumericalFunctor = DownCast<NumericalFunctor_i*>(theFunct);
1744
1745   if ( myNumericalFunctor )
1746   {
1747     myComparatorPtr->SetNumFunctor( myNumericalFunctor->GetNumericalFunctor() );
1748     myNumericalFunctor->Register();
1749     TPythonDump()<<this<<".SetNumFunctor("<<myNumericalFunctor<<")";
1750   }
1751 }
1752
1753 Controls::ComparatorPtr Comparator_i::GetComparator()
1754 {
1755   return myComparatorPtr;
1756 }
1757
1758 NumericalFunctor_i* Comparator_i::GetNumFunctor_i()
1759 {
1760   return myNumericalFunctor;
1761 }
1762
1763
1764 /*
1765   Class       : LessThan_i
1766   Description : Comparator "<"
1767 */
1768 LessThan_i::LessThan_i()
1769 {
1770   myComparatorPtr.reset( new Controls::LessThan() );
1771   myFunctorPtr = myPredicatePtr = myComparatorPtr;
1772 }
1773
1774 FunctorType LessThan_i::GetFunctorType()
1775 {
1776   return SMESH::FT_LessThan;
1777 }
1778
1779
1780 /*
1781   Class       : MoreThan_i
1782   Description : Comparator ">"
1783 */
1784 MoreThan_i::MoreThan_i()
1785 {
1786   myComparatorPtr.reset( new Controls::MoreThan() );
1787   myFunctorPtr = myPredicatePtr = myComparatorPtr;
1788 }
1789
1790 FunctorType MoreThan_i::GetFunctorType()
1791 {
1792   return SMESH::FT_MoreThan;
1793 }
1794
1795
1796 /*
1797   Class       : EqualTo_i
1798   Description : Comparator "="
1799 */
1800 EqualTo_i::EqualTo_i()
1801 : myEqualToPtr( new Controls::EqualTo() )
1802 {
1803   myFunctorPtr = myPredicatePtr = myComparatorPtr = myEqualToPtr;
1804 }
1805
1806 void EqualTo_i::SetTolerance( CORBA::Double theToler )
1807 {
1808   myEqualToPtr->SetTolerance( theToler );
1809   TPythonDump()<<this<<".SetTolerance("<<theToler<<")";
1810 }
1811
1812 CORBA::Double EqualTo_i::GetTolerance()
1813 {
1814   return myEqualToPtr->GetTolerance();
1815 }
1816
1817 FunctorType EqualTo_i::GetFunctorType()
1818 {
1819   return SMESH::FT_EqualTo;
1820 }
1821
1822 /*
1823   Class       : LogicalNOT_i
1824   Description : Logical NOT predicate
1825 */
1826 LogicalNOT_i::LogicalNOT_i()
1827 : myPredicate( NULL ),
1828   myLogicalNOTPtr( new Controls::LogicalNOT() )
1829 {
1830   myFunctorPtr = myPredicatePtr = myLogicalNOTPtr;
1831 }
1832
1833 LogicalNOT_i::~LogicalNOT_i()
1834 {
1835   if ( myPredicate )
1836     myPredicate->UnRegister();
1837 }
1838
1839 void LogicalNOT_i::SetPredicate( Predicate_ptr thePredicate )
1840 {
1841   if ( myPredicate )
1842     myPredicate->UnRegister();
1843
1844   myPredicate = SMESH::GetPredicate(thePredicate);
1845
1846   if ( myPredicate ){
1847     myLogicalNOTPtr->SetPredicate(myPredicate->GetPredicate());
1848     myPredicate->Register();
1849     TPythonDump()<<this<<".SetPredicate("<<myPredicate<<")";
1850   }
1851 }
1852
1853 FunctorType LogicalNOT_i::GetFunctorType()
1854 {
1855   return SMESH::FT_LogicalNOT;
1856 }
1857
1858 Predicate_i* LogicalNOT_i::GetPredicate_i()
1859 {
1860   return myPredicate;
1861 }
1862
1863
1864 /*
1865   Class       : LogicalBinary_i
1866   Description : Base class for binary logical predicate
1867 */
1868 LogicalBinary_i::LogicalBinary_i()
1869 : myPredicate1( NULL ),
1870   myPredicate2( NULL )
1871 {}
1872
1873 LogicalBinary_i::~LogicalBinary_i()
1874 {
1875   if ( myPredicate1 )
1876     myPredicate1->UnRegister();
1877
1878   if ( myPredicate2 )
1879     myPredicate2->UnRegister();
1880 }
1881
1882 void LogicalBinary_i::SetMesh( SMESH_Mesh_ptr theMesh )
1883 {
1884   if ( myPredicate1 )
1885     myPredicate1->SetMesh( theMesh );
1886
1887   if ( myPredicate2 )
1888     myPredicate2->SetMesh( theMesh );
1889 }
1890
1891 void LogicalBinary_i::SetPredicate1( Predicate_ptr thePredicate )
1892 {
1893   if ( myPredicate1 )
1894     myPredicate1->UnRegister();
1895
1896   myPredicate1 = SMESH::GetPredicate(thePredicate);
1897
1898   if ( myPredicate1 ){
1899     myLogicalBinaryPtr->SetPredicate1(myPredicate1->GetPredicate());
1900     myPredicate1->Register();
1901     TPythonDump()<<this<<".SetPredicate1("<<myPredicate1<<")";
1902   }
1903 }
1904
1905 void LogicalBinary_i::SetPredicate2( Predicate_ptr thePredicate )
1906 {
1907   if ( myPredicate2 )
1908     myPredicate2->UnRegister();
1909
1910   myPredicate2 = SMESH::GetPredicate(thePredicate);
1911
1912   if ( myPredicate2 ){
1913     myLogicalBinaryPtr->SetPredicate2(myPredicate2->GetPredicate());
1914     myPredicate2->Register();
1915     TPythonDump()<<this<<".SetPredicate2("<<myPredicate2<<")";
1916   }
1917 }
1918
1919 Controls::LogicalBinaryPtr LogicalBinary_i::GetLogicalBinary()
1920 {
1921   return myLogicalBinaryPtr;
1922 }
1923
1924 Predicate_i* LogicalBinary_i::GetPredicate1_i()
1925 {
1926   return myPredicate1;
1927 }
1928 Predicate_i* LogicalBinary_i::GetPredicate2_i()
1929 {
1930   return myPredicate2;
1931 }
1932
1933
1934 /*
1935   Class       : LogicalAND_i
1936   Description : Logical AND
1937 */
1938 LogicalAND_i::LogicalAND_i()
1939 {
1940   myLogicalBinaryPtr.reset( new Controls::LogicalAND() );
1941   myFunctorPtr = myPredicatePtr = myLogicalBinaryPtr;
1942 }
1943
1944 FunctorType LogicalAND_i::GetFunctorType()
1945 {
1946   return SMESH::FT_LogicalAND;
1947 }
1948
1949
1950 /*
1951   Class       : LogicalOR_i
1952   Description : Logical OR
1953 */
1954 LogicalOR_i::LogicalOR_i()
1955 {
1956   myLogicalBinaryPtr.reset( new Controls::LogicalOR() );
1957   myFunctorPtr = myPredicatePtr = myLogicalBinaryPtr;
1958 }
1959
1960 FunctorType LogicalOR_i::GetFunctorType()
1961 {
1962   return SMESH::FT_LogicalOR;
1963 }
1964
1965
1966 /*
1967                             FILTER MANAGER
1968 */
1969
1970 FilterManager_i::FilterManager_i()
1971 : SALOME::GenericObj_i( SMESH_Gen_i::GetPOA() )
1972 {
1973   //Base class Salome_GenericObject do it inmplicitly by overriding PortableServer::POA_ptr _default_POA() method
1974   //PortableServer::ObjectId_var anObjectId =
1975   //  SMESH_Gen_i::GetPOA()->activate_object( this );
1976 }
1977
1978
1979 FilterManager_i::~FilterManager_i()
1980 {
1981   //TPythonDump()<<this<<".UnRegister()";
1982 }
1983
1984
1985 MinimumAngle_ptr FilterManager_i::CreateMinimumAngle()
1986 {
1987   SMESH::MinimumAngle_i* aServant = new SMESH::MinimumAngle_i();
1988   SMESH::MinimumAngle_var anObj = aServant->_this();
1989   TPythonDump()<<aServant<<" = "<<this<<".CreateMinimumAngle()";
1990   return anObj._retn();
1991 }
1992
1993
1994 AspectRatio_ptr FilterManager_i::CreateAspectRatio()
1995 {
1996   SMESH::AspectRatio_i* aServant = new SMESH::AspectRatio_i();
1997   SMESH::AspectRatio_var anObj = aServant->_this();
1998   TPythonDump()<<aServant<<" = "<<this<<".CreateAspectRatio()";
1999   return anObj._retn();
2000 }
2001
2002
2003 AspectRatio3D_ptr FilterManager_i::CreateAspectRatio3D()
2004 {
2005   SMESH::AspectRatio3D_i* aServant = new SMESH::AspectRatio3D_i();
2006   SMESH::AspectRatio3D_var anObj = aServant->_this();
2007   TPythonDump()<<aServant<<" = "<<this<<".CreateAspectRatio3D()";
2008   return anObj._retn();
2009 }
2010
2011
2012 Warping_ptr FilterManager_i::CreateWarping()
2013 {
2014   SMESH::Warping_i* aServant = new SMESH::Warping_i();
2015   SMESH::Warping_var anObj = aServant->_this();
2016   TPythonDump()<<aServant<<" = "<<this<<".CreateWarping()";
2017   return anObj._retn();
2018 }
2019
2020
2021 Taper_ptr FilterManager_i::CreateTaper()
2022 {
2023   SMESH::Taper_i* aServant = new SMESH::Taper_i();
2024   SMESH::Taper_var anObj = aServant->_this();
2025   TPythonDump()<<aServant<<" = "<<this<<".CreateTaper()";
2026   return anObj._retn();
2027 }
2028
2029
2030 Skew_ptr FilterManager_i::CreateSkew()
2031 {
2032   SMESH::Skew_i* aServant = new SMESH::Skew_i();
2033   SMESH::Skew_var anObj = aServant->_this();
2034   TPythonDump()<<aServant<<" = "<<this<<".CreateSkew()";
2035   return anObj._retn();
2036 }
2037
2038
2039 Area_ptr FilterManager_i::CreateArea()
2040 {
2041   SMESH::Area_i* aServant = new SMESH::Area_i();
2042   SMESH::Area_var anObj = aServant->_this();
2043   TPythonDump()<<aServant<<" = "<<this<<".CreateArea()";
2044   return anObj._retn();
2045 }
2046
2047
2048 Volume3D_ptr FilterManager_i::CreateVolume3D()
2049 {
2050   SMESH::Volume3D_i* aServant = new SMESH::Volume3D_i();
2051   SMESH::Volume3D_var anObj = aServant->_this();
2052   TPythonDump()<<aServant<<" = "<<this<<".CreateVolume3D()";
2053   return anObj._retn();
2054 }
2055
2056
2057 MaxElementLength2D_ptr FilterManager_i::CreateMaxElementLength2D()
2058 {
2059   SMESH::MaxElementLength2D_i* aServant = new SMESH::MaxElementLength2D_i();
2060   SMESH::MaxElementLength2D_var anObj = aServant->_this();
2061   TPythonDump()<<aServant<<" = "<<this<<".CreateMaxElementLength2D()";
2062   return anObj._retn();
2063 }
2064
2065
2066 MaxElementLength3D_ptr FilterManager_i::CreateMaxElementLength3D()
2067 {
2068   SMESH::MaxElementLength3D_i* aServant = new SMESH::MaxElementLength3D_i();
2069   SMESH::MaxElementLength3D_var anObj = aServant->_this();
2070   TPythonDump()<<aServant<<" = "<<this<<".CreateMaxElementLength3D()";
2071   return anObj._retn();
2072 }
2073
2074
2075 Length_ptr FilterManager_i::CreateLength()
2076 {
2077   SMESH::Length_i* aServant = new SMESH::Length_i();
2078   SMESH::Length_var anObj = aServant->_this();
2079   TPythonDump()<<aServant<<" = "<<this<<".CreateLength()";
2080   return anObj._retn();
2081 }
2082
2083 Length2D_ptr FilterManager_i::CreateLength2D()
2084 {
2085   SMESH::Length2D_i* aServant = new SMESH::Length2D_i();
2086   SMESH::Length2D_var anObj = aServant->_this();
2087   TPythonDump()<<aServant<<" = "<<this<<".CreateLength2D()";
2088   return anObj._retn();
2089 }
2090
2091 MultiConnection_ptr FilterManager_i::CreateMultiConnection()
2092 {
2093   SMESH::MultiConnection_i* aServant = new SMESH::MultiConnection_i();
2094   SMESH::MultiConnection_var anObj = aServant->_this();
2095   TPythonDump()<<aServant<<" = "<<this<<".CreateMultiConnection()";
2096   return anObj._retn();
2097 }
2098
2099 MultiConnection2D_ptr FilterManager_i::CreateMultiConnection2D()
2100 {
2101   SMESH::MultiConnection2D_i* aServant = new SMESH::MultiConnection2D_i();
2102   SMESH::MultiConnection2D_var anObj = aServant->_this();
2103   TPythonDump()<<aServant<<" = "<<this<<".CreateMultiConnection2D()";
2104   return anObj._retn();
2105 }
2106
2107 BallDiameter_ptr FilterManager_i::CreateBallDiameter()
2108 {
2109   SMESH::BallDiameter_i* aServant = new SMESH::BallDiameter_i();
2110   SMESH::BallDiameter_var anObj = aServant->_this();
2111   TPythonDump()<<aServant<<" = "<<this<<".CreateBallDiameter()";
2112   return anObj._retn();
2113 }
2114
2115 BelongToGeom_ptr FilterManager_i::CreateBelongToGeom()
2116 {
2117   SMESH::BelongToGeom_i* aServant = new SMESH::BelongToGeom_i();
2118   SMESH::BelongToGeom_var anObj = aServant->_this();
2119   TPythonDump()<<aServant<<" = "<<this<<".CreateBelongToGeom()";
2120   return anObj._retn();
2121 }
2122
2123 BelongToPlane_ptr FilterManager_i::CreateBelongToPlane()
2124 {
2125   SMESH::BelongToPlane_i* aServant = new SMESH::BelongToPlane_i();
2126   SMESH::BelongToPlane_var anObj = aServant->_this();
2127   TPythonDump()<<aServant<<" = "<<this<<".CreateBelongToPlane()";
2128   return anObj._retn();
2129 }
2130
2131 BelongToCylinder_ptr FilterManager_i::CreateBelongToCylinder()
2132 {
2133   SMESH::BelongToCylinder_i* aServant = new SMESH::BelongToCylinder_i();
2134   SMESH::BelongToCylinder_var anObj = aServant->_this();
2135   TPythonDump()<<aServant<<" = "<<this<<".CreateBelongToCylinder()";
2136   return anObj._retn();
2137 }
2138
2139 BelongToGenSurface_ptr FilterManager_i::CreateBelongToGenSurface()
2140 {
2141   SMESH::BelongToGenSurface_i* aServant = new SMESH::BelongToGenSurface_i();
2142   SMESH::BelongToGenSurface_var anObj = aServant->_this();
2143   TPythonDump()<<aServant<<" = "<<this<<".CreateBelongToGenSurface()";
2144   return anObj._retn();
2145 }
2146
2147 LyingOnGeom_ptr FilterManager_i::CreateLyingOnGeom()
2148 {
2149   SMESH::LyingOnGeom_i* aServant = new SMESH::LyingOnGeom_i();
2150   SMESH::LyingOnGeom_var anObj = aServant->_this();
2151   TPythonDump()<<aServant<<" = "<<this<<".CreateLyingOnGeom()";
2152   return anObj._retn();
2153 }
2154
2155 CoplanarFaces_ptr FilterManager_i::CreateCoplanarFaces()
2156 {
2157   SMESH::CoplanarFaces_i* aServant = new SMESH::CoplanarFaces_i();
2158   SMESH::CoplanarFaces_var anObj = aServant->_this();
2159   TPythonDump()<<aServant<<" = "<<this<<".CreateCoplanarFaces()";
2160   return anObj._retn();
2161 }
2162
2163 FreeBorders_ptr FilterManager_i::CreateFreeBorders()
2164 {
2165   SMESH::FreeBorders_i* aServant = new SMESH::FreeBorders_i();
2166   SMESH::FreeBorders_var anObj = aServant->_this();
2167   TPythonDump()<<aServant<<" = "<<this<<".CreateFreeBorders()";
2168   return anObj._retn();
2169 }
2170
2171 FreeEdges_ptr FilterManager_i::CreateFreeEdges()
2172 {
2173   SMESH::FreeEdges_i* aServant = new SMESH::FreeEdges_i();
2174   SMESH::FreeEdges_var anObj = aServant->_this();
2175   TPythonDump()<<aServant<<" = "<<this<<".CreateFreeEdges()";
2176   return anObj._retn();
2177 }
2178
2179 FreeFaces_ptr FilterManager_i::CreateFreeFaces()
2180 {
2181   SMESH::FreeFaces_i* aServant = new SMESH::FreeFaces_i();
2182   SMESH::FreeFaces_var anObj = aServant->_this();
2183   TPythonDump()<<aServant<<" = "<<this<<".CreateFreeFaces()";
2184   return anObj._retn();
2185 }
2186
2187 FreeNodes_ptr FilterManager_i::CreateFreeNodes()
2188 {
2189   SMESH::FreeNodes_i* aServant = new SMESH::FreeNodes_i();
2190   SMESH::FreeNodes_var anObj = aServant->_this();
2191   TPythonDump()<<aServant<<" = "<<this<<".CreateFreeNodes()";
2192   return anObj._retn();
2193 }
2194
2195 EqualNodes_ptr FilterManager_i::CreateEqualNodes()
2196 {
2197   SMESH::EqualNodes_i* aServant = new SMESH::EqualNodes_i();
2198   SMESH::EqualNodes_var anObj = aServant->_this();
2199   TPythonDump()<<aServant<<" = "<<this<<".CreateEqualNodes()";
2200   return anObj._retn();
2201 }
2202
2203 EqualEdges_ptr FilterManager_i::CreateEqualEdges()
2204 {
2205   SMESH::EqualEdges_i* aServant = new SMESH::EqualEdges_i();
2206   SMESH::EqualEdges_var anObj = aServant->_this();
2207   TPythonDump()<<aServant<<" = "<<this<<".CreateEqualEdges()";
2208   return anObj._retn();
2209 }
2210 EqualFaces_ptr FilterManager_i::CreateEqualFaces()
2211 {
2212   SMESH::EqualFaces_i* aServant = new SMESH::EqualFaces_i();
2213   SMESH::EqualFaces_var anObj = aServant->_this();
2214   TPythonDump()<<aServant<<" = "<<this<<".CreateEqualFaces()";
2215   return anObj._retn();
2216 }
2217 EqualVolumes_ptr FilterManager_i::CreateEqualVolumes()
2218 {
2219   SMESH::EqualVolumes_i* aServant = new SMESH::EqualVolumes_i();
2220   SMESH::EqualVolumes_var anObj = aServant->_this();
2221   TPythonDump()<<aServant<<" = "<<this<<".CreateEqualVolumes()";
2222   return anObj._retn();
2223 }
2224
2225 RangeOfIds_ptr FilterManager_i::CreateRangeOfIds()
2226 {
2227   SMESH::RangeOfIds_i* aServant = new SMESH::RangeOfIds_i();
2228   SMESH::RangeOfIds_var anObj = aServant->_this();
2229   TPythonDump()<<aServant<<" = "<<this<<".CreateRangeOfIds()";
2230   return anObj._retn();
2231 }
2232
2233 BadOrientedVolume_ptr FilterManager_i::CreateBadOrientedVolume()
2234 {
2235   SMESH::BadOrientedVolume_i* aServant = new SMESH::BadOrientedVolume_i();
2236   SMESH::BadOrientedVolume_var anObj = aServant->_this();
2237   TPythonDump()<<aServant<<" = "<<this<<".CreateBadOrientedVolume()";
2238   return anObj._retn();
2239 }
2240
2241 BareBorderVolume_ptr FilterManager_i::CreateBareBorderVolume()
2242 {
2243   SMESH::BareBorderVolume_i* aServant = new SMESH::BareBorderVolume_i();
2244   SMESH::BareBorderVolume_var anObj = aServant->_this();
2245   TPythonDump()<<aServant<<" = "<<this<<".CreateBareBorderVolume()";
2246   return anObj._retn();
2247 }
2248
2249 BareBorderFace_ptr FilterManager_i::CreateBareBorderFace()
2250 {
2251   SMESH::BareBorderFace_i* aServant = new SMESH::BareBorderFace_i();
2252   SMESH::BareBorderFace_var anObj = aServant->_this();
2253   TPythonDump()<<aServant<<" = "<<this<<".CreateBareBorderFace()";
2254   return anObj._retn();
2255 }
2256
2257 OverConstrainedVolume_ptr FilterManager_i::CreateOverConstrainedVolume()
2258 {
2259   SMESH::OverConstrainedVolume_i* aServant = new SMESH::OverConstrainedVolume_i();
2260   SMESH::OverConstrainedVolume_var anObj = aServant->_this();
2261   TPythonDump()<<aServant<<" = "<<this<<".CreateOverConstrainedVolume()";
2262   return anObj._retn();
2263 }
2264
2265 OverConstrainedFace_ptr FilterManager_i::CreateOverConstrainedFace()
2266 {
2267   SMESH::OverConstrainedFace_i* aServant = new SMESH::OverConstrainedFace_i();
2268   SMESH::OverConstrainedFace_var anObj = aServant->_this();
2269   TPythonDump()<<aServant<<" = "<<this<<".CreateOverConstrainedFace()";
2270   return anObj._retn();
2271 }
2272
2273 LessThan_ptr FilterManager_i::CreateLessThan()
2274 {
2275   SMESH::LessThan_i* aServant = new SMESH::LessThan_i();
2276   SMESH::LessThan_var anObj = aServant->_this();
2277   TPythonDump()<<aServant<<" = "<<this<<".CreateLessThan()";
2278   return anObj._retn();
2279 }
2280
2281 MoreThan_ptr FilterManager_i::CreateMoreThan()
2282 {
2283   SMESH::MoreThan_i* aServant = new SMESH::MoreThan_i();
2284   SMESH::MoreThan_var anObj = aServant->_this();
2285   TPythonDump()<<aServant<<" = "<<this<<".CreateMoreThan()";
2286   return anObj._retn();
2287 }
2288
2289 EqualTo_ptr FilterManager_i::CreateEqualTo()
2290 {
2291   SMESH::EqualTo_i* aServant = new SMESH::EqualTo_i();
2292   SMESH::EqualTo_var anObj = aServant->_this();
2293   TPythonDump()<<aServant<<" = "<<this<<".CreateEqualTo()";
2294   return anObj._retn();
2295 }
2296
2297 LogicalNOT_ptr FilterManager_i::CreateLogicalNOT()
2298 {
2299   SMESH::LogicalNOT_i* aServant = new SMESH::LogicalNOT_i();
2300   SMESH::LogicalNOT_var anObj = aServant->_this();
2301   TPythonDump()<<aServant<<" = "<<this<<".CreateLogicalNOT()";
2302   return anObj._retn();
2303 }
2304
2305 LogicalAND_ptr FilterManager_i::CreateLogicalAND()
2306 {
2307   SMESH::LogicalAND_i* aServant = new SMESH::LogicalAND_i();
2308   SMESH::LogicalAND_var anObj = aServant->_this();
2309   TPythonDump()<<aServant<<" = "<<this<<".CreateLogicalAND()";
2310   return anObj._retn();
2311 }
2312
2313 LogicalOR_ptr FilterManager_i::CreateLogicalOR()
2314 {
2315   SMESH::LogicalOR_i* aServant = new SMESH::LogicalOR_i();
2316   SMESH::LogicalOR_var anObj = aServant->_this();
2317   TPythonDump()<<aServant<<" = "<<this<<".CreateLogicalOR()";
2318   return anObj._retn();
2319 }
2320
2321 LinearOrQuadratic_ptr FilterManager_i::CreateLinearOrQuadratic()
2322 {
2323   SMESH::LinearOrQuadratic_i* aServant = new SMESH::LinearOrQuadratic_i();
2324   SMESH::LinearOrQuadratic_var anObj = aServant->_this();
2325   TPythonDump()<<aServant<<" = "<<this<<".CreateLinearOrQuadratic()";
2326   return anObj._retn();
2327 }
2328
2329 GroupColor_ptr FilterManager_i::CreateGroupColor()
2330 {
2331   SMESH::GroupColor_i* aServant = new SMESH::GroupColor_i();
2332   SMESH::GroupColor_var anObj = aServant->_this();
2333   TPythonDump()<<aServant<<" = "<<this<<".CreateGroupColor()";
2334   return anObj._retn();
2335 }
2336
2337 ElemGeomType_ptr FilterManager_i::CreateElemGeomType()
2338 {
2339   SMESH::ElemGeomType_i* aServant = new SMESH::ElemGeomType_i();
2340   SMESH::ElemGeomType_var anObj = aServant->_this();
2341   TPythonDump()<<aServant<<" = "<<this<<".CreateElemGeomType()";
2342   return anObj._retn();
2343 }
2344
2345 ElemEntityType_ptr FilterManager_i::CreateElemEntityType()
2346 {
2347   SMESH::ElemEntityType_i* aServant = new SMESH::ElemEntityType_i();
2348   SMESH::ElemEntityType_var anObj = aServant->_this();
2349   TPythonDump()<<aServant<<" = "<<this<<".CreateElemEntityType()";
2350   return anObj._retn();
2351 }
2352
2353 Filter_ptr FilterManager_i::CreateFilter()
2354 {
2355   SMESH::Filter_i* aServant = new SMESH::Filter_i();
2356   SMESH::Filter_var anObj = aServant->_this();
2357   TPythonDump()<<aServant<<" = "<<this<<".CreateFilter()";
2358   return anObj._retn();
2359 }
2360
2361 FilterLibrary_ptr FilterManager_i::LoadLibrary( const char* aFileName )
2362 {
2363   SMESH::FilterLibrary_i* aServant = new SMESH::FilterLibrary_i( aFileName );
2364   SMESH::FilterLibrary_var anObj = aServant->_this();
2365   TPythonDump()<<aServant<<" = "<<this<<".LoadLibrary('"<<aFileName<<"')";
2366   return anObj._retn();
2367 }
2368
2369 FilterLibrary_ptr FilterManager_i::CreateLibrary()
2370 {
2371   SMESH::FilterLibrary_i* aServant = new SMESH::FilterLibrary_i();
2372   SMESH::FilterLibrary_var anObj = aServant->_this();
2373   TPythonDump()<<aServant<<" = "<<this<<".CreateLibrary()";
2374   return anObj._retn();
2375 }
2376
2377 CORBA::Boolean FilterManager_i::DeleteLibrary( const char* aFileName )
2378 {
2379   TPythonDump()<<this<<".DeleteLibrary("<<aFileName<<")";
2380   return remove( aFileName ) ? false : true;
2381 }
2382
2383 //=============================================================================
2384 /*!
2385  *  SMESH_Gen_i::CreateFilterManager
2386  *
2387  *  Create filter manager
2388  */
2389 //=============================================================================
2390
2391 SMESH::FilterManager_ptr SMESH_Gen_i::CreateFilterManager()
2392 {
2393   SMESH::FilterManager_i* aFilter = new SMESH::FilterManager_i();
2394   SMESH::FilterManager_var anObj = aFilter->_this();
2395   return anObj._retn();
2396 }
2397
2398
2399 /*
2400                               FILTER
2401 */
2402
2403 //=======================================================================
2404 // name    : Filter_i::Filter_i
2405 // Purpose : Constructor
2406 //=======================================================================
2407 Filter_i::Filter_i()
2408 : myPredicate( NULL )
2409 {}
2410
2411 //=======================================================================
2412 // name    : Filter_i::~Filter_i
2413 // Purpose : Destructor
2414 //=======================================================================
2415 Filter_i::~Filter_i()
2416 {
2417   if ( myPredicate )
2418     myPredicate->UnRegister();
2419
2420   if(!CORBA::is_nil(myMesh))
2421     myMesh->UnRegister();
2422
2423   //TPythonDump()<<this<<".UnRegister()";
2424 }
2425
2426 //=======================================================================
2427 // name    : Filter_i::SetPredicate
2428 // Purpose : Set predicate
2429 //=======================================================================
2430 void Filter_i::SetPredicate( Predicate_ptr thePredicate )
2431 {
2432   if ( myPredicate )
2433     myPredicate->UnRegister();
2434
2435   myPredicate = SMESH::GetPredicate(thePredicate);
2436
2437   if ( myPredicate )
2438   {
2439     myFilter.SetPredicate( myPredicate->GetPredicate() );
2440     myPredicate->Register();
2441     if ( const SMDS_Mesh* aMesh = MeshPtr2SMDSMesh(myMesh))
2442       myPredicate->GetPredicate()->SetMesh( aMesh );
2443     TPythonDump()<<this<<".SetPredicate("<<myPredicate<<")";
2444   }
2445   std::list<TPredicateChangeWaiter*>::iterator i = myWaiters.begin();
2446   for ( ; i != myWaiters.end(); ++i )
2447     (*i)->PredicateChanged();
2448 }
2449
2450 //=======================================================================
2451 // name    : Filter_i::GetElementType
2452 // Purpose : Get entity type
2453 //=======================================================================
2454 SMESH::ElementType Filter_i::GetElementType()
2455 {
2456   return myPredicate != 0 ? myPredicate->GetElementType() : SMESH::ALL;
2457 }
2458
2459 //=======================================================================
2460 // name    : Filter_i::SetMesh
2461 // Purpose : Set mesh
2462 //=======================================================================
2463 void
2464 Filter_i::
2465 SetMesh( SMESH_Mesh_ptr theMesh )
2466 {
2467   if(!CORBA::is_nil(theMesh))
2468     theMesh->Register();
2469
2470   if(!CORBA::is_nil(myMesh))
2471     myMesh->UnRegister();
2472
2473   myMesh = SMESH_Mesh::_duplicate( theMesh );
2474   TPythonDump()<<this<<".SetMesh("<<theMesh<<")";
2475
2476   if ( myPredicate )
2477     if ( const SMDS_Mesh* aMesh = MeshPtr2SMDSMesh(theMesh))
2478       myPredicate->GetPredicate()->SetMesh( aMesh );
2479 }
2480
2481 SMESH::long_array*
2482 Filter_i::
2483 GetIDs()
2484 {
2485   return GetElementsId(myMesh);
2486 }
2487
2488 //=======================================================================
2489 // name    : Filter_i::GetElementsId
2490 // Purpose : Get ids of entities
2491 //=======================================================================
2492 void
2493 Filter_i::
2494 GetElementsId( Predicate_i* thePredicate,
2495                const SMDS_Mesh* theMesh,
2496                Controls::Filter::TIdSequence& theSequence )
2497 {
2498   if (thePredicate)
2499     Controls::Filter::GetElementsId(theMesh,thePredicate->GetPredicate(),theSequence);
2500 }
2501
2502 void
2503 Filter_i::
2504 GetElementsId( Predicate_i* thePredicate,
2505                SMESH_Mesh_ptr theMesh,
2506                Controls::Filter::TIdSequence& theSequence )
2507 {
2508   if (thePredicate)
2509     if(const SMDS_Mesh* aMesh = MeshPtr2SMDSMesh(theMesh))
2510       Controls::Filter::GetElementsId(aMesh,thePredicate->GetPredicate(),theSequence);
2511 }
2512
2513 SMESH::long_array*
2514 Filter_i::
2515 GetElementsId( SMESH_Mesh_ptr theMesh )
2516 {
2517   SMESH::long_array_var anArray = new SMESH::long_array;
2518   if(!CORBA::is_nil(theMesh) && myPredicate){
2519     Controls::Filter::TIdSequence aSequence;
2520     GetElementsId(myPredicate,theMesh,aSequence);
2521     long i = 0, iEnd = aSequence.size();
2522     anArray->length( iEnd );
2523     for ( ; i < iEnd; i++ )
2524       anArray[ i ] = aSequence[i];
2525   }
2526   return anArray._retn();
2527 }
2528
2529 template<class TElement, class TIterator, class TPredicate>
2530 static void collectMeshInfo(const TIterator& theItr,
2531                             TPredicate& thePred,
2532                             SMESH::long_array& theRes)
2533 {
2534   if (!theItr)
2535     return;
2536   while (theItr->more()) {
2537     const SMDS_MeshElement* anElem = theItr->next();
2538     if ( thePred->IsSatisfy( anElem->GetID() ) )
2539       theRes[ anElem->GetEntityType() ]++;
2540   }
2541 }
2542
2543 //=============================================================================
2544 /*!
2545  * \brief Returns statistic of mesh elements
2546  */
2547 //=============================================================================
2548 SMESH::long_array* ::Filter_i::GetMeshInfo()
2549 {
2550   SMESH::long_array_var aRes = new SMESH::long_array();
2551   aRes->length(SMESH::Entity_Last);
2552   for (int i = SMESH::Entity_Node; i < SMESH::Entity_Last; i++)
2553     aRes[i] = 0;
2554
2555   if(!CORBA::is_nil(myMesh) && myPredicate) {
2556     const SMDS_Mesh* aMesh = MeshPtr2SMDSMesh(myMesh);
2557     SMDS_ElemIteratorPtr it;
2558     switch( GetElementType() )
2559     {
2560     case SMDSAbs_Node:
2561       collectMeshInfo<const SMDS_MeshNode*>(aMesh->nodesIterator(),myPredicate,aRes);
2562       break;
2563     case SMDSAbs_Edge:
2564       collectMeshInfo<const SMDS_MeshElement*>(aMesh->edgesIterator(),myPredicate,aRes);
2565       break;
2566     case SMDSAbs_Face:
2567       collectMeshInfo<const SMDS_MeshElement*>(aMesh->facesIterator(),myPredicate,aRes);
2568       break;
2569     case SMDSAbs_Volume:
2570       collectMeshInfo<const SMDS_MeshElement*>(aMesh->volumesIterator(),myPredicate,aRes);
2571       break;
2572     case SMDSAbs_All:
2573     default:
2574       collectMeshInfo<const SMDS_MeshElement*>(aMesh->elementsIterator(),myPredicate,aRes);
2575       break;
2576     }
2577   }
2578
2579   return aRes._retn();
2580 }
2581
2582 //================================================================================
2583 /*!
2584  * \brief Return GetElementType() within an array
2585  * Implement SMESH_IDSource interface
2586  */
2587 //================================================================================
2588
2589 SMESH::array_of_ElementType* Filter_i::GetTypes()
2590 {
2591   SMESH::array_of_ElementType_var types = new SMESH::array_of_ElementType;
2592
2593   // check if any element passes through the filter
2594   if ( !CORBA::is_nil(myMesh) && myPredicate )
2595   {
2596     const SMDS_Mesh* aMesh = MeshPtr2SMDSMesh(myMesh);
2597     SMDS_ElemIteratorPtr it = aMesh->elementsIterator( SMDSAbs_ElementType( GetElementType() ));
2598     bool satisfies = false;
2599     while ( !satisfies && it->more() )
2600       satisfies = myPredicate->IsSatisfy( it->next()->GetID() );
2601     if ( satisfies ) {
2602       types->length( 1 );
2603       types[0] = GetElementType();
2604     }
2605   }
2606   return types._retn();
2607 }
2608
2609 //=======================================================================
2610 //function : GetMesh
2611 //purpose  : Returns mesh
2612 //=======================================================================
2613
2614 SMESH::SMESH_Mesh_ptr Filter_i::GetMesh()
2615 {
2616   return SMESH_Mesh::_duplicate( myMesh );
2617 }
2618
2619 //================================================================================
2620 /*!
2621  * \brief Stores an object to be notified on change of predicate
2622  */
2623 //================================================================================
2624
2625 void Filter_i::AddWaiter( TPredicateChangeWaiter* waiter )
2626 {
2627   if ( waiter )
2628     myWaiters.push_back( waiter );
2629 }
2630
2631 //================================================================================
2632 /*!
2633  * \brief Removes an object to be notified on change of predicate
2634  */
2635 //================================================================================
2636
2637 void Filter_i::RemoveWaiter( TPredicateChangeWaiter* waiter )
2638 {
2639   myWaiters.remove( waiter );
2640 }
2641
2642 //=======================================================================
2643 // name    : getCriteria
2644 // Purpose : Retrieve criterions from predicate
2645 //=======================================================================
2646 static inline bool getCriteria( Predicate_i*                thePred,
2647                                 SMESH::Filter::Criteria_out theCriteria )
2648 {
2649   int aFType = thePred->GetFunctorType();
2650
2651   switch ( aFType )
2652   {
2653   case FT_FreeBorders:
2654   case FT_FreeEdges:
2655   case FT_FreeFaces:
2656   case FT_LinearOrQuadratic:
2657   case FT_FreeNodes:
2658   case FT_EqualEdges:
2659   case FT_EqualFaces:
2660   case FT_EqualVolumes:
2661   case FT_BadOrientedVolume:
2662   case FT_BareBorderVolume:
2663   case FT_BareBorderFace:
2664   case FT_OverConstrainedVolume:
2665   case FT_OverConstrainedFace:
2666     {
2667       CORBA::ULong i = theCriteria->length();
2668       theCriteria->length( i + 1 );
2669
2670       theCriteria[ i ] = createCriterion();
2671
2672       theCriteria[ i ].Type = aFType;
2673       theCriteria[ i ].TypeOfElement = thePred->GetElementType();
2674       return true;
2675     }
2676   case FT_BelongToGeom:
2677     {
2678       BelongToGeom_i* aPred = dynamic_cast<BelongToGeom_i*>( thePred );
2679
2680       CORBA::ULong i = theCriteria->length();
2681       theCriteria->length( i + 1 );
2682
2683       theCriteria[ i ] = createCriterion();
2684
2685       theCriteria[ i ].Type          = FT_BelongToGeom;
2686       theCriteria[ i ].ThresholdStr  = aPred->GetShapeName();
2687       theCriteria[ i ].ThresholdID   = aPred->GetShapeID();
2688       theCriteria[ i ].TypeOfElement = aPred->GetElementType();
2689       theCriteria[ i ].Tolerance     = aPred->GetTolerance();
2690
2691       return true;
2692     }
2693   case FT_BelongToPlane:
2694   case FT_BelongToCylinder:
2695   case FT_BelongToGenSurface:
2696     {
2697       BelongToSurface_i* aPred = dynamic_cast<BelongToSurface_i*>( thePred );
2698
2699       CORBA::ULong i = theCriteria->length();
2700       theCriteria->length( i + 1 );
2701
2702       theCriteria[ i ] = createCriterion();
2703
2704       theCriteria[ i ].Type          = aFType;
2705       theCriteria[ i ].ThresholdStr  = aPred->GetShapeName();
2706       theCriteria[ i ].ThresholdID   = aPred->GetShapeID();
2707       theCriteria[ i ].TypeOfElement = aPred->GetElementType();
2708       theCriteria[ i ].Tolerance     = aPred->GetTolerance();
2709
2710       return true;
2711     }
2712    case FT_LyingOnGeom:
2713     {
2714       LyingOnGeom_i* aPred = dynamic_cast<LyingOnGeom_i*>( thePred );
2715
2716       CORBA::ULong i = theCriteria->length();
2717       theCriteria->length( i + 1 );
2718
2719       theCriteria[ i ] = createCriterion();
2720
2721       theCriteria[ i ].Type          = FT_LyingOnGeom;
2722       theCriteria[ i ].ThresholdStr  = aPred->GetShapeName();
2723       theCriteria[ i ].ThresholdID   = aPred->GetShapeID();
2724       theCriteria[ i ].TypeOfElement = aPred->GetElementType();
2725       theCriteria[ i ].Tolerance     = aPred->GetTolerance();
2726
2727       return true;
2728     }
2729    case FT_CoplanarFaces:
2730     {
2731       CoplanarFaces_i* aPred = dynamic_cast<CoplanarFaces_i*>( thePred );
2732
2733       CORBA::ULong i = theCriteria->length();
2734       theCriteria->length( i + 1 );
2735
2736       theCriteria[ i ] = createCriterion();
2737       CORBA::String_var faceId = aPred->GetFaceAsString();
2738
2739       theCriteria[ i ].Type          = FT_CoplanarFaces;
2740       theCriteria[ i ].ThresholdID   = faceId;
2741       theCriteria[ i ].Tolerance     = aPred->GetTolerance();
2742
2743       return true;
2744     }
2745   case FT_EqualNodes:
2746     {
2747       EqualNodes_i* aPred = dynamic_cast<EqualNodes_i*>( thePred );
2748
2749       CORBA::ULong i = theCriteria->length();
2750       theCriteria->length( i + 1 );
2751
2752       theCriteria[ i ] = createCriterion();
2753
2754       theCriteria[ i ].Type          = FT_EqualNodes;
2755       theCriteria[ i ].Tolerance     = aPred->GetTolerance();
2756
2757       return true;
2758     }
2759   case FT_RangeOfIds:
2760     {
2761       RangeOfIds_i* aPred = dynamic_cast<RangeOfIds_i*>( thePred );
2762
2763       CORBA::ULong i = theCriteria->length();
2764       theCriteria->length( i + 1 );
2765
2766       theCriteria[ i ] = createCriterion();
2767
2768       theCriteria[ i ].Type          = FT_RangeOfIds;
2769       theCriteria[ i ].ThresholdStr  = aPred->GetRangeStr();
2770       theCriteria[ i ].TypeOfElement = aPred->GetElementType();
2771
2772       return true;
2773     }
2774   case FT_LessThan:
2775   case FT_MoreThan:
2776   case FT_EqualTo:
2777     {
2778       Comparator_i* aCompar = dynamic_cast<Comparator_i*>( thePred );
2779
2780       CORBA::ULong i = theCriteria->length();
2781       theCriteria->length( i + 1 );
2782
2783       theCriteria[ i ] = createCriterion();
2784
2785       theCriteria[ i ].Type      = aCompar->GetNumFunctor_i()->GetFunctorType();
2786       theCriteria[ i ].Compare   = aFType;
2787       theCriteria[ i ].Threshold = aCompar->GetMargin();
2788       theCriteria[ i ].TypeOfElement = aCompar->GetElementType();
2789
2790       if ( aFType == FT_EqualTo )
2791       {
2792         EqualTo_i* aCompar = dynamic_cast<EqualTo_i*>( thePred );
2793         theCriteria[ i ].Tolerance = aCompar->GetTolerance();
2794       }
2795     }
2796     return true;
2797
2798   case FT_LogicalNOT:
2799     {
2800       Predicate_i* aPred = ( dynamic_cast<LogicalNOT_i*>( thePred ) )->GetPredicate_i();
2801       getCriteria( aPred, theCriteria );
2802       theCriteria[ theCriteria->length() - 1 ].UnaryOp = FT_LogicalNOT;
2803     }
2804     return true;
2805
2806   case FT_LogicalAND:
2807   case FT_LogicalOR:
2808     {
2809       Predicate_i* aPred1 = ( dynamic_cast<LogicalBinary_i*>( thePred ) )->GetPredicate1_i();
2810       Predicate_i* aPred2 = ( dynamic_cast<LogicalBinary_i*>( thePred ) )->GetPredicate2_i();
2811       if ( !getCriteria( aPred1, theCriteria ) )
2812         return false;
2813       theCriteria[ theCriteria->length() - 1 ].BinaryOp = aFType;
2814       return getCriteria( aPred2, theCriteria );
2815     }
2816   case FT_GroupColor:
2817     {
2818       CORBA::ULong i = theCriteria->length();
2819       theCriteria->length( i + 1 );
2820
2821       theCriteria[ i ] = createCriterion();
2822
2823       GroupColor_i* aPred = dynamic_cast<GroupColor_i*>( thePred );
2824       theCriteria[ i ].Type          = aFType;
2825       theCriteria[ i ].TypeOfElement = aPred->GetElementType();
2826       theCriteria[ i ].ThresholdStr  = aPred->GetColorStr();
2827
2828       return true;
2829     }
2830   case FT_ElemGeomType:
2831     {
2832       CORBA::ULong i = theCriteria->length();
2833       theCriteria->length( i + 1 );
2834
2835       theCriteria[ i ] = createCriterion();
2836
2837       ElemGeomType_i* aPred = dynamic_cast<ElemGeomType_i*>( thePred );
2838       theCriteria[ i ].Type          = aFType;
2839       theCriteria[ i ].TypeOfElement = aPred->GetElementType();
2840       theCriteria[ i ].Threshold     = (double)aPred->GetGeometryType();
2841       return true;
2842     }
2843   case FT_EntityType:
2844     {
2845       CORBA::ULong i = theCriteria->length();
2846       theCriteria->length( i + 1 );
2847
2848       theCriteria[ i ] = createCriterion();
2849
2850       ElemEntityType_i* aPred = dynamic_cast<ElemEntityType_i*>( thePred );
2851       theCriteria[ i ].Type          = aFType;
2852       theCriteria[ i ].Threshold     = (double)aPred->GetEntityType();
2853       return true;
2854     }
2855
2856   case FT_Undefined:
2857     return false;
2858   default:
2859     return false;
2860   }
2861 }
2862
2863 //=======================================================================
2864 // name    : Filter_i::GetCriteria
2865 // Purpose : Retrieve criterions from predicate
2866 //=======================================================================
2867 CORBA::Boolean Filter_i::GetCriteria( SMESH::Filter::Criteria_out theCriteria )
2868 {
2869   theCriteria = new SMESH::Filter::Criteria;
2870   return myPredicate != 0 ? getCriteria( myPredicate, theCriteria ) : true;
2871 }
2872
2873 //=======================================================================
2874 // name    : Filter_i::SetCriteria
2875 // Purpose : Create new predicate and set criterions in it
2876 //=======================================================================
2877 CORBA::Boolean Filter_i::SetCriteria( const SMESH::Filter::Criteria& theCriteria )
2878 {
2879   if ( myPredicate != 0 )
2880     myPredicate->UnRegister();
2881
2882   SMESH::FilterManager_i* aFilter = new SMESH::FilterManager_i();
2883   FilterManager_ptr aFilterMgr = aFilter->_this();
2884
2885   // CREATE two lists ( PREDICATES  and LOG OP )
2886
2887   // Criterion
2888   TPythonDump()<<"aCriteria = []";
2889   std::list<SMESH::Predicate_ptr> aPredicates;
2890   std::list<int>                  aBinaries;
2891   for ( int i = 0, n = theCriteria.length(); i < n; i++ )
2892   {
2893     int         aCriterion    = theCriteria[ i ].Type;
2894     int         aCompare      = theCriteria[ i ].Compare;
2895     double      aThreshold    = theCriteria[ i ].Threshold;
2896     const char* aThresholdStr = theCriteria[ i ].ThresholdStr;
2897     const char* aThresholdID  = theCriteria[ i ].ThresholdID;
2898     int         aUnary        = theCriteria[ i ].UnaryOp;
2899     int         aBinary       = theCriteria[ i ].BinaryOp;
2900     double      aTolerance    = theCriteria[ i ].Tolerance;
2901     ElementType aTypeOfElem   = theCriteria[ i ].TypeOfElement;
2902     long        aPrecision    = theCriteria[ i ].Precision;
2903
2904     {
2905       TPythonDump pd;
2906       pd << "aCriterion = SMESH.Filter.Criterion("
2907          << aCriterion    << ", "
2908          << aCompare      << ", "
2909          << aThreshold    << ", '"
2910          << aThresholdStr << "', '";
2911       if (aThresholdID) pd << aThresholdID;
2912       pd                  << "', "
2913          << aUnary        << ", "
2914          << aBinary       << ", "
2915          << aTolerance    << ", "
2916          << aTypeOfElem   << ", "
2917          << aPrecision    << ")";
2918     }
2919     TPythonDump pd;
2920
2921     SMESH::Predicate_ptr aPredicate = SMESH::Predicate::_nil();
2922     SMESH::NumericalFunctor_ptr aFunctor = SMESH::NumericalFunctor::_nil();
2923
2924     switch ( aCriterion )
2925     {
2926       // Functors
2927
2928       case SMESH::FT_MultiConnection:
2929         aFunctor = aFilterMgr->CreateMultiConnection();
2930         break;
2931       case SMESH::FT_MultiConnection2D:
2932         aFunctor = aFilterMgr->CreateMultiConnection2D();
2933         break;
2934       case SMESH::FT_Length:
2935         aFunctor = aFilterMgr->CreateLength();
2936         break;
2937       case SMESH::FT_Length2D:
2938         aFunctor = aFilterMgr->CreateLength2D();
2939         break;
2940       case SMESH::FT_AspectRatio:
2941         aFunctor = aFilterMgr->CreateAspectRatio();
2942         break;
2943       case SMESH::FT_AspectRatio3D:
2944         aFunctor = aFilterMgr->CreateAspectRatio3D();
2945         break;
2946       case SMESH::FT_Warping:
2947         aFunctor = aFilterMgr->CreateWarping();
2948         break;
2949       case SMESH::FT_MinimumAngle:
2950         aFunctor = aFilterMgr->CreateMinimumAngle();
2951         break;
2952       case SMESH::FT_Taper:
2953         aFunctor = aFilterMgr->CreateTaper();
2954         break;
2955       case SMESH::FT_Skew:
2956         aFunctor = aFilterMgr->CreateSkew();
2957         break;
2958       case SMESH::FT_Area:
2959         aFunctor = aFilterMgr->CreateArea();
2960         break;
2961       case SMESH::FT_Volume3D:
2962         aFunctor = aFilterMgr->CreateVolume3D();
2963         break;
2964       case SMESH::FT_MaxElementLength2D:
2965         aFunctor = aFilterMgr->CreateMaxElementLength2D();
2966         break;
2967       case SMESH::FT_MaxElementLength3D:
2968         aFunctor = aFilterMgr->CreateMaxElementLength3D();
2969         break;
2970       case SMESH::FT_BallDiameter:
2971         aFunctor = aFilterMgr->CreateBallDiameter();
2972         break;
2973
2974       // Predicates
2975
2976       case SMESH::FT_FreeBorders:
2977         aPredicate = aFilterMgr->CreateFreeBorders();
2978         break;
2979       case SMESH::FT_FreeEdges:
2980         aPredicate = aFilterMgr->CreateFreeEdges();
2981         break;
2982       case SMESH::FT_FreeFaces:
2983         aPredicate = aFilterMgr->CreateFreeFaces();
2984         break;
2985       case SMESH::FT_FreeNodes:
2986         aPredicate = aFilterMgr->CreateFreeNodes();
2987         break;
2988       case SMESH::FT_EqualNodes:
2989         {
2990           SMESH::EqualNodes_ptr pred = aFilterMgr->CreateEqualNodes();
2991           pred->SetTolerance( aTolerance );
2992           aPredicate = pred;
2993           break;
2994         }
2995       case SMESH::FT_EqualEdges:
2996         aPredicate = aFilterMgr->CreateEqualEdges();
2997         break;
2998       case SMESH::FT_EqualFaces:
2999         aPredicate = aFilterMgr->CreateEqualFaces();
3000         break;
3001       case SMESH::FT_EqualVolumes:
3002         aPredicate = aFilterMgr->CreateEqualVolumes();
3003         break;
3004       case SMESH::FT_BelongToGeom:
3005         {
3006           SMESH::BelongToGeom_ptr tmpPred = aFilterMgr->CreateBelongToGeom();
3007           tmpPred->SetElementType( aTypeOfElem );
3008           tmpPred->SetShape( aThresholdID, aThresholdStr );
3009           tmpPred->SetTolerance( aTolerance );
3010           aPredicate = tmpPred;
3011         }
3012         break;
3013       case SMESH::FT_BelongToPlane:
3014       case SMESH::FT_BelongToCylinder:
3015       case SMESH::FT_BelongToGenSurface:
3016         {
3017           SMESH::BelongToSurface_ptr tmpPred;
3018           switch ( aCriterion ) {
3019           case SMESH::FT_BelongToPlane:
3020             tmpPred = aFilterMgr->CreateBelongToPlane(); break;
3021           case SMESH::FT_BelongToCylinder:
3022             tmpPred = aFilterMgr->CreateBelongToCylinder(); break;
3023           default:
3024             tmpPred = aFilterMgr->CreateBelongToGenSurface();
3025           }
3026           tmpPred->SetShape( aThresholdID, aThresholdStr, aTypeOfElem );
3027           tmpPred->SetTolerance( aTolerance );
3028           aPredicate = tmpPred;
3029         }
3030         break;
3031       case SMESH::FT_LyingOnGeom:
3032         {
3033           SMESH::LyingOnGeom_ptr tmpPred = aFilterMgr->CreateLyingOnGeom();
3034           tmpPred->SetElementType( aTypeOfElem );
3035           tmpPred->SetShape( aThresholdID, aThresholdStr );
3036           tmpPred->SetTolerance( aTolerance );
3037           aPredicate = tmpPred;
3038         }
3039         break;
3040       case SMESH::FT_RangeOfIds:
3041         {
3042           SMESH::RangeOfIds_ptr tmpPred = aFilterMgr->CreateRangeOfIds();
3043           tmpPred->SetRangeStr( aThresholdStr );
3044           tmpPred->SetElementType( aTypeOfElem );
3045           aPredicate = tmpPred;
3046         }
3047         break;
3048       case SMESH::FT_BadOrientedVolume:
3049         {
3050           aPredicate = aFilterMgr->CreateBadOrientedVolume();
3051         }
3052         break;
3053       case SMESH::FT_BareBorderVolume:
3054         {
3055           aPredicate = aFilterMgr->CreateBareBorderVolume();
3056         }
3057         break;
3058       case SMESH::FT_BareBorderFace:
3059         {
3060           aPredicate = aFilterMgr->CreateBareBorderFace();
3061         }
3062         break;
3063       case SMESH::FT_OverConstrainedVolume:
3064         {
3065           aPredicate = aFilterMgr->CreateOverConstrainedVolume();
3066         }
3067         break;
3068       case SMESH::FT_OverConstrainedFace:
3069         {
3070           aPredicate = aFilterMgr->CreateOverConstrainedFace();
3071         }
3072         break;
3073       case SMESH::FT_LinearOrQuadratic:
3074         {
3075           SMESH::LinearOrQuadratic_ptr tmpPred = aFilterMgr->CreateLinearOrQuadratic();
3076           tmpPred->SetElementType( aTypeOfElem );
3077           aPredicate = tmpPred;
3078           break;
3079         }
3080       case SMESH::FT_GroupColor:
3081         {
3082           SMESH::GroupColor_ptr tmpPred = aFilterMgr->CreateGroupColor();
3083           tmpPred->SetElementType( aTypeOfElem );
3084           tmpPred->SetColorStr( aThresholdStr );
3085           aPredicate = tmpPred;
3086           break;
3087         }
3088       case SMESH::FT_ElemGeomType:
3089         {
3090           SMESH::ElemGeomType_ptr tmpPred = aFilterMgr->CreateElemGeomType();
3091           tmpPred->SetElementType( aTypeOfElem );
3092           tmpPred->SetGeometryType( (GeometryType)(int)(aThreshold + 0.5) );
3093           aPredicate = tmpPred;
3094           break;
3095         }
3096       case SMESH::FT_EntityType:
3097         {
3098           SMESH::ElemEntityType_ptr tmpPred = aFilterMgr->CreateElemEntityType();
3099           tmpPred->SetElementType( aTypeOfElem );
3100           tmpPred->SetEntityType( EntityType( (int (aThreshold + 0.5))));
3101           aPredicate = tmpPred;
3102           break;
3103         }
3104       case SMESH::FT_CoplanarFaces:
3105         {
3106           SMESH::CoplanarFaces_ptr tmpPred = aFilterMgr->CreateCoplanarFaces();
3107           tmpPred->SetFace( atol (aThresholdID ));
3108           tmpPred->SetTolerance( aTolerance );
3109           aPredicate = tmpPred;
3110           break;
3111         }
3112
3113       default:
3114         continue;
3115     }
3116
3117     // Comparator
3118     if ( !aFunctor->_is_nil() && aPredicate->_is_nil() )
3119     {
3120       SMESH::Comparator_ptr aComparator = SMESH::Comparator::_nil();
3121
3122       if ( aCompare == SMESH::FT_LessThan )
3123         aComparator = aFilterMgr->CreateLessThan();
3124       else if ( aCompare == SMESH::FT_MoreThan )
3125         aComparator = aFilterMgr->CreateMoreThan();
3126       else if ( aCompare == SMESH::FT_EqualTo )
3127         aComparator = aFilterMgr->CreateEqualTo();
3128       else
3129         continue;
3130
3131       aComparator->SetNumFunctor( aFunctor );
3132       aComparator->SetMargin( aThreshold );
3133
3134       if ( aCompare == FT_EqualTo )
3135       {
3136         SMESH::EqualTo_var anEqualTo = SMESH::EqualTo::_narrow( aComparator );
3137         anEqualTo->SetTolerance( aTolerance );
3138       }
3139
3140       aPredicate = aComparator;
3141
3142       aFunctor->SetPrecision( aPrecision );
3143     }
3144
3145     // Logical not
3146     if ( aUnary == FT_LogicalNOT )
3147     {
3148       SMESH::LogicalNOT_ptr aNotPred = aFilterMgr->CreateLogicalNOT();
3149       aNotPred->SetPredicate( aPredicate );
3150       aPredicate = aNotPred;
3151     }
3152
3153     // logical op
3154     aPredicates.push_back( aPredicate );
3155     aBinaries.push_back( aBinary );
3156     pd <<"aCriteria.append(aCriterion)";
3157
3158   } // end of for
3159   TPythonDump pd; pd<<this<<".SetCriteria(aCriteria)";
3160
3161   // CREATE ONE PREDICATE FROM PREVIOUSLY CREATED MAP
3162
3163   // combine all "AND" operations
3164
3165   std::list<SMESH::Predicate_ptr> aResList;
3166
3167   std::list<SMESH::Predicate_ptr>::iterator aPredIter;
3168   std::list<int>::iterator                  aBinaryIter;
3169
3170   SMESH::Predicate_ptr aPrevPredicate = SMESH::Predicate::_nil();
3171   int aPrevBinary = SMESH::FT_Undefined;
3172
3173   for ( aPredIter = aPredicates.begin(), aBinaryIter = aBinaries.begin();
3174         aPredIter != aPredicates.end() && aBinaryIter != aBinaries.end();
3175         ++aPredIter, ++aBinaryIter )
3176   {
3177     int aCurrBinary = *aBinaryIter;
3178
3179     SMESH::Predicate_ptr aCurrPred = SMESH::Predicate::_nil();
3180
3181     if ( aPrevBinary == SMESH::FT_LogicalAND )
3182     {
3183
3184       SMESH::LogicalBinary_ptr aBinaryPred = aFilterMgr->CreateLogicalAND();
3185       aBinaryPred->SetPredicate1( aPrevPredicate );
3186       aBinaryPred->SetPredicate2( *aPredIter );
3187       aCurrPred = aBinaryPred;
3188     }
3189     else
3190       aCurrPred = *aPredIter;
3191
3192     if ( aCurrBinary != SMESH::FT_LogicalAND )
3193       aResList.push_back( aCurrPred );
3194
3195     aPrevPredicate = aCurrPred;
3196     aPrevBinary = aCurrBinary;
3197   }
3198
3199   // combine all "OR" operations
3200
3201   SMESH::Predicate_ptr aResPredicate = SMESH::Predicate::_nil();
3202
3203   if ( aResList.size() == 1 )
3204     aResPredicate = *aResList.begin();
3205   else if ( aResList.size() > 1 )
3206   {
3207     std::list<SMESH::Predicate_ptr>::iterator anIter = aResList.begin();
3208     aResPredicate = *anIter;
3209     anIter++;
3210     for ( ; anIter != aResList.end(); ++anIter )
3211     {
3212       SMESH::LogicalBinary_ptr aBinaryPred = aFilterMgr->CreateLogicalOR();
3213       aBinaryPred->SetPredicate1( aResPredicate );
3214       aBinaryPred->SetPredicate2( *anIter );
3215       aResPredicate = aBinaryPred;
3216     }
3217   }
3218
3219   SetPredicate( aResPredicate );
3220
3221   return !aResPredicate->_is_nil();
3222 }
3223
3224 //=======================================================================
3225 // name    : Filter_i::GetPredicate_i
3226 // Purpose : Get implementation of predicate
3227 //=======================================================================
3228 Predicate_i* Filter_i::GetPredicate_i()
3229 {
3230   return myPredicate;
3231 }
3232
3233 //=======================================================================
3234 // name    : Filter_i::GetPredicate
3235 // Purpose : Get predicate
3236 //=======================================================================
3237 Predicate_ptr Filter_i::GetPredicate()
3238 {
3239   if ( myPredicate == 0 )
3240     return SMESH::Predicate::_nil();
3241   else
3242   {
3243     SMESH::Predicate_var anObj = myPredicate->_this();
3244     // if ( SMESH::Functor_i* fun = SMESH::DownCast<SMESH::Functor_i*>( anObj ))
3245     //   TPythonDump() << fun << " = " << this << ".GetPredicate()";
3246     return anObj._retn();
3247   }
3248 }
3249
3250 /*
3251                             FILTER LIBRARY
3252 */
3253
3254 #define ATTR_TYPE          "type"
3255 #define ATTR_COMPARE       "compare"
3256 #define ATTR_THRESHOLD     "threshold"
3257 #define ATTR_UNARY         "unary"
3258 #define ATTR_BINARY        "binary"
3259 #define ATTR_THRESHOLD_STR "threshold_str"
3260 #define ATTR_TOLERANCE     "tolerance"
3261 #define ATTR_ELEMENT_TYPE  "ElementType"
3262
3263 //=======================================================================
3264 // name    : toString
3265 // Purpose : Convert bool to LDOMString
3266 //=======================================================================
3267 static inline LDOMString toString( CORBA::Boolean val )
3268 {
3269   return val ? "logical not" : "";
3270 }
3271
3272 //=======================================================================
3273 // name    : toBool
3274 // Purpose : Convert LDOMString to bool
3275 //=======================================================================
3276 static inline bool toBool( const LDOMString& theStr )
3277 {
3278   return theStr.equals( "logical not" );
3279 }
3280
3281 //=======================================================================
3282 // name    : toString
3283 // Purpose : Convert double to LDOMString
3284 //=======================================================================
3285 static inline LDOMString toString( CORBA::Double val )
3286 {
3287   char a[ 255 ];
3288   sprintf( a, "%e", val );
3289   return LDOMString( a );
3290 }
3291
3292 //=======================================================================
3293 // name    : toDouble
3294 // Purpose : Convert LDOMString to double
3295 //=======================================================================
3296 static inline double toDouble( const LDOMString& theStr )
3297 {
3298   return atof( theStr.GetString() );
3299 }
3300
3301 //=======================================================================
3302 // name    : toString
3303 // Purpose : Convert functor type to LDOMString
3304 //=======================================================================
3305 static inline LDOMString toString( CORBA::Long theType )
3306 {
3307   switch ( theType )
3308   {
3309     case FT_AspectRatio     : return "Aspect ratio";
3310     case FT_Warping         : return "Warping";
3311     case FT_MinimumAngle    : return "Minimum angle";
3312     case FT_Taper           : return "Taper";
3313     case FT_Skew            : return "Skew";
3314     case FT_Area            : return "Area";
3315     case FT_Volume3D        : return "Volume3D";
3316     case FT_MaxElementLength2D: return "Max element length 2D";
3317     case FT_MaxElementLength3D: return "Max element length 3D";
3318     case FT_BelongToGeom    : return "Belong to Geom";
3319     case FT_BelongToPlane   : return "Belong to Plane";
3320     case FT_BelongToCylinder: return "Belong to Cylinder";
3321     case FT_BelongToGenSurface: return "Belong to Generic Surface";
3322     case FT_LyingOnGeom     : return "Lying on Geom";
3323     case FT_BadOrientedVolume:return "Bad Oriented Volume";
3324     case FT_BareBorderVolume: return "Volumes with bare border";
3325     case FT_BareBorderFace  : return "Faces with bare border";
3326     case FT_OverConstrainedVolume: return "Over-constrained Volumes";
3327     case FT_OverConstrainedFace  : return "Over-constrained Faces";
3328     case FT_RangeOfIds      : return "Range of IDs";
3329     case FT_FreeBorders     : return "Free borders";
3330     case FT_FreeEdges       : return "Free edges";
3331     case FT_FreeFaces       : return "Free faces";
3332     case FT_FreeNodes       : return "Free nodes";
3333     case FT_EqualNodes      : return "Equal nodes";
3334     case FT_EqualEdges      : return "Equal edges";
3335     case FT_EqualFaces      : return "Equal faces";
3336     case FT_EqualVolumes    : return "Equal volumes";
3337     case FT_MultiConnection : return "Borders at multi-connections";
3338     case FT_MultiConnection2D:return "Borders at multi-connections 2D";
3339     case FT_Length          : return "Length";
3340     case FT_Length2D        : return "Length 2D";
3341     case FT_LessThan        : return "Less than";
3342     case FT_MoreThan        : return "More than";
3343     case FT_EqualTo         : return "Equal to";
3344     case FT_LogicalNOT      : return "Not";
3345     case FT_LogicalAND      : return "And";
3346     case FT_LogicalOR       : return "Or";
3347     case FT_GroupColor      : return "Color of Group";
3348     case FT_LinearOrQuadratic : return "Linear or Quadratic";
3349     case FT_ElemGeomType    : return "Element geomtry type";
3350     case FT_EntityType      : return "Entity type";
3351     case FT_Undefined       : return "";
3352     default                 : return "";
3353   }
3354 }
3355
3356 //=======================================================================
3357 // name    : toFunctorType
3358 // Purpose : Convert LDOMString to functor type
3359 //=======================================================================
3360 static inline SMESH::FunctorType toFunctorType( const LDOMString& theStr )
3361 {
3362   if      ( theStr.equals( "Aspect ratio"                 ) ) return FT_AspectRatio;
3363   else if ( theStr.equals( "Warping"                      ) ) return FT_Warping;
3364   else if ( theStr.equals( "Minimum angle"                ) ) return FT_MinimumAngle;
3365   else if ( theStr.equals( "Taper"                        ) ) return FT_Taper;
3366   else if ( theStr.equals( "Skew"                         ) ) return FT_Skew;
3367   else if ( theStr.equals( "Area"                         ) ) return FT_Area;
3368   else if ( theStr.equals( "Volume3D"                     ) ) return FT_Volume3D;
3369   else if ( theStr.equals( "Max element length 2D"        ) ) return FT_MaxElementLength2D;
3370   else if ( theStr.equals( "Max element length 3D"        ) ) return FT_MaxElementLength3D;
3371   else if ( theStr.equals( "Belong to Geom"               ) ) return FT_BelongToGeom;
3372   else if ( theStr.equals( "Belong to Plane"              ) ) return FT_BelongToPlane;
3373   else if ( theStr.equals( "Belong to Cylinder"           ) ) return FT_BelongToCylinder;
3374   else if ( theStr.equals( "Belong to Generic Surface"    ) ) return FT_BelongToGenSurface;
3375   else if ( theStr.equals( "Lying on Geom"                ) ) return FT_LyingOnGeom;
3376   else if ( theStr.equals( "Free borders"                 ) ) return FT_FreeBorders;
3377   else if ( theStr.equals( "Free edges"                   ) ) return FT_FreeEdges;
3378   else if ( theStr.equals( "Free faces"                   ) ) return FT_FreeFaces;
3379   else if ( theStr.equals( "Free nodes"                   ) ) return FT_FreeNodes;
3380   else if ( theStr.equals( "Equal nodes"                  ) ) return FT_EqualNodes;
3381   else if ( theStr.equals( "Equal edges"                  ) ) return FT_EqualEdges;
3382   else if ( theStr.equals( "Equal faces"                  ) ) return FT_EqualFaces;
3383   else if ( theStr.equals( "Equal volumes"                ) ) return FT_EqualVolumes;
3384   else if ( theStr.equals( "Borders at multi-connections" ) ) return FT_MultiConnection;
3385   //  else if ( theStr.equals( "Borders at multi-connections 2D" ) ) return FT_MultiConnection2D;
3386   else if ( theStr.equals( "Length"                       ) ) return FT_Length;
3387   //  else if ( theStr.equals( "Length2D"                     ) ) return FT_Length2D;
3388   else if ( theStr.equals( "Range of IDs"                 ) ) return FT_RangeOfIds;
3389   else if ( theStr.equals( "Bad Oriented Volume"          ) ) return FT_BadOrientedVolume;
3390   else if ( theStr.equals( "Volumes with bare border"     ) ) return FT_BareBorderVolume;
3391   else if ( theStr.equals( "Faces with bare border"       ) ) return FT_BareBorderFace;
3392   else if ( theStr.equals( "Over-constrained Volumes"     ) ) return FT_OverConstrainedVolume;
3393   else if ( theStr.equals( "Over-constrained Faces"       ) ) return FT_OverConstrainedFace;
3394   else if ( theStr.equals( "Less than"                    ) ) return FT_LessThan;
3395   else if ( theStr.equals( "More than"                    ) ) return FT_MoreThan;
3396   else if ( theStr.equals( "Equal to"                     ) ) return FT_EqualTo;
3397   else if ( theStr.equals( "Not"                          ) ) return FT_LogicalNOT;
3398   else if ( theStr.equals( "And"                          ) ) return FT_LogicalAND;
3399   else if ( theStr.equals( "Or"                           ) ) return FT_LogicalOR;
3400   else if ( theStr.equals( "Color of Group"               ) ) return FT_GroupColor;
3401   else if ( theStr.equals( "Linear or Quadratic"          ) ) return FT_LinearOrQuadratic;
3402   else if ( theStr.equals( "Element geomtry type"         ) ) return FT_ElemGeomType;
3403   else if ( theStr.equals( "Entity type"                  ) ) return FT_EntityType;
3404   else if ( theStr.equals( ""                             ) ) return FT_Undefined;
3405   else  return FT_Undefined;
3406 }
3407
3408 //=======================================================================
3409 // name    : toFunctorType
3410 // Purpose : Convert LDOMString to value of ElementType enumeration
3411 //=======================================================================
3412 static inline SMESH::ElementType toElementType( const LDOMString& theStr )
3413 {
3414   if      ( theStr.equals( "NODE"   ) ) return SMESH::NODE;
3415   else if ( theStr.equals( "EDGE"   ) ) return SMESH::EDGE;
3416   else if ( theStr.equals( "FACE"   ) ) return SMESH::FACE;
3417   else if ( theStr.equals( "VOLUME" ) ) return SMESH::VOLUME;
3418   else                                  return SMESH::ALL;
3419 }
3420
3421 //=======================================================================
3422 // name    : toString
3423 // Purpose : Convert ElementType to string
3424 //=======================================================================
3425 static inline LDOMString toString( const SMESH::ElementType theType )
3426 {
3427   switch ( theType )
3428   {
3429     case SMESH::NODE   : return "NODE";
3430     case SMESH::EDGE   : return "EDGE";
3431     case SMESH::FACE   : return "FACE";
3432     case SMESH::VOLUME : return "VOLUME";
3433     case SMESH::ALL    : return "ALL";
3434     default            : return "";
3435   }
3436 }
3437
3438 //=======================================================================
3439 // name    : findFilter
3440 // Purpose : Find filter in document
3441 //=======================================================================
3442 static LDOM_Element findFilter( const char* theFilterName,
3443                                 const LDOM_Document& theDoc,
3444                                 LDOM_Node* theParent = 0 )
3445 {
3446   LDOM_Element aRootElement = theDoc.getDocumentElement();
3447   if ( aRootElement.isNull() || !aRootElement.hasChildNodes() )
3448     return LDOM_Element();
3449
3450   for ( LDOM_Node aTypeNode = aRootElement.getFirstChild();
3451         !aTypeNode.isNull(); aTypeNode = aTypeNode.getNextSibling() )
3452   {
3453     for ( LDOM_Node aFilter = aTypeNode.getFirstChild();
3454           !aFilter.isNull(); aFilter = aFilter.getNextSibling() )
3455     {
3456       LDOM_Element* anElem = ( LDOM_Element* )&aFilter;
3457       if ( anElem->getTagName().equals( LDOMString( "filter" ) ) &&
3458            anElem->getAttribute( "name" ).equals( LDOMString( theFilterName ) ) )
3459       {
3460         if ( theParent != 0  )
3461           *theParent = aTypeNode;
3462         return (LDOM_Element&)aFilter;
3463       }
3464     }
3465   }
3466   return LDOM_Element();
3467 }
3468
3469 //=======================================================================
3470 // name    : getSectionName
3471 // Purpose : Get name of section of filters
3472 //=======================================================================
3473 static const char* getSectionName( const ElementType theType )
3474 {
3475   switch ( theType )
3476   {
3477     case SMESH::NODE   : return "Filters for nodes";
3478     case SMESH::EDGE   : return "Filters for edges";
3479     case SMESH::FACE   : return "Filters for faces";
3480     case SMESH::VOLUME : return "Filters for volumes";
3481     case SMESH::ALL    : return "Filters for elements";
3482     default            : return "";
3483   }
3484 }
3485
3486 //=======================================================================
3487 // name    : getSection
3488 // Purpose : Create section for filters corresponding to the entity type
3489 //=======================================================================
3490 static LDOM_Node getSection( const ElementType theType,
3491                              LDOM_Document&    theDoc,
3492                              const bool        toCreate = false )
3493 {
3494   LDOM_Element aRootElement = theDoc.getDocumentElement();
3495   if ( aRootElement.isNull() )
3496     return LDOM_Node();
3497
3498   // Find section
3499   bool anExist = false;
3500   const char* aSectionName = getSectionName( theType );
3501   if ( strcmp( aSectionName, "" ) == 0 )
3502     return LDOM_Node();
3503
3504   LDOM_NodeList aSections = theDoc.getElementsByTagName( "section" );
3505   LDOM_Node aNode;
3506   for ( int i = 0, n = aSections.getLength(); i < n; i++ )
3507   {
3508     aNode = aSections.item( i );
3509     LDOM_Element& anItem = ( LDOM_Element& )aNode;
3510     if ( anItem.getAttribute( "name" ).equals( LDOMString( aSectionName ) ) )
3511     {
3512       anExist = true;
3513       break;
3514     }
3515   }
3516
3517   // Create new section if necessary
3518   if ( !anExist )
3519   {
3520     if ( toCreate )
3521     {
3522       LDOM_Element aNewItem = theDoc.createElement( "section" );
3523       aNewItem.setAttribute( "name", aSectionName );
3524       aRootElement.appendChild( aNewItem );
3525       return aNewItem;
3526     }
3527     else
3528       return LDOM_Node();
3529   }
3530   return
3531     aNode;
3532 }
3533
3534 //=======================================================================
3535 // name    : createFilterItem
3536 // Purpose : Create filter item or LDOM document
3537 //=======================================================================
3538 static LDOM_Element createFilterItem( const char*       theName,
3539                                       SMESH::Filter_ptr theFilter,
3540                                       LDOM_Document&    theDoc )
3541 {
3542   // create new filter in document
3543   LDOM_Element aFilterItem = theDoc.createElement( "filter" );
3544   aFilterItem.setAttribute( "name", theName );
3545
3546   // save filter criterions
3547   SMESH::Filter::Criteria_var aCriteria = new SMESH::Filter::Criteria;
3548
3549   if ( !theFilter->GetCriteria( aCriteria ) )
3550     return LDOM_Element();
3551
3552   for ( CORBA::ULong i = 0, n = aCriteria->length(); i < n; i++ )
3553   {
3554     LDOM_Element aCriterionItem = theDoc.createElement( "criterion" );
3555
3556     aCriterionItem.setAttribute( ATTR_TYPE         , toString(  aCriteria[ i ].Type) );
3557     aCriterionItem.setAttribute( ATTR_COMPARE      , toString(  aCriteria[ i ].Compare ) );
3558     aCriterionItem.setAttribute( ATTR_THRESHOLD    , toString(  aCriteria[ i ].Threshold ) );
3559     aCriterionItem.setAttribute( ATTR_UNARY        , toString(  aCriteria[ i ].UnaryOp ) );
3560     aCriterionItem.setAttribute( ATTR_BINARY       , toString(  aCriteria[ i ].BinaryOp ) );
3561
3562     aCriterionItem.setAttribute( ATTR_THRESHOLD_STR, (const char*)aCriteria[ i ].ThresholdStr );
3563     aCriterionItem.setAttribute( ATTR_TOLERANCE    , toString( aCriteria[ i ].Tolerance ) );
3564     aCriterionItem.setAttribute( ATTR_ELEMENT_TYPE ,
3565       toString( (SMESH::ElementType)aCriteria[ i ].TypeOfElement ) );
3566
3567     aFilterItem.appendChild( aCriterionItem );
3568   }
3569
3570   return aFilterItem;
3571 }
3572
3573 //=======================================================================
3574 // name    : FilterLibrary_i::FilterLibrary_i
3575 // Purpose : Constructor
3576 //=======================================================================
3577 FilterLibrary_i::FilterLibrary_i( const char* theFileName )
3578 {
3579   myFileName = strdup( theFileName );
3580   SMESH::FilterManager_i* aFilterMgr = new SMESH::FilterManager_i();
3581   myFilterMgr = aFilterMgr->_this();
3582
3583   LDOMParser aParser;
3584
3585   // Try to use existing library file
3586   bool anExists = false;
3587   if ( !aParser.parse( myFileName ) )
3588   {
3589     myDoc = aParser.getDocument();
3590     anExists = true;
3591   }
3592   // Create a new XML document if it doesn't exist
3593   else
3594     myDoc = LDOM_Document::createDocument( LDOMString() );
3595
3596   LDOM_Element aRootElement = myDoc.getDocumentElement();
3597   if ( aRootElement.isNull() )
3598   {
3599     // If the existing document is empty --> try to create a new one
3600     if ( anExists )
3601       myDoc = LDOM_Document::createDocument( LDOMString() );
3602   }
3603 }
3604
3605 //=======================================================================
3606 // name    : FilterLibrary_i::FilterLibrary_i
3607 // Purpose : Constructor
3608 //=======================================================================
3609 FilterLibrary_i::FilterLibrary_i()
3610 {
3611   myFileName = 0;
3612   SMESH::FilterManager_i* aFilter = new SMESH::FilterManager_i();
3613   myFilterMgr = aFilter->_this();
3614
3615   myDoc = LDOM_Document::createDocument( LDOMString() );
3616 }
3617
3618 FilterLibrary_i::~FilterLibrary_i()
3619 {
3620   delete myFileName;
3621   //TPythonDump()<<this<<".UnRegister()";
3622 }
3623
3624 //=======================================================================
3625 // name    : FilterLibrary_i::Copy
3626 // Purpose : Create filter and initialize it with values from library
3627 //=======================================================================
3628 Filter_ptr FilterLibrary_i::Copy( const char* theFilterName )
3629 {
3630   Filter_ptr aRes = Filter::_nil();
3631   LDOM_Node aFilter = findFilter( theFilterName, myDoc );
3632
3633   if ( aFilter.isNull() )
3634     return aRes;
3635
3636   std::list<SMESH::Filter::Criterion> aCriteria;
3637
3638   for ( LDOM_Node aCritNode = aFilter.getFirstChild();
3639         !aCritNode.isNull() ; aCritNode = aCritNode.getNextSibling() )
3640   {
3641     LDOM_Element* aCrit = (LDOM_Element*)&aCritNode;
3642
3643     const char* aTypeStr      = aCrit->getAttribute( ATTR_TYPE          ).GetString();
3644     const char* aCompareStr   = aCrit->getAttribute( ATTR_COMPARE       ).GetString();
3645     const char* aUnaryStr     = aCrit->getAttribute( ATTR_UNARY         ).GetString();
3646     const char* aBinaryStr    = aCrit->getAttribute( ATTR_BINARY        ).GetString();
3647     const char* anElemTypeStr = aCrit->getAttribute( ATTR_ELEMENT_TYPE  ).GetString();
3648
3649     SMESH::Filter::Criterion aCriterion = createCriterion();
3650
3651     aCriterion.Type          = toFunctorType( aTypeStr );
3652     aCriterion.Compare       = toFunctorType( aCompareStr );
3653     aCriterion.UnaryOp       = toFunctorType( aUnaryStr );
3654     aCriterion.BinaryOp      = toFunctorType( aBinaryStr );
3655
3656     aCriterion.TypeOfElement = toElementType( anElemTypeStr );
3657
3658     LDOMString str = aCrit->getAttribute( ATTR_THRESHOLD );
3659     int val = 0;
3660     aCriterion.Threshold = str.Type() == LDOMBasicString::LDOM_Integer && str.GetInteger( val )
3661       ? val : atof( str.GetString() );
3662
3663     str = aCrit->getAttribute( ATTR_TOLERANCE );
3664     aCriterion.Tolerance = str.Type() == LDOMBasicString::LDOM_Integer && str.GetInteger( val )
3665       ? val : atof( str.GetString() );
3666
3667     str = aCrit->getAttribute( ATTR_THRESHOLD_STR );
3668     if ( str.Type() == LDOMBasicString::LDOM_Integer && str.GetInteger( val ) )
3669     {
3670       char a[ 255 ];
3671       sprintf( a, "%d", val );
3672       aCriterion.ThresholdStr = strdup( a );
3673     }
3674     else
3675       aCriterion.ThresholdStr = str.GetString();
3676
3677     aCriteria.push_back( aCriterion );
3678   }
3679
3680   SMESH::Filter::Criteria_var aCriteriaVar = new SMESH::Filter::Criteria;
3681   aCriteriaVar->length( aCriteria.size() );
3682
3683   CORBA::ULong i = 0;
3684   std::list<SMESH::Filter::Criterion>::iterator anIter = aCriteria.begin();
3685
3686   for( ; anIter != aCriteria.end(); ++anIter )
3687     aCriteriaVar[ i++ ] = *anIter;
3688
3689   aRes = myFilterMgr->CreateFilter();
3690   aRes->SetCriteria( aCriteriaVar.inout() );
3691
3692   TPythonDump()<<this<<".Copy('"<<theFilterName<<"')";
3693
3694   return aRes;
3695 }
3696
3697 //=======================================================================
3698 // name    : FilterLibrary_i::SetFileName
3699 // Purpose : Set file name for library
3700 //=======================================================================
3701 void FilterLibrary_i::SetFileName( const char* theFileName )
3702 {
3703   delete myFileName;
3704   myFileName = strdup( theFileName );
3705   TPythonDump()<<this<<".SetFileName('"<<theFileName<<"')";
3706 }
3707
3708 //=======================================================================
3709 // name    : FilterLibrary_i::GetFileName
3710 // Purpose : Get file name of library
3711 //=======================================================================
3712 char* FilterLibrary_i::GetFileName()
3713 {
3714   return CORBA::string_dup( myFileName );
3715 }
3716
3717 //=======================================================================
3718 // name    : FilterLibrary_i::Add
3719 // Purpose : Add new filter to library
3720 //=======================================================================
3721 CORBA::Boolean FilterLibrary_i::Add( const char* theFilterName, Filter_ptr theFilter )
3722 {
3723   // if filter already in library or entry filter is null do nothing
3724   LDOM_Node aFilterNode = findFilter( theFilterName, myDoc );
3725   if ( !aFilterNode.isNull() || theFilter->_is_nil() )
3726     return false;
3727
3728   // get section corresponding to the filter type
3729   ElementType anEntType = theFilter->GetElementType();
3730
3731   LDOM_Node aSection = getSection( anEntType, myDoc, true );
3732   if ( aSection.isNull() )
3733     return false;
3734
3735   // create filter item
3736   LDOM_Element aFilterItem = createFilterItem( theFilterName, theFilter, myDoc );
3737   if ( aFilterItem.isNull() )
3738     return false;
3739   else
3740   {
3741     aSection.appendChild( aFilterItem );
3742     if(Filter_i* aFilter = DownCast<Filter_i*>(theFilter))
3743       TPythonDump()<<this<<".Add('"<<theFilterName<<"',"<<aFilter<<")";
3744     return true;
3745   }
3746 }
3747
3748 //=======================================================================
3749 // name    : FilterLibrary_i::Add
3750 // Purpose : Add new filter to library
3751 //=======================================================================
3752 CORBA::Boolean FilterLibrary_i::AddEmpty( const char* theFilterName, ElementType theType )
3753 {
3754   // if filter already in library or entry filter is null do nothing
3755   LDOM_Node aFilterNode = findFilter( theFilterName, myDoc );
3756   if ( !aFilterNode.isNull() )
3757     return false;
3758
3759   LDOM_Node aSection = getSection( theType, myDoc, true );
3760   if ( aSection.isNull() )
3761     return false;
3762
3763   // create filter item
3764   Filter_var aFilter = myFilterMgr->CreateFilter();
3765
3766   LDOM_Element aFilterItem = createFilterItem( theFilterName, aFilter, myDoc );
3767   if ( aFilterItem.isNull() )
3768     return false;
3769   else
3770   {
3771     aSection.appendChild( aFilterItem );
3772     TPythonDump()<<this<<".AddEmpty('"<<theFilterName<<"',"<<theType<<")";
3773     return true;
3774   }
3775 }
3776
3777 //=======================================================================
3778 // name    : FilterLibrary_i::Delete
3779 // Purpose : Delete filter from library
3780 //=======================================================================
3781 CORBA::Boolean FilterLibrary_i::Delete ( const char* theFilterName )
3782 {
3783   LDOM_Node aParentNode;
3784   LDOM_Node aFilterNode = findFilter( theFilterName, myDoc, &aParentNode );
3785   if ( aFilterNode.isNull() || aParentNode.isNull() )
3786     return false;
3787
3788   aParentNode.removeChild( aFilterNode );
3789   TPythonDump()<<this<<".Delete('"<<theFilterName<<"')";
3790   return true;
3791 }
3792
3793 //=======================================================================
3794 // name      : FilterLibrary_i::Replace
3795 // Purpose   : Replace existing filter with entry filter.
3796 // IMPORTANT : If filter does not exist it is not created
3797 //=======================================================================
3798 CORBA::Boolean FilterLibrary_i::Replace( const char* theFilterName,
3799                                          const char* theNewName,
3800                                          Filter_ptr  theFilter )
3801 {
3802   LDOM_Element aFilterItem = findFilter( theFilterName, myDoc );
3803   if ( aFilterItem.isNull() || theFilter->_is_nil() )
3804     return false;
3805
3806   LDOM_Element aNewItem = createFilterItem( theNewName, theFilter, myDoc );
3807   if ( aNewItem.isNull() )
3808     return false;
3809   else
3810   {
3811     aFilterItem.ReplaceElement( aNewItem );
3812     if(Filter_i* aFilter = DownCast<Filter_i*>(theFilter))
3813       TPythonDump()<<this<<".Replace('"<<theFilterName<<"','"<<theNewName<<"',"<<aFilter<<")";
3814     return true;
3815   }
3816 }
3817
3818 //=======================================================================
3819 // name    : FilterLibrary_i::Save
3820 // Purpose : Save library on disk
3821 //=======================================================================
3822 CORBA::Boolean FilterLibrary_i::Save()
3823 {
3824   if ( myFileName == 0 || strlen( myFileName ) == 0 )
3825     return false;
3826
3827   FILE* aOutFile = fopen( myFileName, "wt" );
3828   if ( !aOutFile )
3829     return false;
3830
3831   LDOM_XmlWriter aWriter( aOutFile );
3832   aWriter.SetIndentation( 2 );
3833   aWriter << myDoc;
3834   fclose( aOutFile );
3835
3836   TPythonDump()<<this<<".Save()";
3837   return true;
3838 }
3839
3840 //=======================================================================
3841 // name    : FilterLibrary_i::SaveAs
3842 // Purpose : Save library on disk
3843 //=======================================================================
3844 CORBA::Boolean FilterLibrary_i::SaveAs( const char* aFileName )
3845 {
3846   myFileName = strdup ( aFileName );
3847   TPythonDump()<<this<<".SaveAs('"<<aFileName<<"')";
3848   return Save();
3849 }
3850
3851 //=======================================================================
3852 // name    : FilterLibrary_i::IsPresent
3853 // Purpose : Verify whether filter is in library
3854 //=======================================================================
3855 CORBA::Boolean FilterLibrary_i::IsPresent( const char* theFilterName )
3856 {
3857   return !findFilter( theFilterName, myDoc ).isNull();
3858 }
3859
3860 //=======================================================================
3861 // name    : FilterLibrary_i::NbFilters
3862 // Purpose : Return amount of filters in library
3863 //=======================================================================
3864 CORBA::Long FilterLibrary_i::NbFilters( ElementType theType )
3865 {
3866   string_array_var aNames = GetNames( theType );
3867   return aNames->length();
3868 }
3869
3870 //=======================================================================
3871 // name    : FilterLibrary_i::GetNames
3872 // Purpose : Get names of filters from library
3873 //=======================================================================
3874 string_array* FilterLibrary_i::GetNames( ElementType theType )
3875 {
3876   string_array_var anArray = new string_array;
3877   TColStd_SequenceOfHAsciiString aSeq;
3878
3879   LDOM_Node aSection = getSection( theType, myDoc, false );
3880
3881   if ( !aSection.isNull() )
3882   {
3883     for ( LDOM_Node aFilter = aSection.getFirstChild();
3884           !aFilter.isNull(); aFilter = aFilter.getNextSibling() )
3885     {
3886       LDOM_Element& anElem = ( LDOM_Element& )aFilter;
3887       aSeq.Append( new TCollection_HAsciiString(
3888          (Standard_CString)anElem.getAttribute( "name" ).GetString() ) );
3889     }
3890   }
3891
3892   anArray->length( aSeq.Length() );
3893   for ( int i = 1, n = aSeq.Length(); i <= n; i++ )
3894     anArray[ i - 1 ] = CORBA::string_dup( aSeq( i )->ToCString() );
3895
3896   return anArray._retn();
3897 }
3898
3899 //=======================================================================
3900 // name    : FilterLibrary_i::GetAllNames
3901 // Purpose : Get names of filters from library
3902 //=======================================================================
3903 string_array* FilterLibrary_i::GetAllNames()
3904 {
3905   string_array_var aResArray = new string_array;
3906   for ( int type = SMESH::ALL; type <= SMESH::VOLUME; type++ )
3907   {
3908     SMESH::string_array_var aNames = GetNames( (SMESH::ElementType)type );
3909
3910     int aPrevLength = aResArray->length();
3911     aResArray->length( aPrevLength + aNames->length() );
3912     for ( int i = 0, n = aNames->length(); i < n; i++ )
3913       aResArray[ aPrevLength + i ] = aNames[ i ];
3914   }
3915
3916   return aResArray._retn();
3917 }
3918
3919 //================================================================================
3920 /*!
3921  * \brief Return an array of strings corresponding to items of enum FunctorType
3922  */
3923 //================================================================================
3924
3925 static const char** getFunctNames()
3926 {
3927   static const char* functName[ SMESH::FT_Undefined + 1 ] = {
3928     // IT's necessary to update this array according to enum FunctorType (SMESH_Filter.idl)
3929     // The order is IMPORTANT !!!
3930     "FT_AspectRatio",
3931     "FT_AspectRatio3D",
3932     "FT_Warping",
3933     "FT_MinimumAngle",
3934     "FT_Taper",
3935     "FT_Skew",
3936     "FT_Area",
3937     "FT_Volume3D",
3938     "FT_MaxElementLength2D",
3939     "FT_MaxElementLength3D",
3940     "FT_FreeBorders",
3941     "FT_FreeEdges",
3942     "FT_FreeNodes",
3943     "FT_FreeFaces",
3944     "FT_EqualNodes",
3945     "FT_EqualEdges",
3946     "FT_EqualFaces",
3947     "FT_EqualVolumes",
3948     "FT_MultiConnection",
3949     "FT_MultiConnection2D",
3950     "FT_Length",
3951     "FT_Length2D",
3952     "FT_BelongToGeom",
3953     "FT_BelongToPlane",
3954     "FT_BelongToCylinder",
3955     "FT_BelongToGenSurface",
3956     "FT_LyingOnGeom",
3957     "FT_RangeOfIds",
3958     "FT_BadOrientedVolume",
3959     "FT_BareBorderVolume",
3960     "FT_BareBorderFace",
3961     "FT_OverConstrainedVolume",
3962     "FT_OverConstrainedFace",
3963     "FT_LinearOrQuadratic",
3964     "FT_GroupColor",
3965     "FT_ElemGeomType",
3966     "FT_EntityType",
3967     "FT_CoplanarFaces",
3968     "FT_BallDiameter",
3969     "FT_LessThan",
3970     "FT_MoreThan",
3971     "FT_EqualTo",
3972     "FT_LogicalNOT",
3973     "FT_LogicalAND",
3974     "FT_LogicalOR",
3975     "FT_Undefined"};
3976   return functName;
3977 }
3978
3979 //================================================================================
3980 /*!
3981  * \brief Return a string corresponding to an item of enum FunctorType
3982  */
3983 //================================================================================
3984
3985 const char* SMESH::FunctorTypeToString(SMESH::FunctorType ft)
3986 {
3987   if ( ft < 0 || ft > SMESH::FT_Undefined )
3988     return "FT_Undefined";
3989   return getFunctNames()[ ft ];
3990 }
3991
3992 //================================================================================
3993 /*!
3994  * \brief Converts a string to FunctorType. This is reverse of FunctorTypeToString()
3995  */
3996 //================================================================================
3997
3998 SMESH::FunctorType SMESH::StringToFunctorType(const char* str)
3999 {
4000   std::string name( str + 3 ); // skip "FT_"
4001   const char** functNames = getFunctNames();
4002   int ft = 0;
4003   for ( ; ft < SMESH::FT_Undefined; ++ft )
4004     if ( name == ( functNames[ft] + 3 ))
4005       break;
4006
4007   //ASSERT( strcmp( str, FunctorTypeToString( SMESH::FunctorType( ft ))) == 0 );
4008
4009   return SMESH::FunctorType( ft );
4010 }