#include <SketchPlugin_ConstraintPerpendicular.h>
#include <SketchPlugin_ConstraintRadius.h>
#include <SketchPlugin_ConstraintRigid.h>
+#include <SketchPlugin_ConstraintSplit.h>
#include <SketchPlugin_ConstraintTangent.h>
#include <SketchPlugin_ConstraintVertical.h>
#include <SketchPlugin_MultiRotation.h>
ConstraintConstraintMap::const_iterator anIt = myConstraints.begin();
for (; !isInteracted && anIt != myConstraints.end(); ++anIt)
if (anIt->first->getKind() == SketchPlugin_MultiRotation::ID() ||
- anIt->first->getKind() == SketchPlugin_MultiTranslation::ID())
+ anIt->first->getKind() == SketchPlugin_MultiTranslation::ID()) {
isInteracted = anIt->second->isUsed(theFeature);
+ if (isInteracted)
+ break;
+ // if theFeature is a constraint, check its attributes
+ ConstraintPtr aConstraint = std::dynamic_pointer_cast<SketchPlugin_Constraint>(theFeature);
+ if (!aConstraint)
+ continue;
+ for (int i = 0; i < 4 && !isInteracted; ++i) {
+ AttributeRefAttrPtr aRefAttr = aConstraint->refattr(aConstraint->ATTRIBUTE(i));
+ if (!aRefAttr)
+ continue;
+ isInteracted = anIt->second->isUsed((AttributePtr)aRefAttr);
+ }
+ }
return isInteracted;
}
aType == CONSTRAINT_MULTI_TRANSLATION)
&& aCIt->second->isUsed(theFeature))
std::dynamic_pointer_cast<SketchSolver_ConstraintMulti>(aCIt->second)->update(true);
- else if ((aType == CONSTRAINT_TANGENT_CIRCLE_LINE ||
+ else if ((aType == CONSTRAINT_TANGENT_CIRCLE_LINE || aType == CONSTRAINT_TANGENT_ARC_ARC ||
aType == CONSTRAINT_SYMMETRIC || aType == CONSTRAINT_ANGLE)
&& aCIt->second->isUsed(theFeature))
aCIt->second->update();
}
} catch (...) {
// Events_Error::send(SketchSolver_Error::SOLVESPACE_CRASH(), this);
- getWorkplane()->string(SketchPlugin_Sketch::SOLVER_ERROR())->setValue(SketchSolver_Error::SOLVESPACE_CRASH());
+ getWorkplane()->string(SketchPlugin_Sketch::SOLVER_ERROR())
+ ->setValue(SketchSolver_Error::SOLVESPACE_CRASH());
if (myPrevResult == STATUS_OK || myPrevResult == STATUS_UNKNOWN) {
// the error message should be changed before sending the message
sendMessage(EVENT_SOLVER_FAILED);
mySketchSolver->undo();
return false;
}
- if (aResult == STATUS_OK || aResult == STATUS_EMPTYSET) { // solution succeeded, store results into correspondent attributes
+ // solution succeeded, store results into correspondent attributes
+ if (aResult == STATUS_OK || aResult == STATUS_EMPTYSET) {
+ myStorage->setNeedToResolve(false);
myStorage->refresh();
updateMultiConstraints(myConstraints);
+ // multi-constraints updated some parameters, need to store them
+ if (myStorage->isNeedToResolve())
+ resolveConstraints();
+
if (myPrevResult != STATUS_OK || myPrevResult == STATUS_UNKNOWN) {
getWorkplane()->string(SketchPlugin_Sketch::SOLVER_ERROR())->setValue("");
std::set<ObjectPtr> aConflicting = myConflictingConstraints;
mySketchSolver->undo();
if (!myConstraints.empty()) {
// the error message should be changed before sending the message
- getWorkplane()->string(SketchPlugin_Sketch::SOLVER_ERROR())->setValue(SketchSolver_Error::CONSTRAINTS());
- if (myPrevResult != aResult || myPrevResult == STATUS_UNKNOWN) {
+ getWorkplane()->string(SketchPlugin_Sketch::SOLVER_ERROR())
+ ->setValue(SketchSolver_Error::CONSTRAINTS());
+ if (myPrevResult != aResult ||
+ myPrevResult == STATUS_UNKNOWN ||
+ myPrevResult == STATUS_FAILED) {
// Obtain list of conflicting constraints
std::set<ObjectPtr> aConflicting = myStorage->getConflictingConstraints(mySketchSolver);
- if (myConflictingConstraints.empty())
- sendMessage(EVENT_SOLVER_FAILED, aConflicting);
- else {
+ if (!myConflictingConstraints.empty()) {
std::set<ObjectPtr>::iterator anIt = aConflicting.begin();
for (; anIt != aConflicting.end(); ++anIt)
myConflictingConstraints.erase(*anIt);
}
}
myConflictingConstraints = aConflicting;
+ if (!myConflictingConstraints.empty())
+ sendMessage(EVENT_SOLVER_FAILED, myConflictingConstraints);
myPrevResult = aResult;
}
}
aResolved = true;
} else if (!isGroupEmpty) {
- // Check there are constraints Fixed. If they exist, update parameters by stored values
+ // Check if the group contains only constraints Fixed, update parameters by stored values
+ aResolved = true;
ConstraintConstraintMap::iterator aCIt = myConstraints.begin();
for (; aCIt != myConstraints.end(); ++aCIt)
- if (aCIt->first->getKind() == SketchPlugin_ConstraintRigid::ID()) {
- aResolved = true;
+ if (aCIt->first->getKind() != SketchPlugin_ConstraintRigid::ID()) {
+ aResolved = false;
break;
}
- if (aCIt != myConstraints.end())
+ if (aCIt == myConstraints.end())
myStorage->refresh();
}
removeTemporaryConstraints();
continue;
changeConstraint(aConstr);
}
+
+ // merge previous states of groups => use the worst state,
+ // so the group after rebuilt may discard error messages if exist
+ if (theGroup.myPrevResult > myPrevResult)
+ myPrevResult = theGroup.myPrevResult;
}
// ============================================================================
{
// New storage will be used in trimmed way to store the list of constraint interacted together.
StoragePtr aNewStorage = SketchSolver_Manager::instance()->builder()->createStorage(getId());
- std::list<ConstraintWrapperPtr> aDummyVec; // empty vector to avoid creation of solver's constraints
+ // empty vector to avoid creation of solver's constraints
+ std::list<ConstraintWrapperPtr> aDummyVec;
// Obtain constraints, which should be separated
std::list<ConstraintPtr> anUnusedConstraints;
anUnusedConstraints.push_back(aCIter->first);
}
- // Check the unused constraints once again, because they may become interacted with new storage since adding constraints
+ // Check the unused constraints once again,
+ // because they may become interacted with new storage since adding constraints
std::list<ConstraintPtr>::iterator aUnuseIt = anUnusedConstraints.begin();
while (aUnuseIt != anUnusedConstraints.end()) {
if (aNewStorage->isInteract(FeaturePtr(*aUnuseIt))) {
}
if (aCIter != myConstraints.end())
myConstraints.erase(aCIter);
+ // empty group => clear storage
+ if (myConstraints.empty()) {
+ myStorage = StoragePtr();
+ mySketchSolver = SolverPtr();
+ updateWorkplane();
+ }
}
// ============================================================================
AttributeRefAttrPtr anAttrB = std::dynamic_pointer_cast<ModelAPI_AttributeRefAttr>(
aConstraint->attribute(SketchPlugin_Constraint::ENTITY_B()));
if (anAttrA && anAttrB && (anAttrA->isObject() || anAttrB->isObject()))
- return 2.0; // point-on-line and point-on-circle should go before points coincidence constraint
+ // point-on-line and point-on-circle should go before points coincidence constraint
+ return 2.0;
return 2.5;
}
if (anID == SketchPlugin_ConstraintDistance::ID() ||
anID == SketchPlugin_ConstraintMirror::ID())
return 6.0;
if (anID == SketchPlugin_ConstraintRigid::ID())
- return 7.0;
+ return 0.5;
if (anID == SketchPlugin_MultiRotation::ID() ||
anID == SketchPlugin_MultiTranslation::ID())
return 8.0;
return featureToVal(theFeature1) < featureToVal(theFeature2);
}
-std::list<FeaturePtr> SketchSolver_Group::selectApplicableFeatures(const std::set<ObjectPtr>& theObjects)
+std::list<FeaturePtr> SketchSolver_Group::
+ selectApplicableFeatures(const std::set<ObjectPtr>& theObjects)
{
std::list<FeaturePtr> aResult;
std::list<FeaturePtr>::iterator aResIt;
std::set<ObjectPtr>::const_iterator anObjIter = theObjects.begin();
for (; anObjIter != theObjects.end(); ++anObjIter) {
// Operate sketch itself and SketchPlugin features only.
- // Also, the Fillet need to be skipped, because there are several separated constraints composing it.
+ // Also, the Fillet and Split need to be skipped,
+ // because there are several separated constraints composing it.
FeaturePtr aFeature = std::dynamic_pointer_cast<ModelAPI_Feature>(*anObjIter);
if (!aFeature)
continue;
- std::shared_ptr<SketchPlugin_Feature> aSketchFeature =
+ std::shared_ptr<SketchPlugin_Feature> aSketchFeature =
std::dynamic_pointer_cast<SketchPlugin_Feature>(aFeature);
if ((aFeature->getKind() != SketchPlugin_Sketch::ID() && !aSketchFeature) ||
- aFeature->getKind() == SketchPlugin_ConstraintFillet::ID())
+ aFeature->getKind() == SketchPlugin_ConstraintFillet::ID() ||
+ aFeature->getKind() == SketchPlugin_ConstraintSplit::ID())
continue;
// Find the place where to insert a feature
