src/SketchSolver/SketchSolver_ConstraintRigid.cpp

   1 #include <SketchSolver_ConstraintRigid.h>
   2 #include <SketchSolver_Error.h>
   3 #include <SketchSolver_Group.h>
   4
   5 #include <SketchPlugin_Arc.h>
   6 #include <SketchPlugin_Circle.h>
   7 #include <SketchPlugin_ConstraintRigid.h>
   8
   9 #include <GeomAPI_Pnt2d.h>
  10 #include <GeomAPI_XY.h>
  11 #include <GeomDataAPI_Point2D.h>
  12 #include <ModelAPI_AttributeDouble.h>
  13
  14 SketchSolver_ConstraintRigid::SketchSolver_ConstraintRigid(FeaturePtr theFeature)
  15   : SketchSolver_Constraint(),
  16     myBaseFeature(theFeature)
  17 {
  18   process();
  19 }
  20
  21 void SketchSolver_ConstraintRigid::process()
  22 {
  23   cleanErrorMsg();
  24   if ((!myBaseConstraint && !myBaseFeature) || !myStorage || myGroup == 0) {
  25     /// TODO: Put error message here
  26     return;
  27   }
  28   if (!mySlvsConstraints.empty()) // some data is changed, update constraint
  29     update(myBaseConstraint);
  30
  31   double aValue;
  32   std::vector<Slvs_hEntity> anEntities;
  33   getAttributes(aValue, anEntities);
  34   if (!myErrorMsg.empty())
  35     return;
  36
  37   Slvs_Constraint aConstraint;
  38   std::vector<Slvs_hConstraint>::iterator aConstrIter = mySlvsConstraints.begin();
  39   bool isEmpty = aConstrIter == mySlvsConstraints.end();
  40
  41   // Check the fixed entity is an arc
  42   if (isEmpty) {
  43     if (!myFeatureMap.empty() && myFeatureMap.begin()->first->getKind() == SketchPlugin_Arc::ID()) {
  44       Slvs_Entity anArc = myStorage->getEntity(myFeatureMap.begin()->second);
  45       fixArc(anArc);
  46       return;
  47     }
  48   }
  49
  50   std::vector<Slvs_hEntity>::const_iterator anEntIter = anEntities.begin();
  51   for (; anEntIter != anEntities.end(); anEntIter++) {
  52     if (*anEntIter == SLVS_E_UNKNOWN)
  53       continue;
  54     Slvs_hConstraint aConstrID = myStorage->isPointFixed(*anEntIter);
  55     bool isForceUpdate = (aConstrID != SLVS_E_UNKNOWN && !myBaseConstraint);
  56     if (isEmpty && !isForceUpdate) { // create new constraint
  57       if (aConstrID != SLVS_E_UNKNOWN)
  58         continue; // the coincident point is already fixed
  59       aConstraint = Slvs_MakeConstraint(SLVS_E_UNKNOWN, myGroup->getId(), getType(), myGroup->getWorkplaneId(),
  60           aValue, *anEntIter, SLVS_E_UNKNOWN, SLVS_E_UNKNOWN, SLVS_E_UNKNOWN);
  61       aConstraint.h = myStorage->addConstraint(aConstraint);
  62       mySlvsConstraints.push_back(aConstraint.h);
  63       if (!myBaseConstraint)
  64         myStorage->addTemporaryConstraint(aConstraint.h);
  65     } else { // update already existent constraint
  66       if (aConstrID == SLVS_E_UNKNOWN || myBaseConstraint)
  67         aConstrID = *aConstrIter;
  68       aConstraint = myStorage->getConstraint(aConstrID);
  69       aConstraint.ptA = *anEntIter;
  70       myStorage->addConstraint(aConstraint);
  71       if (!myBaseConstraint)
  72         myStorage->addTemporaryConstraint(aConstraint.h);
  73       if (!isEmpty) {
  74         aConstrIter++;
  75         isEmpty = aConstrIter == mySlvsConstraints.end();
  76       }
  77     }
  78   }
  79
  80   if (!myFeatureMap.empty() && myFeatureMap.begin()->first->getKind() == SketchPlugin_Circle::ID()) {
  81     // Fix radius of a circle
  82     AttributeDoublePtr aRadiusAttr = std::dynamic_pointer_cast<ModelAPI_AttributeDouble>(
  83         myFeatureMap.begin()->first->attribute(SketchPlugin_Circle::RADIUS_ID()));
  84     aConstraint = Slvs_MakeConstraint(SLVS_E_UNKNOWN, myGroup->getId(), SLVS_C_DIAMETER, myGroup->getWorkplaneId(),
  85       aRadiusAttr->value() * 2.0, SLVS_E_UNKNOWN, SLVS_E_UNKNOWN, myFeatureMap.begin()->second, SLVS_E_UNKNOWN);
  86     aConstraint.h = myStorage->addConstraint(aConstraint);
  87     mySlvsConstraints.push_back(aConstraint.h);
  88     if (!myBaseConstraint)
  89       myStorage->addTemporaryConstraint(aConstraint.h);
  90   }
  91 }
  92
  93
  94 void SketchSolver_ConstraintRigid::getAttributes(
  95     double& theValue,
  96     std::vector<Slvs_hEntity>& theAttributes)
  97 {
  98   theValue = 0.0;
  99   int aType = SLVS_E_UNKNOWN; // type of created entity
 100   Slvs_hEntity anEntityID = SLVS_E_UNKNOWN;
 101   if (myBaseConstraint) {
 102     // Get the attribute of constraint
 103     AttributeRefAttrPtr aRefAttr = std::dynamic_pointer_cast<ModelAPI_AttributeRefAttr>(
 104         myBaseConstraint->attribute(SketchPlugin_ConstraintRigid::ENTITY_A()));
 105     if (!aRefAttr || !aRefAttr->isInitialized()) {
 106       myErrorMsg = SketchSolver_Error::NOT_INITIALIZED();
 107       return;
 108     }
 109     anEntityID = myGroup->getAttributeId(aRefAttr);
 110     if (anEntityID == SLVS_E_UNKNOWN)
 111       anEntityID = changeEntity(aRefAttr, aType);
 112   } else {
 113     anEntityID = myGroup->getFeatureId(myBaseFeature);
 114     if (anEntityID == SLVS_E_UNKNOWN)
 115       anEntityID = changeEntity(myBaseFeature, aType);
 116     else
 117       myFeatureMap[myBaseFeature] = anEntityID;
 118   }
 119
 120   // Check the entity is complex
 121   Slvs_Entity anEntity = myStorage->getEntity(anEntityID);
 122   if (anEntity.point[0] != SLVS_E_UNKNOWN) {
 123     for (int i = 0; i < 4 && anEntity.point[i]; i++)
 124       theAttributes.push_back(anEntity.point[i]);
 125   } else // simple entity
 126     theAttributes.push_back(anEntityID);
 127 }
 128
 129 void SketchSolver_ConstraintRigid::adjustConstraint()
 130 {
 131   if (myFeatureMap.empty() || (
 132       myFeatureMap.begin()->first->getKind() != SketchPlugin_Arc::ID() &&
 133       myFeatureMap.begin()->first->getKind() != SketchPlugin_Circle::ID()))
 134     return;
 135   FeaturePtr aFeature = myFeatureMap.begin()->first;
 136
 137   // Search radius constraints and update them
 138   Slvs_Constraint aConstraint;
 139   std::vector<Slvs_hConstraint>::iterator aCIter = mySlvsConstraints.begin();
 140   for (; aCIter != mySlvsConstraints.end(); aCIter++) {
 141     aConstraint = myStorage->getConstraint(*aCIter);
 142     if (aConstraint.type != SLVS_C_DIAMETER)
 143       continue;
 144     double aRadius = 0.0;
 145     if (aFeature->getKind() == SketchPlugin_Arc::ID()) {
 146       std::shared_ptr<GeomAPI_Pnt2d> aCenter = std::dynamic_pointer_cast<GeomDataAPI_Point2D>(
 147         aFeature->attribute(SketchPlugin_Arc::CENTER_ID()))->pnt();
 148       std::shared_ptr<GeomAPI_Pnt2d> aStart = std::dynamic_pointer_cast<GeomDataAPI_Point2D>(
 149         aFeature->attribute(SketchPlugin_Arc::START_ID()))->pnt();
 150       aRadius = aCenter->distance(aStart);
 151     } else {
 152       aRadius = std::dynamic_pointer_cast<ModelAPI_AttributeDouble>(
 153           aFeature->attribute(SketchPlugin_Circle::RADIUS_ID()))->value();
 154     }
 155
 156     aConstraint.valA = aRadius * 2.0;
 157     *aCIter = myStorage->updateConstraint(aConstraint);
 158   }
 159 }
 160
 161
 162 bool SketchSolver_ConstraintRigid::remove(ConstraintPtr theConstraint)
 163 {
 164   cleanErrorMsg();
 165   if (theConstraint && theConstraint != myBaseConstraint)
 166     return false;
 167   bool isFullyRemoved = true;
 168   std::vector<Slvs_hConstraint>::iterator aCIter = mySlvsConstraints.begin();
 169   for (; aCIter != mySlvsConstraints.end(); aCIter++)
 170     isFullyRemoved = myStorage->removeConstraint(*aCIter) && isFullyRemoved;
 171
 172   if (isFullyRemoved) {
 173     myFeatureMap.clear();
 174     myAttributeMap.clear();
 175     myValueMap.clear();
 176   } else
 177     cleanRemovedEntities();
 178   return true;
 179 }
 180
 181
 182 void SketchSolver_ConstraintRigid::fixArc(const Slvs_Entity& theArc)
 183 {
 184   Slvs_Constraint aConstraint;
 185   Slvs_hConstraint aConstrID = myStorage->isPointFixed(theArc.point[0]);
 186   int aPointsToFix = 2; // number of fixed points for the arc
 187   if (aConstrID != SLVS_E_UNKNOWN)
 188     aPointsToFix--;
 189
 190   // Radius of the arc
 191   FeaturePtr aFeature = myFeatureMap.begin()->first;
 192   std::shared_ptr<GeomAPI_Pnt2d> aCenter = std::dynamic_pointer_cast<GeomDataAPI_Point2D>(
 193     aFeature->attribute(SketchPlugin_Arc::CENTER_ID()))->pnt();
 194   std::shared_ptr<GeomAPI_Pnt2d> aStart = std::dynamic_pointer_cast<GeomDataAPI_Point2D>(
 195     aFeature->attribute(SketchPlugin_Arc::START_ID()))->pnt();
 196   double aRadius = aCenter->distance(aStart);
 197
 198   // Update end point of the arc to be on a curve
 199   std::shared_ptr<GeomAPI_Pnt2d> anEnd = std::dynamic_pointer_cast<GeomDataAPI_Point2D>(
 200     aFeature->attribute(SketchPlugin_Arc::END_ID()))->pnt();
 201   double aDistance = anEnd->distance(aCenter);
 202   std::shared_ptr<GeomAPI_XY> aDir = anEnd->xy()->decreased(aCenter->xy());
 203   if (aDistance < tolerance)
 204     aDir = aStart->xy()->decreased(aCenter->xy())->multiplied(-1.0);
 205   else
 206     aDir = aDir->multiplied(aRadius / aDistance);
 207   double xy[2] = {aCenter->x() + aDir->x(), aCenter->y() + aDir->y()};
 208   Slvs_Entity aEndPoint = myStorage->getEntity(theArc.point[2]);
 209   for (int i = 0; i < 2; i++) {
 210     Slvs_Param aParam = myStorage->getParameter(aEndPoint.param[i]);
 211     aParam.val = xy[i];
 212     myStorage->updateParameter(aParam);
 213   }
 214
 215   for (int i = 1; aPointsToFix > 0; i++, aPointsToFix--) {
 216     aConstrID = myStorage->isPointFixed(theArc.point[i]);
 217     if (aConstrID != SLVS_E_UNKNOWN)
 218       continue; // the coincident point is already fixed
 219     aConstraint = Slvs_MakeConstraint(SLVS_E_UNKNOWN, myGroup->getId(), getType(), myGroup->getWorkplaneId(),
 220         0.0, theArc.point[i], SLVS_E_UNKNOWN, SLVS_E_UNKNOWN, SLVS_E_UNKNOWN);
 221     aConstraint.h = myStorage->addConstraint(aConstraint);
 222     mySlvsConstraints.push_back(aConstraint.h);
 223     if (!myBaseConstraint)
 224       myStorage->addTemporaryConstraint(aConstraint.h);
 225   }
 226
 227   // Fix radius of the arc
 228   bool isExists = false;
 229   std::list<Slvs_Constraint> aDiamConstraints = myStorage->getConstraintsByType(SLVS_C_DIAMETER);
 230   std::list<Slvs_Constraint>::iterator anIt = aDiamConstraints.begin();
 231   for (; anIt != aDiamConstraints.end() && !isExists; anIt)
 232     if (anIt->entityA == myFeatureMap.begin()->second)
 233       isExists = true;
 234   if (!isExists) {
 235     aConstraint = Slvs_MakeConstraint(SLVS_E_UNKNOWN, myGroup->getId(), SLVS_C_DIAMETER, myGroup->getWorkplaneId(),
 236       aRadius * 2.0, SLVS_E_UNKNOWN, SLVS_E_UNKNOWN, myFeatureMap.begin()->second, SLVS_E_UNKNOWN);
 237     aConstraint.h = myStorage->addConstraint(aConstraint);
 238     mySlvsConstraints.push_back(aConstraint.h);
 239     if (!myBaseConstraint)
 240       myStorage->addTemporaryConstraint(aConstraint.h);
 241   }
 242 }
 243