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_hEntity SketchSolver_Storage::copyEntity(const Slvs_hEntity& theCopied)
197 int aPos = Search(theCopied, myEntities);
198 if (aPos < 0 || aPos >= (int)myEntities.size())
199 return SLVS_E_UNKNOWN;
201 Slvs_Entity aCopy = myEntities[aPos];
202 aCopy.h = SLVS_E_UNKNOWN;
204 while (aCopy.point[i] != SLVS_E_UNKNOWN) {
205 aCopy.point[i] = copyEntity(aCopy.point[i]);
208 if (aCopy.param[0] != SLVS_E_UNKNOWN) {
209 aPos = Search(aCopy.param[0], myParameters);
211 while (aCopy.param[i] != SLVS_E_UNKNOWN) {
212 Slvs_Param aNewParam = myParameters[aPos];
213 aNewParam.h = SLVS_E_UNKNOWN;
214 aCopy.param[i] = addParameter(aNewParam);
219 return addEntity(aCopy);
222 void SketchSolver_Storage::copyEntity(const Slvs_hEntity& theFrom, const Slvs_hEntity& theTo)
224 int aPosFrom = Search(theFrom, myEntities);
225 int aPosTo = Search(theTo, myEntities);
226 if (aPosFrom < 0 || aPosFrom >= (int)myEntities.size() ||
227 aPosTo < 0 || aPosTo >= (int)myEntities.size())
230 Slvs_Entity aEntFrom = myEntities[aPosFrom];
231 Slvs_Entity aEntTo = myEntities[aPosTo];
233 while (aEntFrom.point[i] != SLVS_E_UNKNOWN) {
234 copyEntity(aEntFrom.point[i], aEntTo.point[i]);
237 if (aEntFrom.param[0] != SLVS_E_UNKNOWN) {
238 aPosFrom = Search(aEntFrom.param[0], myParameters);
239 aPosTo = Search(aEntTo.param[0], myParameters);
241 while (aEntFrom.param[i] != SLVS_E_UNKNOWN) {
242 myParameters[aPosTo++].val = myParameters[aPosFrom++].val;
249 bool SketchSolver_Storage::isPointFixed(
250 const Slvs_hEntity& thePointID, Slvs_hConstraint& theFixed, bool theAccurate) const
252 // Search the set of coincident points
253 std::set<Slvs_hEntity> aCoincident;
254 aCoincident.insert(thePointID);
255 std::vector< std::set<Slvs_hEntity> >::const_iterator aCPIter = myCoincidentPoints.begin();
256 for (; aCPIter != myCoincidentPoints.end(); aCPIter++)
257 if (aCPIter->find(thePointID) != aCPIter->end()) {
258 aCoincident = *aCPIter;
262 // Search the Rigid constraint
263 std::vector<Slvs_Constraint>::const_iterator aConstrIter = myConstraints.begin();
264 for (; aConstrIter != myConstraints.end(); aConstrIter++)
265 if (aConstrIter->type == SLVS_C_WHERE_DRAGGED &&
266 aCoincident.find(aConstrIter->ptA) != aCoincident.end()) {
267 theFixed = aConstrIter->h;
272 // Try to find the fixed entity which uses such point or its coincidence
273 std::vector<Slvs_Entity>::const_iterator anEntIter = myEntities.begin();
274 for (; anEntIter != myEntities.end(); anEntIter++) {
275 for (int i = 0; i < 4; i++) {
276 Slvs_hEntity aPt = anEntIter->point[i];
277 if (aPt != SLVS_E_UNKNOWN &&
278 (aPt == thePointID || aCoincident.find(aPt) != aCoincident.end())) {
279 if (isEntityFixed(anEntIter->h, true))
285 return SLVS_E_UNKNOWN;
288 bool SketchSolver_Storage::isEntityFixed(const Slvs_hEntity& theEntityID, bool theAccurate) const
290 int aPos = Search(theEntityID, myEntities);
291 if (aPos < 0 || aPos >= (int)myEntities.size())
294 // Firstly, find how many points are under Rigid constraint
296 for (int i = 0; i < 4; i++) {
297 Slvs_hEntity aPoint = myEntities[aPos].point[i];
298 if (aPoint == SLVS_E_UNKNOWN)
301 std::set<Slvs_hEntity> aCoincident;
302 aCoincident.insert(aPoint);
303 std::vector< std::set<Slvs_hEntity> >::const_iterator aCPIter = myCoincidentPoints.begin();
304 for (; aCPIter != myCoincidentPoints.end(); aCPIter++)
305 if (aCPIter->find(aPoint) != aCPIter->end()) {
306 aCoincident = *aCPIter;
310 // Search the Rigid constraint
311 std::vector<Slvs_Constraint>::const_iterator aConstrIter = myConstraints.begin();
312 for (; aConstrIter != myConstraints.end(); aConstrIter++)
313 if (aConstrIter->type == SLVS_C_WHERE_DRAGGED &&
314 aCoincident.find(aConstrIter->ptA) != aCoincident.end())
318 std::list<Slvs_Constraint> aList;
319 std::list<Slvs_Constraint>::iterator anIt;
320 Slvs_hConstraint aTempID; // used in isPointFixed() method
322 if (myEntities[aPos].type == SLVS_E_LINE_SEGMENT) {
325 else if (aNbFixed == 0 || !theAccurate)
327 // Additional check (the line may be fixed if it is used by different constraints):
328 // 1. The line is used in Equal constraint, another entity is fixed and there is a fixed point on line
329 aList = getConstraintsByType(SLVS_C_PT_ON_LINE);
330 for (anIt = aList.begin(); anIt != aList.end(); anIt++)
331 if (anIt->entityA == theEntityID && isPointFixed(anIt->ptA, aTempID))
333 if (anIt != aList.end()) {
334 aList = getConstraintsByType(SLVS_C_EQUAL_LENGTH_LINES);
335 aList.splice(aList.end(), getConstraintsByType(SLVS_C_EQUAL_LINE_ARC_LEN));
336 for (anIt = aList.begin(); anIt != aList.end(); anIt++)
337 if (anIt->entityA == theEntityID || anIt->entityB == theEntityID) {
338 Slvs_hEntity anOther = anIt->entityA == theEntityID ? anIt->entityB : anIt->entityA;
339 if (isEntityFixed(anOther, false))
343 // 2. The line is used in Parallel/Perpendicular and Length constraints
344 aList = getConstraintsByType(SLVS_C_PARALLEL);
345 aList.splice(aList.end(), getConstraintsByType(SLVS_C_PERPENDICULAR));
346 for (anIt = aList.begin(); anIt != aList.end(); anIt++)
347 if (anIt->entityA == theEntityID || anIt->entityB == theEntityID) {
348 Slvs_hEntity anOther = anIt->entityA == theEntityID ? anIt->entityB : anIt->entityA;
349 if (isEntityFixed(anOther, false))
352 if (anIt != aList.end()) {
353 aList = getConstraintsByType(SLVS_C_PT_PT_DISTANCE);
354 for (anIt = aList.begin(); anIt != aList.end(); anIt++)
355 if ((anIt->ptA == myEntities[aPos].point[0] && anIt->ptB == myEntities[aPos].point[1]) ||
356 (anIt->ptA == myEntities[aPos].point[1] && anIt->ptB == myEntities[aPos].point[0]))
359 // 3. Another verifiers ...
360 } else if (myEntities[aPos].type == SLVS_E_CIRCLE) {
363 // Search for Diameter constraint
364 aList = getConstraintsByType(SLVS_C_DIAMETER);
365 for (anIt = aList.begin(); anIt != aList.end(); anIt++)
366 if (anIt->entityA == theEntityID)
370 // Additional check (the circle may be fixed if it is used by different constraints):
371 // 1. The circle is used in Equal constraint and another entity is fixed
372 aList = getConstraintsByType(SLVS_C_EQUAL_RADIUS);
373 for (anIt = aList.begin(); anIt != aList.end(); anIt++)
374 if (anIt->entityA == theEntityID || anIt->entityB == theEntityID) {
375 Slvs_hEntity anOther = anIt->entityA == theEntityID ? anIt->entityB : anIt->entityA;
376 if (isEntityFixed(anOther, false))
379 // 2. Another verifiers ...
380 } else if (myEntities[aPos].type == SLVS_E_ARC_OF_CIRCLE) {
383 else if (aNbFixed <= 1)
385 // Search for Diameter constraint
386 aList = getConstraintsByType(SLVS_C_DIAMETER);
387 for (anIt = aList.begin(); anIt != aList.end(); anIt++)
388 if (anIt->entityA == theEntityID)
392 // Additional check (the arc may be fixed if it is used by different constraints):
393 // 1. The arc is used in Equal constraint and another entity is fixed
394 aList = getConstraintsByType(SLVS_C_EQUAL_RADIUS);
395 aList.splice(aList.end(), getConstraintsByType(SLVS_C_EQUAL_LINE_ARC_LEN));
396 for (anIt = aList.begin(); anIt != aList.end(); anIt++)
397 if (anIt->entityA == theEntityID || anIt->entityB == theEntityID) {
398 Slvs_hEntity anOther = anIt->entityA == theEntityID ? anIt->entityB : anIt->entityA;
399 if (isEntityFixed(anOther, false))
402 // 2. Another verifiers ...
408 Slvs_hConstraint SketchSolver_Storage::addConstraint(const Slvs_Constraint& theConstraint)
410 if (theConstraint.h > 0 && theConstraint.h <= myConstrMaxID) {
411 // Constraint is already used, rewrite it
412 return updateConstraint(theConstraint);
415 Slvs_Constraint aConstraint = theConstraint;
417 // Find a constraint with same type uses same arguments
418 std::vector<Slvs_Constraint>::iterator aCIt = myConstraints.begin();
419 for (; aCIt != myConstraints.end(); aCIt++) {
420 if (aConstraint.type != aCIt->type)
422 if (aConstraint.ptA == aCIt->ptA && aConstraint.ptB == aCIt->ptB &&
423 aConstraint.entityA == aCIt->entityA && aConstraint.entityB == aCIt->entityB &&
424 aConstraint.entityC == aCIt->entityC && aConstraint.entityD == aCIt->entityD) {
425 aConstraint.h = aCIt->h;
426 return updateConstraint(aConstraint);
430 if (aConstraint.h > myConstrMaxID)
431 myConstrMaxID = aConstraint.h;
433 aConstraint.h = ++myConstrMaxID;
434 myConstraints.push_back(aConstraint);
435 myNeedToResolve = true;
436 if (aConstraint.type == SLVS_C_POINTS_COINCIDENT)
437 addCoincidentPoints(aConstraint.ptA, aConstraint.ptB);
438 return aConstraint.h;
441 Slvs_hConstraint SketchSolver_Storage::updateConstraint(const Slvs_Constraint& theConstraint)
443 if (theConstraint.h > 0 && theConstraint.h <= myConstrMaxID) {
444 // Constraint already used, rewrite it
445 int aPos = Search(theConstraint.h, myConstraints);
446 if (aPos >= 0 && aPos < (int)myConstraints.size()) {
447 myNeedToResolve = myNeedToResolve || IsNotEqual(myConstraints[aPos], theConstraint);
448 myConstraints[aPos] = theConstraint;
449 if (theConstraint.type == SLVS_C_POINTS_COINCIDENT)
450 addCoincidentPoints(theConstraint.ptA, theConstraint.ptB);
451 return theConstraint.h;
455 // Constraint is not found, add new one
456 Slvs_Constraint aConstraint = theConstraint;
458 return addConstraint(aConstraint);
461 bool SketchSolver_Storage::removeConstraint(const Slvs_hConstraint& theConstraintID)
464 int aPos = Search(theConstraintID, myConstraints);
465 if (aPos >= 0 && aPos < (int)myConstraints.size()) {
466 Slvs_Constraint aConstraint = myConstraints[aPos];
467 myConstraints.erase(myConstraints.begin() + aPos);
468 myConstrMaxID = myConstraints.empty() ? SLVS_E_UNKNOWN : myConstraints.back().h;
469 myNeedToResolve = true;
470 myRemovedConstraints.insert(theConstraintID);
471 // Remove all entities
472 Slvs_hEntity anEntities[6] = {aConstraint.ptA, aConstraint.ptB,
473 aConstraint.entityA, aConstraint.entityB,
474 aConstraint.entityC, aConstraint.entityD};
475 for (int i = 0; i < 6; i++)
476 if (anEntities[i] != SLVS_E_UNKNOWN)
477 aResult = removeEntity(anEntities[i]) && aResult;
478 // remove temporary fixed point, if available
479 if (myFixed == theConstraintID)
480 myFixed = SLVS_E_UNKNOWN;
485 const Slvs_Constraint& SketchSolver_Storage::getConstraint(const Slvs_hConstraint& theConstraintID) const
487 int aPos = Search(theConstraintID, myConstraints);
488 if (aPos >= 0 && aPos < (int)myConstraints.size())
489 return myConstraints[aPos];
491 // Constraint is not found, return empty object
492 static Slvs_Constraint aDummy;
497 std::list<Slvs_Constraint> SketchSolver_Storage::getConstraintsByType(int theConstraintType) const
499 std::list<Slvs_Constraint> aResult;
500 std::vector<Slvs_Constraint>::const_iterator aCIter = myConstraints.begin();
501 for (; aCIter != myConstraints.end(); aCIter++)
502 if (aCIter->type == theConstraintType)
503 aResult.push_back(*aCIter);
508 void SketchSolver_Storage::addConstraintWhereDragged(const Slvs_hConstraint& theConstraintID)
510 if (myFixed != SLVS_E_UNKNOWN)
511 return; // the point is already fixed
512 int aPos = Search(theConstraintID, myConstraints);
513 if (aPos >= 0 && aPos < (int)myConstraints.size())
514 myFixed = theConstraintID;
517 void SketchSolver_Storage::addTemporaryConstraint(const Slvs_hConstraint& theConstraintID)
519 myTemporaryConstraints.insert(theConstraintID);
522 void SketchSolver_Storage::removeTemporaryConstraints()
524 myTemporaryConstraints.clear();
527 bool SketchSolver_Storage::isTemporary(const Slvs_hConstraint& theConstraintID) const
529 return myTemporaryConstraints.find(theConstraintID) != myTemporaryConstraints.end();
533 void SketchSolver_Storage::getRemoved(
534 std::set<Slvs_hParam>& theParameters,
535 std::set<Slvs_hEntity>& theEntities,
536 std::set<Slvs_hConstraint>& theConstraints)
538 theParameters = myRemovedParameters;
539 theEntities = myRemovedEntities;
540 theConstraints = myRemovedConstraints;
542 myRemovedParameters.clear();
543 myRemovedEntities.clear();
544 myRemovedConstraints.clear();
547 void SketchSolver_Storage::initializeSolver(SketchSolver_Solver& theSolver)
549 theSolver.setParameters(myParameters.data(), (int)myParameters.size());
550 theSolver.setEntities(myEntities.data(), (int)myEntities.size());
552 // Copy constraints excluding the fixed one
553 std::vector<Slvs_Constraint> aConstraints = myConstraints;
554 if (myFixed != SLVS_E_UNKNOWN) {
555 Slvs_hEntity aFixedPoint = SLVS_E_UNKNOWN;
556 std::vector<Slvs_Constraint>::iterator anIt = aConstraints.begin();
557 for (; anIt != aConstraints.end(); anIt++)
558 if (anIt->h == myFixed) {
559 aFixedPoint = anIt->ptA;
560 aConstraints.erase(anIt);
563 // set dragged parameters
564 int aPos = Search(aFixedPoint, myEntities);
565 theSolver.setDraggedParameters(myEntities[aPos].param);
567 theSolver.setConstraints(aConstraints.data(), (int)aConstraints.size());
570 void SketchSolver_Storage::addCoincidentPoints(
571 const Slvs_hEntity& thePoint1, const Slvs_hEntity& thePoint2)
573 std::vector< std::set<Slvs_hEntity> >::iterator aCIter = myCoincidentPoints.begin();
574 std::vector< std::set<Slvs_hEntity> >::iterator aFoundIter = myCoincidentPoints.end(); // already found coincidence
575 bool isFound = false;
576 for (; aCIter != myCoincidentPoints.end(); aCIter++) {
577 bool isFirstFound = aCIter->find(thePoint1) != aCIter->end();
578 bool isSecondFound = aCIter->find(thePoint2) != aCIter->end();
579 isFound = isFound || isFirstFound || isSecondFound;
580 if (isFirstFound && isSecondFound)
581 break; // already coincident
582 else if (isFirstFound || isSecondFound) {
583 if (aFoundIter != myCoincidentPoints.end()) {
585 aFoundIter->insert(aCIter->begin(), aCIter->end());
586 myCoincidentPoints.erase(aCIter);
589 aCIter->insert(thePoint1);
590 aCIter->insert(thePoint2);
593 // coincident points not found
595 std::set<Slvs_hEntity> aNewSet;
596 aNewSet.insert(thePoint1);
597 aNewSet.insert(thePoint2);
598 myCoincidentPoints.push_back(aNewSet);
602 void SketchSolver_Storage::removeCoincidentPoint(const Slvs_hEntity& thePoint)
604 std::vector< std::set<Slvs_hEntity> >::iterator aCIter = myCoincidentPoints.begin();
605 for (; aCIter != myCoincidentPoints.end(); aCIter++)
606 if (aCIter->find(thePoint) != aCIter->end()) {
607 aCIter->erase(thePoint);
608 if (aCIter->size() <= 1)
609 myCoincidentPoints.erase(aCIter);
614 bool SketchSolver_Storage::isCoincident(
615 const Slvs_hEntity& thePoint1, const Slvs_hEntity& thePoint2) const
617 std::vector< std::set<Slvs_hEntity> >::const_iterator aCIter = myCoincidentPoints.begin();
618 for (; aCIter != myCoincidentPoints.end(); aCIter++)
619 if (aCIter->find(thePoint1) != aCIter->end() && aCIter->find(thePoint2) != aCIter->end())
627 // ========================================================
628 // ========= Auxiliary functions ===============
629 // ========================================================
632 int Search(const uint32_t& theEntityID, const std::vector<T>& theEntities)
634 int aResIndex = theEntityID <= theEntities.size() ? theEntityID - 1 : 0;
635 int aVecSize = theEntities.size();
636 if (theEntities.empty())
638 while (aResIndex >= 0 && theEntities[aResIndex].h > theEntityID)
640 while (aResIndex < aVecSize && aResIndex >= 0 && theEntities[aResIndex].h < theEntityID)
643 aResIndex = aVecSize;
647 bool IsNotEqual(const Slvs_Param& theParam1, const Slvs_Param& theParam2)
649 return fabs(theParam1.val - theParam2.val) > tolerance;
652 bool IsNotEqual(const Slvs_Entity& theEntity1, const Slvs_Entity& theEntity2)
655 for (; theEntity1.param[i] != 0 && i < 4; i++)
656 if (theEntity1.param[i] != theEntity2.param[i])
659 for (; theEntity1.point[i] != 0 && i < 4; i++)
660 if (theEntity1.point[i] != theEntity2.point[i])
665 bool IsNotEqual(const Slvs_Constraint& theConstraint1, const Slvs_Constraint& theConstraint2)
667 return theConstraint1.ptA != theConstraint2.ptA ||
668 theConstraint1.ptB != theConstraint2.ptB ||
669 theConstraint1.entityA != theConstraint2.entityA ||
670 theConstraint1.entityB != theConstraint2.entityB ||
671 theConstraint1.entityC != theConstraint2.entityC ||
672 theConstraint1.entityD != theConstraint2.entityD ||
673 fabs(theConstraint1.valA - theConstraint2.valA) > tolerance;