1 // Copyright (C) 2014-20xx CEA/DEN, EDF R&D
3 // File: SketchSolver_Builder.cpp
4 // Created: 25 Mar 2015
5 // Author: Artem ZHIDKOV
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>
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>
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>
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)
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);
95 SolverConstraintPtr PlaneGCSSolver_Tools::createConstraint(ConstraintPtr theConstraint)
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));
122 // All other types of constraints
123 return SolverConstraintPtr(new SketchSolver_Constraint(theConstraint));
126 #ifdef SUPPORT_NEW_MOVE
127 std::shared_ptr<SketchSolver_ConstraintMovement> PlaneGCSSolver_Tools::createMovementConstraint(
128 FeaturePtr theMovedFeature)
130 return std::shared_ptr<SketchSolver_ConstraintMovement>(
131 new SketchSolver_ConstraintMovement(theMovedFeature));
134 std::shared_ptr<SketchSolver_ConstraintMovement> PlaneGCSSolver_Tools::createMovementConstraint(
135 AttributePtr theMovedAttribute)
137 return std::shared_ptr<SketchSolver_ConstraintMovement>(
138 new SketchSolver_ConstraintMovement(theMovedAttribute));
141 std::shared_ptr<SketchSolver_ConstraintFixed> PlaneGCSSolver_Tools::createMovementConstraint(
142 FeaturePtr theMovedFeature)
144 return std::shared_ptr<SketchSolver_ConstraintFixed>(
145 new SketchSolver_ConstraintFixed(theMovedFeature));
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)
160 ConstraintWrapperPtr aResult;
161 ScalarWrapperPtr anIntermediate;
163 std::shared_ptr<PlaneGCSSolver_PointWrapper> aPoint1 = GCS_POINT_WRAPPER(thePoint1);
164 std::shared_ptr<PlaneGCSSolver_PointWrapper> aPoint2 = GCS_POINT_WRAPPER(thePoint2);
167 case CONSTRAINT_PT_PT_COINCIDENT:
168 aResult = createConstraintCoincidence(aPoint1, aPoint2);
170 case CONSTRAINT_PT_ON_LINE:
171 case CONSTRAINT_PT_ON_CIRCLE:
172 aResult = createConstraintPointOnEntity(theType, aPoint1, GCS_EDGE_WRAPPER(theEntity1));
174 case CONSTRAINT_MIDDLE_POINT:
175 aResult = createConstraintMiddlePoint(aPoint1, GCS_EDGE_WRAPPER(theEntity1));
177 case CONSTRAINT_PT_PT_DISTANCE:
178 aResult = createConstraintDistancePointPoint(GCS_SCALAR_WRAPPER(theValue), aPoint1, aPoint2);
180 case CONSTRAINT_PT_LINE_DISTANCE:
181 aResult = createConstraintDistancePointLine(GCS_SCALAR_WRAPPER(theValue),
183 GCS_EDGE_WRAPPER(theEntity1));
185 case CONSTRAINT_RADIUS:
186 aResult = createConstraintRadius(GCS_SCALAR_WRAPPER(theValue),
187 GCS_EDGE_WRAPPER(theEntity1));
189 case CONSTRAINT_ANGLE:
190 aResult = createConstraintAngle(theConstraint,
191 GCS_SCALAR_WRAPPER(theValue),
192 GCS_EDGE_WRAPPER(theEntity1), GCS_EDGE_WRAPPER(theEntity2));
194 case CONSTRAINT_FIXED:
196 case CONSTRAINT_HORIZONTAL:
197 case CONSTRAINT_VERTICAL:
198 aResult = createConstraintHorizVert(theType, GCS_EDGE_WRAPPER(theEntity1));
200 case CONSTRAINT_PARALLEL:
201 aResult = createConstraintParallel(GCS_EDGE_WRAPPER(theEntity1),
202 GCS_EDGE_WRAPPER(theEntity2));
204 case CONSTRAINT_PERPENDICULAR:
205 aResult = createConstraintPerpendicular(GCS_EDGE_WRAPPER(theEntity1),
206 GCS_EDGE_WRAPPER(theEntity2));
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),
224 std::shared_ptr<GeomAPI_Pnt2d> PlaneGCSSolver_Tools::point(EntityWrapperPtr theEntity)
226 if (theEntity->type() != ENTITY_POINT)
227 return std::shared_ptr<GeomAPI_Pnt2d>();
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));
235 std::shared_ptr<GeomAPI_Lin2d> PlaneGCSSolver_Tools::line(EntityWrapperPtr theEntity)
237 if (theEntity->type() != ENTITY_LINE)
238 return std::shared_ptr<GeomAPI_Lin2d>();
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)));
247 std::shared_ptr<GeomAPI_Lin2d> PlaneGCSSolver_Tools::line(FeaturePtr theFeature)
249 if (theFeature->getKind() != SketchPlugin_Line::ID())
250 return std::shared_ptr<GeomAPI_Lin2d>();
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()));
257 return std::shared_ptr<GeomAPI_Lin2d>(new GeomAPI_Lin2d(aStart->pnt(), aEnd->pnt()));
264 // ================ Auxiliary functions ==========================
265 ConstraintWrapperPtr createConstraintCoincidence(
266 std::shared_ptr<PlaneGCSSolver_PointWrapper> thePoint1,
267 std::shared_ptr<PlaneGCSSolver_PointWrapper> thePoint2)
269 GCSPointPtr aPoint1 = thePoint1->point();
270 GCSPointPtr aPoint2 = thePoint2->point();
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)));
279 return ConstraintWrapperPtr(new PlaneGCSSolver_ConstraintWrapper(
280 aConstrList, CONSTRAINT_PT_PT_COINCIDENT));
283 ConstraintWrapperPtr createConstraintPointOnEntity(
284 const SketchSolver_ConstraintType& theType,
285 std::shared_ptr<PlaneGCSSolver_PointWrapper> thePoint,
286 std::shared_ptr<PlaneGCSSolver_EdgeWrapper> theEntity)
288 GCSConstraintPtr aNewConstr;
290 switch (theEntity->type()) {
292 std::shared_ptr<GCS::Line> aLine = std::dynamic_pointer_cast<GCS::Line>(theEntity->entity());
293 aNewConstr = GCSConstraintPtr(new GCS::ConstraintPointOnLine(*(thePoint->point()), *aLine));
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));
305 return ConstraintWrapperPtr();
308 return ConstraintWrapperPtr(new PlaneGCSSolver_ConstraintWrapper(aNewConstr, theType));
311 ConstraintWrapperPtr createConstraintMiddlePoint(
312 std::shared_ptr<PlaneGCSSolver_PointWrapper> thePoint,
313 std::shared_ptr<PlaneGCSSolver_EdgeWrapper> theEntity)
315 GCSPointPtr aPoint = thePoint->point();
316 std::shared_ptr<GCS::Line> aLine = std::dynamic_pointer_cast<GCS::Line>(theEntity->entity());
318 return ConstraintWrapperPtr();
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)));
325 return ConstraintWrapperPtr(
326 new PlaneGCSSolver_ConstraintWrapper(aConstrList, CONSTRAINT_MIDDLE_POINT));
330 ConstraintWrapperPtr createConstraintDistancePointPoint(
331 std::shared_ptr<PlaneGCSSolver_ScalarWrapper> theValue,
332 std::shared_ptr<PlaneGCSSolver_PointWrapper> thePoint1,
333 std::shared_ptr<PlaneGCSSolver_PointWrapper> thePoint2)
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);
343 ConstraintWrapperPtr createConstraintDistancePointLine(
344 std::shared_ptr<PlaneGCSSolver_ScalarWrapper> theValue,
345 std::shared_ptr<PlaneGCSSolver_PointWrapper> thePoint,
346 std::shared_ptr<PlaneGCSSolver_EdgeWrapper> theEntity)
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);
357 ConstraintWrapperPtr createConstraintRadius(
358 std::shared_ptr<PlaneGCSSolver_ScalarWrapper> theValue,
359 std::shared_ptr<PlaneGCSSolver_EdgeWrapper> theEntity)
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);
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)
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;
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;
388 GCSConstraintPtr aNewConstr(new GCS::ConstraintL2LAngle(
389 aLine1Pt1, aLine1Pt2, aLine2Pt1, aLine2Pt2, theValue->scalar()));
391 std::shared_ptr<PlaneGCSSolver_ConstraintWrapper> aResult(
392 new PlaneGCSSolver_ConstraintWrapper(aNewConstr, CONSTRAINT_ANGLE));
393 aResult->setValueParameter(theValue);
397 ConstraintWrapperPtr createConstraintHorizVert(
398 const SketchSolver_ConstraintType& theType,
399 std::shared_ptr<PlaneGCSSolver_EdgeWrapper> theEntity)
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));
406 aNewConstr = GCSConstraintPtr(new GCS::ConstraintEqual(aLine->p1.x, aLine->p2.x));
408 return ConstraintWrapperPtr(new PlaneGCSSolver_ConstraintWrapper(aNewConstr, theType));
411 ConstraintWrapperPtr createConstraintParallel(
412 std::shared_ptr<PlaneGCSSolver_EdgeWrapper> theEntity1,
413 std::shared_ptr<PlaneGCSSolver_EdgeWrapper> theEntity2)
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)));
419 return ConstraintWrapperPtr(
420 new PlaneGCSSolver_ConstraintWrapper(aNewConstr, CONSTRAINT_PARALLEL));
423 ConstraintWrapperPtr createConstraintPerpendicular(
424 std::shared_ptr<PlaneGCSSolver_EdgeWrapper> theEntity1,
425 std::shared_ptr<PlaneGCSSolver_EdgeWrapper> theEntity2)
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)));
431 return ConstraintWrapperPtr(
432 new PlaneGCSSolver_ConstraintWrapper(aNewConstr, CONSTRAINT_PERPENDICULAR));
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)
441 if (theType == CONSTRAINT_EQUAL_LINE_ARC)
442 return ConstraintWrapperPtr(); // line-arc equivalence is not supported yet
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());
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);
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());
464 aConstrList.push_back(GCSConstraintPtr(new GCS::ConstraintEqual(aCirc1->rad, aCirc2->rad)));
467 std::shared_ptr<PlaneGCSSolver_ConstraintWrapper> aResult(
468 new PlaneGCSSolver_ConstraintWrapper(aConstrList, theType));
470 aResult->setValueParameter(theIntermed);