src/SketchSolver/PlaneGCSSolver/PlaneGCSSolver_Storage.cpp

   1 // Copyright (C) 2014-20xx CEA/DEN, EDF R&D
   2
   3 // File:    PlaneGCSSolver_Storage.cpp
   4 // Created: 14 Dec 2015
   5 // Author:  Artem ZHIDKOV
   6
   7 #include <PlaneGCSSolver_Storage.h>
   8 #include <PlaneGCSSolver_Builder.h>
   9 #include <PlaneGCSSolver_Solver.h>
  10 #include <PlaneGCSSolver_ConstraintWrapper.h>
  11 #include <PlaneGCSSolver_EntityWrapper.h>
  12 #include <PlaneGCSSolver_PointWrapper.h>
  13 #include <PlaneGCSSolver_ScalarWrapper.h>
  14 #include <PlaneGCSSolver_ParameterWrapper.h>
  15
  16 #include <GeomAPI_Edge.h>
  17 #include <GeomAPI_Dir2d.h>
  18 #include <GeomAPI_Pnt2d.h>
  19 #include <GeomAPI_XY.h>
  20 #include <GeomDataAPI_Point2D.h>
  21 #include <SketchPlugin_Arc.h>
  22 #include <SketchPlugin_ConstraintTangent.h>
  23
  24 #include <cmath>
  25
  26
  27 PlaneGCSSolver_Storage::PlaneGCSSolver_Storage(const GroupID& theGroup)
  28   : SketchSolver_Storage(theGroup),
  29     myEntityLastID(EID_SKETCH),
  30     myConstraintLastID(CID_UNKNOWN)
  31 {
  32 }
  33
  34 void PlaneGCSSolver_Storage::addConstraint(
  35     ConstraintPtr                   theConstraint,
  36     std::list<ConstraintWrapperPtr> theSolverConstraints)
  37 {
  38   SketchSolver_Storage::addConstraint(theConstraint, theSolverConstraints);
  39
  40   // update point-point coincidence
  41   if (!theSolverConstraints.empty() &&
  42       theSolverConstraints.front()->type() == CONSTRAINT_PT_PT_COINCIDENT) {
  43     std::list<ConstraintWrapperPtr>::iterator aCIt = theSolverConstraints.begin();
  44     for (; aCIt != theSolverConstraints.end(); ++aCIt)
  45       update(*aCIt);
  46   }
  47 }
  48
  49
  50 bool PlaneGCSSolver_Storage::update(ConstraintWrapperPtr theConstraint)
  51 {
  52   bool isUpdated = false;
  53   std::shared_ptr<PlaneGCSSolver_ConstraintWrapper> aConstraint =
  54       std::dynamic_pointer_cast<PlaneGCSSolver_ConstraintWrapper>(theConstraint);
  55
  56   // point-Line distance should be positive
  57   if (aConstraint->type() == CONSTRAINT_PT_LINE_DISTANCE && aConstraint->value() < 0.0)
  58     aConstraint->setValue(-aConstraint->value());
  59
  60   // make value of constraint unchangeable
  61   ParameterWrapperPtr aValue = aConstraint->valueParameter();
  62   if (aValue)
  63     isUpdated = update(aValue) || isUpdated;
  64
  65   // update constrained entities
  66   std::list<EntityWrapperPtr> anEntities = theConstraint->entities();
  67   std::list<EntityWrapperPtr>::iterator anIt = anEntities.begin();
  68   for (; anIt != anEntities.end(); ++anIt)
  69     isUpdated = update(*anIt) || isUpdated;
  70
  71   if (aConstraint->id() == CID_UNKNOWN) {
  72     const std::list<EntityWrapperPtr>& aSubs = aConstraint->entities();
  73     // check middle-point constraint conflicts with point-on-line
  74     if (aConstraint->type() == CONSTRAINT_MIDDLE_POINT) {
  75       std::map<ConstraintPtr, std::list<ConstraintWrapperPtr> >::const_iterator
  76           anIt = myConstraintMap.begin();
  77       for (; anIt != myConstraintMap.end(); ++anIt) {
  78         EntityWrapperPtr aPoint, aLine;
  79         ConstraintWrapperPtr aCurrentConstr = anIt->second.front();
  80         if (aCurrentConstr->type() != CONSTRAINT_PT_ON_LINE)
  81           continue;
  82         const std::list<EntityWrapperPtr>& aCurSubs = aCurrentConstr->entities();
  83         std::list<EntityWrapperPtr>::const_iterator aSIt1, aSIt2;
  84         for (aSIt1 = aSubs.begin(); aSIt1 != aSubs.end(); ++aSIt1) {
  85           if ((*aSIt1)->type() == ENTITY_POINT)
  86             aPoint = *aSIt1;
  87           else if((*aSIt1)->type() == ENTITY_LINE)
  88             aLine = *aSIt1;
  89           else
  90             continue;
  91           for (aSIt2 = aCurSubs.begin(); aSIt2 != aCurSubs.end(); ++aSIt2)
  92             if ((*aSIt1)->id() == (*aSIt2)->id())
  93               break;
  94           if (aSIt2 == aCurSubs.end())
  95             break;
  96         }
  97         // point-on-line found, change it to bisector
  98         if (aSIt1 == aSubs.end()) {
  99           std::list<GCSConstraintPtr> aConstrList = aConstraint->constraints();
 100           aConstrList.pop_front();
 101           aConstraint->setConstraints(aConstrList);
 102           break;
 103         }
 104       }
 105     }
 106
 107     // Change ID of constraints
 108     aConstraint->setId(++myConstraintLastID);
 109   }
 110
 111   return isUpdated;
 112 }
 113
 114 /// \brief Update coordinates of the point or scalar using its base attribute
 115 static bool updateValues(EntityWrapperPtr& theEntity)
 116 {
 117   bool isUpdated = false;
 118   AttributePtr anAttr = theEntity->baseAttribute();
 119   const std::list<ParameterWrapperPtr> aParams = theEntity->parameters();
 120
 121   double aCoord[2];
 122
 123   std::shared_ptr<GeomDataAPI_Point2D> aPoint2D =
 124       std::dynamic_pointer_cast<GeomDataAPI_Point2D>(anAttr);
 125   if (aPoint2D) {
 126     aCoord[0] = aPoint2D->x();
 127     aCoord[1] = aPoint2D->y();
 128   } else {
 129     AttributeDoublePtr aScalar = std::dynamic_pointer_cast<ModelAPI_AttributeDouble>(anAttr);
 130     if (aScalar)
 131       aCoord[0] = aScalar->value();
 132   }
 133
 134   std::list<ParameterWrapperPtr>::const_iterator anIt = aParams.begin();
 135   for (int i = 0; anIt != aParams.end(); ++anIt, ++i)
 136     if (fabs((*anIt)->value() - aCoord[i]) > tolerance) {
 137       (*anIt)->setValue(aCoord[i]);
 138       isUpdated = true;
 139     }
 140   return isUpdated;
 141 }
 142
 143 bool PlaneGCSSolver_Storage::update(EntityWrapperPtr theEntity)
 144 {
 145   if (theEntity->type() == ENTITY_SKETCH)
 146     return true; // sketch is not necessary for PlaneGCS, so it is always says true
 147
 148   bool isUpdated = false;
 149
 150   if (theEntity->baseAttribute()) {
 151     isUpdated = updateValues(theEntity);
 152     if (isUpdated) {
 153       setNeedToResolve(true);
 154       if (theEntity->type() == ENTITY_POINT && theEntity->group() != myGroupID)
 155         updateCoincident(theEntity);
 156     }
 157   }
 158
 159   // update parameters
 160   std::list<ParameterWrapperPtr> aParams = theEntity->parameters();
 161   std::list<ParameterWrapperPtr>::iterator aPIt = aParams.begin();
 162   for (; aPIt != aParams.end(); ++aPIt)
 163     isUpdated = update(*aPIt) || isUpdated;
 164
 165   // update sub-entities
 166   std::list<EntityWrapperPtr> aSubEntities = theEntity->subEntities();
 167   std::list<EntityWrapperPtr>::iterator aSIt = aSubEntities.begin();
 168   for (; aSIt != aSubEntities.end(); ++aSIt)
 169     isUpdated = update(*aSIt) || isUpdated;
 170
 171   // additional constraints for the arc processing
 172   if (theEntity->type() == ENTITY_ARC)
 173     processArc(theEntity);
 174
 175   // Change entity's ID, if necessary
 176   if (theEntity->id() == EID_UNKNOWN) {
 177     if (theEntity->type() == ENTITY_POINT) {
 178       std::shared_ptr<PlaneGCSSolver_PointWrapper> aPoint =
 179           std::dynamic_pointer_cast<PlaneGCSSolver_PointWrapper>(theEntity);
 180       if (!aPoint) {
 181         aPoint = std::dynamic_pointer_cast<PlaneGCSSolver_PointWrapper>(
 182             theEntity->subEntities().front());
 183       }
 184       aPoint->setId(++myEntityLastID);
 185     } else if (theEntity->type() == ENTITY_SCALAR) {
 186       std::shared_ptr<PlaneGCSSolver_ScalarWrapper> aScalar =
 187           std::dynamic_pointer_cast<PlaneGCSSolver_ScalarWrapper>(theEntity);
 188       aScalar->setId(++myEntityLastID);
 189     } else {
 190       std::shared_ptr<PlaneGCSSolver_EntityWrapper> aGCSEnt =
 191           std::dynamic_pointer_cast<PlaneGCSSolver_EntityWrapper>(theEntity);
 192       aGCSEnt->setId(++myEntityLastID);
 193     }
 194   }
 195   return isUpdated;
 196 }
 197
 198 bool PlaneGCSSolver_Storage::update(ParameterWrapperPtr theParameter)
 199 {
 200   std::shared_ptr<PlaneGCSSolver_ParameterWrapper> aParam =
 201       std::dynamic_pointer_cast<PlaneGCSSolver_ParameterWrapper>(theParameter);
 202   if (aParam->isProcessed())
 203     return false;
 204   if (theParameter->group() != myGroupID || theParameter->isParametric())
 205     myConst.push_back(aParam->parameter());
 206   else
 207     myParameters.push_back(aParam->parameter());
 208   aParam->setProcessed(true);
 209   return true;
 210 }
 211
 212
 213 bool PlaneGCSSolver_Storage::remove(ConstraintWrapperPtr theConstraint)
 214 {
 215   std::shared_ptr<PlaneGCSSolver_ConstraintWrapper> aConstraint =
 216     std::dynamic_pointer_cast<PlaneGCSSolver_ConstraintWrapper>(theConstraint);
 217
 218   bool isFullyRemoved = true;
 219   // remove point-point coincidence
 220   if (aConstraint->type() == CONSTRAINT_PT_PT_COINCIDENT)
 221     isFullyRemoved = removeCoincidence(theConstraint) && isFullyRemoved;
 222   // remove sub-entities
 223   const std::list<EntityWrapperPtr>& aSubs = aConstraint->entities();
 224   std::list<EntityWrapperPtr>::const_iterator aSIt = aSubs.begin();
 225   for (; aSIt != aSubs.end(); ++ aSIt)
 226     isFullyRemoved = remove(*aSIt) && isFullyRemoved;
 227
 228   if (aConstraint->valueParameter())
 229     isFullyRemoved = remove(aConstraint->valueParameter()) && isFullyRemoved;
 230   if (!isFullyRemoved && aConstraint->baseConstraint() &&
 231      (!aConstraint->baseConstraint()->data() || !aConstraint->baseConstraint()->data()->isValid()))
 232     isFullyRemoved = true;
 233   setNeedToResolve(true);
 234   myRemovedConstraints.insert(myRemovedConstraints.end(),
 235       aConstraint->constraints().begin(), aConstraint->constraints().end());
 236
 237   if (isFullyRemoved && theConstraint->id() == myConstraintLastID)
 238     --myConstraintLastID;
 239
 240   return isFullyRemoved;
 241 }
 242
 243 bool PlaneGCSSolver_Storage::remove(EntityWrapperPtr theEntity)
 244 {
 245   // do not remove entity, if it is used by constraints or other entities
 246   if ((theEntity->baseFeature() && isUsed(theEntity->baseFeature())) ||
 247       (theEntity->baseAttribute() && isUsed(theEntity->baseAttribute())))
 248     return false;
 249
 250   bool isFullyRemoved = SketchSolver_Storage::remove(theEntity);
 251   if (isFullyRemoved) {
 252     if (theEntity->type() == ENTITY_ARC) {
 253       // remove arc additional constraints
 254       std::map<EntityWrapperPtr, std::vector<GCSConstraintPtr> >::iterator
 255           aFound = myArcConstraintMap.find(theEntity);
 256       if (aFound != myArcConstraintMap.end()) {
 257         myRemovedConstraints.insert(myRemovedConstraints.end(),
 258             aFound->second.begin(), aFound->second.end());
 259         myArcConstraintMap.erase(aFound);
 260       }
 261     }
 262     if (theEntity->id() == myEntityLastID)
 263       --myEntityLastID;
 264   }
 265   return isFullyRemoved;
 266 }
 267
 268 bool PlaneGCSSolver_Storage::remove(ParameterWrapperPtr theParameter)
 269 {
 270   std::shared_ptr<PlaneGCSSolver_ParameterWrapper> aParam =
 271       std::dynamic_pointer_cast<PlaneGCSSolver_ParameterWrapper>(theParameter);
 272   if (aParam->isProcessed()) {
 273     double* aValPtr = aParam->parameter();
 274     GCS::VEC_pD::iterator anIt =  myParameters.begin();
 275     for (; anIt != myParameters.end(); ++anIt)
 276       if (*anIt == aValPtr)
 277         break;
 278     if (anIt != myParameters.end()) {
 279       myParameters.erase(anIt);
 280       setNeedToResolve(true);
 281       aParam->setProcessed(false);
 282     }
 283     else {
 284       for (anIt = myConst.begin(); anIt != myConst.end(); ++anIt)
 285         if (*anIt == aValPtr)
 286           break;
 287       if (anIt != myConst.end()) {
 288         myConst.erase(anIt);
 289         setNeedToResolve(true);
 290         aParam->setProcessed(false);
 291       }
 292     }
 293   }
 294   return true;
 295 }
 296
 297
 298 void PlaneGCSSolver_Storage::addCoincidentPoints(
 299     EntityWrapperPtr theMaster, EntityWrapperPtr theSlave)
 300 {
 301   if (theMaster->type() != ENTITY_POINT || theSlave->type() != ENTITY_POINT)
 302     return;
 303
 304   std::shared_ptr<PlaneGCSSolver_PointWrapper> aMaster =
 305       std::dynamic_pointer_cast<PlaneGCSSolver_PointWrapper>(theMaster);
 306   if (!aMaster)
 307     aMaster = std::dynamic_pointer_cast<PlaneGCSSolver_PointWrapper>(
 308       std::dynamic_pointer_cast<PlaneGCSSolver_EntityWrapper>(theMaster)->subEntities().front());
 309   std::shared_ptr<PlaneGCSSolver_PointWrapper> aSlave =
 310       std::dynamic_pointer_cast<PlaneGCSSolver_PointWrapper>(theSlave);
 311   if (!aSlave)
 312     aSlave = std::dynamic_pointer_cast<PlaneGCSSolver_PointWrapper>(
 313       std::dynamic_pointer_cast<PlaneGCSSolver_EntityWrapper>(theSlave)->subEntities().front());
 314
 315   // Search available coincidence
 316   CoincidentPointsMap::iterator aMasterFound = myCoincidentPoints.find(aMaster);
 317   CoincidentPointsMap::iterator aSlaveFound = myCoincidentPoints.find(aSlave);
 318   if (aMasterFound == myCoincidentPoints.end() &&  aSlaveFound == myCoincidentPoints.end()) {
 319     // try to find master and slave points in the lists of slaves of already existent coincidences
 320     CoincidentPointsMap::iterator anIt = myCoincidentPoints.begin();
 321     for (; anIt != myCoincidentPoints.end(); ++anIt) {
 322       if (anIt->second.find(aMaster) != anIt->second.end())
 323         aMasterFound = anIt;
 324       else if (anIt->second.find(aSlave) != anIt->second.end())
 325         aSlaveFound = anIt;
 326
 327       if (aMasterFound != myCoincidentPoints.end() &&  aSlaveFound != myCoincidentPoints.end())
 328         break;
 329     }
 330   }
 331
 332   if (aMasterFound == myCoincidentPoints.end()) {
 333     // create new group
 334     myCoincidentPoints[aMaster] = std::set<EntityWrapperPtr>();
 335     aMasterFound = myCoincidentPoints.find(aMaster);
 336   } else if (aMasterFound == aSlaveFound)
 337     return; // already coincident
 338
 339   if (aSlaveFound != myCoincidentPoints.end()) {
 340     // A slave has been found, we need to attach all points coincident with it to the new master
 341     std::set<EntityWrapperPtr> aNewSlaves = aSlaveFound->second;
 342     aNewSlaves.insert(aSlaveFound->first);
 343     myCoincidentPoints.erase(aSlaveFound);
 344
 345     std::set<EntityWrapperPtr>::const_iterator aSlIt = aNewSlaves.begin();
 346     for (; aSlIt != aNewSlaves.end(); ++aSlIt)
 347       addCoincidentPoints(aMaster, *aSlIt);
 348   } else {
 349     //std::list<ParameterWrapperPtr> aSlaveParams = aSlave->parameters();
 350     //aSlave->setParameters(aMaster->parameters());
 351
 352     //// Remove slave's parameters
 353     //std::list<ParameterWrapperPtr>::iterator aParIt = aSlaveParams.begin();
 354     //for (; aParIt != aSlaveParams.end(); ++aParIt)
 355     //  remove(*aParIt);
 356
 357     aMasterFound->second.insert(aSlave);
 358   }
 359 }
 360
 361
 362 void PlaneGCSSolver_Storage::changeGroup(EntityWrapperPtr theEntity, const GroupID& theGroup)
 363 {
 364   theEntity->setGroup(theGroup);
 365   if (theGroup == myGroupID)
 366     makeVariable(theEntity);
 367   else {
 368     if (theEntity->type() == ENTITY_POINT)
 369       update(theEntity);
 370     makeConstant(theEntity);
 371   }
 372 }
 373
 374 void PlaneGCSSolver_Storage::changeGroup(ParameterWrapperPtr theParam, const GroupID& theGroup)
 375 {
 376   // TODO
 377 }
 378
 379 void PlaneGCSSolver_Storage::verifyFixed()
 380 {
 381   // TODO
 382 }
 383
 384 void PlaneGCSSolver_Storage::processArc(const EntityWrapperPtr& theArc)
 385 {
 386   // Calculate additional parameters necessary for PlaneGCS
 387   const std::list<EntityWrapperPtr>& aSubs = theArc->subEntities();
 388   std::list<EntityWrapperPtr>::const_iterator aSubIt = aSubs.begin();
 389   while ((*aSubIt)->type() == ENTITY_POINT) // search scalar entities
 390     ++aSubIt;
 391   double* aStartAngle = std::dynamic_pointer_cast<PlaneGCSSolver_ScalarWrapper>(*aSubIt++)->scalar();
 392   double* aEndAngle   = std::dynamic_pointer_cast<PlaneGCSSolver_ScalarWrapper>(*aSubIt++)->scalar();
 393   double* aRadius     = std::dynamic_pointer_cast<PlaneGCSSolver_ScalarWrapper>(*aSubIt)->scalar();
 394
 395   std::shared_ptr<SketchPlugin_Feature> anArcFeature =
 396       std::dynamic_pointer_cast<SketchPlugin_Feature>(theArc->baseFeature());
 397   std::shared_ptr<GeomDataAPI_Point2D> aCenterAttr = std::dynamic_pointer_cast<GeomDataAPI_Point2D>(
 398       anArcFeature->attribute(SketchPlugin_Arc::CENTER_ID()));
 399   std::shared_ptr<GeomDataAPI_Point2D> aStartAttr = std::dynamic_pointer_cast<GeomDataAPI_Point2D>(
 400       anArcFeature->attribute(SketchPlugin_Arc::START_ID()));
 401   std::shared_ptr<GeomDataAPI_Point2D> aEndAttr = std::dynamic_pointer_cast<GeomDataAPI_Point2D>(
 402       anArcFeature->attribute(SketchPlugin_Arc::END_ID()));
 403   if (!aCenterAttr || !aStartAttr || !aEndAttr)
 404     return;
 405   std::shared_ptr<GeomAPI_Pnt2d> aCenterPnt = aCenterAttr->pnt();
 406   std::shared_ptr<GeomAPI_Pnt2d> aStartPnt  = aStartAttr->pnt();
 407   std::shared_ptr<GeomAPI_Pnt2d> aEndPnt    = aEndAttr->pnt();
 408
 409   *aRadius = aCenterPnt->distance(aStartPnt);
 410   if (!anArcFeature->lastResult())
 411     return;
 412   std::shared_ptr<GeomAPI_Edge> anArcEdge =
 413       std::dynamic_pointer_cast<GeomAPI_Edge>(anArcFeature->lastResult()->shape());
 414   if (!anArcEdge)
 415     return;
 416   anArcEdge->getRange(*aStartAngle, *aEndAngle);
 417   // verify the range is correct and not shifted to an angle
 418   std::shared_ptr<GeomAPI_Dir2d> aDir(new GeomAPI_Dir2d(cos(*aStartAngle), sin(*aStartAngle)));
 419   std::shared_ptr<GeomAPI_Pnt2d> aCalcStartPnt(
 420       new GeomAPI_Pnt2d(aCenterPnt->xy()->added(aDir->xy()->multiplied(*aRadius))));
 421   if (aCalcStartPnt->distance(aStartPnt) > tolerance) {
 422     std::shared_ptr<GeomAPI_Dir2d> aDirToStart(
 423         new GeomAPI_Dir2d(aStartPnt->xy()->decreased(aCenterPnt->xy())));
 424     double anAngle = aDir->angle(aDirToStart);
 425     *aStartAngle += anAngle;
 426     *aEndAngle += anAngle;
 427   }
 428
 429   // no need to constraint a fixed or a copied arc
 430   if (theArc->group() == GID_OUTOFGROUP || anArcFeature->isCopy())
 431     return;
 432   // No need to add constraints if they are already exist
 433   std::map<EntityWrapperPtr, std::vector<GCSConstraintPtr> >::const_iterator
 434       aFound = myArcConstraintMap.find(theArc);
 435   if (aFound != myArcConstraintMap.end())
 436     return;
 437
 438   // Prepare additional constraints to produce the arc
 439   std::vector<GCSConstraintPtr> anArcConstraints;
 440   std::shared_ptr<PlaneGCSSolver_EntityWrapper> anArcEnt =
 441       std::dynamic_pointer_cast<PlaneGCSSolver_EntityWrapper>(theArc);
 442   std::shared_ptr<GCS::Arc> anArc = std::dynamic_pointer_cast<GCS::Arc>(anArcEnt->entity());
 443   // Distances from center till start and end points are equal to radius
 444   anArcConstraints.push_back(GCSConstraintPtr(new GCS::ConstraintP2PDistance(
 445       anArc->center, anArc->start, anArc->rad)));
 446   anArcConstraints.push_back(GCSConstraintPtr(new GCS::ConstraintP2PDistance(
 447       anArc->center, anArc->end, anArc->rad)));
 448   // Angles of start and end points should be equal to given angles
 449   anArcConstraints.push_back(GCSConstraintPtr(new GCS::ConstraintP2PAngle(
 450       anArc->center, anArc->start, anArc->startAngle)));
 451   anArcConstraints.push_back(GCSConstraintPtr(new GCS::ConstraintP2PAngle(
 452       anArc->center, anArc->end, anArc->endAngle)));
 453
 454   myArcConstraintMap[theArc] = anArcConstraints;
 455 }
 456
 457
 458 void PlaneGCSSolver_Storage::makeConstant(const EntityWrapperPtr& theEntity)
 459 {
 460   toggleEntity(theEntity, myParameters, myConst);
 461   if (theEntity->type() == ENTITY_POINT)
 462     updateCoincident(theEntity);
 463 }
 464
 465 void PlaneGCSSolver_Storage::makeVariable(const EntityWrapperPtr& theEntity)
 466 {
 467   toggleEntity(theEntity, myConst, myParameters);
 468 }
 469
 470 static void getParametersToMove(const EntityWrapperPtr& theEntity, std::set<double*>& theParamList)
 471 {
 472   const std::list<ParameterWrapperPtr> aParams = theEntity->parameters();
 473   std::list<ParameterWrapperPtr>::const_iterator aPIt = aParams.begin();
 474   for (; aPIt != aParams.end(); ++aPIt)
 475     theParamList.insert(
 476         std::dynamic_pointer_cast<PlaneGCSSolver_ParameterWrapper>(*aPIt)->parameter());
 477
 478   const std::list<EntityWrapperPtr> aSubs = theEntity->subEntities();
 479   std::list<EntityWrapperPtr>::const_iterator aSIt = aSubs.begin();
 480
 481   if (theEntity->type() == ENTITY_ARC) {
 482     // workaround for the arc processing, because the arc is fixed by a set of constraints,
 483     // which will conflict with all parameters fixed:
 484     // 1. take center
 485     getParametersToMove(*aSIt++, theParamList);
 486     // 2. take start point
 487     getParametersToMove(*aSIt++, theParamList);
 488     // 3. skip end point, radius and start angle, but take end angle parameter
 489     getParametersToMove(*(++aSIt), theParamList);
 490   } else {
 491     for (; aSIt != aSubs.end(); ++aSIt)
 492       getParametersToMove(*aSIt, theParamList);
 493   }
 494 }
 495
 496 void PlaneGCSSolver_Storage::toggleEntity(
 497     const EntityWrapperPtr& theEntity, GCS::VEC_pD& theFrom, GCS::VEC_pD& theTo)
 498 {
 499   std::set<double*> aParamsToMove;
 500   getParametersToMove(theEntity, aParamsToMove);
 501
 502   GCS::VEC_pD::iterator anIt = theFrom.begin();
 503   while (anIt != theFrom.end()) {
 504     if (aParamsToMove.find(*anIt) == aParamsToMove.end()) {
 505       ++anIt;
 506       continue;
 507     }
 508
 509     theTo.push_back(*anIt);
 510     int aShift = int(anIt - theFrom.begin());
 511     theFrom.erase(anIt);
 512     anIt = theFrom.begin() + aShift;
 513   }
 514 }
 515
 516 void PlaneGCSSolver_Storage::updateCoincident(const EntityWrapperPtr& thePoint)
 517 {
 518   CoincidentPointsMap::iterator anIt = myCoincidentPoints.begin();
 519   for (; anIt != myCoincidentPoints.end(); ++anIt) {
 520     if (anIt->first == thePoint || anIt->second.find(thePoint) != anIt->second.end()) {
 521       std::set<EntityWrapperPtr> aCoincident = anIt->second;
 522       aCoincident.insert(anIt->first);
 523
 524       const std::list<ParameterWrapperPtr>& aBaseParams = thePoint->parameters();
 525       std::list<ParameterWrapperPtr> aParams;
 526       std::list<ParameterWrapperPtr>::const_iterator aBaseIt, anUpdIt;
 527
 528       std::set<EntityWrapperPtr>::const_iterator aCoincIt = aCoincident.begin();
 529       for (; aCoincIt != aCoincident.end(); ++aCoincIt)
 530         if (*aCoincIt != thePoint && (*aCoincIt)->group() != GID_OUTOFGROUP) {
 531           aParams = (*aCoincIt)->parameters();
 532           aBaseIt = aBaseParams.begin();
 533           for (anUpdIt = aParams.begin(); anUpdIt != aParams.end(); ++anUpdIt, ++aBaseIt)
 534             (*anUpdIt)->setValue((*aBaseIt)->value());
 535         }
 536
 537       break;
 538     }
 539   }
 540 }
 541
 542
 543 bool PlaneGCSSolver_Storage::isRedundant(
 544     GCSConstraintPtr theCheckedConstraint,
 545     ConstraintWrapperPtr theParentConstraint,
 546     std::list<std::set<double*> >& theCoincidentPoints) const
 547 {
 548   if (theParentConstraint->type() == CONSTRAINT_SYMMETRIC) {
 549     if (theCheckedConstraint->getTypeId() == GCS::Perpendicular) {
 550       BuilderPtr aBuilder = PlaneGCSSolver_Builder::getInstance();
 551       // check the initial point is placed on the mirror line
 552       std::list<EntityWrapperPtr> aSubs = theParentConstraint->entities();
 553       std::shared_ptr<GeomAPI_Pnt2d> aPoint = aBuilder->point(aSubs.front());
 554       std::shared_ptr<GeomAPI_Lin2d> aLine = aBuilder->line(aSubs.back());
 555       return aLine->distance(aPoint) < tolerance;
 556     }
 557   }
 558   else if (theParentConstraint->type() == CONSTRAINT_PT_PT_COINCIDENT) {
 559     // Verify that the coincidence between points is already added
 560     GCS::VEC_pD aParams = theCheckedConstraint->params();
 561
 562     std::list<std::set<double*> >::iterator aCoincIt, aFound1, aFound2;
 563     aFound1 = aFound2 = theCoincidentPoints.end();
 564     for (aCoincIt = theCoincidentPoints.begin(); aCoincIt != theCoincidentPoints.end(); ++aCoincIt) {
 565       if (aFound1 == theCoincidentPoints.end() && aCoincIt->find(aParams[0]) != aCoincIt->end())
 566         aFound1 = aCoincIt;
 567       if (aFound2 == theCoincidentPoints.end() && aCoincIt->find(aParams[1]) != aCoincIt->end())
 568         aFound2 = aCoincIt;
 569       if (aFound1 != theCoincidentPoints.end() && aFound2 != theCoincidentPoints.end())
 570         break;
 571     }
 572     if (aCoincIt != theCoincidentPoints.end()) { // both point are found
 573       if (aFound1 == aFound2)
 574         return true;
 575       // merge two groups of coincidence
 576       aFound1->insert(aFound2->begin(), aFound2->end());
 577       theCoincidentPoints.erase(aFound2);
 578     } else {
 579       if (aFound1 != theCoincidentPoints.end())
 580         aFound1->insert(aParams[1]);
 581       else if (aFound2 != theCoincidentPoints.end())
 582         aFound2->insert(aParams[0]);
 583       else {
 584         std::set<double*> aNewCoincidence;
 585         aNewCoincidence.insert(aParams[0]);
 586         aNewCoincidence.insert(aParams[1]);
 587         theCoincidentPoints.push_back(aNewCoincidence);
 588       }
 589     }
 590   }
 591
 592   return false;
 593 }
 594
 595 void PlaneGCSSolver_Storage::initializeSolver(SolverPtr theSolver)
 596 {
 597   std::shared_ptr<PlaneGCSSolver_Solver> aSolver =
 598       std::dynamic_pointer_cast<PlaneGCSSolver_Solver>(theSolver);
 599   if (!aSolver)
 600     return;
 601   aSolver->clear();
 602
 603   if (myExistArc)
 604     processArcs();
 605
 606   // initialize constraints
 607   std::map<ConstraintPtr, std::list<ConstraintWrapperPtr> >::const_iterator
 608       aCIt = myConstraintMap.begin();
 609   GCS::SET_I aTangentIDs;
 610   std::list<std::set<double*> > aCoincidentPoints;
 611   for (; aCIt != myConstraintMap.end(); ++aCIt) {
 612     std::list<ConstraintWrapperPtr>::const_iterator aCWIt = aCIt->second.begin();
 613     for (; aCWIt != aCIt->second.end(); ++ aCWIt) {
 614       std::shared_ptr<PlaneGCSSolver_ConstraintWrapper> aGCS =
 615           std::dynamic_pointer_cast<PlaneGCSSolver_ConstraintWrapper>(*aCWIt);
 616       std::list<GCSConstraintPtr>::const_iterator anIt = aGCS->constraints().begin();
 617       for (; anIt != aGCS->constraints().end(); ++anIt)
 618         if (!isRedundant(*anIt, aGCS, aCoincidentPoints))
 619           aSolver->addConstraint(*anIt);
 620     }
 621     // store IDs of tangent constraints to avoid incorrect report of redundant constraints
 622     if (aCIt->first && aCIt->first->getKind() == SketchPlugin_ConstraintTangent::ID())
 623       for (aCWIt = aCIt->second.begin(); aCWIt != aCIt->second.end(); ++ aCWIt)
 624         aTangentIDs.insert((int)(*aCWIt)->id());
 625   }
 626   // additional constraints for arcs
 627   std::map<EntityWrapperPtr, std::vector<GCSConstraintPtr> >::const_iterator
 628       anArcIt = myArcConstraintMap.begin();
 629   for (; anArcIt != myArcConstraintMap.end(); ++anArcIt) {
 630     std::vector<GCSConstraintPtr>::const_iterator anIt = anArcIt->second.begin();
 631     for (; anIt != anArcIt->second.end(); ++anIt)
 632       aSolver->addConstraint(*anIt);
 633   }
 634   // removed waste constraints
 635   std::list<GCSConstraintPtr>::const_iterator aRemIt = myRemovedConstraints.begin();
 636   for (; aRemIt != myRemovedConstraints.end(); ++aRemIt)
 637     aSolver->removeConstraint(*aRemIt);
 638   myRemovedConstraints.clear();
 639   // set list of tangent constraints
 640   aSolver->setTangent(aTangentIDs);
 641   // initialize unknowns
 642   aSolver->setParameters(myParameters);
 643 }
 644
 645 void PlaneGCSSolver_Storage::refresh(bool theFixedOnly) const
 646 {
 647   //blockEvents(true);
 648
 649   std::map<AttributePtr, EntityWrapperPtr>::const_iterator anIt = myAttributeMap.begin();
 650   std::list<ParameterWrapperPtr> aParams;
 651   std::list<ParameterWrapperPtr>::const_iterator aParIt;
 652   for (; anIt != myAttributeMap.end(); ++anIt) {
 653     // the external feature always should keep the up to date values, so,
 654     // refresh from the solver is never needed
 655     bool isExternal = false;
 656     if (anIt->first.get()) {
 657       std::shared_ptr<SketchPlugin_Feature> aSketchFeature =
 658         std::dynamic_pointer_cast<SketchPlugin_Feature>(anIt->first->owner());
 659       if (aSketchFeature.get() && aSketchFeature->isExternal())
 660         isExternal = true;
 661     }
 662
 663     // update parameter wrappers and obtain values of attributes
 664     aParams = anIt->second->parameters();
 665     double aCoords[3];
 666     bool isUpd[3] = {false};
 667     int i = 0;
 668     for (aParIt = aParams.begin(); i < 3 && aParIt != aParams.end(); ++aParIt, ++i) {
 669       if (!theFixedOnly || isExternal ||
 670           (*aParIt)->group() == GID_OUTOFGROUP || (*aParIt)->isParametric()) {
 671         aCoords[i] = (*aParIt)->value();
 672         isUpd[i] = true;
 673       }
 674     }
 675     if (!isUpd[0] && !isUpd[1] && !isUpd[2])
 676       continue; // nothing is updated
 677
 678     std::shared_ptr<GeomDataAPI_Point2D> aPoint2D =
 679         std::dynamic_pointer_cast<GeomDataAPI_Point2D>(anIt->first);
 680     if (aPoint2D) {
 681       if ((isUpd[0] && fabs(aPoint2D->x() - aCoords[0]) > tolerance) ||
 682           (isUpd[1] && fabs(aPoint2D->y() - aCoords[1]) > tolerance) || isExternal) {
 683         if (!isUpd[0] || isExternal) aCoords[0] = aPoint2D->x();
 684         if (!isUpd[1] || isExternal) aCoords[1] = aPoint2D->y();
 685         aPoint2D->setValue(aCoords[0], aCoords[1]);
 686         // Find points coincident with this one (probably not in GID_OUTOFGROUP)
 687         CoincidentPointsMap::const_iterator aCoincIt = myCoincidentPoints.begin();
 688         for (; aCoincIt != myCoincidentPoints.end(); ++aCoincIt)
 689           if (aCoincIt->first == anIt->second ||
 690               aCoincIt->second.find(anIt->second) != aCoincIt->second.end())
 691             break;
 692         if (aCoincIt != myCoincidentPoints.end()) {
 693           aPoint2D = std::dynamic_pointer_cast<GeomDataAPI_Point2D>(
 694               aCoincIt->first->baseAttribute());
 695           if (aPoint2D)
 696             aPoint2D->setValue(aCoords[0], aCoords[1]);
 697           std::set<EntityWrapperPtr>::const_iterator aSlaveIt = aCoincIt->second.begin();
 698           for (; aSlaveIt != aCoincIt->second.end(); ++aSlaveIt) {
 699             aPoint2D = std::dynamic_pointer_cast<GeomDataAPI_Point2D>((*aSlaveIt)->baseAttribute());
 700             if (aPoint2D)
 701               aPoint2D->setValue(aCoords[0], aCoords[1]);
 702           }
 703         }
 704       }
 705       continue;
 706     }
 707     AttributeDoublePtr aScalar = std::dynamic_pointer_cast<ModelAPI_AttributeDouble>(anIt->first);
 708     if (aScalar && !isExternal) {
 709       if (isUpd[0] && fabs(aScalar->value() - aCoords[0]) > tolerance)
 710         aScalar->setValue(aCoords[0]);
 711       continue;
 712     }
 713   }
 714
 715   //blockEvents(false);
 716 }
 717
 718 EntityWrapperPtr PlaneGCSSolver_Storage::calculateMiddlePoint(
 719     EntityWrapperPtr theBase, double theCoeff)
 720 {
 721   std::shared_ptr<PlaneGCSSolver_Builder> aBuilder =
 722       std::dynamic_pointer_cast<PlaneGCSSolver_Builder>(PlaneGCSSolver_Builder::getInstance());
 723
 724   std::shared_ptr<GeomAPI_XY> aMidPoint;
 725   if (theBase->type() == ENTITY_LINE) {
 726     std::shared_ptr<GeomAPI_Pnt2d> aPoints[2];
 727     const std::list<EntityWrapperPtr>& aSubs = theBase->subEntities();
 728     std::list<EntityWrapperPtr>::const_iterator anIt = aSubs.begin();
 729     for (int i = 0; i < 2; ++i, ++anIt)
 730       aPoints[i] = aBuilder->point(*anIt);
 731     aMidPoint = aPoints[0]->xy()->multiplied(1.0 - theCoeff)->added(
 732         aPoints[1]->xy()->multiplied(theCoeff));
 733   }
 734   else if (theBase->type() == ENTITY_ARC) {
 735     double theX, theY;
 736     double anArcPoint[3][2];
 737     const std::list<EntityWrapperPtr>& aSubs = theBase->subEntities();
 738     std::list<EntityWrapperPtr>::const_iterator anIt = aSubs.begin();
 739     for (int i = 0; i < 3; ++i, ++anIt) {
 740       std::shared_ptr<GeomAPI_Pnt2d> aPoint = aBuilder->point(*anIt);
 741       anArcPoint[i][0] = aPoint->x();
 742       anArcPoint[i][1] = aPoint->y();
 743     }
 744     // project last point of arc on the arc
 745     double x = anArcPoint[1][0] - anArcPoint[0][0];
 746     double y = anArcPoint[1][1] - anArcPoint[0][1];
 747     double aRad = sqrt(x*x + y*y);
 748     x = anArcPoint[2][0] - anArcPoint[0][0];
 749     y = anArcPoint[2][1] - anArcPoint[0][1];
 750     double aNorm = sqrt(x*x + y*y);
 751     if (aNorm >= tolerance) {
 752       anArcPoint[2][0] = x * aRad / aNorm;
 753       anArcPoint[2][1] = y * aRad / aNorm;
 754     }
 755     anArcPoint[1][0] -= anArcPoint[0][0];
 756     anArcPoint[1][1] -= anArcPoint[0][1];
 757     if (theCoeff < tolerance) {
 758       theX = anArcPoint[0][0] + anArcPoint[1][0];
 759       theY = anArcPoint[0][1] + anArcPoint[1][1];
 760     } else if (1 - theCoeff < tolerance) {
 761       theX = anArcPoint[0][0] + anArcPoint[2][0];
 762       theY = anArcPoint[0][1] + anArcPoint[2][1];
 763     } else {
 764       std::shared_ptr<GeomAPI_Dir2d> aStartDir(new GeomAPI_Dir2d(anArcPoint[1][0], anArcPoint[1][1]));
 765       std::shared_ptr<GeomAPI_Dir2d> aEndDir(new GeomAPI_Dir2d(anArcPoint[2][0], anArcPoint[2][1]));
 766       double anAngle = aStartDir->angle(aEndDir);
 767       if (anAngle < 0)
 768         anAngle += 2.0 * PI;
 769       anAngle *= theCoeff;
 770       double aCos = cos(anAngle);
 771       double aSin = sin(anAngle);
 772       theX = anArcPoint[0][0] + anArcPoint[1][0] * aCos - anArcPoint[1][1] * aSin;
 773       theY = anArcPoint[0][1] + anArcPoint[1][0] * aSin + anArcPoint[1][1] * aCos;
 774     }
 775     aMidPoint = std::shared_ptr<GeomAPI_XY>(new GeomAPI_XY(theX, theY));
 776   }
 777
 778   if (!aMidPoint)
 779     return EntityWrapperPtr();
 780
 781   std::list<ParameterWrapperPtr> aParameters;
 782   aParameters.push_back(aBuilder->createParameter(myGroupID, aMidPoint->x()));
 783   aParameters.push_back(aBuilder->createParameter(myGroupID, aMidPoint->y()));
 784   // Create entity (parameters are not filled)
 785   GCSPointPtr aPnt(new GCS::Point);
 786   aPnt->x = std::dynamic_pointer_cast<PlaneGCSSolver_ParameterWrapper>(aParameters.front())->parameter();
 787   aPnt->y = std::dynamic_pointer_cast<PlaneGCSSolver_ParameterWrapper>(aParameters.back())->parameter();
 788
 789   EntityWrapperPtr aResult(new PlaneGCSSolver_PointWrapper(AttributePtr(), aPnt));
 790   aResult->setGroup(myGroupID);
 791   aResult->setParameters(aParameters);
 792
 793   update(aResult);
 794   return aResult;
 795 }