src/SMESH_I/SMESH_Filter_i.cxx

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