src/SketchSolver/SketchSolver_ConstraintMultiTranslation.cpp

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