Salome HOME
0022107: EDF 2502 SMESH: Publish the result of show bad mesh in a group
[modules/smesh.git] / idl / SMESH_Filter.idl
1 // Copyright (C) 2007-2013  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
23 //  File   : SMESH_Filter.idl
24 //  Author : Alexey Petrov, OCC
25 //
26 #ifndef _SMESH_FILTER_IDL_
27 #define _SMESH_FILTER_IDL_
28
29 #include "SALOME_Exception.idl"
30 #include "SALOME_GenericObj.idl"
31 #include "GEOM_Gen.idl"
32 #include "SMESH_Mesh.idl"
33
34 module SMESH
35 {
36
37   /*!
38   * Enumeration of functor types
39   */
40   enum FunctorType
41   {
42     FT_AspectRatio,
43     FT_AspectRatio3D,
44     FT_Warping,   
45     FT_MinimumAngle,
46     FT_Taper,       
47     FT_Skew,         
48     FT_Area,          
49     FT_Volume3D,          
50     FT_MaxElementLength2D,
51     FT_MaxElementLength3D,
52     FT_FreeBorders,
53     FT_FreeEdges,
54     FT_FreeNodes,
55     FT_FreeFaces,
56     FT_EqualNodes,  // IMPORTANT: when a new item is added, don't forget to
57     FT_EqualEdges,  // 1) update getFunctNames() in SMESH_Filter_i.cxx: line 3910
58     FT_EqualFaces,  // 2) update fixFunctorType() in SMESH_2smeshpy.cxx: line 234
59     FT_EqualVolumes,
60     FT_MultiConnection,
61     FT_MultiConnection2D,
62     FT_Length,
63     FT_Length2D,
64     FT_BelongToGeom,
65     FT_BelongToPlane,
66     FT_BelongToCylinder,
67     FT_BelongToGenSurface,
68     FT_LyingOnGeom,
69     FT_RangeOfIds,
70     FT_BadOrientedVolume,
71     FT_BareBorderVolume,
72     FT_BareBorderFace,
73     FT_OverConstrainedVolume,
74     FT_OverConstrainedFace,
75     FT_LinearOrQuadratic,
76     FT_GroupColor,
77     FT_ElemGeomType,
78     FT_EntityType,
79     FT_CoplanarFaces,
80     FT_BallDiameter,
81     FT_ConnectedElements,
82     FT_LessThan,
83     FT_MoreThan,
84     FT_EqualTo,
85     FT_LogicalNOT,
86     FT_LogicalAND,
87     FT_LogicalOR,
88     FT_Undefined
89   };
90
91   /*!
92   * Parameters of a reclangle of histogram
93   */
94   struct HistogramRectangle
95   {
96     long nbEvents;
97     double min;
98     double max;
99   };
100   typedef sequence<HistogramRectangle> Histogram;
101
102
103   /*!
104   * Base interface for all functors ( i.e. numerical functors and predicates )
105   */
106   interface Functor: SALOME::GenericObj
107   {
108     void            SetMesh( in SMESH_Mesh theMesh );
109     FunctorType     GetFunctorType();
110     ElementType     GetElementType();
111   };
112
113   /*!
114   * Numerical functors are intended for calculating value by Id of mesh entity
115   */
116   interface NumericalFunctor: Functor
117   {
118     double GetValue( in long theElementId );
119
120     Histogram GetHistogram( in short nbIntervals, in boolean isLogarithmic );
121
122     /*!
123     * Set precision for calculation. It is a position after point which is
124     * used to functor value after calculation.
125     */
126     void   SetPrecision( in long thePrecision );
127     long   GetPrecision();
128   };
129   interface MinimumAngle    : NumericalFunctor{};
130   interface AspectRatio     : NumericalFunctor{};
131   interface AspectRatio3D   : NumericalFunctor{};
132   interface Warping         : NumericalFunctor{};
133   interface Taper           : NumericalFunctor{};
134   interface Skew            : NumericalFunctor{};
135   interface Area            : NumericalFunctor{};
136   interface Volume3D        : NumericalFunctor{};
137   interface MaxElementLength2D : NumericalFunctor{};
138   interface MaxElementLength3D : NumericalFunctor{};
139   interface Length          : NumericalFunctor{};
140   interface Length2D        : NumericalFunctor
141   {
142     struct Value
143     {
144       double myLength;
145       long myPnt1, myPnt2;
146     };
147     typedef sequence<Value> Values;
148     Values GetValues();
149   };
150   interface MultiConnection   : NumericalFunctor{};
151   interface MultiConnection2D : NumericalFunctor
152   {
153     struct Value
154     {
155       long myNbConnects;
156       long myPnt1, myPnt2;
157     };
158     
159     typedef sequence<Value> Values;
160     Values GetValues();
161   };
162   interface BallDiameter    : NumericalFunctor{};
163   
164
165   /*!
166   * Predicates are intended for verification of criteria,
167   *            must return bool value by mesh id
168   */
169   interface Predicate: Functor
170   {
171     boolean IsSatisfy( in long thEntityId );
172   };
173
174   /*!
175    * Logical functor (predicate) "Bad Oriented Volume".
176    * Verify whether a mesh volume is incorrectly oriented from
177    * the point of view of MED convention
178    */
179   interface BadOrientedVolume: Predicate {};
180
181   /*!
182    * Logical functor (predicate) "Volumes with bare border".
183    * Verify whether a mesh volume has a free facet without a mesh face on it
184    */
185   interface BareBorderVolume: Predicate {};
186   /*!
187    * Logical functor (predicate) "Faces with bare border".
188    * Verify whether a mesh face has a side not shared with another face
189    * and without a mesh edge on it
190    */
191   interface BareBorderFace: Predicate {};
192
193   /*!
194    * Logical functor (predicate) "Over-constrained Volume"
195    * Verify whether a mesh volume has only one facet shared with other volumes
196    */
197   interface OverConstrainedVolume: Predicate {};
198   /*!
199    * Logical functor (predicate) "Over-constrained Face".
200    * Verify whether a mesh face has only one border shared with other faces
201    */
202   interface OverConstrainedFace: Predicate {};
203
204   /*!
205    * Logical functor (predicate) "Equal Nodes".
206    * Verify whether there is another mesh node with same coordinates
207    */
208   interface EqualNodes: Predicate 
209   {
210     void    SetTolerance( in double theToler );
211     double  GetTolerance();
212   };
213   /*!
214    * Logical functor (predicate) "Equal Edges".
215    * Verify whether there is another mesh edge basing on the same nodes
216    */
217   interface EqualEdges: Predicate {};
218   /*!
219    * Logical functor (predicate) "Equal Faces".
220    * Verify whether there is another mesh face basing on the same nodes
221    */
222   interface EqualFaces: Predicate {};
223   /*!
224    * Logical functor (predicate) "Equal Volumes".
225    * Verify whether there is another mesh volumes basing on the same nodes
226    */
227   interface EqualVolumes: Predicate {};
228
229   /*!
230    * Logical functor (predicate) "Belong To Geometry".
231    * Verify whether mesh element or node belong to pointed Geom Object
232    */
233   interface BelongToGeom: Predicate
234   {
235     void SetGeom( in GEOM::GEOM_Object theGeom );
236     void SetElementType( in ElementType theType );
237
238     /*! The tolerance is used only if there is no submesh on the shape
239      */
240     void    SetTolerance( in double theToler );
241     double  GetTolerance();
242
243     void   SetShapeName( in string theName );
244     void   SetShape( in string theID, in string theName );
245     string GetShapeName();
246     string GetShapeID();
247   };
248
249   /*!
250   * Logical functor (predicate) "Belong To Surface".
251   * Base interface for "belong to plane" and "belong to cylinder"
252   * and "Belong To Generic Surface" interfaces
253   */
254   interface BelongToSurface: Predicate
255   {
256     void    SetTolerance( in double theToler );
257     double  GetTolerance();
258     void    SetShapeName( in string theName, in ElementType theType );
259     void    SetShape( in string theID, in string theName, in ElementType theType );
260     string  GetShapeName();
261     string  GetShapeID();
262     /*!
263     * Limit surface extent to bounding box of boundaries (edges)
264     * in surface parametric space. Boundaries are ignored by default
265     */
266     void    SetUseBoundaries( in boolean theUseBndRestrictions );
267     boolean GetUseBoundaries();
268   };
269
270   /*!
271   * Logical functor (predicate) "Belong To Plane".
272   * Verify whether mesh element lie on pointed Geom planar object
273   */
274   interface BelongToPlane: BelongToSurface
275   {
276     void   SetPlane( in GEOM::GEOM_Object theGeom, in ElementType theType );
277   };
278
279   /*!
280   * Logical functor (predicate) "Belong To Cylinder".
281   * Verify whether mesh element lie on pointed Geom cylindrical object
282   */
283   interface BelongToCylinder: BelongToSurface
284   {
285     void   SetCylinder( in GEOM::GEOM_Object theGeom, in ElementType theType );
286   };
287
288   /*!
289   * Logical functor (predicate) "Belong To Generic Surface".
290   * Verify whether mesh element lie in pointed Geom cylindrical object
291   */
292   interface BelongToGenSurface: BelongToSurface
293   {
294     void   SetSurface( in GEOM::GEOM_Object theGeom, in ElementType theType );
295   };
296
297   /*!
298   * Logical functor (predicate) "Lying On Geometry".
299   * Verify whether mesh element or node lying or partially lying on the pointed Geom Object
300   */
301   interface LyingOnGeom: Predicate
302   {
303     void SetGeom( in GEOM::GEOM_Object theGeom );
304     void SetElementType( in ElementType theType );
305
306     /*! The tolerance is used only if there is no submesh on the shape
307      */
308     void    SetTolerance( in double theToler );
309     double  GetTolerance();
310
311     void   SetShapeName( in string theName );
312     void   SetShape( in string theID, in string theName );
313     string GetShapeName();    
314     string GetShapeID(); 
315   };
316  
317   /*!
318   * Logical functor (predicate) "Free borders".
319   * Verify whether 1D mesh element is free ( i.e. connected to one face only )
320   */
321   interface FreeBorders: Predicate {};
322
323   /*!
324   * Logical functor (predicate) "Free edges".
325   * Verify whether 2D mesh element has free edges( i.e. edges connected to one face only )
326   */
327   interface FreeEdges: Predicate
328   {
329     struct Border
330     {
331       long myElemId;
332       long myPnt1, myPnt2;
333     };
334     typedef sequence<Border> Borders;
335     Borders GetBorders();
336   };
337
338   /*!
339   * Logical functor (predicate) "Free nodes".
340   * Verify whether mesh has free nodes( i.e. nodes are not connected to any element )
341   */
342   interface FreeNodes: Predicate {};
343  
344   /*!
345   * Logical functor (predicate) "Free faces".
346   * Verify whether 2D mesh element is free ( i.e. connected to one volume only )
347   */
348   interface FreeFaces: Predicate {};
349
350   /*!
351   * Abstract logical functor (predicate) "RangeOfIds".
352   * Verify whether an Entity Id belongs to defined sequence of id's
353   */
354   interface RangeOfIds: Predicate
355   {
356     void            SetRange( in long_array theIds );
357     boolean         SetRangeStr( in string theRange );
358     string          GetRangeStr();
359
360     void            SetElementType( in ElementType theType );
361   };
362
363   /*!
364   * Comparator. Predicate for compare value calculated
365   *             by numerical functor with threshold value
366   */
367   interface Comparator: Predicate
368   {
369     void    SetMargin( in double theValue );
370     void    SetNumFunctor( in NumericalFunctor theFunct );
371     double  GetMargin();
372   };
373   interface LessThan: Comparator{};
374   interface MoreThan: Comparator{};
375   interface EqualTo : Comparator
376   {
377     void    SetTolerance( in double theToler );
378     double  GetTolerance();
379   };
380
381   /*!
382   * Logical predicates are intended for compose predicates using boolean operations
383   */
384   interface Logical: Predicate {};
385
386   interface LogicalNOT: Logical
387   {
388     void SetPredicate(in Predicate thePredicate);
389   };
390
391   interface LogicalBinary: Logical
392 {
393     void SetPredicate1( in Predicate thePredicate );
394     void SetPredicate2( in Predicate thePredicate );
395   };
396
397   interface LogicalAND: LogicalBinary{};
398   interface LogicalOR : LogicalBinary{};
399
400   /*!
401    * Logical functor (predicate) "Is element Linear or Quadratic".
402    * Verify whether a mesh element is linear
403    */
404   interface LinearOrQuadratic: Predicate {
405     void            SetElementType( in ElementType theType );
406   };
407
408   /*!
409   * Predicate "Group Color"
410   * Returns color of group to which mesh element belongs to
411   */
412   interface GroupColor : Predicate {
413     void            SetElementType( in ElementType theType );
414     void            SetColorStr( in string theColor );
415     string          GetColorStr();
416   };
417
418   /*!
419   * Predicate "Element geometry type"
420   * Returns is element has indicated geometry type
421   */
422   interface ElemGeomType : Predicate {
423     void            SetElementType ( in ElementType  theType );
424     void            SetGeometryType( in GeometryType theType );
425   };
426
427   /*!
428   * Predicate "Element entity type"
429   * Returns is element has indicated entity type
430   */
431   interface ElemEntityType : Predicate {
432     void            SetElementType ( in ElementType  theType );
433     void            SetEntityType( in EntityType theSetEntityType );
434   };
435
436   /*!
437   * Predicate "Coplanar faces"
438   * Returns true if a mesh face is a coplanar neighbour to a given one. It checks
439   * if normal of a face has angle with the threshold face less than a tolerance.
440   */
441   interface CoplanarFaces : Predicate {
442     void            SetFace ( in long theFaceID );
443     void            SetTolerance( in double theToler );
444   };
445
446   /*!
447   * Predicate "Connected Elements"
448   * Returns true if an element is connected via other elements to the element 
449   * located at a given point.
450   */
451   interface ConnectedElements : Predicate {
452     enum ThresholdType { POINT, VERTEX, NODE, NONE };
453     void            SetElementType( in ElementType type );
454     void            SetPoint      ( in double x, in double y, in double z );
455     void            SetVertex     ( in GEOM::GEOM_Object vertex );
456     void            SetNode       ( in long nodeID );
457     string          GetThreshold  ( out ThresholdType type );
458     void            SetThreshold  ( in string threshold, in ThresholdType type ) 
459       raises (SALOME::SALOME_Exception);
460   };
461
462   /*!
463   *  Filter
464   */
465   interface Filter: SALOME::GenericObj, SMESH_IDSource
466   {
467     /*!
468     * Structure containing information about one criterion
469     *   Type          - FT_Taper, FT_Skew ...
470     *   Compare       - FT_LessThan, FT_MoreThan, FT_EqualTo
471     *   Threshold     - threshold value
472     *   UnaryOp       - unary logical operation: FT_LogicalNOT or FT_Undefined
473     *   BinaryOp      - binary logical operation FT_LogicalAND, FT_LogicalOR or
474     *                   (FT_Undefined must be for the last criterion)
475     *   ThresholdStr  - Threshold value defined as string. Used for:
476     *                   1. Diapason of identifiers. Example: "1,2,3,5-10,12,27-29".
477     *                   2. Storing name of shape.
478     *                   3. Storing group color "0.2;0;0.5".
479     *                   4. Storing point coordinates.
480     *   ThresholdID   - One more threshold value defined as string. Used for:
481     *                   1. Storing id of shape
482     *   Tolerance     - Tolerance is used for 
483     *                   1. Comparison of real values.
484     *                   2. Detection of geometrical coincidence.
485     *   TypeOfElement - type of element SMESH::NODE, SMESH::FACE etc.
486     *   Precision     - Precision of numerical functors
487     */
488     struct Criterion
489     {
490       long        Type;
491       long        Compare;
492       double      Threshold;
493       string      ThresholdStr;
494       string      ThresholdID;
495       long        UnaryOp;
496       long        BinaryOp;
497       double      Tolerance;
498       ElementType TypeOfElement;
499       long        Precision;
500     };
501
502     typedef sequence<Criterion> Criteria;
503
504     void          SetPredicate( in Predicate thePredicate );
505     void          SetMesh( in SMESH_Mesh theMesh );
506
507     long_array    GetElementsId( in SMESH_Mesh theMesh );
508     ElementType   GetElementType();
509     Predicate     GetPredicate();
510
511     boolean       GetCriteria( out Criteria theCriteria );
512     boolean       SetCriteria( in Criteria theCriteria );
513   };
514
515
516   /*!
517   *  Interface for working with library of filters
518   */
519   interface FilterLibrary : SALOME::GenericObj
520   {
521     /*!
522     *  Copy filter from library by name (new filter is created)
523     */
524     Filter        Copy( in string theFilterName );
525
526     /*!
527     * Methods for editing library
528     */
529     boolean       Add     ( in string theFilterName, in Filter theFilter );
530     boolean       AddEmpty( in string theFilterName, in ElementType theType ); // add empty filter
531     boolean       Delete  ( in string theFilterName );
532     boolean       Replace ( in string theFilterName, in string theNewName, in Filter theFilter );
533
534     /*!
535     *  Save library on disk
536     */
537     boolean       Save();
538     boolean       SaveAs( in string aFileName );
539
540     /*!
541     * Query methods
542     */
543     boolean       IsPresent( in string aFilterName );
544     long          NbFilters( in ElementType aType );
545     string_array  GetNames( in ElementType aType );
546     string_array  GetAllNames();
547     void          SetFileName( in string aFilterName );
548     string        GetFileName();
549   };
550
551
552   /*!
553   * Interface of Filter manager
554   */
555   interface FilterManager: SALOME::GenericObj
556   {
557     /*!
558     *  Create numerical functors
559     */
560     MinimumAngle      CreateMinimumAngle();
561     AspectRatio       CreateAspectRatio();
562     AspectRatio3D     CreateAspectRatio3D();
563     Warping           CreateWarping();
564     Taper             CreateTaper();
565     Skew              CreateSkew();
566     Area              CreateArea();
567     Volume3D          CreateVolume3D();
568     MaxElementLength2D CreateMaxElementLength2D();
569     MaxElementLength3D CreateMaxElementLength3D();
570     Length            CreateLength();
571     Length2D          CreateLength2D();
572     MultiConnection   CreateMultiConnection();
573     MultiConnection2D CreateMultiConnection2D();
574     BallDiameter      CreateBallDiameter();
575     /*!
576     *  Create logical functors ( predicates )
577     */
578     BelongToGeom      CreateBelongToGeom();
579     BelongToPlane     CreateBelongToPlane();
580     BelongToCylinder  CreateBelongToCylinder();
581     BelongToGenSurface CreateBelongToGenSurface();
582
583     LyingOnGeom       CreateLyingOnGeom();
584
585     FreeBorders       CreateFreeBorders();
586     FreeEdges         CreateFreeEdges();
587     FreeNodes         CreateFreeNodes();
588     FreeFaces         CreateFreeFaces();
589
590     EqualNodes        CreateEqualNodes();
591     EqualEdges        CreateEqualEdges();
592     EqualFaces        CreateEqualFaces();
593     EqualVolumes      CreateEqualVolumes();
594
595     RangeOfIds        CreateRangeOfIds();
596
597     BadOrientedVolume CreateBadOrientedVolume();
598     BareBorderVolume  CreateBareBorderVolume();
599     BareBorderFace    CreateBareBorderFace();
600     OverConstrainedVolume CreateOverConstrainedVolume();
601     OverConstrainedFace   CreateOverConstrainedFace();
602     LinearOrQuadratic CreateLinearOrQuadratic();
603
604     GroupColor        CreateGroupColor();
605     ElemGeomType      CreateElemGeomType();
606     ElemEntityType    CreateElemEntityType();
607     CoplanarFaces     CreateCoplanarFaces();
608     ConnectedElements CreateConnectedElements();
609
610     /*!
611     *  Create comparators ( predicates )
612     */
613     LessThan          CreateLessThan();
614     MoreThan          CreateMoreThan();
615     EqualTo           CreateEqualTo();
616
617     /*!
618     *  Create boolean operations ( predicates )
619     */
620     LogicalNOT        CreateLogicalNOT();
621     LogicalAND        CreateLogicalAND();
622     LogicalOR         CreateLogicalOR();
623
624     /*!
625     *  Create filter
626     */
627     Filter            CreateFilter();
628
629     /*!
630     *  Load filter library. If libary does not exist it is created
631     */
632     FilterLibrary     LoadLibrary( in string aFileName );
633
634     /*!
635     *  Create new library
636     */
637     FilterLibrary     CreateLibrary();
638
639     /*!
640     *  Delete library
641     */
642     boolean           DeleteLibrary( in string aFileName );
643   };
644 };
645
646
647 #endif