src/SketchSolver/SketchSolver_ConstraintMultiTranslation.cpp

   1 #include <SketchSolver_ConstraintMultiTranslation.h>
   2 #include <SketchSolver_Error.h>
   3 #include <SketchSolver_Manager.h>
   4
   5 #include <SketchPlugin_MultiTranslation.h>
   6
   7 #include <ModelAPI_AttributeString.h>
   8
   9 #include <GeomDataAPI_Point2D.h>
  10
  11 void SketchSolver_ConstraintMultiTranslation::getAttributes(
  12     EntityWrapperPtr& theStartPoint, EntityWrapperPtr& theEndPoint,
  13     bool& theFullValue, std::list<EntityWrapperPtr>& theEntities)
  14 {
  15   DataPtr aData = myBaseConstraint->data();
  16   AttributePtr aStartPointAttr = aData->attribute(SketchPlugin_MultiTranslation::START_POINT_ID());
  17   AttributePtr aEndPointAttr = aData->attribute(SketchPlugin_MultiTranslation::END_POINT_ID());
  18   if (!aStartPointAttr || !aStartPointAttr->isInitialized() ||
  19       !aEndPointAttr || !aEndPointAttr->isInitialized()) {
  20     myErrorMsg = SketchSolver_Error::NOT_INITIALIZED();
  21     return;
  22   }
  23
  24   myType = CONSTRAINT_MULTI_TRANSLATION;
  25
  26   myStorage->update(aStartPointAttr);
  27   theStartPoint = myStorage->entity(aStartPointAttr);
  28   myStorage->update(aEndPointAttr);
  29   theEndPoint = myStorage->entity(aEndPointAttr);
  30
  31   AttributeStringPtr aMethodTypeAttr = aData->string(SketchPlugin_MultiTranslation::VALUE_TYPE());
  32   theFullValue = aMethodTypeAttr->value() != "SingleValue";
  33
  34   getEntities(theEntities);
  35 }
  36
  37 void SketchSolver_ConstraintMultiTranslation::process()
  38 {
  39   cleanErrorMsg();
  40   if (!myBaseConstraint || !myStorage || myGroupID == GID_UNKNOWN) {
  41     /// TODO: Put error message here
  42     return;
  43   }
  44
  45   EntityWrapperPtr aStartPoint, aEndPoint;
  46   bool aFullValue;
  47   std::list<EntityWrapperPtr> aBaseEntities;
  48   getAttributes(aStartPoint, aEndPoint, aFullValue, aBaseEntities);
  49   if (!myErrorMsg.empty())
  50     return;
  51
  52   AttributeStringPtr aMethodTypeAttr =
  53       myBaseConstraint->data()->string(SketchPlugin_MultiTranslation::VALUE_TYPE());
  54
  55   BuilderPtr aBuilder = SketchSolver_Manager::instance()->builder();
  56   std::list<ConstraintWrapperPtr> aTransConstraints;
  57
  58   std::list<EntityWrapperPtr>::iterator anEntIt = aBaseEntities.begin();
  59   for (; anEntIt != aBaseEntities.end(); ++anEntIt) {
  60     std::list<ConstraintWrapperPtr> aNewConstraints =
  61         aBuilder->createConstraint(myBaseConstraint, myGroupID, mySketchID, myType,
  62         0.0, aFullValue, aStartPoint, aEndPoint, std::list<EntityWrapperPtr>(1, *anEntIt));
  63     aTransConstraints.insert(aTransConstraints.end(), aNewConstraints.begin(), aNewConstraints.end());
  64   }
  65
  66   myStorage->addConstraint(myBaseConstraint, aTransConstraints);
  67
  68   myAdjusted = false;
  69   adjustConstraint();
  70 }
  71
  72 const std::string& SketchSolver_ConstraintMultiTranslation::nameNbObjects()
  73 {
  74   return SketchPlugin_MultiTranslation::NUMBER_OF_OBJECTS_ID();
  75 }
  76
  77 void SketchSolver_ConstraintMultiTranslation::updateLocal()
  78 {
  79   DataPtr aData = myBaseConstraint->data();
  80   AttributePoint2DPtr aStartPointAttribute = GeomDataAPI_Point2D::getPoint2D(aData,
  81                                       SketchPlugin_MultiTranslation::START_POINT_ID());
  82   AttributePoint2DPtr anEndPointAttribute = GeomDataAPI_Point2D::getPoint2D(aData,
  83                                       SketchPlugin_MultiTranslation::END_POINT_ID());
  84   AttributeStringPtr aMethodTypeAttr = aData->string(SketchPlugin_MultiTranslation::VALUE_TYPE());
  85   bool aFullValue = aMethodTypeAttr->value() != "SingleValue";
  86
  87   bool aStartPointChanged = aStartPointAttribute != myStartPointAttribute;
  88   bool anEndPointChanged = anEndPointAttribute != myEndPointAttribute;
  89   bool isMethodChanged = aFullValue != myIsFullValue;
  90
  91   if (aStartPointChanged)
  92     myStartPointAttribute = aStartPointAttribute;
  93   if (aStartPointChanged)
  94     myEndPointAttribute = anEndPointAttribute;
  95   if (isMethodChanged)
  96     myIsFullValue = aFullValue;
  97
  98   if (aStartPointChanged || anEndPointChanged || isMethodChanged) {
  99     DataPtr aData = myBaseConstraint->data();
 100     std::list<ConstraintWrapperPtr> aConstraints = myStorage->constraint(myBaseConstraint);
 101     std::list<ConstraintWrapperPtr>::const_iterator anIt = aConstraints.begin(),
 102                                                     aLast = aConstraints.end();
 103     std::list<EntityWrapperPtr> anEntities;
 104     for (; anIt != aLast; anIt++) {
 105       ConstraintWrapperPtr aConstraint = *anIt;
 106       aConstraint->setIsFullValue(myIsFullValue);
 107       anEntities.clear();
 108
 109       const std::list<EntityWrapperPtr>& aConstraintEntities = aConstraint->entities();
 110       std::list<EntityWrapperPtr>::const_iterator aSIt = aConstraintEntities.begin(),
 111                                                   aSLast = aConstraintEntities.end();
 112       EntityWrapperPtr aStartEntity = *aSIt++;
 113       if (aStartPointChanged) {
 114         AttributePtr aStartPointAttr = aData->attribute(SketchPlugin_MultiTranslation::START_POINT_ID());
 115         myStorage->update(aStartPointAttr);
 116         aStartEntity = myStorage->entity(aStartPointAttr);
 117       }
 118       anEntities.push_back(aStartEntity);
 119
 120       EntityWrapperPtr anEndEntity = *aSIt++;
 121       if (anEndPointChanged) {
 122         AttributePtr anEndPointAttr = aData->attribute(SketchPlugin_MultiTranslation::END_POINT_ID());
 123         myStorage->update(anEndPointAttr);
 124         anEndEntity = myStorage->entity(anEndPointAttr);
 125       }
 126       anEntities.push_back(anEndEntity);
 127
 128       for (; aSIt != aSLast; ++aSIt)
 129         anEntities.push_back(*aSIt);
 130
 131       aConstraint->setEntities(anEntities);
 132     }
 133     myStorage->addConstraint(myBaseConstraint, aConstraints);
 134
 135     myAdjusted = false;
 136   }
 137 }
 138
 139 void SketchSolver_ConstraintMultiTranslation::adjustConstraint()
 140 {
 141   if (myAdjusted)
 142     return;
 143
 144   // Obtain delta between start and end points of translation
 145   EntityWrapperPtr aStart = myStorage->entity(
 146       myBaseConstraint->attribute(SketchPlugin_MultiTranslation::START_POINT_ID()));
 147   std::list<ParameterWrapperPtr> aStartParams = aStart->parameters();
 148   EntityWrapperPtr aEnd = myStorage->entity(
 149       myBaseConstraint->attribute(SketchPlugin_MultiTranslation::END_POINT_ID()));
 150   std::list<ParameterWrapperPtr> aEndParams = aEnd->parameters();
 151   myDelta[0] = aEndParams.front()->value() - aStartParams.front()->value();
 152   myDelta[1] = aEndParams.back()->value() - aStartParams.back()->value();
 153
 154   SketchSolver_ConstraintMulti::adjustConstraint();
 155 }
 156
 157 void SketchSolver_ConstraintMultiTranslation::getRelative(
 158     double theAbsX, double theAbsY, double& theRelX, double& theRelY)
 159 {
 160   theRelX = theAbsX;
 161   theRelY = theAbsY;
 162 }
 163
 164 void SketchSolver_ConstraintMultiTranslation::getAbsolute(
 165     double theRelX, double theRelY, double& theAbsX, double& theAbsY)
 166 {
 167   theAbsX = theRelX;
 168   theAbsY = theRelY;
 169 }
 170
 171 void SketchSolver_ConstraintMultiTranslation::transformRelative(double& theX, double& theY)
 172 {
 173   // translate coordinates
 174   theX += myDelta[0];
 175   theY += myDelta[1];
 176 }
 177