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 <GeomAPI_Dir2d.h>
11 #include <GeomDataAPI_Point.h>
12 #include <GeomDataAPI_Point2D.h>
13 #include <ModelAPI_AttributeDouble.h>
14 #include <ModelAPI_ResultConstruction.h>
18 SketchSolver_Constraint::SketchSolver_Constraint(
19 ConstraintPtr theConstraint)
20 : myBaseConstraint(theConstraint),
25 SketchSolver_Constraint::~SketchSolver_Constraint()
27 std::map<AttributePtr, Slvs_hParam>::const_iterator anIt1 = myValueMap.begin();
28 for (; anIt1 != myValueMap.end(); anIt1++)
29 myStorage->removeParameter(anIt1->second);
32 std::map<AttributePtr, Slvs_hEntity>::const_iterator anIt2 = myAttributeMap.begin();
33 for (; anIt2 != myAttributeMap.end(); anIt2++)
34 myStorage->removeEntity(anIt2->second);
35 myAttributeMap.clear();
37 std::map<FeaturePtr, Slvs_hEntity>::iterator anIt3 = myFeatureMap.begin();
38 while (!myFeatureMap.empty()) {
39 std::shared_ptr<SketchPlugin_Feature> aFeature =
40 std::dynamic_pointer_cast<SketchPlugin_Feature>(anIt3->first);
41 Slvs_hEntity anEnt = anIt3->second;
42 std::map<FeaturePtr, Slvs_hEntity>::iterator aRemIt = anIt3++;
43 myFeatureMap.erase(aRemIt);
44 if (!myGroup->isInteract(aFeature))
45 myStorage->removeEntity(anEnt);
48 std::vector<Slvs_hConstraint>::const_iterator anIt4 = mySlvsConstraints.begin();
49 for (; anIt4 != mySlvsConstraints.end(); anIt4++)
50 myStorage->removeConstraint(*anIt4);
51 mySlvsConstraints.clear();
54 void SketchSolver_Constraint::setStorage(StoragePtr theStorage)
56 myStorage = theStorage;
60 void SketchSolver_Constraint::setGroup(SketchSolver_Group* theGroup)
66 void SketchSolver_Constraint::addFeature(FeaturePtr theFeature)
69 changeEntity(theFeature, aType);
73 void SketchSolver_Constraint::process()
76 if (!myBaseConstraint || !myStorage || myGroup == 0) {
77 /// TODO: Put error message here
80 if (!mySlvsConstraints.empty()) // some data is changed, update constraint
81 update(myBaseConstraint);
83 int aConstrType = getType();
85 std::vector<Slvs_hEntity> anAttributes;
86 getAttributes(aValue, anAttributes);
87 if (!myErrorMsg.empty())
89 if (aConstrType == SLVS_C_UNKNOWN)
90 aConstrType = getType();
92 Slvs_hGroup aGroupID = myGroup->getId();
93 Slvs_hEntity aWorkplaneID = myGroup->getWorkplaneId();
94 Slvs_Constraint aConstraint;
95 if (mySlvsConstraints.empty())
96 aConstraint = Slvs_MakeConstraint(SLVS_C_UNKNOWN, aGroupID, aConstrType, aWorkplaneID,
97 aValue, anAttributes[0], anAttributes[1], anAttributes[2], anAttributes[3]);
99 aConstraint = myStorage->getConstraint(mySlvsConstraints[0]);
100 aConstraint.valA = aValue;
101 static const int aNbAttrs = 6;
102 Slvs_hEntity* aConstrAttrs[aNbAttrs] = {
103 &aConstraint.ptA, &aConstraint.ptB,
104 &aConstraint.entityA, &aConstraint.entityB,
105 &aConstraint.entityC, &aConstraint.entityD};
106 std::vector<Slvs_hEntity>::const_iterator anIter = anAttributes.begin();
107 for (int i = 0; i < aNbAttrs && anIter != anAttributes.end(); i++, anIter++)
108 *(aConstrAttrs[i]) = *anIter;
111 Slvs_hConstraint anID = myStorage->addConstraint(aConstraint);
112 if (mySlvsConstraints.empty())
113 mySlvsConstraints.push_back(anID);
115 mySlvsConstraints[0] = anID;
119 bool SketchSolver_Constraint::checkAttributesChanged(ConstraintPtr theConstraint)
121 std::set<Slvs_hEntity> aCurAttrs; // list of currently used attributes
122 std::vector<Slvs_hConstraint>::const_iterator aConstrIter = mySlvsConstraints.begin();
123 for (; aConstrIter != mySlvsConstraints.end(); aConstrIter++) {
124 Slvs_Constraint aConstr = myStorage->getConstraint(*aConstrIter);
125 if (aConstr.ptA != SLVS_E_UNKNOWN) aCurAttrs.insert(aConstr.ptA);
126 if (aConstr.ptB != SLVS_E_UNKNOWN) aCurAttrs.insert(aConstr.ptB);
127 if (aConstr.entityA != SLVS_E_UNKNOWN) aCurAttrs.insert(aConstr.entityA);
128 if (aConstr.entityB != SLVS_E_UNKNOWN) aCurAttrs.insert(aConstr.entityB);
129 if (aConstr.entityC != SLVS_E_UNKNOWN) aCurAttrs.insert(aConstr.entityC);
130 if (aConstr.entityD != SLVS_E_UNKNOWN) aCurAttrs.insert(aConstr.entityD);
132 // Check the attrbutes of constraint are changed
133 ConstraintPtr aConstraint = theConstraint ? theConstraint : myBaseConstraint;
134 std::list<AttributePtr> anAttrList = aConstraint->data()->attributes(std::string());
135 std::list<AttributePtr>::iterator anAttrIter = anAttrList.begin();
136 for (; anAttrIter != anAttrList.end(); anAttrIter++) {
137 AttributeRefAttrPtr aRefAttr =
138 std::dynamic_pointer_cast<ModelAPI_AttributeRefAttr>(*anAttrIter);
140 if (aRefAttr->isObject()) {
141 FeaturePtr aFeature = ModelAPI_Feature::feature(aRefAttr->object());
142 std::map<FeaturePtr, Slvs_hEntity>::iterator aFIt = myFeatureMap.find(aFeature);
144 if (aFIt == myFeatureMap.end())
146 // Additional check the points of entity
147 if (aCurAttrs.find(aFIt->second) == aCurAttrs.end()) {
148 Slvs_Entity anEntity = myStorage->getEntity(aFIt->second);
149 bool isFound = false;
150 for (int i = 0; i < 4 && !isFound; i++)
151 if (anEntity.point[i] != SLVS_E_UNKNOWN &&
152 aCurAttrs.find(anEntity.point[i]) != aCurAttrs.end())
158 } else if (aRefAttr->attr()) {
159 std::map<AttributePtr, Slvs_hEntity>::iterator anAIt = myAttributeMap.find(aRefAttr->attr());
160 if (anAIt == myAttributeMap.end() || aCurAttrs.find(anAIt->second) == aCurAttrs.end())
164 AttributeRefListPtr aRefList =
165 std::dynamic_pointer_cast<ModelAPI_AttributeRefList>(*anAttrIter);
167 std::list<ObjectPtr> anItems = aRefList->list();
168 std::list<ObjectPtr>::iterator anIt = anItems.begin();
169 for (; anIt != anItems.end(); anIt++) {
170 FeaturePtr aFeature = ModelAPI_Feature::feature(*anIt);
171 if (aFeature && myFeatureMap.find(aFeature) == myFeatureMap.end())
179 void SketchSolver_Constraint::update(ConstraintPtr theConstraint)
182 bool needToRebuild = (theConstraint && theConstraint != myBaseConstraint);
184 needToRebuild = checkAttributesChanged(theConstraint);
186 if (theConstraint && theConstraint->getKind() != myBaseConstraint->getKind())
188 remove(myBaseConstraint);
190 myBaseConstraint = theConstraint;
195 // Update all attributes
197 std::map<Slvs_hEntity, Slvs_hEntity> aRelocationMap;
198 std::map<FeaturePtr, Slvs_hEntity>::iterator aFeatIter = myFeatureMap.begin();
199 for (; aFeatIter != myFeatureMap.end(); aFeatIter++) {
200 Slvs_hEntity aPrevID = aFeatIter->second;
201 aFeatIter->second = changeEntity(aFeatIter->first, aType);
202 if (aFeatIter->second != aPrevID)
203 aRelocationMap[aPrevID] = aFeatIter->second;
205 std::map<AttributePtr, Slvs_hEntity>::iterator anAttrIter = myAttributeMap.begin();
206 for (; anAttrIter != myAttributeMap.end(); anAttrIter++) {
207 Slvs_hEntity aPrevID = anAttrIter->second;
208 anAttrIter->second = changeEntity(anAttrIter->first, aType);
209 if (anAttrIter->second != aPrevID)
210 aRelocationMap[aPrevID] = anAttrIter->second;
214 DataPtr aData = myBaseConstraint->data();
216 AttributeDoublePtr aValueAttr = std::dynamic_pointer_cast<ModelAPI_AttributeDouble>(
217 myBaseConstraint->attribute(SketchPlugin_Constraint::VALUE()));
218 double aValue = aValueAttr ? aValueAttr->value() : 0.0;
221 std::vector<Slvs_hConstraint>::iterator aCIter = mySlvsConstraints.begin();
222 for (; aCIter != mySlvsConstraints.end(); aCIter++) {
223 Slvs_Constraint aConstraint = myStorage->getConstraint(*aCIter);
225 aConstraint.valA = aValue;
226 if (aConstraint.type == SLVS_C_DIAMETER)
227 aConstraint.valA *= 2.0;
229 Slvs_hEntity* aCoeffs[6] = {
230 &aConstraint.ptA, &aConstraint.ptB,
231 &aConstraint.entityA, &aConstraint.entityB,
232 &aConstraint.entityC, &aConstraint.entityD};
233 for (int i = 0; i < 6; i++) {
234 if (*(aCoeffs[i]) == SLVS_E_UNKNOWN)
236 std::map<Slvs_hEntity, Slvs_hEntity>::iterator aFound = aRelocationMap.find(*(aCoeffs[i]));
237 if (aFound != aRelocationMap.end())
238 *(aCoeffs[i]) = aFound->second;
240 *aCIter = myStorage->addConstraint(aConstraint);
245 bool SketchSolver_Constraint::remove(ConstraintPtr theConstraint)
248 if (theConstraint && theConstraint != myBaseConstraint)
250 if (mySlvsConstraints.empty())
252 bool isFullyRemoved = myStorage->removeConstraint(mySlvsConstraints.front());
253 if (isFullyRemoved) {
254 myFeatureMap.clear();
255 myAttributeMap.clear();
258 cleanRemovedEntities();
259 mySlvsConstraints.clear();
263 void SketchSolver_Constraint::cleanRemovedEntities()
265 std::set<Slvs_hParam> aRemovedParams;
266 std::set<Slvs_hEntity> aRemovedEntities;
267 std::set<Slvs_hConstraint> aRemovedConstraints;
268 myStorage->getRemoved(aRemovedParams, aRemovedEntities, aRemovedConstraints);
269 std::map<FeaturePtr, Slvs_hEntity>::iterator aFeatIt = myFeatureMap.begin();
270 while (aFeatIt != myFeatureMap.end()) {
271 if (aRemovedEntities.find(aFeatIt->second) == aRemovedEntities.end()) {
275 std::map<FeaturePtr, Slvs_hEntity>::iterator aTmpIter = aFeatIt++;
276 myFeatureMap.erase(aTmpIter);
278 std::map<AttributePtr, Slvs_hEntity>::iterator anAttrIt = myAttributeMap.begin();
279 while (anAttrIt != myAttributeMap.end()) {
280 if (aRemovedEntities.find(anAttrIt->second) == aRemovedEntities.end()) {
284 std::map<AttributePtr, Slvs_hEntity>::iterator aTmpIter = anAttrIt++;
285 myAttributeMap.erase(aTmpIter);
287 std::map<AttributePtr, Slvs_hParam>::iterator aValIt = myValueMap.begin();
288 while (aValIt != myValueMap.end()) {
289 if (aRemovedParams.find(aValIt->second) == aRemovedParams.end()) {
293 std::map<AttributePtr, Slvs_hParam>::iterator aTmpIter = aValIt++;
294 myValueMap.erase(aTmpIter);
296 for (size_t i = 0; i < mySlvsConstraints.size(); i++)
297 if (aRemovedConstraints.find(mySlvsConstraints[i]) != aRemovedConstraints.end()) {
298 mySlvsConstraints.erase(mySlvsConstraints.begin() + i);
303 void SketchSolver_Constraint::getAttributes(
305 std::vector<Slvs_hEntity>& theAttributes)
307 static const int anInitNbOfAttr = 4;
308 theAttributes.assign(anInitNbOfAttr, SLVS_E_UNKNOWN);
310 DataPtr aData = myBaseConstraint->data();
312 AttributeDoublePtr aValueAttr = std::dynamic_pointer_cast<ModelAPI_AttributeDouble>(
313 aData->attribute(SketchPlugin_Constraint::VALUE()));
314 theValue = aValueAttr ? aValueAttr->value() : 0.0;
316 int aPtInd = 0; // index of first point in the list of attributes
317 int aEntInd = 2; // index of first antity in the list of attributes
318 std::list<AttributePtr> aConstrAttrs = aData->attributes(ModelAPI_AttributeRefAttr::typeId());
319 std::list<AttributePtr>::iterator anIter = aConstrAttrs.begin();
320 for (; anIter != aConstrAttrs.end(); anIter++) {
321 AttributeRefAttrPtr aRefAttr =
322 std::dynamic_pointer_cast<ModelAPI_AttributeRefAttr>(*anIter);
323 if (!aRefAttr || !aRefAttr->isInitialized()) {
324 myErrorMsg = SketchSolver_Error::NOT_INITIALIZED();
328 int aType = SLVS_E_UNKNOWN; // type of created entity
329 Slvs_hEntity anEntity = myGroup->getAttributeId(aRefAttr);
330 if (anEntity == SLVS_E_UNKNOWN)
331 anEntity = changeEntity(aRefAttr, aType);
333 Slvs_Entity anEnt = myStorage->getEntity(anEntity);
337 if (aType == SLVS_E_UNKNOWN)
339 else if (aType == SLVS_E_POINT_IN_2D || aType == SLVS_E_POINT_IN_3D)
340 theAttributes[aPtInd++] = anEntity; // the point is created
341 else { // another entity (not a point) is created
342 if (aEntInd < anInitNbOfAttr)
343 theAttributes[aEntInd] = anEntity;
345 theAttributes.push_back(anEntity);
351 Slvs_hEntity SketchSolver_Constraint::changeEntity(AttributeRefAttrPtr theAttribute, int& theType)
353 // Convert the object of the attribute to the feature
355 if (theAttribute->isObject() && theAttribute->object()) {
356 ResultConstructionPtr aRC = std::dynamic_pointer_cast<ModelAPI_ResultConstruction>(
357 theAttribute->object());
359 myErrorMsg = SketchSolver_Error::NOT_INITIALIZED();
360 return SLVS_E_UNKNOWN;
362 std::shared_ptr<ModelAPI_Document> aDoc = aRC->document();
363 aFeature = aDoc->feature(aRC);
365 return changeEntity(aFeature, theType);
368 return changeEntity(theAttribute->attr(), theType);
371 Slvs_hEntity SketchSolver_Constraint::changeEntity(AttributePtr theEntity, int& theType)
373 Slvs_hEntity aResult = SLVS_E_UNKNOWN;
374 if (!theEntity || !isInitialized(theEntity)) {
375 myErrorMsg = SketchSolver_Error::NOT_INITIALIZED();
376 return SLVS_E_UNKNOWN;
379 // If the entity is already in the group, try to find it
380 std::map<std::shared_ptr<ModelAPI_Attribute>, Slvs_hEntity>::const_iterator anEntIter =
381 myAttributeMap.find(theEntity);
382 Slvs_Entity aCurrentEntity;
383 aCurrentEntity.h = SLVS_E_UNKNOWN;
384 if (anEntIter != myAttributeMap.end())
385 aCurrentEntity = myStorage->getEntity(anEntIter->second);
387 aResult = myGroup->getAttributeId(theEntity);
388 if (aResult != SLVS_E_UNKNOWN) {
389 Slvs_Entity anEnt = myStorage->getEntity(aResult);
390 theType = anEnt.type;
391 myAttributeMap[theEntity] = aResult;
396 Slvs_hGroup aGroupID = myGroup->getId();
397 // do not update entity from another group
398 if (aCurrentEntity.h != SLVS_E_UNKNOWN && aGroupID != aCurrentEntity.group)
399 return aCurrentEntity.h;
402 std::shared_ptr<GeomDataAPI_Point> aPoint =
403 std::dynamic_pointer_cast<GeomDataAPI_Point>(theEntity);
405 double aXYZ[3] = {aPoint->x(), aPoint->y(), aPoint->z()};
406 Slvs_hParam aParams[3];
407 for (int i = 0; i < 3; i++) {
408 Slvs_Param aPar = aCurrentEntity.h != SLVS_E_UNKNOWN ?
409 myStorage->getParameter(aCurrentEntity.param[i]) :
410 Slvs_MakeParam(SLVS_E_UNKNOWN, aGroupID, 0.0);
412 aParams[i] = myStorage->addParameter(aPar);
415 if (aCurrentEntity.h == SLVS_E_UNKNOWN) // New entity
416 aCurrentEntity = Slvs_MakePoint3d(SLVS_E_UNKNOWN, aGroupID, aParams[0], aParams[1], aParams[2]);
417 else { // update entity data
418 for (int i = 0; i < 3; i++)
419 aCurrentEntity.param[i] = aParams[i];
421 aResult = myStorage->addEntity(aCurrentEntity);
423 // All entities except 3D points are created on workplane. So, if there is no workplane yet, then error
424 Slvs_hEntity aWorkplaneID = myGroup->getWorkplaneId();
425 if (aWorkplaneID == SLVS_E_UNKNOWN)
426 return SLVS_E_UNKNOWN;
429 std::shared_ptr<GeomDataAPI_Point2D> aPoint2D =
430 std::dynamic_pointer_cast<GeomDataAPI_Point2D>(theEntity);
432 double aXY[2] = {aPoint2D->x(), aPoint2D->y()};
433 Slvs_hParam aParams[2];
434 for (int i = 0; i < 2; i++) {
435 Slvs_Param aPar = aCurrentEntity.h != SLVS_E_UNKNOWN ?
436 myStorage->getParameter(aCurrentEntity.param[i]) :
437 Slvs_MakeParam(SLVS_E_UNKNOWN, aGroupID, 0.0);
439 aParams[i] = myStorage->addParameter(aPar);
442 if (aCurrentEntity.h == SLVS_E_UNKNOWN) // New entity
443 aCurrentEntity = Slvs_MakePoint2d(SLVS_E_UNKNOWN, aGroupID, aWorkplaneID, aParams[0], aParams[1]);
444 else { // update entity data
445 for (int i = 0; i < 2; i++)
446 aCurrentEntity.param[i] = aParams[i];
448 aResult = myStorage->addEntity(aCurrentEntity);
450 // Scalar value (used for the distance entities)
451 AttributeDoublePtr aScalar = std::dynamic_pointer_cast<ModelAPI_AttributeDouble>(theEntity);
453 Slvs_Param aParam = aCurrentEntity.h != SLVS_E_UNKNOWN ?
454 myStorage->getParameter(aCurrentEntity.param[0]) :
455 Slvs_MakeParam(SLVS_E_UNKNOWN, aGroupID, 0.0);
456 aParam.val = aScalar->value();
457 Slvs_hParam aValue = myStorage->addParameter(aParam);
459 if (aCurrentEntity.h == SLVS_E_UNKNOWN) // New entity
460 aCurrentEntity = Slvs_MakeDistance(SLVS_E_UNKNOWN, aGroupID, aWorkplaneID, aValue);
462 aCurrentEntity.param[0] = aValue;
463 aResult = myStorage->addEntity(aCurrentEntity);
468 myAttributeMap[theEntity] = aResult;
469 theType = aCurrentEntity.type;
473 Slvs_hEntity SketchSolver_Constraint::changeEntity(FeaturePtr theEntity, int& theType)
475 Slvs_hEntity aResult = SLVS_E_UNKNOWN;
476 if (!theEntity || !theEntity->data() || !theEntity->data()->isValid())
477 return SLVS_E_UNKNOWN;
478 // If the entity is already in the group, try to find it
479 std::map<FeaturePtr, Slvs_hEntity>::const_iterator anEntIter = myFeatureMap.find(theEntity);
480 Slvs_Entity aCurrentEntity;
481 aCurrentEntity.h = SLVS_E_UNKNOWN;
482 if (anEntIter != myFeatureMap.end())
483 aCurrentEntity = myStorage->getEntity(anEntIter->second);
485 aResult = myGroup->getFeatureId(theEntity);
486 if (aResult != SLVS_E_UNKNOWN) {
487 Slvs_Entity anEnt = myStorage->getEntity(aResult);
488 theType = anEnt.type;
489 myFeatureMap[theEntity] = aResult;
494 Slvs_hGroup aGroupID = myGroup->getId();
495 // do not update entity from another group
496 if (aCurrentEntity.h != SLVS_E_UNKNOWN && aGroupID != aCurrentEntity.group)
497 return aCurrentEntity.h;
499 Slvs_hEntity aWorkplaneID = myGroup->getWorkplaneId();
500 DataPtr aData = theEntity->data();
502 // SketchPlugin features
503 const std::string& aFeatureKind = theEntity->getKind();
504 AttributePtr anAttribute;
507 if (aFeatureKind == SketchPlugin_Line::ID()) {
508 anAttribute = aData->attribute(SketchPlugin_Line::START_ID());
509 if (!isInitialized(anAttribute)) return SLVS_E_UNKNOWN;
510 Slvs_hEntity aStart = changeEntity(anAttribute, anAttrType);
512 anAttribute = aData->attribute(SketchPlugin_Line::END_ID());
513 if (!isInitialized(anAttribute)) return SLVS_E_UNKNOWN;
514 Slvs_hEntity aEnd = changeEntity(anAttribute, anAttrType);
516 if (aCurrentEntity.h == SLVS_E_UNKNOWN) // New entity
517 aCurrentEntity = Slvs_MakeLineSegment(SLVS_E_UNKNOWN, aGroupID, aWorkplaneID, aStart, aEnd);
519 aCurrentEntity.point[0] = aStart;
520 aCurrentEntity.point[1] = aEnd;
522 aResult = myStorage->addEntity(aCurrentEntity);
525 else if (aFeatureKind == SketchPlugin_Circle::ID()) {
526 anAttribute = aData->attribute(SketchPlugin_Circle::CENTER_ID());
527 if (!isInitialized(anAttribute)) return SLVS_E_UNKNOWN;
528 Slvs_hEntity aCenter = changeEntity(anAttribute, anAttrType);
530 anAttribute = aData->attribute(SketchPlugin_Circle::RADIUS_ID());
531 if (!isInitialized(anAttribute)) return SLVS_E_UNKNOWN;
532 Slvs_hEntity aRadius = changeEntity(anAttribute, anAttrType);
534 if (aCurrentEntity.h == SLVS_E_UNKNOWN) { // New entity
535 Slvs_Entity aWorkplane = myStorage->getEntity(aWorkplaneID);
536 aCurrentEntity = Slvs_MakeCircle(SLVS_E_UNKNOWN, aGroupID, aWorkplaneID,
537 aCenter, aWorkplane.normal, aRadius);
539 aCurrentEntity.point[0] = aCenter;
540 aCurrentEntity.distance = aRadius;
542 aResult = myStorage->addEntity(aCurrentEntity);
545 else if (aFeatureKind == SketchPlugin_Arc::ID()) {
546 anAttribute = aData->attribute(SketchPlugin_Arc::CENTER_ID());
547 if (!isInitialized(anAttribute)) return SLVS_E_UNKNOWN;
548 Slvs_hEntity aCenter = changeEntity(anAttribute, anAttrType);
550 anAttribute = aData->attribute(SketchPlugin_Arc::START_ID());
551 if (!isInitialized(anAttribute)) return SLVS_E_UNKNOWN;
552 Slvs_hEntity aStart = changeEntity(anAttribute, anAttrType);
554 anAttribute = aData->attribute(SketchPlugin_Arc::END_ID());
555 if (!isInitialized(anAttribute)) return SLVS_E_UNKNOWN;
556 Slvs_hEntity aEnd = changeEntity(anAttribute, anAttrType);
558 if (aCurrentEntity.h == SLVS_E_UNKNOWN) { // New entity
559 Slvs_Entity aWorkplane = myStorage->getEntity(aWorkplaneID);
560 aCurrentEntity = Slvs_MakeArcOfCircle(SLVS_E_UNKNOWN, aGroupID, aWorkplaneID,
561 aWorkplane.normal, aCenter, aStart, aEnd);
563 aCurrentEntity.point[0] = aCenter;
564 aCurrentEntity.point[1] = aStart;
565 aCurrentEntity.point[2] = aEnd;
567 aResult = myStorage->addEntity(aCurrentEntity);
569 // Point (it has low probability to be an attribute of constraint, so it is checked at the end)
570 else if (aFeatureKind == SketchPlugin_Point::ID()) {
571 anAttribute = aData->attribute(SketchPlugin_Point::COORD_ID());
572 if (!isInitialized(anAttribute)) return SLVS_E_UNKNOWN;
573 // Both the sketch point and its attribute (coordinates) link to the same SolveSpace point identifier
574 aResult = changeEntity(anAttribute, anAttrType);
575 aCurrentEntity.type = SLVS_E_POINT_IN_3D;
578 if (aResult != SLVS_E_UNKNOWN) {
579 myFeatureMap[theEntity] = aResult;
580 theType = aCurrentEntity.type;
585 std::list<ConstraintPtr> SketchSolver_Constraint::constraints() const
587 std::list<ConstraintPtr> aConstraints;
588 aConstraints.push_back(myBaseConstraint);
592 void SketchSolver_Constraint::refresh()
595 std::map<AttributePtr, Slvs_hEntity>::iterator anAttrIter = myAttributeMap.begin();
596 while (anAttrIter != myAttributeMap.end()) {
597 std::shared_ptr<GeomDataAPI_Point> aPoint =
598 std::dynamic_pointer_cast<GeomDataAPI_Point>(anAttrIter->first);
599 Slvs_Entity anEntity = myStorage->getEntity(anAttrIter->second);
600 if (anEntity.h == SLVS_E_UNKNOWN) {
601 std::map<AttributePtr, Slvs_hEntity>::iterator aTmpIter = anAttrIter++;
602 myAttributeMap.erase(aTmpIter);
607 for (int i = 0; i < 3; i++) {
608 Slvs_Param aPar = myStorage->getParameter(anEntity.param[i]);
611 if (fabs(aPoint->x() - aXYZ[0]) > tolerance ||
612 fabs(aPoint->y() - aXYZ[1]) > tolerance ||
613 fabs(aPoint->z() - aXYZ[2]) > tolerance)
614 aPoint->setValue(aXYZ[0], aXYZ[1], aXYZ[2]);
617 std::shared_ptr<GeomDataAPI_Point2D> aPoint2D =
618 std::dynamic_pointer_cast<GeomDataAPI_Point2D>(anAttrIter->first);
621 for (int i = 0; i < 2; i++) {
622 Slvs_Param aPar = myStorage->getParameter(anEntity.param[i]);
625 if (fabs(aPoint2D->x() - aXY[0]) > tolerance ||
626 fabs(aPoint2D->y() - aXY[1]) > tolerance)
627 aPoint2D->setValue(aXY[0], aXY[1]);
629 // Scalar value (used for the distance entities)
630 AttributeDoublePtr aScalar =
631 std::dynamic_pointer_cast<ModelAPI_AttributeDouble>(anAttrIter->first);
633 Slvs_Param aPar = myStorage->getParameter(anEntity.param[0]);
634 if (fabs(aScalar->value() - aPar.val) > tolerance)
635 aScalar->setValue(aPar.val);
642 std::map<AttributePtr, Slvs_hParam>::iterator aValIter = myValueMap.begin();
643 for (; aValIter != myValueMap.end(); aValIter++) {
644 AttributeDoublePtr aScalar =
645 std::dynamic_pointer_cast<ModelAPI_AttributeDouble>(anAttrIter->first);
647 Slvs_Param aPar = myStorage->getParameter(anAttrIter->second);
648 aScalar->setValue(aPar.val);
653 Slvs_hEntity SketchSolver_Constraint::getId(FeaturePtr theFeature) const
655 std::map<FeaturePtr, Slvs_hEntity>::const_iterator aFIter = myFeatureMap.find(theFeature);
656 if (aFIter == myFeatureMap.end())
657 return SLVS_E_UNKNOWN;
658 //// check the Feature is really in the storage
659 //Slvs_Entity anEntity = myStorage->getEntity(aFIter->second);
660 //if (anEntity.h == SLVS_E_UNKNOWN) {
661 // // rebuild feature
663 // anEntity.h = const_cast<SketchSolver_Constraint*>(this)->changeEntity(aFIter->first, aType);
664 // const_cast<SketchSolver_Constraint*>(this)->myFeatureMap[theFeature] = anEntity.h;
667 return aFIter->second;
670 Slvs_hEntity SketchSolver_Constraint::getId(AttributePtr theAttribute) const
672 std::map<AttributePtr, Slvs_hEntity>::const_iterator anAttrIter = myAttributeMap.find(theAttribute);
673 if (anAttrIter == myAttributeMap.end())
674 return SLVS_E_UNKNOWN;
675 return anAttrIter->second;
678 bool SketchSolver_Constraint::isInitialized(AttributePtr theAttribute)
680 if (theAttribute->isInitialized())
682 myErrorMsg = SketchSolver_Error::NOT_INITIALIZED();
687 void SketchSolver_Constraint::calculateMiddlePoint(
688 const Slvs_Entity& theEntity, double theCoeff, double& theX, double& theY) const
690 if (theEntity.type == SLVS_E_LINE_SEGMENT) {
691 double aStartEndXY[2][2];
693 for (int i = 0; i < 2; i++) {
694 aPoint = myStorage->getEntity(theEntity.point[i]);
695 for (int j = 0; j < 2; j++)
696 aStartEndXY[i][j] = myStorage->getParameter(aPoint.param[j]).val;
698 theX = (1.0 - theCoeff) * aStartEndXY[0][0] + theCoeff * aStartEndXY[1][0];
699 theY = (1.0 - theCoeff) * aStartEndXY[0][1] + theCoeff * aStartEndXY[1][1];
700 } else if (theEntity.type == SLVS_E_ARC_OF_CIRCLE) {
701 double anArcPoint[3][2];
703 for (int i = 0; i < 3; i++) {
704 aPoint = myStorage->getEntity(theEntity.point[i]);
705 for (int j = 0; j < 2; j++)
706 anArcPoint[i][j] = myStorage->getParameter(aPoint.param[j]).val;
708 // project last point of arc on the arc
709 double x = anArcPoint[1][0] - anArcPoint[0][0];
710 double y = anArcPoint[1][1] - anArcPoint[0][1];
711 double aRad = sqrt(x*x + y*y);
712 x = anArcPoint[2][0] - anArcPoint[0][0];
713 y = anArcPoint[2][1] - anArcPoint[0][1];
714 double aNorm = sqrt(x*x + y*y);
715 if (aNorm >= tolerance) {
716 anArcPoint[2][0] = x * aRad / aNorm;
717 anArcPoint[2][1] = y * aRad / aNorm;
719 anArcPoint[1][0] -= anArcPoint[0][0];
720 anArcPoint[1][1] -= anArcPoint[0][1];
721 if (theCoeff < tolerance) {
722 theX = anArcPoint[0][0] + anArcPoint[1][0];
723 theY = anArcPoint[0][1] + anArcPoint[1][1];
725 } else if (1 - theCoeff < tolerance) {
726 theX = anArcPoint[0][0] + anArcPoint[2][0];
727 theY = anArcPoint[0][1] + anArcPoint[2][1];
731 std::shared_ptr<GeomAPI_Dir2d> aStartDir(new GeomAPI_Dir2d(anArcPoint[1][0], anArcPoint[1][1]));
732 std::shared_ptr<GeomAPI_Dir2d> aEndDir(new GeomAPI_Dir2d(anArcPoint[2][0], anArcPoint[2][1]));
733 double anAngle = aStartDir->angle(aEndDir);
737 double aCos = cos(anAngle);
738 double aSin = sin(anAngle);
739 theX = anArcPoint[0][0] + anArcPoint[1][0] * aCos - anArcPoint[1][1] * aSin;
740 theY = anArcPoint[0][1] + anArcPoint[1][0] * aSin + anArcPoint[1][1] * aCos;
744 void SketchSolver_Constraint::makeTemporary() const
746 std::vector<Slvs_hConstraint>::const_iterator anIt = mySlvsConstraints.begin();
747 for (; anIt != mySlvsConstraints.end(); anIt++)
748 myStorage->addTemporaryConstraint(*anIt);