1 #include <SketchSolver_ConstraintCoincidence.h>
2 #include <SketchSolver_Error.h>
3 #include <SketchSolver_Group.h>
7 void SketchSolver_ConstraintCoincidence::getAttributes(
9 std::vector<Slvs_hEntity>& theAttributes)
11 SketchSolver_Constraint::getAttributes(theValue, theAttributes);
12 if (!myErrorMsg.empty() || theAttributes[0] == SLVS_E_UNKNOWN)
15 if (theAttributes[1] != SLVS_E_UNKNOWN)
16 myType = SLVS_C_POINTS_COINCIDENT;
17 else if (theAttributes[2] != SLVS_E_UNKNOWN) {
18 // check the type of entity (line or circle)
19 Slvs_Entity anEnt = myStorage->getEntity(theAttributes[2]);
20 if (anEnt.type == SLVS_E_LINE_SEGMENT)
21 myType = SLVS_C_PT_ON_LINE;
22 else if (anEnt.type == SLVS_E_CIRCLE || anEnt.type == SLVS_E_ARC_OF_CIRCLE)
23 myType = SLVS_C_PT_ON_CIRCLE;
25 myErrorMsg = SketchSolver_Error::INCORRECT_ATTRIBUTE();
27 myErrorMsg = SketchSolver_Error::INCORRECT_ATTRIBUTE();
31 bool SketchSolver_ConstraintCoincidence::hasConstraint(ConstraintPtr theConstraint) const
33 if (myBaseConstraint == theConstraint)
35 std::map<Slvs_hConstraint, ConstraintPtr>::const_iterator anIt = myExtraCoincidence.begin();
36 for (; anIt != myExtraCoincidence.end(); anIt++)
37 if (anIt->second == theConstraint)
42 std::list<ConstraintPtr> SketchSolver_ConstraintCoincidence::constraints() const
44 std::list<ConstraintPtr> aConstraints;
45 aConstraints.push_back(myBaseConstraint);
46 std::map<Slvs_hConstraint, ConstraintPtr>::const_iterator anIt = myExtraCoincidence.begin();
47 for (; anIt != myExtraCoincidence.end(); anIt++)
48 aConstraints.push_back(anIt->second);
52 bool SketchSolver_ConstraintCoincidence::isCoincide(
53 std::shared_ptr<SketchSolver_ConstraintCoincidence> theConstraint) const
55 // Multi-coincidence allowed for two points only
56 if (getType() != theConstraint->getType() || getType() != SLVS_C_POINTS_COINCIDENT)
59 std::set<AttributePtr>::const_iterator anAttrIter = theConstraint->myCoincidentPoints.begin();
60 for (; anAttrIter != theConstraint->myCoincidentPoints.end(); anAttrIter++)
61 if (myCoincidentPoints.find(*anAttrIter) != myCoincidentPoints.end())
66 void SketchSolver_ConstraintCoincidence::attach(
67 std::shared_ptr<SketchSolver_ConstraintCoincidence> theConstraint)
70 Slvs_Constraint aBaseCoincidence = myStorage->getConstraint(mySlvsConstraints.front());
71 // Remove constraints from theConstraint
72 std::vector<Slvs_hConstraint>::iterator aCIter = theConstraint->mySlvsConstraints.begin();
73 for (; aCIter != theConstraint->mySlvsConstraints.end(); aCIter++)
74 theConstraint->myStorage->removeConstraint(*aCIter);
76 if (myStorage == theConstraint->myStorage) {
77 // Clean removed items
78 std::set<Slvs_hParam> aRemParams;
79 std::set<Slvs_hEntity> aRemEnts;
80 std::set<Slvs_hConstraint> aRemConstr;
81 theConstraint->myStorage->getRemoved(aRemParams, aRemEnts, aRemConstr);
85 addConstraint(theConstraint->myBaseConstraint);
86 std::map<Slvs_hConstraint, ConstraintPtr>::iterator aConstrIter =
87 theConstraint->myExtraCoincidence.begin();
88 for (; aConstrIter != theConstraint->myExtraCoincidence.end(); aConstrIter++)
89 addConstraint(aConstrIter->second);
90 // Clear the lists to not remove the entities on destruction
91 theConstraint->mySlvsConstraints.clear();
92 theConstraint->myFeatureMap.clear();
93 theConstraint->myAttributeMap.clear();
96 Slvs_hConstraint SketchSolver_ConstraintCoincidence::addConstraint(
97 Slvs_hEntity thePoint1, Slvs_hEntity thePoint2)
99 bool hasDuplicated = myStorage->hasDuplicatedConstraint();
100 Slvs_Constraint aNewConstraint = Slvs_MakeConstraint(SLVS_E_UNKNOWN, myGroup->getId(),
101 SLVS_C_POINTS_COINCIDENT, myGroup->getWorkplaneId(), 0.0, thePoint1, thePoint2,
102 SLVS_E_UNKNOWN, SLVS_E_UNKNOWN);
103 Slvs_hConstraint aNewID = myStorage->addConstraint(aNewConstraint);
104 if (!hasDuplicated && myStorage->hasDuplicatedConstraint()) {
105 // the duplicated constraint appears
106 myStorage->removeConstraint(aNewID);
107 return SLVS_E_UNKNOWN;
109 mySlvsConstraints.push_back(aNewID);
113 void SketchSolver_ConstraintCoincidence::addConstraint(ConstraintPtr theConstraint)
115 std::list<AttributePtr> anAttrList =
116 theConstraint->data()->attributes(ModelAPI_AttributeRefAttr::typeId());
117 std::list<AttributePtr>::iterator anIter = anAttrList.begin();
118 std::vector<Slvs_hEntity> anEntities;
119 for (; anIter != anAttrList.end(); anIter++) {
120 AttributeRefAttrPtr aRefAttr = std::dynamic_pointer_cast<ModelAPI_AttributeRefAttr>(*anIter);
121 if (!aRefAttr || aRefAttr->isObject() ||
122 myAttributeMap.find(aRefAttr->attr()) != myAttributeMap.end())
125 Slvs_hEntity anEntityID = myGroup->getAttributeId(aRefAttr->attr());
126 if (anEntityID == SLVS_E_UNKNOWN)
127 anEntityID = changeEntity(aRefAttr->attr(), aType);
128 anEntities.push_back(anEntityID);
129 myCoincidentPoints.insert(aRefAttr->attr());
132 Slvs_Constraint aBaseCoincidence = myStorage->getConstraint(mySlvsConstraints.front());
133 Slvs_hConstraint aNewConstr = SLVS_E_UNKNOWN;
134 std::vector<Slvs_hEntity>::iterator anEntIter = anEntities.begin();
135 for (; anEntIter != anEntities.end(); anEntIter++)
136 aNewConstr = addConstraint(aBaseCoincidence.ptA, *anEntIter);
137 myExtraCoincidence[aNewConstr] = theConstraint;
140 void SketchSolver_ConstraintCoincidence::process()
142 SketchSolver_Constraint::process();
144 // Fill the list of coincident points
145 std::list<AttributePtr> anAttrList =
146 myBaseConstraint->data()->attributes(ModelAPI_AttributeRefAttr::typeId());
147 std::list<AttributePtr>::iterator anIt = anAttrList.begin();
148 for (; anIt != anAttrList.end(); anIt++) {
149 AttributeRefAttrPtr aRefAttr = std::dynamic_pointer_cast<ModelAPI_AttributeRefAttr>(*anIt);
150 if (!aRefAttr || aRefAttr->isObject())
152 myCoincidentPoints.insert(aRefAttr->attr());
156 bool SketchSolver_ConstraintCoincidence::remove(ConstraintPtr theConstraint)
159 if (mySlvsConstraints.empty())
161 ConstraintPtr aConstraint = theConstraint ? theConstraint : myBaseConstraint;
162 int aPos = -1; // position of constraint in the list (-1 for base constraint)
163 std::map<Slvs_hConstraint, ConstraintPtr>::iterator anExtraIt;
164 if (aConstraint != myBaseConstraint) {
165 anExtraIt = myExtraCoincidence.begin();
166 for (aPos = 0; anExtraIt != myExtraCoincidence.end(); anExtraIt++, aPos++)
167 if (anExtraIt->second == aConstraint)
169 if (aPos >= (int)myExtraCoincidence.size())
170 return false; // there is no constraint, which is specified to remove
172 bool isEmpty = anExtraIt->first == SLVS_E_UNKNOWN;
173 myExtraCoincidence.erase(anExtraIt);
179 bool isFullyRemoved = myStorage->removeConstraint(mySlvsConstraints[aPos+1]);
180 mySlvsConstraints.erase(mySlvsConstraints.begin() + (1+aPos));
181 if (aPos < 0 && !myExtraCoincidence.empty()) {
182 anExtraIt = myExtraCoincidence.begin();
183 // Remove invalid constraints
184 while (anExtraIt != myExtraCoincidence.end()) {
185 if (!anExtraIt->second->data() || !anExtraIt->second->data()->isValid()) {
186 std::map<Slvs_hConstraint, ConstraintPtr>::iterator aTempIt = anExtraIt++;
187 if (aTempIt->first != SLVS_E_UNKNOWN) {
188 myStorage->removeConstraint(aTempIt->first);
189 std::vector<Slvs_hConstraint>::iterator anIt = mySlvsConstraints.begin();
190 for (; anIt != mySlvsConstraints.end(); anIt++)
191 if (*anIt == aTempIt->first) {
192 mySlvsConstraints.erase(anIt);
196 myExtraCoincidence.erase(aTempIt);
201 // Find first non-extra conststraint
202 while (anExtraIt != myExtraCoincidence.end() && anExtraIt->first == SLVS_E_UNKNOWN)
204 if (anExtraIt != myExtraCoincidence.end()) {
205 // Need to specify another base coincidence constraint
206 myBaseConstraint = anExtraIt->second;
207 myExtraCoincidence.erase(anExtraIt);
208 std::vector<Slvs_hConstraint>::iterator aCIter = mySlvsConstraints.begin();
209 Slvs_Constraint aBase = myStorage->getConstraint(*aCIter);
210 for (++aCIter; aCIter != mySlvsConstraints.end(); aCIter++) {
211 Slvs_Constraint aConstr = myStorage->getConstraint(*aCIter);
212 aConstr.ptA = aBase.ptA;
213 myStorage->updateConstraint(aConstr);
217 // Clear removed attributes
218 std::set<Slvs_hParam> aParamRemoved;
219 std::set<Slvs_hEntity> anEntRemoved;
220 std::set<Slvs_hConstraint> aConstrRemoved;
221 myStorage->getRemoved(aParamRemoved, anEntRemoved, aConstrRemoved);
222 std::map<AttributePtr, Slvs_hEntity>::iterator anAttrIter = myAttributeMap.begin();
223 while (anAttrIter != myAttributeMap.end()) {
224 if (anEntRemoved.find(anAttrIter->second) != anEntRemoved.end()) {
225 std::map<AttributePtr, Slvs_hEntity>::iterator aTempIt = anAttrIter++;
226 myCoincidentPoints.erase(aTempIt->first);
227 myAttributeMap.erase(aTempIt);
233 // Go through remaining extra coincidence and try to add or remove them
234 anExtraIt = myExtraCoincidence.begin();
235 while (anExtraIt != myExtraCoincidence.end()) {
236 if (anExtraIt->first == SLVS_E_UNKNOWN) {
237 if (!anExtraIt->second->data() || !anExtraIt->second->data()->isValid()) {
238 std::map<Slvs_hConstraint, ConstraintPtr>::iterator aTempIt = anExtraIt++;
239 myExtraCoincidence.erase(aTempIt);
242 if (mySlvsConstraints.empty()) {
243 myBaseConstraint = anExtraIt->second;
244 std::map<Slvs_hConstraint, ConstraintPtr>::iterator aTempIt = anExtraIt++;
245 myExtraCoincidence.erase(aTempIt);
249 addConstraint(anExtraIt->second);
253 return mySlvsConstraints.empty();