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