X-Git-Url: http://git.salome-platform.org/gitweb/?a=blobdiff_plain;f=src%2FBLSURFPlugin%2FBLSURFPlugin_Hypothesis.hxx;h=693def64b2be4f74426741f8a1b1abedfe715bc1;hb=0a057ad10d10cbec461c916216f468dbe94390c7;hp=e0e0f3b12732e4955963a638a0e3667def261e78;hpb=d4f641ef5f8a763d3a5c411394be90998dd2ee09;p=plugins%2Fblsurfplugin.git diff --git a/src/BLSURFPlugin/BLSURFPlugin_Hypothesis.hxx b/src/BLSURFPlugin/BLSURFPlugin_Hypothesis.hxx index e0e0f3b..693def6 100644 --- a/src/BLSURFPlugin/BLSURFPlugin_Hypothesis.hxx +++ b/src/BLSURFPlugin/BLSURFPlugin_Hypothesis.hxx @@ -1,99 +1,612 @@ -// BLSURFPlugin : C++ implementation +// Copyright (C) 2007-2021 CEA/DEN, EDF R&D // -// Copyright (C) 2006 OPEN CASCADE, CEA/DEN, EDF R&D -// -// 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. -// -// 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.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org +// 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 // -// File : BLSURFPlugin_Hypothesis.hxx -// Authors : Francis KLOSS (OCC) & Patrick LAUG (INRIA) & Lioka RAZAFINDRAZAKA (CEA) -// & Aurelien ALLEAUME (DISTENE) -// Date : 27/03/2006 -// Project : SALOME -// $Header$ -//============================================================================= +// --- +// File : BLSURFPlugin_Hypothesis.hxx +// Authors : Francis KLOSS (OCC) & Patrick LAUG (INRIA) & Lioka RAZAFINDRAZAKA (CEA) +// & Aurelien ALLEAUME (DISTENE) +// Size maps developement: Nicolas GEIMER (OCC) & Gilles DAVID (EURIWARE) +// --- +// #ifndef _BLSURFPlugin_Hypothesis_HXX_ #define _BLSURFPlugin_Hypothesis_HXX_ -#include "SMESH_Hypothesis.hxx" -#include "Utils_SALOME_Exception.hxx" +#include "BLSURFPlugin_Attractor.hxx" + +#include +#include +#include + +#include +#include +#include +#include -// Parameters for work of BLSURF +class SMESH_Mesh; + +// Parameters for work of MG-CADSurf + +enum EnforcedMeshType { ENFORCED_MESH, ENFORCED_GROUP, ENFORCED_SUBMESH }; class BLSURFPlugin_Hypothesis: public SMESH_Hypothesis { public: - BLSURFPlugin_Hypothesis(int hypId, int studyId, SMESH_Gen * gen); + BLSURFPlugin_Hypothesis(int hypId, SMESH_Gen * gen, bool hasgeom); enum Topology { FromCAD, Process, - Process2 + Process2, + PreCAD }; enum PhysicalMesh { DefaultSize, - PhysicalUserDefined + PhysicalGlobalSize, + PhysicalLocalSize }; enum GeometricMesh { DefaultGeom, - UserDefined + GeometricalGlobalSize, + GeometricalLocalSize }; - void SetTopology(Topology theTopology); - Topology GetTopology() const { return _topology; } + enum ElementType { + Triangles, + QuadrangleDominant, + Quadrangles + }; + + static const char* GetHypType(bool hasgeom) + { return hasgeom ? "MG-CADSurf Parameters" : "MG-CADSurf Parameters_NOGEOM"; } + + TopoDS_Shape entryToShape(std::string entry); + + static std::string GetMeshGemsVersion(); void SetPhysicalMesh(PhysicalMesh thePhysicalMesh); PhysicalMesh GetPhysicalMesh() const { return _physicalMesh; } - void SetPhySize(double thePhySize); - double GetPhySize() const { return _phySize; } - void SetGeometricMesh(GeometricMesh theGeometricMesh); GeometricMesh GetGeometricMesh() const { return _geometricMesh; } - void SetAngleMeshS(double theAngle); - double GetAngleMeshS() const { return _angleMeshS; } + void SetPhySize(double thePhySize, bool isRelative = false); + double GetPhySize() const { return _phySize; } + bool IsPhySizeRel() const { return _phySizeRel; } + + void SetMinSize(double theMinSize, bool isRelative = false); + double GetMinSize() const { return _minSize; } + bool IsMinSizeRel() const { return _minSizeRel; } + + void SetMaxSize(double theMaxSize, bool isRelative = false); + double GetMaxSize() const { return _maxSize; } + bool IsMaxSizeRel() const { return _maxSizeRel; } + void SetUseGradation(bool toUse); + bool GetUseGradation() const { return _useGradation; } void SetGradation(double theGradation); double GetGradation() const { return _gradation; } - void SetQuadAllowed(bool theVal); - bool GetQuadAllowed() const { return _quadAllowed; } + void SetUseVolumeGradation(bool toUse); + bool GetUseVolumeGradation() const { return _useVolumeGradation; } + void SetVolumeGradation(double theGradation); + double GetVolumeGradation() const { return _volumeGradation; } + + void SetElementType(ElementType theElementType); + ElementType GetElementType() const { return _elementType; } + + void SetAngleMesh(double theAngle); + double GetAngleMesh() const { return _angleMesh; } + + void SetChordalError(double theDistance); + double GetChordalError() const { return _chordalError; } + + void SetAnisotropic(bool theVal); + bool GetAnisotropic() const { return _anisotropic; } + + void SetAnisotropicRatio(double theVal); + double GetAnisotropicRatio() const { return _anisotropicRatio; } + + void SetRemoveTinyEdges(bool theVal); + bool GetRemoveTinyEdges() const { return _removeTinyEdges; } + + void SetTinyEdgeLength(double theVal); + double GetTinyEdgeLength() const { return _tinyEdgeLength; } + + void SetOptimiseTinyEdges(bool theVal); + bool GetOptimiseTinyEdges() const { return _optimiseTinyEdges; } + + void SetTinyEdgeOptimisationLength(double theVal); + double GetTinyEdgeOptimisationLength() const { return _tinyEdgeOptimisationLength; } + + void SetCorrectSurfaceIntersection(bool theVal); + bool GetCorrectSurfaceIntersection() const { return _correctSurfaceIntersec; } + + void SetCorrectSurfaceIntersectionMaxCost(double theVal); + double GetCorrectSurfaceIntersectionMaxCost() const { return _corrSurfaceIntersCost; } + + void SetBadElementRemoval(bool theVal); + bool GetBadElementRemoval() const { return _badElementRemoval; } + + void SetBadElementAspectRatio(double theVal); + double GetBadElementAspectRatio() const { return _badElementAspectRatio; } + + void SetOptimizeMesh(bool theVal); + bool GetOptimizeMesh() const { return _optimizeMesh; } + + void SetQuadraticMesh(bool theVal); + bool GetQuadraticMesh() const { return _quadraticMesh; } + + 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(); + + void SetEnforceCadEdgesSize( bool toEnforce ); + bool GetEnforceCadEdgesSize(); + + void SetJacobianRectificationRespectGeometry( bool allowRectification ); + bool GetJacobianRectificationRespectGeometry(); + + void SetUseDeprecatedPatchMesher( bool useDeprecatedPatchMesher ); + bool GetUseDeprecatedPatchMesher(); + + void SetJacobianRectification( bool allowRectification ); + bool GetJacobianRectification(); + + void SetMaxNumberOfPointsPerPatch( int nb ); + int GetMaxNumberOfPointsPerPatch(); + + void SetMaxNumberOfThreads( int nb ); + int GetMaxNumberOfThreads(); + + void SetRespectGeometry( bool toRespect ); + bool GetRespectGeometry(); + + void SetTinyEdgesAvoidSurfaceIntersections( bool toAvoidIntersection ); + bool GetTinyEdgesAvoidSurfaceIntersections(); + + void SetClosedGeometry( bool isClosed ); + bool GetClosedGeometry(); + + void SetDebug( bool isDebug ); + bool GetDebug(); + + void SetPeriodicTolerance( double tol ); + double GetPeriodicTolerance(); + + void SetRequiredEntities( const std::string& howToTreat ); + std::string GetRequiredEntities(); + + void SetSewingTolerance( double tol ); + double GetSewingTolerance(); + + void SetTags( const std::string& howToTreat ); + std::string GetTags(); + + // Hyper-patches + typedef std::set< int > THyperPatchTags; + typedef std::vector< THyperPatchTags > THyperPatchList; + typedef std::set< std::string > THyperPatchEntries; + typedef std::vector< THyperPatchEntries > THyperPatchEntriesList; + + void SetHyperPatches(const THyperPatchList& hpl, bool notifyMesh=true); + void SetHyperPatches(const THyperPatchEntriesList& hpl); + void SetHyperPatchIDsByEntry( const TopoDS_Shape& mainShape, + const std::map< std::string, TopoDS_Shape >& entryToShape); + const THyperPatchList& GetHyperPatches() const { return _hyperPatchList; } + const THyperPatchEntriesList& GetHyperPatchEntries() const { return _hyperPatchEntriesList; } + static int GetHyperPatchTag( int faceTag, const BLSURFPlugin_Hypothesis* hyp, int* iPatch=0 ); + + // Enforced mesh + struct EnforcedMesh + { + int _meshID; // persistent mesh ID + int _subID; // either persistent group ID or sub-shape ID for sub-mesh + EnforcedMeshType _type; /* specify what _subID means: + - nothing for ENFORCED_MESH + - group ID for ENFORCED_GROUP + - sub-shape ID for ENFORCED_SUBMESH */ + std::string _groupName; // name of a group to add mesh edges to + + bool operator==(const EnforcedMesh& em ) const + { + return ( _meshID == em._meshID && _subID == em._subID && + _type == em._type && _groupName == em._groupName ); + } + }; + + void SetEnforcedMeshes( std::vector< EnforcedMesh > & enforcedMeshes ); + const std::vector< EnforcedMesh > & GetEnforcedMeshes() const { return _enforcedMeshes; } + SMDS_ElemIteratorPtr GetEnforcedSegments( const EnforcedMesh& enfMesh, + SMESH_Mesh* & mesh ) const; + + + void SetPreCADMergeEdges(bool theVal); + bool GetPreCADMergeEdges() const { return _preCADMergeEdges; } + + void SetPreCADRemoveDuplicateCADFaces(bool theVal); + bool GetPreCADRemoveDuplicateCADFaces() const { return _preCADRemoveDuplicateCADFaces; } + + void SetPreCADProcess3DTopology(bool theVal); + bool GetPreCADProcess3DTopology() const { return _preCADProcess3DTopology; } + + void SetPreCADDiscardInput(bool theVal); + bool GetPreCADDiscardInput() const { return _preCADDiscardInput; } + + static bool HasPreCADOptions(const BLSURFPlugin_Hypothesis* hyp); + + typedef std::map TSizeMap; + + void SetSizeMapEntry(const std::string& entry,const std::string& sizeMap ); + std::string GetSizeMapEntry(const std::string& entry); + const TSizeMap& _GetSizeMapEntries() const { return _sizeMap; } + /*! + * \brief Return the size maps + */ + static TSizeMap GetSizeMapEntries(const BLSURFPlugin_Hypothesis* hyp); + + + void SetAttractorEntry(const std::string& entry,const std::string& attractor ); + std::string GetAttractorEntry(const std::string& entry); + const TSizeMap& _GetAttractorEntries() const { return _attractors; }; + /*! + * \brief Return the attractors + */ + static TSizeMap GetAttractorEntries(const BLSURFPlugin_Hypothesis* hyp); + + +/* + void SetCustomSizeMapEntry(const std::string& entry,const std::string& sizeMap ); + std::string GetCustomSizeMapEntry(const std::string& entry); + void UnsetCustomSizeMap(const std::string& entry); + const TSizeMap& GetCustomSizeMapEntries() const { return _customSizeMap; } + */ + + typedef std::multimap< std::string, BLSURFPlugin_Attractor* > TAttractorMap; + typedef std::map< std::string, std::vector > TParamsMap; //TODO ?? finir + + void SetClassAttractorEntry(const std::string& entry, const std::string& att_entry, double StartSize, double EndSize, double ActionRadius, double ConstantRadius); + std::string GetClassAttractorEntry(const std::string& entry); + const TAttractorMap& _GetClassAttractorEntries() const { return _classAttractors; } + /*! + * \brief Return the attractors entries + */ + static TAttractorMap GetClassAttractorEntries(const BLSURFPlugin_Hypothesis* hyp); + + /*! + * To set/get/unset an enforced vertex + */ + // Name + typedef std::string TEnfName; + // Entry + typedef std::string TEntry; + // List of entries + typedef std::set TEntryList; + // Group name + typedef std::string TEnfGroupName; + // Coordinates + typedef std::vector TEnfVertexCoords; + typedef std::set< TEnfVertexCoords > TEnfVertexCoordsList; + + // Enforced vertex + struct TEnfVertex { + TEnfName name; + TEntry geomEntry; + TEnfVertexCoords coords; + TEnfGroupName grpName; + TEntryList faceEntries; + TopoDS_Vertex vertex; + }; + + struct CompareEnfVertices + { + bool operator () (const TEnfVertex* e1, const TEnfVertex* e2) const { + if (e1 && e2) { + if (e1->coords.size() && e2->coords.size()) + return (e1->coords < e2->coords); + else + return (e1->geomEntry < e2->geomEntry); + } + return false; + } + }; + + // PreCad Face and Edge periodicity + struct TPreCadPeriodicity { + TEntry shape1Entry; + TEntry shape2Entry; + std::vector theSourceVerticesEntries; + std::vector theTargetVerticesEntries; + }; + + // Edge periodicity + struct TEdgePeriodicity { + TEntry theFace1Entry; + TEntry theEdge1Entry; + TEntry theFace2Entry; + TEntry theEdge2Entry; + int edge_orientation; + }; + + // Vertex periodicity + struct TVertexPeriodicity { + TEntry theEdge1Entry; + TEntry theVertex1Entry; + TEntry theEdge2Entry; + TEntry theVertex2Entry; + }; + + typedef std::pair< TEntry, TEntry > TFacesPeriodicity; + + // List of enforced vertices + typedef std::set< TEnfVertex*, CompareEnfVertices > TEnfVertexList; + + // Map Face Entry / List of enforced vertices + typedef std::map< TEntry, TEnfVertexList > TFaceEntryEnfVertexListMap; + + // List of Face Entry with internal enforced vertices activated + typedef std::set< TEntry > TFaceEntryInternalVerticesList; + + // Map Face Entry / List of coords + typedef std::map< TEntry, TEnfVertexCoordsList > TFaceEntryCoordsListMap; + + // Map Face Entry / List of Vertex entry + typedef std::map< TEntry, TEntryList > TFaceEntryEnfVertexEntryListMap; + + // Map Coords / Enforced vertex + typedef std::map< TEnfVertexCoords, TEnfVertex* > TCoordsEnfVertexMap; + + // Map Vertex entry / Enforced vertex + typedef std::map< TEntry, TEnfVertex* > TEnfVertexEntryEnfVertexMap; + + typedef std::map< TEnfGroupName, std::set > TGroupNameNodeIDMap; + /* TODO GROUPS + // Map Group Name / List of enforced vertices + typedef std::map< TEnfGroupName , TEnfVertexList > TGroupNameEnfVertexListMap; + */ + + // Vector of pairs of entries + typedef std::vector< TPreCadPeriodicity > TPreCadPeriodicityVector; + typedef std::vector< TFacesPeriodicity > TFacesPeriodicityVector; + typedef std::vector< TEdgePeriodicity > TEdgesPeriodicityVector; + typedef std::vector< TVertexPeriodicity > TVerticesPeriodicityVector; + + + bool SetEnforcedVertex(TEntry theFaceEntry, TEnfName theVertexName, TEntry theVertexEntry, TEnfGroupName theGroupName, + double x = 0.0, double y = 0.0, double z = 0.0); + TEnfVertexList GetEnfVertexList(const TEntry& theFaceEntry); + TEnfVertexCoordsList GetEnfVertexCoordsList(const TEntry& theFaceEntry); + TEntryList GetEnfVertexEntryList (const TEntry& theFaceEntry); + TEnfVertex* GetEnfVertex(TEnfVertexCoords coords); + TEnfVertex* GetEnfVertex(const TEntry& theEnfVertexEntry); + void AddEnfVertexNodeID(TEnfGroupName theGroupName,smIdType theNodeID); + std::set GetEnfVertexNodeIDs(TEnfGroupName theGroupName); + void RemoveEnfVertexNodeID(TEnfGroupName theGroupName,smIdType theNodeID); + + bool ClearEnforcedVertex(const TEntry& theFaceEntry, double x = 0.0, double y = 0.0, double z = 0.0, const TEntry& theVertexEntry=""); + bool ClearEnforcedVertices(const TEntry& theFaceEntry); + + void ClearAllEnforcedVertices(); + void AddEnforcedVertex( const TEntry& theFaceEntry, TEnfVertex * theEnfVertex ); + + const TFaceEntryEnfVertexListMap& _GetAllEnforcedVerticesByFace() const { return _faceEntryEnfVertexListMap; } + const TEnfVertexList& _GetAllEnforcedVertices() const { return _enfVertexList; } + + const TFaceEntryCoordsListMap& _GetAllCoordsByFace() const { return _faceEntryCoordsListMap; } + const TCoordsEnfVertexMap& _GetAllEnforcedVerticesByCoords() const { return _coordsEnfVertexMap; } + + const TFaceEntryEnfVertexEntryListMap& _GetAllEnfVertexEntriesByFace() const { return _faceEntryEnfVertexEntryListMap; } + const TEnfVertexEntryEnfVertexMap& _GetAllEnforcedVerticesByEnfVertexEntry() const { return _enfVertexEntryEnfVertexMap; } + +// TODO GROUPS +// const TEnfVertexGroupNameMap _GetEnforcedVertexGroupNameMap() const { return _enfVertexGroupNameMap; } + + + /*! + * \brief Return the enforced vertices + */ + static TFaceEntryEnfVertexListMap GetAllEnforcedVerticesByFace(const BLSURFPlugin_Hypothesis* hyp); + static TEnfVertexList GetAllEnforcedVertices(const BLSURFPlugin_Hypothesis* hyp); + + static TFaceEntryCoordsListMap GetAllCoordsByFace(const BLSURFPlugin_Hypothesis* hyp); + static TCoordsEnfVertexMap GetAllEnforcedVerticesByCoords(const BLSURFPlugin_Hypothesis* hyp); + + static TFaceEntryEnfVertexEntryListMap GetAllEnfVertexEntriesByFace(const BLSURFPlugin_Hypothesis* hyp); + static TEnfVertexEntryEnfVertexMap GetAllEnforcedVerticesByEnfVertexEntry(const BLSURFPlugin_Hypothesis* hyp); + + /*! + * \brief Internal enforced vertices + */ + void SetInternalEnforcedVertexAllFaces(bool toEnforceInternalVertices); + bool _GetInternalEnforcedVertexAllFaces() const { return _enforcedInternalVerticesAllFaces; } + static bool GetInternalEnforcedVertexAllFaces( const BLSURFPlugin_Hypothesis* hyp ); + void SetInternalEnforcedVertexAllFacesGroup(TEnfGroupName theGroupName); + const TEnfGroupName _GetInternalEnforcedVertexAllFacesGroup() const { return _enforcedInternalVerticesAllFacesGroup; } + static TEnfGroupName GetInternalEnforcedVertexAllFacesGroup( const BLSURFPlugin_Hypothesis* hyp ); + +// Enable internal enforced vertices on specific face if requested by user +// static TFaceEntryInternalVerticesList GetDefaultFaceEntryInternalVerticesMap() { return TFaceEntryInternalVerticesList(); } +// const TFaceEntryInternalVerticesList _GetAllInternalEnforcedVerticesByFace() const { return _faceEntryInternalVerticesList; } +// static TFaceEntryInternalVerticesList GetAllInternalEnforcedVerticesByFace(const BLSURFPlugin_Hypothesis* hyp); +// void SetInternalEnforcedVertex(TEntry theFaceEntry, bool toEnforceInternalVertices, TEnfGroupName theGroupName); +// bool GetInternalEnforcedVertex(const TEntry& theFaceEntry); + + static PhysicalMesh GetDefaultPhysicalMesh() { return PhysicalGlobalSize; } + static GeometricMesh GetDefaultGeometricMesh() { return GeometricalGlobalSize; } + static double GetDefaultPhySize(double diagonal, double bbSegmentation); + static double GetDefaultPhySize() { return undefinedDouble(); } + static bool GetDefaultPhySizeRel() { return false; } + static double GetDefaultMinSize(double diagonal); + static double GetDefaultMinSize() { return undefinedDouble(); } + static bool GetDefaultMinSizeRel() { return false; } + static double GetDefaultMaxSize(double diagonal); + static double GetDefaultMaxSize() { return undefinedDouble(); } + static bool GetDefaultMaxSizeRel() { return false; } + static bool GetDefaultUseGradation() { return true; } + static double GetDefaultGradation() { return 1.3; } + static bool GetDefaultUseVolumeGradation() { return false; } + 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.; } - void SetDecimesh(bool theVal); - bool GetDecimesh() const { return _decimesh; } + static double GetDefaultChordalError(double diagonal); + static double GetDefaultChordalError() { return undefinedDouble(); } + static bool GetDefaultAnisotropic() { return false; } + static double GetDefaultAnisotropicRatio() { return 0.0; } + static bool GetDefaultRemoveTinyEdges() { return false; } + static double GetDefaultTinyEdgeLength(double diagonal); + static double GetDefaultTinyEdgeLength() { return undefinedDouble(); } + static bool GetDefaultOptimiseTinyEdges() { return false; } + static double GetDefaultTinyEdgeOptimisationLength(double diagonal); + static double GetDefaultTinyEdgeOptimisationLength() { return undefinedDouble(); } + static bool GetDefaultCorrectSurfaceIntersection() { return true; } + static double GetDefaultCorrectSurfaceIntersectionMaxCost() { return 15.; } + static bool GetDefaultBadElementRemoval() { return false; } + static double GetDefaultBadElementAspectRatio() {return 1000.0; } + static bool GetDefaultOptimizeMesh() { return true; } + static bool GetDefaultQuadraticMesh() { return false; } - static Topology GetDefaultTopology(); - static PhysicalMesh GetDefaultPhysicalMesh(); - static double GetDefaultPhySize(); - static GeometricMesh GetDefaultGeometricMesh(); - static double GetDefaultAngleMeshS(); - static double GetDefaultGradation(); - static bool GetDefaultQuadAllowed(); - static bool GetDefaultDecimesh(); + static int GetDefaultVerbosity() { return 3; } + static Topology GetDefaultTopology() { return FromCAD; } + // PreCAD + static bool GetDefaultPreCADMergeEdges() { return false; } + 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(); } + + static TFaceEntryEnfVertexListMap GetDefaultFaceEntryEnfVertexListMap() { return TFaceEntryEnfVertexListMap(); } + static TEnfVertexList GetDefaultEnfVertexList() { return TEnfVertexList(); } + static TFaceEntryCoordsListMap GetDefaultFaceEntryCoordsListMap() { return TFaceEntryCoordsListMap(); } + static TCoordsEnfVertexMap GetDefaultCoordsEnfVertexMap() { return TCoordsEnfVertexMap(); } + static TFaceEntryEnfVertexEntryListMap GetDefaultFaceEntryEnfVertexEntryListMap() { return TFaceEntryEnfVertexEntryListMap(); } + static TEnfVertexEntryEnfVertexMap GetDefaultEnfVertexEntryEnfVertexMap() { return TEnfVertexEntryEnfVertexMap(); } + static TGroupNameNodeIDMap GetDefaultGroupNameNodeIDMap() { return TGroupNameNodeIDMap(); } + + static bool GetDefaultInternalEnforcedVertex() { return false; } + + /* TODO GROUPS + static TGroupNameEnfVertexListMap GetDefaultGroupNameEnfVertexListMap() { return TGroupNameEnfVertexListMap(); } + static TEnfVertexGroupNameMap GetDefaultEnfVertexGroupNameMap() { return TEnfVertexGroupNameMap(); } + */ + +// const TPreCadPeriodicityEntriesVector _GetPreCadFacesPeriodicityEntries() const { return _preCadFacesPeriodicityEntriesVector; } + + static TPreCadPeriodicityVector GetDefaultPreCadFacesPeriodicityVector() { return TPreCadPeriodicityVector(); } + const TPreCadPeriodicityVector& _GetPreCadFacesPeriodicityVector() const { return _preCadFacesPeriodicityVector; } + static TPreCadPeriodicityVector GetPreCadFacesPeriodicityVector(const BLSURFPlugin_Hypothesis* hyp); + + static TPreCadPeriodicityVector GetDefaultPreCadEdgesPeriodicityVector() { return TPreCadPeriodicityVector(); } + const TPreCadPeriodicityVector& _GetPreCadEdgesPeriodicityVector() const { return _preCadEdgesPeriodicityVector; } + static TPreCadPeriodicityVector GetPreCadEdgesPeriodicityVector(const BLSURFPlugin_Hypothesis* hyp); + + static TFacesPeriodicityVector GetDefaultFacesPeriodicityVector() { return TFacesPeriodicityVector(); } + const TFacesPeriodicityVector& _GetFacesPeriodicityVector() const { return _facesPeriodicityVector; } + static TFacesPeriodicityVector GetFacesPeriodicityVector(const BLSURFPlugin_Hypothesis* hyp); + + static TEdgesPeriodicityVector GetDefaultEdgesPeriodicityVector() { return TEdgesPeriodicityVector(); } + const TEdgesPeriodicityVector& _GetEdgesPeriodicityVector() const { return _edgesPeriodicityVector; } + static TEdgesPeriodicityVector GetEdgesPeriodicityVector(const BLSURFPlugin_Hypothesis* hyp); + + static TVerticesPeriodicityVector GetDefaultVerticesPeriodicityVector() { return TVerticesPeriodicityVector(); } + const TVerticesPeriodicityVector& _GetVerticesPeriodicityVector() const { return _verticesPeriodicityVector; } + static TVerticesPeriodicityVector GetVerticesPeriodicityVector(const BLSURFPlugin_Hypothesis* hyp); + + void ClearPreCadPeriodicityVectors(); + + void AddPreCadFacesPeriodicity(TEntry theFace1Entry, TEntry theFace2Entry, + std::vector &theSourceVerticesEntries, std::vector &theTargetVerticesEntries); + void AddPreCadEdgesPeriodicity(TEntry theEdge1Entry, TEntry theEdge2Entry, + std::vector &theSourceVerticesEntries, std::vector &theTargetVerticesEntries); + + static double undefinedDouble() { return -1.0; } + + typedef std::map< std::string, std::string > TOptionValues; + typedef std::set< std::string > TOptionNames; + + void SetOptionValue(const std::string& optionName, + const std::string& optionValue); + void SetPreCADOptionValue(const std::string& optionName, + const std::string& optionValue); + std::string GetOptionValue(const std::string& optionName, bool* isDefault=0) const; + std::string GetPreCADOptionValue(const std::string& optionName, bool* isDefault=0) const; + void ClearOption(const std::string& optionName); + void ClearPreCADOption(const std::string& optionName); + TOptionValues GetOptionValues() const; + TOptionValues GetPreCADOptionValues() const; + const TOptionValues& GetCustomOptionValues() const { return _customOption2value; } + + void AddOption(const std::string& optionName, const std::string& optionValue); + void AddPreCADOption(const std::string& optionName, const std::string& optionValue); + std::string GetOption(const std::string& optionName) const; + std::string GetPreCADOption(const std::string& optionName) const; + + static bool ToBool(const std::string& str, bool* isOk=0); + static double ToDbl(const std::string& str, bool* isOk=0); + static int ToInt(const std::string& str, bool* isOk=0); + + /*! + * Sets the file for export resulting mesh in GMF format + */ +// void SetGMFFile(const std::string& theFileName, bool isBinary); + void SetGMFFile(const std::string& theFileName); + std::string GetGMFFile() const { return _GMFFileName; } + static std::string GetDefaultGMFFile() { return "";} +// bool GetGMFFileMode() const { return _GMFFileMode; } + // Persistence - virtual ostream & SaveTo(ostream & save); - virtual istream & LoadFrom(istream & load); - friend ostream & operator <<(ostream & save, BLSURFPlugin_Hypothesis & hyp); - friend istream & operator >>(istream & load, BLSURFPlugin_Hypothesis & hyp); + virtual std::ostream & SaveTo(std::ostream & save); + virtual std::istream & LoadFrom(std::istream & load); + friend std::ostream & operator <<(std::ostream & save, BLSURFPlugin_Hypothesis & hyp); + friend std::istream & operator >>(std::istream & load, BLSURFPlugin_Hypothesis & hyp); /*! * \brief Does nothing @@ -103,15 +616,118 @@ public: */ virtual bool SetParametersByMesh(const SMESH_Mesh* theMesh, const TopoDS_Shape& theShape); + /*! + * \brief Initialize my parameter values by default parameters. + * \retval bool - true if parameter values have been successfully defined + */ + virtual bool SetParametersByDefaults(const TDefaults& dflts, const SMESH_Mesh* theMesh=0); + + private: - Topology _topology; - PhysicalMesh _physicalMesh; - double _phySize; - GeometricMesh _geometricMesh; - double _angleMeshS; - double _gradation; - bool _quadAllowed; - bool _decimesh; + PhysicalMesh _physicalMesh; + GeometricMesh _geometricMesh; + double _phySize; + bool _phySizeRel; + double _minSize, _maxSize; + bool _minSizeRel, _maxSizeRel; + bool _useGradation; + double _gradation; + bool _useVolumeGradation; + double _volumeGradation; + ElementType _elementType; + double _angleMesh; + double _chordalError; + bool _anisotropic; + double _anisotropicRatio; + bool _removeTinyEdges; + double _tinyEdgeLength; + bool _optimiseTinyEdges; + double _tinyEdgeOptimisationLength; + bool _correctSurfaceIntersec; + double _corrSurfaceIntersCost; + bool _badElementRemoval; + double _badElementAspectRatio; + bool _optimizeMesh; + 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 + TOptionNames _preCADdoubleOptions, _preCADcharOptions; + + TSizeMap _sizeMap; + TSizeMap _attractors; + TAttractorMap _classAttractors; + + TFaceEntryEnfVertexListMap _faceEntryEnfVertexListMap; + TEnfVertexList _enfVertexList; + // maps to get "manual" enf vertex (through their coordinates) + TFaceEntryCoordsListMap _faceEntryCoordsListMap; + TCoordsEnfVertexMap _coordsEnfVertexMap; + // maps to get "geom" enf vertex (through their geom entries) + TFaceEntryEnfVertexEntryListMap _faceEntryEnfVertexEntryListMap; + TEnfVertexEntryEnfVertexMap _enfVertexEntryEnfVertexMap; + TGroupNameNodeIDMap _groupNameNodeIDMap; + +// Enable internal enforced vertices on specific face if requested by user +// TFaceEntryInternalVerticesList _faceEntryInternalVerticesList; + bool _enforcedInternalVerticesAllFaces; + TEnfGroupName _enforcedInternalVerticesAllFacesGroup; + + TPreCadPeriodicityVector _preCadFacesPeriodicityVector; + TPreCadPeriodicityVector _preCadEdgesPeriodicityVector; + + TFacesPeriodicityVector _facesPeriodicityVector; + TEdgesPeriodicityVector _edgesPeriodicityVector; + TVerticesPeriodicityVector _verticesPeriodicityVector; + + THyperPatchList _hyperPatchList; + THyperPatchEntriesList _hyperPatchEntriesList; + + std::vector< EnforcedMesh > _enforcedMeshes; // enforced 1D meshes + + // Called by SaveTo to store content of _preCadFacesPeriodicityVector and _preCadEdgesPeriodicityVector + void SavePreCADPeriodicity(std::ostream & save, const char* shapeType); + + // Called by LoadFrom to fill _preCadFacesPeriodicityVector and _preCadEdgesPeriodicityVector + void LoadPreCADPeriodicity(std::istream & load, const char* shapeType); + + // Called by LoadFrom to fill _facesPeriodicityVector + void LoadFacesPeriodicity(std::istream & load); + + // Called by LoadFrom to fill _edgesPeriodicityVector + void LoadEdgesPeriodicity(std::istream & load); + + // Called by LoadFrom to fill _verticesPeriodicityVector + void LoadVerticesPeriodicity(std::istream & load); + + // Called by SaveTo to store content of _facesPeriodicityVector + void SaveFacesPeriodicity(std::ostream & save); + + // Called by SaveTo to store content of _edgesPeriodicityVector + void SaveEdgesPeriodicity(std::ostream & save); + + // Called by SaveTo to store content of _verticesPeriodicityVector + void SaveVerticesPeriodicity(std::ostream & save); + + std::string _GMFFileName; +// bool _GMFFileMode; + +// TSizeMap _customSizeMap; }; #endif