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