+std::shared_ptr<SketchAPI_Ellipse> SketchAPI_Sketch::addEllipse(
+ double theCenterX, double theCenterY,
+ double theFocusX, double theFocusY,
+ double theMinorRadius)
+{
+ std::shared_ptr<ModelAPI_Feature> aFeature =
+ compositeFeature()->addFeature(SketchPlugin_Ellipse::ID());
+ return EllipsePtr(new SketchAPI_Ellipse(aFeature,
+ theCenterX, theCenterY, theFocusX, theFocusY, theMinorRadius));
+}
+
+std::shared_ptr<SketchAPI_Ellipse> SketchAPI_Sketch::addEllipse(
+ const std::shared_ptr<GeomAPI_Pnt2d>& theCenter,
+ const std::shared_ptr<GeomAPI_Pnt2d>& theFocus,
+ double theMinorRadius)
+{
+ std::shared_ptr<ModelAPI_Feature> aFeature =
+ compositeFeature()->addFeature(SketchPlugin_Ellipse::ID());
+ return EllipsePtr(new SketchAPI_Ellipse(aFeature, theCenter, theFocus, theMinorRadius));
+}
+
+std::shared_ptr<SketchAPI_MacroEllipse> SketchAPI_Sketch::addEllipse(
+ double thePoint1X, double thePoint1Y,
+ double thePoint2X, double thePoint2Y,
+ double thePassedX, double thePassedY,
+ bool isPoint1Center)
+{
+ std::shared_ptr<ModelAPI_Feature> aFeature =
+ compositeFeature()->addFeature(SketchPlugin_MacroEllipse::ID());
+ return MacroEllipsePtr(new SketchAPI_MacroEllipse(aFeature,
+ thePoint1X, thePoint1Y, thePoint2X, thePoint2Y, thePassedX, thePassedY, isPoint1Center));
+}
+
+std::shared_ptr<SketchAPI_MacroEllipse> SketchAPI_Sketch::addEllipse(
+ const PointOrReference& thePoint1,
+ const PointOrReference& thePoint2,
+ const PointOrReference& thePassedPoint,
+ bool isPoint1Center)
+{
+ std::shared_ptr<ModelAPI_Feature> aFeature =
+ compositeFeature()->addFeature(SketchPlugin_MacroEllipse::ID());
+ MacroEllipsePtr anEllipse;
+ if (thePoint1.second.isEmpty() &&
+ thePoint2.second.isEmpty() &&
+ thePassedPoint.second.isEmpty()) {
+ anEllipse.reset(new SketchAPI_MacroEllipse(aFeature,
+ thePoint1.first, thePoint2.first, thePassedPoint.first, isPoint1Center));
+ }
+ else {
+ anEllipse.reset(new SketchAPI_MacroEllipse(aFeature,
+ thePoint1.first, thePoint1.second,
+ thePoint2.first, thePoint2.second,
+ thePassedPoint.first, thePassedPoint.second,
+ isPoint1Center));
+ }
+ return anEllipse;
+}
+
+std::shared_ptr<SketchAPI_Ellipse> SketchAPI_Sketch::addEllipse(
+ const ModelHighAPI_Selection & theExternal)
+{
+ std::shared_ptr<ModelAPI_Feature> aFeature =
+ compositeFeature()->addFeature(SketchPlugin_Ellipse::ID());
+ return EllipsePtr(new SketchAPI_Ellipse(aFeature, theExternal));
+}
+
+std::shared_ptr<SketchAPI_Ellipse> SketchAPI_Sketch::addEllipse(
+ const std::string & theExternalName)
+{
+ std::shared_ptr<ModelAPI_Feature> aFeature =
+ compositeFeature()->addFeature(SketchPlugin_Ellipse::ID());
+ return EllipsePtr(new SketchAPI_Ellipse(aFeature, theExternalName));
+}
+
+//--------------------------------------------------------------------------------------
+std::shared_ptr<SketchAPI_EllipticArc> SketchAPI_Sketch::addEllipticArc(
+ double theCenterX, double theCenterY,
+ double theFocusX, double theFocusY,
+ double theStartX, double theStartY,
+ double theEndX, double theEndY,
+ bool theInversed)
+{
+ std::shared_ptr<ModelAPI_Feature> aFeature =
+ compositeFeature()->addFeature(SketchPlugin_EllipticArc::ID());
+ return EllipticArcPtr(new SketchAPI_EllipticArc(aFeature,
+ theCenterX, theCenterY,
+ theFocusX, theFocusY,
+ theStartX, theStartY,
+ theEndX, theEndY,
+ theInversed));
+}
+
+std::shared_ptr<SketchAPI_MacroEllipticArc> SketchAPI_Sketch::addEllipticArc(
+ const PointOrReference& theCenter,
+ const PointOrReference& theMajorAxisPoint,
+ const PointOrReference& theStartPoint,
+ const PointOrReference& theEndPoint,
+ bool theInversed)
+{
+ std::shared_ptr<ModelAPI_Feature> aFeature =
+ compositeFeature()->addFeature(SketchPlugin_MacroEllipticArc::ID());
+ return MacroEllipticArcPtr(new SketchAPI_MacroEllipticArc(aFeature,
+ theCenter.first, theCenter.second,
+ theMajorAxisPoint.first, theMajorAxisPoint.second,
+ theStartPoint.first, theStartPoint.second,
+ theEndPoint.first, theEndPoint.second,
+ theInversed));
+}
+
+std::shared_ptr<SketchAPI_EllipticArc> SketchAPI_Sketch::addEllipticArc(
+ const ModelHighAPI_Selection & theExternal)
+{
+ std::shared_ptr<ModelAPI_Feature> aFeature =
+ compositeFeature()->addFeature(SketchPlugin_EllipticArc::ID());
+ return EllipticArcPtr(new SketchAPI_EllipticArc(aFeature, theExternal));
+}
+
+std::shared_ptr<SketchAPI_EllipticArc> SketchAPI_Sketch::addEllipticArc(
+ const std::string & theExternalName)
+{
+ std::shared_ptr<ModelAPI_Feature> aFeature =
+ compositeFeature()->addFeature(SketchPlugin_EllipticArc::ID());
+ return EllipticArcPtr(new SketchAPI_EllipticArc(aFeature, theExternalName));
+}
+
+//--------------------------------------------------------------------------------------
+
+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;
+}
+
+//--------------------------------------------------------------------------------------
+std::shared_ptr<SketchAPI_Projection> SketchAPI_Sketch::addProjection(
+ const ModelHighAPI_Selection & theExternalFeature,
+ bool theKeepResult)
+{
+ std::shared_ptr<ModelAPI_Feature> aFeature =
+ compositeFeature()->addFeature(SketchPlugin_Projection::ID());
+ ProjectionPtr aProjection(new SketchAPI_Projection(aFeature, theExternalFeature));
+ aProjection->setIncludeToResult(theKeepResult);
+ return aProjection;
+}
+
+std::shared_ptr<SketchAPI_Projection> SketchAPI_Sketch::addProjection(
+ const std::string & theExternalName,
+ bool theKeepResult)
+{
+ std::shared_ptr<ModelAPI_Feature> aFeature =
+ compositeFeature()->addFeature(SketchPlugin_Projection::ID());
+ ProjectionPtr aProjection(new SketchAPI_Projection(aFeature, theExternalName));
+ aProjection->setIncludeToResult(theKeepResult);
+ return aProjection;
+}
+
+//--------------------------------------------------------------------------------------
+std::shared_ptr<SketchAPI_Mirror> SketchAPI_Sketch::addMirror(
+ const ModelHighAPI_RefAttr & theMirrorLine,
+ const std::list<std::shared_ptr<ModelAPI_Object> > & theObjects)
+{
+ std::shared_ptr<ModelAPI_Feature> aFeature =
+ compositeFeature()->addFeature(SketchPlugin_ConstraintMirror::ID());
+ return MirrorPtr(new SketchAPI_Mirror(aFeature, theMirrorLine, theObjects));
+}
+
+//--------------------------------------------------------------------------------------
+std::shared_ptr<SketchAPI_Translation> SketchAPI_Sketch::addTranslation(
+ const std::list<std::shared_ptr<ModelAPI_Object> > & theObjects,
+ const ModelHighAPI_RefAttr & thePoint1,
+ const ModelHighAPI_RefAttr & thePoint2,
+ const ModelHighAPI_Integer & theNumberOfObjects,
+ bool theFullValue)
+{
+ std::shared_ptr<ModelAPI_Feature> aFeature =
+ compositeFeature()->addFeature(SketchPlugin_MultiTranslation::ID());
+ return TranslationPtr(new SketchAPI_Translation(aFeature, theObjects, thePoint1,
+ thePoint2, theNumberOfObjects, theFullValue));
+}
+
+//--------------------------------------------------------------------------------------
+std::shared_ptr<SketchAPI_Rotation> SketchAPI_Sketch::addRotation(
+ const std::list<std::shared_ptr<ModelAPI_Object> > & theObjects,
+ const ModelHighAPI_RefAttr & theCenter,
+ const ModelHighAPI_Double & theAngle,
+ const ModelHighAPI_Integer & theNumberOfObjects,
+ bool theFullValue,
+ bool theReversed)
+{
+ std::shared_ptr<ModelAPI_Feature> aFeature =
+ compositeFeature()->addFeature(SketchPlugin_MultiRotation::ID());
+ return RotationPtr(
+ new SketchAPI_Rotation(aFeature, theObjects, theCenter,
+ theAngle, theNumberOfObjects, theFullValue, theReversed));
+}
+
+//--------------------------------------------------------------------------------------
+std::shared_ptr<ModelHighAPI_Interface> SketchAPI_Sketch::addSplit(
+ const ModelHighAPI_Reference& theFeature,
+ const std::shared_ptr<GeomAPI_Pnt2d>& thePositionPoint)
+{
+ std::shared_ptr<ModelAPI_Feature> aFeature =
+ compositeFeature()->addFeature(SketchPlugin_Split::ID());
+ fillAttribute(theFeature, aFeature->reference(SketchPlugin_Split::SELECTED_OBJECT()));
+
+ AttributePtr anAttribute = aFeature->attribute(SketchPlugin_Split::SELECTED_POINT());
+ if (anAttribute->attributeType() == GeomDataAPI_Point2D::typeId()) {
+ AttributePoint2DPtr aPointAttr = std::dynamic_pointer_cast<GeomDataAPI_Point2D>(anAttribute);
+ fillAttribute(thePositionPoint, aPointAttr);
+ }
+
+ return InterfacePtr(new ModelHighAPI_Interface(aFeature));
+}
+
+//--------------------------------------------------------------------------------------
+std::shared_ptr<ModelHighAPI_Interface> SketchAPI_Sketch::addTrim(
+ const ModelHighAPI_Reference& theFeature,
+ const std::shared_ptr<GeomAPI_Pnt2d>& thePositionPoint)
+{
+ std::shared_ptr<ModelAPI_Feature> aFeature =
+ compositeFeature()->addFeature(SketchPlugin_Trim::ID());
+ fillAttribute(theFeature, aFeature->reference(SketchPlugin_Trim::SELECTED_OBJECT()));
+
+ AttributePtr anAttribute = aFeature->attribute(SketchPlugin_Trim::SELECTED_POINT());
+ if (anAttribute->attributeType() == GeomDataAPI_Point2D::typeId()) {
+ AttributePoint2DPtr aPointAttr = std::dynamic_pointer_cast<GeomDataAPI_Point2D>(anAttribute);
+ fillAttribute(thePositionPoint, aPointAttr);
+ }
+
+ return InterfacePtr(new ModelHighAPI_Interface(aFeature));
+}
+
+//--------------------------------------------------------------------------------------
+std::shared_ptr<ModelHighAPI_Interface> SketchAPI_Sketch::setAngle(
+ const ModelHighAPI_RefAttr & theLine1,
+ const ModelHighAPI_RefAttr & theLine2,
+ const ModelHighAPI_Double & theValue,
+ const std::string& theType)
+{
+ std::shared_ptr<ModelAPI_Feature> aFeature =
+ compositeFeature()->addFeature(SketchPlugin_ConstraintAngle::ID());
+
+ const int aVersion = theType.empty() ? SketchPlugin_ConstraintAngle::THE_VERSION_0
+ : SketchPlugin_ConstraintAngle::THE_VERSION_1;
+ fillAttribute(aVersion, aFeature->integer(SketchPlugin_ConstraintAngle::VERSION_ID()));
+
+ int aType = (int)SketcherPrs_Tools::ANGLE_DIRECT;
+ fillAttribute(aType, aFeature->integer(SketchPlugin_ConstraintAngle::PREV_TYPE_ID()));
+ fillAttribute(aType, aFeature->integer(SketchPlugin_ConstraintAngle::TYPE_ID()));
+
+ if (aVersion == SketchPlugin_ConstraintAngle::THE_VERSION_0)
+ fillAttribute(theValue, aFeature->real(SketchPlugin_ConstraintAngle::ANGLE_VALUE_ID()));
+
+ fillAttribute(theLine1, aFeature->refattr(SketchPlugin_Constraint::ENTITY_A()));
+ fillAttribute(theLine2, aFeature->refattr(SketchPlugin_Constraint::ENTITY_B()));
+
+ if (aVersion == SketchPlugin_ConstraintAngle::THE_VERSION_1) {
+ std::string aTypeLC = theType;
+ std::transform(aTypeLC.begin(), aTypeLC.end(), aTypeLC.begin(), ::tolower);
+ if (aTypeLC == "supplementary")
+ aType = (int)SketcherPrs_Tools::ANGLE_COMPLEMENTARY;
+ else if (aTypeLC == "backward")
+ aType = (int)SketcherPrs_Tools::ANGLE_BACKWARD;
+
+ fillAttribute(aType, aFeature->integer(SketchPlugin_ConstraintAngle::TYPE_ID()));
+ fillAttribute(theValue, aFeature->real(SketchPlugin_ConstraintAngle::ANGLE_VALUE_ID()));
+ }
+
+ aFeature->execute();
+ return InterfacePtr(new ModelHighAPI_Interface(aFeature));
+}
+
+std::shared_ptr<ModelHighAPI_Interface> SketchAPI_Sketch::setAngleComplementary(