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       aList->push_back(myStorage->getEntity(anEntity));
  61     }
  62   }
  63
  64   if (theBaseEntities.size() > theMirrorEntities.size())
  65     myErrorMsg = SketchSolver_Error::NOT_INITIALIZED();
  66 }
  67
  68 void SketchSolver_ConstraintMirror::process()
  69 {
  70   cleanErrorMsg();
  71   if (!myBaseConstraint || !myStorage || myGroup == 0) {
  72     /// TODO: Put error message here
  73     return;
  74   }
  75   if (!mySlvsConstraints.empty()) // some data is changed, update constraint
  76     update(myBaseConstraint);
  77
  78   Slvs_Entity aMirrorLine;
  79   std::vector<Slvs_Entity> aBaseList;
  80   std::vector<Slvs_Entity> aMirrorList;
  81   getAttributes(aMirrorLine, aBaseList, aMirrorList);
  82   if (!myErrorMsg.empty())
  83     return;
  84
  85   if (aBaseList.size() != aMirrorList.size()) {
  86     myErrorMsg = SketchSolver_Error::INCORRECT_MIRROR_ATTRIBUTE();
  87     return;
  88   }
  89
  90   Slvs_Constraint aConstraint;
  91   // Get coordinates of mirror line points for speed up
  92   double aStartEnd[4];
  93   for (int i = 0; i < 2; i++) {
  94     Slvs_Entity aPoint = myStorage->getEntity(aMirrorLine.point[i]);
  95     for (int j = 0; j < 2; j++)
  96       aStartEnd[2*i+j] = myStorage->getParameter(aPoint.param[j]).val;
  97   }
  98
  99   std::vector<Slvs_Entity>::iterator aBaseIter = aBaseList.begin();
 100   std::vector<Slvs_Entity>::iterator aMirrorIter = aMirrorList.begin();
 101   for (; aBaseIter != aBaseList.end(); aBaseIter++, aMirrorIter++) {
 102     // Make aMirrorEnt parameters to be symmetric with aBaseEnt
 103     makeMirrorEntity(*aBaseIter, *aMirrorIter, aStartEnd);
 104
 105     if (aBaseIter->type == SLVS_E_POINT_IN_2D) {
 106       aConstraint = Slvs_MakeConstraint(
 107           SLVS_E_UNKNOWN, myGroup->getId(), getType(), myGroup->getWorkplaneId(),
 108           0.0, aBaseIter->h, aMirrorIter->h, aMirrorLine.h, SLVS_E_UNKNOWN);
 109       aConstraint.h = myStorage->addConstraint(aConstraint);
 110       mySlvsConstraints.push_back(aConstraint.h);
 111     } else if (aBaseIter->type == SLVS_E_LINE_SEGMENT) {
 112       for (int i = 0; i < 2; i++) {
 113         aConstraint = Slvs_MakeConstraint(
 114             SLVS_E_UNKNOWN, myGroup->getId(), getType(), myGroup->getWorkplaneId(), 0.0,
 115             aBaseIter->point[i], aMirrorIter->point[i], aMirrorLine.h, SLVS_E_UNKNOWN);
 116         aConstraint.h = myStorage->addConstraint(aConstraint);
 117         mySlvsConstraints.push_back(aConstraint.h);
 118       }
 119     } else if (aBaseIter->type == SLVS_E_CIRCLE) {
 120       aConstraint = Slvs_MakeConstraint(
 121           SLVS_E_UNKNOWN, myGroup->getId(), getType(), myGroup->getWorkplaneId(), 0.0,
 122           aBaseIter->point[0], aMirrorIter->point[0], aMirrorLine.h, SLVS_E_UNKNOWN);
 123       aConstraint.h = myStorage->addConstraint(aConstraint);
 124       mySlvsConstraints.push_back(aConstraint.h);
 125       // Additional constraint for equal radii
 126       Slvs_Constraint anEqRadConstr = Slvs_MakeConstraint(
 127           SLVS_E_UNKNOWN, myGroup->getId(), SLVS_C_EQUAL_RADIUS, myGroup->getWorkplaneId(),
 128           0.0, SLVS_E_UNKNOWN, SLVS_E_UNKNOWN, aBaseIter->h, aMirrorIter->h);
 129       anEqRadConstr.h = myStorage->addConstraint(anEqRadConstr);
 130       mySlvsConstraints.push_back(anEqRadConstr.h);
 131     } else if (aBaseIter->type == SLVS_E_ARC_OF_CIRCLE) {
 132       // Workaround to avoid problems in SolveSpace.
 133       // The symmetry of two arcs will be done using symmetry of three points on these arcs:
 134       // start point, end point, and any other point on the arc
 135       Slvs_hEntity aBaseArcPoints[3] = {
 136           aBaseIter->point[1],
 137           aBaseIter->point[2],
 138           SLVS_E_UNKNOWN};
 139       Slvs_hEntity aMirrorArcPoints[3] = { // indices of points of arc, center corresponds center, first point corresponds last point
 140           aMirrorIter->point[2],
 141           aMirrorIter->point[1],
 142           SLVS_E_UNKNOWN};
 143
 144       Slvs_Entity aBothArcs[2] = {*aBaseIter, *aMirrorIter};
 145       Slvs_hEntity aBothMiddlePoints[2];
 146       for (int i = 0; i < 2; i++) {
 147         double x, y;
 148         calculateMiddlePoint(aBothArcs[i], 0.5, x, y);
 149         Slvs_Param aParamX = Slvs_MakeParam(SLVS_E_UNKNOWN, myGroup->getId(), x);
 150         Slvs_Param aParamY = Slvs_MakeParam(SLVS_E_UNKNOWN, myGroup->getId(), y);
 151         aParamX.h = myStorage->addParameter(aParamX);
 152         aParamY.h = myStorage->addParameter(aParamY);
 153         Slvs_Entity aPoint = Slvs_MakePoint2d(SLVS_E_UNKNOWN, myGroup->getId(),
 154             myGroup->getWorkplaneId(), aParamX.h, aParamY.h);
 155         aBothMiddlePoints[i] = myStorage->addEntity(aPoint);
 156         // additional constraint point-on-curve
 157         Slvs_Constraint aPonCircConstr = Slvs_MakeConstraint(
 158             SLVS_E_UNKNOWN, myGroup->getId(), SLVS_C_PT_ON_CIRCLE, myGroup->getWorkplaneId(),
 159             0.0, aBothMiddlePoints[i], SLVS_E_UNKNOWN, aBothArcs[i].h, SLVS_E_UNKNOWN);
 160         aPonCircConstr.h = myStorage->addConstraint(aPonCircConstr);
 161         mySlvsConstraints.push_back(aPonCircConstr.h);
 162       }
 163
 164       aBaseArcPoints[2] = aBothMiddlePoints[0];
 165       aMirrorArcPoints[2] = aBothMiddlePoints[1];
 166       for (int ind = 0; ind < 3; ind++) {
 167         Slvs_Constraint aConstraint = Slvs_MakeConstraint(
 168             SLVS_E_UNKNOWN, myGroup->getId(), getType(), myGroup->getWorkplaneId(), 0.0,
 169             aBaseArcPoints[ind], aMirrorArcPoints[ind], aMirrorLine.h, SLVS_E_UNKNOWN);
 170         aConstraint.h = myStorage->addConstraint(aConstraint);
 171         mySlvsConstraints.push_back(aConstraint.h);
 172       }
 173     }
 174   }
 175
 176   // Set the mirror line unchanged during constraint recalculation
 177   for (int i = 0; i < 2; i++) {
 178     aConstraint = Slvs_MakeConstraint(
 179         SLVS_E_UNKNOWN, myGroup->getId(), SLVS_C_WHERE_DRAGGED, myGroup->getWorkplaneId(), 0.0,
 180         aMirrorLine.point[i], SLVS_E_UNKNOWN, SLVS_E_UNKNOWN, SLVS_E_UNKNOWN);
 181     aConstraint.h = myStorage->addConstraint(aConstraint);
 182     mySlvsConstraints.push_back(aConstraint.h);
 183   }
 184 }
 185
 186
 187 void SketchSolver_ConstraintMirror::update(ConstraintPtr theConstraint)
 188 {
 189   cleanErrorMsg();
 190   if (!theConstraint || theConstraint == myBaseConstraint) {
 191     AttributeRefListPtr aMirroredRefList = std::dynamic_pointer_cast<ModelAPI_AttributeRefList>(
 192         myBaseConstraint->attribute(SketchPlugin_Constraint::ENTITY_C()));
 193     if (aMirroredRefList->size() != myNumberOfObjects) {
 194       remove(myBaseConstraint);
 195       process();
 196     }
 197   }
 198   SketchSolver_Constraint::update();
 199 }
 200
 201 bool SketchSolver_ConstraintMirror::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   if (isFullyRemoved) {
 213     myFeatureMap.clear();
 214     myAttributeMap.clear();
 215     myValueMap.clear();
 216   } else
 217     cleanRemovedEntities();
 218   return true;
 219 }
 220
 221 void SketchSolver_ConstraintMirror::makeMirrorEntity(
 222     const Slvs_Entity& theBase,
 223     const Slvs_Entity& theMirror,
 224     const double theMirrorLine[]) const
 225 {
 226   Slvs_hEntity aBasePoint[4];
 227   Slvs_hEntity aMirrorPoint[4];
 228   for (int i = 0; i < 4; i++) {
 229     aBasePoint[i] = theBase.point[i];
 230     aMirrorPoint[i] = theMirror.point[i];
 231   }
 232   if (theBase.type == SLVS_E_ARC_OF_CIRCLE) {
 233     Slvs_hEntity aTmp = aMirrorPoint[2];
 234     aMirrorPoint[2] = aMirrorPoint[1];
 235     aMirrorPoint[1] = aTmp;
 236   }
 237   if (theBase.type == SLVS_E_POINT_IN_2D || theBase.type == SLVS_E_POINT_IN_3D) {
 238     aBasePoint[0] = theBase.h;
 239     aMirrorPoint[0] = theMirror.h;
 240   }
 241
 242   // Mirror line parameters
 243   std::shared_ptr<GeomAPI_XY> aLinePoints[2];
 244   for (int i = 0; i < 2; i++)
 245     aLinePoints[i] = std::shared_ptr<GeomAPI_XY>(
 246         new GeomAPI_XY(theMirrorLine[2*i], theMirrorLine[2*i+1]));
 247   // direction of a mirror line
 248   std::shared_ptr<GeomAPI_Dir2d> aDir = std::shared_ptr<GeomAPI_Dir2d>(
 249     new GeomAPI_Dir2d(aLinePoints[1]->added(aLinePoints[0]->multiplied(-1.0))));
 250   // orthogonal direction
 251   aDir = std::shared_ptr<GeomAPI_Dir2d>(new GeomAPI_Dir2d(aDir->y(), -aDir->x()));
 252
 253   for (int i = 0; i < 4; i++) {
 254     if (aBasePoint[i] == SLVS_E_UNKNOWN || aMirrorPoint[i] == SLVS_E_UNKNOWN)
 255       continue;
 256     Slvs_Entity aPointEnt = myStorage->getEntity(aBasePoint[i]);
 257     double aBaseX = myStorage->getParameter(aPointEnt.param[0]).val;
 258     double aBaseY = myStorage->getParameter(aPointEnt.param[1]).val;
 259     std::shared_ptr<GeomAPI_XY> aPoint = std::shared_ptr<GeomAPI_XY>(new GeomAPI_XY(aBaseX, aBaseY));
 260
 261     std::shared_ptr<GeomAPI_XY> aVec = std::shared_ptr<GeomAPI_XY>(
 262         new GeomAPI_XY(aPoint->x() - aLinePoints[0]->x(), aPoint->y() - aLinePoints[0]->y()));
 263     double aDist = aVec->dot(aDir->xy());
 264     aPoint = aPoint->added(aDir->xy()->multiplied(-2.0 * aDist));
 265
 266     Slvs_Entity aMirrorEnt = myStorage->getEntity(aMirrorPoint[i]);
 267     Slvs_Param aParam = Slvs_MakeParam(aMirrorEnt.param[0], myGroup->getId(), aPoint->x());
 268     myStorage->updateParameter(aParam);
 269     aParam = Slvs_MakeParam(aMirrorEnt.param[1], myGroup->getId(), aPoint->y());
 270     myStorage->updateParameter(aParam);
 271   }
 272 }
 273
 274 void SketchSolver_ConstraintMirror::adjustConstraint()
 275 {
 276   // Search mirror between middle points on the arcs and recompute their coordinates
 277   std::list<Slvs_Constraint> aPonCirc = myStorage->getConstraintsByType(SLVS_C_PT_ON_CIRCLE);
 278   if (aPonCirc.empty())
 279     return;
 280
 281   AttributeRefAttrPtr aMirLineAttr = std::dynamic_pointer_cast<ModelAPI_AttributeRefAttr>(
 282       myBaseConstraint->attribute(SketchPlugin_Constraint::ENTITY_A()));
 283   if (!aMirLineAttr || !aMirLineAttr->isInitialized() || !aMirLineAttr->isObject()) {
 284     myErrorMsg = SketchSolver_Error::NOT_INITIALIZED();
 285     return;
 286   }
 287   ResultConstructionPtr aRC =
 288       std::dynamic_pointer_cast<ModelAPI_ResultConstruction>(aMirLineAttr->object());
 289   FeaturePtr aFeature = aRC ? aRC->document()->feature(aRC) :
 290     std::dynamic_pointer_cast<ModelAPI_Feature>(aMirLineAttr->object());
 291   std::map<FeaturePtr, Slvs_hEntity>::iterator aMirLineIter = myFeatureMap.find(aFeature);
 292   if (aMirLineIter == myFeatureMap.end())
 293     return;
 294   Slvs_Entity aMirrorLine = myStorage->getEntity(aMirLineIter->second);
 295
 296   double aStartEnd[4];
 297   for (int i = 0; i < 2; i++) {
 298     Slvs_Entity aPoint = myStorage->getEntity(aMirrorLine.point[i]);
 299     for (int j = 0; j < 2; j++)
 300       aStartEnd[2*i+j] = myStorage->getParameter(aPoint.param[j]).val;
 301   }
 302
 303   Slvs_Constraint aMirror;
 304   std::vector<Slvs_hConstraint>::iterator aConstrIter = mySlvsConstraints.begin();
 305   for (; aConstrIter != mySlvsConstraints.end(); aConstrIter++) {
 306     aMirror = myStorage->getConstraint(*aConstrIter);
 307     if (aMirror.type != SLVS_C_SYMMETRIC_LINE)
 308       continue;
 309     Slvs_Constraint aPonCircA, aPonCircB;
 310     aPonCircA.h = SLVS_E_UNKNOWN;
 311     aPonCircB.h = SLVS_E_UNKNOWN;
 312     std::list<Slvs_Constraint>::iterator aPtIter = aPonCirc.begin();
 313     for (; aPtIter != aPonCirc.end(); aPtIter++) {
 314       if (aMirror.ptA == aPtIter->ptA)
 315         aPonCircA = *aPtIter;
 316       if (aMirror.ptB == aPtIter->ptA)
 317         aPonCircB = *aPtIter;
 318     }
 319     if (aPonCircA.h == SLVS_E_UNKNOWN || aPonCircB.h == SLVS_E_UNKNOWN)
 320       continue;
 321
 322     // Calculate middle point for base arc and mirrored point on mirror arc
 323     Slvs_Entity aBaseArc = myStorage->getEntity(aPonCircA.entityA);
 324     Slvs_Entity aBasePoint = myStorage->getEntity(aPonCircA.ptA);
 325     Slvs_Param aParamX = myStorage->getParameter(aBasePoint.param[0]);
 326     Slvs_Param aParamY = myStorage->getParameter(aBasePoint.param[1]);
 327     calculateMiddlePoint(aBaseArc, 0.5, aParamX.val, aParamY.val);
 328     myStorage->updateParameter(aParamX);
 329     myStorage->updateParameter(aParamY);
 330     Slvs_Entity aMirrorPoint = myStorage->getEntity(aPonCircB.ptA);
 331     makeMirrorEntity(aBasePoint, aMirrorPoint, aStartEnd);
 332   }
 333 }