3 \page tui_filters_page Filters usage
5 Filters allows to pick only those mesh elements which satisfy to
6 specific condition or set of conditions. Filters can be used to create
7 or edit mesh groups, remove elements from the mesh object, control
8 mesh quality by different parameters, etc.
10 Several filters can be combined together by using logical operators \a
11 AND and \a OR. In addition, applied filter criterion can be reverted
12 using logical operator \a NOT.
14 Mesh filters use the functionality of mesh quality controls to filter
15 mesh nodes / elements by specific characteristic (Area, Length, etc).
17 This page provides a short description of the existing mesh filters,
18 describing required parameters and gives simple examples of usage in
21 \sa \ref tui_quality_controls_page
23 \section filter_aspect_ratio Aspect ratio
25 Filter 2D mesh elements (faces) according to the aspect ratio value:
26 - element type should be \a smesh.FACE
27 - functor type should be \a smesh.FT_AspectRatio
28 - threshold is floating point value (aspect ratio)
32 from SMESH_mechanic import *
33 # get faces with aspect ratio > 6.5
34 filter = smesh.GetFilter(smesh.FACE, smesh.FT_AspectRatio, smesh.FT_MoreThan, 6.5)
35 ids = mesh.GetIdsFromFilter(filter)
36 print "Number of faces with aspect ratio > 6.5:", len(ids)
39 \sa \ref tui_aspect_ratio
41 \section filter_aspect_ratio_3d Aspect ratio 3D
43 Filter 3D mesh elements (volumes) according to the aspect ratio value:
44 - element type is \a smesh.VOLUME
45 - functor type is \a smesh.FT_AspectRatio3D
46 - threshold is floating point value (aspect ratio)
49 # create mesh with volumes
50 from SMESH_mechanic import *
51 mesh.Tetrahedron( algo=smesh.NETGEN )
53 # get volumes with aspect ratio < 2.0
54 filter = smesh.GetFilter(smesh.VOLUME, smesh.FT_AspectRatio3D, smesh.FT_LessThan, 2.0)
55 ids = mesh.GetIdsFromFilter(filter)
56 print "Number of volumes with aspect ratio < 2.0:", len(ids)
59 \sa \ref tui_aspect_ratio_3d
61 \section filter_warping_angle Warping angle
63 Filter 2D mesh elements (faces) according to the warping angle value:
64 - element type is \a smesh.FACE
65 - functor type is \a smesh.FT_Warping
66 - threshold is floating point value (warping angle)
70 from SMESH_mechanic import *
71 # get faces with warping angle = 2.0e-13 with tolerance 5.0e-14
72 criterion = smesh.GetCriterion(smesh.FACE, smesh.FT_Warping, smesh.FT_EqualTo, 2.0e-13)
73 criterion.Tolerance = 5.0e-14
74 filter = smesh.CreateFilterManager().CreateFilter()
75 filter.SetCriteria([criterion])
76 ids = mesh.GetIdsFromFilter(filter)
77 print "Number of faces with warping angle = 2.0e-13 (tolerance 5.0e-14):", len(ids)
82 \section filter_minimum_angle Minimum angle
84 Filter 2D mesh elements (faces) according to the minimum angle value:
85 - element type is \a smesh.FACE
86 - functor type is \a smesh.FT_MinimumAngle
87 - threshold is floating point value (minimum angle)
91 from SMESH_mechanic import *
92 # get faces with minimum angle > 75
93 filter = smesh.GetFilter(smesh.FACE, smesh.FT_MinimumAngle, smesh.FT_MoreThan, 75)
94 ids = mesh.GetIdsFromFilter(filter)
95 print "Number of faces with minimum angle > 75:", len(ids)
98 \sa \ref tui_minimum_angle
100 \section filter_taper Taper
102 Filter 2D mesh elements (faces) according to the taper value:
103 - element type is \a smesh.FACE
104 - functor type is \a smesh.FT_Taper
105 - threshold is floating point value (taper)
109 from SMESH_mechanic import *
110 # get faces with taper < 1.e-15
111 filter = smesh.GetFilter(smesh.FACE, smesh.FT_Taper, smesh.FT_LessThan, 1.e-15)
112 ids = mesh.GetIdsFromFilter(filter)
113 print "Number of faces with taper < 1.e-15:", len(ids)
118 \section filter_skew Skew
120 Filter 2D mesh elements (faces) according to the skew value:
121 - element type is \a smesh.FACE
122 - functor type is \a smesh.FT_Skew
123 - threshold is floating point value (skew)
127 from SMESH_mechanic import *
128 # get faces with skew > 50
129 filter = smesh.GetFilter(smesh.FACE, smesh.FT_Skew, smesh.FT_MoreThan, 50)
130 ids = mesh.GetIdsFromFilter(filter)
131 print "Number of faces with skew > 50:", len(ids)
136 \section filter_area Area
138 Filter 2D mesh elements (faces) according to the area value:
139 - element type is \a smesh.FACE
140 - functor type is \a smesh.FT_Area
141 - threshold is floating point value (area)
145 from SMESH_mechanic import *
146 # get faces with area > 60 and < 90
147 criterion1 = smesh.GetCriterion(smesh.FACE, smesh.FT_Area, smesh.FT_MoreThan, 60,\
148 smesh.FT_Undefined, smesh.FT_LogicalAND)
149 criterion2 = smesh.GetCriterion(smesh.FACE, smesh.FT_Area, smesh.FT_LessThan, 90)
150 filter = smesh.CreateFilterManager().CreateFilter()
151 filter.SetCriteria([criterion1,criterion2])
152 ids = mesh.GetIdsFromFilter(filter)
153 print "Number of faces with area in range (60,90):", len(ids)
158 \section filter_volume Volume
160 Filter 3D mesh elements (volumes) according to the volume value:
161 - element type is \a smesh.VOLUME
162 - functor type is \a smesh.FT_Volume3D
163 - threshold is floating point value (volume)
166 # create mesh with volumes
167 from SMESH_mechanic import *
168 mesh.Tetrahedron( algo=smesh.NETGEN )
170 # get volumes faces with volume > 100
171 filter = smesh.GetFilter(smesh.VOLUME, smesh.FT_Volume3D, smesh.FT_MoreThan, 100)
172 ids = mesh.GetIdsFromFilter(filter)
173 print "Number of volumes with volume > 100:", len(ids)
178 \section filter_free_borders Free borders
180 Filter 1D mesh elements (edges) which represent free borders of a mesh:
181 - element type is \a smesh.EDGE
182 - functor type is \a smesh.FT_FreeBorders
183 - threshold value is not required
187 import geompy, smesh, StdMeshers
188 face = geompy.MakeFaceHW(100, 100, 1)
189 geompy.addToStudy( face, "quadrangle" )
190 mesh = smesh.Mesh(face)
191 mesh.Segment().NumberOfSegments(10)
192 mesh.Triangle().MaxElementArea(25)
194 # get all free borders
195 filter = smesh.GetFilter(smesh.EDGE, smesh.FT_FreeBorders)
196 ids = mesh.GetIdsFromFilter(filter)
197 print "Number of edges on free borders:", len(ids)
200 \sa \ref tui_free_borders
202 \section filter_free_edges Free edges
204 Filter 2D mesh elements (faces) consisting of edges belonging to one
205 element of mesh only:
206 - element type is \a smesh.FACE
207 - functor type is \a smesh.FT_FreeEdges
208 - threshold value is not required
212 import geompy, smesh, StdMeshers
213 face = geompy.MakeFaceHW(100, 100, 1)
214 geompy.addToStudy( face, "quadrangle" )
215 mesh = smesh.Mesh(face)
216 mesh.Segment().NumberOfSegments(10)
217 mesh.Triangle().MaxElementArea(25)
219 # get all faces with free edges
220 filter = smesh.GetFilter(smesh.FACE, smesh.FT_FreeEdges)
221 ids = mesh.GetIdsFromFilter(filter)
222 print "Number of faces with free edges:", len(ids)
225 \sa \ref tui_free_edges
227 \section filter_free_nodes Free nodes
230 - element type is \a smesh.NODE
231 - functor type is \a smesh.FT_FreeNodes
232 - threshold value is not required
236 from SMESH_mechanic import *
240 filter = smesh.GetFilter(smesh.EDGE, smesh.FT_FreeNodes)
241 ids = mesh.GetIdsFromFilter(filter)
242 print "Number of free nodes:", len(ids)
245 \sa \ref tui_free_nodes
247 \section filter_free_faces Free faces
250 - element type is \a smesh.FACE
251 - functor type is \a smesh.FT_FreeFaces
252 - threshold value is not required
256 from SMESH_mechanic import *
258 filter = smesh.GetFilter(smesh.EDGE, smesh.FT_FreeFaces)
259 ids = mesh.GetIdsFromFilter(filter)
260 print "Number of free faces:", len(ids)
263 \sa \ref tui_free_faces
265 \section filter_borders_multiconnection Borders at multi-connection
267 Filter border 1D mesh elements (edges) according to the specified number of
268 connections (faces belonging the border edges)
269 - element type is \a smesh.EDGE
270 - functor type is \a smesh.FT_MultiConnection
271 - threshold is integer value (number of connections)
275 from SMESH_mechanic import *
276 # get border edges with number of connected faces = 5
277 filter = smesh.GetFilter(smesh.EDGE, smesh.FT_MultiConnection, 5)
278 ids = mesh.GetIdsFromFilter(filter)
279 print "Number of border edges with 5 faces connected:", len(ids)
282 \sa \ref tui_borders_at_multiconnection
284 \section filter_borders_multiconnection_2d Borders at multi-connection 2D
286 Filter 2D mesh elements (faces) which consist of edges belonging
287 to the specified number of mesh elements
288 - element type is \a smesh.FACE
289 - functor type is \a smesh.FT_MultiConnection2D
290 - threshold is integer value (number of connections)
294 from SMESH_mechanic import *
295 # get faces which consist of edges belonging to 2 mesh elements
296 filter = smesh.GetFilter(smesh.FACE, smesh.FT_MultiConnection2D, 2)
297 ids = mesh.GetIdsFromFilter(filter)
298 print "Number of faces consisting of edges belonging to 2 faces:", len(ids)
301 \sa \ref tui_borders_at_multiconnection_2d
303 \section filter_length Length
305 Filter 1D mesh elements (edges) according to the edge length value:
306 - element type should be \a smesh.EDGE
307 - functor type should be \a smesh.FT_Length
308 - threshold is floating point value (length)
312 from SMESH_mechanic import *
313 # get edges with length > 14
314 filter = smesh.GetFilter(smesh.EDGE, smesh.FT_Length, smesh.FT_MoreThan, 14)
315 ids = mesh.GetIdsFromFilter(filter)
316 print "Number of edges with length > 14:", len(ids)
319 \sa \ref tui_length_1d
321 \section filter_length_2d Length 2D
323 Filter 2D mesh elements (faces) corresponding to the maximum length.
325 - element type should be \a smesh.FACE
326 - functor type should be \a smesh.FT_Length2D
327 - threshold is floating point value (edge length)
331 from SMESH_mechanic import *
332 # get all faces that have edges with length > 14
333 filter = smesh.GetFilter(smesh.FACE, smesh.FT_Length2D, smesh.FT_MoreThan, 14)
334 ids = mesh.GetIdsFromFilter(filter)
335 print "Number of faces with maximum edge length > 14:", len(ids)
338 \sa \ref tui_length_2d
340 \section filter_belong_to_geom Belong to Geom
342 Filter mesh entities (nodes or elements) which all nodes lie on the
343 shape defined by threshold value:
344 - element type can be any entity type, from \a smesh.NODE to \a smesh.VOLUME
345 - functor type should be \a smesh.FT_BelongToGeom
346 - threshold is geometrical object
350 from SMESH_mechanic import *
351 # get all faces which nodes lie on the face sub_face3
352 filter = smesh.GetFilter(smesh.FACE, smesh.FT_BelongToGeom, sub_face3)
353 ids = mesh.GetIdsFromFilter(filter)
354 print "Number of faces which nodes lie on sub_face3:", len(ids)
357 \section filter_lying_on_geom Lying on Geom
359 Filter mesh entities (nodes or elements) at least one node of which lies on the
360 shape defined by threshold value:
361 - element type can be any entity type, from \a smesh.NODE to \a smesh.VOLUME
362 - functor type should be \a smesh.FT_LyingOnGeom
363 - threshold is geometrical object
367 from SMESH_mechanic import *
368 # get all faces at least one node of each lies on the face sub_face3
369 filter = smesh.GetFilter(smesh.FACE, smesh.FT_LyingOnGeom, sub_face3)
370 ids = mesh.GetIdsFromFilter(filter)
371 print "Number of faces at least one node of each lies on sub_face3:", len(ids)
374 \section filter_belong_to_plane Belong to Plane
376 Filter mesh entities (nodes or elements) which all nodes belong to the
377 plane defined by threshold value with the given tolerance:
378 - element type can be: \a smesh.NODE, \a smesh.EDGE, \a smesh.FACE
379 - functor type should be \a smesh.FT_BelongToPlane
380 - threshold is geometrical object (plane)
381 - default tolerance is 1.0e-7
385 from SMESH_mechanic import *
388 plane_1 = geompy.MakePlane(p3,seg1,2000)
389 geompy.addToStudy(plane_1, "plane_1")
390 # get all nodes which lie on the plane \a plane_1
391 filter = smesh.GetFilter(smesh.NODE, smesh.FT_BelongToPlane, plane_1)
392 ids = mesh.GetIdsFromFilter(filter)
393 print "Number of nodes which lie on the plane plane_1:", len(ids)
396 \section filter_belong_to_cylinder Belong to Cylinder
398 Filter mesh entities (nodes or elements) which all nodes belong to the
399 cylindrical face defined by threshold value with the given tolerance:
400 - element type can be: \a smesh.NODE, \a smesh.EDGE, \a smesh.FACE
401 - functor type should be \a smesh.FT_BelongToCylinder
402 - threshold is geometrical object (cylindrical face)
403 - default tolerance is 1.0e-7
407 from SMESH_mechanic import *
408 # get all faces which lie on the cylindrical face \a sub_face1
409 filter = smesh.GetFilter(smesh.FACE, smesh.FT_BelongToCylinder, sub_face1)
410 ids = mesh.GetIdsFromFilter(filter)
411 print "Number of faces which lie on the cylindrical surface sub_face1:", len(ids)
414 \section filter_belong_to_surface Belong to Surface
416 Filter mesh entities (nodes or elements) which all nodes belong to the
417 arbitrary surface defined by threshold value with the given tolerance:
418 - element type can be: \a smesh.NODE, \a smesh.EDGE, \a smesh.FACE
419 - functor type should be \a smesh.FT_BelongToGenSurface
420 - threshold is geometrical object (arbitrary surface)
421 - default tolerance is 1.0e-7
425 from SMESH_mechanic import *
427 spline_1 = geompy.MakeInterpol([p4,p6,p3,p1])
428 surface_1 = geompy.MakePrismVecH( spline_1, vz, 70.0 )
429 geompy.addToStudy(surface_1, "surface_1")
430 # get all nodes which lie on the surface \a surface_1
431 filter = smesh.GetFilter(smesh.NODE, smesh.FT_BelongToGenSurface, surface_1)
432 ids = mesh.GetIdsFromFilter(filter)
433 print "Number of nodes which lie on the surface surface_1:", len(ids)
436 \section filter_range_of_ids Range of IDs
438 Filter mesh entities elements (nodes or elements) according to the
439 specified identifiers range:
440 - element type can be any entity type, from \a smesh.NODE to \a smesh.VOLUME
441 - functor type is \a smesh.FT_RangeOfIds
442 - threshold is string listing required IDs and/or ranges of IDs, e.g."1,2,3,50-60,63,67,70-78"
446 from SMESH_mechanic import *
447 # get nodes with identifiers [5-10] and [15-30]
448 criterion1 = smesh.GetCriterion(smesh.NODE, smesh.FT_RangeOfIds, Treshold="5-10",\
449 BinaryOp=smesh.FT_LogicalOR)
450 criterion2 = smesh.GetCriterion(smesh.NODE, smesh.FT_RangeOfIds, Treshold="15-30")
451 filter = smesh.CreateFilterManager().CreateFilter()
452 filter.SetCriteria([criterion1,criterion2])
453 ids = mesh.GetIdsFromFilter(filter)
454 print "Number of nodes in ranges [5-10] and [15-30]:", len(ids)
457 \section filter_bad_oriented_volume Badly oriented volume
459 Filter 3D mesh elements (volumes), which are incorrectly oriented from
460 the point of view of MED convention.
461 - element type should be \a smesh.VOLUME
462 - functor type is \a smesh.FT_BadOrientedVolume
463 - threshold is not required
466 # create mesh with volumes
467 from SMESH_mechanic import *
468 mesh.Tetrahedron( algo=smesh.NETGEN )
470 # get all badly oriented volumes
471 filter = smesh.GetFilter(smesh.VOLUME, smesh.FT_BadOrientedVolume)
472 ids = mesh.GetIdsFromFilter(filter)
473 print "Number of badly oriented volumes:", len(ids)
476 \section filter_linear_or_quadratic Linear / quadratic
478 Filter linear / quadratic mesh elements:
479 - element type should be any element type, e.g.: \a smesh.EDGE, \a smesh.FACE, \a smesh.VOLUME
480 - functor type is \a smesh.FT_LinearOrQuadratic
481 - threshold is not required
482 - if unary operator is set to smesh.FT_LogicalNOT, the quadratic
483 elements are selected, otherwise (by default) linear elements are selected
487 from SMESH_mechanic import *
488 # get number of linear and quadratic edges
489 filter_linear = smesh.GetFilter(smesh.EDGE, smesh.FT_LinearOrQuadratic)
490 filter_quadratic = smesh.GetFilter(smesh.EDGE, smesh.FT_LinearOrQuadratic, smesh.FT_LogicalNOT)
491 ids_linear = mesh.GetIdsFromFilter(filter_linear)
492 ids_quadratic = mesh.GetIdsFromFilter(filter_quadratic)
493 print "Number of linear edges:", len(ids_linear), "; number of quadratic edges:", len(ids_quadratic)
494 # convert mesh to quadratic
495 print "Convert to quadratic..."
496 mesh.ConvertToQuadratic(True)
497 # get number of linear and quadratic edges
498 ids_linear = mesh.GetIdsFromFilter(filter_linear)
499 ids_quadratic = mesh.GetIdsFromFilter(filter_quadratic)
500 print "Number of linear edges:", len(ids_linear), "; number of quadratic edges:", len(ids_quadratic)
503 \section filter_group_color Group color
505 Filter mesh entities, belonging to the group with the color defined by the threshold value.
506 - element type can be any entity type, from \a smesh.NODE to \a smesh.VOLUME
507 - functor type is \a smesh.FT_GroupColor
508 - threshold should be of SALOMEDS.Color type
512 from SMESH_mechanic import *
513 # create group of edges
514 all_edges = mesh.GetElementsByType(smesh.EDGE)
515 grp = mesh.MakeGroupByIds("edges group", smesh.EDGE, all_edges[:len(all_edges)/4])
517 c = SALOMEDS.Color(0.1, 0.5, 1.0)
519 # get number of the edges not belonging to the group with the given color
520 filter = smesh.GetFilter(smesh.EDGE, smesh.FT_GroupColor, c, smesh.FT_LogicalNOT)
521 ids = mesh.GetIdsFromFilter(filter)
522 print "Number of edges not beloging to the group with color (0.1, 0.5, 1.0):", len(ids)
525 \section filter_geom_type Geometry type
527 Filter mesh elements by the geometric type defined with the threshold
528 value. The list of available geometric types depends on the element
530 - element type should be any element type, e.g.: \a smesh.EDGE, \a smesh.FACE, \a smesh.VOLUME
531 - functor type should be \a smesh.FT_ElemGeomType
532 - threshold is of smesh.GeometryType value
535 # create mesh with volumes
536 from SMESH_mechanic import *
537 mesh.Tetrahedron( algo=smesh.NETGEN )
539 # get all triangles, quadrangles, tetrahedrons, pyramids
540 filter_tri = smesh.GetFilter(smesh.FACE, smesh.FT_ElemGeomType, smesh.Geom_TRIANGLE)
541 filter_qua = smesh.GetFilter(smesh.FACE, smesh.FT_ElemGeomType, smesh.Geom_QUADRANGLE)
542 filter_tet = smesh.GetFilter(smesh.VOLUME, smesh.FT_ElemGeomType, smesh.Geom_TETRA)
543 filter_pyr = smesh.GetFilter(smesh.VOLUME, smesh.FT_ElemGeomType, smesh.Geom_PYRAMID)
544 ids_tri = mesh.GetIdsFromFilter(filter_tri)
545 ids_qua = mesh.GetIdsFromFilter(filter_qua)
546 ids_tet = mesh.GetIdsFromFilter(filter_tet)
547 ids_pyr = mesh.GetIdsFromFilter(filter_pyr)
548 print "Number of triangles:", len(ids_tri)
549 print "Number of quadrangles:", len(ids_qua)
550 print "Number of tetrahedrons:", len(ids_tet)
551 print "Number of pyramids:", len(ids_pyr)