1 // Copyright (C) 2014-20xx CEA/DEN, EDF R&D
3 // File: SketchSolver_Group.cpp
4 // Created: 27 May 2014
5 // Author: Artem ZHIDKOV
7 #include "SketchSolver_Group.h"
9 #include <SketchSolver_Builder.h>
10 #include <SketchSolver_Constraint.h>
11 #include <SketchSolver_ConstraintCoincidence.h>
12 #include <SketchSolver_Error.h>
14 #include <Events_Error.h>
15 #include <Events_Loop.h>
16 #include <GeomAPI_XY.h>
17 #include <GeomAPI_Dir2d.h>
18 #include <GeomAPI_Pnt2d.h>
19 #include <GeomDataAPI_Dir.h>
20 #include <GeomDataAPI_Point.h>
21 #include <GeomDataAPI_Point2D.h>
22 #include <ModelAPI_AttributeDouble.h>
23 #include <ModelAPI_Document.h>
24 #include <ModelAPI_Events.h>
25 #include <ModelAPI_ResultConstruction.h>
27 #include <SketchPlugin_Constraint.h>
28 #include <SketchPlugin_ConstraintEqual.h>
29 #include <SketchPlugin_ConstraintFillet.h>
30 #include <SketchPlugin_ConstraintLength.h>
31 #include <SketchPlugin_ConstraintCoincidence.h>
32 #include <SketchPlugin_ConstraintMirror.h>
33 #include <SketchPlugin_ConstraintRigid.h>
34 #include <SketchPlugin_ConstraintTangent.h>
35 #include <SketchPlugin_Feature.h>
37 #include <SketchPlugin_Arc.h>
38 #include <SketchPlugin_Circle.h>
39 #include <SketchPlugin_Line.h>
40 #include <SketchPlugin_Point.h>
41 #include <SketchPlugin_Sketch.h>
47 /// \brief This class is used to give unique index to the groups
51 /// \brief Return vacant index
52 static Slvs_hGroup NEW_GROUP() { return ++myGroupIndex; }
53 /// \brief Removes the index
54 static void REMOVE_GROUP(const Slvs_hGroup& theIndex) {
55 if (myGroupIndex == theIndex)
62 static Slvs_hGroup myGroupIndex; ///< index of the group
65 Slvs_hGroup GroupIndexer::myGroupIndex = 0;
69 // ========================================================
70 // ========= SketchSolver_Group ===============
71 // ========================================================
73 SketchSolver_Group::SketchSolver_Group(
74 std::shared_ptr<ModelAPI_CompositeFeature> theWorkplane)
75 : myID(GroupIndexer::NEW_GROUP())
77 // Initialize workplane
78 myWorkplaneID = SLVS_E_UNKNOWN;
80 assert(addWorkplane(theWorkplane));
82 addWorkplane(theWorkplane);
86 SketchSolver_Group::~SketchSolver_Group()
88 myConstraints.clear();
89 GroupIndexer::REMOVE_GROUP(myID);
92 // ============================================================================
93 // Function: isBaseWorkplane
94 // Class: SketchSolver_Group
95 // Purpose: verify the group is based on the given workplane
96 // ============================================================================
97 bool SketchSolver_Group::isBaseWorkplane(CompositeFeaturePtr theWorkplane) const
99 return theWorkplane == mySketch;
102 // ============================================================================
103 // Function: isInteract
104 // Class: SketchSolver_Group
105 // Purpose: verify are there any entities in the group used by given constraint
106 // ============================================================================
107 bool SketchSolver_Group::isInteract(
108 std::shared_ptr<SketchPlugin_Feature> theFeature) const
110 // Empty group interacts with everything
111 if (isEmpty()) return true;
112 ConstraintPtr aConstraint = std::dynamic_pointer_cast<SketchPlugin_Constraint>(theFeature);
114 return myFeatureStorage->isInteract(aConstraint);
115 return myFeatureStorage->isInteract(std::dynamic_pointer_cast<ModelAPI_Feature>(theFeature));
118 // ============================================================================
119 // Function: getFeatureId
120 // Class: SketchSolver_Group
121 // Purpose: Find the identifier of the feature, if it already exists in the group
122 // ============================================================================
123 Slvs_hEntity SketchSolver_Group::getFeatureId(FeaturePtr theFeature) const
125 Slvs_hEntity aResult = SLVS_E_UNKNOWN;
126 if (!myFeatureStorage)
128 std::set<ConstraintPtr> aConstraints = myFeatureStorage->getConstraints(theFeature);
129 if (aConstraints.empty())
131 std::set<ConstraintPtr>::iterator aConstrIter = aConstraints.begin();
132 for (; aConstrIter != aConstraints.end(); aConstrIter++) {
133 ConstraintConstraintMap::const_iterator aCIter = myConstraints.find(*aConstrIter);
134 if (aCIter == myConstraints.end())
136 aResult = aCIter->second->getId(theFeature);
137 if (aResult != SLVS_E_UNKNOWN)
140 return SLVS_E_UNKNOWN;
143 // ============================================================================
144 // Function: getAttributeId
145 // Class: SketchSolver_Group
146 // Purpose: Find the identifier of the attribute, if it already exists in the group
147 // ============================================================================
148 Slvs_hEntity SketchSolver_Group::getAttributeId(AttributePtr theAttribute) const
150 Slvs_hEntity aResult = SLVS_E_UNKNOWN;
151 if (!myFeatureStorage)
153 std::set<ConstraintPtr> aConstraints = myFeatureStorage->getConstraints(theAttribute);
154 if (aConstraints.empty())
156 std::set<ConstraintPtr>::iterator aConstrIter = aConstraints.begin();
157 for (; aConstrIter != aConstraints.end(); aConstrIter++) {
158 ConstraintConstraintMap::const_iterator aCIter = myConstraints.find(*aConstrIter);
159 if (aCIter == myConstraints.end())
161 aResult = aCIter->second->getId(theAttribute);
162 if (aResult != SLVS_E_UNKNOWN)
165 return SLVS_E_UNKNOWN;
168 // ============================================================================
169 // Function: changeConstraint
170 // Class: SketchSolver_Group
171 // Purpose: create/update the constraint in the group
172 // ============================================================================
173 bool SketchSolver_Group::changeConstraint(
174 std::shared_ptr<SketchPlugin_Constraint> theConstraint)
176 // There is no workplane yet, something wrong
177 if (myWorkplaneID == SLVS_E_UNKNOWN)
183 bool isNewConstraint = myConstraints.find(theConstraint) == myConstraints.end();
184 if (isNewConstraint) {
185 // Add constraint to the current group
186 SolverConstraintPtr aConstraint =
187 SketchSolver_Builder::getInstance()->createConstraint(theConstraint);
190 aConstraint->setGroup(this);
191 aConstraint->setStorage(myStorage);
192 if (!aConstraint->error().empty()) {
193 if (aConstraint->error() == SketchSolver_Error::NOT_INITIALIZED())
194 return false; // some attribute are not initialized yet, don't show message
195 Events_Error::send(aConstraint->error(), this);
198 // Additional verification of coincidence of several points
199 if (theConstraint->getKind() == SketchPlugin_ConstraintCoincidence::ID()) {
200 ConstraintConstraintMap::iterator aCIter = myConstraints.begin();
201 for (; aCIter != myConstraints.end(); aCIter++) {
202 std::shared_ptr<SketchSolver_ConstraintCoincidence> aCoincidence =
203 std::dynamic_pointer_cast<SketchSolver_ConstraintCoincidence>(aCIter->second);
206 std::shared_ptr<SketchSolver_ConstraintCoincidence> aCoinc2 =
207 std::dynamic_pointer_cast<SketchSolver_ConstraintCoincidence>(aConstraint);
208 if (aCoincidence != aCoinc2 && aCoincidence->isCoincide(aCoinc2)) {
209 aCoincidence->attach(aCoinc2);
210 aConstraint = aCoincidence;
214 myConstraints[theConstraint] = aConstraint;
217 myConstraints[theConstraint]->update();
219 // Fix base features for fillet
220 if (isNewConstraint && theConstraint->getKind() == SketchPlugin_ConstraintFillet::ID()) {
221 std::list<AttributePtr> anAttrList =
222 theConstraint->data()->attributes(ModelAPI_AttributeRefAttr::typeId());
223 std::list<AttributePtr>::iterator anAttrIter = anAttrList.begin();
224 for (; anAttrIter != anAttrList.end(); anAttrIter++) {
225 AttributeRefAttrPtr aRefAttr =
226 std::dynamic_pointer_cast<ModelAPI_AttributeRefAttr>(*anAttrIter);
227 if (!aRefAttr || !aRefAttr->isObject())
229 FeaturePtr aFeature = ModelAPI_Feature::feature(aRefAttr->object());
230 SolverConstraintPtr aConstraint =
231 SketchSolver_Builder::getInstance()->createRigidConstraint(aFeature);
234 aConstraint->setGroup(this);
235 aConstraint->setStorage(myStorage);
236 setTemporary(aConstraint);
240 if (theConstraint->getKind() == SketchPlugin_ConstraintMirror::ID()) {
241 AttributeRefAttrPtr aRefAttr = std::dynamic_pointer_cast<ModelAPI_AttributeRefAttr>(
242 theConstraint->attribute(SketchPlugin_ConstraintMirror::ENTITY_A()));
243 if (aRefAttr && aRefAttr->isObject()) {
244 FeaturePtr aFeature = ModelAPI_Feature::feature(aRefAttr->object());
246 SolverConstraintPtr aConstraint =
247 SketchSolver_Builder::getInstance()->createRigidConstraint(aFeature);
249 aConstraint->setGroup(this);
250 aConstraint->setStorage(myStorage);
251 setTemporary(aConstraint);
257 if (!myFeatureStorage)
258 myFeatureStorage = FeatureStoragePtr(new SketchSolver_FeatureStorage);
259 myFeatureStorage->changeConstraint(theConstraint);
265 bool SketchSolver_Group::updateFeature(std::shared_ptr<SketchPlugin_Feature> theFeature)
267 std::set<ConstraintPtr> aConstraints =
268 myFeatureStorage->getConstraints(std::dynamic_pointer_cast<ModelAPI_Feature>(theFeature));
269 if (aConstraints.empty())
271 std::set<ConstraintPtr>::iterator aCIter = aConstraints.begin();
272 for (; aCIter != aConstraints.end(); aCIter++) {
273 ConstraintConstraintMap::iterator aSolConIter = myConstraints.find(*aCIter);
274 if (aSolConIter == myConstraints.end() || !aSolConIter->first->data() ||
275 !aSolConIter->first->data()->isValid())
277 myFeatureStorage->changeFeature(theFeature, aSolConIter->first);
278 aSolConIter->second->addFeature(theFeature);
279 aSolConIter->second->update();
284 void SketchSolver_Group::moveFeature(std::shared_ptr<SketchPlugin_Feature> theFeature)
286 // Firstly, create temporary rigid constraint
287 SolverConstraintPtr aConstraint =
288 SketchSolver_Builder::getInstance()->createMovementConstraint(theFeature);
291 aConstraint->setGroup(this);
292 aConstraint->setStorage(myStorage);
293 if (aConstraint->error().empty())
294 setTemporary(aConstraint);
295 // Secondly, update the feature
296 updateFeature(theFeature);
299 // ============================================================================
300 // Function: fixFeaturesList
301 // Class: SketchSolver_Group
302 // Purpose: Apply temporary rigid constraints for the list of features
303 // ============================================================================
304 void SketchSolver_Group::fixFeaturesList(AttributeRefListPtr theList)
306 std::list<ObjectPtr> aList = theList->list();
307 std::list<ObjectPtr>::iterator anIt = aList.begin();
308 std::list<FeaturePtr> aFeatures;
309 // Sort features, at begining there are features used by Equal constraint
310 for (; anIt != aList.end(); anIt++) {
313 FeaturePtr aFeature = ModelAPI_Feature::feature(*anIt);
314 std::set<ConstraintPtr> aConstraints = myFeatureStorage->getConstraints(aFeature);
315 std::set<ConstraintPtr>::iterator aCIter = aConstraints.begin();
316 for (; aCIter != aConstraints.end(); aCIter++)
317 if ((*aCIter)->getKind() == SketchPlugin_ConstraintEqual::ID())
319 if (aCIter != aConstraints.end())
320 aFeatures.push_front(aFeature);
322 aFeatures.push_back(aFeature);
325 std::list<FeaturePtr>::iterator aFeatIter = aFeatures.begin();
326 for (; aFeatIter != aFeatures.end(); aFeatIter++) {
327 SolverConstraintPtr aConstraint =
328 SketchSolver_Builder::getInstance()->createRigidConstraint(*aFeatIter);
331 aConstraint->setGroup(this);
332 aConstraint->setStorage(myStorage);
333 setTemporary(aConstraint);
337 // ============================================================================
338 // Function: addWorkplane
339 // Class: SketchSolver_Group
340 // Purpose: create workplane for the group
341 // ============================================================================
342 bool SketchSolver_Group::addWorkplane(CompositeFeaturePtr theSketch)
344 if (myWorkplaneID != SLVS_E_UNKNOWN || theSketch->getKind() != SketchPlugin_Sketch::ID())
345 return false; // the workplane already exists or the function parameter is not Sketch
347 mySketch = theSketch;
352 // ============================================================================
353 // Function: updateWorkplane
354 // Class: SketchSolver_Group
355 // Purpose: update parameters of workplane
356 // ============================================================================
357 bool SketchSolver_Group::updateWorkplane()
359 if (!myStorage) // Create storage if not exists
360 myStorage = StoragePtr(new SketchSolver_Storage);
361 SketchSolver_Builder* aBuilder = SketchSolver_Builder::getInstance();
363 std::vector<Slvs_Entity> anEntities;
364 std::vector<Slvs_Param> aParams;
365 if (!aBuilder->createWorkplane(mySketch, anEntities, aParams))
368 if (myWorkplaneID == SLVS_E_UNKNOWN) {
369 myWorkplaneID = anEntities.back().h;
370 // Add new workplane elements
371 std::vector<Slvs_Param>::iterator aParIter = aParams.begin();
372 for (; aParIter != aParams.end(); aParIter++) {
373 aParIter->h = SLVS_E_UNKNOWN; // the ID should be generated by storage
374 aParIter->group = myID;
375 aParIter->h = myStorage->addParameter(*aParIter);
377 std::vector<Slvs_Entity>::iterator anEntIter = anEntities.begin();
378 for (; anEntIter != anEntities.end(); anEntIter++) {
379 anEntIter->h = SLVS_E_UNKNOWN; // the ID should be generated by storage
380 anEntIter->group = myID;
381 anEntIter->wrkpl = myWorkplaneID;
382 for (int i = 0; i < 4; i++)
383 if (anEntIter->param[i] != SLVS_E_UNKNOWN)
384 anEntIter->param[i] = aParams[anEntIter->param[i]-1].h;
385 for (int i = 0; i < 4; i++)
386 if (anEntIter->point[i] != SLVS_E_UNKNOWN)
387 anEntIter->point[i] = anEntities[anEntIter->point[i]-1].h;
388 anEntIter->h = myStorage->addEntity(*anEntIter);
391 // Update existent workplane
392 const Slvs_Entity& aWP = myStorage->getEntity(myWorkplaneID);
393 const Slvs_Entity& anOrigin = myStorage->getEntity(aWP.point[0]);
394 const Slvs_Entity& aNormal = myStorage->getEntity(aWP.normal);
395 // Get parameters and update them
396 Slvs_hParam aWPParams[7] = {
397 anOrigin.param[0], anOrigin.param[1], anOrigin.param[2],
398 aNormal.param[0], aNormal.param[1], aNormal.param[2], aNormal.param[3]
400 std::vector<Slvs_Param>::iterator aParIter = aParams.begin();
401 for (int i = 0; aParIter != aParams.end(); aParIter++, i++) {
402 Slvs_Param aParam = myStorage->getParameter(aWPParams[i]);
403 aParam.val = aParIter->val;
404 myStorage->updateParameter(aParam);
407 return myWorkplaneID > 0;
410 // ============================================================================
411 // Function: resolveConstraints
412 // Class: SketchSolver_Group
413 // Purpose: solve the set of constraints for the current group
414 // ============================================================================
415 bool SketchSolver_Group::resolveConstraints()
417 bool aResolved = false;
418 if (myStorage->isNeedToResolve() && !isEmpty()) {
419 myConstrSolver.setGroupID(myID);
420 myStorage->initializeSolver(myConstrSolver);
422 int aResult = SLVS_RESULT_OKAY;
424 if (myStorage->hasDuplicatedConstraint())
425 aResult = SLVS_RESULT_INCONSISTENT;
427 // To avoid overconstraint situation, we will remove temporary constraints one-by-one
428 // and try to find the case without overconstraint
429 int aNbTemp = myStorage->numberTemporary();
431 aResult = myConstrSolver.solve();
432 if (aResult == SLVS_RESULT_OKAY || aNbTemp <= 0)
434 aNbTemp = myStorage->deleteTemporaryConstraint();
435 myStorage->initializeSolver(myConstrSolver);
439 Events_Error::send(SketchSolver_Error::SOLVESPACE_CRASH(), this);
442 if (aResult == SLVS_RESULT_OKAY) { // solution succeeded, store results into correspondent attributes
443 myFeatureStorage->blockEvents(true);
444 ConstraintConstraintMap::iterator aConstrIter = myConstraints.begin();
445 for (; aConstrIter != myConstraints.end(); aConstrIter++)
446 aConstrIter->second->refresh();
447 myFeatureStorage->blockEvents(false);
448 } else if (!myConstraints.empty())
449 Events_Error::send(SketchSolver_Error::CONSTRAINTS(), this);
453 removeTemporaryConstraints();
454 myStorage->setNeedToResolve(false);
458 // ============================================================================
459 // Function: mergeGroups
460 // Class: SketchSolver_Group
461 // Purpose: append specified group to the current group
462 // ============================================================================
463 void SketchSolver_Group::mergeGroups(const SketchSolver_Group& theGroup)
465 // If specified group is empty, no need to merge
466 if (theGroup.isEmpty())
468 if (!myFeatureStorage)
469 myFeatureStorage = FeatureStoragePtr(new SketchSolver_FeatureStorage);
471 std::vector<ConstraintPtr> aComplexConstraints;
472 ConstraintConstraintMap::const_iterator aConstrIter = theGroup.myConstraints.begin();
473 // append simple constraints
474 for (; aConstrIter != theGroup.myConstraints.end(); aConstrIter++)
475 if (isComplexConstraint(aConstrIter->first))
476 aComplexConstraints.push_back(aConstrIter->first);
478 changeConstraint(aConstrIter->first);
479 // append complex constraints
480 std::vector<ConstraintPtr>::iterator aComplexIter = aComplexConstraints.begin();
481 for (; aComplexIter != aComplexConstraints.end(); aComplexIter++)
482 changeConstraint(*aComplexIter);
485 // ============================================================================
486 // Function: splitGroup
487 // Class: SketchSolver_Group
488 // Purpose: divide the group into several subgroups
489 // ============================================================================
490 void SketchSolver_Group::splitGroup(std::vector<SketchSolver_Group*>& theCuts)
492 // Obtain constraints, which should be separated
493 FeatureStoragePtr aNewFeatStorage(new SketchSolver_FeatureStorage);
494 std::vector<ConstraintPtr> anUnusedConstraints;
495 ConstraintConstraintMap::iterator aCIter = myConstraints.begin();
496 for ( ; aCIter != myConstraints.end(); aCIter++) {
497 std::list<ConstraintPtr> aBaseConstraints = aCIter->second->constraints();
498 std::list<ConstraintPtr>::iterator anIter = aBaseConstraints.begin();
499 for (; anIter != aBaseConstraints.end(); anIter++)
500 if (aNewFeatStorage->isInteract(*anIter)) {
501 aNewFeatStorage->changeConstraint(*anIter);
503 anUnusedConstraints.push_back(*anIter);
506 // Check the unused constraints once again, because they may become interacted with new storage since adding constraints
507 std::vector<ConstraintPtr>::iterator aUnuseIt = anUnusedConstraints.begin();
508 while (aUnuseIt != anUnusedConstraints.end()) {
509 if (aNewFeatStorage->isInteract(*aUnuseIt)) {
510 size_t aShift = aUnuseIt - anUnusedConstraints.begin();
511 anUnusedConstraints.erase(aUnuseIt);
512 aUnuseIt = anUnusedConstraints.begin() + aShift;
518 std::vector<SketchSolver_Group*>::iterator aCutsIter;
519 aUnuseIt = anUnusedConstraints.begin();
520 for ( ; aUnuseIt != anUnusedConstraints.end(); aUnuseIt++) {
521 // Remove unused constraints
522 removeConstraint(*aUnuseIt);
523 // Try to append constraint to already existent group
524 for (aCutsIter = theCuts.begin(); aCutsIter != theCuts.end(); aCutsIter++)
525 if ((*aCutsIter)->isInteract(*aUnuseIt)) {
526 (*aCutsIter)->changeConstraint(*aUnuseIt);
529 if (aCutsIter == theCuts.end()) {
531 SketchSolver_Group* aGroup = new SketchSolver_Group(mySketch);
532 aGroup->changeConstraint(*aUnuseIt);
533 theCuts.push_back(aGroup);
538 // ============================================================================
539 // Function: isConsistent
540 // Class: SketchSolver_Group
541 // Purpose: search removed entities and constraints
542 // ============================================================================
543 bool SketchSolver_Group::isConsistent()
545 if (!myFeatureStorage) // no one constraint is initialized yet
548 bool aResult = myFeatureStorage->isConsistent();
550 // remove invalid entities
551 ConstraintConstraintMap::iterator aCIter = myConstraints.begin();
552 while (aCIter != myConstraints.end()) {
553 std::list<ConstraintPtr> aConstraints = aCIter->second->constraints();
554 std::list<ConstraintPtr>::iterator anIt = aConstraints.begin();
555 for (; anIt != aConstraints.end(); anIt++)
556 if (!(*anIt)->data() || !(*anIt)->data()->isValid())
557 if (aCIter->second->remove(*anIt)) {
558 // the constraint is fully removed, detach it from the list
559 ConstraintConstraintMap::iterator aTmpIt = aCIter++;
560 myFeatureStorage->removeConstraint(aTmpIt->first);
561 myConstraints.erase(aTmpIt);
564 if (anIt == aConstraints.end())
571 // ============================================================================
572 // Function: removeTemporaryConstraints
573 // Class: SketchSolver_Group
574 // Purpose: remove all transient SLVS_C_WHERE_DRAGGED constraints after
575 // resolving the set of constraints
576 // ============================================================================
577 void SketchSolver_Group::removeTemporaryConstraints()
579 myTempConstraints.clear();
580 while (myStorage->numberTemporary())
581 myStorage->deleteTemporaryConstraint();
582 // Clean lists of removed entities in the storage
583 std::set<Slvs_hParam> aRemPar;
584 std::set<Slvs_hEntity> aRemEnt;
585 std::set<Slvs_hConstraint> aRemCon;
586 myStorage->getRemoved(aRemPar, aRemEnt, aRemCon);
587 myStorage->setNeedToResolve(false);
590 // ============================================================================
591 // Function: removeConstraint
592 // Class: SketchSolver_Group
593 // Purpose: remove constraint and all unused entities
594 // ============================================================================
595 void SketchSolver_Group::removeConstraint(ConstraintPtr theConstraint)
597 myFeatureStorage->removeConstraint(theConstraint);
598 ConstraintConstraintMap::iterator aCIter = myConstraints.begin();
599 for (; aCIter != myConstraints.end(); aCIter++)
600 if (aCIter->second->hasConstraint(theConstraint)) {
601 if (!aCIter->second->remove(theConstraint)) // the constraint is not fully removed
602 aCIter = myConstraints.end();
605 if (aCIter != myConstraints.end())
606 myConstraints.erase(aCIter);
609 // ============================================================================
610 // Function: isComplexConstraint
611 // Class: SketchSolver_Group
612 // Purpose: verifies the constraint is complex, i.e. it needs another constraints to be created before
613 // ============================================================================
614 bool SketchSolver_Group::isComplexConstraint(FeaturePtr theConstraint)
616 return theConstraint->getKind() == SketchPlugin_ConstraintFillet::ID() ||
617 theConstraint->getKind() == SketchPlugin_ConstraintMirror::ID() ||
618 theConstraint->getKind() == SketchPlugin_ConstraintTangent::ID();
621 // ============================================================================
622 // Function: setTemporary
623 // Class: SketchSolver_Group
624 // Purpose: append given constraint to th group of temporary constraints
625 // ============================================================================
626 void SketchSolver_Group::setTemporary(SolverConstraintPtr theConstraint)
628 theConstraint->makeTemporary();
629 myTempConstraints.insert(theConstraint);