src/SketchAPI/SketchAPI_Sketch.cpp

   1 // Copyright (C) 2014-2017  CEA/DEN, EDF R&D
   2 //
   3 // This library is free software; you can redistribute it and/or
   4 // modify it under the terms of the GNU Lesser General Public
   5 // License as published by the Free Software Foundation; either
   6 // version 2.1 of the License, or (at your option) any later version.
   7 //
   8 // This library is distributed in the hope that it will be useful,
   9 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  10 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  11 // Lesser General Public License for more details.
  12 //
  13 // You should have received a copy of the GNU Lesser General Public
  14 // License along with this library; if not, write to the Free Software
  15 // Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
  16 //
  17 // See http://www.salome-platform.org/ or
  18 // email : webmaster.salome@opencascade.com<mailto:webmaster.salome@opencascade.com>
  19 //
  20
  21 #include "SketchAPI_Sketch.h"
  22 //--------------------------------------------------------------------------------------
  23 #include <SketchPlugin_Constraint.h>
  24 #include <SketchPlugin_ConstraintAngle.h>
  25 #include <SketchPlugin_ConstraintCoincidence.h>
  26 #include <SketchPlugin_ConstraintCollinear.h>
  27 #include <SketchPlugin_ConstraintDistance.h>
  28 #include <SketchPlugin_ConstraintDistanceHorizontal.h>
  29 #include <SketchPlugin_ConstraintDistanceVertical.h>
  30 #include <SketchPlugin_ConstraintEqual.h>
  31 #include <SketchPlugin_Fillet.h>
  32 #include <SketchPlugin_ConstraintHorizontal.h>
  33 #include <SketchPlugin_ConstraintLength.h>
  34 #include <SketchPlugin_ConstraintMiddle.h>
  35 #include <SketchPlugin_ConstraintMirror.h>
  36 #include <SketchPlugin_ConstraintParallel.h>
  37 #include <SketchPlugin_ConstraintPerpendicular.h>
  38 #include <SketchPlugin_ConstraintRadius.h>
  39 #include <SketchPlugin_ConstraintRigid.h>
  40 #include <SketchPlugin_Trim.h>
  41 #include <SketchPlugin_Split.h>
  42 #include <SketchPlugin_ConstraintTangent.h>
  43 #include <SketchPlugin_ConstraintVertical.h>
  44 #include <SketcherPrs_Tools.h>
  45 //--------------------------------------------------------------------------------------
  46 #include <ModelAPI_Events.h>
  47 #include <ModelAPI_CompositeFeature.h>
  48 #include <ModelAPI_ResultConstruction.h>
  49 #include <ModelHighAPI_Double.h>
  50 #include <ModelHighAPI_Dumper.h>
  51 #include <ModelHighAPI_RefAttr.h>
  52 #include <ModelHighAPI_Selection.h>
  53 #include <ModelHighAPI_Services.h>
  54 #include <ModelHighAPI_Tools.h>
  55 //--------------------------------------------------------------------------------------
  56 #include "SketchAPI_Arc.h"
  57 #include "SketchAPI_MacroArc.h"
  58 #include "SketchAPI_Circle.h"
  59 #include "SketchAPI_IntersectionPoint.h"
  60 #include "SketchAPI_Line.h"
  61 #include "SketchAPI_MacroCircle.h"
  62 #include "SketchAPI_Mirror.h"
  63 #include "SketchAPI_Point.h"
  64 #include "SketchAPI_Projection.h"
  65 #include "SketchAPI_Rectangle.h"
  66 #include "SketchAPI_Rotation.h"
  67 #include "SketchAPI_Translation.h"
  68 //--------------------------------------------------------------------------------------
  69 #include <GeomAPI_Dir2d.h>
  70 #include <GeomAPI_XY.h>
  71 #include <cmath>
  72 //--------------------------------------------------------------------------------------
  73 SketchAPI_Sketch::SketchAPI_Sketch(
  74     const std::shared_ptr<ModelAPI_Feature> & theFeature)
  75 : ModelHighAPI_Interface(theFeature)
  76 {
  77   initialize();
  78 }
  79
  80 SketchAPI_Sketch::SketchAPI_Sketch(
  81     const std::shared_ptr<ModelAPI_Feature> & theFeature,
  82     const std::shared_ptr<GeomAPI_Ax3> & thePlane)
  83 : ModelHighAPI_Interface(theFeature)
  84 {
  85   if (initialize()) {
  86     setPlane(thePlane);
  87   }
  88 }
  89
  90 SketchAPI_Sketch::SketchAPI_Sketch(
  91     const std::shared_ptr<ModelAPI_Feature> & theFeature,
  92     const ModelHighAPI_Selection & theExternal)
  93 : ModelHighAPI_Interface(theFeature)
  94 {
  95   if (initialize()) {
  96     setExternal(theExternal);
  97   }
  98 }
  99
 100 SketchAPI_Sketch::SketchAPI_Sketch(
 101     const std::shared_ptr<ModelAPI_Feature> & theFeature,
 102     std::shared_ptr<ModelAPI_Object> thePlaneObject)
 103 : ModelHighAPI_Interface(theFeature)
 104 {
 105   if (initialize()) {
 106     setExternal(thePlaneObject);
 107   }
 108 }
 109
 110 SketchAPI_Sketch::~SketchAPI_Sketch()
 111 {
 112
 113 }
 114
 115 //--------------------------------------------------------------------------------------
 116 std::shared_ptr<ModelAPI_CompositeFeature> SketchAPI_Sketch::compositeFeature() const
 117 {
 118   return std::dynamic_pointer_cast<ModelAPI_CompositeFeature>(feature());
 119 }
 120
 121 //--------------------------------------------------------------------------------------
 122 void SketchAPI_Sketch::setPlane(const std::shared_ptr<GeomAPI_Ax3> & thePlane)
 123 {
 124   fillAttribute(thePlane->origin(), myorigin);
 125   fillAttribute(thePlane->dirX(), mydirX);
 126   fillAttribute(thePlane->normal(), mynormal);
 127
 128   execute();
 129 }
 130
 131 void SketchAPI_Sketch::setExternal(const ModelHighAPI_Selection & theExternal)
 132 {
 133   fillAttribute(theExternal, myexternal);
 134
 135   execute();
 136 }
 137
 138 void SketchAPI_Sketch::setExternal(std::shared_ptr<ModelAPI_Object> thePlaneObject)
 139 {
 140   ResultPtr aRes = std::dynamic_pointer_cast<ModelAPI_Result>(thePlaneObject);
 141   ModelHighAPI_Selection aSel(aRes);
 142   setExternal(aSel);
 143 }
 144
 145 //--------------------------------------------------------------------------------------
 146 void SketchAPI_Sketch::setValue(
 147     const std::shared_ptr<ModelHighAPI_Interface> & theConstraint,
 148     const ModelHighAPI_Double & theValue)
 149 {
 150   fillAttribute(theValue, theConstraint->feature()->real(SketchPlugin_Constraint::VALUE()));
 151
 152 //  theConstraint->execute();
 153 }
 154
 155 //--------------------------------------------------------------------------------------
 156 std::list<ModelHighAPI_Selection> SketchAPI_Sketch::selectFace() const
 157 {
 158   const_cast<SketchAPI_Sketch*>(this)->execute();
 159
 160   std::list<ModelHighAPI_Selection> aSelectionList;
 161
 162   ResultConstructionPtr aResultConstruction =
 163       std::dynamic_pointer_cast<ModelAPI_ResultConstruction>(feature()->firstResult());
 164   if (aResultConstruction.get() == NULL)
 165     return aSelectionList;
 166
 167   for (int anIndex = 0; anIndex < aResultConstruction->facesNum(); ++anIndex) {
 168     aSelectionList.push_back(
 169         ModelHighAPI_Selection(aResultConstruction,
 170                                aResultConstruction->face(anIndex)));
 171   }
 172
 173   return aSelectionList;
 174 }
 175
 176 //--------------------------------------------------------------------------------------
 177 SketchPtr addSketch(const std::shared_ptr<ModelAPI_Document> & thePart,
 178                     const std::shared_ptr<GeomAPI_Ax3> & thePlane)
 179 {
 180   std::shared_ptr<ModelAPI_Feature> aFeature = thePart->addFeature(SketchAPI_Sketch::ID());
 181   return SketchPtr(new SketchAPI_Sketch(aFeature, thePlane));
 182 }
 183
 184 SketchPtr addSketch(const std::shared_ptr<ModelAPI_Document> & thePart,
 185                     const ModelHighAPI_Selection & theExternal)
 186 {
 187   std::shared_ptr<ModelAPI_Feature> aFeature = thePart->addFeature(SketchAPI_Sketch::ID());
 188   return SketchPtr(new SketchAPI_Sketch(aFeature, theExternal));
 189 }
 190
 191 SketchPtr addSketch(const std::shared_ptr<ModelAPI_Document> & thePart,
 192                     const std::string & theExternalName)
 193 {
 194   std::shared_ptr<ModelAPI_Feature> aFeature = thePart->addFeature(SketchAPI_Sketch::ID());
 195   return SketchPtr(
 196     new SketchAPI_Sketch(aFeature, ModelHighAPI_Selection("FACE", theExternalName)));
 197 }
 198
 199 SketchPtr addSketch(const std::shared_ptr<ModelAPI_Document> & thePart,
 200                     std::shared_ptr<ModelAPI_Object> thePlaneObject)
 201 {
 202   std::shared_ptr<ModelAPI_Feature> aFeature = thePart->addFeature(SketchAPI_Sketch::ID());
 203   return SketchPtr(new SketchAPI_Sketch(aFeature, thePlaneObject));
 204 }
 205
 206
 207 //--------------------------------------------------------------------------------------
 208 std::shared_ptr<SketchAPI_Point> SketchAPI_Sketch::addPoint(
 209     double theX, double theY)
 210 {
 211   std::shared_ptr<ModelAPI_Feature> aFeature =
 212     compositeFeature()->addFeature(SketchPlugin_Point::ID());
 213   return PointPtr(new SketchAPI_Point(aFeature, theX, theY));
 214 }
 215 std::shared_ptr<SketchAPI_Point> SketchAPI_Sketch::addPoint(
 216     const std::shared_ptr<GeomAPI_Pnt2d> & thePoint)
 217 {
 218   std::shared_ptr<ModelAPI_Feature> aFeature =
 219     compositeFeature()->addFeature(SketchPlugin_Point::ID());
 220   return PointPtr(new SketchAPI_Point(aFeature, thePoint));
 221 }
 222 std::shared_ptr<SketchAPI_Point>
 223   SketchAPI_Sketch::addPoint(const ModelHighAPI_Selection & theExternal)
 224 {
 225   std::shared_ptr<ModelAPI_Feature> aFeature =
 226     compositeFeature()->addFeature(SketchPlugin_Point::ID());
 227   return PointPtr(new SketchAPI_Point(aFeature, theExternal));
 228 }
 229 std::shared_ptr<SketchAPI_Point> SketchAPI_Sketch::addPoint(const std::string & theExternalName)
 230 {
 231   std::shared_ptr<ModelAPI_Feature> aFeature =
 232     compositeFeature()->addFeature(SketchPlugin_Point::ID());
 233   return PointPtr(new SketchAPI_Point(aFeature, theExternalName));
 234 }
 235
 236 //--------------------------------------------------------------------------------------
 237 std::shared_ptr<SketchAPI_IntersectionPoint> SketchAPI_Sketch::addIntersectionPoint(
 238     const ModelHighAPI_Selection & theExternal)
 239 {
 240   std::shared_ptr<ModelAPI_Feature> aFeature =
 241     compositeFeature()->addFeature(SketchPlugin_IntersectionPoint::ID());
 242   return IntersectionPointPtr(new SketchAPI_IntersectionPoint(aFeature, theExternal));
 243 }
 244 std::shared_ptr<SketchAPI_IntersectionPoint> SketchAPI_Sketch::addIntersectionPoint(
 245     const std::string & theExternalName)
 246 {
 247   std::shared_ptr<ModelAPI_Feature> aFeature =
 248     compositeFeature()->addFeature(SketchPlugin_IntersectionPoint::ID());
 249   return IntersectionPointPtr(new SketchAPI_IntersectionPoint(aFeature, theExternalName));
 250 }
 251
 252 //--------------------------------------------------------------------------------------
 253 std::shared_ptr<SketchAPI_Line> SketchAPI_Sketch::addLine(double theX1, double theY1,
 254                                                           double theX2, double theY2)
 255 {
 256   std::shared_ptr<ModelAPI_Feature> aFeature =
 257     compositeFeature()->addFeature(SketchPlugin_Line::ID());
 258   return LinePtr(new SketchAPI_Line(aFeature, theX1, theY1, theX2, theY2));
 259 }
 260 std::shared_ptr<SketchAPI_Line> SketchAPI_Sketch::addLine(
 261     const std::shared_ptr<GeomAPI_Pnt2d> & theStartPoint,
 262     const std::shared_ptr<GeomAPI_Pnt2d> & theEndPoint)
 263 {
 264   std::shared_ptr<ModelAPI_Feature> aFeature =
 265     compositeFeature()->addFeature(SketchPlugin_Line::ID());
 266   return LinePtr(new SketchAPI_Line(aFeature, theStartPoint, theEndPoint));
 267 }
 268 std::shared_ptr<SketchAPI_Line>
 269   SketchAPI_Sketch::addLine(const ModelHighAPI_Selection & theExternal)
 270 {
 271   std::shared_ptr<ModelAPI_Feature> aFeature =
 272     compositeFeature()->addFeature(SketchPlugin_Line::ID());
 273   return LinePtr(new SketchAPI_Line(aFeature, theExternal));
 274 }
 275 std::shared_ptr<SketchAPI_Line> SketchAPI_Sketch::addLine(const std::string & theExternalName)
 276 {
 277   std::shared_ptr<ModelAPI_Feature> aFeature =
 278     compositeFeature()->addFeature(SketchPlugin_Line::ID());
 279   return LinePtr(new SketchAPI_Line(aFeature, theExternalName));
 280 }
 281
 282 //--------------------------------------------------------------------------------------
 283 std::shared_ptr<SketchAPI_Rectangle> SketchAPI_Sketch::addRectangle(double theX1, double theY1,
 284                                                                     double theX2, double theY2)
 285 {
 286   std::shared_ptr<ModelAPI_Feature> aFeature =
 287     compositeFeature()->addFeature(SketchAPI_Rectangle::ID());
 288   return RectanglePtr(new SketchAPI_Rectangle(aFeature, theX1, theY1, theX2, theY2));
 289 }
 290 std::shared_ptr<SketchAPI_Rectangle> SketchAPI_Sketch::addRectangle(
 291     const std::shared_ptr<GeomAPI_Pnt2d> & theStartPoint,
 292     const std::shared_ptr<GeomAPI_Pnt2d> & theEndPoint)
 293 {
 294   std::shared_ptr<ModelAPI_Feature> aFeature =
 295     compositeFeature()->addFeature(SketchAPI_Rectangle::ID());
 296   return RectanglePtr(new SketchAPI_Rectangle(aFeature, theStartPoint, theEndPoint));
 297 }
 298
 299 //--------------------------------------------------------------------------------------
 300 std::shared_ptr<SketchAPI_Circle> SketchAPI_Sketch::addCircle(double theCenterX,
 301                                                               double theCenterY,
 302                                                               double theRadius)
 303 {
 304   std::shared_ptr<ModelAPI_Feature> aFeature =
 305     compositeFeature()->addFeature(SketchPlugin_Circle::ID());
 306   return CirclePtr(new SketchAPI_Circle(aFeature, theCenterX, theCenterY, theRadius));
 307 }
 308
 309 std::shared_ptr<SketchAPI_Circle> SketchAPI_Sketch::addCircle(
 310                                     const std::shared_ptr<GeomAPI_Pnt2d>& theCenter,
 311                                     double theRadius)
 312 {
 313   std::shared_ptr<ModelAPI_Feature> aFeature =
 314     compositeFeature()->addFeature(SketchPlugin_Circle::ID());
 315   return CirclePtr(new SketchAPI_Circle(aFeature, theCenter, theRadius));
 316 }
 317
 318 std::shared_ptr<SketchAPI_MacroCircle> SketchAPI_Sketch::addCircle(double theCenterX,
 319                                                                    double theCenterY,
 320                                                                    double thePassedX,
 321                                                                    double thePassedY)
 322 {
 323   std::shared_ptr<ModelAPI_Feature> aFeature =
 324     compositeFeature()->addFeature(SketchPlugin_MacroCircle::ID());
 325   return MacroCirclePtr(new SketchAPI_MacroCircle(aFeature, theCenterX, theCenterY,
 326                                                             thePassedX, thePassedY));
 327 }
 328
 329 std::shared_ptr<SketchAPI_MacroCircle> SketchAPI_Sketch::addCircle(
 330     const std::shared_ptr<GeomAPI_Pnt2d>& theCenterPoint,
 331     const std::shared_ptr<GeomAPI_Pnt2d>& thePassedPoint)
 332 {
 333   std::shared_ptr<ModelAPI_Feature> aFeature =
 334     compositeFeature()->addFeature(SketchPlugin_MacroCircle::ID());
 335   return MacroCirclePtr(new SketchAPI_MacroCircle(aFeature, theCenterPoint, thePassedPoint));
 336 }
 337
 338 std::shared_ptr<SketchAPI_MacroCircle> SketchAPI_Sketch::addCircle(double theX1, double theY1,
 339                                                                    double theX2, double theY2,
 340                                                                    double theX3, double theY3)
 341 {
 342   std::shared_ptr<ModelAPI_Feature> aFeature =
 343     compositeFeature()->addFeature(SketchPlugin_MacroCircle::ID());
 344   return MacroCirclePtr(new SketchAPI_MacroCircle(aFeature, theX1, theY1,
 345                                                             theX2, theY2,
 346                                                             theX3, theY3));
 347 }
 348
 349 std::shared_ptr<SketchAPI_MacroCircle> SketchAPI_Sketch::addCircle(
 350     const std::shared_ptr<GeomAPI_Pnt2d>& thePoint1,
 351     const std::shared_ptr<GeomAPI_Pnt2d>& thePoint2,
 352     const std::shared_ptr<GeomAPI_Pnt2d>& thePoint3)
 353 {
 354   std::shared_ptr<ModelAPI_Feature> aFeature =
 355     compositeFeature()->addFeature(SketchPlugin_MacroCircle::ID());
 356   return MacroCirclePtr(new SketchAPI_MacroCircle(aFeature, thePoint1, thePoint2, thePoint3));
 357 }
 358
 359 std::shared_ptr<SketchAPI_Circle>
 360   SketchAPI_Sketch::addCircle(const ModelHighAPI_Selection & theExternal)
 361 {
 362   std::shared_ptr<ModelAPI_Feature> aFeature =
 363     compositeFeature()->addFeature(SketchPlugin_Circle::ID());
 364   return CirclePtr(new SketchAPI_Circle(aFeature, theExternal));
 365 }
 366
 367 std::shared_ptr<SketchAPI_Circle> SketchAPI_Sketch::addCircle(const std::string & theExternalName)
 368 {
 369   // TODO(spo): Add constraint SketchConstraintRigid like in PythonAPI. Is it necessary?
 370   std::shared_ptr<ModelAPI_Feature> aFeature =
 371     compositeFeature()->addFeature(SketchPlugin_Circle::ID());
 372   return CirclePtr(new SketchAPI_Circle(aFeature, theExternalName));
 373 }
 374
 375 //--------------------------------------------------------------------------------------
 376 std::shared_ptr<SketchAPI_Arc> SketchAPI_Sketch::addArc(double theCenterX, double theCenterY,
 377                                                         double theStartX, double theStartY,
 378                                                         double theEndX, double theEndY,
 379                                                         bool theInversed)
 380 {
 381   std::shared_ptr<ModelAPI_Feature> aFeature =
 382     compositeFeature()->addFeature(SketchPlugin_Arc::ID());
 383   return ArcPtr(new SketchAPI_Arc(aFeature,
 384                                   theCenterX, theCenterY,
 385                                   theStartX, theStartY,
 386                                   theEndX, theEndY,
 387                                   theInversed));
 388 }
 389
 390 std::shared_ptr<SketchAPI_Arc> SketchAPI_Sketch::addArc(
 391                                               const std::shared_ptr<GeomAPI_Pnt2d>& theCenter,
 392                                               const std::shared_ptr<GeomAPI_Pnt2d>& theStart,
 393                                               const std::shared_ptr<GeomAPI_Pnt2d>& theEnd,
 394                                               bool theInversed)
 395 {
 396   std::shared_ptr<ModelAPI_Feature> aFeature =
 397     compositeFeature()->addFeature(SketchPlugin_Arc::ID());
 398   return ArcPtr(new SketchAPI_Arc(aFeature, theCenter, theStart, theEnd, theInversed));
 399 }
 400
 401 std::shared_ptr<SketchAPI_MacroArc> SketchAPI_Sketch::addArc(double theStartX, double theStartY,
 402                                                         double theEndX, double theEndY,
 403                                                         double thePassedX, double thePassedY)
 404 {
 405   std::shared_ptr<ModelAPI_Feature> aFeature =
 406     compositeFeature()->addFeature(SketchPlugin_MacroArc::ID());
 407   return MacroArcPtr(new SketchAPI_MacroArc(aFeature,
 408                                        theStartX, theStartY,
 409                                        theEndX, theEndY,
 410                                        thePassedX, thePassedY));
 411 }
 412
 413 std::shared_ptr<SketchAPI_MacroArc> SketchAPI_Sketch::addArc(
 414                                                 const std::shared_ptr<GeomAPI_Pnt2d>& theStart,
 415                                                 const std::shared_ptr<GeomAPI_Pnt2d>& theEnd,
 416                                                 const std::shared_ptr<GeomAPI_Pnt2d>& thePassed)
 417 {
 418   std::shared_ptr<ModelAPI_Feature> aFeature =
 419     compositeFeature()->addFeature(SketchPlugin_MacroArc::ID());
 420   return MacroArcPtr(new SketchAPI_MacroArc(aFeature, theStart, theEnd, thePassed));
 421 }
 422
 423 std::shared_ptr<SketchAPI_MacroArc> SketchAPI_Sketch::addArc(
 424                                                 const ModelHighAPI_RefAttr& theTangentPoint,
 425                                                 double theEndX, double theEndY,
 426                                                 bool theInversed)
 427 {
 428   std::shared_ptr<ModelAPI_Feature> aFeature =
 429     compositeFeature()->addFeature(SketchPlugin_MacroArc::ID());
 430   return MacroArcPtr(new SketchAPI_MacroArc(
 431     aFeature, theTangentPoint, theEndX, theEndY, theInversed));
 432 }
 433
 434 std::shared_ptr<SketchAPI_MacroArc> SketchAPI_Sketch::addArc(
 435                                               const ModelHighAPI_RefAttr& theTangentPoint,
 436                                               const std::shared_ptr<GeomAPI_Pnt2d>& theEnd,
 437                                               bool theInversed)
 438 {
 439   std::shared_ptr<ModelAPI_Feature> aFeature =
 440     compositeFeature()->addFeature(SketchPlugin_MacroArc::ID());
 441   return MacroArcPtr(new SketchAPI_MacroArc(aFeature, theTangentPoint, theEnd, theInversed));
 442 }
 443
 444 std::shared_ptr<SketchAPI_Arc> SketchAPI_Sketch::addArc(const ModelHighAPI_Selection & theExternal)
 445 {
 446   std::shared_ptr<ModelAPI_Feature> aFeature =
 447     compositeFeature()->addFeature(SketchPlugin_Arc::ID());
 448   return ArcPtr(new SketchAPI_Arc(aFeature, theExternal));
 449 }
 450
 451 std::shared_ptr<SketchAPI_Arc> SketchAPI_Sketch::addArc(const std::string & theExternalName)
 452 {
 453   // TODO(spo): Add constraint SketchConstraintRigid like in PythonAPI. Is it necessary?
 454   std::shared_ptr<ModelAPI_Feature> aFeature =
 455     compositeFeature()->addFeature(SketchPlugin_Arc::ID());
 456   return ArcPtr(new SketchAPI_Arc(aFeature, theExternalName));
 457 }
 458
 459 //--------------------------------------------------------------------------------------
 460 std::shared_ptr<SketchAPI_Projection> SketchAPI_Sketch::addProjection(
 461     const ModelHighAPI_Selection & theExternalFeature,
 462     bool theKeepResult)
 463 {
 464   std::shared_ptr<ModelAPI_Feature> aFeature =
 465     compositeFeature()->addFeature(SketchPlugin_Projection::ID());
 466   ProjectionPtr aProjection(new SketchAPI_Projection(aFeature, theExternalFeature));
 467   aProjection->setIncludeToResult(theKeepResult);
 468   return aProjection;
 469 }
 470
 471 std::shared_ptr<SketchAPI_Projection> SketchAPI_Sketch::addProjection(
 472     const std::string & theExternalName,
 473     bool theKeepResult)
 474 {
 475   std::shared_ptr<ModelAPI_Feature> aFeature =
 476     compositeFeature()->addFeature(SketchPlugin_Projection::ID());
 477   ProjectionPtr aProjection(new SketchAPI_Projection(aFeature, theExternalName));
 478   aProjection->setIncludeToResult(theKeepResult);
 479   return aProjection;
 480 }
 481
 482 //--------------------------------------------------------------------------------------
 483 std::shared_ptr<SketchAPI_Mirror> SketchAPI_Sketch::addMirror(
 484     const ModelHighAPI_RefAttr & theMirrorLine,
 485     const std::list<std::shared_ptr<ModelAPI_Object> > & theObjects)
 486 {
 487   std::shared_ptr<ModelAPI_Feature> aFeature =
 488     compositeFeature()->addFeature(SketchPlugin_ConstraintMirror::ID());
 489   return MirrorPtr(new SketchAPI_Mirror(aFeature, theMirrorLine, theObjects));
 490 }
 491
 492 //--------------------------------------------------------------------------------------
 493 std::shared_ptr<SketchAPI_Translation> SketchAPI_Sketch::addTranslation(
 494     const std::list<std::shared_ptr<ModelAPI_Object> > & theObjects,
 495     const ModelHighAPI_RefAttr & thePoint1,
 496     const ModelHighAPI_RefAttr & thePoint2,
 497     const ModelHighAPI_Integer & theNumberOfObjects,
 498     bool theFullValue)
 499 {
 500   std::shared_ptr<ModelAPI_Feature> aFeature =
 501     compositeFeature()->addFeature(SketchPlugin_MultiTranslation::ID());
 502   return TranslationPtr(new SketchAPI_Translation(aFeature, theObjects, thePoint1,
 503                                                   thePoint2, theNumberOfObjects, theFullValue));
 504 }
 505
 506 //--------------------------------------------------------------------------------------
 507 std::shared_ptr<SketchAPI_Rotation> SketchAPI_Sketch::addRotation(
 508     const std::list<std::shared_ptr<ModelAPI_Object> > & theObjects,
 509     const ModelHighAPI_RefAttr & theCenter,
 510     const ModelHighAPI_Double & theAngle,
 511     const ModelHighAPI_Integer & theNumberOfObjects,
 512     bool theFullValue)
 513 {
 514   std::shared_ptr<ModelAPI_Feature> aFeature =
 515     compositeFeature()->addFeature(SketchPlugin_MultiRotation::ID());
 516   return RotationPtr(
 517     new SketchAPI_Rotation(aFeature, theObjects, theCenter,
 518                            theAngle, theNumberOfObjects, theFullValue));
 519 }
 520
 521 //--------------------------------------------------------------------------------------
 522 std::shared_ptr<ModelHighAPI_Interface> SketchAPI_Sketch::addSplit(
 523                                           const ModelHighAPI_Reference& theFeature,
 524                                           const std::shared_ptr<GeomAPI_Pnt2d>& thePositionPoint)
 525 {
 526   std::shared_ptr<ModelAPI_Feature> aFeature =
 527     compositeFeature()->addFeature(SketchPlugin_Split::ID());
 528   fillAttribute(theFeature, aFeature->reference(SketchPlugin_Split::SELECTED_OBJECT()));
 529
 530   AttributePtr anAttribute = aFeature->attribute(SketchPlugin_Split::SELECTED_POINT());
 531   if (anAttribute->attributeType() == GeomDataAPI_Point2D::typeId()) {
 532     AttributePoint2DPtr aPointAttr = std::dynamic_pointer_cast<GeomDataAPI_Point2D>(anAttribute);
 533     fillAttribute(thePositionPoint, aPointAttr);
 534   }
 535
 536   return InterfacePtr(new ModelHighAPI_Interface(aFeature));
 537 }
 538
 539 //--------------------------------------------------------------------------------------
 540 std::shared_ptr<ModelHighAPI_Interface> SketchAPI_Sketch::addTrim(
 541                                         const ModelHighAPI_Reference& theFeature,
 542                                         const std::shared_ptr<GeomAPI_Pnt2d>& thePositionPoint)
 543 {
 544   std::shared_ptr<ModelAPI_Feature> aFeature =
 545     compositeFeature()->addFeature(SketchPlugin_Trim::ID());
 546   fillAttribute(theFeature, aFeature->reference(SketchPlugin_Trim::SELECTED_OBJECT()));
 547
 548   AttributePtr anAttribute = aFeature->attribute(SketchPlugin_Trim::SELECTED_POINT());
 549   if (anAttribute->attributeType() == GeomDataAPI_Point2D::typeId()) {
 550     AttributePoint2DPtr aPointAttr = std::dynamic_pointer_cast<GeomDataAPI_Point2D>(anAttribute);
 551     fillAttribute(thePositionPoint, aPointAttr);
 552   }
 553
 554   return InterfacePtr(new ModelHighAPI_Interface(aFeature));
 555 }
 556
 557 //--------------------------------------------------------------------------------------
 558 std::shared_ptr<ModelHighAPI_Interface> SketchAPI_Sketch::setAngle(
 559     const ModelHighAPI_RefAttr & theLine1,
 560     const ModelHighAPI_RefAttr & theLine2,
 561     const ModelHighAPI_Double & theValue)
 562 {
 563   std::shared_ptr<ModelAPI_Feature> aFeature =
 564       compositeFeature()->addFeature(SketchPlugin_ConstraintAngle::ID());
 565   fillAttribute(SketcherPrs_Tools::ANGLE_DIRECT,
 566       aFeature->integer(SketchPlugin_ConstraintAngle::TYPE_ID()));
 567   fillAttribute(SketcherPrs_Tools::LOCATION_AUTOMATIC,
 568     aFeature->integer(SketchPlugin_ConstraintAngle::LOCATION_TYPE_ID()));
 569   // fill the value before llines to avoid calculation of angle value by the Angle feature
 570   fillAttribute(theValue, aFeature->real(SketchPlugin_ConstraintAngle::ANGLE_VALUE_ID()));
 571   fillAttribute(theLine1, aFeature->refattr(SketchPlugin_Constraint::ENTITY_A()));
 572   fillAttribute(theLine2, aFeature->refattr(SketchPlugin_Constraint::ENTITY_B()));
 573   aFeature->execute();
 574   return InterfacePtr(new ModelHighAPI_Interface(aFeature));
 575 }
 576
 577 std::shared_ptr<ModelHighAPI_Interface> SketchAPI_Sketch::setAngleComplementary(
 578     const ModelHighAPI_RefAttr & theLine1,
 579     const ModelHighAPI_RefAttr & theLine2,
 580     const ModelHighAPI_Double & theValue)
 581 {
 582   std::shared_ptr<ModelAPI_Feature> aFeature =
 583       compositeFeature()->addFeature(SketchPlugin_ConstraintAngle::ID());
 584   fillAttribute(SketcherPrs_Tools::ANGLE_COMPLEMENTARY,
 585       aFeature->integer(SketchPlugin_ConstraintAngle::TYPE_ID()));
 586   fillAttribute(SketcherPrs_Tools::LOCATION_AUTOMATIC,
 587     aFeature->integer(SketchPlugin_ConstraintAngle::LOCATION_TYPE_ID()));
 588   fillAttribute(theValue, aFeature->real(SketchPlugin_ConstraintAngle::ANGLE_VALUE_ID()));
 589   fillAttribute(theLine1, aFeature->refattr(SketchPlugin_Constraint::ENTITY_A()));
 590   fillAttribute(theLine2, aFeature->refattr(SketchPlugin_Constraint::ENTITY_B()));
 591 //  fillAttribute(theValue, aFeature->real(SketchPlugin_Constraint::VALUE()));
 592   aFeature->execute();
 593   return InterfacePtr(new ModelHighAPI_Interface(aFeature));
 594 }
 595
 596 std::shared_ptr<ModelHighAPI_Interface> SketchAPI_Sketch::setAngleBackward(
 597     const ModelHighAPI_RefAttr & theLine1,
 598     const ModelHighAPI_RefAttr & theLine2,
 599     const ModelHighAPI_Double & theValue)
 600 {
 601   std::shared_ptr<ModelAPI_Feature> aFeature =
 602       compositeFeature()->addFeature(SketchPlugin_ConstraintAngle::ID());
 603   fillAttribute(SketcherPrs_Tools::ANGLE_BACKWARD,
 604       aFeature->integer(SketchPlugin_ConstraintAngle::TYPE_ID()));
 605   fillAttribute(SketcherPrs_Tools::LOCATION_AUTOMATIC,
 606     aFeature->integer(SketchPlugin_ConstraintAngle::LOCATION_TYPE_ID()));
 607   fillAttribute(theValue, aFeature->real(SketchPlugin_ConstraintAngle::ANGLE_VALUE_ID()));
 608   fillAttribute(theLine1, aFeature->refattr(SketchPlugin_Constraint::ENTITY_A()));
 609   fillAttribute(theLine2, aFeature->refattr(SketchPlugin_Constraint::ENTITY_B()));
 610 //  fillAttribute(theValue, aFeature->real(SketchPlugin_Constraint::VALUE()));
 611   aFeature->execute();
 612   return InterfacePtr(new ModelHighAPI_Interface(aFeature));
 613 }
 614
 615 std::shared_ptr<ModelHighAPI_Interface> SketchAPI_Sketch::setCoincident(
 616     const ModelHighAPI_RefAttr & thePoint1,
 617     const ModelHighAPI_RefAttr & thePoint2)
 618 {
 619   std::shared_ptr<ModelAPI_Feature> aFeature =
 620       compositeFeature()->addFeature(SketchPlugin_ConstraintCoincidence::ID());
 621   fillAttribute(thePoint1, aFeature->refattr(SketchPlugin_Constraint::ENTITY_A()));
 622   fillAttribute(thePoint2, aFeature->refattr(SketchPlugin_Constraint::ENTITY_B()));
 623   aFeature->execute();
 624   return InterfacePtr(new ModelHighAPI_Interface(aFeature));
 625 }
 626
 627 std::shared_ptr<ModelHighAPI_Interface> SketchAPI_Sketch::setCollinear(
 628     const ModelHighAPI_RefAttr & theLine1,
 629     const ModelHighAPI_RefAttr & theLine2)
 630 {
 631   std::shared_ptr<ModelAPI_Feature> aFeature =
 632       compositeFeature()->addFeature(SketchPlugin_ConstraintCollinear::ID());
 633   fillAttribute(theLine1, aFeature->refattr(SketchPlugin_Constraint::ENTITY_A()));
 634   fillAttribute(theLine2, aFeature->refattr(SketchPlugin_Constraint::ENTITY_B()));
 635   aFeature->execute();
 636   return InterfacePtr(new ModelHighAPI_Interface(aFeature));
 637 }
 638
 639 std::shared_ptr<ModelHighAPI_Interface> SketchAPI_Sketch::setDistance(
 640     const ModelHighAPI_RefAttr & thePoint,
 641     const ModelHighAPI_RefAttr & thePointOrLine,
 642     const ModelHighAPI_Double & theValue,
 643     bool isSigned)
 644 {
 645   std::shared_ptr<ModelAPI_Feature> aFeature =
 646       compositeFeature()->addFeature(SketchPlugin_ConstraintDistance::ID());
 647   fillAttribute(SketcherPrs_Tools::LOCATION_AUTOMATIC,
 648     aFeature->integer(SketchPlugin_ConstraintDistance::LOCATION_TYPE_ID()));
 649   fillAttribute(thePoint, aFeature->refattr(SketchPlugin_Constraint::ENTITY_A()));
 650   fillAttribute(thePointOrLine, aFeature->refattr(SketchPlugin_Constraint::ENTITY_B()));
 651   fillAttribute(theValue, aFeature->real(SketchPlugin_Constraint::VALUE()));
 652   fillAttribute(isSigned, aFeature->boolean(SketchPlugin_ConstraintDistance::SIGNED()));
 653   aFeature->execute();
 654   return InterfacePtr(new ModelHighAPI_Interface(aFeature));
 655 }
 656
 657 std::shared_ptr<ModelHighAPI_Interface> SketchAPI_Sketch::setSignedDistance(
 658     const ModelHighAPI_RefAttr & thePoint,
 659     const ModelHighAPI_RefAttr & thePointOrLine,
 660     const ModelHighAPI_Double & theValue)
 661 {
 662   return setDistance(thePoint, thePointOrLine, theValue, true);
 663 }
 664
 665 std::shared_ptr<ModelHighAPI_Interface> SketchAPI_Sketch::setUnsignedDistance(
 666     const ModelHighAPI_RefAttr & thePoint,
 667     const ModelHighAPI_RefAttr & thePointOrLine,
 668     const ModelHighAPI_Double & theValue)
 669 {
 670   return setDistance(thePoint, thePointOrLine, theValue, false);
 671 }
 672
 673 std::shared_ptr<ModelHighAPI_Interface> SketchAPI_Sketch::setHorizontalDistance(
 674     const ModelHighAPI_RefAttr & thePoint1,
 675     const ModelHighAPI_RefAttr & thePoint2,
 676     const ModelHighAPI_Double & theValue)
 677 {
 678   std::shared_ptr<ModelAPI_Feature> aFeature =
 679       compositeFeature()->addFeature(SketchPlugin_ConstraintDistanceHorizontal::ID());
 680   fillAttribute(SketcherPrs_Tools::LOCATION_AUTOMATIC,
 681     aFeature->integer(SketchPlugin_ConstraintDistanceHorizontal::LOCATION_TYPE_ID()));
 682   fillAttribute(thePoint1, aFeature->refattr(SketchPlugin_Constraint::ENTITY_A()));
 683   fillAttribute(thePoint2, aFeature->refattr(SketchPlugin_Constraint::ENTITY_B()));
 684   fillAttribute(theValue, aFeature->real(SketchPlugin_Constraint::VALUE()));
 685   aFeature->execute();
 686   return InterfacePtr(new ModelHighAPI_Interface(aFeature));
 687 }
 688
 689 std::shared_ptr<ModelHighAPI_Interface> SketchAPI_Sketch::setVerticalDistance(
 690     const ModelHighAPI_RefAttr & thePoint1,
 691     const ModelHighAPI_RefAttr & thePoint2,
 692     const ModelHighAPI_Double & theValue)
 693 {
 694   std::shared_ptr<ModelAPI_Feature> aFeature =
 695       compositeFeature()->addFeature(SketchPlugin_ConstraintDistanceVertical::ID());
 696   fillAttribute(SketcherPrs_Tools::LOCATION_AUTOMATIC,
 697     aFeature->integer(SketchPlugin_ConstraintDistanceVertical::LOCATION_TYPE_ID()));
 698   fillAttribute(thePoint1, aFeature->refattr(SketchPlugin_Constraint::ENTITY_A()));
 699   fillAttribute(thePoint2, aFeature->refattr(SketchPlugin_Constraint::ENTITY_B()));
 700   fillAttribute(theValue, aFeature->real(SketchPlugin_Constraint::VALUE()));
 701   aFeature->execute();
 702   return InterfacePtr(new ModelHighAPI_Interface(aFeature));
 703 }
 704
 705 std::shared_ptr<ModelHighAPI_Interface> SketchAPI_Sketch::setEqual(
 706     const ModelHighAPI_RefAttr & theObject1,
 707     const ModelHighAPI_RefAttr & theObject2)
 708 {
 709   std::shared_ptr<ModelAPI_Feature> aFeature =
 710       compositeFeature()->addFeature(SketchPlugin_ConstraintEqual::ID());
 711   fillAttribute(theObject1, aFeature->refattr(SketchPlugin_Constraint::ENTITY_A()));
 712   fillAttribute(theObject2, aFeature->refattr(SketchPlugin_Constraint::ENTITY_B()));
 713   aFeature->execute();
 714   return InterfacePtr(new ModelHighAPI_Interface(aFeature));
 715 }
 716
 717 std::shared_ptr<ModelHighAPI_Interface> SketchAPI_Sketch::setFillet(
 718     const ModelHighAPI_RefAttr & thePoint)
 719 {
 720   std::shared_ptr<ModelAPI_Feature> aFeature =
 721       compositeFeature()->addFeature(SketchPlugin_Fillet::ID());
 722   fillAttribute(thePoint, aFeature->data()->refattr(SketchPlugin_Fillet::FILLET_POINT_ID()));
 723   apply(); // finish operation to remove Fillet feature correcly
 724   return InterfacePtr(new ModelHighAPI_Interface(aFeature));
 725 }
 726
 727 std::shared_ptr<ModelHighAPI_Interface> SketchAPI_Sketch::setFilletWithRadius(
 728     const ModelHighAPI_RefAttr & thePoint,
 729     const ModelHighAPI_Double & theRadius)
 730 {
 731   CompositeFeaturePtr aSketch = compositeFeature();
 732   int aNbSubs = aSketch->numberOfSubs();
 733
 734   // create fillet
 735   InterfacePtr aFilletFeature = setFillet(thePoint);
 736
 737   // set radius for just created arc
 738   FeaturePtr anArc = aSketch->subFeature(aNbSubs - 1);
 739   if (anArc->getKind() == SketchPlugin_Arc::ID())
 740     setRadius(ModelHighAPI_RefAttr(ObjectPtr(anArc->lastResult())), ModelHighAPI_Double(theRadius));
 741
 742   return aFilletFeature;
 743 }
 744
 745 std::shared_ptr<ModelHighAPI_Interface> SketchAPI_Sketch::setFixed(
 746     const ModelHighAPI_RefAttr & theObject)
 747 {
 748   std::shared_ptr<ModelAPI_Feature> aFeature =
 749       compositeFeature()->addFeature(SketchPlugin_ConstraintRigid::ID());
 750   fillAttribute(theObject, aFeature->refattr(SketchPlugin_Constraint::ENTITY_A()));
 751   aFeature->execute();
 752   return InterfacePtr(new ModelHighAPI_Interface(aFeature));
 753 }
 754
 755 std::shared_ptr<ModelHighAPI_Interface> SketchAPI_Sketch::setHorizontal(
 756     const ModelHighAPI_RefAttr & theLine)
 757 {
 758   std::shared_ptr<ModelAPI_Feature> aFeature =
 759       compositeFeature()->addFeature(SketchPlugin_ConstraintHorizontal::ID());
 760   fillAttribute(theLine, aFeature->refattr(SketchPlugin_Constraint::ENTITY_A()));
 761   aFeature->execute();
 762   return InterfacePtr(new ModelHighAPI_Interface(aFeature));
 763 }
 764
 765 std::shared_ptr<ModelHighAPI_Interface> SketchAPI_Sketch::setLength(
 766     const ModelHighAPI_RefAttr & theLine,
 767     const ModelHighAPI_Double & theValue)
 768 {
 769   std::shared_ptr<ModelAPI_Feature> aFeature =
 770       compositeFeature()->addFeature(SketchPlugin_ConstraintLength::ID());
 771   fillAttribute(SketcherPrs_Tools::LOCATION_AUTOMATIC,
 772     aFeature->integer(SketchPlugin_ConstraintLength::LOCATION_TYPE_ID()));
 773   fillAttribute(theLine, aFeature->refattr(SketchPlugin_Constraint::ENTITY_A()));
 774   fillAttribute(theValue, aFeature->real(SketchPlugin_Constraint::VALUE()));
 775   aFeature->execute();
 776   return InterfacePtr(new ModelHighAPI_Interface(aFeature));
 777 }
 778
 779 std::shared_ptr<ModelHighAPI_Interface> SketchAPI_Sketch::setMiddlePoint(
 780     const ModelHighAPI_RefAttr & thePoint,
 781     const ModelHighAPI_RefAttr & theLine)
 782 {
 783   std::shared_ptr<ModelAPI_Feature> aFeature =
 784       compositeFeature()->addFeature(SketchPlugin_ConstraintMiddle::ID());
 785   fillAttribute(thePoint, aFeature->refattr(SketchPlugin_Constraint::ENTITY_A()));
 786   fillAttribute(theLine, aFeature->refattr(SketchPlugin_Constraint::ENTITY_B()));
 787   aFeature->execute();
 788   return InterfacePtr(new ModelHighAPI_Interface(aFeature));
 789 }
 790
 791 std::shared_ptr<ModelHighAPI_Interface> SketchAPI_Sketch::setParallel(
 792     const ModelHighAPI_RefAttr & theLine1,
 793     const ModelHighAPI_RefAttr & theLine2)
 794 {
 795   std::shared_ptr<ModelAPI_Feature> aFeature =
 796       compositeFeature()->addFeature(SketchPlugin_ConstraintParallel::ID());
 797   fillAttribute(theLine1, aFeature->refattr(SketchPlugin_Constraint::ENTITY_A()));
 798   fillAttribute(theLine2, aFeature->refattr(SketchPlugin_Constraint::ENTITY_B()));
 799   aFeature->execute();
 800   return InterfacePtr(new ModelHighAPI_Interface(aFeature));
 801 }
 802
 803 std::shared_ptr<ModelHighAPI_Interface> SketchAPI_Sketch::setPerpendicular(
 804     const ModelHighAPI_RefAttr & theLine1,
 805     const ModelHighAPI_RefAttr & theLine2)
 806 {
 807   std::shared_ptr<ModelAPI_Feature> aFeature =
 808       compositeFeature()->addFeature(SketchPlugin_ConstraintPerpendicular::ID());
 809   fillAttribute(theLine1, aFeature->refattr(SketchPlugin_Constraint::ENTITY_A()));
 810   fillAttribute(theLine2, aFeature->refattr(SketchPlugin_Constraint::ENTITY_B()));
 811   aFeature->execute();
 812   return InterfacePtr(new ModelHighAPI_Interface(aFeature));
 813 }
 814
 815 std::shared_ptr<ModelHighAPI_Interface> SketchAPI_Sketch::setRadius(
 816     const ModelHighAPI_RefAttr & theCircleOrArc,
 817     const ModelHighAPI_Double & theValue)
 818 {
 819   std::shared_ptr<ModelAPI_Feature> aFeature =
 820       compositeFeature()->addFeature(SketchPlugin_ConstraintRadius::ID());
 821   fillAttribute(SketcherPrs_Tools::LOCATION_AUTOMATIC,
 822     aFeature->integer(SketchPlugin_ConstraintRadius::LOCATION_TYPE_ID()));
 823   fillAttribute(theCircleOrArc, aFeature->refattr(SketchPlugin_Constraint::ENTITY_A()));
 824   fillAttribute(theValue, aFeature->real(SketchPlugin_Constraint::VALUE()));
 825   aFeature->execute();
 826   return InterfacePtr(new ModelHighAPI_Interface(aFeature));
 827 }
 828
 829 std::shared_ptr<ModelHighAPI_Interface> SketchAPI_Sketch::setTangent(
 830     const ModelHighAPI_RefAttr & theLine,
 831     const ModelHighAPI_RefAttr & theCircle)
 832 {
 833   std::shared_ptr<ModelAPI_Feature> aFeature =
 834       compositeFeature()->addFeature(SketchPlugin_ConstraintTangent::ID());
 835   fillAttribute(theLine, aFeature->refattr(SketchPlugin_Constraint::ENTITY_A()));
 836   fillAttribute(theCircle, aFeature->refattr(SketchPlugin_Constraint::ENTITY_B()));
 837   aFeature->execute();
 838   return InterfacePtr(new ModelHighAPI_Interface(aFeature));
 839 }
 840
 841 std::shared_ptr<ModelHighAPI_Interface> SketchAPI_Sketch::setVertical(
 842     const ModelHighAPI_RefAttr & theLine)
 843 {
 844   std::shared_ptr<ModelAPI_Feature> aFeature =
 845       compositeFeature()->addFeature(SketchPlugin_ConstraintVertical::ID());
 846   fillAttribute(theLine, aFeature->refattr(SketchPlugin_Constraint::ENTITY_A()));
 847   aFeature->execute();
 848   return InterfacePtr(new ModelHighAPI_Interface(aFeature));
 849 }
 850
 851 //--------------------------------------------------------------------------------------
 852
 853 static std::shared_ptr<GeomAPI_Pnt2d> pointCoordinates(const AttributePtr& thePoint)
 854 {
 855   AttributePoint2DPtr aPnt = std::dynamic_pointer_cast<GeomDataAPI_Point2D>(thePoint);
 856   if (aPnt)
 857     return aPnt->pnt();
 858   return std::shared_ptr<GeomAPI_Pnt2d>();
 859 }
 860
 861 static std::shared_ptr<GeomAPI_Pnt2d> middlePointOnLine(const FeaturePtr& theFeature)
 862 {
 863   AttributePoint2DPtr aStartAttr = std::dynamic_pointer_cast<GeomDataAPI_Point2D>(
 864       theFeature->attribute(SketchPlugin_Line::START_ID()));
 865   AttributePoint2DPtr aEndAttr = std::dynamic_pointer_cast<GeomDataAPI_Point2D>(
 866       theFeature->attribute(SketchPlugin_Line::END_ID()));
 867
 868   if (!aStartAttr || !aEndAttr)
 869     return std::shared_ptr<GeomAPI_Pnt2d>();
 870
 871   std::shared_ptr<GeomAPI_XY> aStartPoint = aStartAttr->pnt()->xy();
 872   std::shared_ptr<GeomAPI_XY> aEndPoint = aEndAttr->pnt()->xy();
 873   return std::shared_ptr<GeomAPI_Pnt2d>(
 874       new GeomAPI_Pnt2d(aStartPoint->added(aEndPoint)->multiplied(0.5)));
 875 }
 876
 877 static std::shared_ptr<GeomAPI_Pnt2d> pointOnCircle(const FeaturePtr& theFeature)
 878 {
 879   AttributePoint2DPtr aCenter = std::dynamic_pointer_cast<GeomDataAPI_Point2D>(
 880       theFeature->attribute(SketchPlugin_Circle::CENTER_ID()));
 881   AttributeDoublePtr aRadius = theFeature->real(SketchPlugin_Circle::RADIUS_ID());
 882
 883   if (!aCenter || !aRadius)
 884     return std::shared_ptr<GeomAPI_Pnt2d>();
 885
 886   return std::shared_ptr<GeomAPI_Pnt2d>(
 887       new GeomAPI_Pnt2d(aCenter->x() + aRadius->value(), aCenter->y()));
 888 }
 889
 890 static std::shared_ptr<GeomAPI_Pnt2d> middlePointOnArc(const FeaturePtr& theFeature)
 891 {
 892   static const double PI = 3.141592653589793238463;
 893
 894   AttributePoint2DPtr aCenterAttr = std::dynamic_pointer_cast<GeomDataAPI_Point2D>(
 895       theFeature->attribute(SketchPlugin_Arc::CENTER_ID()));
 896   AttributePoint2DPtr aStartAttr = std::dynamic_pointer_cast<GeomDataAPI_Point2D>(
 897       theFeature->attribute(SketchPlugin_Arc::START_ID()));
 898   AttributePoint2DPtr aEndAttr = std::dynamic_pointer_cast<GeomDataAPI_Point2D>(
 899       theFeature->attribute(SketchPlugin_Arc::END_ID()));
 900
 901   if (!aCenterAttr || !aStartAttr || !aEndAttr)
 902     return std::shared_ptr<GeomAPI_Pnt2d>();
 903
 904   std::shared_ptr<GeomAPI_Dir2d> aStartDir(new GeomAPI_Dir2d(
 905       aStartAttr->x() - aCenterAttr->x(), aStartAttr->y() - aCenterAttr->y()));
 906   std::shared_ptr<GeomAPI_Dir2d> aEndDir(new GeomAPI_Dir2d(
 907       aEndAttr->x() - aCenterAttr->x(), aEndAttr->y() - aCenterAttr->y()));
 908
 909   double anAngle = aStartDir->angle(aEndDir);
 910   bool isReversed = theFeature->boolean(SketchPlugin_Arc::REVERSED_ID())->value();
 911   if (isReversed && anAngle > 0.)
 912     anAngle -= 2.0 * PI;
 913   else if (!isReversed && anAngle <= 0.)
 914     anAngle += 2.0 * PI;
 915
 916   double cosA = cos(anAngle);
 917   double sinA = sin(anAngle);
 918
 919   // rotate start dir to find middle point on arc
 920   double aRadius = aStartAttr->pnt()->distance(aCenterAttr->pnt());
 921   double x = aCenterAttr->x() + aRadius * (aStartDir->x() * cosA - aStartDir->y() * sinA);
 922   double y = aCenterAttr->y() + aRadius * (aStartDir->x() * sinA + aStartDir->y() * cosA);
 923
 924   return std::shared_ptr<GeomAPI_Pnt2d>(new GeomAPI_Pnt2d(x, y));
 925 }
 926
 927 static std::shared_ptr<GeomAPI_Pnt2d> middlePoint(const ObjectPtr& theObject)
 928 {
 929   FeaturePtr aFeature = ModelAPI_Feature::feature(theObject);
 930   if (aFeature) {
 931     const std::string& aFeatureKind = aFeature->getKind();
 932     if (aFeatureKind == SketchPlugin_Point::ID())
 933       return pointCoordinates(aFeature->attribute(SketchPlugin_Point::COORD_ID()));
 934     else if (aFeatureKind == SketchPlugin_Line::ID())
 935       return middlePointOnLine(aFeature);
 936     else if (aFeatureKind == SketchPlugin_Circle::ID())
 937       return pointOnCircle(aFeature);
 938     else if (aFeatureKind == SketchPlugin_Arc::ID())
 939       return middlePointOnArc(aFeature);
 940   }
 941   // do not move other types of features
 942   return std::shared_ptr<GeomAPI_Pnt2d>();
 943 }
 944
 945 void SketchAPI_Sketch::move(const ModelHighAPI_RefAttr& theMovedEntity,
 946                             const std::shared_ptr<GeomAPI_Pnt2d>& theTargetPoint)
 947 {
 948   std::shared_ptr<ModelAPI_ObjectMovedMessage> aMessage(new ModelAPI_ObjectMovedMessage);
 949   theMovedEntity.fillMessage(aMessage);
 950
 951   std::shared_ptr<GeomAPI_Pnt2d> anOriginalPosition;
 952   if (aMessage->movedAttribute())
 953     anOriginalPosition = pointCoordinates(aMessage->movedAttribute());
 954   else
 955     anOriginalPosition = middlePoint(aMessage->movedObject());
 956
 957   if (!anOriginalPosition)
 958     return; // something has gone wrong, do not process movement
 959
 960   aMessage->setOriginalPosition(anOriginalPosition);
 961   aMessage->setCurrentPosition(theTargetPoint);
 962   Events_Loop::loop()->send(aMessage);
 963 }
 964
 965 void SketchAPI_Sketch::move(const ModelHighAPI_RefAttr& theMovedEntity,
 966                             double theTargetX, double theTargetY)
 967 {
 968   std::shared_ptr<GeomAPI_Pnt2d> aTargetPoint(new GeomAPI_Pnt2d(theTargetX, theTargetY));
 969   move(theMovedEntity, aTargetPoint);
 970 }
 971
 972 //--------------------------------------------------------------------------------------
 973
 974 std::shared_ptr<GeomAPI_Pnt2d> SketchAPI_Sketch::to2D(const std::shared_ptr<GeomAPI_Pnt>& thePoint)
 975 {
 976   FeaturePtr aBase = feature();
 977   std::shared_ptr<GeomDataAPI_Point> aC = std::dynamic_pointer_cast<GeomDataAPI_Point>(
 978       aBase->attribute(SketchPlugin_Sketch::ORIGIN_ID()));
 979   std::shared_ptr<GeomDataAPI_Dir> aNorm = std::dynamic_pointer_cast<GeomDataAPI_Dir>(
 980       aBase->attribute(SketchPlugin_Sketch::NORM_ID()));
 981   std::shared_ptr<GeomDataAPI_Dir> aX = std::dynamic_pointer_cast<GeomDataAPI_Dir>(
 982       aBase->attribute(SketchPlugin_Sketch::DIRX_ID()));
 983   std::shared_ptr<GeomAPI_Dir> aY(new GeomAPI_Dir(aNorm->dir()->cross(aX->dir())));
 984
 985   return thePoint->to2D(aC->pnt(), aX->dir(), aY);
 986 }
 987
 988 //--------------------------------------------------------------------------------------
 989
 990 void SketchAPI_Sketch::dump(ModelHighAPI_Dumper& theDumper) const
 991 {
 992   FeaturePtr aBase = feature();
 993   const std::string& aDocName = theDumper.name(aBase->document());
 994
 995   AttributeSelectionPtr anExternal = aBase->selection(SketchPlugin_SketchEntity::EXTERNAL_ID());
 996   if (anExternal->value()) {
 997     theDumper << aBase << " = model.addSketch(" << aDocName <<
 998       ", " << anExternal << ")" << std::endl;
 999   } else {
1000     // Sketch is base on a plane.
1001     std::shared_ptr<GeomAPI_Pnt> anOrigin = std::dynamic_pointer_cast<GeomDataAPI_Point>(
1002         aBase->attribute(SketchPlugin_Sketch::ORIGIN_ID()))->pnt();
1003     std::shared_ptr<GeomAPI_Dir> aNormal = std::dynamic_pointer_cast<GeomDataAPI_Dir>(
1004         aBase->attribute(SketchPlugin_Sketch::NORM_ID()))->dir();
1005     std::shared_ptr<GeomAPI_Dir> aDirX = std::dynamic_pointer_cast<GeomDataAPI_Dir>(
1006         aBase->attribute(SketchPlugin_Sketch::DIRX_ID()))->dir();
1007
1008     // Check the plane is coordinate plane
1009     std::string aPlaneName = defaultPlane(anOrigin, aNormal, aDirX);
1010     if(anExternal->context()) { // checking for selected planes
1011       if (!aPlaneName.empty()
1012           && anExternal->context()->data()
1013           && anExternal->context()->data()->name() == aPlaneName) {
1014         // dump sketch based on coordinate plane
1015         theDumper << aBase << " = model.addSketch(" << aDocName
1016                   << ", model.standardPlane(\"" << aPlaneName << "\"))" << std::endl;
1017       } else { // some other plane
1018         theDumper << aBase << " = model.addSketch(" << aDocName <<
1019           ", " << anExternal<< ")" << std::endl;
1020       }
1021     } else {
1022       if (aPlaneName.empty()) {
1023         // needs import additional module
1024         theDumper.importModule("GeomAPI");
1025         // dump plane parameters
1026         const std::string& aSketchName = theDumper.name(aBase);
1027         std::string anOriginName = aSketchName + "_origin";
1028         std::string aNormalName  = aSketchName + "_norm";
1029         std::string aDirXName    = aSketchName + "_dirx";
1030         // use "\n" instead of std::endl to avoid automatic dumping sketch here
1031         // and then dumplicate dumping it in the next line
1032         theDumper << anOriginName << " = " << anOrigin << "\n"
1033                   << aNormalName  << " = " << aNormal  << "\n"
1034                   << aDirXName    << " = " << aDirX    << "\n";
1035         // dump sketch based on arbitrary plane
1036         theDumper << aBase << " = model.addSketch(" << aDocName << ", GeomAPI_Ax3("
1037                   << anOriginName << ", " << aDirXName << ", " << aNormalName << "))" << std::endl;
1038       } else {
1039         // dump sketch based on coordinate plane
1040         theDumper << aBase << " = model.addSketch(" << aDocName
1041                   << ", model.defaultPlane(\"" << aPlaneName << "\"))" << std::endl;
1042       }
1043     }
1044   }
1045
1046   // dump sketch's subfeatures
1047   CompositeFeaturePtr aCompFeat = std::dynamic_pointer_cast<ModelAPI_CompositeFeature>(aBase);
1048   theDumper.processSubs(aCompFeat, true);
1049 }