-// Copyright (C) 2014-2019 CEA/DEN, EDF R&D
+// Copyright (C) 2014-2024 CEA, EDF
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
#include <SketchPlugin_ConstraintPerpendicular.h>
#include <SketchPlugin_ConstraintRadius.h>
#include <SketchPlugin_ConstraintRigid.h>
+#include <SketchPlugin_CurveFitting.h>
#include <SketchPlugin_Trim.h>
#include <SketchPlugin_Split.h>
#include <SketchPlugin_ConstraintTangent.h>
#include <SketchPlugin_ConstraintVertical.h>
+#include <SketchPlugin_MacroBSpline.h>
+#include <SketchPlugin_SketchCopy.h>
+#include <SketchPlugin_Offset.h>
#include <SketcherPrs_Tools.h>
//--------------------------------------------------------------------------------------
#include <ModelAPI_Events.h>
#include <ModelHighAPI_Tools.h>
//--------------------------------------------------------------------------------------
#include "SketchAPI_Arc.h"
+#include "SketchAPI_BSpline.h"
#include "SketchAPI_Circle.h"
#include "SketchAPI_Ellipse.h"
#include "SketchAPI_EllipticArc.h"
#include "SketchAPI_MacroCircle.h"
#include "SketchAPI_MacroEllipse.h"
#include "SketchAPI_MacroEllipticArc.h"
+#include "SketchAPI_MacroMiddlePoint.h"
#include "SketchAPI_Mirror.h"
+#include "SketchAPI_Offset.h"
#include "SketchAPI_Point.h"
#include "SketchAPI_Projection.h"
#include "SketchAPI_Rectangle.h"
#include "SketchAPI_Rotation.h"
#include "SketchAPI_Translation.h"
+#include "SketchAPI_Constraint.h"
//--------------------------------------------------------------------------------------
#include <GeomAPI_Curve.h>
#include <GeomAPI_Dir2d.h>
#include <algorithm>
#include <cmath>
//--------------------------------------------------------------------------------------
+
+
+static std::shared_ptr<GeomAPI_Pnt2d> pointCoordinates(const AttributePtr& thePoint)
+{
+ AttributePoint2DPtr aPnt = std::dynamic_pointer_cast<GeomDataAPI_Point2D>(thePoint);
+ return aPnt ? aPnt->pnt() : std::shared_ptr<GeomAPI_Pnt2d>();
+}
+
+static std::shared_ptr<GeomAPI_Pnt2d> middlePointOnLine(const FeaturePtr& theFeature)
+{
+ AttributePoint2DPtr aStartAttr = std::dynamic_pointer_cast<GeomDataAPI_Point2D>(
+ theFeature->attribute(SketchPlugin_Line::START_ID()));
+ AttributePoint2DPtr aEndAttr = std::dynamic_pointer_cast<GeomDataAPI_Point2D>(
+ theFeature->attribute(SketchPlugin_Line::END_ID()));
+
+ if (!aStartAttr || !aEndAttr)
+ return std::shared_ptr<GeomAPI_Pnt2d>();
+
+ std::shared_ptr<GeomAPI_XY> aStartPoint = aStartAttr->pnt()->xy();
+ std::shared_ptr<GeomAPI_XY> aEndPoint = aEndAttr->pnt()->xy();
+ return std::shared_ptr<GeomAPI_Pnt2d>(
+ new GeomAPI_Pnt2d(aStartPoint->added(aEndPoint)->multiplied(0.5)));
+}
+
+static std::shared_ptr<GeomAPI_Pnt2d> pointOnCircle(const FeaturePtr& theFeature)
+{
+ AttributePoint2DPtr aCenter = std::dynamic_pointer_cast<GeomDataAPI_Point2D>(
+ theFeature->attribute(SketchPlugin_Circle::CENTER_ID()));
+ AttributeDoublePtr aRadius = theFeature->real(SketchPlugin_Circle::RADIUS_ID());
+
+ if (!aCenter || !aRadius)
+ return std::shared_ptr<GeomAPI_Pnt2d>();
+
+ return std::shared_ptr<GeomAPI_Pnt2d>(
+ new GeomAPI_Pnt2d(aCenter->x() + aRadius->value(), aCenter->y()));
+}
+
+static std::shared_ptr<GeomAPI_Pnt2d> middlePointOnArc(const FeaturePtr& theFeature)
+{
+ static const double PI = 3.141592653589793238463;
+
+ AttributePoint2DPtr aCenterAttr = std::dynamic_pointer_cast<GeomDataAPI_Point2D>(
+ theFeature->attribute(SketchPlugin_Arc::CENTER_ID()));
+ AttributePoint2DPtr aStartAttr = std::dynamic_pointer_cast<GeomDataAPI_Point2D>(
+ theFeature->attribute(SketchPlugin_Arc::START_ID()));
+ AttributePoint2DPtr aEndAttr = std::dynamic_pointer_cast<GeomDataAPI_Point2D>(
+ theFeature->attribute(SketchPlugin_Arc::END_ID()));
+
+ if (!aCenterAttr || !aStartAttr || !aEndAttr)
+ return std::shared_ptr<GeomAPI_Pnt2d>();
+
+ std::shared_ptr<GeomAPI_Dir2d> aStartDir(new GeomAPI_Dir2d(
+ aStartAttr->x() - aCenterAttr->x(), aStartAttr->y() - aCenterAttr->y()));
+ std::shared_ptr<GeomAPI_Dir2d> aEndDir(new GeomAPI_Dir2d(
+ aEndAttr->x() - aCenterAttr->x(), aEndAttr->y() - aCenterAttr->y()));
+
+ double anAngle = aStartDir->angle(aEndDir);
+ bool isReversed = theFeature->boolean(SketchPlugin_Arc::REVERSED_ID())->value();
+ if (isReversed && anAngle > 0.)
+ anAngle -= 2.0 * PI;
+ else if (!isReversed && anAngle <= 0.)
+ anAngle += 2.0 * PI;
+
+ double cosA = cos(anAngle);
+ double sinA = sin(anAngle);
+
+ // rotate start dir to find middle point on arc
+ double aRadius = aStartAttr->pnt()->distance(aCenterAttr->pnt());
+ double x = aCenterAttr->x() + aRadius * (aStartDir->x() * cosA - aStartDir->y() * sinA);
+ double y = aCenterAttr->y() + aRadius * (aStartDir->x() * sinA + aStartDir->y() * cosA);
+
+ return std::shared_ptr<GeomAPI_Pnt2d>(new GeomAPI_Pnt2d(x, y));
+}
+
+static std::shared_ptr<GeomAPI_Pnt2d> pointOnEllipse(const FeaturePtr& theFeature,
+ bool isEllipse = true)
+{
+ const std::string& anAttrName = isEllipse ? SketchPlugin_Ellipse::MAJOR_AXIS_END_ID() :
+ SketchPlugin_EllipticArc::MAJOR_AXIS_END_ID();
+ AttributePoint2DPtr aMajorAxisEnd = std::dynamic_pointer_cast<GeomDataAPI_Point2D>(
+ theFeature->attribute(anAttrName));
+ return aMajorAxisEnd ? aMajorAxisEnd->pnt() : std::shared_ptr<GeomAPI_Pnt2d>();
+}
+
+static std::shared_ptr<GeomAPI_Pnt2d> middlePointOnBSpline(const FeaturePtr& theFeature,
+ SketchAPI_Sketch* theSketch)
+{
+ GeomAPI_Edge anEdge(theFeature->lastResult()->shape());
+ GeomPointPtr aMiddle = anEdge.middlePoint();
+ return theSketch->to2D(aMiddle);
+}
+
+static std::shared_ptr<GeomAPI_Pnt2d> middlePoint(const ObjectPtr& theObject,
+ SketchAPI_Sketch* theSketch)
+{
+ std::shared_ptr<GeomAPI_Pnt2d> aMiddlePoint;
+ FeaturePtr aFeature = ModelAPI_Feature::feature(theObject);
+ if (aFeature) {
+ // move only features of the following types
+ const std::string& aFeatureKind = aFeature->getKind();
+ if (aFeatureKind == SketchPlugin_Point::ID())
+ aMiddlePoint = pointCoordinates(aFeature->attribute(SketchPlugin_Point::COORD_ID()));
+ else if (aFeatureKind == SketchPlugin_Line::ID())
+ aMiddlePoint = middlePointOnLine(aFeature);
+ else if (aFeatureKind == SketchPlugin_Circle::ID())
+ aMiddlePoint = pointOnCircle(aFeature);
+ else if (aFeatureKind == SketchPlugin_Arc::ID())
+ aMiddlePoint = middlePointOnArc(aFeature);
+ else if (aFeatureKind == SketchPlugin_Ellipse::ID())
+ aMiddlePoint = pointOnEllipse(aFeature);
+ else if (aFeatureKind == SketchPlugin_EllipticArc::ID())
+ aMiddlePoint = pointOnEllipse(aFeature, false);
+ else if (aFeatureKind == SketchPlugin_BSpline::ID() ||
+ aFeatureKind == SketchPlugin_BSplinePeriodic::ID())
+ aMiddlePoint = middlePointOnBSpline(aFeature, theSketch);
+ }
+ return aMiddlePoint;
+}
+
SketchAPI_Sketch::SketchAPI_Sketch(
const std::shared_ptr<ModelAPI_Feature> & theFeature)
: ModelHighAPI_Interface(theFeature)
}
SketchPtr addSketch(const std::shared_ptr<ModelAPI_Document> & thePart,
- const std::string & theExternalName)
+ const std::wstring & theExternalName)
{
std::shared_ptr<ModelAPI_Feature> aFeature = thePart->addFeature(SketchAPI_Sketch::ID());
return SketchPtr(
return SketchPtr(new SketchAPI_Sketch(aFeature, thePlaneObject));
}
+//--------------------------------------------------------------------------------------
+SketchPtr copySketch(const std::shared_ptr<ModelAPI_Document> & thePart,
+ const SketchPtr & theSketch)
+{
+ FeaturePtr aCopyer = thePart->addFeature(SketchPlugin_SketchCopy::ID());
+ aCopyer->reference(SketchPlugin_SketchCopy::BASE_ID())->setValue(theSketch->feature());
+ aCopyer->execute();
+
+ FeaturePtr aNewSketch = thePart->nextFeature(aCopyer);
+
+ // perform removing the macro-feature
+ thePart->removeFeature(aCopyer);
+ apply();
+
+ return SketchPtr(new SketchAPI_Sketch(aNewSketch));
+}
+
//--------------------------------------------------------------------------------------
std::list< std::shared_ptr<SketchAPI_Point> > SketchAPI_Sketch::getFreePoints()
compositeFeature()->addFeature(SketchPlugin_Point::ID());
return PointPtr(new SketchAPI_Point(aFeature, theExternal));
}
-std::shared_ptr<SketchAPI_Point> SketchAPI_Sketch::addPoint(const std::string & theExternalName)
+std::shared_ptr<SketchAPI_Point> SketchAPI_Sketch::addPoint(const std::wstring & theExternalName)
{
std::shared_ptr<ModelAPI_Feature> aFeature =
compositeFeature()->addFeature(SketchPlugin_Point::ID());
return anIntersection;
}
std::shared_ptr<SketchAPI_IntersectionPoint> SketchAPI_Sketch::addIntersectionPoint(
- const std::string & theExternalName,
+ const std::wstring & theExternalName,
bool theKeepResult)
{
std::shared_ptr<ModelAPI_Feature> aFeature =
compositeFeature()->addFeature(SketchPlugin_Line::ID());
return LinePtr(new SketchAPI_Line(aFeature, theExternal));
}
-std::shared_ptr<SketchAPI_Line> SketchAPI_Sketch::addLine(const std::string & theExternalName)
+std::shared_ptr<SketchAPI_Line> SketchAPI_Sketch::addLine(const std::wstring & theExternalName)
{
std::shared_ptr<ModelAPI_Feature> aFeature =
compositeFeature()->addFeature(SketchPlugin_Line::ID());
std::shared_ptr<SketchAPI_Rectangle> SketchAPI_Sketch::addRectangle(double theX1, double theY1,
double theX2, double theY2)
{
- std::shared_ptr<ModelAPI_Feature> aFeature =
- compositeFeature()->addFeature(SketchAPI_Rectangle::ID());
+ std::shared_ptr<ModelAPI_Feature> aFeature = compositeFeature()->addFeature(SketchAPI_Rectangle::ID());
return RectanglePtr(new SketchAPI_Rectangle(aFeature, theX1, theY1, theX2, theY2));
}
+
+static std::shared_ptr<GeomAPI_Pnt2d> pointCoordinates(
+ const std::pair<std::shared_ptr<GeomAPI_Pnt2d>, ModelHighAPI_RefAttr> & thePoint)
+{
+ if (thePoint.first)
+ return thePoint.first;
+
+ AttributePtr anAttr = thePoint.second.attr();
+ if (thePoint.second.object()) {
+ FeaturePtr aFeature = ModelAPI_Feature::feature(thePoint.second.object());
+ if (aFeature)
+ anAttr = aFeature->attribute(SketchPlugin_Point::COORD_ID());
+ }
+
+ std::shared_ptr<GeomDataAPI_Point2D> aPntAttr = std::dynamic_pointer_cast<GeomDataAPI_Point2D>(anAttr);
+ if (aPntAttr)
+ return aPntAttr->pnt();
+ return std::shared_ptr<GeomAPI_Pnt2d>();
+}
+
std::shared_ptr<SketchAPI_Rectangle> SketchAPI_Sketch::addRectangle(
- const std::shared_ptr<GeomAPI_Pnt2d> & theStartPoint,
- const std::shared_ptr<GeomAPI_Pnt2d> & theEndPoint)
+ const std::pair<std::shared_ptr<GeomAPI_Pnt2d>, ModelHighAPI_RefAttr> & theStartPoint,
+ const std::pair<std::shared_ptr<GeomAPI_Pnt2d>, ModelHighAPI_RefAttr> & theEndPoint)
+{
+ std::shared_ptr<ModelAPI_Feature> aFeature = compositeFeature()->addFeature(SketchAPI_Rectangle::ID());
+ RectanglePtr aRect(new SketchAPI_Rectangle(aFeature));
+ fillAttribute("RectangleTypeByCorners", aRect->type());
+ fillAttribute(pointCoordinates(theStartPoint), aRect->startPoint());
+ fillAttribute(pointCoordinates(theEndPoint), aRect->endPoint());
+ aRect->execute();
+
+ if (!theStartPoint.second.isEmpty() && aRect->linesList()->size() >= 1) {
+ // Get end point of the first line of rectangle and apply coincidence constraint
+ FeaturePtr aLine = ModelAPI_Feature::feature(aRect->linesList()->object(0));
+ AttributePtr aLinePnt = aLine->attribute(SketchPlugin_Line::END_ID());
+ setCoincident(ModelHighAPI_RefAttr(aLinePnt), theStartPoint.second);
+ }
+
+ if (!theEndPoint.second.isEmpty() && aRect->linesList()->size() >= 4) {
+ // Get start point of the last line of rectangle and apply coincidence constraint
+ FeaturePtr aLine = ModelAPI_Feature::feature(aRect->linesList()->object(3));
+ AttributePtr aLinePnt = aLine->attribute(SketchPlugin_Line::START_ID());
+ setCoincident(ModelHighAPI_RefAttr(aLinePnt), theEndPoint.second);
+ }
+ return aRect;
+}
+
+std::pair<std::shared_ptr<SketchAPI_Rectangle>, std::shared_ptr<SketchAPI_Point>> SketchAPI_Sketch::addRectangleCentered(
+ const std::pair<std::shared_ptr<GeomAPI_Pnt2d>, ModelHighAPI_RefAttr> & theCenter,
+ const std::pair<std::shared_ptr<GeomAPI_Pnt2d>, ModelHighAPI_RefAttr> & theCorner)
{
- std::shared_ptr<ModelAPI_Feature> aFeature =
- compositeFeature()->addFeature(SketchAPI_Rectangle::ID());
- return RectanglePtr(new SketchAPI_Rectangle(aFeature, theStartPoint, theEndPoint));
+ std::shared_ptr<ModelAPI_Feature> aFeature = compositeFeature()->addFeature(SketchAPI_Rectangle::ID());
+ RectanglePtr aRect(new SketchAPI_Rectangle(aFeature));
+ fillAttribute("RectangleTypeCentered", aRect->type());
+
+ if (!theCenter.second.isEmpty())
+ fillAttribute(theCenter.second, aRect->centerPointRef());
+ else
+ fillAttribute(pointCoordinates(theCenter), aRect->centerPoint());
+
+ fillAttribute(pointCoordinates(theCorner), aRect->cornerPoint());
+ aRect->execute();
+
+ if (!theCorner.second.isEmpty() && aRect->linesList()->size() >= 4) {
+ // get start point of the last line in rectangle and apply coincidence constraint
+ FeaturePtr aLine = ModelAPI_Feature::feature(aRect->linesList()->object(3));
+ AttributePtr aEndPnt = aLine->attribute(SketchPlugin_Line::START_ID());
+ setCoincident(ModelHighAPI_RefAttr(aEndPnt), theCorner.second);
+ }
+ return std::pair<std::shared_ptr<SketchAPI_Rectangle>, std::shared_ptr<SketchAPI_Point>>(aRect, aRect->centerSketchPoint());
+}
+
+std::pair<std::shared_ptr<SketchAPI_Rectangle>, std::shared_ptr<SketchAPI_Point>> SketchAPI_Sketch::addRectangleCentered(
+ double theCenterX, double theCenterY,
+ double theCornerX, double theCornerY
+) {
+ std::shared_ptr<ModelAPI_Feature> aFeature = compositeFeature()->addFeature(SketchAPI_Rectangle::ID());
+ auto aRect = RectanglePtr(new SketchAPI_Rectangle(aFeature, theCenterX, theCenterY, theCornerX, theCornerY, true));
+ return std::pair<std::shared_ptr<SketchAPI_Rectangle>, std::shared_ptr<SketchAPI_Point>>(aRect, aRect->centerSketchPoint());
}
//--------------------------------------------------------------------------------------
return CirclePtr(new SketchAPI_Circle(aFeature, theExternal));
}
-std::shared_ptr<SketchAPI_Circle> SketchAPI_Sketch::addCircle(const std::string & theExternalName)
+std::shared_ptr<SketchAPI_Circle> SketchAPI_Sketch::addCircle(const std::wstring & theExternalName)
{
std::shared_ptr<ModelAPI_Feature> aFeature =
compositeFeature()->addFeature(SketchPlugin_Circle::ID());
return ArcPtr(new SketchAPI_Arc(aFeature, theExternal));
}
-std::shared_ptr<SketchAPI_Arc> SketchAPI_Sketch::addArc(const std::string & theExternalName)
+std::shared_ptr<SketchAPI_Arc> SketchAPI_Sketch::addArc(const std::wstring & theExternalName)
{
std::shared_ptr<ModelAPI_Feature> aFeature =
compositeFeature()->addFeature(SketchPlugin_Arc::ID());
}
std::shared_ptr<SketchAPI_MacroEllipse> SketchAPI_Sketch::addEllipse(
- const std::pair<std::shared_ptr<GeomAPI_Pnt2d>, ModelHighAPI_RefAttr>& thePoint1,
- const std::pair<std::shared_ptr<GeomAPI_Pnt2d>, ModelHighAPI_RefAttr>& thePoint2,
- const std::pair<std::shared_ptr<GeomAPI_Pnt2d>, ModelHighAPI_RefAttr>& thePassedPoint,
+ const PointOrReference& thePoint1,
+ const PointOrReference& thePoint2,
+ const PointOrReference& thePassedPoint,
bool isPoint1Center)
{
std::shared_ptr<ModelAPI_Feature> aFeature =
}
std::shared_ptr<SketchAPI_Ellipse> SketchAPI_Sketch::addEllipse(
- const std::string & theExternalName)
+ const std::wstring & theExternalName)
{
std::shared_ptr<ModelAPI_Feature> aFeature =
compositeFeature()->addFeature(SketchPlugin_Ellipse::ID());
}
std::shared_ptr<SketchAPI_MacroEllipticArc> SketchAPI_Sketch::addEllipticArc(
- const std::pair<std::shared_ptr<GeomAPI_Pnt2d>, ModelHighAPI_RefAttr>& theCenter,
- const std::pair<std::shared_ptr<GeomAPI_Pnt2d>, ModelHighAPI_RefAttr>& theMajorAxisPoint,
- const std::pair<std::shared_ptr<GeomAPI_Pnt2d>, ModelHighAPI_RefAttr>& theStartPoint,
- const std::pair<std::shared_ptr<GeomAPI_Pnt2d>, ModelHighAPI_RefAttr>& theEndPoint,
+ const PointOrReference& theCenter,
+ const PointOrReference& theMajorAxisPoint,
+ const PointOrReference& theStartPoint,
+ const PointOrReference& theEndPoint,
bool theInversed)
{
std::shared_ptr<ModelAPI_Feature> aFeature =
}
std::shared_ptr<SketchAPI_EllipticArc> SketchAPI_Sketch::addEllipticArc(
- const std::string & theExternalName)
+ const std::wstring & theExternalName)
{
std::shared_ptr<ModelAPI_Feature> aFeature =
compositeFeature()->addFeature(SketchPlugin_EllipticArc::ID());
}
//--------------------------------------------------------------------------------------
-std::shared_ptr<SketchAPI_Projection> SketchAPI_Sketch::addProjection(
- const ModelHighAPI_Selection & theExternalFeature,
- bool theKeepResult)
+
+std::shared_ptr<SketchAPI_BSpline> SketchAPI_Sketch::addSpline(
+ const ModelHighAPI_Selection & external,
+ const int degree,
+ const std::list<PointOrReference>& poles,
+ const std::list<ModelHighAPI_Double>& weights,
+ const std::list<ModelHighAPI_Double>& knots,
+ const std::list<ModelHighAPI_Integer>& multiplicities,
+ const bool periodic)
+{
+ // split poles and references to other shapes
+ bool hasReference = false;
+ std::list<GeomPnt2dPtr> aPoints;
+ std::list<ModelHighAPI_RefAttr> aReferences;
+ for (std::list<PointOrReference>::const_iterator it = poles.begin(); it != poles.end(); ++it) {
+ aPoints.push_back(it->first);
+ aReferences.push_back(it->second);
+ if (!it->second.isEmpty())
+ hasReference = true;
+ }
+
+ BSplinePtr aBSpline;
+ CompositeFeaturePtr aSketch = compositeFeature();
+ if (hasReference) {
+ // use macro-feature to create coincidences to referred features
+ FeaturePtr aMacroFeature = aSketch->addFeature(
+ periodic ? SketchPlugin_MacroBSplinePeriodic::ID() : SketchPlugin_MacroBSpline::ID());
+ AttributePoint2DArrayPtr aPolesAttr = std::dynamic_pointer_cast<GeomDataAPI_Point2DArray>(
+ aMacroFeature->attribute(SketchPlugin_MacroBSpline::POLES_ID()));
+ AttributeDoubleArrayPtr aWeightsAttr =
+ aMacroFeature->data()->realArray(SketchPlugin_MacroBSpline::WEIGHTS_ID());
+ AttributeRefAttrListPtr aPolesRefAttr =
+ aMacroFeature->data()->refattrlist(SketchPlugin_MacroBSpline::REF_POLES_ID());
+ // always generate a control polygon to apply coincidences correctly
+ aMacroFeature->boolean(SketchPlugin_MacroBSpline::CONTROL_POLYGON_ID())->setValue(true);
+ // initialize B-spline attributes
+ fillAttribute(aPoints, aPolesAttr);
+ if (weights.empty())
+ fillAttribute(std::list<ModelHighAPI_Double>(poles.size(), 1.0), aWeightsAttr);
+ else
+ fillAttribute(weights, aWeightsAttr);
+ fillAttribute(aReferences, aPolesRefAttr);
+ apply(); // to kill macro-feature
+
+ // find created B-spline feature
+ const std::string& aKindToFind =
+ periodic ? SketchPlugin_BSplinePeriodic::ID() : SketchPlugin_BSpline::ID();
+ int aNbSubs = aSketch->numberOfSubs();
+ for (int anIndex = aNbSubs - 1; anIndex >= 0; --anIndex) {
+ FeaturePtr aFeature = aSketch->subFeature(anIndex);
+ if (aFeature->getKind() == aKindToFind) {
+ aBSpline.reset(periodic ? new SketchAPI_BSplinePeriodic(aFeature)
+ : new SketchAPI_BSpline(aFeature));
+ aBSpline->execute();
+ break;
+ }
+ }
+ }
+ else {
+ // compute B-spline by parameters
+ FeaturePtr aFeature = aSketch->addFeature(
+ periodic ? SketchPlugin_BSplinePeriodic::ID() : SketchPlugin_BSpline::ID());
+
+ aBSpline.reset(periodic ? new SketchAPI_BSplinePeriodic(aFeature)
+ : new SketchAPI_BSpline(aFeature));
+ if (external.variantType() != ModelHighAPI_Selection::VT_Empty)
+ aBSpline->setByExternal(external);
+ else if (knots.empty() || multiplicities.empty())
+ aBSpline->setByDegreePolesAndWeights(degree, aPoints, weights);
+ else
+ aBSpline->setByParameters(degree, aPoints, weights, knots, multiplicities);
+ }
+ return aBSpline;
+}
+
+//--------------------------------------------------------------------------------------
+static std::shared_ptr<SketchAPI_BSpline> buildInterpolation(
+ const CompositeFeaturePtr& theSketch,
+ const FeaturePtr& theCurveFittingFeature,
+ const std::list<ModelHighAPI_RefAttr>& points,
+ const bool periodic,
+ const bool closed)
+{
+ AttributeBooleanPtr aPeriodicAttr =
+ theCurveFittingFeature->boolean(SketchPlugin_CurveFitting::PERIODIC_ID());
+ fillAttribute(periodic, aPeriodicAttr);
+ AttributeBooleanPtr aClosedAttr =
+ theCurveFittingFeature->boolean(SketchPlugin_CurveFitting::CLOSED_ID());
+ fillAttribute(closed, aClosedAttr);
+ AttributeRefAttrListPtr aPointsAttr =
+ theCurveFittingFeature->refattrlist(SketchPlugin_CurveFitting::POINTS_ID());
+ fillAttribute(points, aPointsAttr);
+ apply(); // to execute and kill the macro-feature
+
+ // find created B-spline feature
+ BSplinePtr aBSpline;
+ const std::string& aKindToFind =
+ periodic ? SketchPlugin_BSplinePeriodic::ID() : SketchPlugin_BSpline::ID();
+ int aNbSubs = theSketch->numberOfSubs();
+ for (int anIndex = aNbSubs - 1; anIndex >= 0; --anIndex) {
+ FeaturePtr aFeature = theSketch->subFeature(anIndex);
+ if (aFeature->getKind() == aKindToFind) {
+ aBSpline.reset(periodic ? new SketchAPI_BSplinePeriodic(aFeature)
+ : new SketchAPI_BSpline(aFeature));
+ aBSpline->execute();
+ break;
+ }
+ }
+ return aBSpline;
+}
+
+std::shared_ptr<SketchAPI_BSpline> SketchAPI_Sketch::addInterpolation(
+ const std::list<ModelHighAPI_RefAttr>& points,
+ const bool periodic,
+ const bool closed)
{
- std::shared_ptr<ModelAPI_Feature> aFeature =
- compositeFeature()->addFeature(SketchPlugin_Projection::ID());
- ProjectionPtr aProjection(new SketchAPI_Projection(aFeature, theExternalFeature));
- aProjection->setIncludeToResult(theKeepResult);
- return aProjection;
+ CompositeFeaturePtr aSketch = compositeFeature();
+ FeaturePtr anInterpFeature = aSketch->addFeature(SketchPlugin_CurveFitting::ID());
+ anInterpFeature->string(SketchPlugin_CurveFitting::TYPE_ID())
+ ->setValue(SketchPlugin_CurveFitting::TYPE_INTERPOLATION_ID());
+ return buildInterpolation(aSketch, anInterpFeature, points, periodic, closed);
+}
+
+std::shared_ptr<SketchAPI_BSpline> SketchAPI_Sketch::addApproximation(
+ const std::list<ModelHighAPI_RefAttr>& points,
+ const ModelHighAPI_Double& precision,
+ const bool periodic,
+ const bool closed)
+{
+ CompositeFeaturePtr aSketch = compositeFeature();
+ FeaturePtr anInterpFeature = aSketch->addFeature(SketchPlugin_CurveFitting::ID());
+ anInterpFeature->string(SketchPlugin_CurveFitting::TYPE_ID())
+ ->setValue(SketchPlugin_CurveFitting::TYPE_APPROXIMATION_ID());
+ fillAttribute(precision, anInterpFeature->real(SketchPlugin_CurveFitting::PRECISION_ID()));
+ return buildInterpolation(aSketch, anInterpFeature, points, periodic, closed);
}
+//--------------------------------------------------------------------------------------
std::shared_ptr<SketchAPI_Projection> SketchAPI_Sketch::addProjection(
- const std::string & theExternalName,
- bool theKeepResult)
+ const ModelHighAPI_Selection & theExternalFeature,
+ bool keepResult,
+ bool keepRefToOriginal)
{
std::shared_ptr<ModelAPI_Feature> aFeature =
compositeFeature()->addFeature(SketchPlugin_Projection::ID());
- ProjectionPtr aProjection(new SketchAPI_Projection(aFeature, theExternalName));
- aProjection->setIncludeToResult(theKeepResult);
+ ProjectionPtr aProjection(new SketchAPI_Projection(aFeature));
+ aProjection->setIncludeToResult(keepResult);
+ aProjection->setKeepReferenceToOriginal(keepRefToOriginal);
+ aProjection->setExternalFeature(theExternalFeature);
return aProjection;
}
return MirrorPtr(new SketchAPI_Mirror(aFeature, theMirrorLine, theObjects));
}
+//--------------------------------------------------------------------------------------
+std::shared_ptr<SketchAPI_Offset> SketchAPI_Sketch::addOffset(
+ const std::list<std::shared_ptr<ModelAPI_Object> > & theObjects,
+ const ModelHighAPI_Double & theValue,
+ const bool theReversed,
+ const std::string & theJointType,
+ const bool theApprox)
+{
+ std::shared_ptr<ModelAPI_Feature> aFeature =
+ compositeFeature()->addFeature(SketchPlugin_Offset::ID());
+ return OffsetPtr(new SketchAPI_Offset(aFeature, theObjects, theValue, theReversed, theJointType, theApprox));
+}
+
//--------------------------------------------------------------------------------------
std::shared_ptr<SketchAPI_Translation> SketchAPI_Sketch::addTranslation(
const std::list<std::shared_ptr<ModelAPI_Object> > & theObjects,
if (aVersion == SketchPlugin_ConstraintAngle::THE_VERSION_1) {
std::string aTypeLC = theType;
- std::transform(aTypeLC.begin(), aTypeLC.end(), aTypeLC.begin(), ::tolower);
+ std::transform(aTypeLC.begin(), aTypeLC.end(), aTypeLC.begin(),
+ [](char c) { return static_cast<char>(::tolower(c)); });
if (aTypeLC == "supplementary")
aType = (int)SketcherPrs_Tools::ANGLE_COMPLEMENTARY;
else if (aTypeLC == "backward")
{
std::shared_ptr<ModelAPI_Feature> aFeature =
compositeFeature()->addFeature(SketchPlugin_ConstraintMiddle::ID());
+ auto aType = aFeature->data()->string(SketchPlugin_ConstraintMiddle::MIDDLE_TYPE());
+ fillAttribute(SketchPlugin_ConstraintMiddle::MIDDLE_TYPE_BY_LINE_AND_POINT(), aType);
+
fillAttribute(thePoint, aFeature->refattr(SketchPlugin_Constraint::ENTITY_A()));
fillAttribute(theLine, aFeature->refattr(SketchPlugin_Constraint::ENTITY_B()));
+
aFeature->execute();
return InterfacePtr(new ModelHighAPI_Interface(aFeature));
}
+std::shared_ptr<SketchAPI_MacroMiddlePoint> SketchAPI_Sketch::setMiddlePoint(
+ const ModelHighAPI_RefAttr& theLine)
+{
+ std::shared_ptr<ModelAPI_Feature> aFeature =
+ compositeFeature()->addFeature(SketchPlugin_Point::ID());
+
+ ObjectPtr anObj = theLine.object();
+ auto aPoint = middlePoint(anObj, this);
+
+ return std::shared_ptr<SketchAPI_MacroMiddlePoint>
+ (new SketchAPI_MacroMiddlePoint(aFeature, theLine, aPoint));
+}
+
std::shared_ptr<ModelHighAPI_Interface> SketchAPI_Sketch::setParallel(
const ModelHighAPI_RefAttr & theLine1,
const ModelHighAPI_RefAttr & theLine2)
//--------------------------------------------------------------------------------------
-static std::shared_ptr<GeomAPI_Pnt2d> pointCoordinates(const AttributePtr& thePoint)
-{
- AttributePoint2DPtr aPnt = std::dynamic_pointer_cast<GeomDataAPI_Point2D>(thePoint);
- return aPnt ? aPnt->pnt() : std::shared_ptr<GeomAPI_Pnt2d>();
-}
-
-static std::shared_ptr<GeomAPI_Pnt2d> middlePointOnLine(const FeaturePtr& theFeature)
-{
- AttributePoint2DPtr aStartAttr = std::dynamic_pointer_cast<GeomDataAPI_Point2D>(
- theFeature->attribute(SketchPlugin_Line::START_ID()));
- AttributePoint2DPtr aEndAttr = std::dynamic_pointer_cast<GeomDataAPI_Point2D>(
- theFeature->attribute(SketchPlugin_Line::END_ID()));
-
- if (!aStartAttr || !aEndAttr)
- return std::shared_ptr<GeomAPI_Pnt2d>();
-
- std::shared_ptr<GeomAPI_XY> aStartPoint = aStartAttr->pnt()->xy();
- std::shared_ptr<GeomAPI_XY> aEndPoint = aEndAttr->pnt()->xy();
- return std::shared_ptr<GeomAPI_Pnt2d>(
- new GeomAPI_Pnt2d(aStartPoint->added(aEndPoint)->multiplied(0.5)));
-}
-
-static std::shared_ptr<GeomAPI_Pnt2d> pointOnCircle(const FeaturePtr& theFeature)
-{
- AttributePoint2DPtr aCenter = std::dynamic_pointer_cast<GeomDataAPI_Point2D>(
- theFeature->attribute(SketchPlugin_Circle::CENTER_ID()));
- AttributeDoublePtr aRadius = theFeature->real(SketchPlugin_Circle::RADIUS_ID());
-
- if (!aCenter || !aRadius)
- return std::shared_ptr<GeomAPI_Pnt2d>();
-
- return std::shared_ptr<GeomAPI_Pnt2d>(
- new GeomAPI_Pnt2d(aCenter->x() + aRadius->value(), aCenter->y()));
-}
-
-static std::shared_ptr<GeomAPI_Pnt2d> middlePointOnArc(const FeaturePtr& theFeature)
-{
- static const double PI = 3.141592653589793238463;
-
- AttributePoint2DPtr aCenterAttr = std::dynamic_pointer_cast<GeomDataAPI_Point2D>(
- theFeature->attribute(SketchPlugin_Arc::CENTER_ID()));
- AttributePoint2DPtr aStartAttr = std::dynamic_pointer_cast<GeomDataAPI_Point2D>(
- theFeature->attribute(SketchPlugin_Arc::START_ID()));
- AttributePoint2DPtr aEndAttr = std::dynamic_pointer_cast<GeomDataAPI_Point2D>(
- theFeature->attribute(SketchPlugin_Arc::END_ID()));
-
- if (!aCenterAttr || !aStartAttr || !aEndAttr)
- return std::shared_ptr<GeomAPI_Pnt2d>();
-
- std::shared_ptr<GeomAPI_Dir2d> aStartDir(new GeomAPI_Dir2d(
- aStartAttr->x() - aCenterAttr->x(), aStartAttr->y() - aCenterAttr->y()));
- std::shared_ptr<GeomAPI_Dir2d> aEndDir(new GeomAPI_Dir2d(
- aEndAttr->x() - aCenterAttr->x(), aEndAttr->y() - aCenterAttr->y()));
-
- double anAngle = aStartDir->angle(aEndDir);
- bool isReversed = theFeature->boolean(SketchPlugin_Arc::REVERSED_ID())->value();
- if (isReversed && anAngle > 0.)
- anAngle -= 2.0 * PI;
- else if (!isReversed && anAngle <= 0.)
- anAngle += 2.0 * PI;
-
- double cosA = cos(anAngle);
- double sinA = sin(anAngle);
-
- // rotate start dir to find middle point on arc
- double aRadius = aStartAttr->pnt()->distance(aCenterAttr->pnt());
- double x = aCenterAttr->x() + aRadius * (aStartDir->x() * cosA - aStartDir->y() * sinA);
- double y = aCenterAttr->y() + aRadius * (aStartDir->x() * sinA + aStartDir->y() * cosA);
-
- return std::shared_ptr<GeomAPI_Pnt2d>(new GeomAPI_Pnt2d(x, y));
-}
-
-static std::shared_ptr<GeomAPI_Pnt2d> pointOnEllipse(const FeaturePtr& theFeature,
- bool isEllipse = true)
-{
- const std::string& anAttrName = isEllipse ? SketchPlugin_Ellipse::MAJOR_AXIS_END_ID() :
- SketchPlugin_EllipticArc::MAJOR_AXIS_END_ID();
- AttributePoint2DPtr aMajorAxisEnd = std::dynamic_pointer_cast<GeomDataAPI_Point2D>(
- theFeature->attribute(anAttrName));
- return aMajorAxisEnd ? aMajorAxisEnd->pnt() : std::shared_ptr<GeomAPI_Pnt2d>();
-}
-
-static std::shared_ptr<GeomAPI_Pnt2d> middlePoint(const ObjectPtr& theObject)
-{
- std::shared_ptr<GeomAPI_Pnt2d> aMiddlePoint;
- FeaturePtr aFeature = ModelAPI_Feature::feature(theObject);
- if (aFeature) {
- // move only features of the following types
- const std::string& aFeatureKind = aFeature->getKind();
- if (aFeatureKind == SketchPlugin_Point::ID())
- aMiddlePoint = pointCoordinates(aFeature->attribute(SketchPlugin_Point::COORD_ID()));
- else if (aFeatureKind == SketchPlugin_Line::ID())
- aMiddlePoint = middlePointOnLine(aFeature);
- else if (aFeatureKind == SketchPlugin_Circle::ID())
- aMiddlePoint = pointOnCircle(aFeature);
- else if (aFeatureKind == SketchPlugin_Arc::ID())
- aMiddlePoint = middlePointOnArc(aFeature);
- else if (aFeatureKind == SketchPlugin_Ellipse::ID())
- aMiddlePoint = pointOnEllipse(aFeature);
- else if (aFeatureKind == SketchPlugin_EllipticArc::ID())
- aMiddlePoint = pointOnEllipse(aFeature, false);
- }
- return aMiddlePoint;
-}
-
void SketchAPI_Sketch::move(const ModelHighAPI_RefAttr& theMovedEntity,
const std::shared_ptr<GeomAPI_Pnt2d>& theTargetPoint)
{
if (aMessage->movedAttribute())
anOriginalPosition = pointCoordinates(aMessage->movedAttribute());
else
- anOriginalPosition = middlePoint(aMessage->movedObject());
+ anOriginalPosition = middlePoint(aMessage->movedObject(), this);
if (!anOriginalPosition)
return; // something has gone wrong, do not process movement
aBase->attribute(SketchPlugin_Sketch::DIRX_ID()))->dir();
// Check the plane is coordinate plane
- std::string aPlaneName = defaultPlane(anOrigin, aNormal, aDirX);
+ std::wstring aPlaneName = defaultPlane(anOrigin, aNormal, aDirX);
if(anExternal->context()) { // checking for selected planes
if (!aPlaneName.empty()
&& anExternal->context()->data()
