X-Git-Url: http://git.salome-platform.org/gitweb/?p=modules%2Fsmesh.git;a=blobdiff_plain;f=src%2FSMESH%2FSMESH_Algo.hxx;h=ba8c2d356f0a3aad3da622548fbdfcf9405111b6;hp=25224689a452baa82dcda91775cba10b50a43da5;hb=30ce546b0c5099ad1112929e2db94810e683e54b;hpb=4443257370246592db3996a2fbdd92e85c26da6f diff --git a/src/SMESH/SMESH_Algo.hxx b/src/SMESH/SMESH_Algo.hxx index 25224689a..ba8c2d356 100644 --- a/src/SMESH/SMESH_Algo.hxx +++ b/src/SMESH/SMESH_Algo.hxx @@ -1,4 +1,4 @@ -// Copyright (C) 2007-2013 CEA/DEN, EDF R&D, OPEN CASCADE +// 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 @@ -6,7 +6,7 @@ // 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. +// 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 @@ -35,8 +35,6 @@ #include "SMESH_ComputeError.hxx" #include "SMESH_Hypothesis.hxx" -#include -#include #include #include @@ -52,7 +50,9 @@ class SMESH_Gen; class SMESH_HypoFilter; class SMESH_Mesh; class SMESH_MesherHelper; +class SMESH_ProxyMesh; class SMESH_subMesh; +class TopoDS_Edge; class TopoDS_Face; class TopoDS_Shape; class TopoDS_Vertex; @@ -137,6 +137,8 @@ class SMESH_EXPORT SMESH_Algo : public SMESH_Hypothesis * \param aShape - the shape * \param aStatus - check result * \retval bool - true if hypothesis is well defined + * + * Textual description of a problem can be stored in _comment field. */ virtual bool CheckHypothesis(SMESH_Mesh& aMesh, const TopoDS_Shape& aShape, @@ -163,18 +165,32 @@ class SMESH_EXPORT SMESH_Algo : public SMESH_Hypothesis */ virtual bool Compute(SMESH_Mesh & aMesh, SMESH_MesherHelper* aHelper); + /*! + * \brief Return true if the algorithm can mesh a given shape + * \param [in] aShape - shape to check + * \param [in] toCheckAll - if true, this check returns OK if all shapes are OK, + * else, returns OK if at least one shape is OK + * \retval bool - \c true by default + */ + virtual bool IsApplicableToShape(const TopoDS_Shape & shape, bool toCheckAll) const; + /*! * \brief Sets _computeCanceled to true. It's usage depends on * implementation of a particular mesher. */ virtual void CancelCompute(); + /*! + * \brief If possible, returns progress of computation [0.,1.] + */ + virtual double GetProgress() const; + /*! * \brief evaluates size of prospective mesh on a shape - * \param aMesh - the mesh - * \param aShape - the shape - * \param aNbElems - prospective number of elements by types - * \retval bool - is a success + * \param aMesh - the mesh + * \param aShape - the shape + * \param aResMap - prospective number of elements by SMDSAbs_ElementType by a sub-mesh + * \retval bool - is a success */ virtual bool Evaluate(SMESH_Mesh & aMesh, const TopoDS_Shape & aShape, MapShapeNbElems& aResMap) = 0; @@ -207,31 +223,39 @@ class SMESH_EXPORT SMESH_Algo : public SMESH_Hypothesis * have a name (type) listed in the algorithm. Hypothesis associated to * father shape -are not- taken into account (see GetUsedHypothesis) */ - const list & + const std::list & GetAppliedHypothesis(SMESH_Mesh & aMesh, const TopoDS_Shape & aShape, const bool ignoreAuxiliary=true) const; /*! - * \brief Make the filter recognize only compatible hypotheses - * \param theFilter - the filter to initialize - * \param ignoreAuxiliary - make filter ignore compatible auxiliary hypotheses - * \retval bool - true if the algo has compatible hypotheses + * \brief Returns the filter recognizing only compatible hypotheses + * \param ignoreAuxiliary - make filter ignore compatible auxiliary hypotheses + * \retval SMESH_HypoFilter* - the filter that can be NULL */ - bool InitCompatibleHypoFilter( SMESH_HypoFilter & theFilter, - const bool ignoreAuxiliary) const; + const SMESH_HypoFilter* GetCompatibleHypoFilter(const bool ignoreAuxiliary) const; + /*! * \brief Just return false as the algorithm does not hold parameters values */ virtual bool SetParametersByMesh(const SMESH_Mesh* theMesh, const TopoDS_Shape& theShape); virtual bool SetParametersByDefaults(const TDefaults& dflts, const SMESH_Mesh* theMesh=0); + /*! * \brief return compute error */ SMESH_ComputeErrorPtr GetComputeError() const; /*! - * \brief initialize compute error + * \brief initialize compute error etc. before call of Compute() */ void InitComputeError(); + /*! + * \brief Return compute progress by nb of calls of this method + */ + double GetProgressByTic() const; + /*! + * Return a vector of sub-meshes to Compute() + */ + std::vector& SubMeshesToCompute() { return _smToCompute; } public: // ================================================================== @@ -240,7 +264,7 @@ public: // ================================================================== // SMESH_Hypothesis::GetDim(); - // 1 - dimention of target mesh + // 1 - dimension of target mesh bool OnlyUnaryInput() const { return _onlyUnaryInput; } // 2 - is collection of tesselatable shapes inacceptable as input; @@ -254,7 +278,7 @@ public: // 3 - is a Dim-1 mesh prerequisite bool NeedShape() const { return _requireShape; } - // 4 - is shape existance required + // 4 - is shape existence required bool SupportSubmeshes() const { return _supportSubmeshes; } // 5 - whether supports submeshes if !NeedDiscreteBoundary() @@ -297,6 +321,7 @@ public: * \param theEdge - The geometrical edge of interest * \param theParams - The resulting vector of sorted node parameters * \retval bool - false if not all parameters are OK + * \warning Nodes moved to other geometry by MergeNodes() are NOT returned. */ static bool GetNodeParamOnEdge(const SMESHDS_Mesh* theMesh, const TopoDS_Edge& theEdge, @@ -307,17 +332,16 @@ public: * \param theEdge - The geometrical edge of interest * \param theNodes - The resulting map * \param ignoreMediumNodes - to store medium nodes of quadratic elements or not + * \param typeToCheck - type of elements to check for medium nodes * \retval bool - false if not all parameters are OK + * \warning Nodes moved to other geometry by MergeNodes() are NOT returned. */ static bool GetSortedNodesOnEdge(const SMESHDS_Mesh* theMesh, const TopoDS_Edge& theEdge, const bool ignoreMediumNodes, - std::map< double, const SMDS_MeshNode* > & theNodes); - /*! - * Moved to SMESH_MesherHelper - */ - // static bool IsReversedSubMesh (const TopoDS_Face& theFace, - // SMESHDS_Mesh* theMeshDS); + std::map< double, const SMDS_MeshNode* > & theNodes, + const SMDSAbs_ElementType typeToCheck = SMDSAbs_All); + /*! * \brief Compute length of an edge * \param E - the edge @@ -325,7 +349,6 @@ public: */ static double EdgeLength(const TopoDS_Edge & E); - //static int NumberOfWires(const TopoDS_Shape& S); int NumberOfPoints(SMESH_Mesh& aMesh,const TopoDS_Wire& W); /*! @@ -334,7 +357,7 @@ public: * \param E2 - the 2nd edge * \retval GeomAbs_Shape - regularity at the junction between E1 and E2 */ - static GeomAbs_Shape Continuity(TopoDS_Edge E1, TopoDS_Edge E2); + static GeomAbs_Shape Continuity(const TopoDS_Edge& E1, const TopoDS_Edge& E2); /*! * \brief Return true if an edge can be considered as a continuation of another @@ -342,15 +365,46 @@ public: static bool IsContinuous(const TopoDS_Edge & E1, const TopoDS_Edge & E2) { return ( Continuity( E1, E2 ) >= GeomAbs_G1 ); } + /*! + * \brief Return true if an edge can be considered straight + */ + static bool IsStraight( const TopoDS_Edge & E, const bool degenResult=false ); + /*! + * \brief Return true if an edge has no 3D curve + */ + static bool isDegenerated( const TopoDS_Edge & E, const bool checkLength=false ); /*! * \brief Return the node built on a vertex * \param V - the vertex - * \param meshDS - mesh + * \param meshDS - mesh data structure * \retval const SMDS_MeshNode* - found node or NULL */ static const SMDS_MeshNode* VertexNode(const TopoDS_Vertex& V, const SMESHDS_Mesh* meshDS); + /*! + * \brief Return the node built on a vertex. + * A node moved to other geometry by MergeNodes() is also returned. + * \param V - the vertex + * \param mesh - mesh + * \retval const SMDS_MeshNode* - found node or NULL + */ + static const SMDS_MeshNode* VertexNode(const TopoDS_Vertex& V, const SMESH_Mesh* mesh); + + /*! + * \brief Return the node built on a vertex. + * A node moved to other geometry by MergeNodes() is also returned. + * \param V - the vertex + * \param edgeSM - sub-mesh of a meshed EDGE sharing the vertex + * \param mesh - the mesh + * \param checkV - if \c true, presence of a node on the vertex is checked + * \retval const SMDS_MeshNode* - found node or NULL + */ + static const SMDS_MeshNode* VertexNode(const TopoDS_Vertex& V, + const SMESHDS_SubMesh* edgeSM, + const SMESH_Mesh* mesh, + const bool checkV=true); + enum EMeshError { MEr_OK = 0, MEr_HOLES, MEr_BAD_ORI, MEr_EMPTY }; /*! @@ -385,9 +439,12 @@ public: protected: + const SMESH_HypoFilter * _compatibleAllHypFilter; + const SMESH_HypoFilter * _compatibleNoAuxHypFilter; std::vector _compatibleHypothesis; std::list _appliedHypList; std::list _usedHypList; + // Algo features influencing which Compute() and how is called: // in what turn and with what input shape. @@ -396,7 +453,7 @@ protected: bool _requireDiscreteBoundary;// GetDim()-1 mesh must be present. Default TRUE bool _requireShape; // work with GetDim()-1 mesh bound to geom only. Default TRUE bool _supportSubmeshes; // if !_requireDiscreteBoundary. Default FALSE - bool _neededLowerHyps[4]; // hyp dims needed by algo that !NeedDiscreteBoundary(). Df. FALSE + bool _neededLowerHyps[4]; // hyp dims needed by algo that !_requireDiscreteBoundary. Df. FALSE // indicates if quadratic mesh creation is required, // is usually set like this: _quadraticMesh = SMESH_MesherHelper::IsQuadraticSubMesh(shape) @@ -407,8 +464,14 @@ protected: std::list _badInputElements; //!< to explain COMPERR_BAD_INPUT_MESH volatile bool _computeCanceled; //!< is set to True while computing to stop it + + double _progress; /* progress of Compute() [0.,1.], + to be set by an algo really tracking the progress */ + int _progressTic; // counter of calls from SMESH_Mesh::GetComputeProgress() + std::vector _smToCompute; // sub-meshes to Compute() }; + class SMESH_EXPORT SMESH_0D_Algo: public SMESH_Algo { public: @@ -425,6 +488,13 @@ class SMESH_EXPORT SMESH_2D_Algo: public SMESH_Algo { public: SMESH_2D_Algo(int hypId, int studyId, SMESH_Gen* gen); + /*! + * \brief Method in which an algorithm generating a structured mesh + * fixes positions of in-face nodes after there movement + * due to insertion of viscous layers. + */ + virtual bool FixInternalNodes(const SMESH_ProxyMesh& mesh, + const TopoDS_Face& face); }; class SMESH_EXPORT SMESH_3D_Algo: public SMESH_Algo