src/SketchSolver/PlaneGCSSolver/PlaneGCSSolver_Tools.cpp

   1 // Copyright (C) 2014-2019  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 email : webmaster.salome@opencascade.com
  18 //
  19
  20 #include <PlaneGCSSolver_Tools.h>
  21 #include <PlaneGCSSolver_EdgeWrapper.h>
  22 #include <PlaneGCSSolver_PointArrayWrapper.h>
  23 #include <PlaneGCSSolver_PointWrapper.h>
  24 #include <PlaneGCSSolver_ScalarArrayWrapper.h>
  25 #include <PlaneGCSSolver_ScalarWrapper.h>
  26 #include <PlaneGCSSolver_ConstraintWrapper.h>
  27
  28 #include <SketchSolver_Constraint.h>
  29 #include <SketchSolver_ConstraintAngle.h>
  30 #include <SketchSolver_ConstraintCoincidence.h>
  31 #include <SketchPlugin_ConstraintCoincidenceInternal.h>
  32 #include <SketchSolver_ConstraintCollinear.h>
  33 #include <SketchSolver_ConstraintDistance.h>
  34 #include <SketchSolver_ConstraintEqual.h>
  35 #include <SketchSolver_ConstraintFixed.h>
  36 #include <SketchSolver_ConstraintLength.h>
  37 #include <SketchSolver_ConstraintMiddle.h>
  38 #include <SketchSolver_ConstraintMirror.h>
  39 #include <SketchSolver_ConstraintPerpendicular.h>
  40 #include <SketchSolver_ConstraintTangent.h>
  41 #include <SketchSolver_ConstraintMultiRotation.h>
  42 #include <SketchSolver_ConstraintMultiTranslation.h>
  43
  44 #include <SketchPlugin_Arc.h>
  45 #include <SketchPlugin_BSpline.h>
  46 #include <SketchPlugin_Circle.h>
  47 #include <SketchPlugin_ConstraintAngle.h>
  48 #include <SketchPlugin_ConstraintCoincidence.h>
  49 #include <SketchPlugin_ConstraintCollinear.h>
  50 #include <SketchPlugin_ConstraintDistance.h>
  51 #include <SketchPlugin_ConstraintDistanceHorizontal.h>
  52 #include <SketchPlugin_ConstraintDistanceVertical.h>
  53 #include <SketchPlugin_ConstraintEqual.h>
  54 #include <SketchPlugin_ConstraintLength.h>
  55 #include <SketchPlugin_ConstraintMiddle.h>
  56 #include <SketchPlugin_ConstraintMirror.h>
  57 #include <SketchPlugin_ConstraintRigid.h>
  58 #include <SketchPlugin_ConstraintPerpendicular.h>
  59 #include <SketchPlugin_ConstraintTangent.h>
  60 #include <SketchPlugin_Ellipse.h>
  61 #include <SketchPlugin_EllipticArc.h>
  62 #include <SketchPlugin_Line.h>
  63 #include <SketchPlugin_MultiRotation.h>
  64 #include <SketchPlugin_MultiTranslation.h>
  65 #include <SketchPlugin_Point.h>
  66
  67 #include <GeomAPI_Circ2d.h>
  68 #include <GeomAPI_Dir2d.h>
  69 #include <GeomAPI_Ellipse2d.h>
  70 #include <GeomAPI_Lin2d.h>
  71 #include <GeomAPI_Pnt2d.h>
  72
  73 #include <ModelAPI_AttributeDoubleArray.h>
  74 #include <ModelAPI_AttributeIntArray.h>
  75
  76 #include <cmath>
  77
  78
  79 #define GCS_EDGE_WRAPPER(x)   std::dynamic_pointer_cast<PlaneGCSSolver_EdgeWrapper>(x)
  80 #define GCS_POINT_WRAPPER(x)  std::dynamic_pointer_cast<PlaneGCSSolver_PointWrapper>(x)
  81 #define GCS_SCALAR_WRAPPER(x) std::dynamic_pointer_cast<PlaneGCSSolver_ScalarWrapper>(x)
  82
  83
  84
  85 static ConstraintWrapperPtr
  86   createConstraintCoincidence(std::shared_ptr<PlaneGCSSolver_PointWrapper> thePoint1,
  87                               std::shared_ptr<PlaneGCSSolver_PointWrapper> thePoint2);
  88 static ConstraintWrapperPtr
  89   createConstraintPointOnEntity(const SketchSolver_ConstraintType& theType,
  90                                 std::shared_ptr<PlaneGCSSolver_PointWrapper> thePoint,
  91                                 std::shared_ptr<PlaneGCSSolver_EdgeWrapper> theEntity,
  92                                 std::shared_ptr<PlaneGCSSolver_ScalarWrapper> theValue);
  93 static ConstraintWrapperPtr
  94   createConstraintPointsCollinear(std::shared_ptr<PlaneGCSSolver_PointWrapper> thePoint1,
  95                                   std::shared_ptr<PlaneGCSSolver_PointWrapper> thePoint2,
  96                                   std::shared_ptr<PlaneGCSSolver_PointWrapper> thePoint3);
  97 static ConstraintWrapperPtr
  98   createConstraintDistancePointPoint(std::shared_ptr<PlaneGCSSolver_ScalarWrapper> theValue,
  99                                      std::shared_ptr<PlaneGCSSolver_PointWrapper> thePoint1,
 100                                      std::shared_ptr<PlaneGCSSolver_PointWrapper> thePoint2);
 101 static ConstraintWrapperPtr
 102   createConstraintDistancePointLine(std::shared_ptr<PlaneGCSSolver_ScalarWrapper> theValue,
 103                                     std::shared_ptr<PlaneGCSSolver_PointWrapper>  thePoint,
 104                                     std::shared_ptr<PlaneGCSSolver_EdgeWrapper> theEntity);
 105 static ConstraintWrapperPtr
 106   createConstraintHVDistance(const SketchSolver_ConstraintType& theType,
 107                              std::shared_ptr<PlaneGCSSolver_ScalarWrapper> theValue,
 108                              std::shared_ptr<PlaneGCSSolver_PointWrapper> thePoint1,
 109                              std::shared_ptr<PlaneGCSSolver_PointWrapper> thePoint2);
 110 static ConstraintWrapperPtr
 111   createConstraintRadius(std::shared_ptr<PlaneGCSSolver_ScalarWrapper> theValue,
 112                          std::shared_ptr<PlaneGCSSolver_EdgeWrapper> theEntity);
 113 static ConstraintWrapperPtr
 114   createConstraintAngle(ConstraintPtr theConstraint,
 115                         std::shared_ptr<PlaneGCSSolver_ScalarWrapper> theValue,
 116                         std::shared_ptr<PlaneGCSSolver_EdgeWrapper> theEntity1,
 117                         std::shared_ptr<PlaneGCSSolver_EdgeWrapper> theEntity2);
 118 static ConstraintWrapperPtr
 119   createConstraintHorizVert(const SketchSolver_ConstraintType& theType,
 120                             std::shared_ptr<PlaneGCSSolver_EdgeWrapper> theEntity);
 121 static ConstraintWrapperPtr
 122   createConstraintParallel(std::shared_ptr<PlaneGCSSolver_EdgeWrapper> theEntity1,
 123                            std::shared_ptr<PlaneGCSSolver_EdgeWrapper> theEntity2);
 124 static ConstraintWrapperPtr
 125   createConstraintPerpendicular(std::shared_ptr<PlaneGCSSolver_EdgeWrapper> theEntity1,
 126                                 std::shared_ptr<PlaneGCSSolver_EdgeWrapper> theEntity2);
 127 static ConstraintWrapperPtr
 128   createConstraintEqual(const SketchSolver_ConstraintType& theType,
 129                         std::shared_ptr<PlaneGCSSolver_EdgeWrapper> theEntity1,
 130                         std::shared_ptr<PlaneGCSSolver_EdgeWrapper> theEntity2,
 131                         std::shared_ptr<PlaneGCSSolver_ScalarWrapper> theIntermed);
 132 static ConstraintWrapperPtr
 133   createConstraintMiddlePoint(std::shared_ptr<PlaneGCSSolver_PointWrapper> thePoint,
 134                               std::shared_ptr<PlaneGCSSolver_EdgeWrapper>  theEntity,
 135                               std::shared_ptr<PlaneGCSSolver_PointWrapper> theAuxParameters);
 136 static ConstraintWrapperPtr
 137   createConstraintAngleBetweenCurves(std::shared_ptr<PlaneGCSSolver_ScalarWrapper> theValue,
 138                                      std::shared_ptr<PlaneGCSSolver_PointWrapper> thePoint,
 139                                      std::shared_ptr<PlaneGCSSolver_EdgeWrapper> theEntity1,
 140                                      std::shared_ptr<PlaneGCSSolver_EdgeWrapper> theEntity2);
 141
 142 static GCS::SET_pD scalarParameters(const ScalarWrapperPtr& theScalar);
 143 static GCS::SET_pD scalarArrayParameters(const EntityWrapperPtr& theArray);
 144 static GCS::SET_pD pointParameters(const PointWrapperPtr& thePoint);
 145 static GCS::SET_pD pointArrayParameters(const EntityWrapperPtr& theArray);
 146 static GCS::SET_pD lineParameters(const EdgeWrapperPtr& theLine);
 147 static GCS::SET_pD circleParameters(const EdgeWrapperPtr& theCircle);
 148 static GCS::SET_pD arcParameters(const EdgeWrapperPtr& theArc);
 149 static GCS::SET_pD ellipseParameters(const EdgeWrapperPtr& theEllipse);
 150 static GCS::SET_pD ellipticArcParameters(const EdgeWrapperPtr& theEllipticArc);
 151 static GCS::SET_pD bsplineParameters(const EdgeWrapperPtr& theEdge);
 152
 153
 154
 155
 156 SolverConstraintPtr PlaneGCSSolver_Tools::createConstraint(ConstraintPtr theConstraint)
 157 {
 158   if (theConstraint->getKind() == SketchPlugin_ConstraintCoincidence::ID() ||
 159       theConstraint->getKind() == SketchPlugin_ConstraintCoincidenceInternal::ID()) {
 160     return SolverConstraintPtr(new SketchSolver_ConstraintCoincidence(theConstraint));
 161   } else if (theConstraint->getKind() == SketchPlugin_ConstraintCollinear::ID()) {
 162     return SolverConstraintPtr(new SketchSolver_ConstraintCollinear(theConstraint));
 163   } else if (theConstraint->getKind() == SketchPlugin_ConstraintDistance::ID() ||
 164              theConstraint->getKind() == SketchPlugin_ConstraintDistanceHorizontal::ID() ||
 165              theConstraint->getKind() == SketchPlugin_ConstraintDistanceVertical::ID()) {
 166     return SolverConstraintPtr(new SketchSolver_ConstraintDistance(theConstraint));
 167   } else if (theConstraint->getKind() == SketchPlugin_ConstraintEqual::ID()) {
 168     return SolverConstraintPtr(new SketchSolver_ConstraintEqual(theConstraint));
 169   } else if (theConstraint->getKind() == SketchPlugin_ConstraintLength::ID()) {
 170     return SolverConstraintPtr(new SketchSolver_ConstraintLength(theConstraint));
 171   } else if (theConstraint->getKind() == SketchPlugin_ConstraintMiddle::ID()) {
 172     return SolverConstraintPtr(new SketchSolver_ConstraintMiddle(theConstraint));
 173   } else if (theConstraint->getKind() == SketchPlugin_ConstraintMirror::ID()) {
 174     return SolverConstraintPtr(new SketchSolver_ConstraintMirror(theConstraint));
 175   } else if (theConstraint->getKind() == SketchPlugin_ConstraintTangent::ID()) {
 176     return SolverConstraintPtr(new SketchSolver_ConstraintTangent(theConstraint));
 177   } else if (theConstraint->getKind() == SketchPlugin_ConstraintRigid::ID()) {
 178     return SolverConstraintPtr(new SketchSolver_ConstraintFixed(theConstraint));
 179   } else if (theConstraint->getKind() == SketchPlugin_MultiTranslation::ID()) {
 180     return SolverConstraintPtr(new SketchSolver_ConstraintMultiTranslation(theConstraint));
 181   } else if (theConstraint->getKind() == SketchPlugin_MultiRotation::ID()) {
 182     return SolverConstraintPtr(new SketchSolver_ConstraintMultiRotation(theConstraint));
 183   } else if (theConstraint->getKind() == SketchPlugin_ConstraintAngle::ID()) {
 184     return SolverConstraintPtr(new SketchSolver_ConstraintAngle(theConstraint));
 185   } else if (theConstraint->getKind() == SketchPlugin_ConstraintPerpendicular::ID()) {
 186     return SolverConstraintPtr(new SketchSolver_ConstraintPerpendicular(theConstraint));
 187   }
 188   // All other types of constraints
 189   return SolverConstraintPtr(new SketchSolver_Constraint(theConstraint));
 190 }
 191
 192 std::shared_ptr<SketchSolver_ConstraintMovement> PlaneGCSSolver_Tools::createMovementConstraint(
 193     FeaturePtr theMovedFeature)
 194 {
 195   return std::shared_ptr<SketchSolver_ConstraintMovement>(
 196       new SketchSolver_ConstraintMovement(theMovedFeature));
 197 }
 198
 199 std::shared_ptr<SketchSolver_ConstraintMovement> PlaneGCSSolver_Tools::createMovementConstraint(
 200     AttributePtr theMovedAttribute)
 201 {
 202   return std::shared_ptr<SketchSolver_ConstraintMovement>(
 203       new SketchSolver_ConstraintMovement(theMovedAttribute));
 204 }
 205
 206 std::shared_ptr<SketchSolver_ConstraintMovement> PlaneGCSSolver_Tools::createMovementConstraint(
 207     const std::pair<AttributePtr, int>& theMovedPointInArray)
 208 {
 209   return std::shared_ptr<SketchSolver_ConstraintMovement>(
 210       new SketchSolver_ConstraintMovement(theMovedPointInArray.first, theMovedPointInArray.second));
 211 }
 212
 213
 214
 215 ConstraintWrapperPtr PlaneGCSSolver_Tools::createConstraint(
 216     ConstraintPtr theConstraint,
 217     const SketchSolver_ConstraintType& theType,
 218     const EntityWrapperPtr& theValue,
 219     const EntityWrapperPtr& thePoint1,
 220     const EntityWrapperPtr& thePoint2,
 221     const EntityWrapperPtr& theEntity1,
 222     const EntityWrapperPtr& theEntity2)
 223 {
 224   ConstraintWrapperPtr aResult;
 225   ScalarWrapperPtr anIntermediate;
 226
 227   std::shared_ptr<PlaneGCSSolver_PointWrapper> aPoint1 = GCS_POINT_WRAPPER(thePoint1);
 228   std::shared_ptr<PlaneGCSSolver_PointWrapper> aPoint2 = GCS_POINT_WRAPPER(thePoint2);
 229   std::shared_ptr<PlaneGCSSolver_EdgeWrapper> anEntity1 = GCS_EDGE_WRAPPER(theEntity1);
 230
 231   switch (theType) {
 232   case CONSTRAINT_PT_PT_COINCIDENT:
 233     aResult = createConstraintCoincidence(aPoint1, aPoint2);
 234     break;
 235   case CONSTRAINT_PT_ON_CURVE:
 236     aResult = anEntity1 ?
 237         createConstraintPointOnEntity(theType, aPoint1, anEntity1, GCS_SCALAR_WRAPPER(theValue)) :
 238         createConstraintPointsCollinear(aPoint1, aPoint2, GCS_POINT_WRAPPER(theEntity1));
 239     break;
 240   case CONSTRAINT_MIDDLE_POINT:
 241     aResult = createConstraintMiddlePoint(aPoint1, GCS_EDGE_WRAPPER(theEntity1), aPoint2);
 242     break;
 243   case CONSTRAINT_PT_PT_DISTANCE:
 244     aResult = createConstraintDistancePointPoint(GCS_SCALAR_WRAPPER(theValue), aPoint1, aPoint2);
 245     break;
 246   case CONSTRAINT_PT_LINE_DISTANCE:
 247     aResult = createConstraintDistancePointLine(GCS_SCALAR_WRAPPER(theValue),
 248                                                 aPoint1,
 249                                                 anEntity1);
 250     break;
 251   case CONSTRAINT_HORIZONTAL_DISTANCE:
 252   case CONSTRAINT_VERTICAL_DISTANCE:
 253     aResult = createConstraintHVDistance(theType, GCS_SCALAR_WRAPPER(theValue), aPoint1, aPoint2);
 254     break;
 255   case CONSTRAINT_RADIUS:
 256     aResult = createConstraintRadius(GCS_SCALAR_WRAPPER(theValue), anEntity1);
 257     break;
 258   case CONSTRAINT_ANGLE:
 259     aResult = createConstraintAngle(theConstraint,
 260                   GCS_SCALAR_WRAPPER(theValue),
 261                   anEntity1, GCS_EDGE_WRAPPER(theEntity2));
 262     break;
 263   case CONSTRAINT_FIXED:
 264     break;
 265   case CONSTRAINT_HORIZONTAL:
 266   case CONSTRAINT_VERTICAL:
 267     aResult = createConstraintHorizVert(theType, anEntity1);
 268     break;
 269   case CONSTRAINT_PARALLEL:
 270     aResult = createConstraintParallel(anEntity1, GCS_EDGE_WRAPPER(theEntity2));
 271     break;
 272   case CONSTRAINT_PERPENDICULAR:
 273     aResult = createConstraintPerpendicular(anEntity1, GCS_EDGE_WRAPPER(theEntity2));
 274     break;
 275   case CONSTRAINT_PERPENDICULAR_CURVES:
 276     aResult = createConstraintAngleBetweenCurves(GCS_SCALAR_WRAPPER(theValue),
 277                   aPoint1, anEntity1, GCS_EDGE_WRAPPER(theEntity2));
 278     break;
 279   case CONSTRAINT_EQUAL_LINES:
 280   case CONSTRAINT_EQUAL_ELLIPSES:
 281     anIntermediate = GCS_SCALAR_WRAPPER(theValue); // parameter is used to store length of lines
 282   case CONSTRAINT_EQUAL_LINE_ARC:
 283   case CONSTRAINT_EQUAL_RADIUS:
 284     aResult = createConstraintEqual(theType,
 285                                     anEntity1,
 286                                     GCS_EDGE_WRAPPER(theEntity2),
 287                                     anIntermediate);
 288     break;
 289   default:
 290     break;
 291   }
 292
 293   return aResult;
 294 }
 295
 296 std::shared_ptr<GeomAPI_Pnt2d> PlaneGCSSolver_Tools::point(EntityWrapperPtr theEntity)
 297 {
 298   if (theEntity->type() != ENTITY_POINT)
 299     return std::shared_ptr<GeomAPI_Pnt2d>();
 300
 301   std::shared_ptr<PlaneGCSSolver_PointWrapper> aPointWrapper =
 302       std::dynamic_pointer_cast<PlaneGCSSolver_PointWrapper>(theEntity);
 303   const GCSPointPtr& aPoint = aPointWrapper->point();
 304   return std::shared_ptr<GeomAPI_Pnt2d>(new GeomAPI_Pnt2d(*aPoint->x, *aPoint->y));
 305 }
 306
 307 std::shared_ptr<GeomAPI_Lin2d> PlaneGCSSolver_Tools::line(EntityWrapperPtr theEntity)
 308 {
 309   if (theEntity->type() != ENTITY_LINE)
 310     return std::shared_ptr<GeomAPI_Lin2d>();
 311
 312   std::shared_ptr<PlaneGCSSolver_EdgeWrapper> anEntity =
 313       std::dynamic_pointer_cast<PlaneGCSSolver_EdgeWrapper>(theEntity);
 314   std::shared_ptr<GCS::Line> aLine = std::dynamic_pointer_cast<GCS::Line>(anEntity->entity());
 315   return std::shared_ptr<GeomAPI_Lin2d>(
 316       new GeomAPI_Lin2d(*(aLine->p1.x), *(aLine->p1.y), *(aLine->p2.x), *(aLine->p2.y)));
 317 }
 318
 319 std::shared_ptr<GeomAPI_Lin2d> PlaneGCSSolver_Tools::line(FeaturePtr theFeature)
 320 {
 321   if (theFeature->getKind() != SketchPlugin_Line::ID())
 322     return std::shared_ptr<GeomAPI_Lin2d>();
 323
 324   AttributePoint2DPtr aStart = std::dynamic_pointer_cast<GeomDataAPI_Point2D>(
 325       theFeature->attribute(SketchPlugin_Line::START_ID()));
 326   AttributePoint2DPtr aEnd = std::dynamic_pointer_cast<GeomDataAPI_Point2D>(
 327       theFeature->attribute(SketchPlugin_Line::END_ID()));
 328
 329   return std::shared_ptr<GeomAPI_Lin2d>(new GeomAPI_Lin2d(aStart->pnt(), aEnd->pnt()));
 330 }
 331
 332 std::shared_ptr<GeomAPI_Circ2d> PlaneGCSSolver_Tools::circle(EntityWrapperPtr theEntity)
 333 {
 334   if (theEntity->type() != ENTITY_CIRCLE && theEntity->type() != ENTITY_ARC)
 335     return std::shared_ptr<GeomAPI_Circ2d>();
 336
 337   std::shared_ptr<PlaneGCSSolver_EdgeWrapper> anEntity =
 338     std::dynamic_pointer_cast<PlaneGCSSolver_EdgeWrapper>(theEntity);
 339   std::shared_ptr<GCS::Circle> aCirc = std::dynamic_pointer_cast<GCS::Circle>(anEntity->entity());
 340   return std::shared_ptr<GeomAPI_Circ2d>(
 341     new GeomAPI_Circ2d(*(aCirc->center.x), *(aCirc->center.y), *(aCirc->rad)));
 342 }
 343
 344 std::shared_ptr<GeomAPI_Ellipse2d> PlaneGCSSolver_Tools::ellipse(EntityWrapperPtr theEntity)
 345 {
 346   if (theEntity->type() != ENTITY_ELLIPSE && theEntity->type() != ENTITY_ELLIPTIC_ARC)
 347     return std::shared_ptr<GeomAPI_Ellipse2d>();
 348
 349   std::shared_ptr<PlaneGCSSolver_EdgeWrapper> anEntity =
 350     std::dynamic_pointer_cast<PlaneGCSSolver_EdgeWrapper>(theEntity);
 351   std::shared_ptr<GCS::Ellipse> anEllipse =
 352       std::dynamic_pointer_cast<GCS::Ellipse>(anEntity->entity());
 353
 354   std::shared_ptr<GeomAPI_Pnt2d> aCenter(
 355       new GeomAPI_Pnt2d(*(anEllipse->center.x), *(anEllipse->center.y)));
 356   std::shared_ptr<GeomAPI_Dir2d> anAxis(new GeomAPI_Dir2d(
 357       *(anEllipse->focus1.x) - *(anEllipse->center.x),
 358       *(anEllipse->focus1.y) - *(anEllipse->center.y)));
 359
 360   return std::shared_ptr<GeomAPI_Ellipse2d>(
 361       new GeomAPI_Ellipse2d(aCenter, anAxis, anEllipse->getRadMaj(), *anEllipse->radmin));
 362 }
 363
 364 void PlaneGCSSolver_Tools::recalculateArcParameters(EntityWrapperPtr theArc)
 365 {
 366   std::shared_ptr<PlaneGCSSolver_EdgeWrapper> anEdge =
 367       std::dynamic_pointer_cast<PlaneGCSSolver_EdgeWrapper>(theArc);
 368   if (!anEdge)
 369     return;
 370
 371   if (anEdge->type() == ENTITY_ARC) {
 372     std::shared_ptr<GCS::Arc> anArc = std::dynamic_pointer_cast<GCS::Arc>(anEdge->entity());
 373
 374     GCS::Point aCenter = anArc->center;
 375     GCS::Point aStartPnt = anArc->start;
 376     GCS::Point aEndPnt = anArc->end;
 377
 378     *anArc->rad = distance(aCenter, aStartPnt);
 379
 380     static GeomDir2dPtr OX(new GeomAPI_Dir2d(1.0, 0.0));
 381
 382     GeomDir2dPtr aDir(new GeomAPI_Dir2d(*aStartPnt.x - *aCenter.x, *aStartPnt.y - *aCenter.y));
 383     *anArc->startAngle = OX->angle(aDir);
 384
 385     aDir.reset(new GeomAPI_Dir2d(*aEndPnt.x - *aCenter.x, *aEndPnt.y - *aCenter.y));
 386     *anArc->endAngle = OX->angle(aDir);
 387   }
 388   else if (anEdge->type() == ENTITY_ELLIPTIC_ARC) {
 389     std::shared_ptr<GCS::ArcOfEllipse> aEllArc =
 390         std::dynamic_pointer_cast<GCS::ArcOfEllipse>(anEdge->entity());
 391
 392     GeomPnt2dPtr aCenter(new GeomAPI_Pnt2d(*aEllArc->center.x, *aEllArc->center.y));
 393     GeomPnt2dPtr aStartPnt(new GeomAPI_Pnt2d(*aEllArc->start.x, *aEllArc->start.y));
 394     GeomPnt2dPtr aEndPnt(new GeomAPI_Pnt2d(*aEllArc->end.x, *aEllArc->end.y));
 395
 396     GeomDir2dPtr anAxis(new GeomAPI_Dir2d(*aEllArc->focus1.x - aCenter->x(),
 397                                           *aEllArc->focus1.y - aCenter->y()));
 398     GeomAPI_Ellipse2d anEllipse(aCenter, anAxis, aEllArc->getRadMaj(), *aEllArc->radmin);
 399     anEllipse.parameter(aStartPnt, 1.e-4, *aEllArc->startAngle);
 400     anEllipse.parameter(aEndPnt, 1.e-4, *aEllArc->endAngle);
 401   }
 402 }
 403
 404
 405
 406 GCS::SET_pD PlaneGCSSolver_Tools::parameters(const EntityWrapperPtr& theEntity)
 407 {
 408   switch (theEntity->type()) {
 409   case ENTITY_SCALAR:
 410   case ENTITY_ANGLE:
 411     return scalarParameters(GCS_SCALAR_WRAPPER(theEntity));
 412   case ENTITY_SCALAR_ARRAY:
 413     return scalarArrayParameters(theEntity);
 414   case ENTITY_POINT:
 415     return pointParameters(GCS_POINT_WRAPPER(theEntity));
 416   case ENTITY_POINT_ARRAY:
 417     return pointArrayParameters(theEntity);
 418   case ENTITY_LINE:
 419     return lineParameters(GCS_EDGE_WRAPPER(theEntity));
 420   case ENTITY_CIRCLE:
 421     return circleParameters(GCS_EDGE_WRAPPER(theEntity));
 422   case ENTITY_ARC:
 423     return arcParameters(GCS_EDGE_WRAPPER(theEntity));
 424   case ENTITY_ELLIPSE:
 425     return ellipseParameters(GCS_EDGE_WRAPPER(theEntity));
 426   case ENTITY_ELLIPTIC_ARC:
 427     return ellipticArcParameters(GCS_EDGE_WRAPPER(theEntity));
 428   case ENTITY_BSPLINE:
 429     return bsplineParameters(GCS_EDGE_WRAPPER(theEntity));
 430   default: break;
 431   }
 432   return GCS::SET_pD();
 433 }
 434
 435 bool PlaneGCSSolver_Tools::isAttributeApplicable(const std::string& theAttrName,
 436                                                  const std::string& theOwnerName)
 437 {
 438   if (theOwnerName == SketchPlugin_Arc::ID()) {
 439     return theAttrName == SketchPlugin_Arc::CENTER_ID() ||
 440            theAttrName == SketchPlugin_Arc::START_ID() ||
 441            theAttrName == SketchPlugin_Arc::END_ID() ||
 442            theAttrName == SketchPlugin_Arc::REVERSED_ID();
 443   }
 444   else if (theOwnerName == SketchPlugin_Circle::ID()) {
 445     return theAttrName == SketchPlugin_Circle::CENTER_ID() ||
 446            theAttrName == SketchPlugin_Circle::RADIUS_ID();
 447   }
 448   else if (theOwnerName == SketchPlugin_Line::ID()) {
 449     return theAttrName == SketchPlugin_Line::START_ID() ||
 450            theAttrName == SketchPlugin_Line::END_ID();
 451   }
 452   else if (theOwnerName == SketchPlugin_Ellipse::ID()) {
 453     return theAttrName == SketchPlugin_Ellipse::CENTER_ID() ||
 454            theAttrName == SketchPlugin_Ellipse::FIRST_FOCUS_ID() ||
 455            theAttrName == SketchPlugin_Ellipse::SECOND_FOCUS_ID() ||
 456            theAttrName == SketchPlugin_Ellipse::MAJOR_AXIS_START_ID() ||
 457            theAttrName == SketchPlugin_Ellipse::MAJOR_AXIS_END_ID() ||
 458            theAttrName == SketchPlugin_Ellipse::MINOR_AXIS_START_ID() ||
 459            theAttrName == SketchPlugin_Ellipse::MINOR_AXIS_END_ID() ||
 460            theAttrName == SketchPlugin_Ellipse::MAJOR_RADIUS_ID() ||
 461            theAttrName == SketchPlugin_Ellipse::MINOR_RADIUS_ID();
 462   }
 463   else if (theOwnerName == SketchPlugin_EllipticArc::ID()) {
 464     return theAttrName == SketchPlugin_EllipticArc::CENTER_ID() ||
 465            theAttrName == SketchPlugin_EllipticArc::FIRST_FOCUS_ID() ||
 466            theAttrName == SketchPlugin_EllipticArc::SECOND_FOCUS_ID() ||
 467            theAttrName == SketchPlugin_EllipticArc::MAJOR_AXIS_START_ID() ||
 468            theAttrName == SketchPlugin_EllipticArc::MAJOR_AXIS_END_ID() ||
 469            theAttrName == SketchPlugin_EllipticArc::MINOR_AXIS_START_ID() ||
 470            theAttrName == SketchPlugin_EllipticArc::MINOR_AXIS_END_ID() ||
 471            theAttrName == SketchPlugin_EllipticArc::MAJOR_RADIUS_ID() ||
 472            theAttrName == SketchPlugin_EllipticArc::MINOR_RADIUS_ID() ||
 473            theAttrName == SketchPlugin_EllipticArc::START_POINT_ID() ||
 474            theAttrName == SketchPlugin_EllipticArc::END_POINT_ID() ||
 475            theAttrName == SketchPlugin_EllipticArc::REVERSED_ID();
 476   }
 477   else if (theOwnerName == SketchPlugin_BSpline::ID()) {
 478     return theAttrName == SketchPlugin_BSpline::POLES_ID() ||
 479            theAttrName == SketchPlugin_BSpline::WEIGHTS_ID() ||
 480            theAttrName == SketchPlugin_BSpline::KNOTS_ID() ||
 481            theAttrName == SketchPlugin_BSpline::MULTS_ID() ||
 482            theAttrName == SketchPlugin_BSpline::DEGREE_ID() ||
 483            theAttrName == SketchPlugin_BSpline::START_ID() ||
 484            theAttrName == SketchPlugin_BSpline::END_ID();
 485   }
 486
 487   // suppose that all remaining features are points
 488   return theAttrName == SketchPlugin_Point::COORD_ID();
 489 }
 490
 491 /// \brief Update value
 492 bool PlaneGCSSolver_Tools::updateValue(const double& theSource, double& theDest,
 493                                        const double theTolerance)
 494 {
 495   bool isUpdated = fabs(theSource - theDest) > theTolerance;
 496   if (isUpdated)
 497     theDest = theSource;
 498   return isUpdated;
 499 }
 500
 501
 502 double PlaneGCSSolver_Tools::distance(const GCS::Point& thePnt1, const GCS::Point& thePnt2)
 503 {
 504   double x = *thePnt1.x - *thePnt2.x;
 505   double y = *thePnt1.y - *thePnt2.y;
 506   return sqrt(x*x + y*y);
 507 }
 508
 509
 510
 511
 512 // ================   AttributeArray methods   ==========================
 513 PlaneGCSSolver_Tools::AttributeArray::AttributeArray(AttributePtr theAttribute)
 514 {
 515   myDouble = std::dynamic_pointer_cast<ModelAPI_AttributeDoubleArray>(theAttribute);
 516   myInteger = std::dynamic_pointer_cast<ModelAPI_AttributeIntArray>(theAttribute);
 517 }
 518
 519 bool PlaneGCSSolver_Tools::AttributeArray::isInitialized() const
 520 {
 521   return (myDouble && myDouble->isInitialized()) || (myInteger && myInteger->isInitialized());
 522 }
 523
 524 int PlaneGCSSolver_Tools::AttributeArray::size() const
 525 {
 526   return myDouble.get() ? myDouble->size() : myInteger->size();
 527 }
 528
 529 double PlaneGCSSolver_Tools::AttributeArray::value(const int theIndex) const
 530 {
 531   return myDouble.get() ? myDouble->value(theIndex) : myInteger->value(theIndex);
 532 }
 533
 534
 535
 536
 537
 538
 539 // ================   Auxiliary functions   ==========================
 540 ConstraintWrapperPtr createConstraintCoincidence(
 541     std::shared_ptr<PlaneGCSSolver_PointWrapper> thePoint1,
 542     std::shared_ptr<PlaneGCSSolver_PointWrapper> thePoint2)
 543 {
 544   GCSPointPtr aPoint1 = thePoint1->point();
 545   GCSPointPtr aPoint2 = thePoint2->point();
 546
 547   // Create equality constraint for corresponding attributes of the points
 548   std::list<GCSConstraintPtr> aConstrList;
 549   aConstrList.push_back(
 550       GCSConstraintPtr(new GCS::ConstraintEqual(aPoint1->x, aPoint2->x)));
 551   aConstrList.push_back(
 552       GCSConstraintPtr(new GCS::ConstraintEqual(aPoint1->y, aPoint2->y)));
 553
 554   return ConstraintWrapperPtr(new PlaneGCSSolver_ConstraintWrapper(
 555       aConstrList, CONSTRAINT_PT_PT_COINCIDENT));
 556 }
 557
 558 ConstraintWrapperPtr createConstraintPointOnEntity(
 559     const SketchSolver_ConstraintType& theType,
 560     std::shared_ptr<PlaneGCSSolver_PointWrapper> thePoint,
 561     std::shared_ptr<PlaneGCSSolver_EdgeWrapper> theEntity,
 562     std::shared_ptr<PlaneGCSSolver_ScalarWrapper> theValue)
 563 {
 564   GCSConstraintPtr aNewConstr;
 565
 566   switch (theEntity->type()) {
 567   case ENTITY_LINE: {
 568     std::shared_ptr<GCS::Line> aLine = std::dynamic_pointer_cast<GCS::Line>(theEntity->entity());
 569     aNewConstr = GCSConstraintPtr(new GCS::ConstraintPointOnLine(*(thePoint->point()), *aLine));
 570     break;
 571     }
 572   case ENTITY_ARC:
 573   case ENTITY_CIRCLE: {
 574     std::shared_ptr<GCS::Circle> aCirc =
 575       std::dynamic_pointer_cast<GCS::Circle>(theEntity->entity());
 576     aNewConstr = GCSConstraintPtr(
 577         new GCS::ConstraintP2PDistance(*(thePoint->point()), aCirc->center, aCirc->rad));
 578     break;
 579     }
 580   case ENTITY_ELLIPSE:
 581   case ENTITY_ELLIPTIC_ARC: {
 582     std::shared_ptr<GCS::Ellipse> anEllipse =
 583         std::dynamic_pointer_cast<GCS::Ellipse>(theEntity->entity());
 584     aNewConstr = GCSConstraintPtr(
 585         new GCS::ConstraintPointOnEllipse(*(thePoint->point()), *anEllipse));
 586     break;
 587     }
 588   case ENTITY_BSPLINE: {
 589     std::list<GCSConstraintPtr> aConstraints;
 590     aConstraints.push_back(GCSConstraintPtr(new GCS::ConstraintCurveValue(
 591         *thePoint->point(), thePoint->point()->x, *theEntity->entity(), theValue->scalar())));
 592     aConstraints.push_back(GCSConstraintPtr(new GCS::ConstraintCurveValue(
 593         *thePoint->point(), thePoint->point()->y, *theEntity->entity(), theValue->scalar())));
 594     return ConstraintWrapperPtr(new PlaneGCSSolver_ConstraintWrapper(aConstraints, theType));
 595   }
 596   default:
 597     return ConstraintWrapperPtr();
 598   }
 599
 600   return ConstraintWrapperPtr(new PlaneGCSSolver_ConstraintWrapper(aNewConstr, theType));
 601 }
 602
 603 ConstraintWrapperPtr createConstraintPointsCollinear(
 604     std::shared_ptr<PlaneGCSSolver_PointWrapper> thePoint1,
 605     std::shared_ptr<PlaneGCSSolver_PointWrapper> thePoint2,
 606     std::shared_ptr<PlaneGCSSolver_PointWrapper> thePoint3)
 607 {
 608   GCSConstraintPtr aNewConstr(new GCS::ConstraintPointOnLine(
 609       *(thePoint1->point()), *(thePoint2->point()), *(thePoint3->point())));
 610   return ConstraintWrapperPtr(
 611       new PlaneGCSSolver_ConstraintWrapper(aNewConstr, CONSTRAINT_PT_ON_CURVE));
 612 }
 613
 614 template <typename ARCTYPE>
 615 void createConstraintMiddlePointOnArc(ARCTYPE theArc,
 616                                       GCSPointPtr thePoint,
 617                                       std::shared_ptr<PlaneGCSSolver_PointWrapper> theAuxParameters,
 618                                       std::list<GCSConstraintPtr>& theConstraints)
 619 {
 620   double* u = theAuxParameters->point()->x;
 621   double* diff = theAuxParameters->point()->y;
 622   *u = (*theArc->startAngle + *theArc->endAngle) * 0.5;
 623   *diff = (*theArc->endAngle - *theArc->startAngle) * 0.5;
 624
 625   theConstraints.push_back(GCSConstraintPtr(
 626       new GCS::ConstraintCurveValue(*thePoint, thePoint->x, *theArc, u)));
 627   theConstraints.push_back(GCSConstraintPtr(
 628       new GCS::ConstraintCurveValue(*thePoint, thePoint->y, *theArc, u)));
 629   theConstraints.push_back(GCSConstraintPtr(
 630       new GCS::ConstraintDifference(theArc->startAngle, u, diff)));
 631   theConstraints.push_back(GCSConstraintPtr(
 632       new GCS::ConstraintDifference(u, theArc->endAngle, diff)));
 633 }
 634
 635 ConstraintWrapperPtr createConstraintMiddlePoint(
 636     std::shared_ptr<PlaneGCSSolver_PointWrapper> thePoint,
 637     std::shared_ptr<PlaneGCSSolver_EdgeWrapper> theEntity,
 638     std::shared_ptr<PlaneGCSSolver_PointWrapper> theAuxParameters)
 639 {
 640   std::list<GCSConstraintPtr> aConstrList;
 641
 642   GCSPointPtr aPoint = thePoint->point();
 643   std::shared_ptr<GCS::Line> aLine = std::dynamic_pointer_cast<GCS::Line>(theEntity->entity());
 644   if (aLine) {
 645     aConstrList.push_back(GCSConstraintPtr(new GCS::ConstraintPointOnLine(*aPoint, *aLine)));
 646     aConstrList.push_back(
 647         GCSConstraintPtr(new GCS::ConstraintPointOnPerpBisector(*aPoint, aLine->p1, aLine->p2)));
 648   }
 649   else {
 650     std::shared_ptr<GCS::Arc> anArc = std::dynamic_pointer_cast<GCS::Arc>(theEntity->entity());
 651     if (anArc)
 652       createConstraintMiddlePointOnArc(anArc, aPoint, theAuxParameters, aConstrList);
 653     else {
 654       std::shared_ptr<GCS::ArcOfEllipse> aEllArc =
 655           std::dynamic_pointer_cast<GCS::ArcOfEllipse>(theEntity->entity());
 656       if (aEllArc)
 657         createConstraintMiddlePointOnArc(aEllArc, aPoint, theAuxParameters, aConstrList);
 658     }
 659   }
 660
 661   return aConstrList.empty() ? ConstraintWrapperPtr() : ConstraintWrapperPtr(
 662       new PlaneGCSSolver_ConstraintWrapper(aConstrList, CONSTRAINT_MIDDLE_POINT));
 663 }
 664
 665
 666 ConstraintWrapperPtr createConstraintDistancePointPoint(
 667     std::shared_ptr<PlaneGCSSolver_ScalarWrapper> theValue,
 668     std::shared_ptr<PlaneGCSSolver_PointWrapper>  thePoint1,
 669     std::shared_ptr<PlaneGCSSolver_PointWrapper>  thePoint2)
 670 {
 671   GCSConstraintPtr aNewConstr(new GCS::ConstraintP2PDistance(
 672       *(thePoint1->point()), *(thePoint2->point()), theValue->scalar()));
 673   std::shared_ptr<PlaneGCSSolver_ConstraintWrapper> aResult(
 674       new PlaneGCSSolver_ConstraintWrapper(aNewConstr, CONSTRAINT_PT_PT_DISTANCE));
 675   aResult->setValueParameter(theValue);
 676   return aResult;
 677 }
 678
 679 ConstraintWrapperPtr createConstraintDistancePointLine(
 680     std::shared_ptr<PlaneGCSSolver_ScalarWrapper> theValue,
 681     std::shared_ptr<PlaneGCSSolver_PointWrapper>  thePoint,
 682     std::shared_ptr<PlaneGCSSolver_EdgeWrapper> theEntity)
 683 {
 684   std::shared_ptr<GCS::Line> aLine = std::dynamic_pointer_cast<GCS::Line>(theEntity->entity());
 685   GCSConstraintPtr aNewConstr(new GCS::ConstraintP2LDistance(
 686       *(thePoint->point()), *(aLine), theValue->scalar()));
 687   std::shared_ptr<PlaneGCSSolver_ConstraintWrapper> aResult(
 688       new PlaneGCSSolver_ConstraintWrapper(aNewConstr, CONSTRAINT_PT_LINE_DISTANCE));
 689   aResult->setValueParameter(theValue);
 690   return aResult;
 691 }
 692
 693 ConstraintWrapperPtr createConstraintHVDistance(
 694     const SketchSolver_ConstraintType& theType,
 695     std::shared_ptr<PlaneGCSSolver_ScalarWrapper> theValue,
 696     std::shared_ptr<PlaneGCSSolver_PointWrapper> thePoint1,
 697     std::shared_ptr<PlaneGCSSolver_PointWrapper> thePoint2)
 698 {
 699   GCSPointPtr aPoint1 = thePoint1->point();
 700   GCSPointPtr aPoint2 = thePoint2->point();
 701
 702   double *aParam1, *aParam2;
 703   if (theType == CONSTRAINT_HORIZONTAL_DISTANCE) {
 704     aParam1 = aPoint1->x;
 705     aParam2 = aPoint2->x;
 706   } else if (theType == CONSTRAINT_VERTICAL_DISTANCE) {
 707     aParam1 = aPoint1->y;
 708     aParam2 = aPoint2->y;
 709   }
 710
 711   GCSConstraintPtr aNewConstr(new GCS::ConstraintDifference(aParam1, aParam2, theValue->scalar()));
 712
 713   std::shared_ptr<PlaneGCSSolver_ConstraintWrapper> aResult(
 714       new PlaneGCSSolver_ConstraintWrapper(aNewConstr, theType));
 715   aResult->setValueParameter(theValue);
 716   return aResult;
 717 }
 718
 719 ConstraintWrapperPtr createConstraintRadius(
 720     std::shared_ptr<PlaneGCSSolver_ScalarWrapper> theValue,
 721     std::shared_ptr<PlaneGCSSolver_EdgeWrapper> theEntity)
 722 {
 723   std::shared_ptr<GCS::Circle> aCircle =
 724     std::dynamic_pointer_cast<GCS::Circle>(theEntity->entity());
 725   GCSConstraintPtr aNewConstr(new GCS::ConstraintEqual(aCircle->rad, theValue->scalar()));
 726   std::shared_ptr<PlaneGCSSolver_ConstraintWrapper> aResult(
 727       new PlaneGCSSolver_ConstraintWrapper(aNewConstr, CONSTRAINT_RADIUS));
 728   aResult->setValueParameter(theValue);
 729   return aResult;
 730 }
 731
 732 ConstraintWrapperPtr createConstraintAngle(
 733     ConstraintPtr theConstraint,
 734     std::shared_ptr<PlaneGCSSolver_ScalarWrapper> theValue,
 735     std::shared_ptr<PlaneGCSSolver_EdgeWrapper> theEntity1,
 736     std::shared_ptr<PlaneGCSSolver_EdgeWrapper> theEntity2)
 737 {
 738   std::shared_ptr<GCS::Line> aLine1 = std::dynamic_pointer_cast<GCS::Line>(theEntity1->entity());
 739   std::shared_ptr<GCS::Line> aLine2 = std::dynamic_pointer_cast<GCS::Line>(theEntity2->entity());
 740
 741   GCSConstraintPtr aNewConstr(new GCS::ConstraintL2LAngle(
 742       aLine1->p1, aLine1->p2, aLine2->p1, aLine2->p2, theValue->scalar()));
 743
 744   std::shared_ptr<PlaneGCSSolver_ConstraintWrapper> aResult(
 745       new PlaneGCSSolver_ConstraintWrapper(aNewConstr, CONSTRAINT_ANGLE));
 746   aResult->setValueParameter(theValue);
 747   return aResult;
 748 }
 749
 750 ConstraintWrapperPtr createConstraintHorizVert(
 751     const SketchSolver_ConstraintType& theType,
 752     std::shared_ptr<PlaneGCSSolver_EdgeWrapper> theEntity)
 753 {
 754   std::shared_ptr<GCS::Line> aLine = std::dynamic_pointer_cast<GCS::Line>(theEntity->entity());
 755   GCSConstraintPtr aNewConstr;
 756   if (theType == CONSTRAINT_HORIZONTAL)
 757     aNewConstr = GCSConstraintPtr(new GCS::ConstraintEqual(aLine->p1.y, aLine->p2.y));
 758   else
 759     aNewConstr = GCSConstraintPtr(new GCS::ConstraintEqual(aLine->p1.x, aLine->p2.x));
 760
 761   return ConstraintWrapperPtr(new PlaneGCSSolver_ConstraintWrapper(aNewConstr, theType));
 762 }
 763
 764 ConstraintWrapperPtr createConstraintParallel(
 765     std::shared_ptr<PlaneGCSSolver_EdgeWrapper> theEntity1,
 766     std::shared_ptr<PlaneGCSSolver_EdgeWrapper> theEntity2)
 767 {
 768   std::shared_ptr<GCS::Line> aLine1 = std::dynamic_pointer_cast<GCS::Line>(theEntity1->entity());
 769   std::shared_ptr<GCS::Line> aLine2 = std::dynamic_pointer_cast<GCS::Line>(theEntity2->entity());
 770   GCSConstraintPtr aNewConstr(new GCS::ConstraintParallel(*(aLine1), *(aLine2)));
 771
 772   return ConstraintWrapperPtr(
 773       new PlaneGCSSolver_ConstraintWrapper(aNewConstr, CONSTRAINT_PARALLEL));
 774 }
 775
 776 ConstraintWrapperPtr createConstraintPerpendicular(
 777     std::shared_ptr<PlaneGCSSolver_EdgeWrapper> theEntity1,
 778     std::shared_ptr<PlaneGCSSolver_EdgeWrapper> theEntity2)
 779 {
 780   std::shared_ptr<GCS::Line> aLine1 = std::dynamic_pointer_cast<GCS::Line>(theEntity1->entity());
 781   std::shared_ptr<GCS::Line> aLine2 = std::dynamic_pointer_cast<GCS::Line>(theEntity2->entity());
 782
 783   std::shared_ptr<GCS::Circle> aCirc1 =
 784       std::dynamic_pointer_cast<GCS::Circle>(theEntity1->entity());
 785   std::shared_ptr<GCS::Circle> aCirc2 =
 786       std::dynamic_pointer_cast<GCS::Circle>(theEntity2->entity());
 787
 788   GCSConstraintPtr aNewConstr;
 789   if (aLine1 && aLine2)
 790     aNewConstr.reset(new GCS::ConstraintPerpendicular(*(aLine1), *(aLine2)));
 791   else {
 792     if (aLine1 && aCirc2)
 793       aCirc1 = aCirc2;
 794     else if (aLine2 && aCirc1)
 795       aLine1 = aLine2;
 796
 797     aNewConstr.reset(new GCS::ConstraintPointOnLine(aCirc1->center, *aLine1));
 798   }
 799
 800   return ConstraintWrapperPtr(
 801       new PlaneGCSSolver_ConstraintWrapper(aNewConstr, CONSTRAINT_PERPENDICULAR));
 802 }
 803
 804 ConstraintWrapperPtr createConstraintAngleBetweenCurves(
 805     std::shared_ptr<PlaneGCSSolver_ScalarWrapper> theValue,
 806     std::shared_ptr<PlaneGCSSolver_PointWrapper> thePoint,
 807     std::shared_ptr<PlaneGCSSolver_EdgeWrapper> theEntity1,
 808     std::shared_ptr<PlaneGCSSolver_EdgeWrapper> theEntity2)
 809 {
 810   GCSConstraintPtr aNewConstr(new GCS::ConstraintAngleViaPoint(
 811       *theEntity1->entity(), *theEntity2->entity(), *thePoint->point(), theValue->scalar()));
 812   return ConstraintWrapperPtr(
 813       new PlaneGCSSolver_ConstraintWrapper(aNewConstr, CONSTRAINT_PERPENDICULAR_CURVES));
 814 }
 815
 816 ConstraintWrapperPtr createConstraintEqual(
 817     const SketchSolver_ConstraintType& theType,
 818     std::shared_ptr<PlaneGCSSolver_EdgeWrapper> theEntity1,
 819     std::shared_ptr<PlaneGCSSolver_EdgeWrapper> theEntity2,
 820     std::shared_ptr<PlaneGCSSolver_ScalarWrapper> theIntermed)
 821 {
 822   if (theType == CONSTRAINT_EQUAL_LINE_ARC)
 823     return ConstraintWrapperPtr(); // line-arc equivalence is not supported yet
 824
 825   std::list<GCSConstraintPtr> aConstrList;
 826   if (theType == CONSTRAINT_EQUAL_LINES) {
 827     std::shared_ptr<GCS::Line> aLine1 = std::dynamic_pointer_cast<GCS::Line>(theEntity1->entity());
 828     std::shared_ptr<GCS::Line> aLine2 = std::dynamic_pointer_cast<GCS::Line>(theEntity2->entity());
 829
 830     aConstrList.push_back(GCSConstraintPtr(
 831         new GCS::ConstraintP2PDistance(aLine1->p1, aLine1->p2, theIntermed->scalar())));
 832     aConstrList.push_back(GCSConstraintPtr(
 833         new GCS::ConstraintP2PDistance(aLine2->p1, aLine2->p2, theIntermed->scalar())));
 834     // update value of intermediate parameter
 835     theIntermed->setValue(PlaneGCSSolver_Tools::distance(aLine1->p1, aLine1->p2));
 836   }
 837   else if (theType == CONSTRAINT_EQUAL_ELLIPSES) {
 838     std::shared_ptr<GCS::Ellipse> anEllipse1 =
 839         std::dynamic_pointer_cast<GCS::Ellipse>(theEntity1->entity());
 840     std::shared_ptr<GCS::Ellipse> anEllipse2 =
 841         std::dynamic_pointer_cast<GCS::Ellipse>(theEntity2->entity());
 842
 843     aConstrList.push_back(GCSConstraintPtr(
 844         new GCS::ConstraintEqual(anEllipse1->radmin, anEllipse2->radmin)));
 845     aConstrList.push_back(GCSConstraintPtr(new GCS::ConstraintP2PDistance(
 846         anEllipse1->center, anEllipse1->focus1, theIntermed->scalar())));
 847     aConstrList.push_back(GCSConstraintPtr(new GCS::ConstraintP2PDistance(
 848         anEllipse2->center, anEllipse2->focus1, theIntermed->scalar())));
 849     // update value of intermediate parameter
 850     theIntermed->setValue(PlaneGCSSolver_Tools::distance(anEllipse1->center, anEllipse1->focus1));
 851   }
 852   else {
 853     std::shared_ptr<GCS::Circle> aCirc1 =
 854         std::dynamic_pointer_cast<GCS::Circle>(theEntity1->entity());
 855     std::shared_ptr<GCS::Circle> aCirc2 =
 856         std::dynamic_pointer_cast<GCS::Circle>(theEntity2->entity());
 857     aConstrList.push_back(GCSConstraintPtr(new GCS::ConstraintEqual(aCirc1->rad, aCirc2->rad)));
 858   }
 859
 860   std::shared_ptr<PlaneGCSSolver_ConstraintWrapper> aResult(
 861       new PlaneGCSSolver_ConstraintWrapper(aConstrList, theType));
 862   if (theIntermed)
 863     aResult->setValueParameter(theIntermed);
 864   return aResult;
 865 }
 866
 867 GCS::SET_pD scalarParameters(const ScalarWrapperPtr& theScalar)
 868 {
 869   GCS::SET_pD aParams;
 870   aParams.insert(theScalar->scalar());
 871   return aParams;
 872 }
 873
 874 GCS::SET_pD scalarArrayParameters(const EntityWrapperPtr& theArray)
 875 {
 876   ScalarArrayWrapperPtr anArray =
 877       std::dynamic_pointer_cast<PlaneGCSSolver_ScalarArrayWrapper>(theArray);
 878   return GCS::SET_pD(anArray->array().begin(), anArray->array().end());
 879 }
 880
 881 GCS::SET_pD pointParameters(const PointWrapperPtr& thePoint)
 882 {
 883   GCS::SET_pD aParams;
 884   aParams.insert(thePoint->point()->x);
 885   aParams.insert(thePoint->point()->y);
 886   return aParams;
 887 }
 888
 889 GCS::SET_pD pointArrayParameters(const EntityWrapperPtr& theArray)
 890 {
 891   GCS::SET_pD aParams;
 892   PointArrayWrapperPtr aPoints =
 893       std::dynamic_pointer_cast<PlaneGCSSolver_PointArrayWrapper>(theArray);
 894   for (std::vector<PointWrapperPtr>::const_iterator anIt = aPoints->array().begin();
 895        anIt != aPoints->array().end(); ++anIt) {
 896     GCS::SET_pD aPointParams = PlaneGCSSolver_Tools::parameters(*anIt);
 897     aParams.insert(aPointParams.begin(), aPointParams.end());
 898   }
 899   return aParams;
 900 }
 901
 902 GCS::SET_pD lineParameters(const EdgeWrapperPtr& theLine)
 903 {
 904   GCS::SET_pD aParams;
 905   std::shared_ptr<GCS::Line> aLine = std::dynamic_pointer_cast<GCS::Line>(theLine->entity());
 906   aParams.insert(aLine->p1.x);
 907   aParams.insert(aLine->p1.y);
 908   aParams.insert(aLine->p2.x);
 909   aParams.insert(aLine->p2.y);
 910   return aParams;
 911 }
 912
 913 GCS::SET_pD circleParameters(const EdgeWrapperPtr& theCircle)
 914 {
 915   GCS::SET_pD aParams;
 916   std::shared_ptr<GCS::Circle> aCirc = std::dynamic_pointer_cast<GCS::Circle>(theCircle->entity());
 917   aParams.insert(aCirc->center.x);
 918   aParams.insert(aCirc->center.y);
 919   aParams.insert(aCirc->rad);
 920   return aParams;
 921 }
 922
 923 GCS::SET_pD arcParameters(const EdgeWrapperPtr& theArc)
 924 {
 925   GCS::SET_pD aParams = circleParameters(theArc);
 926   std::shared_ptr<GCS::Arc> anArc = std::dynamic_pointer_cast<GCS::Arc>(theArc->entity());
 927   aParams.insert(anArc->start.x);
 928   aParams.insert(anArc->start.y);
 929   aParams.insert(anArc->end.x);
 930   aParams.insert(anArc->end.y);
 931   aParams.insert(anArc->startAngle);
 932   aParams.insert(anArc->endAngle);
 933   return aParams;
 934 }
 935
 936 GCS::SET_pD ellipseParameters(const EdgeWrapperPtr& theEllipse)
 937 {
 938   GCS::SET_pD aParams;
 939   std::shared_ptr<GCS::Ellipse> anEllipse =
 940       std::dynamic_pointer_cast<GCS::Ellipse>(theEllipse->entity());
 941   aParams.insert(anEllipse->center.x);
 942   aParams.insert(anEllipse->center.y);
 943   aParams.insert(anEllipse->focus1.x);
 944   aParams.insert(anEllipse->focus1.y);
 945   aParams.insert(anEllipse->radmin);
 946   return aParams;
 947 }
 948
 949 GCS::SET_pD ellipticArcParameters(const EdgeWrapperPtr& theEllipticArc)
 950 {
 951   GCS::SET_pD aParams = ellipseParameters(theEllipticArc);
 952   std::shared_ptr<GCS::ArcOfEllipse> anArc =
 953       std::dynamic_pointer_cast<GCS::ArcOfEllipse>(theEllipticArc->entity());
 954   aParams.insert(anArc->start.x);
 955   aParams.insert(anArc->start.y);
 956   aParams.insert(anArc->end.x);
 957   aParams.insert(anArc->end.y);
 958   aParams.insert(anArc->startAngle);
 959   aParams.insert(anArc->endAngle);
 960   return aParams;
 961 }
 962
 963 GCS::SET_pD bsplineParameters(const EdgeWrapperPtr& theEdge)
 964 {
 965   GCS::SET_pD aParams;
 966
 967   std::shared_ptr<GCS::BSpline> aBSpline =
 968     std::dynamic_pointer_cast<GCS::BSpline>(theEdge->entity());
 969
 970   for (GCS::VEC_P::iterator it = aBSpline->poles.begin(); it != aBSpline->poles.end(); ++it) {
 971     aParams.insert(it->x);
 972     aParams.insert(it->y);
 973   }
 974   for (GCS::VEC_pD::iterator it = aBSpline->weights.begin(); it != aBSpline->weights.end(); ++it)
 975     aParams.insert(*it);
 976
 977   return aParams;
 978 }