ForkMaster/smesh
1
0
Fork 0
mirror of https://git.salome-platform.org/gitpub/modules/smesh.git synced 2025-01-13 18:20:34 +05:00
Code Issues Packages Projects Releases Wiki Activity

PR: synchro V7_main tag mergefrom_V6_main_06Mar13

Browse Source
This commit is contained in:
prascle 2013-03-11 16:10:13 +00:00
parent 4cd2499bdd
commit 373c03904b
72 changed files with 3390 additions and 1694 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
doc/salome/examples/Makefile.am
View File

@ -174,7 +174,10 @@ pyexamples_SCRIPTS = $(BAD_TESTS) $(GOOD_TESTS)
EXTRA_DIST += $(pyexamples_SCRIPTS) testme.py EXTRA_DIST += $(pyexamples_SCRIPTS) testme.py
THIS_PYTHONPATH = $(KERNEL_ROOT_DIR)/bin/salome:$(KERNEL_ROOT_DIR)/lib/python$(PYTHON_VERSION)/site-packages/salome:$(KERNEL_ROOT_DIR)/lib64/python$(PYTHON_VERSION)/site-packages/salome
THIS_LD_LIBRARY_PATH = $(KERNEL_ROOT_DIR)/lib/salome
installcheck-local: installcheck-local:
@for f in $(GOOD_TESTS) ; do \ @for f in $(GOOD_TESTS) ; do \
env SMESH_ROOT_DIR=$(prefix) python -B $(top_srcdir)/doc/salome/examples/testme.py $(top_srcdir)/doc/salome/examples/$$f || exit 1; \ SMESH_ROOT_DIR=$(prefix) PYTHONPATH=$(THIS_PYTHONPATH):${PYTHONPATH} LD_LIBRARY_PATH=$(THIS_LD_LIBRARY_PATH):${LD_LIBRARY_PATH} python -B $(top_srcdir)/doc/salome/examples/testme.py $(top_srcdir)/doc/salome/examples/$$f || exit 1; \
done done

BIN
doc/salome/gui/SMESH/images/convert.png
View File

Binary file not shown.
Side by Side Swipe Overlay

Before

Width:  |  Height:  |  Size: 14 KiB

After

Width:  |  Height:  |  Size: 8.5 KiB

20
doc/salome/gui/SMESH/input/adding_quadratic_elements.doc
View File

@ -4,10 +4,22 @@
\n MESH module allows you to work with <b>Quadratic Elements</b>. \n MESH module allows you to work with <b>Quadratic Elements</b>.
Quadratic Edge is not a straight but a broken line and can be defined Quadratic elements are defined by same corner nodes as the
by three points: first, middle and last. All more complex \b Quadratic corresponding linear ones, and in addition they bear \a midside nodes
\b Elements differ from ordinary ones in that they consist of Quadratic located between the corner nodes on element sides.
Edges.
The quadratic quadrilateral element can bear an additional node at the
element center, then it is referred as bi-quadratic one (or
QUAD9). The quadratic hexahedral element can bear 7 additional nodes:
at the element center and at centers of sides, then it is referred as
tri-quadratic one (or HEXA27).
There are several ways you can create quadratic elements in your mesh:
- manually create quadratic elements (the way described below);
- use \ref quadratic_mesh_anchor "Quadratic Mesh" hypothesis to
generate quadratic mesh on your geometry;
- convert an existing linear mesh to a quadratic one
(see \ref convert_to_from_quadratic_mesh_page).
<em>To add a quadratic element to your mesh:</em> <em>To add a quadratic element to your mesh:</em>
<ol> <ol>

3
doc/salome/gui/SMESH/input/additional_hypo.doc
View File

@ -23,6 +23,9 @@ Quadratic Mesh hypothesis allows to build a quadratic mesh (whose
edges are not straight but curved lines and can be defined by three edges are not straight but curved lines and can be defined by three
points: first, middle and last instead of an ordinary two). points: first, middle and last instead of an ordinary two).
See \ref adding_quadratic_elements_page
for more information about quadratic meshes.
\anchor propagation_anchor \anchor propagation_anchor
<h2>Propagation of 1D Hypothesis on opposite edges</h2> <h2>Propagation of 1D Hypothesis on opposite edges</h2>

35
doc/salome/gui/SMESH/input/convert_to_from_quadratic_mesh.doc
View File

@ -2,13 +2,14 @@
\page convert_to_from_quadratic_mesh_page Convert to/from Quadratic Mesh \page convert_to_from_quadratic_mesh_page Convert to/from Quadratic Mesh
\n This functionality allows transforming standard meshes (or \n This functionality allows transforming linear meshes (or
sub-meshes) to quadratic and vice versa. sub-meshes) to quadratic and vice versa.
See \ref adding_quadratic_elements_page "Adding quadratic elements" Note that conversion of a sub-mesh most probably will produce a
for more information about quadratic meshes. non-conformal mesh. Elements on the boundary between quadratic and
Note that conversion of a sub-mesh most probably will linear sub-meshes become (or remain) quadratic.
produce a non-conformal mesh. Elements on the boundary between
quadratic and linear sub-meshes become (or remain) quadratic. See \ref adding_quadratic_elements_page for more information about
quadratic meshes.
<em>To produce a conversion:</em> <em>To produce a conversion:</em>
<ol> <ol>
@ -18,8 +19,10 @@ Viewer.</li>
Mesh item </b>, or click <em>"Convert to/from quadratic"</em> button in the Mesh item </b>, or click <em>"Convert to/from quadratic"</em> button in the
toolbar. toolbar.
<center>
\image html image154.png \image html image154.png
<center><em>"Convert to/from quadratic" button</em></center> <em>"Convert to/from quadratic" button</em>
</center>
The following dialog box will appear: The following dialog box will appear:
@ -29,18 +32,20 @@ The following dialog box will appear:
<li>In this dialog box specify: <li>In this dialog box specify:
<ul> <ul>
<li>if it is necessary to convert a standard mesh to quadratic or a quadratic <li>If it is necessary to convert a linear mesh to quadratic or a quadratic
mesh to standard. Note that the choice is available only if the selected mesh mesh to linear. **Convert to bi-quadratic** option means same as
(or sub-mesh) contains both quadratic and linear elements, else the **Convert to quadratic** except that QUAD9 elements are created
direction of conversion is selected automatically.</li> instead of QUAD8, and HEXA27 elements are created instead of
HEXA20. Note that the choice is available only if the selected mesh
<li>if it is necessary to place medium nodes of the quadratic mesh on the (or sub-mesh) contains both quadratic and linear elements, else the
direction of conversion is selected automatically.</li>
<li>If it is necessary to place medium nodes of the quadratic mesh on the
geometry (meshed object). This option is relevant for conversion to geometry (meshed object). This option is relevant for conversion to
quadratic provided that the mesh is based on a geometry (not imported from file).</li> quadratic provided that the mesh is based on a geometry (not imported from file).</li>
</ul> </ul>
\image html image156.gif \image html image156.gif
<center>Standard mesh (coarse mesh on a torus)</center> <center>Linear mesh (coarse mesh on a torus)</center>
\image html image155.gif \image html image155.gif
<center>Quadratic mesh</center> <center>Quadratic mesh</center>

12
idl/SMESH_Filter.idl
View File

@ -75,6 +75,7 @@ module SMESH
FT_LinearOrQuadratic, FT_LinearOrQuadratic,
FT_GroupColor, FT_GroupColor,
FT_ElemGeomType, FT_ElemGeomType,
FT_EntityType,
FT_CoplanarFaces, FT_CoplanarFaces,
FT_BallDiameter, FT_BallDiameter,
FT_LessThan, FT_LessThan,
@ -422,6 +423,15 @@ module SMESH
void SetGeometryType( in GeometryType theType ); void SetGeometryType( in GeometryType theType );
}; };
/*!
* Functor "Element entity type"
* Returns is element has indicated entity type
*/
interface ElemEntityType : Predicate{
void SetElementType ( in ElementType theType );
void SetEntityType( in EntityType theSetEntityType );
};
/*! /*!
* Functor "Coplanar faces" * Functor "Coplanar faces"
* Returns true if a mesh face is a coplanar neighbour to a given one. It checks * Returns true if a mesh face is a coplanar neighbour to a given one. It checks
@ -543,7 +553,6 @@ module SMESH
MultiConnection CreateMultiConnection(); MultiConnection CreateMultiConnection();
MultiConnection2D CreateMultiConnection2D(); MultiConnection2D CreateMultiConnection2D();
BallDiameter CreateBallDiameter(); BallDiameter CreateBallDiameter();
/*! /*!
* Create logical functors ( predicates ) * Create logical functors ( predicates )
*/ */
@ -575,6 +584,7 @@ module SMESH
GroupColor CreateGroupColor(); GroupColor CreateGroupColor();
ElemGeomType CreateElemGeomType(); ElemGeomType CreateElemGeomType();
ElemEntityType CreateElemEntityType();
CoplanarFaces CreateCoplanarFaces(); CoplanarFaces CreateCoplanarFaces();
/*! /*!

360
idl/SMESH_MeshEditor.idl
View File

@ -42,26 +42,26 @@ module SMESH
* Return data of mesh edition preview which is computed provided * Return data of mesh edition preview which is computed provided
* that the editor was obtained trough SMESH_Mesh::GetMeshEditPreviewer() * that the editor was obtained trough SMESH_Mesh::GetMeshEditPreviewer()
*/ */
MeshPreviewStruct GetPreviewData(); MeshPreviewStruct GetPreviewData() raises (SALOME::SALOME_Exception);
/*! /*!
* If during last operation of MeshEditor some nodes were * If during last operation of MeshEditor some nodes were
* created this method returns list of their IDs, if new nodes * created this method returns list of their IDs, if new nodes
* not created - returns empty list * not created - returns empty list
*/ */
long_array GetLastCreatedNodes(); long_array GetLastCreatedNodes() raises (SALOME::SALOME_Exception);
/*! /*!
* If during last operation of MeshEditor some elements were * If during last operation of MeshEditor some elements were
* created this method returns list of their IDs, if new elements * created this method returns list of their IDs, if new elements
* not created - returns empty list * not created - returns empty list
*/ */
long_array GetLastCreatedElems(); long_array GetLastCreatedElems() raises (SALOME::SALOME_Exception);
/*! /*!
* \brief Returns description of an error/warning occured during the last operation * \brief Returns description of an error/warning occured during the last operation
*/ */
ComputeError GetLastError(); ComputeError GetLastError() raises (SALOME::SALOME_Exception);
/*! /*!
* \brief Wrap a sequence of ids in a SMESH_IDSource * \brief Wrap a sequence of ids in a SMESH_IDSource
@ -75,20 +75,20 @@ module SMESH
* \param IDsOfElements list of mesh elements identifiers * \param IDsOfElements list of mesh elements identifiers
* \return \c true if elements are correctly removed or \c false otherwise * \return \c true if elements are correctly removed or \c false otherwise
*/ */
boolean RemoveElements(in long_array IDsOfElements); boolean RemoveElements(in long_array IDsOfElements) raises (SALOME::SALOME_Exception);
/*! /*!
* \brief Remove mesh nodes specified by their identifiers. * \brief Remove mesh nodes specified by their identifiers.
* \param IDsOfNodes list of mesh nodes identifiers * \param IDsOfNodes list of mesh nodes identifiers
* \return \c true if nodes are correctly removed or \c false otherwise * \return \c true if nodes are correctly removed or \c false otherwise
*/ */
boolean RemoveNodes(in long_array IDsOfNodes); boolean RemoveNodes(in long_array IDsOfNodes) raises (SALOME::SALOME_Exception);
/*! /*!
* \brief Remove all orphan nodes. * \brief Remove all orphan nodes.
* \return number of removed nodes * \return number of removed nodes
*/ */
long RemoveOrphanNodes(); long RemoveOrphanNodes() raises (SALOME::SALOME_Exception);
/*! /*!
* \brief Add a new node. * \brief Add a new node.
@ -97,19 +97,19 @@ module SMESH
* \param z Z coordinate of new node * \param z Z coordinate of new node
* \return integer identifier of new node * \return integer identifier of new node
*/ */
long AddNode(in double x, in double y, in double z); long AddNode(in double x, in double y, in double z) raises (SALOME::SALOME_Exception);
/*! /*!
* Create a 0D element on the given node. * Create a 0D element on the given node.
* \param IdOfNode Node IDs for creation of element. * \param IdOfNode Node IDs for creation of element.
*/ */
long Add0DElement(in long IDOfNode); long Add0DElement(in long IDOfNode) raises (SALOME::SALOME_Exception);
/*! /*!
* Create a ball element on the given node. * Create a ball element on the given node.
* \param IdOfNode Node IDs for creation of element. * \param IdOfNode Node IDs for creation of element.
*/ */
long AddBall(in long IDOfNode, in double diameter); long AddBall(in long IDOfNode, in double diameter) raises (SALOME::SALOME_Exception);
/*! /*!
* Create an edge, either linear and quadratic (this is determed * Create an edge, either linear and quadratic (this is determed
@ -119,7 +119,7 @@ module SMESH
* of MED. This description is located by the following link: * of MED. This description is located by the following link:
* http://www.salome-platform.org/salome2/web_med_internet/logiciels/medV2.2.2_doc_html/html/modele_de_donnees.html#3. * http://www.salome-platform.org/salome2/web_med_internet/logiciels/medV2.2.2_doc_html/html/modele_de_donnees.html#3.
*/ */
long AddEdge(in long_array IDsOfNodes); long AddEdge(in long_array IDsOfNodes) raises (SALOME::SALOME_Exception);
/*! /*!
* Create face, either linear and quadratic (this is determed * Create face, either linear and quadratic (this is determed
@ -129,9 +129,9 @@ module SMESH
* of MED. This description is located by the following link: * of MED. This description is located by the following link:
* http://www.salome-platform.org/salome2/web_med_internet/logiciels/medV2.2.2_doc_html/html/modele_de_donnees.html#3. * http://www.salome-platform.org/salome2/web_med_internet/logiciels/medV2.2.2_doc_html/html/modele_de_donnees.html#3.
*/ */
long AddFace(in long_array IDsOfNodes); long AddFace(in long_array IDsOfNodes) raises (SALOME::SALOME_Exception);
long AddPolygonalFace(in long_array IdsOfNodes); long AddPolygonalFace(in long_array IdsOfNodes) raises (SALOME::SALOME_Exception);
/*! /*!
* Create volume, either linear and quadratic (this is determed * Create volume, either linear and quadratic (this is determed
@ -141,7 +141,7 @@ module SMESH
* of MED. This description is located by the following link: * of MED. This description is located by the following link:
* http://www.salome-platform.org/salome2/web_med_internet/logiciels/medV2.2.2_doc_html/html/modele_de_donnees.html#3. * http://www.salome-platform.org/salome2/web_med_internet/logiciels/medV2.2.2_doc_html/html/modele_de_donnees.html#3.
*/ */
long AddVolume(in long_array IDsOfNodes); long AddVolume(in long_array IDsOfNodes) raises (SALOME::SALOME_Exception);
/*! /*!
* Create volume of many faces, giving nodes for each face. * Create volume of many faces, giving nodes for each face.
@ -150,14 +150,14 @@ module SMESH
* gives quantity of nodes in face number i. * gives quantity of nodes in face number i.
*/ */
long AddPolyhedralVolume (in long_array IdsOfNodes, long AddPolyhedralVolume (in long_array IdsOfNodes,
in long_array Quantities); in long_array Quantities) raises (SALOME::SALOME_Exception);
/*! /*!
* Create volume of many faces, giving IDs of existing faces. * Create volume of many faces, giving IDs of existing faces.
* \param IdsOfFaces List of face IDs for volume creation. * \param IdsOfFaces List of face IDs for volume creation.
* \note The created volume will refer only to nodes * \note The created volume will refer only to nodes
* of the given faces, not to the faces itself. * of the given faces, not to the faces itself.
*/ */
long AddPolyhedralVolumeByFaces (in long_array IdsOfFaces); long AddPolyhedralVolumeByFaces (in long_array IdsOfFaces) raises (SALOME::SALOME_Exception);
/*! /*!
* Create 0D elements on all nodes of the given object except those * Create 0D elements on all nodes of the given object except those
@ -212,15 +212,20 @@ module SMESH
raises (SALOME::SALOME_Exception); raises (SALOME::SALOME_Exception);
boolean MoveNode(in long NodeID, in double x, in double y, in double z); boolean MoveNode(in long NodeID, in double x, in double y, in double z)
raises (SALOME::SALOME_Exception);
boolean InverseDiag(in long NodeID1, in long NodeID2); boolean InverseDiag(in long NodeID1, in long NodeID2)
raises (SALOME::SALOME_Exception);
boolean DeleteDiag(in long NodeID1, in long NodeID2); boolean DeleteDiag(in long NodeID1, in long NodeID2)
raises (SALOME::SALOME_Exception);
boolean Reorient(in long_array IDsOfElements); boolean Reorient(in long_array IDsOfElements)
raises (SALOME::SALOME_Exception);
boolean ReorientObject(in SMESH_IDSource theObject); boolean ReorientObject(in SMESH_IDSource theObject)
raises (SALOME::SALOME_Exception);
/*! /*!
* \brief Reorient faces contained in \a the2Dgroup. * \brief Reorient faces contained in \a the2Dgroup.
* \param the2Dgroup - the mesh or its part to reorient * \param the2Dgroup - the mesh or its part to reorient
@ -245,7 +250,7 @@ module SMESH
*/ */
boolean TriToQuad (in long_array IDsOfElements, boolean TriToQuad (in long_array IDsOfElements,
in NumericalFunctor Criterion, in NumericalFunctor Criterion,
in double MaxAngle); in double MaxAngle) raises (SALOME::SALOME_Exception);
/*! /*!
* \brief Fuse neighbour triangles into quadrangles. * \brief Fuse neighbour triangles into quadrangles.
@ -254,7 +259,7 @@ module SMESH
*/ */
boolean TriToQuadObject (in SMESH_IDSource theObject, boolean TriToQuadObject (in SMESH_IDSource theObject,
in NumericalFunctor Criterion, in NumericalFunctor Criterion,
in double MaxAngle); in double MaxAngle) raises (SALOME::SALOME_Exception);
/*! /*!
* \brief Split quadrangles into triangles. * \brief Split quadrangles into triangles.
@ -263,7 +268,7 @@ module SMESH
* \return TRUE in case of success, FALSE otherwise. * \return TRUE in case of success, FALSE otherwise.
*/ */
boolean QuadToTri (in long_array IDsOfElements, boolean QuadToTri (in long_array IDsOfElements,
in NumericalFunctor Criterion); in NumericalFunctor Criterion) raises (SALOME::SALOME_Exception);
/*! /*!
* \brief Split quadrangles into triangles. * \brief Split quadrangles into triangles.
@ -271,7 +276,7 @@ module SMESH
* Behaves like the above method, taking list of elements from \a theObject * Behaves like the above method, taking list of elements from \a theObject
*/ */
boolean QuadToTriObject (in SMESH_IDSource theObject, boolean QuadToTriObject (in SMESH_IDSource theObject,
in NumericalFunctor Criterion); in NumericalFunctor Criterion) raises (SALOME::SALOME_Exception);
/*! /*!
* \brief Split quadrangles into triangles. * \brief Split quadrangles into triangles.
@ -280,7 +285,7 @@ module SMESH
* \return TRUE in case of success, FALSE otherwise. * \return TRUE in case of success, FALSE otherwise.
*/ */
boolean SplitQuad (in long_array IDsOfElements, boolean SplitQuad (in long_array IDsOfElements,
in boolean Diag13); in boolean Diag13) raises (SALOME::SALOME_Exception);
/*! /*!
* \brief Split quadrangles into triangles. * \brief Split quadrangles into triangles.
@ -288,7 +293,7 @@ module SMESH
* Behaves like the above method, taking list of elements from \a theObject * Behaves like the above method, taking list of elements from \a theObject
*/ */
boolean SplitQuadObject (in SMESH_IDSource theObject, boolean SplitQuadObject (in SMESH_IDSource theObject,
in boolean Diag13); in boolean Diag13) raises (SALOME::SALOME_Exception);
/*! /*!
* Find better splitting of the given quadrangle. * Find better splitting of the given quadrangle.
@ -298,7 +303,7 @@ module SMESH
* diagonal is better, 0 if error occurs. * diagonal is better, 0 if error occurs.
*/ */
long BestSplit (in long IDOfQuad, long BestSplit (in long IDOfQuad,
in NumericalFunctor Criterion); in NumericalFunctor Criterion) raises (SALOME::SALOME_Exception);
/*! /*!
* \brief Split volumic elements into tetrahedrons * \brief Split volumic elements into tetrahedrons
@ -318,40 +323,44 @@ module SMESH
in long_array IDsOfFixedNodes, in long_array IDsOfFixedNodes,
in long MaxNbOfIterations, in long MaxNbOfIterations,
in double MaxAspectRatio, in double MaxAspectRatio,
in Smooth_Method Method); in Smooth_Method Method) raises (SALOME::SALOME_Exception);
boolean SmoothObject(in SMESH_IDSource theObject, boolean SmoothObject(in SMESH_IDSource theObject,
in long_array IDsOfFixedNodes, in long_array IDsOfFixedNodes,
in long MaxNbOfIterations, in long MaxNbOfIterations,
in double MaxAspectRatio, in double MaxAspectRatio,
in Smooth_Method Method); in Smooth_Method Method) raises (SALOME::SALOME_Exception);
boolean SmoothParametric(in long_array IDsOfElements, boolean SmoothParametric(in long_array IDsOfElements,
in long_array IDsOfFixedNodes, in long_array IDsOfFixedNodes,
in long MaxNbOfIterations, in long MaxNbOfIterations,
in double MaxAspectRatio, in double MaxAspectRatio,
in Smooth_Method Method); in Smooth_Method Method) raises (SALOME::SALOME_Exception);
boolean SmoothParametricObject(in SMESH_IDSource theObject, boolean SmoothParametricObject(in SMESH_IDSource theObject,
in long_array IDsOfFixedNodes, in long_array IDsOfFixedNodes,
in long MaxNbOfIterations, in long MaxNbOfIterations,
in double MaxAspectRatio, in double MaxAspectRatio,
in Smooth_Method Method); in Smooth_Method Method) raises (SALOME::SALOME_Exception);
void ConvertToQuadratic(in boolean theForce3d);
boolean ConvertFromQuadratic();
void ConvertToQuadratic(in boolean theForce3d)
raises (SALOME::SALOME_Exception);
void ConvertToQuadraticObject(in boolean theForce3d, void ConvertToQuadraticObject(in boolean theForce3d,
in SMESH_IDSource theObject) in SMESH_IDSource theObject)
raises (SALOME::SALOME_Exception); raises (SALOME::SALOME_Exception);
void ConvertFromQuadraticObject(in SMESH_IDSource theObject) boolean ConvertFromQuadratic()
raises (SALOME::SALOME_Exception);
void ConvertFromQuadraticObject(in SMESH_IDSource theObject)
raises (SALOME::SALOME_Exception); raises (SALOME::SALOME_Exception);
void RenumberNodes(); void ConvertToBiQuadratic(in boolean theForce3d,
in SMESH_IDSource theObject)
raises (SALOME::SALOME_Exception);
void RenumberElements(); void RenumberNodes() raises (SALOME::SALOME_Exception);
void RenumberElements() raises (SALOME::SALOME_Exception);
/*! /*!
* \brief Genarate dim+1 elements by rotation of given elements around axis * \brief Genarate dim+1 elements by rotation of given elements around axis
@ -364,7 +373,8 @@ module SMESH
in AxisStruct Axix, in AxisStruct Axix,
in double AngleInRadians, in double AngleInRadians,
in long NbOfSteps, in long NbOfSteps,
in double Tolerance); in double Tolerance)
raises (SALOME::SALOME_Exception);
/*! /*!
* \brief Same as previous but additionally create groups of elements * \brief Same as previous but additionally create groups of elements
* generated from elements belonging to preexisting groups * generated from elements belonging to preexisting groups
@ -373,7 +383,8 @@ module SMESH
in AxisStruct Axix, in AxisStruct Axix,
in double AngleInRadians, in double AngleInRadians,
in long NbOfSteps, in long NbOfSteps,
in double Tolerance); in double Tolerance)
raises (SALOME::SALOME_Exception);
/*! /*!
* \brief Genarate dim+1 elements by rotation of the object around axis * \brief Genarate dim+1 elements by rotation of the object around axis
* \param theObject - object containing elements to ratate * \param theObject - object containing elements to ratate
@ -385,7 +396,8 @@ module SMESH
in AxisStruct Axix, in AxisStruct Axix,
in double AngleInRadians, in double AngleInRadians,
in long NbOfSteps, in long NbOfSteps,
in double Tolerance); in double Tolerance)
raises (SALOME::SALOME_Exception);
/*! /*!
* \brief Same as previous but additionally create groups of elements * \brief Same as previous but additionally create groups of elements
* generated from elements belonging to preexisting groups * generated from elements belonging to preexisting groups
@ -394,7 +406,8 @@ module SMESH
in AxisStruct Axix, in AxisStruct Axix,
in double AngleInRadians, in double AngleInRadians,
in long NbOfSteps, in long NbOfSteps,
in double Tolerance); in double Tolerance)
raises (SALOME::SALOME_Exception);
/*! /*!
* \brief Genarate dim+1 elements by rotation of the object around axis * \brief Genarate dim+1 elements by rotation of the object around axis
* \param theObject - object containing elements to ratate * \param theObject - object containing elements to ratate
@ -406,7 +419,8 @@ module SMESH
in AxisStruct Axix, in AxisStruct Axix,
in double AngleInRadians, in double AngleInRadians,
in long NbOfSteps, in long NbOfSteps,
in double Tolerance); in double Tolerance)
raises (SALOME::SALOME_Exception);
/*! /*!
* \brief Same as previous but additionally create groups of elements * \brief Same as previous but additionally create groups of elements
* generated from elements belonging to preexisting groups * generated from elements belonging to preexisting groups
@ -415,7 +429,8 @@ module SMESH
in AxisStruct Axix, in AxisStruct Axix,
in double AngleInRadians, in double AngleInRadians,
in long NbOfSteps, in long NbOfSteps,
in double Tolerance); in double Tolerance)
raises (SALOME::SALOME_Exception);
/*! /*!
* \brief Genarate dim+1 elements by rotation of the object around axis * \brief Genarate dim+1 elements by rotation of the object around axis
* \param theObject - object containing elements to ratate * \param theObject - object containing elements to ratate
@ -427,7 +442,8 @@ module SMESH
in AxisStruct Axix, in AxisStruct Axix,
in double AngleInRadians, in double AngleInRadians,
in long NbOfSteps, in long NbOfSteps,
in double Tolerance); in double Tolerance)
raises (SALOME::SALOME_Exception);
/*! /*!
* \brief Same as previous but additionally create groups of elements * \brief Same as previous but additionally create groups of elements
* generated from elements belonging to preexisting groups * generated from elements belonging to preexisting groups
@ -436,7 +452,8 @@ module SMESH
in AxisStruct Axix, in AxisStruct Axix,
in double AngleInRadians, in double AngleInRadians,
in long NbOfSteps, in long NbOfSteps,
in double Tolerance); in double Tolerance)
raises (SALOME::SALOME_Exception);
/*! /*!
* \brief Genarate dim+1 elements by extrusion of elements along vector * \brief Genarate dim+1 elements by extrusion of elements along vector
* \param IDsOfElements - elements to sweep * \param IDsOfElements - elements to sweep
@ -445,7 +462,8 @@ module SMESH
*/ */
void ExtrusionSweep(in long_array IDsOfElements, void ExtrusionSweep(in long_array IDsOfElements,
in DirStruct StepVector, in DirStruct StepVector,
in long NbOfSteps); in long NbOfSteps)
raises (SALOME::SALOME_Exception);
/*! /*!
* \brief Genarate dim+1 elements by extrusion of elements along vector * \brief Genarate dim+1 elements by extrusion of elements along vector
* \param IDsOfElements - elements to sweep * \param IDsOfElements - elements to sweep
@ -454,20 +472,23 @@ module SMESH
*/ */
void ExtrusionSweep0D(in long_array IDsOfElements, void ExtrusionSweep0D(in long_array IDsOfElements,
in DirStruct StepVector, in DirStruct StepVector,
in long NbOfSteps); in long NbOfSteps)
raises (SALOME::SALOME_Exception);
/*! /*!
* \brief Same as previous but additionally create groups of elements * \brief Same as previous but additionally create groups of elements
* generated from elements belonging to preexisting groups * generated from elements belonging to preexisting groups
*/ */
ListOfGroups ExtrusionSweepMakeGroups(in long_array IDsOfElements, ListOfGroups ExtrusionSweepMakeGroups(in long_array IDsOfElements,
in DirStruct StepVector, in DirStruct StepVector,
in long NbOfSteps); in long NbOfSteps)
raises (SALOME::SALOME_Exception);
/*! /*!
* \brief Same as previous but elements are nodes * \brief Same as previous but elements are nodes
*/ */
ListOfGroups ExtrusionSweepMakeGroups0D(in long_array IDsOfElements, ListOfGroups ExtrusionSweepMakeGroups0D(in long_array IDsOfElements,
in DirStruct StepVector, in DirStruct StepVector,
in long NbOfSteps); in long NbOfSteps)
raises (SALOME::SALOME_Exception);
/*! /*!
* Generate new elements by extrusion of theElements * Generate new elements by extrusion of theElements
* by StepVector by NbOfSteps * by StepVector by NbOfSteps
@ -479,7 +500,8 @@ module SMESH
in DirStruct StepVector, in DirStruct StepVector,
in long NbOfSteps, in long NbOfSteps,
in long ExtrFlags, in long ExtrFlags,
in double SewTolerance); in double SewTolerance)
raises (SALOME::SALOME_Exception);
/*! /*!
* \brief Same as previous but additionally create groups of elements * \brief Same as previous but additionally create groups of elements
* generated from elements belonging to preexisting groups * generated from elements belonging to preexisting groups
@ -488,35 +510,44 @@ module SMESH
in DirStruct StepVector, in DirStruct StepVector,
in long NbOfSteps, in long NbOfSteps,
in long ExtrFlags, in long ExtrFlags,
in double SewTolerance); in double SewTolerance)
raises (SALOME::SALOME_Exception);
void ExtrusionSweepObject(in SMESH_IDSource theObject, void ExtrusionSweepObject(in SMESH_IDSource theObject,
in DirStruct StepVector, in DirStruct StepVector,
in long NbOfSteps); in long NbOfSteps)
raises (SALOME::SALOME_Exception);
ListOfGroups ExtrusionSweepObjectMakeGroups(in SMESH_IDSource theObject, ListOfGroups ExtrusionSweepObjectMakeGroups(in SMESH_IDSource theObject,
in DirStruct StepVector, in DirStruct StepVector,
in long NbOfSteps); in long NbOfSteps)
raises (SALOME::SALOME_Exception);
void ExtrusionSweepObject0D(in SMESH_IDSource theObject, void ExtrusionSweepObject0D(in SMESH_IDSource theObject,
in DirStruct StepVector, in DirStruct StepVector,
in long NbOfSteps); in long NbOfSteps)
raises (SALOME::SALOME_Exception);
ListOfGroups ExtrusionSweepObject0DMakeGroups(in SMESH_IDSource theObject, ListOfGroups ExtrusionSweepObject0DMakeGroups(in SMESH_IDSource theObject,
in DirStruct StepVector, in DirStruct StepVector,
in long NbOfSteps); in long NbOfSteps)
raises (SALOME::SALOME_Exception);
void ExtrusionSweepObject1D(in SMESH_IDSource theObject, void ExtrusionSweepObject1D(in SMESH_IDSource theObject,
in DirStruct StepVector, in DirStruct StepVector,
in long NbOfSteps); in long NbOfSteps)
raises (SALOME::SALOME_Exception);
ListOfGroups ExtrusionSweepObject1DMakeGroups(in SMESH_IDSource theObject, ListOfGroups ExtrusionSweepObject1DMakeGroups(in SMESH_IDSource theObject,
in DirStruct StepVector, in DirStruct StepVector,
in long NbOfSteps); in long NbOfSteps)
raises (SALOME::SALOME_Exception);
void ExtrusionSweepObject2D(in SMESH_IDSource theObject, void ExtrusionSweepObject2D(in SMESH_IDSource theObject,
in DirStruct StepVector, in DirStruct StepVector,
in long NbOfSteps); in long NbOfSteps)
raises (SALOME::SALOME_Exception);
ListOfGroups ExtrusionSweepObject2DMakeGroups(in SMESH_IDSource theObject, ListOfGroups ExtrusionSweepObject2DMakeGroups(in SMESH_IDSource theObject,
in DirStruct StepVector, in DirStruct StepVector,
in long NbOfSteps); in long NbOfSteps)
raises (SALOME::SALOME_Exception);
enum Extrusion_Error { enum Extrusion_Error {
EXTR_OK, EXTR_OK,
@ -538,7 +569,8 @@ module SMESH
in PointStruct RefPoint, in PointStruct RefPoint,
in boolean MakeGroups, in boolean MakeGroups,
in ElementType ElemType, in ElementType ElemType,
out Extrusion_Error Error); out Extrusion_Error Error)
raises (SALOME::SALOME_Exception);
ListOfGroups ExtrusionAlongPathObjX(in SMESH_IDSource theObject, ListOfGroups ExtrusionAlongPathObjX(in SMESH_IDSource theObject,
in SMESH_IDSource Path, in SMESH_IDSource Path,
@ -550,7 +582,8 @@ module SMESH
in PointStruct RefPoint, in PointStruct RefPoint,
in boolean MakeGroups, in boolean MakeGroups,
in ElementType ElemType, in ElementType ElemType,
out Extrusion_Error Error); out Extrusion_Error Error)
raises (SALOME::SALOME_Exception);
Extrusion_Error ExtrusionAlongPath(in long_array IDsOfElements, Extrusion_Error ExtrusionAlongPath(in long_array IDsOfElements,
in SMESH_Mesh PathMesh, in SMESH_Mesh PathMesh,
@ -559,7 +592,8 @@ module SMESH
in boolean HasAngles, in boolean HasAngles,
in double_array Angles, in double_array Angles,
in boolean HasRefPoint, in boolean HasRefPoint,
in PointStruct RefPoint); in PointStruct RefPoint)
raises (SALOME::SALOME_Exception);
ListOfGroups ExtrusionAlongPathMakeGroups(in long_array IDsOfElements, ListOfGroups ExtrusionAlongPathMakeGroups(in long_array IDsOfElements,
in SMESH_Mesh PathMesh, in SMESH_Mesh PathMesh,
in GEOM::GEOM_Object PathShape, in GEOM::GEOM_Object PathShape,
@ -568,7 +602,8 @@ module SMESH
in double_array Angles, in double_array Angles,
in boolean HasRefPoint, in boolean HasRefPoint,
in PointStruct RefPoint, in PointStruct RefPoint,
out Extrusion_Error Error); out Extrusion_Error Error)
raises (SALOME::SALOME_Exception);
Extrusion_Error ExtrusionAlongPathObject(in SMESH_IDSource theObject, Extrusion_Error ExtrusionAlongPathObject(in SMESH_IDSource theObject,
in SMESH_Mesh PathMesh, in SMESH_Mesh PathMesh,
@ -577,7 +612,8 @@ module SMESH
in boolean HasAngles, in boolean HasAngles,
in double_array Angles, in double_array Angles,
in boolean HasRefPoint, in boolean HasRefPoint,
in PointStruct RefPoint); in PointStruct RefPoint)
raises (SALOME::SALOME_Exception);
ListOfGroups ExtrusionAlongPathObjectMakeGroups(in SMESH_IDSource theObject, ListOfGroups ExtrusionAlongPathObjectMakeGroups(in SMESH_IDSource theObject,
in SMESH_Mesh PathMesh, in SMESH_Mesh PathMesh,
in GEOM::GEOM_Object PathShape, in GEOM::GEOM_Object PathShape,
@ -586,7 +622,8 @@ module SMESH
in double_array Angles, in double_array Angles,
in boolean HasRefPoint, in boolean HasRefPoint,
in PointStruct RefPoint, in PointStruct RefPoint,
out Extrusion_Error Error); out Extrusion_Error Error)
raises (SALOME::SALOME_Exception);
Extrusion_Error ExtrusionAlongPathObject1D(in SMESH_IDSource theObject, Extrusion_Error ExtrusionAlongPathObject1D(in SMESH_IDSource theObject,
in SMESH_Mesh PathMesh, in SMESH_Mesh PathMesh,
@ -595,7 +632,8 @@ module SMESH
in boolean HasAngles, in boolean HasAngles,
in double_array Angles, in double_array Angles,
in boolean HasRefPoint, in boolean HasRefPoint,
in PointStruct RefPoint); in PointStruct RefPoint)
raises (SALOME::SALOME_Exception);
ListOfGroups ExtrusionAlongPathObject1DMakeGroups(in SMESH_IDSource theObject, ListOfGroups ExtrusionAlongPathObject1DMakeGroups(in SMESH_IDSource theObject,
in SMESH_Mesh PathMesh, in SMESH_Mesh PathMesh,
in GEOM::GEOM_Object PathShape, in GEOM::GEOM_Object PathShape,
@ -604,7 +642,8 @@ module SMESH
in double_array Angles, in double_array Angles,
in boolean HasRefPoint, in boolean HasRefPoint,
in PointStruct RefPoint, in PointStruct RefPoint,
out Extrusion_Error Error); out Extrusion_Error Error)
raises (SALOME::SALOME_Exception);
Extrusion_Error ExtrusionAlongPathObject2D(in SMESH_IDSource theObject, Extrusion_Error ExtrusionAlongPathObject2D(in SMESH_IDSource theObject,
in SMESH_Mesh PathMesh, in SMESH_Mesh PathMesh,
@ -613,7 +652,8 @@ module SMESH
in boolean HasAngles, in boolean HasAngles,
in double_array Angles, in double_array Angles,
in boolean HasRefPoint, in boolean HasRefPoint,
in PointStruct RefPoint); in PointStruct RefPoint)
raises (SALOME::SALOME_Exception);
ListOfGroups ExtrusionAlongPathObject2DMakeGroups(in SMESH_IDSource theObject, ListOfGroups ExtrusionAlongPathObject2DMakeGroups(in SMESH_IDSource theObject,
in SMESH_Mesh PathMesh, in SMESH_Mesh PathMesh,
in GEOM::GEOM_Object PathShape, in GEOM::GEOM_Object PathShape,
@ -622,7 +662,8 @@ module SMESH
in double_array Angles, in double_array Angles,
in boolean HasRefPoint, in boolean HasRefPoint,
in PointStruct RefPoint, in PointStruct RefPoint,
out Extrusion_Error Error); out Extrusion_Error Error)
raises (SALOME::SALOME_Exception);
/*! /*!
* Compute rotation angles for ExtrusionAlongPath as linear variation * Compute rotation angles for ExtrusionAlongPath as linear variation
@ -641,101 +682,126 @@ module SMESH
void Mirror (in long_array IDsOfElements, void Mirror (in long_array IDsOfElements,
in AxisStruct Mirror, in AxisStruct Mirror,
in MirrorType Type, in MirrorType Type,
in boolean Copy); in boolean Copy)
raises (SALOME::SALOME_Exception);
ListOfGroups MirrorMakeGroups (in long_array IDsOfElements, ListOfGroups MirrorMakeGroups (in long_array IDsOfElements,
in AxisStruct Mirror, in AxisStruct Mirror,
in MirrorType Type); in MirrorType Type)
raises (SALOME::SALOME_Exception);
SMESH_Mesh MirrorMakeMesh (in long_array IDsOfElements, SMESH_Mesh MirrorMakeMesh (in long_array IDsOfElements,
in AxisStruct Mirror, in AxisStruct Mirror,
in MirrorType Type, in MirrorType Type,
in boolean CopyGroups, in boolean CopyGroups,
in string MeshName); in string MeshName)
raises (SALOME::SALOME_Exception);
void MirrorObject (in SMESH_IDSource theObject, void MirrorObject (in SMESH_IDSource theObject,
in AxisStruct Mirror, in AxisStruct Mirror,
in MirrorType Type, in MirrorType Type,
in boolean Copy); in boolean Copy)
raises (SALOME::SALOME_Exception);
ListOfGroups MirrorObjectMakeGroups (in SMESH_IDSource theObject, ListOfGroups MirrorObjectMakeGroups (in SMESH_IDSource theObject,
in AxisStruct Mirror, in AxisStruct Mirror,
in MirrorType Type); in MirrorType Type)
raises (SALOME::SALOME_Exception);
SMESH_Mesh MirrorObjectMakeMesh (in SMESH_IDSource theObject, SMESH_Mesh MirrorObjectMakeMesh (in SMESH_IDSource theObject,
in AxisStruct Mirror, in AxisStruct Mirror,
in MirrorType Type, in MirrorType Type,
in boolean CopyGroups, in boolean CopyGroups,
in string MeshName); in string MeshName)
raises (SALOME::SALOME_Exception);
void Translate (in long_array IDsOfElements, void Translate (in long_array IDsOfElements,
in DirStruct Vector, in DirStruct Vector,
in boolean Copy); in boolean Copy)
raises (SALOME::SALOME_Exception);
ListOfGroups TranslateMakeGroups (in long_array IDsOfElements, ListOfGroups TranslateMakeGroups (in long_array IDsOfElements,
in DirStruct Vector); in DirStruct Vector)
raises (SALOME::SALOME_Exception);
SMESH_Mesh TranslateMakeMesh (in long_array IDsOfElements, SMESH_Mesh TranslateMakeMesh (in long_array IDsOfElements,
in DirStruct Vector, in DirStruct Vector,
in boolean CopyGroups, in boolean CopyGroups,
in string MeshName); in string MeshName)
raises (SALOME::SALOME_Exception);
void TranslateObject (in SMESH_IDSource theObject, void TranslateObject (in SMESH_IDSource theObject,
in DirStruct Vector, in DirStruct Vector,
in boolean Copy); in boolean Copy)
raises (SALOME::SALOME_Exception);
ListOfGroups TranslateObjectMakeGroups (in SMESH_IDSource theObject, ListOfGroups TranslateObjectMakeGroups (in SMESH_IDSource theObject,
in DirStruct Vector); in DirStruct Vector)
raises (SALOME::SALOME_Exception);
SMESH_Mesh TranslateObjectMakeMesh (in SMESH_IDSource theObject, SMESH_Mesh TranslateObjectMakeMesh (in SMESH_IDSource theObject,
in DirStruct Vector, in DirStruct Vector,
in boolean CopyGroups, in boolean CopyGroups,
in string MeshName); in string MeshName)
raises (SALOME::SALOME_Exception);
void Scale (in SMESH_IDSource theObject, void Scale (in SMESH_IDSource theObject,
in PointStruct thePoint, in PointStruct thePoint,
in double_array theScaleFact, in double_array theScaleFact,
in boolean Copy); in boolean Copy)
raises (SALOME::SALOME_Exception);
ListOfGroups ScaleMakeGroups (in SMESH_IDSource theObject, ListOfGroups ScaleMakeGroups (in SMESH_IDSource theObject,
in PointStruct thePoint, in PointStruct thePoint,
in double_array theScaleFact); in double_array theScaleFact)
raises (SALOME::SALOME_Exception);
SMESH_Mesh ScaleMakeMesh (in SMESH_IDSource theObject, SMESH_Mesh ScaleMakeMesh (in SMESH_IDSource theObject,
in PointStruct thePoint, in PointStruct thePoint,
in double_array theScaleFact, in double_array theScaleFact,
in boolean CopyGroups, in boolean CopyGroups,
in string MeshName); in string MeshName)
raises (SALOME::SALOME_Exception);
void Rotate (in long_array IDsOfElements, void Rotate (in long_array IDsOfElements,
in AxisStruct Axis, in AxisStruct Axis,
in double AngleInRadians, in double AngleInRadians,
in boolean Copy); in boolean Copy)
raises (SALOME::SALOME_Exception);
ListOfGroups RotateMakeGroups (in long_array IDsOfElements, ListOfGroups RotateMakeGroups (in long_array IDsOfElements,
in AxisStruct Axis, in AxisStruct Axis,
in double AngleInRadians); in double AngleInRadians)
raises (SALOME::SALOME_Exception);
SMESH_Mesh RotateMakeMesh (in long_array IDsOfElements, SMESH_Mesh RotateMakeMesh (in long_array IDsOfElements,
in AxisStruct Axis, in AxisStruct Axis,
in double AngleInRadians, in double AngleInRadians,
in boolean CopyGroups, in boolean CopyGroups,
in string MeshName); in string MeshName)
raises (SALOME::SALOME_Exception);
void RotateObject (in SMESH_IDSource theObject, void RotateObject (in SMESH_IDSource theObject,
in AxisStruct Axis, in AxisStruct Axis,
in double AngleInRadians, in double AngleInRadians,
in boolean Copy); in boolean Copy)
raises (SALOME::SALOME_Exception);
ListOfGroups RotateObjectMakeGroups (in SMESH_IDSource theObject, ListOfGroups RotateObjectMakeGroups (in SMESH_IDSource theObject,
in AxisStruct Axis, in AxisStruct Axis,
in double AngleInRadians); in double AngleInRadians)
raises (SALOME::SALOME_Exception);
SMESH_Mesh RotateObjectMakeMesh (in SMESH_IDSource theObject, SMESH_Mesh RotateObjectMakeMesh (in SMESH_IDSource theObject,
in AxisStruct Axis, in AxisStruct Axis,
in double AngleInRadians, in double AngleInRadians,
in boolean CopyGroups, in boolean CopyGroups,
in string MeshName); in string MeshName)
raises (SALOME::SALOME_Exception);
void FindCoincidentNodes (in double Tolerance, void FindCoincidentNodes (in double Tolerance,
out array_of_long_array GroupsOfNodes); out array_of_long_array GroupsOfNodes)
raises (SALOME::SALOME_Exception);
void FindCoincidentNodesOnPart (in SMESH_IDSource SubMeshOrGroup, void FindCoincidentNodesOnPart (in SMESH_IDSource SubMeshOrGroup,
in double Tolerance, in double Tolerance,
out array_of_long_array GroupsOfNodes); out array_of_long_array GroupsOfNodes)
raises (SALOME::SALOME_Exception);
void FindCoincidentNodesOnPartBut (in SMESH_IDSource SubMeshOrGroup, void FindCoincidentNodesOnPartBut (in SMESH_IDSource SubMeshOrGroup,
in double Tolerance, in double Tolerance,
out array_of_long_array GroupsOfNodes, out array_of_long_array GroupsOfNodes,
in ListOfIDSources ExceptSubMeshOrGroups); in ListOfIDSources ExceptSubMeshOrGroups)
raises (SALOME::SALOME_Exception);
void MergeNodes (in array_of_long_array GroupsOfNodes); void MergeNodes (in array_of_long_array GroupsOfNodes)
raises (SALOME::SALOME_Exception);
/*! /*!
* \brief Find elements built on the same nodes. * \brief Find elements built on the same nodes.
@ -743,36 +809,42 @@ module SMESH
* \return List of groups of equal elements. * \return List of groups of equal elements.
*/ */
void FindEqualElements (in SMESH_IDSource MeshOrSubMeshOrGroup, void FindEqualElements (in SMESH_IDSource MeshOrSubMeshOrGroup,
out array_of_long_array GroupsOfElementsID); out array_of_long_array GroupsOfElementsID)
raises (SALOME::SALOME_Exception);
/*! /*!
* \brief Merge elements in each given group. * \brief Merge elements in each given group.
* \param GroupsOfElementsID Groups of elements for merging. * \param GroupsOfElementsID Groups of elements for merging.
*/ */
void MergeElements(in array_of_long_array GroupsOfElementsID); void MergeElements(in array_of_long_array GroupsOfElementsID)
raises (SALOME::SALOME_Exception);
/*! /*!
* \brief Merge equal elements in the whole mesh. * \brief Merge equal elements in the whole mesh.
*/ */
void MergeEqualElements(); void MergeEqualElements()
raises (SALOME::SALOME_Exception);
/*! /*!
* If the given ID is a valid node ID (nodeID > 0), just move this node, else * If the given ID is a valid node ID (nodeID > 0), just move this node, else
* move the node closest to the point to point's location and return ID of the node * move the node closest to the point to point's location and return ID of the node
*/ */
long MoveClosestNodeToPoint(in double x, in double y, in double z, in long nodeID); long MoveClosestNodeToPoint(in double x, in double y, in double z, in long nodeID)
raises (SALOME::SALOME_Exception);
/*! /*!
* Return ID of node closest to a given point * Return ID of node closest to a given point
*/ */
long FindNodeClosestTo(in double x, in double y, in double z); long FindNodeClosestTo(in double x, in double y, in double z)
raises (SALOME::SALOME_Exception);
/*! /*!
* Return elements of given type where the given point is IN or ON. * Return elements of given type where the given point is IN or ON.
* *
* 'ALL' type means elements of any type excluding nodes and 0D elements * 'ALL' type means elements of any type excluding nodes and 0D elements
*/ */
long_array FindElementsByPoint(in double x, in double y, in double z, in ElementType type); long_array FindElementsByPoint(in double x, in double y, in double z, in ElementType type)
raises (SALOME::SALOME_Exception);
/*! /*!
* Searching among the given elements, return elements of given type * Searching among the given elements, return elements of given type
@ -782,13 +854,15 @@ module SMESH
*/ */
long_array FindAmongElementsByPoint(in SMESH_IDSource elements, long_array FindAmongElementsByPoint(in SMESH_IDSource elements,
in double x, in double y, in double z, in double x, in double y, in double z,
in ElementType type); in ElementType type)
raises (SALOME::SALOME_Exception);
/*! /*!
* Return point state in a closed 2D mesh in terms of TopAbs_State enumeration. * Return point state in a closed 2D mesh in terms of TopAbs_State enumeration.
* TopAbs_UNKNOWN state means that either mesh is wrong or the analysis fails. * TopAbs_UNKNOWN state means that either mesh is wrong or the analysis fails.
*/ */
short GetPointState(in double x, in double y, in double z); short GetPointState(in double x, in double y, in double z)
raises (SALOME::SALOME_Exception);
enum Sew_Error { enum Sew_Error {
SEW_OK, SEW_OK,
@ -811,13 +885,15 @@ module SMESH
in long SecondNodeID2, in long SecondNodeID2,
in long LastNodeID2, in long LastNodeID2,
in boolean CreatePolygons, in boolean CreatePolygons,
in boolean CreatePolyedrs); in boolean CreatePolyedrs)
raises (SALOME::SALOME_Exception);
Sew_Error SewConformFreeBorders (in long FirstNodeID1, Sew_Error SewConformFreeBorders (in long FirstNodeID1,
in long SecondNodeID1, in long SecondNodeID1,
in long LastNodeID1, in long LastNodeID1,
in long FirstNodeID2, in long FirstNodeID2,
in long SecondNodeID2); in long SecondNodeID2)
raises (SALOME::SALOME_Exception);
Sew_Error SewBorderToSide (in long FirstNodeIDOnFreeBorder, Sew_Error SewBorderToSide (in long FirstNodeIDOnFreeBorder,
in long SecondNodeIDOnFreeBorder, in long SecondNodeIDOnFreeBorder,
@ -825,21 +901,24 @@ module SMESH
in long FirstNodeIDOnSide, in long FirstNodeIDOnSide,
in long LastNodeIDOnSide, in long LastNodeIDOnSide,
in boolean CreatePolygons, in boolean CreatePolygons,
in boolean CreatePolyedrs); in boolean CreatePolyedrs)
raises (SALOME::SALOME_Exception);
Sew_Error SewSideElements (in long_array IDsOfSide1Elements, Sew_Error SewSideElements (in long_array IDsOfSide1Elements,
in long_array IDsOfSide2Elements, in long_array IDsOfSide2Elements,
in long NodeID1OfSide1ToMerge, in long NodeID1OfSide1ToMerge,
in long NodeID1OfSide2ToMerge, in long NodeID1OfSide2ToMerge,
in long NodeID2OfSide1ToMerge, in long NodeID2OfSide1ToMerge,
in long NodeID2OfSide2ToMerge); in long NodeID2OfSide2ToMerge)
raises (SALOME::SALOME_Exception);
/*! /*!
* Set new nodes for given element. * Set new nodes for given element.
* If number of nodes is not corresponded to type of * If number of nodes is not corresponded to type of
* element - returns false * element - returns false
*/ */
boolean ChangeElemNodes(in long ide, in long_array newIDs); boolean ChangeElemNodes(in long ide, in long_array newIDs)
raises (SALOME::SALOME_Exception);
/*! /*!
* \brief Creates a hole in a mesh by doubling the nodes of some particular elements * \brief Creates a hole in a mesh by doubling the nodes of some particular elements
@ -850,7 +929,8 @@ module SMESH
* \return TRUE if operation has been completed successfully, FALSE otherwise * \return TRUE if operation has been completed successfully, FALSE otherwise
* \sa DoubleNode(), DoubleNodeGroup(), DoubleNodeGroups() * \sa DoubleNode(), DoubleNodeGroup(), DoubleNodeGroups()
*/ */
boolean DoubleNodes( in long_array theNodes, in long_array theModifiedElems ); boolean DoubleNodes( in long_array theNodes, in long_array theModifiedElems )
raises (SALOME::SALOME_Exception);
/*! /*!
* \brief Creates a hole in a mesh by doubling the nodes of some particular elements * \brief Creates a hole in a mesh by doubling the nodes of some particular elements
@ -860,7 +940,8 @@ module SMESH
* \return TRUE if operation has been completed successfully, FALSE otherwise * \return TRUE if operation has been completed successfully, FALSE otherwise
* \sa DoubleNodes(), DoubleNodeGroup(), DoubleNodeGroups() * \sa DoubleNodes(), DoubleNodeGroup(), DoubleNodeGroups()
*/ */
boolean DoubleNode( in long theNodeId, in long_array theModifiedElems ); boolean DoubleNode( in long theNodeId, in long_array theModifiedElems )
raises (SALOME::SALOME_Exception);
/*! /*!
* \brief Creates a hole in a mesh by doubling the nodes of some particular elements * \brief Creates a hole in a mesh by doubling the nodes of some particular elements
@ -871,7 +952,8 @@ module SMESH
* \sa DoubleNode(), DoubleNodes(), DoubleNodeGroups(), DoubleNodeGroupNew() * \sa DoubleNode(), DoubleNodes(), DoubleNodeGroups(), DoubleNodeGroupNew()
*/ */
boolean DoubleNodeGroup( in SMESH_GroupBase theNodes, boolean DoubleNodeGroup( in SMESH_GroupBase theNodes,
in SMESH_GroupBase theModifiedElems ); in SMESH_GroupBase theModifiedElems )
raises (SALOME::SALOME_Exception);
/*! /*!
* \brief Creates a hole in a mesh by doubling the nodes of some particular elements. * \brief Creates a hole in a mesh by doubling the nodes of some particular elements.
* Works as DoubleNodeGroup() described above, but returns a new group with * Works as DoubleNodeGroup() described above, but returns a new group with
@ -882,7 +964,8 @@ module SMESH
* \sa DoubleNodeGroup() * \sa DoubleNodeGroup()
*/ */
SMESH_Group DoubleNodeGroupNew( in SMESH_GroupBase theNodes, SMESH_Group DoubleNodeGroupNew( in SMESH_GroupBase theNodes,
in SMESH_GroupBase theModifiedElems ); in SMESH_GroupBase theModifiedElems )
raises (SALOME::SALOME_Exception);
/*! /*!
* \brief Creates a hole in a mesh by doubling the nodes of some particular elements * \brief Creates a hole in a mesh by doubling the nodes of some particular elements
@ -893,7 +976,8 @@ module SMESH
* \sa DoubleNode(), DoubleNodeGroup(), DoubleNodes() * \sa DoubleNode(), DoubleNodeGroup(), DoubleNodes()
*/ */
boolean DoubleNodeGroups( in ListOfGroups theNodes, boolean DoubleNodeGroups( in ListOfGroups theNodes,
in ListOfGroups theModifiedElems ); in ListOfGroups theModifiedElems )
raises (SALOME::SALOME_Exception);
/*! /*!
* \brief Creates a hole in a mesh by doubling the nodes of some particular elements * \brief Creates a hole in a mesh by doubling the nodes of some particular elements
* Works as DoubleNodeGroups() described above, but returns a new group with * Works as DoubleNodeGroups() described above, but returns a new group with
@ -904,7 +988,8 @@ module SMESH
* \sa DoubleNodeGroups() * \sa DoubleNodeGroups()
*/ */
SMESH_Group DoubleNodeGroupsNew( in ListOfGroups theNodes, SMESH_Group DoubleNodeGroupsNew( in ListOfGroups theNodes,
in ListOfGroups theModifiedElems ); in ListOfGroups theModifiedElems )
raises (SALOME::SALOME_Exception);
/*! /*!
* \brief Creates a hole in a mesh by doubling the nodes of some particular elements * \brief Creates a hole in a mesh by doubling the nodes of some particular elements
@ -918,7 +1003,8 @@ module SMESH
*/ */
boolean DoubleNodeElem( in long_array theElems, boolean DoubleNodeElem( in long_array theElems,
in long_array theNodesNot, in long_array theNodesNot,
in long_array theAffectedElems ); in long_array theAffectedElems )
raises (SALOME::SALOME_Exception);
/*! /*!
* \brief Creates a hole in a mesh by doubling the nodes of some particular elements * \brief Creates a hole in a mesh by doubling the nodes of some particular elements
@ -933,7 +1019,8 @@ module SMESH
*/ */
boolean DoubleNodeElemInRegion( in long_array theElems, boolean DoubleNodeElemInRegion( in long_array theElems,
in long_array theNodesNot, in long_array theNodesNot,
in GEOM::GEOM_Object theShape ); in GEOM::GEOM_Object theShape )
raises (SALOME::SALOME_Exception);
/*! /*!
* \brief Creates a hole in a mesh by doubling the nodes of some particular elements * \brief Creates a hole in a mesh by doubling the nodes of some particular elements
@ -947,7 +1034,8 @@ module SMESH
*/ */
boolean DoubleNodeElemGroup( in SMESH_GroupBase theElems, boolean DoubleNodeElemGroup( in SMESH_GroupBase theElems,
in SMESH_GroupBase theNodesNot, in SMESH_GroupBase theNodesNot,
in SMESH_GroupBase theAffectedElems ); in SMESH_GroupBase theAffectedElems )
raises (SALOME::SALOME_Exception);
/*! /*!
* \brief Creates a hole in a mesh by doubling the nodes of some particular elements. * \brief Creates a hole in a mesh by doubling the nodes of some particular elements.
* Works as DoubleNodeElemGroup() described above, but returns a new group with * Works as DoubleNodeElemGroup() described above, but returns a new group with
@ -961,7 +1049,8 @@ module SMESH
*/ */
SMESH_Group DoubleNodeElemGroupNew( in SMESH_GroupBase theElems, SMESH_Group DoubleNodeElemGroupNew( in SMESH_GroupBase theElems,
in SMESH_GroupBase theNodesNot, in SMESH_GroupBase theNodesNot,
in SMESH_GroupBase theAffectedElems ); in SMESH_GroupBase theAffectedElems )
raises (SALOME::SALOME_Exception);
/*! /*!
* \brief Creates a hole in a mesh by doubling the nodes of some particular elements. * \brief Creates a hole in a mesh by doubling the nodes of some particular elements.
* Works as DoubleNodeElemGroup() described above, but returns two new groups: * Works as DoubleNodeElemGroup() described above, but returns two new groups:
@ -979,7 +1068,8 @@ module SMESH
in SMESH_GroupBase theNodesNot, in SMESH_GroupBase theNodesNot,
in SMESH_GroupBase theAffectedElems, in SMESH_GroupBase theAffectedElems,
in boolean theElemGroupNeeded, in boolean theElemGroupNeeded,
in boolean theNodeGroupNeeded); in boolean theNodeGroupNeeded)
raises (SALOME::SALOME_Exception);
/*! /*!
* \brief Creates a hole in a mesh by doubling the nodes of some particular elements * \brief Creates a hole in a mesh by doubling the nodes of some particular elements
@ -994,7 +1084,8 @@ module SMESH
*/ */
boolean DoubleNodeElemGroupInRegion( in SMESH_GroupBase theElems, boolean DoubleNodeElemGroupInRegion( in SMESH_GroupBase theElems,
in SMESH_GroupBase theNodesNot, in SMESH_GroupBase theNodesNot,
in GEOM::GEOM_Object theShape ); in GEOM::GEOM_Object theShape )
raises (SALOME::SALOME_Exception);
/*! /*!
* \brief Creates a hole in a mesh by doubling the nodes of some particular elements * \brief Creates a hole in a mesh by doubling the nodes of some particular elements
@ -1008,7 +1099,8 @@ module SMESH
*/ */
boolean DoubleNodeElemGroups( in ListOfGroups theElems, boolean DoubleNodeElemGroups( in ListOfGroups theElems,
in ListOfGroups theNodesNot, in ListOfGroups theNodesNot,
in ListOfGroups theAffectedElems ); in ListOfGroups theAffectedElems )
raises (SALOME::SALOME_Exception);
/*! /*!
* \brief Creates a hole in a mesh by doubling the nodes of some particular elements. * \brief Creates a hole in a mesh by doubling the nodes of some particular elements.
* Works as DoubleNodeElemGroups() described above, but returns a new group with * Works as DoubleNodeElemGroups() described above, but returns a new group with
@ -1022,7 +1114,8 @@ module SMESH
*/ */
SMESH_Group DoubleNodeElemGroupsNew( in ListOfGroups theElems, SMESH_Group DoubleNodeElemGroupsNew( in ListOfGroups theElems,
in ListOfGroups theNodesNot, in ListOfGroups theNodesNot,
in ListOfGroups theAffectedElems ); in ListOfGroups theAffectedElems )
raises (SALOME::SALOME_Exception);
/*! /*!
* \brief Creates a hole in a mesh by doubling the nodes of some particular elements. * \brief Creates a hole in a mesh by doubling the nodes of some particular elements.
* Works as DoubleNodeElemGroups() described above, but returns two new groups: * Works as DoubleNodeElemGroups() described above, but returns two new groups:
@ -1040,7 +1133,8 @@ module SMESH
in ListOfGroups theNodesNot, in ListOfGroups theNodesNot,
in ListOfGroups theAffectedElems, in ListOfGroups theAffectedElems,
in boolean theElemGroupNeeded, in boolean theElemGroupNeeded,
in boolean theNodeGroupNeeded ); in boolean theNodeGroupNeeded )
raises (SALOME::SALOME_Exception);
/*! /*!
* \brief Creates a hole in a mesh by doubling the nodes of some particular elements * \brief Creates a hole in a mesh by doubling the nodes of some particular elements
@ -1055,7 +1149,8 @@ module SMESH
*/ */
boolean DoubleNodeElemGroupsInRegion( in ListOfGroups theElems, boolean DoubleNodeElemGroupsInRegion( in ListOfGroups theElems,
in ListOfGroups theNodesNot, in ListOfGroups theNodesNot,
in GEOM::GEOM_Object theShape ); in GEOM::GEOM_Object theShape )
raises (SALOME::SALOME_Exception);
/*! /*!
* \brief Identify the elements that will be affected by node duplication (actual duplication is not performed). * \brief Identify the elements that will be affected by node duplication (actual duplication is not performed).
@ -1070,14 +1165,15 @@ module SMESH
*/ */
ListOfGroups AffectedElemGroupsInRegion( in ListOfGroups theElems, ListOfGroups AffectedElemGroupsInRegion( in ListOfGroups theElems,
in ListOfGroups theNodesNot, in ListOfGroups theNodesNot,
in GEOM::GEOM_Object theShape ); in GEOM::GEOM_Object theShape )
raises (SALOME::SALOME_Exception);
/*! /*!
* \brief Generates skin mesh (containing 2D cells) from 3D mesh * \brief Generates skin mesh (containing 2D cells) from 3D mesh
* The created 2D mesh elements based on nodes of free faces of boundary volumes * The created 2D mesh elements based on nodes of free faces of boundary volumes
* \return TRUE if operation has been completed successfully, FALSE otherwise * \return TRUE if operation has been completed successfully, FALSE otherwise
*/ */
boolean Make2DMeshFrom3D(); boolean Make2DMeshFrom3D() raises (SALOME::SALOME_Exception);
/*! /*!
* \brief Creates missing boundary elements * \brief Creates missing boundary elements
@ -1101,7 +1197,7 @@ module SMESH
in string meshName, in string meshName,
in boolean toCopyElements, in boolean toCopyElements,
in boolean toCopyExistingBondary, in boolean toCopyExistingBondary,
out SMESH_Group group); out SMESH_Group group) raises (SALOME::SALOME_Exception);
/*! /*!
* \brief Creates missing boundary elements around either the whole mesh or * \brief Creates missing boundary elements around either the whole mesh or
* groups of 2D elements * groups of 2D elements
@ -1150,7 +1246,8 @@ module SMESH
* \param theGroupsOfFaces - list of groups of faces * \param theGroupsOfFaces - list of groups of faces
* \return TRUE if operation has been completed successfully, FALSE otherwise * \return TRUE if operation has been completed successfully, FALSE otherwise
*/ */
boolean CreateFlatElementsOnFacesGroups( in ListOfGroups theGroupsOfFaces ); boolean CreateFlatElementsOnFacesGroups( in ListOfGroups theGroupsOfFaces )
raises (SALOME::SALOME_Exception);
/*! /*!
* \brief identify all the elements around a geom shape, get the faces delimiting the hole * \brief identify all the elements around a geom shape, get the faces delimiting the hole
@ -1162,7 +1259,8 @@ module SMESH
in GEOM::GEOM_Object theShape, in GEOM::GEOM_Object theShape,
in string groupName, in string groupName,
in double_array theNodesCoords, in double_array theNodesCoords,
out array_of_long_array GroupsOfNodes) raises (SALOME::SALOME_Exception); out array_of_long_array GroupsOfNodes)
raises (SALOME::SALOME_Exception);
}; };
}; };

137
src/Controls/SMESH_Controls.cxx
View File

@ -210,10 +210,13 @@ using namespace SMESH::Controls;
* FUNCTORS * FUNCTORS
*/ */
//================================================================================
/* /*
Class : NumericalFunctor Class : NumericalFunctor
Description : Base class for numerical functors Description : Base class for numerical functors
*/ */
//================================================================================
NumericalFunctor::NumericalFunctor(): NumericalFunctor::NumericalFunctor():
myMesh(NULL) myMesh(NULL)
{ {
@ -321,6 +324,7 @@ double NumericalFunctor::Round( const double & aVal )
* \param minmax - boundaries of diapason of values to divide into intervals * \param minmax - boundaries of diapason of values to divide into intervals
*/ */
//================================================================================ //================================================================================
void NumericalFunctor::GetHistogram(int nbIntervals, void NumericalFunctor::GetHistogram(int nbIntervals,
std::vector<int>& nbEvents, std::vector<int>& nbEvents,
std::vector<double>& funValues, std::vector<double>& funValues,
@ -403,9 +407,11 @@ void NumericalFunctor::GetHistogram(int nbIntervals,
} }
//======================================================================= //=======================================================================
//function : GetValue /*
//purpose : Class : Volume
//======================================================================= Description : Functor calculating volume of a 3D element
*/
//================================================================================
double Volume::GetValue( long theElementId ) double Volume::GetValue( long theElementId )
{ {
@ -417,21 +423,11 @@ double Volume::GetValue( long theElementId )
return 0; return 0;
} }
//=======================================================================
//function : GetBadRate
//purpose : meaningless as it is not quality control functor
//=======================================================================
double Volume::GetBadRate( double Value, int /*nbNodes*/ ) const double Volume::GetBadRate( double Value, int /*nbNodes*/ ) const
{ {
return Value; return Value;
} }
//=======================================================================
//function : GetType
//purpose :
//=======================================================================
SMDSAbs_ElementType Volume::GetType() const SMDSAbs_ElementType Volume::GetType() const
{ {
return SMDSAbs_Volume; return SMDSAbs_Volume;
@ -442,6 +438,8 @@ SMDSAbs_ElementType Volume::GetType() const
Class : MaxElementLength2D Class : MaxElementLength2D
Description : Functor calculating maximum length of 2D element Description : Functor calculating maximum length of 2D element
*/ */
//================================================================================
double MaxElementLength2D::GetValue( const TSequenceOfXYZ& P ) double MaxElementLength2D::GetValue( const TSequenceOfXYZ& P )
{ {
if(P.size() == 0) if(P.size() == 0)
@ -508,6 +506,7 @@ SMDSAbs_ElementType MaxElementLength2D::GetType() const
Class : MaxElementLength3D Class : MaxElementLength3D
Description : Functor calculating maximum length of 3D element Description : Functor calculating maximum length of 3D element
*/ */
//================================================================================
double MaxElementLength3D::GetValue( long theElementId ) double MaxElementLength3D::GetValue( long theElementId )
{ {
@ -683,6 +682,7 @@ SMDSAbs_ElementType MaxElementLength3D::GetType() const
Class : MinimumAngle Class : MinimumAngle
Description : Functor for calculation of minimum angle Description : Functor for calculation of minimum angle
*/ */
//================================================================================
double MinimumAngle::GetValue( const TSequenceOfXYZ& P ) double MinimumAngle::GetValue( const TSequenceOfXYZ& P )
{ {
@ -715,10 +715,13 @@ SMDSAbs_ElementType MinimumAngle::GetType() const
} }
//================================================================================
/* /*
Class : AspectRatio Class : AspectRatio
Description : Functor for calculating aspect ratio Description : Functor for calculating aspect ratio
*/ */
//================================================================================
double AspectRatio::GetValue( long theId ) double AspectRatio::GetValue( long theId )
{ {
double aVal = 0; double aVal = 0;
@ -899,10 +902,13 @@ SMDSAbs_ElementType AspectRatio::GetType() const
} }
//================================================================================
/* /*
Class : AspectRatio3D Class : AspectRatio3D
Description : Functor for calculating aspect ratio Description : Functor for calculating aspect ratio
*/ */
//================================================================================
namespace{ namespace{
inline double getHalfPerimeter(double theTria[3]){ inline double getHalfPerimeter(double theTria[3]){
@ -1269,10 +1275,13 @@ SMDSAbs_ElementType AspectRatio3D::GetType() const
} }
//================================================================================
/* /*
Class : Warping Class : Warping
Description : Functor for calculating warping Description : Functor for calculating warping
*/ */
//================================================================================
double Warping::GetValue( const TSequenceOfXYZ& P ) double Warping::GetValue( const TSequenceOfXYZ& P )
{ {
if ( P.size() != 4 ) if ( P.size() != 4 )
@ -1326,10 +1335,13 @@ SMDSAbs_ElementType Warping::GetType() const
} }
//================================================================================
/* /*
Class : Taper Class : Taper
Description : Functor for calculating taper Description : Functor for calculating taper
*/ */
//================================================================================
double Taper::GetValue( const TSequenceOfXYZ& P ) double Taper::GetValue( const TSequenceOfXYZ& P )
{ {
if ( P.size() != 4 ) if ( P.size() != 4 )
@ -1366,11 +1378,13 @@ SMDSAbs_ElementType Taper::GetType() const
return SMDSAbs_Face; return SMDSAbs_Face;
} }
//================================================================================
/* /*
Class : Skew Class : Skew
Description : Functor for calculating skew in degrees Description : Functor for calculating skew in degrees
*/ */
//================================================================================
static inline double skewAngle( const gp_XYZ& p1, const gp_XYZ& p2, const gp_XYZ& p3 ) static inline double skewAngle( const gp_XYZ& p1, const gp_XYZ& p2, const gp_XYZ& p3 )
{ {
gp_XYZ p12 = ( p2 + p1 ) / 2.; gp_XYZ p12 = ( p2 + p1 ) / 2.;
@ -1430,10 +1444,13 @@ SMDSAbs_ElementType Skew::GetType() const
} }
//================================================================================
/* /*
Class : Area Class : Area
Description : Functor for calculating area Description : Functor for calculating area
*/ */
//================================================================================
double Area::GetValue( const TSequenceOfXYZ& P ) double Area::GetValue( const TSequenceOfXYZ& P )
{ {
double val = 0.0; double val = 0.0;
@ -1463,11 +1480,13 @@ SMDSAbs_ElementType Area::GetType() const
return SMDSAbs_Face; return SMDSAbs_Face;
} }
//================================================================================
/* /*
Class : Length Class : Length
Description : Functor for calculating length of edge Description : Functor for calculating length of edge
*/ */
//================================================================================
double Length::GetValue( const TSequenceOfXYZ& P ) double Length::GetValue( const TSequenceOfXYZ& P )
{ {
switch ( P.size() ) { switch ( P.size() ) {
@ -1488,10 +1507,12 @@ SMDSAbs_ElementType Length::GetType() const
return SMDSAbs_Edge; return SMDSAbs_Edge;
} }
//================================================================================
/* /*
Class : Length2D Class : Length2D
Description : Functor for calculating length of edge Description : Functor for calculating length of edge
*/ */
//================================================================================
double Length2D::GetValue( long theElementId) double Length2D::GetValue( long theElementId)
{ {
@ -1799,10 +1820,13 @@ void Length2D::GetValues(TValues& theValues){
} }
} }
//================================================================================
/* /*
Class : MultiConnection Class : MultiConnection
Description : Functor for calculating number of faces conneted to the edge Description : Functor for calculating number of faces conneted to the edge
*/ */
//================================================================================
double MultiConnection::GetValue( const TSequenceOfXYZ& P ) double MultiConnection::GetValue( const TSequenceOfXYZ& P )
{ {
return 0; return 0;
@ -1823,10 +1847,13 @@ SMDSAbs_ElementType MultiConnection::GetType() const
return SMDSAbs_Edge; return SMDSAbs_Edge;
} }
//================================================================================
/* /*
Class : MultiConnection2D Class : MultiConnection2D
Description : Functor for calculating number of faces conneted to the edge Description : Functor for calculating number of faces conneted to the edge
*/ */
//================================================================================
double MultiConnection2D::GetValue( const TSequenceOfXYZ& P ) double MultiConnection2D::GetValue( const TSequenceOfXYZ& P )
{ {
return 0; return 0;
@ -1970,10 +1997,13 @@ void MultiConnection2D::GetValues(MValues& theValues){
} }
//================================================================================
/* /*
Class : BallDiameter Class : BallDiameter
Description : Functor returning diameter of a ball element Description : Functor returning diameter of a ball element
*/ */
//================================================================================
double BallDiameter::GetValue( long theId ) double BallDiameter::GetValue( long theId )
{ {
double diameter = 0; double diameter = 0;
@ -2002,10 +2032,12 @@ SMDSAbs_ElementType BallDiameter::GetType() const
PREDICATES PREDICATES
*/ */
//================================================================================
/* /*
Class : BadOrientedVolume Class : BadOrientedVolume
Description : Predicate bad oriented volumes Description : Predicate bad oriented volumes
*/ */
//================================================================================
BadOrientedVolume::BadOrientedVolume() BadOrientedVolume::BadOrientedVolume()
{ {
@ -2052,9 +2084,11 @@ bool BareBorderVolume::IsSatisfy(long theElementId )
return false; return false;
} }
//================================================================================
/* /*
Class : BareBorderFace Class : BareBorderFace
*/ */
//================================================================================
bool BareBorderFace::IsSatisfy(long theElementId ) bool BareBorderFace::IsSatisfy(long theElementId )
{ {
@ -2092,9 +2126,11 @@ bool BareBorderFace::IsSatisfy(long theElementId )
return ok; return ok;
} }
//================================================================================
/* /*
Class : OverConstrainedVolume Class : OverConstrainedVolume
*/ */
//================================================================================
bool OverConstrainedVolume::IsSatisfy(long theElementId ) bool OverConstrainedVolume::IsSatisfy(long theElementId )
{ {
@ -2112,9 +2148,11 @@ bool OverConstrainedVolume::IsSatisfy(long theElementId )
return false; return false;
} }
//================================================================================
/* /*
Class : OverConstrainedFace Class : OverConstrainedFace
*/ */
//================================================================================
bool OverConstrainedFace::IsSatisfy(long theElementId ) bool OverConstrainedFace::IsSatisfy(long theElementId )
{ {
@ -2145,10 +2183,12 @@ bool OverConstrainedFace::IsSatisfy(long theElementId )
return false; return false;
} }
//================================================================================
/* /*
Class : CoincidentNodes Class : CoincidentNodes
Description : Predicate of Coincident nodes Description : Predicate of Coincident nodes
*/ */
//================================================================================
CoincidentNodes::CoincidentNodes() CoincidentNodes::CoincidentNodes()
{ {
@ -2190,11 +2230,13 @@ void CoincidentNodes::SetMesh( const SMDS_Mesh* theMesh )
} }
} }
//================================================================================
/* /*
Class : CoincidentElements Class : CoincidentElements
Description : Predicate of Coincident Elements Description : Predicate of Coincident Elements
Note : This class is suitable only for visualization of Coincident Elements Note : This class is suitable only for visualization of Coincident Elements
*/ */
//================================================================================
CoincidentElements::CoincidentElements() CoincidentElements::CoincidentElements()
{ {
@ -2245,10 +2287,12 @@ SMDSAbs_ElementType CoincidentElements3D::GetType() const
} }
//================================================================================
/* /*
Class : FreeBorders Class : FreeBorders
Description : Predicate for free borders Description : Predicate for free borders
*/ */
//================================================================================
FreeBorders::FreeBorders() FreeBorders::FreeBorders()
{ {
@ -2271,10 +2315,13 @@ SMDSAbs_ElementType FreeBorders::GetType() const
} }
//================================================================================
/* /*
Class : FreeEdges Class : FreeEdges
Description : Predicate for free Edges Description : Predicate for free Edges
*/ */
//================================================================================
FreeEdges::FreeEdges() FreeEdges::FreeEdges()
{ {
myMesh = 0; myMesh = 0;
@ -2406,11 +2453,12 @@ void FreeEdges::GetBoreders(TBorders& theBorders)
} }
} }
//================================================================================
/* /*
Class : FreeNodes Class : FreeNodes
Description : Predicate for free nodes Description : Predicate for free nodes
*/ */
//================================================================================
FreeNodes::FreeNodes() FreeNodes::FreeNodes()
{ {
@ -2437,10 +2485,12 @@ SMDSAbs_ElementType FreeNodes::GetType() const
} }
//================================================================================
/* /*
Class : FreeFaces Class : FreeFaces
Description : Predicate for free faces Description : Predicate for free faces
*/ */
//================================================================================
FreeFaces::FreeFaces() FreeFaces::FreeFaces()
{ {
@ -2493,10 +2543,12 @@ SMDSAbs_ElementType FreeFaces::GetType() const
return SMDSAbs_Face; return SMDSAbs_Face;
} }
//================================================================================
/* /*
Class : LinearOrQuadratic Class : LinearOrQuadratic
Description : Predicate to verify whether a mesh element is linear Description : Predicate to verify whether a mesh element is linear
*/ */
//================================================================================
LinearOrQuadratic::LinearOrQuadratic() LinearOrQuadratic::LinearOrQuadratic()
{ {
@ -2527,10 +2579,12 @@ SMDSAbs_ElementType LinearOrQuadratic::GetType() const
return myType; return myType;
} }
//================================================================================
/* /*
Class : GroupColor Class : GroupColor
Description : Functor for check color of group to whic mesh element belongs to Description : Functor for check color of group to whic mesh element belongs to
*/ */
//================================================================================
GroupColor::GroupColor() GroupColor::GroupColor()
{ {
@ -2619,6 +2673,7 @@ void GroupColor::SetColorStr( const TCollection_AsciiString& theStr )
// Purpose : Get range as a string. // Purpose : Get range as a string.
// Example: "1,2,3,50-60,63,67,70-" // Example: "1,2,3,50-60,63,67,70-"
//======================================================================= //=======================================================================
void GroupColor::GetColorStr( TCollection_AsciiString& theResStr ) const void GroupColor::GetColorStr( TCollection_AsciiString& theResStr ) const
{ {
theResStr.Clear(); theResStr.Clear();
@ -2627,10 +2682,12 @@ void GroupColor::GetColorStr( TCollection_AsciiString& theResStr ) const
theResStr += TCollection_AsciiString( ";" ) + TCollection_AsciiString( myColor.Blue() ); theResStr += TCollection_AsciiString( ";" ) + TCollection_AsciiString( myColor.Blue() );
} }
//================================================================================
/* /*
Class : ElemGeomType Class : ElemGeomType
Description : Predicate to check element geometry type Description : Predicate to check element geometry type
*/ */
//================================================================================
ElemGeomType::ElemGeomType() ElemGeomType::ElemGeomType()
{ {
@ -2677,6 +2734,54 @@ SMDSAbs_GeometryType ElemGeomType::GetGeomType() const
return myGeomType; return myGeomType;
} }
//================================================================================
/*
Class : ElemEntityType
Description : Predicate to check element entity type
*/
//================================================================================
ElemEntityType::ElemEntityType():
myMesh( 0 ),
myType( SMDSAbs_All ),
myEntityType( SMDSEntity_0D )
{
}
void ElemEntityType::SetMesh( const SMDS_Mesh* theMesh )
{
myMesh = theMesh;
}
bool ElemEntityType::IsSatisfy( long theId )
{
if ( !myMesh ) return false;
const SMDS_MeshElement* anElem = myMesh->FindElement( theId );
return ( anElem &&
myEntityType == anElem->GetEntityType() &&
( myType == SMDSAbs_Edge || myType == SMDSAbs_Face || myType == SMDSAbs_Volume ));
}
void ElemEntityType::SetType( SMDSAbs_ElementType theType )
{
myType = theType;
}
SMDSAbs_ElementType ElemEntityType::GetType() const
{
return myType;
}
void ElemEntityType::SetElemEntityType( SMDSAbs_EntityType theEntityType )
{
myEntityType = theEntityType;
}
SMDSAbs_EntityType ElemEntityType::GetElemEntityType() const
{
return myEntityType;
}
//================================================================================ //================================================================================
/*! /*!
* \brief Class CoplanarFaces * \brief Class CoplanarFaces

23
src/Controls/SMESH_ControlsDef.hxx
View File

@ -245,7 +245,6 @@ namespace SMESH{
virtual SMDSAbs_ElementType GetType() const; virtual SMDSAbs_ElementType GetType() const;
}; };
/* /*
Class : Skew Class : Skew
Description : Functor for calculating skew in degrees Description : Functor for calculating skew in degrees
@ -429,6 +428,28 @@ namespace SMESH{
const SMDS_Mesh* myMesh; const SMDS_Mesh* myMesh;
}; };
/*
Class : ElemEntityType
Description : Functor for calculating entity type
*/
class SMESHCONTROLS_EXPORT ElemEntityType: public virtual Predicate{
public:
ElemEntityType();
virtual void SetMesh( const SMDS_Mesh* theMesh );
virtual bool IsSatisfy( long theElementId );
void SetType( SMDSAbs_ElementType theType );
virtual SMDSAbs_ElementType GetType() const;
void SetElemEntityType( SMDSAbs_EntityType theEntityType );
SMDSAbs_EntityType GetElemEntityType() const;
private:
const SMDS_Mesh* myMesh;
SMDSAbs_ElementType myType;
SMDSAbs_EntityType myEntityType;
};
typedef boost::shared_ptr<ElemEntityType> ElemEntityTypePtr;
/* /*
BareBorderVolume BareBorderVolume
*/ */

390
src/DriverGMF/DriverGMF_Read.cxx
View File

@ -29,6 +29,7 @@
#include "SMESHDS_Group.hxx" #include "SMESHDS_Group.hxx"
#include "SMESHDS_Mesh.hxx" #include "SMESHDS_Mesh.hxx"
#include "SMESH_Comment.hxx" #include "SMESH_Comment.hxx"
#include "SMESH_TypeDefs.hxx"
#include <Basics_Utils.hxx> #include <Basics_Utils.hxx>
@ -69,9 +70,11 @@ Driver_Mesh::Status DriverGMF_Read::Perform()
if ( !meshID ) if ( !meshID )
{ {
if ( DriverGMF::isExtensionCorrect( myFile )) if ( DriverGMF::isExtensionCorrect( myFile ))
return addMessage( SMESH_Comment("Can't open for reading ") << myFile, /*fatal=*/true ); return addMessage( SMESH_Comment("Can't open for reading ") << myFile,
/*fatal=*/true );
else else
return addMessage( SMESH_Comment("Not '.mesh' or '.meshb' extension of file ") << myFile, /*fatal=*/true ); return addMessage( SMESH_Comment("Not '.mesh' or '.meshb' extension of file ") << myFile,
/*fatal=*/true );
} }
DriverGMF::MeshCloser aMeshCloser( meshID ); // An object closing GMF mesh at destruction DriverGMF::MeshCloser aMeshCloser( meshID ); // An object closing GMF mesh at destruction
@ -109,34 +112,33 @@ Driver_Mesh::Status DriverGMF_Read::Perform()
int iN[28]; // 28 - nb nodes in HEX27 (+ 1 for safety :) int iN[28]; // 28 - nb nodes in HEX27 (+ 1 for safety :)
/* Read extra vertices for quadratic edges */
std::vector<int> quadNodesAtEdges;
int nbQuadEdges = 0;
if ( (nbQuadEdges = GmfStatKwd(meshID, GmfExtraVerticesAtEdges)) )
{
quadNodesAtEdges.reserve( nbQuadEdges );
GmfGotoKwd(meshID, GmfExtraVerticesAtEdges);
for ( int i = 1; i <= nbQuadEdges; ++i )
{
GmfGetLin(meshID, GmfExtraVerticesAtEdges, &iN[0], &iN[1], &iN[2]);
quadNodesAtEdges.push_back(iN[2]);
}
}
/* Read edges */ /* Read edges */
const int edgeIDShift = myMesh->GetMeshInfo().NbElements(); const int edgeIDShift = myMesh->GetMeshInfo().NbElements();
if ( int nbEdges = GmfStatKwd(meshID, GmfEdges)) if ( int nbEdges = GmfStatKwd(meshID, GmfEdges))
{ {
const bool readQuadNodes = ( nbQuadEdges == nbEdges ); // read extra vertices for quadratic edges
std::vector<int> quadNodesAtEdges( nbEdges + 1, -1 );
if ( int nbQuadEdges = GmfStatKwd(meshID, GmfExtraVerticesAtEdges))
{
GmfGotoKwd(meshID, GmfExtraVerticesAtEdges);
for ( int i = 1; i <= nbQuadEdges; ++i )
{
GmfGetLin(meshID, GmfExtraVerticesAtEdges, &iN[0], &iN[1], &iN[2]);
if ( iN[1] >= 1 )
quadNodesAtEdges[ iN[0] ] = iN[2];
}
}
// create edges
GmfGotoKwd(meshID, GmfEdges); GmfGotoKwd(meshID, GmfEdges);
for ( int i = 1; i <= nbEdges; ++i ) for ( int i = 1; i <= nbEdges; ++i )
{ {
GmfGetLin(meshID, GmfEdges, &iN[0], &iN[1], &ref); GmfGetLin(meshID, GmfEdges, &iN[0], &iN[1], &ref);
if ( readQuadNodes ) const int midN = quadNodesAtEdges[ i ];
if ( midN > 0 )
{ {
const int midN = quadNodesAtEdges[i-1];
if ( !myMesh->AddEdgeWithID( iN[0], iN[1], midN, edgeIDShift + i )) if ( !myMesh->AddEdgeWithID( iN[0], iN[1], midN, edgeIDShift + i ))
status = storeBadNodeIds( "GmfEdges + GmfExtraVerticesAtEdges",i, 3, iN[0],iN[1],midN); status = storeBadNodeIds( "GmfEdges + GmfExtraVerticesAtEdges",i,
3, iN[0], iN[1], midN);
} }
else else
{ {
@ -145,47 +147,40 @@ Driver_Mesh::Status DriverGMF_Read::Perform()
} }
} }
} }
// the vector of extra vertices at edges won't be used anymore so it is cleared
quadNodesAtEdges.clear();
/* Read extra vertices for quadratic triangles */
std::vector< std::vector<int> > quadNodesAtTriangles;
int nbQuadTria = 0;
if ( (nbQuadTria = GmfStatKwd(meshID, GmfExtraVerticesAtTriangles)) )
{
GmfGotoKwd(meshID, GmfExtraVerticesAtTriangles);
quadNodesAtTriangles.reserve( nbQuadTria );
std::vector<int> nodes(4);
for ( int i = 1; i <= nbQuadTria; ++i )
{
GmfGetLin(meshID, GmfExtraVerticesAtTriangles,
&iN[0], &iN[1], &iN[2], &iN[3], &iN[4],
&iN[5]); // iN[5] - preview TRIA7
nodes.clear();
nodes.push_back(iN[2]);
nodes.push_back(iN[3]);
nodes.push_back(iN[4]);
nodes.push_back(iN[5]);
nodes.resize( iN[1] );
quadNodesAtTriangles.push_back(nodes);
}
}
/* Read triangles */ /* Read triangles */
const int triaIDShift = myMesh->GetMeshInfo().NbElements(); const int triaIDShift = myMesh->GetMeshInfo().NbElements();
if ( int nbTria = GmfStatKwd(meshID, GmfTriangles)) if ( int nbTria = GmfStatKwd(meshID, GmfTriangles))
{ {
const bool readQuadNodes = (nbQuadTria == nbTria); // read extra vertices for quadratic triangles
std::vector< std::vector<int> > quadNodesAtTriangles( nbTria + 1 );
if ( int nbQuadTria = GmfStatKwd(meshID, GmfExtraVerticesAtTriangles ))
{
GmfGotoKwd( meshID, GmfExtraVerticesAtTriangles );
for ( int i = 1; i <= nbQuadTria; ++i )
{
GmfGetLin(meshID, GmfExtraVerticesAtTriangles,
&iN[0], &iN[1], &iN[2], &iN[3], &iN[4],
&iN[5]); // iN[5] - preview TRIA7
if ( iN[0] <= nbTria )
{
std::vector<int>& nodes = quadNodesAtTriangles[ iN[0] ];
nodes.insert( nodes.end(), & iN[2], & iN[5+1] );
nodes.resize( iN[1] );
}
}
}
// create triangles
GmfGotoKwd(meshID, GmfTriangles); GmfGotoKwd(meshID, GmfTriangles);
for ( int i = 1; i <= nbTria; ++i ) for ( int i = 1; i <= nbTria; ++i )
{ {
GmfGetLin(meshID, GmfTriangles, &iN[0], &iN[1], &iN[2], &ref); GmfGetLin(meshID, GmfTriangles, &iN[0], &iN[1], &iN[2], &ref);
if ( readQuadNodes ) std::vector<int>& midN = quadNodesAtTriangles[ i ];
if ( midN.size() >= 3 )
{ {
const std::vector<int>& midN = quadNodesAtTriangles[ i-1 ]; if ( !myMesh->AddFaceWithID( iN[0],iN[1],iN[2], midN[0],midN[1],midN[2],
if ( !myMesh->AddFaceWithID( iN[0],iN[1],iN[2], midN[0],midN[1],midN[2], triaIDShift + i )) triaIDShift + i ))
status = storeBadNodeIds( "GmfTriangles + GmfExtraVerticesAtTriangles",i, 6, status = storeBadNodeIds( "GmfTriangles + GmfExtraVerticesAtTriangles",i, 6,
iN[0],iN[1],iN[2], midN[0],midN[1],midN[2] ); iN[0],iN[1],iN[2], midN[0],midN[1],midN[2] );
} }
else else
@ -193,127 +188,108 @@ Driver_Mesh::Status DriverGMF_Read::Perform()
if ( !myMesh->AddFaceWithID( iN[0], iN[1], iN[2], triaIDShift + i )) if ( !myMesh->AddFaceWithID( iN[0], iN[1], iN[2], triaIDShift + i ))
status = storeBadNodeIds( "GmfTriangles",i, 3, iN[0], iN[1], iN[2] ); status = storeBadNodeIds( "GmfTriangles",i, 3, iN[0], iN[1], iN[2] );
} }
} if ( !midN.empty() ) SMESHUtils::FreeVector( midN );
}
// the vector of extra vertices at triangles won't be used anymore so it is cleared
quadNodesAtTriangles.clear();
/* Read extra vertices for quadratic quadrangles */
std::vector< std::vector<int> > quadNodesAtQuadrilaterals;
int nbQuadQuad = 0;
if ( (nbQuadQuad = GmfStatKwd(meshID, GmfExtraVerticesAtQuadrilaterals)) )
{
GmfGotoKwd(meshID, GmfExtraVerticesAtQuadrilaterals);
quadNodesAtQuadrilaterals.reserve( nbQuadQuad );
std::vector<int> nodes( 5 );
for ( int i = 1; i <= nbQuadQuad; ++i )
{
GmfGetLin(meshID, GmfExtraVerticesAtQuadrilaterals,
&iN[0], &iN[1], &iN[2], &iN[3], &iN[4], &iN[5], &iN[6]);
nodes.clear();
nodes.push_back(iN[2]);
nodes.push_back(iN[3]);
nodes.push_back(iN[4]);
nodes.push_back(iN[5]);
nodes.push_back(iN[6]);
nodes.resize( iN[1] );
quadNodesAtQuadrilaterals.push_back(nodes);
} }
} }
/* Read quadrangles */ /* Read quadrangles */
const int quadIDShift = myMesh->GetMeshInfo().NbElements(); const int quadIDShift = myMesh->GetMeshInfo().NbElements();
if ( int nbQuad = GmfStatKwd(meshID, GmfQuadrilaterals)) if ( int nbQuad = GmfStatKwd(meshID, GmfQuadrilaterals))
{ {
const bool readQuadNodes = (nbQuadQuad == nbQuad); // read extra vertices for quadratic quadrangles
std::vector< std::vector<int> > quadNodesAtQuadrilaterals( nbQuad + 1 );
if ( int nbQuadQuad = GmfStatKwd( meshID, GmfExtraVerticesAtQuadrilaterals ))
{
GmfGotoKwd(meshID, GmfExtraVerticesAtQuadrilaterals);
for ( int i = 1; i <= nbQuadQuad; ++i )
{
GmfGetLin(meshID, GmfExtraVerticesAtQuadrilaterals,
&iN[0], &iN[1], &iN[2], &iN[3], &iN[4], &iN[5], &iN[6]);
if ( iN[0] <= nbQuad )
{
std::vector<int>& nodes = quadNodesAtQuadrilaterals[ iN[0] ];
nodes.insert( nodes.end(), & iN[2], & iN[6+1] );
nodes.resize( iN[1] );
}
}
}
// create quadrangles
GmfGotoKwd(meshID, GmfQuadrilaterals); GmfGotoKwd(meshID, GmfQuadrilaterals);
for ( int i = 1; i <= nbQuad; ++i ) for ( int i = 1; i <= nbQuad; ++i )
{ {
GmfGetLin(meshID, GmfQuadrilaterals, &iN[0], &iN[1], &iN[2], &iN[3], &ref); GmfGetLin(meshID, GmfQuadrilaterals, &iN[0], &iN[1], &iN[2], &iN[3], &ref);
if ( readQuadNodes ) std::vector<int>& midN = quadNodesAtQuadrilaterals[ i ];
if ( midN.size() == 8-4 ) // QUAD8
{ {
const std::vector<int>& midN = quadNodesAtQuadrilaterals[ i-1 ]; if ( !myMesh->AddFaceWithID( iN[0], iN[1], iN[2], iN[3],
if ( midN.size() == 4 ) midN[0], midN[1], midN[2], midN[3],
{ quadIDShift + i ))
if ( !myMesh->AddFaceWithID( iN[0], iN[1], iN[2], iN[3], status = storeBadNodeIds( "GmfQuadrilaterals + GmfExtraVerticesAtQuadrilaterals",i, 8,
midN[0], midN[1], midN[2], midN[3], iN[0], iN[1],iN[2], iN[3],
quadIDShift + i )) midN[0], midN[1], midN[2], midN[3]);
status = storeBadNodeIds( "GmfQuadrilaterals + GmfExtraVerticesAtQuadrilaterals",i, 8,
iN[0], iN[1],iN[2], iN[3],
midN[0], midN[1], midN[2], midN[3]);
}
else
{
if ( !myMesh->AddFaceWithID( iN[0], iN[1], iN[2], iN[3],
midN[0], midN[1], midN[2], midN[3], midN[4],
quadIDShift + i ))
status = storeBadNodeIds( "GmfQuadrilaterals + GmfExtraVerticesAtQuadrilaterals",i, 9,
iN[0], iN[1],iN[2], iN[3],
midN[0], midN[1], midN[2], midN[3], midN[4]);
}
} }
else else if ( midN.size() > 8-4 ) // QUAD9
{
if ( !myMesh->AddFaceWithID( iN[0], iN[1], iN[2], iN[3],
midN[0], midN[1], midN[2], midN[3], midN[4],
quadIDShift + i ))
status = storeBadNodeIds( "GmfQuadrilaterals + GmfExtraVerticesAtQuadrilaterals",i, 9,
iN[0], iN[1],iN[2], iN[3],
midN[0], midN[1], midN[2], midN[3], midN[4]);
}
else // QUAD4
{ {
if ( !myMesh->AddFaceWithID( iN[0], iN[1], iN[2], iN[3], quadIDShift + i )) if ( !myMesh->AddFaceWithID( iN[0], iN[1], iN[2], iN[3], quadIDShift + i ))
status = storeBadNodeIds( "GmfQuadrilaterals",i, 4, iN[0], iN[1],iN[2], iN[3] ); status = storeBadNodeIds( "GmfQuadrilaterals",i, 4, iN[0], iN[1],iN[2], iN[3] );
} }
if ( !midN.empty() ) SMESHUtils::FreeVector( midN );
} }
} }
// the vector of extra vertices at quadrilaterals won't be used anymore so it is cleared
quadNodesAtQuadrilaterals.clear();
/* Read extra vertices for quadratic tetrahedra */
std::vector< std::vector<int> > quadNodesAtTetrahedra;
int nbQuadTetra = 0;
if ( (nbQuadTetra = GmfStatKwd(meshID, GmfExtraVerticesAtTetrahedra)) )
{
GmfGotoKwd(meshID, GmfExtraVerticesAtTetrahedra);
quadNodesAtTetrahedra.reserve( nbQuadTetra );
std::vector<int> nodes( 6 );
for ( int i = 1; i <= nbQuadTetra; ++i )
{
GmfGetLin(meshID, GmfExtraVerticesAtTetrahedra,
&iN[0], &iN[1], &iN[2], &iN[3], &iN[4], &iN[5], &iN[6], &iN[7]);
nodes.clear();
nodes.push_back(iN[2]);
nodes.push_back(iN[3]);
nodes.push_back(iN[4]);
nodes.push_back(iN[5]);
nodes.push_back(iN[6]);
nodes.push_back(iN[7]);
nodes.resize( iN[1] );
quadNodesAtTetrahedra.push_back(nodes);
}
}
/* Read terahedra */ /* Read terahedra */
const int tetIDShift = myMesh->GetMeshInfo().NbElements(); const int tetIDShift = myMesh->GetMeshInfo().NbElements();
if ( int nbTet = GmfStatKwd(meshID, GmfTetrahedra)) if ( int nbTet = GmfStatKwd( meshID, GmfTetrahedra ))
{ {
const bool readQuadNodes = (nbQuadTetra == nbTet); // read extra vertices for quadratic tetrahedra
std::vector< std::vector<int> > quadNodesAtTetrahedra( nbTet + 1 );
if ( int nbQuadTetra = GmfStatKwd( meshID, GmfExtraVerticesAtTetrahedra ))
{
GmfGotoKwd(meshID, GmfExtraVerticesAtTetrahedra);
for ( int i = 1; i <= nbQuadTetra; ++i )
{
GmfGetLin(meshID, GmfExtraVerticesAtTetrahedra,
&iN[0], &iN[1], &iN[2], &iN[3], &iN[4], &iN[5], &iN[6], &iN[7]);
if ( iN[0] <= nbTet )
{
std::vector<int>& nodes = quadNodesAtTetrahedra[ iN[0] ];
nodes.insert( nodes.end(), & iN[2], & iN[7+1] );
nodes.resize( iN[1] );
}
}
}
// create tetrahedra
GmfGotoKwd(meshID, GmfTetrahedra); GmfGotoKwd(meshID, GmfTetrahedra);
for ( int i = 1; i <= nbTet; ++i ) for ( int i = 1; i <= nbTet; ++i )
{ {
GmfGetLin(meshID, GmfTetrahedra, &iN[0], &iN[1], &iN[2], &iN[3], &ref); GmfGetLin(meshID, GmfTetrahedra, &iN[0], &iN[1], &iN[2], &iN[3], &ref);
if ( readQuadNodes ) std::vector<int>& midN = quadNodesAtTetrahedra[ i ];
if ( midN.size() >= 10-4 ) // TETRA10
{ {
const std::vector<int>& midN = quadNodesAtTetrahedra[ i-1 ];
if ( !myMesh->AddVolumeWithID( iN[0], iN[2], iN[1], iN[3], if ( !myMesh->AddVolumeWithID( iN[0], iN[2], iN[1], iN[3],
midN[2], midN[1], midN[0], midN[3], midN[5], midN[4], tetIDShift + i )) midN[2], midN[1], midN[0], midN[3], midN[5], midN[4],
status = storeBadNodeIds( "GmfTetrahedra + GmfExtraVerticesAtTetrahedra",i, 10, iN[0], iN[2], iN[1], iN[3], tetIDShift + i ))
midN[2], midN[1], midN[0], midN[3], midN[5], midN[4] ); status = storeBadNodeIds( "GmfTetrahedra + GmfExtraVerticesAtTetrahedra",i, 10,
iN[0], iN[2], iN[1], iN[3],
midN[2], midN[1], midN[0], midN[3], midN[5], midN[4] );
} }
else else // TETRA4
{ {
if ( !myMesh->AddVolumeWithID( iN[0], iN[2], iN[1], iN[3], tetIDShift + i ) ) if ( !myMesh->AddVolumeWithID( iN[0], iN[2], iN[1], iN[3], tetIDShift + i ))
status = storeBadNodeIds( "GmfTetrahedra" ,i, 4, iN[0], iN[2], iN[1], iN[3] ); status = storeBadNodeIds( "GmfTetrahedra" ,i, 4, iN[0], iN[2], iN[1], iN[3] );
} }
if ( !midN.empty() ) SMESHUtils::FreeVector( midN );
} }
} }
// the vector of extra vertices at tetrahedra won't be used anymore so it is cleared
quadNodesAtTetrahedra.clear();
/* Read pyramids */ /* Read pyramids */
const int pyrIDShift = myMesh->GetMeshInfo().NbElements(); const int pyrIDShift = myMesh->GetMeshInfo().NbElements();
@ -328,92 +304,58 @@ Driver_Mesh::Status DriverGMF_Read::Perform()
} }
} }
/* Read extra vertices for quadratic hexahedra */
std::vector< std::vector<int> > quadNodesAtHexahedra;
int nbQuadHexa = 0;
if ( (nbQuadHexa = GmfStatKwd(meshID, GmfExtraVerticesAtHexahedra)) )
{
GmfGotoKwd(meshID, GmfExtraVerticesAtHexahedra);
quadNodesAtHexahedra.reserve( nbQuadHexa );
std::vector<int> nodes( 19 );
for ( int i = 1; i <= nbQuadHexa; ++i )
{
GmfGetLin(meshID, GmfExtraVerticesAtHexahedra, &iN[0], &iN[1], // Hexa Id, Nb of extra vertices
&iN[2], &iN[3], &iN[4], &iN[5],
&iN[6], &iN[7], &iN[8], &iN[9],
&iN[10], &iN[11], &iN[12], &iN[13], // HEXA20
&iN[14],
&iN[15], &iN[16], &iN[17], &iN[18],
&iN[19],
&iN[20]); // HEXA27
nodes.clear();
nodes.push_back(iN[2]);
nodes.push_back(iN[3]);
nodes.push_back(iN[4]);
nodes.push_back(iN[5]);
nodes.push_back(iN[6]);
nodes.push_back(iN[7]);
nodes.push_back(iN[8]);
nodes.push_back(iN[9]);
nodes.push_back(iN[10]);
nodes.push_back(iN[11]);
nodes.push_back(iN[12]);
nodes.push_back(iN[13]);
nodes.push_back(iN[14]);
nodes.push_back(iN[15]);
nodes.push_back(iN[16]);
nodes.push_back(iN[17]);
nodes.push_back(iN[18]);
nodes.push_back(iN[19]);
nodes.push_back(iN[20]);
nodes.resize( iN[1] );
quadNodesAtHexahedra.push_back(nodes);
}
}
/* Read hexahedra */ /* Read hexahedra */
const int hexIDShift = myMesh->GetMeshInfo().NbElements(); const int hexIDShift = myMesh->GetMeshInfo().NbElements();
if ( int nbHex = GmfStatKwd(meshID, GmfHexahedra)) if ( int nbHex = GmfStatKwd(meshID, GmfHexahedra))
{ {
const bool readQuadNodes = (nbQuadHexa == nbHex); // read extra vertices for quadratic hexahedra
std::vector< std::vector<int> > quadNodesAtHexahedra( nbHex + 1 );
if ( int nbQuadHexa = GmfStatKwd( meshID, GmfExtraVerticesAtHexahedra ))
{
GmfGotoKwd(meshID, GmfExtraVerticesAtHexahedra);
for ( int i = 1; i <= nbQuadHexa; ++i )
{
GmfGetLin(meshID, GmfExtraVerticesAtHexahedra, &iN[0], &iN[1], // Hexa Id, Nb extra vertices
&iN[2], &iN[3], &iN[4], &iN[5],
&iN[6], &iN[7], &iN[8], &iN[9],
&iN[10], &iN[11], &iN[12], &iN[13], // HEXA20
&iN[14],
&iN[15], &iN[16], &iN[17], &iN[18],
&iN[19],
&iN[20]); // HEXA27
if ( iN[0] <= nbHex )
{
std::vector<int>& nodes = quadNodesAtHexahedra[ iN[0] ];
nodes.insert( nodes.end(), & iN[2], & iN[20+1] );
nodes.resize( iN[1] );
}
}
}
// create hexhedra
GmfGotoKwd(meshID, GmfHexahedra); GmfGotoKwd(meshID, GmfHexahedra);
for ( int i = 1; i <= nbHex; ++i ) for ( int i = 1; i <= nbHex; ++i )
{ {
GmfGetLin(meshID, GmfHexahedra, &iN[0], &iN[1], &iN[2], &iN[3], GmfGetLin(meshID, GmfHexahedra, &iN[0], &iN[1], &iN[2], &iN[3],
&iN[4], &iN[5], &iN[6], &iN[7],&ref); &iN[4], &iN[5], &iN[6], &iN[7], &ref);
if ( readQuadNodes ) std::vector<int>& midN = quadNodesAtHexahedra[ i ];
if ( midN.size() == 20-8 ) // HEXA20
{ {
const std::vector<int>& midN = quadNodesAtHexahedra[ i-1 ]; if ( !myMesh->AddVolumeWithID( iN[0], iN[3], iN[2], iN[1],
if ( midN.size() == 12 ) // HEXA20
{
if ( !myMesh->AddVolumeWithID( iN[0], iN[3], iN[2], iN[1],
iN[4], iN[7], iN[6], iN[5],
midN[3], midN[2], midN[1], midN[0],
midN[7], midN[6], midN[5], midN[4],
midN[8], midN[11], midN[10], midN[9],
tetIDShift + i ))
status = storeBadNodeIds( "GmfHexahedra + GmfExtraVerticesAtHexahedra",i, 20,
iN[0], iN[3], iN[2], iN[1],
iN[4], iN[7], iN[6], iN[5], iN[4], iN[7], iN[6], iN[5],
midN[3], midN[2], midN[1], midN[0], midN[3], midN[2], midN[1], midN[0],
midN[7], midN[6], midN[5], midN[4], midN[7], midN[6], midN[5], midN[4],
midN[8], midN[11], midN[10], midN[9]); midN[8], midN[11], midN[10], midN[9],
} hexIDShift + i ))
else // HEXA27 status = storeBadNodeIds( "GmfHexahedra + GmfExtraVerticesAtHexahedra",i, 20,
{ iN[0], iN[3], iN[2], iN[1],
if ( !myMesh->AddVolumeWithID( iN[0], iN[3], iN[2], iN[1], iN[4], iN[7], iN[6], iN[5],
iN[4], iN[7], iN[6], iN[5], midN[3], midN[2], midN[1], midN[0],
midN[3], midN[2], midN[1], midN[0], midN[7], midN[6], midN[5], midN[4],
midN[7], midN[6], midN[5], midN[4], midN[8], midN[11], midN[10], midN[9]);
midN[8], midN[11], midN[10], midN[9], }
midN[12], else if ( midN.size() >= 27-8 ) // HEXA27
midN[16], midN[15], midN[14], midN[13], {
midN[17], if ( !myMesh->AddVolumeWithID( iN[0], iN[3], iN[2], iN[1],
midN[18],
tetIDShift + i ))
status = storeBadNodeIds( "GmfHexahedra + GmfExtraVerticesAtHexahedra",i, 27,
iN[0], iN[3], iN[2], iN[1],
iN[4], iN[7], iN[6], iN[5], iN[4], iN[7], iN[6], iN[5],
midN[3], midN[2], midN[1], midN[0], midN[3], midN[2], midN[1], midN[0],
midN[7], midN[6], midN[5], midN[4], midN[7], midN[6], midN[5], midN[4],
@ -421,20 +363,29 @@ Driver_Mesh::Status DriverGMF_Read::Perform()
midN[12], midN[12],
midN[16], midN[15], midN[14], midN[13], midN[16], midN[15], midN[14], midN[13],
midN[17], midN[17],
midN[18]); midN[18],
} hexIDShift + i ))
status = storeBadNodeIds( "GmfHexahedra + GmfExtraVerticesAtHexahedra",i, 27,
iN[0], iN[3], iN[2], iN[1],
iN[4], iN[7], iN[6], iN[5],
midN[3], midN[2], midN[1], midN[0],
midN[7], midN[6], midN[5], midN[4],
midN[8], midN[11], midN[10], midN[9],
midN[12],
midN[16], midN[15], midN[14], midN[13],
midN[17],
midN[18]);
} }
else else // HEXA8
{ {
if ( !myMesh->AddVolumeWithID( iN[0], iN[3], iN[2], iN[1], if ( !myMesh->AddVolumeWithID( iN[0], iN[3], iN[2], iN[1],
iN[4], iN[7], iN[6], iN[5], hexIDShift + i ) ) iN[4], iN[7], iN[6], iN[5], hexIDShift + i ) )
status = storeBadNodeIds( "GmfHexahedra" ,i, 8, iN[0], iN[3], iN[2], iN[1], status = storeBadNodeIds( "GmfHexahedra" ,i, 8, iN[0], iN[3], iN[2], iN[1],
iN[4], iN[7], iN[6], iN[5] ); iN[4], iN[7], iN[6], iN[5] );
} }
if ( !midN.empty() ) SMESHUtils::FreeVector( midN );
} }
} }
// the vector of extra vertices at tetrahedra won't be used anymore so it is cleared
quadNodesAtHexahedra.clear();
/* Read prism */ /* Read prism */
const int prismIDShift = myMesh->GetMeshInfo().NbElements(); const int prismIDShift = myMesh->GetMeshInfo().NbElements();
@ -443,8 +394,7 @@ Driver_Mesh::Status DriverGMF_Read::Perform()
GmfGotoKwd(meshID, GmfPrisms); GmfGotoKwd(meshID, GmfPrisms);
for ( int i = 1; i <= nbPrism; ++i ) for ( int i = 1; i <= nbPrism; ++i )
{ {
GmfGetLin(meshID, GmfPrisms, GmfGetLin(meshID, GmfPrisms, &iN[0], &iN[1], &iN[2], &iN[3], &iN[4], &iN[5], &ref);
&iN[0], &iN[1], &iN[2], &iN[3], &iN[4], &iN[5], &ref);
if ( !myMesh->AddVolumeWithID( iN[0], iN[2], iN[1], iN[3], iN[5], iN[4], prismIDShift + i)) if ( !myMesh->AddVolumeWithID( iN[0], iN[2], iN[1], iN[3], iN[5], iN[4], prismIDShift + i))
status = storeBadNodeIds( "GmfPrisms",i, status = storeBadNodeIds( "GmfPrisms",i,
6, iN[0], iN[1],iN[2], iN[3], iN[4], iN[5] ); 6, iN[0], iN[1],iN[2], iN[3], iN[4], iN[5] );

185
src/DriverGMF/DriverGMF_Write.cxx
View File

@ -40,37 +40,42 @@ extern "C"
#include <vector> #include <vector>
#define BEGIN_ELEM_WRITE( SMDSEntity, GmfKwd, elem ) \ #define BEGIN_ELEM_WRITE( SMDSEntity, GmfKwd, elem ) \
elemIt = myMesh->elementEntityIterator( SMDSEntity ); \ elemIt = elementIterator( SMDSEntity ); \
if ( elemIt->more() ) \ if ( elemIt->more() ) \
{ \ { \
GmfSetKwd(meshID, GmfKwd, myMesh->GetMeshInfo().NbEntities( SMDSEntity )); \ GmfSetKwd(meshID, GmfKwd, myMesh->GetMeshInfo().NbElements( SMDSEntity )); \
for ( int gmfID = 1; elemIt->more(); ++gmfID ) \ for ( int gmfID = 1; elemIt->more(); ++gmfID ) \
{ \ { \
const SMDS_MeshElement* elem = elemIt->next(); \ const SMDS_MeshElement* elem = elemIt->next(); \
GmfSetLin(meshID, GmfKwd, GmfSetLin(meshID, GmfKwd,
#define BEGIN_EXTRA_VERTICES_WRITE( SMDSEntity, GmfKwd, elem, nbVertices ) \ #define BEGIN_EXTRA_VERTICES_WRITE( SMDSGeom, LinType, GmfKwd, elem ) \
elemIt = myMesh->elementEntityIterator( SMDSEntity ); \ elemIt = elementIterator( SMDSGeom ); \
if ( elemIt->more() ) \ if ( elemIt->more() ) \
{ \ { \
GmfSetKwd(meshID, GmfKwd, myMesh->GetMeshInfo().NbEntities( SMDSEntity )); \ int totalNbElems = myMesh->GetMeshInfo().NbElements( SMDSGeom ); \
int nbLinearElems = myMesh->GetMeshInfo().NbElements( LinType ); \
if ( totalNbElems - nbLinearElems > 0 ) \
{ \
GmfSetKwd(meshID, GmfKwd, totalNbElems - nbLinearElems); \
for ( int gmfID = 1; elemIt->more(); ++gmfID ) \ for ( int gmfID = 1; elemIt->more(); ++gmfID ) \
{ \ { \
const SMDS_MeshElement* elem = elemIt->next(); \ const SMDS_MeshElement* elem = elemIt->next(); \
GmfSetLin(meshID, GmfKwd, gmfID, nbVertices, if ( elem->IsQuadratic() ) { \
GmfSetLin(meshID, GmfKwd, gmfID, elem->NbNodes() - elem->NbCornerNodes(),
#define END_ELEM_WRITE( elem ) \ #define END_ELEM_WRITE( elem ) \
elem->getshapeId() ); \ elem->getshapeId() ); \
}} \ }}
#define END_ELEM_WRITE_ADD_TO_MAP( elem, e2id ) \ #define END_ELEM_WRITE_ADD_TO_MAP( elem, e2id ) \
elem->getshapeId() ); \ elem->getshapeId() ); \
e2id.insert( e2id.end(), make_pair( elem, gmfID )); \ e2id.insert( e2id.end(), make_pair( elem, gmfID )); \
}} \ }}
#define END_EXTRA_VERTICES_WRITE() \ #define END_EXTRA_VERTICES_WRITE() \
); \ ); \
}} \ }}}}
DriverGMF_Write::DriverGMF_Write(): DriverGMF_Write::DriverGMF_Write():
@ -126,107 +131,73 @@ Driver_Mesh::Status DriverGMF_Write::Perform()
// edges // edges
TElem2IDMap edge2IDMap; TElem2IDMap edge2IDMap;
BEGIN_ELEM_WRITE( SMDSEntity_Edge, GmfEdges, edge ) BEGIN_ELEM_WRITE( SMDSGeom_EDGE, GmfEdges, edge )
node2IdMap[ edge->GetNode( 0 )], node2IdMap[ edge->GetNode( 0 )],
node2IdMap[ edge->GetNode( 1 )], node2IdMap[ edge->GetNode( 1 )],
END_ELEM_WRITE_ADD_TO_MAP( edge, edge2IDMap ); END_ELEM_WRITE_ADD_TO_MAP( edge, edge2IDMap );
// quadratic edges // nodes of quadratic edges
BEGIN_ELEM_WRITE( SMDSEntity_Quad_Edge, GmfEdges, edge ) BEGIN_EXTRA_VERTICES_WRITE( SMDSGeom_EDGE, SMDSEntity_Edge,
node2IdMap[ edge->GetNode( 0 )], GmfExtraVerticesAtEdges, edge )
node2IdMap[ edge->GetNode( 1 )],
END_ELEM_WRITE( edge );
BEGIN_EXTRA_VERTICES_WRITE( SMDSEntity_Quad_Edge, GmfExtraVerticesAtEdges, edge, 1 )
node2IdMap[ edge->GetNode( 2 )] node2IdMap[ edge->GetNode( 2 )]
END_EXTRA_VERTICES_WRITE(); END_EXTRA_VERTICES_WRITE();
// triangles // triangles
TElem2IDMap tria2IDMap; TElem2IDMap tria2IDMap;
BEGIN_ELEM_WRITE( SMDSEntity_Triangle, GmfTriangles, tria ) BEGIN_ELEM_WRITE( SMDSGeom_TRIANGLE, GmfTriangles, tria )
node2IdMap[ tria->GetNode( 0 )], node2IdMap[ tria->GetNode( 0 )],
node2IdMap[ tria->GetNode( 1 )], node2IdMap[ tria->GetNode( 1 )],
node2IdMap[ tria->GetNode( 2 )], node2IdMap[ tria->GetNode( 2 )],
END_ELEM_WRITE_ADD_TO_MAP( tria, tria2IDMap ); END_ELEM_WRITE_ADD_TO_MAP( tria, tria2IDMap );
// quadratic triangles // nodes of quadratic triangles
BEGIN_ELEM_WRITE( SMDSEntity_Quad_Triangle, GmfTriangles, tria ) BEGIN_EXTRA_VERTICES_WRITE( SMDSGeom_TRIANGLE, SMDSEntity_Triangle,
node2IdMap[ tria->GetNode( 0 )], GmfExtraVerticesAtTriangles, tria )
node2IdMap[ tria->GetNode( 1 )],
node2IdMap[ tria->GetNode( 2 )],
END_ELEM_WRITE( tria );
BEGIN_EXTRA_VERTICES_WRITE( SMDSEntity_Quad_Triangle, GmfExtraVerticesAtTriangles, tria, 3 )
node2IdMap[ tria->GetNode( 3 )], node2IdMap[ tria->GetNode( 3 )],
node2IdMap[ tria->GetNode( 4 )], node2IdMap[ tria->GetNode( 4 )],
node2IdMap[ tria->GetNode( 5 )] node2IdMap[ tria->GetNode( 5 )]
//node2IdMap[ tria->GetNodeWrap( 6 )] // for TRIA7
END_EXTRA_VERTICES_WRITE(); END_EXTRA_VERTICES_WRITE();
// quadrangles // quadrangles
TElem2IDMap quad2IDMap; TElem2IDMap quad2IDMap;
BEGIN_ELEM_WRITE( SMDSEntity_Quadrangle, GmfQuadrilaterals, quad ) BEGIN_ELEM_WRITE( SMDSGeom_QUADRANGLE, GmfQuadrilaterals, quad )
node2IdMap[ quad->GetNode( 0 )], node2IdMap[ quad->GetNode( 0 )],
node2IdMap[ quad->GetNode( 1 )], node2IdMap[ quad->GetNode( 1 )],
node2IdMap[ quad->GetNode( 2 )], node2IdMap[ quad->GetNode( 2 )],
node2IdMap[ quad->GetNode( 3 )], node2IdMap[ quad->GetNode( 3 )],
END_ELEM_WRITE_ADD_TO_MAP( quad, quad2IDMap ); END_ELEM_WRITE_ADD_TO_MAP( quad, quad2IDMap );
// quadratic quadrangles // nodes of quadratic quadrangles
BEGIN_ELEM_WRITE( SMDSEntity_Quad_Quadrangle, GmfQuadrilaterals, quad ) BEGIN_EXTRA_VERTICES_WRITE( SMDSGeom_QUADRANGLE, SMDSEntity_Quadrangle,
node2IdMap[ quad->GetNode( 0 )], GmfExtraVerticesAtQuadrilaterals, quad )
node2IdMap[ quad->GetNode( 1 )],
node2IdMap[ quad->GetNode( 2 )],
node2IdMap[ quad->GetNode( 3 )],
END_ELEM_WRITE( quad );
BEGIN_EXTRA_VERTICES_WRITE( SMDSEntity_Quad_Quadrangle, GmfExtraVerticesAtQuadrilaterals, quad, 4 )
node2IdMap[ quad->GetNode( 4 )],
node2IdMap[ quad->GetNode( 5 )],
node2IdMap[ quad->GetNode( 6 )],
node2IdMap[ quad->GetNode( 7 )]
END_EXTRA_VERTICES_WRITE();
// bi-quadratic quadrangles
BEGIN_ELEM_WRITE( SMDSEntity_BiQuad_Quadrangle, GmfQuadrilaterals, quad )
node2IdMap[ quad->GetNode( 0 )],
node2IdMap[ quad->GetNode( 1 )],
node2IdMap[ quad->GetNode( 2 )],
node2IdMap[ quad->GetNode( 3 )],
END_ELEM_WRITE( quad );
BEGIN_EXTRA_VERTICES_WRITE( SMDSEntity_BiQuad_Quadrangle, GmfExtraVerticesAtQuadrilaterals, quad, 5 )
node2IdMap[ quad->GetNode( 4 )], node2IdMap[ quad->GetNode( 4 )],
node2IdMap[ quad->GetNode( 5 )], node2IdMap[ quad->GetNode( 5 )],
node2IdMap[ quad->GetNode( 6 )], node2IdMap[ quad->GetNode( 6 )],
node2IdMap[ quad->GetNode( 7 )], node2IdMap[ quad->GetNode( 7 )],
node2IdMap[ quad->GetNode( 8 )] node2IdMap[ quad->GetNodeWrap( 8 )] // for QUAD9
END_EXTRA_VERTICES_WRITE(); END_EXTRA_VERTICES_WRITE();
// terahedra // terahedra
BEGIN_ELEM_WRITE( SMDSEntity_Tetra, GmfTetrahedra, tetra ) BEGIN_ELEM_WRITE( SMDSGeom_TETRA, GmfTetrahedra, tetra )
node2IdMap[ tetra->GetNode( 0 )], node2IdMap[ tetra->GetNode( 0 )],
node2IdMap[ tetra->GetNode( 2 )], node2IdMap[ tetra->GetNode( 2 )],
node2IdMap[ tetra->GetNode( 1 )], node2IdMap[ tetra->GetNode( 1 )],
node2IdMap[ tetra->GetNode( 3 )], node2IdMap[ tetra->GetNode( 3 )],
END_ELEM_WRITE( tetra ); END_ELEM_WRITE( tetra );
// quadratic terahedra // nodes of quadratic terahedra
BEGIN_ELEM_WRITE( SMDSEntity_Quad_Tetra, GmfTetrahedra, tetra ) BEGIN_EXTRA_VERTICES_WRITE( SMDSGeom_TETRA, SMDSEntity_Tetra,
node2IdMap[ tetra->GetNode( 0 )], GmfExtraVerticesAtTetrahedra, tetra )
node2IdMap[ tetra->GetNode( 2 )],
node2IdMap[ tetra->GetNode( 1 )],
node2IdMap[ tetra->GetNode( 3 )],
END_ELEM_WRITE( tetra );
BEGIN_EXTRA_VERTICES_WRITE( SMDSEntity_Quad_Tetra, GmfExtraVerticesAtTetrahedra, tetra, 6 )
node2IdMap[ tetra->GetNode( 6 )], node2IdMap[ tetra->GetNode( 6 )],
node2IdMap[ tetra->GetNode( 5 )], node2IdMap[ tetra->GetNode( 5 )],
node2IdMap[ tetra->GetNode( 4 )], node2IdMap[ tetra->GetNode( 4 )],
node2IdMap[ tetra->GetNode( 7 )], node2IdMap[ tetra->GetNode( 7 )],
node2IdMap[ tetra->GetNode( 9 )], node2IdMap[ tetra->GetNode( 9 )],
node2IdMap[ tetra->GetNode( 8 )] node2IdMap[ tetra->GetNode( 8 )]
//node2IdMap[ tetra->GetNodeWrap( 10 )], // for TETRA11
END_EXTRA_VERTICES_WRITE(); END_EXTRA_VERTICES_WRITE();
// pyramids // pyramids
BEGIN_ELEM_WRITE( SMDSEntity_Pyramid, GmfPyramids, pyra ) BEGIN_ELEM_WRITE( SMDSEntity_Pyramid, GmfPyramids, pyra )
node2IdMap[ pyra->GetNode( 0 )], node2IdMap[ pyra->GetNode( 0 )],
@ -237,7 +208,7 @@ Driver_Mesh::Status DriverGMF_Write::Perform()
END_ELEM_WRITE( pyra ); END_ELEM_WRITE( pyra );
// hexahedra // hexahedra
BEGIN_ELEM_WRITE( SMDSEntity_Hexa, GmfHexahedra, hexa ) BEGIN_ELEM_WRITE( SMDSGeom_HEXA, GmfHexahedra, hexa )
node2IdMap[ hexa->GetNode( 0 )], node2IdMap[ hexa->GetNode( 0 )],
node2IdMap[ hexa->GetNode( 3 )], node2IdMap[ hexa->GetNode( 3 )],
node2IdMap[ hexa->GetNode( 2 )], node2IdMap[ hexa->GetNode( 2 )],
@ -248,65 +219,28 @@ Driver_Mesh::Status DriverGMF_Write::Perform()
node2IdMap[ hexa->GetNode( 5 )], node2IdMap[ hexa->GetNode( 5 )],
END_ELEM_WRITE( hexa ); END_ELEM_WRITE( hexa );
// quadratic hexahedra // nodes of quadratic hexahedra
BEGIN_ELEM_WRITE( SMDSEntity_Quad_Hexa, GmfHexahedra, hexa ) BEGIN_EXTRA_VERTICES_WRITE( SMDSGeom_HEXA, SMDSEntity_Hexa,
node2IdMap[ hexa->GetNode( 0 )], GmfExtraVerticesAtHexahedra, hexa )
node2IdMap[ hexa->GetNode( 3 )], node2IdMap[ hexa->GetNode( 11 )], // HEXA20
node2IdMap[ hexa->GetNode( 2 )],
node2IdMap[ hexa->GetNode( 1 )],
node2IdMap[ hexa->GetNode( 4 )],
node2IdMap[ hexa->GetNode( 7 )],
node2IdMap[ hexa->GetNode( 6 )],
node2IdMap[ hexa->GetNode( 5 )],
END_ELEM_WRITE( hexa );
BEGIN_EXTRA_VERTICES_WRITE( SMDSEntity_Quad_Hexa, GmfExtraVerticesAtHexahedra, hexa, 12 )
node2IdMap[ hexa->GetNode( 11 )],
node2IdMap[ hexa->GetNode( 10 )], node2IdMap[ hexa->GetNode( 10 )],
node2IdMap[ hexa->GetNode( 9 )], node2IdMap[ hexa->GetNode( 9 )],
node2IdMap[ hexa->GetNode( 8 )], node2IdMap[ hexa->GetNode( 8 )],
node2IdMap[ hexa->GetNode( 15 )], node2IdMap[ hexa->GetNode( 15 )],
node2IdMap[ hexa->GetNode( 14 )], node2IdMap[ hexa->GetNode( 14 )],
node2IdMap[ hexa->GetNode( 13 )], node2IdMap[ hexa->GetNode( 13 )],
node2IdMap[ hexa->GetNode( 12 )], node2IdMap[ hexa->GetNode( 12 )],
node2IdMap[ hexa->GetNode( 16 )], node2IdMap[ hexa->GetNode( 16 )],
node2IdMap[ hexa->GetNode( 19 )], node2IdMap[ hexa->GetNode( 19 )],
node2IdMap[ hexa->GetNode( 18 )], node2IdMap[ hexa->GetNodeWrap( 18 )], // + HEXA27
node2IdMap[ hexa->GetNode( 17 )] node2IdMap[ hexa->GetNodeWrap( 17 )],
END_EXTRA_VERTICES_WRITE(); node2IdMap[ hexa->GetNodeWrap( 20 )],
node2IdMap[ hexa->GetNodeWrap( 24 )],
// tri-quadratic hexahedra node2IdMap[ hexa->GetNodeWrap( 23 )],
BEGIN_ELEM_WRITE( SMDSEntity_TriQuad_Hexa, GmfHexahedra, hexa ) node2IdMap[ hexa->GetNodeWrap( 22 )],
node2IdMap[ hexa->GetNode( 0 )], node2IdMap[ hexa->GetNodeWrap( 21 )],
node2IdMap[ hexa->GetNode( 3 )], node2IdMap[ hexa->GetNodeWrap( 25 )],
node2IdMap[ hexa->GetNode( 2 )], node2IdMap[ hexa->GetNodeWrap( 26 )]
node2IdMap[ hexa->GetNode( 1 )],
node2IdMap[ hexa->GetNode( 4 )],
node2IdMap[ hexa->GetNode( 7 )],
node2IdMap[ hexa->GetNode( 6 )],
node2IdMap[ hexa->GetNode( 5 )],
END_ELEM_WRITE( hexa );
BEGIN_EXTRA_VERTICES_WRITE( SMDSEntity_TriQuad_Hexa, GmfExtraVerticesAtHexahedra, hexa, 19 )
node2IdMap[ hexa->GetNode( 11 )],
node2IdMap[ hexa->GetNode( 10 )],
node2IdMap[ hexa->GetNode( 9 )],
node2IdMap[ hexa->GetNode( 8 )],
node2IdMap[ hexa->GetNode( 15 )],
node2IdMap[ hexa->GetNode( 14 )],
node2IdMap[ hexa->GetNode( 13 )],
node2IdMap[ hexa->GetNode( 12 )],
node2IdMap[ hexa->GetNode( 16 )],
node2IdMap[ hexa->GetNode( 19 )],
node2IdMap[ hexa->GetNode( 18 )],
node2IdMap[ hexa->GetNode( 17 )],
node2IdMap[ hexa->GetNode( 20 )],
node2IdMap[ hexa->GetNode( 24 )],
node2IdMap[ hexa->GetNode( 23 )],
node2IdMap[ hexa->GetNode( 22 )],
node2IdMap[ hexa->GetNode( 21 )],
node2IdMap[ hexa->GetNode( 25 )],
node2IdMap[ hexa->GetNode( 26 )]
END_EXTRA_VERTICES_WRITE(); END_EXTRA_VERTICES_WRITE();
// prism // prism
@ -405,3 +339,22 @@ Driver_Mesh::Status DriverGMF_Write::Perform()
return DRS_OK; return DRS_OK;
} }
//================================================================================
/*!
* \brief Returns an iterator on elements of a certain type
*/
//================================================================================
SMDS_ElemIteratorPtr DriverGMF_Write::elementIterator(SMDSAbs_ElementType type)
{
return myMesh->elementsIterator(type);
}
SMDS_ElemIteratorPtr DriverGMF_Write::elementIterator(SMDSAbs_EntityType type)
{
return myMesh->elementEntityIterator(type);
}
SMDS_ElemIteratorPtr DriverGMF_Write::elementIterator(SMDSAbs_GeometryType type)
{
return myMesh->elementGeomIterator(type);
}

5
src/DriverGMF/DriverGMF_Write.hxx
View File

@ -31,6 +31,7 @@
#include "Driver_SMESHDS_Mesh.h" #include "Driver_SMESHDS_Mesh.h"
#include "SMDSAbs_ElementType.hxx" #include "SMDSAbs_ElementType.hxx"
#include "SMDS_ElemIterator.hxx"
/*! /*!
* \brief Driver Writing a mesh into a GMF file. * \brief Driver Writing a mesh into a GMF file.
@ -51,6 +52,10 @@ public:
private: private:
SMDS_ElemIteratorPtr elementIterator(SMDSAbs_ElementType type);
SMDS_ElemIteratorPtr elementIterator(SMDSAbs_EntityType type);
SMDS_ElemIteratorPtr elementIterator(SMDSAbs_GeometryType type);
bool _exportRequiredGroups; bool _exportRequiredGroups;
}; };

2
src/DriverMED/Makefile.am
View File

@ -21,7 +21,7 @@
# Author : Marc Tajchman (CEA) # Author : Marc Tajchman (CEA)
# Modified by : Alexander BORODIN (OCN) - autotools usage # Modified by : Alexander BORODIN (OCN) - autotools usage
# Module : SMESH # Module : SMESH
#
include $(top_srcdir)/adm_local/unix/make_common_starter.am include $(top_srcdir)/adm_local/unix/make_common_starter.am
# header files # header files

111
src/OBJECT/SMESH_Actor.cxx
View File

@ -146,10 +146,10 @@ SMESH_ActorDef::SMESH_ActorDef()
if ( mgr && mgr->booleanValue( "SMESH", "use_precision", false ) ) if ( mgr && mgr->booleanValue( "SMESH", "use_precision", false ) )
myControlsPrecision = mgr->integerValue( "SMESH", "controls_precision", -1); myControlsPrecision = mgr->integerValue( "SMESH", "controls_precision", -1);
vtkFloatingPointType aElem0DSize = SMESH::GetFloat("SMESH:elem0d_size",5); double aElem0DSize = SMESH::GetFloat("SMESH:elem0d_size",5);
vtkFloatingPointType aBallElemSize = SMESH::GetFloat("SMESH:ball_elem_size",10); double aBallElemSize = SMESH::GetFloat("SMESH:ball_elem_size",10);
vtkFloatingPointType aLineWidth = SMESH::GetFloat("SMESH:element_width",1); double aLineWidth = SMESH::GetFloat("SMESH:element_width",1);
vtkFloatingPointType aOutlineWidth = SMESH::GetFloat("SMESH:outline_width",1); double aOutlineWidth = SMESH::GetFloat("SMESH:outline_width",1);
SMESH::LabelFont aFamilyNd = SMESH::FntTimes; SMESH::LabelFont aFamilyNd = SMESH::FntTimes;
bool aBoldNd = true; bool aBoldNd = true;
@ -166,7 +166,7 @@ SMESH_ActorDef::SMESH_ActorDef()
aShadowNd = f.overline(); aShadowNd = f.overline();
aSizeNd = f.pointSize(); aSizeNd = f.pointSize();
} }
vtkFloatingPointType anRGBNd[3] = {1,1,1}; double anRGBNd[3] = {1,1,1};
SMESH::GetColor( "SMESH", "numbering_node_color", anRGBNd[0], anRGBNd[1], anRGBNd[2], QColor( 255, 255, 255 ) ); SMESH::GetColor( "SMESH", "numbering_node_color", anRGBNd[0], anRGBNd[1], anRGBNd[2], QColor( 255, 255, 255 ) );
SMESH::LabelFont aFamilyEl = SMESH::FntTimes; SMESH::LabelFont aFamilyEl = SMESH::FntTimes;
@ -184,7 +184,7 @@ SMESH_ActorDef::SMESH_ActorDef()
aShadowEl = f.overline(); aShadowEl = f.overline();
aSizeEl = f.pointSize(); aSizeEl = f.pointSize();
} }
vtkFloatingPointType anRGBEl[3] = {0,1,0}; double anRGBEl[3] = {0,1,0};
SMESH::GetColor( "SMESH", "numbering_elem_color", anRGBEl[0], anRGBEl[1], anRGBEl[2], QColor( 0, 255, 0 ) ); SMESH::GetColor( "SMESH", "numbering_elem_color", anRGBEl[0], anRGBEl[1], anRGBEl[2], QColor( 0, 255, 0 ) );
vtkMatrix4x4 *aMatrix = vtkMatrix4x4::New(); vtkMatrix4x4 *aMatrix = vtkMatrix4x4::New();
@ -192,7 +192,7 @@ SMESH_ActorDef::SMESH_ActorDef()
//Definition 2D and 3D devices of the actor //Definition 2D and 3D devices of the actor
//----------------------------------------- //-----------------------------------------
vtkFloatingPointType anRGB[3] = {1,1,1}; double anRGB[3] = {1,1,1};
mySurfaceProp = vtkProperty::New(); mySurfaceProp = vtkProperty::New();
QColor ffc, bfc; QColor ffc, bfc;
int delta; int delta;
@ -665,8 +665,8 @@ void SMESH_ActorDef::SetPointsLabeled( bool theIsPointsLabeled )
void SMESH_ActorDef::SetPointsFontProperties( SMESH::LabelFont theFamily, int theSize, void SMESH_ActorDef::SetPointsFontProperties( SMESH::LabelFont theFamily, int theSize,
bool theBold, bool theItalic, bool theShadow, bool theBold, bool theItalic, bool theShadow,
vtkFloatingPointType r, vtkFloatingPointType g, vtkFloatingPointType b ) double r, double g, double b )
{ {
if(myNodeActor) { if(myNodeActor) {
myNodeActor->SetFontProperties( theFamily, theSize, theBold, theItalic, theShadow, r, g, b ); myNodeActor->SetFontProperties( theFamily, theSize, theBold, theItalic, theShadow, r, g, b );
SetRepresentation( GetRepresentation() ); SetRepresentation( GetRepresentation() );
@ -676,8 +676,8 @@ void SMESH_ActorDef::SetPointsFontProperties( SMESH::LabelFont theFamily, int th
void SMESH_ActorDef::SetCellsFontProperties( SMESH::LabelFont theFamily, int theSize, void SMESH_ActorDef::SetCellsFontProperties( SMESH::LabelFont theFamily, int theSize,
bool theBold, bool theItalic, bool theShadow, bool theBold, bool theItalic, bool theShadow,
vtkFloatingPointType r, vtkFloatingPointType g, vtkFloatingPointType b ) double r, double g, double b )
{ {
if(my3DActor) { if(my3DActor) {
my3DActor->SetFontProperties( theFamily, theSize, theBold, theItalic, theShadow, r, g, b ); my3DActor->SetFontProperties( theFamily, theSize, theBold, theItalic, theShadow, r, g, b );
SetRepresentation( GetRepresentation() ); SetRepresentation( GetRepresentation() );
@ -766,24 +766,24 @@ bool SMESH_ActorDef::GetFacesOriented()
return myIsFacesOriented; return myIsFacesOriented;
} }
void SMESH_ActorDef::SetFacesOrientationColor(vtkFloatingPointType r,vtkFloatingPointType g,vtkFloatingPointType b) void SMESH_ActorDef::SetFacesOrientationColor(double r,double g,double b)
{ {
my2DActor->SetFacesOrientationColor( r, g, b ); my2DActor->SetFacesOrientationColor( r, g, b );
my3DActor->SetFacesOrientationColor( r, g, b ); my3DActor->SetFacesOrientationColor( r, g, b );
} }
void SMESH_ActorDef::GetFacesOrientationColor(vtkFloatingPointType& r,vtkFloatingPointType& g,vtkFloatingPointType& b) void SMESH_ActorDef::GetFacesOrientationColor(double& r,double& g,double& b)
{ {
my3DActor->GetFacesOrientationColor( r, g, b ); my3DActor->GetFacesOrientationColor( r, g, b );
} }
void SMESH_ActorDef::SetFacesOrientationScale(vtkFloatingPointType theScale) void SMESH_ActorDef::SetFacesOrientationScale(double theScale)
{ {
my2DActor->SetFacesOrientationScale( theScale ); my2DActor->SetFacesOrientationScale( theScale );
my3DActor->SetFacesOrientationScale( theScale ); my3DActor->SetFacesOrientationScale( theScale );
} }
vtkFloatingPointType SMESH_ActorDef::GetFacesOrientationScale() double SMESH_ActorDef::GetFacesOrientationScale()
{ {
return my3DActor->GetFacesOrientationScale(); return my3DActor->GetFacesOrientationScale();
} }
@ -1189,8 +1189,8 @@ bool SMESH_ActorDef::Init(TVisualObjPtr theVisualObj,
my2DExtActor->GetMapper()->SetLookupTable(myLookupTable); my2DExtActor->GetMapper()->SetLookupTable(myLookupTable);
my3DActor->GetMapper()->SetLookupTable(myLookupTable); my3DActor->GetMapper()->SetLookupTable(myLookupTable);
my3DExtActor->GetMapper()->SetLookupTable(myLookupTable); my3DExtActor->GetMapper()->SetLookupTable(myLookupTable);
vtkFloatingPointType aFactor, aUnits; double aFactor, aUnits;
my2DActor->GetPolygonOffsetParameters(aFactor,aUnits); my2DActor->GetPolygonOffsetParameters(aFactor,aUnits);
my2DActor->SetPolygonOffsetParameters(aFactor,aUnits*0.75); my2DActor->SetPolygonOffsetParameters(aFactor,aUnits*0.75);
my2DExtActor->SetPolygonOffsetParameters(aFactor,aUnits*0.5); my2DExtActor->SetPolygonOffsetParameters(aFactor,aUnits*0.5);
@ -1233,7 +1233,7 @@ bool SMESH_ActorDef::Init(TVisualObjPtr theVisualObj,
} }
vtkFloatingPointType* SMESH_ActorDef::GetBounds(){ double* SMESH_ActorDef::GetBounds(){
return myNodeActor->GetBounds(); return myNodeActor->GetBounds();
} }
@ -1291,7 +1291,6 @@ vtkUnstructuredGrid* SMESH_ActorDef::GetUnstructuredGrid(){
bool SMESH_ActorDef::IsInfinitive(){ bool SMESH_ActorDef::IsInfinitive(){
vtkDataSet *aDataSet = myPickableActor->GetUnstructuredGrid(); vtkDataSet *aDataSet = myPickableActor->GetUnstructuredGrid();
aDataSet->Update();
myIsInfinite = aDataSet->GetNumberOfCells() == 0 || myIsInfinite = aDataSet->GetNumberOfCells() == 0 ||
( aDataSet->GetNumberOfCells() == 1 && ( aDataSet->GetNumberOfCells() == 1 &&
aDataSet->GetCell(0)->GetCellType() == VTK_VERTEX ); aDataSet->GetCell(0)->GetCellType() == VTK_VERTEX );
@ -1306,11 +1305,11 @@ void SMESH_ActorDef::SetIsShrunkable(bool theShrunkable){
Modified(); Modified();
} }
vtkFloatingPointType SMESH_ActorDef::GetShrinkFactor(){ double SMESH_ActorDef::GetShrinkFactor(){
return myBaseActor->GetShrinkFactor(); return myBaseActor->GetShrinkFactor();
} }
void SMESH_ActorDef::SetShrinkFactor(vtkFloatingPointType theValue){ void SMESH_ActorDef::SetShrinkFactor(double theValue){
myBaseActor->SetShrinkFactor(theValue); myBaseActor->SetShrinkFactor(theValue);
my1DActor->SetShrinkFactor(theValue); my1DActor->SetShrinkFactor(theValue);
@ -1367,7 +1366,7 @@ int SMESH_ActorDef::GetNodeObjId(int theVtkID){
return myPickableActor->GetNodeObjId(theVtkID); return myPickableActor->GetNodeObjId(theVtkID);
} }
vtkFloatingPointType* SMESH_ActorDef::GetNodeCoord(int theObjID){ double* SMESH_ActorDef::GetNodeCoord(int theObjID){
return myPickableActor->GetNodeCoord(theObjID); return myPickableActor->GetNodeCoord(theObjID);
} }
@ -1916,15 +1915,15 @@ void SMESH_ActorDef::ReleaseGraphicsResources(vtkWindow *renWin){
} }
static void GetColor(vtkProperty *theProperty, vtkFloatingPointType& r,vtkFloatingPointType& g,vtkFloatingPointType& b){ static void GetColor(vtkProperty *theProperty, double& r,double& g,double& b){
vtkFloatingPointType* aColor = theProperty->GetColor(); double* aColor = theProperty->GetColor();
r = aColor[0]; r = aColor[0];
g = aColor[1]; g = aColor[1];
b = aColor[2]; b = aColor[2];
} }
void SMESH_ActorDef::SetOpacity(vtkFloatingPointType theValue){ void SMESH_ActorDef::SetOpacity(double theValue){
mySurfaceProp->SetOpacity(theValue); mySurfaceProp->SetOpacity(theValue);
myBackSurfaceProp->SetOpacity(theValue); myBackSurfaceProp->SetOpacity(theValue);
myNormalVProp->SetOpacity(theValue); myNormalVProp->SetOpacity(theValue);
@ -1939,12 +1938,12 @@ void SMESH_ActorDef::SetOpacity(vtkFloatingPointType theValue){
} }
vtkFloatingPointType SMESH_ActorDef::GetOpacity(){ double SMESH_ActorDef::GetOpacity(){
return mySurfaceProp->GetOpacity(); return mySurfaceProp->GetOpacity();
} }
void SMESH_ActorDef::SetSufaceColor(vtkFloatingPointType r,vtkFloatingPointType g,vtkFloatingPointType b, int delta){ void SMESH_ActorDef::SetSufaceColor(double r,double g,double b, int delta){
mySurfaceProp->SetColor(r,g,b); mySurfaceProp->SetColor(r,g,b);
my2DExtProp->SetColor(1.0-r,1.0-g,1.0-b); my2DExtProp->SetColor(1.0-r,1.0-g,1.0-b);
if( SMESH_GroupObj* aGroupObj = dynamic_cast<SMESH_GroupObj*>( myVisualObj.get() ) ) if( SMESH_GroupObj* aGroupObj = dynamic_cast<SMESH_GroupObj*>( myVisualObj.get() ) )
@ -1957,12 +1956,12 @@ void SMESH_ActorDef::SetSufaceColor(vtkFloatingPointType r,vtkFloatingPointType
Modified(); Modified();
} }
void SMESH_ActorDef::GetSufaceColor(vtkFloatingPointType& r,vtkFloatingPointType& g,vtkFloatingPointType& b, int& delta){ void SMESH_ActorDef::GetSufaceColor(double& r,double& g,double& b, int& delta){
::GetColor(mySurfaceProp,r,g,b); ::GetColor(mySurfaceProp,r,g,b);
delta = myDeltaBrightness; delta = myDeltaBrightness;
} }
void SMESH_ActorDef::SetVolumeColor(vtkFloatingPointType r,vtkFloatingPointType g,vtkFloatingPointType b, int delta){ void SMESH_ActorDef::SetVolumeColor(double r,double g,double b, int delta){
myNormalVProp->SetColor(r,g,b); myNormalVProp->SetColor(r,g,b);
my3DExtProp->SetColor(1.0-r,1.0-g,1.0-b); my3DExtProp->SetColor(1.0-r,1.0-g,1.0-b);
if( SMESH_GroupObj* aGroupObj = dynamic_cast<SMESH_GroupObj*>( myVisualObj.get() ) ) if( SMESH_GroupObj* aGroupObj = dynamic_cast<SMESH_GroupObj*>( myVisualObj.get() ) )
@ -1975,12 +1974,12 @@ void SMESH_ActorDef::SetVolumeColor(vtkFloatingPointType r,vtkFloatingPointType
Modified(); Modified();
} }
void SMESH_ActorDef::GetVolumeColor(vtkFloatingPointType& r,vtkFloatingPointType& g,vtkFloatingPointType& b, int& delta){ void SMESH_ActorDef::GetVolumeColor(double& r,double& g,double& b, int& delta){
::GetColor(myNormalVProp,r,g,b); ::GetColor(myNormalVProp,r,g,b);
delta = myDeltaVBrightness; delta = myDeltaVBrightness;
} }
void SMESH_ActorDef::SetEdgeColor(vtkFloatingPointType r,vtkFloatingPointType g,vtkFloatingPointType b){ void SMESH_ActorDef::SetEdgeColor(double r,double g,double b){
myEdgeProp->SetColor(r,g,b); myEdgeProp->SetColor(r,g,b);
my1DProp->SetColor(r,g,b); my1DProp->SetColor(r,g,b);
my1DExtProp->SetColor(1.0-r,1.0-g,1.0-b); my1DExtProp->SetColor(1.0-r,1.0-g,1.0-b);
@ -1990,21 +1989,21 @@ void SMESH_ActorDef::SetEdgeColor(vtkFloatingPointType r,vtkFloatingPointType g,
Modified(); Modified();
} }
void SMESH_ActorDef::GetEdgeColor(vtkFloatingPointType& r,vtkFloatingPointType& g,vtkFloatingPointType& b){ void SMESH_ActorDef::GetEdgeColor(double& r,double& g,double& b){
::GetColor(myEdgeProp,r,g,b); ::GetColor(myEdgeProp,r,g,b);
} }
void SMESH_ActorDef::SetOutlineColor(vtkFloatingPointType r,vtkFloatingPointType g,vtkFloatingPointType b){ void SMESH_ActorDef::SetOutlineColor(double r,double g,double b){
myOutLineProp->SetColor(r,g,b); myOutLineProp->SetColor(r,g,b);
Modified(); Modified();
} }
void SMESH_ActorDef::GetOutlineColor(vtkFloatingPointType& r,vtkFloatingPointType& g,vtkFloatingPointType& b){ void SMESH_ActorDef::GetOutlineColor(double& r,double& g,double& b){
::GetColor(myOutLineProp,r,g,b); ::GetColor(myOutLineProp,r,g,b);
} }
void SMESH_ActorDef::SetNodeColor(vtkFloatingPointType r,vtkFloatingPointType g,vtkFloatingPointType b){ void SMESH_ActorDef::SetNodeColor(double r,double g,double b){
myNodeProp->SetColor(r,g,b); myNodeProp->SetColor(r,g,b);
myNodeExtProp->SetColor(1.0-r,1.0-g,1.0-b); myNodeExtProp->SetColor(1.0-r,1.0-g,1.0-b);
if( SMESH_GroupObj* aGroupObj = dynamic_cast<SMESH_GroupObj*>( myVisualObj.get() ) ) if( SMESH_GroupObj* aGroupObj = dynamic_cast<SMESH_GroupObj*>( myVisualObj.get() ) )
@ -2013,11 +2012,11 @@ void SMESH_ActorDef::SetNodeColor(vtkFloatingPointType r,vtkFloatingPointType g,
Modified(); Modified();
} }
void SMESH_ActorDef::GetNodeColor(vtkFloatingPointType& r,vtkFloatingPointType& g,vtkFloatingPointType& b){ void SMESH_ActorDef::GetNodeColor(double& r,double& g,double& b){
::GetColor(myNodeProp,r,g,b); ::GetColor(myNodeProp,r,g,b);
} }
void SMESH_ActorDef::Set0DColor(vtkFloatingPointType r,vtkFloatingPointType g,vtkFloatingPointType b){ void SMESH_ActorDef::Set0DColor(double r,double g,double b){
my0DProp->SetColor(r,g,b); my0DProp->SetColor(r,g,b);
if( SMESH_GroupObj* aGroupObj = dynamic_cast<SMESH_GroupObj*>( myVisualObj.get() ) ) if( SMESH_GroupObj* aGroupObj = dynamic_cast<SMESH_GroupObj*>( myVisualObj.get() ) )
if( aGroupObj->GetElementType() == SMDSAbs_0DElement ) if( aGroupObj->GetElementType() == SMDSAbs_0DElement )
@ -2025,11 +2024,11 @@ void SMESH_ActorDef::Set0DColor(vtkFloatingPointType r,vtkFloatingPointType g,vt
Modified(); Modified();
} }
void SMESH_ActorDef::Get0DColor(vtkFloatingPointType& r,vtkFloatingPointType& g,vtkFloatingPointType& b){ void SMESH_ActorDef::Get0DColor(double& r,double& g,double& b){
::GetColor(my0DProp,r,g,b); ::GetColor(my0DProp,r,g,b);
} }
void SMESH_ActorDef::SetBallColor(vtkFloatingPointType r,vtkFloatingPointType g,vtkFloatingPointType b){ void SMESH_ActorDef::SetBallColor(double r,double g,double b){
myBallProp->SetColor(r,g,b); myBallProp->SetColor(r,g,b);
if( SMESH_GroupObj* aGroupObj = dynamic_cast<SMESH_GroupObj*>( myVisualObj.get() ) ) if( SMESH_GroupObj* aGroupObj = dynamic_cast<SMESH_GroupObj*>( myVisualObj.get() ) )
if( aGroupObj->GetElementType() == SMDSAbs_Ball ) if( aGroupObj->GetElementType() == SMDSAbs_Ball )
@ -2037,37 +2036,37 @@ void SMESH_ActorDef::SetBallColor(vtkFloatingPointType r,vtkFloatingPointType g,
Modified(); Modified();
} }
void SMESH_ActorDef::GetBallColor(vtkFloatingPointType& r,vtkFloatingPointType& g,vtkFloatingPointType& b){ void SMESH_ActorDef::GetBallColor(double& r,double& g,double& b){
::GetColor(myBallProp,r,g,b); ::GetColor(myBallProp,r,g,b);
} }
void SMESH_ActorDef::SetHighlightColor(vtkFloatingPointType r,vtkFloatingPointType g,vtkFloatingPointType b){ void SMESH_ActorDef::SetHighlightColor(double r,double g,double b){
myHighlightProp->SetColor(r,g,b); myHighlightProp->SetColor(r,g,b);
myBallHighlightProp->SetColor(r,g,b); myBallHighlightProp->SetColor(r,g,b);
Modified(); Modified();
} }
void SMESH_ActorDef::GetHighlightColor(vtkFloatingPointType& r,vtkFloatingPointType& g,vtkFloatingPointType& b){ void SMESH_ActorDef::GetHighlightColor(double& r,double& g,double& b){
::GetColor(myHighlightProp,r,g,b); ::GetColor(myHighlightProp,r,g,b);
} }
void SMESH_ActorDef::SetPreHighlightColor(vtkFloatingPointType r,vtkFloatingPointType g,vtkFloatingPointType b){ void SMESH_ActorDef::SetPreHighlightColor(double r,double g,double b){
myPreselectProp->SetColor(r,g,b); myPreselectProp->SetColor(r,g,b);
myBallPreselectProp->SetColor(r,g,b); myBallPreselectProp->SetColor(r,g,b);
Modified(); Modified();
} }
void SMESH_ActorDef::GetPreHighlightColor(vtkFloatingPointType& r,vtkFloatingPointType& g,vtkFloatingPointType& b){ void SMESH_ActorDef::GetPreHighlightColor(double& r,double& g,double& b){
::GetColor(myPreselectProp,r,g,b); ::GetColor(myPreselectProp,r,g,b);
} }
vtkFloatingPointType SMESH_ActorDef::GetLineWidth(){ double SMESH_ActorDef::GetLineWidth(){
return myEdgeProp->GetLineWidth(); return myEdgeProp->GetLineWidth();
} }
void SMESH_ActorDef::SetLineWidth(vtkFloatingPointType theVal){ void SMESH_ActorDef::SetLineWidth(double theVal){
myEdgeProp->SetLineWidth(theVal); myEdgeProp->SetLineWidth(theVal);
my1DProp->SetLineWidth(theVal + aLineWidthInc); my1DProp->SetLineWidth(theVal + aLineWidthInc);
@ -2080,18 +2079,18 @@ void SMESH_ActorDef::SetLineWidth(vtkFloatingPointType theVal){
Modified(); Modified();
} }
vtkFloatingPointType SMESH_ActorDef::GetOutlineWidth() double SMESH_ActorDef::GetOutlineWidth()
{ {
return myOutLineProp->GetLineWidth(); return myOutLineProp->GetLineWidth();
} }
void SMESH_ActorDef::SetOutlineWidth(vtkFloatingPointType theVal) void SMESH_ActorDef::SetOutlineWidth(double theVal)
{ {
myOutLineProp->SetLineWidth(theVal); myOutLineProp->SetLineWidth(theVal);
Modified(); Modified();
} }
void SMESH_ActorDef::Set0DSize(vtkFloatingPointType theVal){ void SMESH_ActorDef::Set0DSize(double theVal){
my0DProp->SetPointSize(theVal); my0DProp->SetPointSize(theVal);
myHighlightProp->SetPointSize(theVal); myHighlightProp->SetPointSize(theVal);
myPreselectProp->SetPointSize(theVal); myPreselectProp->SetPointSize(theVal);
@ -2106,11 +2105,11 @@ void SMESH_ActorDef::Set0DSize(vtkFloatingPointType theVal){
Modified(); Modified();
} }
vtkFloatingPointType SMESH_ActorDef::Get0DSize(){ double SMESH_ActorDef::Get0DSize(){
return my0DProp->GetPointSize(); return my0DProp->GetPointSize();
} }
void SMESH_ActorDef::SetBallSize(vtkFloatingPointType theVal){ void SMESH_ActorDef::SetBallSize(double theVal){
myBallProp->SetPointSize(theVal); myBallProp->SetPointSize(theVal);
myBallHighlightProp->SetPointSize(theVal); myBallHighlightProp->SetPointSize(theVal);
myBallPreselectProp->SetPointSize(theVal); myBallPreselectProp->SetPointSize(theVal);
@ -2124,7 +2123,7 @@ void SMESH_ActorDef::SetBallSize(vtkFloatingPointType theVal){
Modified(); Modified();
} }
vtkFloatingPointType SMESH_ActorDef::GetBallSize(){ double SMESH_ActorDef::GetBallSize(){
return myBallProp->GetPointSize(); return myBallProp->GetPointSize();
} }
@ -2288,21 +2287,21 @@ void SMESH_ActorDef::UpdateScalarBar()
myScalarBarActor->SetOrientationToVertical(); myScalarBarActor->SetOrientationToVertical();
vtkFloatingPointType aXVal = horiz ? 0.20 : 0.01; double aXVal = horiz ? 0.20 : 0.01;
if( mgr->hasValue( "SMESH", name + "x" ) ) if( mgr->hasValue( "SMESH", name + "x" ) )
aXVal = mgr->doubleValue( "SMESH", name + "x", aXVal ); aXVal = mgr->doubleValue( "SMESH", name + "x", aXVal );
vtkFloatingPointType aYVal = horiz ? 0.01 : 0.1; double aYVal = horiz ? 0.01 : 0.1;
if( mgr->hasValue( "SMESH", name + "y" ) ) if( mgr->hasValue( "SMESH", name + "y" ) )
aYVal = mgr->doubleValue( "SMESH", name + "y", aYVal ); aYVal = mgr->doubleValue( "SMESH", name + "y", aYVal );
myScalarBarActor->SetPosition( aXVal, aYVal ); myScalarBarActor->SetPosition( aXVal, aYVal );
vtkFloatingPointType aWVal = horiz ? 0.60 : 0.10; double aWVal = horiz ? 0.60 : 0.10;
if( mgr->hasValue( "SMESH", name + "width" ) ) if( mgr->hasValue( "SMESH", name + "width" ) )
aWVal = mgr->doubleValue( "SMESH", name + "width", aWVal ); aWVal = mgr->doubleValue( "SMESH", name + "width", aWVal );
myScalarBarActor->SetWidth( aWVal ); myScalarBarActor->SetWidth( aWVal );
vtkFloatingPointType aHVal = horiz ? 0.12 : 0.80; double aHVal = horiz ? 0.12 : 0.80;
if( mgr->hasValue( "SMESH", name + "height" ) ) if( mgr->hasValue( "SMESH", name + "height" ) )
aHVal = mgr->doubleValue( "SMESH", name + "height", aHVal ); aHVal = mgr->doubleValue( "SMESH", name + "height", aHVal );
myScalarBarActor->SetHeight( aHVal ); myScalarBarActor->SetHeight( aHVal );

66
src/OBJECT/SMESH_Actor.h
View File

@ -62,44 +62,44 @@ class SMESHOBJECT_EXPORT SMESH_Actor: public SALOME_Actor
const char* theName, const char* theName,
int theIsClear); int theIsClear);
virtual void SetSufaceColor(vtkFloatingPointType r,vtkFloatingPointType g,vtkFloatingPointType b, int delta ) = 0; virtual void SetSufaceColor(double r,double g,double b, int delta ) = 0;
virtual void GetSufaceColor(vtkFloatingPointType& r,vtkFloatingPointType& g,vtkFloatingPointType& b, int& delta ) = 0; virtual void GetSufaceColor(double& r,double& g,double& b, int& delta ) = 0;
virtual void SetVolumeColor(vtkFloatingPointType r,vtkFloatingPointType g,vtkFloatingPointType b, int delta ) = 0; virtual void SetVolumeColor(double r,double g,double b, int delta ) = 0;
virtual void GetVolumeColor(vtkFloatingPointType& r,vtkFloatingPointType& g,vtkFloatingPointType& b, int& delta) = 0; virtual void GetVolumeColor(double& r,double& g,double& b, int& delta) = 0;
virtual void SetEdgeColor(vtkFloatingPointType r,vtkFloatingPointType g,vtkFloatingPointType b) = 0; virtual void SetEdgeColor(double r,double g,double b) = 0;
virtual void GetEdgeColor(vtkFloatingPointType& r,vtkFloatingPointType& g,vtkFloatingPointType& b) = 0; virtual void GetEdgeColor(double& r,double& g,double& b) = 0;
virtual void SetNodeColor(vtkFloatingPointType r,vtkFloatingPointType g,vtkFloatingPointType b) = 0; virtual void SetNodeColor(double r,double g,double b) = 0;
virtual void GetNodeColor(vtkFloatingPointType& r,vtkFloatingPointType& g,vtkFloatingPointType& b) = 0; virtual void GetNodeColor(double& r,double& g,double& b) = 0;
virtual void SetOutlineColor(vtkFloatingPointType r,vtkFloatingPointType g,vtkFloatingPointType b) = 0; virtual void SetOutlineColor(double r,double g,double b) = 0;
virtual void GetOutlineColor(vtkFloatingPointType& r,vtkFloatingPointType& g,vtkFloatingPointType& b) = 0; virtual void GetOutlineColor(double& r,double& g,double& b) = 0;
virtual void Set0DColor(vtkFloatingPointType r,vtkFloatingPointType g,vtkFloatingPointType b) = 0; virtual void Set0DColor(double r,double g,double b) = 0;
virtual void Get0DColor(vtkFloatingPointType& r,vtkFloatingPointType& g,vtkFloatingPointType& b) = 0; virtual void Get0DColor(double& r,double& g,double& b) = 0;
virtual void SetBallColor(vtkFloatingPointType r,vtkFloatingPointType g,vtkFloatingPointType b) = 0; virtual void SetBallColor(double r,double g,double b) = 0;
virtual void GetBallColor(vtkFloatingPointType& r,vtkFloatingPointType& g,vtkFloatingPointType& b) = 0; virtual void GetBallColor(double& r,double& g,double& b) = 0;
virtual void SetHighlightColor(vtkFloatingPointType r,vtkFloatingPointType g,vtkFloatingPointType b) = 0; virtual void SetHighlightColor(double r,double g,double b) = 0;
virtual void GetHighlightColor(vtkFloatingPointType& r,vtkFloatingPointType& g,vtkFloatingPointType& b) = 0; virtual void GetHighlightColor(double& r,double& g,double& b) = 0;
virtual void SetPreHighlightColor(vtkFloatingPointType r,vtkFloatingPointType g,vtkFloatingPointType b) = 0; virtual void SetPreHighlightColor(double r,double g,double b) = 0;
virtual void GetPreHighlightColor(vtkFloatingPointType& r,vtkFloatingPointType& g,vtkFloatingPointType& b) = 0; virtual void GetPreHighlightColor(double& r,double& g,double& b) = 0;
virtual vtkFloatingPointType GetLineWidth() = 0; virtual double GetLineWidth() = 0;
virtual void SetLineWidth(vtkFloatingPointType theVal) = 0; virtual void SetLineWidth(double theVal) = 0;
virtual vtkFloatingPointType GetOutlineWidth() = 0; virtual double GetOutlineWidth() = 0;
virtual void SetOutlineWidth(vtkFloatingPointType theVal) = 0; virtual void SetOutlineWidth(double theVal) = 0;
virtual void Set0DSize(vtkFloatingPointType size) = 0; virtual void Set0DSize(double size) = 0;
virtual vtkFloatingPointType Get0DSize() = 0; virtual double Get0DSize() = 0;
virtual void SetBallSize(vtkFloatingPointType size) = 0; virtual void SetBallSize(double size) = 0;
virtual vtkFloatingPointType GetBallSize() = 0; virtual double GetBallSize() = 0;
enum EReperesent { ePoint, eEdge, eSurface}; enum EReperesent { ePoint, eEdge, eSurface};
@ -118,7 +118,7 @@ class SMESHOBJECT_EXPORT SMESH_Actor: public SALOME_Actor
virtual vtkUnstructuredGrid* GetUnstructuredGrid() = 0; virtual vtkUnstructuredGrid* GetUnstructuredGrid() = 0;
virtual void SetShrinkFactor(vtkFloatingPointType theValue) = 0; virtual void SetShrinkFactor(double theValue) = 0;
virtual void SetPointsLabeled(bool theIsPointsLabeled) = 0; virtual void SetPointsLabeled(bool theIsPointsLabeled) = 0;
virtual bool GetPointsLabeled() = 0; virtual bool GetPointsLabeled() = 0;
@ -129,11 +129,11 @@ class SMESHOBJECT_EXPORT SMESH_Actor: public SALOME_Actor
virtual void SetFacesOriented(bool theIsFacesOriented) = 0; virtual void SetFacesOriented(bool theIsFacesOriented) = 0;
virtual bool GetFacesOriented() = 0; virtual bool GetFacesOriented() = 0;
virtual void SetFacesOrientationColor(vtkFloatingPointType r,vtkFloatingPointType g,vtkFloatingPointType b) = 0; virtual void SetFacesOrientationColor(double r,double g,double b) = 0;
virtual void GetFacesOrientationColor(vtkFloatingPointType& r,vtkFloatingPointType& g,vtkFloatingPointType& b) = 0; virtual void GetFacesOrientationColor(double& r,double& g,double& b) = 0;
virtual void SetFacesOrientationScale(vtkFloatingPointType theScale) = 0; virtual void SetFacesOrientationScale(double theScale) = 0;
virtual vtkFloatingPointType GetFacesOrientationScale() = 0; virtual double GetFacesOrientationScale() = 0;
virtual void SetFacesOrientation3DVectors(bool theState) = 0; virtual void SetFacesOrientation3DVectors(bool theState) = 0;
virtual bool GetFacesOrientation3DVectors() = 0; virtual bool GetFacesOrientation3DVectors() = 0;
@ -165,10 +165,10 @@ class SMESHOBJECT_EXPORT SMESH_Actor: public SALOME_Actor
virtual void SetPointsFontProperties( SMESH::LabelFont family, int size, virtual void SetPointsFontProperties( SMESH::LabelFont family, int size,
bool bold, bool italic, bool shadow, bool bold, bool italic, bool shadow,
vtkFloatingPointType r, vtkFloatingPointType g, vtkFloatingPointType b ) = 0; double r, double g, double b ) = 0;
virtual void SetCellsFontProperties( SMESH::LabelFont family, int size, virtual void SetCellsFontProperties( SMESH::LabelFont family, int size,
bool bold, bool italic, bool shadow, bool bold, bool italic, bool shadow,
vtkFloatingPointType r, vtkFloatingPointType g, vtkFloatingPointType b ) = 0; double r, double g, double b ) = 0;
#ifndef DISABLE_PLOT2DVIEWER #ifndef DISABLE_PLOT2DVIEWER
virtual SPlot2d_Histogram* GetPlot2Histogram() = 0; virtual SPlot2d_Histogram* GetPlot2Histogram() = 0;

76
src/OBJECT/SMESH_ActorDef.h
View File

@ -100,51 +100,51 @@ class SMESH_ActorDef : public SMESH_Actor
virtual bool IsInfinitive(); virtual bool IsInfinitive();
virtual void SetOpacity(vtkFloatingPointType theValue); virtual void SetOpacity(double theValue);
virtual vtkFloatingPointType GetOpacity(); virtual double GetOpacity();
virtual void SetSufaceColor(vtkFloatingPointType r,vtkFloatingPointType g,vtkFloatingPointType b, int delta ); virtual void SetSufaceColor(double r,double g,double b, int delta );
virtual void GetSufaceColor(vtkFloatingPointType& r,vtkFloatingPointType& g,vtkFloatingPointType& b, int& delta); virtual void GetSufaceColor(double& r,double& g,double& b, int& delta);
virtual void SetVolumeColor(vtkFloatingPointType r,vtkFloatingPointType g,vtkFloatingPointType b, int delta ); virtual void SetVolumeColor(double r,double g,double b, int delta );
virtual void GetVolumeColor(vtkFloatingPointType& r,vtkFloatingPointType& g,vtkFloatingPointType& b, int& delta); virtual void GetVolumeColor(double& r,double& g,double& b, int& delta);
virtual void SetEdgeColor(vtkFloatingPointType r,vtkFloatingPointType g,vtkFloatingPointType b); virtual void SetEdgeColor(double r,double g,double b);
virtual void GetEdgeColor(vtkFloatingPointType& r,vtkFloatingPointType& g,vtkFloatingPointType& b); virtual void GetEdgeColor(double& r,double& g,double& b);
virtual void SetOutlineColor(vtkFloatingPointType r,vtkFloatingPointType g,vtkFloatingPointType b); virtual void SetOutlineColor(double r,double g,double b);
virtual void GetOutlineColor(vtkFloatingPointType& r,vtkFloatingPointType& g,vtkFloatingPointType& b); virtual void GetOutlineColor(double& r,double& g,double& b);
virtual void SetNodeColor(vtkFloatingPointType r,vtkFloatingPointType g,vtkFloatingPointType b); virtual void SetNodeColor(double r,double g,double b);
virtual void GetNodeColor(vtkFloatingPointType& r,vtkFloatingPointType& g,vtkFloatingPointType& b); virtual void GetNodeColor(double& r,double& g,double& b);
virtual void Set0DColor(vtkFloatingPointType r,vtkFloatingPointType g,vtkFloatingPointType b); virtual void Set0DColor(double r,double g,double b);
virtual void Get0DColor(vtkFloatingPointType& r,vtkFloatingPointType& g,vtkFloatingPointType& b); virtual void Get0DColor(double& r,double& g,double& b);
virtual void SetBallColor(vtkFloatingPointType r,vtkFloatingPointType g,vtkFloatingPointType b); virtual void SetBallColor(double r,double g,double b);
virtual void GetBallColor(vtkFloatingPointType& r,vtkFloatingPointType& g,vtkFloatingPointType& b); virtual void GetBallColor(double& r,double& g,double& b);
virtual void SetHighlightColor(vtkFloatingPointType r,vtkFloatingPointType g,vtkFloatingPointType b); virtual void SetHighlightColor(double r,double g,double b);
virtual void GetHighlightColor(vtkFloatingPointType& r,vtkFloatingPointType& g,vtkFloatingPointType& b); virtual void GetHighlightColor(double& r,double& g,double& b);
virtual void SetPreHighlightColor(vtkFloatingPointType r,vtkFloatingPointType g,vtkFloatingPointType b); virtual void SetPreHighlightColor(double r,double g,double b);
virtual void GetPreHighlightColor(vtkFloatingPointType& r,vtkFloatingPointType& g,vtkFloatingPointType& b); virtual void GetPreHighlightColor(double& r,double& g,double& b);
virtual vtkFloatingPointType GetLineWidth(); virtual double GetLineWidth();
virtual void SetLineWidth(vtkFloatingPointType theVal); virtual void SetLineWidth(double theVal);
virtual vtkFloatingPointType GetOutlineWidth(); virtual double GetOutlineWidth();
virtual void SetOutlineWidth(vtkFloatingPointType theVal); virtual void SetOutlineWidth(double theVal);
virtual void Set0DSize(vtkFloatingPointType size); virtual void Set0DSize(double size);
virtual vtkFloatingPointType Get0DSize(); virtual double Get0DSize();
virtual void SetBallSize(vtkFloatingPointType size); virtual void SetBallSize(double size);
virtual vtkFloatingPointType GetBallSize(); virtual double GetBallSize();
virtual int GetNodeObjId(int theVtkID); virtual int GetNodeObjId(int theVtkID);
virtual vtkFloatingPointType* GetNodeCoord(int theObjID); virtual double* GetNodeCoord(int theObjID);
virtual int GetElemObjId(int theVtkID); virtual int GetElemObjId(int theVtkID);
virtual vtkCell* GetElemCell(int theObjID); virtual vtkCell* GetElemCell(int theObjID);
@ -162,15 +162,15 @@ class SMESH_ActorDef : public SMESH_Actor
virtual void SetPointRepresentation(bool theIsPointsVisible); virtual void SetPointRepresentation(bool theIsPointsVisible);
virtual bool GetPointRepresentation(); virtual bool GetPointRepresentation();
virtual vtkFloatingPointType* GetBounds(); virtual double* GetBounds();
virtual void SetTransform(VTKViewer_Transform* theTransform); virtual void SetTransform(VTKViewer_Transform* theTransform);
virtual vtkUnstructuredGrid* GetUnstructuredGrid(); virtual vtkUnstructuredGrid* GetUnstructuredGrid();
virtual vtkDataSet* GetInput(); virtual vtkDataSet* GetInput();
virtual vtkMapper* GetMapper(); virtual vtkMapper* GetMapper();
virtual vtkFloatingPointType GetShrinkFactor(); virtual double GetShrinkFactor();
virtual void SetShrinkFactor(vtkFloatingPointType theValue); virtual void SetShrinkFactor(double theValue);
virtual bool IsShrunkable() { return myIsShrinkable;} virtual bool IsShrunkable() { return myIsShrinkable;}
virtual bool IsShrunk() { return myIsShrunk;} virtual bool IsShrunk() { return myIsShrunk;}
@ -182,10 +182,10 @@ class SMESH_ActorDef : public SMESH_Actor
virtual void SetPointsFontProperties( SMESH::LabelFont family, int size, virtual void SetPointsFontProperties( SMESH::LabelFont family, int size,
bool bold, bool italic, bool shadow, bool bold, bool italic, bool shadow,
vtkFloatingPointType r, vtkFloatingPointType g, vtkFloatingPointType b ); double r, double g, double b );
virtual void SetCellsFontProperties( SMESH::LabelFont family, int size, virtual void SetCellsFontProperties( SMESH::LabelFont family, int size,
bool bold, bool italic, bool shadow, bool bold, bool italic, bool shadow,
vtkFloatingPointType r, vtkFloatingPointType g, vtkFloatingPointType b ); double r, double g, double b );
virtual void SetCellsLabeled(bool theIsCellsLabeled); virtual void SetCellsLabeled(bool theIsCellsLabeled);
virtual bool GetCellsLabeled(); virtual bool GetCellsLabeled();
@ -193,11 +193,11 @@ class SMESH_ActorDef : public SMESH_Actor
virtual void SetFacesOriented(bool theIsFacesOriented); virtual void SetFacesOriented(bool theIsFacesOriented);
virtual bool GetFacesOriented(); virtual bool GetFacesOriented();
virtual void SetFacesOrientationColor(vtkFloatingPointType r,vtkFloatingPointType g,vtkFloatingPointType b); virtual void SetFacesOrientationColor(double r,double g,double b);
virtual void GetFacesOrientationColor(vtkFloatingPointType& r,vtkFloatingPointType& g,vtkFloatingPointType& b); virtual void GetFacesOrientationColor(double& r,double& g,double& b);
virtual void SetFacesOrientationScale(vtkFloatingPointType theScale); virtual void SetFacesOrientationScale(double theScale);
virtual vtkFloatingPointType GetFacesOrientationScale(); virtual double GetFacesOrientationScale();
virtual void SetFacesOrientation3DVectors(bool theState); virtual void SetFacesOrientation3DVectors(bool theState);
virtual bool GetFacesOrientation3DVectors(); virtual bool GetFacesOrientation3DVectors();

22
src/OBJECT/SMESH_ActorUtils.cxx
View File

@ -55,12 +55,12 @@
namespace SMESH namespace SMESH
{ {
vtkFloatingPointType double
GetFloat( const QString& theValue, GetFloat( const QString& theValue,
vtkFloatingPointType theDefault ) double theDefault )
{ {
int pos = theValue.indexOf( ":" ); int pos = theValue.indexOf( ":" );
vtkFloatingPointType val = theDefault; double val = theDefault;
if( pos>=0 ) if( pos>=0 )
{ {
QString name = theValue.right( theValue.length()-pos-1 ), QString name = theValue.right( theValue.length()-pos-1 ),
@ -71,15 +71,15 @@ namespace SMESH
return val; return val;
} }
vtkFloatingPointType double
GetFloat( const QString& theValue, GetFloat( const QString& theValue,
const QString& theSection, const QString& theSection,
vtkFloatingPointType theDefault ) double theDefault )
{ {
vtkFloatingPointType val = theDefault; double val = theDefault;
SUIT_ResourceMgr* mgr = SUIT_Session::session()->resourceMgr(); SUIT_ResourceMgr* mgr = SUIT_Session::session()->resourceMgr();
if( mgr ) if( mgr )
val = (vtkFloatingPointType) mgr->doubleValue( theSection, theValue, theDefault ); val = (double) mgr->doubleValue( theSection, theValue, theDefault );
return val; return val;
} }
@ -90,7 +90,7 @@ namespace SMESH
{ {
vtkXMLUnstructuredGridWriter* aWriter = vtkXMLUnstructuredGridWriter::New(); vtkXMLUnstructuredGridWriter* aWriter = vtkXMLUnstructuredGridWriter::New();
aWriter->SetFileName(theFileName); aWriter->SetFileName(theFileName);
aWriter->SetInput(theGrid); aWriter->SetInputData(theGrid);
aWriter->SetDataModeToAscii(); aWriter->SetDataModeToAscii();
if(theGrid->GetNumberOfCells()){ if(theGrid->GetNumberOfCells()){
aWriter->Write(); aWriter->Write();
@ -129,9 +129,9 @@ namespace SMESH
void void
GetColor( const QString& theSect, GetColor( const QString& theSect,
const QString& theName, const QString& theName,
vtkFloatingPointType& r, double& r,
vtkFloatingPointType& g, double& g,
vtkFloatingPointType& b, double& b,
const QColor& def ) const QColor& def )
{ {
int ir( 0 ), ig( 0 ), ib( 0 ); int ir( 0 ), ig( 0 ), ib( 0 );

14
src/OBJECT/SMESH_ActorUtils.h
View File

@ -41,15 +41,15 @@ namespace SMESH
}; };
SMESHOBJECT_EXPORT SMESHOBJECT_EXPORT
vtkFloatingPointType double
GetFloat( const QString& theValue, GetFloat( const QString& theValue,
vtkFloatingPointType theDefault = 0 ); double theDefault = 0 );
SMESHOBJECT_EXPORT SMESHOBJECT_EXPORT
vtkFloatingPointType double
GetFloat( const QString& theName, GetFloat( const QString& theName,
const QString& theSection, const QString& theSection,
vtkFloatingPointType theDefault = 0 ); double theDefault = 0 );
SMESHOBJECT_EXPORT SMESHOBJECT_EXPORT
QColor QColor
@ -70,9 +70,9 @@ SMESHOBJECT_EXPORT
void void
GetColor( const QString& theSect, GetColor( const QString& theSect,
const QString& theName, const QString& theName,
vtkFloatingPointType&, double&,
vtkFloatingPointType&, double&,
vtkFloatingPointType&, double&,
const QColor& = QColor() ); const QColor& = QColor() );
SMESHOBJECT_EXPORT SMESHOBJECT_EXPORT

12
src/OBJECT/SMESH_CellLabelActor.cxx
View File

@ -52,19 +52,19 @@ SMESH_CellLabelActor::SMESH_CellLabelActor() {
myCellsNumDataSet = vtkUnstructuredGrid::New(); myCellsNumDataSet = vtkUnstructuredGrid::New();
myCellCenters = VTKViewer_CellCenters::New(); myCellCenters = VTKViewer_CellCenters::New();
myCellCenters->SetInput(myCellsNumDataSet); myCellCenters->SetInputData(myCellsNumDataSet);
myClsMaskPoints = vtkMaskPoints::New(); myClsMaskPoints = vtkMaskPoints::New();
myClsMaskPoints->SetInput(myCellCenters->GetOutput()); myClsMaskPoints->SetInputConnection(myCellCenters->GetOutputPort());
myClsMaskPoints->SetOnRatio(1); myClsMaskPoints->SetOnRatio(1);
myClsSelectVisiblePoints = vtkSelectVisiblePoints::New(); myClsSelectVisiblePoints = vtkSelectVisiblePoints::New();
myClsSelectVisiblePoints->SetInput(myClsMaskPoints->GetOutput()); myClsSelectVisiblePoints->SetInputConnection(myClsMaskPoints->GetOutputPort());
myClsSelectVisiblePoints->SelectInvisibleOff(); myClsSelectVisiblePoints->SelectInvisibleOff();
myClsSelectVisiblePoints->SetTolerance(0.1); myClsSelectVisiblePoints->SetTolerance(0.1);
myClsLabeledDataMapper = vtkLabeledDataMapper::New(); myClsLabeledDataMapper = vtkLabeledDataMapper::New();
myClsLabeledDataMapper->SetInput(myClsSelectVisiblePoints->GetOutput()); myClsLabeledDataMapper->SetInputConnection(myClsSelectVisiblePoints->GetOutputPort());
myClsLabeledDataMapper->SetLabelFormat("%d"); myClsLabeledDataMapper->SetLabelFormat("%d");
myClsLabeledDataMapper->SetLabelModeToLabelScalars(); myClsLabeledDataMapper->SetLabelModeToLabelScalars();
@ -120,7 +120,7 @@ SMESH_CellLabelActor::~SMESH_CellLabelActor() {
void SMESH_CellLabelActor::SetFontProperties( SMESH::LabelFont family, int size, void SMESH_CellLabelActor::SetFontProperties( SMESH::LabelFont family, int size,
bool bold, bool italic, bool shadow, bool bold, bool italic, bool shadow,
vtkFloatingPointType r, vtkFloatingPointType g, vtkFloatingPointType b ) double r, double g, double b )
{ {
switch ( family ) { switch ( family ) {
case SMESH::FntArial: case SMESH::FntArial:
@ -156,7 +156,7 @@ void SMESH_CellLabelActor::SetCellsLabeled(bool theIsCellsLabeled) {
anArray->SetValue(anId,aSMDSId); anArray->SetValue(anId,aSMDSId);
} }
aDataSet->GetCellData()->SetScalars(anArray); aDataSet->GetCellData()->SetScalars(anArray);
myCellCenters->SetInput(aDataSet); myCellCenters->SetInputData(aDataSet);
myCellsLabels->SetVisibility(GetVisibility()); myCellsLabels->SetVisibility(GetVisibility());
}else{ }else{
myCellsLabels->SetVisibility(false); myCellsLabels->SetVisibility(false);

2
src/OBJECT/SMESH_CellLabelActor.h
View File

@ -62,7 +62,7 @@ public:
virtual void SetFontProperties( SMESH::LabelFont family, int size, virtual void SetFontProperties( SMESH::LabelFont family, int size,
bool bold, bool italic, bool shadow, bool bold, bool italic, bool shadow,
vtkFloatingPointType r, vtkFloatingPointType g, vtkFloatingPointType b ); double r, double g, double b );
void UpdateLabels(); void UpdateLabels();

80
src/OBJECT/SMESH_DeviceActor.cxx
View File

@ -119,13 +119,13 @@ SMESH_DeviceActor
// Orientation of faces // Orientation of faces
myIsFacesOriented = false; myIsFacesOriented = false;
vtkFloatingPointType anRGB[3] = { 1, 1, 1 }; double anRGB[3] = { 1, 1, 1 };
SMESH::GetColor( "SMESH", "orientation_color", anRGB[0], anRGB[1], anRGB[2], QColor( 255, 255, 255 ) ); SMESH::GetColor( "SMESH", "orientation_color", anRGB[0], anRGB[1], anRGB[2], QColor( 255, 255, 255 ) );
myFaceOrientationFilter = SMESH_FaceOrientationFilter::New(); myFaceOrientationFilter = SMESH_FaceOrientationFilter::New();
myFaceOrientationDataMapper = vtkPolyDataMapper::New(); myFaceOrientationDataMapper = vtkPolyDataMapper::New();
myFaceOrientationDataMapper->SetInput(myFaceOrientationFilter->GetOutput()); myFaceOrientationDataMapper->SetInputConnection(myFaceOrientationFilter->GetOutputPort());
myFaceOrientation = vtkActor::New(); myFaceOrientation = vtkActor::New();
myFaceOrientation->SetMapper(myFaceOrientationDataMapper); myFaceOrientation->SetMapper(myFaceOrientationDataMapper);
@ -208,9 +208,9 @@ SMESH_DeviceActor
{ {
int anId = 0; int anId = 0;
if(theIsImplicitFunctionUsed) if(theIsImplicitFunctionUsed)
myPassFilter[ anId ]->SetInput( myExtractGeometry->GetOutput() ); myPassFilter[ anId ]->SetInputConnection( myExtractGeometry->GetOutputPort() );
else else
myPassFilter[ anId ]->SetInput( myMergeFilter->GetOutput() ); myPassFilter[ anId ]->SetInputConnection( myMergeFilter->GetOutputPort() );
myIsImplicitFunctionUsed = theIsImplicitFunctionUsed; myIsImplicitFunctionUsed = theIsImplicitFunctionUsed;
SetStoreClippingMapping(myStoreClippingMapping); SetStoreClippingMapping(myStoreClippingMapping);
@ -225,32 +225,32 @@ SMESH_DeviceActor
//myIsShrinkable = theGrid->GetNumberOfCells() > 10; //myIsShrinkable = theGrid->GetNumberOfCells() > 10;
myIsShrinkable = true; myIsShrinkable = true;
myExtractUnstructuredGrid->SetInput(theGrid); myExtractUnstructuredGrid->SetInputData(theGrid);
myMergeFilter->SetGeometry(myExtractUnstructuredGrid->GetOutput()); myMergeFilter->SetGeometryConnection(myExtractUnstructuredGrid->GetOutputPort());
myExtractGeometry->SetInput(myMergeFilter->GetOutput()); myExtractGeometry->SetInputConnection(myMergeFilter->GetOutputPort());
int anId = 0; int anId = 0;
SetImplicitFunctionUsed(myIsImplicitFunctionUsed); SetImplicitFunctionUsed(myIsImplicitFunctionUsed);
myPassFilter[ anId + 1]->SetInput( myPassFilter[ anId ]->GetOutput() ); myPassFilter[ anId + 1]->SetInputConnection( myPassFilter[ anId ]->GetOutputPort() );
anId++; // 1 anId++; // 1
myTransformFilter->SetInput( myPassFilter[ anId ]->GetOutput() ); myTransformFilter->SetInputConnection( myPassFilter[ anId ]->GetOutputPort() );
anId++; // 2 anId++; // 2
myPassFilter[ anId ]->SetInput( myTransformFilter->GetOutput() ); myPassFilter[ anId ]->SetInputConnection( myTransformFilter->GetOutputPort() );
myPassFilter[ anId + 1 ]->SetInput( myPassFilter[ anId ]->GetOutput() ); myPassFilter[ anId + 1 ]->SetInputConnection( myPassFilter[ anId ]->GetOutputPort() );
anId++; // 3 anId++; // 3
myGeomFilter->SetInput( myPassFilter[ anId ]->GetOutput() ); myGeomFilter->SetInputConnection( myPassFilter[ anId ]->GetOutputPort() );
anId++; // 4 anId++; // 4
myPassFilter[ anId ]->SetInput( myGeomFilter->GetOutput() ); myPassFilter[ anId ]->SetInputConnection( myGeomFilter->GetOutputPort() );
myPassFilter[ anId + 1 ]->SetInput( myPassFilter[ anId ]->GetOutput() ); myPassFilter[ anId + 1 ]->SetInputConnection( myPassFilter[ anId ]->GetOutputPort() );
anId++; // 5 anId++; // 5
myMapper->SetInput( myPassFilter[ anId ]->GetPolyDataOutput() ); myMapper->SetInputConnection( myPassFilter[ anId ]->GetOutputPort() );
vtkLODActor::SetMapper( myMapper ); vtkLODActor::SetMapper( myMapper );
Modified(); Modified();
@ -322,7 +322,7 @@ SMESH_DeviceActor
theLookupTable->SetNumberOfTableValues(theScalarBarActor->GetMaximumNumberOfColors()); theLookupTable->SetNumberOfTableValues(theScalarBarActor->GetMaximumNumberOfColors());
theLookupTable->Build(); theLookupTable->Build();
myMergeFilter->SetScalars(aDataSet); myMergeFilter->SetScalarsData(aDataSet);
aDataSet->Delete(); aDataSet->Delete();
} }
GetMapper()->SetScalarVisibility(anIsInitialized); GetMapper()->SetScalarVisibility(anIsInitialized);
@ -402,7 +402,7 @@ SMESH_DeviceActor
theLookupTable->SetRange(aScalars->GetRange()); theLookupTable->SetRange(aScalars->GetRange());
theLookupTable->Build(); theLookupTable->Build();
myMergeFilter->SetScalars(aDataSet); myMergeFilter->SetScalarsData(aDataSet);
aDataSet->Delete(); aDataSet->Delete();
} }
else if (MultiConnection2D* aMultiConnection2D = dynamic_cast<MultiConnection2D*>(theFunctor.get())){ else if (MultiConnection2D* aMultiConnection2D = dynamic_cast<MultiConnection2D*>(theFunctor.get())){
@ -462,7 +462,7 @@ SMESH_DeviceActor
theLookupTable->SetRange(aScalars->GetRange()); theLookupTable->SetRange(aScalars->GetRange());
theLookupTable->Build(); theLookupTable->Build();
myMergeFilter->SetScalars(aDataSet); myMergeFilter->SetScalarsData(aDataSet);
aDataSet->Delete(); aDataSet->Delete();
} }
} }
@ -600,10 +600,10 @@ SMESH_DeviceActor
::SetShrink() ::SetShrink()
{ {
if ( !myIsShrinkable ) return; if ( !myIsShrinkable ) return;
if ( vtkDataSet* aDataSet = myPassFilter[ 0 ]->GetOutput() ) if ( vtkAlgorithmOutput* aDataSet = myPassFilter[ 0 ]->GetOutputPort() )
{ {
myShrinkFilter->SetInput( aDataSet ); myShrinkFilter->SetInputConnection( aDataSet );
myPassFilter[ 1 ]->SetInput( myShrinkFilter->GetOutput() ); myPassFilter[ 1 ]->SetInputConnection( myShrinkFilter->GetOutputPort() );
myIsShrunk = true; myIsShrunk = true;
} }
} }
@ -613,9 +613,9 @@ SMESH_DeviceActor
::UnShrink() ::UnShrink()
{ {
if ( !myIsShrunk ) return; if ( !myIsShrunk ) return;
if ( vtkDataSet* aDataSet = myPassFilter[ 0 ]->GetOutput() ) if ( vtkAlgorithmOutput* aDataSet = myPassFilter[ 0 ]->GetOutputPort() )
{ {
myPassFilter[ 1 ]->SetInput( aDataSet ); myPassFilter[ 1 ]->SetInputConnection( aDataSet );
myPassFilter[ 1 ]->Modified(); myPassFilter[ 1 ]->Modified();
myIsShrunk = false; myIsShrunk = false;
Modified(); Modified();
@ -627,37 +627,37 @@ void
SMESH_DeviceActor SMESH_DeviceActor
::SetFacesOriented(bool theIsFacesOriented) ::SetFacesOriented(bool theIsFacesOriented)
{ {
if ( vtkDataSet* aDataSet = myTransformFilter->GetOutput() ) if ( vtkAlgorithmOutput* aDataSet = myTransformFilter->GetOutputPort() )
{ {
myIsFacesOriented = theIsFacesOriented; myIsFacesOriented = theIsFacesOriented;
if( theIsFacesOriented ) if( theIsFacesOriented )
myFaceOrientationFilter->SetInput( aDataSet ); myFaceOrientationFilter->SetInputConnection( aDataSet );
UpdateFaceOrientation(); UpdateFaceOrientation();
} }
} }
void void
SMESH_DeviceActor SMESH_DeviceActor
::SetFacesOrientationColor(vtkFloatingPointType r,vtkFloatingPointType g,vtkFloatingPointType b) ::SetFacesOrientationColor(double r,double g,double b)
{ {
myFaceOrientation->GetProperty()->SetColor( r, g, b ); myFaceOrientation->GetProperty()->SetColor( r, g, b );
} }
void void
SMESH_DeviceActor SMESH_DeviceActor
::GetFacesOrientationColor(vtkFloatingPointType& r,vtkFloatingPointType& g,vtkFloatingPointType& b) ::GetFacesOrientationColor(double& r,double& g,double& b)
{ {
myFaceOrientation->GetProperty()->GetColor( r, g, b ); myFaceOrientation->GetProperty()->GetColor( r, g, b );
} }
void void
SMESH_DeviceActor SMESH_DeviceActor
::SetFacesOrientationScale(vtkFloatingPointType theScale) ::SetFacesOrientationScale(double theScale)
{ {
myFaceOrientationFilter->SetOrientationScale( theScale ); myFaceOrientationFilter->SetOrientationScale( theScale );
} }
vtkFloatingPointType double
SMESH_DeviceActor SMESH_DeviceActor
::GetFacesOrientationScale() ::GetFacesOrientationScale()
{ {
@ -780,13 +780,13 @@ SMESH_DeviceActor
return aRetID; return aRetID;
} }
vtkFloatingPointType* double*
SMESH_DeviceActor SMESH_DeviceActor
::GetNodeCoord(int theObjID) ::GetNodeCoord(int theObjID)
{ {
vtkDataSet* aDataSet = myMergeFilter->GetOutput(); vtkDataSet* aDataSet = myMergeFilter->GetOutput();
vtkIdType anID = myVisualObj->GetNodeVTKId(theObjID); vtkIdType anID = myVisualObj->GetNodeVTKId(theObjID);
vtkFloatingPointType* aCoord = (anID >=0) ? aDataSet->GetPoint(anID) : NULL; double* aCoord = (anID >=0) ? aDataSet->GetPoint(anID) : NULL;
if(MYDEBUG) MESSAGE("GetNodeCoord - theObjID = "<<theObjID<<"; anID = "<<anID); if(MYDEBUG) MESSAGE("GetNodeCoord - theObjID = "<<theObjID<<"; anID = "<<anID);
return aCoord; return aCoord;
} }
@ -829,7 +829,7 @@ SMESH_DeviceActor
} }
vtkFloatingPointType double
SMESH_DeviceActor SMESH_DeviceActor
::GetShrinkFactor() ::GetShrinkFactor()
{ {
@ -838,7 +838,7 @@ SMESH_DeviceActor
void void
SMESH_DeviceActor SMESH_DeviceActor
::SetShrinkFactor(vtkFloatingPointType theValue) ::SetShrinkFactor(double theValue)
{ {
theValue = theValue > 0.1? theValue: 0.8; theValue = theValue > 0.1? theValue: 0.8;
myShrinkFilter->SetShrinkFactor(theValue); myShrinkFilter->SetShrinkFactor(theValue);
@ -861,13 +861,13 @@ SMESH_DeviceActor
::Render(vtkRenderer *ren, vtkMapper* m) ::Render(vtkRenderer *ren, vtkMapper* m)
{ {
int aResolveCoincidentTopology = vtkMapper::GetResolveCoincidentTopology(); int aResolveCoincidentTopology = vtkMapper::GetResolveCoincidentTopology();
vtkFloatingPointType aStoredFactor, aStoredUnit; double aStoredFactor, aStoredUnit;
vtkMapper::GetResolveCoincidentTopologyPolygonOffsetParameters(aStoredFactor,aStoredUnit); vtkMapper::GetResolveCoincidentTopologyPolygonOffsetParameters(aStoredFactor,aStoredUnit);
vtkMapper::SetResolveCoincidentTopologyToPolygonOffset(); vtkMapper::SetResolveCoincidentTopologyToPolygonOffset();
vtkFloatingPointType aFactor = myPolygonOffsetFactor, aUnits = myPolygonOffsetUnits; double aFactor = myPolygonOffsetFactor, aUnits = myPolygonOffsetUnits;
if(myIsHighlited){ if(myIsHighlited){
static vtkFloatingPointType EPS = .01; static double EPS = .01;
aUnits *= (1.0-EPS); aUnits *= (1.0-EPS);
} }
vtkMapper::SetResolveCoincidentTopologyPolygonOffsetParameters(aFactor,aUnits); vtkMapper::SetResolveCoincidentTopologyPolygonOffsetParameters(aFactor,aUnits);
@ -880,8 +880,8 @@ SMESH_DeviceActor
void void
SMESH_DeviceActor SMESH_DeviceActor
::SetPolygonOffsetParameters(vtkFloatingPointType factor, ::SetPolygonOffsetParameters(double factor,
vtkFloatingPointType units) double units)
{ {
myPolygonOffsetFactor = factor; myPolygonOffsetFactor = factor;
myPolygonOffsetUnits = units; myPolygonOffsetUnits = units;
@ -903,14 +903,14 @@ bool SMESH_DeviceActor::GetQuadraticArcMode(){
/*! /*!
* Set Max angle for representation 2D quadratic element as arked polygon * Set Max angle for representation 2D quadratic element as arked polygon
*/ */
void SMESH_DeviceActor::SetQuadraticArcAngle(vtkFloatingPointType theMaxAngle){ void SMESH_DeviceActor::SetQuadraticArcAngle(double theMaxAngle){
myGeomFilter->SetQuadraticArcAngle(theMaxAngle); myGeomFilter->SetQuadraticArcAngle(theMaxAngle);
} }
/*! /*!
* Return Max angle of the representation 2D quadratic element as arked polygon * Return Max angle of the representation 2D quadratic element as arked polygon
*/ */
vtkFloatingPointType SMESH_DeviceActor::GetQuadraticArcAngle(){ double SMESH_DeviceActor::GetQuadraticArcAngle(){
return myGeomFilter->GetQuadraticArcAngle(); return myGeomFilter->GetQuadraticArcAngle();
} }

30
src/OBJECT/SMESH_DeviceActor.h
View File

@ -68,7 +68,7 @@ class SMESHOBJECT_EXPORT SMESH_DeviceActor: public vtkLODActor{
void SetStoreIDMapping(bool theStoreMapping); void SetStoreIDMapping(bool theStoreMapping);
virtual int GetNodeObjId(int theVtkID); virtual int GetNodeObjId(int theVtkID);
virtual vtkFloatingPointType* GetNodeCoord(int theObjID); virtual double* GetNodeCoord(int theObjID);
virtual int GetElemObjId(int theVtkID); virtual int GetElemObjId(int theVtkID);
virtual vtkCell* GetElemCell(int theObjID); virtual vtkCell* GetElemCell(int theObjID);
@ -79,11 +79,11 @@ class SMESHOBJECT_EXPORT SMESH_DeviceActor: public vtkLODActor{
virtual void SetFacesOriented(bool theIsFacesOriented); virtual void SetFacesOriented(bool theIsFacesOriented);
virtual bool GetFacesOriented() { return myIsFacesOriented; } virtual bool GetFacesOriented() { return myIsFacesOriented; }
virtual void SetFacesOrientationColor(vtkFloatingPointType r,vtkFloatingPointType g,vtkFloatingPointType b); virtual void SetFacesOrientationColor(double r,double g,double b);
virtual void GetFacesOrientationColor(vtkFloatingPointType& r,vtkFloatingPointType& g,vtkFloatingPointType& b); virtual void GetFacesOrientationColor(double& r,double& g,double& b);
virtual void SetFacesOrientationScale(vtkFloatingPointType theScale); virtual void SetFacesOrientationScale(double theScale);
virtual vtkFloatingPointType GetFacesOrientationScale(); virtual double GetFacesOrientationScale();
virtual void SetFacesOrientation3DVectors(bool theState); virtual void SetFacesOrientation3DVectors(bool theState);
virtual bool GetFacesOrientation3DVectors(); virtual bool GetFacesOrientation3DVectors();
@ -93,13 +93,13 @@ class SMESHOBJECT_EXPORT SMESH_DeviceActor: public vtkLODActor{
virtual void SetQuadraticArcMode(bool theFlag); virtual void SetQuadraticArcMode(bool theFlag);
virtual bool GetQuadraticArcMode(); virtual bool GetQuadraticArcMode();
virtual void SetQuadraticArcAngle(vtkFloatingPointType theMaxAngle); virtual void SetQuadraticArcAngle(double theMaxAngle);
virtual vtkFloatingPointType GetQuadraticArcAngle(); virtual double GetQuadraticArcAngle();
void UpdateFaceOrientation(); void UpdateFaceOrientation();
vtkFloatingPointType GetShrinkFactor(); double GetShrinkFactor();
void SetShrinkFactor(vtkFloatingPointType value); void SetShrinkFactor(double value);
bool IsShrunkable() { return myIsShrinkable;} bool IsShrunkable() { return myIsShrinkable;}
bool IsShrunk() { return myIsShrunk;} bool IsShrunk() { return myIsShrunk;}
@ -182,16 +182,16 @@ class SMESHOBJECT_EXPORT SMESH_DeviceActor: public vtkLODActor{
bool myIsHighlited; bool myIsHighlited;
vtkFloatingPointType myPolygonOffsetFactor; double myPolygonOffsetFactor;
vtkFloatingPointType myPolygonOffsetUnits; double myPolygonOffsetUnits;
void void
SetPolygonOffsetParameters(vtkFloatingPointType factor, SetPolygonOffsetParameters(double factor,
vtkFloatingPointType units); double units);
void void
GetPolygonOffsetParameters(vtkFloatingPointType& factor, GetPolygonOffsetParameters(double& factor,
vtkFloatingPointType& units) double& units)
{ {
factor = myPolygonOffsetFactor; factor = myPolygonOffsetFactor;
units = myPolygonOffsetUnits; units = myPolygonOffsetUnits;

6
src/OBJECT/SMESH_ExtractGeometry.cxx
View File

@ -89,8 +89,8 @@ int SMESH_ExtractGeometry::RequestData(
vtkIdList *cellPts; vtkIdList *cellPts;
vtkCell *cell; vtkCell *cell;
int numCellPts; int numCellPts;
vtkFloatingPointType *x; double *x;
vtkFloatingPointType multiplier; double multiplier;
vtkPoints *newPts; vtkPoints *newPts;
vtkIdList *newCellPts; vtkIdList *newCellPts;
vtkPointData *pd = input->GetPointData(); vtkPointData *pd = input->GetPointData();
@ -163,7 +163,7 @@ int SMESH_ExtractGeometry::RequestData(
// To extract boundary cells, we have to create supplemental information // To extract boundary cells, we have to create supplemental information
if ( this->ExtractBoundaryCells ) if ( this->ExtractBoundaryCells )
{ {
vtkFloatingPointType val; double val;
newScalars = vtkFloatArray::New(); newScalars = vtkFloatArray::New();
newScalars->SetNumberOfValues(numPts); newScalars->SetNumberOfValues(numPts);

19
src/OBJECT/SMESH_FaceOrientationFilter.cxx
View File

@ -42,7 +42,6 @@
#define PI 3.14159265359 #define PI 3.14159265359
vtkCxxRevisionMacro(SMESH_FaceOrientationFilter, "$Revision$");
vtkStandardNewMacro(SMESH_FaceOrientationFilter); vtkStandardNewMacro(SMESH_FaceOrientationFilter);
/*! /*!
@ -61,10 +60,10 @@ SMESH_FaceOrientationFilter::SMESH_FaceOrientationFilter()
myFacePolyData = vtkPolyData::New(); myFacePolyData = vtkPolyData::New();
myFaceCenters = VTKViewer_CellCenters::New(); myFaceCenters = VTKViewer_CellCenters::New();
myFaceCenters->SetInput(myFacePolyData); myFaceCenters->SetInputData(myFacePolyData);
myFaceMaskPoints = vtkMaskPoints::New(); myFaceMaskPoints = vtkMaskPoints::New();
myFaceMaskPoints->SetInput(myFaceCenters->GetOutput()); myFaceMaskPoints->SetInputConnection(myFaceCenters->GetOutputPort());
myFaceMaskPoints->SetOnRatio(1); myFaceMaskPoints->SetOnRatio(1);
myGlyphSource = vtkGlyphSource2D::New(); myGlyphSource = vtkGlyphSource2D::New();
@ -73,11 +72,14 @@ SMESH_FaceOrientationFilter::SMESH_FaceOrientationFilter()
myGlyphSource->SetCenter(0.5, 0.0, 0.0); myGlyphSource->SetCenter(0.5, 0.0, 0.0);
myBaseGlyph = vtkGlyph3D::New(); myBaseGlyph = vtkGlyph3D::New();
myBaseGlyph->SetInput(myFaceMaskPoints->GetOutput()); myBaseGlyph->SetInputConnection(myFaceMaskPoints->GetOutputPort());
myBaseGlyph->SetVectorModeToUseVector(); myBaseGlyph->SetVectorModeToUseVector();
myBaseGlyph->SetScaleModeToDataScalingOff(); myBaseGlyph->SetScaleModeToDataScalingOff();
myBaseGlyph->SetColorModeToColorByScalar(); myBaseGlyph->SetColorModeToColorByScalar();
myBaseGlyph->SetSource(my3dVectors ? myArrowPolyData : myGlyphSource->GetOutput()); if( my3dVectors )
myBaseGlyph->SetSourceData(myArrowPolyData);
else
myBaseGlyph->SetSourceConnection(myGlyphSource->GetOutputPort());
} }
SMESH_FaceOrientationFilter::~SMESH_FaceOrientationFilter() SMESH_FaceOrientationFilter::~SMESH_FaceOrientationFilter()
@ -90,7 +92,7 @@ SMESH_FaceOrientationFilter::~SMESH_FaceOrientationFilter()
myBaseGlyph->Delete(); myBaseGlyph->Delete();
} }
void SMESH_FaceOrientationFilter::SetOrientationScale( vtkFloatingPointType theScale ) void SMESH_FaceOrientationFilter::SetOrientationScale( double theScale )
{ {
myOrientationScale = theScale; myOrientationScale = theScale;
Modified(); Modified();
@ -99,7 +101,10 @@ void SMESH_FaceOrientationFilter::SetOrientationScale( vtkFloatingPointType theS
void SMESH_FaceOrientationFilter::Set3dVectors( bool theState ) void SMESH_FaceOrientationFilter::Set3dVectors( bool theState )
{ {
my3dVectors = theState; my3dVectors = theState;
myBaseGlyph->SetSource(my3dVectors ? myArrowPolyData : myGlyphSource->GetOutput()); if( my3dVectors )
myBaseGlyph->SetSourceData(myArrowPolyData);
else
myBaseGlyph->SetSourceConnection(myGlyphSource->GetOutputPort());
Modified(); Modified();
} }

8
src/OBJECT/SMESH_FaceOrientationFilter.h
View File

@ -33,13 +33,13 @@ class VTKViewer_CellCenters;
class SMESHOBJECT_EXPORT SMESH_FaceOrientationFilter : public vtkPolyDataAlgorithm class SMESHOBJECT_EXPORT SMESH_FaceOrientationFilter : public vtkPolyDataAlgorithm
{ {
public: public:
vtkTypeRevisionMacro( SMESH_FaceOrientationFilter, vtkPolyDataAlgorithm ); vtkTypeMacro( SMESH_FaceOrientationFilter, vtkPolyDataAlgorithm );
/*!Create a new SMESH_FaceOrientationFilter.*/ /*!Create a new SMESH_FaceOrientationFilter.*/
static SMESH_FaceOrientationFilter *New(); static SMESH_FaceOrientationFilter *New();
void SetOrientationScale( vtkFloatingPointType ); void SetOrientationScale( double );
vtkFloatingPointType GetOrientationScale() const { return myOrientationScale; } double GetOrientationScale() const { return myOrientationScale; }
void Set3dVectors( bool ); void Set3dVectors( bool );
bool Get3dVectors() const { return my3dVectors; } bool Get3dVectors() const { return my3dVectors; }
@ -61,7 +61,7 @@ private:
private: private:
bool my3dVectors; bool my3dVectors;
vtkFloatingPointType myOrientationScale; double myOrientationScale;
vtkPolyData* myArrowPolyData; vtkPolyData* myArrowPolyData;
vtkPolyData* myFacePolyData; vtkPolyData* myFacePolyData;
VTKViewer_CellCenters* myFaceCenters; VTKViewer_CellCenters* myFaceCenters;

10
src/OBJECT/SMESH_NodeLabelActor.cxx
View File

@ -50,16 +50,16 @@ SMESH_NodeLabelActor::SMESH_NodeLabelActor() {
myPointsNumDataSet = vtkUnstructuredGrid::New(); myPointsNumDataSet = vtkUnstructuredGrid::New();
myPtsMaskPoints = vtkMaskPoints::New(); myPtsMaskPoints = vtkMaskPoints::New();
myPtsMaskPoints->SetInput(myPointsNumDataSet); myPtsMaskPoints->SetInputData(myPointsNumDataSet);
myPtsMaskPoints->SetOnRatio(1); myPtsMaskPoints->SetOnRatio(1);
myPtsSelectVisiblePoints = vtkSelectVisiblePoints::New(); myPtsSelectVisiblePoints = vtkSelectVisiblePoints::New();
myPtsSelectVisiblePoints->SetInput(myPtsMaskPoints->GetOutput()); myPtsSelectVisiblePoints->SetInputConnection(myPtsMaskPoints->GetOutputPort());
myPtsSelectVisiblePoints->SelectInvisibleOff(); myPtsSelectVisiblePoints->SelectInvisibleOff();
myPtsSelectVisiblePoints->SetTolerance(0.1); myPtsSelectVisiblePoints->SetTolerance(0.1);
myPtsLabeledDataMapper = vtkLabeledDataMapper::New(); myPtsLabeledDataMapper = vtkLabeledDataMapper::New();
myPtsLabeledDataMapper->SetInput(myPtsSelectVisiblePoints->GetOutput()); myPtsLabeledDataMapper->SetInputConnection(myPtsSelectVisiblePoints->GetOutputPort());
myPtsLabeledDataMapper->SetLabelFormat("%d"); myPtsLabeledDataMapper->SetLabelFormat("%d");
myPtsLabeledDataMapper->SetLabelModeToLabelScalars(); myPtsLabeledDataMapper->SetLabelModeToLabelScalars();
@ -112,7 +112,7 @@ SMESH_NodeLabelActor::~SMESH_NodeLabelActor() {
void SMESH_NodeLabelActor::SetFontProperties( SMESH::LabelFont family, int size, void SMESH_NodeLabelActor::SetFontProperties( SMESH::LabelFont family, int size,
bool bold, bool italic, bool shadow, bool bold, bool italic, bool shadow,
vtkFloatingPointType r, vtkFloatingPointType g, vtkFloatingPointType b ) double r, double g, double b )
{ {
switch ( family ) { switch ( family ) {
case SMESH::FntArial: case SMESH::FntArial:
@ -156,7 +156,7 @@ void SMESH_NodeLabelActor::SetPointsLabeled(bool theIsPointsLabeled) {
} }
aDataSet->GetPointData()->SetScalars( anArray ); aDataSet->GetPointData()->SetScalars( anArray );
myPtsMaskPoints->SetInput( aDataSet ); myPtsMaskPoints->SetInputData( aDataSet );
myPointLabels->SetVisibility( GetVisibility() ); myPointLabels->SetVisibility( GetVisibility() );
anArray->Delete(); anArray->Delete();
} }

2
src/OBJECT/SMESH_NodeLabelActor.h
View File

@ -59,7 +59,7 @@ public:
virtual void SetFontProperties( SMESH::LabelFont family, int size, virtual void SetFontProperties( SMESH::LabelFont family, int size,
bool bold, bool italic, bool shadow, bool bold, bool italic, bool shadow,
vtkFloatingPointType r, vtkFloatingPointType g, vtkFloatingPointType b ); double r, double g, double b );
void UpdateLabels(); void UpdateLabels();

4
src/OBJECT/SMESH_ScalarBarActor.cxx
View File

@ -88,7 +88,7 @@ SMESH_ScalarBarActor::SMESH_ScalarBarActor() {
this->ScalarBar = vtkPolyData::New(); this->ScalarBar = vtkPolyData::New();
this->ScalarBarMapper = vtkPolyDataMapper2D::New(); this->ScalarBarMapper = vtkPolyDataMapper2D::New();
this->ScalarBarMapper->SetInput(this->ScalarBar); this->ScalarBarMapper->SetInputData(this->ScalarBar);
this->ScalarBarActor = vtkActor2D::New(); this->ScalarBarActor = vtkActor2D::New();
this->ScalarBarActor->SetMapper(this->ScalarBarMapper); this->ScalarBarActor->SetMapper(this->ScalarBarMapper);
this->ScalarBarActor->GetPositionCoordinate()-> this->ScalarBarActor->GetPositionCoordinate()->
@ -103,7 +103,7 @@ SMESH_ScalarBarActor::SMESH_ScalarBarActor() {
// Customization of the vtkScalarBarActor to show distribution histogram. // Customization of the vtkScalarBarActor to show distribution histogram.
myDistribution = vtkPolyData::New(); myDistribution = vtkPolyData::New();
myDistributionMapper = vtkPolyDataMapper2D::New(); myDistributionMapper = vtkPolyDataMapper2D::New();
myDistributionMapper->SetInput(this->myDistribution); myDistributionMapper->SetInputData(this->myDistribution);
myDistributionActor = vtkActor2D::New(); myDistributionActor = vtkActor2D::New();
myDistributionActor->SetMapper(this->myDistributionMapper); myDistributionActor->SetMapper(this->myDistributionMapper);

69
src/SMDS/SMDS_MeshInfo.hxx
View File

@ -39,8 +39,12 @@ public:
inline SMDS_MeshInfo& operator=(const SMDS_MeshInfo& other); inline SMDS_MeshInfo& operator=(const SMDS_MeshInfo& other);
inline void Clear(); inline void Clear();
inline int NbElements(SMDSAbs_ElementType type=SMDSAbs_All) const; inline int NbElements(SMDSAbs_ElementType type=SMDSAbs_All) const;
inline int NbElements(SMDSAbs_EntityType type) const { return NbEntities(type); }
inline int NbElements(SMDSAbs_GeometryType type) const { return NbElementsOfGeom(type); }
inline int NbEntities(SMDSAbs_EntityType type) const; inline int NbEntities(SMDSAbs_EntityType type) const;
inline int NbElementsOfGeom(SMDSAbs_GeometryType geom) const;
int NbNodes() const { return myNbNodes; } int NbNodes() const { return myNbNodes; }
int Nb0DElements() const { return myNb0DElements; } int Nb0DElements() const { return myNb0DElements; }
@ -230,47 +234,47 @@ inline void // RemoveVolume
SMDS_MeshInfo::RemoveVolume(const SMDS_MeshElement* el) SMDS_MeshInfo::RemoveVolume(const SMDS_MeshElement* el)
{ if ( el->IsPoly() ) --myNbPolyhedrons; else remove( el ); } { if ( el->IsPoly() ) --myNbPolyhedrons; else remove( el ); }
inline int // NbEdges inline int // NbEdges
SMDS_MeshInfo::NbEdges (SMDSAbs_ElementOrder order) const SMDS_MeshInfo::NbEdges (SMDSAbs_ElementOrder order) const
{ return order == ORDER_ANY ? myNbEdges+myNbQuadEdges : order == ORDER_LINEAR ? myNbEdges : myNbQuadEdges; } { return order == ORDER_ANY ? myNbEdges+myNbQuadEdges : order == ORDER_LINEAR ? myNbEdges : myNbQuadEdges; }
inline int // NbFaces inline int // NbFaces
SMDS_MeshInfo::NbFaces (SMDSAbs_ElementOrder order) const SMDS_MeshInfo::NbFaces (SMDSAbs_ElementOrder order) const
{ return NbTriangles(order)+NbQuadrangles(order)+(order == ORDER_QUADRATIC ? 0 : myNbPolygons); } { return NbTriangles(order)+NbQuadrangles(order)+(order == ORDER_QUADRATIC ? 0 : myNbPolygons); }
inline int // NbTriangles inline int // NbTriangles
SMDS_MeshInfo::NbTriangles (SMDSAbs_ElementOrder order) const SMDS_MeshInfo::NbTriangles (SMDSAbs_ElementOrder order) const
{ return order == ORDER_ANY ? myNbTriangles+myNbQuadTriangles : order == ORDER_LINEAR ? myNbTriangles : myNbQuadTriangles; } { return order == ORDER_ANY ? myNbTriangles+myNbQuadTriangles : order == ORDER_LINEAR ? myNbTriangles : myNbQuadTriangles; }
inline int // NbQuadrangles inline int // NbQuadrangles
SMDS_MeshInfo::NbQuadrangles(SMDSAbs_ElementOrder order) const SMDS_MeshInfo::NbQuadrangles(SMDSAbs_ElementOrder order) const
{ return order == ORDER_ANY ? myNbQuadrangles+myNbQuadQuadrangles+myNbBiQuadQuadrangles : order == ORDER_LINEAR ? myNbQuadrangles : myNbQuadQuadrangles+myNbBiQuadQuadrangles; } { return order == ORDER_ANY ? myNbQuadrangles+myNbQuadQuadrangles+myNbBiQuadQuadrangles : order == ORDER_LINEAR ? myNbQuadrangles : myNbQuadQuadrangles+myNbBiQuadQuadrangles; }
inline int // NbVolumes inline int // NbVolumes
SMDS_MeshInfo::NbVolumes (SMDSAbs_ElementOrder order) const SMDS_MeshInfo::NbVolumes (SMDSAbs_ElementOrder order) const
{ return NbTetras(order) + NbHexas(order) + NbPyramids(order) + NbPrisms(order) + NbHexPrisms(order) + (order == ORDER_QUADRATIC ? 0 : myNbPolyhedrons); } { return NbTetras(order) + NbHexas(order) + NbPyramids(order) + NbPrisms(order) + NbHexPrisms(order) + (order == ORDER_QUADRATIC ? 0 : myNbPolyhedrons); }
inline int // NbTetras inline int // NbTetras
SMDS_MeshInfo::NbTetras (SMDSAbs_ElementOrder order) const SMDS_MeshInfo::NbTetras (SMDSAbs_ElementOrder order) const
{ return order == ORDER_ANY ? myNbTetras+myNbQuadTetras : order == ORDER_LINEAR ? myNbTetras : myNbQuadTetras; } { return order == ORDER_ANY ? myNbTetras+myNbQuadTetras : order == ORDER_LINEAR ? myNbTetras : myNbQuadTetras; }
inline int // NbHexas inline int // NbHexas
SMDS_MeshInfo::NbHexas (SMDSAbs_ElementOrder order) const SMDS_MeshInfo::NbHexas (SMDSAbs_ElementOrder order) const
{ return order == ORDER_ANY ? myNbHexas+myNbQuadHexas+myNbTriQuadHexas : order == ORDER_LINEAR ? myNbHexas : myNbQuadHexas+myNbTriQuadHexas; } { return order == ORDER_ANY ? myNbHexas+myNbQuadHexas+myNbTriQuadHexas : order == ORDER_LINEAR ? myNbHexas : myNbQuadHexas+myNbTriQuadHexas; }
inline int // NbPyramids inline int // NbPyramids
SMDS_MeshInfo::NbPyramids(SMDSAbs_ElementOrder order) const SMDS_MeshInfo::NbPyramids(SMDSAbs_ElementOrder order) const
{ return order == ORDER_ANY ? myNbPyramids+myNbQuadPyramids : order == ORDER_LINEAR ? myNbPyramids : myNbQuadPyramids; } { return order == ORDER_ANY ? myNbPyramids+myNbQuadPyramids : order == ORDER_LINEAR ? myNbPyramids : myNbQuadPyramids; }
inline int // NbPrisms inline int // NbPrisms
SMDS_MeshInfo::NbPrisms (SMDSAbs_ElementOrder order) const SMDS_MeshInfo::NbPrisms (SMDSAbs_ElementOrder order) const
{ return order == ORDER_ANY ? myNbPrisms+myNbQuadPrisms : order == ORDER_LINEAR ? myNbPrisms : myNbQuadPrisms; } { return order == ORDER_ANY ? myNbPrisms+myNbQuadPrisms : order == ORDER_LINEAR ? myNbPrisms : myNbQuadPrisms; }
inline int // NbHexPrisms inline int // NbHexPrisms
SMDS_MeshInfo::NbHexPrisms (SMDSAbs_ElementOrder order) const SMDS_MeshInfo::NbHexPrisms (SMDSAbs_ElementOrder order) const
{ return order == ORDER_ANY ? myNbHexPrism : order == ORDER_LINEAR ? myNbHexPrism : 0; } { return order == ORDER_ANY ? myNbHexPrism : order == ORDER_LINEAR ? myNbHexPrism : 0; }
inline int // NbElements inline int // NbElements
SMDS_MeshInfo::NbElements(SMDSAbs_ElementType type) const SMDS_MeshInfo::NbElements(SMDSAbs_ElementType type) const
{ {
int nb = 0; int nb = 0;
@ -305,7 +309,7 @@ SMDS_MeshInfo::NbElements(SMDSAbs_ElementType type) const
return nb; return nb;
} }
int // NbEntities inline int // NbEntities
SMDS_MeshInfo::NbEntities(SMDSAbs_EntityType type) const SMDS_MeshInfo::NbEntities(SMDSAbs_EntityType type) const
{ {
switch (type) { switch (type) {
@ -338,7 +342,44 @@ SMDS_MeshInfo::NbEntities(SMDSAbs_EntityType type) const
return 0; return 0;
} }
void // set inline int // NbElementsOfGeom
SMDS_MeshInfo::NbElementsOfGeom(SMDSAbs_GeometryType geom) const
{
switch ( geom ) {
// 0D:
case SMDSGeom_POINT: return myNb0DElements;
// 1D:
case SMDSGeom_EDGE: return (myNbEdges +
myNbQuadEdges);
// 2D:
case SMDSGeom_TRIANGLE: return (myNbTriangles +
myNbQuadTriangles);
case SMDSGeom_QUADRANGLE: return (myNbQuadrangles +
myNbQuadQuadrangles +
myNbBiQuadQuadrangles );
case SMDSGeom_POLYGON: return myNbPolygons;
// 3D:
case SMDSGeom_TETRA: return (myNbTetras +
myNbQuadTetras);
case SMDSGeom_PYRAMID: return (myNbPyramids +
myNbQuadPyramids);
case SMDSGeom_HEXA: return (myNbHexas +
myNbQuadHexas +
myNbTriQuadHexas);
case SMDSGeom_PENTA: return (myNbPrisms +
myNbQuadPrisms);
case SMDSGeom_HEXAGONAL_PRISM: return myNbHexPrism;
case SMDSGeom_POLYHEDRA: return myNbPolyhedrons;
// Discrete:
case SMDSGeom_BALL: return myNbBalls;
//
case SMDSGeom_NONE:
default:;
}
return 0;
}
inline void // setNb
SMDS_MeshInfo::setNb(const SMDSAbs_EntityType geomType, const int nb) SMDS_MeshInfo::setNb(const SMDSAbs_EntityType geomType, const int nb)
{ {
switch (geomType) { switch (geomType) {

5
src/SMDS/SMDS_UnstructuredGrid.cxx
View File

@ -87,7 +87,8 @@ unsigned long SMDS_UnstructuredGrid::GetMTime()
MESSAGE("vtkUnstructuredGrid::GetMTime: " << mtime); MESSAGE("vtkUnstructuredGrid::GetMTime: " << mtime);
return mtime; return mtime;
} }
// OUV_PORTING_VTK6: seems to be useless
/*
void SMDS_UnstructuredGrid::Update() void SMDS_UnstructuredGrid::Update()
{ {
MESSAGE("SMDS_UnstructuredGrid::Update"); MESSAGE("SMDS_UnstructuredGrid::Update");
@ -99,7 +100,7 @@ void SMDS_UnstructuredGrid::UpdateInformation()
MESSAGE("SMDS_UnstructuredGrid::UpdateInformation"); MESSAGE("SMDS_UnstructuredGrid::UpdateInformation");
return vtkUnstructuredGrid::UpdateInformation(); return vtkUnstructuredGrid::UpdateInformation();
} }
*/
vtkPoints* SMDS_UnstructuredGrid::GetPoints() vtkPoints* SMDS_UnstructuredGrid::GetPoints()
{ {
// TODO erreur incomprehensible de la macro vtk GetPoints apparue avec la version paraview de fin aout 2010 // TODO erreur incomprehensible de la macro vtk GetPoints apparue avec la version paraview de fin aout 2010

5
src/SMDS/SMDS_UnstructuredGrid.hxx
View File

@ -70,8 +70,9 @@ public:
std::vector<int>& idCellsOldToNew, std::vector<int>& idCellsOldToNew,
int newCellSize); int newCellSize);
virtual unsigned long GetMTime(); virtual unsigned long GetMTime();
virtual void Update(); // OUV_PORTING_VTK6: seems to be useless
virtual void UpdateInformation(); //virtual void Update();
//virtual void UpdateInformation();
virtual vtkPoints *GetPoints(); virtual vtkPoints *GetPoints();
//#ifdef VTK_HAVE_POLYHEDRON //#ifdef VTK_HAVE_POLYHEDRON

42
src/SMDS/SMDS_VolumeTool.cxx
View File

@ -292,27 +292,27 @@ static int QuadPenta_RE [5][9] = { // REVERSED -> EXTERNAL
static int QuadPenta_nbN [] = { 6, 6, 8, 8, 8 }; static int QuadPenta_nbN [] = { 6, 6, 8, 8, 8 };
/* /*
// 13 // 13
// N5+-----+-----+N6 // N5+-----+-----+N6 +-----+-----+
// /| /| // /| /| /| /|
// 12+ | 14+ | // 12+ | 14+ | + | +25 + |
// / | / | // / | / | / | / |
// N4+-----+-----+N7 | QUADRATIC // N4+-----+-----+N7 | QUADRATIC +-----+-----+ | Central nodes
// | | 15 | | HEXAHEDRON // | | 15 | | HEXAHEDRON | | | | of tri-quadratic
// | | | | // | | | | | | | | HEXAHEDRON
// | 17+ | +18 // | 17+ | +18 | + 22+ | +
// | | | | // | | | | |21 | | |
// | | | | // | | | | | + | 26+ | + |
// | | | | // | | | | | | |23 |
// 16+ | +19 | // 16+ | +19 | + | +24 + |
// | | | | // | | | | | | | |
// | | 9 | | // | | 9 | | | | | |
// | N1+-----+-|---+N2 // | N1+-----+-|---+N2 | +-----+-|---+
// | / | / // | / | / | / | /
// | +8 | +10 // | +8 | +10 | + 20+ | +
// |/ |/ // |/ |/ |/ |/
// N0+-----+-----+N3 // N0+-----+-----+N3 +-----+-----+
// 11 // 11
*/ */
static int QuadHexa_F [6][9] = { // FORWARD static int QuadHexa_F [6][9] = { // FORWARD
{ 0, 8, 1, 9, 2, 10,3, 11,0 }, // all face normals are external, { 0, 8, 1, 9, 2, 10,3, 11,0 }, // all face normals are external,

89
src/SMESH/SMESH_MeshEditor.cxx
View File

@ -9587,14 +9587,26 @@ int SMESH_MeshEditor::convertElemToQuadratic(SMESHDS_SubMesh * theSm,
{ {
nbElem++; nbElem++;
const SMDS_MeshElement* elem = ElemItr->next(); const SMDS_MeshElement* elem = ElemItr->next();
if( !elem || elem->IsQuadratic() ) continue; if( !elem ) continue;
const SMDSAbs_EntityType aGeomType = elem->GetEntityType();
if ( elem->IsQuadratic() )
{
bool alreadyOK;
switch ( aGeomType ) {
case SMDSEntity_Quad_Quadrangle:
case SMDSEntity_Quad_Hexa: alreadyOK = !theHelper.GetIsBiQuadratic(); break;
case SMDSEntity_BiQuad_Quadrangle:
case SMDSEntity_TriQuad_Hexa: alreadyOK = theHelper.GetIsBiQuadratic(); break;
default: alreadyOK = true;
}
if ( alreadyOK ) continue;
}
// get elem data needed to re-create it // get elem data needed to re-create it
// //
const int id = elem->GetID(); const int id = elem->GetID();
const int nbNodes = elem->NbNodes(); const int nbNodes = elem->NbCornerNodes();
const SMDSAbs_ElementType aType = elem->GetType(); const SMDSAbs_ElementType aType = elem->GetType();
const SMDSAbs_EntityType aGeomType = elem->GetEntityType();
nodes.assign(elem->begin_nodes(), elem->end_nodes()); nodes.assign(elem->begin_nodes(), elem->end_nodes());
if ( aGeomType == SMDSEntity_Polyhedra ) if ( aGeomType == SMDSEntity_Polyhedra )
nbNodeInFaces = static_cast<const SMDS_VtkVolume* >( elem )->GetQuantities(); nbNodeInFaces = static_cast<const SMDS_VtkVolume* >( elem )->GetQuantities();
@ -9643,6 +9655,8 @@ int SMESH_MeshEditor::convertElemToQuadratic(SMESHDS_SubMesh * theSm,
NewElem = theHelper.AddVolume(nodes[0], nodes[1], nodes[2], nodes[3], nodes[4], nodes[5], id, theForce3d); NewElem = theHelper.AddVolume(nodes[0], nodes[1], nodes[2], nodes[3], nodes[4], nodes[5], id, theForce3d);
break; break;
case SMDSEntity_Hexa: case SMDSEntity_Hexa:
case SMDSEntity_Quad_Hexa:
case SMDSEntity_TriQuad_Hexa:
NewElem = theHelper.AddVolume(nodes[0], nodes[1], nodes[2], nodes[3], NewElem = theHelper.AddVolume(nodes[0], nodes[1], nodes[2], nodes[3],
nodes[4], nodes[5], nodes[6], nodes[7], id, theForce3d); nodes[4], nodes[5], nodes[6], nodes[7], id, theForce3d);
break; break;
@ -9661,18 +9675,20 @@ int SMESH_MeshEditor::convertElemToQuadratic(SMESHDS_SubMesh * theSm,
} }
return nbElem; return nbElem;
} }
//======================================================================= //=======================================================================
//function : ConvertToQuadratic //function : ConvertToQuadratic
//purpose : //purpose :
//======================================================================= //=======================================================================
void SMESH_MeshEditor::ConvertToQuadratic(const bool theForce3d) void SMESH_MeshEditor::ConvertToQuadratic(const bool theForce3d, const bool theToBiQuad)
{ {
SMESHDS_Mesh* meshDS = GetMeshDS(); SMESHDS_Mesh* meshDS = GetMeshDS();
SMESH_MesherHelper aHelper(*myMesh); SMESH_MesherHelper aHelper(*myMesh);
aHelper.SetIsQuadratic( true ); aHelper.SetIsQuadratic( true );
aHelper.SetIsBiQuadratic( theToBiQuad );
aHelper.SetElementsOnShape(true);
int nbCheckedElems = 0; int nbCheckedElems = 0;
if ( myMesh->HasShapeToMesh() ) if ( myMesh->HasShapeToMesh() )
@ -9714,10 +9730,14 @@ void SMESH_MeshEditor::ConvertToQuadratic(const bool theForce3d)
while(aFaceItr->more()) while(aFaceItr->more())
{ {
const SMDS_MeshFace* face = aFaceItr->next(); const SMDS_MeshFace* face = aFaceItr->next();
if(!face || face->IsQuadratic() ) continue; if ( !face ) continue;
const SMDSAbs_EntityType type = face->GetEntityType();
if (( theToBiQuad && type == SMDSEntity_BiQuad_Quadrangle ) ||
( !theToBiQuad && type == SMDSEntity_Quad_Quadrangle ))
continue;
const int id = face->GetID(); const int id = face->GetID();
const SMDSAbs_EntityType type = face->GetEntityType();
vector<const SMDS_MeshNode *> nodes ( face->begin_nodes(), face->end_nodes()); vector<const SMDS_MeshNode *> nodes ( face->begin_nodes(), face->end_nodes());
meshDS->RemoveFreeElement(face, smDS, /*fromGroups=*/false); meshDS->RemoveFreeElement(face, smDS, /*fromGroups=*/false);
@ -9743,8 +9763,12 @@ void SMESH_MeshEditor::ConvertToQuadratic(const bool theForce3d)
const SMDS_MeshVolume* volume = aVolumeItr->next(); const SMDS_MeshVolume* volume = aVolumeItr->next();
if(!volume || volume->IsQuadratic() ) continue; if(!volume || volume->IsQuadratic() ) continue;
const int id = volume->GetID();
const SMDSAbs_EntityType type = volume->GetEntityType(); const SMDSAbs_EntityType type = volume->GetEntityType();
if (( theToBiQuad && type == SMDSEntity_TriQuad_Hexa ) ||
( !theToBiQuad && type == SMDSEntity_Quad_Hexa ))
continue;
const int id = volume->GetID();
vector<const SMDS_MeshNode *> nodes (volume->begin_nodes(), volume->end_nodes()); vector<const SMDS_MeshNode *> nodes (volume->begin_nodes(), volume->end_nodes());
if ( type == SMDSEntity_Polyhedra ) if ( type == SMDSEntity_Polyhedra )
nbNodeInFaces = static_cast<const SMDS_VtkVolume* >(volume)->GetQuantities(); nbNodeInFaces = static_cast<const SMDS_VtkVolume* >(volume)->GetQuantities();
@ -9760,6 +9784,8 @@ void SMESH_MeshEditor::ConvertToQuadratic(const bool theForce3d)
NewVolume = aHelper.AddVolume(nodes[0], nodes[1], nodes[2], nodes[3], id, theForce3d ); NewVolume = aHelper.AddVolume(nodes[0], nodes[1], nodes[2], nodes[3], id, theForce3d );
break; break;
case SMDSEntity_Hexa: case SMDSEntity_Hexa:
case SMDSEntity_Quad_Hexa:
case SMDSEntity_TriQuad_Hexa:
NewVolume = aHelper.AddVolume(nodes[0], nodes[1], nodes[2], nodes[3], NewVolume = aHelper.AddVolume(nodes[0], nodes[1], nodes[2], nodes[3],
nodes[4], nodes[5], nodes[6], nodes[7], id, theForce3d); nodes[4], nodes[5], nodes[6], nodes[7], id, theForce3d);
break; break;
@ -9795,7 +9821,8 @@ void SMESH_MeshEditor::ConvertToQuadratic(const bool theForce3d)
//================================================================================ //================================================================================
void SMESH_MeshEditor::ConvertToQuadratic(const bool theForce3d, void SMESH_MeshEditor::ConvertToQuadratic(const bool theForce3d,
TIDSortedElemSet& theElements) TIDSortedElemSet& theElements,
const bool theToBiQuad)
{ {
if ( theElements.empty() ) return; if ( theElements.empty() ) return;
@ -9822,8 +9849,19 @@ void SMESH_MeshEditor::ConvertToQuadratic(const bool theForce3d,
const SMDS_MeshElement* e = invIt->next(); const SMDS_MeshElement* e = invIt->next();
if ( e->IsQuadratic() ) if ( e->IsQuadratic() )
{ {
quadAdjacentElems[ e->GetType() ].insert( e ); bool alreadyOK;
continue; switch ( e->GetEntityType() ) {
case SMDSEntity_Quad_Quadrangle:
case SMDSEntity_Quad_Hexa: alreadyOK = !theToBiQuad; break;
case SMDSEntity_BiQuad_Quadrangle:
case SMDSEntity_TriQuad_Hexa: alreadyOK = theToBiQuad; break;
default: alreadyOK = true;
}
if ( alreadyOK )
{
quadAdjacentElems[ e->GetType() ].insert( e );
continue;
}
} }
if ( e->GetType() >= elemType ) if ( e->GetType() >= elemType )
{ {
@ -9845,6 +9883,7 @@ void SMESH_MeshEditor::ConvertToQuadratic(const bool theForce3d,
SMESH_MesherHelper helper(*myMesh); SMESH_MesherHelper helper(*myMesh);
helper.SetIsQuadratic( true ); helper.SetIsQuadratic( true );
helper.SetIsBiQuadratic( theToBiQuad );
// add links of quadratic adjacent elements to the helper // add links of quadratic adjacent elements to the helper
@ -9867,18 +9906,32 @@ void SMESH_MeshEditor::ConvertToQuadratic(const bool theForce3d,
helper.AddTLinks( static_cast< const SMDS_MeshVolume*> (*eIt) ); helper.AddTLinks( static_cast< const SMDS_MeshVolume*> (*eIt) );
} }
// make quadratic elements instead of linear ones // make quadratic (or bi-tri-quadratic) elements instead of linear ones
SMESHDS_Mesh* meshDS = GetMeshDS(); SMESHDS_Mesh* meshDS = GetMeshDS();
SMESHDS_SubMesh* smDS = 0; SMESHDS_SubMesh* smDS = 0;
for ( eIt = theElements.begin(); eIt != theElements.end(); ++eIt ) for ( eIt = theElements.begin(); eIt != theElements.end(); ++eIt )
{ {
const SMDS_MeshElement* elem = *eIt; const SMDS_MeshElement* elem = *eIt;
if( elem->IsQuadratic() || elem->NbNodes() < 2 || elem->IsPoly() ) if( elem->NbNodes() < 2 || elem->IsPoly() )
continue; continue;
const int id = elem->GetID(); if ( elem->IsQuadratic() )
{
bool alreadyOK;
switch ( elem->GetEntityType() ) {
case SMDSEntity_Quad_Quadrangle:
case SMDSEntity_Quad_Hexa: alreadyOK = !theToBiQuad; break;
case SMDSEntity_BiQuad_Quadrangle:
case SMDSEntity_TriQuad_Hexa: alreadyOK = theToBiQuad; break;
default: alreadyOK = true;
}
if ( alreadyOK ) continue;
}
const SMDSAbs_ElementType type = elem->GetType(); const SMDSAbs_ElementType type = elem->GetType();
const int id = elem->GetID();
const int nbNodes = elem->NbCornerNodes();
vector<const SMDS_MeshNode *> nodes ( elem->begin_nodes(), elem->end_nodes()); vector<const SMDS_MeshNode *> nodes ( elem->begin_nodes(), elem->end_nodes());
if ( !smDS || !smDS->Contains( elem )) if ( !smDS || !smDS->Contains( elem ))
@ -9886,7 +9939,7 @@ void SMESH_MeshEditor::ConvertToQuadratic(const bool theForce3d,
meshDS->RemoveFreeElement(elem, smDS, /*fromGroups=*/false); meshDS->RemoveFreeElement(elem, smDS, /*fromGroups=*/false);
SMDS_MeshElement * newElem = 0; SMDS_MeshElement * newElem = 0;
switch( nodes.size() ) switch( nbNodes )
{ {
case 4: // cases for most frequently used element types go first (for optimization) case 4: // cases for most frequently used element types go first (for optimization)
if ( type == SMDSAbs_Volume ) if ( type == SMDSAbs_Volume )

16
src/SMESH/SMESH_MeshEditor.hxx
View File

@ -117,7 +117,6 @@ public:
const SMESH_SequenceOfElemPtr& GetLastCreatedNodes() const { return myLastCreatedNodes; } const SMESH_SequenceOfElemPtr& GetLastCreatedNodes() const { return myLastCreatedNodes; }
const SMESH_SequenceOfElemPtr& GetLastCreatedElems() const { return myLastCreatedElems; } const SMESH_SequenceOfElemPtr& GetLastCreatedElems() const { return myLastCreatedElems; }
void CrearLastCreated(); void CrearLastCreated();
SMESH_ComputeErrorPtr & GetError() { return myError; } SMESH_ComputeErrorPtr & GetError() { return myError; }
/*! /*!
@ -492,15 +491,15 @@ public:
// insert theNodesToInsert into all volumes, containing link // insert theNodesToInsert into all volumes, containing link
// theBetweenNode1 - theBetweenNode2, between theBetweenNode1 and theBetweenNode2. // theBetweenNode1 - theBetweenNode2, between theBetweenNode1 and theBetweenNode2.
void ConvertToQuadratic(const bool theForce3d); void ConvertToQuadratic(const bool theForce3d, const bool theToBiQuad);
void ConvertToQuadratic(const bool theForce3d, TIDSortedElemSet& theElements); void ConvertToQuadratic(const bool theForce3d,
// Converts all mesh to quadratic one, deletes old elements, replacing TIDSortedElemSet& theElements, const bool theToBiQuad);
// them with quadratic ones with the same id. // Converts all mesh to quadratic or bi-quadratic one, deletes old elements,
// replacing them with quadratic or bi-quadratic ones with the same id.
// If theForce3d = 1; this results in the medium node lying at the // If theForce3d = 1; this results in the medium node lying at the
// middle of the line segments connecting start and end node of a mesh // middle of the line segments connecting start and end node of a mesh element.
// element
// If theForce3d = 0; this results in the medium node lying at the // If theForce3d = 0; this results in the medium node lying at the
// geometrical edge from which the mesh element is built // geometrical edge from which the mesh element is built.
bool ConvertFromQuadratic(); bool ConvertFromQuadratic();
void ConvertFromQuadratic(TIDSortedElemSet& theElements); void ConvertFromQuadratic(TIDSortedElemSet& theElements);
@ -625,7 +624,6 @@ public:
bool toAddExistingBondary = false, bool toAddExistingBondary = false,
bool aroundElements = false); bool aroundElements = false);
private: private:
/*! /*!

478
src/SMESH/SMESH_MesherHelper.cxx
View File

@ -81,7 +81,11 @@ namespace {
//================================================================================ //================================================================================
SMESH_MesherHelper::SMESH_MesherHelper(SMESH_Mesh& theMesh) SMESH_MesherHelper::SMESH_MesherHelper(SMESH_Mesh& theMesh)
: myParIndex(0), myMesh(&theMesh), myShapeID(0), myCreateQuadratic(false), : myParIndex(0),
myMesh(&theMesh),
myShapeID(0),
myCreateQuadratic(false),
myCreateBiQuadratic(false),
myFixNodeParameters(false) myFixNodeParameters(false)
{ {
myPar1[0] = myPar2[0] = myPar1[1] = myPar2[1] = 0; myPar1[0] = myPar2[0] = myPar1[1] = myPar2[1] = 0;
@ -934,11 +938,18 @@ bool SMESH_MesherHelper::CheckNodeU(const TopoDS_Edge& E,
//function : GetMediumPos //function : GetMediumPos
//purpose : Return index and type of the shape (EDGE or FACE only) to //purpose : Return index and type of the shape (EDGE or FACE only) to
// set a medium node on // set a medium node on
//param : useCurSubShape - if true, returns the shape set via SetSubShape()
// if any
//======================================================================= //=======================================================================
std::pair<int, TopAbs_ShapeEnum> SMESH_MesherHelper::GetMediumPos(const SMDS_MeshNode* n1, std::pair<int, TopAbs_ShapeEnum>
const SMDS_MeshNode* n2) SMESH_MesherHelper::GetMediumPos(const SMDS_MeshNode* n1,
const SMDS_MeshNode* n2,
const bool useCurSubShape)
{ {
if ( useCurSubShape && !myShape.IsNull() )
return std::make_pair( myShapeID, myShape.ShapeType() );
TopAbs_ShapeEnum shapeType = TopAbs_SHAPE; TopAbs_ShapeEnum shapeType = TopAbs_SHAPE;
int shapeID = -1; int shapeID = -1;
TopoDS_Shape shape; TopoDS_Shape shape;
@ -1009,9 +1020,157 @@ std::pair<int, TopAbs_ShapeEnum> SMESH_MesherHelper::GetMediumPos(const SMDS_Mes
return make_pair( shapeID, shapeType ); return make_pair( shapeID, shapeType );
} }
//=======================================================================
//function : GetCentralNode
//purpose : Return existing or create a new central node for a quardilateral
// quadratic face given its 8 nodes.
//@param : force3d - true means node creation in between the given nodes,
// else node position is found on a geometrical face if any.
//=======================================================================
const SMDS_MeshNode* SMESH_MesherHelper::GetCentralNode(const SMDS_MeshNode* n1,
const SMDS_MeshNode* n2,
const SMDS_MeshNode* n3,
const SMDS_MeshNode* n4,
const SMDS_MeshNode* n12,
const SMDS_MeshNode* n23,
const SMDS_MeshNode* n34,
const SMDS_MeshNode* n41,
bool force3d)
{
SMDS_MeshNode *centralNode = 0; // central node to return
// Find an existing central node
TBiQuad keyOfMap(n1,n2,n3,n4);
std::map<TBiQuad, SMDS_MeshNode* >::iterator itMapCentralNode;
itMapCentralNode = myMapWithCentralNode.find( keyOfMap );
if ( itMapCentralNode != myMapWithCentralNode.end() )
{
return (*itMapCentralNode).second;
}
// Get type of shape for the new central node
TopAbs_ShapeEnum shapeType = TopAbs_SHAPE;
int shapeID = -1;
int faceID = -1;
TopoDS_Shape shape;
TopTools_ListIteratorOfListOfShape it;
std::map< int, int > faceId2nbNodes;
std::map< int, int > ::iterator itMapWithIdFace;
SMESHDS_Mesh* meshDS = GetMeshDS();
// check if a face lie on a FACE, i.e. its all corner nodes lie either on the FACE or
// on sub-shapes of the FACE
if ( GetMesh()->HasShapeToMesh() )
{
const SMDS_MeshNode* nodes[] = { n1, n2, n3, n4 };
for(int i = 0; i < 4; i++)
{
shape = GetSubShapeByNode( nodes[i], meshDS );
if ( shape.IsNull() ) break;
if ( shape.ShapeType() == TopAbs_SOLID )
{
shapeID = nodes[i]->getshapeId();
shapeType = TopAbs_SOLID;
break;
}
if ( shape.ShapeType() == TopAbs_FACE )
{
faceID = nodes[i]->getshapeId();
itMapWithIdFace = faceId2nbNodes.insert( std::make_pair( faceID, 0 ) ).first;
itMapWithIdFace->second++;
}
else
{
PShapeIteratorPtr it = GetAncestors(shape, *GetMesh(), TopAbs_FACE );
while ( const TopoDS_Shape* face = it->next() )
{
faceID = meshDS->ShapeToIndex( *face );
itMapWithIdFace = faceId2nbNodes.insert( std::make_pair( faceID, 0 ) ).first;
itMapWithIdFace->second++;
}
}
}
}
if ( shapeID < 1 && !faceId2nbNodes.empty() ) // SOLID not found
{
// find ID of the FACE the four corner nodes belong to
itMapWithIdFace = faceId2nbNodes.begin();
for ( ; itMapWithIdFace != faceId2nbNodes.end(); ++itMapWithIdFace)
{
if ( itMapWithIdFace->second == 4 )
{
shapeType = TopAbs_FACE;
faceID = (*itMapWithIdFace).first;
break;
}
}
}
TopoDS_Face F;
if ( shapeType == TopAbs_FACE )
{
F = TopoDS::Face( meshDS->IndexToShape( faceID ));
}
// Create a node
gp_XY uvAvg;
gp_Pnt P;
if ( !F.IsNull() )
{
if ( !force3d )
{
uvAvg = calcTFI (0.5, 0.5,
GetNodeUV(F,n1,n3), GetNodeUV(F,n2,n4),
GetNodeUV(F,n3,n1), GetNodeUV(F,n4,n2),
GetNodeUV(F,n12,n3), GetNodeUV(F,n23,n4),
GetNodeUV(F,n34,n2), GetNodeUV(F,n41,n2));
TopLoc_Location loc;
Handle( Geom_Surface ) S = BRep_Tool::Surface( F, loc );
P = S->Value( uvAvg.X(), uvAvg.Y() ).Transformed( loc );
centralNode = meshDS->AddNode( P.X(), P.Y(), P.Z() );
if ( mySetElemOnShape )
meshDS->SetNodeOnFace( centralNode, faceID, uvAvg.X(), uvAvg.Y() );
myMapWithCentralNode.insert( std::make_pair( keyOfMap, centralNode ) );
return centralNode;
}
}
P = ( SMESH_TNodeXYZ( n1 ) +
SMESH_TNodeXYZ( n2 ) +
SMESH_TNodeXYZ( n3 ) +
SMESH_TNodeXYZ( n4 ) ) / 4;
centralNode = meshDS->AddNode( P.X(), P.Y(), P.Z() );
if ( mySetElemOnShape )
{
if ( !F.IsNull() )
{
uvAvg = (GetNodeUV(F,n1,n3) +
GetNodeUV(F,n2,n4) +
GetNodeUV(F,n3,n1) +
GetNodeUV(F,n4,n2)) / 4;
CheckNodeUV( F, centralNode, uvAvg, 2*BRep_Tool::Tolerance( F ), /*force=*/true);
meshDS->SetNodeOnFace( centralNode, faceID, uvAvg.X(), uvAvg.Y() );
}
else if ( shapeID > 0 )
meshDS->SetNodeInVolume( centralNode, shapeID );
else if ( myShapeID > 0 )
meshDS->SetMeshElementOnShape( centralNode, myShapeID );
}
myMapWithCentralNode.insert( std::make_pair( keyOfMap, centralNode ) );
return centralNode;
}
//======================================================================= //=======================================================================
//function : GetMediumNode //function : GetMediumNode
//purpose : Return existing or create new medium nodes between given ones //purpose : Return existing or create a new medium node between given ones
//======================================================================= //=======================================================================
const SMDS_MeshNode* SMESH_MesherHelper::GetMediumNode(const SMDS_MeshNode* n1, const SMDS_MeshNode* SMESH_MesherHelper::GetMediumNode(const SMDS_MeshNode* n1,
@ -1041,7 +1200,7 @@ const SMDS_MeshNode* SMESH_MesherHelper::GetMediumNode(const SMDS_MeshNode* n1,
TopoDS_Face F; gp_XY uv[2]; TopoDS_Face F; gp_XY uv[2];
bool uvOK[2] = { false, false }; bool uvOK[2] = { false, false };
pair<int, TopAbs_ShapeEnum> pos = GetMediumPos( n1, n2 ); pair<int, TopAbs_ShapeEnum> pos = GetMediumPos( n1, n2, mySetElemOnShape );
// get positions of the given nodes on shapes // get positions of the given nodes on shapes
if ( pos.second == TopAbs_FACE ) if ( pos.second == TopAbs_FACE )
@ -1088,7 +1247,8 @@ const SMDS_MeshNode* SMESH_MesherHelper::GetMediumNode(const SMDS_MeshNode* n1,
gp_XY UV = GetMiddleUV( S, uv[0], uv[1] ); gp_XY UV = GetMiddleUV( S, uv[0], uv[1] );
gp_Pnt P = S->Value( UV.X(), UV.Y() ).Transformed(loc); gp_Pnt P = S->Value( UV.X(), UV.Y() ).Transformed(loc);
n12 = meshDS->AddNode(P.X(), P.Y(), P.Z()); n12 = meshDS->AddNode(P.X(), P.Y(), P.Z());
meshDS->SetNodeOnFace(n12, faceID, UV.X(), UV.Y()); if ( mySetElemOnShape )
meshDS->SetNodeOnFace(n12, faceID, UV.X(), UV.Y());
myTLinkNodeMap.insert(make_pair(link,n12)); myTLinkNodeMap.insert(make_pair(link,n12));
return n12; return n12;
} }
@ -1112,7 +1272,8 @@ const SMDS_MeshNode* SMESH_MesherHelper::GetMediumNode(const SMDS_MeshNode* n1,
gp_Pnt P = C->Value( U ); gp_Pnt P = C->Value( U );
n12 = meshDS->AddNode(P.X(), P.Y(), P.Z()); n12 = meshDS->AddNode(P.X(), P.Y(), P.Z());
meshDS->SetNodeOnEdge(n12, edgeID, U); if ( mySetElemOnShape )
meshDS->SetNodeOnEdge(n12, edgeID, U);
myTLinkNodeMap.insert(make_pair(link,n12)); myTLinkNodeMap.insert(make_pair(link,n12));
return n12; return n12;
} }
@ -1125,21 +1286,24 @@ const SMDS_MeshNode* SMESH_MesherHelper::GetMediumNode(const SMDS_MeshNode* n1,
double z = ( n1->Z() + n2->Z() )/2.; double z = ( n1->Z() + n2->Z() )/2.;
n12 = meshDS->AddNode(x,y,z); n12 = meshDS->AddNode(x,y,z);
if ( !F.IsNull() ) if ( mySetElemOnShape )
{ {
gp_XY UV = ( uv[0] + uv[1] ) / 2.; if ( !F.IsNull() )
CheckNodeUV( F, n12, UV, 2*BRep_Tool::Tolerance( F ), /*force=*/true); {
meshDS->SetNodeOnFace(n12, faceID, UV.X(), UV.Y() ); gp_XY UV = ( uv[0] + uv[1] ) / 2.;
} CheckNodeUV( F, n12, UV, 2*BRep_Tool::Tolerance( F ), /*force=*/true);
else if ( !E.IsNull() ) meshDS->SetNodeOnFace(n12, faceID, UV.X(), UV.Y() );
{ }
double U = ( u[0] + u[1] ) / 2.; else if ( !E.IsNull() )
CheckNodeU( E, n12, U, 2*BRep_Tool::Tolerance( E ), /*force=*/true); {
meshDS->SetNodeOnEdge(n12, edgeID, U); double U = ( u[0] + u[1] ) / 2.;
} CheckNodeU( E, n12, U, 2*BRep_Tool::Tolerance( E ), /*force=*/true);
else if ( myShapeID > 0 ) meshDS->SetNodeOnEdge(n12, edgeID, U);
{ }
meshDS->SetNodeInVolume(n12, myShapeID); else if ( myShapeID > 0 )
{
meshDS->SetMeshElementOnShape(n12, myShapeID);
}
} }
myTLinkNodeMap.insert( make_pair( link, n12 )); myTLinkNodeMap.insert( make_pair( link, n12 ));
@ -1211,7 +1375,8 @@ const SMDS_MeshNode* SMESH_MesherHelper::getMediumNodeOnComposedWire(const SMDS_
GetMeshDS()->MoveNode( n12, p.X(), p.Y(), p.Z() ); GetMeshDS()->MoveNode( n12, p.X(), p.Y(), p.Z() );
} }
GetMeshDS()->SetNodeOnEdge(n12, edges[iOkEdge], u); if ( mySetElemOnShape )
GetMeshDS()->SetNodeOnEdge(n12, edges[iOkEdge], u);
myTLinkNodeMap.insert( make_pair( SMESH_TLink(n1,n2), n12 )); myTLinkNodeMap.insert( make_pair( SMESH_TLink(n1,n2), n12 ));
@ -1319,7 +1484,7 @@ SMDS_MeshFace* SMESH_MesherHelper::AddFace(const SMDS_MeshNode* n1,
//======================================================================= //=======================================================================
//function : AddFace //function : AddFace
//purpose : Creates quadratic or linear quadrangle //purpose : Creates bi-quadratic, quadratic or linear quadrangle
//======================================================================= //=======================================================================
SMDS_MeshFace* SMESH_MesherHelper::AddFace(const SMDS_MeshNode* n1, SMDS_MeshFace* SMESH_MesherHelper::AddFace(const SMDS_MeshNode* n1,
@ -1362,11 +1527,21 @@ SMDS_MeshFace* SMESH_MesherHelper::AddFace(const SMDS_MeshNode* n1,
const SMDS_MeshNode* n23 = GetMediumNode(n2,n3,force3d); const SMDS_MeshNode* n23 = GetMediumNode(n2,n3,force3d);
const SMDS_MeshNode* n34 = GetMediumNode(n3,n4,force3d); const SMDS_MeshNode* n34 = GetMediumNode(n3,n4,force3d);
const SMDS_MeshNode* n41 = GetMediumNode(n4,n1,force3d); const SMDS_MeshNode* n41 = GetMediumNode(n4,n1,force3d);
if(myCreateBiQuadratic)
if(id) {
elem = meshDS->AddFaceWithID(n1, n2, n3, n4, n12, n23, n34, n41, id); const SMDS_MeshNode* nCenter = GetCentralNode(n1, n2, n3, n4, n12, n23, n34, n41, force3d);
if(id)
elem = meshDS->AddFaceWithID(n1, n2, n3, n4, n12, n23, n34, n41, nCenter, id);
else
elem = meshDS->AddFace(n1, n2, n3, n4, n12, n23, n34, n41, nCenter);
}
else else
elem = meshDS->AddFace(n1, n2, n3, n4, n12, n23, n34, n41); {
if(id)
elem = meshDS->AddFaceWithID(n1, n2, n3, n4, n12, n23, n34, n41, id);
else
elem = meshDS->AddFace(n1, n2, n3, n4, n12, n23, n34, n41);
}
} }
if ( mySetElemOnShape && myShapeID > 0 ) if ( mySetElemOnShape && myShapeID > 0 )
meshDS->SetMeshElementOnShape( elem, myShapeID ); meshDS->SetMeshElementOnShape( elem, myShapeID );
@ -1550,7 +1725,7 @@ SMDS_MeshVolume* SMESH_MesherHelper::AddVolume(const SMDS_MeshNode* n1,
//======================================================================= //=======================================================================
//function : AddVolume //function : AddVolume
//purpose : Creates quadratic or linear hexahedron //purpose : Creates bi-quadratic, quadratic or linear hexahedron
//======================================================================= //=======================================================================
SMDS_MeshVolume* SMESH_MesherHelper::AddVolume(const SMDS_MeshNode* n1, SMDS_MeshVolume* SMESH_MesherHelper::AddVolume(const SMDS_MeshNode* n1,
@ -1587,15 +1762,75 @@ SMDS_MeshVolume* SMESH_MesherHelper::AddVolume(const SMDS_MeshNode* n1,
const SMDS_MeshNode* n26 = GetMediumNode(n2,n6,force3d); const SMDS_MeshNode* n26 = GetMediumNode(n2,n6,force3d);
const SMDS_MeshNode* n37 = GetMediumNode(n3,n7,force3d); const SMDS_MeshNode* n37 = GetMediumNode(n3,n7,force3d);
const SMDS_MeshNode* n48 = GetMediumNode(n4,n8,force3d); const SMDS_MeshNode* n48 = GetMediumNode(n4,n8,force3d);
if(myCreateBiQuadratic)
{
const SMDS_MeshNode* n1234 = GetCentralNode(n1,n2,n3,n4,n12,n23,n34,n41,force3d);
const SMDS_MeshNode* n1256 = GetCentralNode(n1,n2,n5,n6,n12,n26,n56,n15,force3d);
const SMDS_MeshNode* n2367 = GetCentralNode(n2,n3,n6,n7,n23,n37,n67,n26,force3d);
const SMDS_MeshNode* n3478 = GetCentralNode(n3,n4,n7,n8,n34,n48,n78,n37,force3d);
const SMDS_MeshNode* n1458 = GetCentralNode(n1,n4,n5,n8,n41,n48,n15,n85,force3d);
const SMDS_MeshNode* n5678 = GetCentralNode(n5,n6,n7,n8,n56,n67,n78,n85,force3d);
if(id) vector<gp_XYZ> pointsOnShapes( SMESH_Block::ID_Shell );
elem = meshDS->AddVolumeWithID(n1, n2, n3, n4, n5, n6, n7, n8,
n12, n23, n34, n41, n56, n67, pointsOnShapes[ SMESH_Block::ID_V000 ] = SMESH_TNodeXYZ( n4 );
n78, n85, n15, n26, n37, n48, id); pointsOnShapes[ SMESH_Block::ID_V100 ] = SMESH_TNodeXYZ( n8 );
pointsOnShapes[ SMESH_Block::ID_V010 ] = SMESH_TNodeXYZ( n3 );
pointsOnShapes[ SMESH_Block::ID_V110 ] = SMESH_TNodeXYZ( n7 );
pointsOnShapes[ SMESH_Block::ID_V001 ] = SMESH_TNodeXYZ( n1 );
pointsOnShapes[ SMESH_Block::ID_V101 ] = SMESH_TNodeXYZ( n5 );
pointsOnShapes[ SMESH_Block::ID_V011 ] = SMESH_TNodeXYZ( n2 );
pointsOnShapes[ SMESH_Block::ID_V111 ] = SMESH_TNodeXYZ( n6 );
pointsOnShapes[ SMESH_Block::ID_Ex00 ] = SMESH_TNodeXYZ( n48 );
pointsOnShapes[ SMESH_Block::ID_Ex10 ] = SMESH_TNodeXYZ( n37 );
pointsOnShapes[ SMESH_Block::ID_E0y0 ] = SMESH_TNodeXYZ( n15 );
pointsOnShapes[ SMESH_Block::ID_E1y0 ] = SMESH_TNodeXYZ( n26 );
pointsOnShapes[ SMESH_Block::ID_Ex01 ] = SMESH_TNodeXYZ( n34 );
pointsOnShapes[ SMESH_Block::ID_Ex11 ] = SMESH_TNodeXYZ( n78 );
pointsOnShapes[ SMESH_Block::ID_E0y1 ] = SMESH_TNodeXYZ( n12 );
pointsOnShapes[ SMESH_Block::ID_E1y1 ] = SMESH_TNodeXYZ( n56 );
pointsOnShapes[ SMESH_Block::ID_E00z ] = SMESH_TNodeXYZ( n41 );
pointsOnShapes[ SMESH_Block::ID_E10z ] = SMESH_TNodeXYZ( n85 );
pointsOnShapes[ SMESH_Block::ID_E01z ] = SMESH_TNodeXYZ( n23 );
pointsOnShapes[ SMESH_Block::ID_E11z ] = SMESH_TNodeXYZ( n67 );
pointsOnShapes[ SMESH_Block::ID_Fxy0 ] = SMESH_TNodeXYZ( n3478 );
pointsOnShapes[ SMESH_Block::ID_Fxy1 ] = SMESH_TNodeXYZ( n1256 );
pointsOnShapes[ SMESH_Block::ID_Fx0z ] = SMESH_TNodeXYZ( n1458 );
pointsOnShapes[ SMESH_Block::ID_Fx1z ] = SMESH_TNodeXYZ( n2367 );
pointsOnShapes[ SMESH_Block::ID_F0yz ] = SMESH_TNodeXYZ( n1234 );
pointsOnShapes[ SMESH_Block::ID_F1yz ] = SMESH_TNodeXYZ( n5678 );
gp_XYZ centerCube(0.5, 0.5, 0.5);
gp_XYZ nCenterElem;
SMESH_Block::ShellPoint( centerCube, pointsOnShapes, nCenterElem );
const SMDS_MeshNode* nCenter =
meshDS->AddNode( nCenterElem.X(), nCenterElem.Y(), nCenterElem.Z() );
meshDS->SetNodeInVolume( nCenter, myShapeID );
if(id)
elem = meshDS->AddVolumeWithID(n1, n2, n3, n4, n5, n6, n7, n8,
n12, n23, n34, n41, n56, n67,
n78, n85, n15, n26, n37, n48,
n1234, n1256, n2367, n3478, n1458, n5678, nCenter, id);
else
elem = meshDS->AddVolume(n1, n2, n3, n4, n5, n6, n7, n8,
n12, n23, n34, n41, n56, n67,
n78, n85, n15, n26, n37, n48,
n1234, n1256, n2367, n3478, n1458, n5678, nCenter);
}
else else
elem = meshDS->AddVolume(n1, n2, n3, n4, n5, n6, n7, n8, {
n12, n23, n34, n41, n56, n67, if(id)
n78, n85, n15, n26, n37, n48); elem = meshDS->AddVolumeWithID(n1, n2, n3, n4, n5, n6, n7, n8,
n12, n23, n34, n41, n56, n67,
n78, n85, n15, n26, n37, n48, id);
else
elem = meshDS->AddVolume(n1, n2, n3, n4, n5, n6, n7, n8,
n12, n23, n34, n41, n56, n67,
n78, n85, n15, n26, n37, n48);
}
} }
if ( mySetElemOnShape && myShapeID > 0 ) if ( mySetElemOnShape && myShapeID > 0 )
meshDS->SetMeshElementOnShape( elem, myShapeID ); meshDS->SetMeshElementOnShape( elem, myShapeID );
@ -1720,10 +1955,11 @@ bool SMESH_MesherHelper::IsSameElemGeometry(const SMESHDS_SubMesh* smDS,
if ( !smDS ) return nullSubMeshRes; if ( !smDS ) return nullSubMeshRes;
SMDS_ElemIteratorPtr elemIt = smDS->GetElements(); SMDS_ElemIteratorPtr elemIt = smDS->GetElements();
while ( elemIt->more() ) while ( elemIt->more() ) {
if ( elemIt->next()->GetGeomType() != shape ) const SMDS_MeshElement* e = elemIt->next();
if ( e->GetGeomType() != shape )
return false; return false;
}
return true; return true;
} }
@ -1898,7 +2134,8 @@ namespace
//================================================================================ //================================================================================
bool isCornerOfStructure( const SMDS_MeshNode* n, bool isCornerOfStructure( const SMDS_MeshNode* n,
const SMESHDS_SubMesh* faceSM ) const SMESHDS_SubMesh* faceSM,
SMESH_MesherHelper& faceAnalyser )
{ {
int nbFacesInSM = 0; int nbFacesInSM = 0;
if ( n ) { if ( n ) {
@ -1906,7 +2143,14 @@ namespace
while ( fIt->more() ) while ( fIt->more() )
nbFacesInSM += faceSM->Contains( fIt->next() ); nbFacesInSM += faceSM->Contains( fIt->next() );
} }
return ( nbFacesInSM == 1 ); if ( nbFacesInSM == 1 )
return true;
if ( nbFacesInSM == 2 && n->GetPosition()->GetTypeOfPosition() == SMDS_TOP_VERTEX )
{
return faceAnalyser.IsRealSeam( n->getshapeId() );
}
return false;
} }
} }
@ -1925,13 +2169,15 @@ bool SMESH_MesherHelper::IsStructured( SMESH_subMesh* faceSM )
list< int > nbEdgesInWires; list< int > nbEdgesInWires;
int nbWires = SMESH_Block::GetOrderedEdges( TopoDS::Face( faceSM->GetSubShape() ), int nbWires = SMESH_Block::GetOrderedEdges( TopoDS::Face( faceSM->GetSubShape() ),
edges, nbEdgesInWires ); edges, nbEdgesInWires );
if ( nbWires != 1 ) if ( nbWires != 1 || nbEdgesInWires.front() != 4 )
return false; return false;
// algo: find corners of a structure and then analyze nb of faces and // algo: find corners of a structure and then analyze nb of faces and
// length of structure sides // length of structure sides
SMESHDS_Mesh* meshDS = faceSM->GetFather()->GetMeshDS(); SMESHDS_Mesh* meshDS = faceSM->GetFather()->GetMeshDS();
SMESH_MesherHelper faceAnalyser( *faceSM->GetFather() );
faceAnalyser.SetSubShape( faceSM->GetSubShape() );
// rotate edges to get the first node being at corner // rotate edges to get the first node being at corner
// (in principle it's not necessary but so far none SALOME algo can make // (in principle it's not necessary but so far none SALOME algo can make
@ -1940,7 +2186,8 @@ bool SMESH_MesherHelper::IsStructured( SMESH_subMesh* faceSM )
int nbRemainEdges = nbEdgesInWires.front(); int nbRemainEdges = nbEdgesInWires.front();
do { do {
TopoDS_Vertex V = IthVertex( 0, edges.front() ); TopoDS_Vertex V = IthVertex( 0, edges.front() );
isCorner = isCornerOfStructure( SMESH_Algo::VertexNode( V, meshDS ), fSM); isCorner = isCornerOfStructure( SMESH_Algo::VertexNode( V, meshDS ),
fSM, faceAnalyser);
if ( !isCorner ) { if ( !isCorner ) {
edges.splice( edges.end(), edges, edges.begin() ); edges.splice( edges.end(), edges, edges.begin() );
--nbRemainEdges; --nbRemainEdges;
@ -1963,16 +2210,13 @@ bool SMESH_MesherHelper::IsStructured( SMESH_subMesh* faceSM )
list< const SMDS_MeshNode* > edgeNodes; list< const SMDS_MeshNode* > edgeNodes;
map< double, const SMDS_MeshNode* >::iterator u2n = u2Nodes.begin(); map< double, const SMDS_MeshNode* >::iterator u2n = u2Nodes.begin();
if ( !nodes.empty() && nodes.back() == u2n->second ) for ( ; u2n != u2Nodes.end(); ++u2n )
++u2n;
map< double, const SMDS_MeshNode* >::iterator u2nEnd = --u2Nodes.end();
if ( nodes.empty() || nodes.back() != u2nEnd->second )
++u2nEnd;
for ( ; u2n != u2nEnd; ++u2n )
edgeNodes.push_back( u2n->second ); edgeNodes.push_back( u2n->second );
if ( edge->Orientation() == TopAbs_REVERSED ) if ( edge->Orientation() == TopAbs_REVERSED )
edgeNodes.reverse(); edgeNodes.reverse();
if ( !nodes.empty() && nodes.back() == edgeNodes.front() )
edgeNodes.pop_front();
nodes.splice( nodes.end(), edgeNodes, edgeNodes.begin(), edgeNodes.end() ); nodes.splice( nodes.end(), edgeNodes, edgeNodes.begin(), edgeNodes.end() );
} }
@ -1983,7 +2227,7 @@ bool SMESH_MesherHelper::IsStructured( SMESH_subMesh* faceSM )
for ( ; n != nodes.end(); ++n ) for ( ; n != nodes.end(); ++n )
{ {
++nbEdges; ++nbEdges;
if ( isCornerOfStructure( *n, fSM )) { if ( isCornerOfStructure( *n, fSM, faceAnalyser )) {
nbEdgesInSide.push_back( nbEdges ); nbEdgesInSide.push_back( nbEdges );
nbEdges = 0; nbEdges = 0;
} }
@ -2488,7 +2732,7 @@ namespace { // Structures used by FixQuadraticElements()
enum { ERR_OK, ERR_TRI, ERR_PRISM, ERR_UNKNOWN }; // errors of QFace::GetLinkChain() enum { ERR_OK, ERR_TRI, ERR_PRISM, ERR_UNKNOWN }; // errors of QFace::GetLinkChain()
// -------------------------------------------------------------------- // --------------------------------------------------------------------
/*! /*!
* \brief Face shared by two volumes and bound by QLinks * \brief Quadratic face shared by two volumes and bound by QLinks
*/ */
struct QFace: public TIDSortedNodeSet struct QFace: public TIDSortedNodeSet
{ {
@ -3857,11 +4101,13 @@ void SMESH_MesherHelper::FixQuadraticElements(SMESH_ComputeErrorPtr& compError,
// 3. Compute displacement of medium nodes // 3. Compute displacement of medium nodes
// --------------------------------------- // ---------------------------------------
// two loops on QFaces: the first is to treat boundary links, the second is for internal ones // two loops on QFaces: the first is to treat boundary links, the second is for internal ones.
TopLoc_Location loc; TopLoc_Location loc;
// not treat boundary of volumic submesh bool checkUV;
// not to treat boundary of volumic sub-mesh.
int isInside = ( elemType == SMDSAbs_Volume && volumeOnly ) ? 1 : 0; int isInside = ( elemType == SMDSAbs_Volume && volumeOnly ) ? 1 : 0;
for ( ; isInside < 2; ++isInside ) { for ( ; isInside < 2; ++isInside )
{
MSG( "--------------- LOOP (inside=" << isInside << ") ------------------"); MSG( "--------------- LOOP (inside=" << isInside << ") ------------------");
SMDS_TypeOfPosition pos = isInside ? SMDS_TOP_3DSPACE : SMDS_TOP_FACE; SMDS_TypeOfPosition pos = isInside ? SMDS_TOP_3DSPACE : SMDS_TOP_FACE;
SMDS_TypeOfPosition bndPos = isInside ? SMDS_TOP_FACE : SMDS_TOP_EDGE; SMDS_TypeOfPosition bndPos = isInside ? SMDS_TOP_FACE : SMDS_TOP_EDGE;
@ -3936,7 +4182,6 @@ void SMESH_MesherHelper::FixQuadraticElements(SMESH_ComputeErrorPtr& compError,
gp_Vec move1 = chain.back ()->_nodeMove; gp_Vec move1 = chain.back ()->_nodeMove;
TopoDS_Face face; TopoDS_Face face;
bool checkUV = true;
if ( !isInside ) if ( !isInside )
{ {
// compute node displacement of end links of chain in parametric space of face // compute node displacement of end links of chain in parametric space of face
@ -4049,10 +4294,131 @@ void SMESH_MesherHelper::FixQuadraticElements(SMESH_ComputeErrorPtr& compError,
// 4. Move nodes // 4. Move nodes
// ------------- // -------------
TIDSortedElemSet biQuadQuas, triQuadHexa;
const SMDS_MeshElement *biQuadQua, *triQuadHex;
const bool toFixCentralNodes = ( myMesh->NbBiQuadQuadrangles() +
myMesh->NbTriQuadraticHexas() );
for ( pLink = links.begin(); pLink != links.end(); ++pLink ) { for ( pLink = links.begin(); pLink != links.end(); ++pLink ) {
if ( pLink->IsMoved() ) { if ( pLink->IsMoved() )
{
gp_Pnt p = pLink->MiddlePnt() + pLink->Move(); gp_Pnt p = pLink->MiddlePnt() + pLink->Move();
GetMeshDS()->MoveNode( pLink->_mediumNode, p.X(), p.Y(), p.Z()); GetMeshDS()->MoveNode( pLink->_mediumNode, p.X(), p.Y(), p.Z());
// collect bi-quadratic elements
if ( toFixCentralNodes )
{
biQuadQua = triQuadHex = 0;
SMDS_ElemIteratorPtr eIt = pLink->_mediumNode->GetInverseElementIterator();
while ( eIt->more() )
{
const SMDS_MeshElement* e = eIt->next();
SMDSAbs_EntityType type = e->GetEntityType();
if ( type == SMDSEntity_BiQuad_Quadrangle )
biQuadQuas.insert( e );
else if ( type == SMDSEntity_TriQuad_Hexa )
triQuadHexa.insert( e );
}
}
}
}
// Fix positions of central nodes of bi-tri-quadratic elements
// treat bi-quad quadrangles
{
vector< const SMDS_MeshNode* > nodes( 9 );
gp_XY uv[ 9 ];
//TIDSortedNodeSet checkedNodes;
TIDSortedElemSet::iterator quadIt = biQuadQuas.begin();
for ( ; quadIt != biQuadQuas.end(); ++quadIt )
{
const SMDS_MeshElement* quad = *quadIt;
// nodes
nodes.clear();
nodes.assign( quad->begin_nodes(), quad->end_nodes() );
// FACE
TopoDS_Shape S = GetSubShapeByNode( nodes.back(), GetMeshDS() );
if ( S.IsNull() || S.ShapeType() != TopAbs_FACE ) continue;
const TopoDS_Face& F = TopoDS::Face( S );
Handle( Geom_Surface ) surf = BRep_Tool::Surface( F, loc );
const double tol = BRep_Tool::Tolerance( F );
// UV
for ( int i = 0; i < 8; ++i )
{
uv[ i ] = GetNodeUV( F, nodes[i], nodes[8], &checkUV );
// as this method is used after mesh generation, UV of nodes is not
// updated according to bending links, so we update
if ( i > 3 && nodes[i]->GetPosition()->GetTypeOfPosition() == SMDS_TOP_FACE )
CheckNodeUV( F, nodes[i], uv[ i ], 2*tol, /*force=*/true );
}
// move central node
gp_XY uvCent = calcTFI (0.5, 0.5, uv[0],uv[1],uv[2],uv[3],uv[4],uv[5],uv[6],uv[7] );
gp_Pnt p = surf->Value( uvCent.X(), uvCent.Y() ).Transformed( loc );
GetMeshDS()->MoveNode( nodes[8], p.X(), p.Y(), p.Z());
}
}
// treat tri-quadratic hexahedra
{
SMDS_VolumeTool volExp;
TIDSortedElemSet::iterator hexIt = triQuadHexa.begin();
for ( ; hexIt != triQuadHexa.end(); ++hexIt )
{
volExp.Set( *hexIt, /*ignoreCentralNodes=*/false );
// fix nodes central in sides
for ( int iQuad = 0; iQuad < volExp.NbFaces(); ++iQuad )
{
const SMDS_MeshNode** quadNodes = volExp.GetFaceNodes( iQuad );
if ( quadNodes[8]->GetPosition()->GetTypeOfPosition() == SMDS_TOP_3DSPACE )
{
gp_XYZ p = calcTFI( 0.5, 0.5,
SMESH_TNodeXYZ( quadNodes[0] ), SMESH_TNodeXYZ( quadNodes[2] ),
SMESH_TNodeXYZ( quadNodes[4] ), SMESH_TNodeXYZ( quadNodes[6] ),
SMESH_TNodeXYZ( quadNodes[1] ), SMESH_TNodeXYZ( quadNodes[3] ),
SMESH_TNodeXYZ( quadNodes[5] ), SMESH_TNodeXYZ( quadNodes[7] ));
GetMeshDS()->MoveNode( quadNodes[8], p.X(), p.Y(), p.Z());
}
}
// fix the volume central node
vector<gp_XYZ> pointsOnShapes( SMESH_Block::ID_Shell );
const SMDS_MeshNode** hexNodes = volExp.GetNodes();
pointsOnShapes[ SMESH_Block::ID_V000 ] = SMESH_TNodeXYZ( hexNodes[ 0 ] );
pointsOnShapes[ SMESH_Block::ID_V100 ] = SMESH_TNodeXYZ( hexNodes[ 3 ] );
pointsOnShapes[ SMESH_Block::ID_V010 ] = SMESH_TNodeXYZ( hexNodes[ 1 ] );
pointsOnShapes[ SMESH_Block::ID_V110 ] = SMESH_TNodeXYZ( hexNodes[ 2 ] );
pointsOnShapes[ SMESH_Block::ID_V001 ] = SMESH_TNodeXYZ( hexNodes[ 4 ] );
pointsOnShapes[ SMESH_Block::ID_V101 ] = SMESH_TNodeXYZ( hexNodes[ 7 ] );
pointsOnShapes[ SMESH_Block::ID_V011 ] = SMESH_TNodeXYZ( hexNodes[ 5 ] );
pointsOnShapes[ SMESH_Block::ID_V111 ] = SMESH_TNodeXYZ( hexNodes[ 6 ] );
pointsOnShapes[ SMESH_Block::ID_Ex00 ] = SMESH_TNodeXYZ( hexNodes[ 11 ] );
pointsOnShapes[ SMESH_Block::ID_Ex10 ] = SMESH_TNodeXYZ( hexNodes[ 9 ] );
pointsOnShapes[ SMESH_Block::ID_E0y0 ] = SMESH_TNodeXYZ( hexNodes[ 8 ] );
pointsOnShapes[ SMESH_Block::ID_E1y0 ] = SMESH_TNodeXYZ( hexNodes[ 10 ] );
pointsOnShapes[ SMESH_Block::ID_Ex01 ] = SMESH_TNodeXYZ( hexNodes[ 15 ] );
pointsOnShapes[ SMESH_Block::ID_Ex11 ] = SMESH_TNodeXYZ( hexNodes[ 13 ] );
pointsOnShapes[ SMESH_Block::ID_E0y1 ] = SMESH_TNodeXYZ( hexNodes[ 12 ] );
pointsOnShapes[ SMESH_Block::ID_E1y1 ] = SMESH_TNodeXYZ( hexNodes[ 14 ] );
pointsOnShapes[ SMESH_Block::ID_E00z ] = SMESH_TNodeXYZ( hexNodes[ 16 ] );
pointsOnShapes[ SMESH_Block::ID_E10z ] = SMESH_TNodeXYZ( hexNodes[ 19 ] );
pointsOnShapes[ SMESH_Block::ID_E01z ] = SMESH_TNodeXYZ( hexNodes[ 17 ] );
pointsOnShapes[ SMESH_Block::ID_E11z ] = SMESH_TNodeXYZ( hexNodes[ 18 ] );
pointsOnShapes[ SMESH_Block::ID_Fxy0 ] = SMESH_TNodeXYZ( hexNodes[ 20 ] );
pointsOnShapes[ SMESH_Block::ID_Fxy1 ] = SMESH_TNodeXYZ( hexNodes[ 25 ] );
pointsOnShapes[ SMESH_Block::ID_Fx0z ] = SMESH_TNodeXYZ( hexNodes[ 21 ] );
pointsOnShapes[ SMESH_Block::ID_Fx1z ] = SMESH_TNodeXYZ( hexNodes[ 23 ] );
pointsOnShapes[ SMESH_Block::ID_F0yz ] = SMESH_TNodeXYZ( hexNodes[ 24 ] );
pointsOnShapes[ SMESH_Block::ID_F1yz ] = SMESH_TNodeXYZ( hexNodes[ 22 ] );
gp_XYZ nCenterParams(0.5, 0.5, 0.5), nCenterCoords;
SMESH_Block::ShellPoint( nCenterParams, pointsOnShapes, nCenterCoords );
GetMeshDS()->MoveNode( hexNodes[26],
nCenterCoords.X(), nCenterCoords.Y(), nCenterCoords.Z());
} }
} }

129
src/SMESH/SMESH_MesherHelper.hxx
View File

@ -72,7 +72,7 @@ typedef gp_XY (*xyFunPtr)(const gp_XY& uv1, const gp_XY& uv2);
class SMESH_EXPORT SMESH_MesherHelper class SMESH_EXPORT SMESH_MesherHelper
{ {
public: public:
// ---------- PUBLIC UTILITIES ---------- // ---------- PUBLIC UTILITIES ----------
/*! /*!
@ -146,6 +146,36 @@ public:
return ind; return ind;
} }
/*!
* \brief Return UV of a point inside a quadrilateral FACE by it's
* normalized parameters within a unit quadrangle and the
* corresponding projections on sub-shapes of the real-world FACE.
* The used calculation method is called Trans-Finite Interpolation (TFI).
* \param x,y - normalized parameters that should be in range [0,1]
* \param a0,a1,a2,a3 - UV of VERTEXes of the FACE == projections on VERTEXes
* \param p0,p1,p2,p3 - UV of the point projections on EDGEs of the FACE
* \return gp_XY - UV of the point on the FACE
*
* Order of those UV in the FACE is as follows.
* a4 p3 a3
* o---x-----o
* | : |
* | :UV |
* p4 x...O.....x p2
* | : |
* o---x-----o
* a1 p1 a2
*/
inline static gp_XY calcTFI(double x, double y,
const gp_XY a0,const gp_XY a1,const gp_XY a2,const gp_XY a3,
const gp_XY p0,const gp_XY p1,const gp_XY p2,const gp_XY p3);
/*!
* \brief Same as "gp_XY calcTFI(...)" but in 3D
*/
inline static gp_XYZ calcTFI(double x, double y,
const gp_XYZ a0,const gp_XYZ a1,const gp_XYZ a2,const gp_XYZ a3,
const gp_XYZ p0,const gp_XYZ p1,const gp_XYZ p2,const gp_XYZ p3);
/*! /*!
* \brief Count nb of sub-shapes * \brief Count nb of sub-shapes
* \param shape - the shape * \param shape - the shape
@ -214,8 +244,19 @@ public:
/*! /*!
* \brief Set order of elements to create without calling IsQuadraticSubMesh() * \brief Set order of elements to create without calling IsQuadraticSubMesh()
*/ */
/*!
* \brief Set myCreateQuadratic flag
*/
void SetIsQuadratic(const bool theBuildQuadratic) void SetIsQuadratic(const bool theBuildQuadratic)
{ myCreateQuadratic = theBuildQuadratic; } { myCreateQuadratic = theBuildQuadratic; }
/*!
* \brief Set myCreateBiQuadratic flag
*/
void SetIsBiQuadratic(const bool theBuildBiQuadratic)
{ myCreateBiQuadratic = theBuildBiQuadratic; }
/*! /*!
* \brief Return myCreateQuadratic flag * \brief Return myCreateQuadratic flag
*/ */
@ -226,6 +267,11 @@ public:
*/ */
bool IsReversedSubMesh (const TopoDS_Face& theFace); bool IsReversedSubMesh (const TopoDS_Face& theFace);
/*!
* \brief Return myCreateBiQuadratic flag
*/
bool GetIsBiQuadratic() const { return myCreateBiQuadratic; }
/*! /*!
* \brief Move medium nodes of faces and volumes to fix distorted elements * \brief Move medium nodes of faces and volumes to fix distorted elements
* \param error - container of fixed distorted elements * \param error - container of fixed distorted elements
@ -276,7 +322,7 @@ public:
const int id=0, const int id=0,
const bool force3d = false); const bool force3d = false);
/*! /*!
* Creates quadratic or linear quadrangle * Creates bi-quadratic, quadratic or linear quadrangle
*/ */
SMDS_MeshFace* AddFace(const SMDS_MeshNode* n1, SMDS_MeshFace* AddFace(const SMDS_MeshNode* n1,
const SMDS_MeshNode* n2, const SMDS_MeshNode* n2,
@ -284,7 +330,6 @@ public:
const SMDS_MeshNode* n4, const SMDS_MeshNode* n4,
const int id = 0, const int id = 0,
const bool force3d = false); const bool force3d = false);
/*! /*!
* Creates polygon, with additional nodes in quadratic mesh * Creates polygon, with additional nodes in quadratic mesh
*/ */
@ -322,7 +367,7 @@ public:
const int id = 0, const int id = 0,
const bool force3d = true); const bool force3d = true);
/*! /*!
* Creates quadratic or linear hexahedron * Creates bi-quadratic, quadratic or linear hexahedron
*/ */
SMDS_MeshVolume* AddVolume(const SMDS_MeshNode* n1, SMDS_MeshVolume* AddVolume(const SMDS_MeshNode* n1,
const SMDS_MeshNode* n2, const SMDS_MeshNode* n2,
@ -525,11 +570,27 @@ public:
const SMDS_MeshNode* GetMediumNode(const SMDS_MeshNode* n1, const SMDS_MeshNode* GetMediumNode(const SMDS_MeshNode* n1,
const SMDS_MeshNode* n2, const SMDS_MeshNode* n2,
const bool force3d); const bool force3d);
/*!
* \brief Return existing or create a new central node for a quardilateral
* quadratic face given its 8 nodes.
* \param force3d - true means node creation in between the given nodes,
* else node position is found on a geometrical face if any.
*/
const SMDS_MeshNode* GetCentralNode(const SMDS_MeshNode* n1,
const SMDS_MeshNode* n2,
const SMDS_MeshNode* n3,
const SMDS_MeshNode* n4,
const SMDS_MeshNode* n12,
const SMDS_MeshNode* n23,
const SMDS_MeshNode* n34,
const SMDS_MeshNode* n41,
bool force3d);
/*! /*!
* \brief Return index and type of the shape (EDGE or FACE only) to set a medium node on * \brief Return index and type of the shape (EDGE or FACE only) to set a medium node on
*/ */
std::pair<int, TopAbs_ShapeEnum> GetMediumPos(const SMDS_MeshNode* n1, std::pair<int, TopAbs_ShapeEnum> GetMediumPos(const SMDS_MeshNode* n1,
const SMDS_MeshNode* n2); const SMDS_MeshNode* n2,
const bool useCurSubShape=false);
/*! /*!
* \brief Add a link in my data structure * \brief Add a link in my data structure
*/ */
@ -561,13 +622,13 @@ public:
virtual ~SMESH_MesherHelper(); virtual ~SMESH_MesherHelper();
protected: protected:
/*! /*!
* \brief Select UV on either of 2 pcurves of a seam edge, closest to the given UV * \brief Select UV on either of 2 pcurves of a seam edge, closest to the given UV
* \param uv1 - UV on the seam * \param uv1 - UV on the seam
* \param uv2 - UV within a face * \param uv2 - UV within a face
* \retval gp_Pnt2d - selected UV * \retval gp_Pnt2d - selected UV
*/ */
gp_Pnt2d GetUVOnSeam( const gp_Pnt2d& uv1, const gp_Pnt2d& uv2 ) const; gp_Pnt2d GetUVOnSeam( const gp_Pnt2d& uv1, const gp_Pnt2d& uv2 ) const;
@ -577,10 +638,31 @@ protected:
private: private:
// Forbiden copy constructor // Forbiden copy constructor
SMESH_MesherHelper (const SMESH_MesherHelper& theOther) {}; SMESH_MesherHelper (const SMESH_MesherHelper& theOther);
// special map for using during creation of quadratic elements // key of a map of bi-quadratic face to it's central node
TLinkNodeMap myTLinkNodeMap; struct TBiQuad: public std::pair<int, std::pair<int, int> >
{
TBiQuad(const SMDS_MeshNode* n1,
const SMDS_MeshNode* n2,
const SMDS_MeshNode* n3,
const SMDS_MeshNode* n4)
{
TIDSortedNodeSet s;
s.insert(n1);
s.insert(n2);
s.insert(n3);
s.insert(n4);
TIDSortedNodeSet::iterator n = s.begin();
first = (*n++)->GetID();
second.first = (*n++)->GetID();
second.second = (*n++)->GetID();
}
};
// maps used during creation of quadratic elements
TLinkNodeMap myTLinkNodeMap; // medium nodes on links
std::map< TBiQuad, SMDS_MeshNode* > myMapWithCentralNode; // central nodes of faces
std::set< int > myDegenShapeIds; std::set< int > myDegenShapeIds;
std::set< int > mySeamShapeIds; std::set< int > mySeamShapeIds;
@ -597,14 +679,35 @@ protected:
int myShapeID; int myShapeID;
bool myCreateQuadratic; bool myCreateQuadratic;
bool myCreateBiQuadratic;
bool mySetElemOnShape; bool mySetElemOnShape;
bool myFixNodeParameters; bool myFixNodeParameters;
std::map< int,bool > myNodePosShapesValidity; std::map< int,bool > myNodePosShapesValidity;
bool toCheckPosOnShape(int shapeID ) const; bool toCheckPosOnShape(int shapeID ) const;
void setPosOnShapeValidity(int shapeID, bool ok ) const; void setPosOnShapeValidity(int shapeID, bool ok ) const;
}; };
//=======================================================================
inline gp_XY
SMESH_MesherHelper::calcTFI(double x, double y,
const gp_XY a0,const gp_XY a1,const gp_XY a2,const gp_XY a3,
const gp_XY p0,const gp_XY p1,const gp_XY p2,const gp_XY p3)
{
return
((1 - y) * p0 + x * p1 + y * p2 + (1 - x) * p3 ) -
((1 - x) * (1 - y) * a0 + x * (1 - y) * a1 + x * y * a2 + (1 - x) * y * a3);
}
//=======================================================================
inline gp_XYZ
SMESH_MesherHelper::calcTFI(double x, double y,
const gp_XYZ a0,const gp_XYZ a1,const gp_XYZ a2,const gp_XYZ a3,
const gp_XYZ p0,const gp_XYZ p1,const gp_XYZ p2,const gp_XYZ p3)
{
return
((1 - y) * p0 + x * p1 + y * p2 + (1 - x) * p3 ) -
((1 - x) * (1 - y) * a0 + x * (1 - y) * a1 + x * y * a2 + (1 - x) * y * a3);
}
//=======================================================================
#endif #endif

96
src/SMESH/SMESH_subMesh.cxx
View File

@ -647,7 +647,7 @@ SMESH_Hypothesis::Hypothesis_Status
int oldAlgoState = _algoState; int oldAlgoState = _algoState;
bool modifiedHyp = (event == MODIF_HYP); // if set to true, force event MODIF_ALGO_STATE bool modifiedHyp = (event == MODIF_HYP); // if set to true, force event MODIF_ALGO_STATE
bool needFullClean = false, subMeshesSupported = false; SMESH_Algo* algoRequiringCleaning = 0;
bool isApplicableHyp = IsApplicableHypotesis( anHyp ); bool isApplicableHyp = IsApplicableHypotesis( anHyp );
@ -671,7 +671,8 @@ SMESH_Hypothesis::Hypothesis_Status
filter.Or( SMESH_HypoFilter::HasType( algo->GetType()+1 )); filter.Or( SMESH_HypoFilter::HasType( algo->GetType()+1 ));
filter.Or( SMESH_HypoFilter::HasType( algo->GetType()+2 )); filter.Or( SMESH_HypoFilter::HasType( algo->GetType()+2 ));
if ( SMESH_Algo * curAlgo = (SMESH_Algo*)_father->GetHypothesis(_subShape, filter, true )) if ( SMESH_Algo * curAlgo = (SMESH_Algo*)_father->GetHypothesis(_subShape, filter, true ))
needFullClean = ( !curAlgo->NeedDiscreteBoundary() ); if ( !curAlgo->NeedDiscreteBoundary() )
algoRequiringCleaning = curAlgo;
} }
} }
@ -702,13 +703,7 @@ SMESH_Hypothesis::Hypothesis_Status
{ {
algo = dynamic_cast<SMESH_Algo*> (anHyp); algo = dynamic_cast<SMESH_Algo*> (anHyp);
if (!algo->NeedDiscreteBoundary()) if (!algo->NeedDiscreteBoundary())
{ algoRequiringCleaning = algo;
// clean all mesh in the tree of the current submesh;
// we must perform it now because later
// we will have no information about the type of the removed algo
needFullClean = true;
subMeshesSupported = algo->SupportSubmeshes();
}
} }
} }
@ -990,10 +985,7 @@ SMESH_Hypothesis::Hypothesis_Status
// CLEAN was not called at event REMOVE_ALGO because the algo is not applicable to SOLID. // CLEAN was not called at event REMOVE_ALGO because the algo is not applicable to SOLID.
algo = dynamic_cast<SMESH_Algo*> (anHyp); algo = dynamic_cast<SMESH_Algo*> (anHyp);
if (!algo->NeedDiscreteBoundary()) if (!algo->NeedDiscreteBoundary())
{ algoRequiringCleaning = algo;
needFullClean = true;
subMeshesSupported = algo->SupportSubmeshes();
}
algo = GetAlgo(); algo = GetAlgo();
if (algo == NULL) // no more applying algo on father if (algo == NULL) // no more applying algo on father
{ {
@ -1069,10 +1061,10 @@ SMESH_Hypothesis::Hypothesis_Status
} }
} }
if ( needFullClean ) { if ( algoRequiringCleaning ) {
// added or removed algo is all-dimensional // added or removed algo is all-dimensional
ComputeStateEngine( CLEAN ); ComputeStateEngine( CLEAN );
cleanDependsOn( subMeshesSupported ); cleanDependsOn( algoRequiringCleaning );
ComputeSubMeshStateEngine( CHECK_COMPUTE_STATE ); ComputeSubMeshStateEngine( CHECK_COMPUTE_STATE );
} }
@ -1174,45 +1166,67 @@ SMESH_Hypothesis::Hypothesis_Status
//================================================================================ //================================================================================
/*! /*!
* \brief Remove elements from sub-meshes. * \brief Remove elements from sub-meshes.
* \param keepSupportedsubMeshes - if true, the sub-meshes computed using more * \param algoRequiringCleaning - an all-dimensional algorithm whose presence
* local algorithms are not cleaned * causes the cleaning.
*/ */
//================================================================================ //================================================================================
void SMESH_subMesh::cleanDependsOn( bool keepSupportedsubMeshes ) void SMESH_subMesh::cleanDependsOn( SMESH_Algo* algoRequiringCleaning/*=0*/ )
{ {
if ( _father->NbNodes() == 0 ) return;
SMESH_subMeshIteratorPtr smIt = getDependsOnIterator(false, SMESH_subMeshIteratorPtr smIt = getDependsOnIterator(false,
/*complexShapeFirst=*/true); /*complexShapeFirst=*/true);
if ( !keepSupportedsubMeshes ) if ( _father->NbNodes() == 0 )
{
while ( smIt->more() )
smIt->next()->ComputeStateEngine(CHECK_COMPUTE_STATE);
}
else if ( !algoRequiringCleaning || !algoRequiringCleaning->SupportSubmeshes() )
{ {
while ( smIt->more() ) while ( smIt->more() )
smIt->next()->ComputeStateEngine(CLEAN); smIt->next()->ComputeStateEngine(CLEAN);
} }
else else if ( algoRequiringCleaning && algoRequiringCleaning->SupportSubmeshes() )
{ {
SMESHDS_Mesh* meshDS = _father->GetMeshDS();
// find sub-meshes to keep elements on // find sub-meshes to keep elements on
set< SMESH_subMesh* > smToKeep; set< SMESH_subMesh* > smToKeep;
SMESHDS_Mesh* meshDS = _father->GetMeshDS(); TopAbs_ShapeEnum prevShapeType = TopAbs_SHAPE;
bool toKeepPrevShapeType = false;
while ( smIt->more() ) while ( smIt->more() )
{ {
SMESH_subMesh* sm = smIt->next(); SMESH_subMesh* sm = smIt->next();
if ( sm->IsEmpty() ) continue; sm->ComputeStateEngine(CHECK_COMPUTE_STATE);
if ( !sm->IsEmpty() )
// look for an algo assigned to sm
bool algoFound = false;
const list<const SMESHDS_Hypothesis*>& hyps = meshDS->GetHypothesis( sm->_subShape );
list<const SMESHDS_Hypothesis*>::const_iterator h = hyps.begin();
for ( ; ( !algoFound && h != hyps.end() ); ++h )
algoFound = ((*h)->GetType() != SMESHDS_Hypothesis::PARAM_ALGO );
// remember all sub-meshes of sm
if ( algoFound )
{ {
SMESH_subMeshIteratorPtr smIt2 = getDependsOnIterator(false,true); const bool sameShapeType = ( prevShapeType == sm->GetSubShape().ShapeType() );
while ( smIt2->more() ) bool keepSubMeshes = ( sameShapeType && toKeepPrevShapeType );
smToKeep.insert( smIt2->next() ); if ( !sameShapeType )
{
// check if the algo allows presence of global algos of dimension the algo
// can generate it-self
int shapeDim = SMESH_Gen::GetShapeDim( sm->GetSubShape() );
keepSubMeshes = algoRequiringCleaning->NeedLowerHyps( shapeDim );
prevShapeType = sm->GetSubShape().ShapeType();
toKeepPrevShapeType = keepSubMeshes;
}
if ( !keepSubMeshes )
{
// look for an algo assigned to sm
bool algoFound = false;
const list<const SMESHDS_Hypothesis*>& hyps = meshDS->GetHypothesis( sm->_subShape );
list<const SMESHDS_Hypothesis*>::const_iterator h = hyps.begin();
for ( ; ( !algoFound && h != hyps.end() ); ++h )
algoFound = ((*h)->GetType() != SMESHDS_Hypothesis::PARAM_ALGO );
keepSubMeshes = algoFound;
}
// remember all sub-meshes of sm
if ( keepSubMeshes )
{
SMESH_subMeshIteratorPtr smIt2 = getDependsOnIterator(false,true);
while ( smIt2->more() )
smToKeep.insert( smIt2->next() );
}
} }
} }
// remove elements // remove elements
@ -1374,7 +1388,7 @@ bool SMESH_subMesh::ComputeStateEngine(int event)
case MODIF_ALGO_STATE: case MODIF_ALGO_STATE:
algo = GetAlgo(); algo = GetAlgo();
if (algo && !algo->NeedDiscreteBoundary()) if (algo && !algo->NeedDiscreteBoundary())
cleanDependsOn( algo->SupportSubmeshes() ); // clean sub-meshes with event CLEAN cleanDependsOn( algo ); // clean sub-meshes with event CLEAN
if ( _algoState == HYP_OK ) if ( _algoState == HYP_OK )
_computeState = READY_TO_COMPUTE; _computeState = READY_TO_COMPUTE;
break; break;
@ -1420,7 +1434,7 @@ bool SMESH_subMesh::ComputeStateEngine(int event)
if (algo) if (algo)
{ {
if (!algo->NeedDiscreteBoundary()) if (!algo->NeedDiscreteBoundary())
cleanDependsOn( algo->SupportSubmeshes() ); // clean sub-meshes with event CLEAN cleanDependsOn( algo ); // clean sub-meshes with event CLEAN
if ( _algoState == HYP_OK ) if ( _algoState == HYP_OK )
_computeState = READY_TO_COMPUTE; _computeState = READY_TO_COMPUTE;
} }
@ -1646,7 +1660,7 @@ bool SMESH_subMesh::ComputeStateEngine(int event)
ComputeStateEngine( CLEAN ); ComputeStateEngine( CLEAN );
algo = GetAlgo(); algo = GetAlgo();
if (algo && !algo->NeedDiscreteBoundary()) if (algo && !algo->NeedDiscreteBoundary())
cleanDependsOn( algo->SupportSubmeshes() ); // clean sub-meshes with event CLEAN cleanDependsOn( algo ); // clean sub-meshes with event CLEAN
break; break;
case COMPUTE: // nothing to do case COMPUTE: // nothing to do
break; break;
@ -1701,7 +1715,7 @@ bool SMESH_subMesh::ComputeStateEngine(int event)
ComputeStateEngine( CLEAN ); ComputeStateEngine( CLEAN );
algo = GetAlgo(); algo = GetAlgo();
if (algo && !algo->NeedDiscreteBoundary()) if (algo && !algo->NeedDiscreteBoundary())
cleanDependsOn( algo->SupportSubmeshes() ); // clean sub-meshes with event CLEAN cleanDependsOn( algo ); // clean sub-meshes with event CLEAN
if (_algoState == HYP_OK) if (_algoState == HYP_OK)
_computeState = READY_TO_COMPUTE; _computeState = READY_TO_COMPUTE;
else else

2
src/SMESH/SMESH_subMesh.hxx
View File

@ -273,7 +273,7 @@ protected:
void updateDependantsState(const compute_event theEvent); void updateDependantsState(const compute_event theEvent);
void updateSubMeshState(const compute_state theState); void updateSubMeshState(const compute_state theState);
void cleanDependants(); void cleanDependants();
void cleanDependsOn( bool keepSupportedsubMeshes = false ); void cleanDependsOn( SMESH_Algo* algoRequiringCleaning=0 );
void setAlgoState(algo_state state); void setAlgoState(algo_state state);
/*! /*!

14
src/SMESHGUI/SMESHGUI.cxx
View File

@ -1256,7 +1256,7 @@
return; return;
} }
case 1132: { case 1132: {
vtkFloatingPointType color[3]; double color[3];
QColor faceColor, edgeColor, nodeColor, elem0dColor, ballColor; QColor faceColor, edgeColor, nodeColor, elem0dColor, ballColor;
QColor orientationColor, outlineColor, volumeColor; QColor orientationColor, outlineColor, volumeColor;
int deltaF = 0, deltaV = 0; int deltaF = 0, deltaV = 0;
@ -1264,8 +1264,8 @@
int ballSize = 1; int ballSize = 1;
int edgeWidth = 1; int edgeWidth = 1;
int outlineWidth = 1; int outlineWidth = 1;
vtkFloatingPointType shrinkCoef = 0.0; double shrinkCoef = 0.0;
vtkFloatingPointType orientationScale = 0.0; double orientationScale = 0.0;
bool orientation3d = false; bool orientation3d = false;
VTK::MarkerType markerType = VTK::MT_NONE; VTK::MarkerType markerType = VTK::MT_NONE;
VTK::MarkerScale markerScale = VTK::MS_NONE; VTK::MarkerScale markerScale = VTK::MS_NONE;
@ -5456,7 +5456,7 @@ void SMESHGUI::storeVisualParameters (int savePoint)
ip->setParameter(entry, param, modeStr.toLatin1().data()); ip->setParameter(entry, param, modeStr.toLatin1().data());
// Colors // Colors
vtkFloatingPointType r, g, b; double r, g, b;
int delta; int delta;
aSmeshActor->GetSufaceColor(r, g, b, delta); aSmeshActor->GetSufaceColor(r, g, b, delta);
@ -5595,8 +5595,8 @@ void SMESHGUI::storeVisualParameters (int savePoint)
typedef struct { typedef struct {
int Id; int Id;
vtkIdType Orientation; vtkIdType Orientation;
vtkFloatingPointType Distance; double Distance;
vtkFloatingPointType Angle[2]; double Angle[2];
} TPlaneData; } TPlaneData;
typedef std::list<TPlaneData> TPlaneDataList; typedef std::list<TPlaneData> TPlaneDataList;
typedef std::map<int, TPlaneDataList> TPlaneDataMap; typedef std::map<int, TPlaneDataList> TPlaneDataMap;
@ -6171,7 +6171,7 @@ void SMESHGUI::restoreVisualParameters (int savePoint)
if (val != "Off") { if (val != "Off") {
SMESH::Orientation anOrientation = (SMESH::Orientation)vals[0].toInt(); SMESH::Orientation anOrientation = (SMESH::Orientation)vals[0].toInt();
double aDistance = vals[1].toFloat(); double aDistance = vals[1].toFloat();
vtkFloatingPointType anAngle[2]; double anAngle[2];
anAngle[0] = vals[2].toFloat(); anAngle[0] = vals[2].toFloat();
anAngle[1] = vals[3].toFloat(); anAngle[1] = vals[3].toFloat();

2
src/SMESHGUI/SMESHGUI.h
View File

@ -221,7 +221,7 @@ private :
SMESHGUI_ClippingPlaneInfoMap myClippingPlaneInfoMap; SMESHGUI_ClippingPlaneInfoMap myClippingPlaneInfoMap;
vtkSmartPointer<vtkCallbackCommand> myEventCallbackCommand; vtkSmartPointer<vtkCallbackCommand> myEventCallbackCommand;
vtkFloatingPointType myPriority; double myPriority;
}; };
#endif // SMESHGUI_H #endif // SMESHGUI_H

8
src/SMESHGUI/SMESHGUI_AddMeshElementDlg.cxx
View File

@ -113,14 +113,14 @@ namespace SMESH
// Create and display actor // Create and display actor
myMapper = vtkDataSetMapper::New(); myMapper = vtkDataSetMapper::New();
myMapper->SetInput(myGrid); myMapper->SetInputData(myGrid);
myPreviewActor = SALOME_Actor::New(); myPreviewActor = SALOME_Actor::New();
myPreviewActor->PickableOff(); myPreviewActor->PickableOff();
myPreviewActor->VisibilityOff(); myPreviewActor->VisibilityOff();
myPreviewActor->SetMapper(myMapper); myPreviewActor->SetMapper(myMapper);
vtkFloatingPointType anRGB[3]; double anRGB[3];
vtkProperty* aProp = vtkProperty::New(); vtkProperty* aProp = vtkProperty::New();
GetColor( "SMESH", "fill_color", anRGB[0], anRGB[1], anRGB[2], QColor( 0, 170, 255 ) ); GetColor( "SMESH", "fill_color", anRGB[0], anRGB[1], anRGB[2], QColor( 0, 170, 255 ) );
aProp->SetColor( anRGB[0], anRGB[1], anRGB[2] ); aProp->SetColor( anRGB[0], anRGB[1], anRGB[2] );
@ -137,10 +137,10 @@ namespace SMESH
// Orientation of faces // Orientation of faces
myFaceOrientationFilter = SMESH_FaceOrientationFilter::New(); myFaceOrientationFilter = SMESH_FaceOrientationFilter::New();
myFaceOrientationFilter->SetInput(myGrid); myFaceOrientationFilter->SetInputData(myGrid);
myFaceOrientationDataMapper = vtkPolyDataMapper::New(); myFaceOrientationDataMapper = vtkPolyDataMapper::New();
myFaceOrientationDataMapper->SetInput(myFaceOrientationFilter->GetOutput()); myFaceOrientationDataMapper->SetInputConnection(myFaceOrientationFilter->GetOutputPort());
myFaceOrientation = SALOME_Actor::New(); myFaceOrientation = SALOME_Actor::New();
myFaceOrientation->PickableOff(); myFaceOrientation->PickableOff();

10
src/SMESHGUI/SMESHGUI_AddQuadraticElementDlg.cxx
View File

@ -121,7 +121,7 @@ namespace SMESH
vtkUnstructuredGrid* myGrid; vtkUnstructuredGrid* myGrid;
//vtkProperty* myBackProp, *myProp; //vtkProperty* myBackProp, *myProp;
//vtkFloatingPointType myRGB[3], myBackRGB[3]; //double myRGB[3], myBackRGB[3];
SALOME_Actor* myFaceOrientation; SALOME_Actor* myFaceOrientation;
vtkPolyDataMapper* myFaceOrientationDataMapper; vtkPolyDataMapper* myFaceOrientationDataMapper;
@ -140,7 +140,7 @@ namespace SMESH
// Create and display actor // Create and display actor
myMapper = vtkDataSetMapper::New(); myMapper = vtkDataSetMapper::New();
myMapper->SetInput(myGrid); myMapper->SetInputData(myGrid);
myPreviewActor = SALOME_Actor::New(); myPreviewActor = SALOME_Actor::New();
myPreviewActor->PickableOff(); myPreviewActor->PickableOff();
@ -148,7 +148,7 @@ namespace SMESH
myPreviewActor->SetMapper(myMapper); myPreviewActor->SetMapper(myMapper);
vtkProperty* myProp = vtkProperty::New(); vtkProperty* myProp = vtkProperty::New();
vtkFloatingPointType aRGB[3], aBackRGB[3]; double aRGB[3], aBackRGB[3];
GetColor( "SMESH", "fill_color", aRGB[0], aRGB[1], aRGB[2], QColor( 0, 170, 255 ) ); GetColor( "SMESH", "fill_color", aRGB[0], aRGB[1], aRGB[2], QColor( 0, 170, 255 ) );
myProp->SetColor( aRGB[0], aRGB[1], aRGB[2] ); myProp->SetColor( aRGB[0], aRGB[1], aRGB[2] );
myPreviewActor->SetProperty( myProp ); myPreviewActor->SetProperty( myProp );
@ -164,10 +164,10 @@ namespace SMESH
// Orientation of faces // Orientation of faces
myFaceOrientationFilter = SMESH_FaceOrientationFilter::New(); myFaceOrientationFilter = SMESH_FaceOrientationFilter::New();
myFaceOrientationFilter->SetInput(myGrid); myFaceOrientationFilter->SetInputData(myGrid);
myFaceOrientationDataMapper = vtkPolyDataMapper::New(); myFaceOrientationDataMapper = vtkPolyDataMapper::New();
myFaceOrientationDataMapper->SetInput(myFaceOrientationFilter->GetOutput()); myFaceOrientationDataMapper->SetInputConnection(myFaceOrientationFilter->GetOutputPort());
myFaceOrientation = SALOME_Actor::New(); myFaceOrientation = SALOME_Actor::New();
myFaceOrientation->PickableOff(); myFaceOrientation->PickableOff();

79
src/SMESHGUI/SMESHGUI_ClippingDlg.cxx
View File

@ -105,6 +105,7 @@ void SMESH::OrientedPlane::ShallowCopy(SMESH::OrientedPlane* theOrientedPlane)
myPlaneSource->SetOrigin(theOrientedPlane->myPlaneSource->GetOrigin()); myPlaneSource->SetOrigin(theOrientedPlane->myPlaneSource->GetOrigin());
myPlaneSource->SetPoint1(theOrientedPlane->myPlaneSource->GetPoint1()); myPlaneSource->SetPoint1(theOrientedPlane->myPlaneSource->GetPoint1());
myPlaneSource->SetPoint2(theOrientedPlane->myPlaneSource->GetPoint2()); myPlaneSource->SetPoint2(theOrientedPlane->myPlaneSource->GetPoint2());
myPlaneSource->Update();
} }
SMESH::OrientedPlane::OrientedPlane(SVTK_ViewWindow* theViewWindow): SMESH::OrientedPlane::OrientedPlane(SVTK_ViewWindow* theViewWindow):
@ -132,7 +133,7 @@ void SMESH::OrientedPlane::Init()
// Create and display actor // Create and display actor
myMapper = vtkDataSetMapper::New(); myMapper = vtkDataSetMapper::New();
myMapper->SetInput(myPlaneSource->GetOutput()); myMapper->SetInputConnection(myPlaneSource->GetOutputPort());
myActor = SALOME_Actor::New(); myActor = SALOME_Actor::New();
myActor->VisibilityOff(); myActor->VisibilityOff();
@ -140,7 +141,7 @@ void SMESH::OrientedPlane::Init()
myActor->SetInfinitive(true); myActor->SetInfinitive(true);
myActor->SetMapper(myMapper); myActor->SetMapper(myMapper);
vtkFloatingPointType anRGB[3]; double anRGB[3];
vtkProperty* aProp = vtkProperty::New(); vtkProperty* aProp = vtkProperty::New();
SMESH::GetColor( "SMESH", "fill_color", anRGB[0], anRGB[1], anRGB[2], QColor( 0, 170, 255 ) ); SMESH::GetColor( "SMESH", "fill_color", anRGB[0], anRGB[1], anRGB[2], QColor( 0, 170, 255 ) );
aProp->SetColor(anRGB[0],anRGB[1],anRGB[2]); aProp->SetColor(anRGB[0],anRGB[1],anRGB[2]);
@ -208,7 +209,7 @@ SMESH::OrientedPlane* SMESHGUI_ClippingDlg::AddPlane (SMESH::TActorList
SVTK_ViewWindow* theViewWindow, SVTK_ViewWindow* theViewWindow,
SMESH::Orientation theOrientation, SMESH::Orientation theOrientation,
double theDistance, double theDistance,
const vtkFloatingPointType theAngle[2]) const double theAngle[2])
{ {
SMESH::OrientedPlane* aPlane = SMESH::OrientedPlane::New(theViewWindow); SMESH::OrientedPlane* aPlane = SMESH::OrientedPlane::New(theViewWindow);
@ -218,13 +219,13 @@ SMESH::OrientedPlane* SMESHGUI_ClippingDlg::AddPlane (SMESH::TActorList
aPlane->SetOrientation(theOrientation); aPlane->SetOrientation(theOrientation);
aPlane->SetDistance(theDistance); aPlane->SetDistance(theDistance);
vtkFloatingPointType aNormal[3]; double aNormal[3];
vtkFloatingPointType aDir[2][3] = {{0, 0, 0}, {0, 0, 0}}; double aDir[2][3] = {{0, 0, 0}, {0, 0, 0}};
{ {
static double aCoeff = vtkMath::Pi()/180.0; static double aCoeff = vtkMath::Pi()/180.0;
vtkFloatingPointType anU[2] = {cos(aCoeff * theAngle[0]), cos(aCoeff * theAngle[1])}; double anU[2] = {cos(aCoeff * theAngle[0]), cos(aCoeff * theAngle[1])};
vtkFloatingPointType aV[2] = {sqrt(1.0 - anU[0]*anU[0]), sqrt(1.0 - anU[1]*anU[1])}; double aV[2] = {sqrt(1.0 - anU[0]*anU[0]), sqrt(1.0 - anU[1]*anU[1])};
aV[0] = theAngle[0] > 0? aV[0]: -aV[0]; aV[0] = theAngle[0] > 0? aV[0]: -aV[0];
aV[1] = theAngle[1] > 0? aV[1]: -aV[1]; aV[1] = theAngle[1] > 0? aV[1]: -aV[1];
@ -260,8 +261,8 @@ SMESH::OrientedPlane* SMESHGUI_ClippingDlg::AddPlane (SMESH::TActorList
vtkMath::Cross(aNormal,aDir[1],aDir[0]); vtkMath::Cross(aNormal,aDir[1],aDir[0]);
} }
vtkFloatingPointType aBounds[6]; double aBounds[6];
vtkFloatingPointType anOrigin[3]; double anOrigin[3];
bool anIsOk = false; bool anIsOk = false;
if( theActorList.empty() ) { if( theActorList.empty() ) {
@ -284,38 +285,38 @@ SMESH::OrientedPlane* SMESHGUI_ClippingDlg::AddPlane (SMESH::TActorList
aPlane->SetNormal( aNormal ); aPlane->SetNormal( aNormal );
aPlane->SetOrigin( anOrigin ); aPlane->SetOrigin( anOrigin );
vtkFloatingPointType aPnt[3] = { ( aBounds[0] + aBounds[1] ) / 2., double aPnt[3] = { ( aBounds[0] + aBounds[1] ) / 2.,
( aBounds[2] + aBounds[3] ) / 2., ( aBounds[2] + aBounds[3] ) / 2.,
( aBounds[4] + aBounds[5] ) / 2. }; ( aBounds[4] + aBounds[5] ) / 2. };
vtkFloatingPointType aDel = pow( pow( aBounds[1] - aBounds[0], 2 ) + double aDel = pow( pow( aBounds[1] - aBounds[0], 2 ) +
pow( aBounds[3] - aBounds[2], 2 ) + pow( aBounds[3] - aBounds[2], 2 ) +
pow( aBounds[5] - aBounds[4], 2 ), 0.5 ); pow( aBounds[5] - aBounds[4], 2 ), 0.5 );
vtkFloatingPointType aDelta[2][3] = {{aDir[0][0]*aDel, aDir[0][1]*aDel, aDir[0][2]*aDel}, double aDelta[2][3] = {{aDir[0][0]*aDel, aDir[0][1]*aDel, aDir[0][2]*aDel},
{aDir[1][0]*aDel, aDir[1][1]*aDel, aDir[1][2]*aDel}}; {aDir[1][0]*aDel, aDir[1][1]*aDel, aDir[1][2]*aDel}};
vtkFloatingPointType aParam, aPnt0[3], aPnt1[3], aPnt2[3]; double aParam, aPnt0[3], aPnt1[3], aPnt2[3];
vtkFloatingPointType aPnt01[3] = {aPnt[0] - aDelta[0][0] - aDelta[1][0], double aPnt01[3] = {aPnt[0] - aDelta[0][0] - aDelta[1][0],
aPnt[1] - aDelta[0][1] - aDelta[1][1], aPnt[1] - aDelta[0][1] - aDelta[1][1],
aPnt[2] - aDelta[0][2] - aDelta[1][2]}; aPnt[2] - aDelta[0][2] - aDelta[1][2]};
vtkFloatingPointType aPnt02[3] = {aPnt01[0] + aNormal[0], double aPnt02[3] = {aPnt01[0] + aNormal[0],
aPnt01[1] + aNormal[1], aPnt01[1] + aNormal[1],
aPnt01[2] + aNormal[2]}; aPnt01[2] + aNormal[2]};
vtkPlane::IntersectWithLine(aPnt01,aPnt02,aNormal,anOrigin,aParam,aPnt0); vtkPlane::IntersectWithLine(aPnt01,aPnt02,aNormal,anOrigin,aParam,aPnt0);
vtkFloatingPointType aPnt11[3] = {aPnt[0] - aDelta[0][0] + aDelta[1][0], double aPnt11[3] = {aPnt[0] - aDelta[0][0] + aDelta[1][0],
aPnt[1] - aDelta[0][1] + aDelta[1][1], aPnt[1] - aDelta[0][1] + aDelta[1][1],
aPnt[2] - aDelta[0][2] + aDelta[1][2]}; aPnt[2] - aDelta[0][2] + aDelta[1][2]};
vtkFloatingPointType aPnt12[3] = {aPnt11[0] + aNormal[0], double aPnt12[3] = {aPnt11[0] + aNormal[0],
aPnt11[1] + aNormal[1], aPnt11[1] + aNormal[1],
aPnt11[2] + aNormal[2]}; aPnt11[2] + aNormal[2]};
vtkPlane::IntersectWithLine(aPnt11,aPnt12,aNormal,anOrigin,aParam,aPnt1); vtkPlane::IntersectWithLine(aPnt11,aPnt12,aNormal,anOrigin,aParam,aPnt1);
vtkFloatingPointType aPnt21[3] = {aPnt[0] + aDelta[0][0] - aDelta[1][0], double aPnt21[3] = {aPnt[0] + aDelta[0][0] - aDelta[1][0],
aPnt[1] + aDelta[0][1] - aDelta[1][1], aPnt[1] + aDelta[0][1] - aDelta[1][1],
aPnt[2] + aDelta[0][2] - aDelta[1][2]}; aPnt[2] + aDelta[0][2] - aDelta[1][2]};
vtkFloatingPointType aPnt22[3] = {aPnt21[0] + aNormal[0], double aPnt22[3] = {aPnt21[0] + aNormal[0],
aPnt21[1] + aNormal[1], aPnt21[1] + aNormal[1],
aPnt21[2] + aNormal[2]}; aPnt21[2] + aNormal[2]};
vtkPlane::IntersectWithLine(aPnt21,aPnt22,aNormal,anOrigin,aParam,aPnt2); vtkPlane::IntersectWithLine(aPnt21,aPnt22,aNormal,anOrigin,aParam,aPnt2);
@ -325,6 +326,7 @@ SMESH::OrientedPlane* SMESHGUI_ClippingDlg::AddPlane (SMESH::TActorList
aPlaneSource->SetOrigin(aPnt0[0],aPnt0[1],aPnt0[2]); aPlaneSource->SetOrigin(aPnt0[0],aPnt0[1],aPnt0[2]);
aPlaneSource->SetPoint1(aPnt1[0],aPnt1[1],aPnt1[2]); aPlaneSource->SetPoint1(aPnt1[0],aPnt1[1],aPnt1[2]);
aPlaneSource->SetPoint2(aPnt2[0],aPnt2[1],aPnt2[2]); aPlaneSource->SetPoint2(aPnt2[0],aPnt2[1],aPnt2[2]);
aPlaneSource->Update();
SMESH::TActorList::iterator anIter = theActorList.begin(); SMESH::TActorList::iterator anIter = theActorList.begin();
for ( ; anIter != theActorList.end(); anIter++ ) for ( ; anIter != theActorList.end(); anIter++ )
@ -898,18 +900,18 @@ void SMESHGUI_ClippingDlg::SetCurrentPlaneParam()
SMESH::TPlaneData aPlaneData = myPlanes[aCurPlaneIndex]; SMESH::TPlaneData aPlaneData = myPlanes[aCurPlaneIndex];
SMESH::OrientedPlane* aPlane = aPlaneData.Plane.GetPointer(); SMESH::OrientedPlane* aPlane = aPlaneData.Plane.GetPointer();
vtkFloatingPointType aNormal[3]; double aNormal[3];
SMESH::Orientation anOrientation; SMESH::Orientation anOrientation;
vtkFloatingPointType aDir[3][3] = {{0, 0, 0}, {0, 0, 0}}; double aDir[3][3] = {{0, 0, 0}, {0, 0, 0}};
{ {
static double aCoeff = vtkMath::Pi()/180.0; static double aCoeff = vtkMath::Pi()/180.0;
vtkFloatingPointType aRot[2] = {getRotation1(), getRotation2()}; double aRot[2] = {getRotation1(), getRotation2()};
aPlane->myAngle[0] = aRot[0]; aPlane->myAngle[0] = aRot[0];
aPlane->myAngle[1] = aRot[1]; aPlane->myAngle[1] = aRot[1];
vtkFloatingPointType anU[2] = {cos(aCoeff*aRot[0]), cos(aCoeff*aRot[1])}; double anU[2] = {cos(aCoeff*aRot[0]), cos(aCoeff*aRot[1])};
vtkFloatingPointType aV[2] = {sqrt(1.0-anU[0]*anU[0]), sqrt(1.0-anU[1]*anU[1])}; double aV[2] = {sqrt(1.0-anU[0]*anU[0]), sqrt(1.0-anU[1]*anU[1])};
aV[0] = aRot[0] > 0? aV[0]: -aV[0]; aV[0] = aRot[0] > 0? aV[0]: -aV[0];
aV[1] = aRot[1] > 0? aV[1]: -aV[1]; aV[1] = aRot[1] > 0? aV[1]: -aV[1];
@ -956,8 +958,8 @@ void SMESHGUI_ClippingDlg::SetCurrentPlaneParam()
SMESH::TActorList anActorList = aPlaneData.ActorList; SMESH::TActorList anActorList = aPlaneData.ActorList;
vtkFloatingPointType aBounds[6]; double aBounds[6];
vtkFloatingPointType anOrigin[3]; double anOrigin[3];
bool anIsOk = SMESH::ComputeClippingPlaneParameters( anActorList, bool anIsOk = SMESH::ComputeClippingPlaneParameters( anActorList,
aNormal, aNormal,
getDistance(), getDistance(),
@ -970,38 +972,38 @@ void SMESHGUI_ClippingDlg::SetCurrentPlaneParam()
aPlane->SetNormal( aNormal ); aPlane->SetNormal( aNormal );
aPlane->SetOrigin( anOrigin ); aPlane->SetOrigin( anOrigin );
vtkFloatingPointType aPnt[3] = { ( aBounds[0] + aBounds[1] ) / 2., double aPnt[3] = { ( aBounds[0] + aBounds[1] ) / 2.,
( aBounds[2] + aBounds[3] ) / 2., ( aBounds[2] + aBounds[3] ) / 2.,
( aBounds[4] + aBounds[5] ) / 2. }; ( aBounds[4] + aBounds[5] ) / 2. };
vtkFloatingPointType aDel = pow( pow( aBounds[1] - aBounds[0], 2 ) + double aDel = pow( pow( aBounds[1] - aBounds[0], 2 ) +
pow( aBounds[3] - aBounds[2], 2 ) + pow( aBounds[3] - aBounds[2], 2 ) +
pow( aBounds[5] - aBounds[4], 2 ), 0.5 ); pow( aBounds[5] - aBounds[4], 2 ), 0.5 );
vtkFloatingPointType aDelta[2][3] = {{aDir[0][0]*aDel, aDir[0][1]*aDel, aDir[0][2]*aDel}, double aDelta[2][3] = {{aDir[0][0]*aDel, aDir[0][1]*aDel, aDir[0][2]*aDel},
{aDir[1][0]*aDel, aDir[1][1]*aDel, aDir[1][2]*aDel}}; {aDir[1][0]*aDel, aDir[1][1]*aDel, aDir[1][2]*aDel}};
vtkFloatingPointType aParam, aPnt0[3], aPnt1[3], aPnt2[3]; double aParam, aPnt0[3], aPnt1[3], aPnt2[3];
vtkFloatingPointType aPnt01[3] = {aPnt[0] - aDelta[0][0] - aDelta[1][0], double aPnt01[3] = {aPnt[0] - aDelta[0][0] - aDelta[1][0],
aPnt[1] - aDelta[0][1] - aDelta[1][1], aPnt[1] - aDelta[0][1] - aDelta[1][1],
aPnt[2] - aDelta[0][2] - aDelta[1][2]}; aPnt[2] - aDelta[0][2] - aDelta[1][2]};
vtkFloatingPointType aPnt02[3] = {aPnt01[0] + aNormal[0], double aPnt02[3] = {aPnt01[0] + aNormal[0],
aPnt01[1] + aNormal[1], aPnt01[1] + aNormal[1],
aPnt01[2] + aNormal[2]}; aPnt01[2] + aNormal[2]};
vtkPlane::IntersectWithLine(aPnt01,aPnt02,aNormal,anOrigin,aParam,aPnt0); vtkPlane::IntersectWithLine(aPnt01,aPnt02,aNormal,anOrigin,aParam,aPnt0);
vtkFloatingPointType aPnt11[3] = {aPnt[0] - aDelta[0][0] + aDelta[1][0], double aPnt11[3] = {aPnt[0] - aDelta[0][0] + aDelta[1][0],
aPnt[1] - aDelta[0][1] + aDelta[1][1], aPnt[1] - aDelta[0][1] + aDelta[1][1],
aPnt[2] - aDelta[0][2] + aDelta[1][2]}; aPnt[2] - aDelta[0][2] + aDelta[1][2]};
vtkFloatingPointType aPnt12[3] = {aPnt11[0] + aNormal[0], double aPnt12[3] = {aPnt11[0] + aNormal[0],
aPnt11[1] + aNormal[1], aPnt11[1] + aNormal[1],
aPnt11[2] + aNormal[2]}; aPnt11[2] + aNormal[2]};
vtkPlane::IntersectWithLine(aPnt11,aPnt12,aNormal,anOrigin,aParam,aPnt1); vtkPlane::IntersectWithLine(aPnt11,aPnt12,aNormal,anOrigin,aParam,aPnt1);
vtkFloatingPointType aPnt21[3] = {aPnt[0] + aDelta[0][0] - aDelta[1][0], double aPnt21[3] = {aPnt[0] + aDelta[0][0] - aDelta[1][0],
aPnt[1] + aDelta[0][1] - aDelta[1][1], aPnt[1] + aDelta[0][1] - aDelta[1][1],
aPnt[2] + aDelta[0][2] - aDelta[1][2]}; aPnt[2] + aDelta[0][2] - aDelta[1][2]};
vtkFloatingPointType aPnt22[3] = {aPnt21[0] + aNormal[0], double aPnt22[3] = {aPnt21[0] + aNormal[0],
aPnt21[1] + aNormal[1], aPnt21[1] + aNormal[1],
aPnt21[2] + aNormal[2]}; aPnt21[2] + aNormal[2]};
vtkPlane::IntersectWithLine(aPnt21,aPnt22,aNormal,anOrigin,aParam,aPnt2); vtkPlane::IntersectWithLine(aPnt21,aPnt22,aNormal,anOrigin,aParam,aPnt2);
@ -1011,6 +1013,7 @@ void SMESHGUI_ClippingDlg::SetCurrentPlaneParam()
aPlaneSource->SetOrigin(aPnt0[0],aPnt0[1],aPnt0[2]); aPlaneSource->SetOrigin(aPnt0[0],aPnt0[1],aPnt0[2]);
aPlaneSource->SetPoint1(aPnt1[0],aPnt1[1],aPnt1[2]); aPlaneSource->SetPoint1(aPnt1[0],aPnt1[1],aPnt1[2]);
aPlaneSource->SetPoint2(aPnt2[0],aPnt2[1],aPnt2[2]); aPlaneSource->SetPoint2(aPnt2[0],aPnt2[1],aPnt2[2]);
aPlaneSource->Update();
} }
if(AutoApplyCheckBox->isChecked()) if(AutoApplyCheckBox->isChecked())
@ -1148,8 +1151,8 @@ void SMESHGUI_ClippingDlg::dumpPlaneData() const
for ( ; anIter1 != myPlanes.end(); anIter1++, anId++ ) { for ( ; anIter1 != myPlanes.end(); anIter1++, anId++ ) {
SMESH::TPlaneData aPlaneData = *anIter1; SMESH::TPlaneData aPlaneData = *anIter1;
SMESH::TPlane aPlane = aPlaneData.Plane; SMESH::TPlane aPlane = aPlaneData.Plane;
vtkFloatingPointType* aNormal = aPlane->GetNormal(); double* aNormal = aPlane->GetNormal();
vtkFloatingPointType* anOrigin = aPlane->GetOrigin(); double* anOrigin = aPlane->GetOrigin();
printf( "Plane N%d:\n", anId ); printf( "Plane N%d:\n", anId );
printf( " Normal = ( %f, %f, %f )\n", aNormal[0], aNormal[1], aNormal[2] ); printf( " Normal = ( %f, %f, %f )\n", aNormal[0], aNormal[1], aNormal[2] );
printf( " Origin = ( %f, %f, %f )\n", anOrigin[0], anOrigin[1], anOrigin[2] ); printf( " Origin = ( %f, %f, %f )\n", anOrigin[0], anOrigin[1], anOrigin[2] );

2
src/SMESHGUI/SMESHGUI_ClippingDlg.h
View File

@ -145,7 +145,7 @@ public:
SVTK_ViewWindow* theViewWindow, SVTK_ViewWindow* theViewWindow,
SMESH::Orientation theOrientation, SMESH::Orientation theOrientation,
double theDistance, double theDistance,
const vtkFloatingPointType theAngle[2]); const double theAngle[2]);
protected: protected:
void keyPressEvent( QKeyEvent* ); void keyPressEvent( QKeyEvent* );

4
src/SMESHGUI/SMESHGUI_ComputeDlg.cxx
View File

@ -1180,8 +1180,8 @@ void SMESHGUI_BaseComputeOp::onShowBadMesh()
if ( myBadMeshDisplayer ) delete myBadMeshDisplayer; if ( myBadMeshDisplayer ) delete myBadMeshDisplayer;
myBadMeshDisplayer = new SMESHGUI_MeshEditPreview( view ); myBadMeshDisplayer = new SMESHGUI_MeshEditPreview( view );
SMESH::MeshPreviewStruct_var aMeshData = gen->GetBadInputElements(myMesh,curSub); SMESH::MeshPreviewStruct_var aMeshData = gen->GetBadInputElements(myMesh,curSub);
vtkFloatingPointType aPointSize = SMESH::GetFloat("SMESH:node_size",3); double aPointSize = SMESH::GetFloat("SMESH:node_size",3);
vtkFloatingPointType aLineWidth = SMESH::GetFloat("SMESH:element_width",1); double aLineWidth = SMESH::GetFloat("SMESH:element_width",1);
vtkProperty* prop = vtkProperty::New(); vtkProperty* prop = vtkProperty::New();
prop->SetLineWidth( aLineWidth * 3 ); prop->SetLineWidth( aLineWidth * 3 );
prop->SetPointSize( aPointSize * 3 ); prop->SetPointSize( aPointSize * 3 );

51
src/SMESHGUI/SMESHGUI_ConvToQuadDlg.cxx
View File

@ -27,6 +27,8 @@
// //
#include "SMESHGUI_ConvToQuadDlg.h" #include "SMESHGUI_ConvToQuadDlg.h"
#include "SMESHGUI_ConvToQuadOp.h"
// Qt includes // Qt includes
#include <QGroupBox> #include <QGroupBox>
#include <QCheckBox> #include <QCheckBox>
@ -62,14 +64,17 @@ SMESHGUI_ConvToQuadDlg::SMESHGUI_ConvToQuadDlg()
aBGLayout->setMargin(MARGIN); aBGLayout->setMargin(MARGIN);
aBGLayout->setSpacing(SPACING); aBGLayout->setSpacing(SPACING);
myRB1 = new QRadioButton( tr( "RADIOBTN_1" ), myBGBox ); myRB2Lin = new QRadioButton( tr( "RADIOBTN_1" ), myBGBox );
myRB2 = new QRadioButton( tr( "RADIOBTN_2" ), myBGBox ); myRB2Quad = new QRadioButton( tr( "RADIOBTN_2" ), myBGBox );
myRB2BiQua = new QRadioButton( tr( "RADIOBTN_3" ), myBGBox );
aBGLayout->addWidget(myRB1); aBGLayout->addWidget(myRB2Lin);
aBGLayout->addWidget(myRB2); aBGLayout->addWidget(myRB2Quad);
myBG->addButton(myRB1, 0); aBGLayout->addWidget(myRB2BiQua);
myBG->addButton(myRB2, 1); myBG->addButton(myRB2Lin, 0);
myRB1->setChecked( true ); myBG->addButton(myRB2Quad, 1);
myBG->addButton(myRB2BiQua, 2);
myRB2Lin->setChecked( true );
myWarning = new QLabel(QString("<b>%1</b>").arg(tr("NON_CONFORM_WARNING")), mainFrame()); myWarning = new QLabel(QString("<b>%1</b>").arg(tr("NON_CONFORM_WARNING")), mainFrame());
@ -92,6 +97,11 @@ SMESHGUI_ConvToQuadDlg::~SMESHGUI_ConvToQuadDlg()
{ {
} }
bool SMESHGUI_ConvToQuadDlg::IsBiQuadratic() const
{
return myRB2BiQua->isChecked();
}
bool SMESHGUI_ConvToQuadDlg::IsMediumNdsOnGeom() const bool SMESHGUI_ConvToQuadDlg::IsMediumNdsOnGeom() const
{ {
return !myMedNdsOnGeom->isChecked(); return !myMedNdsOnGeom->isChecked();
@ -133,27 +143,32 @@ bool SMESHGUI_ConvToQuadDlg::isWarningShown()
void SMESHGUI_ConvToQuadDlg::SetEnabledControls( const bool theCheck ) void SMESHGUI_ConvToQuadDlg::SetEnabledControls( const bool theCheck )
{ {
//myBGBox->setEnabled( theCheck ); //myBGBox->setEnabled( theCheck );
myRB1->setEnabled( theCheck ); myRB2Lin->setEnabled( theCheck );
myRB2->setEnabled( theCheck ); myRB2Quad->setEnabled( theCheck );
myRB2BiQua->setEnabled( theCheck );
myMedNdsOnGeom->setEnabled( theCheck ); myMedNdsOnGeom->setEnabled( theCheck );
//setButtonEnabled( theCheck, QtxDialog::OK | QtxDialog::Apply ); //setButtonEnabled( theCheck, QtxDialog::OK | QtxDialog::Apply );
} }
void SMESHGUI_ConvToQuadDlg::SetEnabledRB( const int idx, const bool theCheck ) void SMESHGUI_ConvToQuadDlg::SetEnabledRB( const int idx, const bool theCheck )
{ {
if(idx) myRB2Lin ->setEnabled( idx & SMESHGUI_ConvToQuadOp::Linear );
myRB2Quad ->setEnabled( idx & SMESHGUI_ConvToQuadOp::Quadratic );
myRB2BiQua->setEnabled( idx & SMESHGUI_ConvToQuadOp::BiQuadratic );
if ( idx & SMESHGUI_ConvToQuadOp::Linear )
{ {
myRB2->setEnabled( theCheck ); myRB2Lin->setChecked( true );
myRB1->setEnabled( !theCheck ); myRB2Quad->setChecked( false );
myRB1->setChecked( true );
} }
else else
{ {
myRB1->setEnabled( theCheck ); myRB2Lin->setChecked( false );
myRB2->setEnabled( !theCheck ); myRB2Quad->setChecked( true );
myRB2->setChecked( true );
} }
myRB2BiQua->setChecked( false );
myMedNdsOnGeom->setEnabled( theCheck );
emit onClicked( myBG->checkedId() ); emit onClicked( myBG->checkedId() );
} }

6
src/SMESHGUI/SMESHGUI_ConvToQuadDlg.h
View File

@ -56,6 +56,7 @@ public:
int CurrentRB(); //returns the ID of the selected toggle button int CurrentRB(); //returns the ID of the selected toggle button
void ShowWarning(bool); void ShowWarning(bool);
bool isWarningShown(); bool isWarningShown();
bool IsBiQuadratic() const;
signals: signals:
void onClicked( int ); void onClicked( int );
@ -64,8 +65,9 @@ private:
QCheckBox* myMedNdsOnGeom; QCheckBox* myMedNdsOnGeom;
QGroupBox* myBGBox; QGroupBox* myBGBox;
QButtonGroup* myBG; QButtonGroup* myBG;
QRadioButton* myRB1; QRadioButton* myRB2Lin;
QRadioButton* myRB2; QRadioButton* myRB2Quad;
QRadioButton* myRB2BiQua;
QLabel* myWarning; QLabel* myWarning;
}; };

84
src/SMESHGUI/SMESHGUI_ConvToQuadOp.cxx
View File

@ -142,19 +142,10 @@ void SMESHGUI_ConvToQuadOp::selectionDone()
myDlg->setButtonEnabled( false, QtxDialog::OK | QtxDialog::Apply ); myDlg->setButtonEnabled( false, QtxDialog::OK | QtxDialog::Apply );
return; return;
} }
MeshType meshType = ConsistMesh( idSource ); SMESH::SMESH_Mesh_var mesh = idSource->GetMesh();
if( meshType == SMESHGUI_ConvToQuadOp::Quadratic ) bool hasGeom = mesh->HasShapeToMesh();
{ MeshDestinationType meshTgtType = DestinationMesh( idSource );
myDlg->SetEnabledRB( 0, false ); myDlg->SetEnabledRB( meshTgtType, hasGeom && ( meshTgtType & ( BiQuadratic | Quadratic )));
}
else if( meshType == SMESHGUI_ConvToQuadOp::Linear )
{
myDlg->SetEnabledRB( 1, false );
}
else
{
myDlg->SetEnabledControls( true );
}
// show warning on non-conformal result mesh // show warning on non-conformal result mesh
if ( ! idSource->_is_nil() ) if ( ! idSource->_is_nil() )
@ -166,8 +157,9 @@ void SMESHGUI_ConvToQuadOp::selectionDone()
{ {
SMESH::SMESH_Mesh_var mesh = idSource->GetMesh(); SMESH::SMESH_Mesh_var mesh = idSource->GetMesh();
idSource = SMESH::SMESH_IDSource::_narrow( mesh ); idSource = SMESH::SMESH_IDSource::_narrow( mesh );
MeshType fullMeshType = ConsistMesh( idSource ); bool isMixOrder;
toShow = ( fullMeshType != Comp ); DestinationMesh( idSource, &isMixOrder );
toShow = !isMixOrder;
} }
myDlg->ShowWarning( toShow ); myDlg->ShowWarning( toShow );
} }
@ -241,17 +233,20 @@ bool SMESHGUI_ConvToQuadOp::onApply()
SMESH::SMESH_MeshEditor_var aEditor = mesh->GetMeshEditor(); SMESH::SMESH_MeshEditor_var aEditor = mesh->GetMeshEditor();
aResult = true; aResult = true;
SMESH::SMESH_Mesh_var sourceMesh = SMESH::SObjectToInterface<SMESH::SMESH_Mesh>( pObj ); SMESH::SMESH_Mesh_var sourceMesh = SMESH::SObjectToInterface<SMESH::SMESH_Mesh>( pObj );
if( !myDlg->CurrentRB() ) if( myDlg->CurrentRB()==1 || myDlg->CurrentRB()==2)
{ {
bool force3d = true; bool force3d = true;
if( myDlg->IsEnabledCheck() ) if( myDlg->IsEnabledCheck() )
force3d = myDlg->IsMediumNdsOnGeom(); force3d = myDlg->IsMediumNdsOnGeom();
bool theToBiQuad = myDlg->IsBiQuadratic();
if ( sourceMesh->_is_nil() ) if ( sourceMesh->_is_nil() ) {
aEditor->ConvertToQuadraticObject( force3d, idSource ); if ( theToBiQuad ) aEditor->ConvertToBiQuadratic ( force3d, idSource );
else else aEditor->ConvertToQuadraticObject( force3d, idSource );
aEditor->ConvertToQuadratic( force3d ); }
else {
if ( theToBiQuad ) aEditor->ConvertToBiQuadratic( force3d, sourceMesh );
else aEditor->ConvertToQuadratic ( force3d );
}
if ( !force3d ) if ( !force3d )
{ {
SMESH::ComputeError_var error = aEditor->GetLastError(); SMESH::ComputeError_var error = aEditor->GetLastError();
@ -259,9 +254,9 @@ bool SMESHGUI_ConvToQuadOp::onApply()
{ {
if ( myBadElemsPreview ) delete myBadElemsPreview; // viewWindow may change if ( myBadElemsPreview ) delete myBadElemsPreview; // viewWindow may change
myBadElemsPreview = new SMESHGUI_MeshEditPreview( viewWindow() ); myBadElemsPreview = new SMESHGUI_MeshEditPreview( viewWindow() );
vtkFloatingPointType aPointSize = SMESH::GetFloat("SMESH:node_size",3); double aPointSize = SMESH::GetFloat("SMESH:node_size",3);
vtkFloatingPointType aLineWidth = SMESH::GetFloat("SMESH:element_width",1); double aLineWidth = SMESH::GetFloat("SMESH:element_width",1);
vtkProperty* prop = vtkProperty::New(); vtkProperty* prop = vtkProperty::New();
prop->SetLineWidth( aLineWidth * 3 ); prop->SetLineWidth( aLineWidth * 3 );
prop->SetPointSize( aPointSize * 3 ); prop->SetPointSize( aPointSize * 3 );
@ -325,12 +320,23 @@ void SMESHGUI_ConvToQuadOp::onWarningWinFinished()
//================================================================================ //================================================================================
/*! ConsistMesh /*! ConsistMesh
* Determines, what elements this mesh contains. * Determines, what elements this mesh does not contain.
*/ */
//================================================================================ //================================================================================
SMESHGUI_ConvToQuadOp::MeshType SMESHGUI_ConvToQuadOp::ConsistMesh( const SMESH::SMESH_IDSource_var& idSource) const
SMESHGUI_ConvToQuadOp::MeshDestinationType
SMESHGUI_ConvToQuadOp::DestinationMesh( const SMESH::SMESH_IDSource_var& idSource,
bool* isMixOrder) const
{ {
SMESH::long_array_var nbElemOfType = idSource->GetMeshInfo(); SMESH::long_array_var nbElemOfType = idSource->GetMeshInfo();
bool hasBiQuad = ( nbElemOfType[SMDSEntity_BiQuad_Quadrangle ] ||
nbElemOfType[SMDSEntity_TriQuad_Hexa ] );
bool hasLinStruct = ( nbElemOfType[SMDSEntity_Quadrangle ] ||
nbElemOfType[SMDSEntity_Hexa ] );
bool hasQuadStruct = ( nbElemOfType[SMDSEntity_Quad_Quadrangle ] ||
nbElemOfType[SMDSEntity_Quad_Hexa ] );
bool hasQuad = ( nbElemOfType[SMDSEntity_Quad_Edge ] || bool hasQuad = ( nbElemOfType[SMDSEntity_Quad_Edge ] ||
nbElemOfType[SMDSEntity_Quad_Triangle ] || nbElemOfType[SMDSEntity_Quad_Triangle ] ||
nbElemOfType[SMDSEntity_Quad_Quadrangle] || nbElemOfType[SMDSEntity_Quad_Quadrangle] ||
@ -347,9 +353,25 @@ SMESHGUI_ConvToQuadOp::MeshType SMESHGUI_ConvToQuadOp::ConsistMesh( const SMESH:
nbElemOfType[SMDSEntity_Pyramid ] || nbElemOfType[SMDSEntity_Pyramid ] ||
nbElemOfType[SMDSEntity_Penta ] ); nbElemOfType[SMDSEntity_Penta ] );
if ( hasQuad && hasLin ) int tgtType = 0;
return Comp; if ( hasBiQuad )
return hasQuad ? Quadratic : Linear; tgtType |= ( Quadratic | Linear );
if ( hasLinStruct )
tgtType |= ( BiQuadratic | Quadratic );
if ( hasQuadStruct )
tgtType |= ( BiQuadratic | Linear );
if ( hasQuad )
tgtType |= Linear;
if ( hasLin )
tgtType |= Quadratic;
if ( tgtType == 0 )
tgtType = Quadratic;
if ( isMixOrder )
*isMixOrder = ( hasLin && ( hasQuad || hasBiQuad ));
return MeshDestinationType( tgtType );
} }
void SMESHGUI_ConvToQuadOp::ConnectRadioButtons( int id ) void SMESHGUI_ConvToQuadOp::ConnectRadioButtons( int id )
@ -364,7 +386,7 @@ void SMESHGUI_ConvToQuadOp::ConnectRadioButtons( int id )
bool hasGeom = mesh->HasShapeToMesh(); bool hasGeom = mesh->HasShapeToMesh();
if( id || !hasGeom ) if( id==0 || !hasGeom )
myDlg->SetEnabledCheck( false ); myDlg->SetEnabledCheck( false );
else else
myDlg->SetEnabledCheck( true ); myDlg->SetEnabledCheck( true );

5
src/SMESHGUI/SMESHGUI_ConvToQuadOp.h
View File

@ -44,7 +44,7 @@ class SMESHGUI_EXPORT SMESHGUI_ConvToQuadOp : public SMESHGUI_SelectionOp
Q_OBJECT Q_OBJECT
public: public:
enum MeshType{ Comp = 0, Linear, Quadratic }; enum MeshDestinationType { Linear = 1, Quadratic = 2, BiQuadratic = 4 };
public: public:
SMESHGUI_ConvToQuadOp(); SMESHGUI_ConvToQuadOp();
@ -56,7 +56,8 @@ protected:
virtual void startOperation(); virtual void startOperation();
virtual void selectionDone(); virtual void selectionDone();
virtual SUIT_SelectionFilter* createFilter( const int ) const; virtual SUIT_SelectionFilter* createFilter( const int ) const;
MeshType ConsistMesh( const SMESH::SMESH_IDSource_var& ) const; MeshDestinationType DestinationMesh( const SMESH::SMESH_IDSource_var& ,
bool* isMixOrder = 0) const;
protected slots: protected slots:
virtual bool onApply(); virtual bool onApply();

6
src/SMESHGUI/SMESHGUI_CreatePolyhedralVolumeDlg.cxx
View File

@ -106,7 +106,7 @@ namespace SMESH
// Create and display actor // Create and display actor
myMapper = vtkDataSetMapper::New(); myMapper = vtkDataSetMapper::New();
myMapper->SetInput( myGrid ); myMapper->SetInputData( myGrid );
myPreviewActor = SALOME_Actor::New(); myPreviewActor = SALOME_Actor::New();
myPreviewActor->PickableOff(); myPreviewActor->PickableOff();
@ -114,12 +114,12 @@ namespace SMESH
myPreviewActor->SetMapper( myMapper ); myPreviewActor->SetMapper( myMapper );
myPreviewActor->SetRepresentation( 3 ); myPreviewActor->SetRepresentation( 3 );
vtkFloatingPointType anRGB[3]; double anRGB[3];
vtkProperty* aProp = vtkProperty::New(); vtkProperty* aProp = vtkProperty::New();
GetColor( "SMESH", "selection_element_color", anRGB[0], anRGB[1], anRGB[2], QColor( 0, 170, 255 ) ); GetColor( "SMESH", "selection_element_color", anRGB[0], anRGB[1], anRGB[2], QColor( 0, 170, 255 ) );
aProp->SetColor(anRGB[0],anRGB[1],anRGB[2]); aProp->SetColor(anRGB[0],anRGB[1],anRGB[2]);
myPreviewActor->SetProperty( aProp ); myPreviewActor->SetProperty( aProp );
vtkFloatingPointType aFactor,aUnits; double aFactor,aUnits;
myPreviewActor->SetResolveCoincidentTopology(true); myPreviewActor->SetResolveCoincidentTopology(true);
myPreviewActor->GetPolygonOffsetParameters(aFactor,aUnits); myPreviewActor->GetPolygonOffsetParameters(aFactor,aUnits);
myPreviewActor->SetPolygonOffsetParameters(aFactor,0.2*aUnits); myPreviewActor->SetPolygonOffsetParameters(aFactor,0.2*aUnits);

66
src/SMESHGUI/SMESHGUI_FilterDlg.cxx
View File

@ -1137,6 +1137,7 @@ bool SMESHGUI_FilterTable::IsValid (const bool theMess, const int theEntityType)
aCriterion == SMESH::FT_BelongToCylinder || aCriterion == SMESH::FT_BelongToCylinder ||
aCriterion == SMESH::FT_BelongToGenSurface || aCriterion == SMESH::FT_BelongToGenSurface ||
aCriterion == SMESH::FT_ElemGeomType || aCriterion == SMESH::FT_ElemGeomType ||
aCriterion == SMESH::FT_EntityType ||
aCriterion == SMESH::FT_CoplanarFaces || aCriterion == SMESH::FT_CoplanarFaces ||
aCriterion == SMESH::FT_LyingOnGeom) aCriterion == SMESH::FT_LyingOnGeom)
{ {
@ -1253,6 +1254,8 @@ void SMESHGUI_FilterTable::GetCriterion (const int theRow,
} }
else if ( aCriterionType == SMESH::FT_ElemGeomType ) else if ( aCriterionType == SMESH::FT_ElemGeomType )
theCriterion.Threshold = (double)((ComboItem*)aTable->item(theRow, 2))->value(); theCriterion.Threshold = (double)((ComboItem*)aTable->item(theRow, 2))->value();
else if ( aCriterionType == SMESH::FT_EntityType )
theCriterion.Threshold = (double)((ComboItem*)aTable->item(theRow, 2))->value();
else if ( aCriterionType == SMESH::FT_CoplanarFaces ) else if ( aCriterionType == SMESH::FT_CoplanarFaces )
theCriterion.ThresholdID = aTable->text(theRow, 2).toLatin1().constData(); theCriterion.ThresholdID = aTable->text(theRow, 2).toLatin1().constData();
else if ( aCriterionType != SMESH::FT_RangeOfIds && else if ( aCriterionType != SMESH::FT_RangeOfIds &&
@ -1329,6 +1332,11 @@ void SMESHGUI_FilterTable::SetCriterion (const int theRow,
ComboItem* typeBox = (ComboItem*)aTable->item(theRow, 2); ComboItem* typeBox = (ComboItem*)aTable->item(theRow, 2);
typeBox->setValue( (int)(theCriterion.Threshold + 0.5) ); typeBox->setValue( (int)(theCriterion.Threshold + 0.5) );
} }
else if (theCriterion.Type == SMESH::FT_EntityType )
{
ComboItem* typeBox = (ComboItem*)aTable->item(theRow, 2);
typeBox->setValue( (int)(theCriterion.Threshold + 0.5) );
}
else if (theCriterion.Type == SMESH::FT_CoplanarFaces ) else if (theCriterion.Type == SMESH::FT_CoplanarFaces )
{ {
aTable->item( theRow, 2 )->setText( QString( theCriterion.ThresholdID ) ); aTable->item( theRow, 2 )->setText( QString( theCriterion.ThresholdID ) );
@ -1651,10 +1659,40 @@ static QList<int> geomTypes( const int theType )
return typeIds; return typeIds;
} }
//=======================================================================
// name : entityTypes
// Purpose : returns available entity types of elements
//=======================================================================
static QList<int> entityTypes( const int theType )
{
QList<int> typeIds;
if ( theType == SMESH::EDGE )
{
typeIds.append( SMDSEntity_Edge );
typeIds.append( SMDSEntity_Quad_Edge );
}
if ( theType == SMESH::FACE )
{
typeIds.append( SMDSEntity_Quadrangle );
typeIds.append( SMDSEntity_Quad_Quadrangle );
typeIds.append( SMDSEntity_BiQuad_Quadrangle );
}
if ( theType == SMESH::VOLUME )
{
typeIds.append( SMDSEntity_Hexa );
typeIds.append( SMDSEntity_Quad_Hexa );
typeIds.append( SMDSEntity_TriQuad_Hexa );
}
return typeIds;
}
//======================================================================= //=======================================================================
// name : SMESHGUI_FilterTable::onCriterionChanged() // name : SMESHGUI_FilterTable::onCriterionChanged()
// Purpose : Provides reaction on change of criterion // Purpose : Provides reaction on change of criterion
//======================================================================= //=======================================================================
void SMESHGUI_FilterTable::onCriterionChanged (const int row, const int col, const int entityType) void SMESHGUI_FilterTable::onCriterionChanged (const int row, const int col, const int entityType)
{ {
int aType = entityType == -1 ? GetType() : entityType; int aType = entityType == -1 ? GetType() : entityType;
@ -1689,8 +1727,8 @@ void SMESHGUI_FilterTable::onCriterionChanged (const int row, const int col, con
aCriterionType == SMESH::FT_Length2D || aCriterionType == SMESH::FT_Length2D ||
aCriterionType == SMESH::FT_MaxElementLength2D || aCriterionType == SMESH::FT_MaxElementLength2D ||
aCriterionType == SMESH::FT_MaxElementLength3D || aCriterionType == SMESH::FT_MaxElementLength3D ||
aCriterionType == SMESH::FT_Volume3D; aCriterionType == SMESH::FT_Volume3D ||
aCriterionType == SMESH::FT_EntityType;
int aPrecision = 0; int aPrecision = 0;
if ( anIsDoubleCriterion ) { if ( anIsDoubleCriterion ) {
const char* aPrecisionType = getPrecision( aCriterionType ); const char* aPrecisionType = getPrecision( aCriterionType );
@ -1710,6 +1748,7 @@ void SMESHGUI_FilterTable::onCriterionChanged (const int row, const int col, con
if ( (aCriterionType != SMESH::FT_GroupColor && clrBtn) || if ( (aCriterionType != SMESH::FT_GroupColor && clrBtn) ||
(aCriterionType != SMESH::FT_ElemGeomType && isComboItem) || (aCriterionType != SMESH::FT_ElemGeomType && isComboItem) ||
(aCriterionType != SMESH::FT_EntityType && isComboItem) ||
(aCriterionType != SMESH::FT_MultiConnection && isIntSpinItem) || (aCriterionType != SMESH::FT_MultiConnection && isIntSpinItem) ||
(!anIsDoubleCriterion && isDoubleSpinItem) || (!anIsDoubleCriterion && isDoubleSpinItem) ||
anIsPrecisionChanged ) anIsPrecisionChanged )
@ -1722,6 +1761,7 @@ void SMESHGUI_FilterTable::onCriterionChanged (const int row, const int col, con
} }
if ( (aCriterionType == SMESH::FT_GroupColor && !clrBtn) || if ( (aCriterionType == SMESH::FT_GroupColor && !clrBtn) ||
(aCriterionType == SMESH::FT_ElemGeomType && !isComboItem) || (aCriterionType == SMESH::FT_ElemGeomType && !isComboItem) ||
(aCriterionType == SMESH::FT_EntityType && !isComboItem) ||
(aCriterionType == SMESH::FT_MultiConnection && !isIntSpinItem) || (aCriterionType == SMESH::FT_MultiConnection && !isIntSpinItem) ||
(anIsDoubleCriterion && !isDoubleSpinItem) || (anIsDoubleCriterion && !isDoubleSpinItem) ||
anIsPrecisionChanged ) anIsPrecisionChanged )
@ -1742,6 +1782,18 @@ void SMESHGUI_FilterTable::onCriterionChanged (const int row, const int col, con
ComboItem* typeBox = new ComboItem( typeNames ); ComboItem* typeBox = new ComboItem( typeNames );
aTable->setItem( row, 2, typeBox ); aTable->setItem( row, 2, typeBox );
} }
else if ( aCriterionType == SMESH::FT_EntityType ) {
QList<int> typeIds = entityTypes( aType );
QMap<int, QString> typeNames;
QList<int>::const_iterator anIter = typeIds.begin();
for ( int i = 0; anIter != typeIds.end(); ++anIter, ++i)
{
QString typeKey = QString( "ENTITY_TYPE_%1" ).arg( *anIter );
typeNames[ *anIter ] = tr( typeKey.toLatin1().data() );
}
ComboItem* typeBox = new ComboItem( typeNames );
aTable->setItem( row, 2, typeBox );
}
else if ( aCriterionType == SMESH::FT_MultiConnection ) { else if ( aCriterionType == SMESH::FT_MultiConnection ) {
IntSpinItem* intSpin = new IntSpinItem( 0 ); IntSpinItem* intSpin = new IntSpinItem( 0 );
aTable->setItem( row, 2, intSpin ); aTable->setItem( row, 2, intSpin );
@ -1771,7 +1823,8 @@ void SMESHGUI_FilterTable::onCriterionChanged (const int row, const int col, con
aCriterionType == SMESH::FT_LinearOrQuadratic || aCriterionType == SMESH::FT_LinearOrQuadratic ||
aCriterionType == SMESH::FT_GroupColor || aCriterionType == SMESH::FT_GroupColor ||
aCriterionType == SMESH::FT_ElemGeomType || aCriterionType == SMESH::FT_ElemGeomType ||
aCriterionType == SMESH::FT_CoplanarFaces aCriterionType == SMESH::FT_CoplanarFaces ||
aCriterionType == SMESH::FT_EntityType
) )
{ {
bool isSignalsBlocked = aTable->signalsBlocked(); bool isSignalsBlocked = aTable->signalsBlocked();
@ -1783,6 +1836,7 @@ void SMESHGUI_FilterTable::onCriterionChanged (const int row, const int col, con
aTable->item(row, 2)->setText( QString("") ); aTable->item(row, 2)->setText( QString("") );
aTable->setEditable(aCriterionType == SMESH::FT_GroupColor || aTable->setEditable(aCriterionType == SMESH::FT_GroupColor ||
aCriterionType == SMESH::FT_ElemGeomType || aCriterionType == SMESH::FT_ElemGeomType ||
aCriterionType == SMESH::FT_EntityType ||
aCriterionType == SMESH::FT_CoplanarFaces, row, 2); aCriterionType == SMESH::FT_CoplanarFaces, row, 2);
aTable->blockSignals( isSignalsBlocked ); aTable->blockSignals( isSignalsBlocked );
} }
@ -1802,7 +1856,8 @@ void SMESHGUI_FilterTable::onCriterionChanged (const int row, const int col, con
aTable->setEditable(true, row, 2); aTable->setEditable(true, row, 2);
} }
else if (aCriterionType == SMESH::FT_GroupColor || else if (aCriterionType == SMESH::FT_GroupColor ||
aCriterionType == SMESH::FT_ElemGeomType) aCriterionType == SMESH::FT_ElemGeomType ||
aCriterionType == SMESH::FT_EntityType)
{ {
if (!aTable->isEditable(row, 2)) if (!aTable->isEditable(row, 2))
aTable->setEditable(true, row, 2); aTable->setEditable(true, row, 2);
@ -2034,6 +2089,7 @@ const QMap<int, QString>& SMESHGUI_FilterTable::getCriteria (const int theType)
aCriteria[ SMESH::FT_GroupColor ] = tr("GROUP_COLOR"); aCriteria[ SMESH::FT_GroupColor ] = tr("GROUP_COLOR");
aCriteria[ SMESH::FT_ElemGeomType ] = tr("GEOM_TYPE"); aCriteria[ SMESH::FT_ElemGeomType ] = tr("GEOM_TYPE");
aCriteria[ SMESH::FT_EqualEdges ] = tr("EQUAL_EDGE"); aCriteria[ SMESH::FT_EqualEdges ] = tr("EQUAL_EDGE");
aCriteria[ SMESH::FT_EntityType ] = tr("ENTITY_TYPE");
} }
return aCriteria; return aCriteria;
} }
@ -2066,6 +2122,7 @@ const QMap<int, QString>& SMESHGUI_FilterTable::getCriteria (const int theType)
aCriteria[ SMESH::FT_ElemGeomType ] = tr("GEOM_TYPE"); aCriteria[ SMESH::FT_ElemGeomType ] = tr("GEOM_TYPE");
aCriteria[ SMESH::FT_CoplanarFaces ] = tr("COPLANAR_FACES"); aCriteria[ SMESH::FT_CoplanarFaces ] = tr("COPLANAR_FACES");
aCriteria[ SMESH::FT_EqualFaces ] = tr("EQUAL_FACE"); aCriteria[ SMESH::FT_EqualFaces ] = tr("EQUAL_FACE");
aCriteria[ SMESH::FT_EntityType ] = tr("ENTITY_TYPE");
} }
return aCriteria; return aCriteria;
} }
@ -2087,6 +2144,7 @@ const QMap<int, QString>& SMESHGUI_FilterTable::getCriteria (const int theType)
aCriteria[ SMESH::FT_GroupColor ] = tr("GROUP_COLOR"); aCriteria[ SMESH::FT_GroupColor ] = tr("GROUP_COLOR");
aCriteria[ SMESH::FT_ElemGeomType ] = tr("GEOM_TYPE"); aCriteria[ SMESH::FT_ElemGeomType ] = tr("GEOM_TYPE");
aCriteria[ SMESH::FT_EqualVolumes ] = tr("EQUAL_VOLUME"); aCriteria[ SMESH::FT_EqualVolumes ] = tr("EQUAL_VOLUME");
aCriteria[ SMESH::FT_EntityType ] = tr("ENTITY_TYPE");
} }
return aCriteria; return aCriteria;
} }

4
src/SMESHGUI/SMESHGUI_Measurements.cxx
View File

@ -362,7 +362,7 @@ void SMESHGUI_MinDistance::createPreview( double x1, double y1, double z1, doubl
aCells->Delete(); aCells->Delete();
// create actor // create actor
vtkDataSetMapper* aMapper = vtkDataSetMapper::New(); vtkDataSetMapper* aMapper = vtkDataSetMapper::New();
aMapper->SetInput( aGrid ); aMapper->SetInputData( aGrid );
aGrid->Delete(); aGrid->Delete();
myPreview = SALOME_Actor::New(); myPreview = SALOME_Actor::New();
myPreview->PickableOff(); myPreview->PickableOff();
@ -879,7 +879,7 @@ void SMESHGUI_BoundingBox::createPreview( double minX, double maxX, double minY,
aCells->Delete(); aCells->Delete();
// create actor // create actor
vtkDataSetMapper* aMapper = vtkDataSetMapper::New(); vtkDataSetMapper* aMapper = vtkDataSetMapper::New();
aMapper->SetInput( aGrid ); aMapper->SetInputData( aGrid );
aGrid->Delete(); aGrid->Delete();
myPreview = SALOME_Actor::New(); myPreview = SALOME_Actor::New();
myPreview->PickableOff(); myPreview->PickableOff();

10
src/SMESHGUI/SMESHGUI_MergeDlg.cxx
View File

@ -124,7 +124,7 @@ namespace SMESH
// Create and display actor // Create and display actor
vtkDataSetMapper* aMapper = vtkDataSetMapper::New(); vtkDataSetMapper* aMapper = vtkDataSetMapper::New();
aMapper->SetInput( myIdGrid ); aMapper->SetInputData( myIdGrid );
myIdActor = SALOME_Actor::New(); myIdActor = SALOME_Actor::New();
myIdActor->SetInfinitive(true); myIdActor->SetInfinitive(true);
@ -140,16 +140,16 @@ namespace SMESH
myPointsNumDataSet = vtkUnstructuredGrid::New(); myPointsNumDataSet = vtkUnstructuredGrid::New();
myPtsMaskPoints = vtkMaskPoints::New(); myPtsMaskPoints = vtkMaskPoints::New();
myPtsMaskPoints->SetInput(myPointsNumDataSet); myPtsMaskPoints->SetInputData(myPointsNumDataSet);
myPtsMaskPoints->SetOnRatio(1); myPtsMaskPoints->SetOnRatio(1);
myPtsSelectVisiblePoints = vtkSelectVisiblePoints::New(); myPtsSelectVisiblePoints = vtkSelectVisiblePoints::New();
myPtsSelectVisiblePoints->SetInput(myPtsMaskPoints->GetOutput()); myPtsSelectVisiblePoints->SetInputConnection(myPtsMaskPoints->GetOutputPort());
myPtsSelectVisiblePoints->SelectInvisibleOff(); myPtsSelectVisiblePoints->SelectInvisibleOff();
myPtsSelectVisiblePoints->SetTolerance(0.1); myPtsSelectVisiblePoints->SetTolerance(0.1);
myPtsLabeledDataMapper = vtkLabeledDataMapper::New(); myPtsLabeledDataMapper = vtkLabeledDataMapper::New();
myPtsLabeledDataMapper->SetInput(myPtsSelectVisiblePoints->GetOutput()); myPtsLabeledDataMapper->SetInputConnection(myPtsSelectVisiblePoints->GetOutputPort());
#if (VTK_XVERSION < 0x050200) #if (VTK_XVERSION < 0x050200)
myPtsLabeledDataMapper->SetLabelFormat("%g"); myPtsLabeledDataMapper->SetLabelFormat("%g");
#endif #endif
@ -250,7 +250,7 @@ namespace SMESH
anArray->SetValue( i, myIDs[i] ); anArray->SetValue( i, myIDs[i] );
aDataSet->GetPointData()->SetScalars( anArray ); aDataSet->GetPointData()->SetScalars( anArray );
anArray->Delete(); anArray->Delete();
myPtsMaskPoints->SetInput( aDataSet ); myPtsMaskPoints->SetInputData( aDataSet );
myPointLabels->SetVisibility( theIsActorVisible ); myPointLabels->SetVisibility( theIsActorVisible );
} }
else { else {

6
src/SMESHGUI/SMESHGUI_MeshEditPreview.cxx
View File

@ -66,19 +66,19 @@ SMESHGUI_MeshEditPreview::SMESHGUI_MeshEditPreview(SVTK_ViewWindow* theViewWindo
// Create and display actor // Create and display actor
vtkDataSetMapper* aMapper = vtkDataSetMapper::New(); vtkDataSetMapper* aMapper = vtkDataSetMapper::New();
aMapper->SetInput( myGrid ); aMapper->SetInputData( myGrid );
myPreviewActor = SALOME_Actor::New(); myPreviewActor = SALOME_Actor::New();
myPreviewActor->SetInfinitive(true); myPreviewActor->SetInfinitive(true);
myPreviewActor->VisibilityOn(); myPreviewActor->VisibilityOn();
myPreviewActor->PickableOff(); myPreviewActor->PickableOff();
vtkFloatingPointType aFactor,aUnits; double aFactor,aUnits;
myPreviewActor->SetResolveCoincidentTopology(true); myPreviewActor->SetResolveCoincidentTopology(true);
myPreviewActor->GetPolygonOffsetParameters(aFactor,aUnits); myPreviewActor->GetPolygonOffsetParameters(aFactor,aUnits);
myPreviewActor->SetPolygonOffsetParameters(aFactor,0.2*aUnits); myPreviewActor->SetPolygonOffsetParameters(aFactor,0.2*aUnits);
vtkFloatingPointType anRGB[3]; double anRGB[3];
SMESH::GetColor( "SMESH", "selection_element_color", anRGB[0], anRGB[1], anRGB[2], QColor( 0, 170, 255 ) ); SMESH::GetColor( "SMESH", "selection_element_color", anRGB[0], anRGB[1], anRGB[2], QColor( 0, 170, 255 ) );
SetColor( anRGB[0], anRGB[1], anRGB[2] ); SetColor( anRGB[0], anRGB[1], anRGB[2] );

2
src/SMESHGUI/SMESHGUI_MeshPatternDlg.cxx
View File

@ -948,7 +948,7 @@ void SMESHGUI_MeshPatternDlg::displayPreview()
// Create and display actor // Create and display actor
vtkDataSetMapper* aMapper = vtkDataSetMapper::New(); vtkDataSetMapper* aMapper = vtkDataSetMapper::New();
aMapper->SetInput(aGrid); aMapper->SetInputData(aGrid);
myPreviewActor = SALOME_Actor::New(); myPreviewActor = SALOME_Actor::New();
myPreviewActor->PickableOff(); myPreviewActor->PickableOff();

2
src/SMESHGUI/SMESHGUI_MultiEditDlg.cxx
View File

@ -1433,7 +1433,7 @@ void SMESHGUI_CuttingOfQuadsDlg::displayPreview()
// Create and display actor // Create and display actor
vtkDataSetMapper* aMapper = vtkDataSetMapper::New(); vtkDataSetMapper* aMapper = vtkDataSetMapper::New();
aMapper->SetInput(aGrid); aMapper->SetInputData(aGrid);
myPreviewActor = SALOME_Actor::New(); myPreviewActor = SALOME_Actor::New();
myPreviewActor->PickableOff(); myPreviewActor->PickableOff();

6
src/SMESHGUI/SMESHGUI_NodesDlg.cxx
View File

@ -173,7 +173,7 @@ namespace SMESH
// Create and display actor // Create and display actor
myMapper = vtkDataSetMapper::New(); myMapper = vtkDataSetMapper::New();
myMapper->SetInput( aGrid ); myMapper->SetInputData( aGrid );
aGrid->Delete(); aGrid->Delete();
myPreviewActor = SALOME_Actor::New(); myPreviewActor = SALOME_Actor::New();
@ -185,11 +185,11 @@ namespace SMESH
vtkProperty* aProp = vtkProperty::New(); vtkProperty* aProp = vtkProperty::New();
aProp->SetRepresentationToPoints(); aProp->SetRepresentationToPoints();
vtkFloatingPointType anRGB[3]; double anRGB[3];
GetColor( "SMESH", "node_color", anRGB[0], anRGB[1], anRGB[2], QColor( 0, 255, 0 ) ); GetColor( "SMESH", "node_color", anRGB[0], anRGB[1], anRGB[2], QColor( 0, 255, 0 ) );
aProp->SetColor( anRGB[0], anRGB[1], anRGB[2] ); aProp->SetColor( anRGB[0], anRGB[1], anRGB[2] );
vtkFloatingPointType aPointSize = GetFloat( "SMESH:node_size", 3 ); double aPointSize = GetFloat( "SMESH:node_size", 3 );
aProp->SetPointSize( aPointSize ); aProp->SetPointSize( aPointSize );
myPreviewActor->SetProperty( aProp ); myPreviewActor->SetProperty( aProp );

6
src/SMESHGUI/SMESHGUI_Preferences_ScalarBarDlg.cxx
View File

@ -649,7 +649,7 @@ void SMESHGUI_Preferences_ScalarBarDlg::onSelectionChanged()
if ( myScalarBarActor->GetLookupTable() ) { if ( myScalarBarActor->GetLookupTable() ) {
vtkLookupTable* aLookupTable = static_cast<vtkLookupTable*>(myScalarBarActor->GetLookupTable()); vtkLookupTable* aLookupTable = static_cast<vtkLookupTable*>(myScalarBarActor->GetLookupTable());
vtkFloatingPointType *range = aLookupTable->GetRange(); double *range = aLookupTable->GetRange();
myMinEdit->setText( QString::number( range[0],'g',12 ) ); myMinEdit->setText( QString::number( range[0],'g',12 ) );
myMaxEdit->setText( QString::number( range[1],'g',12 ) ); myMaxEdit->setText( QString::number( range[1],'g',12 ) );
myLogarithmicCheck->setChecked(aLookupTable->GetScale() == VTK_SCALE_LOG10); myLogarithmicCheck->setChecked(aLookupTable->GetScale() == VTK_SCALE_LOG10);
@ -657,7 +657,7 @@ void SMESHGUI_Preferences_ScalarBarDlg::onSelectionChanged()
} }
vtkTextProperty* aTitleTextPrp = myScalarBarActor->GetTitleTextProperty(); vtkTextProperty* aTitleTextPrp = myScalarBarActor->GetTitleTextProperty();
vtkFloatingPointType aTColor[3]; double aTColor[3];
aTitleTextPrp->GetColor( aTColor ); aTitleTextPrp->GetColor( aTColor );
myTitleColorBtn->setColor( QColor( (int)( aTColor[0]*255 ), (int)( aTColor[1]*255 ), (int)( aTColor[2]*255 ) ) ); myTitleColorBtn->setColor( QColor( (int)( aTColor[0]*255 ), (int)( aTColor[1]*255 ), (int)( aTColor[2]*255 ) ) );
myTitleFontCombo->setCurrentIndex( aTitleTextPrp->GetFontFamily() ); myTitleFontCombo->setCurrentIndex( aTitleTextPrp->GetFontFamily() );
@ -666,7 +666,7 @@ void SMESHGUI_Preferences_ScalarBarDlg::onSelectionChanged()
myTitleShadowCheck->setChecked( aTitleTextPrp->GetShadow() ); myTitleShadowCheck->setChecked( aTitleTextPrp->GetShadow() );
vtkTextProperty* aLabelsTextPrp = myScalarBarActor->GetLabelTextProperty(); vtkTextProperty* aLabelsTextPrp = myScalarBarActor->GetLabelTextProperty();
vtkFloatingPointType aLColor[3]; double aLColor[3];
aLabelsTextPrp->GetColor( aLColor ); aLabelsTextPrp->GetColor( aLColor );
myLabelsColorBtn->setColor( QColor( (int)( aLColor[0]*255 ), (int)( aLColor[1]*255 ), (int)( aLColor[2]*255 ) ) ); myLabelsColorBtn->setColor( QColor( (int)( aLColor[0]*255 ), (int)( aLColor[1]*255 ), (int)( aLColor[2]*255 ) ) );
myLabelsFontCombo->setCurrentIndex( aLabelsTextPrp->GetFontFamily() ); myLabelsFontCombo->setCurrentIndex( aLabelsTextPrp->GetFontFamily() );

56
src/SMESHGUI/SMESHGUI_VTKUtils.cxx
View File

@ -961,7 +961,7 @@ namespace SMESH
SUIT_ResourceMgr* mgr = SMESH::GetResourceMgr( theModule ); SUIT_ResourceMgr* mgr = SMESH::GetResourceMgr( theModule );
if ( !mgr ) return; if ( !mgr ) return;
// //
vtkFloatingPointType anRGBNd[3] = {1,1,1}; double anRGBNd[3] = {1,1,1};
SMESH::GetColor( "SMESH", "numbering_node_color", anRGBNd[0], anRGBNd[1], anRGBNd[2], QColor( 255, 255, 255 ) ); SMESH::GetColor( "SMESH", "numbering_node_color", anRGBNd[0], anRGBNd[1], anRGBNd[2], QColor( 255, 255, 255 ) );
int aSizeNd = 10; int aSizeNd = 10;
SMESH::LabelFont aFamilyNd = SMESH::FntTimes; SMESH::LabelFont aFamilyNd = SMESH::FntTimes;
@ -980,7 +980,7 @@ namespace SMESH
aSizeNd = f.pointSize(); aSizeNd = f.pointSize();
} }
// //
vtkFloatingPointType anRGBEl[3] = {0,1,0}; double anRGBEl[3] = {0,1,0};
SMESH::GetColor( "SMESH", "numbering_elem_color", anRGBEl[0], anRGBEl[1], anRGBEl[2], QColor( 0, 255, 0 ) ); SMESH::GetColor( "SMESH", "numbering_elem_color", anRGBEl[0], anRGBEl[1], anRGBEl[2], QColor( 0, 255, 0 ) );
int aSizeEl = 12; int aSizeEl = 12;
SMESH::LabelFont aFamilyEl = SMESH::FntTimes; SMESH::LabelFont aFamilyEl = SMESH::FntTimes;
@ -1323,21 +1323,21 @@ namespace SMESH
//---------------------------------------------------------------------------- //----------------------------------------------------------------------------
// internal function // internal function
void ComputeBoundsParam( vtkFloatingPointType theBounds[6], void ComputeBoundsParam( double theBounds[6],
vtkFloatingPointType theDirection[3], double theDirection[3],
vtkFloatingPointType theMinPnt[3], double theMinPnt[3],
vtkFloatingPointType& theMaxBoundPrj, double& theMaxBoundPrj,
vtkFloatingPointType& theMinBoundPrj ) double& theMinBoundPrj )
{ {
//Enlarge bounds in order to avoid conflicts of precision //Enlarge bounds in order to avoid conflicts of precision
for(int i = 0; i < 6; i += 2){ for(int i = 0; i < 6; i += 2){
static double EPS = 1.0E-3; static double EPS = 1.0E-3;
vtkFloatingPointType aDelta = (theBounds[i+1] - theBounds[i])*EPS; double aDelta = (theBounds[i+1] - theBounds[i])*EPS;
theBounds[i] -= aDelta; theBounds[i] -= aDelta;
theBounds[i+1] += aDelta; theBounds[i+1] += aDelta;
} }
vtkFloatingPointType aBoundPoints[8][3] = { {theBounds[0],theBounds[2],theBounds[4]}, double aBoundPoints[8][3] = { {theBounds[0],theBounds[2],theBounds[4]},
{theBounds[1],theBounds[2],theBounds[4]}, {theBounds[1],theBounds[2],theBounds[4]},
{theBounds[0],theBounds[3],theBounds[4]}, {theBounds[0],theBounds[3],theBounds[4]},
{theBounds[1],theBounds[3],theBounds[4]}, {theBounds[1],theBounds[3],theBounds[4]},
@ -1350,7 +1350,7 @@ namespace SMESH
theMaxBoundPrj = vtkMath::Dot(theDirection,aBoundPoints[aMaxId]); theMaxBoundPrj = vtkMath::Dot(theDirection,aBoundPoints[aMaxId]);
theMinBoundPrj = theMaxBoundPrj; theMinBoundPrj = theMaxBoundPrj;
for(int i = 1; i < 8; i++){ for(int i = 1; i < 8; i++){
vtkFloatingPointType aTmp = vtkMath::Dot(theDirection,aBoundPoints[i]); double aTmp = vtkMath::Dot(theDirection,aBoundPoints[i]);
if(theMaxBoundPrj < aTmp){ if(theMaxBoundPrj < aTmp){
theMaxBoundPrj = aTmp; theMaxBoundPrj = aTmp;
aMaxId = i; aMaxId = i;
@ -1359,43 +1359,43 @@ namespace SMESH
theMinBoundPrj = aTmp; theMinBoundPrj = aTmp;
} }
} }
vtkFloatingPointType *aMinPnt = aBoundPoints[aMaxId]; double *aMinPnt = aBoundPoints[aMaxId];
theMinPnt[0] = aMinPnt[0]; theMinPnt[0] = aMinPnt[0];
theMinPnt[1] = aMinPnt[1]; theMinPnt[1] = aMinPnt[1];
theMinPnt[2] = aMinPnt[2]; theMinPnt[2] = aMinPnt[2];
} }
// internal function // internal function
void DistanceToPosition( vtkFloatingPointType theBounds[6], void DistanceToPosition( double theBounds[6],
vtkFloatingPointType theDirection[3], double theDirection[3],
vtkFloatingPointType theDist, double theDist,
vtkFloatingPointType thePos[3] ) double thePos[3] )
{ {
vtkFloatingPointType aMaxBoundPrj, aMinBoundPrj, aMinPnt[3]; double aMaxBoundPrj, aMinBoundPrj, aMinPnt[3];
ComputeBoundsParam(theBounds,theDirection,aMinPnt,aMaxBoundPrj,aMinBoundPrj); ComputeBoundsParam(theBounds,theDirection,aMinPnt,aMaxBoundPrj,aMinBoundPrj);
vtkFloatingPointType aLength = (aMaxBoundPrj-aMinBoundPrj)*theDist; double aLength = (aMaxBoundPrj-aMinBoundPrj)*theDist;
thePos[0] = aMinPnt[0]-theDirection[0]*aLength; thePos[0] = aMinPnt[0]-theDirection[0]*aLength;
thePos[1] = aMinPnt[1]-theDirection[1]*aLength; thePos[1] = aMinPnt[1]-theDirection[1]*aLength;
thePos[2] = aMinPnt[2]-theDirection[2]*aLength; thePos[2] = aMinPnt[2]-theDirection[2]*aLength;
} }
// internal function (currently unused, left just in case) // internal function (currently unused, left just in case)
void PositionToDistance( vtkFloatingPointType theBounds[6], void PositionToDistance( double theBounds[6],
vtkFloatingPointType theDirection[3], double theDirection[3],
vtkFloatingPointType thePos[3], double thePos[3],
vtkFloatingPointType& theDist ) double& theDist )
{ {
vtkFloatingPointType aMaxBoundPrj, aMinBoundPrj, aMinPnt[3]; double aMaxBoundPrj, aMinBoundPrj, aMinPnt[3];
ComputeBoundsParam(theBounds,theDirection,aMinPnt,aMaxBoundPrj,aMinBoundPrj); ComputeBoundsParam(theBounds,theDirection,aMinPnt,aMaxBoundPrj,aMinBoundPrj);
vtkFloatingPointType aPrj = vtkMath::Dot(theDirection,thePos); double aPrj = vtkMath::Dot(theDirection,thePos);
theDist = (aPrj-aMinBoundPrj)/(aMaxBoundPrj-aMinBoundPrj); theDist = (aPrj-aMinBoundPrj)/(aMaxBoundPrj-aMinBoundPrj);
} }
bool ComputeClippingPlaneParameters( std::list<vtkActor*> theActorList, bool ComputeClippingPlaneParameters( std::list<vtkActor*> theActorList,
vtkFloatingPointType theNormal[3], double theNormal[3],
vtkFloatingPointType theDist, double theDist,
vtkFloatingPointType theBounds[6], double theBounds[6],
vtkFloatingPointType theOrigin[3] ) double theOrigin[3] )
{ {
bool anIsOk = false; bool anIsOk = false;
theBounds[0] = theBounds[2] = theBounds[4] = VTK_DOUBLE_MAX; theBounds[0] = theBounds[2] = theBounds[4] = VTK_DOUBLE_MAX;
@ -1404,7 +1404,7 @@ namespace SMESH
for( ; anIter != theActorList.end(); anIter++ ) { for( ; anIter != theActorList.end(); anIter++ ) {
if( vtkActor* aVTKActor = *anIter ) { if( vtkActor* aVTKActor = *anIter ) {
if( SMESH_Actor* anActor = SMESH_Actor::SafeDownCast( aVTKActor ) ) { if( SMESH_Actor* anActor = SMESH_Actor::SafeDownCast( aVTKActor ) ) {
vtkFloatingPointType aBounds[6]; double aBounds[6];
anActor->GetUnstructuredGrid()->GetBounds( aBounds ); anActor->GetUnstructuredGrid()->GetBounds( aBounds );
theBounds[0] = std::min( theBounds[0], aBounds[0] ); theBounds[0] = std::min( theBounds[0], aBounds[0] );
theBounds[1] = std::max( theBounds[1], aBounds[1] ); theBounds[1] = std::max( theBounds[1], aBounds[1] );

8
src/SMESHGUI/SMESHGUI_VTKUtils.h
View File

@ -202,10 +202,10 @@ SMESHGUI_EXPORT
//---------------------------------------------------------------------------- //----------------------------------------------------------------------------
SMESHGUI_EXPORT SMESHGUI_EXPORT
bool ComputeClippingPlaneParameters( std::list<vtkActor*> theActorList, bool ComputeClippingPlaneParameters( std::list<vtkActor*> theActorList,
vtkFloatingPointType theNormal[3], double theNormal[3],
vtkFloatingPointType theDist, double theDist,
vtkFloatingPointType theBounds[6], double theBounds[6],
vtkFloatingPointType theOrigin[3] ); double theOrigin[3] );
SMESHGUI_EXPORT SMESHGUI_EXPORT
void RemoveVisualObjectWithActors( const char* theEntry, bool fromAllViews = false ); void RemoveVisualObjectWithActors( const char* theEntry, bool fromAllViews = false );
}; };

110
src/SMESHGUI/SMESH_msg_en.ts
View File

@ -4634,13 +4634,17 @@ Do you want to restore original submesh priority?</translation>
</message> </message>
<message> <message>
<source>RADIOBTN_1</source> <source>RADIOBTN_1</source>
<translation>Convert to quadratic</translation> <translation>Convert to linear</translation>
</message> </message>
<message> <message>
<source>RADIOBTN_2</source> <source>RADIOBTN_2</source>
<translation>Convert from quadratic</translation> <translation>Convert to quadratic</translation>
</message> </message>
<message> <message>
<source>RADIOBTN_3</source>
<translation>Convert to bi-quadratic</translation>
</message>
<message>
<source>NON_CONFORM_WARNING</source> <source>NON_CONFORM_WARNING</source>
<translation>Warning: mesh can become non-conformal</translation> <translation>Warning: mesh can become non-conformal</translation>
</message> </message>
@ -5196,6 +5200,10 @@ Please check input data and try again</translation>
<source>COPLANAR_FACES</source> <source>COPLANAR_FACES</source>
<translation>Coplanar faces</translation> <translation>Coplanar faces</translation>
</message> </message>
<message>
<source>NUMBEROFNODESINELEMENT</source>
<translation>Number Of Nodes In Element</translation>
</message>
<message> <message>
<source>COPY_FROM</source> <source>COPY_FROM</source>
<translation>Copy from...</translation> <translation>Copy from...</translation>
@ -5216,10 +5224,6 @@ Please check input data and try again</translation>
<source>EDGES</source> <source>EDGES</source>
<translation>Edges</translation> <translation>Edges</translation>
</message> </message>
<message>
<source>ENTITY_TYPE</source>
<translation>Entity type</translation>
</message>
<message> <message>
<source>EQUAL_TO</source> <source>EQUAL_TO</source>
<translation>Equal to</translation> <translation>Equal to</translation>
@ -5367,6 +5371,98 @@ Please enter correct value and try again</translation>
<source>ELEMENTS</source> <source>ELEMENTS</source>
<translation>Elements</translation> <translation>Elements</translation>
</message> </message>
<message>
<source>ENTITY_TYPE</source>
<translation>Entity type</translation>
</message>
<message>
<source>ENTITY_TYPE_0</source>
<translation>POINT1</translation>
</message>
<message>
<source>ENTITY_TYPE_2</source>
<translation>SEG2</translation>
</message>
<message>
<source>ENTITY_TYPE_3</source>
<translation>SEG3</translation>
</message>
<message>
<source>ENTITY_TYPE_4</source>
<translation>TRIA3</translation>
</message>
<message>
<source>ENTITY_TYPE_5</source>
<translation>TRIA6</translation>
</message>
<message>
<source>ENTITY_TYPE_6</source>
<translation>QUAD4</translation>
</message>
<message>
<source>ENTITY_TYPE_7</source>
<translation>QUAD8</translation>
</message>
<message>
<source>ENTITY_TYPE_8</source>
<translation>QUAD9</translation>
</message>
<message>
<source>ENTITY_TYPE_9</source>
<translation>TETRA4</translation>
</message>
<message>
<source>ENTITY_TYPE_10</source>
<translation>TETRA10</translation>
</message>
<message>
<source>ENTITY_TYPE_11</source>
<translation>PYRA5</translation>
</message>
<message>
<source>ENTITY_TYPE_12</source>
<translation>PYRA13</translation>
</message>
<message>
<source>ENTITY_TYPE_13</source>
<translation>PENTA6</translation>
</message>
<message>
<source>ENTITY_TYPE_14</source>
<translation>PENTA15</translation>
</message>
<message>
<source>ENTITY_TYPE_15</source>
<translation>HEXA8</translation>
</message>
<message>
<source>ENTITY_TYPE_16</source>
<translation>HEXA20</translation>
</message>
<message>
<source>ENTITY_TYPE_17</source>
<translation>HEXA27</translation>
</message>
<message>
<source>ENTITY_TYPE_18</source>
<translation>OCTA12</translation>
</message>
<message>
<source>ENTITY_TYPE_19</source>
<translation>POLYGONE</translation>
</message>
<message>
<source>ENTITY_TYPE_20</source>
<translation>POLYEDRE</translation>
</message>
<message>
<source>ENTITY_TYPE_21</source>
<translation>NONE</translation>
</message>
<message>
<source>ENTITY_TYPE_22</source>
<translation>BALL</translation>
</message>
<message> <message>
<source>GEOM_TYPE</source> <source>GEOM_TYPE</source>
<translation>Geometry type</translation> <translation>Geometry type</translation>

68
src/SMESH_I/SMESH_2smeshpy.cxx
View File

@ -256,6 +256,8 @@ namespace {
// - FT_EqualVolumes = 17 // - FT_EqualVolumes = 17
// v 6.6.0: FT_Undefined == 44, new items: // v 6.6.0: FT_Undefined == 44, new items:
// - FT_BallDiameter = 37 // - FT_BallDiameter = 37
// v 6.7.1: FT_Undefined == 45, new items:
// - FT_EntityType = 36
// //
// It's necessary to continue recording this history and to fill // It's necessary to continue recording this history and to fill
// undef2newItems (see below) accordingly. // undef2newItems (see below) accordingly.
@ -275,6 +277,8 @@ namespace {
undef2newItems[ 43 ].assign( items, items+4 ); } undef2newItems[ 43 ].assign( items, items+4 ); }
{ int items[] = { 37 }; { int items[] = { 37 };
undef2newItems[ 44 ].assign( items, items+1 ); } undef2newItems[ 44 ].assign( items, items+1 ); }
{ int items[] = { 36 };
undef2newItems[ 45 ].assign( items, items+1 ); }
} }
int iType = Type.IntegerValue(); int iType = Type.IntegerValue();
@ -660,7 +664,7 @@ Handle(_pyCommand) _pyGen::AddCommand( const TCollection_AsciiString& theCommand
// 1 2 3 4 5 6 7 8 9 10 // 1 2 3 4 5 6 7 8 9 10
// in order to avoid the problem of type mismatch of long and FunctorType // in order to avoid the problem of type mismatch of long and FunctorType
const TCollection_AsciiString const TCollection_AsciiString
SMESH("SMESH."), dfltFunctor = "SMESH.FT_Undefined", dftlTol = "1e-07", dftlPreci = "-1"; SMESH("SMESH."), dfltFunctor("SMESH.FT_Undefined"), dftlTol("1e-07"), dftlPreci("-1");
TCollection_AsciiString TCollection_AsciiString
Type = aCommand->GetArg(1), // long Type = aCommand->GetArg(1), // long
Compare = aCommand->GetArg(2), // long Compare = aCommand->GetArg(2), // long
@ -686,17 +690,34 @@ Handle(_pyCommand) _pyGen::AddCommand( const TCollection_AsciiString& theCommand
aCommand->SetArg( 2, Type ); aCommand->SetArg( 2, Type );
aCommand->SetArg( 3, Compare ); aCommand->SetArg( 3, Compare );
if ( Type == "SMESH.FT_ElemGeomType" && Threshold.IsIntegerValue() ) if ( Threshold.IsIntegerValue() )
{ {
// set SMESH.GeometryType instead of a numerical Threshold
const char* types[SMESH::Geom_BALL+1] = {
"Geom_POINT", "Geom_EDGE", "Geom_TRIANGLE", "Geom_QUADRANGLE", "Geom_POLYGON",
"Geom_TETRA", "Geom_PYRAMID", "Geom_HEXA", "Geom_PENTA", "Geom_HEXAGONAL_PRISM",
"Geom_POLYHEDRA", "Geom_BALL"
};
int iGeom = Threshold.IntegerValue(); int iGeom = Threshold.IntegerValue();
if ( -1 < iGeom && iGeom < SMESH::Geom_POLYHEDRA+1 ) if ( Type == "SMESH.FT_ElemGeomType" )
Threshold = SMESH + types[ iGeom ]; {
// set SMESH.GeometryType instead of a numerical Threshold
const char* types[SMESH::Geom_BALL+1] = {
"Geom_POINT", "Geom_EDGE", "Geom_TRIANGLE", "Geom_QUADRANGLE", "Geom_POLYGON",
"Geom_TETRA", "Geom_PYRAMID", "Geom_HEXA", "Geom_PENTA", "Geom_HEXAGONAL_PRISM",
"Geom_POLYHEDRA", "Geom_BALL" };
if ( -1 < iGeom && iGeom < SMESH::Geom_POLYHEDRA+1 )
Threshold = SMESH + types[ iGeom ];
}
if (Type == "SMESH.FT_EntityType")
{
// set SMESH.EntityType instead of a numerical Threshold
const char* types[SMESH::Entity_Ball+1] = {
"Entity_Node", "Entity_0D", "Entity_Edge", "Entity_Quad_Edge",
"Entity_Triangle", "Entity_Quad_Triangle",
"Entity_Quadrangle", "Entity_Quad_Quadrangle", "Entity_BiQuad_Quadrangle",
"Entity_Polygon", "Entity_Quad_Polygon", "Entity_Tetra", "Entity_Quad_Tetra",
"Entity_Pyramid", "Entity_Quad_Pyramid",
"Entity_Hexa", "Entity_Quad_Hexa", "Entity_TriQuad_Hexa",
"Entity_Penta", "Entity_Quad_Penta", "Entity_Hexagonal_Prism",
"Entity_Polyhedra", "Entity_Quad_Polyhedra", "Entity_Ball" };
if ( -1 < iGeom && iGeom < SMESH::Entity_Quad_Polyhedra+1 )
Threshold = SMESH + types[ iGeom ];
}
} }
if ( ThresholdID.Length() != 2 && ThresholdStr.Length() != 2) // not '' or "" if ( ThresholdID.Length() != 2 && ThresholdStr.Length() != 2) // not '' or ""
aCommand->SetArg( 4, ThresholdID.SubString( 2, ThresholdID.Length()-1 )); // shape entry aCommand->SetArg( 4, ThresholdID.SubString( 2, ThresholdID.Length()-1 )); // shape entry
@ -773,6 +794,14 @@ void _pyGen::Process( const Handle(_pyCommand)& theCommand )
Handle(_pyMesh) mesh = new _pyMesh( theCommand, theCommand->GetResultValue(ind+1)); Handle(_pyMesh) mesh = new _pyMesh( theCommand, theCommand->GetResultValue(ind+1));
myMeshes.insert( make_pair( mesh->GetID(), mesh )); myMeshes.insert( make_pair( mesh->GetID(), mesh ));
} }
if ( method == "CreateMeshesFromGMF" )
{
// CreateMeshesFromGMF( theFileName, theMakeRequiredGroups ) ->
// CreateMeshesFromGMF( theFileName )
_AString file = theCommand->GetArg(1);
theCommand->RemoveArgs();
theCommand->SetArg( 1, file );
}
} }
// CreateHypothesis() // CreateHypothesis()
@ -1571,7 +1600,7 @@ void _pyMesh::Process( const Handle(_pyCommand)& theCommand )
method == "ExportToMEDX" ) { // ExportToMEDX() --> ExportMED() method == "ExportToMEDX" ) { // ExportToMEDX() --> ExportMED()
theCommand->SetMethod( "ExportMED" ); theCommand->SetMethod( "ExportMED" );
} }
else if ( method == "ExportCGNS" || method == "ExportGMF" ) else if ( method == "ExportCGNS" )
{ // ExportCGNS(part, ...) -> ExportCGNS(..., part) { // ExportCGNS(part, ...) -> ExportCGNS(..., part)
_pyID partID = theCommand->GetArg( 1 ); _pyID partID = theCommand->GetArg( 1 );
int nbArgs = theCommand->GetNbArgs(); int nbArgs = theCommand->GetNbArgs();
@ -1579,6 +1608,14 @@ void _pyMesh::Process( const Handle(_pyCommand)& theCommand )
theCommand->SetArg( i-1, theCommand->GetArg( i )); theCommand->SetArg( i-1, theCommand->GetArg( i ));
theCommand->SetArg( nbArgs, partID ); theCommand->SetArg( nbArgs, partID );
} }
else if ( method == "ExportGMF" )
{ // ExportGMF(part,file,bool) -> ExportCGNS(file, part)
_pyID partID = theCommand->GetArg( 1 );
_AString file = theCommand->GetArg( 2 );
theCommand->RemoveArgs();
theCommand->SetArg( 1, file );
theCommand->SetArg( 2, partID );
}
else if ( theCommand->MethodStartsFrom( "ExportPartTo" )) else if ( theCommand->MethodStartsFrom( "ExportPartTo" ))
{ // ExportPartTo*(part, ...) -> Export*(..., part) { // ExportPartTo*(part, ...) -> Export*(..., part)
// //
@ -2035,6 +2072,13 @@ void _pyMeshEditor::Process( const Handle(_pyCommand)& theCommand)
if (( isPyMeshMethod = ( newMethod.Length() > 0 ))) if (( isPyMeshMethod = ( newMethod.Length() > 0 )))
theCommand->SetMethod( newMethod ); theCommand->SetMethod( newMethod );
} }
// ConvertToBiQuadratic(...) -> ConvertToQuadratic(...,True)
if ( !isPyMeshMethod && (method == "ConvertToBiQuadratic" || method == "ConvertToBiQuadraticObject") )
{
isPyMeshMethod = true;
theCommand->SetMethod( method.SubString( 1, 9) + method.SubString( 12, method.Length()));
theCommand->SetArg( theCommand->GetNbArgs() + 1, "True" );
}
if ( !isPyMeshMethod ) if ( !isPyMeshMethod )
{ {
@ -3593,7 +3637,7 @@ void _pyCommand::SetArg( int index, const TCollection_AsciiString& theArg)
void _pyCommand::RemoveArgs() void _pyCommand::RemoveArgs()
{ {
if ( int pos = myString.Location( '(', 1, Length() )) if ( int pos = myString.Location( '(', Max( 1, GetBegPos( METHOD_IND )), Length() ))
myString.Trunc( pos ); myString.Trunc( pos );
myString += ")"; myString += ")";
myArgs.Clear(); myArgs.Clear();

34
src/SMESH_I/SMESH_DumpPython.cxx
View File

@ -196,6 +196,40 @@ namespace SMESH
} }
return *this; return *this;
} }
TPythonDump&
TPythonDump::
operator<<(const SMESH::EntityType& theArg)
{
myStream<<"SMESH.";
switch(theArg){
case Entity_0D: myStream<<"Entity_0D"; break;
case Entity_Edge: myStream<<"Entity_Edge"; break;
case Entity_Quad_Edge: myStream<<"Entity_Quad_Edge"; break;
case Entity_Triangle: myStream<<"Entity_Triangle"; break;
case Entity_Quad_Triangle: myStream<<"Entity_Quad_Triangle"; break;
case Entity_Quadrangle: myStream<<"Entity_Quadrangle"; break;
case Entity_Quad_Quadrangle: myStream<<"Entity_Quad_Quadrangle"; break;
case Entity_BiQuad_Quadrangle: myStream<<"Entity_BiQuad_Quadrangle"; break;
case Entity_Polygon: myStream<<"Entity_Polygon"; break;
case Entity_Quad_Polygon: myStream<<"Entity_Quad_Polygon"; break;
case Entity_Tetra: myStream<<"Entity_Tetra"; break;
case Entity_Quad_Tetra: myStream<<"Entity_Quad_Tetra"; break;
case Entity_Pyramid: myStream<<"Entity_Pyramid"; break;
case Entity_Quad_Pyramid: myStream<<"Entity_Quad_Pyramid"; break;
case Entity_Hexa: myStream<<"Entity_Hexa"; break;
case Entity_Quad_Hexa: myStream<<"Entity_Quad_Hexa"; break;
case Entity_TriQuad_Hexa: myStream<<"Entity_TriQuad_Hexa"; break;
case Entity_Penta: myStream<<"Entity_Penta"; break;
case Entity_Quad_Penta: myStream<<"Entity_Quad_Penta"; break;
case Entity_Hexagonal_Prism: myStream<<"Entity_Hexagonal_Prism"; break;
case Entity_Polyhedra: myStream<<"Entity_Polyhedra"; break;
case Entity_Quad_Polyhedra: myStream<<"Entity_Quad_Polyhedra"; break;
case Entity_Ball: myStream<<"Entity_Ball"; break;
case Entity_Last: myStream<<"Entity_Last"; break;
default: myStream<<"__UNKNOWN__EntityType: " << theArg;
}
return *this;
}
template<class TArray> template<class TArray>
void DumpArray(const TArray& theArray, TPythonDump & theStream) void DumpArray(const TArray& theArray, TPythonDump & theStream)

65
src/SMESH_I/SMESH_Filter_i.cxx
View File

@ -702,7 +702,6 @@ FunctorType Taper_i::GetFunctorType()
return SMESH::FT_Taper; return SMESH::FT_Taper;
} }
/* /*
Class : Skew_i Class : Skew_i
Description : Functor for calculating skew in degrees Description : Functor for calculating skew in degrees
@ -1637,6 +1636,37 @@ FunctorType ElemGeomType_i::GetFunctorType()
return SMESH::FT_ElemGeomType; return SMESH::FT_ElemGeomType;
} }
/*
Class : ElemEntityType_i
Description : Predicate check is element has indicated entity type
*/
ElemEntityType_i::ElemEntityType_i()
{
myElemEntityTypePtr.reset(new Controls::ElemEntityType());
myFunctorPtr = myPredicatePtr = myElemEntityTypePtr;
}
void ElemEntityType_i::SetElementType(ElementType theType)
{
myElemEntityTypePtr->SetType(SMDSAbs_ElementType(theType));
TPythonDump()<<this<<".SetElementType("<<theType<<")";
}
void ElemEntityType_i::SetEntityType(EntityType theEntityType)
{
myElemEntityTypePtr->SetElemEntityType(SMDSAbs_EntityType (theEntityType));
TPythonDump()<<this<<".SetEntityType("<<theEntityType<<")";
}
EntityType ElemEntityType_i::GetEntityType() const
{
return (EntityType) myElemEntityTypePtr->GetElemEntityType();
}
FunctorType ElemEntityType_i::GetFunctorType()
{
return SMESH::FT_EntityType;
}
/* /*
Class : CoplanarFaces_i Class : CoplanarFaces_i
Description : Returns true if a mesh face is a coplanar neighbour to a given one Description : Returns true if a mesh face is a coplanar neighbour to a given one
@ -2312,6 +2342,14 @@ ElemGeomType_ptr FilterManager_i::CreateElemGeomType()
return anObj._retn(); return anObj._retn();
} }
ElemEntityType_ptr FilterManager_i::CreateElemEntityType()
{
SMESH::ElemEntityType_i* aServant = new SMESH::ElemEntityType_i();
SMESH::ElemEntityType_var anObj = aServant->_this();
TPythonDump()<<aServant<<" = "<<this<<".CreateElemEntityType()";
return anObj._retn();
}
Filter_ptr FilterManager_i::CreateFilter() Filter_ptr FilterManager_i::CreateFilter()
{ {
SMESH::Filter_i* aServant = new SMESH::Filter_i(); SMESH::Filter_i* aServant = new SMESH::Filter_i();
@ -2802,6 +2840,18 @@ static inline bool getCriteria( Predicate_i* thePred,
theCriteria[ i ].Threshold = (double)aPred->GetGeometryType(); theCriteria[ i ].Threshold = (double)aPred->GetGeometryType();
return true; return true;
} }
case FT_EntityType:
{
CORBA::ULong i = theCriteria->length();
theCriteria->length( i + 1 );
theCriteria[ i ] = createCriterion();
ElemEntityType_i* aPred = dynamic_cast<ElemEntityType_i*>( thePred );
theCriteria[ i ].Type = aFType;
theCriteria[ i ].Threshold = (double)aPred->GetEntityType();
return true;
}
case FT_Undefined: case FT_Undefined:
return false; return false;
@ -3043,6 +3093,14 @@ CORBA::Boolean Filter_i::SetCriteria( const SMESH::Filter::Criteria& theCriteria
aPredicate = tmpPred; aPredicate = tmpPred;
break; break;
} }
case SMESH::FT_EntityType:
{
SMESH::ElemEntityType_ptr tmpPred = aFilterMgr->CreateElemEntityType();
tmpPred->SetElementType( aTypeOfElem );
tmpPred->SetEntityType( EntityType( (int (aThreshold + 0.5))));
aPredicate = tmpPred;
break;
}
case SMESH::FT_CoplanarFaces: case SMESH::FT_CoplanarFaces:
{ {
SMESH::CoplanarFaces_ptr tmpPred = aFilterMgr->CreateCoplanarFaces(); SMESH::CoplanarFaces_ptr tmpPred = aFilterMgr->CreateCoplanarFaces();
@ -3289,6 +3347,7 @@ static inline LDOMString toString( CORBA::Long theType )
case FT_GroupColor : return "Color of Group"; case FT_GroupColor : return "Color of Group";
case FT_LinearOrQuadratic : return "Linear or Quadratic"; case FT_LinearOrQuadratic : return "Linear or Quadratic";
case FT_ElemGeomType : return "Element geomtry type"; case FT_ElemGeomType : return "Element geomtry type";
case FT_EntityType : return "Entity type";
case FT_Undefined : return ""; case FT_Undefined : return "";
default : return ""; default : return "";
} }
@ -3341,6 +3400,7 @@ static inline SMESH::FunctorType toFunctorType( const LDOMString& theStr )
else if ( theStr.equals( "Color of Group" ) ) return FT_GroupColor; else if ( theStr.equals( "Color of Group" ) ) return FT_GroupColor;
else if ( theStr.equals( "Linear or Quadratic" ) ) return FT_LinearOrQuadratic; else if ( theStr.equals( "Linear or Quadratic" ) ) return FT_LinearOrQuadratic;
else if ( theStr.equals( "Element geomtry type" ) ) return FT_ElemGeomType; else if ( theStr.equals( "Element geomtry type" ) ) return FT_ElemGeomType;
else if ( theStr.equals( "Entity type" ) ) return FT_EntityType;
else if ( theStr.equals( "" ) ) return FT_Undefined; else if ( theStr.equals( "" ) ) return FT_Undefined;
else return FT_Undefined; else return FT_Undefined;
} }
@ -3903,6 +3963,7 @@ static const char** getFunctNames()
"FT_LinearOrQuadratic", "FT_LinearOrQuadratic",
"FT_GroupColor", "FT_GroupColor",
"FT_ElemGeomType", "FT_ElemGeomType",
"FT_EntityType",
"FT_CoplanarFaces", "FT_CoplanarFaces",
"FT_BallDiameter", "FT_BallDiameter",
"FT_LessThan", "FT_LessThan",
@ -3911,7 +3972,7 @@ static const char** getFunctNames()
"FT_LogicalNOT", "FT_LogicalNOT",
"FT_LogicalAND", "FT_LogicalAND",
"FT_LogicalOR", "FT_LogicalOR",
"FT_Undefined" }; "FT_Undefined"};
return functName; return functName;
} }

23
src/SMESH_I/SMESH_Filter_i.hxx
View File

@ -329,7 +329,6 @@ namespace SMESH
Controls::Length2DPtr myLength2DPtr; Controls::Length2DPtr myLength2DPtr;
}; };
/* /*
Class : MultiConnection_i Class : MultiConnection_i
Description : Functor for calculating number of faces conneted to the edge Description : Functor for calculating number of faces conneted to the edge
@ -450,7 +449,7 @@ namespace SMESH
OverConstrainedFace_i(); OverConstrainedFace_i();
FunctorType GetFunctorType(); FunctorType GetFunctorType();
}; };
/* /*
Class : BelongToGeom_i Class : BelongToGeom_i
Description : Predicate for selection on geometrical support Description : Predicate for selection on geometrical support
@ -763,6 +762,25 @@ namespace SMESH
private: private:
Controls::ElemGeomTypePtr myElemGeomTypePtr; Controls::ElemGeomTypePtr myElemGeomTypePtr;
}; };
/*
Class : ElemEntityType_i
Description : Functor for check element entity type
*/
class SMESH_I_EXPORT ElemEntityType_i: public virtual POA_SMESH::ElemEntityType,
public virtual Predicate_i
{
public:
ElemEntityType_i();
FunctorType GetFunctorType();
void SetElementType ( ElementType theType );
void SetEntityType( EntityType theEntityType );
EntityType GetEntityType() const;
private:
Controls::ElemEntityTypePtr myElemEntityTypePtr;
};
/* /*
Class : CoplanarFaces_i Class : CoplanarFaces_i
@ -1095,6 +1113,7 @@ namespace SMESH
LinearOrQuadratic_ptr CreateLinearOrQuadratic(); LinearOrQuadratic_ptr CreateLinearOrQuadratic();
GroupColor_ptr CreateGroupColor(); GroupColor_ptr CreateGroupColor();
ElemGeomType_ptr CreateElemGeomType(); ElemGeomType_ptr CreateElemGeomType();
ElemEntityType_ptr CreateElemEntityType();
CoplanarFaces_ptr CreateCoplanarFaces(); CoplanarFaces_ptr CreateCoplanarFaces();
LessThan_ptr CreateLessThan(); LessThan_ptr CreateLessThan();

1227
src/SMESH_I/SMESH_MeshEditor_i.cxx
View File

File diff suppressed because it is too large Load Diff

440
src/SMESH_I/SMESH_MeshEditor_i.hxx
View File

@ -61,23 +61,23 @@ public:
/*! /*!
* Return data of mesh edition preview * Return data of mesh edition preview
*/ */
SMESH::MeshPreviewStruct* GetPreviewData(); SMESH::MeshPreviewStruct* GetPreviewData() throw (SALOME::SALOME_Exception);
/*! /*!
* If during last operation of MeshEditor some nodes were * If during last operation of MeshEditor some nodes were
* created this method returns list of their IDs, if new nodes * created this method returns list of their IDs, if new nodes
* not created - returns an empty list * not created - returns an empty list
*/ */
SMESH::long_array* GetLastCreatedNodes(); SMESH::long_array* GetLastCreatedNodes() throw (SALOME::SALOME_Exception);
/*! /*!
* If during last operation of MeshEditor some elements were * If during last operation of MeshEditor some elements were
* created this method returns list of their IDs, if new elements * created this method returns list of their IDs, if new elements
* not created - returns an empty list * not created - returns an empty list
*/ */
SMESH::long_array* GetLastCreatedElems(); SMESH::long_array* GetLastCreatedElems() throw (SALOME::SALOME_Exception);
/*! /*!
* \brief Returns description of an error/warning occured during the last operation * \brief Returns description of an error/warning occured during the last operation
*/ */
SMESH::ComputeError* GetLastError(); SMESH::ComputeError* GetLastError() throw (SALOME::SALOME_Exception);
/*! /*!
* \brief Wrap a sequence of ids in a SMESH_IDSource * \brief Wrap a sequence of ids in a SMESH_IDSource
@ -85,25 +85,37 @@ public:
SMESH::SMESH_IDSource_ptr MakeIDSource(const SMESH::long_array& IDsOfElements, SMESH::SMESH_IDSource_ptr MakeIDSource(const SMESH::long_array& IDsOfElements,
SMESH::ElementType type); SMESH::ElementType type);
static bool IsTemporaryIDSource( SMESH::SMESH_IDSource_ptr& idSource ); static bool IsTemporaryIDSource( SMESH::SMESH_IDSource_ptr& idSource );
CORBA::Boolean RemoveElements(const SMESH::long_array & IDsOfElements);
CORBA::Boolean RemoveNodes(const SMESH::long_array & IDsOfNodes); CORBA::Boolean RemoveElements(const SMESH::long_array & IDsOfElements)
CORBA::Long RemoveOrphanNodes(); throw (SALOME::SALOME_Exception);
CORBA::Boolean RemoveNodes (const SMESH::long_array & IDsOfNodes)
throw (SALOME::SALOME_Exception);
CORBA::Long RemoveOrphanNodes()
throw (SALOME::SALOME_Exception);
/*! /*!
* Methods for creation new elements. * Methods for creation new elements.
* Returns ID of created element or 0 if element not created * Returns ID of created element or 0 if element not created
*/ */
CORBA::Long AddNode(CORBA::Double x, CORBA::Double y, CORBA::Double z); CORBA::Long AddNode(CORBA::Double x, CORBA::Double y, CORBA::Double z)
CORBA::Long Add0DElement(CORBA::Long IDOfNode); throw (SALOME::SALOME_Exception);
CORBA::Long Add0DElement(CORBA::Long IDOfNode)
throw (SALOME::SALOME_Exception);
CORBA::Long AddBall(CORBA::Long IDOfNodem, CORBA::Double diameter) CORBA::Long AddBall(CORBA::Long IDOfNodem, CORBA::Double diameter)
throw (SALOME::SALOME_Exception); throw (SALOME::SALOME_Exception);
CORBA::Long AddEdge(const SMESH::long_array & IDsOfNodes); CORBA::Long AddEdge(const SMESH::long_array & IDsOfNodes)
CORBA::Long AddFace(const SMESH::long_array & IDsOfNodes); throw (SALOME::SALOME_Exception);
CORBA::Long AddPolygonalFace(const SMESH::long_array & IDsOfNodes); CORBA::Long AddFace(const SMESH::long_array & IDsOfNodes)
CORBA::Long AddVolume(const SMESH::long_array & IDsOfNodes); throw (SALOME::SALOME_Exception);
CORBA::Long AddPolygonalFace(const SMESH::long_array & IDsOfNodes)
throw (SALOME::SALOME_Exception);
CORBA::Long AddVolume(const SMESH::long_array & IDsOfNodes)
throw (SALOME::SALOME_Exception);
CORBA::Long AddPolyhedralVolume(const SMESH::long_array & IDsOfNodes, CORBA::Long AddPolyhedralVolume(const SMESH::long_array & IDsOfNodes,
const SMESH::long_array & Quantities); const SMESH::long_array & Quantities)
CORBA::Long AddPolyhedralVolumeByFaces(const SMESH::long_array & IdsOfFaces); throw (SALOME::SALOME_Exception);
CORBA::Long AddPolyhedralVolumeByFaces(const SMESH::long_array & IdsOfFaces)
throw (SALOME::SALOME_Exception);
/*! /*!
* \brief Create 0D elements on all nodes of the given object except those * \brief Create 0D elements on all nodes of the given object except those
@ -161,12 +173,18 @@ public:
CORBA::Boolean MoveNode(CORBA::Long NodeID, CORBA::Boolean MoveNode(CORBA::Long NodeID,
CORBA::Double x, CORBA::Double y, CORBA::Double z); CORBA::Double x, CORBA::Double y, CORBA::Double z)
throw (SALOME::SALOME_Exception);
CORBA::Boolean InverseDiag(CORBA::Long NodeID1, CORBA::Long NodeID2)
throw (SALOME::SALOME_Exception);
CORBA::Boolean DeleteDiag(CORBA::Long NodeID1, CORBA::Long NodeID2)
throw (SALOME::SALOME_Exception);
CORBA::Boolean Reorient(const SMESH::long_array & IDsOfElements)
throw (SALOME::SALOME_Exception);
CORBA::Boolean ReorientObject(SMESH::SMESH_IDSource_ptr theObject)
throw (SALOME::SALOME_Exception);
CORBA::Boolean InverseDiag(CORBA::Long NodeID1, CORBA::Long NodeID2);
CORBA::Boolean DeleteDiag(CORBA::Long NodeID1, CORBA::Long NodeID2);
CORBA::Boolean Reorient(const SMESH::long_array & IDsOfElements);
CORBA::Boolean ReorientObject(SMESH::SMESH_IDSource_ptr theObject);
/*! /*!
* \brief Reorient faces contained in \a the2Dgroup. * \brief Reorient faces contained in \a the2Dgroup.
* \param the2Dgroup - the mesh or its part to reorient * \param the2Dgroup - the mesh or its part to reorient
@ -184,114 +202,143 @@ public:
// Split/Join faces // Split/Join faces
CORBA::Boolean TriToQuad (const SMESH::long_array & IDsOfElements, CORBA::Boolean TriToQuad (const SMESH::long_array & IDsOfElements,
SMESH::NumericalFunctor_ptr Criterion, SMESH::NumericalFunctor_ptr Criterion,
CORBA::Double MaxAngle); CORBA::Double MaxAngle)
throw (SALOME::SALOME_Exception);
CORBA::Boolean TriToQuadObject (SMESH::SMESH_IDSource_ptr theObject, CORBA::Boolean TriToQuadObject (SMESH::SMESH_IDSource_ptr theObject,
SMESH::NumericalFunctor_ptr Criterion, SMESH::NumericalFunctor_ptr Criterion,
CORBA::Double MaxAngle); CORBA::Double MaxAngle)
throw (SALOME::SALOME_Exception);
CORBA::Boolean QuadToTri (const SMESH::long_array & IDsOfElements, CORBA::Boolean QuadToTri (const SMESH::long_array & IDsOfElements,
SMESH::NumericalFunctor_ptr Criterion); SMESH::NumericalFunctor_ptr Criterion)
throw (SALOME::SALOME_Exception);
CORBA::Boolean QuadToTriObject (SMESH::SMESH_IDSource_ptr theObject, CORBA::Boolean QuadToTriObject (SMESH::SMESH_IDSource_ptr theObject,
SMESH::NumericalFunctor_ptr Criterion); SMESH::NumericalFunctor_ptr Criterion)
throw (SALOME::SALOME_Exception);
CORBA::Boolean SplitQuad (const SMESH::long_array & IDsOfElements, CORBA::Boolean SplitQuad (const SMESH::long_array & IDsOfElements,
CORBA::Boolean Diag13); CORBA::Boolean Diag13)
throw (SALOME::SALOME_Exception);
CORBA::Boolean SplitQuadObject (SMESH::SMESH_IDSource_ptr theObject, CORBA::Boolean SplitQuadObject (SMESH::SMESH_IDSource_ptr theObject,
CORBA::Boolean Diag13); CORBA::Boolean Diag13)
throw (SALOME::SALOME_Exception);
CORBA::Long BestSplit (CORBA::Long IDOfQuad, CORBA::Long BestSplit (CORBA::Long IDOfQuad,
SMESH::NumericalFunctor_ptr Criterion); SMESH::NumericalFunctor_ptr Criterion)
void SplitVolumesIntoTetra (SMESH::SMESH_IDSource_ptr elems, throw (SALOME::SALOME_Exception);
CORBA::Short methodFlags) throw (SALOME::SALOME_Exception); void SplitVolumesIntoTetra(SMESH::SMESH_IDSource_ptr elems,
CORBA::Short methodFlags)
throw (SALOME::SALOME_Exception);
CORBA::Boolean Smooth(const SMESH::long_array & IDsOfElements, CORBA::Boolean Smooth(const SMESH::long_array & IDsOfElements,
const SMESH::long_array & IDsOfFixedNodes, const SMESH::long_array & IDsOfFixedNodes,
CORBA::Long MaxNbOfIterations, CORBA::Long MaxNbOfIterations,
CORBA::Double MaxAspectRatio, CORBA::Double MaxAspectRatio,
SMESH::SMESH_MeshEditor::Smooth_Method Method); SMESH::SMESH_MeshEditor::Smooth_Method Method)
throw (SALOME::SALOME_Exception);
CORBA::Boolean SmoothObject(SMESH::SMESH_IDSource_ptr theObject, CORBA::Boolean SmoothObject(SMESH::SMESH_IDSource_ptr theObject,
const SMESH::long_array & IDsOfFixedNodes, const SMESH::long_array & IDsOfFixedNodes,
CORBA::Long MaxNbOfIterations, CORBA::Long MaxNbOfIterations,
CORBA::Double MaxAspectRatio, CORBA::Double MaxAspectRatio,
SMESH::SMESH_MeshEditor::Smooth_Method Method); SMESH::SMESH_MeshEditor::Smooth_Method Method)
throw (SALOME::SALOME_Exception);
CORBA::Boolean SmoothParametric(const SMESH::long_array & IDsOfElements, CORBA::Boolean SmoothParametric(const SMESH::long_array & IDsOfElements,
const SMESH::long_array & IDsOfFixedNodes, const SMESH::long_array & IDsOfFixedNodes,
CORBA::Long MaxNbOfIterations, CORBA::Long MaxNbOfIterations,
CORBA::Double MaxAspectRatio, CORBA::Double MaxAspectRatio,
SMESH::SMESH_MeshEditor::Smooth_Method Method); SMESH::SMESH_MeshEditor::Smooth_Method Method)
throw (SALOME::SALOME_Exception);
CORBA::Boolean SmoothParametricObject(SMESH::SMESH_IDSource_ptr theObject, CORBA::Boolean SmoothParametricObject(SMESH::SMESH_IDSource_ptr theObject,
const SMESH::long_array & IDsOfFixedNodes, const SMESH::long_array & IDsOfFixedNodes,
CORBA::Long MaxNbOfIterations, CORBA::Long MaxNbOfIterations,
CORBA::Double MaxAspectRatio, CORBA::Double MaxAspectRatio,
SMESH::SMESH_MeshEditor::Smooth_Method Method); SMESH::SMESH_MeshEditor::Smooth_Method Method)
throw (SALOME::SALOME_Exception);
CORBA::Boolean smooth(const SMESH::long_array & IDsOfElements, CORBA::Boolean smooth(const SMESH::long_array & IDsOfElements,
const SMESH::long_array & IDsOfFixedNodes, const SMESH::long_array & IDsOfFixedNodes,
CORBA::Long MaxNbOfIterations, CORBA::Long MaxNbOfIterations,
CORBA::Double MaxAspectRatio, CORBA::Double MaxAspectRatio,
SMESH::SMESH_MeshEditor::Smooth_Method Method, SMESH::SMESH_MeshEditor::Smooth_Method Method,
bool IsParametric); bool IsParametric)
throw (SALOME::SALOME_Exception);
CORBA::Boolean smoothObject(SMESH::SMESH_IDSource_ptr theObject, CORBA::Boolean smoothObject(SMESH::SMESH_IDSource_ptr theObject,
const SMESH::long_array & IDsOfFixedNodes, const SMESH::long_array & IDsOfFixedNodes,
CORBA::Long MaxNbOfIterations, CORBA::Long MaxNbOfIterations,
CORBA::Double MaxAspectRatio, CORBA::Double MaxAspectRatio,
SMESH::SMESH_MeshEditor::Smooth_Method Method, SMESH::SMESH_MeshEditor::Smooth_Method Method,
bool IsParametric); bool IsParametric)
void ConvertToQuadratic(CORBA::Boolean Force3d);
CORBA::Boolean ConvertFromQuadratic();
void ConvertToQuadraticObject(CORBA::Boolean theForce3d,
SMESH::SMESH_IDSource_ptr theObject)
throw (SALOME::SALOME_Exception);
void ConvertFromQuadraticObject(SMESH::SMESH_IDSource_ptr theObject)
throw (SALOME::SALOME_Exception); throw (SALOME::SALOME_Exception);
void RenumberNodes(); CORBA::Boolean ConvertFromQuadratic()
void RenumberElements(); throw (SALOME::SALOME_Exception);
void ConvertFromQuadraticObject(SMESH::SMESH_IDSource_ptr theObject)
throw (SALOME::SALOME_Exception);
void ConvertToQuadratic(CORBA::Boolean Force3d)
throw (SALOME::SALOME_Exception);
void ConvertToQuadraticObject(CORBA::Boolean theForce3d,
SMESH::SMESH_IDSource_ptr theObject)
throw (SALOME::SALOME_Exception);
void ConvertToBiQuadratic(CORBA::Boolean theForce3d,
SMESH::SMESH_IDSource_ptr theObject)
throw (SALOME::SALOME_Exception);
void RenumberNodes() throw (SALOME::SALOME_Exception);
void RenumberElements() throw (SALOME::SALOME_Exception);
void RotationSweep(const SMESH::long_array & IDsOfElements, void RotationSweep(const SMESH::long_array & IDsOfElements,
const SMESH::AxisStruct & Axis, const SMESH::AxisStruct & Axis,
CORBA::Double AngleInRadians, CORBA::Double AngleInRadians,
CORBA::Long NbOfSteps, CORBA::Long NbOfSteps,
CORBA::Double Tolerance); CORBA::Double Tolerance)
throw (SALOME::SALOME_Exception);
void RotationSweepObject(SMESH::SMESH_IDSource_ptr theObject, void RotationSweepObject(SMESH::SMESH_IDSource_ptr theObject,
const SMESH::AxisStruct & Axis, const SMESH::AxisStruct & Axis,
CORBA::Double AngleInRadians, CORBA::Double AngleInRadians,
CORBA::Long NbOfSteps, CORBA::Long NbOfSteps,
CORBA::Double Tolerance); CORBA::Double Tolerance)
throw (SALOME::SALOME_Exception);
void RotationSweepObject1D(SMESH::SMESH_IDSource_ptr theObject, void RotationSweepObject1D(SMESH::SMESH_IDSource_ptr theObject,
const SMESH::AxisStruct & Axis, const SMESH::AxisStruct & Axis,
CORBA::Double AngleInRadians, CORBA::Double AngleInRadians,
CORBA::Long NbOfSteps, CORBA::Long NbOfSteps,
CORBA::Double Tolerance); CORBA::Double Tolerance)
throw (SALOME::SALOME_Exception);
void RotationSweepObject2D(SMESH::SMESH_IDSource_ptr theObject, void RotationSweepObject2D(SMESH::SMESH_IDSource_ptr theObject,
const SMESH::AxisStruct & Axis, const SMESH::AxisStruct & Axis,
CORBA::Double AngleInRadians, CORBA::Double AngleInRadians,
CORBA::Long NbOfSteps, CORBA::Long NbOfSteps,
CORBA::Double Tolerance); CORBA::Double Tolerance)
throw (SALOME::SALOME_Exception);
void ExtrusionSweep(const SMESH::long_array & IDsOfElements, void ExtrusionSweep(const SMESH::long_array & IDsOfElements,
const SMESH::DirStruct & StepVector, const SMESH::DirStruct & StepVector,
CORBA::Long NbOfSteps); CORBA::Long NbOfSteps)
throw (SALOME::SALOME_Exception);
void ExtrusionSweep0D(const SMESH::long_array & IDsOfElements, void ExtrusionSweep0D(const SMESH::long_array & IDsOfElements,
const SMESH::DirStruct & StepVector, const SMESH::DirStruct & StepVector,
CORBA::Long NbOfSteps); CORBA::Long NbOfSteps)
throw (SALOME::SALOME_Exception);
void ExtrusionSweepObject(SMESH::SMESH_IDSource_ptr theObject, void ExtrusionSweepObject(SMESH::SMESH_IDSource_ptr theObject,
const SMESH::DirStruct & StepVector, const SMESH::DirStruct & StepVector,
CORBA::Long NbOfSteps); CORBA::Long NbOfSteps)
throw (SALOME::SALOME_Exception);
void ExtrusionSweepObject0D(SMESH::SMESH_IDSource_ptr theObject, void ExtrusionSweepObject0D(SMESH::SMESH_IDSource_ptr theObject,
const SMESH::DirStruct & StepVector, const SMESH::DirStruct & StepVector,
CORBA::Long NbOfSteps); CORBA::Long NbOfSteps)
throw (SALOME::SALOME_Exception);
void ExtrusionSweepObject1D(SMESH::SMESH_IDSource_ptr theObject, void ExtrusionSweepObject1D(SMESH::SMESH_IDSource_ptr theObject,
const SMESH::DirStruct & StepVector, const SMESH::DirStruct & StepVector,
CORBA::Long NbOfSteps); CORBA::Long NbOfSteps)
throw (SALOME::SALOME_Exception);
void ExtrusionSweepObject2D(SMESH::SMESH_IDSource_ptr theObject, void ExtrusionSweepObject2D(SMESH::SMESH_IDSource_ptr theObject,
const SMESH::DirStruct & StepVector, const SMESH::DirStruct & StepVector,
CORBA::Long NbOfSteps); CORBA::Long NbOfSteps)
throw (SALOME::SALOME_Exception);
void AdvancedExtrusion(const SMESH::long_array & theIDsOfElements, void AdvancedExtrusion(const SMESH::long_array & theIDsOfElements,
const SMESH::DirStruct & theStepVector, const SMESH::DirStruct & theStepVector,
CORBA::Long theNbOfSteps, CORBA::Long theNbOfSteps,
CORBA::Long theExtrFlags, CORBA::Long theExtrFlags,
CORBA::Double theSewTolerance); CORBA::Double theSewTolerance)
throw (SALOME::SALOME_Exception);
SMESH::SMESH_MeshEditor::Extrusion_Error SMESH::SMESH_MeshEditor::Extrusion_Error
ExtrusionAlongPath(const SMESH::long_array & IDsOfElements, ExtrusionAlongPath(const SMESH::long_array & IDsOfElements,
@ -301,7 +348,8 @@ public:
CORBA::Boolean HasAngles, CORBA::Boolean HasAngles,
const SMESH::double_array & Angles, const SMESH::double_array & Angles,
CORBA::Boolean HasRefPoint, CORBA::Boolean HasRefPoint,
const SMESH::PointStruct & RefPoint); const SMESH::PointStruct & RefPoint)
throw (SALOME::SALOME_Exception);
SMESH::SMESH_MeshEditor::Extrusion_Error SMESH::SMESH_MeshEditor::Extrusion_Error
ExtrusionAlongPathObject(SMESH::SMESH_IDSource_ptr theObject, ExtrusionAlongPathObject(SMESH::SMESH_IDSource_ptr theObject,
@ -311,7 +359,8 @@ public:
CORBA::Boolean HasAngles, CORBA::Boolean HasAngles,
const SMESH::double_array & Angles, const SMESH::double_array & Angles,
CORBA::Boolean HasRefPoint, CORBA::Boolean HasRefPoint,
const SMESH::PointStruct & RefPoint); const SMESH::PointStruct & RefPoint)
throw (SALOME::SALOME_Exception);
SMESH::SMESH_MeshEditor::Extrusion_Error SMESH::SMESH_MeshEditor::Extrusion_Error
ExtrusionAlongPathObject1D(SMESH::SMESH_IDSource_ptr theObject, ExtrusionAlongPathObject1D(SMESH::SMESH_IDSource_ptr theObject,
SMESH::SMESH_Mesh_ptr PathMesh, SMESH::SMESH_Mesh_ptr PathMesh,
@ -320,7 +369,8 @@ public:
CORBA::Boolean HasAngles, CORBA::Boolean HasAngles,
const SMESH::double_array & Angles, const SMESH::double_array & Angles,
CORBA::Boolean HasRefPoint, CORBA::Boolean HasRefPoint,
const SMESH::PointStruct & RefPoint); const SMESH::PointStruct & RefPoint)
throw (SALOME::SALOME_Exception);
SMESH::SMESH_MeshEditor::Extrusion_Error SMESH::SMESH_MeshEditor::Extrusion_Error
ExtrusionAlongPathObject2D(SMESH::SMESH_IDSource_ptr theObject, ExtrusionAlongPathObject2D(SMESH::SMESH_IDSource_ptr theObject,
SMESH::SMESH_Mesh_ptr PathMesh, SMESH::SMESH_Mesh_ptr PathMesh,
@ -329,7 +379,8 @@ public:
CORBA::Boolean HasAngles, CORBA::Boolean HasAngles,
const SMESH::double_array & Angles, const SMESH::double_array & Angles,
CORBA::Boolean HasRefPoint, CORBA::Boolean HasRefPoint,
const SMESH::PointStruct & RefPoint); const SMESH::PointStruct & RefPoint)
throw (SALOME::SALOME_Exception);
SMESH::double_array* LinearAnglesVariation(SMESH::SMESH_Mesh_ptr PathMesh, SMESH::double_array* LinearAnglesVariation(SMESH::SMESH_Mesh_ptr PathMesh,
GEOM::GEOM_Object_ptr PathShape, GEOM::GEOM_Object_ptr PathShape,
@ -338,70 +389,87 @@ public:
void Mirror(const SMESH::long_array & IDsOfElements, void Mirror(const SMESH::long_array & IDsOfElements,
const SMESH::AxisStruct & Axis, const SMESH::AxisStruct & Axis,
SMESH::SMESH_MeshEditor::MirrorType MirrorType, SMESH::SMESH_MeshEditor::MirrorType MirrorType,
CORBA::Boolean Copy); CORBA::Boolean Copy)
throw (SALOME::SALOME_Exception);
void MirrorObject(SMESH::SMESH_IDSource_ptr theObject, void MirrorObject(SMESH::SMESH_IDSource_ptr theObject,
const SMESH::AxisStruct & Axis, const SMESH::AxisStruct & Axis,
SMESH::SMESH_MeshEditor::MirrorType MirrorType, SMESH::SMESH_MeshEditor::MirrorType MirrorType,
CORBA::Boolean Copy); CORBA::Boolean Copy)
throw (SALOME::SALOME_Exception);
void Translate(const SMESH::long_array & IDsOfElements, void Translate(const SMESH::long_array & IDsOfElements,
const SMESH::DirStruct & Vector, const SMESH::DirStruct & Vector,
CORBA::Boolean Copy); CORBA::Boolean Copy)
throw (SALOME::SALOME_Exception);
void TranslateObject(SMESH::SMESH_IDSource_ptr theObject, void TranslateObject(SMESH::SMESH_IDSource_ptr theObject,
const SMESH::DirStruct & Vector, const SMESH::DirStruct & Vector,
CORBA::Boolean Copy); CORBA::Boolean Copy)
throw (SALOME::SALOME_Exception);
void Rotate(const SMESH::long_array & IDsOfElements, void Rotate(const SMESH::long_array & IDsOfElements,
const SMESH::AxisStruct & Axis, const SMESH::AxisStruct & Axis,
CORBA::Double Angle, CORBA::Double Angle,
CORBA::Boolean Copy); CORBA::Boolean Copy)
throw (SALOME::SALOME_Exception);
void RotateObject(SMESH::SMESH_IDSource_ptr theObject, void RotateObject(SMESH::SMESH_IDSource_ptr theObject,
const SMESH::AxisStruct & Axis, const SMESH::AxisStruct & Axis,
CORBA::Double Angle, CORBA::Double Angle,
CORBA::Boolean Copy); CORBA::Boolean Copy)
throw (SALOME::SALOME_Exception);
SMESH::ListOfGroups* RotationSweepMakeGroups(const SMESH::long_array& IDsOfElements, SMESH::ListOfGroups* RotationSweepMakeGroups(const SMESH::long_array& IDsOfElements,
const SMESH::AxisStruct& Axix, const SMESH::AxisStruct& Axix,
CORBA::Double AngleInRadians, CORBA::Double AngleInRadians,
CORBA::Long NbOfSteps, CORBA::Long NbOfSteps,
CORBA::Double Tolerance); CORBA::Double Tolerance)
throw (SALOME::SALOME_Exception);
SMESH::ListOfGroups* RotationSweepObjectMakeGroups(SMESH::SMESH_IDSource_ptr Object, SMESH::ListOfGroups* RotationSweepObjectMakeGroups(SMESH::SMESH_IDSource_ptr Object,
const SMESH::AxisStruct& Axix, const SMESH::AxisStruct& Axix,
CORBA::Double AngleInRadians, CORBA::Double AngleInRadians,
CORBA::Long NbOfSteps, CORBA::Long NbOfSteps,
CORBA::Double Tolerance); CORBA::Double Tolerance)
throw (SALOME::SALOME_Exception);
SMESH::ListOfGroups* RotationSweepObject1DMakeGroups(SMESH::SMESH_IDSource_ptr Object, SMESH::ListOfGroups* RotationSweepObject1DMakeGroups(SMESH::SMESH_IDSource_ptr Object,
const SMESH::AxisStruct& Axix, const SMESH::AxisStruct& Axix,
CORBA::Double AngleInRadians, CORBA::Double AngleInRadians,
CORBA::Long NbOfSteps, CORBA::Long NbOfSteps,
CORBA::Double Tolerance); CORBA::Double Tolerance)
throw (SALOME::SALOME_Exception);
SMESH::ListOfGroups* RotationSweepObject2DMakeGroups(SMESH::SMESH_IDSource_ptr Object, SMESH::ListOfGroups* RotationSweepObject2DMakeGroups(SMESH::SMESH_IDSource_ptr Object,
const SMESH::AxisStruct& Axix, const SMESH::AxisStruct& Axix,
CORBA::Double AngleInRadians, CORBA::Double AngleInRadians,
CORBA::Long NbOfSteps, CORBA::Long NbOfSteps,
CORBA::Double Tolerance); CORBA::Double Tolerance)
throw (SALOME::SALOME_Exception);
SMESH::ListOfGroups* ExtrusionSweepMakeGroups(const SMESH::long_array& IDsOfElements, SMESH::ListOfGroups* ExtrusionSweepMakeGroups(const SMESH::long_array& IDsOfElements,
const SMESH::DirStruct& StepVector, const SMESH::DirStruct& StepVector,
CORBA::Long NbOfSteps); CORBA::Long NbOfSteps)
throw (SALOME::SALOME_Exception);
SMESH::ListOfGroups* ExtrusionSweepMakeGroups0D(const SMESH::long_array& IDsOfElements, SMESH::ListOfGroups* ExtrusionSweepMakeGroups0D(const SMESH::long_array& IDsOfElements,
const SMESH::DirStruct& StepVector, const SMESH::DirStruct& StepVector,
CORBA::Long NbOfSteps); CORBA::Long NbOfSteps)
throw (SALOME::SALOME_Exception);
SMESH::ListOfGroups* AdvancedExtrusionMakeGroups(const SMESH::long_array& IDsOfElements, SMESH::ListOfGroups* AdvancedExtrusionMakeGroups(const SMESH::long_array& IDsOfElements,
const SMESH::DirStruct& StepVector, const SMESH::DirStruct& StepVector,
CORBA::Long NbOfSteps, CORBA::Long NbOfSteps,
CORBA::Long ExtrFlags, CORBA::Long ExtrFlags,
CORBA::Double SewTolerance); CORBA::Double SewTolerance)
throw (SALOME::SALOME_Exception);
SMESH::ListOfGroups* ExtrusionSweepObjectMakeGroups(SMESH::SMESH_IDSource_ptr Object, SMESH::ListOfGroups* ExtrusionSweepObjectMakeGroups(SMESH::SMESH_IDSource_ptr Object,
const SMESH::DirStruct& StepVector, const SMESH::DirStruct& StepVector,
CORBA::Long NbOfSteps); CORBA::Long NbOfSteps)
throw (SALOME::SALOME_Exception);
SMESH::ListOfGroups* ExtrusionSweepObject0DMakeGroups(SMESH::SMESH_IDSource_ptr Object, SMESH::ListOfGroups* ExtrusionSweepObject0DMakeGroups(SMESH::SMESH_IDSource_ptr Object,
const SMESH::DirStruct& StepVector, const SMESH::DirStruct& StepVector,
CORBA::Long NbOfSteps); CORBA::Long NbOfSteps)
throw (SALOME::SALOME_Exception);
SMESH::ListOfGroups* ExtrusionSweepObject1DMakeGroups(SMESH::SMESH_IDSource_ptr Object, SMESH::ListOfGroups* ExtrusionSweepObject1DMakeGroups(SMESH::SMESH_IDSource_ptr Object,
const SMESH::DirStruct& StepVector, const SMESH::DirStruct& StepVector,
CORBA::Long NbOfSteps); CORBA::Long NbOfSteps)
throw (SALOME::SALOME_Exception);
SMESH::ListOfGroups* ExtrusionSweepObject2DMakeGroups(SMESH::SMESH_IDSource_ptr Object, SMESH::ListOfGroups* ExtrusionSweepObject2DMakeGroups(SMESH::SMESH_IDSource_ptr Object,
const SMESH::DirStruct& StepVector, const SMESH::DirStruct& StepVector,
CORBA::Long NbOfSteps); CORBA::Long NbOfSteps)
throw (SALOME::SALOME_Exception);
SMESH::ListOfGroups* ExtrusionAlongPathMakeGroups(const SMESH::long_array& IDsOfElements, SMESH::ListOfGroups* ExtrusionAlongPathMakeGroups(const SMESH::long_array& IDsOfElements,
SMESH::SMESH_Mesh_ptr PathMesh, SMESH::SMESH_Mesh_ptr PathMesh,
GEOM::GEOM_Object_ptr PathShape, GEOM::GEOM_Object_ptr PathShape,
@ -410,7 +478,8 @@ public:
const SMESH::double_array& Angles, const SMESH::double_array& Angles,
CORBA::Boolean HasRefPoint, CORBA::Boolean HasRefPoint,
const SMESH::PointStruct& RefPoint, const SMESH::PointStruct& RefPoint,
SMESH::SMESH_MeshEditor::Extrusion_Error& Error); SMESH::SMESH_MeshEditor::Extrusion_Error& Error)
throw (SALOME::SALOME_Exception);
SMESH::ListOfGroups* ExtrusionAlongPathObjectMakeGroups(SMESH::SMESH_IDSource_ptr Object, SMESH::ListOfGroups* ExtrusionAlongPathObjectMakeGroups(SMESH::SMESH_IDSource_ptr Object,
SMESH::SMESH_Mesh_ptr PathMesh, SMESH::SMESH_Mesh_ptr PathMesh,
GEOM::GEOM_Object_ptr PathShape, GEOM::GEOM_Object_ptr PathShape,
@ -419,7 +488,8 @@ public:
const SMESH::double_array& Angles, const SMESH::double_array& Angles,
CORBA::Boolean HasRefPoint, CORBA::Boolean HasRefPoint,
const SMESH::PointStruct& RefPoint, const SMESH::PointStruct& RefPoint,
SMESH::SMESH_MeshEditor::Extrusion_Error& Error); SMESH::SMESH_MeshEditor::Extrusion_Error& Error)
throw (SALOME::SALOME_Exception);
SMESH::ListOfGroups* ExtrusionAlongPathObject1DMakeGroups(SMESH::SMESH_IDSource_ptr Object, SMESH::ListOfGroups* ExtrusionAlongPathObject1DMakeGroups(SMESH::SMESH_IDSource_ptr Object,
SMESH::SMESH_Mesh_ptr PathMesh, SMESH::SMESH_Mesh_ptr PathMesh,
GEOM::GEOM_Object_ptr PathShape, GEOM::GEOM_Object_ptr PathShape,
@ -428,7 +498,8 @@ public:
const SMESH::double_array& Angles, const SMESH::double_array& Angles,
CORBA::Boolean HasRefPoint, CORBA::Boolean HasRefPoint,
const SMESH::PointStruct& RefPoint, const SMESH::PointStruct& RefPoint,
SMESH::SMESH_MeshEditor::Extrusion_Error& Error); SMESH::SMESH_MeshEditor::Extrusion_Error& Error)
throw (SALOME::SALOME_Exception);
SMESH::ListOfGroups* ExtrusionAlongPathObject2DMakeGroups(SMESH::SMESH_IDSource_ptr Object, SMESH::ListOfGroups* ExtrusionAlongPathObject2DMakeGroups(SMESH::SMESH_IDSource_ptr Object,
SMESH::SMESH_Mesh_ptr PathMesh, SMESH::SMESH_Mesh_ptr PathMesh,
GEOM::GEOM_Object_ptr PathShape, GEOM::GEOM_Object_ptr PathShape,
@ -437,7 +508,8 @@ public:
const SMESH::double_array& Angles, const SMESH::double_array& Angles,
CORBA::Boolean HasRefPoint, CORBA::Boolean HasRefPoint,
const SMESH::PointStruct& RefPoint, const SMESH::PointStruct& RefPoint,
SMESH::SMESH_MeshEditor::Extrusion_Error& Error); SMESH::SMESH_MeshEditor::Extrusion_Error& Error)
throw (SALOME::SALOME_Exception);
// skl 04.06.2009 // skl 04.06.2009
SMESH::ListOfGroups* ExtrusionAlongPathObjX(SMESH::SMESH_IDSource_ptr Object, SMESH::ListOfGroups* ExtrusionAlongPathObjX(SMESH::SMESH_IDSource_ptr Object,
@ -450,7 +522,8 @@ public:
const SMESH::PointStruct& RefPoint, const SMESH::PointStruct& RefPoint,
CORBA::Boolean MakeGroups, CORBA::Boolean MakeGroups,
SMESH::ElementType ElemType, SMESH::ElementType ElemType,
SMESH::SMESH_MeshEditor::Extrusion_Error& Error); SMESH::SMESH_MeshEditor::Extrusion_Error& Error)
throw (SALOME::SALOME_Exception);
SMESH::ListOfGroups* ExtrusionAlongPathX(const SMESH::long_array& IDsOfElements, SMESH::ListOfGroups* ExtrusionAlongPathX(const SMESH::long_array& IDsOfElements,
SMESH::SMESH_IDSource_ptr Path, SMESH::SMESH_IDSource_ptr Path,
CORBA::Long NodeStart, CORBA::Long NodeStart,
@ -461,93 +534,118 @@ public:
const SMESH::PointStruct& RefPoint, const SMESH::PointStruct& RefPoint,
CORBA::Boolean MakeGroups, CORBA::Boolean MakeGroups,
SMESH::ElementType ElemType, SMESH::ElementType ElemType,
SMESH::SMESH_MeshEditor::Extrusion_Error& Error); SMESH::SMESH_MeshEditor::Extrusion_Error& Error)
throw (SALOME::SALOME_Exception);
SMESH::ListOfGroups* MirrorMakeGroups(const SMESH::long_array& IDsOfElements, SMESH::ListOfGroups* MirrorMakeGroups(const SMESH::long_array& IDsOfElements,
const SMESH::AxisStruct& Mirror, const SMESH::AxisStruct& Mirror,
SMESH::SMESH_MeshEditor::MirrorType MirrorType); SMESH::SMESH_MeshEditor::MirrorType MirrorType)
throw (SALOME::SALOME_Exception);
SMESH::ListOfGroups* MirrorObjectMakeGroups(SMESH::SMESH_IDSource_ptr Object, SMESH::ListOfGroups* MirrorObjectMakeGroups(SMESH::SMESH_IDSource_ptr Object,
const SMESH::AxisStruct& Mirror, const SMESH::AxisStruct& Mirror,
SMESH::SMESH_MeshEditor::MirrorType MirrorType); SMESH::SMESH_MeshEditor::MirrorType MirrorType)
throw (SALOME::SALOME_Exception);
SMESH::ListOfGroups* TranslateMakeGroups(const SMESH::long_array& IDsOfElements, SMESH::ListOfGroups* TranslateMakeGroups(const SMESH::long_array& IDsOfElements,
const SMESH::DirStruct& Vector); const SMESH::DirStruct& Vector)
throw (SALOME::SALOME_Exception);
SMESH::ListOfGroups* TranslateObjectMakeGroups(SMESH::SMESH_IDSource_ptr Object, SMESH::ListOfGroups* TranslateObjectMakeGroups(SMESH::SMESH_IDSource_ptr Object,
const SMESH::DirStruct& Vector); const SMESH::DirStruct& Vector)
throw (SALOME::SALOME_Exception);
SMESH::ListOfGroups* RotateMakeGroups(const SMESH::long_array& IDsOfElements, SMESH::ListOfGroups* RotateMakeGroups(const SMESH::long_array& IDsOfElements,
const SMESH::AxisStruct& Axis, const SMESH::AxisStruct& Axis,
CORBA::Double AngleInRadians); CORBA::Double AngleInRadians)
throw (SALOME::SALOME_Exception);
SMESH::ListOfGroups* RotateObjectMakeGroups(SMESH::SMESH_IDSource_ptr Object, SMESH::ListOfGroups* RotateObjectMakeGroups(SMESH::SMESH_IDSource_ptr Object,
const SMESH::AxisStruct& Axis, const SMESH::AxisStruct& Axis,
CORBA::Double AngleInRadians); CORBA::Double AngleInRadians)
throw (SALOME::SALOME_Exception);
SMESH::SMESH_Mesh_ptr MirrorMakeMesh(const SMESH::long_array& IDsOfElements, SMESH::SMESH_Mesh_ptr MirrorMakeMesh(const SMESH::long_array& IDsOfElements,
const SMESH::AxisStruct& Mirror, const SMESH::AxisStruct& Mirror,
SMESH::SMESH_MeshEditor::MirrorType MirrorType, SMESH::SMESH_MeshEditor::MirrorType MirrorType,
CORBA::Boolean CopyGroups, CORBA::Boolean CopyGroups,
const char* MeshName); const char* MeshName)
throw (SALOME::SALOME_Exception);
SMESH::SMESH_Mesh_ptr MirrorObjectMakeMesh(SMESH::SMESH_IDSource_ptr Object, SMESH::SMESH_Mesh_ptr MirrorObjectMakeMesh(SMESH::SMESH_IDSource_ptr Object,
const SMESH::AxisStruct& Mirror, const SMESH::AxisStruct& Mirror,
SMESH::SMESH_MeshEditor::MirrorType MirrorType, SMESH::SMESH_MeshEditor::MirrorType MirrorType,
CORBA::Boolean CopyGroups, CORBA::Boolean CopyGroups,
const char* MeshName); const char* MeshName)
throw (SALOME::SALOME_Exception);
SMESH::SMESH_Mesh_ptr TranslateMakeMesh(const SMESH::long_array& IDsOfElements, SMESH::SMESH_Mesh_ptr TranslateMakeMesh(const SMESH::long_array& IDsOfElements,
const SMESH::DirStruct& Vector, const SMESH::DirStruct& Vector,
CORBA::Boolean CopyGroups, CORBA::Boolean CopyGroups,
const char* MeshName); const char* MeshName)
throw (SALOME::SALOME_Exception);
SMESH::SMESH_Mesh_ptr TranslateObjectMakeMesh(SMESH::SMESH_IDSource_ptr Object, SMESH::SMESH_Mesh_ptr TranslateObjectMakeMesh(SMESH::SMESH_IDSource_ptr Object,
const SMESH::DirStruct& Vector, const SMESH::DirStruct& Vector,
CORBA::Boolean CopyGroups, CORBA::Boolean CopyGroups,
const char* MeshName); const char* MeshName)
throw (SALOME::SALOME_Exception);
SMESH::SMESH_Mesh_ptr RotateMakeMesh(const SMESH::long_array& IDsOfElements, SMESH::SMESH_Mesh_ptr RotateMakeMesh(const SMESH::long_array& IDsOfElements,
const SMESH::AxisStruct& Axis, const SMESH::AxisStruct& Axis,
CORBA::Double AngleInRadians, CORBA::Double AngleInRadians,
CORBA::Boolean CopyGroups, CORBA::Boolean CopyGroups,
const char* MeshName); const char* MeshName)
throw (SALOME::SALOME_Exception);
SMESH::SMESH_Mesh_ptr RotateObjectMakeMesh(SMESH::SMESH_IDSource_ptr Object, SMESH::SMESH_Mesh_ptr RotateObjectMakeMesh(SMESH::SMESH_IDSource_ptr Object,
const SMESH::AxisStruct& Axis, const SMESH::AxisStruct& Axis,
CORBA::Double AngleInRadians, CORBA::Double AngleInRadians,
CORBA::Boolean CopyGroups, CORBA::Boolean CopyGroups,
const char* MeshName); const char* MeshName)
throw (SALOME::SALOME_Exception);
void Scale(SMESH::SMESH_IDSource_ptr theObject, void Scale(SMESH::SMESH_IDSource_ptr theObject,
const SMESH::PointStruct& thePoint, const SMESH::PointStruct& thePoint,
const SMESH::double_array& theScaleFact, const SMESH::double_array& theScaleFact,
CORBA::Boolean theCopy); CORBA::Boolean theCopy)
throw (SALOME::SALOME_Exception);
SMESH::ListOfGroups* ScaleMakeGroups(SMESH::SMESH_IDSource_ptr theObject, SMESH::ListOfGroups* ScaleMakeGroups(SMESH::SMESH_IDSource_ptr theObject,
const SMESH::PointStruct& thePoint, const SMESH::PointStruct& thePoint,
const SMESH::double_array& theScaleFact); const SMESH::double_array& theScaleFact)
throw (SALOME::SALOME_Exception);
SMESH::SMESH_Mesh_ptr ScaleMakeMesh(SMESH::SMESH_IDSource_ptr Object, SMESH::SMESH_Mesh_ptr ScaleMakeMesh(SMESH::SMESH_IDSource_ptr Object,
const SMESH::PointStruct& Point, const SMESH::PointStruct& Point,
const SMESH::double_array& theScaleFact, const SMESH::double_array& theScaleFact,
CORBA::Boolean CopyGroups, CORBA::Boolean CopyGroups,
const char* MeshName); const char* MeshName)
throw (SALOME::SALOME_Exception);
void FindCoincidentNodes (CORBA::Double Tolerance, void FindCoincidentNodes (CORBA::Double Tolerance,
SMESH::array_of_long_array_out GroupsOfNodes); SMESH::array_of_long_array_out GroupsOfNodes)
throw (SALOME::SALOME_Exception);
void FindCoincidentNodesOnPart(SMESH::SMESH_IDSource_ptr Object, void FindCoincidentNodesOnPart(SMESH::SMESH_IDSource_ptr Object,
CORBA::Double Tolerance, CORBA::Double Tolerance,
SMESH::array_of_long_array_out GroupsOfNodes); SMESH::array_of_long_array_out GroupsOfNodes)
throw (SALOME::SALOME_Exception);
void FindCoincidentNodesOnPartBut(SMESH::SMESH_IDSource_ptr Object, void FindCoincidentNodesOnPartBut(SMESH::SMESH_IDSource_ptr Object,
CORBA::Double Tolerance, CORBA::Double Tolerance,
SMESH::array_of_long_array_out GroupsOfNodes, SMESH::array_of_long_array_out GroupsOfNodes,
const SMESH::ListOfIDSources& ExceptSubMeshOrGroups); const SMESH::ListOfIDSources& ExceptSubMeshOrGroups)
void MergeNodes (const SMESH::array_of_long_array& GroupsOfNodes); throw (SALOME::SALOME_Exception);
void MergeNodes (const SMESH::array_of_long_array& GroupsOfNodes)
throw (SALOME::SALOME_Exception);
void FindEqualElements(SMESH::SMESH_IDSource_ptr Object, void FindEqualElements(SMESH::SMESH_IDSource_ptr Object,
SMESH::array_of_long_array_out GroupsOfElementsID); SMESH::array_of_long_array_out GroupsOfElementsID)
void MergeElements(const SMESH::array_of_long_array& GroupsOfElementsID); throw (SALOME::SALOME_Exception);
void MergeEqualElements(); void MergeElements(const SMESH::array_of_long_array& GroupsOfElementsID)
throw (SALOME::SALOME_Exception);
void MergeEqualElements()
throw (SALOME::SALOME_Exception);
CORBA::Long MoveClosestNodeToPoint(CORBA::Double x, CORBA::Long MoveClosestNodeToPoint(CORBA::Double x,
CORBA::Double y, CORBA::Double y,
CORBA::Double z, CORBA::Double z,
CORBA::Long nodeID); CORBA::Long nodeID)
throw (SALOME::SALOME_Exception);
/*! /*!
* \brief Return ID of node closest to a given point * \brief Return ID of node closest to a given point
*/ */
CORBA::Long FindNodeClosestTo(CORBA::Double x, CORBA::Long FindNodeClosestTo(CORBA::Double x,
CORBA::Double y, CORBA::Double y,
CORBA::Double z); CORBA::Double z)
throw (SALOME::SALOME_Exception);
/*! /*!
* Return elements of given type where the given point is IN or ON. * Return elements of given type where the given point is IN or ON.
* 'ALL' type means elements of any type excluding nodes * 'ALL' type means elements of any type excluding nodes
@ -555,7 +653,8 @@ public:
SMESH::long_array* FindElementsByPoint(CORBA::Double x, SMESH::long_array* FindElementsByPoint(CORBA::Double x,
CORBA::Double y, CORBA::Double y,
CORBA::Double z, CORBA::Double z,
SMESH::ElementType type); SMESH::ElementType type)
throw (SALOME::SALOME_Exception);
/*! /*!
* Searching among the given elements, return elements of given type * Searching among the given elements, return elements of given type
* where the given point is IN or ON. * where the given point is IN or ON.
@ -565,13 +664,15 @@ public:
CORBA::Double x, CORBA::Double x,
CORBA::Double y, CORBA::Double y,
CORBA::Double z, CORBA::Double z,
SMESH::ElementType type); SMESH::ElementType type)
throw (SALOME::SALOME_Exception);
/*! /*!
* Return point state in a closed 2D mesh in terms of TopAbs_State enumeration. * Return point state in a closed 2D mesh in terms of TopAbs_State enumeration.
* TopAbs_UNKNOWN state means that either mesh is wrong or the analysis fails. * TopAbs_UNKNOWN state means that either mesh is wrong or the analysis fails.
*/ */
CORBA::Short GetPointState(CORBA::Double x, CORBA::Double y, CORBA::Double z); CORBA::Short GetPointState(CORBA::Double x, CORBA::Double y, CORBA::Double z)
throw (SALOME::SALOME_Exception);
SMESH::SMESH_MeshEditor::Sew_Error SMESH::SMESH_MeshEditor::Sew_Error
SewFreeBorders(CORBA::Long FirstNodeID1, SewFreeBorders(CORBA::Long FirstNodeID1,
@ -581,13 +682,15 @@ public:
CORBA::Long SecondNodeID2, CORBA::Long SecondNodeID2,
CORBA::Long LastNodeID2, CORBA::Long LastNodeID2,
CORBA::Boolean CreatePolygons, CORBA::Boolean CreatePolygons,
CORBA::Boolean CreatePolyedrs); CORBA::Boolean CreatePolyedrs)
throw (SALOME::SALOME_Exception);
SMESH::SMESH_MeshEditor::Sew_Error SMESH::SMESH_MeshEditor::Sew_Error
SewConformFreeBorders(CORBA::Long FirstNodeID1, SewConformFreeBorders(CORBA::Long FirstNodeID1,
CORBA::Long SecondNodeID1, CORBA::Long SecondNodeID1,
CORBA::Long LastNodeID1, CORBA::Long LastNodeID1,
CORBA::Long FirstNodeID2, CORBA::Long FirstNodeID2,
CORBA::Long SecondNodeID2); CORBA::Long SecondNodeID2)
throw (SALOME::SALOME_Exception);
SMESH::SMESH_MeshEditor::Sew_Error SMESH::SMESH_MeshEditor::Sew_Error
SewBorderToSide(CORBA::Long FirstNodeIDOnFreeBorder, SewBorderToSide(CORBA::Long FirstNodeIDOnFreeBorder,
CORBA::Long SecondNodeIDOnFreeBorder, CORBA::Long SecondNodeIDOnFreeBorder,
@ -595,30 +698,36 @@ public:
CORBA::Long FirstNodeIDOnSide, CORBA::Long FirstNodeIDOnSide,
CORBA::Long LastNodeIDOnSide, CORBA::Long LastNodeIDOnSide,
CORBA::Boolean CreatePolygons, CORBA::Boolean CreatePolygons,
CORBA::Boolean CreatePolyedrs); CORBA::Boolean CreatePolyedrs)
throw (SALOME::SALOME_Exception);
SMESH::SMESH_MeshEditor::Sew_Error SMESH::SMESH_MeshEditor::Sew_Error
SewSideElements(const SMESH::long_array& IDsOfSide1Elements, SewSideElements(const SMESH::long_array& IDsOfSide1Elements,
const SMESH::long_array& IDsOfSide2Elements, const SMESH::long_array& IDsOfSide2Elements,
CORBA::Long NodeID1OfSide1ToMerge, CORBA::Long NodeID1OfSide1ToMerge,
CORBA::Long NodeID1OfSide2ToMerge, CORBA::Long NodeID1OfSide2ToMerge,
CORBA::Long NodeID2OfSide1ToMerge, CORBA::Long NodeID2OfSide1ToMerge,
CORBA::Long NodeID2OfSide2ToMerge); CORBA::Long NodeID2OfSide2ToMerge)
throw (SALOME::SALOME_Exception);
/*! /*!
* Set new nodes for given element. * Set new nodes for given element.
* If number of nodes is not corresponded to type of * If number of nodes is not corresponded to type of
* element - returns false * element - returns false
*/ */
CORBA::Boolean ChangeElemNodes(CORBA::Long ide, const SMESH::long_array& newIDs); CORBA::Boolean ChangeElemNodes(CORBA::Long ide, const SMESH::long_array& newIDs)
throw (SALOME::SALOME_Exception);
CORBA::Boolean DoubleNodes( const SMESH::long_array& theNodes, CORBA::Boolean DoubleNodes( const SMESH::long_array& theNodes,
const SMESH::long_array& theModifiedElems ); const SMESH::long_array& theModifiedElems )
throw (SALOME::SALOME_Exception);
CORBA::Boolean DoubleNode( CORBA::Long theNodeId, CORBA::Boolean DoubleNode( CORBA::Long theNodeId,
const SMESH::long_array& theModifiedElems ); const SMESH::long_array& theModifiedElems )
throw (SALOME::SALOME_Exception);
CORBA::Boolean DoubleNodeGroup( SMESH::SMESH_GroupBase_ptr theNodes, CORBA::Boolean DoubleNodeGroup( SMESH::SMESH_GroupBase_ptr theNodes,
SMESH::SMESH_GroupBase_ptr theModifiedElems ); SMESH::SMESH_GroupBase_ptr theModifiedElems )
throw (SALOME::SALOME_Exception);
/*! /*!
* \brief Creates a hole in a mesh by doubling the nodes of some particular elements. * \brief Creates a hole in a mesh by doubling the nodes of some particular elements.
@ -629,13 +738,16 @@ public:
* \sa DoubleNodeGroup() * \sa DoubleNodeGroup()
*/ */
SMESH::SMESH_Group_ptr DoubleNodeGroupNew( SMESH::SMESH_GroupBase_ptr theNodes, SMESH::SMESH_Group_ptr DoubleNodeGroupNew( SMESH::SMESH_GroupBase_ptr theNodes,
SMESH::SMESH_GroupBase_ptr theModifiedElems ); SMESH::SMESH_GroupBase_ptr theModifiedElems )
throw (SALOME::SALOME_Exception);
CORBA::Boolean DoubleNodeGroups( const SMESH::ListOfGroups& theNodes, CORBA::Boolean DoubleNodeGroups( const SMESH::ListOfGroups& theNodes,
const SMESH::ListOfGroups& theModifiedElems ); const SMESH::ListOfGroups& theModifiedElems )
throw (SALOME::SALOME_Exception);
SMESH::SMESH_Group_ptr DoubleNodeGroupsNew( const SMESH::ListOfGroups& theNodes, SMESH::SMESH_Group_ptr DoubleNodeGroupsNew( const SMESH::ListOfGroups& theNodes,
const SMESH::ListOfGroups& theModifiedElems ); const SMESH::ListOfGroups& theModifiedElems )
throw (SALOME::SALOME_Exception);
/*! /*!
* \brief Creates a hole in a mesh by doubling the nodes of some particular elements * \brief Creates a hole in a mesh by doubling the nodes of some particular elements
@ -649,7 +761,8 @@ public:
*/ */
CORBA::Boolean DoubleNodeElem( const SMESH::long_array& theElems, CORBA::Boolean DoubleNodeElem( const SMESH::long_array& theElems,
const SMESH::long_array& theNodesNot, const SMESH::long_array& theNodesNot,
const SMESH::long_array& theAffectedElems ); const SMESH::long_array& theAffectedElems )
throw (SALOME::SALOME_Exception);
/*! /*!
* \brief Creates a hole in a mesh by doubling the nodes of some particular elements * \brief Creates a hole in a mesh by doubling the nodes of some particular elements
@ -664,7 +777,8 @@ public:
*/ */
CORBA::Boolean DoubleNodeElemInRegion( const SMESH::long_array& theElems, CORBA::Boolean DoubleNodeElemInRegion( const SMESH::long_array& theElems,
const SMESH::long_array& theNodesNot, const SMESH::long_array& theNodesNot,
GEOM::GEOM_Object_ptr theShape ); GEOM::GEOM_Object_ptr theShape )
throw (SALOME::SALOME_Exception);
/*! /*!
* \brief Creates a hole in a mesh by doubling the nodes of some particular elements * \brief Creates a hole in a mesh by doubling the nodes of some particular elements
@ -677,7 +791,8 @@ public:
*/ */
CORBA::Boolean DoubleNodeElemGroup( SMESH::SMESH_GroupBase_ptr theElems, CORBA::Boolean DoubleNodeElemGroup( SMESH::SMESH_GroupBase_ptr theElems,
SMESH::SMESH_GroupBase_ptr theNodesNot, SMESH::SMESH_GroupBase_ptr theNodesNot,
SMESH::SMESH_GroupBase_ptr theAffectedElems ); SMESH::SMESH_GroupBase_ptr theAffectedElems )
throw (SALOME::SALOME_Exception);
/*! /*!
* \brief Creates a hole in a mesh by doubling the nodes of some particular elements * \brief Creates a hole in a mesh by doubling the nodes of some particular elements
@ -691,13 +806,15 @@ public:
*/ */
SMESH::SMESH_Group_ptr DoubleNodeElemGroupNew( SMESH::SMESH_GroupBase_ptr theElems, SMESH::SMESH_Group_ptr DoubleNodeElemGroupNew( SMESH::SMESH_GroupBase_ptr theElems,
SMESH::SMESH_GroupBase_ptr theNodesNot, SMESH::SMESH_GroupBase_ptr theNodesNot,
SMESH::SMESH_GroupBase_ptr theAffectedElems ); SMESH::SMESH_GroupBase_ptr theAffectedElems )
throw (SALOME::SALOME_Exception);
SMESH::ListOfGroups* DoubleNodeElemGroup2New(SMESH::SMESH_GroupBase_ptr theElems, SMESH::ListOfGroups* DoubleNodeElemGroup2New(SMESH::SMESH_GroupBase_ptr theElems,
SMESH::SMESH_GroupBase_ptr theNodesNot, SMESH::SMESH_GroupBase_ptr theNodesNot,
SMESH::SMESH_GroupBase_ptr theAffectedElems, SMESH::SMESH_GroupBase_ptr theAffectedElems,
CORBA::Boolean theElemGroupNeeded, CORBA::Boolean theElemGroupNeeded,
CORBA::Boolean theNodeGroupNeeded); CORBA::Boolean theNodeGroupNeeded)
throw (SALOME::SALOME_Exception);
/*! /*!
* \brief Creates a hole in a mesh by doubling the nodes of some particular elements * \brief Creates a hole in a mesh by doubling the nodes of some particular elements
@ -711,7 +828,8 @@ public:
*/ */
CORBA::Boolean DoubleNodeElemGroupInRegion( SMESH::SMESH_GroupBase_ptr theElems, CORBA::Boolean DoubleNodeElemGroupInRegion( SMESH::SMESH_GroupBase_ptr theElems,
SMESH::SMESH_GroupBase_ptr theNodesNot, SMESH::SMESH_GroupBase_ptr theNodesNot,
GEOM::GEOM_Object_ptr theShape ); GEOM::GEOM_Object_ptr theShape )
throw (SALOME::SALOME_Exception);
/*! /*!
* \brief Creates a hole in a mesh by doubling the nodes of some particular elements * \brief Creates a hole in a mesh by doubling the nodes of some particular elements
@ -725,7 +843,8 @@ public:
*/ */
CORBA::Boolean DoubleNodeElemGroups( const SMESH::ListOfGroups& theElems, CORBA::Boolean DoubleNodeElemGroups( const SMESH::ListOfGroups& theElems,
const SMESH::ListOfGroups& theNodesNot, const SMESH::ListOfGroups& theNodesNot,
const SMESH::ListOfGroups& theAffectedElems ); const SMESH::ListOfGroups& theAffectedElems )
throw (SALOME::SALOME_Exception);
/*! /*!
* \brief Creates a hole in a mesh by doubling the nodes of some particular elements * \brief Creates a hole in a mesh by doubling the nodes of some particular elements
@ -739,13 +858,15 @@ public:
*/ */
SMESH::SMESH_Group_ptr DoubleNodeElemGroupsNew( const SMESH::ListOfGroups& theElems, SMESH::SMESH_Group_ptr DoubleNodeElemGroupsNew( const SMESH::ListOfGroups& theElems,
const SMESH::ListOfGroups& theNodesNot, const SMESH::ListOfGroups& theNodesNot,
const SMESH::ListOfGroups& theAffectedElems ); const SMESH::ListOfGroups& theAffectedElems )
throw (SALOME::SALOME_Exception);
SMESH::ListOfGroups* DoubleNodeElemGroups2New(const SMESH::ListOfGroups& theElems, SMESH::ListOfGroups* DoubleNodeElemGroups2New(const SMESH::ListOfGroups& theElems,
const SMESH::ListOfGroups& theNodesNot, const SMESH::ListOfGroups& theNodesNot,
const SMESH::ListOfGroups& theAffectedElems, const SMESH::ListOfGroups& theAffectedElems,
CORBA::Boolean theElemGroupNeeded, CORBA::Boolean theElemGroupNeeded,
CORBA::Boolean theNodeGroupNeeded); CORBA::Boolean theNodeGroupNeeded)
throw (SALOME::SALOME_Exception);
/*! /*!
* \brief Creates a hole in a mesh by doubling the nodes of some particular elements * \brief Creates a hole in a mesh by doubling the nodes of some particular elements
@ -760,7 +881,8 @@ public:
*/ */
CORBA::Boolean DoubleNodeElemGroupsInRegion( const SMESH::ListOfGroups& theElems, CORBA::Boolean DoubleNodeElemGroupsInRegion( const SMESH::ListOfGroups& theElems,
const SMESH::ListOfGroups& theNodesNot, const SMESH::ListOfGroups& theNodesNot,
GEOM::GEOM_Object_ptr theShape ); GEOM::GEOM_Object_ptr theShape )
throw (SALOME::SALOME_Exception);
/*! /*!
* \brief Identify the elements that will be affected by node duplication (actual duplication is not performed. * \brief Identify the elements that will be affected by node duplication (actual duplication is not performed.
@ -775,7 +897,8 @@ public:
*/ */
SMESH::ListOfGroups* AffectedElemGroupsInRegion( const SMESH::ListOfGroups& theElems, SMESH::ListOfGroups* AffectedElemGroupsInRegion( const SMESH::ListOfGroups& theElems,
const SMESH::ListOfGroups& theNodesNot, const SMESH::ListOfGroups& theNodesNot,
GEOM::GEOM_Object_ptr theShape ); GEOM::GEOM_Object_ptr theShape )
throw (SALOME::SALOME_Exception);
/*! /*!
* \brief Double nodes on shared faces between groups of volumes and create flat elements on demand. * \brief Double nodes on shared faces between groups of volumes and create flat elements on demand.
@ -799,7 +922,8 @@ public:
* @param theGroupsOfFaces - list of groups of faces * @param theGroupsOfFaces - list of groups of faces
* @return TRUE if operation has been completed successfully, FALSE otherwise * @return TRUE if operation has been completed successfully, FALSE otherwise
*/ */
CORBA::Boolean CreateFlatElementsOnFacesGroups( const SMESH::ListOfGroups& theGroupsOfFaces ); CORBA::Boolean CreateFlatElementsOnFacesGroups( const SMESH::ListOfGroups& theGroupsOfFaces )
throw (SALOME::SALOME_Exception);
/*! /*!
* \brief identify all the elements around a geom shape, get the faces delimiting the hole * \brief identify all the elements around a geom shape, get the faces delimiting the hole
@ -819,7 +943,8 @@ public:
* The created 2D mesh elements based on nodes of free faces of boundary volumes * The created 2D mesh elements based on nodes of free faces of boundary volumes
* \return TRUE if operation has been completed successfully, FALSE otherwise * \return TRUE if operation has been completed successfully, FALSE otherwise
*/ */
CORBA::Boolean Make2DMeshFrom3D(); CORBA::Boolean Make2DMeshFrom3D()
throw (SALOME::SALOME_Exception);
SMESH::SMESH_Mesh_ptr MakeBoundaryMesh(SMESH::SMESH_IDSource_ptr elements, SMESH::SMESH_Mesh_ptr MakeBoundaryMesh(SMESH::SMESH_IDSource_ptr elements,
SMESH::Bnd_Dimension dimension, SMESH::Bnd_Dimension dimension,
@ -827,7 +952,8 @@ public:
const char* meshName, const char* meshName,
CORBA::Boolean toCopyElements, CORBA::Boolean toCopyElements,
CORBA::Boolean toCopyMissingBondary, CORBA::Boolean toCopyMissingBondary,
SMESH::SMESH_Group_out group); SMESH::SMESH_Group_out group)
throw (SALOME::SALOME_Exception);
CORBA::Long MakeBoundaryElements(SMESH::Bnd_Dimension dimension, CORBA::Long MakeBoundaryElements(SMESH::Bnd_Dimension dimension,
const char* groupName, const char* groupName,
@ -846,11 +972,8 @@ private: //!< private methods
MeshEditor_I::TPreviewMesh * getPreviewMesh( SMDSAbs_ElementType previewType = SMDSAbs_All ); MeshEditor_I::TPreviewMesh * getPreviewMesh( SMDSAbs_ElementType previewType = SMDSAbs_All );
/*! void declareMeshModified( bool isReComputeSafe );
* \brief Update myLastCreated* or myPreviewData
* \param anEditor - it contains edition results
*/
//void storeResult(::SMESH_MeshEditor& anEditor);
/*! /*!
* \brief Clear myLastCreated* or myPreviewData * \brief Clear myLastCreated* or myPreviewData
*/ */
@ -859,7 +982,8 @@ private: //!< private methods
/*! /*!
* \brief Return groups by their IDs * \brief Return groups by their IDs
*/ */
SMESH::ListOfGroups* getGroups(const std::list<int>* groupIDs); SMESH::ListOfGroups* getGroups(const std::list<int>* groupIDs)
throw (SALOME::SALOME_Exception);
SMESH::ListOfGroups* rotationSweep(const SMESH::long_array & IDsOfElements, SMESH::ListOfGroups* rotationSweep(const SMESH::long_array & IDsOfElements,
const SMESH::AxisStruct & Axis, const SMESH::AxisStruct & Axis,
@ -867,18 +991,21 @@ private: //!< private methods
CORBA::Long NbOfSteps, CORBA::Long NbOfSteps,
CORBA::Double Tolerance, CORBA::Double Tolerance,
const bool MakeGroups, const bool MakeGroups,
const SMDSAbs_ElementType ElementType=SMDSAbs_All); const SMDSAbs_ElementType ElementType=SMDSAbs_All)
throw (SALOME::SALOME_Exception);
SMESH::ListOfGroups* extrusionSweep(const SMESH::long_array & IDsOfElements, SMESH::ListOfGroups* extrusionSweep(const SMESH::long_array & IDsOfElements,
const SMESH::DirStruct & StepVector, const SMESH::DirStruct & StepVector,
CORBA::Long NbOfSteps, CORBA::Long NbOfSteps,
bool MakeGroups, bool MakeGroups,
const SMDSAbs_ElementType ElementType=SMDSAbs_All); const SMDSAbs_ElementType ElementType=SMDSAbs_All)
throw (SALOME::SALOME_Exception);
SMESH::ListOfGroups* advancedExtrusion(const SMESH::long_array & theIDsOfElements, SMESH::ListOfGroups* advancedExtrusion(const SMESH::long_array & theIDsOfElements,
const SMESH::DirStruct & theStepVector, const SMESH::DirStruct & theStepVector,
CORBA::Long theNbOfSteps, CORBA::Long theNbOfSteps,
CORBA::Long theExtrFlags, CORBA::Long theExtrFlags,
CORBA::Double theSewTolerance, CORBA::Double theSewTolerance,
const bool MakeGroups); const bool MakeGroups)
throw (SALOME::SALOME_Exception);
SMESH::ListOfGroups* extrusionAlongPath(const SMESH::long_array & IDsOfElements, SMESH::ListOfGroups* extrusionAlongPath(const SMESH::long_array & IDsOfElements,
SMESH::SMESH_Mesh_ptr PathMesh, SMESH::SMESH_Mesh_ptr PathMesh,
GEOM::GEOM_Object_ptr PathShape, GEOM::GEOM_Object_ptr PathShape,
@ -889,7 +1016,8 @@ private: //!< private methods
const SMESH::PointStruct & RefPoint, const SMESH::PointStruct & RefPoint,
const bool MakeGroups, const bool MakeGroups,
SMESH::SMESH_MeshEditor::Extrusion_Error & Error, SMESH::SMESH_MeshEditor::Extrusion_Error & Error,
const SMDSAbs_ElementType ElementType=SMDSAbs_All); const SMDSAbs_ElementType ElementType=SMDSAbs_All)
throw (SALOME::SALOME_Exception);
SMESH::ListOfGroups* extrusionAlongPathX(const SMESH::long_array & IDsOfElements, SMESH::ListOfGroups* extrusionAlongPathX(const SMESH::long_array & IDsOfElements,
SMESH::SMESH_IDSource_ptr Path, SMESH::SMESH_IDSource_ptr Path,
CORBA::Long NodeStart, CORBA::Long NodeStart,
@ -900,35 +1028,45 @@ private: //!< private methods
const SMESH::PointStruct& RefPoint, const SMESH::PointStruct& RefPoint,
bool MakeGroups, bool MakeGroups,
const SMDSAbs_ElementType ElementType, const SMDSAbs_ElementType ElementType,
SMESH::SMESH_MeshEditor::Extrusion_Error & theError); SMESH::SMESH_MeshEditor::Extrusion_Error & theError)
throw (SALOME::SALOME_Exception);
SMESH::ListOfGroups* mirror(TIDSortedElemSet & IDsOfElements, SMESH::ListOfGroups* mirror(TIDSortedElemSet & IDsOfElements,
const SMESH::AxisStruct & Axis, const SMESH::AxisStruct & Axis,
SMESH::SMESH_MeshEditor::MirrorType MirrorType, SMESH::SMESH_MeshEditor::MirrorType MirrorType,
CORBA::Boolean Copy, CORBA::Boolean Copy,
bool MakeGroups, bool MakeGroups,
::SMESH_Mesh* TargetMesh=0); ::SMESH_Mesh* TargetMesh=0)
throw (SALOME::SALOME_Exception);
SMESH::ListOfGroups* translate(TIDSortedElemSet & IDsOfElements, SMESH::ListOfGroups* translate(TIDSortedElemSet & IDsOfElements,
const SMESH::DirStruct & Vector, const SMESH::DirStruct & Vector,
CORBA::Boolean Copy, CORBA::Boolean Copy,
bool MakeGroups, bool MakeGroups,
::SMESH_Mesh* TargetMesh=0); ::SMESH_Mesh* TargetMesh=0)
throw (SALOME::SALOME_Exception);
SMESH::ListOfGroups* rotate(TIDSortedElemSet & IDsOfElements, SMESH::ListOfGroups* rotate(TIDSortedElemSet & IDsOfElements,
const SMESH::AxisStruct & Axis, const SMESH::AxisStruct & Axis,
CORBA::Double Angle, CORBA::Double Angle,
CORBA::Boolean Copy, CORBA::Boolean Copy,
bool MakeGroups, bool MakeGroups,
::SMESH_Mesh* TargetMesh=0); ::SMESH_Mesh* TargetMesh=0)
throw (SALOME::SALOME_Exception);
SMESH::ListOfGroups* scale(SMESH::SMESH_IDSource_ptr theObject, SMESH::ListOfGroups* scale(SMESH::SMESH_IDSource_ptr theObject,
const SMESH::PointStruct& thePoint, const SMESH::PointStruct& thePoint,
const SMESH::double_array& theScaleFact, const SMESH::double_array& theScaleFact,
CORBA::Boolean theCopy, CORBA::Boolean theCopy,
bool theMakeGroups, bool theMakeGroups,
::SMESH_Mesh* theTargetMesh=0); ::SMESH_Mesh* theTargetMesh=0)
throw (SALOME::SALOME_Exception);
void convertToQuadratic(CORBA::Boolean theForce3d,
CORBA::Boolean theToBiQuad,
SMESH::SMESH_IDSource_ptr theObject = SMESH::SMESH_IDSource::_nil())
throw (SALOME::SALOME_Exception);
SMESH::SMESH_Mesh_ptr makeMesh(const char* theMeshName); SMESH::SMESH_Mesh_ptr makeMesh(const char* theMeshName);
void DumpGroupsList(SMESH::TPythonDump & theDumpPython, void dumpGroupsList(SMESH::TPythonDump & theDumpPython,
const SMESH::ListOfGroups * theGroupList); const SMESH::ListOfGroups * theGroupList);
string generateGroupName(const string& thePrefix); string generateGroupName(const string& thePrefix);

3
src/SMESH_I/SMESH_PythonDump.hxx
View File

@ -142,6 +142,9 @@ namespace SMESH
TPythonDump& TPythonDump&
operator<<(const SMESH::GeometryType& theArg); operator<<(const SMESH::GeometryType& theArg);
TPythonDump&
operator<<(const SMESH::EntityType& theArg);
TPythonDump& TPythonDump&
operator<<(const SMESH::long_array& theArg); operator<<(const SMESH::long_array& theArg);

32
src/SMESH_SWIG/smeshDC.py
View File

@ -737,6 +737,20 @@ class smeshDC(object, SMESH._objref_SMESH_Gen):
return None return None
pass pass
pass pass
elif CritType == FT_EntityType:
# Checks the Threshold
try:
aCriterion.Threshold = self.EnumToLong(aThreshold)
assert( aThreshold in SMESH.EntityType._items )
except:
if isinstance(aThreshold, int):
aCriterion.Threshold = aThreshold
else:
print "Error: The Threshold should be an integer or SMESH.EntityType."
return None
pass
pass
elif CritType == FT_GroupColor: elif CritType == FT_GroupColor:
# Checks the Threshold # Checks the Threshold
try: try:
@ -2221,7 +2235,7 @@ class Mesh:
def GetElemNbNodes(self, id): def GetElemNbNodes(self, id):
return self.mesh.GetElemNbNodes(id) return self.mesh.GetElemNbNodes(id)
## Returns the node ID the given index for the given element ## Returns the node ID the given (zero based) index for the given element
# \n If there is no element for the given ID - returns -1 # \n If there is no element for the given ID - returns -1
# \n If there is no node for the given index - returns -2 # \n If there is no node for the given index - returns -2
# @return an integer value # @return an integer value
@ -3062,19 +3076,23 @@ class Mesh:
return self.editor.SmoothParametricObject(theObject, IDsOfFixedNodes, return self.editor.SmoothParametricObject(theObject, IDsOfFixedNodes,
MaxNbOfIterations, MaxAspectRatio, Method) MaxNbOfIterations, MaxAspectRatio, Method)
## Converts the mesh to quadratic, deletes old elements, replacing ## Converts the mesh to quadratic or bi-quadratic, deletes old elements, replacing
# them with quadratic with the same id. # them with quadratic with the same id.
# @param theForce3d new node creation method: # @param theForce3d new node creation method:
# 0 - the medium node lies at the geometrical entity from which the mesh element is built # 0 - the medium node lies at the geometrical entity from which the mesh element is built
# 1 - the medium node lies at the middle of the line segments connecting start and end node of a mesh element # 1 - the medium node lies at the middle of the line segments connecting start and end node of a mesh element
# @param theSubMesh a group or a sub-mesh to convert; WARNING: in this case the mesh can become not conformal # @param theSubMesh a group or a sub-mesh to convert; WARNING: in this case the mesh can become not conformal
# @param theToBiQuad If True, converts the mesh to bi-quadratic
# @ingroup l2_modif_tofromqu # @ingroup l2_modif_tofromqu
def ConvertToQuadratic(self, theForce3d, theSubMesh=None): def ConvertToQuadratic(self, theForce3d, theSubMesh=None, theToBiQuad=False):
if theSubMesh: if theToBiQuad:
self.editor.ConvertToQuadraticObject(theForce3d,theSubMesh) self.editor.ConvertToBiQuadratic(theForce3d,theSubMesh)
else: else:
self.editor.ConvertToQuadratic(theForce3d) if theSubMesh:
self.editor.ConvertToQuadraticObject(theForce3d,theSubMesh)
else:
self.editor.ConvertToQuadratic(theForce3d)
## Converts the mesh from quadratic to ordinary, ## Converts the mesh from quadratic to ordinary,
# deletes old quadratic elements, \n replacing # deletes old quadratic elements, \n replacing
# them with ordinary mesh elements with the same id. # them with ordinary mesh elements with the same id.

65
src/StdMeshers/StdMeshers_MEFISTO_2D.cxx
View File

@ -770,6 +770,23 @@ void StdMeshers_MEFISTO_2D::ComputeScaleOnFace(SMESH_Mesh & aMesh,
ASSERT(scaley); ASSERT(scaley);
} }
// namespace
// {
// bool isDegenTria( const SMDS_MeshNode * nn[3] )
// {
// SMESH_TNodeXYZ p1( nn[0] );
// SMESH_TNodeXYZ p2( nn[1] );
// SMESH_TNodeXYZ p3( nn[2] );
// gp_XYZ vec1 = p2 - p1;
// gp_XYZ vec2 = p3 - p1;
// gp_XYZ cross = vec1 ^ vec2;
// const double eps = 1e-100;
// return ( fabs( cross.X() ) < eps &&
// fabs( cross.Y() ) < eps &&
// fabs( cross.Z() ) < eps );
// }
// }
//============================================================================= //=============================================================================
/*! /*!
* *
@ -780,12 +797,13 @@ void StdMeshers_MEFISTO_2D::StoreResult(Z nbst, R2 * uvst, Z nbt, Z * nust,
vector< const SMDS_MeshNode*>&mefistoToDS, vector< const SMDS_MeshNode*>&mefistoToDS,
double scalex, double scaley) double scalex, double scaley)
{ {
SMESHDS_Mesh * meshDS = _helper->GetMeshDS(); _helper->SetElementsOnShape( true );
int faceID = _helper->GetSubShapeID();
TopoDS_Face F = TopoDS::Face( _helper->GetSubShape() ); TopoDS_Face F = TopoDS::Face( _helper->GetSubShape() );
Handle(Geom_Surface) S = BRep_Tool::Surface( F ); Handle(Geom_Surface) S = BRep_Tool::Surface( F );
//const size_t nbInputNodes = mefistoToDS.size();
Z n = mefistoToDS.size(); // nb input points Z n = mefistoToDS.size(); // nb input points
mefistoToDS.resize( nbst ); mefistoToDS.resize( nbst );
for ( ; n < nbst; n++) for ( ; n < nbst; n++)
@ -796,12 +814,7 @@ void StdMeshers_MEFISTO_2D::StoreResult(Z nbst, R2 * uvst, Z nbt, Z * nust,
double v = uvst[n][1] / scaley; double v = uvst[n][1] / scaley;
gp_Pnt P = S->Value(u, v); gp_Pnt P = S->Value(u, v);
SMDS_MeshNode * node = meshDS->AddNode(P.X(), P.Y(), P.Z()); mefistoToDS[n] = _helper->AddNode( P.X(), P.Y(), P.Z(), 0, u, v );
meshDS->SetNodeOnFace(node, faceID, u, v);
//MESSAGE(P.X()<<" "<<P.Y()<<" "<<P.Z());
mefistoToDS[n] = node;
//MESSAGE("NEW: "<<n<<" "<<mefistoToDS[n+1]);
} }
} }
@ -810,26 +823,32 @@ void StdMeshers_MEFISTO_2D::StoreResult(Z nbst, R2 * uvst, Z nbt, Z * nust,
// triangle points must be in trigonometric order if face is Forward // triangle points must be in trigonometric order if face is Forward
// else they must be put clockwise // else they must be put clockwise
bool triangleIsWellOriented = ( F.Orientation() == TopAbs_FORWARD ); int i1 = 1, i2 = 2;
if ( F.Orientation() != TopAbs_FORWARD )
std::swap( i1, i2 );
const SMDS_MeshNode * nn[3];
for (n = 1; n <= nbt; n++) for (n = 1; n <= nbt; n++)
{ {
const SMDS_MeshNode * n1 = mefistoToDS[ nust[m++] - 1 ]; // const bool allNodesAreOld = ( nust[m + 0] <= nbInputNodes &&
const SMDS_MeshNode * n2 = mefistoToDS[ nust[m++] - 1 ]; // nust[m + 1] <= nbInputNodes &&
const SMDS_MeshNode * n3 = mefistoToDS[ nust[m++] - 1 ]; // nust[m + 2] <= nbInputNodes );
nn[ 0 ] = mefistoToDS[ nust[m++] - 1 ];
nn[ 1 ] = mefistoToDS[ nust[m++] - 1 ];
nn[ 2 ] = mefistoToDS[ nust[m++] - 1 ];
m++;
// avoid creating degenetrated faces // avoid creating degenetrated faces
bool isDegen = ( _helper->HasDegeneratedEdges() && ( n1 == n2 || n1 == n3 || n2 == n3 )); bool isDegen = ( _helper->HasDegeneratedEdges() &&
( nn[0] == nn[1] || nn[1] == nn[2] || nn[2] == nn[0] ));
// It was an attemp to fix a problem of a zero area face whose all nodes
// are on one staight EDGE. But omitting this face makes a hole in the mesh :(
// if ( !isDegen && allNodesAreOld )
// isDegen = isDegenTria( nn );
if ( !isDegen ) if ( !isDegen )
{ _helper->AddFace( nn[0], nn[i1], nn[i2] );
SMDS_MeshElement * elt;
if (triangleIsWellOriented)
elt = _helper->AddFace(n1, n2, n3);
else
elt = _helper->AddFace(n1, n3, n2);
meshDS->SetMeshElementOnShape(elt, faceID);
}
m++;
} }
// remove bad elements built on vertices shared by wires // remove bad elements built on vertices shared by wires
@ -849,7 +868,7 @@ void StdMeshers_MEFISTO_2D::StoreResult(Z nbst, R2 * uvst, Z nbt, Z * nust,
nbSame++; nbSame++;
if (nbSame > 1) { if (nbSame > 1) {
MESSAGE( "RM bad element " << elem->GetID()); MESSAGE( "RM bad element " << elem->GetID());
meshDS->RemoveElement( elem ); _helper->GetMeshDS()->RemoveElement( elem );
} }
} }
} }

8
src/StdMeshers/StdMeshers_Prism_3D.cxx
View File

@ -1142,7 +1142,7 @@ bool StdMeshers_Prism_3D::computeWalls(const Prism_3D::TPrismTopo& thePrism)
} }
continue; continue;
} }
// Compute // Compute 'vertical projection'
if ( nbTgtMeshed == 0 ) if ( nbTgtMeshed == 0 )
{ {
// compute nodes on target VERTEXes // compute nodes on target VERTEXes
@ -2195,8 +2195,10 @@ bool StdMeshers_PrismAsBlock::Init(SMESH_MesherHelper* helper,
{ {
if ( len2edgeMap.size() != nbEdges ) if ( len2edgeMap.size() != nbEdges )
RETURN_BAD_RESULT("Uniqueness of edge lengths not assured"); RETURN_BAD_RESULT("Uniqueness of edge lengths not assured");
map< double, int >::reverse_iterator maxLen_i = len2edgeMap.rbegin();
map< double, int >::reverse_iterator midLen_i = ++len2edgeMap.rbegin(); multimap< double, int >::reverse_iterator maxLen_i = len2edgeMap.rbegin();
multimap< double, int >::reverse_iterator midLen_i = ++len2edgeMap.rbegin();
double maxLen = maxLen_i->first; double maxLen = maxLen_i->first;
double midLen = ( len2edgeMap.size() == 1 ) ? 0 : midLen_i->first; double midLen = ( len2edgeMap.size() == 1 ) ? 0 : midLen_i->first;
switch ( nbEdges ) { switch ( nbEdges ) {

2
src/StdMeshers/StdMeshers_Projection_2D.cxx
View File

@ -1144,7 +1144,7 @@ bool StdMeshers_Projection_2D::Compute(SMESH_Mesh& theMesh, const TopoDS_Shape&
while ( faceIt->more() ) while ( faceIt->more() )
tgtFaces.insert( tgtFaces.end(), faceIt->next() ); tgtFaces.insert( tgtFaces.end(), faceIt->next() );
editor.ConvertToQuadratic(/*theForce3d=*/false, tgtFaces); editor.ConvertToQuadratic(/*theForce3d=*/false, tgtFaces, false);
} }
cleaner.Release(); // not to remove mesh cleaner.Release(); // not to remove mesh