#include <SketchSolver_Builder.h>
#include <SketchSolver_Constraint.h>
#include <SketchSolver_ConstraintCoincidence.h>
+#include <SketchSolver_ConstraintMulti.h>
#include <SketchSolver_Error.h>
#include <Events_Error.h>
return aResult;
// Obtain regular constraints interacting with the attribute and find its ID
std::set<ConstraintPtr> aConstraints = myFeatureStorage->getConstraints(theAttribute);
- if (aConstraints.empty())
- return aResult;
std::set<ConstraintPtr>::iterator aConstrIter = aConstraints.begin();
for (; aConstrIter != aConstraints.end(); aConstrIter++) {
ConstraintConstraintMap::const_iterator aCIter = myConstraints.find(*aConstrIter);
return aResult;
}
// The attribute is not found, check it in the temporary constraints
- std::set<SolverConstraintPtr>::iterator aTmpCIter = myTempConstraints.begin();
+ std::set<SolverConstraintPtr>::const_iterator aTmpCIter = myTempConstraints.begin();
for (; aTmpCIter != myTempConstraints.end() && aResult == SLVS_E_UNKNOWN; ++aTmpCIter)
aResult = (*aTmpCIter)->getId(theAttribute);
+ // Last chance to find attribute in parametric constraints
+ std::map<AttributePtr, SolverConstraintPtr>::const_iterator aParIter =
+ myParametricConstraints.find(theAttribute);
+ if (aParIter != myParametricConstraints.end())
+ aResult = aParIter->second->getId(theAttribute);
return aResult;
}
// Additional verification of coincidence of several points
if (theConstraint->getKind() == SketchPlugin_ConstraintCoincidence::ID()) {
+ bool hasMultiCoincidence = false;
ConstraintConstraintMap::iterator aCIter = myConstraints.begin();
- for (; aCIter != myConstraints.end(); aCIter++) {
+ for (; aCIter != myConstraints.end(); ++aCIter) {
std::shared_ptr<SketchSolver_ConstraintCoincidence> aCoincidence =
std::dynamic_pointer_cast<SketchSolver_ConstraintCoincidence>(aCIter->second);
if (!aCoincidence)
if (anIt->second == aCIter->second)
anIt->second = aCoinc2;
aCIter->second = aCoinc2;
+ hasMultiCoincidence = true;
}
}
+
+ if (hasMultiCoincidence)
+ notifyMultiConstraints();
}
myConstraints[theConstraint] = aConstraint;
}
// Search attributes of the feature in the set of parametric constraints and update them
std::list<AttributePtr> anAttrList =
- theFeature->data()->attributes(ModelAPI_AttributeRefAttr::typeId());
+ theFeature->data()->attributes(GeomDataAPI_Point2D::typeId());
std::list<AttributePtr>::iterator anAttrIt = anAttrList.begin();
for (; anAttrIt != anAttrList.end(); ++anAttrIt) {
- AttributeRefAttrPtr aRefAttr = std::dynamic_pointer_cast<ModelAPI_AttributeRefAttr>(*anAttrIt);
- if (!aRefAttr || aRefAttr->isObject())
- continue;
std::map<AttributePtr, SolverConstraintPtr>::iterator aFound =
- myParametricConstraints.find(aRefAttr->attr());
+ myParametricConstraints.find(*anAttrIt);
if (aFound != myParametricConstraints.end())
aFound->second->update();
+ else {
+ std::shared_ptr<GeomDataAPI_Point2D> aPoint =
+ std::dynamic_pointer_cast<GeomDataAPI_Point2D>(*anAttrIt);
+ if (aPoint && (!aPoint->textX().empty() || !aPoint->textY().empty())) {
+ // Create new parametric constraint
+ SolverConstraintPtr aConstraint =
+ SketchSolver_Builder::getInstance()->createParametricConstraint(*anAttrIt);
+ if (!aConstraint)
+ continue;
+ aConstraint->setGroup(this);
+ aConstraint->setStorage(myStorage);
+ myParametricConstraints[*anAttrIt] = aConstraint;
+ }
+ }
}
return true;
}
bool aResolved = false;
if (myStorage->isNeedToResolve() && !isEmpty()) {
myConstrSolver.setGroupID(myID);
+ myConstrSolver.calculateFailedConstraints(false);
myStorage->initializeSolver(myConstrSolver);
int aResult = SLVS_RESULT_OKAY;
isLastChance = true;
} else
aNbTemp = myStorage->deleteTemporaryConstraint();
+ myConstrSolver.calculateFailedConstraints(true); // something failed => need to find it
myStorage->initializeSolver(myConstrSolver);
}
}
// ============================================================================
void SketchSolver_Group::removeTemporaryConstraints()
{
+ std::set<SolverConstraintPtr>::iterator aTmpIt = myTempConstraints.begin();
+ for (; aTmpIt != myTempConstraints.end(); ++aTmpIt)
+ (*aTmpIt)->remove();
myTempConstraints.clear();
+
while (myStorage->numberTemporary())
myStorage->deleteTemporaryConstraint();
// Clean lists of removed entities in the storage
std::list<ConstraintPtr>::iterator anIt = aMultiCoinc.begin();
for (; anIt != aMultiCoinc.end(); ++anIt)
changeConstraint(*anIt);
+
+ notifyMultiConstraints();
}
}
return aFactory->validate(theFeature);
}
+// ============================================================================
+// Function: notifyMultiConstraints
+// Class: SketchSolver_Group
+// Purpose: Update Multi-Translation/-Rotation constraints due to multi coincidence appears/disappears
+// ============================================================================
+void SketchSolver_Group::notifyMultiConstraints()
+{
+ ConstraintConstraintMap::iterator aCIter = myConstraints.begin();
+ for (; aCIter != myConstraints.end(); ++aCIter) {
+ if (aCIter->first->getKind() == SketchPlugin_MultiRotation::ID() ||
+ aCIter->first->getKind() == SketchPlugin_MultiTranslation::ID()) {
+ std::shared_ptr<SketchSolver_ConstraintMulti> aMulti =
+ std::dynamic_pointer_cast<SketchSolver_ConstraintMulti>(aCIter->second);
+ aMulti->checkCoincidence();
+ }
+ }
+}