src/SketchSolver/SketchSolver_Constraint.cpp

   1 #include <SketchSolver_Constraint.h>
   2 #include <SketchSolver_Group.h>
   3 #include <SketchSolver_Error.h>
   4
   5 #include <SketchPlugin_Arc.h>
   6 #include <SketchPlugin_Circle.h>
   7 #include <SketchPlugin_Line.h>
   8 #include <SketchPlugin_Point.h>
   9
  10 #include <GeomDataAPI_Point.h>
  11 #include <GeomDataAPI_Point2D.h>
  12 #include <ModelAPI_AttributeDouble.h>
  13 #include <ModelAPI_ResultConstruction.h>
  14
  15
  16 SketchSolver_Constraint::SketchSolver_Constraint(
  17     ConstraintPtr  theConstraint)
  18   : myBaseConstraint(theConstraint),
  19     myGroup(0)
  20 {
  21 }
  22
  23 SketchSolver_Constraint::~SketchSolver_Constraint()
  24 {
  25   std::map<AttributePtr, Slvs_hParam>::const_iterator anIt1 = myValueMap.begin();
  26   for (; anIt1 != myValueMap.end(); anIt1++)
  27     myStorage->removeParameter(anIt1->second);
  28   myValueMap.clear();
  29
  30   std::map<AttributePtr, Slvs_hEntity>::const_iterator anIt2 = myAttributeMap.begin();
  31   for (; anIt2 != myAttributeMap.end(); anIt2++)
  32     myStorage->removeEntity(anIt2->second);
  33   myAttributeMap.clear();
  34
  35   std::map<FeaturePtr, Slvs_hEntity>::const_iterator anIt3 =  myFeatureMap.begin();
  36   for (; anIt3 != myFeatureMap.end(); anIt3++)
  37     myStorage->removeEntity(anIt3->second);
  38   myFeatureMap.clear();
  39
  40   std::vector<Slvs_hConstraint>::const_iterator anIt4 = mySlvsConstraints.begin();
  41   for (; anIt4 != mySlvsConstraints.end(); anIt4++)
  42     myStorage->removeConstraint(*anIt4);
  43   mySlvsConstraints.clear();
  44 }
  45
  46 void SketchSolver_Constraint::setStorage(StoragePtr theStorage)
  47 {
  48   myStorage = theStorage;
  49   process();
  50 }
  51
  52 void SketchSolver_Constraint::setGroup(SketchSolver_Group* theGroup)
  53 {
  54   myGroup = theGroup;
  55   process();
  56 }
  57
  58
  59 void SketchSolver_Constraint::process()
  60 {
  61   cleanErrorMsg();
  62   if (!myBaseConstraint || !myStorage || myGroup == 0) {
  63     /// TODO: Put error message here
  64     return;
  65   }
  66   if (!mySlvsConstraints.empty()) // some data is changed, update constraint
  67     update(myBaseConstraint);
  68
  69   int aConstrType = getType();
  70   double aValue = 0.0;
  71   std::vector<Slvs_hEntity> anAttributes;
  72   getAttributes(aValue, anAttributes);
  73   if (!myErrorMsg.empty())
  74     return;
  75
  76   Slvs_hGroup aGroupID = myGroup->getId();
  77   Slvs_hEntity aWorkplaneID = myGroup->getWorkplaneId();
  78   Slvs_Constraint aConstraint;
  79   if (mySlvsConstraints.empty())
  80     aConstraint = Slvs_MakeConstraint(SLVS_C_UNKNOWN, aGroupID, aConstrType, aWorkplaneID,
  81         aValue, anAttributes[0], anAttributes[1], anAttributes[2], anAttributes[3]);
  82   else {
  83     aConstraint = myStorage->getConstraint(mySlvsConstraints[0]);
  84     aConstraint.valA = aValue;
  85     static const int aNbAttrs = 6;
  86     Slvs_hEntity* aConstrAttrs[aNbAttrs] = {
  87         &aConstraint.ptA, &aConstraint.ptB,
  88         &aConstraint.entityA, &aConstraint.entityB,
  89         &aConstraint.entityC, &aConstraint.entityD};
  90     std::vector<Slvs_hEntity>::const_iterator anIter = anAttributes.begin();
  91     for (int i = 0; i < aNbAttrs && anIter != anAttributes.end(); i++, anIter++)
  92       *(aConstrAttrs[i]) = *anIter;
  93   }
  94
  95   Slvs_hConstraint anID = myStorage->addConstraint(aConstraint);
  96   if (mySlvsConstraints.empty())
  97     mySlvsConstraints.push_back(anID);
  98   else
  99     mySlvsConstraints[0] = anID;
 100   adjustConstraint();
 101 }
 102
 103 void SketchSolver_Constraint::update(ConstraintPtr theConstraint)
 104 {
 105   cleanErrorMsg();
 106   if (theConstraint && theConstraint != myBaseConstraint) {
 107     if (theConstraint->getKind() != myBaseConstraint->getKind())
 108       return;
 109     remove(myBaseConstraint);
 110     myBaseConstraint = theConstraint;
 111     process();
 112   }
 113
 114   // Update all attributes
 115   int aType;
 116   std::map<Slvs_hEntity, Slvs_hEntity> aRelocationMap;
 117   std::map<FeaturePtr, Slvs_hEntity>::iterator aFeatIter = myFeatureMap.begin();
 118   for (; aFeatIter != myFeatureMap.end(); aFeatIter++) {
 119     Slvs_hEntity aPrevID = aFeatIter->second;
 120     aFeatIter->second = changeEntity(aFeatIter->first, aType);
 121     if (aFeatIter->second != aPrevID)
 122       aRelocationMap[aPrevID] = aFeatIter->second;
 123   }
 124   std::map<AttributePtr, Slvs_hEntity>::iterator anAttrIter = myAttributeMap.begin();
 125   for (; anAttrIter != myAttributeMap.end(); anAttrIter++) {
 126     Slvs_hEntity aPrevID = anAttrIter->second;
 127     anAttrIter->second = changeEntity(anAttrIter->first, aType);
 128     if (anAttrIter->second != aPrevID)
 129       aRelocationMap[aPrevID] = anAttrIter->second;
 130   }
 131
 132   // Value if exists
 133   AttributeDoublePtr aValueAttr = std::dynamic_pointer_cast<ModelAPI_AttributeDouble>(
 134     myBaseConstraint->data()->attribute(SketchPlugin_Constraint::VALUE()));
 135   double aValue = aValueAttr ? aValueAttr->value() : 0.0;
 136
 137   // Update constraint
 138   std::vector<Slvs_hConstraint>::iterator aCIter = mySlvsConstraints.begin();
 139   for (; aCIter != mySlvsConstraints.end(); aCIter++) {
 140     Slvs_Constraint aConstraint = myStorage->getConstraint(*aCIter);
 141     aConstraint.valA = aValue;
 142     Slvs_hEntity* aCoeffs[6] = {
 143         &aConstraint.ptA, &aConstraint.ptB,
 144         &aConstraint.entityA, &aConstraint.entityB,
 145         &aConstraint.entityC, &aConstraint.entityD};
 146     for (int i = 0; i < 6; i++) {
 147       if (*(aCoeffs[i]) == SLVS_E_UNKNOWN)
 148         continue;
 149       std::map<Slvs_hEntity, Slvs_hEntity>::iterator aFound = aRelocationMap.find(*(aCoeffs[i]));
 150       if (aFound != aRelocationMap.end())
 151         *(aCoeffs[i]) = aFound->second;
 152     }
 153     *aCIter = myStorage->addConstraint(aConstraint);
 154   }
 155   adjustConstraint();
 156 }
 157
 158 bool SketchSolver_Constraint::remove(ConstraintPtr theConstraint)
 159 {
 160   cleanErrorMsg();
 161   if (theConstraint && theConstraint != myBaseConstraint)
 162     return false;
 163   if (mySlvsConstraints.empty())
 164     return true;
 165   bool isFullyRemoved = myStorage->removeConstraint(mySlvsConstraints.front());
 166   if (isFullyRemoved) {
 167     myFeatureMap.clear();
 168     myAttributeMap.clear();
 169     myValueMap.clear();
 170   } else
 171     cleanRemovedEntities();
 172   return true;
 173 }
 174
 175 void SketchSolver_Constraint::cleanRemovedEntities()
 176 {
 177   std::set<Slvs_hParam> aRemovedParams;
 178   std::set<Slvs_hEntity> aRemovedEntities;
 179   std::set<Slvs_hConstraint> aRemovedConstraints;
 180   myStorage->getRemoved(aRemovedParams, aRemovedEntities, aRemovedConstraints);
 181   std::map<FeaturePtr, Slvs_hEntity>::iterator aFeatIt = myFeatureMap.begin();
 182   while (aFeatIt != myFeatureMap.end()) {
 183     if (aRemovedEntities.find(aFeatIt->second) == aRemovedEntities.end()) {
 184       aFeatIt++;
 185       continue;
 186     }
 187     std::map<FeaturePtr, Slvs_hEntity>::iterator aTmpIter = aFeatIt++;
 188     myFeatureMap.erase(aTmpIter);
 189   }
 190   std::map<AttributePtr, Slvs_hEntity>::iterator anAttrIt = myAttributeMap.begin();
 191   while (anAttrIt != myAttributeMap.end()) {
 192     if (aRemovedEntities.find(anAttrIt->second) == aRemovedEntities.end()) {
 193       anAttrIt++;
 194       continue;
 195     }
 196     std::map<AttributePtr, Slvs_hEntity>::iterator aTmpIter = anAttrIt++;
 197     myAttributeMap.erase(aTmpIter);
 198   }
 199   std::map<AttributePtr, Slvs_hParam>::iterator aValIt = myValueMap.begin();
 200   while (aValIt != myValueMap.end()) {
 201     if (aRemovedParams.find(aValIt->second) == aRemovedParams.end()) {
 202       aValIt++;
 203       continue;
 204     }
 205     std::map<AttributePtr, Slvs_hParam>::iterator aTmpIter = aValIt++;
 206     myValueMap.erase(aTmpIter);
 207   }
 208 }
 209
 210 void SketchSolver_Constraint::getAttributes(
 211     double& theValue,
 212     std::vector<Slvs_hEntity>& theAttributes)
 213 {
 214   static const int anInitNbOfAttr = 4;
 215   theAttributes.assign(anInitNbOfAttr, SLVS_E_UNKNOWN);
 216
 217   DataPtr aData = myBaseConstraint->data();
 218
 219   AttributeDoublePtr aValueAttr = std::dynamic_pointer_cast<ModelAPI_AttributeDouble>(
 220     aData->attribute(SketchPlugin_Constraint::VALUE()));
 221   theValue = aValueAttr ? aValueAttr->value() : 0.0;
 222
 223   int aPtInd = 0; // index of first point in the list of attributes
 224   int aEntInd = 2; // index of first antity in the list of attributes
 225   std::list<AttributePtr> aConstrAttrs = aData->attributes(ModelAPI_AttributeRefAttr::typeId());
 226   std::list<AttributePtr>::iterator anIter = aConstrAttrs.begin();
 227   for (; anIter != aConstrAttrs.end(); anIter++) {
 228     AttributeRefAttrPtr aRefAttr =
 229         std::dynamic_pointer_cast<ModelAPI_AttributeRefAttr>(*anIter);
 230     if (!aRefAttr || !aRefAttr->isInitialized()) {
 231       myErrorMsg = SketchSolver_Error::NOT_INITIALIZED();
 232       return;
 233     }
 234
 235     int aType = SLVS_E_UNKNOWN; // type of created entity
 236     Slvs_hEntity anEntity = myGroup->getAttributeId(aRefAttr);
 237     if (anEntity == SLVS_E_UNKNOWN)
 238       anEntity = changeEntity(aRefAttr, aType);
 239     else {
 240       Slvs_Entity anEnt = myStorage->getEntity(anEntity);
 241       aType = anEnt.type;
 242     }
 243
 244     if (aType == SLVS_E_UNKNOWN)
 245       continue;
 246     else if (aType == SLVS_E_POINT_IN_2D || aType == SLVS_E_POINT_IN_3D)
 247       theAttributes[aPtInd++] = anEntity; // the point is created
 248     else { // another entity (not a point) is created
 249       if (aEntInd < anInitNbOfAttr)
 250         theAttributes[aEntInd] = anEntity;
 251       else
 252         theAttributes.push_back(anEntity);
 253       aEntInd++;
 254     }
 255   }
 256 }
 257
 258 Slvs_hEntity SketchSolver_Constraint::changeEntity(AttributeRefAttrPtr theAttribute, int& theType)
 259 {
 260   // Convert the object of the attribute to the feature
 261   FeaturePtr aFeature;
 262   if (theAttribute->isObject() && theAttribute->object()) {
 263     ResultConstructionPtr aRC = std::dynamic_pointer_cast<ModelAPI_ResultConstruction>(
 264         theAttribute->object());
 265     if (!aRC) {
 266       myErrorMsg = SketchSolver_Error::NOT_INITIALIZED();
 267       return SLVS_E_UNKNOWN;
 268     }
 269     std::shared_ptr<ModelAPI_Document> aDoc = aRC->document();
 270     aFeature = aDoc->feature(aRC);
 271
 272     return changeEntity(aFeature, theType);
 273   }
 274
 275   return changeEntity(theAttribute->attr(), theType);
 276 }
 277
 278 Slvs_hEntity SketchSolver_Constraint::changeEntity(AttributePtr theEntity, int& theType)
 279 {
 280   Slvs_hEntity aResult = SLVS_E_UNKNOWN;
 281   if (!theEntity->isInitialized())
 282     return SLVS_E_UNKNOWN;
 283
 284   // If the entity is already in the group, try to find it
 285   std::map<std::shared_ptr<ModelAPI_Attribute>, Slvs_hEntity>::const_iterator anEntIter =
 286       myAttributeMap.find(theEntity);
 287   Slvs_Entity aCurrentEntity;
 288   aCurrentEntity.h = SLVS_E_UNKNOWN;
 289   if (anEntIter != myAttributeMap.end())
 290     aCurrentEntity = myStorage->getEntity(anEntIter->second);
 291   else {
 292     aResult = myGroup->getAttributeId(theEntity);
 293     if (aResult != SLVS_E_UNKNOWN) {
 294       Slvs_Entity anEnt = myStorage->getEntity(aResult);
 295       theType = anEnt.type;
 296       return aResult;
 297     }
 298   }
 299
 300   Slvs_hGroup aGroupID = myGroup->getId();
 301   // Point in 3D
 302   std::shared_ptr<GeomDataAPI_Point> aPoint =
 303       std::dynamic_pointer_cast<GeomDataAPI_Point>(theEntity);
 304   if (aPoint) {
 305     double aXYZ[3] = {aPoint->x(), aPoint->y(), aPoint->z()};
 306     Slvs_hParam aParams[3];
 307     for (int i = 0; i < 3; i++) {
 308       Slvs_Param aPar = aCurrentEntity.h != SLVS_E_UNKNOWN ?
 309           myStorage->getParameter(aCurrentEntity.param[i]) :
 310           Slvs_MakeParam(SLVS_E_UNKNOWN, aGroupID, 0.0);
 311       aPar.val = aXYZ[i];
 312       aParams[i] = myStorage->addParameter(aPar);
 313     }
 314
 315     if (aCurrentEntity.h == SLVS_E_UNKNOWN) // New entity
 316       aCurrentEntity = Slvs_MakePoint3d(SLVS_E_UNKNOWN, aGroupID, aParams[0], aParams[1], aParams[2]);
 317     else { // update entity data
 318       for (int i = 0; i < 3; i++)
 319         aCurrentEntity.param[i] = aParams[i];
 320     }
 321     aResult = myStorage->addEntity(aCurrentEntity);
 322   } else {
 323     // All entities except 3D points are created on workplane. So, if there is no workplane yet, then error
 324     Slvs_hEntity aWorkplaneID = myGroup->getWorkplaneId();
 325     if (aWorkplaneID == SLVS_E_UNKNOWN)
 326       return SLVS_E_UNKNOWN;
 327
 328     // Point in 2D
 329     std::shared_ptr<GeomDataAPI_Point2D> aPoint2D =
 330         std::dynamic_pointer_cast<GeomDataAPI_Point2D>(theEntity);
 331     if (aPoint2D) {
 332       double aXY[2] = {aPoint2D->x(), aPoint2D->y()};
 333       Slvs_hParam aParams[2];
 334       for (int i = 0; i < 2; i++) {
 335         Slvs_Param aPar = aCurrentEntity.h != SLVS_E_UNKNOWN ?
 336             myStorage->getParameter(aCurrentEntity.param[i]) :
 337             Slvs_MakeParam(SLVS_E_UNKNOWN, aGroupID, 0.0);
 338         aPar.val = aXY[i];
 339         aParams[i] = myStorage->addParameter(aPar);
 340       }
 341
 342       if (aCurrentEntity.h == SLVS_E_UNKNOWN) // New entity
 343         aCurrentEntity = Slvs_MakePoint2d(SLVS_E_UNKNOWN, aGroupID, aWorkplaneID, aParams[0], aParams[1]);
 344       else { // update entity data
 345         for (int i = 0; i < 2; i++)
 346           aCurrentEntity.param[i] = aParams[i];
 347       }
 348       aResult = myStorage->addEntity(aCurrentEntity);
 349     } else {
 350       // Scalar value (used for the distance entities)
 351       AttributeDoublePtr aScalar = std::dynamic_pointer_cast<ModelAPI_AttributeDouble>(theEntity);
 352       if (aScalar) {
 353         Slvs_Param aParam = aCurrentEntity.h != SLVS_E_UNKNOWN ?
 354             myStorage->getParameter(aCurrentEntity.param[0]) :
 355             Slvs_MakeParam(SLVS_E_UNKNOWN, aGroupID, 0.0);
 356         aParam.val = aScalar->value();
 357         Slvs_hParam aValue = myStorage->addParameter(aParam);
 358
 359         if (aCurrentEntity.h == SLVS_E_UNKNOWN) // New entity
 360           aCurrentEntity = Slvs_MakeDistance(SLVS_E_UNKNOWN, aGroupID, aWorkplaneID, aValue);
 361         else
 362           aCurrentEntity.param[0] = aValue;
 363         aResult = myStorage->addEntity(aCurrentEntity);
 364       }
 365     }
 366   }
 367
 368   myAttributeMap[theEntity] = aResult;
 369   theType = aCurrentEntity.type;
 370   return aResult;
 371 }
 372
 373 Slvs_hEntity SketchSolver_Constraint::changeEntity(FeaturePtr theEntity, int& theType)
 374 {
 375   Slvs_hEntity aResult = SLVS_E_UNKNOWN;
 376   if (!theEntity->data()->isValid())
 377     return SLVS_E_UNKNOWN;
 378   // If the entity is already in the group, try to find it
 379   std::map<FeaturePtr, Slvs_hEntity>::const_iterator anEntIter = myFeatureMap.find(theEntity);
 380   Slvs_Entity aCurrentEntity;
 381   aCurrentEntity.h = SLVS_E_UNKNOWN;
 382   if (anEntIter != myFeatureMap.end())
 383     aCurrentEntity = myStorage->getEntity(anEntIter->second);
 384   else {
 385     aResult = myGroup->getFeatureId(theEntity);
 386     if (aResult != SLVS_E_UNKNOWN) {
 387       Slvs_Entity anEnt = myStorage->getEntity(aResult);
 388       theType = anEnt.type;
 389       return aResult;
 390     }
 391   }
 392
 393   Slvs_hGroup aGroupID = myGroup->getId();
 394   Slvs_hEntity aWorkplaneID = myGroup->getWorkplaneId();
 395   // SketchPlugin features
 396   std::shared_ptr<SketchPlugin_Feature> aFeature = std::dynamic_pointer_cast<
 397       SketchPlugin_Feature>(theEntity);
 398   if (aFeature) {  // Verify the feature by its kind
 399     const std::string& aFeatureKind = aFeature->getKind();
 400     AttributePtr anAttribute;
 401     int anAttrType;
 402
 403     // Line
 404     if (aFeatureKind == SketchPlugin_Line::ID()) {
 405       anAttribute = aFeature->data()->attribute(SketchPlugin_Line::START_ID());
 406       if (!anAttribute->isInitialized()) return SLVS_E_UNKNOWN;
 407       Slvs_hEntity aStart = changeEntity(anAttribute, anAttrType);
 408
 409       anAttribute = aFeature->data()->attribute(SketchPlugin_Line::END_ID());
 410       if (!anAttribute->isInitialized()) return SLVS_E_UNKNOWN;
 411       Slvs_hEntity aEnd = changeEntity(anAttribute, anAttrType);
 412
 413       if (aCurrentEntity.h == SLVS_E_UNKNOWN) // New entity
 414         aCurrentEntity = Slvs_MakeLineSegment(SLVS_E_UNKNOWN, aGroupID, aWorkplaneID, aStart, aEnd);
 415       else {
 416         aCurrentEntity.point[0] = aStart;
 417         aCurrentEntity.point[1] = aEnd;
 418       }
 419       aResult = myStorage->addEntity(aCurrentEntity);
 420     }
 421     // Circle
 422     else if (aFeatureKind == SketchPlugin_Circle::ID()) {
 423       anAttribute = aFeature->data()->attribute(SketchPlugin_Circle::CENTER_ID());
 424       if (!anAttribute->isInitialized()) return SLVS_E_UNKNOWN;
 425       Slvs_hEntity aCenter = changeEntity(anAttribute, anAttrType);
 426
 427       anAttribute = aFeature->data()->attribute(SketchPlugin_Circle::RADIUS_ID());
 428       if (!anAttribute->isInitialized()) return SLVS_E_UNKNOWN;
 429       Slvs_hEntity aRadius = changeEntity(anAttribute, anAttrType);
 430
 431       if (aCurrentEntity.h == SLVS_E_UNKNOWN) { // New entity
 432         Slvs_Entity aWorkplane = myStorage->getEntity(aWorkplaneID);
 433         aCurrentEntity = Slvs_MakeCircle(SLVS_E_UNKNOWN, aGroupID, aWorkplaneID,
 434                                          aCenter, aWorkplane.normal, aRadius);
 435       } else {
 436         aCurrentEntity.point[0] = aCenter;
 437         aCurrentEntity.distance = aRadius;
 438       }
 439       aResult = myStorage->addEntity(aCurrentEntity);
 440     }
 441     // Arc
 442     else if (aFeatureKind == SketchPlugin_Arc::ID()) {
 443       anAttribute = aFeature->data()->attribute(SketchPlugin_Arc::CENTER_ID());
 444       if (!anAttribute->isInitialized()) return SLVS_E_UNKNOWN;
 445       Slvs_hEntity aCenter = changeEntity(anAttribute, anAttrType);
 446
 447       anAttribute = aFeature->data()->attribute(SketchPlugin_Arc::START_ID());
 448       if (!anAttribute->isInitialized()) return SLVS_E_UNKNOWN;
 449       Slvs_hEntity aStart = changeEntity(anAttribute, anAttrType);
 450
 451       anAttribute = aFeature->data()->attribute(SketchPlugin_Arc::END_ID());
 452       if (!anAttribute->isInitialized()) return SLVS_E_UNKNOWN;
 453       Slvs_hEntity aEnd = changeEntity(anAttribute, anAttrType);
 454
 455       if (aCurrentEntity.h == SLVS_E_UNKNOWN) { // New entity
 456         Slvs_Entity aWorkplane = myStorage->getEntity(aWorkplaneID);
 457         aCurrentEntity = Slvs_MakeArcOfCircle(SLVS_E_UNKNOWN, aGroupID, aWorkplaneID,
 458                                               aWorkplane.normal, aCenter, aStart, aEnd);
 459       } else {
 460         aCurrentEntity.point[0] = aCenter;
 461         aCurrentEntity.point[1] = aStart;
 462         aCurrentEntity.point[2] = aEnd;
 463       }
 464       aResult = myStorage->addEntity(aCurrentEntity);
 465     }
 466     // Point (it has low probability to be an attribute of constraint, so it is checked at the end)
 467     else if (aFeatureKind == SketchPlugin_Point::ID()) {
 468       anAttribute = aFeature->data()->attribute(SketchPlugin_Point::COORD_ID());
 469       if (!anAttribute->isInitialized()) return SLVS_E_UNKNOWN;
 470       // Both the sketch point and its attribute (coordinates) link to the same SolveSpace point identifier
 471       aResult = changeEntity(anAttribute, anAttrType);
 472       aCurrentEntity.type = SLVS_E_POINT_IN_3D;
 473     }
 474   }
 475
 476   if (aResult != SLVS_E_UNKNOWN) {
 477     myFeatureMap[theEntity] = aResult;
 478     theType = aCurrentEntity.type;
 479   }
 480   return aResult;
 481 }
 482
 483 std::list<ConstraintPtr> SketchSolver_Constraint::constraints() const
 484 {
 485   std::list<ConstraintPtr> aConstraints;
 486   aConstraints.push_back(myBaseConstraint);
 487   return aConstraints;
 488 }
 489
 490 void SketchSolver_Constraint::refresh()
 491 {
 492   cleanErrorMsg();
 493   std::map<AttributePtr, Slvs_hEntity>::iterator anAttrIter = myAttributeMap.begin();
 494   for (; anAttrIter != myAttributeMap.end(); anAttrIter++) {
 495     std::shared_ptr<GeomDataAPI_Point> aPoint =
 496         std::dynamic_pointer_cast<GeomDataAPI_Point>(anAttrIter->first);
 497     if (aPoint) {
 498       Slvs_Entity anEntity = myStorage->getEntity(anAttrIter->second);
 499       double aXYZ[3];
 500       for (int i = 0; i < 3; i++) {
 501         Slvs_Param aPar = myStorage->getParameter(anEntity.param[i]);
 502         aXYZ[i] = aPar.val;
 503       }
 504       aPoint->setValue(aXYZ[0], aXYZ[1], aXYZ[2]);
 505     } else {
 506       // Point in 2D
 507       std::shared_ptr<GeomDataAPI_Point2D> aPoint2D =
 508           std::dynamic_pointer_cast<GeomDataAPI_Point2D>(anAttrIter->first);
 509       if (aPoint2D) {
 510         Slvs_Entity anEntity = myStorage->getEntity(anAttrIter->second);
 511         double aXYZ[2];
 512         for (int i = 0; i < 2; i++) {
 513           Slvs_Param aPar = myStorage->getParameter(anEntity.param[i]);
 514           aXYZ[i] = aPar.val;
 515         }
 516         aPoint2D->setValue(aXYZ[0], aXYZ[1]);
 517       } else {
 518         // Scalar value (used for the distance entities)
 519         AttributeDoublePtr aScalar =
 520             std::dynamic_pointer_cast<ModelAPI_AttributeDouble>(anAttrIter->first);
 521         if (aScalar) {
 522           Slvs_Entity anEntity = myStorage->getEntity(anAttrIter->second);
 523           Slvs_Param aPar = myStorage->getParameter(anEntity.param[0]);
 524           aScalar->setValue(aPar.val);
 525         }
 526       }
 527     }
 528   }
 529
 530   std::map<AttributePtr, Slvs_hParam>::iterator aValIter = myValueMap.begin();
 531   for (; aValIter != myValueMap.end(); aValIter++) {
 532     AttributeDoublePtr aScalar =
 533         std::dynamic_pointer_cast<ModelAPI_AttributeDouble>(anAttrIter->first);
 534     if (aScalar) {
 535       Slvs_Param aPar = myStorage->getParameter(anAttrIter->second);
 536       aScalar->setValue(aPar.val);
 537     }
 538   }
 539 }
 540
 541 Slvs_hEntity SketchSolver_Constraint::getId(FeaturePtr theFeature) const
 542 {
 543   std::map<FeaturePtr, Slvs_hEntity>::const_iterator aFIter = myFeatureMap.find(theFeature);
 544   if (aFIter == myFeatureMap.end())
 545     return SLVS_E_UNKNOWN;
 546   return aFIter->second;
 547 }
 548
 549 Slvs_hEntity SketchSolver_Constraint::getId(AttributePtr theAttribute) const
 550 {
 551   std::map<AttributePtr, Slvs_hEntity>::const_iterator anAttrIter = myAttributeMap.find(theAttribute);
 552   if (anAttrIter == myAttributeMap.end())
 553     return SLVS_E_UNKNOWN;
 554   return anAttrIter->second;
 555 }
 556