X-Git-Url: http://git.salome-platform.org/gitweb/?a=blobdiff_plain;f=src%2FSketchAPI%2FSketchAPI_Sketch.cpp;h=ad2e2b55d2e96fa4bd26b95d5b9cd8cee212be22;hb=94581487c6eb2ab39101070bb60fd6562903b989;hp=e16966ecac78be584ec5413fa2cf7d8a442fa686;hpb=14e1c70aaa0300fdb3c780e2e8dce0e4ba305072;p=modules%2Fshaper.git diff --git a/src/SketchAPI/SketchAPI_Sketch.cpp b/src/SketchAPI/SketchAPI_Sketch.cpp index e16966eca..ad2e2b55d 100644 --- a/src/SketchAPI/SketchAPI_Sketch.cpp +++ b/src/SketchAPI/SketchAPI_Sketch.cpp @@ -7,9 +7,43 @@ //-------------------------------------------------------------------------------------- #include "SketchAPI_Sketch.h" //-------------------------------------------------------------------------------------- +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +//-------------------------------------------------------------------------------------- #include +#include +#include +#include +#include +#include #include +//-------------------------------------------------------------------------------------- +#include "SketchAPI_Arc.h" +#include "SketchAPI_Circle.h" +#include "SketchAPI_IntersectionPoint.h" #include "SketchAPI_Line.h" +#include "SketchAPI_Mirror.h" +#include "SketchAPI_Point.h" +#include "SketchAPI_Projection.h" +#include "SketchAPI_Rectangle.h" +#include "SketchAPI_Rotation.h" +#include "SketchAPI_Translation.h" //-------------------------------------------------------------------------------------- SketchAPI_Sketch::SketchAPI_Sketch( const std::shared_ptr & theFeature) @@ -38,6 +72,16 @@ SketchAPI_Sketch::SketchAPI_Sketch( } } +SketchAPI_Sketch::SketchAPI_Sketch( + const std::shared_ptr & theFeature, + std::shared_ptr thePlaneObject) +: ModelHighAPI_Interface(theFeature) +{ + if (initialize()) { + setExternal(thePlaneObject); + } +} + SketchAPI_Sketch::~SketchAPI_Sketch() { @@ -66,6 +110,45 @@ void SketchAPI_Sketch::setExternal(const ModelHighAPI_Selection & theExternal) execute(); } +void SketchAPI_Sketch::setExternal(std::shared_ptr thePlaneObject) +{ + ResultPtr aRes = std::dynamic_pointer_cast(thePlaneObject); + ModelHighAPI_Selection aSel(aRes); + setExternal(aSel); +} + +//-------------------------------------------------------------------------------------- +void SketchAPI_Sketch::setValue( + const std::shared_ptr & theConstraint, + const ModelHighAPI_Double & theValue) +{ + // TODO(spo): check somehow that the feature is a constraint or eliminate crash if the feature have no real attribute VALUE + fillAttribute(theValue, theConstraint->real(SketchPlugin_Constraint::VALUE())); + +// theConstraint->execute(); +} + +//-------------------------------------------------------------------------------------- +std::list SketchAPI_Sketch::selectFace() const +{ + const_cast(this)->execute(); + + std::list aSelectionList; + + ResultConstructionPtr aResultConstruction = + std::dynamic_pointer_cast(feature()->firstResult()); + if (aResultConstruction.get() == NULL) + return aSelectionList; + + for (int anIndex = 0; anIndex < aResultConstruction->facesNum(); ++anIndex) { + aSelectionList.push_back( + ModelHighAPI_Selection(aResultConstruction, + aResultConstruction->face(anIndex))); + } + + return aSelectionList; +} + //-------------------------------------------------------------------------------------- SketchPtr addSketch(const std::shared_ptr & thePart, const std::shared_ptr & thePlane) @@ -83,6 +166,60 @@ SketchPtr addSketch(const std::shared_ptr & thePart, return SketchPtr(new SketchAPI_Sketch(aFeature, theExternal)); } +SketchPtr addSketch(const std::shared_ptr & thePart, + const std::string & theExternalName) +{ + // TODO(spo): check that thePart is not empty + std::shared_ptr aFeature = thePart->addFeature(SketchAPI_Sketch::ID()); + return SketchPtr(new SketchAPI_Sketch(aFeature, ModelHighAPI_Selection("FACE", theExternalName))); +} + +SketchPtr addSketch(const std::shared_ptr & thePart, + std::shared_ptr thePlaneObject) +{ + std::shared_ptr aFeature = thePart->addFeature(SketchAPI_Sketch::ID()); + return SketchPtr(new SketchAPI_Sketch(aFeature, thePlaneObject)); +} + + +//-------------------------------------------------------------------------------------- +std::shared_ptr SketchAPI_Sketch::addPoint( + double theX, double theY) +{ + std::shared_ptr aFeature = compositeFeature()->addFeature(SketchPlugin_Point::ID()); + return PointPtr(new SketchAPI_Point(aFeature, theX, theY)); +} +std::shared_ptr SketchAPI_Sketch::addPoint( + const std::shared_ptr & thePoint) +{ + std::shared_ptr aFeature = compositeFeature()->addFeature(SketchPlugin_Point::ID()); + return PointPtr(new SketchAPI_Point(aFeature, thePoint)); +} +std::shared_ptr SketchAPI_Sketch::addPoint(const ModelHighAPI_Selection & theExternal) +{ + std::shared_ptr aFeature = compositeFeature()->addFeature(SketchPlugin_Point::ID()); + return PointPtr(new SketchAPI_Point(aFeature, theExternal)); +} +std::shared_ptr SketchAPI_Sketch::addPoint(const std::string & theExternalName) +{ + std::shared_ptr aFeature = compositeFeature()->addFeature(SketchPlugin_Point::ID()); + return PointPtr(new SketchAPI_Point(aFeature, theExternalName)); +} + +//-------------------------------------------------------------------------------------- +std::shared_ptr SketchAPI_Sketch::addIntersectionPoint( + const ModelHighAPI_Selection & theExternal) +{ + std::shared_ptr aFeature = compositeFeature()->addFeature(SketchPlugin_IntersectionPoint::ID()); + return IntersectionPointPtr(new SketchAPI_IntersectionPoint(aFeature, theExternal)); +} +std::shared_ptr SketchAPI_Sketch::addIntersectionPoint( + const std::string & theExternalName) +{ + std::shared_ptr aFeature = compositeFeature()->addFeature(SketchPlugin_IntersectionPoint::ID()); + return IntersectionPointPtr(new SketchAPI_IntersectionPoint(aFeature, theExternalName)); +} + //-------------------------------------------------------------------------------------- std::shared_ptr SketchAPI_Sketch::addLine(double theX1, double theY1, double theX2, double theY2) { @@ -103,9 +240,458 @@ std::shared_ptr SketchAPI_Sketch::addLine(const ModelHighAPI_Sel } std::shared_ptr SketchAPI_Sketch::addLine(const std::string & theExternalName) { - // TODO(spo): Add constraint SketchConstraintRigid like in PythonAPI. Is it necessary? std::shared_ptr aFeature = compositeFeature()->addFeature(SketchPlugin_Line::ID()); return LinePtr(new SketchAPI_Line(aFeature, theExternalName)); } //-------------------------------------------------------------------------------------- +std::shared_ptr SketchAPI_Sketch::addRectangle(double theX1, double theY1, double theX2, double theY2) +{ + std::shared_ptr aFeature = compositeFeature()->addFeature(SketchAPI_Rectangle::ID()); + return RectanglePtr(new SketchAPI_Rectangle(aFeature, theX1, theY1, theX2, theY2)); +} +std::shared_ptr SketchAPI_Sketch::addRectangle( + const std::shared_ptr & theStartPoint, + const std::shared_ptr & theEndPoint) +{ + std::shared_ptr aFeature = compositeFeature()->addFeature(SketchAPI_Rectangle::ID()); + return RectanglePtr(new SketchAPI_Rectangle(aFeature, theStartPoint, theEndPoint)); +} + +//-------------------------------------------------------------------------------------- +std::shared_ptr SketchAPI_Sketch::addCircle(double theCenterX, + double theCenterY, + double theRadius) +{ + std::shared_ptr aFeature = compositeFeature()->addFeature(SketchPlugin_Circle::ID()); + return CirclePtr(new SketchAPI_Circle(aFeature, theCenterX, theCenterY, theRadius)); +} + +std::shared_ptr SketchAPI_Sketch::addCircle(const std::shared_ptr& theCenter, + double theRadius) +{ + std::shared_ptr aFeature = compositeFeature()->addFeature(SketchPlugin_Circle::ID()); + return CirclePtr(new SketchAPI_Circle(aFeature, theCenter, theRadius)); +} + +std::shared_ptr SketchAPI_Sketch::addCircle(double theX1, double theY1, + double theX2, double theY2, + double theX3, double theY3) +{ + std::shared_ptr aFeature = compositeFeature()->addFeature(SketchPlugin_Circle::ID()); + return CirclePtr(new SketchAPI_Circle(aFeature, theX1, theY1, theX2, theY2, theX3, theY3)); +} + +std::shared_ptr SketchAPI_Sketch::addCircle(const std::shared_ptr& thePoint1, + const std::shared_ptr& thePoint2, + const std::shared_ptr& thePoint3) +{ + std::shared_ptr aFeature = compositeFeature()->addFeature(SketchPlugin_Circle::ID()); + return CirclePtr(new SketchAPI_Circle(aFeature, thePoint1, thePoint2, thePoint3)); +} + +std::shared_ptr SketchAPI_Sketch::addCircle(const ModelHighAPI_Selection & theExternal) +{ + std::shared_ptr aFeature = compositeFeature()->addFeature(SketchPlugin_Circle::ID()); + return CirclePtr(new SketchAPI_Circle(aFeature, theExternal)); +} + +std::shared_ptr SketchAPI_Sketch::addCircle(const std::string & theExternalName) +{ + // TODO(spo): Add constraint SketchConstraintRigid like in PythonAPI. Is it necessary? + std::shared_ptr aFeature = compositeFeature()->addFeature(SketchPlugin_Circle::ID()); + return CirclePtr(new SketchAPI_Circle(aFeature, theExternalName)); +} + +//-------------------------------------------------------------------------------------- +std::shared_ptr SketchAPI_Sketch::addArc(double theCenterX, double theCenterY, + double theStartX, double theStartY, + double theEndX, double theEndY, + bool theInversed) +{ + std::shared_ptr aFeature = compositeFeature()->addFeature(SketchPlugin_Arc::ID()); + return ArcPtr(new SketchAPI_Arc(aFeature, + theCenterX, theCenterY, + theStartX, theStartY, + theEndX, theEndY, + theInversed)); +} + +std::shared_ptr SketchAPI_Sketch::addArc(const std::shared_ptr& theCenter, + const std::shared_ptr& theStart, + const std::shared_ptr& theEnd, + bool theInversed) +{ + std::shared_ptr aFeature = compositeFeature()->addFeature(SketchPlugin_Arc::ID()); + return ArcPtr(new SketchAPI_Arc(aFeature, theCenter, theStart, theEnd, theInversed)); +} + +std::shared_ptr SketchAPI_Sketch::addArc(double theStartX, double theStartY, + double theEndX, double theEndY, + double thePassedX, double thePassedY) +{ + std::shared_ptr aFeature = compositeFeature()->addFeature(SketchPlugin_Arc::ID()); + return ArcPtr(new SketchAPI_Arc(aFeature, + theStartX, theStartY, + theEndX, theEndY, + thePassedX, thePassedY)); +} + +std::shared_ptr SketchAPI_Sketch::addArc(const std::shared_ptr& theStart, + const std::shared_ptr& theEnd, + const std::shared_ptr& thePassed) +{ + std::shared_ptr aFeature = compositeFeature()->addFeature(SketchPlugin_Arc::ID()); + return ArcPtr(new SketchAPI_Arc(aFeature, theStart, theEnd, thePassed)); +} + +std::shared_ptr SketchAPI_Sketch::addArc(const ModelHighAPI_RefAttr& theTangentPoint, + double theEndX, double theEndY, + bool theInversed) +{ + std::shared_ptr aFeature = compositeFeature()->addFeature(SketchPlugin_Arc::ID()); + return ArcPtr(new SketchAPI_Arc(aFeature, theTangentPoint, theEndX, theEndY, theInversed)); +} + +std::shared_ptr SketchAPI_Sketch::addArc(const ModelHighAPI_RefAttr& theTangentPoint, + const std::shared_ptr& theEnd, + bool theInversed) +{ + std::shared_ptr aFeature = compositeFeature()->addFeature(SketchPlugin_Arc::ID()); + return ArcPtr(new SketchAPI_Arc(aFeature, theTangentPoint, theEnd, theInversed)); +} + +std::shared_ptr SketchAPI_Sketch::addArc(const ModelHighAPI_Selection & theExternal) +{ + std::shared_ptr aFeature = compositeFeature()->addFeature(SketchPlugin_Arc::ID()); + return ArcPtr(new SketchAPI_Arc(aFeature, theExternal)); +} + +std::shared_ptr SketchAPI_Sketch::addArc(const std::string & theExternalName) +{ + // TODO(spo): Add constraint SketchConstraintRigid like in PythonAPI. Is it necessary? + std::shared_ptr aFeature = compositeFeature()->addFeature(SketchPlugin_Arc::ID()); + return ArcPtr(new SketchAPI_Arc(aFeature, theExternalName)); +} + +//-------------------------------------------------------------------------------------- +std::shared_ptr SketchAPI_Sketch::addProjection( + const ModelHighAPI_Selection & theExternalFeature) +{ + std::shared_ptr aFeature = compositeFeature()->addFeature(SketchPlugin_Projection::ID()); + return ProjectionPtr(new SketchAPI_Projection(aFeature, theExternalFeature)); +} + +std::shared_ptr SketchAPI_Sketch::addProjection( + const std::string & theExternalName) +{ + std::shared_ptr aFeature = compositeFeature()->addFeature(SketchPlugin_Projection::ID()); + return ProjectionPtr(new SketchAPI_Projection(aFeature, theExternalName)); +} + +//-------------------------------------------------------------------------------------- +std::shared_ptr SketchAPI_Sketch::addMirror( + const ModelHighAPI_RefAttr & theMirrorLine, + const std::list > & theObjects) +{ + std::shared_ptr aFeature = compositeFeature()->addFeature(SketchPlugin_ConstraintMirror::ID()); + return MirrorPtr(new SketchAPI_Mirror(aFeature, theMirrorLine, theObjects)); +} + +//-------------------------------------------------------------------------------------- +std::shared_ptr SketchAPI_Sketch::addTranslation( + const std::list > & theObjects, + const ModelHighAPI_RefAttr & thePoint1, + const ModelHighAPI_RefAttr & thePoint2, + const ModelHighAPI_Integer & theNumberOfObjects, + bool theFullValue) +{ + std::shared_ptr aFeature = compositeFeature()->addFeature(SketchPlugin_MultiTranslation::ID()); + return TranslationPtr(new SketchAPI_Translation(aFeature, theObjects, thePoint1, thePoint2, theNumberOfObjects, theFullValue)); +} + +//-------------------------------------------------------------------------------------- +std::shared_ptr SketchAPI_Sketch::addRotation( + const std::list > & theObjects, + const ModelHighAPI_RefAttr & theCenter, + const ModelHighAPI_Double & theAngle, + const ModelHighAPI_Integer & theNumberOfObjects, + bool theFullValue) +{ + std::shared_ptr aFeature = compositeFeature()->addFeature(SketchPlugin_MultiRotation::ID()); + return RotationPtr(new SketchAPI_Rotation(aFeature, theObjects, theCenter, theAngle, theNumberOfObjects, theFullValue)); +} + +//-------------------------------------------------------------------------------------- +std::shared_ptr SketchAPI_Sketch::setAngle( + const ModelHighAPI_RefAttr & theLine1, + const ModelHighAPI_RefAttr & theLine2, + const ModelHighAPI_Double & theValue) +{ + std::shared_ptr aFeature = + compositeFeature()->addFeature(SketchPlugin_ConstraintAngle::ID()); + fillAttribute(SketcherPrs_Tools::ANGLE_DIRECT, + aFeature->integer(SketchPlugin_ConstraintAngle::TYPE_ID())); + fillAttribute(theLine1, aFeature->refattr(SketchPlugin_Constraint::ENTITY_A())); + fillAttribute(theLine2, aFeature->refattr(SketchPlugin_Constraint::ENTITY_B())); + fillAttribute(theValue, aFeature->real(SketchPlugin_Constraint::VALUE())); + aFeature->execute(); + return aFeature; +} + +std::shared_ptr SketchAPI_Sketch::setAngleComplementary( + const ModelHighAPI_RefAttr & theLine1, + const ModelHighAPI_RefAttr & theLine2, + const ModelHighAPI_Double & theValue) +{ + std::shared_ptr aFeature = + compositeFeature()->addFeature(SketchPlugin_ConstraintAngle::ID()); + fillAttribute(SketcherPrs_Tools::ANGLE_COMPLEMENTARY, + aFeature->integer(SketchPlugin_ConstraintAngle::TYPE_ID())); + 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())); +// fillAttribute(theValue, aFeature->real(SketchPlugin_Constraint::VALUE())); + aFeature->execute(); + return aFeature; +} + +std::shared_ptr SketchAPI_Sketch::setAngleBackward( + const ModelHighAPI_RefAttr & theLine1, + const ModelHighAPI_RefAttr & theLine2, + const ModelHighAPI_Double & theValue) +{ + std::shared_ptr aFeature = + compositeFeature()->addFeature(SketchPlugin_ConstraintAngle::ID()); + fillAttribute(SketcherPrs_Tools::ANGLE_BACKWARD, + aFeature->integer(SketchPlugin_ConstraintAngle::TYPE_ID())); + 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())); +// fillAttribute(theValue, aFeature->real(SketchPlugin_Constraint::VALUE())); + aFeature->execute(); + return aFeature; +} + +std::shared_ptr SketchAPI_Sketch::setCoincident( + const ModelHighAPI_RefAttr & thePoint1, + const ModelHighAPI_RefAttr & thePoint2) +{ + std::shared_ptr aFeature = + compositeFeature()->addFeature(SketchPlugin_ConstraintCoincidence::ID()); + fillAttribute(thePoint1, aFeature->refattr(SketchPlugin_Constraint::ENTITY_A())); + fillAttribute(thePoint2, aFeature->refattr(SketchPlugin_Constraint::ENTITY_B())); + aFeature->execute(); + return aFeature; +} + +std::shared_ptr SketchAPI_Sketch::setCollinear( + const ModelHighAPI_RefAttr & theLine1, + const ModelHighAPI_RefAttr & theLine2) +{ + std::shared_ptr aFeature = + compositeFeature()->addFeature(SketchPlugin_ConstraintCollinear::ID()); + fillAttribute(theLine1, aFeature->refattr(SketchPlugin_Constraint::ENTITY_A())); + fillAttribute(theLine2, aFeature->refattr(SketchPlugin_Constraint::ENTITY_B())); + aFeature->execute(); + return aFeature; +} + +std::shared_ptr SketchAPI_Sketch::setDistance( + const ModelHighAPI_RefAttr & thePoint, + const ModelHighAPI_RefAttr & thePointOrLine, + const ModelHighAPI_Double & theValue) +{ + std::shared_ptr aFeature = + compositeFeature()->addFeature(SketchPlugin_ConstraintDistance::ID()); + fillAttribute(thePoint, aFeature->refattr(SketchPlugin_Constraint::ENTITY_A())); + fillAttribute(thePointOrLine, aFeature->refattr(SketchPlugin_Constraint::ENTITY_B())); + fillAttribute(theValue, aFeature->real(SketchPlugin_Constraint::VALUE())); + aFeature->execute(); + return aFeature; +} + +std::shared_ptr SketchAPI_Sketch::setEqual( + const ModelHighAPI_RefAttr & theObject1, + const ModelHighAPI_RefAttr & theObject2) +{ + std::shared_ptr aFeature = + compositeFeature()->addFeature(SketchPlugin_ConstraintEqual::ID()); + fillAttribute(theObject1, aFeature->refattr(SketchPlugin_Constraint::ENTITY_A())); + fillAttribute(theObject2, aFeature->refattr(SketchPlugin_Constraint::ENTITY_B())); + aFeature->execute(); + return aFeature; +} + +std::shared_ptr SketchAPI_Sketch::setFillet( + const std::list & thePoints, + const ModelHighAPI_Double & theRadius) +{ + std::shared_ptr aFeature = + compositeFeature()->addFeature(SketchPlugin_ConstraintFillet::ID()); + fillAttribute(thePoints, aFeature->data()->refattrlist(SketchPlugin_Constraint::ENTITY_A())); + fillAttribute(theRadius, aFeature->real(SketchPlugin_Constraint::VALUE())); + aFeature->execute(); + return aFeature; +} + +std::shared_ptr SketchAPI_Sketch::setFixed( + const ModelHighAPI_RefAttr & theObject) +{ + std::shared_ptr aFeature = + compositeFeature()->addFeature(SketchPlugin_ConstraintRigid::ID()); + fillAttribute(theObject, aFeature->refattr(SketchPlugin_Constraint::ENTITY_A())); + aFeature->execute(); + return aFeature; +} + +std::shared_ptr SketchAPI_Sketch::setHorizontal( + const ModelHighAPI_RefAttr & theLine) +{ + std::shared_ptr aFeature = + compositeFeature()->addFeature(SketchPlugin_ConstraintHorizontal::ID()); + fillAttribute(theLine, aFeature->refattr(SketchPlugin_Constraint::ENTITY_A())); + aFeature->execute(); + return aFeature; +} + +std::shared_ptr SketchAPI_Sketch::setLength( + const ModelHighAPI_RefAttr & theLine, + const ModelHighAPI_Double & theValue) +{ + std::shared_ptr aFeature = + compositeFeature()->addFeature(SketchPlugin_ConstraintLength::ID()); + fillAttribute(theLine, aFeature->refattr(SketchPlugin_Constraint::ENTITY_A())); + fillAttribute(theValue, aFeature->real(SketchPlugin_Constraint::VALUE())); + aFeature->execute(); + return aFeature; +} + +std::shared_ptr SketchAPI_Sketch::setMiddlePoint( + const ModelHighAPI_RefAttr & thePoint, + const ModelHighAPI_RefAttr & theLine) +{ + std::shared_ptr aFeature = + compositeFeature()->addFeature(SketchPlugin_ConstraintMiddle::ID()); + fillAttribute(thePoint, aFeature->refattr(SketchPlugin_Constraint::ENTITY_A())); + fillAttribute(theLine, aFeature->refattr(SketchPlugin_Constraint::ENTITY_B())); + aFeature->execute(); + return aFeature; +} + +std::shared_ptr SketchAPI_Sketch::setParallel( + const ModelHighAPI_RefAttr & theLine1, + const ModelHighAPI_RefAttr & theLine2) +{ + std::shared_ptr aFeature = + compositeFeature()->addFeature(SketchPlugin_ConstraintParallel::ID()); + fillAttribute(theLine1, aFeature->refattr(SketchPlugin_Constraint::ENTITY_A())); + fillAttribute(theLine2, aFeature->refattr(SketchPlugin_Constraint::ENTITY_B())); + aFeature->execute(); + return aFeature; +} + +std::shared_ptr SketchAPI_Sketch::setPerpendicular( + const ModelHighAPI_RefAttr & theLine1, + const ModelHighAPI_RefAttr & theLine2) +{ + std::shared_ptr aFeature = + compositeFeature()->addFeature(SketchPlugin_ConstraintPerpendicular::ID()); + fillAttribute(theLine1, aFeature->refattr(SketchPlugin_Constraint::ENTITY_A())); + fillAttribute(theLine2, aFeature->refattr(SketchPlugin_Constraint::ENTITY_B())); + aFeature->execute(); + return aFeature; +} + +std::shared_ptr SketchAPI_Sketch::setRadius( + const ModelHighAPI_RefAttr & theCircleOrArc, + const ModelHighAPI_Double & theValue) +{ + std::shared_ptr aFeature = + compositeFeature()->addFeature(SketchPlugin_ConstraintRadius::ID()); + fillAttribute(theCircleOrArc, aFeature->refattr(SketchPlugin_Constraint::ENTITY_A())); + fillAttribute(theValue, aFeature->real(SketchPlugin_Constraint::VALUE())); + aFeature->execute(); + return aFeature; +} + +std::shared_ptr SketchAPI_Sketch::setTangent( + const ModelHighAPI_RefAttr & theLine, + const ModelHighAPI_RefAttr & theCircle) +{ + std::shared_ptr aFeature = + compositeFeature()->addFeature(SketchPlugin_ConstraintTangent::ID()); + fillAttribute(theLine, aFeature->refattr(SketchPlugin_Constraint::ENTITY_A())); + fillAttribute(theCircle, aFeature->refattr(SketchPlugin_Constraint::ENTITY_B())); + aFeature->execute(); + return aFeature; +} + +std::shared_ptr SketchAPI_Sketch::setVertical( + const ModelHighAPI_RefAttr & theLine) +{ + std::shared_ptr aFeature = + compositeFeature()->addFeature(SketchPlugin_ConstraintVertical::ID()); + fillAttribute(theLine, aFeature->refattr(SketchPlugin_Constraint::ENTITY_A())); + aFeature->execute(); + return aFeature; +} + +//-------------------------------------------------------------------------------------- + +void SketchAPI_Sketch::dump(ModelHighAPI_Dumper& theDumper) const +{ + FeaturePtr aBase = feature(); + const std::string& aDocName = theDumper.name(aBase->document()); + + AttributeSelectionPtr anExternal = aBase->selection(SketchPlugin_SketchEntity::EXTERNAL_ID()); + if (anExternal->value()) { + theDumper << aBase << " = model.addSketch(" << aDocName << ", " << anExternal << ")" << std::endl; + } else { + // Sketch is base on a plane. + std::shared_ptr anOrigin = std::dynamic_pointer_cast( + aBase->attribute(SketchPlugin_Sketch::ORIGIN_ID()))->pnt(); + std::shared_ptr aNormal = std::dynamic_pointer_cast( + aBase->attribute(SketchPlugin_Sketch::NORM_ID()))->dir(); + std::shared_ptr aDirX = std::dynamic_pointer_cast( + aBase->attribute(SketchPlugin_Sketch::DIRX_ID()))->dir(); + + // Check the plane is coordinate plane + std::string aPlaneName = defaultPlane(anOrigin, aNormal, aDirX); + if (anExternal->context()) { // checking for selected planes + if (!aPlaneName.empty()) { + // dump sketch based on coordinate plane + theDumper << aBase << " = model.addSketch(" << aDocName + << ", model.standardPlane(\"" << aPlaneName << "\"))" << std::endl; + } else { // some other plane + theDumper << aBase << " = model.addSketch(" << aDocName << ", " << anExternal<< ")" << std::endl; + } + } else { + if (aPlaneName.empty()) { + // needs import additional module + theDumper.importModule("GeomAPI"); + // dump plane parameters + const std::string& aSketchName = theDumper.name(aBase); + std::string anOriginName = aSketchName + "_origin"; + std::string aNormalName = aSketchName + "_norm"; + std::string aDirXName = aSketchName + "_dirx"; + // use "\n" instead of std::endl to avoid automatic dumping sketch here + // and then dumplicate dumping it in the next line + theDumper << anOriginName << " = " << anOrigin << "\n" + << aNormalName << " = " << aNormal << "\n" + << aDirXName << " = " << aDirX << "\n"; + // dump sketch based on arbitrary plane + theDumper << aBase << " = model.addSketch(" << aDocName << ", GeomAPI_Ax3(" + << anOriginName << ", " << aDirXName << ", " << aNormalName << "))" << std::endl; + } else { + // dump sketch based on coordinate plane + theDumper << aBase << " = model.addSketch(" << aDocName + << ", model.defaultPlane(\"" << aPlaneName << "\"))" << std::endl; + } + } + } + + // dump sketch's subfeatures + CompositeFeaturePtr aCompFeat = std::dynamic_pointer_cast(aBase); + theDumper.processSubs(aCompFeat, true); +}