Salome HOME
Merge branch 'Dev_1.1.1' of newgeom:newgeom into Dev_1.2.0
[modules/shaper.git] / src / SketchSolver / SketchSolver_ConstraintCoincidence.cpp
1 #include <SketchSolver_ConstraintCoincidence.h>
2 #include <SketchSolver_Error.h>
3 #include <SketchSolver_Group.h>
4
5 #include <map>
6
7 void SketchSolver_ConstraintCoincidence::getAttributes(
8     double& theValue,
9     std::vector<Slvs_hEntity>& theAttributes)
10 {
11   SketchSolver_Constraint::getAttributes(theValue, theAttributes);
12   if (!myErrorMsg.empty() || theAttributes[0] == SLVS_E_UNKNOWN)
13     return;
14
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;
24     else
25       myErrorMsg = SketchSolver_Error::INCORRECT_ATTRIBUTE();
26   } else
27     myErrorMsg = SketchSolver_Error::INCORRECT_ATTRIBUTE();
28 }
29
30
31 bool SketchSolver_ConstraintCoincidence::hasConstraint(ConstraintPtr theConstraint) const
32 {
33   if (myBaseConstraint == theConstraint)
34     return true;
35   std::map<Slvs_hConstraint, ConstraintPtr>::const_iterator anIt = myExtraCoincidence.begin();
36   for (; anIt != myExtraCoincidence.end(); anIt++)
37     if (anIt->second == theConstraint)
38       return true;
39   return false;
40 }
41
42 std::list<ConstraintPtr> SketchSolver_ConstraintCoincidence::constraints() const
43 {
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);
49   return aConstraints;
50 }
51
52 bool SketchSolver_ConstraintCoincidence::isCoincide(
53     std::shared_ptr<SketchSolver_ConstraintCoincidence> theConstraint) const
54 {
55   // Multi-coincidence allowed for two points only
56   if (getType() != theConstraint->getType() || getType() != SLVS_C_POINTS_COINCIDENT)
57     return false;
58
59   std::set<AttributePtr>::const_iterator anAttrIter = theConstraint->myCoincidentPoints.begin();
60   for (; anAttrIter != theConstraint->myCoincidentPoints.end(); anAttrIter++)
61     if (myCoincidentPoints.find(*anAttrIter) != myCoincidentPoints.end())
62       return true;
63   return false;
64 }
65
66 void SketchSolver_ConstraintCoincidence::attach(
67     std::shared_ptr<SketchSolver_ConstraintCoincidence> theConstraint)
68 {
69   cleanErrorMsg();
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);
75
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);
82   }
83
84   // Copy data.
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();
94 }
95
96 Slvs_hConstraint SketchSolver_ConstraintCoincidence::addConstraint(
97     Slvs_hEntity thePoint1, Slvs_hEntity thePoint2)
98 {
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;
108   }
109   mySlvsConstraints.push_back(aNewID);
110   return aNewID;
111 }
112
113 void SketchSolver_ConstraintCoincidence::addConstraint(ConstraintPtr theConstraint)
114 {
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())
123       continue;
124     int aType;
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());
130   }
131
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;
138 }
139
140 void SketchSolver_ConstraintCoincidence::process()
141 {
142   SketchSolver_Constraint::process();
143
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())
151       continue;
152     myCoincidentPoints.insert(aRefAttr->attr());
153   }
154 }
155
156 bool SketchSolver_ConstraintCoincidence::remove(ConstraintPtr theConstraint)
157 {
158   cleanErrorMsg();
159   if (mySlvsConstraints.empty())
160     return true;
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)
168         break;
169     if (aPos >= (int)myExtraCoincidence.size())
170       return false; // there is no constraint, which is specified to remove
171     else {
172       bool isEmpty = anExtraIt->first == SLVS_E_UNKNOWN;
173       myExtraCoincidence.erase(anExtraIt);
174       if (isEmpty)
175         return false;
176     }
177   }
178
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);
193               break;
194             }
195         }
196         myExtraCoincidence.erase(aTempIt);
197         continue;
198       }
199       anExtraIt++;
200     }
201     // Find first non-extra conststraint
202     anExtraIt = myExtraCoincidence.begin();
203     while (anExtraIt != myExtraCoincidence.end() && anExtraIt->first == SLVS_E_UNKNOWN)
204       anExtraIt++;
205     if (anExtraIt != myExtraCoincidence.end()) {
206       // Need to specify another base coincidence constraint
207       myBaseConstraint = anExtraIt->second;
208       myExtraCoincidence.erase(anExtraIt);
209       std::vector<Slvs_hConstraint>::iterator aCIter = mySlvsConstraints.begin();
210       Slvs_Constraint aBase = myStorage->getConstraint(*aCIter);
211       for (++aCIter; aCIter != mySlvsConstraints.end(); aCIter++) {
212         Slvs_Constraint aConstr = myStorage->getConstraint(*aCIter);
213         aConstr.ptA = aBase.ptA;
214         myStorage->updateConstraint(aConstr);
215       }
216     }
217   }
218   // Clear removed attributes
219   std::set<Slvs_hParam> aParamRemoved;
220   std::set<Slvs_hEntity> anEntRemoved;
221   std::set<Slvs_hConstraint> aConstrRemoved;
222   myStorage->getRemoved(aParamRemoved, anEntRemoved, aConstrRemoved);
223   std::map<AttributePtr, Slvs_hEntity>::iterator anAttrIter = myAttributeMap.begin();
224   while (anAttrIter != myAttributeMap.end()) {
225     if (anEntRemoved.find(anAttrIter->second) != anEntRemoved.end()) {
226       std::map<AttributePtr, Slvs_hEntity>::iterator aTempIt = anAttrIter++;
227       myCoincidentPoints.erase(aTempIt->first);
228       myAttributeMap.erase(aTempIt);
229       continue;
230     }
231     anAttrIter++;
232   }
233
234   // Go through remaining extra coincidence and try to add or remove them
235   anExtraIt = myExtraCoincidence.begin();
236   while (anExtraIt != myExtraCoincidence.end()) {
237     if (anExtraIt->first == SLVS_E_UNKNOWN) {
238       if (!anExtraIt->second->data() || !anExtraIt->second->data()->isValid()) {
239         std::map<Slvs_hConstraint, ConstraintPtr>::iterator aTempIt = anExtraIt++;
240         myExtraCoincidence.erase(aTempIt);
241         continue;
242       }
243       if (mySlvsConstraints.empty()) {
244         myBaseConstraint = anExtraIt->second;
245         std::map<Slvs_hConstraint, ConstraintPtr>::iterator aTempIt = anExtraIt++;
246         myExtraCoincidence.erase(aTempIt);
247         process();
248         continue;
249       } else
250         addConstraint(anExtraIt->second);
251     }
252     anExtraIt++;
253   }
254   return mySlvsConstraints.empty();
255 }
256