]> SALOME platform Git repositories - modules/shaper.git/blob - src/GeomAPI/GeomAPI_Shape.cpp
Salome HOME
Reverted some changes in salome build/run scripts.
[modules/shaper.git] / src / GeomAPI / GeomAPI_Shape.cpp
1 // Copyright (C) 2014-2017  CEA/DEN, EDF R&D
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
18 // email : webmaster.salome@opencascade.com<mailto:webmaster.salome@opencascade.com>
19 //
20
21 #include "GeomAPI_Shape.h"
22
23 #include <GeomAPI_Pnt.h>
24 #include <GeomAPI_Vertex.h>
25 #include <GeomAPI_Edge.h>
26 #include <GeomAPI_Wire.h>
27 #include <GeomAPI_Face.h>
28 #include <GeomAPI_Shell.h>
29 #include <GeomAPI_Solid.h>
30
31 #include <BRep_Tool.hxx>
32 #include <BRepAlgoAPI_Section.hxx>
33 #include <BRepBndLib.hxx>
34 #include <BRepBuilderAPI_FindPlane.hxx>
35 #include <BRepExtrema_DistShapeShape.hxx>
36 #include <BRepTools.hxx>
37 #include <Bnd_Box.hxx>
38 #include <Geom_Circle.hxx>
39 #include <Geom_Conic.hxx>
40 #include <Geom_Curve.hxx>
41 #include <Geom_Ellipse.hxx>
42 #include <Geom_Hyperbola.hxx>
43 #include <Geom_Line.hxx>
44 #include <Geom_Parabola.hxx>
45 #include <Geom_Plane.hxx>
46 #include <Geom_RectangularTrimmedSurface.hxx>
47 #include <Geom_TrimmedCurve.hxx>
48 #include <TopExp_Explorer.hxx>
49 #include <TopoDS.hxx>
50 #include <TopoDS_Iterator.hxx>
51 #include <TopoDS_Shape.hxx>
52 #include <NCollection_List.hxx>
53
54 #include <BOPAlgo_CheckerSI.hxx>
55 #include <BOPDS_DS.hxx>
56
57 #include <sstream>
58 #include <algorithm> // for std::transform
59
60 #include <BRepTools.hxx>
61
62 #define MY_SHAPE implPtr<TopoDS_Shape>()
63
64 GeomAPI_Shape::GeomAPI_Shape()
65     : GeomAPI_Interface(new TopoDS_Shape())
66 {
67 }
68
69 std::shared_ptr<GeomAPI_Shape> GeomAPI_Shape::emptyCopied() const
70 {
71   GeomShapePtr aShape(new GeomAPI_Shape());
72   aShape->setImpl(new TopoDS_Shape(MY_SHAPE->EmptyCopied()));
73   return aShape;
74 }
75
76 bool GeomAPI_Shape::isNull() const
77 {
78   return MY_SHAPE->IsNull() == Standard_True;
79 }
80
81 bool GeomAPI_Shape::isEqual(const std::shared_ptr<GeomAPI_Shape> theShape) const
82 {
83   if (!theShape.get())
84     return false;
85   if (isNull())
86     return theShape->isNull();
87   if (theShape->isNull())
88     return false;
89
90   return MY_SHAPE->IsEqual(theShape->impl<TopoDS_Shape>()) == Standard_True;
91 }
92
93 bool GeomAPI_Shape::isSame(const std::shared_ptr<GeomAPI_Shape> theShape) const
94 {
95   if (!theShape.get())
96     return false;
97   if (isNull())
98     return theShape->isNull();
99   if (theShape->isNull())
100     return false;
101
102   return MY_SHAPE->IsSame(theShape->impl<TopoDS_Shape>()) == Standard_True;
103 }
104
105 bool GeomAPI_Shape::isVertex() const
106 {
107   const TopoDS_Shape& aShape = const_cast<GeomAPI_Shape*>(this)->impl<TopoDS_Shape>();
108   return !aShape.IsNull() && aShape.ShapeType() == TopAbs_VERTEX;
109 }
110
111 bool GeomAPI_Shape::isEdge() const
112 {
113   const TopoDS_Shape& aShape = const_cast<GeomAPI_Shape*>(this)->impl<TopoDS_Shape>();
114   return !aShape.IsNull() && aShape.ShapeType() == TopAbs_EDGE;
115 }
116
117 bool GeomAPI_Shape::isWire() const
118 {
119   const TopoDS_Shape& aShape = const_cast<GeomAPI_Shape*>(this)->impl<TopoDS_Shape>();
120   return !aShape.IsNull() && aShape.ShapeType() == TopAbs_WIRE;
121 }
122
123 bool GeomAPI_Shape::isFace() const
124 {
125   const TopoDS_Shape& aShape = const_cast<GeomAPI_Shape*>(this)->impl<TopoDS_Shape>();
126   return !aShape.IsNull() && aShape.ShapeType() == TopAbs_FACE;
127 }
128
129 bool GeomAPI_Shape::isShell() const
130 {
131   const TopoDS_Shape& aShape = const_cast<GeomAPI_Shape*>(this)->impl<TopoDS_Shape>();
132   return !aShape.IsNull() && aShape.ShapeType() == TopAbs_SHELL;
133 }
134
135 bool GeomAPI_Shape::isCompound() const
136 {
137   const TopoDS_Shape& aShape = const_cast<GeomAPI_Shape*>(this)->impl<TopoDS_Shape>();
138   return !aShape.IsNull() && aShape.ShapeType() == TopAbs_COMPOUND;
139 }
140
141 bool GeomAPI_Shape::isCompoundOfSolids() const
142 {
143   const TopoDS_Shape& aShape = const_cast<GeomAPI_Shape*>(this)->impl<TopoDS_Shape>();
144   if (aShape.IsNull() || aShape.ShapeType() != TopAbs_COMPOUND)
145     return false;
146   bool isAtLeastOne = false;
147   for(TopoDS_Iterator aSubs(aShape); aSubs.More(); aSubs.Next()) {
148     if (aSubs.Value().IsNull() || aSubs.Value().ShapeType() != TopAbs_SOLID)
149       return false;
150     isAtLeastOne = true;
151   }
152   return isAtLeastOne;
153 }
154
155 GeomAPI_Shape::ShapeType GeomAPI_Shape::typeOfCompoundShapes() const
156 {
157   const TopoDS_Shape& aShape = const_cast<GeomAPI_Shape*>(this)->impl<TopoDS_Shape>();
158   if (aShape.IsNull() || aShape.ShapeType() != TopAbs_COMPOUND)
159     return SHAPE;
160   int aType = -1;
161   for(TopoDS_Iterator aSubs(aShape); aSubs.More(); aSubs.Next()) {
162     if (!aSubs.Value().IsNull()) {
163       if (aType == -1)
164         aType = aSubs.Value().ShapeType();
165       else if (aSubs.Value().ShapeType() != aType)
166         return SHAPE;
167     }
168   }
169   return (GeomAPI_Shape::ShapeType) aType;
170 }
171
172 // adds the nopt-compound elements recursively to the list
173 static void addSimpleToList(const TopoDS_Shape& theShape, NCollection_List<TopoDS_Shape>& theList)
174 {
175   if (!theShape.IsNull()) {
176     if (theShape.ShapeType() == TopAbs_COMPOUND) {
177       for(TopoDS_Iterator aSubs(theShape); aSubs.More(); aSubs.Next()) {
178         addSimpleToList(aSubs.Value(), theList);
179       }
180     } else {
181       theList.Append(theShape);
182     }
183   }
184 }
185
186 bool GeomAPI_Shape::isConnectedTopology() const
187 {
188   const TopoDS_Shape& aShape = const_cast<GeomAPI_Shape*>(this)->impl<TopoDS_Shape>();
189   if (aShape.IsNull() || aShape.ShapeType() != TopAbs_COMPOUND)
190     return false;
191   // list of simple elements that are not detected in connection to others
192   NCollection_List<TopoDS_Shape> aNotConnected;
193   addSimpleToList(aShape, aNotConnected);
194   if (aNotConnected.IsEmpty()) // an empty compound
195     return false;
196
197   // collect here the group of connected subs, starting with one first element
198   NCollection_List<TopoDS_Shape> aNewConnected;
199   aNewConnected.Append(aNotConnected.First());
200   aNotConnected.RemoveFirst();
201   // iterate until some new element become connected
202   while(!aNewConnected.IsEmpty() && !aNotConnected.IsEmpty()) {
203     NCollection_List<TopoDS_Shape> aNew; // very new connected to new connected
204     NCollection_List<TopoDS_Shape>::Iterator aNotIter(aNotConnected);
205     while(aNotIter.More()) {
206       // optimization to avoid TopExp_Explorer double-cycle, collect all vertices in the list first
207       NCollection_List<TopoDS_Shape> aNotVertices;
208       for(TopExp_Explorer anExp1(aNotIter.Value(), TopAbs_VERTEX); anExp1.More(); anExp1.Next()) {
209         aNotVertices.Append(anExp1.Current());
210       }
211
212       bool aConnected =  false;
213       NCollection_List<TopoDS_Shape>::Iterator aNewIter(aNewConnected);
214       for(; !aConnected && aNewIter.More(); aNewIter.Next()) {
215         // checking topological connecion of aNotIter and aNewIter
216         // (if shapes are connected, vertices are connected for sure)
217         TopExp_Explorer anExp2(aNewIter.Value(), TopAbs_VERTEX);
218         for(; !aConnected && anExp2.More(); anExp2.Next()) {
219           NCollection_List<TopoDS_Shape>::Iterator aNotIter(aNotVertices);
220           for(; aNotIter.More(); aNotIter.Next()) {
221             if (aNotIter.Value().IsSame(anExp2.Current())) {
222               aConnected = true;
223               break;
224             }
225           }
226         }
227       }
228       if (aConnected) {
229         aNew.Append(aNotIter.Value());
230         aNotConnected.Remove(aNotIter);
231       } else {
232         aNotIter.Next();
233       }
234     }
235     // remove all new connected and put to this list very new connected
236     aNewConnected.Clear();
237     aNewConnected.Append(aNew);
238   }
239   return aNotConnected.IsEmpty() == Standard_True;
240 }
241
242 bool GeomAPI_Shape::isSolid() const
243 {
244   const TopoDS_Shape& aShape = const_cast<GeomAPI_Shape*>(this)->impl<TopoDS_Shape>();
245   return !aShape.IsNull() && aShape.ShapeType() == TopAbs_SOLID;
246 }
247
248 bool GeomAPI_Shape::isCompSolid() const
249 {
250   const TopoDS_Shape& aShape = const_cast<GeomAPI_Shape*>(this)->impl<TopoDS_Shape>();
251   return !aShape.IsNull() && aShape.ShapeType() == TopAbs_COMPSOLID;
252 }
253
254 bool GeomAPI_Shape::isPlanar() const
255 {
256   TopoDS_Shape aShape = impl<TopoDS_Shape>();
257
258   if(aShape.IsNull()) {
259     return false;
260   }
261
262   TopAbs_ShapeEnum aShapeType = aShape.ShapeType();
263   if(aShapeType == TopAbs_COMPOUND) {
264     TopoDS_Iterator anIt(aShape);
265     int aShNum = 0;
266     for(; anIt.More(); anIt.Next()) {
267       ++aShNum;
268     }
269     if(aShNum == 1) {
270       anIt.Initialize(aShape);
271       aShape = anIt.Value();
272     }
273   }
274
275   aShapeType = aShape.ShapeType();
276   if(aShapeType == TopAbs_VERTEX) {
277     return true;
278   } else if(aShapeType == TopAbs_FACE) {
279     const Handle(Geom_Surface)& aSurface = BRep_Tool::Surface(TopoDS::Face(aShape));
280     Handle(Standard_Type) aType = aSurface->DynamicType();
281
282     if(aType == STANDARD_TYPE(Geom_RectangularTrimmedSurface)) {
283       Handle(Geom_RectangularTrimmedSurface) aTrimSurface =
284         Handle(Geom_RectangularTrimmedSurface)::DownCast(aSurface);
285       aType = aTrimSurface->BasisSurface()->DynamicType();
286     }
287     return (aType == STANDARD_TYPE(Geom_Plane)) == Standard_True;
288   } else {
289     BRepBuilderAPI_FindPlane aFindPlane(aShape);
290     bool isFound = aFindPlane.Found() == Standard_True;
291
292     if(!isFound && aShapeType == TopAbs_EDGE) {
293       Standard_Real aFirst, aLast;
294       Handle(Geom_Curve) aCurve = BRep_Tool::Curve(TopoDS::Edge(aShape), aFirst, aLast);
295       Handle(Standard_Type) aType = aCurve->DynamicType();
296
297       if(aType == STANDARD_TYPE(Geom_TrimmedCurve)) {
298         Handle(Geom_TrimmedCurve) aTrimCurve = Handle(Geom_TrimmedCurve)::DownCast(aCurve);
299         aType = aTrimCurve->BasisCurve()->DynamicType();
300       }
301
302       if(aType == STANDARD_TYPE(Geom_Line)
303           || aType == STANDARD_TYPE(Geom_Conic)
304           || aType == STANDARD_TYPE(Geom_Circle)
305           || aType == STANDARD_TYPE(Geom_Ellipse)
306           || aType == STANDARD_TYPE(Geom_Hyperbola)
307           || aType == STANDARD_TYPE(Geom_Parabola)) {
308         isFound = true;
309       }
310     }
311
312     return isFound;
313   }
314
315   return false;
316 }
317
318 std::shared_ptr<GeomAPI_Vertex> GeomAPI_Shape::vertex() const
319 {
320   GeomVertexPtr aVertex;
321   if (isVertex()) {
322     const TopoDS_Shape& aShape = const_cast<GeomAPI_Shape*>(this)->impl<TopoDS_Shape>();
323     aVertex = GeomVertexPtr(new GeomAPI_Vertex);
324     aVertex->setImpl(new TopoDS_Shape(aShape));
325   }
326   return aVertex;
327 }
328
329 std::shared_ptr<GeomAPI_Edge> GeomAPI_Shape::edge() const
330 {
331   GeomEdgePtr anEdge;
332   if (isEdge()) {
333     const TopoDS_Shape& aShape = const_cast<GeomAPI_Shape*>(this)->impl<TopoDS_Shape>();
334     anEdge = GeomEdgePtr(new GeomAPI_Edge);
335     anEdge->setImpl(new TopoDS_Shape(aShape));
336   }
337   return anEdge;
338 }
339
340 std::shared_ptr<GeomAPI_Wire> GeomAPI_Shape::wire() const
341 {
342   GeomWirePtr aWire;
343   if (isWire()) {
344     const TopoDS_Shape& aShape = const_cast<GeomAPI_Shape*>(this)->impl<TopoDS_Shape>();
345     aWire = GeomWirePtr(new GeomAPI_Wire);
346     aWire->setImpl(new TopoDS_Shape(aShape));
347   }
348   return aWire;
349 }
350
351 std::shared_ptr<GeomAPI_Face> GeomAPI_Shape::face() const
352 {
353   GeomFacePtr aFace;
354   if (isFace()) {
355     const TopoDS_Shape& aShape = const_cast<GeomAPI_Shape*>(this)->impl<TopoDS_Shape>();
356     aFace = GeomFacePtr(new GeomAPI_Face);
357     aFace->setImpl(new TopoDS_Shape(aShape));
358   }
359   return aFace;
360 }
361
362 std::shared_ptr<GeomAPI_Shell> GeomAPI_Shape::shell() const
363 {
364   GeomShellPtr aShell;
365   if (isShell()) {
366     const TopoDS_Shape& aShape = const_cast<GeomAPI_Shape*>(this)->impl<TopoDS_Shape>();
367     aShell = GeomShellPtr(new GeomAPI_Shell);
368     aShell->setImpl(new TopoDS_Shape(aShape));
369   }
370   return aShell;
371 }
372
373 std::shared_ptr<GeomAPI_Solid> GeomAPI_Shape::solid() const
374 {
375   GeomSolidPtr aSolid;
376   if (isSolid()) {
377     const TopoDS_Shape& aShape = const_cast<GeomAPI_Shape*>(this)->impl<TopoDS_Shape>();
378     aSolid = GeomSolidPtr(new GeomAPI_Solid);
379     aSolid->setImpl(new TopoDS_Shape(aShape));
380   }
381   return aSolid;
382 }
383
384 std::list<std::shared_ptr<GeomAPI_Shape> >
385 GeomAPI_Shape::subShapes(ShapeType theSubShapeType) const
386 {
387   ListOfShape aSubs;
388   const TopoDS_Shape& aShape = impl<TopoDS_Shape>();
389   if (aShape.IsNull())
390     return aSubs;
391
392   for (TopExp_Explorer anExp(aShape, (TopAbs_ShapeEnum)theSubShapeType);
393        anExp.More(); anExp.Next()) {
394     GeomShapePtr aSub(new GeomAPI_Shape);
395     aSub->setImpl(new TopoDS_Shape(anExp.Current()));
396     aSubs.push_back(aSub);
397   }
398   return aSubs;
399 }
400
401 GeomAPI_Shape::ShapeType GeomAPI_Shape::shapeType() const
402 {
403   const TopoDS_Shape& aShape = impl<TopoDS_Shape>();
404   if (aShape.IsNull())
405     return GeomAPI_Shape::SHAPE;
406
407   ShapeType aST = GeomAPI_Shape::SHAPE;
408
409   switch(aShape.ShapeType()) {
410   case TopAbs_COMPOUND:
411     aST = GeomAPI_Shape::COMPOUND;
412     break;
413   case TopAbs_COMPSOLID:
414     aST = GeomAPI_Shape::COMPSOLID;
415     break;
416   case TopAbs_SOLID:
417     aST = GeomAPI_Shape::SOLID;
418     break;
419   case TopAbs_SHELL:
420     aST = GeomAPI_Shape::SHELL;
421     break;
422   case TopAbs_FACE:
423     aST = GeomAPI_Shape::FACE;
424     break;
425   case TopAbs_WIRE:
426     aST = GeomAPI_Shape::WIRE;
427     break;
428   case TopAbs_EDGE:
429     aST = GeomAPI_Shape::EDGE;
430     break;
431   case TopAbs_VERTEX:
432     aST = GeomAPI_Shape::VERTEX;
433     break;
434   case TopAbs_SHAPE:
435     aST = GeomAPI_Shape::SHAPE;
436     break;
437   }
438
439   return aST;
440 }
441
442 GeomAPI_Shape::ShapeType GeomAPI_Shape::shapeTypeByStr(std::string theType)
443 {
444   std::transform(theType.begin(), theType.end(), theType.begin(), ::toupper);
445   if (theType == "COMPOUND")
446     return COMPOUND;
447   if (theType == "COMPSOLID")
448     return COMPSOLID;
449   if (theType == "SOLID")
450     return SOLID;
451   if (theType == "SHELL")
452     return SHELL;
453   if (theType == "FACE")
454     return FACE;
455   if (theType == "WIRE")
456     return WIRE;
457   if (theType == "EDGE")
458     return EDGE;
459   if (theType == "VERTEX")
460     return VERTEX;
461   return SHAPE; // default
462 }
463
464 std::string GeomAPI_Shape::shapeTypeStr() const
465 {
466   ShapeType aShapeType = shapeType();
467   std::string aShapeTypeStr;
468
469   switch(aShapeType) {
470     case COMPOUND: {
471       aShapeTypeStr = "COMPOUND";
472       break;
473     }
474     case COMPSOLID: {
475       aShapeTypeStr = "COMPSOLID";
476       break;
477     }
478     case SOLID: {
479       aShapeTypeStr = "SOLID";
480       break;
481     }
482     case SHELL: {
483       aShapeTypeStr = "SHELL";
484       break;
485     }
486     case FACE: {
487       aShapeTypeStr = "FACE";
488       break;
489     }
490     case WIRE: {
491       aShapeTypeStr = "WIRE";
492       break;
493     }
494     case EDGE: {
495       aShapeTypeStr = "EDGE";
496       break;
497     }
498     case VERTEX: {
499       aShapeTypeStr = "VERTEX";
500       break;
501     }
502     case SHAPE: {
503       aShapeTypeStr = "SHAPE";
504       break;
505     }
506   }
507
508   return aShapeTypeStr;
509 }
510
511 GeomAPI_Shape::Orientation GeomAPI_Shape::orientation() const
512 {
513   TopAbs_Orientation anOrientation = MY_SHAPE->Orientation();
514
515   switch(anOrientation) {
516     case TopAbs_FORWARD:  return FORWARD;
517     case TopAbs_REVERSED: return REVERSED;
518     case TopAbs_INTERNAL: return INTERNAL;
519     case TopAbs_EXTERNAL: return EXTERNAL;
520     default:              return FORWARD;
521   }
522 }
523
524 void GeomAPI_Shape::setOrientation(const GeomAPI_Shape::Orientation theOrientation)
525 {
526   TopAbs_Orientation anOrientation = MY_SHAPE->Orientation();
527
528   switch(theOrientation) {
529     case FORWARD:  MY_SHAPE->Orientation(TopAbs_FORWARD);  break;
530     case REVERSED: MY_SHAPE->Orientation(TopAbs_REVERSED); break;
531     case INTERNAL: MY_SHAPE->Orientation(TopAbs_INTERNAL); break;
532     case EXTERNAL: MY_SHAPE->Orientation(TopAbs_EXTERNAL); break;
533   }
534 }
535
536 void GeomAPI_Shape::reverse()
537 {
538   MY_SHAPE->Reverse();
539 }
540
541 bool GeomAPI_Shape::isSubShape(const std::shared_ptr<GeomAPI_Shape> theShape,
542                                const bool theCheckOrientation) const
543 {
544   if(!theShape.get()) {
545     return false;
546   }
547
548   const TopoDS_Shape& aShapeToSearch = theShape->impl<TopoDS_Shape>();
549   if(aShapeToSearch.IsNull()) {
550     return false;
551   }
552
553   for(TopExp_Explorer anExp(*MY_SHAPE, aShapeToSearch.ShapeType()); anExp.More(); anExp.Next()) {
554     if(theCheckOrientation ?
555        aShapeToSearch.IsEqual(anExp.Current()) : aShapeToSearch.IsSame(anExp.Current())) {
556       return true;
557     }
558   }
559
560   return false;
561 }
562
563 bool GeomAPI_Shape::computeSize(double& theXmin, double& theYmin, double& theZmin,
564                                 double& theXmax, double& theYmax, double& theZmax) const
565 {
566   const TopoDS_Shape& aShape = const_cast<GeomAPI_Shape*>(this)->impl<TopoDS_Shape>();
567   if (aShape.IsNull())
568     return false;
569   Bnd_Box aBndBox;
570   BRepBndLib::Add(aShape, aBndBox, false);
571   if (aBndBox.IsVoid())
572     return false;
573   aBndBox.Get(theXmin, theYmin, theZmin, theXmax, theYmax, theZmax);
574   return true;
575 }
576
577 GeomPointPtr GeomAPI_Shape::middlePoint() const
578 {
579   GeomPointPtr aMiddlePoint;
580
581   switch (shapeType()) {
582   case VERTEX:
583     aMiddlePoint = vertex()->point();
584     break;
585   case EDGE:
586     aMiddlePoint = edge()->middlePoint();
587     break;
588   case WIRE:
589     aMiddlePoint = wire()->middlePoint();
590     break;
591   case FACE:
592     aMiddlePoint = face()->middlePoint();
593     break;
594   case SHELL:
595     aMiddlePoint = shell()->middlePoint();
596     break;
597   case SOLID:
598     aMiddlePoint = solid()->middlePoint();
599     break;
600   default: {
601       // get middle point as center of the bounding box
602       double aMinX, aMinY, aMinZ, aMaxX, aMaxY, aMaxZ;
603       computeSize(aMinX, aMinY, aMinZ, aMaxX, aMaxY, aMaxZ);
604       aMiddlePoint = GeomPointPtr(new GeomAPI_Pnt(
605           (aMinX + aMaxX) * 0.5, (aMinY + aMaxY) * 0.5, (aMinZ + aMaxZ) * 0.5));
606     }
607   }
608
609   return aMiddlePoint;
610 }
611
612 std::string GeomAPI_Shape::getShapeStream() const
613 {
614   std::ostringstream aStream;
615   const TopoDS_Shape& aShape = const_cast<GeomAPI_Shape*>(this)->impl<TopoDS_Shape>();
616   BRepTools::Write(aShape, aStream);
617   return aStream.str();
618 }
619
620 GeomShapePtr GeomAPI_Shape::intersect(const GeomShapePtr theShape) const
621 {
622   const TopoDS_Shape& aShape1 = const_cast<GeomAPI_Shape*>(this)->impl<TopoDS_Shape>();
623   const TopoDS_Shape& aShape2 = theShape->impl<TopoDS_Shape>();
624
625   BRepAlgoAPI_Section aCommon(aShape1, aShape2);
626   if (!aCommon.IsDone())
627     return GeomShapePtr();
628
629   TopoDS_Shape aResult = aCommon.Shape();
630   if (aResult.ShapeType() == TopAbs_COMPOUND) {
631     NCollection_List<TopoDS_Shape> aSubs;
632     addSimpleToList(aResult, aSubs);
633     if(aSubs.Size() == 1) {
634       aResult = aSubs.First();
635     } else if(aSubs.Size() == 0) {
636       return GeomShapePtr();
637     }
638   }
639
640   GeomShapePtr aResShape(new GeomAPI_Shape);
641   aResShape->setImpl(new TopoDS_Shape(aResult));
642   return aResShape;
643 }
644
645 bool GeomAPI_Shape::isIntersect(const GeomShapePtr theShape) const
646 {
647   if(!theShape.get()) {
648     return false;
649   }
650
651   const TopoDS_Shape& aShape1 = const_cast<GeomAPI_Shape*>(this)->impl<TopoDS_Shape>();
652   const TopoDS_Shape& aShape2 = theShape->impl<TopoDS_Shape>();
653
654   BRepExtrema_DistShapeShape aDist(aShape1, aShape2);
655   aDist.Perform();
656   if(aDist.IsDone() && aDist.Value() < Precision::Confusion()) {
657     return true;
658   }
659
660   return false;
661 }
662
663 void GeomAPI_Shape::translate(const std::shared_ptr<GeomAPI_Dir> theDir, const double theOffset)
664 {
665   gp_Dir aDir = theDir->impl<gp_Dir>();
666   gp_Vec aTrsfVec(aDir.XYZ() * theOffset);
667   gp_Trsf aTranslation;
668   aTranslation.SetTranslation(aTrsfVec);
669   TopoDS_Shape aResult = MY_SHAPE->Moved(aTranslation);
670   setImpl(new TopoDS_Shape(aResult));
671 }
672
673 bool GeomAPI_Shape::isSelfIntersected(const int theLevelOfCheck) const
674 {
675   BOPAlgo_CheckerSI aCSI;  // checker of self-interferences
676   aCSI.SetLevelOfCheck(theLevelOfCheck);
677   TopTools_ListOfShape aList;
678   const TopoDS_Shape& aThisShape = const_cast<GeomAPI_Shape*>(this)->impl<TopoDS_Shape>();
679   aList.Append(aThisShape);
680   aCSI.SetArguments(aList);
681   aCSI.Perform();
682   if (aCSI.HasErrors() || aCSI.DS().Interferences().Extent() > 0) {
683     return true;
684   }
685
686   return false;
687 }