X-Git-Url: http://git.salome-platform.org/gitweb/?a=blobdiff_plain;f=src%2FSketchSolver%2FSolveSpaceSolver%2FSolveSpaceSolver_Storage.cpp;h=999f43eefc46a7e7451a83382f998de382839106;hb=cf8f82e87c5bec5bef69549ce628bfdb093b92a1;hp=d48730926de2283aa027aedee5272dbf776bf200;hpb=8e3ea4b8a0e09cfb299a7a74f97b2df3f7f1b657;p=modules%2Fshaper.git diff --git a/src/SketchSolver/SolveSpaceSolver/SolveSpaceSolver_Storage.cpp b/src/SketchSolver/SolveSpaceSolver/SolveSpaceSolver_Storage.cpp index d48730926..999f43eef 100644 --- a/src/SketchSolver/SolveSpaceSolver/SolveSpaceSolver_Storage.cpp +++ b/src/SketchSolver/SolveSpaceSolver/SolveSpaceSolver_Storage.cpp @@ -19,7 +19,9 @@ #include #include #include +#include #include +#include /** \brief Search the entity/parameter with specified ID in the list of elements * \param[in] theEntityID unique ID of the element @@ -48,7 +50,7 @@ SolveSpaceSolver_Storage::SolveSpaceSolver_Storage(const GroupID& theGroup) { } -bool SolveSpaceSolver_Storage::update(ConstraintWrapperPtr& theConstraint) +bool SolveSpaceSolver_Storage::update(ConstraintWrapperPtr theConstraint) { bool isUpdated = false; std::shared_ptr aConstraint = @@ -109,7 +111,7 @@ bool SolveSpaceSolver_Storage::update(ConstraintWrapperPtr& theConstraint) return isUpdated; } -bool SolveSpaceSolver_Storage::update(EntityWrapperPtr& theEntity) +bool SolveSpaceSolver_Storage::update(EntityWrapperPtr theEntity) { bool isUpdated = false; std::shared_ptr anEntity = @@ -178,33 +180,18 @@ bool SolveSpaceSolver_Storage::update(EntityWrapperPtr& theEntity) if (aSlvsEnt.group == SLVS_G_UNKNOWN) aSlvsEnt.group = (Slvs_hGroup)myGroupID; Slvs_hEntity anEntID = updateEntity(aSlvsEnt); - if (aSlvsEnt.h == SLVS_E_UNKNOWN) { + if (aSlvsEnt.h == SLVS_E_UNKNOWN || isUpdated) { anEntity->changeEntity() = getEntity(anEntID); isUpdated = true; if (anEntity->type() == ENTITY_SKETCH) storeWorkplane(anEntity); - - // For the correct work with arcs we will add them if their parameter is added - if (theEntity->baseAttribute()) { - FeaturePtr aFeature = ModelAPI_Feature::feature(theEntity->baseAttribute()->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()) { - myFeatureMap[aFeature] = EntityWrapperPtr(); - return SketchSolver_Storage::update(aFeature); - } - } - } } return isUpdated; } -bool SolveSpaceSolver_Storage::update(ParameterWrapperPtr& theParameter) +bool SolveSpaceSolver_Storage::update(ParameterWrapperPtr theParameter) { std::shared_ptr aParameter = std::dynamic_pointer_cast(theParameter); @@ -1475,6 +1462,105 @@ bool SolveSpaceSolver_Storage::isUsedInEqual( } +bool SolveSpaceSolver_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 + + // Create new copies of coincident points + BuilderPtr aBuilder = SolveSpaceSolver_Builder::getInstance(); + std::list aNewPoints; + for (aPIt = aPoints.begin(); aPIt != aPoints.end(); ++aPIt) + aNewPoints.push_back(aBuilder->createAttribute( + (*aPIt)->baseAttribute(), myGroupID, myWorkplaneID)); + + // Find all points fallen out of group of coincident points + std::map aNotCoinc; + aNotCoinc[aPtPtIt->first] = EntityWrapperPtr(); + std::set::const_iterator aTempIt = aPtPtIt->second.begin(); + for (; aTempIt != aPtPtIt->second.end(); ++aTempIt) + aNotCoinc[*aTempIt] = EntityWrapperPtr(); + std::map >::iterator + aConstrIt = myConstraintMap.begin(); + for (; aConstrIt != myConstraintMap.end(); ++aConstrIt) + if (aConstrIt->first->getKind() == SketchPlugin_ConstraintCoincidence::ID()) { + AttributeRefAttrPtr aRefAttrA = std::dynamic_pointer_cast( + aConstrIt->first->attribute(SketchPlugin_Constraint::ENTITY_A())); + AttributeRefAttrPtr aRefAttrB = std::dynamic_pointer_cast( + aConstrIt->first->attribute(SketchPlugin_Constraint::ENTITY_B())); + if (!aRefAttrA || !aRefAttrB || aRefAttrA->isObject() || aRefAttrB->isObject()) + continue; + std::map::iterator + aFound = myAttributeMap.find(aRefAttrA->attr()); + if (aFound != myAttributeMap.end()) + aNotCoinc.erase(aFound->second); + aFound = myAttributeMap.find(aRefAttrB->attr()); + if (aFound != myAttributeMap.end()) + aNotCoinc.erase(aFound->second); + } + if (aNotCoinc.empty()) + return false; + std::list::const_iterator aNewPIt; + for (aPIt = aPoints.begin(), aNewPIt = aNewPoints.begin(); + aPIt != aPoints.end(); ++aPIt, ++aNewPIt) { + if (aNotCoinc.find(*aPIt) != aNotCoinc.end()) + aNotCoinc[*aPIt] = *aNewPIt; + } + + // Find all features and constraints uses coincident points + std::map::iterator aNotCIt; + std::set anUpdFeatures; + std::map::iterator aFIt = myFeatureMap.begin(); + for (; aFIt != myFeatureMap.end(); ++aFIt) { + for (aNotCIt = aNotCoinc.begin(); aNotCIt != aNotCoinc.end(); ++aNotCIt) { + if (!aFIt->second->isUsed(aNotCIt->first->baseAttribute())) + continue; + std::list aSubs = aFIt->second->subEntities(); + std::list::iterator aSIt = aSubs.begin(); + for (; aSIt != aSubs.end(); ++aSIt) + if (*aSIt == aNotCIt->first) + *aSIt = aNotCIt->second; + aFIt->second->setSubEntities(aSubs); + anUpdFeatures.insert(aFIt->second); + } + } + // update features + std::set::iterator anUpdIt = anUpdFeatures.begin(); + for (; anUpdIt != anUpdFeatures.end(); ++anUpdIt) + update(EntityWrapperPtr(*anUpdIt)); + + // remove not coincident points + for (aNotCIt = aNotCoinc.begin(); aNotCIt != aNotCoinc.end(); ++aNotCIt) { + if (aPtPtIt->second.size() <= 1) { + myCoincidentPoints.erase(aPtPtIt); + break; + } + if (aPtPtIt->first == aNotCIt->first) { + std::set aSlaves = aPtPtIt->second; + EntityWrapperPtr aNewMaster = *aSlaves.begin(); + aSlaves.erase(aSlaves.begin()); + myCoincidentPoints[aNewMaster] = aSlaves; + myCoincidentPoints.erase(aPtPtIt); + aPtPtIt = myCoincidentPoints.find(aNewMaster); + } else + aPtPtIt->second.erase(aNotCIt->first); + } + return true; +} + bool SolveSpaceSolver_Storage::remove(ConstraintWrapperPtr theConstraint) { std::shared_ptr aConstraint = @@ -1491,6 +1577,11 @@ bool SolveSpaceSolver_Storage::remove(ConstraintWrapperPtr theConstraint) return true; bool isFullyRemoved = removeConstraint((Slvs_hConstraint)aConstraint->id()); + + // remove point-point coincidence + if (aConstraint->type() == CONSTRAINT_PT_PT_COINCIDENT) + isFullyRemoved = removeCoincidence(theConstraint); + return SketchSolver_Storage::remove(theConstraint) && isFullyRemoved; } @@ -1519,6 +1610,8 @@ void SolveSpaceSolver_Storage::refresh(bool theFixedOnly) const std::list aParams; std::list::const_iterator aParIt; for (; anIt != myAttributeMap.end(); ++anIt) { + if (!anIt->second) + continue; // the external feature always should keep the up to date values, so, // refresh from the solver is never needed if (anIt->first.get()) { @@ -1591,6 +1684,8 @@ void SolveSpaceSolver_Storage::verifyFixed() { std::map::iterator anAttrIt = myAttributeMap.begin(); for (; anAttrIt != myAttributeMap.end(); ++anAttrIt) { + if (!anAttrIt->second) + continue; const std::list& aParameters = anAttrIt->second->parameters(); std::list::const_iterator aParIt = aParameters.begin(); for (; aParIt != aParameters.end(); ++aParIt)