src/SketchSolver/SketchSolver_ConstraintMultiRotation.cpp

   1 #include <SketchSolver_ConstraintMultiRotation.h>
   2 #include <SketchSolver_Error.h>
   3 #include <SketchSolver_Manager.h>
   4
   5 #include <SketchPlugin_MultiRotation.h>
   6
   7 #include <ModelAPI_AttributeString.h>
   8
   9 #include <math.h>
  10
  11 void SketchSolver_ConstraintMultiRotation::getAttributes(
  12     EntityWrapperPtr& theCenter, double& theAngle,
  13     bool& theFullValue,
  14     std::list< std::list<EntityWrapperPtr> >& theEntities)
  15 {
  16   DataPtr aData = myBaseConstraint->data();
  17   theAngle = std::dynamic_pointer_cast<ModelAPI_AttributeDouble>(
  18       aData->attribute(SketchPlugin_MultiRotation::ANGLE_ID()))->value();
  19
  20   AttributePtr aCenterAttr = aData->attribute(SketchPlugin_MultiRotation::CENTER_ID());
  21   if (!aCenterAttr || !aCenterAttr->isInitialized()) {
  22     myErrorMsg = SketchSolver_Error::NOT_INITIALIZED();
  23     return;
  24   }
  25
  26   myType = CONSTRAINT_MULTI_ROTATION;
  27
  28   myStorage->update(aCenterAttr, GID_OUTOFGROUP);
  29   theCenter = myStorage->entity(aCenterAttr);
  30
  31   AttributeStringPtr aMethodTypeAttr = aData->string(SketchPlugin_MultiRotation::ANGLE_TYPE());
  32   theFullValue = aMethodTypeAttr->value() != "SingleAngle";
  33
  34   getEntitiesAndCopies(theEntities);
  35 }
  36
  37 void SketchSolver_ConstraintMultiRotation::process()
  38 {
  39   cleanErrorMsg();
  40   if (!myBaseConstraint || !myStorage || myGroupID == GID_UNKNOWN) {
  41     /// TODO: Put error message here
  42     return;
  43   }
  44
  45   EntityWrapperPtr aRotationCenter;
  46   bool isFullValue;
  47   std::list<std::list<EntityWrapperPtr> > anEntitiesAndCopies;
  48   getAttributes(aRotationCenter, myAngle, isFullValue, anEntitiesAndCopies);
  49   if (!myErrorMsg.empty())
  50     return;
  51
  52   BuilderPtr aBuilder = SketchSolver_Manager::instance()->builder();
  53   std::list<ConstraintWrapperPtr> aRotConstraints;
  54
  55   std::list< std::list<EntityWrapperPtr> >::iterator anEntIt = anEntitiesAndCopies.begin();
  56   for (; anEntIt != anEntitiesAndCopies.end(); ++anEntIt) {
  57     std::list<ConstraintWrapperPtr> aNewConstraints =
  58         aBuilder->createConstraint(myBaseConstraint, myGroupID, mySketchID, myType,
  59         myAngle, isFullValue, aRotationCenter, EntityWrapperPtr(), *anEntIt);
  60     aRotConstraints.insert(aRotConstraints.end(), aNewConstraints.begin(), aNewConstraints.end());
  61   }
  62   myStorage->addConstraint(myBaseConstraint, aRotConstraints);
  63
  64   myAdjusted = false;
  65   adjustConstraint();
  66 }
  67
  68 void SketchSolver_ConstraintMultiRotation::updateLocal()
  69 {
  70   double aValue = std::dynamic_pointer_cast<ModelAPI_AttributeDouble>(
  71       myBaseConstraint->attribute(SketchPlugin_MultiRotation::ANGLE_ID()))->value();
  72   if (fabs(myAngle - aValue) > tolerance)
  73     myAdjusted = false;
  74   // update angle value
  75   myAngle = aValue;
  76
  77   // update center
  78   DataPtr aData = myBaseConstraint->data();
  79   AttributePoint2DPtr aCenterPointAttribute = GeomDataAPI_Point2D::getPoint2D(aData,
  80                                            SketchPlugin_MultiRotation::CENTER_ID());
  81   bool aCenterPointChanged = aCenterPointAttribute != myCenterPointAttribute;
  82   if (aCenterPointChanged)
  83     myCenterPointAttribute = aCenterPointAttribute;
  84
  85   AttributeStringPtr aMethodTypeAttr = aData->string(SketchPlugin_MultiRotation::ANGLE_TYPE());
  86   bool aFullValue = aMethodTypeAttr->value() != "SingleAngle";
  87   bool isMethodChanged = aFullValue != myIsFullValue;
  88   if (isMethodChanged)
  89     myIsFullValue = aFullValue;
  90
  91   if (aCenterPointChanged || isMethodChanged) {
  92     DataPtr aData = myBaseConstraint->data();
  93     std::list<ConstraintWrapperPtr> aConstraints = myStorage->constraint(myBaseConstraint);
  94     std::list<ConstraintWrapperPtr>::const_iterator anIt = aConstraints.begin(),
  95       aLast = aConstraints.end();
  96     std::list<EntityWrapperPtr> anEntities;
  97     for (; anIt != aLast; anIt++) {
  98       ConstraintWrapperPtr aConstraint = *anIt;
  99       aConstraint->setIsFullValue(myIsFullValue);
 100       if (aCenterPointChanged) {
 101         anEntities.clear();
 102         const std::list<EntityWrapperPtr>& aConstraintEntities = aConstraint->entities();
 103         std::list<EntityWrapperPtr>::const_iterator aSIt = aConstraintEntities.begin(),
 104           aSLast = aConstraintEntities.end();
 105         EntityWrapperPtr aCenterPointEntity = *aSIt++;
 106         if (aCenterPointChanged) {
 107           AttributePtr aCenterPointAttr = aData->attribute(SketchPlugin_MultiRotation::CENTER_ID());
 108           myStorage->update(aCenterPointAttr);
 109           aCenterPointEntity = myStorage->entity(aCenterPointAttr);
 110         }
 111         anEntities.push_back(aCenterPointEntity);
 112
 113         for (; aSIt != aSLast; ++aSIt)
 114           anEntities.push_back(*aSIt);
 115
 116         aConstraint->setEntities(anEntities);
 117       }
 118     }
 119     myStorage->addConstraint(myBaseConstraint, aConstraints);
 120
 121     myAdjusted = false;
 122   }
 123 }
 124
 125 void SketchSolver_ConstraintMultiRotation::adjustConstraint()
 126 {
 127   if (fabs(myAngle) < tolerance) {
 128     myStorage->setNeedToResolve(false);
 129     return;
 130   }
 131
 132   const std::list<ConstraintWrapperPtr>& aConstraints = myStorage->constraint(myBaseConstraint);
 133   std::list<ConstraintWrapperPtr>::const_iterator aCIt = aConstraints.begin();
 134   for (; aCIt != aConstraints.end(); ++aCIt)
 135     (*aCIt)->setValue(myAngle);
 136
 137   SketchSolver_ConstraintMulti::adjustConstraint();
 138 }
 139
 140 const std::string& SketchSolver_ConstraintMultiRotation::nameNbObjects()
 141 {
 142   return SketchPlugin_MultiRotation::NUMBER_OF_OBJECTS_ID();
 143 }