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

Remove magic number and hard type enums in DimensionValidator.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-02-03 15:33:41 +01:00
parent ee11eb188f
commit 738608db07
4 changed files with 201 additions and 201 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@@ -79,6 +79,7 @@ using namespace TechDrawGui;
using namespace TechDraw;
using namespace std;
using DimensionType = TechDraw::DrawViewDimension::DimensionType;
using DimensionGeometry = TechDraw::DimensionGeometry;
//===========================================================================
// utility routines
@@ -104,7 +105,7 @@ void execAngle3Pt(Gui::Command* cmd);
void execRadius(Gui::Command* cmd);
void execDiameter(Gui::Command* cmd);
void execArea(Gui::Command* cmd);
void execDim(Gui::Command* cmd, std::string type, StringVector acceptableGeometry, std::vector<int> minimumCounts, std::vector<DimensionGeometryType> acceptableDimensionGeometrys);
void execDim(Gui::Command* cmd, std::string type, StringVector acceptableGeometry, std::vector<int> minimumCounts, std::vector<DimensionGeometry> acceptableDimensionGeometrys);
void execExtent(Gui::Command* cmd, const std::string& dimType);
@@ -1100,7 +1101,7 @@ protected:
}
void createAngleDimension(ReferenceEntry ref1, ReferenceEntry ref2) {
if (TechDraw::isValidMultiEdge({ ref1, ref2 }) != isAngle) {
if (TechDraw::isValidMultiEdge({ ref1, ref2 }) != DimensionGeometry::isAngle) {
//isValidMultiEdge check if lines are parallel.
restartCommand(QT_TRANSLATE_NOOP("Command", "Add Distance dimension"));
createDistanceDimension("Distance", { ref1, ref2 });
@@ -1354,10 +1355,10 @@ protected:
bool isVerticalDistance(ReferenceVector refs)
{
DimensionGeometryType geometryRefs2d = validateDimSelection(
refs, { "Edge", "Vertex" }, { 1, 2 }, { isDiagonal });
DimensionGeometry geometryRefs2d = validateDimSelection(
refs, { "Edge", "Vertex" }, { 1, 2 }, { DimensionGeometry::isDiagonal });
return geometryRefs2d == TechDraw::isDiagonal;
return geometryRefs2d == DimensionGeometry::isDiagonal;
}
QPixmap icon(std::string name)
@@ -1531,8 +1532,8 @@ void execRadius(Gui::Command* cmd)
//Define the geometric configuration required for a radius dimension
StringVector acceptableGeometry({"Edge"});
std::vector<int> minimumCounts({1});
std::vector<DimensionGeometryType> acceptableDimensionGeometrys(
{isCircle, isEllipse, isBSplineCircle, isBSpline});
std::vector<DimensionGeometry> acceptableDimensionGeometrys(
{DimensionGeometry::isCircle, DimensionGeometry::isEllipse, DimensionGeometry::isBSplineCircle, DimensionGeometry::isBSpline});
execDim(cmd, "Radius", acceptableGeometry, minimumCounts, acceptableDimensionGeometrys);
}
@@ -1579,8 +1580,8 @@ void execDiameter(Gui::Command* cmd)
//Define the geometric configuration required for a diameter dimension
StringVector acceptableGeometry({"Edge"});
std::vector<int> minimumCounts({1});
std::vector<DimensionGeometryType> acceptableDimensionGeometrys(
{isCircle, isEllipse, isBSplineCircle, isBSpline});
std::vector<DimensionGeometry> acceptableDimensionGeometrys(
{DimensionGeometry::isCircle, DimensionGeometry::isEllipse, DimensionGeometry::isBSplineCircle, DimensionGeometry::isBSpline});
execDim(cmd, "Diameter", acceptableGeometry, minimumCounts, acceptableDimensionGeometrys);
}
@@ -1626,8 +1627,8 @@ void execDistance(Gui::Command* cmd)
{
StringVector acceptableGeometry({"Edge", "Vertex"});
std::vector<int> minimumCounts({1, 2});
std::vector<DimensionGeometryType> acceptableDimensionGeometrys(
{isVertical, isHorizontal, isDiagonal, isHybrid});
std::vector<DimensionGeometry> acceptableDimensionGeometrys(
{DimensionGeometry::isVertical, DimensionGeometry::isHorizontal, DimensionGeometry::isDiagonal, DimensionGeometry::isHybrid});
execDim(cmd, "Distance", acceptableGeometry, minimumCounts, acceptableDimensionGeometrys);
}
@@ -1675,7 +1676,7 @@ void execDistanceX(Gui::Command* cmd)
//Define the geometric configuration required for a length dimension
StringVector acceptableGeometry({"Edge", "Vertex"});
std::vector<int> minimumCounts({1, 2});
std::vector<DimensionGeometryType> acceptableDimensionGeometrys({isHorizontal, isDiagonal, isHybrid});
std::vector<DimensionGeometry> acceptableDimensionGeometrys({DimensionGeometry::isHorizontal, DimensionGeometry::isDiagonal, DimensionGeometry::isHybrid});
execDim(cmd, "DistanceX", acceptableGeometry, minimumCounts, acceptableDimensionGeometrys);
}
@@ -1723,7 +1724,7 @@ void execDistanceY(Gui::Command* cmd)
//Define the geometric configuration required for a length dimension
StringVector acceptableGeometry({"Edge", "Vertex"});
std::vector<int> minimumCounts({1, 2});
std::vector<DimensionGeometryType> acceptableDimensionGeometrys({isVertical, isDiagonal, isHybrid});
std::vector<DimensionGeometry> acceptableDimensionGeometrys({DimensionGeometry::isVertical, DimensionGeometry::isDiagonal, DimensionGeometry::isHybrid});
execDim(cmd, "DistanceY", acceptableGeometry, minimumCounts, acceptableDimensionGeometrys);
}
@@ -1770,7 +1771,7 @@ void execAngle(Gui::Command* cmd)
//Define the geometric configuration required for a length dimension
StringVector acceptableGeometry({"Edge"});
std::vector<int> minimumCounts({2});
std::vector<DimensionGeometryType> acceptableDimensionGeometrys({isAngle});
std::vector<DimensionGeometry> acceptableDimensionGeometrys({DimensionGeometry::isAngle});
execDim(cmd, "Angle", acceptableGeometry, minimumCounts, acceptableDimensionGeometrys);
}
@@ -1817,7 +1818,7 @@ void execAngle3Pt(Gui::Command* cmd)
//Define the geometric configuration required for a length dimension
StringVector acceptableGeometry({"Vertex"});
std::vector<int> minimumCounts({3});
std::vector<DimensionGeometryType> acceptableDimensionGeometrys({isAngle3Pt});
std::vector<DimensionGeometry> acceptableDimensionGeometrys({DimensionGeometry::isAngle3Pt});
execDim(cmd, "Angle3Pt", acceptableGeometry, minimumCounts, acceptableDimensionGeometrys);
}
@@ -1864,7 +1865,7 @@ void execArea(Gui::Command* cmd)
//Define the geometric configuration required for a area dimension
StringVector acceptableGeometry({"Face"});
std::vector<int> minimumCounts({1});
std::vector<DimensionGeometryType> acceptableDimensionGeometrys({isFace});
std::vector<DimensionGeometry> acceptableDimensionGeometrys({DimensionGeometry::isFace});
execDim(cmd, "Area", acceptableGeometry, minimumCounts, acceptableDimensionGeometrys);
}
@@ -2116,20 +2117,20 @@ void execExtent(Gui::Command* cmd, const std::string& dimType)
//Define the geometric configuration required for a extent dimension
StringVector acceptableGeometry({"Edge"});
std::vector<int> minimumCounts({1});
std::vector<DimensionGeometryType> acceptableDimensionGeometrys({isMultiEdge,
isHorizontal,
isVertical,
isDiagonal,
isCircle,
isEllipse,
isBSplineCircle,
isBSpline,
isZLimited});
std::vector<DimensionGeometry> acceptableDimensionGeometrys({DimensionGeometry::isMultiEdge,
DimensionGeometry::isHorizontal,
DimensionGeometry::isVertical,
DimensionGeometry::isDiagonal,
DimensionGeometry::isCircle,
DimensionGeometry::isEllipse,
DimensionGeometry::isBSplineCircle,
DimensionGeometry::isBSpline,
DimensionGeometry::isZLimited});
//what 2d geometry configuration did we receive?
DimensionGeometryType geometryRefs2d = validateDimSelection(
DimensionGeometry geometryRefs2d = validateDimSelection(
references2d, acceptableGeometry, minimumCounts, acceptableDimensionGeometrys);
if (geometryRefs2d == TechDraw::isInvalid) {
if (geometryRefs2d == DimensionGeometry::isInvalid) {
QMessageBox::warning(Gui::getMainWindow(),
QObject::tr("Incorrect Selection"),
QObject::tr("Can not make 2D extent dimension from selection"));
@@ -2137,14 +2138,14 @@ void execExtent(Gui::Command* cmd, const std::string& dimType)
}
//what 3d geometry configuration did we receive?
DimensionGeometryType geometryRefs3d;
if (geometryRefs2d == TechDraw::isViewReference && !references3d.empty()) {
DimensionGeometry geometryRefs3d;
if (geometryRefs2d == DimensionGeometry::isViewReference && !references3d.empty()) {
geometryRefs3d = validateDimSelection3d(partFeat,
references3d,
acceptableGeometry,
minimumCounts,
acceptableDimensionGeometrys);
if (geometryRefs3d == isInvalid) {
if (geometryRefs3d == DimensionGeometry::isInvalid) {
QMessageBox::warning(Gui::getMainWindow(),
QObject::tr("Incorrect Selection"),
QObject::tr("Can not make 3D extent dimension from selection"));
@@ -2380,7 +2381,7 @@ void CreateTechDrawCommandsDims()
//Common code to build a dimension feature
void execDim(Gui::Command* cmd, std::string type, StringVector acceptableGeometry, std::vector<int> minimumCounts, std::vector<DimensionGeometryType> acceptableDimensionGeometrys)
void execDim(Gui::Command* cmd, std::string type, StringVector acceptableGeometry, std::vector<int> minimumCounts, std::vector<DimensionGeometry> acceptableDimensionGeometrys)
{
bool result = _checkDrawViewPart(cmd);
if (!result) {
@@ -2396,9 +2397,9 @@ void execDim(Gui::Command* cmd, std::string type, StringVector acceptableGeometr
TechDraw::getReferencesFromSelection(references2d, references3d);
//what 2d geometry configuration did we receive?
DimensionGeometryType geometryRefs2d = validateDimSelection(
DimensionGeometry geometryRefs2d = validateDimSelection(
references2d, acceptableGeometry, minimumCounts, acceptableDimensionGeometrys);
if (geometryRefs2d == TechDraw::isInvalid) {
if (geometryRefs2d == DimensionGeometry::isInvalid) {
QMessageBox::warning(Gui::getMainWindow(),
QObject::tr("Incorrect Selection"),
QObject::tr("Can not make 2D dimension from selection"));
@@ -2406,15 +2407,15 @@ void execDim(Gui::Command* cmd, std::string type, StringVector acceptableGeometr
}
//what 3d geometry configuration did we receive?
DimensionGeometryType geometryRefs3d{TechDraw::isInvalid};
if (geometryRefs2d == TechDraw::isViewReference && !references3d.empty()) {
DimensionGeometry geometryRefs3d{DimensionGeometry::isInvalid};
if (geometryRefs2d == DimensionGeometry::isViewReference && !references3d.empty()) {
geometryRefs3d = validateDimSelection3d(partFeat,
references3d,
acceptableGeometry,
minimumCounts,
acceptableDimensionGeometrys);
if (geometryRefs3d == TechDraw::isInvalid) {
if (geometryRefs3d == DimensionGeometry::isInvalid) {
QMessageBox::warning(Gui::getMainWindow(),
QObject::tr("Incorrect Selection"),
QObject::tr("Can not make 3D dimension from selection"));
@@ -2427,7 +2428,7 @@ void execDim(Gui::Command* cmd, std::string type, StringVector acceptableGeometr
//errors and warnings
if (type == "Radius" || type == "Diameter") {
if (geometryRefs2d == isEllipse || geometryRefs3d == isEllipse) {
if (geometryRefs2d == DimensionGeometry::isEllipse || geometryRefs3d == DimensionGeometry::isEllipse) {
QMessageBox::StandardButton result = QMessageBox::warning(
Gui::getMainWindow(),
QObject::tr("Ellipse Curve Warning"),
@@ -2438,7 +2439,7 @@ void execDim(Gui::Command* cmd, std::string type, StringVector acceptableGeometr
return;
}
}
if (geometryRefs2d == isBSplineCircle || geometryRefs3d == isBSplineCircle) {
if (geometryRefs2d == DimensionGeometry::isBSplineCircle || geometryRefs3d == DimensionGeometry::isBSplineCircle) {
QMessageBox::StandardButton result = QMessageBox::warning(
Gui::getMainWindow(),
QObject::tr("B-spline Curve Warning"),
@@ -2449,7 +2450,7 @@ void execDim(Gui::Command* cmd, std::string type, StringVector acceptableGeometr
return;
}
}
if (geometryRefs2d == isBSpline || geometryRefs3d == isBSpline) {
if (geometryRefs2d == DimensionGeometry::isBSpline || geometryRefs3d == DimensionGeometry::isBSpline) {
QMessageBox::critical(
Gui::getMainWindow(),
QObject::tr("B-spline Curve Error"),

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

@@ -40,6 +40,7 @@
using namespace TechDraw;
using namespace Measure;
using DU = DrawUtil;
using DimensionGeometry = TechDraw::DimensionGeometry;
TechDraw::DrawViewPart* TechDraw::getReferencesFromSelection(ReferenceVector& references2d,
ReferenceVector& references3d)
@@ -95,11 +96,11 @@ TechDraw::DrawViewPart* TechDraw::getReferencesFromSelection(ReferenceVector& re
}
//! verify that the proposed references contains valid geometries from a 2d DrawViewPart.
DimensionGeometryType TechDraw::validateDimSelection(
DimensionGeometry TechDraw::validateDimSelection(
const ReferenceVector& references, //[(dvp*, std::string),...,(dvp*, std::string)]
const StringVector& acceptableGeometry,//"Edge", "Vertex", etc
const std::vector<int>& minimumCounts, //how many of each geometry are needed for a good dimension
const std::vector<DimensionGeometryType>& acceptableDimensionGeometrys)//isVertical, isHorizontal, ...
const std::vector<DimensionGeometry>& acceptableDimensionGeometrys)//isVertical, isHorizontal, ...
{
StringVector subNames;
TechDraw::DrawViewPart* dvpSave(nullptr);
@@ -114,18 +115,18 @@ DimensionGeometryType TechDraw::validateDimSelection(
}
if (!dvpSave) {
//must have 1 DVP in selection
return isInvalid;
return DimensionGeometry::isInvalid;
}
if (subNames.empty()) {
//no geometry referenced. can not make a dim from this mess. We are being called to validate
//a selection for a 3d reference
return isViewReference;
return DimensionGeometry::isViewReference;
}
if (subNames.front().empty()) {
//can this still happen?
return isViewReference;
return DimensionGeometry::isViewReference;
}
//check for invalid geometry descriptors in the subNames
@@ -133,7 +134,7 @@ DimensionGeometryType TechDraw::validateDimSelection(
acceptableGeometry.end());
if (!TechDraw::validateSubnameList(subNames, acceptableGeometrySet)) {
//can not make a dimension from this
return isInvalid;
return DimensionGeometry::isInvalid;
}
//check for wrong number of geometry
@@ -141,7 +142,7 @@ DimensionGeometryType TechDraw::validateDimSelection(
GeomCountMap minimumCountMap = loadRequiredCounts(acceptableGeometry, minimumCounts);
if (!checkGeometryOccurrences(subNames, minimumCountMap)) {
//too many or too few geometry descriptors.
return isInvalid;
return DimensionGeometry::isInvalid;
}
//we have a (potentially valid collection of 2d geometry
@@ -151,7 +152,7 @@ DimensionGeometryType TechDraw::validateDimSelection(
valid2dReferences.push_back(validEntry);
}
DimensionGeometryType foundGeometry = getGeometryConfiguration(valid2dReferences);
DimensionGeometry foundGeometry = getGeometryConfiguration(valid2dReferences);
if (acceptableDimensionGeometrys.empty()) {
//if the list is empty, we are accepting anything
return foundGeometry;
@@ -162,16 +163,16 @@ DimensionGeometryType TechDraw::validateDimSelection(
}
}
return isInvalid;
return DimensionGeometry::isInvalid;
}
//! verify that the proposed references contains valid geometries from non-TechDraw objects.
DimensionGeometryType TechDraw::validateDimSelection3d(
DimensionGeometry TechDraw::validateDimSelection3d(
TechDraw::DrawViewPart* dvp,
const ReferenceVector& references, //[(dvp*, std::string),...,(dvp*, std::string)]
const StringVector& acceptableGeometry,//"Edge", "Vertex", etc
const std::vector<int>& minimumCounts, //how many of each geometry are needed for a good dimension
const std::vector<DimensionGeometryType>& acceptableDimensionGeometrys)//isVertical, isHorizontal, ...
const std::vector<DimensionGeometry>& acceptableDimensionGeometrys)//isVertical, isHorizontal, ...
{
StringVector subNames;
for (auto& ref : references) {
@@ -185,18 +186,18 @@ DimensionGeometryType TechDraw::validateDimSelection3d(
acceptableGeometry.end());
if (!TechDraw::validateSubnameList(subNames, acceptableGeometrySet)) {
//can not make a dimension from this
return isInvalid;
return DimensionGeometry::isInvalid;
}
//check for wrong number of geometry
GeomCountMap minimumCountMap = loadRequiredCounts(acceptableGeometry, minimumCounts);
if (!checkGeometryOccurrences(subNames, minimumCountMap)) {
//too many or too few geometry descriptors.
return isInvalid;
return DimensionGeometry::isInvalid;
}
//we have a (potentially valid collection of 3d geometry
DimensionGeometryType foundGeometry = getGeometryConfiguration3d(dvp, references);
DimensionGeometry foundGeometry = getGeometryConfiguration3d(dvp, references);
if (acceptableDimensionGeometrys.empty()) {
//if the list is empty, we are accepting anything
return foundGeometry;
@@ -207,7 +208,7 @@ DimensionGeometryType TechDraw::validateDimSelection3d(
}
}
return isInvalid;
return DimensionGeometry::isInvalid;
}
bool TechDraw::validateSubnameList(StringVector subNames, GeometrySet acceptableGeometrySet)
{
@@ -263,36 +264,36 @@ bool TechDraw::checkGeometryOccurrences(StringVector subNames, GeomCountMap keye
}
//return the first valid configuration contained in the already validated references
DimensionGeometryType TechDraw::getGeometryConfiguration(ReferenceVector valid2dReferences)
DimensionGeometry TechDraw::getGeometryConfiguration(ReferenceVector valid2dReferences)
{
DimensionGeometryType config = isValidHybrid(valid2dReferences);
if (config > isInvalid) {
DimensionGeometry config = isValidHybrid(valid2dReferences);
if (config > DimensionGeometry::isInvalid) {
return config;
}
config = isValidMultiEdge(valid2dReferences);
if (config > isInvalid) {
if (config > DimensionGeometry::isInvalid) {
return config;
}
config = isValidVertexes(valid2dReferences);
if (config > isInvalid) {
if (config > DimensionGeometry::isInvalid) {
return config;
}
config = isValidSingleEdge(valid2dReferences.front());
if (config > isInvalid) {
if (config > DimensionGeometry::isInvalid) {
return config;
}
config = isValidSingleFace(valid2dReferences.front());
if (config > isInvalid) {
if (config > DimensionGeometry::isInvalid) {
return config;
}
// no valid configuration found
return isInvalid;
return DimensionGeometry::isInvalid;
}
//return the first valid configuration contained in the already validated references
DimensionGeometryType TechDraw::getGeometryConfiguration3d(DrawViewPart* dvp,
DimensionGeometry TechDraw::getGeometryConfiguration3d(DrawViewPart* dvp,
ReferenceVector valid3dReferences)
{
//first we check for whole object references
@@ -307,37 +308,37 @@ DimensionGeometryType TechDraw::getGeometryConfiguration3d(DrawViewPart* dvp,
}
if (subElementRefs.empty()) {
//only whole object references
return isMultiEdge;
return DimensionGeometry::isMultiEdge;
}
if (!wholeObjectRefs.empty()) {
//mix of whole object and subelement refs
return isMultiEdge;//??? correct ???
return DimensionGeometry::isMultiEdge;//??? correct ???
}
//only have subelement refs
DimensionGeometryType config = isValidMultiEdge3d(dvp, valid3dReferences);
if (config > isInvalid) {
DimensionGeometry config = isValidMultiEdge3d(dvp, valid3dReferences);
if (config > DimensionGeometry::isInvalid) {
return config;
}
config = isValidVertexes3d(dvp, valid3dReferences);
if (config > isInvalid) {
if (config > DimensionGeometry::isInvalid) {
return config;
}
config = isValidSingleEdge3d(dvp, valid3dReferences.front());
if (config > isInvalid) {
if (config > DimensionGeometry::isInvalid) {
return config;
}
config = isValidSingleFace3d(dvp, valid3dReferences.front());
if (config > isInvalid) {
if (config > DimensionGeometry::isInvalid) {
return config;
}
config = isValidHybrid3d(dvp, valid3dReferences);
if (config > isInvalid) {
if (config > DimensionGeometry::isInvalid) {
return config;
}
// no valid configuration found
return isInvalid;
return DimensionGeometry::isInvalid;
}
//fill the GeomCountMap with pairs made from corresponding items in acceptableGeometry
@@ -359,62 +360,62 @@ GeomCountMap TechDraw::loadRequiredCounts(const StringVector& acceptableGeometry
}
//! verify that Selection contains a valid Geometry for a single Edge Dimension
DimensionGeometryType TechDraw::isValidSingleEdge(ReferenceEntry ref)
DimensionGeometry TechDraw::isValidSingleEdge(ReferenceEntry ref)
{
auto objFeat(dynamic_cast<TechDraw::DrawViewPart*>(ref.getObject()));
if (!objFeat) {
return isInvalid;
return DimensionGeometry::isInvalid;
}
//the Name starts with "Edge"
std::string geomName = DrawUtil::getGeomTypeFromName(ref.getSubName());
if (geomName != "Edge") {
return isInvalid;
return DimensionGeometry::isInvalid;
}
//the geometry exists (redundant?)
int GeoId(TechDraw::DrawUtil::getIndexFromName(ref.getSubName()));
TechDraw::BaseGeomPtr geom = objFeat->getGeomByIndex(GeoId);
if (!geom) {
return isInvalid;
return DimensionGeometry::isInvalid;
}
if (geom->getGeomType() == GeomType::GENERIC) {
TechDraw::GenericPtr gen1 = std::static_pointer_cast<TechDraw::Generic>(geom);
if (gen1->points.size() < 2) {
return isInvalid;
return DimensionGeometry::isInvalid;
}
Base::Vector3d line = gen1->points.at(1) - gen1->points.at(0);
if (fabs(line.y) < FLT_EPSILON) {
return TechDraw::isHorizontal;
return DimensionGeometry::isHorizontal;
} else if (fabs(line.x) < FLT_EPSILON) {
return TechDraw::isVertical;
return DimensionGeometry::isHorizontal;
} else {
return TechDraw::isDiagonal;
return DimensionGeometry::isDiagonal;
}
} else if (geom->getGeomType() == GeomType::CIRCLE || geom->getGeomType() == GeomType::ARCOFCIRCLE) {
return isCircle;
return DimensionGeometry::isCircle;
} else if (geom->getGeomType() == GeomType::ELLIPSE || geom->getGeomType() == GeomType::ARCOFELLIPSE) {
return isEllipse;
return DimensionGeometry::isEllipse;
} else if (geom->getGeomType() == GeomType::BSPLINE) {
TechDraw::BSplinePtr spline = std::static_pointer_cast<TechDraw::BSpline>(geom);
if (spline->isCircle()) {
return isBSplineCircle;
return DimensionGeometry::isBSplineCircle;
} else {
return isBSpline;
return DimensionGeometry::isBSpline;
}
}
return isInvalid;
return DimensionGeometry::isInvalid;
}
//! verify that Selection contains a valid Geometry for a single Edge Dimension
DimensionGeometryType TechDraw::isValidSingleEdge3d(DrawViewPart* dvp, ReferenceEntry ref)
DimensionGeometry TechDraw::isValidSingleEdge3d(DrawViewPart* dvp, ReferenceEntry ref)
{
(void)dvp;
//the Name starts with "Edge"
std::string geomName = DrawUtil::getGeomTypeFromName(ref.getSubName());
if (geomName != "Edge") {
return isInvalid;
return DimensionGeometry::isInvalid;
}
TopoDS_Shape refShape = ref.getGeometry();
@@ -431,85 +432,85 @@ DimensionGeometryType TechDraw::isValidSingleEdge3d(DrawViewPart* dvp, Reference
point1 = dvp->projectPoint(point1);
Base::Vector3d line = point1 - point0;
if (fabs(line.y) < FLT_EPSILON) {
return TechDraw::isHorizontal;
return DimensionGeometry::isHorizontal;
} else if (fabs(line.x) < FLT_EPSILON) {
return TechDraw::isVertical;
return DimensionGeometry::isHorizontal;
}
// else if (fabs(line.z) < FLT_EPSILON) {
// return TechDraw::isZLimited;
// }
else {
return TechDraw::isDiagonal;
return DimensionGeometry::isDiagonal;
}
} else if (adapt.GetType() == GeomAbs_Circle) {
return isCircle;
return DimensionGeometry::isCircle;
} else if (adapt.GetType() == GeomAbs_Ellipse) {
return isEllipse;
return DimensionGeometry::isEllipse;
} else if (adapt.GetType() == GeomAbs_BSplineCurve) {
if (GeometryUtils::isCircle(occEdge)) {
return isBSplineCircle;
return DimensionGeometry::isBSplineCircle;
} else {
return isBSpline;
return DimensionGeometry::isBSpline;
}
}
return isInvalid;
return DimensionGeometry::isInvalid;
}
//! verify that Selection contains a valid Geometry for a single Edge Dimension
DimensionGeometryType TechDraw::isValidSingleFace(ReferenceEntry ref)
DimensionGeometry TechDraw::isValidSingleFace(ReferenceEntry ref)
{
auto objFeat(dynamic_cast<TechDraw::DrawViewPart*>(ref.getObject()));
if (!objFeat) {
return isInvalid;
return DimensionGeometry::isInvalid;
}
//the Name starts with "Edge"
std::string geomName = DrawUtil::getGeomTypeFromName(ref.getSubName());
if (geomName != "Face") {
return isInvalid;
return DimensionGeometry::isInvalid;
}
auto geom = objFeat->getFace(ref.getSubName());
if (!geom) {
return isInvalid;
return DimensionGeometry::isInvalid;
}
return isFace;
return DimensionGeometry::isFace;
}
//! verify that Selection contains a valid Geometry for a single Edge Dimension
DimensionGeometryType TechDraw::isValidSingleFace3d(DrawViewPart* dvp, ReferenceEntry ref)
DimensionGeometry TechDraw::isValidSingleFace3d(DrawViewPart* dvp, ReferenceEntry ref)
{
(void)dvp;
//the Name starts with "Edge"
std::string geomName = DrawUtil::getGeomTypeFromName(ref.getSubName());
if (geomName != "Face") {
return isInvalid;
return DimensionGeometry::isInvalid;
}
TopoDS_Shape refShape = ref.getGeometry();
if (refShape.IsNull() || refShape.ShapeType() != TopAbs_FACE) {
Base::Console().Warning("Geometry for reference is not a face.\n");
return isInvalid;
return DimensionGeometry::isInvalid;
}
return isFace;
return DimensionGeometry::isFace;
}
//! verify that the edge references can make a dimension. Currently only extent
//! dimensions support more than 2 edges
DimensionGeometryType TechDraw::isValidMultiEdge(ReferenceVector refs)
DimensionGeometry TechDraw::isValidMultiEdge(ReferenceVector refs)
{
//there has to be at least 2
if (refs.size() < 2) {
return isInvalid;
return DimensionGeometry::isInvalid;
}
//they all must start with "Edge"
const std::string matchToken{"Edge"};
if (!refsMatchToken(refs, matchToken)) {
return isInvalid;
return DimensionGeometry::isInvalid;
}
auto objFeat0(dynamic_cast<TechDraw::DrawViewPart*>(refs.at(0).getObject()));
@@ -520,7 +521,7 @@ DimensionGeometryType TechDraw::isValidMultiEdge(ReferenceVector refs)
if (refs.size() > 2) {
//many edges, must be an extent?
return isMultiEdge;
return DimensionGeometry::isMultiEdge;
}
//exactly 2 edges. could be angle, could be distance
@@ -533,7 +534,7 @@ DimensionGeometryType TechDraw::isValidMultiEdge(ReferenceVector refs)
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
return isInvalid; //not supported yet
return DimensionGeometry::isInvalid; //not supported yet
}
Base::Vector3d line0 = gen0->points.at(1) - gen0->points.at(0);
line0.Normalize();
@@ -541,27 +542,27 @@ DimensionGeometryType TechDraw::isValidMultiEdge(ReferenceVector refs)
line1.Normalize();
double dot = fabs(line0.Dot(line1));
if (DU::fpCompare(dot, 1.0, EWTOLERANCE)) {
return isDiagonal; //distance || line
return DimensionGeometry::isDiagonal; //distance || line
}
return isAngle; //angle or distance
return DimensionGeometry::isAngle; //angle or distance
}
return isDiagonal; //two edges, not both straight lines
return DimensionGeometry::isDiagonal; //two edges, not both straight lines
}
//! verify that the edge references can make a dimension. Currently only extent
//! dimensions support more than 2 edges
DimensionGeometryType TechDraw::isValidMultiEdge3d(DrawViewPart* dvp, ReferenceVector refs)
DimensionGeometry TechDraw::isValidMultiEdge3d(DrawViewPart* dvp, ReferenceVector refs)
{
(void)dvp;
//there has to be at least 2
if (refs.size() < 2) {
return isInvalid;
return DimensionGeometry::isInvalid;
}
//they all must start with "Edge"
const std::string matchToken{"Edge"};
if (!refsMatchToken(refs, matchToken)) {
return isInvalid;
return DimensionGeometry::isInvalid;
}
std::vector<TopoDS_Edge> edges;
@@ -569,7 +570,7 @@ DimensionGeometryType TechDraw::isValidMultiEdge3d(DrawViewPart* dvp, ReferenceV
std::vector<TopoDS_Shape> shapesAll = ShapeExtractor::getShapesFromObject(ref.getObject());
if (shapesAll.empty()) {
//reference has no geometry
return isInvalid;
return DimensionGeometry::isInvalid;
}
}
std::vector<TopoDS_Edge> edgesAll;
@@ -577,19 +578,19 @@ DimensionGeometryType TechDraw::isValidMultiEdge3d(DrawViewPart* dvp, ReferenceV
for (auto& ref : refs) {
TopoDS_Shape geometry = ref.getGeometry();
if (geometry.ShapeType() != TopAbs_EDGE) {
return isInvalid;
return DimensionGeometry::isInvalid;
}
TopoDS_Edge edge = TopoDS::Edge(geometry);
BRepAdaptor_Curve adapt(edge);
if (adapt.GetType() != GeomAbs_Line) {
//not a line, so this must be an extent dim?
return isMultiEdge;
return DimensionGeometry::isMultiEdge;
}
edgesAll.push_back(edge);
}
if (edgesAll.size() > 2) {
//must be an extent dimension of lines?
return isMultiEdge;
return DimensionGeometry::isMultiEdge;
}
if (edgesAll.size() == 2) {
@@ -604,17 +605,17 @@ DimensionGeometryType TechDraw::isValidMultiEdge3d(DrawViewPart* dvp, ReferenceV
auto dot = fabs(line0.Dot(line1));
if (DU::fpCompare(dot, 1.0, EWTOLERANCE)) {
//lines are parallel, must be distance dim
return isDiagonal;
return DimensionGeometry::isDiagonal;
}
//lines are skew, could be angle, could be distance?
return isAngle;
return DimensionGeometry::isAngle;
}
return isInvalid;
return DimensionGeometry::isInvalid;
}
//! verify that the vertex references can make a dimension
DimensionGeometryType TechDraw::isValidVertexes(ReferenceVector refs)
DimensionGeometry TechDraw::isValidVertexes(ReferenceVector refs)
{
TechDraw::DrawViewPart* dvp(dynamic_cast<TechDraw::DrawViewPart*>(refs.front().getObject()));
if (!dvp) {
@@ -624,7 +625,7 @@ DimensionGeometryType TechDraw::isValidVertexes(ReferenceVector refs)
const std::string matchToken{"Vertex"};
if (!refsMatchToken(refs, matchToken)) {
return isInvalid;
return DimensionGeometry::isInvalid;
}
if (refs.size() == 2) {
@@ -633,28 +634,28 @@ DimensionGeometryType TechDraw::isValidVertexes(ReferenceVector refs)
TechDraw::VertexPtr v1 = dvp->getVertex(refs.at(1).getSubName());
Base::Vector3d line = v1->point() - v0->point();
if (fabs(line.y) < FLT_EPSILON) {
return isHorizontal;
return DimensionGeometry::isHorizontal;
} else if (fabs(line.x) < FLT_EPSILON) {
return isVertical;
return DimensionGeometry::isHorizontal;
} else {
return isDiagonal;
return DimensionGeometry::isDiagonal;
}
} else if (refs.size() == 3) {
//three vertices make an angle dimension
return isAngle3Pt;
return DimensionGeometry::isAngle3Pt;
}
// did not find a valid configuration
return isInvalid;
return DimensionGeometry::isInvalid;
}
//! verify that the vertex references can make a dimension
DimensionGeometryType TechDraw::isValidVertexes3d(DrawViewPart* dvp, ReferenceVector refs)
DimensionGeometry TechDraw::isValidVertexes3d(DrawViewPart* dvp, ReferenceVector refs)
{
(void)dvp;
const std::string matchToken{"Vertex"};
if (!refsMatchToken(refs, matchToken)) {
return isInvalid;
return DimensionGeometry::isInvalid;
}
if (refs.size() == 2) {
@@ -663,7 +664,7 @@ DimensionGeometryType TechDraw::isValidVertexes3d(DrawViewPart* dvp, ReferenceVe
TopoDS_Shape geometry1 = refs.at(1).getGeometry();
if (geometry0.IsNull() || geometry1.IsNull() || geometry0.ShapeType() != TopAbs_VERTEX
|| geometry1.ShapeType() != TopAbs_VERTEX) {
return isInvalid;
return DimensionGeometry::isInvalid;
}
Base::Vector3d point0 = DU::toVector3d(BRep_Tool::Pnt(TopoDS::Vertex(geometry0)));
point0 = dvp->projectPoint(point0);
@@ -671,29 +672,29 @@ DimensionGeometryType TechDraw::isValidVertexes3d(DrawViewPart* dvp, ReferenceVe
point1 = dvp->projectPoint(point1);
Base::Vector3d line = point1 - point0;
if (fabs(line.y) < FLT_EPSILON) {
return isHorizontal;
return DimensionGeometry::isHorizontal;
} else if (fabs(line.x) < FLT_EPSILON) {
return isVertical;
return DimensionGeometry::isHorizontal;
// } else if(fabs(line.z) < FLT_EPSILON) {
// return isZLimited;
} else {
return isDiagonal;
return DimensionGeometry::isDiagonal;
}
} else if (refs.size() == 3) {
//three vertices make an angle dimension
//we could check here that all the geometries are Vertex
return isAngle3Pt;
return DimensionGeometry::isAngle3Pt;
}
// did not find a valid configuration
return isInvalid;
return DimensionGeometry::isInvalid;
}
//! verify that the mixed bag (ex Vertex-Edge) of references can make a dimension
DimensionGeometryType TechDraw::isValidHybrid(ReferenceVector refs)
DimensionGeometry TechDraw::isValidHybrid(ReferenceVector refs)
{
if (refs.empty()) {
return isInvalid;
return DimensionGeometry::isInvalid;
}
int vertexCount(0);
@@ -707,15 +708,15 @@ DimensionGeometryType TechDraw::isValidHybrid(ReferenceVector refs)
}
}
if (vertexCount > 0 && edgeCount > 0) {
//must be a diagonal dim? could it be isHorizontal or isVertical?
return isHybrid;
//must be a diagonal dim? could it be DimensionGeometry::isHorizontal or isVertical?
return DimensionGeometry::isHybrid;
}
return isInvalid;
return DimensionGeometry::isInvalid;
}
//! verify that the mixed bag (ex Vertex-Edge) of references can make a dimension
DimensionGeometryType TechDraw::isValidHybrid3d(DrawViewPart* dvp, ReferenceVector refs)
DimensionGeometry TechDraw::isValidHybrid3d(DrawViewPart* dvp, ReferenceVector refs)
{
(void)dvp;
//we can reuse the 2d check here.
@@ -723,38 +724,38 @@ DimensionGeometryType TechDraw::isValidHybrid3d(DrawViewPart* dvp, ReferenceVect
}
//handle situations where revised geometry type is valid but not suitable for existing dimType
long int TechDraw::mapGeometryTypeToDimType(long int dimType, DimensionGeometryType geometry2d,
DimensionGeometryType geometry3d)
long int TechDraw::mapGeometryTypeToDimType(long int dimType, DimensionGeometry geometry2d,
DimensionGeometry geometry3d)
{
if (geometry2d == isInvalid && geometry3d == isInvalid) {
if (geometry2d == DimensionGeometry::isInvalid && geometry3d == DimensionGeometry::isInvalid) {
//probably an error, but we can't do anything with this
return dimType;
}
if (geometry2d == isViewReference && geometry3d != isInvalid) {
if (geometry2d == DimensionGeometry::isViewReference && geometry3d != DimensionGeometry::isInvalid) {
switch (geometry3d) {
case isDiagonal:
case DimensionGeometry::isDiagonal:
return DrawViewDimension::Distance;
case isHorizontal:
case DimensionGeometry::isHorizontal:
return DrawViewDimension::DistanceX;
case isVertical:
case DimensionGeometry::isVertical:
return DrawViewDimension::DistanceY;
case isAngle:
case DimensionGeometry::isAngle:
return DrawViewDimension::Angle;
case isAngle3Pt:
case DimensionGeometry::isAngle3Pt:
return DrawViewDimension::Angle3Pt;
}
} else if (geometry2d != isViewReference) {
} else if (geometry2d != DimensionGeometry::isViewReference) {
switch (geometry2d) {
case isDiagonal:
case DimensionGeometry::isDiagonal:
return DrawViewDimension::Distance;
case isHorizontal:
case DimensionGeometry::isHorizontal:
return DrawViewDimension::DistanceX;
case isVertical:
case DimensionGeometry::isVertical:
return DrawViewDimension::DistanceY;
case isAngle:
case DimensionGeometry::isAngle:
return DrawViewDimension::Angle;
case isAngle3Pt:
case DimensionGeometry::isAngle3Pt:
return DrawViewDimension::Angle3Pt;
}
}

72
src/Mod/TechDraw/Gui/DimensionValidators.h
View File

@@ -39,67 +39,65 @@ using GeomCountVector = std::vector<GeomCount>;
using GeomCountMap = std::map<std::string, int>;
using GeometrySet = std::unordered_set<std::string>; //queryable unique set of geometrty descriptors
using DimensionGeometryType = int;
namespace TechDraw
{
class DrawViewPart;
enum DimensionGeometryEnum {
isInvalid,
isHorizontal,
isVertical,
isDiagonal,
isCircle,
isEllipse,
isBSplineCircle,
isBSpline,
isAngle,
isAngle3Pt,
isMultiEdge,
isZLimited,
isHybrid,
isFace,
isViewReference //never needs to be specified in the acceptable list
};
enum class DimensionGeometry {
isInvalid,
isHorizontal,
isVertical,
isDiagonal,
isCircle,
isEllipse,
isBSplineCircle,
isBSpline,
isAngle,
isAngle3Pt,
isMultiEdge,
isZLimited,
isHybrid,
isFace,
isViewReference //never needs to be specified in the acceptable list
};
DrawViewPart* getReferencesFromSelection(ReferenceVector& references2d,
ReferenceVector& references3d);
DimensionGeometryType validateDimSelection(const ReferenceVector& references,
DimensionGeometry validateDimSelection(const ReferenceVector& references,
const StringVector& acceptableGeometry,//"Edge", "Vertex", etc
const std::vector<int>& minimumCounts, //how many of each geometry are needed for a good dimension
const std::vector<DimensionGeometryType>& acceptableDimensionGeometrys);//isVertical, isHorizontal, ...
DimensionGeometryType validateDimSelection3d(DrawViewPart* dvp,
const std::vector<DimensionGeometry>& acceptableDimensionGeometrys);//isVertical, isHorizontal, ...
DimensionGeometry validateDimSelection3d(DrawViewPart* dvp,
const ReferenceVector& references,
const StringVector& acceptableGeometry, //"Edge", "Vertex", etc
const std::vector<int>& minimumCounts, //how many of each geometry are needed for a good dimension
const std::vector<DimensionGeometryType>& acceptableDimensionGeometrys);//isVertical, isHorizontal, ...
const std::vector<DimensionGeometry>& acceptableDimensionGeometrys);//isVertical, isHorizontal, ...
bool validateSubnameList(StringVector subNames, GeometrySet acceptableGeometrySet);
DimensionGeometryType getGeometryConfiguration(ReferenceVector valid2dReferences);
DimensionGeometryType getGeometryConfiguration3d(DrawViewPart* dvp,
DimensionGeometry getGeometryConfiguration(ReferenceVector valid2dReferences);
DimensionGeometry getGeometryConfiguration3d(DrawViewPart* dvp,
ReferenceVector valid3dReferences);
GeomCountMap loadRequiredCounts(const StringVector& acceptableGeometry,
const std::vector<int>& minimumCouts);
bool checkGeometryOccurrences(StringVector subNames, GeomCountMap keyedMinimumCounts);
DimensionGeometryType isValidVertexes(ReferenceVector refs);
DimensionGeometryType isValidMultiEdge(ReferenceVector refs);
DimensionGeometryType isValidSingleEdge(ReferenceEntry ref);
DimensionGeometryType isValidSingleFace(ReferenceEntry ref);
DimensionGeometryType isValidHybrid(ReferenceVector refs);
DimensionGeometry isValidVertexes(ReferenceVector refs);
DimensionGeometry isValidMultiEdge(ReferenceVector refs);
DimensionGeometry isValidSingleEdge(ReferenceEntry ref);
DimensionGeometry isValidSingleFace(ReferenceEntry ref);
DimensionGeometry isValidHybrid(ReferenceVector refs);
DimensionGeometryType isValidVertexes3d(DrawViewPart* dvp, ReferenceVector refs);
DimensionGeometryType isValidMultiEdge3d(DrawViewPart* dvp, ReferenceVector refs);
DimensionGeometryType isValidSingleEdge3d(DrawViewPart* dvp, ReferenceEntry ref);
DimensionGeometryType isValidSingleFace3d(DrawViewPart* dvp, ReferenceEntry ref);
DimensionGeometryType isValidHybrid3d(DrawViewPart* dvp, ReferenceVector refs);
DimensionGeometry isValidVertexes3d(DrawViewPart* dvp, ReferenceVector refs);
DimensionGeometry isValidMultiEdge3d(DrawViewPart* dvp, ReferenceVector refs);
DimensionGeometry isValidSingleEdge3d(DrawViewPart* dvp, ReferenceEntry ref);
DimensionGeometry isValidSingleFace3d(DrawViewPart* dvp, ReferenceEntry ref);
DimensionGeometry isValidHybrid3d(DrawViewPart* dvp, ReferenceVector refs);
long int mapGeometryTypeToDimType(long int dimType, DimensionGeometryType geometry2d,
DimensionGeometryType geometry3d);
long int mapGeometryTypeToDimType(long int dimType, DimensionGeometry geometry2d,
DimensionGeometry geometry3d);
bool refsMatchToken(const ReferenceVector& refs, const std::string& matchToken);

12
src/Mod/TechDraw/Gui/TaskDimRepair.cpp
View File

@@ -128,21 +128,21 @@ void TaskDimRepair::slotUseSelection()
StringVector acceptableGeometry({ "Edge", "Vertex", "Face" });
std::vector<int> minimumCounts({1, 1, 1});
std::vector<DimensionGeometryType> acceptableDimensionGeometrys;//accept anything
DimensionGeometryType geometryRefs2d = validateDimSelection(
std::vector<DimensionGeometry> acceptableDimensionGeometrys;//accept anything
DimensionGeometry geometryRefs2d = validateDimSelection(
references2d, acceptableGeometry, minimumCounts, acceptableDimensionGeometrys);
if (geometryRefs2d == isInvalid) {
if (geometryRefs2d == DimensionGeometry::isInvalid) {
QMessageBox::warning(Gui::getMainWindow(),
QObject::tr("Incorrect Selection"),
QObject::tr("Can not make dimension from selection"));
return;
}
//what 3d geometry configuration did we receive?
DimensionGeometryType geometryRefs3d(isInvalid);
if (geometryRefs2d == TechDraw::isViewReference && !references3d.empty()) {
DimensionGeometry geometryRefs3d(DimensionGeometry::isInvalid);
if (geometryRefs2d == DimensionGeometry::isViewReference && !references3d.empty()) {
geometryRefs3d = validateDimSelection3d(
dvp, references3d, acceptableGeometry, minimumCounts, acceptableDimensionGeometrys);
if (geometryRefs3d == isInvalid) {
if (geometryRefs3d == DimensionGeometry::isInvalid) {
QMessageBox::warning(Gui::getMainWindow(),
QObject::tr("Incorrect Selection"),
QObject::tr("Can not make dimension from selection"));