kindred/create
1
1
Fork 0
Code Issues 37 Pull Requests Actions Packages Projects 9 Releases 2 Wiki Activity

PartDesign, 758, 766, 773, 775: several improvements, fixes and code refactoring for Pad and Pocket

Browse Source
This commit is contained in:
jrheinlaender
2012-11-03 23:07:48 +01:00
committed by logari81
parent 83cca85c1c
commit 13d68e99aa
12 changed files with 795 additions and 462 deletions
Download Patch File Download Diff File Expand all files Collapse all files

196
src/Mod/PartDesign/App/FeaturePad.cpp
View File

@@ -26,7 +26,7 @@
# include <BRep_Builder.hxx>
# include <BRep_Tool.hxx>
# include <BRepBndLib.hxx>
# include <BRepPrimAPI_MakePrism.hxx>
# include <BRepFeat_MakePrism.hxx>
# include <BRepBuilderAPI_MakeFace.hxx>
# include <Handle_Geom_Surface.hxx>
# include <TopoDS.hxx>
@@ -58,7 +58,7 @@ Pad::Pad()
Type.setEnums(TypeEnums);
ADD_PROPERTY(Length,(100.0));
ADD_PROPERTY(Length2,(100.0));
ADD_PROPERTY(FaceName,(""));
ADD_PROPERTY_TYPE(UpToFace,(0),"Pad",(App::PropertyType)(App::Prop_None),"Face where feature will end");
}
short Pad::mustExecute() const
@@ -66,7 +66,7 @@ short Pad::mustExecute() const
if (Placement.isTouched() ||
Length.isTouched() ||
Length2.isTouched() ||
FaceName.isTouched())
UpToFace.isTouched())
return 1;
return Additive::mustExecute();
}
@@ -108,171 +108,57 @@ App::DocumentObjectExecReturn *Pad::execute(void)
TopLoc_Location invObjLoc = this->getLocation().Inverted();
try {
// TopoDS::Face is not strictly necessary, but it will through an exception for
// invalid wires e.g. intersections or multiple separate wires
TopoDS_Shape aFace = TopoDS::Face(makeFace(wires));
if (aFace.IsNull())
return new App::DocumentObjectExecReturn("Creating a face from sketch failed");
support.Move(invObjLoc);
// extrude the face to a solid
gp_Dir dir(SketchVector.x,SketchVector.y,SketchVector.z);
dir.Transform(invObjLoc.Transformation());
TopoDS_Shape sketchshape = makeFace(wires);
if (sketchshape.IsNull())
return new App::DocumentObjectExecReturn("Pad: Creating a face from sketch failed");
sketchshape.Move(invObjLoc);
TopoDS_Shape prism;
bool isSolid = false; // support is a solid?
bool isSolidChecked = false; // not checked yet
std::string method(Type.getValueAsString());
if (method == "UpToFirst" || method == "UpToLast" || method == "UpToFace") {
TopoDS_Face supportface = getSupportFace();
supportface.Move(invObjLoc);
if ((std::string(Type.getValueAsString()) == "UpToLast") ||
(std::string(Type.getValueAsString()) == "UpToFirst") ||
(std::string(Type.getValueAsString()) == "UpToFace"))
{
// Find a valid face to extrude up to
TopoDS_Face upToFace;
gp_Dir dir(SketchVector.x,SketchVector.y,SketchVector.z);
if ((std::string(Type.getValueAsString()) == "UpToLast") ||
(std::string(Type.getValueAsString()) == "UpToFirst"))
{
// Check for valid support object
if (support.IsNull())
return new App::DocumentObjectExecReturn("Cannot extrude up to face: No valid support in Sketch");
TopExp_Explorer xp (support, TopAbs_SOLID);
if (!xp.More())
return new App::DocumentObjectExecReturn("Cannot extrude up to face: Support shape is not a solid");
isSolid = true;
isSolidChecked = true;
TopoDS_Shape origFace = makeFace(wires); // original sketch face before moving one unit
std::vector<Part::cutFaces> cfaces = Part::findAllFacesCutBy(support, origFace, dir);
if (cfaces.empty())
return new App::DocumentObjectExecReturn("No faces found in this direction");
// Find nearest/furthest face
std::vector<Part::cutFaces>::const_iterator it, it_near, it_far;
it_near = it_far = cfaces.begin();
for (it = cfaces.begin(); it != cfaces.end(); it++)
if (it->distsq > it_far->distsq)
it_far = it;
else if (it->distsq < it_near->distsq)
it_near = it;
upToFace = (std::string(Type.getValueAsString()) == "UpToLast" ? it_far->face : it_near->face);
} else {
if (FaceName.isEmpty())
return new App::DocumentObjectExecReturn("Cannot extrude up to face: No face selected");
// Get active object, this is the object that the user referenced when he clicked on the face!
App::DocumentObject* baseLink = this->getDocument()->getActiveObject();
if (!baseLink)
return new App::DocumentObjectExecReturn("Cannot extrude up to face: No object linked");
if (!baseLink->getTypeId().isDerivedFrom(Part::Feature::getClassTypeId()))
return new App::DocumentObjectExecReturn("Cannot extrude up to face: Linked object is not a Part object");
Part::Feature *base = static_cast<Part::Feature*>(baseLink);
const Part::TopoShape& baseShape = base->Shape.getShape();
if (baseShape._Shape.IsNull())
return new App::DocumentObjectExecReturn("Cannot extrude up to face: Cannot work on invalid shape");
TopoDS_Shape sub = baseShape.getSubShape(FaceName.getValue());
if (!sub.IsNull() && sub.ShapeType() == TopAbs_FACE)
upToFace = TopoDS::Face(sub);
else
return new App::DocumentObjectExecReturn("Cannot extrude up to face: Selection is not a face");
// Validate face
// TODO: This would also exclude faces that are valid but not cut by the line
// So for now we trust to the intelligence of the user when picking the face
/*std::vector<cutFaces> cfaces = findAllFacesCutBy(upToFace, origFace, dir);
if (cfaces.empty())
return new App::DocumentObjectExecReturn("No faces found in this direction");*/
if (method == "UpToFace") {
getUpToFaceFromLinkSub(upToFace, UpToFace);
upToFace.Move(invObjLoc);
}
getUpToFace(upToFace, support, supportface, sketchshape, method, dir);
// A support object is always required and we need to use BRepFeat_MakePrism
// Problem: For Pocket/UpToFirst (or an equivalent Pocket/UpToFace) the resulting shape is invalid
// because the feature does not add any material. This only happens with the "2" option, though
// Note: It might be possible to pass a shell or a compound containing multiple faces
// as the Until parameter of Perform()
BRepFeat_MakePrism PrismMaker;
PrismMaker.Init(support, sketchshape, supportface, dir, 2, 1);
PrismMaker.Perform(upToFace);
// Create semi-infinite prism from sketch in direction dir
// Hack, because the two lines commented out below do NOT work!!!
SketchVector *= 1E6;
gp_Vec vec(SketchVector.x,SketchVector.y,SketchVector.z);
vec.Transform(invObjLoc.Transformation());
BRepPrimAPI_MakePrism PrismMaker(aFace.Moved(invObjLoc),vec,0,1); // very long, but finite prism
//dir.Transform(invObjLoc.Transformation());
//BRepPrimAPI_MakePrism PrismMaker(aFace.Moved(invObjLoc),dir,0,0,1);
if (!PrismMaker.IsDone())
return new App::DocumentObjectExecReturn("Cannot extrude up to face: Could not extrude the sketch!");
// Cut off the prism at the face we found
// Grab any point from the sketch
TopExp_Explorer exp;
exp.Init(aFace, TopAbs_VERTEX);
if (!exp.More())
return new App::DocumentObjectExecReturn("Cannot extrude up to face: Sketch without points?");
gp_Pnt aPnt = BRep_Tool::Pnt(TopoDS::Vertex(exp.Current()));
// Create a halfspace from the face, extending in direction of sketch plane
BRepPrimAPI_MakeHalfSpace mkHalfSpace(upToFace, aPnt);
if (!mkHalfSpace.IsDone())
return new App::DocumentObjectExecReturn("Cannot extrude up to face: HalfSpace creation failed");
// Find common material between halfspace and prism
BRepAlgoAPI_Common mkCommon(PrismMaker.Shape(), mkHalfSpace.Solid().Moved(invObjLoc));
if (!mkCommon.IsDone())
return new App::DocumentObjectExecReturn("Cannot extrude up to face: Common creation failed");
prism = this->getSolid(mkCommon.Shape());
if (prism.IsNull())
return new App::DocumentObjectExecReturn("Cannot extrude up to face: Resulting shape is not a solid");
} else if ((std::string(Type.getValueAsString()) == "Length") ||
(std::string(Type.getValueAsString()) == "TwoLengths")) {
if (std::string(Type.getValueAsString()) == "Length") {
if (Midplane.getValue()) {
// Move face by half the extrusion distance to get pad symmetric to sketch plane
gp_Trsf mov;
mov.SetTranslation(gp_Vec(SketchVector.x,SketchVector.y,SketchVector.z) * (-1.0) * L/2.0);
TopLoc_Location loc(mov);
aFace.Move(loc);
} else if (Reversed.getValue()) { // negative direction
SketchVector *= -1.0;
}
// lengthen the vector
SketchVector *= L;
} else {
// Move face by the second length to get pad extending to both sides of sketch plane
gp_Trsf mov;
mov.SetTranslation(gp_Vec(SketchVector.x,SketchVector.y,SketchVector.z) * (-1.0) * L2);
TopLoc_Location loc(mov);
aFace.Move(loc);
// lengthen the vector
SketchVector *= (L + L2);
}
// create the extrusion
gp_Vec vec(SketchVector.x,SketchVector.y,SketchVector.z);
vec.Transform(invObjLoc.Transformation());
BRepPrimAPI_MakePrism PrismMaker(aFace.Moved(invObjLoc),vec,0,1); // finite prism
if (!PrismMaker.IsDone())
return new App::DocumentObjectExecReturn("Could not extrude the sketch!");
return new App::DocumentObjectExecReturn("Pad: Up to face: Could not extrude the sketch!");
prism = PrismMaker.Shape();
} else {
return new App::DocumentObjectExecReturn("Internal error: Unknown type for Pad feature");
generatePrism(prism, sketchshape, method, dir, L, L2,
Midplane.getValue(), Reversed.getValue());
}
if (prism.IsNull())
return new App::DocumentObjectExecReturn("Pad: Resulting shape is empty");
// set the additive shape property for later usage in e.g. pattern
this->AddShape.setValue(prism);
// if the sketch has a support fuse them to get one result object
if (!support.IsNull()) {
if (!isSolidChecked) { // we haven't checked for solid, yet
if (!support.IsNull()) {
TopExp_Explorer xp;
xp.Init(support,TopAbs_SOLID);
for (;xp.More(); xp.Next()) {
isSolid = true;
break;
}
}
if (!isSolid)
return new App::DocumentObjectExecReturn("Support is not a solid");
}
// Let's call algorithm computing a fuse operation:
BRepAlgoAPI_Fuse mkFuse(support.Moved(invObjLoc), prism);
BRepAlgoAPI_Fuse mkFuse(support, prism);
// Let's check if the fusion has been successful
if (!mkFuse.IsDone())
return new App::DocumentObjectExecReturn("Pad: Fusion with support failed");
@@ -283,12 +169,8 @@ App::DocumentObjectExecReturn *Pad::execute(void)
if (solRes.IsNull())
return new App::DocumentObjectExecReturn("Pad: Resulting shape is not a solid");
this->Shape.setValue(solRes);
}
else {
TopoDS_Shape result = this->getSolid(prism);
// set the additive shape property for later usage in e.g. pattern
this->AddShape.setValue(result);
this->Shape.setValue(result);
} else {
this->Shape.setValue(prism);
}
return App::DocumentObject::StdReturn;

2
src/Mod/PartDesign/App/FeaturePad.h
View File

@@ -41,7 +41,7 @@ public:
App::PropertyEnumeration Type;
App::PropertyLength Length;
App::PropertyLength Length2;
App::PropertyString FaceName;
App::PropertyLinkSub UpToFace;
/** @name methods override feature */
//@{

205
src/Mod/PartDesign/App/FeaturePocket.cpp
View File

@@ -27,10 +27,9 @@
# include <gp_Dir.hxx>
# include <gp_Pln.hxx>
# include <BRep_Builder.hxx>
# include <BRep_Tool.hxx>
# include <BRepAdaptor_Surface.hxx>
# include <BRepBndLib.hxx>
# include <BRepPrimAPI_MakePrism.hxx>
# include <BRepFeat_MakePrism.hxx>
# include <BRepBuilderAPI_MakeFace.hxx>
# include <Geom_Plane.hxx>
# include <Handle_Geom_Surface.hxx>
@@ -52,7 +51,7 @@
using namespace PartDesign;
const char* Pocket::TypeEnums[]= {"Length","UpToLast","UpToFirst","ThroughAll","UpToFace",NULL};
const char* Pocket::TypeEnums[]= {"Length","ThroughAll","UpToFirst","UpToFace",NULL};
PROPERTY_SOURCE(PartDesign::Pocket, PartDesign::Subtractive)
@@ -61,20 +60,26 @@ Pocket::Pocket()
ADD_PROPERTY(Type,((long)0));
Type.setEnums(TypeEnums);
ADD_PROPERTY(Length,(100.0));
ADD_PROPERTY(FaceName,(""));
ADD_PROPERTY_TYPE(UpToFace,(0),"Pocket",(App::PropertyType)(App::Prop_None),"Face where feature will end");
}
short Pocket::mustExecute() const
{
if (Placement.isTouched() ||
Length.isTouched() ||
FaceName.isTouched())
UpToFace.isTouched())
return 1;
return Subtractive::mustExecute();
}
App::DocumentObjectExecReturn *Pocket::execute(void)
{
// Handle legacy features, these typically have Type set to 3 (previously NULL, now UpToFace),
// empty FaceName (because it didn't exist) and a value for Length
if (std::string(Type.getValueAsString()) == "UpToFace" &&
(UpToFace.getValue() == NULL && Length.getValue() > Precision::Confusion()))
Type.setValue("Length");
// Validate parameters
double L = Length.getValue();
if ((std::string(Type.getValueAsString()) == "Length") && (L < Precision::Confusion()))
@@ -97,156 +102,84 @@ App::DocumentObjectExecReturn *Pocket::execute(void)
Base::Vector3d SketchVector(0,0,1);
SketchOrientation.multVec(SketchVector,SketchVector);
// turn around for pockets
SketchVector *= -1;
this->positionBySketch();
TopLoc_Location invObjLoc = this->getLocation().Inverted();
try {
TopoDS_Face aFace = TopoDS::Face(makeFace(wires));
if (aFace.IsNull())
return new App::DocumentObjectExecReturn("Pocket: Creating a face from sketch failed");
// This is a trick to avoid problems with the cut operation. Sometimes a cut doesn't
// work as expected if faces are coincident. Thus, we move the face in normal direction
// but make it longer by one unit in the opposite direction.
// TODO: Isn't one unit (one millimeter) a lot, assuming someone models a really tiny solid?
// What about using 2 * Precision::Confusion() ?
gp_Trsf mov;
mov.SetTranslation(gp_Vec(SketchVector.x,SketchVector.y,SketchVector.z));
TopLoc_Location loc(mov);
aFace.Move(loc);
support.Move(invObjLoc);
// lengthen the vector
SketchVector *= (Length.getValue()+1);
gp_Dir dir(SketchVector.x,SketchVector.y,SketchVector.z);
dir.Transform(invObjLoc.Transformation());
// turn around for pockets
SketchVector *= -1;
TopoDS_Shape sketchshape = makeFace(wires);
if (sketchshape.IsNull())
return new App::DocumentObjectExecReturn("Pocket: Creating a face from sketch failed");
sketchshape.Move(invObjLoc);
// extrude the face to a solid
TopoDS_Shape prism;
std::string method(Type.getValueAsString());
if (method == "UpToFirst" || method == "UpToFace") {
TopoDS_Face supportface = getSupportFace();
supportface.Move(invObjLoc);
if ((std::string(Type.getValueAsString()) == "UpToLast") ||
(std::string(Type.getValueAsString()) == "UpToFirst") ||
(std::string(Type.getValueAsString()) == "UpToFace"))
{
// Find a valid face to extrude up to
TopoDS_Face upToFace;
gp_Dir dir(SketchVector.x,SketchVector.y,SketchVector.z);
if ((std::string(Type.getValueAsString()) == "UpToLast") ||
(std::string(Type.getValueAsString()) == "UpToFirst"))
{
TopoDS_Shape origFace = makeFace(wires); // original sketch face before moving one unit
std::vector<Part::cutFaces> cfaces = Part::findAllFacesCutBy(support, origFace, dir);
if (cfaces.empty())
return new App::DocumentObjectExecReturn("No faces found in this direction");
// Find nearest/furthest face
std::vector<Part::cutFaces>::const_iterator it, it_near, it_far;
it_near = it_far = cfaces.begin();
for (it = cfaces.begin(); it != cfaces.end(); it++)
if (it->distsq > it_far->distsq)
it_far = it;
else if (it->distsq < it_near->distsq)
it_near = it;
upToFace = (std::string(Type.getValueAsString()) == "UpToLast" ? it_far->face : it_near->face);
} else {
if (FaceName.isEmpty())
return new App::DocumentObjectExecReturn("Cannot extrude up to face: No face selected");
// Get active object, this is the object that the user referenced when he clicked on the face!
App::DocumentObject* baseLink = this->getDocument()->getActiveObject();
if (!baseLink)
return new App::DocumentObjectExecReturn("Cannot extrude up to face: No object linked");
if (!baseLink->getTypeId().isDerivedFrom(Part::Feature::getClassTypeId()))
return new App::DocumentObjectExecReturn("Cannot extrude up to face: Linked object is not a Part object");
Part::Feature *base = static_cast<Part::Feature*>(baseLink);
const Part::TopoShape& baseShape = base->Shape.getShape();
if (baseShape._Shape.IsNull())
return new App::DocumentObjectExecReturn("Cannot extrude up to face: Cannot work on invalid shape");
TopoDS_Shape sub = baseShape.getSubShape(FaceName.getValue());
if (!sub.IsNull() && sub.ShapeType() == TopAbs_FACE)
upToFace = TopoDS::Face(sub);
else
return new App::DocumentObjectExecReturn("Cannot extrude up to face: Selection is not a face");
// Find the origin of this face (i.e. a vertex or a edge in a sketch)
TopoDS_Shape origin = base->findOriginOf(sub);
// Validate face
// TODO: This would also exclude faces that are valid but not cut by the line
// So for now we trust to the intelligence of the user when picking the face
/*std::vector<cutFaces> cfaces = findAllFacesCutBy(upToFace, origFace, dir);
if (cfaces.empty())
return new App::DocumentObjectExecReturn("No faces found in this direction");*/
if (method == "UpToFace") {
getUpToFaceFromLinkSub(upToFace, UpToFace);
upToFace.Move(invObjLoc);
}
getUpToFace(upToFace, support, supportface, sketchshape, method, dir);
// Special treatment because often the created stand-alone prism is invalid (empty) because
// BRepFeat_MakePrism(..., 2, 1) is buggy
BRepFeat_MakePrism PrismMaker;
PrismMaker.Init(support, sketchshape, supportface, dir, 0, 1);
PrismMaker.Perform(upToFace);
// Create semi-infinite prism from sketch in direction dir
dir.Transform(invObjLoc.Transformation());
BRepPrimAPI_MakePrism PrismMaker(aFace.Moved(invObjLoc),dir,0,0,1);
if (!PrismMaker.IsDone())
return new App::DocumentObjectExecReturn("Cannot extrude up to face: Could not extrude the sketch!");
return new App::DocumentObjectExecReturn("Pocket: Up to face: Could not extrude the sketch!");
TopoDS_Shape prism = PrismMaker.Shape();
// Cut off the prism at the face we found
// Grab any point from the sketch
TopExp_Explorer exp;
exp.Init(aFace, TopAbs_VERTEX);
if (!exp.More())
return new App::DocumentObjectExecReturn("Cannot extrude up to face: Sketch without points?");
gp_Pnt aPnt = BRep_Tool::Pnt(TopoDS::Vertex(exp.Current()));
// Create a halfspace from the face, extending in direction of sketch plane
BRepPrimAPI_MakeHalfSpace mkHalfSpace(upToFace, aPnt);
if (!mkHalfSpace.IsDone())
return new App::DocumentObjectExecReturn("Cannot extrude up to face: HalfSpace creation failed");
// Find common material between halfspace and prism
BRepAlgoAPI_Common mkCommon(PrismMaker.Shape(), mkHalfSpace.Solid().Moved(invObjLoc));
if (!mkCommon.IsDone())
return new App::DocumentObjectExecReturn("Cannot extrude up to face: Common creation failed");
prism = this->getSolid(mkCommon.Shape());
if (prism.IsNull())
return new App::DocumentObjectExecReturn("Cannot extrude up to face: Resulting shape is not a solid");
} else if (std::string(Type.getValueAsString()) == "ThroughAll") {
gp_Dir dir(SketchVector.x,SketchVector.y,SketchVector.z);
dir.Transform(invObjLoc.Transformation());
BRepPrimAPI_MakePrism PrismMaker(aFace.Moved(invObjLoc),dir,1,0,1); // infinite prism (in both directions!)
if (!PrismMaker.IsDone())
return new App::DocumentObjectExecReturn("Could not extrude the sketch!");
prism = PrismMaker.Shape();
} else if (std::string(Type.getValueAsString()) == "Length") {
gp_Vec vec(SketchVector.x,SketchVector.y,SketchVector.z);
vec.Transform(invObjLoc.Transformation());
BRepPrimAPI_MakePrism PrismMaker(aFace.Moved(invObjLoc),vec,0,1); // finite prism
if (!PrismMaker.IsDone())
return new App::DocumentObjectExecReturn("Could not extrude the sketch!");
prism = PrismMaker.Shape();
// And the really expensive way to get the SubShape...
BRepAlgoAPI_Cut mkCut(support, prism);
if (!mkCut.IsDone())
return new App::DocumentObjectExecReturn("Pocket: Up to face: Could not get SubShape!");
// FIXME: In some cases this affects the Shape property: It is set to the same shape as the SubShape!!!!
this->SubShape.setValue(mkCut.Shape());
this->Shape.setValue(prism);
} else {
return new App::DocumentObjectExecReturn("Internal error: Unknown type for Pocket feature");
TopoDS_Shape prism;
generatePrism(prism, sketchshape, method, dir, L, 0.0,
Midplane.getValue(), Reversed.getValue());
if (prism.IsNull())
return new App::DocumentObjectExecReturn("Pocket: Resulting shape is empty");
// set the subtractive shape property for later usage in e.g. pattern
this->SubShape.setValue(prism);
// Cut the SubShape out of the support
BRepAlgoAPI_Cut mkCut(support, prism);
if (!mkCut.IsDone())
return new App::DocumentObjectExecReturn("Pocket: Cut out of support failed");
TopoDS_Shape result = mkCut.Shape();
// we have to get the solids (fuse sometimes creates compounds)
TopoDS_Shape solRes = this->getSolid(result);
if (solRes.IsNull())
return new App::DocumentObjectExecReturn("Pocket: Resulting shape is not a solid");
this->Shape.setValue(solRes);
}
this->SubShape.setValue(prism);
// Cut out the pocket
BRepAlgoAPI_Cut mkCut(support.Moved(invObjLoc), prism);
// Let's check if the fusion has been successful
if (!mkCut.IsDone())
return new App::DocumentObjectExecReturn("Cut with support failed");
// we have to get the solids (fuse sometimes creates compounds)
TopoDS_Shape solRes = this->getSolid(mkCut.Shape());
if (solRes.IsNull())
return new App::DocumentObjectExecReturn("Resulting shape is not a solid");
this->Shape.setValue(solRes);
return App::DocumentObject::StdReturn;
} catch (Standard_Failure) {
}
catch (Standard_Failure) {
Handle_Standard_Failure e = Standard_Failure::Caught();
if (std::string(e->GetMessageString()) == "TopoDS::Face")
if (std::string(e->GetMessageString()) == "TopoDS::Face" &&
(Type.getValueAsString() == "UpToFirst" || Type.getValueAsString() == "UpToFace"))
return new App::DocumentObjectExecReturn("Could not create face from sketch.\n"
"Intersecting sketch entities or multiple faces in a sketch are not allowed.");
"Intersecting sketch entities or multiple faces in a sketch are not allowed "
"for making a pocket up to a face.");
else
return new App::DocumentObjectExecReturn(e->GetMessageString());
}

2
src/Mod/PartDesign/App/FeaturePocket.h
View File

@@ -39,7 +39,7 @@ public:
App::PropertyEnumeration Type;
App::PropertyLength Length;
App::PropertyString FaceName;
App::PropertyLinkSub UpToFace;
/** @name methods override feature */
//@{

189
src/Mod/PartDesign/App/FeatureSketchBased.cpp
View File

@@ -31,6 +31,9 @@
# include <BRepAdaptor_Surface.hxx>
# include <BRepCheck_Analyzer.hxx>
# include <BRep_Tool.hxx>
# include <BRepExtrema_DistShapeShape.hxx>
# include <BRepPrimAPI_MakePrism.hxx>
# include <BRepProj_Projection.hxx>
# include <Geom_Plane.hxx>
# include <TopoDS.hxx>
# include <TopoDS_Compound.hxx>
@@ -136,13 +139,50 @@ std::vector<TopoDS_Wire> SketchBased::getSketchWires() const {
return result;
}
const TopoDS_Shape& SketchBased::getSupportShape() const {
// TODO: This code is taken from and duplicates code in Part2DObject::positionBySupport()
// Note: We cannot return a reference, because it will become Null.
// Not clear where, because we check for IsNull() here, but as soon as it is passed out of
// this method, it becomes null!
const TopoDS_Face SketchBased::getSupportFace() const {
const App::PropertyLinkSub& Support = static_cast<Part::Part2DObject*>(Sketch.getValue())->Support;
Part::Feature *part = static_cast<Part::Feature*>(Support.getValue());
if (!part || !part->getTypeId().isDerivedFrom(Part::Feature::getClassTypeId()))
throw Base::Exception("Sketch has no support shape");
const std::vector<std::string> &sub = Support.getSubValues();
assert(sub.size()==1);
// get the selected sub shape (a Face)
const Part::TopoShape &shape = part->Shape.getShape();
if (shape._Shape.IsNull())
throw Base::Exception("Sketch support shape is empty!");
TopoDS_Shape sh = shape.getSubShape(sub[0].c_str());
if (sh.IsNull())
throw Base::Exception("Null shape in SketchBased::getSupportFace()!");
const TopoDS_Face face = TopoDS::Face(sh);
if (face.IsNull())
throw Base::Exception("Null face in SketchBased::getSupportFace()!");
BRepAdaptor_Surface adapt(face);
if (adapt.GetType() != GeomAbs_Plane)
throw Base::Exception("No planar face in SketchBased::getSupportFace()!");
return face;
}
Part::Feature* SketchBased::getSupport() const {
// get the support of the Sketch if any
App::DocumentObject* SupportLink = static_cast<Part::Part2DObject*>(Sketch.getValue())->Support.getValue();
Part::Feature* SupportObject = NULL;
if (SupportLink && SupportLink->getTypeId().isDerivedFrom(Part::Feature::getClassTypeId()))
SupportObject = static_cast<Part::Feature*>(SupportLink);
return SupportObject;
}
const TopoDS_Shape& SketchBased::getSupportShape() const {
Part::Feature* SupportObject = getSupport();
if (SupportObject == NULL)
throw Base::Exception("No support in Sketch!");
@@ -156,6 +196,12 @@ const TopoDS_Shape& SketchBased::getSupportShape() const {
return result;
}
int SketchBased::getSketchAxisCount(void) const
{
Part::Part2DObject *sketch = static_cast<Part::Part2DObject*>(Sketch.getValue());
return sketch->getAxisCount();
}
void SketchBased::onChanged(const App::Property* prop)
{
if (prop == &Sketch) {
@@ -332,10 +378,145 @@ TopoDS_Shape SketchBased::makeFace(const std::vector<TopoDS_Wire>& w) const
}
}
int SketchBased::getSketchAxisCount(void) const
void SketchBased::getUpToFaceFromLinkSub(TopoDS_Face& upToFace,
const App::PropertyLinkSub& refFace)
{
Part::Part2DObject *sketch = static_cast<Part::Part2DObject*>(Sketch.getValue());
return sketch->getAxisCount();
App::DocumentObject* ref = refFace.getValue();
std::vector<std::string> subStrings = refFace.getSubValues();
if (ref == NULL)
throw Base::Exception("SketchBased: Up to face: No face selected");
if (!ref->getTypeId().isDerivedFrom(Part::Feature::getClassTypeId()))
throw Base::Exception("SketchBased: Up to face: Must be face of a feature");
Part::TopoShape baseShape = static_cast<Part::Feature*>(ref)->Shape.getShape();
if (subStrings.empty() || subStrings[0].empty())
throw Base::Exception("SketchBased: Up to face: No face selected");
// TODO: Check for multiple UpToFaces?
upToFace = TopoDS::Face(baseShape.getSubShape(subStrings[0].c_str()));
if (upToFace.IsNull())
throw Base::Exception("SketchBased: Up to face: Failed to extract face");
}
void SketchBased::getUpToFace(TopoDS_Face& upToFace,
const TopoDS_Shape& support,
const TopoDS_Face& supportface,
const TopoDS_Shape& sketchshape,
const std::string& method,
const gp_Dir& dir)
{
if ((method == "UpToLast") || (method == "UpToFirst")) {
// Check for valid support object
if (support.IsNull())
throw Base::Exception("SketchBased: Up to face: No support in Sketch!");
std::vector<Part::cutFaces> cfaces = Part::findAllFacesCutBy(support, sketchshape, dir);
if (cfaces.empty())
throw Base::Exception("SketchBased: Up to face: No faces found in this direction");
// Find nearest/furthest face
std::vector<Part::cutFaces>::const_iterator it, it_near, it_far;
it_near = it_far = cfaces.begin();
for (it = cfaces.begin(); it != cfaces.end(); it++)
if (it->distsq > it_far->distsq)
it_far = it;
else if (it->distsq < it_near->distsq)
it_near = it;
upToFace = (method == "UpToLast" ? it_far->face : it_near->face);
}
// Remove the limits of the upToFace so that the extrusion works even if sketchshape is larger
// than the upToFace
bool remove_limits = false;
TopExp_Explorer Ex;
for (Ex.Init(sketchshape,TopAbs_FACE); Ex.More(); Ex.Next()) {
// Get outermost wire of sketch face
TopoDS_Face sketchface = TopoDS::Face(Ex.Current());
TopoDS_Wire outerWire = ShapeAnalysis::OuterWire(sketchface);
if (!checkWireInsideFace(outerWire, upToFace, dir)) {
remove_limits = true;
break;
}
}
if (remove_limits) {
// Note: Using an unlimited face every time gives unnecessary failures for concave faces
BRepAdaptor_Surface adapt(upToFace, Standard_False);
BRepBuilderAPI_MakeFace mkFace(adapt.Surface().Surface());
if (!mkFace.IsDone())
throw Base::Exception("SketchBased: Up To Face: Failed to create unlimited face");
upToFace = TopoDS::Face(mkFace.Shape());
}
// Check that the upToFace does not intersect the sketch face and
// is not parallel to the extrusion direction
BRepAdaptor_Surface adapt1(TopoDS::Face(supportface));
BRepAdaptor_Surface adapt2(TopoDS::Face(upToFace));
if (adapt2.GetType() == GeomAbs_Plane) {
if (adapt1.Plane().Axis().IsNormal(adapt2.Plane().Axis(), Precision::Confusion()))
throw Base::Exception("SketchBased: Up to face: Must not be parallel to extrusion direction!");
}
BRepExtrema_DistShapeShape distSS(supportface, upToFace);
if (distSS.Value() < Precision::Confusion())
throw Base::Exception("SketchBased: Up to face: Must not intersect sketch!");
}
void SketchBased::generatePrism(TopoDS_Shape& prism,
const TopoDS_Shape& sketchshape,
const std::string& method,
const gp_Dir& dir,
const double L,
const double L2,
const bool midplane,
const bool reversed)
{
if (method == "Length" || method == "TwoLengths" || method == "ThroughAll") {
double Ltotal = L;
double Loffset = 0.;
if (method == "ThroughAll")
// "ThroughAll" is modelled as a very long, but finite prism to avoid problems with pockets
// Note: 1E6 created problems once...
Ltotal = 1E4;
if (midplane)
Loffset = -Ltotal/2;
else if (method == "TwoLengths") {
Loffset = -L2;
Ltotal += L2;
}
TopoDS_Shape from = sketchshape;
if (method == "TwoLengths" || midplane) {
gp_Trsf mov;
mov.SetTranslation(Loffset * gp_Vec(dir));
TopLoc_Location loc(mov);
from = sketchshape.Moved(loc);
} else if (reversed)
Ltotal *= -1.0;
// Its better not to use BRepFeat_MakePrism here even if we have a support because the
// resulting shape creates problems with Pocket
BRepPrimAPI_MakePrism PrismMaker(from, Ltotal*gp_Vec(dir), 0,1); // finite prism
if (!PrismMaker.IsDone())
throw Base::Exception("SketchBased: Length: Could not extrude the sketch!");
prism = PrismMaker.Shape();
} else {
throw Base::Exception("SketchBased: Internal error: Unknown method for generatePrism()");
}
}
const bool SketchBased::checkWireInsideFace(const TopoDS_Wire& wire, const TopoDS_Face& face,
const gp_Dir& dir) {
// Project wire onto the face (face, not surface! So limits of face apply)
// FIXME: For a user-selected upToFace, sometimes this returns a non-closed wire for no apparent reason
// Check again after introduction of "robust" reference for upToFace
BRepProj_Projection proj(wire, face, dir);
return (proj.More() && proj.Current().Closed());
}
}

35
src/Mod/PartDesign/App/FeatureSketchBased.h
View File

@@ -30,6 +30,7 @@
class TopoDS_Face;
class TopoDS_Wire;
class gp_Dir;
namespace PartDesign
{
@@ -59,8 +60,13 @@ public:
Part::Part2DObject* getVerifiedSketch() const;
/// Returns the wires the sketch is composed of
std::vector<TopoDS_Wire> getSketchWires() const;
/// Returns the face of the sketch support (if any)
const TopoDS_Face getSupportFace() const;
/// Returns the sketch support feature or NULL
Part::Feature* getSupport() const;
/// Returns the sketch support shape (if any)
const TopoDS_Shape& getSupportShape() const;
/// retrieves the number of axes in the linked sketch (defined as construction lines)
int getSketchAxisCount(void) const;
@@ -70,6 +76,35 @@ protected:
TopoDS_Shape makeFace(const std::vector<TopoDS_Wire>&) const;
TopoDS_Shape makeFace(std::list<TopoDS_Wire>&) const; // for internal use only
bool isInside(const TopoDS_Wire&, const TopoDS_Wire&) const;
/// Extract a face from a given LinkSub
static void getUpToFaceFromLinkSub(TopoDS_Face& upToFace,
const App::PropertyLinkSub& refFace);
/// Find a valid face to extrude up to
static void getUpToFace(TopoDS_Face& upToFace,
const TopoDS_Shape& support,
const TopoDS_Face& supportface,
const TopoDS_Shape& sketchshape,
const std::string& method,
const gp_Dir& dir);
/**
* Generate a linear prism
* It will be a stand-alone solid created with BRepPrimAPI_MakePrism
*/
static void generatePrism(TopoDS_Shape& prism,
const TopoDS_Shape& sketchshape,
const std::string& method,
const gp_Dir& direction,
const double L,
const double L2,
const bool midplane,
const bool reversed);
/// Check whether the wire after projection on the face is inside the face
static const bool checkWireInsideFace(const TopoDS_Wire& wire,
const TopoDS_Face& face,
const gp_Dir& dir);
};
} //namespace PartDesign