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_EntityWrapper.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_ENTITY_WRAPPER(x) std::dynamic_pointer_cast<PlaneGCSSolver_EntityWrapper>(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_EntityWrapper> 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_EntityWrapper> theEntity);
65 static ConstraintWrapperPtr
66 createConstraintRadius(std::shared_ptr<PlaneGCSSolver_ScalarWrapper> theValue,
67 std::shared_ptr<PlaneGCSSolver_EntityWrapper> theEntity);
68 static ConstraintWrapperPtr
69 createConstraintAngle(ConstraintPtr theConstraint,
70 std::shared_ptr<PlaneGCSSolver_ScalarWrapper> theValue,
71 std::shared_ptr<PlaneGCSSolver_EntityWrapper> theEntity1,
72 std::shared_ptr<PlaneGCSSolver_EntityWrapper> theEntity2);
73 static ConstraintWrapperPtr
74 createConstraintHorizVert(const SketchSolver_ConstraintType& theType,
75 std::shared_ptr<PlaneGCSSolver_EntityWrapper> theEntity);
76 static ConstraintWrapperPtr
77 createConstraintParallel(std::shared_ptr<PlaneGCSSolver_EntityWrapper> theEntity1,
78 std::shared_ptr<PlaneGCSSolver_EntityWrapper> theEntity2);
79 static ConstraintWrapperPtr
80 createConstraintPerpendicular(std::shared_ptr<PlaneGCSSolver_EntityWrapper> theEntity1,
81 std::shared_ptr<PlaneGCSSolver_EntityWrapper> theEntity2);
82 static ConstraintWrapperPtr
83 createConstraintEqual(const SketchSolver_ConstraintType& theType,
84 std::shared_ptr<PlaneGCSSolver_EntityWrapper> theEntity1,
85 std::shared_ptr<PlaneGCSSolver_EntityWrapper> theEntity2,
86 std::shared_ptr<PlaneGCSSolver_ScalarWrapper> theIntermed);
87 static ConstraintWrapperPtr
88 createConstraintTangent(const SketchSolver_ConstraintType& theType,
89 std::shared_ptr<PlaneGCSSolver_EntityWrapper> theEntity1,
90 std::shared_ptr<PlaneGCSSolver_EntityWrapper> theEntity2);
91 static ConstraintWrapperPtr
92 createConstraintCollinear(ConstraintPtr theConstraint,
93 std::shared_ptr<PlaneGCSSolver_EntityWrapper> theEntity1,
94 std::shared_ptr<PlaneGCSSolver_EntityWrapper> theEntity2);
95 static ConstraintWrapperPtr
96 createConstraintMiddlePoint(std::shared_ptr<PlaneGCSSolver_PointWrapper> thePoint,
97 std::shared_ptr<PlaneGCSSolver_EntityWrapper> theEntity);
103 SolverConstraintPtr PlaneGCSSolver_Tools::createConstraint(ConstraintPtr theConstraint)
105 if (theConstraint->getKind() == SketchPlugin_ConstraintCoincidence::ID()) {
106 return SolverConstraintPtr(new SketchSolver_ConstraintCoincidence(theConstraint));
107 } else if (theConstraint->getKind() == SketchPlugin_ConstraintCollinear::ID()) {
108 return SolverConstraintPtr(new SketchSolver_ConstraintCollinear(theConstraint));
109 } else if (theConstraint->getKind() == SketchPlugin_ConstraintDistance::ID()) {
110 return SolverConstraintPtr(new SketchSolver_ConstraintDistance(theConstraint));
111 } else if (theConstraint->getKind() == SketchPlugin_ConstraintEqual::ID()) {
112 return SolverConstraintPtr(new SketchSolver_ConstraintEqual(theConstraint));
113 } else if (theConstraint->getKind() == SketchPlugin_ConstraintLength::ID()) {
114 return SolverConstraintPtr(new SketchSolver_ConstraintLength(theConstraint));
115 } else if (theConstraint->getKind() == SketchPlugin_ConstraintMiddle::ID()) {
116 return SolverConstraintPtr(new SketchSolver_ConstraintMiddle(theConstraint));
117 } else if (theConstraint->getKind() == SketchPlugin_ConstraintMirror::ID()) {
118 return SolverConstraintPtr(new SketchSolver_ConstraintMirror(theConstraint));
119 } else if (theConstraint->getKind() == SketchPlugin_ConstraintTangent::ID()) {
120 return SolverConstraintPtr(new SketchSolver_ConstraintTangent(theConstraint));
121 } else if (theConstraint->getKind() == SketchPlugin_ConstraintRigid::ID()) {
122 return SolverConstraintPtr(new SketchSolver_ConstraintFixed(theConstraint));
123 } else if (theConstraint->getKind() == SketchPlugin_MultiTranslation::ID()) {
124 return SolverConstraintPtr(new SketchSolver_ConstraintMultiTranslation(theConstraint));
125 } else if (theConstraint->getKind() == SketchPlugin_MultiRotation::ID()) {
126 return SolverConstraintPtr(new SketchSolver_ConstraintMultiRotation(theConstraint));
127 } else if (theConstraint->getKind() == SketchPlugin_ConstraintAngle::ID()) {
128 return SolverConstraintPtr(new SketchSolver_ConstraintAngle(theConstraint));
130 // All other types of constraints
131 return SolverConstraintPtr(new SketchSolver_Constraint(theConstraint));
134 SolverConstraintPtr PlaneGCSSolver_Tools::createMovementConstraint(FeaturePtr theMovedFeature)
136 return SolverConstraintPtr(new SketchSolver_ConstraintFixed(theMovedFeature));
141 ConstraintWrapperPtr PlaneGCSSolver_Tools::createConstraint(
142 ConstraintPtr theConstraint,
143 const SketchSolver_ConstraintType& theType,
144 const EntityWrapperPtr& theValue,
145 const EntityWrapperPtr& thePoint1,
146 const EntityWrapperPtr& thePoint2,
147 const EntityWrapperPtr& theEntity1,
148 const EntityWrapperPtr& theEntity2)
150 ConstraintWrapperPtr aResult;
151 ScalarWrapperPtr anIntermediate;
153 std::shared_ptr<PlaneGCSSolver_PointWrapper> aPoint1 = GCS_POINT_WRAPPER(thePoint1);
154 std::shared_ptr<PlaneGCSSolver_PointWrapper> aPoint2 = GCS_POINT_WRAPPER(thePoint2);
157 case CONSTRAINT_PT_PT_COINCIDENT:
158 aResult = createConstraintCoincidence(aPoint1, aPoint2);
160 case CONSTRAINT_PT_ON_LINE:
161 case CONSTRAINT_PT_ON_CIRCLE:
162 aResult = createConstraintPointOnEntity(theType, aPoint1, GCS_ENTITY_WRAPPER(theEntity1));
164 case CONSTRAINT_MIDDLE_POINT:
165 aResult = createConstraintMiddlePoint(aPoint1, GCS_ENTITY_WRAPPER(theEntity1));
167 case CONSTRAINT_PT_PT_DISTANCE:
168 aResult = createConstraintDistancePointPoint(GCS_SCALAR_WRAPPER(theValue), aPoint1, aPoint2);
170 case CONSTRAINT_PT_LINE_DISTANCE:
171 aResult = createConstraintDistancePointLine(GCS_SCALAR_WRAPPER(theValue),
173 GCS_ENTITY_WRAPPER(theEntity1));
175 case CONSTRAINT_RADIUS:
176 aResult = createConstraintRadius(GCS_SCALAR_WRAPPER(theValue),
177 GCS_ENTITY_WRAPPER(theEntity1));
179 case CONSTRAINT_ANGLE:
180 aResult = createConstraintAngle(theConstraint,
181 GCS_SCALAR_WRAPPER(theValue),
182 GCS_ENTITY_WRAPPER(theEntity1), GCS_ENTITY_WRAPPER(theEntity2));
184 case CONSTRAINT_FIXED:
186 case CONSTRAINT_HORIZONTAL:
187 case CONSTRAINT_VERTICAL:
188 aResult = createConstraintHorizVert(theType, GCS_ENTITY_WRAPPER(theEntity1));
190 case CONSTRAINT_PARALLEL:
191 aResult = createConstraintParallel(GCS_ENTITY_WRAPPER(theEntity1),
192 GCS_ENTITY_WRAPPER(theEntity2));
194 case CONSTRAINT_PERPENDICULAR:
195 aResult = createConstraintPerpendicular(GCS_ENTITY_WRAPPER(theEntity1),
196 GCS_ENTITY_WRAPPER(theEntity2));
198 case CONSTRAINT_EQUAL_LINES:
199 anIntermediate = GCS_SCALAR_WRAPPER(theValue); // parameter is used to store length of lines
200 case CONSTRAINT_EQUAL_LINE_ARC:
201 case CONSTRAINT_EQUAL_RADIUS:
202 aResult = createConstraintEqual(theType,
203 GCS_ENTITY_WRAPPER(theEntity1),
204 GCS_ENTITY_WRAPPER(theEntity2),
207 case CONSTRAINT_TANGENT_CIRCLE_LINE:
208 case CONSTRAINT_TANGENT_CIRCLE_CIRCLE:
209 aResult = createConstraintTangent(theType,
210 GCS_ENTITY_WRAPPER(theEntity1),
211 GCS_ENTITY_WRAPPER(theEntity2));
213 case CONSTRAINT_COLLINEAR:
214 aResult = createConstraintCollinear(theConstraint,
215 GCS_ENTITY_WRAPPER(theEntity1), GCS_ENTITY_WRAPPER(theEntity2));
217 case CONSTRAINT_MULTI_TRANSLATION:
218 case CONSTRAINT_MULTI_ROTATION:
219 case CONSTRAINT_SYMMETRIC:
227 std::shared_ptr<GeomAPI_Pnt2d> PlaneGCSSolver_Tools::point(EntityWrapperPtr theEntity)
229 if (theEntity->type() != ENTITY_POINT)
230 return std::shared_ptr<GeomAPI_Pnt2d>();
232 std::shared_ptr<PlaneGCSSolver_PointWrapper> aPointWrapper =
233 std::dynamic_pointer_cast<PlaneGCSSolver_PointWrapper>(theEntity);
234 const GCSPointPtr& aPoint = aPointWrapper->point();
235 return std::shared_ptr<GeomAPI_Pnt2d>(new GeomAPI_Pnt2d(*aPoint->x, *aPoint->y));
238 std::shared_ptr<GeomAPI_Lin2d> PlaneGCSSolver_Tools::line(EntityWrapperPtr theEntity)
240 if (theEntity->type() != ENTITY_LINE)
241 return std::shared_ptr<GeomAPI_Lin2d>();
243 std::shared_ptr<PlaneGCSSolver_EntityWrapper> anEntity =
244 std::dynamic_pointer_cast<PlaneGCSSolver_EntityWrapper>(theEntity);
245 std::shared_ptr<GCS::Line> aLine = std::dynamic_pointer_cast<GCS::Line>(anEntity->entity());
246 return std::shared_ptr<GeomAPI_Lin2d>(
247 new GeomAPI_Lin2d(*(aLine->p1.x), *(aLine->p1.y), *(aLine->p2.x), *(aLine->p2.y)));
250 std::shared_ptr<GeomAPI_Lin2d> PlaneGCSSolver_Tools::line(FeaturePtr theFeature)
252 if (theFeature->getKind() != SketchPlugin_Line::ID())
253 return std::shared_ptr<GeomAPI_Lin2d>();
255 AttributePoint2DPtr aStart = std::dynamic_pointer_cast<GeomDataAPI_Point2D>(
256 theFeature->attribute(SketchPlugin_Line::START_ID()));
257 AttributePoint2DPtr aEnd = std::dynamic_pointer_cast<GeomDataAPI_Point2D>(
258 theFeature->attribute(SketchPlugin_Line::END_ID()));
260 return std::shared_ptr<GeomAPI_Lin2d>(new GeomAPI_Lin2d(aStart->pnt(), aEnd->pnt()));
267 // ================ Auxiliary functions ==========================
268 ConstraintWrapperPtr createConstraintCoincidence(
269 std::shared_ptr<PlaneGCSSolver_PointWrapper> thePoint1,
270 std::shared_ptr<PlaneGCSSolver_PointWrapper> thePoint2)
272 GCSPointPtr aPoint1 = thePoint1->point();
273 GCSPointPtr aPoint2 = thePoint2->point();
275 // Create equality constraint for corresponding attributes of the points
276 std::list<GCSConstraintPtr> aConstrList;
277 aConstrList.push_back(
278 GCSConstraintPtr(new GCS::ConstraintEqual(aPoint1->x, aPoint2->x)));
279 aConstrList.push_back(
280 GCSConstraintPtr(new GCS::ConstraintEqual(aPoint1->y, aPoint2->y)));
282 return ConstraintWrapperPtr(new PlaneGCSSolver_ConstraintWrapper(
283 aConstrList, CONSTRAINT_PT_PT_COINCIDENT));
286 ConstraintWrapperPtr createConstraintPointOnEntity(
287 const SketchSolver_ConstraintType& theType,
288 std::shared_ptr<PlaneGCSSolver_PointWrapper> thePoint,
289 std::shared_ptr<PlaneGCSSolver_EntityWrapper> theEntity)
291 GCSConstraintPtr aNewConstr;
293 switch (theEntity->type()) {
295 std::shared_ptr<GCS::Line> aLine = std::dynamic_pointer_cast<GCS::Line>(theEntity->entity());
296 aNewConstr = GCSConstraintPtr(new GCS::ConstraintPointOnLine(*(thePoint->point()), *aLine));
300 case ENTITY_CIRCLE: {
301 std::shared_ptr<GCS::Circle> aCirc =
302 std::dynamic_pointer_cast<GCS::Circle>(theEntity->entity());
303 aNewConstr = GCSConstraintPtr(
304 new GCS::ConstraintP2PDistance(*(thePoint->point()), aCirc->center, aCirc->rad));
308 return ConstraintWrapperPtr();
311 return ConstraintWrapperPtr(new PlaneGCSSolver_ConstraintWrapper(aNewConstr, theType));
314 ConstraintWrapperPtr createConstraintMiddlePoint(
315 std::shared_ptr<PlaneGCSSolver_PointWrapper> thePoint,
316 std::shared_ptr<PlaneGCSSolver_EntityWrapper> theEntity)
318 GCSPointPtr aPoint = thePoint->point();
319 std::shared_ptr<GCS::Line> aLine = std::dynamic_pointer_cast<GCS::Line>(theEntity->entity());
321 return ConstraintWrapperPtr();
323 std::list<GCSConstraintPtr> aConstrList;
324 aConstrList.push_back(
325 GCSConstraintPtr(new GCS::ConstraintPointOnPerpBisector(*aPoint, aLine->p1, aLine->p2)));
326 aConstrList.push_back(GCSConstraintPtr(new GCS::ConstraintPointOnLine(*aPoint, *aLine)));
328 return ConstraintWrapperPtr(
329 new PlaneGCSSolver_ConstraintWrapper(aConstrList, CONSTRAINT_MIDDLE_POINT));
333 ConstraintWrapperPtr createConstraintDistancePointPoint(
334 std::shared_ptr<PlaneGCSSolver_ScalarWrapper> theValue,
335 std::shared_ptr<PlaneGCSSolver_PointWrapper> thePoint1,
336 std::shared_ptr<PlaneGCSSolver_PointWrapper> thePoint2)
338 GCSConstraintPtr aNewConstr(new GCS::ConstraintP2PDistance(
339 *(thePoint1->point()), *(thePoint2->point()), theValue->scalar()));
340 std::shared_ptr<PlaneGCSSolver_ConstraintWrapper> aResult(
341 new PlaneGCSSolver_ConstraintWrapper(aNewConstr, CONSTRAINT_PT_PT_DISTANCE));
342 aResult->setValueParameter(theValue);
346 ConstraintWrapperPtr createConstraintDistancePointLine(
347 std::shared_ptr<PlaneGCSSolver_ScalarWrapper> theValue,
348 std::shared_ptr<PlaneGCSSolver_PointWrapper> thePoint,
349 std::shared_ptr<PlaneGCSSolver_EntityWrapper> theEntity)
351 std::shared_ptr<GCS::Line> aLine = std::dynamic_pointer_cast<GCS::Line>(theEntity->entity());
352 GCSConstraintPtr aNewConstr(new GCS::ConstraintP2LDistance(
353 *(thePoint->point()), *(aLine), theValue->scalar()));
354 std::shared_ptr<PlaneGCSSolver_ConstraintWrapper> aResult(
355 new PlaneGCSSolver_ConstraintWrapper(aNewConstr, CONSTRAINT_PT_LINE_DISTANCE));
356 aResult->setValueParameter(theValue);
360 ConstraintWrapperPtr createConstraintRadius(
361 std::shared_ptr<PlaneGCSSolver_ScalarWrapper> theValue,
362 std::shared_ptr<PlaneGCSSolver_EntityWrapper> theEntity)
364 std::shared_ptr<GCS::Circle> aCircle =
365 std::dynamic_pointer_cast<GCS::Circle>(theEntity->entity());
366 GCSConstraintPtr aNewConstr(new GCS::ConstraintEqual(aCircle->rad, theValue->scalar()));
367 std::shared_ptr<PlaneGCSSolver_ConstraintWrapper> aResult(
368 new PlaneGCSSolver_ConstraintWrapper(aNewConstr, CONSTRAINT_RADIUS));
369 aResult->setValueParameter(theValue);
373 ConstraintWrapperPtr createConstraintAngle(
374 ConstraintPtr theConstraint,
375 std::shared_ptr<PlaneGCSSolver_ScalarWrapper> theValue,
376 std::shared_ptr<PlaneGCSSolver_EntityWrapper> theEntity1,
377 std::shared_ptr<PlaneGCSSolver_EntityWrapper> theEntity2)
379 std::shared_ptr<GCS::Line> aLine1 = std::dynamic_pointer_cast<GCS::Line>(theEntity1->entity());
380 bool isLine1Rev = theConstraint->boolean(
381 SketchPlugin_ConstraintAngle::ANGLE_REVERSED_FIRST_LINE_ID())->value();
382 GCS::Point aLine1Pt1 = isLine1Rev ? aLine1->p2 : aLine1->p1;
383 GCS::Point aLine1Pt2 = isLine1Rev ? aLine1->p1 : aLine1->p2;
385 std::shared_ptr<GCS::Line> aLine2 = std::dynamic_pointer_cast<GCS::Line>(theEntity2->entity());
386 bool isLine2Rev = theConstraint->boolean(
387 SketchPlugin_ConstraintAngle::ANGLE_REVERSED_SECOND_LINE_ID())->value();
388 GCS::Point aLine2Pt1 = isLine2Rev ? aLine2->p2 : aLine2->p1;
389 GCS::Point aLine2Pt2 = isLine2Rev ? aLine2->p1 : aLine2->p2;
391 GCSConstraintPtr aNewConstr(new GCS::ConstraintL2LAngle(
392 aLine1Pt1, aLine1Pt2, aLine2Pt1, aLine2Pt2, theValue->scalar()));
394 std::shared_ptr<PlaneGCSSolver_ConstraintWrapper> aResult(
395 new PlaneGCSSolver_ConstraintWrapper(aNewConstr, CONSTRAINT_ANGLE));
396 aResult->setValueParameter(theValue);
400 ConstraintWrapperPtr createConstraintHorizVert(
401 const SketchSolver_ConstraintType& theType,
402 std::shared_ptr<PlaneGCSSolver_EntityWrapper> theEntity)
404 std::shared_ptr<GCS::Line> aLine = std::dynamic_pointer_cast<GCS::Line>(theEntity->entity());
405 GCSConstraintPtr aNewConstr;
406 if (theType == CONSTRAINT_HORIZONTAL)
407 aNewConstr = GCSConstraintPtr(new GCS::ConstraintEqual(aLine->p1.y, aLine->p2.y));
409 aNewConstr = GCSConstraintPtr(new GCS::ConstraintEqual(aLine->p1.x, aLine->p2.x));
411 return ConstraintWrapperPtr(new PlaneGCSSolver_ConstraintWrapper(aNewConstr, theType));
414 ConstraintWrapperPtr createConstraintCollinear(
415 ConstraintPtr theConstraint,
416 std::shared_ptr<PlaneGCSSolver_EntityWrapper> theEntity1,
417 std::shared_ptr<PlaneGCSSolver_EntityWrapper> theEntity2)
419 std::shared_ptr<GCS::Line> aLine1 = std::dynamic_pointer_cast<GCS::Line>(theEntity1->entity());
420 std::shared_ptr<GCS::Line> aLine2 = std::dynamic_pointer_cast<GCS::Line>(theEntity2->entity());
422 // create two point-on-line constraints
423 std::list<GCSConstraintPtr> aConstrList;
424 aConstrList.push_back( GCSConstraintPtr(new GCS::ConstraintPointOnLine(aLine2->p1, *aLine1)) );
425 aConstrList.push_back( GCSConstraintPtr(new GCS::ConstraintPointOnLine(aLine2->p2, *aLine1)) );
427 return ConstraintWrapperPtr(
428 new PlaneGCSSolver_ConstraintWrapper(aConstrList, CONSTRAINT_COLLINEAR));
431 ConstraintWrapperPtr createConstraintParallel(
432 std::shared_ptr<PlaneGCSSolver_EntityWrapper> theEntity1,
433 std::shared_ptr<PlaneGCSSolver_EntityWrapper> theEntity2)
435 std::shared_ptr<GCS::Line> aLine1 = std::dynamic_pointer_cast<GCS::Line>(theEntity1->entity());
436 std::shared_ptr<GCS::Line> aLine2 = std::dynamic_pointer_cast<GCS::Line>(theEntity2->entity());
437 GCSConstraintPtr aNewConstr(new GCS::ConstraintParallel(*(aLine1), *(aLine2)));
439 return ConstraintWrapperPtr(
440 new PlaneGCSSolver_ConstraintWrapper(aNewConstr, CONSTRAINT_PARALLEL));
443 ConstraintWrapperPtr createConstraintPerpendicular(
444 std::shared_ptr<PlaneGCSSolver_EntityWrapper> theEntity1,
445 std::shared_ptr<PlaneGCSSolver_EntityWrapper> theEntity2)
447 std::shared_ptr<GCS::Line> aLine1 = std::dynamic_pointer_cast<GCS::Line>(theEntity1->entity());
448 std::shared_ptr<GCS::Line> aLine2 = std::dynamic_pointer_cast<GCS::Line>(theEntity2->entity());
449 GCSConstraintPtr aNewConstr(new GCS::ConstraintPerpendicular(*(aLine1), *(aLine2)));
451 return ConstraintWrapperPtr(
452 new PlaneGCSSolver_ConstraintWrapper(aNewConstr, CONSTRAINT_PERPENDICULAR));
455 ConstraintWrapperPtr createConstraintEqual(
456 const SketchSolver_ConstraintType& theType,
457 std::shared_ptr<PlaneGCSSolver_EntityWrapper> theEntity1,
458 std::shared_ptr<PlaneGCSSolver_EntityWrapper> theEntity2,
459 std::shared_ptr<PlaneGCSSolver_ScalarWrapper> theIntermed)
461 if (theType == CONSTRAINT_EQUAL_LINE_ARC)
462 return ConstraintWrapperPtr(); // line-arc equivalence is not supported yet
464 std::list<GCSConstraintPtr> aConstrList;
465 if (theType == CONSTRAINT_EQUAL_LINES) {
466 std::shared_ptr<GCS::Line> aLine1 = std::dynamic_pointer_cast<GCS::Line>(theEntity1->entity());
467 std::shared_ptr<GCS::Line> aLine2 = std::dynamic_pointer_cast<GCS::Line>(theEntity2->entity());
469 aConstrList.push_back(GCSConstraintPtr(
470 new GCS::ConstraintP2PDistance(aLine1->p1, aLine1->p2, theIntermed->scalar())));
471 aConstrList.push_back(GCSConstraintPtr(
472 new GCS::ConstraintP2PDistance(aLine2->p1, aLine2->p2, theIntermed->scalar())));
473 // update value of intermediate parameter
474 double x = *aLine1->p1.x - *aLine1->p2.x;
475 double y = *aLine1->p1.y - *aLine1->p2.y;
476 double aLen = sqrt(x*x + y*y);
477 theIntermed->setValue(aLen);
479 std::shared_ptr<GCS::Circle> aCirc1 =
480 std::dynamic_pointer_cast<GCS::Circle>(theEntity1->entity());
481 std::shared_ptr<GCS::Circle> aCirc2 =
482 std::dynamic_pointer_cast<GCS::Circle>(theEntity2->entity());
484 aConstrList.push_back(GCSConstraintPtr(new GCS::ConstraintEqual(aCirc1->rad, aCirc2->rad)));
487 std::shared_ptr<PlaneGCSSolver_ConstraintWrapper> aResult(
488 new PlaneGCSSolver_ConstraintWrapper(aConstrList, theType));
490 aResult->setValueParameter(theIntermed);
494 ConstraintWrapperPtr createConstraintTangent(
495 const SketchSolver_ConstraintType& theType,
496 std::shared_ptr<PlaneGCSSolver_EntityWrapper> theEntity1,
497 std::shared_ptr<PlaneGCSSolver_EntityWrapper> theEntity2)
499 GCSConstraintPtr aNewConstr;
500 if (theType == CONSTRAINT_TANGENT_CIRCLE_LINE) {
501 std::shared_ptr<GCS::Circle> aCirc =
502 std::dynamic_pointer_cast<GCS::Circle>(theEntity1->entity());
503 std::shared_ptr<GCS::Line> aLine =
504 std::dynamic_pointer_cast<GCS::Line>(theEntity2->entity());
507 GCSConstraintPtr(new GCS::ConstraintP2LDistance(aCirc->center, *aLine, aCirc->rad));
509 std::shared_ptr<GCS::Circle> aCirc1 =
510 std::dynamic_pointer_cast<GCS::Circle>(theEntity1->entity());
511 std::shared_ptr<GCS::Circle> aCirc2 =
512 std::dynamic_pointer_cast<GCS::Circle>(theEntity2->entity());
514 double aDX = *(aCirc1->center.x) - *(aCirc2->center.x);
515 double aDY = *(aCirc1->center.y) - *(aCirc2->center.y);
516 double aDist = sqrt(aDX * aDX + aDY * aDY);
517 aNewConstr = GCSConstraintPtr(new GCS::ConstraintTangentCircumf(aCirc1->center, aCirc2->center,
518 aCirc1->rad, aCirc2->rad, (aDist < *(aCirc1->rad) || aDist < *(aCirc2->rad))));
521 return ConstraintWrapperPtr(new PlaneGCSSolver_ConstraintWrapper(aNewConstr, theType));
524 bool PlaneGCSSolver_Tools::isArcArcTangencyInternal(
525 EntityWrapperPtr theArc1, EntityWrapperPtr theArc2)
527 std::shared_ptr<GCS::Circle> aCirc1 = std::dynamic_pointer_cast<GCS::Circle>(
528 GCS_ENTITY_WRAPPER(theArc1)->entity());
529 std::shared_ptr<GCS::Circle> aCirc2 = std::dynamic_pointer_cast<GCS::Circle>(
530 GCS_ENTITY_WRAPPER(theArc2)->entity());
532 if (!aCirc1 || !aCirc2)
535 double aDX = *(aCirc1->center.x) - *(aCirc2->center.x);
536 double aDY = *(aCirc1->center.y) - *(aCirc2->center.y);
537 double aDist = sqrt(aDX * aDX + aDY * aDY);
539 return (aDist < *(aCirc1->rad) || aDist < *(aCirc2->rad));