From: eap Date: Tue, 1 Oct 2019 11:04:51 +0000 (+0300) Subject: #17784 [EDF] MESH-GEMS-2.9.6 Meshers options X-Git-Tag: V9_4_0a2~3 X-Git-Url: http://git.salome-platform.org/gitweb/?a=commitdiff_plain;h=cc141b72a0231b7db946b0d0ad931495bab97502;p=plugins%2Fblsurfplugin.git #17784 [EDF] MESH-GEMS-2.9.6 Meshers options Add all options available by MG-2.9.6 version. --- diff --git a/doc/salome/gui/BLSURFPLUGIN/images/blsurf_parameters.png b/doc/salome/gui/BLSURFPLUGIN/images/blsurf_parameters.png index 884b411..5f67d49 100644 Binary files a/doc/salome/gui/BLSURFPLUGIN/images/blsurf_parameters.png and b/doc/salome/gui/BLSURFPLUGIN/images/blsurf_parameters.png differ diff --git a/doc/salome/gui/BLSURFPLUGIN/images/blsurf_parameters_advanced.png b/doc/salome/gui/BLSURFPLUGIN/images/blsurf_parameters_advanced.png index 9c96679..ca56968 100644 Binary files a/doc/salome/gui/BLSURFPLUGIN/images/blsurf_parameters_advanced.png and b/doc/salome/gui/BLSURFPLUGIN/images/blsurf_parameters_advanced.png differ diff --git a/doc/salome/gui/BLSURFPLUGIN/input/blsurf_hypo.doc b/doc/salome/gui/BLSURFPLUGIN/input/blsurf_hypo.doc index 228022b..1b1c1d5 100644 --- a/doc/salome/gui/BLSURFPLUGIN/input/blsurf_hypo.doc +++ b/doc/salome/gui/BLSURFPLUGIN/input/blsurf_hypo.doc @@ -65,6 +65,20 @@ The smaller this distance is, the closer the mesh is to the exact surface (only - Quadrangles: generate a mesh with only quadrangles. +- Surface proximity - activates surface proximity based refinement. + + - Number of layers - number of surface element layers to be generated. + + - Ratio - a multiplicative coefficient which will be used to scale the size computed by +the surface proximity detection. + +- Volume proximity - activates volume proximity based refinement. + + - Number of layers - number of surface element layers to be generated. + + - Ratio - a multiplicative coefficient which will be used to scale the size computed by +the volume proximity detection. + - Anisotropic - if checked, this parameter defines the maximum anisotropic ratio of the metric governing the anisotropic meshing process. The default value (0) means that the metric (and thus the generated elements) can be arbitrarily stretched. @@ -102,6 +116,8 @@ The notion of diag used in the descriptions means the diagonal of the bou - \b Meshing options + - Independent patches - This parameter can be used to activate the more complete patch independent meshing, by generating the mesh on global user-defined hyperpatches. + - Enforce CAD edge sizes - Relaxes the given sizemap constraint around CAD edges to allow a better element quality and a better geometric approximation. It is only useful in combination with the gradation option. @@ -141,6 +157,12 @@ local size on a vertex situated on a border curve. \n All options are unchecked by default. No cleanup is made by default so that the mesh matches the shape. If the user has a bad shape (e.g. imported shape), he can activate some options to improve the mesh. + - Compute ridges - If this option is deactivated, + MeshGems-CADSurf will not try to preserve lines defined by a sharp + angle in the input discrete geometry. Only input ridges, free edges, + non manifold edges and separation betwen zones with different + attributes will be respected (if tags is set to respect). + - Closed geometry - describes whether the working geometry should be closed or not. When activated, this option helps PreCAD to process the dirtiest geometries. diff --git a/idl/BLSURFPlugin_Algorithm.idl b/idl/BLSURFPlugin_Algorithm.idl index 27b80df..07af2be 100644 --- a/idl/BLSURFPlugin_Algorithm.idl +++ b/idl/BLSURFPlugin_Algorithm.idl @@ -138,7 +138,7 @@ module BLSURFPlugin { /*! - * Sets a way to define size of mesh elements to generate + *Set a way to define size of mesh elements to generate * 0 - size is defined automatically * 1 - size is set by SetPhySize() method * 2 - size is set by SetPhySize() method. A sizemap is defined. @@ -147,7 +147,7 @@ module BLSURFPlugin long GetPhysicalMesh(); /*! - * Sets a way to define maximum angular deflection of mesh from CAD model + *Set a way to define maximum angular deflection of mesh from CAD model * 0 - deflection is defined automatically * 1 - deflection is set by SetAngleMesh() method * 2 - deflection is set by SetAngleMesh() method. A sizemap is defined (TODO). @@ -156,7 +156,7 @@ module BLSURFPlugin long GetGeometricMesh(); /*! - * Sets size of mesh elements to generate + *Set size of mesh elements to generate */ void SetPhySize(in double size); void SetPhySizeRel(in double size); @@ -164,7 +164,7 @@ module BLSURFPlugin boolean IsPhySizeRel(); /*! - * Sets lower boundary of mesh element size + *Set lower boundary of mesh element size */ void SetMinSize(in double theMinSize); void SetMinSizeRel(in double theMinSize); @@ -172,7 +172,7 @@ module BLSURFPlugin boolean IsMinSizeRel(); /*! - * Sets upper boundary of mesh element size + *Set upper boundary of mesh element size */ void SetMaxSize(in double theMaxSize); void SetMaxSizeRel(in double theMaxSize); @@ -180,7 +180,7 @@ module BLSURFPlugin boolean IsMaxSizeRel(); /*! - * Sets maximal allowed ratio between the lengths of two adjacent edges + *Set maximal allowed ratio between the lengths of two adjacent edges */ void SetUseGradation(in boolean toUse); boolean GetUseGradation(); @@ -188,7 +188,7 @@ module BLSURFPlugin double GetGradation(); /*! - * Sets maximal allowed ratio between the lengths of two adjacent edges in 3D mesh + *Set maximal allowed ratio between the lengths of two adjacent edges in 3D mesh */ void SetUseVolumeGradation(in boolean toUse); boolean GetUseVolumeGradation(); @@ -196,20 +196,20 @@ module BLSURFPlugin double GetVolumeGradation(); /*! - * Sets to create quadrilateral elements or not + *Set to create quadrilateral elements or not */ void SetQuadAllowed(in boolean allowed); void SetElementType(in long elementType); long GetElementType(); /*! - * Sets angular deflection (in degrees) of a mesh face and edge from CAD surface + *Set angular deflection (in degrees) of a mesh face and edge from CAD surface */ void SetAngleMesh(in double angle); double GetAngleMesh(); /*! - * Sets the maximum desired distance between a triangle and its supporting CAD surface + *Set the maximum desired distance between a triangle and its supporting CAD surface */ void SetChordalError(in double distance); double GetChordalError(); @@ -274,7 +274,7 @@ module BLSURFPlugin double GetCorrectSurfaceIntersectionMaxCost(); /*! - * This patch independent correction option can be activated to remove the bad + * This patch independent correction option can be activated to remove the bad * elements (often called slivers) from the generated mesh, without taking into account * the tags (attributes) specification. */ @@ -283,7 +283,7 @@ module BLSURFPlugin /*! * This parameter defines the aspect ratio triggering the "bad element" - * classification for the force bad surface element removal option. + * classification for the force bad surface element removal option. */ void SetBadElementAspectRatio(in double ratio); double GetBadElementAspectRatio(); @@ -303,7 +303,7 @@ module BLSURFPlugin boolean GetQuadraticMesh(); /*! - * Sets topology usage way defining how mesh conformity is assured + *Set topology usage way defining how mesh conformity is assured * value=0 - mesh conformity is assured by conformity of a shape * value=1,2 - mesh conformity is assured by pre-processing a CAD model (OBSOLETE) * value=3 - mesh conformity is assured by pre-processing a CAD model with Pre-CAD @@ -311,8 +311,45 @@ module BLSURFPlugin void SetTopology(in long way); long GetTopology(); + + /*! + * Activate/deactivate surface proximity computation + */ + void SetUseSurfaceProximity( in boolean toUse ); + boolean GetUseSurfaceProximity(); + + /*! + * Set number of surface element layers to be generated due to surface proximity + */ + void SetNbSurfaceProximityLayers( in short nbLayers ); + short GetNbSurfaceProximityLayers(); + + /*! + * Set coefficient by which size of element refined due to surface proximity is increased + */ + void SetSurfaceProximityRatio( in double ratio ); + double GetSurfaceProximityRatio(); + + /*! + * Activate/deactivate volume proximity computation + */ + void SetUseVolumeProximity( in boolean toUse ); + boolean GetUseVolumeProximity(); + + /*! + * Set number of surface element layers to be generated due to volume proximity + */ + void SetNbVolumeProximityLayers( in short nbLayers ); + short GetNbVolumeProximityLayers(); + + /*! + * Set coefficient by which size of element refined due to volume proximity is increased + */ + void SetVolumeProximityRatio( in double ratio ); + double GetVolumeProximityRatio(); + /*! - * Sets verbosity level in the range 0 to 100. + *Set verbosity level in the range 0 to 100. */ void SetVerbosity(in short theVal) raises (SALOME::SALOME_Exception); short GetVerbosity(); @@ -485,7 +522,7 @@ module BLSURFPlugin boolean GetPreCADDiscardInput(); /*! - * Sets advanced option value + *Set advanced option value */ void SetOptionValue(in string optionName, in string optionValue) raises (SALOME::SALOME_Exception); @@ -672,7 +709,7 @@ module BLSURFPlugin /////////////////////// /*! - * Sets the file for export resulting mesh in GMF format + *Set the file for export resulting mesh in GMF format */ void SetGMFFile(in string theFileName); string GetGMFFile(); diff --git a/src/BLSURFPlugin/BLSURFPluginBuilder.py b/src/BLSURFPlugin/BLSURFPluginBuilder.py index df59b33..d934e55 100644 --- a/src/BLSURFPlugin/BLSURFPluginBuilder.py +++ b/src/BLSURFPlugin/BLSURFPluginBuilder.py @@ -198,6 +198,49 @@ class BLSURF_Algorithm(Mesh_Algorithm): self.Parameters().SetTopology(way) pass + ## Activate/deactivate surface proximity computation + # @param toUse boolean flag + # + def SetSurfaceProximity(self, toUse ): + self.Parameters().SetUseSurfaceProximity(toUse) + return + + ## Set number of surface element layers to be generated due to surface proximity + # @param nbLayers number of layers + # + def SetNbSurfaceProximityLayers(self, nbLayers ): + self.Parameters().SetNbSurfaceProximityLayers( nbLayers ) + return + + ## Set coefficient by which size of element refined due to surface proximity is increased + # @param ratio proximity coefficient + # + def SetSurfaceProximityRatio(self, ratio ): + self.Parameters().SetSurfaceProximityRatio(ratio) + return + + ## Activate/deactivate volume proximity computation + # @param toUse boolean flag + # + def SetVolumeProximity(self, toUse ): + self.Parameters().SetUseVolumeProximity(toUse) + return + + ## Set number of surface element layers to be generated due to volume proximity + # @param nbLayers number of layers + # + def SetNbVolumeProximityLayers(self, nbLayers ): + self.Parameters().SetNbVolumeProximityLayers(nbLayers) + return + + ## Set coefficient by which size of element refined due to volume proximity is increased + # @param ratio proximity coefficient + # + def SetVolumeProximityRatio(self, ratio ): + self.Parameters().SetVolumeProximityRatio(ratio) + return + + ## Sets verbosity level in the range 0 to 100. # @param level verbosity level def SetVerbosity(self, level): @@ -333,6 +376,28 @@ class BLSURF_Algorithm(Mesh_Algorithm): def SetTags( self, howToTreat ): self.Parameters().SetTags( howToTreat ) + ## Activate/deactivate fully patch independent meshing + # @param isIndependent boolean flag + # + # This feature can only be used if the @a tags parameter is set to "respect". + # By default this option deactivated. + # + def SetPatchIndependent( self, isIndependent ): + self.SetOptionValue( "allow_patch_independent", "yes" if isIndependent else "no" ) + + ## Set to preserve lines defined by a sharp angle in the input discrete geometry + # @param toCompute boolean flag + # + # If this option is deactivated, MeshGems-CADSurf will not try to preserve lines + # defined by a sharp angle in the input discrete geometry. Only input ridges, free + # edges, non manifold edges and separation betwen zones with different attributes + # will be respected (if tags is set to respect). + # By default this option activated. + # + def SetComputeRidges( self, toCompute ): + self.SetOptionValue( "compute_ridges", "yes" if toCompute else "no" ) + + ## Activate removal of the tiny edges from the generated # mesh when it improves the local mesh quality, without taking into account the # tags (attributes) specifications. diff --git a/src/BLSURFPlugin/BLSURFPlugin_BLSURF.cxx b/src/BLSURFPlugin/BLSURFPlugin_BLSURF.cxx index 9ee847f..828b139 100644 --- a/src/BLSURFPlugin/BLSURFPlugin_BLSURF.cxx +++ b/src/BLSURFPlugin/BLSURFPlugin_BLSURF.cxx @@ -879,6 +879,12 @@ void BLSURFPlugin_BLSURF::SetParameters(const BLSURFPlugin_Hypothesis* hyp, bool _quadraticMesh = BLSURFPlugin_Hypothesis::GetDefaultQuadraticMesh(); int _verb = BLSURFPlugin_Hypothesis::GetDefaultVerbosity(); //int _topology = BLSURFPlugin_Hypothesis::GetDefaultTopology(); + bool _useSurfaceProximity = BLSURFPlugin_Hypothesis::GetDefaultUseSurfaceProximity (); + int _nbSurfaceProximityLayers = BLSURFPlugin_Hypothesis::GetDefaultNbSurfaceProximityLayers(); + double _surfaceProximityRatio = BLSURFPlugin_Hypothesis::GetDefaultSurfaceProximityRatio (); + bool _useVolumeProximity = BLSURFPlugin_Hypothesis::GetDefaultUseVolumeProximity (); + int _nbVolumeProximityLayers = BLSURFPlugin_Hypothesis::GetDefaultNbVolumeProximityLayers (); + double _volumeProximityRatio = BLSURFPlugin_Hypothesis::GetDefaultVolumeProximityRatio (); // PreCAD //int _precadMergeEdges = BLSURFPlugin_Hypothesis::GetDefaultPreCADMergeEdges(); @@ -941,6 +947,13 @@ void BLSURFPlugin_BLSURF::SetParameters(const BLSURFPlugin_Hypothesis* hyp, //_precadRemoveDuplicateCADFaces = hyp->GetPreCADRemoveDuplicateCADFaces(); //_precadProcess3DTopology = hyp->GetPreCADProcess3DTopology(); //_precadDiscardInput = hyp->GetPreCADDiscardInput(); + _useSurfaceProximity = hyp->GetUseSurfaceProximity (); + _nbSurfaceProximityLayers = hyp->GetNbSurfaceProximityLayers(); + _surfaceProximityRatio = hyp->GetSurfaceProximityRatio (); + _useVolumeProximity = hyp->GetUseVolumeProximity (); + _nbVolumeProximityLayers = hyp->GetNbVolumeProximityLayers (); + _volumeProximityRatio = hyp->GetVolumeProximityRatio (); + const BLSURFPlugin_Hypothesis::TOptionValues& opts = hyp->GetOptionValues(); BLSURFPlugin_Hypothesis::TOptionValues::const_iterator opIt; @@ -1086,6 +1099,19 @@ void BLSURFPlugin_BLSURF::SetParameters(const BLSURFPlugin_Hypothesis* hyp, set_param(css, "element_order", _quadraticMesh ? "quadratic" : "linear"); set_param(css, "verbose", val_to_string(_verb).c_str()); + set_param(css, "use_surface_proximity", _useSurfaceProximity ? "yes" : "no" ); + if ( _useSurfaceProximity ) + { + set_param(css, "surface_proximity_layers", SMESH_Comment( _nbSurfaceProximityLayers )); + set_param(css, "surface_proximity_ratio", SMESH_Comment( _surfaceProximityRatio )); + } + set_param(css, "use_volume_proximity", _useVolumeProximity ? "yes" : "no" ); + if ( _useVolumeProximity ) + { + set_param(css, "volume_proximity_layers", SMESH_Comment( _nbVolumeProximityLayers )); + set_param(css, "volume_proximity_ratio", SMESH_Comment( _volumeProximityRatio )); + } + _smp_phy_size = _phySizeRel ? _phySize*diagonal : _phySize; if ( _verb > 0 ) std::cout << "_smp_phy_size = " << _smp_phy_size << std::endl; diff --git a/src/BLSURFPlugin/BLSURFPlugin_Hypothesis.cxx b/src/BLSURFPlugin/BLSURFPlugin_Hypothesis.cxx index f57f5ab..50ff614 100644 --- a/src/BLSURFPlugin/BLSURFPlugin_Hypothesis.cxx +++ b/src/BLSURFPlugin/BLSURFPlugin_Hypothesis.cxx @@ -50,7 +50,7 @@ namespace //============================================================================= BLSURFPlugin_Hypothesis::BLSURFPlugin_Hypothesis(int hypId, SMESH_Gen * gen, bool hasgeom) : - SMESH_Hypothesis(hypId, gen), + SMESH_Hypothesis(hypId, gen), _physicalMesh(GetDefaultPhysicalMesh()), _geometricMesh(GetDefaultGeometricMesh()), _phySize(GetDefaultPhySize()), @@ -65,7 +65,7 @@ BLSURFPlugin_Hypothesis::BLSURFPlugin_Hypothesis(int hypId, SMESH_Gen * gen, boo _volumeGradation(GetDefaultVolumeGradation()), _elementType(GetDefaultElementType()), _angleMesh(GetDefaultAngleMesh()), - _chordalError(GetDefaultChordalError()), + _chordalError(GetDefaultChordalError()), _anisotropic(GetDefaultAnisotropic()), _anisotropicRatio(GetDefaultAnisotropicRatio()), _removeTinyEdges(GetDefaultRemoveTinyEdges()), @@ -80,6 +80,12 @@ BLSURFPlugin_Hypothesis::BLSURFPlugin_Hypothesis(int hypId, SMESH_Gen * gen, boo _quadraticMesh(GetDefaultQuadraticMesh()), _verb(GetDefaultVerbosity()), _topology(GetDefaultTopology()), + _useSurfaceProximity(GetDefaultUseSurfaceProximity()), + _nbSurfaceProximityLayers(GetDefaultNbSurfaceProximityLayers()), + _surfaceProximityRatio(GetDefaultSurfaceProximityRatio()), + _useVolumeProximity(GetDefaultUseVolumeProximity()), + _nbVolumeProximityLayers(GetDefaultNbVolumeProximityLayers()), + _volumeProximityRatio(GetDefaultVolumeProximityRatio()), _preCADMergeEdges(GetDefaultPreCADMergeEdges()), _preCADRemoveDuplicateCADFaces(GetDefaultPreCADRemoveDuplicateCADFaces()), _preCADProcess3DTopology(GetDefaultPreCADProcess3DTopology()), @@ -101,8 +107,6 @@ BLSURFPlugin_Hypothesis::BLSURFPlugin_Hypothesis(int hypId, SMESH_Gen * gen, boo { _name = GetHypType(hasgeom); _param_algo_dim = 2; - -// _GMFFileMode = false; // GMF ascii mode // Advanced options with their defaults according to MG User Manual @@ -115,8 +119,10 @@ BLSURFPlugin_Hypothesis::BLSURFPlugin_Hypothesis(int hypId, SMESH_Gen * gen, boo // "optimise_tiny_edges", // default = 0 // "remove_duplicate_cad_faces", // default = 1 "tiny_edge_avoid_surface_intersections", // default = 1 - "debug", // default = 0 - "use_deprecated_patch_mesher", // default 0 + "debug", // default = 0 + "allow_patch_independent", // false + + //"use_deprecated_patch_mesher", // default 0 // "tiny_edge_respect_geometry", // default = 0 "" // mark of end }; @@ -147,6 +153,7 @@ BLSURFPlugin_Hypothesis::BLSURFPlugin_Hypothesis(int hypId, SMESH_Gen * gen, boo // remove_tiny_uv_edges option is not documented // but it is useful that the user can change it to disable all preprocessing options "remove_tiny_uv_edges", // default = 1 + "compute_ridges", // true "" // mark of end }; const char* preCADintOptionNames[] = { // "manifold_geometry", // default = 0 @@ -210,11 +217,11 @@ BLSURFPlugin_Hypothesis::BLSURFPlugin_Hypothesis(int hypId, SMESH_Gen * gen, boo _defaultOptionValues["max_number_of_points_per_patch" ] = "0"; _defaultOptionValues["max_number_of_threads" ] = "4"; _defaultOptionValues["rectify_jacobian" ] = "yes"; - _defaultOptionValues["use_deprecated_patch_mesher" ] = "yes"; _defaultOptionValues["respect_geometry" ] = "yes"; _defaultOptionValues["tiny_edge_avoid_surface_intersections" ] = "yes"; - _defaultOptionValues["use_deprecated_patch_mesher" ] = "no"; + //_defaultOptionValues["use_deprecated_patch_mesher" ] = "no"; _defaultOptionValues["debug" ] = "no"; + _defaultOptionValues["allow_patch_independent" ] = "no"; if ( hasgeom ) { _defaultOptionValues["closed_geometry" ] = "no"; @@ -227,6 +234,7 @@ BLSURFPlugin_Hypothesis::BLSURFPlugin_Hypothesis(int hypId, SMESH_Gen * gen, boo _defaultOptionValues["required_entities" ] = "respect"; _defaultOptionValues["sewing_tolerance" ] = "5e-4*D"; _defaultOptionValues["tags" ] = "respect"; + _defaultOptionValues["compute_ridges" ] = "yes"; } #ifdef _DEBUG_ @@ -237,20 +245,6 @@ BLSURFPlugin_Hypothesis::BLSURFPlugin_Hypothesis(int hypId, SMESH_Gen * gen, boo ASSERT( _option2value.size() + _preCADoption2value.size() == _defaultOptionValues.size() ); #endif - _sizeMap.clear(); - _attractors.clear(); - _faceEntryEnfVertexListMap.clear(); - _enfVertexList.clear(); - _faceEntryCoordsListMap.clear(); - _coordsEnfVertexMap.clear(); - _faceEntryEnfVertexEntryListMap.clear(); - _enfVertexEntryEnfVertexMap.clear(); - _groupNameNodeIDMap.clear(); - - /* TODO GROUPS - _groupNameEnfVertexListMap.clear(); - _enfVertexGroupNameMap.clear(); - */ } TopoDS_Shape BLSURFPlugin_Hypothesis::entryToShape(std::string entry) @@ -485,6 +479,66 @@ void BLSURFPlugin_Hypothesis::SetTopology(Topology theTopology) { } } +//============================================================================= +void BLSURFPlugin_Hypothesis::SetUseSurfaceProximity( bool toUse ) +{ + if ( _useSurfaceProximity != toUse ) + { + _useSurfaceProximity = toUse; + NotifySubMeshesHypothesisModification(); + } +} + +//============================================================================= +void BLSURFPlugin_Hypothesis::SetNbSurfaceProximityLayers( int nbLayers ) +{ + if ( _nbSurfaceProximityLayers != nbLayers ) + { + _nbSurfaceProximityLayers = nbLayers; + NotifySubMeshesHypothesisModification(); + } +} + +//============================================================================= +void BLSURFPlugin_Hypothesis::SetSurfaceProximityRatio( double ratio ) +{ + if ( _surfaceProximityRatio != ratio ) + { + _surfaceProximityRatio = ratio; + NotifySubMeshesHypothesisModification(); + } +} + +//============================================================================= +void BLSURFPlugin_Hypothesis::SetUseVolumeProximity( bool toUse ) +{ + if ( _useVolumeProximity != toUse ) + { + _useVolumeProximity = toUse; + NotifySubMeshesHypothesisModification(); + } +} + +//============================================================================= +void BLSURFPlugin_Hypothesis::SetNbVolumeProximityLayers( int nbLayers ) +{ + if ( _nbVolumeProximityLayers != nbLayers ) + { + _nbVolumeProximityLayers = nbLayers; + NotifySubMeshesHypothesisModification(); + } +} + +//============================================================================= +void BLSURFPlugin_Hypothesis::SetVolumeProximityRatio( double ratio ) +{ + if ( _volumeProximityRatio != ratio ) + { + _volumeProximityRatio = ratio; + NotifySubMeshesHypothesisModification(); + } +} + //============================================================================= void BLSURFPlugin_Hypothesis::SetVerbosity(int theVal) { if (theVal != _verb) { @@ -541,16 +595,16 @@ bool BLSURFPlugin_Hypothesis::GetJacobianRectification() void BLSURFPlugin_Hypothesis::SetUseDeprecatedPatchMesher( bool useDeprecatedPatchMesher ) { - if ( GetUseDeprecatedPatchMesher() != useDeprecatedPatchMesher ) - { - SetOptionValue( "use_deprecated_patch_mesher", useDeprecatedPatchMesher ? "yes" : "no" ); - NotifySubMeshesHypothesisModification(); - } + // if ( GetUseDeprecatedPatchMesher() != useDeprecatedPatchMesher ) + // { + // SetOptionValue( "use_deprecated_patch_mesher", useDeprecatedPatchMesher ? "yes" : "no" ); + // NotifySubMeshesHypothesisModification(); + // } } //============================================================================= bool BLSURFPlugin_Hypothesis::GetUseDeprecatedPatchMesher() { - return ToBool( GetOptionValue("use_deprecated_patch_mesher", GET_DEFAULT())); + return false;//ToBool( GetOptionValue("use_deprecated_patch_mesher", GET_DEFAULT())); } //============================================================================= @@ -2097,6 +2151,14 @@ std::ostream & BLSURFPlugin_Hypothesis::SaveTo(std::ostream & save) save << *tag << " "; } + // New options in 2.9.6 (issue #17784) + save << " " << _useSurfaceProximity; + save << " " << _nbSurfaceProximityLayers; + save << " " << _surfaceProximityRatio; + save << " " << _useVolumeProximity; + save << " " << _nbVolumeProximityLayers; + save << " " << _volumeProximityRatio; + return save; } @@ -3110,6 +3172,16 @@ std::istream & BLSURFPlugin_Hypothesis::LoadFrom(std::istream & load) } } + // New options in 2.9.6 (issue #17784) + if ( static_cast( load >> _useSurfaceProximity )); + { + load >> _nbSurfaceProximityLayers; + load >> _surfaceProximityRatio; + load >> _useVolumeProximity; + load >> _nbVolumeProximityLayers; + isOK = static_cast( load >> _volumeProximityRatio ); + } + return load; } diff --git a/src/BLSURFPlugin/BLSURFPlugin_Hypothesis.hxx b/src/BLSURFPlugin/BLSURFPlugin_Hypothesis.hxx index 08ac943..fcff08a 100644 --- a/src/BLSURFPlugin/BLSURFPlugin_Hypothesis.hxx +++ b/src/BLSURFPlugin/BLSURFPlugin_Hypothesis.hxx @@ -151,9 +151,27 @@ public: void SetTopology(Topology theTopology); Topology GetTopology() const { return _topology; } + bool GetUseSurfaceProximity() const { return _useSurfaceProximity; } + void SetUseSurfaceProximity( bool toUse ); + + int GetNbSurfaceProximityLayers() const { return _nbSurfaceProximityLayers; } + void SetNbSurfaceProximityLayers( int nbLayers ); + + double GetSurfaceProximityRatio() const { return _surfaceProximityRatio; } + void SetSurfaceProximityRatio( double ratio ); + + bool GetUseVolumeProximity() const { return _useVolumeProximity; } + void SetUseVolumeProximity( bool toUse ); + + int GetNbVolumeProximityLayers() const { return _nbVolumeProximityLayers; } + void SetNbVolumeProximityLayers( int nbLayers ); + + double GetVolumeProximityRatio() const { return _volumeProximityRatio; } + void SetVolumeProximityRatio( double ratio ); + void SetVerbosity(int theVal); int GetVerbosity() const { return _verb; } - + void ClearEntry(const std::string& entry, const char * attEntry = 0); void ClearSizeMaps(); @@ -162,7 +180,7 @@ public: void SetJacobianRectificationRespectGeometry( bool allowRectification ); bool GetJacobianRectificationRespectGeometry(); - + void SetUseDeprecatedPatchMesher( bool useDeprecatedPatchMesher ); bool GetUseDeprecatedPatchMesher(); @@ -434,7 +452,13 @@ public: static double GetDefaultVolumeGradation() { return 2; } static ElementType GetDefaultElementType() { return Triangles; } static double GetDefaultAngleMesh() { return 8.0; } - + static bool GetDefaultUseSurfaceProximity() { return false; } + static int GetDefaultNbSurfaceProximityLayers() { return 1; } + static double GetDefaultSurfaceProximityRatio() { return 1.; } + static bool GetDefaultUseVolumeProximity() { return false; } + static int GetDefaultNbVolumeProximityLayers() { return 1; } + static double GetDefaultVolumeProximityRatio() { return 1.; } + static double GetDefaultChordalError(double diagonal); static double GetDefaultChordalError() { return undefinedDouble(); } static bool GetDefaultAnisotropic() { return false; } @@ -448,10 +472,10 @@ public: static bool GetDefaultCorrectSurfaceIntersection() { return true; } static double GetDefaultCorrectSurfaceIntersectionMaxCost() { return 15.; } static bool GetDefaultBadElementRemoval() { return false; } - static double GetDefaultBadElementAspectRatio() {return 1000.0; } + static double GetDefaultBadElementAspectRatio() {return 1000.0; } static bool GetDefaultOptimizeMesh() { return true; } static bool GetDefaultQuadraticMesh() { return false; } - + static int GetDefaultVerbosity() { return 3; } static Topology GetDefaultTopology() { return FromCAD; } // PreCAD @@ -459,7 +483,7 @@ public: static bool GetDefaultPreCADRemoveDuplicateCADFaces() { return false; } static bool GetDefaultPreCADProcess3DTopology() { return false; } static bool GetDefaultPreCADDiscardInput() { return false; } - + static TSizeMap GetDefaultSizeMap() { return TSizeMap();} static TAttractorMap GetDefaultAttractorMap() { return TAttractorMap(); } @@ -591,13 +615,19 @@ private: bool _quadraticMesh; int _verb; Topology _topology; - + bool _useSurfaceProximity; + int _nbSurfaceProximityLayers; + double _surfaceProximityRatio; + bool _useVolumeProximity; + int _nbVolumeProximityLayers; + double _volumeProximityRatio; + bool _preCADMergeEdges; bool _preCADRemoveDuplicateCADFaces; bool _preCADProcess3DTopology; bool _preCADDiscardInput; double _preCADEpsNano; - + TOptionValues _option2value, _preCADoption2value, _customOption2value; // user defined values TOptionValues _defaultOptionValues; // default values TOptionNames _doubleOptions, _charOptions, _boolOptions; // to find a type of option diff --git a/src/BLSURFPlugin/BLSURFPlugin_Hypothesis_i.cxx b/src/BLSURFPlugin/BLSURFPlugin_Hypothesis_i.cxx index dfeaf50..d1b530a 100644 --- a/src/BLSURFPlugin/BLSURFPlugin_Hypothesis_i.cxx +++ b/src/BLSURFPlugin/BLSURFPlugin_Hypothesis_i.cxx @@ -786,6 +786,115 @@ CORBA::Long BLSURFPlugin_Hypothesis_i::GetTopology() { return this->GetImpl()->GetTopology(); } +//============================================================================= +/*! + * Activate/deactivate surface proximity computation + */ +void BLSURFPlugin_Hypothesis_i::SetUseSurfaceProximity( CORBA::Boolean toUse ) +{ + if ( GetUseSurfaceProximity() != toUse ) + { + this->GetImpl()->SetUseSurfaceProximity( toUse ); + SMESH::TPythonDump() << _this() << ".SetUseSurfaceProximity( " << toUse << " )"; + } +} + +CORBA::Boolean BLSURFPlugin_Hypothesis_i::GetUseSurfaceProximity() +{ + return this->GetImpl()->GetUseSurfaceProximity(); +} + +//============================================================================= +/*! + * Set number of surface element layers to be generated due to surface proximity + */ +void BLSURFPlugin_Hypothesis_i::SetNbSurfaceProximityLayers( CORBA::Short nbLayers ) +{ + if ( GetNbSurfaceProximityLayers() != nbLayers ) + { + this->GetImpl()->SetNbSurfaceProximityLayers( nbLayers ); + SMESH::TPythonDump() << _this() << ".SetNbSurfaceProximityLayers( " << nbLayers << " )"; + } +} + +CORBA::Short BLSURFPlugin_Hypothesis_i::GetNbSurfaceProximityLayers() +{ + return this->GetImpl()->GetNbSurfaceProximityLayers(); +} + +//============================================================================= +/*! + * Set coefficient by which size of element refined due to surface proximity is increased + */ +void BLSURFPlugin_Hypothesis_i::SetSurfaceProximityRatio( CORBA::Double ratio ) +{ + if ( GetSurfaceProximityRatio() != ratio ) + { + this->GetImpl()->SetSurfaceProximityRatio( ratio ); + SMESH::TPythonDump() << _this() << ".SetSurfaceProximityRatio( " << ratio << " )"; + } +} + +CORBA::Double BLSURFPlugin_Hypothesis_i::GetSurfaceProximityRatio() +{ + return this->GetImpl()->GetSurfaceProximityRatio(); +} + +//============================================================================= +/*! + * Activate/deactivate volume proximity computation + */ +void BLSURFPlugin_Hypothesis_i::SetUseVolumeProximity( CORBA::Boolean toUse ) +{ + if ( GetUseVolumeProximity() != toUse ) + { + this->GetImpl()->SetUseVolumeProximity( toUse ); + SMESH::TPythonDump() << _this() << ".SetUseVolumeProximity( " << toUse << " )"; + } +} + +CORBA::Boolean BLSURFPlugin_Hypothesis_i::GetUseVolumeProximity() +{ + return this->GetImpl()->GetUseVolumeProximity(); +} + + +//============================================================================= +/*! + * Set number of surface element layers to be generated due to volume proximity + */ +void BLSURFPlugin_Hypothesis_i::SetNbVolumeProximityLayers( CORBA::Short nbLayers ) +{ + if ( GetNbVolumeProximityLayers() != nbLayers ) + { + this->GetImpl()->SetNbVolumeProximityLayers( nbLayers ); + SMESH::TPythonDump() << _this() << ".SetNbVolumeProximityLayers( " << nbLayers << " )"; + } +} + +CORBA::Short BLSURFPlugin_Hypothesis_i::GetNbVolumeProximityLayers() +{ + return this->GetImpl()->GetNbVolumeProximityLayers(); +} + +//============================================================================= + /*! + * Set coefficient by which size of element refined due to volume proximity is increased + */ +void BLSURFPlugin_Hypothesis_i::SetVolumeProximityRatio( CORBA::Double ratio ) +{ + if ( GetVolumeProximityRatio() != ratio ) + { + this->GetImpl()->SetVolumeProximityRatio( ratio ); + SMESH::TPythonDump() << _this() << ".SetVolumeProximityRatio( " << ratio << " )"; + } +} + +CORBA::Double BLSURFPlugin_Hypothesis_i::GetVolumeProximityRatio() +{ + return this->GetImpl()->GetVolumeProximityRatio(); +} + //============================================================================= void BLSURFPlugin_Hypothesis_i::SetVerbosity(CORBA::Short theVal) throw (SALOME::SALOME_Exception) { ASSERT(myBaseImpl); diff --git a/src/BLSURFPlugin/BLSURFPlugin_Hypothesis_i.hxx b/src/BLSURFPlugin/BLSURFPlugin_Hypothesis_i.hxx index f555f0d..9d180f4 100644 --- a/src/BLSURFPlugin/BLSURFPlugin_Hypothesis_i.hxx +++ b/src/BLSURFPlugin/BLSURFPlugin_Hypothesis_i.hxx @@ -130,6 +130,44 @@ public: void SetTopology(CORBA::Long theValue); CORBA::Long GetTopology(); + + /*! + * Activate/deactivate surface proximity computation + */ + void SetUseSurfaceProximity( CORBA::Boolean toUse ); + CORBA::Boolean GetUseSurfaceProximity(); + + /*! + * Set number of surface element layers to be generated due to surface proximity + */ + void SetNbSurfaceProximityLayers( CORBA::Short nbLayers ); + CORBA::Short GetNbSurfaceProximityLayers(); + + /*! + * Set coefficient by which size of element refined due to surface proximity is increased + */ + void SetSurfaceProximityRatio( CORBA::Double ratio ); + CORBA::Double GetSurfaceProximityRatio(); + + /*! + * Activate/deactivate volume proximity computation + */ + void SetUseVolumeProximity( CORBA::Boolean toUse ); + CORBA::Boolean GetUseVolumeProximity(); + + /*! + * Set number of surface element layers to be generated due to volume proximity + */ + void SetNbVolumeProximityLayers( CORBA::Short nbLayers ); + CORBA::Short GetNbVolumeProximityLayers(); + + /*! + * Set coefficient by which size of element refined due to volume proximity is increased + */ + void SetVolumeProximityRatio( CORBA::Double ratio ); + CORBA::Double GetVolumeProximityRatio(); + + void SetVerbosity(CORBA::Short theVal) throw (SALOME::SALOME_Exception); CORBA::Short GetVerbosity(); diff --git a/src/GUI/BLSURFPluginGUI_HypothesisCreator.cxx b/src/GUI/BLSURFPluginGUI_HypothesisCreator.cxx index 196fcc1..79a0f23 100644 --- a/src/GUI/BLSURFPluginGUI_HypothesisCreator.cxx +++ b/src/GUI/BLSURFPluginGUI_HypothesisCreator.cxx @@ -1793,7 +1793,7 @@ void BLSURFPluginGUI_HypothesisCreator::onPeriodicityContentModified() /** BLSURFPluginGUI_HypothesisCreator::retrieveParams() -This method updates the GUI widgets with the hypothesis data + This method updates the GUI widgets with the hypothesis data */ void BLSURFPluginGUI_HypothesisCreator::retrieveParams() const { @@ -1834,7 +1834,7 @@ void BLSURFPluginGUI_HypothesisCreator::retrieveParams() const myStdWidget->myVolumeGradation->setText(""); else myStdWidget->myVolumeGradation->SetValue( data.myVolumeGradation ); - + foreach (QAbstractButton* button, myStdWidget->myButtonGroupElementType->buttons()) { if (myStdWidget->myButtonGroupElementType->id(button) == data.myElementType) { button->setChecked(true); @@ -1842,6 +1842,23 @@ void BLSURFPluginGUI_HypothesisCreator::retrieveParams() const } } + myStdWidget->myUseSurfaceProximity->setChecked( data.myUseSurfaceProximity ); + myStdWidget->myNbSurfaceProximityLayers->setValue( data.myNbSurfaceProximityLayers ); + myStdWidget->mySurfaceProximityRatio->SetValue( data.mySurfaceProximityRatio ); + myStdWidget->myUseVolumeProximity->setChecked( data.myUseVolumeProximity ); + myStdWidget->myNbVolumeProximityLayers->setValue( data.myNbVolumeProximityLayers ); + myStdWidget->myVolumeProximityRatio->SetValue( data.myVolumeProximityRatio ); + if ( !data.myUseSurfaceProximity ) + { + //myStdWidget->myNbSurfaceProximityLayers->setText(""); + myStdWidget->mySurfaceProximityRatio->setText(""); + } + if ( !data.myUseVolumeProximity ) + { + //myStdWidget->myNbVolumeProximityLayers->setText(""); + myStdWidget->myVolumeProximityRatio->setText(""); + } + if (data.myAngleMesh < 0) myStdWidget->myAngleMesh->setText(""); else @@ -2056,7 +2073,7 @@ bool BLSURFPluginGUI_HypothesisCreator::readParamsFromHypo( BlsurfHypothesisData h_data.myTinyEdgeOptimisLength = myTinyEdgeOptimisLength > 0 ? myTinyEdgeOptimisLength : -1.0; h_data.myCorrectSurfaceIntersection = h->GetCorrectSurfaceIntersection(); double corrSurfaceIntersMaxCost = h->GetCorrectSurfaceIntersectionMaxCost(); - h_data.myCorrectSurfaceIntersectionMaxCost = corrSurfaceIntersMaxCost > 0 ? corrSurfaceIntersMaxCost : -1.0; + h_data.myCorrectSurfaceIntersectionMaxCost = corrSurfaceIntersMaxCost > 0 ? corrSurfaceIntersMaxCost : -1.0; h_data.myForceBadElementRemoval = h->GetBadElementRemoval(); double myBadElementAspectRatio = h->GetBadElementAspectRatio(); h_data.myBadElementAspectRatio = myBadElementAspectRatio > 0 ? myBadElementAspectRatio : -1.0; @@ -2067,7 +2084,12 @@ bool BLSURFPluginGUI_HypothesisCreator::readParamsFromHypo( BlsurfHypothesisData //h_data.myPreCADMergeEdges = h->GetPreCADMergeEdges(); // h_data.myPreCADProcess3DTopology = h->GetPreCADProcess3DTopology(); // h_data.myPreCADDiscardInput = h->GetPreCADDiscardInput(); - + h_data.myUseSurfaceProximity = h->GetUseSurfaceProximity (); + h_data.myNbSurfaceProximityLayers = h->GetNbSurfaceProximityLayers(); + h_data.mySurfaceProximityRatio = h->GetSurfaceProximityRatio (); + h_data.myUseVolumeProximity = h->GetUseVolumeProximity (); + h_data.myNbVolumeProximityLayers = h->GetNbVolumeProximityLayers (); + h_data.myVolumeProximityRatio = h->GetVolumeProximityRatio (); BLSURFPluginGUI_HypothesisCreator* that = (BLSURFPluginGUI_HypothesisCreator*)this; that->myOptions = h->GetOptionValues(); @@ -2301,26 +2323,33 @@ bool BLSURFPluginGUI_HypothesisCreator::storeParamsToHypo( const BlsurfHypothesi if ( h->GetVolumeGradation() != h_data.myVolumeGradation ) h->SetVolumeGradation( h_data.myVolumeGradation <= 0 ? -1 : h_data.myVolumeGradation ); + h->SetUseSurfaceProximity ( h_data.myUseSurfaceProximity ); + h->SetNbSurfaceProximityLayers( h_data.myNbSurfaceProximityLayers ); + h->SetSurfaceProximityRatio ( h_data.mySurfaceProximityRatio ); + h->SetUseVolumeProximity ( h_data.myUseVolumeProximity ); + h->SetNbVolumeProximityLayers ( h_data.myNbVolumeProximityLayers ); + h->SetVolumeProximityRatio ( h_data.myVolumeProximityRatio ); + if ( h->GetElementType() != h_data.myElementType ) h->SetElementType( h_data.myElementType ); - + if ( (int) h_data.myGeometricMesh != DefaultGeom ) { if ( h->GetAngleMesh() != h_data.myAngleMesh ) h->SetAngleMesh( h_data.myAngleMesh <= 0 ? -1 :h_data.myAngleMesh ); if ( h->GetChordalError() != h_data.myChordalError ) h->SetChordalError( h_data.myChordalError <= 0 ? -1 :h_data.myChordalError ); } - + if ( h->GetAnisotropic() != h_data.myAnisotropic ) h->SetAnisotropic( h_data.myAnisotropic ); if ( h_data.myAnisotropic && ( h->GetAnisotropicRatio() != h_data.myAnisotropicRatio ) ) h->SetAnisotropicRatio( h_data.myAnisotropicRatio <= 0 ? -1 :h_data.myAnisotropicRatio ); - + if ( h->GetRemoveTinyEdges() != h_data.myRemoveTinyEdges ) h->SetRemoveTinyEdges( h_data.myRemoveTinyEdges ); if ( h_data.myRemoveTinyEdges && ( h->GetTinyEdgeLength() != h_data.myTinyEdgeLength ) ) h->SetTinyEdgeLength( h_data.myTinyEdgeLength <= 0 ? -1 :h_data.myTinyEdgeLength ); - + if ( h->GetOptimiseTinyEdges() != h_data.myOptimiseTinyEdges ) h->SetOptimiseTinyEdges( h_data.myOptimiseTinyEdges ); if ( h_data.myOptimiseTinyEdges && ( h->GetTinyEdgeOptimisationLength() != h_data.myTinyEdgeOptimisLength ) ) @@ -2553,6 +2582,12 @@ QString BLSURFPluginGUI_HypothesisCreator::readParamsFromWidgets( BlsurfHypothes //h_data.myPreCADMergeEdges = myAdvWidget->myPreCADMergeEdges->isChecked(); //h_data.myPreCADProcess3DTopology = myAdvWidget->myPreCADProcess3DTopology->isChecked(); //h_data.myPreCADDiscardInput = myAdvWidget->myPreCADDiscardInput->isChecked(); + h_data.myUseSurfaceProximity = myStdWidget->myUseSurfaceProximity ->isChecked(); + h_data.myNbSurfaceProximityLayers = myStdWidget->myNbSurfaceProximityLayers->value(); + h_data.mySurfaceProximityRatio = myStdWidget->mySurfaceProximityRatio ->value(); + h_data.myUseVolumeProximity = myStdWidget->myUseVolumeProximity ->isChecked(); + h_data.myNbVolumeProximityLayers = myStdWidget->myNbVolumeProximityLayers ->value(); + h_data.myVolumeProximityRatio = myStdWidget->myVolumeProximityRatio ->value(); QString guiHyp; guiHyp += tr("BLSURF_PHY_MESH") + " = " + QString::number( h_data.myPhysicalMesh ) + "; "; diff --git a/src/GUI/BLSURFPluginGUI_HypothesisCreator.h b/src/GUI/BLSURFPluginGUI_HypothesisCreator.h index 5d609bb..a1f5f99 100644 --- a/src/GUI/BLSURFPluginGUI_HypothesisCreator.h +++ b/src/GUI/BLSURFPluginGUI_HypothesisCreator.h @@ -171,6 +171,12 @@ typedef struct bool myOptimizeMesh, myQuadraticMesh; bool mySmpsurface,mySmpedge,mySmppoint,myEnforcedVertex,myInternalEnforcedVerticesAllFaces; long myElementType; + bool myUseSurfaceProximity; + int myNbSurfaceProximityLayers; + double mySurfaceProximityRatio; + bool myUseVolumeProximity; + int myNbVolumeProximityLayers; + double myVolumeProximityRatio; // bool myPreCADMergeEdges, myPreCADProcess3DTopology, myPreCADDiscardInput; // bool myGMFFileMode; std::string myGMFFileName, myInternalEnforcedVerticesAllFacesGroup; diff --git a/src/GUI/BLSURFPluginGUI_StdWidget.cxx b/src/GUI/BLSURFPluginGUI_StdWidget.cxx index 845791f..0996dcf 100644 --- a/src/GUI/BLSURFPluginGUI_StdWidget.cxx +++ b/src/GUI/BLSURFPluginGUI_StdWidget.cxx @@ -52,6 +52,8 @@ BLSURFPluginGUI_StdWidget::BLSURFPluginGUI_StdWidget( QWidget* parent, Qt::Windo myTinyEdgeOptimisLength->RangeStepAndValidator(0, COORD_MAX, 0.1, "length_precision"); myCorrectSurfaceIntersectionMaxCost->RangeStepAndValidator(0, COORD_MAX, 1); myBadElementAspectRatio->RangeStepAndValidator(0, COORD_MAX, 1000, "length_precision"); + mySurfaceProximityRatio->RangeStepAndValidator(1, COORD_MAX, 1, "length_precision"); + myVolumeProximityRatio->RangeStepAndValidator(1, COORD_MAX, 1, "length_precision"); myMinSize->setText(""); myMaxSize->setText(""); myAngleMesh->setText(""); @@ -131,25 +133,3 @@ void BLSURFPluginGUI_StdWidget::onEditingFinished() { spinBox->setText(""); } } - - - - - - - - - - - - - - - - - - - - - - diff --git a/src/GUI/BLSURFPluginGUI_StdWidget_QTD.ui b/src/GUI/BLSURFPluginGUI_StdWidget_QTD.ui index 608fe0d..7780a04 100644 --- a/src/GUI/BLSURFPluginGUI_StdWidget_QTD.ui +++ b/src/GUI/BLSURFPluginGUI_StdWidget_QTD.ui @@ -7,11 +7,11 @@ 0 0 - 723 - 399 + 899 + 532 - + @@ -232,6 +232,70 @@ + + + BLSURF_ELEMENT_TYPE + + + + + + BLSURF_TRIANGLES_TOOLTIP + + + BLSURF_TRIANGLES + + + true + + + myButtonGroupElementType + + + + + + + BLSURF_ALLOW_QUADRANGLES_TOOLTIP + + + BLSURF_QUADRANGLE_DOMINANT + + + myButtonGroupElementType + + + + + + + BLSURF_QUADRANGLES_TOOLTIP + + + BLSURF_QUADRANGLES + + + myButtonGroupElementType + + + + + + + Qt::Vertical + + + + 20 + 3 + + + + + + + + BLSURF_MAIN_PARAMETERS @@ -293,7 +357,164 @@ - + + + + + + + BLSURF_PROXIMITY + + + + + + BLSURF_VOLUME_GRADATION_TOOLTIP + + + BLSURF_VOLUME_GRADATION + + + + + + + false + + + + + + + BLSURF_SURFACE_PROXIMITY_TOOLTIP + + + BLSURF_SURFACE_PROXIMITY + + + true + + + + + + BLSURF_SURF_RATIO_TOOLTIP + + + BLSURF_SURF_RATIO + + + + + + + true + + + BLSURF_SURF_RATIO_TOOLTIP + + + 1.000000000000000 + + + + + + + BLSURF_SURF_NB_LAYRES_TOOLTIP + + + + + + + BLSURF_SURF_NB_LAYRES_TOOLTIP + + + BLSURF_SURF_NB_LAYRES + + + + + label_7 + myVolumeGradation_2 + myNbSurfaceProximityLayers + label_9 + mySurfaceProximityRatio + + + + + + BLSURF_VOLUME_PROXIMITY_TOOLTIP + + + BLSURF_VOLUME_PROXIMITY + + + true + + + + + + BLSURF_VOL_NB_LAYERS_TOOLTIP + + + BLSURF_VOL_NB_LAYERS + + + + + + + BLSURF_VOL_NB_LAYERS_TOOLTIP + + + + + + + BLSURF_VOL_RATIO_TOOLTIP + + + BLSURF_VOL_RATIO + + + + + + + true + + + BLSURF_VOL_RATIO_TOOLTIP + + + 1.000000000000000 + + + + + + + + + + Qt::Vertical + + + + 20 + 15 + + + + + + + + BLSURF_OTHER_PARAMETERS @@ -385,23 +606,6 @@ - - - BLSURF_VOLUME_GRADATION_TOOLTIP - - - BLSURF_VOLUME_GRADATION - - - - - - - false - - - - Qt::Vertical @@ -417,70 +621,6 @@ - - - - BLSURF_ELEMENT_TYPE - - - - - - BLSURF_TRIANGLES_TOOLTIP - - - BLSURF_TRIANGLES - - - true - - - myButtonGroupElementType - - - - - - - BLSURF_ALLOW_QUADRANGLES_TOOLTIP - - - BLSURF_QUADRANGLE_DOMINANT - - - myButtonGroupElementType - - - - - - - BLSURF_QUADRANGLES_TOOLTIP - - - BLSURF_QUADRANGLES - - - myButtonGroupElementType - - - - - - - Qt::Vertical - - - - 20 - 3 - - - - - - - @@ -515,8 +655,6 @@ myBadElementAspectRatio myCorrectSurfaceIntersection myCorrectSurfaceIntersectionMaxCost - myUseVolumeGradation - myVolumeGradation @@ -527,8 +665,8 @@ onGeometricMeshChanged() - 495 - 48 + 775 + 57 281 @@ -559,12 +697,12 @@ setEnabled(bool) - 488 - 176 + 641 + 466 - 655 - 175 + 787 + 467 @@ -575,12 +713,12 @@ setEnabled(bool) - 488 - 228 + 641 + 518 - 655 - 227 + 787 + 519 @@ -591,12 +729,12 @@ setEnabled(bool) - 488 - 254 + 641 + 544 - 655 - 253 + 787 + 545 @@ -607,12 +745,12 @@ setDisabled(bool) - 488 - 176 + 641 + 466 - 495 - 100 + 775 + 109 @@ -623,11 +761,11 @@ setDisabled(bool) - 488 - 176 + 641 + 466 - 446 + 576 100 @@ -639,7 +777,7 @@ onEditingFinished() - 159 + 197 74 @@ -655,7 +793,7 @@ onEditingFinished() - 159 + 197 100 @@ -671,7 +809,7 @@ onEditingFinished() - 159 + 197 126 @@ -687,8 +825,8 @@ onEditingFinished() - 316 - 199 + 780 + 287 315 @@ -703,8 +841,8 @@ onEditingFinished() - 495 - 74 + 775 + 83 566 @@ -719,8 +857,8 @@ onEditingFinished() - 495 - 100 + 775 + 109 537 @@ -735,12 +873,12 @@ setEnabled(bool) - 438 - 202 + 641 + 492 - 655 - 201 + 787 + 493 @@ -751,12 +889,12 @@ setEnabled(bool) - 450 - 280 + 641 + 570 - 655 - 279 + 787 + 571 @@ -767,12 +905,12 @@ setEnabled(bool) - 449 - 306 + 210 + 466 - 655 - 305 + 383 + 467 @@ -783,12 +921,12 @@ setEnabled(bool) - 115 - 206 + 593 + 286 - 249 - 211 + 780 + 287 diff --git a/src/GUI/BLSURFPlugin_msg_en.ts b/src/GUI/BLSURFPlugin_msg_en.ts index 41a84a8..9016435 100644 --- a/src/GUI/BLSURFPlugin_msg_en.ts +++ b/src/GUI/BLSURFPlugin_msg_en.ts @@ -99,6 +99,58 @@ The default computed value is <em>diag</em>/5. BLSURF_VOLUME_GRADATION_TOOLTIP Maximum ratio between the lengths of two adjacent edges in 3D mesh. + + BLSURF_PROXIMITY + Proximity + + + BLSURF_SURFACE_PROXIMITY + Surface proximity + + + BLSURF_SURFACE_PROXIMITY_TOOLTIP + Detection of proximities onto the surface. + + + BLSURF_SURF_NB_LAYRES + Number of layers + + + BLSURF_SURF_NB_LAYRES_TOOLTIP + Number of surface element layers. + + + BLSURF_VOLUME_PROXIMITY + Volume proximity + + + BLSURF_VOLUME_PROXIMITY_TOOLTIP + Detection of proximities into the volume. + + + BLSURF_SURF_RATIO + Ratio + + + BLSURF_SURF_RATIO_TOOLTIP + Ratio between layers. + + + BLSURF_VOL_NB_LAYERS + Number of layers + + + BLSURF_VOL_NB_LAYERS_TOOLTIP + Number of surface element layers. + + + BLSURF_VOL_RATIO + Ratio + + + BLSURF_VOL_RATIO_TOOLTIP + Ratio between layers. + BLSURF_ELEMENT_TYPE Elements type @@ -677,6 +729,14 @@ The smaller this distance is, the closer the mesh is to the exact surface (only tiny_edge_avoid_surface_intersections Tiny edges avoid surface intersections + + allow_patch_independent + Independent patches + + + compute_ridges + Compute ridges + closed_geometry Closed geometry