]> SALOME platform Git repositories - modules/shaper.git/blob - src/SketchSolver/PlaneGCSSolver/PlaneGCSSolver_Tools.cpp
Salome HOME
Task 2.4. Ability to modify the radius of circles and arcs of circle with the mouse
[modules/shaper.git] / src / SketchSolver / PlaneGCSSolver / PlaneGCSSolver_Tools.cpp
1 // Copyright (C) 2014-20xx CEA/DEN, EDF R&D
2
3 // File:    SketchSolver_Builder.cpp
4 // Created: 25 Mar 2015
5 // Author:  Artem ZHIDKOV
6
7 #include <PlaneGCSSolver_Tools.h>
8 #include <PlaneGCSSolver_EdgeWrapper.h>
9 #include <PlaneGCSSolver_PointWrapper.h>
10 #include <PlaneGCSSolver_ScalarWrapper.h>
11 #include <PlaneGCSSolver_ConstraintWrapper.h>
12
13 #include <SketchSolver_Constraint.h>
14 #include <SketchSolver_ConstraintAngle.h>
15 #include <SketchSolver_ConstraintCoincidence.h>
16 #include <SketchSolver_ConstraintCollinear.h>
17 #include <SketchSolver_ConstraintDistance.h>
18 #include <SketchSolver_ConstraintEqual.h>
19 #include <SketchSolver_ConstraintFixed.h>
20 #include <SketchSolver_ConstraintLength.h>
21 #include <SketchSolver_ConstraintMiddle.h>
22 #include <SketchSolver_ConstraintMirror.h>
23 #include <SketchSolver_ConstraintTangent.h>
24 #include <SketchSolver_ConstraintMultiRotation.h>
25 #include <SketchSolver_ConstraintMultiTranslation.h>
26
27 #include <SketchPlugin_ConstraintAngle.h>
28 #include <SketchPlugin_ConstraintCoincidence.h>
29 #include <SketchPlugin_ConstraintCollinear.h>
30 #include <SketchPlugin_ConstraintDistance.h>
31 #include <SketchPlugin_ConstraintEqual.h>
32 #include <SketchPlugin_ConstraintLength.h>
33 #include <SketchPlugin_ConstraintMiddle.h>
34 #include <SketchPlugin_ConstraintMirror.h>
35 #include <SketchPlugin_ConstraintRigid.h>
36 #include <SketchPlugin_ConstraintTangent.h>
37 #include <SketchPlugin_Line.h>
38 #include <SketchPlugin_MultiRotation.h>
39 #include <SketchPlugin_MultiTranslation.h>
40
41 #include <cmath>
42
43
44 #define GCS_EDGE_WRAPPER(x)   std::dynamic_pointer_cast<PlaneGCSSolver_EdgeWrapper>(x)
45 #define GCS_POINT_WRAPPER(x)  std::dynamic_pointer_cast<PlaneGCSSolver_PointWrapper>(x)
46 #define GCS_SCALAR_WRAPPER(x) std::dynamic_pointer_cast<PlaneGCSSolver_ScalarWrapper>(x)
47
48
49
50 static ConstraintWrapperPtr
51   createConstraintCoincidence(std::shared_ptr<PlaneGCSSolver_PointWrapper> thePoint1,
52                               std::shared_ptr<PlaneGCSSolver_PointWrapper> thePoint2);
53 static ConstraintWrapperPtr
54   createConstraintPointOnEntity(const SketchSolver_ConstraintType& theType,
55                                 std::shared_ptr<PlaneGCSSolver_PointWrapper> thePoint,
56                                 std::shared_ptr<PlaneGCSSolver_EdgeWrapper> theEntity);
57 static ConstraintWrapperPtr
58   createConstraintDistancePointPoint(std::shared_ptr<PlaneGCSSolver_ScalarWrapper> theValue,
59                                      std::shared_ptr<PlaneGCSSolver_PointWrapper> thePoint1,
60                                      std::shared_ptr<PlaneGCSSolver_PointWrapper> thePoint2);
61 static ConstraintWrapperPtr
62   createConstraintDistancePointLine(std::shared_ptr<PlaneGCSSolver_ScalarWrapper> theValue,
63                                     std::shared_ptr<PlaneGCSSolver_PointWrapper>  thePoint,
64                                     std::shared_ptr<PlaneGCSSolver_EdgeWrapper> theEntity);
65 static ConstraintWrapperPtr
66   createConstraintRadius(std::shared_ptr<PlaneGCSSolver_ScalarWrapper> theValue,
67                          std::shared_ptr<PlaneGCSSolver_EdgeWrapper> theEntity);
68 static ConstraintWrapperPtr
69   createConstraintAngle(ConstraintPtr theConstraint,
70                         std::shared_ptr<PlaneGCSSolver_ScalarWrapper> theValue,
71                         std::shared_ptr<PlaneGCSSolver_EdgeWrapper> theEntity1,
72                         std::shared_ptr<PlaneGCSSolver_EdgeWrapper> theEntity2);
73 static ConstraintWrapperPtr
74   createConstraintHorizVert(const SketchSolver_ConstraintType& theType,
75                             std::shared_ptr<PlaneGCSSolver_EdgeWrapper> theEntity);
76 static ConstraintWrapperPtr
77   createConstraintParallel(std::shared_ptr<PlaneGCSSolver_EdgeWrapper> theEntity1,
78                            std::shared_ptr<PlaneGCSSolver_EdgeWrapper> theEntity2);
79 static ConstraintWrapperPtr
80   createConstraintPerpendicular(std::shared_ptr<PlaneGCSSolver_EdgeWrapper> theEntity1,
81                                 std::shared_ptr<PlaneGCSSolver_EdgeWrapper> theEntity2);
82 static ConstraintWrapperPtr
83   createConstraintEqual(const SketchSolver_ConstraintType& theType,
84                         std::shared_ptr<PlaneGCSSolver_EdgeWrapper> theEntity1,
85                         std::shared_ptr<PlaneGCSSolver_EdgeWrapper> theEntity2,
86                         std::shared_ptr<PlaneGCSSolver_ScalarWrapper> theIntermed);
87 static ConstraintWrapperPtr
88   createConstraintMiddlePoint(std::shared_ptr<PlaneGCSSolver_PointWrapper> thePoint,
89                               std::shared_ptr<PlaneGCSSolver_EdgeWrapper> theEntity);
90
91
92
93
94
95 SolverConstraintPtr PlaneGCSSolver_Tools::createConstraint(ConstraintPtr theConstraint)
96 {
97   if (theConstraint->getKind() == SketchPlugin_ConstraintCoincidence::ID()) {
98     return SolverConstraintPtr(new SketchSolver_ConstraintCoincidence(theConstraint));
99   } else if (theConstraint->getKind() == SketchPlugin_ConstraintCollinear::ID()) {
100     return SolverConstraintPtr(new SketchSolver_ConstraintCollinear(theConstraint));
101   } else if (theConstraint->getKind() == SketchPlugin_ConstraintDistance::ID()) {
102     return SolverConstraintPtr(new SketchSolver_ConstraintDistance(theConstraint));
103   } else if (theConstraint->getKind() == SketchPlugin_ConstraintEqual::ID()) {
104     return SolverConstraintPtr(new SketchSolver_ConstraintEqual(theConstraint));
105   } else if (theConstraint->getKind() == SketchPlugin_ConstraintLength::ID()) {
106     return SolverConstraintPtr(new SketchSolver_ConstraintLength(theConstraint));
107   } else if (theConstraint->getKind() == SketchPlugin_ConstraintMiddle::ID()) {
108     return SolverConstraintPtr(new SketchSolver_ConstraintMiddle(theConstraint));
109   } else if (theConstraint->getKind() == SketchPlugin_ConstraintMirror::ID()) {
110     return SolverConstraintPtr(new SketchSolver_ConstraintMirror(theConstraint));
111   } else if (theConstraint->getKind() == SketchPlugin_ConstraintTangent::ID()) {
112     return SolverConstraintPtr(new SketchSolver_ConstraintTangent(theConstraint));
113   } else if (theConstraint->getKind() == SketchPlugin_ConstraintRigid::ID()) {
114     return SolverConstraintPtr(new SketchSolver_ConstraintFixed(theConstraint));
115   } else if (theConstraint->getKind() == SketchPlugin_MultiTranslation::ID()) {
116     return SolverConstraintPtr(new SketchSolver_ConstraintMultiTranslation(theConstraint));
117   } else if (theConstraint->getKind() == SketchPlugin_MultiRotation::ID()) {
118     return SolverConstraintPtr(new SketchSolver_ConstraintMultiRotation(theConstraint));
119   } else if (theConstraint->getKind() == SketchPlugin_ConstraintAngle::ID()) {
120     return SolverConstraintPtr(new SketchSolver_ConstraintAngle(theConstraint));
121   }
122   // All other types of constraints
123   return SolverConstraintPtr(new SketchSolver_Constraint(theConstraint));
124 }
125
126 #ifdef SUPPORT_NEW_MOVE
127 std::shared_ptr<SketchSolver_ConstraintMovement> PlaneGCSSolver_Tools::createMovementConstraint(
128     FeaturePtr theMovedFeature)
129 {
130   return std::shared_ptr<SketchSolver_ConstraintMovement>(
131       new SketchSolver_ConstraintMovement(theMovedFeature));
132 }
133
134 std::shared_ptr<SketchSolver_ConstraintMovement> PlaneGCSSolver_Tools::createMovementConstraint(
135     AttributePtr theMovedAttribute)
136 {
137   return std::shared_ptr<SketchSolver_ConstraintMovement>(
138       new SketchSolver_ConstraintMovement(theMovedAttribute));
139 }
140 #else
141 std::shared_ptr<SketchSolver_ConstraintFixed> PlaneGCSSolver_Tools::createMovementConstraint(
142     FeaturePtr theMovedFeature)
143 {
144   return std::shared_ptr<SketchSolver_ConstraintFixed>(
145       new SketchSolver_ConstraintFixed(theMovedFeature));
146 }
147 #endif
148
149
150
151 ConstraintWrapperPtr PlaneGCSSolver_Tools::createConstraint(
152     ConstraintPtr theConstraint,
153     const SketchSolver_ConstraintType& theType,
154     const EntityWrapperPtr& theValue,
155     const EntityWrapperPtr& thePoint1,
156     const EntityWrapperPtr& thePoint2,
157     const EntityWrapperPtr& theEntity1,
158     const EntityWrapperPtr& theEntity2)
159 {
160   ConstraintWrapperPtr aResult;
161   ScalarWrapperPtr anIntermediate;
162
163   std::shared_ptr<PlaneGCSSolver_PointWrapper> aPoint1 = GCS_POINT_WRAPPER(thePoint1);
164   std::shared_ptr<PlaneGCSSolver_PointWrapper> aPoint2 = GCS_POINT_WRAPPER(thePoint2);
165
166   switch (theType) {
167   case CONSTRAINT_PT_PT_COINCIDENT:
168     aResult = createConstraintCoincidence(aPoint1, aPoint2);
169     break;
170   case CONSTRAINT_PT_ON_LINE:
171   case CONSTRAINT_PT_ON_CIRCLE:
172     aResult = createConstraintPointOnEntity(theType, aPoint1, GCS_EDGE_WRAPPER(theEntity1));
173     break;
174   case CONSTRAINT_MIDDLE_POINT:
175     aResult = createConstraintMiddlePoint(aPoint1, GCS_EDGE_WRAPPER(theEntity1));
176     break;
177   case CONSTRAINT_PT_PT_DISTANCE:
178     aResult = createConstraintDistancePointPoint(GCS_SCALAR_WRAPPER(theValue), aPoint1, aPoint2);
179     break;
180   case CONSTRAINT_PT_LINE_DISTANCE:
181     aResult = createConstraintDistancePointLine(GCS_SCALAR_WRAPPER(theValue),
182                                                 aPoint1,
183                                                 GCS_EDGE_WRAPPER(theEntity1));
184     break;
185   case CONSTRAINT_RADIUS:
186     aResult = createConstraintRadius(GCS_SCALAR_WRAPPER(theValue),
187                                      GCS_EDGE_WRAPPER(theEntity1));
188     break;
189   case CONSTRAINT_ANGLE:
190     aResult = createConstraintAngle(theConstraint,
191                   GCS_SCALAR_WRAPPER(theValue),
192                   GCS_EDGE_WRAPPER(theEntity1), GCS_EDGE_WRAPPER(theEntity2));
193     break;
194   case CONSTRAINT_FIXED:
195     break;
196   case CONSTRAINT_HORIZONTAL:
197   case CONSTRAINT_VERTICAL:
198     aResult = createConstraintHorizVert(theType, GCS_EDGE_WRAPPER(theEntity1));
199     break;
200   case CONSTRAINT_PARALLEL:
201     aResult = createConstraintParallel(GCS_EDGE_WRAPPER(theEntity1),
202                                        GCS_EDGE_WRAPPER(theEntity2));
203     break;
204   case CONSTRAINT_PERPENDICULAR:
205     aResult = createConstraintPerpendicular(GCS_EDGE_WRAPPER(theEntity1),
206                                             GCS_EDGE_WRAPPER(theEntity2));
207     break;
208   case CONSTRAINT_EQUAL_LINES:
209     anIntermediate = GCS_SCALAR_WRAPPER(theValue); // parameter is used to store length of lines
210   case CONSTRAINT_EQUAL_LINE_ARC:
211   case CONSTRAINT_EQUAL_RADIUS:
212     aResult = createConstraintEqual(theType,
213                                     GCS_EDGE_WRAPPER(theEntity1),
214                                     GCS_EDGE_WRAPPER(theEntity2),
215                                     anIntermediate);
216     break;
217   default:
218     break;
219   }
220
221   return aResult;
222 }
223
224 std::shared_ptr<GeomAPI_Pnt2d> PlaneGCSSolver_Tools::point(EntityWrapperPtr theEntity)
225 {
226   if (theEntity->type() != ENTITY_POINT)
227     return std::shared_ptr<GeomAPI_Pnt2d>();
228
229   std::shared_ptr<PlaneGCSSolver_PointWrapper> aPointWrapper =
230       std::dynamic_pointer_cast<PlaneGCSSolver_PointWrapper>(theEntity);
231   const GCSPointPtr& aPoint = aPointWrapper->point();
232   return std::shared_ptr<GeomAPI_Pnt2d>(new GeomAPI_Pnt2d(*aPoint->x, *aPoint->y));
233 }
234
235 std::shared_ptr<GeomAPI_Lin2d> PlaneGCSSolver_Tools::line(EntityWrapperPtr theEntity)
236 {
237   if (theEntity->type() != ENTITY_LINE)
238     return std::shared_ptr<GeomAPI_Lin2d>();
239
240   std::shared_ptr<PlaneGCSSolver_EdgeWrapper> anEntity =
241       std::dynamic_pointer_cast<PlaneGCSSolver_EdgeWrapper>(theEntity);
242   std::shared_ptr<GCS::Line> aLine = std::dynamic_pointer_cast<GCS::Line>(anEntity->entity());
243   return std::shared_ptr<GeomAPI_Lin2d>(
244       new GeomAPI_Lin2d(*(aLine->p1.x), *(aLine->p1.y), *(aLine->p2.x), *(aLine->p2.y)));
245 }
246
247 std::shared_ptr<GeomAPI_Lin2d> PlaneGCSSolver_Tools::line(FeaturePtr theFeature)
248 {
249   if (theFeature->getKind() != SketchPlugin_Line::ID())
250     return std::shared_ptr<GeomAPI_Lin2d>();
251
252   AttributePoint2DPtr aStart = std::dynamic_pointer_cast<GeomDataAPI_Point2D>(
253       theFeature->attribute(SketchPlugin_Line::START_ID()));
254   AttributePoint2DPtr aEnd = std::dynamic_pointer_cast<GeomDataAPI_Point2D>(
255       theFeature->attribute(SketchPlugin_Line::END_ID()));
256
257   return std::shared_ptr<GeomAPI_Lin2d>(new GeomAPI_Lin2d(aStart->pnt(), aEnd->pnt()));
258 }
259
260
261
262
263
264 // ================   Auxiliary functions   ==========================
265 ConstraintWrapperPtr createConstraintCoincidence(
266     std::shared_ptr<PlaneGCSSolver_PointWrapper> thePoint1,
267     std::shared_ptr<PlaneGCSSolver_PointWrapper> thePoint2)
268 {
269   GCSPointPtr aPoint1 = thePoint1->point();
270   GCSPointPtr aPoint2 = thePoint2->point();
271
272   // Create equality constraint for corresponding attributes of the points
273   std::list<GCSConstraintPtr> aConstrList;
274   aConstrList.push_back(
275       GCSConstraintPtr(new GCS::ConstraintEqual(aPoint1->x, aPoint2->x)));
276   aConstrList.push_back(
277       GCSConstraintPtr(new GCS::ConstraintEqual(aPoint1->y, aPoint2->y)));
278
279   return ConstraintWrapperPtr(new PlaneGCSSolver_ConstraintWrapper(
280       aConstrList, CONSTRAINT_PT_PT_COINCIDENT));
281 }
282
283 ConstraintWrapperPtr createConstraintPointOnEntity(
284     const SketchSolver_ConstraintType& theType,
285     std::shared_ptr<PlaneGCSSolver_PointWrapper> thePoint,
286     std::shared_ptr<PlaneGCSSolver_EdgeWrapper> theEntity)
287 {
288   GCSConstraintPtr aNewConstr;
289
290   switch (theEntity->type()) {
291   case ENTITY_LINE: {
292     std::shared_ptr<GCS::Line> aLine = std::dynamic_pointer_cast<GCS::Line>(theEntity->entity());
293     aNewConstr = GCSConstraintPtr(new GCS::ConstraintPointOnLine(*(thePoint->point()), *aLine));
294     break;
295     }
296   case ENTITY_ARC:
297   case ENTITY_CIRCLE: {
298     std::shared_ptr<GCS::Circle> aCirc =
299       std::dynamic_pointer_cast<GCS::Circle>(theEntity->entity());
300     aNewConstr = GCSConstraintPtr(
301         new GCS::ConstraintP2PDistance(*(thePoint->point()), aCirc->center, aCirc->rad));
302     break;
303     }
304   default:
305     return ConstraintWrapperPtr();
306   }
307
308   return ConstraintWrapperPtr(new PlaneGCSSolver_ConstraintWrapper(aNewConstr, theType));
309 }
310
311 ConstraintWrapperPtr createConstraintMiddlePoint(
312     std::shared_ptr<PlaneGCSSolver_PointWrapper> thePoint,
313     std::shared_ptr<PlaneGCSSolver_EdgeWrapper> theEntity)
314 {
315   GCSPointPtr aPoint = thePoint->point();
316   std::shared_ptr<GCS::Line> aLine = std::dynamic_pointer_cast<GCS::Line>(theEntity->entity());
317   if (!aLine)
318     return ConstraintWrapperPtr();
319
320   std::list<GCSConstraintPtr> aConstrList;
321   aConstrList.push_back(
322       GCSConstraintPtr(new GCS::ConstraintPointOnPerpBisector(*aPoint, aLine->p1, aLine->p2)));
323   aConstrList.push_back(GCSConstraintPtr(new GCS::ConstraintPointOnLine(*aPoint, *aLine)));
324
325   return ConstraintWrapperPtr(
326       new PlaneGCSSolver_ConstraintWrapper(aConstrList, CONSTRAINT_MIDDLE_POINT));
327 }
328
329
330 ConstraintWrapperPtr createConstraintDistancePointPoint(
331     std::shared_ptr<PlaneGCSSolver_ScalarWrapper> theValue,
332     std::shared_ptr<PlaneGCSSolver_PointWrapper>  thePoint1,
333     std::shared_ptr<PlaneGCSSolver_PointWrapper>  thePoint2)
334 {
335   GCSConstraintPtr aNewConstr(new GCS::ConstraintP2PDistance(
336       *(thePoint1->point()), *(thePoint2->point()), theValue->scalar()));
337   std::shared_ptr<PlaneGCSSolver_ConstraintWrapper> aResult(
338       new PlaneGCSSolver_ConstraintWrapper(aNewConstr, CONSTRAINT_PT_PT_DISTANCE));
339   aResult->setValueParameter(theValue);
340   return aResult;
341 }
342
343 ConstraintWrapperPtr createConstraintDistancePointLine(
344     std::shared_ptr<PlaneGCSSolver_ScalarWrapper> theValue,
345     std::shared_ptr<PlaneGCSSolver_PointWrapper>  thePoint,
346     std::shared_ptr<PlaneGCSSolver_EdgeWrapper> theEntity)
347 {
348   std::shared_ptr<GCS::Line> aLine = std::dynamic_pointer_cast<GCS::Line>(theEntity->entity());
349   GCSConstraintPtr aNewConstr(new GCS::ConstraintP2LDistance(
350       *(thePoint->point()), *(aLine), theValue->scalar()));
351   std::shared_ptr<PlaneGCSSolver_ConstraintWrapper> aResult(
352       new PlaneGCSSolver_ConstraintWrapper(aNewConstr, CONSTRAINT_PT_LINE_DISTANCE));
353   aResult->setValueParameter(theValue);
354   return aResult;
355 }
356
357 ConstraintWrapperPtr createConstraintRadius(
358     std::shared_ptr<PlaneGCSSolver_ScalarWrapper> theValue,
359     std::shared_ptr<PlaneGCSSolver_EdgeWrapper> theEntity)
360 {
361   std::shared_ptr<GCS::Circle> aCircle =
362     std::dynamic_pointer_cast<GCS::Circle>(theEntity->entity());
363   GCSConstraintPtr aNewConstr(new GCS::ConstraintEqual(aCircle->rad, theValue->scalar()));
364   std::shared_ptr<PlaneGCSSolver_ConstraintWrapper> aResult(
365       new PlaneGCSSolver_ConstraintWrapper(aNewConstr, CONSTRAINT_RADIUS));
366   aResult->setValueParameter(theValue);
367   return aResult;
368 }
369
370 ConstraintWrapperPtr createConstraintAngle(
371     ConstraintPtr theConstraint,
372     std::shared_ptr<PlaneGCSSolver_ScalarWrapper> theValue,
373     std::shared_ptr<PlaneGCSSolver_EdgeWrapper> theEntity1,
374     std::shared_ptr<PlaneGCSSolver_EdgeWrapper> theEntity2)
375 {
376   std::shared_ptr<GCS::Line> aLine1 = std::dynamic_pointer_cast<GCS::Line>(theEntity1->entity());
377   bool isLine1Rev = theConstraint->boolean(
378       SketchPlugin_ConstraintAngle::ANGLE_REVERSED_FIRST_LINE_ID())->value();
379   GCS::Point aLine1Pt1 = isLine1Rev ? aLine1->p2 : aLine1->p1;
380   GCS::Point aLine1Pt2 = isLine1Rev ? aLine1->p1 : aLine1->p2;
381
382   std::shared_ptr<GCS::Line> aLine2 = std::dynamic_pointer_cast<GCS::Line>(theEntity2->entity());
383   bool isLine2Rev = theConstraint->boolean(
384       SketchPlugin_ConstraintAngle::ANGLE_REVERSED_SECOND_LINE_ID())->value();
385   GCS::Point aLine2Pt1 = isLine2Rev ? aLine2->p2 : aLine2->p1;
386   GCS::Point aLine2Pt2 = isLine2Rev ? aLine2->p1 : aLine2->p2;
387
388   GCSConstraintPtr aNewConstr(new GCS::ConstraintL2LAngle(
389       aLine1Pt1, aLine1Pt2, aLine2Pt1, aLine2Pt2, theValue->scalar()));
390
391   std::shared_ptr<PlaneGCSSolver_ConstraintWrapper> aResult(
392       new PlaneGCSSolver_ConstraintWrapper(aNewConstr, CONSTRAINT_ANGLE));
393   aResult->setValueParameter(theValue);
394   return aResult;
395 }
396
397 ConstraintWrapperPtr createConstraintHorizVert(
398     const SketchSolver_ConstraintType& theType,
399     std::shared_ptr<PlaneGCSSolver_EdgeWrapper> theEntity)
400 {
401   std::shared_ptr<GCS::Line> aLine = std::dynamic_pointer_cast<GCS::Line>(theEntity->entity());
402   GCSConstraintPtr aNewConstr;
403   if (theType == CONSTRAINT_HORIZONTAL)
404     aNewConstr = GCSConstraintPtr(new GCS::ConstraintEqual(aLine->p1.y, aLine->p2.y));
405   else
406     aNewConstr = GCSConstraintPtr(new GCS::ConstraintEqual(aLine->p1.x, aLine->p2.x));
407
408   return ConstraintWrapperPtr(new PlaneGCSSolver_ConstraintWrapper(aNewConstr, theType));
409 }
410
411 ConstraintWrapperPtr createConstraintParallel(
412     std::shared_ptr<PlaneGCSSolver_EdgeWrapper> theEntity1,
413     std::shared_ptr<PlaneGCSSolver_EdgeWrapper> theEntity2)
414 {
415   std::shared_ptr<GCS::Line> aLine1 = std::dynamic_pointer_cast<GCS::Line>(theEntity1->entity());
416   std::shared_ptr<GCS::Line> aLine2 = std::dynamic_pointer_cast<GCS::Line>(theEntity2->entity());
417   GCSConstraintPtr aNewConstr(new GCS::ConstraintParallel(*(aLine1), *(aLine2)));
418
419   return ConstraintWrapperPtr(
420       new PlaneGCSSolver_ConstraintWrapper(aNewConstr, CONSTRAINT_PARALLEL));
421 }
422
423 ConstraintWrapperPtr createConstraintPerpendicular(
424     std::shared_ptr<PlaneGCSSolver_EdgeWrapper> theEntity1,
425     std::shared_ptr<PlaneGCSSolver_EdgeWrapper> theEntity2)
426 {
427   std::shared_ptr<GCS::Line> aLine1 = std::dynamic_pointer_cast<GCS::Line>(theEntity1->entity());
428   std::shared_ptr<GCS::Line> aLine2 = std::dynamic_pointer_cast<GCS::Line>(theEntity2->entity());
429   GCSConstraintPtr aNewConstr(new GCS::ConstraintPerpendicular(*(aLine1), *(aLine2)));
430
431   return ConstraintWrapperPtr(
432       new PlaneGCSSolver_ConstraintWrapper(aNewConstr, CONSTRAINT_PERPENDICULAR));
433 }
434
435 ConstraintWrapperPtr createConstraintEqual(
436     const SketchSolver_ConstraintType& theType,
437     std::shared_ptr<PlaneGCSSolver_EdgeWrapper> theEntity1,
438     std::shared_ptr<PlaneGCSSolver_EdgeWrapper> theEntity2,
439     std::shared_ptr<PlaneGCSSolver_ScalarWrapper> theIntermed)
440 {
441   if (theType == CONSTRAINT_EQUAL_LINE_ARC)
442     return ConstraintWrapperPtr(); // line-arc equivalence is not supported yet
443
444   std::list<GCSConstraintPtr> aConstrList;
445   if (theType == CONSTRAINT_EQUAL_LINES) {
446     std::shared_ptr<GCS::Line> aLine1 = std::dynamic_pointer_cast<GCS::Line>(theEntity1->entity());
447     std::shared_ptr<GCS::Line> aLine2 = std::dynamic_pointer_cast<GCS::Line>(theEntity2->entity());
448
449     aConstrList.push_back(GCSConstraintPtr(
450         new GCS::ConstraintP2PDistance(aLine1->p1, aLine1->p2, theIntermed->scalar())));
451     aConstrList.push_back(GCSConstraintPtr(
452         new GCS::ConstraintP2PDistance(aLine2->p1, aLine2->p2, theIntermed->scalar())));
453     // update value of intermediate parameter
454     double x = *aLine1->p1.x - *aLine1->p2.x;
455     double y = *aLine1->p1.y - *aLine1->p2.y;
456     double aLen = sqrt(x*x + y*y);
457     theIntermed->setValue(aLen);
458   } else {
459     std::shared_ptr<GCS::Circle> aCirc1 =
460         std::dynamic_pointer_cast<GCS::Circle>(theEntity1->entity());
461     std::shared_ptr<GCS::Circle> aCirc2 =
462         std::dynamic_pointer_cast<GCS::Circle>(theEntity2->entity());
463
464     aConstrList.push_back(GCSConstraintPtr(new GCS::ConstraintEqual(aCirc1->rad, aCirc2->rad)));
465   }
466
467   std::shared_ptr<PlaneGCSSolver_ConstraintWrapper> aResult(
468       new PlaneGCSSolver_ConstraintWrapper(aConstrList, theType));
469   if (theIntermed)
470     aResult->setValueParameter(theIntermed);
471   return aResult;
472 }