-# Copyright (C) 2012-2016 CEA/DEN, EDF R&D, OPEN CASCADE
+# Copyright (C) 2012-2019 CEA/DEN, EDF R&D, OPEN CASCADE
#
# This library is free software; you can redistribute it and/or
# modify it under the terms of the GNU Lesser General Public
SET(${PROJECT_NAME_UC}_PATCH_VERSION 2)
SET(${PROJECT_NAME_UC}_VERSION
${${PROJECT_NAME_UC}_MAJOR_VERSION}.${${PROJECT_NAME_UC}_MINOR_VERSION}.${${PROJECT_NAME_UC}_PATCH_VERSION})
-SET(${PROJECT_NAME_UC}_VERSION_DEV 0)
+SET(${PROJECT_NAME_UC}_VERSION_DEV 1)
# Common CMake macros
# ===================
-// Copyright (C) 2007-2016 CEA/DEN, EDF R&D, OPEN CASCADE
+// Copyright (C) 2007-2019 CEA/DEN, EDF R&D, OPEN CASCADE
//
// Copyright (C) 2003-2007 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
#
###############################################################
-# Copyright (C) 2007-2016 CEA/DEN, EDF R&D, OPEN CASCADE
+# Copyright (C) 2007-2019 CEA/DEN, EDF R&D, OPEN CASCADE
#
# Copyright (C) 2003-2007 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
# CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
-# Copyright (C) 2007-2016 CEA/DEN, EDF R&D, OPEN CASCADE
+# Copyright (C) 2007-2019 CEA/DEN, EDF R&D, OPEN CASCADE
#
# Copyright (C) 2003-2007 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
# CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
-# Copyright (C) 2012-2016 CEA/DEN, EDF R&D, OPEN CASCADE
+# Copyright (C) 2012-2019 CEA/DEN, EDF R&D, OPEN CASCADE
#
# This library is free software; you can redistribute it and/or
# modify it under the terms of the GNU Lesser General Public
-# Copyright (C) 2007-2016 CEA/DEN, EDF R&D, OPEN CASCADE
+# Copyright (C) 2007-2019 CEA/DEN, EDF R&D, OPEN CASCADE
#
# Copyright (C) 2003-2007 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
# CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
-dnl Copyright (C) 2007-2016 CEA/DEN, EDF R&D, OPEN CASCADE
+dnl Copyright (C) 2007-2019 CEA/DEN, EDF R&D, OPEN CASCADE
dnl
dnl Copyright (C) 2003-2007 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
dnl CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
-dnl Copyright (C) 2007-2016 CEA/DEN, EDF R&D, OPEN CASCADE
+dnl Copyright (C) 2007-2019 CEA/DEN, EDF R&D, OPEN CASCADE
dnl
dnl Copyright (C) 2003-2007 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
dnl CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
-# Copyright (C) 2012-2016 CEA/DEN, EDF R&D, OPEN CASCADE
+# Copyright (C) 2012-2019 CEA/DEN, EDF R&D, OPEN CASCADE
#
# This library is free software; you can redistribute it and/or
# modify it under the terms of the GNU Lesser General Public
-# Copyright (C) 2007-2016 CEA/DEN, EDF R&D, OPEN CASCADE
+# Copyright (C) 2007-2019 CEA/DEN, EDF R&D, OPEN CASCADE
#
# Copyright (C) 2003-2007 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
# CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
-# Copyright (C) 2007-2016 CEA/DEN, EDF R&D, OPEN CASCADE
+# Copyright (C) 2007-2019 CEA/DEN, EDF R&D, OPEN CASCADE
#
# Copyright (C) 2003-2007 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
# CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
-# Copyright (C) 2013-2016 CEA/DEN, EDF R&D, OPEN CASCADE
+# Copyright (C) 2013-2019 CEA/DEN, EDF R&D, OPEN CASCADE
#
# This library is free software; you can redistribute it and/or
# modify it under the terms of the GNU Lesser General Public
-# Copyright (C) 2007-2016 CEA/DEN, EDF R&D, OPEN CASCADE
+# Copyright (C) 2007-2019 CEA/DEN, EDF R&D, OPEN CASCADE
#
# Copyright (C) 2003-2007 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
# CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
-# Copyright (C) 2012-2016 CEA/DEN, EDF R&D, OPEN CASCADE
+# Copyright (C) 2012-2019 CEA/DEN, EDF R&D, OPEN CASCADE
#
# This library is free software; you can redistribute it and/or
# modify it under the terms of the GNU Lesser General Public
-# Copyright (C) 2007-2016 CEA/DEN, EDF R&D, OPEN CASCADE
-#
-# Copyright (C) 2003-2007 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
-# CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
-#
-# This library is free software; you can redistribute it and/or
-# modify it under the terms of the GNU Lesser General Public
-# License as published by the Free Software Foundation; either
-# version 2.1 of the License, or (at your option) any later version.
-#
-# This library is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
-# Lesser General Public License for more details.
-#
-# You should have received a copy of the GNU Lesser General Public
-# License along with this library; if not, write to the Free Software
-# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
-#
-# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
-#
-
#---------------------------------------------------------------------------
# Project related configuration options
#---------------------------------------------------------------------------
-# Copyright (C) 2007-2016 CEA/DEN, EDF R&D, OPEN CASCADE
-#
-# Copyright (C) 2003-2007 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
-# CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
-#
-# This library is free software; you can redistribute it and/or
-# modify it under the terms of the GNU Lesser General Public
-# License as published by the Free Software Foundation; either
-# version 2.1 of the License, or (at your option) any later version.
-#
-# This library is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
-# Lesser General Public License for more details.
-#
-# You should have received a copy of the GNU Lesser General Public
-# License along with this library; if not, write to the Free Software
-# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
-#
-# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
-#
-
#---------------------------------------------------------------------------
# Project related configuration options
#---------------------------------------------------------------------------
\page netgen_2d_3d_hypo_page NETGEN 2D and 3D hypotheses
-<b>NETGEN 2D Parameters</b> and <b>NETGEN 3D Parameters</b> hypotheses work only with
-<b>NETGEN 1D-2D</b>, <b>NETGEN 2D</b>, <b>NETGEN 1D-2D-3D</b> and
-<b>NETGEN 3D</b> algorithms. <b>NETGEN 1D-2D</b> and <b>NETGEN
-1D-2D-3D</b> algorithms do not require definition of lower-level
-hypotheses and algorithms (2D and 1D for meshing 3D objects and 1D for
-meshing 2D objects).
+<b>NETGEN 2D Parameters</b> and <b>NETGEN 3D Parameters</b>
+hypotheses work only with NETGEN algorithm in it's different forms:
+- <b>NETGEN 1D-2D</b>
+- <b>NETGEN 2D</b>
+- <b>NETGEN 1D-2D-3D</b>
+- <b>NETGEN 3D</b>.
-\image html netgen2d3d.png
-<center><em>Hypothesis dialog boxes of <b>NETGEN 1D-2D</b> and <b>NETGEN
- 1D-2D-3D</b> algorithms are same</em></center>
-<br>
+<b>NETGEN 1D-2D</b> and <b>NETGEN 1D-2D-3D</b> algorithms do not
+ require definition of lower-level hypotheses and algorithms (2D and
+ 1D for meshing 3D objects and 1D for meshing 2D objects).
-\image html netgen2d3d_only.png
-<center><em>Dialog boxes of <b>NETGEN 2D</b> and <b>NETGEN 3D</b>
- algorithms </em></center>
-<br>
-\image html netgen2d_remesher.png
-<center><em>Hypothesis dialog box of <b>NETGEN 2D</b> remesher algorithms</em></center>
+<b>NETGEN 1D-2D-3D</b> algorithm has maximal number of options. The
+rest forms have less options as they construct elements of less number
+of dimensions. All options are distributed among following tabs:
+- \ref arguments_anchor "Arguments" - basic options.
+- \ref local_sizes_anchor "Local Sizes" - local element size.
+- \ref advanced_anchor "Advanced" - advanced options.
+- \ref stl_anchor "STL" - specific Remesher options.
+
+\ref simple_anchor "NETGEN 2D/3D simple parameters" hypotheses allow
+defining the size of elements for each dimension separately.
+\anchor arguments_anchor
+<h2> Arguments tab</h2>
+
+<b>Arguments</b> tab defines basic mesh parameters.
+
+\image html netgen2d3d.png
+<center><em>Main tab of hypothesis dialog box <b>NETGEN 1D-2D-3D</b> algorithm</em></center>
+<br>
+
- <b>Name</b> - allows to define the name for the algorithm (NETGEN
2D (or 3D) Parameters by default).
- <b>Max Size</b> - maximum linear dimensions for mesh cells.
- <b>Min Size</b> - minimum linear dimensions for mesh cells. It is
ignored if it is more than <b>Max Size</b>.
-- <b>Second Order</b> - if this box is checked in, the algorithm will
-create second order mesh.
- <b>Fineness</b> - ranging from <em>Very Coarse</em> to <em>Very Fine</em>
allows to set the level of meshing detalization using the three
parameters below. You can select \a Custom to define them manually.
into account.) If this box is not checked in, then size of elements is
defined by three parameters only:
<b>Max Size</b>, <b>Min Size</b> and <b>Growth rate</b>.
-- <b>Allow Quadrangles</b> - if this box is checked in, the mesher
+- <b>Quad-dominated</b> - if this box is checked in, the mesher
tries to generate quadrangle 2D mesh. Triangle elements are created
where quadrangles are not possible.
+- <b>Second Order</b> - if this box is checked in, the algorithm will
+create second order mesh.
- <b>Optimize</b> - if this box is checked in, the algorithm will modify
initially created mesh in order to improve quality of elements. Optimization
-process is rather time consuming comparing to creation of initial mesh.
-- <b>Fuse Coincident Nodes on Edges and Vertices</b> - allows merging
-mesh nodes on vertices and edges which are geometrically coincident
-but are topologically different.
-- <b>Ridge angle</b> - allows to define minimum angle in degrees between
-normals of adjacent triangles at which the remesher (Netgen 2D working
-w/o geometry) considers the edge between these triangles as a feature edge.
+process is rather time consuming comparing to creation of initial
+mesh.
+
+Remesher has two additional basic options:
+- <b>Keep existing edges</b> - if activated, all edges present in the
+initial mesh are kept and used to separate STL surfaces.
+- <b>Create groups of surfaces </b> if activated, all new surface
+elements are distributed among groups corresponding to STL surfaces
+the Remesher detects.
+
+
+\anchor local_sizes_anchor
+<h2> Local sizes tab</h2>
+
+<b>Local sizes</b> tab allows to define size of elements on and
+around specified geometrical objects.
\image html netgen3d_local_size.png
-- <b>Local sizes</b> - allows to define size of elements on and
-around specified geometrical objects. To define the local
+- To define the local
size it is necessary to select a geometrical objects in the
object browser or in the viewer, and to click a button corresponding
to the type of the geometrical objects: <b>On Vertex</b>, <b>On
25, 0) and (25, 25, 200) size of elements should be 0.3.
-\image html netgen2d3d_simple.png
+
+\anchor advanced_anchor
+<h2> Advanced tab</h2>
+
+<b>Advanced</b> tab allows advance controlling meshing algorithm.
+
+\image html netgen_advanced.png
+
+- <b>Element size weight</b> - weight of triangle size badness with respect to
+triangle shape badness. Total triangle badness is evaluated as <em>
+ shape_badness + size_weight * size_mismatch</em>.
+- <b>Nb. surface optimization steps</b> - number of loops when optimizing surface mesh.
+- <b>Nb. volume optimization steps</b> - number of loops when optimizing volume mesh.
+- <b>Worst element measure</b> - power of error, used to approximate max error optimization.
+- <b>Use Delaunay</b> - if activated, use Delaunay approach to
+construct volume elements, otherwise use Advancing front method.
+- <b>Check overlapping</b> - check overlapping surfaces during surface meshing.
+- <b>Check chart boundary</b> - to check chart boundary.
+- <b>Fuse Coincident Nodes on Edges and Vertices</b> - allows merging
+mesh nodes on vertices and edges which are geometrically coincident
+but are topologically different.
+
+
+
+\anchor stl_anchor
+<h2> STL tab</h2>
+
+<b> STL </b> tab holds option of Remesher (NETGEN 2D working w/o geometry).
+
+\image html netgen2d_remesher.png
+<center><em>Options specific to <b>NETGEN 2D</b> remesher algorithms</em></center>
+
+
+- <b>Ridge angle</b> - defines minimum angle in degrees between
+normals of adjacent triangles at which the remesher considers the edge
+between these triangles as a feature edge. Feature edges bound charts
+of triangles that are re-meshed as separate surfaces.
+- <b> Edge corner angle </b> - defines minimum angle in degrees
+between adjacent edges of chart boundary, above which a point shared
+by the edges is considered as an end point of chart boundary curve.
+- <b> Chart angle </b> - angle between normals of adjacent triangles
+under which a shared sharp edge is <em>not</em> considered as chart boundary,
+provided that this edge is not classified as chart boundary due
+to <b>Ridge angle</b> and <b>Keep existing edges</b> options.
+- <b> Outer chart angle </b> - angle for overlapping parts of chart.
+- <b> Chart distance </b> - defines a factor used to limit element
+size by distance to neighbor chart.
+- <b> Line length </b> - defines a factor used to limit size
+of elements located near ends of chart boundary curves by length of a
+chart boundary curve.
+- <b> Close edges </b> - defines a factor used to limit size
+of elements located near chart boundary curves by distance to other
+chart boundary curves.
+- <b> Surface curvature </b> - defines a factor used to limit size
+of elements by surface curvature.
+- <b> Edge angle </b> - defines a factor used to limit size
+of elements by chart boundary curve curvature.
+- <b> Surface mesh curvature</b> - defines a number of elements per
+curvature radius.
+
+\anchor simple_anchor
+<h2> NETGEN 2D/3D simple parameters</h2>
<b>NETGEN 2D simple parameters</b> and <b>NETGEN 3D simple
-parameters</b> allow defining the size of elements for each
+parameters</b> hypotheses allow defining the size of elements for each
dimension.
+\image html netgen2d3d_simple.png
+
\b 1D group allows defining the size of 1D elements in either of two ways:
- <b>Number of Segments</b> allows specifying number of segments, that
will split each edge, with equidistant distribution.
<ul>
$navpath
<li class="footer">
- Copyright © 2007-2017 CEA/DEN, EDF R&D, OPEN CASCADE<br>
+ Copyright © 2007-2019 CEA/DEN, EDF R&D, OPEN CASCADE<br>
Copyright © 2003-2007 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN, CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS<br>
</li>
</ul>
-# Copyright (C) 2012-2016 CEA/DEN, EDF R&D, OPEN CASCADE
+# Copyright (C) 2012-2019 CEA/DEN, EDF R&D, OPEN CASCADE
#
# This library is free software; you can redistribute it and/or
# modify it under the terms of the GNU Lesser General Public
-// Copyright (C) 2007-2016 CEA/DEN, EDF R&D, OPEN CASCADE
+// Copyright (C) 2007-2019 CEA/DEN, EDF R&D, OPEN CASCADE
//
// Copyright (C) 2003-2007 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
#include "SALOME_Exception.idl"
#include "SMESH_Hypothesis.idl"
+#include "SMESH_Group.idl"
#include "GEOM_Gen.idl"
/*!
*/
interface NETGENPlugin_Hypothesis : SMESH::SMESH_Hypothesis
{
- void SetMaxSize(in double value);
- double GetMaxSize();
+ void SetMaxSize(in double value);
+ double GetMaxSize();
- void SetMinSize(in double value);
- double GetMinSize();
+ void SetMinSize(in double value);
+ double GetMinSize();
- void SetSecondOrder(in boolean value);
+ void SetSecondOrder(in boolean value);
boolean GetSecondOrder();
- void SetOptimize(in boolean value);
+ void SetOptimize(in boolean value);
boolean GetOptimize();
- void SetFineness(in long value);
- long GetFineness();
+ void SetFineness(in long value);
+ long GetFineness();
- void SetGrowthRate(in double value);
- double GetGrowthRate();
+ void SetGrowthRate(in double value);
+ double GetGrowthRate();
- void SetNbSegPerEdge(in double value);
- double GetNbSegPerEdge();
+ void SetNbSegPerEdge(in double value);
+ double GetNbSegPerEdge();
- void SetChordalErrorEnabled(in boolean value);
+ void SetChordalErrorEnabled(in boolean value);
boolean GetChordalErrorEnabled();
- void SetChordalError(in double value);
- double GetChordalError();
+ void SetChordalError(in double value);
+ double GetChordalError();
- void SetNbSegPerRadius(in double value);
- double GetNbSegPerRadius();
+ void SetNbSegPerRadius(in double value);
+ double GetNbSegPerRadius();
- void SetQuadAllowed(in boolean value);
+ void SetQuadAllowed(in boolean value);
boolean GetQuadAllowed();
- void SetUseSurfaceCurvature(in boolean value);
+ void SetUseSurfaceCurvature(in boolean value);
boolean GetUseSurfaceCurvature();
- void SetFuseEdges(in boolean value);
+ void SetFuseEdges(in boolean value);
boolean GetFuseEdges();
- void SetLocalSizeOnShape(in GEOM::GEOM_Object GeomObj, in double localSize)
+ void SetLocalSizeOnShape(in GEOM::GEOM_Object GeomObj, in double localSize)
raises (SALOME::SALOME_Exception);
- void SetLocalSizeOnEntry(in string entry, in double localSize);
- double GetLocalSizeOnEntry(in string entry);
+ void SetLocalSizeOnEntry(in string entry, in double localSize);
+ double GetLocalSizeOnEntry(in string entry);
string_array GetLocalSizeEntries();
- void UnsetLocalSizeOnEntry(in string entry);
+ void UnsetLocalSizeOnEntry(in string entry);
- void SetMeshSizeFile(in string fileName);
- string GetMeshSizeFile();
+ void SetMeshSizeFile(in string fileName);
+ string GetMeshSizeFile();
+
+ void SetNbSurfOptSteps(in short nb );
+ short GetNbSurfOptSteps();
+
+ void SetNbVolOptSteps(in short nb );
+ short GetNbVolOptSteps();
+
+ void SetElemSizeWeight(in double size );
+ double GetElemSizeWeight();
+
+ void SetWorstElemMeasure(in short val );
+ short GetWorstElemMeasure();
+
+ void SetUseDelauney(in boolean toUse);
+ boolean GetUseDelauney();
+
+ void SetCheckOverlapping(in boolean toCheck );
+ boolean GetCheckOverlapping();
+
+ void SetCheckChartBoundary(in boolean toCheck );
+ boolean GetCheckChartBoundary();
};
/*!
/*!
* \brief Set/get ridge angle
*/
- void SetRidgeAngle(in double angle );
- double GetRidgeAngle();
+ void SetRidgeAngle(in double angle );
+ double GetRidgeAngle();
+
+ void SetEdgeCornerAngle(in double angle );
+ double GetEdgeCornerAngle();
+
+ void SetChartAngle(in double angle );
+ double GetChartAngle();
+
+ void SetOuterChartAngle(in double angle );
+ double GetOuterChartAngle();
+
+ void SetRestHChartDistFactor(in double f );
+ double GetRestHChartDistFactor();
+
+ void SetRestHChartDistEnable(in boolean enable );
+ boolean GetRestHChartDistEnable();
+
+ void SetRestHLineLengthFactor(in double f );
+ double GetRestHLineLengthFactor();
+
+ void SetRestHLineLengthEnable(in boolean enable );
+ boolean GetRestHLineLengthEnable();
+
+ void SetRestHCloseEdgeFactor(in double f );
+ double GetRestHCloseEdgeFactor();
+
+ void SetRestHCloseEdgeEnable(in boolean enable );
+ boolean GetRestHCloseEdgeEnable();
+
+ void SetRestHSurfCurvFactor(in double f );
+ double GetRestHSurfCurvFactor();
+
+ void SetRestHSurfCurvEnable(in boolean enable );
+ boolean GetRestHSurfCurvEnable();
+
+ void SetRestHEdgeAngleFactor(in double f );
+ double GetRestHEdgeAngleFactor();
+
+ void SetRestHEdgeAngleEnable(in boolean enable );
+ boolean GetRestHEdgeAngleEnable();
+
+ void SetRestHSurfMeshCurvFactor(in double f );
+ double GetRestHSurfMeshCurvFactor();
+
+ void SetRestHSurfMeshCurvEnable(in boolean enable );
+ boolean GetRestHSurfMeshCurvEnable();
+
+ void SetKeepExistingEdges(in boolean toKeep );
+ boolean GetKeepExistingEdges();
+
+ void SetMakeGroupsOfSurfaces(in boolean toMake );
+ boolean GetMakeGroupsOfSurfaces();
+
+ void SetLoadMeshOnCancel(in boolean toLoad );
+ boolean GetLoadMeshOnCancel();
+
+ void SetFixedEdgeGroup( in SMESH::SMESH_GroupBase edgeGroup );
+ SMESH::SMESH_GroupBase GetFixedEdgeGroup( in SMESH::SMESH_Mesh mesh );
};
/*!
-# Copyright (C) 2007-2016 CEA/DEN, EDF R&D, OPEN CASCADE
+# Copyright (C) 2007-2019 CEA/DEN, EDF R&D, OPEN CASCADE
#
# Copyright (C) 2003-2007 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
# CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
<?xml version='1.0' encoding='us-ascii'?>
<!DOCTYPE meshers PUBLIC "" "desktop.dtd">
-<!--
- Copyright (C) 2007-2016 CEA/DEN, EDF R&D, OPEN CASCADE
-
- Copyright (C) 2003-2007 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
- CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
-
- This library is free software; you can redistribute it and/or
- modify it under the terms of the GNU Lesser General Public
- License as published by the Free Software Foundation; either
- version 2.1 of the License, or (at your option) any later version.
-
- This library is distributed in the hope that it will be useful,
- but WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- Lesser General Public License for more details.
-
- You should have received a copy of the GNU Lesser General Public
- License along with this library; if not, write to the Free Software
- Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
-
- See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
-
--->
-
-<!-- GUI customization for MESH component -->
<meshers>
-<!--
- Copyright (C) 2007-2016 CEA/DEN, EDF R&D, OPEN CASCADE
-
- Copyright (C) 2003-2007 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
- CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
-
- This library is free software; you can redistribute it and/or
- modify it under the terms of the GNU Lesser General Public
- License as published by the Free Software Foundation; either
- version 2.1 of the License, or (at your option) any later version.
-
- This library is distributed in the hope that it will be useful,
- but WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- Lesser General Public License for more details.
-
- You should have received a copy of the GNU Lesser General Public
- License along with this library; if not, write to the Free Software
- Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
-
- See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
-
--->
<document>
<section name="resources">
<parameter name="NETGENPlugin" value="${NETGENPLUGIN_ROOT_DIR}/share/salome/resources/netgenplugin"/>
</section>
- <section name="SMESH">
- <!-- Default SMESH module plugins -->
- <parameter name="plugins" value="NETGENPlugin,GHS3DPlugin"/>
- </section>
<section name="smesh_help">
<parameter name="User's Guide/Mesh module/Plug-ins/NETGEN plugin" value="${NETGENPLUGIN_ROOT_DIR}/share/doc/salome/gui/NETGENPLUGIN/index.html;;http://docs.salome-platform.org/latest/gui/NETGENPLUGIN/index.html"/>
</section>
-# Copyright (C) 2012-2016 CEA/DEN, EDF R&D, OPEN CASCADE
+# Copyright (C) 2012-2019 CEA/DEN, EDF R&D, OPEN CASCADE
#
# This library is free software; you can redistribute it and/or
# modify it under the terms of the GNU Lesser General Public
-# Copyright (C) 2012-2016 CEA/DEN, EDF R&D, OPEN CASCADE
+# Copyright (C) 2012-2019 CEA/DEN, EDF R&D, OPEN CASCADE
#
# This library is free software; you can redistribute it and/or
# modify it under the terms of the GNU Lesser General Public
-// Copyright (C) 2007-2016 CEA/DEN, EDF R&D, OPEN CASCADE
+// Copyright (C) 2007-2019 CEA/DEN, EDF R&D, OPEN CASCADE
//
// Copyright (C) 2003-2007 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
-// Copyright (C) 2007-2016 CEA/DEN, EDF R&D, OPEN CASCADE
+// Copyright (C) 2007-2019 CEA/DEN, EDF R&D, OPEN CASCADE
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
-// Copyright (C) 2007-2016 CEA/DEN, EDF R&D, OPEN CASCADE
+// Copyright (C) 2007-2019 CEA/DEN, EDF R&D, OPEN CASCADE
//
// Copyright (C) 2003-2007 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
#include CORBA_SERVER_HEADER(NETGENPlugin_Algorithm)
+#include <LightApp_SelectionMgr.h>
+#include <SALOME_ListIO.hxx>
#include <SUIT_FileDlg.h>
#include <SUIT_ResourceMgr.h>
#include <SUIT_Session.h>
-
+#include <SalomeApp_IntSpinBox.h>
#include <SalomeApp_Tools.h>
-#include <LightApp_SelectionMgr.h>
-#include <SALOME_ListIO.hxx>
#include <QComboBox>
#include <QLabel>
#include <QHeaderView>
#include <QPushButton>
-enum Fineness
- {
- VeryCoarse,
- Coarse,
- Moderate,
- Fine,
- VeryFine,
- UserDefined
- };
+enum Fineness {
+ VeryCoarse,
+ Coarse,
+ Moderate,
+ Fine,
+ VeryFine,
+ UserDefined
+};
enum {
STD_TAB = 0,
- LSZ_TAB
+ STL_TAB,
+ LSZ_TAB,
+ ADV_TAB
};
enum {
LSZ_FILE_LE = 9
};
+template<class SPINBOX, typename VALUETYPE>
+void setTextOrVar( SPINBOX* spin, VALUETYPE value, const QString& variable )
+{
+ if ( spin )
+ {
+ if ( variable.isEmpty() )
+ spin->setValue( value );
+ else
+ spin->setText( variable );
+ }
+}
+
NETGENPluginGUI_HypothesisCreator::NETGENPluginGUI_HypothesisCreator( const QString& theHypType )
: SMESHGUI_GenericHypothesisCreator( theHypType )
{
readParamsFromHypo( data_old );
readParamsFromWidgets( data_new );
bool res = storeParamsToHypo( data_new );
- //storeParamsToHypo( data_old ); -- issue 0021364: Dump of netgen parameters has duplicate lines
-
- res = myMaxSize->isValid(msg,true) && res;
- res = myMinSize->isValid(msg,true) && res;
- res = myGrowthRate->isValid(msg,true) && res; ;
- if ( myNbSegPerEdge )
- res = myNbSegPerEdge->isValid(msg,true) && res;
- if ( myNbSegPerRadius )
- res = myNbSegPerRadius->isValid(msg,true) && res;
- if ( myRidgeAngle )
- res = myRidgeAngle->isValid(msg,true) && res;
if ( !res ) // -- issue 0021364: Dump of netgen parameters has duplicate lines
storeParamsToHypo( data_old );
tab->setTabShape( QTabWidget::Rounded );
tab->setTabPosition( QTabWidget::North );
lay->addWidget( tab );
+
+ // ==============
+ // Arguments TAB
+ // ==============
+
QWidget* GroupC1 = new QWidget();
tab->insertTab( STD_TAB, GroupC1, tr( "SMESH_ARGUMENTS" ) );
-
+
QGridLayout* aGroupLayout = new QGridLayout( GroupC1 );
- aGroupLayout->setSpacing( 6 );
- aGroupLayout->setMargin( 11 );
-
- int row = 0;
+ aGroupLayout->setMargin( 6 );
+ aGroupLayout->setSpacing( 11 );
+
+ int row0 = 0;
myName = 0;
- if( isCreation() )
+ if ( isCreation() )
{
- aGroupLayout->addWidget( new QLabel( tr( "SMESH_NAME" ), GroupC1 ), row, 0 );
+ aGroupLayout->addWidget( new QLabel( tr( "SMESH_NAME" ), GroupC1 ), row0, 0 );
myName = new QLineEdit( GroupC1 );
myName->setMinimumWidth(160);
- aGroupLayout->addWidget( myName, row, 1 );
- row++;
+ aGroupLayout->addWidget( myName, row0, 1 );
+ row0++;
}
- aGroupLayout->addWidget( new QLabel( tr( "NETGEN_MAX_SIZE" ), GroupC1 ), row, 0 );
- myMaxSize = new SMESHGUI_SpinBox( GroupC1 );
- myMaxSize->RangeStepAndValidator( 1e-07, 1e+06, 10., "length_precision" );
- aGroupLayout->addWidget( myMaxSize, row, 1 );
- row++;
+ // Mesh size group
+ // ----------------
+ {
+ QGroupBox* aSizeBox = new QGroupBox( tr("NETGEN_MESH_SIZE"), GroupC1 );
+ aGroupLayout->addWidget( aSizeBox, row0, 0, 1, 2 );
+ row0++;
+
+ QGridLayout* aSizeLayout = new QGridLayout( aSizeBox );
+ aSizeLayout->setSpacing( 6 );
+ aSizeLayout->setMargin( 11 );
+ int row = 0;
+
+ aSizeLayout->addWidget( new QLabel( tr( "NETGEN_MAX_SIZE" ), aSizeBox ), row, 0 );
+ myMaxSize = new SMESHGUI_SpinBox( aSizeBox );
+ myMaxSize->RangeStepAndValidator( 1e-07, 1e+06, 10., "length_precision" );
+ aSizeLayout->addWidget( myMaxSize, row, 1 );
+ row++;
+
+ aSizeLayout->addWidget( new QLabel( tr( "NETGEN_MIN_SIZE" ), aSizeBox ), row, 0 );
+ myMinSize = new SMESHGUI_SpinBox( aSizeBox );
+ myMinSize->RangeStepAndValidator( 0.0, 1e+06, 10., "length_precision" );
+ aSizeLayout->addWidget( myMinSize, row, 1 );
+ row++;
+
+ aSizeLayout->addWidget( new QLabel( tr( "NETGEN_FINENESS" ), aSizeBox ), row, 0 );
+ myFineness = new QComboBox( aSizeBox );
+ QStringList types;
+ types << tr( "NETGEN_VERYCOARSE" ) << tr( "NETGEN_COARSE" ) << tr( "NETGEN_MODERATE" ) <<
+ tr( "NETGEN_FINE" ) << tr( "NETGEN_VERYFINE" ) << tr( "NETGEN_CUSTOM" );
+ myFineness->addItems( types );
+ aSizeLayout->addWidget( myFineness, row, 1 );
+ connect( myFineness, SIGNAL( activated( int ) ), this, SLOT( onFinenessChanged() ) );
+ row++;
+
+ aSizeLayout->addWidget( new QLabel( tr( "NETGEN_GROWTH_RATE" ), aSizeBox ), row, 0 );
+ myGrowthRate = new SMESHGUI_SpinBox( aSizeBox );
+ myGrowthRate->RangeStepAndValidator( .0001, 10., .1, "parametric_precision" );
+ aSizeLayout->addWidget( myGrowthRate, row, 1 );
+ row++;
+
+ myNbSegPerEdge = 0;
+ myNbSegPerRadius = 0;
+ if ( !myIsONLY )
+ {
+ const double VALUE_MAX = 1.0e+6;
+
+ aSizeLayout->addWidget( new QLabel( tr( "NETGEN_SEG_PER_EDGE" ), aSizeBox ), row, 0 );
+ myNbSegPerEdge = new SMESHGUI_SpinBox( aSizeBox );
+ myNbSegPerEdge->RangeStepAndValidator( .2, VALUE_MAX, .1, "parametric_precision" );
+ aSizeLayout->addWidget( myNbSegPerEdge, row, 1 );
+ row++;
+
+ aSizeLayout->addWidget( new QLabel( tr( "NETGEN_SEG_PER_RADIUS" ), aSizeBox ), row, 0 );
+ myNbSegPerRadius = new SMESHGUI_SpinBox( aSizeBox );
+ myNbSegPerRadius->RangeStepAndValidator( .2, VALUE_MAX, .1, "parametric_precision" );
+ aSizeLayout->addWidget( myNbSegPerRadius, row, 1 );
+ row++;
+ }
- aGroupLayout->addWidget( new QLabel( tr( "NETGEN_MIN_SIZE" ), GroupC1 ), row, 0 );
- myMinSize = new SMESHGUI_SpinBox( GroupC1 );
- myMinSize->RangeStepAndValidator( 0.0, 1e+06, 10., "length_precision" );
- aGroupLayout->addWidget( myMinSize, row, 1 );
- row++;
+ myChordalErrorEnabled = 0;
+ myChordalError = 0;
+ if (( myIs2D && !isRemesher ) || !myIsONLY )
+ {
+ myChordalErrorEnabled = new QCheckBox( tr( "NETGEN_CHORDAL_ERROR" ), aSizeBox );
+ aSizeLayout->addWidget( myChordalErrorEnabled, row, 0 );
+ myChordalError = new SMESHGUI_SpinBox( aSizeBox );
+ myChordalError->RangeStepAndValidator( COORD_MIN, COORD_MAX, .1, "length_precision" );
+ aSizeLayout->addWidget( myChordalError, row, 1 );
+ connect( myChordalErrorEnabled, SIGNAL( stateChanged(int)), SLOT( onChordalErrorEnabled()));
+ row++;
+ }
+
+ mySurfaceCurvature = 0;
+ if (( myIs2D && !isRemesher ) || !myIsONLY )
+ {
+ mySurfaceCurvature = new QCheckBox( tr( "NETGEN_SURFACE_CURVATURE" ), aSizeBox );
+ aSizeLayout->addWidget( mySurfaceCurvature, row, 0, 1, 2 );
+ connect( mySurfaceCurvature, SIGNAL( stateChanged( int ) ), this, SLOT( onSurfaceCurvatureChanged() ) );
+ row++;
+ }
+ } // end Mesh Size box
+
+ myAllowQuadrangles = 0;
+ if ( myIs2D || !myIsONLY ) // disable only for NETGEN 3D
+ {
+ myAllowQuadrangles = new QCheckBox( tr( "NETGEN_ALLOW_QUADRANGLES" ), GroupC1 );
+ aGroupLayout->addWidget( myAllowQuadrangles, row0, 0, 1, 2 );
+ row0++;
+ }
mySecondOrder = 0;
if ( !myIsONLY )
{
mySecondOrder = new QCheckBox( tr( "NETGEN_SECOND_ORDER" ), GroupC1 );
- aGroupLayout->addWidget( mySecondOrder, row, 0, 1, 2 );
- row++;
+ aGroupLayout->addWidget( mySecondOrder, row0, 0, 1, 2 );
+ row0++;
}
- aGroupLayout->addWidget( new QLabel( tr( "NETGEN_FINENESS" ), GroupC1 ), row, 0 );
- myFineness = new QComboBox( GroupC1 );
- QStringList types;
- types << tr( "NETGEN_VERYCOARSE" ) << tr( "NETGEN_COARSE" ) << tr( "NETGEN_MODERATE" ) <<
- tr( "NETGEN_FINE" ) << tr( "NETGEN_VERYFINE" ) << tr( "NETGEN_CUSTOM" );
- myFineness->addItems( types );
- aGroupLayout->addWidget( myFineness, row, 1 );
- connect( myFineness, SIGNAL( activated( int ) ), this, SLOT( onFinenessChanged() ) );
- row++;
-
- aGroupLayout->addWidget( new QLabel( tr( "NETGEN_GROWTH_RATE" ), GroupC1 ), row, 0 );
- myGrowthRate = new SMESHGUI_SpinBox( GroupC1 );
- myGrowthRate->RangeStepAndValidator( .0001, 10., .1, "parametric_precision" );
- aGroupLayout->addWidget( myGrowthRate, row, 1 );
- row++;
-
- myNbSegPerEdge = 0;
- myNbSegPerRadius = 0;
- if ( !myIsONLY )
+ myOptimize = 0;
+ // if ( !isRemesher ) ???
{
- const double VALUE_MAX = 1.0e+6;
-
- aGroupLayout->addWidget( new QLabel( tr( "NETGEN_SEG_PER_EDGE" ), GroupC1 ), row, 0 );
- myNbSegPerEdge = new SMESHGUI_SpinBox( GroupC1 );
- myNbSegPerEdge->RangeStepAndValidator( .2, VALUE_MAX, .1, "parametric_precision" );
- aGroupLayout->addWidget( myNbSegPerEdge, row, 1 );
- row++;
-
- aGroupLayout->addWidget( new QLabel( tr( "NETGEN_SEG_PER_RADIUS" ), GroupC1 ), row, 0 );
- myNbSegPerRadius = new SMESHGUI_SpinBox( GroupC1 );
- myNbSegPerRadius->RangeStepAndValidator( .2, VALUE_MAX, .1, "parametric_precision" );
- aGroupLayout->addWidget( myNbSegPerRadius, row, 1 );
- row++;
+ myOptimize = new QCheckBox( tr( "NETGEN_OPTIMIZE" ), GroupC1 );
+ aGroupLayout->addWidget( myOptimize, row0, 0, 1, 2 );
+ row0++;
}
- myChordalErrorEnabled = 0;
- myChordalError = 0;
- if (( myIs2D && !isRemesher ) || !myIsONLY )
+ myKeepExistingEdges = myMakeGroupsOfSurfaces = 0;
+ if ( isRemesher )
{
- myChordalErrorEnabled = new QCheckBox( tr( "NETGEN_CHORDAL_ERROR" ), GroupC1 );
- aGroupLayout->addWidget( myChordalErrorEnabled, row, 0 );
- myChordalError = new SMESHGUI_SpinBox( GroupC1 );
- myChordalError->RangeStepAndValidator( COORD_MIN, COORD_MAX, .1, "length_precision" );
- aGroupLayout->addWidget( myChordalError, row, 1 );
- connect( myChordalErrorEnabled, SIGNAL( stateChanged(int)), SLOT( onChordalErrorEnabled()));
- row++;
+ myKeepExistingEdges = new QCheckBox( tr( "NETGEN_KEEP_EXISTING_EDGES" ), GroupC1 );
+ aGroupLayout->addWidget( myKeepExistingEdges, row0, 0, 1, 2 );
+ row0++;
+
+ myMakeGroupsOfSurfaces = new QCheckBox( tr( "NETGEN_MAKE_SURFACE_GROUPS" ), GroupC1 );
+ aGroupLayout->addWidget( myMakeGroupsOfSurfaces, row0, 0, 1, 2 );
+ row0++;
}
- myRidgeAngle = 0;
- if ( isRemesher )
+ aGroupLayout->setRowStretch( row0, 1 );
+
+ // ========
+ // STL TAB
+ // ========
+
+ QWidget* stlGroup = new QWidget();
+ QVBoxLayout* stlLay = new QVBoxLayout( stlGroup );
+ stlLay->setMargin( 5 );
+ stlLay->setSpacing( 10 );
+
+ // Charts group
{
- aGroupLayout->addWidget( new QLabel( tr( "NETGEN_RIDGE_ANGLE" ), GroupC1 ), row, 0 );
- myRidgeAngle = new SMESHGUI_SpinBox( GroupC1 );
+ QGroupBox* chaGroup = new QGroupBox( tr("NETGEN_STL_CHARTS"), stlGroup );
+ stlLay->addWidget( chaGroup );
+
+ QGridLayout* chaLayout = new QGridLayout( chaGroup );
+ chaLayout->setMargin( 6 );
+ chaLayout->setSpacing( 6 );
+
+ int row = 0;
+ chaLayout->addWidget( new QLabel( tr( "NETGEN_RIDGE_ANGLE" ), chaGroup ), row, 0 );
+ myRidgeAngle = new SMESHGUI_SpinBox( chaGroup );
myRidgeAngle->RangeStepAndValidator( 0, 90, 10, "angle_precision" );
- aGroupLayout->addWidget( myRidgeAngle, row, 1 );
+ chaLayout->addWidget( myRidgeAngle, row, 1 );
row++;
- }
- mySurfaceCurvature = 0;
- if (( myIs2D && !isRemesher ) || !myIsONLY )
- {
- mySurfaceCurvature = new QCheckBox( tr( "NETGEN_SURFACE_CURVATURE" ), GroupC1 );
- aGroupLayout->addWidget( mySurfaceCurvature, row, 0, 1, 2 );
- connect( mySurfaceCurvature, SIGNAL( stateChanged( int ) ), this, SLOT( onSurfaceCurvatureChanged() ) );
+ chaLayout->addWidget( new QLabel( tr( "NETGEN_EDGE_CORNER_ANGLE" ), chaGroup ), row, 0 );
+ myEdgeCornerAngle = new SMESHGUI_SpinBox( chaGroup );
+ myEdgeCornerAngle->RangeStepAndValidator( 0., 180., 20., "angle_precision" );
+ chaLayout->addWidget( myEdgeCornerAngle, row, 1 );
row++;
- }
- myAllowQuadrangles = 0;
- if ( myIs2D || !myIsONLY ) // disable only for NETGEN 3D
- {
- myAllowQuadrangles = new QCheckBox( tr( "NETGEN_ALLOW_QUADRANGLES" ), GroupC1 );
- aGroupLayout->addWidget( myAllowQuadrangles, row, 0, 1, 2 );
+ chaLayout->addWidget( new QLabel( tr( "NETGEN_CHART_ANGLE" ), chaGroup ), row, 0 );
+ myChartAngle = new SMESHGUI_SpinBox( chaGroup );
+ myChartAngle->RangeStepAndValidator( 0., 180., 20., "angle_precision" );
+ chaLayout->addWidget( myChartAngle, row, 1 );
row++;
- }
- myOptimize = 0;
- if ( !isRemesher )
- {
- myOptimize = new QCheckBox( tr( "NETGEN_OPTIMIZE" ), GroupC1 );
- aGroupLayout->addWidget( myOptimize, row, 0, 1, 2 );
+ chaLayout->addWidget( new QLabel( tr( "NETGEN_OUTER_CHART_ANGLE" ), chaGroup ), row, 0 );
+ myOuterChartAngle = new SMESHGUI_SpinBox( chaGroup );
+ myOuterChartAngle->RangeStepAndValidator( 0., 180., 20., "angle_precision" );
+ chaLayout->addWidget( myOuterChartAngle, row, 1 );
row++;
}
-
- myFuseEdges = 0;
- if ( !myIsONLY )
+ // STL size group
{
- myFuseEdges = new QCheckBox( tr( "NETGEN_FUSE_EDGES" ), GroupC1 );
- aGroupLayout->addWidget( myFuseEdges, row, 0, 1, 2 );
+ QGroupBox* sizeGroup = new QGroupBox( tr("NETGEN_STL_SIZE"), stlGroup );
+ stlLay->addWidget( sizeGroup );
+
+ QGridLayout* sizeLayout = new QGridLayout( sizeGroup );
+ sizeLayout->setMargin( 6 );
+ sizeLayout->setSpacing( 6 );
+
+ int row = 0;
+ myRestHChartDistEnable = new QCheckBox( tr("NETGEN_RESTH_CHART_DIST"), sizeGroup );
+ sizeLayout->addWidget( myRestHChartDistEnable, row, 0 );
+ myRestHChartDistFactor = new SMESHGUI_SpinBox( sizeGroup );
+ myRestHChartDistFactor->RangeStepAndValidator( 0.2, 5., 0.1, "length_precision" );
+ sizeLayout->addWidget( myRestHChartDistFactor, row, 1 );
+ row++;
+
+ myRestHLineLengthEnable = new QCheckBox( tr("NETGEN_RESTH_LINE_LENGTH"), sizeGroup );
+ sizeLayout->addWidget( myRestHLineLengthEnable, row, 0 );
+ myRestHLineLengthFactor = new SMESHGUI_SpinBox( sizeGroup );
+ myRestHLineLengthFactor->RangeStepAndValidator( 0.2, 5., 0.1, "length_precision" );
+ sizeLayout->addWidget( myRestHLineLengthFactor, row, 1 );
+ row++;
+
+ myRestHCloseEdgeEnable = new QCheckBox( tr("NETGEN_RESTH_CLOSE_EDGE"), sizeGroup );
+ sizeLayout->addWidget( myRestHCloseEdgeEnable, row, 0 );
+ myRestHCloseEdgeFactor = new SMESHGUI_SpinBox( sizeGroup );
+ myRestHCloseEdgeFactor->RangeStepAndValidator( 0.2, 8., 0.1, "length_precision" );
+ sizeLayout->addWidget( myRestHCloseEdgeFactor, row, 1 );
+ row++;
+
+ myRestHSurfCurvEnable = new QCheckBox( tr("NETGEN_RESTH_SURF_CURV"), sizeGroup );
+ sizeLayout->addWidget( myRestHSurfCurvEnable, row, 0 );
+ myRestHSurfCurvFactor = new SMESHGUI_SpinBox( sizeGroup );
+ myRestHSurfCurvFactor->RangeStepAndValidator( 0.2, 5., 0.1, "length_precision" );
+ sizeLayout->addWidget( myRestHSurfCurvFactor, row, 1 );
+ row++;
+
+ myRestHEdgeAngleEnable = new QCheckBox( tr("NETGEN_RESTH_EDGE_ANGLE"), sizeGroup );
+ sizeLayout->addWidget( myRestHEdgeAngleEnable, row, 0 );
+ myRestHEdgeAngleFactor = new SMESHGUI_SpinBox( sizeGroup );
+ myRestHEdgeAngleFactor->RangeStepAndValidator( 0.2, 5., 0.1, "length_precision" );
+ sizeLayout->addWidget( myRestHEdgeAngleFactor, row, 1 );
+ row++;
+
+ myRestHSurfMeshCurvEnable = new QCheckBox( tr("NETGEN_RESTH_SURF_MESH_CURV"), sizeGroup );
+ sizeLayout->addWidget( myRestHSurfMeshCurvEnable, row, 0 );
+ myRestHSurfMeshCurvFactor = new SMESHGUI_SpinBox( sizeGroup );
+ myRestHSurfMeshCurvFactor->RangeStepAndValidator( 0.2, 5., 0.1, "length_precision" );
+ sizeLayout->addWidget( myRestHSurfMeshCurvFactor, row, 1 );
row++;
}
+ if ( isRemesher )
+ {
+ tab->insertTab( STL_TAB, stlGroup, tr( "NETGEN_STL" ));
+ connect( myRestHChartDistEnable , SIGNAL( toggled(bool) ), this, SLOT( onSTLEnable() ));
+ connect( myRestHLineLengthEnable , SIGNAL( toggled(bool) ), this, SLOT( onSTLEnable() ));
+ connect( myRestHCloseEdgeEnable , SIGNAL( toggled(bool) ), this, SLOT( onSTLEnable() ));
+ connect( myRestHSurfCurvEnable , SIGNAL( toggled(bool) ), this, SLOT( onSTLEnable() ));
+ connect( myRestHEdgeAngleEnable , SIGNAL( toggled(bool) ), this, SLOT( onSTLEnable() ));
+ connect( myRestHSurfMeshCurvEnable, SIGNAL( toggled(bool) ), this, SLOT( onSTLEnable() ));
+ }
+ else
+ {
+ delete stlGroup;
+ myRidgeAngle = 0;
+ }
+
+ // ===============
+ // Local Size TAB
+ // ===============
myLocalSizeTable = 0;
//if ( !myIsONLY )
tab->insertTab(LSZ_TAB, localSizeGroup, tr("NETGEN_LOCAL_SIZE"));
}
+
+ // =============
+ // Advanced TAB
+ // =============
+
+ QWidget* advGroup = new QWidget();
+ tab->insertTab( ADV_TAB, advGroup, tr( "SMESH_ADVANCED" ));
+ QVBoxLayout* advLay = new QVBoxLayout( advGroup );
+ advLay->setSpacing( 6 );
+ advLay->setMargin( 5 );
+
+ // Optimizer group
+ // ----------------
+ {
+ QGroupBox* optBox = new QGroupBox( tr("NETGEN_OPTIMIZER"), advGroup );
+ advLay->addWidget( optBox );
+
+ QGridLayout* optLayout = new QGridLayout( optBox );
+ optLayout->setMargin( 6 );
+ optLayout->setSpacing( 6 );
+
+ int row = 0;
+ myElemSizeWeight = 0;
+ myNbSurfOptSteps = 0;
+ if ( myIs2D || !myIsONLY ) // 2D options
+ {
+ optLayout->addWidget( new QLabel( tr( "NETGEN_ELEM_SIZE_WEIGHT" ), optBox ), row, 0 );
+ myElemSizeWeight = new SMESHGUI_SpinBox( optBox );
+ myElemSizeWeight->RangeStepAndValidator( 0., 1., 0.1, "parametric_precision" );
+ optLayout->addWidget( myElemSizeWeight, row, 1 );
+ row++;
+
+ optLayout->addWidget( new QLabel( tr( "NETGEN_NB_SURF_OPT_STEPS" ), optBox ), row, 0 );
+ myNbSurfOptSteps = new SalomeApp_IntSpinBox( optBox );
+ myNbSurfOptSteps->setMinimum( 0 );
+ myNbSurfOptSteps->setMaximum( 99 );
+ optLayout->addWidget( myNbSurfOptSteps, row, 1 );
+ row++;
+ }
+
+ myNbVolOptSteps = 0;
+ if ( !myIs2D )
+ {
+ optLayout->addWidget( new QLabel( tr( "NETGEN_NB_VOL_OPT_STEPS" ), optBox ), row, 0 );
+ myNbVolOptSteps = new SalomeApp_IntSpinBox( optBox );
+ myNbVolOptSteps->setMinimum( 0 );
+ myNbVolOptSteps->setMaximum( 99 );
+ optLayout->addWidget( myNbVolOptSteps, row, 1 );
+ }
+ }
+ // Insider group
+ {
+ QGroupBox* insGroup = new QGroupBox( tr("NETGEN_INSIDER"), advGroup );
+ advLay->addWidget( insGroup );
+
+ QGridLayout* insLayout = new QGridLayout( insGroup );
+ insLayout->setMargin( 6 );
+ insLayout->setSpacing( 6 );
+
+ int row = 0;
+ myWorstElemMeasure = 0;
+ myUseDelauney = 0;
+ if ( !myIs2D )
+ {
+ insLayout->addWidget( new QLabel( tr( "NETGEN_WORST_ELEM_MEASURE" ), insGroup ), row, 0 );
+ myWorstElemMeasure = new SalomeApp_IntSpinBox( insGroup );
+ myWorstElemMeasure->setMinimum( 1 );
+ myWorstElemMeasure->setMaximum( 10 );
+ insLayout->addWidget( myWorstElemMeasure, row, 1, 1, 2 );
+ row++;
+
+ myUseDelauney = new QCheckBox( tr( "NETGEN_USE_DELAUNEY" ), insGroup );
+ insLayout->addWidget( myUseDelauney, row, 0, 1, 2 );
+ row++;
+ }
+
+ myCheckOverlapping = 0;
+ if ( myIs2D || !myIsONLY ) // 2D options
+ {
+ myCheckOverlapping = new QCheckBox( tr( "NETGEN_CHECK_OVERLAPPING" ), insGroup );
+ insLayout->addWidget( myCheckOverlapping, row, 0, 1, 2 );
+ row++;
+ }
+
+ myCheckChartBoundary = 0;
+ if ( isRemesher )
+ {
+ myCheckChartBoundary = new QCheckBox( tr( "NETGEN_CHECK_CHART_BOUNDARY" ), insGroup );
+ insLayout->addWidget( myCheckChartBoundary, row, 0, 1, 2 );
+ row++;
+ }
+
+ myFuseEdges = 0;
+ if ( !myIsONLY && !isRemesher )
+ {
+ myFuseEdges = new QCheckBox( tr( "NETGEN_FUSE_EDGES" ), insGroup );
+ insLayout->addWidget( myFuseEdges, row, 0, 1, 2 );
+ row++;
+ }
+ insLayout->setRowStretch( row, 1 );
+ }
+
return fr;
}
if( myName )
myName->setText( data.myName );
- if(data.myMaxSizeVar.isEmpty())
- myMaxSize->setValue( data.myMaxSize );
- else
- myMaxSize->setText( data.myMaxSizeVar );
-
- if(data.myMinSizeVar.isEmpty())
- myMinSize->setValue( data.myMinSize );
- else
- myMinSize->setText( data.myMinSizeVar );
+ setTextOrVar( myMaxSize, data.myMaxSize, data.myMaxSizeVar );
+ setTextOrVar( myMinSize, data.myMinSize, data.myMinSizeVar );
if ( mySecondOrder )
mySecondOrder->setChecked( data.mySecondOrder );
if ( myOptimize )
myOptimize->setChecked( data.myOptimize );
myFineness->setCurrentIndex( data.myFineness );
+ setTextOrVar( myGrowthRate, data.myGrowthRate, data.myGrowthRateVar );
+ setTextOrVar( myNbSegPerEdge, data.myNbSegPerEdge, data.myNbSegPerEdgeVar );
+ setTextOrVar( myNbSegPerRadius, data.myNbSegPerRadius, data.myNbSegPerRadiusVar );
- if(data.myGrowthRateVar.isEmpty())
- myGrowthRate->setValue( data.myGrowthRate );
- else
- myGrowthRate->setText( data.myGrowthRateVar );
-
- if ( myNbSegPerEdge )
- {
- if(data.myNbSegPerEdgeVar.isEmpty())
- myNbSegPerEdge->setValue( data.myNbSegPerEdge );
- else
- myNbSegPerEdge->setText( data.myNbSegPerEdgeVar );
- }
- if ( myNbSegPerRadius )
- {
- if(data.myNbSegPerRadiusVar.isEmpty())
- myNbSegPerRadius->setValue( data.myNbSegPerRadius );
- else
- myNbSegPerRadius->setText( data.myNbSegPerRadiusVar );
- }
if ( myChordalError )
{
myChordalErrorEnabled->setChecked( data.myChordalErrorEnabled && data.myChordalError > 0 );
- if(data.myChordalErrorVar.isEmpty())
- myChordalError->setValue( data.myChordalError > 0 ? data.myChordalError : 0.1 );
- else
- myChordalError->setText( data.myChordalErrorVar );
+ setTextOrVar( myChordalError, data.myChordalError, data.myChordalErrorVar );
myChordalError->setEnabled( myChordalErrorEnabled->isChecked() );
}
- if ( myRidgeAngle )
- {
- if ( data.myRidgeAngleVar.isEmpty() )
- myRidgeAngle->setValue( data.myRidgeAngle );
- else
- myRidgeAngle->setText( data.myRidgeAngleVar );
- }
if (myAllowQuadrangles)
myAllowQuadrangles->setChecked( data.myAllowQuadrangles );
-
if (mySurfaceCurvature)
mySurfaceCurvature->setChecked( data.mySurfaceCurvature );
+ if ( myKeepExistingEdges )
+ {
+ myKeepExistingEdges->setChecked( data.myKeepExistingEdges );
+ myMakeGroupsOfSurfaces->setChecked( data.myMakeGroupsOfSurfaces );
+ }
+
+ setTextOrVar( myElemSizeWeight, data.myElemSizeWeight, data.myElemSizeWeightVar );
+ setTextOrVar( myNbSurfOptSteps, data.myNbSurfOptSteps, data.myNbSurfOptStepsVar );
+ setTextOrVar( myNbVolOptSteps, data.myNbVolOptSteps, data.myNbVolOptStepsVar );
+
if (myFuseEdges)
myFuseEdges->setChecked( data.myFuseEdges );
+ setTextOrVar( myWorstElemMeasure, data.myWorstElemMeasure, data.myWorstElemMeasureVar );
+ if ( myUseDelauney )
+ myUseDelauney->setChecked( data.myUseDelauney );
+ if ( myCheckOverlapping )
+ myCheckOverlapping->setChecked( data.myCheckOverlapping );
+ if ( myCheckChartBoundary )
+ myCheckChartBoundary->setChecked( data.myCheckChartBoundary );
+
+ if ( myRidgeAngle )
+ {
+ setTextOrVar( myRidgeAngle, data.myRidgeAngle, data.myRidgeAngleVar );
+ setTextOrVar( myEdgeCornerAngle, data.myEdgeCornerAngle, data.myEdgeCornerAngleVar );
+ setTextOrVar( myChartAngle, data.myChartAngle, data.myChartAngleVar );
+ setTextOrVar( myOuterChartAngle, data.myOuterChartAngle, data.myOuterChartAngleVar );
+ setTextOrVar( myRestHChartDistFactor, data.myRestHChartDistFactor,
+ data.myRestHChartDistFactorVar );
+ setTextOrVar( myRestHLineLengthFactor, data.myRestHLineLengthFactor,
+ data.myRestHLineLengthFactorVar );
+ setTextOrVar( myRestHCloseEdgeFactor, data.myRestHCloseEdgeFactor,
+ data.myRestHCloseEdgeFactorVar );
+ setTextOrVar( myRestHSurfCurvFactor, data.myRestHSurfCurvFactor,
+ data.myRestHSurfCurvFactorVar );
+ setTextOrVar( myRestHEdgeAngleFactor, data.myRestHEdgeAngleFactor,
+ data.myRestHEdgeAngleFactorVar );
+ setTextOrVar( myRestHSurfMeshCurvFactor, data.myRestHSurfMeshCurvFactor,
+ data.myRestHSurfMeshCurvFactorVar );
+
+ myRestHChartDistEnable->setChecked( data.myRestHChartDistEnable );
+ myRestHLineLengthEnable->setChecked( data.myRestHLineLengthEnable );
+ myRestHCloseEdgeEnable->setChecked( data.myRestHCloseEdgeEnable );
+ myRestHSurfCurvEnable->setChecked( data.myRestHSurfCurvEnable );
+ myRestHEdgeAngleEnable->setChecked( data.myRestHEdgeAngleEnable );
+ myRestHSurfMeshCurvEnable->setChecked( data.myRestHSurfMeshCurvEnable );
+ }
// update widgets
((NETGENPluginGUI_HypothesisCreator*) this )-> onSurfaceCurvatureChanged();
h_data.myName = isCreation() ? hypName() : "";
- h_data.myMaxSize = h->GetMaxSize();
- h_data.myMaxSizeVar = getVariableName("SetMaxSize");
- h_data.mySecondOrder = h->GetSecondOrder();
- h_data.myOptimize = h->GetOptimize();
+ h_data.myMaxSize = h->GetMaxSize();
+ h_data.myMaxSizeVar = getVariableName("SetMaxSize");
+ h_data.myMinSize = h->GetMinSize();
+ h_data.myMinSizeVar = getVariableName("SetMinSize");
+ h_data.mySecondOrder = h->GetSecondOrder();
+ h_data.myOptimize = h->GetOptimize();
h_data.myFineness = (int) h->GetFineness();
h_data.myGrowthRate = h->GetGrowthRate();
h_data.myChordalError = h->GetChordalError();
h_data.myChordalErrorVar = getVariableName("SetChordalError");
h_data.myChordalErrorEnabled = h->GetChordalErrorEnabled();
- h_data.myMinSize = h->GetMinSize();
- h_data.myMinSizeVar = getVariableName("SetMinSize");
h_data.mySurfaceCurvature = h->GetUseSurfaceCurvature();
+
+ h_data.myElemSizeWeight = h->GetElemSizeWeight ();
+ h_data.myElemSizeWeightVar = getVariableName("SetElemSizeWeight");
+ h_data.myNbSurfOptSteps = h->GetNbSurfOptSteps ();
+ h_data.myNbSurfOptStepsVar = getVariableName("SetNbSurfOptSteps");
+ h_data.myNbVolOptSteps = h->GetNbVolOptSteps ();
+ h_data.myNbVolOptStepsVar = getVariableName("SetNbVolOptSteps");
h_data.myFuseEdges = h->GetFuseEdges();
+ h_data.myWorstElemMeasure = h->GetWorstElemMeasure ();
+ h_data.myWorstElemMeasureVar = getVariableName("SetWorstElemMeasure");
+ h_data.myUseDelauney = h->GetUseDelauney ();
+ h_data.myCheckOverlapping = h->GetCheckOverlapping ();
+ h_data.myCheckChartBoundary = h->GetCheckChartBoundary();
+
h_data.myMeshSizeFile = h->GetMeshSizeFile();
//if ( myIs2D )
{
NETGENPlugin::NETGENPlugin_RemesherHypothesis_2D_var rh =
NETGENPlugin::NETGENPlugin_RemesherHypothesis_2D::_narrow( h );
-
if ( !rh->_is_nil() )
- h_data.myRidgeAngle = rh->GetRidgeAngle();
+ {
+ h_data.myRidgeAngle = rh->GetRidgeAngle();
+ h_data.myRidgeAngleVar = getVariableName("SetRidgeAngle");
+ h_data.myEdgeCornerAngle = rh->GetEdgeCornerAngle ();
+ h_data.myEdgeCornerAngleVar = getVariableName("SetEdgeCornerAngle");
+ h_data.myChartAngle = rh->GetChartAngle ();
+ h_data.myChartAngleVar = getVariableName("SetChartAngle");
+ h_data.myOuterChartAngle = rh->GetOuterChartAngle ();
+ h_data.myOuterChartAngleVar = getVariableName("SetOuterChartAngle");
+ h_data.myRestHChartDistFactor = rh->GetRestHChartDistFactor ();
+ h_data.myRestHChartDistFactorVar = getVariableName("SetRestHChartDistFactor");
+ h_data.myRestHLineLengthFactor = rh->GetRestHLineLengthFactor ();
+ h_data.myRestHLineLengthFactorVar = getVariableName("SetRestHLineLengthFactor");
+ h_data.myRestHCloseEdgeFactor = rh->GetRestHCloseEdgeFactor ();
+ h_data.myRestHCloseEdgeFactorVar = getVariableName("SetRestHCloseEdgeFactor");
+ h_data.myRestHSurfCurvFactor = rh->GetRestHSurfCurvFactor ();
+ h_data.myRestHSurfCurvFactorVar = getVariableName("SetRestHSurfCurvFactor");
+ h_data.myRestHEdgeAngleFactor = rh->GetRestHEdgeAngleFactor ();
+ h_data.myRestHEdgeAngleFactorVar = getVariableName("SetRestHEdgeAngleFactor");
+ h_data.myRestHSurfMeshCurvFactor = rh->GetRestHSurfMeshCurvFactor();
+ h_data.myRestHSurfMeshCurvFactorVar = getVariableName("SetRestHSurfMeshCurvFactor");
+ h_data.myRestHChartDistEnable = rh->GetRestHChartDistEnable ();
+ h_data.myRestHLineLengthEnable = rh->GetRestHLineLengthEnable ();
+ h_data.myRestHCloseEdgeEnable = rh->GetRestHCloseEdgeEnable ();
+ h_data.myRestHSurfCurvEnable = rh->GetRestHSurfCurvEnable ();
+ h_data.myRestHEdgeAngleEnable = rh->GetRestHEdgeAngleEnable ();
+ h_data.myRestHSurfMeshCurvEnable = rh->GetRestHSurfMeshCurvEnable();
+ h_data.myKeepExistingEdges = rh->GetKeepExistingEdges ();
+ h_data.myMakeGroupsOfSurfaces = rh->GetMakeGroupsOfSurfaces ();
+ }
}
NETGENPluginGUI_HypothesisCreator* that = (NETGENPluginGUI_HypothesisCreator*)this;
bool ok = true;
try
{
- if( isCreation() )
+ if ( isCreation() )
SMESH::SetName( SMESH::FindSObject( h ), h_data.myName.toLatin1().data() );
h->SetVarParameter( h_data.myMaxSizeVar.toLatin1().constData(), "SetMaxSize");
h->SetMaxSize ( h_data.myMaxSize );
+ h->SetVarParameter( h_data.myMinSizeVar.toLatin1().constData(), "SetMinSize");
+ h->SetMinSize ( h_data.myMinSize );
if ( mySecondOrder )
h->SetSecondOrder ( h_data.mySecondOrder );
if ( myOptimize )
h->SetOptimize ( h_data.myOptimize );
- int fineness = h_data.myFineness;
- h->SetFineness ( fineness );
+ h->SetFineness ( h_data.myFineness );
- if( fineness==UserDefined )
+ if ( h_data.myFineness == UserDefined )
{
h->SetVarParameter ( h_data.myGrowthRateVar.toLatin1().constData(), "SetGrowthRate");
h->SetGrowthRate ( h_data.myGrowthRate );
h->SetChordalError ( h_data.myChordalError );
h->SetChordalErrorEnabled( h_data.myChordalErrorEnabled );
}
- h->SetVarParameter ( h_data.myMinSizeVar.toLatin1().constData(), "SetMinSize");
- h->SetMinSize ( h_data.myMinSize );
if ( mySurfaceCurvature )
h->SetUseSurfaceCurvature( h_data.mySurfaceCurvature );
- if ( myFuseEdges )
- h->SetFuseEdges ( h_data.myFuseEdges );
- h->SetMeshSizeFile ( h_data.myMeshSizeFile.toUtf8().constData() );
+ h->SetMeshSizeFile ( h_data.myMeshSizeFile.toUtf8().constData() );
+ h->SetVarParameter ( h_data.myElemSizeWeightVar.toLatin1().constData(), "SetElemSizeWeight");
+ h->SetElemSizeWeight( h_data.myElemSizeWeight );
+ if ( myNbSurfOptSteps )
+ {
+ h->SetVarParameter ( h_data.myNbSurfOptStepsVar.toLatin1().constData(), "SetNbSurfOptSteps");
+ h->SetNbSurfOptSteps( h_data.myNbSurfOptSteps );
+ }
+ if ( myNbVolOptSteps )
+ {
+ h->SetVarParameter ( h_data.myNbVolOptStepsVar.toLatin1().constData(), "SetNbVolOptSteps");
+ h->SetNbVolOptSteps( h_data.myNbVolOptSteps );
+ }
+ if ( myFuseEdges )
+ h->SetFuseEdges( h_data.myFuseEdges );
+ h->SetVarParameter ( h_data.myWorstElemMeasureVar.toLatin1().constData(), "SetWorstElemMeasure");
+ h->SetWorstElemMeasure( h_data.myWorstElemMeasure );
+
+ h->SetUseDelauney( h_data.myUseDelauney );
+ h->SetCheckOverlapping( h_data.myCheckOverlapping );
+ h->SetCheckChartBoundary( h_data.myCheckChartBoundary );
+
//if ( myIs2D )
{
// NETGENPlugin::NETGENPlugin_Hypothesis_2D_var h_2d =
NETGENPlugin::NETGENPlugin_RemesherHypothesis_2D::_narrow( h );
if ( !rh->_is_nil() )
{
- rh->SetVarParameter( h_data.myRidgeAngleVar.toLatin1().constData(), "SetRidgeAngle");
- rh->SetRidgeAngle ( h_data.myRidgeAngle );
+ rh->SetVarParameter ( h_data.myRidgeAngleVar.toLatin1().constData(), "SetRidgeAngle");
+ rh->SetRidgeAngle ( h_data.myRidgeAngle );
+ rh->SetVarParameter ( h_data.myEdgeCornerAngleVar.toLatin1().constData(), "SetEdgeCornerAngle");
+ rh->SetEdgeCornerAngle( h_data.myEdgeCornerAngle );
+ rh->SetVarParameter ( h_data.myChartAngleVar.toLatin1().constData(), "SetChartAngle");
+ rh->SetChartAngle ( h_data.myChartAngle );
+ rh->SetVarParameter ( h_data.myOuterChartAngleVar.toLatin1().constData(), "SetOuterChartAngle");
+ rh->SetOuterChartAngle( h_data.myOuterChartAngle );
+
+ rh->SetVarParameter ( h_data.myRestHChartDistFactorVar.toLatin1().constData(), "SetRestHChartDistFactor");
+ rh->SetRestHChartDistFactor ( h_data.myRestHChartDistFactor );
+ rh->SetVarParameter ( h_data.myRestHLineLengthFactorVar.toLatin1().constData(), "SetRestHLineLengthFactor");
+ rh->SetRestHLineLengthFactor ( h_data.myRestHLineLengthFactor );
+ rh->SetVarParameter ( h_data.myRestHCloseEdgeFactorVar.toLatin1().constData(), "SetRestHCloseEdgeFactor");
+ rh->SetRestHCloseEdgeFactor ( h_data.myRestHCloseEdgeFactor );
+ rh->SetVarParameter ( h_data.myRestHSurfCurvFactorVar.toLatin1().constData(), "SetRestHSurfCurvFactor");
+ rh->SetRestHSurfCurvFactor ( h_data.myRestHSurfCurvFactor );
+ rh->SetVarParameter ( h_data.myRestHEdgeAngleFactorVar.toLatin1().constData(), "SetRestHEdgeAngleFactor");
+ rh->SetRestHEdgeAngleFactor ( h_data.myRestHEdgeAngleFactor );
+ rh->SetVarParameter ( h_data.myRestHSurfMeshCurvFactorVar.toLatin1().constData(), "SetRestHSurfMeshCurvFactor");
+ rh->SetRestHSurfMeshCurvFactor( h_data.myRestHSurfMeshCurvFactor );
+
+ rh->SetRestHChartDistEnable ( h_data.myRestHChartDistEnable );
+ rh->SetRestHLineLengthEnable ( h_data.myRestHLineLengthEnable );
+ rh->SetRestHCloseEdgeEnable ( h_data.myRestHCloseEdgeEnable );
+ rh->SetRestHSurfCurvEnable ( h_data.myRestHSurfCurvEnable );
+ rh->SetRestHEdgeAngleEnable ( h_data.myRestHEdgeAngleEnable );
+ rh->SetRestHSurfMeshCurvEnable( h_data.myRestHSurfMeshCurvEnable );
+
+ rh->SetKeepExistingEdges ( h_data.myKeepExistingEdges );
+ rh->SetMakeGroupsOfSurfaces ( h_data.myMakeGroupsOfSurfaces );
+ rh->SetFixedEdgeGroup ( 0 );
}
}
for ( QMapIterator<QString,QString> i(myLocalSizeMap); i.hasNext(); )
h_data.myChordalError = myChordalError->value();
h_data.myChordalErrorEnabled = myChordalError->isEnabled();
}
- if ( myRidgeAngle )
- {
- h_data.myRidgeAngleVar = myRidgeAngle->text();
- h_data.myRidgeAngle = myRidgeAngle->value();
- }
-
if ( myAllowQuadrangles )
h_data.myAllowQuadrangles = myAllowQuadrangles->isChecked();
if ( myFuseEdges )
h_data.myFuseEdges = myFuseEdges->isChecked();
+ if ( myElemSizeWeight )
+ {
+ h_data.myElemSizeWeight = myElemSizeWeight->value();
+ h_data.myElemSizeWeightVar = myElemSizeWeight->text();
+ }
+ if ( myNbSurfOptSteps )
+ {
+ h_data.myNbSurfOptSteps = myNbSurfOptSteps->value();
+ h_data.myNbSurfOptStepsVar = myNbSurfOptSteps->text();
+ }
+ if ( myNbVolOptSteps )
+ {
+ h_data.myNbVolOptSteps = myNbVolOptSteps->value();
+ h_data.myNbVolOptStepsVar = myNbVolOptSteps->text();
+ }
+ if ( myWorstElemMeasure )
+ {
+ h_data.myWorstElemMeasure = myWorstElemMeasure->value();
+ h_data.myWorstElemMeasureVar = myWorstElemMeasure->text();
+ }
+ if ( myUseDelauney )
+ h_data.myUseDelauney = myUseDelauney->isChecked();
+
+ if ( myCheckOverlapping )
+ h_data.myCheckOverlapping = myCheckOverlapping->isChecked();
+
+ if ( myCheckChartBoundary )
+ h_data.myCheckChartBoundary = myCheckChartBoundary->isChecked();
+
+ if ( myRidgeAngle )
+ {
+ h_data.myRidgeAngle = myRidgeAngle ->value();
+ h_data.myRidgeAngleVar = myRidgeAngle ->text();
+ h_data.myEdgeCornerAngle = myEdgeCornerAngle ->value();
+ h_data.myEdgeCornerAngleVar = myEdgeCornerAngle ->text();
+ h_data.myChartAngle = myChartAngle ->value();
+ h_data.myChartAngleVar = myChartAngle ->text();
+ h_data.myOuterChartAngle = myOuterChartAngle ->value();
+ h_data.myOuterChartAngleVar = myOuterChartAngle ->text();
+ h_data.myRestHChartDistFactor = myRestHChartDistFactor ->value();
+ h_data.myRestHChartDistFactorVar = myRestHChartDistFactor ->text();
+ h_data.myRestHLineLengthFactor = myRestHLineLengthFactor ->value();
+ h_data.myRestHLineLengthFactorVar = myRestHLineLengthFactor ->text();
+ h_data.myRestHCloseEdgeFactor = myRestHCloseEdgeFactor ->value();
+ h_data.myRestHCloseEdgeFactorVar = myRestHCloseEdgeFactor ->text();
+ h_data.myRestHSurfCurvFactor = myRestHSurfCurvFactor ->value();
+ h_data.myRestHSurfCurvFactorVar = myRestHSurfCurvFactor ->text();
+ h_data.myRestHEdgeAngleFactor = myRestHEdgeAngleFactor ->value();
+ h_data.myRestHEdgeAngleFactorVar = myRestHEdgeAngleFactor ->text();
+ h_data.myRestHSurfMeshCurvFactor = myRestHSurfMeshCurvFactor->value();
+ h_data.myRestHSurfMeshCurvFactorVar = myRestHSurfMeshCurvFactor->text();
+ h_data.myRestHChartDistEnable = myRestHChartDistEnable ->isChecked();
+ h_data.myRestHLineLengthEnable = myRestHLineLengthEnable ->isChecked();
+ h_data.myRestHCloseEdgeEnable = myRestHCloseEdgeEnable ->isChecked();
+ h_data.myRestHSurfCurvEnable = myRestHSurfCurvEnable ->isChecked();
+ h_data.myRestHEdgeAngleEnable = myRestHEdgeAngleEnable ->isChecked();
+ h_data.myRestHSurfMeshCurvEnable = myRestHSurfMeshCurvEnable->isChecked();
+ h_data.myKeepExistingEdges = myKeepExistingEdges ->isChecked();
+ h_data.myMakeGroupsOfSurfaces = myMakeGroupsOfSurfaces ->isChecked();
+ }
+
if ( myLocalSizeTable )
{
NETGENPluginGUI_HypothesisCreator* that = (NETGENPluginGUI_HypothesisCreator*)this;
myMeshSizeFile->setText( dir );
}
+void NETGENPluginGUI_HypothesisCreator::onSTLEnable()
+{
+ myRestHChartDistFactor ->setEnabled( myRestHChartDistEnable ->isChecked() );
+ myRestHLineLengthFactor ->setEnabled( myRestHLineLengthEnable ->isChecked() );
+ myRestHCloseEdgeFactor ->setEnabled( myRestHCloseEdgeEnable ->isChecked() );
+ myRestHSurfCurvFactor ->setEnabled( myRestHSurfCurvEnable ->isChecked() );
+ myRestHEdgeAngleFactor ->setEnabled( myRestHEdgeAngleEnable ->isChecked() );
+ myRestHSurfMeshCurvFactor->setEnabled( myRestHSurfMeshCurvEnable->isChecked() );
+}
+
GeomSelectionTools* NETGENPluginGUI_HypothesisCreator::getGeomSelectionTools()
{
if (myGeomSelectionTools == NULL) {
-// Copyright (C) 2007-2016 CEA/DEN, EDF R&D, OPEN CASCADE
+// Copyright (C) 2007-2019 CEA/DEN, EDF R&D, OPEN CASCADE
//
// Copyright (C) 2003-2007 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
#include <TopAbs_ShapeEnum.hxx>
-class SMESHGUI_SpinBox;
class GeomSelectionTools;
-class QComboBox;
class QCheckBox;
+class QComboBox;
class QLineEdit;
class QTableWidget;
+class SMESHGUI_SpinBox;
+class SalomeApp_IntSpinBox;
typedef struct
{
- double myMaxSize, myMinSize, myGrowthRate, myNbSegPerEdge, myNbSegPerRadius, myRidgeAngle, myChordalError;
- int myFineness;
- bool mySecondOrder, myAllowQuadrangles, myOptimize, mySurfaceCurvature, myFuseEdges, myChordalErrorEnabled;
+ double myMaxSize, myMinSize, myGrowthRate, myNbSegPerEdge, myNbSegPerRadius, myRidgeAngle, myChordalError, myElemSizeWeight, myEdgeCornerAngle, myChartAngle, myOuterChartAngle, myRestHChartDistFactor, myRestHLineLengthFactor, myRestHCloseEdgeFactor, myRestHSurfCurvFactor, myRestHEdgeAngleFactor, myRestHSurfMeshCurvFactor;
+ int myFineness, myNbSurfOptSteps, myNbVolOptSteps, myWorstElemMeasure;
+ bool mySecondOrder, myAllowQuadrangles, myOptimize, mySurfaceCurvature, myFuseEdges, myChordalErrorEnabled, myUseDelauney, myCheckOverlapping, myCheckChartBoundary, myRestHChartDistEnable, myRestHLineLengthEnable, myRestHCloseEdgeEnable, myRestHSurfCurvEnable, myRestHEdgeAngleEnable, myRestHSurfMeshCurvEnable, myKeepExistingEdges, myMakeGroupsOfSurfaces;
QString myName, myMeshSizeFile;
- QString myMaxSizeVar, myMinSizeVar, myGrowthRateVar, myNbSegPerEdgeVar, myNbSegPerRadiusVar, myRidgeAngleVar, myChordalErrorVar;
+ QString myMaxSizeVar, myMinSizeVar, myGrowthRateVar, myNbSegPerEdgeVar, myNbSegPerRadiusVar, myRidgeAngleVar, myChordalErrorVar, myNbSurfOptStepsVar, myNbVolOptStepsVar, myElemSizeWeightVar, myWorstElemMeasureVar, myEdgeCornerAngleVar, myChartAngleVar, myOuterChartAngleVar, myRestHChartDistFactorVar, myRestHLineLengthFactorVar, myRestHCloseEdgeFactorVar, myRestHSurfCurvFactorVar, myRestHEdgeAngleFactorVar, myRestHSurfMeshCurvFactorVar;
} NetgenHypothesisData;
/*!
virtual void onRemoveLocalSizeOnShape();
virtual void onSetLocalSize(int,int);
virtual void onSetSizeFile();
+ virtual void onSTLEnable();
private:
bool readParamsFromHypo( NetgenHypothesisData& ) const;
void addLocalSizeOnShape(TopAbs_ShapeEnum);
private:
- QLineEdit* myName;
- SMESHGUI_SpinBox* myMaxSize;
- SMESHGUI_SpinBox* myMinSize;
- QCheckBox* mySecondOrder;
- QCheckBox* myOptimize;
- QComboBox* myFineness;
- SMESHGUI_SpinBox* myGrowthRate;
- SMESHGUI_SpinBox* myNbSegPerEdge;
- SMESHGUI_SpinBox* myNbSegPerRadius;
- SMESHGUI_SpinBox* myRidgeAngle;
- QCheckBox* myChordalErrorEnabled;
- SMESHGUI_SpinBox* myChordalError;
- QCheckBox* myAllowQuadrangles;
- QCheckBox* mySurfaceCurvature;
- QCheckBox* myFuseEdges;
+ QLineEdit* myName;
+ SMESHGUI_SpinBox* myMaxSize;
+ SMESHGUI_SpinBox* myMinSize;
+ QCheckBox* mySecondOrder;
+ QCheckBox* myOptimize;
+ QComboBox* myFineness;
+ SMESHGUI_SpinBox* myGrowthRate;
+ SMESHGUI_SpinBox* myNbSegPerEdge;
+ SMESHGUI_SpinBox* myNbSegPerRadius;
+ QCheckBox* myChordalErrorEnabled;
+ SMESHGUI_SpinBox* myChordalError;
+ QCheckBox* myAllowQuadrangles;
+ QCheckBox* mySurfaceCurvature;
+ // optimizer
+ SMESHGUI_SpinBox* myElemSizeWeight;
+ SalomeApp_IntSpinBox* myNbSurfOptSteps;
+ SalomeApp_IntSpinBox* myNbVolOptSteps;
+ // insider
+ QCheckBox* myFuseEdges;
+ SalomeApp_IntSpinBox* myWorstElemMeasure;
+ QCheckBox* myUseDelauney;
+ QCheckBox* myCheckOverlapping;
+ QCheckBox* myCheckChartBoundary;
+ // stl options
+ QCheckBox* myKeepExistingEdges;
+ QCheckBox* myMakeGroupsOfSurfaces;
+ // stl charts
+ SMESHGUI_SpinBox* myRidgeAngle;
+ SMESHGUI_SpinBox* myEdgeCornerAngle;
+ SMESHGUI_SpinBox* myChartAngle;
+ SMESHGUI_SpinBox* myOuterChartAngle;
+ // stl size
+ SMESHGUI_SpinBox* myRestHChartDistFactor;
+ SMESHGUI_SpinBox* myRestHLineLengthFactor;
+ SMESHGUI_SpinBox* myRestHCloseEdgeFactor;
+ SMESHGUI_SpinBox* myRestHSurfCurvFactor;
+ SMESHGUI_SpinBox* myRestHEdgeAngleFactor;
+ SMESHGUI_SpinBox* myRestHSurfMeshCurvFactor;
+ QCheckBox* myRestHChartDistEnable;
+ QCheckBox* myRestHLineLengthEnable;
+ QCheckBox* myRestHCloseEdgeEnable;
+ QCheckBox* myRestHSurfCurvEnable;
+ QCheckBox* myRestHEdgeAngleEnable;
+ QCheckBox* myRestHSurfMeshCurvEnable;
bool myIs2D; // 2D or 3D
bool myIsONLY; // one dim or several
-// Copyright (C) 2007-2016 CEA/DEN, EDF R&D, OPEN CASCADE
+// Copyright (C) 2007-2019 CEA/DEN, EDF R&D, OPEN CASCADE
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
-// Copyright (C) 2007-2016 CEA/DEN, EDF R&D, OPEN CASCADE
+// Copyright (C) 2007-2019 CEA/DEN, EDF R&D, OPEN CASCADE
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
</message>
<message>
<source>NETGEN_ALLOW_QUADRANGLES</source>
- <translation>Allow Quadrangles</translation>
+ <translation>Quad-dominated</translation>
</message>
<message>
<source>NETGEN_COARSE</source>
</message>
<message>
<source>NETGEN_FUSE_EDGES</source>
- <translation>Fuse Coincident Nodes on Edges and Vertices</translation>
+ <translation>Fuse coincident nodes on edges and vertices</translation>
</message>
<message>
<source>NETGEN_GROWTH_RATE</source>
- <translation>Growth Rate</translation>
+ <translation>Growth rate</translation>
</message>
<message>
<source>NETGEN_MAX_SIZE</source>
- <translation>Max. Size</translation>
+ <translation>Max. size</translation>
</message>
<message>
<source>NETGEN_MIN_SIZE</source>
- <translation>Min. Size</translation>
+ <translation>Min. size</translation>
</message>
<message>
<source>NETGEN_MODERATE</source>
<source>NETGEN_OPTIMIZE</source>
<translation>Optimize</translation>
</message>
+ <message>
+ <source>NETGEN_OPTIMIZER</source>
+ <translation>Optimizer</translation>
+ </message>
<message>
<source>NETGEN_SECOND_ORDER</source>
- <translation>Second Order</translation>
+ <translation>Second order</translation>
</message>
<message>
<source>NETGEN_SEG_PER_EDGE</source>
- <translation>Nb. Segs per Edge</translation>
+ <translation>Nb. segs per edge</translation>
</message>
<message>
<source>NETGEN_SEG_PER_RADIUS</source>
- <translation>Nb. Segs per Radius</translation>
+ <translation>Nb. segs per radius</translation>
</message>
<message>
<source>NETGEN_CHORDAL_ERROR</source>
- <translation>Chordal Error</translation>
+ <translation>Chordal error</translation>
</message>
<message>
<source>NETGEN_RIDGE_ANGLE</source>
- <translation>Ridge Angle</translation>
+ <translation>Ridge angle</translation>
+ </message>
+ <message>
+ <source>NETGEN_KEEP_EXISTING_EDGES</source>
+ <translation>Keep existing edges</translation>
+ </message>
+ <message>
+ <source>NETGEN_MAKE_SURFACE_GROUPS</source>
+ <translation>Create groups of surfaces</translation>
</message>
<message>
<source>NETGEN_SURFACE_CURVATURE</source>
- <translation>Limit Size by Surface Curvature</translation>
+ <translation>Limit size by surface curvature</translation>
</message>
<message>
<source>NETGEN_VERYCOARSE</source>
- <translation>Very Coarse</translation>
+ <translation>Very coarse</translation>
</message>
<message>
<source>NETGEN_VERYFINE</source>
- <translation>Very Fine</translation>
+ <translation>Very fine</translation>
</message>
<message>
<source>NG_1D</source>
</message>
<message>
<source>NETGEN_LSZ_VERTEX</source>
- <translation>On Vertex</translation>
+ <translation>On vertex</translation>
</message>
<message>
<source>NETGEN_LSZ_EDGE</source>
- <translation>On Edge</translation>
+ <translation>On edge</translation>
</message>
<message>
<source>NETGEN_LSZ_FACE</source>
- <translation>On Face</translation>
+ <translation>On face</translation>
</message>
<message>
<source>NETGEN_LSZ_SOLID</source>
- <translation>On Solid</translation>
+ <translation>On solid</translation>
</message>
<message>
<source>NETGEN_LSZ_REMOVE</source>
</message>
<message>
<source>NETGEN_LSZ_FILE</source>
- <translation>Mesh-size File</translation>
+ <translation>Mesh-size file</translation>
+ </message>
+ <message>
+ <source>NETGEN_MESH_SIZE</source>
+ <translation>Mesh size</translation>
+ </message>
+ <message>
+ <source>NETGEN_INSIDER</source>
+ <translation>Insider</translation>
+ </message>
+ <message>
+ <source>NETGEN_WORST_ELEM_MEASURE</source>
+ <translation>Worst element measure</translation>
+ </message>
+ <message>
+ <source>NETGEN_USE_DELAUNEY</source>
+ <translation>Use Delaunay</translation>
+ </message>
+ <message>
+ <source>NETGEN_CHECK_OVERLAPPING</source>
+ <translation>Check overlapping</translation>
+ </message>
+ <message>
+ <source>NETGEN_CHECK_CHART_BOUNDARY</source>
+ <translation>Check chart boundary</translation>
+ </message>
+ <message>
+ <source>NETGEN_ELEM_SIZE_WEIGHT</source>
+ <translation>Element size weight</translation>
+ </message>
+ <message>
+ <source>NETGEN_NB_SURF_OPT_STEPS</source>
+ <translation>Nb. surface optimization steps</translation>
+ </message>
+ <message>
+ <source>NETGEN_NB_VOL_OPT_STEPS</source>
+ <translation>Nb. volume optimization steps</translation>
+ </message>
+ <message>
+ <source>NETGEN_STL</source>
+ <translation>STL</translation>
+ </message>
+ <message>
+ <source>NETGEN_STL_CHARTS</source>
+ <translation>Charts</translation>
+ </message>
+ <message>
+ <source>NETGEN_STL_SIZE</source>
+ <translation>Mesh size depends on... (enable and factor)</translation>
+ </message>
+ <message>
+ <source>NETGEN_EDGE_CORNER_ANGLE</source>
+ <translation>Edge corner angle</translation>
+ </message>
+ <message>
+ <source>NETGEN_CHART_ANGLE</source>
+ <translation>Chart angle</translation>
+ </message>
+ <message>
+ <source>NETGEN_OUTER_CHART_ANGLE</source>
+ <translation>Outer chart angle</translation>
+ </message>
+ <message>
+ <source>NETGEN_RESTH_CHART_DIST</source>
+ <translation>Chart distance</translation>
+ </message>
+ <message>
+ <source>NETGEN_RESTH_LINE_LENGTH</source>
+ <translation>Line length</translation>
+ </message>
+ <message>
+ <source>NETGEN_RESTH_CLOSE_EDGE</source>
+ <translation>Close edges</translation>
+ </message>
+ <message>
+ <source>NETGEN_RESTH_SURF_CURV</source>
+ <translation>Surface curvature</translation>
+ </message>
+ <message>
+ <source>NETGEN_RESTH_EDGE_ANGLE</source>
+ <translation>Edge angle</translation>
+ </message>
+ <message>
+ <source>NETGEN_RESTH_SURF_MESH_CURV</source>
+ <translation>Surface mesh curvature</translation>
</message>
</context>
</TS>
-# Copyright (C) 2012-2016 CEA/DEN, EDF R&D, OPEN CASCADE
+# Copyright (C) 2012-2019 CEA/DEN, EDF R&D, OPEN CASCADE
#
# This library is free software; you can redistribute it and/or
# modify it under the terms of the GNU Lesser General Public
-# Copyright (C) 2007-2016 CEA/DEN, EDF R&D, OPEN CASCADE
+# Copyright (C) 2007-2019 CEA/DEN, EDF R&D, OPEN CASCADE
#
# This library is free software; you can redistribute it and/or
# modify it under the terms of the GNU Lesser General Public
-// Copyright (C) 2007-2016 CEA/DEN, EDF R&D, OPEN CASCADE
+// Copyright (C) 2007-2019 CEA/DEN, EDF R&D, OPEN CASCADE
//
// Copyright (C) 2003-2007 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
#define _NETGENPlugin_DEFS_HXX_
#ifdef WIN32
+
#if defined NETGENPLUGIN_EXPORTS || defined NETGENEngine_EXPORTS
#define NETGENPLUGIN_EXPORT __declspec( dllexport )
#else
#define NETGENPLUGIN_EXPORT __declspec( dllimport )
#endif
+
+ #if defined(NETGEN_V5)
+ #define NETGENPLUGIN_DLL_HEADER DLL_HEADER
+ #else
+ #define NETGENPLUGIN_DLL_HEADER
+ #endif
+
#else
+
#define NETGENPLUGIN_EXPORT
+ #define NETGENPLUGIN_DLL_HEADER
+
#endif
#endif
-// Copyright (C) 2007-2016 CEA/DEN, EDF R&D, OPEN CASCADE
+// Copyright (C) 2007-2019 CEA/DEN, EDF R&D, OPEN CASCADE
//
// Copyright (C) 2003-2007 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
//=============================================================================
/*!
- *
+ *
*/
//=============================================================================
-NETGENPlugin_Hypothesis::NETGENPlugin_Hypothesis (int hypId,
- SMESH_Gen * gen)
+NETGENPlugin_Hypothesis::NETGENPlugin_Hypothesis (int hypId, SMESH_Gen * gen)
: SMESH_Hypothesis(hypId, gen),
+ _fineness (GetDefaultFineness()),
+ _secondOrder (GetDefaultSecondOrder()),
+ _quadAllowed (GetDefaultQuadAllowed()),
_maxSize (GetDefaultMaxSize()),
_minSize (0),
_growthRate (GetDefaultGrowthRate()),
- _nbSegPerEdge (GetDefaultNbSegPerEdge()),
_nbSegPerRadius (GetDefaultNbSegPerRadius()),
- _fineness (GetDefaultFineness()),
+ _nbSegPerEdge (GetDefaultNbSegPerEdge()),
_chordalErrorEnabled(GetDefaultChordalError() > 0),
_chordalError (GetDefaultChordalError() ),
- _secondOrder (GetDefaultSecondOrder()),
_optimize (GetDefaultOptimize()),
- _quadAllowed (GetDefaultQuadAllowed()),
+ _nbSurfOptSteps (GetDefaultNbSurfOptSteps()),
+ _nbVolOptSteps (GetDefaultNbVolOptSteps()),
+ _elemSizeWeight (GetDefaultElemSizeWeight()),
+ _worstElemMeasure (GetDefaultWorstElemMeasure()),
_surfaceCurvature (GetDefaultSurfaceCurvature()),
+ _useDelauney (GetDefaultUseDelauney()),
+ _checkOverlapping (GetDefaultCheckOverlapping()),
+ _checkChartBoundary (GetDefaultCheckChartBoundary()),
_fuseEdges (GetDefaultFuseEdges())
{
_name = "NETGEN_Parameters";
_param_algo_dim = 3;
- _localSize.clear();
}
//=============================================================================
/*!
- *
+ *
*/
//=============================================================================
void NETGENPlugin_Hypothesis::SetMaxSize(double theSize)
}
}
-//=============================================================================
-/*!
- *
- */
-//=============================================================================
-bool NETGENPlugin_Hypothesis::GetDefaultQuadAllowed()
-{
- return false;
-}
-
//=============================================================================
/*!
*
}
}
-//=============================================================================
-/*!
- *
- */
-//=============================================================================
-bool NETGENPlugin_Hypothesis::GetDefaultSurfaceCurvature()
-{
- return true;
-}
-
//=============================================================================
/*!
*
}
}
-//=============================================================================
-/*!
- *
- */
-//=============================================================================
-bool NETGENPlugin_Hypothesis::GetDefaultFuseEdges()
+//=======================================================================
+//function : SetNbSurfOptSteps
+//purpose :
+//=======================================================================
+
+void NETGENPlugin_Hypothesis::SetNbSurfOptSteps( int theVal )
{
- return true; // false; -- for SALOME_TESTS/Grids/smesh/3D_mesh_NETGEN_05/F6
+ if (theVal != _nbSurfOptSteps)
+ {
+ _nbSurfOptSteps = theVal;
+ NotifySubMeshesHypothesisModification();
+ }
+}
+
+//=======================================================================
+//function : SetNbVolOptSteps
+//purpose :
+//=======================================================================
+
+void NETGENPlugin_Hypothesis::SetNbVolOptSteps( int theVal )
+{
+ if (theVal != _nbVolOptSteps)
+ {
+ _nbVolOptSteps = theVal;
+ NotifySubMeshesHypothesisModification();
+ }
+}
+
+//=======================================================================
+//function : SetElemSizeWeight
+//purpose :
+//=======================================================================
+
+void NETGENPlugin_Hypothesis::SetElemSizeWeight( double theVal )
+{
+ if (theVal != _elemSizeWeight)
+ {
+ _elemSizeWeight = theVal;
+ NotifySubMeshesHypothesisModification();
+ }
+}
+
+//=======================================================================
+//function : SetWorstElemMeasure
+//purpose :
+//=======================================================================
+
+void NETGENPlugin_Hypothesis::SetWorstElemMeasure( int theVal )
+{
+ if (theVal != _worstElemMeasure)
+ {
+ _worstElemMeasure = theVal;
+ NotifySubMeshesHypothesisModification();
+ }
+}
+
+//=======================================================================
+//function : SetUseDelauney
+//purpose :
+//=======================================================================
+
+void NETGENPlugin_Hypothesis::SetUseDelauney( bool theVal )
+{
+ if (theVal != _useDelauney )
+ {
+ _useDelauney = theVal;
+ NotifySubMeshesHypothesisModification();
+ }
+}
+
+//=======================================================================
+//function : SetCheckOverlapping
+//purpose :
+//=======================================================================
+
+void NETGENPlugin_Hypothesis::SetCheckOverlapping( bool theVal )
+{
+ if (theVal != _checkOverlapping )
+ {
+ _checkOverlapping = theVal;
+ NotifySubMeshesHypothesisModification();
+ }
+}
+
+//=======================================================================
+//function : SetCheckChartBoundary
+//purpose :
+//=======================================================================
+
+void NETGENPlugin_Hypothesis::SetCheckChartBoundary( bool theVal )
+{
+ if (theVal != _checkChartBoundary)
+ {
+ _checkChartBoundary = theVal;
+ NotifySubMeshesHypothesisModification();
+ }
}
//=============================================================================
save << " " << ( _chordalErrorEnabled ? _chordalError : 0. );
+
+ // added for option set completion
+
+ save << " " << _nbSurfOptSteps;
+ save << " " << _nbVolOptSteps;
+ save << " " << _elemSizeWeight;
+ save << " " << _worstElemMeasure;
+
+ save << " " << _useDelauney;
+ save << " " << _checkOverlapping;
+ save << " " << _checkChartBoundary;
+
return save;
}
load.clear(ios::badbit | load.rdstate());
_chordalErrorEnabled = ( _chordalError > 0 );
- return load;
-}
-//=============================================================================
-/*!
- *
- */
-//=============================================================================
-ostream & operator <<(ostream & save, NETGENPlugin_Hypothesis & hyp)
-{
- return hyp.SaveTo( save );
-}
+ // added for option set completion
-//=============================================================================
-/*!
- *
- */
-//=============================================================================
-istream & operator >>(istream & load, NETGENPlugin_Hypothesis & hyp)
-{
- return hyp.LoadFrom( load );
-}
+ isOK = static_cast<bool>( load >> is );
+ if ( isOK )
+ _nbSurfOptSteps = is;
+
+ isOK = static_cast<bool>( load >> is );
+ if ( isOK )
+ _nbVolOptSteps = is;
+
+ isOK = static_cast<bool>( load >> val );
+ if ( isOK )
+ _elemSizeWeight = val;
+
+ isOK = static_cast<bool>( load >> is );
+ if ( isOK )
+ _worstElemMeasure = is;
+
+ isOK = static_cast<bool>( load >> is );
+ if ( isOK )
+ _useDelauney = (bool) is;
+
+ isOK = static_cast<bool>( load >> is );
+ if ( isOK )
+ _checkOverlapping = (bool) is;
+ isOK = static_cast<bool>( load >> is );
+ if ( isOK )
+ _checkChartBoundary = (bool) is;
+
+ return load;
+}
//================================================================================
/*!
return _nbSegPerEdge && _maxSize > 0;
}
-
-//=============================================================================
-/*!
- *
- */
-//=============================================================================
-double NETGENPlugin_Hypothesis::GetDefaultMaxSize()
-{
- return 1000;
-}
-
-//=============================================================================
-/*!
- *
- */
-//=============================================================================
-NETGENPlugin_Hypothesis::Fineness NETGENPlugin_Hypothesis::GetDefaultFineness()
-{
- return Moderate;
-}
-
-//=============================================================================
-/*!
- *
- */
-//=============================================================================
-double NETGENPlugin_Hypothesis::GetDefaultGrowthRate()
-{
- return 0.3;
-}
-
-//=============================================================================
-/*!
- *
- */
-//=============================================================================
-double NETGENPlugin_Hypothesis::GetDefaultNbSegPerEdge()
-{
- return 1;
-}
-
-//=============================================================================
-/*!
- *
- */
-//=============================================================================
-double NETGENPlugin_Hypothesis::GetDefaultNbSegPerRadius()
-{
- return 2;
-}
-//=============================================================================
-/*!
- *
- */
-//=============================================================================
-double NETGENPlugin_Hypothesis::GetDefaultChordalError()
-{
- return -1; // disabled by default
-}
-
-//=============================================================================
-/*!
- *
- */
-//=============================================================================
-bool NETGENPlugin_Hypothesis::GetDefaultSecondOrder()
-{
- return false;
-}
-
-//=============================================================================
-/*!
- *
- */
-//=============================================================================
-bool NETGENPlugin_Hypothesis::GetDefaultOptimize()
-{
- return true;
-}
-// Copyright (C) 2007-2016 CEA/DEN, EDF R&D, OPEN CASCADE
+// Copyright (C) 2007-2019 CEA/DEN, EDF R&D, OPEN CASCADE
//
// Copyright (C) 2003-2007 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
NETGENPlugin_Hypothesis(int hypId, SMESH_Gen * gen);
- void SetMaxSize(double theSize);
+ void SetMaxSize(double theSize);
double GetMaxSize() const { return _maxSize; }
- void SetMinSize(double theSize);
+ void SetMinSize(double theSize);
double GetMinSize() const { return _minSize; }
- void SetSecondOrder(bool theVal);
- bool GetSecondOrder() const { return _secondOrder; }
+ void SetSecondOrder(bool theVal);
+ bool GetSecondOrder() const { return _secondOrder; }
- void SetOptimize(bool theVal);
- bool GetOptimize() const { return _optimize; }
+ void SetOptimize(bool theVal);
+ bool GetOptimize() const { return _optimize; }
enum Fineness
{
UserDefined
};
- void SetFineness(Fineness theFineness);
+ void SetFineness(Fineness theFineness);
Fineness GetFineness() const { return _fineness; }
- // the following parameters are controlled by Fineness
+ // the following 3 parameters are controlled by Fineness
- void SetGrowthRate(double theRate);
+ void SetGrowthRate(double theRate);
double GetGrowthRate() const { return _growthRate; }
- void SetNbSegPerEdge(double theVal);
+ void SetNbSegPerEdge(double theVal);
double GetNbSegPerEdge() const { return _nbSegPerEdge; }
- void SetNbSegPerRadius(double theVal);
+ void SetNbSegPerRadius(double theVal);
double GetNbSegPerRadius() const { return _nbSegPerRadius; }
- void SetChordalErrorEnabled(bool value);
+ void SetChordalErrorEnabled(bool value);
double GetChordalErrorEnabled() const { return _chordalErrorEnabled; }
- void SetChordalError(double value);
+ void SetChordalError(double value);
double GetChordalError() const { return _chordalError; }
typedef std::map<std::string, double> TLocalSize;
void SetLocalSizeOnEntry(const std::string& entry, double localSize);
double GetLocalSizeOnEntry(const std::string& entry);
const TLocalSize& GetLocalSizesAndEntries() const { return _localSize; }
- void UnsetLocalSizeOnEntry(const std::string& entry);
+ void UnsetLocalSizeOnEntry(const std::string& entry);
- void SetMeshSizeFile(const std::string& fileName);
+ void SetMeshSizeFile(const std::string& fileName);
const std::string& GetMeshSizeFile() const { return _meshSizeFile; }
- void SetQuadAllowed(bool theVal);
- bool GetQuadAllowed() const { return _quadAllowed; }
+ void SetQuadAllowed(bool theVal);
+ bool GetQuadAllowed() const { return _quadAllowed; }
- void SetSurfaceCurvature(bool theVal);
- bool GetSurfaceCurvature() const { return _surfaceCurvature; }
+ void SetSurfaceCurvature(bool theVal);
+ bool GetSurfaceCurvature() const { return _surfaceCurvature; }
- void SetFuseEdges(bool theVal);
- bool GetFuseEdges() const { return _fuseEdges; }
+ void SetFuseEdges(bool theVal);
+ bool GetFuseEdges() const { return _fuseEdges; }
+
+ void SetNbSurfOptSteps( int nb );
+ int GetNbSurfOptSteps() const { return _nbSurfOptSteps; }
+
+ void SetNbVolOptSteps( int nb );
+ int GetNbVolOptSteps() const { return _nbVolOptSteps; }
+
+ void SetElemSizeWeight( double size );
+ double GetElemSizeWeight() const { return _elemSizeWeight; }
+
+ void SetWorstElemMeasure( int val );
+ int GetWorstElemMeasure() const { return _worstElemMeasure; }
+
+ void SetUseDelauney( bool toUse);
+ bool GetUseDelauney() const { return _useDelauney; }
+
+ void SetCheckOverlapping( bool toCheck );
+ bool GetCheckOverlapping() const { return _checkOverlapping; }
+
+ void SetCheckChartBoundary( bool toCheck );
+ bool GetCheckChartBoundary() const { return _checkChartBoundary; }
// the default values (taken from NETGEN 4.5 sources)
- static double GetDefaultMaxSize();
- static Fineness GetDefaultFineness();
- static double GetDefaultGrowthRate();
- static double GetDefaultNbSegPerEdge();
- static double GetDefaultNbSegPerRadius();
- static double GetDefaultChordalError();
- static bool GetDefaultSecondOrder();
- static bool GetDefaultOptimize();
- static bool GetDefaultQuadAllowed();
- static bool GetDefaultSurfaceCurvature();
- static bool GetDefaultFuseEdges();
+ static Fineness GetDefaultFineness() { return Moderate; }
+ static bool GetDefaultSecondOrder() { return false; }
+ static bool GetDefaultQuadAllowed() { return false; }
+ static double GetDefaultMaxSize() { return 1000; }
+ static double GetDefaultGrowthRate() { return 0.3; }
+ static double GetDefaultNbSegPerRadius() { return 2; }
+ static double GetDefaultNbSegPerEdge() { return 1; }
+ static double GetDefaultChordalError() { return -1; } // disabled by default
+ static bool GetDefaultOptimize() { return true; }
+ static int GetDefaultNbSurfOptSteps() { return 3; }
+ static int GetDefaultNbVolOptSteps() { return 3; }
+ static double GetDefaultElemSizeWeight() { return 0.2; }
+ static int GetDefaultWorstElemMeasure() { return 2; }
+ static bool GetDefaultSurfaceCurvature() { return true; }
+ static bool GetDefaultUseDelauney() { return true; }
+ static bool GetDefaultCheckOverlapping() { return true; }
+ static bool GetDefaultCheckChartBoundary(){ return true; }
+ static bool GetDefaultFuseEdges() { return true; }
// Persistence
- virtual std::ostream & SaveTo(std::ostream & save);
+ virtual std::ostream & SaveTo (std::ostream & save);
virtual std::istream & LoadFrom(std::istream & load);
/*!
virtual bool SetParametersByDefaults(const TDefaults& dflts, const SMESH_Mesh* theMesh=0);
private:
+
+ // General
+ Fineness _fineness;
+ bool _secondOrder;
+ bool _quadAllowed;
+
+ // Mesh size
double _maxSize, _minSize;
double _growthRate;
- double _nbSegPerEdge;
+ std::string _meshSizeFile;
double _nbSegPerRadius;
- Fineness _fineness;
+ double _nbSegPerEdge;
+ // (SALOME additions)
+ TLocalSize _localSize;
bool _chordalErrorEnabled;
double _chordalError;
- bool _secondOrder;
+
+ // Optimizer
bool _optimize;
- TLocalSize _localSize;
- std::string _meshSizeFile;
- bool _quadAllowed;
+ int _nbSurfOptSteps;
+ int _nbVolOptSteps;
+ double _elemSizeWeight;
+ int _worstElemMeasure;
+
+ // Insider
bool _surfaceCurvature;
+ bool _useDelauney;
+ bool _checkOverlapping;
+ bool _checkChartBoundary;
+ //bool _blockFilling; -- not used by netgen
+ // (SALOME additions)
bool _fuseEdges;
};
-// Copyright (C) 2007-2016 CEA/DEN, EDF R&D, OPEN CASCADE
+// Copyright (C) 2007-2019 CEA/DEN, EDF R&D, OPEN CASCADE
//
// Copyright (C) 2003-2007 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
//
#include "NETGENPlugin_Hypothesis_2D.hxx"
+#include <SMESH_Mesh.hxx>
+#include <SMESH_Group.hxx>
+#include <SMESHDS_GroupBase.hxx>
+
using namespace std;
//=============================================================================
//=============================================================================
/*!
- *
+ *
*/
//=============================================================================
NETGENPlugin_RemesherHypothesis_2D::
NETGENPlugin_RemesherHypothesis_2D (int hypId, SMESH_Gen * gen)
- : NETGENPlugin_Hypothesis(hypId, gen)
+ : NETGENPlugin_Hypothesis(hypId, gen),
+ _ridgeAngle ( DefaultRidgeAngle() ),
+ _edgeCornerAngle ( DefaultEdgeCornerAngle() ),
+ _chartAngle ( DefaultChartAngle() ),
+ _outerChartAngle ( DefaultOuterChartAngle() ),
+ _restHChartDistFactor ( DefaultRestHChartDistFactor() ),
+ _restHChartDistEnable ( DefaultRestHChartDistEnable() ),
+ _restHLineLengthFactor ( DefaultRestHLineLengthFactor() ),
+ _restHLineLengthEnable ( DefaultRestHLineLengthEnable() ),
+ _restHCloseEdgeFactor ( DefaultRestHCloseEdgeFactor() ),
+ _restHCloseEdgeEnable ( DefaultRestHCloseEdgeEnable() ),
+ _restHSurfCurvFactor ( DefaultRestHSurfCurvFactor() ),
+ _restHSurfCurvEnable ( DefaultRestHSurfCurvEnable() ),
+ _restHEdgeAngleFactor ( DefaultRestHEdgeAngleFactor() ),
+ _restHEdgeAngleEnable ( DefaultRestHEdgeAngleEnable() ),
+ _restHSurfMeshCurvFactor( DefaultRestHSurfMeshCurvFactor()),
+ _restHSurfMeshCurvEnable( DefaultRestHSurfMeshCurvEnable()),
+ _keepExistingEdges ( DefaultKeepExistingEdges() ),
+ _makeGroupsOfSurfaces ( DefaultMakeGroupsOfSurfaces() ),
+ _fixedEdgeGroupID ( -1 ),
+ _loadOnCancel ( false )
{
_name = "NETGEN_RemesherParameters_2D";
_param_algo_dim = 2;
-
- _ridgeAngle = DefaultRidgeAngle();
}
//=============================================================================
/*!
- *
+ *
*/
//=============================================================================
}
}
-//=============================================================================
-/*!
- *
- */
-//=============================================================================
+//=======================================================================
+//function : SetEdgeCornerAngle
+//purpose :
+//=======================================================================
+
+void NETGENPlugin_RemesherHypothesis_2D::SetEdgeCornerAngle( double angle )
+{
+ if ( _edgeCornerAngle != angle )
+ {
+ _edgeCornerAngle = angle;
+ NotifySubMeshesHypothesisModification();
+ }
+}
+
+//=======================================================================
+//function : SetChartAngle
+//purpose :
+//=======================================================================
+
+void NETGENPlugin_RemesherHypothesis_2D::SetChartAngle( double angle )
+{
+ if ( _chartAngle != angle )
+ {
+ _chartAngle = angle;
+ NotifySubMeshesHypothesisModification();
+ }
+}
+
+//=======================================================================
+//function : SetOuterChartAngle
+//purpose :
+//=======================================================================
+
+void NETGENPlugin_RemesherHypothesis_2D::SetOuterChartAngle( double angle )
+{
+ if ( _outerChartAngle != angle )
+ {
+ _outerChartAngle = angle;
+ NotifySubMeshesHypothesisModification();
+ }
+}
+
+//=======================================================================
+//function : SetRestHChartDistFactor
+//purpose :
+//=======================================================================
+
+void NETGENPlugin_RemesherHypothesis_2D::SetRestHChartDistFactor( double f )
+{
+ if ( _restHChartDistFactor != f )
+ {
+ _restHChartDistFactor = f;
+ NotifySubMeshesHypothesisModification();
+ }
+}
+
+//=======================================================================
+//function : SetRestHChartDistEnable
+//purpose :
+//=======================================================================
+
+void NETGENPlugin_RemesherHypothesis_2D::SetRestHChartDistEnable( bool enable )
+{
+ if ( _restHChartDistEnable != enable )
+ {
+ _restHChartDistEnable = enable;
+ NotifySubMeshesHypothesisModification();
+ }
+}
+
+//=======================================================================
+//function : SetRestHLineLengthFactor
+//purpose :
+//=======================================================================
+
+void NETGENPlugin_RemesherHypothesis_2D::SetRestHLineLengthFactor( double f )
+{
+ if ( _restHLineLengthFactor != f )
+ {
+ _restHLineLengthFactor = f;
+ NotifySubMeshesHypothesisModification();
+ }
+}
+
+//=======================================================================
+//function : SetRestHLineLengthEnable
+//purpose :
+//=======================================================================
+
+void NETGENPlugin_RemesherHypothesis_2D::SetRestHLineLengthEnable( bool enable )
+{
+ if ( _restHLineLengthEnable != enable )
+ {
+ _restHLineLengthEnable = enable;
+ NotifySubMeshesHypothesisModification();
+ }
+}
+
+//=======================================================================
+//function : SetRestHCloseEdgeFactor
+//purpose :
+//=======================================================================
+
+void NETGENPlugin_RemesherHypothesis_2D::SetRestHCloseEdgeFactor( double f )
+{
+ if ( _restHCloseEdgeFactor != f )
+ {
+ _restHCloseEdgeFactor = f;
+ NotifySubMeshesHypothesisModification();
+ }
+}
+
+//=======================================================================
+//function : SetRestHCloseEdgeEnable
+//purpose :
+//=======================================================================
+
+void NETGENPlugin_RemesherHypothesis_2D::SetRestHCloseEdgeEnable( bool enable )
+{
+ if ( _restHCloseEdgeEnable != enable )
+ {
+ _restHCloseEdgeEnable = enable;
+ NotifySubMeshesHypothesisModification();
+ }
+}
+
+//=======================================================================
+//function : SetRestHSurfCurvFactor
+//purpose :
+//=======================================================================
+
+void NETGENPlugin_RemesherHypothesis_2D::SetRestHSurfCurvFactor( double f )
+{
+ if ( _restHSurfCurvFactor != f )
+ {
+ _restHSurfCurvFactor = f;
+ NotifySubMeshesHypothesisModification();
+ }
+}
+
+//=======================================================================
+//function : SetRestHSurfCurvEnable
+//purpose :
+//=======================================================================
+
+void NETGENPlugin_RemesherHypothesis_2D::SetRestHSurfCurvEnable( bool enable )
+{
+ if ( _restHSurfCurvEnable != enable )
+ {
+ _restHSurfCurvEnable = enable;
+ NotifySubMeshesHypothesisModification();
+ }
+}
+
+//=======================================================================
+//function : SetRestHEdgeAngleFactor
+//purpose :
+//=======================================================================
+
+void NETGENPlugin_RemesherHypothesis_2D::SetRestHEdgeAngleFactor( double f )
+{
+ if ( _restHEdgeAngleFactor != f )
+ {
+ _restHEdgeAngleFactor = f;
+ NotifySubMeshesHypothesisModification();
+ }
+}
+
+//=======================================================================
+//function : SetRestHEdgeAngleEnable
+//purpose :
+//=======================================================================
+
+void NETGENPlugin_RemesherHypothesis_2D::SetRestHEdgeAngleEnable( bool enable )
+{
+ if ( _restHEdgeAngleEnable != enable )
+ {
+ _restHEdgeAngleEnable = enable;
+ NotifySubMeshesHypothesisModification();
+ }
+}
+
+//=======================================================================
+//function : SetRestHSurfMeshCurvFactor
+//purpose :
+//=======================================================================
+
+void NETGENPlugin_RemesherHypothesis_2D::SetRestHSurfMeshCurvFactor( double f )
+{
+ if ( _restHSurfMeshCurvFactor != f )
+ {
+ _restHSurfMeshCurvFactor = f;
+ NotifySubMeshesHypothesisModification();
+ }
+}
+
+//=======================================================================
+//function : SetRestHSurfMeshCurvEnable
+//purpose :
+//=======================================================================
+
+void NETGENPlugin_RemesherHypothesis_2D::SetRestHSurfMeshCurvEnable( bool enable )
+{
+ if ( _restHSurfMeshCurvEnable != enable )
+ {
+ _restHSurfMeshCurvEnable = enable;
+ NotifySubMeshesHypothesisModification();
+ }
+}
+
+//=======================================================================
+//function : SetKeepExistingEdges
+//purpose :
+//=======================================================================
+
+void NETGENPlugin_RemesherHypothesis_2D::SetKeepExistingEdges( bool toKeep )
+{
+ if ( _keepExistingEdges != toKeep )
+ {
+ _keepExistingEdges = toKeep;
+ NotifySubMeshesHypothesisModification();
+ }
+}
+
+//=======================================================================
+//function : SetMakeGroupsOfSurfaces
+//purpose :
+//=======================================================================
+
+void NETGENPlugin_RemesherHypothesis_2D::SetMakeGroupsOfSurfaces( bool toMake )
+{
+ if ( _makeGroupsOfSurfaces != toMake )
+ {
+ _makeGroupsOfSurfaces = toMake;
+ NotifySubMeshesHypothesisModification();
+ }
+}
+
+//=======================================================================
+//function : SetFixedEdgeGroup
+//purpose : Set a group of edges whose nodes must not be moved
+//=======================================================================
+
+void NETGENPlugin_RemesherHypothesis_2D::SetFixedEdgeGroup( const SMESH_Group* edgeGroup )
+{
+ int id = edgeGroup ? edgeGroup->GetID() : -1;
+ if ( id != _fixedEdgeGroupID )
+ {
+ _fixedEdgeGroupID = id;
+ NotifySubMeshesHypothesisModification();
+ }
+}
+
+//=======================================================================
+//function : SetLoadMeshOnCancel
+//purpose : allow getting a current mesh existing upon CancelCompute()
+//=======================================================================
+
+void NETGENPlugin_RemesherHypothesis_2D::SetLoadMeshOnCancel( bool toLoad )
+{
+ if ( toLoad != _loadOnCancel )
+ {
+ _loadOnCancel = toLoad;
+ NotifySubMeshesHypothesisModification();
+ }
+}
+
+//=======================================================================
+//function : GetFixedEdgeGroup
+//purpose : Return a group of edges whose nodes must not be moved
+//=======================================================================
-double NETGENPlugin_RemesherHypothesis_2D::GetRidgeAngle() const
+SMESH_Group*
+NETGENPlugin_RemesherHypothesis_2D::GetFixedEdgeGroup( const SMESH_Mesh& mesh ) const
{
- return _ridgeAngle;
+ SMESH_Group* group = mesh.GetGroup( _fixedEdgeGroupID );
+ if ( group && group->GetGroupDS()->GetType() != SMDSAbs_Edge )
+ group = NULL;
+
+ return group;
}
//=============================================================================
NETGENPlugin_Hypothesis::SaveTo( save );
save << " " << _ridgeAngle;
+ save << " " << _edgeCornerAngle ;
+ save << " " << _chartAngle ;
+ save << " " << _outerChartAngle ;
+ save << " " << _restHChartDistFactor ;
+ save << " " << _restHChartDistEnable ;
+ save << " " << _restHLineLengthFactor ;
+ save << " " << _restHLineLengthEnable ;
+ save << " " << _restHCloseEdgeFactor ;
+ save << " " << _restHCloseEdgeEnable ;
+ save << " " << _restHSurfCurvFactor ;
+ save << " " << _restHSurfCurvEnable ;
+ save << " " << _restHEdgeAngleFactor ;
+ save << " " << _restHEdgeAngleEnable ;
+ save << " " << _restHSurfMeshCurvFactor;
+ save << " " << _restHSurfMeshCurvEnable;
+ save << " " << _keepExistingEdges ;
+ save << " " << _makeGroupsOfSurfaces ;
+ save << " " << _fixedEdgeGroupID ;
+ save << " " << _loadOnCancel ;
+
return save;
}
if ( !load )
_ridgeAngle = DefaultRidgeAngle();
+ load >> _edgeCornerAngle;
+ if ( !load )
+ _edgeCornerAngle = DefaultEdgeCornerAngle();
+
+ load >> _chartAngle;
+ if ( !load )
+ _chartAngle = DefaultChartAngle();
+
+ load >> _outerChartAngle;
+ if ( !load )
+ _outerChartAngle = DefaultOuterChartAngle();
+
+ load >> _restHChartDistFactor;
+ if ( !load )
+ _restHChartDistFactor = DefaultRestHChartDistFactor();
+
+ load >> _restHChartDistEnable;
+ if ( !load )
+ _restHChartDistEnable = DefaultRestHChartDistEnable();
+
+ load >> _restHLineLengthFactor;
+ if ( !load )
+ _restHLineLengthFactor = DefaultRestHLineLengthFactor();
+
+ load >> _restHLineLengthEnable;
+ if ( !load )
+ _restHLineLengthEnable = DefaultRestHLineLengthEnable();
+
+ load >> _restHCloseEdgeFactor;
+ if ( !load )
+ _restHCloseEdgeFactor = DefaultRestHCloseEdgeFactor();
+
+ load >> _restHCloseEdgeEnable;
+ if ( !load )
+ _restHCloseEdgeEnable = DefaultRestHCloseEdgeEnable();
+
+ load >> _restHSurfCurvFactor;
+ if ( !load )
+ _restHSurfCurvFactor = DefaultRestHSurfCurvFactor();
+
+ load >> _restHSurfCurvEnable;
+ if ( !load )
+ _restHSurfCurvEnable = DefaultRestHSurfCurvEnable();
+
+ load >> _restHEdgeAngleFactor;
+ if ( !load )
+ _restHEdgeAngleFactor = DefaultRestHEdgeAngleFactor();
+
+ load >> _restHEdgeAngleEnable;
+ if ( !load )
+ _restHEdgeAngleEnable = DefaultRestHEdgeAngleEnable();
+
+ load >> _restHSurfMeshCurvFactor;
+ if ( !load )
+ _restHSurfMeshCurvFactor = DefaultRestHSurfMeshCurvFactor();
+
+ load >> _restHSurfMeshCurvEnable;
+ if ( !load )
+ _restHSurfMeshCurvEnable = DefaultRestHSurfMeshCurvEnable();
+
+ load >> _keepExistingEdges;
+ if ( !load )
+ _keepExistingEdges = DefaultKeepExistingEdges();
+
+ load >> _makeGroupsOfSurfaces;
+ if ( !load )
+ _makeGroupsOfSurfaces = DefaultMakeGroupsOfSurfaces();
+
+ load >> _fixedEdgeGroupID;
+ if ( !load )
+ _fixedEdgeGroupID = -1;
+
+ load >> _loadOnCancel;
+ if ( !load )
+ _loadOnCancel = false;
+
return load;
}
-// Copyright (C) 2007-2016 CEA/DEN, EDF R&D, OPEN CASCADE
+// Copyright (C) 2007-2019 CEA/DEN, EDF R&D, OPEN CASCADE
//
// Copyright (C) 2003-2007 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
#include "NETGENPlugin_Hypothesis.hxx"
#include "Utils_SALOME_Exception.hxx"
-// Parameters for work of NETGEN.
+class SMESH_Group;
+
+// Parameters of NETGEN.
// This class is just to give 2D dimension, actually
// it inherits all behaviour of the parent
NETGENPlugin_Hypothesis_2D(int hypId, SMESH_Gen * gen);
- // void SetQuadAllowed(bool theVal);
- // bool GetQuadAllowed() const { return _quadAllowed; }
- // static bool GetDefaultQuadAllowed();
-
- // Persistence
- // virtual ostream & SaveTo(ostream & save);
- // virtual istream & LoadFrom(istream & load);
-
// private:
// bool _quadAllowed;
};
NETGENPlugin_RemesherHypothesis_2D(int hypId, SMESH_Gen * gen);
- void SetRidgeAngle( double angle );
- double GetRidgeAngle() const;
+ void SetRidgeAngle( double angle );
+ double GetRidgeAngle() const{ return _ridgeAngle; }
+
+ void SetEdgeCornerAngle( double angle );
+ double GetEdgeCornerAngle() const { return _edgeCornerAngle; }
+
+ void SetChartAngle( double angle );
+ double GetChartAngle() const { return _chartAngle; }
+
+ void SetOuterChartAngle( double angle );
+ double GetOuterChartAngle() const { return _outerChartAngle; }
+
+ void SetRestHChartDistFactor( double f );
+ double GetRestHChartDistFactor() const { return _restHChartDistFactor; }
+
+ void SetRestHChartDistEnable( bool enable );
+ bool GetRestHChartDistEnable() const { return _restHChartDistEnable; }
+
+ void SetRestHLineLengthFactor( double f );
+ double GetRestHLineLengthFactor() const { return _restHLineLengthFactor; }
+
+ void SetRestHLineLengthEnable( bool enable );
+ bool GetRestHLineLengthEnable() const { return _restHLineLengthEnable; }
+
+ void SetRestHCloseEdgeFactor( double f );
+ double GetRestHCloseEdgeFactor() const { return _restHCloseEdgeFactor; }
+
+ void SetRestHCloseEdgeEnable( bool enable );
+ bool GetRestHCloseEdgeEnable() const { return _restHCloseEdgeEnable; }
- static double DefaultRidgeAngle() { return 30.; }
+ void SetRestHSurfCurvFactor( double f );
+ double GetRestHSurfCurvFactor() const { return _restHSurfCurvFactor; }
+
+ void SetRestHSurfCurvEnable( bool enable );
+ bool GetRestHSurfCurvEnable() const { return _restHSurfCurvEnable; }
+
+ void SetRestHEdgeAngleFactor( double f );
+ double GetRestHEdgeAngleFactor() const { return _restHEdgeAngleFactor; }
+
+ void SetRestHEdgeAngleEnable( bool enable );
+ bool GetRestHEdgeAngleEnable() const { return _restHEdgeAngleEnable; }
+
+ void SetRestHSurfMeshCurvFactor( double f );
+ double GetRestHSurfMeshCurvFactor() const { return _restHSurfMeshCurvFactor; }
+
+ void SetRestHSurfMeshCurvEnable( bool enable );
+ bool GetRestHSurfMeshCurvEnable() const { return _restHSurfMeshCurvEnable; }
+
+ void SetKeepExistingEdges( bool toKeep );
+ bool GetKeepExistingEdges() const { return _keepExistingEdges; }
+
+ void SetMakeGroupsOfSurfaces( bool toMake );
+ bool GetMakeGroupsOfSurfaces() const { return _makeGroupsOfSurfaces; }
+
+ void SetFixedEdgeGroup( const SMESH_Group* edgeGroup );
+ int GetFixedEdgeGroupID() const { return _fixedEdgeGroupID; }
+ SMESH_Group* GetFixedEdgeGroup( const SMESH_Mesh& mesh ) const;
+
+ void SetLoadMeshOnCancel( bool toLoad );
+ bool GetLoadMeshOnCancel() const { return _loadOnCancel; }
+
+ static double DefaultRidgeAngle() { return 30.; }
+ static double DefaultEdgeCornerAngle() { return 60.; }
+ static double DefaultChartAngle() { return 15.; }
+ static double DefaultOuterChartAngle() { return 70.; }
+ static double DefaultRestHChartDistFactor() { return 1.2; }
+ static bool DefaultRestHChartDistEnable() { return true; }
+ static double DefaultRestHLineLengthFactor() { return 0.5; }
+ static bool DefaultRestHLineLengthEnable() { return true; }
+ static double DefaultRestHCloseEdgeFactor() { return 1.; }
+ static bool DefaultRestHCloseEdgeEnable() { return true; }
+ static double DefaultRestHSurfCurvFactor() { return 1.; }
+ static bool DefaultRestHSurfCurvEnable() { return false; }
+ static double DefaultRestHEdgeAngleFactor() { return 1.; }
+ static bool DefaultRestHEdgeAngleEnable() { return false; }
+ static double DefaultRestHSurfMeshCurvFactor() { return 1.; }
+ static bool DefaultRestHSurfMeshCurvEnable() { return false; }
+ static bool DefaultKeepExistingEdges() { return false; }
+ static bool DefaultMakeGroupsOfSurfaces() { return false; }
virtual std::ostream & SaveTo(std::ostream & save);
virtual std::istream & LoadFrom(std::istream & load);
private:
- double _ridgeAngle; // in degrees
+ // STL charts
+ double _ridgeAngle; // yellow edges angle (in degrees)
+ double _edgeCornerAngle;
+ double _chartAngle;
+ double _outerChartAngle;
+
+ // Mesh size: restrict h due to ...
+ double _restHChartDistFactor; // chart distance
+ bool _restHChartDistEnable;
+ double _restHLineLengthFactor; // line length
+ bool _restHLineLengthEnable;
+ double _restHCloseEdgeFactor; // close edges
+ bool _restHCloseEdgeEnable;
+ double _restHSurfCurvFactor; // surface curvature
+ bool _restHSurfCurvEnable;
+ double _restHEdgeAngleFactor; // edge angle
+ bool _restHEdgeAngleEnable;
+ double _restHSurfMeshCurvFactor; // surface mesh curv
+ bool _restHSurfMeshCurvEnable;
+
+ // SALOME features
+ bool _keepExistingEdges;
+ bool _makeGroupsOfSurfaces;
+ int _fixedEdgeGroupID;
+ bool _loadOnCancel;
+
};
#endif
-// Copyright (C) 2007-2016 CEA/DEN, EDF R&D, OPEN CASCADE
+// Copyright (C) 2007-2019 CEA/DEN, EDF R&D, OPEN CASCADE
//
// Copyright (C) 2003-2007 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
-// Copyright (C) 2007-2016 CEA/DEN, EDF R&D, OPEN CASCADE
+// Copyright (C) 2007-2019 CEA/DEN, EDF R&D, OPEN CASCADE
//
// Copyright (C) 2003-2007 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
-// Copyright (C) 2007-2016 CEA/DEN, EDF R&D, OPEN CASCADE
+// Copyright (C) 2007-2019 CEA/DEN, EDF R&D, OPEN CASCADE
//
// Copyright (C) 2003-2007 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
//=============================================================================
//
#include "NETGENPlugin_Hypothesis_2D_i.hxx"
-#include "SMESH_Gen.hxx"
-#include "SMESH_PythonDump.hxx"
+
+#include <SMESH_Gen.hxx>
+#include <SMESH_Gen_i.hxx>
+#include <SMESH_Group_i.hxx>
+#include <SMESH_Group.hxx>
+#include <SMESH_PythonDump.hxx>
//=============================================================================
/*!
void NETGENPlugin_RemesherHypothesis_2D_i::SetRidgeAngle( CORBA::Double angle )
{
- GetImpl()->SetRidgeAngle( angle );
+ if ( GetRidgeAngle() != angle )
+ {
+ GetImpl()->SetRidgeAngle( angle );
- SMESH::TPythonDump() << _this() << ".SetRidgeAngle( " << SMESH::TVar(angle) << " )";
+ SMESH::TPythonDump() << _this() << ".SetRidgeAngle( " << SMESH::TVar(angle) << " )";
+ }
}
//================================================================================
{
return GetImpl()->GetRidgeAngle();
}
+
+void NETGENPlugin_RemesherHypothesis_2D_i::SetEdgeCornerAngle(CORBA::Double angle )
+{
+ if ( GetEdgeCornerAngle() != angle )
+ {
+ GetImpl()->SetEdgeCornerAngle( angle );
+
+ SMESH::TPythonDump() << _this() << ".SetEdgeCornerAngle( " << SMESH::TVar(angle) << " )";
+ }
+}
+
+CORBA::Double NETGENPlugin_RemesherHypothesis_2D_i::GetEdgeCornerAngle()
+{
+ return GetImpl()->GetEdgeCornerAngle();
+}
+
+void NETGENPlugin_RemesherHypothesis_2D_i::SetChartAngle(CORBA::Double angle )
+{
+ if ( GetChartAngle() != angle )
+ {
+ GetImpl()->SetChartAngle( angle );
+
+ SMESH::TPythonDump() << _this() << ".SetChartAngle( " << SMESH::TVar(angle) << " )";
+ }
+}
+
+CORBA::Double NETGENPlugin_RemesherHypothesis_2D_i::GetChartAngle()
+{
+ return GetImpl()->GetChartAngle();
+}
+
+void NETGENPlugin_RemesherHypothesis_2D_i::SetOuterChartAngle(CORBA::Double angle )
+{
+ if ( GetOuterChartAngle() != angle )
+ {
+ GetImpl()->SetOuterChartAngle( angle );
+
+ SMESH::TPythonDump() << _this() << ".SetOuterChartAngle( " << SMESH::TVar(angle) << " )";
+ }
+}
+
+CORBA::Double NETGENPlugin_RemesherHypothesis_2D_i::GetOuterChartAngle()
+{
+ return GetImpl()->GetOuterChartAngle();
+}
+
+void NETGENPlugin_RemesherHypothesis_2D_i::SetRestHChartDistFactor(CORBA::Double f )
+{
+ if ( GetRestHChartDistFactor() != f )
+ {
+ GetImpl()->SetRestHChartDistFactor( f );
+
+ SMESH::TPythonDump() << _this() << ".SetRestHChartDistFactor( " << SMESH::TVar(f) << " )";
+ }
+}
+
+CORBA::Double NETGENPlugin_RemesherHypothesis_2D_i::GetRestHChartDistFactor()
+{
+ return GetImpl()->GetRestHChartDistFactor();
+}
+
+void NETGENPlugin_RemesherHypothesis_2D_i::SetRestHChartDistEnable(CORBA::Boolean enable )
+{
+ if ( GetRestHChartDistEnable() != enable )
+ {
+ GetImpl()->SetRestHChartDistEnable( enable );
+
+ SMESH::TPythonDump() << _this() << ".SetRestHChartDistEnable( " << enable << " )";
+ }
+}
+
+CORBA::Boolean NETGENPlugin_RemesherHypothesis_2D_i::GetRestHChartDistEnable()
+{
+ return GetImpl()->GetRestHChartDistEnable();
+}
+
+void NETGENPlugin_RemesherHypothesis_2D_i::SetRestHLineLengthFactor(CORBA::Double f )
+{
+ if ( GetRestHLineLengthFactor() != f )
+ {
+ GetImpl()->SetRestHLineLengthFactor( f );
+
+ SMESH::TPythonDump() << _this() << ".SetRestHLineLengthFactor( " << SMESH::TVar(f) << " )";
+ }
+}
+
+CORBA::Double NETGENPlugin_RemesherHypothesis_2D_i::GetRestHLineLengthFactor()
+{
+ return GetImpl()->GetRestHLineLengthFactor();
+}
+
+void NETGENPlugin_RemesherHypothesis_2D_i::SetRestHLineLengthEnable(CORBA::Boolean enable )
+{
+ if ( GetRestHLineLengthEnable() != enable )
+ {
+ GetImpl()->SetRestHLineLengthEnable( enable );
+
+ SMESH::TPythonDump() << _this() << ".SetRestHLineLengthEnable( " << enable << " )";
+ }
+}
+
+CORBA::Boolean NETGENPlugin_RemesherHypothesis_2D_i::GetRestHLineLengthEnable()
+{
+ return GetImpl()->GetRestHLineLengthEnable();
+}
+
+void NETGENPlugin_RemesherHypothesis_2D_i::SetRestHCloseEdgeFactor(CORBA::Double f )
+{
+ if ( GetRestHCloseEdgeFactor() != f )
+ {
+ GetImpl()->SetRestHCloseEdgeFactor( f );
+
+ SMESH::TPythonDump() << _this() << ".SetRestHCloseEdgeFactor( " << SMESH::TVar(f) << " )";
+ }
+}
+
+CORBA::Double NETGENPlugin_RemesherHypothesis_2D_i::GetRestHCloseEdgeFactor()
+{
+ return GetImpl()->GetRestHCloseEdgeFactor();
+}
+
+void NETGENPlugin_RemesherHypothesis_2D_i::SetRestHCloseEdgeEnable(CORBA::Boolean enable )
+{
+ if ( GetRestHCloseEdgeEnable() != enable )
+ {
+ GetImpl()->SetRestHCloseEdgeEnable( enable );
+
+ SMESH::TPythonDump() << _this() << ".SetRestHCloseEdgeEnable( " << enable << " )";
+ }
+}
+
+CORBA::Boolean NETGENPlugin_RemesherHypothesis_2D_i::GetRestHCloseEdgeEnable()
+{
+ return GetImpl()->GetRestHCloseEdgeEnable();
+}
+
+void NETGENPlugin_RemesherHypothesis_2D_i::SetRestHSurfCurvFactor(CORBA::Double f )
+{
+ if ( GetRestHSurfCurvFactor() != f )
+ {
+ GetImpl()->SetRestHSurfCurvFactor( f );
+
+ SMESH::TPythonDump() << _this() << ".SetRestHSurfCurvFactor( " << SMESH::TVar(f) << " )";
+ }
+}
+
+CORBA::Double NETGENPlugin_RemesherHypothesis_2D_i::GetRestHSurfCurvFactor()
+{
+ return GetImpl()->GetRestHSurfCurvFactor();
+}
+
+void NETGENPlugin_RemesherHypothesis_2D_i::SetRestHSurfCurvEnable(CORBA::Boolean enable )
+{
+ if ( GetRestHSurfCurvEnable() != enable )
+ {
+ GetImpl()->SetRestHSurfCurvEnable( enable );
+
+ SMESH::TPythonDump() << _this() << ".SetRestHSurfCurvEnable( " << enable << " )";
+ }
+}
+
+CORBA::Boolean NETGENPlugin_RemesherHypothesis_2D_i::GetRestHSurfCurvEnable()
+{
+ return GetImpl()->GetRestHSurfCurvEnable();
+}
+
+void NETGENPlugin_RemesherHypothesis_2D_i::SetRestHEdgeAngleFactor(CORBA::Double f )
+{
+ if ( GetRestHEdgeAngleFactor() != f )
+ {
+ GetImpl()->SetRestHEdgeAngleFactor( f );
+
+ SMESH::TPythonDump() << _this() << ".SetRestHEdgeAngleFactor( " << SMESH::TVar(f) << " )";
+ }
+}
+
+CORBA::Double NETGENPlugin_RemesherHypothesis_2D_i::GetRestHEdgeAngleFactor()
+{
+ return GetImpl()->GetRestHEdgeAngleFactor();
+}
+
+void NETGENPlugin_RemesherHypothesis_2D_i::SetRestHEdgeAngleEnable(CORBA::Boolean enable )
+{
+ if ( GetRestHEdgeAngleEnable() != enable )
+ {
+ GetImpl()->SetRestHEdgeAngleEnable( enable );
+
+ SMESH::TPythonDump() << _this() << ".SetRestHEdgeAngleEnable( " << enable << " )";
+ }
+}
+
+CORBA::Boolean NETGENPlugin_RemesherHypothesis_2D_i::GetRestHEdgeAngleEnable()
+{
+ return GetImpl()->GetRestHEdgeAngleEnable();
+}
+
+void NETGENPlugin_RemesherHypothesis_2D_i::SetRestHSurfMeshCurvFactor(CORBA::Double f )
+{
+ if ( GetRestHSurfMeshCurvFactor() != f )
+ {
+ GetImpl()->SetRestHSurfMeshCurvFactor( f );
+
+ SMESH::TPythonDump() << _this() << ".SetRestHSurfMeshCurvFactor( " << SMESH::TVar(f) << " )";
+ }
+}
+
+CORBA::Double NETGENPlugin_RemesherHypothesis_2D_i::GetRestHSurfMeshCurvFactor()
+{
+ return GetImpl()->GetRestHSurfMeshCurvFactor();
+}
+
+void NETGENPlugin_RemesherHypothesis_2D_i::SetRestHSurfMeshCurvEnable(CORBA::Boolean enable )
+{
+ if ( GetRestHSurfMeshCurvEnable() != enable )
+ {
+ GetImpl()->SetRestHSurfMeshCurvEnable( enable );
+
+ SMESH::TPythonDump() << _this() << ".SetRestHSurfMeshCurvEnable( " << enable << " )";
+ }
+}
+
+CORBA::Boolean NETGENPlugin_RemesherHypothesis_2D_i::GetRestHSurfMeshCurvEnable()
+{
+ return GetImpl()->GetRestHSurfMeshCurvEnable();
+}
+
+void NETGENPlugin_RemesherHypothesis_2D_i::SetKeepExistingEdges( CORBA::Boolean toKeep )
+{
+ if ( GetKeepExistingEdges() != toKeep )
+ {
+ GetImpl()->SetKeepExistingEdges( toKeep );
+
+ SMESH::TPythonDump() << _this() << ".SetKeepExistingEdges( " << toKeep << " )";
+ }
+}
+
+CORBA::Boolean NETGENPlugin_RemesherHypothesis_2D_i::GetKeepExistingEdges()
+{
+ return GetImpl()->GetKeepExistingEdges();
+}
+
+void NETGENPlugin_RemesherHypothesis_2D_i::SetMakeGroupsOfSurfaces( CORBA::Boolean toMake )
+{
+ if ( GetMakeGroupsOfSurfaces() != toMake )
+ {
+ GetImpl()->SetMakeGroupsOfSurfaces( toMake );
+
+ SMESH::TPythonDump() << _this() << ".SetMakeGroupsOfSurfaces( " << toMake << " )";
+ }
+}
+
+CORBA::Boolean NETGENPlugin_RemesherHypothesis_2D_i::GetMakeGroupsOfSurfaces()
+{
+ return GetImpl()->GetMakeGroupsOfSurfaces();
+}
+
+void
+NETGENPlugin_RemesherHypothesis_2D_i::SetFixedEdgeGroup( SMESH::SMESH_GroupBase_ptr edgeGroup )
+{
+ const SMESH_Group * group = 0;
+ if ( SMESH_GroupBase_i* group_i = SMESH::DownCast< SMESH_GroupBase_i* >( edgeGroup ))
+ {
+ if ( group_i->GetType() == SMESH::EDGE )
+ group = group_i->GetSmeshGroup();
+ }
+
+ int id = group ? group->GetID() : -1;
+ if ( id != GetImpl()->GetFixedEdgeGroupID() )
+ {
+ GetImpl()->SetFixedEdgeGroup( group );
+ SMESH::TPythonDump() << _this() << ".SetFixedEdgeGroup( " << edgeGroup << " )";
+ }
+}
+
+SMESH::SMESH_GroupBase_ptr
+NETGENPlugin_RemesherHypothesis_2D_i::GetFixedEdgeGroup( SMESH::SMESH_Mesh_ptr mesh )
+{
+ SMESH::SMESH_GroupBase_var resGroup;
+ if ( SMESH_Mesh_i* mesh_i = SMESH::DownCast< SMESH_Mesh_i* >( mesh ))
+ {
+ const std::map<int, SMESH::SMESH_GroupBase_ptr>& groups = mesh_i->getGroups();
+ std::map<int, SMESH::SMESH_GroupBase_ptr>::const_iterator i_gr =
+ groups.find( GetImpl()->GetFixedEdgeGroupID() );
+ if ( i_gr != groups.end() && i_gr->second->GetType() == SMESH::EDGE )
+ resGroup = SMESH::SMESH_GroupBase::_duplicate( i_gr->second );
+ }
+ return resGroup._retn();
+}
+
+void NETGENPlugin_RemesherHypothesis_2D_i::SetLoadMeshOnCancel( CORBA::Boolean toMake )
+{
+ if ( GetLoadMeshOnCancel() != toMake )
+ {
+ GetImpl()->SetLoadMeshOnCancel( toMake );
+
+ SMESH::TPythonDump() << _this() << ".SetLoadMeshOnCancel( " << toMake << " )";
+ }
+}
+
+CORBA::Boolean NETGENPlugin_RemesherHypothesis_2D_i::GetLoadMeshOnCancel()
+{
+ return GetImpl()->GetLoadMeshOnCancel();
+}
-// Copyright (C) 2007-2016 CEA/DEN, EDF R&D, OPEN CASCADE
+// Copyright (C) 2007-2019 CEA/DEN, EDF R&D, OPEN CASCADE
//
// Copyright (C) 2003-2007 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
::SMESH_Gen* theGenImpl);
void SetRidgeAngle( CORBA::Double angle );
-
CORBA::Double GetRidgeAngle();
+ void SetEdgeCornerAngle( CORBA::Double angle );
+ CORBA::Double GetEdgeCornerAngle();
+
+ void SetChartAngle( CORBA::Double angle );
+ CORBA::Double GetChartAngle();
+
+ void SetOuterChartAngle( CORBA::Double angle );
+ CORBA::Double GetOuterChartAngle();
+
+ void SetRestHChartDistFactor( CORBA::Double f );
+ CORBA::Double GetRestHChartDistFactor();
+
+ void SetRestHChartDistEnable( CORBA::Boolean enable );
+ CORBA::Boolean GetRestHChartDistEnable();
+
+ void SetRestHLineLengthFactor( CORBA::Double f );
+ CORBA::Double GetRestHLineLengthFactor();
+
+ void SetRestHLineLengthEnable( CORBA::Boolean enable );
+ CORBA::Boolean GetRestHLineLengthEnable();
+
+ void SetRestHCloseEdgeFactor( CORBA::Double f );
+ CORBA::Double GetRestHCloseEdgeFactor();
+
+ void SetRestHCloseEdgeEnable( CORBA::Boolean enable );
+ CORBA::Boolean GetRestHCloseEdgeEnable();
+
+ void SetRestHSurfCurvFactor( CORBA::Double f );
+ CORBA::Double GetRestHSurfCurvFactor();
+
+ void SetRestHSurfCurvEnable( CORBA::Boolean enable );
+ CORBA::Boolean GetRestHSurfCurvEnable();
+
+ void SetRestHEdgeAngleFactor( CORBA::Double f );
+ CORBA::Double GetRestHEdgeAngleFactor();
+
+ void SetRestHEdgeAngleEnable( CORBA::Boolean enable );
+ CORBA::Boolean GetRestHEdgeAngleEnable();
+
+ void SetRestHSurfMeshCurvFactor( CORBA::Double f );
+ CORBA::Double GetRestHSurfMeshCurvFactor();
+
+ void SetRestHSurfMeshCurvEnable( CORBA::Boolean enable );
+ CORBA::Boolean GetRestHSurfMeshCurvEnable();
+
+ void SetKeepExistingEdges( CORBA::Boolean toKeep );
+ CORBA::Boolean GetKeepExistingEdges();
+
+ void SetMakeGroupsOfSurfaces( CORBA::Boolean toMake );
+ CORBA::Boolean GetMakeGroupsOfSurfaces();
+
+ void SetFixedEdgeGroup( SMESH::SMESH_GroupBase_ptr edgeGroup );
+ SMESH::SMESH_GroupBase_ptr GetFixedEdgeGroup( SMESH::SMESH_Mesh_ptr mesh );
+
+ void SetLoadMeshOnCancel( CORBA::Boolean toLoad );
+ CORBA::Boolean GetLoadMeshOnCancel();
+
+
// Get implementation
::NETGENPlugin_RemesherHypothesis_2D* GetImpl();
-// Copyright (C) 2007-2016 CEA/DEN, EDF R&D, OPEN CASCADE
+// Copyright (C) 2007-2019 CEA/DEN, EDF R&D, OPEN CASCADE
//
// Copyright (C) 2003-2007 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
-// Copyright (C) 2007-2016 CEA/DEN, EDF R&D, OPEN CASCADE
+// Copyright (C) 2007-2019 CEA/DEN, EDF R&D, OPEN CASCADE
//
// Copyright (C) 2003-2007 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
-// Copyright (C) 2007-2016 CEA/DEN, EDF R&D, OPEN CASCADE
+// Copyright (C) 2007-2019 CEA/DEN, EDF R&D, OPEN CASCADE
//
// Copyright (C) 2003-2007 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
return this->GetImpl()->GetFuseEdges();
}
+//=======================================================================
+//function : SetNbSurfOptSteps
+//purpose :
+//=======================================================================
+
+void NETGENPlugin_Hypothesis_i::SetNbSurfOptSteps(CORBA::Short nb )
+{
+ if ( GetNbSurfOptSteps() != nb )
+ {
+ this->GetImpl()->SetNbSurfOptSteps( nb );
+ SMESH::TPythonDump() << _this() << ".SetNbSurfOptSteps( " << SMESH::TVar(nb) << " )";
+ }
+}
+
+//=======================================================================
+//function : GetNbSurfOptSteps
+//purpose :
+//=======================================================================
+
+CORBA::Short NETGENPlugin_Hypothesis_i::GetNbSurfOptSteps()
+{
+ return GetImpl()->GetNbSurfOptSteps();
+}
+
+//=======================================================================
+//function : SetNbVolOptSteps
+//purpose :
+//=======================================================================
+
+void NETGENPlugin_Hypothesis_i::SetNbVolOptSteps(CORBA::Short nb )
+{
+ if ( GetNbVolOptSteps() != nb )
+ {
+ this->GetImpl()->SetNbVolOptSteps( nb );
+ SMESH::TPythonDump() << _this() << ".SetNbVolOptSteps( " << SMESH::TVar(nb) << " )";
+ }
+
+}
+
+//=======================================================================
+//function : GetNbVolOptSteps
+//purpose :
+//=======================================================================
+
+CORBA::Short NETGENPlugin_Hypothesis_i::GetNbVolOptSteps()
+{
+ return GetImpl()->GetNbVolOptSteps();
+}
+
+//=======================================================================
+//function : SetElemSizeWeight
+//purpose :
+//=======================================================================
+
+void NETGENPlugin_Hypothesis_i::SetElemSizeWeight(CORBA::Double size )
+{
+ if ( GetElemSizeWeight() != size )
+ {
+ this->GetImpl()->SetElemSizeWeight( size );
+ SMESH::TPythonDump() << _this() << ".SetElemSizeWeight( " << SMESH::TVar(size) << " )";
+ }
+}
+
+//=======================================================================
+//function : GetElemSizeWeight
+//purpose :
+//=======================================================================
+
+CORBA::Double NETGENPlugin_Hypothesis_i::GetElemSizeWeight()
+{
+ return GetImpl()->GetElemSizeWeight();
+}
+
+//=======================================================================
+//function : SetWorstElemMeasure
+//purpose :
+//=======================================================================
+
+void NETGENPlugin_Hypothesis_i::SetWorstElemMeasure(CORBA::Short val )
+{
+ if ( GetWorstElemMeasure() != val )
+ {
+ this->GetImpl()->SetWorstElemMeasure( val );
+ SMESH::TPythonDump() << _this() << ".SetWorstElemMeasure( " << SMESH::TVar(val) << " )";
+ }
+}
+
+//=======================================================================
+//function : GetWorstElemMeasure
+//purpose :
+//=======================================================================
+
+CORBA::Short NETGENPlugin_Hypothesis_i::GetWorstElemMeasure()
+{
+ return GetImpl()->GetWorstElemMeasure();
+}
+
+//=======================================================================
+//function : SetUseDelauney
+//purpose :
+//=======================================================================
+
+void NETGENPlugin_Hypothesis_i::SetUseDelauney(CORBA::Boolean toUse)
+{
+ if ( GetUseDelauney() != toUse )
+ {
+ this->GetImpl()->SetUseDelauney( toUse );
+ SMESH::TPythonDump() << _this() << ".SetUseDelauney( " << toUse << " )";
+ }
+}
+
+//=======================================================================
+//function : GetUseDelauney
+//purpose :
+//=======================================================================
+
+CORBA::Boolean NETGENPlugin_Hypothesis_i::GetUseDelauney()
+{
+ return GetImpl()->GetUseDelauney();
+}
+
+//=======================================================================
+//function : SetCheckOverlapping
+//purpose :
+//=======================================================================
+
+void NETGENPlugin_Hypothesis_i::SetCheckOverlapping(CORBA::Boolean toCheck )
+{
+ if ( GetCheckOverlapping() != toCheck )
+ {
+ this->GetImpl()->SetCheckOverlapping( toCheck );
+ SMESH::TPythonDump() << _this() << ".SetCheckOverlapping( " << toCheck << " )";
+ }
+}
+
+//=======================================================================
+//function : GetCheckOverlapping
+//purpose :
+//=======================================================================
+
+CORBA::Boolean NETGENPlugin_Hypothesis_i::GetCheckOverlapping()
+{
+ return GetImpl()->GetCheckOverlapping();
+}
+
+//=======================================================================
+//function : SetCheckChartBoundary
+//purpose :
+//=======================================================================
+
+void NETGENPlugin_Hypothesis_i::SetCheckChartBoundary(CORBA::Boolean toCheck )
+{
+ if ( GetCheckChartBoundary() != toCheck )
+ {
+ this->GetImpl()->SetCheckChartBoundary( toCheck );
+ SMESH::TPythonDump() << _this() << ".SetCheckChartBoundary( " << toCheck << " )";
+ }
+}
+
+//=======================================================================
+//function : GetCheckChartBoundary
+//purpose : Get implementation
+//=======================================================================
+
+CORBA::Boolean NETGENPlugin_Hypothesis_i::GetCheckChartBoundary()
+{
+ return GetImpl()->GetCheckChartBoundary();
+}
+
//=============================================================================
/*!
* NETGENPlugin_Hypothesis_i::GetImpl
-// Copyright (C) 2007-2016 CEA/DEN, EDF R&D, OPEN CASCADE
+// Copyright (C) 2007-2019 CEA/DEN, EDF R&D, OPEN CASCADE
//
// Copyright (C) 2003-2007 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
void SetFuseEdges(CORBA::Boolean theVal);
CORBA::Boolean GetFuseEdges();
+ void SetNbSurfOptSteps(CORBA::Short nb );
+ CORBA::Short GetNbSurfOptSteps();
+
+ void SetNbVolOptSteps(CORBA::Short nb );
+ CORBA::Short GetNbVolOptSteps();
+
+ void SetElemSizeWeight(CORBA::Double size );
+ CORBA::Double GetElemSizeWeight();
+
+ void SetWorstElemMeasure(CORBA::Short val );
+ CORBA::Short GetWorstElemMeasure();
+
+ void SetUseDelauney(CORBA::Boolean toUse);
+ CORBA::Boolean GetUseDelauney();
+
+ void SetCheckOverlapping(CORBA::Boolean toCheck );
+ CORBA::Boolean GetCheckOverlapping();
+
+ void SetCheckChartBoundary(CORBA::Boolean toCheck );
+ CORBA::Boolean GetCheckChartBoundary();
+
// Get implementation
::NETGENPlugin_Hypothesis* GetImpl();
-
+
// Verify whether hypothesis supports given entity type
CORBA::Boolean IsDimSupported( SMESH::Dimension type );
-// Copyright (C) 2007-2016 CEA/DEN, EDF R&D, OPEN CASCADE
+// Copyright (C) 2007-2019 CEA/DEN, EDF R&D, OPEN CASCADE
//
// Copyright (C) 2003-2007 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
extern int OCCGenerateMesh (OCCGeometry&, Mesh*&, int, int, char*);
#endif
//extern void OCCSetLocalMeshSize(OCCGeometry & geom, Mesh & mesh);
-#if defined(NETGEN_V5) && defined(WIN32)
- DLL_HEADER
-#endif
+
+ NETGENPLUGIN_DLL_HEADER
extern MeshingParameters mparam;
-#if defined(NETGEN_V5) && defined(WIN32)
- DLL_HEADER
-#endif
+
+ NETGENPLUGIN_DLL_HEADER
extern volatile multithreadt multithread;
-#if defined(NETGEN_V5) && defined(WIN32)
- DLL_HEADER
-#endif
+ NETGENPLUGIN_DLL_HEADER
extern bool merge_solids;
// values used for occgeo.facemeshstatus
netgen::MeshingParameters& mparams = netgen::mparam;
// Initialize global NETGEN parameters:
// maximal mesh segment size
- mparams.maxh = hyp->GetMaxSize();
+ mparams.maxh = hyp->GetMaxSize();
// maximal mesh element linear size
- mparams.minh = hyp->GetMinSize();
+ mparams.minh = hyp->GetMinSize();
// minimal number of segments per edge
- mparams.segmentsperedge = hyp->GetNbSegPerEdge();
+ mparams.segmentsperedge = hyp->GetNbSegPerEdge();
// rate of growth of size between elements
- mparams.grading = hyp->GetGrowthRate();
+ mparams.grading = hyp->GetGrowthRate();
// safety factor for curvatures (elements per radius)
- mparams.curvaturesafety = hyp->GetNbSegPerRadius();
+ mparams.curvaturesafety = hyp->GetNbSegPerRadius();
// create elements of second order
- mparams.secondorder = hyp->GetSecondOrder() ? 1 : 0;
+ mparams.secondorder = hyp->GetSecondOrder() ? 1 : 0;
// quad-dominated surface meshing
- mparams.quad = hyp->GetQuadAllowed() ? 1 : 0;
- _optimize = hyp->GetOptimize();
- _fineness = hyp->GetFineness();
- mparams.uselocalh = hyp->GetSurfaceCurvature();
- netgen::merge_solids = hyp->GetFuseEdges();
- _chordalError = hyp->GetChordalErrorEnabled() ? hyp->GetChordalError() : -1.;
- _simpleHyp = NULL;
+ mparams.quad = hyp->GetQuadAllowed() ? 1 : 0;
+ _optimize = hyp->GetOptimize();
+ _fineness = hyp->GetFineness();
+ mparams.uselocalh = hyp->GetSurfaceCurvature();
+ netgen::merge_solids = hyp->GetFuseEdges();
+ _chordalError = hyp->GetChordalErrorEnabled() ? hyp->GetChordalError() : -1.;
+ mparams.optsteps2d = _optimize ? hyp->GetNbSurfOptSteps() : 0;
+ mparams.optsteps3d = _optimize ? hyp->GetNbVolOptSteps() : 0;
+ mparams.elsizeweight = hyp->GetElemSizeWeight();
+ mparams.opterrpow = hyp->GetWorstElemMeasure();
+ mparams.delaunay = hyp->GetUseDelauney();
+ mparams.checkoverlap = hyp->GetCheckOverlapping();
+ mparams.checkchartboundary = hyp->GetCheckChartBoundary();
+ _simpleHyp = NULL;
// mesh size file
mparams.meshsizefilename= hyp->GetMeshSizeFile().empty() ? 0 : hyp->GetMeshSizeFile().c_str();
SMESH_ComputeErrorPtr& smError = sm->GetComputeError();
if ( !smComputed && ( !smError || smError->IsOK() ))
{
- smError.reset( new SMESH_ComputeError( *error ));
+ smError = error;
if ( nbVol && SMESH_Algo::GetMeshError( sm ) == SMESH_Algo::MEr_OK )
{
smError->myName = COMPERR_WARNING;
-// Copyright (C) 2007-2016 CEA/DEN, EDF R&D, OPEN CASCADE
+// Copyright (C) 2007-2019 CEA/DEN, EDF R&D, OPEN CASCADE
//
// Copyright (C) 2003-2007 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
-// Copyright (C) 2007-2016 CEA/DEN, EDF R&D, OPEN CASCADE
+// Copyright (C) 2007-2019 CEA/DEN, EDF R&D, OPEN CASCADE
//
// Copyright (C) 2003-2007 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
-// Copyright (C) 2007-2016 CEA/DEN, EDF R&D, OPEN CASCADE
+// Copyright (C) 2007-2019 CEA/DEN, EDF R&D, OPEN CASCADE
//
// Copyright (C) 2003-2007 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
-// Copyright (C) 2007-2016 CEA/DEN, EDF R&D, OPEN CASCADE
+// Copyright (C) 2007-2019 CEA/DEN, EDF R&D, OPEN CASCADE
//
// Copyright (C) 2003-2007 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
-// Copyright (C) 2007-2016 CEA/DEN, EDF R&D, OPEN CASCADE
+// Copyright (C) 2007-2019 CEA/DEN, EDF R&D, OPEN CASCADE
//
// Copyright (C) 2003-2007 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
-// Copyright (C) 2007-2016 CEA/DEN, EDF R&D, OPEN CASCADE
+// Copyright (C) 2007-2019 CEA/DEN, EDF R&D, OPEN CASCADE
//
// Copyright (C) 2003-2007 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
-// Copyright (C) 2007-2016 CEA/DEN, EDF R&D, OPEN CASCADE
+// Copyright (C) 2007-2019 CEA/DEN, EDF R&D, OPEN CASCADE
//
// Copyright (C) 2003-2007 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
-// Copyright (C) 2007-2016 CEA/DEN, EDF R&D, OPEN CASCADE
+// Copyright (C) 2007-2019 CEA/DEN, EDF R&D, OPEN CASCADE
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
#else
extern int OCCGenerateMesh (OCCGeometry&, Mesh*&, int, int, char*);
#endif
-#if defined(NETGEN_V5) && defined(WIN32)
- DLL_HEADER
-#endif
+ NETGENPLUGIN_DLL_HEADER
extern MeshingParameters mparam;
extern void OCCSetLocalMeshSize(OCCGeometry & geom, Mesh & mesh);
}
-// Copyright (C) 2007-2016 CEA/DEN, EDF R&D, OPEN CASCADE
+// Copyright (C) 2007-2019 CEA/DEN, EDF R&D, OPEN CASCADE
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
-// Copyright (C) 2007-2016 CEA/DEN, EDF R&D, OPEN CASCADE
+// Copyright (C) 2007-2019 CEA/DEN, EDF R&D, OPEN CASCADE
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
-// Copyright (C) 2007-2016 CEA/DEN, EDF R&D, OPEN CASCADE
+// Copyright (C) 2007-2019 CEA/DEN, EDF R&D, OPEN CASCADE
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
-// Copyright (C) 2007-2016 CEA/DEN, EDF R&D, OPEN CASCADE
+// Copyright (C) 2007-2019 CEA/DEN, EDF R&D, OPEN CASCADE
//
// Copyright (C) 2003-2007 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
-// Copyright (C) 2007-2016 CEA/DEN, EDF R&D, OPEN CASCADE
+// Copyright (C) 2007-2019 CEA/DEN, EDF R&D, OPEN CASCADE
//
// Copyright (C) 2003-2007 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
-// Copyright (C) 2007-2016 CEA/DEN, EDF R&D, OPEN CASCADE
+// Copyright (C) 2007-2019 CEA/DEN, EDF R&D, OPEN CASCADE
//
// Copyright (C) 2003-2007 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
#else
extern int OCCGenerateMesh (OCCGeometry&, Mesh*&, int, int, char*);
#endif
-#if defined(NETGEN_V5) && defined(WIN32)
- DLL_HEADER
-#endif
-extern MeshingParameters mparam;
-#if defined(NETGEN_V5) && defined(WIN32)
- DLL_HEADER
-#endif
+
+ NETGENPLUGIN_DLL_HEADER
+ extern MeshingParameters mparam;
+
+ NETGENPLUGIN_DLL_HEADER
extern volatile multithreadt multithread;
}
using namespace nglib;
-// Copyright (C) 2007-2016 CEA/DEN, EDF R&D, OPEN CASCADE
+// Copyright (C) 2007-2019 CEA/DEN, EDF R&D, OPEN CASCADE
//
// Copyright (C) 2003-2007 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
-// Copyright (C) 2007-2016 CEA/DEN, EDF R&D, OPEN CASCADE
+// Copyright (C) 2007-2019 CEA/DEN, EDF R&D, OPEN CASCADE
//
// Copyright (C) 2003-2007 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
-// Copyright (C) 2007-2016 CEA/DEN, EDF R&D, OPEN CASCADE
+// Copyright (C) 2007-2019 CEA/DEN, EDF R&D, OPEN CASCADE
//
// Copyright (C) 2003-2007 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
-// Copyright (C) 2007-2016 CEA/DEN, EDF R&D, OPEN CASCADE
+// Copyright (C) 2007-2019 CEA/DEN, EDF R&D, OPEN CASCADE
//
// Copyright (C) 2003-2007 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
#include "NETGENPlugin_Hypothesis_2D.hxx"
#include <SMDS_SetIterator.hxx>
+#include <SMESHDS_Group.hxx>
#include <SMESHDS_Mesh.hxx>
#include <SMESH_ControlsDef.hxx>
#include <SMESH_Gen.hxx>
#include <SMESH_MeshAlgos.hxx>
#include <SMESH_MesherHelper.hxx>
+#include <SMESH_Group.hxx>
+#include <SMESH_MeshEditor.hxx>
#include <SMESH_subMesh.hxx>
#include <Bnd_B3d.hxx>
namespace netgen {
-#if defined(NETGEN_V5) && defined(WIN32)
- DLL_HEADER
- #endif
- extern STLParameters stlparam;
+ NETGENPLUGIN_DLL_HEADER
+ extern STLParameters stlparam;
+
+ NETGENPLUGIN_DLL_HEADER
+ extern STLDoctorParams stldoctor;
}
namespace nglib
{
-#if defined(NETGEN_V5) && defined(WIN32)
- DLL_HEADER
-#endif
+ NETGENPLUGIN_DLL_HEADER
extern netgen::Array<netgen::Point<3> > readedges;
}
public:
HoleFiller( SMESH_Mesh& meshDS );
~HoleFiller();
- void AddHoleBorders( Ng_STL_Geometry * ngStlGeo );
+ void AddHoleBordersAndEdges( Ng_STL_Geometry * ngStlGeo, bool toAddEdges );
void KeepHole() { myHole.clear(); myCapElems.clear(); }
void ClearCapElements() { myCapElems.clear(); }
*/
//================================================================================
- void HoleFiller::AddHoleBorders( Ng_STL_Geometry * ngStlGeo )
+ void HoleFiller::AddHoleBordersAndEdges( Ng_STL_Geometry * ngStlGeo, bool toAddEdges )
{
nglib::readedges.SetSize(0);
myHole[i][iP-1].ChangeData(),
myHole[i][iP-0].ChangeData() );
}
+
+ if ( toAddEdges )
+ {
+ std::vector<const SMDS_MeshNode *> nodes(2);
+ std::vector<const SMDS_MeshElement *> faces(2);
+ SMDS_EdgeIteratorPtr eIt = myMeshDS->edgesIterator();
+ while ( eIt->more() )
+ {
+ const SMDS_MeshElement* edge = eIt->next();
+ nodes[0] = edge->GetNode(0);
+ nodes[1] = edge->GetNode(1);
+ // check that an edge is a face border
+ if ( myMeshDS->GetElementsByNodes( nodes, faces, SMDSAbs_Face ))
+ {
+ Ng_STL_AddEdge( ngStlGeo,
+ SMESH_NodeXYZ( nodes[0] ).ChangeData(),
+ SMESH_NodeXYZ( nodes[1] ).ChangeData() );
+ }
+ }
+ }
+ return;
}
//================================================================================
/*!
return;
} // ~HoleFiller()
+
+ //================================================================================
+ /*!
+ * \brief Fix nodes of a group
+ */
+ //================================================================================
+
+ void fixNodes( SMESHDS_GroupBase* group, netgen::STLGeometry* stlGeom )
+ {
+ SMESH_MeshAlgos::MarkElemNodes( group->GetElements(), false ); // un-mark nodes
+
+ for ( SMDS_ElemIteratorPtr eIt = group->GetElements(); eIt->more(); )
+ {
+ const SMDS_MeshElement* e = eIt->next();
+ for ( SMDS_NodeIteratorPtr nIt = e->nodeIterator(); nIt->more(); )
+ {
+ const SMDS_MeshNode* n = nIt->next();
+ if ( n->isMarked() )
+ continue;
+ n->setIsMarked( true );
+
+ SMESH_NodeXYZ p( n );
+ int id = stlGeom->GetPointNum( netgen::Point<3>( p.X(),p.Y(),p.Z() ));
+ if ( id > 0 )
+ stlGeom->SetLineEndPoint( id );
+ }
+ }
+ }
+
} // namespace
//=============================================================================
}
}
// add edges
- holeFiller.AddHoleBorders( ngStlGeo );
+ bool toAddExistingEdges = ( hyp && hyp->GetKeepExistingEdges() );
+ holeFiller.AddHoleBordersAndEdges( ngStlGeo, toAddExistingEdges );
// init stl DS
+ //netgen::stldoctor.geom_tol_fact = 1e-12; // pointtol=boundingbox.Diam()*stldoctor.geom_tol_fact
Ng_Result ng_res = Ng_STL_InitSTLGeometry( ngStlGeo );
if ( ng_res != NG_OK )
{
return error( COMPERR_BAD_INPUT_MESH, txt );
}
- Ng_Meshing_Parameters ngParams;
- ng_res = Ng_STL_MakeEdges( ngStlGeo, ngLib._ngMesh, &ngParams );
- if ( ng_res != NG_OK )
- return error( "Error in Edge Meshing" );
-
// set parameters
+ Ng_Meshing_Parameters ngParams;
if ( hyp )
{
ngParams.maxh = hyp->GetMaxSize();
ngParams.minh = hyp->GetMinSize();
ngParams.meshsize_filename = (char*) hyp->GetMeshSizeFile().c_str();
ngParams.quad_dominated = hyp->GetQuadAllowed();
- netgen::stlparam.yangle = hyp->GetRidgeAngle();
+
+ netgen::stlparam.yangle = hyp->GetRidgeAngle();
+ netgen::stlparam.edgecornerangle = hyp->GetEdgeCornerAngle();
+ netgen::stlparam.chartangle = hyp->GetChartAngle();
+ netgen::stlparam.outerchartangle = hyp->GetOuterChartAngle();
+ netgen::stlparam.resthchartdistfac = hyp->GetRestHChartDistFactor();
+ netgen::stlparam.resthchartdistenable = hyp->GetRestHChartDistEnable();
+ netgen::stlparam.resthlinelengthfac = hyp->GetRestHLineLengthFactor();
+ netgen::stlparam.resthlinelengthenable = hyp->GetRestHLineLengthEnable();
+ netgen::stlparam.resthcloseedgefac = hyp->GetRestHCloseEdgeFactor();
+ netgen::stlparam.resthcloseedgeenable = hyp->GetRestHCloseEdgeEnable();
+ netgen::stlparam.resthsurfcurvfac = hyp->GetRestHSurfCurvFactor();
+ netgen::stlparam.resthsurfcurvenable = hyp->GetRestHSurfCurvEnable();
+ netgen::stlparam.resthedgeanglefac = hyp->GetRestHEdgeAngleFactor();
+ netgen::stlparam.resthedgeangleenable = hyp->GetRestHEdgeAngleEnable();
+ netgen::stlparam.resthsurfmeshcurvfac = hyp->GetRestHSurfMeshCurvFactor();
+ netgen::stlparam.resthsurfmeshcurvenable = hyp->GetRestHSurfMeshCurvEnable();
+
mesher.SetParameters( hyp );
}
else
netgen::mparam.minh = netgen::mparam.maxh;
}
- // TODO: expose stlparam.resth* to the user
- // netgen::stlparam.resthcloseedgeenable = 0; // Restrict H due to close edges
- // netgen::stlparam.resthlinelengthenable = 0; // Restrict H due to line-length
- // netgen::stlparam.resthatlasenable = 0;
- // //netgen::stlparam.resthchartdistenable = 0;
+ // save netgen::mparam as Ng_STL_MakeEdges() modify it by Ng_Meshing_Parameters
+ netgen::MeshingParameters savedParams = netgen::mparam;
+
+ if ( SMESH_Group* fixedEdges = ( hyp ? hyp->GetFixedEdgeGroup( theMesh ) : 0 ))
+ {
+ netgen::STLGeometry* stlGeom = (netgen::STLGeometry*)ngStlGeo;
+
+ // the following code is taken from STLMeshing() method
+ stlGeom->Clear();
+ stlGeom->BuildEdges();
+ stlGeom->MakeAtlas( *ngMesh );
+ stlGeom->CalcFaceNums();
+ stlGeom->AddFaceEdges();
+ fixNodes( fixedEdges->GetGroupDS(), stlGeom );
+ stlGeom->LinkEdges();
+
+ ngMesh->ClearFaceDescriptors();
+ for (int i = 1; i <= stlGeom->GetNOFaces(); i++)
+ ngMesh->AddFaceDescriptor (netgen::FaceDescriptor (i, 1, 0, 0));
+
+ stlGeom->edgesfound = 1;
+ }
+ else
+ {
+ Ng_STL_MakeEdges( ngStlGeo, ngLib._ngMesh, &ngParams );
+ }
+
+ netgen::mparam = savedParams;
double h = netgen::mparam.maxh;
ngMesh->SetGlobalH( h );
netgen::OCCGeometry occgeo;
mesher.SetLocalSize( occgeo, *ngMesh );
+ // const char* optStr = "SmSmSm";//"smsmsmSmSmSm";
+ // netgen::mparam.optimize2d = optStr;
+
// meshing
try
{
catch (netgen::NgException & ex)
{
if ( netgen::multithread.terminate )
- return false;
+ if ( !hyp || !hyp->GetLoadMeshOnCancel() )
+ return false;
}
if ( ng_res != NG_OK )
return error( "Error in Surface Meshing" );
meshDS->AddEdge( nodes[0], nodes[1] );
}
+ // find existing groups
+ const char* theNamePrefix = "Surface_";
+ const int theNamePrefixLen = strlen( theNamePrefix );
+ std::vector< SMESHDS_Group* > groups;
+ if ( hyp && hyp->GetMakeGroupsOfSurfaces() )
+ {
+ SMESH_Mesh::GroupIteratorPtr grIt = theMesh.GetGroups();
+ while ( grIt->more() )
+ {
+ SMESH_Group* group = grIt->next();
+ SMESHDS_Group* groupDS;
+ if (( group->GetGroupDS()->GetType() == SMDSAbs_Face ) &&
+ ( strncmp( group->GetName(), theNamePrefix, theNamePrefixLen ) == 0 ) &&
+ ( groupDS = dynamic_cast<SMESHDS_Group*>( group->GetGroupDS() )))
+ groups.push_back( groupDS );
+ }
+ }
+
// add faces
for ( int i = 1; i <= nbF; ++i )
{
else
break;
}
+ const SMDS_MeshElement* newFace = 0;
switch( nodes.size() )
{
- case 3: meshDS->AddFace( nodes[0], nodes[1], nodes[2] ); break;
- case 4: meshDS->AddFace( nodes[0], nodes[1], nodes[2], nodes[3] ); break;
+ case 3: newFace = meshDS->AddFace( nodes[0], nodes[1], nodes[2] ); break;
+ case 4: newFace = meshDS->AddFace( nodes[0], nodes[1], nodes[2], nodes[3] ); break;
+ }
+
+ // add newFace to a group
+ if ( newFace && hyp && hyp->GetMakeGroupsOfSurfaces() )
+ {
+ if ((size_t) elem.GetIndex()-1 >= groups.size() )
+ groups.resize( elem.GetIndex(), 0 );
+
+ SMESHDS_Group* & group = groups[ elem.GetIndex()-1 ];
+ if ( !group )
+ {
+ SMESH_Group* gr = theMesh.AddGroup( SMDSAbs_Face, "");
+ group = static_cast<SMESHDS_Group*>( gr->GetGroupDS() );
+ }
+ group->SMDSGroup().Add( newFace );
+ }
+ }
+
+ // update groups
+ int groupIndex = 1;
+ for ( size_t i = 0; i < groups.size(); ++i )
+ {
+ if ( !groups[i] )
+ continue;
+ if ( groups[i]->IsEmpty() )
+ {
+ theMesh.RemoveGroup( groups[i]->GetID() );
+ }
+ else if ( SMESH_Group* g = theMesh.GetGroup( groups[i]->GetID() ))
+ {
+ g->SetName( SMESH_Comment( theNamePrefix ) << groupIndex++ );
}
}
-// Copyright (C) 2007-2016 CEA/DEN, EDF R&D, OPEN CASCADE
+// Copyright (C) 2007-2019 CEA/DEN, EDF R&D, OPEN CASCADE
//
// Copyright (C) 2003-2007 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
-// Copyright (C) 2007-2016 CEA/DEN, EDF R&D, OPEN CASCADE
+// Copyright (C) 2007-2019 CEA/DEN, EDF R&D, OPEN CASCADE
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
-// Copyright (C) 2007-2016 CEA/DEN, EDF R&D, OPEN CASCADE
+// Copyright (C) 2007-2019 CEA/DEN, EDF R&D, OPEN CASCADE
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
-// Copyright (C) 2007-2016 CEA/DEN, EDF R&D, OPEN CASCADE
+// Copyright (C) 2007-2019 CEA/DEN, EDF R&D, OPEN CASCADE
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
-// Copyright (C) 2007-2016 CEA/DEN, EDF R&D, OPEN CASCADE
+// Copyright (C) 2007-2019 CEA/DEN, EDF R&D, OPEN CASCADE
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
-// Copyright (C) 2007-2016 CEA/DEN, EDF R&D, OPEN CASCADE
+// Copyright (C) 2007-2019 CEA/DEN, EDF R&D, OPEN CASCADE
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
-// Copyright (C) 2007-2016 CEA/DEN, EDF R&D, OPEN CASCADE
+// Copyright (C) 2007-2019 CEA/DEN, EDF R&D, OPEN CASCADE
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
-// Copyright (C) 2007-2016 CEA/DEN, EDF R&D, OPEN CASCADE
+// Copyright (C) 2007-2019 CEA/DEN, EDF R&D, OPEN CASCADE
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
-// Copyright (C) 2007-2016 CEA/DEN, EDF R&D, OPEN CASCADE
+// Copyright (C) 2007-2019 CEA/DEN, EDF R&D, OPEN CASCADE
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
-// Copyright (C) 2007-2016 CEA/DEN, EDF R&D, OPEN CASCADE
+// Copyright (C) 2007-2019 CEA/DEN, EDF R&D, OPEN CASCADE
//
// Copyright (C) 2003-2007 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
-# Copyright (C) 2007-2016 CEA/DEN, EDF R&D, OPEN CASCADE
+# Copyright (C) 2007-2019 CEA/DEN, EDF R&D, OPEN CASCADE
#
# This library is free software; you can redistribute it and/or
# modify it under the terms of the GNU Lesser General Public