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) {
 144           if (aFIt == myFeatureMap.end())
 145             return true;
 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())
 153                 isFound = true;
 154             if (!isFound)
 155               return true;
 156           }
 157         }
 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())
 161           return true;
 162       }
 163     }
 164     AttributeRefListPtr aRefList =
 165         std::dynamic_pointer_cast<ModelAPI_AttributeRefList>(*anAttrIter);
 166     if (aRefList) {
 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())
 172           return true;
 173       }
 174     }
 175   }
 176   return false;
 177 }
 178
 179 void SketchSolver_Constraint::update(ConstraintPtr theConstraint)
 180 {
 181   cleanErrorMsg();
 182   bool needToRebuild = (theConstraint && theConstraint != myBaseConstraint);
 183   if (!needToRebuild)
 184     needToRebuild = checkAttributesChanged(theConstraint);
 185   if (needToRebuild) {
 186     if (theConstraint && theConstraint->getKind() != myBaseConstraint->getKind())
 187       return;
 188     remove(myBaseConstraint);
 189     if (theConstraint)
 190       myBaseConstraint = theConstraint;
 191     process();
 192     return;
 193   }
 194
 195   // Update all attributes
 196   int aType;
 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;
 204   }
 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;
 211   }
 212
 213   // Value if exists
 214   DataPtr aData = myBaseConstraint->data();
 215   if (!aData) return;
 216   AttributeDoublePtr aValueAttr = std::dynamic_pointer_cast<ModelAPI_AttributeDouble>(
 217     myBaseConstraint->attribute(SketchPlugin_Constraint::VALUE()));
 218   double aValue = aValueAttr ? aValueAttr->value() : 0.0;
 219
 220   // Update constraint
 221   std::vector<Slvs_hConstraint>::iterator aCIter = mySlvsConstraints.begin();
 222   for (; aCIter != mySlvsConstraints.end(); aCIter++) {
 223     Slvs_Constraint aConstraint = myStorage->getConstraint(*aCIter);
 224     if (aValueAttr) {
 225       aConstraint.valA = aValue;
 226       if (aConstraint.type == SLVS_C_DIAMETER)
 227         aConstraint.valA *= 2.0;
 228     }
 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)
 235         continue;
 236       std::map<Slvs_hEntity, Slvs_hEntity>::iterator aFound = aRelocationMap.find(*(aCoeffs[i]));
 237       if (aFound != aRelocationMap.end())
 238         *(aCoeffs[i]) = aFound->second;
 239     }
 240     *aCIter = myStorage->addConstraint(aConstraint);
 241   }
 242   adjustConstraint();
 243 }
 244
 245 bool SketchSolver_Constraint::remove(ConstraintPtr theConstraint)
 246 {
 247   cleanErrorMsg();
 248   if (theConstraint && theConstraint != myBaseConstraint)
 249     return false;
 250   if (mySlvsConstraints.empty())
 251     return true;
 252   bool isFullyRemoved = myStorage->removeConstraint(mySlvsConstraints.front());
 253   if (isFullyRemoved) {
 254     myFeatureMap.clear();
 255     myAttributeMap.clear();
 256     myValueMap.clear();
 257   } else
 258     cleanRemovedEntities();
 259   mySlvsConstraints.clear();
 260   return true;
 261 }
 262
 263 void SketchSolver_Constraint::cleanRemovedEntities()
 264 {
 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()) {
 272       aFeatIt++;
 273       continue;
 274     }
 275     std::map<FeaturePtr, Slvs_hEntity>::iterator aTmpIter = aFeatIt++;
 276     myFeatureMap.erase(aTmpIter);
 277   }
 278   std::map<AttributePtr, Slvs_hEntity>::iterator anAttrIt = myAttributeMap.begin();
 279   while (anAttrIt != myAttributeMap.end()) {
 280     if (aRemovedEntities.find(anAttrIt->second) == aRemovedEntities.end()) {
 281       anAttrIt++;
 282       continue;
 283     }
 284     std::map<AttributePtr, Slvs_hEntity>::iterator aTmpIter = anAttrIt++;
 285     myAttributeMap.erase(aTmpIter);
 286   }
 287   std::map<AttributePtr, Slvs_hParam>::iterator aValIt = myValueMap.begin();
 288   while (aValIt != myValueMap.end()) {
 289     if (aRemovedParams.find(aValIt->second) == aRemovedParams.end()) {
 290       aValIt++;
 291       continue;
 292     }
 293     std::map<AttributePtr, Slvs_hParam>::iterator aTmpIter = aValIt++;
 294     myValueMap.erase(aTmpIter);
 295   }
 296   for (size_t i = 0; i < mySlvsConstraints.size(); i++)
 297     if (aRemovedConstraints.find(mySlvsConstraints[i]) != aRemovedConstraints.end()) {
 298       mySlvsConstraints.erase(mySlvsConstraints.begin() + i);
 299       i--;
 300     }
 301 }
 302
 303 void SketchSolver_Constraint::getAttributes(
 304     double& theValue,
 305     std::vector<Slvs_hEntity>& theAttributes)
 306 {
 307   static const int anInitNbOfAttr = 4;
 308   theAttributes.assign(anInitNbOfAttr, SLVS_E_UNKNOWN);
 309
 310   DataPtr aData = myBaseConstraint->data();
 311
 312   AttributeDoublePtr aValueAttr = std::dynamic_pointer_cast<ModelAPI_AttributeDouble>(
 313     aData->attribute(SketchPlugin_Constraint::VALUE()));
 314   theValue = aValueAttr ? aValueAttr->value() : 0.0;
 315
 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();
 325       return;
 326     }
 327
 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);
 332     else {
 333       Slvs_Entity anEnt = myStorage->getEntity(anEntity);
 334       aType = anEnt.type;
 335     }
 336
 337     if (aType == SLVS_E_UNKNOWN)
 338       continue;
 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;
 344       else
 345         theAttributes.push_back(anEntity);
 346       aEntInd++;
 347     }
 348   }
 349 }
 350
 351 Slvs_hEntity SketchSolver_Constraint::changeEntity(AttributeRefAttrPtr theAttribute, int& theType)
 352 {
 353   // Convert the object of the attribute to the feature
 354   FeaturePtr aFeature;
 355   if (theAttribute->isObject() && theAttribute->object()) {
 356     ResultConstructionPtr aRC = std::dynamic_pointer_cast<ModelAPI_ResultConstruction>(
 357         theAttribute->object());
 358     if (!aRC) {
 359       myErrorMsg = SketchSolver_Error::NOT_INITIALIZED();
 360       return SLVS_E_UNKNOWN;
 361     }
 362     std::shared_ptr<ModelAPI_Document> aDoc = aRC->document();
 363     aFeature = aDoc->feature(aRC);
 364
 365     return changeEntity(aFeature, theType);
 366   }
 367
 368   return changeEntity(theAttribute->attr(), theType);
 369 }
 370
 371 Slvs_hEntity SketchSolver_Constraint::changeEntity(AttributePtr theEntity, int& theType)
 372 {
 373   Slvs_hEntity aResult = SLVS_E_UNKNOWN;
 374   if (!theEntity || !isInitialized(theEntity)) {
 375     myErrorMsg = SketchSolver_Error::NOT_INITIALIZED();
 376     return SLVS_E_UNKNOWN;
 377   }
 378
 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);
 386   else {
 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;
 392       return aResult;
 393     }
 394   }
 395
 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;
 400
 401   // Point in 3D
 402   std::shared_ptr<GeomDataAPI_Point> aPoint =
 403       std::dynamic_pointer_cast<GeomDataAPI_Point>(theEntity);
 404   if (aPoint) {
 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);
 411       aPar.val = aXYZ[i];
 412       aParams[i] = myStorage->addParameter(aPar);
 413     }
 414
 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];
 420     }
 421     aResult = myStorage->addEntity(aCurrentEntity);
 422   } else {
 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;
 427
 428     // Point in 2D
 429     std::shared_ptr<GeomDataAPI_Point2D> aPoint2D =
 430         std::dynamic_pointer_cast<GeomDataAPI_Point2D>(theEntity);
 431     if (aPoint2D) {
 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);
 438         aPar.val = aXY[i];
 439         aParams[i] = myStorage->addParameter(aPar);
 440       }
 441
 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];
 447       }
 448       aResult = myStorage->addEntity(aCurrentEntity);
 449     } else {
 450       // Scalar value (used for the distance entities)
 451       AttributeDoublePtr aScalar = std::dynamic_pointer_cast<ModelAPI_AttributeDouble>(theEntity);
 452       if (aScalar) {
 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);
 458
 459         if (aCurrentEntity.h == SLVS_E_UNKNOWN) // New entity
 460           aCurrentEntity = Slvs_MakeDistance(SLVS_E_UNKNOWN, aGroupID, aWorkplaneID, aValue);
 461         else
 462           aCurrentEntity.param[0] = aValue;
 463         aResult = myStorage->addEntity(aCurrentEntity);
 464       }
 465     }
 466   }
 467
 468   myAttributeMap[theEntity] = aResult;
 469   theType = aCurrentEntity.type;
 470   return aResult;
 471 }
 472
 473 Slvs_hEntity SketchSolver_Constraint::changeEntity(FeaturePtr theEntity, int& theType)
 474 {
 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);
 484   else {
 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;
 490       return aResult;
 491     }
 492   }
 493
 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;
 498
 499   Slvs_hEntity aWorkplaneID = myGroup->getWorkplaneId();
 500   DataPtr aData = theEntity->data();
 501
 502   // SketchPlugin features
 503   const std::string& aFeatureKind = theEntity->getKind();
 504   AttributePtr anAttribute;
 505   int anAttrType;
 506   // Line
 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);
 511
 512     anAttribute = aData->attribute(SketchPlugin_Line::END_ID());
 513     if (!isInitialized(anAttribute)) return SLVS_E_UNKNOWN;
 514     Slvs_hEntity aEnd = changeEntity(anAttribute, anAttrType);
 515
 516     if (aCurrentEntity.h == SLVS_E_UNKNOWN) // New entity
 517       aCurrentEntity = Slvs_MakeLineSegment(SLVS_E_UNKNOWN, aGroupID, aWorkplaneID, aStart, aEnd);
 518     else {
 519       aCurrentEntity.point[0] = aStart;
 520       aCurrentEntity.point[1] = aEnd;
 521     }
 522     aResult = myStorage->addEntity(aCurrentEntity);
 523   }
 524   // Circle
 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);
 529
 530     anAttribute = aData->attribute(SketchPlugin_Circle::RADIUS_ID());
 531     if (!isInitialized(anAttribute)) return SLVS_E_UNKNOWN;
 532     Slvs_hEntity aRadius = changeEntity(anAttribute, anAttrType);
 533
 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);
 538     } else {
 539       aCurrentEntity.point[0] = aCenter;
 540       aCurrentEntity.distance = aRadius;
 541     }
 542     aResult = myStorage->addEntity(aCurrentEntity);
 543   }
 544   // Arc
 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);
 549
 550     anAttribute = aData->attribute(SketchPlugin_Arc::START_ID());
 551     if (!isInitialized(anAttribute)) return SLVS_E_UNKNOWN;
 552     Slvs_hEntity aStart = changeEntity(anAttribute, anAttrType);
 553
 554     anAttribute = aData->attribute(SketchPlugin_Arc::END_ID());
 555     if (!isInitialized(anAttribute)) return SLVS_E_UNKNOWN;
 556     Slvs_hEntity aEnd = changeEntity(anAttribute, anAttrType);
 557
 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);
 562     } else {
 563       aCurrentEntity.point[0] = aCenter;
 564       aCurrentEntity.point[1] = aStart;
 565       aCurrentEntity.point[2] = aEnd;
 566     }
 567     aResult = myStorage->addEntity(aCurrentEntity);
 568   }
 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;
 576   }
 577
 578   if (aResult != SLVS_E_UNKNOWN) {
 579     myFeatureMap[theEntity] = aResult;
 580     theType = aCurrentEntity.type;
 581   }
 582   return aResult;
 583 }
 584
 585 std::list<ConstraintPtr> SketchSolver_Constraint::constraints() const
 586 {
 587   std::list<ConstraintPtr> aConstraints;
 588   aConstraints.push_back(myBaseConstraint);
 589   return aConstraints;
 590 }
 591
 592 void SketchSolver_Constraint::refresh()
 593 {
 594   cleanErrorMsg();
 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);
 603       continue;
 604     }
 605     if (aPoint) {
 606       double aXYZ[3];
 607       for (int i = 0; i < 3; i++) {
 608         Slvs_Param aPar = myStorage->getParameter(anEntity.param[i]);
 609         aXYZ[i] = aPar.val;
 610       }
 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]);
 615     } else {
 616       // Point in 2D
 617       std::shared_ptr<GeomDataAPI_Point2D> aPoint2D =
 618           std::dynamic_pointer_cast<GeomDataAPI_Point2D>(anAttrIter->first);
 619       if (aPoint2D) {
 620         double aXY[2];
 621         for (int i = 0; i < 2; i++) {
 622           Slvs_Param aPar = myStorage->getParameter(anEntity.param[i]);
 623           aXY[i] = aPar.val;
 624         }
 625         if (fabs(aPoint2D->x() - aXY[0]) > tolerance ||
 626             fabs(aPoint2D->y() - aXY[1]) > tolerance)
 627           aPoint2D->setValue(aXY[0], aXY[1]);
 628       } else {
 629         // Scalar value (used for the distance entities)
 630         AttributeDoublePtr aScalar =
 631             std::dynamic_pointer_cast<ModelAPI_AttributeDouble>(anAttrIter->first);
 632         if (aScalar) {
 633           Slvs_Param aPar = myStorage->getParameter(anEntity.param[0]);
 634           if (fabs(aScalar->value() - aPar.val) > tolerance)
 635             aScalar->setValue(aPar.val);
 636         }
 637       }
 638     }
 639     anAttrIter++;
 640   }
 641
 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);
 646     if (aScalar) {
 647       Slvs_Param aPar = myStorage->getParameter(anAttrIter->second);
 648       aScalar->setValue(aPar.val);
 649     }
 650   }
 651 }
 652
 653 Slvs_hEntity SketchSolver_Constraint::getId(FeaturePtr theFeature) const
 654 {
 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
 662   //  int aType;
 663   //  anEntity.h = const_cast<SketchSolver_Constraint*>(this)->changeEntity(aFIter->first, aType);
 664   //  const_cast<SketchSolver_Constraint*>(this)->myFeatureMap[theFeature] = anEntity.h;
 665   //}
 666   //return anEntity.h;
 667   return aFIter->second;
 668 }
 669
 670 Slvs_hEntity SketchSolver_Constraint::getId(AttributePtr theAttribute) const
 671 {
 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;
 676 }
 677
 678 bool SketchSolver_Constraint::isInitialized(AttributePtr theAttribute)
 679 {
 680   if (theAttribute->isInitialized())
 681     return true;
 682   myErrorMsg = SketchSolver_Error::NOT_INITIALIZED();
 683   return false;
 684 }
 685
 686
 687 void SketchSolver_Constraint::calculateMiddlePoint(
 688     const Slvs_Entity& theEntity, double theCoeff, double& theX, double& theY) const
 689 {
 690   if (theEntity.type == SLVS_E_LINE_SEGMENT) {
 691     double aStartEndXY[2][2];
 692     Slvs_Entity aPoint;
 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;
 697     }
 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];
 702     Slvs_Entity aPoint;
 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;
 707     }
 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;
 718     }
 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];
 724       return;
 725     } else if (1 - theCoeff < tolerance) {
 726       theX = anArcPoint[0][0] + anArcPoint[2][0];
 727       theY = anArcPoint[0][1] + anArcPoint[2][1];
 728       return;
 729     }
 730
 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);
 734     if (anAngle < 0)
 735       anAngle += 2.0 * PI;
 736     anAngle *= theCoeff;
 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;
 741   }
 742 }
 743
 744 void SketchSolver_Constraint::makeTemporary() const
 745 {
 746   std::vector<Slvs_hConstraint>::const_iterator anIt = mySlvsConstraints.begin();
 747   for (; anIt != mySlvsConstraints.end(); anIt++)
 748     myStorage->addTemporaryConstraint(*anIt);
 749 }
 750