#include <BRep_Builder.hxx>
#include <BRepAlgoAPI_Cut.hxx>
#include <BRepBndLib.hxx>
+#include <BRepBuilderAPI_FindPlane.hxx>
#include <BRepBuilderAPI_Transform.hxx>
+#include <BRepTools.hxx>
+#include <Geom_Curve.hxx>
+#include <Geom2d_Curve.hxx>
+#include <BRepLib_CheckCurveOnSurface.hxx>
#include <BRepPrimAPI_MakePrism.hxx>
+#include <Geom_Plane.hxx>
+#include <Geom_RectangularTrimmedSurface.hxx>
#include <gp_Pln.hxx>
#include <IntAna_IntConicQuad.hxx>
#include <IntAna_Quadric.hxx>
+#include <IntTools_Context.hxx>
#include <TopExp_Explorer.hxx>
+#include <TopoDS.hxx>
+#include <TopoDS_Edge.hxx>
#include <TopoDS_Shell.hxx>
#include <TopoDS_Solid.hxx>
#include <TopTools_ListIteratorOfListOfShape.hxx>
-//=================================================================================================
-GeomAlgoAPI_Prism::GeomAlgoAPI_Prism(std::shared_ptr<GeomAPI_Shape> theBaseShape,
- double theToSize,
- double theFromSize)
+
+static void storeGenerationHistory(GeomAlgoAPI_Prism* thePrismAlgo,
+ const TopoDS_Shape& theBase,
+ const TopAbs_ShapeEnum theType,
+ BRepPrimAPI_MakePrism* thePrismBuilder);
+
+static void storeGenerationHistory(GeomAlgoAPI_Prism* thePrismAlgo,
+ const TopoDS_Shape& theResult,
+ const TopAbs_ShapeEnum theType,
+ const TopoDS_Face& theToFace,
+ const TopoDS_Face& theFromFace);
+
+
+//==================================================================================================
+GeomAlgoAPI_Prism::GeomAlgoAPI_Prism(const GeomShapePtr theBaseShape,
+ const double theToSize,
+ const double theFromSize)
+{
+ build(theBaseShape, std::shared_ptr<GeomAPI_Dir>(), GeomShapePtr(), theToSize, GeomShapePtr(), theFromSize);
+}
+
+//==================================================================================================
+GeomAlgoAPI_Prism::GeomAlgoAPI_Prism(const GeomShapePtr theBaseShape,
+ const std::shared_ptr<GeomAPI_Dir> theDirection,
+ const double theToSize,
+ const double theFromSize)
+{
+ build(theBaseShape, theDirection, GeomShapePtr(), theToSize, GeomShapePtr(), theFromSize);
+}
+
+//==================================================================================================
+GeomAlgoAPI_Prism::GeomAlgoAPI_Prism(const GeomShapePtr theBaseShape,
+ const GeomShapePtr theToShape,
+ const double theToSize,
+ const GeomShapePtr theFromShape,
+ const double theFromSize)
{
- build(theBaseShape, std::shared_ptr<GeomAPI_Shape>(), theToSize, std::shared_ptr<GeomAPI_Shape>(), theFromSize);
+ build(theBaseShape, std::shared_ptr<GeomAPI_Dir>(), theToShape, theToSize, theFromShape, theFromSize);
}
-//=================================================================================================
-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)
+//==================================================================================================
+GeomAlgoAPI_Prism::GeomAlgoAPI_Prism(const GeomShapePtr theBaseShape,
+ const std::shared_ptr<GeomAPI_Dir> theDirection,
+ const GeomShapePtr theToShape,
+ const double theToSize,
+ const GeomShapePtr theFromShape,
+ const double theFromSize)
{
- build(theBaseShape, theToShape, theToSize, theFromShape, theFromSize);
+ build(theBaseShape, theDirection, theToShape, theToSize, theFromShape, theFromSize);
}
-//=================================================================================================
-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)
+//==================================================================================================
+void GeomAlgoAPI_Prism::build(const GeomShapePtr& theBaseShape,
+ const std::shared_ptr<GeomAPI_Dir> theDirection,
+ const GeomShapePtr& theToShape,
+ const double theToSize,
+ const GeomShapePtr& theFromShape,
+ const double theFromSize)
{
- if(!theBaseShape ||
- (((!theFromShape && !theToShape) || (theFromShape && theToShape && theFromShape->isEqual(theToShape)))
+ if(!theBaseShape.get() ||
+ (((!theFromShape.get() && !theToShape.get()) || (theFromShape.get() && theToShape.get() && theFromShape->isEqual(theToShape)))
&& (theFromSize == -theToSize))) {
return;
}
- // Getting base plane.
+ // Getting base shape.
const TopoDS_Shape& aBaseShape = theBaseShape->impl<TopoDS_Shape>();
- std::shared_ptr<GeomAPI_Face> aBaseFace;
- 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));
- }
- }
- if(!aBaseFace.get()) {
- return;
+ TopAbs_ShapeEnum aShapeTypeToExp;
+ switch(aBaseShape.ShapeType()) {
+ case TopAbs_VERTEX:
+ aShapeTypeToExp = TopAbs_VERTEX;
+ break;
+ case TopAbs_EDGE:
+ case TopAbs_WIRE:
+ aShapeTypeToExp = TopAbs_EDGE;
+ break;
+ case TopAbs_FACE:
+ case TopAbs_SHELL:
+ aShapeTypeToExp = TopAbs_FACE;
+ break;
+ case TopAbs_COMPOUND:
+ aShapeTypeToExp = TopAbs_COMPOUND;
+ break;
+ default:
+ 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);
+ // Getting direction.
+ gp_Vec aDirVec;
+ std::shared_ptr<GeomAPI_Pnt> aBaseLoc;
+ std::shared_ptr<GeomAPI_Dir> aBaseDir;
+ GeomShapePtr aBasePlane;
+ const bool isBoundingShapesSet = theFromShape.get() || theToShape.get();
+ BRepBuilderAPI_FindPlane aFindPlane(aBaseShape);
+ if(theDirection.get()) {
+ aBaseDir = theDirection;
+ aDirVec = theDirection->impl<gp_Dir>();
+ } else {
+ if(aBaseShape.ShapeType() == TopAbs_VERTEX
+ || aBaseShape.ShapeType() == TopAbs_EDGE
+ || aFindPlane.Found() == Standard_False) {
+ return;
+ }
- gp_Vec aBaseVec(aBaseDir->impl<gp_Dir>());
- const gp_Pnt& aBasePnt = aBaseLoc->impl<gp_Pnt>();
+ Handle(Geom_Plane) aPlane;
+ if(aBaseShape.ShapeType() == TopAbs_FACE || aBaseShape.ShapeType() == TopAbs_SHELL) {
+ TopExp_Explorer anExp(aBaseShape, TopAbs_FACE);
+ const TopoDS_Shape& aFace = anExp.Current();
+ Handle(Geom_Surface) aSurface = BRep_Tool::Surface(TopoDS::Face(aFace));
+ if(aSurface->DynamicType() == STANDARD_TYPE(Geom_RectangularTrimmedSurface)) {
+ Handle(Geom_RectangularTrimmedSurface) aTrimSurface =
+ Handle(Geom_RectangularTrimmedSurface)::DownCast(aSurface);
+ aSurface = aTrimSurface->BasisSurface();
+ }
+ if(aSurface->DynamicType() != STANDARD_TYPE(Geom_Plane)) {
+ return;
+ }
+ aPlane = Handle(Geom_Plane)::DownCast(aSurface);
+ } else {
+ aPlane = aFindPlane.Plane();
+ }
+ gp_Pnt aLoc = aPlane->Axis().Location();
+ aDirVec = aPlane->Axis().Direction();
+ aBaseLoc.reset(new GeomAPI_Pnt(aLoc.X(), aLoc.Y(), aLoc.Z()));
+ aBaseDir.reset(new GeomAPI_Dir(aDirVec.X(), aDirVec.Y(), aDirVec.Z()));
+ }
+ if(!aBaseLoc.get()) {
+ gp_Pnt aLoc;
+ gp_XYZ aDirXYZ = aDirVec.XYZ();
+ Standard_Real aMinParam = Precision::Infinite();
+ for(TopExp_Explorer anExp(aBaseShape, TopAbs_VERTEX); anExp.More(); anExp.Next()) {
+ const TopoDS_Shape& aVertex = anExp.Current();
+ gp_Pnt aPnt = BRep_Tool::Pnt(TopoDS::Vertex(aVertex));
+ double aParam = aDirXYZ.Dot(aPnt.XYZ());
+ if(aParam < aMinParam) {
+ aMinParam = aParam;
+ aLoc = aPnt;
+ }
+ }
+ aBaseLoc.reset(new GeomAPI_Pnt(aLoc.X(), aLoc.Y(), aLoc.Z()));
+ }
+ aBasePlane = GeomAlgoAPI_FaceBuilder::planarFace(aBaseLoc, aBaseDir);
TopoDS_Shape aResult;
- bool isBoundingShapesSet = theFromShape || theToShape;
if(!isBoundingShapesSet) {
// Moving base shape.
gp_Trsf aTrsf;
- aTrsf.SetTranslation(aBaseVec * -theFromSize);
+ aTrsf.SetTranslation(aDirVec * -theFromSize);
BRepBuilderAPI_Transform* aTransformBuilder = new BRepBuilderAPI_Transform(aBaseShape, aTrsf);
if(!aTransformBuilder) {
return;
TopoDS_Shape aMovedBase = aTransformBuilder->Shape();
// Making prism.
- BRepPrimAPI_MakePrism* aPrismBuilder = new BRepPrimAPI_MakePrism(aMovedBase, aBaseVec * (theFromSize + theToSize));
+ BRepPrimAPI_MakePrism* aPrismBuilder = new BRepPrimAPI_MakePrism(aMovedBase, aDirVec * (theFromSize + theToSize));
if(!aPrismBuilder) {
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)));
- this->addFromShape(aFromShape);
- this->addToShape(aToShape);
+ if(aShapeTypeToExp == TopAbs_COMPOUND) {
+ storeGenerationHistory(this, aMovedBase, TopAbs_EDGE, aPrismBuilder);
+ storeGenerationHistory(this, aMovedBase, TopAbs_FACE, aPrismBuilder);
+ } else {
+ storeGenerationHistory(this, aMovedBase, aShapeTypeToExp, aPrismBuilder);
}
} else {
- std::shared_ptr<GeomAPI_Shape> aBoundingFromShape = theFromShape ? theFromShape : aBasePlane;
- std::shared_ptr<GeomAPI_Shape> aBoundingToShape = theToShape ? theToShape : aBasePlane;
+ GeomShapePtr aBoundingFromShape = theFromShape ? theFromShape : aBasePlane;
+ GeomShapePtr 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_Pln> aFromPln = GeomAPI_Face(aBoundingFromShape).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();
+ std::shared_ptr<GeomAPI_Pln> aToPln = GeomAPI_Face(aBoundingToShape).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());
IntAna_Quadric aBndFromQuadric(gp_Pln(aFromPnt->impl<gp_Pnt>(), aFromDir->impl<gp_Dir>()));
Standard_Real aMaxToDist = 0, aMaxFromDist = 0;
for(int i = 0; i < 8; i++) {
- gp_Lin aLine(aPoints[i], aBaseVec);
+ gp_Lin aLine(aPoints[i], aDirVec);
IntAna_IntConicQuad aToIntAna(aLine, aBndToQuadric);
IntAna_IntConicQuad aFromIntAna(aLine, aBndFromQuadric);
if(aToIntAna.NbPoints() == 0 || aFromIntAna.NbPoints() == 0) {
// Moving base shape.
gp_Trsf aTrsf;
- aTrsf.SetTranslation(aBaseVec * -aPrismLength);
+ aTrsf.SetTranslation(aDirVec * -aPrismLength);
BRepBuilderAPI_Transform* aTransformBuilder = new BRepBuilderAPI_Transform(aBaseShape, aTrsf);
if(!aTransformBuilder) {
return;
TopoDS_Shape aMovedBase = aTransformBuilder->Shape();
// Making prism.
- BRepPrimAPI_MakePrism* aPrismBuilder = new BRepPrimAPI_MakePrism(aMovedBase, aBaseVec * 2 * aPrismLength);
+ BRepPrimAPI_MakePrism* aPrismBuilder = new BRepPrimAPI_MakePrism(aMovedBase, aDirVec * 2 * aPrismLength);
if(!aPrismBuilder) {
return;
}
// Orienting bounding planes.
std::shared_ptr<GeomAPI_Pnt> aCentreOfMass = GeomAlgoAPI_ShapeTools::centreOfMass(theBaseShape);
const gp_Pnt& aCentrePnt = aCentreOfMass->impl<gp_Pnt>();
- gp_Lin aLine(aCentrePnt, aBaseVec);
+ gp_Lin aLine(aCentrePnt, aDirVec);
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 * aBaseVec) > 0) {
+ if((aVec * aDirVec) > 0) {
aToDir->setImpl(new gp_Dir(aVec.Reversed()));
aBoundingToShape = GeomAlgoAPI_FaceBuilder::planarFace(aToPnt, aToDir);
}
aVec = aFromDir->impl<gp_Dir>();
- if((aVec * aBaseVec) < 0) {
+ if((aVec * aDirVec) < 0) {
aFromDir->setImpl(new gp_Dir(aVec.Reversed()));
aBoundingFromShape = GeomAlgoAPI_FaceBuilder::planarFace(aFromPnt, aFromDir);
}
} else {
gp_Vec aVec = aToDir->impl<gp_Dir>();
- if((aVec * aBaseVec) < 0) {
+ if((aVec * aDirVec) < 0) {
aToDir->setImpl(new gp_Dir(aVec.Reversed()));
aBoundingToShape = GeomAlgoAPI_FaceBuilder::planarFace(aToPnt, aToDir);
}
aVec = aFromDir->impl<gp_Dir>();
- if((aVec * aBaseVec) > 0) {
+ if((aVec * aDirVec) > 0) {
aFromDir->setImpl(new gp_Dir(aVec.Reversed()));
aBoundingFromShape = GeomAlgoAPI_FaceBuilder::planarFace(aFromPnt, aFromDir);
}
TopoDS_Solid aToSolid, aFromSolid;
const TopoDS_Shape& aToShape = aBoundingToShape->impl<TopoDS_Shape>();
const TopoDS_Shape& aFromShape = aBoundingFromShape->impl<TopoDS_Shape>();
+ TopoDS_Face aToFace = TopoDS::Face(aToShape);
+ TopoDS_Face aFromFace = TopoDS::Face(aFromShape);
BRep_Builder aBoundingBuilder;
aBoundingBuilder.MakeShell(aToShell);
- aBoundingBuilder.MakeShell(aFromShell);
aBoundingBuilder.Add(aToShell, aToShape);
+ aBoundingBuilder.MakeShell(aFromShell);
aBoundingBuilder.Add(aFromShell, aFromShape);
aBoundingBuilder.MakeSolid(aToSolid);
- aBoundingBuilder.MakeSolid(aFromSolid);
aBoundingBuilder.Add(aToSolid, aToShell);
+ aBoundingBuilder.MakeSolid(aFromSolid);
aBoundingBuilder.Add(aFromSolid, aFromShell);
// Cutting with to plane.
return;
}
this->appendAlgo(std::shared_ptr<GeomAlgoAPI_MakeShape>(new GeomAlgoAPI_MakeShape(aToCutBuilder)));
- const TopTools_ListOfShape& aToShapes = aToCutBuilder->Modified(aToShape);
- for(TopTools_ListIteratorOfListOfShape anIt(aToShapes); anIt.More(); anIt.Next()) {
- std::shared_ptr<GeomAPI_Shape> aShape(new GeomAPI_Shape());
- aShape->setImpl(new TopoDS_Shape(anIt.Value()));
- this->addToShape(aShape);
- }
aResult = aToCutBuilder->Shape();
+ if(aResult.ShapeType() == TopAbs_COMPOUND) {
+ aResult = GeomAlgoAPI_DFLoader::refineResult(aResult);
+ }
+ if(aShapeTypeToExp == TopAbs_FACE || aShapeTypeToExp == TopAbs_COMPOUND) {
+ const TopTools_ListOfShape& aToShapes = aToCutBuilder->Modified(aToShape);
+ for(TopTools_ListIteratorOfListOfShape anIt(aToShapes); anIt.More(); anIt.Next()) {
+ GeomShapePtr aGeomSh(new GeomAPI_Shape());
+ aGeomSh->setImpl(new TopoDS_Shape(anIt.Value()));
+ this->addToShape(aGeomSh);
+ }
+ }
// Cutting with from plane.
BRepAlgoAPI_Cut* aFromCutBuilder = new BRepAlgoAPI_Cut(aResult, aFromSolid);
return;
}
this->appendAlgo(std::shared_ptr<GeomAlgoAPI_MakeShape>(new GeomAlgoAPI_MakeShape(aFromCutBuilder)));
- const TopTools_ListOfShape& aFromShapes = aFromCutBuilder->Modified(aFromShape);
- for(TopTools_ListIteratorOfListOfShape anIt(aFromShapes); anIt.More(); anIt.Next()) {
- std::shared_ptr<GeomAPI_Shape> aShape(new GeomAPI_Shape());
- aShape->setImpl(new TopoDS_Shape(anIt.Value()));
- this->addFromShape(aShape);
- }
aResult = aFromCutBuilder->Shape();
-
- TopExp_Explorer anExp(aResult, TopAbs_SOLID);
- if(!anExp.More()) {
+ TopoDS_Iterator aCheckIt(aResult);
+ if(!aCheckIt.More()) {
return;
}
if(aResult.ShapeType() == TopAbs_COMPOUND) {
aResult = GeomAlgoAPI_DFLoader::refineResult(aResult);
}
+ if(aShapeTypeToExp == TopAbs_FACE || aShapeTypeToExp == TopAbs_COMPOUND) {
+ const TopTools_ListOfShape& aFromShapes = aFromCutBuilder->Modified(aFromShape);
+ for(TopTools_ListIteratorOfListOfShape anIt(aFromShapes); anIt.More(); anIt.Next()) {
+ GeomShapePtr aGeomSh(new GeomAPI_Shape());
+ aGeomSh->setImpl(new TopoDS_Shape(anIt.Value()));
+ this->addFromShape(aGeomSh);
+ }
+ }
+
+ // Naming for extrusion from vertex, edge.
+ if(aShapeTypeToExp == TopAbs_COMPOUND) {
+ storeGenerationHistory(this, aResult, TopAbs_EDGE, aToFace, aFromFace);
+ storeGenerationHistory(this, aResult, TopAbs_FACE, aToFace, aFromFace);
+ } else {
+ storeGenerationHistory(this, aResult, aShapeTypeToExp, aToFace, aFromFace);
+ }
+
if(aResult.ShapeType() == TopAbs_COMPOUND) {
- std::shared_ptr<GeomAPI_Shape> aCompound(new GeomAPI_Shape);
- aCompound->setImpl(new TopoDS_Shape(aResult));
+ std::shared_ptr<GeomAPI_Shape> aGeomShape(new GeomAPI_Shape);
+ aGeomShape->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;
- }
+ aGeomShape = GeomAlgoAPI_ShapeTools::combineShapes(aGeomShape,
+ GeomAPI_Shape::COMPSOLID,
+ aCompSolids,
+ aFreeSolids);
+ aResult = aGeomShape->impl<TopoDS_Shape>();
}
}
if(aResult.IsNull()) {
return;
}
- std::shared_ptr<GeomAPI_Shape> aShape(new GeomAPI_Shape());
- aShape->setImpl(new TopoDS_Shape(aResult));
- this->setShape(aShape);
+ aResult = GeomAlgoAPI_DFLoader::refineResult(aResult);
+ GeomShapePtr aGeomSh(new GeomAPI_Shape());
+ aGeomSh->setImpl(new TopoDS_Shape(aResult));
+ this->setShape(aGeomSh);
this->setDone(true);
}
+
+// Auxilary functions:
+//==================================================================================================
+void storeGenerationHistory(GeomAlgoAPI_Prism* thePrismAlgo,
+ const TopoDS_Shape& theBase,
+ const TopAbs_ShapeEnum theType,
+ BRepPrimAPI_MakePrism* thePrismBuilder)
+{
+ for(TopExp_Explorer anExp(theBase, theType); anExp.More(); anExp.Next()) {
+ const TopoDS_Shape& aShape = anExp.Current();
+ GeomShapePtr aFromShape(new GeomAPI_Shape), aToShape(new GeomAPI_Shape);
+ aFromShape->setImpl(new TopoDS_Shape(thePrismBuilder->FirstShape(aShape)));
+ aToShape->setImpl(new TopoDS_Shape(thePrismBuilder->LastShape(aShape)));
+ thePrismAlgo->addFromShape(aFromShape);
+ thePrismAlgo->addToShape(aToShape);
+ }
+}
+
+//==================================================================================================
+void storeGenerationHistory(GeomAlgoAPI_Prism* thePrismAlgo,
+ const TopoDS_Shape& theResult,
+ const TopAbs_ShapeEnum theType,
+ const TopoDS_Face& theToFace,
+ const TopoDS_Face& theFromFace)
+{
+ for(TopExp_Explorer anExp(theResult, theType); anExp.More(); anExp.Next()) {
+ const TopoDS_Shape& aShape = anExp.Current();
+ GeomShapePtr aGeomSh(new GeomAPI_Shape());
+ if(theType == TopAbs_VERTEX) {
+ gp_Pnt aPnt = BRep_Tool::Pnt(TopoDS::Vertex(aShape));
+ IntTools_Context anIntTools;
+ if(anIntTools.IsValidPointForFace(aPnt, theToFace, Precision::Confusion()) == Standard_True) {
+ aGeomSh->setImpl(new TopoDS_Shape(aShape));
+ thePrismAlgo->addToShape(aGeomSh);
+ }
+ if(anIntTools.IsValidPointForFace(aPnt, theFromFace, Precision::Confusion()) == Standard_True) {
+ aGeomSh->setImpl(new TopoDS_Shape(aShape));
+ thePrismAlgo->addFromShape(aGeomSh);
+ }
+ } else if(theType == TopAbs_EDGE) {
+ TopoDS_Edge anEdge = TopoDS::Edge(aShape);
+ BRepLib_CheckCurveOnSurface anEdgeCheck(anEdge, theToFace);
+ anEdgeCheck.Perform();
+ if(anEdgeCheck.MaxDistance() < Precision::Confusion()) {
+ aGeomSh->setImpl(new TopoDS_Shape(aShape));
+ thePrismAlgo->addToShape(aGeomSh);
+ }
+ anEdgeCheck.Init(anEdge, theFromFace);
+ anEdgeCheck.Perform();
+ if(anEdgeCheck.MaxDistance() < Precision::Confusion()) {
+ aGeomSh->setImpl(new TopoDS_Shape(aShape));
+ thePrismAlgo->addFromShape(aGeomSh);
+ }
+ } else {
+ break;
+ }
+ }
+}