Provide context-menus for segmentations in data manager. More...

#include <QmitkSegmentationPostProcessing.h>

Collaboration diagram for QmitkSegmentationPostProcessing:

Public Member Functions
	QmitkSegmentationPostProcessing (mitk::DataStorage storage, QmitkFunctionality functionality, QObject *parent=0)
virtual	~QmitkSegmentationPostProcessing ()
void	OnSurfaceCalculationDone ()
void	OnThresholdingToolManagerToolModified ()
void	SelectionChanged (berry::IWorkbenchPart::Pointer sourcepart, berry::ISelection::ConstPointer selection)
Protected Types
typedef std::vector < mitk::DataNode * >	NodeList
Protected Slots
void	ThresholdImage (bool)
void	CreateSurface (bool)
void	CreateSmoothedSurface (bool)
void	ImageStatistics (bool)
void	AutocropSelected (bool)
void	ThresholdingDone (int)
void	InternalCreateSurface (bool smoothed)
Protected Member Functions
NodeList	GetSelectedNodes () const
mitk::Image::Pointer	IncreaseCroppedImageSize (mitk::Image::Pointer image)
Protected Attributes
QmitkFunctionality *	m_BlueBerryView
mitk::DataStorage::Pointer	m_DataStorage
QAction *	m_CreateSurfaceAction
QAction *	m_CreateSmoothSurfaceAction
QAction *	m_StatisticsAction
QAction *	m_AutocropAction
QAction *	m_ThresholdAction
QDialog *	m_ThresholdingDialog
mitk::ToolManager::Pointer	m_ThresholdingToolManager
berry::ISelectionListener::Pointer	m_SelectionListener
mitk::DataNodeSelection::ConstPointer	m_CurrentSelection
Friends
struct	berry::SelectionChangedAdapter< QmitkSegmentationPostProcessing >

Detailed Description

Provide context-menus for segmentations in data manager.

This class is mainly meant as a helper to the org.mitk.gui.qt.segmentation view. Independency of this class has been attempted, so it might also be useful in a different context.

Definition at line 37 of file QmitkSegmentationPostProcessing.h.

Member Typedef Documentation

typedef std::vector<mitk::DataNode*> QmitkSegmentationPostProcessing::NodeList [protected]

Definition at line 67 of file QmitkSegmentationPostProcessing.h.

Constructor & Destructor Documentation

QmitkSegmentationPostProcessing::QmitkSegmentationPostProcessing	(	mitk::DataStorage *	storage,
		QmitkFunctionality *	functionality,
		QObject *	parent = `0`
	)

Definition at line 37 of file QmitkSegmentationPostProcessing.cpp.

References QmitkNodeDescriptor::AddAction(), AutocropSelected(), CreateSmoothedSurface(), CreateSurface(), berry::Platform::GetBundle(), QmitkNodeDescriptorManager::GetDescriptor(), QmitkNodeDescriptorManager::GetInstance(), berry::WorkbenchPart::GetSite(), ImageStatistics(), berry::SmartPointer< TObjectType >::IsNotNull(), m_AutocropAction, m_BlueBerryView, m_CreateSmoothSurfaceAction, m_CreateSurfaceAction, m_SelectionListener, m_StatisticsAction, m_ThresholdAction, MITK_WARN, SelectionChanged(), and ThresholdImage().

:QObject(parent)
,m_BlueBerryView(functionality)
,m_DataStorage(storage)
{
  // register a couple of additional actions for DataManager's context menu
  QmitkNodeDescriptor* imageDataNodeDescriptor =
    QmitkNodeDescriptorManager::GetInstance()->GetDescriptor("NoneBinaryImage");

  if (imageDataNodeDescriptor)
  {
    m_ThresholdAction = new QAction("Threshold..", parent);
    imageDataNodeDescriptor->AddAction(m_ThresholdAction);
    connect( m_ThresholdAction, SIGNAL( triggered(bool) ) , this, SLOT( ThresholdImage(bool) ) );
  }
  else
  {
    MITK_WARN << "Could not get datamanager's node descriptor for 'Image'";
  }

  // register a couple of additional actions for DataManager's context menu
  QmitkNodeDescriptor* binaryImageDataNodeDescriptor =
    QmitkNodeDescriptorManager::GetInstance()->GetDescriptor("ImageMask");

  if (binaryImageDataNodeDescriptor)
  {
    m_CreateSurfaceAction = new QAction("Create polygon model", parent);
    binaryImageDataNodeDescriptor->AddAction(m_CreateSurfaceAction);
    connect( m_CreateSurfaceAction, SIGNAL( triggered(bool) ) , this, SLOT( CreateSurface(bool) ) );

    m_CreateSmoothSurfaceAction = new QAction("Create smoothed polygon model", parent);
    binaryImageDataNodeDescriptor->AddAction(m_CreateSmoothSurfaceAction);
    connect( m_CreateSmoothSurfaceAction, SIGNAL( triggered(bool) ) , this, SLOT( CreateSmoothedSurface(bool) ) );

    m_StatisticsAction = new QAction("Statistics", parent);
    binaryImageDataNodeDescriptor->AddAction(m_StatisticsAction);
    berry::IBundle::Pointer imageStatisticsBundle = berry::Platform::GetBundle("org.mitk.gui.qt.imagestatistics");
    if(imageStatisticsBundle.IsNotNull())
      connect( m_StatisticsAction, SIGNAL( triggered(bool) ) , this, SLOT( ImageStatistics(bool) ) );
    else
      m_StatisticsAction->setEnabled( false );

    m_AutocropAction = new QAction("Autocrop", parent);
    binaryImageDataNodeDescriptor->AddAction(m_AutocropAction);
    connect( m_AutocropAction, SIGNAL( triggered(bool) ) , this, SLOT( AutocropSelected(bool) ) );
  }
  else
  {
    MITK_WARN << "Could not get datamanager's node descriptor for 'ImageMask'";
  }

  // register for blueberry selection events
  m_SelectionListener = berry::ISelectionListener::Pointer(new berry::SelectionChangedAdapter<QmitkSegmentationPostProcessing>(this, &QmitkSegmentationPostProcessing::SelectionChanged));
  m_BlueBerryView->GetSite()->GetWorkbenchWindow()->GetSelectionService()->AddPostSelectionListener(/*"org.mitk.views.datamanager",*/ m_SelectionListener);
}

QmitkSegmentationPostProcessing::~QmitkSegmentationPostProcessing ( ) [virtual]

Definition at line 93 of file QmitkSegmentationPostProcessing.cpp.

References QmitkNodeDescriptorManager::GetDescriptor(), QmitkNodeDescriptorManager::GetInstance(), berry::WorkbenchPart::GetSite(), m_AutocropAction, m_BlueBerryView, m_CreateSmoothSurfaceAction, m_CreateSurfaceAction, m_SelectionListener, m_StatisticsAction, m_ThresholdAction, MITK_WARN, QmitkNodeDescriptor::RemoveAction(), and berry::ISelectionService::RemovePostSelectionListener().

{
  berry::ISelectionService* s = m_BlueBerryView->GetSite()->GetWorkbenchWindow()->GetSelectionService();
  if(s)
  {
    s->RemovePostSelectionListener(m_SelectionListener);
  }

  // unregister a couple of additional actions for DataManager's context menu
  QmitkNodeDescriptor* imageDataNodeDescriptor =
    QmitkNodeDescriptorManager::GetInstance()->GetDescriptor("Image");

  if (imageDataNodeDescriptor)
  {
    imageDataNodeDescriptor->RemoveAction( m_ThresholdAction );
  }
  else
  {
    MITK_WARN << "Could not get datamanager's node descriptor for 'Image'";
  }

  // unregister a couple of additional actions for DataManager's context menu
  QmitkNodeDescriptor* binaryImageDataNodeDescriptor =
    QmitkNodeDescriptorManager::GetInstance()->GetDescriptor("ImageMask");

  if (binaryImageDataNodeDescriptor)
  {
    binaryImageDataNodeDescriptor->RemoveAction( m_CreateSurfaceAction );
    binaryImageDataNodeDescriptor->RemoveAction( m_CreateSmoothSurfaceAction );
    binaryImageDataNodeDescriptor->RemoveAction( m_StatisticsAction );
    binaryImageDataNodeDescriptor->RemoveAction( m_AutocropAction );
  }
  else
  {
    MITK_WARN << "Could not get datamanager's node descriptor for 'ImageMask'";
  }
}

Member Function Documentation

void QmitkSegmentationPostProcessing::AutocropSelected ( bool ) [protected, slot]

Definition at line 326 of file QmitkSegmentationPostProcessing.cpp.

References mitk::DataNode::GetData(), mitk::ProgressBar::GetInstance(), GetSelectedNodes(), IncreaseCroppedImageSize(), MITK_ERROR, MITK_INFO, mitk::AutoCropImageFilter::New(), and mitk::DataNode::SetData().

Referenced by QmitkSegmentationPostProcessing().

{
  NodeList selection = this->GetSelectedNodes();

  for ( NodeList::iterator iter = selection.begin(); iter != selection.end(); ++iter )
  {
    mitk::DataNode* node = *iter;

    if (node)
    {
      mitk::Image::Pointer image = dynamic_cast<mitk::Image*>( node->GetData() );
      if (image.IsNull()) return;

      mitk::ProgressBar::GetInstance()->AddStepsToDo(10);
      mitk::ProgressBar::GetInstance()->Progress(2);

      qApp->processEvents();

      mitk::AutoCropImageFilter::Pointer cropFilter = mitk::AutoCropImageFilter::New();
      cropFilter->SetInput( image );
      cropFilter->SetBackgroundValue( 0 );
      try
      {
        cropFilter->Update();

        image = cropFilter->GetOutput();

        if (image.IsNotNull())
        {
          node->SetData( this->IncreaseCroppedImageSize(image) ); // bug fix 3145
        }
      }
      catch(...)
      {
        MITK_ERROR << "Cropping image failed...";
      }
      mitk::ProgressBar::GetInstance()->Progress(8);
    }
    else
    {
      MITK_INFO << "   a NULL node selected";
    }
  }
}

void QmitkSegmentationPostProcessing::CreateSmoothedSurface ( bool ) [protected, slot]

Definition at line 233 of file QmitkSegmentationPostProcessing.cpp.

References InternalCreateSurface().

Referenced by QmitkSegmentationPostProcessing().

{
  InternalCreateSurface(true);
}

void QmitkSegmentationPostProcessing::CreateSurface ( bool ) [protected, slot]

Definition at line 238 of file QmitkSegmentationPostProcessing.cpp.

References InternalCreateSurface().

Referenced by QmitkSegmentationPostProcessing().

{
  InternalCreateSurface(false);
}

QmitkSegmentationPostProcessing::NodeList QmitkSegmentationPostProcessing::GetSelectedNodes ( ) const [protected]

Definition at line 142 of file QmitkSegmentationPostProcessing.cpp.

References berry::SmartPointer< TObjectType >::Cast(), and m_CurrentSelection.

Referenced by AutocropSelected(), InternalCreateSurface(), and ThresholdImage().

{
  NodeList result;
  if (m_CurrentSelection)
  {

    // iterate selection
    for (mitk::DataNodeSelection::iterator i = m_CurrentSelection->Begin(); i != m_CurrentSelection->End(); ++i)
    {
      // extract datatree node
      if (mitk::DataNodeObject::Pointer nodeObj = i->Cast<mitk::DataNodeObject>())
      {
        mitk::DataNode::Pointer node = nodeObj->GetDataNode();
        result.push_back( node );
      }
    }
  }

  return result;
}

void QmitkSegmentationPostProcessing::ImageStatistics ( bool ) [protected, slot]

Definition at line 318 of file QmitkSegmentationPostProcessing.cpp.

References berry::WorkbenchPart::GetSite(), and m_BlueBerryView.

Referenced by QmitkSegmentationPostProcessing().

{
  if (m_BlueBerryView)
  {
    m_BlueBerryView->GetSite()->GetWorkbenchWindow()->GetActivePage()->ShowView("org.mitk.views.imagestatistics");
  }
}

mitk::Image::Pointer QmitkSegmentationPostProcessing::IncreaseCroppedImageSize ( mitk::Image::Pointer image ) [protected]

Definition at line 371 of file QmitkSegmentationPostProcessing.cpp.

References mitk::CastToItkImage(), mitk::CastToMitkImage(), and mitk::Image::New().

Referenced by AutocropSelected().

{
  typedef itk::Image< short, 3 > ImageType;
  typedef itk::Image< unsigned char, 3 > PADOutputImageType;
  ImageType::Pointer itkTransformImage = ImageType::New();
  mitk::CastToItkImage( image, itkTransformImage );

  typedef itk::ConstantPadImageFilter< ImageType, PADOutputImageType > PadFilterType;
  PadFilterType::Pointer padFilter = PadFilterType::New();

  unsigned long upperPad[3];
  unsigned long lowerPad[3];
  int borderLiner = 6;

  mitk::Point3D mitkOriginPoint;
  double origin[3];
  origin[0]=0;
  origin[1]=0;
  origin[2]=0;
  itkTransformImage->SetOrigin(origin);

  lowerPad[0]=borderLiner/2;
  lowerPad[1]=borderLiner/2;
  lowerPad[2]=borderLiner/2;

  upperPad[0]=borderLiner/2;
  upperPad[1]=borderLiner/2;
  upperPad[2]=borderLiner/2;

  padFilter->SetInput(itkTransformImage);
  padFilter->SetConstant(0);
  padFilter->SetPadUpperBound(upperPad);
  padFilter->SetPadLowerBound(lowerPad);
  padFilter->UpdateLargestPossibleRegion();


  mitk::Image::Pointer paddedImage = mitk::Image::New();
  mitk::CastToMitkImage(padFilter->GetOutput(), paddedImage);

  paddedImage->SetGeometry(image->GetGeometry());

  //calculate translation vector according to padding to get the new origin
  mitk::Vector3D transVector = image->GetGeometry()->GetSpacing();
  transVector[0] = -(borderLiner/2);
  transVector[1] = -(borderLiner/2);
  transVector[2] = -(borderLiner/2);

  mitk::Vector3D newTransVectorInmm = image->GetGeometry()->GetSpacing();

  image->GetGeometry()->IndexToWorld(mitkOriginPoint, transVector, newTransVectorInmm);
  paddedImage->GetGeometry()->Translate(newTransVectorInmm);
  //paddedImage->SetRequestedRegionToLargestPossibleRegion();

  return paddedImage;
}

void QmitkSegmentationPostProcessing::InternalCreateSurface ( bool smoothed ) [protected, slot]

Definition at line 243 of file QmitkSegmentationPostProcessing.cpp.

References mitk::DataNode::GetData(), mitk::StatusBar::GetInstance(), mitk::ProgressBar::GetInstance(), GetSelectedNodes(), m_DataStorage, MITK_ERROR, MITK_INFO, mitk::ShowSegmentationAsSurface::New(), and OnSurfaceCalculationDone().

Referenced by CreateSmoothedSurface(), and CreateSurface().

{
  NodeList selection = this->GetSelectedNodes();

  for ( NodeList::iterator iter = selection.begin(); iter != selection.end(); ++iter )
  {
    mitk::DataNode* node = *iter;

    if (node)
    {
      mitk::Image::Pointer image = dynamic_cast<mitk::Image*>( node->GetData() );
      if (image.IsNull()) return;

      try
      {
        mitk::ShowSegmentationAsSurface::Pointer surfaceFilter = mitk::ShowSegmentationAsSurface::New();

        // attach observer to get notified about result
        itk::SimpleMemberCommand<QmitkSegmentationPostProcessing>::Pointer goodCommand = itk::SimpleMemberCommand<QmitkSegmentationPostProcessing>::New();
        goodCommand->SetCallbackFunction(this, &QmitkSegmentationPostProcessing::OnSurfaceCalculationDone);
        surfaceFilter->AddObserver(mitk::ResultAvailable(), goodCommand);
        itk::SimpleMemberCommand<QmitkSegmentationPostProcessing>::Pointer badCommand = itk::SimpleMemberCommand<QmitkSegmentationPostProcessing>::New();
        badCommand->SetCallbackFunction(this, &QmitkSegmentationPostProcessing::OnSurfaceCalculationDone);
        surfaceFilter->AddObserver(mitk::ProcessingError(), badCommand);

        mitk::DataNode::Pointer nodepointer = node;
        surfaceFilter->SetPointerParameter("Input", image);
        surfaceFilter->SetPointerParameter("Group node", nodepointer);
        surfaceFilter->SetParameter("Show result", true );
        surfaceFilter->SetParameter("Sync visibility", false );
        surfaceFilter->SetDataStorage( *m_DataStorage );

        if (smoothed)
        {
          surfaceFilter->SetParameter("Smooth", true );
          //surfaceFilter->SetParameter("Apply median", true );
          surfaceFilter->SetParameter("Apply median", false );  // median makes the resulting surfaces look like lego models
          surfaceFilter->SetParameter("Median kernel size", 3u );
          surfaceFilter->SetParameter("Gaussian SD", 2.5f );
          surfaceFilter->SetParameter("Decimate mesh", true );
          surfaceFilter->SetParameter("Decimation rate", 0.80f );
        }
        else
        {
          surfaceFilter->SetParameter("Smooth", false );
          surfaceFilter->SetParameter("Apply median", false );
          surfaceFilter->SetParameter("Median kernel size", 3u );
          surfaceFilter->SetParameter("Gaussian SD", 1.5f );
          surfaceFilter->SetParameter("Decimate mesh", true );
          surfaceFilter->SetParameter("Decimation rate", 0.8f );
        }

        mitk::ProgressBar::GetInstance()->AddStepsToDo(10);
        mitk::ProgressBar::GetInstance()->Progress(2);
        mitk::StatusBar::GetInstance()->DisplayText("Surface creation started in background...");
        surfaceFilter->StartAlgorithm();
      }
      catch(...)
      {
        MITK_ERROR << "surface creation filter had an error";
      }
    }
    else
    {
      MITK_INFO << "   a NULL node selected";
    }
  }
}

void QmitkSegmentationPostProcessing::OnSurfaceCalculationDone ( )

Definition at line 312 of file QmitkSegmentationPostProcessing.cpp.

References mitk::ProgressBar::GetInstance().

Referenced by InternalCreateSurface().

{
  mitk::ProgressBar::GetInstance()->Progress(8);
}

void QmitkSegmentationPostProcessing::OnThresholdingToolManagerToolModified ( )

Definition at line 220 of file QmitkSegmentationPostProcessing.cpp.

References m_ThresholdingDialog, and m_ThresholdingToolManager.

Referenced by ThresholdImage().

{
  if ( m_ThresholdingToolManager.IsNull() ) return;

  //MITK_INFO << "Now got tool " << m_ThresholdingToolManager->GetActiveToolID();

  if ( m_ThresholdingToolManager->GetActiveToolID() < 0)
  {
    if (m_ThresholdingDialog)
      m_ThresholdingDialog->accept();
  }
}

void QmitkSegmentationPostProcessing::SelectionChanged	(	berry::IWorkbenchPart::Pointer	sourcepart,
		berry::ISelection::ConstPointer	selection
	)

Definition at line 131 of file QmitkSegmentationPostProcessing.cpp.

References berry::SmartPointer< TObjectType >::Cast(), berry::SmartPointer< TObjectType >::IsNull(), and m_CurrentSelection.

Referenced by QmitkSegmentationPostProcessing().

{
  if ( selection.IsNull()  )
  {
    return;
  }

  // save current selection in member variable
  m_CurrentSelection = selection.Cast<const mitk::DataNodeSelection>();
}

void QmitkSegmentationPostProcessing::ThresholdImage ( bool ) [protected, slot]

Definition at line 163 of file QmitkSegmentationPostProcessing.cpp.

References mitk::Tool::GetGUI(), GetSelectedNodes(), m_DataStorage, m_ThresholdingDialog, m_ThresholdingToolManager, mitk::ToolManager::New(), OnThresholdingToolManagerToolModified(), QmitkToolGUI::SetTool(), and ThresholdingDone().

Referenced by QmitkSegmentationPostProcessing().

{
  NodeList selection = this->GetSelectedNodes();

  m_ThresholdingToolManager = mitk::ToolManager::New( m_DataStorage );
  m_ThresholdingToolManager->RegisterClient();
  m_ThresholdingToolManager->ActiveToolChanged +=
    mitk::MessageDelegate<QmitkSegmentationPostProcessing>( this, &QmitkSegmentationPostProcessing::OnThresholdingToolManagerToolModified );
  
  m_ThresholdingDialog = new QDialog(qobject_cast<QWidget *>(parent()));
  connect( m_ThresholdingDialog, SIGNAL(finished(int)), this, SLOT(ThresholdingDone(int)) );

  QVBoxLayout* layout = new QVBoxLayout;
  layout->setContentsMargins(0, 0, 0, 0);

  mitk::Tool* tool = m_ThresholdingToolManager->GetToolById( m_ThresholdingToolManager->GetToolIdByToolType<mitk::BinaryThresholdTool>() );
  if (tool)
  {
    itk::Object::Pointer possibleGUI = tool->GetGUI("Qmitk", "GUI");
    QmitkToolGUI* gui = dynamic_cast<QmitkToolGUI*>( possibleGUI.GetPointer() );
    if (gui)
    {
      gui->SetTool(tool);
      gui->setParent(m_ThresholdingDialog);
      layout->addWidget(gui);
      m_ThresholdingDialog->setLayout(layout);
      layout->activate();
      m_ThresholdingDialog->setFixedSize(300,75);
      m_ThresholdingDialog->open();
    }
  }

  for ( NodeList::iterator iter = selection.begin(); iter != selection.end(); ++iter )
  {
    mitk::DataNode* node = *iter;

    if (node)
    {
      m_ThresholdingToolManager->SetReferenceData( node );
      m_ThresholdingToolManager->ActivateTool( m_ThresholdingToolManager->GetToolIdByToolType<mitk::BinaryThresholdTool>() );
    }
  }
}

void QmitkSegmentationPostProcessing::ThresholdingDone ( int result ) [protected, slot]

Definition at line 207 of file QmitkSegmentationPostProcessing.cpp.

References mitk::RenderingManager::GetInstance(), m_ThresholdingDialog, m_ThresholdingToolManager, and MITK_INFO.

Referenced by ThresholdImage().

{
  if (result == QDialog::Rejected)
    m_ThresholdingToolManager->ActivateTool(-1);
  MITK_INFO << "Thresholding done, cleaning up";
  m_ThresholdingDialog->deleteLater();
  m_ThresholdingDialog = NULL;
  m_ThresholdingToolManager->SetReferenceData( NULL );
  m_ThresholdingToolManager->SetWorkingData( NULL );

  mitk::RenderingManager::GetInstance()->RequestUpdateAll();
}