src/SketchSolver/SketchSolver_ConstraintMultiTranslation.cpp

   1 #include <SketchSolver_ConstraintMultiTranslation.h>
   2 #include <SketchSolver_Group.h>
   3 #include <SketchSolver_Error.h>
   4
   5 #include <SketchPlugin_Arc.h>
   6 #include <SketchPlugin_MultiTranslation.h>
   7
   8 #include <ModelAPI_AttributeDouble.h>
   9 #include <ModelAPI_AttributeInteger.h>
  10 #include <ModelAPI_AttributeRefAttr.h>
  11 #include <ModelAPI_AttributeRefList.h>
  12 #include <ModelAPI_ResultConstruction.h>
  13 #include <ModelAPI_Data.h>
  14
  15 #include <GeomAPI_Dir2d.h>
  16 #include <GeomAPI_XY.h>
  17
  18 #include <math.h>
  19
  20
  21 void SketchSolver_ConstraintMultiTranslation::getAttributes(
  22     Slvs_hEntity& theStartPoint, Slvs_hEntity& theEndPoint,
  23     std::vector< std::vector<Slvs_hEntity> >& thePoints,
  24     std::vector< std::vector<Slvs_hEntity> >& theEntities)
  25 {
  26   DataPtr aData = myBaseConstraint->data();
  27   AttributePtr aStartPointAttr = aData->attribute(SketchPlugin_MultiTranslation::START_POINT_ID());
  28   AttributePtr aEndPointAttr = aData->attribute(SketchPlugin_MultiTranslation::END_POINT_ID());
  29   if (!aStartPointAttr || !aStartPointAttr->isInitialized() ||
  30       !aEndPointAttr || !aEndPointAttr->isInitialized()) {
  31     myErrorMsg = SketchSolver_Error::NOT_INITIALIZED();
  32     return;
  33   }
  34
  35   int aType = SLVS_E_UNKNOWN; // type of created entity
  36   Slvs_hEntity anEntityID = myGroup->getAttributeId(aStartPointAttr);
  37   if (anEntityID == SLVS_E_UNKNOWN)
  38     anEntityID = changeEntity(aStartPointAttr, aType);
  39   theStartPoint = anEntityID;
  40   anEntityID = myGroup->getAttributeId(aEndPointAttr);
  41   if (anEntityID == SLVS_E_UNKNOWN)
  42     anEntityID = changeEntity(aEndPointAttr, aType);
  43   theEndPoint = anEntityID;
  44
  45   // Lists of objects and number of copies
  46   AttributeRefListPtr anInitialRefList = std::dynamic_pointer_cast<ModelAPI_AttributeRefList>(
  47       aData->attribute(SketchPlugin_Constraint::ENTITY_A()));
  48   myNumberOfObjects = anInitialRefList->size();
  49   myNumberOfCopies = (size_t) aData->integer(SketchPlugin_MultiTranslation::NUMBER_OF_COPIES_ID())->value();
  50   AttributeRefListPtr aRefList = std::dynamic_pointer_cast<ModelAPI_AttributeRefList>(
  51       myBaseConstraint->attribute(SketchPlugin_Constraint::ENTITY_B()));
  52   if (!aRefList) {
  53     myErrorMsg = SketchSolver_Error::INCORRECT_ATTRIBUTE();
  54     return;
  55   }
  56
  57   // Obtain all points of initial features and store them into separate lists
  58   // containing their translated copies.
  59   // Also all circles and arc collected too, because they will be constrained by equal radii.
  60   FeaturePtr aFeature;
  61   ResultConstructionPtr aRC;
  62   static const size_t MAX_POINTS = 3;
  63   std::vector<Slvs_hEntity> aPoints[MAX_POINTS]; // lists of points of features
  64   std::vector<Slvs_hEntity> anEntities;          // list of translated entities
  65   std::list<ObjectPtr> anObjectList = aRefList->list();
  66   std::list<ObjectPtr>::iterator anObjectIter = anObjectList.begin();
  67   while (anObjectIter != anObjectList.end()) {
  68     for (size_t i = 0; i < MAX_POINTS; i++)
  69       aPoints[i].clear();
  70     anEntities.clear();
  71
  72     for (size_t i = 0; i <= myNumberOfCopies && anObjectIter != anObjectList.end(); i++, anObjectIter++) {
  73       aFeature = ModelAPI_Feature::feature(*anObjectIter);
  74       if (!aFeature)
  75         continue;
  76       anEntityID = changeEntity(aFeature, aType);
  77       anEntities.push_back(anEntityID);
  78       Slvs_Entity anEntity = myStorage->getEntity(anEntityID);
  79       switch (aType) {
  80       case SLVS_E_POINT_IN_2D:
  81       case SLVS_E_POINT_IN_3D:
  82         aPoints[0].push_back(anEntityID);
  83         break;
  84       case SLVS_E_LINE_SEGMENT:
  85         aPoints[0].push_back(anEntity.point[0]); // start point of line
  86         aPoints[1].push_back(anEntity.point[1]); // end point of line
  87         break;
  88       case SLVS_E_CIRCLE:
  89         aPoints[0].push_back(anEntity.point[0]); // center of circle
  90         break;
  91       case SLVS_E_ARC_OF_CIRCLE:
  92         aPoints[0].push_back(anEntity.point[0]); // center of arc
  93         aPoints[1].push_back(anEntity.point[1]); // start point of arc
  94         aPoints[2].push_back(anEntity.point[2]); // end point of arc
  95         break;
  96       default:
  97         myErrorMsg = SketchSolver_Error::INCORRECT_ATTRIBUTE();
  98         return;
  99       }
 100     }
 101
 102     for (size_t i = 0; i < MAX_POINTS; ++i)
 103       if (!aPoints[i].empty())
 104         thePoints.push_back(aPoints[i]);
 105     if (!anEntities.empty())
 106       theEntities.push_back(anEntities);
 107   }
 108 }
 109
 110 void SketchSolver_ConstraintMultiTranslation::process()
 111 {
 112   cleanErrorMsg();
 113   if (!myBaseConstraint || !myStorage || myGroup == 0) {
 114     /// TODO: Put error message here
 115     return;
 116   }
 117   if (!mySlvsConstraints.empty()) // some data is changed, update constraint
 118     update(myBaseConstraint);
 119
 120   Slvs_hEntity aStartPoint, aEndPoint;
 121   std::vector<std::vector<Slvs_hEntity> > anEntitiesAndCopies;
 122   getAttributes(aStartPoint, aEndPoint, myPointsAndCopies, anEntitiesAndCopies);
 123   if (!myErrorMsg.empty())
 124     return;
 125
 126   // Create translation line
 127   if (myTranslationLine == SLVS_E_UNKNOWN) {
 128     Slvs_Entity aTranslationLine = Slvs_MakeLineSegment(SLVS_E_UNKNOWN, myGroup->getId(),
 129         myGroup->getWorkplaneId(), aStartPoint, aEndPoint);
 130     aTranslationLine.h = myStorage->addEntity(aTranslationLine);
 131     myTranslationLine = aTranslationLine.h;
 132   } else {
 133     Slvs_Entity aTranslationLine = myStorage->getEntity(myTranslationLine);
 134     if (aTranslationLine.point[0] != aStartPoint || aTranslationLine.point[1] != aEndPoint) {
 135       aTranslationLine.point[0] = aStartPoint;
 136       aTranslationLine.point[1] = aEndPoint;
 137       myStorage->updateEntity(aTranslationLine);
 138     }
 139   }
 140
 141   // Keep all objects unchanged (only initial object may be changed by user)
 142   myCircsAndCopies.clear();
 143   std::vector<std::vector<Slvs_hEntity> >::const_iterator anEntIt = anEntitiesAndCopies.begin();
 144   std::vector<Slvs_hEntity>::const_iterator aCpIt;
 145   for (; anEntIt != anEntitiesAndCopies.end(); ++anEntIt) {
 146     std::vector<Slvs_hEntity> aCircs;
 147     aCpIt = anEntIt->begin();
 148     // Obtain initial points
 149     Slvs_Entity anInitial = myStorage->getEntity(*aCpIt);
 150     if (anInitial.type == SLVS_E_POINT_IN_2D || anInitial.type == SLVS_E_POINT_IN_3D)
 151       myInitialPoints.insert(anInitial.h);
 152     else {
 153       for (int i = 0; i < 4 && anInitial.point[i] != SLVS_E_UNKNOWN; i++)
 154         myInitialPoints.insert(anInitial.point[i]);
 155     }
 156
 157     // Fix the copies
 158     for (++aCpIt; aCpIt != anEntIt->end(); ++aCpIt) {
 159       const Slvs_Entity& anEntity = myStorage->getEntity(*aCpIt);
 160       std::vector<Slvs_hConstraint> aNewConstr;
 161       if (anEntity.type == SLVS_E_CIRCLE) {
 162         aCircs.push_back(anEntity.distance);
 163         // for circles we fix only center
 164         aNewConstr = myStorage->fixEntity(anEntity.point[0]);
 165       } else
 166         aNewConstr = myStorage->fixEntity(*aCpIt);
 167       if (anEntity.type == SLVS_E_ARC_OF_CIRCLE)
 168         aCircs.push_back(anEntity.h);
 169       mySlvsConstraints.insert(mySlvsConstraints.end(), aNewConstr.begin(), aNewConstr.end());
 170     }
 171
 172     if (!aCircs.empty()) {
 173       if (anInitial.type == SLVS_E_CIRCLE)
 174         aCircs.insert(aCircs.begin(), anInitial.distance);
 175       else
 176         aCircs.insert(aCircs.begin(), anInitial.h);
 177       myCircsAndCopies.push_back(aCircs);
 178     }
 179   }
 180
 181   adjustConstraint();
 182 }
 183
 184 void SketchSolver_ConstraintMultiTranslation::update(ConstraintPtr theConstraint)
 185 {
 186   cleanErrorMsg();
 187   if (!theConstraint || theConstraint == myBaseConstraint) {
 188     AttributeRefListPtr anInitialRefList = std::dynamic_pointer_cast<ModelAPI_AttributeRefList>(
 189         myBaseConstraint->attribute(SketchPlugin_Constraint::ENTITY_A()));
 190     AttributeIntegerPtr aNbCopies = myBaseConstraint->integer(SketchPlugin_MultiTranslation::NUMBER_OF_COPIES_ID());
 191     if (anInitialRefList->size() != myNumberOfObjects ||
 192         (size_t)aNbCopies->value() != myNumberOfCopies) {
 193       remove(myBaseConstraint);
 194       process();
 195       return;
 196     }
 197   }
 198   SketchSolver_Constraint::update();
 199 }
 200
 201 bool SketchSolver_ConstraintMultiTranslation::remove(ConstraintPtr theConstraint)
 202 {
 203   cleanErrorMsg();
 204   if (theConstraint && theConstraint != myBaseConstraint)
 205     return false;
 206   bool isFullyRemoved = true;
 207   std::vector<Slvs_hEntity>::iterator aCIter = mySlvsConstraints.begin();
 208   for (; aCIter != mySlvsConstraints.end(); aCIter++)
 209    isFullyRemoved = myStorage->removeConstraint(*aCIter) && isFullyRemoved;
 210   mySlvsConstraints.clear();
 211
 212   std::map<FeaturePtr, Slvs_hEntity>::iterator aFeatIt = myFeatureMap.begin();
 213   for (; aFeatIt != myFeatureMap.end(); aFeatIt++)
 214     myStorage->removeEntity(aFeatIt->second);
 215
 216   std::map<FeaturePtr, Slvs_hEntity> aFeatureMapCopy = myFeatureMap;
 217
 218   if (isFullyRemoved) {
 219     myFeatureMap.clear();
 220     myAttributeMap.clear();
 221     myValueMap.clear();
 222   } else
 223     cleanRemovedEntities();
 224
 225   // Restore initial features
 226   std::map<FeaturePtr, Slvs_hEntity>::iterator aFIter = aFeatureMapCopy.begin();
 227   for (; aFIter != aFeatureMapCopy.end(); ++aFIter)
 228   {
 229     if (myFeatureMap.find(aFIter->first) != myFeatureMap.end())
 230       continue; // the feature was not removed
 231     Slvs_hEntity anEntity = myGroup->getFeatureId(aFIter->first);
 232     if (anEntity != SLVS_E_UNKNOWN)
 233       myFeatureMap[aFIter->first] = anEntity;
 234   }
 235
 236   return true;
 237 }
 238
 239 void SketchSolver_ConstraintMultiTranslation::addFeature(FeaturePtr theFeature)
 240 {
 241   SketchSolver_Constraint::addFeature(theFeature);
 242
 243   std::map<FeaturePtr, Slvs_hEntity>::iterator aFeatIt = myFeatureMap.find(theFeature);
 244   if (aFeatIt == myFeatureMap.end())
 245     return;
 246
 247   // store list of points of the feature
 248   const Slvs_Entity& theEntity = myStorage->getEntity(aFeatIt->second);
 249   for (int i = 0; i < 4; i++)
 250     if (theEntity.point[i] != SLVS_E_UNKNOWN)
 251       myPointsJustUpdated.insert(theEntity.point[i]);
 252 }
 253
 254 void SketchSolver_ConstraintMultiTranslation::adjustConstraint()
 255 {
 256   Slvs_Entity aTranslationLine = myStorage->getEntity(myTranslationLine);
 257   Slvs_hConstraint aFixed; // temporary variable
 258   // Set the translation line unchanged during constraint recalculation
 259   for (int i = 0; i < 2; i++) {
 260     if (myStorage->isPointFixed(aTranslationLine.point[i], aFixed, true))
 261       continue;
 262     Slvs_Constraint aConstraint = Slvs_MakeConstraint(
 263         SLVS_E_UNKNOWN, myGroup->getId(), SLVS_C_WHERE_DRAGGED, myGroup->getWorkplaneId(), 0.0,
 264         aTranslationLine.point[i], SLVS_E_UNKNOWN, SLVS_E_UNKNOWN, SLVS_E_UNKNOWN);
 265     aConstraint.h = myStorage->addConstraint(aConstraint);
 266     myStorage->addTemporaryConstraint(aConstraint.h);
 267   }
 268
 269   // Check if the distance between point is 0, no need to resolve constraints (just wait another values)
 270   double aXY[4];
 271   for (int i = 0; i < 2; i++) {
 272     Slvs_Entity aPnt = myStorage->getEntity(aTranslationLine.point[i]);
 273     aXY[2*i] = myStorage->getParameter(aPnt.param[0]).val;
 274     aXY[2*i+1] = myStorage->getParameter(aPnt.param[1]).val;
 275   }
 276   double aDelta[2] = {aXY[2] - aXY[0], aXY[3] - aXY[1]};
 277   if (fabs(aDelta[0]) + fabs(aDelta[1]) < tolerance) {
 278     myStorage->setNeedToResolve(false);
 279     return;
 280   }
 281
 282   std::list<Slvs_Constraint> aCoincident = myStorage->getConstraintsByType(SLVS_C_POINTS_COINCIDENT);
 283   std::list<Slvs_Constraint>::const_iterator aCoIt;
 284
 285   double aCoord[2];
 286
 287   // Update positions of all points to satisfy distances
 288   std::vector< std::vector<Slvs_hEntity> >::const_iterator aPointsIter = myPointsAndCopies.begin();
 289   std::vector<Slvs_hEntity>::const_iterator aCopyIter;
 290   for (; aPointsIter != myPointsAndCopies.end(); ++aPointsIter) {
 291     aCopyIter = aPointsIter->begin();
 292     const Slvs_Entity& anInitial = myStorage->getEntity(*aCopyIter);
 293     for (int i = 0; i < 2; i++)
 294       aCoord[i] = myStorage->getParameter(anInitial.param[i]).val;
 295
 296     // if the point is coincident with another one which is temporary fixed (moved by user),
 297     // we will update its position correspondingly
 298     Slvs_hConstraint aFixed;
 299     for (aCoIt = aCoincident.begin(); aCoIt != aCoincident.end(); ++aCoIt) {
 300       if ((aCoIt->ptA == anInitial.h && myInitialPoints.find(aCoIt->ptB) != myInitialPoints.end()) ||
 301           (aCoIt->ptB == anInitial.h && myInitialPoints.find(aCoIt->ptA) != myInitialPoints.end())) {
 302         Slvs_hEntity anOtherId = aCoIt->ptA == anInitial.h ? aCoIt->ptB : aCoIt->ptA;
 303         if (!myStorage->isTemporary(aFixed) &&
 304             myPointsJustUpdated.find(anOtherId) == myPointsJustUpdated.end())
 305           continue; // nothing to change
 306
 307         const Slvs_Entity& anOtherPnt = myStorage->getEntity(anOtherId);
 308         for (int i = 0; i < 2; i++) {
 309           Slvs_Param anInitParam = myStorage->getParameter(anInitial.param[i]);
 310           const Slvs_Param& anOtherParam = myStorage->getParameter(anOtherPnt.param[i]);
 311           anInitParam.val = anOtherParam.val;
 312           myStorage->updateParameter(anInitParam);
 313           aCoord[i] = anOtherParam.val;
 314         }
 315       }
 316     }
 317
 318     // update copied points
 319     aCopyIter = aPointsIter->begin();
 320     for (++aCopyIter; aCopyIter != aPointsIter->end(); ++aCopyIter) {
 321       // update position
 322       aCoord[0] += aDelta[0];
 323       aCoord[1] += aDelta[1];
 324
 325       const Slvs_Entity& aTarget = myStorage->getEntity(*aCopyIter);
 326       for (int i = 0; i < 2; i++) {
 327         Slvs_Param aParam = myStorage->getParameter(aTarget.param[i]);
 328         aParam.val = aCoord[i];
 329         myStorage->updateParameter(aParam);
 330       }
 331     }
 332   }
 333
 334   std::list<Slvs_Constraint> aDiamConstr;
 335   for (aPointsIter = myCircsAndCopies.begin(); aPointsIter != myCircsAndCopies.end(); ++aPointsIter) {
 336     aCopyIter = aPointsIter->begin();
 337     const Slvs_Entity& anInitial = myStorage->getEntity(*aCopyIter);
 338     if (anInitial.type == SLVS_E_DISTANCE) {
 339       const Slvs_Param& anInitRad = myStorage->getParameter(anInitial.param[0]);
 340       for (++aCopyIter; aCopyIter != aPointsIter->end(); ++aCopyIter) {
 341         const Slvs_Entity& aCopy = myStorage->getEntity(*aCopyIter);
 342         Slvs_Param aCopyRad = myStorage->getParameter(aCopy.param[0]);
 343         aCopyRad.val = anInitRad.val;
 344         myStorage->updateParameter(aCopyRad);
 345       }
 346     } else if (anInitial.type == SLVS_E_ARC_OF_CIRCLE) {
 347       const Slvs_Entity& aCenterEnt = myStorage->getEntity(anInitial.point[0]);
 348       const Slvs_Entity& aStartEnt = myStorage->getEntity(anInitial.point[1]);
 349
 350       if (aDiamConstr.empty())
 351         aDiamConstr = myStorage->getConstraintsByType(SLVS_C_DIAMETER);
 352       // Calculate diameter of initial arc
 353       double aDiam = 0.0;
 354       for (int i = 0; i < 2; i++) {
 355         double d = myStorage->getParameter(aStartEnt.param[i]).val -
 356                    myStorage->getParameter(aCenterEnt.param[i]).val;
 357         aDiam += d * d;
 358       }
 359       aDiam = sqrt(aDiam) * 2.0;
 360       // Update the Diameter constraints of copied arcs
 361       for (++aCopyIter; aCopyIter != aPointsIter->end(); ++aCopyIter) {
 362         std::list<Slvs_Constraint>::iterator aDCIt = aDiamConstr.begin();
 363         for (; aDCIt != aDiamConstr.end(); ++aDCIt)
 364           if (aDCIt->entityA == *aCopyIter) {
 365             aDCIt->valA = aDiam;
 366             myStorage->updateConstraint(*aDCIt);
 367             aDiamConstr.erase(aDCIt);
 368             break;
 369           }
 370       }
 371     }
 372   }
 373
 374   myPointsJustUpdated.clear();
 375 }