X-Git-Url: http://git.salome-platform.org/gitweb/?a=blobdiff_plain;f=src%2FSketchSolver%2FSketchSolver_Storage.cpp;h=5af9d5043d6acf6971ab469805409145a3b9a22e;hb=176403004ff97696f3c0b5f8bdf48692177fb34a;hp=2e283a90f6cde0897740b187b0570429134d9237;hpb=4e04f27e9f9639aaf902c9221e494677c70b94ae;p=modules%2Fshaper.git

diff --git a/src/SketchSolver/SketchSolver_Storage.cpp b/src/SketchSolver/SketchSolver_Storage.cpp
index 2e283a90f..5af9d5043 100644
--- a/src/SketchSolver/SketchSolver_Storage.cpp
+++ b/src/SketchSolver/SketchSolver_Storage.cpp
@@ -12,6 +12,12 @@
 #include <ModelAPI_AttributeRefList.h>
 #include <SketchPlugin_Arc.h>
 #include <SketchPlugin_Circle.h>
+#include <SketchPlugin_Line.h>
+#include <SketchPlugin_Point.h>
+#include <SketchPlugin_IntersectionPoint.h>
+#include <SketchPlugin_ConstraintCoincidence.h>
+#include <SketchPlugin_ConstraintMirror.h>
+#include <SketchPlugin_ConstraintRigid.h>
 
 
 /// \brief Verify two vectors of constraints are equal.
@@ -19,12 +25,19 @@
 static bool isEqual(const std::list<ConstraintWrapperPtr>& theCVec1,
                     const std::list<ConstraintWrapperPtr>& theCVec2);
 
+/// \brief Convert result to feature or attribute
+static void resultToFeatureOrAttribute(const ObjectPtr& theResult,
+    FeaturePtr& theFeature, AttributePtr& theAttribute);
+
 
 void SketchSolver_Storage::addConstraint(ConstraintPtr        theConstraint,
                                          ConstraintWrapperPtr theSolverConstraint)
 {
-  std::list<ConstraintWrapperPtr> aConstrList(1, theSolverConstraint);
-  addConstraint(theConstraint, aConstrList);
+  if (theSolverConstraint) {
+    std::list<ConstraintWrapperPtr> aConstrList(1, theSolverConstraint);
+    addConstraint(theConstraint, aConstrList);
+  } else
+    addConstraint(theConstraint, std::list<ConstraintWrapperPtr>());
 }
 
 void SketchSolver_Storage::addConstraint(
@@ -36,28 +49,87 @@ void SketchSolver_Storage::addConstraint(
   if (aFound == myConstraintMap.end() || !isEqual(aFound->second, theSolverConstraints))
     setNeedToResolve(true);
 
-  // Do not add point-point coincidence, because it is already made by setting
-  // the same parameters for both points
-  if (!theSolverConstraints.empty() &&
-      theSolverConstraints.front()->type() != CONSTRAINT_PT_PT_COINCIDENT) {
+  if (theSolverConstraints.empty()) {
+    // constraint links to the empty list, add its attributes linked to the empty entities
+    std::list<AttributePtr> aRefAttrs =
+        theConstraint->data()->attributes(ModelAPI_AttributeRefAttr::typeId());
+    std::list<AttributePtr>::const_iterator anAttrIt = aRefAttrs.begin();
+    for (; anAttrIt != aRefAttrs.end(); ++anAttrIt) {
+      AttributeRefAttrPtr aRef = std::dynamic_pointer_cast<ModelAPI_AttributeRefAttr>(*anAttrIt);
+      if (aRef->isObject()) {
+        FeaturePtr aFeature = ModelAPI_Feature::feature(aRef->object());
+        if (aFeature) addEntity(aFeature, EntityWrapperPtr());
+      } else
+        addEntity(aRef->attr(), EntityWrapperPtr());
+    }
+    std::list<AttributePtr> aRefLists =
+        theConstraint->data()->attributes(ModelAPI_AttributeRefList::typeId());
+    for (anAttrIt = aRefLists.begin(); anAttrIt != aRefLists.end(); ++anAttrIt) {
+      AttributeRefListPtr aRef = std::dynamic_pointer_cast<ModelAPI_AttributeRefList>(*anAttrIt);
+      std::list<ObjectPtr> anObj = aRef->list();
+      std::list<ObjectPtr>::iterator anIt = anObj.begin();
+      for (; anIt != anObj.end(); ++anIt) {
+        FeaturePtr aFeature = ModelAPI_Feature::feature(*anIt);
+        if (aFeature) addEntity(aFeature, EntityWrapperPtr());
+      }
+    }
+  }
+  else if (theSolverConstraints.front()->type() != CONSTRAINT_PT_PT_COINCIDENT) {
+    // Do not add point-point coincidence, because it is already made by setting
+    // the same parameters for both points
     std::list<ConstraintWrapperPtr>::iterator aCIt = theSolverConstraints.begin();
     for (; aCIt != theSolverConstraints.end(); ++aCIt)
       update(*aCIt);
   }
-  myConstraintMap[theConstraint] = theSolverConstraints;
+
+  if (!theSolverConstraints.empty() || aFound == myConstraintMap.end())
+    myConstraintMap[theConstraint] = theSolverConstraints;
   // block events if necessary
-  if (myEventsBlocked && theConstraint->data() && theConstraint->data()->isValid())
+  if (myEventsBlocked && theConstraint && theConstraint->data() && theConstraint->data()->isValid())
     theConstraint->data()->blockSendAttributeUpdated(myEventsBlocked);
 }
 
+static std::list<AttributePtr> pointAttributes(FeaturePtr theFeature)
+{
+  std::list<AttributePtr> aPoints;
+  if (!theFeature->data() || !theFeature->data()->isValid())
+    return aPoints;
+  if (theFeature->getKind() == SketchPlugin_Arc::ID()) {
+    aPoints.push_back(theFeature->attribute(SketchPlugin_Arc::CENTER_ID()));
+    aPoints.push_back(theFeature->attribute(SketchPlugin_Arc::START_ID()));
+    aPoints.push_back(theFeature->attribute(SketchPlugin_Arc::END_ID()));
+  }
+  else if (theFeature->getKind() == SketchPlugin_Circle::ID())
+    aPoints.push_back(theFeature->attribute(SketchPlugin_Circle::CENTER_ID()));
+  else if (theFeature->getKind() == SketchPlugin_Line::ID()) {
+    aPoints.push_back(theFeature->attribute(SketchPlugin_Line::START_ID()));
+    aPoints.push_back(theFeature->attribute(SketchPlugin_Line::END_ID()));
+  }
+  else if (theFeature->getKind() == SketchPlugin_Point::ID() ||
+           theFeature->getKind() == SketchPlugin_IntersectionPoint::ID())
+    aPoints.push_back(theFeature->attribute(SketchPlugin_Point::COORD_ID()));
+  return aPoints;
+}
+
 void SketchSolver_Storage::addEntity(FeaturePtr       theFeature,
                                      EntityWrapperPtr theSolverEntity)
 {
   std::map<FeaturePtr, EntityWrapperPtr>::const_iterator aFound = myFeatureMap.find(theFeature);
-  if (aFound == myFeatureMap.end() || !aFound->second || !aFound->second->isEqual(theSolverEntity))
+  if (aFound == myFeatureMap.end() || !aFound->second ||
+     (theSolverEntity && !aFound->second->isEqual(theSolverEntity)))
     setNeedToResolve(true); // the entity is new or modified
 
-  myFeatureMap[theFeature] = theSolverEntity;
+  if (!theSolverEntity) {
+    // feature links to the empty entity, add its attributes
+    std::list<AttributePtr> aPntAttrs = pointAttributes(theFeature);
+    std::list<AttributePtr>::const_iterator anAttrIt = aPntAttrs.begin();
+    for (; anAttrIt != aPntAttrs.end(); ++anAttrIt)
+      addEntity(*anAttrIt, EntityWrapperPtr());
+    if (aFound == myFeatureMap.end())
+      myFeatureMap[theFeature] = theSolverEntity;
+  } else
+    myFeatureMap[theFeature] = theSolverEntity;
+
   // block events if necessary
   if (myEventsBlocked && theFeature->data() && theFeature->data()->isValid())
     theFeature->data()->blockSendAttributeUpdated(myEventsBlocked);
@@ -66,11 +138,14 @@ void SketchSolver_Storage::addEntity(FeaturePtr       theFeature,
 void SketchSolver_Storage::addEntity(AttributePtr     theAttribute,
                                      EntityWrapperPtr theSolverEntity)
 {
-  std::map<AttributePtr, EntityWrapperPtr>::const_iterator aFound = myAttributeMap.find(theAttribute);
-  if (aFound == myAttributeMap.end() || !aFound->second || !aFound->second->isEqual(theSolverEntity))
+  std::map<AttributePtr, EntityWrapperPtr>::const_iterator aFound = 
+    myAttributeMap.find(theAttribute);
+  if (aFound == myAttributeMap.end() || !aFound->second ||
+     (theSolverEntity && !aFound->second->isEqual(theSolverEntity)))
     setNeedToResolve(true); // the entity is new or modified
 
-  myAttributeMap[theAttribute] = theSolverEntity;
+  if (theSolverEntity || aFound == myAttributeMap.end())
+    myAttributeMap[theAttribute] = theSolverEntity;
   // block events if necessary
   if (myEventsBlocked && theAttribute->owner() &&
       theAttribute->owner()->data() && theAttribute->owner()->data()->isValid())
@@ -78,26 +153,60 @@ void SketchSolver_Storage::addEntity(AttributePtr     theAttribute,
 }
 
 
-bool SketchSolver_Storage::update(FeaturePtr theFeature, const GroupID& theGroup)
+static bool isCopyInMulti(std::shared_ptr<SketchPlugin_Feature> theFeature,
+    const std::map<ConstraintPtr, std::list<ConstraintWrapperPtr> >& theConstraints)
+{
+  if (!theFeature)
+    return false;
+  bool aResult = theFeature->isCopy();
+  if (aResult) {
+    std::map<ConstraintPtr, std::list<ConstraintWrapperPtr> >::const_iterator
+        anIt = theConstraints.begin();
+    for (; anIt != theConstraints.end() && aResult; ++anIt) {
+      if (anIt->first->getKind() != SketchPlugin_ConstraintMirror::ID())
+        continue;
+      AttributeRefListPtr aRefList = std::dynamic_pointer_cast<ModelAPI_AttributeRefList>(
+          anIt->first->attribute(SketchPlugin_Constraint::ENTITY_C()));
+      std::list<ObjectPtr> aMirroredList =  aRefList->list();
+      std::list<ObjectPtr>::const_iterator aMIt = aMirroredList.begin();
+      for (; aMIt != aMirroredList.end() && aResult; ++aMIt) {
+        FeaturePtr aFeat = ModelAPI_Feature::feature(*aMIt);
+        if (aFeat == theFeature)
+          aResult = false;
+      }
+    }
+  }
+  return aResult;
+}
+
+bool SketchSolver_Storage::update(FeaturePtr theFeature, const GroupID& theGroup, bool theForce)
 {
   bool isUpdated = false;
   EntityWrapperPtr aRelated = entity(theFeature);
   if (!aRelated) { // Feature is not exist, create it
+    std::shared_ptr<SketchPlugin_Feature> aSketchFeature = 
+        std::dynamic_pointer_cast<SketchPlugin_Feature>(theFeature);
+    bool isCopy = isCopyInMulti(aSketchFeature, myConstraintMap);
+    // the feature is a copy in "Multi" constraint and does not used in other constraints
+    if (!theForce && isCopy && myFeatureMap.find(theFeature) == myFeatureMap.end())
+      return false;
+
     std::list<EntityWrapperPtr> aSubs;
     // Reserve the feature in the map of features (do not want to add several copies of it)
     myFeatureMap[theFeature] = aRelated;
     // Firstly, create/update its attributes
-    std::list<AttributePtr> anAttrs =
-        theFeature->data()->attributes(GeomDataAPI_Point2D::typeId());
+    std::list<AttributePtr> anAttrs = pointAttributes(theFeature);
     std::list<AttributePtr>::const_iterator anIt = anAttrs.begin();
     for (; anIt != anAttrs.end(); ++anIt) {
-      isUpdated = update(*anIt, theGroup) || isUpdated;
+      if (!(*anIt)->isInitialized())
+        return false;
+      isUpdated = update(*anIt, theGroup, theForce) || isUpdated;
       aSubs.push_back(entity(*anIt));
     }
     // If the feature is a circle, add its radius as a sub
     if (theFeature->getKind() == SketchPlugin_Circle::ID()) {
       AttributePtr aRadius = theFeature->attribute(SketchPlugin_Circle::RADIUS_ID());
-      isUpdated = update(aRadius, theGroup) || isUpdated;
+      isUpdated = update(aRadius, theGroup, theForce) || isUpdated;
       aSubs.push_back(entity(aRadius));
     }
     // If the feature if circle or arc, we need to add normal of the sketch to the list of subs
@@ -109,6 +218,9 @@ bool SketchSolver_Storage::update(FeaturePtr theFeature, const GroupID& theGroup
     // Secondly, convert feature
     BuilderPtr aBuilder = SketchSolver_Manager::instance()->builder();
     GroupID aGroup = theGroup != GID_UNKNOWN ? theGroup : myGroupID;
+    // Check external feature
+    if (aSketchFeature && (aSketchFeature->isExternal() || isCopy))
+      aGroup = GID_OUTOFGROUP;
     aRelated = aBuilder->createFeature(theFeature, aSubs, aGroup);
     if (!aRelated)
       return false;
@@ -118,22 +230,52 @@ bool SketchSolver_Storage::update(FeaturePtr theFeature, const GroupID& theGroup
   return update(aRelated) || isUpdated;
 }
 
-bool SketchSolver_Storage::update(AttributePtr theAttribute, const GroupID& theGroup)
+bool SketchSolver_Storage::update(AttributePtr theAttribute, const GroupID& theGroup, bool theForce)
 {
+  if (!theAttribute->isInitialized())
+    return false;
+
   AttributePtr anAttribute = theAttribute;
   AttributeRefAttrPtr aRefAttr = std::dynamic_pointer_cast<ModelAPI_AttributeRefAttr>(anAttribute);
   if (aRefAttr) {
     if (aRefAttr->isObject()) {
-      FeaturePtr aFeature = ModelAPI_Feature::feature(aRefAttr->object());
-      return update(aFeature, theGroup);
-    } else
+      FeaturePtr aFeature;
+      resultToFeatureOrAttribute(aRefAttr->object(), aFeature, anAttribute);
+      if (aFeature)
+        return update(aFeature, theGroup, theForce);
+    } else {
       anAttribute = aRefAttr->attr();
+      if (!anAttribute->isInitialized())
+        return false;
+    }
   }
 
   EntityWrapperPtr aRelated = entity(anAttribute);
   if (!aRelated) { // Attribute is not exist, create it
+    // verify the attribute is a point of arc and add whole arc
+    if (anAttribute->owner()) {
+      FeaturePtr aFeature = ModelAPI_Feature::feature(anAttribute->owner());
+      if (aFeature->getKind() == SketchPlugin_Arc::ID() &&
+          myFeatureMap.find(aFeature) == myFeatureMap.end()) {
+        // Additional checking that all attributes are initialized
+        if (aFeature->attribute(SketchPlugin_Arc::CENTER_ID())->isInitialized() && 
+            aFeature->attribute(SketchPlugin_Arc::START_ID())->isInitialized() && 
+            aFeature->attribute(SketchPlugin_Arc::END_ID())->isInitialized()) {
+          return SketchSolver_Storage::update(aFeature, theGroup, theForce);
+        } else {
+          myFeatureMap[aFeature] = EntityWrapperPtr();
+          myExistArc = true;
+        }
+      }
+    }
     BuilderPtr aBuilder = SketchSolver_Manager::instance()->builder();
     GroupID aGroup = theGroup != GID_UNKNOWN ? theGroup : myGroupID;
+    // Check attribute of external features
+    std::shared_ptr<SketchPlugin_Feature> aSketchFeature = 
+        std::dynamic_pointer_cast<SketchPlugin_Feature>(anAttribute->owner());
+    if (aSketchFeature && (aSketchFeature->isExternal() || 
+        isCopyInMulti(aSketchFeature, myConstraintMap)))
+      aGroup = GID_OUTOFGROUP;
     aRelated = aBuilder->createAttribute(anAttribute, aGroup);
     if (!aRelated)
       return false;
@@ -180,8 +322,13 @@ const EntityWrapperPtr& SketchSolver_Storage::entity(const AttributePtr& theAttr
       std::dynamic_pointer_cast<ModelAPI_AttributeRefAttr>(theAttribute);
   if (aRefAttr) {
     if (aRefAttr->isObject()) {
-      FeaturePtr aFeature = ModelAPI_Feature::feature(aRefAttr->object());
-      return entity(aFeature);
+      FeaturePtr aFeature;
+      AttributePtr anAttribute;
+      resultToFeatureOrAttribute(aRefAttr->object(), aFeature, anAttribute);
+      if (aFeature)
+        return entity(aFeature);
+      else
+        return entity(anAttribute);
     } else
       return entity(aRefAttr->attr());
   }
@@ -210,16 +357,14 @@ bool SketchSolver_Storage::removeConstraint(ConstraintPtr theConstraint)
       ++anIt;
     }
   }
-  if (!isFullyRemoved) {
-    // revert removed constraint
-    addConstraint(theConstraint, aConstrList);
-  }
   return isFullyRemoved;
 }
 
 template <class ENT_TYPE>
 static bool isUsed(ConstraintWrapperPtr theConstraint, ENT_TYPE theEntity)
 {
+  if (!theConstraint || !theEntity)
+    return false;
   std::list<EntityWrapperPtr>::const_iterator anEntIt = theConstraint->entities().begin();
   for (; anEntIt != theConstraint->entities().end(); ++anEntIt)
     if ((*anEntIt)->isBase(theEntity))
@@ -229,6 +374,8 @@ static bool isUsed(ConstraintWrapperPtr theConstraint, ENT_TYPE theEntity)
 
 static bool isUsed(EntityWrapperPtr theFeature, AttributePtr theSubEntity)
 {
+  if (!theFeature || !theSubEntity)
+    return false;
   std::list<EntityWrapperPtr>::const_iterator aSubIt = theFeature->subEntities().begin();
   for (; aSubIt != theFeature->subEntities().end(); ++aSubIt)
     if ((*aSubIt)->isBase(theSubEntity))
@@ -236,6 +383,22 @@ static bool isUsed(EntityWrapperPtr theFeature, AttributePtr theSubEntity)
   return false;
 }
 
+static bool isUsed(FeaturePtr theFeature, AttributePtr theAttribute)
+{
+  if (!theFeature || !theAttribute)
+    return false;
+  std::list<AttributePtr> anAttrList = theFeature->data()->attributes(std::string());
+  std::list<AttributePtr>::const_iterator anIt = anAttrList.begin();
+  for (; anIt != anAttrList.end(); ++anIt) {
+    if (*anIt == theAttribute)
+      return true;
+    AttributeRefAttrPtr aRefAttr = std::dynamic_pointer_cast<ModelAPI_AttributeRefAttr>(*anIt);
+    if (aRefAttr && !aRefAttr->isObject() && aRefAttr->attr() == theAttribute)
+      return true;
+  }
+  return false;
+}
+
 bool SketchSolver_Storage::isUsed(FeaturePtr theFeature) const
 {
   if (myFeatureMap.find(theFeature) != myFeatureMap.end())
@@ -249,7 +412,7 @@ bool SketchSolver_Storage::isUsed(FeaturePtr theFeature) const
       if (::isUsed(*aCWIt, theFeature))
         return true;
   // check attributes
-  std::list<AttributePtr> anAttrList = theFeature->data()->attributes(GeomDataAPI_Point2D::typeId());
+  std::list<AttributePtr> anAttrList = pointAttributes(theFeature);
   std::list<AttributePtr>::const_iterator anIt = anAttrList.begin();
   for (; anIt != anAttrList.end(); ++anIt)
     if (isUsed(*anIt))
@@ -274,10 +437,15 @@ bool SketchSolver_Storage::isUsed(AttributePtr theAttribute) const
   std::map<ConstraintPtr, std::list<ConstraintWrapperPtr> >::const_iterator
       aCIt = myConstraintMap.begin();
   std::list<ConstraintWrapperPtr>::const_iterator aCWIt;
-  for (; aCIt != myConstraintMap.end(); ++aCIt)
+  for (; aCIt != myConstraintMap.end(); ++aCIt) {
     for (aCWIt = aCIt->second.begin(); aCWIt != aCIt->second.end(); ++aCWIt)
       if (::isUsed(*aCWIt, anAttribute))
         return true;
+    // Additional check for the Fixed constraints, which have no wrapper associated.
+    if (aCIt->first->getKind() == SketchPlugin_ConstraintRigid::ID() &&
+        ::isUsed(FeaturePtr(aCIt->first), anAttribute))
+      return true;
+  }
   // check in features
   std::map<FeaturePtr, EntityWrapperPtr>::const_iterator aFIt = myFeatureMap.begin();
   for (; aFIt != myFeatureMap.end(); ++aFIt)
@@ -291,17 +459,15 @@ bool SketchSolver_Storage::removeEntity(FeaturePtr theFeature)
 {
   std::map<FeaturePtr, EntityWrapperPtr>::iterator aFound = myFeatureMap.find(theFeature);
   if (aFound == myFeatureMap.end())
-    return false; // feature not found, nothing to delete
-
-  // Check the feature is not used by constraints
-  if (isUsed(theFeature))
-    return false; // the feature is used, don't remove it
+    return true; // feature not found, nothing to delete
 
-  // Remove feature
   EntityWrapperPtr anEntity = aFound->second;
   myFeatureMap.erase(aFound);
-  if (remove(anEntity))
+
+  // Check if the feature is not used by constraints, remove it
+  if (!anEntity || (!isUsed(theFeature) && remove(anEntity)))
     return true;
+
   // feature is not removed, revert operation
   myFeatureMap[theFeature] = anEntity;
   update(anEntity);
@@ -312,28 +478,218 @@ bool SketchSolver_Storage::removeEntity(AttributePtr theAttribute)
 {
   std::map<AttributePtr, EntityWrapperPtr>::iterator aFound = myAttributeMap.find(theAttribute);
   if (aFound == myAttributeMap.end())
-    return false; // attribute not found, nothing to delete
-
-  // Check the attribute is not used by constraints
-  if (isUsed(theAttribute))
-    return false; // the attribute is used, don't remove it
-  // Check the attribute is not used by other features
-  std::map<FeaturePtr, EntityWrapperPtr>::const_iterator aFIt = myFeatureMap.begin();
-  for (; aFIt != myFeatureMap.end(); ++aFIt)
-    if (::isUsed(aFIt->second, theAttribute)) // the attribute is used, don't remove it
-      return false;
+    return true; // attribute not found, nothing to delete
 
-  // Remove attribute
   EntityWrapperPtr anEntity = aFound->second;
   myAttributeMap.erase(aFound);
-  if (remove(anEntity))
+
+  // Check if the attribute is not used by constraints and features, remove it
+  if (!anEntity || (!isUsed(theAttribute) && remove(anEntity)))
     return true;
+
   // attribute is not removed, revert operation
   myAttributeMap[theAttribute] = anEntity;
   update(anEntity);
   return false;
 }
 
+// Merge groups containing given entities
+static void mergeGroups(std::list<std::set<EntityWrapperPtr> >& theGroups,
+    const EntityWrapperPtr& theEntity1, const EntityWrapperPtr& theEntity2)
+{
+  std::list<std::set<EntityWrapperPtr> >::iterator aFound1 = theGroups.end();
+  std::list<std::set<EntityWrapperPtr> >::iterator aFound2 = theGroups.end();
+  std::list<std::set<EntityWrapperPtr> >::iterator anIt = theGroups.begin();
+  for (; anIt != theGroups.end() && (aFound1 == theGroups.end() || aFound2 == theGroups.end());
+       ++anIt) {
+    if (anIt->find(theEntity1) != anIt->end())
+      aFound1 = anIt;
+    if (anIt->find(theEntity2) != anIt->end())
+      aFound2 = anIt;
+  }
+
+  if (aFound1 == aFound2 || aFound1 == theGroups.end() || aFound2 == theGroups.end())
+    return; // nothing to merge
+
+  aFound1->insert(aFound2->begin(), aFound2->end());
+  theGroups.erase(aFound2);
+}
+
+bool SketchSolver_Storage::removeCoincidence(ConstraintWrapperPtr theConstraint)
+{
+  std::list<EntityWrapperPtr> aPoints = theConstraint->entities();
+  std::list<EntityWrapperPtr>::const_iterator aPIt;
+
+  CoincidentPointsMap::iterator aPtPtIt = myCoincidentPoints.begin();
+  for (; aPtPtIt != myCoincidentPoints.end(); ++aPtPtIt) {
+    for (aPIt = aPoints.begin(); aPIt != aPoints.end(); ++aPIt)
+      if (aPtPtIt->first == *aPIt ||
+          aPtPtIt->second.find(*aPIt) != aPtPtIt->second.end())
+        break;
+    if (aPIt != aPoints.end())
+      break;
+  }
+
+  if (aPtPtIt == myCoincidentPoints.end())
+    return true; // already removed
+
+  // Removing of coincidence may split this group of coincident point to several groups.
+  // Find all of them and also the points which become alone.
+  std::list< std::set<EntityWrapperPtr> > aCoincGroups;
+  std::set<EntityWrapperPtr> aGroup;
+  aGroup.insert(aPtPtIt->first);
+  aCoincGroups.push_back(aGroup);
+  std::set<EntityWrapperPtr>::const_iterator aTempIt = aPtPtIt->second.begin();
+  for (; aTempIt != aPtPtIt->second.end(); ++aTempIt) {
+    aGroup.clear();
+    aGroup.insert(*aTempIt);
+    aCoincGroups.push_back(aGroup);
+  }
+
+  std::map<ConstraintPtr, std::list<ConstraintWrapperPtr> >::iterator
+      aConstrIt = myConstraintMap.begin();
+  for (; aConstrIt != myConstraintMap.end(); ++aConstrIt) {
+    if (aConstrIt->first->getKind() != SketchPlugin_ConstraintCoincidence::ID())
+      continue;
+
+    AttributeRefAttrPtr aRefAttr[2] = {
+        aConstrIt->first->refattr(SketchPlugin_Constraint::ENTITY_A()),
+        aConstrIt->first->refattr(SketchPlugin_Constraint::ENTITY_B())
+    };
+    AttributePtr anAttr[2];
+    if (aConstrIt->first->data()->isValid()) {
+      if (!aRefAttr[0] || !aRefAttr[1])
+        continue;
+
+      for (int i = 0; i < 2; ++i) {
+        if (aRefAttr[i]->isObject()) {
+          FeaturePtr aFeature = ModelAPI_Feature::feature(aRefAttr[i]->object());
+          if (!aFeature || (aFeature->getKind() != SketchPlugin_Point::ID() &&
+              aFeature->getKind() != SketchPlugin_IntersectionPoint::ID()))
+            continue;
+          anAttr[i] = aFeature->attribute(SketchPlugin_Point::COORD_ID());
+        } else
+          anAttr[i] = aRefAttr[i]->attr();
+      }
+    } else {
+      // obtain attributes from the constraint wrapper
+      // if SketchPlugin_Constraint has invalid data (already removed)
+      ConstraintWrapperPtr aWrapper = aConstrIt->second.front();
+      anAttr[0] = aWrapper->entities().front()->baseAttribute();
+      anAttr[1] = aWrapper->entities().back()->baseAttribute();
+    }
+
+    EntityWrapperPtr anEntities[2];
+    for (int i = 0; i < 2; ++i) {
+      std::map<AttributePtr, EntityWrapperPtr>::iterator
+          aFound = myAttributeMap.find(anAttr[i]);
+      if (aFound != myAttributeMap.end())
+        anEntities[i] = aFound->second;
+    }
+    mergeGroups(aCoincGroups, anEntities[0], anEntities[1]);
+  }
+
+  // Collect alone points and build them new instances
+  std::list<EntityWrapperPtr> aShutOffList;
+  BuilderPtr aBuilder = SketchSolver_Manager::instance()->builder();
+  std::map<EntityWrapperPtr, EntityWrapperPtr> aNotCoinc;
+  std::list<std::set<EntityWrapperPtr> >::iterator aGroupIt = aCoincGroups.begin();
+  while (aGroupIt != aCoincGroups.end()) {
+    if (aGroupIt->size() == 1) {
+      EntityWrapperPtr aPoint = *aGroupIt->begin();
+      aShutOffList.push_back(aPoint);
+      aNotCoinc[aPoint] =
+          aBuilder->createAttribute(aPoint->baseAttribute(), myGroupID, mySketchID);
+      std::list<std::set<EntityWrapperPtr> >::iterator aRemoveIt = aGroupIt++;
+      aCoincGroups.erase(aRemoveIt);
+    } else // point is not alone
+      ++aGroupIt;
+  }
+
+  if (aNotCoinc.empty() && aCoincGroups.size() == 1)
+    return false;
+
+  // Find all features and constraints uses non-coincident points
+  replaceEntities(aNotCoinc);
+
+  // Remove not coincident points and points in separated groups
+  if (!aCoincGroups.empty()) {
+    aGroupIt = aCoincGroups.begin();
+    for (++aGroupIt; aGroupIt != aCoincGroups.end(); ++aGroupIt)
+      aShutOffList.insert(aShutOffList.end(), aGroupIt->begin(), aGroupIt->end());
+  }
+  std::list<EntityWrapperPtr>::iterator aNotCIt = aShutOffList.begin();
+  for (; aNotCIt != aShutOffList.end(); ++aNotCIt) {
+    if (aPtPtIt->second.size() <= 1) {
+      myCoincidentPoints.erase(aPtPtIt);
+      break;
+    }
+    if (aPtPtIt->first == *aNotCIt) {
+      std::set<EntityWrapperPtr> aSlaves = aPtPtIt->second;
+      EntityWrapperPtr aNewMaster = *aSlaves.begin();
+      aSlaves.erase(aSlaves.begin());
+      myCoincidentPoints.erase(aPtPtIt);
+      myCoincidentPoints[aNewMaster] = aSlaves;
+      aPtPtIt = myCoincidentPoints.find(aNewMaster);
+    } else
+      aPtPtIt->second.erase(*aNotCIt);
+  }
+
+  // Create additional groups of coincident points
+  aGroupIt = aCoincGroups.begin();
+  if (!aCoincGroups.empty())
+    ++aGroupIt;
+  for (; aGroupIt != aCoincGroups.end(); ++aGroupIt) {
+    aNotCoinc.clear();
+    std::set<EntityWrapperPtr>::iterator anEntIt = aGroupIt->begin();
+    for (; anEntIt != aGroupIt->end(); ++anEntIt) {
+      aNotCoinc[*anEntIt] =
+          aBuilder->createAttribute((*anEntIt)->baseAttribute(), myGroupID, mySketchID);
+    }
+    // replace points by newly created
+    replaceEntities(aNotCoinc);
+    // set new group of coincident points
+    EntityWrapperPtr aMasterEnt = aNotCoinc.begin()->second;
+    std::map<EntityWrapperPtr, EntityWrapperPtr>::iterator aNCIt = aNotCoinc.begin();
+    for (++aNCIt; aNCIt != aNotCoinc.end(); ++aNCIt)
+      addCoincidentPoints(aMasterEnt, aNCIt->second);
+  }
+
+  return true;
+}
+
+void SketchSolver_Storage::replaceEntities(const std::map<EntityWrapperPtr, 
+                                           EntityWrapperPtr>& theChange)
+{
+  std::set<EntityWrapperPtr> anUpdFeatures;
+  std::map<EntityWrapperPtr, EntityWrapperPtr>::const_iterator aSubIt;
+  std::map<FeaturePtr, EntityWrapperPtr>::iterator aFIt = myFeatureMap.begin();
+  for (; aFIt != myFeatureMap.end(); ++aFIt) {
+    if (!aFIt->second)
+      continue; // avoid not completed arcs
+    for (aSubIt = theChange.begin(); aSubIt != theChange.end(); ++aSubIt) {
+      if (!aSubIt->second || !::isUsed(aFIt->first, aSubIt->first->baseAttribute()))
+        continue;
+      std::list<EntityWrapperPtr> aSubs = aFIt->second->subEntities();
+      std::list<EntityWrapperPtr>::iterator aSIt = aSubs.begin();
+      bool isUpd = false;
+      for (; aSIt != aSubs.end(); ++aSIt)
+        if (*aSIt == aSubIt->first) {
+          (*aSIt)->update(aSubIt->second);
+          (*aSIt)->setGroup(aFIt->second->group());
+          isUpd = true;
+        }
+      if (isUpd) {
+        aFIt->second->setSubEntities(aSubs);
+        anUpdFeatures.insert(aFIt->second);
+      }
+    }
+  }
+  // update features
+  std::set<EntityWrapperPtr>::iterator anUpdIt = anUpdFeatures.begin();
+  for (; anUpdIt != anUpdFeatures.end(); ++anUpdIt)
+    update(EntityWrapperPtr(*anUpdIt));
+}
 
 bool SketchSolver_Storage::remove(ConstraintWrapperPtr theConstraint)
 {
@@ -344,7 +700,8 @@ bool SketchSolver_Storage::remove(ConstraintWrapperPtr theConstraint)
     if (aBaseFeature)
       isFullyRemoved = SketchSolver_Storage::removeEntity(aBaseFeature) && isFullyRemoved;
     else
-      isFullyRemoved = SketchSolver_Storage::removeEntity((*anIt)->baseAttribute()) && isFullyRemoved;
+      isFullyRemoved = 
+        SketchSolver_Storage::removeEntity((*anIt)->baseAttribute()) && isFullyRemoved;
   }
   return isFullyRemoved;
 }
@@ -357,8 +714,13 @@ bool SketchSolver_Storage::remove(EntityWrapperPtr theEntity)
     FeaturePtr aBaseFeature = (*anEntIt)->baseFeature();
     if (aBaseFeature)
       isFullyRemoved = SketchSolver_Storage::removeEntity(aBaseFeature) && isFullyRemoved;
-    else
-      isFullyRemoved = SketchSolver_Storage::removeEntity((*anEntIt)->baseAttribute()) && isFullyRemoved;
+    else {
+      AttributePtr aBaseAttr = (*anEntIt)->baseAttribute();
+      if (aBaseAttr)
+        isFullyRemoved = SketchSolver_Storage::removeEntity(aBaseAttr) && isFullyRemoved;
+      else
+        remove(*anEntIt);
+    }
   }
 
   std::list<ParameterWrapperPtr>::const_iterator aParIt = theEntity->parameters().begin();
@@ -454,6 +816,22 @@ bool SketchSolver_Storage::isFixed(EntityWrapperPtr theEntity) const
         if ((*anEntIt)->group() != myGroupID)
           return true;
     }
+
+  std::map<ConstraintPtr, std::list<ConstraintWrapperPtr> >::const_iterator aCIt = 
+    myConstraintMap.begin();
+  std::list<ConstraintWrapperPtr>::const_iterator aCWIt;
+  for (; aCIt != myConstraintMap.end(); ++aCIt) {
+    if (aCIt->second.empty())
+      continue;
+    aCWIt = aCIt->second.begin();
+    if ((*aCWIt)->type() != CONSTRAINT_FIXED)
+      continue;
+    for (; aCWIt != aCIt->second.end(); ++aCIt)
+      if ((theEntity->baseAttribute() && (*aCWIt)->isUsed(theEntity->baseAttribute())) ||
+          (theEntity->baseFeature() && (*aCWIt)->isUsed(theEntity->baseFeature())))
+        return true;
+  }
+
   return false;
 }
 
@@ -515,6 +893,22 @@ void SketchSolver_Storage::setSketch(const EntityWrapperPtr& theSketch)
   addEntity(FeaturePtr(), theSketch);
 }
 
+void SketchSolver_Storage::processArcs()
+{
+  myExistArc = false;
+  std::map<FeaturePtr, EntityWrapperPtr>::iterator aFIt = myFeatureMap.begin();
+  for (; aFIt != myFeatureMap.end(); ++aFIt)
+    if (!aFIt->second && aFIt->first->getKind() == SketchPlugin_Arc::ID()) {
+      // Additional checking the attributes are initialized
+      if (aFIt->first->attribute(SketchPlugin_Arc::CENTER_ID())->isInitialized() && 
+          aFIt->first->attribute(SketchPlugin_Arc::START_ID())->isInitialized() && 
+          aFIt->first->attribute(SketchPlugin_Arc::END_ID())->isInitialized())
+        update(aFIt->first);
+      else
+        myExistArc = true;
+    }
+}
+
 void SketchSolver_Storage::blockEvents(bool isBlocked)
 {
   if (isBlocked == myEventsBlocked)
@@ -539,6 +933,21 @@ void SketchSolver_Storage::blockEvents(bool isBlocked)
   myEventsBlocked = isBlocked;
 }
 
+std::set<ObjectPtr> SketchSolver_Storage::getConflictingConstraints(SolverPtr theSolver) const
+{
+  std::set<ObjectPtr> aConflicting;
+  std::map<ConstraintPtr, std::list<ConstraintWrapperPtr> >::const_iterator
+      aConstrIt = myConstraintMap.begin();
+  for (; aConstrIt != myConstraintMap.end(); ++aConstrIt) {
+    std::list<ConstraintWrapperPtr>::const_iterator anIt = aConstrIt->second.begin();
+    for (; anIt != aConstrIt->second.end(); ++anIt)
+      if (theSolver->isConflicting((*anIt)->id())) {
+        aConflicting.insert(aConstrIt->first);
+        break;
+      }
+  }
+  return aConflicting;
+}
 
 
 
@@ -571,3 +980,25 @@ bool isEqual(const std::list<ConstraintWrapperPtr>& theCVec1,
   }
   return true;
 }
+
+void resultToFeatureOrAttribute(const ObjectPtr& theResult,
+    FeaturePtr& theFeature, AttributePtr& theAttribute)
+{
+  FeaturePtr aFeature = ModelAPI_Feature::feature(theResult);
+  // if the feature has several results, we choose which one is referred
+  const std::list<ResultPtr>& aResults = aFeature->results();
+  if (aResults.size() > 1 && theResult != aFeature->lastResult()) {
+    // actually, the attribute refers to center of arc or circle, 
+    // but not the edge, get correct attributes
+    std::string anAttrName;
+    if (aFeature->getKind() == SketchPlugin_Arc::ID())
+      anAttrName = SketchPlugin_Arc::CENTER_ID();
+    else if (aFeature->getKind() == SketchPlugin_Circle::ID())
+      anAttrName = SketchPlugin_Circle::CENTER_ID();
+    if (!anAttrName.empty()) {
+      theAttribute = aFeature->attribute(anAttrName);
+      aFeature = FeaturePtr();
+    }
+  }
+  theFeature = aFeature;
+}