1 // Copyright (C) 2014-2019 CEA/DEN, EDF R&D
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.
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.
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
17 // See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
20 #include <PlaneGCSSolver_Tools.h>
21 #include <PlaneGCSSolver_EdgeWrapper.h>
22 #include <PlaneGCSSolver_PointWrapper.h>
23 #include <PlaneGCSSolver_ScalarWrapper.h>
24 #include <PlaneGCSSolver_ConstraintWrapper.h>
26 #include <SketchSolver_Constraint.h>
27 #include <SketchSolver_ConstraintAngle.h>
28 #include <SketchSolver_ConstraintCoincidence.h>
29 #include <SketchSolver_ConstraintCollinear.h>
30 #include <SketchSolver_ConstraintDistance.h>
31 #include <SketchSolver_ConstraintEqual.h>
32 #include <SketchSolver_ConstraintFixed.h>
33 #include <SketchSolver_ConstraintLength.h>
34 #include <SketchSolver_ConstraintMiddle.h>
35 #include <SketchSolver_ConstraintMirror.h>
36 #include <SketchSolver_ConstraintTangent.h>
37 #include <SketchSolver_ConstraintMultiRotation.h>
38 #include <SketchSolver_ConstraintMultiTranslation.h>
40 #include <SketchPlugin_ConstraintAngle.h>
41 #include <SketchPlugin_ConstraintCoincidence.h>
42 #include <SketchPlugin_ConstraintCollinear.h>
43 #include <SketchPlugin_ConstraintDistance.h>
44 #include <SketchPlugin_ConstraintDistanceHorizontal.h>
45 #include <SketchPlugin_ConstraintDistanceVertical.h>
46 #include <SketchPlugin_ConstraintEqual.h>
47 #include <SketchPlugin_ConstraintLength.h>
48 #include <SketchPlugin_ConstraintMiddle.h>
49 #include <SketchPlugin_ConstraintMirror.h>
50 #include <SketchPlugin_ConstraintRigid.h>
51 #include <SketchPlugin_ConstraintTangent.h>
52 #include <SketchPlugin_Line.h>
53 #include <SketchPlugin_MultiRotation.h>
54 #include <SketchPlugin_MultiTranslation.h>
59 #define GCS_EDGE_WRAPPER(x) std::dynamic_pointer_cast<PlaneGCSSolver_EdgeWrapper>(x)
60 #define GCS_POINT_WRAPPER(x) std::dynamic_pointer_cast<PlaneGCSSolver_PointWrapper>(x)
61 #define GCS_SCALAR_WRAPPER(x) std::dynamic_pointer_cast<PlaneGCSSolver_ScalarWrapper>(x)
65 static ConstraintWrapperPtr
66 createConstraintCoincidence(std::shared_ptr<PlaneGCSSolver_PointWrapper> thePoint1,
67 std::shared_ptr<PlaneGCSSolver_PointWrapper> thePoint2);
68 static ConstraintWrapperPtr
69 createConstraintPointOnEntity(const SketchSolver_ConstraintType& theType,
70 std::shared_ptr<PlaneGCSSolver_PointWrapper> thePoint,
71 std::shared_ptr<PlaneGCSSolver_EdgeWrapper> theEntity);
72 static ConstraintWrapperPtr
73 createConstraintDistancePointPoint(std::shared_ptr<PlaneGCSSolver_ScalarWrapper> theValue,
74 std::shared_ptr<PlaneGCSSolver_PointWrapper> thePoint1,
75 std::shared_ptr<PlaneGCSSolver_PointWrapper> thePoint2);
76 static ConstraintWrapperPtr
77 createConstraintDistancePointLine(std::shared_ptr<PlaneGCSSolver_ScalarWrapper> theValue,
78 std::shared_ptr<PlaneGCSSolver_PointWrapper> thePoint,
79 std::shared_ptr<PlaneGCSSolver_EdgeWrapper> theEntity);
80 static ConstraintWrapperPtr
81 createConstraintHVDistance(const SketchSolver_ConstraintType& theType,
82 std::shared_ptr<PlaneGCSSolver_ScalarWrapper> theValue,
83 std::shared_ptr<PlaneGCSSolver_PointWrapper> thePoint1,
84 std::shared_ptr<PlaneGCSSolver_PointWrapper> thePoint2);
85 static ConstraintWrapperPtr
86 createConstraintRadius(std::shared_ptr<PlaneGCSSolver_ScalarWrapper> theValue,
87 std::shared_ptr<PlaneGCSSolver_EdgeWrapper> theEntity);
88 static ConstraintWrapperPtr
89 createConstraintAngle(ConstraintPtr theConstraint,
90 std::shared_ptr<PlaneGCSSolver_ScalarWrapper> theValue,
91 std::shared_ptr<PlaneGCSSolver_EdgeWrapper> theEntity1,
92 std::shared_ptr<PlaneGCSSolver_EdgeWrapper> theEntity2);
93 static ConstraintWrapperPtr
94 createConstraintHorizVert(const SketchSolver_ConstraintType& theType,
95 std::shared_ptr<PlaneGCSSolver_EdgeWrapper> theEntity);
96 static ConstraintWrapperPtr
97 createConstraintParallel(std::shared_ptr<PlaneGCSSolver_EdgeWrapper> theEntity1,
98 std::shared_ptr<PlaneGCSSolver_EdgeWrapper> theEntity2);
99 static ConstraintWrapperPtr
100 createConstraintPerpendicular(std::shared_ptr<PlaneGCSSolver_EdgeWrapper> theEntity1,
101 std::shared_ptr<PlaneGCSSolver_EdgeWrapper> theEntity2);
102 static ConstraintWrapperPtr
103 createConstraintEqual(const SketchSolver_ConstraintType& theType,
104 std::shared_ptr<PlaneGCSSolver_EdgeWrapper> theEntity1,
105 std::shared_ptr<PlaneGCSSolver_EdgeWrapper> theEntity2,
106 std::shared_ptr<PlaneGCSSolver_ScalarWrapper> theIntermed);
107 static ConstraintWrapperPtr
108 createConstraintMiddlePoint(std::shared_ptr<PlaneGCSSolver_PointWrapper> thePoint,
109 std::shared_ptr<PlaneGCSSolver_EdgeWrapper> theEntity,
110 std::shared_ptr<PlaneGCSSolver_PointWrapper> theAuxParameters);
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);
122 SolverConstraintPtr PlaneGCSSolver_Tools::createConstraint(ConstraintPtr theConstraint)
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));
151 // All other types of constraints
152 return SolverConstraintPtr(new SketchSolver_Constraint(theConstraint));
155 std::shared_ptr<SketchSolver_ConstraintMovement> PlaneGCSSolver_Tools::createMovementConstraint(
156 FeaturePtr theMovedFeature)
158 return std::shared_ptr<SketchSolver_ConstraintMovement>(
159 new SketchSolver_ConstraintMovement(theMovedFeature));
162 std::shared_ptr<SketchSolver_ConstraintMovement> PlaneGCSSolver_Tools::createMovementConstraint(
163 AttributePtr theMovedAttribute)
165 return std::shared_ptr<SketchSolver_ConstraintMovement>(
166 new SketchSolver_ConstraintMovement(theMovedAttribute));
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)
180 ConstraintWrapperPtr aResult;
181 ScalarWrapperPtr anIntermediate;
183 std::shared_ptr<PlaneGCSSolver_PointWrapper> aPoint1 = GCS_POINT_WRAPPER(thePoint1);
184 std::shared_ptr<PlaneGCSSolver_PointWrapper> aPoint2 = GCS_POINT_WRAPPER(thePoint2);
187 case CONSTRAINT_PT_PT_COINCIDENT:
188 aResult = createConstraintCoincidence(aPoint1, aPoint2);
190 case CONSTRAINT_PT_ON_LINE:
191 case CONSTRAINT_PT_ON_CIRCLE:
192 aResult = createConstraintPointOnEntity(theType, aPoint1, GCS_EDGE_WRAPPER(theEntity1));
194 case CONSTRAINT_MIDDLE_POINT:
195 aResult = createConstraintMiddlePoint(aPoint1, GCS_EDGE_WRAPPER(theEntity1), aPoint2);
197 case CONSTRAINT_PT_PT_DISTANCE:
198 aResult = createConstraintDistancePointPoint(GCS_SCALAR_WRAPPER(theValue), aPoint1, aPoint2);
200 case CONSTRAINT_PT_LINE_DISTANCE:
201 aResult = createConstraintDistancePointLine(GCS_SCALAR_WRAPPER(theValue),
203 GCS_EDGE_WRAPPER(theEntity1));
205 case CONSTRAINT_HORIZONTAL_DISTANCE:
206 case CONSTRAINT_VERTICAL_DISTANCE:
207 aResult = createConstraintHVDistance(theType, GCS_SCALAR_WRAPPER(theValue), aPoint1, aPoint2);
209 case CONSTRAINT_RADIUS:
210 aResult = createConstraintRadius(GCS_SCALAR_WRAPPER(theValue),
211 GCS_EDGE_WRAPPER(theEntity1));
213 case CONSTRAINT_ANGLE:
214 aResult = createConstraintAngle(theConstraint,
215 GCS_SCALAR_WRAPPER(theValue),
216 GCS_EDGE_WRAPPER(theEntity1), GCS_EDGE_WRAPPER(theEntity2));
218 case CONSTRAINT_FIXED:
220 case CONSTRAINT_HORIZONTAL:
221 case CONSTRAINT_VERTICAL:
222 aResult = createConstraintHorizVert(theType, GCS_EDGE_WRAPPER(theEntity1));
224 case CONSTRAINT_PARALLEL:
225 aResult = createConstraintParallel(GCS_EDGE_WRAPPER(theEntity1),
226 GCS_EDGE_WRAPPER(theEntity2));
228 case CONSTRAINT_PERPENDICULAR:
229 aResult = createConstraintPerpendicular(GCS_EDGE_WRAPPER(theEntity1),
230 GCS_EDGE_WRAPPER(theEntity2));
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),
248 std::shared_ptr<GeomAPI_Pnt2d> PlaneGCSSolver_Tools::point(EntityWrapperPtr theEntity)
250 if (theEntity->type() != ENTITY_POINT)
251 return std::shared_ptr<GeomAPI_Pnt2d>();
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));
259 std::shared_ptr<GeomAPI_Lin2d> PlaneGCSSolver_Tools::line(EntityWrapperPtr theEntity)
261 if (theEntity->type() != ENTITY_LINE)
262 return std::shared_ptr<GeomAPI_Lin2d>();
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)));
271 std::shared_ptr<GeomAPI_Lin2d> PlaneGCSSolver_Tools::line(FeaturePtr theFeature)
273 if (theFeature->getKind() != SketchPlugin_Line::ID())
274 return std::shared_ptr<GeomAPI_Lin2d>();
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()));
281 return std::shared_ptr<GeomAPI_Lin2d>(new GeomAPI_Lin2d(aStart->pnt(), aEnd->pnt()));
285 GCS::SET_pD PlaneGCSSolver_Tools::parameters(const EntityWrapperPtr& theEntity)
287 switch (theEntity->type()) {
290 return scalarParameters(GCS_SCALAR_WRAPPER(theEntity));
292 return pointParameters(GCS_POINT_WRAPPER(theEntity));
294 return lineParameters(GCS_EDGE_WRAPPER(theEntity));
296 return circleParameters(GCS_EDGE_WRAPPER(theEntity));
298 return arcParameters(GCS_EDGE_WRAPPER(theEntity));
301 return GCS::SET_pD();
309 // ================ Auxiliary functions ==========================
310 ConstraintWrapperPtr createConstraintCoincidence(
311 std::shared_ptr<PlaneGCSSolver_PointWrapper> thePoint1,
312 std::shared_ptr<PlaneGCSSolver_PointWrapper> thePoint2)
314 GCSPointPtr aPoint1 = thePoint1->point();
315 GCSPointPtr aPoint2 = thePoint2->point();
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)));
324 return ConstraintWrapperPtr(new PlaneGCSSolver_ConstraintWrapper(
325 aConstrList, CONSTRAINT_PT_PT_COINCIDENT));
328 ConstraintWrapperPtr createConstraintPointOnEntity(
329 const SketchSolver_ConstraintType& theType,
330 std::shared_ptr<PlaneGCSSolver_PointWrapper> thePoint,
331 std::shared_ptr<PlaneGCSSolver_EdgeWrapper> theEntity)
333 GCSConstraintPtr aNewConstr;
335 switch (theEntity->type()) {
337 std::shared_ptr<GCS::Line> aLine = std::dynamic_pointer_cast<GCS::Line>(theEntity->entity());
338 aNewConstr = GCSConstraintPtr(new GCS::ConstraintPointOnLine(*(thePoint->point()), *aLine));
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));
350 return ConstraintWrapperPtr();
353 return ConstraintWrapperPtr(new PlaneGCSSolver_ConstraintWrapper(aNewConstr, theType));
356 ConstraintWrapperPtr createConstraintMiddlePoint(
357 std::shared_ptr<PlaneGCSSolver_PointWrapper> thePoint,
358 std::shared_ptr<PlaneGCSSolver_EdgeWrapper> theEntity,
359 std::shared_ptr<PlaneGCSSolver_PointWrapper> theAuxParameters)
361 std::list<GCSConstraintPtr> aConstrList;
363 GCSPointPtr aPoint = thePoint->point();
364 std::shared_ptr<GCS::Line> aLine = std::dynamic_pointer_cast<GCS::Line>(theEntity->entity());
366 aConstrList.push_back(GCSConstraintPtr(new GCS::ConstraintPointOnLine(*aPoint, *aLine)));
367 aConstrList.push_back(
368 GCSConstraintPtr(new GCS::ConstraintPointOnPerpBisector(*aPoint, aLine->p1, aLine->p2)));
371 std::shared_ptr<GCS::Arc> anArc = std::dynamic_pointer_cast<GCS::Arc>(theEntity->entity());
373 double* u = theAuxParameters->point()->x;
374 double* diff = theAuxParameters->point()->y;
375 *u = (*anArc->startAngle + *anArc->endAngle) * 0.5;
376 *diff = (*anArc->endAngle - *anArc->startAngle) * 0.5;
378 aConstrList.push_back(GCSConstraintPtr(
379 new GCS::ConstraintCurveValue(*aPoint, aPoint->x, *anArc, u)));
380 aConstrList.push_back(GCSConstraintPtr(
381 new GCS::ConstraintCurveValue(*aPoint, aPoint->y, *anArc, u)));
382 aConstrList.push_back(GCSConstraintPtr(
383 new GCS::ConstraintDifference(anArc->startAngle, u, diff)));
384 aConstrList.push_back(GCSConstraintPtr(
385 new GCS::ConstraintDifference(u, anArc->endAngle, diff)));
389 return aConstrList.empty() ? ConstraintWrapperPtr() : ConstraintWrapperPtr(
390 new PlaneGCSSolver_ConstraintWrapper(aConstrList, CONSTRAINT_MIDDLE_POINT));
394 ConstraintWrapperPtr createConstraintDistancePointPoint(
395 std::shared_ptr<PlaneGCSSolver_ScalarWrapper> theValue,
396 std::shared_ptr<PlaneGCSSolver_PointWrapper> thePoint1,
397 std::shared_ptr<PlaneGCSSolver_PointWrapper> thePoint2)
399 GCSConstraintPtr aNewConstr(new GCS::ConstraintP2PDistance(
400 *(thePoint1->point()), *(thePoint2->point()), theValue->scalar()));
401 std::shared_ptr<PlaneGCSSolver_ConstraintWrapper> aResult(
402 new PlaneGCSSolver_ConstraintWrapper(aNewConstr, CONSTRAINT_PT_PT_DISTANCE));
403 aResult->setValueParameter(theValue);
407 ConstraintWrapperPtr createConstraintDistancePointLine(
408 std::shared_ptr<PlaneGCSSolver_ScalarWrapper> theValue,
409 std::shared_ptr<PlaneGCSSolver_PointWrapper> thePoint,
410 std::shared_ptr<PlaneGCSSolver_EdgeWrapper> theEntity)
412 std::shared_ptr<GCS::Line> aLine = std::dynamic_pointer_cast<GCS::Line>(theEntity->entity());
413 GCSConstraintPtr aNewConstr(new GCS::ConstraintP2LDistance(
414 *(thePoint->point()), *(aLine), theValue->scalar()));
415 std::shared_ptr<PlaneGCSSolver_ConstraintWrapper> aResult(
416 new PlaneGCSSolver_ConstraintWrapper(aNewConstr, CONSTRAINT_PT_LINE_DISTANCE));
417 aResult->setValueParameter(theValue);
421 ConstraintWrapperPtr createConstraintHVDistance(
422 const SketchSolver_ConstraintType& theType,
423 std::shared_ptr<PlaneGCSSolver_ScalarWrapper> theValue,
424 std::shared_ptr<PlaneGCSSolver_PointWrapper> thePoint1,
425 std::shared_ptr<PlaneGCSSolver_PointWrapper> thePoint2)
427 GCSPointPtr aPoint1 = thePoint1->point();
428 GCSPointPtr aPoint2 = thePoint2->point();
430 double *aParam1, *aParam2;
431 if (theType == CONSTRAINT_HORIZONTAL_DISTANCE) {
432 aParam1 = aPoint1->x;
433 aParam2 = aPoint2->x;
434 } else if (theType == CONSTRAINT_VERTICAL_DISTANCE) {
435 aParam1 = aPoint1->y;
436 aParam2 = aPoint2->y;
439 GCSConstraintPtr aNewConstr(new GCS::ConstraintDifference(aParam1, aParam2, theValue->scalar()));
441 std::shared_ptr<PlaneGCSSolver_ConstraintWrapper> aResult(
442 new PlaneGCSSolver_ConstraintWrapper(aNewConstr, theType));
443 aResult->setValueParameter(theValue);
447 ConstraintWrapperPtr createConstraintRadius(
448 std::shared_ptr<PlaneGCSSolver_ScalarWrapper> theValue,
449 std::shared_ptr<PlaneGCSSolver_EdgeWrapper> theEntity)
451 std::shared_ptr<GCS::Circle> aCircle =
452 std::dynamic_pointer_cast<GCS::Circle>(theEntity->entity());
453 GCSConstraintPtr aNewConstr(new GCS::ConstraintEqual(aCircle->rad, theValue->scalar()));
454 std::shared_ptr<PlaneGCSSolver_ConstraintWrapper> aResult(
455 new PlaneGCSSolver_ConstraintWrapper(aNewConstr, CONSTRAINT_RADIUS));
456 aResult->setValueParameter(theValue);
460 ConstraintWrapperPtr createConstraintAngle(
461 ConstraintPtr theConstraint,
462 std::shared_ptr<PlaneGCSSolver_ScalarWrapper> theValue,
463 std::shared_ptr<PlaneGCSSolver_EdgeWrapper> theEntity1,
464 std::shared_ptr<PlaneGCSSolver_EdgeWrapper> theEntity2)
466 std::shared_ptr<GCS::Line> aLine1 = std::dynamic_pointer_cast<GCS::Line>(theEntity1->entity());
467 bool isLine1Rev = theConstraint->boolean(
468 SketchPlugin_ConstraintAngle::ANGLE_REVERSED_FIRST_LINE_ID())->value();
469 GCS::Point aLine1Pt1 = isLine1Rev ? aLine1->p2 : aLine1->p1;
470 GCS::Point aLine1Pt2 = isLine1Rev ? aLine1->p1 : aLine1->p2;
472 std::shared_ptr<GCS::Line> aLine2 = std::dynamic_pointer_cast<GCS::Line>(theEntity2->entity());
473 bool isLine2Rev = theConstraint->boolean(
474 SketchPlugin_ConstraintAngle::ANGLE_REVERSED_SECOND_LINE_ID())->value();
475 GCS::Point aLine2Pt1 = isLine2Rev ? aLine2->p2 : aLine2->p1;
476 GCS::Point aLine2Pt2 = isLine2Rev ? aLine2->p1 : aLine2->p2;
478 GCSConstraintPtr aNewConstr(new GCS::ConstraintL2LAngle(
479 aLine1Pt1, aLine1Pt2, aLine2Pt1, aLine2Pt2, theValue->scalar()));
481 std::shared_ptr<PlaneGCSSolver_ConstraintWrapper> aResult(
482 new PlaneGCSSolver_ConstraintWrapper(aNewConstr, CONSTRAINT_ANGLE));
483 aResult->setValueParameter(theValue);
487 ConstraintWrapperPtr createConstraintHorizVert(
488 const SketchSolver_ConstraintType& theType,
489 std::shared_ptr<PlaneGCSSolver_EdgeWrapper> theEntity)
491 std::shared_ptr<GCS::Line> aLine = std::dynamic_pointer_cast<GCS::Line>(theEntity->entity());
492 GCSConstraintPtr aNewConstr;
493 if (theType == CONSTRAINT_HORIZONTAL)
494 aNewConstr = GCSConstraintPtr(new GCS::ConstraintEqual(aLine->p1.y, aLine->p2.y));
496 aNewConstr = GCSConstraintPtr(new GCS::ConstraintEqual(aLine->p1.x, aLine->p2.x));
498 return ConstraintWrapperPtr(new PlaneGCSSolver_ConstraintWrapper(aNewConstr, theType));
501 ConstraintWrapperPtr createConstraintParallel(
502 std::shared_ptr<PlaneGCSSolver_EdgeWrapper> theEntity1,
503 std::shared_ptr<PlaneGCSSolver_EdgeWrapper> theEntity2)
505 std::shared_ptr<GCS::Line> aLine1 = std::dynamic_pointer_cast<GCS::Line>(theEntity1->entity());
506 std::shared_ptr<GCS::Line> aLine2 = std::dynamic_pointer_cast<GCS::Line>(theEntity2->entity());
507 GCSConstraintPtr aNewConstr(new GCS::ConstraintParallel(*(aLine1), *(aLine2)));
509 return ConstraintWrapperPtr(
510 new PlaneGCSSolver_ConstraintWrapper(aNewConstr, CONSTRAINT_PARALLEL));
513 ConstraintWrapperPtr createConstraintPerpendicular(
514 std::shared_ptr<PlaneGCSSolver_EdgeWrapper> theEntity1,
515 std::shared_ptr<PlaneGCSSolver_EdgeWrapper> theEntity2)
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());
520 std::shared_ptr<GCS::Circle> aCirc1 =
521 std::dynamic_pointer_cast<GCS::Circle>(theEntity1->entity());
522 std::shared_ptr<GCS::Circle> aCirc2 =
523 std::dynamic_pointer_cast<GCS::Circle>(theEntity2->entity());
525 GCSConstraintPtr aNewConstr;
526 if (aLine1 && aLine2)
527 aNewConstr.reset(new GCS::ConstraintPerpendicular(*(aLine1), *(aLine2)));
529 if (aLine1 && aCirc2)
531 else if (aLine2 && aCirc1)
534 aNewConstr.reset(new GCS::ConstraintPointOnLine(aCirc1->center, *aLine1));
537 return ConstraintWrapperPtr(
538 new PlaneGCSSolver_ConstraintWrapper(aNewConstr, CONSTRAINT_PERPENDICULAR));
541 ConstraintWrapperPtr createConstraintEqual(
542 const SketchSolver_ConstraintType& theType,
543 std::shared_ptr<PlaneGCSSolver_EdgeWrapper> theEntity1,
544 std::shared_ptr<PlaneGCSSolver_EdgeWrapper> theEntity2,
545 std::shared_ptr<PlaneGCSSolver_ScalarWrapper> theIntermed)
547 if (theType == CONSTRAINT_EQUAL_LINE_ARC)
548 return ConstraintWrapperPtr(); // line-arc equivalence is not supported yet
550 std::list<GCSConstraintPtr> aConstrList;
551 if (theType == CONSTRAINT_EQUAL_LINES) {
552 std::shared_ptr<GCS::Line> aLine1 = std::dynamic_pointer_cast<GCS::Line>(theEntity1->entity());
553 std::shared_ptr<GCS::Line> aLine2 = std::dynamic_pointer_cast<GCS::Line>(theEntity2->entity());
555 aConstrList.push_back(GCSConstraintPtr(
556 new GCS::ConstraintP2PDistance(aLine1->p1, aLine1->p2, theIntermed->scalar())));
557 aConstrList.push_back(GCSConstraintPtr(
558 new GCS::ConstraintP2PDistance(aLine2->p1, aLine2->p2, theIntermed->scalar())));
559 // update value of intermediate parameter
560 double x = *aLine1->p1.x - *aLine1->p2.x;
561 double y = *aLine1->p1.y - *aLine1->p2.y;
562 double aLen = sqrt(x*x + y*y);
563 theIntermed->setValue(aLen);
565 std::shared_ptr<GCS::Circle> aCirc1 =
566 std::dynamic_pointer_cast<GCS::Circle>(theEntity1->entity());
567 std::shared_ptr<GCS::Circle> aCirc2 =
568 std::dynamic_pointer_cast<GCS::Circle>(theEntity2->entity());
570 aConstrList.push_back(GCSConstraintPtr(new GCS::ConstraintEqual(aCirc1->rad, aCirc2->rad)));
573 std::shared_ptr<PlaneGCSSolver_ConstraintWrapper> aResult(
574 new PlaneGCSSolver_ConstraintWrapper(aConstrList, theType));
576 aResult->setValueParameter(theIntermed);
580 GCS::SET_pD scalarParameters(const ScalarWrapperPtr& theScalar)
583 aParams.insert(theScalar->scalar());
587 GCS::SET_pD pointParameters(const PointWrapperPtr& thePoint)
590 aParams.insert(thePoint->point()->x);
591 aParams.insert(thePoint->point()->y);
595 GCS::SET_pD lineParameters(const EdgeWrapperPtr& theLine)
598 std::shared_ptr<GCS::Line> aLine = std::dynamic_pointer_cast<GCS::Line>(theLine->entity());
599 aParams.insert(aLine->p1.x);
600 aParams.insert(aLine->p1.y);
601 aParams.insert(aLine->p2.x);
602 aParams.insert(aLine->p2.y);
606 GCS::SET_pD circleParameters(const EdgeWrapperPtr& theCircle)
609 std::shared_ptr<GCS::Circle> aCirc = std::dynamic_pointer_cast<GCS::Circle>(theCircle->entity());
610 aParams.insert(aCirc->center.x);
611 aParams.insert(aCirc->center.y);
612 aParams.insert(aCirc->rad);
616 GCS::SET_pD arcParameters(const EdgeWrapperPtr& theArc)
619 std::shared_ptr<GCS::Arc> anArc = std::dynamic_pointer_cast<GCS::Arc>(theArc->entity());
620 aParams.insert(anArc->center.x);
621 aParams.insert(anArc->center.y);
622 aParams.insert(anArc->start.x);
623 aParams.insert(anArc->start.y);
624 aParams.insert(anArc->end.x);
625 aParams.insert(anArc->end.y);
626 aParams.insert(anArc->startAngle);
627 aParams.insert(anArc->endAngle);
628 aParams.insert(anArc->rad);