Version: 6.3.1
Public Member Functions | Static Public Member Functions | Private Attributes

SMESH.Filter_i Class Reference

#include <SMESH_Filter_i.hxx>

Inheritance diagram for SMESH.Filter_i:
Inheritance graph
[legend]

Public Member Functions

 Filter_i ()
 ~Filter_i ()
virtual void SetPredicate (Predicate_ptr)
virtual void SetMesh (SMESH_Mesh_ptr)
virtual long_array * GetElementsId (SMESH_Mesh_ptr)
virtual ElementType GetElementType ()
virtual CORBA::Boolean GetCriteria (SMESH::Filter::Criteria_out theCriteria)
virtual CORBA::Boolean SetCriteria (const SMESH::Filter::Criteria &theCriteria)
virtual Predicate_ptr GetPredicate ()
Predicate_i * GetPredicate_i ()
virtual SMESH::long_array * GetIDs ()
virtual SMESH::long_array * GetMeshInfo ()
 Returns statistic of mesh elements.
virtual
SMESH::array_of_ElementType * 		GetTypes ()
 Return GetElementType() within an array Implement SMESH_IDSource interface.
virtual SMESH::SMESH_Mesh_ptr GetMesh ()

Static Public Member Functions

static void GetElementsId (Predicate_i *, const SMDS_Mesh *, Controls::Filter::TIdSequence &)
static void GetElementsId (Predicate_i *, SMESH_Mesh_ptr, Controls::Filter::TIdSequence &)

Private Attributes

Controls::Filter myFilter
Predicate_i * myPredicate
SMESH_Mesh_var myMesh

Detailed Description

Definition at line 868 of file SMESH_Filter_i.hxx.

Constructor & Destructor Documentation

Filter_i::Filter_i ( )

Definition at line 2259 of file SMESH_Filter_i.cxx.

: myPredicate( NULL )
{}
Filter_i::~Filter_i ( )

Definition at line 2267 of file SMESH_Filter_i.cxx.

References SMESH.Filter_i.myMesh, and SMESH.Filter_i.myPredicate.

{
  if ( myPredicate )
    myPredicate->UnRegister();

  if(!CORBA::is_nil(myMesh))
    myMesh->UnRegister();

  //TPythonDump()<<this<<".UnRegister()";
}

Member Function Documentation

CORBA::Boolean Filter_i::GetCriteria ( SMESH::Filter::Criteria_out  theCriteria) [virtual]

Definition at line 2712 of file SMESH_Filter_i.cxx.

References getCriteria(), and SMESH.Filter_i.myPredicate.

{
  theCriteria = new SMESH::Filter::Criteria;
  return myPredicate != 0 ? getCriteria( myPredicate, theCriteria ) : true;
}
void Filter_i::GetElementsId ( Predicate_i *  thePredicate,
SMESH_Mesh_ptr  theMesh,
Controls::Filter::TIdSequence &  theSequence 
) [static]

Definition at line 2347 of file SMESH_Filter_i.cxx.

References SMESH.Filter_i.GetElementsId(), SMESH.Predicate_i.GetPredicate(), and MeshPtr2SMDSMesh().

{
  if (thePredicate) 
    if(const SMDS_Mesh* aMesh = MeshPtr2SMDSMesh(theMesh))
      Controls::Filter::GetElementsId(aMesh,thePredicate->GetPredicate(),theSequence);
}
SMESH::long_array * Filter_i::GetElementsId ( SMESH_Mesh_ptr  theMesh) [virtual]

Definition at line 2358 of file SMESH_Filter_i.cxx.

References SMESH.Filter_i.GetElementsId(), and SMESH.Filter_i.myPredicate.

{
  SMESH::long_array_var anArray = new SMESH::long_array;
  if(!CORBA::is_nil(theMesh) && myPredicate){
    Controls::Filter::TIdSequence aSequence;
    GetElementsId(myPredicate,theMesh,aSequence);
    long i = 0, iEnd = aSequence.size();
    anArray->length( iEnd );
    for ( ; i < iEnd; i++ )
      anArray[ i ] = aSequence[i];
  }
  return anArray._retn();
}
void Filter_i::GetElementsId ( Predicate_i *  thePredicate,
const SMDS_Mesh *  theMesh,
Controls::Filter::TIdSequence &  theSequence 
) [static]

Definition at line 2337 of file SMESH_Filter_i.cxx.

References SMESH.Predicate_i.GetPredicate().

Referenced by ChangeByPredicate(), SMESH.Filter_i.GetElementsId(), and SMESH.Filter_i.GetIDs().

{
  if (thePredicate)
    Controls::Filter::GetElementsId(theMesh,thePredicate->GetPredicate(),theSequence);
}
SMESH::ElementType Filter_i::GetElementType ( ) [virtual]

Definition at line 2301 of file SMESH_Filter_i.cxx.

References SMESH.ALL, SMESH.Functor_i.GetElementType(), and SMESH.Filter_i.myPredicate.

Referenced by SMESH.Filter_i.GetTypes().

{
  return myPredicate != 0 ? myPredicate->GetElementType() : SMESH::ALL;
}
SMESH::long_array * Filter_i::GetIDs ( ) [virtual]

Definition at line 2326 of file SMESH_Filter_i.cxx.

References SMESH.Filter_i.GetElementsId(), and SMESH.Filter_i.myMesh.

{
  return GetElementsId(myMesh);
}
SMESH::SMESH_Mesh_ptr Filter_i::GetMesh ( ) [virtual]

Definition at line 2446 of file SMESH_Filter_i.cxx.

References SMESH.Filter_i.myMesh.

{
  return SMESH_Mesh::_duplicate( myMesh );
}
SMESH::long_array * Filter_i::GetMeshInfo ( ) [virtual]

Returns statistic of mesh elements.

Definition at line 2391 of file SMESH_Filter_i.cxx.

References SMDS_Mesh.edgesIterator(), SMDS_Mesh.elementsIterator(), SMESH.Entity_Last, SMESH.Entity_Node, SMDS_Mesh.facesIterator(), MeshPtr2SMDSMesh(), SMDS_Mesh.nodesIterator(), SMDSAbs_All, SMDSAbs_Edge, SMDSAbs_Face, SMDSAbs_Node, SMDSAbs_Volume, and SMDS_Mesh.volumesIterator().

{
  SMESH::long_array_var aRes = new SMESH::long_array();
  aRes->length(SMESH::Entity_Last);
  for (int i = SMESH::Entity_Node; i < SMESH::Entity_Last; i++)
    aRes[i] = 0;

  if(!CORBA::is_nil(myMesh) && myPredicate) {
    const SMDS_Mesh* aMesh = MeshPtr2SMDSMesh(myMesh);
    SMDS_ElemIteratorPtr it;
    switch( GetElementType() )
    {
  case SMDSAbs_Node:
    collectMeshInfo<const SMDS_MeshNode*>(aMesh->nodesIterator(),myPredicate,aRes);
    break;
  case SMDSAbs_Edge:
    collectMeshInfo<const SMDS_MeshElement*>(aMesh->edgesIterator(),myPredicate,aRes);
    break;
  case SMDSAbs_Face:
    collectMeshInfo<const SMDS_MeshElement*>(aMesh->facesIterator(),myPredicate,aRes);
    break;
  case SMDSAbs_Volume:
    collectMeshInfo<const SMDS_MeshElement*>(aMesh->volumesIterator(),myPredicate,aRes);
    break;
  case SMDSAbs_All:
  default:
    collectMeshInfo<const SMDS_MeshElement*>(aMesh->elementsIterator(),myPredicate,aRes);
    break;
    }
  }


  return aRes._retn();  
}
Predicate_ptr Filter_i::GetPredicate ( ) [virtual]

Definition at line 3052 of file SMESH_Filter_i.cxx.

References SMESH.Filter_i.myPredicate.

Referenced by SMESH.Filter_i.SetPredicate().

{
  if ( myPredicate == 0 )
    return SMESH::Predicate::_nil();
  else
  {
    SMESH::Predicate_var anObj = myPredicate->_this();
    return anObj._retn();
  }
}
Predicate_i * Filter_i::GetPredicate_i ( )

Definition at line 3043 of file SMESH_Filter_i.cxx.

References SMESH.Filter_i.myPredicate.

{
  return myPredicate;
}
SMESH::array_of_ElementType * Filter_i::GetTypes ( ) [virtual]

Return GetElementType() within an array Implement SMESH_IDSource interface.

Definition at line 2433 of file SMESH_Filter_i.cxx.

References SMESH.Filter_i.GetElementType().

{
  SMESH::array_of_ElementType_var types = new SMESH::array_of_ElementType;
  types->length( 1 );
  types[0] = GetElementType();
  return types._retn();
}
CORBA::Boolean Filter_i::SetCriteria ( const SMESH::Filter::Criteria &  theCriteria) [virtual]

Definition at line 2722 of file SMESH_Filter_i.cxx.

References SMESH_freebord.aCriterion, SMESH.FT_Area, SMESH.FT_AspectRatio, SMESH.FT_AspectRatio3D, SMESH.FT_BadOrientedVolume, SMESH.FT_BareBorderFace, SMESH.FT_BareBorderVolume, SMESH.FT_BelongToCylinder, SMESH.FT_BelongToGenSurface, SMESH.FT_BelongToGeom, SMESH.FT_BelongToPlane, SMESH.FT_CoplanarFaces, SMESH.FT_ElemGeomType, SMESH.FT_EqualTo, SMESH.FT_FreeBorders, SMESH.FT_FreeEdges, SMESH.FT_FreeFaces, SMESH.FT_FreeNodes, SMESH.FT_GroupColor, SMESH.FT_Length, SMESH.FT_Length2D, SMESH.FT_LessThan, SMESH.FT_LinearOrQuadratic, SMESH.FT_LogicalAND, SMESH.FT_LogicalNOT, SMESH.FT_LyingOnGeom, SMESH.FT_MaxElementLength2D, SMESH.FT_MaxElementLength3D, SMESH.FT_MinimumAngle, SMESH.FT_MoreThan, SMESH.FT_MultiConnection, SMESH.FT_MultiConnection2D, SMESH.FT_OverConstrainedFace, SMESH.FT_OverConstrainedVolume, SMESH.FT_RangeOfIds, SMESH.FT_Skew, SMESH.FT_Taper, SMESH.FT_Undefined, SMESH.FT_Volume3D, SMESH.FT_Warping, SMESH.Filter_i.myPredicate, and SMESH.Filter_i.SetPredicate().

{
  if ( myPredicate != 0 )
    myPredicate->UnRegister();

  SMESH::FilterManager_i* aFilter = new SMESH::FilterManager_i();
  FilterManager_ptr aFilterMgr = aFilter->_this();

  // CREATE two lists ( PREDICATES  and LOG OP )

  // Criterion
  TPythonDump()<<"aCriteria = []";
  std::list<SMESH::Predicate_ptr> aPredicates;
  std::list<int>                  aBinaries;
  for ( int i = 0, n = theCriteria.length(); i < n; i++ )
  {
    int         aCriterion    = theCriteria[ i ].Type;
    int         aCompare      = theCriteria[ i ].Compare;
    double      aThreshold    = theCriteria[ i ].Threshold;
    const char* aThresholdStr = theCriteria[ i ].ThresholdStr;
    const char* aThresholdID  = theCriteria[ i ].ThresholdID;
    int         aUnary        = theCriteria[ i ].UnaryOp;
    int         aBinary       = theCriteria[ i ].BinaryOp;
    double      aTolerance    = theCriteria[ i ].Tolerance;
    ElementType aTypeOfElem   = theCriteria[ i ].TypeOfElement;
    long        aPrecision    = theCriteria[ i ].Precision;

    {
      TPythonDump pd;
      pd << "aCriterion = SMESH.Filter.Criterion(" << aCriterion << "," << aCompare
         << "," << aThreshold << ",'" << aThresholdStr;
      if (aThresholdID && strlen(aThresholdID))
        //pd << "',salome.ObjectToID(" << aThresholdID
        pd << "','" << aThresholdID
           << "'," << aUnary << "," << aBinary << "," << aTolerance
           << "," << aTypeOfElem << "," << aPrecision << ")";
      else
        pd << "',''," << aUnary << "," << aBinary << "," << aTolerance
           << "," << aTypeOfElem << "," << aPrecision << ")";
    }

    SMESH::Predicate_ptr aPredicate = SMESH::Predicate::_nil();
    SMESH::NumericalFunctor_ptr aFunctor = SMESH::NumericalFunctor::_nil();

    switch ( aCriterion )
    {
      // Functors

      case SMESH::FT_MultiConnection:
        aFunctor = aFilterMgr->CreateMultiConnection();
        break;
      case SMESH::FT_MultiConnection2D:
        aFunctor = aFilterMgr->CreateMultiConnection2D();
        break;
      case SMESH::FT_Length:
        aFunctor = aFilterMgr->CreateLength();
        break;
      case SMESH::FT_Length2D:
        aFunctor = aFilterMgr->CreateLength2D();
        break;
      case SMESH::FT_AspectRatio:
        aFunctor = aFilterMgr->CreateAspectRatio();
        break;
      case SMESH::FT_AspectRatio3D:
        aFunctor = aFilterMgr->CreateAspectRatio3D();
        break;
      case SMESH::FT_Warping:
        aFunctor = aFilterMgr->CreateWarping();
        break;
      case SMESH::FT_MinimumAngle:
        aFunctor = aFilterMgr->CreateMinimumAngle();
        break;
      case SMESH::FT_Taper:
        aFunctor = aFilterMgr->CreateTaper();
        break;
      case SMESH::FT_Skew:
        aFunctor = aFilterMgr->CreateSkew();
        break;
      case SMESH::FT_Area:
        aFunctor = aFilterMgr->CreateArea();
        break;
      case SMESH::FT_Volume3D:
        aFunctor = aFilterMgr->CreateVolume3D();
        break;
      case SMESH::FT_MaxElementLength2D:
        aFunctor = aFilterMgr->CreateMaxElementLength2D();
        break;
      case SMESH::FT_MaxElementLength3D:
        aFunctor = aFilterMgr->CreateMaxElementLength3D();
        break;

      // Predicates

      case SMESH::FT_FreeBorders:
        aPredicate = aFilterMgr->CreateFreeBorders();
        break;
      case SMESH::FT_FreeEdges:
        aPredicate = aFilterMgr->CreateFreeEdges();
        break;
      case SMESH::FT_FreeFaces:
        aPredicate = aFilterMgr->CreateFreeFaces();
        break;
      case SMESH::FT_FreeNodes:
        aPredicate = aFilterMgr->CreateFreeNodes();
        break;
      case SMESH::FT_BelongToGeom:
        {
          SMESH::BelongToGeom_ptr tmpPred = aFilterMgr->CreateBelongToGeom();
          tmpPred->SetElementType( aTypeOfElem );
          tmpPred->SetShape( aThresholdID, aThresholdStr );
          tmpPred->SetTolerance( aTolerance );
          aPredicate = tmpPred;
        }
        break;
      case SMESH::FT_BelongToPlane:
      case SMESH::FT_BelongToCylinder:
      case SMESH::FT_BelongToGenSurface:
        {
          SMESH::BelongToSurface_ptr tmpPred;
          switch ( aCriterion ) {
          case SMESH::FT_BelongToPlane:
            tmpPred = aFilterMgr->CreateBelongToPlane(); break;
          case SMESH::FT_BelongToCylinder:
            tmpPred = aFilterMgr->CreateBelongToCylinder(); break;
          default:
            tmpPred = aFilterMgr->CreateBelongToGenSurface();
          }
          tmpPred->SetShape( aThresholdID, aThresholdStr, aTypeOfElem );
          tmpPred->SetTolerance( aTolerance );
          aPredicate = tmpPred;
        }
        break;
      case SMESH::FT_LyingOnGeom:
        {
          SMESH::LyingOnGeom_ptr tmpPred = aFilterMgr->CreateLyingOnGeom();
          tmpPred->SetElementType( aTypeOfElem );
          tmpPred->SetShape( aThresholdID, aThresholdStr );
          tmpPred->SetTolerance( aTolerance );
          aPredicate = tmpPred;
        }
        break;
      case SMESH::FT_RangeOfIds:
        {
          SMESH::RangeOfIds_ptr tmpPred = aFilterMgr->CreateRangeOfIds();
          tmpPred->SetRangeStr( aThresholdStr );
          tmpPred->SetElementType( aTypeOfElem );
          aPredicate = tmpPred;
        }
        break;
      case SMESH::FT_BadOrientedVolume:
        {
          aPredicate = aFilterMgr->CreateBadOrientedVolume();
        }
        break;
      case SMESH::FT_BareBorderVolume:
        {
          aPredicate = aFilterMgr->CreateBareBorderVolume();
        }
        break;
      case SMESH::FT_BareBorderFace:
        {
          aPredicate = aFilterMgr->CreateBareBorderFace();
        }
        break;
      case SMESH::FT_OverConstrainedVolume:
        {
          aPredicate = aFilterMgr->CreateOverConstrainedVolume();
        }
        break;
      case SMESH::FT_OverConstrainedFace:
        {
          aPredicate = aFilterMgr->CreateOverConstrainedFace();
        }
        break;
      case SMESH::FT_LinearOrQuadratic:
        {
          SMESH::LinearOrQuadratic_ptr tmpPred = aFilterMgr->CreateLinearOrQuadratic();
          tmpPred->SetElementType( aTypeOfElem );
          aPredicate = tmpPred;
          break;
        }
      case SMESH::FT_GroupColor:
        {
          SMESH::GroupColor_ptr tmpPred = aFilterMgr->CreateGroupColor();
          tmpPred->SetElementType( aTypeOfElem );
          tmpPred->SetColorStr( aThresholdStr );
          aPredicate = tmpPred;
          break;
        }
      case SMESH::FT_ElemGeomType:
        {
          SMESH::ElemGeomType_ptr tmpPred = aFilterMgr->CreateElemGeomType();
          tmpPred->SetElementType( aTypeOfElem );
          tmpPred->SetGeometryType( (GeometryType)(int)(aThreshold + 0.5) );
          aPredicate = tmpPred;
          break;
        }
      case SMESH::FT_CoplanarFaces:
        {
          SMESH::CoplanarFaces_ptr tmpPred = aFilterMgr->CreateCoplanarFaces();
          tmpPred->SetFace( atol (aThresholdID ));
          tmpPred->SetTolerance( aTolerance );
          aPredicate = tmpPred;
          break;
        }

      default:
        continue;
    }

    // Comparator
    if ( !aFunctor->_is_nil() && aPredicate->_is_nil() )
    {
      SMESH::Comparator_ptr aComparator = SMESH::Comparator::_nil();

      if ( aCompare == SMESH::FT_LessThan )
        aComparator = aFilterMgr->CreateLessThan();
      else if ( aCompare == SMESH::FT_MoreThan )
        aComparator = aFilterMgr->CreateMoreThan();
      else if ( aCompare == SMESH::FT_EqualTo )
        aComparator = aFilterMgr->CreateEqualTo();
      else
        continue;

      aComparator->SetNumFunctor( aFunctor );
      aComparator->SetMargin( aThreshold );

      if ( aCompare == FT_EqualTo )
      {
        SMESH::EqualTo_var anEqualTo = SMESH::EqualTo::_narrow( aComparator );
        anEqualTo->SetTolerance( aTolerance );
      }

      aPredicate = aComparator;

      aFunctor->SetPrecision( aPrecision );
    }

    // Logical not
    if ( aUnary == FT_LogicalNOT )
    {
      SMESH::LogicalNOT_ptr aNotPred = aFilterMgr->CreateLogicalNOT();
      aNotPred->SetPredicate( aPredicate );
      aPredicate = aNotPred;
    }

    // logical op
    aPredicates.push_back( aPredicate );
    aBinaries.push_back( aBinary );
    TPythonDump()<<"aCriteria.append(aCriterion)";

  } // end of for
  TPythonDump()<<this<<".SetCriteria(aCriteria)";

  // CREATE ONE PREDICATE FROM PREVIOUSLY CREATED MAP

  // combine all "AND" operations

  std::list<SMESH::Predicate_ptr> aResList;

  std::list<SMESH::Predicate_ptr>::iterator aPredIter;
  std::list<int>::iterator                  aBinaryIter;

  SMESH::Predicate_ptr aPrevPredicate = SMESH::Predicate::_nil();
  int aPrevBinary = SMESH::FT_Undefined;

  for ( aPredIter = aPredicates.begin(), aBinaryIter = aBinaries.begin();
        aPredIter != aPredicates.end() && aBinaryIter != aBinaries.end();
        ++aPredIter, ++aBinaryIter )
  {
    int aCurrBinary = *aBinaryIter;

    SMESH::Predicate_ptr aCurrPred = SMESH::Predicate::_nil();

    if ( aPrevBinary == SMESH::FT_LogicalAND )
    {

      SMESH::LogicalBinary_ptr aBinaryPred = aFilterMgr->CreateLogicalAND();
      aBinaryPred->SetPredicate1( aPrevPredicate );
      aBinaryPred->SetPredicate2( *aPredIter );
      aCurrPred = aBinaryPred;
    }
    else
      aCurrPred = *aPredIter;

    if ( aCurrBinary != SMESH::FT_LogicalAND )
      aResList.push_back( aCurrPred );

    aPrevPredicate = aCurrPred;
    aPrevBinary = aCurrBinary;
  }

  // combine all "OR" operations

  SMESH::Predicate_ptr aResPredicate = SMESH::Predicate::_nil();

  if ( aResList.size() == 1 )
    aResPredicate = *aResList.begin();
  else if ( aResList.size() > 1 )
  {
    std::list<SMESH::Predicate_ptr>::iterator anIter = aResList.begin();
    aResPredicate = *anIter;
    anIter++;
    for ( ; anIter != aResList.end(); ++anIter )
    {
      SMESH::LogicalBinary_ptr aBinaryPred = aFilterMgr->CreateLogicalOR();
      aBinaryPred->SetPredicate1( aResPredicate );
      aBinaryPred->SetPredicate2( *anIter );
      aResPredicate = aBinaryPred;
    }
  }

  SetPredicate( aResPredicate );

  return !aResPredicate->_is_nil();
}
void Filter_i::SetMesh ( SMESH_Mesh_ptr  theMesh) [virtual]

Definition at line 2312 of file SMESH_Filter_i.cxx.

References SMESH.Filter_i.myMesh.

{
  if(!CORBA::is_nil(theMesh))
    theMesh->Register();

  if(!CORBA::is_nil(myMesh))
    myMesh->UnRegister();

  myMesh = SMESH_Mesh::_duplicate( theMesh );
  TPythonDump()<<this<<".SetMesh("<<theMesh<<")";
}
void Filter_i::SetPredicate ( Predicate_ptr  thePredicate) [virtual]

Definition at line 2282 of file SMESH_Filter_i.cxx.

References SMESH.Predicate_i.GetPredicate(), SMESH.Filter_i.GetPredicate(), SMESH.Filter_i.myFilter, SMESH.Filter_i.myPredicate, and SMESH.Controls.Filter.SetPredicate().

Referenced by SMESH.Filter_i.SetCriteria().

{
  if ( myPredicate )
    myPredicate->UnRegister();

  myPredicate = SMESH::GetPredicate(thePredicate);

  if ( myPredicate )
  {
    myFilter.SetPredicate( myPredicate->GetPredicate() );
    myPredicate->Register();
    TPythonDump()<<this<<".SetPredicate("<<myPredicate<<")";
  }
}

Field Documentation

Controls::Filter SMESH.Filter_i.myFilter [private]

Definition at line 925 of file SMESH_Filter_i.hxx.

Referenced by SMESH.Filter_i.SetPredicate().

SMESH_Mesh_var SMESH.Filter_i.myMesh [private]

Definition at line 927 of file SMESH_Filter_i.hxx.

Referenced by SMESH.Filter_i.GetIDs(), SMESH.Filter_i.GetMesh(), SMESH.Filter_i.SetMesh(), and SMESH.Filter_i.~Filter_i().

Predicate_i* SMESH.Filter_i.myPredicate [private]

Definition at line 926 of file SMESH_Filter_i.hxx.

Referenced by SMESH.Filter_i.GetCriteria(), SMESH.Filter_i.GetElementsId(), SMESH.Filter_i.GetElementType(), SMESH.Filter_i.GetPredicate(), SMESH.Filter_i.GetPredicate_i(), SMESH.Filter_i.SetCriteria(), SMESH.Filter_i.SetPredicate(), and SMESH.Filter_i.~Filter_i().

Copyright © 2007-2011 CEA/DEN, EDF R&D, OPEN CASCADE
Copyright © 2003-2007 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN, CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS