1 #include <SketchSolver_Constraint.h>
2 #include <SketchSolver_Group.h>
3 #include <SketchSolver_Error.h>
5 #include <SketchPlugin_Arc.h>
6 #include <SketchPlugin_Circle.h>
7 #include <SketchPlugin_Line.h>
8 #include <SketchPlugin_Point.h>
10 #include <GeomDataAPI_Point.h>
11 #include <GeomDataAPI_Point2D.h>
12 #include <ModelAPI_AttributeDouble.h>
13 #include <ModelAPI_ResultConstruction.h>
17 SketchSolver_Constraint::SketchSolver_Constraint(
18 ConstraintPtr theConstraint)
19 : myBaseConstraint(theConstraint),
24 SketchSolver_Constraint::~SketchSolver_Constraint()
26 std::map<AttributePtr, Slvs_hParam>::const_iterator anIt1 = myValueMap.begin();
27 for (; anIt1 != myValueMap.end(); anIt1++)
28 myStorage->removeParameter(anIt1->second);
31 std::map<AttributePtr, Slvs_hEntity>::const_iterator anIt2 = myAttributeMap.begin();
32 for (; anIt2 != myAttributeMap.end(); anIt2++)
33 myStorage->removeEntity(anIt2->second);
34 myAttributeMap.clear();
36 std::map<FeaturePtr, Slvs_hEntity>::iterator anIt3 = myFeatureMap.begin();
37 while (!myFeatureMap.empty()) {
38 std::shared_ptr<SketchPlugin_Feature> aFeature =
39 std::dynamic_pointer_cast<SketchPlugin_Feature>(anIt3->first);
40 Slvs_hEntity anEnt = anIt3->second;
41 std::map<FeaturePtr, Slvs_hEntity>::iterator aRemIt = anIt3++;
42 myFeatureMap.erase(aRemIt);
43 if (!myGroup->isInteract(aFeature))
44 myStorage->removeEntity(anEnt);
47 std::vector<Slvs_hConstraint>::const_iterator anIt4 = mySlvsConstraints.begin();
48 for (; anIt4 != mySlvsConstraints.end(); anIt4++)
49 myStorage->removeConstraint(*anIt4);
50 mySlvsConstraints.clear();
53 void SketchSolver_Constraint::setStorage(StoragePtr theStorage)
55 myStorage = theStorage;
59 void SketchSolver_Constraint::setGroup(SketchSolver_Group* theGroup)
65 void SketchSolver_Constraint::addFeature(FeaturePtr theFeature)
68 changeEntity(theFeature, aType);
72 void SketchSolver_Constraint::process()
75 if (!myBaseConstraint || !myStorage || myGroup == 0) {
76 /// TODO: Put error message here
79 if (!mySlvsConstraints.empty()) // some data is changed, update constraint
80 update(myBaseConstraint);
82 int aConstrType = getType();
84 std::vector<Slvs_hEntity> anAttributes;
85 getAttributes(aValue, anAttributes);
86 if (!myErrorMsg.empty())
88 if (aConstrType == SLVS_C_UNKNOWN)
89 aConstrType = getType();
91 Slvs_hGroup aGroupID = myGroup->getId();
92 Slvs_hEntity aWorkplaneID = myGroup->getWorkplaneId();
93 Slvs_Constraint aConstraint;
94 if (mySlvsConstraints.empty())
95 aConstraint = Slvs_MakeConstraint(SLVS_C_UNKNOWN, aGroupID, aConstrType, aWorkplaneID,
96 aValue, anAttributes[0], anAttributes[1], anAttributes[2], anAttributes[3]);
98 aConstraint = myStorage->getConstraint(mySlvsConstraints[0]);
99 aConstraint.valA = aValue;
100 static const int aNbAttrs = 6;
101 Slvs_hEntity* aConstrAttrs[aNbAttrs] = {
102 &aConstraint.ptA, &aConstraint.ptB,
103 &aConstraint.entityA, &aConstraint.entityB,
104 &aConstraint.entityC, &aConstraint.entityD};
105 std::vector<Slvs_hEntity>::const_iterator anIter = anAttributes.begin();
106 for (int i = 0; i < aNbAttrs && anIter != anAttributes.end(); i++, anIter++)
107 *(aConstrAttrs[i]) = *anIter;
110 Slvs_hConstraint anID = myStorage->addConstraint(aConstraint);
111 if (mySlvsConstraints.empty())
112 mySlvsConstraints.push_back(anID);
114 mySlvsConstraints[0] = anID;
118 bool SketchSolver_Constraint::checkAttributesChanged(ConstraintPtr theConstraint)
120 // Check the attrbutes of constraint are changed
121 ConstraintPtr aConstraint = theConstraint ? theConstraint : myBaseConstraint;
122 std::list<AttributePtr> anAttrList = aConstraint->data()->attributes(std::string());
123 std::list<AttributePtr>::iterator anAttrIter = anAttrList.begin();
124 for (; anAttrIter != anAttrList.end(); anAttrIter++) {
125 AttributeRefAttrPtr aRefAttr =
126 std::dynamic_pointer_cast<ModelAPI_AttributeRefAttr>(*anAttrIter);
128 if (aRefAttr->isObject()) {
129 FeaturePtr aFeature = ModelAPI_Feature::feature(aRefAttr->object());
130 if (aFeature && myFeatureMap.find(aFeature) == myFeatureMap.end())
132 } else if (aRefAttr->attr() &&
133 myAttributeMap.find(aRefAttr->attr()) == myAttributeMap.end())
136 AttributeRefListPtr aRefList =
137 std::dynamic_pointer_cast<ModelAPI_AttributeRefList>(*anAttrIter);
139 std::list<ObjectPtr> anItems = aRefList->list();
140 std::list<ObjectPtr>::iterator anIt = anItems.begin();
141 for (; anIt != anItems.end(); anIt++) {
142 FeaturePtr aFeature = ModelAPI_Feature::feature(*anIt);
143 if (aFeature && myFeatureMap.find(aFeature) == myFeatureMap.end())
151 void SketchSolver_Constraint::update(ConstraintPtr theConstraint)
154 bool needToRebuild = (theConstraint && theConstraint != myBaseConstraint);
156 needToRebuild = checkAttributesChanged(theConstraint);
158 if (theConstraint && theConstraint->getKind() != myBaseConstraint->getKind())
160 remove(myBaseConstraint);
162 myBaseConstraint = theConstraint;
167 // Update all attributes
169 std::map<Slvs_hEntity, Slvs_hEntity> aRelocationMap;
170 std::map<FeaturePtr, Slvs_hEntity>::iterator aFeatIter = myFeatureMap.begin();
171 for (; aFeatIter != myFeatureMap.end(); aFeatIter++) {
172 Slvs_hEntity aPrevID = aFeatIter->second;
173 aFeatIter->second = changeEntity(aFeatIter->first, aType);
174 if (aFeatIter->second != aPrevID)
175 aRelocationMap[aPrevID] = aFeatIter->second;
177 std::map<AttributePtr, Slvs_hEntity>::iterator anAttrIter = myAttributeMap.begin();
178 for (; anAttrIter != myAttributeMap.end(); anAttrIter++) {
179 Slvs_hEntity aPrevID = anAttrIter->second;
180 anAttrIter->second = changeEntity(anAttrIter->first, aType);
181 if (anAttrIter->second != aPrevID)
182 aRelocationMap[aPrevID] = anAttrIter->second;
186 DataPtr aData = myBaseConstraint->data();
188 AttributeDoublePtr aValueAttr = std::dynamic_pointer_cast<ModelAPI_AttributeDouble>(
189 myBaseConstraint->attribute(SketchPlugin_Constraint::VALUE()));
190 double aValue = aValueAttr ? aValueAttr->value() : 0.0;
193 std::vector<Slvs_hConstraint>::iterator aCIter = mySlvsConstraints.begin();
194 for (; aCIter != mySlvsConstraints.end(); aCIter++) {
195 Slvs_Constraint aConstraint = myStorage->getConstraint(*aCIter);
197 aConstraint.valA = aValue;
198 Slvs_hEntity* aCoeffs[6] = {
199 &aConstraint.ptA, &aConstraint.ptB,
200 &aConstraint.entityA, &aConstraint.entityB,
201 &aConstraint.entityC, &aConstraint.entityD};
202 for (int i = 0; i < 6; i++) {
203 if (*(aCoeffs[i]) == SLVS_E_UNKNOWN)
205 std::map<Slvs_hEntity, Slvs_hEntity>::iterator aFound = aRelocationMap.find(*(aCoeffs[i]));
206 if (aFound != aRelocationMap.end())
207 *(aCoeffs[i]) = aFound->second;
209 *aCIter = myStorage->addConstraint(aConstraint);
214 bool SketchSolver_Constraint::remove(ConstraintPtr theConstraint)
217 if (theConstraint && theConstraint != myBaseConstraint)
219 if (mySlvsConstraints.empty())
221 bool isFullyRemoved = myStorage->removeConstraint(mySlvsConstraints.front());
222 if (isFullyRemoved) {
223 myFeatureMap.clear();
224 myAttributeMap.clear();
227 cleanRemovedEntities();
228 mySlvsConstraints.clear();
232 void SketchSolver_Constraint::cleanRemovedEntities()
234 std::set<Slvs_hParam> aRemovedParams;
235 std::set<Slvs_hEntity> aRemovedEntities;
236 std::set<Slvs_hConstraint> aRemovedConstraints;
237 myStorage->getRemoved(aRemovedParams, aRemovedEntities, aRemovedConstraints);
238 std::map<FeaturePtr, Slvs_hEntity>::iterator aFeatIt = myFeatureMap.begin();
239 while (aFeatIt != myFeatureMap.end()) {
240 if (aRemovedEntities.find(aFeatIt->second) == aRemovedEntities.end()) {
244 std::map<FeaturePtr, Slvs_hEntity>::iterator aTmpIter = aFeatIt++;
245 myFeatureMap.erase(aTmpIter);
247 std::map<AttributePtr, Slvs_hEntity>::iterator anAttrIt = myAttributeMap.begin();
248 while (anAttrIt != myAttributeMap.end()) {
249 if (aRemovedEntities.find(anAttrIt->second) == aRemovedEntities.end()) {
253 std::map<AttributePtr, Slvs_hEntity>::iterator aTmpIter = anAttrIt++;
254 myAttributeMap.erase(aTmpIter);
256 std::map<AttributePtr, Slvs_hParam>::iterator aValIt = myValueMap.begin();
257 while (aValIt != myValueMap.end()) {
258 if (aRemovedParams.find(aValIt->second) == aRemovedParams.end()) {
262 std::map<AttributePtr, Slvs_hParam>::iterator aTmpIter = aValIt++;
263 myValueMap.erase(aTmpIter);
267 void SketchSolver_Constraint::getAttributes(
269 std::vector<Slvs_hEntity>& theAttributes)
271 static const int anInitNbOfAttr = 4;
272 theAttributes.assign(anInitNbOfAttr, SLVS_E_UNKNOWN);
274 DataPtr aData = myBaseConstraint->data();
276 AttributeDoublePtr aValueAttr = std::dynamic_pointer_cast<ModelAPI_AttributeDouble>(
277 aData->attribute(SketchPlugin_Constraint::VALUE()));
278 theValue = aValueAttr ? aValueAttr->value() : 0.0;
280 int aPtInd = 0; // index of first point in the list of attributes
281 int aEntInd = 2; // index of first antity in the list of attributes
282 std::list<AttributePtr> aConstrAttrs = aData->attributes(ModelAPI_AttributeRefAttr::typeId());
283 std::list<AttributePtr>::iterator anIter = aConstrAttrs.begin();
284 for (; anIter != aConstrAttrs.end(); anIter++) {
285 AttributeRefAttrPtr aRefAttr =
286 std::dynamic_pointer_cast<ModelAPI_AttributeRefAttr>(*anIter);
287 if (!aRefAttr || !aRefAttr->isInitialized()) {
288 myErrorMsg = SketchSolver_Error::NOT_INITIALIZED();
292 int aType = SLVS_E_UNKNOWN; // type of created entity
293 Slvs_hEntity anEntity = myGroup->getAttributeId(aRefAttr);
294 if (anEntity == SLVS_E_UNKNOWN)
295 anEntity = changeEntity(aRefAttr, aType);
297 Slvs_Entity anEnt = myStorage->getEntity(anEntity);
301 if (aType == SLVS_E_UNKNOWN)
303 else if (aType == SLVS_E_POINT_IN_2D || aType == SLVS_E_POINT_IN_3D)
304 theAttributes[aPtInd++] = anEntity; // the point is created
305 else { // another entity (not a point) is created
306 if (aEntInd < anInitNbOfAttr)
307 theAttributes[aEntInd] = anEntity;
309 theAttributes.push_back(anEntity);
315 Slvs_hEntity SketchSolver_Constraint::changeEntity(AttributeRefAttrPtr theAttribute, int& theType)
317 // Convert the object of the attribute to the feature
319 if (theAttribute->isObject() && theAttribute->object()) {
320 ResultConstructionPtr aRC = std::dynamic_pointer_cast<ModelAPI_ResultConstruction>(
321 theAttribute->object());
323 myErrorMsg = SketchSolver_Error::NOT_INITIALIZED();
324 return SLVS_E_UNKNOWN;
326 std::shared_ptr<ModelAPI_Document> aDoc = aRC->document();
327 aFeature = aDoc->feature(aRC);
329 return changeEntity(aFeature, theType);
332 return changeEntity(theAttribute->attr(), theType);
335 Slvs_hEntity SketchSolver_Constraint::changeEntity(AttributePtr theEntity, int& theType)
337 Slvs_hEntity aResult = SLVS_E_UNKNOWN;
338 if (!theEntity || !isInitialized(theEntity))
339 return SLVS_E_UNKNOWN;
341 // If the entity is already in the group, try to find it
342 std::map<std::shared_ptr<ModelAPI_Attribute>, Slvs_hEntity>::const_iterator anEntIter =
343 myAttributeMap.find(theEntity);
344 Slvs_Entity aCurrentEntity;
345 aCurrentEntity.h = SLVS_E_UNKNOWN;
346 if (anEntIter != myAttributeMap.end())
347 aCurrentEntity = myStorage->getEntity(anEntIter->second);
349 aResult = myGroup->getAttributeId(theEntity);
350 if (aResult != SLVS_E_UNKNOWN) {
351 Slvs_Entity anEnt = myStorage->getEntity(aResult);
352 theType = anEnt.type;
353 myAttributeMap[theEntity] = aResult;
358 Slvs_hGroup aGroupID = myGroup->getId();
360 std::shared_ptr<GeomDataAPI_Point> aPoint =
361 std::dynamic_pointer_cast<GeomDataAPI_Point>(theEntity);
363 double aXYZ[3] = {aPoint->x(), aPoint->y(), aPoint->z()};
364 Slvs_hParam aParams[3];
365 for (int i = 0; i < 3; i++) {
366 Slvs_Param aPar = aCurrentEntity.h != SLVS_E_UNKNOWN ?
367 myStorage->getParameter(aCurrentEntity.param[i]) :
368 Slvs_MakeParam(SLVS_E_UNKNOWN, aGroupID, 0.0);
370 aParams[i] = myStorage->addParameter(aPar);
373 if (aCurrentEntity.h == SLVS_E_UNKNOWN) // New entity
374 aCurrentEntity = Slvs_MakePoint3d(SLVS_E_UNKNOWN, aGroupID, aParams[0], aParams[1], aParams[2]);
375 else { // update entity data
376 for (int i = 0; i < 3; i++)
377 aCurrentEntity.param[i] = aParams[i];
379 aResult = myStorage->addEntity(aCurrentEntity);
381 // All entities except 3D points are created on workplane. So, if there is no workplane yet, then error
382 Slvs_hEntity aWorkplaneID = myGroup->getWorkplaneId();
383 if (aWorkplaneID == SLVS_E_UNKNOWN)
384 return SLVS_E_UNKNOWN;
387 std::shared_ptr<GeomDataAPI_Point2D> aPoint2D =
388 std::dynamic_pointer_cast<GeomDataAPI_Point2D>(theEntity);
390 double aXY[2] = {aPoint2D->x(), aPoint2D->y()};
391 Slvs_hParam aParams[2];
392 for (int i = 0; i < 2; i++) {
393 Slvs_Param aPar = aCurrentEntity.h != SLVS_E_UNKNOWN ?
394 myStorage->getParameter(aCurrentEntity.param[i]) :
395 Slvs_MakeParam(SLVS_E_UNKNOWN, aGroupID, 0.0);
397 aParams[i] = myStorage->addParameter(aPar);
400 if (aCurrentEntity.h == SLVS_E_UNKNOWN) // New entity
401 aCurrentEntity = Slvs_MakePoint2d(SLVS_E_UNKNOWN, aGroupID, aWorkplaneID, aParams[0], aParams[1]);
402 else { // update entity data
403 for (int i = 0; i < 2; i++)
404 aCurrentEntity.param[i] = aParams[i];
406 aResult = myStorage->addEntity(aCurrentEntity);
408 // Scalar value (used for the distance entities)
409 AttributeDoublePtr aScalar = std::dynamic_pointer_cast<ModelAPI_AttributeDouble>(theEntity);
411 Slvs_Param aParam = aCurrentEntity.h != SLVS_E_UNKNOWN ?
412 myStorage->getParameter(aCurrentEntity.param[0]) :
413 Slvs_MakeParam(SLVS_E_UNKNOWN, aGroupID, 0.0);
414 aParam.val = aScalar->value();
415 Slvs_hParam aValue = myStorage->addParameter(aParam);
417 if (aCurrentEntity.h == SLVS_E_UNKNOWN) // New entity
418 aCurrentEntity = Slvs_MakeDistance(SLVS_E_UNKNOWN, aGroupID, aWorkplaneID, aValue);
420 aCurrentEntity.param[0] = aValue;
421 aResult = myStorage->addEntity(aCurrentEntity);
426 myAttributeMap[theEntity] = aResult;
427 theType = aCurrentEntity.type;
431 Slvs_hEntity SketchSolver_Constraint::changeEntity(FeaturePtr theEntity, int& theType)
433 Slvs_hEntity aResult = SLVS_E_UNKNOWN;
434 if (!theEntity || !theEntity->data() || !theEntity->data()->isValid())
435 return SLVS_E_UNKNOWN;
436 // If the entity is already in the group, try to find it
437 std::map<FeaturePtr, Slvs_hEntity>::const_iterator anEntIter = myFeatureMap.find(theEntity);
438 Slvs_Entity aCurrentEntity;
439 aCurrentEntity.h = SLVS_E_UNKNOWN;
440 if (anEntIter != myFeatureMap.end())
441 aCurrentEntity = myStorage->getEntity(anEntIter->second);
443 aResult = myGroup->getFeatureId(theEntity);
444 if (aResult != SLVS_E_UNKNOWN) {
445 Slvs_Entity anEnt = myStorage->getEntity(aResult);
446 theType = anEnt.type;
447 myFeatureMap[theEntity] = aResult;
452 Slvs_hGroup aGroupID = myGroup->getId();
453 Slvs_hEntity aWorkplaneID = myGroup->getWorkplaneId();
454 DataPtr aData = theEntity->data();
456 // SketchPlugin features
457 const std::string& aFeatureKind = theEntity->getKind();
458 AttributePtr anAttribute;
461 if (aFeatureKind == SketchPlugin_Line::ID()) {
462 anAttribute = aData->attribute(SketchPlugin_Line::START_ID());
463 if (!isInitialized(anAttribute)) return SLVS_E_UNKNOWN;
464 Slvs_hEntity aStart = changeEntity(anAttribute, anAttrType);
466 anAttribute = aData->attribute(SketchPlugin_Line::END_ID());
467 if (!isInitialized(anAttribute)) return SLVS_E_UNKNOWN;
468 Slvs_hEntity aEnd = changeEntity(anAttribute, anAttrType);
470 if (aCurrentEntity.h == SLVS_E_UNKNOWN) // New entity
471 aCurrentEntity = Slvs_MakeLineSegment(SLVS_E_UNKNOWN, aGroupID, aWorkplaneID, aStart, aEnd);
473 aCurrentEntity.point[0] = aStart;
474 aCurrentEntity.point[1] = aEnd;
476 aResult = myStorage->addEntity(aCurrentEntity);
479 else if (aFeatureKind == SketchPlugin_Circle::ID()) {
480 anAttribute = aData->attribute(SketchPlugin_Circle::CENTER_ID());
481 if (!isInitialized(anAttribute)) return SLVS_E_UNKNOWN;
482 Slvs_hEntity aCenter = changeEntity(anAttribute, anAttrType);
484 anAttribute = aData->attribute(SketchPlugin_Circle::RADIUS_ID());
485 if (!isInitialized(anAttribute)) return SLVS_E_UNKNOWN;
486 Slvs_hEntity aRadius = changeEntity(anAttribute, anAttrType);
488 if (aCurrentEntity.h == SLVS_E_UNKNOWN) { // New entity
489 Slvs_Entity aWorkplane = myStorage->getEntity(aWorkplaneID);
490 aCurrentEntity = Slvs_MakeCircle(SLVS_E_UNKNOWN, aGroupID, aWorkplaneID,
491 aCenter, aWorkplane.normal, aRadius);
493 aCurrentEntity.point[0] = aCenter;
494 aCurrentEntity.distance = aRadius;
496 aResult = myStorage->addEntity(aCurrentEntity);
499 else if (aFeatureKind == SketchPlugin_Arc::ID()) {
500 anAttribute = aData->attribute(SketchPlugin_Arc::CENTER_ID());
501 if (!isInitialized(anAttribute)) return SLVS_E_UNKNOWN;
502 Slvs_hEntity aCenter = changeEntity(anAttribute, anAttrType);
504 anAttribute = aData->attribute(SketchPlugin_Arc::START_ID());
505 if (!isInitialized(anAttribute)) return SLVS_E_UNKNOWN;
506 Slvs_hEntity aStart = changeEntity(anAttribute, anAttrType);
508 anAttribute = aData->attribute(SketchPlugin_Arc::END_ID());
509 if (!isInitialized(anAttribute)) return SLVS_E_UNKNOWN;
510 Slvs_hEntity aEnd = changeEntity(anAttribute, anAttrType);
512 if (aCurrentEntity.h == SLVS_E_UNKNOWN) { // New entity
513 Slvs_Entity aWorkplane = myStorage->getEntity(aWorkplaneID);
514 aCurrentEntity = Slvs_MakeArcOfCircle(SLVS_E_UNKNOWN, aGroupID, aWorkplaneID,
515 aWorkplane.normal, aCenter, aStart, aEnd);
517 aCurrentEntity.point[0] = aCenter;
518 aCurrentEntity.point[1] = aStart;
519 aCurrentEntity.point[2] = aEnd;
521 aResult = myStorage->addEntity(aCurrentEntity);
523 // Point (it has low probability to be an attribute of constraint, so it is checked at the end)
524 else if (aFeatureKind == SketchPlugin_Point::ID()) {
525 anAttribute = aData->attribute(SketchPlugin_Point::COORD_ID());
526 if (!isInitialized(anAttribute)) return SLVS_E_UNKNOWN;
527 // Both the sketch point and its attribute (coordinates) link to the same SolveSpace point identifier
528 aResult = changeEntity(anAttribute, anAttrType);
529 aCurrentEntity.type = SLVS_E_POINT_IN_3D;
532 if (aResult != SLVS_E_UNKNOWN) {
533 myFeatureMap[theEntity] = aResult;
534 theType = aCurrentEntity.type;
539 std::list<ConstraintPtr> SketchSolver_Constraint::constraints() const
541 std::list<ConstraintPtr> aConstraints;
542 aConstraints.push_back(myBaseConstraint);
546 void SketchSolver_Constraint::refresh()
549 std::map<AttributePtr, Slvs_hEntity>::iterator anAttrIter = myAttributeMap.begin();
550 for (; anAttrIter != myAttributeMap.end(); anAttrIter++) {
551 std::shared_ptr<GeomDataAPI_Point> aPoint =
552 std::dynamic_pointer_cast<GeomDataAPI_Point>(anAttrIter->first);
554 Slvs_Entity anEntity = myStorage->getEntity(anAttrIter->second);
556 for (int i = 0; i < 3; i++) {
557 Slvs_Param aPar = myStorage->getParameter(anEntity.param[i]);
560 if (fabs(aPoint->x() - aXYZ[0]) > tolerance ||
561 fabs(aPoint->y() - aXYZ[1]) > tolerance ||
562 fabs(aPoint->z() - aXYZ[2]) > tolerance)
563 aPoint->setValue(aXYZ[0], aXYZ[1], aXYZ[2]);
566 std::shared_ptr<GeomDataAPI_Point2D> aPoint2D =
567 std::dynamic_pointer_cast<GeomDataAPI_Point2D>(anAttrIter->first);
569 Slvs_Entity anEntity = myStorage->getEntity(anAttrIter->second);
571 for (int i = 0; i < 2; i++) {
572 Slvs_Param aPar = myStorage->getParameter(anEntity.param[i]);
575 if (fabs(aPoint2D->x() - aXY[0]) > tolerance ||
576 fabs(aPoint2D->y() - aXY[1]) > tolerance)
577 aPoint2D->setValue(aXY[0], aXY[1]);
579 // Scalar value (used for the distance entities)
580 AttributeDoublePtr aScalar =
581 std::dynamic_pointer_cast<ModelAPI_AttributeDouble>(anAttrIter->first);
583 Slvs_Entity anEntity = myStorage->getEntity(anAttrIter->second);
584 Slvs_Param aPar = myStorage->getParameter(anEntity.param[0]);
585 if (fabs(aScalar->value() - aPar.val) > tolerance)
586 aScalar->setValue(aPar.val);
592 std::map<AttributePtr, Slvs_hParam>::iterator aValIter = myValueMap.begin();
593 for (; aValIter != myValueMap.end(); aValIter++) {
594 AttributeDoublePtr aScalar =
595 std::dynamic_pointer_cast<ModelAPI_AttributeDouble>(anAttrIter->first);
597 Slvs_Param aPar = myStorage->getParameter(anAttrIter->second);
598 aScalar->setValue(aPar.val);
603 Slvs_hEntity SketchSolver_Constraint::getId(FeaturePtr theFeature) const
605 std::map<FeaturePtr, Slvs_hEntity>::const_iterator aFIter = myFeatureMap.find(theFeature);
606 if (aFIter == myFeatureMap.end())
607 return SLVS_E_UNKNOWN;
608 // check the Feature is really in the storage
609 Slvs_Entity anEntity = myStorage->getEntity(aFIter->second);
610 if (anEntity.h == SLVS_E_UNKNOWN) {
613 anEntity.h = const_cast<SketchSolver_Constraint*>(this)->changeEntity(aFIter->first, aType);
614 const_cast<SketchSolver_Constraint*>(this)->myFeatureMap[theFeature] = anEntity.h;
619 Slvs_hEntity SketchSolver_Constraint::getId(AttributePtr theAttribute) const
621 std::map<AttributePtr, Slvs_hEntity>::const_iterator anAttrIter = myAttributeMap.find(theAttribute);
622 if (anAttrIter == myAttributeMap.end())
623 return SLVS_E_UNKNOWN;
624 return anAttrIter->second;
627 bool SketchSolver_Constraint::isInitialized(AttributePtr theAttribute)
629 if (theAttribute->isInitialized())
631 myErrorMsg = SketchSolver_Error::NOT_INITIALIZED();
636 void SketchSolver_Constraint::calculateMiddlePoint(
637 const Slvs_Entity& theEntity, double theCoeff, double& theX, double& theY) const
639 if (theEntity.type == SLVS_E_LINE_SEGMENT) {
640 double aStartEndXY[2][2];
642 for (int i = 0; i < 2; i++) {
643 aPoint = myStorage->getEntity(theEntity.point[i]);
644 for (int j = 0; j < 2; j++)
645 aStartEndXY[i][j] = myStorage->getParameter(aPoint.param[j]).val;
647 theX = (1.0 - theCoeff) * aStartEndXY[0][0] + theCoeff * aStartEndXY[1][0];
648 theY = (1.0 - theCoeff) * aStartEndXY[0][1] + theCoeff * aStartEndXY[1][1];
649 } else if (theEntity.type == SLVS_E_ARC_OF_CIRCLE) {
650 double anArcPoint[3][2];
652 for (int i = 0; i < 3; i++) {
653 aPoint = myStorage->getEntity(theEntity.point[i]);
654 for (int j = 0; j < 2; j++)
655 anArcPoint[i][j] = myStorage->getParameter(aPoint.param[j]).val;
657 // project last point of arc on the arc
658 double x = anArcPoint[1][0] - anArcPoint[0][0];
659 double y = anArcPoint[1][1] - anArcPoint[0][1];
660 double aRad = sqrt(x*x + y*y);
661 x = anArcPoint[2][0] - anArcPoint[0][0];
662 y = anArcPoint[2][1] - anArcPoint[0][1];
663 double aNorm = sqrt(x*x + y*y);
664 if (aNorm >= tolerance) {
665 anArcPoint[2][0] = x * aRad / aNorm;
666 anArcPoint[2][1] = y * aRad / aNorm;
668 anArcPoint[1][0] -= anArcPoint[0][0];
669 anArcPoint[1][1] -= anArcPoint[0][1];
670 if (theCoeff < tolerance) {
671 theX = anArcPoint[0][0] + anArcPoint[1][0];
672 theY = anArcPoint[0][1] + anArcPoint[1][1];
674 } else if (1 - theCoeff < tolerance) {
675 theX = anArcPoint[0][0] + anArcPoint[2][0];
676 theY = anArcPoint[0][1] + anArcPoint[2][1];
680 double xStart = anArcPoint[1][0] / aRad, xEnd = anArcPoint[2][0] / aRad;
681 double yStart = anArcPoint[1][1] / aRad, yEnd = anArcPoint[2][1] / aRad;
682 double aTanStart = abs(xStart) < tolerance ? yStart : yStart / xStart;
683 double aTanEnd = abs(xEnd) < tolerance ? yEnd : yEnd / xEnd;
684 double aCotStart = abs(yStart) < tolerance ? xStart : xStart / yStart;
685 double aCotEnd = abs(yEnd) < tolerance ? xEnd : xEnd / yEnd;
686 if (anArcPoint[1][0] * anArcPoint[2][0] < 0.0) {
687 if (anArcPoint[1][0] > 0.0)
690 yStart = -2.0 - yStart;
692 if (aTanStart > aTanEnd) {
694 yStart = 2.0 - yStart;
697 yStart = -2.0 - yStart;
702 if (anArcPoint[1][1] * anArcPoint[2][1] < 0.0) {
703 if (anArcPoint[1][1] > 0.0)
706 xStart = -2.0 - xStart;
708 if (aCotStart < aCotEnd) {
710 xStart = 2.0 - xStart;
713 xStart = -2.0 - xStart;
718 x = (1.0 - theCoeff) * xStart + theCoeff * xEnd;
719 y = (1.0 - theCoeff) * yStart + theCoeff * yEnd;
720 if (x > 1.0) x = 2.0 - x;
721 if (x < -1.0) x = -2.0 - x;
722 if (y > 1.0) y = 2.0 - y;
723 if (y < -1.0) y = -2.0 - y;
725 aNorm = sqrt(x*x + y*y);
726 if (aNorm >= tolerance) {
730 x = -0.5 * (anArcPoint[2][1] + anArcPoint[1][1]);
731 y = -0.5 * (anArcPoint[2][0] + anArcPoint[1][0]);
733 theX = anArcPoint[0][0] + x;
734 theY = anArcPoint[0][1] + y;
738 void SketchSolver_Constraint::makeTemporary() const
740 std::vector<Slvs_hConstraint>::const_iterator anIt = mySlvsConstraints.begin();
741 for (; anIt != mySlvsConstraints.end(); anIt++)
742 myStorage->addTemporaryConstraint(*anIt);