X-Git-Url: http://git.salome-platform.org/gitweb/?a=blobdiff_plain;f=src%2FSketchSolver%2FSketchSolver_ConstraintCoincidence.cpp;h=a2c3357b6ca82576b782079ea852563290bcaef7;hb=ae86330710c2a0f8d6b82ddb53fcba1707ecf9e4;hp=0e6ee74906d94719567f80112fde232e40c9f8f8;hpb=3c445d389d3cbe4c98403bc62e4b6ba8d06cc314;p=modules%2Fshaper.git diff --git a/src/SketchSolver/SketchSolver_ConstraintCoincidence.cpp b/src/SketchSolver/SketchSolver_ConstraintCoincidence.cpp index 0e6ee7490..a2c3357b6 100644 --- a/src/SketchSolver/SketchSolver_ConstraintCoincidence.cpp +++ b/src/SketchSolver/SketchSolver_ConstraintCoincidence.cpp @@ -1,345 +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; - return myExtraCoincidence.find(theConstraint) != myExtraCoincidence.end(); -} - -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->first); - return aConstraints; -} - -bool SketchSolver_ConstraintCoincidence::isCoincide( - std::shared_ptr theConstraint) const -{ - 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(); - // 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); - - if (!aRemEnts.empty()) { - std::map::iterator aFeatIt = theConstraint->myFeatureMap.begin(); - while (aFeatIt != theConstraint->myFeatureMap.end()) { - if (aRemEnts.find(aFeatIt->second) != aRemEnts.end()) { - // remove feature - std::map::iterator aRemoveIt = aFeatIt++; - theConstraint->myFeatureMap.erase(aRemoveIt); - } else - ++aFeatIt; - } - std::map::iterator anAttrIt = theConstraint->myAttributeMap.begin(); - while (anAttrIt != theConstraint->myAttributeMap.end()) { - if (aRemEnts.find(anAttrIt->second) != aRemEnts.end()) { - // remove attribute - std::map::iterator aRemoveIt = anAttrIt++; - theConstraint->myAttributeMap.erase(aRemoveIt); - } else - ++anAttrIt; - } - } + return; } - // Copy data. - addConstraint(theConstraint->myBaseConstraint); - std::map::iterator aConstrIter = - theConstraint->myExtraCoincidence.begin(); - for (; aConstrIter != theConstraint->myExtraCoincidence.end(); aConstrIter++) - addConstraint(aConstrIter->first); - // Clear the lists to not remove the entities on destruction - theConstraint->mySlvsConstraints.clear(); - theConstraint->myFeatureMap.clear(); - theConstraint->myAttributeMap.clear(); -} - -Slvs_hConstraint SketchSolver_ConstraintCoincidence::addConstraint( - Slvs_hEntity thePoint1, Slvs_hEntity thePoint2) -{ - if (thePoint1 == thePoint2) - return SLVS_E_UNKNOWN; + mySolverConstraint = PlaneGCSSolver_Tools::createConstraint( + myBaseConstraint, getType(), + aValue, anAttributes[0], anAttributes[1], anAttributes[2], anAttributes[3]); - 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); } -Slvs_hConstraint SketchSolver_ConstraintCoincidence::addPointOnEntity( - Slvs_hEntity thePoint, Slvs_hEntity theEntity) +bool SketchSolver_ConstraintCoincidence::remove() { - // Check the point is not coincident with boundaries of the entity - Slvs_Entity anEnt = myStorage->getEntity(theEntity); - int aPos = anEnt.type == SLVS_E_LINE_SEGMENT ? 0 : 1; - for (; anEnt.point[aPos] != SLVS_E_UNKNOWN; aPos++) - if (anEnt.point[aPos] == thePoint || - myStorage->isCoincident(anEnt.point[aPos], thePoint)) - return SLVS_E_UNKNOWN; - - bool hasDuplicated = myStorage->hasDuplicatedConstraint(); - Slvs_Constraint aBaseCoincidence = myStorage->getConstraint(mySlvsConstraints.front()); - Slvs_hConstraint aType = anEnt.type == SLVS_E_LINE_SEGMENT ? - SLVS_C_PT_ON_LINE : SLVS_C_PT_ON_CIRCLE; - Slvs_Constraint aNewConstraint = Slvs_MakeConstraint(SLVS_E_UNKNOWN, myGroup->getId(), - aType, myGroup->getWorkplaneId(), 0.0, aBaseCoincidence.ptA, SLVS_E_UNKNOWN, - theEntity, 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; + myInSolver = false; + return SketchSolver_Constraint::remove(); } -void SketchSolver_ConstraintCoincidence::addConstraint(ConstraintPtr theConstraint) +void SketchSolver_ConstraintCoincidence::getAttributes( + EntityWrapperPtr& theValue, + std::vector& theAttributes) { - if (mySlvsConstraints.empty()) { - // This constraint is empty, rebuild it from scratch - myBaseConstraint = theConstraint; - process(); + SketchSolver_Constraint::getAttributes(theValue, theAttributes); + if (!myErrorMsg.empty() || !theAttributes[0]) { + theAttributes.clear(); return; } - std::list anAttrList = - theConstraint->data()->attributes(ModelAPI_AttributeRefAttr::typeId()); - std::list::iterator anIter = anAttrList.begin(); - std::vector aPoints; - Slvs_hEntity anEntity = SLVS_E_UNKNOWN; - int anEntType; - for (; anIter != anAttrList.end(); anIter++) { - AttributeRefAttrPtr aRefAttr = std::dynamic_pointer_cast(*anIter); - if (!aRefAttr) - continue; - if (aRefAttr->isObject()) { - FeaturePtr aFeature = ModelAPI_Feature::feature(aRefAttr->object()); - std::map::const_iterator aFeatFound = - myFeatureMap.find(aFeature); - if (aFeatFound != myFeatureMap.end()) - anEntity = aFeatFound->second; - else { - anEntity = myGroup->getFeatureId(aFeature); - if (anEntity == SLVS_E_UNKNOWN) - anEntity = changeEntity(aFeature, anEntType); - else - myFeatureMap[aFeature] = anEntity; - } - } else { - Slvs_hEntity anEntID = SLVS_E_UNKNOWN; - std::map::const_iterator anAttrFound = - myAttributeMap.find(aRefAttr->attr()); - if (anAttrFound != myAttributeMap.end()) - anEntID = anAttrFound->second; - else { - anEntID = myGroup->getAttributeId(aRefAttr->attr()); - if (anEntID == SLVS_E_UNKNOWN) - anEntID = changeEntity(aRefAttr->attr(), anEntType); - else - myAttributeMap[aRefAttr->attr()] = anEntID; - } - aPoints.push_back(anEntID); - myCoincidentPoints.insert(aRefAttr->attr()); - } - } - - Slvs_hConstraint aNewConstr = SLVS_E_UNKNOWN; - if (anEntity != SLVS_E_UNKNOWN) - aNewConstr = addPointOnEntity(aPoints.front(), anEntity); - else { // coincidence between two points - Slvs_Constraint aBaseCoincidence = myStorage->getConstraint(mySlvsConstraints.front()); - std::vector::const_iterator aPtIter = aPoints.begin(); - for (; aPtIter != aPoints.end(); aPtIter++) { - Slvs_hConstraint aC = addConstraint(aBaseCoincidence.ptA, *aPtIter); - if (aC != SLVS_E_UNKNOWN) - aNewConstr = aC; - } - } - myExtraCoincidence[theConstraint] = aNewConstr; -} - -void SketchSolver_ConstraintCoincidence::process() -{ - 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()); - } + 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.find(aConstraint); - if (anExtraIt == myExtraCoincidence.end()) - return false; // there is no constraint, which is specified to remove - else { - bool isEmpty = anExtraIt->second == SLVS_E_UNKNOWN; - if (!isEmpty) { - isEmpty = true; - for (aPos = 0; aPos < (int)mySlvsConstraints.size(); aPos++) - if (mySlvsConstraints[aPos] == anExtraIt->second) { - isEmpty = false; - 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->first->data() || !anExtraIt->first->data()->isValid()) { - std::map::iterator aTempIt = anExtraIt++; - if (aTempIt->first != SLVS_E_UNKNOWN) { - myStorage->removeConstraint(aTempIt->second); - std::vector::iterator anIt = mySlvsConstraints.begin(); - for (; anIt != mySlvsConstraints.end(); anIt++) - if (*anIt == aTempIt->second) { - mySlvsConstraints.erase(anIt); - break; - } - } - myExtraCoincidence.erase(aTempIt); - continue; - } - anExtraIt++; - } - // Find first non-extra conststraint - anExtraIt = myExtraCoincidence.begin(); - while (anExtraIt != myExtraCoincidence.end() && anExtraIt->second == SLVS_E_UNKNOWN) - anExtraIt++; - if (anExtraIt != myExtraCoincidence.end()) { - // Need to specify another base coincidence constraint - myBaseConstraint = anExtraIt->first; - myExtraCoincidence.erase(anExtraIt); - if (mySlvsConstraints.empty()) { - 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); - } - } - } - } - // 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; + PlaneGCSSolver_UpdateCoincidence* anUpdater = + static_cast(theUpdater); + bool isAccepted = anUpdater->checkCoincidence(myAttributes.front(), myAttributes.back()); + if (isAccepted) { + if (!myInSolver) { + myInSolver = true; + myStorage->addConstraint(myBaseConstraint, mySolverConstraint); } - 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->first->data() || !anExtraIt->first->data()->isValid()) { - std::map::iterator aTempIt = anExtraIt++; - myExtraCoincidence.erase(aTempIt); - continue; - } - if (mySlvsConstraints.empty()) { - myBaseConstraint = anExtraIt->first; - std::map::iterator aTempIt = anExtraIt++; - myExtraCoincidence.erase(aTempIt); - process(); - continue; - } else - addConstraint(anExtraIt->first); + } else { + if (myInSolver) { + myInSolver = false; + myStorage->removeConstraint(myBaseConstraint); } - anExtraIt++; } - return mySlvsConstraints.empty(); } -