idl/SMESH_Filter.idl

Go to the documentation of this file.

//  Copyright (C) 2003  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_FreeBorders,
    FT_FreeEdges,
    FT_MultiConnection,
    FT_MultiConnection2D,
    FT_Length,
    FT_Length2D,
    FT_BelongToGeom,
    FT_BelongToPlane,
    FT_BelongToCylinder,
    FT_LyingOnGeom,
    FT_RangeOfIds,
    FT_BadOrientedVolume,
    FT_LessThan,
    FT_MoreThan,
    FT_EqualTo,
    FT_LogicalNOT,
    FT_LogicalAND,
    FT_LogicalOR,
    FT_Undefined
  };

  interface Functor: SALOME::GenericObj
  {
    void            SetMesh( in SMESH_Mesh theMesh );
    FunctorType     GetFunctorType();
    ElementType     GetElementType();
  };



  interface NumericalFunctor: Functor
  {
    double GetValue( in long theElementId );

    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 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 BelongToGeom: Predicate
  {
    void SetGeom( in GEOM::GEOM_Object theGeom );
    void SetElementType( in ElementType theType );

    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();
  };


  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 LyingOnGeom: Predicate
  {
    void SetGeom( in GEOM::GEOM_Object theGeom );
    void SetElementType( in ElementType theType );

    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 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 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();
    Length            CreateLength();
    Length2D          CreateLength2D();
    MultiConnection   CreateMultiConnection();
    MultiConnection2D CreateMultiConnection2D();

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

    LyingOnGeom       CreateLyingOnGeom();

    FreeBorders       CreateFreeBorders();
    FreeEdges         CreateFreeEdges();

    RangeOfIds        CreateRangeOfIds();

    BadOrientedVolume CreateBadOrientedVolume();

    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

Generated on Tue Sep 19 09:21:36 2006 for SALOME - SMESH - v.3.2.2 by  1.4.6