Salome HOME
Issue #604 Creation of an unexpected line in the Sketcher
[modules/shaper.git] / src / SketchSolver / SketchSolver_ConstraintRigid.cpp
index 7f12c7d32b1238285d9cc76c62c65f15485e7ab4..ff52e577437e5f8db91ae8a17077de087fa94395 100644 (file)
@@ -6,12 +6,15 @@
 #include <SketchPlugin_Circle.h>
 #include <SketchPlugin_ConstraintRigid.h>
 #include <SketchPlugin_Line.h>
+#include <SketchPlugin_Point.h>
 
 #include <GeomAPI_Pnt2d.h>
 #include <GeomAPI_XY.h>
 #include <GeomDataAPI_Point2D.h>
 #include <ModelAPI_AttributeDouble.h>
 
+#include <math.h>
+
 SketchSolver_ConstraintRigid::SketchSolver_ConstraintRigid(FeaturePtr theFeature)
   : SketchSolver_Constraint(),
     myBaseFeature(theFeature)
@@ -32,20 +35,43 @@ void SketchSolver_ConstraintRigid::process()
   double aValue;
   std::vector<Slvs_hEntity> anEntities;
   getAttributes(aValue, anEntities);
-  if (!myErrorMsg.empty() || myFeatureMap.empty())
+  if (!myErrorMsg.empty() || (myFeatureMap.empty() && myAttributeMap.empty()))
+    return;
+  fixFeature();
+}
+
+void SketchSolver_ConstraintRigid::fixFeature()
+{
+  Slvs_hEntity anEntID;
+  if (!myFeatureMap.empty())
+    anEntID = myFeatureMap.begin()->second;
+  else
+    anEntID = myAttributeMap.begin()->second;
+  if (myStorage->isEntityFixed(anEntID, true)) {
+    myErrorMsg = SketchSolver_Error::ALREADY_FIXED();
     return;
+  }
 
-  if (myFeatureMap.begin()->first->getKind() == SketchPlugin_Line::ID()) {
-    Slvs_Entity aLine = myStorage->getEntity(myFeatureMap.begin()->second);
+  std::string aKind;
+  if (!myFeatureMap.empty())
+    aKind = myFeatureMap.begin()->first->getKind();
+  else
+    aKind = myAttributeMap.begin()->first->attributeType();
+
+  if (aKind == SketchPlugin_Line::ID()) {
+    Slvs_Entity aLine = myStorage->getEntity(anEntID);
     fixLine(aLine);
   }
-  else if (myFeatureMap.begin()->first->getKind() == SketchPlugin_Arc::ID()) {
-    Slvs_Entity anArc = myStorage->getEntity(myFeatureMap.begin()->second);
+  else if (aKind == SketchPlugin_Arc::ID()) {
+    Slvs_Entity anArc = myStorage->getEntity(anEntID);
     fixArc(anArc);
   }
-  else if (myFeatureMap.begin()->first->getKind() == SketchPlugin_Circle::ID()) {
-    Slvs_Entity aCirc = myStorage->getEntity(myFeatureMap.begin()->second);
-    fixArc(aCirc);
+  else if (aKind == SketchPlugin_Circle::ID()) {
+    Slvs_Entity aCirc = myStorage->getEntity(anEntID);
+    fixCircle(aCirc);
+  }
+  else if (aKind == SketchPlugin_Point::ID() || aKind == GeomDataAPI_Point2D::typeId()) {
+    fixPoint(anEntID);
   }
 }
 
@@ -148,12 +174,12 @@ void SketchSolver_ConstraintRigid::fixPoint(const Slvs_hEntity& thePointID)
     return;
 
   Slvs_Constraint aConstraint;
-  Slvs_hConstraint aConstrID = myStorage->isPointFixed(thePointID);
-  bool isForceUpdate = (aConstrID != SLVS_E_UNKNOWN && !myBaseConstraint &&
+  Slvs_hConstraint aConstrID = SLVS_E_UNKNOWN;
+  bool isFixed = myStorage->isPointFixed(thePointID, aConstrID, true);
+  bool isForceUpdate = (isFixed && !myBaseConstraint &&
                         myStorage->isTemporary(aConstrID));
   if (!isForceUpdate) { // create new constraint
-    if (aConstrID != SLVS_E_UNKNOWN)
-      return; // the coincident point is already fixed
+    if (isFixed) return;
     aConstraint = Slvs_MakeConstraint(SLVS_E_UNKNOWN, myGroup->getId(), getType(), myGroup->getWorkplaneId(),
         0.0, thePointID, SLVS_E_UNKNOWN, SLVS_E_UNKNOWN, SLVS_E_UNKNOWN);
     aConstraint.h = myStorage->addConstraint(aConstraint);
@@ -161,7 +187,7 @@ void SketchSolver_ConstraintRigid::fixPoint(const Slvs_hEntity& thePointID)
     if (!myBaseConstraint)
       myStorage->addConstraintWhereDragged(aConstraint.h);
   } else { // update already existent constraint
-    if (aConstrID == SLVS_E_UNKNOWN || myBaseConstraint)
+    if (!isFixed || aConstrID == SLVS_E_UNKNOWN || myBaseConstraint)
       return;
     aConstraint = myStorage->getConstraint(aConstrID);
     aConstraint.ptA = thePointID;
@@ -174,14 +200,48 @@ void SketchSolver_ConstraintRigid::fixPoint(const Slvs_hEntity& thePointID)
 void SketchSolver_ConstraintRigid::fixLine(const Slvs_Entity& theLine)
 {
   Slvs_Constraint anEqual;
-  if (isUsedInEqual(theLine, anEqual)) {
+  if (isAxisParallel(theLine)) {
+    // Fix one point and a line length
+    Slvs_hConstraint aFixed;
+    if (!myStorage->isPointFixed(theLine.point[0], aFixed, true) &&
+        !myStorage->isPointFixed(theLine.point[1], aFixed, true))
+      fixPoint(theLine.point[0]);
+    if (!isUsedInEqual(theLine, anEqual)) {
+      // Check the distance is not set yet
+      std::list<Slvs_Constraint> aDistConstr = myStorage->getConstraintsByType(SLVS_C_PT_PT_DISTANCE);
+      std::list<Slvs_Constraint>::const_iterator aDIt = aDistConstr.begin();
+      for (; aDIt != aDistConstr.end(); aDIt++)
+        if ((aDIt->ptA == theLine.point[0] && aDIt->ptB == theLine.point[1]) ||
+            (aDIt->ptA == theLine.point[1] && aDIt->ptB == theLine.point[0]))
+          return;
+      // Calculate distance between points on the line
+      double aCoords[4];
+      for (int i = 0; i < 2; i++) {
+        Slvs_Entity aPnt = myStorage->getEntity(theLine.point[i]);
+        for (int j = 0; j < 2; j++) {
+          Slvs_Param aParam = myStorage->getParameter(aPnt.param[j]);
+          aCoords[2*i+j] = aParam.val;
+        }
+      }
+      double aLength = sqrt((aCoords[2] - aCoords[0]) * (aCoords[2] - aCoords[0]) + 
+                            (aCoords[3] - aCoords[1]) * (aCoords[3] - aCoords[1]));
+      // fix line length
+      Slvs_Constraint aDistance = Slvs_MakeConstraint(SLVS_E_UNKNOWN, myGroup->getId(),
+          SLVS_C_PT_PT_DISTANCE, myGroup->getWorkplaneId(), aLength,
+          theLine.point[0], theLine.point[1], SLVS_E_UNKNOWN, SLVS_E_UNKNOWN);
+      aDistance.h = myStorage->addConstraint(aDistance);
+      mySlvsConstraints.push_back(aDistance.h);
+    }
+    return;
+  }
+  else if (isUsedInEqual(theLine, anEqual)) {
     // Check another entity of Equal is already fixed
     Slvs_hEntity anOtherEntID = anEqual.entityA == theLine.h ? anEqual.entityB : anEqual.entityA;
-    Slvs_Entity anOtherEntity = myStorage->getEntity(anOtherEntID);
-    if (isFixed(anOtherEntity)) {
+    if (myStorage->isEntityFixed(anOtherEntID, true)) {
       // Fix start point of the line (if end point is not fixed yet) ...
-      Slvs_hConstraint anEndFixedID = myStorage->isPointFixed(theLine.point[1]);
-      if (anEndFixedID == SLVS_E_UNKNOWN)
+      Slvs_hConstraint anEndFixedID = SLVS_E_UNKNOWN;
+      bool isFixed = myStorage->isPointFixed(theLine.point[1], anEndFixedID, true);
+      if (isFixed == SLVS_E_UNKNOWN)
         fixPoint(theLine.point[0]);
       // ...  and create fixed point lying on this line
       Slvs_hEntity aPointToCopy = anEndFixedID == SLVS_E_UNKNOWN ? theLine.point[1] : theLine.point[0];
@@ -192,7 +252,7 @@ void SketchSolver_ConstraintRigid::fixLine(const Slvs_Entity& theLine)
       std::list<Slvs_Constraint>::const_iterator aPLIter = aPonLineList.begin();
       for (; aPLIter != aPonLineList.end() && !isPonLineFixed; aPLIter++)
         if (aPLIter->entityA == theLine.h) {
-          isPonLineFixed = (myStorage->isPointFixed(aPLIter->ptA) != SLVS_E_UNKNOWN);
+          isPonLineFixed = myStorage->isPointFixed(aPLIter->ptA, anEndFixedID);
           aFixedPoint = aPLIter->ptA;
         }
 
@@ -222,14 +282,20 @@ void SketchSolver_ConstraintRigid::fixCircle(const Slvs_Entity& theCircle)
   if (isUsedInEqual(theCircle, anEqual)) {
     // Check another entity of Equal is already fixed
     Slvs_hEntity anOtherEntID = anEqual.entityA == theCircle.h ? anEqual.entityB : anEqual.entityA;
-    Slvs_Entity anOtherEntity = myStorage->getEntity(anOtherEntID);
-    if (isFixed(anOtherEntity))
+    if (myStorage->isEntityFixed(anOtherEntID, true))
       isFixRadius = false;
   }
 
   fixPoint(theCircle.point[0]);
 
   if (isFixRadius) {
+    // Search the radius is already fixed
+    std::list<Slvs_Constraint> aDiamConstr = myStorage->getConstraintsByType(SLVS_C_DIAMETER);
+    std::list<Slvs_Constraint>::const_iterator aDiamIter = aDiamConstr.begin();
+    for (; aDiamIter != aDiamConstr.end(); aDiamIter++)
+      if (aDiamIter->entityA == theCircle.h)
+        return;
+
     // Fix radius of a circle
     AttributeDoublePtr aRadiusAttr = std::dynamic_pointer_cast<ModelAPI_AttributeDouble>(
         myFeatureMap.begin()->first->attribute(SketchPlugin_Circle::RADIUS_ID()));
@@ -253,9 +319,9 @@ void SketchSolver_ConstraintRigid::fixArc(const Slvs_Entity& theArc)
   if (isUsedInEqual(theArc, anEqual)) {
     // Check another entity of Equal is already fixed
     Slvs_hEntity anOtherEntID = anEqual.entityA == theArc.h ? anEqual.entityB : anEqual.entityA;
-    Slvs_Entity anOtherEntity = myStorage->getEntity(anOtherEntID);
-    if (isFixed(anOtherEntity)) {
+    if (myStorage->isEntityFixed(anOtherEntID, true)) {
       isFixRadius = false;
+      Slvs_Entity anOtherEntity = myStorage->getEntity(anOtherEntID);
       if (anOtherEntity.type == SLVS_E_LINE_SEGMENT) {
         aPointsToFix.pop_back();
         aPointsToFix.push_back(theArc.point[0]);
@@ -263,9 +329,9 @@ void SketchSolver_ConstraintRigid::fixArc(const Slvs_Entity& theArc)
     }
   }
 
-  Slvs_hConstraint aConstrID = myStorage->isPointFixed(theArc.point[0]);
+  Slvs_hConstraint aConstrID;
   int aNbPointsToFix = 2; // number of fixed points for the arc
-  if (aConstrID != SLVS_E_UNKNOWN)
+  if (myStorage->isPointFixed(theArc.point[0], aConstrID, true))
     aNbPointsToFix--;
 
   // Radius of the arc
@@ -303,7 +369,7 @@ void SketchSolver_ConstraintRigid::fixArc(const Slvs_Entity& theArc)
     std::list<Slvs_Constraint> aDiamConstraints = myStorage->getConstraintsByType(SLVS_C_DIAMETER);
     std::list<Slvs_Constraint>::iterator anIt = aDiamConstraints.begin();
     for (; anIt != aDiamConstraints.end() && !isExists; anIt++)
-      if (anIt->entityA == myFeatureMap.begin()->second)
+      if (anIt->entityA == theArc.h)
         isExists = true;
     if (!isExists) {
       Slvs_Constraint aFixedR = Slvs_MakeConstraint(SLVS_E_UNKNOWN, myGroup->getId(), SLVS_C_DIAMETER,
@@ -336,26 +402,15 @@ bool SketchSolver_ConstraintRigid::isUsedInEqual(
   return false;
 }
 
-bool SketchSolver_ConstraintRigid::isFixed(const Slvs_Entity& theEntity) const
+bool SketchSolver_ConstraintRigid::isAxisParallel(const Slvs_Entity& theEntity) const
 {
-  if (theEntity.type == SLVS_E_POINT_IN_2D)
-    return myStorage->isPointFixed(theEntity.h) != SLVS_E_UNKNOWN;
-
-  // Check all the points of entity are fixed
-  int aNbFixed = 0;
-  for (int i = 0; i < 4; i++) {
-    if (theEntity.point[i] != SLVS_E_UNKNOWN &&
-        myStorage->isPointFixed(theEntity.point[i]) != SLVS_E_UNKNOWN)
-      aNbFixed++;
-  }
+  std::list<Slvs_Constraint> aConstr = myStorage->getConstraintsByType(SLVS_C_HORIZONTAL);
+  std::list<Slvs_Constraint> aVert = myStorage->getConstraintsByType(SLVS_C_VERTICAL);
+  aConstr.insert(aConstr.end(), aVert.begin(), aVert.end());
 
-  switch (theEntity.type) {
-  case SLVS_E_LINE_SEGMENT:
-  case SLVS_E_ARC_OF_CIRCLE:
-    if (aNbFixed == 2) return true;
-  case SLVS_E_CIRCLE:
-    if (aNbFixed == 1) return true;
-  }
+  std::list<Slvs_Constraint>::const_iterator anIter = aConstr.begin();
+  for (; anIter != aConstr.end(); anIter++)
+    if (anIter->entityA == theEntity.h)
+      return true;
   return false;
 }
-