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