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_ConstraintPerpendicular.h>
38 #include <SketchSolver_ConstraintTangent.h>
39 #include <SketchSolver_ConstraintMultiRotation.h>
40 #include <SketchSolver_ConstraintMultiTranslation.h>
42 #include <SketchPlugin_ConstraintAngle.h>
43 #include <SketchPlugin_ConstraintCoincidence.h>
44 #include <SketchPlugin_ConstraintCollinear.h>
45 #include <SketchPlugin_ConstraintDistance.h>
46 #include <SketchPlugin_ConstraintDistanceHorizontal.h>
47 #include <SketchPlugin_ConstraintDistanceVertical.h>
48 #include <SketchPlugin_ConstraintEqual.h>
49 #include <SketchPlugin_ConstraintLength.h>
50 #include <SketchPlugin_ConstraintMiddle.h>
51 #include <SketchPlugin_ConstraintMirror.h>
52 #include <SketchPlugin_ConstraintRigid.h>
53 #include <SketchPlugin_ConstraintPerpendicular.h>
54 #include <SketchPlugin_ConstraintTangent.h>
55 #include <SketchPlugin_Line.h>
56 #include <SketchPlugin_MultiRotation.h>
57 #include <SketchPlugin_MultiTranslation.h>
59 #include <GeomAPI_Circ2d.h>
60 #include <GeomAPI_Dir2d.h>
61 #include <GeomAPI_Ellipse2d.h>
62 #include <GeomAPI_Lin2d.h>
63 #include <GeomAPI_Pnt2d.h>
68 #define GCS_EDGE_WRAPPER(x) std::dynamic_pointer_cast<PlaneGCSSolver_EdgeWrapper>(x)
69 #define GCS_POINT_WRAPPER(x) std::dynamic_pointer_cast<PlaneGCSSolver_PointWrapper>(x)
70 #define GCS_SCALAR_WRAPPER(x) std::dynamic_pointer_cast<PlaneGCSSolver_ScalarWrapper>(x)
74 static ConstraintWrapperPtr
75 createConstraintCoincidence(std::shared_ptr<PlaneGCSSolver_PointWrapper> thePoint1,
76 std::shared_ptr<PlaneGCSSolver_PointWrapper> thePoint2);
77 static ConstraintWrapperPtr
78 createConstraintPointOnEntity(const SketchSolver_ConstraintType& theType,
79 std::shared_ptr<PlaneGCSSolver_PointWrapper> thePoint,
80 std::shared_ptr<PlaneGCSSolver_EdgeWrapper> theEntity);
81 static ConstraintWrapperPtr
82 createConstraintPointsCollinear(std::shared_ptr<PlaneGCSSolver_PointWrapper> thePoint1,
83 std::shared_ptr<PlaneGCSSolver_PointWrapper> thePoint2,
84 std::shared_ptr<PlaneGCSSolver_PointWrapper> thePoint3);
85 static ConstraintWrapperPtr
86 createConstraintDistancePointPoint(std::shared_ptr<PlaneGCSSolver_ScalarWrapper> theValue,
87 std::shared_ptr<PlaneGCSSolver_PointWrapper> thePoint1,
88 std::shared_ptr<PlaneGCSSolver_PointWrapper> thePoint2);
89 static ConstraintWrapperPtr
90 createConstraintDistancePointLine(std::shared_ptr<PlaneGCSSolver_ScalarWrapper> theValue,
91 std::shared_ptr<PlaneGCSSolver_PointWrapper> thePoint,
92 std::shared_ptr<PlaneGCSSolver_EdgeWrapper> theEntity);
93 static ConstraintWrapperPtr
94 createConstraintHVDistance(const SketchSolver_ConstraintType& theType,
95 std::shared_ptr<PlaneGCSSolver_ScalarWrapper> theValue,
96 std::shared_ptr<PlaneGCSSolver_PointWrapper> thePoint1,
97 std::shared_ptr<PlaneGCSSolver_PointWrapper> thePoint2);
98 static ConstraintWrapperPtr
99 createConstraintRadius(std::shared_ptr<PlaneGCSSolver_ScalarWrapper> theValue,
100 std::shared_ptr<PlaneGCSSolver_EdgeWrapper> theEntity);
101 static ConstraintWrapperPtr
102 createConstraintAngle(ConstraintPtr theConstraint,
103 std::shared_ptr<PlaneGCSSolver_ScalarWrapper> theValue,
104 std::shared_ptr<PlaneGCSSolver_EdgeWrapper> theEntity1,
105 std::shared_ptr<PlaneGCSSolver_EdgeWrapper> theEntity2);
106 static ConstraintWrapperPtr
107 createConstraintHorizVert(const SketchSolver_ConstraintType& theType,
108 std::shared_ptr<PlaneGCSSolver_EdgeWrapper> theEntity);
109 static ConstraintWrapperPtr
110 createConstraintParallel(std::shared_ptr<PlaneGCSSolver_EdgeWrapper> theEntity1,
111 std::shared_ptr<PlaneGCSSolver_EdgeWrapper> theEntity2);
112 static ConstraintWrapperPtr
113 createConstraintPerpendicular(std::shared_ptr<PlaneGCSSolver_EdgeWrapper> theEntity1,
114 std::shared_ptr<PlaneGCSSolver_EdgeWrapper> theEntity2);
115 static ConstraintWrapperPtr
116 createConstraintEqual(const SketchSolver_ConstraintType& theType,
117 std::shared_ptr<PlaneGCSSolver_EdgeWrapper> theEntity1,
118 std::shared_ptr<PlaneGCSSolver_EdgeWrapper> theEntity2,
119 std::shared_ptr<PlaneGCSSolver_ScalarWrapper> theIntermed);
120 static ConstraintWrapperPtr
121 createConstraintMiddlePoint(std::shared_ptr<PlaneGCSSolver_PointWrapper> thePoint,
122 std::shared_ptr<PlaneGCSSolver_EdgeWrapper> theEntity,
123 std::shared_ptr<PlaneGCSSolver_PointWrapper> theAuxParameters);
124 static ConstraintWrapperPtr
125 createConstraintAngleBetweenCurves(std::shared_ptr<PlaneGCSSolver_ScalarWrapper> theValue,
126 std::shared_ptr<PlaneGCSSolver_PointWrapper> thePoint,
127 std::shared_ptr<PlaneGCSSolver_EdgeWrapper> theEntity1,
128 std::shared_ptr<PlaneGCSSolver_EdgeWrapper> theEntity2);
130 static GCS::SET_pD scalarParameters(const ScalarWrapperPtr& theScalar);
131 static GCS::SET_pD pointParameters(const PointWrapperPtr& thePoint);
132 static GCS::SET_pD lineParameters(const EdgeWrapperPtr& theLine);
133 static GCS::SET_pD circleParameters(const EdgeWrapperPtr& theCircle);
134 static GCS::SET_pD arcParameters(const EdgeWrapperPtr& theArc);
135 static GCS::SET_pD ellipseParameters(const EdgeWrapperPtr& theEllipse);
136 static GCS::SET_pD ellipticArcParameters(const EdgeWrapperPtr& theEllipticArc);
138 static double distance(const GCS::Point& thePnt1, const GCS::Point& thePnt2);
144 SolverConstraintPtr PlaneGCSSolver_Tools::createConstraint(ConstraintPtr theConstraint)
146 if (theConstraint->getKind() == SketchPlugin_ConstraintCoincidence::ID() ||
147 theConstraint->getKind() == SketchPlugin_ConstraintCoincidenceInternal::ID()) {
148 return SolverConstraintPtr(new SketchSolver_ConstraintCoincidence(theConstraint));
149 } else if (theConstraint->getKind() == SketchPlugin_ConstraintCollinear::ID()) {
150 return SolverConstraintPtr(new SketchSolver_ConstraintCollinear(theConstraint));
151 } else if (theConstraint->getKind() == SketchPlugin_ConstraintDistance::ID() ||
152 theConstraint->getKind() == SketchPlugin_ConstraintDistanceHorizontal::ID() ||
153 theConstraint->getKind() == SketchPlugin_ConstraintDistanceVertical::ID()) {
154 return SolverConstraintPtr(new SketchSolver_ConstraintDistance(theConstraint));
155 } else if (theConstraint->getKind() == SketchPlugin_ConstraintEqual::ID()) {
156 return SolverConstraintPtr(new SketchSolver_ConstraintEqual(theConstraint));
157 } else if (theConstraint->getKind() == SketchPlugin_ConstraintLength::ID()) {
158 return SolverConstraintPtr(new SketchSolver_ConstraintLength(theConstraint));
159 } else if (theConstraint->getKind() == SketchPlugin_ConstraintMiddle::ID()) {
160 return SolverConstraintPtr(new SketchSolver_ConstraintMiddle(theConstraint));
161 } else if (theConstraint->getKind() == SketchPlugin_ConstraintMirror::ID()) {
162 return SolverConstraintPtr(new SketchSolver_ConstraintMirror(theConstraint));
163 } else if (theConstraint->getKind() == SketchPlugin_ConstraintTangent::ID()) {
164 return SolverConstraintPtr(new SketchSolver_ConstraintTangent(theConstraint));
165 } else if (theConstraint->getKind() == SketchPlugin_ConstraintRigid::ID()) {
166 return SolverConstraintPtr(new SketchSolver_ConstraintFixed(theConstraint));
167 } else if (theConstraint->getKind() == SketchPlugin_MultiTranslation::ID()) {
168 return SolverConstraintPtr(new SketchSolver_ConstraintMultiTranslation(theConstraint));
169 } else if (theConstraint->getKind() == SketchPlugin_MultiRotation::ID()) {
170 return SolverConstraintPtr(new SketchSolver_ConstraintMultiRotation(theConstraint));
171 } else if (theConstraint->getKind() == SketchPlugin_ConstraintAngle::ID()) {
172 return SolverConstraintPtr(new SketchSolver_ConstraintAngle(theConstraint));
173 } else if (theConstraint->getKind() == SketchPlugin_ConstraintPerpendicular::ID()) {
174 return SolverConstraintPtr(new SketchSolver_ConstraintPerpendicular(theConstraint));
176 // All other types of constraints
177 return SolverConstraintPtr(new SketchSolver_Constraint(theConstraint));
180 std::shared_ptr<SketchSolver_ConstraintMovement> PlaneGCSSolver_Tools::createMovementConstraint(
181 FeaturePtr theMovedFeature)
183 return std::shared_ptr<SketchSolver_ConstraintMovement>(
184 new SketchSolver_ConstraintMovement(theMovedFeature));
187 std::shared_ptr<SketchSolver_ConstraintMovement> PlaneGCSSolver_Tools::createMovementConstraint(
188 AttributePtr theMovedAttribute)
190 return std::shared_ptr<SketchSolver_ConstraintMovement>(
191 new SketchSolver_ConstraintMovement(theMovedAttribute));
196 ConstraintWrapperPtr PlaneGCSSolver_Tools::createConstraint(
197 ConstraintPtr theConstraint,
198 const SketchSolver_ConstraintType& theType,
199 const EntityWrapperPtr& theValue,
200 const EntityWrapperPtr& thePoint1,
201 const EntityWrapperPtr& thePoint2,
202 const EntityWrapperPtr& theEntity1,
203 const EntityWrapperPtr& theEntity2)
205 ConstraintWrapperPtr aResult;
206 ScalarWrapperPtr anIntermediate;
208 std::shared_ptr<PlaneGCSSolver_PointWrapper> aPoint1 = GCS_POINT_WRAPPER(thePoint1);
209 std::shared_ptr<PlaneGCSSolver_PointWrapper> aPoint2 = GCS_POINT_WRAPPER(thePoint2);
210 std::shared_ptr<PlaneGCSSolver_EdgeWrapper> anEntity1 = GCS_EDGE_WRAPPER(theEntity1);
213 case CONSTRAINT_PT_PT_COINCIDENT:
214 aResult = createConstraintCoincidence(aPoint1, aPoint2);
216 case CONSTRAINT_PT_ON_CURVE:
217 aResult = anEntity1 ? createConstraintPointOnEntity(theType, aPoint1, anEntity1):
218 createConstraintPointsCollinear(aPoint1, aPoint2, GCS_POINT_WRAPPER(theEntity1));
220 case CONSTRAINT_MIDDLE_POINT:
221 aResult = createConstraintMiddlePoint(aPoint1, GCS_EDGE_WRAPPER(theEntity1), aPoint2);
223 case CONSTRAINT_PT_PT_DISTANCE:
224 aResult = createConstraintDistancePointPoint(GCS_SCALAR_WRAPPER(theValue), aPoint1, aPoint2);
226 case CONSTRAINT_PT_LINE_DISTANCE:
227 aResult = createConstraintDistancePointLine(GCS_SCALAR_WRAPPER(theValue),
231 case CONSTRAINT_HORIZONTAL_DISTANCE:
232 case CONSTRAINT_VERTICAL_DISTANCE:
233 aResult = createConstraintHVDistance(theType, GCS_SCALAR_WRAPPER(theValue), aPoint1, aPoint2);
235 case CONSTRAINT_RADIUS:
236 aResult = createConstraintRadius(GCS_SCALAR_WRAPPER(theValue), anEntity1);
238 case CONSTRAINT_ANGLE:
239 aResult = createConstraintAngle(theConstraint,
240 GCS_SCALAR_WRAPPER(theValue),
241 anEntity1, GCS_EDGE_WRAPPER(theEntity2));
243 case CONSTRAINT_FIXED:
245 case CONSTRAINT_HORIZONTAL:
246 case CONSTRAINT_VERTICAL:
247 aResult = createConstraintHorizVert(theType, anEntity1);
249 case CONSTRAINT_PARALLEL:
250 aResult = createConstraintParallel(anEntity1, GCS_EDGE_WRAPPER(theEntity2));
252 case CONSTRAINT_PERPENDICULAR:
253 aResult = createConstraintPerpendicular(anEntity1, GCS_EDGE_WRAPPER(theEntity2));
255 case CONSTRAINT_PERPENDICULAR_CURVES:
256 aResult = createConstraintAngleBetweenCurves(GCS_SCALAR_WRAPPER(theValue),
257 aPoint1, anEntity1, GCS_EDGE_WRAPPER(theEntity2));
259 case CONSTRAINT_EQUAL_LINES:
260 case CONSTRAINT_EQUAL_ELLIPSES:
261 anIntermediate = GCS_SCALAR_WRAPPER(theValue); // parameter is used to store length of lines
262 case CONSTRAINT_EQUAL_LINE_ARC:
263 case CONSTRAINT_EQUAL_RADIUS:
264 aResult = createConstraintEqual(theType,
266 GCS_EDGE_WRAPPER(theEntity2),
276 std::shared_ptr<GeomAPI_Pnt2d> PlaneGCSSolver_Tools::point(EntityWrapperPtr theEntity)
278 if (theEntity->type() != ENTITY_POINT)
279 return std::shared_ptr<GeomAPI_Pnt2d>();
281 std::shared_ptr<PlaneGCSSolver_PointWrapper> aPointWrapper =
282 std::dynamic_pointer_cast<PlaneGCSSolver_PointWrapper>(theEntity);
283 const GCSPointPtr& aPoint = aPointWrapper->point();
284 return std::shared_ptr<GeomAPI_Pnt2d>(new GeomAPI_Pnt2d(*aPoint->x, *aPoint->y));
287 std::shared_ptr<GeomAPI_Lin2d> PlaneGCSSolver_Tools::line(EntityWrapperPtr theEntity)
289 if (theEntity->type() != ENTITY_LINE)
290 return std::shared_ptr<GeomAPI_Lin2d>();
292 std::shared_ptr<PlaneGCSSolver_EdgeWrapper> anEntity =
293 std::dynamic_pointer_cast<PlaneGCSSolver_EdgeWrapper>(theEntity);
294 std::shared_ptr<GCS::Line> aLine = std::dynamic_pointer_cast<GCS::Line>(anEntity->entity());
295 return std::shared_ptr<GeomAPI_Lin2d>(
296 new GeomAPI_Lin2d(*(aLine->p1.x), *(aLine->p1.y), *(aLine->p2.x), *(aLine->p2.y)));
299 std::shared_ptr<GeomAPI_Lin2d> PlaneGCSSolver_Tools::line(FeaturePtr theFeature)
301 if (theFeature->getKind() != SketchPlugin_Line::ID())
302 return std::shared_ptr<GeomAPI_Lin2d>();
304 AttributePoint2DPtr aStart = std::dynamic_pointer_cast<GeomDataAPI_Point2D>(
305 theFeature->attribute(SketchPlugin_Line::START_ID()));
306 AttributePoint2DPtr aEnd = std::dynamic_pointer_cast<GeomDataAPI_Point2D>(
307 theFeature->attribute(SketchPlugin_Line::END_ID()));
309 return std::shared_ptr<GeomAPI_Lin2d>(new GeomAPI_Lin2d(aStart->pnt(), aEnd->pnt()));
312 std::shared_ptr<GeomAPI_Circ2d> PlaneGCSSolver_Tools::circle(EntityWrapperPtr theEntity)
314 if (theEntity->type() != ENTITY_CIRCLE && theEntity->type() != ENTITY_ARC)
315 return std::shared_ptr<GeomAPI_Circ2d>();
317 std::shared_ptr<PlaneGCSSolver_EdgeWrapper> anEntity =
318 std::dynamic_pointer_cast<PlaneGCSSolver_EdgeWrapper>(theEntity);
319 std::shared_ptr<GCS::Circle> aCirc = std::dynamic_pointer_cast<GCS::Circle>(anEntity->entity());
320 return std::shared_ptr<GeomAPI_Circ2d>(
321 new GeomAPI_Circ2d(*(aCirc->center.x), *(aCirc->center.y), *(aCirc->rad)));
324 std::shared_ptr<GeomAPI_Ellipse2d> PlaneGCSSolver_Tools::ellipse(EntityWrapperPtr theEntity)
326 if (theEntity->type() != ENTITY_ELLIPSE && theEntity->type() != ENTITY_ELLIPTIC_ARC)
327 return std::shared_ptr<GeomAPI_Ellipse2d>();
329 std::shared_ptr<PlaneGCSSolver_EdgeWrapper> anEntity =
330 std::dynamic_pointer_cast<PlaneGCSSolver_EdgeWrapper>(theEntity);
331 std::shared_ptr<GCS::Ellipse> anEllipse =
332 std::dynamic_pointer_cast<GCS::Ellipse>(anEntity->entity());
334 std::shared_ptr<GeomAPI_Pnt2d> aCenter(
335 new GeomAPI_Pnt2d(*(anEllipse->center.x), *(anEllipse->center.y)));
336 std::shared_ptr<GeomAPI_Dir2d> anAxis(new GeomAPI_Dir2d(
337 *(anEllipse->focus1.x) - *(anEllipse->center.x),
338 *(anEllipse->focus1.y) - *(anEllipse->center.y)));
340 return std::shared_ptr<GeomAPI_Ellipse2d>(
341 new GeomAPI_Ellipse2d(aCenter, anAxis, anEllipse->getRadMaj(), *anEllipse->radmin));
344 void PlaneGCSSolver_Tools::recalculateArcParameters(EntityWrapperPtr theArc)
346 std::shared_ptr<PlaneGCSSolver_EdgeWrapper> anEdge =
347 std::dynamic_pointer_cast<PlaneGCSSolver_EdgeWrapper>(theArc);
351 if (anEdge->type() == ENTITY_ARC) {
352 std::shared_ptr<GCS::Arc> anArc = std::dynamic_pointer_cast<GCS::Arc>(anEdge->entity());
354 GCS::Point aCenter = anArc->center;
355 GCS::Point aStartPnt = anArc->start;
356 GCS::Point aEndPnt = anArc->end;
358 *anArc->rad = distance(aCenter, aStartPnt);
360 static GeomDir2dPtr OX(new GeomAPI_Dir2d(1.0, 0.0));
362 GeomDir2dPtr aDir(new GeomAPI_Dir2d(*aStartPnt.x - *aCenter.x, *aStartPnt.y - *aCenter.y));
363 *anArc->startAngle = OX->angle(aDir);
365 aDir.reset(new GeomAPI_Dir2d(*aEndPnt.x - *aCenter.x, *aEndPnt.y - *aCenter.y));
366 *anArc->endAngle = OX->angle(aDir);
368 else if (anEdge->type() == ENTITY_ELLIPTIC_ARC) {
369 std::shared_ptr<GCS::ArcOfEllipse> aEllArc =
370 std::dynamic_pointer_cast<GCS::ArcOfEllipse>(anEdge->entity());
372 GeomPnt2dPtr aCenter(new GeomAPI_Pnt2d(*aEllArc->center.x, *aEllArc->center.y));
373 GeomPnt2dPtr aStartPnt(new GeomAPI_Pnt2d(*aEllArc->start.x, *aEllArc->start.y));
374 GeomPnt2dPtr aEndPnt(new GeomAPI_Pnt2d(*aEllArc->end.x, *aEllArc->end.y));
376 GeomDir2dPtr anAxis(new GeomAPI_Dir2d(*aEllArc->focus1.x - aCenter->x(),
377 *aEllArc->focus1.y - aCenter->y()));
378 GeomAPI_Ellipse2d anEllipse(aCenter, anAxis, aEllArc->getRadMaj(), *aEllArc->radmin);
379 anEllipse.parameter(aStartPnt, 1.e-4, *aEllArc->startAngle);
380 anEllipse.parameter(aEndPnt, 1.e-4, *aEllArc->endAngle);
386 GCS::SET_pD PlaneGCSSolver_Tools::parameters(const EntityWrapperPtr& theEntity)
388 switch (theEntity->type()) {
391 return scalarParameters(GCS_SCALAR_WRAPPER(theEntity));
393 return pointParameters(GCS_POINT_WRAPPER(theEntity));
395 return lineParameters(GCS_EDGE_WRAPPER(theEntity));
397 return circleParameters(GCS_EDGE_WRAPPER(theEntity));
399 return arcParameters(GCS_EDGE_WRAPPER(theEntity));
401 return ellipseParameters(GCS_EDGE_WRAPPER(theEntity));
402 case ENTITY_ELLIPTIC_ARC:
403 return ellipticArcParameters(GCS_EDGE_WRAPPER(theEntity));
406 return GCS::SET_pD();
414 // ================ Auxiliary functions ==========================
415 ConstraintWrapperPtr createConstraintCoincidence(
416 std::shared_ptr<PlaneGCSSolver_PointWrapper> thePoint1,
417 std::shared_ptr<PlaneGCSSolver_PointWrapper> thePoint2)
419 GCSPointPtr aPoint1 = thePoint1->point();
420 GCSPointPtr aPoint2 = thePoint2->point();
422 // Create equality constraint for corresponding attributes of the points
423 std::list<GCSConstraintPtr> aConstrList;
424 aConstrList.push_back(
425 GCSConstraintPtr(new GCS::ConstraintEqual(aPoint1->x, aPoint2->x)));
426 aConstrList.push_back(
427 GCSConstraintPtr(new GCS::ConstraintEqual(aPoint1->y, aPoint2->y)));
429 return ConstraintWrapperPtr(new PlaneGCSSolver_ConstraintWrapper(
430 aConstrList, CONSTRAINT_PT_PT_COINCIDENT));
433 ConstraintWrapperPtr createConstraintPointOnEntity(
434 const SketchSolver_ConstraintType& theType,
435 std::shared_ptr<PlaneGCSSolver_PointWrapper> thePoint,
436 std::shared_ptr<PlaneGCSSolver_EdgeWrapper> theEntity)
438 GCSConstraintPtr aNewConstr;
440 switch (theEntity->type()) {
442 std::shared_ptr<GCS::Line> aLine = std::dynamic_pointer_cast<GCS::Line>(theEntity->entity());
443 aNewConstr = GCSConstraintPtr(new GCS::ConstraintPointOnLine(*(thePoint->point()), *aLine));
447 case ENTITY_CIRCLE: {
448 std::shared_ptr<GCS::Circle> aCirc =
449 std::dynamic_pointer_cast<GCS::Circle>(theEntity->entity());
450 aNewConstr = GCSConstraintPtr(
451 new GCS::ConstraintP2PDistance(*(thePoint->point()), aCirc->center, aCirc->rad));
455 case ENTITY_ELLIPTIC_ARC: {
456 std::shared_ptr<GCS::Ellipse> anEllipse =
457 std::dynamic_pointer_cast<GCS::Ellipse>(theEntity->entity());
458 aNewConstr = GCSConstraintPtr(
459 new GCS::ConstraintPointOnEllipse(*(thePoint->point()), *anEllipse));
463 return ConstraintWrapperPtr();
466 return ConstraintWrapperPtr(new PlaneGCSSolver_ConstraintWrapper(aNewConstr, theType));
469 ConstraintWrapperPtr createConstraintPointsCollinear(
470 std::shared_ptr<PlaneGCSSolver_PointWrapper> thePoint1,
471 std::shared_ptr<PlaneGCSSolver_PointWrapper> thePoint2,
472 std::shared_ptr<PlaneGCSSolver_PointWrapper> thePoint3)
474 GCSConstraintPtr aNewConstr(new GCS::ConstraintPointOnLine(
475 *(thePoint1->point()), *(thePoint2->point()), *(thePoint3->point())));
476 return ConstraintWrapperPtr(
477 new PlaneGCSSolver_ConstraintWrapper(aNewConstr, CONSTRAINT_PT_ON_CURVE));
480 template <typename ARCTYPE>
481 void createConstraintMiddlePointOnArc(ARCTYPE theArc,
482 GCSPointPtr thePoint,
483 std::shared_ptr<PlaneGCSSolver_PointWrapper> theAuxParameters,
484 std::list<GCSConstraintPtr>& theConstraints)
486 double* u = theAuxParameters->point()->x;
487 double* diff = theAuxParameters->point()->y;
488 *u = (*theArc->startAngle + *theArc->endAngle) * 0.5;
489 *diff = (*theArc->endAngle - *theArc->startAngle) * 0.5;
491 theConstraints.push_back(GCSConstraintPtr(
492 new GCS::ConstraintCurveValue(*thePoint, thePoint->x, *theArc, u)));
493 theConstraints.push_back(GCSConstraintPtr(
494 new GCS::ConstraintCurveValue(*thePoint, thePoint->y, *theArc, u)));
495 theConstraints.push_back(GCSConstraintPtr(
496 new GCS::ConstraintDifference(theArc->startAngle, u, diff)));
497 theConstraints.push_back(GCSConstraintPtr(
498 new GCS::ConstraintDifference(u, theArc->endAngle, diff)));
501 ConstraintWrapperPtr createConstraintMiddlePoint(
502 std::shared_ptr<PlaneGCSSolver_PointWrapper> thePoint,
503 std::shared_ptr<PlaneGCSSolver_EdgeWrapper> theEntity,
504 std::shared_ptr<PlaneGCSSolver_PointWrapper> theAuxParameters)
506 std::list<GCSConstraintPtr> aConstrList;
508 GCSPointPtr aPoint = thePoint->point();
509 std::shared_ptr<GCS::Line> aLine = std::dynamic_pointer_cast<GCS::Line>(theEntity->entity());
511 aConstrList.push_back(GCSConstraintPtr(new GCS::ConstraintPointOnLine(*aPoint, *aLine)));
512 aConstrList.push_back(
513 GCSConstraintPtr(new GCS::ConstraintPointOnPerpBisector(*aPoint, aLine->p1, aLine->p2)));
516 std::shared_ptr<GCS::Arc> anArc = std::dynamic_pointer_cast<GCS::Arc>(theEntity->entity());
518 createConstraintMiddlePointOnArc(anArc, aPoint, theAuxParameters, aConstrList);
520 std::shared_ptr<GCS::ArcOfEllipse> aEllArc =
521 std::dynamic_pointer_cast<GCS::ArcOfEllipse>(theEntity->entity());
523 createConstraintMiddlePointOnArc(aEllArc, aPoint, theAuxParameters, aConstrList);
527 return aConstrList.empty() ? ConstraintWrapperPtr() : ConstraintWrapperPtr(
528 new PlaneGCSSolver_ConstraintWrapper(aConstrList, CONSTRAINT_MIDDLE_POINT));
532 ConstraintWrapperPtr createConstraintDistancePointPoint(
533 std::shared_ptr<PlaneGCSSolver_ScalarWrapper> theValue,
534 std::shared_ptr<PlaneGCSSolver_PointWrapper> thePoint1,
535 std::shared_ptr<PlaneGCSSolver_PointWrapper> thePoint2)
537 GCSConstraintPtr aNewConstr(new GCS::ConstraintP2PDistance(
538 *(thePoint1->point()), *(thePoint2->point()), theValue->scalar()));
539 std::shared_ptr<PlaneGCSSolver_ConstraintWrapper> aResult(
540 new PlaneGCSSolver_ConstraintWrapper(aNewConstr, CONSTRAINT_PT_PT_DISTANCE));
541 aResult->setValueParameter(theValue);
545 ConstraintWrapperPtr createConstraintDistancePointLine(
546 std::shared_ptr<PlaneGCSSolver_ScalarWrapper> theValue,
547 std::shared_ptr<PlaneGCSSolver_PointWrapper> thePoint,
548 std::shared_ptr<PlaneGCSSolver_EdgeWrapper> theEntity)
550 std::shared_ptr<GCS::Line> aLine = std::dynamic_pointer_cast<GCS::Line>(theEntity->entity());
551 GCSConstraintPtr aNewConstr(new GCS::ConstraintP2LDistance(
552 *(thePoint->point()), *(aLine), theValue->scalar()));
553 std::shared_ptr<PlaneGCSSolver_ConstraintWrapper> aResult(
554 new PlaneGCSSolver_ConstraintWrapper(aNewConstr, CONSTRAINT_PT_LINE_DISTANCE));
555 aResult->setValueParameter(theValue);
559 ConstraintWrapperPtr createConstraintHVDistance(
560 const SketchSolver_ConstraintType& theType,
561 std::shared_ptr<PlaneGCSSolver_ScalarWrapper> theValue,
562 std::shared_ptr<PlaneGCSSolver_PointWrapper> thePoint1,
563 std::shared_ptr<PlaneGCSSolver_PointWrapper> thePoint2)
565 GCSPointPtr aPoint1 = thePoint1->point();
566 GCSPointPtr aPoint2 = thePoint2->point();
568 double *aParam1, *aParam2;
569 if (theType == CONSTRAINT_HORIZONTAL_DISTANCE) {
570 aParam1 = aPoint1->x;
571 aParam2 = aPoint2->x;
572 } else if (theType == CONSTRAINT_VERTICAL_DISTANCE) {
573 aParam1 = aPoint1->y;
574 aParam2 = aPoint2->y;
577 GCSConstraintPtr aNewConstr(new GCS::ConstraintDifference(aParam1, aParam2, theValue->scalar()));
579 std::shared_ptr<PlaneGCSSolver_ConstraintWrapper> aResult(
580 new PlaneGCSSolver_ConstraintWrapper(aNewConstr, theType));
581 aResult->setValueParameter(theValue);
585 ConstraintWrapperPtr createConstraintRadius(
586 std::shared_ptr<PlaneGCSSolver_ScalarWrapper> theValue,
587 std::shared_ptr<PlaneGCSSolver_EdgeWrapper> theEntity)
589 std::shared_ptr<GCS::Circle> aCircle =
590 std::dynamic_pointer_cast<GCS::Circle>(theEntity->entity());
591 GCSConstraintPtr aNewConstr(new GCS::ConstraintEqual(aCircle->rad, theValue->scalar()));
592 std::shared_ptr<PlaneGCSSolver_ConstraintWrapper> aResult(
593 new PlaneGCSSolver_ConstraintWrapper(aNewConstr, CONSTRAINT_RADIUS));
594 aResult->setValueParameter(theValue);
598 ConstraintWrapperPtr createConstraintAngle(
599 ConstraintPtr theConstraint,
600 std::shared_ptr<PlaneGCSSolver_ScalarWrapper> theValue,
601 std::shared_ptr<PlaneGCSSolver_EdgeWrapper> theEntity1,
602 std::shared_ptr<PlaneGCSSolver_EdgeWrapper> theEntity2)
604 std::shared_ptr<GCS::Line> aLine1 = std::dynamic_pointer_cast<GCS::Line>(theEntity1->entity());
605 bool isLine1Rev = theConstraint->boolean(
606 SketchPlugin_ConstraintAngle::ANGLE_REVERSED_FIRST_LINE_ID())->value();
607 GCS::Point aLine1Pt1 = isLine1Rev ? aLine1->p2 : aLine1->p1;
608 GCS::Point aLine1Pt2 = isLine1Rev ? aLine1->p1 : aLine1->p2;
610 std::shared_ptr<GCS::Line> aLine2 = std::dynamic_pointer_cast<GCS::Line>(theEntity2->entity());
611 bool isLine2Rev = theConstraint->boolean(
612 SketchPlugin_ConstraintAngle::ANGLE_REVERSED_SECOND_LINE_ID())->value();
613 GCS::Point aLine2Pt1 = isLine2Rev ? aLine2->p2 : aLine2->p1;
614 GCS::Point aLine2Pt2 = isLine2Rev ? aLine2->p1 : aLine2->p2;
616 GCSConstraintPtr aNewConstr(new GCS::ConstraintL2LAngle(
617 aLine1Pt1, aLine1Pt2, aLine2Pt1, aLine2Pt2, theValue->scalar()));
619 std::shared_ptr<PlaneGCSSolver_ConstraintWrapper> aResult(
620 new PlaneGCSSolver_ConstraintWrapper(aNewConstr, CONSTRAINT_ANGLE));
621 aResult->setValueParameter(theValue);
625 ConstraintWrapperPtr createConstraintHorizVert(
626 const SketchSolver_ConstraintType& theType,
627 std::shared_ptr<PlaneGCSSolver_EdgeWrapper> theEntity)
629 std::shared_ptr<GCS::Line> aLine = std::dynamic_pointer_cast<GCS::Line>(theEntity->entity());
630 GCSConstraintPtr aNewConstr;
631 if (theType == CONSTRAINT_HORIZONTAL)
632 aNewConstr = GCSConstraintPtr(new GCS::ConstraintEqual(aLine->p1.y, aLine->p2.y));
634 aNewConstr = GCSConstraintPtr(new GCS::ConstraintEqual(aLine->p1.x, aLine->p2.x));
636 return ConstraintWrapperPtr(new PlaneGCSSolver_ConstraintWrapper(aNewConstr, theType));
639 ConstraintWrapperPtr createConstraintParallel(
640 std::shared_ptr<PlaneGCSSolver_EdgeWrapper> theEntity1,
641 std::shared_ptr<PlaneGCSSolver_EdgeWrapper> theEntity2)
643 std::shared_ptr<GCS::Line> aLine1 = std::dynamic_pointer_cast<GCS::Line>(theEntity1->entity());
644 std::shared_ptr<GCS::Line> aLine2 = std::dynamic_pointer_cast<GCS::Line>(theEntity2->entity());
645 GCSConstraintPtr aNewConstr(new GCS::ConstraintParallel(*(aLine1), *(aLine2)));
647 return ConstraintWrapperPtr(
648 new PlaneGCSSolver_ConstraintWrapper(aNewConstr, CONSTRAINT_PARALLEL));
651 ConstraintWrapperPtr createConstraintPerpendicular(
652 std::shared_ptr<PlaneGCSSolver_EdgeWrapper> theEntity1,
653 std::shared_ptr<PlaneGCSSolver_EdgeWrapper> theEntity2)
655 std::shared_ptr<GCS::Line> aLine1 = std::dynamic_pointer_cast<GCS::Line>(theEntity1->entity());
656 std::shared_ptr<GCS::Line> aLine2 = std::dynamic_pointer_cast<GCS::Line>(theEntity2->entity());
658 std::shared_ptr<GCS::Circle> aCirc1 =
659 std::dynamic_pointer_cast<GCS::Circle>(theEntity1->entity());
660 std::shared_ptr<GCS::Circle> aCirc2 =
661 std::dynamic_pointer_cast<GCS::Circle>(theEntity2->entity());
663 GCSConstraintPtr aNewConstr;
664 if (aLine1 && aLine2)
665 aNewConstr.reset(new GCS::ConstraintPerpendicular(*(aLine1), *(aLine2)));
667 if (aLine1 && aCirc2)
669 else if (aLine2 && aCirc1)
672 aNewConstr.reset(new GCS::ConstraintPointOnLine(aCirc1->center, *aLine1));
675 return ConstraintWrapperPtr(
676 new PlaneGCSSolver_ConstraintWrapper(aNewConstr, CONSTRAINT_PERPENDICULAR));
679 ConstraintWrapperPtr createConstraintAngleBetweenCurves(
680 std::shared_ptr<PlaneGCSSolver_ScalarWrapper> theValue,
681 std::shared_ptr<PlaneGCSSolver_PointWrapper> thePoint,
682 std::shared_ptr<PlaneGCSSolver_EdgeWrapper> theEntity1,
683 std::shared_ptr<PlaneGCSSolver_EdgeWrapper> theEntity2)
685 GCSConstraintPtr aNewConstr(new GCS::ConstraintAngleViaPoint(
686 *theEntity1->entity(), *theEntity2->entity(), *thePoint->point(), theValue->scalar()));
687 return ConstraintWrapperPtr(
688 new PlaneGCSSolver_ConstraintWrapper(aNewConstr, CONSTRAINT_PERPENDICULAR_CURVES));
691 ConstraintWrapperPtr createConstraintEqual(
692 const SketchSolver_ConstraintType& theType,
693 std::shared_ptr<PlaneGCSSolver_EdgeWrapper> theEntity1,
694 std::shared_ptr<PlaneGCSSolver_EdgeWrapper> theEntity2,
695 std::shared_ptr<PlaneGCSSolver_ScalarWrapper> theIntermed)
697 if (theType == CONSTRAINT_EQUAL_LINE_ARC)
698 return ConstraintWrapperPtr(); // line-arc equivalence is not supported yet
700 std::list<GCSConstraintPtr> aConstrList;
701 if (theType == CONSTRAINT_EQUAL_LINES) {
702 std::shared_ptr<GCS::Line> aLine1 = std::dynamic_pointer_cast<GCS::Line>(theEntity1->entity());
703 std::shared_ptr<GCS::Line> aLine2 = std::dynamic_pointer_cast<GCS::Line>(theEntity2->entity());
705 aConstrList.push_back(GCSConstraintPtr(
706 new GCS::ConstraintP2PDistance(aLine1->p1, aLine1->p2, theIntermed->scalar())));
707 aConstrList.push_back(GCSConstraintPtr(
708 new GCS::ConstraintP2PDistance(aLine2->p1, aLine2->p2, theIntermed->scalar())));
709 // update value of intermediate parameter
710 theIntermed->setValue(distance(aLine1->p1, aLine1->p2));
712 else if (theType == CONSTRAINT_EQUAL_ELLIPSES) {
713 std::shared_ptr<GCS::Ellipse> anEllipse1 =
714 std::dynamic_pointer_cast<GCS::Ellipse>(theEntity1->entity());
715 std::shared_ptr<GCS::Ellipse> anEllipse2 =
716 std::dynamic_pointer_cast<GCS::Ellipse>(theEntity2->entity());
718 aConstrList.push_back(GCSConstraintPtr(
719 new GCS::ConstraintEqual(anEllipse1->radmin, anEllipse2->radmin)));
720 aConstrList.push_back(GCSConstraintPtr(new GCS::ConstraintP2PDistance(
721 anEllipse1->center, anEllipse1->focus1, theIntermed->scalar())));
722 aConstrList.push_back(GCSConstraintPtr(new GCS::ConstraintP2PDistance(
723 anEllipse2->center, anEllipse2->focus1, theIntermed->scalar())));
724 // update value of intermediate parameter
725 theIntermed->setValue(distance(anEllipse1->center, anEllipse1->focus1));
728 std::shared_ptr<GCS::Circle> aCirc1 =
729 std::dynamic_pointer_cast<GCS::Circle>(theEntity1->entity());
730 std::shared_ptr<GCS::Circle> aCirc2 =
731 std::dynamic_pointer_cast<GCS::Circle>(theEntity2->entity());
732 aConstrList.push_back(GCSConstraintPtr(new GCS::ConstraintEqual(aCirc1->rad, aCirc2->rad)));
735 std::shared_ptr<PlaneGCSSolver_ConstraintWrapper> aResult(
736 new PlaneGCSSolver_ConstraintWrapper(aConstrList, theType));
738 aResult->setValueParameter(theIntermed);
742 GCS::SET_pD scalarParameters(const ScalarWrapperPtr& theScalar)
745 aParams.insert(theScalar->scalar());
749 GCS::SET_pD pointParameters(const PointWrapperPtr& thePoint)
752 aParams.insert(thePoint->point()->x);
753 aParams.insert(thePoint->point()->y);
757 GCS::SET_pD lineParameters(const EdgeWrapperPtr& theLine)
760 std::shared_ptr<GCS::Line> aLine = std::dynamic_pointer_cast<GCS::Line>(theLine->entity());
761 aParams.insert(aLine->p1.x);
762 aParams.insert(aLine->p1.y);
763 aParams.insert(aLine->p2.x);
764 aParams.insert(aLine->p2.y);
768 GCS::SET_pD circleParameters(const EdgeWrapperPtr& theCircle)
771 std::shared_ptr<GCS::Circle> aCirc = std::dynamic_pointer_cast<GCS::Circle>(theCircle->entity());
772 aParams.insert(aCirc->center.x);
773 aParams.insert(aCirc->center.y);
774 aParams.insert(aCirc->rad);
778 GCS::SET_pD arcParameters(const EdgeWrapperPtr& theArc)
780 GCS::SET_pD aParams = circleParameters(theArc);
781 std::shared_ptr<GCS::Arc> anArc = std::dynamic_pointer_cast<GCS::Arc>(theArc->entity());
782 aParams.insert(anArc->start.x);
783 aParams.insert(anArc->start.y);
784 aParams.insert(anArc->end.x);
785 aParams.insert(anArc->end.y);
786 aParams.insert(anArc->startAngle);
787 aParams.insert(anArc->endAngle);
791 GCS::SET_pD ellipseParameters(const EdgeWrapperPtr& theEllipse)
794 std::shared_ptr<GCS::Ellipse> anEllipse =
795 std::dynamic_pointer_cast<GCS::Ellipse>(theEllipse->entity());
796 aParams.insert(anEllipse->center.x);
797 aParams.insert(anEllipse->center.y);
798 aParams.insert(anEllipse->focus1.x);
799 aParams.insert(anEllipse->focus1.y);
800 aParams.insert(anEllipse->radmin);
804 GCS::SET_pD ellipticArcParameters(const EdgeWrapperPtr& theEllipticArc)
806 GCS::SET_pD aParams = ellipseParameters(theEllipticArc);
807 std::shared_ptr<GCS::ArcOfEllipse> anArc =
808 std::dynamic_pointer_cast<GCS::ArcOfEllipse>(theEllipticArc->entity());
809 aParams.insert(anArc->start.x);
810 aParams.insert(anArc->start.y);
811 aParams.insert(anArc->end.x);
812 aParams.insert(anArc->end.y);
813 aParams.insert(anArc->startAngle);
814 aParams.insert(anArc->endAngle);
818 double distance(const GCS::Point& thePnt1, const GCS::Point& thePnt2)
820 double x = *thePnt1.x - *thePnt2.x;
821 double y = *thePnt1.y - *thePnt2.y;
822 return sqrt(x*x + y*y);