1 #include <SketchSolver_ConstraintCoincidence.h>
2 #include <SketchSolver_Error.h>
3 #include <SketchSolver_Group.h>
7 bool SketchSolver_ConstraintCoincidence::hasConstraint(ConstraintPtr theConstraint) const
9 if (myBaseConstraint == theConstraint)
11 std::map<Slvs_hConstraint, ConstraintPtr>::const_iterator anIt = myExtraCoincidence.begin();
12 for (; anIt != myExtraCoincidence.end(); anIt++)
13 if (anIt->second == theConstraint)
18 std::list<ConstraintPtr> SketchSolver_ConstraintCoincidence::constraints() const
20 std::list<ConstraintPtr> aConstraints;
21 aConstraints.push_back(myBaseConstraint);
22 std::map<Slvs_hConstraint, ConstraintPtr>::const_iterator anIt = myExtraCoincidence.begin();
23 for (; anIt != myExtraCoincidence.end(); anIt++)
24 aConstraints.push_back(anIt->second);
28 bool SketchSolver_ConstraintCoincidence::isCoincide(
29 std::shared_ptr<SketchSolver_ConstraintCoincidence> theConstraint) const
31 std::map<FeaturePtr, Slvs_hEntity>::const_iterator aFeatIter = myFeatureMap.begin();
32 for (; aFeatIter != myFeatureMap.end(); aFeatIter++)
33 if (theConstraint->myFeatureMap.find(aFeatIter->first) != theConstraint->myFeatureMap.end())
35 std::map<AttributePtr, Slvs_hEntity>::const_iterator anAttrIter = myAttributeMap.begin();
36 for (; anAttrIter != myAttributeMap.end(); anAttrIter++)
37 if (theConstraint->myAttributeMap.find(anAttrIter->first) != theConstraint->myAttributeMap.end())
42 void SketchSolver_ConstraintCoincidence::attach(
43 std::shared_ptr<SketchSolver_ConstraintCoincidence> theConstraint)
46 Slvs_Constraint aBaseCoincidence = myStorage->getConstraint(mySlvsConstraints.front());
47 // Remove constraints from theConstraint
48 std::vector<Slvs_hConstraint>::iterator aCIter = theConstraint->mySlvsConstraints.begin();
49 for (; aCIter != theConstraint->mySlvsConstraints.end(); aCIter++)
50 theConstraint->myStorage->removeConstraint(*aCIter);
52 if (myStorage == theConstraint->myStorage) {
53 // Clean removed items
54 std::set<Slvs_hParam> aRemParams;
55 std::set<Slvs_hEntity> aRemEnts;
56 std::set<Slvs_hConstraint> aRemConstr;
57 theConstraint->myStorage->getRemoved(aRemParams, aRemEnts, aRemConstr);
61 addConstraint(theConstraint->myBaseConstraint);
62 std::map<Slvs_hConstraint, ConstraintPtr>::iterator aConstrIter =
63 theConstraint->myExtraCoincidence.begin();
64 for (; aConstrIter != theConstraint->myExtraCoincidence.end(); aConstrIter++)
65 addConstraint(aConstrIter->second);
66 // Clear the lists to not remove the entities on destruction
67 theConstraint->mySlvsConstraints.clear();
68 theConstraint->myFeatureMap.clear();
69 theConstraint->myAttributeMap.clear();
72 Slvs_hConstraint SketchSolver_ConstraintCoincidence::addConstraint(
73 Slvs_hEntity thePoint1, Slvs_hEntity thePoint2)
75 Slvs_Constraint aNewConstraint = Slvs_MakeConstraint(SLVS_E_UNKNOWN, myGroup->getId(),
76 SLVS_C_POINTS_COINCIDENT, myGroup->getWorkplaneId(), 0.0, thePoint1, thePoint2,
77 SLVS_E_UNKNOWN, SLVS_E_UNKNOWN);
78 Slvs_hConstraint aNewID = myStorage->addConstraint(aNewConstraint);
79 mySlvsConstraints.push_back(aNewID);
83 void SketchSolver_ConstraintCoincidence::addConstraint(ConstraintPtr theConstraint)
85 std::list<AttributePtr> anAttrList =
86 theConstraint->data()->attributes(ModelAPI_AttributeRefAttr::typeId());
87 std::list<AttributePtr>::iterator anIter = anAttrList.begin();
88 std::vector<Slvs_hEntity> anEntities;
89 for (; anIter != anAttrList.end(); anIter++) {
90 AttributeRefAttrPtr aRefAttr = std::dynamic_pointer_cast<ModelAPI_AttributeRefAttr>(*anIter);
91 if (!aRefAttr || aRefAttr->isObject() ||
92 myAttributeMap.find(aRefAttr->attr()) != myAttributeMap.end())
95 Slvs_hEntity anEntityID = myGroup->getAttributeId(aRefAttr->attr());
96 if (anEntityID == SLVS_E_UNKNOWN)
97 anEntityID = changeEntity(aRefAttr->attr(), aType);
98 anEntities.push_back(anEntityID);
101 Slvs_Constraint aBaseCoincidence = myStorage->getConstraint(mySlvsConstraints.front());
102 Slvs_hConstraint aNewConstr = SLVS_E_UNKNOWN;
103 std::vector<Slvs_hEntity>::iterator anEntIter = anEntities.begin();
104 for (; anEntIter != anEntities.end(); anEntIter++)
105 aNewConstr = addConstraint(aBaseCoincidence.ptA, *anEntIter);
106 myExtraCoincidence[aNewConstr] = theConstraint;
109 bool SketchSolver_ConstraintCoincidence::remove(ConstraintPtr theConstraint)
112 if (mySlvsConstraints.empty())
114 ConstraintPtr aConstraint = theConstraint ? theConstraint : myBaseConstraint;
115 int aPos = -1; // position of constraint in the list (-1 for base constraint)
116 std::map<Slvs_hConstraint, ConstraintPtr>::iterator anExtraIt;
117 if (aConstraint != myBaseConstraint) {
118 anExtraIt = myExtraCoincidence.begin();
119 for (aPos = 0; anExtraIt != myExtraCoincidence.end(); anExtraIt++, aPos++)
120 if (anExtraIt->second == aConstraint)
122 if (aPos >= (int)myExtraCoincidence.size())
123 return false; // there is no constraint, which is specified to remove
125 bool isEmpty = anExtraIt->first == SLVS_E_UNKNOWN;
126 myExtraCoincidence.erase(anExtraIt);
132 bool isFullyRemoved = myStorage->removeConstraint(mySlvsConstraints[aPos+1]);
133 mySlvsConstraints.erase(mySlvsConstraints.begin() + (1+aPos));
134 if (aPos < 0 && !myExtraCoincidence.empty()) {
135 anExtraIt = myExtraCoincidence.begin();
136 // Remove invalid constraints
137 while (anExtraIt != myExtraCoincidence.end()) {
138 if (!anExtraIt->second->data() || !anExtraIt->second->data()->isValid()) {
139 std::map<Slvs_hConstraint, ConstraintPtr>::iterator aTempIt = anExtraIt++;
140 if (aTempIt->first != SLVS_E_UNKNOWN) {
141 myStorage->removeConstraint(aTempIt->first);
142 std::vector<Slvs_hConstraint>::iterator anIt = mySlvsConstraints.begin();
143 for (; anIt != mySlvsConstraints.end(); anIt++)
144 if (*anIt == aTempIt->first) {
145 mySlvsConstraints.erase(anIt);
149 myExtraCoincidence.erase(aTempIt);
154 // Find first non-extra conststraint
155 while (anExtraIt != myExtraCoincidence.end() && anExtraIt->first == SLVS_E_UNKNOWN)
157 if (anExtraIt != myExtraCoincidence.end()) {
158 // Need to specify another base coincidence constraint
159 myBaseConstraint = anExtraIt->second;
160 myExtraCoincidence.erase(anExtraIt);
161 std::vector<Slvs_hConstraint>::iterator aCIter = mySlvsConstraints.begin();
162 Slvs_Constraint aBase = myStorage->getConstraint(*aCIter);
163 for (++aCIter; aCIter != mySlvsConstraints.end(); aCIter++) {
164 Slvs_Constraint aConstr = myStorage->getConstraint(*aCIter);
165 aConstr.ptA = aBase.ptA;
166 myStorage->updateConstraint(aConstr);
170 // Clear removed attributes
171 std::set<Slvs_hParam> aParamRemoved;
172 std::set<Slvs_hEntity> anEntRemoved;
173 std::set<Slvs_hConstraint> aConstrRemoved;
174 myStorage->getRemoved(aParamRemoved, anEntRemoved, aConstrRemoved);
175 std::map<AttributePtr, Slvs_hEntity>::iterator anAttrIter = myAttributeMap.begin();
176 while (anAttrIter != myAttributeMap.end()) {
177 if (anEntRemoved.find(anAttrIter->second) != anEntRemoved.end()) {
178 std::map<AttributePtr, Slvs_hEntity>::iterator aTempIt = anAttrIter++;
179 myAttributeMap.erase(aTempIt);
185 // Go through remaining extra coincidence and try to add or remove them
186 anExtraIt = myExtraCoincidence.begin();
187 while (anExtraIt != myExtraCoincidence.end()) {
188 if (anExtraIt->first == SLVS_E_UNKNOWN) {
189 if (!anExtraIt->second->data() || !anExtraIt->second->data()->isValid()) {
190 std::map<Slvs_hConstraint, ConstraintPtr>::iterator aTempIt = anExtraIt++;
191 myExtraCoincidence.erase(aTempIt);
194 if (mySlvsConstraints.empty()) {
195 myBaseConstraint = anExtraIt->second;
196 std::map<Slvs_hConstraint, ConstraintPtr>::iterator aTempIt = anExtraIt++;
197 myExtraCoincidence.erase(aTempIt);
201 addConstraint(anExtraIt->second);
205 return mySlvsConstraints.empty();