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 <SketchPlugin_ConstraintCoincidenceInternal.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>
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>
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)
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 std::shared_ptr<PlaneGCSSolver_PointWrapper> theAuxParameters);
113 static GCS::SET_pD scalarParameters(const ScalarWrapperPtr& theScalar);
114 static GCS::SET_pD pointParameters(const PointWrapperPtr& thePoint);
115 static GCS::SET_pD lineParameters(const EdgeWrapperPtr& theLine);
116 static GCS::SET_pD circleParameters(const EdgeWrapperPtr& theCircle);
117 static GCS::SET_pD arcParameters(const EdgeWrapperPtr& theArc);
118 static GCS::SET_pD ellipseParameters(const EdgeWrapperPtr& theEllipse);
124 SolverConstraintPtr PlaneGCSSolver_Tools::createConstraint(ConstraintPtr theConstraint)
126 if (theConstraint->getKind() == SketchPlugin_ConstraintCoincidence::ID() ||
127 theConstraint->getKind() == SketchPlugin_ConstraintCoincidenceInternal::ID()) {
128 return SolverConstraintPtr(new SketchSolver_ConstraintCoincidence(theConstraint));
129 } else if (theConstraint->getKind() == SketchPlugin_ConstraintCollinear::ID()) {
130 return SolverConstraintPtr(new SketchSolver_ConstraintCollinear(theConstraint));
131 } else if (theConstraint->getKind() == SketchPlugin_ConstraintDistance::ID() ||
132 theConstraint->getKind() == SketchPlugin_ConstraintDistanceHorizontal::ID() ||
133 theConstraint->getKind() == SketchPlugin_ConstraintDistanceVertical::ID()) {
134 return SolverConstraintPtr(new SketchSolver_ConstraintDistance(theConstraint));
135 } else if (theConstraint->getKind() == SketchPlugin_ConstraintEqual::ID()) {
136 return SolverConstraintPtr(new SketchSolver_ConstraintEqual(theConstraint));
137 } else if (theConstraint->getKind() == SketchPlugin_ConstraintLength::ID()) {
138 return SolverConstraintPtr(new SketchSolver_ConstraintLength(theConstraint));
139 } else if (theConstraint->getKind() == SketchPlugin_ConstraintMiddle::ID()) {
140 return SolverConstraintPtr(new SketchSolver_ConstraintMiddle(theConstraint));
141 } else if (theConstraint->getKind() == SketchPlugin_ConstraintMirror::ID()) {
142 return SolverConstraintPtr(new SketchSolver_ConstraintMirror(theConstraint));
143 } else if (theConstraint->getKind() == SketchPlugin_ConstraintTangent::ID()) {
144 return SolverConstraintPtr(new SketchSolver_ConstraintTangent(theConstraint));
145 } else if (theConstraint->getKind() == SketchPlugin_ConstraintRigid::ID()) {
146 return SolverConstraintPtr(new SketchSolver_ConstraintFixed(theConstraint));
147 } else if (theConstraint->getKind() == SketchPlugin_MultiTranslation::ID()) {
148 return SolverConstraintPtr(new SketchSolver_ConstraintMultiTranslation(theConstraint));
149 } else if (theConstraint->getKind() == SketchPlugin_MultiRotation::ID()) {
150 return SolverConstraintPtr(new SketchSolver_ConstraintMultiRotation(theConstraint));
151 } else if (theConstraint->getKind() == SketchPlugin_ConstraintAngle::ID()) {
152 return SolverConstraintPtr(new SketchSolver_ConstraintAngle(theConstraint));
154 // All other types of constraints
155 return SolverConstraintPtr(new SketchSolver_Constraint(theConstraint));
158 std::shared_ptr<SketchSolver_ConstraintMovement> PlaneGCSSolver_Tools::createMovementConstraint(
159 FeaturePtr theMovedFeature)
161 return std::shared_ptr<SketchSolver_ConstraintMovement>(
162 new SketchSolver_ConstraintMovement(theMovedFeature));
165 std::shared_ptr<SketchSolver_ConstraintMovement> PlaneGCSSolver_Tools::createMovementConstraint(
166 AttributePtr theMovedAttribute)
168 return std::shared_ptr<SketchSolver_ConstraintMovement>(
169 new SketchSolver_ConstraintMovement(theMovedAttribute));
174 ConstraintWrapperPtr PlaneGCSSolver_Tools::createConstraint(
175 ConstraintPtr theConstraint,
176 const SketchSolver_ConstraintType& theType,
177 const EntityWrapperPtr& theValue,
178 const EntityWrapperPtr& thePoint1,
179 const EntityWrapperPtr& thePoint2,
180 const EntityWrapperPtr& theEntity1,
181 const EntityWrapperPtr& theEntity2)
183 ConstraintWrapperPtr aResult;
184 ScalarWrapperPtr anIntermediate;
186 std::shared_ptr<PlaneGCSSolver_PointWrapper> aPoint1 = GCS_POINT_WRAPPER(thePoint1);
187 std::shared_ptr<PlaneGCSSolver_PointWrapper> aPoint2 = GCS_POINT_WRAPPER(thePoint2);
190 case CONSTRAINT_PT_PT_COINCIDENT:
191 aResult = createConstraintCoincidence(aPoint1, aPoint2);
193 case CONSTRAINT_PT_ON_LINE:
194 case CONSTRAINT_PT_ON_CIRCLE:
195 case CONSTRAINT_PT_ON_ELLIPSE:
196 aResult = createConstraintPointOnEntity(theType, aPoint1, GCS_EDGE_WRAPPER(theEntity1));
198 case CONSTRAINT_MIDDLE_POINT:
199 aResult = createConstraintMiddlePoint(aPoint1, GCS_EDGE_WRAPPER(theEntity1), aPoint2);
201 case CONSTRAINT_PT_PT_DISTANCE:
202 aResult = createConstraintDistancePointPoint(GCS_SCALAR_WRAPPER(theValue), aPoint1, aPoint2);
204 case CONSTRAINT_PT_LINE_DISTANCE:
205 aResult = createConstraintDistancePointLine(GCS_SCALAR_WRAPPER(theValue),
207 GCS_EDGE_WRAPPER(theEntity1));
209 case CONSTRAINT_HORIZONTAL_DISTANCE:
210 case CONSTRAINT_VERTICAL_DISTANCE:
211 aResult = createConstraintHVDistance(theType, GCS_SCALAR_WRAPPER(theValue), aPoint1, aPoint2);
213 case CONSTRAINT_RADIUS:
214 aResult = createConstraintRadius(GCS_SCALAR_WRAPPER(theValue),
215 GCS_EDGE_WRAPPER(theEntity1));
217 case CONSTRAINT_ANGLE:
218 aResult = createConstraintAngle(theConstraint,
219 GCS_SCALAR_WRAPPER(theValue),
220 GCS_EDGE_WRAPPER(theEntity1), GCS_EDGE_WRAPPER(theEntity2));
222 case CONSTRAINT_FIXED:
224 case CONSTRAINT_HORIZONTAL:
225 case CONSTRAINT_VERTICAL:
226 aResult = createConstraintHorizVert(theType, GCS_EDGE_WRAPPER(theEntity1));
228 case CONSTRAINT_PARALLEL:
229 aResult = createConstraintParallel(GCS_EDGE_WRAPPER(theEntity1),
230 GCS_EDGE_WRAPPER(theEntity2));
232 case CONSTRAINT_PERPENDICULAR:
233 aResult = createConstraintPerpendicular(GCS_EDGE_WRAPPER(theEntity1),
234 GCS_EDGE_WRAPPER(theEntity2));
236 case CONSTRAINT_EQUAL_LINES:
237 anIntermediate = GCS_SCALAR_WRAPPER(theValue); // parameter is used to store length of lines
238 case CONSTRAINT_EQUAL_LINE_ARC:
239 case CONSTRAINT_EQUAL_RADIUS:
240 aResult = createConstraintEqual(theType,
241 GCS_EDGE_WRAPPER(theEntity1),
242 GCS_EDGE_WRAPPER(theEntity2),
252 std::shared_ptr<GeomAPI_Pnt2d> PlaneGCSSolver_Tools::point(EntityWrapperPtr theEntity)
254 if (theEntity->type() != ENTITY_POINT)
255 return std::shared_ptr<GeomAPI_Pnt2d>();
257 std::shared_ptr<PlaneGCSSolver_PointWrapper> aPointWrapper =
258 std::dynamic_pointer_cast<PlaneGCSSolver_PointWrapper>(theEntity);
259 const GCSPointPtr& aPoint = aPointWrapper->point();
260 return std::shared_ptr<GeomAPI_Pnt2d>(new GeomAPI_Pnt2d(*aPoint->x, *aPoint->y));
263 std::shared_ptr<GeomAPI_Lin2d> PlaneGCSSolver_Tools::line(EntityWrapperPtr theEntity)
265 if (theEntity->type() != ENTITY_LINE)
266 return std::shared_ptr<GeomAPI_Lin2d>();
268 std::shared_ptr<PlaneGCSSolver_EdgeWrapper> anEntity =
269 std::dynamic_pointer_cast<PlaneGCSSolver_EdgeWrapper>(theEntity);
270 std::shared_ptr<GCS::Line> aLine = std::dynamic_pointer_cast<GCS::Line>(anEntity->entity());
271 return std::shared_ptr<GeomAPI_Lin2d>(
272 new GeomAPI_Lin2d(*(aLine->p1.x), *(aLine->p1.y), *(aLine->p2.x), *(aLine->p2.y)));
275 std::shared_ptr<GeomAPI_Lin2d> PlaneGCSSolver_Tools::line(FeaturePtr theFeature)
277 if (theFeature->getKind() != SketchPlugin_Line::ID())
278 return std::shared_ptr<GeomAPI_Lin2d>();
280 AttributePoint2DPtr aStart = std::dynamic_pointer_cast<GeomDataAPI_Point2D>(
281 theFeature->attribute(SketchPlugin_Line::START_ID()));
282 AttributePoint2DPtr aEnd = std::dynamic_pointer_cast<GeomDataAPI_Point2D>(
283 theFeature->attribute(SketchPlugin_Line::END_ID()));
285 return std::shared_ptr<GeomAPI_Lin2d>(new GeomAPI_Lin2d(aStart->pnt(), aEnd->pnt()));
289 GCS::SET_pD PlaneGCSSolver_Tools::parameters(const EntityWrapperPtr& theEntity)
291 switch (theEntity->type()) {
294 return scalarParameters(GCS_SCALAR_WRAPPER(theEntity));
296 return pointParameters(GCS_POINT_WRAPPER(theEntity));
298 return lineParameters(GCS_EDGE_WRAPPER(theEntity));
300 return circleParameters(GCS_EDGE_WRAPPER(theEntity));
302 return arcParameters(GCS_EDGE_WRAPPER(theEntity));
304 return ellipseParameters(GCS_EDGE_WRAPPER(theEntity));
307 return GCS::SET_pD();
315 // ================ Auxiliary functions ==========================
316 ConstraintWrapperPtr createConstraintCoincidence(
317 std::shared_ptr<PlaneGCSSolver_PointWrapper> thePoint1,
318 std::shared_ptr<PlaneGCSSolver_PointWrapper> thePoint2)
320 GCSPointPtr aPoint1 = thePoint1->point();
321 GCSPointPtr aPoint2 = thePoint2->point();
323 // Create equality constraint for corresponding attributes of the points
324 std::list<GCSConstraintPtr> aConstrList;
325 aConstrList.push_back(
326 GCSConstraintPtr(new GCS::ConstraintEqual(aPoint1->x, aPoint2->x)));
327 aConstrList.push_back(
328 GCSConstraintPtr(new GCS::ConstraintEqual(aPoint1->y, aPoint2->y)));
330 return ConstraintWrapperPtr(new PlaneGCSSolver_ConstraintWrapper(
331 aConstrList, CONSTRAINT_PT_PT_COINCIDENT));
334 ConstraintWrapperPtr createConstraintPointOnEntity(
335 const SketchSolver_ConstraintType& theType,
336 std::shared_ptr<PlaneGCSSolver_PointWrapper> thePoint,
337 std::shared_ptr<PlaneGCSSolver_EdgeWrapper> theEntity)
339 GCSConstraintPtr aNewConstr;
341 switch (theEntity->type()) {
343 std::shared_ptr<GCS::Line> aLine = std::dynamic_pointer_cast<GCS::Line>(theEntity->entity());
344 aNewConstr = GCSConstraintPtr(new GCS::ConstraintPointOnLine(*(thePoint->point()), *aLine));
348 case ENTITY_CIRCLE: {
349 std::shared_ptr<GCS::Circle> aCirc =
350 std::dynamic_pointer_cast<GCS::Circle>(theEntity->entity());
351 aNewConstr = GCSConstraintPtr(
352 new GCS::ConstraintP2PDistance(*(thePoint->point()), aCirc->center, aCirc->rad));
356 case ENTITY_ELLIPTICAL_ARC: {
357 std::shared_ptr<GCS::Ellipse> anEllipse =
358 std::dynamic_pointer_cast<GCS::Ellipse>(theEntity->entity());
359 aNewConstr = GCSConstraintPtr(
360 new GCS::ConstraintPointOnEllipse(*(thePoint->point()), *anEllipse));
364 return ConstraintWrapperPtr();
367 return ConstraintWrapperPtr(new PlaneGCSSolver_ConstraintWrapper(aNewConstr, theType));
370 ConstraintWrapperPtr createConstraintMiddlePoint(
371 std::shared_ptr<PlaneGCSSolver_PointWrapper> thePoint,
372 std::shared_ptr<PlaneGCSSolver_EdgeWrapper> theEntity,
373 std::shared_ptr<PlaneGCSSolver_PointWrapper> theAuxParameters)
375 std::list<GCSConstraintPtr> aConstrList;
377 GCSPointPtr aPoint = thePoint->point();
378 std::shared_ptr<GCS::Line> aLine = std::dynamic_pointer_cast<GCS::Line>(theEntity->entity());
380 aConstrList.push_back(GCSConstraintPtr(new GCS::ConstraintPointOnLine(*aPoint, *aLine)));
381 aConstrList.push_back(
382 GCSConstraintPtr(new GCS::ConstraintPointOnPerpBisector(*aPoint, aLine->p1, aLine->p2)));
385 std::shared_ptr<GCS::Arc> anArc = std::dynamic_pointer_cast<GCS::Arc>(theEntity->entity());
387 double* u = theAuxParameters->point()->x;
388 double* diff = theAuxParameters->point()->y;
389 *u = (*anArc->startAngle + *anArc->endAngle) * 0.5;
390 *diff = (*anArc->endAngle - *anArc->startAngle) * 0.5;
392 aConstrList.push_back(GCSConstraintPtr(
393 new GCS::ConstraintCurveValue(*aPoint, aPoint->x, *anArc, u)));
394 aConstrList.push_back(GCSConstraintPtr(
395 new GCS::ConstraintCurveValue(*aPoint, aPoint->y, *anArc, u)));
396 aConstrList.push_back(GCSConstraintPtr(
397 new GCS::ConstraintDifference(anArc->startAngle, u, diff)));
398 aConstrList.push_back(GCSConstraintPtr(
399 new GCS::ConstraintDifference(u, anArc->endAngle, diff)));
403 return aConstrList.empty() ? ConstraintWrapperPtr() : ConstraintWrapperPtr(
404 new PlaneGCSSolver_ConstraintWrapper(aConstrList, CONSTRAINT_MIDDLE_POINT));
408 ConstraintWrapperPtr createConstraintDistancePointPoint(
409 std::shared_ptr<PlaneGCSSolver_ScalarWrapper> theValue,
410 std::shared_ptr<PlaneGCSSolver_PointWrapper> thePoint1,
411 std::shared_ptr<PlaneGCSSolver_PointWrapper> thePoint2)
413 GCSConstraintPtr aNewConstr(new GCS::ConstraintP2PDistance(
414 *(thePoint1->point()), *(thePoint2->point()), theValue->scalar()));
415 std::shared_ptr<PlaneGCSSolver_ConstraintWrapper> aResult(
416 new PlaneGCSSolver_ConstraintWrapper(aNewConstr, CONSTRAINT_PT_PT_DISTANCE));
417 aResult->setValueParameter(theValue);
421 ConstraintWrapperPtr createConstraintDistancePointLine(
422 std::shared_ptr<PlaneGCSSolver_ScalarWrapper> theValue,
423 std::shared_ptr<PlaneGCSSolver_PointWrapper> thePoint,
424 std::shared_ptr<PlaneGCSSolver_EdgeWrapper> theEntity)
426 std::shared_ptr<GCS::Line> aLine = std::dynamic_pointer_cast<GCS::Line>(theEntity->entity());
427 GCSConstraintPtr aNewConstr(new GCS::ConstraintP2LDistance(
428 *(thePoint->point()), *(aLine), theValue->scalar()));
429 std::shared_ptr<PlaneGCSSolver_ConstraintWrapper> aResult(
430 new PlaneGCSSolver_ConstraintWrapper(aNewConstr, CONSTRAINT_PT_LINE_DISTANCE));
431 aResult->setValueParameter(theValue);
435 ConstraintWrapperPtr createConstraintHVDistance(
436 const SketchSolver_ConstraintType& theType,
437 std::shared_ptr<PlaneGCSSolver_ScalarWrapper> theValue,
438 std::shared_ptr<PlaneGCSSolver_PointWrapper> thePoint1,
439 std::shared_ptr<PlaneGCSSolver_PointWrapper> thePoint2)
441 GCSPointPtr aPoint1 = thePoint1->point();
442 GCSPointPtr aPoint2 = thePoint2->point();
444 double *aParam1, *aParam2;
445 if (theType == CONSTRAINT_HORIZONTAL_DISTANCE) {
446 aParam1 = aPoint1->x;
447 aParam2 = aPoint2->x;
448 } else if (theType == CONSTRAINT_VERTICAL_DISTANCE) {
449 aParam1 = aPoint1->y;
450 aParam2 = aPoint2->y;
453 GCSConstraintPtr aNewConstr(new GCS::ConstraintDifference(aParam1, aParam2, theValue->scalar()));
455 std::shared_ptr<PlaneGCSSolver_ConstraintWrapper> aResult(
456 new PlaneGCSSolver_ConstraintWrapper(aNewConstr, theType));
457 aResult->setValueParameter(theValue);
461 ConstraintWrapperPtr createConstraintRadius(
462 std::shared_ptr<PlaneGCSSolver_ScalarWrapper> theValue,
463 std::shared_ptr<PlaneGCSSolver_EdgeWrapper> theEntity)
465 std::shared_ptr<GCS::Circle> aCircle =
466 std::dynamic_pointer_cast<GCS::Circle>(theEntity->entity());
467 GCSConstraintPtr aNewConstr(new GCS::ConstraintEqual(aCircle->rad, theValue->scalar()));
468 std::shared_ptr<PlaneGCSSolver_ConstraintWrapper> aResult(
469 new PlaneGCSSolver_ConstraintWrapper(aNewConstr, CONSTRAINT_RADIUS));
470 aResult->setValueParameter(theValue);
474 ConstraintWrapperPtr createConstraintAngle(
475 ConstraintPtr theConstraint,
476 std::shared_ptr<PlaneGCSSolver_ScalarWrapper> theValue,
477 std::shared_ptr<PlaneGCSSolver_EdgeWrapper> theEntity1,
478 std::shared_ptr<PlaneGCSSolver_EdgeWrapper> theEntity2)
480 std::shared_ptr<GCS::Line> aLine1 = std::dynamic_pointer_cast<GCS::Line>(theEntity1->entity());
481 bool isLine1Rev = theConstraint->boolean(
482 SketchPlugin_ConstraintAngle::ANGLE_REVERSED_FIRST_LINE_ID())->value();
483 GCS::Point aLine1Pt1 = isLine1Rev ? aLine1->p2 : aLine1->p1;
484 GCS::Point aLine1Pt2 = isLine1Rev ? aLine1->p1 : aLine1->p2;
486 std::shared_ptr<GCS::Line> aLine2 = std::dynamic_pointer_cast<GCS::Line>(theEntity2->entity());
487 bool isLine2Rev = theConstraint->boolean(
488 SketchPlugin_ConstraintAngle::ANGLE_REVERSED_SECOND_LINE_ID())->value();
489 GCS::Point aLine2Pt1 = isLine2Rev ? aLine2->p2 : aLine2->p1;
490 GCS::Point aLine2Pt2 = isLine2Rev ? aLine2->p1 : aLine2->p2;
492 GCSConstraintPtr aNewConstr(new GCS::ConstraintL2LAngle(
493 aLine1Pt1, aLine1Pt2, aLine2Pt1, aLine2Pt2, theValue->scalar()));
495 std::shared_ptr<PlaneGCSSolver_ConstraintWrapper> aResult(
496 new PlaneGCSSolver_ConstraintWrapper(aNewConstr, CONSTRAINT_ANGLE));
497 aResult->setValueParameter(theValue);
501 ConstraintWrapperPtr createConstraintHorizVert(
502 const SketchSolver_ConstraintType& theType,
503 std::shared_ptr<PlaneGCSSolver_EdgeWrapper> theEntity)
505 std::shared_ptr<GCS::Line> aLine = std::dynamic_pointer_cast<GCS::Line>(theEntity->entity());
506 GCSConstraintPtr aNewConstr;
507 if (theType == CONSTRAINT_HORIZONTAL)
508 aNewConstr = GCSConstraintPtr(new GCS::ConstraintEqual(aLine->p1.y, aLine->p2.y));
510 aNewConstr = GCSConstraintPtr(new GCS::ConstraintEqual(aLine->p1.x, aLine->p2.x));
512 return ConstraintWrapperPtr(new PlaneGCSSolver_ConstraintWrapper(aNewConstr, theType));
515 ConstraintWrapperPtr createConstraintParallel(
516 std::shared_ptr<PlaneGCSSolver_EdgeWrapper> theEntity1,
517 std::shared_ptr<PlaneGCSSolver_EdgeWrapper> theEntity2)
519 std::shared_ptr<GCS::Line> aLine1 = std::dynamic_pointer_cast<GCS::Line>(theEntity1->entity());
520 std::shared_ptr<GCS::Line> aLine2 = std::dynamic_pointer_cast<GCS::Line>(theEntity2->entity());
521 GCSConstraintPtr aNewConstr(new GCS::ConstraintParallel(*(aLine1), *(aLine2)));
523 return ConstraintWrapperPtr(
524 new PlaneGCSSolver_ConstraintWrapper(aNewConstr, CONSTRAINT_PARALLEL));
527 ConstraintWrapperPtr createConstraintPerpendicular(
528 std::shared_ptr<PlaneGCSSolver_EdgeWrapper> theEntity1,
529 std::shared_ptr<PlaneGCSSolver_EdgeWrapper> theEntity2)
531 std::shared_ptr<GCS::Line> aLine1 = std::dynamic_pointer_cast<GCS::Line>(theEntity1->entity());
532 std::shared_ptr<GCS::Line> aLine2 = std::dynamic_pointer_cast<GCS::Line>(theEntity2->entity());
534 std::shared_ptr<GCS::Circle> aCirc1 =
535 std::dynamic_pointer_cast<GCS::Circle>(theEntity1->entity());
536 std::shared_ptr<GCS::Circle> aCirc2 =
537 std::dynamic_pointer_cast<GCS::Circle>(theEntity2->entity());
539 GCSConstraintPtr aNewConstr;
540 if (aLine1 && aLine2)
541 aNewConstr.reset(new GCS::ConstraintPerpendicular(*(aLine1), *(aLine2)));
543 if (aLine1 && aCirc2)
545 else if (aLine2 && aCirc1)
548 aNewConstr.reset(new GCS::ConstraintPointOnLine(aCirc1->center, *aLine1));
551 return ConstraintWrapperPtr(
552 new PlaneGCSSolver_ConstraintWrapper(aNewConstr, CONSTRAINT_PERPENDICULAR));
555 ConstraintWrapperPtr createConstraintEqual(
556 const SketchSolver_ConstraintType& theType,
557 std::shared_ptr<PlaneGCSSolver_EdgeWrapper> theEntity1,
558 std::shared_ptr<PlaneGCSSolver_EdgeWrapper> theEntity2,
559 std::shared_ptr<PlaneGCSSolver_ScalarWrapper> theIntermed)
561 if (theType == CONSTRAINT_EQUAL_LINE_ARC)
562 return ConstraintWrapperPtr(); // line-arc equivalence is not supported yet
564 std::list<GCSConstraintPtr> aConstrList;
565 if (theType == CONSTRAINT_EQUAL_LINES) {
566 std::shared_ptr<GCS::Line> aLine1 = std::dynamic_pointer_cast<GCS::Line>(theEntity1->entity());
567 std::shared_ptr<GCS::Line> aLine2 = std::dynamic_pointer_cast<GCS::Line>(theEntity2->entity());
569 aConstrList.push_back(GCSConstraintPtr(
570 new GCS::ConstraintP2PDistance(aLine1->p1, aLine1->p2, theIntermed->scalar())));
571 aConstrList.push_back(GCSConstraintPtr(
572 new GCS::ConstraintP2PDistance(aLine2->p1, aLine2->p2, theIntermed->scalar())));
573 // update value of intermediate parameter
574 double x = *aLine1->p1.x - *aLine1->p2.x;
575 double y = *aLine1->p1.y - *aLine1->p2.y;
576 double aLen = sqrt(x*x + y*y);
577 theIntermed->setValue(aLen);
579 std::shared_ptr<GCS::Circle> aCirc1 =
580 std::dynamic_pointer_cast<GCS::Circle>(theEntity1->entity());
581 std::shared_ptr<GCS::Circle> aCirc2 =
582 std::dynamic_pointer_cast<GCS::Circle>(theEntity2->entity());
584 if (aCirc1 && aCirc2)
585 aConstrList.push_back(GCSConstraintPtr(new GCS::ConstraintEqual(aCirc1->rad, aCirc2->rad)));
587 std::shared_ptr<GCS::Ellipse> anEllipse1 =
588 std::dynamic_pointer_cast<GCS::Ellipse>(theEntity1->entity());
589 std::shared_ptr<GCS::Ellipse> anEllipse2 =
590 std::dynamic_pointer_cast<GCS::Ellipse>(theEntity2->entity());
592 aConstrList.push_back(GCSConstraintPtr(
593 new GCS::ConstraintEqual(anEllipse1->radmin, anEllipse2->radmin)));
594 aConstrList.push_back(GCSConstraintPtr(
595 new GCS::ConstraintEqualMajorAxesConic(anEllipse1.get(), anEllipse2.get())));
599 std::shared_ptr<PlaneGCSSolver_ConstraintWrapper> aResult(
600 new PlaneGCSSolver_ConstraintWrapper(aConstrList, theType));
602 aResult->setValueParameter(theIntermed);
606 GCS::SET_pD scalarParameters(const ScalarWrapperPtr& theScalar)
609 aParams.insert(theScalar->scalar());
613 GCS::SET_pD pointParameters(const PointWrapperPtr& thePoint)
616 aParams.insert(thePoint->point()->x);
617 aParams.insert(thePoint->point()->y);
621 GCS::SET_pD lineParameters(const EdgeWrapperPtr& theLine)
624 std::shared_ptr<GCS::Line> aLine = std::dynamic_pointer_cast<GCS::Line>(theLine->entity());
625 aParams.insert(aLine->p1.x);
626 aParams.insert(aLine->p1.y);
627 aParams.insert(aLine->p2.x);
628 aParams.insert(aLine->p2.y);
632 GCS::SET_pD circleParameters(const EdgeWrapperPtr& theCircle)
635 std::shared_ptr<GCS::Circle> aCirc = std::dynamic_pointer_cast<GCS::Circle>(theCircle->entity());
636 aParams.insert(aCirc->center.x);
637 aParams.insert(aCirc->center.y);
638 aParams.insert(aCirc->rad);
642 GCS::SET_pD arcParameters(const EdgeWrapperPtr& theArc)
645 std::shared_ptr<GCS::Arc> anArc = std::dynamic_pointer_cast<GCS::Arc>(theArc->entity());
646 aParams.insert(anArc->center.x);
647 aParams.insert(anArc->center.y);
648 aParams.insert(anArc->start.x);
649 aParams.insert(anArc->start.y);
650 aParams.insert(anArc->end.x);
651 aParams.insert(anArc->end.y);
652 aParams.insert(anArc->startAngle);
653 aParams.insert(anArc->endAngle);
654 aParams.insert(anArc->rad);
658 GCS::SET_pD ellipseParameters(const EdgeWrapperPtr& theEllipse)
661 std::shared_ptr<GCS::Ellipse> anEllipse =
662 std::dynamic_pointer_cast<GCS::Ellipse>(theEllipse->entity());
663 aParams.insert(anEllipse->center.x);
664 aParams.insert(anEllipse->center.y);
665 aParams.insert(anEllipse->focus1.x);
666 aParams.insert(anEllipse->focus1.y);
667 aParams.insert(anEllipse->radmin);