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>
57 #include <GeomAPI_Circ2d.h>
58 #include <GeomAPI_Dir2d.h>
59 #include <GeomAPI_Ellipse2d.h>
60 #include <GeomAPI_Lin2d.h>
61 #include <GeomAPI_Pnt2d.h>
66 #define GCS_EDGE_WRAPPER(x) std::dynamic_pointer_cast<PlaneGCSSolver_EdgeWrapper>(x)
67 #define GCS_POINT_WRAPPER(x) std::dynamic_pointer_cast<PlaneGCSSolver_PointWrapper>(x)
68 #define GCS_SCALAR_WRAPPER(x) std::dynamic_pointer_cast<PlaneGCSSolver_ScalarWrapper>(x)
72 static ConstraintWrapperPtr
73 createConstraintCoincidence(std::shared_ptr<PlaneGCSSolver_PointWrapper> thePoint1,
74 std::shared_ptr<PlaneGCSSolver_PointWrapper> thePoint2);
75 static ConstraintWrapperPtr
76 createConstraintPointOnEntity(const SketchSolver_ConstraintType& theType,
77 std::shared_ptr<PlaneGCSSolver_PointWrapper> thePoint,
78 std::shared_ptr<PlaneGCSSolver_EdgeWrapper> theEntity);
79 static ConstraintWrapperPtr
80 createConstraintPointsCollinear(std::shared_ptr<PlaneGCSSolver_PointWrapper> thePoint1,
81 std::shared_ptr<PlaneGCSSolver_PointWrapper> thePoint2,
82 std::shared_ptr<PlaneGCSSolver_PointWrapper> thePoint3);
83 static ConstraintWrapperPtr
84 createConstraintDistancePointPoint(std::shared_ptr<PlaneGCSSolver_ScalarWrapper> theValue,
85 std::shared_ptr<PlaneGCSSolver_PointWrapper> thePoint1,
86 std::shared_ptr<PlaneGCSSolver_PointWrapper> thePoint2);
87 static ConstraintWrapperPtr
88 createConstraintDistancePointLine(std::shared_ptr<PlaneGCSSolver_ScalarWrapper> theValue,
89 std::shared_ptr<PlaneGCSSolver_PointWrapper> thePoint,
90 std::shared_ptr<PlaneGCSSolver_EdgeWrapper> theEntity);
91 static ConstraintWrapperPtr
92 createConstraintHVDistance(const SketchSolver_ConstraintType& theType,
93 std::shared_ptr<PlaneGCSSolver_ScalarWrapper> theValue,
94 std::shared_ptr<PlaneGCSSolver_PointWrapper> thePoint1,
95 std::shared_ptr<PlaneGCSSolver_PointWrapper> thePoint2);
96 static ConstraintWrapperPtr
97 createConstraintRadius(std::shared_ptr<PlaneGCSSolver_ScalarWrapper> theValue,
98 std::shared_ptr<PlaneGCSSolver_EdgeWrapper> theEntity);
99 static ConstraintWrapperPtr
100 createConstraintAngle(ConstraintPtr theConstraint,
101 std::shared_ptr<PlaneGCSSolver_ScalarWrapper> theValue,
102 std::shared_ptr<PlaneGCSSolver_EdgeWrapper> theEntity1,
103 std::shared_ptr<PlaneGCSSolver_EdgeWrapper> theEntity2);
104 static ConstraintWrapperPtr
105 createConstraintHorizVert(const SketchSolver_ConstraintType& theType,
106 std::shared_ptr<PlaneGCSSolver_EdgeWrapper> theEntity);
107 static ConstraintWrapperPtr
108 createConstraintParallel(std::shared_ptr<PlaneGCSSolver_EdgeWrapper> theEntity1,
109 std::shared_ptr<PlaneGCSSolver_EdgeWrapper> theEntity2);
110 static ConstraintWrapperPtr
111 createConstraintPerpendicular(std::shared_ptr<PlaneGCSSolver_EdgeWrapper> theEntity1,
112 std::shared_ptr<PlaneGCSSolver_EdgeWrapper> theEntity2);
113 static ConstraintWrapperPtr
114 createConstraintEqual(const SketchSolver_ConstraintType& theType,
115 std::shared_ptr<PlaneGCSSolver_EdgeWrapper> theEntity1,
116 std::shared_ptr<PlaneGCSSolver_EdgeWrapper> theEntity2,
117 std::shared_ptr<PlaneGCSSolver_ScalarWrapper> theIntermed);
118 static ConstraintWrapperPtr
119 createConstraintMiddlePoint(std::shared_ptr<PlaneGCSSolver_PointWrapper> thePoint,
120 std::shared_ptr<PlaneGCSSolver_EdgeWrapper> theEntity,
121 std::shared_ptr<PlaneGCSSolver_PointWrapper> theAuxParameters);
123 static GCS::SET_pD scalarParameters(const ScalarWrapperPtr& theScalar);
124 static GCS::SET_pD pointParameters(const PointWrapperPtr& thePoint);
125 static GCS::SET_pD lineParameters(const EdgeWrapperPtr& theLine);
126 static GCS::SET_pD circleParameters(const EdgeWrapperPtr& theCircle);
127 static GCS::SET_pD arcParameters(const EdgeWrapperPtr& theArc);
128 static GCS::SET_pD ellipseParameters(const EdgeWrapperPtr& theEllipse);
129 static GCS::SET_pD ellipticArcParameters(const EdgeWrapperPtr& theEllipticArc);
131 static double distance(const GCS::Point& thePnt1, const GCS::Point& thePnt2);
137 SolverConstraintPtr PlaneGCSSolver_Tools::createConstraint(ConstraintPtr theConstraint)
139 if (theConstraint->getKind() == SketchPlugin_ConstraintCoincidence::ID() ||
140 theConstraint->getKind() == SketchPlugin_ConstraintCoincidenceInternal::ID()) {
141 return SolverConstraintPtr(new SketchSolver_ConstraintCoincidence(theConstraint));
142 } else if (theConstraint->getKind() == SketchPlugin_ConstraintCollinear::ID()) {
143 return SolverConstraintPtr(new SketchSolver_ConstraintCollinear(theConstraint));
144 } else if (theConstraint->getKind() == SketchPlugin_ConstraintDistance::ID() ||
145 theConstraint->getKind() == SketchPlugin_ConstraintDistanceHorizontal::ID() ||
146 theConstraint->getKind() == SketchPlugin_ConstraintDistanceVertical::ID()) {
147 return SolverConstraintPtr(new SketchSolver_ConstraintDistance(theConstraint));
148 } else if (theConstraint->getKind() == SketchPlugin_ConstraintEqual::ID()) {
149 return SolverConstraintPtr(new SketchSolver_ConstraintEqual(theConstraint));
150 } else if (theConstraint->getKind() == SketchPlugin_ConstraintLength::ID()) {
151 return SolverConstraintPtr(new SketchSolver_ConstraintLength(theConstraint));
152 } else if (theConstraint->getKind() == SketchPlugin_ConstraintMiddle::ID()) {
153 return SolverConstraintPtr(new SketchSolver_ConstraintMiddle(theConstraint));
154 } else if (theConstraint->getKind() == SketchPlugin_ConstraintMirror::ID()) {
155 return SolverConstraintPtr(new SketchSolver_ConstraintMirror(theConstraint));
156 } else if (theConstraint->getKind() == SketchPlugin_ConstraintTangent::ID()) {
157 return SolverConstraintPtr(new SketchSolver_ConstraintTangent(theConstraint));
158 } else if (theConstraint->getKind() == SketchPlugin_ConstraintRigid::ID()) {
159 return SolverConstraintPtr(new SketchSolver_ConstraintFixed(theConstraint));
160 } else if (theConstraint->getKind() == SketchPlugin_MultiTranslation::ID()) {
161 return SolverConstraintPtr(new SketchSolver_ConstraintMultiTranslation(theConstraint));
162 } else if (theConstraint->getKind() == SketchPlugin_MultiRotation::ID()) {
163 return SolverConstraintPtr(new SketchSolver_ConstraintMultiRotation(theConstraint));
164 } else if (theConstraint->getKind() == SketchPlugin_ConstraintAngle::ID()) {
165 return SolverConstraintPtr(new SketchSolver_ConstraintAngle(theConstraint));
167 // All other types of constraints
168 return SolverConstraintPtr(new SketchSolver_Constraint(theConstraint));
171 std::shared_ptr<SketchSolver_ConstraintMovement> PlaneGCSSolver_Tools::createMovementConstraint(
172 FeaturePtr theMovedFeature)
174 return std::shared_ptr<SketchSolver_ConstraintMovement>(
175 new SketchSolver_ConstraintMovement(theMovedFeature));
178 std::shared_ptr<SketchSolver_ConstraintMovement> PlaneGCSSolver_Tools::createMovementConstraint(
179 AttributePtr theMovedAttribute)
181 return std::shared_ptr<SketchSolver_ConstraintMovement>(
182 new SketchSolver_ConstraintMovement(theMovedAttribute));
187 ConstraintWrapperPtr PlaneGCSSolver_Tools::createConstraint(
188 ConstraintPtr theConstraint,
189 const SketchSolver_ConstraintType& theType,
190 const EntityWrapperPtr& theValue,
191 const EntityWrapperPtr& thePoint1,
192 const EntityWrapperPtr& thePoint2,
193 const EntityWrapperPtr& theEntity1,
194 const EntityWrapperPtr& theEntity2)
196 ConstraintWrapperPtr aResult;
197 ScalarWrapperPtr anIntermediate;
199 std::shared_ptr<PlaneGCSSolver_PointWrapper> aPoint1 = GCS_POINT_WRAPPER(thePoint1);
200 std::shared_ptr<PlaneGCSSolver_PointWrapper> aPoint2 = GCS_POINT_WRAPPER(thePoint2);
201 std::shared_ptr<PlaneGCSSolver_EdgeWrapper> anEntity1 = GCS_EDGE_WRAPPER(theEntity1);
204 case CONSTRAINT_PT_PT_COINCIDENT:
205 aResult = createConstraintCoincidence(aPoint1, aPoint2);
207 case CONSTRAINT_PT_ON_CURVE:
208 aResult = anEntity1 ? createConstraintPointOnEntity(theType, aPoint1, anEntity1):
209 createConstraintPointsCollinear(aPoint1, aPoint2, GCS_POINT_WRAPPER(theEntity1));
211 case CONSTRAINT_MIDDLE_POINT:
212 aResult = createConstraintMiddlePoint(aPoint1, GCS_EDGE_WRAPPER(theEntity1), aPoint2);
214 case CONSTRAINT_PT_PT_DISTANCE:
215 aResult = createConstraintDistancePointPoint(GCS_SCALAR_WRAPPER(theValue), aPoint1, aPoint2);
217 case CONSTRAINT_PT_LINE_DISTANCE:
218 aResult = createConstraintDistancePointLine(GCS_SCALAR_WRAPPER(theValue),
222 case CONSTRAINT_HORIZONTAL_DISTANCE:
223 case CONSTRAINT_VERTICAL_DISTANCE:
224 aResult = createConstraintHVDistance(theType, GCS_SCALAR_WRAPPER(theValue), aPoint1, aPoint2);
226 case CONSTRAINT_RADIUS:
227 aResult = createConstraintRadius(GCS_SCALAR_WRAPPER(theValue), anEntity1);
229 case CONSTRAINT_ANGLE:
230 aResult = createConstraintAngle(theConstraint,
231 GCS_SCALAR_WRAPPER(theValue),
232 anEntity1, GCS_EDGE_WRAPPER(theEntity2));
234 case CONSTRAINT_FIXED:
236 case CONSTRAINT_HORIZONTAL:
237 case CONSTRAINT_VERTICAL:
238 aResult = createConstraintHorizVert(theType, anEntity1);
240 case CONSTRAINT_PARALLEL:
241 aResult = createConstraintParallel(anEntity1, GCS_EDGE_WRAPPER(theEntity2));
243 case CONSTRAINT_PERPENDICULAR:
244 aResult = createConstraintPerpendicular(anEntity1, GCS_EDGE_WRAPPER(theEntity2));
246 case CONSTRAINT_EQUAL_LINES:
247 case CONSTRAINT_EQUAL_ELLIPSES:
248 anIntermediate = GCS_SCALAR_WRAPPER(theValue); // parameter is used to store length of lines
249 case CONSTRAINT_EQUAL_LINE_ARC:
250 case CONSTRAINT_EQUAL_RADIUS:
251 aResult = createConstraintEqual(theType,
253 GCS_EDGE_WRAPPER(theEntity2),
263 std::shared_ptr<GeomAPI_Pnt2d> PlaneGCSSolver_Tools::point(EntityWrapperPtr theEntity)
265 if (theEntity->type() != ENTITY_POINT)
266 return std::shared_ptr<GeomAPI_Pnt2d>();
268 std::shared_ptr<PlaneGCSSolver_PointWrapper> aPointWrapper =
269 std::dynamic_pointer_cast<PlaneGCSSolver_PointWrapper>(theEntity);
270 const GCSPointPtr& aPoint = aPointWrapper->point();
271 return std::shared_ptr<GeomAPI_Pnt2d>(new GeomAPI_Pnt2d(*aPoint->x, *aPoint->y));
274 std::shared_ptr<GeomAPI_Lin2d> PlaneGCSSolver_Tools::line(EntityWrapperPtr theEntity)
276 if (theEntity->type() != ENTITY_LINE)
277 return std::shared_ptr<GeomAPI_Lin2d>();
279 std::shared_ptr<PlaneGCSSolver_EdgeWrapper> anEntity =
280 std::dynamic_pointer_cast<PlaneGCSSolver_EdgeWrapper>(theEntity);
281 std::shared_ptr<GCS::Line> aLine = std::dynamic_pointer_cast<GCS::Line>(anEntity->entity());
282 return std::shared_ptr<GeomAPI_Lin2d>(
283 new GeomAPI_Lin2d(*(aLine->p1.x), *(aLine->p1.y), *(aLine->p2.x), *(aLine->p2.y)));
286 std::shared_ptr<GeomAPI_Lin2d> PlaneGCSSolver_Tools::line(FeaturePtr theFeature)
288 if (theFeature->getKind() != SketchPlugin_Line::ID())
289 return std::shared_ptr<GeomAPI_Lin2d>();
291 AttributePoint2DPtr aStart = std::dynamic_pointer_cast<GeomDataAPI_Point2D>(
292 theFeature->attribute(SketchPlugin_Line::START_ID()));
293 AttributePoint2DPtr aEnd = std::dynamic_pointer_cast<GeomDataAPI_Point2D>(
294 theFeature->attribute(SketchPlugin_Line::END_ID()));
296 return std::shared_ptr<GeomAPI_Lin2d>(new GeomAPI_Lin2d(aStart->pnt(), aEnd->pnt()));
299 std::shared_ptr<GeomAPI_Circ2d> PlaneGCSSolver_Tools::circle(EntityWrapperPtr theEntity)
301 if (theEntity->type() != ENTITY_CIRCLE && theEntity->type() != ENTITY_ARC)
302 return std::shared_ptr<GeomAPI_Circ2d>();
304 std::shared_ptr<PlaneGCSSolver_EdgeWrapper> anEntity =
305 std::dynamic_pointer_cast<PlaneGCSSolver_EdgeWrapper>(theEntity);
306 std::shared_ptr<GCS::Circle> aCirc = std::dynamic_pointer_cast<GCS::Circle>(anEntity->entity());
307 return std::shared_ptr<GeomAPI_Circ2d>(
308 new GeomAPI_Circ2d(*(aCirc->center.x), *(aCirc->center.y), *(aCirc->rad)));
311 std::shared_ptr<GeomAPI_Ellipse2d> PlaneGCSSolver_Tools::ellipse(EntityWrapperPtr theEntity)
313 if (theEntity->type() != ENTITY_ELLIPSE && theEntity->type() != ENTITY_ELLIPTIC_ARC)
314 return std::shared_ptr<GeomAPI_Ellipse2d>();
316 std::shared_ptr<PlaneGCSSolver_EdgeWrapper> anEntity =
317 std::dynamic_pointer_cast<PlaneGCSSolver_EdgeWrapper>(theEntity);
318 std::shared_ptr<GCS::Ellipse> anEllipse =
319 std::dynamic_pointer_cast<GCS::Ellipse>(anEntity->entity());
321 std::shared_ptr<GeomAPI_Pnt2d> aCenter(
322 new GeomAPI_Pnt2d(*(anEllipse->center.x), *(anEllipse->center.y)));
323 std::shared_ptr<GeomAPI_Dir2d> anAxis(new GeomAPI_Dir2d(
324 *(anEllipse->focus1.x) - *(anEllipse->center.x),
325 *(anEllipse->focus1.y) - *(anEllipse->center.y)));
327 return std::shared_ptr<GeomAPI_Ellipse2d>(
328 new GeomAPI_Ellipse2d(aCenter, anAxis, anEllipse->getRadMaj(), *anEllipse->radmin));
331 void PlaneGCSSolver_Tools::recalculateArcParameters(EntityWrapperPtr theArc)
333 std::shared_ptr<PlaneGCSSolver_EdgeWrapper> anEdge =
334 std::dynamic_pointer_cast<PlaneGCSSolver_EdgeWrapper>(theArc);
338 if (anEdge->type() == ENTITY_ARC) {
339 std::shared_ptr<GCS::Arc> anArc = std::dynamic_pointer_cast<GCS::Arc>(anEdge->entity());
341 GCS::Point aCenter = anArc->center;
342 GCS::Point aStartPnt = anArc->start;
343 GCS::Point aEndPnt = anArc->end;
345 *anArc->rad = distance(aCenter, aStartPnt);
347 static GeomDir2dPtr OX(new GeomAPI_Dir2d(1.0, 0.0));
349 GeomDir2dPtr aDir(new GeomAPI_Dir2d(*aStartPnt.x - *aCenter.x, *aStartPnt.y - *aCenter.y));
350 *anArc->startAngle = OX->angle(aDir);
352 aDir.reset(new GeomAPI_Dir2d(*aEndPnt.x - *aCenter.x, *aEndPnt.y - *aCenter.y));
353 *anArc->endAngle = OX->angle(aDir);
355 else if (anEdge->type() == ENTITY_ELLIPTIC_ARC) {
356 std::shared_ptr<GCS::ArcOfEllipse> aEllArc =
357 std::dynamic_pointer_cast<GCS::ArcOfEllipse>(anEdge->entity());
359 GeomPnt2dPtr aCenter(new GeomAPI_Pnt2d(*aEllArc->center.x, *aEllArc->center.y));
360 GeomPnt2dPtr aStartPnt(new GeomAPI_Pnt2d(*aEllArc->start.x, *aEllArc->start.y));
361 GeomPnt2dPtr aEndPnt(new GeomAPI_Pnt2d(*aEllArc->end.x, *aEllArc->end.y));
363 GeomDir2dPtr anAxis(new GeomAPI_Dir2d(*aEllArc->focus1.x - aCenter->x(),
364 *aEllArc->focus1.y - aCenter->y()));
365 GeomAPI_Ellipse2d anEllipse(aCenter, anAxis, aEllArc->getRadMaj(), *aEllArc->radmin);
366 anEllipse.parameter(aStartPnt, 1.e-4, *aEllArc->startAngle);
367 anEllipse.parameter(aEndPnt, 1.e-4, *aEllArc->endAngle);
373 GCS::SET_pD PlaneGCSSolver_Tools::parameters(const EntityWrapperPtr& theEntity)
375 switch (theEntity->type()) {
378 return scalarParameters(GCS_SCALAR_WRAPPER(theEntity));
380 return pointParameters(GCS_POINT_WRAPPER(theEntity));
382 return lineParameters(GCS_EDGE_WRAPPER(theEntity));
384 return circleParameters(GCS_EDGE_WRAPPER(theEntity));
386 return arcParameters(GCS_EDGE_WRAPPER(theEntity));
388 return ellipseParameters(GCS_EDGE_WRAPPER(theEntity));
389 case ENTITY_ELLIPTIC_ARC:
390 return ellipticArcParameters(GCS_EDGE_WRAPPER(theEntity));
393 return GCS::SET_pD();
401 // ================ Auxiliary functions ==========================
402 ConstraintWrapperPtr createConstraintCoincidence(
403 std::shared_ptr<PlaneGCSSolver_PointWrapper> thePoint1,
404 std::shared_ptr<PlaneGCSSolver_PointWrapper> thePoint2)
406 GCSPointPtr aPoint1 = thePoint1->point();
407 GCSPointPtr aPoint2 = thePoint2->point();
409 // Create equality constraint for corresponding attributes of the points
410 std::list<GCSConstraintPtr> aConstrList;
411 aConstrList.push_back(
412 GCSConstraintPtr(new GCS::ConstraintEqual(aPoint1->x, aPoint2->x)));
413 aConstrList.push_back(
414 GCSConstraintPtr(new GCS::ConstraintEqual(aPoint1->y, aPoint2->y)));
416 return ConstraintWrapperPtr(new PlaneGCSSolver_ConstraintWrapper(
417 aConstrList, CONSTRAINT_PT_PT_COINCIDENT));
420 ConstraintWrapperPtr createConstraintPointOnEntity(
421 const SketchSolver_ConstraintType& theType,
422 std::shared_ptr<PlaneGCSSolver_PointWrapper> thePoint,
423 std::shared_ptr<PlaneGCSSolver_EdgeWrapper> theEntity)
425 GCSConstraintPtr aNewConstr;
427 switch (theEntity->type()) {
429 std::shared_ptr<GCS::Line> aLine = std::dynamic_pointer_cast<GCS::Line>(theEntity->entity());
430 aNewConstr = GCSConstraintPtr(new GCS::ConstraintPointOnLine(*(thePoint->point()), *aLine));
434 case ENTITY_CIRCLE: {
435 std::shared_ptr<GCS::Circle> aCirc =
436 std::dynamic_pointer_cast<GCS::Circle>(theEntity->entity());
437 aNewConstr = GCSConstraintPtr(
438 new GCS::ConstraintP2PDistance(*(thePoint->point()), aCirc->center, aCirc->rad));
442 case ENTITY_ELLIPTIC_ARC: {
443 std::shared_ptr<GCS::Ellipse> anEllipse =
444 std::dynamic_pointer_cast<GCS::Ellipse>(theEntity->entity());
445 aNewConstr = GCSConstraintPtr(
446 new GCS::ConstraintPointOnEllipse(*(thePoint->point()), *anEllipse));
450 return ConstraintWrapperPtr();
453 return ConstraintWrapperPtr(new PlaneGCSSolver_ConstraintWrapper(aNewConstr, theType));
456 ConstraintWrapperPtr createConstraintPointsCollinear(
457 std::shared_ptr<PlaneGCSSolver_PointWrapper> thePoint1,
458 std::shared_ptr<PlaneGCSSolver_PointWrapper> thePoint2,
459 std::shared_ptr<PlaneGCSSolver_PointWrapper> thePoint3)
461 GCSConstraintPtr aNewConstr(new GCS::ConstraintPointOnLine(
462 *(thePoint1->point()), *(thePoint2->point()), *(thePoint3->point())));
463 return ConstraintWrapperPtr(
464 new PlaneGCSSolver_ConstraintWrapper(aNewConstr, CONSTRAINT_PT_ON_CURVE));
467 template <typename ARCTYPE>
468 void createConstraintMiddlePointOnArc(ARCTYPE theArc,
469 GCSPointPtr thePoint,
470 std::shared_ptr<PlaneGCSSolver_PointWrapper> theAuxParameters,
471 std::list<GCSConstraintPtr>& theConstraints)
473 double* u = theAuxParameters->point()->x;
474 double* diff = theAuxParameters->point()->y;
475 *u = (*theArc->startAngle + *theArc->endAngle) * 0.5;
476 *diff = (*theArc->endAngle - *theArc->startAngle) * 0.5;
478 theConstraints.push_back(GCSConstraintPtr(
479 new GCS::ConstraintCurveValue(*thePoint, thePoint->x, *theArc, u)));
480 theConstraints.push_back(GCSConstraintPtr(
481 new GCS::ConstraintCurveValue(*thePoint, thePoint->y, *theArc, u)));
482 theConstraints.push_back(GCSConstraintPtr(
483 new GCS::ConstraintDifference(theArc->startAngle, u, diff)));
484 theConstraints.push_back(GCSConstraintPtr(
485 new GCS::ConstraintDifference(u, theArc->endAngle, diff)));
488 ConstraintWrapperPtr createConstraintMiddlePoint(
489 std::shared_ptr<PlaneGCSSolver_PointWrapper> thePoint,
490 std::shared_ptr<PlaneGCSSolver_EdgeWrapper> theEntity,
491 std::shared_ptr<PlaneGCSSolver_PointWrapper> theAuxParameters)
493 std::list<GCSConstraintPtr> aConstrList;
495 GCSPointPtr aPoint = thePoint->point();
496 std::shared_ptr<GCS::Line> aLine = std::dynamic_pointer_cast<GCS::Line>(theEntity->entity());
498 aConstrList.push_back(GCSConstraintPtr(new GCS::ConstraintPointOnLine(*aPoint, *aLine)));
499 aConstrList.push_back(
500 GCSConstraintPtr(new GCS::ConstraintPointOnPerpBisector(*aPoint, aLine->p1, aLine->p2)));
503 std::shared_ptr<GCS::Arc> anArc = std::dynamic_pointer_cast<GCS::Arc>(theEntity->entity());
505 createConstraintMiddlePointOnArc(anArc, aPoint, theAuxParameters, aConstrList);
507 std::shared_ptr<GCS::ArcOfEllipse> aEllArc =
508 std::dynamic_pointer_cast<GCS::ArcOfEllipse>(theEntity->entity());
510 createConstraintMiddlePointOnArc(aEllArc, aPoint, theAuxParameters, aConstrList);
514 return aConstrList.empty() ? ConstraintWrapperPtr() : ConstraintWrapperPtr(
515 new PlaneGCSSolver_ConstraintWrapper(aConstrList, CONSTRAINT_MIDDLE_POINT));
519 ConstraintWrapperPtr createConstraintDistancePointPoint(
520 std::shared_ptr<PlaneGCSSolver_ScalarWrapper> theValue,
521 std::shared_ptr<PlaneGCSSolver_PointWrapper> thePoint1,
522 std::shared_ptr<PlaneGCSSolver_PointWrapper> thePoint2)
524 GCSConstraintPtr aNewConstr(new GCS::ConstraintP2PDistance(
525 *(thePoint1->point()), *(thePoint2->point()), theValue->scalar()));
526 std::shared_ptr<PlaneGCSSolver_ConstraintWrapper> aResult(
527 new PlaneGCSSolver_ConstraintWrapper(aNewConstr, CONSTRAINT_PT_PT_DISTANCE));
528 aResult->setValueParameter(theValue);
532 ConstraintWrapperPtr createConstraintDistancePointLine(
533 std::shared_ptr<PlaneGCSSolver_ScalarWrapper> theValue,
534 std::shared_ptr<PlaneGCSSolver_PointWrapper> thePoint,
535 std::shared_ptr<PlaneGCSSolver_EdgeWrapper> theEntity)
537 std::shared_ptr<GCS::Line> aLine = std::dynamic_pointer_cast<GCS::Line>(theEntity->entity());
538 GCSConstraintPtr aNewConstr(new GCS::ConstraintP2LDistance(
539 *(thePoint->point()), *(aLine), theValue->scalar()));
540 std::shared_ptr<PlaneGCSSolver_ConstraintWrapper> aResult(
541 new PlaneGCSSolver_ConstraintWrapper(aNewConstr, CONSTRAINT_PT_LINE_DISTANCE));
542 aResult->setValueParameter(theValue);
546 ConstraintWrapperPtr createConstraintHVDistance(
547 const SketchSolver_ConstraintType& theType,
548 std::shared_ptr<PlaneGCSSolver_ScalarWrapper> theValue,
549 std::shared_ptr<PlaneGCSSolver_PointWrapper> thePoint1,
550 std::shared_ptr<PlaneGCSSolver_PointWrapper> thePoint2)
552 GCSPointPtr aPoint1 = thePoint1->point();
553 GCSPointPtr aPoint2 = thePoint2->point();
555 double *aParam1, *aParam2;
556 if (theType == CONSTRAINT_HORIZONTAL_DISTANCE) {
557 aParam1 = aPoint1->x;
558 aParam2 = aPoint2->x;
559 } else if (theType == CONSTRAINT_VERTICAL_DISTANCE) {
560 aParam1 = aPoint1->y;
561 aParam2 = aPoint2->y;
564 GCSConstraintPtr aNewConstr(new GCS::ConstraintDifference(aParam1, aParam2, theValue->scalar()));
566 std::shared_ptr<PlaneGCSSolver_ConstraintWrapper> aResult(
567 new PlaneGCSSolver_ConstraintWrapper(aNewConstr, theType));
568 aResult->setValueParameter(theValue);
572 ConstraintWrapperPtr createConstraintRadius(
573 std::shared_ptr<PlaneGCSSolver_ScalarWrapper> theValue,
574 std::shared_ptr<PlaneGCSSolver_EdgeWrapper> theEntity)
576 std::shared_ptr<GCS::Circle> aCircle =
577 std::dynamic_pointer_cast<GCS::Circle>(theEntity->entity());
578 GCSConstraintPtr aNewConstr(new GCS::ConstraintEqual(aCircle->rad, theValue->scalar()));
579 std::shared_ptr<PlaneGCSSolver_ConstraintWrapper> aResult(
580 new PlaneGCSSolver_ConstraintWrapper(aNewConstr, CONSTRAINT_RADIUS));
581 aResult->setValueParameter(theValue);
585 ConstraintWrapperPtr createConstraintAngle(
586 ConstraintPtr theConstraint,
587 std::shared_ptr<PlaneGCSSolver_ScalarWrapper> theValue,
588 std::shared_ptr<PlaneGCSSolver_EdgeWrapper> theEntity1,
589 std::shared_ptr<PlaneGCSSolver_EdgeWrapper> theEntity2)
591 std::shared_ptr<GCS::Line> aLine1 = std::dynamic_pointer_cast<GCS::Line>(theEntity1->entity());
592 bool isLine1Rev = theConstraint->boolean(
593 SketchPlugin_ConstraintAngle::ANGLE_REVERSED_FIRST_LINE_ID())->value();
594 GCS::Point aLine1Pt1 = isLine1Rev ? aLine1->p2 : aLine1->p1;
595 GCS::Point aLine1Pt2 = isLine1Rev ? aLine1->p1 : aLine1->p2;
597 std::shared_ptr<GCS::Line> aLine2 = std::dynamic_pointer_cast<GCS::Line>(theEntity2->entity());
598 bool isLine2Rev = theConstraint->boolean(
599 SketchPlugin_ConstraintAngle::ANGLE_REVERSED_SECOND_LINE_ID())->value();
600 GCS::Point aLine2Pt1 = isLine2Rev ? aLine2->p2 : aLine2->p1;
601 GCS::Point aLine2Pt2 = isLine2Rev ? aLine2->p1 : aLine2->p2;
603 GCSConstraintPtr aNewConstr(new GCS::ConstraintL2LAngle(
604 aLine1Pt1, aLine1Pt2, aLine2Pt1, aLine2Pt2, theValue->scalar()));
606 std::shared_ptr<PlaneGCSSolver_ConstraintWrapper> aResult(
607 new PlaneGCSSolver_ConstraintWrapper(aNewConstr, CONSTRAINT_ANGLE));
608 aResult->setValueParameter(theValue);
612 ConstraintWrapperPtr createConstraintHorizVert(
613 const SketchSolver_ConstraintType& theType,
614 std::shared_ptr<PlaneGCSSolver_EdgeWrapper> theEntity)
616 std::shared_ptr<GCS::Line> aLine = std::dynamic_pointer_cast<GCS::Line>(theEntity->entity());
617 GCSConstraintPtr aNewConstr;
618 if (theType == CONSTRAINT_HORIZONTAL)
619 aNewConstr = GCSConstraintPtr(new GCS::ConstraintEqual(aLine->p1.y, aLine->p2.y));
621 aNewConstr = GCSConstraintPtr(new GCS::ConstraintEqual(aLine->p1.x, aLine->p2.x));
623 return ConstraintWrapperPtr(new PlaneGCSSolver_ConstraintWrapper(aNewConstr, theType));
626 ConstraintWrapperPtr createConstraintParallel(
627 std::shared_ptr<PlaneGCSSolver_EdgeWrapper> theEntity1,
628 std::shared_ptr<PlaneGCSSolver_EdgeWrapper> theEntity2)
630 std::shared_ptr<GCS::Line> aLine1 = std::dynamic_pointer_cast<GCS::Line>(theEntity1->entity());
631 std::shared_ptr<GCS::Line> aLine2 = std::dynamic_pointer_cast<GCS::Line>(theEntity2->entity());
632 GCSConstraintPtr aNewConstr(new GCS::ConstraintParallel(*(aLine1), *(aLine2)));
634 return ConstraintWrapperPtr(
635 new PlaneGCSSolver_ConstraintWrapper(aNewConstr, CONSTRAINT_PARALLEL));
638 ConstraintWrapperPtr createConstraintPerpendicular(
639 std::shared_ptr<PlaneGCSSolver_EdgeWrapper> theEntity1,
640 std::shared_ptr<PlaneGCSSolver_EdgeWrapper> theEntity2)
642 std::shared_ptr<GCS::Line> aLine1 = std::dynamic_pointer_cast<GCS::Line>(theEntity1->entity());
643 std::shared_ptr<GCS::Line> aLine2 = std::dynamic_pointer_cast<GCS::Line>(theEntity2->entity());
645 std::shared_ptr<GCS::Circle> aCirc1 =
646 std::dynamic_pointer_cast<GCS::Circle>(theEntity1->entity());
647 std::shared_ptr<GCS::Circle> aCirc2 =
648 std::dynamic_pointer_cast<GCS::Circle>(theEntity2->entity());
650 GCSConstraintPtr aNewConstr;
651 if (aLine1 && aLine2)
652 aNewConstr.reset(new GCS::ConstraintPerpendicular(*(aLine1), *(aLine2)));
654 if (aLine1 && aCirc2)
656 else if (aLine2 && aCirc1)
659 aNewConstr.reset(new GCS::ConstraintPointOnLine(aCirc1->center, *aLine1));
662 return ConstraintWrapperPtr(
663 new PlaneGCSSolver_ConstraintWrapper(aNewConstr, CONSTRAINT_PERPENDICULAR));
666 ConstraintWrapperPtr createConstraintEqual(
667 const SketchSolver_ConstraintType& theType,
668 std::shared_ptr<PlaneGCSSolver_EdgeWrapper> theEntity1,
669 std::shared_ptr<PlaneGCSSolver_EdgeWrapper> theEntity2,
670 std::shared_ptr<PlaneGCSSolver_ScalarWrapper> theIntermed)
672 if (theType == CONSTRAINT_EQUAL_LINE_ARC)
673 return ConstraintWrapperPtr(); // line-arc equivalence is not supported yet
675 std::list<GCSConstraintPtr> aConstrList;
676 if (theType == CONSTRAINT_EQUAL_LINES) {
677 std::shared_ptr<GCS::Line> aLine1 = std::dynamic_pointer_cast<GCS::Line>(theEntity1->entity());
678 std::shared_ptr<GCS::Line> aLine2 = std::dynamic_pointer_cast<GCS::Line>(theEntity2->entity());
680 aConstrList.push_back(GCSConstraintPtr(
681 new GCS::ConstraintP2PDistance(aLine1->p1, aLine1->p2, theIntermed->scalar())));
682 aConstrList.push_back(GCSConstraintPtr(
683 new GCS::ConstraintP2PDistance(aLine2->p1, aLine2->p2, theIntermed->scalar())));
684 // update value of intermediate parameter
685 theIntermed->setValue(distance(aLine1->p1, aLine1->p2));
687 else if (theType == CONSTRAINT_EQUAL_ELLIPSES) {
688 std::shared_ptr<GCS::Ellipse> anEllipse1 =
689 std::dynamic_pointer_cast<GCS::Ellipse>(theEntity1->entity());
690 std::shared_ptr<GCS::Ellipse> anEllipse2 =
691 std::dynamic_pointer_cast<GCS::Ellipse>(theEntity2->entity());
693 aConstrList.push_back(GCSConstraintPtr(
694 new GCS::ConstraintEqual(anEllipse1->radmin, anEllipse2->radmin)));
695 aConstrList.push_back(GCSConstraintPtr(new GCS::ConstraintP2PDistance(
696 anEllipse1->center, anEllipse1->focus1, theIntermed->scalar())));
697 aConstrList.push_back(GCSConstraintPtr(new GCS::ConstraintP2PDistance(
698 anEllipse2->center, anEllipse2->focus1, theIntermed->scalar())));
699 // update value of intermediate parameter
700 theIntermed->setValue(distance(anEllipse1->center, anEllipse1->focus1));
703 std::shared_ptr<GCS::Circle> aCirc1 =
704 std::dynamic_pointer_cast<GCS::Circle>(theEntity1->entity());
705 std::shared_ptr<GCS::Circle> aCirc2 =
706 std::dynamic_pointer_cast<GCS::Circle>(theEntity2->entity());
707 aConstrList.push_back(GCSConstraintPtr(new GCS::ConstraintEqual(aCirc1->rad, aCirc2->rad)));
710 std::shared_ptr<PlaneGCSSolver_ConstraintWrapper> aResult(
711 new PlaneGCSSolver_ConstraintWrapper(aConstrList, theType));
713 aResult->setValueParameter(theIntermed);
717 GCS::SET_pD scalarParameters(const ScalarWrapperPtr& theScalar)
720 aParams.insert(theScalar->scalar());
724 GCS::SET_pD pointParameters(const PointWrapperPtr& thePoint)
727 aParams.insert(thePoint->point()->x);
728 aParams.insert(thePoint->point()->y);
732 GCS::SET_pD lineParameters(const EdgeWrapperPtr& theLine)
735 std::shared_ptr<GCS::Line> aLine = std::dynamic_pointer_cast<GCS::Line>(theLine->entity());
736 aParams.insert(aLine->p1.x);
737 aParams.insert(aLine->p1.y);
738 aParams.insert(aLine->p2.x);
739 aParams.insert(aLine->p2.y);
743 GCS::SET_pD circleParameters(const EdgeWrapperPtr& theCircle)
746 std::shared_ptr<GCS::Circle> aCirc = std::dynamic_pointer_cast<GCS::Circle>(theCircle->entity());
747 aParams.insert(aCirc->center.x);
748 aParams.insert(aCirc->center.y);
749 aParams.insert(aCirc->rad);
753 GCS::SET_pD arcParameters(const EdgeWrapperPtr& theArc)
755 GCS::SET_pD aParams = circleParameters(theArc);
756 std::shared_ptr<GCS::Arc> anArc = std::dynamic_pointer_cast<GCS::Arc>(theArc->entity());
757 aParams.insert(anArc->start.x);
758 aParams.insert(anArc->start.y);
759 aParams.insert(anArc->end.x);
760 aParams.insert(anArc->end.y);
761 aParams.insert(anArc->startAngle);
762 aParams.insert(anArc->endAngle);
766 GCS::SET_pD ellipseParameters(const EdgeWrapperPtr& theEllipse)
769 std::shared_ptr<GCS::Ellipse> anEllipse =
770 std::dynamic_pointer_cast<GCS::Ellipse>(theEllipse->entity());
771 aParams.insert(anEllipse->center.x);
772 aParams.insert(anEllipse->center.y);
773 aParams.insert(anEllipse->focus1.x);
774 aParams.insert(anEllipse->focus1.y);
775 aParams.insert(anEllipse->radmin);
779 GCS::SET_pD ellipticArcParameters(const EdgeWrapperPtr& theEllipticArc)
781 GCS::SET_pD aParams = ellipseParameters(theEllipticArc);
782 std::shared_ptr<GCS::ArcOfEllipse> anArc =
783 std::dynamic_pointer_cast<GCS::ArcOfEllipse>(theEllipticArc->entity());
784 aParams.insert(anArc->start.x);
785 aParams.insert(anArc->start.y);
786 aParams.insert(anArc->end.x);
787 aParams.insert(anArc->end.y);
788 aParams.insert(anArc->startAngle);
789 aParams.insert(anArc->endAngle);
793 double distance(const GCS::Point& thePnt1, const GCS::Point& thePnt2)
795 double x = *thePnt1.x - *thePnt2.x;
796 double y = *thePnt1.y - *thePnt2.y;
797 return sqrt(x*x + y*y);