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_PointArrayWrapper.h>
23 #include <PlaneGCSSolver_PointWrapper.h>
24 #include <PlaneGCSSolver_ScalarArrayWrapper.h>
25 #include <PlaneGCSSolver_ScalarWrapper.h>
26 #include <PlaneGCSSolver_ConstraintWrapper.h>
28 #include <SketchSolver_Constraint.h>
29 #include <SketchSolver_ConstraintAngle.h>
30 #include <SketchSolver_ConstraintCoincidence.h>
31 #include <SketchPlugin_ConstraintCoincidenceInternal.h>
32 #include <SketchSolver_ConstraintCollinear.h>
33 #include <SketchSolver_ConstraintDistance.h>
34 #include <SketchSolver_ConstraintEqual.h>
35 #include <SketchSolver_ConstraintFixed.h>
36 #include <SketchSolver_ConstraintLength.h>
37 #include <SketchSolver_ConstraintMiddle.h>
38 #include <SketchSolver_ConstraintMirror.h>
39 #include <SketchSolver_ConstraintPerpendicular.h>
40 #include <SketchSolver_ConstraintTangent.h>
41 #include <SketchSolver_ConstraintMultiRotation.h>
42 #include <SketchSolver_ConstraintMultiTranslation.h>
44 #include <SketchPlugin_Arc.h>
45 #include <SketchPlugin_BSpline.h>
46 #include <SketchPlugin_BSplinePeriodic.h>
47 #include <SketchPlugin_Circle.h>
48 #include <SketchPlugin_ConstraintAngle.h>
49 #include <SketchPlugin_ConstraintCoincidence.h>
50 #include <SketchPlugin_ConstraintCollinear.h>
51 #include <SketchPlugin_ConstraintDistance.h>
52 #include <SketchPlugin_ConstraintDistanceHorizontal.h>
53 #include <SketchPlugin_ConstraintDistanceVertical.h>
54 #include <SketchPlugin_ConstraintEqual.h>
55 #include <SketchPlugin_ConstraintLength.h>
56 #include <SketchPlugin_ConstraintMiddle.h>
57 #include <SketchPlugin_ConstraintMirror.h>
58 #include <SketchPlugin_ConstraintRigid.h>
59 #include <SketchPlugin_ConstraintPerpendicular.h>
60 #include <SketchPlugin_ConstraintTangent.h>
61 #include <SketchPlugin_Ellipse.h>
62 #include <SketchPlugin_EllipticArc.h>
63 #include <SketchPlugin_Line.h>
64 #include <SketchPlugin_MultiRotation.h>
65 #include <SketchPlugin_MultiTranslation.h>
66 #include <SketchPlugin_Point.h>
68 #include <GeomAPI_Circ2d.h>
69 #include <GeomAPI_Dir2d.h>
70 #include <GeomAPI_Ellipse2d.h>
71 #include <GeomAPI_Lin2d.h>
72 #include <GeomAPI_Pnt2d.h>
74 #include <ModelAPI_AttributeDoubleArray.h>
75 #include <ModelAPI_AttributeIntArray.h>
80 #define GCS_EDGE_WRAPPER(x) std::dynamic_pointer_cast<PlaneGCSSolver_EdgeWrapper>(x)
81 #define GCS_POINT_WRAPPER(x) std::dynamic_pointer_cast<PlaneGCSSolver_PointWrapper>(x)
82 #define GCS_SCALAR_WRAPPER(x) std::dynamic_pointer_cast<PlaneGCSSolver_ScalarWrapper>(x)
86 static ConstraintWrapperPtr
87 createConstraintCoincidence(std::shared_ptr<PlaneGCSSolver_PointWrapper> thePoint1,
88 std::shared_ptr<PlaneGCSSolver_PointWrapper> thePoint2);
89 static ConstraintWrapperPtr
90 createConstraintPointOnEntity(const SketchSolver_ConstraintType& theType,
91 std::shared_ptr<PlaneGCSSolver_PointWrapper> thePoint,
92 std::shared_ptr<PlaneGCSSolver_EdgeWrapper> theEntity,
93 std::shared_ptr<PlaneGCSSolver_ScalarWrapper> theValue);
94 static ConstraintWrapperPtr
95 createConstraintPointsCollinear(std::shared_ptr<PlaneGCSSolver_PointWrapper> thePoint1,
96 std::shared_ptr<PlaneGCSSolver_PointWrapper> thePoint2,
97 std::shared_ptr<PlaneGCSSolver_PointWrapper> thePoint3);
98 static ConstraintWrapperPtr
99 createConstraintDistancePointPoint(std::shared_ptr<PlaneGCSSolver_ScalarWrapper> theValue,
100 std::shared_ptr<PlaneGCSSolver_PointWrapper> thePoint1,
101 std::shared_ptr<PlaneGCSSolver_PointWrapper> thePoint2);
102 static ConstraintWrapperPtr
103 createConstraintDistancePointLine(std::shared_ptr<PlaneGCSSolver_ScalarWrapper> theValue,
104 std::shared_ptr<PlaneGCSSolver_PointWrapper> thePoint,
105 std::shared_ptr<PlaneGCSSolver_EdgeWrapper> theEntity);
106 static ConstraintWrapperPtr
107 createConstraintHVDistance(const SketchSolver_ConstraintType& theType,
108 std::shared_ptr<PlaneGCSSolver_ScalarWrapper> theValue,
109 std::shared_ptr<PlaneGCSSolver_PointWrapper> thePoint1,
110 std::shared_ptr<PlaneGCSSolver_PointWrapper> thePoint2);
111 static ConstraintWrapperPtr
112 createConstraintRadius(std::shared_ptr<PlaneGCSSolver_ScalarWrapper> theValue,
113 std::shared_ptr<PlaneGCSSolver_EdgeWrapper> theEntity);
114 static ConstraintWrapperPtr
115 createConstraintAngle(ConstraintPtr theConstraint,
116 std::shared_ptr<PlaneGCSSolver_ScalarWrapper> theValue,
117 std::shared_ptr<PlaneGCSSolver_EdgeWrapper> theEntity1,
118 std::shared_ptr<PlaneGCSSolver_EdgeWrapper> theEntity2);
119 static ConstraintWrapperPtr
120 createConstraintHorizVert(const SketchSolver_ConstraintType& theType,
121 std::shared_ptr<PlaneGCSSolver_EdgeWrapper> theEntity);
122 static ConstraintWrapperPtr
123 createConstraintParallel(std::shared_ptr<PlaneGCSSolver_EdgeWrapper> theEntity1,
124 std::shared_ptr<PlaneGCSSolver_EdgeWrapper> theEntity2);
125 static ConstraintWrapperPtr
126 createConstraintPerpendicular(std::shared_ptr<PlaneGCSSolver_EdgeWrapper> theEntity1,
127 std::shared_ptr<PlaneGCSSolver_EdgeWrapper> theEntity2);
128 static ConstraintWrapperPtr
129 createConstraintEqual(const SketchSolver_ConstraintType& theType,
130 std::shared_ptr<PlaneGCSSolver_EdgeWrapper> theEntity1,
131 std::shared_ptr<PlaneGCSSolver_EdgeWrapper> theEntity2,
132 std::shared_ptr<PlaneGCSSolver_ScalarWrapper> theIntermed);
133 static ConstraintWrapperPtr
134 createConstraintMiddlePoint(std::shared_ptr<PlaneGCSSolver_PointWrapper> thePoint,
135 std::shared_ptr<PlaneGCSSolver_EdgeWrapper> theEntity,
136 std::shared_ptr<PlaneGCSSolver_PointWrapper> theAuxParameters);
137 static ConstraintWrapperPtr
138 createConstraintAngleBetweenCurves(std::shared_ptr<PlaneGCSSolver_ScalarWrapper> theValue,
139 std::shared_ptr<PlaneGCSSolver_PointWrapper> thePoint,
140 std::shared_ptr<PlaneGCSSolver_EdgeWrapper> theEntity1,
141 std::shared_ptr<PlaneGCSSolver_EdgeWrapper> theEntity2);
143 static GCS::SET_pD scalarParameters(const ScalarWrapperPtr& theScalar);
144 static GCS::SET_pD scalarArrayParameters(const EntityWrapperPtr& theArray);
145 static GCS::SET_pD pointParameters(const PointWrapperPtr& thePoint);
146 static GCS::SET_pD pointArrayParameters(const EntityWrapperPtr& theArray);
147 static GCS::SET_pD lineParameters(const EdgeWrapperPtr& theLine);
148 static GCS::SET_pD circleParameters(const EdgeWrapperPtr& theCircle);
149 static GCS::SET_pD arcParameters(const EdgeWrapperPtr& theArc);
150 static GCS::SET_pD ellipseParameters(const EdgeWrapperPtr& theEllipse);
151 static GCS::SET_pD ellipticArcParameters(const EdgeWrapperPtr& theEllipticArc);
152 static GCS::SET_pD bsplineParameters(const EdgeWrapperPtr& theEdge);
157 SolverConstraintPtr PlaneGCSSolver_Tools::createConstraint(ConstraintPtr theConstraint)
159 if (theConstraint->getKind() == SketchPlugin_ConstraintCoincidence::ID() ||
160 theConstraint->getKind() == SketchPlugin_ConstraintCoincidenceInternal::ID()) {
161 return SolverConstraintPtr(new SketchSolver_ConstraintCoincidence(theConstraint));
162 } else if (theConstraint->getKind() == SketchPlugin_ConstraintCollinear::ID()) {
163 return SolverConstraintPtr(new SketchSolver_ConstraintCollinear(theConstraint));
164 } else if (theConstraint->getKind() == SketchPlugin_ConstraintDistance::ID() ||
165 theConstraint->getKind() == SketchPlugin_ConstraintDistanceHorizontal::ID() ||
166 theConstraint->getKind() == SketchPlugin_ConstraintDistanceVertical::ID()) {
167 return SolverConstraintPtr(new SketchSolver_ConstraintDistance(theConstraint));
168 } else if (theConstraint->getKind() == SketchPlugin_ConstraintEqual::ID()) {
169 return SolverConstraintPtr(new SketchSolver_ConstraintEqual(theConstraint));
170 } else if (theConstraint->getKind() == SketchPlugin_ConstraintLength::ID()) {
171 return SolverConstraintPtr(new SketchSolver_ConstraintLength(theConstraint));
172 } else if (theConstraint->getKind() == SketchPlugin_ConstraintMiddle::ID()) {
173 return SolverConstraintPtr(new SketchSolver_ConstraintMiddle(theConstraint));
174 } else if (theConstraint->getKind() == SketchPlugin_ConstraintMirror::ID()) {
175 return SolverConstraintPtr(new SketchSolver_ConstraintMirror(theConstraint));
176 } else if (theConstraint->getKind() == SketchPlugin_ConstraintTangent::ID()) {
177 return SolverConstraintPtr(new SketchSolver_ConstraintTangent(theConstraint));
178 } else if (theConstraint->getKind() == SketchPlugin_ConstraintRigid::ID()) {
179 return SolverConstraintPtr(new SketchSolver_ConstraintFixed(theConstraint));
180 } else if (theConstraint->getKind() == SketchPlugin_MultiTranslation::ID()) {
181 return SolverConstraintPtr(new SketchSolver_ConstraintMultiTranslation(theConstraint));
182 } else if (theConstraint->getKind() == SketchPlugin_MultiRotation::ID()) {
183 return SolverConstraintPtr(new SketchSolver_ConstraintMultiRotation(theConstraint));
184 } else if (theConstraint->getKind() == SketchPlugin_ConstraintAngle::ID()) {
185 return SolverConstraintPtr(new SketchSolver_ConstraintAngle(theConstraint));
186 } else if (theConstraint->getKind() == SketchPlugin_ConstraintPerpendicular::ID()) {
187 return SolverConstraintPtr(new SketchSolver_ConstraintPerpendicular(theConstraint));
189 // All other types of constraints
190 return SolverConstraintPtr(new SketchSolver_Constraint(theConstraint));
193 std::shared_ptr<SketchSolver_ConstraintMovement> PlaneGCSSolver_Tools::createMovementConstraint(
194 FeaturePtr theMovedFeature)
196 return std::shared_ptr<SketchSolver_ConstraintMovement>(
197 new SketchSolver_ConstraintMovement(theMovedFeature));
200 std::shared_ptr<SketchSolver_ConstraintMovement> PlaneGCSSolver_Tools::createMovementConstraint(
201 AttributePtr theMovedAttribute)
203 return std::shared_ptr<SketchSolver_ConstraintMovement>(
204 new SketchSolver_ConstraintMovement(theMovedAttribute));
207 std::shared_ptr<SketchSolver_ConstraintMovement> PlaneGCSSolver_Tools::createMovementConstraint(
208 const std::pair<AttributePtr, int>& theMovedPointInArray)
210 return std::shared_ptr<SketchSolver_ConstraintMovement>(
211 new SketchSolver_ConstraintMovement(theMovedPointInArray.first, theMovedPointInArray.second));
216 ConstraintWrapperPtr PlaneGCSSolver_Tools::createConstraint(
217 ConstraintPtr theConstraint,
218 const SketchSolver_ConstraintType& theType,
219 const EntityWrapperPtr& theValue,
220 const EntityWrapperPtr& thePoint1,
221 const EntityWrapperPtr& thePoint2,
222 const EntityWrapperPtr& theEntity1,
223 const EntityWrapperPtr& theEntity2)
225 ConstraintWrapperPtr aResult;
226 ScalarWrapperPtr anIntermediate;
228 std::shared_ptr<PlaneGCSSolver_PointWrapper> aPoint1 = GCS_POINT_WRAPPER(thePoint1);
229 std::shared_ptr<PlaneGCSSolver_PointWrapper> aPoint2 = GCS_POINT_WRAPPER(thePoint2);
230 std::shared_ptr<PlaneGCSSolver_EdgeWrapper> anEntity1 = GCS_EDGE_WRAPPER(theEntity1);
233 case CONSTRAINT_PT_PT_COINCIDENT:
234 aResult = createConstraintCoincidence(aPoint1, aPoint2);
236 case CONSTRAINT_PT_ON_CURVE:
237 aResult = anEntity1 ?
238 createConstraintPointOnEntity(theType, aPoint1, anEntity1, GCS_SCALAR_WRAPPER(theValue)) :
239 createConstraintPointsCollinear(aPoint1, aPoint2, GCS_POINT_WRAPPER(theEntity1));
241 case CONSTRAINT_MIDDLE_POINT:
242 aResult = createConstraintMiddlePoint(aPoint1, GCS_EDGE_WRAPPER(theEntity1), aPoint2);
244 case CONSTRAINT_PT_PT_DISTANCE:
245 aResult = createConstraintDistancePointPoint(GCS_SCALAR_WRAPPER(theValue), aPoint1, aPoint2);
247 case CONSTRAINT_PT_LINE_DISTANCE:
248 aResult = createConstraintDistancePointLine(GCS_SCALAR_WRAPPER(theValue),
252 case CONSTRAINT_HORIZONTAL_DISTANCE:
253 case CONSTRAINT_VERTICAL_DISTANCE:
254 aResult = createConstraintHVDistance(theType, GCS_SCALAR_WRAPPER(theValue), aPoint1, aPoint2);
256 case CONSTRAINT_RADIUS:
257 aResult = createConstraintRadius(GCS_SCALAR_WRAPPER(theValue), anEntity1);
259 case CONSTRAINT_ANGLE:
260 aResult = createConstraintAngle(theConstraint,
261 GCS_SCALAR_WRAPPER(theValue),
262 anEntity1, GCS_EDGE_WRAPPER(theEntity2));
264 case CONSTRAINT_FIXED:
266 case CONSTRAINT_HORIZONTAL:
267 case CONSTRAINT_VERTICAL:
268 aResult = createConstraintHorizVert(theType, anEntity1);
270 case CONSTRAINT_PARALLEL:
271 aResult = createConstraintParallel(anEntity1, GCS_EDGE_WRAPPER(theEntity2));
273 case CONSTRAINT_PERPENDICULAR:
274 aResult = createConstraintPerpendicular(anEntity1, GCS_EDGE_WRAPPER(theEntity2));
276 case CONSTRAINT_PERPENDICULAR_CURVES:
277 aResult = createConstraintAngleBetweenCurves(GCS_SCALAR_WRAPPER(theValue),
278 aPoint1, anEntity1, GCS_EDGE_WRAPPER(theEntity2));
280 case CONSTRAINT_EQUAL_LINES:
281 case CONSTRAINT_EQUAL_ELLIPSES:
282 anIntermediate = GCS_SCALAR_WRAPPER(theValue); // parameter is used to store length of lines
283 case CONSTRAINT_EQUAL_LINE_ARC:
284 case CONSTRAINT_EQUAL_RADIUS:
285 aResult = createConstraintEqual(theType,
287 GCS_EDGE_WRAPPER(theEntity2),
297 std::shared_ptr<GeomAPI_Pnt2d> PlaneGCSSolver_Tools::point(EntityWrapperPtr theEntity)
299 if (theEntity->type() != ENTITY_POINT)
300 return std::shared_ptr<GeomAPI_Pnt2d>();
302 std::shared_ptr<PlaneGCSSolver_PointWrapper> aPointWrapper =
303 std::dynamic_pointer_cast<PlaneGCSSolver_PointWrapper>(theEntity);
304 const GCSPointPtr& aPoint = aPointWrapper->point();
305 return std::shared_ptr<GeomAPI_Pnt2d>(new GeomAPI_Pnt2d(*aPoint->x, *aPoint->y));
308 std::shared_ptr<GeomAPI_Lin2d> PlaneGCSSolver_Tools::line(EntityWrapperPtr theEntity)
310 if (theEntity->type() != ENTITY_LINE)
311 return std::shared_ptr<GeomAPI_Lin2d>();
313 std::shared_ptr<PlaneGCSSolver_EdgeWrapper> anEntity =
314 std::dynamic_pointer_cast<PlaneGCSSolver_EdgeWrapper>(theEntity);
315 std::shared_ptr<GCS::Line> aLine = std::dynamic_pointer_cast<GCS::Line>(anEntity->entity());
316 return std::shared_ptr<GeomAPI_Lin2d>(
317 new GeomAPI_Lin2d(*(aLine->p1.x), *(aLine->p1.y), *(aLine->p2.x), *(aLine->p2.y)));
320 std::shared_ptr<GeomAPI_Lin2d> PlaneGCSSolver_Tools::line(FeaturePtr theFeature)
322 if (theFeature->getKind() != SketchPlugin_Line::ID())
323 return std::shared_ptr<GeomAPI_Lin2d>();
325 AttributePoint2DPtr aStart = std::dynamic_pointer_cast<GeomDataAPI_Point2D>(
326 theFeature->attribute(SketchPlugin_Line::START_ID()));
327 AttributePoint2DPtr aEnd = std::dynamic_pointer_cast<GeomDataAPI_Point2D>(
328 theFeature->attribute(SketchPlugin_Line::END_ID()));
330 return std::shared_ptr<GeomAPI_Lin2d>(new GeomAPI_Lin2d(aStart->pnt(), aEnd->pnt()));
333 std::shared_ptr<GeomAPI_Circ2d> PlaneGCSSolver_Tools::circle(EntityWrapperPtr theEntity)
335 if (theEntity->type() != ENTITY_CIRCLE && theEntity->type() != ENTITY_ARC)
336 return std::shared_ptr<GeomAPI_Circ2d>();
338 std::shared_ptr<PlaneGCSSolver_EdgeWrapper> anEntity =
339 std::dynamic_pointer_cast<PlaneGCSSolver_EdgeWrapper>(theEntity);
340 std::shared_ptr<GCS::Circle> aCirc = std::dynamic_pointer_cast<GCS::Circle>(anEntity->entity());
341 return std::shared_ptr<GeomAPI_Circ2d>(
342 new GeomAPI_Circ2d(*(aCirc->center.x), *(aCirc->center.y), *(aCirc->rad)));
345 std::shared_ptr<GeomAPI_Ellipse2d> PlaneGCSSolver_Tools::ellipse(EntityWrapperPtr theEntity)
347 if (theEntity->type() != ENTITY_ELLIPSE && theEntity->type() != ENTITY_ELLIPTIC_ARC)
348 return std::shared_ptr<GeomAPI_Ellipse2d>();
350 std::shared_ptr<PlaneGCSSolver_EdgeWrapper> anEntity =
351 std::dynamic_pointer_cast<PlaneGCSSolver_EdgeWrapper>(theEntity);
352 std::shared_ptr<GCS::Ellipse> anEllipse =
353 std::dynamic_pointer_cast<GCS::Ellipse>(anEntity->entity());
355 std::shared_ptr<GeomAPI_Pnt2d> aCenter(
356 new GeomAPI_Pnt2d(*(anEllipse->center.x), *(anEllipse->center.y)));
357 std::shared_ptr<GeomAPI_Dir2d> anAxis(new GeomAPI_Dir2d(
358 *(anEllipse->focus1.x) - *(anEllipse->center.x),
359 *(anEllipse->focus1.y) - *(anEllipse->center.y)));
361 return std::shared_ptr<GeomAPI_Ellipse2d>(
362 new GeomAPI_Ellipse2d(aCenter, anAxis, anEllipse->getRadMaj(), *anEllipse->radmin));
365 void PlaneGCSSolver_Tools::recalculateArcParameters(EntityWrapperPtr theArc)
367 std::shared_ptr<PlaneGCSSolver_EdgeWrapper> anEdge =
368 std::dynamic_pointer_cast<PlaneGCSSolver_EdgeWrapper>(theArc);
372 if (anEdge->type() == ENTITY_ARC) {
373 std::shared_ptr<GCS::Arc> anArc = std::dynamic_pointer_cast<GCS::Arc>(anEdge->entity());
375 GCS::Point aCenter = anArc->center;
376 GCS::Point aStartPnt = anArc->start;
377 GCS::Point aEndPnt = anArc->end;
379 *anArc->rad = distance(aCenter, aStartPnt);
381 static GeomDir2dPtr OX(new GeomAPI_Dir2d(1.0, 0.0));
383 GeomDir2dPtr aDir(new GeomAPI_Dir2d(*aStartPnt.x - *aCenter.x, *aStartPnt.y - *aCenter.y));
384 *anArc->startAngle = OX->angle(aDir);
386 aDir.reset(new GeomAPI_Dir2d(*aEndPnt.x - *aCenter.x, *aEndPnt.y - *aCenter.y));
387 *anArc->endAngle = OX->angle(aDir);
389 else if (anEdge->type() == ENTITY_ELLIPTIC_ARC) {
390 std::shared_ptr<GCS::ArcOfEllipse> aEllArc =
391 std::dynamic_pointer_cast<GCS::ArcOfEllipse>(anEdge->entity());
393 GeomPnt2dPtr aCenter(new GeomAPI_Pnt2d(*aEllArc->center.x, *aEllArc->center.y));
394 GeomPnt2dPtr aStartPnt(new GeomAPI_Pnt2d(*aEllArc->start.x, *aEllArc->start.y));
395 GeomPnt2dPtr aEndPnt(new GeomAPI_Pnt2d(*aEllArc->end.x, *aEllArc->end.y));
397 GeomDir2dPtr anAxis(new GeomAPI_Dir2d(*aEllArc->focus1.x - aCenter->x(),
398 *aEllArc->focus1.y - aCenter->y()));
399 GeomAPI_Ellipse2d anEllipse(aCenter, anAxis, aEllArc->getRadMaj(), *aEllArc->radmin);
400 anEllipse.parameter(aStartPnt, 1.e-4, *aEllArc->startAngle);
401 anEllipse.parameter(aEndPnt, 1.e-4, *aEllArc->endAngle);
407 GCS::SET_pD PlaneGCSSolver_Tools::parameters(const EntityWrapperPtr& theEntity)
409 switch (theEntity->type()) {
412 return scalarParameters(GCS_SCALAR_WRAPPER(theEntity));
413 case ENTITY_SCALAR_ARRAY:
414 return scalarArrayParameters(theEntity);
416 return pointParameters(GCS_POINT_WRAPPER(theEntity));
417 case ENTITY_POINT_ARRAY:
418 return pointArrayParameters(theEntity);
420 return lineParameters(GCS_EDGE_WRAPPER(theEntity));
422 return circleParameters(GCS_EDGE_WRAPPER(theEntity));
424 return arcParameters(GCS_EDGE_WRAPPER(theEntity));
426 return ellipseParameters(GCS_EDGE_WRAPPER(theEntity));
427 case ENTITY_ELLIPTIC_ARC:
428 return ellipticArcParameters(GCS_EDGE_WRAPPER(theEntity));
430 return bsplineParameters(GCS_EDGE_WRAPPER(theEntity));
433 return GCS::SET_pD();
436 bool PlaneGCSSolver_Tools::isAttributeApplicable(const std::string& theAttrName,
437 const std::string& theOwnerName)
439 if (theOwnerName == SketchPlugin_Arc::ID()) {
440 return theAttrName == SketchPlugin_Arc::CENTER_ID() ||
441 theAttrName == SketchPlugin_Arc::START_ID() ||
442 theAttrName == SketchPlugin_Arc::END_ID() ||
443 theAttrName == SketchPlugin_Arc::REVERSED_ID();
445 else if (theOwnerName == SketchPlugin_Circle::ID()) {
446 return theAttrName == SketchPlugin_Circle::CENTER_ID() ||
447 theAttrName == SketchPlugin_Circle::RADIUS_ID();
449 else if (theOwnerName == SketchPlugin_Line::ID()) {
450 return theAttrName == SketchPlugin_Line::START_ID() ||
451 theAttrName == SketchPlugin_Line::END_ID();
453 else if (theOwnerName == SketchPlugin_Ellipse::ID()) {
454 return theAttrName == SketchPlugin_Ellipse::CENTER_ID() ||
455 theAttrName == SketchPlugin_Ellipse::FIRST_FOCUS_ID() ||
456 theAttrName == SketchPlugin_Ellipse::SECOND_FOCUS_ID() ||
457 theAttrName == SketchPlugin_Ellipse::MAJOR_AXIS_START_ID() ||
458 theAttrName == SketchPlugin_Ellipse::MAJOR_AXIS_END_ID() ||
459 theAttrName == SketchPlugin_Ellipse::MINOR_AXIS_START_ID() ||
460 theAttrName == SketchPlugin_Ellipse::MINOR_AXIS_END_ID() ||
461 theAttrName == SketchPlugin_Ellipse::MAJOR_RADIUS_ID() ||
462 theAttrName == SketchPlugin_Ellipse::MINOR_RADIUS_ID();
464 else if (theOwnerName == SketchPlugin_EllipticArc::ID()) {
465 return theAttrName == SketchPlugin_EllipticArc::CENTER_ID() ||
466 theAttrName == SketchPlugin_EllipticArc::FIRST_FOCUS_ID() ||
467 theAttrName == SketchPlugin_EllipticArc::SECOND_FOCUS_ID() ||
468 theAttrName == SketchPlugin_EllipticArc::MAJOR_AXIS_START_ID() ||
469 theAttrName == SketchPlugin_EllipticArc::MAJOR_AXIS_END_ID() ||
470 theAttrName == SketchPlugin_EllipticArc::MINOR_AXIS_START_ID() ||
471 theAttrName == SketchPlugin_EllipticArc::MINOR_AXIS_END_ID() ||
472 theAttrName == SketchPlugin_EllipticArc::MAJOR_RADIUS_ID() ||
473 theAttrName == SketchPlugin_EllipticArc::MINOR_RADIUS_ID() ||
474 theAttrName == SketchPlugin_EllipticArc::START_POINT_ID() ||
475 theAttrName == SketchPlugin_EllipticArc::END_POINT_ID() ||
476 theAttrName == SketchPlugin_EllipticArc::REVERSED_ID();
478 else if (theOwnerName == SketchPlugin_BSpline::ID()) {
479 return theAttrName == SketchPlugin_BSpline::POLES_ID() ||
480 theAttrName == SketchPlugin_BSpline::WEIGHTS_ID() ||
481 theAttrName == SketchPlugin_BSpline::KNOTS_ID() ||
482 theAttrName == SketchPlugin_BSpline::MULTS_ID() ||
483 theAttrName == SketchPlugin_BSpline::DEGREE_ID() ||
484 theAttrName == SketchPlugin_BSpline::START_ID() ||
485 theAttrName == SketchPlugin_BSpline::END_ID();
487 else if (theOwnerName == SketchPlugin_BSplinePeriodic::ID()) {
488 return theAttrName == SketchPlugin_BSplinePeriodic::POLES_ID() ||
489 theAttrName == SketchPlugin_BSplinePeriodic::WEIGHTS_ID() ||
490 theAttrName == SketchPlugin_BSplinePeriodic::KNOTS_ID() ||
491 theAttrName == SketchPlugin_BSplinePeriodic::MULTS_ID() ||
492 theAttrName == SketchPlugin_BSplinePeriodic::DEGREE_ID();
495 // suppose that all remaining features are points
496 return theAttrName == SketchPlugin_Point::COORD_ID();
499 /// \brief Update value
500 bool PlaneGCSSolver_Tools::updateValue(const double& theSource, double& theDest,
501 const double theTolerance)
503 bool isUpdated = fabs(theSource - theDest) > theTolerance;
510 double PlaneGCSSolver_Tools::distance(const GCS::Point& thePnt1, const GCS::Point& thePnt2)
512 double x = *thePnt1.x - *thePnt2.x;
513 double y = *thePnt1.y - *thePnt2.y;
514 return sqrt(x*x + y*y);
520 // ================ AttributeArray methods ==========================
521 PlaneGCSSolver_Tools::AttributeArray::AttributeArray(AttributePtr theAttribute)
523 myDouble = std::dynamic_pointer_cast<ModelAPI_AttributeDoubleArray>(theAttribute);
524 myInteger = std::dynamic_pointer_cast<ModelAPI_AttributeIntArray>(theAttribute);
527 bool PlaneGCSSolver_Tools::AttributeArray::isInitialized() const
529 return (myDouble && myDouble->isInitialized()) || (myInteger && myInteger->isInitialized());
532 int PlaneGCSSolver_Tools::AttributeArray::size() const
534 return myDouble.get() ? myDouble->size() : myInteger->size();
537 double PlaneGCSSolver_Tools::AttributeArray::value(const int theIndex) const
539 return myDouble.get() ? myDouble->value(theIndex) : myInteger->value(theIndex);
547 // ================ Auxiliary functions ==========================
548 ConstraintWrapperPtr createConstraintCoincidence(
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 // Create equality constraint for corresponding attributes of the points
556 std::list<GCSConstraintPtr> aConstrList;
557 aConstrList.push_back(
558 GCSConstraintPtr(new GCS::ConstraintEqual(aPoint1->x, aPoint2->x)));
559 aConstrList.push_back(
560 GCSConstraintPtr(new GCS::ConstraintEqual(aPoint1->y, aPoint2->y)));
562 return ConstraintWrapperPtr(new PlaneGCSSolver_ConstraintWrapper(
563 aConstrList, CONSTRAINT_PT_PT_COINCIDENT));
566 ConstraintWrapperPtr createConstraintPointOnEntity(
567 const SketchSolver_ConstraintType& theType,
568 std::shared_ptr<PlaneGCSSolver_PointWrapper> thePoint,
569 std::shared_ptr<PlaneGCSSolver_EdgeWrapper> theEntity,
570 std::shared_ptr<PlaneGCSSolver_ScalarWrapper> theValue)
572 GCSConstraintPtr aNewConstr;
574 switch (theEntity->type()) {
576 std::shared_ptr<GCS::Line> aLine = std::dynamic_pointer_cast<GCS::Line>(theEntity->entity());
577 aNewConstr = GCSConstraintPtr(new GCS::ConstraintPointOnLine(*(thePoint->point()), *aLine));
581 case ENTITY_CIRCLE: {
582 std::shared_ptr<GCS::Circle> aCirc =
583 std::dynamic_pointer_cast<GCS::Circle>(theEntity->entity());
584 aNewConstr = GCSConstraintPtr(
585 new GCS::ConstraintP2PDistance(*(thePoint->point()), aCirc->center, aCirc->rad));
589 case ENTITY_ELLIPTIC_ARC: {
590 std::shared_ptr<GCS::Ellipse> anEllipse =
591 std::dynamic_pointer_cast<GCS::Ellipse>(theEntity->entity());
592 aNewConstr = GCSConstraintPtr(
593 new GCS::ConstraintPointOnEllipse(*(thePoint->point()), *anEllipse));
596 case ENTITY_BSPLINE: {
597 std::list<GCSConstraintPtr> aConstraints;
598 aConstraints.push_back(GCSConstraintPtr(new GCS::ConstraintCurveValue(
599 *thePoint->point(), thePoint->point()->x, *theEntity->entity(), theValue->scalar())));
600 aConstraints.push_back(GCSConstraintPtr(new GCS::ConstraintCurveValue(
601 *thePoint->point(), thePoint->point()->y, *theEntity->entity(), theValue->scalar())));
602 return ConstraintWrapperPtr(new PlaneGCSSolver_ConstraintWrapper(aConstraints, theType));
605 return ConstraintWrapperPtr();
608 return ConstraintWrapperPtr(new PlaneGCSSolver_ConstraintWrapper(aNewConstr, theType));
611 ConstraintWrapperPtr createConstraintPointsCollinear(
612 std::shared_ptr<PlaneGCSSolver_PointWrapper> thePoint1,
613 std::shared_ptr<PlaneGCSSolver_PointWrapper> thePoint2,
614 std::shared_ptr<PlaneGCSSolver_PointWrapper> thePoint3)
616 GCSConstraintPtr aNewConstr(new GCS::ConstraintPointOnLine(
617 *(thePoint1->point()), *(thePoint2->point()), *(thePoint3->point())));
618 return ConstraintWrapperPtr(
619 new PlaneGCSSolver_ConstraintWrapper(aNewConstr, CONSTRAINT_PT_ON_CURVE));
622 template <typename ARCTYPE>
623 void createConstraintMiddlePointOnArc(ARCTYPE theArc,
624 GCSPointPtr thePoint,
625 std::shared_ptr<PlaneGCSSolver_PointWrapper> theAuxParameters,
626 std::list<GCSConstraintPtr>& theConstraints)
628 double* u = theAuxParameters->point()->x;
629 double* diff = theAuxParameters->point()->y;
630 *u = (*theArc->startAngle + *theArc->endAngle) * 0.5;
631 *diff = (*theArc->endAngle - *theArc->startAngle) * 0.5;
633 theConstraints.push_back(GCSConstraintPtr(
634 new GCS::ConstraintCurveValue(*thePoint, thePoint->x, *theArc, u)));
635 theConstraints.push_back(GCSConstraintPtr(
636 new GCS::ConstraintCurveValue(*thePoint, thePoint->y, *theArc, u)));
637 theConstraints.push_back(GCSConstraintPtr(
638 new GCS::ConstraintDifference(theArc->startAngle, u, diff)));
639 theConstraints.push_back(GCSConstraintPtr(
640 new GCS::ConstraintDifference(u, theArc->endAngle, diff)));
643 ConstraintWrapperPtr createConstraintMiddlePoint(
644 std::shared_ptr<PlaneGCSSolver_PointWrapper> thePoint,
645 std::shared_ptr<PlaneGCSSolver_EdgeWrapper> theEntity,
646 std::shared_ptr<PlaneGCSSolver_PointWrapper> theAuxParameters)
648 std::list<GCSConstraintPtr> aConstrList;
650 GCSPointPtr aPoint = thePoint->point();
651 std::shared_ptr<GCS::Line> aLine = std::dynamic_pointer_cast<GCS::Line>(theEntity->entity());
653 aConstrList.push_back(GCSConstraintPtr(new GCS::ConstraintPointOnLine(*aPoint, *aLine)));
654 aConstrList.push_back(
655 GCSConstraintPtr(new GCS::ConstraintPointOnPerpBisector(*aPoint, aLine->p1, aLine->p2)));
658 std::shared_ptr<GCS::Arc> anArc = std::dynamic_pointer_cast<GCS::Arc>(theEntity->entity());
660 createConstraintMiddlePointOnArc(anArc, aPoint, theAuxParameters, aConstrList);
662 std::shared_ptr<GCS::ArcOfEllipse> aEllArc =
663 std::dynamic_pointer_cast<GCS::ArcOfEllipse>(theEntity->entity());
665 createConstraintMiddlePointOnArc(aEllArc, aPoint, theAuxParameters, aConstrList);
669 return aConstrList.empty() ? ConstraintWrapperPtr() : ConstraintWrapperPtr(
670 new PlaneGCSSolver_ConstraintWrapper(aConstrList, CONSTRAINT_MIDDLE_POINT));
674 ConstraintWrapperPtr createConstraintDistancePointPoint(
675 std::shared_ptr<PlaneGCSSolver_ScalarWrapper> theValue,
676 std::shared_ptr<PlaneGCSSolver_PointWrapper> thePoint1,
677 std::shared_ptr<PlaneGCSSolver_PointWrapper> thePoint2)
679 GCSConstraintPtr aNewConstr(new GCS::ConstraintP2PDistance(
680 *(thePoint1->point()), *(thePoint2->point()), theValue->scalar()));
681 std::shared_ptr<PlaneGCSSolver_ConstraintWrapper> aResult(
682 new PlaneGCSSolver_ConstraintWrapper(aNewConstr, CONSTRAINT_PT_PT_DISTANCE));
683 aResult->setValueParameter(theValue);
687 ConstraintWrapperPtr createConstraintDistancePointLine(
688 std::shared_ptr<PlaneGCSSolver_ScalarWrapper> theValue,
689 std::shared_ptr<PlaneGCSSolver_PointWrapper> thePoint,
690 std::shared_ptr<PlaneGCSSolver_EdgeWrapper> theEntity)
692 std::shared_ptr<GCS::Line> aLine = std::dynamic_pointer_cast<GCS::Line>(theEntity->entity());
693 GCSConstraintPtr aNewConstr(new GCS::ConstraintP2LDistance(
694 *(thePoint->point()), *(aLine), theValue->scalar()));
695 std::shared_ptr<PlaneGCSSolver_ConstraintWrapper> aResult(
696 new PlaneGCSSolver_ConstraintWrapper(aNewConstr, CONSTRAINT_PT_LINE_DISTANCE));
697 aResult->setValueParameter(theValue);
701 ConstraintWrapperPtr createConstraintHVDistance(
702 const SketchSolver_ConstraintType& theType,
703 std::shared_ptr<PlaneGCSSolver_ScalarWrapper> theValue,
704 std::shared_ptr<PlaneGCSSolver_PointWrapper> thePoint1,
705 std::shared_ptr<PlaneGCSSolver_PointWrapper> thePoint2)
707 GCSPointPtr aPoint1 = thePoint1->point();
708 GCSPointPtr aPoint2 = thePoint2->point();
710 double *aParam1, *aParam2;
711 if (theType == CONSTRAINT_HORIZONTAL_DISTANCE) {
712 aParam1 = aPoint1->x;
713 aParam2 = aPoint2->x;
714 } else if (theType == CONSTRAINT_VERTICAL_DISTANCE) {
715 aParam1 = aPoint1->y;
716 aParam2 = aPoint2->y;
719 GCSConstraintPtr aNewConstr(new GCS::ConstraintDifference(aParam1, aParam2, theValue->scalar()));
721 std::shared_ptr<PlaneGCSSolver_ConstraintWrapper> aResult(
722 new PlaneGCSSolver_ConstraintWrapper(aNewConstr, theType));
723 aResult->setValueParameter(theValue);
727 ConstraintWrapperPtr createConstraintRadius(
728 std::shared_ptr<PlaneGCSSolver_ScalarWrapper> theValue,
729 std::shared_ptr<PlaneGCSSolver_EdgeWrapper> theEntity)
731 std::shared_ptr<GCS::Circle> aCircle =
732 std::dynamic_pointer_cast<GCS::Circle>(theEntity->entity());
733 GCSConstraintPtr aNewConstr(new GCS::ConstraintEqual(aCircle->rad, theValue->scalar()));
734 std::shared_ptr<PlaneGCSSolver_ConstraintWrapper> aResult(
735 new PlaneGCSSolver_ConstraintWrapper(aNewConstr, CONSTRAINT_RADIUS));
736 aResult->setValueParameter(theValue);
740 ConstraintWrapperPtr createConstraintAngle(
741 ConstraintPtr theConstraint,
742 std::shared_ptr<PlaneGCSSolver_ScalarWrapper> theValue,
743 std::shared_ptr<PlaneGCSSolver_EdgeWrapper> theEntity1,
744 std::shared_ptr<PlaneGCSSolver_EdgeWrapper> theEntity2)
746 std::shared_ptr<GCS::Line> aLine1 = std::dynamic_pointer_cast<GCS::Line>(theEntity1->entity());
747 std::shared_ptr<GCS::Line> aLine2 = std::dynamic_pointer_cast<GCS::Line>(theEntity2->entity());
749 GCSConstraintPtr aNewConstr(new GCS::ConstraintL2LAngle(
750 aLine1->p1, aLine1->p2, aLine2->p1, aLine2->p2, theValue->scalar()));
752 std::shared_ptr<PlaneGCSSolver_ConstraintWrapper> aResult(
753 new PlaneGCSSolver_ConstraintWrapper(aNewConstr, CONSTRAINT_ANGLE));
754 aResult->setValueParameter(theValue);
758 ConstraintWrapperPtr createConstraintHorizVert(
759 const SketchSolver_ConstraintType& theType,
760 std::shared_ptr<PlaneGCSSolver_EdgeWrapper> theEntity)
762 std::shared_ptr<GCS::Line> aLine = std::dynamic_pointer_cast<GCS::Line>(theEntity->entity());
763 GCSConstraintPtr aNewConstr;
764 if (theType == CONSTRAINT_HORIZONTAL)
765 aNewConstr = GCSConstraintPtr(new GCS::ConstraintEqual(aLine->p1.y, aLine->p2.y));
767 aNewConstr = GCSConstraintPtr(new GCS::ConstraintEqual(aLine->p1.x, aLine->p2.x));
769 return ConstraintWrapperPtr(new PlaneGCSSolver_ConstraintWrapper(aNewConstr, theType));
772 ConstraintWrapperPtr createConstraintParallel(
773 std::shared_ptr<PlaneGCSSolver_EdgeWrapper> theEntity1,
774 std::shared_ptr<PlaneGCSSolver_EdgeWrapper> theEntity2)
776 std::shared_ptr<GCS::Line> aLine1 = std::dynamic_pointer_cast<GCS::Line>(theEntity1->entity());
777 std::shared_ptr<GCS::Line> aLine2 = std::dynamic_pointer_cast<GCS::Line>(theEntity2->entity());
778 GCSConstraintPtr aNewConstr(new GCS::ConstraintParallel(*(aLine1), *(aLine2)));
780 return ConstraintWrapperPtr(
781 new PlaneGCSSolver_ConstraintWrapper(aNewConstr, CONSTRAINT_PARALLEL));
784 ConstraintWrapperPtr createConstraintPerpendicular(
785 std::shared_ptr<PlaneGCSSolver_EdgeWrapper> theEntity1,
786 std::shared_ptr<PlaneGCSSolver_EdgeWrapper> theEntity2)
788 std::shared_ptr<GCS::Line> aLine1 = std::dynamic_pointer_cast<GCS::Line>(theEntity1->entity());
789 std::shared_ptr<GCS::Line> aLine2 = std::dynamic_pointer_cast<GCS::Line>(theEntity2->entity());
791 std::shared_ptr<GCS::Circle> aCirc1 =
792 std::dynamic_pointer_cast<GCS::Circle>(theEntity1->entity());
793 std::shared_ptr<GCS::Circle> aCirc2 =
794 std::dynamic_pointer_cast<GCS::Circle>(theEntity2->entity());
796 GCSConstraintPtr aNewConstr;
797 if (aLine1 && aLine2)
798 aNewConstr.reset(new GCS::ConstraintPerpendicular(*(aLine1), *(aLine2)));
800 if (aLine1 && aCirc2)
802 else if (aLine2 && aCirc1)
805 aNewConstr.reset(new GCS::ConstraintPointOnLine(aCirc1->center, *aLine1));
808 return ConstraintWrapperPtr(
809 new PlaneGCSSolver_ConstraintWrapper(aNewConstr, CONSTRAINT_PERPENDICULAR));
812 ConstraintWrapperPtr createConstraintAngleBetweenCurves(
813 std::shared_ptr<PlaneGCSSolver_ScalarWrapper> theValue,
814 std::shared_ptr<PlaneGCSSolver_PointWrapper> thePoint,
815 std::shared_ptr<PlaneGCSSolver_EdgeWrapper> theEntity1,
816 std::shared_ptr<PlaneGCSSolver_EdgeWrapper> theEntity2)
818 GCSConstraintPtr aNewConstr(new GCS::ConstraintAngleViaPoint(
819 *theEntity1->entity(), *theEntity2->entity(), *thePoint->point(), theValue->scalar()));
820 return ConstraintWrapperPtr(
821 new PlaneGCSSolver_ConstraintWrapper(aNewConstr, CONSTRAINT_PERPENDICULAR_CURVES));
824 ConstraintWrapperPtr createConstraintEqual(
825 const SketchSolver_ConstraintType& theType,
826 std::shared_ptr<PlaneGCSSolver_EdgeWrapper> theEntity1,
827 std::shared_ptr<PlaneGCSSolver_EdgeWrapper> theEntity2,
828 std::shared_ptr<PlaneGCSSolver_ScalarWrapper> theIntermed)
830 if (theType == CONSTRAINT_EQUAL_LINE_ARC)
831 return ConstraintWrapperPtr(); // line-arc equivalence is not supported yet
833 std::list<GCSConstraintPtr> aConstrList;
834 if (theType == CONSTRAINT_EQUAL_LINES) {
835 std::shared_ptr<GCS::Line> aLine1 = std::dynamic_pointer_cast<GCS::Line>(theEntity1->entity());
836 std::shared_ptr<GCS::Line> aLine2 = std::dynamic_pointer_cast<GCS::Line>(theEntity2->entity());
838 aConstrList.push_back(GCSConstraintPtr(
839 new GCS::ConstraintP2PDistance(aLine1->p1, aLine1->p2, theIntermed->scalar())));
840 aConstrList.push_back(GCSConstraintPtr(
841 new GCS::ConstraintP2PDistance(aLine2->p1, aLine2->p2, theIntermed->scalar())));
842 // update value of intermediate parameter
843 theIntermed->setValue(PlaneGCSSolver_Tools::distance(aLine1->p1, aLine1->p2));
845 else if (theType == CONSTRAINT_EQUAL_ELLIPSES) {
846 std::shared_ptr<GCS::Ellipse> anEllipse1 =
847 std::dynamic_pointer_cast<GCS::Ellipse>(theEntity1->entity());
848 std::shared_ptr<GCS::Ellipse> anEllipse2 =
849 std::dynamic_pointer_cast<GCS::Ellipse>(theEntity2->entity());
851 aConstrList.push_back(GCSConstraintPtr(
852 new GCS::ConstraintEqual(anEllipse1->radmin, anEllipse2->radmin)));
853 aConstrList.push_back(GCSConstraintPtr(new GCS::ConstraintP2PDistance(
854 anEllipse1->center, anEllipse1->focus1, theIntermed->scalar())));
855 aConstrList.push_back(GCSConstraintPtr(new GCS::ConstraintP2PDistance(
856 anEllipse2->center, anEllipse2->focus1, theIntermed->scalar())));
857 // update value of intermediate parameter
858 theIntermed->setValue(PlaneGCSSolver_Tools::distance(anEllipse1->center, anEllipse1->focus1));
861 std::shared_ptr<GCS::Circle> aCirc1 =
862 std::dynamic_pointer_cast<GCS::Circle>(theEntity1->entity());
863 std::shared_ptr<GCS::Circle> aCirc2 =
864 std::dynamic_pointer_cast<GCS::Circle>(theEntity2->entity());
865 aConstrList.push_back(GCSConstraintPtr(new GCS::ConstraintEqual(aCirc1->rad, aCirc2->rad)));
868 std::shared_ptr<PlaneGCSSolver_ConstraintWrapper> aResult(
869 new PlaneGCSSolver_ConstraintWrapper(aConstrList, theType));
871 aResult->setValueParameter(theIntermed);
875 GCS::SET_pD scalarParameters(const ScalarWrapperPtr& theScalar)
878 aParams.insert(theScalar->scalar());
882 GCS::SET_pD scalarArrayParameters(const EntityWrapperPtr& theArray)
884 ScalarArrayWrapperPtr anArray =
885 std::dynamic_pointer_cast<PlaneGCSSolver_ScalarArrayWrapper>(theArray);
886 return GCS::SET_pD(anArray->array().begin(), anArray->array().end());
889 GCS::SET_pD pointParameters(const PointWrapperPtr& thePoint)
892 aParams.insert(thePoint->point()->x);
893 aParams.insert(thePoint->point()->y);
897 GCS::SET_pD pointArrayParameters(const EntityWrapperPtr& theArray)
900 PointArrayWrapperPtr aPoints =
901 std::dynamic_pointer_cast<PlaneGCSSolver_PointArrayWrapper>(theArray);
902 for (std::vector<PointWrapperPtr>::const_iterator anIt = aPoints->array().begin();
903 anIt != aPoints->array().end(); ++anIt) {
904 GCS::SET_pD aPointParams = PlaneGCSSolver_Tools::parameters(*anIt);
905 aParams.insert(aPointParams.begin(), aPointParams.end());
910 GCS::SET_pD lineParameters(const EdgeWrapperPtr& theLine)
913 std::shared_ptr<GCS::Line> aLine = std::dynamic_pointer_cast<GCS::Line>(theLine->entity());
914 aParams.insert(aLine->p1.x);
915 aParams.insert(aLine->p1.y);
916 aParams.insert(aLine->p2.x);
917 aParams.insert(aLine->p2.y);
921 GCS::SET_pD circleParameters(const EdgeWrapperPtr& theCircle)
924 std::shared_ptr<GCS::Circle> aCirc = std::dynamic_pointer_cast<GCS::Circle>(theCircle->entity());
925 aParams.insert(aCirc->center.x);
926 aParams.insert(aCirc->center.y);
927 aParams.insert(aCirc->rad);
931 GCS::SET_pD arcParameters(const EdgeWrapperPtr& theArc)
933 GCS::SET_pD aParams = circleParameters(theArc);
934 std::shared_ptr<GCS::Arc> anArc = std::dynamic_pointer_cast<GCS::Arc>(theArc->entity());
935 aParams.insert(anArc->start.x);
936 aParams.insert(anArc->start.y);
937 aParams.insert(anArc->end.x);
938 aParams.insert(anArc->end.y);
939 aParams.insert(anArc->startAngle);
940 aParams.insert(anArc->endAngle);
944 GCS::SET_pD ellipseParameters(const EdgeWrapperPtr& theEllipse)
947 std::shared_ptr<GCS::Ellipse> anEllipse =
948 std::dynamic_pointer_cast<GCS::Ellipse>(theEllipse->entity());
949 aParams.insert(anEllipse->center.x);
950 aParams.insert(anEllipse->center.y);
951 aParams.insert(anEllipse->focus1.x);
952 aParams.insert(anEllipse->focus1.y);
953 aParams.insert(anEllipse->radmin);
957 GCS::SET_pD ellipticArcParameters(const EdgeWrapperPtr& theEllipticArc)
959 GCS::SET_pD aParams = ellipseParameters(theEllipticArc);
960 std::shared_ptr<GCS::ArcOfEllipse> anArc =
961 std::dynamic_pointer_cast<GCS::ArcOfEllipse>(theEllipticArc->entity());
962 aParams.insert(anArc->start.x);
963 aParams.insert(anArc->start.y);
964 aParams.insert(anArc->end.x);
965 aParams.insert(anArc->end.y);
966 aParams.insert(anArc->startAngle);
967 aParams.insert(anArc->endAngle);
971 GCS::SET_pD bsplineParameters(const EdgeWrapperPtr& theEdge)
975 std::shared_ptr<GCS::BSpline> aBSpline =
976 std::dynamic_pointer_cast<GCS::BSpline>(theEdge->entity());
978 for (GCS::VEC_P::iterator it = aBSpline->poles.begin(); it != aBSpline->poles.end(); ++it) {
979 aParams.insert(it->x);
980 aParams.insert(it->y);
982 for (GCS::VEC_pD::iterator it = aBSpline->weights.begin(); it != aBSpline->weights.end(); ++it)