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

[PD] Use enum class for revolution method

Browse Source
This commit is contained in:
Ajinkya Dahale
2022-07-24 01:33:51 +05:30
parent 7a6927ca78
commit 796727fcd3
4 changed files with 73 additions and 54 deletions
Download Patch File Download Diff File Expand all files Collapse all files

65
src/Mod/PartDesign/App/FeatureRevolution.cpp
View File

@@ -125,7 +125,7 @@ App::DocumentObjectExecReturn *Revolution::execute()
if (sketchshape.IsNull())
return new App::DocumentObjectExecReturn(QT_TRANSLATE_NOOP("Exception", "Creating a face from sketch failed"));
std::string method(Type.getValueAsString());
RevolMethod method = methodFromString(Type.getValueAsString());
this->positionByPrevious();
TopLoc_Location invObjLoc = this->getLocation().Inverted();
@@ -147,9 +147,9 @@ App::DocumentObjectExecReturn *Revolution::execute()
TopoDS_Face supportface = getSupportFace();
supportface.Move(invObjLoc);
if (method == "UpToFace" || method == "UpToFirst" || method == "UpToLast") {
if (method == RevolMethod::ToFace || method == RevolMethod::ToFirst || method == RevolMethod::ToLast) {
TopoDS_Face upToFace;
if (method == "UpToFace") {
if (method == RevolMethod::ToFace) {
getFaceFromLinkSub(upToFace, UpToFace);
upToFace.Move(invObjLoc);
}
@@ -157,7 +157,7 @@ App::DocumentObjectExecReturn *Revolution::execute()
throw Base::RuntimeError("ProfileBased: Revolution up to first/last is not yet supported");
// TODO: This method is designed for extrusions. needs to be adapted for revolutions.
getUpToFace(upToFace, base, sketchshape, method, dir);
// getUpToFace(upToFace, base, supportface, sketchshape, method, dir);
TopoDS_Face supportface = getSupportFace();
supportface.Move(invObjLoc);
@@ -169,12 +169,12 @@ App::DocumentObjectExecReturn *Revolution::execute()
if (!Ex.More())
supportface = TopoDS_Face();
RevolMode mode = RevolMode::None;
generateRevolution(result, method, base, sketchshape, supportface, upToFace, gp_Ax1(pnt, dir), mode, Standard_True);
generateRevolution(result, base, sketchshape, supportface, upToFace, gp_Ax1(pnt, dir), method, mode, Standard_True);
}
else {
bool midplane = Midplane.getValue();
bool reversed = Reversed.getValue();
generateRevolution(result, sketchshape, method, gp_Ax1(pnt, dir), angle, angle2, midplane, reversed);
generateRevolution(result, sketchshape, gp_Ax1(pnt, dir), angle, angle2, midplane, reversed, method);
}
if (!result.IsNull()) {
@@ -238,20 +238,39 @@ void Revolution::updateAxis()
Axis.setValue(dir.x,dir.y,dir.z);
}
Revolution::RevolMethod Revolution::methodFromString(const std::string& methodStr)
{
if (methodStr == "Angle")
return RevolMethod::Dimension;
if (methodStr == "UpToLast")
return RevolMethod::ToLast;
if (methodStr == "ThroughAll")
return RevolMethod::ThroughAll;
if (methodStr == "UpToFirst")
return RevolMethod::ToFirst;
if (methodStr == "UpToFace")
return RevolMethod::ToFace;
if (methodStr == "TwoAngles")
return RevolMethod::TwoDimensions;
throw Base::ValueError("Revolution:: No such method");
return RevolMethod::Dimension;
}
void Revolution::generateRevolution(TopoDS_Shape& revol,
const TopoDS_Shape& sketchshape,
const std::string& method,
const gp_Ax1& axis,
const double angle,
const double angle2,
const bool midplane,
const bool reversed)
const bool reversed,
RevolMethod method)
{
if (method == "Angle" || method == "TwoAngles" || method == "ThroughAll") {
if (method == RevolMethod::Dimension || method == RevolMethod::TwoDimensions || method == RevolMethod::ThroughAll) {
double angleTotal = angle;
double angleOffset = 0.;
if (method == "TwoAngles") {
if (method == RevolMethod::TwoDimensions) {
// Rotate the face by `angle2`/`angle` to get "second" angle
angleTotal += angle2;
angleOffset = angle2 * -1.0;
@@ -270,7 +289,7 @@ void Revolution::generateRevolution(TopoDS_Shape& revol,
}
TopoDS_Shape from = sketchshape;
if (method == "TwoAngles" || midplane) {
if (method == RevolMethod::TwoDimensions || midplane) {
gp_Trsf mov;
mov.SetRotation(revolAx, angleOffset);
TopLoc_Location loc(mov);
@@ -289,23 +308,22 @@ void Revolution::generateRevolution(TopoDS_Shape& revol,
}
else {
std::stringstream str;
str << "ProfileBased: Internal error: Unknown method '"
<< method << "' for generateRevolution()";
str << "ProfileBased: Internal error: Unknown method for generateRevolution()";
throw Base::RuntimeError(str.str());
}
}
void Revolution::generateRevolution(TopoDS_Shape& revol,
const std::string& method,
const TopoDS_Shape& baseshape,
const TopoDS_Shape& profileshape,
const TopoDS_Face& supportface,
const TopoDS_Face& uptoface,
const gp_Ax1& axis,
RevolMethod method,
RevolMode Mode,
Standard_Boolean Modify)
{
if (method == "UpToFirst" || method == "UpToFace" || method == "UpToLast") {
if (method == RevolMethod::ToFirst || method == RevolMethod::ToFace || method == RevolMethod::ToLast) {
BRepFeat_MakeRevol RevolMaker;
TopoDS_Shape base = baseshape;
for (TopExp_Explorer xp(profileshape, TopAbs_FACE); xp.More(); xp.Next()) {
@@ -323,13 +341,12 @@ void Revolution::generateRevolution(TopoDS_Shape& revol,
}
else {
std::stringstream str;
str << "ProfileBased: Internal error: Unknown method '"
<< method << "' for generateRevolution()";
str << "ProfileBased: Internal error: Unknown method for generateRevolution()";
throw Base::RuntimeError(str.str());
}
}
void Revolution::updateProperties(const std::string &method)
void Revolution::updateProperties(RevolMethod method)
{
// disable settings that are not valid on the current method
// disable everything unless we are sure we need it
@@ -338,26 +355,26 @@ void Revolution::updateProperties(const std::string &method)
bool isMidplaneEnabled = false;
bool isReversedEnabled = false;
bool isUpToFaceEnabled = false;
if (method == "Angle") {
if (method == RevolMethod::Dimension) {
isAngleEnabled = true;
isMidplaneEnabled = true;
isReversedEnabled = !Midplane.getValue();
}
else if (method == "UpToLast") {
else if (method == RevolMethod::ToLast) {
isReversedEnabled = true;
}
else if (method == "ThroughAll") {
else if (method == RevolMethod::ThroughAll) {
isMidplaneEnabled = true;
isReversedEnabled = !Midplane.getValue();
}
else if (method == "UpToFirst") {
else if (method == RevolMethod::ToFirst) {
isReversedEnabled = true;
}
else if (method == "UpToFace") {
else if (method == RevolMethod::ToFace) {
isReversedEnabled = true;
isUpToFaceEnabled = true;
}
else if (method == "TwoAngles") {
else if (method == RevolMethod::TwoDimensions) {
isAngleEnabled = true;
isAngle2Enabled = true;
isReversedEnabled = true;

39
src/Mod/PartDesign/App/FeatureRevolution.h
View File

@@ -68,24 +68,21 @@ public:
/// suggests a value for Reversed flag so that material is always added to the support
bool suggestReversed();
enum class RevolMethod {
Dimension,
ThroughAll,
ToLast = ThroughAll,
ToFirst,
ToFace,
TwoDimensions
};
protected:
/// updates Axis from ReferenceAxis
void updateAxis();
static const App::PropertyAngle::Constraints floatAngle;
/**
* Generates a revolution of the input sketchshape and stores it in the given \a revol.
*/
void generateRevolution(TopoDS_Shape& revol,
const TopoDS_Shape& sketchshape,
const std::string& method,
const gp_Ax1& ax1,
const double angle,
const double angle2,
const bool midplane,
const bool reversed);
// See BRepFeat_MakeRevol
enum RevolMode {
CutFromBase = 0,
@@ -93,24 +90,38 @@ protected:
None = 2
};
RevolMethod methodFromString(const std::string& methodStr);
/**
* Generates a revolution of the input sketchshape and stores it in the given \a revol.
*/
void generateRevolution(TopoDS_Shape& revol,
const TopoDS_Shape& sketchshape,
const gp_Ax1& ax1,
const double angle,
const double angle2,
const bool midplane,
const bool reversed,
RevolMethod method);
/**
* Generates a revolution of the input \a profileshape.
* It will be a stand-alone solid created with BRepFeat_MakeRevol.
*/
void generateRevolution(TopoDS_Shape& revol,
const std::string& method,
const TopoDS_Shape& baseshape,
const TopoDS_Shape& profileshape,
const TopoDS_Face& supportface,
const TopoDS_Face& uptoface,
const gp_Ax1& ax1,
RevolMethod method,
RevolMode Mode,
Standard_Boolean Modify);
/**
* Disables settings that are not valid for the current method
*/
void updateProperties(const std::string &method);
void updateProperties(RevolMethod method);
private:
static const char* TypeEnums[];

14
src/Mod/PartDesign/Gui/TaskRevolutionParameters.cpp
View File

@@ -450,23 +450,23 @@ void TaskRevolutionParameters::onModeChanged(int index)
{
PartDesign::Revolution* pcRevolution = static_cast<PartDesign::Revolution*>(vp->getObject());
switch (static_cast<Modes>(index)) {
case Modes::Dimension:
switch (static_cast<PartDesign::Revolution::RevolMethod>(index)) {
case PartDesign::Revolution::RevolMethod::Dimension:
pcRevolution->Type.setValue("Angle");
// Avoid error message
// if (ui->revolveAngle->value() < Base::Quantity(Precision::Angular(), Base::Unit::Angle)) // TODO: Ensure radians/degree consistency
// ui->revolveAngle->setValue(5.0);
break;
case Modes::ToLast:
case PartDesign::Revolution::RevolMethod::ToLast:
pcRevolution->Type.setValue("UpToLast");
break;
case Modes::ToFirst:
case PartDesign::Revolution::RevolMethod::ToFirst:
pcRevolution->Type.setValue("UpToFirst");
break;
case Modes::ToFace:
case PartDesign::Revolution::RevolMethod::ToFace:
pcRevolution->Type.setValue("UpToFace");
break;
case Modes::TwoDimensions:
case PartDesign::Revolution::RevolMethod::TwoDimensions:
pcRevolution->Type.setValue("TwoAngles");
break;
}
@@ -550,7 +550,7 @@ void TaskRevolutionParameters::apply()
int mode = ui->changeMode->currentIndex();
FCMD_OBJ_CMD(tobj, "Type = " << mode);
QString facename = QString::fromLatin1("None");
if (static_cast<Modes>(mode) == Modes::ToFace) {
if (static_cast<PartDesign::Revolution::RevolMethod>(mode) == PartDesign::Revolution::RevolMethod::ToFace) {
facename = getFaceName();
}
FCMD_OBJ_CMD(tobj, "UpToFace = " << facename.toLatin1().data());

9
src/Mod/PartDesign/Gui/TaskRevolutionParameters.h
View File

@@ -49,15 +49,6 @@ public:
void apply() override;
enum class Modes {
Dimension,
ThroughAll,
ToLast = ThroughAll,
ToFirst,
ToFace,
TwoDimensions
};
/**
* @brief fillAxisCombo fills the combo and selects the item according to
* current value of revolution object's axis reference.