X-Git-Url: http://git.salome-platform.org/gitweb/?a=blobdiff_plain;f=src%2FSMESH%2FSMESH_Mesh.hxx;h=8ba8f082cfe5977fce80c97afea904a983d1497c;hb=78fb42dc3ea751d55039317d05b7e96ff86c0931;hp=ef0090d2a0192447b9fd56b9f5a0cb5e3e5b22ae;hpb=789d7f7415a1e465aee36232e7633eea548ff1fb;p=modules%2Fsmesh.git

diff --git a/src/SMESH/SMESH_Mesh.hxx b/src/SMESH/SMESH_Mesh.hxx
index ef0090d2a..8ba8f082c 100644
--- a/src/SMESH/SMESH_Mesh.hxx
+++ b/src/SMESH/SMESH_Mesh.hxx
@@ -17,7 +17,7 @@
 //  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 
+// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
 //
 //
 //
@@ -29,137 +29,243 @@
 #ifndef _SMESH_MESH_HXX_
 #define _SMESH_MESH_HXX_
 
-#include "SMESHDS_Document.hxx"
-#include "SMESHDS_Mesh.hxx"
+#include "SMESH_SMESH.hxx"
+
 #include "SMESH_Hypothesis.hxx"
-#include "SMESH_subMesh.hxx"
-#include "SMESHDS_ListOfCommand.hxx"
-//#include "SMESHDS_ListOfAsciiString.hxx"
-//#include "SMESHDS_ListIteratorOfListOfAsciiString.hxx"
 
+#include "SMESHDS_Mesh.hxx"
+#include "SMESHDS_Command.hxx"
+#include "SMDSAbs_ElementType.hxx"
 
 #include "Utils_SALOME_Exception.hxx"
 
-#include <TopExp.hxx>
-#include <TopExp_Explorer.hxx>
-#include <TopoDS.hxx>
-#include <TopoDS_Iterator.hxx>
-#include <TopoDS_Compound.hxx>
-#include <TopoDS_CompSolid.hxx>
-#include <TopoDS_Solid.hxx>
-#include <TopoDS_Shell.hxx>
-#include <TopoDS_Face.hxx>
-#include <TopoDS_Wire.hxx>
-#include <TopoDS_Edge.hxx>
-#include <TopoDS_Vertex.hxx>
 #include <TopoDS_Shape.hxx>
-#include <TopTools_IndexedMapOfShape.hxx>
+#include <TopTools_IndexedDataMapOfShapeListOfShape.hxx>
 
-#include <vector>
 #include <list>
 #include <map>
 
 class SMESH_Gen;
+class SMESHDS_Document;
+class SMESH_Group;
+class TopTools_ListOfShape;
+class SMESH_subMesh;
+class SMESH_HypoFilter;
+class TopoDS_Solid;
 
-class SMESH_Mesh
+class SMESH_EXPORT SMESH_Mesh
 {
 public:
-  SMESH_Mesh();
-  SMESH_Mesh(int localId,
-	     int studyId,
-	     SMESH_Gen* gen,
-	     const Handle(SMESHDS_Document)& myDocument);
-
+  SMESH_Mesh(int               theLocalId, 
+	     int               theStudyId, 
+	     SMESH_Gen*        theGen,
+	     bool              theIsEmbeddedMode,
+	     SMESHDS_Document* theDocument);
+  
   virtual ~SMESH_Mesh();
+  
+  /*!
+   * \brief Set geometry to be meshed
+   */
+  void ShapeToMesh(const TopoDS_Shape & aShape);
+  /*!
+   * \brief Return geometry to be meshed. (It may be a PseudoShape()!)
+   */
+  TopoDS_Shape GetShapeToMesh() const;
+  /*!
+   * \brief Return true if there is a geometry to be meshed, not PseudoShape()
+   */
+  bool HasShapeToMesh() const { return _isShapeToMesh; }
+  /*!
+   * \brief Return a solid which is returned by GetShapeToMesh() if
+   *        a real geometry to be meshed was not set
+   */
+  static const TopoDS_Solid& PseudoShape();
 
-  void ShapeToMesh(const TopoDS_Shape& aShape)
-    throw (SALOME_Exception);
-
-  bool AddHypothesis(const TopoDS_Shape& aSubShape,
-		     int anHypId)
-    throw (SALOME_Exception);
+  /*!
+   * \brief Remove all nodes and elements
+   */
+  void Clear();
 
-  bool RemoveHypothesis(const TopoDS_Shape& aSubShape,
-			int anHypId)
-    throw (SALOME_Exception);
+  /*!
+   * \brief Remove all nodes and elements of indicated shape
+   */
+  void ClearSubMesh(const int theShapeId);
 
-  const list<SMESHDS_Hypothesis*>&
-  GetHypothesisList(const TopoDS_Shape& aSubShape)
-    throw (SALOME_Exception);
+  int UNVToMesh(const char* theFileName);
+  /*!
+   * consult DriverMED_R_SMESHDS_Mesh::ReadStatus for returned value
+   */
+  int MEDToMesh(const char* theFileName, const char* theMeshName);
+  
+  int STLToMesh(const char* theFileName);
 
-  const SMESHDS_ListOfCommand& GetLog()
-    throw (SALOME_Exception);
+  SMESH_Hypothesis::Hypothesis_Status
+  AddHypothesis(const TopoDS_Shape & aSubShape, int anHypId)
+    throw(SALOME_Exception);
+  
+  SMESH_Hypothesis::Hypothesis_Status
+  RemoveHypothesis(const TopoDS_Shape & aSubShape, int anHypId)
+    throw(SALOME_Exception);
+  
+  const std::list <const SMESHDS_Hypothesis * >&
+  GetHypothesisList(const TopoDS_Shape & aSubShape) const
+    throw(SALOME_Exception);
 
-//   const SMESHDS_ListOfAsciiString& GetLog()
-//     throw (SALOME_Exception);
+  const SMESH_Hypothesis * GetHypothesis(const TopoDS_Shape &    aSubShape,
+                                         const SMESH_HypoFilter& aFilter,
+                                         const bool              andAncestors,
+                                         TopoDS_Shape*           assignedTo=0) const;
+  
+  int GetHypotheses(const TopoDS_Shape &                     aSubShape,
+                    const SMESH_HypoFilter&                  aFilter,
+                    std::list <const SMESHDS_Hypothesis * >& aHypList,
+                    const bool                               andAncestors) const;
 
-  void ClearLog()
-    throw (SALOME_Exception);
+  const std::list<SMESHDS_Command*> & GetLog() throw(SALOME_Exception);
+  
+  void ClearLog() throw(SALOME_Exception);
+  
+  int GetId()                { return _id; }
+  
+  SMESHDS_Mesh * GetMeshDS() { return _myMeshDS; }
+  
+  SMESH_Gen *GetGen()        { return _gen; }
+  
+  SMESH_subMesh *GetSubMesh(const TopoDS_Shape & aSubShape)
+    throw(SALOME_Exception);
+  
+  SMESH_subMesh *GetSubMeshContaining(const TopoDS_Shape & aSubShape) const
+    throw(SALOME_Exception);
+  
+  SMESH_subMesh *GetSubMeshContaining(const int aShapeID) const
+    throw(SALOME_Exception);
+  /*!
+   * \brief Return submeshes of groups containing the given subshape
+   */
+  std::list<SMESH_subMesh*> GetGroupSubMeshesContaining(const TopoDS_Shape & shape) const
+    throw(SALOME_Exception);
+  /*!
+   * \brief Say all submeshes that theChangedHyp has been modified
+   */
+  void NotifySubMeshesHypothesisModification(const SMESH_Hypothesis* theChangedHyp);
 
-  int GetId();
- 
-  const Handle(SMESHDS_Mesh)& GetMeshDS();
+  const std::list < SMESH_subMesh * >&
+  GetSubMeshUsingHypothesis(SMESHDS_Hypothesis * anHyp) throw(SALOME_Exception);
+  /*!
+   * \brief Return True if anHyp is used to mesh aSubShape
+   */
+  bool IsUsedHypothesis(SMESHDS_Hypothesis *  anHyp,
+			const SMESH_subMesh * aSubMesh);
+  /*!
+   * \brief check if a hypothesis alowing notconform mesh is present
+   */
+  bool IsNotConformAllowed() const;
+  
+  bool IsMainShape(const TopoDS_Shape& theShape) const;
+  /*!
+   * \brief Return list of ancestors of theSubShape in the order
+   *        that lower dimention shapes come first
+   */
+  const TopTools_ListOfShape& GetAncestors(const TopoDS_Shape& theSubShape) const;
 
-  SMESH_Gen* GetGen();
+  void SetAutoColor(bool theAutoColor) throw(SALOME_Exception);
 
-  SMESH_subMesh* GetSubMesh(const TopoDS_Shape & aSubShape)
-    throw (SALOME_Exception);
+  bool GetAutoColor() throw(SALOME_Exception);
 
-  SMESH_subMesh* GetSubMeshContaining(const TopoDS_Shape & aSubShape)
-    throw (SALOME_Exception);
+  /*!
+   * \brief Return data map of descendant to ancestor shapes
+   */
+  typedef TopTools_IndexedDataMapOfShapeListOfShape TAncestorMap;
+  const TAncestorMap& GetAncestorMap() const { return _mapAncestors; }
+  /*!
+   * \brief Check group names for duplications.
+   *  Consider maximum group name length stored in MED file
+   */
+  bool HasDuplicatedGroupNamesMED();
 
-  const list <SMESH_subMesh*>&
-  GetSubMeshUsingHypothesis(SMESHDS_Hypothesis* anHyp)
-    throw (SALOME_Exception);
+  void ExportMED(const char *file, 
+		 const char* theMeshName = NULL, 
+		 bool theAutoGroups = true, 
+		 int theVersion = 0) 
+    throw(SALOME_Exception);
 
-  void ExportDAT( const char* file )
-    throw (SALOME_Exception);
-  void ExportMED( const char* file )
-    throw (SALOME_Exception);
-  void ExportUNV( const char* file )
-    throw (SALOME_Exception);
-    
-  int NbNodes()
-    throw (SALOME_Exception);
+  void ExportDAT(const char *file) throw(SALOME_Exception);
+  void ExportUNV(const char *file) throw(SALOME_Exception);
+  void ExportSTL(const char *file, const bool isascii) throw(SALOME_Exception);
   
-  int NbEdges()
-    throw (SALOME_Exception);
+  int NbNodes() throw(SALOME_Exception);
   
-  int NbFaces()
-    throw (SALOME_Exception);
+  int NbEdges(SMDSAbs_ElementOrder order = ORDER_ANY) throw(SALOME_Exception);
+  
+  int NbFaces(SMDSAbs_ElementOrder order = ORDER_ANY) throw(SALOME_Exception);
+  
+  int NbTriangles(SMDSAbs_ElementOrder order = ORDER_ANY) throw(SALOME_Exception);
+  
+  int NbQuadrangles(SMDSAbs_ElementOrder order = ORDER_ANY) throw(SALOME_Exception);
 
-  int NbTriangles()
-    throw (SALOME_Exception);
+  int NbPolygons() throw(SALOME_Exception);
+  
+  int NbVolumes(SMDSAbs_ElementOrder order = ORDER_ANY) throw(SALOME_Exception);
+  
+  int NbTetras(SMDSAbs_ElementOrder order = ORDER_ANY) throw(SALOME_Exception);
+  
+  int NbHexas(SMDSAbs_ElementOrder order = ORDER_ANY) throw(SALOME_Exception);
+  
+  int NbPyramids(SMDSAbs_ElementOrder order = ORDER_ANY) throw(SALOME_Exception);
 
-  int NbQuadrangles()
-    throw (SALOME_Exception);
+  int NbPrisms(SMDSAbs_ElementOrder order = ORDER_ANY) throw(SALOME_Exception);
+  
+  int NbPolyhedrons() throw(SALOME_Exception);
+  
+  int NbSubMesh() throw(SALOME_Exception);
+  
+  int NbGroup() const { return _mapGroup.size(); }
   
-  int NbVolumes()
-    throw (SALOME_Exception);
+  SMESH_Group* AddGroup (const SMDSAbs_ElementType theType,
+			 const char*               theName,
+			 int&                      theId,
+                         const TopoDS_Shape&       theShape=TopoDS_Shape());
+  
+  typedef boost::shared_ptr< SMDS_Iterator<SMESH_Group*> > GroupIteratorPtr;
+  GroupIteratorPtr GetGroups() const;
+  
+  std::list<int> GetGroupIds() const;
+  
+  SMESH_Group* GetGroup (const int theGroupID);
+
+  void RemoveGroup (const int theGroupID);
+
+  SMESH_Group* ConvertToStandalone ( int theGroupID );
 
-  int NbTetras()
-    throw (SALOME_Exception);
+  SMDSAbs_ElementType GetElementType( const int id, const bool iselem );
 
-  int NbHexas()
-    throw (SALOME_Exception);
+  //
   
-  int NbSubMesh()
-    throw (SALOME_Exception);
+  ostream& Dump(ostream & save);
   
-
 private:
+  
+protected:
+  int                        _id;           // id given by creator (unique within the creator instance)
+  int                        _studyId;
+  int                        _idDoc;        // id given by SMESHDS_Document
+  int                        _groupId;      // id generator for group objects
+  bool                       _isShapeToMesh;// set to true when a shape is given (only once)
+  std::list <SMESH_subMesh*> _subMeshesUsingHypothesisList;
+  SMESHDS_Document *         _myDocument;
+  SMESHDS_Mesh *             _myMeshDS;
+  std::map <int, SMESH_subMesh*> _mapSubMesh;
+  std::map <int, SMESH_Group*>   _mapGroup;
+  SMESH_Gen *                _gen;
+
+  bool                       _isAutoColor;
+  
+  TopTools_IndexedDataMapOfShapeListOfShape _mapAncestors;
 
-  int _id;          // id given by creator (unique within the creator instance)
-  int _studyId;
-  int _idDoc;       // id given by SMESHDS_Document
-  bool _isShapeToMesh; // set to true when a shape is given (only once)
-  list<SMESHDS_Hypothesis*> _subShapeHypothesisList;
-  list<SMESH_subMesh*> _subMeshesUsingHypothesisList;
-  Handle (SMESHDS_Document) _myDocument;
-  Handle (SMESHDS_Mesh) _myMeshDS;
-  TopTools_IndexedMapOfShape _subShapes;
-  map<int, SMESH_subMesh*> _mapSubMesh;
-  SMESH_Gen* _gen;
+protected:
+  SMESH_Mesh() {};
+  SMESH_Mesh(const SMESH_Mesh&) {};
 };
 
 #endif