]> SALOME platform Git repositories - modules/shaper.git/blob - src/XAO/XAO_BrepGeometry.cxx
Salome HOME
Fixed validators for Boolean and Intersection
[modules/shaper.git] / src / XAO / XAO_BrepGeometry.cxx
1 // Copyright (C) 2013-2015  CEA/DEN, EDF R&D, OPEN CASCADE
2 //
3 // This library is free software; you can redistribute it and/or
4 // modify it under the terms of the GNU Lesser General Public
5 // License as published by the Free Software Foundation; either
6 // version 2.1 of the License, or (at your option) any later version.
7 //
8 // This library is distributed in the hope that it will be useful,
9 // but WITHOUT ANY WARRANTY; without even the implied warranty of
10 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
11 // Lesser General Public License for more details.
12 //
13 // You should have received a copy of the GNU Lesser General Public
14 // License along with this library; if not, write to the Free Software
15 // Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
16 //
17 // See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
18 //
19 // Author : Frederic Pons (OpenCascade)
20
21 #include <cassert>
22
23 #include <Standard_TypeMismatch.hxx>
24
25 #include <BRepTools.hxx>
26 #include <BRep_Builder.hxx>
27 #include <TopAbs.hxx>
28 #include <TopTools_MapOfShape.hxx>
29 #include <TopTools_ListOfShape.hxx>
30 #include <TopTools_ListIteratorOfListOfShape.hxx>
31 #include <TopTools_IndexedMapOfShape.hxx>
32 #include <TopExp.hxx>
33 #include <TopExp_Explorer.hxx>
34 #include <GProp_GProps.hxx>
35 #include <BRepGProp.hxx>
36 #include <TopoDS.hxx>
37 #include <TopoDS_Vertex.hxx>
38
39 #include "XAO_BrepGeometry.hxx"
40 #include "XAO_XaoUtils.hxx"
41
42 using namespace XAO;
43
44 BrepGeometry::BrepGeometry() : Geometry("")
45 {
46 }
47
48 BrepGeometry::BrepGeometry(const std::string& name) : Geometry(name)
49 {
50 }
51
52 const std::string BrepGeometry::getShapeString()
53 {
54     std::ostringstream streamShape;
55     BRepTools::Write(m_shape, streamShape);
56     return streamShape.str();
57 }
58
59 void BrepGeometry::setShapeString(const std::string& shape)
60 {
61     std::istringstream streamBrep(shape.c_str());
62     BRep_Builder builder;
63     BRepTools::Read(m_shape, streamBrep, builder);
64
65     initIds();
66 }
67
68 TopoDS_Shape BrepGeometry::getTopoDS_Shape()
69 {
70     return m_shape;
71 }
72
73 void BrepGeometry::setTopoDS_Shape(const TopoDS_Shape& shape)
74 {
75     m_shape = shape;
76     initIds();
77 }
78
79 void BrepGeometry::initIds()
80 {
81     // intialization of Ids
82     initListIds(TopAbs_VERTEX, m_vertices);
83     initListIds(TopAbs_EDGE, m_edges);
84     initListIds(TopAbs_FACE, m_faces);
85     initListIds(TopAbs_SOLID, m_solids);
86 }
87
88 void BrepGeometry::initListIds(const TopAbs_ShapeEnum& shapeType, GeometricElementList& eltList)
89 {
90     TopTools_MapOfShape mapShape;
91     TopTools_ListOfShape listShape;
92
93     int nbElt = 0;
94     TopExp_Explorer exp(m_shape, shapeType);
95     for (; exp.More(); exp.Next())
96     {
97         if (mapShape.Add(exp.Current()))
98         {
99             listShape.Append(exp.Current());
100             nbElt++;
101         }
102     }
103
104     if (listShape.IsEmpty())
105         return;
106
107     TopTools_IndexedMapOfShape indices;
108     TopExp::MapShapes(m_shape, indices);
109
110     eltList.setSize(nbElt);
111     TopTools_ListIteratorOfListOfShape itSub(listShape);
112     for (int index = 0; itSub.More(); itSub.Next(), ++index)
113     {
114         TopoDS_Shape value = itSub.Value();
115         int ref = indices.FindIndex(value);
116         eltList.setReference(index, XaoUtils::intToString(ref));
117     }
118 }
119
120 TopoDS_Shape BrepGeometry::getSubShape(const TopoDS_Shape& mainShape, const TopAbs_ShapeEnum& shapeType, const int& shapeIndex)
121 throw (XAO_Exception)
122 {
123     TopTools_MapOfShape mapShape;
124     TopTools_ListOfShape listShape;
125
126     TopExp_Explorer exp(mainShape, shapeType);
127     for (; exp.More(); exp.Next())
128     {
129         if (mapShape.Add(exp.Current()))
130             listShape.Append(exp.Current());
131     }
132
133     if (!listShape.IsEmpty())
134     {
135         TopTools_ListIteratorOfListOfShape itSub(listShape);
136         for (int index = 0; itSub.More(); itSub.Next(), ++index)
137         {
138             if (shapeIndex == index)
139             {
140                 TopoDS_Shape value = itSub.Value();
141                 return value;
142             }
143         }
144     }
145
146     throw XAO_Exception(MsgBuilder() << "Shape with reference [" << shapeIndex << "]  not found.");
147 }
148
149 // -----------------------------
150 const int BrepGeometry::countGeometricalElements(const TopoDS_Shape& shape, const TopAbs_ShapeEnum& shapeType)
151 {
152     int res = 0;
153     TopExp_Explorer exp(shape, shapeType);
154     for (; exp.More(); exp.Next())
155         res++;
156
157     return res;
158 }
159
160 std::vector<int> BrepGeometry::getGeometricalElements(const TopoDS_Shape& shape, const TopAbs_ShapeEnum& shapeType, const XAO::Dimension& dim)
161 {
162     std::vector<int> indexList;
163
164     TopTools_MapOfShape mapShape;
165     TopTools_ListOfShape listShape;
166
167     TopExp_Explorer exp(shape, shapeType);
168     for (; exp.More(); exp.Next())
169     {
170         if (mapShape.Add(exp.Current()))
171             listShape.Append(exp.Current());
172     }
173
174     if (!listShape.IsEmpty())
175     {
176         // use the shape of the geometry for the indices
177         TopTools_IndexedMapOfShape indices;
178         TopExp::MapShapes(m_shape, indices);
179
180         TopTools_ListIteratorOfListOfShape itSub(listShape);
181         for (int index = 0; itSub.More(); itSub.Next(), ++index)
182         {
183             TopoDS_Shape value = itSub.Value();
184             int id = indices.FindIndex(value);
185             indexList.push_back(findElement(dim, id));
186         }
187     }
188
189     return indexList;
190 }
191
192 void BrepGeometry::getEdgeVertices(const int& edgeIndex, int& vertexA, int& vertexB)
193 {
194     TopoDS_Shape edge = getSubShape(m_shape, TopAbs_EDGE, edgeIndex);
195     std::vector<int> vertices = getGeometricalElements(edge, TopAbs_VERTEX, XAO::VERTEX);
196     assert(vertices.size() == 2);
197
198     vertexA = vertices[0];
199     vertexB = vertices[1];
200 }
201
202 const int BrepGeometry::countFaceWires(const int& faceIndex)
203 {
204     TopoDS_Shape face = getSubShape(m_shape, TopAbs_FACE, faceIndex);
205     return countGeometricalElements(face, TopAbs_WIRE);
206 }
207
208 std::vector<int> BrepGeometry::getFaceEdges(const int& faceIndex, const int& wireIndex)
209 {
210     // get the face
211     TopoDS_Shape face = getSubShape(m_shape, TopAbs_FACE, faceIndex);
212     // get the wire
213     TopoDS_Shape wire = getSubShape(face, TopAbs_WIRE, wireIndex);
214     return getGeometricalElements(wire, TopAbs_EDGE, XAO::EDGE);
215 }
216
217 const int BrepGeometry::countSolidShells(const int& solidIndex)
218 {
219     TopoDS_Shape solid = getSubShape(m_shape, TopAbs_SOLID, solidIndex);
220     return countGeometricalElements(solid, TopAbs_SHELL);
221 }
222
223 std::vector<int> BrepGeometry::getSolidFaces(const int& solidIndex, const int& shellIndex)
224 {
225     TopoDS_Shape solid = getSubShape(m_shape, TopAbs_SOLID, solidIndex);
226     TopoDS_Shape shell = getSubShape(solid, TopAbs_SHELL, shellIndex);
227     return getGeometricalElements(shell, TopAbs_FACE, XAO::FACE);
228 }
229
230 void BrepGeometry::getVertexXYZ(const int& vertexIndex, double& xCoord, double& yCoord, double& zCoord)
231 throw (XAO_Exception)
232 {
233     xCoord = 0.;
234     yCoord = 0.;
235     zCoord = 0.;
236
237     TopoDS_Shape vertex = getSubShape(m_shape, TopAbs_VERTEX, vertexIndex);
238     if (vertex.ShapeType() != TopAbs_VERTEX)
239         throw XAO_Exception(MsgBuilder() << "Shape " << vertexIndex<< " is not a point.");
240
241     TopoDS_Vertex point = TopoDS::Vertex(vertex);
242     if (!point.IsNull())
243     {
244         gp_Pnt aPnt = BRep_Tool::Pnt(point);
245         xCoord = aPnt.X();
246         yCoord = aPnt.Y();
247         zCoord = aPnt.Z();
248     }
249 }
250
251 // -----------------------------
252 const double BrepGeometry::getEdgeLength(const int& edgeIndex)
253 {
254     TopoDS_Shape edge = getSubShape(m_shape, TopAbs_EDGE, edgeIndex);
255     GProp_GProps system;
256     BRepGProp::LinearProperties(edge, system);
257     return system.Mass();
258 }
259
260 const double BrepGeometry::getFaceArea(const int& faceIndex)
261 {
262     TopoDS_Shape face = getSubShape(m_shape, TopAbs_FACE, faceIndex);
263     GProp_GProps system;
264     BRepGProp::SurfaceProperties(face, system);
265     return system.Mass();
266 }
267
268 const double BrepGeometry::getSolidVolume(const int& solidIndex)
269 {
270     TopoDS_Shape solid = getSubShape(m_shape, TopAbs_SOLID, solidIndex);
271     GProp_GProps system;
272     BRepGProp::VolumeProperties(solid, system);
273     return system.Mass();
274 }
275
276 // -----------------------------
277 const int BrepGeometry::getVertexID(const int& index)
278 {
279     return XaoUtils::stringToInt(getVertexReference(index));
280 }
281
282 const int BrepGeometry::getEdgeID(const int& index)
283 {
284     return XaoUtils::stringToInt(getEdgeReference(index));
285 }
286
287 const int BrepGeometry::getFaceID(const int& index)
288 {
289     return XaoUtils::stringToInt(getFaceReference(index));
290 }
291
292 const int BrepGeometry::getSolidID(const int& index)
293 {
294     return XaoUtils::stringToInt(getSolidReference(index));
295 }
296
297 // -----------------------------
298 void BrepGeometry::setVertexID(const int& index, const int& id)
299 {
300     setVertexReference(index, XaoUtils::intToString(id));
301 }
302
303 void BrepGeometry::setEdgeID(const int& index, const int& id)
304 {
305     setEdgeReference(index, XaoUtils::intToString(id));
306 }
307
308 void BrepGeometry::setFaceID(const int& index, const int& id)
309 {
310     setEdgeReference(index, XaoUtils::intToString(id));
311 }
312
313 void BrepGeometry::setSolidID(const int& index, const int& id)
314 {
315     setEdgeReference(index, XaoUtils::intToString(id));
316 }
317
318 // -----------------------------
319 const int BrepGeometry::findElement(const XAO::Dimension& dim, const int& id)
320 throw (XAO_Exception)
321 {
322     if (dim == XAO::VERTEX)
323         return findVertex(id);
324     if (dim == XAO::EDGE)
325         return findEdge(id);
326     if (dim == XAO::FACE)
327         return findFace(id);
328     if (dim == XAO::SOLID)
329         return findSolid(id);
330
331     throw XAO_Exception(MsgBuilder() << "Unknown Dimension: " << dim);
332 }
333
334 const int BrepGeometry::findVertex(const int& id)
335 {
336     return getVertexIndexByReference(XaoUtils::intToString(id));
337 }
338
339 const int BrepGeometry::findEdge(const int& id)
340 {
341     return getEdgeIndexByReference(XaoUtils::intToString(id));
342 }
343
344 const int BrepGeometry::findFace(const int& id)
345 {
346     return getFaceIndexByReference(XaoUtils::intToString(id));
347 }
348
349 const int BrepGeometry::findSolid(const int& id)
350 {
351     return getSolidIndexByReference(XaoUtils::intToString(id));
352 }
353
354 // -----------------------------
355 const std::string BrepGeometry::findVertexName(const int& id)
356 {
357     return getVertexName(findVertex(id));
358 }
359
360 const std::string BrepGeometry::findEdgeName(const int& id)
361 {
362     return getEdgeName(findEdge(id));
363 }
364
365 const std::string BrepGeometry::findFaceName(const int& id)
366 {
367     return getFaceName(findFace(id));
368 }
369
370 const std::string BrepGeometry::findSolidName(const int& id)
371 {
372     return getSolidName(findSolid(id));
373 }
374
375 // -----------------------------
376 void BrepGeometry::changeVertexName(const int& id, const std::string& name)
377 throw (XAO_Exception)
378 {
379     setVertexName(findVertex(id), name);
380 }
381
382 void BrepGeometry::changeEdgeName(const int& id, const std::string& name)
383 throw (XAO_Exception)
384 {
385     setEdgeName(findEdge(id), name);
386 }
387
388 void BrepGeometry::changeFaceName(const int& id, const std::string& name)
389 throw (XAO_Exception)
390 {
391     setFaceName(findFace(id), name);
392 }
393
394 void BrepGeometry::changeSolidName(const int& id, const std::string& name)
395 throw (XAO_Exception)
396 {
397     setSolidName(findSolid(id), name);
398 }