+void SketchSolver_Constraint::setGroup(SketchSolver_Group* theGroup)
+{
+ myGroup = theGroup;
+ process();
+}
+
+
+void SketchSolver_Constraint::process()
+{
+ cleanErrorMsg();
+ if (!myBaseConstraint || !myStorage || myGroup == 0) {
+ /// TODO: Put error message here
+ return;
+ }
+ if (!mySlvsConstraints.empty()) // some data is changed, update constraint
+ update(myBaseConstraint);
+
+ int aConstrType = getType();
+ double aValue = 0.0;
+ std::vector<Slvs_hEntity> anAttributes;
+ getAttributes(aValue, anAttributes);
+ if (!myErrorMsg.empty())
+ return;
+
+ Slvs_hGroup aGroupID = myGroup->getId();
+ Slvs_hEntity aWorkplaneID = myGroup->getWorkplaneId();
+ Slvs_Constraint aConstraint;
+ if (mySlvsConstraints.empty())
+ aConstraint = Slvs_MakeConstraint(SLVS_C_UNKNOWN, aGroupID, aConstrType, aWorkplaneID,
+ aValue, anAttributes[0], anAttributes[1], anAttributes[2], anAttributes[3]);
+ else {
+ aConstraint = myStorage->getConstraint(mySlvsConstraints[0]);
+ aConstraint.valA = aValue;
+ static const int aNbAttrs = 6;
+ Slvs_hEntity* aConstrAttrs[aNbAttrs] = {
+ &aConstraint.ptA, &aConstraint.ptB,
+ &aConstraint.entityA, &aConstraint.entityB,
+ &aConstraint.entityC, &aConstraint.entityD};
+ std::vector<Slvs_hEntity>::const_iterator anIter = anAttributes.begin();
+ for (int i = 0; i < aNbAttrs && anIter != anAttributes.end(); i++, anIter++)
+ *(aConstrAttrs[i]) = *anIter;
+ }
+
+ Slvs_hConstraint anID = myStorage->addConstraint(aConstraint);
+ if (mySlvsConstraints.empty())
+ mySlvsConstraints.push_back(anID);
+ else
+ mySlvsConstraints[0] = anID;
+ adjustConstraint();
+}
+
+void SketchSolver_Constraint::update(ConstraintPtr theConstraint)
+{
+ cleanErrorMsg();
+ if (theConstraint && theConstraint != myBaseConstraint) {
+ if (theConstraint->getKind() != myBaseConstraint->getKind())
+ return;
+ remove(myBaseConstraint);
+ myBaseConstraint = theConstraint;
+ process();
+ }
+
+ // Update all attributes
+ int aType;
+ std::map<Slvs_hEntity, Slvs_hEntity> aRelocationMap;
+ std::map<FeaturePtr, Slvs_hEntity>::iterator aFeatIter = myFeatureMap.begin();
+ for (; aFeatIter != myFeatureMap.end(); aFeatIter++) {
+ Slvs_hEntity aPrevID = aFeatIter->second;
+ aFeatIter->second = changeEntity(aFeatIter->first, aType);
+ if (aFeatIter->second != aPrevID)
+ aRelocationMap[aPrevID] = aFeatIter->second;
+ }
+ std::map<AttributePtr, Slvs_hEntity>::iterator anAttrIter = myAttributeMap.begin();
+ for (; anAttrIter != myAttributeMap.end(); anAttrIter++) {
+ Slvs_hEntity aPrevID = anAttrIter->second;
+ anAttrIter->second = changeEntity(anAttrIter->first, aType);
+ if (anAttrIter->second != aPrevID)
+ aRelocationMap[aPrevID] = anAttrIter->second;
+ }
+
+ // Value if exists
+ DataPtr aData = myBaseConstraint->data();
+ if (!aData) return;
+ AttributeDoublePtr aValueAttr = std::dynamic_pointer_cast<ModelAPI_AttributeDouble>(
+ myBaseConstraint->attribute(SketchPlugin_Constraint::VALUE()));
+ double aValue = aValueAttr ? aValueAttr->value() : 0.0;
+
+ // Update constraint
+ std::vector<Slvs_hConstraint>::iterator aCIter = mySlvsConstraints.begin();
+ for (; aCIter != mySlvsConstraints.end(); aCIter++) {
+ Slvs_Constraint aConstraint = myStorage->getConstraint(*aCIter);
+ aConstraint.valA = aValue;
+ Slvs_hEntity* aCoeffs[6] = {
+ &aConstraint.ptA, &aConstraint.ptB,
+ &aConstraint.entityA, &aConstraint.entityB,
+ &aConstraint.entityC, &aConstraint.entityD};
+ for (int i = 0; i < 6; i++) {
+ if (*(aCoeffs[i]) == SLVS_E_UNKNOWN)
+ continue;
+ std::map<Slvs_hEntity, Slvs_hEntity>::iterator aFound = aRelocationMap.find(*(aCoeffs[i]));
+ if (aFound != aRelocationMap.end())
+ *(aCoeffs[i]) = aFound->second;
+ }
+ *aCIter = myStorage->addConstraint(aConstraint);
+ }
+ adjustConstraint();
+}
+
+bool SketchSolver_Constraint::remove(ConstraintPtr theConstraint)
+{
+ cleanErrorMsg();
+ if (theConstraint && theConstraint != myBaseConstraint)
+ return false;
+ if (mySlvsConstraints.empty())
+ return true;
+ bool isFullyRemoved = myStorage->removeConstraint(mySlvsConstraints.front());
+ if (isFullyRemoved) {
+ myFeatureMap.clear();
+ myAttributeMap.clear();
+ myValueMap.clear();
+ } else
+ cleanRemovedEntities();
+ mySlvsConstraints.clear();
+ return true;
+}
+
+void SketchSolver_Constraint::cleanRemovedEntities()
+{
+ std::set<Slvs_hParam> aRemovedParams;
+ std::set<Slvs_hEntity> aRemovedEntities;
+ std::set<Slvs_hConstraint> aRemovedConstraints;
+ myStorage->getRemoved(aRemovedParams, aRemovedEntities, aRemovedConstraints);
+ std::map<FeaturePtr, Slvs_hEntity>::iterator aFeatIt = myFeatureMap.begin();
+ while (aFeatIt != myFeatureMap.end()) {
+ if (aRemovedEntities.find(aFeatIt->second) == aRemovedEntities.end()) {
+ aFeatIt++;
+ continue;
+ }
+ std::map<FeaturePtr, Slvs_hEntity>::iterator aTmpIter = aFeatIt++;
+ myFeatureMap.erase(aTmpIter);
+ }
+ std::map<AttributePtr, Slvs_hEntity>::iterator anAttrIt = myAttributeMap.begin();
+ while (anAttrIt != myAttributeMap.end()) {
+ if (aRemovedEntities.find(anAttrIt->second) == aRemovedEntities.end()) {
+ anAttrIt++;
+ continue;
+ }
+ std::map<AttributePtr, Slvs_hEntity>::iterator aTmpIter = anAttrIt++;
+ myAttributeMap.erase(aTmpIter);
+ }
+ std::map<AttributePtr, Slvs_hParam>::iterator aValIt = myValueMap.begin();
+ while (aValIt != myValueMap.end()) {
+ if (aRemovedParams.find(aValIt->second) == aRemovedParams.end()) {
+ aValIt++;
+ continue;
+ }
+ std::map<AttributePtr, Slvs_hParam>::iterator aTmpIter = aValIt++;
+ myValueMap.erase(aTmpIter);
+ }
+}
+
+void SketchSolver_Constraint::getAttributes(
+ double& theValue,
+ std::vector<Slvs_hEntity>& theAttributes)
+{
+ static const int anInitNbOfAttr = 4;
+ theAttributes.assign(anInitNbOfAttr, SLVS_E_UNKNOWN);
+
+ DataPtr aData = myBaseConstraint->data();
+
+ AttributeDoublePtr aValueAttr = std::dynamic_pointer_cast<ModelAPI_AttributeDouble>(
+ aData->attribute(SketchPlugin_Constraint::VALUE()));
+ theValue = aValueAttr ? aValueAttr->value() : 0.0;
+
+ int aPtInd = 0; // index of first point in the list of attributes
+ int aEntInd = 2; // index of first antity in the list of attributes
+ std::list<AttributePtr> aConstrAttrs = aData->attributes(ModelAPI_AttributeRefAttr::typeId());
+ std::list<AttributePtr>::iterator anIter = aConstrAttrs.begin();
+ for (; anIter != aConstrAttrs.end(); anIter++) {
+ AttributeRefAttrPtr aRefAttr =
+ std::dynamic_pointer_cast<ModelAPI_AttributeRefAttr>(*anIter);
+ if (!aRefAttr || !aRefAttr->isInitialized()) {
+ myErrorMsg = SketchSolver_Error::NOT_INITIALIZED();
+ return;
+ }
+
+ int aType = SLVS_E_UNKNOWN; // type of created entity
+ Slvs_hEntity anEntity = myGroup->getAttributeId(aRefAttr);
+ if (anEntity == SLVS_E_UNKNOWN)
+ anEntity = changeEntity(aRefAttr, aType);
+ else {
+ Slvs_Entity anEnt = myStorage->getEntity(anEntity);
+ aType = anEnt.type;
+ }
+
+ if (aType == SLVS_E_UNKNOWN)
+ continue;
+ else if (aType == SLVS_E_POINT_IN_2D || aType == SLVS_E_POINT_IN_3D)
+ theAttributes[aPtInd++] = anEntity; // the point is created
+ else { // another entity (not a point) is created
+ if (aEntInd < anInitNbOfAttr)
+ theAttributes[aEntInd] = anEntity;
+ else
+ theAttributes.push_back(anEntity);
+ aEntInd++;
+ }
+ }
+}
+
+Slvs_hEntity SketchSolver_Constraint::changeEntity(AttributeRefAttrPtr theAttribute, int& theType)
+{
+ // Convert the object of the attribute to the feature
+ FeaturePtr aFeature;
+ if (theAttribute->isObject() && theAttribute->object()) {
+ ResultConstructionPtr aRC = std::dynamic_pointer_cast<ModelAPI_ResultConstruction>(
+ theAttribute->object());
+ if (!aRC) {
+ myErrorMsg = SketchSolver_Error::NOT_INITIALIZED();
+ return SLVS_E_UNKNOWN;
+ }
+ std::shared_ptr<ModelAPI_Document> aDoc = aRC->document();
+ aFeature = aDoc->feature(aRC);
+
+ return changeEntity(aFeature, theType);
+ }
+
+ return changeEntity(theAttribute->attr(), theType);
+}
+
+Slvs_hEntity SketchSolver_Constraint::changeEntity(AttributePtr theEntity, int& theType)
+{
+ Slvs_hEntity aResult = SLVS_E_UNKNOWN;
+ if (!theEntity || !isInitialized(theEntity))
+ return SLVS_E_UNKNOWN;
+
+ // If the entity is already in the group, try to find it
+ std::map<std::shared_ptr<ModelAPI_Attribute>, Slvs_hEntity>::const_iterator anEntIter =
+ myAttributeMap.find(theEntity);
+ Slvs_Entity aCurrentEntity;
+ aCurrentEntity.h = SLVS_E_UNKNOWN;
+ if (anEntIter != myAttributeMap.end())
+ aCurrentEntity = myStorage->getEntity(anEntIter->second);
+ else {
+ aResult = myGroup->getAttributeId(theEntity);
+ if (aResult != SLVS_E_UNKNOWN) {
+ Slvs_Entity anEnt = myStorage->getEntity(aResult);
+ theType = anEnt.type;
+ myAttributeMap[theEntity] = aResult;
+ return aResult;