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

Remove duplicate code/save Dim line geom

Browse Source
This commit is contained in:
wandererfan
2018-03-23 15:00:53 -04:00
committed by wmayer
parent 154f027496
commit e9eeea9318
5 changed files with 606 additions and 674 deletions
Download Patch File Download Diff File Expand all files Collapse all files

471
src/Mod/TechDraw/App/DrawViewDimension.cpp
View File

@@ -33,6 +33,9 @@
#include <BRepBuilderAPI_MakeVertex.hxx>
#include <BRepBuilderAPI_MakeEdge.hxx>
#include <BRepExtrema_DistShapeShape.hxx>
#include <gp_Pnt.hxx>
#include <TopoDS_Shape.hxx>
#include <TopoDS_Edge.hxx>
#endif
#include <QLocale>
@@ -114,6 +117,10 @@ DrawViewDimension::DrawViewDimension(void)
measurement = new Measure::Measurement();
//TODO: should have better initial datumLabel position than (0,0) in the DVP?? something closer to the object being measured?
//start/end point for linear measures
m_linearPoints.first = Base::Vector3d(0,0,0);
m_linearPoints.second = Base::Vector3d(0,0,0);
}
DrawViewDimension::~DrawViewDimension()
@@ -167,6 +174,15 @@ short DrawViewDimension::mustExecute() const
if (result) {
return result;
}
auto dvp = getViewPart();
if (dvp != nullptr) {
result = dvp->isTouched();
}
if (result) {
return result;
}
return DrawView::mustExecute();
}
@@ -179,11 +195,139 @@ App::DocumentObjectExecReturn *DrawViewDimension::execute(void)
if (!has2DReferences()) { //too soon
return App::DocumentObject::StdReturn;
}
if (!getViewPart()->hasGeometry()) { //happens when loading saved document
Base::Console().Log("INFO - DVD::getDimValue ViewPart has no Geometry yet\n");
return App::DocumentObject::StdReturn;
}
if (!checkReferences2D()) {
Base::Console().Log("Error: DVD - %s - 2D references are corrupt\n",getNameInDocument());
return App::DocumentObject::StdReturn;
}
const std::vector<std::string> &subElements = References2D.getSubValues();
if ( Type.isValue("Distance") ||
Type.isValue("DistanceX") ||
Type.isValue("DistanceY") ) {
if (getRefType() == oneEdge) {
m_linearPoints = getPointsOneEdge();
}else if (getRefType() == twoEdge) {
m_linearPoints = getPointsTwoEdges();
} else if (getRefType() == twoVertex) {
m_linearPoints = getPointsTwoVerts();
} else if (getRefType() == vertexEdge) {
m_linearPoints = getPointsEdgeVert();
} //else tarfu
} else if(Type.isValue("Radius")){
int idx = DrawUtil::getIndexFromName(subElements[0]);
TechDrawGeometry::BaseGeom* base = getViewPart()->getProjEdgeByIndex(idx);
TechDrawGeometry::Circle* circle;
arcPoints pts;
if( (base && base->geomType == TechDrawGeometry::GeomType::CIRCLE) ||
(base && base->geomType == TechDrawGeometry::GeomType::ARCOFCIRCLE)) {
circle = static_cast<TechDrawGeometry::Circle*> (base);
pts.center = Base::Vector3d(circle->center.x,circle->center.y,0.0);
pts.radius = circle->radius;
if (base->geomType == TechDrawGeometry::GeomType::ARCOFCIRCLE) {
TechDrawGeometry::AOC* aoc = static_cast<TechDrawGeometry::AOC*> (circle);
pts.isArc = true;
pts.onCurve.first = Base::Vector3d(aoc->midPnt.x,aoc->midPnt.y,0.0);
pts.midArc = Base::Vector3d(aoc->midPnt.x,aoc->midPnt.y,0.0);
pts.arcEnds.first = Base::Vector3d(aoc->startPnt.x,aoc->startPnt.y,0.0);
pts.arcEnds.second = Base::Vector3d(aoc->endPnt.x,aoc->endPnt.y,0.0);
pts.arcCW = aoc->cw;
} else {
pts.isArc = false;
pts.onCurve.first = pts.center + Base::Vector3d(1,0,0) * circle->radius; //arbitrary point on edge
pts.onCurve.second = pts.center + Base::Vector3d(-1,0,0) * circle->radius; //arbitrary point on edge
}
} else {
Base::Console().Log("Error: DVD - %s - 2D references are corrupt\n",getNameInDocument());
return App::DocumentObject::StdReturn;
}
m_arcPoints = pts;
} else if(Type.isValue("Diameter")){
int idx = DrawUtil::getIndexFromName(subElements[0]);
TechDrawGeometry::BaseGeom* base = getViewPart()->getProjEdgeByIndex(idx);
TechDrawGeometry::Circle* circle;
arcPoints pts;
if ((base && base->geomType == TechDrawGeometry::GeomType::CIRCLE) ||
(base && base->geomType == TechDrawGeometry::GeomType::ARCOFCIRCLE)) {
circle = static_cast<TechDrawGeometry::Circle*> (base);
pts.center = Base::Vector3d(circle->center.x,circle->center.y,0.0);
pts.center = Base::Vector3d(circle->center.x,circle->center.y,0.0);
pts.radius = circle->radius;
if (base->geomType == TechDrawGeometry::GeomType::ARCOFCIRCLE) {
TechDrawGeometry::AOC* aoc = static_cast<TechDrawGeometry::AOC*> (circle);
pts.isArc = true;
pts.onCurve.first = Base::Vector3d(aoc->midPnt.x,aoc->midPnt.y,0.0);
pts.midArc = Base::Vector3d(aoc->midPnt.x,aoc->midPnt.y,0.0);
pts.arcEnds.first = Base::Vector3d(aoc->startPnt.x,aoc->startPnt.y,0.0);
pts.arcEnds.second = Base::Vector3d(aoc->endPnt.x,aoc->endPnt.y,0.0);
pts.arcCW = aoc->cw;
} else {
pts.isArc = false;
pts.onCurve.first = pts.center + Base::Vector3d(1,0,0) * circle->radius; //arbitrary point on edge
pts.onCurve.second = pts.center + Base::Vector3d(-1,0,0) * circle->radius; //arbitrary point on edge
}
} else {
Base::Console().Log("Error: DVD - %s - 2D references are corrupt\n",getNameInDocument());
return App::DocumentObject::StdReturn;
}
m_arcPoints = pts;
} else if(Type.isValue("Angle")){
//TODO: do we need to distinguish inner vs outer angle? -wf
if (getRefType() != twoEdge) {
Base::Console().Log("Error: DVD - %s - 2D references are corrupt\n",getNameInDocument());
return App::DocumentObject::StdReturn;
}
int idx0 = DrawUtil::getIndexFromName(subElements[0]);
int idx1 = DrawUtil::getIndexFromName(subElements[1]);
TechDrawGeometry::BaseGeom* edge0 = getViewPart()->getProjEdgeByIndex(idx0);
TechDrawGeometry::BaseGeom* edge1 = getViewPart()->getProjEdgeByIndex(idx1);
TechDrawGeometry::Generic *gen0;
TechDrawGeometry::Generic *gen1;
if (edge0 && edge0->geomType == TechDrawGeometry::GeomType::GENERIC) {
gen0 = static_cast<TechDrawGeometry::Generic*>(edge0);
} else {
Base::Console().Log("Error: DVD - %s - 2D references are corrupt\n",getNameInDocument());
return App::DocumentObject::StdReturn;
}
if (edge1 && edge1->geomType == TechDrawGeometry::GeomType::GENERIC) {
gen1 = static_cast<TechDrawGeometry::Generic*>(edge1);
} else {
Base::Console().Log("Error: DVD - %s - 2D references are corrupt\n",getNameInDocument());
return App::DocumentObject::StdReturn;
}
anglePoints pts;
Base::Vector3d apex = DrawUtil::vector23(gen0->apparentInter(gen1));
Base::Vector3d extPoint0,extPoint1;
if ((DrawUtil::vector23(gen0->getStartPoint()) - apex).Length() >
(DrawUtil::vector23(gen0->getEndPoint()) - apex).Length()) {
extPoint0 = DrawUtil::vector23(gen0->getStartPoint());
} else {
extPoint0 = DrawUtil::vector23(gen0->getEndPoint());
}
if ((DrawUtil::vector23(gen1->getStartPoint()) - apex).Length() >
(DrawUtil::vector23(gen1->getEndPoint()) - apex).Length()) {
extPoint1 = DrawUtil::vector23(gen1->getStartPoint());
} else {
extPoint1 = DrawUtil::vector23(gen1->getEndPoint());
}
pts.ends.first = extPoint0;
pts.ends.second = extPoint1;
pts.vertex = apex;
m_anglePoints = pts;
}
//TODO: if MeasureType = Projected and the Projected shape changes, the Dimension may become invalid (see tilted Cube example)
requestPaint();
return App::DocumentObject::execute();;
return App::DocumentObject::execute();
}
std::string DrawViewDimension::getFormatedValue()
@@ -293,224 +437,117 @@ double DrawViewDimension::getDimValue()
}
} else {
// Projected Values
const std::vector<App::DocumentObject*> &objects = References2D.getValues();
const std::vector<std::string> &subElements = References2D.getSubValues();
if (!checkReferences2D()) {
Base::Console().Log("Error: DVD - %s - 2D references are corrupt\n",getNameInDocument());
References2D.setValue(nullptr,"");
return result;
}
if ( Type.isValue("Distance") ||
Type.isValue("DistanceX") ||
Type.isValue("DistanceY") ) {
if (getRefType() == oneEdge) {
//TODO: Check for straight line Edge?
int idx = DrawUtil::getIndexFromName(subElements[0]);
TechDrawGeometry::BaseGeom* geom = getViewPart()->getProjEdgeByIndex(idx);
TechDrawGeometry::Generic* gen;
if (geom && geom->geomType == TechDrawGeometry::GeomType::GENERIC) {
gen = static_cast<TechDrawGeometry::Generic*>(geom);
} else {
Base::Console().Log("Error: DVD - %s - 2D references are corrupt\n",getNameInDocument());
References2D.setValue(nullptr,"");
return result;
}
Base::Vector2d start = gen->points[0];
Base::Vector2d end = gen->points[1];
Base::Vector2d line = end - start;
if (Type.isValue("Distance")) {
result = line.Length() / getViewPart()->getScale();
} else if (Type.isValue("DistanceX")) {
return fabs(line.x) / getViewPart()->getScale();
} else {
result = fabs(line.y) / getViewPart()->getScale();
}
}else if (getRefType() == twoEdge) {
//only works for straight line edges
int idx0 = DrawUtil::getIndexFromName(subElements[0]);
int idx1 = DrawUtil::getIndexFromName(subElements[1]);
TechDrawGeometry::BaseGeom* geom0 = getViewPart()->getProjEdgeByIndex(idx0);
TechDrawGeometry::Generic* gen0;
if (geom0 && geom0->geomType == TechDrawGeometry::GeomType::GENERIC) {
gen0 = static_cast<TechDrawGeometry::Generic*>(geom0);
} else {
Base::Console().Log("Error: DVD - %s - 2D references are corrupt\n",getNameInDocument());
References2D.setValue(nullptr,"");
return result;
}
TechDrawGeometry::BaseGeom* geom1 = getViewPart()->getProjEdgeByIndex(idx1);
TechDrawGeometry::Generic* gen1;
if (geom1 && geom1->geomType == TechDrawGeometry::GeomType::GENERIC) {
gen1 = static_cast<TechDrawGeometry::Generic*>(geom1);
} else {
Base::Console().Log("Error: DVD - %s - 2D references are corrupt\n",getNameInDocument());
References2D.setValue(nullptr,"");
return result;
}
Base::Vector2d s0 = gen0->points[0];
Base::Vector2d e0 = gen0->points[1];
Base::Vector2d s1 = gen1->points[0];
Base::Vector2d e1 = gen1->points[1];
if (Type.isValue("Distance")) {
result = dist2Segs(s0,e0,s1,e1) / getViewPart()->getScale();
} else if (Type.isValue("DistanceX")) {
Base::Vector2d p1 = geom0->nearPoint(geom1);
Base::Vector2d p2 = geom1->nearPoint(geom0);
result = fabs(p1.x - p2.x) / getViewPart()->getScale();
} else if (Type.isValue("DistanceY")) {
Base::Vector2d p1 = geom0->nearPoint(geom1);
Base::Vector2d p2 = geom1->nearPoint(geom0);
result = fabs(p1.y - p2.y) / getViewPart()->getScale();
}
} else if (getRefType() == twoVertex) {
int idx0 = DrawUtil::getIndexFromName(subElements[0]);
int idx1 = DrawUtil::getIndexFromName(subElements[1]);
TechDrawGeometry::Vertex* v0 = getViewPart()->getProjVertexByIndex(idx0);
TechDrawGeometry::Vertex* v1 = getViewPart()->getProjVertexByIndex(idx1);
if ((v0 == nullptr) ||
(v1 == nullptr) ) {
Base::Console().Error("Error: DVD - %s - 2D references are corrupt\n",getNameInDocument());
References2D.setValue(nullptr,"");
return result;
}
Base::Vector2d start = v0->pnt; //v0 != nullptr, but v0->pnt is invalid
Base::Vector2d end = v1->pnt;
Base::Vector2d line = end - start;
if (Type.isValue("Distance")) {
result = line.Length() / getViewPart()->getScale();
} else if (Type.isValue("DistanceX")) {
result = fabs(line.x) / getViewPart()->getScale();
} else {
result = fabs(line.y) / getViewPart()->getScale();
}
} else if (getRefType() == vertexEdge) {
int idx0 = DrawUtil::getIndexFromName(subElements[0]);
int idx1 = DrawUtil::getIndexFromName(subElements[1]);
TechDrawGeometry::BaseGeom* e;
TechDrawGeometry::Vertex* v;
if (DrawUtil::getGeomTypeFromName(subElements[0]) == "Edge") {
e = getViewPart()->getProjEdgeByIndex(idx0);
v = getViewPart()->getProjVertexByIndex(idx1);
} else {
e = getViewPart()->getProjEdgeByIndex(idx1);
v = getViewPart()->getProjVertexByIndex(idx0);
}
if ((v == nullptr) ||
(e == nullptr) ) {
Base::Console().Log("Error: DVD - %s - 2D references are corrupt\n",getNameInDocument());
References2D.setValue(nullptr,"");
return result;
}
Base::Vector2d nearPoint = e->nearPoint(v->pnt);
Base::Vector2d line = nearPoint - v->pnt;
if (Type.isValue("Distance")) {
result = e->minDist(v->pnt) / getViewPart()->getScale();
} else if (Type.isValue("DistanceX")) {
result = fabs(line.x) / getViewPart()->getScale();
} else {
result = fabs(line.y) / getViewPart()->getScale();
}
} //else tarfu
pointPair pts = m_linearPoints;
Base::Vector3d dimVec = pts.first - pts.second;
if (Type.isValue("Distance")) {
result = dimVec.Length() / getViewPart()->getScale();
} else if (Type.isValue("DistanceX")) {
result = fabs(dimVec.x) / getViewPart()->getScale();
} else {
result = fabs(dimVec.y) / getViewPart()->getScale();
}
} else if(Type.isValue("Radius")){
//only 1 reference for a Radius
int idx = DrawUtil::getIndexFromName(subElements[0]);
TechDrawGeometry::BaseGeom* base = getViewPart()->getProjEdgeByIndex(idx);
TechDrawGeometry::Circle* circle;
if( (base && base->geomType == TechDrawGeometry::GeomType::CIRCLE) ||
(base && base->geomType == TechDrawGeometry::GeomType::ARCOFCIRCLE)) {
circle = static_cast<TechDrawGeometry::Circle*> (base);
} else {
Base::Console().Log("Error: DVD - %s - 2D references are corrupt\n",getNameInDocument());
References2D.setValue(nullptr,"");
return result;
}
result = circle->radius / getViewPart()->getScale(); //Projected BaseGeom is scaled for drawing
arcPoints pts = m_arcPoints;
result = pts.radius / getViewPart()->getScale(); //Projected BaseGeom is scaled for drawing
} else if(Type.isValue("Diameter")){
//only 1 reference for a Diameter
int idx = DrawUtil::getIndexFromName(subElements[0]);
TechDrawGeometry::BaseGeom* base = getViewPart()->getProjEdgeByIndex(idx);
TechDrawGeometry::Circle* circle;
if ((base && base->geomType == TechDrawGeometry::GeomType::CIRCLE) ||
(base && base->geomType == TechDrawGeometry::GeomType::ARCOFCIRCLE)) {
circle = static_cast<TechDrawGeometry::Circle*> (base);
} else {
return result;
}
result = (circle->radius * 2.0) / getViewPart()->getScale(); //Projected BaseGeom is scaled for drawing
arcPoints pts = m_arcPoints;
result = (pts.radius * 2.0) / getViewPart()->getScale(); //Projected BaseGeom is scaled for drawing
} else if(Type.isValue("Angle")){
// Must project lines to 2D so cannot use measurement framework this time
//Relcalculate the measurement based on references stored.
//WF: why not use projected geom in GeomObject and Vector2d.GetAngle? intersection pt & direction issues?
//TODO: do we need to distinguish inner vs outer angle? -wf
if (getRefType() != twoEdge) {
Base::Console().Log("Error: DVD - %s - 2D references are corrupt\n",getNameInDocument());
References2D.setValue(nullptr,"");
return result;
}
int idx0 = DrawUtil::getIndexFromName(subElements[0]);
int idx1 = DrawUtil::getIndexFromName(subElements[1]);
auto viewPart( dynamic_cast<TechDraw::DrawViewPart *>(objects[0]) );
if( viewPart == nullptr ) {
Base::Console().Log("INFO - DVD::getDimValue - References2D not DrawViewPart\n");
return result;
}
TechDrawGeometry::BaseGeom* edge0 = viewPart->getProjEdgeByIndex(idx0);
TechDrawGeometry::BaseGeom* edge1 = viewPart->getProjEdgeByIndex(idx1);
TechDrawGeometry::Generic *gen1;
TechDrawGeometry::Generic *gen2;
if (edge0 && edge0->geomType == TechDrawGeometry::GeomType::GENERIC) {
gen1 = static_cast<TechDrawGeometry::Generic*>(edge0);
} else {
Base::Console().Log("Error: DVD - %s - 2D references are corrupt\n",getNameInDocument());
References2D.setValue(nullptr,"");
return result;
}
if (edge1 && edge1->geomType == TechDrawGeometry::GeomType::GENERIC) {
gen2 = static_cast<TechDrawGeometry::Generic*>(edge1);
} else {
Base::Console().Log("Error: DVD - %s - 2D references are corrupt\n",getNameInDocument());
References2D.setValue(nullptr,"");
return result;
}
anglePoints pts = m_anglePoints;
Base::Vector3d vertex = pts.vertex;
Base::Vector3d leg0 = pts.ends.first - vertex;
Base::Vector3d leg1 = pts.ends.second - vertex;
double legAngle = leg0.GetAngle(leg1) * 180.0 / M_PI;
result = legAngle;
}
}
return result;
}
Base::Vector3d p1S(gen1->points.at(0).x, gen1->points.at(0).y, 0.);
Base::Vector3d p1E(gen1->points.at(1).x, gen1->points.at(1).y, 0.);
pointPair DrawViewDimension::getPointsOneEdge()
{
pointPair result;
const std::vector<std::string> &subElements = References2D.getSubValues();
Base::Vector3d p2S(gen2->points.at(0).x, gen2->points.at(0).y, 0.);
Base::Vector3d p2E(gen2->points.at(1).x, gen2->points.at(1).y, 0.);
//TODO: Check for straight line Edge?
int idx = DrawUtil::getIndexFromName(subElements[0]);
TechDrawGeometry::BaseGeom* geom = getViewPart()->getProjEdgeByIndex(idx);
TechDrawGeometry::Generic* gen;
if (geom && geom->geomType == TechDrawGeometry::GeomType::GENERIC) {
gen = static_cast<TechDrawGeometry::Generic*>(geom);
} else {
Base::Console().Log("Error: DVD - %s - 2D references are corrupt\n",getNameInDocument());
return result;
}
result.first = DrawUtil::vector23(gen->points[0]);
result.second = DrawUtil::vector23(gen->points[1]);
return result;
}
Base::Vector3d dir1 = p1E - p1S;
Base::Vector3d dir2 = p2E - p2S;
pointPair DrawViewDimension::getPointsTwoEdges()
{
pointPair result;
const std::vector<std::string> &subElements = References2D.getSubValues();
// Line Intersetion (taken from ViewProviderSketch.cpp)
double det = dir1.x*dir2.y - dir1.y*dir2.x;
if ((det > 0 ? det : -det) < 1e-10)
throw Base::Exception("Invalid selection - Det = 0");
int idx0 = DrawUtil::getIndexFromName(subElements[0]);
int idx1 = DrawUtil::getIndexFromName(subElements[1]);
TechDrawGeometry::BaseGeom* geom0 = getViewPart()->getProjEdgeByIndex(idx0);
TechDrawGeometry::BaseGeom* geom1 = getViewPart()->getProjEdgeByIndex(idx1);
result = closestPoints(geom0->occEdge,geom1->occEdge);
return result;
}
double c1 = dir1.y*gen1->points.at(0).x - dir1.x*gen1->points.at(0).y;
double c2 = dir2.y*gen2->points.at(1).x - dir2.x*gen2->points.at(1).y;
double x = (dir1.x*c2 - dir2.x*c1)/det;
double y = (dir1.y*c2 - dir2.y*c1)/det;
pointPair DrawViewDimension::getPointsTwoVerts()
{
pointPair result;
const std::vector<std::string> &subElements = References2D.getSubValues();
// Intersection point
Base::Vector3d p0 = Base::Vector3d(x,y,0);
int idx0 = DrawUtil::getIndexFromName(subElements[0]);
int idx1 = DrawUtil::getIndexFromName(subElements[1]);
TechDrawGeometry::Vertex* v0 = getViewPart()->getProjVertexByIndex(idx0);
TechDrawGeometry::Vertex* v1 = getViewPart()->getProjVertexByIndex(idx1);
if ((v0 == nullptr) ||
(v1 == nullptr) ) {
Base::Console().Error("Error: DVD - %s - 2D references are corrupt\n",getNameInDocument());
return result;
}
result.first = DrawUtil::vector23(v0->pnt);
result.second = DrawUtil::vector23(v1->pnt);
return result;
}
Base::Vector3d lPos((double) X.getValue(), (double) Y.getValue(), 0.);
//Base::Vector3d delta = lPos - p0;
pointPair DrawViewDimension::getPointsEdgeVert()
{
pointPair result;
const std::vector<std::string> &subElements = References2D.getSubValues();
// Create vectors point towards intersection always
Base::Vector3d a = -p0, b = -p0;
a += ((p1S - p0).Length() < FLT_EPSILON) ? p1E : p1S;
b += ((p2S - p0).Length() < FLT_EPSILON) ? p2E : p2S;
double angle2 = atan2( a.x*b.y - a.y*b.x, a.x*b.x + a.y*b.y );
result = angle2 * 180. / M_PI;
} else {
throw Base::Exception("getDimValue() - Unknown Dimension Type (2)");
} //endif Angle
} //endif Projected
int idx0 = DrawUtil::getIndexFromName(subElements[0]);
int idx1 = DrawUtil::getIndexFromName(subElements[1]);
TechDrawGeometry::BaseGeom* e;
TechDrawGeometry::Vertex* v;
if (DrawUtil::getGeomTypeFromName(subElements[0]) == "Edge") {
e = getViewPart()->getProjEdgeByIndex(idx0);
v = getViewPart()->getProjVertexByIndex(idx1);
} else {
e = getViewPart()->getProjEdgeByIndex(idx1);
v = getViewPart()->getProjVertexByIndex(idx0);
}
if ((v == nullptr) ||
(e == nullptr) ) {
Base::Console().Log("Error: DVD - %s - 2D references are corrupt\n",getNameInDocument());
return result;
}
result = closestPoints(e->occEdge,v->occVertex);
return result;
}
@@ -591,6 +628,24 @@ bool DrawViewDimension::checkReferences2D() const
return result;
}
pointPair DrawViewDimension::closestPoints(TopoDS_Shape s1,
TopoDS_Shape s2) const
{
pointPair result;
BRepExtrema_DistShapeShape extss(s1, s2);
if (!extss.IsDone()) {
throw Base::Exception("DVD::closestPoints - BRepExtrema_DistShapeShape failed");
}
int count = extss.NbSolution();
if (count != 0) {
gp_Pnt p = extss.PointOnShape1(1);
result.first = Base::Vector3d(p.X(),p.Y(),p.Z());
p = extss.PointOnShape2(1);
result.second = Base::Vector3d(p.X(),p.Y(),p.Z());
} //TODO: else { explode }
return result;
}
//!add Dimension 3D references to measurement
void DrawViewDimension::setAll3DMeasurement()
@@ -646,7 +701,7 @@ double DrawViewDimension::dist2Segs(Base::Vector2d s1,
BRepExtrema_DistShapeShape extss(edge1, edge2);
if (!extss.IsDone()) {
throw Base::Exception("DVD - BRepExtrema_DistShapeShape failed");
throw Base::Exception("DVD::dist2Segs - BRepExtrema_DistShapeShape failed");
}
int count = extss.NbSolution();
double minDist = 0.0;
@@ -657,6 +712,20 @@ double DrawViewDimension::dist2Segs(Base::Vector2d s1,
return minDist;
}
bool DrawViewDimension::leaderIntersectsArc(Base::Vector3d s, Base::Vector3d pointOnCircle) {
bool result = false;
const std::vector<std::string> &subElements = References2D.getSubValues();
int idx = DrawUtil::getIndexFromName(subElements[0]);
TechDrawGeometry::BaseGeom* base = getViewPart()->getProjEdgeByIndex(idx);
if( base && base->geomType == TechDrawGeometry::GeomType::ARCOFCIRCLE ) {
TechDrawGeometry::AOC* aoc = static_cast<TechDrawGeometry::AOC*> (base);
if (aoc->intersectsArc(s,pointOnCircle)) {
result = true;
}
}
return result;
}
bool DrawViewDimension::has2DReferences(void) const
{
bool result = false;

34
src/Mod/TechDraw/App/DrawViewDimension.h
View File

@@ -30,6 +30,8 @@
#include "DrawView.h"
class TopoDS_Shape;
namespace Measure {
class Measurement;
}
@@ -42,7 +44,22 @@ struct DimRef {
std::string sub;
};
class DrawViewPart;
typedef std::pair<Base::Vector3d,Base::Vector3d> pointPair;
struct anglePoints {
pointPair ends;
Base::Vector3d vertex;
};
struct arcPoints {
bool isArc;
double radius;
Base::Vector3d center;
pointPair onCurve;
pointPair arcEnds;
Base::Vector3d midArc;
bool arcCW;
};
class TechDrawExport DrawViewDimension : public TechDraw::DrawView
{
@@ -86,6 +103,10 @@ public:
void setAll3DMeasurement();
void clear3DMeasurements(void);
bool checkReferences2D(void) const;
pointPair getLinearPoints(void) {return m_linearPoints; }
arcPoints getArcPoints(void) {return m_arcPoints; }
anglePoints getAnglePoints(void) {return m_anglePoints; }
bool leaderIntersectsArc(Base::Vector3d s, Base::Vector3d pointOnCircle);
protected:
void onChanged(const App::Property* prop);
@@ -94,6 +115,10 @@ protected:
bool useDecimals() const;
std::string getPrefix() const;
std::string getDefaultFormatSpec() const;
pointPair getPointsOneEdge();
pointPair getPointsTwoEdges();
pointPair getPointsTwoVerts();
pointPair getPointsEdgeVert();
protected:
Measure::Measurement *measurement;
@@ -101,10 +126,17 @@ protected:
Base::Vector2d e1,
Base::Vector2d s2,
Base::Vector2d e2) const;
pointPair closestPoints(TopoDS_Shape s1,
TopoDS_Shape s2) const;
private:
static const char* TypeEnums[];
static const char* MeasureTypeEnums[];
void dumpRefs2D(char* text) const;
//Dimension "geometry"
pointPair m_linearPoints;
arcPoints m_arcPoints;
anglePoints m_anglePoints;
};
} //namespace TechDraw

20
src/Mod/TechDraw/App/DrawViewDimensionPy.xml
View File

@@ -13,6 +13,26 @@
<Author Licence="LGPL" Name="WandererFan" EMail="wandererfan@gmail.com" />
<UserDocu>Feature for creating and manipulating Technical Drawing Dimensions</UserDocu>
</Documentation>
<Methode Name="getText">
<Documentation>
<UserDocu>getText() - returns Dimension text.</UserDocu>
</Documentation>
</Methode>
<Methode Name="getLinearPoints">
<Documentation>
<UserDocu>getLinearPoints() - returns list of points for linear Dimension</UserDocu>
</Documentation>
</Methode>
<Methode Name="getArcPoints">
<Documentation>
<UserDocu>getArcPoints() - returns list of points for circle/arc Dimension</UserDocu>
</Documentation>
</Methode>
<Methode Name="getAnglePoints">
<Documentation>
<UserDocu>getAnglePoints() - returns list of points for angle Dimension</UserDocu>
</Documentation>
</Methode>
<CustomAttributes />
</PythonExport>
</GenerateModel>

83
src/Mod/TechDraw/App/DrawViewDimensionPyImp.cpp
View File

@@ -1,9 +1,37 @@
/***************************************************************************
* Copyright (c) WandererFan (wandererfan@gmail.com) 2018 *
* *
* 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 *
* *
***************************************************************************/
#include "PreCompiled.h"
#ifndef _PreComp_
#endif
#include <Base/Console.h>
#include <Base/PyObjectBase.h>
#include <Base/Vector3D.h>
#include "DrawViewDimension.h"
// inclusion of the generated files (generated out of DrawViewDimensionPy.xml)
#include <Base/VectorPy.h>
#include <Mod/TechDraw/App/DrawViewDimensionPy.h>
#include <Mod/TechDraw/App/DrawViewDimensionPy.cpp>
@@ -14,7 +42,62 @@ std::string DrawViewDimensionPy::representation(void) const
{
return std::string("<DrawViewDimension object>");
}
PyObject* DrawViewDimensionPy::getText(PyObject* args)
{
(void) args;
// PyObject* asShape = Py_False;
// PyObject* pagePos = Py_False;
// if (!PyArg_ParseTuple(args, "|OO", &asShape, &pagePos)) {
// return 0;
// }
DrawViewDimension* dvd = getDrawViewDimensionPtr();
std::string textString = dvd->getFormatedValue();
//TODO: check multiversion code!
#if PY_MAJOR_VERSION >= 3
PyObject* pyText = Base::PyAsUnicodeObject(textString);
#else
PyObject *pyText = PyString_FromString(textString.c_str());
#endif
return pyText;
}
PyObject* DrawViewDimensionPy::getLinearPoints(PyObject* args)
{
(void) args;
DrawViewDimension* dvd = getDrawViewDimensionPtr();
pointPair pts = dvd->getLinearPoints();
PyObject* ret = PyList_New(0);
PyList_Append(ret,new Base::VectorPy(new Base::Vector3d(pts.first)));
PyList_Append(ret,new Base::VectorPy(new Base::Vector3d(pts.second)));
return ret;
}
PyObject* DrawViewDimensionPy::getArcPoints(PyObject* args)
{
(void) args;
DrawViewDimension* dvd = getDrawViewDimensionPtr();
arcPoints pts = dvd->getArcPoints();
PyObject* ret = PyList_New(0);
PyList_Append(ret,new Base::VectorPy(new Base::Vector3d(pts.center)));
PyList_Append(ret,new Base::VectorPy(new Base::Vector3d(pts.onCurve.first)));
PyList_Append(ret,new Base::VectorPy(new Base::Vector3d(pts.onCurve.second)));
PyList_Append(ret,new Base::VectorPy(new Base::Vector3d(pts.arcEnds.first)));
PyList_Append(ret,new Base::VectorPy(new Base::Vector3d(pts.arcEnds.second)));
PyList_Append(ret,new Base::VectorPy(new Base::Vector3d(pts.midArc)));
return ret;
}
PyObject* DrawViewDimensionPy::getAnglePoints(PyObject* args)
{
(void) args;
DrawViewDimension* dvd = getDrawViewDimensionPtr();
anglePoints pts = dvd->getAnglePoints();
PyObject* ret = PyList_New(0);
PyList_Append(ret,new Base::VectorPy(new Base::Vector3d(pts.ends.first)));
PyList_Append(ret,new Base::VectorPy(new Base::Vector3d(pts.ends.second)));
PyList_Append(ret,new Base::VectorPy(new Base::Vector3d(pts.vertex)));
return ret;
}
PyObject *DrawViewDimensionPy::getCustomAttributes(const char* /*attr*/) const
{