vtkSegmentationHistory.h

Go to the documentation of this file.

/*==============================================================================
 
  Copyright (c) Laboratory for Percutaneous Surgery (PerkLab)
  Queen's University, Kingston, ON, Canada. All Rights Reserved.
 
  See COPYRIGHT.txt
  or http://www.slicer.org/copyright/copyright.txt for details.
 
  Unless required by applicable law or agreed to in writing, software
  distributed under the License is distributed on an "AS IS" BASIS,
  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  See the License for the specific language governing permissions and
  limitations under the License.
 
  This file was originally developed by Csaba Pinter, PerkLab, Queen's University
  and was supported through the Applied Cancer Research Unit program of Cancer Care
  Ontario with funds provided by the Ontario Ministry of Health and Long-Term Care
 
==============================================================================*/
 
#ifndef __vtkSegmentationHistory_h
#define __vtkSegmentationHistory_h
 
// VTK includes
#include <vtkObject.h>
#include <vtkSmartPointer.h>
 
// STD includes
#include <deque>
#include <map>
#include <vector>
 
#include "vtkSegmentationCoreConfigure.h"
 
class vtkCallbackCommand;
class vtkDataObject;
class vtkSegment;
class vtkSegmentation;
 
class vtkSegmentationCore_EXPORT vtkSegmentationHistory : public vtkObject
{
public:
  static vtkSegmentationHistory* New();
  vtkTypeMacro(vtkSegmentationHistory, vtkObject);
  void PrintSelf(ostream& os, vtkIndent indent) override;
 
  void SetSegmentation(vtkSegmentation* segmentation);
 
  vtkGetMacro(Segmentation, vtkSegmentation*);
 
  bool SaveState();
 
  bool RestorePreviousState();
 
  bool IsRestorePreviousStateAvailable();
 
  bool RestoreNextState();
 
  bool IsRestoreNextStateAvailable();
 
  void RemoveAllStates();
 
  void SetMaximumNumberOfStates(unsigned int maximumNumberOfStates);
 
  vtkGetMacro(MaximumNumberOfStates, unsigned int);
 
  int GetNumberOfStates();
 
protected:
  static void OnSegmentationModified(vtkObject* caller, unsigned long eid, void* clientData, void* callData);
 
  void RemoveAllNextStates();
 
  void RemoveAllObsoleteStates();
 
  bool RestoreState(unsigned int stateIndex);
 
protected:
  vtkSegmentationHistory();
  ~vtkSegmentationHistory() override;
 
  typedef std::map<std::string, vtkSmartPointer<vtkSegment> > SegmentsMap;
 
  struct SegmentationState
    {
    SegmentsMap Segments;
    std::vector<std::string> SegmentIds; // order of segments
    };
 
  vtkSegmentation* Segmentation;
  vtkCallbackCommand* SegmentationModifiedCallbackCommand;
  std::deque<SegmentationState> SegmentationStates;
  unsigned int MaximumNumberOfStates;
 
  // Index of the state in SegmentationStates that was restored last.
  // If LastRestoredState == size of states then it means that the segmentation has changed
  // since the last restored state.
  unsigned int LastRestoredState;
 
  bool RestoreStateInProgress;
 
private:
  vtkSegmentationHistory(const vtkSegmentationHistory&) = delete;
  void operator=(const vtkSegmentationHistory&) = delete;
};
 
#endif