aRes->setImpl(new TopoDS_Shape(anEdge));
return aRes;
}
+
+boost::shared_ptr<GeomAPI_Shape> GeomAlgoAPI_EdgeBuilder::lineCircleArc(
+ boost::shared_ptr<GeomAPI_Pnt> theCenter,
+ boost::shared_ptr<GeomAPI_Pnt> theStartPoint,
+ boost::shared_ptr<GeomAPI_Pnt> theEndPoint,
+ boost::shared_ptr<GeomAPI_Dir> theNormal)
+{
+ const gp_Pnt& aCenter = theCenter->impl<gp_Pnt>();
+ const gp_Dir& aDir = theNormal->impl<gp_Dir>();
+
+ double aRadius = theCenter->distance(theStartPoint);
+ gp_Circ aCircle(gp_Ax2(aCenter, aDir), aRadius);
+
+ BRepBuilderAPI_MakeEdge anEdgeBuilder(aCircle);
+ boost::shared_ptr<GeomAPI_Shape> aRes(new GeomAPI_Shape);
+ TopoDS_Edge anEdge = anEdgeBuilder.Edge();
+ aRes->setImpl(new TopoDS_Shape(anEdge));
+ return aRes;
+}
static boost::shared_ptr<GeomAPI_Shape> lineCircle(
boost::shared_ptr<GeomAPI_Pnt> theCenter,
boost::shared_ptr<GeomAPI_Dir> theNormal, double theRadius);
+
+ /// Creates linear edge in a form of a circle arc by a three points
+ static boost::shared_ptr<GeomAPI_Shape> lineCircleArc(
+ boost::shared_ptr<GeomAPI_Pnt> theCenter,
+ boost::shared_ptr<GeomAPI_Pnt> theStartPoint,
+ boost::shared_ptr<GeomAPI_Pnt> theEndPoint,
+ boost::shared_ptr<GeomAPI_Dir> theNormal);
};
#endif
SET(PROJECT_HEADERS
PartSet.h
PartSet_Constants.h
+ PartSet_FeatureArcPrs.h
PartSet_FeatureCirclePrs.h
PartSet_FeaturePrs.h
PartSet_FeatureLinePrs.h
SET(PROJECT_SOURCES
PartSet_FeaturePrs.cpp
+ PartSet_FeatureArcPrs.cpp
PartSet_FeatureCirclePrs.cpp
PartSet_FeatureLinePrs.cpp
PartSet_FeaturePointPrs.cpp
{
SM_FirstPoint,
SM_SecondPoint,
+ SM_ThirdPoint,
SM_DonePoint
};
--- /dev/null
+// File: PartSet_FeaturePrs.h
+// Created: 04 Jun 2014
+// Author: Natalia ERMOLAEVA
+
+#include <PartSet_FeatureArcPrs.h>
+#include <PartSet_Tools.h>
+
+#include <SketchPlugin_Feature.h>
+#include <SketchPlugin_Sketch.h>
+#include <SketchPlugin_Arc.h>
+
+#include <GeomDataAPI_Point2D.h>
+
+#include <ModelAPI_Data.h>
+#include <ModelAPI_Document.h>
+#include <ModelAPI_AttributeRefAttr.h>
+#include <ModelAPI_AttributeRefList.h>
+
+#include <Precision.hxx>
+
+using namespace std;
+
+PartSet_FeatureArcPrs::PartSet_FeatureArcPrs(FeaturePtr theSketch)
+: PartSet_FeaturePrs(theSketch)
+{
+}
+
+PartSet_SelectionMode PartSet_FeatureArcPrs::setPoint(double theX, double theY,
+ const PartSet_SelectionMode& theMode)
+{
+ PartSet_SelectionMode aMode = theMode;
+ switch (theMode)
+ {
+ case SM_FirstPoint: {
+ PartSet_Tools::setFeaturePoint(feature(), theX, theY, ARC_ATTR_CENTER);
+ aMode = SM_SecondPoint;
+ }
+ break;
+ case SM_SecondPoint: {
+ PartSet_Tools::setFeaturePoint(feature(), theX, theY, ARC_ATTR_START);
+ aMode = SM_ThirdPoint;
+ }
+ break;
+ case SM_ThirdPoint: {
+ PartSet_Tools::setFeaturePoint(feature(), theX, theY, ARC_ATTR_END);
+ aMode = SM_DonePoint;
+ }
+ break;
+ default:
+ break;
+ }
+ return aMode;
+}
+
+std::string PartSet_FeatureArcPrs::getAttribute(const PartSet_SelectionMode& theMode) const
+{
+ std::string aAttribute;
+ switch (theMode)
+ {
+ case SM_FirstPoint:
+ aAttribute = ARC_ATTR_CENTER;
+ break;
+ case SM_SecondPoint:
+ aAttribute = ARC_ATTR_START;
+ break;
+ case SM_ThirdPoint:
+ aAttribute = ARC_ATTR_END;
+ break;
+ default:
+ break;
+ }
+ return aAttribute;
+}
+
+PartSet_SelectionMode PartSet_FeatureArcPrs::getNextMode(const std::string& theAttribute) const
+{
+ PartSet_SelectionMode aMode;
+
+ if (theAttribute == ARC_ATTR_CENTER)
+ aMode = SM_SecondPoint;
+ else if (theAttribute == ARC_ATTR_START)
+ aMode = SM_ThirdPoint;
+ else if (theAttribute == ARC_ATTR_END)
+ aMode = SM_DonePoint;
+ return aMode;
+}
+
+boost::shared_ptr<GeomDataAPI_Point2D> PartSet_FeatureArcPrs::featurePoint
+ (const PartSet_SelectionMode& theMode)
+{
+ std::string aPointArg;
+ switch (theMode)
+ {
+ case SM_FirstPoint:
+ aPointArg = ARC_ATTR_CENTER;
+ break;
+ case SM_SecondPoint:
+ aPointArg = ARC_ATTR_START;
+ break;
+ case SM_ThirdPoint:
+ aPointArg = ARC_ATTR_END;
+ break;
+ default:
+ break;
+ }
+ boost::shared_ptr<ModelAPI_Data> aData = feature()->data();
+ boost::shared_ptr<GeomDataAPI_Point2D> aPoint = boost::dynamic_pointer_cast<GeomDataAPI_Point2D>
+ (aData->attribute(aPointArg));
+ return aPoint;
+}
--- /dev/null
+// File: PartSet_FeatureArcPrs.h
+// Created: 04 Jun 2014
+// Author: Natalia ERMOLAEVA
+
+#ifndef PartSet_FeatureArcPrs_H
+#define PartSet_FeatureArcPrs_H
+
+#include "PartSet.h"
+
+#include "PartSet_FeaturePrs.h"
+#include "PartSet_Constants.h"
+
+class GeomDataAPI_Point2D;
+
+/*!
+ \class PartSet_FeatureArcPrs
+ * \brief The class to define the circle arc feature manipulation. It is created for
+ * the feature create operation to move out the feature properties set and use one operation
+ * for any type of features.
+*/
+class PARTSET_EXPORT PartSet_FeatureArcPrs : public PartSet_FeaturePrs
+{
+public:
+ /// Constructor
+ /// \param theSketch the sketch feature
+ PartSet_FeatureArcPrs(FeaturePtr theSketch);
+ /// Destructor
+ virtual ~PartSet_FeatureArcPrs() {};
+
+ /// Sets the point to the feature in an attribute depending on the selection mode
+ /// \param theX the 2D point horizontal coordinate
+ /// \param theY the 2D point vertical coordinate
+ /// \param theMode the selection mode
+ /// \return the new selection mode
+ virtual PartSet_SelectionMode setPoint(double theX, double theY,
+ const PartSet_SelectionMode& theMode);
+
+ /// Returns the feature attribute name for the selection mode
+ /// \param theMode the current operation selection mode. The feature attribute depends on the mode
+ virtual std::string getAttribute(const PartSet_SelectionMode& theMode) const;
+
+ /// Returns the next selection mode after the attribute
+ /// \param theAttribute the feature attribute name
+ /// \return next attribute selection mode
+ virtual PartSet_SelectionMode getNextMode(const std::string& theAttribute) const;
+
+protected:
+ /// Returns the feature point in the selection mode position.
+ /// \param theMode the current operation selection mode. The feature attribute depends on the mode
+ virtual boost::shared_ptr<GeomDataAPI_Point2D> featurePoint(const PartSet_SelectionMode& theMode);
+};
+
+#endif
/*!
\class PartSet_FeatureCirclePrs
- * \brief The abstract class to define the specific feature manipulation. It is created for
+ * \brief The class to define the circle feature manipulation. It is created for
* the feature create operation to move out the feature properties set and use one operation
* for any type of features.
*/
#include <ModelAPI_AttributeRefList.h>
#include <Precision.hxx>
+#include <V3d_View.hxx>
using namespace std;
return aMode;
}
+void PartSet_FeatureLinePrs::projectPointOnLine(FeaturePtr theFeature,
+ const PartSet_SelectionMode& theMode,
+ const gp_Pnt& thePoint, Handle(V3d_View) theView,
+ double& theX, double& theY)
+{
+ if (theFeature) {
+ double X0, X1, X2, X3;
+ double Y0, Y1, Y2, Y3;
+ PartSet_Tools::getLinePoint(theFeature, LINE_ATTR_START, X2, Y2);
+ PartSet_Tools::getLinePoint(theFeature, LINE_ATTR_END, X3, Y3);
+ PartSet_Tools::convertTo2D(thePoint, sketch(), theView, X1, Y1);
+
+ switch (theMode) {
+ case SM_FirstPoint:
+ PartSet_Tools::projectPointOnLine(X2, Y2, X3, Y3, X1, Y1, theX, theY);
+ break;
+ case SM_SecondPoint: {
+ PartSet_Tools::getLinePoint(feature(), LINE_ATTR_START, X0, Y0);
+ PartSet_Tools::intersectLines(X0, Y0, X1, Y1, X2, Y2, X3, Y3, theX, theY);
+ }
+ break;
+ default:
+ break;
+ }
+ }
+}
+
boost::shared_ptr<GeomDataAPI_Point2D> PartSet_FeatureLinePrs::featurePoint
(const PartSet_SelectionMode& theMode)
{
#include "PartSet_FeaturePrs.h"
#include "PartSet_Constants.h"
+#include <gp_Pnt.hxx>
+
class GeomDataAPI_Point2D;
+class Handle_V3d_View;
/*!
\class PartSet_FeatureLinePrs
- * \brief The abstract class to define the specific feature manipulation. It is created for
+ * \brief The class to define the line feature manipulation. It is created for
* the feature create operation to move out the feature properties set and use one operation
* for any type of features.
*/
/// \return next attribute selection mode
virtual PartSet_SelectionMode getNextMode(const std::string& theAttribute) const;
+
+ /// Project the point on a feature
+ /// \param theFeature the feature to be projected on
+ /// \param theMode the selection mode
+ /// \param thePoint the clicked point
+ /// \param theView the viewer
+ /// \param theX the output horizontal coordinate
+ /// \param theY the output vertical coordinate
+ void projectPointOnLine(FeaturePtr theFeature, const PartSet_SelectionMode& theMode,
+ const gp_Pnt& thePoint, Handle_V3d_View theView,
+ double& theX, double& theY);
+
protected:
/// Initializes current feature by the given
/// \param theSourceFeature the feature, which attributes are used to initialize the current feature
/*!
\class PartSet_FeaturePointPrs
- * \brief The abstract class to define the specific feature manipulation. It is created for
+ * \brief The class to define the point feature manipulation. It is created for
* the feature create operation to move out the feature properties set and use one operation
* for any type of features.
*/
#include <PartSet_FeaturePointPrs.h>
#include <PartSet_FeatureLinePrs.h>
#include <PartSet_FeatureCirclePrs.h>
+#include <PartSet_FeatureArcPrs.h>
#include <SketchPlugin_Feature.h>
#include <SketchPlugin_Point.h>
#include <SketchPlugin_Line.h>
#include <SketchPlugin_Circle.h>
+#include <SketchPlugin_Arc.h>
#include <ModuleBase_OperationDescription.h>
else if (aKind == SKETCH_CIRCLE_KIND) {
myFeaturePrs = new PartSet_FeatureCirclePrs(theFeature);
}
+ else if (aKind == SKETCH_ARC_KIND) {
+ myFeaturePrs = new PartSet_FeatureArcPrs(theFeature);
+ }
}
PartSet_OperationCreateFeature::~PartSet_OperationCreateFeature()
bool PartSet_OperationCreateFeature::canProcessKind(const std::string& theId)
{
- return theId == SKETCH_LINE_KIND || theId == SKETCH_POINT_KIND || theId == SKETCH_CIRCLE_KIND;
+ return theId == SKETCH_LINE_KIND || theId == SKETCH_POINT_KIND || theId == SKETCH_CIRCLE_KIND ||
+ theId == SKETCH_ARC_KIND;
}
bool PartSet_OperationCreateFeature::canBeCommitted() const
double aX, anY;
- bool isFoundPoint = false;
gp_Pnt aPoint = PartSet_Tools::convertClickToPoint(theEvent->pos(), theView);
if (theSelected.empty()) {
PartSet_Tools::convertTo2D(aPoint, sketch(), theView, aX, anY);
- isFoundPoint = true;
}
else {
XGUI_ViewerPrs aPrs = theSelected.front();
if (!aVertex.IsNull()) {
aPoint = BRep_Tool::Pnt(aVertex);
PartSet_Tools::convertTo2D(aPoint, sketch(), theView, aX, anY);
- isFoundPoint = true;
myFeaturePrs->setConstraints(aX, anY, myPointSelectionMode);
}
else if (aShape.ShapeType() == TopAbs_EDGE) // the line is selected
{
PartSet_Tools::convertTo2D(aPoint, sketch(), theView, aX, anY);
- isFoundPoint = true;
- /*
- FeaturePtr aFeature = aPrs.feature();
- if (aFeature) {
- double X0, X1, X2, X3;
- double Y0, Y1, Y2, Y3;
- PartSet_Tools::getLinePoint(aFeature, LINE_ATTR_START, X2, Y2);
- PartSet_Tools::getLinePoint(aFeature, LINE_ATTR_END, X3, Y3);
- PartSet_Tools::convertTo2D(aPoint, sketch(), theView, X1, Y1);
-
- switch (myPointSelectionMode) {
- case SM_FirstPoint:
- PartSet_Tools::projectPointOnLine(X2, Y2, X3, Y3, X1, Y1, aX, anY);
- break;
- case SM_SecondPoint: {
- PartSet_Tools::getLinePoint(feature(), LINE_ATTR_START, X0, Y0);
- PartSet_Tools::intersectLines(X0, Y0, X1, Y1, X2, Y2, X3, Y3, aX, anY);
- }
- break;
- default:
- break;
+ // move to selected line
+ if (feature()->getKind() == SKETCH_LINE_KIND) {
+ PartSet_FeatureLinePrs* aLinePrs = dynamic_cast<PartSet_FeatureLinePrs*>(myFeaturePrs);
+ if (aLinePrs) {
+ FeaturePtr aFeature = aPrs.feature();
+ aLinePrs->projectPointOnLine(aFeature, myPointSelectionMode, aPoint, theView, aX, anY);
}
- isFoundPoint = true;
}
- */
}
}
}
switch (myPointSelectionMode)
{
case SM_FirstPoint:
- case SM_SecondPoint: {
+ case SM_SecondPoint:
+ case SM_ThirdPoint: {
PartSet_SelectionMode aMode = myFeaturePrs->setPoint(aX, anY, myPointSelectionMode);
flushUpdated();
setPointSelectionMode(aMode);
{
case SM_FirstPoint:
case SM_SecondPoint:
+ case SM_ThirdPoint:
{
double aX, anY;
gp_Pnt aPoint = PartSet_Tools::convertClickToPoint(theEvent->pos(), theView);
#include "SketchPlugin_Arc.h"
#include "SketchPlugin_Sketch.h"
#include <ModelAPI_Data.h>
+
#include <GeomDataAPI_Point2D.h>
+#include <GeomDataAPI_Dir.h>
+
+#include <GeomAlgoAPI_PointBuilder.h>
+#include <GeomAlgoAPI_EdgeBuilder.h>
+#include <GeomAlgoAPI_CompoundBuilder.h>
SketchPlugin_Arc::SketchPlugin_Arc()
: SketchPlugin_Feature()
const boost::shared_ptr<GeomAPI_Shape>& SketchPlugin_Arc::preview()
{
- /// \todo Implement preview for arc of circle
+ SketchPlugin_Sketch* aSketch = sketch();
+ if (aSketch) {
+ std::list<boost::shared_ptr<GeomAPI_Shape> > aShapes;
+
+ // compute a circle point in 3D view
+ boost::shared_ptr<GeomDataAPI_Point2D> aCenterAttr =
+ boost::dynamic_pointer_cast<GeomDataAPI_Point2D>(data()->attribute(ARC_ATTR_CENTER));
+ boost::shared_ptr<GeomAPI_Pnt> aCenter(aSketch->to3D(aCenterAttr->x(), aCenterAttr->y()));
+ // make a visible point
+ boost::shared_ptr<GeomAPI_Shape> aCenterPointShape = GeomAlgoAPI_PointBuilder::point(aCenter);
+ aShapes.push_back(aCenterPointShape);
+
+ // make a visible circle
+ boost::shared_ptr<GeomDataAPI_Dir> aNDir =
+ boost::dynamic_pointer_cast<GeomDataAPI_Dir>(aSketch->data()->attribute(SKETCH_ATTR_NORM));
+ bool aHasPlane = aNDir && !(aNDir->x() == 0 && aNDir->y() == 0 && aNDir->z() == 0);
+ if (aHasPlane) {
+ boost::shared_ptr<GeomAPI_Dir> aNormal(new GeomAPI_Dir(aNDir->x(), aNDir->y(), aNDir->z()));
+ // compute the arc start point
+ boost::shared_ptr<GeomDataAPI_Point2D> aStartAttr =
+ boost::dynamic_pointer_cast<GeomDataAPI_Point2D>(data()->attribute(ARC_ATTR_START));
+ boost::shared_ptr<GeomAPI_Pnt> aStartPoint(aSketch->to3D(aStartAttr->x(), aStartAttr->y()));
+
+ // compute the arc end point
+ boost::shared_ptr<GeomDataAPI_Point2D> anEndAttr =
+ boost::dynamic_pointer_cast<GeomDataAPI_Point2D>(data()->attribute(ARC_ATTR_END));
+ boost::shared_ptr<GeomAPI_Pnt> aEndPoint(aSketch->to3D(anEndAttr->x(), anEndAttr->y()));
+
+ boost::shared_ptr<GeomAPI_Shape> aCircleShape =
+ GeomAlgoAPI_EdgeBuilder::lineCircleArc(aCenter, aStartPoint, aEndPoint, aNormal);
+ aShapes.push_back(aCircleShape);
+ }
+ boost::shared_ptr<GeomAPI_Shape> aCompound = GeomAlgoAPI_CompoundBuilder::compound(aShapes);
+ setPreview(aCompound);
+ }
return getPreview();
}
#include "SketchPlugin_Circle.h"
#include "SketchPlugin_Sketch.h"
#include <ModelAPI_Data.h>
+
#include <GeomDataAPI_Point2D.h>
+#include <GeomDataAPI_Dir.h>
+
#include <GeomAlgoAPI_PointBuilder.h>
#include <GeomAlgoAPI_EdgeBuilder.h>
#include <GeomAlgoAPI_CompoundBuilder.h>
-#include <GeomDataAPI_Dir.h>
#include <ModelAPI_AttributeDouble.h>
{
SketchPlugin_Sketch* aSketch = sketch();
if (aSketch) {
+ std::list<boost::shared_ptr<GeomAPI_Shape> > aShapes;
+
// compute a circle point in 3D view
boost::shared_ptr<GeomDataAPI_Point2D> aCenterAttr =
boost::dynamic_pointer_cast<GeomDataAPI_Point2D>(data()->attribute(CIRCLE_ATTR_CENTER));
boost::shared_ptr<GeomAPI_Pnt> aCenter(aSketch->to3D(aCenterAttr->x(), aCenterAttr->y()));
-
- // compute the circle radius
- boost::shared_ptr<ModelAPI_AttributeDouble> aRadiusAttr =
- boost::dynamic_pointer_cast<ModelAPI_AttributeDouble>(data()->attribute(CIRCLE_ATTR_RADIUS));
- double aRadius = aRadiusAttr->value();
-
- std::list<boost::shared_ptr<GeomAPI_Shape> > aShapes;
// make a visible point
boost::shared_ptr<GeomAPI_Shape> aCenterPointShape = GeomAlgoAPI_PointBuilder::point(aCenter);
aShapes.push_back(aCenterPointShape);
bool aHasPlane = aNDir && !(aNDir->x() == 0 && aNDir->y() == 0 && aNDir->z() == 0);
if (aHasPlane) {
boost::shared_ptr<GeomAPI_Dir> aNormal(new GeomAPI_Dir(aNDir->x(), aNDir->y(), aNDir->z()));
+ // compute the circle radius
+ boost::shared_ptr<ModelAPI_AttributeDouble> aRadiusAttr =
+ boost::dynamic_pointer_cast<ModelAPI_AttributeDouble>(data()->attribute(CIRCLE_ATTR_RADIUS));
+ double aRadius = aRadiusAttr->value();
boost::shared_ptr<GeomAPI_Shape> aCircleShape =
GeomAlgoAPI_EdgeBuilder::lineCircle(aCenter, aNormal, aRadius);
aShapes.push_back(aCircleShape);
-
- boost::shared_ptr<GeomAPI_Shape> aCompound = GeomAlgoAPI_CompoundBuilder::compound(aShapes);
- setPreview(aCompound);
}
+ boost::shared_ptr<GeomAPI_Shape> aCompound = GeomAlgoAPI_CompoundBuilder::compound(aShapes);
+ setPreview(aCompound);
}
- /// \todo Implement preview for the circle
return getPreview();
}
else if (theFeatureID == SKETCH_CIRCLE_KIND) {
return FeaturePtr(new SketchPlugin_Circle);
}
+ else if (theFeatureID == SKETCH_ARC_KIND) {
+ return FeaturePtr(new SketchPlugin_Arc);
+ }
else if (theFeatureID == SKETCH_CONSTRAINT_COINCIDENCE_KIND) {
return FeaturePtr(new SketchPlugin_ConstraintCoincidence);
}
<plugin>
<workbench id="Sketch">
<group id="Basic">
- <feature id="Sketch" nested="SketchPoint SketchLine SketchCircle SketchConstraintLength" title="Sketch" tooltip="Create a new sketch or edit an existing sketch" icon=":icons/sketch.png">
+ <feature id="Sketch" nested="SketchPoint SketchLine SketchCircle SketchArc SketchConstraintLength" title="Sketch" tooltip="Create a new sketch or edit an existing sketch" icon=":icons/sketch.png">
<label title="Select a plane on which to create a sketch" tooltip="Select a plane on which to create a sketch"/>
<!--icon=":pictures/x_point.png"-->
</feature>
<point_selector id="CircleCenter" title="Center" tooltip="Center of the circle"/>
<doublevalue id="CircleRadius" label="Radius:" min="0" step="1.0" default="0" icon=":icons/radius.png" tooltip="Set Radius"/>
</feature>
- <feature id="SketchArc" title="Arc" tooltip="Create a new arc of a circle" icon="" internal="1">
+ <feature id="SketchArc" title="Arc" tooltip="Create a new arc of a circle" icon="">
<point_selector id="ArcCenter" title="Center" tooltip="Center of the arc"/>
<point_selector id="ArcStartPoint" title="Start point" tooltip="Start point of the arc"/>
<point_selector id="ArcEndPoint" title="End point" tooltip="End point of the arc"/>
