src/SketchSolver/PlaneGCSSolver/PlaneGCSSolver_Tools.cpp

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