src/SketchSolver/SketchSolver_Manager.cpp

   1 // Copyright (C) 2014-2017  CEA/DEN, EDF R&D
   2 //
   3 // This library is free software; you can redistribute it and/or
   4 // modify it under the terms of the GNU Lesser General Public
   5 // License as published by the Free Software Foundation; either
   6 // version 2.1 of the License, or (at your option) any later version.
   7 //
   8 // This library is distributed in the hope that it will be useful,
   9 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  10 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  11 // Lesser General Public License for more details.
  12 //
  13 // You should have received a copy of the GNU Lesser General Public
  14 // License along with this library; if not, write to the Free Software
  15 // Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
  16 //
  17 // See http://www.salome-platform.org/ or
  18 // email : webmaster.salome@opencascade.com<mailto:webmaster.salome@opencascade.com>
  19 //
  20
  21 #include "SketchSolver_Manager.h"
  22 #include "SketchSolver_Error.h"
  23
  24 #include <Events_Loop.h>
  25 #include <GeomDataAPI_Point2D.h>
  26 #include <ModelAPI_Events.h>
  27 #include <ModelAPI_ResultConstruction.h>
  28 #include <ModelAPI_Session.h>
  29 #include <ModelAPI_Validator.h>
  30 #include <SketchPlugin_Sketch.h>
  31
  32 /// Global constraint manager object
  33 static SketchSolver_Manager* myManager = SketchSolver_Manager::instance();
  34
  35 /// \brief Verifies is the feature valid
  36 static bool isFeatureValid(FeaturePtr theFeature)
  37 {
  38   if (!theFeature || !theFeature->data() || !theFeature->data()->isValid())
  39     return false;
  40
  41   SessionPtr aMgr = ModelAPI_Session::get();
  42   ModelAPI_ValidatorsFactory* aFactory = aMgr->validators();
  43   return aFactory->validate(theFeature);
  44 }
  45
  46
  47
  48 // ========================================================
  49 // ========= SketchSolver_Manager ===============
  50 // ========================================================
  51 SketchSolver_Manager* SketchSolver_Manager::instance()
  52 {
  53   static SketchSolver_Manager* mySelf = 0; // Self pointer to implement singleton functionality
  54   if (!mySelf)
  55     mySelf = new SketchSolver_Manager();
  56   return mySelf;
  57 }
  58
  59 SketchSolver_Manager::SketchSolver_Manager()
  60 {
  61   myGroups.clear();
  62   myIsComputed = false;
  63
  64   // Register in event loop
  65   Events_Loop::loop()->registerListener(this, Events_Loop::eventByName(EVENT_OBJECT_CREATED));
  66   Events_Loop::loop()->registerListener(this, Events_Loop::eventByName(EVENT_OBJECT_UPDATED));
  67   Events_Loop::loop()->registerListener(this, Events_Loop::eventByName(EVENT_OBJECT_DELETED));
  68   Events_Loop::loop()->registerListener(this, Events_Loop::eventByName(EVENT_OBJECT_MOVED));
  69
  70   ////Events_Loop::loop()->registerListener(this, Events_Loop::eventByName(EVENT_SOLVER_FAILED));
  71   ////Events_Loop::loop()->registerListener(this, Events_Loop::eventByName(EVENT_SOLVER_REPAIRED));
  72   Events_Loop::loop()->registerListener(this, Events_Loop::eventByName(EVENT_SKETCH_PREPARED));
  73 }
  74
  75 SketchSolver_Manager::~SketchSolver_Manager()
  76 {
  77   myGroups.clear();
  78 }
  79
  80 bool SketchSolver_Manager::groupMessages()
  81 {
  82   return true;
  83 }
  84
  85 // ============================================================================
  86 //  Function: processEvent
  87 //  Purpose:  listen the event loop and process the message
  88 // ============================================================================
  89 void SketchSolver_Manager::processEvent(
  90   const std::shared_ptr<Events_Message>& theMessage)
  91 {
  92   bool needToResolve = false;
  93   bool isUpdateFlushed = false;
  94   bool isMovedEvt = false;
  95
  96   static const Events_ID aCreatedEvent = Events_Loop::eventByName(EVENT_OBJECT_CREATED);
  97   static const Events_ID anUpdateEvent = Events_Loop::eventByName(EVENT_OBJECT_UPDATED);
  98   static const Events_ID aSketchPreparedEvent = Events_Loop::eventByName(EVENT_SKETCH_PREPARED);
  99   // sketch is prepared for resolve: all the needed events
 100   // are collected and must be processed by the solver
 101   if (theMessage->eventID() == aSketchPreparedEvent) {
 102     flushGrouped(anUpdateEvent);
 103     needToResolve = true;
 104   }
 105
 106   if (myIsComputed)
 107     return;
 108   myIsComputed = true;
 109
 110   if (theMessage->eventID() == aCreatedEvent || theMessage->eventID() == anUpdateEvent) {
 111     std::shared_ptr<ModelAPI_ObjectUpdatedMessage> anUpdateMsg =
 112         std::dynamic_pointer_cast<ModelAPI_ObjectUpdatedMessage>(theMessage);
 113
 114     isUpdateFlushed = stopSendUpdate();
 115
 116     // update sketch features only
 117     const std::set<ObjectPtr>& aFeatures = anUpdateMsg->objects();
 118     // try to keep order as features were created if there are several created features: #2229
 119     if (theMessage->eventID() == aCreatedEvent && aFeatures.size() > 1) {
 120       std::map<int, std::shared_ptr<SketchPlugin_Feature>> anOrderedFeatures;
 121       std::set<ObjectPtr>::iterator aFeatIter;
 122       for (aFeatIter = aFeatures.begin(); aFeatIter != aFeatures.end(); aFeatIter++) {
 123         std::shared_ptr<SketchPlugin_Feature> aFeature =
 124             std::dynamic_pointer_cast<SketchPlugin_Feature>(*aFeatIter);
 125         if (aFeature && !aFeature->isMacro() && aFeature->data() && aFeature->data()->isValid()) {
 126           anOrderedFeatures[aFeature->data()->featureId()] = aFeature;
 127         }
 128       }
 129       std::map<int, std::shared_ptr<SketchPlugin_Feature>>::iterator aFeat;
 130       for(aFeat = anOrderedFeatures.begin(); aFeat != anOrderedFeatures.end(); aFeat++) {
 131         updateFeature(aFeat->second);
 132       }
 133     } else { // order is not important
 134       std::set<ObjectPtr>::iterator aFeatIter;
 135       for (aFeatIter = aFeatures.begin(); aFeatIter != aFeatures.end(); aFeatIter++) {
 136         std::shared_ptr<SketchPlugin_Feature> aFeature =
 137             std::dynamic_pointer_cast<SketchPlugin_Feature>(*aFeatIter);
 138         if (aFeature && !aFeature->isMacro())
 139           updateFeature(aFeature);
 140       }
 141     }
 142
 143   } else if (theMessage->eventID() == Events_Loop::loop()->eventByName(EVENT_OBJECT_MOVED)) {
 144     std::shared_ptr<ModelAPI_ObjectMovedMessage> aMoveMsg =
 145         std::dynamic_pointer_cast<ModelAPI_ObjectMovedMessage>(theMessage);
 146
 147     ObjectPtr aMovedObject = aMoveMsg->movedObject();
 148     std::shared_ptr<GeomDataAPI_Point2D> aMovedPoint =
 149         std::dynamic_pointer_cast<GeomDataAPI_Point2D>(aMoveMsg->movedAttribute());
 150
 151     const std::shared_ptr<GeomAPI_Pnt2d>& aFrom = aMoveMsg->originalPosition();
 152     const std::shared_ptr<GeomAPI_Pnt2d>& aTo = aMoveMsg->currentPosition();
 153
 154     if (aMovedObject) {
 155       FeaturePtr aMovedFeature = ModelAPI_Feature::feature(aMovedObject);
 156       std::shared_ptr<SketchPlugin_Feature> aSketchFeature =
 157           std::dynamic_pointer_cast<SketchPlugin_Feature>(aMovedFeature);
 158       if (aSketchFeature && !aSketchFeature->isMacro())
 159         needToResolve = moveFeature(aSketchFeature, aFrom, aTo);
 160     } else if (aMovedPoint)
 161       needToResolve = moveAttribute(aMovedPoint, aFrom, aTo);
 162
 163   } else if (theMessage->eventID() == Events_Loop::loop()->eventByName(EVENT_OBJECT_DELETED)) {
 164     std::shared_ptr<ModelAPI_ObjectDeletedMessage> aDeleteMsg =
 165       std::dynamic_pointer_cast<ModelAPI_ObjectDeletedMessage>(theMessage);
 166     const std::set<std::string>& aFeatureGroups = aDeleteMsg->groups();
 167
 168     // Find SketchPlugin_Sketch::ID() in groups.
 169     // The constraint groups should be updated when an object removed from Sketch
 170     std::set<std::string>::const_iterator aFGrIter;
 171     for (aFGrIter = aFeatureGroups.begin(); aFGrIter != aFeatureGroups.end(); aFGrIter++)
 172       if (aFGrIter->compare(ModelAPI_ResultConstruction::group()) == 0 ||
 173           aFGrIter->compare(ModelAPI_Feature::group()) == 0)
 174         break;
 175
 176     if (aFGrIter != aFeatureGroups.end()) {
 177       std::list<SketchGroupPtr>::iterator aGroupIter = myGroups.begin();
 178       while (aGroupIter != myGroups.end()) {
 179         if (!(*aGroupIter)->isWorkplaneValid()) {  // the group should be removed
 180           std::list<SketchGroupPtr>::iterator aRemoveIt = aGroupIter++;
 181           myGroups.erase(aRemoveIt);
 182           continue;
 183         }
 184
 185         (*aGroupIter)->repairConsistency();
 186         ++aGroupIter;
 187       }
 188     }
 189     myIsComputed = false;
 190   }
 191
 192   // resolve constraints if needed
 193   bool needToUpdate = needToResolve && resolveConstraints();
 194   releaseFeaturesIfEventsBlocked();
 195
 196   // Features may be updated => now send events, but for all changed at once
 197   if (isUpdateFlushed)
 198     allowSendUpdate();
 199
 200   myIsComputed = false;
 201
 202   // send update for movement in any case
 203   if (needToUpdate || isMovedEvt)
 204     Events_Loop::loop()->flush(anUpdateEvent);
 205 }
 206
 207 // ============================================================================
 208 //  Function: updateFeature
 209 //  Purpose:  create/update constraint or feature in appropriate group
 210 // ============================================================================
 211 bool SketchSolver_Manager::updateFeature(const std::shared_ptr<SketchPlugin_Feature>& theFeature)
 212 {
 213   // Check feature validity and find a group to place it.
 214   // If the feature is not valid, the returned group will be empty.
 215   // This will protect to deal with wrong (not fully initialized) features.
 216   SketchGroupPtr aGroup = findGroup(theFeature);
 217   if (!aGroup)
 218     return false;
 219   aGroup->blockEvents(true);
 220
 221   std::shared_ptr<SketchPlugin_Constraint> aConstraint =
 222       std::dynamic_pointer_cast<SketchPlugin_Constraint>(theFeature);
 223
 224   bool isOk = false;
 225   if (aConstraint)
 226     isOk = aGroup->changeConstraint(aConstraint);
 227   else
 228     isOk = aGroup->updateFeature(theFeature);
 229   return isOk;
 230 }
 231
 232 // ============================================================================
 233 //  Function: moveFeature
 234 //  Purpose:  move given feature in appropriate group
 235 // ============================================================================
 236 bool SketchSolver_Manager::moveFeature(
 237     const std::shared_ptr<SketchPlugin_Feature>& theMovedFeature,
 238     const std::shared_ptr<GeomAPI_Pnt2d>& theFrom,
 239     const std::shared_ptr<GeomAPI_Pnt2d>& theTo)
 240 {
 241   SketchGroupPtr aGroup = findGroup(theMovedFeature);
 242   if (!aGroup)
 243     return false;
 244
 245   std::shared_ptr<SketchPlugin_Constraint> aConstraint =
 246       std::dynamic_pointer_cast<SketchPlugin_Constraint>(theMovedFeature);
 247   if (aConstraint)
 248   {
 249     std::shared_ptr<GeomDataAPI_Point2D> aPntAttr = std::dynamic_pointer_cast<GeomDataAPI_Point2D>
 250       (aConstraint->attribute(SketchPlugin_Constraint::FLYOUT_VALUE_PNT()));
 251     if (aPntAttr)
 252     {
 253       aPntAttr->setValue(theTo);
 254       Events_Loop::loop()->flush(Events_Loop::eventByName(EVENT_OBJECT_UPDATED));
 255     }
 256     return true;
 257   }
 258
 259   aGroup->blockEvents(true);
 260   return aGroup->moveFeature(theMovedFeature, theFrom, theTo);
 261 }
 262
 263 // ============================================================================
 264 //  Function: moveAttribute
 265 //  Purpose:  move given attribute in appropriate group
 266 // ============================================================================
 267 bool SketchSolver_Manager::moveAttribute(
 268     const std::shared_ptr<GeomDataAPI_Point2D>& theMovedAttribute,
 269     const std::shared_ptr<GeomAPI_Pnt2d>& theFrom,
 270     const std::shared_ptr<GeomAPI_Pnt2d>& theTo)
 271 {
 272   FeaturePtr anOwner = ModelAPI_Feature::feature(theMovedAttribute->owner());
 273   std::shared_ptr<SketchPlugin_Constraint> aConstraint =
 274       std::dynamic_pointer_cast<SketchPlugin_Constraint>(anOwner);
 275   if (aConstraint)
 276   {
 277     theMovedAttribute->setValue(theTo);
 278     Events_Loop::loop()->flush(Events_Loop::eventByName(EVENT_OBJECT_UPDATED));
 279     return true;
 280   }
 281
 282   std::shared_ptr<SketchPlugin_Feature> aSketchFeature =
 283       std::dynamic_pointer_cast<SketchPlugin_Feature>(anOwner);
 284   SketchGroupPtr aGroup;
 285   if (aSketchFeature)
 286     aGroup = findGroup(aSketchFeature);
 287   if (!aGroup) {
 288     theMovedAttribute->setValue(theTo);
 289     return false;
 290   }
 291
 292   aGroup->blockEvents(true);
 293   return aGroup->movePoint(theMovedAttribute, theFrom, theTo);
 294 }
 295
 296 // ============================================================================
 297 //  Function: findGroup
 298 //  Purpose:  search groups of entities interacting with given feature
 299 // ============================================================================
 300 SketchGroupPtr SketchSolver_Manager::findGroup(
 301     std::shared_ptr<SketchPlugin_Feature> theFeature)
 302 {
 303   if (!isFeatureValid(theFeature))
 304     return SketchGroupPtr(); // do not process wrong features
 305
 306   // Obtain sketch, containing the feature
 307   CompositeFeaturePtr aSketch;
 308   const std::set<AttributePtr>& aRefsList = theFeature->data()->refsToMe();
 309   std::set<AttributePtr>::const_iterator aRefIt = aRefsList.begin();
 310   for (; aRefIt != aRefsList.end(); ++aRefIt) {
 311     FeaturePtr anOwner = ModelAPI_Feature::feature((*aRefIt)->owner());
 312     if (anOwner && anOwner->getKind() == SketchPlugin_Sketch::ID()) {
 313       aSketch = std::dynamic_pointer_cast<ModelAPI_CompositeFeature>(anOwner);
 314       break;
 315     }
 316   }
 317
 318   if (!aSketch)
 319     return SketchGroupPtr(); // not a sketch's feature
 320
 321   std::list<SketchGroupPtr>::const_iterator aGroupIt;
 322   for (aGroupIt = myGroups.begin(); aGroupIt != myGroups.end(); ++aGroupIt)
 323     if ((*aGroupIt)->getWorkplane() == aSketch)
 324       return *aGroupIt;
 325
 326   // group for the sketch does not created yet
 327   SketchGroupPtr aNewGroup = SketchGroupPtr(new SketchSolver_Group(aSketch));
 328   myGroups.push_back(aNewGroup);
 329   return aNewGroup;
 330 }
 331
 332 // ============================================================================
 333 //  Function: resolveConstraints
 334 //  Purpose:  change entities according to available constraints
 335 // ============================================================================
 336 bool SketchSolver_Manager::resolveConstraints()
 337 {
 338   bool needToUpdate = false;
 339   std::list<SketchGroupPtr>::const_iterator aGroupIter = myGroups.begin();
 340   for (; aGroupIter != myGroups.end(); ++aGroupIter) {
 341     if ((*aGroupIter)->resolveConstraints())
 342       needToUpdate = true;
 343   }
 344   return needToUpdate;
 345 }
 346
 347 void SketchSolver_Manager::releaseFeaturesIfEventsBlocked() const
 348 {
 349   std::list<SketchGroupPtr>::const_iterator aGroupIter = myGroups.begin();
 350   for (; aGroupIter != myGroups.end(); ++aGroupIter)
 351     (*aGroupIter)->blockEvents(false);
 352 }
 353
 354 bool SketchSolver_Manager::stopSendUpdate() const
 355 {
 356 static const Events_ID anUpdateEvent = Events_Loop::eventByName(EVENT_OBJECT_UPDATED);
 357   // to avoid redisplay of each segment on update by solver one by one in the viewer
 358   bool isUpdateFlushed = Events_Loop::loop()->isFlushed(anUpdateEvent);
 359   if (isUpdateFlushed) {
 360     Events_Loop::loop()->setFlushed(anUpdateEvent, false);
 361   }
 362   return isUpdateFlushed;
 363 }
 364
 365 void SketchSolver_Manager::allowSendUpdate() const
 366 {
 367   Events_Loop::loop()->setFlushed(Events_Loop::eventByName(EVENT_OBJECT_UPDATED), true);
 368 }