doc/salome/gui/SMESH/input/tui_filters.doc

   1 /*!
   2
   3 \page tui_filters_page Filters usage
   4
   5 Filters allow picking only the mesh elements satisfying to a
   6 specific condition or a 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.
   9
  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.
  13
  14 Mesh filters use the functionality of mesh quality controls to filter
  15 mesh nodes / elements by a specific characteristic (Area, Length, etc).
  16
  17 This page provides a short description of the existing mesh filters,
  18 describes required parameters and gives simple examples of usage in
  19 Python scripts.
  20
  21 \sa \ref tui_quality_controls_page
  22
  23 \section filter_aspect_ratio Aspect ratio
  24
  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)
  29
  30 \code
  31 # create mesh
  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)
  37 \endcode
  38
  39 \sa \ref tui_aspect_ratio
  40
  41 \section filter_aspect_ratio_3d Aspect ratio 3D
  42
  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)
  47
  48 \code
  49 # create mesh with volumes
  50 from SMESH_mechanic import *
  51 mesh.Tetrahedron( algo=smesh.NETGEN )
  52 mesh.Compute()
  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)
  57 \endcode
  58
  59 \sa \ref tui_aspect_ratio_3d
  60
  61 \section filter_warping_angle Warping angle
  62
  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)
  67
  68 \code
  69 # create mesh
  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)
  78 \endcode
  79
  80 \sa \ref tui_warping
  81
  82 \section filter_minimum_angle Minimum angle
  83
  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)
  88
  89 \code
  90 # create mesh
  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)
  96 \endcode
  97
  98 \sa \ref tui_minimum_angle
  99
 100 \section filter_taper Taper
 101
 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)
 106
 107 \code
 108 # create mesh
 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)
 114 \endcode
 115
 116 \sa \ref tui_taper
 117
 118 \section filter_skew Skew
 119
 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)
 124
 125 \code
 126 # create mesh
 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)
 132 \endcode
 133
 134 \sa \ref tui_skew
 135
 136 \section filter_area Area
 137
 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)
 142
 143 \code
 144 # create mesh
 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)
 154 \endcode
 155
 156 \sa \ref tui_area
 157
 158 \section filter_volume Volume
 159
 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)
 164
 165 \code
 166 # create mesh with volumes
 167 from SMESH_mechanic import *
 168 mesh.Tetrahedron( algo=smesh.NETGEN )
 169 mesh.Compute()
 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)
 174 \endcode
 175
 176 \sa \ref tui_volume
 177
 178 \section filter_free_borders Free borders
 179
 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
 184
 185 \code
 186 # create mesh
 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)
 193 mesh.Compute()
 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)
 198 \endcode
 199
 200 \sa \ref tui_free_borders
 201
 202 \section filter_free_edges Free edges
 203
 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
 209
 210 \code
 211 # create mesh
 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)
 218 mesh.Compute()
 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)
 223 \endcode
 224
 225 \sa \ref tui_free_edges
 226
 227 \section filter_free_nodes Free nodes
 228
 229 Filter free nodes:
 230 - element type is \a smesh.NODE
 231 - functor type is \a smesh.FT_FreeNodes
 232 - threshold value is not required
 233
 234 \code
 235 # create mesh
 236 from SMESH_mechanic import *
 237 # add node
 238 mesh.AddNode(0,0,0)
 239 # get all free nodes
 240 filter = smesh.GetFilter(smesh.EDGE, smesh.FT_FreeNodes)
 241 ids = mesh.GetIdsFromFilter(filter)
 242 print "Number of free nodes:", len(ids)
 243 \endcode
 244
 245 \sa \ref tui_free_nodes
 246
 247 \section filter_free_faces Free faces
 248
 249 Filter free faces:
 250 - element type is \a smesh.FACE
 251 - functor type is \a smesh.FT_FreeFaces
 252 - threshold value is not required
 253
 254 \code
 255 # create mesh
 256 from SMESH_mechanic import *
 257 # get all free faces
 258 filter = smesh.GetFilter(smesh.EDGE, smesh.FT_FreeFaces)
 259 ids = mesh.GetIdsFromFilter(filter)
 260 print "Number of free faces:", len(ids)
 261 \endcode
 262
 263 \sa \ref tui_free_faces
 264
 265 \section filter_borders_multiconnection Borders at multi-connection
 266
 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)
 272
 273 \code
 274 # create mesh
 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)
 280 \endcode
 281
 282 \sa \ref tui_borders_at_multiconnection
 283
 284 \section filter_borders_multiconnection_2d Borders at multi-connection 2D
 285
 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)
 291
 292 \code
 293 # create mesh
 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)
 299 \endcode
 300
 301 \sa \ref tui_borders_at_multiconnection_2d
 302
 303 \section filter_length Length
 304
 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)
 309
 310 \code
 311 # create mesh
 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)
 317 \endcode
 318
 319 \sa \ref tui_length_1d
 320
 321 \section filter_length_2d Length 2D
 322
 323 Filter 2D mesh elements (faces) corresponding to the maximum length.
 324 value of its edges:
 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)
 328
 329 \code
 330 # create mesh
 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)
 336 \endcode
 337
 338 \sa \ref tui_length_2d
 339
 340 \section filter_belong_to_geom Belong to Geom
 341
 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
 347
 348 \code
 349 # create mesh
 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)
 355 \endcode
 356
 357 \section filter_lying_on_geom Lying on Geom
 358
 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
 364
 365 \code
 366 # create mesh
 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)
 372 \endcode
 373
 374 \section filter_belong_to_plane Belong to Plane
 375
 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
 382
 383 \code
 384 # create mesh
 385 from SMESH_mechanic import *
 386 # create plane
 387 import geompy
 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)
 394 \endcode
 395
 396 \section filter_belong_to_cylinder Belong to Cylinder
 397
 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
 404
 405 \code
 406 # create mesh
 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)
 412 \endcode
 413
 414 \section filter_belong_to_surface Belong to Surface
 415
 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
 422
 423 \code
 424 # create mesh
 425 from SMESH_mechanic import *
 426 # create b-spline
 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)
 434 \endcode
 435
 436 \section filter_range_of_ids Range of IDs
 437
 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"
 443
 444 \code
 445 # create mesh
 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)
 455 \endcode
 456
 457 \section filter_bad_oriented_volume Badly oriented volume
 458
 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
 464
 465 \code
 466 # create mesh with volumes
 467 from SMESH_mechanic import *
 468 mesh.Tetrahedron( algo=smesh.NETGEN )
 469 mesh.Compute()
 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)
 474 \endcode
 475
 476 \section filter_linear_or_quadratic Linear / quadratic
 477
 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
 484
 485 \code
 486 # create mesh
 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)
 501 \endcode
 502
 503 \section filter_group_color Group color
 504
 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
 509
 510 \code
 511 # create mesh
 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])
 516 import SALOMEDS
 517 c = SALOMEDS.Color(0.1, 0.5, 1.0)
 518 grp.SetColor(c)
 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)
 523 \endcode
 524
 525 \section filter_geom_type Geometry type
 526
 527 Filter mesh elements by the geometric type defined with the threshold
 528 value. The list of available geometric types depends on the element
 529 entity type.
 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
 533
 534 \code
 535 # create mesh with volumes
 536 from SMESH_mechanic import *
 537 mesh.Tetrahedron( algo=smesh.NETGEN )
 538 mesh.Compute()
 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)
 552 \endcode
 553
 554 */