Change algorithms for extrusion and revolution building. Now they use algos from...

diff --git a/src/GeomAlgoAPI/GeomAlgoAPI_MakeShape.cpp b/src/GeomAlgoAPI/GeomAlgoAPI_MakeShape.cpp
index 140a0a5831a9ab7b95c3acb8b9e063f3622a6b02..f5e69c52fc1ef53430e26d4145a0427539ad6c3e 100644 (file)
--- a/src/GeomAlgoAPI/GeomAlgoAPI_MakeShape.cpp
+++ b/src/GeomAlgoAPI/GeomAlgoAPI_MakeShape.cpp
@@ -77,6 +77,9 @@ void GeomAlgoAPI_MakeShape::generated(const std::shared_ptr<GeomAPI_Shape> theSh
         return;
       }
       const TopoDS_Shape& aGeneratedShape = aMakePipe->Generated(aSpine, aProfile);
+      if(aGeneratedShape.IsNull()) {
+        continue;
+      }
       std::shared_ptr<GeomAPI_Shape> aShape(new GeomAPI_Shape());
       aShape->setImpl(new TopoDS_Shape(aGeneratedShape));
       theHistory.push_back(aShape);
@@ -91,6 +94,9 @@ void GeomAlgoAPI_MakeShape::generated(const std::shared_ptr<GeomAPI_Shape> theSh
       aList = aBOPBuilder->Generated(theShape->impl<TopoDS_Shape>());
     }
     for(TopTools_ListIteratorOfListOfShape anIt(aList); anIt.More(); anIt.Next()) {
+      if(anIt.Value().IsNull()) {
+        continue;
+      }
       std::shared_ptr<GeomAPI_Shape> aShape(new GeomAPI_Shape());
       aShape->setImpl(new TopoDS_Shape(anIt.Value()));
       theHistory.push_back(aShape);
@@ -111,6 +117,9 @@ void GeomAlgoAPI_MakeShape::modified(const std::shared_ptr<GeomAPI_Shape> theSha
     aList = aBOPBuilder->Modified(theShape->impl<TopoDS_Shape>());
   }
   for(TopTools_ListIteratorOfListOfShape anIt(aList); anIt.More(); anIt.Next()) {
+    if(anIt.Value().IsNull()) {
+      continue;
+    }
     std::shared_ptr<GeomAPI_Shape> aShape(new GeomAPI_Shape());
     aShape->setImpl(new TopoDS_Shape(anIt.Value()));
     theHistory.push_back(aShape);

diff --git a/src/GeomAlgoAPI/GeomAlgoAPI_MakeShapeCustom.cpp b/src/GeomAlgoAPI/GeomAlgoAPI_MakeShapeCustom.cpp
index 318f9b6e5b01afbfdab97825fab51dcfa488bc16..88576740ef4505881b621a1ce0d93189798130eb 100644 (file)
--- a/src/GeomAlgoAPI/GeomAlgoAPI_MakeShapeCustom.cpp
+++ b/src/GeomAlgoAPI/GeomAlgoAPI_MakeShapeCustom.cpp
@@ -48,8 +48,9 @@ void GeomAlgoAPI_MakeShapeCustom::generated(const std::shared_ptr<GeomAPI_Shape>
                                             ListOfShape& theHistory)
 {
   ListOfShape aGenerated;
-  myGenerated.find(theShape, aGenerated);
-  theHistory.insert(theHistory.end(), aGenerated.begin(), aGenerated.end());
+  if(myGenerated.find(theShape, aGenerated)) {
+    theHistory.insert(theHistory.end(), aGenerated.begin(), aGenerated.end());
+  }
 }
 
 //=================================================================================================
@@ -57,8 +58,9 @@ void GeomAlgoAPI_MakeShapeCustom::modified(const std::shared_ptr<GeomAPI_Shape>
                                            ListOfShape& theHistory)
 {
   ListOfShape aModified;
-  myModified.find(theShape, aModified);
-  theHistory.insert(theHistory.end(), aModified.begin(), aModified.end());
+  if(myModified.find(theShape, aModified)) {
+    theHistory.insert(theHistory.end(), aModified.begin(), aModified.end());
+  }
 }
 
 //=================================================================================================

diff --git a/src/GeomAlgoAPI/GeomAlgoAPI_MakeShapeList.cpp b/src/GeomAlgoAPI/GeomAlgoAPI_MakeShapeList.cpp
index 71ed1594745a4cda3130287f39d806d2106e1621..ac243f7bf9d46d85aaaaa5cb01f07206e56edfb3 100644 (file)
--- a/src/GeomAlgoAPI/GeomAlgoAPI_MakeShapeList.cpp
+++ b/src/GeomAlgoAPI/GeomAlgoAPI_MakeShapeList.cpp
@@ -104,6 +104,7 @@ void GeomAlgoAPI_MakeShapeList::result(const std::shared_ptr<GeomAPI_Shape> theS
       const TopoDS_Shape& aSh = aShape->impl<TopoDS_Shape>();
       aMakeShape->generated(aShape, aGeneratedShapes);
       for(ListOfShape::const_iterator anIt = aGeneratedShapes.cbegin(); anIt != aGeneratedShapes.cend(); anIt++) {
+        TopoDS_Shape aSh = (*anIt)->impl<TopoDS_Shape>();
         aTempShapes.Add((*anIt)->impl<TopoDS_Shape>());
         aResultShapes.Add((*anIt)->impl<TopoDS_Shape>());
         hasResults = true;
@@ -111,6 +112,7 @@ void GeomAlgoAPI_MakeShapeList::result(const std::shared_ptr<GeomAPI_Shape> theS
       ListOfShape aModifiedShapes;
       aMakeShape->modified(aShape, aModifiedShapes);
       for(ListOfShape::const_iterator anIt = aModifiedShapes.cbegin(); anIt != aModifiedShapes.cend(); anIt++) {
+        TopoDS_Shape aSH = (*anIt)->impl<TopoDS_Shape>();
         aTempShapes.Add((*anIt)->impl<TopoDS_Shape>());
         aResultShapes.Add((*anIt)->impl<TopoDS_Shape>());
         hasResults = true;

diff --git a/src/GeomAlgoAPI/GeomAlgoAPI_Prism.cpp b/src/GeomAlgoAPI/GeomAlgoAPI_Prism.cpp
index 8c142cb3a77e8fcce9ff1467409dc33721c489ea..04f6ef2a8cbbf6591e507763eebcd59e80c5a32e 100644 (file)
--- a/src/GeomAlgoAPI/GeomAlgoAPI_Prism.cpp
+++ b/src/GeomAlgoAPI/GeomAlgoAPI_Prism.cpp
@@ -18,71 +18,62 @@
 
 #include <Bnd_Box.hxx>
 #include <BRep_Builder.hxx>
-#include <BRep_Tool.hxx>
 #include <BRepAlgoAPI_Cut.hxx>
 #include <BRepBndLib.hxx>
-#include <BRepBuilderAPI_MakeEdge.hxx>
-#include <BRepBuilderAPI_MakeShape.hxx>
-#include <BRepBuilderAPI_MakeWire.hxx>
+#include <BRepBuilderAPI_Transform.hxx>
 #include <BRepCheck_Analyzer.hxx>
 #include <BRepExtrema_ExtCF.hxx>
-#include <BRepFeat_MakePrism.hxx>
 #include <BRepGProp.hxx>
-#include <BRepOffsetAPI_MakePipe.hxx>
-#include <BRepTools.hxx>
-#include <Geom_Plane.hxx>
+#include <BRepPrimAPI_MakePrism.hxx>
 #include <gp_Pln.hxx>
 #include <GProp_GProps.hxx>
 #include <IntAna_IntConicQuad.hxx>
 #include <IntAna_Quadric.hxx>
-#include <TCollection_AsciiString.hxx>
 #include <TopExp_Explorer.hxx>
-#include <TopoDS.hxx>
-#include <TopoDS_Edge.hxx>
 #include <TopoDS_Shell.hxx>
 #include <TopoDS_Solid.hxx>
-#include <TopoDS_Wire.hxx>
 #include <TopTools_ListIteratorOfListOfShape.hxx>
 
 //=================================================================================================
-GeomAlgoAPI_Prism::GeomAlgoAPI_Prism(std::shared_ptr<GeomAPI_Shape> theBasis,
+GeomAlgoAPI_Prism::GeomAlgoAPI_Prism(std::shared_ptr<GeomAPI_Shape> theBaseShape,
                                      double                         theToSize,
                                      double                         theFromSize)
 : myDone(false)
 {
-  build(theBasis, std::shared_ptr<GeomAPI_Shape>(), theToSize, std::shared_ptr<GeomAPI_Shape>(), theFromSize);
+  build(theBaseShape, std::shared_ptr<GeomAPI_Shape>(), theToSize, std::shared_ptr<GeomAPI_Shape>(), theFromSize);
 }
 
 //=================================================================================================
-GeomAlgoAPI_Prism::GeomAlgoAPI_Prism(std::shared_ptr<GeomAPI_Shape> theBasis,
+GeomAlgoAPI_Prism::GeomAlgoAPI_Prism(std::shared_ptr<GeomAPI_Shape> theBaseShape,
                                      std::shared_ptr<GeomAPI_Shape> theToShape,
                                      double                         theToSize,
                                      std::shared_ptr<GeomAPI_Shape> theFromShape,
                                      double                         theFromSize)
 : myDone(false)
 {
-  build(theBasis, theToShape, theToSize, theFromShape, theFromSize);
+  build(theBaseShape, theToShape, theToSize, theFromShape, theFromSize);
 }
 
 //=================================================================================================
-void GeomAlgoAPI_Prism::build(const std::shared_ptr<GeomAPI_Shape>& theBasis,
+void GeomAlgoAPI_Prism::build(const std::shared_ptr<GeomAPI_Shape>& theBaseShape,
                               const std::shared_ptr<GeomAPI_Shape>& theToShape,
                               double                                theToSize,
                               const std::shared_ptr<GeomAPI_Shape>& theFromShape,
                               double                                theFromSize)
 {
-  if(!theBasis ||
+  if(!theBaseShape ||
     (((!theFromShape && !theToShape) || (theFromShape && theToShape && theFromShape->isEqual(theToShape)))
     && (theFromSize == -theToSize))) {
     return;
   }
 
-  // If bounding faces was not set creating them.
+  // Getting base plane.
+  const TopoDS_Shape& aBaseShape = theBaseShape->impl<TopoDS_Shape>();
   std::shared_ptr<GeomAPI_Face> aBaseFace;
-  if(theBasis->shapeType() == GeomAPI_Shape::FACE) {
-    aBaseFace = std::shared_ptr<GeomAPI_Face>(new GeomAPI_Face(theBasis));
-  } else if(theBasis->shapeType() == GeomAPI_Shape::SHELL){
-    GeomAPI_ShapeExplorer anExp(theBasis, GeomAPI_Shape::FACE);
+  if(theBaseShape->shapeType() == GeomAPI_Shape::FACE) {
+    aBaseFace = std::shared_ptr<GeomAPI_Face>(new GeomAPI_Face(theBaseShape));
+  } else if(theBaseShape->shapeType() == GeomAPI_Shape::SHELL){
+    GeomAPI_ShapeExplorer anExp(theBaseShape, GeomAPI_Shape::FACE);
     if(anExp.more()) {
       std::shared_ptr<GeomAPI_Shape> aFaceOnShell = anExp.current();
       aBaseFace = std::shared_ptr<GeomAPI_Face>(new GeomAPI_Face(aFaceOnShell));
@@ -91,77 +82,80 @@ void GeomAlgoAPI_Prism::build(const std::shared_ptr<GeomAPI_Shape>& theBasis,
   if(!aBaseFace.get()) {
     return;
   }
+
   std::shared_ptr<GeomAPI_Pln>   aBasePln = aBaseFace->getPlane();
   std::shared_ptr<GeomAPI_Dir>   aBaseDir = aBasePln->direction();
   std::shared_ptr<GeomAPI_Pnt>   aBaseLoc = aBasePln->location();
   std::shared_ptr<GeomAPI_Shape> aBasePlane = GeomAlgoAPI_FaceBuilder::planarFace(aBaseLoc, aBaseDir);
 
-  std::shared_ptr<GeomAPI_Shape> aBoundingFromShape = theFromShape ? theFromShape : aBasePlane;
-  std::shared_ptr<GeomAPI_Shape> aBoundingToShape   = theToShape   ? theToShape   : aBasePlane;
-
-  // Moving bounding faces according to "from" and "to" sizes.
-  std::shared_ptr<GeomAPI_Face> aFromFace(new GeomAPI_Face(aBoundingFromShape));
-  std::shared_ptr<GeomAPI_Pln>  aFromPln = aFromFace->getPlane();
-  std::shared_ptr<GeomAPI_Pnt>  aFromLoc = aFromPln->location();
-  std::shared_ptr<GeomAPI_Dir>  aFromDir = aFromPln->direction();
-
-  std::shared_ptr<GeomAPI_Face> aToFace(new GeomAPI_Face(aBoundingToShape));
-  std::shared_ptr<GeomAPI_Pln>  aToPln = aToFace->getPlane();
-  std::shared_ptr<GeomAPI_Pnt>  aToLoc = aToPln->location();
-  std::shared_ptr<GeomAPI_Dir>  aToDir = aToPln->direction();
-
-  bool aSign = aFromLoc->xyz()->dot(aBaseDir->xyz()) > aToLoc->xyz()->dot(aBaseDir->xyz());
-
-  std::shared_ptr<GeomAPI_Pnt> aFromPnt(new GeomAPI_Pnt(aFromLoc->xyz()->added(aBaseDir->xyz()->multiplied(
-                                                        aSign ? theFromSize : -theFromSize))));
-  aBoundingFromShape = GeomAlgoAPI_FaceBuilder::planarFace(aFromPnt, aFromDir);
-
-  std::shared_ptr<GeomAPI_Pnt> aToPnt(new GeomAPI_Pnt(aToLoc->xyz()->added(aBaseDir->xyz()->multiplied(
-                                                      aSign ? -theToSize : theToSize))));
-  aBoundingToShape = GeomAlgoAPI_FaceBuilder::planarFace(aToPnt, aToDir);
-
-  if(theBasis->shapeType() == GeomAPI_Shape::FACE) {
-    TopoDS_Face aBasis = TopoDS::Face(aBaseFace->impl<TopoDS_Shape>());
-    const gp_Dir& aNormal = aBaseDir->impl<gp_Dir>();
-    BRepFeat_MakePrism* aBuilder = new BRepFeat_MakePrism(aBasis, aBasis, aBasis, aNormal, 2, Standard_True);
-
-    if(aBuilder) {
-      const TopoDS_Shape& aFromShape = aBoundingFromShape->impl<TopoDS_Shape>();
-      const TopoDS_Shape& aToShape   = aBoundingToShape->impl<TopoDS_Shape>();
-      aBuilder->Perform(aFromShape, aToShape);
-      myDone = aBuilder->IsDone() == Standard_True;
-      if(myDone){
-        TopoDS_Shape aResult = aBuilder->Shape();
-        TopExp_Explorer anExp(aResult, TopAbs_SOLID);
-        if(!anExp.More()) {
-          return;
-        }
-        if(aResult.ShapeType() == TopAbs_COMPOUND) {
-          aResult = GeomAlgoAPI_DFLoader::refineResult(aResult);
-        }
-        // fill data map to keep correct orientation of sub-shapes
-        myMap.reset(new GeomAPI_DataMapOfShapeShape);
-        for (TopExp_Explorer Exp(aResult,TopAbs_FACE); Exp.More(); Exp.Next()) {
-          std::shared_ptr<GeomAPI_Shape> aCurrentShape(new GeomAPI_Shape());
-          aCurrentShape->setImpl(new TopoDS_Shape(Exp.Current()));
-          myMap->bind(aCurrentShape, aCurrentShape);
-        }
-        myShape.reset(new GeomAPI_Shape);
-        myShape->setImpl(new TopoDS_Shape(aResult));
-        std::shared_ptr<GeomAPI_Shape> aFrom(new GeomAPI_Shape());
-        aFrom->setImpl(new TopoDS_Shape(aBuilder->Modified(aFromShape).First()));
-        myFromFaces.push_back(aFrom);
-        std::shared_ptr<GeomAPI_Shape> aTo(new GeomAPI_Shape());
-        aTo->setImpl(new TopoDS_Shape(aBuilder->Modified(aToShape).First()));
-        myToFaces.push_back(aTo);
-        myMkShape.reset(new GeomAlgoAPI_MakeShape(aBuilder));
-      }
+  gp_Vec aBaseVec(aBaseDir->impl<gp_Dir>());
+  const gp_Pnt& aBasePnt = aBaseLoc->impl<gp_Pnt>();
+
+  TopoDS_Shape aResult;
+  ListOfMakeShape aListOfMakeShape;
+  bool isBoundingShapesSet = theFromShape || theToShape;
+  if(!isBoundingShapesSet) {
+    // Moving base shape.
+    gp_Trsf aTrsf;
+    aTrsf.SetTranslation(aBaseVec * -theFromSize);
+    BRepBuilderAPI_Transform* aTransformBuilder = new BRepBuilderAPI_Transform(aBaseShape, aTrsf);
+    if(!aTransformBuilder) {
+      return;
+    }
+    aListOfMakeShape.push_back(std::shared_ptr<GeomAlgoAPI_MakeShape>(new GeomAlgoAPI_MakeShape(aTransformBuilder)));
+    if(!aTransformBuilder->IsDone()) {
+      return;
+    }
+    TopoDS_Shape aMovedBase = aTransformBuilder->Shape();
+
+    // Making prism.
+    BRepPrimAPI_MakePrism* aPrismBuilder = new BRepPrimAPI_MakePrism(aMovedBase, aBaseVec * (theFromSize + theToSize));
+    if(!aPrismBuilder) {
+      return;
+    }
+    aListOfMakeShape.push_back(std::shared_ptr<GeomAlgoAPI_MakeShape>(new GeomAlgoAPI_MakeShape(aPrismBuilder)));
+    if(!aPrismBuilder->IsDone()) {
+      return;
+    }
+    aResult = aPrismBuilder->Shape();
+
+    // Setting naming.
+    for(TopExp_Explorer anExp(aMovedBase, TopAbs_FACE); anExp.More(); anExp.Next()) {
+      const TopoDS_Shape& aFace = anExp.Current();
+      std::shared_ptr<GeomAPI_Shape> aFromShape(new GeomAPI_Shape), aToShape(new GeomAPI_Shape);
+      aFromShape->setImpl(new TopoDS_Shape(aPrismBuilder->FirstShape(aFace)));
+      aToShape->setImpl(new TopoDS_Shape(aPrismBuilder->LastShape(aFace)));
+      myFromFaces.push_back(aFromShape);
+      myToFaces.push_back(aToShape);
     }
   } else {
+    std::shared_ptr<GeomAPI_Shape> aBoundingFromShape = theFromShape ? theFromShape : aBasePlane;
+    std::shared_ptr<GeomAPI_Shape> aBoundingToShape   = theToShape   ? theToShape   : aBasePlane;
+
+    // Moving prism bounding faces according to "from" and "to" sizes.
+    std::shared_ptr<GeomAPI_Face> aFromFace(new GeomAPI_Face(aBoundingFromShape));
+    std::shared_ptr<GeomAPI_Pln>  aFromPln = aFromFace->getPlane();
+    std::shared_ptr<GeomAPI_Pnt>  aFromLoc = aFromPln->location();
+    std::shared_ptr<GeomAPI_Dir>  aFromDir = aFromPln->direction();
+
+    std::shared_ptr<GeomAPI_Face> aToFace(new GeomAPI_Face(aBoundingToShape));
+    std::shared_ptr<GeomAPI_Pln>  aToPln = aToFace->getPlane();
+    std::shared_ptr<GeomAPI_Pnt>  aToLoc = aToPln->location();
+    std::shared_ptr<GeomAPI_Dir>  aToDir = aToPln->direction();
+
+    bool aSign = aFromLoc->xyz()->dot(aBaseDir->xyz()) > aToLoc->xyz()->dot(aBaseDir->xyz());
+
+    std::shared_ptr<GeomAPI_Pnt> aFromPnt(new GeomAPI_Pnt(aFromLoc->xyz()->added(aBaseDir->xyz()->multiplied(
+                                                          aSign ? theFromSize : -theFromSize))));
+    aBoundingFromShape = GeomAlgoAPI_FaceBuilder::planarFace(aFromPnt, aFromDir);
+
+    std::shared_ptr<GeomAPI_Pnt> aToPnt(new GeomAPI_Pnt(aToLoc->xyz()->added(aBaseDir->xyz()->multiplied(
+                                                        aSign ? -theToSize : theToSize))));
+    aBoundingToShape = GeomAlgoAPI_FaceBuilder::planarFace(aToPnt, aToDir);
+
     // Getting bounding box for base shape.
-    const TopoDS_Shape& aBasisShape = theBasis->impl<TopoDS_Shape>();
     Bnd_Box aBndBox;
-    BRepBndLib::Add(aBasisShape, aBndBox);
+    BRepBndLib::Add(aBaseShape, aBndBox);
     Standard_Real aXArr[2] = {aBndBox.CornerMin().X(), aBndBox.CornerMax().X()};
     Standard_Real aYArr[2] = {aBndBox.CornerMin().Y(), aBndBox.CornerMax().Y()};
     Standard_Real aZArr[2] = {aBndBox.CornerMin().Z(), aBndBox.CornerMax().Z()};
@@ -180,9 +174,8 @@ void GeomAlgoAPI_Prism::build(const std::shared_ptr<GeomAPI_Shape>& theBasis,
     IntAna_Quadric aBndToQuadric(gp_Pln(aToPnt->impl<gp_Pnt>(), aToDir->impl<gp_Dir>()));
     IntAna_Quadric aBndFromQuadric(gp_Pln(aFromPnt->impl<gp_Pnt>(), aFromDir->impl<gp_Dir>()));
     Standard_Real aMaxToDist = 0, aMaxFromDist = 0;
-    gp_Vec aNormal(aBaseDir->impl<gp_Dir>());
     for(int i = 0; i < 8; i++) {
-      gp_Lin aLine(aPoints[i], aNormal);
+      gp_Lin aLine(aPoints[i], aBaseVec);
       IntAna_IntConicQuad aToIntAna(aLine, aBndToQuadric);
       IntAna_IntConicQuad aFromIntAna(aLine, aBndFromQuadric);
       if(aToIntAna.NbPoints() == 0 || aFromIntAna.NbPoints() == 0) {
@@ -197,56 +190,61 @@ void GeomAlgoAPI_Prism::build(const std::shared_ptr<GeomAPI_Shape>& theBasis,
         aMaxFromDist = aPoints[i].Distance(aPntOnFromFace);
       }
     }
-    // We added 1 just to be sure that pipe is long enough for boolean operation.
-    Standard_Real aPipeLength = aMaxToDist + aMaxFromDist + 1;
-
-    // Making wire for pipe.
-    std::shared_ptr<GeomAPI_Pnt> aCentreOfMass = GeomAlgoAPI_ShapeTools::centreOfMass(theBasis);
-    const gp_Pnt aCentrePnt = aCentreOfMass->impl<gp_Pnt>();
-    TopoDS_Face aFace = TopoDS::Face(aBaseFace->impl<TopoDS_Shape>());
-    gp_Pnt aPipeStartPnt = aCentrePnt.Translated(aNormal.Scaled(aPipeLength));
-    gp_Pnt aPipeEndPnt = aCentrePnt.Translated(aNormal.Scaled(-aPipeLength));
-    TopoDS_Edge aPipeEdge = BRepBuilderAPI_MakeEdge(aPipeStartPnt, aPipeEndPnt);
-    TopoDS_Wire aPipeWire = BRepBuilderAPI_MakeWire(aPipeEdge).Wire();
-
-    // Making pipe.
-    ListOfMakeShape aListOfMakeShape;
-    BRepOffsetAPI_MakePipe* aPipeBuilder = new BRepOffsetAPI_MakePipe(aPipeWire, aBasisShape);
-    if(!aPipeBuilder) {
+
+    // We added 1 just to be sure that prism is long enough for boolean operation.
+    double aPrismLength = aMaxToDist + aMaxFromDist + 1;
+
+    // Moving base shape.
+    gp_Trsf aTrsf;
+    aTrsf.SetTranslation(aBaseVec * -aPrismLength);
+    BRepBuilderAPI_Transform* aTransformBuilder = new BRepBuilderAPI_Transform(aBaseShape, aTrsf);
+    if(!aTransformBuilder) {
       return;
     }
-    std::shared_ptr<GeomAPI_Shape> aWire(new GeomAPI_Shape);
-    std::shared_ptr<GeomAPI_Shape> aBShape(new GeomAPI_Shape);
-    aWire->setImpl(new TopoDS_Shape(aPipeWire));
-    aBShape->setImpl(new TopoDS_Shape(aBasisShape));
-    aListOfMakeShape.push_back(std::shared_ptr<GeomAlgoAPI_MakeShape>(new GeomAlgoAPI_MakeShape(aPipeBuilder, aWire, aBShape)));
-    TopoDS_Shape aResult = aPipeBuilder->Shape();
+    aListOfMakeShape.push_back(std::shared_ptr<GeomAlgoAPI_MakeShape>(new GeomAlgoAPI_MakeShape(aTransformBuilder)));
+    if(!aTransformBuilder->IsDone()) {
+      return;
+    }
+    TopoDS_Shape aMovedBase = aTransformBuilder->Shape();
+
+    // Making prism.
+    BRepPrimAPI_MakePrism* aPrismBuilder = new BRepPrimAPI_MakePrism(aMovedBase, aBaseVec * 2 * aPrismLength);
+    if(!aPrismBuilder) {
+      return;
+    }
+    aListOfMakeShape.push_back(std::shared_ptr<GeomAlgoAPI_MakeShape>(new GeomAlgoAPI_MakeShape(aPrismBuilder)));
+    if(!aPrismBuilder->IsDone()) {
+      return;
+    }
+    aResult = aPrismBuilder->Shape();
 
     // Orienting bounding planes.
-    gp_Lin aLine(aCentrePnt, aNormal);
+    std::shared_ptr<GeomAPI_Pnt> aCentreOfMass = GeomAlgoAPI_ShapeTools::centreOfMass(theBaseShape);
+    const gp_Pnt& aCentrePnt = aCentreOfMass->impl<gp_Pnt>();
+    gp_Lin aLine(aCentrePnt, aBaseVec);
     IntAna_IntConicQuad aToIntAna(aLine, aBndToQuadric);
     IntAna_IntConicQuad aFromIntAna(aLine, aBndFromQuadric);
     Standard_Real aToParameter = aToIntAna.ParamOnConic(1);
     Standard_Real aFromParameter = aFromIntAna.ParamOnConic(1);
     if(aToParameter > aFromParameter) {
       gp_Vec aVec = aToDir->impl<gp_Dir>();
-      if((aVec * aNormal) > 0) {
+      if((aVec * aBaseVec) > 0) {
         aToDir->setImpl(new gp_Dir(aVec.Reversed()));
         aBoundingToShape = GeomAlgoAPI_FaceBuilder::planarFace(aToPnt, aToDir);
       }
       aVec = aFromDir->impl<gp_Dir>();
-      if((aVec * aNormal) < 0) {
+      if((aVec * aBaseVec) < 0) {
         aFromDir->setImpl(new gp_Dir(aVec.Reversed()));
         aBoundingFromShape = GeomAlgoAPI_FaceBuilder::planarFace(aFromPnt, aFromDir);
       }
     } else {
       gp_Vec aVec = aToDir->impl<gp_Dir>();
-      if((aVec * aNormal) < 0) {
+      if((aVec * aBaseVec) < 0) {
         aToDir->setImpl(new gp_Dir(aVec.Reversed()));
         aBoundingToShape = GeomAlgoAPI_FaceBuilder::planarFace(aToPnt, aToDir);
       }
       aVec = aFromDir->impl<gp_Dir>();
-      if((aVec * aNormal) > 0) {
+      if((aVec * aBaseVec) > 0) {
         aFromDir->setImpl(new gp_Dir(aVec.Reversed()));
         aBoundingFromShape = GeomAlgoAPI_FaceBuilder::planarFace(aFromPnt, aFromDir);
       }
@@ -324,19 +322,27 @@ void GeomAlgoAPI_Prism::build(const std::shared_ptr<GeomAPI_Shape>& theBasis,
         aResult = aResultComp;
       }
     }
+  }
 
-    // Fill data map to keep correct orientation of sub-shapes.
-    myMap = std::shared_ptr<GeomAPI_DataMapOfShapeShape>(new GeomAPI_DataMapOfShapeShape);
-    for (TopExp_Explorer Exp(aResult,TopAbs_FACE); Exp.More(); Exp.Next()) {
-      std::shared_ptr<GeomAPI_Shape> aCurrentShape(new GeomAPI_Shape());
-      aCurrentShape->setImpl(new TopoDS_Shape(Exp.Current()));
-      myMap->bind(aCurrentShape, aCurrentShape);
-    }
-    myShape = std::shared_ptr<GeomAPI_Shape>(new GeomAPI_Shape);
-    myShape->setImpl(new TopoDS_Shape(aResult));
-    myMkShape = std::shared_ptr<GeomAlgoAPI_MakeShapeList>(new GeomAlgoAPI_MakeShapeList(aListOfMakeShape));
-    myDone = true;
+  // Setting result.
+  if(aResult.IsNull()) {
+    return;
+  }
+  myShape.reset(new GeomAPI_Shape);
+  myShape->setImpl(new TopoDS_Shape(aResult));
+
+  // Filling data map to keep correct orientation of sub-shapes.
+  myMap.reset(new GeomAPI_DataMapOfShapeShape);
+  for (TopExp_Explorer Exp(aResult,TopAbs_FACE); Exp.More(); Exp.Next()) {
+    std::shared_ptr<GeomAPI_Shape> aCurrentShape(new GeomAPI_Shape);
+    aCurrentShape->setImpl(new TopoDS_Shape(Exp.Current()));
+    myMap->bind(aCurrentShape, aCurrentShape);
   }
+
+  // Setting list of make shape.
+  myMkShape.reset(new GeomAlgoAPI_MakeShapeList(aListOfMakeShape));
+
+  myDone = true;
 }
 
 //=================================================================================================

diff --git a/src/GeomAlgoAPI/GeomAlgoAPI_Prism.h b/src/GeomAlgoAPI/GeomAlgoAPI_Prism.h
index cb0747181f34d74fad2cb08c539d55c8ba4efe5b..e7c18fcb9af367051b048777238a8cb2b5ca03d4 100644 (file)
--- a/src/GeomAlgoAPI/GeomAlgoAPI_Prism.h
+++ b/src/GeomAlgoAPI/GeomAlgoAPI_Prism.h
@@ -23,22 +23,22 @@ class GeomAlgoAPI_Prism : public GeomAPI_Interface
 {
 public:
   /** \brief Creates extrusion for the given shape along the normal for this shape.
-   *  \param[in] theBasis face or wire to be extruded.
+   *  \param[in] theBaseShape face or wire to be extruded.
    *  \param[in] theToSize offset for "to" plane.
    *  \param[in] theFromSize offset for "from" plane.
    */
-  GEOMALGOAPI_EXPORT GeomAlgoAPI_Prism(std::shared_ptr<GeomAPI_Shape> theBasis,
+  GEOMALGOAPI_EXPORT GeomAlgoAPI_Prism(std::shared_ptr<GeomAPI_Shape> theBaseShape,
                                        double                         theToSize,
                                        double                         theFromSize);
 
   /** \brief Creates extrusion for the given shape along the normal for this shape.
-   *  \param[in] theBasis face or wire to be extruded.
+   *  \param[in] theBaseShape face or wire to be extruded.
    *  \param[in] theToShape top bounding shape.  Can be empty. In this case offset will be applied to the basis.
    *  \param[in] theToSize offset for "to" plane.
    *  \param[in] theFromShape bottom bounding shape. Can be empty. In this case offset will be applied to the basis.
    *  \param[in] theFromSize offset for "from" plane.
    */
-  GEOMALGOAPI_EXPORT GeomAlgoAPI_Prism(std::shared_ptr<GeomAPI_Shape> theBasis,
+  GEOMALGOAPI_EXPORT GeomAlgoAPI_Prism(std::shared_ptr<GeomAPI_Shape> theBaseShape,
                                        std::shared_ptr<GeomAPI_Shape> theToShape,
                                        double                         theToSize,
                                        std::shared_ptr<GeomAPI_Shape> theFromShape,
@@ -70,7 +70,7 @@ public:
 
 private:
   /// Builds resulting shape.
-  void build(const std::shared_ptr<GeomAPI_Shape>& theBasis,
+  void build(const std::shared_ptr<GeomAPI_Shape>& theBaseShape,
              const std::shared_ptr<GeomAPI_Shape>& theToShape,
              double                                theToSize,
              const std::shared_ptr<GeomAPI_Shape>& theFromShape,

diff --git a/src/GeomAlgoAPI/GeomAlgoAPI_Revolution.cpp b/src/GeomAlgoAPI/GeomAlgoAPI_Revolution.cpp
index 544ff79b883cd76ae4eca544f12feb8c68811cc4..21eb56f29320d8bb9291b898013e361dfa8a2a0b 100644 (file)
--- a/src/GeomAlgoAPI/GeomAlgoAPI_Revolution.cpp
+++ b/src/GeomAlgoAPI/GeomAlgoAPI_Revolution.cpp
@@ -10,27 +10,18 @@
 #include <GeomAPI_ShapeExplorer.h>
 #include <GeomAlgoAPI_DFLoader.h>
 #include <GeomAlgoAPI_MakeShapeList.h>
-#include <GeomAlgoAPI_Rotation.h>
 #include <GeomAlgoAPI_ShapeTools.h>
 
 #include <BRep_Builder.hxx>
 #include <BRep_Tool.hxx>
 #include <BRepAlgoAPI_Cut.hxx>
-#include <BRepBuilderAPI_MakeEdge.hxx>
 #include <BRepBuilderAPI_MakeFace.hxx>
 #include <BRepBuilderAPI_Transform.hxx>
-#include <BRepBuilderAPI_MakeWire.hxx>
 #include <BRepCheck_Analyzer.hxx>
 #include <BRepPrimAPI_MakeRevol.hxx>
 #include <BRepGProp.hxx>
-#include <BRepOffsetAPI_MakePipe.hxx>
-#include <BRepTools.hxx>
-#include <Geom_Circle.hxx>
-#include <Geom_Line.hxx>
 #include <Geom_Plane.hxx>
-#include <GeomAPI_ProjectPointOnCurve.hxx>
 #include <GeomLib_IsPlanarSurface.hxx>
-#include <gp_Circ.hxx>
 #include <gp_Pln.hxx>
 #include <GProp_GProps.hxx>
 #include <TopExp_Explorer.hxx>
@@ -38,17 +29,17 @@
 #include <TopTools_ListIteratorOfListOfShape.hxx>
 
 //=================================================================================================
-GeomAlgoAPI_Revolution::GeomAlgoAPI_Revolution(std::shared_ptr<GeomAPI_Shape> theBasis,
+GeomAlgoAPI_Revolution::GeomAlgoAPI_Revolution(std::shared_ptr<GeomAPI_Shape> theBaseShape,
                                                std::shared_ptr<GeomAPI_Ax1>   theAxis,
                                                double                         theToAngle,
                                                double                         theFromAngle)
 : myDone(false)
 {
-  build(theBasis, theAxis, std::shared_ptr<GeomAPI_Shape>(), theToAngle, std::shared_ptr<GeomAPI_Shape>(), theFromAngle);
+  build(theBaseShape, theAxis, std::shared_ptr<GeomAPI_Shape>(), theToAngle, std::shared_ptr<GeomAPI_Shape>(), theFromAngle);
 }
 
 //=================================================================================================
-GeomAlgoAPI_Revolution::GeomAlgoAPI_Revolution(std::shared_ptr<GeomAPI_Shape> theBasis,
+GeomAlgoAPI_Revolution::GeomAlgoAPI_Revolution(std::shared_ptr<GeomAPI_Shape> theBaseShape,
                                                std::shared_ptr<GeomAPI_Ax1>   theAxis,
                                                std::shared_ptr<GeomAPI_Shape> theToShape,
                                                double                         theToAngle,
@@ -56,7 +47,7 @@ GeomAlgoAPI_Revolution::GeomAlgoAPI_Revolution(std::shared_ptr<GeomAPI_Shape> th
                                                double                         theFromAngle)
 : myDone(false)
 {
-  build(theBasis, theAxis, theToShape, theToAngle, theFromShape, theFromAngle);
+  build(theBaseShape, theAxis, theToShape, theToAngle, theFromShape, theFromAngle);
 }
 
 //=================================================================================================
@@ -119,65 +110,43 @@ TopoDS_Shape GeomAlgoAPI_Revolution::findClosest(const TopoDS_Shape& theShape, c
 }
 
 //=================================================================================================
-void GeomAlgoAPI_Revolution::build(const std::shared_ptr<GeomAPI_Shape>& theBasis,
+void GeomAlgoAPI_Revolution::build(const std::shared_ptr<GeomAPI_Shape>& theBaseShape,
                                    const std::shared_ptr<GeomAPI_Ax1>&   theAxis,
                                    const std::shared_ptr<GeomAPI_Shape>& theToShape,
                                    double                                theToAngle,
                                    const std::shared_ptr<GeomAPI_Shape>& theFromShape,
                                    double                                theFromAngle)
 {
-  if(!theBasis || !theAxis ||
+  if(!theBaseShape || !theAxis ||
     (((!theFromShape && !theToShape) || (theFromShape && theToShape && theFromShape->isEqual(theToShape)))
     && (theFromAngle == -theToAngle))) {
     return;
   }
 
-  // Checking that shell is planar.
-  TopoDS_Shape aBasis = theBasis->impl<TopoDS_Shape>();
-  // TODO: fix planar checking
-  //TopExp_Explorer aBasisExp(aBasis, TopAbs_FACE);
-  //for(; aBasisExp.More(); aBasisExp.Next()) {
-  //  const TopoDS_Shape& aCurSh = aBasisExp.Current();
-  //}
-
   // Geting base plane.
-  std::shared_ptr<GeomAPI_Face> aBaseFace;
-  if(theBasis->shapeType() == GeomAPI_Shape::FACE) {
-    aBaseFace = std::shared_ptr<GeomAPI_Face>(new GeomAPI_Face(theBasis));
-  } else if(theBasis->shapeType() == GeomAPI_Shape::SHELL) {
-    GeomAPI_ShapeExplorer anExp(theBasis, GeomAPI_Shape::FACE);
+  const TopoDS_Shape& aBaseShape = theBaseShape->impl<TopoDS_Shape>();
+  TopoDS_Face aBaseFace;
+  if(theBaseShape->shapeType() == GeomAPI_Shape::FACE) {
+    aBaseFace = TopoDS::Face(theBaseShape->impl<TopoDS_Shape>());
+  } else if(theBaseShape->shapeType() == GeomAPI_Shape::SHELL) {
+    GeomAPI_ShapeExplorer anExp(theBaseShape, GeomAPI_Shape::FACE);
     if(anExp.more()) {
       std::shared_ptr<GeomAPI_Shape> aFaceOnShell = anExp.current();
-      aBaseFace = std::shared_ptr<GeomAPI_Face>(new GeomAPI_Face(aFaceOnShell));
+      aBaseFace = TopoDS::Face(aFaceOnShell->impl<TopoDS_Shape>());
     }
   }
-  if(!aBaseFace.get()) {
+  if(aBaseFace.IsNull()) {
     return;
   }
-  TopoDS_Face aBasisFace = TopoDS::Face(aBaseFace->impl<TopoDS_Shape>());
-  GeomLib_IsPlanarSurface isBasisPlanar(BRep_Tool::Surface(aBasisFace));
-  gp_Pln aBasisPln = isBasisPlanar.Plan();
-  Geom_Plane aBasisPlane(aBasisPln);
+  GeomLib_IsPlanarSurface isBasePlanar(BRep_Tool::Surface(aBaseFace));
+  gp_Pln aBasePln = isBasePlanar.Plan();
+  Geom_Plane aBasePlane(aBasePln);
   gp_Ax1 anAxis = theAxis->impl<gp_Ax1>();
-  if(aBasisPlane.Axis().Angle(anAxis) < Precision::Confusion()) {
+  if(aBasePlane.Axis().Angle(anAxis) < Precision::Confusion()) {
     return;
   }
-  gp_Lin anAxisLin(anAxis);
-
-  // Creating circle for pipe.
-  gp_Pnt aBasisCentre = GeomAlgoAPI_ShapeTools::centreOfMass(theBasis)->impl<gp_Pnt>();
-  gp_Pnt aStartPnt = aBasisCentre;
-  const TopoDS_Shape& aBasisShape = theBasis->impl<TopoDS_Shape>();
-  Handle(Geom_Line) anAxisLine = new Geom_Line(anAxis);
-  if(anAxisLin.Contains(aStartPnt, Precision::Confusion())) {
-    aStartPnt.Translate(anAxis.Direction() ^ aBasisPln.Axis().Direction());
-  }
-  GeomAPI_ProjectPointOnCurve aProjection(aStartPnt, anAxisLine);
-  if(aProjection.NbPoints() != 1) {
-    return;
-  }
-  Standard_Real aRadius = aProjection.Distance(1);
-  gp_Circ aCircle(gp_Ax2(aProjection.NearestPoint(), anAxis.Direction()), aRadius);
+
+  gp_Pnt aBaseCentre = GeomAlgoAPI_ShapeTools::centreOfMass(theBaseShape)->impl<gp_Pnt>();
 
   TopoDS_Shape aResult;
   ListOfMakeShape aListOfMakeShape;
@@ -185,74 +154,53 @@ void GeomAlgoAPI_Revolution::build(const std::shared_ptr<GeomAPI_Shape>& theBasi
     // Rotating base face with the negative value of "from angle".
     gp_Trsf aBaseTrsf;
     aBaseTrsf.SetRotation(anAxis, -theFromAngle / 180.0 * M_PI);
-    BRepBuilderAPI_Transform* aBaseTransform = new BRepBuilderAPI_Transform(aBasisShape,
+    BRepBuilderAPI_Transform* aBaseTransform = new BRepBuilderAPI_Transform(aBaseShape,
                                                                             aBaseTrsf,
                                                                             true);
-    if(!aBaseTransform || !aBaseTransform->IsDone()) {
+    if(!aBaseTransform) {
       return;
     }
     aListOfMakeShape.push_back(std::shared_ptr<GeomAlgoAPI_MakeShape>(new GeomAlgoAPI_MakeShape(aBaseTransform)));
-    TopoDS_Shape aRotatedBaseShape = aBaseTransform->Shape();
-
-    if(theBasis->shapeType() == GeomAPI_Shape::FACE) {
-      // Making revolution to the angle equal to the sum of "from angle" and "to angle".
-      double anAngle = theFromAngle + theToAngle;
-      BRepPrimAPI_MakeRevol* aRevolBuilder = new BRepPrimAPI_MakeRevol(aRotatedBaseShape,
-                                                                       anAxis,
-                                                                       anAngle / 180 * M_PI,
-                                                                       Standard_True);
-      aRevolBuilder->Build();
-      if(!aRevolBuilder->IsDone()) {
-        return;
-      }
-      aListOfMakeShape.push_back(std::shared_ptr<GeomAlgoAPI_MakeShape>(new GeomAlgoAPI_MakeShape(aRevolBuilder)));
-      aResult = aRevolBuilder->Shape();
-
-      // Setting naming.
-      std::shared_ptr<GeomAPI_Shape> aFSHape(new GeomAPI_Shape);
-      aFSHape->setImpl(new TopoDS_Shape(aRevolBuilder->FirstShape()));
-      myFromFaces.push_back(aFSHape);
-      std::shared_ptr<GeomAPI_Shape> aTSHape(new GeomAPI_Shape);
-      aTSHape->setImpl(new TopoDS_Shape(aRevolBuilder->LastShape()));
-      myToFaces.push_back(aTSHape);
-    } else {
-      gp_Pnt aFromPnt = aStartPnt.Transformed(aBaseTrsf);
-      aCircle = gp_Circ(gp_Ax2(aProjection.NearestPoint(), anAxis.Direction(), gp_Vec(aProjection.NearestPoint(), aFromPnt)),
-                        aRadius);
-
-      // Making wire for pipe.
-      TopoDS_Edge aPipeEdge = BRepBuilderAPI_MakeEdge(aCircle, 0, (theFromAngle + theToAngle) / 180.0 * M_PI);
-      TopoDS_Wire aPipeWire = BRepBuilderAPI_MakeWire(aPipeEdge).Wire();
-
-      // Making pipe.
-      BRepOffsetAPI_MakePipe* aPipeBuilder = new BRepOffsetAPI_MakePipe(aPipeWire, aRotatedBaseShape);
-      if(!aPipeBuilder || !aPipeBuilder->IsDone()) {
-        return;
-      }
-      std::shared_ptr<GeomAPI_Shape> aWire(new GeomAPI_Shape);
-      std::shared_ptr<GeomAPI_Shape> aBShape(new GeomAPI_Shape);
-      aWire->setImpl(new TopoDS_Shape(aPipeWire));
-      aBShape->setImpl(new TopoDS_Shape(aRotatedBaseShape));
-      aListOfMakeShape.push_back(std::shared_ptr<GeomAlgoAPI_MakeShape>(new GeomAlgoAPI_MakeShape(aPipeBuilder, aWire, aBShape)));
-      aResult = aPipeBuilder->Shape();
-      TopoDS_Shape aToShape = aPipeBuilder->LastShape();
-      TopoDS_Shape aFromShape = aPipeBuilder->FirstShape();
-
-      // Setting naming.
-      TopExp_Explorer anExp(aToShape, TopAbs_FACE);
-      for(; anExp.More(); anExp.Next()) {
-        std::shared_ptr<GeomAPI_Shape> aTSHape(new GeomAPI_Shape);
-        aTSHape->setImpl(new TopoDS_Shape(anExp.Current()));
-        myToFaces.push_back(aTSHape);
-      }
-      anExp.Init(aFromShape, TopAbs_FACE);
-      for(; anExp.More(); anExp.Next()) {
-        std::shared_ptr<GeomAPI_Shape> aFSHape(new GeomAPI_Shape);
-        aFSHape->setImpl(new TopoDS_Shape(anExp.Current()));
-        myFromFaces.push_back(aFSHape);
-      }
+    if(!aBaseTransform->IsDone()) {
+      return;
+    }
+    TopoDS_Shape aRotatedBase = aBaseTransform->Shape();
+
+    // Making revolution to the angle equal to the sum of "from angle" and "to angle".
+    BRepPrimAPI_MakeRevol* aRevolBuilder = new BRepPrimAPI_MakeRevol(aRotatedBase,
+                                                                      anAxis,
+                                                                      (theFromAngle + theToAngle) / 180 * M_PI,
+                                                                      Standard_True);
+    if(!aRevolBuilder) {
+      return;
+    }
+    aListOfMakeShape.push_back(std::shared_ptr<GeomAlgoAPI_MakeShape>(new GeomAlgoAPI_MakeShape(aRevolBuilder)));
+    if(!aRevolBuilder->IsDone()) {
+      return;
+    }
+    aResult = aRevolBuilder->Shape();
+
+    // Setting naming.
+    for(TopExp_Explorer anExp(aRotatedBase, TopAbs_FACE); anExp.More(); anExp.Next()) {
+      const TopoDS_Shape& aFace = anExp.Current();
+      std::shared_ptr<GeomAPI_Shape> aFromShape(new GeomAPI_Shape), aToShape(new GeomAPI_Shape);
+      aFromShape->setImpl(new TopoDS_Shape(aRevolBuilder->FirstShape(aFace)));
+      aToShape->setImpl(new TopoDS_Shape(aRevolBuilder->LastShape(aFace)));
+      myFromFaces.push_back(aFromShape);
+      myToFaces.push_back(aToShape);
     }
   } else if(theFromShape && theToShape) { // Case 2: When both bounding planes were set.
+    // Making revolution to the 360 angle.
+    BRepPrimAPI_MakeRevol* aRevolBuilder = new BRepPrimAPI_MakeRevol(aBaseShape, anAxis, 2 * M_PI, Standard_True);
+    if(!aRevolBuilder) {
+      return;
+    }
+    aListOfMakeShape.push_back(std::shared_ptr<GeomAlgoAPI_MakeShape>(new GeomAlgoAPI_MakeShape(aRevolBuilder)));
+    if(!aRevolBuilder->IsDone()) {
+      return;
+    }
+    aResult = aRevolBuilder->Shape();
+
     // Getting bounding faces.
     TopoDS_Face aFromFace = TopoDS::Face(theFromShape->impl<TopoDS_Shape>());
     TopoDS_Face aToFace   = TopoDS::Face(theToShape->impl<TopoDS_Shape>());
@@ -268,8 +216,8 @@ void GeomAlgoAPI_Revolution::build(const std::shared_ptr<GeomAPI_Shape>& theBasi
 
     // Orienting bounding planes properly so that the center of mass of the base face stays
     // on the result shape after cut.
-    aFromFace = makeFaceFromPlane(aFromPln, aBasisCentre);
-    aToFace   = makeFaceFromPlane(aToPln, aBasisCentre);
+    aFromFace = makeFaceFromPlane(aFromPln, aBaseCentre);
+    aToFace   = makeFaceFromPlane(aToPln, aBaseCentre);
 
     // Making solids from bounding planes and putting them in compound.
     TopoDS_Shape aFromSolid = makeSolidFromShape(aFromFace);
@@ -278,8 +226,8 @@ void GeomAlgoAPI_Revolution::build(const std::shared_ptr<GeomAPI_Shape>& theBasi
     // Rotating bounding planes to the specified angle.
     gp_Trsf aFromTrsf;
     gp_Trsf aToTrsf;
-    double aFromRotAngle = ((aFromPln.Axis().Direction() * aBasisPln.Axis().Direction()) > 0) ? -theFromAngle : theFromAngle;
-    double aToRotAngle = ((aToPln.Axis().Direction() * aBasisPln.Axis().Direction()) > 0) ? -theToAngle : theToAngle;
+    double aFromRotAngle = ((aFromPln.Axis().Direction() * aBasePln.Axis().Direction()) > 0) ? -theFromAngle : theFromAngle;
+    double aToRotAngle = ((aToPln.Axis().Direction() * aBasePln.Axis().Direction()) > 0) ? -theToAngle : theToAngle;
     aFromTrsf.SetRotation(anAxis,aFromRotAngle / 180.0 * M_PI);
     aToTrsf.SetRotation(anAxis, aToRotAngle / 180.0 * M_PI);
     BRepBuilderAPI_Transform aFromTransform(aFromSolid, aFromTrsf, true);
@@ -289,30 +237,6 @@ void GeomAlgoAPI_Revolution::build(const std::shared_ptr<GeomAPI_Shape>& theBasi
     aFromSolid = aFromTransform.Shape();
     aToSolid = aToTransform.Shape();
 
-    // Making revolution to the 360 angle.
-    if(theBasis->shapeType() == GeomAPI_Shape::FACE) {
-      BRepPrimAPI_MakeRevol* aRevolBuilder = new BRepPrimAPI_MakeRevol(aBasisShape, anAxis, 2 * M_PI, Standard_True);
-      aRevolBuilder->Build();
-      aListOfMakeShape.push_back(std::shared_ptr<GeomAlgoAPI_MakeShape>(new GeomAlgoAPI_MakeShape(aRevolBuilder)));
-      aResult = aRevolBuilder->Shape();
-    } else {
-      // Making wire for pipe.
-      TopoDS_Edge aPipeEdge = BRepBuilderAPI_MakeEdge(aCircle, 0, 2 * M_PI);
-      TopoDS_Wire aPipeWire = BRepBuilderAPI_MakeWire(aPipeEdge).Wire();
-
-      // Making pipe.
-      BRepOffsetAPI_MakePipe* aPipeBuilder = new BRepOffsetAPI_MakePipe(aPipeWire, aBasisShape);
-      if(!aPipeBuilder || !aPipeBuilder->IsDone()) {
-        return;
-      }
-      std::shared_ptr<GeomAPI_Shape> aWire(new GeomAPI_Shape);
-      std::shared_ptr<GeomAPI_Shape> aBShape(new GeomAPI_Shape);
-      aWire->setImpl(new TopoDS_Shape(aPipeWire));
-      aBShape->setImpl(new TopoDS_Shape(aBasisShape));
-      aListOfMakeShape.push_back(std::shared_ptr<GeomAlgoAPI_MakeShape>(new GeomAlgoAPI_MakeShape(aPipeBuilder, aWire, aBShape)));
-      aResult = aPipeBuilder->Shape();
-    }
-
     // Cutting revolution with from plane.
     BRepAlgoAPI_Cut* aFromCutBuilder = new BRepAlgoAPI_Cut(aResult, aFromSolid);
     aFromCutBuilder->Build();
@@ -331,8 +255,36 @@ void GeomAlgoAPI_Revolution::build(const std::shared_ptr<GeomAPI_Shape>& theBasi
     aListOfMakeShape.push_back(std::shared_ptr<GeomAlgoAPI_MakeShape>(new GeomAlgoAPI_MakeShape(aToCutBuilder)));
     aResult = aToCutBuilder->Shape();
 
+    TopExp_Explorer anExp(aResult, TopAbs_SOLID);
+    if(!anExp.More()) {
+      return;
+    }
+    if(aResult.ShapeType() == TopAbs_COMPOUND) {
+      aResult = GeomAlgoAPI_DFLoader::refineResult(aResult);
+    }
+    if(aResult.ShapeType() == TopAbs_COMPOUND) {
+      std::shared_ptr<GeomAPI_Shape> aCompound(new GeomAPI_Shape);
+      aCompound->setImpl(new TopoDS_Shape(aResult));
+      ListOfShape aCompSolids, aFreeSolids;
+      GeomAlgoAPI_ShapeTools::combineShapes(aCompound, GeomAPI_Shape::COMPSOLID, aCompSolids, aFreeSolids);
+      if(aCompSolids.size() == 1 && aFreeSolids.size() == 0) {
+        aResult = aCompSolids.front()->impl<TopoDS_Shape>();
+      } else if (aCompSolids.size() > 1 || (aCompSolids.size() >= 1 && aFreeSolids.size() >= 1)) {
+        TopoDS_Compound aResultComp;
+        TopoDS_Builder aBuilder;
+        aBuilder.MakeCompound(aResultComp);
+        for(ListOfShape::const_iterator anIter = aCompSolids.cbegin(); anIter != aCompSolids.cend(); anIter++) {
+          aBuilder.Add(aResultComp, (*anIter)->impl<TopoDS_Shape>());
+        }
+        for(ListOfShape::const_iterator anIter = aFreeSolids.cbegin(); anIter != aFreeSolids.cend(); anIter++) {
+          aBuilder.Add(aResultComp, (*anIter)->impl<TopoDS_Shape>());
+        }
+        aResult = aResultComp;
+      }
+    }
+
     // If after cut we got more than one solids then take closest to the center of mass of the base face.
-    aResult = findClosest(aResult, aBasisCentre);
+    aResult = findClosest(aResult, aBaseCentre);
 
     // Setting naming.
     for(TopExp_Explorer anExp(aResult, TopAbs_FACE); anExp.More (); anExp.Next ()) {
@@ -352,6 +304,17 @@ void GeomAlgoAPI_Revolution::build(const std::shared_ptr<GeomAPI_Shape>& theBasi
       }
     }
   } else { //Case 3: When only one bounding plane was set.
+    // Making revolution to the 360 angle.
+    BRepPrimAPI_MakeRevol* aRevolBuilder = new BRepPrimAPI_MakeRevol(aBaseShape, anAxis, 2 * M_PI, Standard_True);
+    if(!aRevolBuilder) {
+      return;
+    }
+    aListOfMakeShape.push_back(std::shared_ptr<GeomAlgoAPI_MakeShape>(new GeomAlgoAPI_MakeShape(aRevolBuilder)));
+    if(!aRevolBuilder->IsDone()) {
+      return;
+    }
+    aResult = aRevolBuilder->Shape();
+
     // Getting bounding face.
     TopoDS_Face aBoundingFace;
     bool isFromFaceSet = false;
@@ -371,18 +334,17 @@ void GeomAlgoAPI_Revolution::build(const std::shared_ptr<GeomAPI_Shape>& theBasi
 
     // Orienting bounding plane properly so that the center of mass of the base face stays
     // on the result shape after cut.
-    gp_Pnt aBasisCentr = GeomAlgoAPI_ShapeTools::centreOfMass(theBasis)->impl<gp_Pnt>();
-    aBoundingFace = makeFaceFromPlane(aBoundingPln, aBasisCentr);
+    aBoundingFace = makeFaceFromPlane(aBoundingPln, aBaseCentre);
 
     // Making solid from bounding plane.
     TopoDS_Shape aBoundingSolid = makeSolidFromShape(aBoundingFace);
 
     // Rotating bounding plane to the specified angle.
     double aBoundingRotAngle = isFromFaceSet ? theFromAngle : theToAngle;
-    if(aBoundingPln.Axis().IsParallel(aBasisPln.Axis(), Precision::Confusion())) {
+    if(aBoundingPln.Axis().IsParallel(aBasePln.Axis(), Precision::Confusion())) {
       if(isFromFaceSet) aBoundingRotAngle = -aBoundingRotAngle;
     } else {
-      double aSign = (aBoundingPln.Axis().Direction() ^ aBasisPln.Axis().Direction()) *
+      double aSign = (aBoundingPln.Axis().Direction() ^ aBasePln.Axis().Direction()) *
                      anAxis.Direction();
       if((aSign <= 0 && !isFromFaceSet) || (aSign > 0 && isFromFaceSet)) {
         aBoundingRotAngle = -aBoundingRotAngle;
@@ -394,30 +356,6 @@ void GeomAlgoAPI_Revolution::build(const std::shared_ptr<GeomAPI_Shape>& theBasi
     TopoDS_Shape aRotatedBoundingFace = aBoundingTransform.Modified(aBoundingFace).First();
     aBoundingSolid = aBoundingTransform.Shape();
 
-    // Making revolution to the 360 angle.
-    if(theBasis->shapeType() == GeomAPI_Shape::FACE) {
-      BRepPrimAPI_MakeRevol* aRevolBuilder = new BRepPrimAPI_MakeRevol(aBasisShape, anAxis, 2 * M_PI, Standard_True);
-      aRevolBuilder->Build();
-      aListOfMakeShape.push_back(std::shared_ptr<GeomAlgoAPI_MakeShape>(new GeomAlgoAPI_MakeShape(aRevolBuilder)));
-      aResult = aRevolBuilder->Shape();
-    } else {
-      // Making wire for pipe.
-      TopoDS_Edge aPipeEdge = BRepBuilderAPI_MakeEdge(aCircle, 0, 2 * M_PI);
-      TopoDS_Wire aPipeWire = BRepBuilderAPI_MakeWire(aPipeEdge).Wire();
-
-      // Making pipe.
-      BRepOffsetAPI_MakePipe* aPipeBuilder = new BRepOffsetAPI_MakePipe(aPipeWire, aBasisShape);
-      if(!aPipeBuilder || !aPipeBuilder->IsDone()) {
-        return;
-      }
-      std::shared_ptr<GeomAPI_Shape> aWire(new GeomAPI_Shape);
-      std::shared_ptr<GeomAPI_Shape> aBShape(new GeomAPI_Shape);
-      aWire->setImpl(new TopoDS_Shape(aPipeWire));
-      aBShape->setImpl(new TopoDS_Shape(aBasisShape));
-      aListOfMakeShape.push_back(std::shared_ptr<GeomAlgoAPI_MakeShape>(new GeomAlgoAPI_MakeShape(aPipeBuilder, aWire, aBShape)));
-      aResult = aPipeBuilder->Shape();
-    }
-
     // Cutting revolution with bounding plane.
     BRepAlgoAPI_Cut* aBoundingCutBuilder = new BRepAlgoAPI_Cut(aResult, aBoundingSolid);
     aBoundingCutBuilder->Build();
@@ -436,45 +374,77 @@ void GeomAlgoAPI_Revolution::build(const std::shared_ptr<GeomAPI_Shape>& theBasi
     }
 
     // Try to cut with base face. If it can not be done then keep result of cut with bounding plane.
+    TopoDS_Shape aModifiedBaseShape = aBaseShape;
     if(isFromFaceSet) {
-      gp_Trsf aMirrorTrsf;
-      aMirrorTrsf.SetMirror(aBasisPlane.Position().Ax2());
-      BRepBuilderAPI_Transform aMirrorTransform(aBasis, aMirrorTrsf, true);
-      aBasis = aMirrorTransform.Shape();
+      if(aModifiedBaseShape.ShapeType() == TopAbs_FACE) {
+        aModifiedBaseShape.Orientation(TopAbs_REVERSED);
+      } else {
+        gp_Trsf aMirrorTrsf;
+        aMirrorTrsf.SetMirror(aBasePlane.Position().Ax2());
+        BRepBuilderAPI_Transform aMirrorTransform(aModifiedBaseShape, aMirrorTrsf, true);
+        aModifiedBaseShape = aMirrorTransform.Shape();
+      }
     }
 
-    // Making solid from basis face.
-    TopoDS_Shape aBasisSolid = makeSolidFromShape(aBasis);
-
-    // Rotating basis face to the specified angle.
-    gp_Trsf aBasisTrsf;
-    double aBasisRotAngle = isFromFaceSet ? theToAngle : -theFromAngle;
-    aBasisTrsf.SetRotation(anAxis, aBasisRotAngle / 180.0 * M_PI);
-    BRepBuilderAPI_Transform aBasisTransform(aBasisSolid, aBasisTrsf, true);
-    TopoDS_Shape aRotatedBasis = aBasisTransform.Modified(aBasis).First();
-    aBasisSolid = aBasisTransform.Shape();
-
-    // Cutting revolution with basis.
-    BRepAlgoAPI_Cut* aBasisCutBuilder = new BRepAlgoAPI_Cut(aResult, aBasisSolid);
-    aBasisCutBuilder->Build();
-    if(aBasisCutBuilder->IsDone()) {
-      TopoDS_Shape aCutResult = aBasisCutBuilder->Shape();
+    // Making solid from base face.
+    TopoDS_Shape aBaseSolid = makeSolidFromShape(aModifiedBaseShape);
+
+    // Rotating base face to the specified angle.
+    gp_Trsf aBaseTrsf;
+    double aBaseRotAngle = isFromFaceSet ? theToAngle : -theFromAngle;
+    aBaseTrsf.SetRotation(anAxis, aBaseRotAngle / 180.0 * M_PI);
+    BRepBuilderAPI_Transform aBaseTransform(aBaseSolid, aBaseTrsf, true);
+    aBaseSolid = aBaseTransform.Shape();
+
+    // Cutting revolution with base.
+    BRepAlgoAPI_Cut* aBaseCutBuilder = new BRepAlgoAPI_Cut(aResult, aBaseSolid);
+    aBaseCutBuilder->Build();
+    if(aBaseCutBuilder->IsDone()) {
+      TopoDS_Shape aCutResult = aBaseCutBuilder->Shape();
       TopExp_Explorer anExp(aCutResult, TopAbs_SOLID);
       if(anExp.More()) {
-        aListOfMakeShape.push_back(std::shared_ptr<GeomAlgoAPI_MakeShape>(new GeomAlgoAPI_MakeShape(aBasisCutBuilder)));
+        aListOfMakeShape.push_back(std::shared_ptr<GeomAlgoAPI_MakeShape>(new GeomAlgoAPI_MakeShape(aBaseCutBuilder)));
         aResult = aCutResult;
       }
     }
 
-    const TopTools_ListOfShape& aBsShapes = aBasisCutBuilder->Modified(aBoundingFace);
+    const TopTools_ListOfShape& aBsShapes = aBaseCutBuilder->Modified(aBoundingFace);
     for(TopTools_ListIteratorOfListOfShape anIt(aBsShapes); anIt.More(); anIt.Next()) {
       std::shared_ptr<GeomAPI_Shape> aShape(new GeomAPI_Shape());
       aShape->setImpl(new TopoDS_Shape(anIt.Value()));
       isFromFaceSet ? myToFaces.push_back(aShape) : myFromFaces.push_back(aShape);
     }
 
+    TopExp_Explorer anExp(aResult, TopAbs_SOLID);
+    if(!anExp.More()) {
+      return;
+    }
+    if(aResult.ShapeType() == TopAbs_COMPOUND) {
+      aResult = GeomAlgoAPI_DFLoader::refineResult(aResult);
+    }
+    if(aResult.ShapeType() == TopAbs_COMPOUND) {
+      std::shared_ptr<GeomAPI_Shape> aCompound(new GeomAPI_Shape);
+      aCompound->setImpl(new TopoDS_Shape(aResult));
+      ListOfShape aCompSolids, aFreeSolids;
+      GeomAlgoAPI_ShapeTools::combineShapes(aCompound, GeomAPI_Shape::COMPSOLID, aCompSolids, aFreeSolids);
+      if(aCompSolids.size() == 1 && aFreeSolids.size() == 0) {
+        aResult = aCompSolids.front()->impl<TopoDS_Shape>();
+      } else if (aCompSolids.size() > 1 || (aCompSolids.size() >= 1 && aFreeSolids.size() >= 1)) {
+        TopoDS_Compound aResultComp;
+        TopoDS_Builder aBuilder;
+        aBuilder.MakeCompound(aResultComp);
+        for(ListOfShape::const_iterator anIter = aCompSolids.cbegin(); anIter != aCompSolids.cend(); anIter++) {
+          aBuilder.Add(aResultComp, (*anIter)->impl<TopoDS_Shape>());
+        }
+        for(ListOfShape::const_iterator anIter = aFreeSolids.cbegin(); anIter != aFreeSolids.cend(); anIter++) {
+          aBuilder.Add(aResultComp, (*anIter)->impl<TopoDS_Shape>());
+        }
+        aResult = aResultComp;
+      }
+    }
+
     // If after cut we got more than one solids then take closest to the center of mass of the base face.
-    aResult = findClosest(aResult, aBasisCentr);
+    aResult = findClosest(aResult, aBaseCentre);
 
     // Setting naming.
     for(TopExp_Explorer anExp(aResult, TopAbs_FACE); anExp.More (); anExp.Next ()) {
@@ -489,44 +459,24 @@ void GeomAlgoAPI_Revolution::build(const std::shared_ptr<GeomAPI_Shape>& theBasi
     }
   }
 
-  TopExp_Explorer anExp(aResult, TopAbs_SOLID);
-  if(!anExp.More()) {
+  // Setting result.
+  if(aResult.IsNull()) {
     return;
   }
-  if(aResult.ShapeType() == TopAbs_COMPOUND) {
-    aResult = GeomAlgoAPI_DFLoader::refineResult(aResult);
-  }
-  if(aResult.ShapeType() == TopAbs_COMPOUND) {
-    std::shared_ptr<GeomAPI_Shape> aCompound(new GeomAPI_Shape);
-    aCompound->setImpl(new TopoDS_Shape(aResult));
-    ListOfShape aCompSolids, aFreeSolids;
-    GeomAlgoAPI_ShapeTools::combineShapes(aCompound, GeomAPI_Shape::COMPSOLID, aCompSolids, aFreeSolids);
-    if(aCompSolids.size() == 1 && aFreeSolids.size() == 0) {
-      aResult = aCompSolids.front()->impl<TopoDS_Shape>();
-    } else if (aCompSolids.size() > 1 || (aCompSolids.size() >= 1 && aFreeSolids.size() >= 1)) {
-      TopoDS_Compound aResultComp;
-      TopoDS_Builder aBuilder;
-      aBuilder.MakeCompound(aResultComp);
-      for(ListOfShape::const_iterator anIter = aCompSolids.cbegin(); anIter != aCompSolids.cend(); anIter++) {
-        aBuilder.Add(aResultComp, (*anIter)->impl<TopoDS_Shape>());
-      }
-      for(ListOfShape::const_iterator anIter = aFreeSolids.cbegin(); anIter != aFreeSolids.cend(); anIter++) {
-        aBuilder.Add(aResultComp, (*anIter)->impl<TopoDS_Shape>());
-      }
-      aResult = aResultComp;
-    }
-  }
+  myShape.reset(new GeomAPI_Shape);
+  myShape->setImpl(new TopoDS_Shape(aResult));
 
-  // fill data map to keep correct orientation of sub-shapes
-  myMap = std::shared_ptr<GeomAPI_DataMapOfShapeShape>(new GeomAPI_DataMapOfShapeShape());
+  // Filling data map to keep correct orientation of sub-shapes.
+  myMap.reset(new GeomAPI_DataMapOfShapeShape);
   for (TopExp_Explorer Exp(aResult,TopAbs_FACE); Exp.More(); Exp.Next()) {
-    std::shared_ptr<GeomAPI_Shape> aCurrentShape(new GeomAPI_Shape());
+    std::shared_ptr<GeomAPI_Shape> aCurrentShape(new GeomAPI_Shape);
     aCurrentShape->setImpl(new TopoDS_Shape(Exp.Current()));
     myMap->bind(aCurrentShape, aCurrentShape);
   }
-  myShape = std::shared_ptr<GeomAPI_Shape>(new GeomAPI_Shape());
-  myShape->setImpl(new TopoDS_Shape(aResult));
-  myMkShape = std::shared_ptr<GeomAlgoAPI_MakeShapeList>(new GeomAlgoAPI_MakeShapeList(aListOfMakeShape));
+
+  // Setting list of make shape.
+  myMkShape.reset(new GeomAlgoAPI_MakeShapeList(aListOfMakeShape));
+
   myDone = true;
 }
 

diff --git a/src/GeomAlgoAPI/GeomAlgoAPI_Revolution.h b/src/GeomAlgoAPI/GeomAlgoAPI_Revolution.h
index 2484fcee19a99412529d2892760c7a1be107f506..0bb2ddfa589d688260bb93816f7b448a59e6e1f2 100644 (file)
--- a/src/GeomAlgoAPI/GeomAlgoAPI_Revolution.h
+++ b/src/GeomAlgoAPI/GeomAlgoAPI_Revolution.h
@@ -33,25 +33,25 @@ class GeomAlgoAPI_Revolution : public GeomAPI_Interface
 {
 public:
   /** \brief Creates revolution for the given shape.
-   *  \param[in] theBasis face for revolution.
+   *  \param[in] theBaseShape face for revolution.
    *  \param[in] theAxis axis for revolution.
    *  \param[in] theToAngle to angle.
    *  \param[in] theFromAngle from angle.
    */
-  GEOMALGOAPI_EXPORT GeomAlgoAPI_Revolution(std::shared_ptr<GeomAPI_Shape> theBasis,
+  GEOMALGOAPI_EXPORT GeomAlgoAPI_Revolution(std::shared_ptr<GeomAPI_Shape> theBaseShape,
                                             std::shared_ptr<GeomAPI_Ax1>   theAxis,
                                             double                         theToAngle,
                                             double                         theFromAngle);
 
   /** \brief Creates revolution for the given shape.
-   *  \param[in] theBasis face for revolution.
+   *  \param[in] theBaseShape face for revolution.
    *  \param[in] theAxis axis for revolution.
    *  \param[in] theToShape to bounding shape. Can be empty. In this case offset will be applied to the basis.
    *  \param[in] theToAngle to angle.
    *  \param[in] theFromShape from bounding shape. Can be empty. In this case offset will be applied to the basis.
    *  \param[in] theFromAngle from angle.
    */
-  GEOMALGOAPI_EXPORT GeomAlgoAPI_Revolution(std::shared_ptr<GeomAPI_Shape> theBasis,
+  GEOMALGOAPI_EXPORT GeomAlgoAPI_Revolution(std::shared_ptr<GeomAPI_Shape> theBaseShape,
                                             std::shared_ptr<GeomAPI_Ax1>   theAxis,
                                             std::shared_ptr<GeomAPI_Shape> theToShape,
                                             double                         theToAngle,
@@ -102,7 +102,7 @@ private:
   TopoDS_Shape findClosest(const TopoDS_Shape& theShape, const gp_Pnt& thePoint);
 
   /// Builds resulting shape.
-  void build(const std::shared_ptr<GeomAPI_Shape>& theBasis,
+  void build(const std::shared_ptr<GeomAPI_Shape>& theBaseShape,
              const std::shared_ptr<GeomAPI_Ax1>&   theAxis,
              const std::shared_ptr<GeomAPI_Shape>& theToShape,
              double                                theToAngle,