0027562: Coding - avoid exporting of inline methods
[occt.git] / src / BRepMesh / BRepMesh_DataStructureOfDelaun.hxx
1 // Copyright (c) 2013 OPEN CASCADE SAS
2 //
3 // This file is part of Open CASCADE Technology software library.
4 //
5 // This library is free software; you can redistribute it and/or modify it under
6 // the terms of the GNU Lesser General Public License version 2.1 as published
7 // by the Free Software Foundation, with special exception defined in the file
8 // OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
9 // distribution for complete text of the license and disclaimer of any warranty.
10 //
11 // Alternatively, this file may be used under the terms of Open CASCADE
12 // commercial license or contractual agreement.
13
14 #ifndef _BRepMesh_DataStructureOfDelaun_HeaderFile
15 #define _BRepMesh_DataStructureOfDelaun_HeaderFile
16
17 #include <Standard.hxx>
18 #include <Standard_Type.hxx>
19 #include <BRepMesh_VertexTool.hxx>
20 #include <Standard_Transient.hxx>
21 #include <BRepMesh_Triangle.hxx>
22 #include <BRepMesh_PairOfIndex.hxx>
23 #include <Standard_OStream.hxx>
24 #include <BRepMesh.hxx>
25
26 class BRepMesh_Vertex;
27 class BRepMesh_VertexTool;
28 class BRepMesh_Edge;
29
30 //! Describes the data structure necessary for the mesh algorithms in 
31 //! two dimensions plane or on surface by meshing in UV space.
32 class BRepMesh_DataStructureOfDelaun : public Standard_Transient
33 {
34 public:
35
36   //! Constructor.
37   //! @param theAllocator memory allocator to be used by internal structures.
38   //! @param theReservedNodeSize presumed number of nodes in this mesh.
39   Standard_EXPORT BRepMesh_DataStructureOfDelaun(
40     const Handle(NCollection_IncAllocator)& theAllocator,
41     const Standard_Integer                  theReservedNodeSize = 100);
42
43
44
45 public: //! @name API for accessing mesh nodes.
46
47   //! Returns number of nodes.
48   inline Standard_Integer NbNodes() const
49   {
50     return myNodes->Extent();
51   }
52
53
54   //! Adds node to the mesh if it is not already in the mesh.
55   //! @param theNode node to be added to the mesh.
56   //! @param isForceAdd adds the given node to structure without 
57   //! checking on coincidence with other nodes.
58   //! @return index of the node in the structure.
59   Standard_EXPORT Standard_Integer AddNode(
60     const BRepMesh_Vertex& theNode,
61     const Standard_Boolean isForceAdd = Standard_False);
62
63   //! Finds the index of the given node.
64   //! @param theNode node to find.
65   //! @return index of the given element of zero if node is not in the mesh.
66   Standard_Integer IndexOf(const BRepMesh_Vertex& theNode)
67   {
68     return myNodes->FindIndex(theNode);
69   }
70
71   //! Get node by the index.
72   //! @param theIndex index of a node.
73   //! @return node with the given index.
74   inline const BRepMesh_Vertex& GetNode(const Standard_Integer theIndex)
75   {
76     return myNodes->FindKey(theIndex);
77   }
78
79   //! Alias for GetNode.
80   const BRepMesh_Vertex& operator ()(const Standard_Integer theIndex)
81   {
82     return GetNode(theIndex);
83   }
84
85   //! Substitutes the node with the given index by new one.
86   //! @param theIndex index of node to be substituted.
87   //! @param theNewNode substituting node.
88   //! @return FALSE in case if new node is already in the structure, TRUE elsewhere.
89   Standard_EXPORT Standard_Boolean SubstituteNode(
90     const Standard_Integer theIndex,
91     const BRepMesh_Vertex& theNewNode);
92
93   //! Removes node from the mesh in case if it has no connected links 
94   //! and its type is Free.
95   //! @param theIndex index of node to be removed.
96   //! @param isForce if TRUE node will be removed even if movability
97   //! is not Free.
98   void RemoveNode(const Standard_Integer theIndex,
99                   const Standard_Boolean isForce = Standard_False)
100   {
101     if (isForce || myNodes->FindKey(theIndex).Movability() == BRepMesh_Free)
102     {
103       if (LinksConnectedTo(theIndex).Extent()==0)
104         myNodes->Delete(theIndex);
105     }
106   }
107
108   //! Get list of links attached to the node with the given index.
109   //! @param theIndex index of node whose links should be retrieved.
110   //! @return list of links attached to the node.
111   inline const BRepMesh::ListOfInteger& LinksConnectedTo(
112     const Standard_Integer theIndex) const
113   {
114     return linksConnectedTo(theIndex);
115   }
116
117
118 public: //! @name API for accessing mesh links.
119
120   //! Returns number of links.
121   inline Standard_Integer NbLinks() const
122   {
123     return myLinks.Extent();
124   }
125
126   //! Adds link to the mesh if it is not already in the mesh.
127   //! @param theLink link to be added to the mesh.
128   //! @return index of the link in the structure.
129   Standard_EXPORT Standard_Integer AddLink(const BRepMesh_Edge& theLink);
130
131   //! Finds the index of the given link.
132   //! @param theLink link to find.
133   //! @return index of the given element of zero if link is not in the mesh.
134   Standard_Integer IndexOf(const BRepMesh_Edge& theLink) const
135   {
136     return myLinks.FindIndex(theLink);
137   }
138
139   //! Get link by the index.
140   //! @param theIndex index of a link.
141   //! @return link with the given index.
142   const BRepMesh_Edge& GetLink(const Standard_Integer theIndex)
143   {
144     return myLinks.FindKey(theIndex);
145   }
146
147   //! Returns map of indices of links registered in mesh.
148   inline const BRepMesh::MapOfInteger& LinksOfDomain() const
149   {
150     return myLinksOfDomain;
151   }
152
153   //! Substitutes the link with the given index by new one.
154   //! @param theIndex index of link to be substituted.
155   //! @param theNewLink substituting link.
156   //! @return FALSE in case if new link is already in the structure, TRUE elsewhere.
157   Standard_EXPORT Standard_Boolean SubstituteLink(const Standard_Integer theIndex,
158                                                   const BRepMesh_Edge&   theNewLink);
159
160   //! Removes link from the mesh in case if it has no connected elements 
161   //! and its type is Free.
162   //! @param theIndex index of link to be removed.
163   //! @param isForce if TRUE link will be removed even if movability
164   //! is not Free.
165   Standard_EXPORT void RemoveLink(const Standard_Integer theIndex,
166                                   const Standard_Boolean isForce = Standard_False);
167
168   //! Returns indices of elements conected to the link with the given index.
169   //! @param theLinkIndex index of link whose data should be retrieved.
170   //! @return indices of elements conected to the link.
171   const BRepMesh_PairOfIndex& ElementsConnectedTo(
172     const Standard_Integer theLinkIndex) const
173   {
174     return myLinks.FindFromIndex(theLinkIndex);
175   }
176
177
178
179 public: //! @name API for accessing mesh elements.
180
181   //! Returns number of links.
182   inline Standard_Integer NbElements() const
183   {
184     return myElements.Extent();
185   }
186
187   //! Adds element to the mesh if it is not already in the mesh.
188   //! @param theElement element to be added to the mesh.
189   //! @return index of the element in the structure.
190   Standard_EXPORT Standard_Integer AddElement(const BRepMesh_Triangle& theElement);
191
192   //! Finds the index of the given element.
193   //! @param theElement element to find.
194   //! @return index of the given element of zero if element is not in the mesh.
195   Standard_Integer IndexOf(const BRepMesh_Triangle& theElement) const
196   {
197     return myElements.FindIndex(theElement);
198   }
199
200   //! Get element by the index.
201   //! @param theIndex index of an element.
202   //! @return element with the given index.
203   const BRepMesh_Triangle& GetElement(const Standard_Integer theIndex)
204   {
205     return myElements.FindKey(theIndex);
206   }
207
208   //! Returns map of indices of elements registered in mesh.
209   inline const BRepMesh::MapOfInteger& ElementsOfDomain() const
210   {
211     return myElementsOfDomain;
212   }
213
214   //! Substitutes the element with the given index by new one.
215   //! @param theIndex index of element to be substituted.
216   //! @param theNewLink substituting element.
217   //! @return FALSE in case if new element is already in the structure, TRUE elsewhere.
218   Standard_EXPORT Standard_Boolean SubstituteElement(const Standard_Integer   theIndex,
219                                                      const BRepMesh_Triangle& theNewElement);
220
221   //! Removes element from the mesh.
222   //! @param theIndex index of element to be removed.
223   Standard_EXPORT void RemoveElement(const Standard_Integer theIndex);
224
225   //! Returns indices of nodes forming the given element.
226   //! @param theElement element which nodes should be retrieved.
227   //! @param[out] theNodes nodes of the given element.
228   Standard_EXPORT void ElementNodes(
229     const BRepMesh_Triangle& theElement,
230     Standard_Integer         (&theNodes)[3]);
231
232
233
234 public: //! @name Auxilary API
235
236   //! Dumps information about this structure.
237   //! @param theStream stream to be used for dump.
238   Standard_EXPORT void Statistics(Standard_OStream& theStream) const;
239   
240   //! Returns memory allocator used by the structure.
241   inline const Handle(NCollection_IncAllocator)& Allocator() const
242   {
243     return myAllocator;
244   }
245
246   //! Gives the data structure for initialization of cell size and tolerance.
247   inline BRepMesh::HVertexTool& Data()
248   {
249     return myNodes;
250   }
251
252   //! Removes all elements.
253   Standard_EXPORT void ClearDomain();
254
255   //! Substitutes deleted items by the last one from corresponding map 
256   //! to have only non-deleted elements, links or nodes in the structure.
257   void ClearDeleted()
258   {
259     clearDeletedLinks();
260     clearDeletedNodes();
261   }
262
263   DEFINE_STANDARD_RTTIEXT(BRepMesh_DataStructureOfDelaun,Standard_Transient)
264
265 private: 
266
267   //! Get list of links attached to the node with the given index.
268   //! @param theIndex index of node whose links should be retrieved.
269   //! @return list of links attached to the node.
270   inline BRepMesh::ListOfInteger& linksConnectedTo(
271     const Standard_Integer theIndex) const
272   {
273     return (BRepMesh::ListOfInteger&)myNodeLinks.Find(theIndex);
274   }
275
276   //! Substitutes deleted links by the last one from corresponding map 
277   //! to have only non-deleted links in the structure.
278   Standard_EXPORT void clearDeletedLinks();
279
280   //! Substitutes deleted nodes by the last one from corresponding map 
281   //! to have only non-deleted nodes in the structure.
282   Standard_EXPORT void clearDeletedNodes();
283
284   //! Cleans dependent structures from the given link.
285   //! @param theIndex index of link in the data structure.
286   //! @param theLink reference to the link to avoid double accessing 
287   //! to map of links.
288   void cleanLink(const Standard_Integer theIndex,
289                  const BRepMesh_Edge&   theLink);
290
291   //! Cleans dependent structures from the given element.
292   //! @param theIndex index of element in the data structure.
293   //! @param theElement reference to the element to avoid double accessing 
294   //! to map of elements.
295   void cleanElement(const Standard_Integer   theIndex,
296                     const BRepMesh_Triangle& theElement);
297
298   //! Removes element index from the given pair. Used by cleanElement.
299   //! @param theIndex index of element to be removed.
300   //! @param thePair pair of elements to be cleaned.
301   void removeElementIndex(const Standard_Integer theIndex,
302                           BRepMesh_PairOfIndex&  thePair);
303
304
305 private:
306
307   Handle(NCollection_IncAllocator)      myAllocator;
308   BRepMesh::HVertexTool                 myNodes;
309   BRepMesh::DMapOfIntegerListOfInteger  myNodeLinks;
310   BRepMesh::IDMapOfLink                 myLinks;
311   BRepMesh::ListOfInteger               myDelLinks;
312   BRepMesh::IMapOfElement               myElements;
313   BRepMesh::MapOfInteger                myElementsOfDomain;
314   BRepMesh::MapOfInteger                myLinksOfDomain;
315 };
316
317 DEFINE_STANDARD_HANDLE(BRepMesh_DataStructureOfDelaun,Standard_Transient)
318
319 #endif