{
myObject = theObject;
}
+
+
+// ===== ModelAPI_SolverFailedMessage =====
+ModelAPI_SolverFailedMessage::ModelAPI_SolverFailedMessage(const Events_ID theID, const void* theSender)
+ : Events_Message(theID, theSender)
+{
+}
+
+ModelAPI_SolverFailedMessage::~ModelAPI_SolverFailedMessage()
+{
+}
+
+void ModelAPI_SolverFailedMessage::setObjects(const std::set<ObjectPtr>& theObjects)
+{
+ myObjects = theObjects;
+}
+
+const std::set<ObjectPtr>& ModelAPI_SolverFailedMessage::objects() const
+{
+ return myObjects;
+}
+
static const char * EVENT_UPDATE_VIEWER_BLOCKED = "UpdateViewerBlocked";
static const char * EVENT_UPDATE_VIEWER_UNBLOCKED = "UpdateViewerUnblocked";
+/// Event ID that solver has conflicting constraints (comes with ModelAPI_SolverFailedMessage)
static const char * EVENT_SOLVER_FAILED = "SolverFailed";
+/// Event ID that the problem in solver disappeared
static const char * EVENT_SOLVER_REPAIRED = "SolverRepaired";
/// Event ID that order of objects in group is changed, so, tree must be fully rectreated (movement of feature)
MODELAPI_EXPORT void setObject(ObjectPtr theObject);
};
+
+class ModelAPI_SolverFailedMessage : public Events_Message
+{
+public:
+ MODELAPI_EXPORT ModelAPI_SolverFailedMessage(const Events_ID theID, const void* theSender = 0);
+ MODELAPI_EXPORT virtual ~ModelAPI_SolverFailedMessage();
+
+ /// Sets list of conflicting constraints
+ MODELAPI_EXPORT void setObjects(const std::set<ObjectPtr>& theObjects);
+ /// Returns list of conflicting constraints
+ MODELAPI_EXPORT const std::set<ObjectPtr>& objects() const;
+
+private:
+ std::set<ObjectPtr> myObjects;
+};
+
#endif
aSession.startOperation()
aDistance.setValue(PT_PT_DIST)
aSession.finishOperation()
-assert (distancePointPoint(aSketchPointCoords, aLineAStartPoint) == PT_PT_DIST)
+assert (math.fabs(distancePointPoint(aSketchPointCoords, aLineAStartPoint) - PT_PT_DIST) < 1.e-10)
#=========================================================================
# Move line, check that distance is constant
#=========================================================================
aLineAStartPoint.setValue(0., 40.)
aLineAEndPoint.setValue(100., 40.)
aSession.finishOperation()
-assert (distancePointPoint(aSketchPointCoords, aLineAStartPoint) == PT_PT_DIST)
+assert (math.fabs(distancePointPoint(aSketchPointCoords, aLineAStartPoint) - PT_PT_DIST) < 1.e-10)
#=========================================================================
# Remove constraint, check the points are unconstrained now
#=========================================================================
aSession.startOperation()
aSketchPointCoords.setValue(0., 0.)
aSession.finishOperation()
-assert (distancePointPoint(aSketchPointCoords, aLineAStartPoint) != PT_PT_DIST)
+assert (math.fabs(distancePointPoint(aSketchPointCoords, aLineAStartPoint) - PT_PT_DIST) > 1.e-10)
#=========================================================================
# Add distance between point and line
aSession.startOperation()
aDistance.setValue(PT_LINE_DIST)
aSession.finishOperation()
-assert (distancePointLine(aSketchPointCoords, aSketchLine) == PT_LINE_DIST)
+assert (math.fabs(distancePointLine(aSketchPointCoords, aSketchLine) - PT_LINE_DIST) < 1.e-10)
#=========================================================================
# Set distance between line boundaries
#=========================================================================
refattrA.setAttr(aLineAStartPoint)
refattrB.setAttr(aLineAEndPoint)
aSession.finishOperation()
-assert (distancePointPoint(aLineAStartPoint, aLineAEndPoint) != PT_LINE_DIST)
+assert (math.fabs(distancePointPoint(aLineAStartPoint, aLineAEndPoint) - PT_LINE_DIST) < 1.e-10)
#=========================================================================
# End of test
#=========================================================================
myValue = 0.0;
}
+void PlaneGCSSolver_ConstraintWrapper::setId(const ConstraintID& theID)
+{
+ myID = theID;
+ std::list<GCSConstraintPtr>::iterator anIt = myGCSConstraints.begin();
+ for (; anIt != myGCSConstraints.end(); ++anIt)
+ (*anIt)->setTag((int)theID);
+}
+
void PlaneGCSSolver_ConstraintWrapper::setValueParameter(const ParameterWrapperPtr& theValue)
{
myValueParam = theValue;
/// \brief Return ID of current entity
virtual ConstraintID id() const
{ return myID; }
+ /// \brief Change constraint ID
+ void setId( const ConstraintID& theID);
/// \brief Change group for the constraint
virtual void setGroup(const GroupID& theGroup);
SketchSolver_SolveStatus PlaneGCSSolver_Solver::solve()
{
+ // clear list of conflicting constraints
+ if (myConfCollected) {
+ myConflictingIDs.clear();
+ myConfCollected = false;
+ }
+
if (myConstraints.empty())
return STATUS_EMPTYSET;
if (myParameters.empty())
return STATUS_INCONSISTENT;
- //myEquationSystem.calculateFaileds = myFindFaileds ? 1 : 0;
-
Events_LongOp::start(this);
GCS::SolveStatus aResult = (GCS::SolveStatus)myEquationSystem.solve(myParameters);
Events_LongOp::end(this);
{
myEquationSystem.undoSolution();
}
+
+bool PlaneGCSSolver_Solver::isConflicting(const ConstraintID& theConstraint) const
+{
+ if (!myConfCollected)
+ const_cast<PlaneGCSSolver_Solver*>(this)->collectConflicting();
+
+ GCS::VEC_I::const_iterator anIt = myConflictingIDs.begin();
+ for (; anIt != myConflictingIDs.end(); ++anIt)
+ if (*anIt == (int)theConstraint)
+ return true;
+ return false;
+}
+
+void PlaneGCSSolver_Solver::collectConflicting()
+{
+ myEquationSystem.getConflicting(myConflictingIDs);
+
+ GCS::VEC_I aRedundantID;
+ myEquationSystem.getRedundant(aRedundantID);
+ myConflictingIDs.insert(myConflictingIDs.end(), aRedundantID.begin(), aRedundantID.end());
+
+ myConfCollected = true;
+}
+
/// \brief Revert solution to initial values
virtual void undo();
+ /// \brief Check the constraint is conflicted with others
+ virtual bool isConflicting(const ConstraintID& theConstraint) const;
+
+private:
+ void collectConflicting();
+
private:
GCS::VEC_pD myParameters; ///< list of unknowns
std::set<GCS::Constraint*> myConstraints; ///< list of constraints already processed by the system
GCS::System myEquationSystem; ///< set of equations for solving in FreeGCS
+
+ GCS::VEC_I myConflictingIDs; ///< list of IDs of conflicting constraints
+ bool myConfCollected; ///< specifies the conflicting constraints are already collected
};
#endif
PlaneGCSSolver_Storage::PlaneGCSSolver_Storage(const GroupID& theGroup)
: SketchSolver_Storage(theGroup),
- myEntityLastID(EID_SKETCH)
+ myEntityLastID(EID_SKETCH),
+ myConstraintLastID(CID_UNKNOWN)
{
}
for (; anIt != anEntities.end(); ++anIt)
isUpdated = update(*anIt) || isUpdated;
+ // Change ID of constraints
+ if (aConstraint->id() == CID_UNKNOWN)
+ aConstraint->setId(++myConstraintLastID);
+
return isUpdated;
}
setNeedToResolve(true);
myRemovedConstraints.insert(myRemovedConstraints.end(),
aConstraint->constraints().begin(), aConstraint->constraints().end());
+
+ if (isFullyRemoved && theConstraint->id() == myConstraintLastID)
+ --myConstraintLastID;
+
return isFullyRemoved;
}
GCS::VEC_pD myParameters; ///< list of parameters
GCS::VEC_pD myConst; ///< list of constants
EntityID myEntityLastID; ///< identifier of last added entity
+ ConstraintID myConstraintLastID; ///< identifier of last added constraint
std::map<EntityWrapperPtr, std::vector<GCSConstraintPtr> >
myArcConstraintMap; ///< additional constraints for correct processing of the arcs
if (aRefAttr) {
if (aRefAttr->isObject()) {
FeaturePtr aFeat = ModelAPI_Feature::feature(aRefAttr->object());
- aFeatures.insert(aFeat);
+ if (myBaseConstraint->getKind() != SketchPlugin_ConstraintLength::ID())
+ aFeatures.insert(aFeat);
+ else {
+ // Workaround for the Length constraint: add points of line, not line itself
+ anAttributes.insert(aFeat->attribute(SketchPlugin_Line::START_ID()));
+ anAttributes.insert(aFeat->attribute(SketchPlugin_Line::END_ID()));
+ }
} else
anAttributes.insert(aRefAttr->attr());
} else
bool SketchSolver_Constraint::remove()
{
cleanErrorMsg();
+ myType = CONSTRAINT_UNKNOWN;
return myStorage->removeConstraint(myBaseConstraint);
}
Events_Loop::loop()->send(aMessage);
}
+static void sendMessage(const char* theMessageName, const std::set<ObjectPtr>& theConflicting)
+{
+ std::shared_ptr<ModelAPI_SolverFailedMessage> aMessage =
+ std::shared_ptr<ModelAPI_SolverFailedMessage>(
+ new ModelAPI_SolverFailedMessage(Events_Loop::eventByName(theMessageName)));
+ aMessage->setObjects(theConflicting);
+ Events_Loop::loop()->send(aMessage);
+}
+
// ========================================================
// Events_Error::send(SketchSolver_Error::CONSTRAINTS(), this);
getWorkplane()->string(SketchPlugin_Sketch::SOLVER_ERROR())->setValue(SketchSolver_Error::CONSTRAINTS());
if (myPrevResult != aResult || myPrevResult == STATUS_UNKNOWN) {
+ // Obtain list of conflicting constraints
+ std::set<ObjectPtr> aConflicting = myStorage->getConflictingConstraints(mySketchSolver);
+
// the error message should be changed before sending the message
- sendMessage(EVENT_SOLVER_FAILED);
+ sendMessage(EVENT_SOLVER_FAILED, aConflicting);
myPrevResult = aResult;
}
}
/// \brief Revert solution to initial values
virtual void undo() = 0;
+ /// \brief Check the constraint is conflicted with others
+ virtual bool isConflicting(const ConstraintID& theConstraint) const = 0;
+
protected:
GroupID myGroup; ///< ID of the group to be solved
bool myFindFaileds; ///< flag to find conflicting or inappropriate constraints
#include <ModelAPI_Object.h>
#include <ModelAPI_ResultConstruction.h>
#include <ModelAPI_Attribute.h>
+#include <ModelAPI_AttributeString.h>
#include <SketchPlugin_Constraint.h>
break;
if (aFGrIter != aFeatureGroups.end()) {
- std::vector<SketchSolver_Group*>::iterator aGroupIter = myGroups.begin();
+ std::list<SketchSolver_Group*> aGroupsToResolve;
+ std::list<SketchSolver_Group*>::iterator aGroupIter = myGroups.begin();
std::list<SketchSolver_Group*> aSeparatedGroups;
while (aGroupIter != myGroups.end()) {
if (!(*aGroupIter)->isWorkplaneValid()) { // the group should be removed
delete *aGroupIter;
- int aShift = aGroupIter - myGroups.begin();
- myGroups.erase(aGroupIter);
- aGroupIter = myGroups.begin() + aShift;
+ std::list<SketchSolver_Group*>::iterator aRemoveIt = aGroupIter++;
+ myGroups.erase(aRemoveIt);
continue;
}
if (!(*aGroupIter)->isConsistent()) { // some constraints were removed, try to split the group
(*aGroupIter)->splitGroup(aSeparatedGroups);
+ if (!(*aGroupIter)->getWorkplane()->string(
+ SketchPlugin_Sketch::SOLVER_ERROR())->value().empty())
+ aGroupsToResolve.push_back(*aGroupIter);
}
aGroupIter++;
}
- if (aSeparatedGroups.size() > 0)
+ if (aSeparatedGroups.size() > 0) {
myGroups.insert(myGroups.end(), aSeparatedGroups.begin(), aSeparatedGroups.end());
+ aGroupsToResolve.insert(aGroupsToResolve.end(),
+ aSeparatedGroups.begin(), aSeparatedGroups.end());
+ }
+
+ if (!aGroupsToResolve.empty())
+ resolveConstraints(aGroupsToResolve);
}
}
myIsComputed = false;
bool aResult = true; // changed when a workplane wrongly updated
bool isUpdated = false;
// Try to update specified workplane in all groups
- std::vector<SketchSolver_Group*>::iterator aGroupIter;
+ std::list<SketchSolver_Group*>::iterator aGroupIter;
for (aGroupIter = myGroups.begin(); aGroupIter != myGroups.end(); aGroupIter++)
if ((*aGroupIter)->isBaseWorkplane(theSketch)) {
isUpdated = true;
return true;
} else if (aGroups.size() == 1) { // Only one group => add feature into it
GroupID aGroupId = *(aGroups.begin());
- std::vector<SketchSolver_Group*>::iterator aGroupIter;
+ std::list<SketchSolver_Group*>::iterator aGroupIter;
for (aGroupIter = myGroups.begin(); aGroupIter != myGroups.end(); aGroupIter++)
if ((*aGroupIter)->getId() == aGroupId) {
// If the group is empty, the feature is not added (the constraint only)
std::set<GroupID>::const_iterator aGroupsIter = aGroups.begin();
// Search first group
- std::vector<SketchSolver_Group*>::iterator aFirstGroupIter;
+ std::list<SketchSolver_Group*>::iterator aFirstGroupIter;
for (aFirstGroupIter = myGroups.begin(); aFirstGroupIter != myGroups.end(); aFirstGroupIter++)
if ((*aFirstGroupIter)->getId() == *aGroupsIter)
break;
return false;
// Append other groups to the first one
- std::vector<SketchSolver_Group*>::iterator anOtherGroupIter = aFirstGroupIter + 1;
+ std::list<SketchSolver_Group*>::iterator anOtherGroupIter = aFirstGroupIter;
+ ++anOtherGroupIter;
for (aGroupsIter++; aGroupsIter != aGroups.end(); aGroupsIter++) {
for (; anOtherGroupIter != myGroups.end(); anOtherGroupIter++)
if ((*anOtherGroupIter)->getId() == *aGroupsIter)
break;
if (anOtherGroupIter == myGroups.end()) { // Group disappears
- anOtherGroupIter = aFirstGroupIter + 1;
+ anOtherGroupIter = aFirstGroupIter;
+ ++anOtherGroupIter;
continue;
}
(*aFirstGroupIter)->mergeGroups(**anOtherGroupIter);
- int aShiftFirst = aFirstGroupIter - myGroups.begin();
- int aShiftOther = anOtherGroupIter - myGroups.begin();
- delete *anOtherGroupIter;
- myGroups.erase(anOtherGroupIter);
- aFirstGroupIter = myGroups.begin() + aShiftFirst;
- anOtherGroupIter = myGroups.begin() + aShiftOther;
+ std::list<SketchSolver_Group*>::iterator aRemoveIt = anOtherGroupIter++;
+ delete *aRemoveIt;
+ myGroups.erase(aRemoveIt);
}
if (aConstraint)
void SketchSolver_Manager::moveEntity(std::shared_ptr<SketchPlugin_Feature> theFeature)
{
bool isMoved = false;
- std::vector<SketchSolver_Group*>::iterator aGroupIt = myGroups.begin();
+ std::list<SketchSolver_Group*>::iterator aGroupIt = myGroups.begin();
for (; aGroupIt != myGroups.end(); aGroupIt++)
if (!(*aGroupIt)->isEmpty() && (*aGroupIt)->isInteract(theFeature)) {
(*aGroupIt)->moveFeature(theFeature);
std::shared_ptr<ModelAPI_CompositeFeature> aWP = findWorkplane(theFeature);
SketchSolver_Group* anEmptyGroup = 0; // appropriate empty group for specified constraint
- std::vector<SketchSolver_Group*>::const_iterator aGroupIter;
+ std::list<SketchSolver_Group*>::const_iterator aGroupIter;
for (aGroupIter = myGroups.begin(); aGroupIter != myGroups.end(); aGroupIter++)
if (aWP == (*aGroupIter)->getWorkplane() && (*aGroupIter)->isInteract(theFeature)) {
if (!(*aGroupIter)->isEmpty())
// Already verified workplanes
std::set<std::shared_ptr<ModelAPI_CompositeFeature> > aVerified;
- std::vector<SketchSolver_Group*>::const_iterator aGroupIter;
+ std::list<SketchSolver_Group*>::const_iterator aGroupIter;
for (aGroupIter = myGroups.begin(); aGroupIter != myGroups.end(); aGroupIter++) {
std::shared_ptr<ModelAPI_CompositeFeature> aWP = (*aGroupIter)->getWorkplane();
if (aVerified.find(aWP) != aVerified.end())
// Function: resolveConstraints
// Purpose: change entities according to available constraints
// ============================================================================
-bool SketchSolver_Manager::resolveConstraints()
+bool SketchSolver_Manager::resolveConstraints(const std::list<SketchSolver_Group*>& theGroups)
{
bool needToUpdate = false;
- std::vector<SketchSolver_Group*>::iterator aGroupIter;
- for (aGroupIter = myGroups.begin(); aGroupIter != myGroups.end(); aGroupIter++)
+ const std::list<SketchSolver_Group*>& aGroupsToResolve = theGroups.empty() ? myGroups : theGroups;
+ std::list<SketchSolver_Group*>::const_iterator aGroupIter = aGroupsToResolve.begin();
+ for (; aGroupIter != aGroupsToResolve.end(); aGroupIter++)
if ((*aGroupIter)->resolveConstraints())
needToUpdate = true;
return needToUpdate;
#include <Events_Listener.h>
#include <SketchPlugin_Constraint.h>
-#include <vector>
+#include <list>
#include <set>
/** \class SketchSolver_Manager
void moveEntity(std::shared_ptr<SketchPlugin_Feature> theFeature);
/** \brief Goes through the list of groups and solve the constraints
+ * \param[in] theGroups list of groups to be resolved (if empty list, all groups are resolved)
* \return \c true, if groups are resolved, and features should be updated (send the Update event)
*/
- bool resolveConstraints();
+ bool resolveConstraints(const std::list<SketchSolver_Group*>& theGroups = std::list<SketchSolver_Group*>());
private:
/** \brief Searches list of groups which interact with specified feature
private:
static SketchSolver_Manager* mySelf; ///< Self pointer to implement singleton functionality
- std::vector<SketchSolver_Group*> myGroups; ///< Groups of constraints
+ std::list<SketchSolver_Group*> myGroups; ///< Groups of constraints
BuilderPtr myBuilder; ///< Builder for solver's entities
/// true if computation is performed and all "updates" are generated by this algo
/// and needs no recomputation
myEventsBlocked = isBlocked;
}
+std::set<ObjectPtr> SketchSolver_Storage::getConflictingConstraints(SolverPtr theSolver) const
+{
+ std::set<ObjectPtr> aConflicting;
+ std::map<ConstraintPtr, std::list<ConstraintWrapperPtr> >::const_iterator
+ aConstrIt = myConstraintMap.begin();
+ for (; aConstrIt != myConstraintMap.end(); ++aConstrIt) {
+ std::list<ConstraintWrapperPtr>::const_iterator anIt = aConstrIt->second.begin();
+ for (; anIt != aConstrIt->second.end(); ++anIt)
+ if (theSolver->isConflicting((*anIt)->id())) {
+ aConflicting.insert(aConstrIt->first);
+ break;
+ }
+ }
+ return aConflicting;
+}
/// \brief Initialize solver by constraints, entities and parameters
virtual void initializeSolver(SolverPtr theSolver) = 0;
+ /// \brief Return list of conflicting constraints
+ std::set<ObjectPtr> getConflictingConstraints(SolverPtr theSolver) const;
/// \brief Update SketchPlugin features after resolving constraints
/// \param theFixedOnly [in] if \c true the fixed points will be updated only
//if (myEquationsSystem.constraints <= 0)
// return STATUS_EMPTYSET;
- myEquationsSystem.calculateFaileds = myFindFaileds ? 1 : 0;
+ myEquationsSystem.calculateFaileds = 0;
+ if (myFindFaileds) {
+ myEquationsSystem.calculateFaileds = 1;
+ myEquationsSystem.faileds = myEquationsSystem.constraints;
+ }
Events_LongOp::start(this);
Slvs_Solve(&myEquationsSystem, myGroup);
}
return false;
}
+
+bool SolveSpaceSolver_Solver::isConflicting(const ConstraintID& theConstraint) const
+{
+ for (int i = 0; i < myEquationsSystem.faileds; ++i)
+ if (myEquationsSystem.failed[i] == (Slvs_hConstraint)theConstraint)
+ return true;
+ return false;
+}
/// \brief Revert solution to initial values
virtual void undo();
+ /// \brief Check the constraint is conflicted with others
+ virtual bool isConflicting(const ConstraintID& theConstraint) const;
+
private:
/// \brief Check whether degenerated arcs exist
bool hasDegeneratedArcs() const;
aConstraint->changeConstraint() = getConstraint(aConstrID);
isUpdated = true;
// check duplicated constraints based on different attributes
- if (myDuplicatedConstraint && !hasDupConstraints && findSameConstraint(aConstraint))
+ if (myDuplicatedConstraint && findSameConstraint(aConstraint) && !hasDupConstraints)
myDuplicatedConstraint = false;
}
}
(*aCWIt)->type() == CONSTRAINT_MULTI_TRANSLATION)
continue;
if ((*aCWIt)->type() == theConstraint->type()) {
- const Slvs_Constraint& aCComp = std::dynamic_pointer_cast<
- SolveSpaceSolver_ConstraintWrapper>(*aCWIt)->constraint();
+ const Slvs_Constraint& aCComp = getConstraint((Slvs_hConstraint)(*aCWIt)->id());
+
if (aCBase.ptA == aCComp.ptA && aCBase.ptB == aCComp.ptB &&
aCBase.entityA == aCComp.entityA && aCBase.entityB == aCComp.entityB &&
aCBase.entityC == aCComp.entityC && aCBase.entityD == aCComp.entityD &&
// parameter already used, rewrite it
int aPos = Search(theParam.h, myParameters);
if (aPos >= 0 && aPos < (int)myParameters.size()) {
- if (IsNotEqual(myParameters[aPos], theParam)) {
- myUpdatedParameters.insert(theParam.h);
+ if (IsNotEqual(myParameters[aPos], theParam))
setNeedToResolve(true);
- }
myParameters[aPos] = theParam;
return theParam.h;
}
aConstraint.entityA == aCIt->entityA && aConstraint.entityB == aCIt->entityB &&
aConstraint.entityC == aCIt->entityC && aConstraint.entityD == aCIt->entityD) {
myDuplicatedConstraint = true;
- return aCIt->h;
+ break;
}
}
std::dynamic_pointer_cast<SolveSpaceSolver_ConstraintWrapper>(theConstraint);
// verify whether the constraint has duplicated
+ bool hasSameID = false;
SameConstraintMap::iterator anEqIt = myEqualConstraints.begin();
- for (; anEqIt != myEqualConstraints.end(); ++anEqIt)
- if (anEqIt->find(aConstraint) != anEqIt->end()) {
+ for (; anEqIt != myEqualConstraints.end(); ++anEqIt) {
+ std::set<ConstraintWrapperPtr>::const_iterator aFound = anEqIt->find(aConstraint);
+ if (aFound != anEqIt->end()) {
+ // verify there is a constraint with same ID
+ std::set<ConstraintWrapperPtr>::const_iterator anIt = anEqIt->begin();
+ ConstraintID anID = (*aFound)->id();
+ for (++anIt; anIt != anEqIt->end() && !hasSameID; ++anIt)
+ if ((*anIt)->id() == anID && aFound != anIt)
+ hasSameID = true;
+ // erase constraint
anEqIt->erase(aConstraint);
break;
}
- if (anEqIt != myEqualConstraints.end())
+ }
+ if (anEqIt != myEqualConstraints.end() && hasSameID)
return true;
bool isFullyRemoved = removeConstraint((Slvs_hConstraint)aConstraint->id());
bool myDuplicatedConstraint; ///< shows the storage has same constraint twice
- std::set<Slvs_hParam> myUpdatedParameters; ///< list of just updated parameters (cleared when isNeedToResolve() called)
-
SameConstraintMap myEqualConstraints; ///< list of groups of equal constraints
};
