niftkMultiViewerVisibilityManager.h

Go to the documentation of this file.

/*=============================================================================

  NifTK: A software platform for medical image computing.

  Copyright (c) University College London (UCL). All rights reserved.

  This software is distributed WITHOUT ANY WARRANTY; without even
  the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
  PURPOSE.

  See LICENSE.txt in the top level directory for details.

=============================================================================*/

#ifndef niftkMultiViewerVisibilityManager_h
#define niftkMultiViewerVisibilityManager_h

#include <niftkDnDDisplayExports.h>

#include <QObject>

#include <itkImage.h>

#include <mitkDataStorage.h>
#include <mitkProperties.h>

#include <niftkDataNodePropertyListener.h>

#include "niftkDnDDisplayEnums.h"


namespace niftk
{

class SingleViewerWidget;

class NIFTKDNDDISPLAY_EXPORT MultiViewerVisibilityManager : public QObject, public DataNodePropertyListener
{
  Q_OBJECT

public:

  mitkClassMacro(MultiViewerVisibilityManager, DataNodePropertyListener)
  mitkNewMacro1Param(MultiViewerVisibilityManager, const mitk::DataStorage::Pointer)

  
  MultiViewerVisibilityManager(mitk::DataStorage::Pointer dataStorage);

  virtual ~MultiViewerVisibilityManager();

  MultiViewerVisibilityManager(const MultiViewerVisibilityManager&); // Purposefully not implemented.
  MultiViewerVisibilityManager& operator=(const MultiViewerVisibilityManager&); // Purposefully not implemented.

  void RegisterViewer(SingleViewerWidget *viewer);

  void DeregisterViewers(std::size_t startIndex = 0, std::size_t endIndex = -1);

  void ClearViewers(std::size_t startIndex = 0, std::size_t endIndex = -1);

  DnDDisplayDropType GetDropType() const { return m_DropType; }

  void SetDropType(DnDDisplayDropType dropType) { m_DropType = dropType; }

  DnDDisplayInterpolationType GetInterpolationType() const { return m_InterpolationType; }

  void SetInterpolationType(DnDDisplayInterpolationType interpolationType) { m_InterpolationType = interpolationType; }

  WindowLayout GetDefaultWindowLayout() const { return m_DefaultWindowLayout; }

  void SetDefaultWindowLayout(WindowLayout windowLayout) { m_DefaultWindowLayout = windowLayout; }

  bool GetAutomaticallyAddChildren() const { return m_AutomaticallyAddChildren; }

  void SetAutomaticallyAddChildren(bool autoAdd) { m_AutomaticallyAddChildren = autoAdd; }

  bool GetAccumulateWhenDropped() const { return m_Accumulate; }

  void SetAccumulateWhenDropping(bool accumulate) { m_Accumulate = accumulate; }

  void OnFocusChanged();

public slots:

  void OnNodesDropped(std::vector<mitk::DataNode*> nodes);

protected:

  virtual void OnNodeAdded(mitk::DataNode* node) override;

  virtual void OnNodeRemoved(mitk::DataNode* node) override;

  virtual void OnPropertyChanged(mitk::DataNode* node, const mitk::BaseRenderer* renderer) override;

  virtual void AddNodeToViewer(int windowIndex, mitk::DataNode* node, bool visibility=true);

  virtual void RemoveNodesFromViewer(int windowIndex);

private:

  void UpdateGlobalVisibilities(mitk::BaseRenderer* renderer);

  virtual int GetNodesInViewer(int windowIndex);

  WindowLayout GetWindowLayout(std::vector<mitk::DataNode*> nodes);

  template<typename TPixel, unsigned int VImageDimension>
  void GetAsAcquiredOrientation(itk::Image<TPixel, VImageDimension>* itkImage, WindowOrientation& outputOrientation);

  // Will retrieve the correct geometry from a list of nodes.
  // If nodeIndex < 0 (for single drop case).
  //   Search for first available image
  //   Failing that, first geometry.
  // If node index >=0, and < nodes.size()
  //   Picks out the geometry of the object for that index.
  // Else
  //   Picks out the first geometry.
  mitk::TimeGeometry::Pointer GetTimeGeometry(std::vector<mitk::DataNode*> nodes, int nodeIndex);

  // We maintain a set of data nodes present in each window.
  // So, it's a vector, as we have one set for each of the registered windows.
  std::vector< std::set<mitk::DataNode*> > m_DataNodesPerViewer;

  // Additionally, we manage a list of viewers, where m_DataNodes.size() == m_Viewers.size() should always be true.
  std::vector< SingleViewerWidget* > m_Viewers;

  // Keeps track of the current mode, as it effects the response when images are dropped, as images are spread over single, multiple or all windows.
  DnDDisplayDropType m_DropType;

  // Keeps track of the default window layout, as it affects the response when images are dropped, as the image should be oriented axial, coronal, sagittal, or as acquired (as per the X-Y plane).
  WindowLayout m_DefaultWindowLayout;

  // Keeps track of the default interpolation, as it affects the response when images are dropped,
  // as the dropped image should switch to that interpolation type, although as it is a node based property will affect all windows.
  DnDDisplayInterpolationType m_InterpolationType;

  // Boolean to indicate whether to automatically add children, default to true.
  bool m_AutomaticallyAddChildren;

  // Boolean to indicate whether successive drops into the same window are cumulative.
  bool m_Accumulate;

  unsigned long m_FocusManagerObserverTag;
};

}

#endif