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=809bef132cf4fa9e5c9591990dbfe151b55c4cd1;hpb=ebca2e1b92ff164b5a9438e2353b4c2df2c3c7e8;p=modules%2Fshaper.git diff --git a/src/SketchSolver/SketchSolver_Storage.cpp b/src/SketchSolver/SketchSolver_Storage.cpp index 809bef132..d1f6c4f17 100644 --- a/src/SketchSolver/SketchSolver_Storage.cpp +++ b/src/SketchSolver/SketchSolver_Storage.cpp @@ -14,7 +14,11 @@ #include #include #include +#include +#include +#include #include +#include /// \brief Verify two vectors of constraints are equal. @@ -22,6 +26,10 @@ 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) @@ -85,6 +93,8 @@ void SketchSolver_Storage::addConstraint( 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())); @@ -96,7 +106,8 @@ static std::list pointAttributes(FeaturePtr theFeature) 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()) + else if (theFeature->getKind() == SketchPlugin_Point::ID() || + theFeature->getKind() == SketchPlugin_IntersectionPoint::ID()) aPoints.push_back(theFeature->attribute(SketchPlugin_Point::COORD_ID())); return aPoints; } @@ -128,7 +139,8 @@ void SketchSolver_Storage::addEntity(FeaturePtr theFeature, void SketchSolver_Storage::addEntity(AttributePtr theAttribute, EntityWrapperPtr theSolverEntity) { - std::map::const_iterator aFound = myAttributeMap.find(theAttribute); + 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 @@ -142,11 +154,38 @@ void SketchSolver_Storage::addEntity(AttributePtr theAttribute, } -bool SketchSolver_Storage::update(FeaturePtr theFeature, const GroupID& theGroup) +static bool isCopyInMulti(std::shared_ptr theFeature, + const std::map >& theConstraints) +{ + 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; + } + } + 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; @@ -154,13 +193,15 @@ bool SketchSolver_Storage::update(FeaturePtr theFeature, const GroupID& theGroup std::list anAttrs = pointAttributes(theFeature); std::list::const_iterator anIt = anAttrs.begin(); for (; anIt != anAttrs.end(); ++anIt) { - isUpdated = update(*anIt, theGroup) || isUpdated; + if (!(*anIt)->isInitialized()) + return false; + isUpdated = update(*anIt, theGroup, theForce) || isUpdated; aSubs.push_back(entity(*anIt)); } // If the feature is a circle, add its radius as a sub if (theFeature->getKind() == SketchPlugin_Circle::ID()) { AttributePtr aRadius = theFeature->attribute(SketchPlugin_Circle::RADIUS_ID()); - isUpdated = update(aRadius, theGroup) || isUpdated; + isUpdated = update(aRadius, theGroup, theForce) || isUpdated; aSubs.push_back(entity(aRadius)); } // If the feature if circle or arc, we need to add normal of the sketch to the list of subs @@ -173,9 +214,7 @@ bool SketchSolver_Storage::update(FeaturePtr theFeature, const GroupID& theGroup 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()) + if (aSketchFeature && (aSketchFeature->isExternal() || isCopy)) aGroup = GID_OUTOFGROUP; aRelated = aBuilder->createFeature(theFeature, aSubs, aGroup); if (!aRelated) @@ -186,16 +225,24 @@ bool SketchSolver_Storage::update(FeaturePtr theFeature, const GroupID& theGroup return update(aRelated) || isUpdated; } -bool SketchSolver_Storage::update(AttributePtr theAttribute, const GroupID& theGroup) +bool SketchSolver_Storage::update(AttributePtr theAttribute, const GroupID& theGroup, bool theForce) { + if (!theAttribute->isInitialized()) + return false; + AttributePtr anAttribute = theAttribute; AttributeRefAttrPtr aRefAttr = std::dynamic_pointer_cast(anAttribute); if (aRefAttr) { if (aRefAttr->isObject()) { - FeaturePtr aFeature = ModelAPI_Feature::feature(aRefAttr->object()); - return update(aFeature, theGroup); - } else + FeaturePtr aFeature; + resultToFeatureOrAttribute(aRefAttr->object(), aFeature, anAttribute); + if (aFeature) + return update(aFeature, theGroup, theForce); + } else { anAttribute = aRefAttr->attr(); + if (!anAttribute->isInitialized()) + return false; + } } EntityWrapperPtr aRelated = entity(anAttribute); @@ -206,10 +253,10 @@ bool SketchSolver_Storage::update(AttributePtr theAttribute, const GroupID& theG 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() && + 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); + return SketchSolver_Storage::update(aFeature, theGroup, theForce); } else { myFeatureMap[aFeature] = EntityWrapperPtr(); myExistArc = true; @@ -219,9 +266,10 @@ bool SketchSolver_Storage::update(AttributePtr theAttribute, const GroupID& theG 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()) + 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) @@ -269,8 +317,13 @@ const EntityWrapperPtr& SketchSolver_Storage::entity(const AttributePtr& theAttr std::dynamic_pointer_cast(theAttribute); if (aRefAttr) { if (aRefAttr->isObject()) { - FeaturePtr aFeature = ModelAPI_Feature::feature(aRefAttr->object()); - return entity(aFeature); + FeaturePtr aFeature; + AttributePtr anAttribute; + resultToFeatureOrAttribute(aRefAttr->object(), aFeature, anAttribute); + if (aFeature) + return entity(aFeature); + else + return entity(anAttribute); } else return entity(aRefAttr->attr()); } @@ -325,11 +378,11 @@ static bool isUsed(EntityWrapperPtr theFeature, AttributePtr theSubEntity) return false; } -static bool isUsed(ConstraintPtr theConstraint, AttributePtr theAttribute) +static bool isUsed(FeaturePtr theFeature, AttributePtr theAttribute) { - if (!theConstraint || !theAttribute) + if (!theFeature || !theAttribute) return false; - std::list anAttrList = theConstraint->data()->attributes(std::string()); + std::list anAttrList = theFeature->data()->attributes(std::string()); std::list::const_iterator anIt = anAttrList.begin(); for (; anIt != anAttrList.end(); ++anIt) { if (*anIt == theAttribute) @@ -385,7 +438,7 @@ bool SketchSolver_Storage::isUsed(AttributePtr theAttribute) const return true; // Additional check for the Fixed constraints, which have no wrapper associated. if (aCIt->first->getKind() == SketchPlugin_ConstraintRigid::ID() && - ::isUsed(aCIt->first, anAttribute)) + ::isUsed(FeaturePtr(aCIt->first), anAttribute)) return true; } // check in features @@ -435,6 +488,203 @@ bool SketchSolver_Storage::removeEntity(AttributePtr theAttribute) 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; +} + +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) { @@ -445,7 +695,8 @@ bool SketchSolver_Storage::remove(ConstraintWrapperPtr theConstraint) if (aBaseFeature) isFullyRemoved = SketchSolver_Storage::removeEntity(aBaseFeature) && isFullyRemoved; else - isFullyRemoved = SketchSolver_Storage::removeEntity((*anIt)->baseAttribute()) && isFullyRemoved; + isFullyRemoved = + SketchSolver_Storage::removeEntity((*anIt)->baseAttribute()) && isFullyRemoved; } return isFullyRemoved; } @@ -458,8 +709,13 @@ bool SketchSolver_Storage::remove(EntityWrapperPtr theEntity) FeaturePtr aBaseFeature = (*anEntIt)->baseFeature(); if (aBaseFeature) isFullyRemoved = SketchSolver_Storage::removeEntity(aBaseFeature) && isFullyRemoved; - else - isFullyRemoved = SketchSolver_Storage::removeEntity((*anEntIt)->baseAttribute()) && isFullyRemoved; + else { + AttributePtr aBaseAttr = (*anEntIt)->baseAttribute(); + if (aBaseAttr) + isFullyRemoved = SketchSolver_Storage::removeEntity(aBaseAttr) && isFullyRemoved; + else + remove(*anEntIt); + } } std::list::const_iterator aParIt = theEntity->parameters().begin(); @@ -497,7 +753,7 @@ bool SketchSolver_Storage::isInteract(const AttributePtr& theAttribute) const if (!theAttribute) return false; - AttributeRefListPtr aRefList = + AttributeRefListPtr aRefList = std::dynamic_pointer_cast(theAttribute); if (aRefList) { std::list anObjects = aRefList->list(); @@ -556,7 +812,8 @@ bool SketchSolver_Storage::isFixed(EntityWrapperPtr theEntity) const return true; } - std::map >::const_iterator aCIt = myConstraintMap.begin(); + std::map >::const_iterator aCIt = + myConstraintMap.begin(); std::list::const_iterator aCWIt; for (; aCIt != myConstraintMap.end(); ++aCIt) { if (aCIt->second.empty()) @@ -638,8 +895,8 @@ void SketchSolver_Storage::processArcs() 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() && + 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 @@ -718,3 +975,25 @@ bool isEqual(const std::list& theCVec1, } return true; } + +void resultToFeatureOrAttribute(const ObjectPtr& theResult, + FeaturePtr& theFeature, AttributePtr& theAttribute) +{ + FeaturePtr aFeature = ModelAPI_Feature::feature(theResult); + // if the feature has several results, we choose which one is referred + const std::list& 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; +}