ForkMaster/smesh
1
0
Fork 0
mirror of https://git.salome-platform.org/gitpub/modules/smesh.git synced 2024-12-24 16:30:34 +05:00
Code Issues Packages Projects Releases Wiki Activity

Merge from V5_1_3_BR branch (07/12/09)

Browse Source
This commit is contained in:
vsr 2009-12-08 13:11:42 +00:00
parent 2ed875d56d
commit 2daa321efa
112 changed files with 4058 additions and 3229 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

15
adm_local/unix/config_files/check_qwt.m4
View File

@ -47,16 +47,18 @@ AC_ARG_WITH(qwt_inc,
libqwt_name=qwt libqwt_name=qwt
if test -z $QWTHOME; then if test -z $QWTHOME; then
AC_MSG_RESULT(QWTHOME not defined) AC_MSG_RESULT(QWTHOME not defined)
AC_MSG_NOTICE(Trying native Qwt...)
exist_ok=no exist_ok=no
if test "x$exist_ok" = "xno"; then if test "x$exist_ok" = "xno"; then
for d in /usr /usr/local ; do for d in /usr /usr/local ; do
for extension in qwt qwt-qt4; do for extension in qwt-qt4 qwt; do
AC_CHECK_FILE(${d}/lib${LIB_LOCATION_SUFFIX}/lib${extension}.so,exist_ok=yes,exist_ok=no) AC_CHECK_FILE(${d}/lib${LIB_LOCATION_SUFFIX}/lib${extension}.so,exist_ok=yes,exist_ok=no)
if test "x$exist_ok" = "xyes"; then if test "x$exist_ok" = "xyes"; then
QWTHOME=$d QWTHOME=$d
AC_MSG_RESULT(lib${extension}.so detected in $d/lib) AC_MSG_RESULT(lib${extension}.so detected in $d/lib)
libqwt_name=${extension} libqwt_name=${extension}
dnl No break here, libqwt-qt4.so is choosen even if libqwt.so is present: if 2 are present, in most of cases, libqwt.so is Qt3 version. dnl break, libqwt-qt4.so is choosen before libqwt.so since it is surely the Qt4 version.
break
fi fi
done done
if test "x$exist_ok" = "xyes"; then if test "x$exist_ok" = "xyes"; then
@ -77,21 +79,22 @@ if test -z $QWTHOME; then
fi fi
if test "x$exist_ok" = "xyes"; then if test "x$exist_ok" = "xyes"; then
if test -z $QWT_INCDIR; then if test -z $QWT_INCDIR; then
QWT_INCDIR=$QWTHOME"/include/qwt" QWT_INCDIR=$QWTHOME"/include/qwt-qt4"
if test ! -f $QWT_INCDIR/qwt.h ; then
QWT_INCDIR=/usr/include/qwt
fi
if test ! -f $QWT_INCDIR/qwt.h ; then if test ! -f $QWT_INCDIR/qwt.h ; then
QWT_INCDIR=$QWTHOME"/include" QWT_INCDIR=$QWTHOME"/include"
fi fi
if test ! -f $QWT_INCDIR/qwt.h ; then if test ! -f $QWT_INCDIR/qwt.h ; then
QWT_INCDIR=/usr/lib/qt4/include/qwt QWT_INCDIR=/usr/lib/qt4/include/qwt
fi fi
if test ! -f $QWT_INCDIR/qwt.h ; then
QWT_INCDIR=/usr/include/qwt-qt4
fi
fi fi
else else
qwt_ok=no qwt_ok=no
fi fi
else else
AC_MSG_NOTICE(Trying Qwt from $QWTHOME ...)
if test -z $QWT_INCDIR; then if test -z $QWT_INCDIR; then
QWT_INCDIR="$QWTHOME/include" QWT_INCDIR="$QWTHOME/include"
fi fi

BIN
doc/salome/gui/SMESH/images/hypo_quad_params_2.png Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 2.1 KiB

BIN
doc/salome/gui/SMESH/images/hypo_quad_params_res_2.png Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 9.2 KiB

36
doc/salome/gui/SMESH/input/1d_meshing_hypo.doc
View File

@ -199,31 +199,27 @@ minimum and maximum value of this parameter.
\anchor fixed_points_1d_anchor \anchor fixed_points_1d_anchor
<h2>Fixed points 1D hypothesis</h2> <h2>Fixed points 1D hypothesis</h2>
<b>Fixed points 1D</b> hypothesis allows to split edges into segments <b>Fixed points 1D</b> hypothesis allows splitting edges through a
using set of fixed points given by normalized parameters on edge and set of points parameterized on the edge (from 1 to 0) and a number of segments for each
set of numbers of segments for splitting each sub-segment between interval limited by the points.
fixed points. Optionally it is possible to set flag
<b>Same Nb. Segments for all intervals</b> and
only one value for mentioned number of segments.
The direction of the splitting is defined by the orientation of the \image html hypo_fixedpnt_dlg.png
It is possible to check in <b>Same Nb. Segments for all intervals</b>
option and to define one value for all intervals.
The splitting direction is defined by the orientation of the
underlying geometrical edge. <b>"Reverse Edges"</b> list box allows to underlying geometrical edge. <b>"Reverse Edges"</b> list box allows to
specify the edges for which the splitting should be made in the specify the edges for which the splitting should be made in the
direction opposing to their orientation. This list box is enabled only direction opposite to their orientation. This list box is enabled only
if the geometry object is selected for the meshing. In this case the if the geometrical object is selected for meshing. In this case it is
user can select edges to be reversed either directly picking them in possible to select the edges to be reversed either directly picking them in
the 3D viewer or by selecting the edges or groups of edges in the the 3D viewer or selecting the edges or groups of edges in the
Object browser. Object browser.
Using of this hypothesis for quadrangle face where main mesh is \image html mesh_fixedpnt.png "Example of a submesh on the edge built using Fixed points 1D hypothesis"
created using <b>Quadrangle(Mapping)</b> and <b>NumberOfSegments</b>
hypothesises. Creation hypothesis <b>FixedPoint_1D</b> for submesh on
one edge:
\image html hypo_fixedpnt_dlg.png <b>See Also</b> a sample TUI Script of a
\ref tui_fixed_points "Defining Fixed Points" hypothesis operation.
Resulting 2D mesh:
\image html mesh_fixedpnt.png
*/ */

14
doc/salome/gui/SMESH/input/2d_meshing_hypo.doc
View File

@ -23,6 +23,8 @@ which will compose the mesh of these 2D faces.
\image html a-maxelarea.png \image html a-maxelarea.png
\n
\image html max_el_area.png "In this example, Max. element area is very small compared to the 1D hypothesis" \image html max_el_area.png "In this example, Max. element area is very small compared to the 1D hypothesis"
<b>See Also</b> a sample TUI Script of a <b>See Also</b> a sample TUI Script of a
@ -52,6 +54,18 @@ used as a degenerated edge.
\image html hypo_quad_params_res.png "The resulting mesh" \image html hypo_quad_params_res.png "The resulting mesh"
This hypothesis can be also used to mesh a segment of a circular face.
Please, consider that there is a limitation on the selectiion of the degenerated
vertex for the faces built with the angle > 180 degrees (see the picture).
\image html hypo_quad_params_2.png "3/4 of a circular face"
In this case, selection of a wrong vertex for the <b>Quadrangle parameters</b>
hypothesis will generate a wrong mesh. The picture below
shows the good (left) and the bad (right) results of meshing.
\image html hypo_quad_params_res_2.png "The resulting meshes"
<br> <br>
\anchor quadrangle_preference_anchor \anchor quadrangle_preference_anchor
<h2>Quadrangle Preference</h2> <h2>Quadrangle Preference</h2>

1
doc/salome/gui/SMESH/input/about_hypo.doc
View File

@ -28,6 +28,7 @@ them, you operate numerical values):
<ul> <ul>
<li>\ref max_element_area_anchor "Max Element Area"</li> <li>\ref max_element_area_anchor "Max Element Area"</li>
<li>\ref length_from_edges_anchor "Length from Edges"</li> <li>\ref length_from_edges_anchor "Length from Edges"</li>
<li>\ref hypo_quad_params_anchor "Quadrangle Parameters"</li>
<li>\ref quadrangle_preference_anchor "Quadrangle Preference"</li> <li>\ref quadrangle_preference_anchor "Quadrangle Preference"</li>
<li>\ref triangle_preference_anchor "Triangle Preference"</li> <li>\ref triangle_preference_anchor "Triangle Preference"</li>
</ul> </ul>

2
doc/salome/gui/SMESH/input/basic_meshing_algos.doc
View File

@ -47,7 +47,7 @@ tetrahedral (pyramidal) elements.</li>
\image html image126.gif "Example of a hexahedral 3D mesh" \image html image126.gif "Example of a hexahedral 3D mesh"
</ul> </ul>
\Note that BLSURF and GHS3D are commercial meshers and require a \note BLSURF and GHS3D are commercial meshers and require a
license to be used within the Mesh module. license to be used within the Mesh module.
There is also a number of more specific algorithms: There is also a number of more specific algorithms:

38
doc/salome/gui/SMESH/input/blsurf_hypo.doc
View File

@ -207,22 +207,33 @@ String variables:
\image html blsurf_parameters_sizemap.png \image html blsurf_parameters_sizemap.png
It is possible to define user sizes on faces, edges or verteces. User sizes can be defined on faces, edges or vertices.
<ul> <ul>
<li>Those faces, edges and verteces must be sub-shapes (from explode command) of the meshed geometry object.</li> <li>The faces, edges and vertices can belong to the meshed geometrical
<li>Groups of faces, edges and verteces are also handled.</li> object or to its sub-shapes (created using <b>Explode</b> command).</li>
<li>Multi-selection is possible.</li> <li>Groups of faces, edges and vertices are also handled.</li>
<li>The sizes are constant values.</li> <li>It is possible to attribute the same size to several geometries using multi-selection.</li>
<li>The sizes are constant values or python functions.</li>
<li>In case of a python function, the following rules must be respected:
<ul>
<li>The name of the function is f.</li>
<li>If geometry is a face or a group of faces, the function is f(u,v).</li>
<li>If geometry is an edge or a group of edges, the function is f(t).</li>
<li>If geometry is a vertex or a group of vertices, the function is f().</li>
<li>The function must return a double.</li>
</ul></li>
</ul> </ul>
<br><b>See Also</b> a sample TUI Script of the \ref tui_blsurf "creation of a BLSurf hypothesis", including size map. <br><b>See Also</b> a sample TUI Script of the \ref tui_blsurf "creation of a BLSurf hypothesis", including size map.
\anchor blsurf_sizemap_computation \anchor blsurf_sizemap_computation
<h2>Computation of the physical size</h2> <h2>Computation of the physical size</h2>
Here is the detail on the calculation of the size (from BLSurf documentation).
\n \n
The size is obtained by querying sizemap functions associated to the input CAD object for surfaces, curves and points. The physical size is obtained by querying sizemap functions associated to the input CAD object for surfaces, curves and points.
Each function can either return a value h (which is then trimmed between the two bounds hphymin and hphymax), or "no answer" (by not assigning a value to h), thus providing great flexibility in the specification of the sizes. The computation depends whether point P is internal to a surface, internal to a curve, or at the end of several curves: Each function can either return a value h (which is then trimmed
between the two bounds hphymin and hphymax), or "no answer" (by not
assigning a value to h), thus providing great flexibility in the
specification of the sizes. The computation depends on whether point P is internal to a surface, internal to a curve, or at the end of several curves:
<ul> <ul>
<li> If point P is internal to a surface, the CAD surface size function is queried. If no answer is returned, one interpolates with the values at the vertices of the discretized interface curves.</li> <li> If point P is internal to a surface, the CAD surface size function is queried. If no answer is returned, one interpolates with the values at the vertices of the discretized interface curves.</li>
<li> If point P is internal to a curve, the CAD curve size function is queried first. If no answer is returned, the surface size function is queried for every adjacent surface and the mean value of the returned values is computed. If no answer is returned, sizes h1 and h2 at both ends of the curve are considered (see next item) and the interpolated value is computed.</li> <li> If point P is internal to a curve, the CAD curve size function is queried first. If no answer is returned, the surface size function is queried for every adjacent surface and the mean value of the returned values is computed. If no answer is returned, sizes h1 and h2 at both ends of the curve are considered (see next item) and the interpolated value is computed.</li>
@ -235,12 +246,13 @@ In order to compute the mean of several values, the arithmetic mean is used by d
\image html blsurf_parameters_enforced_vertices.png \image html blsurf_parameters_enforced_vertices.png
It is possible to define some enforced vertices to BLSurf algorithm without any vertex creation into the CAD. It is possible to define some enforced vertices to BLSurf algorithm
without creating any vertices by CAD algorithms.
<ul> <ul>
<li>Enforced vertices are the projection of a given point defines by its (x,y,z) coordinates on the concerned face.</li> <li>The enforced vertex is the projection of a point defined by its
<li>It is possible to define several enforced vertices on 1 face.</li> (x,y,z) coordinates on the selected face.</li>
<li>Group of faces are also handled.</li> <li>It is possible to define several enforced vertices on a face or a group of faces.</li>
<li>If the projection point is on the boundary or outside the face, then it will be ignored.</li> <li>If the projected point is on the boundary or outside of the face, it will be ignored.</li>
</ul> </ul>
<br><b>See Also</b> a sample TUI Script of the \ref tui_blsurf "creation of a BLSurf hypothesis", including enforced vertices. <br><b>See Also</b> a sample TUI Script of the \ref tui_blsurf "creation of a BLSurf hypothesis", including enforced vertices.

2
doc/salome/gui/SMESH/input/building_compounds.doc
View File

@ -47,4 +47,6 @@ for this operation.</li>
\image html image160.gif "Example of a compound of two meshed cubes" \image html image160.gif "Example of a compound of two meshed cubes"
<b>See Also</b> a sample
\ref tui_building_compound "TUI Example of building compounds."
*/ */

2
doc/salome/gui/SMESH/input/constructing_meshes.doc
View File

@ -126,7 +126,7 @@ visualizing the geometrical entity that causes it.
\image html failed_computation.png "Example of the invalid input mesh" \image html failed_computation.png "Example of the invalid input mesh"
\Note Mesh Computation Information box does not appear if you set \note Mesh Computation Information box does not appear if you set
"Mesh computation/Show a computation result notification" preference "Mesh computation/Show a computation result notification" preference
to the "Never" value. This option gives the possibility to control mesh to the "Never" value. This option gives the possibility to control mesh
computation reporting. There are the following possibilities: always computation reporting. There are the following possibilities: always

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

@ -37,4 +37,6 @@ The following dialog box will appear:
<li>Click the \b Apply or \b OK button.</li> <li>Click the \b Apply or \b OK button.</li>
</ol> </ol>
*/ <br><b>See Also</b> a sample TUI Script of a \ref tui_quadratic "Convert to/from quadratic" operation.
*/

12
doc/salome/gui/SMESH/input/editing_groups.doc
View File

@ -2,7 +2,7 @@
\page editing_groups_page Editing groups \page editing_groups_page Editing groups
\n <em>To edit an existing group of elements:</em> <em>To edit an existing group of elements:</em>
<ol> <ol>
<li>Select your group in the Object Browser and in the \b Mesh menu click <li>Select your group in the Object Browser and in the \b Mesh menu click
the <b>Edit Group</b> item or <em>"Edit Group"</em> button in the toolbar.</li> the <b>Edit Group</b> item or <em>"Edit Group"</em> button in the toolbar.</li>
@ -17,11 +17,12 @@ The following dialog box will appear:
In this dialog box you can modify the name of your group and add or In this dialog box you can modify the name of your group and add or
remove the elements forming it. For more information see remove the elements forming it. For more information see
\ref creating_groups_page "Creating Groups" page. \ref creating_groups_page "Creating Groups" page.
<li>Click the \b Apply or <b>Apply and Close</b> button to confirm modification of the <li>Click the \b Apply or <b>Apply and Close</b> button to confirm modification of the
group.</li> group.</li>
</ol> </ol>
\n <em>To convert an existing group on geometry into standalone group <em>To convert an existing group on geometry into standalone group
of elements and modify:</em> of elements and modify:</em>
<ol> <ol>
<li>Select your group on geometry in the Object Browser and in the \b Mesh menu click <li>Select your group on geometry in the Object Browser and in the \b Mesh menu click
@ -31,11 +32,12 @@ the <b>Edit Group as Standalone</b> item.</li>
<center><em>"Edit Group as Standalone" button</em></center> <center><em>"Edit Group as Standalone" button</em></center>
The group on geometry will be converted into standalone group and can The group on geometry will be converted into standalone group and can
be modified as group of elements be modified as group of elements.
<li>Click the \b Apply or <b>Apply and Close</b> button to confirm modification of the <li>Click the \b Apply or <b>Apply and Close</b> button to confirm modification of the
group.</li> group.</li>
</ol>
<br><b>See Also</b> a sample TUI Script of an \sa A sample TUI Script of an \ref tui_edit_group "Edit Group" operation.
\ref tui_edit_group "Edit Group" operation.
*/ */

9
doc/salome/gui/SMESH/input/free_faces.doc
View File

@ -2,16 +2,17 @@
\page free_faces_page Free faces \page free_faces_page Free faces
\n This mesh quality control highlights the faces connected to This mesh quality control highlights the faces connected to
less than two mesh volume elements. The free faces are shown with a less than two mesh volume elements. The free faces are shown with a
color different from the color of shared faces. color different from the color of shared faces.
\image html free_faces.png \image html free_faces.png
<center>In this picture some volume mesh elements have been removed, as
In this picture some volume mesh elements have been removed, as
a result some faces became connected only to one a result some faces became connected only to one
volume. i.e. became free. volume. i.e. became free.
<br><b>See Also</b> a sample TUI Script of a \sa A sample TUI Script of a \ref tui_free_faces "Free Faces quality control"
\ref tui_free_faces "Free Faces quality control" operation. operation.
*/ */

9
doc/salome/gui/SMESH/input/free_nodes.doc
View File

@ -2,14 +2,15 @@
\page free_nodes_page Free nodes \page free_nodes_page Free nodes
\n This mesh quality control highlights the nodes which are not connected This mesh quality control highlights the nodes which are not connected
to any mesh element. to any mesh element.
\image html free_nodes.png \image html free_nodes.png
<center>In this picture some nodes are not connected to any mesh
In this picture some nodes are not connected to any mesh
element after deleting some elements and adding several isolated nodes. element after deleting some elements and adding several isolated nodes.
<br><b>See Also</b> a sample TUI Script of a \sa A sample TUI Script of a \ref tui_free_nodes "Free Nodes quality control"
\ref tui_free_nodes "Free Nodes quality control" operation. operation.
*/ */

38
doc/salome/gui/SMESH/input/ghs3d_hypo.doc
View File

@ -56,16 +56,18 @@ together with the characteristics of the final mesh.
<li><b>To create new nodes</b> - if this option is checked off, ghs3d <li><b>To create new nodes</b> - if this option is checked off, ghs3d
tries to create tetrahedrons using only the nodes of the 2D mesh.</li> tries to create tetrahedrons using only the nodes of the 2D mesh.</li>
<li><b>To remove initial central point</b> - TetMesh-GHS3D adds an internal point <li><b>To remove the initial central point</b> TetMesh-GHS3D adds an internal point
at the centre of gravity of the bounding box in order to speed up and to simplify at the gravity centre of the bounding box to speed up and to simplify
the meshing process. It is however possible for TetMesh-GHS3D to refrain from creating the meshing process. However, it is possible to refrain from creating
this point by using the command line option -no initial central point. This can be this point by using the command line option -no initial central point. This can be
particularly useful to generate a volume mesh without internal points at all, and in some rare cases, particularly useful to generate a volume mesh without internal points at all and in some rare cases
to help the boundary regeneration phase when it failed with the standard options (for example when at the boundary regeneration phase when it is impossible to proceed
one dimension of the domain is large compared to the other two, with a ratio of 20 or more). with the standard options
Use this option when the boundary regeneration failed with the standard parameters and before using (for example, when one dimension of the domain is more than 20 times greater than the other two).
Use this option if the boundary regeneration has failed with the standard parameters and before using
the recovery version (command line option -C). the recovery version (command line option -C).
Note: when using this option, the speed of the meshing process may decrease, and quality may change. Note: when using this option, the speed of the meshing process may
decrease, and the quality may change.
Note: the boundary regeneration may fail with this option, in some rare cases.</li> Note: the boundary regeneration may fail with this option, in some rare cases.</li>
<li><b>To use boundary recovery version</b> - enables using a <li><b>To use boundary recovery version</b> - enables using a
@ -78,18 +80,18 @@ quality (poor aspect ratio of elements, tetrahedra with a very small
positive volume).</li> positive volume).</li>
<li><b>To use FEM correction</b> - Applies finite-element correction by <li><b>To use FEM correction</b> - Applies finite-element correction by
replacing overconstrained elements where it is possible. The process is replacing overconstrained elements where it is possible. At first the process
first slicing the overconstrained edges and second the overconstrained slices the overconstrained edges and at second the overconstrained
facets. This ensures that no edges have two boundary vertices and that facets. This ensures that there are no edges with two boundary
no facets have three boundary vertices. TetMesh-GHS3D gives the initial vertices and that there are no facets with three boundary vertices. TetMesh-GHS3D gives the initial
and final overconstrained edges and facets. It also gives the facets and final overconstrained edges and facets. It also gives the facets
which have three edges on the boundary. which have three edges on the boundary.
Note: when using this option, the speed of the meshing process may Note: when using this option, the speed of the meshing process may
decrease, quality may change, and the smallest volume may be smaller. decrease, quality may change, and the smallest volume may be smaller.
The default is no correction.</li> By default, the FEM correction is not used.</li>
<li><b>Option as text</b> - allows input of any text as command line <li><b>Option as text</b> - allows to input in the command line any text
for ghs3d. This allows the input of advanced options in a free from. </li> for ghs3d, for example, advanced options. </li>
</ul> </ul>
@ -98,9 +100,9 @@ for ghs3d. This allows the input of advanced options in a free from. </li>
\image html ghs3d_enforced_vertices.png \image html ghs3d_enforced_vertices.png
GHS3D algorithm can locally raffine the mesh. It is possible to define enforced vertices in the volume where the mesh will be raffined. GHS3D algorithm can locally make the mesh finer. It is possible to define enforced vertices in the volume where the mesh will be detailed.
A node will be created at the enforced vertex coordinates. There is no need to create a vertex in the CAD. A node will be created at the enforced vertex coordinates. There is no need to create a vertex in CAD.
An enforced vertex is defined by: An enforced vertex is defined by:
<ul> <ul>
@ -111,4 +113,4 @@ An enforced vertex is defined by:
<br><b>See Also</b> a sample TUI Script of the \ref tui_ghs3d "creation of a Ghs3D hypothesis", including enforced vertices. <br><b>See Also</b> a sample TUI Script of the \ref tui_ghs3d "creation of a Ghs3D hypothesis", including enforced vertices.
*/ */

8
doc/salome/gui/SMESH/input/grouping_elements.doc
View File

@ -12,19 +12,15 @@ dialog.</li>
<li> by creating a group of elements of the selected type from all <li> by creating a group of elements of the selected type from all
such elements of the chosen geometrical object - <b>Group on such elements of the chosen geometrical object - <b>Group on
geometry</b> tab of \ref creating_groups_page "Create group" dialog.</li> geometry</b> tab of \ref creating_groups_page "Create group" dialog.</li>
<li> by creating a group including all types of elements from an <li> by creating a group including all types of elements from an
existing geometrical object - using \subpage create_groups_from_geometry_page "Create Groups from Geometry" dialog.</li> existing geometrical object - using \subpage create_groups_from_geometry_page "Create Groups from Geometry" dialog.</li>
<li> by creating several groups of elements (nodes, <li> by creating several groups of elements (nodes,
edges, faces and volumes) from the chosen submesh - using <b>Mesh -> Construct edges, faces and volumes) from the chosen submesh - using <b>Mesh -> Construct
Group</b> Menu item. In this case groups of elements are created Group</b> Menu item. In this case groups of elements are created
automatically.</li> automatically.</li>
<li> by creating groups of entities from existing groups of superior <li> by creating groups of entities from existing groups of superior
dimensions - using \subpage group_of_underlying_elements_page "Create Group of Underlying Elements" dimensions - using \subpage group_of_underlying_elements_page "Create Group of Underlying Elements"
dialog.</li> dialog.</li>
</ul> </ul>
@ -32,12 +28,12 @@ The created groups can be later:
<ul> <ul>
<li>\subpage editing_groups_page "Edited"</li> <li>\subpage editing_groups_page "Edited"</li>
<li>\subpage using_operations_on_groups_page "Subjected to Boolean operations", or</li> <li>\subpage using_operations_on_groups_page "Subjected to Boolean operations"</li>
<li>\subpage deleting_groups_page "Deleted"</li> <li>\subpage deleting_groups_page "Deleted"</li>
</ul> </ul>
An important tool, providing filters for creation of \b Standalone An important tool, providing filters for creation of \b Standalone
groups is \subpage selection_filter_library_page</li>. groups is \subpage selection_filter_library_page.
*/ */

16
doc/salome/gui/SMESH/input/make_2dmesh_from_3d.doc
View File

@ -2,21 +2,21 @@
\page make_2dmesh_from_3d_page Generate the skin elements (2D) of a mesh having 3D elements \page make_2dmesh_from_3d_page Generate the skin elements (2D) of a mesh having 3D elements
\n This functionality allows you to generate 2D mesh elements as skin \n This functionality allows to generate 2D mesh elements as a skin
on existing 3D mesh elements on the existing 3D mesh elements.
<em>To generate 2D mesh:</em> <em>To generate 2D mesh:</em>
<ol> <ol>
<li>From the Modification menu choose the "Create 2D mesh from 3D" <li>From the Modification menu choose "Create 2D mesh from 3D"
Mesh item, or invoke from popup menu. item, or choose from the popup menu.
\image html 2d_from_3d_menu.png \image html 2d_from_3d_menu.png
The algorithm detects boundary volume faces without connections to The algorithm detects boundary volume faces without connections to
other volumes and create 2D mesh elements on face nodes. If mesh other volumes and creates 2D mesh elements on face nodes. If the mesh
already contains 2D elements on detected nodes - no new element already contains 2D elements on the detected nodes, new elements are not
created. The result dialog shows mesh information statistic about new created. The the resulting dialog shows mesh information statistics
created 2D mesh elements. about the newly created 2D mesh elements.
</ol> </ol>
*/ */

8
doc/salome/gui/SMESH/input/mesh_infos.doc
View File

@ -44,11 +44,6 @@ The following information will be displayed:
\image html advanced_mesh_infos.png \image html advanced_mesh_infos.png
In case you get Mesh Infos via a \ref tui_viewing_mesh_infos "TUI script",
the information is displayed in Python Console.
\image html b-mesh_infos.png
<br> <br>
\anchor mesh_element_info_anchor \anchor mesh_element_info_anchor
<h2>Mesh Element Info</h2> <h2>Mesh Element Info</h2>
@ -61,4 +56,7 @@ the Viewer.
\image html eleminfo2.png \image html eleminfo2.png
In case you get Mesh Infos via a TUI script the information is displayed in Python Console.
<b>See the</b> \ref tui_viewing_mesh_infos "TUI Example",
*/ */

92
doc/salome/gui/SMESH/input/netgen_2d_3d_hypo.doc
View File

@ -2,7 +2,7 @@
\page netgen_2d_3d_hypo_page Netgen 2D and 3D hypotheses \page netgen_2d_3d_hypo_page Netgen 2D and 3D hypotheses
\n <b>Netgen 2D</b> and <b>Netgen 3D</b> hypotheses work only with <b>Netgen 1D-2D</b> and <b>Netgen 2D</b> and <b>Netgen 3D</b> hypotheses work only with <b>Netgen 1D-2D</b> and
<b>Netgen 1D-2D-3D</b> algorithms. These algorithms do not require <b>Netgen 1D-2D-3D</b> algorithms. These algorithms do not require
definition of lower-level hypotheses and algorithms (2D and 1D for definition of lower-level hypotheses and algorithms (2D and 1D for
meshing 3D objects and 1D for meshing 2D objects). They prove to be meshing 3D objects and 1D for meshing 2D objects). They prove to be
@ -11,68 +11,64 @@ of the meshed object.
\image html netgen2d.png \image html netgen2d.png
<ul> - <b>Name</b> - allows to define the name for the algorithm (Netgen
<li><b>Name</b> - allows to define the name for the algorithm (Netgen 2D (or 3D) Parameters by default).
2D (or 3D) Parameters by default).</li> - <b>Max Size</b> - maximum linear dimensions for mesh cells.
<li><b>Max Size</b> - maximum linear dimensions for mesh cells.</li> - <b>Second Order</b> - if this box is checked in, the algorithm will
<li><b>Second Order</b> - if this box is checked in, the algorithm will
create second order nodes on the mesh, which actually will become create second order nodes on the mesh, which actually will become
\ref adding_quadratic_elements_page "Quadratic".</li> \ref adding_quadratic_elements_page "Quadratic".
<li><b>Fineness</b> - ranging from Very Coarse to Very Fine allows to set the - <b>Fineness</b> - ranging from Very Coarse to Very Fine allows to set the
level of meshing detalization using the three parameters below. You level of meshing detalization using the three parameters below. You
can select Custom to define them manually.</li> can select Custom to define them manually.
<li><b>Growth rate</b> - allows to define how much the linear dimensions of - <b>Growth rate</b> - allows to define how much the linear dimensions of
two adjacent cells can differ (i.e. 0.3 means 30%).</li> two adjacent cells can differ (i.e. 0.3 means 30%).
<li><b>Nb. Segs per Edge</b> and <b>Nb Segs per Radius</b> - allows to define the - <b>Nb. Segs per Edge</b> and <b>Nb Segs per Radius</b> - allows to define the
minimum number of mesh segments in which edges and radiuses will be minimum number of mesh segments in which edges and radiuses will be
split.</li> split.
<li><b>Allow Quadrangles</b> - allows to use quadrangle elements in a - <b>Allow Quadrangles</b> - allows to use quadrangle elements in a
triangle 2D mesh. This checkbox is not present in Netgen 3D parameters triangle 2D mesh. This checkbox is not present in Netgen 3D parameters
because currently building a tetrahedral mesh with quadrangle faces is because currently building a tetrahedral mesh with quadrangle faces is
not possible.</li> not possible.
<li><b>Optimize</b> - if this box is checked in, the algorithm will try to - <b>Optimize</b> - if this box is checked in, the algorithm will try to
create regular (possessing even sides) elements.</li> create regular (possessing even sides) elements.
</ul>
\image html netgen3d_simple.png \image html netgen3d_simple.png
<b>Netgen 2D simple parameters</b> and <b>Netgen 3D simple parameters</b> allow defining the size of elements for each dimension. <br> <b>Netgen 2D simple parameters</b> and <b>Netgen 3D simple
parameters</b> allow defining the size of elements for each
dimension.
\b 1D group allows defining the size of 1D elements in either of two ways: \b 1D group allows defining the size of 1D elements in either of two ways:
<ul> - <b>Number of Segments</b> has the same sense as \ref
<li><b>Number of Segments</b> has the same sense as \ref
number_of_segments_anchor "Number of segments" hypothesis with number_of_segments_anchor "Number of segments" hypothesis with
equidistant distribution.</li> equidistant distribution.
<li><b>Average Length</b> has the same sense as \ref - <b>Average Length</b> has the same sense as \ref
average_length_anchor "Average Length" hypothesis.</li> average_length_anchor "Average Length" hypothesis.
</ul>
\b 2D group allows defining the size of 2D elements \b 2D group allows defining the size of 2D elements
<ul> - <b>Length from edges</b> if checked in, acts like \ref
<li><b>Length from edges</b> if checked in, acts like \ref length_from_edges_anchor "Length from Edges" hypothesis, else
length_from_edges_anchor "Length from Edges" hypothesis, else </li> - <b>Max. Element Area</b> defines the maximum element area like \ref
<li><b>Max. Element Area</b> defines the maximum element area like \ref max_element_area_anchor "Max Element Area" hypothesis.
max_element_area_anchor "Max Element Area" hypothesis. </li>
</ul>
\b 3D groups allows defining the size of 3D elements. \b 3D groups allows defining the size of 3D elements.
<ul> - <b>Length from faces</b> if checked in, the area of sides of
<li><b>Length from faces</b> if checked in, the area of sides of volumic elements will be equal to an average area of 2D elements, else
volumic elements will be equal to an average area of 2D elements, else </li> - <b>Max. Element Volume</b> defines the maximum element volume like
<li><b>Max. Element Volume</b> defines the maximum element volume like
\ref max_element_volume_hypo_page "Max Element Volume" \ref max_element_volume_hypo_page "Max Element Volume"
hypothesis.</li> hypothesis.
<ul>
\n Note that Netgen algorithm does not strictly follow the input \note Netgen algorithm does not strictly follow the input
parameters. The actual mesh can be more or less dense than required. There are several factors in it: parameters. The actual mesh can be more or less dense than
<ol> required. There are several factors in it:
<li> NETGEN does not actually use "NbOfSegments" parameter for discretization of - NETGEN does not actually use "NbOfSegments" parameter for discretization of
edge. This parameter is used only to define the local element size (size at the given point), so local sizes of adjacent edges influence each other. </li> edge. This parameter is used only to define the local element size
<li> NETGEN additionally restricts the element size according to edge curvature.</li> (size at the given point), so local sizes of adjacent edges influence
<li> The local size of edges influences the size of close triangles.</li> each other.
<li> The order of elements and their size in the 1D mesh generated by - NETGEN additionally restricts the element size according to edge curvature.
- The local size of edges influences the size of close triangles.
- The order of elements and their size in the 1D mesh generated by
NETGEN differ from those in the 1D mesh generated by Regular_1D NETGEN differ from those in the 1D mesh generated by Regular_1D
algorithm, resulting in different 2D and 3D meshes.</li> algorithm, resulting in different 2D and 3D meshes.
</ol>
*/ */

12
doc/salome/gui/SMESH/input/prism_3d_algo.doc
View File

@ -4,9 +4,9 @@
3D extrusion algorithm can be used for meshing prisms, i.e. <b>3D Shapes</b> 3D extrusion algorithm can be used for meshing prisms, i.e. <b>3D Shapes</b>
defined by two opposing faces having the same number of vertices and defined by two opposing faces having the same number of vertices and
edges and meshed using the \ref projection_algos_page "2D Projection" edges and meshed using, for example, the \ref projection_algos_page
algorithm. These two faces should be connected by quadrangle "side" "2D Projection" algorithm. These two faces should be connected by
faces. quadrangle "side" faces.
The opposing faces can be meshed with either quadrangles or triangles, The opposing faces can be meshed with either quadrangles or triangles,
while the side faces should be meshed with quadrangles only. while the side faces should be meshed with quadrangles only.
@ -17,4 +17,8 @@ As you can see, the <b>3D extrusion</b> algorithm permits to build and to
have in the same 3D mesh such elements as hexahedrons, prisms and have in the same 3D mesh such elements as hexahedrons, prisms and
polyhedrons. polyhedrons.
*/ \note This algorithm works correctly only if the opposing faces have
the same (or similar) meshing topography. Otherwise, 3D extrusion
algorithm can fail to build mesh volumes.
*/

24
doc/salome/gui/SMESH/input/radial_quadrangle_1D2D_algo.doc
View File

@ -2,27 +2,21 @@
\page radial_quadrangle_1D2D_algo_page Radial Quadrangle 1D2D \page radial_quadrangle_1D2D_algo_page Radial Quadrangle 1D2D
\n This algorithm applies to the meshing of a 2D shapes. \n This algorithm applies to the meshing of 2D shapes under the
Required conditions: Face must be a full circle or part of circle following conditions: the face must be a full circle or a part of circle
(i.e. number of edges <= 3 and one of them must be a circle curve). (i.e. the number of edges is less or equal to 3 and one of them is a circle curve).
The resulting mesh consists of triangles (near center point) and The resulting mesh consists of triangles (near the center point) and
quadrangles. quadrangles.
This algorithm also requires the information concerning the number and This algorithm requires the hypothesis indicating the number
distribution of mesh layers alond a radius of circle. Distribution of of mesh layers along the radius. The distribution of layers can be set with any 1D Hypothesis.
layers can be set with any of 1D Hypotheses.
Creation hypothesis:
\image html hypo_radquad_dlg.png \image html hypo_radquad_dlg.png
Resulting 3D mesh for the cylinder with <b>RadialQuadrangle_1D2D</b> \image html mesh_radquad_01.png "Radial Quadrangle 2D mesh on the top and the bottom faces of a cylinder"
hypothesis for top and bottom faces:
\image html mesh_radquad_01.png \image html mesh_radquad_02.png "Radial Quadrangle 2D mesh on a part of circle"
Resulting 2D mesh for the part of circle: \sa A sample \ref tui_radial_quadrangle "TUI Script".
\image html mesh_radquad_02.png
*/ */

191
doc/salome/gui/SMESH/input/smeshpy_interface.doc
View File

@ -2,129 +2,140 @@
\page smeshpy_interface_page Python interface \page smeshpy_interface_page Python interface
\n Python package smesh defines several classes, destined for easy and Python package smesh defines several classes, destined for easy and
clear mesh creation and edition. clear mesh creation and edition.
\n Documentation for smesh package is available in two forms: Documentation for smesh package is available in two forms:
\n The <a href="smeshpy_doc/modules.html"> structured The <a href="smeshpy_doc/modules.html"> structured
documentation for smesh package</a>, where all methods and documentation for smesh package</a>, where all methods and
classes are grouped by their functionality, like it is done in the GUI documentation classes are grouped by their functionality, like it is done in the GUI documentation
\n and the \ref smeshDC "linear documentation for smesh package" and the \ref smeshDC "linear documentation for smesh package"
grouped only by classes, declared in the smesh.py file. grouped only by classes, declared in the smesh.py file.
\n The main page of the \ref smeshDC "linear documentation for smesh package" The main page of the \ref smeshDC "linear documentation for smesh package"
contains a list of data structures and a list of contains a list of data structures and a list of
functions, provided by the package smesh.py. The first item in functions, provided by the package smesh.py. The first item in
the list of data structures (\ref smeshDC::smeshDC "class smesh") the list of data structures (\ref smeshDC::smeshDC "class smesh")
also represents documentation for the methods of the package smesh.py itself. also represents documentation for the methods of the package smesh.py itself.
\n The package smesh.py provides an interface to create and handle The package smesh.py provides an interface to create and handle
meshes. Use it to create an empty mesh or to import it from the data file. meshes. Use it to create an empty mesh or to import it from the data file.
\n Once a mesh has been created, it is possible to manage it via its own Once a mesh has been created, it is possible to manage it via its own
methods, described at \ref smeshDC::Mesh "class Mesh" documentation methods, described at \ref smeshDC::Mesh "class Mesh" documentation
(it is also accessible by the second item "class Mesh" in the list of data structures). (it is also accessible by the second item "class Mesh" in the list of data structures).
\n Class Mesh allows assigning algorithms to a mesh. Class \b Mesh allows assigning algorithms to a mesh.
\n Please note, that some algorithms, Please note, that some algorithms, included in the standard SALOME
included in the standard Salome installation are always available: distribution are always available:
- REGULAR(1D), COMPOSITE(1D), MEFISTO(2D), Quadrangle(2D), Hexa(3D), etc. - REGULAR (1D)
- COMPOSITE (1D)
- MEFISTO (2D)
- Quadrangle (2D)
- Hexa(3D)
- etc...
\n There are also some algorithms, which can be installed optionally, There are also some algorithms, which can be installed optionally,
\n some of them are based on open-source meshers: some of them are based on open-source meshers:
- NETGEN(1D-2D,2D,1D-2D-3D,3D), - NETGEN (1D-2D, 2D, 1D-2D-3D, 3D)
\n others are based on commercial meshers: ... and others are based on commercial meshers:
- GHS3D(3D), BLSURF(2D). - GHS3D (3D)
- BLSURF (2D)
\n To add hypotheses, use the interfaces, provided by the assigned To add hypotheses, use the interfaces, provided by the assigned
algorithms. algorithms.
\n Below you can see an example of usage of the package smesh for 3d mesh generation. Below you can see an example of usage of the package smesh for 3d mesh generation.
\anchor example_3d_mesh
<h2>Example of 3d mesh generation with NETGEN:</h2> <h2>Example of 3d mesh generation with NETGEN:</h2>
\n from geompy import * \code
\n import smesh from geompy import *
import smesh
<b># Geometry</b> ###
\n <b># an assembly of a box, a cylinder and a truncated cone meshed with tetrahedral</b>. # Geometry: an assembly of a box, a cylinder and a truncated cone
# meshed with tetrahedral
###
<b># Define values</b> # Define values
\n name = "ex21_lamp" name = "ex21_lamp"
\n cote = 60 cote = 60
\n section = 20 section = 20
\n size = 200 size = 200
\n radius_1 = 80 radius_1 = 80
\n radius_2 = 40 radius_2 = 40
\n height = 100 height = 100
<b># Build a box</b> # Build a box
\n box = MakeBox(-cote, -cote, -cote, +cote, +cote, +cote) box = MakeBox(-cote, -cote, -cote, +cote, +cote, +cote)
<b># Build a cylinder</b> # Build a cylinder
\n pt1 = MakeVertex(0, 0, cote/3) pt1 = MakeVertex(0, 0, cote/3)
\n di1 = MakeVectorDXDYDZ(0, 0, 1) di1 = MakeVectorDXDYDZ(0, 0, 1)
\n cyl = MakeCylinder(pt1, di1, section, size) cyl = MakeCylinder(pt1, di1, section, size)
<b># Build a truncated cone</b> # Build a truncated cone
\n pt2 = MakeVertex(0, 0, size) pt2 = MakeVertex(0, 0, size)
\n cone = MakeCone(pt2, di1, radius_1, radius_2, height) cone = MakeCone(pt2, di1, radius_1, radius_2, height)
<b># Fuse </b> # Fuse
\n box_cyl = MakeFuse(box, cyl) box_cyl = MakeFuse(box, cyl)
\n piece = MakeFuse(box_cyl, cone) piece = MakeFuse(box_cyl, cone)
<b># Add in study</b> # Add to the study
\n addToStudy(piece, name) addToStudy(piece, name)
<b># Create a group of faces</b> # Create a group of faces
\n group = CreateGroup(piece, ShapeType["FACE"]) group = CreateGroup(piece, ShapeType["FACE"])
\n group_name = name + "_grp" group_name = name + "_grp"
\n addToStudy(group, group_name) addToStudy(group, group_name)
\n group.SetName(group_name) group.SetName(group_name)
<b># Add faces in the group</b> # Add faces to the group
\n faces = SubShapeAllIDs(piece, ShapeType["FACE"]) faces = SubShapeAllIDs(piece, ShapeType["FACE"])
\n UnionIDs(group, faces) UnionIDs(group, faces)
<b># Create a mesh</b> ###
# Create a mesh
###
<b># Define a mesh on a geometry</b> # Define a mesh on a geometry
\n tetra = smesh.Mesh(piece, name) tetra = smesh.Mesh(piece, name)
<b># Define 1D hypothesis</b> # Define 1D hypothesis
\n algo1d = tetra.Segment() algo1d = tetra.Segment()
\n algo1d.LocalLength(10) algo1d.LocalLength(10)
<b># Define 2D hypothesis</b> # Define 2D hypothesis
\n algo2d = tetra.Triangle() algo2d = tetra.Triangle()
\n algo2d.LengthFromEdges() algo2d.LengthFromEdges()
<b># Define 3D hypothesis</b> # Define 3D hypothesis
\n algo3d = tetra.Tetrahedron(smesh.NETGEN) algo3d = tetra.Tetrahedron(smesh.NETGEN)
\n algo3d.MaxElementVolume(100) algo3d.MaxElementVolume(100)
<b># Compute the mesh</b> # Compute the mesh
\n tetra.Compute() tetra.Compute()
<b># Create a groupe of faces</b> # Create a groupe of faces
\n tetra.Group(group) tetra.Group(group)
\n Examples of Python scripts for all Mesh operations are available by \endcode
Examples of Python scripts for all Mesh operations are available by
the following links: the following links:
<ul> - \subpage tui_creating_meshes_page
<li>\subpage tui_creating_meshes_page</li> - \subpage tui_viewing_meshes_page
<li>\subpage tui_viewing_meshes_page</li> - \subpage tui_defining_hypotheses_page
<li>\subpage tui_defining_hypotheses_page</li> - \subpage tui_quality_controls_page
<li>\subpage tui_quality_controls_page</li> - \subpage tui_grouping_elements_page
<li>\subpage tui_grouping_elements_page</li> - \subpage tui_modifying_meshes_page
<li>\subpage tui_modifying_meshes_page</li> - \subpage tui_transforming_meshes_page
<li>\subpage tui_transforming_meshes_page</li> - \subpage tui_notebook_smesh_page
<li>\subpage tui_notebook_smesh_page</li>
</ul>
*/ */

8
doc/salome/gui/SMESH/input/translation.doc
View File

@ -64,13 +64,9 @@ name in the adjacent box);</li>
</ul> </ul>
</li> </li>
<li>Click \b Apply or <b> Apply and Close</b> button to confirm the <li>Click \b Apply or <b> Apply and Close</b> button to confirm the operation.</li>
operation.</li>
</ol> </ol>
<br><b>See Also</b> a sample TUI Script of a \ref tui_translation "Translation" operation.
<br><b>See Also</b> a sample TUI Script of a
\ref tui_translation "Translation" operation.
*/ */

2
doc/salome/gui/SMESH/input/tui_creating_meshes.doc
View File

@ -2,7 +2,7 @@
\page tui_creating_meshes_page Creating Meshes \page tui_creating_meshes_page Creating Meshes
\n First of all see \ref introduction_to_mesh_python_page "Example of 3d mesh generation", \n First of all see \ref example_3d_mesh "Example of 3d mesh generation",
which is an example of good python script style for Mesh module. which is an example of good python script style for Mesh module.
<br> <br>

74
doc/salome/gui/SMESH/input/tui_defining_hypotheses.doc
View File

@ -468,9 +468,83 @@ src_mesh.TranslateObject( src_mesh, MakeDirStruct( 210, 0, 0 ), Copy=False)
\endcode \endcode
<br>
\anchor tui_fixed_points
<h2>1D Mesh with Fixed Points example</h2>
\code
import salome
import geompy
import smesh
import StdMeshers
# Create face and explode it on edges
face = geompy.MakeFaceHW(100, 100, 1)
edges = geompy.SubShapeAllSorted(face, geompy.ShapeType["EDGE"])
geompy.addToStudy( face, "Face" )
# get the first edge from exploded result
edge1 = geompy.GetSubShapeID(face, edges[0])
# Define Mesh on previously created face
Mesh_1 = smesh.Mesh(face)
# Create Fixed Point 1D hypothesis and define parameters.
# Note: values greater than 1.0 and less than 0.0 are not taken into account;
# duplicated values are removed. Also, if not specified explicitly, values 0.0 and 1.0
# add added automatically.
# The number of segments should correspond to the number of points (NbSeg = NbPnt-1);
# extra values of segments splitting parameter are not taken into account,
# while missing values are considered to be equal to 1.
Fixed_points_1D_1 = smesh.CreateHypothesis('FixedPoints1D')
Fixed_points_1D_1.SetPoints( [ 1.1, 0.9, 0.5, 0.0, 0.5, -0.3 ] )
Fixed_points_1D_1.SetNbSegments( [ 3, 1, 2 ] )
Fixed_points_1D_1.SetReversedEdges( [edge1] )
# Add hypothesis to mesh and define 2D parameters
Mesh_1.AddHypothesis(Fixed_points_1D_1)
Regular_1D = Mesh_1.Segment()
Quadrangle_2D = Mesh_1.Quadrangle()
# Compute mesh
Mesh_1.Compute()
\endcode
\anchor tui_radial_quadrangle
<h2> Radial Quadrangle 1D2D example </h2>
\code
import salome
import geompy
import smesh
import StdMeshers
# Create face from the wire and add to study
WirePath = geompy.MakeSketcher("Sketcher:F 0 0:TT 20 0:R 90:C 20 90:WW", [0, 0, 0, 1, 0, 0, 0, 0, 1])
Face = geompy.MakeFace(WirePath,1)
geompy.addToStudy(Face,"Face")
# Define geometry for mesh, and 1D parameters
mesh = smesh.Mesh(Face)
Wire_discretisation = mesh.Segment()
Nb_Segments = Wire_discretisation.NumberOfSegments(5)
Nb_Segments.SetDistrType( 0 )
# Define 2D parameters and Radial Quadrange hypothesis
Number_of_Layers = smesh.CreateHypothesis('NumberOfLayers2D')
Number_of_Layers.SetNumberOfLayers( 4 )
mesh.AddHypothesis(Number_of_Layers)
RadialQuadrangle_1D2D = smesh.CreateHypothesis('RadialQuadrangle_1D2D')
mesh.AddHypothesis(RadialQuadrangle_1D2D)
mesh.Compute()
\endcode
\n Other meshing algorithms: \n Other meshing algorithms:
<ul> <ul>
<li>\subpage tui_defining_blsurf_hypotheses_page</li> <li>\subpage tui_defining_blsurf_hypotheses_page</li>
<li>\subpage tui_defining_ghs3d_hypotheses_page</li>
</ul> </ul>
*/ */

8
doc/salome/gui/SMESH/input/tui_grouping_elements.doc
View File

@ -1,4 +1,4 @@
/*! /*!
\page tui_grouping_elements_page Grouping Elements \page tui_grouping_elements_page Grouping Elements
@ -318,13 +318,13 @@ salome.sg.updateObjBrowser(1)
\endcode \endcode
\image html dimgroup_tui1.png \image html dimgroup_tui1.png
<center>Source groups of faces<\center> <center>Source groups of faces</center>
\image html dimgroup_tui2.png \image html dimgroup_tui2.png
<center>Result groups of edges and nodes<\center> <center>Result groups of edges and nodes</center>
*/ */

46
doc/salome/gui/SMESH/input/tui_modifying_meshes.doc
View File

@ -815,4 +815,48 @@ isDone = pattern.MakeMesh(Mesh_1.GetMesh(), 0, 0)
if (isDone != 1): print 'MakeMesh :', pattern.GetErrorCode() if (isDone != 1): print 'MakeMesh :', pattern.GetErrorCode()
\endcode \endcode
*/ <br>
\anchor tui_quadratic
<h2>Convert mesh to/from quadratic</h2>
\code
import geompy
import smesh
# create sphere of radius 100
Sphere = geompy.MakeSphereR( 100 )
geompy.addToStudy( Sphere, "Sphere" )
# create simple trihedral mesh
Mesh = smesh.Mesh(Sphere)
Regular_1D = Mesh.Segment()
Nb_Segments = Regular_1D.NumberOfSegments(5)
MEFISTO_2D = Mesh.Triangle()
Tetrahedron_Netgen = Mesh.Tetrahedron(algo=smesh.NETGEN)
# compute mesh
isDone = Mesh.Compute()
# convert to quadratic
# 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
Mesh.ConvertToQuadratic( theForce3d=1 )
# revert back to the non-quadratic mesh
Mesh.ConvertFromQuadratic()
# convert to quadratic
# theForce3d = 0; this results in the medium node lying at the
# geometrical edge from which the mesh element is built
Mesh.ConvertToQuadratic( theForce3d=0 )
\endcode
*/

43
doc/salome/gui/SMESH/input/tui_viewing_meshes.doc
View File

@ -9,10 +9,12 @@
\code \code
import geompy import geompy
import smesh import smesh
import SMESH
# create a box # create a box
box = geompy.MakeBox(0., 0., 0., 20., 20., 20.) box = geompy.MakeBox(0., 0., 0., 20., 20., 20.)
geompy.addToStudy(box, "box") geompy.addToStudy(box, "box")
[Face_1,Face_2,Face_3,Face_4,Face_5,Face_5] = geompy.SubShapeAll(box, geompy.ShapeType["FACE"])
# create a mesh # create a mesh
tetra = smesh.Mesh(box, "MeshBox") tetra = smesh.Mesh(box, "MeshBox")
@ -26,10 +28,22 @@ algo2D.MaxElementArea(10.)
algo3D = tetra.Tetrahedron(smesh.NETGEN) algo3D = tetra.Tetrahedron(smesh.NETGEN)
algo3D.MaxElementVolume(900.) algo3D.MaxElementVolume(900.)
# Creation of SubMesh
Regular_1D_1_1 = tetra.Segment(geom=Face_1)
Nb_Segments_1 = Regular_1D_1_1.NumberOfSegments(5)
Nb_Segments_1.SetDistrType( 0 )
Quadrangle_2D = tetra.Quadrangle(geom=Face_1)
isDone = tetra.Compute()
submesh = Regular_1D_1_1.GetSubMesh()
# compute the mesh # compute the mesh
tetra.Compute() tetra.Compute()
# print information about the mesh # Creation of group
group = tetra.CreateEmptyGroup( SMESH.FACE, 'Group' )
nbAdd = group.Add( [ 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76 ] )
# Print information about the mesh
print "Information about mesh:" print "Information about mesh:"
print "Number of nodes : ", tetra.NbNodes() print "Number of nodes : ", tetra.NbNodes()
print "Number of edges : ", tetra.NbEdges() print "Number of edges : ", tetra.NbEdges()
@ -43,5 +57,30 @@ print " hexahedrons : ", tetra.NbHexas()
print " prisms : ", tetra.NbPrisms() print " prisms : ", tetra.NbPrisms()
print " pyramids : ", tetra.NbPyramids() print " pyramids : ", tetra.NbPyramids()
print " polyhedrons : ", tetra.NbPolyhedrons() print " polyhedrons : ", tetra.NbPolyhedrons()
# Get Information About Mesh by GetMeshInfo
print "\nInformation about mesh by GetMeshInfo:"
info = smesh.GetMeshInfo(tetra)
keys = info.keys(); keys.sort()
for i in keys:
print " %s : %d" % ( i, info[i] )
pass
# Get Information About Group by GetMeshInfo
print "\nInformation about group by GetMeshInfo:"
info = smesh.GetMeshInfo(group)
keys = info.keys(); keys.sort()
for i in keys:
print " %s : %d" % ( i, info[i] )
pass
# Get Information About SubMesh by GetMeshInfo
print "\nInformation about Submesh by GetMeshInfo:"
info = smesh.GetMeshInfo(submesh)
keys = info.keys(); keys.sort()
for i in keys:
print " %s : %d" % ( i, info[i] )
pass
\endcode \endcode
*/
*/

2
doc/salome/gui/SMESH/input/viewing_meshes_overview.doc
View File

@ -38,7 +38,7 @@ meshes.</li>
<li>\subpage transparency_page "Transparency" - allows to change the <li>\subpage transparency_page "Transparency" - allows to change the
transparency of mesh elements.</li> transparency of mesh elements.</li>
<li>\subpage clipping_page "Clipping" - allows to create cross-sections of the selected objects.</li> <li>\subpage clipping_page "Clipping" - allows to create cross-sections of the selected objects.</li>
<li>\ref about_quality_controls_page "Controls" - graphically <li>\ref quality_page "Controls" - graphically
presents various information about meshes.</li> presents various information about meshes.</li>
<li><b>Hide</b> - allows to hide the selected mesh from the viewer.</li> <li><b>Hide</b> - allows to hide the selected mesh from the viewer.</li>
<li><b>Show Only</b> -allows to display only the selected mesh, hiding all other from the viewer.</li> <li><b>Show Only</b> -allows to display only the selected mesh, hiding all other from the viewer.</li>

4
idl/SMESH_Mesh.idl
View File

@ -46,7 +46,6 @@ module SMESH
enum log_command enum log_command
{ {
ADD_NODE, ADD_NODE,
ADD_ELEM0D,
ADD_EDGE, ADD_EDGE,
ADD_TRIANGLE, ADD_TRIANGLE,
ADD_QUADRANGLE, ADD_QUADRANGLE,
@ -69,7 +68,8 @@ module SMESH
ADD_QUADTETRAHEDRON, ADD_QUADTETRAHEDRON,
ADD_QUADPYRAMID, ADD_QUADPYRAMID,
ADD_QUADPENTAHEDRON, ADD_QUADPENTAHEDRON,
ADD_QUADHEXAHEDRON ADD_QUADHEXAHEDRON,
ADD_ELEM0D
}; };
struct log_block struct log_block

75
idl/SMESH_MeshEditor.idl
View File

@ -696,6 +696,49 @@ module SMESH
* not creared - returns empty list * not creared - returns empty list
*/ */
long_array GetLastCreatedElems(); long_array GetLastCreatedElems();
/*!
* \brief Creates a hole in a mesh by doubling the nodes of some particular elements
* \param theNodes - identifiers of nodes to be doubled
* \param theModifiedElems - identifiers of elements to be updated by the new (doubled)
* nodes. If list of element identifiers is empty then nodes are doubled but
* they not assigned to elements
* \return TRUE if operation has been completed successfully, FALSE otherwise
* \sa DoubleNode(), DoubleNodeGroup(), DoubleNodeGroups()
*/
boolean DoubleNodes( in long_array theNodes, in long_array theModifiedElems );
/*!
* \brief Creates a hole in a mesh by doubling the nodes of some particular elements
* This method provided for convenience works as DoubleNodes() described above.
* \param theNodeId - identifier of node to be doubled.
* \param theModifiedElems - identifiers of elements to be updated.
* \return TRUE if operation has been completed successfully, FALSE otherwise
* \sa DoubleNodes(), DoubleNodeGroup(), DoubleNodeGroups()
*/
boolean DoubleNode( in long theNodeId, in long_array theModifiedElems );
/*!
* \brief Creates a hole in a mesh by doubling the nodes of some particular elements
* This method provided for convenience works as DoubleNodes() described above.
* \param theNodes - group of nodes to be doubled.
* \param theModifiedElems - group of elements to be updated.
* \return TRUE if operation has been completed successfully, FALSE otherwise
* \sa DoubleNode(), DoubleNodes(), DoubleNodeGroups()
*/
boolean DoubleNodeGroup( in SMESH_GroupBase theNodes,
in SMESH_GroupBase theModifiedElems );
/*!
\brief Creates a hole in a mesh by doubling the nodes of some particular elements
This method provided for convenience works as DoubleNodes() described above.
\param theNodes - list of groups of nodes to be doubled
\param theModifiedElems - list of groups of elements to be updated.
\return TRUE if operation has been completed successfully, FALSE otherwise
\sa DoubleNode(), DoubleNodeGroup(), DoubleNodes()
*/
boolean DoubleNodeGroups( in ListOfGroups theNodes,
in ListOfGroups theModifiedElems );
/*! /*!
* \brief Creates a hole in a mesh by doubling the nodes of some particular elements * \brief Creates a hole in a mesh by doubling the nodes of some particular elements
@ -707,9 +750,9 @@ module SMESH
* \return TRUE if operation has been completed successfully, FALSE otherwise * \return TRUE if operation has been completed successfully, FALSE otherwise
* \sa DoubleNodeGroup(), DoubleNodeGroups() * \sa DoubleNodeGroup(), DoubleNodeGroups()
*/ */
boolean DoubleNodes( in long_array theElems, boolean DoubleNodeElem( in long_array theElems,
in long_array theNodesNot, in long_array theNodesNot,
in long_array theAffectedElems ); in long_array theAffectedElems );
/*! /*!
* \brief Creates a hole in a mesh by doubling the nodes of some particular elements * \brief Creates a hole in a mesh by doubling the nodes of some particular elements
@ -722,9 +765,9 @@ module SMESH
* \return TRUE if operation has been completed successfully, FALSE otherwise * \return TRUE if operation has been completed successfully, FALSE otherwise
* \sa DoubleNodeGroupInRegion(), DoubleNodeGroupsInRegion() * \sa DoubleNodeGroupInRegion(), DoubleNodeGroupsInRegion()
*/ */
boolean DoubleNodesInRegion( in long_array theElems, boolean DoubleNodeElemInRegion( in long_array theElems,
in long_array theNodesNot, in long_array theNodesNot,
in GEOM::GEOM_Object theShape ); in GEOM::GEOM_Object theShape );
/*! /*!
* \brief Creates a hole in a mesh by doubling the nodes of some particular elements * \brief Creates a hole in a mesh by doubling the nodes of some particular elements
@ -736,9 +779,9 @@ module SMESH
* \return TRUE if operation has been completed successfully, FALSE otherwise * \return TRUE if operation has been completed successfully, FALSE otherwise
* \sa DoubleNodes(), DoubleNodeGroups() * \sa DoubleNodes(), DoubleNodeGroups()
*/ */
boolean DoubleNodeGroup( in SMESH_GroupBase theElems, boolean DoubleNodeElemGroup( in SMESH_GroupBase theElems,
in SMESH_GroupBase theNodesNot, in SMESH_GroupBase theNodesNot,
in SMESH_GroupBase theAffectedElems ); in SMESH_GroupBase theAffectedElems );
/*! /*!
* \brief Creates a hole in a mesh by doubling the nodes of some particular elements * \brief Creates a hole in a mesh by doubling the nodes of some particular elements
@ -751,7 +794,7 @@ module SMESH
* \return TRUE if operation has been completed successfully, FALSE otherwise * \return TRUE if operation has been completed successfully, FALSE otherwise
* \sa DoubleNodesInRegion(), DoubleNodeGroupsInRegion() * \sa DoubleNodesInRegion(), DoubleNodeGroupsInRegion()
*/ */
boolean DoubleNodeGroupInRegion( in SMESH_GroupBase theElems, boolean DoubleNodeElemGroupInRegion( in SMESH_GroupBase theElems,
in SMESH_GroupBase theNodesNot, in SMESH_GroupBase theNodesNot,
in GEOM::GEOM_Object theShape ); in GEOM::GEOM_Object theShape );
@ -765,9 +808,9 @@ module SMESH
* \return TRUE if operation has been completed successfully, FALSE otherwise * \return TRUE if operation has been completed successfully, FALSE otherwise
* \sa DoubleNodeGroup(), DoubleNodes() * \sa DoubleNodeGroup(), DoubleNodes()
*/ */
boolean DoubleNodeGroups( in ListOfGroups theElems, boolean DoubleNodeElemGroups( in ListOfGroups theElems,
in ListOfGroups theNodesNot, in ListOfGroups theNodesNot,
in ListOfGroups theAffectedElems ); in ListOfGroups theAffectedElems );
/*! /*!
* \brief Creates a hole in a mesh by doubling the nodes of some particular elements * \brief Creates a hole in a mesh by doubling the nodes of some particular elements
@ -780,9 +823,9 @@ module SMESH
* \return TRUE if operation has been completed successfully, FALSE otherwise * \return TRUE if operation has been completed successfully, FALSE otherwise
* \sa DoubleNodeGroupInRegion(), DoubleNodesInRegion() * \sa DoubleNodeGroupInRegion(), DoubleNodesInRegion()
*/ */
boolean DoubleNodeGroupsInRegion( in ListOfGroups theElems, boolean DoubleNodeElemGroupsInRegion( in ListOfGroups theElems,
in ListOfGroups theNodesNot, in ListOfGroups theNodesNot,
in GEOM::GEOM_Object theShape ); in GEOM::GEOM_Object theShape );
/*! /*!
* \brief Generated skin mesh (containing 2D cells) from 3D mesh * \brief Generated skin mesh (containing 2D cells) from 3D mesh

298
src/Controls/SMESH_Controls.cxx
View File

@ -149,21 +149,21 @@ namespace{
// SMDS_ElemIteratorPtr anIter = anEdge->nodesIterator(); // SMDS_ElemIteratorPtr anIter = anEdge->nodesIterator();
// if ( anIter != 0 ) { // if ( anIter != 0 ) {
// while( anIter->more() ) { // while( anIter->more() ) {
// const SMDS_MeshNode* aNode = (SMDS_MeshNode*)anIter->next(); // const SMDS_MeshNode* aNode = (SMDS_MeshNode*)anIter->next();
// if ( aNode == 0 ) // if ( aNode == 0 )
// return 0; // return 0;
// SMDS_ElemIteratorPtr anElemIter = aNode->GetInverseElementIterator(); // SMDS_ElemIteratorPtr anElemIter = aNode->GetInverseElementIterator();
// while( anElemIter->more() ) { // while( anElemIter->more() ) {
// const SMDS_MeshElement* anElem = anElemIter->next(); // const SMDS_MeshElement* anElem = anElemIter->next();
// if ( anElem != 0 && anElem->GetType() != SMDSAbs_Edge ) { // if ( anElem != 0 && anElem->GetType() != SMDSAbs_Edge ) {
// int anId = anElem->GetID(); // int anId = anElem->GetID();
// if ( anIter->more() ) // i.e. first node // if ( anIter->more() ) // i.e. first node
// aMap.Add( anId ); // aMap.Add( anId );
// else if ( aMap.Contains( anId ) ) // else if ( aMap.Contains( anId ) )
// aResult++; // aResult++;
// } // }
// } // }
// } // }
// } // }
@ -476,9 +476,9 @@ namespace{
inline double getArea(double theHalfPerim, double theTria[3]){ inline double getArea(double theHalfPerim, double theTria[3]){
return sqrt(theHalfPerim* return sqrt(theHalfPerim*
(theHalfPerim-theTria[0])* (theHalfPerim-theTria[0])*
(theHalfPerim-theTria[1])* (theHalfPerim-theTria[1])*
(theHalfPerim-theTria[2])); (theHalfPerim-theTria[2]));
} }
inline double getVolume(double theLen[6]){ inline double getVolume(double theLen[6]){
@ -1036,160 +1036,160 @@ double Length2D::GetValue( long theElementId)
case SMDSAbs_Node: case SMDSAbs_Node:
case SMDSAbs_Edge: case SMDSAbs_Edge:
if (len == 2){ if (len == 2){
aVal = getDistance( P( 1 ), P( 2 ) ); aVal = getDistance( P( 1 ), P( 2 ) );
break; break;
} }
else if (len == 3){ // quadratic edge else if (len == 3){ // quadratic edge
aVal = getDistance(P( 1 ),P( 3 )) + getDistance(P( 3 ),P( 2 )); aVal = getDistance(P( 1 ),P( 3 )) + getDistance(P( 3 ),P( 2 ));
break; break;
} }
case SMDSAbs_Face: case SMDSAbs_Face:
if (len == 3){ // triangles if (len == 3){ // triangles
double L1 = getDistance(P( 1 ),P( 2 )); double L1 = getDistance(P( 1 ),P( 2 ));
double L2 = getDistance(P( 2 ),P( 3 )); double L2 = getDistance(P( 2 ),P( 3 ));
double L3 = getDistance(P( 3 ),P( 1 )); double L3 = getDistance(P( 3 ),P( 1 ));
aVal = Max(L1,Max(L2,L3)); aVal = Max(L1,Max(L2,L3));
break; break;
} }
else if (len == 4){ // quadrangles else if (len == 4){ // quadrangles
double L1 = getDistance(P( 1 ),P( 2 )); double L1 = getDistance(P( 1 ),P( 2 ));
double L2 = getDistance(P( 2 ),P( 3 )); double L2 = getDistance(P( 2 ),P( 3 ));
double L3 = getDistance(P( 3 ),P( 4 )); double L3 = getDistance(P( 3 ),P( 4 ));
double L4 = getDistance(P( 4 ),P( 1 )); double L4 = getDistance(P( 4 ),P( 1 ));
aVal = Max(Max(L1,L2),Max(L3,L4)); aVal = Max(Max(L1,L2),Max(L3,L4));
break; break;
} }
if (len == 6){ // quadratic triangles if (len == 6){ // quadratic triangles
double L1 = getDistance(P( 1 ),P( 2 )) + getDistance(P( 2 ),P( 3 )); double L1 = getDistance(P( 1 ),P( 2 )) + getDistance(P( 2 ),P( 3 ));
double L2 = getDistance(P( 3 ),P( 4 )) + getDistance(P( 4 ),P( 5 )); double L2 = getDistance(P( 3 ),P( 4 )) + getDistance(P( 4 ),P( 5 ));
double L3 = getDistance(P( 5 ),P( 6 )) + getDistance(P( 6 ),P( 1 )); double L3 = getDistance(P( 5 ),P( 6 )) + getDistance(P( 6 ),P( 1 ));
aVal = Max(L1,Max(L2,L3)); aVal = Max(L1,Max(L2,L3));
//cout<<"L1="<<L1<<" L2="<<L2<<"L3="<<L3<<" aVal="<<aVal<<endl; //cout<<"L1="<<L1<<" L2="<<L2<<"L3="<<L3<<" aVal="<<aVal<<endl;
break; break;
} }
else if (len == 8){ // quadratic quadrangles else if (len == 8){ // quadratic quadrangles
double L1 = getDistance(P( 1 ),P( 2 )) + getDistance(P( 2 ),P( 3 )); double L1 = getDistance(P( 1 ),P( 2 )) + getDistance(P( 2 ),P( 3 ));
double L2 = getDistance(P( 3 ),P( 4 )) + getDistance(P( 4 ),P( 5 )); double L2 = getDistance(P( 3 ),P( 4 )) + getDistance(P( 4 ),P( 5 ));
double L3 = getDistance(P( 5 ),P( 6 )) + getDistance(P( 6 ),P( 7 )); double L3 = getDistance(P( 5 ),P( 6 )) + getDistance(P( 6 ),P( 7 ));
double L4 = getDistance(P( 7 ),P( 8 )) + getDistance(P( 8 ),P( 1 )); double L4 = getDistance(P( 7 ),P( 8 )) + getDistance(P( 8 ),P( 1 ));
aVal = Max(Max(L1,L2),Max(L3,L4)); aVal = Max(Max(L1,L2),Max(L3,L4));
break; break;
} }
case SMDSAbs_Volume: case SMDSAbs_Volume:
if (len == 4){ // tetraidrs if (len == 4){ // tetraidrs
double L1 = getDistance(P( 1 ),P( 2 )); double L1 = getDistance(P( 1 ),P( 2 ));
double L2 = getDistance(P( 2 ),P( 3 )); double L2 = getDistance(P( 2 ),P( 3 ));
double L3 = getDistance(P( 3 ),P( 1 )); double L3 = getDistance(P( 3 ),P( 1 ));
double L4 = getDistance(P( 1 ),P( 4 )); double L4 = getDistance(P( 1 ),P( 4 ));
double L5 = getDistance(P( 2 ),P( 4 )); double L5 = getDistance(P( 2 ),P( 4 ));
double L6 = getDistance(P( 3 ),P( 4 )); double L6 = getDistance(P( 3 ),P( 4 ));
aVal = Max(Max(Max(L1,L2),Max(L3,L4)),Max(L5,L6)); aVal = Max(Max(Max(L1,L2),Max(L3,L4)),Max(L5,L6));
break; break;
} }
else if (len == 5){ // piramids else if (len == 5){ // piramids
double L1 = getDistance(P( 1 ),P( 2 )); double L1 = getDistance(P( 1 ),P( 2 ));
double L2 = getDistance(P( 2 ),P( 3 )); double L2 = getDistance(P( 2 ),P( 3 ));
double L3 = getDistance(P( 3 ),P( 1 )); double L3 = getDistance(P( 3 ),P( 1 ));
double L4 = getDistance(P( 4 ),P( 1 )); double L4 = getDistance(P( 4 ),P( 1 ));
double L5 = getDistance(P( 1 ),P( 5 )); double L5 = getDistance(P( 1 ),P( 5 ));
double L6 = getDistance(P( 2 ),P( 5 )); double L6 = getDistance(P( 2 ),P( 5 ));
double L7 = getDistance(P( 3 ),P( 5 )); double L7 = getDistance(P( 3 ),P( 5 ));
double L8 = getDistance(P( 4 ),P( 5 )); double L8 = getDistance(P( 4 ),P( 5 ));
aVal = Max(Max(Max(L1,L2),Max(L3,L4)),Max(L5,L6)); aVal = Max(Max(Max(L1,L2),Max(L3,L4)),Max(L5,L6));
aVal = Max(aVal,Max(L7,L8)); aVal = Max(aVal,Max(L7,L8));
break; break;
} }
else if (len == 6){ // pentaidres else if (len == 6){ // pentaidres
double L1 = getDistance(P( 1 ),P( 2 )); double L1 = getDistance(P( 1 ),P( 2 ));
double L2 = getDistance(P( 2 ),P( 3 )); double L2 = getDistance(P( 2 ),P( 3 ));
double L3 = getDistance(P( 3 ),P( 1 )); double L3 = getDistance(P( 3 ),P( 1 ));
double L4 = getDistance(P( 4 ),P( 5 )); double L4 = getDistance(P( 4 ),P( 5 ));
double L5 = getDistance(P( 5 ),P( 6 )); double L5 = getDistance(P( 5 ),P( 6 ));
double L6 = getDistance(P( 6 ),P( 4 )); double L6 = getDistance(P( 6 ),P( 4 ));
double L7 = getDistance(P( 1 ),P( 4 )); double L7 = getDistance(P( 1 ),P( 4 ));
double L8 = getDistance(P( 2 ),P( 5 )); double L8 = getDistance(P( 2 ),P( 5 ));
double L9 = getDistance(P( 3 ),P( 6 )); double L9 = getDistance(P( 3 ),P( 6 ));
aVal = Max(Max(Max(L1,L2),Max(L3,L4)),Max(L5,L6)); aVal = Max(Max(Max(L1,L2),Max(L3,L4)),Max(L5,L6));
aVal = Max(aVal,Max(Max(L7,L8),L9)); aVal = Max(aVal,Max(Max(L7,L8),L9));
break; break;
} }
else if (len == 8){ // hexaider else if (len == 8){ // hexaider
double L1 = getDistance(P( 1 ),P( 2 )); double L1 = getDistance(P( 1 ),P( 2 ));
double L2 = getDistance(P( 2 ),P( 3 )); double L2 = getDistance(P( 2 ),P( 3 ));
double L3 = getDistance(P( 3 ),P( 4 )); double L3 = getDistance(P( 3 ),P( 4 ));
double L4 = getDistance(P( 4 ),P( 1 )); double L4 = getDistance(P( 4 ),P( 1 ));
double L5 = getDistance(P( 5 ),P( 6 )); double L5 = getDistance(P( 5 ),P( 6 ));
double L6 = getDistance(P( 6 ),P( 7 )); double L6 = getDistance(P( 6 ),P( 7 ));
double L7 = getDistance(P( 7 ),P( 8 )); double L7 = getDistance(P( 7 ),P( 8 ));
double L8 = getDistance(P( 8 ),P( 5 )); double L8 = getDistance(P( 8 ),P( 5 ));
double L9 = getDistance(P( 1 ),P( 5 )); double L9 = getDistance(P( 1 ),P( 5 ));
double L10= getDistance(P( 2 ),P( 6 )); double L10= getDistance(P( 2 ),P( 6 ));
double L11= getDistance(P( 3 ),P( 7 )); double L11= getDistance(P( 3 ),P( 7 ));
double L12= getDistance(P( 4 ),P( 8 )); double L12= getDistance(P( 4 ),P( 8 ));
aVal = Max(Max(Max(L1,L2),Max(L3,L4)),Max(L5,L6)); aVal = Max(Max(Max(L1,L2),Max(L3,L4)),Max(L5,L6));
aVal = Max(aVal,Max(Max(L7,L8),Max(L9,L10))); aVal = Max(aVal,Max(Max(L7,L8),Max(L9,L10)));
aVal = Max(aVal,Max(L11,L12)); aVal = Max(aVal,Max(L11,L12));
break; break;
} }
if (len == 10){ // quadratic tetraidrs if (len == 10){ // quadratic tetraidrs
double L1 = getDistance(P( 1 ),P( 5 )) + getDistance(P( 5 ),P( 2 )); double L1 = getDistance(P( 1 ),P( 5 )) + getDistance(P( 5 ),P( 2 ));
double L2 = getDistance(P( 2 ),P( 6 )) + getDistance(P( 6 ),P( 3 )); double L2 = getDistance(P( 2 ),P( 6 )) + getDistance(P( 6 ),P( 3 ));
double L3 = getDistance(P( 3 ),P( 7 )) + getDistance(P( 7 ),P( 1 )); double L3 = getDistance(P( 3 ),P( 7 )) + getDistance(P( 7 ),P( 1 ));
double L4 = getDistance(P( 1 ),P( 8 )) + getDistance(P( 8 ),P( 4 )); double L4 = getDistance(P( 1 ),P( 8 )) + getDistance(P( 8 ),P( 4 ));
double L5 = getDistance(P( 2 ),P( 9 )) + getDistance(P( 9 ),P( 4 )); double L5 = getDistance(P( 2 ),P( 9 )) + getDistance(P( 9 ),P( 4 ));
double L6 = getDistance(P( 3 ),P( 10 )) + getDistance(P( 10 ),P( 4 )); double L6 = getDistance(P( 3 ),P( 10 )) + getDistance(P( 10 ),P( 4 ));
aVal = Max(Max(Max(L1,L2),Max(L3,L4)),Max(L5,L6)); aVal = Max(Max(Max(L1,L2),Max(L3,L4)),Max(L5,L6));
break; break;
} }
else if (len == 13){ // quadratic piramids else if (len == 13){ // quadratic piramids
double L1 = getDistance(P( 1 ),P( 6 )) + getDistance(P( 6 ),P( 2 )); double L1 = getDistance(P( 1 ),P( 6 )) + getDistance(P( 6 ),P( 2 ));
double L2 = getDistance(P( 2 ),P( 7 )) + getDistance(P( 7 ),P( 3 )); double L2 = getDistance(P( 2 ),P( 7 )) + getDistance(P( 7 ),P( 3 ));
double L3 = getDistance(P( 3 ),P( 8 )) + getDistance(P( 8 ),P( 1 )); double L3 = getDistance(P( 3 ),P( 8 )) + getDistance(P( 8 ),P( 1 ));
double L4 = getDistance(P( 4 ),P( 9 )) + getDistance(P( 9 ),P( 1 )); double L4 = getDistance(P( 4 ),P( 9 )) + getDistance(P( 9 ),P( 1 ));
double L5 = getDistance(P( 1 ),P( 10 )) + getDistance(P( 10 ),P( 5 )); double L5 = getDistance(P( 1 ),P( 10 )) + getDistance(P( 10 ),P( 5 ));
double L6 = getDistance(P( 2 ),P( 11 )) + getDistance(P( 11 ),P( 5 )); double L6 = getDistance(P( 2 ),P( 11 )) + getDistance(P( 11 ),P( 5 ));
double L7 = getDistance(P( 3 ),P( 12 )) + getDistance(P( 12 ),P( 5 )); double L7 = getDistance(P( 3 ),P( 12 )) + getDistance(P( 12 ),P( 5 ));
double L8 = getDistance(P( 4 ),P( 13 )) + getDistance(P( 13 ),P( 5 )); double L8 = getDistance(P( 4 ),P( 13 )) + getDistance(P( 13 ),P( 5 ));
aVal = Max(Max(Max(L1,L2),Max(L3,L4)),Max(L5,L6)); aVal = Max(Max(Max(L1,L2),Max(L3,L4)),Max(L5,L6));
aVal = Max(aVal,Max(L7,L8)); aVal = Max(aVal,Max(L7,L8));
break; break;
} }
else if (len == 15){ // quadratic pentaidres else if (len == 15){ // quadratic pentaidres
double L1 = getDistance(P( 1 ),P( 7 )) + getDistance(P( 7 ),P( 2 )); double L1 = getDistance(P( 1 ),P( 7 )) + getDistance(P( 7 ),P( 2 ));
double L2 = getDistance(P( 2 ),P( 8 )) + getDistance(P( 8 ),P( 3 )); double L2 = getDistance(P( 2 ),P( 8 )) + getDistance(P( 8 ),P( 3 ));
double L3 = getDistance(P( 3 ),P( 9 )) + getDistance(P( 9 ),P( 1 )); double L3 = getDistance(P( 3 ),P( 9 )) + getDistance(P( 9 ),P( 1 ));
double L4 = getDistance(P( 4 ),P( 10 )) + getDistance(P( 10 ),P( 5 )); double L4 = getDistance(P( 4 ),P( 10 )) + getDistance(P( 10 ),P( 5 ));
double L5 = getDistance(P( 5 ),P( 11 )) + getDistance(P( 11 ),P( 6 )); double L5 = getDistance(P( 5 ),P( 11 )) + getDistance(P( 11 ),P( 6 ));
double L6 = getDistance(P( 6 ),P( 12 )) + getDistance(P( 12 ),P( 4 )); double L6 = getDistance(P( 6 ),P( 12 )) + getDistance(P( 12 ),P( 4 ));
double L7 = getDistance(P( 1 ),P( 13 )) + getDistance(P( 13 ),P( 4 )); double L7 = getDistance(P( 1 ),P( 13 )) + getDistance(P( 13 ),P( 4 ));
double L8 = getDistance(P( 2 ),P( 14 )) + getDistance(P( 14 ),P( 5 )); double L8 = getDistance(P( 2 ),P( 14 )) + getDistance(P( 14 ),P( 5 ));
double L9 = getDistance(P( 3 ),P( 15 )) + getDistance(P( 15 ),P( 6 )); double L9 = getDistance(P( 3 ),P( 15 )) + getDistance(P( 15 ),P( 6 ));
aVal = Max(Max(Max(L1,L2),Max(L3,L4)),Max(L5,L6)); aVal = Max(Max(Max(L1,L2),Max(L3,L4)),Max(L5,L6));
aVal = Max(aVal,Max(Max(L7,L8),L9)); aVal = Max(aVal,Max(Max(L7,L8),L9));
break; break;
} }
else if (len == 20){ // quadratic hexaider else if (len == 20){ // quadratic hexaider
double L1 = getDistance(P( 1 ),P( 9 )) + getDistance(P( 9 ),P( 2 )); double L1 = getDistance(P( 1 ),P( 9 )) + getDistance(P( 9 ),P( 2 ));
double L2 = getDistance(P( 2 ),P( 10 )) + getDistance(P( 10 ),P( 3 )); double L2 = getDistance(P( 2 ),P( 10 )) + getDistance(P( 10 ),P( 3 ));
double L3 = getDistance(P( 3 ),P( 11 )) + getDistance(P( 11 ),P( 4 )); double L3 = getDistance(P( 3 ),P( 11 )) + getDistance(P( 11 ),P( 4 ));
double L4 = getDistance(P( 4 ),P( 12 )) + getDistance(P( 12 ),P( 1 )); double L4 = getDistance(P( 4 ),P( 12 )) + getDistance(P( 12 ),P( 1 ));
double L5 = getDistance(P( 5 ),P( 13 )) + getDistance(P( 13 ),P( 6 )); double L5 = getDistance(P( 5 ),P( 13 )) + getDistance(P( 13 ),P( 6 ));
double L6 = getDistance(P( 6 ),P( 14 )) + getDistance(P( 14 ),P( 7 )); double L6 = getDistance(P( 6 ),P( 14 )) + getDistance(P( 14 ),P( 7 ));
double L7 = getDistance(P( 7 ),P( 15 )) + getDistance(P( 15 ),P( 8 )); double L7 = getDistance(P( 7 ),P( 15 )) + getDistance(P( 15 ),P( 8 ));
double L8 = getDistance(P( 8 ),P( 16 )) + getDistance(P( 16 ),P( 5 )); double L8 = getDistance(P( 8 ),P( 16 )) + getDistance(P( 16 ),P( 5 ));
double L9 = getDistance(P( 1 ),P( 17 )) + getDistance(P( 17 ),P( 5 )); double L9 = getDistance(P( 1 ),P( 17 )) + getDistance(P( 17 ),P( 5 ));
double L10= getDistance(P( 2 ),P( 18 )) + getDistance(P( 18 ),P( 6 )); double L10= getDistance(P( 2 ),P( 18 )) + getDistance(P( 18 ),P( 6 ));
double L11= getDistance(P( 3 ),P( 19 )) + getDistance(P( 19 ),P( 7 )); double L11= getDistance(P( 3 ),P( 19 )) + getDistance(P( 19 ),P( 7 ));
double L12= getDistance(P( 4 ),P( 20 )) + getDistance(P( 20 ),P( 8 )); double L12= getDistance(P( 4 ),P( 20 )) + getDistance(P( 20 ),P( 8 ));
aVal = Max(Max(Max(L1,L2),Max(L3,L4)),Max(L5,L6)); aVal = Max(Max(Max(L1,L2),Max(L3,L4)),Max(L5,L6));
aVal = Max(aVal,Max(Max(L7,L8),Max(L9,L10))); aVal = Max(aVal,Max(Max(L7,L8),Max(L9,L10)));
aVal = Max(aVal,Max(L11,L12)); aVal = Max(aVal,Max(L11,L12));
break; break;
} }
@ -1467,12 +1467,12 @@ void MultiConnection2D::GetValues(MValues& theValues){
Value aValue(aNodeId[1],aNodeId[2]); Value aValue(aNodeId[1],aNodeId[2]);
MValues::iterator aItr = theValues.find(aValue); MValues::iterator aItr = theValues.find(aValue);
if (aItr != theValues.end()){ if (aItr != theValues.end()){
aItr->second += 1; aItr->second += 1;
//aNbConnects = nb; //aNbConnects = nb;
} }
else { else {
theValues[aValue] = 1; theValues[aValue] = 1;
//aNbConnects = 1; //aNbConnects = 1;
} }
//cout << "NodeIds: "<<aNodeId[1]<<","<<aNodeId[2]<<" nbconn="<<aNbConnects<<endl; //cout << "NodeIds: "<<aNodeId[1]<<","<<aNodeId[2]<<" nbconn="<<aNbConnects<<endl;
aNodeId[1] = aNodeId[2]; aNodeId[1] = aNodeId[2];
@ -1651,8 +1651,8 @@ bool FreeEdges::Border::operator<(const FreeEdges::Border& x) const{
} }
inline void UpdateBorders(const FreeEdges::Border& theBorder, inline void UpdateBorders(const FreeEdges::Border& theBorder,
FreeEdges::TBorders& theRegistry, FreeEdges::TBorders& theRegistry,
FreeEdges::TBorders& theContainer) FreeEdges::TBorders& theContainer)
{ {
if(theRegistry.find(theBorder) == theRegistry.end()){ if(theRegistry.find(theBorder) == theRegistry.end()){
theRegistry.insert(theBorder); theRegistry.insert(theBorder);
@ -1938,8 +1938,10 @@ bool ElemGeomType::IsSatisfy( long theId )
{ {
if (!myMesh) return false; if (!myMesh) return false;
const SMDS_MeshElement* anElem = myMesh->FindElement( theId ); const SMDS_MeshElement* anElem = myMesh->FindElement( theId );
if ( !anElem )
return false;
const SMDSAbs_ElementType anElemType = anElem->GetType(); const SMDSAbs_ElementType anElemType = anElem->GetType();
if ( !anElem || (myType != SMDSAbs_All && anElemType != myType) ) if ( myType != SMDSAbs_All && anElemType != myType )
return false; return false;
const int aNbNode = anElem->NbNodes(); const int aNbNode = anElem->NbNodes();
bool isOk = false; bool isOk = false;
@ -2412,15 +2414,15 @@ void Filter::SetPredicate( PredicatePtr thePredicate )
template<class TElement, class TIterator, class TPredicate> template<class TElement, class TIterator, class TPredicate>
inline void FillSequence(const TIterator& theIterator, inline void FillSequence(const TIterator& theIterator,
TPredicate& thePredicate, TPredicate& thePredicate,
Filter::TIdSequence& theSequence) Filter::TIdSequence& theSequence)
{ {
if ( theIterator ) { if ( theIterator ) {
while( theIterator->more() ) { while( theIterator->more() ) {
TElement anElem = theIterator->next(); TElement anElem = theIterator->next();
long anId = anElem->GetID(); long anId = anElem->GetID();
if ( thePredicate->IsSatisfy( anId ) ) if ( thePredicate->IsSatisfy( anId ) )
theSequence.push_back( anId ); theSequence.push_back( anId );
} }
} }
} }
@ -2428,8 +2430,8 @@ inline void FillSequence(const TIterator& theIterator,
void void
Filter:: Filter::
GetElementsId( const SMDS_Mesh* theMesh, GetElementsId( const SMDS_Mesh* theMesh,
PredicatePtr thePredicate, PredicatePtr thePredicate,
TIdSequence& theSequence ) TIdSequence& theSequence )
{ {
theSequence.clear(); theSequence.clear();
@ -2462,7 +2464,7 @@ GetElementsId( const SMDS_Mesh* theMesh,
void void
Filter::GetElementsId( const SMDS_Mesh* theMesh, Filter::GetElementsId( const SMDS_Mesh* theMesh,
Filter::TIdSequence& theSequence ) Filter::TIdSequence& theSequence )
{ {
GetElementsId(theMesh,myPredicate,theSequence); GetElementsId(theMesh,myPredicate,theSequence);
} }

32
src/Controls/SMESH_ControlsDef.hxx
View File

@ -132,9 +132,9 @@ namespace SMESH{
void SetPrecision( const long thePrecision ); void SetPrecision( const long thePrecision );
bool GetPoints(const int theId, bool GetPoints(const int theId,
TSequenceOfXYZ& theRes) const; TSequenceOfXYZ& theRes) const;
static bool GetPoints(const SMDS_MeshElement* theElem, static bool GetPoints(const SMDS_MeshElement* theElem,
TSequenceOfXYZ& theRes); TSequenceOfXYZ& theRes);
protected: protected:
const SMDS_Mesh* myMesh; const SMDS_Mesh* myMesh;
const SMDS_MeshElement* myCurrElement; const SMDS_MeshElement* myCurrElement;
@ -263,10 +263,10 @@ namespace SMESH{
virtual double GetBadRate( double Value, int nbNodes ) const; virtual double GetBadRate( double Value, int nbNodes ) const;
virtual SMDSAbs_ElementType GetType() const; virtual SMDSAbs_ElementType GetType() const;
struct Value{ struct Value{
double myLength; double myLength;
long myPntId[2]; long myPntId[2];
Value(double theLength, long thePntId1, long thePntId2); Value(double theLength, long thePntId1, long thePntId2);
bool operator<(const Value& x) const; bool operator<(const Value& x) const;
}; };
typedef std::set<Value> TValues; typedef std::set<Value> TValues;
void GetValues(TValues& theValues); void GetValues(TValues& theValues);
@ -296,9 +296,9 @@ namespace SMESH{
virtual double GetBadRate( double Value, int nbNodes ) const; virtual double GetBadRate( double Value, int nbNodes ) const;
virtual SMDSAbs_ElementType GetType() const; virtual SMDSAbs_ElementType GetType() const;
struct Value{ struct Value{
long myPntId[2]; long myPntId[2];
Value(long thePntId1, long thePntId2); Value(long thePntId1, long thePntId2);
bool operator<(const Value& x) const; bool operator<(const Value& x) const;
}; };
typedef std::map<Value,int> MValues; typedef std::map<Value,int> MValues;
@ -364,10 +364,10 @@ namespace SMESH{
static bool IsFreeEdge( const SMDS_MeshNode** theNodes, const int theFaceId ); static bool IsFreeEdge( const SMDS_MeshNode** theNodes, const int theFaceId );
typedef long TElemId; typedef long TElemId;
struct Border{ struct Border{
TElemId myElemId; TElemId myElemId;
TElemId myPntId[2]; TElemId myPntId[2];
Border(long theElemId, long thePntId1, long thePntId2); Border(long theElemId, long thePntId1, long thePntId2);
bool operator<(const Border& x) const; bool operator<(const Border& x) const;
}; };
typedef std::set<Border> TBorders; typedef std::set<Border> TBorders;
void GetBoreders(TBorders& theBorders); void GetBoreders(TBorders& theBorders);
@ -797,13 +797,13 @@ namespace SMESH{
virtual virtual
void void
GetElementsId( const SMDS_Mesh* theMesh, GetElementsId( const SMDS_Mesh* theMesh,
TIdSequence& theSequence ); TIdSequence& theSequence );
static static
void void
GetElementsId( const SMDS_Mesh* theMesh, GetElementsId( const SMDS_Mesh* theMesh,
PredicatePtr thePredicate, PredicatePtr thePredicate,
TIdSequence& theSequence ); TIdSequence& theSequence );
protected: protected:
PredicatePtr myPredicate; PredicatePtr myPredicate;

3
src/DriverDAT/DriverDAT_R_SMDS_Mesh.cxx
View File

@ -26,10 +26,13 @@
#include "utilities.h" #include "utilities.h"
#include <Basics_Utils.hxx>
using namespace std; using namespace std;
Driver_Mesh::Status DriverDAT_R_SMDS_Mesh::Perform() Driver_Mesh::Status DriverDAT_R_SMDS_Mesh::Perform()
{ {
Kernel_Utils::Localizer loc;
Status aResult = DRS_OK; Status aResult = DRS_OK;
int i, j; int i, j;

3
src/DriverDAT/DriverDAT_W_SMDS_Mesh.cxx
View File

@ -27,10 +27,13 @@
#include "utilities.h" #include "utilities.h"
#include <Basics_Utils.hxx>
using namespace std; using namespace std;
Driver_Mesh::Status DriverDAT_W_SMDS_Mesh::Perform() Driver_Mesh::Status DriverDAT_W_SMDS_Mesh::Perform()
{ {
Kernel_Utils::Localizer loc;
Status aResult = DRS_OK; Status aResult = DRS_OK;
int nbNodes, nbCells; int nbNodes, nbCells;

1
src/DriverDAT/Makefile.am
View File

@ -65,6 +65,7 @@ libMeshDriverDAT_la_CPPFLAGS = \
libMeshDriverDAT_la_LDFLAGS = \ libMeshDriverDAT_la_LDFLAGS = \
../Driver/libMeshDriver.la \ ../Driver/libMeshDriver.la \
$(KERNEL_LDFLAGS) -lSALOMEBasics \
$(CAS_KERNEL) $(CAS_KERNEL)
DAT_Test_CPPFLAGS = \ DAT_Test_CPPFLAGS = \

50
src/DriverMED/DriverMED_Family.cxx
View File

@ -23,12 +23,11 @@
// File : DriverMED_Family.cxx // File : DriverMED_Family.cxx
// Author : Julia DOROVSKIKH // Author : Julia DOROVSKIKH
// Module : SMESH // Module : SMESH
// $Header$
// //
#include "DriverMED_Family.h" #include "DriverMED_Family.h"
#include "MED_Factory.hxx" #include "MED_Factory.hxx"
#include <sstream> #include <sstream>
using namespace std; using namespace std;
@ -83,7 +82,7 @@ void
DriverMED_Family DriverMED_Family
::SetType(const SMDSAbs_ElementType theType) ::SetType(const SMDSAbs_ElementType theType)
{ {
myType = theType; myTypes.insert( myType = theType );
} }
SMDSAbs_ElementType SMDSAbs_ElementType
@ -93,6 +92,13 @@ DriverMED_Family
return myType; return myType;
} }
const std::set< SMDSAbs_ElementType >&
DriverMED_Family
::GetTypes() const
{
return myTypes;
}
bool bool
DriverMED_Family DriverMED_Family
::MemberOf(std::string theGroupName) const ::MemberOf(std::string theGroupName) const
@ -139,11 +145,11 @@ DriverMED_Family
DriverMED_FamilyPtrList DriverMED_FamilyPtrList
DriverMED_Family DriverMED_Family
::MakeFamilies(const SMESHDS_SubMeshPtrMap& theSubMeshes, ::MakeFamilies(const SMESHDS_SubMeshPtrMap& theSubMeshes,
const SMESHDS_GroupBasePtrList& theGroups, const SMESHDS_GroupBasePtrList& theGroups,
const bool doGroupOfNodes, const bool doGroupOfNodes,
const bool doGroupOfEdges, const bool doGroupOfEdges,
const bool doGroupOfFaces, const bool doGroupOfFaces,
const bool doGroupOfVolumes) const bool doGroupOfVolumes)
{ {
DriverMED_FamilyPtrList aFamilies; DriverMED_FamilyPtrList aFamilies;
@ -189,7 +195,7 @@ DriverMED_Family
aFamilies.erase(aCurrIter); aFamilies.erase(aCurrIter);
} }
if (aFam2->IsEmpty()) if (aFam2->IsEmpty())
break; break;
} }
} }
// The rest elements of family // The rest elements of family
@ -218,7 +224,7 @@ DriverMED_Family
aFam1->Split(aFam2, aCommon); aFam1->Split(aFam2, aCommon);
if (!aCommon->IsEmpty()) if (!aCommon->IsEmpty())
{ {
aCommon->SetGroupAttributVal(0); aCommon->SetGroupAttributVal(0);
aFamilies.push_back(aCommon); aFamilies.push_back(aCommon);
} }
if (aFam1->IsEmpty()) if (aFam1->IsEmpty())
@ -226,7 +232,7 @@ DriverMED_Family
aFamilies.erase(aCurrIter); aFamilies.erase(aCurrIter);
} }
if (aFam2->IsEmpty()) if (aFam2->IsEmpty())
break; break;
} }
} }
// The rest elements of group // The rest elements of group
@ -310,7 +316,7 @@ DriverMED_Family
//============================================================================= //=============================================================================
MED::PFamilyInfo MED::PFamilyInfo
DriverMED_Family::GetFamilyInfo(const MED::PWrapper& theWrapper, DriverMED_Family::GetFamilyInfo(const MED::PWrapper& theWrapper,
const MED::PMeshInfo& theMeshInfo) const const MED::PMeshInfo& theMeshInfo) const
{ {
ostringstream aStr; ostringstream aStr;
aStr << "FAM_" << myId; aStr << "FAM_" << myId;
@ -332,20 +338,20 @@ DriverMED_Family::GetFamilyInfo(const MED::PWrapper& theWrapper,
MED::PFamilyInfo anInfo; MED::PFamilyInfo anInfo;
if(myId == 0 || myGroupAttributVal == 0){ if(myId == 0 || myGroupAttributVal == 0){
anInfo = theWrapper->CrFamilyInfo(theMeshInfo, anInfo = theWrapper->CrFamilyInfo(theMeshInfo,
aValue, aValue,
myId, myId,
myGroupNames); myGroupNames);
}else{ }else{
MED::TStringVector anAttrDescs (1, ""); // 1 attribute with empty description, MED::TStringVector anAttrDescs (1, ""); // 1 attribute with empty description,
MED::TIntVector anAttrIds (1, myId); // Id=0, MED::TIntVector anAttrIds (1, myId); // Id=0,
MED::TIntVector anAttrVals (1, myGroupAttributVal); MED::TIntVector anAttrVals (1, myGroupAttributVal);
anInfo = theWrapper->CrFamilyInfo(theMeshInfo, anInfo = theWrapper->CrFamilyInfo(theMeshInfo,
aValue, aValue,
myId, myId,
myGroupNames, myGroupNames,
anAttrDescs, anAttrDescs,
anAttrIds, anAttrIds,
anAttrVals); anAttrVals);
} }
// cout << endl; // cout << endl;
@ -413,7 +419,7 @@ void DriverMED_Family::Init (SMESHDS_GroupBase* theGroup)
DriverMED_FamilyPtrList DriverMED_FamilyPtrList
DriverMED_Family DriverMED_Family
::SplitByType (SMESHDS_SubMesh* theSubMesh, ::SplitByType (SMESHDS_SubMesh* theSubMesh,
const int theId) const int theId)
{ {
DriverMED_FamilyPtrList aFamilies; DriverMED_FamilyPtrList aFamilies;
DriverMED_FamilyPtr aNodesFamily (new DriverMED_Family); DriverMED_FamilyPtr aNodesFamily (new DriverMED_Family);

19
src/DriverMED/DriverMED_Family.h
View File

@ -23,7 +23,6 @@
// File : DriverMED_Family.hxx // File : DriverMED_Family.hxx
// Author : Julia DOROVSKIKH // Author : Julia DOROVSKIKH
// Module : SMESH // Module : SMESH
// $Header$
// //
#ifndef _INCLUDE_DRIVERMED_FAMILY #ifndef _INCLUDE_DRIVERMED_FAMILY
#define _INCLUDE_DRIVERMED_FAMILY #define _INCLUDE_DRIVERMED_FAMILY
@ -68,16 +67,16 @@ class MESHDRIVERMED_EXPORT DriverMED_Family
static static
DriverMED_FamilyPtrList DriverMED_FamilyPtrList
MakeFamilies (const SMESHDS_SubMeshPtrMap& theSubMeshes, MakeFamilies (const SMESHDS_SubMeshPtrMap& theSubMeshes,
const SMESHDS_GroupBasePtrList& theGroups, const SMESHDS_GroupBasePtrList& theGroups,
const bool doGroupOfNodes, const bool doGroupOfNodes,
const bool doGroupOfEdges, const bool doGroupOfEdges,
const bool doGroupOfFaces, const bool doGroupOfFaces,
const bool doGroupOfVolumes); const bool doGroupOfVolumes);
//! Create TFamilyInfo for this family //! Create TFamilyInfo for this family
MED::PFamilyInfo MED::PFamilyInfo
GetFamilyInfo (const MED::PWrapper& theWrapper, GetFamilyInfo (const MED::PWrapper& theWrapper,
const MED::PMeshInfo& theMeshInfo) const; const MED::PMeshInfo& theMeshInfo) const;
//! Returns elements of this family //! Returns elements of this family
const ElementsSet& GetElements () const; const ElementsSet& GetElements () const;
@ -99,6 +98,7 @@ class MESHDRIVERMED_EXPORT DriverMED_Family
void SetType(const SMDSAbs_ElementType theType); void SetType(const SMDSAbs_ElementType theType);
SMDSAbs_ElementType GetType(); SMDSAbs_ElementType GetType();
const std::set< SMDSAbs_ElementType >& GetTypes() const;
bool MemberOf(std::string theGroupName) const; bool MemberOf(std::string theGroupName) const;
@ -113,7 +113,7 @@ class MESHDRIVERMED_EXPORT DriverMED_Family
static static
DriverMED_FamilyPtrList DriverMED_FamilyPtrList
SplitByType(SMESHDS_SubMesh* theSubMesh, SplitByType(SMESHDS_SubMesh* theSubMesh,
const int theId); const int theId);
/*! Remove from <Elements> elements, common with <by>, /*! Remove from <Elements> elements, common with <by>,
@ -121,7 +121,7 @@ class MESHDRIVERMED_EXPORT DriverMED_Family
Create family <common> from common elements, with combined groups list. Create family <common> from common elements, with combined groups list.
*/ */
void Split (DriverMED_FamilyPtr by, void Split (DriverMED_FamilyPtr by,
DriverMED_FamilyPtr common); DriverMED_FamilyPtr common);
//! Check, if this family has empty list of elements //! Check, if this family has empty list of elements
bool IsEmpty () const; bool IsEmpty () const;
@ -133,6 +133,7 @@ class MESHDRIVERMED_EXPORT DriverMED_Family
ElementsSet myElements; ElementsSet myElements;
MED::TStringSet myGroupNames; MED::TStringSet myGroupNames;
int myGroupAttributVal; int myGroupAttributVal;
std::set<SMDSAbs_ElementType> myTypes; // Issue 0020576
}; };
#endif #endif

459
src/DriverMED/DriverMED_R_SMESHDS_Mesh.cxx
View File

@ -48,10 +48,11 @@ static int MYDEBUG = 0;
#define _EDF_NODE_IDS_ #define _EDF_NODE_IDS_
using namespace MED; using namespace MED;
using namespace std;
void void
DriverMED_R_SMESHDS_Mesh DriverMED_R_SMESHDS_Mesh
::SetMeshName(std::string theMeshName) ::SetMeshName(string theMeshName)
{ {
myMeshName = theMeshName; myMeshName = theMeshName;
} }
@ -60,7 +61,7 @@ static const SMDS_MeshNode*
FindNode(const SMDS_Mesh* theMesh, TInt theId){ FindNode(const SMDS_Mesh* theMesh, TInt theId){
const SMDS_MeshNode* aNode = theMesh->FindNode(theId); const SMDS_MeshNode* aNode = theMesh->FindNode(theId);
if(aNode) return aNode; if(aNode) return aNode;
EXCEPTION(std::runtime_error,"SMDS_Mesh::FindNode - cannot find a SMDS_MeshNode for ID = "<<theId); EXCEPTION(runtime_error,"SMDS_Mesh::FindNode - cannot find a SMDS_MeshNode for ID = "<<theId);
} }
@ -79,88 +80,88 @@ DriverMED_R_SMESHDS_Mesh
aResult = DRS_EMPTY; aResult = DRS_EMPTY;
if(TInt aNbMeshes = aMed->GetNbMeshes()){ if(TInt aNbMeshes = aMed->GetNbMeshes()){
for(int iMesh = 0; iMesh < aNbMeshes; iMesh++){ for(int iMesh = 0; iMesh < aNbMeshes; iMesh++){
// Reading the MED mesh // Reading the MED mesh
//--------------------- //---------------------
PMeshInfo aMeshInfo = aMed->GetPMeshInfo(iMesh+1); PMeshInfo aMeshInfo = aMed->GetPMeshInfo(iMesh+1);
std::string aMeshName; string aMeshName;
if (myMeshId != -1) { if (myMeshId != -1) {
std::ostringstream aMeshNameStr; ostringstream aMeshNameStr;
aMeshNameStr<<myMeshId; aMeshNameStr<<myMeshId;
aMeshName = aMeshNameStr.str(); aMeshName = aMeshNameStr.str();
} else { } else {
aMeshName = myMeshName; aMeshName = myMeshName;
} }
if(MYDEBUG) MESSAGE("Perform - aMeshName : "<<aMeshName<<"; "<<aMeshInfo->GetName()); if(MYDEBUG) MESSAGE("Perform - aMeshName : "<<aMeshName<<"; "<<aMeshInfo->GetName());
if(aMeshName != aMeshInfo->GetName()) continue; if(aMeshName != aMeshInfo->GetName()) continue;
aResult = DRS_OK; aResult = DRS_OK;
//TInt aMeshDim = aMeshInfo->GetDim(); //TInt aMeshDim = aMeshInfo->GetDim();
// Reading MED families to the temporary structure // Reading MED families to the temporary structure
//------------------------------------------------ //------------------------------------------------
TErr anErr; TErr anErr;
TInt aNbFams = aMed->GetNbFamilies(aMeshInfo); TInt aNbFams = aMed->GetNbFamilies(aMeshInfo);
if(MYDEBUG) MESSAGE("Read " << aNbFams << " families"); if(MYDEBUG) MESSAGE("Read " << aNbFams << " families");
for (TInt iFam = 0; iFam < aNbFams; iFam++) { for (TInt iFam = 0; iFam < aNbFams; iFam++) {
PFamilyInfo aFamilyInfo = aMed->GetPFamilyInfo(aMeshInfo,iFam+1,&anErr); PFamilyInfo aFamilyInfo = aMed->GetPFamilyInfo(aMeshInfo,iFam+1,&anErr);
if(anErr >= 0){ if(anErr >= 0){
TInt aFamId = aFamilyInfo->GetId(); TInt aFamId = aFamilyInfo->GetId();
if(MYDEBUG) MESSAGE("Family " << aFamId << " :"); if(MYDEBUG) MESSAGE("Family " << aFamId << " :");
DriverMED_FamilyPtr aFamily (new DriverMED_Family); DriverMED_FamilyPtr aFamily (new DriverMED_Family);
TInt aNbGrp = aFamilyInfo->GetNbGroup(); TInt aNbGrp = aFamilyInfo->GetNbGroup();
if(MYDEBUG) MESSAGE("belong to " << aNbGrp << " groups"); if(MYDEBUG) MESSAGE("belong to " << aNbGrp << " groups");
bool isAttrOk = false; bool isAttrOk = false;
if(aFamilyInfo->GetNbAttr() == aNbGrp) if(aFamilyInfo->GetNbAttr() == aNbGrp)
isAttrOk = true; isAttrOk = true;
for (TInt iGr = 0; iGr < aNbGrp; iGr++) { for (TInt iGr = 0; iGr < aNbGrp; iGr++) {
std::string aGroupName = aFamilyInfo->GetGroupName(iGr); string aGroupName = aFamilyInfo->GetGroupName(iGr);
if(isAttrOk){ if(isAttrOk){
TInt anAttrVal = aFamilyInfo->GetAttrVal(iGr); TInt anAttrVal = aFamilyInfo->GetAttrVal(iGr);
aFamily->SetGroupAttributVal(anAttrVal); aFamily->SetGroupAttributVal(anAttrVal);
} }
if(MYDEBUG) MESSAGE(aGroupName); if(MYDEBUG) MESSAGE(aGroupName);
aFamily->AddGroupName(aGroupName); aFamily->AddGroupName(aGroupName);
} }
aFamily->SetId( aFamId ); aFamily->SetId( aFamId );
myFamilies[aFamId] = aFamily; myFamilies[aFamId] = aFamily;
} }
} }
if (aMeshInfo->GetType() == MED::eSTRUCTURE){ if (aMeshInfo->GetType() == MED::eSTRUCTURE){
/*bool aRes = */buildMeshGrille(aMed,aMeshInfo); /*bool aRes = */buildMeshGrille(aMed,aMeshInfo);
continue; continue;
} }
// Reading MED nodes to the corresponding SMDS structure // Reading MED nodes to the corresponding SMDS structure
//------------------------------------------------------ //------------------------------------------------------
PNodeInfo aNodeInfo = aMed->GetPNodeInfo(aMeshInfo); PNodeInfo aNodeInfo = aMed->GetPNodeInfo(aMeshInfo);
if (!aNodeInfo) { if (!aNodeInfo) {
aResult = DRS_FAIL; aResult = DRS_FAIL;
continue; continue;
} }
PCoordHelper aCoordHelper = GetCoordHelper(aNodeInfo); PCoordHelper aCoordHelper = GetCoordHelper(aNodeInfo);
EBooleen anIsNodeNum = aNodeInfo->IsElemNum(); EBooleen anIsNodeNum = aNodeInfo->IsElemNum();
TInt aNbElems = aNodeInfo->GetNbElem(); TInt aNbElems = aNodeInfo->GetNbElem();
if(MYDEBUG) MESSAGE("Perform - aNodeInfo->GetNbElem() = "<<aNbElems<<"; anIsNodeNum = "<<anIsNodeNum); if(MYDEBUG) MESSAGE("Perform - aNodeInfo->GetNbElem() = "<<aNbElems<<"; anIsNodeNum = "<<anIsNodeNum);
DriverMED_FamilyPtr aFamily; DriverMED_FamilyPtr aFamily;
for(TInt iElem = 0; iElem < aNbElems; iElem++){ for(TInt iElem = 0; iElem < aNbElems; iElem++){
TCCoordSlice aCoordSlice = aNodeInfo->GetCoordSlice(iElem); TCCoordSlice aCoordSlice = aNodeInfo->GetCoordSlice(iElem);
double aCoords[3] = {0.0, 0.0, 0.0}; double aCoords[3] = {0.0, 0.0, 0.0};
for(TInt iDim = 0; iDim < 3; iDim++) for(TInt iDim = 0; iDim < 3; iDim++)
aCoords[iDim] = aCoordHelper->GetCoord(aCoordSlice,iDim); aCoords[iDim] = aCoordHelper->GetCoord(aCoordSlice,iDim);
const SMDS_MeshNode* aNode; const SMDS_MeshNode* aNode;
if(anIsNodeNum) { if(anIsNodeNum) {
aNode = myMesh->AddNodeWithID aNode = myMesh->AddNodeWithID
(aCoords[0],aCoords[1],aCoords[2],aNodeInfo->GetElemNum(iElem)); (aCoords[0],aCoords[1],aCoords[2],aNodeInfo->GetElemNum(iElem));
} else { } else {
aNode = myMesh->AddNode aNode = myMesh->AddNode
(aCoords[0],aCoords[1],aCoords[2]); (aCoords[0],aCoords[1],aCoords[2]);
} }
//cout<<aNode->GetID()<<": "<<aNode->X()<<", "<<aNode->Y()<<", "<<aNode->Z()<<endl; //cout<<aNode->GetID()<<": "<<aNode->X()<<", "<<aNode->Y()<<", "<<aNode->Z()<<endl;
@ -174,44 +175,44 @@ DriverMED_R_SMESHDS_Mesh
} }
} }
// Reading pre information about all MED cells // Reading pre information about all MED cells
//-------------------------------------------- //--------------------------------------------
typedef MED::TVector<int> TNodeIds; typedef MED::TVector<int> TNodeIds;
bool takeNumbers = true; // initially we trust the numbers from file bool takeNumbers = true; // initially we trust the numbers from file
MED::TEntityInfo aEntityInfo = aMed->GetEntityInfo(aMeshInfo); MED::TEntityInfo aEntityInfo = aMed->GetEntityInfo(aMeshInfo);
MED::TEntityInfo::iterator anEntityIter = aEntityInfo.begin(); MED::TEntityInfo::iterator anEntityIter = aEntityInfo.begin();
for(; anEntityIter != aEntityInfo.end(); anEntityIter++){ for(; anEntityIter != aEntityInfo.end(); anEntityIter++){
const EEntiteMaillage& anEntity = anEntityIter->first; const EEntiteMaillage& anEntity = anEntityIter->first;
if(anEntity == eNOEUD) continue; if(anEntity == eNOEUD) continue;
// Reading MED cells to the corresponding SMDS structure // Reading MED cells to the corresponding SMDS structure
//------------------------------------------------------ //------------------------------------------------------
const MED::TGeom2Size& aGeom2Size = anEntityIter->second; const MED::TGeom2Size& aGeom2Size = anEntityIter->second;
MED::TGeom2Size::const_iterator aGeom2SizeIter = aGeom2Size.begin(); MED::TGeom2Size::const_iterator aGeom2SizeIter = aGeom2Size.begin();
for(; aGeom2SizeIter != aGeom2Size.end(); aGeom2SizeIter++){ for(; aGeom2SizeIter != aGeom2Size.end(); aGeom2SizeIter++){
const EGeometrieElement& aGeom = aGeom2SizeIter->first; const EGeometrieElement& aGeom = aGeom2SizeIter->first;
switch(aGeom) { switch(aGeom) {
// case ePOINT1: ## PAL16410 // case ePOINT1: ## PAL16410
// break; // break;
case ePOLYGONE: { case ePOLYGONE: {
PPolygoneInfo aPolygoneInfo = aMed->GetPPolygoneInfo(aMeshInfo,anEntity,aGeom); PPolygoneInfo aPolygoneInfo = aMed->GetPPolygoneInfo(aMeshInfo,anEntity,aGeom);
EBooleen anIsElemNum = takeNumbers ? aPolygoneInfo->IsElemNum() : eFAUX; EBooleen anIsElemNum = takeNumbers ? aPolygoneInfo->IsElemNum() : eFAUX;
TInt aNbElem = aPolygoneInfo->GetNbElem(); TInt aNbElem = aPolygoneInfo->GetNbElem();
for(TInt iElem = 0; iElem < aNbElem; iElem++){ for(TInt iElem = 0; iElem < aNbElem; iElem++){
MED::TCConnSlice aConnSlice = aPolygoneInfo->GetConnSlice(iElem); MED::TCConnSlice aConnSlice = aPolygoneInfo->GetConnSlice(iElem);
TInt aNbConn = aPolygoneInfo->GetNbConn(iElem); TInt aNbConn = aPolygoneInfo->GetNbConn(iElem);
TNodeIds aNodeIds(aNbConn); TNodeIds aNodeIds(aNbConn);
#ifdef _EDF_NODE_IDS_ #ifdef _EDF_NODE_IDS_
if(anIsNodeNum) if(anIsNodeNum)
for(TInt iConn = 0; iConn < aNbConn; iConn++) for(TInt iConn = 0; iConn < aNbConn; iConn++)
aNodeIds[iConn] = aNodeInfo->GetElemNum(aConnSlice[iConn] - 1); aNodeIds[iConn] = aNodeInfo->GetElemNum(aConnSlice[iConn] - 1);
else else
for(TInt iConn = 0; iConn < aNbConn; iConn++) for(TInt iConn = 0; iConn < aNbConn; iConn++)
aNodeIds[iConn] = aConnSlice[iConn]; aNodeIds[iConn] = aConnSlice[iConn];
#else #else
for(TInt iConn = 0; iConn < aNbConn; iConn++) for(TInt iConn = 0; iConn < aNbConn; iConn++)
aNodeIds[iConn] = aConnSlice[iConn]; aNodeIds[iConn] = aConnSlice[iConn];
#endif #endif
bool isRenum = false; bool isRenum = false;
SMDS_MeshElement* anElement = NULL; SMDS_MeshElement* anElement = NULL;
@ -221,12 +222,12 @@ DriverMED_R_SMESHDS_Mesh
try{ try{
#endif #endif
if(anIsElemNum){ if(anIsElemNum){
TInt anElemId = aPolygoneInfo->GetElemNum(iElem); TInt anElemId = aPolygoneInfo->GetElemNum(iElem);
anElement = myMesh->AddPolygonalFaceWithID(aNodeIds,anElemId); anElement = myMesh->AddPolygonalFaceWithID(aNodeIds,anElemId);
} }
if(!anElement){ if(!anElement){
std::vector<const SMDS_MeshNode*> aNodes(aNbConn); vector<const SMDS_MeshNode*> aNodes(aNbConn);
for(TInt iConn = 0; iConn < aNbConn; iConn++) for(TInt iConn = 0; iConn < aNbConn; iConn++)
aNodes[iConn] = FindNode(myMesh,aNodeIds[iConn]); aNodes[iConn] = FindNode(myMesh,aNodeIds[iConn]);
anElement = myMesh->AddPolygonalFace(aNodes); anElement = myMesh->AddPolygonalFace(aNodes);
isRenum = anIsElemNum; isRenum = anIsElemNum;
@ -256,107 +257,107 @@ DriverMED_R_SMESHDS_Mesh
} }
} }
break; break;
} }
case ePOLYEDRE: { case ePOLYEDRE: {
PPolyedreInfo aPolyedreInfo = aMed->GetPPolyedreInfo(aMeshInfo,anEntity,aGeom); PPolyedreInfo aPolyedreInfo = aMed->GetPPolyedreInfo(aMeshInfo,anEntity,aGeom);
EBooleen anIsElemNum = takeNumbers ? aPolyedreInfo->IsElemNum() : eFAUX; EBooleen anIsElemNum = takeNumbers ? aPolyedreInfo->IsElemNum() : eFAUX;
TInt aNbElem = aPolyedreInfo->GetNbElem(); TInt aNbElem = aPolyedreInfo->GetNbElem();
for(TInt iElem = 0; iElem < aNbElem; iElem++){ for(TInt iElem = 0; iElem < aNbElem; iElem++){
MED::TCConnSliceArr aConnSliceArr = aPolyedreInfo->GetConnSliceArr(iElem); MED::TCConnSliceArr aConnSliceArr = aPolyedreInfo->GetConnSliceArr(iElem);
TInt aNbFaces = aConnSliceArr.size(); TInt aNbFaces = aConnSliceArr.size();
typedef MED::TVector<int> TQuantities; typedef MED::TVector<int> TQuantities;
TQuantities aQuantities(aNbFaces); TQuantities aQuantities(aNbFaces);
TInt aNbNodes = aPolyedreInfo->GetNbNodes(iElem); TInt aNbNodes = aPolyedreInfo->GetNbNodes(iElem);
TNodeIds aNodeIds(aNbNodes); TNodeIds aNodeIds(aNbNodes);
for(TInt iFace = 0, iNode = 0; iFace < aNbFaces; iFace++){ for(TInt iFace = 0, iNode = 0; iFace < aNbFaces; iFace++){
MED::TCConnSlice aConnSlice = aConnSliceArr[iFace]; MED::TCConnSlice aConnSlice = aConnSliceArr[iFace];
TInt aNbConn = aConnSlice.size(); TInt aNbConn = aConnSlice.size();
aQuantities[iFace] = aNbConn; aQuantities[iFace] = aNbConn;
#ifdef _EDF_NODE_IDS_ #ifdef _EDF_NODE_IDS_
if(anIsNodeNum) if(anIsNodeNum)
for(TInt iConn = 0; iConn < aNbConn; iConn++) for(TInt iConn = 0; iConn < aNbConn; iConn++)
aNodeIds[iNode++] = aNodeInfo->GetElemNum(aConnSlice[iConn] - 1); aNodeIds[iNode++] = aNodeInfo->GetElemNum(aConnSlice[iConn] - 1);
else else
for(TInt iConn = 0; iConn < aNbConn; iConn++) for(TInt iConn = 0; iConn < aNbConn; iConn++)
aNodeIds[iNode++] = aConnSlice[iConn]; aNodeIds[iNode++] = aConnSlice[iConn];
#else #else
for(TInt iConn = 0; iConn < aNbConn; iConn++) for(TInt iConn = 0; iConn < aNbConn; iConn++)
aNodeIds[iNode++] = aConnSlice[iConn]; aNodeIds[iNode++] = aConnSlice[iConn];
#endif #endif
} }
bool isRenum = false; bool isRenum = false;
SMDS_MeshElement* anElement = NULL; SMDS_MeshElement* anElement = NULL;
TInt aFamNum = aPolyedreInfo->GetFamNum(iElem); TInt aFamNum = aPolyedreInfo->GetFamNum(iElem);
#ifndef _DEXCEPT_ #ifndef _DEXCEPT_
try{ try{
#endif #endif
if(anIsElemNum){ if(anIsElemNum){
TInt anElemId = aPolyedreInfo->GetElemNum(iElem); TInt anElemId = aPolyedreInfo->GetElemNum(iElem);
anElement = myMesh->AddPolyhedralVolumeWithID(aNodeIds,aQuantities,anElemId); anElement = myMesh->AddPolyhedralVolumeWithID(aNodeIds,aQuantities,anElemId);
} }
if(!anElement){ if(!anElement){
std::vector<const SMDS_MeshNode*> aNodes(aNbNodes); vector<const SMDS_MeshNode*> aNodes(aNbNodes);
for(TInt iConn = 0; iConn < aNbNodes; iConn++) for(TInt iConn = 0; iConn < aNbNodes; iConn++)
aNodes[iConn] = FindNode(myMesh,aNodeIds[iConn]); aNodes[iConn] = FindNode(myMesh,aNodeIds[iConn]);
anElement = myMesh->AddPolyhedralVolume(aNodes,aQuantities); anElement = myMesh->AddPolyhedralVolume(aNodes,aQuantities);
isRenum = anIsElemNum; isRenum = anIsElemNum;
} }
#ifndef _DEXCEPT_ #ifndef _DEXCEPT_
}catch(const std::exception& exc){ }catch(const std::exception& exc){
aResult = DRS_FAIL; aResult = DRS_FAIL;
}catch(...){ }catch(...){
aResult = DRS_FAIL; aResult = DRS_FAIL;
} }
#endif #endif
if(!anElement){ if(!anElement){
aResult = DRS_WARN_SKIP_ELEM; aResult = DRS_WARN_SKIP_ELEM;
}else{ }else{
if(isRenum){ if(isRenum){
anIsElemNum = eFAUX; anIsElemNum = eFAUX;
takeNumbers = false; takeNumbers = false;
if (aResult < DRS_WARN_RENUMBER) if (aResult < DRS_WARN_RENUMBER)
aResult = DRS_WARN_RENUMBER; aResult = DRS_WARN_RENUMBER;
} }
if ( checkFamilyID ( aFamily, aFamNum )) { if ( checkFamilyID ( aFamily, aFamNum )) {
// Save reference to this element from its family // Save reference to this element from its family
aFamily->AddElement(anElement); aFamily->AddElement(anElement);
aFamily->SetType(anElement->GetType()); aFamily->SetType(anElement->GetType());
} }
} }
} }
break; break;
} }
default: { default: {
PCellInfo aCellInfo = aMed->GetPCellInfo(aMeshInfo,anEntity,aGeom); PCellInfo aCellInfo = aMed->GetPCellInfo(aMeshInfo,anEntity,aGeom);
EBooleen anIsElemNum = takeNumbers ? aCellInfo->IsElemNum() : eFAUX; EBooleen anIsElemNum = takeNumbers ? aCellInfo->IsElemNum() : eFAUX;
TInt aNbElems = aCellInfo->GetNbElem(); TInt aNbElems = aCellInfo->GetNbElem();
if(MYDEBUG) MESSAGE("Perform - anEntity = "<<anEntity<<"; anIsElemNum = "<<anIsElemNum); if(MYDEBUG) MESSAGE("Perform - anEntity = "<<anEntity<<"; anIsElemNum = "<<anIsElemNum);
if(MYDEBUG) MESSAGE("Perform - aGeom = "<<aGeom<<"; aNbElems = "<<aNbElems); if(MYDEBUG) MESSAGE("Perform - aGeom = "<<aGeom<<"; aNbElems = "<<aNbElems);
TInt aNbNodes = -1;
switch(aGeom){
case eSEG2: aNbNodes = 2; break;
case eSEG3: aNbNodes = 3; break;
case eTRIA3: aNbNodes = 3; break;
case eTRIA6: aNbNodes = 6; break;
case eQUAD4: aNbNodes = 4; break;
case eQUAD8: aNbNodes = 8; break;
case eTETRA4: aNbNodes = 4; break;
case eTETRA10: aNbNodes = 10; break;
case ePYRA5: aNbNodes = 5; break;
case ePYRA13: aNbNodes = 13; break;
case ePENTA6: aNbNodes = 6; break;
case ePENTA15: aNbNodes = 15; break;
case eHEXA8: aNbNodes = 8; break;
case eHEXA20: aNbNodes = 20; break;
case ePOINT1: aNbNodes = 1; break;
default:;
}
vector<TInt> aNodeIds(aNbNodes);
for(int iElem = 0; iElem < aNbElems; iElem++){ for(int iElem = 0; iElem < aNbElems; iElem++){
TInt aNbNodes = -1;
switch(aGeom){
case eSEG2: aNbNodes = 2; break;
case eSEG3: aNbNodes = 3; break;
case eTRIA3: aNbNodes = 3; break;
case eTRIA6: aNbNodes = 6; break;
case eQUAD4: aNbNodes = 4; break;
case eQUAD8: aNbNodes = 8; break;
case eTETRA4: aNbNodes = 4; break;
case eTETRA10: aNbNodes = 10; break;
case ePYRA5: aNbNodes = 5; break;
case ePYRA13: aNbNodes = 13; break;
case ePENTA6: aNbNodes = 6; break;
case ePENTA15: aNbNodes = 15; break;
case eHEXA8: aNbNodes = 8; break;
case eHEXA20: aNbNodes = 20; break;
case ePOINT1: aNbNodes = 1; break;
default:;
}
std::vector<TInt> aNodeIds(aNbNodes);
bool anIsValidConnect = false; bool anIsValidConnect = false;
TCConnSlice aConnSlice = aCellInfo->GetConnSlice(iElem); TCConnSlice aConnSlice = aCellInfo->GetConnSlice(iElem);
#ifndef _DEXCEPT_ #ifndef _DEXCEPT_
@ -736,9 +737,9 @@ DriverMED_R_SMESHDS_Mesh
return aResult; return aResult;
} }
std::list<std::string> DriverMED_R_SMESHDS_Mesh::GetMeshNames(Status& theStatus) list<string> DriverMED_R_SMESHDS_Mesh::GetMeshNames(Status& theStatus)
{ {
std::list<std::string> aMeshNames; list<string> aMeshNames;
try { try {
if(MYDEBUG) MESSAGE("GetMeshNames - myFile : " << myFile); if(MYDEBUG) MESSAGE("GetMeshNames - myFile : " << myFile);
@ -747,10 +748,10 @@ std::list<std::string> DriverMED_R_SMESHDS_Mesh::GetMeshNames(Status& theStatus)
if (TInt aNbMeshes = aMed->GetNbMeshes()) { if (TInt aNbMeshes = aMed->GetNbMeshes()) {
for (int iMesh = 0; iMesh < aNbMeshes; iMesh++) { for (int iMesh = 0; iMesh < aNbMeshes; iMesh++) {
// Reading the MED mesh // Reading the MED mesh
//--------------------- //---------------------
PMeshInfo aMeshInfo = aMed->GetPMeshInfo(iMesh+1); PMeshInfo aMeshInfo = aMed->GetPMeshInfo(iMesh+1);
aMeshNames.push_back(aMeshInfo->GetName()); aMeshNames.push_back(aMeshInfo->GetName());
} }
} }
}catch(const std::exception& exc){ }catch(const std::exception& exc){
@ -764,26 +765,28 @@ std::list<std::string> DriverMED_R_SMESHDS_Mesh::GetMeshNames(Status& theStatus)
return aMeshNames; return aMeshNames;
} }
std::list<TNameAndType> DriverMED_R_SMESHDS_Mesh::GetGroupNamesAndTypes() list<TNameAndType> DriverMED_R_SMESHDS_Mesh::GetGroupNamesAndTypes()
{ {
std::list<TNameAndType> aResult; list<TNameAndType> aResult;
std::set<TNameAndType> aResGroupNames; set<TNameAndType> aResGroupNames;
std::map<int, DriverMED_FamilyPtr>::iterator aFamsIter = myFamilies.begin(); map<int, DriverMED_FamilyPtr>::iterator aFamsIter = myFamilies.begin();
for (; aFamsIter != myFamilies.end(); aFamsIter++) for (; aFamsIter != myFamilies.end(); aFamsIter++)
{ {
DriverMED_FamilyPtr aFamily = (*aFamsIter).second; DriverMED_FamilyPtr aFamily = (*aFamsIter).second;
const MED::TStringSet& aGroupNames = aFamily->GetGroupNames(); const MED::TStringSet& aGroupNames = aFamily->GetGroupNames();
std::set<std::string>::const_iterator aGrNamesIter = aGroupNames.begin(); set<string>::const_iterator aGrNamesIter = aGroupNames.begin();
for (; aGrNamesIter != aGroupNames.end(); aGrNamesIter++) for (; aGrNamesIter != aGroupNames.end(); aGrNamesIter++)
{ {
TNameAndType aNameAndType = make_pair( *aGrNamesIter, aFamily->GetType() ); const set< SMDSAbs_ElementType >& types = aFamily->GetTypes();
// Check, if this is a Group or SubMesh name set< SMDSAbs_ElementType >::const_iterator type = types.begin();
//if (aName.substr(0, 5) == string("Group")) { for ( ; type != types.end(); ++type )
{
TNameAndType aNameAndType = make_pair( *aGrNamesIter, *type );
if ( aResGroupNames.insert( aNameAndType ).second ) { if ( aResGroupNames.insert( aNameAndType ).second ) {
aResult.push_back( aNameAndType ); aResult.push_back( aNameAndType );
} }
// } }
} }
} }
@ -792,28 +795,28 @@ std::list<TNameAndType> DriverMED_R_SMESHDS_Mesh::GetGroupNamesAndTypes()
void DriverMED_R_SMESHDS_Mesh::GetGroup(SMESHDS_Group* theGroup) void DriverMED_R_SMESHDS_Mesh::GetGroup(SMESHDS_Group* theGroup)
{ {
std::string aGroupName (theGroup->GetStoreName()); string aGroupName (theGroup->GetStoreName());
if(MYDEBUG) MESSAGE("Get Group " << aGroupName); if(MYDEBUG) MESSAGE("Get Group " << aGroupName);
std::map<int, DriverMED_FamilyPtr>::iterator aFamsIter = myFamilies.begin(); map<int, DriverMED_FamilyPtr>::iterator aFamsIter = myFamilies.begin();
for (; aFamsIter != myFamilies.end(); aFamsIter++) for (; aFamsIter != myFamilies.end(); aFamsIter++)
{ {
DriverMED_FamilyPtr aFamily = (*aFamsIter).second; DriverMED_FamilyPtr aFamily = (*aFamsIter).second;
if (aFamily->GetType() == theGroup->GetType() && aFamily->MemberOf(aGroupName)) if (aFamily->GetTypes().count( theGroup->GetType() ) && aFamily->MemberOf(aGroupName))
{ {
const std::set<const SMDS_MeshElement *>& anElements = aFamily->GetElements(); const set<const SMDS_MeshElement *>& anElements = aFamily->GetElements();
std::set<const SMDS_MeshElement *>::const_iterator anElemsIter = anElements.begin(); set<const SMDS_MeshElement *>::const_iterator anElemsIter = anElements.begin();
const SMDS_MeshElement * element = 0;
for (; anElemsIter != anElements.end(); anElemsIter++) for (; anElemsIter != anElements.end(); anElemsIter++)
{ {
element = *anElemsIter; const SMDS_MeshElement * element = *anElemsIter;
theGroup->SMDSGroup().Add(element); if ( element->GetType() == theGroup->GetType() ) // Issue 0020576
int aGroupAttrVal = aFamily->GetGroupAttributVal(); theGroup->SMDSGroup().Add(element);
if( aGroupAttrVal != 0)
theGroup->SetColorGroup(aGroupAttrVal);
} }
if ( element ) int aGroupAttrVal = aFamily->GetGroupAttributVal();
theGroup->SetType( theGroup->SMDSGroup().GetType() ); if( aGroupAttrVal != 0)
theGroup->SetColorGroup(aGroupAttrVal);
// if ( element ) -- Issue 0020576
// theGroup->SetType( theGroup->SMDSGroup().GetType() );
} }
} }
} }
@ -823,15 +826,15 @@ void DriverMED_R_SMESHDS_Mesh::GetSubMesh (SMESHDS_SubMesh* theSubMesh,
{ {
char submeshGrpName[ 30 ]; char submeshGrpName[ 30 ];
sprintf( submeshGrpName, "SubMesh %d", theId ); sprintf( submeshGrpName, "SubMesh %d", theId );
std::string aName (submeshGrpName); string aName (submeshGrpName);
std::map<int, DriverMED_FamilyPtr>::iterator aFamsIter = myFamilies.begin(); map<int, DriverMED_FamilyPtr>::iterator aFamsIter = myFamilies.begin();
for (; aFamsIter != myFamilies.end(); aFamsIter++) for (; aFamsIter != myFamilies.end(); aFamsIter++)
{ {
DriverMED_FamilyPtr aFamily = (*aFamsIter).second; DriverMED_FamilyPtr aFamily = (*aFamsIter).second;
if (aFamily->MemberOf(aName)) if (aFamily->MemberOf(aName))
{ {
const std::set<const SMDS_MeshElement *>& anElements = aFamily->GetElements(); const set<const SMDS_MeshElement *>& anElements = aFamily->GetElements();
std::set<const SMDS_MeshElement *>::const_iterator anElemsIter = anElements.begin(); set<const SMDS_MeshElement *>::const_iterator anElemsIter = anElements.begin();
if (aFamily->GetType() == SMDSAbs_Node) if (aFamily->GetType() == SMDSAbs_Node)
{ {
for (; anElemsIter != anElements.end(); anElemsIter++) for (; anElemsIter != anElements.end(); anElemsIter++)
@ -853,21 +856,21 @@ void DriverMED_R_SMESHDS_Mesh::GetSubMesh (SMESHDS_SubMesh* theSubMesh,
void DriverMED_R_SMESHDS_Mesh::CreateAllSubMeshes () void DriverMED_R_SMESHDS_Mesh::CreateAllSubMeshes ()
{ {
std::map<int, DriverMED_FamilyPtr>::iterator aFamsIter = myFamilies.begin(); map<int, DriverMED_FamilyPtr>::iterator aFamsIter = myFamilies.begin();
for (; aFamsIter != myFamilies.end(); aFamsIter++) for (; aFamsIter != myFamilies.end(); aFamsIter++)
{ {
DriverMED_FamilyPtr aFamily = (*aFamsIter).second; DriverMED_FamilyPtr aFamily = (*aFamsIter).second;
MED::TStringSet aGroupNames = aFamily->GetGroupNames(); MED::TStringSet aGroupNames = aFamily->GetGroupNames();
std::set<std::string>::iterator aGrNamesIter = aGroupNames.begin(); set<string>::iterator aGrNamesIter = aGroupNames.begin();
for (; aGrNamesIter != aGroupNames.end(); aGrNamesIter++) for (; aGrNamesIter != aGroupNames.end(); aGrNamesIter++)
{ {
std::string aName = *aGrNamesIter; string aName = *aGrNamesIter;
// Check, if this is a Group or SubMesh name // Check, if this is a Group or SubMesh name
if (aName.substr(0, 7) == std::string("SubMesh")) if (aName.substr(0, 7) == string("SubMesh"))
{ {
int Id = atoi(std::string(aName).substr(7).c_str()); int Id = atoi(string(aName).substr(7).c_str());
std::set<const SMDS_MeshElement *> anElements = aFamily->GetElements(); set<const SMDS_MeshElement *> anElements = aFamily->GetElements();
std::set<const SMDS_MeshElement *>::iterator anElemsIter = anElements.begin(); set<const SMDS_MeshElement *>::iterator anElemsIter = anElements.begin();
if (aFamily->GetType() == SMDSAbs_Node) if (aFamily->GetType() == SMDSAbs_Node)
{ {
for (; anElemsIter != anElements.end(); anElemsIter++) for (; anElemsIter != anElements.end(); anElemsIter++)
@ -909,7 +912,7 @@ void DriverMED_R_SMESHDS_Mesh::CreateAllSubMeshes ()
bool DriverMED_R_SMESHDS_Mesh::checkFamilyID(DriverMED_FamilyPtr & aFamily, int anID) const bool DriverMED_R_SMESHDS_Mesh::checkFamilyID(DriverMED_FamilyPtr & aFamily, int anID) const
{ {
if ( !aFamily || aFamily->GetId() != anID ) { if ( !aFamily || aFamily->GetId() != anID ) {
std::map<int, DriverMED_FamilyPtr>::const_iterator i_fam = myFamilies.find(anID); map<int, DriverMED_FamilyPtr>::const_iterator i_fam = myFamilies.find(anID);
if ( i_fam == myFamilies.end() ) if ( i_fam == myFamilies.end() )
return false; return false;
aFamily = i_fam->second; aFamily = i_fam->second;
@ -924,7 +927,7 @@ bool DriverMED_R_SMESHDS_Mesh::checkFamilyID(DriverMED_FamilyPtr & aFamily, int
* \return TRUE, if successfully. Else FALSE * \return TRUE, if successfully. Else FALSE
*/ */
bool DriverMED_R_SMESHDS_Mesh::buildMeshGrille(const MED::PWrapper& theWrapper, bool DriverMED_R_SMESHDS_Mesh::buildMeshGrille(const MED::PWrapper& theWrapper,
const MED::PMeshInfo& theMeshInfo) const MED::PMeshInfo& theMeshInfo)
{ {
bool res = true; bool res = true;
@ -944,10 +947,10 @@ bool DriverMED_R_SMESHDS_Mesh::buildMeshGrille(const MED::PWrapper& theWrapper,
if((aGrilleInfo->myFamNumNode).size() > 0){ if((aGrilleInfo->myFamNumNode).size() > 0){
TInt aFamNum = aGrilleInfo->GetFamNumNode(iNode); TInt aFamNum = aGrilleInfo->GetFamNumNode(iNode);
if ( checkFamilyID ( aFamily, aFamNum )) if ( checkFamilyID ( aFamily, aFamNum ))
{ {
aFamily->AddElement(aNode); aFamily->AddElement(aNode);
aFamily->SetType(SMDSAbs_Node); aFamily->SetType(SMDSAbs_Node);
} }
} }
} }
@ -959,38 +962,38 @@ bool DriverMED_R_SMESHDS_Mesh::buildMeshGrille(const MED::PWrapper& theWrapper,
switch(aGrilleInfo->GetGeom()){ switch(aGrilleInfo->GetGeom()){
case MED::eSEG2: case MED::eSEG2:
if(aNodeIds.size() != 2){ if(aNodeIds.size() != 2){
res = false; res = false;
EXCEPTION(std::runtime_error,"buildMeshGrille Error. Incorrect size of ids 2!="<<aNodeIds.size()); EXCEPTION(runtime_error,"buildMeshGrille Error. Incorrect size of ids 2!="<<aNodeIds.size());
} }
anElement = myMesh->AddEdgeWithID(aNodeIds[0], anElement = myMesh->AddEdgeWithID(aNodeIds[0],
aNodeIds[1], aNodeIds[1],
iCell); iCell);
break; break;
case MED::eQUAD4: case MED::eQUAD4:
if(aNodeIds.size() != 4){ if(aNodeIds.size() != 4){
res = false; res = false;
EXCEPTION(std::runtime_error,"buildMeshGrille Error. Incorrect size of ids 4!="<<aNodeIds.size()); EXCEPTION(runtime_error,"buildMeshGrille Error. Incorrect size of ids 4!="<<aNodeIds.size());
} }
anElement = myMesh->AddFaceWithID(aNodeIds[0], anElement = myMesh->AddFaceWithID(aNodeIds[0],
aNodeIds[2], aNodeIds[2],
aNodeIds[3], aNodeIds[3],
aNodeIds[1], aNodeIds[1],
iCell); iCell);
break; break;
case MED::eHEXA8: case MED::eHEXA8:
if(aNodeIds.size() != 8){ if(aNodeIds.size() != 8){
res = false; res = false;
EXCEPTION(std::runtime_error,"buildMeshGrille Error. Incorrect size of ids 8!="<<aNodeIds.size()); EXCEPTION(runtime_error,"buildMeshGrille Error. Incorrect size of ids 8!="<<aNodeIds.size());
} }
anElement = myMesh->AddVolumeWithID(aNodeIds[0], anElement = myMesh->AddVolumeWithID(aNodeIds[0],
aNodeIds[2], aNodeIds[2],
aNodeIds[3], aNodeIds[3],
aNodeIds[1], aNodeIds[1],
aNodeIds[4], aNodeIds[4],
aNodeIds[6], aNodeIds[6],
aNodeIds[7], aNodeIds[7],
aNodeIds[5], aNodeIds[5],
iCell); iCell);
break; break;
default: default:
break; break;
@ -999,8 +1002,8 @@ bool DriverMED_R_SMESHDS_Mesh::buildMeshGrille(const MED::PWrapper& theWrapper,
if((aGrilleInfo->myFamNum).size() > 0){ if((aGrilleInfo->myFamNum).size() > 0){
TInt aFamNum = aGrilleInfo->GetFamNum(iCell); TInt aFamNum = aGrilleInfo->GetFamNum(iCell);
if ( checkFamilyID ( aFamily, aFamNum )){ if ( checkFamilyID ( aFamily, aFamNum )){
aFamily->AddElement(anElement); aFamily->AddElement(anElement);
aFamily->SetType(anElement->GetType()); aFamily->SetType(anElement->GetType());
} }
} }
} }

2
src/DriverMED/DriverMED_R_SMESHDS_Mesh.h
View File

@ -62,7 +62,7 @@ class MESHDRIVERMED_EXPORT DriverMED_R_SMESHDS_Mesh: public Driver_SMESHDS_Mesh
bool checkFamilyID(DriverMED_FamilyPtr & aFamily, int anID) const; bool checkFamilyID(DriverMED_FamilyPtr & aFamily, int anID) const;
bool buildMeshGrille(const MED::PWrapper& theWrapper, bool buildMeshGrille(const MED::PWrapper& theWrapper,
const MED::PMeshInfo& theMeshInfo); const MED::PMeshInfo& theMeshInfo);
private: private:
std::string myMeshName; std::string myMeshName;

96
src/DriverMED/DriverMED_W_SMESHDS_Mesh.cxx
View File

@ -54,7 +54,7 @@ DriverMED_W_SMESHDS_Mesh::DriverMED_W_SMESHDS_Mesh():
{} {}
void DriverMED_W_SMESHDS_Mesh::SetFile(const std::string& theFileName, void DriverMED_W_SMESHDS_Mesh::SetFile(const std::string& theFileName,
MED::EVersion theId) MED::EVersion theId)
{ {
myMed = CrWrapper(theFileName,theId); myMed = CrWrapper(theFileName,theId);
Driver_SMESHDS_Mesh::SetFile(theFileName); Driver_SMESHDS_Mesh::SetFile(theFileName);
@ -189,9 +189,9 @@ namespace{
TUnit* myUnit; TUnit* myUnit;
public: public:
TCoordHelper(const SMDS_NodeIteratorPtr& theNodeIter, TCoordHelper(const SMDS_NodeIteratorPtr& theNodeIter,
TGetCoord* theGetCoord, TGetCoord* theGetCoord,
TName* theName, TName* theName,
TUnit* theUnit = aUnit): TUnit* theUnit = aUnit):
myNodeIter(theNodeIter), myNodeIter(theNodeIter),
myGetCoord(theGetCoord), myGetCoord(theGetCoord),
myName(theName), myName(theName),
@ -200,7 +200,7 @@ namespace{
virtual ~TCoordHelper(){} virtual ~TCoordHelper(){}
bool Next(){ bool Next(){
return myNodeIter->more() && return myNodeIter->more() &&
(myCurrentNode = myNodeIter->next()); (myCurrentNode = myNodeIter->next());
} }
const SMDS_MeshNode* GetNode(){ const SMDS_MeshNode* GetNode(){
return myCurrentNode; return myCurrentNode;
@ -352,33 +352,33 @@ Driver_Mesh::Status DriverMED_W_SMESHDS_Mesh::Perform()
bool anIsYDimension = false; bool anIsYDimension = false;
bool anIsZDimension = false; bool anIsZDimension = false;
{ {
SMDS_NodeIteratorPtr aNodesIter = myMesh->nodesIterator(); SMDS_NodeIteratorPtr aNodesIter = myMesh->nodesIterator();
double aBounds[6]; double aBounds[6];
if(aNodesIter->more()){ if(aNodesIter->more()){
const SMDS_MeshNode* aNode = aNodesIter->next(); const SMDS_MeshNode* aNode = aNodesIter->next();
aBounds[0] = aBounds[1] = aNode->X(); aBounds[0] = aBounds[1] = aNode->X();
aBounds[2] = aBounds[3] = aNode->Y(); aBounds[2] = aBounds[3] = aNode->Y();
aBounds[4] = aBounds[5] = aNode->Z(); aBounds[4] = aBounds[5] = aNode->Z();
} }
while(aNodesIter->more()){ while(aNodesIter->more()){
const SMDS_MeshNode* aNode = aNodesIter->next(); const SMDS_MeshNode* aNode = aNodesIter->next();
aBounds[0] = min(aBounds[0],aNode->X()); aBounds[0] = min(aBounds[0],aNode->X());
aBounds[1] = max(aBounds[1],aNode->X()); aBounds[1] = max(aBounds[1],aNode->X());
aBounds[2] = min(aBounds[2],aNode->Y()); aBounds[2] = min(aBounds[2],aNode->Y());
aBounds[3] = max(aBounds[3],aNode->Y()); aBounds[3] = max(aBounds[3],aNode->Y());
aBounds[4] = min(aBounds[4],aNode->Z()); aBounds[4] = min(aBounds[4],aNode->Z());
aBounds[5] = max(aBounds[5],aNode->Z()); aBounds[5] = max(aBounds[5],aNode->Z());
} }
double EPS = 1.0E-7; double EPS = 1.0E-7;
anIsXDimension = (aBounds[1] - aBounds[0]) + abs(aBounds[1]) + abs(aBounds[0]) > EPS; anIsXDimension = (aBounds[1] - aBounds[0]) + abs(aBounds[1]) + abs(aBounds[0]) > EPS;
anIsYDimension = (aBounds[3] - aBounds[2]) + abs(aBounds[3]) + abs(aBounds[2]) > EPS; anIsYDimension = (aBounds[3] - aBounds[2]) + abs(aBounds[3]) + abs(aBounds[2]) > EPS;
anIsZDimension = (aBounds[5] - aBounds[4]) + abs(aBounds[5]) + abs(aBounds[4]) > EPS; anIsZDimension = (aBounds[5] - aBounds[4]) + abs(aBounds[5]) + abs(aBounds[4]) > EPS;
aMeshDimension = anIsXDimension + anIsYDimension + anIsZDimension; aMeshDimension = anIsXDimension + anIsYDimension + anIsZDimension;
if(!aMeshDimension) if(!aMeshDimension)
aMeshDimension = 3; aMeshDimension = 3;
// PAL16857(SMESH not conform to the MED convention): // PAL16857(SMESH not conform to the MED convention):
if ( aMeshDimension == 2 && anIsZDimension ) // 2D only if mesh is in XOY plane if ( aMeshDimension == 2 && anIsZDimension ) // 2D only if mesh is in XOY plane
aMeshDimension = 3; aMeshDimension = 3;
@ -395,24 +395,24 @@ Driver_Mesh::Status DriverMED_W_SMESHDS_Mesh::Perform()
SMDS_NodeIteratorPtr aNodesIter = myMesh->nodesIterator(); SMDS_NodeIteratorPtr aNodesIter = myMesh->nodesIterator();
switch(aMeshDimension){ switch(aMeshDimension){
case 3: case 3:
aCoordHelperPtr.reset(new TCoordHelper(aNodesIter,aXYZGetCoord,aXYZName)); aCoordHelperPtr.reset(new TCoordHelper(aNodesIter,aXYZGetCoord,aXYZName));
break; break;
case 2: case 2:
if(anIsXDimension && anIsYDimension) if(anIsXDimension && anIsYDimension)
aCoordHelperPtr.reset(new TCoordHelper(aNodesIter,aXYGetCoord,aXYName)); aCoordHelperPtr.reset(new TCoordHelper(aNodesIter,aXYGetCoord,aXYName));
if(anIsYDimension && anIsZDimension) if(anIsYDimension && anIsZDimension)
aCoordHelperPtr.reset(new TCoordHelper(aNodesIter,aYZGetCoord,aYZName)); aCoordHelperPtr.reset(new TCoordHelper(aNodesIter,aYZGetCoord,aYZName));
if(anIsXDimension && anIsZDimension) if(anIsXDimension && anIsZDimension)
aCoordHelperPtr.reset(new TCoordHelper(aNodesIter,aXZGetCoord,aXZName)); aCoordHelperPtr.reset(new TCoordHelper(aNodesIter,aXZGetCoord,aXZName));
break; break;
case 1: case 1:
if(anIsXDimension) if(anIsXDimension)
aCoordHelperPtr.reset(new TCoordHelper(aNodesIter,aXGetCoord,aXName)); aCoordHelperPtr.reset(new TCoordHelper(aNodesIter,aXGetCoord,aXName));
if(anIsYDimension) if(anIsYDimension)
aCoordHelperPtr.reset(new TCoordHelper(aNodesIter,aYGetCoord,aYName)); aCoordHelperPtr.reset(new TCoordHelper(aNodesIter,aYGetCoord,aYName));
if(anIsZDimension) if(anIsZDimension)
aCoordHelperPtr.reset(new TCoordHelper(aNodesIter,aZGetCoord,aZName)); aCoordHelperPtr.reset(new TCoordHelper(aNodesIter,aZGetCoord,aZName));
break; break;
} }
} }
@ -495,7 +495,7 @@ Driver_Mesh::Status DriverMED_W_SMESHDS_Mesh::Perform()
// coordinates // coordinates
TCoordSlice aTCoordSlice = aNodeInfo->GetCoordSlice( iNode ); TCoordSlice aTCoordSlice = aNodeInfo->GetCoordSlice( iNode );
for(TInt iCoord = 0; iCoord < aMeshDimension; iCoord++){ for(TInt iCoord = 0; iCoord < aMeshDimension; iCoord++){
aTCoordSlice[iCoord] = aCoordHelperPtr->GetCoord(iCoord); aTCoordSlice[iCoord] = aCoordHelperPtr->GetCoord(iCoord);
} }
// node number // node number
int aNodeID = aCoordHelperPtr->GetID(); int aNodeID = aCoordHelperPtr->GetID();

3
src/DriverUNV/DriverUNV_R_SMDS_Mesh.cxx
View File

@ -30,6 +30,8 @@
#include "UNV2417_Structure.hxx" #include "UNV2417_Structure.hxx"
#include "UNV_Utilities.hxx" #include "UNV_Utilities.hxx"
#include <Basics_Utils.hxx>
using namespace std; using namespace std;
@ -49,6 +51,7 @@ DriverUNV_R_SMDS_Mesh::~DriverUNV_R_SMDS_Mesh()
Driver_Mesh::Status DriverUNV_R_SMDS_Mesh::Perform() Driver_Mesh::Status DriverUNV_R_SMDS_Mesh::Perform()
{ {
Kernel_Utils::Localizer loc;
Status aResult = DRS_OK; Status aResult = DRS_OK;
std::ifstream in_stream(myFile.c_str()); std::ifstream in_stream(myFile.c_str());
try{ try{

3
src/DriverUNV/DriverUNV_W_SMDS_Mesh.cxx
View File

@ -36,6 +36,8 @@
#include "UNV2417_Structure.hxx" #include "UNV2417_Structure.hxx"
#include "UNV_Utilities.hxx" #include "UNV_Utilities.hxx"
#include <Basics_Utils.hxx>
using namespace std; using namespace std;
using namespace UNV; using namespace UNV;
@ -57,6 +59,7 @@ namespace{
Driver_Mesh::Status DriverUNV_W_SMDS_Mesh::Perform() Driver_Mesh::Status DriverUNV_W_SMDS_Mesh::Perform()
{ {
Kernel_Utils::Localizer loc;
Status aResult = DRS_OK; Status aResult = DRS_OK;
std::ofstream out_stream(myFile.c_str()); std::ofstream out_stream(myFile.c_str());
try{ try{

1
src/DriverUNV/Makefile.am
View File

@ -78,6 +78,7 @@ libMeshDriverUNV_la_CPPFLAGS = \
libMeshDriverUNV_la_LDFLAGS = \ libMeshDriverUNV_la_LDFLAGS = \
../Driver/libMeshDriver.la \ ../Driver/libMeshDriver.la \
$(KERNEL_LDFLAGS) -lSALOMEBasics \
$(CAS_KERNEL) $(CAS_KERNEL)
UNV_Test_CPPFLAGS = \ UNV_Test_CPPFLAGS = \

123
src/OBJECT/SMESH_Actor.cxx
View File

@ -72,6 +72,11 @@
#include <vtkImplicitBoolean.h> #include <vtkImplicitBoolean.h>
#include <vtkImplicitFunctionCollection.h> #include <vtkImplicitFunctionCollection.h>
#include <vtkConfigure.h>
#if !defined(VTK_XVERSION)
#define VTK_XVERSION (VTK_MAJOR_VERSION<<16)+(VTK_MINOR_VERSION<<8)+(VTK_BUILD_VERSION)
#endif
#include "utilities.h" #include "utilities.h"
#ifdef _DEBUG_ #ifdef _DEBUG_
@ -90,9 +95,9 @@ SMESH_ActorDef* SMESH_ActorDef::New(){
SMESH_Actor* SMESH_Actor::New(TVisualObjPtr theVisualObj, SMESH_Actor* SMESH_Actor::New(TVisualObjPtr theVisualObj,
const char* theEntry, const char* theEntry,
const char* theName, const char* theName,
int theIsClear) int theIsClear)
{ {
SMESH_ActorDef* anActor = SMESH_ActorDef::New(); SMESH_ActorDef* anActor = SMESH_ActorDef::New();
if(!anActor->Init(theVisualObj,theEntry,theName,theIsClear)){ if(!anActor->Init(theVisualObj,theEntry,theName,theIsClear)){
@ -399,7 +404,11 @@ SMESH_ActorDef::SMESH_ActorDef()
myPtsLabeledDataMapper = vtkLabeledDataMapper::New(); myPtsLabeledDataMapper = vtkLabeledDataMapper::New();
myPtsLabeledDataMapper->SetInput(myPtsSelectVisiblePoints->GetOutput()); myPtsLabeledDataMapper->SetInput(myPtsSelectVisiblePoints->GetOutput());
#if (VTK_XVERSION >= 0x050200)
myPtsLabeledDataMapper->SetLabelFormat("%d");
#else
myPtsLabeledDataMapper->SetLabelFormat("%g"); myPtsLabeledDataMapper->SetLabelFormat("%g");
#endif
myPtsLabeledDataMapper->SetLabelModeToLabelScalars(); myPtsLabeledDataMapper->SetLabelModeToLabelScalars();
vtkTextProperty* aPtsTextProp = vtkTextProperty::New(); vtkTextProperty* aPtsTextProp = vtkTextProperty::New();
@ -440,7 +449,11 @@ SMESH_ActorDef::SMESH_ActorDef()
myClsLabeledDataMapper = vtkLabeledDataMapper::New(); myClsLabeledDataMapper = vtkLabeledDataMapper::New();
myClsLabeledDataMapper->SetInput(myClsSelectVisiblePoints->GetOutput()); myClsLabeledDataMapper->SetInput(myClsSelectVisiblePoints->GetOutput());
#if (VTK_XVERSION >= 0x050200)
myClsLabeledDataMapper->SetLabelFormat("%d");
#else
myClsLabeledDataMapper->SetLabelFormat("%g"); myClsLabeledDataMapper->SetLabelFormat("%g");
#endif
myClsLabeledDataMapper->SetLabelModeToLabelScalars(); myClsLabeledDataMapper->SetLabelModeToLabelScalars();
vtkTextProperty* aClsTextProp = vtkTextProperty::New(); vtkTextProperty* aClsTextProp = vtkTextProperty::New();
@ -593,7 +606,7 @@ void SMESH_ActorDef::SetPointsLabeled( bool theIsPointsLabeled )
vtkIntArray *anArray = vtkIntArray::New(); vtkIntArray *anArray = vtkIntArray::New();
anArray->SetNumberOfValues( aNbElem ); anArray->SetNumberOfValues( aNbElem );
for ( int anId = 0; anId < aNbElem; anId++ ) for ( vtkIdType anId = 0; anId < aNbElem; anId++ )
{ {
int aSMDSId = myVisualObj->GetNodeObjId( anId ); int aSMDSId = myVisualObj->GetNodeObjId( anId );
anArray->SetValue( anId, aSMDSId ); anArray->SetValue( anId, aSMDSId );
@ -664,7 +677,7 @@ SetControlMode(eControl theMode)
void void
SMESH_ActorDef:: SMESH_ActorDef::
SetControlMode(eControl theMode, SetControlMode(eControl theMode,
bool theCheckEntityMode) bool theCheckEntityMode)
{ {
SUIT_ResourceMgr* mgr = SUIT_Session::session()->resourceMgr(); SUIT_ResourceMgr* mgr = SUIT_Session::session()->resourceMgr();
if( !mgr ) if( !mgr )
@ -796,41 +809,41 @@ SetControlMode(eControl theMode,
myControlMode = theMode; myControlMode = theMode;
switch(myControlMode){ switch(myControlMode){
case eFreeNodes: case eFreeNodes:
myNodeExtActor->SetExtControlMode(aFunctor); myNodeExtActor->SetExtControlMode(aFunctor);
break; break;
case eFreeEdges: case eFreeEdges:
case eFreeBorders: case eFreeBorders:
my1DExtActor->SetExtControlMode(aFunctor); my1DExtActor->SetExtControlMode(aFunctor);
break; break;
case eFreeFaces: case eFreeFaces:
my2DExtActor->SetExtControlMode(aFunctor); my2DExtActor->SetExtControlMode(aFunctor);
break; break;
case eLength2D: case eLength2D:
case eMultiConnection2D: case eMultiConnection2D:
my1DExtActor->SetExtControlMode(aFunctor,myScalarBarActor,myLookupTable); my1DExtActor->SetExtControlMode(aFunctor,myScalarBarActor,myLookupTable);
break; break;
default: default:
myControlActor->SetControlMode(aFunctor,myScalarBarActor,myLookupTable); myControlActor->SetControlMode(aFunctor,myScalarBarActor,myLookupTable);
} }
} }
if(theCheckEntityMode){ if(theCheckEntityMode){
if(myControlActor == my1DActor) if(myControlActor == my1DActor)
SetEntityMode(eEdges); SetEntityMode(eEdges);
else if(myControlActor == my2DActor){ else if(myControlActor == my2DActor){
switch(myControlMode){ switch(myControlMode){
case eLength2D: case eLength2D:
case eFreeEdges: case eFreeEdges:
case eFreeFaces: case eFreeFaces:
case eMultiConnection2D: case eMultiConnection2D:
//SetEntityMode(eEdges); //SetEntityMode(eEdges);
SetEntityMode(eFaces); SetEntityMode(eFaces);
break; break;
default: default:
SetEntityMode(eFaces); SetEntityMode(eFaces);
} }
}else if(myControlActor == my3DActor) }else if(myControlActor == my3DActor)
SetEntityMode(eVolumes); SetEntityMode(eVolumes);
} }
}else if(theCheckEntityMode){ }else if(theCheckEntityMode){
@ -900,9 +913,9 @@ void SMESH_ActorDef::RemoveFromRender(vtkRenderer* theRenderer){
bool SMESH_ActorDef::Init(TVisualObjPtr theVisualObj, bool SMESH_ActorDef::Init(TVisualObjPtr theVisualObj,
const char* theEntry, const char* theEntry,
const char* theName, const char* theName,
int theIsClear) int theIsClear)
{ {
Handle(SALOME_InteractiveObject) anIO = new SALOME_InteractiveObject(theEntry,"SMESH",theName); Handle(SALOME_InteractiveObject) anIO = new SALOME_InteractiveObject(theEntry,"SMESH",theName);
setIO(anIO); setIO(anIO);
@ -1034,8 +1047,8 @@ bool SMESH_ActorDef::IsInfinitive(){
vtkDataSet *aDataSet = myPickableActor->GetUnstructuredGrid(); vtkDataSet *aDataSet = myPickableActor->GetUnstructuredGrid();
aDataSet->Update(); aDataSet->Update();
myIsInfinite = aDataSet->GetNumberOfCells() == 0 || myIsInfinite = aDataSet->GetNumberOfCells() == 0 ||
aDataSet->GetNumberOfCells() == 1 && ( aDataSet->GetNumberOfCells() == 1 &&
aDataSet->GetCell(0)->GetCellType() == VTK_VERTEX; aDataSet->GetCell(0)->GetCellType() == VTK_VERTEX );
return SALOME_Actor::IsInfinitive(); return SALOME_Actor::IsInfinitive();
} }
@ -1149,21 +1162,21 @@ void SMESH_ActorDef::SetVisibility(int theMode, bool theIsUpdateRepersentation){
if(myControlMode != eNone){ if(myControlMode != eNone){
switch(myControlMode){ switch(myControlMode){
case eFreeNodes: case eFreeNodes:
myNodeExtActor->VisibilityOn(); myNodeExtActor->VisibilityOn();
break; break;
case eFreeEdges: case eFreeEdges:
case eFreeBorders: case eFreeBorders:
my1DExtActor->VisibilityOn(); my1DExtActor->VisibilityOn();
break; break;
case eFreeFaces: case eFreeFaces:
my2DExtActor->VisibilityOn(); my2DExtActor->VisibilityOn();
break; break;
case eLength2D: case eLength2D:
case eMultiConnection2D: case eMultiConnection2D:
my1DExtActor->VisibilityOn(); my1DExtActor->VisibilityOn();
default: default:
if(myControlActor->GetUnstructuredGrid()->GetNumberOfCells()) if(myControlActor->GetUnstructuredGrid()->GetNumberOfCells())
myScalarBarActor->VisibilityOn(); myScalarBarActor->VisibilityOn();
} }
} }
@ -1462,12 +1475,12 @@ void SMESH_ActorDef::UpdateHighlight(){
myHighlitableActor->SetHighlited(anIsVisible); myHighlitableActor->SetHighlited(anIsVisible);
myHighlitableActor->SetVisibility(anIsVisible); myHighlitableActor->SetVisibility(anIsVisible);
myHighlitableActor->GetExtractUnstructuredGrid()-> myHighlitableActor->GetExtractUnstructuredGrid()->
SetModeOfExtraction(VTKViewer_ExtractUnstructuredGrid::eCells); SetModeOfExtraction(VTKViewer_ExtractUnstructuredGrid::eCells);
myHighlitableActor->SetRepresentation(SMESH_DeviceActor::eWireframe); myHighlitableActor->SetRepresentation(SMESH_DeviceActor::eWireframe);
}else if(myRepresentation == ePoint || GetPointRepresentation()){ }else if(myRepresentation == ePoint || GetPointRepresentation()){
myHighlitableActor->SetHighlited(anIsVisible); myHighlitableActor->SetHighlited(anIsVisible);
myHighlitableActor->GetExtractUnstructuredGrid()-> myHighlitableActor->GetExtractUnstructuredGrid()->
SetModeOfExtraction(VTKViewer_ExtractUnstructuredGrid::ePoints); SetModeOfExtraction(VTKViewer_ExtractUnstructuredGrid::ePoints);
myHighlitableActor->SetVisibility(anIsVisible); myHighlitableActor->SetVisibility(anIsVisible);
myHighlitableActor->SetRepresentation(SMESH_DeviceActor::ePoint); myHighlitableActor->SetRepresentation(SMESH_DeviceActor::ePoint);
} }
@ -1585,7 +1598,7 @@ void SMESH_ActorDef::SetSufaceColor(vtkFloatingPointType r,vtkFloatingPointType
mySurfaceProp->SetColor(r,g,b); mySurfaceProp->SetColor(r,g,b);
if( SMESH_GroupObj* aGroupObj = dynamic_cast<SMESH_GroupObj*>( myVisualObj.get() ) ) if( SMESH_GroupObj* aGroupObj = dynamic_cast<SMESH_GroupObj*>( myVisualObj.get() ) )
if( aGroupObj->GetElementType() == SMDSAbs_Face || if( aGroupObj->GetElementType() == SMDSAbs_Face ||
aGroupObj->GetElementType() == SMDSAbs_Volume ) aGroupObj->GetElementType() == SMDSAbs_Volume )
myNameActor->SetBackgroundColor(r,g,b); myNameActor->SetBackgroundColor(r,g,b);
Modified(); Modified();
} }
@ -1758,8 +1771,8 @@ GetClippingPlane(vtkIdType theID)
static void ComputeBoundsParam(vtkDataSet* theDataSet, static void ComputeBoundsParam(vtkDataSet* theDataSet,
vtkFloatingPointType theDirection[3], vtkFloatingPointType theMinPnt[3], vtkFloatingPointType theDirection[3], vtkFloatingPointType theMinPnt[3],
vtkFloatingPointType& theMaxBoundPrj, vtkFloatingPointType& theMinBoundPrj) vtkFloatingPointType& theMaxBoundPrj, vtkFloatingPointType& theMinBoundPrj)
{ {
vtkFloatingPointType aBounds[6]; vtkFloatingPointType aBounds[6];
theDataSet->GetBounds(aBounds); theDataSet->GetBounds(aBounds);
@ -1773,13 +1786,13 @@ static void ComputeBoundsParam(vtkDataSet* theDataSet,
} }
vtkFloatingPointType aBoundPoints[8][3] = { {aBounds[0],aBounds[2],aBounds[4]}, vtkFloatingPointType aBoundPoints[8][3] = { {aBounds[0],aBounds[2],aBounds[4]},
{aBounds[1],aBounds[2],aBounds[4]}, {aBounds[1],aBounds[2],aBounds[4]},
{aBounds[0],aBounds[3],aBounds[4]}, {aBounds[0],aBounds[3],aBounds[4]},
{aBounds[1],aBounds[3],aBounds[4]}, {aBounds[1],aBounds[3],aBounds[4]},
{aBounds[0],aBounds[2],aBounds[5]}, {aBounds[0],aBounds[2],aBounds[5]},
{aBounds[1],aBounds[2],aBounds[5]}, {aBounds[1],aBounds[2],aBounds[5]},
{aBounds[0],aBounds[3],aBounds[5]}, {aBounds[0],aBounds[3],aBounds[5]},
{aBounds[1],aBounds[3],aBounds[5]}}; {aBounds[1],aBounds[3],aBounds[5]}};
int aMaxId = 0, aMinId = aMaxId; int aMaxId = 0, aMinId = aMaxId;
theMaxBoundPrj = vtkMath::Dot(theDirection,aBoundPoints[aMaxId]); theMaxBoundPrj = vtkMath::Dot(theDirection,aBoundPoints[aMaxId]);
@ -1803,7 +1816,7 @@ static void ComputeBoundsParam(vtkDataSet* theDataSet,
static void DistanceToPosition(vtkDataSet* theDataSet, static void DistanceToPosition(vtkDataSet* theDataSet,
vtkFloatingPointType theDirection[3], vtkFloatingPointType theDist, vtkFloatingPointType thePos[3]) vtkFloatingPointType theDirection[3], vtkFloatingPointType theDist, vtkFloatingPointType thePos[3])
{ {
vtkFloatingPointType aMaxBoundPrj, aMinBoundPrj, aMinPnt[3]; vtkFloatingPointType aMaxBoundPrj, aMinBoundPrj, aMinPnt[3];
ComputeBoundsParam(theDataSet,theDirection,aMinPnt,aMaxBoundPrj,aMinBoundPrj); ComputeBoundsParam(theDataSet,theDirection,aMinPnt,aMaxBoundPrj,aMinBoundPrj);
@ -1815,7 +1828,7 @@ static void DistanceToPosition(vtkDataSet* theDataSet,
static void PositionToDistance(vtkDataSet* theDataSet, static void PositionToDistance(vtkDataSet* theDataSet,
vtkFloatingPointType theDirection[3], vtkFloatingPointType thePos[3], vtkFloatingPointType& theDist) vtkFloatingPointType theDirection[3], vtkFloatingPointType thePos[3], vtkFloatingPointType& theDist)
{ {
vtkFloatingPointType aMaxBoundPrj, aMinBoundPrj, aMinPnt[3]; vtkFloatingPointType aMaxBoundPrj, aMinBoundPrj, aMinPnt[3];
ComputeBoundsParam(theDataSet,theDirection,aMinPnt,aMaxBoundPrj,aMinBoundPrj); ComputeBoundsParam(theDataSet,theDirection,aMinPnt,aMaxBoundPrj,aMinBoundPrj);

8
src/OBJECT/SMESH_Actor.h
View File

@ -44,9 +44,9 @@ class SMESHOBJECT_EXPORT SMESH_Actor: public SALOME_Actor
public: public:
vtkTypeMacro(SMESH_Actor,SALOME_Actor); vtkTypeMacro(SMESH_Actor,SALOME_Actor);
static SMESH_Actor* New(TVisualObjPtr theVisualObj, static SMESH_Actor* New(TVisualObjPtr theVisualObj,
const char* theEntry, const char* theEntry,
const char* theName, const char* theName,
int theIsClear); int theIsClear);
virtual void SetSufaceColor(vtkFloatingPointType r,vtkFloatingPointType g,vtkFloatingPointType b) = 0; virtual void SetSufaceColor(vtkFloatingPointType r,vtkFloatingPointType g,vtkFloatingPointType b) = 0;
virtual void GetSufaceColor(vtkFloatingPointType& r,vtkFloatingPointType& g,vtkFloatingPointType& b) = 0; virtual void GetSufaceColor(vtkFloatingPointType& r,vtkFloatingPointType& g,vtkFloatingPointType& b) = 0;
@ -102,7 +102,7 @@ class SMESHOBJECT_EXPORT SMESH_Actor: public SALOME_Actor
enum eControl{eNone, eLength, eLength2D, eFreeBorders, eFreeEdges, eFreeNodes, enum eControl{eNone, eLength, eLength2D, eFreeBorders, eFreeEdges, eFreeNodes,
eFreeFaces, eMultiConnection, eArea, eTaper, eAspectRatio, eFreeFaces, eMultiConnection, eArea, eTaper, eAspectRatio,
eMinimumAngle, eWarping, eSkew, eAspectRatio3D, eMultiConnection2D, eVolume3D}; eMinimumAngle, eWarping, eSkew, eAspectRatio3D, eMultiConnection2D, eVolume3D};
virtual void SetControlMode(eControl theMode) = 0; virtual void SetControlMode(eControl theMode) = 0;
virtual eControl GetControlMode() = 0; virtual eControl GetControlMode() = 0;

6
src/OBJECT/SMESH_ActorDef.h
View File

@ -272,9 +272,9 @@ class SMESH_ActorDef : public SMESH_Actor
~SMESH_ActorDef(); ~SMESH_ActorDef();
bool Init(TVisualObjPtr theVisualObj, bool Init(TVisualObjPtr theVisualObj,
const char* theEntry, const char* theEntry,
const char* theName, const char* theName,
int theIsClear); int theIsClear);
void SetIsShrunkable(bool theShrunkable); void SetIsShrunkable(bool theShrunkable);
void UpdateHighlight(); void UpdateHighlight();

34
src/OBJECT/SMESH_ActorUtils.cxx
View File

@ -41,7 +41,7 @@ namespace SMESH
vtkFloatingPointType vtkFloatingPointType
GetFloat( const QString& theValue, GetFloat( const QString& theValue,
vtkFloatingPointType theDefault ) vtkFloatingPointType theDefault )
{ {
int pos = theValue.indexOf( ":" ); int pos = theValue.indexOf( ":" );
vtkFloatingPointType val = theDefault; vtkFloatingPointType val = theDefault;
@ -50,15 +50,15 @@ namespace SMESH
QString name = theValue.right( theValue.length()-pos-1 ), QString name = theValue.right( theValue.length()-pos-1 ),
sect = theValue.left( pos ); sect = theValue.left( pos );
if( !name.isEmpty() && !sect.isEmpty() ) if( !name.isEmpty() && !sect.isEmpty() )
val = GetFloat( name, sect, theDefault ); val = GetFloat( name, sect, theDefault );
} }
return val; return val;
} }
vtkFloatingPointType vtkFloatingPointType
GetFloat( const QString& theValue, GetFloat( const QString& theValue,
const QString& theSection, const QString& theSection,
vtkFloatingPointType theDefault ) vtkFloatingPointType theDefault )
{ {
vtkFloatingPointType val = theDefault; vtkFloatingPointType val = theDefault;
SUIT_ResourceMgr* mgr = SUIT_Session::session()->resourceMgr(); SUIT_ResourceMgr* mgr = SUIT_Session::session()->resourceMgr();
@ -70,7 +70,7 @@ namespace SMESH
void void
WriteUnstructuredGrid(vtkUnstructuredGrid* theGrid, WriteUnstructuredGrid(vtkUnstructuredGrid* theGrid,
const char* theFileName) const char* theFileName)
{ {
vtkUnstructuredGridWriter* aWriter = vtkUnstructuredGridWriter::New(); vtkUnstructuredGridWriter* aWriter = vtkUnstructuredGridWriter::New();
aWriter->SetFileName(theFileName); aWriter->SetFileName(theFileName);
@ -83,8 +83,8 @@ namespace SMESH
QColor QColor
GetColor( const QString& theSect, GetColor( const QString& theSect,
const QString& theName, const QString& theName,
const QColor& def ) const QColor& def )
{ {
QColor c = def; QColor c = def;
SUIT_ResourceMgr* mgr = SUIT_Session::session()->resourceMgr(); SUIT_ResourceMgr* mgr = SUIT_Session::session()->resourceMgr();
@ -95,11 +95,11 @@ namespace SMESH
void void
GetColor( const QString& theSect, GetColor( const QString& theSect,
const QString& theName, const QString& theName,
int& r, int& r,
int& g, int& g,
int& b, int& b,
const QColor& def ) const QColor& def )
{ {
QColor c = def; QColor c = def;
SUIT_ResourceMgr* mgr = SUIT_Session::session()->resourceMgr(); SUIT_ResourceMgr* mgr = SUIT_Session::session()->resourceMgr();
@ -111,11 +111,11 @@ namespace SMESH
void void
GetColor( const QString& theSect, GetColor( const QString& theSect,
const QString& theName, const QString& theName,
vtkFloatingPointType& r, vtkFloatingPointType& r,
vtkFloatingPointType& g, vtkFloatingPointType& g,
vtkFloatingPointType& b, vtkFloatingPointType& b,
const QColor& def ) const QColor& def )
{ {
int ir( 0 ), ig( 0 ), ib( 0 ); int ir( 0 ), ig( 0 ), ib( 0 );
GetColor( theSect, theName, ir, ig, ib, def ); GetColor( theSect, theName, ir, ig, ib, def );

32
src/OBJECT/SMESH_ActorUtils.h
View File

@ -33,42 +33,42 @@ namespace SMESH
SMESHOBJECT_EXPORT SMESHOBJECT_EXPORT
vtkFloatingPointType vtkFloatingPointType
GetFloat( const QString& theValue, GetFloat( const QString& theValue,
vtkFloatingPointType theDefault = 0 ); vtkFloatingPointType theDefault = 0 );
SMESHOBJECT_EXPORT SMESHOBJECT_EXPORT
vtkFloatingPointType vtkFloatingPointType
GetFloat( const QString& theName, GetFloat( const QString& theName,
const QString& theSection, const QString& theSection,
vtkFloatingPointType theDefault = 0 ); vtkFloatingPointType theDefault = 0 );
SMESHOBJECT_EXPORT SMESHOBJECT_EXPORT
QColor QColor
GetColor( const QString& theSect, GetColor( const QString& theSect,
const QString& theName, const QString& theName,
const QColor& = QColor() ); const QColor& = QColor() );
SMESHOBJECT_EXPORT SMESHOBJECT_EXPORT
void void
GetColor( const QString& theSect, GetColor( const QString& theSect,
const QString& theName, const QString& theName,
int&, int&,
int&, int&,
int&, int&,
const QColor& = QColor() ); const QColor& = QColor() );
SMESHOBJECT_EXPORT SMESHOBJECT_EXPORT
void void
GetColor( const QString& theSect, GetColor( const QString& theSect,
const QString& theName, const QString& theName,
vtkFloatingPointType&, vtkFloatingPointType&,
vtkFloatingPointType&, vtkFloatingPointType&,
vtkFloatingPointType&, vtkFloatingPointType&,
const QColor& = QColor() ); const QColor& = QColor() );
SMESHOBJECT_EXPORT SMESHOBJECT_EXPORT
void void
WriteUnstructuredGrid(vtkUnstructuredGrid* theGrid, WriteUnstructuredGrid(vtkUnstructuredGrid* theGrid,
const char* theFileName); const char* theFileName);
} }

98
src/OBJECT/SMESH_DeviceActor.cxx
View File

@ -91,7 +91,7 @@ SMESH_DeviceActor
myMapper = vtkPolyDataMapper::New(); myMapper = vtkPolyDataMapper::New();
vtkMapper::GetResolveCoincidentTopologyPolygonOffsetParameters(myPolygonOffsetFactor, vtkMapper::GetResolveCoincidentTopologyPolygonOffsetParameters(myPolygonOffsetFactor,
myPolygonOffsetUnits); myPolygonOffsetUnits);
myMapper->UseLookupTableScalarRangeOn(); myMapper->UseLookupTableScalarRangeOn();
myMapper->SetColorModeToMapScalars(); myMapper->SetColorModeToMapScalars();
@ -281,8 +281,8 @@ SMESH_DeviceActor
void void
SMESH_DeviceActor SMESH_DeviceActor
::SetControlMode(SMESH::Controls::FunctorPtr theFunctor, ::SetControlMode(SMESH::Controls::FunctorPtr theFunctor,
vtkScalarBarActor* theScalarBarActor, vtkScalarBarActor* theScalarBarActor,
vtkLookupTable* theLookupTable) vtkLookupTable* theLookupTable)
{ {
bool anIsInitialized = theFunctor; bool anIsInitialized = theFunctor;
if(anIsInitialized){ if(anIsInitialized){
@ -304,23 +304,23 @@ SMESH_DeviceActor
using namespace SMESH::Controls; using namespace SMESH::Controls;
if(NumericalFunctor* aNumericalFunctor = dynamic_cast<NumericalFunctor*>(theFunctor.get())){ if(NumericalFunctor* aNumericalFunctor = dynamic_cast<NumericalFunctor*>(theFunctor.get())){
for(vtkIdType i = 0; i < aNbCells; i++){ for(vtkIdType i = 0; i < aNbCells; i++){
vtkIdType anId = myExtractUnstructuredGrid->GetInputId(i); vtkIdType anId = myExtractUnstructuredGrid->GetInputId(i);
vtkIdType anObjId = myVisualObj->GetElemObjId(anId); vtkIdType anObjId = myVisualObj->GetElemObjId(anId);
double aValue = aNumericalFunctor->GetValue(anObjId); double aValue = aNumericalFunctor->GetValue(anObjId);
aScalars->SetValue(i,aValue); aScalars->SetValue(i,aValue);
} }
}else if(Predicate* aPredicate = dynamic_cast<Predicate*>(theFunctor.get())){ }else if(Predicate* aPredicate = dynamic_cast<Predicate*>(theFunctor.get())){
for(vtkIdType i = 0; i < aNbCells; i++){ for(vtkIdType i = 0; i < aNbCells; i++){
vtkIdType anId = myExtractUnstructuredGrid->GetInputId(i); vtkIdType anId = myExtractUnstructuredGrid->GetInputId(i);
vtkIdType anObjId = myVisualObj->GetElemObjId(anId); vtkIdType anObjId = myVisualObj->GetElemObjId(anId);
bool aValue = aPredicate->IsSatisfy(anObjId); bool aValue = aPredicate->IsSatisfy(anObjId);
aScalars->SetValue(i,aValue); aScalars->SetValue(i,aValue);
} }
} }
aDataSet->GetCellData()->SetScalars(aScalars); aDataSet->GetCellData()->SetScalars(aScalars);
aScalars->Delete(); aScalars->Delete();
theLookupTable->SetRange(aScalars->GetRange()); theLookupTable->SetRange(aScalars->GetRange());
theLookupTable->SetNumberOfTableValues(theScalarBarActor->GetMaximumNumberOfColors()); theLookupTable->SetNumberOfTableValues(theScalarBarActor->GetMaximumNumberOfColors());
theLookupTable->Build(); theLookupTable->Build();
@ -335,8 +335,8 @@ SMESH_DeviceActor
void void
SMESH_DeviceActor SMESH_DeviceActor
::SetExtControlMode(SMESH::Controls::FunctorPtr theFunctor, ::SetExtControlMode(SMESH::Controls::FunctorPtr theFunctor,
vtkScalarBarActor* theScalarBarActor, vtkScalarBarActor* theScalarBarActor,
vtkLookupTable* theLookupTable) vtkLookupTable* theLookupTable)
{ {
bool anIsInitialized = theFunctor; bool anIsInitialized = theFunctor;
myExtractUnstructuredGrid->ClearRegisteredCells(); myExtractUnstructuredGrid->ClearRegisteredCells();
@ -374,18 +374,18 @@ SMESH_DeviceActor
Length2D::TValues::const_iterator anIter = aValues.begin(); Length2D::TValues::const_iterator anIter = aValues.begin();
for(vtkIdType aVtkId = 0; anIter != aValues.end(); anIter++,aVtkId++){ for(vtkIdType aVtkId = 0; anIter != aValues.end(); anIter++,aVtkId++){
const Length2D::Value& aValue = *anIter; const Length2D::Value& aValue = *anIter;
int aNode[2] = { int aNode[2] = {
myVisualObj->GetNodeVTKId(aValue.myPntId[0]), myVisualObj->GetNodeVTKId(aValue.myPntId[0]),
myVisualObj->GetNodeVTKId(aValue.myPntId[1]) myVisualObj->GetNodeVTKId(aValue.myPntId[1])
}; };
if(aNode[0] >= 0 && aNode[1] >= 0){ if(aNode[0] >= 0 && aNode[1] >= 0){
anIdList->SetId( 0, aNode[0] ); anIdList->SetId( 0, aNode[0] );
anIdList->SetId( 1, aNode[1] ); anIdList->SetId( 1, aNode[1] );
aConnectivity->InsertNextCell( anIdList ); aConnectivity->InsertNextCell( anIdList );
aCellTypesArray->InsertNextValue( VTK_LINE ); aCellTypesArray->InsertNextValue( VTK_LINE );
aScalars->SetValue(aVtkId,aValue.myLength); aScalars->SetValue(aVtkId,aValue.myLength);
} }
} }
VTKViewer_CellLocationsArray* aCellLocationsArray = VTKViewer_CellLocationsArray::New(); VTKViewer_CellLocationsArray* aCellLocationsArray = VTKViewer_CellLocationsArray::New();
@ -394,7 +394,7 @@ SMESH_DeviceActor
aConnectivity->InitTraversal(); aConnectivity->InitTraversal();
for( vtkIdType idType = 0, *pts, npts; aConnectivity->GetNextCell( npts, pts ); idType++ ) for( vtkIdType idType = 0, *pts, npts; aConnectivity->GetNextCell( npts, pts ); idType++ )
aCellLocationsArray->SetValue( idType, aConnectivity->GetTraversalLocation( npts ) ); aCellLocationsArray->SetValue( idType, aConnectivity->GetTraversalLocation( npts ) );
aDataSet->SetCells( aCellTypesArray, aCellLocationsArray,aConnectivity ); aDataSet->SetCells( aCellTypesArray, aCellLocationsArray,aConnectivity );
SetUnstructuredGrid(aDataSet); SetUnstructuredGrid(aDataSet);
@ -434,18 +434,18 @@ SMESH_DeviceActor
MultiConnection2D::MValues::const_iterator anIter = aValues.begin(); MultiConnection2D::MValues::const_iterator anIter = aValues.begin();
for(vtkIdType aVtkId = 0; anIter != aValues.end(); anIter++,aVtkId++){ for(vtkIdType aVtkId = 0; anIter != aValues.end(); anIter++,aVtkId++){
const MultiConnection2D::Value& aValue = (*anIter).first; const MultiConnection2D::Value& aValue = (*anIter).first;
int aNode[2] = { int aNode[2] = {
myVisualObj->GetNodeVTKId(aValue.myPntId[0]), myVisualObj->GetNodeVTKId(aValue.myPntId[0]),
myVisualObj->GetNodeVTKId(aValue.myPntId[1]) myVisualObj->GetNodeVTKId(aValue.myPntId[1])
}; };
if(aNode[0] >= 0 && aNode[1] >= 0){ if(aNode[0] >= 0 && aNode[1] >= 0){
anIdList->SetId( 0, aNode[0] ); anIdList->SetId( 0, aNode[0] );
anIdList->SetId( 1, aNode[1] ); anIdList->SetId( 1, aNode[1] );
aConnectivity->InsertNextCell( anIdList ); aConnectivity->InsertNextCell( anIdList );
aCellTypesArray->InsertNextValue( VTK_LINE ); aCellTypesArray->InsertNextValue( VTK_LINE );
aScalars->SetValue(aVtkId,(*anIter).second); aScalars->SetValue(aVtkId,(*anIter).second);
} }
} }
VTKViewer_CellLocationsArray* aCellLocationsArray = VTKViewer_CellLocationsArray::New(); VTKViewer_CellLocationsArray* aCellLocationsArray = VTKViewer_CellLocationsArray::New();
@ -454,7 +454,7 @@ SMESH_DeviceActor
aConnectivity->InitTraversal(); aConnectivity->InitTraversal();
for( vtkIdType idType = 0, *pts, npts; aConnectivity->GetNextCell( npts, pts ); idType++ ) for( vtkIdType idType = 0, *pts, npts; aConnectivity->GetNextCell( npts, pts ); idType++ )
aCellLocationsArray->SetValue( idType, aConnectivity->GetTraversalLocation( npts ) ); aCellLocationsArray->SetValue( idType, aConnectivity->GetTraversalLocation( npts ) );
aDataSet->SetCells( aCellTypesArray, aCellLocationsArray,aConnectivity ); aDataSet->SetCells( aCellTypesArray, aCellLocationsArray,aConnectivity );
SetUnstructuredGrid(aDataSet); SetUnstructuredGrid(aDataSet);
@ -492,7 +492,7 @@ SMESH_DeviceActor
for( vtkIdType i = 0; i < aNbCells; i++ ){ for( vtkIdType i = 0; i < aNbCells; i++ ){
vtkIdType anObjId = myVisualObj->GetElemObjId(i); vtkIdType anObjId = myVisualObj->GetElemObjId(i);
if(aFreePredicate->IsSatisfy(anObjId)) if(aFreePredicate->IsSatisfy(anObjId))
myExtractUnstructuredGrid->RegisterCell(i); myExtractUnstructuredGrid->RegisterCell(i);
} }
if(!myExtractUnstructuredGrid->IsCellsRegistered()) if(!myExtractUnstructuredGrid->IsCellsRegistered())
myExtractUnstructuredGrid->RegisterCell(-1); myExtractUnstructuredGrid->RegisterCell(-1);
@ -520,15 +520,15 @@ SMESH_DeviceActor
for(; anIter != aBorders.end(); anIter++){ for(; anIter != aBorders.end(); anIter++){
const FreeEdges::Border& aBorder = *anIter; const FreeEdges::Border& aBorder = *anIter;
int aNode[2] = { int aNode[2] = {
myVisualObj->GetNodeVTKId(aBorder.myPntId[0]), myVisualObj->GetNodeVTKId(aBorder.myPntId[0]),
myVisualObj->GetNodeVTKId(aBorder.myPntId[1]) myVisualObj->GetNodeVTKId(aBorder.myPntId[1])
}; };
//cout<<"aNode = "<<aBorder.myPntId[0]<<"; "<<aBorder.myPntId[1]<<endl; //cout<<"aNode = "<<aBorder.myPntId[0]<<"; "<<aBorder.myPntId[1]<<endl;
if(aNode[0] >= 0 && aNode[1] >= 0){ if(aNode[0] >= 0 && aNode[1] >= 0){
anIdList->SetId( 0, aNode[0] ); anIdList->SetId( 0, aNode[0] );
anIdList->SetId( 1, aNode[1] ); anIdList->SetId( 1, aNode[1] );
aConnectivity->InsertNextCell( anIdList ); aConnectivity->InsertNextCell( anIdList );
aCellTypesArray->InsertNextValue( VTK_LINE ); aCellTypesArray->InsertNextValue( VTK_LINE );
} }
} }
@ -550,7 +550,7 @@ SMESH_DeviceActor
for( vtkIdType i = 0; i < aNbNodes; i++ ){ for( vtkIdType i = 0; i < aNbNodes; i++ ){
vtkIdType anObjId = myVisualObj->GetNodeObjId(i); vtkIdType anObjId = myVisualObj->GetNodeObjId(i);
if(aFreeNodes->IsSatisfy(anObjId)) if(aFreeNodes->IsSatisfy(anObjId))
myExtractUnstructuredGrid->RegisterCell(i); myExtractUnstructuredGrid->RegisterCell(i);
} }
if(!myExtractUnstructuredGrid->IsCellsRegistered()) if(!myExtractUnstructuredGrid->IsCellsRegistered())
myExtractUnstructuredGrid->RegisterCell(-1); myExtractUnstructuredGrid->RegisterCell(-1);
@ -827,7 +827,7 @@ SMESH_DeviceActor
void void
SMESH_DeviceActor SMESH_DeviceActor
::SetPolygonOffsetParameters(vtkFloatingPointType factor, ::SetPolygonOffsetParameters(vtkFloatingPointType factor,
vtkFloatingPointType units) vtkFloatingPointType units)
{ {
myPolygonOffsetFactor = factor; myPolygonOffsetFactor = factor;
myPolygonOffsetUnits = units; myPolygonOffsetUnits = units;

12
src/OBJECT/SMESH_DeviceActor.h
View File

@ -109,11 +109,11 @@ class SMESHOBJECT_EXPORT SMESH_DeviceActor: public vtkLODActor{
vtkUnstructuredGrid* GetUnstructuredGrid(); vtkUnstructuredGrid* GetUnstructuredGrid();
void SetControlMode(SMESH::Controls::FunctorPtr theFunctor, void SetControlMode(SMESH::Controls::FunctorPtr theFunctor,
vtkScalarBarActor* theScalarBarActor, vtkScalarBarActor* theScalarBarActor,
vtkLookupTable* theLookupTable); vtkLookupTable* theLookupTable);
void SetExtControlMode(SMESH::Controls::FunctorPtr theFunctor, void SetExtControlMode(SMESH::Controls::FunctorPtr theFunctor,
vtkScalarBarActor* theScalarBarActor, vtkScalarBarActor* theScalarBarActor,
vtkLookupTable* theLookupTable); vtkLookupTable* theLookupTable);
void SetExtControlMode(SMESH::Controls::FunctorPtr theFunctor); void SetExtControlMode(SMESH::Controls::FunctorPtr theFunctor);
bool IsHighlited() { return myIsHighlited;} bool IsHighlited() { return myIsHighlited;}
@ -161,11 +161,11 @@ class SMESHOBJECT_EXPORT SMESH_DeviceActor: public vtkLODActor{
void void
SetPolygonOffsetParameters(vtkFloatingPointType factor, SetPolygonOffsetParameters(vtkFloatingPointType factor,
vtkFloatingPointType units); vtkFloatingPointType units);
void void
GetPolygonOffsetParameters(vtkFloatingPointType& factor, GetPolygonOffsetParameters(vtkFloatingPointType& factor,
vtkFloatingPointType& units) vtkFloatingPointType& units)
{ {
factor = myPolygonOffsetFactor; factor = myPolygonOffsetFactor;
units = myPolygonOffsetUnits; units = myPolygonOffsetUnits;

6
src/OBJECT/SMESH_ExtractGeometry.cxx
View File

@ -152,7 +152,7 @@ int SMESH_ExtractGeometry::RequestData(
{ {
newId = newPts->InsertNextPoint(x); newId = newPts->InsertNextPoint(x);
pointMap[ptId] = newId; pointMap[ptId] = newId;
myNodeVTK2ObjIds.push_back(ptId); myNodeVTK2ObjIds.push_back(ptId);
outputPD->CopyData(pd,ptId,newId); outputPD->CopyData(pd,ptId,newId);
} }
} }
@ -175,7 +175,7 @@ int SMESH_ExtractGeometry::RequestData(
{ {
newId = newPts->InsertNextPoint(x); newId = newPts->InsertNextPoint(x);
pointMap[ptId] = newId; pointMap[ptId] = newId;
myNodeVTK2ObjIds.push_back(ptId); myNodeVTK2ObjIds.push_back(ptId);
outputPD->CopyData(pd,ptId,newId); outputPD->CopyData(pd,ptId,newId);
} }
} }
@ -228,7 +228,7 @@ int SMESH_ExtractGeometry::RequestData(
x = input->GetPoint(ptId); x = input->GetPoint(ptId);
newId = newPts->InsertNextPoint(x); newId = newPts->InsertNextPoint(x);
pointMap[ptId] = newId; pointMap[ptId] = newId;
myNodeVTK2ObjIds.push_back(ptId); myNodeVTK2ObjIds.push_back(ptId);
outputPD->CopyData(pd,ptId,newId); outputPD->CopyData(pd,ptId,newId);
} }
newCellPts->InsertId(i,pointMap[ptId]); newCellPts->InsertId(i,pointMap[ptId]);

6
src/OBJECT/SMESH_FaceOrientationFilter.cxx
View File

@ -209,8 +209,8 @@ void GetFaceParams( vtkCell* theFace, double theNormal[3], double& theSize )
double* aBounds = theFace->GetBounds(); double* aBounds = theFace->GetBounds();
theSize = pow( pow( aBounds[1] - aBounds[0], 2 ) + theSize = pow( pow( aBounds[1] - aBounds[0], 2 ) +
pow( aBounds[3] - aBounds[2], 2 ) + pow( aBounds[3] - aBounds[2], 2 ) +
pow( aBounds[5] - aBounds[4], 2 ), 0.5 ); pow( aBounds[5] - aBounds[4], 2 ), 0.5 );
} }
/*! /*!
@ -268,7 +268,7 @@ int SMESH_FaceOrientationFilter::RequestData(
input->GetCellNeighbors( aCellId, aFace->PointIds, aNeighborIds ); input->GetCellNeighbors( aCellId, aFace->PointIds, aNeighborIds );
if( aNeighborIds->GetNumberOfIds() > 0 ) if( aNeighborIds->GetNumberOfIds() > 0 )
continue; continue;
double aSize, aNormal[3]; double aSize, aNormal[3];
GetFaceParams( aFace, aNormal, aSize ); GetFaceParams( aFace, aNormal, aSize );

123
src/OBJECT/SMESH_Object.cxx
View File

@ -46,7 +46,7 @@
#include <vtkUnstructuredGrid.h> #include <vtkUnstructuredGrid.h>
#include <memory> #include <memory>
#include <sstream> #include <sstream>
#include <stdexcept> #include <stdexcept>
#include <set> #include <set>
@ -81,7 +81,7 @@ static int MYDEBUGWITHFILES = 0;
// purpose : Get type of VTK cell // purpose : Get type of VTK cell
//================================================================================= //=================================================================================
static inline vtkIdType getCellType( const SMDSAbs_ElementType theType, static inline vtkIdType getCellType( const SMDSAbs_ElementType theType,
const bool thePoly, const bool thePoly,
const int theNbNodes ) const int theNbNodes )
{ {
switch( theType ) switch( theType )
@ -263,7 +263,7 @@ namespace{
typedef std::vector<const SMDS_MeshElement*> TConnect; typedef std::vector<const SMDS_MeshElement*> TConnect;
int GetConnect(const SMDS_ElemIteratorPtr& theNodesIter, int GetConnect(const SMDS_ElemIteratorPtr& theNodesIter,
TConnect& theConnect) TConnect& theConnect)
{ {
theConnect.clear(); theConnect.clear();
for(; theNodesIter->more();) for(; theNodesIter->more();)
@ -273,10 +273,10 @@ namespace{
inline inline
void SetId(vtkIdList *theIdList, void SetId(vtkIdList *theIdList,
const SMESH_VisualObjDef::TMapOfIds& theSMDS2VTKNodes, const SMESH_VisualObjDef::TMapOfIds& theSMDS2VTKNodes,
const TConnect& theConnect, const TConnect& theConnect,
int thePosition, int thePosition,
int theId) int theId)
{ {
theIdList->SetId(thePosition,theSMDS2VTKNodes.find(theConnect[theId]->GetID())->second); theIdList->SetId(thePosition,theSMDS2VTKNodes.find(theConnect[theId]->GetID())->second);
} }
@ -372,12 +372,12 @@ void SMESH_VisualObjDef::buildElemPrs()
myVTK2SMDSElems.insert( TMapOfIds::value_type( iElem, anId ) ); myVTK2SMDSElems.insert( TMapOfIds::value_type( iElem, anId ) );
SMDS_ElemIteratorPtr aNodesIter = anElem->nodesIterator(); SMDS_ElemIteratorPtr aNodesIter = anElem->nodesIterator();
switch (aType) { switch (aType) {
case SMDSAbs_Volume:{ case SMDSAbs_Volume:{
aConnect.clear(); aConnect.clear();
std::vector<int> aConnectivities; std::vector<int> aConnectivities;
// Convertions connectivities from SMDS to VTK // Convertions connectivities from SMDS to VTK
if (anElem->IsPoly() && aNbNodes > 3) { // POLYEDRE if (anElem->IsPoly() && aNbNodes > 3) { // POLYEDRE
if ( const SMDS_PolyhedralVolumeOfNodes* ph = if ( const SMDS_PolyhedralVolumeOfNodes* ph =
dynamic_cast<const SMDS_PolyhedralVolumeOfNodes*> (anElem)) dynamic_cast<const SMDS_PolyhedralVolumeOfNodes*> (anElem))
@ -385,67 +385,67 @@ void SMESH_VisualObjDef::buildElemPrs()
aNbNodes = GetConnect(ph->uniqueNodesIterator(),aConnect); aNbNodes = GetConnect(ph->uniqueNodesIterator(),aConnect);
anIdList->SetNumberOfIds( aNbNodes ); anIdList->SetNumberOfIds( aNbNodes );
} }
for (int k = 0; k < aNbNodes; k++) for (int k = 0; k < aNbNodes; k++)
aConnectivities.push_back(k); aConnectivities.push_back(k);
} else if (aNbNodes == 4) { } else if (aNbNodes == 4) {
static int anIds[] = {0,2,1,3}; static int anIds[] = {0,2,1,3};
for (int k = 0; k < aNbNodes; k++) aConnectivities.push_back(anIds[k]); for (int k = 0; k < aNbNodes; k++) aConnectivities.push_back(anIds[k]);
} else if (aNbNodes == 5) { } else if (aNbNodes == 5) {
static int anIds[] = {0,3,2,1,4}; static int anIds[] = {0,3,2,1,4};
for (int k = 0; k < aNbNodes; k++) aConnectivities.push_back(anIds[k]); for (int k = 0; k < aNbNodes; k++) aConnectivities.push_back(anIds[k]);
} else if (aNbNodes == 6) { } else if (aNbNodes == 6) {
static int anIds[] = {0,1,2,3,4,5}; static int anIds[] = {0,1,2,3,4,5};
for (int k = 0; k < aNbNodes; k++) aConnectivities.push_back(anIds[k]); for (int k = 0; k < aNbNodes; k++) aConnectivities.push_back(anIds[k]);
} }
else if (aNbNodes == 8) { else if (aNbNodes == 8) {
static int anIds[] = {0,3,2,1,4,7,6,5}; static int anIds[] = {0,3,2,1,4,7,6,5};
for (int k = 0; k < aNbNodes; k++) aConnectivities.push_back(anIds[k]); for (int k = 0; k < aNbNodes; k++) aConnectivities.push_back(anIds[k]);
} }
else if (aNbNodes == 10) { else if (aNbNodes == 10) {
static int anIds[] = {0,2,1,3,6,5,4,7,9,8}; static int anIds[] = {0,2,1,3,6,5,4,7,9,8};
for (int k = 0; k < aNbNodes; k++) aConnectivities.push_back(anIds[k]); for (int k = 0; k < aNbNodes; k++) aConnectivities.push_back(anIds[k]);
} }
else if (aNbNodes == 13) { else if (aNbNodes == 13) {
static int anIds[] = {0,3,2,1,4,8,7,6,5,9,12,11,10}; static int anIds[] = {0,3,2,1,4,8,7,6,5,9,12,11,10};
for (int k = 0; k < aNbNodes; k++) aConnectivities.push_back(anIds[k]); for (int k = 0; k < aNbNodes; k++) aConnectivities.push_back(anIds[k]);
} }
else if (aNbNodes == 15) { else if (aNbNodes == 15) {
//static int anIds[] = {0,2,1,3,5,4,8,7,6,11,10,9,12,14,13}; //static int anIds[] = {0,2,1,3,5,4,8,7,6,11,10,9,12,14,13};
static int anIds[] = {0,1,2,3,4,5,6,7,8,9,10,11,12,13,14}; static int anIds[] = {0,1,2,3,4,5,6,7,8,9,10,11,12,13,14};
for (int k = 0; k < aNbNodes; k++) aConnectivities.push_back(anIds[k]); for (int k = 0; k < aNbNodes; k++) aConnectivities.push_back(anIds[k]);
//for (int k = 0; k < aNbNodes; k++) { //for (int k = 0; k < aNbNodes; k++) {
// int nn = aConnectivities[k]; // int nn = aConnectivities[k];
// const SMDS_MeshNode* N = static_cast<const SMDS_MeshNode*> (aConnect[nn]); // const SMDS_MeshNode* N = static_cast<const SMDS_MeshNode*> (aConnect[nn]);
// cout<<"k="<<k<<" N("<<N->X()<<","<<N->Y()<<","<<N->Z()<<")"<<endl; // cout<<"k="<<k<<" N("<<N->X()<<","<<N->Y()<<","<<N->Z()<<")"<<endl;
//} //}
} }
else if (aNbNodes == 20) { else if (aNbNodes == 20) {
static int anIds[] = {0,3,2,1,4,7,6,5,11,10,9,8,15,14,13,12,16,19,18,17}; static int anIds[] = {0,3,2,1,4,7,6,5,11,10,9,8,15,14,13,12,16,19,18,17};
for (int k = 0; k < aNbNodes; k++) aConnectivities.push_back(anIds[k]); for (int k = 0; k < aNbNodes; k++) aConnectivities.push_back(anIds[k]);
} }
else { else {
} }
if ( aConnect.empty() ) if ( aConnect.empty() )
GetConnect(aNodesIter,aConnect); GetConnect(aNodesIter,aConnect);
if (aConnectivities.size() > 0) { if (aConnectivities.size() > 0) {
for (vtkIdType aNodeId = 0; aNodeId < aNbNodes; aNodeId++) for (vtkIdType aNodeId = 0; aNodeId < aNbNodes; aNodeId++)
SetId(anIdList,mySMDS2VTKNodes,aConnect,aNodeId,aConnectivities[aNodeId]); SetId(anIdList,mySMDS2VTKNodes,aConnect,aNodeId,aConnectivities[aNodeId]);
} }
break; break;
} }
default: default:
for( vtkIdType aNodeId = 0; aNodesIter->more(); aNodeId++ ){ for( vtkIdType aNodeId = 0; aNodesIter->more(); aNodeId++ ){
const SMDS_MeshElement* aNode = aNodesIter->next(); const SMDS_MeshElement* aNode = aNodesIter->next();
anIdList->SetId( aNodeId, mySMDS2VTKNodes[aNode->GetID()] ); anIdList->SetId( aNodeId, mySMDS2VTKNodes[aNode->GetID()] );
} }
} }
aConnectivity->InsertNextCell( anIdList ); aConnectivity->InsertNextCell( anIdList );
aCellTypesArray->InsertNextValue( getCellType( aType, anElem->IsPoly(), aNbNodes ) ); aCellTypesArray->InsertNextValue( getCellType( aType, anElem->IsPoly(), aNbNodes ) );
@ -483,9 +483,9 @@ void SMESH_VisualObjDef::buildElemPrs()
// purpose : Retrieve ids of nodes from edge of elements ( edge is numbered from 1 ) // purpose : Retrieve ids of nodes from edge of elements ( edge is numbered from 1 )
//================================================================================= //=================================================================================
bool SMESH_VisualObjDef::GetEdgeNodes( const int theElemId, bool SMESH_VisualObjDef::GetEdgeNodes( const int theElemId,
const int theEdgeNum, const int theEdgeNum,
int& theNodeId1, int& theNodeId1,
int& theNodeId2 ) const int& theNodeId2 ) const
{ {
const SMDS_Mesh* aMesh = GetMesh(); const SMDS_Mesh* aMesh = GetMesh();
if ( aMesh == 0 ) if ( aMesh == 0 )
@ -520,6 +520,19 @@ bool SMESH_VisualObjDef::GetEdgeNodes( const int theElemId,
return true; return true;
} }
//=================================================================================
// function : IsValid
// purpose : Return true if there are some entities
//=================================================================================
bool SMESH_VisualObjDef::IsValid() const
{
return GetNbEntities(SMDSAbs_Node) > 0 ||
GetNbEntities(SMDSAbs_0DElement) > 0 ||
GetNbEntities(SMDSAbs_Edge) > 0 ||
GetNbEntities(SMDSAbs_Face) > 0 ||
GetNbEntities(SMDSAbs_Volume) > 0 ;
}
/* /*
Class : SMESH_MeshObj Class : SMESH_MeshObj
Description : Class for visualisation of mesh Description : Class for visualisation of mesh
@ -905,7 +918,7 @@ int SMESH_subMeshObj::GetNbEntities( const SMDSAbs_ElementType theType) const
case SMDSAbs_Volume: case SMDSAbs_Volume:
{ {
SMESH::long_array_var anIds = SMESH::long_array_var anIds =
mySubMeshServer->GetElementsByType( SMESH::ElementType(theType) ); mySubMeshServer->GetElementsByType( SMESH::ElementType(theType) );
return anIds->length(); return anIds->length();
} }
default: default:
@ -942,7 +955,7 @@ int SMESH_subMeshObj::GetEntities( const SMDSAbs_ElementType theType, TEntityLis
else else
{ {
SMESH::long_array_var anIds = SMESH::long_array_var anIds =
mySubMeshServer->GetElementsByType( SMESH::ElementType(theType) ); mySubMeshServer->GetElementsByType( SMESH::ElementType(theType) );
return getPointers( theType, anIds, aMesh, theResList ); return getPointers( theType, anIds, aMesh, theResList );
} }
} }

7
src/OBJECT/SMESH_Object.h
View File

@ -62,9 +62,10 @@ public:
virtual SMDS_Mesh* GetMesh() const = 0; virtual SMDS_Mesh* GetMesh() const = 0;
virtual bool GetEdgeNodes( const int theElemId, virtual bool GetEdgeNodes( const int theElemId,
const int theEdgeNum, const int theEdgeNum,
int& theNodeId1, int& theNodeId1,
int& theNodeId2 ) const = 0; int& theNodeId2 ) const = 0;
virtual bool IsValid() const = 0;
virtual vtkUnstructuredGrid* GetUnstructuredGrid() = 0; virtual vtkUnstructuredGrid* GetUnstructuredGrid() = 0;

2
src/OBJECT/SMESH_ObjectDef.h
View File

@ -69,6 +69,8 @@ public:
virtual bool IsNodePrs() const = 0; virtual bool IsNodePrs() const = 0;
virtual SMDS_Mesh* GetMesh() const = 0; virtual SMDS_Mesh* GetMesh() const = 0;
virtual bool IsValid() const;
virtual bool GetEdgeNodes( const int theElemId, virtual bool GetEdgeNodes( const int theElemId,
const int theEdgeNum, const int theEdgeNum,
int& theNodeId1, int& theNodeId1,

32
src/OBJECT/SMESH_PreviewActorsCollection.cxx
View File

@ -137,25 +137,25 @@ GEOM_Actor* SMESH_PreviewActorsCollection::createActor(const TopoDS_Shape& shape
actor->SetShape(shape,0,0); actor->SetShape(shape,0,0);
//Color Properties //Color Properties
/* /*
vtkProperty* aProp = vtkProperty::New(); vtkProperty* aProp = vtkProperty::New();
vtkProperty* aHLProp = vtkProperty::New(); vtkProperty* aHLProp = vtkProperty::New();
vtkProperty* aPHLProp = vtkProperty::New(); vtkProperty* aPHLProp = vtkProperty::New();
aProp->SetColor( 255, 0, 0); aProp->SetColor( 255, 0, 0);
actor->SetProperty(aProp); actor->SetProperty(aProp);
aHLProp->SetColor( 255, 255, 255); aHLProp->SetColor( 255, 255, 255);
actor->SetHighlightProperty(aHLProp); actor->SetHighlightProperty(aHLProp);
aPHLProp->SetColor( 155, 155, 155); aPHLProp->SetColor( 155, 155, 155);
aPHLProp->SetLineWidth ( 3 ); aPHLProp->SetLineWidth ( 3 );
aPHLProp->SetOpacity ( 0.75 ); aPHLProp->SetOpacity ( 0.75 );
actor->SetPreHighlightProperty(aPHLProp); actor->SetPreHighlightProperty(aPHLProp);
aProp->Delete(); aProp->Delete();
aHLProp->Delete(); aHLProp->Delete();
aPHLProp->Delete(); aPHLProp->Delete();
*/ */
return actor; return actor;

3
src/SMESH/SMESH_Block.cxx
View File

@ -996,7 +996,8 @@ int SMESH_Block::GetOrderedEdges (const TopoDS_Face& theFace,
for ( iE = 0; wExp.More(); wExp.Next(), iE++ ) for ( iE = 0; wExp.More(); wExp.Next(), iE++ )
{ {
TopoDS_Edge edge = wExp.Current(); TopoDS_Edge edge = wExp.Current();
edge = TopoDS::Edge( edge.Oriented( wExp.Orientation() )); // commented for issue 0020557, other related ones: 0020526, PAL19080
// edge = TopoDS::Edge( edge.Oriented( wExp.Orientation() ));
theEdges.push_back( edge ); theEdges.push_back( edge );
} }
theNbVertexInWires.push_back( iE ); theNbVertexInWires.push_back( iE );

82
src/SMESH/SMESH_Gen.cxx
View File

@ -434,7 +434,7 @@ static bool checkConformIgnoredAlgos(SMESH_Mesh& aMesh,
const SMESH_Algo* aGlobIgnoAlgo, const SMESH_Algo* aGlobIgnoAlgo,
const SMESH_Algo* aLocIgnoAlgo, const SMESH_Algo* aLocIgnoAlgo,
bool & checkConform, bool & checkConform,
map<int, SMESH_subMesh*>& aCheckedMap, set<SMESH_subMesh*>& aCheckedMap,
list< SMESH_Gen::TAlgoStateError > & theErrors) list< SMESH_Gen::TAlgoStateError > & theErrors)
{ {
ASSERT( aSubMesh ); ASSERT( aSubMesh );
@ -489,19 +489,15 @@ static bool checkConformIgnoredAlgos(SMESH_Mesh& aMesh,
} }
// sub-algos will be hidden by a local <algo> // sub-algos will be hidden by a local <algo>
const map<int, SMESH_subMesh*>& smMap = aSubMesh->DependsOn(); SMESH_subMeshIteratorPtr revItSub =
map<int, SMESH_subMesh*>::const_reverse_iterator revItSub; aSubMesh->getDependsOnIterator( /*includeSelf=*/false, /*complexShapeFirst=*/true);
bool checkConform2 = false; bool checkConform2 = false;
for ( revItSub = smMap.rbegin(); revItSub != smMap.rend(); revItSub++) while ( revItSub->more() )
{ {
checkConformIgnoredAlgos (aMesh, (*revItSub).second, aGlobIgnoAlgo, SMESH_subMesh* sm = revItSub->next();
checkConformIgnoredAlgos (aMesh, sm, aGlobIgnoAlgo,
algo, checkConform2, aCheckedMap, theErrors); algo, checkConform2, aCheckedMap, theErrors);
int key = (*revItSub).first; aCheckedMap.insert( sm );
SMESH_subMesh* sm = (*revItSub).second;
if ( aCheckedMap.find( key ) == aCheckedMap.end() )
{
aCheckedMap[ key ] = sm;
}
} }
} }
} }
@ -522,7 +518,7 @@ static bool checkMissing(SMESH_Gen* aGen,
const int aTopAlgoDim, const int aTopAlgoDim,
bool* globalChecked, bool* globalChecked,
const bool checkNoAlgo, const bool checkNoAlgo,
map<int, SMESH_subMesh*>& aCheckedMap, set<SMESH_subMesh*>& aCheckedMap,
list< SMESH_Gen::TAlgoStateError > & theErrors) list< SMESH_Gen::TAlgoStateError > & theErrors)
{ {
if ( aSubMesh->GetSubShape().ShapeType() == TopAbs_VERTEX) if ( aSubMesh->GetSubShape().ShapeType() == TopAbs_VERTEX)
@ -595,15 +591,13 @@ static bool checkMissing(SMESH_Gen* aGen,
if (!algo->NeedDescretBoundary() || isTopLocalAlgo) if (!algo->NeedDescretBoundary() || isTopLocalAlgo)
{ {
bool checkNoAlgo2 = ( algo->NeedDescretBoundary() ); bool checkNoAlgo2 = ( algo->NeedDescretBoundary() );
const map<int, SMESH_subMesh*>& subMeshes = aSubMesh->DependsOn(); SMESH_subMeshIteratorPtr itsub = aSubMesh->getDependsOnIterator( /*includeSelf=*/false,
map<int, SMESH_subMesh*>::const_iterator itsub; /*complexShapeFirst=*/false);
for (itsub = subMeshes.begin(); itsub != subMeshes.end(); itsub++) while ( itsub->more() )
{ {
// sub-meshes should not be checked further more // sub-meshes should not be checked further more
int key = (*itsub).first; SMESH_subMesh* sm = itsub->next();
SMESH_subMesh* sm = (*itsub).second; aCheckedMap.insert( sm );
if ( aCheckedMap.find( key ) == aCheckedMap.end() )
aCheckedMap[ key ] = sm;
if (isTopLocalAlgo) if (isTopLocalAlgo)
{ {
@ -697,39 +691,25 @@ bool SMESH_Gen::GetAlgoState(SMESH_Mesh& theMesh,
} }
} }
const map<int, SMESH_subMesh*>& smMap = sm->DependsOn(); set<SMESH_subMesh*> aCheckedSubs;
map<int, SMESH_subMesh*>::const_reverse_iterator revItSub = smMap.rbegin();
map<int, SMESH_subMesh*> aCheckedMap;
bool checkConform = ( !theMesh.IsNotConformAllowed() ); bool checkConform = ( !theMesh.IsNotConformAllowed() );
int aKey = 1;
SMESH_subMesh* smToCheck = sm;
// loop on theShape and its sub-shapes // loop on theShape and its sub-shapes
while ( smToCheck ) SMESH_subMeshIteratorPtr revItSub = sm->getDependsOnIterator( /*includeSelf=*/true,
/*complexShapeFirst=*/true);
while ( revItSub->more() )
{ {
SMESH_subMesh* smToCheck = revItSub->next();
if ( smToCheck->GetSubShape().ShapeType() == TopAbs_VERTEX) if ( smToCheck->GetSubShape().ShapeType() == TopAbs_VERTEX)
break; break;
if ( aCheckedMap.find( aKey ) == aCheckedMap.end() ) if ( aCheckedSubs.insert( smToCheck ).second ) // not yet checked
if (!checkConformIgnoredAlgos (theMesh, smToCheck, aGlobIgnoAlgo, if (!checkConformIgnoredAlgos (theMesh, smToCheck, aGlobIgnoAlgo,
0, checkConform, aCheckedMap, theErrors)) 0, checkConform, aCheckedSubs, theErrors))
ret = false; ret = false;
if ( smToCheck->GetAlgoState() != SMESH_subMesh::NO_ALGO ) if ( smToCheck->GetAlgoState() != SMESH_subMesh::NO_ALGO )
hasAlgo = true; hasAlgo = true;
// next subMesh
if (revItSub != smMap.rend())
{
aKey = (*revItSub).first;
smToCheck = (*revItSub).second;
revItSub++;
}
else
{
smToCheck = 0;
}
} }
// ---------------------------------------------------------------- // ----------------------------------------------------------------
@ -749,36 +729,26 @@ bool SMESH_Gen::GetAlgoState(SMESH_Mesh& theMesh,
break; break;
} }
} }
aCheckedMap.clear();
smToCheck = sm;
revItSub = smMap.rbegin();
bool checkNoAlgo = theMesh.HasShapeToMesh() ? bool( aTopAlgoDim ) : false; bool checkNoAlgo = theMesh.HasShapeToMesh() ? bool( aTopAlgoDim ) : false;
bool globalChecked[] = { false, false, false, false }; bool globalChecked[] = { false, false, false, false };
// loop on theShape and its sub-shapes // loop on theShape and its sub-shapes
while ( smToCheck ) aCheckedSubs.clear();
revItSub = sm->getDependsOnIterator( /*includeSelf=*/true, /*complexShapeFirst=*/true);
while ( revItSub->more() )
{ {
SMESH_subMesh* smToCheck = revItSub->next();
if ( smToCheck->GetSubShape().ShapeType() == TopAbs_VERTEX) if ( smToCheck->GetSubShape().ShapeType() == TopAbs_VERTEX)
break; break;
if ( aCheckedMap.find( aKey ) == aCheckedMap.end() ) if ( aCheckedSubs.insert( smToCheck ).second ) // not yet checked
if (!checkMissing (this, theMesh, smToCheck, aTopAlgoDim, if (!checkMissing (this, theMesh, smToCheck, aTopAlgoDim,
globalChecked, checkNoAlgo, aCheckedMap, theErrors)) globalChecked, checkNoAlgo, aCheckedSubs, theErrors))
{ {
ret = false; ret = false;
if (smToCheck->GetAlgoState() == SMESH_subMesh::NO_ALGO ) if (smToCheck->GetAlgoState() == SMESH_subMesh::NO_ALGO )
checkNoAlgo = false; checkNoAlgo = false;
} }
// next subMesh
if (revItSub != smMap.rend())
{
aKey = (*revItSub).first;
smToCheck = (*revItSub).second;
revItSub++;
}
else
smToCheck = 0;
} }
if ( !hasAlgo ) { if ( !hasAlgo ) {

24
src/SMESH/SMESH_Gen.hxx
View File

@ -61,7 +61,7 @@ typedef std::set<int> TSetOfInt;
class SMESH_EXPORT SMESH_Gen class SMESH_EXPORT SMESH_Gen
{ {
public: public:
SMESH_Gen(); SMESH_Gen();
~SMESH_Gen(); ~SMESH_Gen();
@ -78,8 +78,8 @@ class SMESH_EXPORT SMESH_Gen
bool Compute(::SMESH_Mesh & aMesh, bool Compute(::SMESH_Mesh & aMesh,
const TopoDS_Shape & aShape, const TopoDS_Shape & aShape,
const bool anUpward=false, const bool anUpward=false,
const ::MeshDimension aDim=::MeshDim_3D, const ::MeshDimension aDim=::MeshDim_3D,
TSetOfInt* aShapesId=0); TSetOfInt* aShapesId=0);
/*! /*!
* \brief evaluates size of prospective mesh on a shape * \brief evaluates size of prospective mesh on a shape
@ -89,8 +89,8 @@ class SMESH_EXPORT SMESH_Gen
* \retval bool - is a success * \retval bool - is a success
*/ */
bool Evaluate(::SMESH_Mesh & aMesh, bool Evaluate(::SMESH_Mesh & aMesh,
const TopoDS_Shape & aShape, const TopoDS_Shape & aShape,
MapShapeNbElems& aResMap, MapShapeNbElems& aResMap,
const bool anUpward=false, const bool anUpward=false,
TSetOfInt* aShapesId=0); TSetOfInt* aShapesId=0);
@ -109,7 +109,7 @@ class SMESH_EXPORT SMESH_Gen
*/ */
void SetDefaultNbSegments(int nb) { _nbSegments = nb; } void SetDefaultNbSegments(int nb) { _nbSegments = nb; }
int GetDefaultNbSegments() const { return _nbSegments; } int GetDefaultNbSegments() const { return _nbSegments; }
struct TAlgoStateError struct TAlgoStateError
{ {
TAlgoStateErrorName _name; TAlgoStateErrorName _name;
@ -138,16 +138,6 @@ class SMESH_EXPORT SMESH_Gen
SMESH_Algo* GetAlgo(SMESH_Mesh & aMesh, const TopoDS_Shape & aShape, TopoDS_Shape* assignedTo=0); SMESH_Algo* GetAlgo(SMESH_Mesh & aMesh, const TopoDS_Shape & aShape, TopoDS_Shape* assignedTo=0);
static bool IsGlobalHypothesis(const SMESH_Hypothesis* theHyp, SMESH_Mesh& aMesh); static bool IsGlobalHypothesis(const SMESH_Hypothesis* theHyp, SMESH_Mesh& aMesh);
// inherited methods from SALOMEDS::Driver
// void Save(int studyId, const char *aUrlOfFile);
// void Load(int studyId, const char *aUrlOfFile);
// void Close(int studyId);
// const char *ComponentDataType();
// const char *IORToLocalPersistentID(const char *IORString, bool & IsAFile);
// const char *LocalPersistentIDToIOR(const char *aLocalPersistentID);
int GetANewId(); int GetANewId();
std::map < int, SMESH_Algo * >_mapAlgo; std::map < int, SMESH_Algo * >_mapAlgo;
@ -156,7 +146,7 @@ class SMESH_EXPORT SMESH_Gen
std::map < int, SMESH_2D_Algo * >_map2D_Algo; std::map < int, SMESH_2D_Algo * >_map2D_Algo;
std::map < int, SMESH_3D_Algo * >_map3D_Algo; std::map < int, SMESH_3D_Algo * >_map3D_Algo;
private: private:
int _localId; // unique Id of created objects, within SMESH_Gen entity int _localId; // unique Id of created objects, within SMESH_Gen entity
std::map < int, StudyContextStruct * >_mapStudyContext; std::map < int, StudyContextStruct * >_mapStudyContext;

106
src/SMESH/SMESH_MeshEditor.cxx
View File

@ -2805,12 +2805,12 @@ void SMESH_MeshEditor::sweepElement(const SMDS_MeshElement* elem,
return; return;
} }
issimple[iNode] = (listNewNodes.size()==nbSteps); issimple[iNode] = (listNewNodes.size()==nbSteps); // is node medium
itNN[ iNode ] = listNewNodes.begin(); itNN[ iNode ] = listNewNodes.begin();
prevNod[ iNode ] = node; prevNod[ iNode ] = node;
nextNod[ iNode ] = listNewNodes.front(); nextNod[ iNode ] = listNewNodes.front();
if( !issimple[iNode] ) { if( !elem->IsQuadratic() || !issimple[iNode] ) {
if ( prevNod[ iNode ] != nextNod [ iNode ]) if ( prevNod[ iNode ] != nextNod [ iNode ])
iNotSameNode = iNode; iNotSameNode = iNode;
else { else {
@ -2823,8 +2823,8 @@ void SMESH_MeshEditor::sweepElement(const SMDS_MeshElement* elem,
//cout<<" nbSame = "<<nbSame<<endl; //cout<<" nbSame = "<<nbSame<<endl;
if ( nbSame == nbNodes || nbSame > 2) { if ( nbSame == nbNodes || nbSame > 2) {
//MESSAGE( " Too many same nodes of element " << elem->GetID() ); MESSAGE( " Too many same nodes of element " << elem->GetID() );
INFOS( " Too many same nodes of element " << elem->GetID() ); //INFOS( " Too many same nodes of element " << elem->GetID() );
return; return;
} }
@ -7695,6 +7695,9 @@ int SMESH_MeshEditor::convertElemToQuadratic(SMESHDS_SubMesh * theSm,
case 4: case 4:
NewElem = theHelper.AddVolume(aNds[0], aNds[1], aNds[2], aNds[3], id, theForce3d); NewElem = theHelper.AddVolume(aNds[0], aNds[1], aNds[2], aNds[3], id, theForce3d);
break; break;
case 5:
NewElem = theHelper.AddVolume(aNds[0], aNds[1], aNds[2], aNds[3], aNds[4], id, theForce3d);
break;
case 6: case 6:
NewElem = theHelper.AddVolume(aNds[0], aNds[1], aNds[2], aNds[3], aNds[4], aNds[5], id, theForce3d); NewElem = theHelper.AddVolume(aNds[0], aNds[1], aNds[2], aNds[3], aNds[4], aNds[5], id, theForce3d);
break; break;
@ -7819,6 +7822,10 @@ void SMESH_MeshEditor::ConvertToQuadratic(const bool theForce3d)
NewVolume = aHelper.AddVolume(aNds[0], aNds[1], aNds[2], NewVolume = aHelper.AddVolume(aNds[0], aNds[1], aNds[2],
aNds[3], id, theForce3d ); aNds[3], id, theForce3d );
break; break;
case 5:
NewVolume = aHelper.AddVolume(aNds[0], aNds[1], aNds[2],
aNds[3], aNds[4], id, theForce3d);
break;
case 6: case 6:
NewVolume = aHelper.AddVolume(aNds[0], aNds[1], aNds[2], NewVolume = aHelper.AddVolume(aNds[0], aNds[1], aNds[2],
aNds[3], aNds[4], aNds[5], id, theForce3d); aNds[3], aNds[4], aNds[5], id, theForce3d);
@ -8774,7 +8781,7 @@ bool SMESH_MeshEditor::doubleNodes( SMESHDS_Mesh* theMeshDS,
theNodeNodeMap[ aCurrNode ] = aNewNode; theNodeNodeMap[ aCurrNode ] = aNewNode;
myLastCreatedNodes.Append( aNewNode ); myLastCreatedNodes.Append( aNewNode );
} }
isDuplicate |= (aCurrNode == aNewNode); isDuplicate |= (aCurrNode != aNewNode);
newNodes[ ind++ ] = aNewNode; newNodes[ ind++ ] = aNewNode;
} }
if ( !isDuplicate ) if ( !isDuplicate )
@ -8812,6 +8819,95 @@ static bool isInside(const SMDS_MeshElement* theElem,
return (aState == TopAbs_IN || aState == TopAbs_ON ); return (aState == TopAbs_IN || aState == TopAbs_ON );
} }
/*!
\brief Creates a hole in a mesh by doubling the nodes of some particular elements
\param theNodes - identifiers of nodes to be doubled
\param theModifiedElems - identifiers of elements to be updated by the new (doubled)
nodes. If list of element identifiers is empty then nodes are doubled but
they not assigned to elements
\return TRUE if operation has been completed successfully, FALSE otherwise
*/
bool SMESH_MeshEditor::DoubleNodes( const std::list< int >& theListOfNodes,
const std::list< int >& theListOfModifiedElems )
{
myLastCreatedElems.Clear();
myLastCreatedNodes.Clear();
if ( theListOfNodes.size() == 0 )
return false;
SMESHDS_Mesh* aMeshDS = GetMeshDS();
if ( !aMeshDS )
return false;
// iterate through nodes and duplicate them
std::map< const SMDS_MeshNode*, const SMDS_MeshNode* > anOldNodeToNewNode;
std::list< int >::const_iterator aNodeIter;
for ( aNodeIter = theListOfNodes.begin(); aNodeIter != theListOfNodes.end(); ++aNodeIter )
{
int aCurr = *aNodeIter;
SMDS_MeshNode* aNode = (SMDS_MeshNode*)aMeshDS->FindNode( aCurr );
if ( !aNode )
continue;
// duplicate node
const SMDS_MeshNode* aNewNode = aMeshDS->AddNode( aNode->X(), aNode->Y(), aNode->Z() );
if ( aNewNode )
{
anOldNodeToNewNode[ aNode ] = aNewNode;
myLastCreatedNodes.Append( aNewNode );
}
}
// Create map of new nodes for modified elements
std::map< SMDS_MeshElement*, vector<const SMDS_MeshNode*> > anElemToNodes;
std::list< int >::const_iterator anElemIter;
for ( anElemIter = theListOfModifiedElems.begin();
anElemIter != theListOfModifiedElems.end(); ++anElemIter )
{
int aCurr = *anElemIter;
SMDS_MeshElement* anElem = (SMDS_MeshElement*)aMeshDS->FindElement( aCurr );
if ( !anElem )
continue;
vector<const SMDS_MeshNode*> aNodeArr( anElem->NbNodes() );
SMDS_ElemIteratorPtr anIter = anElem->nodesIterator();
int ind = 0;
while ( anIter->more() )
{
SMDS_MeshNode* aCurrNode = (SMDS_MeshNode*)anIter->next();
if ( aCurr && anOldNodeToNewNode.find( aCurrNode ) != anOldNodeToNewNode.end() )
{
const SMDS_MeshNode* aNewNode = anOldNodeToNewNode[ aCurrNode ];
aNodeArr[ ind++ ] = aNewNode;
}
else
aNodeArr[ ind++ ] = aCurrNode;
}
anElemToNodes[ anElem ] = aNodeArr;
}
// Change nodes of elements
std::map< SMDS_MeshElement*, vector<const SMDS_MeshNode*> >::iterator
anElemToNodesIter = anElemToNodes.begin();
for ( ; anElemToNodesIter != anElemToNodes.end(); ++anElemToNodesIter )
{
const SMDS_MeshElement* anElem = anElemToNodesIter->first;
vector<const SMDS_MeshNode*> aNodeArr = anElemToNodesIter->second;
if ( anElem )
aMeshDS->ChangeElementNodes( anElem, &aNodeArr[ 0 ], anElem->NbNodes() );
}
return true;
}
/*! /*!
\brief Creates a hole in a mesh by doubling the nodes of some particular elements \brief Creates a hole in a mesh by doubling the nodes of some particular elements
\param theElems - group of of elements (edges or faces) to be replicated \param theElems - group of of elements (edges or faces) to be replicated

5
src/SMESH/SMESH_MeshEditor.hxx
View File

@ -601,6 +601,9 @@ public:
const SMESH_SequenceOfElemPtr& GetLastCreatedNodes() const { return myLastCreatedNodes; } const SMESH_SequenceOfElemPtr& GetLastCreatedNodes() const { return myLastCreatedNodes; }
const SMESH_SequenceOfElemPtr& GetLastCreatedElems() const { return myLastCreatedElems; } const SMESH_SequenceOfElemPtr& GetLastCreatedElems() const { return myLastCreatedElems; }
bool DoubleNodes( const std::list< int >& theListOfNodes,
const std::list< int >& theListOfModifiedElems );
bool DoubleNodes( const TIDSortedElemSet& theElems, bool DoubleNodes( const TIDSortedElemSet& theElems,
const TIDSortedElemSet& theNodesNot, const TIDSortedElemSet& theNodesNot,
@ -609,7 +612,7 @@ public:
bool DoubleNodesInRegion( const TIDSortedElemSet& theElems, bool DoubleNodesInRegion( const TIDSortedElemSet& theElems,
const TIDSortedElemSet& theNodesNot, const TIDSortedElemSet& theNodesNot,
const TopoDS_Shape& theShape ); const TopoDS_Shape& theShape );
/*! /*!
* \brief Generated skin mesh (containing 2D cells) from 3D mesh * \brief Generated skin mesh (containing 2D cells) from 3D mesh
* The created 2D mesh elements based on nodes of free faces of boundary volumes * The created 2D mesh elements based on nodes of free faces of boundary volumes

7
src/SMESH/SMESH_MesherHelper.cxx
View File

@ -356,9 +356,12 @@ gp_XY SMESH_MesherHelper::GetNodeUV(const TopoDS_Face& F,
static_cast<const SMDS_EdgePosition*>(n->GetPosition().get()); static_cast<const SMDS_EdgePosition*>(n->GetPosition().get());
int edgeID = Pos->GetShapeId(); int edgeID = Pos->GetShapeId();
TopoDS_Edge E = TopoDS::Edge(GetMeshDS()->IndexToShape(edgeID)); TopoDS_Edge E = TopoDS::Edge(GetMeshDS()->IndexToShape(edgeID));
double f, l; double f, l, u = epos->GetUParameter();
Handle(Geom2d_Curve) C2d = BRep_Tool::CurveOnSurface(E, F, f, l); Handle(Geom2d_Curve) C2d = BRep_Tool::CurveOnSurface(E, F, f, l);
uv = C2d->Value( epos->GetUParameter() ); if ( f < u && u < l )
uv = C2d->Value( u );
else
uv.SetCoord(0.,0.);
uvOK = CheckNodeUV( F, n, uv.ChangeCoord(), BRep_Tool::Tolerance( E )); uvOK = CheckNodeUV( F, n, uv.ChangeCoord(), BRep_Tool::Tolerance( E ));
// for a node on a seam edge select one of UVs on 2 pcurves // for a node on a seam edge select one of UVs on 2 pcurves

1
src/SMESH/SMESH_subMesh.hxx
View File

@ -23,7 +23,6 @@
// File : SMESH_subMesh.hxx // File : SMESH_subMesh.hxx
// Author : Paul RASCLE, EDF // Author : Paul RASCLE, EDF
// Module : SMESH // Module : SMESH
// $Header$
// //
#ifndef _SMESH_SUBMESH_HXX_ #ifndef _SMESH_SUBMESH_HXX_
#define _SMESH_SUBMESH_HXX_ #define _SMESH_SUBMESH_HXX_

5
src/SMESHDS/SMESHDS_CommandType.hxx
View File

@ -30,7 +30,6 @@
enum SMESHDS_CommandType { enum SMESHDS_CommandType {
SMESHDS_AddNode, SMESHDS_AddNode,
SMESHDS_Add0DElement,
SMESHDS_AddEdge, SMESHDS_AddEdge,
SMESHDS_AddTriangle, SMESHDS_AddTriangle,
SMESHDS_AddQuadrangle, SMESHDS_AddQuadrangle,
@ -54,7 +53,9 @@ enum SMESHDS_CommandType {
SMESHDS_AddQuadTetrahedron, SMESHDS_AddQuadTetrahedron,
SMESHDS_AddQuadPyramid, SMESHDS_AddQuadPyramid,
SMESHDS_AddQuadPentahedron, SMESHDS_AddQuadPentahedron,
SMESHDS_AddQuadHexahedron SMESHDS_AddQuadHexahedron,
// special type for 0D elements
SMESHDS_Add0DElement
}; };

15
src/SMESHGUI/SMESHGUI_BuildCompoundDlg.cxx
View File

@ -289,6 +289,8 @@ bool SMESHGUI_BuildCompoundDlg::ClickOnApply()
if (!isValid()) if (!isValid())
return false; return false;
SMESH::SMESH_Mesh_var aCompoundMesh;
if (!myMesh->_is_nil()) { if (!myMesh->_is_nil()) {
QStringList aParameters; QStringList aParameters;
aParameters << (CheckBoxMerge->isChecked() ? SpinBoxTol->text() : QString(" ")); aParameters << (CheckBoxMerge->isChecked() ? SpinBoxTol->text() : QString(" "));
@ -297,7 +299,6 @@ bool SMESHGUI_BuildCompoundDlg::ClickOnApply()
SMESH::SMESH_Gen_var aSMESHGen = SMESHGUI::GetSMESHGen(); SMESH::SMESH_Gen_var aSMESHGen = SMESHGUI::GetSMESHGen();
// concatenate meshes // concatenate meshes
SMESH::SMESH_Mesh_var aCompoundMesh;
if(CheckBoxCommon->isChecked()) if(CheckBoxCommon->isChecked())
aCompoundMesh = aSMESHGen->ConcatenateWithGroups(myMeshArray, aCompoundMesh = aSMESHGen->ConcatenateWithGroups(myMeshArray,
!(ComboBoxUnion->currentIndex()), !(ComboBoxUnion->currentIndex()),
@ -319,8 +320,16 @@ bool SMESHGUI_BuildCompoundDlg::ClickOnApply()
LineEditName->setText(GetDefaultName(tr("COMPOUND_MESH"))); LineEditName->setText(GetDefaultName(tr("COMPOUND_MESH")));
//mySelectionMgr->clearSelected(); // IPAL21468 Compound is hidden after creation.
SMESH::UpdateView(); if ( SMESHGUI::automaticUpdate() ) {
mySelectionMgr->clearSelected();
SMESH::UpdateView();
_PTR(SObject) aSO = SMESH::FindSObject(aCompoundMesh.in());
if ( SMESH_Actor* anActor = SMESH::CreateActor(aSO->GetStudy(), aSO->GetID().c_str()) )
SMESH::DisplayActor(SMESH::GetActiveWindow(), anActor);
}// end IPAL21468
return true; return true;
} }
return false; return false;

5
src/SMESHGUI/SMESHGUI_ClippingDlg.cxx
View File

@ -72,7 +72,7 @@
class OrientedPlane: public vtkPlane class OrientedPlane: public vtkPlane
{ {
SVTK_ViewWindow* myViewWindow; QPointer<SVTK_ViewWindow> myViewWindow;
vtkDataSetMapper* myMapper; vtkDataSetMapper* myMapper;
@ -168,7 +168,8 @@ protected:
} }
~OrientedPlane(){ ~OrientedPlane(){
myViewWindow->RemoveActor(myActor); if (myViewWindow)
myViewWindow->RemoveActor(myActor);
myActor->Delete(); myActor->Delete();
myMapper->RemoveAllInputs(); myMapper->RemoveAllInputs();

6
src/SMESHGUI/SMESHGUI_ConvToQuadOp.cxx
View File

@ -32,9 +32,10 @@
#include <SMESH_TypeFilter.hxx> #include <SMESH_TypeFilter.hxx>
// SALOME GUI includes // SALOME GUI includes
#include <SalomeApp_Tools.h>
#include <SUIT_MessageBox.h>
#include <LightApp_UpdateFlags.h> #include <LightApp_UpdateFlags.h>
#include <SUIT_MessageBox.h>
#include <SUIT_OverrideCursor.h>
#include <SalomeApp_Tools.h>
// IDL includes // IDL includes
#include <SALOMEconfig.h> #include <SALOMEconfig.h>
@ -176,6 +177,7 @@ SUIT_SelectionFilter* SMESHGUI_ConvToQuadOp::createFilter( const int theId ) con
//================================================================================ //================================================================================
bool SMESHGUI_ConvToQuadOp::onApply() bool SMESHGUI_ConvToQuadOp::onApply()
{ {
SUIT_OverrideCursor aWaitCursor;
QString aMess; QString aMess;

8
src/SMESHGUI/SMESHGUI_FilterDlg.cxx
View File

@ -2632,7 +2632,13 @@ void SMESHGUI_FilterDlg::SetSourceWg (QWidget* theWg,
//======================================================================= //=======================================================================
void SMESHGUI_FilterDlg::SetMesh (SMESH::SMESH_Mesh_var theMesh) void SMESHGUI_FilterDlg::SetMesh (SMESH::SMESH_Mesh_var theMesh)
{ {
myMesh = theMesh; if ( !theMesh->_is_nil() ) {
myMesh = theMesh;
if ( !myFilter[ myTable->GetType() ]->_is_nil() && !myFilter[ myTable->GetType() ]->GetPredicate()->_is_nil() ) {
SMESH::Predicate_ptr aPred = myFilter[ myTable->GetType() ]->GetPredicate();
aPred->SetMesh(myMesh);
}
}
const bool isEnable = !(myMesh->_is_nil()); const bool isEnable = !(myMesh->_is_nil());
myButtons[BTN_OK]->setEnabled(isEnable); myButtons[BTN_OK]->setEnabled(isEnable);
myButtons[BTN_Apply]->setEnabled(isEnable); myButtons[BTN_Apply]->setEnabled(isEnable);

10
src/SMESHGUI/SMESHGUI_GroupDlg.cxx
View File

@ -1062,6 +1062,10 @@ void SMESHGUI_GroupDlg::onObjectSelectionChanged()
myIsBusy = false; myIsBusy = false;
return; return;
} }
if ( myFilterDlg && !myMesh->_is_nil()){
myFilterDlg->SetMesh( myMesh );
}
myGroup = SMESH::SMESH_Group::_nil(); myGroup = SMESH::SMESH_Group::_nil();
// NPAL19389: create a group with a selection in another group // NPAL19389: create a group with a selection in another group
@ -1087,7 +1091,6 @@ void SMESHGUI_GroupDlg::onObjectSelectionChanged()
return; return;
} }
myIsBusy = false; myIsBusy = false;
myCurrentLineEdit = 0;
myGroup = SMESH::SMESH_Group::_nil(); myGroup = SMESH::SMESH_Group::_nil();
myGroupOnGeom = SMESH::SMESH_GroupOnGeom::_nil(); myGroupOnGeom = SMESH::SMESH_GroupOnGeom::_nil();
@ -1417,11 +1420,14 @@ void SMESHGUI_GroupDlg::setCurrentSelection()
QPushButton* send = (QPushButton*)sender(); QPushButton* send = (QPushButton*)sender();
myCurrentLineEdit = 0; myCurrentLineEdit = 0;
if (send == myMeshGroupBtn) { if (send == myMeshGroupBtn) {
myCurrentLineEdit = myMeshGroupLine; disconnect(myMeshGroupBtn, SIGNAL(clicked()), this, SLOT(setCurrentSelection()));
mySelectionMgr->clearSelected();
if (myCreate) if (myCreate)
setSelectionMode(6); setSelectionMode(6);
else else
setSelectionMode(5); setSelectionMode(5);
connect(myMeshGroupBtn, SIGNAL(clicked()), this, SLOT(setCurrentSelection()));
myCurrentLineEdit = myMeshGroupLine;
onObjectSelectionChanged(); onObjectSelectionChanged();
} }
else if (send == mySubMeshBtn) { else if (send == mySubMeshBtn) {

7
src/SMESHGUI/SMESHGUI_Hypotheses.cxx
View File

@ -533,14 +533,15 @@ QString SMESHGUI_GenericHypothesisCreator::helpPage() const
else if ( aHypType == "NumberOfLayers") else if ( aHypType == "NumberOfLayers")
aHelpFileName = "radial_prism_algo_page.html"; aHelpFileName = "radial_prism_algo_page.html";
else if ( aHypType == "NumberOfLayers2D") else if ( aHypType == "NumberOfLayers2D")
aHelpFileName = "radial_prism_algo_page.html"; aHelpFileName = "radial_quadrangle_1D2D_algo_page.html";
else if ( aHypType == "LayerDistribution") else if ( aHypType == "LayerDistribution")
aHelpFileName = "radial_prism_algo_page.html"; aHelpFileName = "radial_prism_algo_page.html";
else if ( aHypType == "LayerDistribution2D") else if ( aHypType == "LayerDistribution2D")
aHelpFileName = "radial_prism_algo_page.html"; aHelpFileName = "radial_quadrangle_1D2D_algo_page.html";
else if ( aHypType == "SegmentLengthAroundVertex") else if ( aHypType == "SegmentLengthAroundVertex")
aHelpFileName = "segments_around_vertex_algo_page.html"; aHelpFileName = "segments_around_vertex_algo_page.html";
else if ( aHypType == "QuadrangleParams")
aHelpFileName = "a2d_meshing_hypo_page.html#hypo_quad_params_anchor";
return aHelpFileName; return aHelpFileName;
} }

3
src/SMESHGUI/SMESHGUI_VTKUtils.cxx
View File

@ -712,7 +712,8 @@ namespace SMESH
_PTR(Study) aDocument = aStudy->studyDS(); _PTR(Study) aDocument = aStudy->studyDS();
// Pass non-visual objects (hypotheses, etc.), return true in this case // Pass non-visual objects (hypotheses, etc.), return true in this case
CORBA::Long anId = aDocument->StudyId(); CORBA::Long anId = aDocument->StudyId();
if (TVisualObjPtr aVisualObj = GetVisualObj(anId,theEntry)) TVisualObjPtr aVisualObj;
if ( (aVisualObj = GetVisualObj(anId,theEntry)) && aVisualObj->IsValid())
{ {
if ((anActor = CreateActor(aDocument,theEntry,true))) { if ((anActor = CreateActor(aDocument,theEntry,true))) {
bool needFitAll = noSmeshActors(theWnd); // fit for the first object only bool needFitAll = noSmeshActors(theWnd); // fit for the first object only

62
src/SMESH_I/SMESH_2smeshpy.cxx
View File

@ -121,7 +121,7 @@ namespace {
TCollection_AsciiString TCollection_AsciiString
SMESH_2smeshpy::ConvertScript(const TCollection_AsciiString& theScript, SMESH_2smeshpy::ConvertScript(const TCollection_AsciiString& theScript,
Resource_DataMapOfAsciiStringAsciiString& theEntry2AccessorMethod, Resource_DataMapOfAsciiStringAsciiString& theEntry2AccessorMethod,
Resource_DataMapOfAsciiStringAsciiString& theObjectNames) Resource_DataMapOfAsciiStringAsciiString& theObjectNames)
{ {
theGen = new _pyGen( theEntry2AccessorMethod, theObjectNames ); theGen = new _pyGen( theEntry2AccessorMethod, theObjectNames );
@ -196,7 +196,7 @@ SMESH_2smeshpy::ConvertScript(const TCollection_AsciiString& theScript,
//================================================================================ //================================================================================
_pyGen::_pyGen(Resource_DataMapOfAsciiStringAsciiString& theEntry2AccessorMethod, _pyGen::_pyGen(Resource_DataMapOfAsciiStringAsciiString& theEntry2AccessorMethod,
Resource_DataMapOfAsciiStringAsciiString& theObjectNames) Resource_DataMapOfAsciiStringAsciiString& theObjectNames)
: _pyObject( new _pyCommand( TPythonDump::SMESHGenName(), 0 )), : _pyObject( new _pyCommand( TPythonDump::SMESHGenName(), 0 )),
myID2AccessorMethod( theEntry2AccessorMethod ), myID2AccessorMethod( theEntry2AccessorMethod ),
myObjectNames( theObjectNames ) myObjectNames( theObjectNames )
@ -541,7 +541,7 @@ Handle(_pyHypothesis) _pyGen::FindAlgo( const _pyID& theGeom, const _pyID& theMe
if ( !hyp->IsNull() && if ( !hyp->IsNull() &&
(*hyp)->IsAlgo() && (*hyp)->IsAlgo() &&
theHypothesis->CanBeCreatedBy( (*hyp)->GetAlgoType() ) && theHypothesis->CanBeCreatedBy( (*hyp)->GetAlgoType() ) &&
(*hyp)->GetGeom() == theGeom && (*hyp)->GetGeom() == theGeom &&
(*hyp)->GetMesh() == theMesh ) (*hyp)->GetMesh() == theMesh )
return *hyp; return *hyp;
return 0; return 0;
@ -624,8 +624,8 @@ void _pyGen::SetCommandBefore( Handle(_pyCommand) theCmd, Handle(_pyCommand) the
//================================================================================ //================================================================================
void _pyGen::setNeighbourCommand( Handle(_pyCommand)& theCmd, void _pyGen::setNeighbourCommand( Handle(_pyCommand)& theCmd,
Handle(_pyCommand)& theOtherCmd, Handle(_pyCommand)& theOtherCmd,
const bool theIsAfter ) const bool theIsAfter )
{ {
list< Handle(_pyCommand) >::iterator pos; list< Handle(_pyCommand) >::iterator pos;
pos = find( myCommands.begin(), myCommands.end(), theCmd ); pos = find( myCommands.begin(), myCommands.end(), theCmd );
@ -680,8 +680,8 @@ _pyID _pyGen::GenerateNewID( const _pyID& theID )
while ( myObjectNames.IsBound( aNewID ) ); while ( myObjectNames.IsBound( aNewID ) );
myObjectNames.Bind( aNewID, myObjectNames.IsBound( theID ) myObjectNames.Bind( aNewID, myObjectNames.IsBound( theID )
? (myObjectNames.Find( theID ) + _pyID( "_" ) + _pyID( index-1 )) ? (myObjectNames.Find( theID ) + _pyID( "_" ) + _pyID( index-1 ))
: _pyID( "A" ) + aNewID ); : _pyID( "A" ) + aNewID );
return aNewID; return aNewID;
} }
@ -952,21 +952,21 @@ void _pyMesh::Flush()
if ( algo->IsWrapped() ) { if ( algo->IsWrapped() ) {
_pyID localAlgoID = theGen->GenerateNewID( algoID ); _pyID localAlgoID = theGen->GenerateNewID( algoID );
TCollection_AsciiString aNewCmdStr = localAlgoID + TCollection_AsciiString aNewCmdStr = localAlgoID +
TCollection_AsciiString( " = " ) + theGen->GetID() + TCollection_AsciiString( " = " ) + theGen->GetID() +
TCollection_AsciiString( ".CreateHypothesis( \"" ) + algo->GetAlgoType() + TCollection_AsciiString( ".CreateHypothesis( \"" ) + algo->GetAlgoType() +
TCollection_AsciiString( "\" )" ); TCollection_AsciiString( "\" )" );
Handle(_pyCommand) newCmd = theGen->AddCommand( aNewCmdStr ); Handle(_pyCommand) newCmd = theGen->AddCommand( aNewCmdStr );
Handle(_pyAlgorithm) newAlgo = Handle(_pyAlgorithm)::DownCast(theGen->FindHyp( localAlgoID )); Handle(_pyAlgorithm) newAlgo = Handle(_pyAlgorithm)::DownCast(theGen->FindHyp( localAlgoID ));
if ( !newAlgo.IsNull() ) { if ( !newAlgo.IsNull() ) {
newAlgo->Assign( algo, this->GetID() ); newAlgo->Assign( algo, this->GetID() );
newAlgo->SetCreationCmd( newCmd ); newAlgo->SetCreationCmd( newCmd );
algo = newAlgo; algo = newAlgo;
// set algorithm creation // set algorithm creation
theGen->SetCommandBefore( newCmd, addCmd ); theGen->SetCommandBefore( newCmd, addCmd );
} }
else else
newCmd->Clear(); newCmd->Clear();
} }
_pyID geom = addCmd->GetArg( 1 ); _pyID geom = addCmd->GetArg( 1 );
bool isLocalAlgo = ( geom != GetGeom() ); bool isLocalAlgo = ( geom != GetGeom() );
@ -982,14 +982,14 @@ void _pyMesh::Flush()
addCmd->SetArg( addCmd->GetNbArgs() + 1, addCmd->SetArg( addCmd->GetNbArgs() + 1,
TCollection_AsciiString( "geom=" ) + geom ); TCollection_AsciiString( "geom=" ) + geom );
// sm = mesh.GetSubMesh(geom, name) --> sm = ALGO.GetSubMesh() // sm = mesh.GetSubMesh(geom, name) --> sm = ALGO.GetSubMesh()
list < Handle(_pySubMesh) >::iterator smIt; list < Handle(_pySubMesh) >::iterator smIt;
for ( smIt = mySubmeshes.begin(); smIt != mySubmeshes.end(); ++smIt ) { for ( smIt = mySubmeshes.begin(); smIt != mySubmeshes.end(); ++smIt ) {
Handle(_pySubMesh) subMesh = *smIt; Handle(_pySubMesh) subMesh = *smIt;
Handle(_pyCommand) subCmd = subMesh->GetCreationCmd(); Handle(_pyCommand) subCmd = subMesh->GetCreationCmd();
if ( geom == subCmd->GetArg( 1 )) { if ( geom == subCmd->GetArg( 1 )) {
subCmd->SetObject( algo->GetID() ); subCmd->SetObject( algo->GetID() );
subCmd->RemoveArgs(); subCmd->RemoveArgs();
subMesh->SetCreator( algo ); subMesh->SetCreator( algo );
} }
} }
} }
@ -1271,11 +1271,11 @@ Handle(_pyHypothesis) _pyHypothesis::NewHypothesis( const Handle(_pyCommand)& th
} }
else if ( hypType == "QuadranglePreference" ) { else if ( hypType == "QuadranglePreference" ) {
hyp->SetConvMethodAndType( "QuadranglePreference", "Quadrangle_2D"); hyp->SetConvMethodAndType( "QuadranglePreference", "Quadrangle_2D");
hyp->SetConvMethodAndType( "QuadranglePreference", "NETGEN_2D_ONLY"); hyp->SetConvMethodAndType( "SetQuadAllowed", "NETGEN_2D_ONLY");
} }
else if ( hypType == "TrianglePreference" ) { else if ( hypType == "TrianglePreference" ) {
hyp->SetConvMethodAndType( "TrianglePreference", "Quadrangle_2D"); hyp->SetConvMethodAndType( "TrianglePreference", "Quadrangle_2D");
} }
// BLSURF ---------- // BLSURF ----------
else if ( hypType == "BLSURF" ) { else if ( hypType == "BLSURF" ) {
algo->SetConvMethodAndType( "Triangle", hypType.ToCString()); algo->SetConvMethodAndType( "Triangle", hypType.ToCString());
@ -1532,7 +1532,7 @@ void _pyHypothesis::ClearAllCommands()
//================================================================================ //================================================================================
void _pyHypothesis::Assign( const Handle(_pyHypothesis)& theOther, void _pyHypothesis::Assign( const Handle(_pyHypothesis)& theOther,
const _pyID& theMesh ) const _pyID& theMesh )
{ {
myIsWrapped = false; myIsWrapped = false;
myMesh = theMesh; myMesh = theMesh;
@ -1995,15 +1995,15 @@ const TCollection_AsciiString & _pyCommand::GetObject()
int nb1 = 0; // number of ' character at the left of = int nb1 = 0; // number of ' character at the left of =
int nb2 = 0; // number of " character at the left of = int nb2 = 0; // number of " character at the left of =
for ( int i = 1; i < begPos-1; i++ ) { for ( int i = 1; i < begPos-1; i++ ) {
if ( myString.Value( i )=='\'' ) if ( myString.Value( i )=='\'' )
nb1 += 1; nb1 += 1;
else if ( myString.Value( i )=='"' ) else if ( myString.Value( i )=='"' )
nb2 += 1; nb2 += 1;
} }
// if number of ' or " is not divisible by 2, // if number of ' or " is not divisible by 2,
// then get an object at the start of the command // then get an object at the start of the command
if ( nb1 % 2 != 0 || nb2 % 2 != 0 ) if ( nb1 % 2 != 0 || nb2 % 2 != 0 )
begPos = 1; begPos = 1;
} }
myObj = GetWord( myString, begPos, true ); myObj = GetWord( myString, begPos, true );
// check if object is complex, // check if object is complex,
@ -2073,16 +2073,16 @@ const TCollection_AsciiString & _pyCommand::GetArg( int index )
while ( begPos != EMPTY ) { while ( begPos != EMPTY ) {
begPos += prevLen; begPos += prevLen;
if( myString.Value( begPos ) == '(' ) if( myString.Value( begPos ) == '(' )
nbNestings++; nbNestings++;
// check if we are looking at the closing parenthesis // check if we are looking at the closing parenthesis
while ( begPos <= Length() && isspace( myString.Value( begPos ))) while ( begPos <= Length() && isspace( myString.Value( begPos )))
++begPos; ++begPos;
if ( begPos > Length() ) if ( begPos > Length() )
break; break;
if ( myString.Value( begPos ) == ')' ) { if ( myString.Value( begPos ) == ')' ) {
nbNestings--; nbNestings--;
if( nbNestings == 0 ) if( nbNestings == 0 )
break; break;
} }
myArgs.Append( GetWord( myString, begPos, true, true )); myArgs.Append( GetWord( myString, begPos, true, true ));
SetBegPos( ARG1_IND + i, begPos ); SetBegPos( ARG1_IND + i, begPos );

2
src/SMESH_I/SMESH_2smeshpy.hxx
View File

@ -327,7 +327,7 @@ public:
void Process( const Handle(_pyCommand)& theCommand); void Process( const Handle(_pyCommand)& theCommand);
void Flush(); void Flush();
virtual void Assign( const Handle(_pyHypothesis)& theOther, virtual void Assign( const Handle(_pyHypothesis)& theOther,
const _pyID& theMesh ); const _pyID& theMesh );
DEFINE_STANDARD_RTTI (_pyHypothesis) DEFINE_STANDARD_RTTI (_pyHypothesis)
}; };

12
src/SMESH_I/SMESH_DumpPython.cxx
View File

@ -66,8 +66,8 @@ namespace SMESH
TCollection_AsciiString aCollection(Standard_CString(aString.c_str())); TCollection_AsciiString aCollection(Standard_CString(aString.c_str()));
SALOMEDS::Study_ptr aStudy = aSMESHGen->GetCurrentStudy(); SALOMEDS::Study_ptr aStudy = aSMESHGen->GetCurrentStudy();
if(!aStudy->_is_nil() && !aCollection.IsEmpty()){ if(!aStudy->_is_nil() && !aCollection.IsEmpty()){
aSMESHGen->AddToPythonScript(aStudy->StudyId(),aCollection); aSMESHGen->AddToPythonScript(aStudy->StudyId(),aCollection);
if(MYDEBUG) MESSAGE(aString); if(MYDEBUG) MESSAGE(aString);
} }
} }
} }
@ -587,8 +587,8 @@ Handle(TColStd_HSequenceOfInteger) FindEntries (TCollection_AsciiString& theStri
isFound = Standard_False; isFound = Standard_False;
while((j < aLen) && ( isdigit(c) || c == ':' )) { //Check if it is an entry while((j < aLen) && ( isdigit(c) || c == ':' )) { //Check if it is an entry
c = (int)arr[j++]; c = (int)arr[j++];
if(c == ':') isFound = Standard_True; if(c == ':') isFound = Standard_True;
} }
if (isFound) { if (isFound) {
@ -786,7 +786,7 @@ TCollection_AsciiString SMESH_Gen_i::DumpPython_impl
} }
// set initial part of aSript // set initial part of aSript
TCollection_AsciiString initPart = "import salome, SMESH\n"; TCollection_AsciiString initPart = "import salome, SMESH, SALOMEDS\n";
initPart += helper + "import " + aSmeshpy + "\n\n"; initPart += helper + "import " + aSmeshpy + "\n\n";
if ( importGeom ) if ( importGeom )
{ {
@ -821,7 +821,7 @@ TCollection_AsciiString SMESH_Gen_i::DumpPython_impl
if( !CORBA::is_nil(aGroup) ) if( !CORBA::is_nil(aGroup) )
{ {
SALOMEDS::Color aColor = aGroup->GetColor(); SALOMEDS::Color aColor = aGroup->GetColor();
if ( aColor.R > 0 || aColor.G > 0 || aColor.B > 0 ) if ( aColor.R >= 0 || aColor.G >= 0 || aColor.B >= 0 )
{ {
CORBA::String_var anEntry = aSObj->GetID(); CORBA::String_var anEntry = aSObj->GetID();
anUpdatedScript += SMESH_Comment("\n\t") anUpdatedScript += SMESH_Comment("\n\t")

12
src/SMESH_I/SMESH_Filter_i.cxx
View File

@ -2436,13 +2436,13 @@ CORBA::Boolean Filter_i::SetCriteria( const SMESH::Filter::Criteria& theCriteria
pd << "aCriterion = SMESH.Filter.Criterion(" << aCriterion << "," << aCompare pd << "aCriterion = SMESH.Filter.Criterion(" << aCriterion << "," << aCompare
<< "," << aThreshold << ",'" << aThresholdStr; << "," << aThreshold << ",'" << aThresholdStr;
if (aThresholdID && strlen(aThresholdID)) if (aThresholdID && strlen(aThresholdID))
//pd << "',salome.ObjectToID(" << aThresholdID //pd << "',salome.ObjectToID(" << aThresholdID
pd << "','" << aThresholdID pd << "','" << aThresholdID
<< "'," << aUnary << "," << aBinary << "," << aTolerance << "'," << aUnary << "," << aBinary << "," << aTolerance
<< "," << aTypeOfElem << "," << aPrecision << ")"; << "," << aTypeOfElem << "," << aPrecision << ")";
else else
pd << "',''," << aUnary << "," << aBinary << "," << aTolerance pd << "',''," << aUnary << "," << aBinary << "," << aTolerance
<< "," << aTypeOfElem << "," << aPrecision << ")"; << "," << aTypeOfElem << "," << aPrecision << ")";
} }
SMESH::Predicate_ptr aPredicate = SMESH::Predicate::_nil(); SMESH::Predicate_ptr aPredicate = SMESH::Predicate::_nil();
@ -2534,7 +2534,7 @@ CORBA::Boolean Filter_i::SetCriteria( const SMESH::Filter::Criteria& theCriteria
{ {
SMESH::LyingOnGeom_ptr tmpPred = aFilterMgr->CreateLyingOnGeom(); SMESH::LyingOnGeom_ptr tmpPred = aFilterMgr->CreateLyingOnGeom();
tmpPred->SetElementType( aTypeOfElem ); tmpPred->SetElementType( aTypeOfElem );
tmpPred->SetShape( aThresholdID, aThresholdStr ); tmpPred->SetShape( aThresholdID, aThresholdStr );
tmpPred->SetTolerance( aTolerance ); tmpPred->SetTolerance( aTolerance );
aPredicate = tmpPred; aPredicate = tmpPred;
} }

98
src/SMESH_I/SMESH_Filter_i.hxx
View File

@ -107,10 +107,10 @@ namespace SMESH
double GetTolerance(); double GetTolerance();
virtual bool Contains( const SMESHDS_Mesh* theMeshDS, virtual bool Contains( const SMESHDS_Mesh* theMeshDS,
const TopoDS_Shape& theShape, const TopoDS_Shape& theShape,
const SMDS_MeshElement* theElem, const SMDS_MeshElement* theElem,
TopAbs_ShapeEnum theFindShapeEnum, TopAbs_ShapeEnum theFindShapeEnum,
TopAbs_ShapeEnum theAvoidShapeEnum = TopAbs_SHAPE ); TopAbs_ShapeEnum theAvoidShapeEnum = TopAbs_SHAPE );
private: private:
virtual void init(); virtual void init();
@ -133,7 +133,7 @@ namespace SMESH
Description : An abstact class for all functors Description : An abstact class for all functors
*/ */
class SMESH_I_EXPORT Functor_i: public virtual POA_SMESH::Functor, class SMESH_I_EXPORT Functor_i: public virtual POA_SMESH::Functor,
public virtual SALOME::GenericObj_i public virtual SALOME::GenericObj_i
{ {
public: public:
void SetMesh( SMESH_Mesh_ptr theMesh ); void SetMesh( SMESH_Mesh_ptr theMesh );
@ -152,7 +152,7 @@ namespace SMESH
Description : Base class for numerical functors Description : Base class for numerical functors
*/ */
class SMESH_I_EXPORT NumericalFunctor_i: public virtual POA_SMESH::NumericalFunctor, class SMESH_I_EXPORT NumericalFunctor_i: public virtual POA_SMESH::NumericalFunctor,
public virtual Functor_i public virtual Functor_i
{ {
public: public:
CORBA::Double GetValue( CORBA::Long theElementId ); CORBA::Double GetValue( CORBA::Long theElementId );
@ -170,7 +170,7 @@ namespace SMESH
Description : Functor for calculation of minimum angle Description : Functor for calculation of minimum angle
*/ */
class SMESH_I_EXPORT MinimumAngle_i: public virtual POA_SMESH::MinimumAngle, class SMESH_I_EXPORT MinimumAngle_i: public virtual POA_SMESH::MinimumAngle,
public virtual NumericalFunctor_i public virtual NumericalFunctor_i
{ {
public: public:
MinimumAngle_i(); MinimumAngle_i();
@ -183,7 +183,7 @@ namespace SMESH
Description : Functor for calculating aspect ratio Description : Functor for calculating aspect ratio
*/ */
class SMESH_I_EXPORT AspectRatio_i: public virtual POA_SMESH::AspectRatio, class SMESH_I_EXPORT AspectRatio_i: public virtual POA_SMESH::AspectRatio,
public virtual NumericalFunctor_i public virtual NumericalFunctor_i
{ {
public: public:
AspectRatio_i(); AspectRatio_i();
@ -196,7 +196,7 @@ namespace SMESH
Description : Functor for calculating aspect ratio for 3D Description : Functor for calculating aspect ratio for 3D
*/ */
class SMESH_I_EXPORT AspectRatio3D_i: public virtual POA_SMESH::AspectRatio3D, class SMESH_I_EXPORT AspectRatio3D_i: public virtual POA_SMESH::AspectRatio3D,
public virtual NumericalFunctor_i public virtual NumericalFunctor_i
{ {
public: public:
AspectRatio3D_i(); AspectRatio3D_i();
@ -209,7 +209,7 @@ namespace SMESH
Description : Functor for calculating warping Description : Functor for calculating warping
*/ */
class SMESH_I_EXPORT Warping_i: public virtual POA_SMESH::Warping, class SMESH_I_EXPORT Warping_i: public virtual POA_SMESH::Warping,
public virtual NumericalFunctor_i public virtual NumericalFunctor_i
{ {
public: public:
Warping_i(); Warping_i();
@ -222,7 +222,7 @@ namespace SMESH
Description : Functor for calculating taper Description : Functor for calculating taper
*/ */
class SMESH_I_EXPORT Taper_i: public virtual POA_SMESH::Taper, class SMESH_I_EXPORT Taper_i: public virtual POA_SMESH::Taper,
public virtual NumericalFunctor_i public virtual NumericalFunctor_i
{ {
public: public:
Taper_i(); Taper_i();
@ -235,7 +235,7 @@ namespace SMESH
Description : Functor for calculating skew in degrees Description : Functor for calculating skew in degrees
*/ */
class SMESH_I_EXPORT Skew_i: public virtual POA_SMESH::Skew, class SMESH_I_EXPORT Skew_i: public virtual POA_SMESH::Skew,
public virtual NumericalFunctor_i public virtual NumericalFunctor_i
{ {
public: public:
Skew_i(); Skew_i();
@ -248,7 +248,7 @@ namespace SMESH
Description : Functor for calculating area Description : Functor for calculating area
*/ */
class SMESH_I_EXPORT Area_i: public virtual POA_SMESH::Area, class SMESH_I_EXPORT Area_i: public virtual POA_SMESH::Area,
public virtual NumericalFunctor_i public virtual NumericalFunctor_i
{ {
public: public:
Area_i(); Area_i();
@ -274,7 +274,7 @@ namespace SMESH
Description : Functor for calculating length of edge Description : Functor for calculating length of edge
*/ */
class SMESH_I_EXPORT Length_i: public virtual POA_SMESH::Length, class SMESH_I_EXPORT Length_i: public virtual POA_SMESH::Length,
public virtual NumericalFunctor_i public virtual NumericalFunctor_i
{ {
public: public:
Length_i(); Length_i();
@ -286,7 +286,7 @@ namespace SMESH
Description : Functor for calculating length of edge Description : Functor for calculating length of edge
*/ */
class SMESH_I_EXPORT Length2D_i: public virtual POA_SMESH::Length2D, class SMESH_I_EXPORT Length2D_i: public virtual POA_SMESH::Length2D,
public virtual NumericalFunctor_i public virtual NumericalFunctor_i
{ {
public: public:
Length2D_i(); Length2D_i();
@ -303,7 +303,7 @@ namespace SMESH
Description : Functor for calculating number of faces conneted to the edge Description : Functor for calculating number of faces conneted to the edge
*/ */
class SMESH_I_EXPORT MultiConnection_i: public virtual POA_SMESH::MultiConnection, class SMESH_I_EXPORT MultiConnection_i: public virtual POA_SMESH::MultiConnection,
public virtual NumericalFunctor_i public virtual NumericalFunctor_i
{ {
public: public:
MultiConnection_i(); MultiConnection_i();
@ -315,7 +315,7 @@ namespace SMESH
Description : Functor for calculating number of faces conneted to the edge Description : Functor for calculating number of faces conneted to the edge
*/ */
class SMESH_I_EXPORT MultiConnection2D_i: public virtual POA_SMESH::MultiConnection2D, class SMESH_I_EXPORT MultiConnection2D_i: public virtual POA_SMESH::MultiConnection2D,
public virtual NumericalFunctor_i public virtual NumericalFunctor_i
{ {
public: public:
MultiConnection2D_i(); MultiConnection2D_i();
@ -335,7 +335,7 @@ namespace SMESH
Description : Base class for all predicates Description : Base class for all predicates
*/ */
class SMESH_I_EXPORT Predicate_i: public virtual POA_SMESH::Predicate, class SMESH_I_EXPORT Predicate_i: public virtual POA_SMESH::Predicate,
public virtual Functor_i public virtual Functor_i
{ {
public: public:
CORBA::Boolean IsSatisfy( CORBA::Long theElementId ); CORBA::Boolean IsSatisfy( CORBA::Long theElementId );
@ -352,7 +352,7 @@ namespace SMESH
the point of view of MED convention the point of view of MED convention
*/ */
class SMESH_I_EXPORT BadOrientedVolume_i: public virtual POA_SMESH::BadOrientedVolume, class SMESH_I_EXPORT BadOrientedVolume_i: public virtual POA_SMESH::BadOrientedVolume,
public virtual Predicate_i public virtual Predicate_i
{ {
public: public:
BadOrientedVolume_i(); BadOrientedVolume_i();
@ -364,7 +364,7 @@ namespace SMESH
Description : Predicate for selection on geometrical support Description : Predicate for selection on geometrical support
*/ */
class SMESH_I_EXPORT BelongToGeom_i: public virtual POA_SMESH::BelongToGeom, class SMESH_I_EXPORT BelongToGeom_i: public virtual POA_SMESH::BelongToGeom,
public virtual Predicate_i public virtual Predicate_i
{ {
public: public:
BelongToGeom_i(); BelongToGeom_i();
@ -395,7 +395,7 @@ namespace SMESH
Description : Verify whether mesh element lie in pointed Geom planar object Description : Verify whether mesh element lie in pointed Geom planar object
*/ */
class SMESH_I_EXPORT BelongToSurface_i: public virtual POA_SMESH::BelongToSurface, class SMESH_I_EXPORT BelongToSurface_i: public virtual POA_SMESH::BelongToSurface,
public virtual Predicate_i public virtual Predicate_i
{ {
public: public:
BelongToSurface_i( const Handle(Standard_Type)& ); BelongToSurface_i( const Handle(Standard_Type)& );
@ -426,7 +426,7 @@ namespace SMESH
Description : Verify whether mesh element lie in pointed Geom planar object Description : Verify whether mesh element lie in pointed Geom planar object
*/ */
class SMESH_I_EXPORT BelongToPlane_i: public virtual POA_SMESH::BelongToPlane, class SMESH_I_EXPORT BelongToPlane_i: public virtual POA_SMESH::BelongToPlane,
public virtual BelongToSurface_i public virtual BelongToSurface_i
{ {
public: public:
BelongToPlane_i(); BelongToPlane_i();
@ -439,7 +439,7 @@ namespace SMESH
Description : Verify whether mesh element lie in pointed Geom cylindrical object Description : Verify whether mesh element lie in pointed Geom cylindrical object
*/ */
class SMESH_I_EXPORT BelongToCylinder_i: public virtual POA_SMESH::BelongToCylinder, class SMESH_I_EXPORT BelongToCylinder_i: public virtual POA_SMESH::BelongToCylinder,
public virtual BelongToSurface_i public virtual BelongToSurface_i
{ {
public: public:
BelongToCylinder_i(); BelongToCylinder_i();
@ -465,7 +465,7 @@ namespace SMESH
Description : Predicate for selection on geometrical support(lying or partially lying) Description : Predicate for selection on geometrical support(lying or partially lying)
*/ */
class SMESH_I_EXPORT LyingOnGeom_i: public virtual POA_SMESH::LyingOnGeom, class SMESH_I_EXPORT LyingOnGeom_i: public virtual POA_SMESH::LyingOnGeom,
public virtual Predicate_i public virtual Predicate_i
{ {
public: public:
LyingOnGeom_i(); LyingOnGeom_i();
@ -496,7 +496,7 @@ namespace SMESH
Description : Predicate for free borders Description : Predicate for free borders
*/ */
class SMESH_I_EXPORT FreeBorders_i: public virtual POA_SMESH::FreeBorders, class SMESH_I_EXPORT FreeBorders_i: public virtual POA_SMESH::FreeBorders,
public virtual Predicate_i public virtual Predicate_i
{ {
public: public:
FreeBorders_i(); FreeBorders_i();
@ -509,7 +509,7 @@ namespace SMESH
Description : Predicate for free edges Description : Predicate for free edges
*/ */
class SMESH_I_EXPORT FreeEdges_i: public virtual POA_SMESH::FreeEdges, class SMESH_I_EXPORT FreeEdges_i: public virtual POA_SMESH::FreeEdges,
public virtual Predicate_i public virtual Predicate_i
{ {
public: public:
FreeEdges_i(); FreeEdges_i();
@ -526,7 +526,7 @@ namespace SMESH
Description : Predicate for free faces Description : Predicate for free faces
*/ */
class SMESH_I_EXPORT FreeFaces_i: public virtual POA_SMESH::FreeFaces, class SMESH_I_EXPORT FreeFaces_i: public virtual POA_SMESH::FreeFaces,
public virtual Predicate_i public virtual Predicate_i
{ {
public: public:
FreeFaces_i(); FreeFaces_i();
@ -539,7 +539,7 @@ namespace SMESH
Description : Predicate for free nodes Description : Predicate for free nodes
*/ */
class SMESH_I_EXPORT FreeNodes_i: public virtual POA_SMESH::FreeNodes, class SMESH_I_EXPORT FreeNodes_i: public virtual POA_SMESH::FreeNodes,
public virtual Predicate_i public virtual Predicate_i
{ {
public: public:
FreeNodes_i(); FreeNodes_i();
@ -552,7 +552,7 @@ namespace SMESH
Description : Predicate for Range of Ids Description : Predicate for Range of Ids
*/ */
class SMESH_I_EXPORT RangeOfIds_i: public virtual POA_SMESH::RangeOfIds, class SMESH_I_EXPORT RangeOfIds_i: public virtual POA_SMESH::RangeOfIds,
public virtual Predicate_i public virtual Predicate_i
{ {
public: public:
RangeOfIds_i(); RangeOfIds_i();
@ -572,7 +572,7 @@ namespace SMESH
Description : Verify whether a mesh element is linear Description : Verify whether a mesh element is linear
*/ */
class SMESH_I_EXPORT LinearOrQuadratic_i: public virtual POA_SMESH::LinearOrQuadratic, class SMESH_I_EXPORT LinearOrQuadratic_i: public virtual POA_SMESH::LinearOrQuadratic,
public virtual Predicate_i public virtual Predicate_i
{ {
public: public:
LinearOrQuadratic_i(); LinearOrQuadratic_i();
@ -588,7 +588,7 @@ namespace SMESH
Description : Functor for check color of group to whic mesh element belongs to Description : Functor for check color of group to whic mesh element belongs to
*/ */
class SMESH_I_EXPORT GroupColor_i: public virtual POA_SMESH::GroupColor, class SMESH_I_EXPORT GroupColor_i: public virtual POA_SMESH::GroupColor,
public virtual Predicate_i public virtual Predicate_i
{ {
public: public:
GroupColor_i(); GroupColor_i();
@ -607,7 +607,7 @@ namespace SMESH
Description : Functor for check element geometry type Description : Functor for check element geometry type
*/ */
class SMESH_I_EXPORT ElemGeomType_i: public virtual POA_SMESH::ElemGeomType, class SMESH_I_EXPORT ElemGeomType_i: public virtual POA_SMESH::ElemGeomType,
public virtual Predicate_i public virtual Predicate_i
{ {
public: public:
ElemGeomType_i(); ElemGeomType_i();
@ -626,7 +626,7 @@ namespace SMESH
Description : Base class for comparators Description : Base class for comparators
*/ */
class SMESH_I_EXPORT Comparator_i: public virtual POA_SMESH::Comparator, class SMESH_I_EXPORT Comparator_i: public virtual POA_SMESH::Comparator,
public virtual Predicate_i public virtual Predicate_i
{ {
public: public:
virtual ~Comparator_i(); virtual ~Comparator_i();
@ -651,7 +651,7 @@ namespace SMESH
Description : Comparator "<" Description : Comparator "<"
*/ */
class SMESH_I_EXPORT LessThan_i: public virtual POA_SMESH::LessThan, class SMESH_I_EXPORT LessThan_i: public virtual POA_SMESH::LessThan,
public virtual Comparator_i public virtual Comparator_i
{ {
public: public:
LessThan_i(); LessThan_i();
@ -664,7 +664,7 @@ namespace SMESH
Description : Comparator ">" Description : Comparator ">"
*/ */
class SMESH_I_EXPORT MoreThan_i: public virtual POA_SMESH::MoreThan, class SMESH_I_EXPORT MoreThan_i: public virtual POA_SMESH::MoreThan,
public virtual Comparator_i public virtual Comparator_i
{ {
public: public:
MoreThan_i(); MoreThan_i();
@ -677,7 +677,7 @@ namespace SMESH
Description : Comparator "=" Description : Comparator "="
*/ */
class SMESH_I_EXPORT EqualTo_i: public virtual POA_SMESH::EqualTo, class SMESH_I_EXPORT EqualTo_i: public virtual POA_SMESH::EqualTo,
public virtual Comparator_i public virtual Comparator_i
{ {
public: public:
EqualTo_i(); EqualTo_i();
@ -695,7 +695,7 @@ namespace SMESH
Description : Logical NOT predicate Description : Logical NOT predicate
*/ */
class SMESH_I_EXPORT LogicalNOT_i: public virtual POA_SMESH::LogicalNOT, class SMESH_I_EXPORT LogicalNOT_i: public virtual POA_SMESH::LogicalNOT,
public virtual Predicate_i public virtual Predicate_i
{ {
public: public:
LogicalNOT_i(); LogicalNOT_i();
@ -716,7 +716,7 @@ namespace SMESH
Description : Base class for binary logical predicate Description : Base class for binary logical predicate
*/ */
class SMESH_I_EXPORT LogicalBinary_i: public virtual POA_SMESH::LogicalBinary, class SMESH_I_EXPORT LogicalBinary_i: public virtual POA_SMESH::LogicalBinary,
public virtual Predicate_i public virtual Predicate_i
{ {
public: public:
virtual ~LogicalBinary_i(); virtual ~LogicalBinary_i();
@ -742,7 +742,7 @@ namespace SMESH
Description : Logical AND Description : Logical AND
*/ */
class SMESH_I_EXPORT LogicalAND_i: public virtual POA_SMESH::LogicalAND, class SMESH_I_EXPORT LogicalAND_i: public virtual POA_SMESH::LogicalAND,
public virtual LogicalBinary_i public virtual LogicalBinary_i
{ {
public: public:
LogicalAND_i(); LogicalAND_i();
@ -755,7 +755,7 @@ namespace SMESH
Description : Logical OR Description : Logical OR
*/ */
class SMESH_I_EXPORT LogicalOR_i: public virtual POA_SMESH::LogicalOR, class SMESH_I_EXPORT LogicalOR_i: public virtual POA_SMESH::LogicalOR,
public virtual LogicalBinary_i public virtual LogicalBinary_i
{ {
public: public:
LogicalOR_i(); LogicalOR_i();
@ -767,7 +767,7 @@ namespace SMESH
FILTER FILTER
*/ */
class SMESH_I_EXPORT Filter_i: public virtual POA_SMESH::Filter, class SMESH_I_EXPORT Filter_i: public virtual POA_SMESH::Filter,
public virtual SALOME::GenericObj_i public virtual SALOME::GenericObj_i
{ {
public: public:
Filter_i(); Filter_i();
@ -792,13 +792,13 @@ namespace SMESH
static static
void void
GetElementsId( Predicate_i*, GetElementsId( Predicate_i*,
const SMDS_Mesh*, const SMDS_Mesh*,
Controls::Filter::TIdSequence& ); Controls::Filter::TIdSequence& );
static static
void void
GetElementsId( Predicate_i*, GetElementsId( Predicate_i*,
SMESH_Mesh_ptr, SMESH_Mesh_ptr,
Controls::Filter::TIdSequence& ); Controls::Filter::TIdSequence& );
virtual virtual
long_array* long_array*
@ -833,7 +833,7 @@ namespace SMESH
FILTER LIBRARY FILTER LIBRARY
*/ */
class SMESH_I_EXPORT FilterLibrary_i: public virtual POA_SMESH::FilterLibrary, class SMESH_I_EXPORT FilterLibrary_i: public virtual POA_SMESH::FilterLibrary,
public virtual SALOME::GenericObj_i public virtual SALOME::GenericObj_i
{ {
public: public:
FilterLibrary_i( const char* theFileName ); FilterLibrary_i( const char* theFileName );
@ -846,8 +846,8 @@ namespace SMESH
CORBA::Boolean AddEmpty( const char* theFilterName, ElementType theType ); CORBA::Boolean AddEmpty( const char* theFilterName, ElementType theType );
CORBA::Boolean Delete ( const char* theFilterName ); CORBA::Boolean Delete ( const char* theFilterName );
CORBA::Boolean Replace ( const char* theFilterName, CORBA::Boolean Replace ( const char* theFilterName,
const char* theNewName, const char* theNewName,
Filter_ptr theFilter ); Filter_ptr theFilter );
CORBA::Boolean Save(); CORBA::Boolean Save();
CORBA::Boolean SaveAs( const char* aFileName ); CORBA::Boolean SaveAs( const char* aFileName );
@ -871,7 +871,7 @@ namespace SMESH
*/ */
class SMESH_I_EXPORT FilterManager_i: public virtual POA_SMESH::FilterManager, class SMESH_I_EXPORT FilterManager_i: public virtual POA_SMESH::FilterManager,
public virtual SALOME::GenericObj_i public virtual SALOME::GenericObj_i
{ {
public: public:
FilterManager_i(); FilterManager_i();

21
src/SMESH_I/SMESH_Gen_i.cxx
View File

@ -1879,7 +1879,8 @@ SMESH_Gen_i::ConcatenateCommon(const SMESH::mesh_array& theMeshesArray,
typedef map< pair<string, SMESH::ElementType>, TListOfNewGroups > TGroupsMap; typedef map< pair<string, SMESH::ElementType>, TListOfNewGroups > TGroupsMap;
typedef std::set<SMESHDS_GroupBase*> TGroups; typedef std::set<SMESHDS_GroupBase*> TGroups;
TPythonDump aPythonDump; // prevent dump of called methods TPythonDump* pPythonDump = new TPythonDump;
TPythonDump& aPythonDump = *pPythonDump; // prevent dump of called methods
// create mesh // create mesh
SMESH::SMESH_Mesh_var aNewMesh = CreateEmptyMesh(); SMESH::SMESH_Mesh_var aNewMesh = CreateEmptyMesh();
@ -2147,6 +2148,24 @@ SMESH_Gen_i::ConcatenateCommon(const SMESH::mesh_array& theMeshesArray,
<< theMergeNodesAndElements << ", " << theMergeNodesAndElements << ", "
<< theMergeTolerance << ")"; << theMergeTolerance << ")";
delete pPythonDump; // enable python dump from GetGroups()
// 0020577: EDF 1164 SMESH: Bad dump of concatenate with create common groups
if ( !aNewMesh->_is_nil() )
{
SMESH::ListOfGroups_var groups = aNewMesh->GetGroups();
}
// IPAL21468 Change icon of compound because it need not be computed.
SALOMEDS::SObject_var aMeshSObj = ObjectToSObject( myCurrentStudy, aNewMesh );
if( !aMeshSObj->_is_nil() ) {
SALOMEDS::GenericAttribute_var anAttr;
SALOMEDS::StudyBuilder_var aBuilder = myCurrentStudy->NewBuilder();
anAttr = aBuilder->FindOrCreateAttribute( aMeshSObj,"AttributePixMap" );
SALOMEDS::AttributePixMap_var aPixmap = SALOMEDS::AttributePixMap::_narrow(anAttr);
aPixmap->SetPixMap("ICON_SMESH_TREE_MESH");
}
return aNewMesh._retn(); return aNewMesh._retn();
} }

78
src/SMESH_I/SMESH_Gen_i.hxx
View File

@ -176,7 +176,7 @@ public:
// ***************************************** // *****************************************
// Set a new Mesh object name // Set a new Mesh object name
void SetName(const char* theIOR, void SetName(const char* theIOR,
const char* theName); const char* theName);
//GEOM::GEOM_Gen_ptr SetGeomEngine( const char* containerLoc ); //GEOM::GEOM_Gen_ptr SetGeomEngine( const char* containerLoc );
void SetGeomEngine( GEOM::GEOM_Gen_ptr geomcompo ); void SetGeomEngine( GEOM::GEOM_Gen_ptr geomcompo );
@ -266,9 +266,9 @@ public:
* Return mesh preview structure * Return mesh preview structure
*/ */
SMESH::MeshPreviewStruct* Precompute( SMESH::SMESH_Mesh_ptr theMesh, SMESH::MeshPreviewStruct* Precompute( SMESH::SMESH_Mesh_ptr theMesh,
GEOM::GEOM_Object_ptr theSubObject, GEOM::GEOM_Object_ptr theSubObject,
SMESH::Dimension theDimension, SMESH::Dimension theDimension,
SMESH::long_array& theShapesId ) SMESH::long_array& theShapesId )
throw ( SALOME::SALOME_Exception ); throw ( SALOME::SALOME_Exception );
// Returns errors of hypotheses definintion // Returns errors of hypotheses definintion
@ -294,30 +294,30 @@ public:
// Return geometrical object the given element is built on. Don't publish it in study. // Return geometrical object the given element is built on. Don't publish it in study.
GEOM::GEOM_Object_ptr FindGeometryByMeshElement( SMESH::SMESH_Mesh_ptr theMesh, GEOM::GEOM_Object_ptr FindGeometryByMeshElement( SMESH::SMESH_Mesh_ptr theMesh,
CORBA::Long theElementID) CORBA::Long theElementID)
throw ( SALOME::SALOME_Exception ); throw ( SALOME::SALOME_Exception );
// Concatenate the given meshes into one mesh // Concatenate the given meshes into one mesh
SMESH::SMESH_Mesh_ptr ConcatenateCommon(const SMESH::mesh_array& theMeshesArray, SMESH::SMESH_Mesh_ptr ConcatenateCommon(const SMESH::mesh_array& theMeshesArray,
CORBA::Boolean theUniteIdenticalGroups, CORBA::Boolean theUniteIdenticalGroups,
CORBA::Boolean theMergeNodesAndElements, CORBA::Boolean theMergeNodesAndElements,
CORBA::Double theMergeTolerance, CORBA::Double theMergeTolerance,
CORBA::Boolean theCommonGroups) CORBA::Boolean theCommonGroups)
throw ( SALOME::SALOME_Exception ); throw ( SALOME::SALOME_Exception );
// Concatenate the given meshes into one mesh // Concatenate the given meshes into one mesh
SMESH::SMESH_Mesh_ptr Concatenate(const SMESH::mesh_array& theMeshesArray, SMESH::SMESH_Mesh_ptr Concatenate(const SMESH::mesh_array& theMeshesArray,
CORBA::Boolean theUniteIdenticalGroups, CORBA::Boolean theUniteIdenticalGroups,
CORBA::Boolean theMergeNodesAndElements, CORBA::Boolean theMergeNodesAndElements,
CORBA::Double theMergeTolerance) CORBA::Double theMergeTolerance)
throw ( SALOME::SALOME_Exception ); throw ( SALOME::SALOME_Exception );
// Concatenate the given meshes into one mesh // Concatenate the given meshes into one mesh
// Create the groups of all elements from initial meshes // Create the groups of all elements from initial meshes
SMESH::SMESH_Mesh_ptr ConcatenateWithGroups(const SMESH::mesh_array& theMeshesArray, SMESH::SMESH_Mesh_ptr ConcatenateWithGroups(const SMESH::mesh_array& theMeshesArray,
CORBA::Boolean theUniteIdenticalGroups, CORBA::Boolean theUniteIdenticalGroups,
CORBA::Boolean theMergeNodesAndElements, CORBA::Boolean theMergeNodesAndElements,
CORBA::Double theMergeTolerance) CORBA::Double theMergeTolerance)
throw ( SALOME::SALOME_Exception ); throw ( SALOME::SALOME_Exception );
// **************************************************** // ****************************************************
@ -326,22 +326,22 @@ public:
// Save SMESH data // Save SMESH data
SALOMEDS::TMPFile* Save( SALOMEDS::SComponent_ptr theComponent, SALOMEDS::TMPFile* Save( SALOMEDS::SComponent_ptr theComponent,
const char* theURL, const char* theURL,
bool isMultiFile ); bool isMultiFile );
// Load SMESH data // Load SMESH data
bool Load( SALOMEDS::SComponent_ptr theComponent, bool Load( SALOMEDS::SComponent_ptr theComponent,
const SALOMEDS::TMPFile& theStream, const SALOMEDS::TMPFile& theStream,
const char* theURL, const char* theURL,
bool isMultiFile ); bool isMultiFile );
// Save SMESH data in ASCII format // Save SMESH data in ASCII format
SALOMEDS::TMPFile* SaveASCII( SALOMEDS::SComponent_ptr theComponent, SALOMEDS::TMPFile* SaveASCII( SALOMEDS::SComponent_ptr theComponent,
const char* theURL, const char* theURL,
bool isMultiFile ); bool isMultiFile );
// Load SMESH data in ASCII format // Load SMESH data in ASCII format
bool LoadASCII( SALOMEDS::SComponent_ptr theComponent, bool LoadASCII( SALOMEDS::SComponent_ptr theComponent,
const SALOMEDS::TMPFile& theStream, const SALOMEDS::TMPFile& theStream,
const char* theURL, const char* theURL,
bool isMultiFile ); bool isMultiFile );
// Create filter manager // Create filter manager
SMESH::FilterManager_ptr CreateFilterManager(); SMESH::FilterManager_ptr CreateFilterManager();
@ -357,22 +357,22 @@ public:
// Transform data from transient form to persistent // Transform data from transient form to persistent
char* IORToLocalPersistentID( SALOMEDS::SObject_ptr theSObject, char* IORToLocalPersistentID( SALOMEDS::SObject_ptr theSObject,
const char* IORString, const char* IORString,
CORBA::Boolean isMultiFile, CORBA::Boolean isMultiFile,
CORBA::Boolean isASCII ); CORBA::Boolean isASCII );
// Transform data from persistent form to transient // Transform data from persistent form to transient
char* LocalPersistentIDToIOR( SALOMEDS::SObject_ptr theSObject, char* LocalPersistentIDToIOR( SALOMEDS::SObject_ptr theSObject,
const char* aLocalPersistentID, const char* aLocalPersistentID,
CORBA::Boolean isMultiFile, CORBA::Boolean isMultiFile,
CORBA::Boolean isASCII ); CORBA::Boolean isASCII );
// Returns true if object can be published in the study // Returns true if object can be published in the study
bool CanPublishInStudy( CORBA::Object_ptr theIOR ); bool CanPublishInStudy( CORBA::Object_ptr theIOR );
// Publish object in the study // Publish object in the study
SALOMEDS::SObject_ptr PublishInStudy( SALOMEDS::Study_ptr theStudy, SALOMEDS::SObject_ptr PublishInStudy( SALOMEDS::Study_ptr theStudy,
SALOMEDS::SObject_ptr theSObject, SALOMEDS::SObject_ptr theSObject,
CORBA::Object_ptr theObject, CORBA::Object_ptr theObject,
const char* theName ) const char* theName )
throw ( SALOME::SALOME_Exception ); throw ( SALOME::SALOME_Exception );
// Copy-paste methods - returns true if object can be copied to the clipboard // Copy-paste methods - returns true if object can be copied to the clipboard
@ -383,8 +383,8 @@ public:
CORBA::Boolean CanPaste( const char* theComponentName, CORBA::Long theObjectID ) { return false; } CORBA::Boolean CanPaste( const char* theComponentName, CORBA::Long theObjectID ) { return false; }
// Copy-paste methods - paste object from the clipboard // Copy-paste methods - paste object from the clipboard
SALOMEDS::SObject_ptr PasteInto( const SALOMEDS::TMPFile& theStream, SALOMEDS::SObject_ptr PasteInto( const SALOMEDS::TMPFile& theStream,
CORBA::Long theObjectID, CORBA::Long theObjectID,
SALOMEDS::SObject_ptr theObject ) { SALOMEDS::SObject_ptr theObject ) {
SALOMEDS::SObject_var aResultSO; SALOMEDS::SObject_var aResultSO;
return aResultSO._retn(); return aResultSO._retn();
} }
@ -394,8 +394,8 @@ public:
// ============ // ============
virtual Engines::TMPFile* DumpPython(CORBA::Object_ptr theStudy, virtual Engines::TMPFile* DumpPython(CORBA::Object_ptr theStudy,
CORBA::Boolean isPublished, CORBA::Boolean isPublished,
CORBA::Boolean& isValidScript); CORBA::Boolean& isValidScript);
void AddToPythonScript (int theStudyID, const TCollection_AsciiString& theString); void AddToPythonScript (int theStudyID, const TCollection_AsciiString& theString);
@ -452,7 +452,7 @@ public:
SMESH::SMESH_Mesh_ptr theMesh, SMESH::SMESH_Mesh_ptr theMesh,
SMESH::SMESH_subMesh_ptr theSubMesh, SMESH::SMESH_subMesh_ptr theSubMesh,
GEOM::GEOM_Object_ptr theShapeObject, GEOM::GEOM_Object_ptr theShapeObject,
const char* theName = 0); const char* theName = 0);
SALOMEDS::SObject_ptr PublishGroup (SALOMEDS::Study_ptr theStudy, SALOMEDS::SObject_ptr PublishGroup (SALOMEDS::Study_ptr theStudy,
SMESH::SMESH_Mesh_ptr theMesh, SMESH::SMESH_Mesh_ptr theMesh,
SMESH::SMESH_GroupBase_ptr theGroup, SMESH::SMESH_GroupBase_ptr theGroup,

6
src/SMESH_I/SMESH_Group_i.cxx
View File

@ -305,8 +305,8 @@ typedef bool (SMESHDS_Group::*TFunChangeGroup)(const int);
CORBA::Long CORBA::Long
ChangeByPredicate( SMESH::Predicate_i* thePredicate, ChangeByPredicate( SMESH::Predicate_i* thePredicate,
SMESHDS_GroupBase* theGroupBase, SMESHDS_GroupBase* theGroupBase,
TFunChangeGroup theFun) TFunChangeGroup theFun)
{ {
CORBA::Long aNb = 0; CORBA::Long aNb = 0;
if(SMESHDS_Group* aGroupDS = dynamic_cast<SMESHDS_Group*>(theGroupBase)){ if(SMESHDS_Group* aGroupDS = dynamic_cast<SMESHDS_Group*>(theGroupBase)){
@ -317,7 +317,7 @@ ChangeByPredicate( SMESH::Predicate_i* thePredicate,
CORBA::Long i = 0, iEnd = aSequence.size(); CORBA::Long i = 0, iEnd = aSequence.size();
for(; i < iEnd; i++) for(; i < iEnd; i++)
if((aGroupDS->*theFun)(aSequence[i])) if((aGroupDS->*theFun)(aSequence[i]))
aNb++; aNb++;
return aNb; return aNb;
} }
return aNb; return aNb;

32
src/SMESH_I/SMESH_MEDFamily_i.cxx
View File

@ -77,7 +77,7 @@ SMESH_MEDFamily_i::~SMESH_MEDFamily_i()
*/ */
//============================================================================= //=============================================================================
SMESH_MEDFamily_i::SMESH_MEDFamily_i(int identifier, SMESH_subMesh_i* sm, SMESH_MEDFamily_i::SMESH_MEDFamily_i(int identifier, SMESH_subMesh_i* sm,
string name, string description, SALOME_MED::medEntityMesh entity): string name, string description, SALOME_MED::medEntityMesh entity):
SMESH_MEDSupport_i( sm, name, description, entity ), SMESH_MEDSupport_i( sm, name, description, entity ),
_subMesh_i(sm), _subMesh_i(sm),
@ -103,7 +103,7 @@ throw (SALOME::SALOME_Exception)
{ {
if (_subMeshDS==NULL) if (_subMeshDS==NULL)
THROW_SALOME_CORBA_EXCEPTION("No associated Family",\ THROW_SALOME_CORBA_EXCEPTION("No associated Family",\
SALOME::INTERNAL_ERROR); SALOME::INTERNAL_ERROR);
return _identifier; return _identifier;
} }
@ -117,7 +117,7 @@ throw (SALOME::SALOME_Exception)
{ {
if (_subMeshDS==NULL) if (_subMeshDS==NULL)
THROW_SALOME_CORBA_EXCEPTION("No associated Family",\ THROW_SALOME_CORBA_EXCEPTION("No associated Family",\
SALOME::INTERNAL_ERROR); SALOME::INTERNAL_ERROR);
return _numberOfAttribute; return _numberOfAttribute;
} }
//============================================================================= //=============================================================================
@ -130,12 +130,12 @@ throw (SALOME::SALOME_Exception)
{ {
if (_subMeshDS==NULL) if (_subMeshDS==NULL)
THROW_SALOME_CORBA_EXCEPTION("No associated Family",\ THROW_SALOME_CORBA_EXCEPTION("No associated Family",\
SALOME::INTERNAL_ERROR); SALOME::INTERNAL_ERROR);
if (_numberOfAttribute == 0) if (_numberOfAttribute == 0)
{ {
MESSAGE("Les familles SMESH n ont pas d attribut"); MESSAGE("Les familles SMESH n ont pas d attribut");
THROW_SALOME_CORBA_EXCEPTION("No attributes"\ THROW_SALOME_CORBA_EXCEPTION("No attributes"\
,SALOME::BAD_PARAM); ,SALOME::BAD_PARAM);
}; };
SALOME_MED::long_array_var myseq= new SALOME_MED::long_array; SALOME_MED::long_array_var myseq= new SALOME_MED::long_array;
@ -157,15 +157,15 @@ CORBA::Long SMESH_MEDFamily_i::getAttributeIdentifier(CORBA::Long i)
{ {
if (_subMeshDS==NULL) if (_subMeshDS==NULL)
THROW_SALOME_CORBA_EXCEPTION("No associated Family",\ THROW_SALOME_CORBA_EXCEPTION("No associated Family",\
SALOME::INTERNAL_ERROR); SALOME::INTERNAL_ERROR);
MESSAGE("Les familles SMESH n ont pas d attribut"); MESSAGE("Les familles SMESH n ont pas d attribut");
THROW_SALOME_CORBA_EXCEPTION("No attributes"\ THROW_SALOME_CORBA_EXCEPTION("No attributes"\
,SALOME::BAD_PARAM); ,SALOME::BAD_PARAM);
if (_numberOfAttribute == 0) if (_numberOfAttribute == 0)
{ {
MESSAGE("Les familles SMESH n ont pas d attribut"); MESSAGE("Les familles SMESH n ont pas d attribut");
THROW_SALOME_CORBA_EXCEPTION("No attributes"\ THROW_SALOME_CORBA_EXCEPTION("No attributes"\
,SALOME::BAD_PARAM); ,SALOME::BAD_PARAM);
}; };
ASSERT (i <= _numberOfAttribute); ASSERT (i <= _numberOfAttribute);
return _attributeIdentifier[i]; return _attributeIdentifier[i];
@ -180,13 +180,13 @@ SALOME_MED::long_array* SMESH_MEDFamily_i::getAttributesValues()
{ {
if (_subMeshDS==NULL) if (_subMeshDS==NULL)
THROW_SALOME_CORBA_EXCEPTION("No associated Family",\ THROW_SALOME_CORBA_EXCEPTION("No associated Family",\
SALOME::INTERNAL_ERROR); SALOME::INTERNAL_ERROR);
if (_numberOfAttribute == 0) if (_numberOfAttribute == 0)
{ {
MESSAGE("Les familles SMESH n ont pas d attribut"); MESSAGE("Les familles SMESH n ont pas d attribut");
THROW_SALOME_CORBA_EXCEPTION("No attributes"\ THROW_SALOME_CORBA_EXCEPTION("No attributes"\
,SALOME::BAD_PARAM); ,SALOME::BAD_PARAM);
}; };
SALOME_MED::long_array_var myseq= new SALOME_MED::long_array; SALOME_MED::long_array_var myseq= new SALOME_MED::long_array;
@ -207,12 +207,12 @@ CORBA::Long SMESH_MEDFamily_i::getAttributeValue(CORBA::Long i)
{ {
if (_subMeshDS==NULL) if (_subMeshDS==NULL)
THROW_SALOME_CORBA_EXCEPTION("No associated Family",\ THROW_SALOME_CORBA_EXCEPTION("No associated Family",\
SALOME::INTERNAL_ERROR); SALOME::INTERNAL_ERROR);
if (_numberOfAttribute == 0) if (_numberOfAttribute == 0)
{ {
MESSAGE("Les familles SMESH n ont pas d attribut"); MESSAGE("Les familles SMESH n ont pas d attribut");
THROW_SALOME_CORBA_EXCEPTION("No attributes"\ THROW_SALOME_CORBA_EXCEPTION("No attributes"\
,SALOME::BAD_PARAM); ,SALOME::BAD_PARAM);
} }
ASSERT (i <= _numberOfAttribute); ASSERT (i <= _numberOfAttribute);
@ -228,12 +228,12 @@ SALOME_MED::string_array * SMESH_MEDFamily_i::getAttributesDescriptions()
{ {
if (_subMeshDS==NULL) if (_subMeshDS==NULL)
THROW_SALOME_CORBA_EXCEPTION("No associated Family",\ THROW_SALOME_CORBA_EXCEPTION("No associated Family",\
SALOME::INTERNAL_ERROR); SALOME::INTERNAL_ERROR);
if (_numberOfAttribute == 0) if (_numberOfAttribute == 0)
{ {
MESSAGE("Les familles SMESH n ont pas d attribut"); MESSAGE("Les familles SMESH n ont pas d attribut");
THROW_SALOME_CORBA_EXCEPTION("No attributes"\ THROW_SALOME_CORBA_EXCEPTION("No attributes"\
,SALOME::BAD_PARAM); ,SALOME::BAD_PARAM);
} }
SALOME_MED::string_array_var myseq = new SALOME_MED::string_array; SALOME_MED::string_array_var myseq = new SALOME_MED::string_array;
for (int i=0;i<_numberOfAttribute;i++) for (int i=0;i<_numberOfAttribute;i++)
@ -252,12 +252,12 @@ char * SMESH_MEDFamily_i::getAttributeDescription( CORBA::Long i)
{ {
if (_subMeshDS==NULL) if (_subMeshDS==NULL)
THROW_SALOME_CORBA_EXCEPTION("No associated Family",\ THROW_SALOME_CORBA_EXCEPTION("No associated Family",\
SALOME::INTERNAL_ERROR); SALOME::INTERNAL_ERROR);
if (_numberOfAttribute == 0) if (_numberOfAttribute == 0)
{ {
MESSAGE("Les familles SMESH n ont pas d attribut"); MESSAGE("Les familles SMESH n ont pas d attribut");
THROW_SALOME_CORBA_EXCEPTION("No attributes"\ THROW_SALOME_CORBA_EXCEPTION("No attributes"\
,SALOME::BAD_PARAM); ,SALOME::BAD_PARAM);
} }
ASSERT (i <= _numberOfAttribute); ASSERT (i <= _numberOfAttribute);
return CORBA::string_dup(_attributeDescription[i].c_str()); return CORBA::string_dup(_attributeDescription[i].c_str());

2
src/SMESH_I/SMESH_MEDFamily_i.hxx
View File

@ -56,7 +56,7 @@ public :
// Constructors and associated internal methods // Constructors and associated internal methods
SMESH_MEDFamily_i(int identifier, SMESH_subMesh_i* sm, SMESH_MEDFamily_i(int identifier, SMESH_subMesh_i* sm,
std::string name, std::string description, SALOME_MED::medEntityMesh entity ); std::string name, std::string description, SALOME_MED::medEntityMesh entity );
SMESH_MEDFamily_i(const SMESH_MEDFamily_i & f); SMESH_MEDFamily_i(const SMESH_MEDFamily_i & f);
// IDL Methods // IDL Methods

1181
src/SMESH_I/SMESH_MEDMesh_i.cxx
View File

File diff suppressed because it is too large Load Diff

36
src/SMESH_I/SMESH_MEDMesh_i.hxx
View File

@ -82,9 +82,9 @@ public:
void release() {} void release() {}
SALOME::SenderDouble_ptr getSenderForCoordinates(SALOME_MED::medModeSwitch) {return SALOME::SenderDouble::_nil();} SALOME::SenderDouble_ptr getSenderForCoordinates(SALOME_MED::medModeSwitch) {return SALOME::SenderDouble::_nil();}
SALOME::SenderInt_ptr getSenderForConnectivity(SALOME_MED::medModeSwitch, SALOME::SenderInt_ptr getSenderForConnectivity(SALOME_MED::medModeSwitch,
SALOME_MED::medConnectivity, SALOME_MED::medConnectivity,
SALOME_MED::medEntityMesh, SALOME_MED::medEntityMesh,
SALOME_MED::medGeometryElement) SALOME_MED::medGeometryElement)
{ {
return SALOME::SenderInt::_nil(); return SALOME::SenderInt::_nil();
} }
@ -103,7 +103,7 @@ public:
CORBA::Boolean CORBA::Boolean
existConnectivity(SALOME_MED::medConnectivity connectivityType, existConnectivity(SALOME_MED::medConnectivity connectivityType,
SALOME_MED::medEntityMesh entity) SALOME_MED::medEntityMesh entity)
throw (SALOME::SALOME_Exception); throw (SALOME::SALOME_Exception);
char *getCoordinatesSystem() throw(SALOME::SALOME_Exception); char *getCoordinatesSystem() throw(SALOME::SALOME_Exception);
@ -127,27 +127,27 @@ public:
SALOME_MED::medGeometryElement_array * SALOME_MED::medGeometryElement_array *
getTypes(SALOME_MED::medEntityMesh entity) throw(SALOME:: getTypes(SALOME_MED::medEntityMesh entity) throw(SALOME::
SALOME_Exception); SALOME_Exception);
SALOME_MED::medGeometryElement SALOME_MED::medGeometryElement
getElementType(SALOME_MED::medEntityMesh entity, getElementType(SALOME_MED::medEntityMesh entity,
CORBA::Long number) CORBA::Long number)
throw (SALOME::SALOME_Exception); throw (SALOME::SALOME_Exception);
CORBA::Long getNumberOfElements(SALOME_MED::medEntityMesh entity, CORBA::Long getNumberOfElements(SALOME_MED::medEntityMesh entity,
SALOME_MED::medGeometryElement geomElement) SALOME_MED::medGeometryElement geomElement)
throw(SALOME::SALOME_Exception); throw(SALOME::SALOME_Exception);
SALOME_MED::long_array * SALOME_MED::long_array *
getConnectivity(SALOME_MED::medModeSwitch typeSwitch, getConnectivity(SALOME_MED::medModeSwitch typeSwitch,
SALOME_MED::medConnectivity mode, SALOME_MED::medConnectivity mode,
SALOME_MED::medEntityMesh entity, SALOME_MED::medEntityMesh entity,
SALOME_MED::medGeometryElement geomElement) SALOME_MED::medGeometryElement geomElement)
throw(SALOME::SALOME_Exception); throw(SALOME::SALOME_Exception);
SALOME_MED::long_array * SALOME_MED::long_array *
getConnectivityIndex(SALOME_MED::medConnectivity mode, getConnectivityIndex(SALOME_MED::medConnectivity mode,
SALOME_MED::medEntityMesh entity) SALOME_MED::medEntityMesh entity)
throw(SALOME::SALOME_Exception); throw(SALOME::SALOME_Exception);
SALOME_MED::long_array* SALOME_MED::long_array*
@ -155,9 +155,9 @@ public:
throw (SALOME::SALOME_Exception); throw (SALOME::SALOME_Exception);
CORBA::Long getElementNumber(SALOME_MED::medConnectivity mode, CORBA::Long getElementNumber(SALOME_MED::medConnectivity mode,
SALOME_MED::medEntityMesh entity, SALOME_MED::medEntityMesh entity,
SALOME_MED::medGeometryElement type, SALOME_MED::medGeometryElement type,
const SALOME_MED::long_array & connectivity) const SALOME_MED::long_array & connectivity)
throw(SALOME::SALOME_Exception); throw(SALOME::SALOME_Exception);
SALOME_MED::long_array * SALOME_MED::long_array *
@ -180,14 +180,14 @@ public:
throw(SALOME::SALOME_Exception); throw(SALOME::SALOME_Exception);
SALOME_MED::FAMILY_ptr getFamily(SALOME_MED::medEntityMesh entity, SALOME_MED::FAMILY_ptr getFamily(SALOME_MED::medEntityMesh entity,
CORBA::Long i) CORBA::Long i)
throw(SALOME::SALOME_Exception); throw(SALOME::SALOME_Exception);
SALOME_MED::Group_array * getGroups(SALOME_MED::medEntityMesh entity) SALOME_MED::Group_array * getGroups(SALOME_MED::medEntityMesh entity)
throw(SALOME::SALOME_Exception); throw(SALOME::SALOME_Exception);
SALOME_MED::GROUP_ptr getGroup(SALOME_MED::medEntityMesh entity, SALOME_MED::GROUP_ptr getGroup(SALOME_MED::medEntityMesh entity,
CORBA::Long i) CORBA::Long i)
throw(SALOME::SALOME_Exception); throw(SALOME::SALOME_Exception);
SALOME_MED::SUPPORT_ptr SALOME_MED::SUPPORT_ptr
@ -221,10 +221,10 @@ public:
// Others // Others
void addInStudy(SALOMEDS::Study_ptr myStudy, void addInStudy(SALOMEDS::Study_ptr myStudy,
SALOME_MED::MESH_ptr myIor) SALOME_MED::MESH_ptr myIor)
throw(SALOME::SALOME_Exception); throw(SALOME::SALOME_Exception);
CORBA::Long addDriver(SALOME_MED::medDriverTypes driverType, CORBA::Long addDriver(SALOME_MED::medDriverTypes driverType,
const char *fileName, const char *meshName) const char *fileName, const char *meshName)
throw(SALOME::SALOME_Exception); throw(SALOME::SALOME_Exception);
void rmDriver(CORBA::Long i) throw(SALOME::SALOME_Exception); void rmDriver(CORBA::Long i) throw(SALOME::SALOME_Exception);
void read(CORBA::Long i) throw(SALOME::SALOME_Exception); void read(CORBA::Long i) throw(SALOME::SALOME_Exception);

290
src/SMESH_I/SMESH_MEDSupport_i.cxx
View File

@ -45,8 +45,8 @@ using namespace std;
//============================================================================= //=============================================================================
SMESH_MEDSupport_i::SMESH_MEDSupport_i() SMESH_MEDSupport_i::SMESH_MEDSupport_i()
{ {
BEGIN_OF("Default Constructor SMESH_MEDSupport_i"); BEGIN_OF("Default Constructor SMESH_MEDSupport_i");
END_OF("Default Constructor SMESH_MEDSupport_i"); END_OF("Default Constructor SMESH_MEDSupport_i");
} }
//============================================================================= //=============================================================================
@ -55,40 +55,40 @@ SMESH_MEDSupport_i::SMESH_MEDSupport_i()
*/ */
//============================================================================= //=============================================================================
SMESH_MEDSupport_i::SMESH_MEDSupport_i(SMESH_subMesh_i * sm, string name, SMESH_MEDSupport_i::SMESH_MEDSupport_i(SMESH_subMesh_i * sm, string name,
string description, SALOME_MED::medEntityMesh entity) string description, SALOME_MED::medEntityMesh entity)
:_subMesh_i(sm), _name(name), _description(description), _entity(entity), :_subMesh_i(sm), _name(name), _description(description), _entity(entity),
_seqNumber(false), _seqLength(0) _seqNumber(false), _seqLength(0)
{ {
BEGIN_OF("Constructor SMESH_MEDSupport_i"); BEGIN_OF("Constructor SMESH_MEDSupport_i");
_meshDS = _subMesh_i->_mesh_i->GetImpl().GetMeshDS(); _meshDS = _subMesh_i->_mesh_i->GetImpl().GetMeshDS();
int subMeshId = _subMesh_i->GetId(); int subMeshId = _subMesh_i->GetId();
MESSAGE(" subMeshId " << subMeshId) MESSAGE(" subMeshId " << subMeshId)
if (_subMesh_i->_mesh_i->_mapSubMesh.find(subMeshId) != if (_subMesh_i->_mesh_i->_mapSubMesh.find(subMeshId) !=
_subMesh_i->_mesh_i->_mapSubMesh.end()) _subMesh_i->_mesh_i->_mapSubMesh.end())
{ {
::SMESH_subMesh * subMesh = _subMesh_i->_mesh_i->_mapSubMesh[subMeshId]; ::SMESH_subMesh * subMesh = _subMesh_i->_mesh_i->_mapSubMesh[subMeshId];
_subMeshDS = subMesh->GetSubMeshDS(); _subMeshDS = subMesh->GetSubMeshDS();
} }
if (_entity == SALOME_MED::MED_NODE) if (_entity == SALOME_MED::MED_NODE)
{ {
_numberOfGeometricType = 1; _numberOfGeometricType = 1;
_geometricType = new SALOME_MED::medGeometryElement[1]; _geometricType = new SALOME_MED::medGeometryElement[1];
_geometricType[0] = SALOME_MED::MED_NONE; _geometricType[0] = SALOME_MED::MED_NONE;
} }
else else
{ {
MESSAGE("Pas implemente dans cette version"); MESSAGE("Pas implemente dans cette version");
THROW_SALOME_CORBA_EXCEPTION THROW_SALOME_CORBA_EXCEPTION
("Seules les familles de noeuds sont implementees ", ("Seules les familles de noeuds sont implementees ",
SALOME::BAD_PARAM); SALOME::BAD_PARAM);
} }
END_OF("Constructor SMESH_MEDSupport_i"); END_OF("Constructor SMESH_MEDSupport_i");
} }
//============================================================================= //=============================================================================
@ -101,19 +101,19 @@ SMESH_MEDSupport_i(const SMESH_MEDSupport_i & s):_subMesh_i(s._subMesh_i),
_name(s._name), _description(s._description), _entity(s._entity), _name(s._name), _description(s._description), _entity(s._entity),
_seqNumber(false), _seqLength(0) _seqNumber(false), _seqLength(0)
{ {
BEGIN_OF("Constructor SMESH_MEDSupport_i"); BEGIN_OF("Constructor SMESH_MEDSupport_i");
_meshDS = _subMesh_i->_mesh_i->GetImpl().GetMeshDS(); _meshDS = _subMesh_i->_mesh_i->GetImpl().GetMeshDS();
int subMeshId = _subMesh_i->GetId(); int subMeshId = _subMesh_i->GetId();
if (_subMesh_i->_mesh_i->_mapSubMesh.find(subMeshId) != if (_subMesh_i->_mesh_i->_mapSubMesh.find(subMeshId) !=
_subMesh_i->_mesh_i->_mapSubMesh.end()) _subMesh_i->_mesh_i->_mapSubMesh.end())
{ {
::SMESH_subMesh * subMesh = _subMesh_i->_mesh_i->_mapSubMesh[subMeshId]; ::SMESH_subMesh * subMesh = _subMesh_i->_mesh_i->_mapSubMesh[subMeshId];
_subMeshDS = subMesh->GetSubMeshDS(); _subMeshDS = subMesh->GetSubMeshDS();
} }
END_OF("Constructor SMESH_MEDSupport_i"); END_OF("Constructor SMESH_MEDSupport_i");
} }
//============================================================================= //=============================================================================
@ -134,11 +134,11 @@ SMESH_MEDSupport_i::~SMESH_MEDSupport_i()
CORBA::Long SMESH_MEDSupport_i::getCorbaIndex()throw(SALOME::SALOME_Exception) CORBA::Long SMESH_MEDSupport_i::getCorbaIndex()throw(SALOME::SALOME_Exception)
{ {
if (_subMeshDS == NULL) if (_subMeshDS == NULL)
THROW_SALOME_CORBA_EXCEPTION("No associated Support", THROW_SALOME_CORBA_EXCEPTION("No associated Support",
SALOME::INTERNAL_ERROR); SALOME::INTERNAL_ERROR);
MESSAGE("Not implemented for SMESH_i"); MESSAGE("Not implemented for SMESH_i");
THROW_SALOME_CORBA_EXCEPTION("Not Implemented ", SALOME::BAD_PARAM); THROW_SALOME_CORBA_EXCEPTION("Not Implemented ", SALOME::BAD_PARAM);
} }
@ -150,10 +150,10 @@ CORBA::Long SMESH_MEDSupport_i::getCorbaIndex()throw(SALOME::SALOME_Exception)
char *SMESH_MEDSupport_i::getName() throw(SALOME::SALOME_Exception) char *SMESH_MEDSupport_i::getName() throw(SALOME::SALOME_Exception)
{ {
if (_subMeshDS==NULL) if (_subMeshDS==NULL)
THROW_SALOME_CORBA_EXCEPTION("No associated Support", THROW_SALOME_CORBA_EXCEPTION("No associated Support",
SALOME::INTERNAL_ERROR); SALOME::INTERNAL_ERROR);
return CORBA::string_dup(_name.c_str()); return CORBA::string_dup(_name.c_str());
} }
@ -165,10 +165,10 @@ char *SMESH_MEDSupport_i::getName() throw(SALOME::SALOME_Exception)
char *SMESH_MEDSupport_i::getDescription() throw(SALOME::SALOME_Exception) char *SMESH_MEDSupport_i::getDescription() throw(SALOME::SALOME_Exception)
{ {
if (_subMeshDS==NULL) if (_subMeshDS==NULL)
THROW_SALOME_CORBA_EXCEPTION("No associated Support", THROW_SALOME_CORBA_EXCEPTION("No associated Support",
SALOME::INTERNAL_ERROR); SALOME::INTERNAL_ERROR);
return CORBA::string_dup(_description.c_str()); return CORBA::string_dup(_description.c_str());
} }
//============================================================================= //=============================================================================
@ -178,13 +178,13 @@ char *SMESH_MEDSupport_i::getDescription() throw(SALOME::SALOME_Exception)
//============================================================================= //=============================================================================
SALOME_MED::MESH_ptr SMESH_MEDSupport_i::getMesh()throw(SALOME:: SALOME_MED::MESH_ptr SMESH_MEDSupport_i::getMesh()throw(SALOME::
SALOME_Exception) SALOME_Exception)
{ {
if (_subMeshDS==NULL) if (_subMeshDS==NULL)
THROW_SALOME_CORBA_EXCEPTION("No associated Support", THROW_SALOME_CORBA_EXCEPTION("No associated Support",
SALOME::INTERNAL_ERROR); SALOME::INTERNAL_ERROR);
return _subMesh_i->_mesh_i->GetMEDMesh(); return _subMesh_i->_mesh_i->GetMEDMesh();
} }
//============================================================================= //=============================================================================
@ -194,36 +194,36 @@ SALOME_MED::MESH_ptr SMESH_MEDSupport_i::getMesh()throw(SALOME::
//============================================================================= //=============================================================================
CORBA::Boolean SMESH_MEDSupport_i::isOnAllElements()throw(SALOME:: CORBA::Boolean SMESH_MEDSupport_i::isOnAllElements()throw(SALOME::
SALOME_Exception) SALOME_Exception)
{ {
if (_subMeshDS==NULL) if (_subMeshDS==NULL)
THROW_SALOME_CORBA_EXCEPTION("No associated Support", THROW_SALOME_CORBA_EXCEPTION("No associated Support",
SALOME::INTERNAL_ERROR); SALOME::INTERNAL_ERROR);
if (_seqNumber == false) if (_seqNumber == false)
{ {
if (_entity != SALOME_MED::MED_NONE) if (_entity != SALOME_MED::MED_NONE)
{ {
_seqLength = _subMeshDS->NbNodes(); _seqLength = _subMeshDS->NbNodes();
_seqNumber = true; _seqNumber = true;
} }
else else
{ {
MESSAGE("Only Node Families are implemented "); MESSAGE("Only Node Families are implemented ");
THROW_SALOME_CORBA_EXCEPTION("Not implemented Yet ", THROW_SALOME_CORBA_EXCEPTION("Not implemented Yet ",
SALOME::BAD_PARAM); SALOME::BAD_PARAM);
} }
} }
try try
{ {
_isOnAllElements = (_seqLength == _meshDS->NbNodes()); _isOnAllElements = (_seqLength == _meshDS->NbNodes());
} }
catch(...) catch(...)
{ {
MESSAGE("unable to acces related Mesh"); MESSAGE("unable to acces related Mesh");
THROW_SALOME_CORBA_EXCEPTION("No associated Mesh", THROW_SALOME_CORBA_EXCEPTION("No associated Mesh",
SALOME::INTERNAL_ERROR); SALOME::INTERNAL_ERROR);
}; };
return _isOnAllElements; return _isOnAllElements;
} }
//============================================================================= //=============================================================================
@ -233,12 +233,12 @@ CORBA::Boolean SMESH_MEDSupport_i::isOnAllElements()throw(SALOME::
//============================================================================= //=============================================================================
SALOME_MED::medEntityMesh SMESH_MEDSupport_i::getEntity()throw(SALOME:: SALOME_MED::medEntityMesh SMESH_MEDSupport_i::getEntity()throw(SALOME::
SALOME_Exception) SALOME_Exception)
{ {
if (_subMeshDS==NULL) if (_subMeshDS==NULL)
THROW_SALOME_CORBA_EXCEPTION("No associated Support", THROW_SALOME_CORBA_EXCEPTION("No associated Support",
SALOME::INTERNAL_ERROR); SALOME::INTERNAL_ERROR);
return _entity; return _entity;
} }
//============================================================================= //=============================================================================
@ -248,29 +248,29 @@ SALOME_MED::medEntityMesh SMESH_MEDSupport_i::getEntity()throw(SALOME::
//============================================================================= //=============================================================================
SALOME_MED::medGeometryElement_array * SALOME_MED::medGeometryElement_array *
SMESH_MEDSupport_i::getTypes()throw(SALOME::SALOME_Exception) SMESH_MEDSupport_i::getTypes()throw(SALOME::SALOME_Exception)
{ {
if (_subMeshDS==NULL) if (_subMeshDS==NULL)
THROW_SALOME_CORBA_EXCEPTION("No associated Support", THROW_SALOME_CORBA_EXCEPTION("No associated Support",
SALOME::INTERNAL_ERROR); SALOME::INTERNAL_ERROR);
SALOME_MED::medGeometryElement_array_var myseq = SALOME_MED::medGeometryElement_array_var myseq =
new SALOME_MED::medGeometryElement_array; new SALOME_MED::medGeometryElement_array;
try try
{ {
int mySeqLength = _numberOfGeometricType; int mySeqLength = _numberOfGeometricType;
myseq->length(mySeqLength); myseq->length(mySeqLength);
for (int i = 0; i < mySeqLength; i++) for (int i = 0; i < mySeqLength; i++)
{ {
myseq[i] = _geometricType[i]; myseq[i] = _geometricType[i];
} }
} }
catch(...) catch(...)
{ {
MESSAGE("Exception lors de la recherche des differents types"); MESSAGE("Exception lors de la recherche des differents types");
THROW_SALOME_CORBA_EXCEPTION("Unable to acces Support Types", THROW_SALOME_CORBA_EXCEPTION("Unable to acces Support Types",
SALOME::INTERNAL_ERROR); SALOME::INTERNAL_ERROR);
} }
return myseq._retn(); return myseq._retn();
} }
//============================================================================= //=============================================================================
@ -280,12 +280,12 @@ SALOME_MED::medGeometryElement_array *
*/ */
//============================================================================= //=============================================================================
CORBA::Long SMESH_MEDSupport_i::getNumberOfElements(SALOME_MED:: CORBA::Long SMESH_MEDSupport_i::getNumberOfElements(SALOME_MED::
medGeometryElement geomElement) throw(SALOME::SALOME_Exception) medGeometryElement geomElement) throw(SALOME::SALOME_Exception)
{ {
if (_subMeshDS==NULL) if (_subMeshDS==NULL)
THROW_SALOME_CORBA_EXCEPTION("No associated Support", THROW_SALOME_CORBA_EXCEPTION("No associated Support",
SALOME::INTERNAL_ERROR); SALOME::INTERNAL_ERROR);
return _numberOfGeometricType; return _numberOfGeometricType;
} }
@ -296,32 +296,32 @@ CORBA::Long SMESH_MEDSupport_i::getNumberOfElements(SALOME_MED::
//============================================================================= //=============================================================================
SALOME_MED::long_array * SMESH_MEDSupport_i::getNumber( SALOME_MED::long_array * SMESH_MEDSupport_i::getNumber(
SALOME_MED::medGeometryElement geomElement) throw(SALOME::SALOME_Exception) SALOME_MED::medGeometryElement geomElement) throw(SALOME::SALOME_Exception)
{ {
Unexpect aCatch(SALOME_SalomeException); Unexpect aCatch(SALOME_SalomeException);
if (_subMeshDS==NULL) if (_subMeshDS==NULL)
THROW_SALOME_CORBA_EXCEPTION("No associated Support", THROW_SALOME_CORBA_EXCEPTION("No associated Support",
SALOME::INTERNAL_ERROR); SALOME::INTERNAL_ERROR);
// A changer s'il ne s agit plus seulement de famille de noeuds // A changer s'il ne s agit plus seulement de famille de noeuds
if (geomElement != SALOME_MED::MED_NONE) if (geomElement != SALOME_MED::MED_NONE)
THROW_SALOME_CORBA_EXCEPTION("Not implemented", SALOME::BAD_PARAM); THROW_SALOME_CORBA_EXCEPTION("Not implemented", SALOME::BAD_PARAM);
SALOME_MED::long_array_var myseq = new SALOME_MED::long_array; SALOME_MED::long_array_var myseq = new SALOME_MED::long_array;
int i = 0; int i = 0;
myseq->length(_subMeshDS->NbNodes()); myseq->length(_subMeshDS->NbNodes());
SMDS_NodeIteratorPtr it = _subMeshDS->GetNodes(); SMDS_NodeIteratorPtr it = _subMeshDS->GetNodes();
while(it->more()) while(it->more())
{ {
myseq[i] = it->next()->GetID(); myseq[i] = it->next()->GetID();
i++; i++;
}; };
SCRUTE(myseq->length()); SCRUTE(myseq->length());
MESSAGE("End of SMESH_MEDSupport_i::getNumber"); MESSAGE("End of SMESH_MEDSupport_i::getNumber");
return myseq._retn(); return myseq._retn();
} }
@ -332,7 +332,7 @@ SALOME_MED::long_array * SMESH_MEDSupport_i::getNumber(
//============================================================================= //=============================================================================
SALOME_MED::long_array * SMESH_MEDSupport_i::getNumberFromFile( SALOME_MED::long_array * SMESH_MEDSupport_i::getNumberFromFile(
SALOME_MED::medGeometryElement geomElement) throw(SALOME::SALOME_Exception) SALOME_MED::medGeometryElement geomElement) throw(SALOME::SALOME_Exception)
{ {
return getNumber(geomElement); return getNumber(geomElement);
} }
@ -345,11 +345,11 @@ SALOME_MED::long_array * SMESH_MEDSupport_i::getNumberFromFile(
//============================================================================= //=============================================================================
SALOME_MED::long_array * SALOME_MED::long_array *
SMESH_MEDSupport_i::getNumberIndex()throw(SALOME::SALOME_Exception) SMESH_MEDSupport_i::getNumberIndex()throw(SALOME::SALOME_Exception)
{ {
MESSAGE("Not implemented for SMESH_i"); MESSAGE("Not implemented for SMESH_i");
THROW_SALOME_CORBA_EXCEPTION("Not Implemented", SALOME::BAD_PARAM); THROW_SALOME_CORBA_EXCEPTION("Not Implemented", SALOME::BAD_PARAM);
return NULL; return NULL;
} }
//============================================================================= //=============================================================================
/*! /*!
@ -358,10 +358,10 @@ SALOME_MED::long_array *
//============================================================================= //=============================================================================
CORBA::Long SMESH_MEDSupport_i::getNumberOfGaussPoint(SALOME_MED:: CORBA::Long SMESH_MEDSupport_i::getNumberOfGaussPoint(SALOME_MED::
medGeometryElement geomElement) throw(SALOME::SALOME_Exception) medGeometryElement geomElement) throw(SALOME::SALOME_Exception)
{ {
MESSAGE("Not implemented for SMESH_i"); MESSAGE("Not implemented for SMESH_i");
return 0; return 0;
} }
//============================================================================= //=============================================================================
/*! /*!

78
src/SMESH_I/SMESH_MEDSupport_i.hxx
View File

@ -42,78 +42,78 @@
class SMESH_subMesh_i; class SMESH_subMesh_i;
class SMESH_I_EXPORT SMESH_MEDSupport_i: class SMESH_I_EXPORT SMESH_MEDSupport_i:
public virtual POA_SALOME_MED::SUPPORT, public virtual SALOME::GenericObj_i public virtual POA_SALOME_MED::SUPPORT, public virtual SALOME::GenericObj_i
{ {
public: public:
// Constructors and associated internal methods // Constructors and associated internal methods
SMESH_MEDSupport_i(SMESH_subMesh_i * sm, SMESH_MEDSupport_i(SMESH_subMesh_i * sm,
std::string name, std::string description, SALOME_MED::medEntityMesh entity); std::string name, std::string description, SALOME_MED::medEntityMesh entity);
SMESH_MEDSupport_i(const SMESH_MEDSupport_i & s); SMESH_MEDSupport_i(const SMESH_MEDSupport_i & s);
// IDL Methods // IDL Methods
char *getName() throw(SALOME::SALOME_Exception); char *getName() throw(SALOME::SALOME_Exception);
char *getDescription() throw(SALOME::SALOME_Exception); char *getDescription() throw(SALOME::SALOME_Exception);
SALOME_MED::MESH_ptr getMesh() throw(SALOME::SALOME_Exception); SALOME_MED::MESH_ptr getMesh() throw(SALOME::SALOME_Exception);
CORBA::Boolean isOnAllElements() throw(SALOME::SALOME_Exception); CORBA::Boolean isOnAllElements() throw(SALOME::SALOME_Exception);
SALOME_MED::medEntityMesh getEntity() throw(SALOME::SALOME_Exception); SALOME_MED::medEntityMesh getEntity() throw(SALOME::SALOME_Exception);
CORBA::Long CORBA::Long
getNumberOfElements(SALOME_MED::medGeometryElement geomElement) getNumberOfElements(SALOME_MED::medGeometryElement geomElement)
throw(SALOME::SALOME_Exception); throw(SALOME::SALOME_Exception);
CORBA::Long getNumberOfTypes() throw (SALOME::SALOME_Exception); CORBA::Long getNumberOfTypes() throw (SALOME::SALOME_Exception);
SALOME_MED::long_array * SALOME_MED::long_array *
getNumber(SALOME_MED::medGeometryElement geomElement) getNumber(SALOME_MED::medGeometryElement geomElement)
throw(SALOME::SALOME_Exception); throw(SALOME::SALOME_Exception);
/*! /*!
* Same function as getNumber. * Same function as getNumber.
*/ */
SALOME_MED::long_array * SALOME_MED::long_array *
getNumberFromFile(SALOME_MED::medGeometryElement geomElement) getNumberFromFile(SALOME_MED::medGeometryElement geomElement)
throw(SALOME::SALOME_Exception); throw(SALOME::SALOME_Exception);
SALOME_MED::long_array * getNumberIndex() SALOME_MED::long_array * getNumberIndex()
throw(SALOME::SALOME_Exception); throw(SALOME::SALOME_Exception);
CORBA::Long CORBA::Long
getNumberOfGaussPoint(SALOME_MED::medGeometryElement geomElement) getNumberOfGaussPoint(SALOME_MED::medGeometryElement geomElement)
throw(SALOME::SALOME_Exception); throw(SALOME::SALOME_Exception);
SALOME_MED::long_array* getNumbersOfGaussPoint() SALOME_MED::long_array* getNumbersOfGaussPoint()
throw (SALOME::SALOME_Exception); throw (SALOME::SALOME_Exception);
SALOME_MED::medGeometryElement_array *getTypes() SALOME_MED::medGeometryElement_array *getTypes()
throw(SALOME::SALOME_Exception); throw(SALOME::SALOME_Exception);
void getBoundaryElements() throw (SALOME::SALOME_Exception); void getBoundaryElements() throw (SALOME::SALOME_Exception);
CORBA::Long getCorbaIndex() throw(SALOME::SALOME_Exception); CORBA::Long getCorbaIndex() throw(SALOME::SALOME_Exception);
SALOME_MED::SUPPORT::supportInfos * getSupportGlobal() SALOME_MED::SUPPORT::supportInfos * getSupportGlobal()
throw (SALOME::SALOME_Exception); throw (SALOME::SALOME_Exception);
void createSeq() throw(SALOME::SALOME_Exception); void createSeq() throw(SALOME::SALOME_Exception);
public: //public field public: //public field
const SMESHDS_SubMesh * _subMeshDS; const SMESHDS_SubMesh * _subMeshDS;
::SMESH_subMesh_i * _subMesh_i; ::SMESH_subMesh_i * _subMesh_i;
SMESHDS_Mesh * _meshDS; SMESHDS_Mesh * _meshDS;
std::string _name; std::string _name;
std::string _description; std::string _description;
bool _isOnAllElements; bool _isOnAllElements;
bool _seqNumber; bool _seqNumber;
int _seqLength; int _seqLength;
SALOME_MED::medEntityMesh _entity; SALOME_MED::medEntityMesh _entity;
SALOME_MED::medGeometryElement * _geometricType; SALOME_MED::medGeometryElement * _geometricType;
int _numberOfGeometricType; int _numberOfGeometricType;
protected: protected:
SMESH_MEDSupport_i(); SMESH_MEDSupport_i();
~SMESH_MEDSupport_i(); ~SMESH_MEDSupport_i();
}; };
#endif /* _MED_MEDSUPPORT_I_HXX_ */ #endif /* _MED_MEDSUPPORT_I_HXX_ */

177
src/SMESH_I/SMESH_MeshEditor_i.cxx
View File

@ -2568,6 +2568,7 @@ ExtrusionAlongPathObjX(SMESH::SMESH_IDSource_ptr Object,
<< ( HasRefPoint ? RefPoint.x : 0 ) << ", " << ( HasRefPoint ? RefPoint.x : 0 ) << ", "
<< ( HasRefPoint ? RefPoint.y : 0 ) << ", " << ( HasRefPoint ? RefPoint.y : 0 ) << ", "
<< ( HasRefPoint ? RefPoint.z : 0 ) << " ), " << ( HasRefPoint ? RefPoint.z : 0 ) << " ), "
<< MakeGroups << ", "
<< ElemType << " )"; << ElemType << " )";
} }
return aGroups; return aGroups;
@ -4213,6 +4214,142 @@ void SMESH_MeshEditor_i::DumpGroupsList(TPythonDump & theDumpPytho
} }
} }
//================================================================================
/*!
\brief Creates a hole in a mesh by doubling the nodes of some particular elements
\param theNodes - identifiers of nodes to be doubled
\param theModifiedElems - identifiers of elements to be updated by the new (doubled)
nodes. If list of element identifiers is empty then nodes are doubled but
they not assigned to elements
\return TRUE if operation has been completed successfully, FALSE otherwise
\sa DoubleNode(), DoubleNodeGroup(), DoubleNodeGroups()
*/
//================================================================================
CORBA::Boolean SMESH_MeshEditor_i::DoubleNodes( const SMESH::long_array& theNodes,
const SMESH::long_array& theModifiedElems )
{
initData();
::SMESH_MeshEditor aMeshEditor( myMesh );
list< int > aListOfNodes;
int i, n;
for ( i = 0, n = theNodes.length(); i < n; i++ )
aListOfNodes.push_back( theNodes[ i ] );
list< int > aListOfElems;
for ( i = 0, n = theModifiedElems.length(); i < n; i++ )
aListOfElems.push_back( theModifiedElems[ i ] );
bool aResult = aMeshEditor.DoubleNodes( aListOfNodes, aListOfElems );
storeResult( aMeshEditor) ;
return aResult;
}
//================================================================================
/*!
\brief Creates a hole in a mesh by doubling the nodes of some particular elements
This method provided for convenience works as DoubleNodes() described above.
\param theNodeId - identifier of node to be doubled.
\param theModifiedElems - identifiers of elements to be updated.
\return TRUE if operation has been completed successfully, FALSE otherwise
\sa DoubleNodes(), DoubleNodeGroup(), DoubleNodeGroups()
*/
//================================================================================
CORBA::Boolean SMESH_MeshEditor_i::DoubleNode( CORBA::Long theNodeId,
const SMESH::long_array& theModifiedElems )
{
SMESH::long_array_var aNodes = new SMESH::long_array;
aNodes->length( 1 );
aNodes[ 0 ] = theNodeId;
return DoubleNodes( aNodes, theModifiedElems );
}
//================================================================================
/*!
\brief Creates a hole in a mesh by doubling the nodes of some particular elements
This method provided for convenience works as DoubleNodes() described above.
\param theNodes - group of nodes to be doubled.
\param theModifiedElems - group of elements to be updated.
\return TRUE if operation has been completed successfully, FALSE otherwise
\sa DoubleNode(), DoubleNodes(), DoubleNodeGroups()
*/
//================================================================================
CORBA::Boolean SMESH_MeshEditor_i::DoubleNodeGroup(
SMESH::SMESH_GroupBase_ptr theNodes,
SMESH::SMESH_GroupBase_ptr theModifiedElems )
{
if ( CORBA::is_nil( theNodes ) && theNodes->GetType() != SMESH::NODE )
return false;
SMESH::long_array_var aNodes = theNodes->GetListOfID();
SMESH::long_array_var aModifiedElems;
if ( !CORBA::is_nil( theModifiedElems ) )
aModifiedElems = theModifiedElems->GetListOfID();
else
{
aModifiedElems = new SMESH::long_array;
aModifiedElems->length( 0 );
}
return DoubleNodes( aNodes, aModifiedElems );
}
//================================================================================
/*!
\brief Creates a hole in a mesh by doubling the nodes of some particular elements
This method provided for convenience works as DoubleNodes() described above.
\param theNodes - list of groups of nodes to be doubled
\param theModifiedElems - list of groups of elements to be updated.
\return TRUE if operation has been completed successfully, FALSE otherwise
\sa DoubleNode(), DoubleNodeGroup(), DoubleNodes()
*/
//================================================================================
CORBA::Boolean SMESH_MeshEditor_i::DoubleNodeGroups(
const SMESH::ListOfGroups& theNodes,
const SMESH::ListOfGroups& theModifiedElems )
{
initData();
::SMESH_MeshEditor aMeshEditor( myMesh );
std::list< int > aNodes;
int i, n, j, m;
for ( i = 0, n = theNodes.length(); i < n; i++ )
{
SMESH::SMESH_GroupBase_var aGrp = theNodes[ i ];
if ( !CORBA::is_nil( aGrp ) && aGrp->GetType() == SMESH::NODE )
{
SMESH::long_array_var aCurr = aGrp->GetListOfID();
for ( j = 0, m = aCurr->length(); j < m; j++ )
aNodes.push_back( aCurr[ j ] );
}
}
std::list< int > anElems;
for ( i = 0, n = theModifiedElems.length(); i < n; i++ )
{
SMESH::SMESH_GroupBase_var aGrp = theModifiedElems[ i ];
if ( !CORBA::is_nil( aGrp ) && aGrp->GetType() != SMESH::NODE )
{
SMESH::long_array_var aCurr = aGrp->GetListOfID();
for ( j = 0, m = aCurr->length(); j < m; j++ )
anElems.push_back( aCurr[ j ] );
}
}
bool aResult = aMeshEditor.DoubleNodes( aNodes, anElems );
storeResult( aMeshEditor) ;
return aResult;
}
//================================================================================ //================================================================================
/*! /*!
\brief Creates a hole in a mesh by doubling the nodes of some particular elements \brief Creates a hole in a mesh by doubling the nodes of some particular elements
@ -4226,9 +4363,9 @@ void SMESH_MeshEditor_i::DumpGroupsList(TPythonDump & theDumpPytho
*/ */
//================================================================================ //================================================================================
CORBA::Boolean SMESH_MeshEditor_i::DoubleNodes( const SMESH::long_array& theElems, CORBA::Boolean SMESH_MeshEditor_i::DoubleNodeElem( const SMESH::long_array& theElems,
const SMESH::long_array& theNodesNot, const SMESH::long_array& theNodesNot,
const SMESH::long_array& theAffectedElems ) const SMESH::long_array& theAffectedElems )
{ {
initData(); initData();
@ -4265,7 +4402,7 @@ CORBA::Boolean SMESH_MeshEditor_i::DoubleNodes( const SMESH::long_array& theElem
*/ */
//================================================================================ //================================================================================
CORBA::Boolean SMESH_MeshEditor_i::DoubleNodesInRegion CORBA::Boolean SMESH_MeshEditor_i::DoubleNodeElemInRegion
( const SMESH::long_array& theElems, ( const SMESH::long_array& theElems,
const SMESH::long_array& theNodesNot, const SMESH::long_array& theNodesNot,
GEOM::GEOM_Object_ptr theShape ) GEOM::GEOM_Object_ptr theShape )
@ -4315,10 +4452,10 @@ static void groupToSet(SMESH::SMESH_GroupBase_ptr theGrp,
arrayToSet( anIDs, theMeshDS, theElemSet, theType); arrayToSet( anIDs, theMeshDS, theElemSet, theType);
} }
CORBA::Boolean SMESH_MeshEditor_i::DoubleNodeGroup( CORBA::Boolean SMESH_MeshEditor_i::DoubleNodeElemGroup(
SMESH::SMESH_GroupBase_ptr theElems, SMESH::SMESH_GroupBase_ptr theElems,
SMESH::SMESH_GroupBase_ptr theNodesNot, SMESH::SMESH_GroupBase_ptr theNodesNot,
SMESH::SMESH_GroupBase_ptr theAffectedElems ) SMESH::SMESH_GroupBase_ptr theAffectedElems )
{ {
if ( CORBA::is_nil( theElems ) && theElems->GetType() == SMESH::NODE ) if ( CORBA::is_nil( theElems ) && theElems->GetType() == SMESH::NODE )
@ -4357,10 +4494,10 @@ CORBA::Boolean SMESH_MeshEditor_i::DoubleNodeGroup(
*/ */
//================================================================================ //================================================================================
CORBA::Boolean SMESH_MeshEditor_i::DoubleNodeGroupInRegion( CORBA::Boolean SMESH_MeshEditor_i::DoubleNodeElemGroupInRegion(
SMESH::SMESH_GroupBase_ptr theElems, SMESH::SMESH_GroupBase_ptr theElems,
SMESH::SMESH_GroupBase_ptr theNodesNot, SMESH::SMESH_GroupBase_ptr theNodesNot,
GEOM::GEOM_Object_ptr theShape ) GEOM::GEOM_Object_ptr theShape )
{ {
if ( CORBA::is_nil( theElems ) && theElems->GetType() == SMESH::NODE ) if ( CORBA::is_nil( theElems ) && theElems->GetType() == SMESH::NODE )
@ -4416,10 +4553,10 @@ static void listOfGroupToSet(const SMESH::ListOfGroups& theGrpList,
} }
} }
CORBA::Boolean SMESH_MeshEditor_i::DoubleNodeGroups( CORBA::Boolean SMESH_MeshEditor_i::DoubleNodeElemGroups(
const SMESH::ListOfGroups& theElems, const SMESH::ListOfGroups& theElems,
const SMESH::ListOfGroups& theNodesNot, const SMESH::ListOfGroups& theNodesNot,
const SMESH::ListOfGroups& theAffectedElems ) const SMESH::ListOfGroups& theAffectedElems )
{ {
initData(); initData();
@ -4455,10 +4592,10 @@ CORBA::Boolean SMESH_MeshEditor_i::DoubleNodeGroups(
*/ */
//================================================================================ //================================================================================
CORBA::Boolean SMESH_MeshEditor_i::DoubleNodeGroupsInRegion( CORBA::Boolean SMESH_MeshEditor_i::DoubleNodeElemGroupsInRegion(
const SMESH::ListOfGroups& theElems, const SMESH::ListOfGroups& theElems,
const SMESH::ListOfGroups& theNodesNot, const SMESH::ListOfGroups& theNodesNot,
GEOM::GEOM_Object_ptr theShape ) GEOM::GEOM_Object_ptr theShape )
{ {
initData(); initData();

49
src/SMESH_I/SMESH_MeshEditor_i.hxx
View File

@ -514,6 +514,17 @@ class SMESH_MeshEditor_i: public POA_SMESH::SMESH_MeshEditor
*/ */
int GetMeshId() const { return myMesh->GetId(); } int GetMeshId() const { return myMesh->GetId(); }
CORBA::Boolean DoubleNodes( const SMESH::long_array& theNodes,
const SMESH::long_array& theModifiedElems );
CORBA::Boolean DoubleNode( CORBA::Long theNodeId,
const SMESH::long_array& theModifiedElems );
CORBA::Boolean DoubleNodeGroup( SMESH::SMESH_GroupBase_ptr theNodes,
SMESH::SMESH_GroupBase_ptr theModifiedElems );
CORBA::Boolean DoubleNodeGroups( const SMESH::ListOfGroups& theNodes,
const SMESH::ListOfGroups& theModifiedElems);
/*! /*!
* \brief Creates a hole in a mesh by doubling the nodes of some particular elements * \brief Creates a hole in a mesh by doubling the nodes of some particular elements
@ -525,9 +536,9 @@ class SMESH_MeshEditor_i: public POA_SMESH::SMESH_MeshEditor
* \return TRUE if operation has been completed successfully, FALSE otherwise * \return TRUE if operation has been completed successfully, FALSE otherwise
* \sa DoubleNodeGroup(), DoubleNodeGroups() * \sa DoubleNodeGroup(), DoubleNodeGroups()
*/ */
CORBA::Boolean DoubleNodes( const SMESH::long_array& theElems, CORBA::Boolean DoubleNodeElem( const SMESH::long_array& theElems,
const SMESH::long_array& theNodesNot, const SMESH::long_array& theNodesNot,
const SMESH::long_array& theAffectedElems ); const SMESH::long_array& theAffectedElems );
/*! /*!
* \brief Creates a hole in a mesh by doubling the nodes of some particular elements * \brief Creates a hole in a mesh by doubling the nodes of some particular elements
@ -540,9 +551,9 @@ class SMESH_MeshEditor_i: public POA_SMESH::SMESH_MeshEditor
* \return TRUE if operation has been completed successfully, FALSE otherwise * \return TRUE if operation has been completed successfully, FALSE otherwise
* \sa DoubleNodeGroupInRegion(), DoubleNodeGroupsInRegion() * \sa DoubleNodeGroupInRegion(), DoubleNodeGroupsInRegion()
*/ */
CORBA::Boolean DoubleNodesInRegion( const SMESH::long_array& theElems, CORBA::Boolean DoubleNodeElemInRegion( const SMESH::long_array& theElems,
const SMESH::long_array& theNodesNot, const SMESH::long_array& theNodesNot,
GEOM::GEOM_Object_ptr theShape ); GEOM::GEOM_Object_ptr theShape );
/*! /*!
* \brief Creates a hole in a mesh by doubling the nodes of some particular elements * \brief Creates a hole in a mesh by doubling the nodes of some particular elements
@ -553,10 +564,10 @@ class SMESH_MeshEditor_i: public POA_SMESH::SMESH_MeshEditor
* \return TRUE if operation has been completed successfully, FALSE otherwise * \return TRUE if operation has been completed successfully, FALSE otherwise
* \sa DoubleNodes(), DoubleNodeGroups() * \sa DoubleNodes(), DoubleNodeGroups()
*/ */
CORBA::Boolean DoubleNodeGroup( SMESH::SMESH_GroupBase_ptr theElems, CORBA::Boolean DoubleNodeElemGroup( SMESH::SMESH_GroupBase_ptr theElems,
SMESH::SMESH_GroupBase_ptr theNodesNot, SMESH::SMESH_GroupBase_ptr theNodesNot,
SMESH::SMESH_GroupBase_ptr theAffectedElems ); SMESH::SMESH_GroupBase_ptr theAffectedElems );
/*! /*!
* \brief Creates a hole in a mesh by doubling the nodes of some particular elements * \brief Creates a hole in a mesh by doubling the nodes of some particular elements
* \param theElems - group of of elements (edges or faces) to be replicated * \param theElems - group of of elements (edges or faces) to be replicated
@ -567,9 +578,9 @@ class SMESH_MeshEditor_i: public POA_SMESH::SMESH_MeshEditor
* \return TRUE if operation has been completed successfully, FALSE otherwise * \return TRUE if operation has been completed successfully, FALSE otherwise
* \sa DoubleNodesInRegion(), DoubleNodeGroupsInRegion() * \sa DoubleNodesInRegion(), DoubleNodeGroupsInRegion()
*/ */
CORBA::Boolean DoubleNodeGroupInRegion( SMESH::SMESH_GroupBase_ptr theElems, CORBA::Boolean DoubleNodeElemGroupInRegion( SMESH::SMESH_GroupBase_ptr theElems,
SMESH::SMESH_GroupBase_ptr theNodesNot, SMESH::SMESH_GroupBase_ptr theNodesNot,
GEOM::GEOM_Object_ptr theShape ); GEOM::GEOM_Object_ptr theShape );
/*! /*!
* \brief Creates a hole in a mesh by doubling the nodes of some particular elements * \brief Creates a hole in a mesh by doubling the nodes of some particular elements
@ -581,9 +592,9 @@ class SMESH_MeshEditor_i: public POA_SMESH::SMESH_MeshEditor
* \return TRUE if operation has been completed successfully, FALSE otherwise * \return TRUE if operation has been completed successfully, FALSE otherwise
* \sa DoubleNodeGroup(), DoubleNodes() * \sa DoubleNodeGroup(), DoubleNodes()
*/ */
CORBA::Boolean DoubleNodeGroups( const SMESH::ListOfGroups& theElems, CORBA::Boolean DoubleNodeElemGroups( const SMESH::ListOfGroups& theElems,
const SMESH::ListOfGroups& theNodesNot, const SMESH::ListOfGroups& theNodesNot,
const SMESH::ListOfGroups& theAffectedElems ); const SMESH::ListOfGroups& theAffectedElems );
/*! /*!
@ -597,9 +608,9 @@ class SMESH_MeshEditor_i: public POA_SMESH::SMESH_MeshEditor
* \return TRUE if operation has been completed successfully, FALSE otherwise * \return TRUE if operation has been completed successfully, FALSE otherwise
* \sa DoubleNodeGroupInRegion(), DoubleNodesInRegion() * \sa DoubleNodeGroupInRegion(), DoubleNodesInRegion()
*/ */
CORBA::Boolean DoubleNodeGroupsInRegion( const SMESH::ListOfGroups& theElems, CORBA::Boolean DoubleNodeElemGroupsInRegion( const SMESH::ListOfGroups& theElems,
const SMESH::ListOfGroups& theNodesNot, const SMESH::ListOfGroups& theNodesNot,
GEOM::GEOM_Object_ptr theShape ); GEOM::GEOM_Object_ptr theShape );
/*! /*!
* \brief Generated skin mesh (containing 2D cells) from 3D mesh * \brief Generated skin mesh (containing 2D cells) from 3D mesh

104
src/SMESH_I/SMESH_Mesh_i.cxx
View File

@ -522,41 +522,40 @@ SMESH::Hypothesis_Status SMESH_Mesh_i::RemoveHypothesis(GEOM::GEOM_Object_ptr aS
*/ */
//============================================================================= //=============================================================================
SMESH_Hypothesis::Hypothesis_Status SMESH_Mesh_i::removeHypothesis(GEOM::GEOM_Object_ptr aSubShapeObject, SMESH_Hypothesis::Hypothesis_Status
SMESH::SMESH_Hypothesis_ptr anHyp) SMESH_Mesh_i::removeHypothesis(GEOM::GEOM_Object_ptr aSubShapeObject,
SMESH::SMESH_Hypothesis_ptr anHyp)
{ {
if(MYDEBUG) MESSAGE("removeHypothesis()"); if(MYDEBUG) MESSAGE("removeHypothesis()");
// **** proposer liste de subShape (selection multiple) // **** proposer liste de subShape (selection multiple)
if (CORBA::is_nil(aSubShapeObject) && HasShapeToMesh()) if (CORBA::is_nil(aSubShapeObject) && HasShapeToMesh())
THROW_SALOME_CORBA_EXCEPTION("bad subShape reference", THROW_SALOME_CORBA_EXCEPTION("bad subShape reference", SALOME::BAD_PARAM);
SALOME::BAD_PARAM);
SMESH::SMESH_Hypothesis_var myHyp = SMESH::SMESH_Hypothesis::_narrow(anHyp); SMESH::SMESH_Hypothesis_var myHyp = SMESH::SMESH_Hypothesis::_narrow(anHyp);
if (CORBA::is_nil(myHyp)) if (CORBA::is_nil(myHyp))
THROW_SALOME_CORBA_EXCEPTION("bad hypothesis reference", THROW_SALOME_CORBA_EXCEPTION("bad hypothesis reference", SALOME::BAD_PARAM);
SALOME::BAD_PARAM);
SMESH_Hypothesis::Hypothesis_Status status = SMESH_Hypothesis::HYP_OK; SMESH_Hypothesis::Hypothesis_Status status = SMESH_Hypothesis::HYP_OK;
try try
{ {
TopoDS_Shape myLocSubShape; TopoDS_Shape myLocSubShape;
//use PseudoShape in case if mesh has no shape //use PseudoShape in case if mesh has no shape
if(HasShapeToMesh()) if(HasShapeToMesh())
myLocSubShape = _gen_i->GeomObjectToShape( aSubShapeObject); myLocSubShape = _gen_i->GeomObjectToShape( aSubShapeObject);
else else
myLocSubShape = _impl->GetShapeToMesh(); myLocSubShape = _impl->GetShapeToMesh();
int hypId = myHyp->GetId(); int hypId = myHyp->GetId();
status = _impl->RemoveHypothesis(myLocSubShape, hypId); status = _impl->RemoveHypothesis(myLocSubShape, hypId);
if ( !SMESH_Hypothesis::IsStatusFatal(status) ) // if ( !SMESH_Hypothesis::IsStatusFatal(status) ) EAP: hyp can be used on many subshapes
_mapHypo.erase( hypId ); // _mapHypo.erase( hypId );
} }
catch(SALOME_Exception & S_ex) catch(SALOME_Exception & S_ex)
{ {
THROW_SALOME_CORBA_EXCEPTION(S_ex.what(), SALOME::BAD_PARAM); THROW_SALOME_CORBA_EXCEPTION(S_ex.what(), SALOME::BAD_PARAM);
} }
return status; return status;
} }
//============================================================================= //=============================================================================
@ -572,8 +571,7 @@ throw(SALOME::SALOME_Exception)
Unexpect aCatch(SALOME_SalomeException); Unexpect aCatch(SALOME_SalomeException);
if (MYDEBUG) MESSAGE("GetHypothesisList"); if (MYDEBUG) MESSAGE("GetHypothesisList");
if (_impl->HasShapeToMesh() && CORBA::is_nil(aSubShapeObject)) if (_impl->HasShapeToMesh() && CORBA::is_nil(aSubShapeObject))
THROW_SALOME_CORBA_EXCEPTION("bad subShape reference", THROW_SALOME_CORBA_EXCEPTION("bad subShape reference", SALOME::BAD_PARAM);
SALOME::BAD_PARAM);
SMESH::ListOfHypothesis_var aList = new SMESH::ListOfHypothesis(); SMESH::ListOfHypothesis_var aList = new SMESH::ListOfHypothesis();
@ -669,6 +667,9 @@ void SMESH_Mesh_i::RemoveSubMesh( SMESH::SMESH_subMesh_ptr theSubMesh )
if ( anSO->FindSubObject( aTag, anObj ) && anObj->ReferencedObject( aRef ) ) if ( anSO->FindSubObject( aTag, anObj ) && anObj->ReferencedObject( aRef ) )
aSubShapeObject = GEOM::GEOM_Object::_narrow( aRef->GetObject() ); aSubShapeObject = GEOM::GEOM_Object::_narrow( aRef->GetObject() );
// if ( aSubShapeObject->_is_nil() ) // not published shape (IPAL13617)
// aSubShapeObject = theSubMesh->GetSubShape();
aStudy->NewBuilder()->RemoveObjectWithChildren( anSO ); aStudy->NewBuilder()->RemoveObjectWithChildren( anSO );
// Update Python script // Update Python script
@ -1976,20 +1977,37 @@ void SMESH_Mesh_i::removeSubMesh (SMESH::SMESH_subMesh_ptr theSubMesh,
GEOM::GEOM_Object_ptr theSubShapeObject ) GEOM::GEOM_Object_ptr theSubShapeObject )
{ {
MESSAGE("SMESH_Mesh_i::removeSubMesh()"); MESSAGE("SMESH_Mesh_i::removeSubMesh()");
if ( theSubMesh->_is_nil() || theSubShapeObject->_is_nil() ) if ( theSubMesh->_is_nil() /*|| theSubShapeObject->_is_nil()*/ )
return; return;
try { if ( theSubShapeObject->_is_nil() ) // not published shape (IPAL13617)
SMESH::ListOfHypothesis_var aHypList = GetHypothesisList( theSubShapeObject ); {
for ( int i = 0, n = aHypList->length(); i < n; i++ ) { CORBA::Long shapeId = theSubMesh->GetId();
removeHypothesis( theSubShapeObject, aHypList[i] ); if ( _mapSubMesh.find( shapeId ) != _mapSubMesh.end())
{
TopoDS_Shape S = _mapSubMesh[ shapeId ]->GetSubShape();
if ( !S.IsNull() )
{
list<const SMESHDS_Hypothesis*> hyps = _impl->GetHypothesisList( S );
list<const SMESHDS_Hypothesis*>::const_iterator hyp = hyps.begin();
for ( ; hyp != hyps.end(); ++hyp )
_impl->RemoveHypothesis(S, (*hyp)->GetID());
}
} }
} }
catch( const SALOME::SALOME_Exception& ) { else
INFOS("SMESH_Mesh_i::removeSubMesh(): exception caught!"); {
try {
SMESH::ListOfHypothesis_var aHypList = GetHypothesisList( theSubShapeObject );
for ( int i = 0, n = aHypList->length(); i < n; i++ ) {
removeHypothesis( theSubShapeObject, aHypList[i] );
}
}
catch( const SALOME::SALOME_Exception& ) {
INFOS("SMESH_Mesh_i::removeSubMesh(): exception caught!");
}
removeGeomGroupData( theSubShapeObject );
} }
removeGeomGroupData( theSubShapeObject );
int subMeshId = theSubMesh->GetId(); int subMeshId = theSubMesh->GetId();
_mapSubMesh.erase(subMeshId); _mapSubMesh.erase(subMeshId);
@ -2127,7 +2145,7 @@ throw(SALOME::SALOME_Exception)
void SMESH_Mesh_i::ClearLog() throw(SALOME::SALOME_Exception) void SMESH_Mesh_i::ClearLog() throw(SALOME::SALOME_Exception)
{ {
if(MYDEBUG) MESSAGE("SMESH_Mesh_i::ClearLog"); if(MYDEBUG) MESSAGE("SMESH_Mesh_i::ClearLog");
// **** _impl->ClearLog();
} }
//============================================================================= //=============================================================================

382
src/SMESH_I/SMESH_NoteBook.cxx
View File

@ -239,19 +239,19 @@ void SMESH_NoteBook::ReplaceVariables()
TMeshEditorMap::const_iterator meIt = myMeshEditors.find(aObject); TMeshEditorMap::const_iterator meIt = myMeshEditors.find(aObject);
if(meIt != myMeshEditors.end()) { if(meIt != myMeshEditors.end()) {
TCollection_AsciiString aMesh = (*meIt).second; TCollection_AsciiString aMesh = (*meIt).second;
it = _objectMap.find(aMesh); it = _objectMap.find(aMesh);
} }
} }
if(it == _objectMap.end()) { // additional check for pattern mapping if(it == _objectMap.end()) { // additional check for pattern mapping
if(aMethod.IsEqual("ApplyToMeshFaces") || if(aMethod.IsEqual("ApplyToMeshFaces") ||
aMethod.IsEqual("ApplyToHexahedrons")) aMethod.IsEqual("ApplyToHexahedrons"))
it = _objectMap.find(aCmd->GetArg(1)); it = _objectMap.find(aCmd->GetArg(1));
} }
if(it != _objectMap.end()) { if(it != _objectMap.end()) {
if(MYDEBUG) if(MYDEBUG)
cout << "Found object : " << (*it).first << endl; cout << "Found object : " << (*it).first << endl;
ObjectStates *aStates = (*it).second; ObjectStates *aStates = (*it).second;
// Case for LocalLength hypothesis // Case for LocalLength hypothesis
if(aStates->GetObjectType().IsEqual("LocalLength") && aStates->GetCurrectState().size() >= 2) { if(aStates->GetObjectType().IsEqual("LocalLength") && aStates->GetCurrectState().size() >= 2) {
@ -402,9 +402,9 @@ void SMESH_NoteBook::ReplaceVariables()
} }
else if(aStates->GetObjectType().IsEqual("Mesh")) { else if(aStates->GetObjectType().IsEqual("Mesh")) {
TState aCurrentState = aStates->GetCurrectState(); TState aCurrentState = aStates->GetCurrectState();
int aCurrentStateSize = aCurrentState.size(); int aCurrentStateSize = aCurrentState.size();
if(aMethod.IsEqual("Translate") || if(aMethod.IsEqual("Translate") ||
aMethod.IsEqual("TranslateMakeGroups") || aMethod.IsEqual("TranslateMakeGroups") ||
aMethod.IsEqual("TranslateMakeMesh") || aMethod.IsEqual("TranslateMakeMesh") ||
aMethod.IsEqual("TranslateObject") || aMethod.IsEqual("TranslateObject") ||
@ -419,211 +419,211 @@ void SMESH_NoteBook::ReplaceVariables()
} }
} }
if(anArgIndex > 0) { if(anArgIndex > 0) {
if(aCurrentStateSize == 3) { // translation by dx, dy, dz if(aCurrentStateSize == 3) { // translation by dx, dy, dz
for(int j = 0; j < aCurrentStateSize; j++) { for(int j = 0; j < aCurrentStateSize; j++) {
if(!aCurrentState.at(j).IsEmpty()) { if(!aCurrentState.at(j).IsEmpty()) {
isVariableFound = true; isVariableFound = true;
aCmd->SetArg(anArgIndex+j, aCurrentState.at(j)); aCmd->SetArg(anArgIndex+j, aCurrentState.at(j));
} }
} }
} }
else if(aCurrentStateSize == 6) { // translation by x1, x2, y1, y2, z1, z2 else if(aCurrentStateSize == 6) { // translation by x1, x2, y1, y2, z1, z2
// TODO: limitation until operations on the variables will be introduced // TODO: limitation until operations on the variables will be introduced
/* /*
isVariableFound = true; isVariableFound = true;
for(int j = 0; j < 3; j++) { for(int j = 0; j < 3; j++) {
TCollection_AsciiString anArg = aCmd->GetArg(anArgIndex+j); TCollection_AsciiString anArg = aCmd->GetArg(anArgIndex+j);
TCollection_AsciiString aValue1 = aCurrentState.at(2*j), aValue2 = aCurrentState.at(2*j+1); TCollection_AsciiString aValue1 = aCurrentState.at(2*j), aValue2 = aCurrentState.at(2*j+1);
bool aV1 = !aValue1.IsEmpty(); bool aV1 = !aValue1.IsEmpty();
bool aV2 = !aValue2.IsEmpty(); bool aV2 = !aValue2.IsEmpty();
double aValue, aCurrentValue = anArg.IsRealValue() ? anArg.RealValue() : 0; double aValue, aCurrentValue = anArg.IsRealValue() ? anArg.RealValue() : 0;
if(aV1 && !aV2) { if(aV1 && !aV2) {
if(!GetReal(aValue1, aValue)) if(!GetReal(aValue1, aValue))
aValue = 0; aValue = 0;
aValue2 = TCollection_AsciiString( aValue + aCurrentValue ); aValue2 = TCollection_AsciiString( aValue + aCurrentValue );
} }
else if(!aV1 && aV2) { else if(!aV1 && aV2) {
if(!GetReal(aValue2, aValue)) if(!GetReal(aValue2, aValue))
aValue = 0; aValue = 0;
aValue1 = TCollection_AsciiString( aValue - aCurrentValue ); aValue1 = TCollection_AsciiString( aValue - aCurrentValue );
} }
else if(!aV1 && !aV2) { else if(!aV1 && !aV2) {
aValue1 = TCollection_AsciiString( 0 ); aValue1 = TCollection_AsciiString( 0 );
aValue2 = TCollection_AsciiString( aCurrentValue ); aValue2 = TCollection_AsciiString( aCurrentValue );
} }
aCmd->SetArg(anArgIndex+j, aValue1 + ", " + aValue2 ); aCmd->SetArg(anArgIndex+j, aValue1 + ", " + aValue2 );
} }
*/ */
} }
} }
if(isVariableFound) { if(isVariableFound) {
TCollection_AsciiString aDim; TCollection_AsciiString aDim;
if(aCurrentStateSize == 6) if(aCurrentStateSize == 6)
aDim = "6"; aDim = "6";
aCmd->SetArg(anArgIndex - 1, TCollection_AsciiString(SMESH_2smeshpy::SmeshpyName())+".PointStructStr"+aDim); aCmd->SetArg(anArgIndex - 1, TCollection_AsciiString(SMESH_2smeshpy::SmeshpyName())+".PointStructStr"+aDim);
aCmd->SetArg(anArgIndex - 2, TCollection_AsciiString(SMESH_2smeshpy::SmeshpyName())+".DirStructStr"); aCmd->SetArg(anArgIndex - 2, TCollection_AsciiString(SMESH_2smeshpy::SmeshpyName())+".DirStructStr");
} }
aStates->IncrementState(); aStates->IncrementState();
} }
else if(aMethod.IsEqual("Rotate") || else if(aMethod.IsEqual("Rotate") ||
aMethod.IsEqual("RotateMakeGroups") || aMethod.IsEqual("RotateMakeGroups") ||
aMethod.IsEqual("RotateMakeMesh") || aMethod.IsEqual("RotateMakeMesh") ||
aMethod.IsEqual("RotateObject") || aMethod.IsEqual("RotateObject") ||
aMethod.IsEqual("RotateObjectMakeGroups") || aMethod.IsEqual("RotateObjectMakeGroups") ||
aMethod.IsEqual("RotateObjectMakeMesh") || aMethod.IsEqual("RotateObjectMakeMesh") ||
aMethod.IsEqual("RotationSweep") || aMethod.IsEqual("RotationSweep") ||
aMethod.IsEqual("RotationSweepObject") || aMethod.IsEqual("RotationSweepObject") ||
aMethod.IsEqual("RotationSweepObject1D") || aMethod.IsEqual("RotationSweepObject1D") ||
aMethod.IsEqual("RotationSweepObject2D") || aMethod.IsEqual("RotationSweepObject2D") ||
aMethod.IsEqual("RotationSweepMakeGroups") || aMethod.IsEqual("RotationSweepMakeGroups") ||
aMethod.IsEqual("RotationSweepObjectMakeGroups") || aMethod.IsEqual("RotationSweepObjectMakeGroups") ||
aMethod.IsEqual("RotationSweepObject1DMakeGroups") || aMethod.IsEqual("RotationSweepObject1DMakeGroups") ||
aMethod.IsEqual("RotationSweepObject2DMakeGroups") || aMethod.IsEqual("RotationSweepObject2DMakeGroups") ||
aMethod.IsEqual("Mirror") || aMethod.IsEqual("Mirror") ||
aMethod.IsEqual("MirrorMakeMesh") || aMethod.IsEqual("MirrorMakeMesh") ||
aMethod.IsEqual("MirrorMakeGroups") || aMethod.IsEqual("MirrorMakeGroups") ||
aMethod.IsEqual("MirrorObject") || aMethod.IsEqual("MirrorObject") ||
aMethod.IsEqual("MirrorObjectMakeMesh") || aMethod.IsEqual("MirrorObjectMakeMesh") ||
aMethod.IsEqual("MirrorObjectMakeGroups")) { aMethod.IsEqual("MirrorObjectMakeGroups")) {
bool isSubstitute = false; bool isSubstitute = false;
int anArgIndex = 0; int anArgIndex = 0;
for(int i = 1, n = aCmd->GetNbArgs(); i <= n; i++) { for(int i = 1, n = aCmd->GetNbArgs(); i <= n; i++) {
if(aCmd->GetArg(i).IsEqual("SMESH.AxisStruct")) { if(aCmd->GetArg(i).IsEqual("SMESH.AxisStruct")) {
anArgIndex = i+1; anArgIndex = i+1;
break; break;
} }
} }
if(anArgIndex > 0) { if(anArgIndex > 0) {
for(int j = 0; j < aCurrentStateSize; j++) { for(int j = 0; j < aCurrentStateSize; j++) {
if(!aCurrentState.at(j).IsEmpty()) { if(!aCurrentState.at(j).IsEmpty()) {
if(j < 6) // 0-5 - axis struct, 6 - angle (rotation & sweep), 7-8 - nbSteps and tolerance (sweep) if(j < 6) // 0-5 - axis struct, 6 - angle (rotation & sweep), 7-8 - nbSteps and tolerance (sweep)
isSubstitute = true; isSubstitute = true;
aCmd->SetArg(anArgIndex+j, aCurrentState.at(j)); aCmd->SetArg(anArgIndex+j, aCurrentState.at(j));
} }
} }
} }
if(isSubstitute) if(isSubstitute)
aCmd->SetArg(anArgIndex - 1, TCollection_AsciiString(SMESH_2smeshpy::SmeshpyName())+".AxisStructStr"); aCmd->SetArg(anArgIndex - 1, TCollection_AsciiString(SMESH_2smeshpy::SmeshpyName())+".AxisStructStr");
aStates->IncrementState(); aStates->IncrementState();
} }
else if(aMethod.IsEqual("AddNode") || else if(aMethod.IsEqual("AddNode") ||
aMethod.IsEqual("MoveClosestNodeToPoint")) { aMethod.IsEqual("MoveClosestNodeToPoint")) {
for(int j = 0; j < aCurrentStateSize; j++) { for(int j = 0; j < aCurrentStateSize; j++) {
if(!aCurrentState.at(j).IsEmpty()) if(!aCurrentState.at(j).IsEmpty())
aCmd->SetArg(j+1, aCurrentState.at(j)); aCmd->SetArg(j+1, aCurrentState.at(j));
} }
aStates->IncrementState(); aStates->IncrementState();
} }
else if(aMethod.IsEqual("MoveNode")) { else if(aMethod.IsEqual("MoveNode")) {
for(int j = 0; j < aCurrentStateSize; j++) { for(int j = 0; j < aCurrentStateSize; j++) {
if(!aCurrentState.at(j).IsEmpty()) if(!aCurrentState.at(j).IsEmpty())
aCmd->SetArg(j+2, aCurrentState.at(j)); aCmd->SetArg(j+2, aCurrentState.at(j));
} }
aStates->IncrementState(); aStates->IncrementState();
} }
else if(aMethod.IsEqual("ExtrusionSweep") || else if(aMethod.IsEqual("ExtrusionSweep") ||
aMethod.IsEqual("ExtrusionSweepObject") || aMethod.IsEqual("ExtrusionSweepObject") ||
aMethod.IsEqual("ExtrusionSweepObject1D") || aMethod.IsEqual("ExtrusionSweepObject1D") ||
aMethod.IsEqual("ExtrusionSweepObject2D") || aMethod.IsEqual("ExtrusionSweepObject2D") ||
aMethod.IsEqual("ExtrusionSweepMakeGroups") || aMethod.IsEqual("ExtrusionSweepMakeGroups") ||
aMethod.IsEqual("ExtrusionSweepObjectMakeGroups") || aMethod.IsEqual("ExtrusionSweepObjectMakeGroups") ||
aMethod.IsEqual("ExtrusionSweepObject1DMakeGroups") || aMethod.IsEqual("ExtrusionSweepObject1DMakeGroups") ||
aMethod.IsEqual("ExtrusionSweepObject2DMakeGroups")) { aMethod.IsEqual("ExtrusionSweepObject2DMakeGroups")) {
bool isSubstitute = false; bool isSubstitute = false;
int anArgIndex = 0; int anArgIndex = 0;
for(int i = 1, n = aCmd->GetNbArgs(); i <= n; i++) { for(int i = 1, n = aCmd->GetNbArgs(); i <= n; i++) {
if(aCmd->GetArg(i).IsEqual("SMESH.PointStruct")) { if(aCmd->GetArg(i).IsEqual("SMESH.PointStruct")) {
anArgIndex = i+1; anArgIndex = i+1;
break; break;
} }
} }
if(anArgIndex > 0) { if(anArgIndex > 0) {
for(int j = 0; j < aCurrentStateSize; j++) { for(int j = 0; j < aCurrentStateSize; j++) {
if(!aCurrentState.at(j).IsEmpty()) { if(!aCurrentState.at(j).IsEmpty()) {
if(j < 3) // 0-2 - dir struct, 3 - number of steps if(j < 3) // 0-2 - dir struct, 3 - number of steps
isSubstitute = true; isSubstitute = true;
aCmd->SetArg(anArgIndex+j, aCurrentState.at(j)); aCmd->SetArg(anArgIndex+j, aCurrentState.at(j));
} }
} }
} }
if(isSubstitute) { if(isSubstitute) {
aCmd->SetArg(anArgIndex - 1, TCollection_AsciiString(SMESH_2smeshpy::SmeshpyName())+".PointStructStr"); aCmd->SetArg(anArgIndex - 1, TCollection_AsciiString(SMESH_2smeshpy::SmeshpyName())+".PointStructStr");
aCmd->SetArg(anArgIndex - 2, TCollection_AsciiString(SMESH_2smeshpy::SmeshpyName())+".DirStructStr"); aCmd->SetArg(anArgIndex - 2, TCollection_AsciiString(SMESH_2smeshpy::SmeshpyName())+".DirStructStr");
} }
aStates->IncrementState(); aStates->IncrementState();
} }
else if(aMethod.IsEqual("ExtrusionAlongPath") || else if(aMethod.IsEqual("ExtrusionAlongPath") ||
aMethod.IsEqual("ExtrusionAlongPathObject") || aMethod.IsEqual("ExtrusionAlongPathObject") ||
aMethod.IsEqual("ExtrusionAlongPathObject1D") || aMethod.IsEqual("ExtrusionAlongPathObject1D") ||
aMethod.IsEqual("ExtrusionAlongPathObject2D") || aMethod.IsEqual("ExtrusionAlongPathObject2D") ||
aMethod.IsEqual("ExtrusionAlongPathMakeGroups") || aMethod.IsEqual("ExtrusionAlongPathMakeGroups") ||
aMethod.IsEqual("ExtrusionAlongPathObjectMakeGroups") || aMethod.IsEqual("ExtrusionAlongPathObjectMakeGroups") ||
aMethod.IsEqual("ExtrusionAlongPathObject1DMakeGroups") || aMethod.IsEqual("ExtrusionAlongPathObject1DMakeGroups") ||
aMethod.IsEqual("ExtrusionAlongPathObject2DMakeGroups") || aMethod.IsEqual("ExtrusionAlongPathObject2DMakeGroups") ||
/* workaround for a bug in the command parsing algorithm */ /* workaround for a bug in the command parsing algorithm */
aCmd->GetString().Search("ExtrusionAlongPathMakeGroups") != -1 || aCmd->GetString().Search("ExtrusionAlongPathMakeGroups") != -1 ||
aCmd->GetString().Search("ExtrusionAlongPathObjectMakeGroups") != -1 || aCmd->GetString().Search("ExtrusionAlongPathObjectMakeGroups") != -1 ||
aCmd->GetString().Search("ExtrusionAlongPathObject1DMakeGroups") != -1 || aCmd->GetString().Search("ExtrusionAlongPathObject1DMakeGroups") != -1 ||
aCmd->GetString().Search("ExtrusionAlongPathObject2DMakeGroups") != -1 ) { aCmd->GetString().Search("ExtrusionAlongPathObject2DMakeGroups") != -1 ) {
int aNbAngles = aCurrentStateSize-3; // State looks like "Angle1:...:AngleN:X:Y:Z" int aNbAngles = aCurrentStateSize-3; // State looks like "Angle1:...:AngleN:X:Y:Z"
bool isSubstitute = false; bool isSubstitute = false;
int anArgIndex = 0; int anArgIndex = 0;
for(int i = 1, n = aCmd->GetNbArgs(); i <= n; i++) { for(int i = 1, n = aCmd->GetNbArgs(); i <= n; i++) {
if(aCmd->GetArg(i).IsEqual("SMESH.PointStruct")) { if(aCmd->GetArg(i).IsEqual("SMESH.PointStruct")) {
anArgIndex = i-1-aNbAngles; anArgIndex = i-1-aNbAngles;
break; break;
} }
} }
if(anArgIndex > 0) { if(anArgIndex > 0) {
int j = 0; int j = 0;
for(; j < aNbAngles; j++) { for(; j < aNbAngles; j++) {
if(!aCurrentState.at(j).IsEmpty()) { if(!aCurrentState.at(j).IsEmpty()) {
aCmd->SetArg(anArgIndex+j-1, aCurrentState.at(j)); aCmd->SetArg(anArgIndex+j-1, aCurrentState.at(j));
} }
} }
for(; j < aNbAngles+3; j++) { for(; j < aNbAngles+3; j++) {
if(!aCurrentState.at(j).IsEmpty()) { if(!aCurrentState.at(j).IsEmpty()) {
isSubstitute = true; isSubstitute = true;
aCmd->SetArg(anArgIndex+j+2, aCurrentState.at(j)); aCmd->SetArg(anArgIndex+j+2, aCurrentState.at(j));
} }
} }
} }
if(isSubstitute) if(isSubstitute)
aCmd->SetArg(anArgIndex + aNbAngles + 1, aCmd->SetArg(anArgIndex + aNbAngles + 1,
TCollection_AsciiString(SMESH_2smeshpy::SmeshpyName())+".PointStructStr"); TCollection_AsciiString(SMESH_2smeshpy::SmeshpyName())+".PointStructStr");
aStates->IncrementState(); aStates->IncrementState();
} }
else if(aMethod.IsEqual("TriToQuad") || else if(aMethod.IsEqual("TriToQuad") ||
aMethod.IsEqual("Concatenate") || aMethod.IsEqual("Concatenate") ||
aMethod.IsEqual("ConcatenateWithGroups")) { aMethod.IsEqual("ConcatenateWithGroups")) {
if(aCurrentStateSize && !aCurrentState.at(0).IsEmpty()) if(aCurrentStateSize && !aCurrentState.at(0).IsEmpty())
aCmd->SetArg(aCmd->GetNbArgs(), aCurrentState.at(0)); aCmd->SetArg(aCmd->GetNbArgs(), aCurrentState.at(0));
aStates->IncrementState(); aStates->IncrementState();
} }
else if(aMethod.IsEqual("Smooth") || else if(aMethod.IsEqual("Smooth") ||
aMethod.IsEqual("SmoothObject") || aMethod.IsEqual("SmoothObject") ||
aMethod.IsEqual("SmoothParametric") || aMethod.IsEqual("SmoothParametric") ||
aMethod.IsEqual("SmoothParametricObject")) { aMethod.IsEqual("SmoothParametricObject")) {
int anArgIndex = aCmd->GetNbArgs() - 2; int anArgIndex = aCmd->GetNbArgs() - 2;
for(int j = 0; j < aCurrentStateSize; j++) { for(int j = 0; j < aCurrentStateSize; j++) {
if(!aCurrentState.at(j).IsEmpty()) if(!aCurrentState.at(j).IsEmpty())
aCmd->SetArg(anArgIndex+j, aCurrentState.at(j)); aCmd->SetArg(anArgIndex+j, aCurrentState.at(j));
} }
aStates->IncrementState(); aStates->IncrementState();
} }
else if(aMethod.IsEqual("ApplyToMeshFaces") || else if(aMethod.IsEqual("ApplyToMeshFaces") ||
aMethod.IsEqual("ApplyToHexahedrons")) { aMethod.IsEqual("ApplyToHexahedrons")) {
int anArgIndex = aCmd->GetNbArgs()-1; int anArgIndex = aCmd->GetNbArgs()-1;
for(int j = 0; j < aCurrentStateSize; j++) for(int j = 0; j < aCurrentStateSize; j++)
if(!aCurrentState.at(j).IsEmpty()) if(!aCurrentState.at(j).IsEmpty())
aCmd->SetArg(anArgIndex+j, aCurrentState.at(j)); aCmd->SetArg(anArgIndex+j, aCurrentState.at(j));
aStates->IncrementState(); aStates->IncrementState();
} }
} }
} }
else { else {
if(MYDEBUG) if(MYDEBUG)
cout << "Object not found" << endl; cout << "Object not found" << endl;
} }
if(MYDEBUG) { if(MYDEBUG) {
cout<<"Command after: "<< aCmd->GetString()<<endl; cout<<"Command after: "<< aCmd->GetString()<<endl;
@ -716,7 +716,7 @@ void SMESH_NoteBook::AddCommand(const TCollection_AsciiString& theString)
if ( aCommand->GetMethod() == "GetMeshEditor" ) { // MeshEditor creation if ( aCommand->GetMethod() == "GetMeshEditor" ) { // MeshEditor creation
myMeshEditors.insert( make_pair( aCommand->GetResultValue(), myMeshEditors.insert( make_pair( aCommand->GetResultValue(),
aCommand->GetObject() ) ); aCommand->GetObject() ) );
} }
} }

10
src/SMESH_I/SMESH_Pattern_i.cxx
View File

@ -149,7 +149,7 @@ CORBA::Boolean SMESH_Pattern_i::LoadFromFace(SMESH::SMESH_Mesh_ptr theMesh,
return false; return false;
// Update Python script // Update Python script
TPythonDump() << "isDone = pattern.LoadFromFace( " << theMesh << ", " TPythonDump() << "isDone = pattern.LoadFromFace( " << theMesh << ".GetMesh(), "
<< theFace << ", " << theProject << " )"; << theFace << ", " << theProject << " )";
addErrorCode( "LoadFromFace" ); addErrorCode( "LoadFromFace" );
@ -180,7 +180,7 @@ CORBA::Boolean SMESH_Pattern_i::LoadFrom3DBlock(SMESH::SMESH_Mesh_ptr theMesh,
return false; return false;
// Update Python script // Update Python script
TPythonDump() << "isDone = pattern.LoadFrom3DBlock( " << theMesh << ", " << theBlock << " )"; TPythonDump() << "isDone = pattern.LoadFrom3DBlock( " << theMesh << ".GetMesh(), " << theBlock << " )";
addErrorCode( "LoadFrom3DBlock" ); addErrorCode( "LoadFrom3DBlock" );
return myPattern.Load( aMesh, TopoDS::Shell( exp.Current() )); return myPattern.Load( aMesh, TopoDS::Shell( exp.Current() ));
@ -316,7 +316,7 @@ SMESH::point_array*
} }
// Update Python script // Update Python script
TPythonDump() << "pattern.ApplyToMeshFaces( " << theMesh << ", " TPythonDump() << "pattern.ApplyToMeshFaces( " << theMesh << ".GetMesh(), "
<< theFacesIDs << ", " << theFacesIDs << ", "
<< theNodeIndexOnKeyPoint1 << ", " << theReverse << " )"; << theNodeIndexOnKeyPoint1 << ", " << theReverse << " )";
@ -361,7 +361,7 @@ SMESH::point_array*
} }
// Update Python script // Update Python script
TPythonDump() << "pattern.ApplyToHexahedrons( " << theMesh << ", " TPythonDump() << "pattern.ApplyToHexahedrons( " << theMesh << ".GetMesh(), "
<< theVolumesIDs << ", " << theVolumesIDs << ", "
<< theNode000Index << ", " << theNode001Index << " )"; << theNode000Index << ", " << theNode001Index << " )";
@ -382,7 +382,7 @@ CORBA::Boolean SMESH_Pattern_i::MakeMesh (SMESH::SMESH_Mesh_ptr theMesh,
return false; return false;
// Update Python script // Update Python script
TPythonDump() << "isDone = pattern.MakeMesh( " << theMesh << ", " TPythonDump() << "isDone = pattern.MakeMesh( " << theMesh << ".GetMesh(), "
<< CreatePolygons << ", " << CreatePolyedrs << " )"; << CreatePolygons << ", " << CreatePolyedrs << " )";
addErrorCode( "MakeMesh" ); addErrorCode( "MakeMesh" );

2
src/SMESH_I/SMESH_PythonDump.hxx
View File

@ -56,7 +56,7 @@ public:
static TCollection_AsciiString static TCollection_AsciiString
ConvertScript(const TCollection_AsciiString& theScript, ConvertScript(const TCollection_AsciiString& theScript,
Resource_DataMapOfAsciiStringAsciiString& theEntry2AccessorMethod, Resource_DataMapOfAsciiStringAsciiString& theEntry2AccessorMethod,
Resource_DataMapOfAsciiStringAsciiString& theObjectNames); Resource_DataMapOfAsciiStringAsciiString& theObjectNames);
/*! /*!
* \brief Return the name of the python file wrapping IDL API * \brief Return the name of the python file wrapping IDL API

16
src/SMESH_I/SMESH_subMesh_i.cxx
View File

@ -59,9 +59,9 @@ SMESH_subMesh_i::SMESH_subMesh_i()
//============================================================================= //=============================================================================
SMESH_subMesh_i::SMESH_subMesh_i( PortableServer::POA_ptr thePOA, SMESH_subMesh_i::SMESH_subMesh_i( PortableServer::POA_ptr thePOA,
SMESH_Gen_i* gen_i, SMESH_Gen_i* gen_i,
SMESH_Mesh_i* mesh_i, SMESH_Mesh_i* mesh_i,
int localId ) int localId )
: SALOME::GenericObj_i( thePOA ) : SALOME::GenericObj_i( thePOA )
{ {
MESSAGE("SMESH_subMesh_i::SMESH_subMesh_i"); MESSAGE("SMESH_subMesh_i::SMESH_subMesh_i");
@ -458,11 +458,11 @@ GEOM::GEOM_Object_ptr SMESH_subMesh_i::GetSubShape()
TopoDS_Shape S = _mesh_i->_mapSubMesh[ _localId ]->GetSubShape(); TopoDS_Shape S = _mesh_i->_mapSubMesh[ _localId ]->GetSubShape();
if ( !S.IsNull() ) { if ( !S.IsNull() ) {
aShapeObj = _gen_i->ShapeToGeomObject( S ); aShapeObj = _gen_i->ShapeToGeomObject( S );
//mzn: N7PAL16232, N7PAL16233 //mzn: N7PAL16232, N7PAL16233
//In some cases it's possible that GEOM_Client contains the shape same to S, but //In some cases it's possible that GEOM_Client contains the shape same to S, but
//with another orientation. //with another orientation.
if (aShapeObj->_is_nil()) if (aShapeObj->_is_nil())
aShapeObj = _gen_i->ShapeToGeomObject( S.Reversed() ); aShapeObj = _gen_i->ShapeToGeomObject( S.Reversed() );
} }
} }
} }

4
src/SMESH_I/SMESH_subMesh_i.hxx
View File

@ -48,8 +48,8 @@ public:
SMESH_subMesh_i(); SMESH_subMesh_i();
SMESH_subMesh_i( PortableServer::POA_ptr thePOA, SMESH_subMesh_i( PortableServer::POA_ptr thePOA,
SMESH_Gen_i* gen_i, SMESH_Gen_i* gen_i,
SMESH_Mesh_i* mesh_i, SMESH_Mesh_i* mesh_i,
int localId ); int localId );
~SMESH_subMesh_i(); ~SMESH_subMesh_i();
CORBA::Long GetNumberOfElements() CORBA::Long GetNumberOfElements()

2
src/SMESH_SWIG/SMESH_test.py
View File

@ -130,5 +130,5 @@ for a in log:
i2 = a.indexes[ii] i2 = a.indexes[ii]
ii = ii+1 ii = ii+1
i3 = a.indexes[ii] i3 = a.indexes[ii]
#ii = ii+1 ii = ii+1
print "AddTriangle %i - %i %i %i" % (ind, i1, i2, i3) print "AddTriangle %i - %i %i %i" % (ind, i1, i2, i3)

410
src/SMESH_SWIG/smeshDC.py
View File

@ -108,6 +108,38 @@ except ImportError:
noNETGENPlugin = 1 noNETGENPlugin = 1
pass pass
# import GHS3DPlugin module if possible
noGHS3DPlugin = 0
try:
import GHS3DPlugin
except ImportError:
noGHS3DPlugin = 1
pass
# import GHS3DPRLPlugin module if possible
noGHS3DPRLPlugin = 0
try:
import GHS3DPRLPlugin
except ImportError:
noGHS3DPRLPlugin = 1
pass
# import HexoticPlugin module if possible
noHexoticPlugin = 0
try:
import HexoticPlugin
except ImportError:
noHexoticPlugin = 1
pass
# import BLSURFPlugin module if possible
noBLSURFPlugin = 0
try:
import BLSURFPlugin
except ImportError:
noBLSURFPlugin = 1
pass
## @addtogroup l1_auxiliary ## @addtogroup l1_auxiliary
## @{ ## @{
@ -149,7 +181,10 @@ VeryFine = 4
Custom = 5 Custom = 5
# Optimization level of GHS3D # Optimization level of GHS3D
# V3.1
None_Optimization, Light_Optimization, Medium_Optimization, Strong_Optimization = 0,1,2,3 None_Optimization, Light_Optimization, Medium_Optimization, Strong_Optimization = 0,1,2,3
# V4.1 (partialy redefines V3.1). Issue 0020574
None_Optimization, Light_Optimization, Standard_Optimization, StandardPlus_Optimization, Strong_Optimization = 0,1,2,3,4
# Topology treatment way of BLSURF # Topology treatment way of BLSURF
FromCAD, PreProcess, PreProcessPlus = 0,1,2 FromCAD, PreProcess, PreProcessPlus = 0,1,2
@ -403,6 +438,25 @@ def TreatHypoStatus(status, hypName, geomName, isAlgo):
print hypName, "was not assigned to",geomName,":", reason print hypName, "was not assigned to",geomName,":", reason
pass pass
## Check meshing plugin availability
def CheckPlugin(plugin):
if plugin == NETGEN and noNETGENPlugin:
print "Warning: NETGENPlugin module unavailable"
return False
elif plugin == GHS3D and noGHS3DPlugin:
print "Warning: GHS3DPlugin module unavailable"
return False
elif plugin == GHS3DPRL and noGHS3DPRLPlugin:
print "Warning: GHS3DPRLPlugin module unavailable"
return False
elif plugin == Hexotic and noHexoticPlugin:
print "Warning: HexoticPlugin module unavailable"
return False
elif plugin == BLSURF and noBLSURFPlugin:
print "Warning: BLSURFPlugin module unavailable"
return False
return True
# end of l1_auxiliary # end of l1_auxiliary
## @} ## @}
@ -756,12 +810,26 @@ class smeshDC(SMESH._objref_SMESH_Gen):
print "Error: given parameter is not numerucal functor type." print "Error: given parameter is not numerucal functor type."
## Creates hypothesis ## Creates hypothesis
# @param # @param theHType mesh hypothesis type (string)
# @param # @param theLibName mesh plug-in library name
# @return created hypothesis instance # @return created hypothesis instance
def CreateHypothesis(self, theHType, theLibName="libStdMeshersEngine.so"): def CreateHypothesis(self, theHType, theLibName="libStdMeshersEngine.so"):
return SMESH._objref_SMESH_Gen.CreateHypothesis(self, theHType, theLibName ) return SMESH._objref_SMESH_Gen.CreateHypothesis(self, theHType, theLibName )
## Gets the mesh stattistic
# @return dictionary type element - count of elements
# @ingroup l1_meshinfo
def GetMeshInfo(self, obj):
if isinstance( obj, Mesh ):
obj = obj.GetMesh()
d = {}
if hasattr(obj, "_narrow") and obj._narrow(SMESH.SMESH_IDSource):
values = obj.GetMeshInfo()
for i in range(SMESH.Entity_Last._v):
if i < len(values): d[SMESH.EntityType._item(i)]=values[i]
pass
return d
import omniORB import omniORB
#Registering the new proxy for SMESH_Gen #Registering the new proxy for SMESH_Gen
omniORB.registerObjref(SMESH._objref_SMESH_Gen._NP_RepositoryId, smeshDC) omniORB.registerObjref(SMESH._objref_SMESH_Gen._NP_RepositoryId, smeshDC)
@ -1252,6 +1320,8 @@ class Mesh:
# Exports the mesh in a file in MED format and chooses the \a version of MED format # Exports the mesh in a file in MED format and chooses the \a version of MED format
# @param f the file name # @param f the file name
# @param version values are SMESH.MED_V2_1, SMESH.MED_V2_2 # @param version values are SMESH.MED_V2_1, SMESH.MED_V2_2
# @param opt boolean parameter for creating/not creating
# the groups Group_On_All_Nodes, Group_On_All_Faces, ...
# @ingroup l2_impexp # @ingroup l2_impexp
def ExportToMED(self, f, version, opt=0): def ExportToMED(self, f, version, opt=0):
self.mesh.ExportToMED(f, opt, version) self.mesh.ExportToMED(f, opt, version)
@ -1323,19 +1393,37 @@ class Mesh:
elif tgeo == "SHELL": elif tgeo == "SHELL":
typ = VOLUME typ = VOLUME
elif tgeo == "COMPOUND": elif tgeo == "COMPOUND":
if len( self.geompyD.GetObjectIDs( grp )) == 0: try: # it raises on a compound of compounds
print "Mesh.Group: empty geometric group", GetName( grp ) if len( self.geompyD.GetObjectIDs( grp )) == 0:
return 0 print "Mesh.Group: empty geometric group", GetName( grp )
tgeo = self.geompyD.GetType(grp) return 0
if tgeo == geompyDC.ShapeType["VERTEX"]: pass
typ = NODE except:
elif tgeo == geompyDC.ShapeType["EDGE"]: pass
typ = EDGE if grp.GetType() == 37: # GEOMImpl_Types.hxx: #define GEOM_GROUP 37
elif tgeo == geompyDC.ShapeType["FACE"]: # group
typ = FACE tgeo = self.geompyD.GetType(grp)
elif tgeo == geompyDC.ShapeType["SOLID"]: if tgeo == geompyDC.ShapeType["VERTEX"]:
typ = VOLUME typ = NODE
elif tgeo == geompyDC.ShapeType["EDGE"]:
typ = EDGE
elif tgeo == geompyDC.ShapeType["FACE"]:
typ = FACE
elif tgeo == geompyDC.ShapeType["SOLID"]:
typ = VOLUME
pass
pass
else:
# just a compound
for elemType, shapeType in [[VOLUME,"SOLID"],[FACE,"FACE"],
[EDGE,"EDGE"],[NODE,"VERTEX"]]:
if self.geompyD.SubShapeAll(grp,geompyDC.ShapeType[shapeType]):
typ = elemType
break
pass
pass
pass
pass
if typ == None: if typ == None:
print "Mesh.Group: bad first argument: expected a group, a vertex, an edge, a face or a solid" print "Mesh.Group: bad first argument: expected a group, a vertex, an edge, a face or a solid"
return 0 return 0
@ -1596,13 +1684,7 @@ class Mesh:
# @ingroup l1_meshinfo # @ingroup l1_meshinfo
def GetMeshInfo(self, obj = None): def GetMeshInfo(self, obj = None):
if not obj: obj = self.mesh if not obj: obj = self.mesh
d = {} return self.smeshpyD.GetMeshInfo(obj)
if hasattr(obj, "_narrow") and obj._narrow(SMESH.SMESH_IDSource):
values = obj.GetMeshInfo()
for i in range(SMESH.Entity_Last._v):
if i < len(values): d[SMESH.EntityType._item(i)]=values[i]
pass
return d
## Returns the number of nodes in the mesh ## Returns the number of nodes in the mesh
# @return an integer value # @return an integer value
@ -2128,6 +2210,8 @@ class Mesh:
# @param x the X coordinate of a point # @param x the X coordinate of a point
# @param y the Y coordinate of a point # @param y the Y coordinate of a point
# @param z the Z coordinate of a point # @param z the Z coordinate of a point
# @param NodeID if specified (>0), the node with this ID is moved,
# otherwise, the node closest to point (@a x,@a y,@a z) is moved
# @return the ID of a node # @return the ID of a node
# @ingroup l2_modif_throughp # @ingroup l2_modif_throughp
def MoveClosestNodeToPoint(self, x, y, z, NodeID): def MoveClosestNodeToPoint(self, x, y, z, NodeID):
@ -2814,7 +2898,7 @@ class Mesh:
HasRefPoint, RefPoint, MakeGroups, ElemType) HasRefPoint, RefPoint, MakeGroups, ElemType)
else: else:
if isinstance(Base,Mesh): if isinstance(Base,Mesh):
return self.editor.ExtrusionAlongPathObjX(Base.GetMesh(), Path, NodeStart, return self.editor.ExtrusionAlongPathObjX(Base, Path, NodeStart,
HasAngles, Angles, LinearVariation, HasAngles, Angles, LinearVariation,
HasRefPoint, RefPoint, MakeGroups, ElemType) HasRefPoint, RefPoint, MakeGroups, ElemType)
else: else:
@ -3275,6 +3359,8 @@ class Mesh:
# @return a list of groups of equal elements # @return a list of groups of equal elements
# @ingroup l2_modif_trsf # @ingroup l2_modif_trsf
def FindEqualElements (self, MeshOrSubMeshOrGroup): def FindEqualElements (self, MeshOrSubMeshOrGroup):
if ( isinstance( MeshOrSubMeshOrGroup, Mesh )):
MeshOrSubMeshOrGroup = MeshOrSubMeshOrGroup.GetMesh()
return self.editor.FindEqualElements(MeshOrSubMeshOrGroup) return self.editor.FindEqualElements(MeshOrSubMeshOrGroup)
## Merges elements in each given group. ## Merges elements in each given group.
@ -3352,6 +3438,43 @@ class Mesh:
# @ingroup l1_auxiliary # @ingroup l1_auxiliary
def GetLastCreatedElems(self): def GetLastCreatedElems(self):
return self.editor.GetLastCreatedElems() return self.editor.GetLastCreatedElems()
## Creates a hole in a mesh by doubling the nodes of some particular elements
# @param theNodes identifiers of nodes to be doubled
# @param theModifiedElems identifiers of elements to be updated by the new (doubled)
# nodes. If list of element identifiers is empty then nodes are doubled but
# they not assigned to elements
# @return TRUE if operation has been completed successfully, FALSE otherwise
# @ingroup l2_modif_edit
def DoubleNodes(self, theNodes, theModifiedElems):
return self.editor.DoubleNodes(theNodes, theModifiedElems)
## Creates a hole in a mesh by doubling the nodes of some particular elements
# This method provided for convenience works as DoubleNodes() described above.
# @param theNodes identifiers of node to be doubled
# @param theModifiedElems identifiers of elements to be updated
# @return TRUE if operation has been completed successfully, FALSE otherwise
# @ingroup l2_modif_edit
def DoubleNode(self, theNodeId, theModifiedElems):
return self.editor.DoubleNode(theNodeId, theModifiedElems)
## Creates a hole in a mesh by doubling the nodes of some particular elements
# This method provided for convenience works as DoubleNodes() described above.
# @param theNodes group of nodes to be doubled
# @param theModifiedElems group of elements to be updated.
# @return TRUE if operation has been completed successfully, FALSE otherwise
# @ingroup l2_modif_edit
def DoubleNodeGroup(self, theNodes, theModifiedElems):
return self.editor.DoubleNodeGroup(theNodes, theModifiedElems)
## Creates a hole in a mesh by doubling the nodes of some particular elements
# This method provided for convenience works as DoubleNodes() described above.
# @param theNodes list of groups of nodes to be doubled
# @param theModifiedElems list of groups of elements to be updated.
# @return TRUE if operation has been completed successfully, FALSE otherwise
# @ingroup l2_modif_edit
def DoubleNodeGroups(self, theNodes, theModifiedElems):
return self.editor.DoubleNodeGroups(theNodes, theModifiedElems)
## Creates a hole in a mesh by doubling the nodes of some particular elements ## Creates a hole in a mesh by doubling the nodes of some particular elements
# @param theElems - the list of elements (edges or faces) to be replicated # @param theElems - the list of elements (edges or faces) to be replicated
@ -3361,8 +3484,8 @@ class Mesh:
# replicated nodes should be associated to. # replicated nodes should be associated to.
# @return TRUE if operation has been completed successfully, FALSE otherwise # @return TRUE if operation has been completed successfully, FALSE otherwise
# @ingroup l2_modif_edit # @ingroup l2_modif_edit
def DoubleNodes(self, theElems, theNodesNot, theAffectedElems): def DoubleNodeElem(self, theElems, theNodesNot, theAffectedElems):
return self.editor.DoubleNodes(theElems, theNodesNot, theAffectedElems) return self.editor.DoubleNodeElem(theElems, theNodesNot, theAffectedElems)
## Creates a hole in a mesh by doubling the nodes of some particular elements ## Creates a hole in a mesh by doubling the nodes of some particular elements
# @param theElems - the list of elements (edges or faces) to be replicated # @param theElems - the list of elements (edges or faces) to be replicated
@ -3373,8 +3496,8 @@ class Mesh:
# The replicated nodes should be associated to affected elements. # The replicated nodes should be associated to affected elements.
# @return TRUE if operation has been completed successfully, FALSE otherwise # @return TRUE if operation has been completed successfully, FALSE otherwise
# @ingroup l2_modif_edit # @ingroup l2_modif_edit
def DoubleNodesInRegion(self, theElems, theNodesNot, theShape): def DoubleNodeElemInRegion(self, theElems, theNodesNot, theShape):
return self.editor.DoubleNodesInRegion(theElems, theNodesNot, theShape) return self.editor.DoubleNodeElemInRegion(theElems, theNodesNot, theShape)
## Creates a hole in a mesh by doubling the nodes of some particular elements ## Creates a hole in a mesh by doubling the nodes of some particular elements
# This method provided for convenience works as DoubleNodes() described above. # This method provided for convenience works as DoubleNodes() described above.
@ -3383,8 +3506,8 @@ class Mesh:
# @param theAffectedElems - group of elements to which the replicated nodes # @param theAffectedElems - group of elements to which the replicated nodes
# should be associated to. # should be associated to.
# @ingroup l2_modif_edit # @ingroup l2_modif_edit
def DoubleNodeGroup(self, theElems, theNodesNot, theAffectedElems): def DoubleNodeElemGroup(self, theElems, theNodesNot, theAffectedElems):
return self.editor.DoubleNodeGroup(theElems, theNodesNot, theAffectedElems) return self.editor.DoubleNodeElemGroup(theElems, theNodesNot, theAffectedElems)
## Creates a hole in a mesh by doubling the nodes of some particular elements ## Creates a hole in a mesh by doubling the nodes of some particular elements
# This method provided for convenience works as DoubleNodes() described above. # This method provided for convenience works as DoubleNodes() described above.
@ -3394,8 +3517,8 @@ class Mesh:
# located on or inside shape). # located on or inside shape).
# The replicated nodes should be associated to affected elements. # The replicated nodes should be associated to affected elements.
# @ingroup l2_modif_edit # @ingroup l2_modif_edit
def DoubleNodeGroupInRegion(self, theElems, theNodesNot, theShape): def DoubleNodeElemGroupInRegion(self, theElems, theNodesNot, theShape):
return self.editor.DoubleNodeGroup(theElems, theNodesNot, theShape) return self.editor.DoubleNodeElemGroup(theElems, theNodesNot, theShape)
## Creates a hole in a mesh by doubling the nodes of some particular elements ## Creates a hole in a mesh by doubling the nodes of some particular elements
# This method provided for convenience works as DoubleNodes() described above. # This method provided for convenience works as DoubleNodes() described above.
@ -3405,8 +3528,8 @@ class Mesh:
# should be associated to. # should be associated to.
# @return TRUE if operation has been completed successfully, FALSE otherwise # @return TRUE if operation has been completed successfully, FALSE otherwise
# @ingroup l2_modif_edit # @ingroup l2_modif_edit
def DoubleNodeGroups(self, theElems, theNodesNot, theAffectedElems): def DoubleNodeElemGroups(self, theElems, theNodesNot, theAffectedElems):
return self.editor.DoubleNodeGroups(theElems, theNodesNot, theAffectedElems) return self.editor.DoubleNodeElemGroups(theElems, theNodesNot, theAffectedElems)
## Creates a hole in a mesh by doubling the nodes of some particular elements ## Creates a hole in a mesh by doubling the nodes of some particular elements
# This method provided for convenience works as DoubleNodes() described above. # This method provided for convenience works as DoubleNodes() described above.
@ -3417,8 +3540,8 @@ class Mesh:
# The replicated nodes should be associated to affected elements. # The replicated nodes should be associated to affected elements.
# @return TRUE if operation has been completed successfully, FALSE otherwise # @return TRUE if operation has been completed successfully, FALSE otherwise
# @ingroup l2_modif_edit # @ingroup l2_modif_edit
def DoubleNodeGroupsInRegion(self, theElems, theNodesNot, theShape): def DoubleNodeElemGroupsInRegion(self, theElems, theNodesNot, theShape):
return self.editor.DoubleNodeGroupsInRegion(theElems, theNodesNot, theShape) return self.editor.DoubleNodeElemGroupsInRegion(theElems, theNodesNot, theShape)
## The mother class to define algorithm, it is not recommended to use it directly. ## The mother class to define algorithm, it is not recommended to use it directly.
# #
@ -3996,19 +4119,15 @@ class Mesh_Triangle(Mesh_Algorithm):
self.Create(mesh, geom, "MEFISTO_2D") self.Create(mesh, geom, "MEFISTO_2D")
pass pass
elif algoType == BLSURF: elif algoType == BLSURF:
import BLSURFPlugin CheckPlugin(BLSURF)
self.Create(mesh, geom, "BLSURF", "libBLSURFEngine.so") self.Create(mesh, geom, "BLSURF", "libBLSURFEngine.so")
#self.SetPhysicalMesh() - PAL19680 #self.SetPhysicalMesh() - PAL19680
elif algoType == NETGEN: elif algoType == NETGEN:
if noNETGENPlugin: CheckPlugin(NETGEN)
print "Warning: NETGENPlugin module unavailable"
pass
self.Create(mesh, geom, "NETGEN_2D", "libNETGENEngine.so") self.Create(mesh, geom, "NETGEN_2D", "libNETGENEngine.so")
pass pass
elif algoType == NETGEN_2D: elif algoType == NETGEN_2D:
if noNETGENPlugin: CheckPlugin(NETGEN)
print "Warning: NETGENPlugin module unavailable"
pass
self.Create(mesh, geom, "NETGEN_2D_ONLY", "libNETGENEngine.so") self.Create(mesh, geom, "NETGEN_2D_ONLY", "libNETGENEngine.so")
pass pass
@ -4057,6 +4176,7 @@ class Mesh_Triangle(Mesh_Algorithm):
# @ingroup l3_hypos_blsurf # @ingroup l3_hypos_blsurf
def SetPhySize(self, theVal): def SetPhySize(self, theVal):
# Parameter of BLSURF algo # Parameter of BLSURF algo
self.SetPhysicalMesh(1) #Custom - else why to set the size?
self.Parameters().SetPhySize(theVal) self.Parameters().SetPhySize(theVal)
## Sets lower boundary of mesh element size (PhySize). ## Sets lower boundary of mesh element size (PhySize).
@ -4311,22 +4431,22 @@ class Mesh_Tetrahedron(Mesh_Algorithm):
Mesh_Algorithm.__init__(self) Mesh_Algorithm.__init__(self)
if algoType == NETGEN: if algoType == NETGEN:
CheckPlugin(NETGEN)
self.Create(mesh, geom, "NETGEN_3D", "libNETGENEngine.so") self.Create(mesh, geom, "NETGEN_3D", "libNETGENEngine.so")
pass pass
elif algoType == FULL_NETGEN: elif algoType == FULL_NETGEN:
if noNETGENPlugin: CheckPlugin(NETGEN)
print "Warning: NETGENPlugin module has not been imported."
self.Create(mesh, geom, "NETGEN_2D3D", "libNETGENEngine.so") self.Create(mesh, geom, "NETGEN_2D3D", "libNETGENEngine.so")
pass pass
elif algoType == GHS3D: elif algoType == GHS3D:
import GHS3DPlugin CheckPlugin(GHS3D)
self.Create(mesh, geom, "GHS3D_3D" , "libGHS3DEngine.so") self.Create(mesh, geom, "GHS3D_3D" , "libGHS3DEngine.so")
pass pass
elif algoType == GHS3DPRL: elif algoType == GHS3DPRL:
import GHS3DPRLPlugin CheckPlugin(GHS3DPRL)
self.Create(mesh, geom, "GHS3DPRL_3D" , "libGHS3DPRLEngine.so") self.Create(mesh, geom, "GHS3DPRL_3D" , "libGHS3DPRLEngine.so")
pass pass
@ -4464,8 +4584,9 @@ class Mesh_Tetrahedron(Mesh_Algorithm):
self.Parameters().SetToMeshHoles(toMesh) self.Parameters().SetToMeshHoles(toMesh)
## Set Optimization level: ## Set Optimization level:
# None_Optimization, Light_Optimization, Medium_Optimization, Strong_Optimization. # None_Optimization, Light_Optimization, Standard_Optimization, StandardPlus_Optimization,
# Default is Medium_Optimization # Strong_Optimization.
# Default is Standard_Optimization
# @ingroup l3_hypos_ghs3dh # @ingroup l3_hypos_ghs3dh
def SetOptimizationLevel(self, level): def SetOptimizationLevel(self, level):
# Parameter of GHS3D # Parameter of GHS3D
@ -4562,7 +4683,7 @@ class Mesh_Hexahedron(Mesh_Algorithm):
pass pass
elif algoType == Hexotic: elif algoType == Hexotic:
import HexoticPlugin CheckPlugin(Hexotic)
self.Create(mesh, geom, "Hexotic_3D", "libHexoticEngine.so") self.Create(mesh, geom, "Hexotic_3D", "libHexoticEngine.so")
pass pass
@ -4595,8 +4716,7 @@ class Mesh_Netgen(Mesh_Algorithm):
def __init__(self, mesh, is3D, geom=0): def __init__(self, mesh, is3D, geom=0):
Mesh_Algorithm.__init__(self) Mesh_Algorithm.__init__(self)
if noNETGENPlugin: CheckPlugin(NETGEN)
print "Warning: NETGENPlugin module has not been imported."
self.is3D = is3D self.is3D = is3D
if is3D: if is3D:
@ -5115,7 +5235,7 @@ omniORB.registerObjref(StdMeshers._objref_StdMeshers_MaxElementArea._NP_Reposito
class MaxElementVolume(StdMeshers._objref_StdMeshers_MaxElementVolume): class MaxElementVolume(StdMeshers._objref_StdMeshers_MaxElementVolume):
## Set Max Element Volume parameter value ## Set Max Element Volume parameter value
# @param area numerical value or name of variable from notebook # @param volume numerical value or name of variable from notebook
def SetMaxElementVolume(self, volume): def SetMaxElementVolume(self, volume):
volume ,parameters = ParseParameters(StdMeshers._objref_StdMeshers_MaxElementVolume.GetLastParameters(self),1,1,volume) volume ,parameters = ParseParameters(StdMeshers._objref_StdMeshers_MaxElementVolume.GetLastParameters(self),1,1,volume)
StdMeshers._objref_StdMeshers_MaxElementVolume.SetParameters(self,parameters) StdMeshers._objref_StdMeshers_MaxElementVolume.SetParameters(self,parameters)
@ -5159,110 +5279,112 @@ class NumberOfSegments(StdMeshers._objref_StdMeshers_NumberOfSegments):
#Registering the new proxy for NumberOfSegments #Registering the new proxy for NumberOfSegments
omniORB.registerObjref(StdMeshers._objref_StdMeshers_NumberOfSegments._NP_RepositoryId, NumberOfSegments) omniORB.registerObjref(StdMeshers._objref_StdMeshers_NumberOfSegments._NP_RepositoryId, NumberOfSegments)
if not noNETGENPlugin:
#Wrapper class for NETGENPlugin_Hypothesis hypothesis
class NETGENPlugin_Hypothesis(NETGENPlugin._objref_NETGENPlugin_Hypothesis):
#Wrapper class for NETGENPlugin_Hypothesis hypothesis ## Set Max Size parameter value
class NETGENPlugin_Hypothesis(NETGENPlugin._objref_NETGENPlugin_Hypothesis): # @param maxsize numerical value or name of variable from notebook
def SetMaxSize(self, maxsize):
lastParameters = NETGENPlugin._objref_NETGENPlugin_Hypothesis.GetLastParameters(self)
maxsize, parameters = ParseParameters(lastParameters,4,1,maxsize)
NETGENPlugin._objref_NETGENPlugin_Hypothesis.SetParameters(self,parameters)
NETGENPlugin._objref_NETGENPlugin_Hypothesis.SetMaxSize(self,maxsize)
## Set Max Size parameter value ## Set Growth Rate parameter value
# @param maxsize numerical value or name of variable from notebook # @param value numerical value or name of variable from notebook
def SetMaxSize(self, maxsize): def SetGrowthRate(self, value):
lastParameters = NETGENPlugin._objref_NETGENPlugin_Hypothesis.GetLastParameters(self) lastParameters = NETGENPlugin._objref_NETGENPlugin_Hypothesis.GetLastParameters(self)
maxsize, parameters = ParseParameters(lastParameters,4,1,maxsize) value, parameters = ParseParameters(lastParameters,4,2,value)
NETGENPlugin._objref_NETGENPlugin_Hypothesis.SetParameters(self,parameters) NETGENPlugin._objref_NETGENPlugin_Hypothesis.SetParameters(self,parameters)
NETGENPlugin._objref_NETGENPlugin_Hypothesis.SetMaxSize(self,maxsize) NETGENPlugin._objref_NETGENPlugin_Hypothesis.SetGrowthRate(self,value)
## Set Growth Rate parameter value ## Set Number of Segments per Edge parameter value
# @param value numerical value or name of variable from notebook # @param value numerical value or name of variable from notebook
def SetGrowthRate(self, value): def SetNbSegPerEdge(self, value):
lastParameters = NETGENPlugin._objref_NETGENPlugin_Hypothesis.GetLastParameters(self) lastParameters = NETGENPlugin._objref_NETGENPlugin_Hypothesis.GetLastParameters(self)
value, parameters = ParseParameters(lastParameters,4,2,value) value, parameters = ParseParameters(lastParameters,4,3,value)
NETGENPlugin._objref_NETGENPlugin_Hypothesis.SetParameters(self,parameters) NETGENPlugin._objref_NETGENPlugin_Hypothesis.SetParameters(self,parameters)
NETGENPlugin._objref_NETGENPlugin_Hypothesis.SetGrowthRate(self,value) NETGENPlugin._objref_NETGENPlugin_Hypothesis.SetNbSegPerEdge(self,value)
## Set Number of Segments per Edge parameter value ## Set Number of Segments per Radius parameter value
# @param value numerical value or name of variable from notebook # @param value numerical value or name of variable from notebook
def SetNbSegPerEdge(self, value): def SetNbSegPerRadius(self, value):
lastParameters = NETGENPlugin._objref_NETGENPlugin_Hypothesis.GetLastParameters(self) lastParameters = NETGENPlugin._objref_NETGENPlugin_Hypothesis.GetLastParameters(self)
value, parameters = ParseParameters(lastParameters,4,3,value) value, parameters = ParseParameters(lastParameters,4,4,value)
NETGENPlugin._objref_NETGENPlugin_Hypothesis.SetParameters(self,parameters) NETGENPlugin._objref_NETGENPlugin_Hypothesis.SetParameters(self,parameters)
NETGENPlugin._objref_NETGENPlugin_Hypothesis.SetNbSegPerEdge(self,value) NETGENPlugin._objref_NETGENPlugin_Hypothesis.SetNbSegPerRadius(self,value)
## Set Number of Segments per Radius parameter value #Registering the new proxy for NETGENPlugin_Hypothesis
# @param value numerical value or name of variable from notebook omniORB.registerObjref(NETGENPlugin._objref_NETGENPlugin_Hypothesis._NP_RepositoryId, NETGENPlugin_Hypothesis)
def SetNbSegPerRadius(self, value):
lastParameters = NETGENPlugin._objref_NETGENPlugin_Hypothesis.GetLastParameters(self)
value, parameters = ParseParameters(lastParameters,4,4,value)
NETGENPlugin._objref_NETGENPlugin_Hypothesis.SetParameters(self,parameters)
NETGENPlugin._objref_NETGENPlugin_Hypothesis.SetNbSegPerRadius(self,value)
#Registering the new proxy for NETGENPlugin_Hypothesis
omniORB.registerObjref(NETGENPlugin._objref_NETGENPlugin_Hypothesis._NP_RepositoryId, NETGENPlugin_Hypothesis)
#Wrapper class for NETGENPlugin_Hypothesis_2D hypothesis #Wrapper class for NETGENPlugin_Hypothesis_2D hypothesis
class NETGENPlugin_Hypothesis_2D(NETGENPlugin_Hypothesis,NETGENPlugin._objref_NETGENPlugin_Hypothesis_2D): class NETGENPlugin_Hypothesis_2D(NETGENPlugin_Hypothesis,NETGENPlugin._objref_NETGENPlugin_Hypothesis_2D):
pass pass
#Registering the new proxy for NETGENPlugin_Hypothesis_2D #Registering the new proxy for NETGENPlugin_Hypothesis_2D
omniORB.registerObjref(NETGENPlugin._objref_NETGENPlugin_Hypothesis_2D._NP_RepositoryId, NETGENPlugin_Hypothesis_2D) omniORB.registerObjref(NETGENPlugin._objref_NETGENPlugin_Hypothesis_2D._NP_RepositoryId, NETGENPlugin_Hypothesis_2D)
#Wrapper class for NETGENPlugin_SimpleHypothesis_2D hypothesis #Wrapper class for NETGENPlugin_SimpleHypothesis_2D hypothesis
class NETGEN_SimpleParameters_2D(NETGENPlugin._objref_NETGENPlugin_SimpleHypothesis_2D): class NETGEN_SimpleParameters_2D(NETGENPlugin._objref_NETGENPlugin_SimpleHypothesis_2D):
## Set Number of Segments parameter value
# @param nbSeg numerical value or name of variable from notebook
def SetNumberOfSegments(self, nbSeg):
lastParameters = NETGENPlugin._objref_NETGENPlugin_SimpleHypothesis_2D.GetLastParameters(self)
nbSeg, parameters = ParseParameters(lastParameters,2,1,nbSeg)
NETGENPlugin._objref_NETGENPlugin_SimpleHypothesis_2D.SetParameters(self,parameters)
NETGENPlugin._objref_NETGENPlugin_SimpleHypothesis_2D.SetNumberOfSegments(self, nbSeg)
## Set Local Length parameter value ## Set Number of Segments parameter value
# @param length numerical value or name of variable from notebook # @param nbSeg numerical value or name of variable from notebook
def SetLocalLength(self, length): def SetNumberOfSegments(self, nbSeg):
lastParameters = NETGENPlugin._objref_NETGENPlugin_SimpleHypothesis_2D.GetLastParameters(self) lastParameters = NETGENPlugin._objref_NETGENPlugin_SimpleHypothesis_2D.GetLastParameters(self)
length, parameters = ParseParameters(lastParameters,2,1,length) nbSeg, parameters = ParseParameters(lastParameters,2,1,nbSeg)
NETGENPlugin._objref_NETGENPlugin_SimpleHypothesis_2D.SetParameters(self,parameters) NETGENPlugin._objref_NETGENPlugin_SimpleHypothesis_2D.SetParameters(self,parameters)
NETGENPlugin._objref_NETGENPlugin_SimpleHypothesis_2D.SetLocalLength(self, length) NETGENPlugin._objref_NETGENPlugin_SimpleHypothesis_2D.SetNumberOfSegments(self, nbSeg)
## Set Max Element Area parameter value ## Set Local Length parameter value
# @param area numerical value or name of variable from notebook # @param length numerical value or name of variable from notebook
def SetMaxElementArea(self, area): def SetLocalLength(self, length):
lastParameters = NETGENPlugin._objref_NETGENPlugin_SimpleHypothesis_2D.GetLastParameters(self) lastParameters = NETGENPlugin._objref_NETGENPlugin_SimpleHypothesis_2D.GetLastParameters(self)
area, parameters = ParseParameters(lastParameters,2,2,area) length, parameters = ParseParameters(lastParameters,2,1,length)
NETGENPlugin._objref_NETGENPlugin_SimpleHypothesis_2D.SetParameters(self,parameters) NETGENPlugin._objref_NETGENPlugin_SimpleHypothesis_2D.SetParameters(self,parameters)
NETGENPlugin._objref_NETGENPlugin_SimpleHypothesis_2D.SetMaxElementArea(self, area) NETGENPlugin._objref_NETGENPlugin_SimpleHypothesis_2D.SetLocalLength(self, length)
def LengthFromEdges(self): ## Set Max Element Area parameter value
lastParameters = NETGENPlugin._objref_NETGENPlugin_SimpleHypothesis_2D.GetLastParameters(self) # @param area numerical value or name of variable from notebook
value = 0; def SetMaxElementArea(self, area):
value, parameters = ParseParameters(lastParameters,2,2,value) lastParameters = NETGENPlugin._objref_NETGENPlugin_SimpleHypothesis_2D.GetLastParameters(self)
NETGENPlugin._objref_NETGENPlugin_SimpleHypothesis_2D.SetParameters(self,parameters) area, parameters = ParseParameters(lastParameters,2,2,area)
NETGENPlugin._objref_NETGENPlugin_SimpleHypothesis_2D.LengthFromEdges(self) NETGENPlugin._objref_NETGENPlugin_SimpleHypothesis_2D.SetParameters(self,parameters)
NETGENPlugin._objref_NETGENPlugin_SimpleHypothesis_2D.SetMaxElementArea(self, area)
#Registering the new proxy for NETGEN_SimpleParameters_2D
omniORB.registerObjref(NETGENPlugin._objref_NETGENPlugin_SimpleHypothesis_2D._NP_RepositoryId, NETGEN_SimpleParameters_2D) def LengthFromEdges(self):
lastParameters = NETGENPlugin._objref_NETGENPlugin_SimpleHypothesis_2D.GetLastParameters(self)
value = 0;
value, parameters = ParseParameters(lastParameters,2,2,value)
NETGENPlugin._objref_NETGENPlugin_SimpleHypothesis_2D.SetParameters(self,parameters)
NETGENPlugin._objref_NETGENPlugin_SimpleHypothesis_2D.LengthFromEdges(self)
#Registering the new proxy for NETGEN_SimpleParameters_2D
omniORB.registerObjref(NETGENPlugin._objref_NETGENPlugin_SimpleHypothesis_2D._NP_RepositoryId, NETGEN_SimpleParameters_2D)
#Wrapper class for NETGENPlugin_SimpleHypothesis_3D hypothesis #Wrapper class for NETGENPlugin_SimpleHypothesis_3D hypothesis
class NETGEN_SimpleParameters_3D(NETGEN_SimpleParameters_2D,NETGENPlugin._objref_NETGENPlugin_SimpleHypothesis_3D): class NETGEN_SimpleParameters_3D(NETGEN_SimpleParameters_2D,NETGENPlugin._objref_NETGENPlugin_SimpleHypothesis_3D):
## Set Max Element Volume parameter value ## Set Max Element Volume parameter value
# @param volume numerical value or name of variable from notebook # @param volume numerical value or name of variable from notebook
def SetMaxElementVolume(self, volume): def SetMaxElementVolume(self, volume):
lastParameters = NETGENPlugin._objref_NETGENPlugin_SimpleHypothesis_3D.GetLastParameters(self) lastParameters = NETGENPlugin._objref_NETGENPlugin_SimpleHypothesis_3D.GetLastParameters(self)
volume, parameters = ParseParameters(lastParameters,3,3,volume) volume, parameters = ParseParameters(lastParameters,3,3,volume)
NETGENPlugin._objref_NETGENPlugin_SimpleHypothesis_3D.SetParameters(self,parameters) NETGENPlugin._objref_NETGENPlugin_SimpleHypothesis_3D.SetParameters(self,parameters)
NETGENPlugin._objref_NETGENPlugin_SimpleHypothesis_3D.SetMaxElementVolume(self, volume) NETGENPlugin._objref_NETGENPlugin_SimpleHypothesis_3D.SetMaxElementVolume(self, volume)
def LengthFromFaces(self): def LengthFromFaces(self):
lastParameters = NETGENPlugin._objref_NETGENPlugin_SimpleHypothesis_3D.GetLastParameters(self) lastParameters = NETGENPlugin._objref_NETGENPlugin_SimpleHypothesis_3D.GetLastParameters(self)
value = 0; value = 0;
value, parameters = ParseParameters(lastParameters,3,3,value) value, parameters = ParseParameters(lastParameters,3,3,value)
NETGENPlugin._objref_NETGENPlugin_SimpleHypothesis_3D.SetParameters(self,parameters) NETGENPlugin._objref_NETGENPlugin_SimpleHypothesis_3D.SetParameters(self,parameters)
NETGENPlugin._objref_NETGENPlugin_SimpleHypothesis_3D.LengthFromFaces(self) NETGENPlugin._objref_NETGENPlugin_SimpleHypothesis_3D.LengthFromFaces(self)
#Registering the new proxy for NETGEN_SimpleParameters_3D #Registering the new proxy for NETGEN_SimpleParameters_3D
omniORB.registerObjref(NETGENPlugin._objref_NETGENPlugin_SimpleHypothesis_3D._NP_RepositoryId, NETGEN_SimpleParameters_3D) omniORB.registerObjref(NETGENPlugin._objref_NETGENPlugin_SimpleHypothesis_3D._NP_RepositoryId, NETGEN_SimpleParameters_3D)
pass # if not noNETGENPlugin:
class Pattern(SMESH._objref_SMESH_Pattern): class Pattern(SMESH._objref_SMESH_Pattern):

30
src/StdMeshers/StdMeshers_CompositeHexa_3D.cxx
View File

@ -252,7 +252,7 @@ StdMeshers_CompositeHexa_3D::StdMeshers_CompositeHexa_3D(int hypId, int studyId,
:SMESH_3D_Algo(hypId, studyId, gen) :SMESH_3D_Algo(hypId, studyId, gen)
{ {
_name = "CompositeHexa_3D"; _name = "CompositeHexa_3D";
_shapeType = (1 << TopAbs_SHELL) | (1 << TopAbs_SOLID); // 1 bit /shape type _shapeType = (1 << TopAbs_SHELL) | (1 << TopAbs_SOLID); // 1 bit /shape type
} }
//================================================================================ //================================================================================
@ -514,7 +514,7 @@ bool StdMeshers_CompositeHexa_3D::Compute(SMESH_Mesh& theMesh,
//purpose : auxilary for Evaluate //purpose : auxilary for Evaluate
//======================================================================= //=======================================================================
int GetNb2d(_QuadFaceGrid* QFG, SMESH_Mesh& theMesh, int GetNb2d(_QuadFaceGrid* QFG, SMESH_Mesh& theMesh,
MapShapeNbElems& aResMap) MapShapeNbElems& aResMap)
{ {
int nb2d = 0; int nb2d = 0;
_QuadFaceGrid::TChildIterator aCI = QFG->GetChildren(); _QuadFaceGrid::TChildIterator aCI = QFG->GetChildren();
@ -539,8 +539,8 @@ int GetNb2d(_QuadFaceGrid* QFG, SMESH_Mesh& theMesh,
//================================================================================ //================================================================================
bool StdMeshers_CompositeHexa_3D::Evaluate(SMESH_Mesh& theMesh, bool StdMeshers_CompositeHexa_3D::Evaluate(SMESH_Mesh& theMesh,
const TopoDS_Shape& theShape, const TopoDS_Shape& theShape,
MapShapeNbElems& aResMap) MapShapeNbElems& aResMap)
{ {
SMESH_MesherHelper aTool(theMesh); SMESH_MesherHelper aTool(theMesh);
bool _quadraticMesh = aTool.IsQuadraticSubMesh(theShape); bool _quadraticMesh = aTool.IsQuadraticSubMesh(theShape);
@ -636,22 +636,22 @@ bool StdMeshers_CompositeHexa_3D::Evaluate(SMESH_Mesh& theMesh,
int nb0 = 0; int nb0 = 0;
SMESH_subMesh *sm = theMesh.GetSubMesh(exp.Current()); SMESH_subMesh *sm = theMesh.GetSubMesh(exp.Current());
if( sm ) { if( sm ) {
MapShapeNbElemsItr anIt = aResMap.find(sm); MapShapeNbElemsItr anIt = aResMap.find(sm);
if( anIt == aResMap.end() ) continue; if( anIt == aResMap.end() ) continue;
std::vector<int> aVec = (*anIt).second; std::vector<int> aVec = (*anIt).second;
nb0 = aVec[SMDSEntity_Node]; nb0 = aVec[SMDSEntity_Node];
} }
int j = 1; int j = 1;
for(; j<=BndEdges.Length(); j++) { for(; j<=BndEdges.Length(); j++) {
if( BndEdges.Value(j) == exp.Current() ) { if( BndEdges.Value(j) == exp.Current() ) {
// internal edge => remove it // internal edge => remove it
BndEdges.Remove(j); BndEdges.Remove(j);
nb0d_in += nb0; nb0d_in += nb0;
break; break;
} }
} }
if( j > BndEdges.Length() ) { if( j > BndEdges.Length() ) {
BndEdges.Append(exp.Current()); BndEdges.Append(exp.Current());
} }
//if( BndEdges.Contains(exp.Current()) ) { //if( BndEdges.Contains(exp.Current()) ) {
//BndEdges.Remove( exp.Current() ); //BndEdges.Remove( exp.Current() );

14
src/StdMeshers/StdMeshers_FaceSide.cxx
View File

@ -165,8 +165,8 @@ StdMeshers_FaceSide::StdMeshers_FaceSide(const TopoDS_Face& theFace,
//================================================================================ //================================================================================
StdMeshers_FaceSide::StdMeshers_FaceSide(const SMDS_MeshNode* theNode, StdMeshers_FaceSide::StdMeshers_FaceSide(const SMDS_MeshNode* theNode,
const gp_Pnt2d thePnt2d, const gp_Pnt2d thePnt2d,
const StdMeshers_FaceSide* theSide) const StdMeshers_FaceSide* theSide)
{ {
myC2d.resize(1); myC2d.resize(1);
myLength = 0; myLength = 0;
@ -541,15 +541,7 @@ TSideVector StdMeshers_FaceSide::GetFaceWires(const TopoDS_Face& theFace,
return TSideVector(0); return TSideVector(0);
} }
} }
// find out side orientation, which is important if there are several wires (PAL19080) const bool isForward = true;
bool isForward = true;
if ( nbWires > 1 ) {
TopExp_Explorer e( theFace, TopAbs_EDGE );
while ( ! e.Current().IsSame( wireEdges.back() ))
e.Next();
isForward = ( e.Current().Orientation() == wireEdges.back().Orientation() );
}
StdMeshers_FaceSide* wire = new StdMeshers_FaceSide( theFace, wireEdges, &theMesh, StdMeshers_FaceSide* wire = new StdMeshers_FaceSide( theFace, wireEdges, &theMesh,
isForward, theIgnoreMediumNodes); isForward, theIgnoreMediumNodes);
wires[ iW ] = StdMeshers_FaceSidePtr( wire ); wires[ iW ] = StdMeshers_FaceSidePtr( wire );

2
src/StdMeshers/StdMeshers_FaceSide.hxx
View File

@ -97,7 +97,7 @@ public:
* \brief Wrap for vertex using data from other FaceSide * \brief Wrap for vertex using data from other FaceSide
*/ */
StdMeshers_FaceSide(const SMDS_MeshNode* theNode, StdMeshers_FaceSide(const SMDS_MeshNode* theNode,
const gp_Pnt2d thePnt2d, const gp_Pnt2d thePnt2d,
const StdMeshers_FaceSide* theSide); const StdMeshers_FaceSide* theSide);
/*! /*!
* \brief Return wires of a face as StdMeshers_FaceSide's * \brief Return wires of a face as StdMeshers_FaceSide's

466
src/StdMeshers/StdMeshers_Hexa_3D.cxx
View File

@ -61,10 +61,10 @@ typedef SMESH_Comment TComm;
using namespace std; using namespace std;
static SMESH_ComputeErrorPtr ComputePentahedralMesh(SMESH_Mesh &, static SMESH_ComputeErrorPtr ComputePentahedralMesh(SMESH_Mesh &,
const TopoDS_Shape &); const TopoDS_Shape &);
static bool EvaluatePentahedralMesh(SMESH_Mesh &, const TopoDS_Shape &, static bool EvaluatePentahedralMesh(SMESH_Mesh &, const TopoDS_Shape &,
MapShapeNbElems &); MapShapeNbElems &);
//============================================================================= //=============================================================================
/*! /*!
@ -77,7 +77,7 @@ StdMeshers_Hexa_3D::StdMeshers_Hexa_3D(int hypId, int studyId, SMESH_Gen * gen)
{ {
MESSAGE("StdMeshers_Hexa_3D::StdMeshers_Hexa_3D"); MESSAGE("StdMeshers_Hexa_3D::StdMeshers_Hexa_3D");
_name = "Hexa_3D"; _name = "Hexa_3D";
_shapeType = (1 << TopAbs_SHELL) | (1 << TopAbs_SOLID); // 1 bit /shape type _shapeType = (1 << TopAbs_SHELL) | (1 << TopAbs_SOLID); // 1 bit /shape type
} }
//============================================================================= //=============================================================================
@ -298,7 +298,7 @@ bool StdMeshers_Hexa_3D::Compute(SMESH_Mesh & aMesh,
try { try {
aQuads[i] = quadAlgo->CheckAnd2Dcompute(aMesh, aFace, _quadraticMesh); aQuads[i] = quadAlgo->CheckAnd2Dcompute(aMesh, aFace, _quadraticMesh);
if(!aQuads[i]) { if(!aQuads[i]) {
return error( quadAlgo->GetComputeError()); return error( quadAlgo->GetComputeError());
} }
} }
catch(SALOME_Exception & S_ex) { catch(SALOME_Exception & S_ex) {
@ -361,7 +361,7 @@ bool StdMeshers_Hexa_3D::Compute(SMESH_Mesh & aMesh,
int _indX1 = GetFaceIndex(aMesh, aShape, meshFaces, int _indX1 = GetFaceIndex(aMesh, aShape, meshFaces,
aCube.V100, aCube.V101, aCube.V110, aCube.V111); aCube.V100, aCube.V101, aCube.V110, aCube.V111);
// IPAL21120: SIGSEGV on Meshing attached Compound with Automatic Hexadralization // IPAL21120: SIGSEGV on Meshing attached Compound with Automatic Hexadralization
if ( _indY1 < 1 || _indZ0 < 1 || _indZ1 < 1 || _indX0 < 1 || _indX1 < 1 ) if ( _indY1 < 1 || _indZ0 < 1 || _indZ1 < 1 || _indX0 < 1 || _indX1 < 1 )
return error(COMPERR_BAD_SHAPE); return error(COMPERR_BAD_SHAPE);
@ -374,8 +374,8 @@ bool StdMeshers_Hexa_3D::Compute(SMESH_Mesh & aMesh,
// 1.7 - get convertion coefs from face 2D normalized to 3D normalized // 1.7 - get convertion coefs from face 2D normalized to 3D normalized
Conv2DStruct cx0; // for face X=0 Conv2DStruct cx0; // for face X=0
Conv2DStruct cx1; // for face X=1 Conv2DStruct cx1; // for face X=1
Conv2DStruct cy0; Conv2DStruct cy0;
Conv2DStruct cy1; Conv2DStruct cy1;
Conv2DStruct cz0; Conv2DStruct cz0;
@ -414,12 +414,12 @@ bool StdMeshers_Hexa_3D::Compute(SMESH_Mesh & aMesh,
const TopoDS_Face & F = TopoDS::Face(meshFaces[_indX0]->GetSubShape()); const TopoDS_Face & F = TopoDS::Face(meshFaces[_indX0]->GetSubShape());
faceQuadStruct *quad = aCube.quad_X0; faceQuadStruct *quad = aCube.quad_X0;
int i = 0; // j = x/face , k = y/face int i = 0; // j = x/face , k = y/face
int nbdown = quad->side[0]->NbPoints(); int nbdown = quad->side[0]->NbPoints();
int nbright = quad->side[1]->NbPoints(); int nbright = quad->side[1]->NbPoints();
SMDS_NodeIteratorPtr itf= aMesh.GetSubMesh(F)->GetSubMeshDS()->GetNodes(); SMDS_NodeIteratorPtr itf= aMesh.GetSubMesh(F)->GetSubMeshDS()->GetNodes();
while(itf->more()) { while(itf->more()) {
const SMDS_MeshNode * node = itf->next(); const SMDS_MeshNode * node = itf->next();
if(aTool.IsMedium(node)) if(aTool.IsMedium(node))
@ -433,8 +433,8 @@ bool StdMeshers_Hexa_3D::Compute(SMESH_Mesh & aMesh,
for (int i1 = 0; i1 < nbdown; i1++) for (int i1 = 0; i1 < nbdown; i1++)
for (int j1 = 0; j1 < nbright; j1++) { for (int j1 = 0; j1 < nbright; j1++) {
int ij1 = j1 * nbdown + i1; int ij1 = j1 * nbdown + i1;
int j = cx0.ia * i1 + cx0.ib * j1 + cx0.ic; // j = x/face int j = cx0.ia * i1 + cx0.ib * j1 + cx0.ic; // j = x/face
int k = cx0.ja * i1 + cx0.jb * j1 + cx0.jc; // k = y/face int k = cx0.ja * i1 + cx0.jb * j1 + cx0.jc; // k = y/face
int ijk = k * nbx * nby + j * nbx + i; int ijk = k * nbx * nby + j * nbx + i;
//MESSAGE(" "<<ij1<<" "<<i<<" "<<j<<" "<<ijk); //MESSAGE(" "<<ij1<<" "<<i<<" "<<j<<" "<<ijk);
np[ijk].node = quad->uv_grid[ij1].node; np[ijk].node = quad->uv_grid[ij1].node;
@ -448,7 +448,7 @@ bool StdMeshers_Hexa_3D::Compute(SMESH_Mesh & aMesh,
SMDS_NodeIteratorPtr itf= aMesh.GetSubMesh(F)->GetSubMeshDS()->GetNodes(); SMDS_NodeIteratorPtr itf= aMesh.GetSubMesh(F)->GetSubMeshDS()->GetNodes();
faceQuadStruct *quad = aCube.quad_X1; faceQuadStruct *quad = aCube.quad_X1;
int i = nbx - 1; // j = x/face , k = y/face int i = nbx - 1; // j = x/face , k = y/face
int nbdown = quad->side[0]->NbPoints(); int nbdown = quad->side[0]->NbPoints();
int nbright = quad->side[1]->NbPoints(); int nbright = quad->side[1]->NbPoints();
@ -465,8 +465,8 @@ bool StdMeshers_Hexa_3D::Compute(SMESH_Mesh & aMesh,
for (int i1 = 0; i1 < nbdown; i1++) for (int i1 = 0; i1 < nbdown; i1++)
for (int j1 = 0; j1 < nbright; j1++) { for (int j1 = 0; j1 < nbright; j1++) {
int ij1 = j1 * nbdown + i1; int ij1 = j1 * nbdown + i1;
int j = cx1.ia * i1 + cx1.ib * j1 + cx1.ic; // j = x/face int j = cx1.ia * i1 + cx1.ib * j1 + cx1.ic; // j = x/face
int k = cx1.ja * i1 + cx1.jb * j1 + cx1.jc; // k = y/face int k = cx1.ja * i1 + cx1.jb * j1 + cx1.jc; // k = y/face
int ijk = k * nbx * nby + j * nbx + i; int ijk = k * nbx * nby + j * nbx + i;
//MESSAGE(" "<<ij1<<" "<<i<<" "<<j<<" "<<ijk); //MESSAGE(" "<<ij1<<" "<<i<<" "<<j<<" "<<ijk);
np[ijk].node = quad->uv_grid[ij1].node; np[ijk].node = quad->uv_grid[ij1].node;
@ -480,7 +480,7 @@ bool StdMeshers_Hexa_3D::Compute(SMESH_Mesh & aMesh,
SMDS_NodeIteratorPtr itf= aMesh.GetSubMesh(F)->GetSubMeshDS()->GetNodes(); SMDS_NodeIteratorPtr itf= aMesh.GetSubMesh(F)->GetSubMeshDS()->GetNodes();
faceQuadStruct *quad = aCube.quad_Y0; faceQuadStruct *quad = aCube.quad_Y0;
int j = 0; // i = x/face , k = y/face int j = 0; // i = x/face , k = y/face
int nbdown = quad->side[0]->NbPoints(); int nbdown = quad->side[0]->NbPoints();
int nbright = quad->side[1]->NbPoints(); int nbright = quad->side[1]->NbPoints();
@ -497,8 +497,8 @@ bool StdMeshers_Hexa_3D::Compute(SMESH_Mesh & aMesh,
for (int i1 = 0; i1 < nbdown; i1++) for (int i1 = 0; i1 < nbdown; i1++)
for (int j1 = 0; j1 < nbright; j1++) { for (int j1 = 0; j1 < nbright; j1++) {
int ij1 = j1 * nbdown + i1; int ij1 = j1 * nbdown + i1;
int i = cy0.ia * i1 + cy0.ib * j1 + cy0.ic; // i = x/face int i = cy0.ia * i1 + cy0.ib * j1 + cy0.ic; // i = x/face
int k = cy0.ja * i1 + cy0.jb * j1 + cy0.jc; // k = y/face int k = cy0.ja * i1 + cy0.jb * j1 + cy0.jc; // k = y/face
int ijk = k * nbx * nby + j * nbx + i; int ijk = k * nbx * nby + j * nbx + i;
//MESSAGE(" "<<ij1<<" "<<i<<" "<<j<<" "<<ijk); //MESSAGE(" "<<ij1<<" "<<i<<" "<<j<<" "<<ijk);
np[ijk].node = quad->uv_grid[ij1].node; np[ijk].node = quad->uv_grid[ij1].node;
@ -512,7 +512,7 @@ bool StdMeshers_Hexa_3D::Compute(SMESH_Mesh & aMesh,
SMDS_NodeIteratorPtr itf= aMesh.GetSubMesh(F)->GetSubMeshDS()->GetNodes(); SMDS_NodeIteratorPtr itf= aMesh.GetSubMesh(F)->GetSubMeshDS()->GetNodes();
faceQuadStruct *quad = aCube.quad_Y1; faceQuadStruct *quad = aCube.quad_Y1;
int j = nby - 1; // i = x/face , k = y/face int j = nby - 1; // i = x/face , k = y/face
int nbdown = quad->side[0]->NbPoints(); int nbdown = quad->side[0]->NbPoints();
int nbright = quad->side[1]->NbPoints(); int nbright = quad->side[1]->NbPoints();
@ -529,8 +529,8 @@ bool StdMeshers_Hexa_3D::Compute(SMESH_Mesh & aMesh,
for (int i1 = 0; i1 < nbdown; i1++) for (int i1 = 0; i1 < nbdown; i1++)
for (int j1 = 0; j1 < nbright; j1++) { for (int j1 = 0; j1 < nbright; j1++) {
int ij1 = j1 * nbdown + i1; int ij1 = j1 * nbdown + i1;
int i = cy1.ia * i1 + cy1.ib * j1 + cy1.ic; // i = x/face int i = cy1.ia * i1 + cy1.ib * j1 + cy1.ic; // i = x/face
int k = cy1.ja * i1 + cy1.jb * j1 + cy1.jc; // k = y/face int k = cy1.ja * i1 + cy1.jb * j1 + cy1.jc; // k = y/face
int ijk = k * nbx * nby + j * nbx + i; int ijk = k * nbx * nby + j * nbx + i;
//MESSAGE(" "<<ij1<<" "<<i<<" "<<j<<" "<<ijk); //MESSAGE(" "<<ij1<<" "<<i<<" "<<j<<" "<<ijk);
np[ijk].node = quad->uv_grid[ij1].node; np[ijk].node = quad->uv_grid[ij1].node;
@ -544,7 +544,7 @@ bool StdMeshers_Hexa_3D::Compute(SMESH_Mesh & aMesh,
SMDS_NodeIteratorPtr itf= aMesh.GetSubMesh(F)->GetSubMeshDS()->GetNodes(); SMDS_NodeIteratorPtr itf= aMesh.GetSubMesh(F)->GetSubMeshDS()->GetNodes();
faceQuadStruct *quad = aCube.quad_Z0; faceQuadStruct *quad = aCube.quad_Z0;
int k = 0; // i = x/face , j = y/face int k = 0; // i = x/face , j = y/face
int nbdown = quad->side[0]->NbPoints(); int nbdown = quad->side[0]->NbPoints();
int nbright = quad->side[1]->NbPoints(); int nbright = quad->side[1]->NbPoints();
@ -561,8 +561,8 @@ bool StdMeshers_Hexa_3D::Compute(SMESH_Mesh & aMesh,
for (int i1 = 0; i1 < nbdown; i1++) for (int i1 = 0; i1 < nbdown; i1++)
for (int j1 = 0; j1 < nbright; j1++) { for (int j1 = 0; j1 < nbright; j1++) {
int ij1 = j1 * nbdown + i1; int ij1 = j1 * nbdown + i1;
int i = cz0.ia * i1 + cz0.ib * j1 + cz0.ic; // i = x/face int i = cz0.ia * i1 + cz0.ib * j1 + cz0.ic; // i = x/face
int j = cz0.ja * i1 + cz0.jb * j1 + cz0.jc; // j = y/face int j = cz0.ja * i1 + cz0.jb * j1 + cz0.jc; // j = y/face
int ijk = k * nbx * nby + j * nbx + i; int ijk = k * nbx * nby + j * nbx + i;
//MESSAGE(" "<<ij1<<" "<<i<<" "<<j<<" "<<ijk); //MESSAGE(" "<<ij1<<" "<<i<<" "<<j<<" "<<ijk);
np[ijk].node = quad->uv_grid[ij1].node; np[ijk].node = quad->uv_grid[ij1].node;
@ -576,7 +576,7 @@ bool StdMeshers_Hexa_3D::Compute(SMESH_Mesh & aMesh,
SMDS_NodeIteratorPtr itf= aMesh.GetSubMesh(F)->GetSubMeshDS()->GetNodes(); SMDS_NodeIteratorPtr itf= aMesh.GetSubMesh(F)->GetSubMeshDS()->GetNodes();
faceQuadStruct *quad = aCube.quad_Z1; faceQuadStruct *quad = aCube.quad_Z1;
int k = nbz - 1; // i = x/face , j = y/face int k = nbz - 1; // i = x/face , j = y/face
int nbdown = quad->side[0]->NbPoints(); int nbdown = quad->side[0]->NbPoints();
int nbright = quad->side[1]->NbPoints(); int nbright = quad->side[1]->NbPoints();
@ -593,8 +593,8 @@ bool StdMeshers_Hexa_3D::Compute(SMESH_Mesh & aMesh,
for (int i1 = 0; i1 < nbdown; i1++) for (int i1 = 0; i1 < nbdown; i1++)
for (int j1 = 0; j1 < nbright; j1++) { for (int j1 = 0; j1 < nbright; j1++) {
int ij1 = j1 * nbdown + i1; int ij1 = j1 * nbdown + i1;
int i = cz1.ia * i1 + cz1.ib * j1 + cz1.ic; // i = x/face int i = cz1.ia * i1 + cz1.ib * j1 + cz1.ic; // i = x/face
int j = cz1.ja * i1 + cz1.jb * j1 + cz1.jc; // j = y/face int j = cz1.ja * i1 + cz1.jb * j1 + cz1.jc; // j = y/face
int ijk = k * nbx * nby + j * nbx + i; int ijk = k * nbx * nby + j * nbx + i;
//MESSAGE(" "<<ij1<<" "<<i<<" "<<j<<" "<<ijk); //MESSAGE(" "<<ij1<<" "<<i<<" "<<j<<" "<<ijk);
np[ijk].node = quad->uv_grid[ij1].node; np[ijk].node = quad->uv_grid[ij1].node;
@ -655,9 +655,9 @@ bool StdMeshers_Hexa_3D::Compute(SMESH_Mesh & aMesh,
GetPoint(p1yz, nbx - 1, j, k, nbx, nby, nbz, np, meshDS); GetPoint(p1yz, nbx - 1, j, k, nbx, nby, nbz, np, meshDS);
int ijk = k * nbx * nby + j * nbx + i; int ijk = k * nbx * nby + j * nbx + i;
double x = double (i) / double (nbx - 1); // *** seulement double x = double (i) / double (nbx - 1); // *** seulement
double y = double (j) / double (nby - 1); // *** maillage double y = double (j) / double (nby - 1); // *** maillage
double z = double (k) / double (nbz - 1); // *** regulier double z = double (k) / double (nbz - 1); // *** regulier
Pt3 X; Pt3 X;
for (int i = 0; i < 3; i++) { for (int i = 0; i < 3; i++) {
@ -750,8 +750,8 @@ bool StdMeshers_Hexa_3D::Compute(SMESH_Mesh & aMesh,
//============================================================================= //=============================================================================
bool StdMeshers_Hexa_3D::Evaluate(SMESH_Mesh & aMesh, bool StdMeshers_Hexa_3D::Evaluate(SMESH_Mesh & aMesh,
const TopoDS_Shape & aShape, const TopoDS_Shape & aShape,
MapShapeNbElems& aResMap) MapShapeNbElems& aResMap)
{ {
vector < SMESH_subMesh * >meshFaces; vector < SMESH_subMesh * >meshFaces;
TopTools_SequenceOfShape aFaces; TopTools_SequenceOfShape aFaces;
@ -789,7 +789,7 @@ bool StdMeshers_Hexa_3D::Evaluate(SMESH_Mesh & aMesh,
std::vector<int> aVec = (*anIt).second; std::vector<int> aVec = (*anIt).second;
int nbtri = Max(aVec[SMDSEntity_Triangle],aVec[SMDSEntity_Quad_Triangle]); int nbtri = Max(aVec[SMDSEntity_Triangle],aVec[SMDSEntity_Quad_Triangle]);
if( nbtri == 0 ) if( nbtri == 0 )
isAllQuad = true; isAllQuad = true;
} }
if ( ! isAllQuad ) { if ( ! isAllQuad ) {
return EvaluatePentahedralMesh(aMesh, aShape, aResMap); return EvaluatePentahedralMesh(aMesh, aShape, aResMap);
@ -810,8 +810,8 @@ bool StdMeshers_Hexa_3D::Evaluate(SMESH_Mesh & aMesh,
std::vector<int> aVec = (*anIt).second; std::vector<int> aVec = (*anIt).second;
nb1d += Max(aVec[SMDSEntity_Edge],aVec[SMDSEntity_Quad_Edge]); nb1d += Max(aVec[SMDSEntity_Edge],aVec[SMDSEntity_Quad_Edge]);
if(IsFirst) { if(IsFirst) {
IsQuadratic = (aVec[SMDSEntity_Quad_Edge] > aVec[SMDSEntity_Edge]); IsQuadratic = (aVec[SMDSEntity_Quad_Edge] > aVec[SMDSEntity_Edge]);
IsFirst = false; IsFirst = false;
} }
} }
} }
@ -821,8 +821,8 @@ bool StdMeshers_Hexa_3D::Evaluate(SMESH_Mesh & aMesh,
bool IsOpposite = true; bool IsOpposite = true;
for(TopExp_Explorer exp(aFaces.Value(i), TopAbs_EDGE); exp.More(); exp.Next()) { for(TopExp_Explorer exp(aFaces.Value(i), TopAbs_EDGE); exp.More(); exp.Next()) {
if( Edges1.Contains(exp.Current()) ) { if( Edges1.Contains(exp.Current()) ) {
IsOpposite = false; IsOpposite = false;
break; break;
} }
} }
if(IsOpposite) { if(IsOpposite) {
@ -872,12 +872,12 @@ bool StdMeshers_Hexa_3D::Evaluate(SMESH_Mesh & aMesh,
void StdMeshers_Hexa_3D::GetPoint(Pt3 p, int i, int j, int k, int nbx, int nby, int nbz, void StdMeshers_Hexa_3D::GetPoint(Pt3 p, int i, int j, int k, int nbx, int nby, int nbz,
Point3DStruct * np, const SMESHDS_Mesh * meshDS) Point3DStruct * np, const SMESHDS_Mesh * meshDS)
{ {
int ijk = k * nbx * nby + j * nbx + i; int ijk = k * nbx * nby + j * nbx + i;
const SMDS_MeshNode * node = np[ijk].node; const SMDS_MeshNode * node = np[ijk].node;
p[0] = node->X(); p[0] = node->X();
p[1] = node->Y(); p[1] = node->Y();
p[2] = node->Z(); p[2] = node->Z();
//MESSAGE(" "<<i<<" "<<j<<" "<<k<<" "<<p[0]<<" "<<p[1]<<" "<<p[2]); //MESSAGE(" "<<i<<" "<<j<<" "<<k<<" "<<p[0]<<" "<<p[1]<<" "<<p[2]);
} }
//============================================================================= //=============================================================================
@ -887,35 +887,35 @@ void StdMeshers_Hexa_3D::GetPoint(Pt3 p, int i, int j, int k, int nbx, int nby,
//============================================================================= //=============================================================================
int StdMeshers_Hexa_3D::GetFaceIndex(SMESH_Mesh & aMesh, int StdMeshers_Hexa_3D::GetFaceIndex(SMESH_Mesh & aMesh,
const TopoDS_Shape & aShape, const TopoDS_Shape & aShape,
const vector < SMESH_subMesh * >&meshFaces, const vector < SMESH_subMesh * >&meshFaces,
const TopoDS_Vertex & V0, const TopoDS_Vertex & V0,
const TopoDS_Vertex & V1, const TopoDS_Vertex & V1,
const TopoDS_Vertex & V2, const TopoDS_Vertex & V3) const TopoDS_Vertex & V2, const TopoDS_Vertex & V3)
{ {
//MESSAGE("StdMeshers_Hexa_3D::GetFaceIndex"); //MESSAGE("StdMeshers_Hexa_3D::GetFaceIndex");
int faceIndex = -1; int faceIndex = -1;
for (int i = 1; i < 6; i++) for (int i = 1; i < 6; i++)
{ {
const TopoDS_Shape & aFace = meshFaces[i]->GetSubShape(); const TopoDS_Shape & aFace = meshFaces[i]->GetSubShape();
//const TopoDS_Face& F = TopoDS::Face(aFace); //const TopoDS_Face& F = TopoDS::Face(aFace);
TopTools_IndexedMapOfShape M; TopTools_IndexedMapOfShape M;
TopExp::MapShapes(aFace, TopAbs_VERTEX, M); TopExp::MapShapes(aFace, TopAbs_VERTEX, M);
bool verticesInShape = false; bool verticesInShape = false;
if (M.Contains(V0)) if (M.Contains(V0))
if (M.Contains(V1)) if (M.Contains(V1))
if (M.Contains(V2)) if (M.Contains(V2))
if (M.Contains(V3)) if (M.Contains(V3))
verticesInShape = true; verticesInShape = true;
if (verticesInShape) if (verticesInShape)
{ {
faceIndex = i; faceIndex = i;
break; break;
} }
} }
//IPAL21120 ASSERT(faceIndex > 0); //IPAL21120 ASSERT(faceIndex > 0);
//SCRUTE(faceIndex); //SCRUTE(faceIndex);
return faceIndex; return faceIndex;
} }
//============================================================================= //=============================================================================
@ -925,46 +925,46 @@ int StdMeshers_Hexa_3D::GetFaceIndex(SMESH_Mesh & aMesh,
//============================================================================= //=============================================================================
TopoDS_Edge TopoDS_Edge
StdMeshers_Hexa_3D::EdgeNotInFace(SMESH_Mesh & aMesh, StdMeshers_Hexa_3D::EdgeNotInFace(SMESH_Mesh & aMesh,
const TopoDS_Shape & aShape, const TopoDS_Shape & aShape,
const TopoDS_Face & aFace, const TopoDS_Face & aFace,
const TopoDS_Vertex & aVertex, const TopoDS_Vertex & aVertex,
const TopTools_IndexedDataMapOfShapeListOfShape & MS) const TopTools_IndexedDataMapOfShapeListOfShape & MS)
{ {
//MESSAGE("StdMeshers_Hexa_3D::EdgeNotInFace"); //MESSAGE("StdMeshers_Hexa_3D::EdgeNotInFace");
TopTools_IndexedDataMapOfShapeListOfShape MF; TopTools_IndexedDataMapOfShapeListOfShape MF;
TopExp::MapShapesAndAncestors(aFace, TopAbs_VERTEX, TopAbs_EDGE, MF); TopExp::MapShapesAndAncestors(aFace, TopAbs_VERTEX, TopAbs_EDGE, MF);
const TopTools_ListOfShape & ancestorsInSolid = MS.FindFromKey(aVertex); const TopTools_ListOfShape & ancestorsInSolid = MS.FindFromKey(aVertex);
const TopTools_ListOfShape & ancestorsInFace = MF.FindFromKey(aVertex); const TopTools_ListOfShape & ancestorsInFace = MF.FindFromKey(aVertex);
// SCRUTE(ancestorsInSolid.Extent()); // SCRUTE(ancestorsInSolid.Extent());
// SCRUTE(ancestorsInFace.Extent()); // SCRUTE(ancestorsInFace.Extent());
ASSERT(ancestorsInSolid.Extent() == 6); // 6 (edges doublees) ASSERT(ancestorsInSolid.Extent() == 6); // 6 (edges doublees)
ASSERT(ancestorsInFace.Extent() == 2); ASSERT(ancestorsInFace.Extent() == 2);
TopoDS_Edge E; TopoDS_Edge E;
E.Nullify(); E.Nullify();
TopTools_ListIteratorOfListOfShape its(ancestorsInSolid); TopTools_ListIteratorOfListOfShape its(ancestorsInSolid);
for (; its.More(); its.Next()) for (; its.More(); its.Next())
{ {
TopoDS_Shape ancestor = its.Value(); TopoDS_Shape ancestor = its.Value();
TopTools_ListIteratorOfListOfShape itf(ancestorsInFace); TopTools_ListIteratorOfListOfShape itf(ancestorsInFace);
bool isInFace = false; bool isInFace = false;
for (; itf.More(); itf.Next()) for (; itf.More(); itf.Next())
{ {
TopoDS_Shape ancestorInFace = itf.Value(); TopoDS_Shape ancestorInFace = itf.Value();
if (ancestorInFace.IsSame(ancestor)) if (ancestorInFace.IsSame(ancestor))
{ {
isInFace = true; isInFace = true;
break; break;
} }
} }
if (!isInFace) if (!isInFace)
{ {
E = TopoDS::Edge(ancestor); E = TopoDS::Edge(ancestor);
break; break;
} }
} }
return E; return E;
} }
//============================================================================= //=============================================================================
@ -974,135 +974,135 @@ TopoDS_Edge
//============================================================================= //=============================================================================
void StdMeshers_Hexa_3D::GetConv2DCoefs(const faceQuadStruct & quad, void StdMeshers_Hexa_3D::GetConv2DCoefs(const faceQuadStruct & quad,
const TopoDS_Shape & aShape, const TopoDS_Shape & aShape,
const TopoDS_Vertex & V0, const TopoDS_Vertex & V0,
const TopoDS_Vertex & V1, const TopoDS_Vertex & V1,
const TopoDS_Vertex & V2, const TopoDS_Vertex & V3, Conv2DStruct & conv) const TopoDS_Vertex & V2, const TopoDS_Vertex & V3, Conv2DStruct & conv)
{ {
// MESSAGE("StdMeshers_Hexa_3D::GetConv2DCoefs"); // MESSAGE("StdMeshers_Hexa_3D::GetConv2DCoefs");
// const TopoDS_Face & F = TopoDS::Face(aShape); // const TopoDS_Face & F = TopoDS::Face(aShape);
// TopoDS_Edge E = quad.edge[0]; // TopoDS_Edge E = quad.edge[0];
// double f, l; // double f, l;
// Handle(Geom2d_Curve) C2d = BRep_Tool::CurveOnSurface(E, F, f, l); // Handle(Geom2d_Curve) C2d = BRep_Tool::CurveOnSurface(E, F, f, l);
// TopoDS_Vertex VFirst, VLast; // TopoDS_Vertex VFirst, VLast;
// TopExp::Vertices(E, VFirst, VLast); // corresponds to f and l // TopExp::Vertices(E, VFirst, VLast); // corresponds to f and l
// bool isForward = (((l - f) * (quad.last[0] - quad.first[0])) > 0); // bool isForward = (((l - f) * (quad.last[0] - quad.first[0])) > 0);
TopoDS_Vertex VA, VB; TopoDS_Vertex VA, VB;
// if (isForward) // if (isForward)
// { // {
// VA = VFirst; // VA = VFirst;
// VB = VLast; // VB = VLast;
// } // }
// else // else
// { // {
// VA = VLast; // VA = VLast;
// VB = VFirst; // VB = VFirst;
// } // }
VA = quad.side[0]->FirstVertex(); VA = quad.side[0]->FirstVertex();
VB = quad.side[0]->LastVertex(); VB = quad.side[0]->LastVertex();
int a1, b1, c1, a2, b2, c2; int a1, b1, c1, a2, b2, c2;
if (VA.IsSame(V0)) if (VA.IsSame(V0))
if (VB.IsSame(V1)) if (VB.IsSame(V1))
{ {
a1 = 1; a1 = 1;
b1 = 0; b1 = 0;
c1 = 0; // x c1 = 0; // x
a2 = 0; a2 = 0;
b2 = 1; b2 = 1;
c2 = 0; // y c2 = 0; // y
} }
else else
{ {
ASSERT(VB.IsSame(V3)); ASSERT(VB.IsSame(V3));
a1 = 0; a1 = 0;
b1 = 1; b1 = 1;
c1 = 0; // y c1 = 0; // y
a2 = 1; a2 = 1;
b2 = 0; b2 = 0;
c2 = 0; // x c2 = 0; // x
} }
if (VA.IsSame(V1)) if (VA.IsSame(V1))
if (VB.IsSame(V2)) if (VB.IsSame(V2))
{ {
a1 = 0; a1 = 0;
b1 = -1; b1 = -1;
c1 = 1; // 1-y c1 = 1; // 1-y
a2 = 1; a2 = 1;
b2 = 0; b2 = 0;
c2 = 0; // x c2 = 0; // x
} }
else else
{ {
ASSERT(VB.IsSame(V0)); ASSERT(VB.IsSame(V0));
a1 = -1; a1 = -1;
b1 = 0; b1 = 0;
c1 = 1; // 1-x c1 = 1; // 1-x
a2 = 0; a2 = 0;
b2 = 1; b2 = 1;
c2 = 0; // y c2 = 0; // y
} }
if (VA.IsSame(V2)) if (VA.IsSame(V2))
if (VB.IsSame(V3)) if (VB.IsSame(V3))
{ {
a1 = -1; a1 = -1;
b1 = 0; b1 = 0;
c1 = 1; // 1-x c1 = 1; // 1-x
a2 = 0; a2 = 0;
b2 = -1; b2 = -1;
c2 = 1; // 1-y c2 = 1; // 1-y
} }
else else
{ {
ASSERT(VB.IsSame(V1)); ASSERT(VB.IsSame(V1));
a1 = 0; a1 = 0;
b1 = -1; b1 = -1;
c1 = 1; // 1-y c1 = 1; // 1-y
a2 = -1; a2 = -1;
b2 = 0; b2 = 0;
c2 = 1; // 1-x c2 = 1; // 1-x
} }
if (VA.IsSame(V3)) if (VA.IsSame(V3))
if (VB.IsSame(V0)) if (VB.IsSame(V0))
{ {
a1 = 0; a1 = 0;
b1 = 1; b1 = 1;
c1 = 0; // y c1 = 0; // y
a2 = -1; a2 = -1;
b2 = 0; b2 = 0;
c2 = 1; // 1-x c2 = 1; // 1-x
} }
else else
{ {
ASSERT(VB.IsSame(V2)); ASSERT(VB.IsSame(V2));
a1 = 1; a1 = 1;
b1 = 0; b1 = 0;
c1 = 0; // x c1 = 0; // x
a2 = 0; a2 = 0;
b2 = -1; b2 = -1;
c2 = 1; // 1-y c2 = 1; // 1-y
} }
// MESSAGE("X = " << c1 << "+ " << a1 << "*x + " << b1 << "*y"); // MESSAGE("X = " << c1 << "+ " << a1 << "*x + " << b1 << "*y");
// MESSAGE("Y = " << c2 << "+ " << a2 << "*x + " << b2 << "*y"); // MESSAGE("Y = " << c2 << "+ " << a2 << "*x + " << b2 << "*y");
conv.a1 = a1; conv.a1 = a1;
conv.b1 = b1; conv.b1 = b1;
conv.c1 = c1; conv.c1 = c1;
conv.a2 = a2; conv.a2 = a2;
conv.b2 = b2; conv.b2 = b2;
conv.c2 = c2; conv.c2 = c2;
int nbdown = quad.side[0]->NbPoints(); int nbdown = quad.side[0]->NbPoints();
int nbright = quad.side[1]->NbPoints(); int nbright = quad.side[1]->NbPoints();
conv.ia = int (a1); conv.ia = int (a1);
conv.ib = int (b1); conv.ib = int (b1);
conv.ic = conv.ic =
int (c1 * a1 * a1) * (nbdown - 1) + int (c1 * b1 * b1) * (nbright - 1); int (c1 * a1 * a1) * (nbdown - 1) + int (c1 * b1 * b1) * (nbright - 1);
conv.ja = int (a2); conv.ja = int (a2);
conv.jb = int (b2); conv.jb = int (b2);
conv.jc = conv.jc =
int (c2 * a2 * a2) * (nbdown - 1) + int (c2 * b2 * b2) * (nbright - 1); int (c2 * a2 * a2) * (nbdown - 1) + int (c2 * b2 * b2) * (nbright - 1);
// MESSAGE("I " << conv.ia << " " << conv.ib << " " << conv.ic); // MESSAGE("I " << conv.ia << " " << conv.ib << " " << conv.ic);
// MESSAGE("J " << conv.ja << " " << conv.jb << " " << conv.jc); // MESSAGE("J " << conv.ja << " " << conv.jb << " " << conv.jc);
} }
//================================================================================ //================================================================================
@ -1189,8 +1189,8 @@ SMESH_ComputeErrorPtr ComputePentahedralMesh(SMESH_Mesh & aMesh,
//======================================================================= //=======================================================================
bool EvaluatePentahedralMesh(SMESH_Mesh & aMesh, bool EvaluatePentahedralMesh(SMESH_Mesh & aMesh,
const TopoDS_Shape & aShape, const TopoDS_Shape & aShape,
MapShapeNbElems& aResMap) MapShapeNbElems& aResMap)
{ {
StdMeshers_Penta_3D anAlgo; StdMeshers_Penta_3D anAlgo;
bool bOK = anAlgo.Evaluate(aMesh, aShape, aResMap); bool bOK = anAlgo.Evaluate(aMesh, aShape, aResMap);

Some files were not shown because too many files have changed in this diff Show More