+bool SketchSolver_Storage::removeConstraint(ConstraintPtr theConstraint)
+{
+ std::map<ConstraintPtr, std::list<ConstraintWrapperPtr> >::iterator
+ aFound = myConstraintMap.find(theConstraint);
+ if (aFound == myConstraintMap.end())
+ return true; // no constraint, already deleted
+
+ // Remove constraint
+ std::list<ConstraintWrapperPtr> aConstrList = aFound->second;
+ myConstraintMap.erase(aFound);
+ // Remove SolveSpace constraints
+ bool isFullyRemoved = true;
+ std::list<ConstraintWrapperPtr>::iterator anIt = aConstrList.begin();
+ while (anIt != aConstrList.end()) {
+ if (remove(*anIt)) {
+ std::list<ConstraintWrapperPtr>::iterator aRemoveIt = anIt++;
+ aConstrList.erase(aRemoveIt);
+ } else {
+ isFullyRemoved = false;
+ ++anIt;
+ }
+ }
+ 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))
+ return true;
+ return false;
+}
+
+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))
+ return true;
+ 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())
+ return true;
+ // check constraints
+ std::map<ConstraintPtr, std::list<ConstraintWrapperPtr> >::const_iterator
+ aCIt = myConstraintMap.begin();
+ std::list<ConstraintWrapperPtr>::const_iterator aCWIt;
+ for (; aCIt != myConstraintMap.end(); ++aCIt)
+ for (aCWIt = aCIt->second.begin(); aCWIt != aCIt->second.end(); ++aCWIt)
+ if (::isUsed(*aCWIt, theFeature))
+ return true;
+ // check attributes
+ std::list<AttributePtr> anAttrList = pointAttributes(theFeature);
+ std::list<AttributePtr>::const_iterator anIt = anAttrList.begin();
+ for (; anIt != anAttrList.end(); ++anIt)
+ if (isUsed(*anIt))
+ return true;
+ return false;
+}
+
+bool SketchSolver_Storage::isUsed(AttributePtr theAttribute) const
+{
+ AttributePtr anAttribute = theAttribute;
+ AttributeRefAttrPtr aRefAttr = std::dynamic_pointer_cast<ModelAPI_AttributeRefAttr>(anAttribute);
+ if (aRefAttr) {
+ if (aRefAttr->isObject())
+ return isUsed(ModelAPI_Feature::feature(aRefAttr->object()));
+ else
+ anAttribute = aRefAttr->attr();
+ }
+
+ if (myAttributeMap.find(theAttribute) != myAttributeMap.end())
+ return true;
+ // check in constraints
+ std::map<ConstraintPtr, std::list<ConstraintWrapperPtr> >::const_iterator
+ aCIt = myConstraintMap.begin();
+ std::list<ConstraintWrapperPtr>::const_iterator aCWIt;
+ 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)
+ if (::isUsed(aFIt->second, anAttribute))
+ return true;
+ return false;
+}
+
+
+bool SketchSolver_Storage::removeEntity(FeaturePtr theFeature)
+{
+ std::map<FeaturePtr, EntityWrapperPtr>::iterator aFound = myFeatureMap.find(theFeature);
+ if (aFound == myFeatureMap.end())
+ return true; // feature not found, nothing to delete
+
+ EntityWrapperPtr anEntity = aFound->second;
+ myFeatureMap.erase(aFound);
+
+ // 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);
+ return false;
+}
+
+bool SketchSolver_Storage::removeEntity(AttributePtr theAttribute)
+{
+ std::map<AttributePtr, EntityWrapperPtr>::iterator aFound = myAttributeMap.find(theAttribute);
+ if (aFound == myAttributeMap.end())
+ return true; // attribute not found, nothing to delete
+
+ EntityWrapperPtr anEntity = aFound->second;
+ myAttributeMap.erase(aFound);
+
+ // 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)
+{
+ bool isFullyRemoved = true;
+ std::list<EntityWrapperPtr>::const_iterator anIt = theConstraint->entities().begin();
+ for (; anIt != theConstraint->entities().end(); ++anIt) {
+ FeaturePtr aBaseFeature = (*anIt)->baseFeature();
+ if (aBaseFeature)
+ isFullyRemoved = SketchSolver_Storage::removeEntity(aBaseFeature) && isFullyRemoved;
+ else
+ isFullyRemoved =
+ SketchSolver_Storage::removeEntity((*anIt)->baseAttribute()) && isFullyRemoved;
+ }
+ return isFullyRemoved;
+}
+
+bool SketchSolver_Storage::remove(EntityWrapperPtr theEntity)
+{
+ bool isFullyRemoved = true;
+ std::list<EntityWrapperPtr>::const_iterator anEntIt = theEntity->subEntities().begin();
+ for (; anEntIt != theEntity->subEntities().end(); ++anEntIt) {
+ FeaturePtr aBaseFeature = (*anEntIt)->baseFeature();
+ if (aBaseFeature)
+ isFullyRemoved = SketchSolver_Storage::removeEntity(aBaseFeature) && 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();
+ for (; aParIt != theEntity->parameters().end(); ++aParIt)
+ isFullyRemoved = remove(*aParIt) && isFullyRemoved;
+ return isFullyRemoved;
+}
+
+