niftkGeneralSegmentorController.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 niftkGeneralSegmentorController_h
#define niftkGeneralSegmentorController_h

#include <niftkMIDASGuiExports.h>

#include <mitkOperationActor.h>

#include <niftkBaseSegmentorController.h>
#include <niftkToolKeyPressResponder.h>
#include <niftkToolKeyPressStateMachine.h>

#include "Internal/niftkGeneralSegmentorEventInterface.h"

namespace mitk
{
class PointSet;
}

namespace niftk
{

class GeneralSegmentorControllerPrivate;
class GeneralSegmentorGUI;


class NIFTKMIDASGUI_EXPORT GeneralSegmentorController
  : public BaseSegmentorController,
    public mitk::OperationActor,
    public ToolKeyPressResponder
{
  Q_OBJECT

public:

  GeneralSegmentorController(IBaseView* view);
  virtual ~GeneralSegmentorController();

  virtual void SetupGUI(QWidget* parent) override;

  virtual bool SelectSeedTool() override;

  virtual bool SelectDrawTool() override;

  virtual bool UnselectTools() override;

  virtual bool SelectPolyTool() override;

  virtual bool SelectViewMode() override;

  virtual bool CleanSlice() override;

  virtual void ExecuteOperation(mitk::Operation* operation) override;

protected:

  virtual bool IsASegmentationImage(const mitk::DataNode::Pointer node) override;

  virtual std::vector<mitk::DataNode*> GetWorkingDataFromSegmentationNode(const mitk::DataNode::Pointer node) override;

  virtual bool CanStartSegmentationForBinaryNode(const mitk::DataNode::Pointer node) override;

  virtual BaseGUI* CreateGUI(QWidget* parent) override;

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

  virtual void OnSelectedSliceChanged(ImageOrientation orientation, int sliceIndex) override;

protected slots:

  virtual void OnNewSegmentationButtonClicked() override;

  void OnSeePriorCheckBoxToggled(bool checked);

  void OnSeeNextCheckBoxToggled(bool checked);

  void OnCleanButtonClicked();

  void OnWipeButtonClicked();

  void OnWipePlusButtonClicked();

  void OnWipeMinusButtonClicked();

  void OnPropagateUpButtonClicked();

  void OnPropagateDownButtonClicked();

  void OnPropagate3DButtonClicked();

  void OnThresholdApplyButtonClicked();

  void OnThresholdingCheckBoxToggled(bool checked);

  void OnThresholdValueChanged();

  void OnAnyButtonClicked();

  void OnOKButtonClicked();

  void OnResetButtonClicked();

  void OnCancelButtonClicked();

  void OnRestartButtonClicked();

private:

  virtual void OnViewGetsVisible() override;

  virtual void OnViewGetsHidden() override;

  void OnViewGetsClosed();

  virtual void OnNodeChanged(const mitk::DataNode* node) override;

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

  virtual void OnContoursChanged();

  mitk::DataNode::Pointer CreateHelperImage(const mitk::Image* referenceImage, const mitk::Color& colour, const std::string& name, bool visible, int layer);

  mitk::DataNode::Pointer CreateContourSet(const mitk::Color& colour, const std::string& name, bool visible, int layer);

  void StoreInitialSegmentation();

  mitk::PointSet* GetSeeds();

  void InitialiseSeedsForSlice(int sliceAxis, int sliceIndex);

  void RecalculateMinAndMaxOfImage();

  void RecalculateMinAndMaxOfSeedValues();

  bool DoesSliceHaveUnenclosedSeeds(bool thresholdOn, int sliceAxis, int sliceIndex);

  bool DoesSliceHaveUnenclosedSeeds(bool thresholdOn, int sliceAxis, int sliceIndex, const mitk::PointSet* seeds);

  void FilterSeedsToCurrentSlice(
      const mitk::PointSet* inputPoints,
      int sliceAxis,
      int sliceIndex,
      mitk::PointSet* outputPoints
      );

  void FilterSeedsToEnclosedSeedsOnSlice(
      const mitk::PointSet* inputPoints,
      bool thresholdOn,
      int sliceAxis,
      int sliceIndex,
      mitk::PointSet* outputPoints
      );

  void UpdateRegionGrowing(bool updateRendering = true);

  void UpdateRegionGrowing(bool isVisible, int sliceAxis, int sliceIndex, double lowerThreshold, double upperThreshold, bool skipUpdate);

  void UpdateCurrentSliceContours(bool updateRendering = true);

  void UpdatePriorAndNext(bool updateRendering = true);

  void DoPropagate(bool isUp, bool is3D);

  bool DoWipe(int direction);

  bool DoThresholdApply(bool optimiseSeeds, bool newSliceEmpty, bool newCheckboxStatus);

  void ToggleTool(int toolId);

  void DestroyPipeline();

  void RemoveWorkingData();

  void RestoreInitialSegmentation();

  void DiscardSegmentation();

  void ClearWorkingData();

  QScopedPointer<GeneralSegmentorControllerPrivate> d_ptr;

  Q_DECLARE_PRIVATE(GeneralSegmentorController);

};

}

#endif