lib/creaVtk/MeshManagerModel.cpp

   1 /*
   2 # ---------------------------------------------------------------------
   3 #
   4 # Copyright (c) CREATIS (Centre de Recherche en Acquisition et Traitement de l'Image
   5 #                        pour la Sante)
   6 # Authors : Eduardo Davila, Frederic Cervenansky, Claire Mouton
   7 # Previous Authors : Laurent Guigues, Jean-Pierre Roux
   8 # CreaTools website : www.creatis.insa-lyon.fr/site/fr/creatools_accueil
   9 #
  10 #  This software is governed by the CeCILL-B license under French law and
  11 #  abiding by the rules of distribution of free software. You can  use,
  12 #  modify and/ or redistribute the software under the terms of the CeCILL-B
  13 #  license as circulated by CEA, CNRS and INRIA at the following URL
  14 #  http://www.cecill.info/licences/Licence_CeCILL-B_V1-en.html
  15 #  or in the file LICENSE.txt.
  16 #
  17 #  As a counterpart to the access to the source code and  rights to copy,
  18 #  modify and redistribute granted by the license, users are provided only
  19 #  with a limited warranty  and the software's author,  the holder of the
  20 #  economic rights,  and the successive licensors  have only  limited
  21 #  liability.
  22 #
  23 #  The fact that you are presently reading this means that you have had
  24 #  knowledge of the CeCILL-B license and that you accept its terms.
  25 # ------------------------------------------------------------------------
  26 */
  27
  28 #include "MeshManagerModel.h"
  29
  30 //
  31 //HISTORY HANDLER
  32 //
  33 template <class T>
  34 HistoryHandler<T>::HistoryHandler(int maxElements)
  35 {
  36         this->maxElements = maxElements;
  37 }
  38 template <class T>
  39 HistoryHandler<T>::~HistoryHandler()
  40 {
  41         CleanHistory();
  42 }
  43
  44 template <class T>
  45 void HistoryHandler<T>::CleanHistory()
  46 {
  47         for (T* element : redoStack)
  48         {
  49                 delete element;
  50         }
  51         redoStack.clear();
  52         for (T* element : undoStack)
  53         {
  54                 delete element;
  55         }
  56         undoStack.clear();
  57 }
  58
  59 template <class T>
  60 T* HistoryHandler<T>::Undo(T* state)
  61 {
  62         if(state == NULL)
  63         {
  64                 return NULL;
  65         }
  66         if(!undoStack.empty())
  67         {
  68                 auto lastElem = undoStack.back();
  69                 undoStack.pop_back();
  70                 redoStack.push_back(state);
  71                 return lastElem;
  72         }else{
  73                 delete state;
  74         }
  75         return NULL;
  76 }
  77
  78 template <class T>
  79 T* HistoryHandler<T>::Redo(T* state)
  80 {
  81         if(state == NULL)
  82         {
  83                 return NULL;
  84         }
  85         if(!redoStack.empty())
  86         {
  87                 auto lastElem = redoStack.back();
  88                 redoStack.pop_back();
  89                 undoStack.push_back(state);
  90                 return lastElem;
  91         }else{
  92                 delete state;
  93                 return NULL;
  94         }
  95 }
  96
  97 /**
  98 * To be used with RedoKeepCurrent
  99 * Will always maintain the current state in the undo stack as the first element
 100 * Useful when states are saved after actions and the initial state is saved.
 101 */
 102 template <class T>
 103 T* HistoryHandler<T>::UndoKeepCurrent()
 104 {
 105         if(undoStack.size() > 1)
 106         {
 107                 auto lastElem = undoStack.back();
 108                 undoStack.pop_back();
 109                 redoStack.push_back(lastElem);
 110                 return undoStack.back();
 111         }else{
 112                 return NULL;
 113         }
 114 }
 115
 116 /**
 117 * To be used with UndoKeepCurrent
 118 * Will always maintain the current state in the undo stack as the first element
 119 * Useful when states are saved after actions and the initial state is saved.
 120 */
 121 template <class T>
 122 T* HistoryHandler<T>::RedoKeepCurrent()
 123 {
 124         if(!redoStack.empty())
 125         {
 126                 auto lastElem = redoStack.back();
 127                 redoStack.pop_back();
 128                 undoStack.push_back(lastElem);
 129                 return undoStack.back();
 130         }else{
 131                 return NULL;
 132         }
 133 }
 134
 135 template <class T>
 136 void HistoryHandler<T>::Save(T* state)
 137 {
 138         undoStack.push_back(state);
 139         if(undoStack.size() > maxElements)
 140         {
 141                 T* frontDel = undoStack.front();
 142                 undoStack.pop_front();
 143                 delete frontDel;
 144         }
 145         if(!redoStack.empty())
 146         {
 147                 for (T* element : redoStack)
 148                 {
 149                         delete element;
 150                 }
 151                 redoStack.clear();
 152         }
 153 }
 154
 155 template <class T>
 156 T* HistoryHandler<T>::GetPrevious()
 157 {
 158         if(!undoStack.empty())
 159         {
 160                 return undoStack.back();
 161         }
 162         return NULL;
 163 }
 164
 165 template <class T>
 166 T* HistoryHandler<T>::GetNext()
 167 {
 168         if(!redoStack.empty())
 169         {
 170                 return redoStack.back();
 171         }
 172         return NULL;
 173 }
 174
 175 template <class T>
 176 int HistoryHandler<T>::UndoSize()
 177 {
 178         return undoStack.size();
 179 }
 180
 181 template <class T>
 182 int HistoryHandler<T>::RedoSize()
 183 {
 184         return redoStack.size();
 185 }
 186
 187 ////////////////////
 188 /////////////////////// MESH MODEL
 189 ////////////////////
 190
 191 MeshModel::MeshModel(int id)
 192 {
 193         _meshBase = NULL;
 194     _meshTemp = NULL;
 195     _meshId = id;
 196     _name = "mesh-" + std::to_string(id);
 197 }
 198
 199 MeshModel::MeshModel(vtkPolyData* mesh, int id)
 200 {
 201         if(mesh != NULL)
 202         {
 203                 _meshBase = vtkPolyData::New();//mesh;
 204                 _meshBase->DeepCopy(mesh);
 205                 _meshTemp = vtkPolyData::New();
 206                 _meshTemp->DeepCopy(_meshBase);
 207                 _meshId = id;
 208         _name = "mesh-" + std::to_string(id);
 209         }
 210 }
 211
 212 MeshModel::MeshModel(MeshModel* meshModel)
 213 {
 214         _meshBase = NULL;
 215     _meshTemp = NULL;
 216         if(meshModel->GetMeshBase() != NULL)
 217         {
 218                 _meshBase = vtkPolyData::New();
 219                 _meshBase->DeepCopy(meshModel->GetMeshBase());
 220                 ResetMeshTemp_();
 221         }
 222         _meshId = meshModel->GetId();
 223         _name = "mesh-" + std::to_string(meshModel->GetId());
 224 }
 225
 226 MeshModel::~MeshModel()
 227 {
 228         if(_meshBase != NULL)
 229         {
 230                 _meshBase->Delete();
 231         }
 232         if(_meshTemp != NULL)
 233         {
 234                 _meshTemp->Delete();
 235         }
 236 }
 237
 238 void MeshModel::ResetMeshTemp_()
 239 {
 240     if (_meshBase!=NULL)
 241     {
 242         if (_meshTemp!=NULL)
 243         {
 244             _meshTemp->Delete();
 245         } // if
 246         _meshTemp = vtkPolyData::New();
 247         _meshTemp->DeepCopy(_meshBase);
 248     } else {
 249         if (_meshTemp!=NULL)
 250         {
 251             _meshTemp->Delete();
 252             _meshTemp = NULL;
 253         }
 254     }
 255 }
 256
 257 void MeshModel::SetMeshBase(vtkPolyData* mesh)
 258 {
 259     if (mesh!=NULL)
 260     {
 261         if(_meshBase != NULL)
 262         {
 263                 _meshBase->Delete();
 264         }
 265         _meshBase = vtkPolyData::New();
 266         _meshBase->DeepCopy(mesh);
 267         ResetMeshTemp_();
 268     } // if mesh
 269 }
 270
 271 void MeshModel::SetMeshMemoryMode(vtkPolyData* mesh)
 272 {
 273         if(_meshBase != NULL)
 274         {
 275                 _meshBase->Delete();
 276                 _meshBase = NULL;
 277         }
 278         if(mesh != NULL)
 279         {
 280                 _meshBase = vtkPolyData::New();
 281                 _meshBase->DeepCopy(mesh);
 282         }
 283 }
 284
 285 void MeshModel::ResetMeshTemp()
 286 {
 287     ResetMeshTemp_();
 288 }
 289
 290 void MeshModel::CopySetMeshBase(vtkPolyData* mesh)
 291 {
 292     if (mesh!=NULL)
 293     {
 294       vtkPolyData *newMesh = vtkPolyData::New();
 295       newMesh->DeepCopy( mesh );
 296       SetMeshBase(newMesh);
 297     } // if mesh
 298 }
 299
 300
 301 vtkPolyData* MeshModel::GetMeshBase()
 302 {
 303    return _meshBase;
 304 }
 305
 306 vtkPolyData* MeshModel::GetMeshTemp()
 307 {
 308    return _meshTemp;
 309 }
 310
 311 int MeshModel::GetId()
 312 {
 313         return _meshId;
 314 }
 315
 316 std::string MeshModel::GetName()
 317 {
 318         return _name;
 319 }
 320
 321 ////////////////////
 322 /////////////////////// MESH MANAGER
 323 ////////////////////
 324
 325 MeshManagerModel::MeshManagerModel()
 326 {
 327         currentMesh = 0;
 328         meshId = 0;
 329         history = new HistoryHandler<ManagerState>(15);
 330         lastModified = 0;
 331         memoryMode = false;
 332 }
 333
 334 MeshManagerModel::~MeshManagerModel()
 335 {
 336         DeleteAll();
 337         history->CleanHistory();
 338         delete history;
 339 }
 340
 341 void MeshManagerModel::RefreshOutputs(bool signalBox) // virtual
 342 {
 343 }
 344
 345 void MeshManagerModel::SetHistory(int maxCapacity)
 346 {
 347         if(history != NULL){
 348                 ResetHistory();
 349                 delete history;
 350         }
 351         history = new HistoryHandler<ManagerState>(maxCapacity);
 352 }
 353
 354 void MeshManagerModel::ResetHistory()
 355 {
 356         history->CleanHistory();
 357 }
 358
 359 int MeshManagerModel::GetNumberOfMeshes()
 360 {
 361         return _meshes.size();
 362 }
 363
 364 void MeshManagerModel::AddMesh_(vtkPolyData* mesh)
 365 {
 366         if(mesh != NULL)
 367         {
 368                 _meshes.push_back(std::make_shared<MeshModel>(mesh, meshId));
 369                 meshId++;
 370         }else{
 371                 printf("PG MeshManagerModel::AddMesh Mesh is null \n");
 372         }
 373 }
 374
 375 void MeshManagerModel::AddMesh(vtkPolyData* mesh)
 376 {
 377         Save();
 378         AddMesh_(mesh);
 379         lastModified = currentMesh;
 380         RefreshOutputs(true);
 381 }
 382
 383 void MeshManagerModel::AddMeshes_(std::vector<vtkPolyData*> meshList)
 384 {
 385         if(!meshList.empty())
 386         {
 387                 MeshModel *meshModel;
 388                 for(int i = 0; i < meshList.size(); i++){
 389                         _meshes.push_back(std::make_shared<MeshModel>(meshList[i], meshId));
 390                         meshId++;
 391                 }
 392         }else{
 393                 printf("PG MeshManagerModel::AddMeshes Empty list of meshes \n");
 394         }
 395 }
 396
 397 void MeshManagerModel::AddMeshes(std::vector<vtkPolyData*> meshList)
 398 {
 399         Save();
 400         AddMeshes_(meshList);
 401         lastModified = currentMesh;
 402         RefreshOutputs(true);
 403 }
 404
 405 void MeshManagerModel::AddEmptyMesh_()
 406 {
 407         _meshes.push_back(std::make_shared<MeshModel>(meshId));
 408         meshId++;
 409 }
 410
 411 void MeshManagerModel::AddEmptyMesh()
 412 {
 413         Save();
 414         AddEmptyMesh_();
 415         lastModified = currentMesh;
 416         RefreshOutputs(true);
 417 }
 418
 419 void MeshManagerModel::InsertMeshesAtCurrent_(std::vector<vtkPolyData*> meshList)
 420 {
 421         if(!meshList.empty())
 422         {
 423                 std::vector<std::shared_ptr<MeshModel>> tmpVect;
 424                 MeshModel *meshModel;
 425                 for(int i = 0; i < meshList.size(); i++){
 426                         tmpVect.push_back(std::make_shared<MeshModel>(meshList[i], meshId));
 427                         meshId++;
 428                 }
 429                 _meshes.insert(_meshes.begin() + currentMesh, tmpVect.begin(), tmpVect.end());
 430         }else{
 431                 printf("PG MeshManagerModel::InsertMeshesAtCurrent Empty list of meshes \n");
 432         }
 433 }
 434
 435 void MeshManagerModel::InsertMeshesAtCurrent(std::vector<vtkPolyData*> meshList)
 436 {
 437         Save();
 438         InsertMeshesAtCurrent_(meshList);
 439         lastModified = currentMesh;
 440         RefreshOutputs(true);
 441 }
 442
 443 void MeshManagerModel::SelectMesh(int i)
 444 {
 445         if(i >= 0 && i < _meshes.size())
 446         {
 447                 int prevCurrent = currentMesh;
 448                 currentMesh = i;
 449                 if(prevCurrent != i)
 450                 {
 451                         RefreshOutputs(true);
 452                 }
 453         }
 454         else{
 455                 printf("PG MeshManagerModel::SelectMesh index out of bounds \n");
 456         }
 457 }
 458
 459 void MeshManagerModel::SelectMeshByName(std::string meshName)
 460 {
 461         if(!_meshes.empty())
 462         {
 463                 bool found = false;
 464                 for(int i = 0; i < _meshes.size() && !found; i++){
 465                         if(_meshes.at(i)->GetName() == meshName)
 466                         {
 467                                 found = true;
 468                                 SelectMesh(i);
 469                         }
 470                 }
 471         }
 472 }
 473
 474 void MeshManagerModel::DeleteMesh_(int position)
 475 {
 476         if(position >= 0 && position < _meshes.size())
 477         {
 478                 _meshes.erase(_meshes.begin() + position);
 479                 currentMesh = currentMesh + (position <= currentMesh?-1:0);
 480                 if(currentMesh < 0)
 481                 {
 482                         currentMesh = 0;
 483                 }
 484         }
 485 }
 486
 487 void MeshManagerModel::DeleteMesh(int position)
 488 {
 489         Save();
 490         DeleteMesh_(position);
 491         lastModified = currentMesh;
 492         RefreshOutputs(true);
 493 }
 494
 495 void MeshManagerModel::DeleteMeshByName(std::string meshName)
 496 {
 497         if(!_meshes.empty())
 498         {
 499                 bool found = false;
 500                 for(int i = 0; i < _meshes.size() && !found; i++){
 501                         if(_meshes.at(i)->GetName() == meshName)
 502                         {
 503                                 found = true;
 504                                 DeleteMesh_(i);
 505                                 RefreshOutputs(true);
 506                         }
 507                 }
 508         }
 509 }
 510
 511 void MeshManagerModel::DeleteCurrentMesh()
 512 {
 513         if(!_meshes.empty())
 514         {
 515                 Save();
 516                 DeleteMesh_(currentMesh);
 517                 lastModified = currentMesh;
 518                 RefreshOutputs(true);
 519         }
 520 }
 521
 522 void MeshManagerModel::ReplaceMesh(std::vector<vtkPolyData*> meshList)
 523 {
 524         Save();
 525         if(GetNumberOfMeshes() >= 1)
 526         {
 527                 DeleteMesh_(currentMesh);
 528         }
 529         InsertMeshesAtCurrent_(meshList);
 530         lastModified = currentMesh;
 531         RefreshOutputs(true);
 532 }
 533
 534 void MeshManagerModel::DeleteAll_()
 535 {
 536         if(!_meshes.empty())
 537         {
 538                 currentMesh = 0;
 539                 _meshes.clear();
 540                 RefreshOutputs(true);
 541         }
 542 }
 543
 544 void MeshManagerModel::DeleteAll()
 545 {
 546         Save();
 547         DeleteAll_();
 548         lastModified = currentMesh;
 549         RefreshOutputs(true);
 550 }
 551
 552 void MeshManagerModel::NextMesh()
 553 {
 554         currentMesh++;
 555         if(currentMesh >= _meshes.size())
 556         {
 557                 currentMesh = _meshes.size()-1;
 558         }
 559         RefreshOutputs(true);
 560 }
 561
 562 void MeshManagerModel::PreviousMesh()
 563 {
 564         currentMesh--;
 565         if(currentMesh < 0)
 566         {
 567                 currentMesh = 0;
 568         }
 569         RefreshOutputs(true);
 570 }
 571
 572 std::shared_ptr<MeshModel> MeshManagerModel::GetMeshModel()
 573 {
 574         return _meshes.at(currentMesh);
 575 }
 576
 577 vtkPolyData*  MeshManagerModel::GetMeshBase()
 578 {
 579         if(!_meshes.empty())
 580         {
 581                 return _meshes.at(currentMesh)->GetMeshBase();
 582         }
 583         else{
 584                 return NULL;
 585         }
 586 }
 587
 588 vtkPolyData*  MeshManagerModel::GetMeshTemp()
 589 {
 590         if(!_meshes.empty())
 591         {
 592                 return _meshes.at(currentMesh)->GetMeshTemp();
 593         }
 594         else{
 595                 return NULL;
 596         }
 597 }
 598
 599 void MeshManagerModel::SetMeshBase(vtkPolyData* mesh)
 600 {
 601     if(!_meshes.empty())
 602     {
 603         Save();
 604         _meshes.at(currentMesh) = std::make_shared<MeshModel>(_meshes.at(currentMesh).get());
 605         _meshes.at(currentMesh)->SetMeshBase(mesh);
 606         lastModified = currentMesh;
 607         RefreshOutputs(true);
 608     }else{
 609         printf("PG MeshManagerModel::SetMeshBase Mesh vector is empty \n");
 610     }
 611 }
 612
 613 void MeshManagerModel::MeshMemoryModeOn()
 614 {
 615         memoryMode = true;
 616 }
 617
 618 void MeshManagerModel::MeshMemoryModeOff()
 619 {
 620         memoryMode = false;
 621 }
 622
 623 void MeshManagerModel::SetMeshMemoryMode(vtkPolyData* mesh)
 624 {
 625         if(_meshes.size() > 1)
 626         {
 627                 DeleteAll_();
 628         }
 629         if(_meshes.size() == 0)
 630         {
 631                 AddEmptyMesh_();
 632         }
 633         _meshes.at(currentMesh)->SetMeshMemoryMode(mesh);
 634         ResetHistory();
 635         SaveMemoryMode();
 636         RefreshOutputs(true);
 637 }
 638
 639 void MeshManagerModel::ResetMeshTemp()
 640 {
 641         if(!_meshes.empty())
 642         {
 643         _meshes.at(currentMesh)->ResetMeshTemp();
 644         RefreshOutputs(true);
 645     }else{
 646         printf("PG MeshManagerModel::ResetMeshTemp Mesh vector is empty \n");
 647     }
 648 }
 649
 650 void MeshManagerModel::CopySetMeshBase(vtkPolyData* mesh)
 651 {
 652         if(!_meshes.empty())
 653         {
 654                 Save();
 655                 _meshes.at(currentMesh) = std::make_shared<MeshModel>(_meshes.at(currentMesh).get());
 656                 _meshes.at(currentMesh)->CopySetMeshBase(mesh);
 657                 lastModified = currentMesh;
 658                 RefreshOutputs(true);
 659         }
 660         else{
 661                 printf("PG MeshManagerModel::CopySetMeshBase Mesh vector is empty \n");
 662         }
 663 }
 664
 665 std::vector<std::string> MeshManagerModel::GetMeshNames()
 666 {
 667         std::vector<std::string> names;
 668         for(int i = 0; i < _meshes.size(); i++){
 669                 names.push_back(_meshes.at(i)->GetName());
 670         }
 671         return names;
 672 }
 673
 674 std::vector<vtkPolyData*> MeshManagerModel::GetAllPolyDatas()
 675 {
 676         std::vector<vtkPolyData*> polydatas;
 677         for(int i = 0; i < _meshes.size(); i++){
 678                 polydatas.push_back(_meshes.at(i)->GetMeshBase());
 679         }
 680         return polydatas;
 681 }
 682
 683 int MeshManagerModel::GetCurrentMesh()
 684 {
 685         return currentMesh;
 686 }
 687
 688 void MeshManagerModel::Undo()
 689 {
 690         if(history->UndoSize() > 0)
 691         {
 692                 if(memoryMode == false){
 693                         RestoreState(history->Undo(new ManagerState(_meshes, meshId, lastModified)));
 694                         RefreshOutputs(true);
 695                 }
 696                 else if(history->UndoSize() > 1){
 697                         RestoreStateMemoryMode(history->UndoKeepCurrent());
 698                 }
 699         }
 700 }
 701
 702 void MeshManagerModel::Redo()
 703 {
 704         if(history->RedoSize() > 0)
 705         {
 706                 if(memoryMode == false){
 707                         RestoreState(history->Redo(new ManagerState(_meshes, meshId, lastModified)));
 708                         RefreshOutputs(true);
 709                 }
 710                 else{
 711                         RestoreStateMemoryMode(history->RedoKeepCurrent());
 712                 }
 713         }
 714 }
 715
 716 void MeshManagerModel::Save()
 717 {
 718         history->Save(new ManagerState(_meshes, meshId, currentMesh));
 719 }
 720
 721 void MeshManagerModel::SaveMemoryMode()
 722 {
 723         if(_meshes.size() == 1 && memoryMode)
 724         {
 725                 std::vector<std::shared_ptr<MeshModel>> savedMesh;
 726                 savedMesh.push_back(std::make_shared<MeshModel>(_meshes.at(0).get()));
 727                 history->Save(new ManagerState(savedMesh, meshId, 0));
 728         }
 729         else{
 730                 printf("PG MeshManagerModel::SaveMemoryMode WARNING Mesh vector has invalid size or memoryMode is not set \n");
 731         }
 732 }
 733
 734 void MeshManagerModel::RestoreState(ManagerState* state)
 735 {
 736         if(state != NULL)
 737         {
 738                 _meshes = state->GetMeshes();
 739                 meshId = state->GetMeshId();
 740                 currentMesh = state->GetModifiedPos();
 741                 lastModified = state->GetModifiedPos();
 742                 delete state;
 743         }
 744         else{
 745                 printf("PG MeshManagerModel::RestoreState WARNING State is NULL \n");
 746         }
 747 }
 748
 749 void MeshManagerModel::RestoreStateMemoryMode(ManagerState* state){
 750         if(_meshes.size() == 1 && state != NULL)
 751         {
 752                 vtkPoints* statePoints = vtkPoints::New();
 753                 statePoints->DeepCopy(state->GetMeshes().at(0)->GetMeshBase()->GetPoints());
 754                 _meshes.at(0)->GetMeshBase()->SetPoints(statePoints);
 755                 _meshes.at(0)->GetMeshBase()->GetPoints()->Modified();
 756         _meshes.at(0)->GetMeshBase()->Modified();
 757         }else{
 758                 printf("PG MeshManagerModel::RestoreStateMemoryMode WARNING Mesh vector has invalid size or state is NULL\n");
 759         }
 760 }
 761
 762 //
 763 //Manager State
 764 //
 765 MeshManagerModel::ManagerState::ManagerState(std::vector<std::shared_ptr<MeshModel>> meshesToSave, int meshId, int modifiedPos)
 766 {
 767         savedMeshes = meshesToSave;
 768         savedId = meshId;
 769         savedModifiedPos = modifiedPos;
 770 }
 771
 772 MeshManagerModel::ManagerState::~ManagerState()
 773 {
 774         savedMeshes.clear();
 775 }
 776
 777 std::vector<std::shared_ptr<MeshModel>>& MeshManagerModel::ManagerState::GetMeshes()
 778 {
 779         return savedMeshes;
 780 }
 781
 782 int MeshManagerModel::ManagerState::GetMeshId()
 783 {
 784         return savedId;
 785 }
 786 int MeshManagerModel::ManagerState::GetModifiedPos()
 787 {
 788         return savedModifiedPos;
 789 }
 790