X-Git-Url: http://git.salome-platform.org/gitweb/?a=blobdiff_plain;f=src%2FSketchSolver%2FSketchSolver_Storage.cpp;h=c63d28e437a662c61818cf2c85b400e6f0f3516d;hb=8476d5e088f7b1b5a414fa5e33ce99d6131929eb;hp=2e283a90f6cde0897740b187b0570429134d9237;hpb=4e04f27e9f9639aaf902c9221e494677c70b94ae;p=modules%2Fshaper.git diff --git a/src/SketchSolver/SketchSolver_Storage.cpp b/src/SketchSolver/SketchSolver_Storage.cpp index 2e283a90f..c63d28e43 100644 --- a/src/SketchSolver/SketchSolver_Storage.cpp +++ b/src/SketchSolver/SketchSolver_Storage.cpp @@ -12,6 +12,10 @@ #include #include #include +#include +#include +#include +#include /// \brief Verify two vectors of constraints are equal. @@ -23,8 +27,11 @@ static bool isEqual(const std::list& theCVec1, void SketchSolver_Storage::addConstraint(ConstraintPtr theConstraint, ConstraintWrapperPtr theSolverConstraint) { - std::list aConstrList(1, theSolverConstraint); - addConstraint(theConstraint, aConstrList); + if (theSolverConstraint) { + std::list aConstrList(1, theSolverConstraint); + addConstraint(theConstraint, aConstrList); + } else + addConstraint(theConstraint, std::list()); } void SketchSolver_Storage::addConstraint( @@ -36,28 +43,85 @@ void SketchSolver_Storage::addConstraint( if (aFound == myConstraintMap.end() || !isEqual(aFound->second, theSolverConstraints)) setNeedToResolve(true); - // Do not add point-point coincidence, because it is already made by setting - // the same parameters for both points - if (!theSolverConstraints.empty() && - theSolverConstraints.front()->type() != CONSTRAINT_PT_PT_COINCIDENT) { + if (theSolverConstraints.empty()) { + // constraint links to the empty list, add its attributes linked to the empty entities + std::list 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); } - myConstraintMap[theConstraint] = theSolverConstraints; + + if (!theSolverConstraints.empty() || aFound == myConstraintMap.end()) + myConstraintMap[theConstraint] = theSolverConstraints; // block events if necessary - if (myEventsBlocked && theConstraint->data() && theConstraint->data()->isValid()) + if (myEventsBlocked && theConstraint && theConstraint->data() && theConstraint->data()->isValid()) theConstraint->data()->blockSendAttributeUpdated(myEventsBlocked); } +static std::list pointAttributes(FeaturePtr theFeature) +{ + std::list 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 || !aFound->second->isEqual(theSolverEntity)) + if (aFound == myFeatureMap.end() || !aFound->second || + (theSolverEntity && !aFound->second->isEqual(theSolverEntity))) setNeedToResolve(true); // the entity is new or modified - myFeatureMap[theFeature] = theSolverEntity; + if (!theSolverEntity) { + // feature links to the empty entity, add its attributes + std::list 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); @@ -67,10 +131,12 @@ void SketchSolver_Storage::addEntity(AttributePtr theAttribute, EntityWrapperPtr theSolverEntity) { std::map::const_iterator aFound = myAttributeMap.find(theAttribute); - if (aFound == myAttributeMap.end() || !aFound->second || !aFound->second->isEqual(theSolverEntity)) + if (aFound == myAttributeMap.end() || !aFound->second || + (theSolverEntity && !aFound->second->isEqual(theSolverEntity))) setNeedToResolve(true); // the entity is new or modified - myAttributeMap[theAttribute] = theSolverEntity; + if (theSolverEntity || aFound == myAttributeMap.end()) + myAttributeMap[theAttribute] = theSolverEntity; // block events if necessary if (myEventsBlocked && theAttribute->owner() && theAttribute->owner()->data() && theAttribute->owner()->data()->isValid()) @@ -87,8 +153,7 @@ bool SketchSolver_Storage::update(FeaturePtr theFeature, const GroupID& theGroup // 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 = - theFeature->data()->attributes(GeomDataAPI_Point2D::typeId()); + std::list anAttrs = pointAttributes(theFeature); std::list::const_iterator anIt = anAttrs.begin(); for (; anIt != anAttrs.end(); ++anIt) { isUpdated = update(*anIt, theGroup) || isUpdated; @@ -109,6 +174,11 @@ bool SketchSolver_Storage::update(FeaturePtr theFeature, const GroupID& theGroup // Secondly, convert feature BuilderPtr aBuilder = SketchSolver_Manager::instance()->builder(); GroupID aGroup = theGroup != GID_UNKNOWN ? theGroup : myGroupID; + // Check external feature + std::shared_ptr aSketchFeature = + std::dynamic_pointer_cast(theFeature); + if (aSketchFeature && aSketchFeature->isExternal()) + aGroup = GID_OUTOFGROUP; aRelated = aBuilder->createFeature(theFeature, aSubs, aGroup); if (!aRelated) return false; @@ -132,8 +202,29 @@ bool SketchSolver_Storage::update(AttributePtr theAttribute, const GroupID& theG 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); + } 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(theAttribute->owner()); + if (aSketchFeature && aSketchFeature->isExternal()) + aGroup = GID_OUTOFGROUP; aRelated = aBuilder->createAttribute(anAttribute, aGroup); if (!aRelated) return false; @@ -210,16 +301,14 @@ bool SketchSolver_Storage::removeConstraint(ConstraintPtr theConstraint) ++anIt; } } - if (!isFullyRemoved) { - // revert removed constraint - addConstraint(theConstraint, aConstrList); - } 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)) @@ -229,6 +318,8 @@ static bool isUsed(ConstraintWrapperPtr theConstraint, ENT_TYPE theEntity) 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)) @@ -236,6 +327,22 @@ static bool isUsed(EntityWrapperPtr theFeature, AttributePtr theSubEntity) return false; } +static bool isUsed(ConstraintPtr theConstraint, AttributePtr theAttribute) +{ + if (!theConstraint || !theAttribute) + return false; + std::list anAttrList = theConstraint->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()) @@ -249,7 +356,7 @@ bool SketchSolver_Storage::isUsed(FeaturePtr theFeature) const if (::isUsed(*aCWIt, theFeature)) return true; // check attributes - std::list anAttrList = theFeature->data()->attributes(GeomDataAPI_Point2D::typeId()); + std::list anAttrList = pointAttributes(theFeature); std::list::const_iterator anIt = anAttrList.begin(); for (; anIt != anAttrList.end(); ++anIt) if (isUsed(*anIt)) @@ -274,10 +381,15 @@ bool SketchSolver_Storage::isUsed(AttributePtr theAttribute) const std::map >::const_iterator aCIt = myConstraintMap.begin(); std::list::const_iterator aCWIt; - for (; aCIt != myConstraintMap.end(); ++aCIt) + for (; aCIt != myConstraintMap.end(); ++aCIt) { for (aCWIt = aCIt->second.begin(); aCWIt != aCIt->second.end(); ++aCWIt) if (::isUsed(*aCWIt, anAttribute)) return true; + // Additional check for the Fixed constraints, which have no wrapper associated. + if (aCIt->first->getKind() == SketchPlugin_ConstraintRigid::ID() && + ::isUsed(aCIt->first, anAttribute)) + return true; + } // check in features std::map::const_iterator aFIt = myFeatureMap.begin(); for (; aFIt != myFeatureMap.end(); ++aFIt) @@ -291,17 +403,15 @@ bool SketchSolver_Storage::removeEntity(FeaturePtr theFeature) { std::map::iterator aFound = myFeatureMap.find(theFeature); if (aFound == myFeatureMap.end()) - return false; // feature not found, nothing to delete + return true; // feature not found, nothing to delete - // Check the feature is not used by constraints - if (isUsed(theFeature)) - return false; // the feature is used, don't remove it - - // Remove feature EntityWrapperPtr anEntity = aFound->second; myFeatureMap.erase(aFound); - if (remove(anEntity)) + + // Check if the feature is not used by constraints, remove it + if (!anEntity || (!isUsed(theFeature) && remove(anEntity))) return true; + // feature is not removed, revert operation myFeatureMap[theFeature] = anEntity; update(anEntity); @@ -312,22 +422,15 @@ bool SketchSolver_Storage::removeEntity(AttributePtr theAttribute) { std::map::iterator aFound = myAttributeMap.find(theAttribute); if (aFound == myAttributeMap.end()) - return false; // attribute not found, nothing to delete - - // Check the attribute is not used by constraints - if (isUsed(theAttribute)) - return false; // the attribute is used, don't remove it - // Check the attribute is not used by other features - std::map::const_iterator aFIt = myFeatureMap.begin(); - for (; aFIt != myFeatureMap.end(); ++aFIt) - if (::isUsed(aFIt->second, theAttribute)) // the attribute is used, don't remove it - return false; + return true; // attribute not found, nothing to delete - // Remove attribute EntityWrapperPtr anEntity = aFound->second; myAttributeMap.erase(aFound); - if (remove(anEntity)) + + // Check if the attribute is not used by constraints and features, remove it + if (!anEntity || (!isUsed(theAttribute) && remove(anEntity))) return true; + // attribute is not removed, revert operation myAttributeMap[theAttribute] = anEntity; update(anEntity); @@ -454,6 +557,21 @@ bool SketchSolver_Storage::isFixed(EntityWrapperPtr theEntity) const 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; } @@ -515,6 +633,22 @@ void SketchSolver_Storage::setSketch(const EntityWrapperPtr& theSketch) 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) @@ -539,6 +673,21 @@ void SketchSolver_Storage::blockEvents(bool isBlocked) myEventsBlocked = isBlocked; } +std::set SketchSolver_Storage::getConflictingConstraints(SolverPtr theSolver) const +{ + 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; +}