X-Git-Url: http://git.salome-platform.org/gitweb/?a=blobdiff_plain;ds=sidebyside;f=src%2FSketchSolver%2FSketchSolver_Storage.cpp;h=d1f6c4f17bbe88a2619731e5bb59c8c854be1183;hb=6962b55abf9d2cd5c5a5853ef98b72b86bb262e2;hp=eddd630c94aa4f9365e79673b170c13436306d5e;hpb=f1ed85fd30f2228edb3878e79c911017d4105d23;p=modules%2Fshaper.git diff --git a/src/SketchSolver/SketchSolver_Storage.cpp b/src/SketchSolver/SketchSolver_Storage.cpp index eddd630c9..d1f6c4f17 100644 --- a/src/SketchSolver/SketchSolver_Storage.cpp +++ b/src/SketchSolver/SketchSolver_Storage.cpp @@ -1,674 +1,999 @@ // Copyright (C) 2014-20xx CEA/DEN, EDF R&D // File: SketchSolver_Storage.cpp -// Created: 18 Mar 2015 +// Created: 30 Nov 2015 // Author: Artem ZHIDKOV #include - -#include - -/** \brief Search the entity/parameter with specified ID in the list of elements - * \param[in] theEntityID unique ID of the element - * \param[in] theEntities list of elements - * \return position of the found element or -1 if the element is not found - */ -template -static int Search(const uint32_t& theEntityID, const std::vector& theEntities); - -/// \brief Compare two parameters to be different -static bool IsNotEqual(const Slvs_Param& theParam1, const Slvs_Param& theParam2); -/// \brief Compare two entities to be different -static bool IsNotEqual(const Slvs_Entity& theEntity1, const Slvs_Entity& theEntity2); -/// \brief Compare two constriants to be different -static bool IsNotEqual(const Slvs_Constraint& theConstraint1, const Slvs_Constraint& theConstraint2); - - -SketchSolver_Storage::SketchSolver_Storage() - : myParamMaxID(SLVS_E_UNKNOWN), - myEntityMaxID(SLVS_E_UNKNOWN), - myConstrMaxID(SLVS_C_UNKNOWN), - myFixed(SLVS_E_UNKNOWN), - myNeedToResolve(false) +#include + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#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) { + if (theSolverConstraint) { + std::list aConstrList(1, theSolverConstraint); + addConstraint(theConstraint, aConstrList); + } else + addConstraint(theConstraint, std::list()); } -Slvs_hParam SketchSolver_Storage::addParameter(const Slvs_Param& theParam) +void SketchSolver_Storage::addConstraint( + ConstraintPtr theConstraint, + std::list theSolverConstraints) { - if (theParam.h > 0 && theParam.h <= myParamMaxID) { - // parameter is already used, rewrite it - return updateParameter(theParam); - } - - Slvs_Param aParam = theParam; - if (aParam.h > myParamMaxID) - myParamMaxID = aParam.h; - else - aParam.h = ++myParamMaxID; - myParameters.push_back(aParam); - myNeedToResolve = true; - return aParam.h; -} - -Slvs_hParam SketchSolver_Storage::updateParameter(const Slvs_Param& theParam) -{ - if (theParam.h > 0 && theParam.h <= myParamMaxID) { - // parameter already used, rewrite it - int aPos = Search(theParam.h, myParameters); - if (aPos >= 0 && aPos < (int)myParameters.size()) { - myNeedToResolve = myNeedToResolve || IsNotEqual(myParameters[aPos], theParam); - myParameters[aPos] = theParam; - return theParam.h; + std::map >::const_iterator + aFound = myConstraintMap.find(theConstraint); + if (aFound == myConstraintMap.end() || !isEqual(aFound->second, theSolverConstraints)) + 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); + } - // Parameter is not found, add new one - Slvs_Param aParam = theParam; - aParam.h = 0; - return addParameter(aParam); + if (!theSolverConstraints.empty() || aFound == myConstraintMap.end()) + myConstraintMap[theConstraint] = theSolverConstraints; + // block events if necessary + if (myEventsBlocked && theConstraint && theConstraint->data() && theConstraint->data()->isValid()) + theConstraint->data()->blockSendAttributeUpdated(myEventsBlocked); } -bool SketchSolver_Storage::removeParameter(const Slvs_hParam& theParamID) +static std::list pointAttributes(FeaturePtr theFeature) { - int aPos = Search(theParamID, myParameters); - if (aPos >= 0 && aPos < (int)myParameters.size()) { - // Firstly, search the parametes is not used elsewhere - std::vector::const_iterator anEntIter = myEntities.begin(); - for (; anEntIter != myEntities.end(); anEntIter++) { - for (int i = 0; i < 4; i++) - if (anEntIter->param[i] == theParamID) - return false; - } - // Remove parameter - myParameters.erase(myParameters.begin() + aPos); - myParamMaxID = myParameters.empty() ? SLVS_E_UNKNOWN : myParameters.back().h; - myNeedToResolve = true; - myRemovedParameters.insert(theParamID); - return true; + 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())); } - return false; + 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; } -const Slvs_Param& SketchSolver_Storage::getParameter(const Slvs_hParam& theParamID) const +void SketchSolver_Storage::addEntity(FeaturePtr theFeature, + EntityWrapperPtr theSolverEntity) { - int aPos = Search(theParamID, myParameters); - if (aPos >= 0 && aPos < (int)myParameters.size()) - return myParameters[aPos]; + 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 + myFeatureMap[theFeature] = theSolverEntity; + + // block events if necessary + if (myEventsBlocked && theFeature->data() && theFeature->data()->isValid()) + theFeature->data()->blockSendAttributeUpdated(myEventsBlocked); +} - // Parameter is not found, return empty object - static Slvs_Param aDummy; - aDummy.h = 0; - return aDummy; +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()) + myAttributeMap[theAttribute] = theSolverEntity; + // block events if necessary + if (myEventsBlocked && theAttribute->owner() && + theAttribute->owner()->data() && theAttribute->owner()->data()->isValid()) + theAttribute->owner()->data()->blockSendAttributeUpdated(myEventsBlocked); } -Slvs_hEntity SketchSolver_Storage::addEntity(const Slvs_Entity& theEntity) +static bool isCopyInMulti(std::shared_ptr theFeature, + const std::map >& theConstraints) { - if (theEntity.h > 0 && theEntity.h <= myEntityMaxID) { - // Entity is already used, rewrite it - return updateEntity(theEntity); - } - - Slvs_Entity aEntity = theEntity; - if (aEntity.h > myEntityMaxID) - myEntityMaxID = aEntity.h; - else - aEntity.h = ++myEntityMaxID; - myEntities.push_back(aEntity); - myNeedToResolve = true; - return aEntity.h; -} - -Slvs_hEntity SketchSolver_Storage::updateEntity(const Slvs_Entity& theEntity) -{ - if (theEntity.h > 0 && theEntity.h <= myEntityMaxID) { - // Entity already used, rewrite it - int aPos = Search(theEntity.h, myEntities); - if (aPos >= 0 && aPos < (int)myEntities.size()) { - myNeedToResolve = myNeedToResolve || IsNotEqual(myEntities[aPos], theEntity); - myEntities[aPos] = theEntity; - return theEntity.h; + if (!theFeature) + return false; + bool aResult = theFeature->isCopy(); + if (aResult) { + const std::set& aRefs = theFeature->data()->refsToMe(); + for (std::set::const_iterator aRefIt = aRefs.begin(); + aRefIt != aRefs.end() && aResult; ++aRefIt) { + FeaturePtr anOwner = ModelAPI_Feature::feature((*aRefIt)->owner()); + if ((anOwner->getKind() == SketchPlugin_ConstraintMirror::ID() && + (*aRefIt)->id() == SketchPlugin_Constraint::ENTITY_C()) || + (anOwner->getKind() == SketchPlugin_Projection::ID())) + aResult = false; } } - - // Entity is not found, add new one - Slvs_Entity aEntity = theEntity; - aEntity.h = 0; - return addEntity(aEntity); + return aResult; } -bool SketchSolver_Storage::removeEntity(const Slvs_hEntity& theEntityID) +bool SketchSolver_Storage::update(FeaturePtr theFeature, const GroupID& theGroup, bool theForce) { - bool aResult = true; - int aPos = Search(theEntityID, myEntities); - if (aPos >= 0 && aPos < (int)myEntities.size()) { - // Firstly, check the entity is not used elsewhere - std::vector::const_iterator anEntIter = myEntities.begin(); - for (; anEntIter != myEntities.end(); anEntIter++) { - for (int i = 0; i < 4; i++) - if (anEntIter->point[i] == theEntityID) - return false; - if (anEntIter->distance == theEntityID) + 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)); } - std::vector::const_iterator aConstrIter = myConstraints.begin(); - for (; aConstrIter != myConstraints.end(); aConstrIter++) { - Slvs_hEntity anEntIDs[6] = {aConstrIter->ptA, aConstrIter->ptB, - aConstrIter->entityA, aConstrIter->entityB, - aConstrIter->entityC, aConstrIter->entityD}; - for (int i = 0; i < 6; i++) - if (anEntIDs[i] == theEntityID) - return false; + // 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; } - // The entity is not used, remove it and its parameters - Slvs_Entity anEntity = myEntities[aPos]; - myEntities.erase(myEntities.begin() + aPos); - myEntityMaxID = myEntities.empty() ? SLVS_E_UNKNOWN : myEntities.back().h; - if (anEntity.distance != SLVS_E_UNKNOWN) - aResult = aResult && removeParameter(anEntity.distance); - for (int i = 0; i < 4; i++) - if (anEntity.param[i] != SLVS_E_UNKNOWN) - aResult = removeParameter(anEntity.param[i]) && aResult; - for (int i = 0; i < 4; i++) - if (anEntity.point[i] != SLVS_E_UNKNOWN) - aResult = removeEntity(anEntity.point[i]) && aResult; - myNeedToResolve = true; - myRemovedEntities.insert(theEntityID); - if (anEntity.type == SLVS_E_POINT_IN_2D || anEntity.type == SLVS_E_POINT_IN_3D) - removeCoincidentPoint(theEntityID); } - return aResult; + + 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 Slvs_Entity& SketchSolver_Storage::getEntity(const Slvs_hEntity& theEntityID) const + + +const std::list& SketchSolver_Storage::constraint( + const ConstraintPtr& theConstraint) const { - int aPos = Search(theEntityID, myEntities); - if (aPos >= 0 && aPos < (int)myEntities.size()) - return myEntities[aPos]; + static std::list aDummy; - // Entity is not found, return empty object - static Slvs_Entity aDummy; - aDummy.h = 0; + std::map>::const_iterator + aFound = myConstraintMap.find(theConstraint); + if (aFound != myConstraintMap.end()) + return aFound->second; return aDummy; } -Slvs_hEntity SketchSolver_Storage::copyEntity(const Slvs_hEntity& theCopied) +const EntityWrapperPtr& SketchSolver_Storage::entity(const FeaturePtr& theFeature) const { - int aPos = Search(theCopied, myEntities); - if (aPos < 0 || aPos >= (int)myEntities.size()) - return SLVS_E_UNKNOWN; + static EntityWrapperPtr aDummy; + + std::map::const_iterator aFound = myFeatureMap.find(theFeature); + if (aFound != myFeatureMap.end()) + return aFound->second; + return aDummy; +} - Slvs_Entity aCopy = myEntities[aPos]; - aCopy.h = SLVS_E_UNKNOWN; - int i = 0; - while (aCopy.point[i] != SLVS_E_UNKNOWN) { - aCopy.point[i] = copyEntity(aCopy.point[i]); - i++; +const EntityWrapperPtr& SketchSolver_Storage::entity(const AttributePtr& theAttribute) const +{ + static EntityWrapperPtr aDummy; + + std::map::const_iterator + aFound = myAttributeMap.find(theAttribute); + if (aFound != myAttributeMap.end()) + return aFound->second; + + AttributeRefAttrPtr aRefAttr = + std::dynamic_pointer_cast(theAttribute); + if (aRefAttr) { + if (aRefAttr->isObject()) { + FeaturePtr aFeature; + AttributePtr anAttribute; + resultToFeatureOrAttribute(aRefAttr->object(), aFeature, anAttribute); + if (aFeature) + return entity(aFeature); + else + return entity(anAttribute); + } else + return entity(aRefAttr->attr()); } - if (aCopy.param[0] != SLVS_E_UNKNOWN) { - aPos = Search(aCopy.param[0], myParameters); - i = 0; - while (aCopy.param[i] != SLVS_E_UNKNOWN) { - Slvs_Param aNewParam = myParameters[aPos]; - aNewParam.h = SLVS_E_UNKNOWN; - aCopy.param[i] = addParameter(aNewParam); - i++; - aPos++; + 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 addEntity(aCopy); + return isFullyRemoved; } -void SketchSolver_Storage::copyEntity(const Slvs_hEntity& theFrom, const Slvs_hEntity& theTo) +template +static bool isUsed(ConstraintWrapperPtr theConstraint, ENT_TYPE theEntity) { - int aPosFrom = Search(theFrom, myEntities); - int aPosTo = Search(theTo, myEntities); - if (aPosFrom < 0 || aPosFrom >= (int)myEntities.size() || - aPosTo < 0 || aPosTo >= (int)myEntities.size()) - return; + 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; +} - Slvs_Entity aEntFrom = myEntities[aPosFrom]; - Slvs_Entity aEntTo = myEntities[aPosTo]; - int i = 0; - while (aEntFrom.point[i] != SLVS_E_UNKNOWN) { - copyEntity(aEntFrom.point[i], aEntTo.point[i]); - i++; - } - if (aEntFrom.param[0] != SLVS_E_UNKNOWN) { - aPosFrom = Search(aEntFrom.param[0], myParameters); - aPosTo = Search(aEntTo.param[0], myParameters); - i = 0; - while (aEntFrom.param[i] != SLVS_E_UNKNOWN) { - myParameters[aPosTo++].val = myParameters[aPosFrom++].val; - i++; - } +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::isPointFixed( - const Slvs_hEntity& thePointID, Slvs_hConstraint& theFixed, bool theAccurate) const +bool SketchSolver_Storage::isUsed(AttributePtr theAttribute) const { - // Search the set of coincident points - std::set aCoincident; - aCoincident.insert(thePointID); - std::vector< std::set >::const_iterator aCPIter = myCoincidentPoints.begin(); - for (; aCPIter != myCoincidentPoints.end(); aCPIter++) - if (aCPIter->find(thePointID) != aCPIter->end()) { - aCoincident = *aCPIter; - break; - } + 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(); + } - // Search the Rigid constraint - std::vector::const_iterator aConstrIter = myConstraints.begin(); - for (; aConstrIter != myConstraints.end(); aConstrIter++) - if (aConstrIter->type == SLVS_C_WHERE_DRAGGED && - aCoincident.find(aConstrIter->ptA) != aCoincident.end()) { - theFixed = aConstrIter->h; + 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; - } - - if (theAccurate) { - // Try to find the fixed entity which uses such point or its coincidence - std::vector::const_iterator anEntIter = myEntities.begin(); - for (; anEntIter != myEntities.end(); anEntIter++) { - for (int i = 0; i < 4; i++) { - Slvs_hEntity aPt = anEntIter->point[i]; - if (aPt != SLVS_E_UNKNOWN && - (aPt == thePointID || aCoincident.find(aPt) != aCoincident.end())) { - if (isEntityFixed(anEntIter->h, true)) - return true; - } - } - } } - return SLVS_E_UNKNOWN; + // 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::isEntityFixed(const Slvs_hEntity& theEntityID, bool theAccurate) const + +bool SketchSolver_Storage::removeEntity(FeaturePtr theFeature) { - int aPos = Search(theEntityID, myEntities); - if (aPos < 0 || aPos >= (int)myEntities.size()) - return false; + std::map::iterator aFound = myFeatureMap.find(theFeature); + if (aFound == myFeatureMap.end()) + return true; // feature not found, nothing to delete - // Firstly, find how many points are under Rigid constraint - int aNbFixed = 0; - for (int i = 0; i < 4; i++) { - Slvs_hEntity aPoint = myEntities[aPos].point[i]; - if (aPoint == SLVS_E_UNKNOWN) - continue; + EntityWrapperPtr anEntity = aFound->second; + myFeatureMap.erase(aFound); - std::set aCoincident; - aCoincident.insert(aPoint); - std::vector< std::set >::const_iterator aCPIter = myCoincidentPoints.begin(); - for (; aCPIter != myCoincidentPoints.end(); aCPIter++) - if (aCPIter->find(aPoint) != aCPIter->end()) { - aCoincident = *aCPIter; - break; - } + // Check if the feature is not used by constraints, remove it + if (!anEntity || (!isUsed(theFeature) && remove(anEntity))) + return true; - // Search the Rigid constraint - std::vector::const_iterator aConstrIter = myConstraints.begin(); - for (; aConstrIter != myConstraints.end(); aConstrIter++) - if (aConstrIter->type == SLVS_C_WHERE_DRAGGED && - aCoincident.find(aConstrIter->ptA) != aCoincident.end()) - aNbFixed++; - } + // feature is not removed, revert operation + myFeatureMap[theFeature] = anEntity; + update(anEntity); + return false; +} - std::list aList; - std::list::iterator anIt; - Slvs_hConstraint aTempID; // used in isPointFixed() method +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 - if (myEntities[aPos].type == SLVS_E_LINE_SEGMENT) { - if (aNbFixed == 2) - return true; - else if (aNbFixed == 0 || !theAccurate) - return false; - // Additional check (the line may be fixed if it is used by different constraints): - // 1. The line is used in Equal constraint, another entity is fixed and there is a fixed point on line - aList = getConstraintsByType(SLVS_C_PT_ON_LINE); - for (anIt = aList.begin(); anIt != aList.end(); anIt++) - if (anIt->entityA == theEntityID && isPointFixed(anIt->ptA, aTempID)) - break; - if (anIt != aList.end()) { - aList = getConstraintsByType(SLVS_C_EQUAL_LENGTH_LINES); - aList.splice(aList.end(), getConstraintsByType(SLVS_C_EQUAL_LINE_ARC_LEN)); - for (anIt = aList.begin(); anIt != aList.end(); anIt++) - if (anIt->entityA == theEntityID || anIt->entityB == theEntityID) { - Slvs_hEntity anOther = anIt->entityA == theEntityID ? anIt->entityB : anIt->entityA; - if (isEntityFixed(anOther, false)) - return true; - } - } - // 2. The line is used in Parallel/Perpendicular and Length constraints - aList = getConstraintsByType(SLVS_C_PARALLEL); - aList.splice(aList.end(), getConstraintsByType(SLVS_C_PERPENDICULAR)); - for (anIt = aList.begin(); anIt != aList.end(); anIt++) - if (anIt->entityA == theEntityID || anIt->entityB == theEntityID) { - Slvs_hEntity anOther = anIt->entityA == theEntityID ? anIt->entityB : anIt->entityA; - if (isEntityFixed(anOther, false)) - break; - } - if (anIt != aList.end()) { - aList = getConstraintsByType(SLVS_C_PT_PT_DISTANCE); - for (anIt = aList.begin(); anIt != aList.end(); anIt++) - if ((anIt->ptA == myEntities[aPos].point[0] && anIt->ptB == myEntities[aPos].point[1]) || - (anIt->ptA == myEntities[aPos].point[1] && anIt->ptB == myEntities[aPos].point[0])) - return true; - } - // 3. Another verifiers ... - } else if (myEntities[aPos].type == SLVS_E_CIRCLE) { - if (aNbFixed == 0) - return false; - // Search for Diameter constraint - aList = getConstraintsByType(SLVS_C_DIAMETER); - for (anIt = aList.begin(); anIt != aList.end(); anIt++) - if (anIt->entityA == theEntityID) - return true; - if (!theAccurate) - return false; - // Additional check (the circle may be fixed if it is used by different constraints): - // 1. The circle is used in Equal constraint and another entity is fixed - aList = getConstraintsByType(SLVS_C_EQUAL_RADIUS); - for (anIt = aList.begin(); anIt != aList.end(); anIt++) - if (anIt->entityA == theEntityID || anIt->entityB == theEntityID) { - Slvs_hEntity anOther = anIt->entityA == theEntityID ? anIt->entityB : anIt->entityA; - if (isEntityFixed(anOther, false)) - return true; - } - // 2. Another verifiers ... - } else if (myEntities[aPos].type == SLVS_E_ARC_OF_CIRCLE) { - if (aNbFixed > 2) - return true; - else if (aNbFixed <= 1) - return false; - // Search for Diameter constraint - aList = getConstraintsByType(SLVS_C_DIAMETER); - for (anIt = aList.begin(); anIt != aList.end(); anIt++) - if (anIt->entityA == theEntityID) - return true; - if (!theAccurate) - return false; - // Additional check (the arc may be fixed if it is used by different constraints): - // 1. The arc is used in Equal constraint and another entity is fixed - aList = getConstraintsByType(SLVS_C_EQUAL_RADIUS); - aList.splice(aList.end(), getConstraintsByType(SLVS_C_EQUAL_LINE_ARC_LEN)); - for (anIt = aList.begin(); anIt != aList.end(); anIt++) - if (anIt->entityA == theEntityID || anIt->entityB == theEntityID) { - Slvs_hEntity anOther = anIt->entityA == theEntityID ? anIt->entityB : anIt->entityA; - if (isEntityFixed(anOther, false)) - return true; - } - // 2. Another verifiers ... - } + 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); +} -Slvs_hConstraint SketchSolver_Storage::addConstraint(const Slvs_Constraint& theConstraint) +bool SketchSolver_Storage::removeCoincidence(ConstraintWrapperPtr theConstraint) { - if (theConstraint.h > 0 && theConstraint.h <= myConstrMaxID) { - // Constraint is already used, rewrite it - return updateConstraint(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; } - Slvs_Constraint aConstraint = theConstraint; + 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); + } - // Find a constraint with same type uses same arguments - std::vector::iterator aCIt = myConstraints.begin(); - for (; aCIt != myConstraints.end(); aCIt++) { - if (aConstraint.type != aCIt->type) + std::map >::iterator + aConstrIt = myConstraintMap.begin(); + for (; aConstrIt != myConstraintMap.end(); ++aConstrIt) { + if (aConstrIt->first->getKind() != SketchPlugin_ConstraintCoincidence::ID()) continue; - if (aConstraint.ptA == aCIt->ptA && aConstraint.ptB == aCIt->ptB && - aConstraint.entityA == aCIt->entityA && aConstraint.entityB == aCIt->entityB && - aConstraint.entityC == aCIt->entityC && aConstraint.entityD == aCIt->entityD) { - aConstraint.h = aCIt->h; - return updateConstraint(aConstraint); + + 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(); } - } - if (aConstraint.h > myConstrMaxID) - myConstrMaxID = aConstraint.h; - else - aConstraint.h = ++myConstrMaxID; - myConstraints.push_back(aConstraint); - myNeedToResolve = true; - if (aConstraint.type == SLVS_C_POINTS_COINCIDENT) - addCoincidentPoints(aConstraint.ptA, aConstraint.ptB); - return aConstraint.h; -} - -Slvs_hConstraint SketchSolver_Storage::updateConstraint(const Slvs_Constraint& theConstraint) -{ - if (theConstraint.h > 0 && theConstraint.h <= myConstrMaxID) { - // Constraint already used, rewrite it - int aPos = Search(theConstraint.h, myConstraints); - if (aPos >= 0 && aPos < (int)myConstraints.size()) { - myNeedToResolve = myNeedToResolve || IsNotEqual(myConstraints[aPos], theConstraint); - myConstraints[aPos] = theConstraint; - if (theConstraint.type == SLVS_C_POINTS_COINCIDENT) - addCoincidentPoints(theConstraint.ptA, theConstraint.ptB); - return theConstraint.h; + 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]); } - // Constraint is not found, add new one - Slvs_Constraint aConstraint = theConstraint; - aConstraint.h = 0; - return addConstraint(aConstraint); -} - -bool SketchSolver_Storage::removeConstraint(const Slvs_hConstraint& theConstraintID) -{ - bool aResult = true; - int aPos = Search(theConstraintID, myConstraints); - if (aPos >= 0 && aPos < (int)myConstraints.size()) { - Slvs_Constraint aConstraint = myConstraints[aPos]; - myConstraints.erase(myConstraints.begin() + aPos); - myConstrMaxID = myConstraints.empty() ? SLVS_E_UNKNOWN : myConstraints.back().h; - myNeedToResolve = true; - myRemovedConstraints.insert(theConstraintID); - // Remove all entities - Slvs_hEntity anEntities[6] = {aConstraint.ptA, aConstraint.ptB, - aConstraint.entityA, aConstraint.entityB, - aConstraint.entityC, aConstraint.entityD}; - for (int i = 0; i < 6; i++) - if (anEntities[i] != SLVS_E_UNKNOWN) - aResult = removeEntity(anEntities[i]) && aResult; - // remove temporary fixed point, if available - if (myFixed == theConstraintID) - myFixed = SLVS_E_UNKNOWN; + // 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; } - return aResult; -} -const Slvs_Constraint& SketchSolver_Storage::getConstraint(const Slvs_hConstraint& theConstraintID) const -{ - int aPos = Search(theConstraintID, myConstraints); - if (aPos >= 0 && aPos < (int)myConstraints.size()) - return myConstraints[aPos]; + if (aNotCoinc.empty() && aCoincGroups.size() == 1) + return false; - // Constraint is not found, return empty object - static Slvs_Constraint aDummy; - aDummy.h = 0; - return aDummy; -} + // Find all features and constraints uses non-coincident points + replaceEntities(aNotCoinc); -std::list SketchSolver_Storage::getConstraintsByType(int theConstraintType) const -{ - std::list aResult; - std::vector::const_iterator aCIter = myConstraints.begin(); - for (; aCIter != myConstraints.end(); aCIter++) - if (aCIter->type == theConstraintType) - aResult.push_back(*aCIter); - return aResult; -} + // 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); + } -void SketchSolver_Storage::addConstraintWhereDragged(const Slvs_hConstraint& theConstraintID) -{ - if (myFixed != SLVS_E_UNKNOWN) - return; // the point is already fixed - int aPos = Search(theConstraintID, myConstraints); - if (aPos >= 0 && aPos < (int)myConstraints.size()) - myFixed = theConstraintID; + return true; } -void SketchSolver_Storage::addTemporaryConstraint(const Slvs_hConstraint& theConstraintID) +void SketchSolver_Storage::replaceEntities(const std::map& theChange) { - myTemporaryConstraints.insert(theConstraintID); + 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)); } -void SketchSolver_Storage::removeTemporaryConstraints() +bool SketchSolver_Storage::remove(ConstraintWrapperPtr theConstraint) { - myTemporaryConstraints.clear(); + 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; } -bool SketchSolver_Storage::isTemporary(const Slvs_hConstraint& theConstraintID) const +bool SketchSolver_Storage::remove(EntityWrapperPtr theEntity) { - return myTemporaryConstraints.find(theConstraintID) != myTemporaryConstraints.end(); + 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; } -void SketchSolver_Storage::getRemoved( - std::set& theParameters, - std::set& theEntities, - std::set& theConstraints) +bool SketchSolver_Storage::isInteract(const FeaturePtr& theFeature) const { - theParameters = myRemovedParameters; - theEntities = myRemovedEntities; - theConstraints = myRemovedConstraints; + if (!theFeature) + return false; + if (myConstraintMap.empty()) + return true; // empty storage interacts with each feature - myRemovedParameters.clear(); - myRemovedEntities.clear(); - myRemovedConstraints.clear(); + 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; } -void SketchSolver_Storage::initializeSolver(SketchSolver_Solver& theSolver) +bool SketchSolver_Storage::isInteract(const AttributePtr& theAttribute) const { - theSolver.setParameters(myParameters.data(), (int)myParameters.size()); - theSolver.setEntities(myEntities.data(), (int)myEntities.size()); + if (!theAttribute) + return false; - // Copy constraints excluding the fixed one - std::vector aConstraints = myConstraints; - if (myFixed != SLVS_E_UNKNOWN) { - Slvs_hEntity aFixedPoint = SLVS_E_UNKNOWN; - std::vector::iterator anIt = aConstraints.begin(); - for (; anIt != aConstraints.end(); anIt++) - if (anIt->h == myFixed) { - aFixedPoint = anIt->ptA; - aConstraints.erase(anIt); - break; - } - // set dragged parameters - int aPos = Search(aFixedPoint, myEntities); - theSolver.setDraggedParameters(myEntities[aPos].param); - } - theSolver.setConstraints(aConstraints.data(), (int)aConstraints.size()); -} - -void SketchSolver_Storage::addCoincidentPoints( - const Slvs_hEntity& thePoint1, const Slvs_hEntity& thePoint2) -{ - std::vector< std::set >::iterator aCIter = myCoincidentPoints.begin(); - std::vector< std::set >::iterator aFoundIter = myCoincidentPoints.end(); // already found coincidence - bool isFound = false; - for (; aCIter != myCoincidentPoints.end(); aCIter++) { - bool isFirstFound = aCIter->find(thePoint1) != aCIter->end(); - bool isSecondFound = aCIter->find(thePoint2) != aCIter->end(); - isFound = isFound || isFirstFound || isSecondFound; - if (isFirstFound && isSecondFound) - break; // already coincident - else if (isFirstFound || isSecondFound) { - if (aFoundIter != myCoincidentPoints.end()) { - // merge two sets - aFoundIter->insert(aCIter->begin(), aCIter->end()); - myCoincidentPoints.erase(aCIter); - break; - } - aCIter->insert(thePoint1); - aCIter->insert(thePoint2); + 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; } - // coincident points not found - if (!isFound) { - std::set aNewSet; - aNewSet.insert(thePoint1); - aNewSet.insert(thePoint2); - myCoincidentPoints.push_back(aNewSet); - } + + 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); } -void SketchSolver_Storage::removeCoincidentPoint(const Slvs_hEntity& thePoint) +bool SketchSolver_Storage::isConsistent() const { - std::vector< std::set >::iterator aCIter = myCoincidentPoints.begin(); - for (; aCIter != myCoincidentPoints.end(); aCIter++) - if (aCIter->find(thePoint) != aCIter->end()) { - aCIter->erase(thePoint); - if (aCIter->size() <= 1) - myCoincidentPoints.erase(aCIter); - break; - } + // 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++) + if (!aFIter->first->data() || !aFIter->first->data()->isValid()) + return false; + return true; } -bool SketchSolver_Storage::isCoincident( - const Slvs_hEntity& thePoint1, const Slvs_hEntity& thePoint2) const +bool SketchSolver_Storage::isFixed(EntityWrapperPtr theEntity) const { - std::vector< std::set >::const_iterator aCIter = myCoincidentPoints.begin(); - for (; aCIter != myCoincidentPoints.end(); aCIter++) - if (aCIter->find(thePoint1) != aCIter->end() && aCIter->find(thePoint2) != aCIter->end()) - return true; + 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); +} -// ======================================================== -// ========= Auxiliary functions =============== -// ======================================================== +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; + } +} -template -int Search(const uint32_t& theEntityID, const std::vector& theEntities) +void SketchSolver_Storage::blockEvents(bool isBlocked) { - int aResIndex = theEntityID <= theEntities.size() ? theEntityID - 1 : 0; - int aVecSize = theEntities.size(); - if (theEntities.empty()) - return 1; - while (aResIndex >= 0 && theEntities[aResIndex].h > theEntityID) - aResIndex--; - while (aResIndex < aVecSize && aResIndex >= 0 && theEntities[aResIndex].h < theEntityID) - aResIndex++; - if (aResIndex == -1) - aResIndex = aVecSize; - return aResIndex; + 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()) + aFIter->first->data()->blockSendAttributeUpdated(isBlocked); + + std::map::const_iterator anAtIter = myAttributeMap.begin(); + for (; anAtIter != myAttributeMap.end(); anAtIter++) + if (anAtIter->first->owner() && anAtIter->first->owner()->data() && + anAtIter->first->owner()->data()->isValid()) + anAtIter->first->owner()->data()->blockSendAttributeUpdated(isBlocked); + myEventsBlocked = isBlocked; } -bool IsNotEqual(const Slvs_Param& theParam1, const Slvs_Param& theParam2) +std::set SketchSolver_Storage::getConflictingConstraints(SolverPtr theSolver) const { - return fabs(theParam1.val - theParam2.val) > tolerance; + std::set aConflicting; + 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; + } + } + return aConflicting; } -bool IsNotEqual(const Slvs_Entity& theEntity1, const Slvs_Entity& theEntity2) + + + + +// ============== Auxiliary functions ==================================== +bool isEqual(const std::list& theCVec1, + const std::list& theCVec2) { - int i = 0; - for (; theEntity1.param[i] != 0 && i < 4; i++) - if (theEntity1.param[i] != theEntity2.param[i]) - return true; - i = 0; - for (; theEntity1.point[i] != 0 && i < 4; i++) - if (theEntity1.point[i] != theEntity2.point[i]) - return true; - return false; + 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; } -bool IsNotEqual(const Slvs_Constraint& theConstraint1, const Slvs_Constraint& theConstraint2) +void resultToFeatureOrAttribute(const ObjectPtr& theResult, + FeaturePtr& theFeature, AttributePtr& theAttribute) { - return theConstraint1.ptA != theConstraint2.ptA || - theConstraint1.ptB != theConstraint2.ptB || - theConstraint1.entityA != theConstraint2.entityA || - theConstraint1.entityB != theConstraint2.entityB || - theConstraint1.entityC != theConstraint2.entityC || - theConstraint1.entityD != theConstraint2.entityD || - fabs(theConstraint1.valA - theConstraint2.valA) > tolerance; + FeaturePtr aFeature = ModelAPI_Feature::feature(theResult); + // 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, + // 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; }