X-Git-Url: http://git.salome-platform.org/gitweb/?a=blobdiff_plain;f=src%2FSketchSolver%2FSketchSolver_ConstraintCoincidence.cpp;h=a2c3357b6ca82576b782079ea852563290bcaef7;hb=7d7d8eab2109542bd50a90a09c63f8fee1bfbb60;hp=532097e9935d3b2deac470366824d307ee446953;hpb=729ea3c3b62c68de5bb84ebd972a03b8ff069790;p=modules%2Fshaper.git diff --git a/src/SketchSolver/SketchSolver_ConstraintCoincidence.cpp b/src/SketchSolver/SketchSolver_ConstraintCoincidence.cpp index 532097e99..a2c3357b6 100644 --- a/src/SketchSolver/SketchSolver_ConstraintCoincidence.cpp +++ b/src/SketchSolver/SketchSolver_ConstraintCoincidence.cpp @@ -1,262 +1,82 @@ +// Copyright (C) 2014-20xx CEA/DEN, EDF R&D + #include #include -#include - -#include +#include +#include -void SketchSolver_ConstraintCoincidence::getAttributes( - double& theValue, - std::vector& theAttributes) +void SketchSolver_ConstraintCoincidence::process() { - SketchSolver_Constraint::getAttributes(theValue, theAttributes); - if (!myErrorMsg.empty() || theAttributes[0] == SLVS_E_UNKNOWN) + cleanErrorMsg(); + if (!myBaseConstraint || !myStorage) { + // Not enough parameters are assigned return; + } - if (theAttributes[1] != SLVS_E_UNKNOWN) - myType = SLVS_C_POINTS_COINCIDENT; - else if (theAttributes[2] != SLVS_E_UNKNOWN) { - // check the type of entity (line or circle) - Slvs_Entity anEnt = myStorage->getEntity(theAttributes[2]); - if (anEnt.type == SLVS_E_LINE_SEGMENT) - myType = SLVS_C_PT_ON_LINE; - else if (anEnt.type == SLVS_E_CIRCLE || anEnt.type == SLVS_E_ARC_OF_CIRCLE) - myType = SLVS_C_PT_ON_CIRCLE; - else - myErrorMsg = SketchSolver_Error::INCORRECT_ATTRIBUTE(); - } else + EntityWrapperPtr aValue; + std::vector anAttributes; + getAttributes(aValue, anAttributes); + if (!myErrorMsg.empty()) + return; + if (anAttributes.empty()) { myErrorMsg = SketchSolver_Error::INCORRECT_ATTRIBUTE(); -} - - -bool SketchSolver_ConstraintCoincidence::hasConstraint(ConstraintPtr theConstraint) const -{ - if (myBaseConstraint == theConstraint) - return true; - std::map::const_iterator anIt = myExtraCoincidence.begin(); - for (; anIt != myExtraCoincidence.end(); anIt++) - if (anIt->second == theConstraint) - return true; - return false; -} - -std::list SketchSolver_ConstraintCoincidence::constraints() const -{ - std::list aConstraints; - aConstraints.push_back(myBaseConstraint); - std::map::const_iterator anIt = myExtraCoincidence.begin(); - for (; anIt != myExtraCoincidence.end(); anIt++) - aConstraints.push_back(anIt->second); - return aConstraints; -} - -bool SketchSolver_ConstraintCoincidence::isCoincide( - std::shared_ptr theConstraint) const -{ - // Multi-coincidence allowed for two points only - if (getType() != theConstraint->getType() || getType() != SLVS_C_POINTS_COINCIDENT) - return false; - - std::set::const_iterator anAttrIter = theConstraint->myCoincidentPoints.begin(); - for (; anAttrIter != theConstraint->myCoincidentPoints.end(); anAttrIter++) - if (myCoincidentPoints.find(*anAttrIter) != myCoincidentPoints.end()) - return true; - return false; -} - -void SketchSolver_ConstraintCoincidence::attach( - std::shared_ptr theConstraint) -{ - cleanErrorMsg(); - Slvs_Constraint aBaseCoincidence = myStorage->getConstraint(mySlvsConstraints.front()); - // Remove constraints from theConstraint - std::vector::iterator aCIter = theConstraint->mySlvsConstraints.begin(); - for (; aCIter != theConstraint->mySlvsConstraints.end(); aCIter++) - theConstraint->myStorage->removeConstraint(*aCIter); - - if (myStorage == theConstraint->myStorage) { - // Clean removed items - std::set aRemParams; - std::set aRemEnts; - std::set aRemConstr; - theConstraint->myStorage->getRemoved(aRemParams, aRemEnts, aRemConstr); + return; } - // Copy data. - addConstraint(theConstraint->myBaseConstraint); - std::map::iterator aConstrIter = - theConstraint->myExtraCoincidence.begin(); - for (; aConstrIter != theConstraint->myExtraCoincidence.end(); aConstrIter++) - addConstraint(aConstrIter->second); - // Clear the lists to not remove the entities on destruction - theConstraint->mySlvsConstraints.clear(); - theConstraint->myFeatureMap.clear(); - theConstraint->myAttributeMap.clear(); -} + mySolverConstraint = PlaneGCSSolver_Tools::createConstraint( + myBaseConstraint, getType(), + aValue, anAttributes[0], anAttributes[1], anAttributes[2], anAttributes[3]); -Slvs_hConstraint SketchSolver_ConstraintCoincidence::addConstraint( - Slvs_hEntity thePoint1, Slvs_hEntity thePoint2) -{ - bool hasDuplicated = myStorage->hasDuplicatedConstraint(); - Slvs_Constraint aNewConstraint = Slvs_MakeConstraint(SLVS_E_UNKNOWN, myGroup->getId(), - SLVS_C_POINTS_COINCIDENT, myGroup->getWorkplaneId(), 0.0, thePoint1, thePoint2, - SLVS_E_UNKNOWN, SLVS_E_UNKNOWN); - Slvs_hConstraint aNewID = myStorage->addConstraint(aNewConstraint); - if (!hasDuplicated && myStorage->hasDuplicatedConstraint()) { - // the duplicated constraint appears - myStorage->removeConstraint(aNewID); - return SLVS_E_UNKNOWN; - } - mySlvsConstraints.push_back(aNewID); - return aNewID; + myStorage->subscribeUpdates(this, PlaneGCSSolver_UpdateCoincidence::GROUP()); + myStorage->notify(myBaseConstraint); } -void SketchSolver_ConstraintCoincidence::addConstraint(ConstraintPtr theConstraint) +bool SketchSolver_ConstraintCoincidence::remove() { - std::list anAttrList = - theConstraint->data()->attributes(ModelAPI_AttributeRefAttr::typeId()); - std::list::iterator anIter = anAttrList.begin(); - std::vector anEntities; - for (; anIter != anAttrList.end(); anIter++) { - AttributeRefAttrPtr aRefAttr = std::dynamic_pointer_cast(*anIter); - if (!aRefAttr || aRefAttr->isObject() || - myAttributeMap.find(aRefAttr->attr()) != myAttributeMap.end()) - continue; - int aType; - Slvs_hEntity anEntityID = myGroup->getAttributeId(aRefAttr->attr()); - if (anEntityID == SLVS_E_UNKNOWN) - anEntityID = changeEntity(aRefAttr->attr(), aType); - anEntities.push_back(anEntityID); - myCoincidentPoints.insert(aRefAttr->attr()); - } - - Slvs_Constraint aBaseCoincidence = myStorage->getConstraint(mySlvsConstraints.front()); - Slvs_hConstraint aNewConstr = SLVS_E_UNKNOWN; - std::vector::iterator anEntIter = anEntities.begin(); - for (; anEntIter != anEntities.end(); anEntIter++) - aNewConstr = addConstraint(aBaseCoincidence.ptA, *anEntIter); - myExtraCoincidence[aNewConstr] = theConstraint; + myInSolver = false; + return SketchSolver_Constraint::remove(); } -void SketchSolver_ConstraintCoincidence::process() +void SketchSolver_ConstraintCoincidence::getAttributes( + EntityWrapperPtr& theValue, + std::vector& theAttributes) { - SketchSolver_Constraint::process(); - - // Fill the list of coincident points - std::list anAttrList = - myBaseConstraint->data()->attributes(ModelAPI_AttributeRefAttr::typeId()); - std::list::iterator anIt = anAttrList.begin(); - for (; anIt != anAttrList.end(); anIt++) { - AttributeRefAttrPtr aRefAttr = std::dynamic_pointer_cast(*anIt); - if (!aRefAttr || aRefAttr->isObject()) - continue; - myCoincidentPoints.insert(aRefAttr->attr()); + SketchSolver_Constraint::getAttributes(theValue, theAttributes); + if (!myErrorMsg.empty() || !theAttributes[0]) { + theAttributes.clear(); + return; } + + if (theAttributes[1]) + myType = CONSTRAINT_PT_PT_COINCIDENT; + else if (theAttributes[2]) { + // check the type of entity (line or circle) + SketchSolver_EntityType anEntType = theAttributes[2]->type(); + if (anEntType == ENTITY_LINE) + myType = CONSTRAINT_PT_ON_LINE; + else if (anEntType == ENTITY_CIRCLE || anEntType == ENTITY_ARC) + myType = CONSTRAINT_PT_ON_CIRCLE; + else + myErrorMsg = SketchSolver_Error::INCORRECT_ATTRIBUTE(); + } else + myErrorMsg = SketchSolver_Error::INCORRECT_ATTRIBUTE(); } -bool SketchSolver_ConstraintCoincidence::remove(ConstraintPtr theConstraint) +void SketchSolver_ConstraintCoincidence::notify(const FeaturePtr& theFeature, + PlaneGCSSolver_Update* theUpdater) { - cleanErrorMsg(); - if (mySlvsConstraints.empty()) - return true; - ConstraintPtr aConstraint = theConstraint ? theConstraint : myBaseConstraint; - int aPos = -1; // position of constraint in the list (-1 for base constraint) - std::map::iterator anExtraIt; - if (aConstraint != myBaseConstraint) { - anExtraIt = myExtraCoincidence.begin(); - for (aPos = 0; anExtraIt != myExtraCoincidence.end(); anExtraIt++, aPos++) - if (anExtraIt->second == aConstraint) - break; - if (aPos >= (int)myExtraCoincidence.size()) - return false; // there is no constraint, which is specified to remove - else { - bool isEmpty = anExtraIt->first == SLVS_E_UNKNOWN; - if (!isEmpty) { - for (aPos = 0; aPos < (int)mySlvsConstraints.size(); aPos++) - if (mySlvsConstraints[aPos] == anExtraIt->first) - break; - aPos -= 1; - } - myExtraCoincidence.erase(anExtraIt); - if (isEmpty) - return false; - } - } - - bool isFullyRemoved = myStorage->removeConstraint(mySlvsConstraints[aPos+1]); - mySlvsConstraints.erase(mySlvsConstraints.begin() + (1+aPos)); - if (aPos < 0 && !myExtraCoincidence.empty()) { - anExtraIt = myExtraCoincidence.begin(); - // Remove invalid constraints - while (anExtraIt != myExtraCoincidence.end()) { - if (!anExtraIt->second->data() || !anExtraIt->second->data()->isValid()) { - std::map::iterator aTempIt = anExtraIt++; - if (aTempIt->first != SLVS_E_UNKNOWN) { - myStorage->removeConstraint(aTempIt->first); - std::vector::iterator anIt = mySlvsConstraints.begin(); - for (; anIt != mySlvsConstraints.end(); anIt++) - if (*anIt == aTempIt->first) { - mySlvsConstraints.erase(anIt); - break; - } - } - myExtraCoincidence.erase(aTempIt); - continue; - } - anExtraIt++; + PlaneGCSSolver_UpdateCoincidence* anUpdater = + static_cast(theUpdater); + bool isAccepted = anUpdater->checkCoincidence(myAttributes.front(), myAttributes.back()); + if (isAccepted) { + if (!myInSolver) { + myInSolver = true; + myStorage->addConstraint(myBaseConstraint, mySolverConstraint); } - // Find first non-extra conststraint - anExtraIt = myExtraCoincidence.begin(); - while (anExtraIt != myExtraCoincidence.end() && anExtraIt->first == SLVS_E_UNKNOWN) - anExtraIt++; - if (anExtraIt != myExtraCoincidence.end()) { - // Need to specify another base coincidence constraint - myBaseConstraint = anExtraIt->second; - myExtraCoincidence.erase(anExtraIt); - std::vector::iterator aCIter = mySlvsConstraints.begin(); - Slvs_Constraint aBase = myStorage->getConstraint(*aCIter); - for (++aCIter; aCIter != mySlvsConstraints.end(); aCIter++) { - Slvs_Constraint aConstr = myStorage->getConstraint(*aCIter); - aConstr.ptA = aBase.ptA; - myStorage->updateConstraint(aConstr); - } + } else { + if (myInSolver) { + myInSolver = false; + myStorage->removeConstraint(myBaseConstraint); } } - // Clear removed attributes - std::set aParamRemoved; - std::set anEntRemoved; - std::set aConstrRemoved; - myStorage->getRemoved(aParamRemoved, anEntRemoved, aConstrRemoved); - std::map::iterator anAttrIter = myAttributeMap.begin(); - while (anAttrIter != myAttributeMap.end()) { - if (anEntRemoved.find(anAttrIter->second) != anEntRemoved.end()) { - std::map::iterator aTempIt = anAttrIter++; - myCoincidentPoints.erase(aTempIt->first); - myAttributeMap.erase(aTempIt); - continue; - } - anAttrIter++; - } - - // Go through remaining extra coincidence and try to add or remove them - anExtraIt = myExtraCoincidence.begin(); - while (anExtraIt != myExtraCoincidence.end()) { - if (anExtraIt->first == SLVS_E_UNKNOWN) { - if (!anExtraIt->second->data() || !anExtraIt->second->data()->isValid()) { - std::map::iterator aTempIt = anExtraIt++; - myExtraCoincidence.erase(aTempIt); - continue; - } - if (mySlvsConstraints.empty()) { - myBaseConstraint = anExtraIt->second; - std::map::iterator aTempIt = anExtraIt++; - myExtraCoincidence.erase(aTempIt); - process(); - continue; - } else - addConstraint(anExtraIt->second); - } - anExtraIt++; - } - return mySlvsConstraints.empty(); } -