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