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 <GeomAPI_Dir2d.h>
  11 #include <GeomDataAPI_Point.h>
  12 #include <GeomDataAPI_Point2D.h>
  13 #include <ModelAPI_AttributeDouble.h>
  14 #include <ModelAPI_ResultConstruction.h>
  15
  16 #include <math.h>
  17
  18 SketchSolver_Constraint::SketchSolver_Constraint(
  19     ConstraintPtr  theConstraint)
  20   : myBaseConstraint(theConstraint),
  21     myGroup(0)
  22 {
  23 }
  24
  25 SketchSolver_Constraint::~SketchSolver_Constraint()
  26 {
  27   std::map<AttributePtr, Slvs_hParam>::const_iterator anIt1 = myValueMap.begin();
  28   for (; anIt1 != myValueMap.end(); anIt1++)
  29     myStorage->removeParameter(anIt1->second);
  30   myValueMap.clear();
  31
  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();
  36
  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);
  46   }
  47
  48   std::vector<Slvs_hConstraint>::const_iterator anIt4 = mySlvsConstraints.begin();
  49   for (; anIt4 != mySlvsConstraints.end(); anIt4++)
  50     myStorage->removeConstraint(*anIt4);
  51   mySlvsConstraints.clear();
  52 }
  53
  54 void SketchSolver_Constraint::setStorage(StoragePtr theStorage)
  55 {
  56   myStorage = theStorage;
  57   process();
  58 }
  59
  60 void SketchSolver_Constraint::setGroup(SketchSolver_Group* theGroup)
  61 {
  62   myGroup = theGroup;
  63   process();
  64 }
  65
  66 void SketchSolver_Constraint::addFeature(FeaturePtr theFeature)
  67 {
  68   int aType;
  69   changeEntity(theFeature, aType);
  70 }
  71
  72
  73 void SketchSolver_Constraint::process()
  74 {
  75   cleanErrorMsg();
  76   if (!myBaseConstraint || !myStorage || myGroup == 0) {
  77     /// TODO: Put error message here
  78     return;
  79   }
  80   if (!mySlvsConstraints.empty()) // some data is changed, update constraint
  81     update(myBaseConstraint);
  82
  83   int aConstrType = getType();
  84   double aValue = 0.0;
  85   std::vector<Slvs_hEntity> anAttributes;
  86   getAttributes(aValue, anAttributes);
  87   if (!myErrorMsg.empty())
  88     return;
  89   if (aConstrType == SLVS_C_UNKNOWN)
  90     aConstrType = getType();
  91
  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]);
  98   else {
  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;
 109   }
 110
 111   Slvs_hConstraint anID = myStorage->addConstraint(aConstraint);
 112   if (mySlvsConstraints.empty())
 113     mySlvsConstraints.push_back(anID);
 114   else
 115     mySlvsConstraints[0] = anID;
 116   adjustConstraint();
 117 }
 118
 119 bool SketchSolver_Constraint::checkAttributesChanged(ConstraintPtr theConstraint)
 120 {
 121   // Check the attrbutes of constraint are changed
 122   ConstraintPtr aConstraint = theConstraint ? theConstraint : myBaseConstraint;
 123   std::list<AttributePtr> anAttrList = aConstraint->data()->attributes(std::string());
 124   std::list<AttributePtr>::iterator anAttrIter = anAttrList.begin();
 125   for (; anAttrIter != anAttrList.end(); anAttrIter++) {
 126     AttributeRefAttrPtr aRefAttr =
 127         std::dynamic_pointer_cast<ModelAPI_AttributeRefAttr>(*anAttrIter);
 128     if (aRefAttr) {
 129       if (aRefAttr->isObject()) {
 130         FeaturePtr aFeature = ModelAPI_Feature::feature(aRefAttr->object());
 131         if (aFeature && myFeatureMap.find(aFeature) == myFeatureMap.end())
 132           return true;
 133       } else if (aRefAttr->attr() &&
 134                  myAttributeMap.find(aRefAttr->attr()) == myAttributeMap.end())
 135         return true;
 136     }
 137     AttributeRefListPtr aRefList =
 138         std::dynamic_pointer_cast<ModelAPI_AttributeRefList>(*anAttrIter);
 139     if (aRefList) {
 140       std::list<ObjectPtr> anItems = aRefList->list();
 141       std::list<ObjectPtr>::iterator anIt = anItems.begin();
 142       for (; anIt != anItems.end(); anIt++) {
 143         FeaturePtr aFeature = ModelAPI_Feature::feature(*anIt);
 144         if (aFeature && myFeatureMap.find(aFeature) == myFeatureMap.end())
 145           return true;
 146       }
 147     }
 148   }
 149   return false;
 150 }
 151
 152 void SketchSolver_Constraint::update(ConstraintPtr theConstraint)
 153 {
 154   cleanErrorMsg();
 155   bool needToRebuild = (theConstraint && theConstraint != myBaseConstraint);
 156   if (!needToRebuild)
 157     needToRebuild = checkAttributesChanged(theConstraint);
 158   if (needToRebuild) {
 159     if (theConstraint && theConstraint->getKind() != myBaseConstraint->getKind())
 160       return;
 161     remove(myBaseConstraint);
 162     if (theConstraint)
 163       myBaseConstraint = theConstraint;
 164     process();
 165     return;
 166   }
 167
 168   // Update all attributes
 169   int aType;
 170   std::map<Slvs_hEntity, Slvs_hEntity> aRelocationMap;
 171   std::map<FeaturePtr, Slvs_hEntity>::iterator aFeatIter = myFeatureMap.begin();
 172   for (; aFeatIter != myFeatureMap.end(); aFeatIter++) {
 173     Slvs_hEntity aPrevID = aFeatIter->second;
 174     aFeatIter->second = changeEntity(aFeatIter->first, aType);
 175     if (aFeatIter->second != aPrevID)
 176       aRelocationMap[aPrevID] = aFeatIter->second;
 177   }
 178   std::map<AttributePtr, Slvs_hEntity>::iterator anAttrIter = myAttributeMap.begin();
 179   for (; anAttrIter != myAttributeMap.end(); anAttrIter++) {
 180     Slvs_hEntity aPrevID = anAttrIter->second;
 181     anAttrIter->second = changeEntity(anAttrIter->first, aType);
 182     if (anAttrIter->second != aPrevID)
 183       aRelocationMap[aPrevID] = anAttrIter->second;
 184   }
 185
 186   // Value if exists
 187   DataPtr aData = myBaseConstraint->data();
 188   if (!aData) return;
 189   AttributeDoublePtr aValueAttr = std::dynamic_pointer_cast<ModelAPI_AttributeDouble>(
 190     myBaseConstraint->attribute(SketchPlugin_Constraint::VALUE()));
 191   double aValue = aValueAttr ? aValueAttr->value() : 0.0;
 192
 193   // Update constraint
 194   std::vector<Slvs_hConstraint>::iterator aCIter = mySlvsConstraints.begin();
 195   for (; aCIter != mySlvsConstraints.end(); aCIter++) {
 196     Slvs_Constraint aConstraint = myStorage->getConstraint(*aCIter);
 197     if (aValueAttr)
 198       aConstraint.valA = aValue;
 199     Slvs_hEntity* aCoeffs[6] = {
 200         &aConstraint.ptA, &aConstraint.ptB,
 201         &aConstraint.entityA, &aConstraint.entityB,
 202         &aConstraint.entityC, &aConstraint.entityD};
 203     for (int i = 0; i < 6; i++) {
 204       if (*(aCoeffs[i]) == SLVS_E_UNKNOWN)
 205         continue;
 206       std::map<Slvs_hEntity, Slvs_hEntity>::iterator aFound = aRelocationMap.find(*(aCoeffs[i]));
 207       if (aFound != aRelocationMap.end())
 208         *(aCoeffs[i]) = aFound->second;
 209     }
 210     *aCIter = myStorage->addConstraint(aConstraint);
 211   }
 212   adjustConstraint();
 213 }
 214
 215 bool SketchSolver_Constraint::remove(ConstraintPtr theConstraint)
 216 {
 217   cleanErrorMsg();
 218   if (theConstraint && theConstraint != myBaseConstraint)
 219     return false;
 220   if (mySlvsConstraints.empty())
 221     return true;
 222   bool isFullyRemoved = myStorage->removeConstraint(mySlvsConstraints.front());
 223   if (isFullyRemoved) {
 224     myFeatureMap.clear();
 225     myAttributeMap.clear();
 226     myValueMap.clear();
 227   } else
 228     cleanRemovedEntities();
 229   mySlvsConstraints.clear();
 230   return true;
 231 }
 232
 233 void SketchSolver_Constraint::cleanRemovedEntities()
 234 {
 235   std::set<Slvs_hParam> aRemovedParams;
 236   std::set<Slvs_hEntity> aRemovedEntities;
 237   std::set<Slvs_hConstraint> aRemovedConstraints;
 238   myStorage->getRemoved(aRemovedParams, aRemovedEntities, aRemovedConstraints);
 239   std::map<FeaturePtr, Slvs_hEntity>::iterator aFeatIt = myFeatureMap.begin();
 240   while (aFeatIt != myFeatureMap.end()) {
 241     if (aRemovedEntities.find(aFeatIt->second) == aRemovedEntities.end()) {
 242       aFeatIt++;
 243       continue;
 244     }
 245     std::map<FeaturePtr, Slvs_hEntity>::iterator aTmpIter = aFeatIt++;
 246     myFeatureMap.erase(aTmpIter);
 247   }
 248   std::map<AttributePtr, Slvs_hEntity>::iterator anAttrIt = myAttributeMap.begin();
 249   while (anAttrIt != myAttributeMap.end()) {
 250     if (aRemovedEntities.find(anAttrIt->second) == aRemovedEntities.end()) {
 251       anAttrIt++;
 252       continue;
 253     }
 254     std::map<AttributePtr, Slvs_hEntity>::iterator aTmpIter = anAttrIt++;
 255     myAttributeMap.erase(aTmpIter);
 256   }
 257   std::map<AttributePtr, Slvs_hParam>::iterator aValIt = myValueMap.begin();
 258   while (aValIt != myValueMap.end()) {
 259     if (aRemovedParams.find(aValIt->second) == aRemovedParams.end()) {
 260       aValIt++;
 261       continue;
 262     }
 263     std::map<AttributePtr, Slvs_hParam>::iterator aTmpIter = aValIt++;
 264     myValueMap.erase(aTmpIter);
 265   }
 266 }
 267
 268 void SketchSolver_Constraint::getAttributes(
 269     double& theValue,
 270     std::vector<Slvs_hEntity>& theAttributes)
 271 {
 272   static const int anInitNbOfAttr = 4;
 273   theAttributes.assign(anInitNbOfAttr, SLVS_E_UNKNOWN);
 274
 275   DataPtr aData = myBaseConstraint->data();
 276
 277   AttributeDoublePtr aValueAttr = std::dynamic_pointer_cast<ModelAPI_AttributeDouble>(
 278     aData->attribute(SketchPlugin_Constraint::VALUE()));
 279   theValue = aValueAttr ? aValueAttr->value() : 0.0;
 280
 281   int aPtInd = 0; // index of first point in the list of attributes
 282   int aEntInd = 2; // index of first antity in the list of attributes
 283   std::list<AttributePtr> aConstrAttrs = aData->attributes(ModelAPI_AttributeRefAttr::typeId());
 284   std::list<AttributePtr>::iterator anIter = aConstrAttrs.begin();
 285   for (; anIter != aConstrAttrs.end(); anIter++) {
 286     AttributeRefAttrPtr aRefAttr =
 287         std::dynamic_pointer_cast<ModelAPI_AttributeRefAttr>(*anIter);
 288     if (!aRefAttr || !aRefAttr->isInitialized()) {
 289       myErrorMsg = SketchSolver_Error::NOT_INITIALIZED();
 290       return;
 291     }
 292
 293     int aType = SLVS_E_UNKNOWN; // type of created entity
 294     Slvs_hEntity anEntity = myGroup->getAttributeId(aRefAttr);
 295     if (anEntity == SLVS_E_UNKNOWN)
 296       anEntity = changeEntity(aRefAttr, aType);
 297     else {
 298       Slvs_Entity anEnt = myStorage->getEntity(anEntity);
 299       aType = anEnt.type;
 300     }
 301
 302     if (aType == SLVS_E_UNKNOWN)
 303       continue;
 304     else if (aType == SLVS_E_POINT_IN_2D || aType == SLVS_E_POINT_IN_3D)
 305       theAttributes[aPtInd++] = anEntity; // the point is created
 306     else { // another entity (not a point) is created
 307       if (aEntInd < anInitNbOfAttr)
 308         theAttributes[aEntInd] = anEntity;
 309       else
 310         theAttributes.push_back(anEntity);
 311       aEntInd++;
 312     }
 313   }
 314 }
 315
 316 Slvs_hEntity SketchSolver_Constraint::changeEntity(AttributeRefAttrPtr theAttribute, int& theType)
 317 {
 318   // Convert the object of the attribute to the feature
 319   FeaturePtr aFeature;
 320   if (theAttribute->isObject() && theAttribute->object()) {
 321     ResultConstructionPtr aRC = std::dynamic_pointer_cast<ModelAPI_ResultConstruction>(
 322         theAttribute->object());
 323     if (!aRC) {
 324       myErrorMsg = SketchSolver_Error::NOT_INITIALIZED();
 325       return SLVS_E_UNKNOWN;
 326     }
 327     std::shared_ptr<ModelAPI_Document> aDoc = aRC->document();
 328     aFeature = aDoc->feature(aRC);
 329
 330     return changeEntity(aFeature, theType);
 331   }
 332
 333   return changeEntity(theAttribute->attr(), theType);
 334 }
 335
 336 Slvs_hEntity SketchSolver_Constraint::changeEntity(AttributePtr theEntity, int& theType)
 337 {
 338   Slvs_hEntity aResult = SLVS_E_UNKNOWN;
 339   if (!theEntity || !isInitialized(theEntity)) {
 340     myErrorMsg = SketchSolver_Error::NOT_INITIALIZED();
 341     return SLVS_E_UNKNOWN;
 342   }
 343
 344   // If the entity is already in the group, try to find it
 345   std::map<std::shared_ptr<ModelAPI_Attribute>, Slvs_hEntity>::const_iterator anEntIter =
 346       myAttributeMap.find(theEntity);
 347   Slvs_Entity aCurrentEntity;
 348   aCurrentEntity.h = SLVS_E_UNKNOWN;
 349   if (anEntIter != myAttributeMap.end())
 350     aCurrentEntity = myStorage->getEntity(anEntIter->second);
 351   else {
 352     aResult = myGroup->getAttributeId(theEntity);
 353     if (aResult != SLVS_E_UNKNOWN) {
 354       Slvs_Entity anEnt = myStorage->getEntity(aResult);
 355       theType = anEnt.type;
 356       myAttributeMap[theEntity] = aResult;
 357       return aResult;
 358     }
 359   }
 360
 361   Slvs_hGroup aGroupID = myGroup->getId();
 362   // Point in 3D
 363   std::shared_ptr<GeomDataAPI_Point> aPoint =
 364       std::dynamic_pointer_cast<GeomDataAPI_Point>(theEntity);
 365   if (aPoint) {
 366     double aXYZ[3] = {aPoint->x(), aPoint->y(), aPoint->z()};
 367     Slvs_hParam aParams[3];
 368     for (int i = 0; i < 3; i++) {
 369       Slvs_Param aPar = aCurrentEntity.h != SLVS_E_UNKNOWN ?
 370           myStorage->getParameter(aCurrentEntity.param[i]) :
 371           Slvs_MakeParam(SLVS_E_UNKNOWN, aGroupID, 0.0);
 372       aPar.val = aXYZ[i];
 373       aParams[i] = myStorage->addParameter(aPar);
 374     }
 375
 376     if (aCurrentEntity.h == SLVS_E_UNKNOWN) // New entity
 377       aCurrentEntity = Slvs_MakePoint3d(SLVS_E_UNKNOWN, aGroupID, aParams[0], aParams[1], aParams[2]);
 378     else { // update entity data
 379       for (int i = 0; i < 3; i++)
 380         aCurrentEntity.param[i] = aParams[i];
 381     }
 382     aResult = myStorage->addEntity(aCurrentEntity);
 383   } else {
 384     // All entities except 3D points are created on workplane. So, if there is no workplane yet, then error
 385     Slvs_hEntity aWorkplaneID = myGroup->getWorkplaneId();
 386     if (aWorkplaneID == SLVS_E_UNKNOWN)
 387       return SLVS_E_UNKNOWN;
 388
 389     // Point in 2D
 390     std::shared_ptr<GeomDataAPI_Point2D> aPoint2D =
 391         std::dynamic_pointer_cast<GeomDataAPI_Point2D>(theEntity);
 392     if (aPoint2D) {
 393       double aXY[2] = {aPoint2D->x(), aPoint2D->y()};
 394       Slvs_hParam aParams[2];
 395       for (int i = 0; i < 2; i++) {
 396         Slvs_Param aPar = aCurrentEntity.h != SLVS_E_UNKNOWN ?
 397             myStorage->getParameter(aCurrentEntity.param[i]) :
 398             Slvs_MakeParam(SLVS_E_UNKNOWN, aGroupID, 0.0);
 399         aPar.val = aXY[i];
 400         aParams[i] = myStorage->addParameter(aPar);
 401       }
 402
 403       if (aCurrentEntity.h == SLVS_E_UNKNOWN) // New entity
 404         aCurrentEntity = Slvs_MakePoint2d(SLVS_E_UNKNOWN, aGroupID, aWorkplaneID, aParams[0], aParams[1]);
 405       else { // update entity data
 406         for (int i = 0; i < 2; i++)
 407           aCurrentEntity.param[i] = aParams[i];
 408       }
 409       aResult = myStorage->addEntity(aCurrentEntity);
 410     } else {
 411       // Scalar value (used for the distance entities)
 412       AttributeDoublePtr aScalar = std::dynamic_pointer_cast<ModelAPI_AttributeDouble>(theEntity);
 413       if (aScalar) {
 414         Slvs_Param aParam = aCurrentEntity.h != SLVS_E_UNKNOWN ?
 415             myStorage->getParameter(aCurrentEntity.param[0]) :
 416             Slvs_MakeParam(SLVS_E_UNKNOWN, aGroupID, 0.0);
 417         aParam.val = aScalar->value();
 418         Slvs_hParam aValue = myStorage->addParameter(aParam);
 419
 420         if (aCurrentEntity.h == SLVS_E_UNKNOWN) // New entity
 421           aCurrentEntity = Slvs_MakeDistance(SLVS_E_UNKNOWN, aGroupID, aWorkplaneID, aValue);
 422         else
 423           aCurrentEntity.param[0] = aValue;
 424         aResult = myStorage->addEntity(aCurrentEntity);
 425       }
 426     }
 427   }
 428
 429   myAttributeMap[theEntity] = aResult;
 430   theType = aCurrentEntity.type;
 431   return aResult;
 432 }
 433
 434 Slvs_hEntity SketchSolver_Constraint::changeEntity(FeaturePtr theEntity, int& theType)
 435 {
 436   Slvs_hEntity aResult = SLVS_E_UNKNOWN;
 437   if (!theEntity || !theEntity->data() || !theEntity->data()->isValid())
 438     return SLVS_E_UNKNOWN;
 439   // If the entity is already in the group, try to find it
 440   std::map<FeaturePtr, Slvs_hEntity>::const_iterator anEntIter = myFeatureMap.find(theEntity);
 441   Slvs_Entity aCurrentEntity;
 442   aCurrentEntity.h = SLVS_E_UNKNOWN;
 443   if (anEntIter != myFeatureMap.end())
 444     aCurrentEntity = myStorage->getEntity(anEntIter->second);
 445   else {
 446     aResult = myGroup->getFeatureId(theEntity);
 447     if (aResult != SLVS_E_UNKNOWN) {
 448       Slvs_Entity anEnt = myStorage->getEntity(aResult);
 449       theType = anEnt.type;
 450       myFeatureMap[theEntity] = aResult;
 451       return aResult;
 452     }
 453   }
 454
 455   Slvs_hGroup aGroupID = myGroup->getId();
 456   Slvs_hEntity aWorkplaneID = myGroup->getWorkplaneId();
 457   DataPtr aData = theEntity->data();
 458
 459   // SketchPlugin features
 460   const std::string& aFeatureKind = theEntity->getKind();
 461   AttributePtr anAttribute;
 462   int anAttrType;
 463   // Line
 464   if (aFeatureKind == SketchPlugin_Line::ID()) {
 465     anAttribute = aData->attribute(SketchPlugin_Line::START_ID());
 466     if (!isInitialized(anAttribute)) return SLVS_E_UNKNOWN;
 467     Slvs_hEntity aStart = changeEntity(anAttribute, anAttrType);
 468
 469     anAttribute = aData->attribute(SketchPlugin_Line::END_ID());
 470     if (!isInitialized(anAttribute)) return SLVS_E_UNKNOWN;
 471     Slvs_hEntity aEnd = changeEntity(anAttribute, anAttrType);
 472
 473     if (aCurrentEntity.h == SLVS_E_UNKNOWN) // New entity
 474       aCurrentEntity = Slvs_MakeLineSegment(SLVS_E_UNKNOWN, aGroupID, aWorkplaneID, aStart, aEnd);
 475     else {
 476       aCurrentEntity.point[0] = aStart;
 477       aCurrentEntity.point[1] = aEnd;
 478     }
 479     aResult = myStorage->addEntity(aCurrentEntity);
 480   }
 481   // Circle
 482   else if (aFeatureKind == SketchPlugin_Circle::ID()) {
 483     anAttribute = aData->attribute(SketchPlugin_Circle::CENTER_ID());
 484     if (!isInitialized(anAttribute)) return SLVS_E_UNKNOWN;
 485     Slvs_hEntity aCenter = changeEntity(anAttribute, anAttrType);
 486
 487     anAttribute = aData->attribute(SketchPlugin_Circle::RADIUS_ID());
 488     if (!isInitialized(anAttribute)) return SLVS_E_UNKNOWN;
 489     Slvs_hEntity aRadius = changeEntity(anAttribute, anAttrType);
 490
 491     if (aCurrentEntity.h == SLVS_E_UNKNOWN) { // New entity
 492       Slvs_Entity aWorkplane = myStorage->getEntity(aWorkplaneID);
 493       aCurrentEntity = Slvs_MakeCircle(SLVS_E_UNKNOWN, aGroupID, aWorkplaneID,
 494                                         aCenter, aWorkplane.normal, aRadius);
 495     } else {
 496       aCurrentEntity.point[0] = aCenter;
 497       aCurrentEntity.distance = aRadius;
 498     }
 499     aResult = myStorage->addEntity(aCurrentEntity);
 500   }
 501   // Arc
 502   else if (aFeatureKind == SketchPlugin_Arc::ID()) {
 503     anAttribute = aData->attribute(SketchPlugin_Arc::CENTER_ID());
 504     if (!isInitialized(anAttribute)) return SLVS_E_UNKNOWN;
 505     Slvs_hEntity aCenter = changeEntity(anAttribute, anAttrType);
 506
 507     anAttribute = aData->attribute(SketchPlugin_Arc::START_ID());
 508     if (!isInitialized(anAttribute)) return SLVS_E_UNKNOWN;
 509     Slvs_hEntity aStart = changeEntity(anAttribute, anAttrType);
 510
 511     anAttribute = aData->attribute(SketchPlugin_Arc::END_ID());
 512     if (!isInitialized(anAttribute)) return SLVS_E_UNKNOWN;
 513     Slvs_hEntity aEnd = changeEntity(anAttribute, anAttrType);
 514
 515     if (aCurrentEntity.h == SLVS_E_UNKNOWN) { // New entity
 516       Slvs_Entity aWorkplane = myStorage->getEntity(aWorkplaneID);
 517       aCurrentEntity = Slvs_MakeArcOfCircle(SLVS_E_UNKNOWN, aGroupID, aWorkplaneID,
 518                                             aWorkplane.normal, aCenter, aStart, aEnd);
 519     } else {
 520       aCurrentEntity.point[0] = aCenter;
 521       aCurrentEntity.point[1] = aStart;
 522       aCurrentEntity.point[2] = aEnd;
 523     }
 524     aResult = myStorage->addEntity(aCurrentEntity);
 525   }
 526   // Point (it has low probability to be an attribute of constraint, so it is checked at the end)
 527   else if (aFeatureKind == SketchPlugin_Point::ID()) {
 528     anAttribute = aData->attribute(SketchPlugin_Point::COORD_ID());
 529     if (!isInitialized(anAttribute)) return SLVS_E_UNKNOWN;
 530     // Both the sketch point and its attribute (coordinates) link to the same SolveSpace point identifier
 531     aResult = changeEntity(anAttribute, anAttrType);
 532     aCurrentEntity.type = SLVS_E_POINT_IN_3D;
 533   }
 534
 535   if (aResult != SLVS_E_UNKNOWN) {
 536     myFeatureMap[theEntity] = aResult;
 537     theType = aCurrentEntity.type;
 538   }
 539   return aResult;
 540 }
 541
 542 std::list<ConstraintPtr> SketchSolver_Constraint::constraints() const
 543 {
 544   std::list<ConstraintPtr> aConstraints;
 545   aConstraints.push_back(myBaseConstraint);
 546   return aConstraints;
 547 }
 548
 549 void SketchSolver_Constraint::refresh()
 550 {
 551   cleanErrorMsg();
 552   std::map<AttributePtr, Slvs_hEntity>::iterator anAttrIter = myAttributeMap.begin();
 553   for (; anAttrIter != myAttributeMap.end(); anAttrIter++) {
 554     std::shared_ptr<GeomDataAPI_Point> aPoint =
 555         std::dynamic_pointer_cast<GeomDataAPI_Point>(anAttrIter->first);
 556     if (aPoint) {
 557       Slvs_Entity anEntity = myStorage->getEntity(anAttrIter->second);
 558       double aXYZ[3];
 559       for (int i = 0; i < 3; i++) {
 560         Slvs_Param aPar = myStorage->getParameter(anEntity.param[i]);
 561         aXYZ[i] = aPar.val;
 562       }
 563       if (fabs(aPoint->x() - aXYZ[0]) > tolerance ||
 564           fabs(aPoint->y() - aXYZ[1]) > tolerance ||
 565           fabs(aPoint->z() - aXYZ[2]) > tolerance)
 566         aPoint->setValue(aXYZ[0], aXYZ[1], aXYZ[2]);
 567     } else {
 568       // Point in 2D
 569       std::shared_ptr<GeomDataAPI_Point2D> aPoint2D =
 570           std::dynamic_pointer_cast<GeomDataAPI_Point2D>(anAttrIter->first);
 571       if (aPoint2D) {
 572         Slvs_Entity anEntity = myStorage->getEntity(anAttrIter->second);
 573         double aXY[2];
 574         for (int i = 0; i < 2; i++) {
 575           Slvs_Param aPar = myStorage->getParameter(anEntity.param[i]);
 576           aXY[i] = aPar.val;
 577         }
 578         if (fabs(aPoint2D->x() - aXY[0]) > tolerance ||
 579             fabs(aPoint2D->y() - aXY[1]) > tolerance)
 580           aPoint2D->setValue(aXY[0], aXY[1]);
 581       } else {
 582         // Scalar value (used for the distance entities)
 583         AttributeDoublePtr aScalar =
 584             std::dynamic_pointer_cast<ModelAPI_AttributeDouble>(anAttrIter->first);
 585         if (aScalar) {
 586           Slvs_Entity anEntity = myStorage->getEntity(anAttrIter->second);
 587           Slvs_Param aPar = myStorage->getParameter(anEntity.param[0]);
 588           if (fabs(aScalar->value() - aPar.val) > tolerance)
 589             aScalar->setValue(aPar.val);
 590         }
 591       }
 592     }
 593   }
 594
 595   std::map<AttributePtr, Slvs_hParam>::iterator aValIter = myValueMap.begin();
 596   for (; aValIter != myValueMap.end(); aValIter++) {
 597     AttributeDoublePtr aScalar =
 598         std::dynamic_pointer_cast<ModelAPI_AttributeDouble>(anAttrIter->first);
 599     if (aScalar) {
 600       Slvs_Param aPar = myStorage->getParameter(anAttrIter->second);
 601       aScalar->setValue(aPar.val);
 602     }
 603   }
 604 }
 605
 606 Slvs_hEntity SketchSolver_Constraint::getId(FeaturePtr theFeature) const
 607 {
 608   std::map<FeaturePtr, Slvs_hEntity>::const_iterator aFIter = myFeatureMap.find(theFeature);
 609   if (aFIter == myFeatureMap.end())
 610     return SLVS_E_UNKNOWN;
 611   // check the Feature is really in the storage
 612   Slvs_Entity anEntity = myStorage->getEntity(aFIter->second);
 613   if (anEntity.h == SLVS_E_UNKNOWN) {
 614     // rebuild feature
 615     int aType;
 616     anEntity.h = const_cast<SketchSolver_Constraint*>(this)->changeEntity(aFIter->first, aType);
 617     const_cast<SketchSolver_Constraint*>(this)->myFeatureMap[theFeature] = anEntity.h;
 618   }
 619   return anEntity.h;
 620 }
 621
 622 Slvs_hEntity SketchSolver_Constraint::getId(AttributePtr theAttribute) const
 623 {
 624   std::map<AttributePtr, Slvs_hEntity>::const_iterator anAttrIter = myAttributeMap.find(theAttribute);
 625   if (anAttrIter == myAttributeMap.end())
 626     return SLVS_E_UNKNOWN;
 627   return anAttrIter->second;
 628 }
 629
 630 bool SketchSolver_Constraint::isInitialized(AttributePtr theAttribute)
 631 {
 632   if (theAttribute->isInitialized())
 633     return true;
 634   myErrorMsg = SketchSolver_Error::NOT_INITIALIZED();
 635   return false;
 636 }
 637
 638
 639 void SketchSolver_Constraint::calculateMiddlePoint(
 640     const Slvs_Entity& theEntity, double theCoeff, double& theX, double& theY) const
 641 {
 642   if (theEntity.type == SLVS_E_LINE_SEGMENT) {
 643     double aStartEndXY[2][2];
 644     Slvs_Entity aPoint;
 645     for (int i = 0; i < 2; i++) {
 646       aPoint = myStorage->getEntity(theEntity.point[i]);
 647       for (int j = 0; j < 2; j++)
 648         aStartEndXY[i][j] = myStorage->getParameter(aPoint.param[j]).val;
 649     }
 650     theX = (1.0 - theCoeff) * aStartEndXY[0][0] + theCoeff * aStartEndXY[1][0];
 651     theY = (1.0 - theCoeff) * aStartEndXY[0][1] + theCoeff * aStartEndXY[1][1];
 652   } else if (theEntity.type == SLVS_E_ARC_OF_CIRCLE) {
 653     double anArcPoint[3][2];
 654     Slvs_Entity aPoint;
 655     for (int i = 0; i < 3; i++) {
 656       aPoint = myStorage->getEntity(theEntity.point[i]);
 657       for (int j = 0; j < 2; j++)
 658         anArcPoint[i][j] = myStorage->getParameter(aPoint.param[j]).val;
 659     }
 660     // project last point of arc on the arc
 661     double x = anArcPoint[1][0] - anArcPoint[0][0];
 662     double y = anArcPoint[1][1] - anArcPoint[0][1];
 663     double aRad = sqrt(x*x + y*y);
 664     x = anArcPoint[2][0] - anArcPoint[0][0];
 665     y = anArcPoint[2][1] - anArcPoint[0][1];
 666     double aNorm = sqrt(x*x + y*y);
 667     if (aNorm >= tolerance) {
 668       anArcPoint[2][0] = x * aRad / aNorm;
 669       anArcPoint[2][1] = y * aRad / aNorm;
 670     }
 671     anArcPoint[1][0] -= anArcPoint[0][0];
 672     anArcPoint[1][1] -= anArcPoint[0][1];
 673     if (theCoeff < tolerance) {
 674       theX = anArcPoint[0][0] + anArcPoint[1][0];
 675       theY = anArcPoint[0][1] + anArcPoint[1][1];
 676       return;
 677     } else if (1 - theCoeff < tolerance) {
 678       theX = anArcPoint[0][0] + anArcPoint[2][0];
 679       theY = anArcPoint[0][1] + anArcPoint[2][1];
 680       return;
 681     }
 682
 683     std::shared_ptr<GeomAPI_Dir2d> aStartDir(new GeomAPI_Dir2d(anArcPoint[1][0], anArcPoint[1][1]));
 684     std::shared_ptr<GeomAPI_Dir2d> aEndDir(new GeomAPI_Dir2d(anArcPoint[2][0], anArcPoint[2][1]));
 685     double anAngle = aStartDir->angle(aEndDir);
 686     if (anAngle < 0)
 687       anAngle += 2.0 * PI;
 688     anAngle *= theCoeff;
 689     double aCos = cos(anAngle);
 690     double aSin = sin(anAngle);
 691     theX = anArcPoint[0][0] + anArcPoint[1][0] * aCos - anArcPoint[1][1] * aSin;
 692     theY = anArcPoint[0][1] + anArcPoint[1][0] * aSin + anArcPoint[1][1] * aCos;
 693   }
 694 }
 695
 696 void SketchSolver_Constraint::makeTemporary() const
 697 {
 698   std::vector<Slvs_hConstraint>::const_iterator anIt = mySlvsConstraints.begin();
 699   for (; anIt != mySlvsConstraints.end(); anIt++)
 700     myStorage->addTemporaryConstraint(*anIt);
 701 }
 702