src/GeomAlgoAPI/GeomAlgoAPI_Revolution.cpp

   1 // Copyright (C) 2014-20xx CEA/DEN, EDF R&D
   2
   3 // File:        GeomAlgoAPI_Revolution.cpp
   4 // Created:     12 May 2015
   5 // Author:      Dmitry Bobylev
   6
   7 #include "GeomAlgoAPI_Revolution.h"
   8
   9 #include <GeomAPI_Face.h>
  10 #include <GeomAPI_ShapeExplorer.h>
  11 #include <GeomAlgoAPI_DFLoader.h>
  12 #include <GeomAlgoAPI_FaceBuilder.h>
  13 #include <GeomAlgoAPI_MakeShapeList.h>
  14 #include <GeomAlgoAPI_ShapeTools.h>
  15
  16 #include <BRep_Builder.hxx>
  17 #include <BRep_Tool.hxx>
  18 #include <BRepAlgoAPI_Cut.hxx>
  19 #include <BRepBuilderAPI_FindPlane.hxx>
  20 #include <BRepBuilderAPI_MakeFace.hxx>
  21 #include <BRepBuilderAPI_Transform.hxx>
  22 #include <BRepCheck_Analyzer.hxx>
  23 #include <Geom_Curve.hxx>
  24 #include <Geom2d_Curve.hxx>
  25 #include <BRepLib_CheckCurveOnSurface.hxx>
  26 #include <BRepPrimAPI_MakeRevol.hxx>
  27 #include <BRepGProp.hxx>
  28 #include <GC_MakePlane.hxx>
  29 #include <Geom_Plane.hxx>
  30 #include <GeomLib_IsPlanarSurface.hxx>
  31 #include <gp_Pln.hxx>
  32 #include <GProp_GProps.hxx>
  33 #include <IntTools_Context.hxx>
  34 #include <TopExp_Explorer.hxx>
  35 #include <TopoDS.hxx>
  36 #include <TopoDS_Edge.hxx>
  37 #include <TopTools_ListIteratorOfListOfShape.hxx>
  38
  39 /// \brief Constructs infinite face from thePlane, and with axis located on the same side
  40 /// of the plane as thePoint. Modifies thePlane axis direction.
  41 /// \param[in,out] thePlane plane to construct face.
  42 /// \param[in] thePoint point to locate plane axis.
  43 /// \return constructed face.
  44 static TopoDS_Face makeFaceFromPlane(gp_Pln& thePlane, const gp_Pnt& thePoint);
  45
  46 /// \return solid created from face or shell.
  47 static TopoDS_Solid makeSolidFromShape(const TopoDS_Shape& theShape);
  48
  49 /// \brief return centre of mass for theShape.
  50 /// \param[in] theShape shape.
  51 static gp_Pnt centreOfMass(const TopoDS_Shape& theShape);
  52
  53 /// \brief Selects solid from theShape with closest center of mass to thePoint
  54 /// \param[in] theShape compound with solids.
  55 /// \param[in] thePoint point.
  56 /// \return solid.
  57 static TopoDS_Shape findClosest(const TopoDS_Shape& theShape, const gp_Pnt& thePoint);
  58
  59 static void storeGenerationHistory(GeomAlgoAPI_Revolution* theRevolutionAlgo,
  60                                    const TopoDS_Shape& theBase,
  61                                    const TopAbs_ShapeEnum theType,
  62                                    BRepPrimAPI_MakeRevol* theRevolBuilder);
  63
  64 static void storeGenerationHistory(GeomAlgoAPI_Revolution* theRevolutionAlgo,
  65                                    const TopoDS_Shape& theResult,
  66                                    const TopAbs_ShapeEnum theType,
  67                                    const TopoDS_Shape& theToFace,
  68                                    const TopoDS_Shape& theFromFace);
  69
  70 static void storeGenerationHistory(GeomAlgoAPI_Revolution* theRevolutionAlgo,
  71                                    const TopoDS_Shape& theResult,
  72                                    const TopAbs_ShapeEnum theType,
  73                                    const TopoDS_Shape& theRotatedBoundingFace,
  74                                    const TopoDS_Shape& theModifiedBaseShape,
  75                                    const bool theIsFromFaceSet);
  76
  77 //==================================================================================================
  78 GeomAlgoAPI_Revolution::GeomAlgoAPI_Revolution(const GeomShapePtr                 theBaseShape,
  79                                                const std::shared_ptr<GeomAPI_Ax1> theAxis,
  80                                                const double                       theToAngle,
  81                                                const double                       theFromAngle)
  82 {
  83   build(theBaseShape, theAxis, GeomShapePtr(), theToAngle, GeomShapePtr(), theFromAngle);
  84 }
  85
  86 //==================================================================================================
  87 GeomAlgoAPI_Revolution::GeomAlgoAPI_Revolution(const GeomShapePtr                 theBaseShape,
  88                                                const std::shared_ptr<GeomAPI_Ax1> theAxis,
  89                                                const GeomShapePtr                 theToShape,
  90                                                const double                       theToAngle,
  91                                                const GeomShapePtr                 theFromShape,
  92                                                const double                       theFromAngle)
  93 {
  94   build(theBaseShape, theAxis, theToShape, theToAngle, theFromShape, theFromAngle);
  95 }
  96
  97 //==================================================================================================
  98 void GeomAlgoAPI_Revolution::build(const GeomShapePtr&                 theBaseShape,
  99                                    const std::shared_ptr<GeomAPI_Ax1>& theAxis,
 100                                    const GeomShapePtr&                 theToShape,
 101                                    const double                        theToAngle,
 102                                    const GeomShapePtr&                 theFromShape,
 103                                    const double                        theFromAngle)
 104 {
 105   if(!theBaseShape || !theAxis ||
 106     (((!theFromShape && !theToShape) || (theFromShape && theToShape && theFromShape->isEqual(theToShape)))
 107     && (theFromAngle == -theToAngle))) {
 108     return;
 109   }
 110
 111   // Getting base shape.
 112   const TopoDS_Shape& aBaseShape = theBaseShape->impl<TopoDS_Shape>();
 113   TopAbs_ShapeEnum aShapeTypeToExp;
 114   switch(aBaseShape.ShapeType()) {
 115     case TopAbs_VERTEX:
 116       aShapeTypeToExp = TopAbs_VERTEX;
 117       break;
 118     case TopAbs_EDGE:
 119     case TopAbs_WIRE:
 120       aShapeTypeToExp = TopAbs_EDGE;
 121       break;
 122     case TopAbs_FACE:
 123     case TopAbs_SHELL:
 124       aShapeTypeToExp = TopAbs_FACE;
 125       break;
 126     case TopAbs_COMPOUND:
 127       aShapeTypeToExp = TopAbs_COMPOUND;
 128       break;
 129     default:
 130       return;
 131   }
 132
 133   // Getting axis.
 134   gp_Ax1 anAxis = theAxis->impl<gp_Ax1>();
 135
 136   // Getting base plane.
 137   Handle(Geom_Plane) aBasePlane;
 138   BRepBuilderAPI_FindPlane aFindPlane(aBaseShape);
 139   if(aShapeTypeToExp == TopAbs_FACE && aFindPlane.Found() == Standard_True) {
 140     aBasePlane = aFindPlane.Plane();
 141   } else {
 142     gp_Pnt aPnt1 = anAxis.Location();
 143     gp_Pnt aPnt2 = aPnt1;
 144     aPnt2.Translate(anAxis.Direction());
 145     gp_Pnt aPnt3;
 146
 147     for(TopExp_Explorer anExp(aBaseShape, TopAbs_VERTEX); anExp.More(); anExp.Next()) {
 148       aPnt3 = BRep_Tool::Pnt(TopoDS::Vertex(anExp.Current()));
 149
 150       GC_MakePlane aMkPlane(aPnt1, aPnt2, aPnt3);
 151       if(aMkPlane.IsDone() != Standard_True) {
 152         continue;
 153       }
 154
 155       aBasePlane = aMkPlane.Value();
 156       break;
 157     }
 158
 159     if(aBasePlane.IsNull()) {
 160       aPnt3 = centreOfMass(aBaseShape);
 161
 162       GC_MakePlane aMkPlane(aPnt1, aPnt2, aPnt3);
 163       if(aMkPlane.IsDone() != Standard_True) {
 164         return;
 165       }
 166
 167       aBasePlane = aMkPlane.Value();
 168     }
 169   }
 170
 171   if(aShapeTypeToExp == TopAbs_FACE) {
 172     if(aBasePlane->Axis().Angle(anAxis) < Precision::Confusion()) {
 173       return;
 174     }
 175   }
 176
 177   gp_Pnt aBaseCentre = GeomAlgoAPI_ShapeTools::centreOfMass(theBaseShape)->impl<gp_Pnt>();
 178
 179   TopoDS_Shape aResult;
 180   if(!theFromShape && !theToShape) { // Case 1: When only angles was set.
 181     // Rotating base face with the negative value of "from angle".
 182     gp_Trsf aBaseTrsf;
 183     aBaseTrsf.SetRotation(anAxis, -theFromAngle / 180.0 * M_PI);
 184     BRepBuilderAPI_Transform* aBaseTransform = new BRepBuilderAPI_Transform(aBaseShape,
 185                                                                             aBaseTrsf,
 186                                                                             true);
 187     if(!aBaseTransform) {
 188       return;
 189     }
 190     this->appendAlgo(std::shared_ptr<GeomAlgoAPI_MakeShape>(new GeomAlgoAPI_MakeShape(aBaseTransform)));
 191     if(!aBaseTransform->IsDone()) {
 192       return;
 193     }
 194     TopoDS_Shape aRotatedBase = aBaseTransform->Shape();
 195
 196     // Making revolution to the angle equal to the sum of "from angle" and "to angle".
 197     BRepPrimAPI_MakeRevol* aRevolBuilder = new BRepPrimAPI_MakeRevol(aRotatedBase,
 198                                                                       anAxis,
 199                                                                       (theFromAngle + theToAngle) / 180 * M_PI,
 200                                                                       Standard_True);
 201     if(!aRevolBuilder) {
 202       return;
 203     }
 204     this->appendAlgo(std::shared_ptr<GeomAlgoAPI_MakeShape>(new GeomAlgoAPI_MakeShape(aRevolBuilder)));
 205     if(!aRevolBuilder->IsDone()) {
 206       return;
 207     }
 208     aResult = aRevolBuilder->Shape();
 209
 210     // Setting naming.
 211     if(aShapeTypeToExp == TopAbs_COMPOUND) {
 212       storeGenerationHistory(this, aRotatedBase, TopAbs_EDGE, aRevolBuilder);
 213       storeGenerationHistory(this, aRotatedBase, TopAbs_FACE, aRevolBuilder);
 214     } else {
 215       storeGenerationHistory(this, aRotatedBase, aShapeTypeToExp, aRevolBuilder);
 216     }
 217   } else if(theFromShape && theToShape) { // Case 2: When both bounding planes were set.
 218     // Making revolution to the 360 angle.
 219     BRepPrimAPI_MakeRevol* aRevolBuilder = new BRepPrimAPI_MakeRevol(aBaseShape, anAxis, 2 * M_PI, Standard_True);
 220     if(!aRevolBuilder) {
 221       return;
 222     }
 223     this->appendAlgo(std::shared_ptr<GeomAlgoAPI_MakeShape>(new GeomAlgoAPI_MakeShape(aRevolBuilder)));
 224     if(!aRevolBuilder->IsDone()) {
 225       return;
 226     }
 227     aResult = aRevolBuilder->Shape();
 228
 229     // Getting bounding faces.
 230     TopoDS_Face aFromFace = TopoDS::Face(theFromShape->impl<TopoDS_Shape>());
 231     TopoDS_Face aToFace   = TopoDS::Face(theToShape->impl<TopoDS_Shape>());
 232
 233     // Getting planes from bounding face.
 234     GeomLib_IsPlanarSurface isFromPlanar(BRep_Tool::Surface(aFromFace));
 235     GeomLib_IsPlanarSurface isToPlanar(BRep_Tool::Surface(aToFace));
 236     if(!isFromPlanar.IsPlanar() || !isToPlanar.IsPlanar()) {// non-planar shapes is not supported for revolution bounding
 237       return;
 238     }
 239     gp_Pln aFromPln = isFromPlanar.Plan();
 240     gp_Pln aToPln   = isToPlanar.Plan();
 241
 242     // Orienting bounding planes properly so that the center of mass of the base face stays
 243     // on the result shape after cut.
 244     aFromFace = makeFaceFromPlane(aFromPln, aBaseCentre);
 245     aToFace   = makeFaceFromPlane(aToPln, aBaseCentre);
 246
 247     // Making solids from bounding planes and putting them in compound.
 248     TopoDS_Shape aFromSolid = makeSolidFromShape(aFromFace);
 249     TopoDS_Shape aToSolid   = makeSolidFromShape(aToFace);
 250
 251     // Rotating bounding planes to the specified angle.
 252     gp_Trsf aFromTrsf;
 253     gp_Trsf aToTrsf;
 254     double aFromRotAngle = ((aFromPln.Axis().Direction() * aBasePlane->Axis().Direction()) > 0) ? -theFromAngle : theFromAngle;
 255     double aToRotAngle = ((aToPln.Axis().Direction() * aBasePlane->Axis().Direction()) > 0) ? -theToAngle : theToAngle;
 256     aFromTrsf.SetRotation(anAxis,aFromRotAngle / 180.0 * M_PI);
 257     aToTrsf.SetRotation(anAxis, aToRotAngle / 180.0 * M_PI);
 258     BRepBuilderAPI_Transform aFromTransform(aFromSolid, aFromTrsf, true);
 259     BRepBuilderAPI_Transform aToTransform(aToSolid, aToTrsf, true);
 260     TopoDS_Shape aRotatedFromFace = aFromTransform.Modified(aFromFace).First();
 261     TopoDS_Shape aRotatedToFace = aToTransform.Modified(aToFace).First();
 262     aFromSolid = aFromTransform.Shape();
 263     aToSolid = aToTransform.Shape();
 264
 265     // Cutting revolution with from plane.
 266     BRepAlgoAPI_Cut* aFromCutBuilder = new BRepAlgoAPI_Cut(aResult, aFromSolid);
 267     aFromCutBuilder->Build();
 268     if(!aFromCutBuilder->IsDone()) {
 269       return;
 270     }
 271     this->appendAlgo(std::shared_ptr<GeomAlgoAPI_MakeShape>(new GeomAlgoAPI_MakeShape(aFromCutBuilder)));
 272     aResult = aFromCutBuilder->Shape();
 273     if(aResult.ShapeType() == TopAbs_COMPOUND) {
 274       aResult = GeomAlgoAPI_DFLoader::refineResult(aResult);
 275     }
 276
 277     // Cutting revolution with to plane.
 278     BRepAlgoAPI_Cut* aToCutBuilder = new BRepAlgoAPI_Cut(aResult, aToSolid);
 279     aToCutBuilder->Build();
 280     if(!aToCutBuilder->IsDone()) {
 281       return;
 282     }
 283     this->appendAlgo(std::shared_ptr<GeomAlgoAPI_MakeShape>(new GeomAlgoAPI_MakeShape(aToCutBuilder)));
 284     aResult = aToCutBuilder->Shape();
 285     TopoDS_Iterator aCheckIt(aResult);
 286     if(!aCheckIt.More()) {
 287       return;
 288     }
 289     if(aResult.ShapeType() == TopAbs_COMPOUND) {
 290       aResult = GeomAlgoAPI_DFLoader::refineResult(aResult);
 291     }
 292     if(aResult.ShapeType() == TopAbs_COMPOUND) {
 293       std::shared_ptr<GeomAPI_Shape> aGeomShape(new GeomAPI_Shape);
 294       aGeomShape->setImpl(new TopoDS_Shape(aResult));
 295       ListOfShape aCompSolids, aFreeSolids;
 296       aGeomShape = GeomAlgoAPI_ShapeTools::combineShapes(aGeomShape,
 297                                                          GeomAPI_Shape::COMPSOLID,
 298                                                          aCompSolids,
 299                                                          aFreeSolids);
 300       aResult = aGeomShape->impl<TopoDS_Shape>();
 301     }
 302
 303     // If after cut we got more than one solids then take closest to the center of mass of the base face.
 304     aResult = findClosest(aResult, aBaseCentre);
 305
 306     // Setting naming.
 307     if(aShapeTypeToExp == TopAbs_COMPOUND) {
 308       storeGenerationHistory(this, aResult, TopAbs_EDGE, aRotatedToFace, aRotatedFromFace);
 309       storeGenerationHistory(this, aResult, TopAbs_FACE, aRotatedToFace, aRotatedFromFace);
 310     } else {
 311       storeGenerationHistory(this, aResult, aShapeTypeToExp, aRotatedToFace, aRotatedFromFace);
 312     }
 313   } else { //Case 3: When only one bounding plane was set.
 314     // Making revolution to the 360 angle.
 315     BRepPrimAPI_MakeRevol* aRevolBuilder = new BRepPrimAPI_MakeRevol(aBaseShape, anAxis, 2 * M_PI, Standard_True);
 316     if(!aRevolBuilder) {
 317       return;
 318     }
 319     this->appendAlgo(std::shared_ptr<GeomAlgoAPI_MakeShape>(new GeomAlgoAPI_MakeShape(aRevolBuilder)));
 320     if(!aRevolBuilder->IsDone()) {
 321       return;
 322     }
 323     aResult = aRevolBuilder->Shape();
 324
 325     // Getting bounding face.
 326     TopoDS_Face aBoundingFace;
 327     bool isFromFaceSet = false;
 328     if(theFromShape) {
 329       aBoundingFace = TopoDS::Face(theFromShape->impl<TopoDS_Shape>());
 330       isFromFaceSet = true;
 331     } else if(theToShape) {
 332       aBoundingFace = TopoDS::Face(theToShape->impl<TopoDS_Shape>());
 333     }
 334
 335     // Getting plane from bounding face.
 336     GeomLib_IsPlanarSurface isBoundingPlanar(BRep_Tool::Surface(aBoundingFace));
 337     if(!isBoundingPlanar.IsPlanar()) { // non-planar shapes is not supported for revolution bounding
 338       return;
 339     }
 340     gp_Pln aBoundingPln = isBoundingPlanar.Plan();
 341
 342     // Orienting bounding plane properly so that the center of mass of the base face stays
 343     // on the result shape after cut.
 344     aBoundingFace = makeFaceFromPlane(aBoundingPln, aBaseCentre);
 345
 346     // Making solid from bounding plane.
 347     TopoDS_Shape aBoundingSolid = makeSolidFromShape(aBoundingFace);
 348
 349     // Rotating bounding plane to the specified angle.
 350     double aBoundingRotAngle = isFromFaceSet ? theFromAngle : theToAngle;
 351     if(aBoundingPln.Axis().IsParallel(aBasePlane->Axis(), Precision::Confusion())) {
 352       if(isFromFaceSet) aBoundingRotAngle = -aBoundingRotAngle;
 353     } else {
 354       double aSign = (aBoundingPln.Axis().Direction() ^ aBasePlane->Axis().Direction()) *
 355                      anAxis.Direction();
 356       if((aSign <= 0 && !isFromFaceSet) || (aSign > 0 && isFromFaceSet)) {
 357         aBoundingRotAngle = -aBoundingRotAngle;
 358       }
 359     }
 360     gp_Trsf aBoundingTrsf;
 361     aBoundingTrsf.SetRotation(anAxis, aBoundingRotAngle / 180.0 * M_PI);
 362     BRepBuilderAPI_Transform aBoundingTransform(aBoundingSolid, aBoundingTrsf, true);
 363     TopoDS_Shape aRotatedBoundingFace = aBoundingTransform.Modified(aBoundingFace).First();
 364     aBoundingSolid = aBoundingTransform.Shape();
 365
 366     // Cutting revolution with bounding plane.
 367     BRepAlgoAPI_Cut* aBoundingCutBuilder = new BRepAlgoAPI_Cut(aResult, aBoundingSolid);
 368     aBoundingCutBuilder->Build();
 369     if(!aBoundingCutBuilder->IsDone()) {
 370       return;
 371     }
 372     this->appendAlgo(std::shared_ptr<GeomAlgoAPI_MakeShape>(new GeomAlgoAPI_MakeShape(aBoundingCutBuilder)));
 373     aResult = aBoundingCutBuilder->Shape();
 374     if(aResult.ShapeType() == TopAbs_COMPOUND) {
 375       aResult = GeomAlgoAPI_DFLoader::refineResult(aResult);
 376     }
 377
 378     // Setting naming.
 379     if(aShapeTypeToExp == TopAbs_FACE || aShapeTypeToExp == TopAbs_COMPOUND) {
 380       const TopTools_ListOfShape& aBndShapes = aBoundingCutBuilder->Modified(aBoundingFace);
 381       for(TopTools_ListIteratorOfListOfShape anIt(aBndShapes); anIt.More(); anIt.Next()) {
 382         GeomShapePtr aShape(new GeomAPI_Shape());
 383         aShape->setImpl(new TopoDS_Shape(anIt.Value()));
 384         isFromFaceSet ? this->addFromShape(aShape) : this->addToShape(aShape);
 385       }
 386     }
 387
 388     // Try to cut with base face. If it can not be done then keep result of cut with bounding plane.
 389     TopoDS_Shape aModifiedBaseShape;
 390     if(aShapeTypeToExp != TopAbs_FACE) {
 391       ListOfShape aList;
 392       GeomShapePtr aSh(new GeomAPI_Shape());
 393       aSh->setImpl(new TopoDS_Shape(aBaseShape));
 394       std::shared_ptr<GeomAPI_Pnt> theCenter(new GeomAPI_Pnt(aBasePlane->Location().X(),
 395                                                              aBasePlane->Location().Y(),
 396                                                              aBasePlane->Location().Z()));
 397       std::shared_ptr<GeomAPI_Dir> theNormal(new GeomAPI_Dir(aBasePlane->Axis().Direction().X(),
 398                                                              aBasePlane->Axis().Direction().Y(),
 399                                                              aBasePlane->Axis().Direction().Z()));
 400       GeomShapePtr aPln = GeomAlgoAPI_FaceBuilder::planarFace(theCenter, theNormal);
 401       aList.push_back(aSh);
 402       std::list<std::shared_ptr<GeomAPI_Pnt> > aBoundingPoints = GeomAlgoAPI_ShapeTools::getBoundingBox(aList);
 403       aSh = GeomAlgoAPI_ShapeTools::fitPlaneToBox(aPln, aBoundingPoints);
 404       aModifiedBaseShape = aSh->impl<TopoDS_Shape>();
 405     } else {
 406       aModifiedBaseShape = aBaseShape;
 407     }
 408     if(isFromFaceSet) {
 409       if(aModifiedBaseShape.ShapeType() == TopAbs_FACE) {
 410         aModifiedBaseShape.Orientation(TopAbs_REVERSED);
 411       } else {
 412         gp_Trsf aMirrorTrsf;
 413         aMirrorTrsf.SetMirror(aBasePlane->Position().Ax2());
 414         BRepBuilderAPI_Transform aMirrorTransform(aModifiedBaseShape, aMirrorTrsf, true);
 415         aModifiedBaseShape = aMirrorTransform.Shape();
 416       }
 417     }
 418
 419     // Making solid from base face.
 420     TopoDS_Shape aBaseSolid = makeSolidFromShape(aModifiedBaseShape);
 421
 422     // Rotating base face to the specified angle.
 423     gp_Trsf aBaseTrsf;
 424     double aBaseRotAngle = isFromFaceSet ? theToAngle : -theFromAngle;
 425     aBaseTrsf.SetRotation(anAxis, aBaseRotAngle / 180.0 * M_PI);
 426     BRepBuilderAPI_Transform aBaseTransform(aBaseSolid, aBaseTrsf, true);
 427     aBaseSolid = aBaseTransform.Shape();
 428
 429     // Cutting revolution with base.
 430     BRepAlgoAPI_Cut* aBaseCutBuilder = new BRepAlgoAPI_Cut(aResult, aBaseSolid);
 431     aBaseCutBuilder->Build();
 432     if(aBaseCutBuilder->IsDone()) {
 433       TopoDS_Shape aCutResult = aBaseCutBuilder->Shape();
 434       TopoDS_Iterator aCheckIt(aCutResult);
 435       if(aCheckIt.More()) {
 436         this->appendAlgo(std::shared_ptr<GeomAlgoAPI_MakeShape>(new GeomAlgoAPI_MakeShape(aBaseCutBuilder)));
 437         aResult = aCutResult;
 438         if(aResult.ShapeType() == TopAbs_COMPOUND) {
 439           aResult = GeomAlgoAPI_DFLoader::refineResult(aResult);
 440         }
 441         if(aShapeTypeToExp == TopAbs_FACE || aShapeTypeToExp == TopAbs_COMPOUND) {
 442           const TopTools_ListOfShape& aBsShapes = aBaseCutBuilder->Modified(aBoundingFace);
 443           for(TopTools_ListIteratorOfListOfShape anIt(aBsShapes); anIt.More(); anIt.Next()) {
 444             GeomShapePtr aShape(new GeomAPI_Shape());
 445             aShape->setImpl(new TopoDS_Shape(anIt.Value()));
 446             isFromFaceSet ? this->addToShape(aShape) : this->addFromShape(aShape);
 447           }
 448         }
 449       }
 450     }
 451
 452     if(aResult.ShapeType() == TopAbs_COMPOUND) {
 453       std::shared_ptr<GeomAPI_Shape> aGeomShape(new GeomAPI_Shape);
 454       aGeomShape->setImpl(new TopoDS_Shape(aResult));
 455       ListOfShape aCompSolids, aFreeSolids;
 456       aGeomShape = GeomAlgoAPI_ShapeTools::combineShapes(aGeomShape,
 457                                                          GeomAPI_Shape::COMPSOLID,
 458                                                          aCompSolids,
 459                                                          aFreeSolids);
 460       aResult = aGeomShape->impl<TopoDS_Shape>();
 461     }
 462
 463     // If after cut we got more than one solids then take closest to the center of mass of the base face.
 464     aResult = findClosest(aResult, aBaseCentre);
 465
 466     // Setting naming.
 467     if(aShapeTypeToExp == TopAbs_COMPOUND) {
 468       storeGenerationHistory(this, aResult, TopAbs_EDGE, aRotatedBoundingFace, aModifiedBaseShape, isFromFaceSet);
 469       storeGenerationHistory(this, aResult, TopAbs_FACE, aRotatedBoundingFace, aModifiedBaseShape, isFromFaceSet);
 470     } else {
 471       storeGenerationHistory(this, aResult, aShapeTypeToExp, aRotatedBoundingFace, aModifiedBaseShape, isFromFaceSet);
 472     }
 473   }
 474
 475   // Setting result.
 476   if(aResult.IsNull()) {
 477     return;
 478   }
 479   aResult = GeomAlgoAPI_DFLoader::refineResult(aResult);
 480   GeomShapePtr aShape(new GeomAPI_Shape());
 481   aShape->setImpl(new TopoDS_Shape(aResult));
 482   this->setShape(aShape);
 483   this->setDone(true);
 484 }
 485
 486 //==================================================================================================
 487 TopoDS_Face makeFaceFromPlane(gp_Pln& thePlane, const gp_Pnt& thePoint)
 488 {
 489   if(!thePlane.Contains(thePoint, Precision::Confusion())) {
 490     gp_XYZ aVec = thePoint.XYZ() - thePlane.Location().XYZ();
 491     double aSign = aVec * thePlane.Axis().Direction().XYZ();
 492     if(aSign < 0) thePlane.SetAxis(thePlane.Axis().Reversed());
 493   }
 494
 495   BRepBuilderAPI_MakeFace aMakeFace(thePlane);
 496   TopoDS_Face aResultFace = TopoDS::Face(aMakeFace.Shape());
 497
 498   return aResultFace;
 499 }
 500
 501 //==================================================================================================
 502 TopoDS_Solid makeSolidFromShape(const TopoDS_Shape& theShape)
 503 {
 504   TopoDS_Shell aShell;
 505   TopoDS_Solid aSolid;
 506
 507   BRep_Builder aBoundingBuilder;
 508   if(theShape.ShapeType() == TopAbs_SHELL) {
 509     aShell = TopoDS::Shell(theShape);
 510   } else {
 511     aBoundingBuilder.MakeShell(aShell);
 512     aBoundingBuilder.Add(aShell, theShape);
 513   }
 514   aBoundingBuilder.MakeSolid(aSolid);
 515   aBoundingBuilder.Add(aSolid, aShell);
 516
 517   return aSolid;
 518 }
 519
 520 //==================================================================================================
 521 gp_Pnt centreOfMass(const TopoDS_Shape& theShape)
 522 {
 523   TopAbs_ShapeEnum aShType = theShape.ShapeType();
 524   GProp_GProps aGProps;
 525
 526   if(aShType == TopAbs_EDGE || aShType == TopAbs_WIRE) {
 527     BRepGProp::LinearProperties(theShape, aGProps);
 528   } else if(aShType == TopAbs_FACE || aShType == TopAbs_SHELL) {
 529     BRepGProp::SurfaceProperties(theShape, aGProps);
 530   } else if(aShType == TopAbs_SOLID || aShType == TopAbs_COMPSOLID) {
 531     BRepGProp::VolumeProperties(theShape, aGProps);
 532   }
 533
 534   return aGProps.CentreOfMass();
 535 }
 536
 537 //==================================================================================================
 538 TopoDS_Shape findClosest(const TopoDS_Shape& theShape, const gp_Pnt& thePoint)
 539 {
 540   TopoDS_Shape aResult = theShape;
 541
 542   if(theShape.ShapeType() == TopAbs_COMPOUND) {
 543     double aMinDistance = Precision::Infinite();
 544     double aCurDistance;
 545     gp_Pnt aCentr;
 546     for (TopoDS_Iterator anItr(theShape); anItr.More(); anItr.Next()) {
 547       TopoDS_Shape aValue = anItr.Value();
 548       aCentr = centreOfMass(aValue);
 549       aCurDistance = aCentr.Distance(thePoint);
 550
 551       if(aCurDistance < aMinDistance) {
 552         aMinDistance = aCurDistance;
 553         aResult = aValue;
 554       }
 555     }
 556   }
 557
 558   return aResult;
 559 }
 560
 561 //==================================================================================================
 562 void storeGenerationHistory(GeomAlgoAPI_Revolution* theRevolutionAlgo,
 563                             const TopoDS_Shape& theBase,
 564                             const TopAbs_ShapeEnum theType,
 565                             BRepPrimAPI_MakeRevol* theRevolBuilder)
 566 {
 567   for(TopExp_Explorer anExp(theBase, theType); anExp.More(); anExp.Next()) {
 568     const TopoDS_Shape& aShape = anExp.Current();
 569     GeomShapePtr aFromShape(new GeomAPI_Shape), aToShape(new GeomAPI_Shape);
 570     aFromShape->setImpl(new TopoDS_Shape(theRevolBuilder->FirstShape(aShape)));
 571     aToShape->setImpl(new TopoDS_Shape(theRevolBuilder->LastShape(aShape)));
 572     theRevolutionAlgo->addFromShape(aFromShape);
 573     theRevolutionAlgo->addToShape(aToShape);
 574   }
 575 }
 576
 577 //==================================================================================================
 578 void storeGenerationHistory(GeomAlgoAPI_Revolution* theRevolutionAlgo,
 579                             const TopoDS_Shape& theResult,
 580                             const TopAbs_ShapeEnum theType,
 581                             const TopoDS_Shape& theToFace,
 582                             const TopoDS_Shape& theFromFace)
 583 {
 584   for(TopExp_Explorer anExp(theResult, theType); anExp.More (); anExp.Next ()) {
 585     const TopoDS_Shape& aShape = anExp.Current();
 586     GeomShapePtr aGeomSh(new GeomAPI_Shape());
 587     if(theType == TopAbs_VERTEX) {
 588       gp_Pnt aPnt = BRep_Tool::Pnt(TopoDS::Vertex(aShape));
 589       IntTools_Context anIntTools;
 590       if(anIntTools.IsValidPointForFace(aPnt, TopoDS::Face(theToFace), Precision::Confusion()) == Standard_True) {
 591         aGeomSh->setImpl(new TopoDS_Shape(aShape));
 592         theRevolutionAlgo->addToShape(aGeomSh);
 593       }
 594       if(anIntTools.IsValidPointForFace(aPnt, TopoDS::Face(theFromFace), Precision::Confusion()) == Standard_True) {
 595         aGeomSh->setImpl(new TopoDS_Shape(aShape));
 596         theRevolutionAlgo->addFromShape(aGeomSh);
 597       }
 598     } else if(theType == TopAbs_EDGE) {
 599       TopoDS_Edge anEdge = TopoDS::Edge(aShape);
 600       BRepLib_CheckCurveOnSurface anEdgeCheck(anEdge, TopoDS::Face(theToFace));
 601       anEdgeCheck.Perform();
 602       if(anEdgeCheck.MaxDistance() < Precision::Confusion()) {
 603         aGeomSh->setImpl(new TopoDS_Shape(aShape));
 604         theRevolutionAlgo->addToShape(aGeomSh);
 605       }
 606       anEdgeCheck.Init(anEdge, TopoDS::Face(theFromFace));
 607       anEdgeCheck.Perform();
 608       if(anEdgeCheck.MaxDistance() < Precision::Confusion()) {
 609         aGeomSh->setImpl(new TopoDS_Shape(aShape));
 610         theRevolutionAlgo->addFromShape(aGeomSh);
 611       }
 612     } else {
 613       Handle(Geom_Surface) aFaceSurface = BRep_Tool::Surface(TopoDS::Face(aShape));
 614       Handle(Geom_Surface) aFromSurface = BRep_Tool::Surface(TopoDS::Face(theFromFace));
 615       Handle(Geom_Surface) aToSurface = BRep_Tool::Surface(TopoDS::Face(theToFace));
 616       if(aFaceSurface == aFromSurface) {
 617         aGeomSh->setImpl(new TopoDS_Shape(aShape));
 618         theRevolutionAlgo->addFromShape(aGeomSh);
 619       }
 620       if(aFaceSurface == aToSurface) {
 621         aGeomSh->setImpl(new TopoDS_Shape(aShape));
 622         theRevolutionAlgo->addToShape(aGeomSh);
 623       }
 624     }
 625   }
 626 }
 627
 628 void storeGenerationHistory(GeomAlgoAPI_Revolution* theRevolutionAlgo,
 629                             const TopoDS_Shape& theResult,
 630                             const TopAbs_ShapeEnum theType,
 631                             const TopoDS_Shape& theRotatedBoundingFace,
 632                             const TopoDS_Shape& theModifiedBaseShape,
 633                             const bool theIsFromFaceSet)
 634 {
 635   for(TopExp_Explorer anExp(theResult, theType); anExp.More (); anExp.Next ()) {
 636     const TopoDS_Shape& aShape = anExp.Current();
 637     GeomShapePtr aGeomSh(new GeomAPI_Shape());
 638     if(theType == TopAbs_VERTEX) {
 639       gp_Pnt aPnt = BRep_Tool::Pnt(TopoDS::Vertex(aShape));
 640       IntTools_Context anIntTools;
 641       if(anIntTools.IsValidPointForFace(aPnt, TopoDS::Face(theRotatedBoundingFace), Precision::Confusion()) == Standard_True) {
 642         aGeomSh->setImpl(new TopoDS_Shape(aShape));
 643         theIsFromFaceSet ? theRevolutionAlgo->addFromShape(aGeomSh) : theRevolutionAlgo->addToShape(aGeomSh);
 644       }
 645       if(anIntTools.IsValidPointForFace(aPnt, TopoDS::Face(theModifiedBaseShape), Precision::Confusion()) == Standard_True) {
 646         aGeomSh->setImpl(new TopoDS_Shape(aShape));
 647         theIsFromFaceSet ? theRevolutionAlgo->addToShape(aGeomSh) : theRevolutionAlgo->addFromShape(aGeomSh);
 648       }
 649     } else if(theType == TopAbs_EDGE) {
 650       TopoDS_Edge anEdge = TopoDS::Edge(aShape);
 651       BRepLib_CheckCurveOnSurface anEdgeCheck(anEdge, TopoDS::Face(theRotatedBoundingFace));
 652       anEdgeCheck.Perform();
 653       if(anEdgeCheck.MaxDistance() < Precision::Confusion()) {
 654         aGeomSh->setImpl(new TopoDS_Shape(aShape));
 655         theIsFromFaceSet ? theRevolutionAlgo->addFromShape(aGeomSh) : theRevolutionAlgo->addToShape(aGeomSh);
 656       }
 657       anEdgeCheck.Init(anEdge, TopoDS::Face(theModifiedBaseShape));
 658       anEdgeCheck.Perform();
 659       if(anEdgeCheck.MaxDistance() < Precision::Confusion()) {
 660         aGeomSh->setImpl(new TopoDS_Shape(aShape));
 661         theIsFromFaceSet ? theRevolutionAlgo->addToShape(aGeomSh) : theRevolutionAlgo->addFromShape(aGeomSh);
 662       }
 663     } else {
 664       Handle(Geom_Surface) aFaceSurface = BRep_Tool::Surface(TopoDS::Face(aShape));
 665       Handle(Geom_Surface) aBoundingSurface = BRep_Tool::Surface(TopoDS::Face(theRotatedBoundingFace));
 666       Handle(Geom_Surface) aBaseSurface = BRep_Tool::Surface(TopoDS::Face(theModifiedBaseShape));
 667       if(aFaceSurface == aBoundingSurface) {
 668         aGeomSh->setImpl(new TopoDS_Shape(aShape));
 669         theIsFromFaceSet ? theRevolutionAlgo->addFromShape(aGeomSh) : theRevolutionAlgo->addToShape(aGeomSh);
 670       }
 671       if(aFaceSurface == aBaseSurface) {
 672         aGeomSh->setImpl(new TopoDS_Shape(aShape));
 673         theIsFromFaceSet ? theRevolutionAlgo->addToShape(aGeomSh) : theRevolutionAlgo->addFromShape(aGeomSh);
 674       }
 675     }
 676   }
 677 }