X-Git-Url: http://git.salome-platform.org/gitweb/?a=blobdiff_plain;f=src%2FSketchSolver%2FSketchSolver_Storage.cpp;h=9fb0369d59208b274ce90c4b7cb47966636bd16b;hb=c02fae5493cc6d56c9a1db3bdcf6d872f88fea07;hp=5af9d5043d6acf6971ab469805409145a3b9a22e;hpb=c3aeb6b898054376c1047071ea9fea61abdc9e99;p=modules%2Fshaper.git diff --git a/src/SketchSolver/SketchSolver_Storage.cpp b/src/SketchSolver/SketchSolver_Storage.cpp index 5af9d5043..9fb0369d5 100644 --- a/src/SketchSolver/SketchSolver_Storage.cpp +++ b/src/SketchSolver/SketchSolver_Storage.cpp @@ -1,13 +1,26 @@ -// Copyright (C) 2014-20xx CEA/DEN, EDF R&D - -// File: SketchSolver_Storage.cpp -// Created: 30 Nov 2015 -// Author: Artem ZHIDKOV +// Copyright (C) 2014-2019 CEA/DEN, EDF R&D +// +// This library is free software; you can redistribute it and/or +// modify it under the terms of the GNU Lesser General Public +// License as published by the Free Software Foundation; either +// version 2.1 of the License, or (at your option) any later version. +// +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +// Lesser General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public +// License along with this library; if not, write to the Free Software +// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA +// +// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com +// #include -#include +#include +#include -#include #include #include #include @@ -20,115 +33,73 @@ #include -/// \brief Verify two vectors of constraints are equal. -/// Vectors differ by the order of elements are equal. -static bool isEqual(const std::list& theCVec1, - const std::list& 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) +SketchSolver_Storage::SketchSolver_Storage(SolverPtr theSolver) + : mySketchSolver(theSolver), + myNeedToResolve(false), + myEventsBlocked(false) { - if (theSolverConstraint) { - std::list aConstrList(1, theSolverConstraint); - addConstraint(theConstraint, aConstrList); - } else - addConstraint(theConstraint, std::list()); + // create updaters (constraints processed at first) + UpdaterPtr aFeatureUpdater(new PlaneGCSSolver_UpdateFeature); + myUpdaters = UpdaterPtr(new PlaneGCSSolver_UpdateCoincidence(aFeatureUpdater)); } -void SketchSolver_Storage::addConstraint( - ConstraintPtr theConstraint, - std::list theSolverConstraints) +void SketchSolver_Storage::addConstraint(ConstraintPtr theConstraint, + ConstraintWrapperPtr theSolverConstraint) { - std::map >::const_iterator + std::map::const_iterator aFound = myConstraintMap.find(theConstraint); - if (aFound == myConstraintMap.end() || !isEqual(aFound->second, theSolverConstraints)) + if (aFound == myConstraintMap.end() || aFound->second != theSolverConstraint) setNeedToResolve(true); - if (theSolverConstraints.empty()) { - // constraint links to the empty list, add its attributes linked to the empty entities - std::list aRefAttrs = - theConstraint->data()->attributes(ModelAPI_AttributeRefAttr::typeId()); - std::list::const_iterator anAttrIt = aRefAttrs.begin(); - for (; anAttrIt != aRefAttrs.end(); ++anAttrIt) { - AttributeRefAttrPtr aRef = std::dynamic_pointer_cast(*anAttrIt); - if (aRef->isObject()) { - FeaturePtr aFeature = ModelAPI_Feature::feature(aRef->object()); - if (aFeature) addEntity(aFeature, EntityWrapperPtr()); - } else - addEntity(aRef->attr(), EntityWrapperPtr()); - } - std::list aRefLists = - theConstraint->data()->attributes(ModelAPI_AttributeRefList::typeId()); - for (anAttrIt = aRefLists.begin(); anAttrIt != aRefLists.end(); ++anAttrIt) { - AttributeRefListPtr aRef = std::dynamic_pointer_cast(*anAttrIt); - std::list anObj = aRef->list(); - std::list::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::iterator aCIt = theSolverConstraints.begin(); - for (; aCIt != theSolverConstraints.end(); ++aCIt) - update(*aCIt); - } - - if (!theSolverConstraints.empty() || aFound == myConstraintMap.end()) - myConstraintMap[theConstraint] = theSolverConstraints; +//// if (theSolverConstraints.empty()) { +//// // constraint links to the empty list, add its attributes linked to the empty entities +//// std::list aRefAttrs = +//// theConstraint->data()->attributes(ModelAPI_AttributeRefAttr::typeId()); +//// std::list::const_iterator anAttrIt = aRefAttrs.begin(); +//// for (; anAttrIt != aRefAttrs.end(); ++anAttrIt) { +//// AttributeRefAttrPtr aRef = +//// std::dynamic_pointer_cast(*anAttrIt); +//// if (aRef->isObject()) { +//// FeaturePtr aFeature = ModelAPI_Feature::feature(aRef->object()); +//// if (aFeature) addEntity(aFeature, EntityWrapperPtr()); +//// } else +//// addEntity(aRef->attr(), EntityWrapperPtr()); +//// } +//// std::list aRefLists = +//// theConstraint->data()->attributes(ModelAPI_AttributeRefList::typeId()); +//// for (anAttrIt = aRefLists.begin(); anAttrIt != aRefLists.end(); ++anAttrIt) { +//// AttributeRefListPtr aRef = +//// std::dynamic_pointer_cast(*anAttrIt); +//// std::list anObj = aRef->list(); +//// std::list::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::iterator aCIt = theSolverConstraints.begin(); +//// for (; aCIt != theSolverConstraints.end(); ++aCIt) +//// update(*aCIt); +//// } + + if (!theSolverConstraint || aFound == myConstraintMap.end()) + myConstraintMap[theConstraint] = theSolverConstraint; // block events if necessary if (myEventsBlocked && theConstraint && theConstraint->data() && theConstraint->data()->isValid()) theConstraint->data()->blockSendAttributeUpdated(myEventsBlocked); } -static std::list pointAttributes(FeaturePtr theFeature) -{ - std::list 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::const_iterator aFound = myFeatureMap.find(theFeature); - if (aFound == myFeatureMap.end() || !aFound->second || - (theSolverEntity && !aFound->second->isEqual(theSolverEntity))) - setNeedToResolve(true); // the entity is new or modified - - if (!theSolverEntity) { - // feature links to the empty entity, add its attributes - std::list aPntAttrs = pointAttributes(theFeature); - std::list::const_iterator anAttrIt = aPntAttrs.begin(); - for (; anAttrIt != aPntAttrs.end(); ++anAttrIt) - addEntity(*anAttrIt, EntityWrapperPtr()); - if (aFound == myFeatureMap.end()) - myFeatureMap[theFeature] = theSolverEntity; - } else + if (theSolverEntity) { myFeatureMap[theFeature] = theSolverEntity; + setNeedToResolve(true); + } // block events if necessary if (myEventsBlocked && theFeature->data() && theFeature->data()->isValid()) @@ -138,14 +109,11 @@ void SketchSolver_Storage::addEntity(FeaturePtr theFeature, void SketchSolver_Storage::addEntity(AttributePtr theAttribute, EntityWrapperPtr theSolverEntity) { - std::map::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 - - if (theSolverEntity || aFound == myAttributeMap.end()) + if (theSolverEntity) { myAttributeMap[theAttribute] = theSolverEntity; + setNeedToResolve(true); + } + // block events if necessary if (myEventsBlocked && theAttribute->owner() && theAttribute->owner()->data() && theAttribute->owner()->data()->isValid()) @@ -153,146 +121,13 @@ void SketchSolver_Storage::addEntity(AttributePtr theAttribute, } -static bool isCopyInMulti(std::shared_ptr theFeature, - const std::map >& theConstraints) -{ - if (!theFeature) - return false; - bool aResult = theFeature->isCopy(); - if (aResult) { - std::map >::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( - anIt->first->attribute(SketchPlugin_Constraint::ENTITY_C())); - std::list aMirroredList = aRefList->list(); - std::list::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 aSketchFeature = - std::dynamic_pointer_cast(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 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 anAttrs = pointAttributes(theFeature); - std::list::const_iterator anIt = anAttrs.begin(); - for (; anIt != anAttrs.end(); ++anIt) { - 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, 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 - if (theFeature->getKind() == SketchPlugin_Arc::ID() || - theFeature->getKind() == SketchPlugin_Circle::ID()) { - EntityWrapperPtr aNormal = getNormal(); - if (aNormal) aSubs.push_back(aNormal); - } - // 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; - addEntity(theFeature, aRelated); - } else if (theGroup != GID_UNKNOWN) - changeGroup(aRelated, theGroup); - return update(aRelated) || isUpdated; -} - -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(anAttribute); - if (aRefAttr) { - if (aRefAttr->isObject()) { - 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 aSketchFeature = - std::dynamic_pointer_cast(anAttribute->owner()); - if (aSketchFeature && (aSketchFeature->isExternal() || - isCopyInMulti(aSketchFeature, myConstraintMap))) - aGroup = GID_OUTOFGROUP; - aRelated = aBuilder->createAttribute(anAttribute, aGroup); - if (!aRelated) - return false; - addEntity(anAttribute, aRelated); - } else if (theGroup != GID_UNKNOWN) - changeGroup(aRelated, theGroup); - return update(aRelated); -} - - -const std::list& SketchSolver_Storage::constraint( +const ConstraintWrapperPtr& SketchSolver_Storage::constraint( const ConstraintPtr& theConstraint) const { - static std::list aDummy; + static ConstraintWrapperPtr aDummy; - std::map>::const_iterator + std::map::const_iterator aFound = myConstraintMap.find(theConstraint); if (aFound != myConstraintMap.end()) return aFound->second; @@ -301,18 +136,16 @@ const std::list& SketchSolver_Storage::constraint( const EntityWrapperPtr& SketchSolver_Storage::entity(const FeaturePtr& theFeature) const { - static EntityWrapperPtr aDummy; - std::map::const_iterator aFound = myFeatureMap.find(theFeature); if (aFound != myFeatureMap.end()) return aFound->second; + + static EntityWrapperPtr aDummy; return aDummy; } const EntityWrapperPtr& SketchSolver_Storage::entity(const AttributePtr& theAttribute) const { - static EntityWrapperPtr aDummy; - std::map::const_iterator aFound = myAttributeMap.find(theAttribute); if (aFound != myAttributeMap.end()) @@ -321,475 +154,40 @@ const EntityWrapperPtr& SketchSolver_Storage::entity(const AttributePtr& theAttr AttributeRefAttrPtr aRefAttr = std::dynamic_pointer_cast(theAttribute); if (aRefAttr) { + AttributePtr anAttribute; + if (aRefAttr->isObject()) { + /// TODO: Check resultToFeatureOrAttribute() precisely. Create additional unit-test FeaturePtr aFeature; - AttributePtr anAttribute; resultToFeatureOrAttribute(aRefAttr->object(), aFeature, anAttribute); if (aFeature) return entity(aFeature); - else - return entity(anAttribute); } else - return entity(aRefAttr->attr()); - } - return aDummy; -} - -bool SketchSolver_Storage::removeConstraint(ConstraintPtr theConstraint) -{ - std::map >::iterator - aFound = myConstraintMap.find(theConstraint); - if (aFound == myConstraintMap.end()) - return true; // no constraint, already deleted - - // Remove constraint - std::list aConstrList = aFound->second; - myConstraintMap.erase(aFound); - // Remove SolveSpace constraints - bool isFullyRemoved = true; - std::list::iterator anIt = aConstrList.begin(); - while (anIt != aConstrList.end()) { - if (remove(*anIt)) { - std::list::iterator aRemoveIt = anIt++; - aConstrList.erase(aRemoveIt); - } else { - isFullyRemoved = false; - ++anIt; - } - } - return isFullyRemoved; -} - -template -static bool isUsed(ConstraintWrapperPtr theConstraint, ENT_TYPE theEntity) -{ - if (!theConstraint || !theEntity) - return false; - std::list::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::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 anAttrList = theFeature->data()->attributes(std::string()); - std::list::const_iterator anIt = anAttrList.begin(); - for (; anIt != anAttrList.end(); ++anIt) { - if (*anIt == theAttribute) - return true; - AttributeRefAttrPtr aRefAttr = std::dynamic_pointer_cast(*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 >::const_iterator - aCIt = myConstraintMap.begin(); - std::list::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 anAttrList = pointAttributes(theFeature); - std::list::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(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 >::const_iterator - aCIt = myConstraintMap.begin(); - std::list::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; + return entity(anAttribute); } - // check in features - std::map::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::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::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 >& theGroups, - const EntityWrapperPtr& theEntity1, const EntityWrapperPtr& theEntity2) -{ - std::list >::iterator aFound1 = theGroups.end(); - std::list >::iterator aFound2 = theGroups.end(); - std::list >::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 aPoints = theConstraint->entities(); - std::list::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 > aCoincGroups; - std::set aGroup; - aGroup.insert(aPtPtIt->first); - aCoincGroups.push_back(aGroup); - std::set::const_iterator aTempIt = aPtPtIt->second.begin(); - for (; aTempIt != aPtPtIt->second.end(); ++aTempIt) { - aGroup.clear(); - aGroup.insert(*aTempIt); - aCoincGroups.push_back(aGroup); - } - - std::map >::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::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 aShutOffList; - BuilderPtr aBuilder = SketchSolver_Manager::instance()->builder(); - std::map aNotCoinc; - std::list >::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 >::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::iterator aNotCIt = aShutOffList.begin(); - for (; aNotCIt != aShutOffList.end(); ++aNotCIt) { - if (aPtPtIt->second.size() <= 1) { - myCoincidentPoints.erase(aPtPtIt); - break; - } - if (aPtPtIt->first == *aNotCIt) { - std::set 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::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::iterator aNCIt = aNotCoinc.begin(); - for (++aNCIt; aNCIt != aNotCoinc.end(); ++aNCIt) - addCoincidentPoints(aMasterEnt, aNCIt->second); - } - - return true; + static EntityWrapperPtr aDummy; + return aDummy; } -void SketchSolver_Storage::replaceEntities(const std::map& theChange) -{ - std::set anUpdFeatures; - std::map::const_iterator aSubIt; - std::map::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 aSubs = aFIt->second->subEntities(); - std::list::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::iterator anUpdIt = anUpdFeatures.begin(); - for (; anUpdIt != anUpdFeatures.end(); ++anUpdIt) - update(EntityWrapperPtr(*anUpdIt)); -} -bool SketchSolver_Storage::remove(ConstraintWrapperPtr theConstraint) +void SketchSolver_Storage::removeFeature(FeaturePtr theFeature) { - bool isFullyRemoved = true; - std::list::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; + myFeatureMap.erase(theFeature); + myNeedToResolve = true; } -bool SketchSolver_Storage::remove(EntityWrapperPtr theEntity) +void SketchSolver_Storage::removeAttribute(AttributePtr theAttribute) { - bool isFullyRemoved = true; - std::list::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::const_iterator aParIt = theEntity->parameters().begin(); - for (; aParIt != theEntity->parameters().end(); ++aParIt) - isFullyRemoved = remove(*aParIt) && isFullyRemoved; - return isFullyRemoved; + myAttributeMap.erase(theAttribute); + myNeedToResolve = true; } -bool SketchSolver_Storage::isInteract(const FeaturePtr& theFeature) const -{ - if (!theFeature) - return false; - if (myConstraintMap.empty()) - return true; // empty storage interacts with each feature - - ConstraintPtr aConstraint = std::dynamic_pointer_cast(theFeature); - if (aConstraint) { - if (myConstraintMap.find(aConstraint) != myConstraintMap.end()) - return true; - } else if (myFeatureMap.find(theFeature) != myFeatureMap.end()) - return true; - - std::list anAttrList = theFeature->data()->attributes(std::string()); - std::list::const_iterator anIt = anAttrList.begin(); - for (; anIt != anAttrList.end(); ++anIt) - if (isInteract(*anIt)) - return true; - - return false; -} - -bool SketchSolver_Storage::isInteract(const AttributePtr& theAttribute) const +bool SketchSolver_Storage::areFeaturesValid() const { - if (!theAttribute) - return false; - - AttributeRefListPtr aRefList = - std::dynamic_pointer_cast(theAttribute); - if (aRefList) { - std::list anObjects = aRefList->list(); - std::list::iterator anObjIt = anObjects.begin(); - for (; anObjIt != anObjects.end(); ++anObjIt) { - FeaturePtr aFeature = ModelAPI_Feature::feature(*anObjIt); - if (isInteract(aFeature)) - return true; - } - return false; - } - - AttributeRefAttrPtr aRefAttr = - std::dynamic_pointer_cast(theAttribute); - if (!aRefAttr) - return myAttributeMap.find(theAttribute) != myAttributeMap.end(); - if (!aRefAttr->isObject()) - return myAttributeMap.find(aRefAttr->attr()) != myAttributeMap.end(); - - FeaturePtr aFeature = ModelAPI_Feature::feature(aRefAttr->object()); - return isInteract(aFeature); -} - -bool SketchSolver_Storage::isConsistent() const -{ - // Check the constraints are valid - std::map >::const_iterator - aCIter = myConstraintMap.begin(); - for (; aCIter != myConstraintMap.end(); ++aCIter) - if (!aCIter->first->data() || !aCIter->first->data()->isValid()) - return false; // Check the features are valid std::map::const_iterator aFIter = myFeatureMap.begin(); for (; aFIter != myFeatureMap.end(); aFIter++) @@ -798,128 +196,8 @@ bool SketchSolver_Storage::isConsistent() const return true; } -bool SketchSolver_Storage::isFixed(EntityWrapperPtr theEntity) const -{ - if (theEntity->group() != myGroupID) - return true; - // no need additional checking for entities differ than point - if (theEntity->type() != ENTITY_POINT) - return false; - - CoincidentPointsMap::const_iterator anIt = myCoincidentPoints.begin(); - for (; anIt != myCoincidentPoints.end(); ++anIt) - if (anIt->first == theEntity || anIt->second.find(theEntity) != anIt->second.end()) { - if (anIt->first->group() != myGroupID) - return true; - std::set::const_iterator anEntIt = anIt->second.begin(); - for (; anEntIt != anIt->second.end(); ++anEntIt) - if ((*anEntIt)->group() != myGroupID) - return true; - } - - std::map >::const_iterator aCIt = - myConstraintMap.begin(); - std::list::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; -} - -void SketchSolver_Storage::removeInvalidEntities() -{ - // Remove invalid constraints - std::list anInvalidConstraints; - std::map >::const_iterator - aCIter = myConstraintMap.begin(); - for (; aCIter != myConstraintMap.end(); ++aCIter) - if (!aCIter->first->data() || !aCIter->first->data()->isValid()) - anInvalidConstraints.push_back(aCIter->first); - std::list::const_iterator anInvCIt = anInvalidConstraints.begin(); - for (; anInvCIt != anInvalidConstraints.end(); ++anInvCIt) - removeConstraint(*anInvCIt); - // Remove invalid features - std::list anInvalidFeatures; - std::map::const_iterator aFIter = myFeatureMap.begin(); - for (; aFIter != myFeatureMap.end(); aFIter++) - if (!aFIter->first->data() || !aFIter->first->data()->isValid()) - anInvalidFeatures.push_back(aFIter->first); - std::list::const_iterator anInvFIt = anInvalidFeatures.begin(); - for (; anInvFIt != anInvalidFeatures.end(); ++anInvFIt) - removeEntity(*anInvFIt); -} - -EntityWrapperPtr SketchSolver_Storage::getNormal() const -{ - EntityWrapperPtr aSketch = sketch(); - if (!aSketch) - return aSketch; - - // Find normal entity - const std::list& aSketchSubs = aSketch->subEntities(); - std::list::const_iterator aSIt = aSketchSubs.begin(); - for (; aSIt != aSketchSubs.end(); ++aSIt) - if ((*aSIt)->type() == ENTITY_NORMAL) - return *aSIt; - return EntityWrapperPtr(); -} - -const EntityWrapperPtr& SketchSolver_Storage::sketch() const -{ - static EntityWrapperPtr aDummySketch; - - std::map::const_iterator aFIt = myFeatureMap.begin(); - for (; aFIt != myFeatureMap.end(); ++aFIt) - if (aFIt->second && aFIt->second->type() == ENTITY_SKETCH) - break; - if (aFIt == myFeatureMap.end()) - return aDummySketch; - return aFIt->second; -} - -void SketchSolver_Storage::setSketch(const EntityWrapperPtr& theSketch) -{ - if (sketch()) - return; - addEntity(FeaturePtr(), theSketch); -} - -void SketchSolver_Storage::processArcs() -{ - myExistArc = false; - std::map::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) - return; - - std::map >::const_iterator - aCIter = myConstraintMap.begin(); - for (; aCIter != myConstraintMap.end(); aCIter++) - if (aCIter->first->data() && aCIter->first->data()->isValid()) - aCIter->first->data()->blockSendAttributeUpdated(isBlocked); - std::map::const_iterator aFIter = myFeatureMap.begin(); for (; aFIter != myFeatureMap.end(); aFIter++) if (aFIter->first->data() && aFIter->first->data()->isValid()) @@ -930,65 +208,49 @@ void SketchSolver_Storage::blockEvents(bool isBlocked) if (anAtIter->first->owner() && anAtIter->first->owner()->data() && anAtIter->first->owner()->data()->isValid()) anAtIter->first->owner()->data()->blockSendAttributeUpdated(isBlocked); + myEventsBlocked = isBlocked; } std::set SketchSolver_Storage::getConflictingConstraints(SolverPtr theSolver) const { std::set aConflicting; - std::map >::const_iterator + std::map::const_iterator aConstrIt = myConstraintMap.begin(); for (; aConstrIt != myConstraintMap.end(); ++aConstrIt) { - std::list::const_iterator anIt = aConstrIt->second.begin(); - for (; anIt != aConstrIt->second.end(); ++anIt) - if (theSolver->isConflicting((*anIt)->id())) { - aConflicting.insert(aConstrIt->first); - break; - } + if (theSolver->isConflicting(aConstrIt->second->id())) + aConflicting.insert(aConstrIt->first); } return aConflicting; } +void SketchSolver_Storage::subscribeUpdates( + SketchSolver_Constraint* theSubscriber, const std::string& theGroup) const +{ + myUpdaters->attach(theSubscriber, theGroup); +} +void SketchSolver_Storage::unsubscribeUpdates(SketchSolver_Constraint* theSubscriber) const +{ + myUpdaters->detach(theSubscriber); +} - - -// ============== Auxiliary functions ==================================== -bool isEqual(const std::list& theCVec1, - const std::list& theCVec2) +void SketchSolver_Storage::notify(const FeaturePtr & theFeature) const { - if (theCVec1.size() != theCVec2.size()) - return false; - - std::list aChecked(theCVec2.size(), false); - std::list::const_iterator anIt1 = theCVec1.begin(); - for (; anIt1 != theCVec1.end(); ++anIt1) { - std::list::const_iterator anIt2 = theCVec2.begin(); - std::list::iterator aCheckIt = aChecked.begin(); - while (aCheckIt != aChecked.end() && *aCheckIt) { - ++aCheckIt; - ++anIt2; - } - for (; anIt2 != theCVec2.end(); ++anIt2, ++aCheckIt) - if (!(*aCheckIt) && (*anIt1)->isEqual(*anIt2)) { - *aCheckIt = true; - break; - } - // the same constraint is not found - if (anIt2 == theCVec2.end()) - return false; - } - return true; + myUpdaters->update(theFeature); } -void resultToFeatureOrAttribute(const ObjectPtr& theResult, +void SketchSolver_Storage::resultToFeatureOrAttribute(const ObjectPtr& theResult, FeaturePtr& theFeature, AttributePtr& theAttribute) { FeaturePtr aFeature = ModelAPI_Feature::feature(theResult); + if (!aFeature) + return; + // if the feature has several results, we choose which one is referred const std::list& aResults = aFeature->results(); if (aResults.size() > 1 && theResult != aFeature->lastResult()) { - // actually, the attribute refers to center of arc or circle, + // 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())