1 // Copyright (C) 2014-2017 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
18 // email : webmaster.salome@opencascade.com<mailto:webmaster.salome@opencascade.com>
21 #include <PlaneGCSSolver_Tools.h>
22 #include <PlaneGCSSolver_EdgeWrapper.h>
23 #include <PlaneGCSSolver_PointWrapper.h>
24 #include <PlaneGCSSolver_ScalarWrapper.h>
25 #include <PlaneGCSSolver_ConstraintWrapper.h>
27 #include <SketchSolver_Constraint.h>
28 #include <SketchSolver_ConstraintAngle.h>
29 #include <SketchSolver_ConstraintCoincidence.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_ConstraintEqual.h>
46 #include <SketchPlugin_ConstraintLength.h>
47 #include <SketchPlugin_ConstraintMiddle.h>
48 #include <SketchPlugin_ConstraintMirror.h>
49 #include <SketchPlugin_ConstraintRigid.h>
50 #include <SketchPlugin_ConstraintTangent.h>
51 #include <SketchPlugin_Line.h>
52 #include <SketchPlugin_MultiRotation.h>
53 #include <SketchPlugin_MultiTranslation.h>
58 #define GCS_EDGE_WRAPPER(x) std::dynamic_pointer_cast<PlaneGCSSolver_EdgeWrapper>(x)
59 #define GCS_POINT_WRAPPER(x) std::dynamic_pointer_cast<PlaneGCSSolver_PointWrapper>(x)
60 #define GCS_SCALAR_WRAPPER(x) std::dynamic_pointer_cast<PlaneGCSSolver_ScalarWrapper>(x)
64 static ConstraintWrapperPtr
65 createConstraintCoincidence(std::shared_ptr<PlaneGCSSolver_PointWrapper> thePoint1,
66 std::shared_ptr<PlaneGCSSolver_PointWrapper> thePoint2);
67 static ConstraintWrapperPtr
68 createConstraintPointOnEntity(const SketchSolver_ConstraintType& theType,
69 std::shared_ptr<PlaneGCSSolver_PointWrapper> thePoint,
70 std::shared_ptr<PlaneGCSSolver_EdgeWrapper> theEntity);
71 static ConstraintWrapperPtr
72 createConstraintDistancePointPoint(std::shared_ptr<PlaneGCSSolver_ScalarWrapper> theValue,
73 std::shared_ptr<PlaneGCSSolver_PointWrapper> thePoint1,
74 std::shared_ptr<PlaneGCSSolver_PointWrapper> thePoint2);
75 static ConstraintWrapperPtr
76 createConstraintDistancePointLine(std::shared_ptr<PlaneGCSSolver_ScalarWrapper> theValue,
77 std::shared_ptr<PlaneGCSSolver_PointWrapper> thePoint,
78 std::shared_ptr<PlaneGCSSolver_EdgeWrapper> theEntity);
79 static ConstraintWrapperPtr
80 createConstraintRadius(std::shared_ptr<PlaneGCSSolver_ScalarWrapper> theValue,
81 std::shared_ptr<PlaneGCSSolver_EdgeWrapper> theEntity);
82 static ConstraintWrapperPtr
83 createConstraintAngle(ConstraintPtr theConstraint,
84 std::shared_ptr<PlaneGCSSolver_ScalarWrapper> theValue,
85 std::shared_ptr<PlaneGCSSolver_EdgeWrapper> theEntity1,
86 std::shared_ptr<PlaneGCSSolver_EdgeWrapper> theEntity2);
87 static ConstraintWrapperPtr
88 createConstraintHorizVert(const SketchSolver_ConstraintType& theType,
89 std::shared_ptr<PlaneGCSSolver_EdgeWrapper> theEntity);
90 static ConstraintWrapperPtr
91 createConstraintParallel(std::shared_ptr<PlaneGCSSolver_EdgeWrapper> theEntity1,
92 std::shared_ptr<PlaneGCSSolver_EdgeWrapper> theEntity2);
93 static ConstraintWrapperPtr
94 createConstraintPerpendicular(std::shared_ptr<PlaneGCSSolver_EdgeWrapper> theEntity1,
95 std::shared_ptr<PlaneGCSSolver_EdgeWrapper> theEntity2);
96 static ConstraintWrapperPtr
97 createConstraintEqual(const SketchSolver_ConstraintType& theType,
98 std::shared_ptr<PlaneGCSSolver_EdgeWrapper> theEntity1,
99 std::shared_ptr<PlaneGCSSolver_EdgeWrapper> theEntity2,
100 std::shared_ptr<PlaneGCSSolver_ScalarWrapper> theIntermed);
101 static ConstraintWrapperPtr
102 createConstraintMiddlePoint(std::shared_ptr<PlaneGCSSolver_PointWrapper> thePoint,
103 std::shared_ptr<PlaneGCSSolver_EdgeWrapper> theEntity);
105 static GCS::SET_pD scalarParameters(const ScalarWrapperPtr& theScalar);
106 static GCS::SET_pD pointParameters(const PointWrapperPtr& thePoint);
107 static GCS::SET_pD lineParameters(const EdgeWrapperPtr& theLine);
108 static GCS::SET_pD circleParameters(const EdgeWrapperPtr& theCircle);
109 static GCS::SET_pD arcParameters(const EdgeWrapperPtr& theArc);
115 SolverConstraintPtr PlaneGCSSolver_Tools::createConstraint(ConstraintPtr theConstraint)
117 if (theConstraint->getKind() == SketchPlugin_ConstraintCoincidence::ID()) {
118 return SolverConstraintPtr(new SketchSolver_ConstraintCoincidence(theConstraint));
119 } else if (theConstraint->getKind() == SketchPlugin_ConstraintCollinear::ID()) {
120 return SolverConstraintPtr(new SketchSolver_ConstraintCollinear(theConstraint));
121 } else if (theConstraint->getKind() == SketchPlugin_ConstraintDistance::ID()) {
122 return SolverConstraintPtr(new SketchSolver_ConstraintDistance(theConstraint));
123 } else if (theConstraint->getKind() == SketchPlugin_ConstraintEqual::ID()) {
124 return SolverConstraintPtr(new SketchSolver_ConstraintEqual(theConstraint));
125 } else if (theConstraint->getKind() == SketchPlugin_ConstraintLength::ID()) {
126 return SolverConstraintPtr(new SketchSolver_ConstraintLength(theConstraint));
127 } else if (theConstraint->getKind() == SketchPlugin_ConstraintMiddle::ID()) {
128 return SolverConstraintPtr(new SketchSolver_ConstraintMiddle(theConstraint));
129 } else if (theConstraint->getKind() == SketchPlugin_ConstraintMirror::ID()) {
130 return SolverConstraintPtr(new SketchSolver_ConstraintMirror(theConstraint));
131 } else if (theConstraint->getKind() == SketchPlugin_ConstraintTangent::ID()) {
132 return SolverConstraintPtr(new SketchSolver_ConstraintTangent(theConstraint));
133 } else if (theConstraint->getKind() == SketchPlugin_ConstraintRigid::ID()) {
134 return SolverConstraintPtr(new SketchSolver_ConstraintFixed(theConstraint));
135 } else if (theConstraint->getKind() == SketchPlugin_MultiTranslation::ID()) {
136 return SolverConstraintPtr(new SketchSolver_ConstraintMultiTranslation(theConstraint));
137 } else if (theConstraint->getKind() == SketchPlugin_MultiRotation::ID()) {
138 return SolverConstraintPtr(new SketchSolver_ConstraintMultiRotation(theConstraint));
139 } else if (theConstraint->getKind() == SketchPlugin_ConstraintAngle::ID()) {
140 return SolverConstraintPtr(new SketchSolver_ConstraintAngle(theConstraint));
142 // All other types of constraints
143 return SolverConstraintPtr(new SketchSolver_Constraint(theConstraint));
146 std::shared_ptr<SketchSolver_ConstraintFixed> PlaneGCSSolver_Tools::createMovementConstraint(
147 FeaturePtr theMovedFeature)
149 return std::shared_ptr<SketchSolver_ConstraintFixed>(
150 new SketchSolver_ConstraintFixed(theMovedFeature));
155 ConstraintWrapperPtr PlaneGCSSolver_Tools::createConstraint(
156 ConstraintPtr theConstraint,
157 const SketchSolver_ConstraintType& theType,
158 const EntityWrapperPtr& theValue,
159 const EntityWrapperPtr& thePoint1,
160 const EntityWrapperPtr& thePoint2,
161 const EntityWrapperPtr& theEntity1,
162 const EntityWrapperPtr& theEntity2)
164 ConstraintWrapperPtr aResult;
165 ScalarWrapperPtr anIntermediate;
167 std::shared_ptr<PlaneGCSSolver_PointWrapper> aPoint1 = GCS_POINT_WRAPPER(thePoint1);
168 std::shared_ptr<PlaneGCSSolver_PointWrapper> aPoint2 = GCS_POINT_WRAPPER(thePoint2);
171 case CONSTRAINT_PT_PT_COINCIDENT:
172 aResult = createConstraintCoincidence(aPoint1, aPoint2);
174 case CONSTRAINT_PT_ON_LINE:
175 case CONSTRAINT_PT_ON_CIRCLE:
176 aResult = createConstraintPointOnEntity(theType, aPoint1, GCS_EDGE_WRAPPER(theEntity1));
178 case CONSTRAINT_MIDDLE_POINT:
179 aResult = createConstraintMiddlePoint(aPoint1, GCS_EDGE_WRAPPER(theEntity1));
181 case CONSTRAINT_PT_PT_DISTANCE:
182 aResult = createConstraintDistancePointPoint(GCS_SCALAR_WRAPPER(theValue), aPoint1, aPoint2);
184 case CONSTRAINT_PT_LINE_DISTANCE:
185 aResult = createConstraintDistancePointLine(GCS_SCALAR_WRAPPER(theValue),
187 GCS_EDGE_WRAPPER(theEntity1));
189 case CONSTRAINT_RADIUS:
190 aResult = createConstraintRadius(GCS_SCALAR_WRAPPER(theValue),
191 GCS_EDGE_WRAPPER(theEntity1));
193 case CONSTRAINT_ANGLE:
194 aResult = createConstraintAngle(theConstraint,
195 GCS_SCALAR_WRAPPER(theValue),
196 GCS_EDGE_WRAPPER(theEntity1), GCS_EDGE_WRAPPER(theEntity2));
198 case CONSTRAINT_FIXED:
200 case CONSTRAINT_HORIZONTAL:
201 case CONSTRAINT_VERTICAL:
202 aResult = createConstraintHorizVert(theType, GCS_EDGE_WRAPPER(theEntity1));
204 case CONSTRAINT_PARALLEL:
205 aResult = createConstraintParallel(GCS_EDGE_WRAPPER(theEntity1),
206 GCS_EDGE_WRAPPER(theEntity2));
208 case CONSTRAINT_PERPENDICULAR:
209 aResult = createConstraintPerpendicular(GCS_EDGE_WRAPPER(theEntity1),
210 GCS_EDGE_WRAPPER(theEntity2));
212 case CONSTRAINT_EQUAL_LINES:
213 anIntermediate = GCS_SCALAR_WRAPPER(theValue); // parameter is used to store length of lines
214 case CONSTRAINT_EQUAL_LINE_ARC:
215 case CONSTRAINT_EQUAL_RADIUS:
216 aResult = createConstraintEqual(theType,
217 GCS_EDGE_WRAPPER(theEntity1),
218 GCS_EDGE_WRAPPER(theEntity2),
228 std::shared_ptr<GeomAPI_Pnt2d> PlaneGCSSolver_Tools::point(EntityWrapperPtr theEntity)
230 if (theEntity->type() != ENTITY_POINT)
231 return std::shared_ptr<GeomAPI_Pnt2d>();
233 std::shared_ptr<PlaneGCSSolver_PointWrapper> aPointWrapper =
234 std::dynamic_pointer_cast<PlaneGCSSolver_PointWrapper>(theEntity);
235 const GCSPointPtr& aPoint = aPointWrapper->point();
236 return std::shared_ptr<GeomAPI_Pnt2d>(new GeomAPI_Pnt2d(*aPoint->x, *aPoint->y));
239 std::shared_ptr<GeomAPI_Lin2d> PlaneGCSSolver_Tools::line(EntityWrapperPtr theEntity)
241 if (theEntity->type() != ENTITY_LINE)
242 return std::shared_ptr<GeomAPI_Lin2d>();
244 std::shared_ptr<PlaneGCSSolver_EdgeWrapper> anEntity =
245 std::dynamic_pointer_cast<PlaneGCSSolver_EdgeWrapper>(theEntity);
246 std::shared_ptr<GCS::Line> aLine = std::dynamic_pointer_cast<GCS::Line>(anEntity->entity());
247 return std::shared_ptr<GeomAPI_Lin2d>(
248 new GeomAPI_Lin2d(*(aLine->p1.x), *(aLine->p1.y), *(aLine->p2.x), *(aLine->p2.y)));
251 std::shared_ptr<GeomAPI_Lin2d> PlaneGCSSolver_Tools::line(FeaturePtr theFeature)
253 if (theFeature->getKind() != SketchPlugin_Line::ID())
254 return std::shared_ptr<GeomAPI_Lin2d>();
256 AttributePoint2DPtr aStart = std::dynamic_pointer_cast<GeomDataAPI_Point2D>(
257 theFeature->attribute(SketchPlugin_Line::START_ID()));
258 AttributePoint2DPtr aEnd = std::dynamic_pointer_cast<GeomDataAPI_Point2D>(
259 theFeature->attribute(SketchPlugin_Line::END_ID()));
261 return std::shared_ptr<GeomAPI_Lin2d>(new GeomAPI_Lin2d(aStart->pnt(), aEnd->pnt()));
265 GCS::SET_pD PlaneGCSSolver_Tools::parameters(const EntityWrapperPtr& theEntity)
267 switch (theEntity->type()) {
270 return scalarParameters(GCS_SCALAR_WRAPPER(theEntity));
272 return pointParameters(GCS_POINT_WRAPPER(theEntity));
274 return lineParameters(GCS_EDGE_WRAPPER(theEntity));
276 return circleParameters(GCS_EDGE_WRAPPER(theEntity));
278 return arcParameters(GCS_EDGE_WRAPPER(theEntity));
281 return GCS::SET_pD();
289 // ================ Auxiliary functions ==========================
290 ConstraintWrapperPtr createConstraintCoincidence(
291 std::shared_ptr<PlaneGCSSolver_PointWrapper> thePoint1,
292 std::shared_ptr<PlaneGCSSolver_PointWrapper> thePoint2)
294 GCSPointPtr aPoint1 = thePoint1->point();
295 GCSPointPtr aPoint2 = thePoint2->point();
297 // Create equality constraint for corresponding attributes of the points
298 std::list<GCSConstraintPtr> aConstrList;
299 aConstrList.push_back(
300 GCSConstraintPtr(new GCS::ConstraintEqual(aPoint1->x, aPoint2->x)));
301 aConstrList.push_back(
302 GCSConstraintPtr(new GCS::ConstraintEqual(aPoint1->y, aPoint2->y)));
304 return ConstraintWrapperPtr(new PlaneGCSSolver_ConstraintWrapper(
305 aConstrList, CONSTRAINT_PT_PT_COINCIDENT));
308 ConstraintWrapperPtr createConstraintPointOnEntity(
309 const SketchSolver_ConstraintType& theType,
310 std::shared_ptr<PlaneGCSSolver_PointWrapper> thePoint,
311 std::shared_ptr<PlaneGCSSolver_EdgeWrapper> theEntity)
313 GCSConstraintPtr aNewConstr;
315 switch (theEntity->type()) {
317 std::shared_ptr<GCS::Line> aLine = std::dynamic_pointer_cast<GCS::Line>(theEntity->entity());
318 aNewConstr = GCSConstraintPtr(new GCS::ConstraintPointOnLine(*(thePoint->point()), *aLine));
322 case ENTITY_CIRCLE: {
323 std::shared_ptr<GCS::Circle> aCirc =
324 std::dynamic_pointer_cast<GCS::Circle>(theEntity->entity());
325 aNewConstr = GCSConstraintPtr(
326 new GCS::ConstraintP2PDistance(*(thePoint->point()), aCirc->center, aCirc->rad));
330 return ConstraintWrapperPtr();
333 return ConstraintWrapperPtr(new PlaneGCSSolver_ConstraintWrapper(aNewConstr, theType));
336 ConstraintWrapperPtr createConstraintMiddlePoint(
337 std::shared_ptr<PlaneGCSSolver_PointWrapper> thePoint,
338 std::shared_ptr<PlaneGCSSolver_EdgeWrapper> theEntity)
340 GCSPointPtr aPoint = thePoint->point();
341 std::shared_ptr<GCS::Line> aLine = std::dynamic_pointer_cast<GCS::Line>(theEntity->entity());
343 return ConstraintWrapperPtr();
345 std::list<GCSConstraintPtr> aConstrList;
346 aConstrList.push_back(
347 GCSConstraintPtr(new GCS::ConstraintPointOnPerpBisector(*aPoint, aLine->p1, aLine->p2)));
348 aConstrList.push_back(GCSConstraintPtr(new GCS::ConstraintPointOnLine(*aPoint, *aLine)));
350 return ConstraintWrapperPtr(
351 new PlaneGCSSolver_ConstraintWrapper(aConstrList, CONSTRAINT_MIDDLE_POINT));
355 ConstraintWrapperPtr createConstraintDistancePointPoint(
356 std::shared_ptr<PlaneGCSSolver_ScalarWrapper> theValue,
357 std::shared_ptr<PlaneGCSSolver_PointWrapper> thePoint1,
358 std::shared_ptr<PlaneGCSSolver_PointWrapper> thePoint2)
360 GCSConstraintPtr aNewConstr(new GCS::ConstraintP2PDistance(
361 *(thePoint1->point()), *(thePoint2->point()), theValue->scalar()));
362 std::shared_ptr<PlaneGCSSolver_ConstraintWrapper> aResult(
363 new PlaneGCSSolver_ConstraintWrapper(aNewConstr, CONSTRAINT_PT_PT_DISTANCE));
364 aResult->setValueParameter(theValue);
368 ConstraintWrapperPtr createConstraintDistancePointLine(
369 std::shared_ptr<PlaneGCSSolver_ScalarWrapper> theValue,
370 std::shared_ptr<PlaneGCSSolver_PointWrapper> thePoint,
371 std::shared_ptr<PlaneGCSSolver_EdgeWrapper> theEntity)
373 std::shared_ptr<GCS::Line> aLine = std::dynamic_pointer_cast<GCS::Line>(theEntity->entity());
374 GCSConstraintPtr aNewConstr(new GCS::ConstraintP2LDistance(
375 *(thePoint->point()), *(aLine), theValue->scalar()));
376 std::shared_ptr<PlaneGCSSolver_ConstraintWrapper> aResult(
377 new PlaneGCSSolver_ConstraintWrapper(aNewConstr, CONSTRAINT_PT_LINE_DISTANCE));
378 aResult->setValueParameter(theValue);
382 ConstraintWrapperPtr createConstraintRadius(
383 std::shared_ptr<PlaneGCSSolver_ScalarWrapper> theValue,
384 std::shared_ptr<PlaneGCSSolver_EdgeWrapper> theEntity)
386 std::shared_ptr<GCS::Circle> aCircle =
387 std::dynamic_pointer_cast<GCS::Circle>(theEntity->entity());
388 GCSConstraintPtr aNewConstr(new GCS::ConstraintEqual(aCircle->rad, theValue->scalar()));
389 std::shared_ptr<PlaneGCSSolver_ConstraintWrapper> aResult(
390 new PlaneGCSSolver_ConstraintWrapper(aNewConstr, CONSTRAINT_RADIUS));
391 aResult->setValueParameter(theValue);
395 ConstraintWrapperPtr createConstraintAngle(
396 ConstraintPtr theConstraint,
397 std::shared_ptr<PlaneGCSSolver_ScalarWrapper> theValue,
398 std::shared_ptr<PlaneGCSSolver_EdgeWrapper> theEntity1,
399 std::shared_ptr<PlaneGCSSolver_EdgeWrapper> theEntity2)
401 std::shared_ptr<GCS::Line> aLine1 = std::dynamic_pointer_cast<GCS::Line>(theEntity1->entity());
402 bool isLine1Rev = theConstraint->boolean(
403 SketchPlugin_ConstraintAngle::ANGLE_REVERSED_FIRST_LINE_ID())->value();
404 GCS::Point aLine1Pt1 = isLine1Rev ? aLine1->p2 : aLine1->p1;
405 GCS::Point aLine1Pt2 = isLine1Rev ? aLine1->p1 : aLine1->p2;
407 std::shared_ptr<GCS::Line> aLine2 = std::dynamic_pointer_cast<GCS::Line>(theEntity2->entity());
408 bool isLine2Rev = theConstraint->boolean(
409 SketchPlugin_ConstraintAngle::ANGLE_REVERSED_SECOND_LINE_ID())->value();
410 GCS::Point aLine2Pt1 = isLine2Rev ? aLine2->p2 : aLine2->p1;
411 GCS::Point aLine2Pt2 = isLine2Rev ? aLine2->p1 : aLine2->p2;
413 GCSConstraintPtr aNewConstr(new GCS::ConstraintL2LAngle(
414 aLine1Pt1, aLine1Pt2, aLine2Pt1, aLine2Pt2, theValue->scalar()));
416 std::shared_ptr<PlaneGCSSolver_ConstraintWrapper> aResult(
417 new PlaneGCSSolver_ConstraintWrapper(aNewConstr, CONSTRAINT_ANGLE));
418 aResult->setValueParameter(theValue);
422 ConstraintWrapperPtr createConstraintHorizVert(
423 const SketchSolver_ConstraintType& theType,
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;
428 if (theType == CONSTRAINT_HORIZONTAL)
429 aNewConstr = GCSConstraintPtr(new GCS::ConstraintEqual(aLine->p1.y, aLine->p2.y));
431 aNewConstr = GCSConstraintPtr(new GCS::ConstraintEqual(aLine->p1.x, aLine->p2.x));
433 return ConstraintWrapperPtr(new PlaneGCSSolver_ConstraintWrapper(aNewConstr, theType));
436 ConstraintWrapperPtr createConstraintParallel(
437 std::shared_ptr<PlaneGCSSolver_EdgeWrapper> theEntity1,
438 std::shared_ptr<PlaneGCSSolver_EdgeWrapper> theEntity2)
440 std::shared_ptr<GCS::Line> aLine1 = std::dynamic_pointer_cast<GCS::Line>(theEntity1->entity());
441 std::shared_ptr<GCS::Line> aLine2 = std::dynamic_pointer_cast<GCS::Line>(theEntity2->entity());
442 GCSConstraintPtr aNewConstr(new GCS::ConstraintParallel(*(aLine1), *(aLine2)));
444 return ConstraintWrapperPtr(
445 new PlaneGCSSolver_ConstraintWrapper(aNewConstr, CONSTRAINT_PARALLEL));
448 ConstraintWrapperPtr createConstraintPerpendicular(
449 std::shared_ptr<PlaneGCSSolver_EdgeWrapper> theEntity1,
450 std::shared_ptr<PlaneGCSSolver_EdgeWrapper> theEntity2)
452 std::shared_ptr<GCS::Line> aLine1 = std::dynamic_pointer_cast<GCS::Line>(theEntity1->entity());
453 std::shared_ptr<GCS::Line> aLine2 = std::dynamic_pointer_cast<GCS::Line>(theEntity2->entity());
454 GCSConstraintPtr aNewConstr(new GCS::ConstraintPerpendicular(*(aLine1), *(aLine2)));
456 return ConstraintWrapperPtr(
457 new PlaneGCSSolver_ConstraintWrapper(aNewConstr, CONSTRAINT_PERPENDICULAR));
460 ConstraintWrapperPtr createConstraintEqual(
461 const SketchSolver_ConstraintType& theType,
462 std::shared_ptr<PlaneGCSSolver_EdgeWrapper> theEntity1,
463 std::shared_ptr<PlaneGCSSolver_EdgeWrapper> theEntity2,
464 std::shared_ptr<PlaneGCSSolver_ScalarWrapper> theIntermed)
466 if (theType == CONSTRAINT_EQUAL_LINE_ARC)
467 return ConstraintWrapperPtr(); // line-arc equivalence is not supported yet
469 std::list<GCSConstraintPtr> aConstrList;
470 if (theType == CONSTRAINT_EQUAL_LINES) {
471 std::shared_ptr<GCS::Line> aLine1 = std::dynamic_pointer_cast<GCS::Line>(theEntity1->entity());
472 std::shared_ptr<GCS::Line> aLine2 = std::dynamic_pointer_cast<GCS::Line>(theEntity2->entity());
474 aConstrList.push_back(GCSConstraintPtr(
475 new GCS::ConstraintP2PDistance(aLine1->p1, aLine1->p2, theIntermed->scalar())));
476 aConstrList.push_back(GCSConstraintPtr(
477 new GCS::ConstraintP2PDistance(aLine2->p1, aLine2->p2, theIntermed->scalar())));
478 // update value of intermediate parameter
479 double x = *aLine1->p1.x - *aLine1->p2.x;
480 double y = *aLine1->p1.y - *aLine1->p2.y;
481 double aLen = sqrt(x*x + y*y);
482 theIntermed->setValue(aLen);
484 std::shared_ptr<GCS::Circle> aCirc1 =
485 std::dynamic_pointer_cast<GCS::Circle>(theEntity1->entity());
486 std::shared_ptr<GCS::Circle> aCirc2 =
487 std::dynamic_pointer_cast<GCS::Circle>(theEntity2->entity());
489 aConstrList.push_back(GCSConstraintPtr(new GCS::ConstraintEqual(aCirc1->rad, aCirc2->rad)));
492 std::shared_ptr<PlaneGCSSolver_ConstraintWrapper> aResult(
493 new PlaneGCSSolver_ConstraintWrapper(aConstrList, theType));
495 aResult->setValueParameter(theIntermed);
499 GCS::SET_pD scalarParameters(const ScalarWrapperPtr& theScalar)
502 aParams.insert(theScalar->scalar());
506 GCS::SET_pD pointParameters(const PointWrapperPtr& thePoint)
509 aParams.insert(thePoint->point()->x);
510 aParams.insert(thePoint->point()->y);
514 GCS::SET_pD lineParameters(const EdgeWrapperPtr& theLine)
517 std::shared_ptr<GCS::Line> aLine = std::dynamic_pointer_cast<GCS::Line>(theLine->entity());
518 aParams.insert(aLine->p1.x);
519 aParams.insert(aLine->p1.y);
520 aParams.insert(aLine->p2.x);
521 aParams.insert(aLine->p2.y);
525 GCS::SET_pD circleParameters(const EdgeWrapperPtr& theCircle)
528 std::shared_ptr<GCS::Circle> aCirc = std::dynamic_pointer_cast<GCS::Circle>(theCircle->entity());
529 aParams.insert(aCirc->center.x);
530 aParams.insert(aCirc->center.y);
531 aParams.insert(aCirc->rad);
535 GCS::SET_pD arcParameters(const EdgeWrapperPtr& theArc)
538 std::shared_ptr<GCS::Arc> anArc = std::dynamic_pointer_cast<GCS::Arc>(theArc->entity());
539 aParams.insert(anArc->center.x);
540 aParams.insert(anArc->center.y);
541 aParams.insert(anArc->start.x);
542 aParams.insert(anArc->start.y);
543 aParams.insert(anArc->end.x);
544 aParams.insert(anArc->end.y);
545 aParams.insert(anArc->startAngle);
546 aParams.insert(anArc->endAngle);
547 aParams.insert(anArc->rad);