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 template <class T>
  31 HistoryHandler<T>::HistoryHandler(int maxElements)
  32 {
  33         this->maxElements = maxElements;
  34 }
  35 template <class T>
  36 HistoryHandler<T>::~HistoryHandler()
  37 {
  38         CleanHistory();
  39 }
  40
  41 template <class T>
  42 void HistoryHandler<T>::CleanHistory()
  43 {
  44         for (T* element : redoStack)
  45         {
  46                 delete element;
  47         }
  48         for (T* element : undoStack)
  49         {
  50                 delete element;
  51         }
  52 }
  53
  54 template <class T>
  55 T* HistoryHandler<T>::Undo()
  56 {
  57         if(!undoStack.empty() && undoStack.size()>1)
  58         {
  59                 auto lastElem = undoStack.back();
  60                 undoStack.pop_back();
  61                 redoStack.push_back(lastElem);
  62                 return undoStack.back();
  63         }
  64         return NULL;
  65 }
  66
  67 template <class T>
  68 T* HistoryHandler<T>::Redo()
  69 {
  70         if(!redoStack.empty())
  71         {
  72                 auto lastElem = redoStack.back();
  73                 redoStack.pop_back();
  74                 undoStack.push_back(lastElem);
  75                 return lastElem;
  76         }
  77         return NULL;
  78 }
  79
  80 template <class T>
  81 void HistoryHandler<T>::Save(T* state)
  82 {
  83         undoStack.push_back(state);
  84         if(!redoStack.empty())
  85         {
  86                 for (T* element : redoStack)
  87                 {
  88                         delete element;
  89                 }
  90                 redoStack.clear();
  91         }
  92 }
  93
  94 template <class T>
  95 int HistoryHandler<T>::UndoSize()
  96 {
  97         return undoStack.size();
  98 }
  99
 100 template <class T>
 101 int HistoryHandler<T>::RedoSize()
 102 {
 103         return redoStack.size();
 104 }
 105
 106 ////////////////////
 107 /////////////////////// MESH MODEL
 108 ////////////////////
 109
 110 MeshModel::MeshModel(int id)
 111 {
 112         _meshBase = NULL;
 113     _meshTemp = NULL;
 114     _meshId = id;
 115     _name = "mesh-" + std::to_string(id);
 116 }
 117
 118 MeshModel::MeshModel(vtkPolyData* mesh, int id)
 119 {
 120         if(mesh != NULL){
 121                 _meshBase = mesh;
 122                 _meshTemp = vtkPolyData::New();
 123                 _meshTemp->DeepCopy(_meshBase);
 124                 _meshId = id;
 125         _name = "mesh-" + std::to_string(id);
 126         }
 127 }
 128
 129 MeshModel::MeshModel(MeshModel* meshModel)
 130 {
 131         _meshBase = NULL;
 132     _meshTemp = NULL;
 133         if(meshModel->GetMeshBase() != NULL)
 134         {
 135                 _meshBase = vtkPolyData::New();
 136                 _meshBase->DeepCopy(meshModel->GetMeshBase());
 137                 ResetMeshTemp_();
 138         }
 139         _meshId = meshModel->GetId();
 140         _name = "mesh-" + std::to_string(meshModel->GetId());
 141 }
 142
 143 MeshModel::~MeshModel(){
 144         if(_meshBase != NULL){
 145                 _meshBase->Delete();
 146         }
 147         if(_meshTemp != NULL){
 148                 _meshTemp->Delete();
 149         }
 150 }
 151
 152 void MeshModel::ResetMeshTemp_()
 153 {
 154     if (_meshBase!=NULL)
 155     {
 156         if (_meshTemp!=NULL)
 157         {
 158             _meshTemp->Delete();
 159         } // if
 160         _meshTemp = vtkPolyData::New();
 161         _meshTemp->DeepCopy(_meshBase);
 162     } else {
 163         if (_meshTemp!=NULL)
 164         {
 165             _meshTemp->Delete();
 166             _meshTemp = NULL;
 167         }
 168     }
 169 }
 170
 171 void MeshModel::SetMeshBase(vtkPolyData* mesh)
 172 {
 173     if (mesh!=NULL)
 174     {
 175         if(_meshBase != NULL){
 176                 _meshBase->Delete();
 177         }
 178         _meshBase = mesh;
 179         ResetMeshTemp_();
 180     } // if mesh
 181 }
 182
 183 void MeshModel::SetMeshMemoryMode(vtkPolyData* mesh)
 184 {
 185         //if(_meshBase != NULL)
 186         //{
 187         //      _meshBase->Delete();
 188         //      _meshBase = NULL;
 189         //}
 190         //if (_meshTemp != NULL)
 191     //{
 192     //    _meshTemp->Delete();
 193     //    _meshTemp = NULL;
 194         //}
 195         _meshBase = mesh;
 196 }
 197
 198 void MeshModel::ResetMeshTemp()
 199 {
 200     ResetMeshTemp_();
 201 }
 202
 203 void MeshModel::CopySetMeshBase(vtkPolyData* mesh)
 204 {
 205     if (mesh!=NULL)
 206     {
 207       vtkPolyData *newMesh = vtkPolyData::New();
 208       newMesh->DeepCopy( mesh );
 209       SetMeshBase(newMesh);
 210     } // if mesh
 211 }
 212
 213
 214 vtkPolyData* MeshModel::GetMeshBase()
 215 {
 216    return _meshBase;
 217 }
 218
 219 vtkPolyData* MeshModel::GetMeshTemp()
 220 {
 221    return _meshTemp;
 222 }
 223
 224 int MeshModel::GetId()
 225 {
 226         return _meshId;
 227 }
 228
 229 std::string MeshModel::GetName()
 230 {
 231         return _name;
 232 }
 233
 234 ////////////////////
 235 /////////////////////// MESH MANAGER
 236 ////////////////////
 237
 238 MeshManagerModel::MeshManagerModel()
 239 {
 240         currentMesh = 0;
 241         meshId = 0;
 242         history = new HistoryHandler<ManagerState>(20);
 243 }
 244
 245 MeshManagerModel::~MeshManagerModel()
 246 {
 247         DeleteAll();
 248 }
 249
 250 void MeshManagerModel::RefreshOutputs(bool signalBox) // virtual
 251 {
 252 }
 253
 254 void MeshManagerModel::ResetHistory()
 255 {
 256         history->CleanHistory();
 257         Save();
 258 }
 259
 260 void MeshManagerModel::UpdateMeshReference(vtkPolyData* mesh)
 261 {
 262         _meshes.at(currentMesh)->SetMeshBase(mesh);
 263         RefreshOutputs(true);
 264 }
 265
 266 int MeshManagerModel::GetNumberOfMeshes()
 267 {
 268         return _meshes.size();
 269 }
 270
 271 void MeshManagerModel::AddMesh_(vtkPolyData* mesh)
 272 {
 273         if(mesh != NULL){
 274                 _meshes.push_back(std::make_shared<MeshModel>(mesh, meshId));
 275                 meshId++;
 276         }
 277         else{
 278                 printf("PG MeshManagerModel::AddMesh Mesh is null \n");
 279         }
 280 }
 281
 282 void MeshManagerModel::AddMesh(vtkPolyData* mesh)
 283 {
 284         AddMesh_(mesh);
 285         Save();
 286         RefreshOutputs(true);
 287 }
 288
 289 void MeshManagerModel::AddMeshes_(std::vector<vtkPolyData*> meshList)
 290 {
 291         if(!meshList.empty())
 292         {
 293                 MeshModel *meshModel;
 294                 for(int i = 0; i < meshList.size(); i++){
 295                         _meshes.push_back(std::make_shared<MeshModel>(meshList[i], meshId));
 296                         meshId++;
 297                 }
 298         }else{
 299                 printf("PG MeshManagerModel::AddMeshes Empty list of meshes \n");
 300         }
 301 }
 302
 303 void MeshManagerModel::AddMeshes(std::vector<vtkPolyData*> meshList)
 304 {
 305         AddMeshes_(meshList);
 306         Save();
 307         RefreshOutputs(true);
 308 }
 309
 310 void MeshManagerModel::AddEmptyMesh_()
 311 {
 312         _meshes.push_back(std::make_shared<MeshModel>(meshId));
 313         meshId++;
 314 }
 315
 316 void MeshManagerModel::AddEmptyMesh()
 317 {
 318         AddEmptyMesh_();
 319         Save();
 320         RefreshOutputs(true);
 321 }
 322
 323 void MeshManagerModel::InsertMeshesAtCurrent_(std::vector<vtkPolyData*> meshList)
 324 {
 325         if(!meshList.empty())
 326         {
 327                 std::vector<std::shared_ptr<MeshModel>> tmpVect;
 328                 MeshModel *meshModel;
 329                 for(int i = 0; i < meshList.size(); i++){
 330                         tmpVect.push_back(std::make_shared<MeshModel>(meshList[i], meshId));
 331                         meshId++;
 332                 }
 333                 _meshes.insert(_meshes.begin() + currentMesh, tmpVect.begin(), tmpVect.end());
 334         }else{
 335                 printf("PG MeshManagerModel::InsertMeshesAtCurrent Empty list of meshes \n");
 336         }
 337 }
 338
 339 void MeshManagerModel::InsertMeshesAtCurrent(std::vector<vtkPolyData*> meshList)
 340 {
 341         InsertMeshesAtCurrent_(meshList);
 342         Save();
 343         RefreshOutputs(true);
 344 }
 345
 346 void MeshManagerModel::SelectMesh(int i)
 347 {
 348         if(i >= 0 && i < _meshes.size()){
 349                 int prevCurrent = currentMesh;
 350                 currentMesh = i;
 351                 if(prevCurrent != i){
 352                         RefreshOutputs(true);
 353                 }
 354         }
 355         else{
 356                 printf("PG MeshManagerModel::SelectMesh index out of bounds \n");
 357         }
 358 }
 359
 360 void MeshManagerModel::SelectMeshByName(std::string meshName)
 361 {
 362         if(!_meshes.empty()){
 363                 bool found = false;
 364                 for(int i = 0; i < _meshes.size() && !found; i++){
 365                         if(_meshes.at(i)->GetName() == meshName){
 366                                 found = true;
 367                                 SelectMesh(i);
 368                         }
 369                 }
 370         }
 371 }
 372
 373 void MeshManagerModel::DeleteMesh_(int position)
 374 {
 375         if(position >= 0 && position < _meshes.size()){
 376                 _meshes.erase(_meshes.begin() + position);
 377                 currentMesh = currentMesh + (position <= currentMesh?-1:0);
 378                 if(currentMesh < 0){
 379                         currentMesh = 0;
 380                 }
 381         }
 382 }
 383
 384 void MeshManagerModel::DeleteMesh(int position)
 385 {
 386         DeleteMesh_(position);
 387         Save();
 388         RefreshOutputs(true);
 389 }
 390
 391 void MeshManagerModel::DeleteMeshByName(std::string meshName)
 392 {
 393         if(!_meshes.empty()){
 394                 bool found = false;
 395                 for(int i = 0; i < _meshes.size() && !found; i++){
 396                         if(_meshes.at(i)->GetName() == meshName){
 397                                 found = true;
 398                                 DeleteMesh_(i);
 399                                 RefreshOutputs(true);
 400                         }
 401                 }
 402         }
 403 }
 404
 405 void MeshManagerModel::DeleteCurrentMesh()
 406 {
 407         if(!_meshes.empty()){
 408                 DeleteMesh_(currentMesh);
 409                 Save();
 410                 RefreshOutputs(true);
 411         }
 412 }
 413
 414 void MeshManagerModel::ReplaceMesh(std::vector<vtkPolyData*> meshList)
 415 {
 416         if(GetNumberOfMeshes() >= 1)
 417         {
 418                 DeleteMesh_(currentMesh);
 419         }
 420         InsertMeshesAtCurrent_(meshList);
 421         Save();
 422         RefreshOutputs(true);
 423 }
 424
 425 void MeshManagerModel::DeleteAll_()
 426 {
 427         if(!_meshes.empty())
 428         {
 429                 currentMesh = 0;
 430                 _meshes.clear();
 431                 RefreshOutputs(true);
 432         }
 433 }
 434
 435 void MeshManagerModel::DeleteAll()
 436 {
 437         DeleteAll_();
 438         Save();
 439         RefreshOutputs(true);
 440 }
 441
 442 void MeshManagerModel::NextMesh()
 443 {
 444         currentMesh++;
 445         if(currentMesh >= _meshes.size()){
 446                 currentMesh = _meshes.size()-1;
 447         }
 448         RefreshOutputs(true);
 449 }
 450
 451 void MeshManagerModel::PreviousMesh()
 452 {
 453         currentMesh--;
 454         if(currentMesh < 0){
 455                 currentMesh = 0;
 456         }
 457         RefreshOutputs(true);
 458 }
 459
 460 std::shared_ptr<MeshModel> MeshManagerModel::GetMeshModel()
 461 {
 462         return _meshes.at(currentMesh);
 463 }
 464
 465 vtkPolyData*  MeshManagerModel::GetMeshBase()
 466 {
 467         if(!_meshes.empty()){
 468                 return _meshes.at(currentMesh)->GetMeshBase();
 469         }
 470         else{
 471                 return NULL;
 472         }
 473 }
 474
 475 vtkPolyData*  MeshManagerModel::GetMeshTemp()
 476 {
 477         if(!_meshes.empty()){
 478                 return _meshes.at(currentMesh)->GetMeshTemp();
 479         }
 480         else{
 481                 return NULL;
 482         }
 483 }
 484
 485 void MeshManagerModel::SetMeshBase(vtkPolyData* mesh)
 486 {
 487     if(!_meshes.empty()){
 488         _meshes.at(currentMesh) = std::make_shared<MeshModel>(_meshes.at(currentMesh).get());
 489         _meshes.at(currentMesh)->SetMeshBase(mesh);
 490         Save();
 491         RefreshOutputs(true);
 492     }else{
 493         printf("PG MeshManagerModel::SetMeshBase Mesh vector is empty \n");
 494     }
 495 }
 496
 497 void MeshManagerModel::SetMeshMemoryMode(vtkPolyData* mesh)
 498 {
 499         if(_meshes.size() > 1)
 500         {
 501                 DeleteAll_();
 502         }
 503         if(_meshes.size() == 0)
 504         {
 505                 AddEmptyMesh_();
 506         }
 507         _meshes.at(currentMesh)->SetMeshMemoryMode(mesh);
 508         RefreshOutputs(true);
 509 }
 510
 511 void MeshManagerModel::ResetMeshTemp()
 512 {
 513         if(!_meshes.empty())
 514         {
 515         _meshes.at(currentMesh)->ResetMeshTemp();
 516         RefreshOutputs(true);
 517     }else{
 518         printf("PG MeshManagerModel::ResetMeshTemp Mesh vector is empty \n");
 519     }
 520 }
 521
 522 void MeshManagerModel::CopySetMeshBase(vtkPolyData* mesh)
 523 {
 524         if(!_meshes.empty())
 525         {
 526                 _meshes.at(currentMesh) = std::make_shared<MeshModel>(_meshes.at(currentMesh).get());
 527                 _meshes.at(currentMesh)->CopySetMeshBase(mesh);
 528                 Save();
 529                 RefreshOutputs(true);
 530         }
 531         else{
 532                 printf("PG MeshManagerModel::CopySetMeshBase Mesh vector is empty \n");
 533         }
 534 }
 535
 536 std::vector<std::string> MeshManagerModel::GetMeshNames()
 537 {
 538         std::vector<std::string> names;
 539         for(int i = 0; i < _meshes.size(); i++){
 540                 names.push_back(_meshes.at(i)->GetName());
 541         }
 542         return names;
 543 }
 544
 545 void MeshManagerModel::Undo()
 546 {
 547         RestoreState(history->Undo());
 548         RefreshOutputs(true);
 549 }
 550
 551 void MeshManagerModel::Redo()
 552 {
 553         RestoreState(history->Redo());
 554         RefreshOutputs(true);
 555 }
 556
 557 void MeshManagerModel::Save()
 558 {
 559         history->Save(new ManagerState(_meshes, meshId, currentMesh));
 560 }
 561
 562 void MeshManagerModel::RestoreState(ManagerState* state)
 563 {
 564         if(state != NULL)
 565         {
 566                 _meshes = state->GetMeshes();
 567                 meshId = state->GetMeshId();
 568                 currentMesh = state->GetCurrentMesh();
 569         }
 570 }
 571
 572 //
 573 //Manager State
 574 //
 575 MeshManagerModel::ManagerState::ManagerState(std::vector<std::shared_ptr<MeshModel>> meshesToSave, int meshId, int currentMesh)
 576 {
 577         savedMeshes = meshesToSave;
 578         savedId = meshId;
 579         savedCurrentMesh = currentMesh;
 580 }
 581
 582 MeshManagerModel::ManagerState::~ManagerState()
 583 {
 584 }
 585
 586 std::vector<std::shared_ptr<MeshModel>>& MeshManagerModel::ManagerState::GetMeshes()
 587 {
 588         return savedMeshes;
 589 }
 590
 591 int MeshManagerModel::ManagerState::GetMeshId()
 592 {
 593         return savedId;
 594 }
 595 int MeshManagerModel::ManagerState::GetCurrentMesh()
 596 {
 597         return savedCurrentMesh;
 598 }
 599