1578 lines
59 KiB
C++
1578 lines
59 KiB
C++
/***************************************************************************
|
||
* Copyright (c) 2022 WandererFan <wandererfan@gmail.com> *
|
||
* *
|
||
* This file is part of the FreeCAD CAx development system. *
|
||
* *
|
||
* This library is free software; you can redistribute it and/or *
|
||
* modify it under the terms of the GNU Library General Public *
|
||
* License as published by the Free Software Foundation; either *
|
||
* version 2 of the License, or (at your option) any later version. *
|
||
* *
|
||
* This library is distributed in the hope that it will be useful, *
|
||
* but WITHOUT ANY WARRANTY; without even the implied warranty of *
|
||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
|
||
* GNU Library General Public License for more details. *
|
||
* *
|
||
* You should have received a copy of the GNU Library General Public *
|
||
* License along with this library; see the file COPYING.LIB. If not, *
|
||
* write to the Free Software Foundation, Inc., 59 Temple Place, *
|
||
* Suite 330, Boston, MA 02111-1307, USA *
|
||
* *
|
||
***************************************************************************/
|
||
//DrawComplexSection processing overview
|
||
//for Strategy = Offset, DCS is much the same as DVS
|
||
//for Strategy = Aligned, there are many differences
|
||
|
||
//execute
|
||
// sectionExec(getShapeToCut()*)
|
||
|
||
//sectionExec
|
||
// makeSectionCut(baseShape)
|
||
|
||
//makeSectionCut (separate thread)
|
||
// note that the section cut is not required for Aligned strategy,
|
||
// but it is useful for debugging
|
||
// m_cuttingTool = makeCuttingTool* (DVSTool.brep)
|
||
// m_cutPieces = (baseShape - m_cuttingTool) (DVSCutPieces.brep)
|
||
|
||
//onSectionCutFinished
|
||
// m_preparedShape = prepareShape(m_cutPieces)* - centered, scaled, rotated
|
||
// geometryObject = DVP::buildGeometryObject(m_preparedShape) (HLR)
|
||
|
||
//postHlrTasks
|
||
// faceIntersections = findSectionPlaneIntersections
|
||
// m_sectionTopoDSFaces = alignSectionFaces(faceIntersections)
|
||
// m_tdSectionFaces = makeTDSectionFaces(m_sectionTopoDSFaces)
|
||
|
||
//* for Aligned, we use a different ShapeToCut, as the standard one will
|
||
// cause many coincident face problems later
|
||
//* the cutting tool is built up from the profile, instead of the simple plane in DVS
|
||
//* for Aligned, preparing the shape is much different than Offset or DVS
|
||
// - most of the work is done in makeAlignedPieces
|
||
// - for each segment of the profile, make a cutting tool, then get the boolean
|
||
// intersection of the tool and the shape to cut
|
||
// - align and distribute the intersections along an "effective" section plane
|
||
// which is a flattened version of the profile
|
||
|
||
#include "PreCompiled.h"
|
||
|
||
#ifndef _PreComp_
|
||
#include <BRepAdaptor_Curve.hxx>
|
||
#include <BRepAdaptor_Surface.hxx>
|
||
#include <Mod/Part/App/FCBRepAlgoAPI_Common.h>
|
||
#include <Mod/Part/App/FCBRepAlgoAPI_Cut.h>
|
||
#include <BRepAlgo_NormalProjection.hxx>
|
||
#include <BRepBndLib.hxx>
|
||
#include <BRepBuilderAPI_Copy.hxx>
|
||
#include <BRepBuilderAPI_MakeEdge.hxx>
|
||
#include <BRepBuilderAPI_MakeFace.hxx>
|
||
#include <BRepBuilderAPI_MakeWire.hxx>
|
||
#include <BRepBuilderAPI_Transform.hxx>
|
||
#include <BRepGProp.hxx>
|
||
#include <BRepLProp_SLProps.hxx>
|
||
#include <BRepLib.hxx>
|
||
#include <BRepPrimAPI_MakeBox.hxx>
|
||
#include <BRepPrimAPI_MakeHalfSpace.hxx>
|
||
#include <BRepPrimAPI_MakePrism.hxx>
|
||
#include <BRepTools.hxx>
|
||
#include <BRep_Builder.hxx>
|
||
#include <Bnd_Box.hxx>
|
||
#include <Bnd_OBB.hxx>
|
||
#include <GC_MakeArcOfCircle.hxx>
|
||
#include <GProp_GProps.hxx>
|
||
#include <Geom_Plane.hxx>
|
||
#include <HLRAlgo_Projector.hxx>
|
||
#include <QFuture>
|
||
#include <QFutureWatcher>
|
||
#include <QtConcurrentRun>
|
||
#include <ShapeExtend_WireData.hxx>
|
||
#include <TopExp.hxx>
|
||
#include <TopExp_Explorer.hxx>
|
||
#include <TopoDS.hxx>
|
||
#include <TopoDS_Compound.hxx>
|
||
#include <TopoDS_Edge.hxx>
|
||
#include <TopoDS_Face.hxx>
|
||
#include <TopoDS_Shape.hxx>
|
||
#include <TopoDS_Vertex.hxx>
|
||
#include <gp_Ax2.hxx>
|
||
#include <gp_Ax3.hxx>
|
||
#include <gp_Dir.hxx>
|
||
#include <gp_Pln.hxx>
|
||
#include <gp_Pnt.hxx>
|
||
#endif
|
||
|
||
#include <cmath>
|
||
|
||
#include <sstream>
|
||
|
||
#include <App/Application.h>
|
||
#include <App/Document.h>
|
||
#include <App/Material.h>
|
||
#include <Base/BoundBox.h>
|
||
#include <Base/Console.h>
|
||
#include <Base/Converter.h>
|
||
#include <Base/Exception.h>
|
||
#include <Base/FileInfo.h>
|
||
#include <Base/Interpreter.h>
|
||
#include <Base/Parameter.h>
|
||
#include <Base/Tools.h>
|
||
|
||
#include <Mod/Part/App/PartFeature.h>
|
||
|
||
#include "DrawComplexSection.h"
|
||
#include "DrawUtil.h"
|
||
#include "GeometryObject.h"
|
||
#include "ShapeUtils.h"
|
||
|
||
using namespace TechDraw;
|
||
using namespace std;
|
||
using DU = DrawUtil;
|
||
|
||
//===========================================================================
|
||
// DrawComplexSection
|
||
//===========================================================================
|
||
|
||
//NOLINTBEGIN
|
||
PROPERTY_SOURCE(TechDraw::DrawComplexSection, TechDraw::DrawViewSection)
|
||
|
||
const char* DrawComplexSection::ProjectionStrategyEnums[] = {"Offset", "Aligned", "NoParallel",
|
||
nullptr};
|
||
//NOLINTEND
|
||
|
||
DrawComplexSection::DrawComplexSection() :
|
||
m_waitingForAlign(false)
|
||
{
|
||
static const char* fgroup = "Cutting Tool";
|
||
|
||
//NOLINTBEGIN
|
||
ADD_PROPERTY_TYPE(CuttingToolWireObject, (nullptr), fgroup, App::Prop_None,
|
||
"A sketch that describes the cutting tool");
|
||
CuttingToolWireObject.setScope(App::LinkScope::Global);
|
||
ProjectionStrategy.setEnums(ProjectionStrategyEnums);
|
||
ADD_PROPERTY_TYPE(ProjectionStrategy, ((long)0), fgroup, App::Prop_None,
|
||
"Make a single cut, or use the profile in pieces");
|
||
//NOLINTEND
|
||
}
|
||
|
||
TopoDS_Shape DrawComplexSection::makeCuttingTool(double dMax)
|
||
{
|
||
TopoDS_Wire profileWire = makeProfileWire();
|
||
if (profileWire.IsNull()) {
|
||
throw Base::RuntimeError("Can not make wire from cutting tool (1)");
|
||
}
|
||
|
||
if (debugSection()) {
|
||
//the nose to tail version of the profile
|
||
BRepTools::Write(profileWire, "DCSProfileWire.brep");//debug
|
||
}
|
||
|
||
gp_Ax2 sectionCS = getSectionCS(); // should validate this some where
|
||
|
||
auto uSectionNormal = SectionNormal.getValue();
|
||
uSectionNormal.Normalize();
|
||
auto gWireToFaceDirection = Base::convertTo<gp_Vec>(getReferenceAxis());
|
||
bool isPositionOK = validateProfilePosition(profileWire, sectionCS);
|
||
if (!isPositionOK) {
|
||
//profile is not in a good position. Result might not be right.
|
||
Base::Console().Warning("DCS::makeCuttingTool - %s - profile is outside shape box\n",
|
||
getNameInDocument());
|
||
}
|
||
|
||
//move the profile wire to one side of the shape
|
||
gp_Trsf mov;
|
||
mov.SetTranslation(gp_Vec(gWireToFaceDirection) * (-dMax));
|
||
TopLoc_Location loc(mov);
|
||
profileWire.Move(loc);
|
||
|
||
if (BRep_Tool::IsClosed(profileWire)) {
|
||
// TopoDS_Shape makePrismForClosedProfile(profileWire)
|
||
// Wire is closed, so make a face from it and extrude "vertically"
|
||
BRepBuilderAPI_MakeFace mkFace(profileWire);
|
||
TopoDS_Face toolFace = mkFace.Face();
|
||
if (toolFace.IsNull()) {
|
||
return {};
|
||
}
|
||
gp_Dir gpNormal = getFaceNormal(toolFace);
|
||
auto extrudeDir = 2 * dMax * gpNormal;
|
||
return BRepPrimAPI_MakePrism(toolFace, extrudeDir).Shape();
|
||
}
|
||
|
||
if (ProjectionStrategy.getValue() == 0) {
|
||
// Offset. Warn if profile is not quite aligned with section normal. if
|
||
// the profile and normal are misaligned, the check below for empty "solids"
|
||
// will not be correct.
|
||
constexpr double AngleThresholdDeg{5.0};
|
||
// bool isOK =
|
||
validateOffsetProfile(profileWire, SectionNormal.getValue(), AngleThresholdDeg);
|
||
}
|
||
|
||
m_toolFaceShape = extrudeWireToFace(profileWire, gWireToFaceDirection, 2 * dMax);
|
||
if (debugSection()) {
|
||
BRepTools::Write(m_toolFaceShape, "DCSToolFaceShape.brep");//debug
|
||
}
|
||
|
||
// should this use the circular arc closing method as in closeProfile()??
|
||
auto points = getPointsForClosingProfile(profileWire, dMax);
|
||
|
||
BRepBuilderAPI_MakeWire mkWire(profileWire);
|
||
|
||
for(size_t iFrom = 0; iFrom < points.size() - 1 ; iFrom++) {
|
||
size_t jTo = iFrom + 1;
|
||
BRepBuilderAPI_MakeEdge mkEdge(Base::convertTo<gp_Pnt>(points.at(iFrom)),
|
||
Base::convertTo<gp_Pnt>(points.at(jTo)));
|
||
mkWire.Add(mkEdge.Edge());
|
||
}
|
||
|
||
BRepBuilderAPI_MakeFace mkFace(mkWire.Wire());
|
||
if (debugSection()) {
|
||
BRepTools::Write(mkFace.Face(), "DCSToolPlan.brep"); //debug
|
||
}
|
||
auto padVector = gWireToFaceDirection * dMax * 2;
|
||
TopoDS_Shape roughTool = BRepPrimAPI_MakePrism(mkFace.Face(), padVector).Shape();
|
||
|
||
if (roughTool.ShapeType() == TopAbs_COMPSOLID ||
|
||
roughTool.ShapeType() == TopAbs_COMPOUND) {
|
||
//Composite Solids do not cut well if they contain "solids" with no volume. This
|
||
//happens if the profile has segments parallel to the extrude direction.
|
||
//We need to disassemble it and only keep the real solids.
|
||
return removeEmptyShapes(roughTool);
|
||
}
|
||
|
||
return roughTool;
|
||
}
|
||
|
||
TopoDS_Shape DrawComplexSection::getShapeToPrepare() const
|
||
{
|
||
if (ProjectionStrategy.getValue() == 0) {
|
||
//Offset. Use regular section behaviour
|
||
return DrawViewSection::getShapeToPrepare();
|
||
}
|
||
//Aligned strategy
|
||
return m_saveShape;//the original input shape
|
||
}
|
||
|
||
//get the shape ready for projection and cut surface finding
|
||
TopoDS_Shape DrawComplexSection::prepareShape(const TopoDS_Shape& cutShape, double shapeSize)
|
||
{
|
||
if (ProjectionStrategy.getValue() == 0) {
|
||
//Offset. Use regular section behaviour
|
||
return DrawViewSection::prepareShape(cutShape, shapeSize);
|
||
}
|
||
|
||
//"Aligned" projection (Aligned Section)
|
||
if (m_alignResult.IsNull()) {
|
||
return {};
|
||
}
|
||
|
||
// our shape is already centered "left/right" and "up/down" so we don't need to
|
||
// center it here
|
||
// TopoDS_Shape centeredShape = ShapeUtils::centerShapeXY(m_alignResult, getProjectionCS());
|
||
m_preparedShape = ShapeUtils::scaleShape(m_alignResult, getScale());
|
||
if (!DrawUtil::fpCompare(Rotation.getValue(), 0.0)) {
|
||
m_preparedShape =
|
||
ShapeUtils::rotateShape(m_preparedShape, getProjectionCS(), Rotation.getValue());
|
||
}
|
||
|
||
if (debugSection()) {
|
||
BRepTools::Write(m_preparedShape, "DCS60preparedShape.brep"); //debug
|
||
}
|
||
|
||
return m_preparedShape;
|
||
}
|
||
|
||
|
||
void DrawComplexSection::makeSectionCut(const TopoDS_Shape& baseShape)
|
||
{
|
||
if (ProjectionStrategy.getValue() == 0) {
|
||
//Offset. Use regular section behaviour
|
||
return DrawViewSection::makeSectionCut(baseShape);
|
||
}
|
||
|
||
try {
|
||
connectAlignWatcher =
|
||
QObject::connect(&m_alignWatcher, &QFutureWatcherBase::finished, &m_alignWatcher,
|
||
[this] { this->onSectionCutFinished(); });
|
||
|
||
// We create a lambda closure to hold a copy of baseShape.
|
||
// This is important because this variable might be local to the calling
|
||
// function and might get destructed before the parallel processing finishes.
|
||
auto lambda = [this, baseShape]{this->makeAlignedPieces(baseShape);};
|
||
m_alignFuture = QtConcurrent::run(std::move(lambda));
|
||
m_alignWatcher.setFuture(m_alignFuture);
|
||
waitingForAlign(true);
|
||
}
|
||
catch (...) {
|
||
Base::Console().Message("DCS::makeSectionCut - failed to make alignedPieces");
|
||
return;
|
||
}
|
||
|
||
return DrawViewSection::makeSectionCut(baseShape);
|
||
}
|
||
|
||
|
||
void DrawComplexSection::onSectionCutFinished()
|
||
{
|
||
if (m_cutFuture.isRunning() || //waitingForCut()
|
||
m_alignFuture.isRunning()) {//waitingForAlign()
|
||
//can not continue yet. return until the other thread ends
|
||
return;
|
||
}
|
||
|
||
DrawViewSection::onSectionCutFinished();
|
||
|
||
QObject::disconnect(connectAlignWatcher);
|
||
}
|
||
|
||
//for Aligned strategy, cut the rawShape by each segment of the tool
|
||
void DrawComplexSection::makeAlignedPieces(const TopoDS_Shape& rawShape)
|
||
{
|
||
|
||
if (!canBuild(getSectionCS(), CuttingToolWireObject.getValue())) {
|
||
throw Base::RuntimeError("Profile is parallel to Section Normal");
|
||
}
|
||
|
||
if (debugSection()) {
|
||
BRepTools::Write(rawShape, "DCSRawShape.brep");//debug
|
||
}
|
||
|
||
auto uSectionNormal = SectionNormal.getValue();
|
||
uSectionNormal.Normalize();
|
||
|
||
TopoDS_Wire profileWire = makeProfileWire();
|
||
if (profileWire.IsNull()) {
|
||
throw Base::RuntimeError("ComplexSection failed to make profileWire");
|
||
}
|
||
|
||
auto uRotateAxis = getReferenceAxis();
|
||
uRotateAxis.Normalize();
|
||
|
||
|
||
// the reversers control left to right vs right to left (or top to bottom vs botttom to top)
|
||
// arrangement of the cut pieces.
|
||
double horizReverser{1.0};
|
||
double verticalReverser{1.0};
|
||
gp_Vec gProfileVec = makeProfileVector(profileWire);
|
||
auto isProfileVertical = getReversers(gProfileVec, horizReverser, verticalReverser);
|
||
|
||
std::vector<TopoDS_Shape> pieces; // results of cutting source with each segment's tool shape
|
||
std::vector<double> pieceXSizeAll; //size in sectionCS.XDirection (width)
|
||
std::vector<double> pieceYSizeAll; //size in sectionCS.YDirection (height)
|
||
std::vector<double> pieceZSizeAll; //size in sectionCS.Direction (depth)
|
||
std::vector<double> pieceVerticalAll; // displacement of piece in vertical direction
|
||
|
||
auto faceNormals = getSegmentViewDirections(profileWire, uSectionNormal, uRotateAxis);
|
||
TopExp_Explorer expFaces(m_toolFaceShape, TopAbs_FACE);
|
||
for (int iPiece = 0; expFaces.More(); expFaces.Next(), iPiece++) {
|
||
TopoDS_Face face = TopoDS::Face(expFaces.Current());
|
||
auto segmentNormal = Base::convertTo<gp_Vec>(faceNormals.at(iPiece).second);
|
||
if (!showSegment(segmentNormal)) {
|
||
//skip this segment of the profile
|
||
continue;
|
||
}
|
||
|
||
double pieceVertical{0};
|
||
auto rotatedPiece = cutAndRotatePiece(rawShape, face, iPiece, faceNormals.at(iPiece).second, uRotateAxis, pieceVertical);
|
||
|
||
auto sizeResponse = getAlignedSize(rotatedPiece, iPiece);
|
||
auto pieceSize = sizeResponse.pieceSize;
|
||
pieceXSizeAll.push_back(pieceSize.x); // size in ProjectionCS.
|
||
pieceYSizeAll.push_back(pieceSize.y);
|
||
pieceZSizeAll.push_back(pieceSize.z);
|
||
pieceVerticalAll.push_back(pieceVertical);
|
||
|
||
if (debugSection()) {
|
||
stringstream ss;
|
||
ss << "DCSAlignedPiece" << iPiece << ".brep";
|
||
BRepTools::Write(sizeResponse.alignedPiece, ss.str().c_str());//debug
|
||
}
|
||
|
||
auto pieceOnPlane = movePieceToPaperPlane(sizeResponse.alignedPiece, sizeResponse.zMax);
|
||
if (debugSection()) {
|
||
stringstream ss;
|
||
ss << "DCSEpieceOnPlane" << iPiece << ".brep";
|
||
BRepTools::Write(pieceOnPlane, ss.str().c_str());//debug
|
||
}
|
||
// pieceOnPlane is on the paper plane, with piece centroid at the origin
|
||
pieces.push_back(pieceOnPlane);
|
||
}
|
||
|
||
if (pieces.empty()) {
|
||
m_alignResult = TopoDS_Compound();
|
||
return;
|
||
}
|
||
|
||
//space the pieces "horizontally" or "vertically" in OXYZ
|
||
double movementReverser = isProfileVertical ? verticalReverser : horizReverser;
|
||
auto movementAxis = gp_Vec(gp::OX().Direction());
|
||
auto alignmentAxis = gp_Vec(gp::OY().Direction().Reversed());
|
||
if (isProfileVertical) {
|
||
movementAxis = gp_Vec(gp::OY().Direction());
|
||
alignmentAxis = gp_Vec(gp::OX().Direction());
|
||
}
|
||
gp_Vec gMovementVector = movementAxis * movementReverser;
|
||
|
||
size_t stopAt = pieces.size();
|
||
double cursorPosition = 0.0;
|
||
for (size_t iPiece = 0; iPiece < stopAt; iPiece++) {
|
||
double pieceSizeMoveDist = pieceXSizeAll.at(iPiece);
|
||
if (isProfileVertical) {
|
||
pieceSizeMoveDist = pieceYSizeAll.at(iPiece);
|
||
}
|
||
auto movedPiece = distributePiece(pieces.at(iPiece), pieceSizeMoveDist, pieceVerticalAll.at(iPiece),
|
||
alignmentAxis, gMovementVector, cursorPosition);
|
||
pieces.at(iPiece) = movedPiece;
|
||
cursorPosition += pieceSizeMoveDist;
|
||
|
||
if (debugSection()) {
|
||
stringstream ss;
|
||
ss << "DCSMovedPiece" << iPiece << ".brep";
|
||
BRepTools::Write(pieces.at(iPiece), ss.str().c_str());//debug
|
||
}
|
||
}
|
||
|
||
//make a compound of the aligned pieces
|
||
BRep_Builder builder;
|
||
TopoDS_Compound comp;
|
||
builder.MakeCompound(comp);
|
||
for (auto& piece : pieces) {
|
||
builder.Add(comp, piece);
|
||
}
|
||
|
||
//center the compound along SectionCS XDirection
|
||
Base::Vector3d centerVector = Base::convertTo<Base::Vector3d>(gMovementVector) * cursorPosition / -2;
|
||
TopoDS_Shape centeredCompound = ShapeUtils::moveShape(comp, centerVector);
|
||
|
||
if (debugSection()) {
|
||
BRepTools::Write(centeredCompound, "DCSmap40CenteredCompound.brep");//debug
|
||
}
|
||
|
||
// re-align our shape with the projection CS
|
||
gp_Ax3 stdCS; //OXYZ
|
||
gp_Trsf xPieceAlign;
|
||
xPieceAlign.SetTransformation(getProjectionCS(), stdCS);
|
||
BRepBuilderAPI_Transform mkTransAlign(centeredCompound, xPieceAlign);
|
||
TopoDS_Shape alignedCompound = mkTransAlign.Shape();
|
||
|
||
if (debugSection()) {
|
||
BRepTools::Write(alignedCompound, "DCSmap50AlignedCompound.brep");//debug
|
||
}
|
||
|
||
m_alignResult = alignedCompound;
|
||
}
|
||
|
||
//! tries to find the intersection faces of the cut shape and the cutting tool.
|
||
//! Aligned complex sections need to intersect the final cut shape (which in this
|
||
//! case is a compound of individual cuts) with the "effective" (flattened) section plane.
|
||
//! Profiles containing curves need special handling.
|
||
TopoDS_Compound
|
||
DrawComplexSection::findSectionPlaneIntersections(const TopoDS_Shape& shapeToIntersect)
|
||
{
|
||
if (shapeToIntersect.IsNull()) {
|
||
// this shouldn't happen
|
||
Base::Console().Warning("DCS::findSectionPlaneInter - %s - cut shape is Null\n",
|
||
getNameInDocument());
|
||
return {};
|
||
}
|
||
if (ProjectionStrategy.getValue() == 0) {//Offset
|
||
return singleToolIntersections(shapeToIntersect);
|
||
}
|
||
|
||
return alignedToolIntersections(shapeToIntersect);
|
||
}
|
||
|
||
//Intersect cutShape with each segment of the cutting tool
|
||
TopoDS_Compound DrawComplexSection::singleToolIntersections(const TopoDS_Shape& cutShape)
|
||
{
|
||
App::DocumentObject* toolObj = CuttingToolWireObject.getValue();
|
||
if (!isLinearProfile(toolObj)) {
|
||
//TODO: special handling here
|
||
// Base::Console().Message("DCS::singleToolIntersection - profile has curves\n");
|
||
}
|
||
|
||
BRep_Builder builder;
|
||
TopoDS_Compound result;
|
||
builder.MakeCompound(result);
|
||
|
||
if (debugSection()) {
|
||
BRepTools::Write(cutShape, "DCSOffsetCutShape.brep"); //debug
|
||
BRepTools::Write(m_toolFaceShape, "DCSOffsetCuttingToolFace.brep");//debug
|
||
}
|
||
|
||
if (m_toolFaceShape.IsNull()) {
|
||
return result;
|
||
}
|
||
|
||
TopExp_Explorer expFaces(cutShape, TopAbs_FACE);
|
||
for (; expFaces.More(); expFaces.Next()) {
|
||
TopoDS_Face face = TopoDS::Face(expFaces.Current());
|
||
if (!boxesIntersect(face, m_toolFaceShape)) {
|
||
continue;
|
||
}
|
||
std::vector<TopoDS_Face> commonFaces = faceShapeIntersect(face, m_toolFaceShape);
|
||
for (auto& cFace : commonFaces) {
|
||
builder.Add(result, cFace);
|
||
}
|
||
}
|
||
return result;
|
||
}
|
||
|
||
//Intersect cutShape with the effective (flattened paper plane) cutting plane to generate cut surface faces
|
||
TopoDS_Compound DrawComplexSection::alignedToolIntersections(const TopoDS_Shape& cutShape)
|
||
{
|
||
BRep_Builder builder;
|
||
TopoDS_Compound result;
|
||
builder.MakeCompound(result);
|
||
|
||
App::DocumentObject* toolObj = CuttingToolWireObject.getValue();
|
||
if (!isLinearProfile(toolObj)) {
|
||
//TODO: special handling here?
|
||
// Base::Console().Message("DCS::alignedToolIntersection - profile has curves\n");
|
||
}
|
||
|
||
gp_Pln effectivePlane = getSectionPlane();
|
||
//aligned result can be much wider than the shape itself, so we use an
|
||
//infinite face.
|
||
BRepBuilderAPI_MakeFace mkFace(effectivePlane, -Precision::Infinite(), Precision::Infinite(),
|
||
-Precision::Infinite(), Precision::Infinite());
|
||
TopoDS_Face cuttingFace = mkFace.Face();
|
||
|
||
TopExp_Explorer expFaces(cutShape, TopAbs_FACE);
|
||
for (; expFaces.More(); expFaces.Next()) {
|
||
TopoDS_Face face = TopoDS::Face(expFaces.Current());
|
||
if (!boxesIntersect(face, cuttingFace)) {
|
||
continue;
|
||
}
|
||
std::vector<TopoDS_Face> commonFaces = faceShapeIntersect(face, cuttingFace);
|
||
for (auto& cFace : commonFaces) {
|
||
builder.Add(result, cFace);
|
||
}
|
||
}
|
||
if (debugSection()) {
|
||
BRepTools::Write(cuttingFace, "DCSAlignedCuttingFace.brep"); //debug
|
||
BRepTools::Write(cutShape, "DCSAlignedCutShape.brep"); //debug
|
||
BRepTools::Write(result, "DCSAlignedIntersectionResult.brep");//debug
|
||
}
|
||
return result;
|
||
}
|
||
|
||
TopoDS_Compound DrawComplexSection::alignSectionFaces(const TopoDS_Shape& faceIntersections)
|
||
{
|
||
if (ProjectionStrategy.getValue() == 0) {
|
||
//Offset. Use regular section behaviour
|
||
return DrawViewSection::alignSectionFaces(faceIntersections);
|
||
}
|
||
|
||
return TopoDS::Compound(mapToPage(faceIntersections));
|
||
}
|
||
|
||
TopoDS_Shape DrawComplexSection::getShapeToIntersect()
|
||
{
|
||
if (ProjectionStrategy.getValue() == 0) {//Offset
|
||
return DrawViewSection::getShapeToIntersect();
|
||
}
|
||
//Aligned
|
||
return m_preparedShape;
|
||
}
|
||
|
||
TopoDS_Shape DrawComplexSection::getShapeForDetail() const
|
||
{
|
||
if (ProjectionStrategy.getValue() == 0) {//Offset
|
||
return DrawViewSection::getShapeForDetail();
|
||
}
|
||
//Aligned
|
||
return m_preparedShape;
|
||
}
|
||
|
||
TopoDS_Wire DrawComplexSection::makeProfileWire() const
|
||
{
|
||
App::DocumentObject* toolObj = CuttingToolWireObject.getValue();
|
||
return makeProfileWire(toolObj);
|
||
}
|
||
|
||
TopoDS_Wire DrawComplexSection::makeProfileWire(App::DocumentObject* toolObj)
|
||
{
|
||
if (!isProfileObject(toolObj)) {
|
||
return {};
|
||
}
|
||
|
||
TopoDS_Shape toolShape = Part::Feature::getShape(toolObj);
|
||
if (toolShape.IsNull()) {
|
||
return {};
|
||
}
|
||
|
||
TopoDS_Wire profileWire;
|
||
if (toolShape.ShapeType() == TopAbs_WIRE) {
|
||
profileWire = makeNoseToTailWire(TopoDS::Wire(toolShape));
|
||
}
|
||
else {//we have already checked that the shape is a wire or an edge in isProfileObject
|
||
TopoDS_Edge edge = TopoDS::Edge(toolShape);
|
||
profileWire = BRepBuilderAPI_MakeWire(edge).Wire();
|
||
}
|
||
return profileWire;
|
||
}
|
||
|
||
gp_Vec DrawComplexSection::makeProfileVector(const TopoDS_Wire& profileWire)
|
||
{
|
||
auto ends = getWireEnds(profileWire);
|
||
auto vec = ends.second - ends.first;
|
||
vec.Normalize();
|
||
return Base::convertTo<gp_Vec>(vec);
|
||
}
|
||
|
||
//methods related to section line
|
||
|
||
//make drawable td geometry for section line
|
||
BaseGeomPtrVector DrawComplexSection::makeSectionLineGeometry()
|
||
{
|
||
BaseGeomPtrVector result;
|
||
auto* baseDvp = freecad_cast<DrawViewPart*>(BaseView.getValue());
|
||
if (baseDvp) {
|
||
TopoDS_Wire lineWire = makeSectionLineWire();
|
||
TopoDS_Shape projectedWire =
|
||
GeometryObject::projectSimpleShape(lineWire, baseDvp->getProjectionCS());
|
||
TopExp_Explorer expEdges(projectedWire, TopAbs_EDGE);
|
||
for (; expEdges.More(); expEdges.Next()) {
|
||
BaseGeomPtr edge = BaseGeom::baseFactory(TopoDS::Edge(expEdges.Current()));
|
||
result.push_back(edge);
|
||
}
|
||
}
|
||
return result;
|
||
}
|
||
|
||
//get the end points of the section wire
|
||
std::pair<Base::Vector3d, Base::Vector3d> DrawComplexSection::sectionLineEnds()
|
||
{
|
||
std::pair<Base::Vector3d, Base::Vector3d> result;
|
||
TopoDS_Wire lineWire = makeSectionLineWire();
|
||
if (lineWire.IsNull()) {
|
||
return result;
|
||
}
|
||
|
||
auto ends = getWireEnds(lineWire);
|
||
Base::Vector3d first = ends.first;
|
||
Base::Vector3d last = ends.second;
|
||
|
||
auto* baseDvp = freecad_cast<DrawViewPart*>(BaseView.getValue());
|
||
if (baseDvp) {
|
||
first = baseDvp->projectPoint(first);
|
||
last = baseDvp->projectPoint(last);
|
||
}
|
||
result.first = first;
|
||
result.second = last;
|
||
return result;
|
||
}
|
||
|
||
// get the directions of the section line arrows.
|
||
// the arrows on the section line are line of sight - from eye to preserved material. In a simple section,
|
||
// this is opposite to the section normal. In the complex section, we need a perpendicular direction most
|
||
// opposite to the SectionNormal.
|
||
std::pair<Base::Vector3d, Base::Vector3d> DrawComplexSection::sectionArrowDirs()
|
||
{
|
||
std::pair<Base::Vector3d, Base::Vector3d> result;
|
||
App::DocumentObject* toolObj = CuttingToolWireObject.getValue();
|
||
TopoDS_Wire profileWire = makeProfileWire(toolObj);
|
||
if (profileWire.IsNull()) {
|
||
return result;
|
||
}
|
||
|
||
auto lineOfSight = SectionNormal.getValue() * -1;
|
||
lineOfSight.Normalize();
|
||
|
||
auto referenceAxis = getReferenceAxis();
|
||
|
||
auto uSectionNormal = SectionNormal.getValue();
|
||
uSectionNormal.Normalize();
|
||
auto segmentViewDirections = getSegmentViewDirections(profileWire, uSectionNormal, referenceAxis);
|
||
if (segmentViewDirections.empty()) {
|
||
throw Base::RuntimeError("A complex section failed to create profile segment view directions");
|
||
}
|
||
Base::Vector3d firstArrowDir = segmentViewDirections.front().second;
|
||
Base::Vector3d lastArrowDir = segmentViewDirections.back().second;
|
||
|
||
return { firstArrowDir, lastArrowDir };
|
||
}
|
||
|
||
|
||
//! find an axis for measuring rotation vs the line of sight
|
||
Base::Vector3d DrawComplexSection::getReferenceAxis()
|
||
{
|
||
auto csDir = getBaseDVP()->getProjectionCS().Direction();
|
||
auto rawDirection = Base::convertTo<Base::Vector3d>(csDir);
|
||
rawDirection.Normalize();
|
||
return DU::closestBasisOriented(rawDirection);
|
||
}
|
||
|
||
|
||
//make a wire suitable for projection on a base view
|
||
TopoDS_Wire DrawComplexSection::makeSectionLineWire()
|
||
{
|
||
TopoDS_Wire lineWire;
|
||
App::DocumentObject* toolObj = CuttingToolWireObject.getValue();
|
||
DrawViewPart* baseDvp = freecad_cast<DrawViewPart*>(BaseView.getValue());
|
||
if (baseDvp) {
|
||
TopoDS_Shape toolShape = Part::Feature::getShape(toolObj);
|
||
if (toolShape.IsNull()) {
|
||
// CuttingToolWireObject is likely still restoring and has no shape yet
|
||
return {};
|
||
}
|
||
Base::Vector3d centroid = baseDvp->getCurrentCentroid();
|
||
TopoDS_Shape sTrans =
|
||
ShapeUtils::ShapeUtils::moveShape(toolShape, centroid * -1.0);
|
||
TopoDS_Shape sScaled = ShapeUtils::scaleShape(sTrans, baseDvp->getScale());
|
||
//we don't mirror the scaled shape here as it will be mirrored by the projection
|
||
|
||
if (sScaled.ShapeType() == TopAbs_WIRE) {
|
||
lineWire = makeNoseToTailWire(TopoDS::Wire(sScaled));
|
||
}
|
||
else if (sScaled.ShapeType() == TopAbs_EDGE) {
|
||
TopoDS_Edge edge = TopoDS::Edge(sScaled);
|
||
lineWire = BRepBuilderAPI_MakeWire(edge).Wire();
|
||
}
|
||
else {
|
||
//probably can't happen as cut profile has been checked before this
|
||
Base::Console().Message("DCS::makeSectionLineGeometry - profile is type: %d\n",
|
||
static_cast<int>(sScaled.ShapeType()));
|
||
return TopoDS_Wire();
|
||
}
|
||
}
|
||
return lineWire;
|
||
}
|
||
|
||
//find the points where the section line changes direction, and the direction
|
||
//of the profile before and after the point
|
||
ChangePointVector DrawComplexSection::getChangePointsFromSectionLine()
|
||
{
|
||
ChangePointVector result;
|
||
std::vector<gp_Pnt> allPoints;
|
||
DrawViewPart* baseDvp = freecad_cast<DrawViewPart*>(BaseView.getValue());
|
||
if (baseDvp) {
|
||
TopoDS_Wire lineWire = makeSectionLineWire();
|
||
TopoDS_Shape projectedWire =
|
||
GeometryObject::projectSimpleShape(lineWire, baseDvp->getProjectionCS());
|
||
if (projectedWire.IsNull()) {
|
||
return result;
|
||
}
|
||
//get UNIQUE points along the projected profile
|
||
TopExp_Explorer expVertex(projectedWire, TopAbs_VERTEX);
|
||
gp_Pnt previousPoint(Precision::Infinite(), Precision::Infinite(), Precision::Infinite());
|
||
for (; expVertex.More(); expVertex.Next()) {
|
||
TopoDS_Vertex vert = TopoDS::Vertex(expVertex.Current());
|
||
gp_Pnt gPoint = BRep_Tool::Pnt(vert);
|
||
if (gPoint.IsEqual(previousPoint, 2.0 * EWTOLERANCE)) {
|
||
continue;
|
||
}
|
||
allPoints.push_back(gPoint);
|
||
previousPoint = gPoint;
|
||
}
|
||
|
||
//make the intermediate marks
|
||
for (size_t iPoint = 1; iPoint < allPoints.size() - 1; iPoint++) {
|
||
gp_Pnt location = allPoints.at(iPoint);
|
||
gp_Dir preDir = gp_Dir(allPoints.at(iPoint - 1).XYZ() - allPoints.at(iPoint).XYZ());
|
||
gp_Dir postDir = gp_Dir(allPoints.at(iPoint + 1).XYZ() - allPoints.at(iPoint).XYZ());
|
||
ChangePoint point(location, preDir, postDir);
|
||
result.push_back(point);
|
||
}
|
||
|
||
//make start and end marks
|
||
gp_Pnt location0 = allPoints.at(0);
|
||
gp_Pnt location1 = allPoints.at(1);
|
||
gp_Dir postDir = gp_Dir(location1.XYZ() - location0.XYZ());
|
||
gp_Dir preDir = postDir.Reversed();
|
||
ChangePoint startPoint(location0, preDir, postDir);
|
||
result.push_back(startPoint);
|
||
location0 = allPoints.at(allPoints.size() - 1);
|
||
location1 = allPoints.at(allPoints.size() - 2);
|
||
preDir = gp_Dir(location0.XYZ() - location1.XYZ());
|
||
postDir = preDir.Reversed();
|
||
ChangePoint endPoint(location0, preDir, postDir);
|
||
result.push_back(endPoint);
|
||
}
|
||
return result;
|
||
}
|
||
|
||
gp_Ax2 DrawComplexSection::getCSFromBase(const std::string& sectionName) const
|
||
{
|
||
App::DocumentObject* base = BaseView.getValue();
|
||
if (!base
|
||
|| !base->isDerivedFrom<TechDraw::DrawViewPart>()) {//is second clause necessary?
|
||
//if this DCS does not have a baseView, we must use the existing SectionCS
|
||
return getSectionCS();
|
||
}
|
||
return DrawViewSection::getCSFromBase(sectionName);
|
||
}
|
||
|
||
// check for profile segments that are almost, but not quite in the same direction
|
||
// as the section normal direction. this often indicates a problem with the direction
|
||
// being slightly wrong. see https://forum.freecad.org/viewtopic.php?t=79017&sid=612a62a60f5db955ee071a7aaa362dbb
|
||
bool DrawComplexSection::validateOffsetProfile(TopoDS_Wire profile, Base::Vector3d direction, double angleThresholdDeg) const
|
||
{
|
||
constexpr double HalfCircleDegrees{180.0};
|
||
double angleThresholdRad = angleThresholdDeg * std::numbers::pi / HalfCircleDegrees;
|
||
TopExp_Explorer explEdges(profile, TopAbs_EDGE);
|
||
for (; explEdges.More(); explEdges.Next()) {
|
||
std::pair<Base::Vector3d, Base::Vector3d> segmentEnds = getSegmentEnds(TopoDS::Edge(explEdges.Current()));
|
||
Base::Vector3d segmentDir = segmentEnds.second - segmentEnds.first;
|
||
double angleRad = segmentDir.GetAngle(direction);
|
||
if (angleRad < angleThresholdRad &&
|
||
angleRad > 0.0) {
|
||
// profile segment is slightly skewed. possible bad SectionNormal?
|
||
Base::Console().Warning("%s profile is slightly skewed. Check SectionNormal low decimal places\n",
|
||
getNameInDocument());
|
||
return false;
|
||
}
|
||
}
|
||
return true;
|
||
}
|
||
|
||
|
||
// next two methods could be templated (??) to handle edge/wire
|
||
std::pair<Base::Vector3d, Base::Vector3d>
|
||
DrawComplexSection::getSegmentEnds(const TopoDS_Edge& segment)
|
||
{
|
||
TopoDS_Vertex tvFirst;
|
||
TopoDS_Vertex tvLast;
|
||
TopExp::Vertices(segment, tvFirst, tvLast);
|
||
gp_Pnt gpFirst = BRep_Tool::Pnt(tvFirst);
|
||
gp_Pnt gpLast = BRep_Tool::Pnt(tvLast);
|
||
std::pair<Base::Vector3d, Base::Vector3d> result;
|
||
result.first = Base::convertTo<Base::Vector3d>(gpFirst);
|
||
result.second = Base::convertTo<Base::Vector3d>(gpLast);
|
||
return result;
|
||
}
|
||
|
||
std::pair<Base::Vector3d, Base::Vector3d>
|
||
DrawComplexSection::getWireEnds(const TopoDS_Wire& wire)
|
||
{
|
||
TopoDS_Vertex tvFirst;
|
||
TopoDS_Vertex tvLast;
|
||
TopExp::Vertices(wire, tvFirst, tvLast);
|
||
gp_Pnt gpFirst = BRep_Tool::Pnt(tvFirst);
|
||
gp_Pnt gpLast = BRep_Tool::Pnt(tvLast);
|
||
std::pair<Base::Vector3d, Base::Vector3d> result;
|
||
result.first = Base::convertTo<Base::Vector3d>(gpFirst);
|
||
result.second = Base::convertTo<Base::Vector3d>(gpLast);
|
||
return result;
|
||
}
|
||
|
||
|
||
gp_Vec DrawComplexSection::projectVector(const gp_Vec& vec, gp_Ax2 sectionCS)
|
||
{
|
||
HLRAlgo_Projector projector(sectionCS);
|
||
gp_Pnt2d prjPoint;
|
||
projector.Project(gp_Pnt(vec.XYZ()), prjPoint);
|
||
return {prjPoint.X(), prjPoint.Y(), 0};
|
||
}
|
||
|
||
//simple projection of a 3d vector onto the paper space
|
||
gp_Vec DrawComplexSection::projectVector(const gp_Vec& vec) const
|
||
{
|
||
return projectVector(vec, getProjectionCS());
|
||
}
|
||
|
||
//get the "effective" (flattened paper plane) section plane for Aligned and
|
||
//the regular sectionPlane for Offset.
|
||
gp_Pln DrawComplexSection::getSectionPlane() const
|
||
{
|
||
if (ProjectionStrategy.getValue() == 0) {
|
||
//Offset. Use regular section behaviour
|
||
return DrawViewSection::getSectionPlane();
|
||
}
|
||
|
||
//"Aligned" projection (Aligned Section)
|
||
//this is the same as DVS::getSectionPlane except that the plane origin is not the SectionOrigin
|
||
Base::Vector3d vSectionNormal = SectionNormal.getValue();
|
||
gp_Dir gSectionNormal(vSectionNormal.x, vSectionNormal.y, vSectionNormal.z);
|
||
gp_Pnt gOrigin(0.0, 0.0, 0.0);
|
||
gp_Ax3 gPlaneCS(gOrigin, gSectionNormal);
|
||
|
||
return {gPlaneCS};
|
||
}
|
||
|
||
bool DrawComplexSection::isBaseValid() const
|
||
{
|
||
App::DocumentObject* base = BaseView.getValue();
|
||
if (!base) {
|
||
//complex section is not based on an existing DVP
|
||
return true;
|
||
}
|
||
if (!base->isDerivedFrom<TechDraw::DrawViewPart>()) {
|
||
//this is probably an error somewhere. the valid options are base = a DVP,
|
||
//or no base
|
||
return false;
|
||
}
|
||
//have a base and it is a DVP
|
||
return true;
|
||
}
|
||
|
||
//if the profile is not nicely positioned within the vertical span of the shape, we might not overlap
|
||
//the shape after extrusion. As long as the profile is within the extent of the shape in the
|
||
//extrude direction we should be ok. the extrude direction has to be perpendicular to the profile and SectionNormal
|
||
bool DrawComplexSection::validateProfilePosition(const TopoDS_Wire& profileWire, const gp_Ax2& sectionCS) const
|
||
{
|
||
auto wireEnds = getWireEnds(profileWire);
|
||
auto gpFirst = Base::convertTo<gp_Pnt>(wireEnds.first);
|
||
gp_Vec gProfileVector = makeProfileVector(profileWire);
|
||
|
||
//since bounding boxes are aligned with the cardinal directions, we need to find
|
||
//the appropriate direction to use when validating the profile position
|
||
gp_Vec gSectionVector = getSectionCS().Direction().Reversed();
|
||
gp_Vec gExtrudeVector = gSectionVector.Crossed(gProfileVector);
|
||
Base::Vector3d vClosestBasis = DrawUtil::closestBasis(gp_Dir(gExtrudeVector), sectionCS);
|
||
auto gClosestBasis = gp_Dir(vClosestBasis.x, vClosestBasis.y, vClosestBasis.z);
|
||
|
||
Bnd_Box shapeBox;
|
||
shapeBox.SetGap(0.0);
|
||
BRepBndLib::AddOptimal(m_saveShape, shapeBox);
|
||
double xMin = 0, xMax = 0, yMin = 0, yMax = 0, zMin = 0, zMax = 0; //NOLINT
|
||
shapeBox.Get(xMin, yMin, zMin, xMax, yMax, zMax);
|
||
double spanLow = xMin;
|
||
double spanHigh = xMax;
|
||
double spanCheck = gpFirst.X();
|
||
if (gClosestBasis.IsParallel(sectionCS.YDirection(), Precision::Angular())) {
|
||
spanLow = yMin;
|
||
spanHigh = yMax;
|
||
spanCheck = gpFirst.Y();
|
||
}
|
||
else if (gClosestBasis.IsParallel(sectionCS.Direction(), Precision::Angular())) {
|
||
spanLow = zMin;
|
||
spanHigh = zMax;
|
||
spanCheck = gpFirst.Z();
|
||
}
|
||
|
||
if (spanLow > spanCheck || spanHigh < spanCheck) {
|
||
//profile is not within span of shape
|
||
return false;
|
||
}
|
||
//profile is within span of shape
|
||
return true;
|
||
}
|
||
|
||
bool DrawComplexSection::showSegment(gp_Dir segmentNormal) const
|
||
{
|
||
if (ProjectionStrategy.getValue() < 2) {
|
||
//Offset or Aligned are always true
|
||
return true;
|
||
}
|
||
|
||
Base::Vector3d vSectionNormal = SectionNormal.getValue();
|
||
gp_Dir gSectionNormal(vSectionNormal.x, vSectionNormal.y, vSectionNormal.z);
|
||
//segment normal is perpendicular to section normal, so segment is parallel to section normal,
|
||
//and for ProjectionStrategy "NoParallel", we don't display these segments.
|
||
return !DU::fpCompare(fabs(gSectionNormal.Dot(segmentNormal)), 0.0);
|
||
}
|
||
|
||
//Can we make a ComplexSection using this profile and sectionNormal?
|
||
bool DrawComplexSection::canBuild(gp_Ax2 sectionCS, App::DocumentObject* profileObject)
|
||
{
|
||
if (!isProfileObject(profileObject)) {
|
||
return false;
|
||
}
|
||
|
||
TopoDS_Shape shape = Part::Feature::getShape(profileObject);
|
||
if (BRep_Tool::IsClosed(shape)) {
|
||
//closed profiles don't have a profile vector but should always make a section?
|
||
return true;
|
||
}
|
||
|
||
gp_Vec gProfileVec = makeProfileVector(makeProfileWire(profileObject));
|
||
double dot = fabs(gProfileVec.Dot(sectionCS.Direction()));
|
||
return !DU::fpCompare(dot, 1.0, EWTOLERANCE);
|
||
}
|
||
|
||
// general purpose geometry methods
|
||
|
||
//make a "face" (not necessarily a TopoDS_Face since the extrusion of a wire is a shell)
|
||
//from a single open wire by displacing the wire extruding it
|
||
TopoDS_Shape DrawComplexSection::extrudeWireToFace(TopoDS_Wire& wire, gp_Dir extrudeDir,
|
||
double extrudeDist)
|
||
{
|
||
BRepPrimAPI_MakePrism mkPrism(wire, gp_Vec(extrudeDir) * extrudeDist * 2);
|
||
|
||
return mkPrism.Shape();
|
||
}
|
||
|
||
//returns the normal of the face to be extruded into a cutting tool
|
||
//the face is expected to be planar
|
||
gp_Dir DrawComplexSection::getFaceNormal(TopoDS_Face& face)
|
||
{
|
||
BRepAdaptor_Surface adapt(face);
|
||
double uParmFirst = adapt.FirstUParameter();
|
||
double uParmLast = adapt.LastUParameter();
|
||
double vParmFirst = adapt.FirstVParameter();
|
||
double vParmLast = adapt.LastVParameter();
|
||
double uMid = (uParmFirst + uParmLast) / 2;
|
||
double vMid = (vParmFirst + vParmLast) / 2;
|
||
|
||
constexpr double PropTolerance{0.01};
|
||
BRepLProp_SLProps prop(adapt, uMid, vMid, 1, PropTolerance);
|
||
gp_Dir normalDir(0.0, 0.0, 1.0);//default
|
||
if (prop.IsNormalDefined()) {
|
||
normalDir = prop.Normal();
|
||
}
|
||
return normalDir;
|
||
}
|
||
|
||
bool DrawComplexSection::boxesIntersect(TopoDS_Face& face, TopoDS_Shape& shape)
|
||
{
|
||
constexpr double OverlapTolerance{0.1};
|
||
Bnd_Box box0;
|
||
Bnd_Box box1;
|
||
BRepBndLib::Add(face, box0);
|
||
box0.SetGap(OverlapTolerance);//generous
|
||
BRepBndLib::Add(shape, box1);
|
||
box1.SetGap(OverlapTolerance);
|
||
return !box0.IsOut(box1);
|
||
}
|
||
|
||
TopoDS_Shape DrawComplexSection::shapeShapeIntersect(const TopoDS_Shape& shape0,
|
||
const TopoDS_Shape& shape1)
|
||
{
|
||
FCBRepAlgoAPI_Common anOp;
|
||
anOp.SetFuzzyValue(EWTOLERANCE);
|
||
TopTools_ListOfShape anArg1;
|
||
TopTools_ListOfShape anArg2;
|
||
anArg1.Append(shape0);
|
||
anArg2.Append(shape1);
|
||
anOp.SetArguments(anArg1);
|
||
anOp.SetTools(anArg2);
|
||
anOp.Build();
|
||
TopoDS_Shape result = anOp.Shape();//always a compound
|
||
if (isTrulyEmpty(result)) {
|
||
return {};
|
||
}
|
||
return result;
|
||
}
|
||
|
||
//find all the intersecting regions of face and shape
|
||
std::vector<TopoDS_Face> DrawComplexSection::faceShapeIntersect(const TopoDS_Face& face,
|
||
const TopoDS_Shape& shape)
|
||
{
|
||
TopoDS_Shape intersect = shapeShapeIntersect(face, shape);
|
||
if (intersect.IsNull()) {
|
||
return {};
|
||
}
|
||
std::vector<TopoDS_Face> intersectFaceList;
|
||
TopExp_Explorer expFaces(intersect, TopAbs_FACE);
|
||
for (int i = 1; expFaces.More(); expFaces.Next(), i++) {
|
||
intersectFaceList.push_back(TopoDS::Face(expFaces.Current()));
|
||
}
|
||
return intersectFaceList;
|
||
}
|
||
|
||
//ensure that the edges in the output wire are in nose to tail order
|
||
TopoDS_Wire DrawComplexSection::makeNoseToTailWire(const TopoDS_Wire& inWire)
|
||
{
|
||
if (inWire.IsNull()) {
|
||
return inWire;
|
||
}
|
||
|
||
std::list<TopoDS_Edge> inList;
|
||
TopExp_Explorer expEdges(inWire, TopAbs_EDGE);
|
||
for (; expEdges.More(); expEdges.Next()) {
|
||
TopoDS_Edge edge = TopoDS::Edge(expEdges.Current());
|
||
inList.push_back(edge);
|
||
}
|
||
|
||
std::list<TopoDS_Edge> sortedList;
|
||
if (inList.empty() || inList.size() == 1) {
|
||
return inWire;
|
||
}
|
||
|
||
sortedList = DrawUtil::sort_Edges(EWTOLERANCE, inList);
|
||
BRepBuilderAPI_MakeWire mkWire;
|
||
for (auto& edge : sortedList) {
|
||
mkWire.Add(edge);
|
||
}
|
||
return mkWire.Wire();
|
||
}
|
||
|
||
//static
|
||
bool DrawComplexSection::isProfileObject(App::DocumentObject* obj)
|
||
{
|
||
//if the object's shape is a wire or an edge, then it can be a profile object
|
||
TopoDS_Shape shape = Part::Feature::getShape(obj);
|
||
if (shape.IsNull()) {
|
||
return false;
|
||
}
|
||
if (shape.ShapeType() == TopAbs_WIRE || shape.ShapeType() == TopAbs_EDGE) {
|
||
return true;
|
||
}
|
||
//don't know what this is, but it isn't suitable as a profile
|
||
return false;
|
||
}
|
||
|
||
bool DrawComplexSection::isMultiSegmentProfile(App::DocumentObject* obj)
|
||
{
|
||
//if the object's shape is a wire or an edge, then it can be a profile object
|
||
TopoDS_Shape shape = Part::Feature::getShape(obj);
|
||
if (shape.IsNull()) {
|
||
return false;
|
||
}
|
||
if (shape.ShapeType() == TopAbs_EDGE) {
|
||
//only have 1 edge, can't be multisegment;
|
||
return false;
|
||
}
|
||
if (shape.ShapeType() == TopAbs_WIRE) {
|
||
std::vector<TopoDS_Edge> edgesInWire;
|
||
TopExp_Explorer expEdges(shape, TopAbs_EDGE);
|
||
for (; expEdges.More(); expEdges.Next()) {
|
||
TopoDS_Edge edge = TopoDS::Edge(expEdges.Current());
|
||
BRepAdaptor_Curve adapt(edge);
|
||
if (adapt.GetType() == GeomAbs_Line) {
|
||
edgesInWire.push_back(edge);
|
||
}
|
||
}
|
||
if (edgesInWire.size() > 1) {
|
||
return true;
|
||
}
|
||
}
|
||
return false;
|
||
}
|
||
|
||
//check if the profile has curves in it
|
||
bool DrawComplexSection::isLinearProfile(App::DocumentObject* obj)
|
||
{
|
||
TopoDS_Shape shape = Part::Feature::getShape(obj);
|
||
if (shape.IsNull()) {
|
||
return false;
|
||
}
|
||
if (shape.ShapeType() == TopAbs_EDGE) {
|
||
//only have 1 edge
|
||
TopoDS_Edge edge = TopoDS::Edge(shape);
|
||
BRepAdaptor_Curve adapt(edge);
|
||
return (adapt.GetType() == GeomAbs_Line);
|
||
}
|
||
|
||
if (shape.ShapeType() == TopAbs_WIRE) {
|
||
std::vector<TopoDS_Edge> edgesInWire;
|
||
TopExp_Explorer expEdges(shape, TopAbs_EDGE);
|
||
for (; expEdges.More(); expEdges.Next()) {
|
||
TopoDS_Edge edge = TopoDS::Edge(expEdges.Current());
|
||
BRepAdaptor_Curve adapt(edge);
|
||
if (adapt.GetType() != GeomAbs_Line) {
|
||
return false;
|
||
}
|
||
}
|
||
//all the edges in the wire are lines
|
||
return true;
|
||
}
|
||
|
||
//this shouldn't happen
|
||
return false;
|
||
}
|
||
|
||
//a compound with no content is not considered IsNull by OCC. A more thorough check
|
||
//is required.
|
||
//https://dev.opencascade.org/content/compound-empty
|
||
bool DrawComplexSection::isTrulyEmpty(const TopoDS_Shape& inShape)
|
||
{
|
||
bool hasContent = !inShape.IsNull() && TopoDS_Iterator(inShape).More();
|
||
return !hasContent;
|
||
}
|
||
|
||
|
||
// this is a slightly different closed profile than getSegmentViewDirections uses. Should we use that
|
||
// here??
|
||
std::vector<Base::Vector3d>
|
||
DrawComplexSection::getPointsForClosingProfile(const TopoDS_Wire& profileWire, double dMax)
|
||
{
|
||
auto ends = getWireEnds(profileWire);
|
||
auto firstPoint = ends.first;
|
||
auto lastPoint = ends.second;
|
||
auto midPoint = (firstPoint + lastPoint) / 2; // midpoint of profile vector
|
||
|
||
auto arrows = sectionArrowDirs();
|
||
auto pseudoSectionNormal = ((arrows.first + arrows.second) / 2) * -1;
|
||
pseudoSectionNormal.Normalize();
|
||
auto extraPoint = midPoint + pseudoSectionNormal * dMax * 2;
|
||
|
||
std::vector<Base::Vector3d> points;
|
||
auto pointFromLast = lastPoint + (arrows.second * -1) * dMax;
|
||
auto pointToFirst = firstPoint + (arrows.first * -1) * dMax;
|
||
points.emplace_back(lastPoint);
|
||
points.emplace_back(pointFromLast);
|
||
points.emplace_back(extraPoint);
|
||
points.emplace_back(pointToFirst);
|
||
points.emplace_back(firstPoint);
|
||
return points;
|
||
}
|
||
|
||
TopoDS_Shape DrawComplexSection::removeEmptyShapes(const TopoDS_Shape& roughTool)
|
||
{
|
||
BRep_Builder builder;
|
||
TopoDS_Compound comp;
|
||
builder.MakeCompound(comp);
|
||
TopExp_Explorer expSolids(roughTool, TopAbs_SOLID);
|
||
for (; expSolids.More(); expSolids.Next()) {
|
||
TopoDS_Solid solid = TopoDS::Solid(expSolids.Current());
|
||
GProp_GProps gprops;
|
||
BRepGProp::VolumeProperties(solid, gprops);
|
||
double volume = gprops.Mass();
|
||
if (volume > EWTOLERANCE) {
|
||
builder.Add(comp, solid);
|
||
}
|
||
}
|
||
return comp;
|
||
}
|
||
|
||
//! reversers determine if the cut pieces are arranged left to right or right to left (down to up/up to down)
|
||
//! returns true if the profile vector is vertical.
|
||
bool DrawComplexSection::getReversers(const gp_Vec& gProfileVec, double& horizReverser, double& verticalReverser)
|
||
{
|
||
bool isProfileVertical = true;
|
||
auto sectionCS = getSectionCS();
|
||
auto sectionCSX = sectionCS.XDirection();
|
||
auto sectionCSY = sectionCS.YDirection();
|
||
auto verticalDot = gProfileVec.Dot(sectionCSY);
|
||
if (DU::fpCompare(fabs(verticalDot), 0, EWTOLERANCE)) {
|
||
//profile is +/- normal to Y.
|
||
isProfileVertical = false;
|
||
}
|
||
|
||
horizReverser = 1.0; //profile vector points to right, so we move to right
|
||
if (gProfileVec.Dot(sectionCSX) < 0.0) {
|
||
//profileVec does not point towards stdX (right in paper space)
|
||
horizReverser = -1.0;
|
||
}
|
||
|
||
verticalReverser = 1.0;//profile vector points to top, so we will move pieces upwards
|
||
if (gProfileVec.Dot(sectionCSY) < 0.0) {
|
||
//profileVec does not point towards stdY (up in paper space)
|
||
verticalReverser = -1.0;
|
||
}
|
||
|
||
return isProfileVertical;
|
||
}
|
||
|
||
|
||
//! align a copy of the piece with OXYZ so we can use bounding box to get
|
||
//! width, depth, height of the piece. We copy the piece so the transformation
|
||
//! does not affect the original.
|
||
AlignedSizeResponse DrawComplexSection::getAlignedSize(const TopoDS_Shape& pieceRotated,
|
||
int iPiece) const
|
||
{
|
||
gp_Ax3 stdCS; //OXYZ
|
||
BRepBuilderAPI_Copy BuilderPieceCopy(pieceRotated);
|
||
TopoDS_Shape copyPieceRotatedShape = BuilderPieceCopy.Shape();
|
||
gp_Trsf xPieceAlign;
|
||
xPieceAlign.SetTransformation(stdCS, getProjectionCS());
|
||
BRepBuilderAPI_Transform mkTransAlign(copyPieceRotatedShape, xPieceAlign);
|
||
TopoDS_Shape pieceAligned = mkTransAlign.Shape();
|
||
// we may have shifted our piece off center, so we better recenter here
|
||
gp_Trsf xPieceRecenter;
|
||
gp_Vec rotatedCentroid = gp_Vec(ShapeUtils::findCentroid(pieceAligned).XYZ());
|
||
xPieceRecenter.SetTranslation(rotatedCentroid * -1.0);
|
||
BRepBuilderAPI_Transform mkTransRecenter(pieceAligned, xPieceRecenter, true);
|
||
pieceAligned = mkTransRecenter.Shape();
|
||
|
||
if (debugSection()) {
|
||
stringstream ss;
|
||
ss << "DCSDpieceAligned" << iPiece << ".brep";
|
||
BRepTools::Write(pieceAligned, ss.str().c_str());//debug
|
||
ss.clear();
|
||
ss.str(std::string());
|
||
}
|
||
Bnd_Box shapeBox;
|
||
shapeBox.SetGap(0.0);
|
||
BRepBndLib::AddOptimal(pieceAligned, shapeBox);
|
||
double xMin = 0, xMax = 0, yMin = 0, yMax = 0, zMin = 0, zMax = 0; //NOLINT
|
||
shapeBox.Get(xMin, yMin, zMin, xMax, yMax, zMax);
|
||
double pieceXSize(xMax - xMin);
|
||
double pieceYSize(yMax - yMin);
|
||
double pieceZSize(zMax - zMin);
|
||
Base::Vector3d pieceSize{pieceXSize, pieceYSize, pieceZSize};
|
||
return {pieceAligned, pieceSize, zMax};
|
||
}
|
||
|
||
//! cut the rawShape with a tool derived from the segmentFace and align the result with the
|
||
//! page plane. Also supplies the piece size.
|
||
TopoDS_Shape DrawComplexSection::cutAndRotatePiece(const TopoDS_Shape& rawShape,
|
||
const TopoDS_Face& segmentFace,
|
||
int iPiece,
|
||
Base::Vector3d uOrientedSegmentNormal,
|
||
Base::Vector3d uRotateAxis,
|
||
double& pieceVertical)
|
||
{
|
||
auto segmentNormal = Base::convertTo<gp_Vec>(uOrientedSegmentNormal);
|
||
auto rotateAxis = Base::convertTo<gp_Vec>(uRotateAxis);
|
||
gp_Vec extrudeDir = segmentNormal * m_shapeSize;
|
||
BRepPrimAPI_MakePrism mkPrism(segmentFace, extrudeDir);
|
||
TopoDS_Shape segmentTool = mkPrism.Shape();
|
||
TopoDS_Shape intersect = shapeShapeIntersect(segmentTool, rawShape);
|
||
if (intersect.IsNull()) {
|
||
return {};
|
||
}
|
||
if (debugSection()) {
|
||
stringstream ss;
|
||
ss << "DCSAintersect" << iPiece << ".brep";
|
||
BRepTools::Write(intersect, ss.str().c_str());//debug
|
||
ss.clear();
|
||
ss.str(std::string());
|
||
}
|
||
|
||
// move intersection shape to the origin so we can rotate it without worrying about
|
||
// center of rotation.
|
||
gp_Trsf xPieceCenter;
|
||
gp_Vec pieceCentroid = gp_Vec(ShapeUtils::findCentroid(intersect).XYZ());
|
||
|
||
// save the amount we moved this piece in the vertical direction so we can
|
||
// put it back in the right place later
|
||
gp_Vec maskedVertical = DU::maskDirection(pieceCentroid, rotateAxis);
|
||
maskedVertical = pieceCentroid - maskedVertical;
|
||
pieceVertical = maskedVertical.X() + maskedVertical.Y() + maskedVertical.Z();
|
||
|
||
xPieceCenter.SetTranslation(pieceCentroid * -1.0);
|
||
BRepBuilderAPI_Transform mkTransXLate(intersect, xPieceCenter, true);
|
||
TopoDS_Shape pieceCentered = mkTransXLate.Shape();
|
||
if (debugSection()) {
|
||
stringstream ss;
|
||
ss << "DCSBpieceCentered" << iPiece << ".brep";
|
||
BRepTools::Write(pieceCentered, ss.str().c_str());//debug
|
||
ss.clear();
|
||
ss.str(std::string());
|
||
}
|
||
|
||
//rotate the intersection so interesting face is aligned with what will
|
||
// become the paper plane.
|
||
double faceAngle =
|
||
gp_Vec(getSectionCS().Direction().Reversed()).AngleWithRef(segmentNormal, rotateAxis);
|
||
gp_Ax1 faceAxis(gp_Pnt(0.0, 0.0, 0.0), rotateAxis);
|
||
gp_Ax3 stdCS;
|
||
gp_Ax3 pieceCS;
|
||
pieceCS.Rotate(faceAxis, faceAngle);
|
||
gp_Trsf xPieceRotate;
|
||
xPieceRotate.SetTransformation(stdCS, pieceCS);
|
||
BRepBuilderAPI_Transform mkTransRotate(pieceCentered, xPieceRotate, true);
|
||
TopoDS_Shape pieceRotated = mkTransRotate.Shape();
|
||
|
||
return pieceRotated;
|
||
}
|
||
|
||
TopoDS_Shape DrawComplexSection::movePieceToPaperPlane(const TopoDS_Shape& piece, double sizeMax)
|
||
{
|
||
//now we need to move the piece so that the interesting face is coincident
|
||
//with the paper plane (stdXY). This will be a move along stdZ by -zMax.
|
||
gp_Vec toPaperPlane = gp::OZ().Direction().XYZ() * sizeMax * -1.0;
|
||
gp_Trsf xPieceToPlane;
|
||
xPieceToPlane.SetTranslation(toPaperPlane);
|
||
BRepBuilderAPI_Transform mkTransDisplace(piece, xPieceToPlane, true);
|
||
TopoDS_Shape pieceToPlane = mkTransDisplace.Shape();
|
||
|
||
// piece is on the paper plane, with piece centroid at the origin
|
||
return pieceToPlane;
|
||
}
|
||
|
||
//! move the piece to its position across the page (X for a left right profile)
|
||
TopoDS_Shape DrawComplexSection::distributePiece(const TopoDS_Shape& piece,
|
||
double pieceSizeInDirection,
|
||
double verticalDisplace,
|
||
const gp_Vec& alignmentAxis,
|
||
const gp_Vec& gMovementVector,
|
||
double cursorPosition)
|
||
{
|
||
double pieceTotalDistanceToMove = cursorPosition + pieceSizeInDirection / 2;
|
||
gp_Vec alignmentVector = alignmentAxis * verticalDisplace * -1;
|
||
gp_Vec netDisplacementVector = gMovementVector * pieceTotalDistanceToMove + alignmentVector;
|
||
|
||
gp_Trsf xPieceDistribute;
|
||
xPieceDistribute.SetTranslation(netDisplacementVector);
|
||
BRepBuilderAPI_Transform mkTransDistribute(piece, xPieceDistribute, true);
|
||
auto distributedPiece = mkTransDistribute.Shape();
|
||
|
||
return distributedPiece;
|
||
}
|
||
|
||
|
||
// ?? are these in the correct order?? profile wires are in nose to tail order
|
||
std::vector<TopoDS_Edge> DrawComplexSection::getUniqueEdges(const TopoDS_Wire& wireIn)
|
||
{
|
||
std::vector<TopoDS_Edge> ret;
|
||
TopTools_IndexedMapOfShape shapeMap;
|
||
TopExp_Explorer Ex(wireIn, TopAbs_EDGE);
|
||
while (Ex.More()) {
|
||
shapeMap.Add(Ex.Current());
|
||
Ex.Next();
|
||
}
|
||
|
||
for (Standard_Integer k = 1; k <= shapeMap.Extent(); k++) {
|
||
const TopoDS_Shape& shape = shapeMap(k);
|
||
auto edge = TopoDS::Edge(shape);
|
||
ret.push_back(edge);
|
||
}
|
||
|
||
return ret;
|
||
}
|
||
|
||
//! Find the correct view directions for the profile segments by making a face from the profile and
|
||
//! extruding it into a solid, then examining the faces of the solid.
|
||
std::vector<std::pair<int, Base::Vector3d>> DrawComplexSection::getSegmentViewDirections(const TopoDS_Wire& profileWire,
|
||
Base::Vector3d sectionNormal,
|
||
Base::Vector3d referenceAxis) const
|
||
{
|
||
auto edgesAll = getUniqueEdges(profileWire);
|
||
if (edgesAll.empty()) {
|
||
// this is bad!
|
||
throw Base::RuntimeError("Complex section: profile wire has no edges.");
|
||
}
|
||
|
||
if (!checkSectionCS()) {
|
||
// results will likely be incorrect
|
||
// this message will show for every recompute of the complex section.
|
||
Base::Console().Warning("Coordinate system for ComplexSection is invalid. Check SectionNormal, Direction or XDirection.\n");
|
||
}
|
||
|
||
auto profileVector = Base::convertTo<Base::Vector3d>(makeProfileVector(profileWire));
|
||
auto parallelDot = profileVector.Dot(sectionNormal);
|
||
if (DU::fpCompare(std::fabs(parallelDot), 1, EWTOLERANCE)) {
|
||
Base::Console().Warning("Section normal is parallel to profile vector. Results may be incorrect.\n");
|
||
}
|
||
auto profilePlanWire = closeProfile(profileWire, sectionNormal, m_shapeSize);
|
||
|
||
auto profileSolid = profileToSolid(profilePlanWire, referenceAxis, m_shapeSize);
|
||
if (debugSection()) {
|
||
BRepTools::Write(profileSolid, "DCSProfileSolid.brep");//debug
|
||
}
|
||
|
||
std::vector<Base::Vector3d> profileNormals;
|
||
std::vector<std::pair<int, Base::Vector3d>> normalKV;
|
||
TopExp_Explorer expFaces(profileSolid, TopAbs_FACE);
|
||
// no guarantee of order from TopExp_Explorer?? Need to match faces to the profile segment that
|
||
// generated it?
|
||
for (int iFace = 0; expFaces.More(); expFaces.Next(), iFace++) {
|
||
auto shape = expFaces.Current();
|
||
auto face = TopoDS::Face(shape);
|
||
auto normal = Base::convertTo<Base::Vector3d>(getFaceNormal(face));
|
||
if (face.Orientation() == TopAbs_FORWARD) {
|
||
// face on solid with Forward orientation will have a normal that points out of the
|
||
// solid. With Reverse orientation the normal will point into the solid. We want the
|
||
// direction into the solid.
|
||
// "Face normal shows where body material is – it lies ‘behind' the face. In a correct solid body all face normals go ‘outward' (see below):"
|
||
// https://opencascade.blogspot.com/2009/02/continued.html
|
||
normal *= -1;
|
||
}
|
||
auto topOrBottomDot = std::fabs(normal.Dot(referenceAxis));
|
||
if (DU::fpCompare(topOrBottomDot, 1, EWTOLERANCE)) {
|
||
continue;
|
||
}
|
||
BRepAdaptor_Surface adaptSurface(face);
|
||
auto surfaceType = adaptSurface.GetType();
|
||
if (surfaceType != GeomAbs_SurfaceType::GeomAbs_Plane) {
|
||
continue;
|
||
}
|
||
// this is an interesting face, get the normal and edge
|
||
int iSegment{0};
|
||
for (auto& segment : edgesAll) {
|
||
if (faceContainsEndpoints(segment, face)) {
|
||
std::pair<int, Base::Vector3d> newEntry;
|
||
newEntry.first = iSegment;
|
||
newEntry.second = normal;
|
||
normalKV.push_back(newEntry);
|
||
break;
|
||
}
|
||
iSegment++;
|
||
}
|
||
}
|
||
std::sort(normalKV.begin(), normalKV.end(), DrawComplexSection::normalLess);
|
||
return normalKV;
|
||
}
|
||
|
||
//! true if the endpoints of edgeToMatch are vertexes of faceToSearch
|
||
bool DrawComplexSection::faceContainsEndpoints(const TopoDS_Edge& edgeToMatch, const TopoDS_Face& faceToSearch)
|
||
{
|
||
bool matchedFirst{false};
|
||
bool matchedLast{false};
|
||
|
||
std::pair<Base::Vector3d, Base::Vector3d> edgeEnds = getSegmentEnds(edgeToMatch);
|
||
TopExp_Explorer expVerts(faceToSearch, TopAbs_VERTEX);
|
||
int iFace = 0;
|
||
for (; expVerts.More(); expVerts.Next(), iFace++) {
|
||
auto shape = expVerts.Current();
|
||
auto vertex = TopoDS::Vertex(shape);
|
||
auto point = Base::convertTo<Base::Vector3d>(BRep_Tool::Pnt(vertex));
|
||
if (point.IsEqual(edgeEnds.first, EWTOLERANCE)) {
|
||
matchedFirst = true;
|
||
}
|
||
if (point.IsEqual(edgeEnds.second, EWTOLERANCE)) {
|
||
matchedLast = true;
|
||
}
|
||
if (matchedFirst && matchedLast) {
|
||
break;
|
||
}
|
||
}
|
||
return matchedFirst && matchedLast;
|
||
}
|
||
|
||
|
||
//! forms a closed wire by connecting the end points of the profile wire with an arc.
|
||
TopoDS_Wire DrawComplexSection::closeProfile(const TopoDS_Wire& profileWire,
|
||
Base::Vector3d sectionNormal,
|
||
double dMax)
|
||
{
|
||
auto pvEnds = getWireEnds(profileWire);
|
||
auto firstPWPoint = pvEnds.first;
|
||
auto lastPWPoint = pvEnds.second;
|
||
auto midPWPoint = (firstPWPoint + lastPWPoint) / 2;
|
||
auto SNPoint = sectionNormal * dMax;
|
||
auto awayDirection = midPWPoint - SNPoint;
|
||
awayDirection.Normalize();
|
||
auto radius = (midPWPoint - lastPWPoint).Length();
|
||
auto pointOnArc = midPWPoint + awayDirection * radius;
|
||
|
||
GC_MakeArcOfCircle mkArc(Base::convertTo<gp_Pnt>(lastPWPoint),
|
||
Base::convertTo<gp_Pnt>(pointOnArc),
|
||
Base::convertTo<gp_Pnt>(firstPWPoint));
|
||
auto circleArc = mkArc.Value();
|
||
if (!mkArc.IsDone()) {
|
||
throw Base::RuntimeError("Complex section failed to create arc");
|
||
}
|
||
auto circleEdge = BRepBuilderAPI_MakeEdge(circleArc);
|
||
|
||
BRepBuilderAPI_MakeWire mkWire(profileWire);
|
||
mkWire.Add(circleEdge);
|
||
return mkWire.Wire();
|
||
}
|
||
|
||
|
||
//! extrudes a face made from a wire along the reference axis
|
||
TopoDS_Shape DrawComplexSection::profileToSolid(const TopoDS_Wire& closedProfileWire,
|
||
Base::Vector3d referenceAxis,
|
||
double dMax)
|
||
{
|
||
BRepBuilderAPI_MakeFace mkFace(closedProfileWire);
|
||
if (!mkFace.IsDone()) {
|
||
throw Base::RuntimeError("Complex section could not create face from closed profile");
|
||
}
|
||
|
||
auto extrudeVector = referenceAxis * dMax;
|
||
|
||
BRepPrimAPI_MakePrism mkPrism(mkFace.Face(), Base::convertTo<gp_Vec>(extrudeVector));
|
||
auto profileSolid = mkPrism.Shape();
|
||
|
||
return profileSolid;
|
||
}
|
||
|
||
|
||
//! compare 2 normal entries for sorting on segment index
|
||
bool DrawComplexSection::normalLess(const std::pair<int, Base::Vector3d>& n1, const std::pair<int, Base::Vector3d>& n2)
|
||
{
|
||
return n1.first < n2.first;
|
||
}
|
||
|
||
|
||
// Python Drawing feature ---------------------------------------------------------
|
||
|
||
namespace App
|
||
{
|
||
/// @cond DOXERR
|
||
PROPERTY_SOURCE_TEMPLATE(TechDraw::DrawComplexSectionPython, TechDraw::DrawComplexSection)
|
||
template<> const char* TechDraw::DrawComplexSectionPython::getViewProviderName() const
|
||
{
|
||
return "TechDrawGui::ViewProviderDrawingView";
|
||
}
|
||
/// @endcond
|
||
|
||
// explicit template instantiation
|
||
template class TechDrawExport FeaturePythonT<TechDraw::DrawComplexSection>;
|
||
}// namespace App
|