#3526 Active option in HausdorffDistancePointSetFilter box

[creaVtk.git] / lib / creaVtk / MeshManagerModel.cpp

diff --git a/lib/creaVtk/MeshManagerModel.cpp b/lib/creaVtk/MeshManagerModel.cpp
index 41b97706d227b76b8a5c27aec1e8f406befcdcd4..84713441479ad9dbe9fcfade3da2982d05596f8d 100644 (file)
--- a/lib/creaVtk/MeshManagerModel.cpp
+++ b/lib/creaVtk/MeshManagerModel.cpp
@@ -48,21 +48,27 @@ void HistoryHandler<T>::CleanHistory()
        {
                delete element;
        }
+       redoStack.clear();
        for (T* element : undoStack)
        {
                delete element;
        }
+       undoStack.clear();
 }
 
 template <class T>
 T* HistoryHandler<T>::Undo(T* state)
 {
+       if(state == NULL)
+       {
+               return NULL;
+       }
        if(!undoStack.empty())
        {
                auto lastElem = undoStack.back();
                undoStack.pop_back();
                redoStack.push_back(state);
-               return lastElem;//undoStack.back();
+               return lastElem;
        }else{
                delete state;
        }
@@ -72,6 +78,10 @@ T* HistoryHandler<T>::Undo(T* state)
 template <class T>
 T* HistoryHandler<T>::Redo(T* state)
 {
+       if(state == NULL)
+       {
+               return NULL;
+       }
        if(!redoStack.empty())
        {
                auto lastElem = redoStack.back();
@@ -80,8 +90,46 @@ T* HistoryHandler<T>::Redo(T* state)
                return lastElem;
        }else{
                delete state;
+               return NULL;
+       }
+}
+
+/**
+* To be used with RedoKeepCurrent
+* Will always maintain the current state in the undo stack as the first element
+* Useful when states are saved after actions and the initial state is saved.
+*/
+template <class T>
+T* HistoryHandler<T>::UndoKeepCurrent()
+{
+       if(undoStack.size() > 1)
+       {
+               auto lastElem = undoStack.back();
+               undoStack.pop_back();
+               redoStack.push_back(lastElem);
+               return undoStack.back();
+       }else{
+               return NULL;
+       }
+}
+
+/**
+* To be used with UndoKeepCurrent
+* Will always maintain the current state in the undo stack as the first element
+* Useful when states are saved after actions and the initial state is saved.
+*/
+template <class T>
+T* HistoryHandler<T>::RedoKeepCurrent()
+{
+       if(!redoStack.empty())
+       {
+               auto lastElem = redoStack.back();
+               redoStack.pop_back();
+               undoStack.push_back(lastElem);
+               return undoStack.back();
+       }else{
+               return NULL;
        }
-       return NULL;
 }
 
 template <class T>
@@ -90,8 +138,9 @@ void HistoryHandler<T>::Save(T* state)
        undoStack.push_back(state);
        if(undoStack.size() > maxElements)
        {
-               delete undoStack.front();
+               T* frontDel = undoStack.front();
                undoStack.pop_front();
+               delete frontDel;
        }
        if(!redoStack.empty())
        {
@@ -151,7 +200,7 @@ MeshModel::MeshModel(vtkPolyData* mesh, int id)
 {
        if(mesh != NULL)
        {
-               _meshBase = vtkPolyData::New();//mesh;
+               _meshBase = vtkPolyData::New();
                _meshBase->DeepCopy(mesh);
                _meshTemp = vtkPolyData::New();
                _meshTemp->DeepCopy(_meshBase);
@@ -279,21 +328,54 @@ MeshManagerModel::MeshManagerModel()
        meshId = 0;
        history = new HistoryHandler<ManagerState>(15);
        lastModified = 0;
+       memoryMode = false;
+       referencePoint = {0, 0, 0};
+       referenceNormal = {0, 0, 1};
 }
 
 MeshManagerModel::~MeshManagerModel()
 {
        DeleteAll();
+       history->CleanHistory();
+       delete history;
 }
 
 void MeshManagerModel::RefreshOutputs(bool signalBox) // virtual
 {
 }
 
+void MeshManagerModel::SetHistory(int maxCapacity)
+{
+       if(history != NULL){    
+               ResetHistory();
+               delete history;
+       }
+       history = new HistoryHandler<ManagerState>(maxCapacity);
+}
+
 void MeshManagerModel::ResetHistory()
 {
        history->CleanHistory();
-       //Save();
+}
+
+void MeshManagerModel::SetReferencePoint(std::vector<double> point)
+{
+       referencePoint = point;
+}
+
+std::vector<double> MeshManagerModel::GetReferencePoint()
+{
+       return referencePoint;
+}
+
+void MeshManagerModel::SetReferenceNormal(std::vector<double> normal)
+{
+       referenceNormal = normal;
+}
+
+std::vector<double> MeshManagerModel::GetReferenceNormal()
+{
+       return referenceNormal;
 }
 
 int MeshManagerModel::GetNumberOfMeshes()
@@ -550,6 +632,16 @@ void MeshManagerModel::SetMeshBase(vtkPolyData* mesh)
     }
 }
 
+void MeshManagerModel::MeshMemoryModeOn()
+{
+       memoryMode = true;
+}
+
+void MeshManagerModel::MeshMemoryModeOff()
+{
+       memoryMode = false;
+}
+
 void MeshManagerModel::SetMeshMemoryMode(vtkPolyData* mesh)
 {
        if(_meshes.size() > 1)
@@ -561,6 +653,8 @@ void MeshManagerModel::SetMeshMemoryMode(vtkPolyData* mesh)
                AddEmptyMesh_();
        }
        _meshes.at(currentMesh)->SetMeshMemoryMode(mesh);
+       ResetHistory();
+       SaveMemoryMode();
        RefreshOutputs(true);
 }
 
@@ -616,25 +710,47 @@ int MeshManagerModel::GetCurrentMesh()
 void MeshManagerModel::Undo()
 {      
        if(history->UndoSize() > 0)
-       {       
-               RestoreState(history->Undo(new ManagerState(_meshes, meshId, lastModified)));
-               RefreshOutputs(true);
+       {
+               if(memoryMode == false){
+                       RestoreState(history->Undo(new ManagerState(_meshes, meshId, lastModified)));
+                       RefreshOutputs(true);
+               }
+               else if(history->UndoSize() > 1){
+                       RestoreStateMemoryMode(history->UndoKeepCurrent());
+               }
        }
 }
 
 void MeshManagerModel::Redo()
 {
        if(history->RedoSize() > 0)
-       {       
-               RestoreState(history->Redo(new ManagerState(_meshes, meshId, lastModified)));
-               RefreshOutputs(true);
+       {
+               if(memoryMode == false){
+                       RestoreState(history->Redo(new ManagerState(_meshes, meshId, lastModified)));
+                       RefreshOutputs(true);
+               }
+               else{
+                       RestoreStateMemoryMode(history->RedoKeepCurrent());
+               }
        }
 }
 
 void MeshManagerModel::Save()
 {
        history->Save(new ManagerState(_meshes, meshId, currentMesh));
-       //lastModified = currentMesh;
+}
+
+void MeshManagerModel::SaveMemoryMode()
+{
+       if(_meshes.size() == 1 && memoryMode)
+       {
+               std::vector<std::shared_ptr<MeshModel>> savedMesh;
+               savedMesh.push_back(std::make_shared<MeshModel>(_meshes.at(0).get()));
+               history->Save(new ManagerState(savedMesh, meshId, 0, referencePoint, referenceNormal));
+       }
+       else{
+               printf("PG MeshManagerModel::SaveMemoryMode WARNING Mesh vector has invalid size or memoryMode is not set \n");
+       }
 }
 
 void MeshManagerModel::RestoreState(ManagerState* state)
@@ -645,6 +761,25 @@ void MeshManagerModel::RestoreState(ManagerState* state)
                meshId = state->GetMeshId();
                currentMesh = state->GetModifiedPos();
                lastModified = state->GetModifiedPos();
+               delete state;
+       }
+       else{
+               printf("PG MeshManagerModel::RestoreState WARNING State is NULL \n");
+       }
+}
+
+void MeshManagerModel::RestoreStateMemoryMode(ManagerState* state){
+       if(_meshes.size() == 1 && state != NULL)
+       {
+               vtkPoints* statePoints = vtkPoints::New();
+               statePoints->DeepCopy(state->GetMeshes().at(0)->GetMeshBase()->GetPoints());
+               _meshes.at(0)->GetMeshBase()->SetPoints(statePoints);
+               _meshes.at(0)->GetMeshBase()->GetPoints()->Modified();
+        _meshes.at(0)->GetMeshBase()->Modified();
+        referencePoint = state->GetReferencePoint();
+        referenceNormal = state->referenceNormal;
+       }else{
+               printf("PG MeshManagerModel::RestoreStateMemoryMode WARNING Mesh vector has invalid size or state is NULL\n");
        }
 }
 
@@ -658,6 +793,15 @@ MeshManagerModel::ManagerState::ManagerState(std::vector<std::shared_ptr<MeshMod
        savedModifiedPos = modifiedPos;
 }
 
+MeshManagerModel::ManagerState::ManagerState(std::vector<std::shared_ptr<MeshModel>> meshesToSave, int meshId, int modifiedPos, std::vector<double> refPoint, std::vector<double> refNormal)
+{
+       savedMeshes = meshesToSave;
+       savedId = meshId;
+       savedModifiedPos = modifiedPos;
+       referencePoint = refPoint;
+       referenceNormal = refNormal;
+}
+
 MeshManagerModel::ManagerState::~ManagerState()
 {
        savedMeshes.clear();
@@ -677,3 +821,7 @@ int MeshManagerModel::ManagerState::GetModifiedPos()
        return savedModifiedPos;
 }
 
+std::vector<double>& MeshManagerModel::ManagerState::GetReferencePoint()
+{
+       return referencePoint;
+}