SMESH_Filter.idl

Go to the documentation of this file.

// Copyright (C) 2007-2023  CEA, EDF, OPEN CASCADE
//
// Copyright (C) 2003-2007  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; either
// version 2.1 of the License, or (at your option) any later version.
//
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
// Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public
// License along with this library; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
//
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
 
//  File   : SMESH_Filter.idl
//  Author : Alexey Petrov, OCC
//
#ifndef _SMESH_FILTER_IDL_
#define _SMESH_FILTER_IDL_
 
#include "SALOME_Exception.idl"
#include "SALOME_GenericObj.idl"
#include "GEOM_Gen.idl"
#include "SMESH_Mesh.idl"
#include "SMESH_smIdType.idl"
 
module SMESH
{
 
  enum FunctorType
  {
    FT_AspectRatio,
    FT_AspectRatio3D,
    FT_Warping,   
    FT_MinimumAngle,
    FT_Taper,       
    FT_Skew,         
    FT_Area,          
    FT_Volume3D,   
    FT_ScaledJacobian,       
    FT_MaxElementLength2D,
    FT_MaxElementLength3D,
    FT_FreeBorders,
    FT_FreeEdges,
    FT_FreeNodes,
    FT_FreeFaces,
    FT_EqualNodes,  // IMPORTANT: when a new item is added, don't forget to
    FT_EqualEdges,  // 1) update getFunctNames() in SMESH_Filter_i.cxx: line 3910
    FT_EqualFaces,  // 2) update fixFunctorType() in SMESH_2smeshpy.cxx: line 234
    FT_EqualVolumes,
    FT_MultiConnection,
    FT_MultiConnection2D,
    FT_Length,
    FT_Length2D,
    FT_Length3D,
    FT_Deflection2D,
    FT_NodeConnectivityNumber,
    FT_BelongToMeshGroup,
    FT_BelongToGeom,
    FT_BelongToPlane,
    FT_BelongToCylinder,
    FT_BelongToGenSurface,
    FT_LyingOnGeom,
    FT_RangeOfIds,
    FT_BadOrientedVolume,
    FT_BareBorderVolume,
    FT_BareBorderFace,
    FT_OverConstrainedVolume,
    FT_OverConstrainedFace,
    FT_LinearOrQuadratic,
    FT_GroupColor,
    FT_ElemGeomType,
    FT_EntityType,
    FT_CoplanarFaces,
    FT_BallDiameter,
    FT_ConnectedElements,
    FT_LessThan,
    FT_MoreThan,
    FT_EqualTo,
    FT_LogicalNOT,
    FT_LogicalAND,
    FT_LogicalOR,
    FT_Undefined
  };
 
  struct HistogramRectangle
  {
    long nbEvents;
    double min;
    double max;
  };
  typedef sequence<HistogramRectangle> Histogram;
 
 
  interface Functor: SALOME::GenericObj
  {
    void            SetMesh( in SMESH_Mesh theMesh );
    FunctorType     GetFunctorType();
    ElementType     GetElementType();
  };
 
  interface NumericalFunctor: Functor
  {
    double  GetValue    ( in smIdType theElementId );
    boolean IsApplicable( in smIdType theElementId );
 
    Histogram GetHistogram     ( in short nbIntervals, in boolean isLogarithmic );
    Histogram GetLocalHistogram( in short nbIntervals, in boolean isLogarithmic,
                                 in SMESH::SMESH_IDSource obj );
    void   SetPrecision( in long thePrecision );
    long   GetPrecision();
  };
  interface MinimumAngle    : NumericalFunctor{};
  interface AspectRatio     : NumericalFunctor{};
  interface AspectRatio3D   : NumericalFunctor{};
  interface Warping         : NumericalFunctor{};
  interface Taper           : NumericalFunctor{};
  interface Skew            : NumericalFunctor{};
  interface Area            : NumericalFunctor{};
  interface Volume3D        : NumericalFunctor{};
  interface MaxElementLength2D : NumericalFunctor{};
  interface MaxElementLength3D : NumericalFunctor{};
  interface Length          : NumericalFunctor{};
  interface Length2D        : NumericalFunctor
  {
    struct Value
    {
      double myLength;
      long myPnt1, myPnt2;
    };
    typedef sequence<Value> Values;
    Values GetValues();
  };
  interface Length3D          : NumericalFunctor{};
  interface Deflection2D      : NumericalFunctor{};
  interface MultiConnection   : NumericalFunctor{};
  interface MultiConnection2D : NumericalFunctor
  {
    struct Value
    {
      long myNbConnects;
      long myPnt1, myPnt2;
    };
    
    typedef sequence<Value> Values;
    Values GetValues();
  };
  interface BallDiameter    : NumericalFunctor{};
  interface NodeConnectivityNumber : NumericalFunctor{};
  interface ScaledJacobian  : NumericalFunctor{};
  
 
  interface Predicate: Functor
  {
    boolean IsSatisfy( in long thEntityId );
    long    NbSatisfying( in SMESH::SMESH_IDSource obj );
  };
 
  interface BadOrientedVolume: Predicate {};
 
  interface BareBorderVolume: Predicate {};
  interface BareBorderFace: Predicate {};
 
  interface OverConstrainedVolume: Predicate {};
  interface OverConstrainedFace: Predicate {};
 
  interface EqualNodes: Predicate 
  {
    void    SetTolerance( in double theToler );
    double  GetTolerance();
  };
  interface EqualEdges: Predicate {};
  interface EqualFaces: Predicate {};
  interface EqualVolumes: Predicate {};
 
  interface BelongToMeshGroup: Predicate
  {
    void SetGroup( in SMESH::SMESH_GroupBase theGroup );
    void SetGroupID( in string theID ); // IOR or StoreName
    SMESH::SMESH_GroupBase GetGroup();
  };
 
  interface BelongToGeom: Predicate
  {
    void SetGeom( in GEOM::GEOM_Object theGeom );
    void SetElementType( in ElementType theType );
 
    void    SetTolerance( in double theToler );
    double  GetTolerance();
 
    void   SetShapeName( in string theName );
    void   SetShape( in string theID, in string theName );
    string GetShapeName();
    string GetShapeID();
  };
 
  interface BelongToSurface: Predicate
  {
    void    SetTolerance( in double theToler );
    double  GetTolerance();
    void    SetShapeName( in string theName, in ElementType theType );
    void    SetShape( in string theID, in string theName, in ElementType theType );
    string  GetShapeName();
    string  GetShapeID();
    void    SetUseBoundaries( in boolean theUseBndRestrictions );
    boolean GetUseBoundaries();
  };
 
  interface BelongToPlane: BelongToSurface
  {
    void   SetPlane( in GEOM::GEOM_Object theGeom, in ElementType theType );
  };
 
  interface BelongToCylinder: BelongToSurface
  {
    void   SetCylinder( in GEOM::GEOM_Object theGeom, in ElementType theType );
  };
 
  interface BelongToGenSurface: BelongToSurface
  {
    void   SetSurface( in GEOM::GEOM_Object theGeom, in ElementType theType );
  };
 
  interface LyingOnGeom: Predicate
  {
    void SetGeom( in GEOM::GEOM_Object theGeom );
    void SetElementType( in ElementType theType );
 
    void    SetTolerance( in double theToler );
    double  GetTolerance();
 
    void   SetShapeName( in string theName );
    void   SetShape( in string theID, in string theName );
    string GetShapeName();    
    string GetShapeID(); 
  };
 
  interface FreeBorders: Predicate {};
 
  interface FreeEdges: Predicate
  {
    struct Border
    {
      long myElemId;
      long myPnt1, myPnt2;
    };
    typedef sequence<Border> Borders;
    Borders GetBorders();
  };
 
  interface FreeNodes: Predicate {};
 
  interface FreeFaces: Predicate {};
 
  interface RangeOfIds: Predicate
  {
    void            SetRange( in smIdType_array theIds );
    boolean         SetRangeStr( in string theRange );
    string          GetRangeStr();
 
    void            SetElementType( in ElementType theType );
  };
 
  interface Comparator: Predicate
  {
    void    SetMargin( in double theValue );
    void    SetNumFunctor( in NumericalFunctor theFunct );
    double  GetMargin();
  };
  interface LessThan: Comparator{};
  interface MoreThan: Comparator{};
  interface EqualTo : Comparator
  {
    void    SetTolerance( in double theToler );
    double  GetTolerance();
  };
 
  interface Logical: Predicate {};
 
  interface LogicalNOT: Logical
  {
    void SetPredicate(in Predicate thePredicate);
  };
 
  interface LogicalBinary: Logical
{
    void SetPredicate1( in Predicate thePredicate );
    void SetPredicate2( in Predicate thePredicate );
  };
 
  interface LogicalAND: LogicalBinary{};
  interface LogicalOR : LogicalBinary{};
 
  interface LinearOrQuadratic: Predicate {
    void            SetElementType( in ElementType theType );
  };
 
  interface GroupColor : Predicate {
    void            SetElementType( in ElementType theType );
    void            SetColorStr( in string theColor );
    string          GetColorStr();
  };
 
  interface ElemGeomType : Predicate {
    void            SetElementType ( in ElementType  theType );
    void            SetGeometryType( in GeometryType theType );
  };
 
  interface ElemEntityType : Predicate {
    void            SetElementType ( in ElementType  theType );
    void            SetEntityType( in EntityType theSetEntityType );
  };
 
  interface CoplanarFaces : Predicate {
    void            SetFace ( in long theFaceID );
    void            SetTolerance( in double theToler );
  };
 
  interface ConnectedElements : Predicate {
    enum ThresholdType { POINT, VERTEX, NODE, NONE };
    void            SetElementType( in ElementType type );
    void            SetPoint      ( in double x, in double y, in double z );
    void            SetVertex     ( in GEOM::GEOM_Object vertex );
    void            SetNode       ( in smIdType nodeID );
    string          GetThreshold  ( out ThresholdType type );
    void            SetThreshold  ( in string threshold, in ThresholdType type ) 
      raises (SALOME::SALOME_Exception);
  };
 
  interface Filter: SMESH_IDSource
  {
    struct Criterion
    {
      long        Type;
      long        Compare;
      double      Threshold;
      string      ThresholdStr;
      string      ThresholdID;
      long        UnaryOp;
      long        BinaryOp;
      double      Tolerance;
      ElementType TypeOfElement;
      long        Precision;
    };
 
    typedef sequence<Criterion> Criteria;
 
    void           SetPredicate( in Predicate thePredicate );
    void           SetMesh( in SMESH_Mesh theMesh );
 
    smIdType_array GetElementsId( in SMESH_Mesh theMesh );
    smIdType_array GetElementsIdFromParts( in ListOfIDSources theParts );
    ElementType    GetElementType();
    Predicate      GetPredicate();
 
    boolean        GetCriteria( out Criteria theCriteria );
    boolean        SetCriteria( in Criteria theCriteria );
  };
 
 
  interface FilterLibrary : SALOME::GenericObj
  {
    Filter        Copy( in string theFilterName );
 
    boolean       Add     ( in string theFilterName, in Filter theFilter );
    boolean       AddEmpty( in string theFilterName, in ElementType theType ); // add empty filter
    boolean       Delete  ( in string theFilterName );
    boolean       Replace ( in string theFilterName, in string theNewName, in Filter theFilter );
 
    boolean       Save();
    boolean       SaveAs( in string aFileName );
 
    boolean       IsPresent( in string aFilterName );
    long          NbFilters( in ElementType aType );
    string_array  GetNames( in ElementType aType );
    string_array  GetAllNames();
    void          SetFileName( in string aFilterName );
    string        GetFileName();
  };
 
 
  interface FilterManager: SALOME::GenericObj
  {
    MinimumAngle       CreateMinimumAngle();
    AspectRatio        CreateAspectRatio();
    AspectRatio3D      CreateAspectRatio3D();
    Warping            CreateWarping();
    Taper              CreateTaper();
    Skew               CreateSkew();
    Area               CreateArea();
    Volume3D           CreateVolume3D();
    MaxElementLength2D CreateMaxElementLength2D();
    MaxElementLength3D CreateMaxElementLength3D();
    Length             CreateLength();
    Length2D           CreateLength2D();
    Length3D           CreateLength3D();
    Deflection2D       CreateDeflection2D();
    MultiConnection    CreateMultiConnection();
    MultiConnection2D  CreateMultiConnection2D();
    BallDiameter       CreateBallDiameter();
    NodeConnectivityNumber CreateNodeConnectivityNumber();
    ScaledJacobian     CreateScaledJacobian();
    BelongToMeshGroup  CreateBelongToMeshGroup();
    BelongToGeom       CreateBelongToGeom();
    BelongToPlane      CreateBelongToPlane();
    BelongToCylinder   CreateBelongToCylinder();
    BelongToGenSurface CreateBelongToGenSurface();
 
    LyingOnGeom        CreateLyingOnGeom();
 
    FreeBorders        CreateFreeBorders();
    FreeEdges          CreateFreeEdges();
    FreeNodes          CreateFreeNodes();
    FreeFaces          CreateFreeFaces();
 
    EqualNodes         CreateEqualNodes();
    EqualEdges         CreateEqualEdges();
    EqualFaces         CreateEqualFaces();
    EqualVolumes       CreateEqualVolumes();
 
    RangeOfIds         CreateRangeOfIds();
 
    BadOrientedVolume  CreateBadOrientedVolume();
    BareBorderVolume   CreateBareBorderVolume();
    BareBorderFace     CreateBareBorderFace();
    OverConstrainedVolume CreateOverConstrainedVolume();
    OverConstrainedFace   CreateOverConstrainedFace();
    LinearOrQuadratic  CreateLinearOrQuadratic();
 
    GroupColor         CreateGroupColor();
    ElemGeomType       CreateElemGeomType();
    ElemEntityType     CreateElemEntityType();
    CoplanarFaces      CreateCoplanarFaces();
    ConnectedElements  CreateConnectedElements();
 
    LessThan          CreateLessThan();
    MoreThan          CreateMoreThan();
    EqualTo           CreateEqualTo();
 
    LogicalNOT        CreateLogicalNOT();
    LogicalAND        CreateLogicalAND();
    LogicalOR         CreateLogicalOR();
 
    Filter            CreateFilter();
 
    FilterLibrary     LoadLibrary( in string aFileName );
 
    FilterLibrary     CreateLibrary();
 
    boolean           DeleteLibrary( in string aFileName );
  };
};
 
 
#endif