1 // Copyright (C) 2014-20xx CEA/DEN, EDF R&D
3 // File: SketchSolver_Storage.cpp
4 // Created: 18 Mar 2015
5 // Author: Artem ZHIDKOV
7 #include <SketchSolver_Storage.h>
11 /** \brief Search the entity/parameter with specified ID in the list of elements
12 * \param[in] theEntityID unique ID of the element
13 * \param[in] theEntities list of elements
14 * \return position of the found element or -1 if the element is not found
17 static int Search(const uint32_t& theEntityID, const std::vector<T>& theEntities);
19 /// \brief Compare two parameters to be different
20 static bool IsNotEqual(const Slvs_Param& theParam1, const Slvs_Param& theParam2);
21 /// \brief Compare two entities to be different
22 static bool IsNotEqual(const Slvs_Entity& theEntity1, const Slvs_Entity& theEntity2);
23 /// \brief Compare two constriants to be different
24 static bool IsNotEqual(const Slvs_Constraint& theConstraint1, const Slvs_Constraint& theConstraint2);
27 SketchSolver_Storage::SketchSolver_Storage()
28 : myParamMaxID(SLVS_E_UNKNOWN),
29 myEntityMaxID(SLVS_E_UNKNOWN),
30 myConstrMaxID(SLVS_C_UNKNOWN),
31 myFixed(SLVS_E_UNKNOWN),
32 myNeedToResolve(false)
36 Slvs_hParam SketchSolver_Storage::addParameter(const Slvs_Param& theParam)
38 if (theParam.h > 0 && theParam.h <= myParamMaxID) {
39 // parameter is already used, rewrite it
40 return updateParameter(theParam);
43 Slvs_Param aParam = theParam;
44 if (aParam.h > myParamMaxID)
45 myParamMaxID = aParam.h;
47 aParam.h = ++myParamMaxID;
48 myParameters.push_back(aParam);
49 myNeedToResolve = true;
53 Slvs_hParam SketchSolver_Storage::updateParameter(const Slvs_Param& theParam)
55 if (theParam.h > 0 && theParam.h <= myParamMaxID) {
56 // parameter already used, rewrite it
57 int aPos = Search(theParam.h, myParameters);
58 if (aPos >= 0 && aPos < (int)myParameters.size()) {
59 myNeedToResolve = myNeedToResolve || IsNotEqual(myParameters[aPos], theParam);
60 myParameters[aPos] = theParam;
65 // Parameter is not found, add new one
66 Slvs_Param aParam = theParam;
68 return addParameter(aParam);
71 bool SketchSolver_Storage::removeParameter(const Slvs_hParam& theParamID)
73 int aPos = Search(theParamID, myParameters);
74 if (aPos >= 0 && aPos < (int)myParameters.size()) {
75 // Firstly, search the parametes is not used elsewhere
76 std::vector<Slvs_Entity>::const_iterator anEntIter = myEntities.begin();
77 for (; anEntIter != myEntities.end(); anEntIter++) {
78 for (int i = 0; i < 4; i++)
79 if (anEntIter->param[i] == theParamID)
83 myParameters.erase(myParameters.begin() + aPos);
84 myParamMaxID = myParameters.empty() ? SLVS_E_UNKNOWN : myParameters.back().h;
85 myNeedToResolve = true;
86 myRemovedParameters.insert(theParamID);
92 const Slvs_Param& SketchSolver_Storage::getParameter(const Slvs_hParam& theParamID) const
94 int aPos = Search(theParamID, myParameters);
95 if (aPos >= 0 && aPos < (int)myParameters.size())
96 return myParameters[aPos];
98 // Parameter is not found, return empty object
99 static Slvs_Param aDummy;
105 Slvs_hEntity SketchSolver_Storage::addEntity(const Slvs_Entity& theEntity)
107 if (theEntity.h > 0 && theEntity.h <= myEntityMaxID) {
108 // Entity is already used, rewrite it
109 return updateEntity(theEntity);
112 Slvs_Entity aEntity = theEntity;
113 if (aEntity.h > myEntityMaxID)
114 myEntityMaxID = aEntity.h;
116 aEntity.h = ++myEntityMaxID;
117 myEntities.push_back(aEntity);
118 myNeedToResolve = true;
122 Slvs_hEntity SketchSolver_Storage::updateEntity(const Slvs_Entity& theEntity)
124 if (theEntity.h > 0 && theEntity.h <= myEntityMaxID) {
125 // Entity already used, rewrite it
126 int aPos = Search(theEntity.h, myEntities);
127 if (aPos >= 0 && aPos < (int)myEntities.size()) {
128 myNeedToResolve = myNeedToResolve || IsNotEqual(myEntities[aPos], theEntity);
129 myEntities[aPos] = theEntity;
134 // Entity is not found, add new one
135 Slvs_Entity aEntity = theEntity;
137 return addEntity(aEntity);
140 bool SketchSolver_Storage::removeEntity(const Slvs_hEntity& theEntityID)
143 int aPos = Search(theEntityID, myEntities);
144 if (aPos >= 0 && aPos < (int)myEntities.size()) {
145 // Firstly, check the entity is not used elsewhere
146 std::vector<Slvs_Entity>::const_iterator anEntIter = myEntities.begin();
147 for (; anEntIter != myEntities.end(); anEntIter++) {
148 for (int i = 0; i < 4; i++)
149 if (anEntIter->point[i] == theEntityID)
151 if (anEntIter->distance == theEntityID)
154 std::vector<Slvs_Constraint>::const_iterator aConstrIter = myConstraints.begin();
155 for (; aConstrIter != myConstraints.end(); aConstrIter++) {
156 Slvs_hEntity anEntIDs[6] = {aConstrIter->ptA, aConstrIter->ptB,
157 aConstrIter->entityA, aConstrIter->entityB,
158 aConstrIter->entityC, aConstrIter->entityD};
159 for (int i = 0; i < 6; i++)
160 if (anEntIDs[i] == theEntityID)
163 // The entity is not used, remove it and its parameters
164 Slvs_Entity anEntity = myEntities[aPos];
165 myEntities.erase(myEntities.begin() + aPos);
166 myEntityMaxID = myEntities.empty() ? SLVS_E_UNKNOWN : myEntities.back().h;
167 if (anEntity.distance != SLVS_E_UNKNOWN)
168 aResult = aResult && removeParameter(anEntity.distance);
169 for (int i = 0; i < 4; i++)
170 if (anEntity.param[i] != SLVS_E_UNKNOWN)
171 aResult = removeParameter(anEntity.param[i]) && aResult;
172 for (int i = 0; i < 4; i++)
173 if (anEntity.point[i] != SLVS_E_UNKNOWN)
174 aResult = removeEntity(anEntity.point[i]) && aResult;
175 myNeedToResolve = true;
176 myRemovedEntities.insert(theEntityID);
177 if (anEntity.type == SLVS_E_POINT_IN_2D || anEntity.type == SLVS_E_POINT_IN_3D)
178 removeCoincidentPoint(theEntityID);
183 const Slvs_Entity& SketchSolver_Storage::getEntity(const Slvs_hEntity& theEntityID) const
185 int aPos = Search(theEntityID, myEntities);
186 if (aPos >= 0 && aPos < (int)myEntities.size())
187 return myEntities[aPos];
189 // Entity is not found, return empty object
190 static Slvs_Entity aDummy;
195 Slvs_hConstraint SketchSolver_Storage::isPointFixed(const Slvs_hEntity& thePointID) const
197 // Search the set of coincident points
198 std::vector< std::set<Slvs_hEntity> >::const_iterator aCPIter = myCoincidentPoints.begin();
199 for (; aCPIter != myCoincidentPoints.end(); aCPIter++)
200 if (aCPIter->find(thePointID) != aCPIter->end())
202 if (aCPIter == myCoincidentPoints.end()) {
203 std::vector<Slvs_Constraint>::const_iterator aConstrIter = myConstraints.begin();
204 for (; aConstrIter != myConstraints.end(); aConstrIter++)
205 if (aConstrIter->type == SLVS_C_WHERE_DRAGGED &&
206 aConstrIter->ptA == thePointID)
207 return aConstrIter->h;
208 return SLVS_E_UNKNOWN;
211 // Search the Rigid constraint
212 std::vector<Slvs_Constraint>::const_iterator aConstrIter = myConstraints.begin();
213 for (; aConstrIter != myConstraints.end(); aConstrIter++)
214 if (aConstrIter->type == SLVS_C_WHERE_DRAGGED &&
215 aCPIter->find(aConstrIter->ptA) != aCPIter->end())
216 return aConstrIter->h;
217 return SLVS_E_UNKNOWN;
221 Slvs_hConstraint SketchSolver_Storage::addConstraint(const Slvs_Constraint& theConstraint)
223 if (theConstraint.h > 0 && theConstraint.h <= myConstrMaxID) {
224 // Constraint is already used, rewrite it
225 return updateConstraint(theConstraint);
228 Slvs_Constraint aConstraint = theConstraint;
229 if (aConstraint.h > myConstrMaxID)
230 myConstrMaxID = aConstraint.h;
232 aConstraint.h = ++myConstrMaxID;
233 myConstraints.push_back(aConstraint);
234 myNeedToResolve = true;
235 if (aConstraint.type == SLVS_C_POINTS_COINCIDENT)
236 addCoincidentPoints(aConstraint.ptA, aConstraint.ptB);
237 return aConstraint.h;
240 Slvs_hConstraint SketchSolver_Storage::updateConstraint(const Slvs_Constraint& theConstraint)
242 if (theConstraint.h > 0 && theConstraint.h <= myConstrMaxID) {
243 // Constraint already used, rewrite it
244 int aPos = Search(theConstraint.h, myConstraints);
245 if (aPos >= 0 && aPos < (int)myConstraints.size()) {
246 myNeedToResolve = myNeedToResolve || IsNotEqual(myConstraints[aPos], theConstraint);
247 myConstraints[aPos] = theConstraint;
248 if (theConstraint.type == SLVS_C_POINTS_COINCIDENT)
249 addCoincidentPoints(theConstraint.ptA, theConstraint.ptB);
250 return theConstraint.h;
254 // Constraint is not found, add new one
255 Slvs_Constraint aConstraint = theConstraint;
257 return addConstraint(aConstraint);
260 bool SketchSolver_Storage::removeConstraint(const Slvs_hConstraint& theConstraintID)
263 int aPos = Search(theConstraintID, myConstraints);
264 if (aPos >= 0 && aPos < (int)myConstraints.size()) {
265 Slvs_Constraint aConstraint = myConstraints[aPos];
266 myConstraints.erase(myConstraints.begin() + aPos);
267 myConstrMaxID = myConstraints.empty() ? SLVS_E_UNKNOWN : myConstraints.back().h;
268 myNeedToResolve = true;
269 myRemovedConstraints.insert(theConstraintID);
270 // Remove all entities
271 Slvs_hEntity anEntities[6] = {aConstraint.ptA, aConstraint.ptB,
272 aConstraint.entityA, aConstraint.entityB,
273 aConstraint.entityC, aConstraint.entityD};
274 for (int i = 0; i < 6; i++)
275 if (anEntities[i] != SLVS_E_UNKNOWN)
276 aResult = removeEntity(anEntities[i]) && aResult;
277 // remove temporary fixed point, if available
278 if (myFixed == theConstraintID)
279 myFixed = SLVS_E_UNKNOWN;
284 const Slvs_Constraint& SketchSolver_Storage::getConstraint(const Slvs_hConstraint& theConstraintID) const
286 int aPos = Search(theConstraintID, myConstraints);
287 if (aPos >= 0 && aPos < (int)myConstraints.size())
288 return myConstraints[aPos];
290 // Constraint is not found, return empty object
291 static Slvs_Constraint aDummy;
296 void SketchSolver_Storage::addTemporaryConstraint(const Slvs_hConstraint& theConstraintID)
298 if (myFixed != SLVS_E_UNKNOWN)
299 return; // the point is already fixed
300 int aPos = Search(theConstraintID, myConstraints);
301 if (aPos >= 0 && aPos < (int)myConstraints.size())
302 myFixed = theConstraintID;
305 void SketchSolver_Storage::getRemoved(
306 std::set<Slvs_hParam>& theParameters,
307 std::set<Slvs_hEntity>& theEntities,
308 std::set<Slvs_hConstraint>& theConstraints)
310 theParameters = myRemovedParameters;
311 theEntities = myRemovedEntities;
312 theConstraints = myRemovedConstraints;
314 myRemovedParameters.clear();
315 myRemovedEntities.clear();
316 myRemovedConstraints.clear();
319 void SketchSolver_Storage::initializeSolver(SketchSolver_Solver& theSolver)
321 theSolver.setParameters(myParameters.data(), (int)myParameters.size());
322 theSolver.setEntities(myEntities.data(), (int)myEntities.size());
324 // Copy constraints excluding the fixed one
325 std::vector<Slvs_Constraint> aConstraints = myConstraints;
326 if (myFixed != SLVS_E_UNKNOWN) {
327 Slvs_hEntity aFixedPoint = SLVS_E_UNKNOWN;
328 std::vector<Slvs_Constraint>::iterator anIt = aConstraints.begin();
329 for (; anIt != aConstraints.end(); anIt++)
330 if (anIt->h == myFixed) {
331 aFixedPoint = anIt->ptA;
332 aConstraints.erase(anIt);
335 // set dragged parameters
336 int aPos = Search(aFixedPoint, myEntities);
337 theSolver.setDraggedParameters(myEntities[aPos].param);
339 theSolver.setConstraints(aConstraints.data(), (int)aConstraints.size());
342 void SketchSolver_Storage::addCoincidentPoints(
343 const Slvs_hEntity& thePoint1, const Slvs_hEntity& thePoint2)
345 std::vector< std::set<Slvs_hEntity> >::iterator aCIter = myCoincidentPoints.begin();
346 std::vector< std::set<Slvs_hEntity> >::iterator aFoundIter = myCoincidentPoints.end(); // already found coincidence
347 bool isFound = false;
348 for (; aCIter != myCoincidentPoints.end(); aCIter++) {
349 bool isFirstFound = aCIter->find(thePoint1) != aCIter->end();
350 bool isSecondFound = aCIter->find(thePoint2) != aCIter->end();
351 isFound = isFound || isFirstFound || isSecondFound;
352 if (isFirstFound && isSecondFound)
353 break; // already coincident
354 else if (isFirstFound || isSecondFound) {
355 if (aFoundIter != myCoincidentPoints.end()) {
357 aFoundIter->insert(aCIter->begin(), aCIter->end());
358 myCoincidentPoints.erase(aCIter);
361 aCIter->insert(thePoint1);
362 aCIter->insert(thePoint2);
365 // coincident points not found
367 std::set<Slvs_hEntity> aNewSet;
368 aNewSet.insert(thePoint1);
369 aNewSet.insert(thePoint2);
370 myCoincidentPoints.push_back(aNewSet);
374 void SketchSolver_Storage::removeCoincidentPoint(const Slvs_hEntity& thePoint)
376 std::vector< std::set<Slvs_hEntity> >::iterator aCIter = myCoincidentPoints.begin();
377 for (; aCIter != myCoincidentPoints.end(); aCIter++)
378 if (aCIter->find(thePoint) != aCIter->end()) {
379 aCIter->erase(thePoint);
380 if (aCIter->size() <= 1)
381 myCoincidentPoints.erase(aCIter);
386 bool SketchSolver_Storage::isCoincident(
387 const Slvs_hEntity& thePoint1, const Slvs_hEntity& thePoint2) const
389 std::vector< std::set<Slvs_hEntity> >::const_iterator aCIter = myCoincidentPoints.begin();
390 for (; aCIter != myCoincidentPoints.end(); aCIter++)
391 if (aCIter->find(thePoint1) != aCIter->end() && aCIter->find(thePoint2) != aCIter->end())
399 // ========================================================
400 // ========= Auxiliary functions ===============
401 // ========================================================
404 int Search(const uint32_t& theEntityID, const std::vector<T>& theEntities)
406 int aResIndex = theEntityID <= theEntities.size() ? theEntityID - 1 : 0;
407 int aVecSize = theEntities.size();
408 if (theEntities.empty())
410 while (aResIndex >= 0 && theEntities[aResIndex].h > theEntityID)
412 while (aResIndex < aVecSize && aResIndex >= 0 && theEntities[aResIndex].h < theEntityID)
415 aResIndex = aVecSize;
419 bool IsNotEqual(const Slvs_Param& theParam1, const Slvs_Param& theParam2)
421 return fabs(theParam1.val - theParam2.val) > tolerance;
424 bool IsNotEqual(const Slvs_Entity& theEntity1, const Slvs_Entity& theEntity2)
427 for (; theEntity1.param[i] != 0 && i < 4; i++)
428 if (theEntity1.param[i] != theEntity2.param[i])
431 for (; theEntity1.point[i] != 0 && i < 4; i++)
432 if (theEntity1.point[i] != theEntity2.point[i])
437 bool IsNotEqual(const Slvs_Constraint& theConstraint1, const Slvs_Constraint& theConstraint2)
439 return theConstraint1.ptA != theConstraint2.ptA ||
440 theConstraint1.ptB != theConstraint2.ptB ||
441 theConstraint1.entityA != theConstraint2.entityA ||
442 theConstraint1.entityB != theConstraint2.entityB ||
443 theConstraint1.entityC != theConstraint2.entityC ||
444 theConstraint1.entityD != theConstraint2.entityD ||
445 fabs(theConstraint1.valA - theConstraint2.valA) > tolerance;