src/SketchSolver/SketchSolver_Constraint.cpp

   1 #include <SketchSolver_Constraint.h>
   2 #include <SketchSolver_Group.h>
   3 #include <SketchSolver_Error.h>
   4 #include <SketchSolver_Manager.h>
   5
   6 #include <SketchPlugin_Arc.h>
   7 #include <SketchPlugin_Circle.h>
   8 #include <SketchPlugin_Line.h>
   9 #include <SketchPlugin_Point.h>
  10
  11 #include <SketchPlugin_ConstraintAngle.h>
  12 #include <SketchPlugin_ConstraintCoincidence.h>
  13 #include <SketchPlugin_ConstraintDistance.h>
  14 #include <SketchPlugin_ConstraintEqual.h>
  15 #include <SketchPlugin_ConstraintHorizontal.h>
  16 #include <SketchPlugin_ConstraintLength.h>
  17 #include <SketchPlugin_ConstraintMirror.h>
  18 #include <SketchPlugin_ConstraintParallel.h>
  19 #include <SketchPlugin_ConstraintPerpendicular.h>
  20 #include <SketchPlugin_ConstraintRadius.h>
  21 #include <SketchPlugin_ConstraintRigid.h>
  22 #include <SketchPlugin_ConstraintTangent.h>
  23 #include <SketchPlugin_ConstraintVertical.h>
  24
  25 #include <GeomAPI_Dir2d.h>
  26 #include <GeomDataAPI_Point.h>
  27 #include <GeomDataAPI_Point2D.h>
  28 #include <ModelAPI_AttributeDouble.h>
  29 #include <ModelAPI_ResultConstruction.h>
  30
  31 #include <math.h>
  32
  33 SketchSolver_Constraint::SketchSolver_Constraint(
  34     ConstraintPtr  theConstraint)
  35   : myBaseConstraint(theConstraint),
  36     myGroupID(GID_UNKNOWN),
  37     myType(CONSTRAINT_UNKNOWN)
  38 {
  39 }
  40
  41 void SketchSolver_Constraint::process(StoragePtr theStorage,
  42                                       const GroupID& theGroupID,
  43                                       const EntityID& theSketchID)
  44 {
  45   myStorage = theStorage;
  46   myGroupID = theGroupID;
  47   mySketchID = theSketchID;
  48   // Process constraint according to its type
  49   process();
  50 }
  51
  52
  53 SketchSolver_ConstraintType SketchSolver_Constraint::TYPE(ConstraintPtr theConstraint)
  54 {
  55   const std::string& aType = theConstraint->getKind();
  56   if (aType == SketchPlugin_ConstraintCoincidence::ID())
  57     return CONSTRAINT_COINCIDENCE;
  58   else if (aType == SketchPlugin_ConstraintRigid::ID())
  59     return CONSTRAINT_FIXED;
  60   else if (aType == SketchPlugin_ConstraintHorizontal::ID())
  61     return CONSTRAINT_HORIZONTAL;
  62   else if (aType == SketchPlugin_ConstraintVertical::ID())
  63     return CONSTRAINT_VERTICAL;
  64   else if (aType == SketchPlugin_ConstraintAngle::ID())
  65     return CONSTRAINT_ANGLE;
  66   else if (aType == SketchPlugin_ConstraintDistance::ID())
  67     return CONSTRAINT_DISTANCE;
  68   else if (aType == SketchPlugin_ConstraintEqual::ID())
  69     return CONSTRAINT_EQUAL;
  70   else if (aType == SketchPlugin_ConstraintLength::ID())
  71     return CONSTRAINT_PT_PT_DISTANCE;
  72   else if (aType == SketchPlugin_ConstraintMirror::ID())
  73     return CONSTRAINT_SYMMETRIC;
  74   else if (aType == SketchPlugin_ConstraintParallel::ID())
  75     return CONSTRAINT_PARALLEL;
  76   else if (aType == SketchPlugin_ConstraintPerpendicular::ID())
  77     return CONSTRAINT_PERPENDICULAR;
  78   else if (aType == SketchPlugin_ConstraintRadius::ID())
  79     return CONSTRAINT_RADIUS;
  80   else if (aType == SketchPlugin_ConstraintTangent::ID())
  81     return CONSTRAINT_TANGENT;
  82   return CONSTRAINT_UNKNOWN;
  83 }
  84
  85 void SketchSolver_Constraint::process()
  86 {
  87   cleanErrorMsg();
  88   if (!myBaseConstraint || !myStorage || myGroupID == GID_UNKNOWN) {
  89     // Not enough parameters are assigned
  90     return;
  91   }
  92
  93   SketchSolver_ConstraintType aConstrType = getType();
  94   double aValue;
  95   std::vector<EntityWrapperPtr> anAttributes;
  96   getAttributes(aValue, anAttributes);
  97   if (!myErrorMsg.empty())
  98     return;
  99   if (anAttributes.empty()) {
 100     myErrorMsg = SketchSolver_Error::INCORRECT_ATTRIBUTE();
 101     return;
 102   }
 103   if (aConstrType == CONSTRAINT_UNKNOWN)
 104     aConstrType = getType();
 105
 106   BuilderPtr aBuilder = SketchSolver_Manager::instance()->builder();
 107   std::list<ConstraintWrapperPtr> aNewConstraints = aBuilder->createConstraint(
 108       myBaseConstraint, myGroupID, mySketchID, aConstrType,
 109       aValue, anAttributes[0], anAttributes[1], anAttributes[2], anAttributes[3]);
 110   myStorage->addConstraint(myBaseConstraint, aNewConstraints);
 111
 112   adjustConstraint();
 113 }
 114
 115 void SketchSolver_Constraint::update()
 116 {
 117   cleanErrorMsg();
 118   std::list<ConstraintWrapperPtr> aWrapper = myStorage->constraint(myBaseConstraint);
 119   std::list<ConstraintWrapperPtr>::iterator aWIt = aWrapper.begin();
 120
 121   // Check if attributes of constraint are changed, rebuild constraint
 122   std::set<AttributePtr> anAttributes;
 123   std::set<AttributePtr>::iterator aFoundAttr;
 124   std::set<FeaturePtr> aFeatures;
 125   std::set<FeaturePtr>::iterator aFoundFeat;
 126   for (int anEntIndex = 0; anEntIndex < 4; ++anEntIndex) {
 127     AttributePtr anAttr =
 128         myBaseConstraint->attribute(SketchPlugin_Constraint::ATTRIBUTE(anEntIndex));
 129     if (!anAttr)
 130       continue;
 131
 132     AttributeRefAttrPtr aRefAttr = std::dynamic_pointer_cast<ModelAPI_AttributeRefAttr>(anAttr);
 133     if (aRefAttr) {
 134       if (aRefAttr->isObject()) {
 135         FeaturePtr aFeat = ModelAPI_Feature::feature(aRefAttr->object());
 136         aFeatures.insert(aFeat);
 137       } else
 138         anAttributes.insert(aRefAttr->attr());
 139     } else
 140       anAttributes.insert(anAttr);
 141   }
 142   bool hasNewAttr = !(anAttributes.empty() && aFeatures.empty());
 143   for (; hasNewAttr && aWIt != aWrapper.end(); ++ aWIt) {
 144     const std::list<EntityWrapperPtr>& aSubs = (*aWIt)->entities();
 145     std::list<EntityWrapperPtr>::const_iterator aSIt = aSubs.begin();
 146     for (; hasNewAttr && aSIt != aSubs.end(); ++aSIt) {
 147       if ((*aSIt)->baseAttribute()) {
 148         aFoundAttr = anAttributes.find((*aSIt)->baseAttribute());
 149         if (aFoundAttr != anAttributes.end())
 150           anAttributes.erase(aFoundAttr);
 151       } else {
 152         aFoundFeat = aFeatures.find((*aSIt)->baseFeature());
 153         if (aFoundFeat != aFeatures.end())
 154           aFeatures.erase(aFoundFeat);
 155       }
 156       hasNewAttr = !(anAttributes.empty() && aFeatures.empty());
 157     }
 158   }
 159   if (hasNewAttr) {
 160     remove();
 161     process();
 162     return;
 163   }
 164
 165   AttributeDoublePtr aValueAttr = std::dynamic_pointer_cast<ModelAPI_AttributeDouble>(
 166       myBaseConstraint->attribute(SketchPlugin_Constraint::VALUE()));
 167   if (aValueAttr) {
 168     for (aWIt = aWrapper.begin(); aWIt != aWrapper.end(); ++aWIt)
 169       if (fabs((*aWIt)->value() - aValueAttr->value()) > tolerance) {
 170         (*aWIt)->setValue(aValueAttr->value());
 171         myStorage->setNeedToResolve(true);
 172       }
 173   }
 174   myStorage->addConstraint(myBaseConstraint, aWrapper);
 175
 176   adjustConstraint();
 177 }
 178
 179 bool SketchSolver_Constraint::remove()
 180 {
 181   cleanErrorMsg();
 182   return myStorage->removeConstraint(myBaseConstraint);
 183 }
 184
 185 void SketchSolver_Constraint::getAttributes(
 186     double& theValue,
 187     std::vector<EntityWrapperPtr>& theAttributes)
 188 {
 189   static const int anInitNbOfAttr = 4;
 190   theAttributes.assign(anInitNbOfAttr, EntityWrapperPtr());
 191
 192   DataPtr aData = myBaseConstraint->data();
 193   BuilderPtr aBuilder = SketchSolver_Manager::instance()->builder();
 194
 195   myType = TYPE(myBaseConstraint);
 196
 197   AttributeDoublePtr aValueAttr = std::dynamic_pointer_cast<ModelAPI_AttributeDouble>(
 198       aData->attribute(SketchPlugin_Constraint::VALUE()));
 199   theValue = aValueAttr ? aValueAttr->value() : 0.0;
 200
 201   int aPtInd = 0; // index of first point in the list of attributes
 202   int aEntInd = 2; // index of first entity in the list of attributes
 203   std::list<AttributePtr> aConstrAttrs = aData->attributes(ModelAPI_AttributeRefAttr::typeId());
 204   std::list<AttributePtr>::iterator anIter = aConstrAttrs.begin();
 205   for (; anIter != aConstrAttrs.end(); anIter++) {
 206     AttributeRefAttrPtr aRefAttr =
 207         std::dynamic_pointer_cast<ModelAPI_AttributeRefAttr>(*anIter);
 208     if (!aRefAttr || !aRefAttr->isInitialized()) {
 209       myErrorMsg = SketchSolver_Error::NOT_INITIALIZED();
 210       return;
 211     }
 212
 213     myStorage->update(*anIter/*, myGroupID*/);
 214     EntityWrapperPtr anEntity = myStorage->entity(*anIter);
 215
 216     SketchSolver_EntityType aType = anEntity->type();
 217     if (aType == ENTITY_UNKNOWN)
 218       continue;
 219     else if (aType == ENTITY_POINT)
 220       theAttributes[aPtInd++] = anEntity; // the point is created
 221     else { // another entity (not a point) is created
 222       if (aEntInd < anInitNbOfAttr)
 223         theAttributes[aEntInd] = anEntity;
 224       else
 225         theAttributes.push_back(anEntity);
 226       aEntInd++;
 227     }
 228   }
 229 }
 230
 231 bool SketchSolver_Constraint::isUsed(FeaturePtr theFeature) const
 232 {
 233   const std::list<ConstraintWrapperPtr>& aCList = myStorage->constraint(myBaseConstraint);
 234   std::list<ConstraintWrapperPtr>::const_iterator aCIt = aCList.begin();
 235   for (; aCIt != aCList.end(); ++aCIt)
 236     if ((*aCIt)->isUsed(theFeature))
 237       return true;
 238
 239   std::list<AttributePtr> anAttrList = theFeature->data()->attributes(GeomDataAPI_Point2D::typeId());
 240   std::list<AttributePtr>::const_iterator anAttrIt = anAttrList.begin();
 241   for (; anAttrIt != anAttrList.end(); ++ anAttrIt)
 242     if (isUsed(*anAttrIt))
 243       return true;
 244
 245   return false;
 246 }
 247
 248 bool SketchSolver_Constraint::isUsed(AttributePtr theAttribute) const
 249 {
 250   AttributePtr anAttribute = theAttribute;
 251   AttributeRefAttrPtr aRefAttr =
 252       std::dynamic_pointer_cast<ModelAPI_AttributeRefAttr>(anAttribute);
 253   if (aRefAttr) {
 254     if (aRefAttr->isObject())
 255       return isUsed(ModelAPI_Feature::feature(aRefAttr->object()));
 256     else
 257       anAttribute = aRefAttr->attr();
 258   }
 259
 260   const std::list<ConstraintWrapperPtr>& aCList = myStorage->constraint(myBaseConstraint);
 261   std::list<ConstraintWrapperPtr>::const_iterator aCIt = aCList.begin();
 262   for (; aCIt != aCList.end(); ++aCIt)
 263     if ((*aCIt)->isUsed(theAttribute))
 264       return true;
 265   return false;
 266 }