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

Remove magic number and hard type enums in Geometry.h

Browse Source 
- Remove currently present magic numbers
- Hard type enums, so magic numbers can no longer be introduced. We don't want people to introduce magic numbers.
This commit is contained in:
Benjamin Bræstrup Sayoc
2025-01-30 01:38:44 +01:00
committed by WandererFan
parent 033817f5fe
commit 97b34f9c57
19 changed files with 198 additions and 210 deletions
Download Patch File Download Diff File Expand all files Collapse all files

26
src/Mod/TechDraw/App/CenterLine.cpp
View File

@@ -136,10 +136,10 @@ CenterLine::~CenterLine()
void CenterLine::initialize()
{
m_geometry->setClassOfEdge(ecHARD);
m_geometry->setClassOfEdge(EdgeClass::HARD);
m_geometry->setHlrVisible( true);
m_geometry->setCosmetic(true);
m_geometry->source(CENTERLINE);
m_geometry->source(SourceType::CENTERLINE);
createNewTag();
m_geometry->setCosmeticTag(getTagAsString());
@@ -268,10 +268,10 @@ TechDraw::BaseGeomPtr CenterLine::scaledGeometry(const TechDraw::DrawViewPart* p
TopoDS_Shape s = ShapeUtils::scaleShape(e, scale);
TopoDS_Edge newEdge = TopoDS::Edge(s);
TechDraw::BaseGeomPtr newGeom = TechDraw::BaseGeom::baseFactory(newEdge);
newGeom->setClassOfEdge(ecHARD);
newGeom->setClassOfEdge(EdgeClass::HARD);
newGeom->setHlrVisible( true);
newGeom->setCosmetic(true);
newGeom->source(CENTERLINE);
newGeom->source(SourceType::CENTERLINE);
newGeom->setCosmeticTag(getTagAsString());
return newGeom;
@@ -346,10 +346,10 @@ TechDraw::BaseGeomPtr CenterLine::scaledAndRotatedGeometry(TechDraw::DrawViewPar
if (!newGeom) {
throw Base::RuntimeError("Failed to create center line");
}
newGeom->setClassOfEdge(ecHARD);
newGeom->setClassOfEdge(EdgeClass::HARD);
newGeom->setHlrVisible( true);
newGeom->setCosmetic(true);
newGeom->source(CENTERLINE);
newGeom->source(SourceType::CENTERLINE);
newGeom->setCosmeticTag(getTagAsString());
return newGeom;
@@ -900,13 +900,13 @@ void CenterLine::Save(Base::Writer &writer) const
}
writer.Stream() << writer.ind() << "<GeometryType value=\"" << m_geometry->getGeomType() <<"\"/>" << std::endl;
if (m_geometry->getGeomType() == TechDraw::GeomType::GENERIC) {
if (m_geometry->getGeomType() == GeomType::GENERIC) {
GenericPtr gen = std::static_pointer_cast<Generic>(m_geometry);
gen->Save(writer);
} else if (m_geometry->getGeomType() == TechDraw::GeomType::CIRCLE) {
} else if (m_geometry->getGeomType() == GeomType::CIRCLE) {
TechDraw::CirclePtr circ = std::static_pointer_cast<TechDraw::Circle>(m_geometry);
circ->Save(writer);
} else if (m_geometry->getGeomType() == TechDraw::GeomType::ARCOFCIRCLE) {
} else if (m_geometry->getGeomType() == GeomType::ARCOFCIRCLE) {
TechDraw::AOCPtr aoc = std::static_pointer_cast<TechDraw::AOC>(m_geometry);
aoc->Save(writer);
} else {
@@ -1000,18 +1000,18 @@ void CenterLine::Restore(Base::XMLReader &reader)
//stored geometry
reader.readElement("GeometryType");
TechDraw::GeomType gType = static_cast<TechDraw::GeomType>(reader.getAttributeAsInteger("value"));
if (gType == TechDraw::GeomType::GENERIC) {
GeomType gType = static_cast<GeomType>(reader.getAttributeAsInteger("value"));
if (gType == GeomType::GENERIC) {
TechDraw::GenericPtr gen = std::make_shared<TechDraw::Generic> ();
gen->Restore(reader);
gen->setOCCEdge(GeometryUtils::edgeFromGeneric(gen));
m_geometry = gen;
} else if (gType == TechDraw::GeomType::CIRCLE) {
} else if (gType == GeomType::CIRCLE) {
TechDraw::CirclePtr circ = std::make_shared<TechDraw::Circle> ();
circ->Restore(reader);
circ->setOCCEdge(GeometryUtils::edgeFromCircle(circ));
m_geometry = circ;
} else if (gType == TechDraw::GeomType::ARCOFCIRCLE) {
} else if (gType == GeomType::ARCOFCIRCLE) {
TechDraw::AOCPtr aoc = std::make_shared<TechDraw::AOC> ();
aoc->Restore(reader);
aoc->setOCCEdge(GeometryUtils::edgeFromCircleArc(aoc));

36
src/Mod/TechDraw/App/Cosmetic.cpp
View File

@@ -46,10 +46,6 @@ using namespace TechDraw;
using namespace std;
using DU = DrawUtil;
#define GEOMETRYEDGE 0
#define COSMETICEDGE 1
#define CENTERLINE 2
TYPESYSTEM_SOURCE(TechDraw::CosmeticEdge, Base::Persistence)
//note this ctor has no occEdge or first/last point for geometry!
@@ -89,13 +85,13 @@ CosmeticEdge::CosmeticEdge(const TechDraw::BaseGeomPtr g)
//we assume input edge is already in Yinverted coordinates
permaStart = m_geometry->getStartPoint();
permaEnd = m_geometry->getEndPoint();
if ((g->getGeomType() == TechDraw::GeomType::CIRCLE) ||
(g->getGeomType() == TechDraw::GeomType::ARCOFCIRCLE)) {
if ((g->getGeomType() == GeomType::CIRCLE) ||
(g->getGeomType() == GeomType::ARCOFCIRCLE)) {
TechDraw::CirclePtr circ = std::static_pointer_cast<TechDraw::Circle>(g);
permaStart = circ->center;
permaEnd = circ->center;
permaRadius = circ->radius;
if (g->getGeomType() == TechDraw::GeomType::ARCOFCIRCLE) {
if (g->getGeomType() == GeomType::ARCOFCIRCLE) {
TechDraw::AOCPtr aoc = std::static_pointer_cast<TechDraw::AOC>(circ);
aoc->clockwiseAngle(g->clockwiseAngle());
aoc->startPnt = g->getStartPoint();
@@ -115,10 +111,10 @@ CosmeticEdge::~CosmeticEdge()
void CosmeticEdge::initialize()
{
m_geometry->setClassOfEdge(ecHARD);
m_geometry->setClassOfEdge(EdgeClass::HARD);
m_geometry->setHlrVisible( true);
m_geometry->setCosmetic(true);
m_geometry->source(COSMETICEDGE);
m_geometry->source(SourceType::COSMETICEDGE);
createNewTag();
m_geometry->setCosmeticTag(getTagAsString());
@@ -137,10 +133,10 @@ TechDraw::BaseGeomPtr CosmeticEdge::scaledGeometry(const double scale)
TopoDS_Shape s = ShapeUtils::scaleShape(e, scale);
TopoDS_Edge newEdge = TopoDS::Edge(s);
TechDraw::BaseGeomPtr newGeom = TechDraw::BaseGeom::baseFactory(newEdge);
newGeom->setClassOfEdge(ecHARD);
newGeom->setClassOfEdge(EdgeClass::HARD);
newGeom->setHlrVisible( true);
newGeom->setCosmetic(true);
newGeom->source(COSMETICEDGE);
newGeom->source(SourceType::COSMETICEDGE);
newGeom->setCosmeticTag(getTagAsString());
return newGeom;
}
@@ -156,10 +152,10 @@ TechDraw::BaseGeomPtr CosmeticEdge::scaledAndRotatedGeometry(const double scale,
s = ShapeUtils::mirrorShape(s);
TopoDS_Edge newEdge = TopoDS::Edge(s);
TechDraw::BaseGeomPtr newGeom = TechDraw::BaseGeom::baseFactory(newEdge);
newGeom->setClassOfEdge(ecHARD);
newGeom->setClassOfEdge(EdgeClass::HARD);
newGeom->setHlrVisible( true);
newGeom->setCosmetic(true);
newGeom->source(COSMETICEDGE);
newGeom->source(SourceType::COSMETICEDGE);
newGeom->setCosmeticTag(getTagAsString());
newGeom->clockwiseAngle(saveCW);
return newGeom;
@@ -223,13 +219,13 @@ void CosmeticEdge::Save(Base::Writer &writer) const
writer.Stream() << writer.ind() << "<Visible value=\"" << v << "\"/>" << endl;
writer.Stream() << writer.ind() << "<GeometryType value=\"" << m_geometry->getGeomType() <<"\"/>" << endl;
if (m_geometry->getGeomType() == TechDraw::GeomType::GENERIC) {
if (m_geometry->getGeomType() == GeomType::GENERIC) {
GenericPtr gen = std::static_pointer_cast<Generic>(m_geometry);
gen->Save(writer);
} else if (m_geometry->getGeomType() == TechDraw::GeomType::CIRCLE) {
} else if (m_geometry->getGeomType() == GeomType::CIRCLE) {
TechDraw::CirclePtr circ = std::static_pointer_cast<TechDraw::Circle>(m_geometry);
circ->Save(writer);
} else if (m_geometry->getGeomType() == TechDraw::GeomType::ARCOFCIRCLE) {
} else if (m_geometry->getGeomType() == GeomType::ARCOFCIRCLE) {
TechDraw::AOCPtr aoc = std::static_pointer_cast<TechDraw::AOC>(m_geometry);
aoc->inverted()->Save(writer);
} else {
@@ -259,16 +255,16 @@ void CosmeticEdge::Restore(Base::XMLReader &reader)
m_format.setVisible(reader.getAttributeAsInteger("value") != 0);
reader.readElement("GeometryType");
TechDraw::GeomType gType = static_cast<TechDraw::GeomType>(reader.getAttributeAsInteger("value"));
GeomType gType = static_cast<GeomType>(reader.getAttributeAsInteger("value"));
if (gType == TechDraw::GeomType::GENERIC) {
if (gType == GeomType::GENERIC) {
TechDraw::GenericPtr gen = std::make_shared<TechDraw::Generic> ();
gen->Restore(reader);
gen->setOCCEdge(GeometryUtils::edgeFromGeneric(gen));
m_geometry = gen;
permaStart = gen->getStartPoint();
permaEnd = gen->getEndPoint();
} else if (gType == TechDraw::GeomType::CIRCLE) {
} else if (gType == GeomType::CIRCLE) {
TechDraw::CirclePtr circ = std::make_shared<TechDraw::Circle> ();
circ->Restore(reader);
circ->setOCCEdge(GeometryUtils::edgeFromCircle(circ));
@@ -276,7 +272,7 @@ void CosmeticEdge::Restore(Base::XMLReader &reader)
permaRadius = circ->radius;
permaStart = circ->center;
permaEnd = circ->center;
} else if (gType == TechDraw::GeomType::ARCOFCIRCLE) {
} else if (gType == GeomType::ARCOFCIRCLE) {
TechDraw::AOCPtr aoc = std::make_shared<TechDraw::AOC> ();
aoc->Restore(reader);
aoc->setOCCEdge(GeometryUtils::edgeFromCircleArc(aoc));

24
src/Mod/TechDraw/App/CosmeticEdgePyImp.cpp
View File

@@ -231,9 +231,9 @@ void CosmeticEdgePy::setEnd(Py::Vector arg)
Py::Float CosmeticEdgePy::getRadius() const
{
TechDraw::GeomType gt = getCosmeticEdgePtr()->m_geometry->getGeomType();
if ( (gt != TechDraw::GeomType::CIRCLE) &&
(gt != TechDraw::GeomType::ARCOFCIRCLE) ) {
GeomType gt = getCosmeticEdgePtr()->m_geometry->getGeomType();
if ( (gt != GeomType::CIRCLE) &&
(gt != GeomType::ARCOFCIRCLE) ) {
throw Py::TypeError("Not a circle. Can not get radius");
}
double r = getCosmeticEdgePtr()->permaRadius;
@@ -242,9 +242,9 @@ Py::Float CosmeticEdgePy::getRadius() const
void CosmeticEdgePy::setRadius(Py::Float arg)
{
TechDraw::GeomType gt = getCosmeticEdgePtr()->m_geometry->getGeomType();
if ( (gt != TechDraw::GeomType::CIRCLE) &&
(gt != TechDraw::GeomType::ARCOFCIRCLE) ) {
GeomType gt = getCosmeticEdgePtr()->m_geometry->getGeomType();
if ( (gt != GeomType::CIRCLE) &&
(gt != GeomType::ARCOFCIRCLE) ) {
throw Py::TypeError("Not a circle. Can not set radius");
}
@@ -258,9 +258,9 @@ void CosmeticEdgePy::setRadius(Py::Float arg)
Py::Vector CosmeticEdgePy::getCenter() const
{
TechDraw::GeomType gt = getCosmeticEdgePtr()->m_geometry->getGeomType();
if ( (gt != TechDraw::GeomType::CIRCLE) &&
(gt != TechDraw::GeomType::ARCOFCIRCLE) ) {
GeomType gt = getCosmeticEdgePtr()->m_geometry->getGeomType();
if ( (gt != GeomType::CIRCLE) &&
(gt != GeomType::ARCOFCIRCLE) ) {
throw Py::TypeError("Not a circle. Can not get center");
}
Base::Vector3d point = getCosmeticEdgePtr()->permaStart;
@@ -270,10 +270,10 @@ Py::Vector CosmeticEdgePy::getCenter() const
void CosmeticEdgePy::setCenter(Py::Vector arg)
{
TechDraw::GeomType gt = getCosmeticEdgePtr()->m_geometry->getGeomType();
GeomType gt = getCosmeticEdgePtr()->m_geometry->getGeomType();
// PyObject* p = arg.ptr();
if ( (gt != TechDraw::GeomType::CIRCLE) &&
(gt != TechDraw::GeomType::ARCOFCIRCLE) ) {
if ( (gt != GeomType::CIRCLE) &&
(gt != GeomType::ARCOFCIRCLE) ) {
throw Py::TypeError("Not a circle. Can not set center");
}

2
src/Mod/TechDraw/App/CosmeticExtension.cpp
View File

@@ -328,7 +328,7 @@ void CosmeticExtension::refreshCEGeoms()
std::vector<TechDraw::BaseGeomPtr> gEdges = getOwner()->getEdgeGeometry();
std::vector<TechDraw::BaseGeomPtr> oldGEdges;
for (auto& ge : gEdges) {
if (ge->source() != SourceType::COSEDGE) {
if (ge->source() != SourceType::COSMETICEDGE) {
oldGEdges.push_back(ge);
}
}

4
src/Mod/TechDraw/App/DrawUtil.cpp
View File

@@ -1859,7 +1859,7 @@ bool DrawUtil::isCosmeticEdge(App::DocumentObject* owner, std::string element)
{
auto ownerView = static_cast<TechDraw::DrawViewPart*>(owner);
auto edge = ownerView->getEdge(element);
if (edge && edge->source() == 1 && edge->getCosmetic()) {
if (edge && edge->source() == SourceType::COSMETICEDGE && edge->getCosmetic()) {
return true;
}
return false;
@@ -1870,7 +1870,7 @@ bool DrawUtil::isCenterLine(App::DocumentObject* owner, std::string element)
{
auto ownerView = static_cast<TechDraw::DrawViewPart*>(owner);
auto edge = ownerView->getEdge(element);
if (edge && edge->source() == 2 && edge->getCosmetic()) {
if (edge && edge->source() == SourceType::CENTERLINE && edge->getCosmetic()) {
return true;
}
return false;

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

@@ -821,7 +821,7 @@ pointPair DrawViewDimension::getPointsOneEdge(ReferenceVector references)
ssMessage << getNameInDocument() << " can not find geometry for 2d reference (1)";
throw Base::RuntimeError(ssMessage.str());
}
if (geom->getGeomType() != TechDraw::GeomType::GENERIC) {
if (geom->getGeomType() != GeomType::GENERIC) {
std::stringstream ssMessage;
ssMessage << getNameInDocument() << " 2d reference is a " << geom->geomTypeName();
throw Base::RuntimeError(ssMessage.str());
@@ -1007,12 +1007,12 @@ arcPoints DrawViewDimension::arcPointsFromBaseGeom(TechDraw::BaseGeomPtr base)
arcPoints pts;
pts.center = Base::Vector3d(0.0, 0.0, 0.0);
pts.radius = 0.0;
if ((base && base->getGeomType() == TechDraw::GeomType::CIRCLE)
|| (base && base->getGeomType() == TechDraw::GeomType::ARCOFCIRCLE)) {
if ((base && base->getGeomType() == GeomType::CIRCLE)
|| (base && base->getGeomType() == GeomType::ARCOFCIRCLE)) {
circle = std::static_pointer_cast<TechDraw::Circle>(base);
pts.center = Base::Vector3d(circle->center.x, circle->center.y, 0.0);
pts.radius = circle->radius;
if (base->getGeomType() == TechDraw::GeomType::ARCOFCIRCLE) {
if (base->getGeomType() == GeomType::ARCOFCIRCLE) {
TechDraw::AOCPtr aoc = std::static_pointer_cast<TechDraw::AOC>(circle);
pts.isArc = true;
pts.onCurve.first(Base::Vector3d(aoc->midPnt.x, aoc->midPnt.y, 0.0));
@@ -1029,8 +1029,8 @@ arcPoints DrawViewDimension::arcPointsFromBaseGeom(TechDraw::BaseGeomPtr base)
pts.center + Base::Vector3d(-1, 0, 0) * circle->radius); // arbitrary point on edge
}
}
else if ((base && base->getGeomType() == TechDraw::GeomType::ELLIPSE)
|| (base && base->getGeomType() == TechDraw::GeomType::ARCOFELLIPSE)) {
else if ((base && base->getGeomType() == GeomType::ELLIPSE)
|| (base && base->getGeomType() == GeomType::ARCOFELLIPSE)) {
TechDraw::EllipsePtr ellipse = std::static_pointer_cast<TechDraw::Ellipse>(base);
if (ellipse->closed()) {
double r1 = ellipse->minor;
@@ -1063,7 +1063,7 @@ arcPoints DrawViewDimension::arcPointsFromBaseGeom(TechDraw::BaseGeomPtr base)
+ Base::Vector3d(-1, 0, 0) * rAvg); // arbitrary point on edge
}
}
else if (base && base->getGeomType() == TechDraw::GeomType::BSPLINE) {
else if (base && base->getGeomType() == GeomType::BSPLINE) {
TechDraw::BSplinePtr spline = std::static_pointer_cast<TechDraw::BSpline>(base);
if (spline->isCircle()) {
bool arc{false};
@@ -1219,13 +1219,13 @@ anglePoints DrawViewDimension::getAnglePointsTwoEdges(ReferenceVector references
ssMessage << getNameInDocument() << " can not find geometry for 2d reference (5)";
throw Base::RuntimeError(ssMessage.str());
}
if (geom0->getGeomType() != TechDraw::GeomType::GENERIC) {
if (geom0->getGeomType() != GeomType::GENERIC) {
std::stringstream ssMessage;
ssMessage << getNameInDocument() << " first 2d reference is a "
<< geom0->geomTypeName();
throw Base::RuntimeError(ssMessage.str());
}
if (geom1->getGeomType() != TechDraw::GeomType::GENERIC) {
if (geom1->getGeomType() != GeomType::GENERIC) {
std::stringstream ssMessage;
ssMessage << getNameInDocument() << " second 2d reference is a "
<< geom0->geomTypeName();
@@ -1977,13 +1977,13 @@ bool DrawViewDimension::leaderIntersectsArc(Base::Vector3d s, Base::Vector3d poi
const std::vector<std::string>& subElements = References2D.getSubValues();
int idx = DrawUtil::getIndexFromName(subElements[0]);
TechDraw::BaseGeomPtr base = getViewPart()->getGeomByIndex(idx);
if (base && base->getGeomType() == TechDraw::GeomType::ARCOFCIRCLE) {
if (base && base->getGeomType() == GeomType::ARCOFCIRCLE) {
TechDraw::AOCPtr aoc = std::static_pointer_cast<TechDraw::AOC>(base);
if (aoc->intersectsArc(s, pointOnCircle)) {
result = true;
}
}
else if (base && base->getGeomType() == TechDraw::GeomType::BSPLINE) {
else if (base && base->getGeomType() == GeomType::BSPLINE) {
TechDraw::BSplinePtr spline = std::static_pointer_cast<TechDraw::BSpline>(base);
if (spline->isCircle()) {
if (spline->intersectsArc(s, pointOnCircle)) {

55
src/Mod/TechDraw/App/Geometry.cpp
View File

@@ -101,10 +101,6 @@ using DU = DrawUtil;
using BRepAdaptor_HCurve = BRepAdaptor_Curve;
#endif
#define GEOMETRYEDGE 0
#define COSMETICEDGE 1
#define CENTERLINE 2
// Collection of Geometric Features
Wire::Wire()
{
@@ -195,14 +191,14 @@ Face::~Face()
}
BaseGeom::BaseGeom() :
geomType(NOTDEF),
extractType(Plain), //obs
classOfEdge(ecNONE),
geomType(GeomType::NOTDEF),
extractType(ExtractionType::Plain), //obs
classOfEdge(EdgeClass::NONE),
hlrVisible(true),
reversed(false),
ref3D(-1), //obs?
cosmetic(false),
m_source(0),
m_source(SourceType::GEOMETRY),
m_sourceIndex(-1)
{
occEdge = TopoDS_Edge();
@@ -270,7 +266,7 @@ void BaseGeom::Save(Base::Writer &writer) const
writer.Stream() << writer.ind() << "<Ref3D value=\"" << ref3D << "\"/>" << endl;
const char c = cosmetic?'1':'0';
writer.Stream() << writer.ind() << "<Cosmetic value=\"" << c << "\"/>" << endl;
writer.Stream() << writer.ind() << "<Source value=\"" << m_source << "\"/>" << endl;
writer.Stream() << writer.ind() << "<Source value=\"" << m_source << "\"/>" << endl; // Should this save as text and not number?
writer.Stream() << writer.ind() << "<SourceIndex value=\"" << m_sourceIndex << "\"/>" << endl;
writer.Stream() << writer.ind() << "<CosmeticTag value=\"" << cosmeticTag << "\"/>" << endl;
// writer.Stream() << writer.ind() << "<Tag value=\"" << getTagAsString() << "\"/>" << endl;
@@ -279,11 +275,11 @@ void BaseGeom::Save(Base::Writer &writer) const
void BaseGeom::Restore(Base::XMLReader &reader)
{
reader.readElement("GeomType");
geomType = static_cast<TechDraw::GeomType>(reader.getAttributeAsInteger("value"));
geomType = static_cast<GeomType>(reader.getAttributeAsInteger("value"));
reader.readElement("ExtractType");
extractType = static_cast<TechDraw::ExtractionType>(reader.getAttributeAsInteger("value"));
extractType = static_cast<ExtractionType>(reader.getAttributeAsInteger("value"));
reader.readElement("EdgeClass");
classOfEdge = static_cast<TechDraw::edgeClass>(reader.getAttributeAsInteger("value"));
classOfEdge = static_cast<EdgeClass>(reader.getAttributeAsInteger("value"));
reader.readElement("HLRVisible");
hlrVisible = reader.getAttributeAsInteger("value") != 0;
reader.readElement("Reversed");
@@ -293,7 +289,7 @@ void BaseGeom::Restore(Base::XMLReader &reader)
reader.readElement("Cosmetic");
cosmetic = reader.getAttributeAsInteger("value") != 0;
reader.readElement("Source");
m_source = reader.getAttributeAsInteger("value");
m_source = static_cast<SourceType>(reader.getAttributeAsInteger("value"));
reader.readElement("SourceIndex");
m_sourceIndex = reader.getAttributeAsInteger("value");
reader.readElement("CosmeticTag");
@@ -470,11 +466,8 @@ std::string BaseGeom::geomTypeName()
"Bezier",
"BSpline",
"Line", //why was this ever called "Generic"?
"Unknown" } ;
if (geomType >= typeNames.size()) {
return "Unknown";
}
return typeNames.at(geomType);
};
return typeNames.at(static_cast<int>(geomType));
}
//! Convert 1 OCC edge into 1 BaseGeom (static factory method)
@@ -651,7 +644,7 @@ TopoShape BaseGeom::asTopoShape(double scale)
Ellipse::Ellipse(const TopoDS_Edge &e)
{
geomType = ELLIPSE;
geomType = GeomType::ELLIPSE;
BRepAdaptor_Curve c(e);
occEdge = e;
gp_Elips ellp = c.Ellipse();
@@ -668,7 +661,7 @@ Ellipse::Ellipse(const TopoDS_Edge &e)
Ellipse::Ellipse(Base::Vector3d c, double mnr, double mjr)
{
geomType = ELLIPSE;
geomType = GeomType::ELLIPSE;
center = c;
major = mjr;
minor = mnr;
@@ -688,7 +681,7 @@ Ellipse::Ellipse(Base::Vector3d c, double mnr, double mjr)
AOE::AOE(const TopoDS_Edge &e) : Ellipse(e)
{
geomType = ARCOFELLIPSE;
geomType = GeomType::ARCOFELLIPSE;
BRepAdaptor_Curve c(e);
double f = c.FirstParameter();
@@ -725,14 +718,14 @@ AOE::AOE(const TopoDS_Edge &e) : Ellipse(e)
Circle::Circle()
{
geomType = CIRCLE;
geomType = GeomType::CIRCLE;
radius = 0.0;
center = Base::Vector3d(0.0, 0.0, 0.0);
}
Circle::Circle(Base::Vector3d c, double r)
{
geomType = CIRCLE;
geomType = GeomType::CIRCLE;
radius = r;
center = c;
gp_Pnt loc(c.x, c.y, c.z);
@@ -753,7 +746,7 @@ Circle::Circle(Base::Vector3d c, double r)
Circle::Circle(const TopoDS_Edge &e)
{
geomType = CIRCLE; //center, radius
geomType = GeomType::CIRCLE; //center, radius
BRepAdaptor_Curve c(e);
occEdge = e;
@@ -802,7 +795,7 @@ void Circle::Restore(Base::XMLReader &reader)
AOC::AOC(const TopoDS_Edge &e) : Circle(e)
{
geomType = ARCOFCIRCLE;
geomType = GeomType::ARCOFCIRCLE;
BRepAdaptor_Curve c(e);
double f = c.FirstParameter();
@@ -834,7 +827,7 @@ AOC::AOC(const TopoDS_Edge &e) : Circle(e)
AOC::AOC(Base::Vector3d c, double r, double sAng, double eAng) : Circle()
{
geomType = ARCOFCIRCLE;
geomType = GeomType::ARCOFCIRCLE;
radius = r;
center = c;
@@ -883,7 +876,7 @@ AOC::AOC(Base::Vector3d c, double r, double sAng, double eAng) : Circle()
AOC::AOC() : Circle()
{
geomType = ARCOFCIRCLE;
geomType = GeomType::ARCOFCIRCLE;
startPnt = Base::Vector3d(0.0, 0.0, 0.0);
endPnt = Base::Vector3d(0.0, 0.0, 0.0);
@@ -1028,7 +1021,7 @@ void AOC::Restore(Base::XMLReader &reader)
//! Generic is a multiline
Generic::Generic(const TopoDS_Edge &e)
{
geomType = GENERIC;
geomType = GeomType::GENERIC;
occEdge = e;
BRepLib::BuildCurve3d(occEdge);
@@ -1055,7 +1048,7 @@ Generic::Generic(const TopoDS_Edge &e)
Generic::Generic()
{
geomType = GENERIC;
geomType = GeomType::GENERIC;
}
std::string Generic::toString() const
@@ -1145,7 +1138,7 @@ Base::Vector3d Generic::apparentInter(GenericPtr g)
BSpline::BSpline(const TopoDS_Edge &e)
{
geomType = BSPLINE;
geomType = GeomType::BSPLINE;
BRepAdaptor_Curve c(e);
isArc = !c.IsClosed();
Handle(Geom_BSplineCurve) cSpline = c.BSpline();
@@ -1260,7 +1253,7 @@ bool BSpline::intersectsArc(Base::Vector3d p1, Base::Vector3d p2)
BezierSegment::BezierSegment(const TopoDS_Edge &e)
{
geomType = BEZIER;
geomType = GeomType::BEZIER;
occEdge = e;
BRepAdaptor_Curve c(e);
Handle(Geom_BezierCurve) bez = c.Bezier();

48
src/Mod/TechDraw/App/Geometry.h
View File

@@ -45,22 +45,22 @@ namespace TechDraw {
class DrawViewPart;
enum ExtractionType { //obs
enum class ExtractionType : int { //obs
Plain,
WithHidden,
WithSmooth
};
enum edgeClass {
ecNONE, // Not used, OCC index starts at 1
ecUVISO,
ecOUTLINE,
ecSMOOTH,
ecSEAM,
ecHARD
enum class EdgeClass : int {
NONE, // Not used, OCC index starts at 1
UVISO,
OUTLINE,
SMOOTH,
SEAM,
HARD
};
enum GeomType {
enum class GeomType : int {
NOTDEF,
CIRCLE,
ARCOFCIRCLE,
@@ -71,12 +71,24 @@ enum GeomType {
GENERIC
};
enum SourceType {
GEOM,
COSEDGE,
enum class SourceType : int {
GEOMETRY,
COSMETICEDGE,
CENTERLINE
};
template <typename T, std::enable_if_t<
std::is_same_v<EdgeClass, T> ||
std::is_same_v<ExtractionType, T> ||
std::is_same_v<GeomType, T> ||
std::is_same_v<SourceType, T>,
bool
> =true>
std::ostream& operator<<(std::ostream& out, const T& type) {
out << static_cast<int>(type);
return out;
}
class BaseGeom;
using BaseGeomPtr = std::shared_ptr<BaseGeom>;
class Circle;
@@ -131,8 +143,8 @@ class TechDrawExport BaseGeom : public std::enable_shared_from_this<BaseGeom>
// attribute setters and getters
GeomType getGeomType() { return geomType; }
void setGeomType(GeomType type) { geomType = type; }
edgeClass getClassOfEdge() { return classOfEdge; }
void setClassOfEdge(edgeClass newClass) { classOfEdge = newClass; }
EdgeClass getClassOfEdge() { return classOfEdge; }
void setClassOfEdge(EdgeClass newClass) { classOfEdge = newClass; }
bool getHlrVisible() { return hlrVisible; }
void setHlrVisible(bool state) { hlrVisible = state; }
bool getReversed() { return reversed; }
@@ -143,8 +155,8 @@ class TechDrawExport BaseGeom : public std::enable_shared_from_this<BaseGeom>
void setOCCEdge(TopoDS_Edge newEdge) { occEdge = newEdge; }
bool getCosmetic() { return cosmetic; }
void setCosmetic (bool state) { cosmetic = state; }
int source() { return m_source; }
void source(int s) { m_source = s; }
SourceType source() { return m_source; }
void source(SourceType s) { m_source = s; }
int sourceIndex() { return m_sourceIndex; }
void sourceIndex(int si) { m_sourceIndex = si; }
std::string getCosmeticTag() { return cosmeticTag; }
@@ -161,14 +173,14 @@ protected:
GeomType geomType;
ExtractionType extractType; //obs
edgeClass classOfEdge;
EdgeClass classOfEdge;
bool hlrVisible;
bool reversed;
int ref3D; //obs?
TopoDS_Edge occEdge; //projected Edge
bool cosmetic;
//TODO: all these attributes should be private
int m_source; //0 - geom, 1 - cosmetic edge, 2 - centerline
SourceType m_source;
int m_sourceIndex;
std::string cosmeticTag;
boost::uuids::uuid tag;

64
src/Mod/TechDraw/App/GeometryObject.cpp
View File

@@ -99,16 +99,16 @@ const BaseGeomPtrVector GeometryObject::getVisibleFaceEdges(const bool smooth,
for (auto& e : edgeGeom) {
if (e->getHlrVisible()) {
switch (e->getClassOfEdge()) {
case ecHARD:
case ecOUTLINE:
case EdgeClass::HARD:
case EdgeClass::OUTLINE:
result.push_back(e);
break;
case ecSMOOTH:
case EdgeClass::SMOOTH:
if (smoothOK) {
result.push_back(e);
}
break;
case ecSEAM:
case EdgeClass::SEAM:
if (seamOK) {
result.push_back(e);
}
@@ -251,9 +251,9 @@ void GeometryObject::projectShape(const TopoDS_Shape& inShape, const gp_Ax2& vie
void GeometryObject::makeTDGeometry()
{
// Base::Console().Message("GO::makeTDGeometry()\n");
extractGeometry(TechDraw::ecHARD, //always show the hard&outline visible lines
extractGeometry(EdgeClass::HARD, //always show the hard&outline visible lines
true);
extractGeometry(TechDraw::ecOUTLINE,
extractGeometry(EdgeClass::OUTLINE,
true);
const DrawViewPart* dvp = static_cast<const DrawViewPart*>(m_parent);
@@ -262,26 +262,26 @@ void GeometryObject::makeTDGeometry()
}
if (dvp->SmoothVisible.getValue()) {
extractGeometry(TechDraw::ecSMOOTH, true);
extractGeometry(EdgeClass::SMOOTH, true);
}
if (dvp->SeamVisible.getValue()) {
extractGeometry(TechDraw::ecSEAM, true);
extractGeometry(EdgeClass::SEAM, true);
}
if ((dvp->IsoVisible.getValue()) && (dvp->IsoCount.getValue() > 0)) {
extractGeometry(TechDraw::ecUVISO, true);
extractGeometry(EdgeClass::UVISO, true);
}
if (dvp->HardHidden.getValue()) {
extractGeometry(TechDraw::ecHARD, false);
extractGeometry(TechDraw::ecOUTLINE, false);
extractGeometry(EdgeClass::HARD, false);
extractGeometry(EdgeClass::OUTLINE, false);
}
if (dvp->SmoothHidden.getValue()) {
extractGeometry(TechDraw::ecSMOOTH, false);
extractGeometry(EdgeClass::SMOOTH, false);
}
if (dvp->SeamHidden.getValue()) {
extractGeometry(TechDraw::ecSEAM, false);
extractGeometry(EdgeClass::SEAM, false);
}
if (dvp->IsoHidden.getValue() && (dvp->IsoCount.getValue() > 0)) {
extractGeometry(TechDraw::ecUVISO, false);
extractGeometry(EdgeClass::UVISO, false);
}
}
@@ -452,54 +452,54 @@ TopoDS_Shape GeometryObject::projectFace(const TopoDS_Shape& face, const gp_Ax2&
}
//!add edges meeting filter criteria for category, visibility
void GeometryObject::extractGeometry(edgeClass category, bool hlrVisible)
void GeometryObject::extractGeometry(EdgeClass category, bool hlrVisible)
{
// Base::Console().Message("GO::extractGeometry(%d, %d)\n", category, hlrVisible);
TopoDS_Shape filtEdges;
if (hlrVisible) {
switch (category) {
case ecHARD:
case EdgeClass::HARD:
filtEdges = visHard;
break;
case ecOUTLINE:
case EdgeClass::OUTLINE:
filtEdges = visOutline;
break;
case ecSMOOTH:
case EdgeClass::SMOOTH:
filtEdges = visSmooth;
break;
case ecSEAM:
case EdgeClass::SEAM:
filtEdges = visSeam;
break;
case ecUVISO:
case EdgeClass::UVISO:
filtEdges = visIso;
break;
default:
Base::Console().Warning(
"GeometryObject::ExtractGeometry - unsupported hlrVisible edgeClass: %d\n",
"GeometryObject::ExtractGeometry - unsupported hlrVisible EdgeClass: %d\n",
static_cast<int>(category));
return;
}
}
else {
switch (category) {
case ecHARD:
case EdgeClass::HARD:
filtEdges = hidHard;
break;
case ecOUTLINE:
case EdgeClass::OUTLINE:
filtEdges = hidOutline;
break;
case ecSMOOTH:
case EdgeClass::SMOOTH:
filtEdges = hidSmooth;
break;
case ecSEAM:
case EdgeClass::SEAM:
filtEdges = hidSeam;
break;
case ecUVISO:
case EdgeClass::UVISO:
filtEdges = hidIso;
break;
default:
Base::Console().Warning(
"GeometryObject::ExtractGeometry - unsupported hidden edgeClass: %d\n",
"GeometryObject::ExtractGeometry - unsupported hidden EdgeClass: %d\n",
static_cast<int>(category));
return;
}
@@ -509,7 +509,7 @@ void GeometryObject::extractGeometry(edgeClass category, bool hlrVisible)
}
//! update edgeGeom and vertexGeom from Compound of edges
void GeometryObject::addGeomFromCompound(TopoDS_Shape edgeCompound, edgeClass category,
void GeometryObject::addGeomFromCompound(TopoDS_Shape edgeCompound, EdgeClass category,
bool hlrVisible)
{
// Base::Console().Message("GO::addGeomFromCompound(%d, %d)\n", category, hlrVisible);
@@ -552,7 +552,7 @@ void GeometryObject::addGeomFromCompound(TopoDS_Shape edgeCompound, edgeClass ca
// throw Base::ValueError("GeometryObject::addGeomFromCompound - baseFactory failed");
}
base->source(0);//object geometry
base->source(SourceType::GEOMETRY);
base->sourceIndex(i - 1);
base->setClassOfEdge(category);
base->setHlrVisible(hlrVisible);
@@ -707,7 +707,7 @@ int GeometryObject::addCosmeticEdge(Base::Vector3d start, Base::Vector3d end, st
TechDraw::BaseGeomPtr base = BaseGeom::baseFactory(occEdge);
base->setCosmetic(true);
base->setCosmeticTag(tagString);
base->source(1);//1-CosmeticEdge, 2-CenterLine
base->source(SourceType::COSMETICEDGE);
base->setHlrVisible(true);
int idx = edgeGeom.size();
edgeGeom.push_back(base);
@@ -719,7 +719,7 @@ int GeometryObject::addCosmeticEdge(TechDraw::BaseGeomPtr base, std::string tagS
// Base::Console().Message("GO::addCosmeticEdge(%X, %s) 3\n", base, tagString.c_str());
base->setCosmetic(true);
base->setHlrVisible(true);
base->source(1);//1-CosmeticEdge, 2-CenterLine
base->source(SourceType::COSMETICEDGE);
base->setCosmeticTag(tagString);
base->sourceIndex(-1);
int idx = edgeGeom.size();
@@ -733,7 +733,7 @@ int GeometryObject::addCenterLine(TechDraw::BaseGeomPtr base, std::string tag)
// Base::Console().Message("GO::addCenterLine()\n");
base->setCosmetic(true);
base->setCosmeticTag(tag);
base->source(2);
base->source(SourceType::CENTERLINE);
// base->sourceIndex(si); //index into source;
int idx = edgeGeom.size();
edgeGeom.push_back(base);

4
src/Mod/TechDraw/App/GeometryObject.h
View File

@@ -86,7 +86,7 @@ public:
static TopoDS_Shape simpleProjection(const TopoDS_Shape& shape, const gp_Ax2& projCS);
static TopoDS_Shape projectFace(const TopoDS_Shape& face, const gp_Ax2& CS);
void makeTDGeometry();
void extractGeometry(edgeClass category, bool visible);
void extractGeometry(EdgeClass category, bool visible);
void addFaceGeom(FacePtr f);
void clearFaceGeom();
void setIsoCount(int i) { m_isoCount = i; }
@@ -141,7 +141,7 @@ protected:
TopoDS_Shape hidSeam;
TopoDS_Shape hidIso;
void addGeomFromCompound(TopoDS_Shape edgeCompound, edgeClass category, bool visible);
void addGeomFromCompound(TopoDS_Shape edgeCompound, EdgeClass category, bool visible);
TechDraw::DrawViewDetail* isParentDetail();
//similar function in Geometry?

18
src/Mod/TechDraw/Gui/CommandAnnotate.cpp
View File

@@ -1074,7 +1074,7 @@ void execLine2Points(Gui::Command* cmd)
//check if editing existing edge
if (!edgeNames.empty() && (edgeNames.size() == 1)) {
TechDraw::CosmeticEdge* ce = baseFeat->getCosmeticEdgeBySelection(edgeNames.front());
if (!ce || ce->m_geometry->getGeomType() != TechDraw::GeomType::GENERIC) {
if (!ce || ce->m_geometry->getGeomType() != GeomType::GENERIC) {
QMessageBox::warning(Gui::getMainWindow(), QObject::tr("Wrong Selection"),
QObject::tr("Selection is not a Cosmetic Line."));
return;
@@ -1218,8 +1218,8 @@ void execCosmeticCircle(Gui::Command* cmd)
if (!edgeNames.empty() && (edgeNames.size() == 1)) {
TechDraw::CosmeticEdge* ce = baseFeat->getCosmeticEdgeBySelection(edgeNames.front());
if (!ce
|| !(ce->m_geometry->getGeomType() == TechDraw::GeomType::CIRCLE
|| ce->m_geometry->getGeomType() == TechDraw::GeomType::ARCOFCIRCLE)) {
|| !(ce->m_geometry->getGeomType() == GeomType::CIRCLE
|| ce->m_geometry->getGeomType() == GeomType::ARCOFCIRCLE)) {
QMessageBox::warning(Gui::getMainWindow(), QObject::tr("Wrong Selection"),
QObject::tr("Selection is not a Cosmetic Circle or a Cosmetic Arc of Circle."));
return;
@@ -1275,10 +1275,6 @@ void execCosmeticCircle(Gui::Command* cmd)
// TechDraw_CosmeticEraser
//===========================================================================
#define GEOMETRYEDGE 0
#define COSMETICEDGE 1
#define CENTERLINE 2
DEF_STD_CMD_A(CmdTechDrawCosmeticEraser)
CmdTechDrawCosmeticEraser::CmdTechDrawCosmeticEraser()
@@ -1345,15 +1341,15 @@ void CmdTechDrawCosmeticEraser::activated(int iMsg)
if (geomType == "Edge") {
TechDraw::BaseGeomPtr bg = objFeat->getGeomByIndex(idx);
if (bg && bg->getCosmetic()) {
int source = bg->source();
SourceType source = bg->source();
std::string tag = bg->getCosmeticTag();
if (source == COSMETICEDGE) {
if (source == SourceType::COSMETICEDGE) {
ce2Delete.push_back(tag);
} else if (source == CENTERLINE) {
} else if (source == SourceType::CENTERLINE) {
cl2Delete.push_back(tag);
} else {
Base::Console().Message(
"CMD::CosmeticEraser - edge: %d is confused - source: %d\n", idx, source);
"CMD::CosmeticEraser - edge: %d is confused - source: %d\n", idx, static_cast<int>(source));
}
}
} else if (geomType == "Vertex") {

14
src/Mod/TechDraw/Gui/CommandCreateDims.cpp
View File

@@ -673,7 +673,7 @@ protected:
return emptyVector;
}
if (geom->getGeomType() == TechDraw::GENERIC) {
if (geom->getGeomType() == GeomType::GENERIC) {
TechDraw::GenericPtr gen1 = std::static_pointer_cast<TechDraw::Generic>(geom);
if (gen1->points.size() < 2) {
return emptyVector;
@@ -681,13 +681,13 @@ protected:
return selLine;
//Base::Vector3d line = gen1->points.at(1) - gen1->points.at(0);
}
else if (geom->getGeomType() == TechDraw::CIRCLE || geom->getGeomType() == TechDraw::ARCOFCIRCLE) {
else if (geom->getGeomType() == GeomType::CIRCLE || geom->getGeomType() == GeomType::ARCOFCIRCLE) {
return selCircleArc;
}
else if (geom->getGeomType() == TechDraw::ELLIPSE || geom->getGeomType() == TechDraw::ARCOFELLIPSE) {
else if (geom->getGeomType() == GeomType::ELLIPSE || geom->getGeomType() == GeomType::ARCOFELLIPSE) {
return selEllipseArc;
}
else if (geom->getGeomType() == TechDraw::BSPLINE) {
else if (geom->getGeomType() == GeomType::BSPLINE) {
//TechDraw::BSplinePtr spline = std::static_pointer_cast<TechDraw::BSpline>(geom);
//if (spline->isCircle()) {
// return isBSplineCircle;
@@ -981,7 +981,7 @@ protected:
}
if (availableDimension == AvailableDimension::SECOND) {
createRadiusDiameterDimension(selCircleArc[0], false);
if (selCircleArc[0].geomEdgeType() != TechDraw::ARCOFCIRCLE) {
if (selCircleArc[0].geomEdgeType() != GeomType::ARCOFCIRCLE) {
availableDimension = AvailableDimension::RESET;
}
}
@@ -1015,7 +1015,7 @@ protected:
}
if (availableDimension == AvailableDimension::SECOND) {
createRadiusDiameterDimension(selEllipseArc[0], false);
if (selEllipseArc[0].geomEdgeType() != TechDraw::ARCOFELLIPSE) {
if (selEllipseArc[0].geomEdgeType() != GeomType::ARCOFELLIPSE) {
availableDimension = AvailableDimension::RESET;
}
}
@@ -1074,7 +1074,7 @@ protected:
void createRadiusDiameterDimension(ReferenceEntry ref, bool firstCstr) {
int GeoId(TechDraw::DrawUtil::getIndexFromName(ref.getSubName()));
TechDraw::BaseGeomPtr geom = partFeat->getGeomByIndex(GeoId);
bool isCircleGeom = (geom->getGeomType() == TechDraw::CIRCLE) || (geom->getGeomType() == TechDraw::ELLIPSE);
bool isCircleGeom = (geom->getGeomType() == GeomType::CIRCLE) || (geom->getGeomType() == GeomType::ELLIPSE);
// Use same preference as in sketcher?
ParameterGrp::handle hGrp = App::GetApplication().GetParameterGroupByPath("User parameter:BaseApp/Preferences/Mod/TechDraw/dimensioning");

18
src/Mod/TechDraw/Gui/CommandExtensionPack.cpp
View File

@@ -113,7 +113,7 @@ void execHoleCircle(Gui::Command* cmd)
std::string GeoType = TechDraw::DrawUtil::getGeomTypeFromName(Name);
TechDraw::BaseGeomPtr geom = objFeat->getGeomByIndex(GeoId);
if (GeoType == "Edge") {
if (geom->getGeomType() == TechDraw::CIRCLE || geom->getGeomType() == TechDraw::ARCOFCIRCLE) {
if (geom->getGeomType() == GeomType::CIRCLE || geom->getGeomType() == GeomType::ARCOFCIRCLE) {
TechDraw::CirclePtr cgen = std::static_pointer_cast<TechDraw::Circle>(geom);
Circles.push_back(cgen);
}
@@ -212,7 +212,7 @@ void execCircleCenterLines(Gui::Command* cmd)
TechDraw::BaseGeomPtr geom = objFeat->getGeomByIndex(GeoId);
std::string GeoType = TechDraw::DrawUtil::getGeomTypeFromName(Name);
if (GeoType == "Edge") {
if (geom->getGeomType() == TechDraw::CIRCLE || geom->getGeomType() == TechDraw::ARCOFCIRCLE) {
if (geom->getGeomType() == GeomType::CIRCLE || geom->getGeomType() == GeomType::ARCOFCIRCLE) {
TechDraw::CirclePtr cgen = std::static_pointer_cast<TechDraw::Circle>(geom);
// cgen->center is a scaled, rotated and inverted point
Base::Vector3d center = CosmeticVertex::makeCanonicalPointInverted(objFeat, cgen->center);
@@ -803,11 +803,11 @@ void CmdTechDrawExtensionChangeLineAttributes::activated(int iMsg)
BaseGeomPtr baseGeo = objFeat->getGeomByIndex(num);
if (baseGeo) {
if (baseGeo->getCosmetic()) {
if (baseGeo->source() == 1) {
if (baseGeo->source() == SourceType::COSMETICEDGE) {
TechDraw::CosmeticEdge* cosEdgeTag = objFeat->getCosmeticEdgeBySelection(name);
_setLineAttributes(cosEdgeTag);
}
else if (baseGeo->source() == 2) {
else if (baseGeo->source() == SourceType::CENTERLINE) {
TechDraw::CenterLine* centerLineTag = objFeat->getCenterLineBySelection(name);
_setLineAttributes(centerLineTag);
}
@@ -1516,7 +1516,7 @@ void execExtendShortenLine(Gui::Command* cmd, bool extend)
if (geoType == "Edge") {
TechDraw::BaseGeomPtr baseGeo = objFeat->getGeomByIndex(num);
if (baseGeo) {
if (baseGeo->getGeomType() == TechDraw::GENERIC) {
if (baseGeo->getGeomType() == GeomType::GENERIC) {
// start and end points are geometry points and are scaled, rotated and inverted
// convert start and end to unscaled, unrotated.
Base::Vector3d P0 = CosmeticVertex::makeCanonicalPointInverted(objFeat, baseGeo->getStartPoint());
@@ -1530,7 +1530,7 @@ void execExtendShortenLine(Gui::Command* cmd, bool extend)
App::Color oldColor;
std::vector<std::string> toDelete;
toDelete.push_back(uniTag);
if (baseGeo->source() == 1) {
if (baseGeo->source() == SourceType::COSMETICEDGE) {
// cosmetic edge
auto cosEdge = objFeat->getCosmeticEdge(uniTag);
oldStyle = cosEdge->m_format.getLineNumber();
@@ -1538,7 +1538,7 @@ void execExtendShortenLine(Gui::Command* cmd, bool extend)
oldColor = cosEdge->m_format.getColor();
objFeat->removeCosmeticEdge(toDelete);
}
else if (baseGeo->source() == 2) {
else if (baseGeo->source() == SourceType::CENTERLINE) {
// centerline
isCenterLine = true;
centerEdge = objFeat->getCenterLine(uniTag);
@@ -2121,7 +2121,7 @@ void _createThreadCircle(const std::string Name, TechDraw::DrawViewPart* objFeat
TechDraw::BaseGeomPtr geom = objFeat->getGeomByIndex(GeoId);
std::string GeoType = TechDraw::DrawUtil::getGeomTypeFromName(Name);
if (GeoType == "Edge" && geom->getGeomType() == TechDraw::CIRCLE) {
if (GeoType == "Edge" && geom->getGeomType() == GeomType::CIRCLE) {
TechDraw::CirclePtr cgen = std::static_pointer_cast<TechDraw::Circle>(geom);
// center is rotated and scaled
Base::Vector3d center = CosmeticVertex::makeCanonicalPointInverted(objFeat, cgen->center);
@@ -2146,7 +2146,7 @@ void _createThreadLines(const std::vector<std::string>& SubNames, TechDraw::Draw
int GeoId1 = TechDraw::DrawUtil::getIndexFromName(SubNames[1]);
TechDraw::BaseGeomPtr geom0 = objFeat->getGeomByIndex(GeoId0);
TechDraw::BaseGeomPtr geom1 = objFeat->getGeomByIndex(GeoId1);
if (geom0->getGeomType() != TechDraw::GENERIC || geom1->getGeomType() != TechDraw::GENERIC) {
if (geom0->getGeomType() != GeomType::GENERIC || geom1->getGeomType() != GeomType::GENERIC) {
QMessageBox::warning(Gui::getMainWindow(), QObject::tr("TechDraw Thread Hole Side"),
QObject::tr("Please select two straight lines"));
return;

10
src/Mod/TechDraw/Gui/DimensionValidators.cpp
View File

@@ -379,7 +379,7 @@ DimensionGeometryType TechDraw::isValidSingleEdge(ReferenceEntry ref)
return isInvalid;
}
if (geom->getGeomType() == TechDraw::GENERIC) {
if (geom->getGeomType() == GeomType::GENERIC) {
TechDraw::GenericPtr gen1 = std::static_pointer_cast<TechDraw::Generic>(geom);
if (gen1->points.size() < 2) {
return isInvalid;
@@ -392,11 +392,11 @@ DimensionGeometryType TechDraw::isValidSingleEdge(ReferenceEntry ref)
} else {
return TechDraw::isDiagonal;
}
} else if (geom->getGeomType() == TechDraw::CIRCLE || geom->getGeomType() == TechDraw::ARCOFCIRCLE) {
} else if (geom->getGeomType() == GeomType::CIRCLE || geom->getGeomType() == GeomType::ARCOFCIRCLE) {
return isCircle;
} else if (geom->getGeomType() == TechDraw::ELLIPSE || geom->getGeomType() == TechDraw::ARCOFELLIPSE) {
} else if (geom->getGeomType() == GeomType::ELLIPSE || geom->getGeomType() == GeomType::ARCOFELLIPSE) {
return isEllipse;
} else if (geom->getGeomType() == TechDraw::BSPLINE) {
} else if (geom->getGeomType() == GeomType::BSPLINE) {
TechDraw::BSplinePtr spline = std::static_pointer_cast<TechDraw::BSpline>(geom);
if (spline->isCircle()) {
return isBSplineCircle;
@@ -529,7 +529,7 @@ DimensionGeometryType TechDraw::isValidMultiEdge(ReferenceVector refs)
TechDraw::BaseGeomPtr geom0 = objFeat0->getGeomByIndex(GeoId0);
TechDraw::BaseGeomPtr geom1 = objFeat0->getGeomByIndex(GeoId1);
if (geom0->getGeomType() == TechDraw::GENERIC && geom1->getGeomType() == TechDraw::GENERIC) {
if (geom0->getGeomType() == GeomType::GENERIC && geom1->getGeomType() == GeomType::GENERIC) {
TechDraw::GenericPtr gen0 = std::static_pointer_cast<TechDraw::Generic>(geom0);
TechDraw::GenericPtr gen1 = std::static_pointer_cast<TechDraw::Generic>(geom1);
if (gen0->points.size() > 2 || gen1->points.size() > 2) {//the edge is a polyline

14
src/Mod/TechDraw/Gui/PathBuilder.cpp
View File

@@ -43,7 +43,7 @@ QPainterPath PathBuilder::geomToPainterPath(BaseGeomPtr baseGeom, double rot) co
return path;
switch (baseGeom->getGeomType()) {
case CIRCLE: {
case GeomType::CIRCLE: {
TechDraw::CirclePtr geom = std::static_pointer_cast<TechDraw::Circle>(baseGeom);
double x = geom->center.x - geom->radius;
@@ -52,7 +52,7 @@ QPainterPath PathBuilder::geomToPainterPath(BaseGeomPtr baseGeom, double rot) co
path.addEllipse(Rez::guiX(x), Rez::guiX(y), Rez::guiX(geom->radius * 2),
Rez::guiX(geom->radius * 2));//topleft@(x, y) radx, rady
} break;
case ARCOFCIRCLE: {
case GeomType::ARCOFCIRCLE: {
TechDraw::AOCPtr geom = std::static_pointer_cast<TechDraw::AOC>(baseGeom);
if (baseGeom->getReversed()) { // OCC reversed flag
path.moveTo(Rez::guiX(geom->endPnt.x), Rez::guiX(geom->endPnt.y));
@@ -69,7 +69,7 @@ QPainterPath PathBuilder::geomToPainterPath(BaseGeomPtr baseGeom, double rot) co
Rez::guiX(geom->startPnt.x), Rez::guiX(geom->startPnt.y));
}
} break;
case TechDraw::ELLIPSE: {
case GeomType::ELLIPSE: {
TechDraw::AOEPtr geom = std::static_pointer_cast<TechDraw::AOE>(baseGeom);
// Calculate start and end points as ellipse with theta = 0 and pi
@@ -84,7 +84,7 @@ QPainterPath PathBuilder::geomToPainterPath(BaseGeomPtr baseGeom, double rot) co
pathArc(path, Rez::guiX(geom->major), Rez::guiX(geom->minor), geom->angle, false, false,
Rez::guiX(startX), Rez::guiX(startY), Rez::guiX(endX), Rez::guiX(endY));
} break;
case TechDraw::ARCOFELLIPSE: {
case GeomType::ARCOFELLIPSE: {
TechDraw::AOEPtr geom = std::static_pointer_cast<TechDraw::AOE>(baseGeom);
if (baseGeom->getReversed()) {
path.moveTo(Rez::guiX(geom->endPnt.x), Rez::guiX(geom->endPnt.y));
@@ -101,7 +101,7 @@ QPainterPath PathBuilder::geomToPainterPath(BaseGeomPtr baseGeom, double rot) co
Rez::guiX(geom->startPnt.y));
}
} break;
case TechDraw::BEZIER: {
case GeomType::BEZIER: {
TechDraw::BezierSegmentPtr geom =
std::static_pointer_cast<TechDraw::BezierSegment>(baseGeom);
if (baseGeom->getReversed()) {
@@ -158,7 +158,7 @@ QPainterPath PathBuilder::geomToPainterPath(BaseGeomPtr baseGeom, double rot) co
}
}
} break;
case TechDraw::BSPLINE: {
case GeomType::BSPLINE: {
TechDraw::BSplinePtr geom = std::static_pointer_cast<TechDraw::BSpline>(baseGeom);
if (baseGeom->getReversed()) {
// Move painter to the end of our last segment
@@ -221,7 +221,7 @@ QPainterPath PathBuilder::geomToPainterPath(BaseGeomPtr baseGeom, double rot) co
}
}
} break;
case TechDraw::GENERIC: {
case GeomType::GENERIC: {
TechDraw::GenericPtr geom = std::static_pointer_cast<TechDraw::Generic>(baseGeom);
if (baseGeom->getReversed()) {
if (!geom->points.empty()) {

8
src/Mod/TechDraw/Gui/QGIDrawingTemplate.cpp
View File

@@ -86,9 +86,7 @@ void QGIDrawingTemplate::draw()
// Draw Edges
// iterate through all the geometries
for(; it != geoms.end(); ++it) {
switch((*it)->getGeomType()) {
case TechDraw::GENERIC: {
if((*it)->getGeomType() == TechDraw::GeomType::GENERIC) {
TechDraw::GenericPtr geom = std::static_pointer_cast<TechDraw::Generic>(*it);
path.moveTo(geom->points[0].x, geom->points[0].y);
@@ -97,10 +95,6 @@ void QGIDrawingTemplate::draw()
for(++it; it != geom->points.end(); ++it) {
path.lineTo((*it).x, (*it).y);
}
break;
}
default:
break;
}
}

7
src/Mod/TechDraw/Gui/QGIEdge.h
View File

@@ -23,6 +23,7 @@
#ifndef DRAWINGGUI_QGRAPHICSITEMEDGE_H
#define DRAWINGGUI_QGRAPHICSITEMEDGE_H
#include <Mod/TechDraw/App/Geometry.h>
#include <Mod/TechDraw/TechDrawGlobal.h>
#include "QGIPrimPath.h"
@@ -55,8 +56,8 @@ public:
void setLinePen(QPen isoPen);
void setSource(int source) { m_source = source; }
int getSource() const { return m_source;}
void setSource(TechDraw::SourceType source) { m_source = source; }
TechDraw::SourceType getSource() const { return m_source;}
void setCurrentPen() override;
@@ -75,7 +76,7 @@ protected:
Qt::PenStyle getHiddenStyle();
private:
int m_source{0};
TechDraw::SourceType m_source{TechDraw::SourceType::GEOMETRY};
};
}

32
src/Mod/TechDraw/Gui/QGIViewPart.cpp
View File

@@ -71,10 +71,6 @@ using namespace TechDrawGui;
using namespace std;
using DU = DrawUtil;
#define GEOMETRYEDGE 0
#define COSMETICEDGE 1
#define CENTERLINE 2
const float lineScaleFactor = Rez::guiX(1.);// temp fiddle for devel
QGIViewPart::QGIViewPart()
@@ -365,18 +361,18 @@ void QGIViewPart::drawAllEdges()
item->setNormalColor(PreferencesGui::getAccessibleQColor(PreferencesGui::normalQColor()));
if ((*itGeom)->getCosmetic()) {
// cosmetic edge - format appropriately
int source = (*itGeom)->source();
if (source == COSMETICEDGE) {
TechDraw::SourceType source = (*itGeom)->source();
if (source == TechDraw::SourceType::COSMETICEDGE) {
std::string cTag = (*itGeom)->getCosmeticTag();
showItem = formatGeomFromCosmetic(cTag, item);
}
else if (source == CENTERLINE) {
else if (source == TechDraw::SourceType::CENTERLINE) {
std::string cTag = (*itGeom)->getCosmeticTag();
showItem = formatGeomFromCenterLine(cTag, item);
}
else {
Base::Console().Message("QGIVP::drawVP - cosmetic edge: %d is confused - source: %d\n",
iEdge, source);
iEdge, static_cast<int>(source));
}
} else {
// geometry edge - apply format if applicable
@@ -407,7 +403,7 @@ void QGIViewPart::drawAllEdges()
}
}
if ((*itGeom)->getClassOfEdge() == ecUVISO) {
if ((*itGeom)->getClassOfEdge() == EdgeClass::UVISO) {
// we don't have a style option for iso-parametric lines so draw continuous
item->setLinePen(m_dashedLineGenerator->getLinePen(1, vp->IsoWidth.getValue()));
item->setWidth(Rez::guiX(vp->IsoWidth.getValue())); //graphic
@@ -475,18 +471,18 @@ bool QGIViewPart::showThisEdge(BaseGeomPtr geom)
auto dvp(static_cast<TechDraw::DrawViewPart*>(getViewObject()));
if (geom->getHlrVisible()) {
if ((geom->getClassOfEdge() == ecHARD) || (geom->getClassOfEdge() == ecOUTLINE)
|| ((geom->getClassOfEdge() == ecSMOOTH) && dvp->SmoothVisible.getValue())
|| ((geom->getClassOfEdge() == ecSEAM) && dvp->SeamVisible.getValue())
|| ((geom->getClassOfEdge() == ecUVISO) && dvp->IsoVisible.getValue())) {
if ((geom->getClassOfEdge() == EdgeClass::HARD) || (geom->getClassOfEdge() == EdgeClass::OUTLINE)
|| ((geom->getClassOfEdge() == EdgeClass::SMOOTH) && dvp->SmoothVisible.getValue())
|| ((geom->getClassOfEdge() == EdgeClass::SEAM) && dvp->SeamVisible.getValue())
|| ((geom->getClassOfEdge() == EdgeClass::UVISO) && dvp->IsoVisible.getValue())) {
return true;
}
} else {
if (((geom->getClassOfEdge() == ecHARD) && (dvp->HardHidden.getValue()))
|| ((geom->getClassOfEdge() == ecOUTLINE) && (dvp->HardHidden.getValue()))
|| ((geom->getClassOfEdge() == ecSMOOTH) && (dvp->SmoothHidden.getValue()))
|| ((geom->getClassOfEdge() == ecSEAM) && (dvp->SeamHidden.getValue()))
|| ((geom->getClassOfEdge() == ecUVISO) && (dvp->IsoHidden.getValue()))) {
if (((geom->getClassOfEdge() == EdgeClass::HARD) && (dvp->HardHidden.getValue()))
|| ((geom->getClassOfEdge() == EdgeClass::OUTLINE) && (dvp->HardHidden.getValue()))
|| ((geom->getClassOfEdge() == EdgeClass::SMOOTH) && (dvp->SmoothHidden.getValue()))
|| ((geom->getClassOfEdge() == EdgeClass::SEAM) && (dvp->SeamHidden.getValue()))
|| ((geom->getClassOfEdge() == EdgeClass::UVISO) && (dvp->IsoHidden.getValue()))) {
return true;
}
}

2
src/Mod/TechDraw/Gui/TaskLineDecor.cpp
View File

@@ -108,7 +108,7 @@ TechDraw::LineFormat *TaskLineDecor::getFormatAccessPtr(const std::string &edgeN
BaseGeomPtr bg = m_partFeat->getEdge(edgeName);
if (bg) {
if (bg->getCosmetic()) {
if (bg->source() == SourceType::COSEDGE) {
if (bg->source() == SourceType::COSMETICEDGE) {
TechDraw::CosmeticEdge *ce = m_partFeat->getCosmeticEdgeBySelection(edgeName);
if (ce) {
return &ce->m_format;