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