src/SMESHGUI/SMESHGUI_Filter.cxx

   1 //  Copyright (C) 2007-2008  CEA/DEN, EDF R&D, OPEN CASCADE
   2 //
   3 //  Copyright (C) 2003-2007  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
   4 //  CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
   5 //
   6 //  This library is free software; you can redistribute it and/or
   7 //  modify it under the terms of the GNU Lesser General Public
   8 //  License as published by the Free Software Foundation; either
   9 //  version 2.1 of the License.
  10 //
  11 //  This library is distributed in the hope that it will be useful,
  12 //  but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 //  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14 //  Lesser General Public License for more details.
  15 //
  16 //  You should have received a copy of the GNU Lesser General Public
  17 //  License along with this library; if not, write to the Free Software
  18 //  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  19 //
  20 //  See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
  21 //
  22 // SMESHGUI_Filter : Filters for VTK viewer
  23 // File   : SMESHGUI_Filter.cxx
  24 // Author : Sergey LITONIN, Open CASCADE S.A.S.
  25 // SMESH includes
  26 //
  27 #include "SMESHGUI_Filter.h"
  28
  29 #include "SMESHGUI_Utils.h"
  30
  31 #include <SMESH_Actor.h>
  32 #include <SMDS_Mesh.hxx>
  33 #include <SMDSAbs_ElementType.hxx>
  34
  35 IMPLEMENT_STANDARD_HANDLE(SMESHGUI_Filter, VTKViewer_Filter)
  36 IMPLEMENT_STANDARD_RTTIEXT(SMESHGUI_Filter, VTKViewer_Filter)
  37
  38 IMPLEMENT_STANDARD_HANDLE(SMESHGUI_PredicateFilter, SMESHGUI_Filter)
  39 IMPLEMENT_STANDARD_RTTIEXT(SMESHGUI_PredicateFilter, SMESHGUI_Filter)
  40
  41 IMPLEMENT_STANDARD_HANDLE(SMESHGUI_QuadrangleFilter, SMESHGUI_Filter)
  42 IMPLEMENT_STANDARD_RTTIEXT(SMESHGUI_QuadrangleFilter, SMESHGUI_Filter)
  43
  44 IMPLEMENT_STANDARD_HANDLE(SMESHGUI_TriangleFilter, SMESHGUI_Filter)
  45 IMPLEMENT_STANDARD_RTTIEXT(SMESHGUI_TriangleFilter, SMESHGUI_Filter)
  46
  47 IMPLEMENT_STANDARD_HANDLE(SMESHGUI_FacesFilter, SMESHGUI_Filter)
  48 IMPLEMENT_STANDARD_RTTIEXT(SMESHGUI_FacesFilter, SMESHGUI_Filter)
  49
  50 IMPLEMENT_STANDARD_HANDLE(SMESHGUI_VolumesFilter, SMESHGUI_Filter)
  51 IMPLEMENT_STANDARD_RTTIEXT(SMESHGUI_VolumesFilter, SMESHGUI_Filter)
  52
  53 /*
  54   Class       : SMESHGUI_PredicateFilter
  55   Description : Selection filter for VTK viewer. This class aggregate object
  56                 of SMESH_Predicate class and uses it for verification of criterion
  57 */
  58
  59 //=======================================================================
  60 // name    : SMESHGUI_PredicateFilter::SMESHGUI_PredicateFilter
  61 // Purpose : Constructor
  62 //=======================================================================
  63 SMESHGUI_PredicateFilter::SMESHGUI_PredicateFilter()
  64 {
  65 }
  66
  67 SMESHGUI_PredicateFilter::~SMESHGUI_PredicateFilter()
  68 {
  69 }
  70
  71 //=======================================================================
  72 // name    : SMESHGUI_PredicateFilter::IsValid
  73 // Purpose : Verify whether entry id satisfies to criterion of the filter
  74 //=======================================================================
  75 bool SMESHGUI_PredicateFilter::IsValid( const int theCellId ) const
  76 {
  77   if ( myActor == 0 || myPred->_is_nil() )
  78     return false;
  79
  80   SMESH_Actor* anActor = dynamic_cast<SMESH_Actor*>( myActor );
  81   if ( !anActor || anActor->GetObject() == 0 )
  82     return false;
  83
  84   SMDS_Mesh* aMesh = anActor->GetObject()->GetMesh();
  85   SMDSAbs_ElementType anElemType = (SMDSAbs_ElementType)myPred->GetElementType();
  86   int aMeshId = anElemType == SMDSAbs_Node ? anActor->GetNodeObjId( theCellId )
  87                                            : anActor->GetElemObjId( theCellId );
  88
  89   // if type of element != type of predicate return true because
  90   // this predicate is not intended for filtering sush elements
  91   const SMDS_MeshElement* anElem = anElemType == SMDSAbs_Node ? aMesh->FindNode( aMeshId )
  92                                                               : aMesh->FindElement( aMeshId );
  93   // here we guess that predicate element type can not be All in case of node selection
  94   if ( !anElem || (anElemType != SMDSAbs_All && anElem->GetType() != anElemType) )
  95     return false;
  96
  97   return myPred->IsSatisfy( aMeshId );
  98 }
  99
 100 //=======================================================================
 101 // name    : SMESHGUI_PredicateFilter::IsValid
 102 // Purpose : Verify whether entry id satisfies to criterion of the filter
 103 //=======================================================================
 104 bool SMESHGUI_PredicateFilter::IsObjValid( const int theObjId ) const
 105 {
 106   if ( myActor == 0 || myPred->_is_nil() )
 107     return false;
 108
 109   SMESH_Actor* anActor = ( SMESH_Actor* )myActor;
 110   if ( anActor->GetObject() == 0 )
 111     return false;
 112
 113   SMDS_Mesh* aMesh = anActor->GetObject()->GetMesh();
 114   SMDSAbs_ElementType anElemType = (SMDSAbs_ElementType)myPred->GetElementType();
 115
 116   // if type of element != type of predicate return true because
 117   // this predicate is not intended for filtering sush elements
 118   const SMDS_MeshElement* anElem = anElemType == SMDSAbs_Node ? aMesh->FindNode( theObjId )
 119                                                               : aMesh->FindElement( theObjId );
 120   // here we guess that predicate element type can not be All in case of node selection
 121   if ( !anElem || (anElemType != SMDSAbs_All && anElem->GetType() != anElemType) )
 122     return false;
 123
 124   return myPred->IsSatisfy( theObjId );
 125 }
 126
 127 //=======================================================================
 128 // name    : SMESHGUI_PredicateFilter::IsNodeFilter
 129 // Purpose : Returns true if filter is intended for nodes
 130 //=======================================================================
 131 bool SMESHGUI_PredicateFilter::IsNodeFilter() const
 132 {
 133   return GetId() == SMESH::NodeFilter;
 134 }
 135
 136 //=======================================================================
 137 // name    : SMESHGUI_PredicateFilter::SetPredicate
 138 // Purpose : Set new pridicate to the filter
 139 //=======================================================================
 140 void SMESHGUI_PredicateFilter::SetPredicate( SMESH::Predicate_ptr thePred )
 141 {
 142   myPred = SMESH::Predicate::_duplicate( thePred );
 143 }
 144
 145 //=======================================================================
 146 // name    : SMESHGUI_PredicateFilter::SetActor
 147 // Purpose : Set new actor
 148 //=======================================================================
 149 void SMESHGUI_PredicateFilter::SetActor( SALOME_Actor* theActor )
 150 {
 151   if ( myActor == theActor )
 152     return;
 153   SMESHGUI_Filter::SetActor( theActor );
 154
 155   if ( myActor != 0 && !myPred->_is_nil() )
 156   {
 157     SALOME_Actor* sActor = dynamic_cast<SALOME_Actor*>( myActor );
 158     Handle(SALOME_InteractiveObject) anIO;
 159     if( sActor )
 160       anIO = sActor->getIO();
 161     if ( !anIO.IsNull() )
 162     {
 163       SMESH::SMESH_Mesh_var aMesh = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(anIO);
 164       if(!aMesh->_is_nil())
 165         myPred->SetMesh(aMesh);
 166     }
 167   }
 168 }
 169
 170 //=======================================================================
 171 // name    : SMESHGUI_PredicateFilter::SetActor
 172 // Purpose : Get ID of the filter. Must return value from SMESHGUI_FilterType
 173 //           enumeration. All filters must have different ids
 174 //=======================================================================
 175 int SMESHGUI_PredicateFilter::GetId() const
 176 {
 177   if      ( myPred->GetElementType() == SMESH::NODE   ) return SMESH::NodeFilter;
 178   else if ( myPred->GetElementType() == SMESH::EDGE   ) return SMESH::EdgeFilter;
 179   else if ( myPred->GetElementType() == SMESH::FACE   ) return SMESH::FaceFilter;
 180   else if ( myPred->GetElementType() == SMESH::VOLUME ) return SMESH::VolumeFilter;
 181   else if ( myPred->GetElementType() == SMESH::ALL    ) return SMESH::AllElementsFilter;
 182   else                                                  return SMESH::UnknownFilter;
 183 }
 184
 185
 186 /*
 187   Class       : SMESHGUI_QuadrangleFilter
 188   Description : Verify whether selected cell is quadranle
 189 */
 190
 191 //=======================================================================
 192 // name    : SMESHGUI_QuadrangleFilter::SMESHGUI_QuadrangleFilter
 193 // Purpose : Constructor
 194 //=======================================================================
 195 SMESHGUI_QuadrangleFilter::SMESHGUI_QuadrangleFilter()
 196 : SMESHGUI_Filter()
 197 {
 198 }
 199
 200 SMESHGUI_QuadrangleFilter::~SMESHGUI_QuadrangleFilter()
 201 {
 202 }
 203
 204 //=======================================================================
 205 // name    : SMESHGUI_QuadrangleFilter::IsValid
 206 // Purpose : Verify whether selected cell is quadranle
 207 //=======================================================================
 208 bool SMESHGUI_QuadrangleFilter::IsValid( const int theCellId ) const
 209 {
 210   if ( myActor == 0 )
 211     return false;
 212
 213   SMESH_Actor* anActor = ( SMESH_Actor* )myActor;
 214   if ( anActor->GetObject() == 0 )
 215     return false;
 216
 217   SMDS_Mesh* aMesh = anActor->GetObject()->GetMesh();
 218   const SMDS_MeshElement* anElem = aMesh->FindElement( anActor->GetElemObjId( theCellId ) );
 219
 220   return anElem && anElem->GetType() == SMDSAbs_Face &&
 221     ( anElem->NbNodes() == ( anElem->IsQuadratic() ? 8 : 4 ));
 222 }
 223
 224 //=======================================================================
 225 // name    : SMESHGUI_QuadrangleFilter::IsValid
 226 // Purpose : Verify whether selected cell is quadranle
 227 //=======================================================================
 228 bool SMESHGUI_QuadrangleFilter::IsObjValid( const int theObjId ) const
 229 {
 230   if ( myActor == 0 )
 231     return false;
 232
 233   SMESH_Actor* anActor = ( SMESH_Actor* )myActor;
 234   if ( anActor->GetObject() == 0 )
 235     return false;
 236
 237   SMDS_Mesh* aMesh = anActor->GetObject()->GetMesh();
 238   const SMDS_MeshElement* anElem = aMesh->FindElement( theObjId );
 239
 240   return anElem && anElem->GetType() == SMDSAbs_Face &&
 241     ( anElem->NbNodes() == ( anElem->IsQuadratic() ? 8  : 4 ));
 242 }
 243
 244 //=======================================================================
 245 // name    : SMESHGUI_QuadrangleFilter::SetActor
 246 // Purpose : Get ID of the filter. Must return value from SMESHGUI_FilterType
 247 //           enumeration. All filters must have different ids
 248 //=======================================================================
 249 int SMESHGUI_QuadrangleFilter::GetId() const
 250 {
 251   return SMESH::QuadFilter;
 252 }
 253
 254 //=======================================================================
 255 // name    : SMESHGUI_QuadrangleFilter::IsNodeFilter
 256 // Purpose : Returns true if filter is intended for nodes
 257 //=======================================================================
 258 bool SMESHGUI_QuadrangleFilter::IsNodeFilter() const
 259 {
 260   return false;
 261 }
 262
 263
 264 /*
 265   Class       : SMESHGUI_TriangleFilter
 266   Description : Verify whether selected cell is triangle
 267 */
 268
 269
 270 //=======================================================================
 271 // name    : SMESHGUI_TriangleFilter::SMESHGUI_TriangleFilter
 272 // Purpose : Constructor
 273 //=======================================================================
 274 SMESHGUI_TriangleFilter::SMESHGUI_TriangleFilter()
 275 : SMESHGUI_Filter()
 276 {
 277 }
 278
 279 SMESHGUI_TriangleFilter::~SMESHGUI_TriangleFilter()
 280 {
 281 }
 282
 283 //=======================================================================
 284 // name    : SMESHGUI_TriangleFilter::IsValid
 285 // Purpose : Verify whether selected cell is triangle
 286 //=======================================================================
 287 bool SMESHGUI_TriangleFilter::IsValid( const int theCellId ) const
 288 {
 289   if ( myActor == 0 )
 290     return false;
 291
 292   SMESH_Actor* anActor = ( SMESH_Actor* )myActor;
 293   if ( anActor->GetObject() == 0 )
 294     return false;
 295
 296   SMDS_Mesh* aMesh = anActor->GetObject()->GetMesh();
 297   const SMDS_MeshElement* anElem = aMesh->FindElement( anActor->GetElemObjId( theCellId ) );
 298
 299   return anElem && anElem->GetType() == SMDSAbs_Face &&
 300     ( anElem->NbNodes() == ( anElem->IsQuadratic() ? 6  : 3 ));
 301 }
 302
 303 //=======================================================================
 304 // name    : SMESHGUI_TriangleFilter::IsValid
 305 // Purpose : Verify whether selected cell is triangle
 306 //=======================================================================
 307 bool SMESHGUI_TriangleFilter::IsObjValid( const int theObjId ) const
 308 {
 309   if ( myActor == 0 )
 310     return false;
 311
 312   SMESH_Actor* anActor = ( SMESH_Actor* )myActor;
 313   if ( anActor->GetObject() == 0 )
 314     return false;
 315
 316   SMDS_Mesh* aMesh = anActor->GetObject()->GetMesh();
 317   const SMDS_MeshElement* anElem = aMesh->FindElement( theObjId );
 318
 319   return anElem && anElem->GetType() == SMDSAbs_Face &&
 320     ( anElem->NbNodes() == ( anElem->IsQuadratic() ? 6  : 3 ));
 321 }
 322
 323 //=======================================================================
 324 // name    : SMESHGUI_TriangleFilter::SetActor
 325 // Purpose : Get ID of the filter. Must return value from SMESHGUI_FilterType
 326 //           enumeration. All filters must have different ids
 327 //=======================================================================
 328 int SMESHGUI_TriangleFilter::GetId() const
 329 {
 330   return SMESH::TriaFilter;
 331 }
 332
 333 //=======================================================================
 334 // name    : SMESHGUI_TriangleFilter::IsNodeFilter
 335 // Purpose : Returns true if filter is intended for nodes
 336 //=======================================================================
 337 bool SMESHGUI_TriangleFilter::IsNodeFilter() const
 338 {
 339   return false;
 340 }
 341
 342 /*
 343   Class       : SMESHGUI_FacesFilter
 344   Description : Verify whether selected cell is any face
 345 */
 346
 347
 348 //=======================================================================
 349 // name    : SMESHGUI_FacesFilter::SMESHGUI_FacesFilter
 350 // Purpose : Constructor
 351 //=======================================================================
 352 SMESHGUI_FacesFilter::SMESHGUI_FacesFilter()
 353 : SMESHGUI_Filter()
 354 {
 355 }
 356
 357 SMESHGUI_FacesFilter::~SMESHGUI_FacesFilter()
 358 {
 359 }
 360
 361 //=======================================================================
 362 // name    : SMESHGUI_FacesFilter::IsValid
 363 // Purpose : Verify whether selected cell is face
 364 //=======================================================================
 365 bool SMESHGUI_FacesFilter::IsValid( const int theCellId ) const
 366 {
 367   if ( myActor == 0 )
 368     return false;
 369
 370   SMESH_Actor* anActor = ( SMESH_Actor* )myActor;
 371   if ( anActor->GetObject() == 0 )
 372     return false;
 373
 374   SMDS_Mesh* aMesh = anActor->GetObject()->GetMesh();
 375   const SMDS_MeshElement* anElem = aMesh->FindElement( anActor->GetElemObjId( theCellId ) );
 376
 377   return anElem && anElem->GetType() == SMDSAbs_Face;
 378 }
 379
 380 //=======================================================================
 381 // name    : SMESHGUI_FacesFilter::IsValid
 382 // Purpose : Verify whether selected cell is face
 383 //=======================================================================
 384 bool SMESHGUI_FacesFilter::IsObjValid( const int theObjId ) const
 385 {
 386   if ( myActor == 0 )
 387     return false;
 388
 389   SMESH_Actor* anActor = ( SMESH_Actor* )myActor;
 390   if ( anActor->GetObject() == 0 )
 391     return false;
 392
 393   SMDS_Mesh* aMesh = anActor->GetObject()->GetMesh();
 394   const SMDS_MeshElement* anElem = aMesh->FindElement( theObjId );
 395
 396   return anElem && anElem->GetType() == SMDSAbs_Face;
 397 }
 398
 399 //=======================================================================
 400 // name    : SMESHGUI_FacesFilter::GetId
 401 // Purpose : Get ID of the filter. Must return value from SMESHGUI_FilterType
 402 //           enumeration. All filters must have different ids
 403 //=======================================================================
 404 int SMESHGUI_FacesFilter::GetId() const
 405 {
 406   return SMESH::FaceFilter;
 407 }
 408
 409 //=======================================================================
 410 // name    : SMESHGUI_FacesFilter::IsNodeFilter
 411 // Purpose : Returns true if filter is intended for nodes
 412 //=======================================================================
 413 bool SMESHGUI_FacesFilter::IsNodeFilter() const
 414 {
 415   return false;
 416 }
 417
 418
 419 /*
 420   Class       : SMESHGUI_VolumesFilter
 421   Description : Verify whether selected cell is any volume
 422 */
 423
 424
 425 //=======================================================================
 426 // name    : SMESHGUI_VolumesFilter::SMESHGUI_VolumesFilter
 427 // Purpose : Constructor
 428 //=======================================================================
 429 SMESHGUI_VolumesFilter::SMESHGUI_VolumesFilter()
 430 : SMESHGUI_Filter()
 431 {
 432 }
 433
 434 SMESHGUI_VolumesFilter::~SMESHGUI_VolumesFilter()
 435 {
 436 }
 437
 438 //=======================================================================
 439 // name    : SMESHGUI_VolumesFilter::IsValid
 440 // Purpose : Verify whether selected cell is volume
 441 //=======================================================================
 442 bool SMESHGUI_VolumesFilter::IsValid( const int theCellId ) const
 443 {
 444   if ( myActor == 0 )
 445     return false;
 446
 447   SMESH_Actor* anActor = ( SMESH_Actor* )myActor;
 448   if ( anActor->GetObject() == 0 )
 449     return false;
 450
 451   SMDS_Mesh* aMesh = anActor->GetObject()->GetMesh();
 452   const SMDS_MeshElement* anElem = aMesh->FindElement( anActor->GetElemObjId( theCellId ) );
 453
 454   return anElem && anElem->GetType() == SMDSAbs_Volume;
 455 }
 456
 457 //=======================================================================
 458 // name    : SMESHGUI_VolumesFilter::IsValid
 459 // Purpose : Verify whether selected cell is volume
 460 //=======================================================================
 461 bool SMESHGUI_VolumesFilter::IsObjValid( const int theObjId ) const
 462 {
 463   if ( myActor == 0 )
 464     return false;
 465
 466   SMESH_Actor* anActor = ( SMESH_Actor* )myActor;
 467   if ( anActor->GetObject() == 0 )
 468     return false;
 469
 470   SMDS_Mesh* aMesh = anActor->GetObject()->GetMesh();
 471   const SMDS_MeshElement* anElem = aMesh->FindElement( theObjId );
 472
 473   return anElem && anElem->GetType() == SMDSAbs_Volume;
 474 }
 475
 476 //=======================================================================
 477 // name    : SMESHGUI_VolumesFilter::GetId
 478 // Purpose : Get ID of the filter. Must return value from SMESHGUI_FilterType
 479 //           enumeration. All filters must have different ids
 480 //=======================================================================
 481 int SMESHGUI_VolumesFilter::GetId() const
 482 {
 483   return SMESH::VolumeFilter;
 484 }
 485
 486 //=======================================================================
 487 // name    : SMESHGUI_VolumesFilter::IsNodeFilter
 488 // Purpose : Returns true if filter is intended for nodes
 489 //=======================================================================
 490 bool SMESHGUI_VolumesFilter::IsNodeFilter() const
 491 {
 492   return false;
 493 }