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
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:
@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

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>.
Quadratic Edge is not a straight but a broken line and can be defined
by three points: first, middle and last. All more complex \b Quadratic
\b Elements differ from ordinary ones in that they consist of Quadratic
Edges.
Quadratic elements are defined by same corner nodes as the
corresponding linear ones, and in addition they bear \a midside nodes
located between the corner nodes on element sides.
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>
<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
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
<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
\n This functionality allows transforming standard meshes (or
sub-meshes) to quadratic and vice versa.
See \ref adding_quadratic_elements_page "Adding quadratic elements"
for more information about quadratic meshes.
Note that conversion of a sub-mesh most probably will
produce a non-conformal mesh. Elements on the boundary between
quadratic and linear sub-meshes become (or remain) quadratic.
\n This functionality allows transforming linear meshes (or
sub-meshes) to quadratic and vice versa.
Note that conversion of a sub-mesh most probably will 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>
<ol>
@ -18,8 +19,10 @@ Viewer.</li>
Mesh item </b>, or click <em>"Convert to/from quadratic"</em> button in the
toolbar.
<center>
\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:
@ -29,18 +32,20 @@ The following dialog box will appear:
<li>In this dialog box specify:
<ul>
<li>if it is necessary to convert a standard mesh to quadratic or a quadratic
mesh to standard. Note that the choice is available only if the selected mesh
(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
<li>If it is necessary to convert a linear mesh to quadratic or a quadratic
mesh to linear. **Convert to bi-quadratic** option means same as
**Convert to quadratic** except that QUAD9 elements are created
instead of QUAD8, and HEXA27 elements are created instead of
HEXA20. Note that the choice is available only if the selected mesh
(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
quadratic provided that the mesh is based on a geometry (not imported from file).</li>
</ul>
\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
<center>Quadratic mesh</center>

12
idl/SMESH_Filter.idl
View File

@ -75,6 +75,7 @@ module SMESH
FT_LinearOrQuadratic,
FT_GroupColor,
FT_ElemGeomType,
FT_EntityType,
FT_CoplanarFaces,
FT_BallDiameter,
FT_LessThan,
@ -422,6 +423,15 @@ module SMESH
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"
* Returns true if a mesh face is a coplanar neighbour to a given one. It checks
@ -543,7 +553,6 @@ module SMESH
MultiConnection CreateMultiConnection();
MultiConnection2D CreateMultiConnection2D();
BallDiameter CreateBallDiameter();
/*!
* Create logical functors ( predicates )
*/
@ -575,6 +584,7 @@ module SMESH
GroupColor CreateGroupColor();
ElemGeomType CreateElemGeomType();
ElemEntityType CreateElemEntityType();
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
* 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
* created this method returns list of their IDs, if new nodes
* not created - returns empty list
*/
long_array GetLastCreatedNodes();
long_array GetLastCreatedNodes() raises (SALOME::SALOME_Exception);
/*!
* If during last operation of MeshEditor some elements were
* created this method returns list of their IDs, if new elements
* 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
*/
ComputeError GetLastError();
ComputeError GetLastError() raises (SALOME::SALOME_Exception);
/*!
* \brief Wrap a sequence of ids in a SMESH_IDSource
@ -75,20 +75,20 @@ module SMESH
* \param IDsOfElements list of mesh elements identifiers
* \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.
* \param IDsOfNodes list of mesh nodes identifiers
* \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.
* \return number of removed nodes
*/
long RemoveOrphanNodes();
long RemoveOrphanNodes() raises (SALOME::SALOME_Exception);
/*!
* \brief Add a new node.
@ -97,19 +97,19 @@ module SMESH
* \param z Z coordinate 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.
* \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.
* \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
@ -119,7 +119,7 @@ module SMESH
* 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.
*/
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
@ -129,9 +129,9 @@ module SMESH
* 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.
*/
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
@ -141,7 +141,7 @@ module SMESH
* 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.
*/
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.
@ -150,14 +150,14 @@ module SMESH
* gives quantity of nodes in face number i.
*/
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.
* \param IdsOfFaces List of face IDs for volume creation.
* \note The created volume will refer only to nodes
* 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
@ -212,15 +212,20 @@ module SMESH
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.
* \param the2Dgroup - the mesh or its part to reorient
@ -245,7 +250,7 @@ module SMESH
*/
boolean TriToQuad (in long_array IDsOfElements,
in NumericalFunctor Criterion,
in double MaxAngle);
in double MaxAngle) raises (SALOME::SALOME_Exception);
/*!
* \brief Fuse neighbour triangles into quadrangles.
@ -254,7 +259,7 @@ module SMESH
*/
boolean TriToQuadObject (in SMESH_IDSource theObject,
in NumericalFunctor Criterion,
in double MaxAngle);
in double MaxAngle) raises (SALOME::SALOME_Exception);
/*!
* \brief Split quadrangles into triangles.
@ -263,7 +268,7 @@ module SMESH
* \return TRUE in case of success, FALSE otherwise.
*/
boolean QuadToTri (in long_array IDsOfElements,
in NumericalFunctor Criterion);
in NumericalFunctor Criterion) raises (SALOME::SALOME_Exception);
/*!
* \brief Split quadrangles into triangles.
@ -271,7 +276,7 @@ module SMESH
* Behaves like the above method, taking list of elements from \a theObject
*/
boolean QuadToTriObject (in SMESH_IDSource theObject,
in NumericalFunctor Criterion);
in NumericalFunctor Criterion) raises (SALOME::SALOME_Exception);
/*!
* \brief Split quadrangles into triangles.
@ -280,7 +285,7 @@ module SMESH
* \return TRUE in case of success, FALSE otherwise.
*/
boolean SplitQuad (in long_array IDsOfElements,
in boolean Diag13);
in boolean Diag13) raises (SALOME::SALOME_Exception);
/*!
* \brief Split quadrangles into triangles.
@ -288,7 +293,7 @@ module SMESH
* Behaves like the above method, taking list of elements from \a theObject
*/
boolean SplitQuadObject (in SMESH_IDSource theObject,
in boolean Diag13);
in boolean Diag13) raises (SALOME::SALOME_Exception);
/*!
* Find better splitting of the given quadrangle.
@ -298,7 +303,7 @@ module SMESH
* diagonal is better, 0 if error occurs.
*/
long BestSplit (in long IDOfQuad,
in NumericalFunctor Criterion);
in NumericalFunctor Criterion) raises (SALOME::SALOME_Exception);
/*!
* \brief Split volumic elements into tetrahedrons
@ -318,40 +323,44 @@ module SMESH
in long_array IDsOfFixedNodes,
in long MaxNbOfIterations,
in double MaxAspectRatio,
in Smooth_Method Method);
in Smooth_Method Method) raises (SALOME::SALOME_Exception);
boolean SmoothObject(in SMESH_IDSource theObject,
in long_array IDsOfFixedNodes,
in long MaxNbOfIterations,
in double MaxAspectRatio,
in Smooth_Method Method);
in Smooth_Method Method) raises (SALOME::SALOME_Exception);
boolean SmoothParametric(in long_array IDsOfElements,
in long_array IDsOfFixedNodes,
in long MaxNbOfIterations,
in double MaxAspectRatio,
in Smooth_Method Method);
in Smooth_Method Method) raises (SALOME::SALOME_Exception);
boolean SmoothParametricObject(in SMESH_IDSource theObject,
in long_array IDsOfFixedNodes,
in long MaxNbOfIterations,
in double MaxAspectRatio,
in Smooth_Method Method);
void ConvertToQuadratic(in boolean theForce3d);
boolean ConvertFromQuadratic();
in Smooth_Method Method) raises (SALOME::SALOME_Exception);
void ConvertToQuadratic(in boolean theForce3d)
raises (SALOME::SALOME_Exception);
void ConvertToQuadraticObject(in boolean theForce3d,
in SMESH_IDSource theObject)
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);
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
@ -364,7 +373,8 @@ module SMESH
in AxisStruct Axix,
in double AngleInRadians,
in long NbOfSteps,
in double Tolerance);
in double Tolerance)
raises (SALOME::SALOME_Exception);
/*!
* \brief Same as previous but additionally create groups of elements
* generated from elements belonging to preexisting groups
@ -373,7 +383,8 @@ module SMESH
in AxisStruct Axix,
in double AngleInRadians,
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
* \param theObject - object containing elements to ratate
@ -385,7 +396,8 @@ module SMESH
in AxisStruct Axix,
in double AngleInRadians,
in long NbOfSteps,
in double Tolerance);
in double Tolerance)
raises (SALOME::SALOME_Exception);
/*!
* \brief Same as previous but additionally create groups of elements
* generated from elements belonging to preexisting groups
@ -394,7 +406,8 @@ module SMESH
in AxisStruct Axix,
in double AngleInRadians,
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
* \param theObject - object containing elements to ratate
@ -406,7 +419,8 @@ module SMESH
in AxisStruct Axix,
in double AngleInRadians,
in long NbOfSteps,
in double Tolerance);
in double Tolerance)
raises (SALOME::SALOME_Exception);
/*!
* \brief Same as previous but additionally create groups of elements
* generated from elements belonging to preexisting groups
@ -415,7 +429,8 @@ module SMESH
in AxisStruct Axix,
in double AngleInRadians,
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
* \param theObject - object containing elements to ratate
@ -427,7 +442,8 @@ module SMESH
in AxisStruct Axix,
in double AngleInRadians,
in long NbOfSteps,
in double Tolerance);
in double Tolerance)
raises (SALOME::SALOME_Exception);
/*!
* \brief Same as previous but additionally create groups of elements
* generated from elements belonging to preexisting groups
@ -436,7 +452,8 @@ module SMESH
in AxisStruct Axix,
in double AngleInRadians,
in long NbOfSteps,
in double Tolerance);
in double Tolerance)
raises (SALOME::SALOME_Exception);
/*!
* \brief Genarate dim+1 elements by extrusion of elements along vector
* \param IDsOfElements - elements to sweep
@ -445,7 +462,8 @@ module SMESH
*/
void ExtrusionSweep(in long_array IDsOfElements,
in DirStruct StepVector,
in long NbOfSteps);
in long NbOfSteps)
raises (SALOME::SALOME_Exception);
/*!
* \brief Genarate dim+1 elements by extrusion of elements along vector
* \param IDsOfElements - elements to sweep
@ -454,20 +472,23 @@ module SMESH
*/
void ExtrusionSweep0D(in long_array IDsOfElements,
in DirStruct StepVector,
in long NbOfSteps);
in long NbOfSteps)
raises (SALOME::SALOME_Exception);
/*!
* \brief Same as previous but additionally create groups of elements
* generated from elements belonging to preexisting groups
*/
ListOfGroups ExtrusionSweepMakeGroups(in long_array IDsOfElements,
in DirStruct StepVector,
in long NbOfSteps);
in long NbOfSteps)
raises (SALOME::SALOME_Exception);
/*!
* \brief Same as previous but elements are nodes
*/
ListOfGroups ExtrusionSweepMakeGroups0D(in long_array IDsOfElements,
in DirStruct StepVector,
in long NbOfSteps);
in long NbOfSteps)
raises (SALOME::SALOME_Exception);
/*!
* Generate new elements by extrusion of theElements
* by StepVector by NbOfSteps
@ -479,7 +500,8 @@ module SMESH
in DirStruct StepVector,
in long NbOfSteps,
in long ExtrFlags,
in double SewTolerance);
in double SewTolerance)
raises (SALOME::SALOME_Exception);
/*!
* \brief Same as previous but additionally create groups of elements
* generated from elements belonging to preexisting groups
@ -488,35 +510,44 @@ module SMESH
in DirStruct StepVector,
in long NbOfSteps,
in long ExtrFlags,
in double SewTolerance);
in double SewTolerance)
raises (SALOME::SALOME_Exception);
void ExtrusionSweepObject(in SMESH_IDSource theObject,
in DirStruct StepVector,
in long NbOfSteps);
in long NbOfSteps)
raises (SALOME::SALOME_Exception);
ListOfGroups ExtrusionSweepObjectMakeGroups(in SMESH_IDSource theObject,
in DirStruct StepVector,
in long NbOfSteps);
in long NbOfSteps)
raises (SALOME::SALOME_Exception);
void ExtrusionSweepObject0D(in SMESH_IDSource theObject,
in DirStruct StepVector,
in long NbOfSteps);
in long NbOfSteps)
raises (SALOME::SALOME_Exception);
ListOfGroups ExtrusionSweepObject0DMakeGroups(in SMESH_IDSource theObject,
in DirStruct StepVector,
in long NbOfSteps);
in long NbOfSteps)
raises (SALOME::SALOME_Exception);
void ExtrusionSweepObject1D(in SMESH_IDSource theObject,
in DirStruct StepVector,
in long NbOfSteps);
in long NbOfSteps)
raises (SALOME::SALOME_Exception);
ListOfGroups ExtrusionSweepObject1DMakeGroups(in SMESH_IDSource theObject,
in DirStruct StepVector,
in long NbOfSteps);
in long NbOfSteps)
raises (SALOME::SALOME_Exception);
void ExtrusionSweepObject2D(in SMESH_IDSource theObject,
in DirStruct StepVector,
in long NbOfSteps);
in long NbOfSteps)
raises (SALOME::SALOME_Exception);
ListOfGroups ExtrusionSweepObject2DMakeGroups(in SMESH_IDSource theObject,
in DirStruct StepVector,
in long NbOfSteps);
in long NbOfSteps)
raises (SALOME::SALOME_Exception);
enum Extrusion_Error {
EXTR_OK,
@ -538,7 +569,8 @@ module SMESH
in PointStruct RefPoint,
in boolean MakeGroups,
in ElementType ElemType,
out Extrusion_Error Error);
out Extrusion_Error Error)
raises (SALOME::SALOME_Exception);
ListOfGroups ExtrusionAlongPathObjX(in SMESH_IDSource theObject,
in SMESH_IDSource Path,
@ -550,7 +582,8 @@ module SMESH
in PointStruct RefPoint,
in boolean MakeGroups,
in ElementType ElemType,
out Extrusion_Error Error);
out Extrusion_Error Error)
raises (SALOME::SALOME_Exception);
Extrusion_Error ExtrusionAlongPath(in long_array IDsOfElements,
in SMESH_Mesh PathMesh,
@ -559,7 +592,8 @@ module SMESH
in boolean HasAngles,
in double_array Angles,
in boolean HasRefPoint,
in PointStruct RefPoint);
in PointStruct RefPoint)
raises (SALOME::SALOME_Exception);
ListOfGroups ExtrusionAlongPathMakeGroups(in long_array IDsOfElements,
in SMESH_Mesh PathMesh,
in GEOM::GEOM_Object PathShape,
@ -568,7 +602,8 @@ module SMESH
in double_array Angles,
in boolean HasRefPoint,
in PointStruct RefPoint,
out Extrusion_Error Error);
out Extrusion_Error Error)
raises (SALOME::SALOME_Exception);
Extrusion_Error ExtrusionAlongPathObject(in SMESH_IDSource theObject,
in SMESH_Mesh PathMesh,
@ -577,7 +612,8 @@ module SMESH
in boolean HasAngles,
in double_array Angles,
in boolean HasRefPoint,
in PointStruct RefPoint);
in PointStruct RefPoint)
raises (SALOME::SALOME_Exception);
ListOfGroups ExtrusionAlongPathObjectMakeGroups(in SMESH_IDSource theObject,
in SMESH_Mesh PathMesh,
in GEOM::GEOM_Object PathShape,
@ -586,7 +622,8 @@ module SMESH
in double_array Angles,
in boolean HasRefPoint,
in PointStruct RefPoint,
out Extrusion_Error Error);
out Extrusion_Error Error)
raises (SALOME::SALOME_Exception);
Extrusion_Error ExtrusionAlongPathObject1D(in SMESH_IDSource theObject,
in SMESH_Mesh PathMesh,
@ -595,7 +632,8 @@ module SMESH
in boolean HasAngles,
in double_array Angles,
in boolean HasRefPoint,
in PointStruct RefPoint);
in PointStruct RefPoint)
raises (SALOME::SALOME_Exception);
ListOfGroups ExtrusionAlongPathObject1DMakeGroups(in SMESH_IDSource theObject,
in SMESH_Mesh PathMesh,
in GEOM::GEOM_Object PathShape,
@ -604,7 +642,8 @@ module SMESH
in double_array Angles,
in boolean HasRefPoint,
in PointStruct RefPoint,
out Extrusion_Error Error);
out Extrusion_Error Error)
raises (SALOME::SALOME_Exception);
Extrusion_Error ExtrusionAlongPathObject2D(in SMESH_IDSource theObject,
in SMESH_Mesh PathMesh,
@ -613,7 +652,8 @@ module SMESH
in boolean HasAngles,
in double_array Angles,
in boolean HasRefPoint,
in PointStruct RefPoint);
in PointStruct RefPoint)
raises (SALOME::SALOME_Exception);
ListOfGroups ExtrusionAlongPathObject2DMakeGroups(in SMESH_IDSource theObject,
in SMESH_Mesh PathMesh,
in GEOM::GEOM_Object PathShape,
@ -622,7 +662,8 @@ module SMESH
in double_array Angles,
in boolean HasRefPoint,
in PointStruct RefPoint,
out Extrusion_Error Error);
out Extrusion_Error Error)
raises (SALOME::SALOME_Exception);
/*!
* Compute rotation angles for ExtrusionAlongPath as linear variation
@ -641,101 +682,126 @@ module SMESH
void Mirror (in long_array IDsOfElements,
in AxisStruct Mirror,
in MirrorType Type,
in boolean Copy);
in boolean Copy)
raises (SALOME::SALOME_Exception);
ListOfGroups MirrorMakeGroups (in long_array IDsOfElements,
in AxisStruct Mirror,
in MirrorType Type);
in MirrorType Type)
raises (SALOME::SALOME_Exception);
SMESH_Mesh MirrorMakeMesh (in long_array IDsOfElements,
in AxisStruct Mirror,
in MirrorType Type,
in boolean CopyGroups,
in string MeshName);
in string MeshName)
raises (SALOME::SALOME_Exception);
void MirrorObject (in SMESH_IDSource theObject,
in AxisStruct Mirror,
in MirrorType Type,
in boolean Copy);
in boolean Copy)
raises (SALOME::SALOME_Exception);
ListOfGroups MirrorObjectMakeGroups (in SMESH_IDSource theObject,
in AxisStruct Mirror,
in MirrorType Type);
in MirrorType Type)
raises (SALOME::SALOME_Exception);
SMESH_Mesh MirrorObjectMakeMesh (in SMESH_IDSource theObject,
in AxisStruct Mirror,
in MirrorType Type,
in boolean CopyGroups,
in string MeshName);
in string MeshName)
raises (SALOME::SALOME_Exception);
void Translate (in long_array IDsOfElements,
in DirStruct Vector,
in boolean Copy);
in boolean Copy)
raises (SALOME::SALOME_Exception);
ListOfGroups TranslateMakeGroups (in long_array IDsOfElements,
in DirStruct Vector);
in DirStruct Vector)
raises (SALOME::SALOME_Exception);
SMESH_Mesh TranslateMakeMesh (in long_array IDsOfElements,
in DirStruct Vector,
in boolean CopyGroups,
in string MeshName);
in string MeshName)
raises (SALOME::SALOME_Exception);
void TranslateObject (in SMESH_IDSource theObject,
in DirStruct Vector,
in boolean Copy);
in boolean Copy)
raises (SALOME::SALOME_Exception);
ListOfGroups TranslateObjectMakeGroups (in SMESH_IDSource theObject,
in DirStruct Vector);
in DirStruct Vector)
raises (SALOME::SALOME_Exception);
SMESH_Mesh TranslateObjectMakeMesh (in SMESH_IDSource theObject,
in DirStruct Vector,
in boolean CopyGroups,
in string MeshName);
in string MeshName)
raises (SALOME::SALOME_Exception);
void Scale (in SMESH_IDSource theObject,
in PointStruct thePoint,
in double_array theScaleFact,
in boolean Copy);
in boolean Copy)
raises (SALOME::SALOME_Exception);
ListOfGroups ScaleMakeGroups (in SMESH_IDSource theObject,
in PointStruct thePoint,
in double_array theScaleFact);
in double_array theScaleFact)
raises (SALOME::SALOME_Exception);
SMESH_Mesh ScaleMakeMesh (in SMESH_IDSource theObject,
in PointStruct thePoint,
in double_array theScaleFact,
in boolean CopyGroups,
in string MeshName);
in string MeshName)
raises (SALOME::SALOME_Exception);
void Rotate (in long_array IDsOfElements,
in AxisStruct Axis,
in double AngleInRadians,
in boolean Copy);
in boolean Copy)
raises (SALOME::SALOME_Exception);
ListOfGroups RotateMakeGroups (in long_array IDsOfElements,
in AxisStruct Axis,
in double AngleInRadians);
in double AngleInRadians)
raises (SALOME::SALOME_Exception);
SMESH_Mesh RotateMakeMesh (in long_array IDsOfElements,
in AxisStruct Axis,
in double AngleInRadians,
in boolean CopyGroups,
in string MeshName);
in string MeshName)
raises (SALOME::SALOME_Exception);
void RotateObject (in SMESH_IDSource theObject,
in AxisStruct Axis,
in double AngleInRadians,
in boolean Copy);
in boolean Copy)
raises (SALOME::SALOME_Exception);
ListOfGroups RotateObjectMakeGroups (in SMESH_IDSource theObject,
in AxisStruct Axis,
in double AngleInRadians);
in double AngleInRadians)
raises (SALOME::SALOME_Exception);
SMESH_Mesh RotateObjectMakeMesh (in SMESH_IDSource theObject,
in AxisStruct Axis,
in double AngleInRadians,
in boolean CopyGroups,
in string MeshName);
in string MeshName)
raises (SALOME::SALOME_Exception);
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,
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,
in double Tolerance,
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.
@ -743,36 +809,42 @@ module SMESH
* \return List of groups of equal elements.
*/
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.
* \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.
*/
void MergeEqualElements();
void MergeEqualElements()
raises (SALOME::SALOME_Exception);
/*!
* 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
*/
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
*/
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.
*
* '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
@ -782,13 +854,15 @@ module SMESH
*/
long_array FindAmongElementsByPoint(in SMESH_IDSource elements,
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.
* 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 {
SEW_OK,
@ -811,13 +885,15 @@ module SMESH
in long SecondNodeID2,
in long LastNodeID2,
in boolean CreatePolygons,
in boolean CreatePolyedrs);
in boolean CreatePolyedrs)
raises (SALOME::SALOME_Exception);
Sew_Error SewConformFreeBorders (in long FirstNodeID1,
in long SecondNodeID1,
in long LastNodeID1,
in long FirstNodeID2,
in long SecondNodeID2);
in long SecondNodeID2)
raises (SALOME::SALOME_Exception);
Sew_Error SewBorderToSide (in long FirstNodeIDOnFreeBorder,
in long SecondNodeIDOnFreeBorder,
@ -825,21 +901,24 @@ module SMESH
in long FirstNodeIDOnSide,
in long LastNodeIDOnSide,
in boolean CreatePolygons,
in boolean CreatePolyedrs);
in boolean CreatePolyedrs)
raises (SALOME::SALOME_Exception);
Sew_Error SewSideElements (in long_array IDsOfSide1Elements,
in long_array IDsOfSide2Elements,
in long NodeID1OfSide1ToMerge,
in long NodeID1OfSide2ToMerge,
in long NodeID2OfSide1ToMerge,
in long NodeID2OfSide2ToMerge);
in long NodeID2OfSide2ToMerge)
raises (SALOME::SALOME_Exception);
/*!
* Set new nodes for given element.
* If number of nodes is not corresponded to type of
* 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
@ -850,7 +929,8 @@ module SMESH
* \return TRUE if operation has been completed successfully, FALSE otherwise
* \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
@ -860,7 +940,8 @@ module SMESH
* \return TRUE if operation has been completed successfully, FALSE otherwise
* \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
@ -871,7 +952,8 @@ module SMESH
* \sa DoubleNode(), DoubleNodes(), DoubleNodeGroups(), DoubleNodeGroupNew()
*/
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.
* Works as DoubleNodeGroup() described above, but returns a new group with
@ -882,7 +964,8 @@ module SMESH
* \sa DoubleNodeGroup()
*/
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
@ -893,7 +976,8 @@ module SMESH
* \sa DoubleNode(), DoubleNodeGroup(), DoubleNodes()
*/
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
* Works as DoubleNodeGroups() described above, but returns a new group with
@ -904,7 +988,8 @@ module SMESH
* \sa DoubleNodeGroups()
*/
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
@ -918,7 +1003,8 @@ module SMESH
*/
boolean DoubleNodeElem( in long_array theElems,
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
@ -933,7 +1019,8 @@ module SMESH
*/
boolean DoubleNodeElemInRegion( in long_array theElems,
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
@ -947,7 +1034,8 @@ module SMESH
*/
boolean DoubleNodeElemGroup( in SMESH_GroupBase theElems,
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.
* Works as DoubleNodeElemGroup() described above, but returns a new group with
@ -961,7 +1049,8 @@ module SMESH
*/
SMESH_Group DoubleNodeElemGroupNew( in SMESH_GroupBase theElems,
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.
* Works as DoubleNodeElemGroup() described above, but returns two new groups:
@ -979,7 +1068,8 @@ module SMESH
in SMESH_GroupBase theNodesNot,
in SMESH_GroupBase theAffectedElems,
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
@ -994,7 +1084,8 @@ module SMESH
*/
boolean DoubleNodeElemGroupInRegion( in SMESH_GroupBase theElems,
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
@ -1008,7 +1099,8 @@ module SMESH
*/
boolean DoubleNodeElemGroups( in ListOfGroups theElems,
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.
* Works as DoubleNodeElemGroups() described above, but returns a new group with
@ -1022,7 +1114,8 @@ module SMESH
*/
SMESH_Group DoubleNodeElemGroupsNew( in ListOfGroups theElems,
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.
* Works as DoubleNodeElemGroups() described above, but returns two new groups:
@ -1040,7 +1133,8 @@ module SMESH
in ListOfGroups theNodesNot,
in ListOfGroups theAffectedElems,
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
@ -1055,7 +1149,8 @@ module SMESH
*/
boolean DoubleNodeElemGroupsInRegion( in ListOfGroups theElems,
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).
@ -1070,14 +1165,15 @@ module SMESH
*/
ListOfGroups AffectedElemGroupsInRegion( in ListOfGroups theElems,
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
* The created 2D mesh elements based on nodes of free faces of boundary volumes
* \return TRUE if operation has been completed successfully, FALSE otherwise
*/
boolean Make2DMeshFrom3D();
boolean Make2DMeshFrom3D() raises (SALOME::SALOME_Exception);
/*!
* \brief Creates missing boundary elements
@ -1101,7 +1197,7 @@ module SMESH
in string meshName,
in boolean toCopyElements,
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
* groups of 2D elements
@ -1150,7 +1246,8 @@ module SMESH
* \param theGroupsOfFaces - list of groups of faces
* \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
@ -1162,7 +1259,8 @@ module SMESH
in GEOM::GEOM_Object theShape,
in string groupName,
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
*/
//================================================================================
/*
Class : NumericalFunctor
Description : Base class for numerical functors
*/
//================================================================================
NumericalFunctor::NumericalFunctor():
myMesh(NULL)
{
@ -321,6 +324,7 @@ double NumericalFunctor::Round( const double & aVal )
* \param minmax - boundaries of diapason of values to divide into intervals
*/
//================================================================================
void NumericalFunctor::GetHistogram(int nbIntervals,
std::vector<int>& nbEvents,
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 )
{
@ -417,21 +423,11 @@ double Volume::GetValue( long theElementId )
return 0;
}
//=======================================================================
//function : GetBadRate
//purpose : meaningless as it is not quality control functor
//=======================================================================
double Volume::GetBadRate( double Value, int /*nbNodes*/ ) const
{
return Value;
}
//=======================================================================
//function : GetType
//purpose :
//=======================================================================
SMDSAbs_ElementType Volume::GetType() const
{
return SMDSAbs_Volume;
@ -442,6 +438,8 @@ SMDSAbs_ElementType Volume::GetType() const
Class : MaxElementLength2D
Description : Functor calculating maximum length of 2D element
*/
//================================================================================
double MaxElementLength2D::GetValue( const TSequenceOfXYZ& P )
{
if(P.size() == 0)
@ -508,6 +506,7 @@ SMDSAbs_ElementType MaxElementLength2D::GetType() const
Class : MaxElementLength3D
Description : Functor calculating maximum length of 3D element
*/
//================================================================================
double MaxElementLength3D::GetValue( long theElementId )
{
@ -683,6 +682,7 @@ SMDSAbs_ElementType MaxElementLength3D::GetType() const
Class : MinimumAngle
Description : Functor for calculation of minimum angle
*/
//================================================================================
double MinimumAngle::GetValue( const TSequenceOfXYZ& P )
{
@ -715,10 +715,13 @@ SMDSAbs_ElementType MinimumAngle::GetType() const
}
//================================================================================
/*
Class : AspectRatio
Description : Functor for calculating aspect ratio
*/
//================================================================================
double AspectRatio::GetValue( long theId )
{
double aVal = 0;
@ -899,10 +902,13 @@ SMDSAbs_ElementType AspectRatio::GetType() const
}
//================================================================================
/*
Class : AspectRatio3D
Description : Functor for calculating aspect ratio
*/
//================================================================================
namespace{
inline double getHalfPerimeter(double theTria[3]){
@ -1269,10 +1275,13 @@ SMDSAbs_ElementType AspectRatio3D::GetType() const
}
//================================================================================
/*
Class : Warping
Description : Functor for calculating warping
*/
//================================================================================
double Warping::GetValue( const TSequenceOfXYZ& P )
{
if ( P.size() != 4 )
@ -1326,10 +1335,13 @@ SMDSAbs_ElementType Warping::GetType() const
}
//================================================================================
/*
Class : Taper
Description : Functor for calculating taper
*/
//================================================================================
double Taper::GetValue( const TSequenceOfXYZ& P )
{
if ( P.size() != 4 )
@ -1366,11 +1378,13 @@ SMDSAbs_ElementType Taper::GetType() const
return SMDSAbs_Face;
}
//================================================================================
/*
Class : Skew
Description : Functor for calculating skew in degrees
*/
//================================================================================
static inline double skewAngle( const gp_XYZ& p1, const gp_XYZ& p2, const gp_XYZ& p3 )
{
gp_XYZ p12 = ( p2 + p1 ) / 2.;
@ -1430,10 +1444,13 @@ SMDSAbs_ElementType Skew::GetType() const
}
//================================================================================
/*
Class : Area
Description : Functor for calculating area
*/
//================================================================================
double Area::GetValue( const TSequenceOfXYZ& P )
{
double val = 0.0;
@ -1463,11 +1480,13 @@ SMDSAbs_ElementType Area::GetType() const
return SMDSAbs_Face;
}
//================================================================================
/*
Class : Length
Description : Functor for calculating length of edge
*/
//================================================================================
double Length::GetValue( const TSequenceOfXYZ& P )
{
switch ( P.size() ) {
@ -1488,10 +1507,12 @@ SMDSAbs_ElementType Length::GetType() const
return SMDSAbs_Edge;
}
//================================================================================
/*
Class : Length2D
Description : Functor for calculating length of edge
*/
//================================================================================
double Length2D::GetValue( long theElementId)
{
@ -1799,10 +1820,13 @@ void Length2D::GetValues(TValues& theValues){
}
}
//================================================================================
/*
Class : MultiConnection
Description : Functor for calculating number of faces conneted to the edge
*/
//================================================================================
double MultiConnection::GetValue( const TSequenceOfXYZ& P )
{
return 0;
@ -1823,10 +1847,13 @@ SMDSAbs_ElementType MultiConnection::GetType() const
return SMDSAbs_Edge;
}
//================================================================================
/*
Class : MultiConnection2D
Description : Functor for calculating number of faces conneted to the edge
*/
//================================================================================
double MultiConnection2D::GetValue( const TSequenceOfXYZ& P )
{
return 0;
@ -1970,10 +1997,13 @@ void MultiConnection2D::GetValues(MValues& theValues){
}
//================================================================================
/*
Class : BallDiameter
Description : Functor returning diameter of a ball element
*/
//================================================================================
double BallDiameter::GetValue( long theId )
{
double diameter = 0;
@ -2002,10 +2032,12 @@ SMDSAbs_ElementType BallDiameter::GetType() const
PREDICATES
*/
//================================================================================
/*
Class : BadOrientedVolume
Description : Predicate bad oriented volumes
*/
//================================================================================
BadOrientedVolume::BadOrientedVolume()
{
@ -2052,9 +2084,11 @@ bool BareBorderVolume::IsSatisfy(long theElementId )
return false;
}
//================================================================================
/*
Class : BareBorderFace
*/
//================================================================================
bool BareBorderFace::IsSatisfy(long theElementId )
{
@ -2092,9 +2126,11 @@ bool BareBorderFace::IsSatisfy(long theElementId )
return ok;
}
//================================================================================
/*
Class : OverConstrainedVolume
*/
//================================================================================
bool OverConstrainedVolume::IsSatisfy(long theElementId )
{
@ -2112,9 +2148,11 @@ bool OverConstrainedVolume::IsSatisfy(long theElementId )
return false;
}
//================================================================================
/*
Class : OverConstrainedFace
*/
//================================================================================
bool OverConstrainedFace::IsSatisfy(long theElementId )
{
@ -2145,10 +2183,12 @@ bool OverConstrainedFace::IsSatisfy(long theElementId )
return false;
}
//================================================================================
/*
Class : CoincidentNodes
Description : Predicate of Coincident nodes
*/
//================================================================================
CoincidentNodes::CoincidentNodes()
{
@ -2190,11 +2230,13 @@ void CoincidentNodes::SetMesh( const SMDS_Mesh* theMesh )
}
}
//================================================================================
/*
Class : CoincidentElements
Description : Predicate of Coincident Elements
Note : This class is suitable only for visualization of Coincident Elements
*/
//================================================================================
CoincidentElements::CoincidentElements()
{
@ -2245,10 +2287,12 @@ SMDSAbs_ElementType CoincidentElements3D::GetType() const
}
//================================================================================
/*
Class : FreeBorders
Description : Predicate for free borders
*/
//================================================================================
FreeBorders::FreeBorders()
{
@ -2271,10 +2315,13 @@ SMDSAbs_ElementType FreeBorders::GetType() const
}
//================================================================================
/*
Class : FreeEdges
Description : Predicate for free Edges
*/
//================================================================================
FreeEdges::FreeEdges()
{
myMesh = 0;
@ -2406,11 +2453,12 @@ void FreeEdges::GetBoreders(TBorders& theBorders)
}
}
//================================================================================
/*
Class : FreeNodes
Description : Predicate for free nodes
*/
//================================================================================
FreeNodes::FreeNodes()
{
@ -2437,10 +2485,12 @@ SMDSAbs_ElementType FreeNodes::GetType() const
}
//================================================================================
/*
Class : FreeFaces
Description : Predicate for free faces
*/
//================================================================================
FreeFaces::FreeFaces()
{
@ -2493,10 +2543,12 @@ SMDSAbs_ElementType FreeFaces::GetType() const
return SMDSAbs_Face;
}
//================================================================================
/*
Class : LinearOrQuadratic
Description : Predicate to verify whether a mesh element is linear
*/
//================================================================================
LinearOrQuadratic::LinearOrQuadratic()
{
@ -2527,10 +2579,12 @@ SMDSAbs_ElementType LinearOrQuadratic::GetType() const
return myType;
}
//================================================================================
/*
Class : GroupColor
Description : Functor for check color of group to whic mesh element belongs to
*/
//================================================================================
GroupColor::GroupColor()
{
@ -2619,6 +2673,7 @@ void GroupColor::SetColorStr( const TCollection_AsciiString& theStr )
// Purpose : Get range as a string.
// Example: "1,2,3,50-60,63,67,70-"
//=======================================================================
void GroupColor::GetColorStr( TCollection_AsciiString& theResStr ) const
{
theResStr.Clear();
@ -2627,10 +2682,12 @@ void GroupColor::GetColorStr( TCollection_AsciiString& theResStr ) const
theResStr += TCollection_AsciiString( ";" ) + TCollection_AsciiString( myColor.Blue() );
}
//================================================================================
/*
Class : ElemGeomType
Description : Predicate to check element geometry type
*/
//================================================================================
ElemGeomType::ElemGeomType()
{
@ -2677,6 +2734,54 @@ SMDSAbs_GeometryType ElemGeomType::GetGeomType() const
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

23
src/Controls/SMESH_ControlsDef.hxx
View File

@ -245,7 +245,6 @@ namespace SMESH{
virtual SMDSAbs_ElementType GetType() const;
};
/*
Class : Skew
Description : Functor for calculating skew in degrees
@ -429,6 +428,28 @@ namespace SMESH{
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
*/

390
src/DriverGMF/DriverGMF_Read.cxx
View File

@ -29,6 +29,7 @@
#include "SMESHDS_Group.hxx"
#include "SMESHDS_Mesh.hxx"
#include "SMESH_Comment.hxx"
#include "SMESH_TypeDefs.hxx"
#include <Basics_Utils.hxx>
@ -69,9 +70,11 @@ Driver_Mesh::Status DriverGMF_Read::Perform()
if ( !meshID )
{
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
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
@ -109,34 +112,33 @@ Driver_Mesh::Status DriverGMF_Read::Perform()
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 */
const int edgeIDShift = myMesh->GetMeshInfo().NbElements();
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);
for ( int i = 1; i <= nbEdges; ++i )
{
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 ))
status = storeBadNodeIds( "GmfEdges + GmfExtraVerticesAtEdges",i, 3, iN[0],iN[1],midN);
status = storeBadNodeIds( "GmfEdges + GmfExtraVerticesAtEdges",i,
3, iN[0], iN[1], midN);
}
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 */
const int triaIDShift = myMesh->GetMeshInfo().NbElements();
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);
for ( int i = 1; i <= nbTria; ++i )
{
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], triaIDShift + i ))
status = storeBadNodeIds( "GmfTriangles + GmfExtraVerticesAtTriangles",i, 6,
if ( !myMesh->AddFaceWithID( iN[0],iN[1],iN[2], midN[0],midN[1],midN[2],
triaIDShift + i ))
status = storeBadNodeIds( "GmfTriangles + GmfExtraVerticesAtTriangles",i, 6,
iN[0],iN[1],iN[2], midN[0],midN[1],midN[2] );
}
else
@ -193,127 +188,108 @@ Driver_Mesh::Status DriverGMF_Read::Perform()
if ( !myMesh->AddFaceWithID( iN[0], iN[1], iN[2], triaIDShift + i ))
status = storeBadNodeIds( "GmfTriangles",i, 3, iN[0], iN[1], iN[2] );
}
}
}
// 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);
if ( !midN.empty() ) SMESHUtils::FreeVector( midN );
}
}
/* Read quadrangles */
/* Read quadrangles */
const int quadIDShift = myMesh->GetMeshInfo().NbElements();
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);
for ( int i = 1; i <= nbQuad; ++i )
{
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 ( midN.size() == 4 )
{
if ( !myMesh->AddFaceWithID( iN[0], iN[1], iN[2], iN[3],
midN[0], midN[1], midN[2], midN[3],
quadIDShift + i ))
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]);
}
if ( !myMesh->AddFaceWithID( iN[0], iN[1], iN[2], iN[3],
midN[0], midN[1], midN[2], midN[3],
quadIDShift + i ))
status = storeBadNodeIds( "GmfQuadrilaterals + GmfExtraVerticesAtQuadrilaterals",i, 8,
iN[0], iN[1],iN[2], iN[3],
midN[0], midN[1], midN[2], midN[3]);
}
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 ))
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 */
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);
for ( int i = 1; i <= nbTet; ++i )
{
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],
midN[2], midN[1], midN[0], midN[3], midN[5], midN[4], tetIDShift + i ))
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] );
midN[2], midN[1], midN[0], midN[3], midN[5], midN[4],
tetIDShift + i ))
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] );
}
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 */
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 */
const int hexIDShift = myMesh->GetMeshInfo().NbElements();
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);
for ( int i = 1; i <= nbHex; ++i )
{
GmfGetLin(meshID, GmfHexahedra, &iN[0], &iN[1], &iN[2], &iN[3],
&iN[4], &iN[5], &iN[6], &iN[7],&ref);
if ( readQuadNodes )
&iN[4], &iN[5], &iN[6], &iN[7], &ref);
std::vector<int>& midN = quadNodesAtHexahedra[ i ];
if ( midN.size() == 20-8 ) // HEXA20
{
const std::vector<int>& midN = quadNodesAtHexahedra[ i-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],
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]);
}
else // HEXA27
{
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],
midN[12],
midN[16], midN[15], midN[14], midN[13],
midN[17],
midN[18],
tetIDShift + i ))
status = storeBadNodeIds( "GmfHexahedra + GmfExtraVerticesAtHexahedra",i, 27,
iN[0], iN[3], iN[2], iN[1],
midN[8], midN[11], midN[10], midN[9],
hexIDShift + i ))
status = storeBadNodeIds( "GmfHexahedra + GmfExtraVerticesAtHexahedra",i, 20,
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]);
}
else if ( midN.size() >= 27-8 ) // HEXA27
{
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],
@ -421,20 +363,29 @@ Driver_Mesh::Status DriverGMF_Read::Perform()
midN[12],
midN[16], midN[15], midN[14], midN[13],
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],
iN[4], iN[7], iN[6], iN[5], hexIDShift + i ) )
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 */
const int prismIDShift = myMesh->GetMeshInfo().NbElements();
@ -443,8 +394,7 @@ Driver_Mesh::Status DriverGMF_Read::Perform()
GmfGotoKwd(meshID, GmfPrisms);
for ( int i = 1; i <= nbPrism; ++i )
{
GmfGetLin(meshID, GmfPrisms,
&iN[0], &iN[1], &iN[2], &iN[3], &iN[4], &iN[5], &ref);
GmfGetLin(meshID, GmfPrisms, &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))
status = storeBadNodeIds( "GmfPrisms",i,
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>
#define BEGIN_ELEM_WRITE( SMDSEntity, GmfKwd, elem ) \
elemIt = myMesh->elementEntityIterator( SMDSEntity ); \
elemIt = elementIterator( SMDSEntity ); \
if ( elemIt->more() ) \
{ \
GmfSetKwd(meshID, GmfKwd, myMesh->GetMeshInfo().NbEntities( SMDSEntity )); \
GmfSetKwd(meshID, GmfKwd, myMesh->GetMeshInfo().NbElements( SMDSEntity )); \
for ( int gmfID = 1; elemIt->more(); ++gmfID ) \
{ \
const SMDS_MeshElement* elem = elemIt->next(); \
GmfSetLin(meshID, GmfKwd,
#define BEGIN_EXTRA_VERTICES_WRITE( SMDSEntity, GmfKwd, elem, nbVertices ) \
elemIt = myMesh->elementEntityIterator( SMDSEntity ); \
#define BEGIN_EXTRA_VERTICES_WRITE( SMDSGeom, LinType, GmfKwd, elem ) \
elemIt = elementIterator( SMDSGeom ); \
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 ) \
{ \
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 ) \
elem->getshapeId() ); \
}} \
}}
#define END_ELEM_WRITE_ADD_TO_MAP( elem, e2id ) \
elem->getshapeId() ); \
e2id.insert( e2id.end(), make_pair( elem, gmfID )); \
}} \
}}
#define END_EXTRA_VERTICES_WRITE() \
); \
}} \
}}}}
DriverGMF_Write::DriverGMF_Write():
@ -126,107 +131,73 @@ Driver_Mesh::Status DriverGMF_Write::Perform()
// edges
TElem2IDMap edge2IDMap;
BEGIN_ELEM_WRITE( SMDSEntity_Edge, GmfEdges, edge )
BEGIN_ELEM_WRITE( SMDSGeom_EDGE, GmfEdges, edge )
node2IdMap[ edge->GetNode( 0 )],
node2IdMap[ edge->GetNode( 1 )],
END_ELEM_WRITE_ADD_TO_MAP( edge, edge2IDMap );
// quadratic edges
BEGIN_ELEM_WRITE( SMDSEntity_Quad_Edge, GmfEdges, edge )
node2IdMap[ edge->GetNode( 0 )],
node2IdMap[ edge->GetNode( 1 )],
END_ELEM_WRITE( edge );
BEGIN_EXTRA_VERTICES_WRITE( SMDSEntity_Quad_Edge, GmfExtraVerticesAtEdges, edge, 1 )
// nodes of quadratic edges
BEGIN_EXTRA_VERTICES_WRITE( SMDSGeom_EDGE, SMDSEntity_Edge,
GmfExtraVerticesAtEdges, edge )
node2IdMap[ edge->GetNode( 2 )]
END_EXTRA_VERTICES_WRITE();
// triangles
TElem2IDMap tria2IDMap;
BEGIN_ELEM_WRITE( SMDSEntity_Triangle, GmfTriangles, tria )
BEGIN_ELEM_WRITE( SMDSGeom_TRIANGLE, GmfTriangles, tria )
node2IdMap[ tria->GetNode( 0 )],
node2IdMap[ tria->GetNode( 1 )],
node2IdMap[ tria->GetNode( 2 )],
END_ELEM_WRITE_ADD_TO_MAP( tria, tria2IDMap );
// quadratic triangles
BEGIN_ELEM_WRITE( SMDSEntity_Quad_Triangle, GmfTriangles, tria )
node2IdMap[ tria->GetNode( 0 )],
node2IdMap[ tria->GetNode( 1 )],
node2IdMap[ tria->GetNode( 2 )],
END_ELEM_WRITE( tria );
BEGIN_EXTRA_VERTICES_WRITE( SMDSEntity_Quad_Triangle, GmfExtraVerticesAtTriangles, tria, 3 )
// nodes of quadratic triangles
BEGIN_EXTRA_VERTICES_WRITE( SMDSGeom_TRIANGLE, SMDSEntity_Triangle,
GmfExtraVerticesAtTriangles, tria )
node2IdMap[ tria->GetNode( 3 )],
node2IdMap[ tria->GetNode( 4 )],
node2IdMap[ tria->GetNode( 5 )]
//node2IdMap[ tria->GetNodeWrap( 6 )] // for TRIA7
END_EXTRA_VERTICES_WRITE();
// quadrangles
TElem2IDMap quad2IDMap;
BEGIN_ELEM_WRITE( SMDSEntity_Quadrangle, GmfQuadrilaterals, quad )
BEGIN_ELEM_WRITE( SMDSGeom_QUADRANGLE, GmfQuadrilaterals, quad )
node2IdMap[ quad->GetNode( 0 )],
node2IdMap[ quad->GetNode( 1 )],
node2IdMap[ quad->GetNode( 2 )],
node2IdMap[ quad->GetNode( 3 )],
END_ELEM_WRITE_ADD_TO_MAP( quad, quad2IDMap );
// quadratic quadrangles
BEGIN_ELEM_WRITE( SMDSEntity_Quad_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_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 )
// nodes of quadratic quadrangles
BEGIN_EXTRA_VERTICES_WRITE( SMDSGeom_QUADRANGLE, SMDSEntity_Quadrangle,
GmfExtraVerticesAtQuadrilaterals, quad )
node2IdMap[ quad->GetNode( 4 )],
node2IdMap[ quad->GetNode( 5 )],
node2IdMap[ quad->GetNode( 6 )],
node2IdMap[ quad->GetNode( 7 )],
node2IdMap[ quad->GetNode( 8 )]
node2IdMap[ quad->GetNodeWrap( 8 )] // for QUAD9
END_EXTRA_VERTICES_WRITE();
// terahedra
BEGIN_ELEM_WRITE( SMDSEntity_Tetra, GmfTetrahedra, tetra )
BEGIN_ELEM_WRITE( SMDSGeom_TETRA, GmfTetrahedra, tetra )
node2IdMap[ tetra->GetNode( 0 )],
node2IdMap[ tetra->GetNode( 2 )],
node2IdMap[ tetra->GetNode( 1 )],
node2IdMap[ tetra->GetNode( 3 )],
END_ELEM_WRITE( tetra );
// quadratic terahedra
BEGIN_ELEM_WRITE( SMDSEntity_Quad_Tetra, GmfTetrahedra, tetra )
node2IdMap[ tetra->GetNode( 0 )],
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 )
// nodes of quadratic terahedra
BEGIN_EXTRA_VERTICES_WRITE( SMDSGeom_TETRA, SMDSEntity_Tetra,
GmfExtraVerticesAtTetrahedra, tetra )
node2IdMap[ tetra->GetNode( 6 )],
node2IdMap[ tetra->GetNode( 5 )],
node2IdMap[ tetra->GetNode( 4 )],
node2IdMap[ tetra->GetNode( 7 )],
node2IdMap[ tetra->GetNode( 9 )],
node2IdMap[ tetra->GetNode( 8 )]
//node2IdMap[ tetra->GetNodeWrap( 10 )], // for TETRA11
END_EXTRA_VERTICES_WRITE();
// pyramids
BEGIN_ELEM_WRITE( SMDSEntity_Pyramid, GmfPyramids, pyra )
node2IdMap[ pyra->GetNode( 0 )],
@ -237,7 +208,7 @@ Driver_Mesh::Status DriverGMF_Write::Perform()
END_ELEM_WRITE( pyra );
// hexahedra
BEGIN_ELEM_WRITE( SMDSEntity_Hexa, GmfHexahedra, hexa )
BEGIN_ELEM_WRITE( SMDSGeom_HEXA, GmfHexahedra, hexa )
node2IdMap[ hexa->GetNode( 0 )],
node2IdMap[ hexa->GetNode( 3 )],
node2IdMap[ hexa->GetNode( 2 )],
@ -248,65 +219,28 @@ Driver_Mesh::Status DriverGMF_Write::Perform()
node2IdMap[ hexa->GetNode( 5 )],
END_ELEM_WRITE( hexa );
// quadratic hexahedra
BEGIN_ELEM_WRITE( SMDSEntity_Quad_Hexa, GmfHexahedra, hexa )
node2IdMap[ hexa->GetNode( 0 )],
node2IdMap[ hexa->GetNode( 3 )],
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 )],
// nodes of quadratic hexahedra
BEGIN_EXTRA_VERTICES_WRITE( SMDSGeom_HEXA, SMDSEntity_Hexa,
GmfExtraVerticesAtHexahedra, hexa )
node2IdMap[ hexa->GetNode( 11 )], // HEXA20
node2IdMap[ hexa->GetNode( 10 )],
node2IdMap[ hexa->GetNode( 9 )],
node2IdMap[ hexa->GetNode( 8 )],
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 )]
END_EXTRA_VERTICES_WRITE();
// tri-quadratic hexahedra
BEGIN_ELEM_WRITE( SMDSEntity_TriQuad_Hexa, GmfHexahedra, hexa )
node2IdMap[ hexa->GetNode( 0 )],
node2IdMap[ hexa->GetNode( 3 )],
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_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 )]
node2IdMap[ hexa->GetNodeWrap( 18 )], // + HEXA27
node2IdMap[ hexa->GetNodeWrap( 17 )],
node2IdMap[ hexa->GetNodeWrap( 20 )],
node2IdMap[ hexa->GetNodeWrap( 24 )],
node2IdMap[ hexa->GetNodeWrap( 23 )],
node2IdMap[ hexa->GetNodeWrap( 22 )],
node2IdMap[ hexa->GetNodeWrap( 21 )],
node2IdMap[ hexa->GetNodeWrap( 25 )],
node2IdMap[ hexa->GetNodeWrap( 26 )]
END_EXTRA_VERTICES_WRITE();
// prism
@ -405,3 +339,22 @@ Driver_Mesh::Status DriverGMF_Write::Perform()
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 "SMDSAbs_ElementType.hxx"
#include "SMDS_ElemIterator.hxx"
/*!
* \brief Driver Writing a mesh into a GMF file.
@ -51,6 +52,10 @@ public:
private:
SMDS_ElemIteratorPtr elementIterator(SMDSAbs_ElementType type);
SMDS_ElemIteratorPtr elementIterator(SMDSAbs_EntityType type);
SMDS_ElemIteratorPtr elementIterator(SMDSAbs_GeometryType type);
bool _exportRequiredGroups;
};

2
src/DriverMED/Makefile.am
View File

@ -21,7 +21,7 @@
# Author : Marc Tajchman (CEA)
# Modified by : Alexander BORODIN (OCN) - autotools usage
# Module : SMESH
#
include $(top_srcdir)/adm_local/unix/make_common_starter.am
# 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 ) )
myControlsPrecision = mgr->integerValue( "SMESH", "controls_precision", -1);
vtkFloatingPointType aElem0DSize = SMESH::GetFloat("SMESH:elem0d_size",5);
vtkFloatingPointType aBallElemSize = SMESH::GetFloat("SMESH:ball_elem_size",10);
vtkFloatingPointType aLineWidth = SMESH::GetFloat("SMESH:element_width",1);
vtkFloatingPointType aOutlineWidth = SMESH::GetFloat("SMESH:outline_width",1);
double aElem0DSize = SMESH::GetFloat("SMESH:elem0d_size",5);
double aBallElemSize = SMESH::GetFloat("SMESH:ball_elem_size",10);
double aLineWidth = SMESH::GetFloat("SMESH:element_width",1);
double aOutlineWidth = SMESH::GetFloat("SMESH:outline_width",1);
SMESH::LabelFont aFamilyNd = SMESH::FntTimes;
bool aBoldNd = true;
@ -166,7 +166,7 @@ SMESH_ActorDef::SMESH_ActorDef()
aShadowNd = f.overline();
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::LabelFont aFamilyEl = SMESH::FntTimes;
@ -184,7 +184,7 @@ SMESH_ActorDef::SMESH_ActorDef()
aShadowEl = f.overline();
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 ) );
vtkMatrix4x4 *aMatrix = vtkMatrix4x4::New();
@ -192,7 +192,7 @@ SMESH_ActorDef::SMESH_ActorDef()
//Definition 2D and 3D devices of the actor
//-----------------------------------------
vtkFloatingPointType anRGB[3] = {1,1,1};
double anRGB[3] = {1,1,1};
mySurfaceProp = vtkProperty::New();
QColor ffc, bfc;
int delta;
@ -665,8 +665,8 @@ void SMESH_ActorDef::SetPointsLabeled( bool theIsPointsLabeled )
void SMESH_ActorDef::SetPointsFontProperties( SMESH::LabelFont theFamily, int theSize,
bool theBold, bool theItalic, bool theShadow,
vtkFloatingPointType r, vtkFloatingPointType g, vtkFloatingPointType b )
{
double r, double g, double b )
{
if(myNodeActor) {
myNodeActor->SetFontProperties( theFamily, theSize, theBold, theItalic, theShadow, r, g, b );
SetRepresentation( GetRepresentation() );
@ -676,8 +676,8 @@ void SMESH_ActorDef::SetPointsFontProperties( SMESH::LabelFont theFamily, int th
void SMESH_ActorDef::SetCellsFontProperties( SMESH::LabelFont theFamily, int theSize,
bool theBold, bool theItalic, bool theShadow,
vtkFloatingPointType r, vtkFloatingPointType g, vtkFloatingPointType b )
{
double r, double g, double b )
{
if(my3DActor) {
my3DActor->SetFontProperties( theFamily, theSize, theBold, theItalic, theShadow, r, g, b );
SetRepresentation( GetRepresentation() );
@ -766,24 +766,24 @@ bool SMESH_ActorDef::GetFacesOriented()
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 );
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 );
}
void SMESH_ActorDef::SetFacesOrientationScale(vtkFloatingPointType theScale)
void SMESH_ActorDef::SetFacesOrientationScale(double theScale)
{
my2DActor->SetFacesOrientationScale( theScale );
my3DActor->SetFacesOrientationScale( theScale );
}
vtkFloatingPointType SMESH_ActorDef::GetFacesOrientationScale()
double SMESH_ActorDef::GetFacesOrientationScale()
{
return my3DActor->GetFacesOrientationScale();
}
@ -1189,8 +1189,8 @@ bool SMESH_ActorDef::Init(TVisualObjPtr theVisualObj,
my2DExtActor->GetMapper()->SetLookupTable(myLookupTable);
my3DActor->GetMapper()->SetLookupTable(myLookupTable);
my3DExtActor->GetMapper()->SetLookupTable(myLookupTable);
vtkFloatingPointType aFactor, aUnits;
double aFactor, aUnits;
my2DActor->GetPolygonOffsetParameters(aFactor,aUnits);
my2DActor->SetPolygonOffsetParameters(aFactor,aUnits*0.75);
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();
}
@ -1291,7 +1291,6 @@ vtkUnstructuredGrid* SMESH_ActorDef::GetUnstructuredGrid(){
bool SMESH_ActorDef::IsInfinitive(){
vtkDataSet *aDataSet = myPickableActor->GetUnstructuredGrid();
aDataSet->Update();
myIsInfinite = aDataSet->GetNumberOfCells() == 0 ||
( aDataSet->GetNumberOfCells() == 1 &&
aDataSet->GetCell(0)->GetCellType() == VTK_VERTEX );
@ -1306,11 +1305,11 @@ void SMESH_ActorDef::SetIsShrunkable(bool theShrunkable){
Modified();
}
vtkFloatingPointType SMESH_ActorDef::GetShrinkFactor(){
double SMESH_ActorDef::GetShrinkFactor(){
return myBaseActor->GetShrinkFactor();
}
void SMESH_ActorDef::SetShrinkFactor(vtkFloatingPointType theValue){
void SMESH_ActorDef::SetShrinkFactor(double theValue){
myBaseActor->SetShrinkFactor(theValue);
my1DActor->SetShrinkFactor(theValue);
@ -1367,7 +1366,7 @@ int SMESH_ActorDef::GetNodeObjId(int theVtkID){
return myPickableActor->GetNodeObjId(theVtkID);
}
vtkFloatingPointType* SMESH_ActorDef::GetNodeCoord(int theObjID){
double* SMESH_ActorDef::GetNodeCoord(int 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){
vtkFloatingPointType* aColor = theProperty->GetColor();
static void GetColor(vtkProperty *theProperty, double& r,double& g,double& b){
double* aColor = theProperty->GetColor();
r = aColor[0];
g = aColor[1];
b = aColor[2];
}
void SMESH_ActorDef::SetOpacity(vtkFloatingPointType theValue){
void SMESH_ActorDef::SetOpacity(double theValue){
mySurfaceProp->SetOpacity(theValue);
myBackSurfaceProp->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();
}
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);
my2DExtProp->SetColor(1.0-r,1.0-g,1.0-b);
if( SMESH_GroupObj* aGroupObj = dynamic_cast<SMESH_GroupObj*>( myVisualObj.get() ) )
@ -1957,12 +1956,12 @@ void SMESH_ActorDef::SetSufaceColor(vtkFloatingPointType r,vtkFloatingPointType
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);
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);
my3DExtProp->SetColor(1.0-r,1.0-g,1.0-b);
if( SMESH_GroupObj* aGroupObj = dynamic_cast<SMESH_GroupObj*>( myVisualObj.get() ) )
@ -1975,12 +1974,12 @@ void SMESH_ActorDef::SetVolumeColor(vtkFloatingPointType r,vtkFloatingPointType
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);
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);
my1DProp->SetColor(r,g,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();
}
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);
}
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);
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);
}
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);
myNodeExtProp->SetColor(1.0-r,1.0-g,1.0-b);
if( SMESH_GroupObj* aGroupObj = dynamic_cast<SMESH_GroupObj*>( myVisualObj.get() ) )
@ -2013,11 +2012,11 @@ void SMESH_ActorDef::SetNodeColor(vtkFloatingPointType r,vtkFloatingPointType g,
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);
}
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);
if( SMESH_GroupObj* aGroupObj = dynamic_cast<SMESH_GroupObj*>( myVisualObj.get() ) )
if( aGroupObj->GetElementType() == SMDSAbs_0DElement )
@ -2025,11 +2024,11 @@ void SMESH_ActorDef::Set0DColor(vtkFloatingPointType r,vtkFloatingPointType g,vt
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);
}
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);
if( SMESH_GroupObj* aGroupObj = dynamic_cast<SMESH_GroupObj*>( myVisualObj.get() ) )
if( aGroupObj->GetElementType() == SMDSAbs_Ball )
@ -2037,37 +2036,37 @@ void SMESH_ActorDef::SetBallColor(vtkFloatingPointType r,vtkFloatingPointType g,
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);
}
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);
myBallHighlightProp->SetColor(r,g,b);
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);
}
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);
myBallPreselectProp->SetColor(r,g,b);
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);
}
vtkFloatingPointType SMESH_ActorDef::GetLineWidth(){
double SMESH_ActorDef::GetLineWidth(){
return myEdgeProp->GetLineWidth();
}
void SMESH_ActorDef::SetLineWidth(vtkFloatingPointType theVal){
void SMESH_ActorDef::SetLineWidth(double theVal){
myEdgeProp->SetLineWidth(theVal);
my1DProp->SetLineWidth(theVal + aLineWidthInc);
@ -2080,18 +2079,18 @@ void SMESH_ActorDef::SetLineWidth(vtkFloatingPointType theVal){
Modified();
}
vtkFloatingPointType SMESH_ActorDef::GetOutlineWidth()
double SMESH_ActorDef::GetOutlineWidth()
{
return myOutLineProp->GetLineWidth();
}
void SMESH_ActorDef::SetOutlineWidth(vtkFloatingPointType theVal)
void SMESH_ActorDef::SetOutlineWidth(double theVal)
{
myOutLineProp->SetLineWidth(theVal);
Modified();
}
void SMESH_ActorDef::Set0DSize(vtkFloatingPointType theVal){
void SMESH_ActorDef::Set0DSize(double theVal){
my0DProp->SetPointSize(theVal);
myHighlightProp->SetPointSize(theVal);
myPreselectProp->SetPointSize(theVal);
@ -2106,11 +2105,11 @@ void SMESH_ActorDef::Set0DSize(vtkFloatingPointType theVal){
Modified();
}
vtkFloatingPointType SMESH_ActorDef::Get0DSize(){
double SMESH_ActorDef::Get0DSize(){
return my0DProp->GetPointSize();
}
void SMESH_ActorDef::SetBallSize(vtkFloatingPointType theVal){
void SMESH_ActorDef::SetBallSize(double theVal){
myBallProp->SetPointSize(theVal);
myBallHighlightProp->SetPointSize(theVal);
myBallPreselectProp->SetPointSize(theVal);
@ -2124,7 +2123,7 @@ void SMESH_ActorDef::SetBallSize(vtkFloatingPointType theVal){
Modified();
}
vtkFloatingPointType SMESH_ActorDef::GetBallSize(){
double SMESH_ActorDef::GetBallSize(){
return myBallProp->GetPointSize();
}
@ -2288,21 +2287,21 @@ void SMESH_ActorDef::UpdateScalarBar()
myScalarBarActor->SetOrientationToVertical();
vtkFloatingPointType aXVal = horiz ? 0.20 : 0.01;
double aXVal = horiz ? 0.20 : 0.01;
if( mgr->hasValue( "SMESH", name + "x" ) )
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" ) )
aYVal = mgr->doubleValue( "SMESH", name + "y", 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" ) )
aWVal = mgr->doubleValue( "SMESH", name + "width", aWVal );
myScalarBarActor->SetWidth( aWVal );
vtkFloatingPointType aHVal = horiz ? 0.12 : 0.80;
double aHVal = horiz ? 0.12 : 0.80;
if( mgr->hasValue( "SMESH", name + "height" ) )
aHVal = mgr->doubleValue( "SMESH", name + "height", 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,
int theIsClear);
virtual void SetSufaceColor(vtkFloatingPointType r,vtkFloatingPointType g,vtkFloatingPointType b, int delta ) = 0;
virtual void GetSufaceColor(vtkFloatingPointType& r,vtkFloatingPointType& g,vtkFloatingPointType& b, int& delta ) = 0;
virtual void SetSufaceColor(double r,double g,double 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 GetVolumeColor(vtkFloatingPointType& r,vtkFloatingPointType& g,vtkFloatingPointType& b, int& delta) = 0;
virtual void SetVolumeColor(double r,double g,double 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 GetEdgeColor(vtkFloatingPointType& r,vtkFloatingPointType& g,vtkFloatingPointType& b) = 0;
virtual void SetEdgeColor(double r,double g,double b) = 0;
virtual void GetEdgeColor(double& r,double& g,double& b) = 0;
virtual void SetNodeColor(vtkFloatingPointType r,vtkFloatingPointType g,vtkFloatingPointType b) = 0;
virtual void GetNodeColor(vtkFloatingPointType& r,vtkFloatingPointType& g,vtkFloatingPointType& b) = 0;
virtual void SetNodeColor(double r,double g,double b) = 0;
virtual void GetNodeColor(double& r,double& g,double& b) = 0;
virtual void SetOutlineColor(vtkFloatingPointType r,vtkFloatingPointType g,vtkFloatingPointType b) = 0;
virtual void GetOutlineColor(vtkFloatingPointType& r,vtkFloatingPointType& g,vtkFloatingPointType& b) = 0;
virtual void SetOutlineColor(double r,double g,double b) = 0;
virtual void GetOutlineColor(double& r,double& g,double& b) = 0;
virtual void Set0DColor(vtkFloatingPointType r,vtkFloatingPointType g,vtkFloatingPointType b) = 0;
virtual void Get0DColor(vtkFloatingPointType& r,vtkFloatingPointType& g,vtkFloatingPointType& b) = 0;
virtual void Set0DColor(double r,double g,double b) = 0;
virtual void Get0DColor(double& r,double& g,double& b) = 0;
virtual void SetBallColor(vtkFloatingPointType r,vtkFloatingPointType g,vtkFloatingPointType b) = 0;
virtual void GetBallColor(vtkFloatingPointType& r,vtkFloatingPointType& g,vtkFloatingPointType& b) = 0;
virtual void SetBallColor(double r,double g,double b) = 0;
virtual void GetBallColor(double& r,double& g,double& b) = 0;
virtual void SetHighlightColor(vtkFloatingPointType r,vtkFloatingPointType g,vtkFloatingPointType b) = 0;
virtual void GetHighlightColor(vtkFloatingPointType& r,vtkFloatingPointType& g,vtkFloatingPointType& b) = 0;
virtual void SetHighlightColor(double r,double g,double b) = 0;
virtual void GetHighlightColor(double& r,double& g,double& b) = 0;
virtual void SetPreHighlightColor(vtkFloatingPointType r,vtkFloatingPointType g,vtkFloatingPointType b) = 0;
virtual void GetPreHighlightColor(vtkFloatingPointType& r,vtkFloatingPointType& g,vtkFloatingPointType& b) = 0;
virtual void SetPreHighlightColor(double r,double g,double b) = 0;
virtual void GetPreHighlightColor(double& r,double& g,double& b) = 0;
virtual vtkFloatingPointType GetLineWidth() = 0;
virtual void SetLineWidth(vtkFloatingPointType theVal) = 0;
virtual double GetLineWidth() = 0;
virtual void SetLineWidth(double theVal) = 0;
virtual vtkFloatingPointType GetOutlineWidth() = 0;
virtual void SetOutlineWidth(vtkFloatingPointType theVal) = 0;
virtual double GetOutlineWidth() = 0;
virtual void SetOutlineWidth(double theVal) = 0;
virtual void Set0DSize(vtkFloatingPointType size) = 0;
virtual vtkFloatingPointType Get0DSize() = 0;
virtual void Set0DSize(double size) = 0;
virtual double Get0DSize() = 0;
virtual void SetBallSize(vtkFloatingPointType size) = 0;
virtual vtkFloatingPointType GetBallSize() = 0;
virtual void SetBallSize(double size) = 0;
virtual double GetBallSize() = 0;
enum EReperesent { ePoint, eEdge, eSurface};
@ -118,7 +118,7 @@ class SMESHOBJECT_EXPORT SMESH_Actor: public SALOME_Actor
virtual vtkUnstructuredGrid* GetUnstructuredGrid() = 0;
virtual void SetShrinkFactor(vtkFloatingPointType theValue) = 0;
virtual void SetShrinkFactor(double theValue) = 0;
virtual void SetPointsLabeled(bool theIsPointsLabeled) = 0;
virtual bool GetPointsLabeled() = 0;
@ -129,11 +129,11 @@ class SMESHOBJECT_EXPORT SMESH_Actor: public SALOME_Actor
virtual void SetFacesOriented(bool theIsFacesOriented) = 0;
virtual bool GetFacesOriented() = 0;
virtual void SetFacesOrientationColor(vtkFloatingPointType r,vtkFloatingPointType g,vtkFloatingPointType b) = 0;
virtual void GetFacesOrientationColor(vtkFloatingPointType& r,vtkFloatingPointType& g,vtkFloatingPointType& b) = 0;
virtual void SetFacesOrientationColor(double r,double g,double b) = 0;
virtual void GetFacesOrientationColor(double& r,double& g,double& b) = 0;
virtual void SetFacesOrientationScale(vtkFloatingPointType theScale) = 0;
virtual vtkFloatingPointType GetFacesOrientationScale() = 0;
virtual void SetFacesOrientationScale(double theScale) = 0;
virtual double GetFacesOrientationScale() = 0;
virtual void SetFacesOrientation3DVectors(bool theState) = 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,
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,
bool bold, bool italic, bool shadow,
vtkFloatingPointType r, vtkFloatingPointType g, vtkFloatingPointType b ) = 0;
double r, double g, double b ) = 0;
#ifndef DISABLE_PLOT2DVIEWER
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 void SetOpacity(vtkFloatingPointType theValue);
virtual vtkFloatingPointType GetOpacity();
virtual void SetOpacity(double theValue);
virtual double GetOpacity();
virtual void SetSufaceColor(vtkFloatingPointType r,vtkFloatingPointType g,vtkFloatingPointType b, int delta );
virtual void GetSufaceColor(vtkFloatingPointType& r,vtkFloatingPointType& g,vtkFloatingPointType& b, int& delta);
virtual void SetSufaceColor(double r,double g,double 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 GetVolumeColor(vtkFloatingPointType& r,vtkFloatingPointType& g,vtkFloatingPointType& b, int& delta);
virtual void SetVolumeColor(double r,double g,double 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 GetEdgeColor(vtkFloatingPointType& r,vtkFloatingPointType& g,vtkFloatingPointType& b);
virtual void SetEdgeColor(double r,double g,double b);
virtual void GetEdgeColor(double& r,double& g,double& b);
virtual void SetOutlineColor(vtkFloatingPointType r,vtkFloatingPointType g,vtkFloatingPointType b);
virtual void GetOutlineColor(vtkFloatingPointType& r,vtkFloatingPointType& g,vtkFloatingPointType& b);
virtual void SetOutlineColor(double r,double g,double b);
virtual void GetOutlineColor(double& r,double& g,double& b);
virtual void SetNodeColor(vtkFloatingPointType r,vtkFloatingPointType g,vtkFloatingPointType b);
virtual void GetNodeColor(vtkFloatingPointType& r,vtkFloatingPointType& g,vtkFloatingPointType& b);
virtual void SetNodeColor(double r,double g,double b);
virtual void GetNodeColor(double& r,double& g,double& b);
virtual void Set0DColor(vtkFloatingPointType r,vtkFloatingPointType g,vtkFloatingPointType b);
virtual void Get0DColor(vtkFloatingPointType& r,vtkFloatingPointType& g,vtkFloatingPointType& b);
virtual void Set0DColor(double r,double g,double b);
virtual void Get0DColor(double& r,double& g,double& b);
virtual void SetBallColor(vtkFloatingPointType r,vtkFloatingPointType g,vtkFloatingPointType b);
virtual void GetBallColor(vtkFloatingPointType& r,vtkFloatingPointType& g,vtkFloatingPointType& b);
virtual void SetBallColor(double r,double g,double b);
virtual void GetBallColor(double& r,double& g,double& b);
virtual void SetHighlightColor(vtkFloatingPointType r,vtkFloatingPointType g,vtkFloatingPointType b);
virtual void GetHighlightColor(vtkFloatingPointType& r,vtkFloatingPointType& g,vtkFloatingPointType& b);
virtual void SetHighlightColor(double r,double g,double b);
virtual void GetHighlightColor(double& r,double& g,double& b);
virtual void SetPreHighlightColor(vtkFloatingPointType r,vtkFloatingPointType g,vtkFloatingPointType b);
virtual void GetPreHighlightColor(vtkFloatingPointType& r,vtkFloatingPointType& g,vtkFloatingPointType& b);
virtual void SetPreHighlightColor(double r,double g,double b);
virtual void GetPreHighlightColor(double& r,double& g,double& b);
virtual vtkFloatingPointType GetLineWidth();
virtual void SetLineWidth(vtkFloatingPointType theVal);
virtual double GetLineWidth();
virtual void SetLineWidth(double theVal);
virtual vtkFloatingPointType GetOutlineWidth();
virtual void SetOutlineWidth(vtkFloatingPointType theVal);
virtual double GetOutlineWidth();
virtual void SetOutlineWidth(double theVal);
virtual void Set0DSize(vtkFloatingPointType size);
virtual vtkFloatingPointType Get0DSize();
virtual void Set0DSize(double size);
virtual double Get0DSize();
virtual void SetBallSize(vtkFloatingPointType size);
virtual vtkFloatingPointType GetBallSize();
virtual void SetBallSize(double size);
virtual double GetBallSize();
virtual int GetNodeObjId(int theVtkID);
virtual vtkFloatingPointType* GetNodeCoord(int theObjID);
virtual double* GetNodeCoord(int theObjID);
virtual int GetElemObjId(int theVtkID);
virtual vtkCell* GetElemCell(int theObjID);
@ -162,15 +162,15 @@ class SMESH_ActorDef : public SMESH_Actor
virtual void SetPointRepresentation(bool theIsPointsVisible);
virtual bool GetPointRepresentation();
virtual vtkFloatingPointType* GetBounds();
virtual double* GetBounds();
virtual void SetTransform(VTKViewer_Transform* theTransform);
virtual vtkUnstructuredGrid* GetUnstructuredGrid();
virtual vtkDataSet* GetInput();
virtual vtkMapper* GetMapper();
virtual vtkFloatingPointType GetShrinkFactor();
virtual void SetShrinkFactor(vtkFloatingPointType theValue);
virtual double GetShrinkFactor();
virtual void SetShrinkFactor(double theValue);
virtual bool IsShrunkable() { return myIsShrinkable;}
virtual bool IsShrunk() { return myIsShrunk;}
@ -182,10 +182,10 @@ class SMESH_ActorDef : public SMESH_Actor
virtual void SetPointsFontProperties( SMESH::LabelFont family, int size,
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,
bool bold, bool italic, bool shadow,
vtkFloatingPointType r, vtkFloatingPointType g, vtkFloatingPointType b );
double r, double g, double b );
virtual void SetCellsLabeled(bool theIsCellsLabeled);
virtual bool GetCellsLabeled();
@ -193,11 +193,11 @@ class SMESH_ActorDef : public SMESH_Actor
virtual void SetFacesOriented(bool theIsFacesOriented);
virtual bool GetFacesOriented();
virtual void SetFacesOrientationColor(vtkFloatingPointType r,vtkFloatingPointType g,vtkFloatingPointType b);
virtual void GetFacesOrientationColor(vtkFloatingPointType& r,vtkFloatingPointType& g,vtkFloatingPointType& b);
virtual void SetFacesOrientationColor(double r,double g,double b);
virtual void GetFacesOrientationColor(double& r,double& g,double& b);
virtual void SetFacesOrientationScale(vtkFloatingPointType theScale);
virtual vtkFloatingPointType GetFacesOrientationScale();
virtual void SetFacesOrientationScale(double theScale);
virtual double GetFacesOrientationScale();
virtual void SetFacesOrientation3DVectors(bool theState);
virtual bool GetFacesOrientation3DVectors();

22
src/OBJECT/SMESH_ActorUtils.cxx
View File

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

14
src/OBJECT/SMESH_ActorUtils.h
View File

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

12
src/OBJECT/SMESH_CellLabelActor.cxx
View File

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

2
src/OBJECT/SMESH_CellLabelActor.h
View File

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

80
src/OBJECT/SMESH_DeviceActor.cxx
View File

@ -119,13 +119,13 @@ SMESH_DeviceActor
// Orientation of faces
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 ) );
myFaceOrientationFilter = SMESH_FaceOrientationFilter::New();
myFaceOrientationDataMapper = vtkPolyDataMapper::New();
myFaceOrientationDataMapper->SetInput(myFaceOrientationFilter->GetOutput());
myFaceOrientationDataMapper->SetInputConnection(myFaceOrientationFilter->GetOutputPort());
myFaceOrientation = vtkActor::New();
myFaceOrientation->SetMapper(myFaceOrientationDataMapper);
@ -208,9 +208,9 @@ SMESH_DeviceActor
{
int anId = 0;
if(theIsImplicitFunctionUsed)
myPassFilter[ anId ]->SetInput( myExtractGeometry->GetOutput() );
myPassFilter[ anId ]->SetInputConnection( myExtractGeometry->GetOutputPort() );
else
myPassFilter[ anId ]->SetInput( myMergeFilter->GetOutput() );
myPassFilter[ anId ]->SetInputConnection( myMergeFilter->GetOutputPort() );
myIsImplicitFunctionUsed = theIsImplicitFunctionUsed;
SetStoreClippingMapping(myStoreClippingMapping);
@ -225,32 +225,32 @@ SMESH_DeviceActor
//myIsShrinkable = theGrid->GetNumberOfCells() > 10;
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;
SetImplicitFunctionUsed(myIsImplicitFunctionUsed);
myPassFilter[ anId + 1]->SetInput( myPassFilter[ anId ]->GetOutput() );
myPassFilter[ anId + 1]->SetInputConnection( myPassFilter[ anId ]->GetOutputPort() );
anId++; // 1
myTransformFilter->SetInput( myPassFilter[ anId ]->GetOutput() );
myTransformFilter->SetInputConnection( myPassFilter[ anId ]->GetOutputPort() );
anId++; // 2
myPassFilter[ anId ]->SetInput( myTransformFilter->GetOutput() );
myPassFilter[ anId + 1 ]->SetInput( myPassFilter[ anId ]->GetOutput() );
myPassFilter[ anId ]->SetInputConnection( myTransformFilter->GetOutputPort() );
myPassFilter[ anId + 1 ]->SetInputConnection( myPassFilter[ anId ]->GetOutputPort() );
anId++; // 3
myGeomFilter->SetInput( myPassFilter[ anId ]->GetOutput() );
myGeomFilter->SetInputConnection( myPassFilter[ anId ]->GetOutputPort() );
anId++; // 4
myPassFilter[ anId ]->SetInput( myGeomFilter->GetOutput() );
myPassFilter[ anId + 1 ]->SetInput( myPassFilter[ anId ]->GetOutput() );
myPassFilter[ anId ]->SetInputConnection( myGeomFilter->GetOutputPort() );
myPassFilter[ anId + 1 ]->SetInputConnection( myPassFilter[ anId ]->GetOutputPort() );
anId++; // 5
myMapper->SetInput( myPassFilter[ anId ]->GetPolyDataOutput() );
myMapper->SetInputConnection( myPassFilter[ anId ]->GetOutputPort() );
vtkLODActor::SetMapper( myMapper );
Modified();
@ -322,7 +322,7 @@ SMESH_DeviceActor
theLookupTable->SetNumberOfTableValues(theScalarBarActor->GetMaximumNumberOfColors());
theLookupTable->Build();
myMergeFilter->SetScalars(aDataSet);
myMergeFilter->SetScalarsData(aDataSet);
aDataSet->Delete();
}
GetMapper()->SetScalarVisibility(anIsInitialized);
@ -402,7 +402,7 @@ SMESH_DeviceActor
theLookupTable->SetRange(aScalars->GetRange());
theLookupTable->Build();
myMergeFilter->SetScalars(aDataSet);
myMergeFilter->SetScalarsData(aDataSet);
aDataSet->Delete();
}
else if (MultiConnection2D* aMultiConnection2D = dynamic_cast<MultiConnection2D*>(theFunctor.get())){
@ -462,7 +462,7 @@ SMESH_DeviceActor
theLookupTable->SetRange(aScalars->GetRange());
theLookupTable->Build();
myMergeFilter->SetScalars(aDataSet);
myMergeFilter->SetScalarsData(aDataSet);
aDataSet->Delete();
}
}
@ -600,10 +600,10 @@ SMESH_DeviceActor
::SetShrink()
{
if ( !myIsShrinkable ) return;
if ( vtkDataSet* aDataSet = myPassFilter[ 0 ]->GetOutput() )
if ( vtkAlgorithmOutput* aDataSet = myPassFilter[ 0 ]->GetOutputPort() )
{
myShrinkFilter->SetInput( aDataSet );
myPassFilter[ 1 ]->SetInput( myShrinkFilter->GetOutput() );
myShrinkFilter->SetInputConnection( aDataSet );
myPassFilter[ 1 ]->SetInputConnection( myShrinkFilter->GetOutputPort() );
myIsShrunk = true;
}
}
@ -613,9 +613,9 @@ SMESH_DeviceActor
::UnShrink()
{
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();
myIsShrunk = false;
Modified();
@ -627,37 +627,37 @@ void
SMESH_DeviceActor
::SetFacesOriented(bool theIsFacesOriented)
{
if ( vtkDataSet* aDataSet = myTransformFilter->GetOutput() )
if ( vtkAlgorithmOutput* aDataSet = myTransformFilter->GetOutputPort() )
{
myIsFacesOriented = theIsFacesOriented;
if( theIsFacesOriented )
myFaceOrientationFilter->SetInput( aDataSet );
myFaceOrientationFilter->SetInputConnection( aDataSet );
UpdateFaceOrientation();
}
}
void
SMESH_DeviceActor
::SetFacesOrientationColor(vtkFloatingPointType r,vtkFloatingPointType g,vtkFloatingPointType b)
::SetFacesOrientationColor(double r,double g,double b)
{
myFaceOrientation->GetProperty()->SetColor( r, g, b );
}
void
SMESH_DeviceActor
::GetFacesOrientationColor(vtkFloatingPointType& r,vtkFloatingPointType& g,vtkFloatingPointType& b)
::GetFacesOrientationColor(double& r,double& g,double& b)
{
myFaceOrientation->GetProperty()->GetColor( r, g, b );
}
void
SMESH_DeviceActor
::SetFacesOrientationScale(vtkFloatingPointType theScale)
::SetFacesOrientationScale(double theScale)
{
myFaceOrientationFilter->SetOrientationScale( theScale );
}
vtkFloatingPointType
double
SMESH_DeviceActor
::GetFacesOrientationScale()
{
@ -780,13 +780,13 @@ SMESH_DeviceActor
return aRetID;
}
vtkFloatingPointType*
double*
SMESH_DeviceActor
::GetNodeCoord(int theObjID)
{
vtkDataSet* aDataSet = myMergeFilter->GetOutput();
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);
return aCoord;
}
@ -829,7 +829,7 @@ SMESH_DeviceActor
}
vtkFloatingPointType
double
SMESH_DeviceActor
::GetShrinkFactor()
{
@ -838,7 +838,7 @@ SMESH_DeviceActor
void
SMESH_DeviceActor
::SetShrinkFactor(vtkFloatingPointType theValue)
::SetShrinkFactor(double theValue)
{
theValue = theValue > 0.1? theValue: 0.8;
myShrinkFilter->SetShrinkFactor(theValue);
@ -861,13 +861,13 @@ SMESH_DeviceActor
::Render(vtkRenderer *ren, vtkMapper* m)
{
int aResolveCoincidentTopology = vtkMapper::GetResolveCoincidentTopology();
vtkFloatingPointType aStoredFactor, aStoredUnit;
double aStoredFactor, aStoredUnit;
vtkMapper::GetResolveCoincidentTopologyPolygonOffsetParameters(aStoredFactor,aStoredUnit);
vtkMapper::SetResolveCoincidentTopologyToPolygonOffset();
vtkFloatingPointType aFactor = myPolygonOffsetFactor, aUnits = myPolygonOffsetUnits;
double aFactor = myPolygonOffsetFactor, aUnits = myPolygonOffsetUnits;
if(myIsHighlited){
static vtkFloatingPointType EPS = .01;
static double EPS = .01;
aUnits *= (1.0-EPS);
}
vtkMapper::SetResolveCoincidentTopologyPolygonOffsetParameters(aFactor,aUnits);
@ -880,8 +880,8 @@ SMESH_DeviceActor
void
SMESH_DeviceActor
::SetPolygonOffsetParameters(vtkFloatingPointType factor,
vtkFloatingPointType units)
::SetPolygonOffsetParameters(double factor,
double units)
{
myPolygonOffsetFactor = factor;
myPolygonOffsetUnits = units;
@ -903,14 +903,14 @@ bool SMESH_DeviceActor::GetQuadraticArcMode(){
/*!
* 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);
}
/*!
* Return Max angle of the representation 2D quadratic element as arked polygon
*/
vtkFloatingPointType SMESH_DeviceActor::GetQuadraticArcAngle(){
double SMESH_DeviceActor::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);
virtual int GetNodeObjId(int theVtkID);
virtual vtkFloatingPointType* GetNodeCoord(int theObjID);
virtual double* GetNodeCoord(int theObjID);
virtual int GetElemObjId(int theVtkID);
virtual vtkCell* GetElemCell(int theObjID);
@ -79,11 +79,11 @@ class SMESHOBJECT_EXPORT SMESH_DeviceActor: public vtkLODActor{
virtual void SetFacesOriented(bool theIsFacesOriented);
virtual bool GetFacesOriented() { return myIsFacesOriented; }
virtual void SetFacesOrientationColor(vtkFloatingPointType r,vtkFloatingPointType g,vtkFloatingPointType b);
virtual void GetFacesOrientationColor(vtkFloatingPointType& r,vtkFloatingPointType& g,vtkFloatingPointType& b);
virtual void SetFacesOrientationColor(double r,double g,double b);
virtual void GetFacesOrientationColor(double& r,double& g,double& b);
virtual void SetFacesOrientationScale(vtkFloatingPointType theScale);
virtual vtkFloatingPointType GetFacesOrientationScale();
virtual void SetFacesOrientationScale(double theScale);
virtual double GetFacesOrientationScale();
virtual void SetFacesOrientation3DVectors(bool theState);
virtual bool GetFacesOrientation3DVectors();
@ -93,13 +93,13 @@ class SMESHOBJECT_EXPORT SMESH_DeviceActor: public vtkLODActor{
virtual void SetQuadraticArcMode(bool theFlag);
virtual bool GetQuadraticArcMode();
virtual void SetQuadraticArcAngle(vtkFloatingPointType theMaxAngle);
virtual vtkFloatingPointType GetQuadraticArcAngle();
virtual void SetQuadraticArcAngle(double theMaxAngle);
virtual double GetQuadraticArcAngle();
void UpdateFaceOrientation();
vtkFloatingPointType GetShrinkFactor();
void SetShrinkFactor(vtkFloatingPointType value);
double GetShrinkFactor();
void SetShrinkFactor(double value);
bool IsShrunkable() { return myIsShrinkable;}
bool IsShrunk() { return myIsShrunk;}
@ -182,16 +182,16 @@ class SMESHOBJECT_EXPORT SMESH_DeviceActor: public vtkLODActor{
bool myIsHighlited;
vtkFloatingPointType myPolygonOffsetFactor;
vtkFloatingPointType myPolygonOffsetUnits;
double myPolygonOffsetFactor;
double myPolygonOffsetUnits;
void
SetPolygonOffsetParameters(vtkFloatingPointType factor,
vtkFloatingPointType units);
SetPolygonOffsetParameters(double factor,
double units);
void
GetPolygonOffsetParameters(vtkFloatingPointType& factor,
vtkFloatingPointType& units)
GetPolygonOffsetParameters(double& factor,
double& units)
{
factor = myPolygonOffsetFactor;
units = myPolygonOffsetUnits;

6
src/OBJECT/SMESH_ExtractGeometry.cxx
View File

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

19
src/OBJECT/SMESH_FaceOrientationFilter.cxx
View File

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

8
src/OBJECT/SMESH_FaceOrientationFilter.h
View File

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

10
src/OBJECT/SMESH_NodeLabelActor.cxx
View File

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

2
src/OBJECT/SMESH_NodeLabelActor.h
View File

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

4
src/OBJECT/SMESH_ScalarBarActor.cxx
View File

@ -88,7 +88,7 @@ SMESH_ScalarBarActor::SMESH_ScalarBarActor() {
this->ScalarBar = vtkPolyData::New();
this->ScalarBarMapper = vtkPolyDataMapper2D::New();
this->ScalarBarMapper->SetInput(this->ScalarBar);
this->ScalarBarMapper->SetInputData(this->ScalarBar);
this->ScalarBarActor = vtkActor2D::New();
this->ScalarBarActor->SetMapper(this->ScalarBarMapper);
this->ScalarBarActor->GetPositionCoordinate()->
@ -103,7 +103,7 @@ SMESH_ScalarBarActor::SMESH_ScalarBarActor() {
// Customization of the vtkScalarBarActor to show distribution histogram.
myDistribution = vtkPolyData::New();
myDistributionMapper = vtkPolyDataMapper2D::New();
myDistributionMapper->SetInput(this->myDistribution);
myDistributionMapper->SetInputData(this->myDistribution);
myDistributionActor = vtkActor2D::New();
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 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 NbElementsOfGeom(SMDSAbs_GeometryType geom) const;
int NbNodes() const { return myNbNodes; }
int Nb0DElements() const { return myNb0DElements; }
@ -230,47 +234,47 @@ inline void // RemoveVolume
SMDS_MeshInfo::RemoveVolume(const SMDS_MeshElement* el)
{ if ( el->IsPoly() ) --myNbPolyhedrons; else remove( el ); }
inline int // NbEdges
inline int // NbEdges
SMDS_MeshInfo::NbEdges (SMDSAbs_ElementOrder order) const
{ return order == ORDER_ANY ? myNbEdges+myNbQuadEdges : order == ORDER_LINEAR ? myNbEdges : myNbQuadEdges; }
inline int // NbFaces
inline int // NbFaces
SMDS_MeshInfo::NbFaces (SMDSAbs_ElementOrder order) const
{ return NbTriangles(order)+NbQuadrangles(order)+(order == ORDER_QUADRATIC ? 0 : myNbPolygons); }
inline int // NbTriangles
inline int // NbTriangles
SMDS_MeshInfo::NbTriangles (SMDSAbs_ElementOrder order) const
{ return order == ORDER_ANY ? myNbTriangles+myNbQuadTriangles : order == ORDER_LINEAR ? myNbTriangles : myNbQuadTriangles; }
inline int // NbQuadrangles
inline int // NbQuadrangles
SMDS_MeshInfo::NbQuadrangles(SMDSAbs_ElementOrder order) const
{ 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
{ 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
{ return order == ORDER_ANY ? myNbTetras+myNbQuadTetras : order == ORDER_LINEAR ? myNbTetras : myNbQuadTetras; }
inline int // NbHexas
inline int // NbHexas
SMDS_MeshInfo::NbHexas (SMDSAbs_ElementOrder order) const
{ 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
{ return order == ORDER_ANY ? myNbPyramids+myNbQuadPyramids : order == ORDER_LINEAR ? myNbPyramids : myNbQuadPyramids; }
inline int // NbPrisms
inline int // NbPrisms
SMDS_MeshInfo::NbPrisms (SMDSAbs_ElementOrder order) const
{ return order == ORDER_ANY ? myNbPrisms+myNbQuadPrisms : order == ORDER_LINEAR ? myNbPrisms : myNbQuadPrisms; }
inline int // NbHexPrisms
inline int // NbHexPrisms
SMDS_MeshInfo::NbHexPrisms (SMDSAbs_ElementOrder order) const
{ return order == ORDER_ANY ? myNbHexPrism : order == ORDER_LINEAR ? myNbHexPrism : 0; }
inline int // NbElements
inline int // NbElements
SMDS_MeshInfo::NbElements(SMDSAbs_ElementType type) const
{
int nb = 0;
@ -305,7 +309,7 @@ SMDS_MeshInfo::NbElements(SMDSAbs_ElementType type) const
return nb;
}
int // NbEntities
inline int // NbEntities
SMDS_MeshInfo::NbEntities(SMDSAbs_EntityType type) const
{
switch (type) {
@ -338,7 +342,44 @@ SMDS_MeshInfo::NbEntities(SMDSAbs_EntityType type) const
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)
{
switch (geomType) {

5
src/SMDS/SMDS_UnstructuredGrid.cxx
View File

@ -87,7 +87,8 @@ unsigned long SMDS_UnstructuredGrid::GetMTime()
MESSAGE("vtkUnstructuredGrid::GetMTime: " << mtime);
return mtime;
}
// OUV_PORTING_VTK6: seems to be useless
/*
void SMDS_UnstructuredGrid::Update()
{
MESSAGE("SMDS_UnstructuredGrid::Update");
@ -99,7 +100,7 @@ void SMDS_UnstructuredGrid::UpdateInformation()
MESSAGE("SMDS_UnstructuredGrid::UpdateInformation");
return vtkUnstructuredGrid::UpdateInformation();
}
*/
vtkPoints* SMDS_UnstructuredGrid::GetPoints()
{
// 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,
int newCellSize);
virtual unsigned long GetMTime();
virtual void Update();
virtual void UpdateInformation();
// OUV_PORTING_VTK6: seems to be useless
//virtual void Update();
//virtual void UpdateInformation();
virtual vtkPoints *GetPoints();
//#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 };
/*
// 13
// N5+-----+-----+N6
// /| /|
// 12+ | 14+ |
// / | / |
// N4+-----+-----+N7 | QUADRATIC
// | | 15 | | HEXAHEDRON
// | | | |
// | 17+ | +18
// | | | |
// | | | |
// | | | |
// 16+ | +19 |
// | | | |
// | | 9 | |
// | N1+-----+-|---+N2
// | / | /
// | +8 | +10
// |/ |/
// N0+-----+-----+N3
// 11
// 13
// N5+-----+-----+N6 +-----+-----+
// /| /| /| /|
// 12+ | 14+ | + | +25 + |
// / | / | / | / |
// N4+-----+-----+N7 | QUADRATIC +-----+-----+ | Central nodes
// | | 15 | | HEXAHEDRON | | | | of tri-quadratic
// | | | | | | | | HEXAHEDRON
// | 17+ | +18 | + 22+ | +
// | | | | |21 | | |
// | | | | | + | 26+ | + |
// | | | | | | |23 |
// 16+ | +19 | + | +24 + |
// | | | | | | | |
// | | 9 | | | | | |
// | N1+-----+-|---+N2 | +-----+-|---+
// | / | / | / | /
// | +8 | +10 | + 20+ | +
// |/ |/ |/ |/
// N0+-----+-----+N3 +-----+-----+
// 11
*/
static int QuadHexa_F [6][9] = { // FORWARD
{ 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++;
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
//
const int id = elem->GetID();
const int nbNodes = elem->NbNodes();
const SMDSAbs_ElementType aType = elem->GetType();
const SMDSAbs_EntityType aGeomType = elem->GetEntityType();
const int id = elem->GetID();
const int nbNodes = elem->NbCornerNodes();
const SMDSAbs_ElementType aType = elem->GetType();
nodes.assign(elem->begin_nodes(), elem->end_nodes());
if ( aGeomType == SMDSEntity_Polyhedra )
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);
break;
case SMDSEntity_Hexa:
case SMDSEntity_Quad_Hexa:
case SMDSEntity_TriQuad_Hexa:
NewElem = theHelper.AddVolume(nodes[0], nodes[1], nodes[2], nodes[3],
nodes[4], nodes[5], nodes[6], nodes[7], id, theForce3d);
break;
@ -9661,18 +9675,20 @@ int SMESH_MeshEditor::convertElemToQuadratic(SMESHDS_SubMesh * theSm,
}
return nbElem;
}
//=======================================================================
//function : ConvertToQuadratic
//purpose :
//=======================================================================
void SMESH_MeshEditor::ConvertToQuadratic(const bool theForce3d)
void SMESH_MeshEditor::ConvertToQuadratic(const bool theForce3d, const bool theToBiQuad)
{
SMESHDS_Mesh* meshDS = GetMeshDS();
SMESH_MesherHelper aHelper(*myMesh);
aHelper.SetIsQuadratic( true );
aHelper.SetIsBiQuadratic( theToBiQuad );
aHelper.SetElementsOnShape(true);
int nbCheckedElems = 0;
if ( myMesh->HasShapeToMesh() )
@ -9714,10 +9730,14 @@ void SMESH_MeshEditor::ConvertToQuadratic(const bool theForce3d)
while(aFaceItr->more())
{
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 SMDSAbs_EntityType type = face->GetEntityType();
vector<const SMDS_MeshNode *> nodes ( face->begin_nodes(), face->end_nodes());
meshDS->RemoveFreeElement(face, smDS, /*fromGroups=*/false);
@ -9743,8 +9763,12 @@ void SMESH_MeshEditor::ConvertToQuadratic(const bool theForce3d)
const SMDS_MeshVolume* volume = aVolumeItr->next();
if(!volume || volume->IsQuadratic() ) continue;
const int id = volume->GetID();
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());
if ( type == SMDSEntity_Polyhedra )
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 );
break;
case SMDSEntity_Hexa:
case SMDSEntity_Quad_Hexa:
case SMDSEntity_TriQuad_Hexa:
NewVolume = aHelper.AddVolume(nodes[0], nodes[1], nodes[2], nodes[3],
nodes[4], nodes[5], nodes[6], nodes[7], id, theForce3d);
break;
@ -9795,7 +9821,8 @@ 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;
@ -9822,8 +9849,19 @@ void SMESH_MeshEditor::ConvertToQuadratic(const bool theForce3d,
const SMDS_MeshElement* e = invIt->next();
if ( e->IsQuadratic() )
{
quadAdjacentElems[ e->GetType() ].insert( e );
continue;
bool alreadyOK;
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 )
{
@ -9845,6 +9883,7 @@ void SMESH_MeshEditor::ConvertToQuadratic(const bool theForce3d,
SMESH_MesherHelper helper(*myMesh);
helper.SetIsQuadratic( true );
helper.SetIsBiQuadratic( theToBiQuad );
// 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) );
}
// 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;
for ( eIt = theElements.begin(); eIt != theElements.end(); ++eIt )
{
const SMDS_MeshElement* elem = *eIt;
if( elem->IsQuadratic() || elem->NbNodes() < 2 || elem->IsPoly() )
if( elem->NbNodes() < 2 || elem->IsPoly() )
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 int id = elem->GetID();
const int nbNodes = elem->NbCornerNodes();
vector<const SMDS_MeshNode *> nodes ( elem->begin_nodes(), elem->end_nodes());
if ( !smDS || !smDS->Contains( elem ))
@ -9886,7 +9939,7 @@ void SMESH_MeshEditor::ConvertToQuadratic(const bool theForce3d,
meshDS->RemoveFreeElement(elem, smDS, /*fromGroups=*/false);
SMDS_MeshElement * newElem = 0;
switch( nodes.size() )
switch( nbNodes )
{
case 4: // cases for most frequently used element types go first (for optimization)
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& GetLastCreatedElems() const { return myLastCreatedElems; }
void CrearLastCreated();
SMESH_ComputeErrorPtr & GetError() { return myError; }
/*!
@ -492,15 +491,15 @@ public:
// insert theNodesToInsert into all volumes, containing link
// theBetweenNode1 - theBetweenNode2, between theBetweenNode1 and theBetweenNode2.
void ConvertToQuadratic(const bool theForce3d);
void ConvertToQuadratic(const bool theForce3d, TIDSortedElemSet& theElements);
// Converts all mesh to quadratic one, deletes old elements, replacing
// them with quadratic ones with the same id.
void ConvertToQuadratic(const bool theForce3d, const bool theToBiQuad);
void ConvertToQuadratic(const bool theForce3d,
TIDSortedElemSet& theElements, const bool theToBiQuad);
// 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
// middle of the line segments connecting start and end node of a mesh
// element
// middle of the line segments connecting start and end node of a mesh element.
// 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();
void ConvertFromQuadratic(TIDSortedElemSet& theElements);
@ -625,7 +624,6 @@ public:
bool toAddExistingBondary = false,
bool aroundElements = false);
private:
/*!

478
src/SMESH/SMESH_MesherHelper.cxx
View File

@ -81,7 +81,11 @@ namespace {
//================================================================================
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)
{
myPar1[0] = myPar2[0] = myPar1[1] = myPar2[1] = 0;
@ -934,11 +938,18 @@ bool SMESH_MesherHelper::CheckNodeU(const TopoDS_Edge& E,
//function : GetMediumPos
//purpose : Return index and type of the shape (EDGE or FACE only) to
// 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,
const SMDS_MeshNode* n2)
std::pair<int, TopAbs_ShapeEnum>
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;
int shapeID = -1;
TopoDS_Shape shape;
@ -1009,9 +1020,157 @@ std::pair<int, TopAbs_ShapeEnum> SMESH_MesherHelper::GetMediumPos(const SMDS_Mes
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
//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,
@ -1041,7 +1200,7 @@ const SMDS_MeshNode* SMESH_MesherHelper::GetMediumNode(const SMDS_MeshNode* n1,
TopoDS_Face F; gp_XY uv[2];
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
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_Pnt P = S->Value( UV.X(), UV.Y() ).Transformed(loc);
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));
return n12;
}
@ -1112,7 +1272,8 @@ const SMDS_MeshNode* SMESH_MesherHelper::GetMediumNode(const SMDS_MeshNode* n1,
gp_Pnt P = C->Value( U );
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));
return n12;
}
@ -1125,21 +1286,24 @@ const SMDS_MeshNode* SMESH_MesherHelper::GetMediumNode(const SMDS_MeshNode* n1,
double z = ( n1->Z() + n2->Z() )/2.;
n12 = meshDS->AddNode(x,y,z);
if ( !F.IsNull() )
if ( mySetElemOnShape )
{
gp_XY UV = ( uv[0] + uv[1] ) / 2.;
CheckNodeUV( F, n12, UV, 2*BRep_Tool::Tolerance( F ), /*force=*/true);
meshDS->SetNodeOnFace(n12, faceID, UV.X(), UV.Y() );
}
else if ( !E.IsNull() )
{
double U = ( u[0] + u[1] ) / 2.;
CheckNodeU( E, n12, U, 2*BRep_Tool::Tolerance( E ), /*force=*/true);
meshDS->SetNodeOnEdge(n12, edgeID, U);
}
else if ( myShapeID > 0 )
{
meshDS->SetNodeInVolume(n12, myShapeID);
if ( !F.IsNull() )
{
gp_XY UV = ( uv[0] + uv[1] ) / 2.;
CheckNodeUV( F, n12, UV, 2*BRep_Tool::Tolerance( F ), /*force=*/true);
meshDS->SetNodeOnFace(n12, faceID, UV.X(), UV.Y() );
}
else if ( !E.IsNull() )
{
double U = ( u[0] + u[1] ) / 2.;
CheckNodeU( E, n12, U, 2*BRep_Tool::Tolerance( E ), /*force=*/true);
meshDS->SetNodeOnEdge(n12, edgeID, U);
}
else if ( myShapeID > 0 )
{
meshDS->SetMeshElementOnShape(n12, myShapeID);
}
}
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()->SetNodeOnEdge(n12, edges[iOkEdge], u);
if ( mySetElemOnShape )
GetMeshDS()->SetNodeOnEdge(n12, edges[iOkEdge], u);
myTLinkNodeMap.insert( make_pair( SMESH_TLink(n1,n2), n12 ));
@ -1319,7 +1484,7 @@ SMDS_MeshFace* SMESH_MesherHelper::AddFace(const SMDS_MeshNode* n1,
//=======================================================================
//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,
@ -1362,11 +1527,21 @@ SMDS_MeshFace* SMESH_MesherHelper::AddFace(const SMDS_MeshNode* n1,
const SMDS_MeshNode* n23 = GetMediumNode(n2,n3,force3d);
const SMDS_MeshNode* n34 = GetMediumNode(n3,n4,force3d);
const SMDS_MeshNode* n41 = GetMediumNode(n4,n1,force3d);
if(id)
elem = meshDS->AddFaceWithID(n1, n2, n3, n4, n12, n23, n34, n41, id);
if(myCreateBiQuadratic)
{
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
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 )
meshDS->SetMeshElementOnShape( elem, myShapeID );
@ -1550,7 +1725,7 @@ SMDS_MeshVolume* SMESH_MesherHelper::AddVolume(const SMDS_MeshNode* n1,
//=======================================================================
//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,
@ -1587,15 +1762,75 @@ SMDS_MeshVolume* SMESH_MesherHelper::AddVolume(const SMDS_MeshNode* n1,
const SMDS_MeshNode* n26 = GetMediumNode(n2,n6,force3d);
const SMDS_MeshNode* n37 = GetMediumNode(n3,n7,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)
elem = meshDS->AddVolumeWithID(n1, n2, n3, n4, n5, n6, n7, n8,
n12, n23, n34, n41, n56, n67,
n78, n85, n15, n26, n37, n48, id);
vector<gp_XYZ> pointsOnShapes( SMESH_Block::ID_Shell );
pointsOnShapes[ SMESH_Block::ID_V000 ] = SMESH_TNodeXYZ( n4 );
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
elem = meshDS->AddVolume(n1, n2, n3, n4, n5, n6, n7, n8,
n12, n23, n34, n41, n56, n67,
n78, n85, n15, n26, n37, n48);
{
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, 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 )
meshDS->SetMeshElementOnShape( elem, myShapeID );
@ -1720,10 +1955,11 @@ bool SMESH_MesherHelper::IsSameElemGeometry(const SMESHDS_SubMesh* smDS,
if ( !smDS ) return nullSubMeshRes;
SMDS_ElemIteratorPtr elemIt = smDS->GetElements();
while ( elemIt->more() )
if ( elemIt->next()->GetGeomType() != shape )
while ( elemIt->more() ) {
const SMDS_MeshElement* e = elemIt->next();
if ( e->GetGeomType() != shape )
return false;
}
return true;
}
@ -1898,7 +2134,8 @@ namespace
//================================================================================
bool isCornerOfStructure( const SMDS_MeshNode* n,
const SMESHDS_SubMesh* faceSM )
const SMESHDS_SubMesh* faceSM,
SMESH_MesherHelper& faceAnalyser )
{
int nbFacesInSM = 0;
if ( n ) {
@ -1906,7 +2143,14 @@ namespace
while ( fIt->more() )
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;
int nbWires = SMESH_Block::GetOrderedEdges( TopoDS::Face( faceSM->GetSubShape() ),
edges, nbEdgesInWires );
if ( nbWires != 1 )
if ( nbWires != 1 || nbEdgesInWires.front() != 4 )
return false;
// algo: find corners of a structure and then analyze nb of faces and
// length of structure sides
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
// (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();
do {
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 ) {
edges.splice( edges.end(), edges, edges.begin() );
--nbRemainEdges;
@ -1963,16 +2210,13 @@ bool SMESH_MesherHelper::IsStructured( SMESH_subMesh* faceSM )
list< const SMDS_MeshNode* > edgeNodes;
map< double, const SMDS_MeshNode* >::iterator u2n = u2Nodes.begin();
if ( !nodes.empty() && nodes.back() == u2n->second )
++u2n;
map< double, const SMDS_MeshNode* >::iterator u2nEnd = --u2Nodes.end();
if ( nodes.empty() || nodes.back() != u2nEnd->second )
++u2nEnd;
for ( ; u2n != u2nEnd; ++u2n )
for ( ; u2n != u2Nodes.end(); ++u2n )
edgeNodes.push_back( u2n->second );
if ( edge->Orientation() == TopAbs_REVERSED )
edgeNodes.reverse();
if ( !nodes.empty() && nodes.back() == edgeNodes.front() )
edgeNodes.pop_front();
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 )
{
++nbEdges;
if ( isCornerOfStructure( *n, fSM )) {
if ( isCornerOfStructure( *n, fSM, faceAnalyser )) {
nbEdgesInSide.push_back( nbEdges );
nbEdges = 0;
}
@ -2488,7 +2732,7 @@ namespace { // Structures used by FixQuadraticElements()
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
{
@ -3857,11 +4101,13 @@ void SMESH_MesherHelper::FixQuadraticElements(SMESH_ComputeErrorPtr& compError,
// 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;
// not treat boundary of volumic submesh
bool checkUV;
// not to treat boundary of volumic sub-mesh.
int isInside = ( elemType == SMDSAbs_Volume && volumeOnly ) ? 1 : 0;
for ( ; isInside < 2; ++isInside ) {
for ( ; isInside < 2; ++isInside )
{
MSG( "--------------- LOOP (inside=" << isInside << ") ------------------");
SMDS_TypeOfPosition pos = isInside ? SMDS_TOP_3DSPACE : SMDS_TOP_FACE;
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;
TopoDS_Face face;
bool checkUV = true;
if ( !isInside )
{
// 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
// -------------
TIDSortedElemSet biQuadQuas, triQuadHexa;
const SMDS_MeshElement *biQuadQua, *triQuadHex;
const bool toFixCentralNodes = ( myMesh->NbBiQuadQuadrangles() +
myMesh->NbTriQuadraticHexas() );
for ( pLink = links.begin(); pLink != links.end(); ++pLink ) {
if ( pLink->IsMoved() ) {
if ( pLink->IsMoved() )
{
gp_Pnt p = pLink->MiddlePnt() + pLink->Move();
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
{
public:
public:
// ---------- PUBLIC UTILITIES ----------
/*!
@ -146,6 +146,36 @@ public:
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
* \param shape - the shape
@ -214,8 +244,19 @@ public:
/*!
* \brief Set order of elements to create without calling IsQuadraticSubMesh()
*/
/*!
* \brief Set myCreateQuadratic flag
*/
void SetIsQuadratic(const bool theBuildQuadratic)
{ myCreateQuadratic = theBuildQuadratic; }
/*!
* \brief Set myCreateBiQuadratic flag
*/
void SetIsBiQuadratic(const bool theBuildBiQuadratic)
{ myCreateBiQuadratic = theBuildBiQuadratic; }
/*!
* \brief Return myCreateQuadratic flag
*/
@ -226,6 +267,11 @@ public:
*/
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
* \param error - container of fixed distorted elements
@ -276,7 +322,7 @@ public:
const int id=0,
const bool force3d = false);
/*!
* Creates quadratic or linear quadrangle
* Creates bi-quadratic, quadratic or linear quadrangle
*/
SMDS_MeshFace* AddFace(const SMDS_MeshNode* n1,
const SMDS_MeshNode* n2,
@ -284,7 +330,6 @@ public:
const SMDS_MeshNode* n4,
const int id = 0,
const bool force3d = false);
/*!
* Creates polygon, with additional nodes in quadratic mesh
*/
@ -322,7 +367,7 @@ public:
const int id = 0,
const bool force3d = true);
/*!
* Creates quadratic or linear hexahedron
* Creates bi-quadratic, quadratic or linear hexahedron
*/
SMDS_MeshVolume* AddVolume(const SMDS_MeshNode* n1,
const SMDS_MeshNode* n2,
@ -525,11 +570,27 @@ public:
const SMDS_MeshNode* GetMediumNode(const SMDS_MeshNode* n1,
const SMDS_MeshNode* n2,
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
*/
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
*/
@ -561,13 +622,13 @@ public:
virtual ~SMESH_MesherHelper();
protected:
protected:
/*!
* \brief Select UV on either of 2 pcurves of a seam edge, closest to the given UV
* \param uv1 - UV on the seam
* \param uv2 - UV within a face
* \retval gp_Pnt2d - selected UV
* \param uv1 - UV on the seam
* \param uv2 - UV within a face
* \retval gp_Pnt2d - selected UV
*/
gp_Pnt2d GetUVOnSeam( const gp_Pnt2d& uv1, const gp_Pnt2d& uv2 ) const;
@ -577,10 +638,31 @@ protected:
private:
// Forbiden copy constructor
SMESH_MesherHelper (const SMESH_MesherHelper& theOther) {};
SMESH_MesherHelper (const SMESH_MesherHelper& theOther);
// special map for using during creation of quadratic elements
TLinkNodeMap myTLinkNodeMap;
// key of a map of bi-quadratic face to it's central node
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 > mySeamShapeIds;
@ -597,14 +679,35 @@ protected:
int myShapeID;
bool myCreateQuadratic;
bool myCreateBiQuadratic;
bool mySetElemOnShape;
bool myFixNodeParameters;
std::map< int,bool > myNodePosShapesValidity;
bool toCheckPosOnShape(int shapeID ) 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

96
src/SMESH/SMESH_subMesh.cxx
View File

@ -647,7 +647,7 @@ SMESH_Hypothesis::Hypothesis_Status
int oldAlgoState = _algoState;
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 );
@ -671,7 +671,8 @@ SMESH_Hypothesis::Hypothesis_Status
filter.Or( SMESH_HypoFilter::HasType( algo->GetType()+1 ));
filter.Or( SMESH_HypoFilter::HasType( algo->GetType()+2 ));
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);
if (!algo->NeedDiscreteBoundary())
{
// 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();
}
algoRequiringCleaning = algo;
}
}
@ -990,10 +985,7 @@ SMESH_Hypothesis::Hypothesis_Status
// CLEAN was not called at event REMOVE_ALGO because the algo is not applicable to SOLID.
algo = dynamic_cast<SMESH_Algo*> (anHyp);
if (!algo->NeedDiscreteBoundary())
{
needFullClean = true;
subMeshesSupported = algo->SupportSubmeshes();
}
algoRequiringCleaning = algo;
algo = GetAlgo();
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
ComputeStateEngine( CLEAN );
cleanDependsOn( subMeshesSupported );
cleanDependsOn( algoRequiringCleaning );
ComputeSubMeshStateEngine( CHECK_COMPUTE_STATE );
}
@ -1174,45 +1166,67 @@ SMESH_Hypothesis::Hypothesis_Status
//================================================================================
/*!
* \brief Remove elements from sub-meshes.
* \param keepSupportedsubMeshes - if true, the sub-meshes computed using more
* local algorithms are not cleaned
* \param algoRequiringCleaning - an all-dimensional algorithm whose presence
* 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,
/*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() )
smIt->next()->ComputeStateEngine(CLEAN);
}
else
else if ( algoRequiringCleaning && algoRequiringCleaning->SupportSubmeshes() )
{
SMESHDS_Mesh* meshDS = _father->GetMeshDS();
// find sub-meshes to keep elements on
set< SMESH_subMesh* > smToKeep;
SMESHDS_Mesh* meshDS = _father->GetMeshDS();
TopAbs_ShapeEnum prevShapeType = TopAbs_SHAPE;
bool toKeepPrevShapeType = false;
while ( smIt->more() )
{
SMESH_subMesh* sm = smIt->next();
if ( sm->IsEmpty() ) continue;
// 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 )
sm->ComputeStateEngine(CHECK_COMPUTE_STATE);
if ( !sm->IsEmpty() )
{
SMESH_subMeshIteratorPtr smIt2 = getDependsOnIterator(false,true);
while ( smIt2->more() )
smToKeep.insert( smIt2->next() );
const bool sameShapeType = ( prevShapeType == sm->GetSubShape().ShapeType() );
bool keepSubMeshes = ( sameShapeType && toKeepPrevShapeType );
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
@ -1374,7 +1388,7 @@ bool SMESH_subMesh::ComputeStateEngine(int event)
case MODIF_ALGO_STATE:
algo = GetAlgo();
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 )
_computeState = READY_TO_COMPUTE;
break;
@ -1420,7 +1434,7 @@ bool SMESH_subMesh::ComputeStateEngine(int event)
if (algo)
{
if (!algo->NeedDiscreteBoundary())
cleanDependsOn( algo->SupportSubmeshes() ); // clean sub-meshes with event CLEAN
cleanDependsOn( algo ); // clean sub-meshes with event CLEAN
if ( _algoState == HYP_OK )
_computeState = READY_TO_COMPUTE;
}
@ -1646,7 +1660,7 @@ bool SMESH_subMesh::ComputeStateEngine(int event)
ComputeStateEngine( CLEAN );
algo = GetAlgo();
if (algo && !algo->NeedDiscreteBoundary())
cleanDependsOn( algo->SupportSubmeshes() ); // clean sub-meshes with event CLEAN
cleanDependsOn( algo ); // clean sub-meshes with event CLEAN
break;
case COMPUTE: // nothing to do
break;
@ -1701,7 +1715,7 @@ bool SMESH_subMesh::ComputeStateEngine(int event)
ComputeStateEngine( CLEAN );
algo = GetAlgo();
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)
_computeState = READY_TO_COMPUTE;
else

2
src/SMESH/SMESH_subMesh.hxx
View File

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

14
src/SMESHGUI/SMESHGUI.cxx
View File

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

2
src/SMESHGUI/SMESHGUI.h
View File

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

8
src/SMESHGUI/SMESHGUI_AddMeshElementDlg.cxx
View File

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

10
src/SMESHGUI/SMESHGUI_AddQuadraticElementDlg.cxx
View File

@ -121,7 +121,7 @@ namespace SMESH
vtkUnstructuredGrid* myGrid;
//vtkProperty* myBackProp, *myProp;
//vtkFloatingPointType myRGB[3], myBackRGB[3];
//double myRGB[3], myBackRGB[3];
SALOME_Actor* myFaceOrientation;
vtkPolyDataMapper* myFaceOrientationDataMapper;
@ -140,7 +140,7 @@ namespace SMESH
// Create and display actor
myMapper = vtkDataSetMapper::New();
myMapper->SetInput(myGrid);
myMapper->SetInputData(myGrid);
myPreviewActor = SALOME_Actor::New();
myPreviewActor->PickableOff();
@ -148,7 +148,7 @@ namespace SMESH
myPreviewActor->SetMapper(myMapper);
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 ) );
myProp->SetColor( aRGB[0], aRGB[1], aRGB[2] );
myPreviewActor->SetProperty( myProp );
@ -164,10 +164,10 @@ namespace SMESH
// Orientation of faces
myFaceOrientationFilter = SMESH_FaceOrientationFilter::New();
myFaceOrientationFilter->SetInput(myGrid);
myFaceOrientationFilter->SetInputData(myGrid);
myFaceOrientationDataMapper = vtkPolyDataMapper::New();
myFaceOrientationDataMapper->SetInput(myFaceOrientationFilter->GetOutput());
myFaceOrientationDataMapper->SetInputConnection(myFaceOrientationFilter->GetOutputPort());
myFaceOrientation = SALOME_Actor::New();
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->SetPoint1(theOrientedPlane->myPlaneSource->GetPoint1());
myPlaneSource->SetPoint2(theOrientedPlane->myPlaneSource->GetPoint2());
myPlaneSource->Update();
}
SMESH::OrientedPlane::OrientedPlane(SVTK_ViewWindow* theViewWindow):
@ -132,7 +133,7 @@ void SMESH::OrientedPlane::Init()
// Create and display actor
myMapper = vtkDataSetMapper::New();
myMapper->SetInput(myPlaneSource->GetOutput());
myMapper->SetInputConnection(myPlaneSource->GetOutputPort());
myActor = SALOME_Actor::New();
myActor->VisibilityOff();
@ -140,7 +141,7 @@ void SMESH::OrientedPlane::Init()
myActor->SetInfinitive(true);
myActor->SetMapper(myMapper);
vtkFloatingPointType anRGB[3];
double anRGB[3];
vtkProperty* aProp = vtkProperty::New();
SMESH::GetColor( "SMESH", "fill_color", anRGB[0], anRGB[1], anRGB[2], QColor( 0, 170, 255 ) );
aProp->SetColor(anRGB[0],anRGB[1],anRGB[2]);
@ -208,7 +209,7 @@ SMESH::OrientedPlane* SMESHGUI_ClippingDlg::AddPlane (SMESH::TActorList
SVTK_ViewWindow* theViewWindow,
SMESH::Orientation theOrientation,
double theDistance,
const vtkFloatingPointType theAngle[2])
const double theAngle[2])
{
SMESH::OrientedPlane* aPlane = SMESH::OrientedPlane::New(theViewWindow);
@ -218,13 +219,13 @@ SMESH::OrientedPlane* SMESHGUI_ClippingDlg::AddPlane (SMESH::TActorList
aPlane->SetOrientation(theOrientation);
aPlane->SetDistance(theDistance);
vtkFloatingPointType aNormal[3];
vtkFloatingPointType aDir[2][3] = {{0, 0, 0}, {0, 0, 0}};
double aNormal[3];
double aDir[2][3] = {{0, 0, 0}, {0, 0, 0}};
{
static double aCoeff = vtkMath::Pi()/180.0;
vtkFloatingPointType 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 anU[2] = {cos(aCoeff * theAngle[0]), cos(aCoeff * theAngle[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[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]);
}
vtkFloatingPointType aBounds[6];
vtkFloatingPointType anOrigin[3];
double aBounds[6];
double anOrigin[3];
bool anIsOk = false;
if( theActorList.empty() ) {
@ -284,38 +285,38 @@ SMESH::OrientedPlane* SMESHGUI_ClippingDlg::AddPlane (SMESH::TActorList
aPlane->SetNormal( aNormal );
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[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[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}};
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[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[2] + aNormal[2]};
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[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[2] + aNormal[2]};
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[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[2] + aNormal[2]};
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->SetPoint1(aPnt1[0],aPnt1[1],aPnt1[2]);
aPlaneSource->SetPoint2(aPnt2[0],aPnt2[1],aPnt2[2]);
aPlaneSource->Update();
SMESH::TActorList::iterator anIter = theActorList.begin();
for ( ; anIter != theActorList.end(); anIter++ )
@ -898,18 +900,18 @@ void SMESHGUI_ClippingDlg::SetCurrentPlaneParam()
SMESH::TPlaneData aPlaneData = myPlanes[aCurPlaneIndex];
SMESH::OrientedPlane* aPlane = aPlaneData.Plane.GetPointer();
vtkFloatingPointType aNormal[3];
double aNormal[3];
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;
vtkFloatingPointType aRot[2] = {getRotation1(), getRotation2()};
double aRot[2] = {getRotation1(), getRotation2()};
aPlane->myAngle[0] = aRot[0];
aPlane->myAngle[1] = aRot[1];
vtkFloatingPointType 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 anU[2] = {cos(aCoeff*aRot[0]), cos(aCoeff*aRot[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[1] = aRot[1] > 0? aV[1]: -aV[1];
@ -956,8 +958,8 @@ void SMESHGUI_ClippingDlg::SetCurrentPlaneParam()
SMESH::TActorList anActorList = aPlaneData.ActorList;
vtkFloatingPointType aBounds[6];
vtkFloatingPointType anOrigin[3];
double aBounds[6];
double anOrigin[3];
bool anIsOk = SMESH::ComputeClippingPlaneParameters( anActorList,
aNormal,
getDistance(),
@ -970,38 +972,38 @@ void SMESHGUI_ClippingDlg::SetCurrentPlaneParam()
aPlane->SetNormal( aNormal );
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[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[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}};
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[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[2] + aNormal[2]};
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[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[2] + aNormal[2]};
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[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[2] + aNormal[2]};
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->SetPoint1(aPnt1[0],aPnt1[1],aPnt1[2]);
aPlaneSource->SetPoint2(aPnt2[0],aPnt2[1],aPnt2[2]);
aPlaneSource->Update();
}
if(AutoApplyCheckBox->isChecked())
@ -1148,8 +1151,8 @@ void SMESHGUI_ClippingDlg::dumpPlaneData() const
for ( ; anIter1 != myPlanes.end(); anIter1++, anId++ ) {
SMESH::TPlaneData aPlaneData = *anIter1;
SMESH::TPlane aPlane = aPlaneData.Plane;
vtkFloatingPointType* aNormal = aPlane->GetNormal();
vtkFloatingPointType* anOrigin = aPlane->GetOrigin();
double* aNormal = aPlane->GetNormal();
double* anOrigin = aPlane->GetOrigin();
printf( "Plane N%d:\n", anId );
printf( " Normal = ( %f, %f, %f )\n", aNormal[0], aNormal[1], aNormal[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,
SMESH::Orientation theOrientation,
double theDistance,
const vtkFloatingPointType theAngle[2]);
const double theAngle[2]);
protected:
void keyPressEvent( QKeyEvent* );

4
src/SMESHGUI/SMESHGUI_ComputeDlg.cxx
View File

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

51
src/SMESHGUI/SMESHGUI_ConvToQuadDlg.cxx
View File

@ -27,6 +27,8 @@
//
#include "SMESHGUI_ConvToQuadDlg.h"
#include "SMESHGUI_ConvToQuadOp.h"
// Qt includes
#include <QGroupBox>
#include <QCheckBox>
@ -62,14 +64,17 @@ SMESHGUI_ConvToQuadDlg::SMESHGUI_ConvToQuadDlg()
aBGLayout->setMargin(MARGIN);
aBGLayout->setSpacing(SPACING);
myRB1 = new QRadioButton( tr( "RADIOBTN_1" ), myBGBox );
myRB2 = new QRadioButton( tr( "RADIOBTN_2" ), myBGBox );
myRB2Lin = new QRadioButton( tr( "RADIOBTN_1" ), myBGBox );
myRB2Quad = new QRadioButton( tr( "RADIOBTN_2" ), myBGBox );
myRB2BiQua = new QRadioButton( tr( "RADIOBTN_3" ), myBGBox );
aBGLayout->addWidget(myRB1);
aBGLayout->addWidget(myRB2);
myBG->addButton(myRB1, 0);
myBG->addButton(myRB2, 1);
myRB1->setChecked( true );
aBGLayout->addWidget(myRB2Lin);
aBGLayout->addWidget(myRB2Quad);
aBGLayout->addWidget(myRB2BiQua);
myBG->addButton(myRB2Lin, 0);
myBG->addButton(myRB2Quad, 1);
myBG->addButton(myRB2BiQua, 2);
myRB2Lin->setChecked( true );
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
{
return !myMedNdsOnGeom->isChecked();
@ -133,27 +143,32 @@ bool SMESHGUI_ConvToQuadDlg::isWarningShown()
void SMESHGUI_ConvToQuadDlg::SetEnabledControls( const bool theCheck )
{
//myBGBox->setEnabled( theCheck );
myRB1->setEnabled( theCheck );
myRB2->setEnabled( theCheck );
myRB2Lin->setEnabled( theCheck );
myRB2Quad->setEnabled( theCheck );
myRB2BiQua->setEnabled( theCheck );
myMedNdsOnGeom->setEnabled( theCheck );
//setButtonEnabled( theCheck, QtxDialog::OK | QtxDialog::Apply );
}
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 );
myRB1->setEnabled( !theCheck );
myRB1->setChecked( true );
myRB2Lin->setChecked( true );
myRB2Quad->setChecked( false );
}
else
{
myRB1->setEnabled( theCheck );
myRB2->setEnabled( !theCheck );
myRB2->setChecked( true );
myRB2Lin->setChecked( false );
myRB2Quad->setChecked( true );
}
myRB2BiQua->setChecked( false );
myMedNdsOnGeom->setEnabled( theCheck );
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
void ShowWarning(bool);
bool isWarningShown();
bool IsBiQuadratic() const;
signals:
void onClicked( int );
@ -64,8 +65,9 @@ private:
QCheckBox* myMedNdsOnGeom;
QGroupBox* myBGBox;
QButtonGroup* myBG;
QRadioButton* myRB1;
QRadioButton* myRB2;
QRadioButton* myRB2Lin;
QRadioButton* myRB2Quad;
QRadioButton* myRB2BiQua;
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 );
return;
}
MeshType meshType = ConsistMesh( idSource );
if( meshType == SMESHGUI_ConvToQuadOp::Quadratic )
{
myDlg->SetEnabledRB( 0, false );
}
else if( meshType == SMESHGUI_ConvToQuadOp::Linear )
{
myDlg->SetEnabledRB( 1, false );
}
else
{
myDlg->SetEnabledControls( true );
}
SMESH::SMESH_Mesh_var mesh = idSource->GetMesh();
bool hasGeom = mesh->HasShapeToMesh();
MeshDestinationType meshTgtType = DestinationMesh( idSource );
myDlg->SetEnabledRB( meshTgtType, hasGeom && ( meshTgtType & ( BiQuadratic | Quadratic )));
// show warning on non-conformal result mesh
if ( ! idSource->_is_nil() )
@ -166,8 +157,9 @@ void SMESHGUI_ConvToQuadOp::selectionDone()
{
SMESH::SMESH_Mesh_var mesh = idSource->GetMesh();
idSource = SMESH::SMESH_IDSource::_narrow( mesh );
MeshType fullMeshType = ConsistMesh( idSource );
toShow = ( fullMeshType != Comp );
bool isMixOrder;
DestinationMesh( idSource, &isMixOrder );
toShow = !isMixOrder;
}
myDlg->ShowWarning( toShow );
}
@ -241,17 +233,20 @@ bool SMESHGUI_ConvToQuadOp::onApply()
SMESH::SMESH_MeshEditor_var aEditor = mesh->GetMeshEditor();
aResult = true;
SMESH::SMESH_Mesh_var sourceMesh = SMESH::SObjectToInterface<SMESH::SMESH_Mesh>( pObj );
if( !myDlg->CurrentRB() )
if( myDlg->CurrentRB()==1 || myDlg->CurrentRB()==2)
{
bool force3d = true;
if( myDlg->IsEnabledCheck() )
force3d = myDlg->IsMediumNdsOnGeom();
if ( sourceMesh->_is_nil() )
aEditor->ConvertToQuadraticObject( force3d, idSource );
else
aEditor->ConvertToQuadratic( force3d );
bool theToBiQuad = myDlg->IsBiQuadratic();
if ( sourceMesh->_is_nil() ) {
if ( theToBiQuad ) aEditor->ConvertToBiQuadratic ( force3d, idSource );
else aEditor->ConvertToQuadraticObject( force3d, idSource );
}
else {
if ( theToBiQuad ) aEditor->ConvertToBiQuadratic( force3d, sourceMesh );
else aEditor->ConvertToQuadratic ( force3d );
}
if ( !force3d )
{
SMESH::ComputeError_var error = aEditor->GetLastError();
@ -259,9 +254,9 @@ bool SMESHGUI_ConvToQuadOp::onApply()
{
if ( myBadElemsPreview ) delete myBadElemsPreview; // viewWindow may change
myBadElemsPreview = new SMESHGUI_MeshEditPreview( viewWindow() );
vtkFloatingPointType aPointSize = SMESH::GetFloat("SMESH:node_size",3);
vtkFloatingPointType aLineWidth = SMESH::GetFloat("SMESH:element_width",1);
double aPointSize = SMESH::GetFloat("SMESH:node_size",3);
double aLineWidth = SMESH::GetFloat("SMESH:element_width",1);
vtkProperty* prop = vtkProperty::New();
prop->SetLineWidth( aLineWidth * 3 );
prop->SetPointSize( aPointSize * 3 );
@ -325,12 +320,23 @@ void SMESHGUI_ConvToQuadOp::onWarningWinFinished()
//================================================================================
/*! 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();
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 ] ||
nbElemOfType[SMDSEntity_Quad_Triangle ] ||
nbElemOfType[SMDSEntity_Quad_Quadrangle] ||
@ -347,9 +353,25 @@ SMESHGUI_ConvToQuadOp::MeshType SMESHGUI_ConvToQuadOp::ConsistMesh( const SMESH:
nbElemOfType[SMDSEntity_Pyramid ] ||
nbElemOfType[SMDSEntity_Penta ] );
if ( hasQuad && hasLin )
return Comp;
return hasQuad ? Quadratic : Linear;
int tgtType = 0;
if ( hasBiQuad )
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 )
@ -364,7 +386,7 @@ void SMESHGUI_ConvToQuadOp::ConnectRadioButtons( int id )
bool hasGeom = mesh->HasShapeToMesh();
if( id || !hasGeom )
if( id==0 || !hasGeom )
myDlg->SetEnabledCheck( false );
else
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
public:
enum MeshType{ Comp = 0, Linear, Quadratic };
enum MeshDestinationType { Linear = 1, Quadratic = 2, BiQuadratic = 4 };
public:
SMESHGUI_ConvToQuadOp();
@ -56,7 +56,8 @@ protected:
virtual void startOperation();
virtual void selectionDone();
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:
virtual bool onApply();

6
src/SMESHGUI/SMESHGUI_CreatePolyhedralVolumeDlg.cxx
View File

@ -106,7 +106,7 @@ namespace SMESH
// Create and display actor
myMapper = vtkDataSetMapper::New();
myMapper->SetInput( myGrid );
myMapper->SetInputData( myGrid );
myPreviewActor = SALOME_Actor::New();
myPreviewActor->PickableOff();
@ -114,12 +114,12 @@ namespace SMESH
myPreviewActor->SetMapper( myMapper );
myPreviewActor->SetRepresentation( 3 );
vtkFloatingPointType anRGB[3];
double anRGB[3];
vtkProperty* aProp = vtkProperty::New();
GetColor( "SMESH", "selection_element_color", anRGB[0], anRGB[1], anRGB[2], QColor( 0, 170, 255 ) );
aProp->SetColor(anRGB[0],anRGB[1],anRGB[2]);
myPreviewActor->SetProperty( aProp );
vtkFloatingPointType aFactor,aUnits;
double aFactor,aUnits;
myPreviewActor->SetResolveCoincidentTopology(true);
myPreviewActor->GetPolygonOffsetParameters(aFactor,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_BelongToGenSurface ||
aCriterion == SMESH::FT_ElemGeomType ||
aCriterion == SMESH::FT_EntityType ||
aCriterion == SMESH::FT_CoplanarFaces ||
aCriterion == SMESH::FT_LyingOnGeom)
{
@ -1253,6 +1254,8 @@ void SMESHGUI_FilterTable::GetCriterion (const int theRow,
}
else if ( aCriterionType == SMESH::FT_ElemGeomType )
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 )
theCriterion.ThresholdID = aTable->text(theRow, 2).toLatin1().constData();
else if ( aCriterionType != SMESH::FT_RangeOfIds &&
@ -1329,6 +1332,11 @@ void SMESHGUI_FilterTable::SetCriterion (const int theRow,
ComboItem* typeBox = (ComboItem*)aTable->item(theRow, 2);
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 )
{
aTable->item( theRow, 2 )->setText( QString( theCriterion.ThresholdID ) );
@ -1651,10 +1659,40 @@ static QList<int> geomTypes( const int theType )
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()
// Purpose : Provides reaction on change of criterion
//=======================================================================
void SMESHGUI_FilterTable::onCriterionChanged (const int row, const int col, const int 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_MaxElementLength2D ||
aCriterionType == SMESH::FT_MaxElementLength3D ||
aCriterionType == SMESH::FT_Volume3D;
aCriterionType == SMESH::FT_Volume3D ||
aCriterionType == SMESH::FT_EntityType;
int aPrecision = 0;
if ( anIsDoubleCriterion ) {
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) ||
(aCriterionType != SMESH::FT_ElemGeomType && isComboItem) ||
(aCriterionType != SMESH::FT_EntityType && isComboItem) ||
(aCriterionType != SMESH::FT_MultiConnection && isIntSpinItem) ||
(!anIsDoubleCriterion && isDoubleSpinItem) ||
anIsPrecisionChanged )
@ -1722,6 +1761,7 @@ void SMESHGUI_FilterTable::onCriterionChanged (const int row, const int col, con
}
if ( (aCriterionType == SMESH::FT_GroupColor && !clrBtn) ||
(aCriterionType == SMESH::FT_ElemGeomType && !isComboItem) ||
(aCriterionType == SMESH::FT_EntityType && !isComboItem) ||
(aCriterionType == SMESH::FT_MultiConnection && !isIntSpinItem) ||
(anIsDoubleCriterion && !isDoubleSpinItem) ||
anIsPrecisionChanged )
@ -1742,6 +1782,18 @@ void SMESHGUI_FilterTable::onCriterionChanged (const int row, const int col, con
ComboItem* typeBox = new ComboItem( typeNames );
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 ) {
IntSpinItem* intSpin = new IntSpinItem( 0 );
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_GroupColor ||
aCriterionType == SMESH::FT_ElemGeomType ||
aCriterionType == SMESH::FT_CoplanarFaces
aCriterionType == SMESH::FT_CoplanarFaces ||
aCriterionType == SMESH::FT_EntityType
)
{
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->setEditable(aCriterionType == SMESH::FT_GroupColor ||
aCriterionType == SMESH::FT_ElemGeomType ||
aCriterionType == SMESH::FT_EntityType ||
aCriterionType == SMESH::FT_CoplanarFaces, row, 2);
aTable->blockSignals( isSignalsBlocked );
}
@ -1802,7 +1856,8 @@ void SMESHGUI_FilterTable::onCriterionChanged (const int row, const int col, con
aTable->setEditable(true, row, 2);
}
else if (aCriterionType == SMESH::FT_GroupColor ||
aCriterionType == SMESH::FT_ElemGeomType)
aCriterionType == SMESH::FT_ElemGeomType ||
aCriterionType == SMESH::FT_EntityType)
{
if (!aTable->isEditable(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_ElemGeomType ] = tr("GEOM_TYPE");
aCriteria[ SMESH::FT_EqualEdges ] = tr("EQUAL_EDGE");
aCriteria[ SMESH::FT_EntityType ] = tr("ENTITY_TYPE");
}
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_CoplanarFaces ] = tr("COPLANAR_FACES");
aCriteria[ SMESH::FT_EqualFaces ] = tr("EQUAL_FACE");
aCriteria[ SMESH::FT_EntityType ] = tr("ENTITY_TYPE");
}
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_ElemGeomType ] = tr("GEOM_TYPE");
aCriteria[ SMESH::FT_EqualVolumes ] = tr("EQUAL_VOLUME");
aCriteria[ SMESH::FT_EntityType ] = tr("ENTITY_TYPE");
}
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();
// create actor
vtkDataSetMapper* aMapper = vtkDataSetMapper::New();
aMapper->SetInput( aGrid );
aMapper->SetInputData( aGrid );
aGrid->Delete();
myPreview = SALOME_Actor::New();
myPreview->PickableOff();
@ -879,7 +879,7 @@ void SMESHGUI_BoundingBox::createPreview( double minX, double maxX, double minY,
aCells->Delete();
// create actor
vtkDataSetMapper* aMapper = vtkDataSetMapper::New();
aMapper->SetInput( aGrid );
aMapper->SetInputData( aGrid );
aGrid->Delete();
myPreview = SALOME_Actor::New();
myPreview->PickableOff();

10
src/SMESHGUI/SMESHGUI_MergeDlg.cxx
View File

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

6
src/SMESHGUI/SMESHGUI_MeshEditPreview.cxx
View File

@ -66,19 +66,19 @@ SMESHGUI_MeshEditPreview::SMESHGUI_MeshEditPreview(SVTK_ViewWindow* theViewWindo
// Create and display actor
vtkDataSetMapper* aMapper = vtkDataSetMapper::New();
aMapper->SetInput( myGrid );
aMapper->SetInputData( myGrid );
myPreviewActor = SALOME_Actor::New();
myPreviewActor->SetInfinitive(true);
myPreviewActor->VisibilityOn();
myPreviewActor->PickableOff();
vtkFloatingPointType aFactor,aUnits;
double aFactor,aUnits;
myPreviewActor->SetResolveCoincidentTopology(true);
myPreviewActor->GetPolygonOffsetParameters(aFactor,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 ) );
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
vtkDataSetMapper* aMapper = vtkDataSetMapper::New();
aMapper->SetInput(aGrid);
aMapper->SetInputData(aGrid);
myPreviewActor = SALOME_Actor::New();
myPreviewActor->PickableOff();

2
src/SMESHGUI/SMESHGUI_MultiEditDlg.cxx
View File

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

6
src/SMESHGUI/SMESHGUI_NodesDlg.cxx
View File

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

6
src/SMESHGUI/SMESHGUI_Preferences_ScalarBarDlg.cxx
View File

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

56
src/SMESHGUI/SMESHGUI_VTKUtils.cxx
View File

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

8
src/SMESHGUI/SMESHGUI_VTKUtils.h
View File

@ -202,10 +202,10 @@ SMESHGUI_EXPORT
//----------------------------------------------------------------------------
SMESHGUI_EXPORT
bool ComputeClippingPlaneParameters( std::list<vtkActor*> theActorList,
vtkFloatingPointType theNormal[3],
vtkFloatingPointType theDist,
vtkFloatingPointType theBounds[6],
vtkFloatingPointType theOrigin[3] );
double theNormal[3],
double theDist,
double theBounds[6],
double theOrigin[3] );
SMESHGUI_EXPORT
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>
<source>RADIOBTN_1</source>
<translation>Convert to quadratic</translation>
<translation>Convert to linear</translation>
</message>
<message>
<source>RADIOBTN_2</source>
<translation>Convert from quadratic</translation>
<translation>Convert to quadratic</translation>
</message>
<message>
<message>
<source>RADIOBTN_3</source>
<translation>Convert to bi-quadratic</translation>
</message>
<message>
<source>NON_CONFORM_WARNING</source>
<translation>Warning: mesh can become non-conformal</translation>
</message>
@ -5196,6 +5200,10 @@ Please check input data and try again</translation>
<source>COPLANAR_FACES</source>
<translation>Coplanar faces</translation>
</message>
<message>
<source>NUMBEROFNODESINELEMENT</source>
<translation>Number Of Nodes In Element</translation>
</message>
<message>
<source>COPY_FROM</source>
<translation>Copy from...</translation>
@ -5216,10 +5224,6 @@ Please check input data and try again</translation>
<source>EDGES</source>
<translation>Edges</translation>
</message>
<message>
<source>ENTITY_TYPE</source>
<translation>Entity type</translation>
</message>
<message>
<source>EQUAL_TO</source>
<translation>Equal to</translation>
@ -5367,6 +5371,98 @@ Please enter correct value and try again</translation>
<source>ELEMENTS</source>
<translation>Elements</translation>
</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>
<source>GEOM_TYPE</source>
<translation>Geometry type</translation>

68
src/SMESH_I/SMESH_2smeshpy.cxx
View File

@ -256,6 +256,8 @@ namespace {
// - FT_EqualVolumes = 17
// v 6.6.0: FT_Undefined == 44, new items:
// - 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
// undef2newItems (see below) accordingly.
@ -275,6 +277,8 @@ namespace {
undef2newItems[ 43 ].assign( items, items+4 ); }
{ int items[] = { 37 };
undef2newItems[ 44 ].assign( items, items+1 ); }
{ int items[] = { 36 };
undef2newItems[ 45 ].assign( items, items+1 ); }
}
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
// in order to avoid the problem of type mismatch of long and FunctorType
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
Type = aCommand->GetArg(1), // long
Compare = aCommand->GetArg(2), // long
@ -686,17 +690,34 @@ Handle(_pyCommand) _pyGen::AddCommand( const TCollection_AsciiString& theCommand
aCommand->SetArg( 2, Type );
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();
if ( -1 < iGeom && iGeom < SMESH::Geom_POLYHEDRA+1 )
Threshold = SMESH + types[ iGeom ];
if ( Type == "SMESH.FT_ElemGeomType" )
{
// 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 ""
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));
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()
@ -1571,7 +1600,7 @@ void _pyMesh::Process( const Handle(_pyCommand)& theCommand )
method == "ExportToMEDX" ) { // ExportToMEDX() --> ExportMED()
theCommand->SetMethod( "ExportMED" );
}
else if ( method == "ExportCGNS" || method == "ExportGMF" )
else if ( method == "ExportCGNS" )
{ // ExportCGNS(part, ...) -> ExportCGNS(..., part)
_pyID partID = theCommand->GetArg( 1 );
int nbArgs = theCommand->GetNbArgs();
@ -1579,6 +1608,14 @@ void _pyMesh::Process( const Handle(_pyCommand)& theCommand )
theCommand->SetArg( i-1, theCommand->GetArg( i ));
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" ))
{ // ExportPartTo*(part, ...) -> Export*(..., part)
//
@ -2035,6 +2072,13 @@ void _pyMeshEditor::Process( const Handle(_pyCommand)& theCommand)
if (( isPyMeshMethod = ( newMethod.Length() > 0 )))
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 )
{
@ -3593,7 +3637,7 @@ void _pyCommand::SetArg( int index, const TCollection_AsciiString& theArg)
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 += ")";
myArgs.Clear();

34
src/SMESH_I/SMESH_DumpPython.cxx
View File

@ -196,6 +196,40 @@ namespace SMESH
}
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>
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;
}
/*
Class : Skew_i
Description : Functor for calculating skew in degrees
@ -1637,6 +1636,37 @@ FunctorType ElemGeomType_i::GetFunctorType()
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
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();
}
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()
{
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();
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:
return false;
@ -3043,6 +3093,14 @@ CORBA::Boolean Filter_i::SetCriteria( const SMESH::Filter::Criteria& theCriteria
aPredicate = tmpPred;
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:
{
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_LinearOrQuadratic : return "Linear or Quadratic";
case FT_ElemGeomType : return "Element geomtry type";
case FT_EntityType : return "Entity type";
case FT_Undefined : 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( "Linear or Quadratic" ) ) return FT_LinearOrQuadratic;
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 return FT_Undefined;
}
@ -3903,6 +3963,7 @@ static const char** getFunctNames()
"FT_LinearOrQuadratic",
"FT_GroupColor",
"FT_ElemGeomType",
"FT_EntityType",
"FT_CoplanarFaces",
"FT_BallDiameter",
"FT_LessThan",
@ -3911,7 +3972,7 @@ static const char** getFunctNames()
"FT_LogicalNOT",
"FT_LogicalAND",
"FT_LogicalOR",
"FT_Undefined" };
"FT_Undefined"};
return functName;
}

23
src/SMESH_I/SMESH_Filter_i.hxx
View File

@ -329,7 +329,6 @@ namespace SMESH
Controls::Length2DPtr myLength2DPtr;
};
/*
Class : MultiConnection_i
Description : Functor for calculating number of faces conneted to the edge
@ -450,7 +449,7 @@ namespace SMESH
OverConstrainedFace_i();
FunctorType GetFunctorType();
};
/*
Class : BelongToGeom_i
Description : Predicate for selection on geometrical support
@ -763,6 +762,25 @@ namespace SMESH
private:
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
@ -1095,6 +1113,7 @@ namespace SMESH
LinearOrQuadratic_ptr CreateLinearOrQuadratic();
GroupColor_ptr CreateGroupColor();
ElemGeomType_ptr CreateElemGeomType();
ElemEntityType_ptr CreateElemEntityType();
CoplanarFaces_ptr CreateCoplanarFaces();
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
*/
SMESH::MeshPreviewStruct* GetPreviewData();
SMESH::MeshPreviewStruct* GetPreviewData() throw (SALOME::SALOME_Exception);
/*!
* If during last operation of MeshEditor some nodes were
* created this method returns list of their IDs, if new nodes
* 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
* created this method returns list of their IDs, if new elements
* 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
*/
SMESH::ComputeError* GetLastError();
SMESH::ComputeError* GetLastError() throw (SALOME::SALOME_Exception);
/*!
* \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::ElementType type);
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::Long RemoveOrphanNodes();
CORBA::Boolean RemoveElements(const SMESH::long_array & IDsOfElements)
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.
* 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 Add0DElement(CORBA::Long IDOfNode);
CORBA::Long AddNode(CORBA::Double x, CORBA::Double y, CORBA::Double z)
throw (SALOME::SALOME_Exception);
CORBA::Long Add0DElement(CORBA::Long IDOfNode)
throw (SALOME::SALOME_Exception);
CORBA::Long AddBall(CORBA::Long IDOfNodem, CORBA::Double diameter)
throw (SALOME::SALOME_Exception);
CORBA::Long AddEdge(const SMESH::long_array & IDsOfNodes);
CORBA::Long AddFace(const SMESH::long_array & IDsOfNodes);
CORBA::Long AddPolygonalFace(const SMESH::long_array & IDsOfNodes);
CORBA::Long AddVolume(const SMESH::long_array & IDsOfNodes);
CORBA::Long AddEdge(const SMESH::long_array & IDsOfNodes)
throw (SALOME::SALOME_Exception);
CORBA::Long AddFace(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,
const SMESH::long_array & Quantities);
CORBA::Long AddPolyhedralVolumeByFaces(const SMESH::long_array & IdsOfFaces);
const SMESH::long_array & Quantities)
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
@ -161,12 +173,18 @@ public:
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.
* \param the2Dgroup - the mesh or its part to reorient
@ -184,114 +202,143 @@ public:
// Split/Join faces
CORBA::Boolean TriToQuad (const SMESH::long_array & IDsOfElements,
SMESH::NumericalFunctor_ptr Criterion,
CORBA::Double MaxAngle);
CORBA::Double MaxAngle)
throw (SALOME::SALOME_Exception);
CORBA::Boolean TriToQuadObject (SMESH::SMESH_IDSource_ptr theObject,
SMESH::NumericalFunctor_ptr Criterion,
CORBA::Double MaxAngle);
CORBA::Double MaxAngle)
throw (SALOME::SALOME_Exception);
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,
SMESH::NumericalFunctor_ptr Criterion);
SMESH::NumericalFunctor_ptr Criterion)
throw (SALOME::SALOME_Exception);
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 Diag13);
CORBA::Boolean Diag13)
throw (SALOME::SALOME_Exception);
CORBA::Long BestSplit (CORBA::Long IDOfQuad,
SMESH::NumericalFunctor_ptr Criterion);
void SplitVolumesIntoTetra (SMESH::SMESH_IDSource_ptr elems,
CORBA::Short methodFlags) throw (SALOME::SALOME_Exception);
SMESH::NumericalFunctor_ptr Criterion)
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,
const SMESH::long_array & IDsOfFixedNodes,
CORBA::Long MaxNbOfIterations,
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,
const SMESH::long_array & IDsOfFixedNodes,
CORBA::Long MaxNbOfIterations,
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,
const SMESH::long_array & IDsOfFixedNodes,
CORBA::Long MaxNbOfIterations,
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,
const SMESH::long_array & IDsOfFixedNodes,
CORBA::Long MaxNbOfIterations,
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,
const SMESH::long_array & IDsOfFixedNodes,
CORBA::Long MaxNbOfIterations,
CORBA::Double MaxAspectRatio,
SMESH::SMESH_MeshEditor::Smooth_Method Method,
bool IsParametric);
bool IsParametric)
throw (SALOME::SALOME_Exception);
CORBA::Boolean smoothObject(SMESH::SMESH_IDSource_ptr theObject,
const SMESH::long_array & IDsOfFixedNodes,
CORBA::Long MaxNbOfIterations,
CORBA::Double MaxAspectRatio,
SMESH::SMESH_MeshEditor::Smooth_Method Method,
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)
bool IsParametric)
throw (SALOME::SALOME_Exception);
void RenumberNodes();
void RenumberElements();
CORBA::Boolean ConvertFromQuadratic()
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,
const SMESH::AxisStruct & Axis,
CORBA::Double AngleInRadians,
CORBA::Long NbOfSteps,
CORBA::Double Tolerance);
CORBA::Double Tolerance)
throw (SALOME::SALOME_Exception);
void RotationSweepObject(SMESH::SMESH_IDSource_ptr theObject,
const SMESH::AxisStruct & Axis,
CORBA::Double AngleInRadians,
CORBA::Long NbOfSteps,
CORBA::Double Tolerance);
CORBA::Double Tolerance)
throw (SALOME::SALOME_Exception);
void RotationSweepObject1D(SMESH::SMESH_IDSource_ptr theObject,
const SMESH::AxisStruct & Axis,
CORBA::Double AngleInRadians,
CORBA::Long NbOfSteps,
CORBA::Double Tolerance);
CORBA::Double Tolerance)
throw (SALOME::SALOME_Exception);
void RotationSweepObject2D(SMESH::SMESH_IDSource_ptr theObject,
const SMESH::AxisStruct & Axis,
CORBA::Double AngleInRadians,
CORBA::Long NbOfSteps,
CORBA::Double Tolerance);
CORBA::Double Tolerance)
throw (SALOME::SALOME_Exception);
void ExtrusionSweep(const SMESH::long_array & IDsOfElements,
const SMESH::DirStruct & StepVector,
CORBA::Long NbOfSteps);
CORBA::Long NbOfSteps)
throw (SALOME::SALOME_Exception);
void ExtrusionSweep0D(const SMESH::long_array & IDsOfElements,
const SMESH::DirStruct & StepVector,
CORBA::Long NbOfSteps);
CORBA::Long NbOfSteps)
throw (SALOME::SALOME_Exception);
void ExtrusionSweepObject(SMESH::SMESH_IDSource_ptr theObject,
const SMESH::DirStruct & StepVector,
CORBA::Long NbOfSteps);
CORBA::Long NbOfSteps)
throw (SALOME::SALOME_Exception);
void ExtrusionSweepObject0D(SMESH::SMESH_IDSource_ptr theObject,
const SMESH::DirStruct & StepVector,
CORBA::Long NbOfSteps);
CORBA::Long NbOfSteps)
throw (SALOME::SALOME_Exception);
void ExtrusionSweepObject1D(SMESH::SMESH_IDSource_ptr theObject,
const SMESH::DirStruct & StepVector,
CORBA::Long NbOfSteps);
CORBA::Long NbOfSteps)
throw (SALOME::SALOME_Exception);
void ExtrusionSweepObject2D(SMESH::SMESH_IDSource_ptr theObject,
const SMESH::DirStruct & StepVector,
CORBA::Long NbOfSteps);
CORBA::Long NbOfSteps)
throw (SALOME::SALOME_Exception);
void AdvancedExtrusion(const SMESH::long_array & theIDsOfElements,
const SMESH::DirStruct & theStepVector,
CORBA::Long theNbOfSteps,
CORBA::Long theExtrFlags,
CORBA::Double theSewTolerance);
CORBA::Double theSewTolerance)
throw (SALOME::SALOME_Exception);
SMESH::SMESH_MeshEditor::Extrusion_Error
ExtrusionAlongPath(const SMESH::long_array & IDsOfElements,
@ -301,7 +348,8 @@ public:
CORBA::Boolean HasAngles,
const SMESH::double_array & Angles,
CORBA::Boolean HasRefPoint,
const SMESH::PointStruct & RefPoint);
const SMESH::PointStruct & RefPoint)
throw (SALOME::SALOME_Exception);
SMESH::SMESH_MeshEditor::Extrusion_Error
ExtrusionAlongPathObject(SMESH::SMESH_IDSource_ptr theObject,
@ -311,7 +359,8 @@ public:
CORBA::Boolean HasAngles,
const SMESH::double_array & Angles,
CORBA::Boolean HasRefPoint,
const SMESH::PointStruct & RefPoint);
const SMESH::PointStruct & RefPoint)
throw (SALOME::SALOME_Exception);
SMESH::SMESH_MeshEditor::Extrusion_Error
ExtrusionAlongPathObject1D(SMESH::SMESH_IDSource_ptr theObject,
SMESH::SMESH_Mesh_ptr PathMesh,
@ -320,7 +369,8 @@ public:
CORBA::Boolean HasAngles,
const SMESH::double_array & Angles,
CORBA::Boolean HasRefPoint,
const SMESH::PointStruct & RefPoint);
const SMESH::PointStruct & RefPoint)
throw (SALOME::SALOME_Exception);
SMESH::SMESH_MeshEditor::Extrusion_Error
ExtrusionAlongPathObject2D(SMESH::SMESH_IDSource_ptr theObject,
SMESH::SMESH_Mesh_ptr PathMesh,
@ -329,7 +379,8 @@ public:
CORBA::Boolean HasAngles,
const SMESH::double_array & Angles,
CORBA::Boolean HasRefPoint,
const SMESH::PointStruct & RefPoint);
const SMESH::PointStruct & RefPoint)
throw (SALOME::SALOME_Exception);
SMESH::double_array* LinearAnglesVariation(SMESH::SMESH_Mesh_ptr PathMesh,
GEOM::GEOM_Object_ptr PathShape,
@ -338,70 +389,87 @@ public:
void Mirror(const SMESH::long_array & IDsOfElements,
const SMESH::AxisStruct & Axis,
SMESH::SMESH_MeshEditor::MirrorType MirrorType,
CORBA::Boolean Copy);
CORBA::Boolean Copy)
throw (SALOME::SALOME_Exception);
void MirrorObject(SMESH::SMESH_IDSource_ptr theObject,
const SMESH::AxisStruct & Axis,
SMESH::SMESH_MeshEditor::MirrorType MirrorType,
CORBA::Boolean Copy);
CORBA::Boolean Copy)
throw (SALOME::SALOME_Exception);
void Translate(const SMESH::long_array & IDsOfElements,
const SMESH::DirStruct & Vector,
CORBA::Boolean Copy);
CORBA::Boolean Copy)
throw (SALOME::SALOME_Exception);
void TranslateObject(SMESH::SMESH_IDSource_ptr theObject,
const SMESH::DirStruct & Vector,
CORBA::Boolean Copy);
CORBA::Boolean Copy)
throw (SALOME::SALOME_Exception);
void Rotate(const SMESH::long_array & IDsOfElements,
const SMESH::AxisStruct & Axis,
CORBA::Double Angle,
CORBA::Boolean Copy);
CORBA::Boolean Copy)
throw (SALOME::SALOME_Exception);
void RotateObject(SMESH::SMESH_IDSource_ptr theObject,
const SMESH::AxisStruct & Axis,
CORBA::Double Angle,
CORBA::Boolean Copy);
CORBA::Boolean Copy)
throw (SALOME::SALOME_Exception);
SMESH::ListOfGroups* RotationSweepMakeGroups(const SMESH::long_array& IDsOfElements,
const SMESH::AxisStruct& Axix,
CORBA::Double AngleInRadians,
CORBA::Long NbOfSteps,
CORBA::Double Tolerance);
CORBA::Double Tolerance)
throw (SALOME::SALOME_Exception);
SMESH::ListOfGroups* RotationSweepObjectMakeGroups(SMESH::SMESH_IDSource_ptr Object,
const SMESH::AxisStruct& Axix,
CORBA::Double AngleInRadians,
CORBA::Long NbOfSteps,
CORBA::Double Tolerance);
CORBA::Double Tolerance)
throw (SALOME::SALOME_Exception);
SMESH::ListOfGroups* RotationSweepObject1DMakeGroups(SMESH::SMESH_IDSource_ptr Object,
const SMESH::AxisStruct& Axix,
CORBA::Double AngleInRadians,
CORBA::Long NbOfSteps,
CORBA::Double Tolerance);
CORBA::Double Tolerance)
throw (SALOME::SALOME_Exception);
SMESH::ListOfGroups* RotationSweepObject2DMakeGroups(SMESH::SMESH_IDSource_ptr Object,
const SMESH::AxisStruct& Axix,
CORBA::Double AngleInRadians,
CORBA::Long NbOfSteps,
CORBA::Double Tolerance);
CORBA::Double Tolerance)
throw (SALOME::SALOME_Exception);
SMESH::ListOfGroups* ExtrusionSweepMakeGroups(const SMESH::long_array& IDsOfElements,
const SMESH::DirStruct& StepVector,
CORBA::Long NbOfSteps);
CORBA::Long NbOfSteps)
throw (SALOME::SALOME_Exception);
SMESH::ListOfGroups* ExtrusionSweepMakeGroups0D(const SMESH::long_array& IDsOfElements,
const SMESH::DirStruct& StepVector,
CORBA::Long NbOfSteps);
CORBA::Long NbOfSteps)
throw (SALOME::SALOME_Exception);
SMESH::ListOfGroups* AdvancedExtrusionMakeGroups(const SMESH::long_array& IDsOfElements,
const SMESH::DirStruct& StepVector,
CORBA::Long NbOfSteps,
CORBA::Long ExtrFlags,
CORBA::Double SewTolerance);
CORBA::Double SewTolerance)
throw (SALOME::SALOME_Exception);
SMESH::ListOfGroups* ExtrusionSweepObjectMakeGroups(SMESH::SMESH_IDSource_ptr Object,
const SMESH::DirStruct& StepVector,
CORBA::Long NbOfSteps);
CORBA::Long NbOfSteps)
throw (SALOME::SALOME_Exception);
SMESH::ListOfGroups* ExtrusionSweepObject0DMakeGroups(SMESH::SMESH_IDSource_ptr Object,
const SMESH::DirStruct& StepVector,
CORBA::Long NbOfSteps);
CORBA::Long NbOfSteps)
throw (SALOME::SALOME_Exception);
SMESH::ListOfGroups* ExtrusionSweepObject1DMakeGroups(SMESH::SMESH_IDSource_ptr Object,
const SMESH::DirStruct& StepVector,
CORBA::Long NbOfSteps);
CORBA::Long NbOfSteps)
throw (SALOME::SALOME_Exception);
SMESH::ListOfGroups* ExtrusionSweepObject2DMakeGroups(SMESH::SMESH_IDSource_ptr Object,
const SMESH::DirStruct& StepVector,
CORBA::Long NbOfSteps);
CORBA::Long NbOfSteps)
throw (SALOME::SALOME_Exception);
SMESH::ListOfGroups* ExtrusionAlongPathMakeGroups(const SMESH::long_array& IDsOfElements,
SMESH::SMESH_Mesh_ptr PathMesh,
GEOM::GEOM_Object_ptr PathShape,
@ -410,7 +478,8 @@ public:
const SMESH::double_array& Angles,
CORBA::Boolean HasRefPoint,
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::SMESH_Mesh_ptr PathMesh,
GEOM::GEOM_Object_ptr PathShape,
@ -419,7 +488,8 @@ public:
const SMESH::double_array& Angles,
CORBA::Boolean HasRefPoint,
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::SMESH_Mesh_ptr PathMesh,
GEOM::GEOM_Object_ptr PathShape,
@ -428,7 +498,8 @@ public:
const SMESH::double_array& Angles,
CORBA::Boolean HasRefPoint,
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::SMESH_Mesh_ptr PathMesh,
GEOM::GEOM_Object_ptr PathShape,
@ -437,7 +508,8 @@ public:
const SMESH::double_array& Angles,
CORBA::Boolean HasRefPoint,
const SMESH::PointStruct& RefPoint,
SMESH::SMESH_MeshEditor::Extrusion_Error& Error);
SMESH::SMESH_MeshEditor::Extrusion_Error& Error)
throw (SALOME::SALOME_Exception);
// skl 04.06.2009
SMESH::ListOfGroups* ExtrusionAlongPathObjX(SMESH::SMESH_IDSource_ptr Object,
@ -450,7 +522,8 @@ public:
const SMESH::PointStruct& RefPoint,
CORBA::Boolean MakeGroups,
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::SMESH_IDSource_ptr Path,
CORBA::Long NodeStart,
@ -461,93 +534,118 @@ public:
const SMESH::PointStruct& RefPoint,
CORBA::Boolean MakeGroups,
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,
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,
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,
const SMESH::DirStruct& Vector);
const SMESH::DirStruct& Vector)
throw (SALOME::SALOME_Exception);
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,
const SMESH::AxisStruct& Axis,
CORBA::Double AngleInRadians);
CORBA::Double AngleInRadians)
throw (SALOME::SALOME_Exception);
SMESH::ListOfGroups* RotateObjectMakeGroups(SMESH::SMESH_IDSource_ptr Object,
const SMESH::AxisStruct& Axis,
CORBA::Double AngleInRadians);
CORBA::Double AngleInRadians)
throw (SALOME::SALOME_Exception);
SMESH::SMESH_Mesh_ptr MirrorMakeMesh(const SMESH::long_array& IDsOfElements,
const SMESH::AxisStruct& Mirror,
SMESH::SMESH_MeshEditor::MirrorType MirrorType,
CORBA::Boolean CopyGroups,
const char* MeshName);
const char* MeshName)
throw (SALOME::SALOME_Exception);
SMESH::SMESH_Mesh_ptr MirrorObjectMakeMesh(SMESH::SMESH_IDSource_ptr Object,
const SMESH::AxisStruct& Mirror,
SMESH::SMESH_MeshEditor::MirrorType MirrorType,
CORBA::Boolean CopyGroups,
const char* MeshName);
const char* MeshName)
throw (SALOME::SALOME_Exception);
SMESH::SMESH_Mesh_ptr TranslateMakeMesh(const SMESH::long_array& IDsOfElements,
const SMESH::DirStruct& Vector,
CORBA::Boolean CopyGroups,
const char* MeshName);
const char* MeshName)
throw (SALOME::SALOME_Exception);
SMESH::SMESH_Mesh_ptr TranslateObjectMakeMesh(SMESH::SMESH_IDSource_ptr Object,
const SMESH::DirStruct& Vector,
CORBA::Boolean CopyGroups,
const char* MeshName);
const char* MeshName)
throw (SALOME::SALOME_Exception);
SMESH::SMESH_Mesh_ptr RotateMakeMesh(const SMESH::long_array& IDsOfElements,
const SMESH::AxisStruct& Axis,
CORBA::Double AngleInRadians,
CORBA::Boolean CopyGroups,
const char* MeshName);
const char* MeshName)
throw (SALOME::SALOME_Exception);
SMESH::SMESH_Mesh_ptr RotateObjectMakeMesh(SMESH::SMESH_IDSource_ptr Object,
const SMESH::AxisStruct& Axis,
CORBA::Double AngleInRadians,
CORBA::Boolean CopyGroups,
const char* MeshName);
const char* MeshName)
throw (SALOME::SALOME_Exception);
void Scale(SMESH::SMESH_IDSource_ptr theObject,
const SMESH::PointStruct& thePoint,
const SMESH::double_array& theScaleFact,
CORBA::Boolean theCopy);
CORBA::Boolean theCopy)
throw (SALOME::SALOME_Exception);
SMESH::ListOfGroups* ScaleMakeGroups(SMESH::SMESH_IDSource_ptr theObject,
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,
const SMESH::PointStruct& Point,
const SMESH::double_array& theScaleFact,
CORBA::Boolean CopyGroups,
const char* MeshName);
const char* MeshName)
throw (SALOME::SALOME_Exception);
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,
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,
CORBA::Double Tolerance,
SMESH::array_of_long_array_out GroupsOfNodes,
const SMESH::ListOfIDSources& ExceptSubMeshOrGroups);
void MergeNodes (const SMESH::array_of_long_array& GroupsOfNodes);
const SMESH::ListOfIDSources& ExceptSubMeshOrGroups)
throw (SALOME::SALOME_Exception);
void MergeNodes (const SMESH::array_of_long_array& GroupsOfNodes)
throw (SALOME::SALOME_Exception);
void FindEqualElements(SMESH::SMESH_IDSource_ptr Object,
SMESH::array_of_long_array_out GroupsOfElementsID);
void MergeElements(const SMESH::array_of_long_array& GroupsOfElementsID);
void MergeEqualElements();
SMESH::array_of_long_array_out GroupsOfElementsID)
throw (SALOME::SALOME_Exception);
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::Double y,
CORBA::Double z,
CORBA::Long nodeID);
CORBA::Long nodeID)
throw (SALOME::SALOME_Exception);
/*!
* \brief Return ID of node closest to a given point
*/
CORBA::Long FindNodeClosestTo(CORBA::Double x,
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.
* 'ALL' type means elements of any type excluding nodes
@ -555,7 +653,8 @@ public:
SMESH::long_array* FindElementsByPoint(CORBA::Double x,
CORBA::Double y,
CORBA::Double z,
SMESH::ElementType type);
SMESH::ElementType type)
throw (SALOME::SALOME_Exception);
/*!
* Searching among the given elements, return elements of given type
* where the given point is IN or ON.
@ -565,13 +664,15 @@ public:
CORBA::Double x,
CORBA::Double y,
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.
* 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
SewFreeBorders(CORBA::Long FirstNodeID1,
@ -581,13 +682,15 @@ public:
CORBA::Long SecondNodeID2,
CORBA::Long LastNodeID2,
CORBA::Boolean CreatePolygons,
CORBA::Boolean CreatePolyedrs);
CORBA::Boolean CreatePolyedrs)
throw (SALOME::SALOME_Exception);
SMESH::SMESH_MeshEditor::Sew_Error
SewConformFreeBorders(CORBA::Long FirstNodeID1,
CORBA::Long SecondNodeID1,
CORBA::Long LastNodeID1,
CORBA::Long FirstNodeID2,
CORBA::Long SecondNodeID2);
CORBA::Long SecondNodeID2)
throw (SALOME::SALOME_Exception);
SMESH::SMESH_MeshEditor::Sew_Error
SewBorderToSide(CORBA::Long FirstNodeIDOnFreeBorder,
CORBA::Long SecondNodeIDOnFreeBorder,
@ -595,30 +698,36 @@ public:
CORBA::Long FirstNodeIDOnSide,
CORBA::Long LastNodeIDOnSide,
CORBA::Boolean CreatePolygons,
CORBA::Boolean CreatePolyedrs);
CORBA::Boolean CreatePolyedrs)
throw (SALOME::SALOME_Exception);
SMESH::SMESH_MeshEditor::Sew_Error
SewSideElements(const SMESH::long_array& IDsOfSide1Elements,
const SMESH::long_array& IDsOfSide2Elements,
CORBA::Long NodeID1OfSide1ToMerge,
CORBA::Long NodeID1OfSide2ToMerge,
CORBA::Long NodeID2OfSide1ToMerge,
CORBA::Long NodeID2OfSide2ToMerge);
CORBA::Long NodeID2OfSide2ToMerge)
throw (SALOME::SALOME_Exception);
/*!
* Set new nodes for given element.
* If number of nodes is not corresponded to type of
* 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,
const SMESH::long_array& theModifiedElems );
const SMESH::long_array& theModifiedElems )
throw (SALOME::SALOME_Exception);
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,
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.
@ -629,13 +738,16 @@ public:
* \sa DoubleNodeGroup()
*/
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,
const SMESH::ListOfGroups& theModifiedElems );
const SMESH::ListOfGroups& theModifiedElems )
throw (SALOME::SALOME_Exception);
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
@ -649,7 +761,8 @@ public:
*/
CORBA::Boolean DoubleNodeElem( const SMESH::long_array& theElems,
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
@ -664,7 +777,8 @@ public:
*/
CORBA::Boolean DoubleNodeElemInRegion( const SMESH::long_array& theElems,
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
@ -677,7 +791,8 @@ public:
*/
CORBA::Boolean DoubleNodeElemGroup( SMESH::SMESH_GroupBase_ptr theElems,
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
@ -691,13 +806,15 @@ public:
*/
SMESH::SMESH_Group_ptr DoubleNodeElemGroupNew( SMESH::SMESH_GroupBase_ptr theElems,
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::SMESH_GroupBase_ptr theNodesNot,
SMESH::SMESH_GroupBase_ptr theAffectedElems,
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
@ -711,7 +828,8 @@ public:
*/
CORBA::Boolean DoubleNodeElemGroupInRegion( SMESH::SMESH_GroupBase_ptr theElems,
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
@ -725,7 +843,8 @@ public:
*/
CORBA::Boolean DoubleNodeElemGroups( const SMESH::ListOfGroups& theElems,
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
@ -739,13 +858,15 @@ public:
*/
SMESH::SMESH_Group_ptr DoubleNodeElemGroupsNew( const SMESH::ListOfGroups& theElems,
const SMESH::ListOfGroups& theNodesNot,
const SMESH::ListOfGroups& theAffectedElems );
const SMESH::ListOfGroups& theAffectedElems )
throw (SALOME::SALOME_Exception);
SMESH::ListOfGroups* DoubleNodeElemGroups2New(const SMESH::ListOfGroups& theElems,
const SMESH::ListOfGroups& theNodesNot,
const SMESH::ListOfGroups& theAffectedElems,
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
@ -760,7 +881,8 @@ public:
*/
CORBA::Boolean DoubleNodeElemGroupsInRegion( const SMESH::ListOfGroups& theElems,
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.
@ -775,7 +897,8 @@ public:
*/
SMESH::ListOfGroups* AffectedElemGroupsInRegion( const SMESH::ListOfGroups& theElems,
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.
@ -799,7 +922,8 @@ public:
* @param theGroupsOfFaces - list of groups of faces
* @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
@ -819,7 +943,8 @@ public:
* The created 2D mesh elements based on nodes of free faces of boundary volumes
* \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::Bnd_Dimension dimension,
@ -827,7 +952,8 @@ public:
const char* meshName,
CORBA::Boolean toCopyElements,
CORBA::Boolean toCopyMissingBondary,
SMESH::SMESH_Group_out group);
SMESH::SMESH_Group_out group)
throw (SALOME::SALOME_Exception);
CORBA::Long MakeBoundaryElements(SMESH::Bnd_Dimension dimension,
const char* groupName,
@ -846,11 +972,8 @@ private: //!< private methods
MeshEditor_I::TPreviewMesh * getPreviewMesh( SMDSAbs_ElementType previewType = SMDSAbs_All );
/*!
* \brief Update myLastCreated* or myPreviewData
* \param anEditor - it contains edition results
*/
//void storeResult(::SMESH_MeshEditor& anEditor);
void declareMeshModified( bool isReComputeSafe );
/*!
* \brief Clear myLastCreated* or myPreviewData
*/
@ -859,7 +982,8 @@ private: //!< private methods
/*!
* \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,
const SMESH::AxisStruct & Axis,
@ -867,18 +991,21 @@ private: //!< private methods
CORBA::Long NbOfSteps,
CORBA::Double Tolerance,
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,
const SMESH::DirStruct & StepVector,
CORBA::Long NbOfSteps,
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,
const SMESH::DirStruct & theStepVector,
CORBA::Long theNbOfSteps,
CORBA::Long theExtrFlags,
CORBA::Double theSewTolerance,
const bool MakeGroups);
const bool MakeGroups)
throw (SALOME::SALOME_Exception);
SMESH::ListOfGroups* extrusionAlongPath(const SMESH::long_array & IDsOfElements,
SMESH::SMESH_Mesh_ptr PathMesh,
GEOM::GEOM_Object_ptr PathShape,
@ -889,7 +1016,8 @@ private: //!< private methods
const SMESH::PointStruct & RefPoint,
const bool MakeGroups,
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::SMESH_IDSource_ptr Path,
CORBA::Long NodeStart,
@ -900,35 +1028,45 @@ private: //!< private methods
const SMESH::PointStruct& RefPoint,
bool MakeGroups,
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,
const SMESH::AxisStruct & Axis,
SMESH::SMESH_MeshEditor::MirrorType MirrorType,
CORBA::Boolean Copy,
bool MakeGroups,
::SMESH_Mesh* TargetMesh=0);
::SMESH_Mesh* TargetMesh=0)
throw (SALOME::SALOME_Exception);
SMESH::ListOfGroups* translate(TIDSortedElemSet & IDsOfElements,
const SMESH::DirStruct & Vector,
CORBA::Boolean Copy,
bool MakeGroups,
::SMESH_Mesh* TargetMesh=0);
::SMESH_Mesh* TargetMesh=0)
throw (SALOME::SALOME_Exception);
SMESH::ListOfGroups* rotate(TIDSortedElemSet & IDsOfElements,
const SMESH::AxisStruct & Axis,
CORBA::Double Angle,
CORBA::Boolean Copy,
bool MakeGroups,
::SMESH_Mesh* TargetMesh=0);
::SMESH_Mesh* TargetMesh=0)
throw (SALOME::SALOME_Exception);
SMESH::ListOfGroups* scale(SMESH::SMESH_IDSource_ptr theObject,
const SMESH::PointStruct& thePoint,
const SMESH::double_array& theScaleFact,
CORBA::Boolean theCopy,
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);
void DumpGroupsList(SMESH::TPythonDump & theDumpPython,
void dumpGroupsList(SMESH::TPythonDump & theDumpPython,
const SMESH::ListOfGroups * theGroupList);
string generateGroupName(const string& thePrefix);

3
src/SMESH_I/SMESH_PythonDump.hxx
View File

@ -142,6 +142,9 @@ namespace SMESH
TPythonDump&
operator<<(const SMESH::GeometryType& theArg);
TPythonDump&
operator<<(const SMESH::EntityType& theArg);
TPythonDump&
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
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:
# Checks the Threshold
try:
@ -2221,7 +2235,7 @@ class Mesh:
def GetElemNbNodes(self, 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 node for the given index - returns -2
# @return an integer value
@ -3062,19 +3076,23 @@ class Mesh:
return self.editor.SmoothParametricObject(theObject, IDsOfFixedNodes,
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.
# @param theForce3d new node creation method:
# 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
# @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
def ConvertToQuadratic(self, theForce3d, theSubMesh=None):
if theSubMesh:
self.editor.ConvertToQuadraticObject(theForce3d,theSubMesh)
def ConvertToQuadratic(self, theForce3d, theSubMesh=None, theToBiQuad=False):
if theToBiQuad:
self.editor.ConvertToBiQuadratic(theForce3d,theSubMesh)
else:
self.editor.ConvertToQuadratic(theForce3d)
if theSubMesh:
self.editor.ConvertToQuadraticObject(theForce3d,theSubMesh)
else:
self.editor.ConvertToQuadratic(theForce3d)
## Converts the mesh from quadratic to ordinary,
# deletes old quadratic elements, \n replacing
# 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);
}
// 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,
double scalex, double scaley)
{
SMESHDS_Mesh * meshDS = _helper->GetMeshDS();
int faceID = _helper->GetSubShapeID();
_helper->SetElementsOnShape( true );
TopoDS_Face F = TopoDS::Face( _helper->GetSubShape() );
Handle(Geom_Surface) S = BRep_Tool::Surface( F );
//const size_t nbInputNodes = mefistoToDS.size();
Z n = mefistoToDS.size(); // nb input points
mefistoToDS.resize( nbst );
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;
gp_Pnt P = S->Value(u, v);
SMDS_MeshNode * node = meshDS->AddNode(P.X(), P.Y(), P.Z());
meshDS->SetNodeOnFace(node, faceID, u, v);
//MESSAGE(P.X()<<" "<<P.Y()<<" "<<P.Z());
mefistoToDS[n] = node;
//MESSAGE("NEW: "<<n<<" "<<mefistoToDS[n+1]);
mefistoToDS[n] = _helper->AddNode( P.X(), P.Y(), P.Z(), 0, u, v );
}
}
@ -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
// 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++)
{
const SMDS_MeshNode * n1 = mefistoToDS[ nust[m++] - 1 ];
const SMDS_MeshNode * n2 = mefistoToDS[ nust[m++] - 1 ];
const SMDS_MeshNode * n3 = mefistoToDS[ nust[m++] - 1 ];
// const bool allNodesAreOld = ( nust[m + 0] <= nbInputNodes &&
// nust[m + 1] <= nbInputNodes &&
// 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
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 )
{
SMDS_MeshElement * elt;
if (triangleIsWellOriented)
elt = _helper->AddFace(n1, n2, n3);
else
elt = _helper->AddFace(n1, n3, n2);
meshDS->SetMeshElementOnShape(elt, faceID);
}
m++;
_helper->AddFace( nn[0], nn[i1], nn[i2] );
}
// 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++;
if (nbSame > 1) {
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;
}
// Compute
// Compute 'vertical projection'
if ( nbTgtMeshed == 0 )
{
// compute nodes on target VERTEXes
@ -2195,8 +2195,10 @@ bool StdMeshers_PrismAsBlock::Init(SMESH_MesherHelper* helper,
{
if ( len2edgeMap.size() != nbEdges )
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 midLen = ( len2edgeMap.size() == 1 ) ? 0 : midLen_i->first;
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() )
tgtFaces.insert( tgtFaces.end(), faceIt->next() );
editor.ConvertToQuadratic(/*theForce3d=*/false, tgtFaces);
editor.ConvertToQuadratic(/*theForce3d=*/false, tgtFaces, false);
}
cleaner.Release(); // not to remove mesh