src/SketchSolver/SketchSolver_ConstraintMirror.cpp

   1 #include <SketchSolver_ConstraintMirror.h>
   2 #include <SketchSolver_Group.h>
   3 #include <SketchSolver_Error.h>
   4
   5 #include <ModelAPI_AttributeDouble.h>
   6 #include <ModelAPI_AttributeRefAttr.h>
   7 #include <ModelAPI_AttributeRefList.h>
   8 #include <ModelAPI_ResultConstruction.h>
   9
  10 #include <GeomAPI_Dir2d.h>
  11 #include <GeomAPI_XY.h>
  12
  13
  14 void SketchSolver_ConstraintMirror::getAttributes(
  15     Slvs_Entity& theMirrorLine,
  16     std::vector<Slvs_Entity>& theBaseEntities,
  17     std::vector<Slvs_Entity>& theMirrorEntities)
  18 {
  19   DataPtr aData = myBaseConstraint->data();
  20   AttributeRefAttrPtr aMirLineAttr = std::dynamic_pointer_cast<ModelAPI_AttributeRefAttr>(
  21       myBaseConstraint->attribute(SketchPlugin_Constraint::ENTITY_A()));
  22   if (!aMirLineAttr || !aMirLineAttr->isInitialized() || !aMirLineAttr->isObject()) {
  23     myErrorMsg = SketchSolver_Error::NOT_INITIALIZED();
  24     return;
  25   }
  26   int aType = SLVS_E_UNKNOWN; // type of created entity
  27   Slvs_hEntity anEntity = myGroup->getAttributeId(aMirLineAttr);
  28   if (anEntity == SLVS_E_UNKNOWN)
  29     anEntity = changeEntity(aMirLineAttr, aType);
  30   theMirrorLine = myStorage->getEntity(anEntity);
  31
  32   // Create SolveSpace entity for all features
  33   AttributeRefListPtr aBaseRefList = std::dynamic_pointer_cast<ModelAPI_AttributeRefList>(
  34       myBaseConstraint->attribute(SketchPlugin_Constraint::ENTITY_B()));
  35   AttributeRefListPtr aMirroredRefList = std::dynamic_pointer_cast<ModelAPI_AttributeRefList>(
  36       myBaseConstraint->attribute(SketchPlugin_Constraint::ENTITY_C()));
  37   myNumberOfObjects = aMirroredRefList->size();
  38   if (!aBaseRefList || !aMirroredRefList) {
  39     myErrorMsg = SketchSolver_Error::INCORRECT_MIRROR_ATTRIBUTE();
  40     return;
  41   }
  42
  43   std::list<ObjectPtr> aBaseList = aBaseRefList->list();
  44   std::list<ObjectPtr> aMirroredList = aMirroredRefList->list();
  45
  46   FeaturePtr aFeature;
  47   ResultConstructionPtr aRC;
  48   for (int i = 0; i < 2; i++) {
  49     std::list<ObjectPtr>::iterator anIter = i == 0 ? aBaseList.begin() : aMirroredList.begin();
  50     std::list<ObjectPtr>::iterator aEndIter = i == 0 ? aBaseList.end() : aMirroredList.end();
  51     std::vector<Slvs_Entity>* aList = i == 0 ? &theBaseEntities : & theMirrorEntities;
  52     for ( ; anIter != aEndIter; anIter++) {
  53       aRC = std::dynamic_pointer_cast<ModelAPI_ResultConstruction>(*anIter);
  54       aFeature = aRC ? aRC->document()->feature(aRC) :
  55         std::dynamic_pointer_cast<ModelAPI_Feature>(*anIter);
  56       if (!aFeature)
  57         continue;
  58
  59       anEntity = changeEntity(aFeature, aType);
  60       // Sort entities by their type
  61       std::vector<Slvs_Entity>::iterator anIt = aList->begin();
  62       for (; anIt != aList->end(); anIt++)
  63         if (aType < anIt->type)
  64           break;
  65 //      aList->push_back(myStorage->getEntity(anEntity));
  66       aList->insert(anIt, myStorage->getEntity(anEntity));
  67     }
  68   }
  69
  70   if (theBaseEntities.size() > theMirrorEntities.size())
  71     myErrorMsg = SketchSolver_Error::NOT_INITIALIZED();
  72 }
  73
  74 void SketchSolver_ConstraintMirror::process()
  75 {
  76   cleanErrorMsg();
  77   if (!myBaseConstraint || !myStorage || myGroup == 0) {
  78     /// TODO: Put error message here
  79     return;
  80   }
  81   if (!mySlvsConstraints.empty()) // some data is changed, update constraint
  82     update(myBaseConstraint);
  83
  84   Slvs_Entity aMirrorLine;
  85   std::vector<Slvs_Entity> aBaseList;
  86   std::vector<Slvs_Entity> aMirrorList;
  87   getAttributes(aMirrorLine, aBaseList, aMirrorList);
  88   if (!myErrorMsg.empty())
  89     return;
  90
  91   if (aBaseList.size() != aMirrorList.size()) {
  92     myErrorMsg = SketchSolver_Error::INCORRECT_MIRROR_ATTRIBUTE();
  93     return;
  94   }
  95
  96   Slvs_Constraint aConstraint;
  97   // Get coordinates of mirror line points for speed up
  98   double aStartEnd[4];
  99   for (int i = 0; i < 2; i++) {
 100     Slvs_Entity aPoint = myStorage->getEntity(aMirrorLine.point[i]);
 101     for (int j = 0; j < 2; j++)
 102       aStartEnd[2*i+j] = myStorage->getParameter(aPoint.param[j]).val;
 103   }
 104
 105   std::vector<Slvs_Entity>::iterator aBaseIter = aBaseList.begin();
 106   std::vector<Slvs_Entity>::iterator aMirrorIter = aMirrorList.begin();
 107   for (; aBaseIter != aBaseList.end(); aBaseIter++, aMirrorIter++) {
 108     // Make aMirrorEnt parameters to be symmetric with aBaseEnt
 109     makeMirrorEntity(*aBaseIter, *aMirrorIter, aStartEnd);
 110
 111     if (aBaseIter->type == SLVS_E_POINT_IN_2D) {
 112       aConstraint = Slvs_MakeConstraint(
 113           SLVS_E_UNKNOWN, myGroup->getId(), getType(), myGroup->getWorkplaneId(),
 114           0.0, aBaseIter->h, aMirrorIter->h, aMirrorLine.h, SLVS_E_UNKNOWN);
 115       aConstraint.h = myStorage->addConstraint(aConstraint);
 116       mySlvsConstraints.push_back(aConstraint.h);
 117     } else if (aBaseIter->type == SLVS_E_LINE_SEGMENT) {
 118       for (int i = 0; i < 2; i++) {
 119         aConstraint = Slvs_MakeConstraint(
 120             SLVS_E_UNKNOWN, myGroup->getId(), getType(), myGroup->getWorkplaneId(), 0.0,
 121             aBaseIter->point[i], aMirrorIter->point[i], aMirrorLine.h, SLVS_E_UNKNOWN);
 122         aConstraint.h = myStorage->addConstraint(aConstraint);
 123         mySlvsConstraints.push_back(aConstraint.h);
 124       }
 125     } else if (aBaseIter->type == SLVS_E_CIRCLE) {
 126       aConstraint = Slvs_MakeConstraint(
 127           SLVS_E_UNKNOWN, myGroup->getId(), getType(), myGroup->getWorkplaneId(), 0.0,
 128           aBaseIter->point[0], aMirrorIter->point[0], aMirrorLine.h, SLVS_E_UNKNOWN);
 129       aConstraint.h = myStorage->addConstraint(aConstraint);
 130       mySlvsConstraints.push_back(aConstraint.h);
 131       // Additional constraint for equal radii
 132       Slvs_Constraint anEqRadConstr = Slvs_MakeConstraint(
 133           SLVS_E_UNKNOWN, myGroup->getId(), SLVS_C_EQUAL_RADIUS, myGroup->getWorkplaneId(),
 134           0.0, SLVS_E_UNKNOWN, SLVS_E_UNKNOWN, aBaseIter->h, aMirrorIter->h);
 135       anEqRadConstr.h = myStorage->addConstraint(anEqRadConstr);
 136       mySlvsConstraints.push_back(anEqRadConstr.h);
 137     } else if (aBaseIter->type == SLVS_E_ARC_OF_CIRCLE) {
 138       // Workaround to avoid problems in SolveSpace.
 139       // The symmetry of two arcs will be done using symmetry of three points on these arcs:
 140       // start point, end point, and any other point on the arc
 141       Slvs_hEntity aBaseArcPoints[3] = {
 142           aBaseIter->point[1],
 143           aBaseIter->point[2],
 144           SLVS_E_UNKNOWN};
 145       Slvs_hEntity aMirrorArcPoints[3] = { // indices of points of arc, center corresponds center, first point corresponds last point
 146           aMirrorIter->point[2],
 147           aMirrorIter->point[1],
 148           SLVS_E_UNKNOWN};
 149
 150       Slvs_Entity aBothArcs[2] = {*aBaseIter, *aMirrorIter};
 151       Slvs_hEntity aBothMiddlePoints[2];
 152       for (int i = 0; i < 2; i++) {
 153         double x, y;
 154         calculateMiddlePoint(aBothArcs[i], 0.5, x, y);
 155         Slvs_Param aParamX = Slvs_MakeParam(SLVS_E_UNKNOWN, myGroup->getId(), x);
 156         Slvs_Param aParamY = Slvs_MakeParam(SLVS_E_UNKNOWN, myGroup->getId(), y);
 157         aParamX.h = myStorage->addParameter(aParamX);
 158         aParamY.h = myStorage->addParameter(aParamY);
 159         Slvs_Entity aPoint = Slvs_MakePoint2d(SLVS_E_UNKNOWN, myGroup->getId(),
 160             myGroup->getWorkplaneId(), aParamX.h, aParamY.h);
 161         aBothMiddlePoints[i] = myStorage->addEntity(aPoint);
 162         // additional constraint point-on-curve
 163         Slvs_Constraint aPonCircConstr = Slvs_MakeConstraint(
 164             SLVS_E_UNKNOWN, myGroup->getId(), SLVS_C_PT_ON_CIRCLE, myGroup->getWorkplaneId(),
 165             0.0, aBothMiddlePoints[i], SLVS_E_UNKNOWN, aBothArcs[i].h, SLVS_E_UNKNOWN);
 166         aPonCircConstr.h = myStorage->addConstraint(aPonCircConstr);
 167         mySlvsConstraints.push_back(aPonCircConstr.h);
 168         if (i == 0) {
 169           // additional constraint for the point to be in the middle of a base arc
 170           Slvs_Entity aLine1 = Slvs_MakeLineSegment(SLVS_E_UNKNOWN, myGroup->getId(),
 171               myGroup->getWorkplaneId(), aBothArcs[i].point[1], aBothMiddlePoints[i]);
 172           aLine1.h = myStorage->addEntity(aLine1);
 173           Slvs_Entity aLine2 = Slvs_MakeLineSegment(SLVS_E_UNKNOWN, myGroup->getId(),
 174               myGroup->getWorkplaneId(), aBothArcs[i].point[2], aBothMiddlePoints[i]);
 175           aLine2.h = myStorage->addEntity(aLine2);
 176           Slvs_Constraint aMiddleConstr = Slvs_MakeConstraint(SLVS_E_UNKNOWN, myGroup->getId(),
 177               SLVS_C_EQUAL_LENGTH_LINES, myGroup->getWorkplaneId(),
 178               0.0, SLVS_E_UNKNOWN, SLVS_E_UNKNOWN, aLine1.h, aLine2.h);
 179           aMiddleConstr.h = myStorage->addConstraint(aMiddleConstr);
 180           mySlvsConstraints.push_back(aMiddleConstr.h);
 181         }
 182       }
 183
 184       aBaseArcPoints[2] = aBothMiddlePoints[0];
 185       aMirrorArcPoints[2] = aBothMiddlePoints[1];
 186       for (int ind = 0; ind < 3; ind++) {
 187         Slvs_Constraint aConstraint = Slvs_MakeConstraint(
 188             SLVS_E_UNKNOWN, myGroup->getId(), getType(), myGroup->getWorkplaneId(), 0.0,
 189             aBaseArcPoints[ind], aMirrorArcPoints[ind], aMirrorLine.h, SLVS_E_UNKNOWN);
 190         aConstraint.h = myStorage->addConstraint(aConstraint);
 191         mySlvsConstraints.push_back(aConstraint.h);
 192       }
 193     }
 194   }
 195
 196   // Set the mirror line unchanged during constraint recalculation
 197   for (int i = 0; i < 2; i++) {
 198     if (myStorage->isPointFixed(aMirrorLine.point[i], aConstraint.h, true))
 199       continue;
 200     aConstraint = Slvs_MakeConstraint(
 201         SLVS_E_UNKNOWN, myGroup->getId(), SLVS_C_WHERE_DRAGGED, myGroup->getWorkplaneId(), 0.0,
 202         aMirrorLine.point[i], SLVS_E_UNKNOWN, SLVS_E_UNKNOWN, SLVS_E_UNKNOWN);
 203     aConstraint.h = myStorage->addConstraint(aConstraint);
 204     mySlvsConstraints.push_back(aConstraint.h);
 205   }
 206 }
 207
 208
 209 void SketchSolver_ConstraintMirror::update(ConstraintPtr theConstraint)
 210 {
 211   cleanErrorMsg();
 212   if (!theConstraint || theConstraint == myBaseConstraint) {
 213     AttributeRefListPtr aMirroredRefList = std::dynamic_pointer_cast<ModelAPI_AttributeRefList>(
 214         myBaseConstraint->attribute(SketchPlugin_Constraint::ENTITY_C()));
 215     if (aMirroredRefList->size() != myNumberOfObjects) {
 216       remove(myBaseConstraint);
 217       process();
 218       return;
 219     }
 220   }
 221   SketchSolver_Constraint::update();
 222 }
 223
 224 bool SketchSolver_ConstraintMirror::remove(ConstraintPtr theConstraint)
 225 {
 226   cleanErrorMsg();
 227   if (theConstraint && theConstraint != myBaseConstraint)
 228     return false;
 229   bool isFullyRemoved = true;
 230   std::vector<Slvs_hEntity>::iterator aCIter = mySlvsConstraints.begin();
 231   for (; aCIter != mySlvsConstraints.end(); aCIter++)
 232    isFullyRemoved = myStorage->removeConstraint(*aCIter) && isFullyRemoved;
 233   mySlvsConstraints.clear();
 234
 235   std::map<FeaturePtr, Slvs_hEntity>::iterator aFeatIt = myFeatureMap.begin();
 236   for (; aFeatIt != myFeatureMap.end(); aFeatIt++)
 237     myStorage->removeEntity(aFeatIt->second);
 238
 239   if (isFullyRemoved) {
 240     myFeatureMap.clear();
 241     myAttributeMap.clear();
 242     myValueMap.clear();
 243   } else
 244     cleanRemovedEntities();
 245   return true;
 246 }
 247
 248 bool SketchSolver_ConstraintMirror::checkAttributesChanged(ConstraintPtr theConstraint)
 249 {
 250   // First of all, check the mirror line is changed.
 251   // It may be changed to one of mirrored lines, which is already in this constraint
 252   // (this case is not marked as attribute changing)
 253   ConstraintPtr aConstraint = theConstraint ? theConstraint : myBaseConstraint;
 254   AttributeRefAttrPtr aRefAttr = std::dynamic_pointer_cast<ModelAPI_AttributeRefAttr>(
 255       aConstraint->attribute(SketchPlugin_Constraint::ENTITY_A()));
 256   if (!aRefAttr || !aRefAttr->isObject() || !aRefAttr->object())
 257     return true;
 258   FeaturePtr aMirrorLine = ModelAPI_Feature::feature(aRefAttr->object());
 259   if (!aMirrorLine)
 260     return true;
 261
 262   std::map<FeaturePtr, Slvs_hEntity>::iterator aMirrorIter = myFeatureMap.find(aMirrorLine);
 263   if (aMirrorIter == myFeatureMap.end())
 264     return true;
 265
 266   // Check the entity is not used as mirror line
 267   std::vector<Slvs_hConstraint>::iterator aCIter = mySlvsConstraints.begin();
 268   for (; aCIter != mySlvsConstraints.end(); aCIter++) {
 269     Slvs_Constraint aMirrorConstr = myStorage->getConstraint(*aCIter);
 270     if (aMirrorConstr.type != SLVS_C_SYMMETRIC_LINE)
 271       continue;
 272     if (aMirrorConstr.entityA != aMirrorIter->second)
 273       return true;
 274     else break; // check just one symmetric constraint
 275   }
 276
 277   // Base verification
 278   return SketchSolver_Constraint::checkAttributesChanged(theConstraint);
 279 }
 280
 281 void SketchSolver_ConstraintMirror::makeMirrorEntity(
 282     const Slvs_Entity& theBase,
 283     const Slvs_Entity& theMirror,
 284     const double theMirrorLine[]) const
 285 {
 286   Slvs_hEntity aBasePoint[4];
 287   Slvs_hEntity aMirrorPoint[4];
 288   for (int i = 0; i < 4; i++) {
 289     aBasePoint[i] = theBase.point[i];
 290     aMirrorPoint[i] = theMirror.point[i];
 291   }
 292   if (theBase.type == SLVS_E_ARC_OF_CIRCLE) {
 293     Slvs_hEntity aTmp = aMirrorPoint[2];
 294     aMirrorPoint[2] = aMirrorPoint[1];
 295     aMirrorPoint[1] = aTmp;
 296   }
 297   if (theBase.type == SLVS_E_POINT_IN_2D || theBase.type == SLVS_E_POINT_IN_3D) {
 298     aBasePoint[0] = theBase.h;
 299     aMirrorPoint[0] = theMirror.h;
 300   }
 301
 302   // Mirror line parameters
 303   std::shared_ptr<GeomAPI_XY> aLinePoints[2];
 304   for (int i = 0; i < 2; i++)
 305     aLinePoints[i] = std::shared_ptr<GeomAPI_XY>(
 306         new GeomAPI_XY(theMirrorLine[2*i], theMirrorLine[2*i+1]));
 307   // direction of a mirror line
 308   std::shared_ptr<GeomAPI_Dir2d> aDir = std::shared_ptr<GeomAPI_Dir2d>(
 309     new GeomAPI_Dir2d(aLinePoints[1]->added(aLinePoints[0]->multiplied(-1.0))));
 310   // orthogonal direction
 311   aDir = std::shared_ptr<GeomAPI_Dir2d>(new GeomAPI_Dir2d(aDir->y(), -aDir->x()));
 312
 313   for (int i = 0; i < 4; i++) {
 314     if (aBasePoint[i] == SLVS_E_UNKNOWN || aMirrorPoint[i] == SLVS_E_UNKNOWN)
 315       continue;
 316     Slvs_Entity aPointEnt = myStorage->getEntity(aBasePoint[i]);
 317     double aBaseX = myStorage->getParameter(aPointEnt.param[0]).val;
 318     double aBaseY = myStorage->getParameter(aPointEnt.param[1]).val;
 319     std::shared_ptr<GeomAPI_XY> aPoint = std::shared_ptr<GeomAPI_XY>(new GeomAPI_XY(aBaseX, aBaseY));
 320
 321     std::shared_ptr<GeomAPI_XY> aVec = std::shared_ptr<GeomAPI_XY>(
 322         new GeomAPI_XY(aPoint->x() - aLinePoints[0]->x(), aPoint->y() - aLinePoints[0]->y()));
 323     double aDist = aVec->dot(aDir->xy());
 324     aPoint = aPoint->added(aDir->xy()->multiplied(-2.0 * aDist));
 325
 326     Slvs_Entity aMirrorEnt = myStorage->getEntity(aMirrorPoint[i]);
 327     Slvs_Param aParam = Slvs_MakeParam(aMirrorEnt.param[0], myGroup->getId(), aPoint->x());
 328     myStorage->updateParameter(aParam);
 329     aParam = Slvs_MakeParam(aMirrorEnt.param[1], myGroup->getId(), aPoint->y());
 330     myStorage->updateParameter(aParam);
 331   }
 332 }
 333
 334 void SketchSolver_ConstraintMirror::adjustConstraint()
 335 {
 336   // Search mirror between middle points on the arcs and recompute their coordinates
 337   std::list<Slvs_Constraint> aPonCirc = myStorage->getConstraintsByType(SLVS_C_PT_ON_CIRCLE);
 338   if (aPonCirc.empty())
 339     return;
 340
 341   AttributeRefAttrPtr aMirLineAttr = std::dynamic_pointer_cast<ModelAPI_AttributeRefAttr>(
 342       myBaseConstraint->attribute(SketchPlugin_Constraint::ENTITY_A()));
 343   if (!aMirLineAttr || !aMirLineAttr->isInitialized() || !aMirLineAttr->isObject()) {
 344     myErrorMsg = SketchSolver_Error::NOT_INITIALIZED();
 345     return;
 346   }
 347   ResultConstructionPtr aRC =
 348       std::dynamic_pointer_cast<ModelAPI_ResultConstruction>(aMirLineAttr->object());
 349   FeaturePtr aFeature = aRC ? aRC->document()->feature(aRC) :
 350     std::dynamic_pointer_cast<ModelAPI_Feature>(aMirLineAttr->object());
 351   std::map<FeaturePtr, Slvs_hEntity>::iterator aMirLineIter = myFeatureMap.find(aFeature);
 352   if (aMirLineIter == myFeatureMap.end())
 353     return;
 354   Slvs_Entity aMirrorLine = myStorage->getEntity(aMirLineIter->second);
 355
 356   double aStartEnd[4];
 357   for (int i = 0; i < 2; i++) {
 358     Slvs_Entity aPoint = myStorage->getEntity(aMirrorLine.point[i]);
 359     for (int j = 0; j < 2; j++)
 360       aStartEnd[2*i+j] = myStorage->getParameter(aPoint.param[j]).val;
 361   }
 362
 363   Slvs_Constraint aMirror;
 364   std::vector<Slvs_hConstraint>::iterator aConstrIter = mySlvsConstraints.begin();
 365   for (; aConstrIter != mySlvsConstraints.end(); aConstrIter++) {
 366     aMirror = myStorage->getConstraint(*aConstrIter);
 367     if (aMirror.type != SLVS_C_SYMMETRIC_LINE)
 368       continue;
 369     Slvs_Constraint aPonCircA, aPonCircB;
 370     aPonCircA.h = SLVS_E_UNKNOWN;
 371     aPonCircB.h = SLVS_E_UNKNOWN;
 372     std::list<Slvs_Constraint>::iterator aPtIter = aPonCirc.begin();
 373     for (; aPtIter != aPonCirc.end(); aPtIter++) {
 374       if (aMirror.ptA == aPtIter->ptA)
 375         aPonCircA = *aPtIter;
 376       if (aMirror.ptB == aPtIter->ptA)
 377         aPonCircB = *aPtIter;
 378     }
 379     if (aPonCircA.h == SLVS_E_UNKNOWN || aPonCircB.h == SLVS_E_UNKNOWN)
 380       continue;
 381
 382     bool aNeedToResolve = myStorage->isNeedToResolve();
 383     // Calculate middle point for base arc and mirrored point on mirror arc
 384     Slvs_Entity aBaseArc = myStorage->getEntity(aPonCircA.entityA);
 385     Slvs_Entity aBasePoint = myStorage->getEntity(aPonCircA.ptA);
 386     Slvs_Param aParamX = myStorage->getParameter(aBasePoint.param[0]);
 387     Slvs_Param aParamY = myStorage->getParameter(aBasePoint.param[1]);
 388     calculateMiddlePoint(aBaseArc, 0.5, aParamX.val, aParamY.val);
 389     myStorage->updateParameter(aParamX);
 390     myStorage->updateParameter(aParamY);
 391     Slvs_Entity aMirrorArc = myStorage->getEntity(aPonCircB.entityA);
 392     Slvs_Entity aMirrorPoint = myStorage->getEntity(aPonCircB.ptA);
 393     aParamX = myStorage->getParameter(aMirrorPoint.param[0]);
 394     aParamY = myStorage->getParameter(aMirrorPoint.param[1]);
 395     calculateMiddlePoint(aMirrorArc, 0.5, aParamX.val, aParamY.val);
 396     myStorage->updateParameter(aParamX);
 397     myStorage->updateParameter(aParamY);
 398     // To avoid looped recalculations of sketch
 399     myStorage->setNeedToResolve(aNeedToResolve);
 400   }
 401 }