src/SketchSolver/PlaneGCSSolver/PlaneGCSSolver_Tools.cpp

   1 // Copyright (C) 2014-2017  CEA/DEN, EDF R&D
   2 //
   3 // This library is free software; you can redistribute it and/or
   4 // modify it under the terms of the GNU Lesser General Public
   5 // License as published by the Free Software Foundation; either
   6 // version 2.1 of the License, or (at your option) any later version.
   7 //
   8 // This library is distributed in the hope that it will be useful,
   9 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  10 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  11 // Lesser General Public License for more details.
  12 //
  13 // You should have received a copy of the GNU Lesser General Public
  14 // License along with this library; if not, write to the Free Software
  15 // Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
  16 //
  17 // See http://www.salome-platform.org/ or
  18 // email : webmaster.salome@opencascade.com<mailto:webmaster.salome@opencascade.com>
  19 //
  20
  21 #include <PlaneGCSSolver_Tools.h>
  22 #include <PlaneGCSSolver_EdgeWrapper.h>
  23 #include <PlaneGCSSolver_PointWrapper.h>
  24 #include <PlaneGCSSolver_ScalarWrapper.h>
  25 #include <PlaneGCSSolver_ConstraintWrapper.h>
  26
  27 #include <SketchSolver_Constraint.h>
  28 #include <SketchSolver_ConstraintAngle.h>
  29 #include <SketchSolver_ConstraintCoincidence.h>
  30 #include <SketchSolver_ConstraintCollinear.h>
  31 #include <SketchSolver_ConstraintDistance.h>
  32 #include <SketchSolver_ConstraintEqual.h>
  33 #include <SketchSolver_ConstraintFixed.h>
  34 #include <SketchSolver_ConstraintLength.h>
  35 #include <SketchSolver_ConstraintMiddle.h>
  36 #include <SketchSolver_ConstraintMirror.h>
  37 #include <SketchSolver_ConstraintTangent.h>
  38 #include <SketchSolver_ConstraintMultiRotation.h>
  39 #include <SketchSolver_ConstraintMultiTranslation.h>
  40
  41 #include <SketchPlugin_ConstraintAngle.h>
  42 #include <SketchPlugin_ConstraintCoincidence.h>
  43 #include <SketchPlugin_ConstraintCollinear.h>
  44 #include <SketchPlugin_ConstraintDistance.h>
  45 #include <SketchPlugin_ConstraintDistanceHorizontal.h>
  46 #include <SketchPlugin_ConstraintDistanceVertical.h>
  47 #include <SketchPlugin_ConstraintEqual.h>
  48 #include <SketchPlugin_ConstraintLength.h>
  49 #include <SketchPlugin_ConstraintMiddle.h>
  50 #include <SketchPlugin_ConstraintMirror.h>
  51 #include <SketchPlugin_ConstraintRigid.h>
  52 #include <SketchPlugin_ConstraintTangent.h>
  53 #include <SketchPlugin_Line.h>
  54 #include <SketchPlugin_MultiRotation.h>
  55 #include <SketchPlugin_MultiTranslation.h>
  56
  57 #include <cmath>
  58
  59
  60 #define GCS_EDGE_WRAPPER(x)   std::dynamic_pointer_cast<PlaneGCSSolver_EdgeWrapper>(x)
  61 #define GCS_POINT_WRAPPER(x)  std::dynamic_pointer_cast<PlaneGCSSolver_PointWrapper>(x)
  62 #define GCS_SCALAR_WRAPPER(x) std::dynamic_pointer_cast<PlaneGCSSolver_ScalarWrapper>(x)
  63
  64
  65
  66 static ConstraintWrapperPtr
  67   createConstraintCoincidence(std::shared_ptr<PlaneGCSSolver_PointWrapper> thePoint1,
  68                               std::shared_ptr<PlaneGCSSolver_PointWrapper> thePoint2);
  69 static ConstraintWrapperPtr
  70   createConstraintPointOnEntity(const SketchSolver_ConstraintType& theType,
  71                                 std::shared_ptr<PlaneGCSSolver_PointWrapper> thePoint,
  72                                 std::shared_ptr<PlaneGCSSolver_EdgeWrapper> theEntity);
  73 static ConstraintWrapperPtr
  74   createConstraintDistancePointPoint(std::shared_ptr<PlaneGCSSolver_ScalarWrapper> theValue,
  75                                      std::shared_ptr<PlaneGCSSolver_PointWrapper> thePoint1,
  76                                      std::shared_ptr<PlaneGCSSolver_PointWrapper> thePoint2);
  77 static ConstraintWrapperPtr
  78   createConstraintDistancePointLine(std::shared_ptr<PlaneGCSSolver_ScalarWrapper> theValue,
  79                                     std::shared_ptr<PlaneGCSSolver_PointWrapper>  thePoint,
  80                                     std::shared_ptr<PlaneGCSSolver_EdgeWrapper> theEntity);
  81 static ConstraintWrapperPtr
  82   createConstraintHVDistance(const SketchSolver_ConstraintType& theType,
  83                              std::shared_ptr<PlaneGCSSolver_ScalarWrapper> theValue,
  84                              std::shared_ptr<PlaneGCSSolver_PointWrapper> thePoint1,
  85                              std::shared_ptr<PlaneGCSSolver_PointWrapper> thePoint2);
  86 static ConstraintWrapperPtr
  87   createConstraintRadius(std::shared_ptr<PlaneGCSSolver_ScalarWrapper> theValue,
  88                          std::shared_ptr<PlaneGCSSolver_EdgeWrapper> theEntity);
  89 static ConstraintWrapperPtr
  90   createConstraintAngle(ConstraintPtr theConstraint,
  91                         std::shared_ptr<PlaneGCSSolver_ScalarWrapper> theValue,
  92                         std::shared_ptr<PlaneGCSSolver_EdgeWrapper> theEntity1,
  93                         std::shared_ptr<PlaneGCSSolver_EdgeWrapper> theEntity2);
  94 static ConstraintWrapperPtr
  95   createConstraintHorizVert(const SketchSolver_ConstraintType& theType,
  96                             std::shared_ptr<PlaneGCSSolver_EdgeWrapper> theEntity);
  97 static ConstraintWrapperPtr
  98   createConstraintParallel(std::shared_ptr<PlaneGCSSolver_EdgeWrapper> theEntity1,
  99                            std::shared_ptr<PlaneGCSSolver_EdgeWrapper> theEntity2);
 100 static ConstraintWrapperPtr
 101   createConstraintPerpendicular(std::shared_ptr<PlaneGCSSolver_EdgeWrapper> theEntity1,
 102                                 std::shared_ptr<PlaneGCSSolver_EdgeWrapper> theEntity2);
 103 static ConstraintWrapperPtr
 104   createConstraintEqual(const SketchSolver_ConstraintType& theType,
 105                         std::shared_ptr<PlaneGCSSolver_EdgeWrapper> theEntity1,
 106                         std::shared_ptr<PlaneGCSSolver_EdgeWrapper> theEntity2,
 107                         std::shared_ptr<PlaneGCSSolver_ScalarWrapper> theIntermed);
 108 static ConstraintWrapperPtr
 109   createConstraintMiddlePoint(std::shared_ptr<PlaneGCSSolver_PointWrapper> thePoint,
 110                               std::shared_ptr<PlaneGCSSolver_EdgeWrapper> theEntity);
 111
 112 static GCS::SET_pD scalarParameters(const ScalarWrapperPtr& theScalar);
 113 static GCS::SET_pD pointParameters(const PointWrapperPtr& thePoint);
 114 static GCS::SET_pD lineParameters(const EdgeWrapperPtr& theLine);
 115 static GCS::SET_pD circleParameters(const EdgeWrapperPtr& theCircle);
 116 static GCS::SET_pD arcParameters(const EdgeWrapperPtr& theArc);
 117
 118
 119
 120
 121
 122 SolverConstraintPtr PlaneGCSSolver_Tools::createConstraint(ConstraintPtr theConstraint)
 123 {
 124   if (theConstraint->getKind() == SketchPlugin_ConstraintCoincidence::ID()) {
 125     return SolverConstraintPtr(new SketchSolver_ConstraintCoincidence(theConstraint));
 126   } else if (theConstraint->getKind() == SketchPlugin_ConstraintCollinear::ID()) {
 127     return SolverConstraintPtr(new SketchSolver_ConstraintCollinear(theConstraint));
 128   } else if (theConstraint->getKind() == SketchPlugin_ConstraintDistance::ID() ||
 129              theConstraint->getKind() == SketchPlugin_ConstraintDistanceHorizontal::ID() ||
 130              theConstraint->getKind() == SketchPlugin_ConstraintDistanceVertical::ID()) {
 131     return SolverConstraintPtr(new SketchSolver_ConstraintDistance(theConstraint));
 132   } else if (theConstraint->getKind() == SketchPlugin_ConstraintEqual::ID()) {
 133     return SolverConstraintPtr(new SketchSolver_ConstraintEqual(theConstraint));
 134   } else if (theConstraint->getKind() == SketchPlugin_ConstraintLength::ID()) {
 135     return SolverConstraintPtr(new SketchSolver_ConstraintLength(theConstraint));
 136   } else if (theConstraint->getKind() == SketchPlugin_ConstraintMiddle::ID()) {
 137     return SolverConstraintPtr(new SketchSolver_ConstraintMiddle(theConstraint));
 138   } else if (theConstraint->getKind() == SketchPlugin_ConstraintMirror::ID()) {
 139     return SolverConstraintPtr(new SketchSolver_ConstraintMirror(theConstraint));
 140   } else if (theConstraint->getKind() == SketchPlugin_ConstraintTangent::ID()) {
 141     return SolverConstraintPtr(new SketchSolver_ConstraintTangent(theConstraint));
 142   } else if (theConstraint->getKind() == SketchPlugin_ConstraintRigid::ID()) {
 143     return SolverConstraintPtr(new SketchSolver_ConstraintFixed(theConstraint));
 144   } else if (theConstraint->getKind() == SketchPlugin_MultiTranslation::ID()) {
 145     return SolverConstraintPtr(new SketchSolver_ConstraintMultiTranslation(theConstraint));
 146   } else if (theConstraint->getKind() == SketchPlugin_MultiRotation::ID()) {
 147     return SolverConstraintPtr(new SketchSolver_ConstraintMultiRotation(theConstraint));
 148   } else if (theConstraint->getKind() == SketchPlugin_ConstraintAngle::ID()) {
 149     return SolverConstraintPtr(new SketchSolver_ConstraintAngle(theConstraint));
 150   }
 151   // All other types of constraints
 152   return SolverConstraintPtr(new SketchSolver_Constraint(theConstraint));
 153 }
 154
 155 std::shared_ptr<SketchSolver_ConstraintMovement> PlaneGCSSolver_Tools::createMovementConstraint(
 156     FeaturePtr theMovedFeature)
 157 {
 158   return std::shared_ptr<SketchSolver_ConstraintMovement>(
 159       new SketchSolver_ConstraintMovement(theMovedFeature));
 160 }
 161
 162 std::shared_ptr<SketchSolver_ConstraintMovement> PlaneGCSSolver_Tools::createMovementConstraint(
 163     AttributePtr theMovedAttribute)
 164 {
 165   return std::shared_ptr<SketchSolver_ConstraintMovement>(
 166       new SketchSolver_ConstraintMovement(theMovedAttribute));
 167 }
 168
 169
 170
 171 ConstraintWrapperPtr PlaneGCSSolver_Tools::createConstraint(
 172     ConstraintPtr theConstraint,
 173     const SketchSolver_ConstraintType& theType,
 174     const EntityWrapperPtr& theValue,
 175     const EntityWrapperPtr& thePoint1,
 176     const EntityWrapperPtr& thePoint2,
 177     const EntityWrapperPtr& theEntity1,
 178     const EntityWrapperPtr& theEntity2)
 179 {
 180   ConstraintWrapperPtr aResult;
 181   ScalarWrapperPtr anIntermediate;
 182
 183   std::shared_ptr<PlaneGCSSolver_PointWrapper> aPoint1 = GCS_POINT_WRAPPER(thePoint1);
 184   std::shared_ptr<PlaneGCSSolver_PointWrapper> aPoint2 = GCS_POINT_WRAPPER(thePoint2);
 185
 186   switch (theType) {
 187   case CONSTRAINT_PT_PT_COINCIDENT:
 188     aResult = createConstraintCoincidence(aPoint1, aPoint2);
 189     break;
 190   case CONSTRAINT_PT_ON_LINE:
 191   case CONSTRAINT_PT_ON_CIRCLE:
 192     aResult = createConstraintPointOnEntity(theType, aPoint1, GCS_EDGE_WRAPPER(theEntity1));
 193     break;
 194   case CONSTRAINT_MIDDLE_POINT:
 195     aResult = createConstraintMiddlePoint(aPoint1, GCS_EDGE_WRAPPER(theEntity1));
 196     break;
 197   case CONSTRAINT_PT_PT_DISTANCE:
 198     aResult = createConstraintDistancePointPoint(GCS_SCALAR_WRAPPER(theValue), aPoint1, aPoint2);
 199     break;
 200   case CONSTRAINT_PT_LINE_DISTANCE:
 201     aResult = createConstraintDistancePointLine(GCS_SCALAR_WRAPPER(theValue),
 202                                                 aPoint1,
 203                                                 GCS_EDGE_WRAPPER(theEntity1));
 204     break;
 205   case CONSTRAINT_HORIZONTAL_DISTANCE:
 206   case CONSTRAINT_VERTICAL_DISTANCE:
 207     aResult = createConstraintHVDistance(theType, GCS_SCALAR_WRAPPER(theValue), aPoint1, aPoint2);
 208     break;
 209   case CONSTRAINT_RADIUS:
 210     aResult = createConstraintRadius(GCS_SCALAR_WRAPPER(theValue),
 211                                      GCS_EDGE_WRAPPER(theEntity1));
 212     break;
 213   case CONSTRAINT_ANGLE:
 214     aResult = createConstraintAngle(theConstraint,
 215                   GCS_SCALAR_WRAPPER(theValue),
 216                   GCS_EDGE_WRAPPER(theEntity1), GCS_EDGE_WRAPPER(theEntity2));
 217     break;
 218   case CONSTRAINT_FIXED:
 219     break;
 220   case CONSTRAINT_HORIZONTAL:
 221   case CONSTRAINT_VERTICAL:
 222     aResult = createConstraintHorizVert(theType, GCS_EDGE_WRAPPER(theEntity1));
 223     break;
 224   case CONSTRAINT_PARALLEL:
 225     aResult = createConstraintParallel(GCS_EDGE_WRAPPER(theEntity1),
 226                                        GCS_EDGE_WRAPPER(theEntity2));
 227     break;
 228   case CONSTRAINT_PERPENDICULAR:
 229     aResult = createConstraintPerpendicular(GCS_EDGE_WRAPPER(theEntity1),
 230                                             GCS_EDGE_WRAPPER(theEntity2));
 231     break;
 232   case CONSTRAINT_EQUAL_LINES:
 233     anIntermediate = GCS_SCALAR_WRAPPER(theValue); // parameter is used to store length of lines
 234   case CONSTRAINT_EQUAL_LINE_ARC:
 235   case CONSTRAINT_EQUAL_RADIUS:
 236     aResult = createConstraintEqual(theType,
 237                                     GCS_EDGE_WRAPPER(theEntity1),
 238                                     GCS_EDGE_WRAPPER(theEntity2),
 239                                     anIntermediate);
 240     break;
 241   default:
 242     break;
 243   }
 244
 245   return aResult;
 246 }
 247
 248 std::shared_ptr<GeomAPI_Pnt2d> PlaneGCSSolver_Tools::point(EntityWrapperPtr theEntity)
 249 {
 250   if (theEntity->type() != ENTITY_POINT)
 251     return std::shared_ptr<GeomAPI_Pnt2d>();
 252
 253   std::shared_ptr<PlaneGCSSolver_PointWrapper> aPointWrapper =
 254       std::dynamic_pointer_cast<PlaneGCSSolver_PointWrapper>(theEntity);
 255   const GCSPointPtr& aPoint = aPointWrapper->point();
 256   return std::shared_ptr<GeomAPI_Pnt2d>(new GeomAPI_Pnt2d(*aPoint->x, *aPoint->y));
 257 }
 258
 259 std::shared_ptr<GeomAPI_Lin2d> PlaneGCSSolver_Tools::line(EntityWrapperPtr theEntity)
 260 {
 261   if (theEntity->type() != ENTITY_LINE)
 262     return std::shared_ptr<GeomAPI_Lin2d>();
 263
 264   std::shared_ptr<PlaneGCSSolver_EdgeWrapper> anEntity =
 265       std::dynamic_pointer_cast<PlaneGCSSolver_EdgeWrapper>(theEntity);
 266   std::shared_ptr<GCS::Line> aLine = std::dynamic_pointer_cast<GCS::Line>(anEntity->entity());
 267   return std::shared_ptr<GeomAPI_Lin2d>(
 268       new GeomAPI_Lin2d(*(aLine->p1.x), *(aLine->p1.y), *(aLine->p2.x), *(aLine->p2.y)));
 269 }
 270
 271 std::shared_ptr<GeomAPI_Lin2d> PlaneGCSSolver_Tools::line(FeaturePtr theFeature)
 272 {
 273   if (theFeature->getKind() != SketchPlugin_Line::ID())
 274     return std::shared_ptr<GeomAPI_Lin2d>();
 275
 276   AttributePoint2DPtr aStart = std::dynamic_pointer_cast<GeomDataAPI_Point2D>(
 277       theFeature->attribute(SketchPlugin_Line::START_ID()));
 278   AttributePoint2DPtr aEnd = std::dynamic_pointer_cast<GeomDataAPI_Point2D>(
 279       theFeature->attribute(SketchPlugin_Line::END_ID()));
 280
 281   return std::shared_ptr<GeomAPI_Lin2d>(new GeomAPI_Lin2d(aStart->pnt(), aEnd->pnt()));
 282 }
 283
 284
 285 GCS::SET_pD PlaneGCSSolver_Tools::parameters(const EntityWrapperPtr& theEntity)
 286 {
 287   switch (theEntity->type()) {
 288   case ENTITY_SCALAR:
 289   case ENTITY_ANGLE:
 290     return scalarParameters(GCS_SCALAR_WRAPPER(theEntity));
 291   case ENTITY_POINT:
 292     return pointParameters(GCS_POINT_WRAPPER(theEntity));
 293   case ENTITY_LINE:
 294     return lineParameters(GCS_EDGE_WRAPPER(theEntity));
 295   case ENTITY_CIRCLE:
 296     return circleParameters(GCS_EDGE_WRAPPER(theEntity));
 297   case ENTITY_ARC:
 298     return arcParameters(GCS_EDGE_WRAPPER(theEntity));
 299   default: break;
 300   }
 301   return GCS::SET_pD();
 302 }
 303
 304
 305
 306
 307
 308
 309 // ================   Auxiliary functions   ==========================
 310 ConstraintWrapperPtr createConstraintCoincidence(
 311     std::shared_ptr<PlaneGCSSolver_PointWrapper> thePoint1,
 312     std::shared_ptr<PlaneGCSSolver_PointWrapper> thePoint2)
 313 {
 314   GCSPointPtr aPoint1 = thePoint1->point();
 315   GCSPointPtr aPoint2 = thePoint2->point();
 316
 317   // Create equality constraint for corresponding attributes of the points
 318   std::list<GCSConstraintPtr> aConstrList;
 319   aConstrList.push_back(
 320       GCSConstraintPtr(new GCS::ConstraintEqual(aPoint1->x, aPoint2->x)));
 321   aConstrList.push_back(
 322       GCSConstraintPtr(new GCS::ConstraintEqual(aPoint1->y, aPoint2->y)));
 323
 324   return ConstraintWrapperPtr(new PlaneGCSSolver_ConstraintWrapper(
 325       aConstrList, CONSTRAINT_PT_PT_COINCIDENT));
 326 }
 327
 328 ConstraintWrapperPtr createConstraintPointOnEntity(
 329     const SketchSolver_ConstraintType& theType,
 330     std::shared_ptr<PlaneGCSSolver_PointWrapper> thePoint,
 331     std::shared_ptr<PlaneGCSSolver_EdgeWrapper> theEntity)
 332 {
 333   GCSConstraintPtr aNewConstr;
 334
 335   switch (theEntity->type()) {
 336   case ENTITY_LINE: {
 337     std::shared_ptr<GCS::Line> aLine = std::dynamic_pointer_cast<GCS::Line>(theEntity->entity());
 338     aNewConstr = GCSConstraintPtr(new GCS::ConstraintPointOnLine(*(thePoint->point()), *aLine));
 339     break;
 340     }
 341   case ENTITY_ARC:
 342   case ENTITY_CIRCLE: {
 343     std::shared_ptr<GCS::Circle> aCirc =
 344       std::dynamic_pointer_cast<GCS::Circle>(theEntity->entity());
 345     aNewConstr = GCSConstraintPtr(
 346         new GCS::ConstraintP2PDistance(*(thePoint->point()), aCirc->center, aCirc->rad));
 347     break;
 348     }
 349   default:
 350     return ConstraintWrapperPtr();
 351   }
 352
 353   return ConstraintWrapperPtr(new PlaneGCSSolver_ConstraintWrapper(aNewConstr, theType));
 354 }
 355
 356 ConstraintWrapperPtr createConstraintMiddlePoint(
 357     std::shared_ptr<PlaneGCSSolver_PointWrapper> thePoint,
 358     std::shared_ptr<PlaneGCSSolver_EdgeWrapper> theEntity)
 359 {
 360   GCSPointPtr aPoint = thePoint->point();
 361   std::shared_ptr<GCS::Line> aLine = std::dynamic_pointer_cast<GCS::Line>(theEntity->entity());
 362   if (!aLine)
 363     return ConstraintWrapperPtr();
 364
 365   std::list<GCSConstraintPtr> aConstrList;
 366   aConstrList.push_back(
 367       GCSConstraintPtr(new GCS::ConstraintPointOnPerpBisector(*aPoint, aLine->p1, aLine->p2)));
 368   aConstrList.push_back(GCSConstraintPtr(new GCS::ConstraintPointOnLine(*aPoint, *aLine)));
 369
 370   return ConstraintWrapperPtr(
 371       new PlaneGCSSolver_ConstraintWrapper(aConstrList, CONSTRAINT_MIDDLE_POINT));
 372 }
 373
 374
 375 ConstraintWrapperPtr createConstraintDistancePointPoint(
 376     std::shared_ptr<PlaneGCSSolver_ScalarWrapper> theValue,
 377     std::shared_ptr<PlaneGCSSolver_PointWrapper>  thePoint1,
 378     std::shared_ptr<PlaneGCSSolver_PointWrapper>  thePoint2)
 379 {
 380   GCSConstraintPtr aNewConstr(new GCS::ConstraintP2PDistance(
 381       *(thePoint1->point()), *(thePoint2->point()), theValue->scalar()));
 382   std::shared_ptr<PlaneGCSSolver_ConstraintWrapper> aResult(
 383       new PlaneGCSSolver_ConstraintWrapper(aNewConstr, CONSTRAINT_PT_PT_DISTANCE));
 384   aResult->setValueParameter(theValue);
 385   return aResult;
 386 }
 387
 388 ConstraintWrapperPtr createConstraintDistancePointLine(
 389     std::shared_ptr<PlaneGCSSolver_ScalarWrapper> theValue,
 390     std::shared_ptr<PlaneGCSSolver_PointWrapper>  thePoint,
 391     std::shared_ptr<PlaneGCSSolver_EdgeWrapper> theEntity)
 392 {
 393   std::shared_ptr<GCS::Line> aLine = std::dynamic_pointer_cast<GCS::Line>(theEntity->entity());
 394   GCSConstraintPtr aNewConstr(new GCS::ConstraintP2LDistance(
 395       *(thePoint->point()), *(aLine), theValue->scalar()));
 396   std::shared_ptr<PlaneGCSSolver_ConstraintWrapper> aResult(
 397       new PlaneGCSSolver_ConstraintWrapper(aNewConstr, CONSTRAINT_PT_LINE_DISTANCE));
 398   aResult->setValueParameter(theValue);
 399   return aResult;
 400 }
 401
 402 ConstraintWrapperPtr createConstraintHVDistance(
 403     const SketchSolver_ConstraintType& theType,
 404     std::shared_ptr<PlaneGCSSolver_ScalarWrapper> theValue,
 405     std::shared_ptr<PlaneGCSSolver_PointWrapper> thePoint1,
 406     std::shared_ptr<PlaneGCSSolver_PointWrapper> thePoint2)
 407 {
 408   GCSPointPtr aPoint1 = thePoint1->point();
 409   GCSPointPtr aPoint2 = thePoint2->point();
 410
 411   double *aParam1, *aParam2;
 412   if (theType == CONSTRAINT_HORIZONTAL_DISTANCE) {
 413     aParam1 = aPoint1->x;
 414     aParam2 = aPoint2->x;
 415   } else if (theType == CONSTRAINT_VERTICAL_DISTANCE) {
 416     aParam1 = aPoint1->y;
 417     aParam2 = aPoint2->y;
 418   }
 419
 420   GCSConstraintPtr aNewConstr(new GCS::ConstraintDifference(aParam1, aParam2, theValue->scalar()));
 421
 422   std::shared_ptr<PlaneGCSSolver_ConstraintWrapper> aResult(
 423       new PlaneGCSSolver_ConstraintWrapper(aNewConstr, theType));
 424   aResult->setValueParameter(theValue);
 425   return aResult;
 426 }
 427
 428 ConstraintWrapperPtr createConstraintRadius(
 429     std::shared_ptr<PlaneGCSSolver_ScalarWrapper> theValue,
 430     std::shared_ptr<PlaneGCSSolver_EdgeWrapper> theEntity)
 431 {
 432   std::shared_ptr<GCS::Circle> aCircle =
 433     std::dynamic_pointer_cast<GCS::Circle>(theEntity->entity());
 434   GCSConstraintPtr aNewConstr(new GCS::ConstraintEqual(aCircle->rad, theValue->scalar()));
 435   std::shared_ptr<PlaneGCSSolver_ConstraintWrapper> aResult(
 436       new PlaneGCSSolver_ConstraintWrapper(aNewConstr, CONSTRAINT_RADIUS));
 437   aResult->setValueParameter(theValue);
 438   return aResult;
 439 }
 440
 441 ConstraintWrapperPtr createConstraintAngle(
 442     ConstraintPtr theConstraint,
 443     std::shared_ptr<PlaneGCSSolver_ScalarWrapper> theValue,
 444     std::shared_ptr<PlaneGCSSolver_EdgeWrapper> theEntity1,
 445     std::shared_ptr<PlaneGCSSolver_EdgeWrapper> theEntity2)
 446 {
 447   std::shared_ptr<GCS::Line> aLine1 = std::dynamic_pointer_cast<GCS::Line>(theEntity1->entity());
 448   bool isLine1Rev = theConstraint->boolean(
 449       SketchPlugin_ConstraintAngle::ANGLE_REVERSED_FIRST_LINE_ID())->value();
 450   GCS::Point aLine1Pt1 = isLine1Rev ? aLine1->p2 : aLine1->p1;
 451   GCS::Point aLine1Pt2 = isLine1Rev ? aLine1->p1 : aLine1->p2;
 452
 453   std::shared_ptr<GCS::Line> aLine2 = std::dynamic_pointer_cast<GCS::Line>(theEntity2->entity());
 454   bool isLine2Rev = theConstraint->boolean(
 455       SketchPlugin_ConstraintAngle::ANGLE_REVERSED_SECOND_LINE_ID())->value();
 456   GCS::Point aLine2Pt1 = isLine2Rev ? aLine2->p2 : aLine2->p1;
 457   GCS::Point aLine2Pt2 = isLine2Rev ? aLine2->p1 : aLine2->p2;
 458
 459   GCSConstraintPtr aNewConstr(new GCS::ConstraintL2LAngle(
 460       aLine1Pt1, aLine1Pt2, aLine2Pt1, aLine2Pt2, theValue->scalar()));
 461
 462   std::shared_ptr<PlaneGCSSolver_ConstraintWrapper> aResult(
 463       new PlaneGCSSolver_ConstraintWrapper(aNewConstr, CONSTRAINT_ANGLE));
 464   aResult->setValueParameter(theValue);
 465   return aResult;
 466 }
 467
 468 ConstraintWrapperPtr createConstraintHorizVert(
 469     const SketchSolver_ConstraintType& theType,
 470     std::shared_ptr<PlaneGCSSolver_EdgeWrapper> theEntity)
 471 {
 472   std::shared_ptr<GCS::Line> aLine = std::dynamic_pointer_cast<GCS::Line>(theEntity->entity());
 473   GCSConstraintPtr aNewConstr;
 474   if (theType == CONSTRAINT_HORIZONTAL)
 475     aNewConstr = GCSConstraintPtr(new GCS::ConstraintEqual(aLine->p1.y, aLine->p2.y));
 476   else
 477     aNewConstr = GCSConstraintPtr(new GCS::ConstraintEqual(aLine->p1.x, aLine->p2.x));
 478
 479   return ConstraintWrapperPtr(new PlaneGCSSolver_ConstraintWrapper(aNewConstr, theType));
 480 }
 481
 482 ConstraintWrapperPtr createConstraintParallel(
 483     std::shared_ptr<PlaneGCSSolver_EdgeWrapper> theEntity1,
 484     std::shared_ptr<PlaneGCSSolver_EdgeWrapper> theEntity2)
 485 {
 486   std::shared_ptr<GCS::Line> aLine1 = std::dynamic_pointer_cast<GCS::Line>(theEntity1->entity());
 487   std::shared_ptr<GCS::Line> aLine2 = std::dynamic_pointer_cast<GCS::Line>(theEntity2->entity());
 488   GCSConstraintPtr aNewConstr(new GCS::ConstraintParallel(*(aLine1), *(aLine2)));
 489
 490   return ConstraintWrapperPtr(
 491       new PlaneGCSSolver_ConstraintWrapper(aNewConstr, CONSTRAINT_PARALLEL));
 492 }
 493
 494 ConstraintWrapperPtr createConstraintPerpendicular(
 495     std::shared_ptr<PlaneGCSSolver_EdgeWrapper> theEntity1,
 496     std::shared_ptr<PlaneGCSSolver_EdgeWrapper> theEntity2)
 497 {
 498   std::shared_ptr<GCS::Line> aLine1 = std::dynamic_pointer_cast<GCS::Line>(theEntity1->entity());
 499   std::shared_ptr<GCS::Line> aLine2 = std::dynamic_pointer_cast<GCS::Line>(theEntity2->entity());
 500   GCSConstraintPtr aNewConstr(new GCS::ConstraintPerpendicular(*(aLine1), *(aLine2)));
 501
 502   return ConstraintWrapperPtr(
 503       new PlaneGCSSolver_ConstraintWrapper(aNewConstr, CONSTRAINT_PERPENDICULAR));
 504 }
 505
 506 ConstraintWrapperPtr createConstraintEqual(
 507     const SketchSolver_ConstraintType& theType,
 508     std::shared_ptr<PlaneGCSSolver_EdgeWrapper> theEntity1,
 509     std::shared_ptr<PlaneGCSSolver_EdgeWrapper> theEntity2,
 510     std::shared_ptr<PlaneGCSSolver_ScalarWrapper> theIntermed)
 511 {
 512   if (theType == CONSTRAINT_EQUAL_LINE_ARC)
 513     return ConstraintWrapperPtr(); // line-arc equivalence is not supported yet
 514
 515   std::list<GCSConstraintPtr> aConstrList;
 516   if (theType == CONSTRAINT_EQUAL_LINES) {
 517     std::shared_ptr<GCS::Line> aLine1 = std::dynamic_pointer_cast<GCS::Line>(theEntity1->entity());
 518     std::shared_ptr<GCS::Line> aLine2 = std::dynamic_pointer_cast<GCS::Line>(theEntity2->entity());
 519
 520     aConstrList.push_back(GCSConstraintPtr(
 521         new GCS::ConstraintP2PDistance(aLine1->p1, aLine1->p2, theIntermed->scalar())));
 522     aConstrList.push_back(GCSConstraintPtr(
 523         new GCS::ConstraintP2PDistance(aLine2->p1, aLine2->p2, theIntermed->scalar())));
 524     // update value of intermediate parameter
 525     double x = *aLine1->p1.x - *aLine1->p2.x;
 526     double y = *aLine1->p1.y - *aLine1->p2.y;
 527     double aLen = sqrt(x*x + y*y);
 528     theIntermed->setValue(aLen);
 529   } else {
 530     std::shared_ptr<GCS::Circle> aCirc1 =
 531         std::dynamic_pointer_cast<GCS::Circle>(theEntity1->entity());
 532     std::shared_ptr<GCS::Circle> aCirc2 =
 533         std::dynamic_pointer_cast<GCS::Circle>(theEntity2->entity());
 534
 535     aConstrList.push_back(GCSConstraintPtr(new GCS::ConstraintEqual(aCirc1->rad, aCirc2->rad)));
 536   }
 537
 538   std::shared_ptr<PlaneGCSSolver_ConstraintWrapper> aResult(
 539       new PlaneGCSSolver_ConstraintWrapper(aConstrList, theType));
 540   if (theIntermed)
 541     aResult->setValueParameter(theIntermed);
 542   return aResult;
 543 }
 544
 545 GCS::SET_pD scalarParameters(const ScalarWrapperPtr& theScalar)
 546 {
 547   GCS::SET_pD aParams;
 548   aParams.insert(theScalar->scalar());
 549   return aParams;
 550 }
 551
 552 GCS::SET_pD pointParameters(const PointWrapperPtr& thePoint)
 553 {
 554   GCS::SET_pD aParams;
 555   aParams.insert(thePoint->point()->x);
 556   aParams.insert(thePoint->point()->y);
 557   return aParams;
 558 }
 559
 560 GCS::SET_pD lineParameters(const EdgeWrapperPtr& theLine)
 561 {
 562   GCS::SET_pD aParams;
 563   std::shared_ptr<GCS::Line> aLine = std::dynamic_pointer_cast<GCS::Line>(theLine->entity());
 564   aParams.insert(aLine->p1.x);
 565   aParams.insert(aLine->p1.y);
 566   aParams.insert(aLine->p2.x);
 567   aParams.insert(aLine->p2.y);
 568   return aParams;
 569 }
 570
 571 GCS::SET_pD circleParameters(const EdgeWrapperPtr& theCircle)
 572 {
 573   GCS::SET_pD aParams;
 574   std::shared_ptr<GCS::Circle> aCirc = std::dynamic_pointer_cast<GCS::Circle>(theCircle->entity());
 575   aParams.insert(aCirc->center.x);
 576   aParams.insert(aCirc->center.y);
 577   aParams.insert(aCirc->rad);
 578   return aParams;
 579 }
 580
 581 GCS::SET_pD arcParameters(const EdgeWrapperPtr& theArc)
 582 {
 583   GCS::SET_pD aParams;
 584   std::shared_ptr<GCS::Arc> anArc = std::dynamic_pointer_cast<GCS::Arc>(theArc->entity());
 585   aParams.insert(anArc->center.x);
 586   aParams.insert(anArc->center.y);
 587   aParams.insert(anArc->start.x);
 588   aParams.insert(anArc->start.y);
 589   aParams.insert(anArc->end.x);
 590   aParams.insert(anArc->end.y);
 591   aParams.insert(anArc->startAngle);
 592   aParams.insert(anArc->endAngle);
 593   aParams.insert(anArc->rad);
 594   return aParams;
 595 }