Filters allow picking only the mesh elements satisfying to a
specific condition or a set of conditions. Filters can be used to create
-or edit mesh groups, remove elements from the mesh object, control
+or edit mesh groups, remove elements from the mesh, control
mesh quality by different parameters, etc.
Several filtering criteria can be combined together by using logical
\section filter_aspect_ratio Aspect ratio
-Filter 2D mesh elements (faces) according to the aspect ratio value:
+filters 2D mesh elements (faces) according to the aspect ratio value:
- element type should be \a SMESH.FACE
- functor type should be \a SMESH.FT_AspectRatio
- threshold is floating point value (aspect ratio)
\section filter_aspect_ratio_3d Aspect ratio 3D
-Filter 3D mesh elements (volumes) according to the aspect ratio value:
+filters 3D mesh elements (volumes) according to the aspect ratio value:
- element type is \a SMESH.VOLUME
- functor type is \a SMESH.FT_AspectRatio3D
- threshold is floating point value (aspect ratio)
\section filter_warping_angle Warping angle
-Filter 2D mesh elements (faces) according to the warping angle value:
+filters 2D mesh elements (faces) according to the warping angle value:
- element type is \a SMESH.FACE
- functor type is \a SMESH.FT_Warping
- threshold is floating point value (warping angle)
\section filter_minimum_angle Minimum angle
-Filter 2D mesh elements (faces) according to the minimum angle value:
+filters 2D mesh elements (faces) according to the minimum angle value:
- element type is \a SMESH.FACE
- functor type is \a SMESH.FT_MinimumAngle
- threshold is floating point value (minimum angle)
\section filter_taper Taper
-Filter 2D mesh elements (faces) according to the taper value:
+filters 2D mesh elements (faces) according to the taper value:
- element type is \a SMESH.FACE
- functor type is \a SMESH.FT_Taper
- threshold is floating point value (taper)
\section filter_skew Skew
-Filter 2D mesh elements (faces) according to the skew value:
+filters 2D mesh elements (faces) according to the skew value:
- element type is \a SMESH.FACE
- functor type is \a SMESH.FT_Skew
- threshold is floating point value (skew)
\section filter_area Area
-Filter 2D mesh elements (faces) according to the area value:
+filters 2D mesh elements (faces) according to the area value:
- element type is \a SMESH.FACE
- functor type is \a SMESH.FT_Area
- threshold is floating point value (area)
\section filter_volume Volume
-Filter 3D mesh elements (volumes) according to the volume value:
+filters 3D mesh elements (volumes) according to the volume value:
- element type is \a SMESH.VOLUME
- functor type is \a SMESH.FT_Volume3D
- threshold is floating point value (volume)
\section filter_free_borders Free borders
-Filter 1D mesh elements (edges) which represent free borders of a mesh:
+filters 1D mesh elements (edges) which represent free borders of a mesh:
- element type is \a SMESH.EDGE
- functor type is \a SMESH.FT_FreeBorders
- threshold value is not required
\section filter_free_edges Free edges
-Filter 2D mesh elements (faces) consisting of edges belonging to one
-element of mesh only:
+filters 2D mesh elements (faces) having edges (i.e. links between
+nodes, not mesh segments) belonging to one face of mesh only:
- element type is \a SMESH.FACE
- functor type is \a SMESH.FT_FreeEdges
- threshold value is not required
\section filter_free_nodes Free nodes
-Filter free nodes:
+filters free nodes:
- element type is \a SMESH.NODE
- functor type is \a SMESH.FT_FreeNodes
- threshold value is not required
\section filter_free_faces Free faces
-Filter free faces:
+filters free faces:
- element type is \a SMESH.FACE
- functor type is \a SMESH.FT_FreeFaces
- threshold value is not required
\section filter_bare_border_faces Bare border faces
-Filter faces with bare borders:
+filters faces with bare borders:
- element type is \a SMESH.FACE
- functor type is \a SMESH.FT_BareBorderFace
- threshold value is not required
\section filter_coplanar_faces Coplanar faces
-Filter faces with bare borders:
+filters coplanar faces:
- element type is \a SMESH.FACE
- functor type is \a SMESH.FT_CoplanarFaces
- threshold value is the face ID
\section filter_over_constrained_faces Over-constrained faces
-Filter over-constrained faces:
+filters over-constrained faces:
- element type is \a SMESH.FACE
- functor type is \a SMESH.FT_OverConstrainedFace
- threshold value is not required
\section filter_double_elements Double edges, Double faces, Double volumes
-filter mesh elements basing on the same set of nodes:
+filters mesh elements basing on the same set of nodes:
- element type is either \a SMESH.EGDE, \a SMESH.FACE or \a SMESH.VOLUME
- functor type is either \a SMESH.FT_EqualEdges, \a
SMESH.FT_EqualFaces or \a SMESH.FT_EqualVolumes,
\section filter_borders_multiconnection Borders at multi-connection
-Filter border 1D mesh elements (edges) according to the specified number of
-connections (faces belonging the border edges)
+filters 1D mesh elements (segments) according to the specified number of
+connections (faces and volumes on whose border the segment lies):
- element type is \a SMESH.EDGE
- functor type is \a SMESH.FT_MultiConnection
- threshold is integer value (number of connections)
\section filter_borders_multiconnection_2d Borders at multi-connection 2D
-Filter 2D mesh elements (faces) which consist of edges belonging
-to the specified number of mesh elements
+filters 2D mesh elements (faces) with the specified maximal number of
+faces connected to a border (link between nodes, not mesh segment):
- element type is \a SMESH.FACE
- functor type is \a SMESH.FT_MultiConnection2D
- threshold is integer value (number of connections)
\section filter_length Length
-Filter 1D mesh elements (edges) according to the edge length value:
+filters 1D mesh elements (edges) according to the edge length value:
- element type should be \a SMESH.EDGE
- functor type should be \a SMESH.FT_Length
- threshold is floating point value (length)
\section filter_length_2d Length 2D
-Filter 2D mesh elements (faces) corresponding to the maximum length.
-value of its edges:
+filters 2D mesh elements (faces) according to the maximum length of its
+edges (links between nodes):
- element type should be \a SMESH.FACE
- functor type should be \a SMESH.FT_Length2D
- threshold is floating point value (edge length)
\section filter_max_element_length_2d Element Diameter 2D
-Filter 2D mesh elements (faces) corresponding to the maximum length
-value of its edges and diagonals:
+filters 2D mesh elements (faces) according to the maximum length
+of its edges and diagonals:
- element type should be \a SMESH.FACE
- functor type should be \a SMESH.FT_MaxElementLength2D
-- threshold is floating point value (edge/diagonal length)
+- threshold is floating point value (length)
\tui_script{filters_ex22.py}
\section filter_max_element_length_3d Element Diameter 3D
-Filter 3D mesh elements (volumes) corresponding to the maximum length
-value of its edges and diagonals:
+filters 3D mesh elements (volumes) according to the maximum length
+of its edges and diagonals:
- element type should be \a SMESH.VOLUME
- functor type should be \a SMESH.FT_MaxElementLength3D
- threshold is floating point value (edge/diagonal length)
\section filter_bare_border_volumes Bare border volumes
-Filter 3D mesh elements with bare borders:
+filters 3D mesh elements with bare borders, i.e. having a facet not
+shared with other volumes and without a face on it:
- element type is \a SMESH.VOLUME
- functor type is \a SMESH.FT_BareBorderVolume
- threshold value is not required
\section filter_over_constrained_volumes Over-constrained volumes
-Filter over-constrained volumes:
+filters over-constrained volumes, whose all nodes are on the mesh boundary:
- element type is \a SMESH.VOLUME
- functor type is \a SMESH.FT_OverConstrainedVolume
- threshold value is not required
\section filter_belong_to_group Belong to Mesh Group
-Filter mesh entities (nodes or elements) included in a mesh group
+filters mesh entities (nodes or elements) included in a mesh group
defined by threshold value:
- element type can be any entity type, from \a SMESH.NODE to \a SMESH.VOLUME
- functor type should be \a SMESH.FT_BelongToMeshGroup
\section filter_belong_to_geom Belong to Geom
-Filter mesh entities (nodes or elements) which all nodes lie on the
+filters mesh entities (nodes or elements) which all nodes lie on the
shape defined by threshold value:
- element type can be any entity type, from \a SMESH.NODE to \a SMESH.VOLUME
- functor type should be \a SMESH.FT_BelongToGeom
- threshold is geometrical object
+- tolerance is a distance between a node and the geometrical object;
+it is used if an node is not associated to any geometry.
\tui_script{filters_ex26.py}
\section filter_lying_on_geom Lying on Geom
-Filter mesh entities (nodes or elements) at least one node of which lies on the
+filters mesh entities (nodes or elements) at least one node of which lies on the
shape defined by threshold value:
- element type can be any entity type, from \a SMESH.NODE to \a SMESH.VOLUME
- functor type should be \a SMESH.FT_LyingOnGeom
- threshold is geometrical object
+- tolerance is a distance between a node and the geometrical object;
+it is used if an node is not associated to any geometry.
\tui_script{filters_ex27.py}
\section filter_belong_to_plane Belong to Plane
-Filter mesh entities (nodes or elements) which all nodes belong to the
+filters mesh entities (nodes or elements) which all nodes belong to the
plane defined by threshold value with the given tolerance:
- element type can be: \a SMESH.NODE, \a SMESH.EDGE, \a SMESH.FACE
- functor type should be \a SMESH.FT_BelongToPlane
\section filter_belong_to_cylinder Belong to Cylinder
-Filter mesh entities (nodes or elements) which all nodes belong to the
+filters mesh entities (nodes or elements) which all nodes belong to the
cylindrical face defined by threshold value with the given tolerance:
- element type can be: \a , \a SMESH.EDGE, \a SMESH.FACE
- functor type should be \a SMESH.FT_BelongToCylinder
\section filter_belong_to_surface Belong to Surface
-Filter mesh entities (nodes or elements) which all nodes belong to the
+filters mesh entities (nodes or elements) which all nodes belong to the
arbitrary surface defined by threshold value with the given tolerance:
- element type can be: \a SMESH.NODE, \a SMESH.EDGE, \a SMESH.FACE
- functor type should be \a SMESH.FT_BelongToGenSurface
\section filter_range_of_ids Range of IDs
-Filter mesh entities elements (nodes or elements) according to the
+filters mesh entities elements (nodes or elements) according to the
specified identifiers range:
- element type can be any entity type, from \a SMESH.NODE to \a SMESH.VOLUME
- functor type is \a SMESH.FT_RangeOfIds
\section filter_bad_oriented_volume Badly oriented volume
-Filter 3D mesh elements (volumes), which are incorrectly oriented from
+filters 3D mesh elements (volumes), which are incorrectly oriented from
the point of view of MED convention.
- element type should be \a SMESH.VOLUME
- functor type is \a SMESH.FT_BadOrientedVolume
\section filter_linear_or_quadratic Linear / quadratic
-Filter linear / quadratic mesh elements:
+filters linear / quadratic mesh elements:
- element type should be any element type, e.g.: \a SMESH.EDGE, \a SMESH.FACE, \a SMESH.VOLUME
- functor type is \a SMESH.FT_LinearOrQuadratic
- threshold is not required
\section filter_group_color Group color
-Filter mesh entities, belonging to the group with the color defined by the threshold value.
+filters mesh entities, belonging to the group with the color defined by the threshold value.
- element type can be any entity type, from \a SMESH.NODE to \a SMESH.VOLUME
- functor type is \a SMESH.FT_GroupColor
- threshold should be of SALOMEDS.Color type
\section filter_geom_type Geometry type
-Filter mesh elements by the geometric type defined with the threshold
+filters mesh elements by the geometric type defined with the threshold
value. The list of available geometric types depends on the element
entity type.
- element type should be any element type, e.g.: \a SMESH.EDGE, \a SMESH.FACE, \a SMESH.VOLUME
bool SMESHGUI_MeshOp::isSelectedHyp( int theDim, int theHypType, int theIndex) const
{
+ if ( theIndex < 0 )
+ return false;
+
if ( theHypType < AddHyp ) // only one hyp can be selected
return currentHyp( theDim, theHypType ) == theIndex;
* \param theDim - dimension of hypothesis or algorithm
* \param theHypType - Type of hypothesis (Algo, MainHyp, AddHyp)
* \param theIndex - Index of hypothesis
+ * \param updateHypsOnAlgoDeselection - to clear and disable hyps if algo deselected
*
* Gets current hypothesis or algorithms
*/
//================================================================================
-void SMESHGUI_MeshOp::setCurrentHyp( const int theDim,
- const int theHypType,
- const int theIndex )
+void SMESHGUI_MeshOp::setCurrentHyp( const int theDim,
+ const int theHypType,
+ const int theIndex,
+ const bool updateHypsOnAlgoDeselection)
{
myIgnoreAlgoSelection = true;
myDlg->tab( theDim )->setCurrentHyp( theHypType, theIndex + 1 );
myIgnoreAlgoSelection = false;
+
+ if ( updateHypsOnAlgoDeselection && theHypType == Algo && theIndex < 0 )
+ {
+ const QStringList noHyps;
+ myDlg->tab( theDim )->setAvailableHyps( MainHyp, noHyps );
+ myDlg->tab( theDim )->setExistingHyps ( MainHyp, noHyps );
+ myDlg->tab( theDim )->setAvailableHyps( AddHyp, noHyps );
+ myDlg->tab( theDim )->setExistingHyps ( AddHyp, noHyps );
+ }
}
//================================================================================
* \param theIndex - Index of current type of mesh
*/
//================================================================================
-void SMESHGUI_MeshOp::onAlgoSetByMeshType( const int theTabIndex, const int theIndex)
+void SMESHGUI_MeshOp::onAlgoSetByMeshType( const int theTabIndex, const int theIndex )
{
setFilteredAlgoData( theTabIndex, theIndex);
}
}
else
for ( int i = SMESH::DIM_0D; i <= SMESH::DIM_3D; i++ ) {
- if ( i > myMaxShapeDim || ( isReqDisBound && i != aReqDim ) ) myDlg->disableTab( i );
- else myDlg->enableTab( i );
+ if ( i > myMaxShapeDim || ( isReqDisBound && i < aReqDim ) ) myDlg->disableTab( i );
+ else myDlg->enableTab( i );
}
myDlg->setCurrentTab( theTabIndex );
}
//set new algorithm list and select the current algorithm
myDlg->tab( dim )->setAvailableHyps( Algo, anAvailableAlgs );
anCurrentCompareType = ( anCompareType == "HEXA" || anCompareType == "QUAD" ) ? "QUAD" : "TRIA";
- setCurrentHyp( dim, Algo, anCurrentAvailableAlgo );
+ setCurrentHyp( dim, Algo, anCurrentAvailableAlgo, /*updateHyps=*/true );
}
for ( int i = myMaxShapeDim; i >= SMESH::DIM_0D; i-- ) {
for (int j = myMaxShapeDim; j >= SMESH::DIM_0D; j--) {
if ( currentHyp( j, Algo ) < 0 ) {
myDlg->disableTab( j );
- setCurrentHyp( j , Algo, -1 );
+ setCurrentHyp( j , Algo, -1, /*updateHyps=*/true );
}
}
break;
}
}
if ( aDim == SMESH::DIM_2D) {
+ setCurrentHyp( SMESH::DIM_3D, Algo, -1, /*updateHyps=*/true );
myDlg->disableTab( SMESH::DIM_3D );
- setCurrentHyp( SMESH::DIM_3D, Algo, -1);
}
int currentTab = ( theTabIndex <= aDim ) ? theTabIndex : aDim;
