idl/SMESH_Filter.idl

Go to the documentation of this file.

// Copyright (C) 2007-2011  CEA/DEN, EDF R&D, 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.
//
// 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"

module SMESH
{

  enum FunctorType
  {
    FT_AspectRatio,
    FT_AspectRatio3D,
    FT_Warping,   
    FT_MinimumAngle,
    FT_Taper,       
    FT_Skew,         
    FT_Area,          
    FT_Volume3D,          
    FT_MaxElementLength2D,
    FT_MaxElementLength3D,
    FT_FreeBorders,
    FT_FreeEdges,
    FT_FreeNodes,
    FT_FreeFaces,
    FT_MultiConnection,
    FT_MultiConnection2D,
    FT_Length,
    FT_Length2D,
    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_CoplanarFaces,
    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 long theElementId );

    Histogram GetHistogram( in short nbIntervals );

    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 MultiConnection   : NumericalFunctor{};
  interface MultiConnection2D : NumericalFunctor
  {
    struct Value
    {
      long myNbConnects;
      long myPnt1, myPnt2;
    };
    
    typedef sequence<Value> Values;
    Values GetValues();
  };
  

  interface Predicate: Functor
  {
    boolean IsSatisfy( in long thEntityId );
  };

  interface BadOrientedVolume: Predicate {};

  interface BareBorderVolume: Predicate {};
  interface BareBorderFace: Predicate {};

  interface OverConstrainedVolume: Predicate {};
  interface OverConstrainedFace: Predicate {};

  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 long_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 CoplanarFaces : Predicate{
    void            SetFace ( in long theFaceID );
    void            SetTolerance( in double theToler );
  };

  interface Filter: SALOME::GenericObj, 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 );

    long_array    GetElementsId( in SMESH_Mesh theMesh );
    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();
    MultiConnection   CreateMultiConnection();
    MultiConnection2D CreateMultiConnection2D();

    BelongToGeom      CreateBelongToGeom();
    BelongToPlane     CreateBelongToPlane();
    BelongToCylinder  CreateBelongToCylinder();
    BelongToGenSurface CreateBelongToGenSurface();

    LyingOnGeom       CreateLyingOnGeom();

    FreeBorders       CreateFreeBorders();
    FreeEdges         CreateFreeEdges();
    FreeNodes         CreateFreeNodes();
    FreeFaces         CreateFreeFaces();

    RangeOfIds        CreateRangeOfIds();

    BadOrientedVolume CreateBadOrientedVolume();
    BareBorderVolume  CreateBareBorderVolume();
    BareBorderFace    CreateBareBorderFace();
    OverConstrainedVolume CreateOverConstrainedVolume();
    OverConstrainedFace   CreateOverConstrainedFace();
    LinearOrQuadratic CreateLinearOrQuadratic();

    GroupColor        CreateGroupColor();
    ElemGeomType      CreateElemGeomType();
    CoplanarFaces     CreateCoplanarFaces();

    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