diff --git a/Modules/ContourModel/Algorithms/mitkContourModelUtils.h b/Modules/ContourModel/Algorithms/mitkContourModelUtils.h
index b43386aefb..7c567a697e 100644
--- a/Modules/ContourModel/Algorithms/mitkContourModelUtils.h
+++ b/Modules/ContourModel/Algorithms/mitkContourModelUtils.h
@@ -1,117 +1,124 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
#ifndef mitkContourModelUtils_h
#define mitkContourModelUtils_h
#include <mitkContourModel.h>
#include <mitkImage.h>
#include <vtkSmartPointer.h>
#include <MitkContourModelExports.h>
namespace mitk
{
/**
* \brief Helpful methods for working with contours and images
*
*
*/
class MITKCONTOURMODEL_EXPORT ContourModelUtils : public itk::Object
{
public:
mitkClassMacroItkParent(ContourModelUtils, itk::Object);
/**
\brief Projects a contour onto an image point by point. Converts from world to index coordinates.
\param slice
\param contourIn3D
\param correctionForIpSegmentation adds 0.5 to x and y index coordinates (difference between ipSegmentation and
MITK contours)
\param constrainToInside
*/
static ContourModel::Pointer ProjectContourTo2DSlice(const Image *slice,
const ContourModel *contourIn3D,
bool correctionForIpSegmentation,
bool constrainToInside);
/**
\brief Projects a slice index coordinates of a contour back into world coordinates.
\param sliceGeometry
\param contourIn2D
\param correctionForIpSegmentation subtracts 0.5 to x and y index coordinates (difference between ipSegmentation
and MITK contours)
*/
static ContourModel::Pointer BackProjectContourFrom2DSlice(const BaseGeometry *sliceGeometry,
const ContourModel *contourIn2D,
bool correctionForIpSegmentation = false);
/**
\brief Fill a contour in a 2D slice with a specified pixel value.
This version always uses the contour of time step 0 and fills the image.
\pre sliceImage points to a valid instance
\pre projectedContour points to a valid instance
*/
static void FillContourInSlice(const ContourModel *projectedContour,
Image *sliceImage,
const Image* workingImage,
int paintingPixelValue = 1);
/**
\brief Fill a contour in a 2D slice with a specified pixel value.
This overloaded version uses the contour at the passed contourTimeStep
to fill the passed image slice.
\pre sliceImage points to a valid instance
\pre projectedContour points to a valid instance
*/
static void FillContourInSlice(const ContourModel *projectedContour,
TimeStepType contourTimeStep,
Image *sliceImage,
const Image* workingImage,
int paintingPixelValue = 1);
/**
- \brief Fills a image (filledImage) into another image (resultImage) by incorporating the rules of LabelSet-Images
+ \brief Fills the paintingPixelValue into every pixel of resultImage as indicated by filledImage.
+ If a LableSet image is specified it also by incorporating the rules of LabelSet images when filling the content.
+ \param filledImage Pointer to the image content that should be checked to decied of a pixel in resultImage should
+ be filled with paintingPixelValue or not.
+ \param resultImage Pointer to the image content that should be overwritten guided by the content of filledImage.
+ \param image Pointer to an mitk image that allows to define the LabelSet image which states steer the filling process.
+ If an LabelSet instance is passed its states (e.g. locked labels etc...) will be used. If nullptr or an normal image
+ is passed, then simply any pixel position indicated by filledImage will be overwritten.
\param paintingPixelValue the pixelvalue/label that should be used in the result image when filling.
\param fillForegroundThreshold The threshold value that decides if a pixel in the filled image counts
as foreground (>=fillForegroundThreshold) or not.
*/
static void FillSliceInSlice(vtkSmartPointer<vtkImageData> filledImage,
vtkSmartPointer<vtkImageData> resultImage,
const Image* image,
int paintingPixelValue,
double fillForegroundThreshold = 1.0);
/**
\brief Move the contour in time step 0 to to a new contour model at the given time step.
*/
static ContourModel::Pointer MoveZerothContourTimeStep(const ContourModel *contour, TimeStepType timeStep);
/**
\brief Retrieves the active pixel value of a (labelset) image.
If the image is basic image, the pixel value 1 (one) will be returned.
If the image is actually a labelset image, the pixel value of the active label of the active layer will be
returned.
\param workingImage The (labelset) image to retrieve the active pixel value of.
*/
static int GetActivePixelValue(const Image* workingImage);
protected:
ContourModelUtils();
~ContourModelUtils() override;
};
}
#endif
diff --git a/Modules/Segmentation/Interactions/mitkAdaptiveRegionGrowingTool.cpp b/Modules/Segmentation/Interactions/mitkAdaptiveRegionGrowingTool.cpp
index d4a109ccfe..579561cfd0 100644
--- a/Modules/Segmentation/Interactions/mitkAdaptiveRegionGrowingTool.cpp
+++ b/Modules/Segmentation/Interactions/mitkAdaptiveRegionGrowingTool.cpp
@@ -1,120 +1,120 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
#include "mitkAdaptiveRegionGrowingTool.h"
#include "mitkImage.h"
#include "mitkProperties.h"
#include "mitkToolManager.h"
// us
#include <usGetModuleContext.h>
#include <usModule.h>
#include <usModuleContext.h>
#include <usModuleResource.h>
namespace mitk
{
MITK_TOOL_MACRO(MITKSEGMENTATION_EXPORT, AdaptiveRegionGrowingTool, "AdaptiveRegionGrowingTool");
}
mitk::AdaptiveRegionGrowingTool::AdaptiveRegionGrowingTool()
{
m_PointSetNode = mitk::DataNode::New();
m_PointSetNode->GetPropertyList()->SetProperty("name", mitk::StringProperty::New("3D_Regiongrowing_Seedpoint"));
m_PointSetNode->GetPropertyList()->SetProperty("helper object", mitk::BoolProperty::New(true));
m_PointSet = mitk::PointSet::New();
m_PointSetNode->SetData(m_PointSet);
}
mitk::AdaptiveRegionGrowingTool::~AdaptiveRegionGrowingTool()
{
}
bool mitk::AdaptiveRegionGrowingTool::CanHandle(const BaseData* referenceData, const BaseData* /*workingData*/) const
{
if (referenceData == nullptr)
return false;
auto *image = dynamic_cast<const Image *>(referenceData);
if (image == nullptr)
return false;
if (image->GetDimension() < 3)
return false;
if (image->GetTimeSteps() > 1) //release quickfix for T28275
return false;
return true;
}
const char **mitk::AdaptiveRegionGrowingTool::GetXPM() const
{
return nullptr;
}
const char *mitk::AdaptiveRegionGrowingTool::GetName() const
{
return "Region Growing 3D";
}
us::ModuleResource mitk::AdaptiveRegionGrowingTool::GetIconResource() const
{
us::Module *module = us::GetModuleContext()->GetModule();
us::ModuleResource resource = module->GetResource("RegionGrowing_48x48.png");
return resource;
}
void mitk::AdaptiveRegionGrowingTool::Activated()
{
Superclass::Activated();
if (!GetDataStorage()->Exists(m_PointSetNode))
GetDataStorage()->Add(m_PointSetNode, GetWorkingData());
m_SeedPointInteractor = mitk::SinglePointDataInteractor::New();
m_SeedPointInteractor->LoadStateMachine("PointSet.xml");
m_SeedPointInteractor->SetEventConfig("PointSetConfig.xml");
m_SeedPointInteractor->SetDataNode(m_PointSetNode);
}
void mitk::AdaptiveRegionGrowingTool::Deactivated()
{
m_PointSet->Clear();
GetDataStorage()->Remove(m_PointSetNode);
Superclass::Deactivated();
}
void mitk::AdaptiveRegionGrowingTool::ConfirmSegmentation()
{
- m_ToolManager->ActivateTool(-1);
+ this->GetToolManager()->ActivateTool(-1);
}
mitk::DataNode *mitk::AdaptiveRegionGrowingTool::GetReferenceData()
{
- return this->m_ToolManager->GetReferenceData(0);
+ return this->GetToolManager()->GetReferenceData(0);
}
mitk::DataStorage *mitk::AdaptiveRegionGrowingTool::GetDataStorage()
{
- return this->m_ToolManager->GetDataStorage();
+ return this->GetToolManager()->GetDataStorage();
}
mitk::DataNode *mitk::AdaptiveRegionGrowingTool::GetWorkingData()
{
- return this->m_ToolManager->GetWorkingData(0);
+ return this->GetToolManager()->GetWorkingData(0);
}
mitk::DataNode::Pointer mitk::AdaptiveRegionGrowingTool::GetPointSetNode()
{
return m_PointSetNode;
}
diff --git a/Modules/Segmentation/Interactions/mitkAutoMLSegmentationWithPreviewTool.cpp b/Modules/Segmentation/Interactions/mitkAutoMLSegmentationWithPreviewTool.cpp
index 5451a67f34..64df08bc8b 100644
--- a/Modules/Segmentation/Interactions/mitkAutoMLSegmentationWithPreviewTool.cpp
+++ b/Modules/Segmentation/Interactions/mitkAutoMLSegmentationWithPreviewTool.cpp
@@ -1,204 +1,204 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
// MITK
#include "mitkAutoMLSegmentationWithPreviewTool.h"
#include "mitkImageAccessByItk.h"
#include "mitkToolManager.h"
#include <mitkITKImageImport.h>
#include <mitkImageCast.h>
#include <mitkLevelWindowProperty.h>
#include <mitkLookupTableProperty.h>
#include <mitkRenderingModeProperty.h>
#include <mitkSliceNavigationController.h>
// ITK
#include <itkBinaryThresholdImageFilter.h>
#include <itkOrImageFilter.h>
mitk::AutoMLSegmentationWithPreviewTool::AutoMLSegmentationWithPreviewTool() : AutoSegmentationWithPreviewTool(true)
{
}
void mitk::AutoMLSegmentationWithPreviewTool::SetSelectedLabels(const SelectedLabelVectorType& regions)
{
if (m_SelectedLabels != regions)
{
m_SelectedLabels = regions;
//Note: we do not call this->Modified() on puprose. Reason: changing the
//selected regions should not force to run otsu filter in DoUpdatePreview due to changed MTime.
}
}
const mitk::LabelSetImage* mitk::AutoMLSegmentationWithPreviewTool::GetMLPreview() const
{
if (m_MLPreviewNode.IsNotNull())
{
const auto mlPreviewImage = dynamic_cast<const LabelSetImage*>(this->m_MLPreviewNode->GetData());
return mlPreviewImage;
}
return nullptr;
}
mitk::AutoMLSegmentationWithPreviewTool::SelectedLabelVectorType mitk::AutoMLSegmentationWithPreviewTool::GetSelectedLabels() const
{
return this->m_SelectedLabels;
}
void mitk::AutoMLSegmentationWithPreviewTool::Activated()
{
Superclass::Activated();
m_SelectedLabels = {};
m_MLPreviewNode = mitk::DataNode::New();
m_MLPreviewNode->SetProperty("name", StringProperty::New(std::string(this->GetName()) + "ML preview"));
m_MLPreviewNode->SetProperty("helper object", BoolProperty::New(true));
m_MLPreviewNode->SetVisibility(true);
m_MLPreviewNode->SetOpacity(1.0);
- m_ToolManager->GetDataStorage()->Add(m_MLPreviewNode);
+ this->GetToolManager()->GetDataStorage()->Add(m_MLPreviewNode);
}
void mitk::AutoMLSegmentationWithPreviewTool::Deactivated()
{
- m_ToolManager->GetDataStorage()->Remove(m_MLPreviewNode);
+ this->GetToolManager()->GetDataStorage()->Remove(m_MLPreviewNode);
m_MLPreviewNode = nullptr;
Superclass::Deactivated();
}
void mitk::AutoMLSegmentationWithPreviewTool::UpdateCleanUp()
{
if (m_MLPreviewNode.IsNotNull())
m_MLPreviewNode->SetVisibility(m_SelectedLabels.empty());
if (nullptr != this->GetPreviewSegmentationNode())
this->GetPreviewSegmentationNode()->SetVisibility(!m_SelectedLabels.empty());
if (m_SelectedLabels.empty())
{
this->ResetPreviewNode();
}
}
-void mitk::AutoMLSegmentationWithPreviewTool::DoUpdatePreview(const Image* inputAtTimeStep, Image* previewImage, TimeStepType timeStep)
+void mitk::AutoMLSegmentationWithPreviewTool::DoUpdatePreview(const Image* inputAtTimeStep, const Image* /*oldSegAtTimeStep*/, Image* previewImage, TimeStepType timeStep)
{
const auto timePoint = mitk::RenderingManager::GetInstance()->GetTimeNavigationController()->GetSelectedTimePoint();
if (nullptr == m_MLPreviewNode->GetData()
|| this->GetMTime() > m_MLPreviewNode->GetData()->GetMTime()
|| this->m_LastMLTimeStep != timeStep //this covers the case where dynamic
//segmentations have to compute a preview
//for all time steps on confirmation
|| this->GetLastTimePointOfUpdate() != timePoint //this ensures that static seg
//previews work with dynamic images
//with avoiding unnecessary other computations
)
{
if (nullptr == inputAtTimeStep)
{
MITK_WARN << "Cannot run segementation. Currently selected input image is not set.";
return;
}
this->m_LastMLTimeStep = timeStep;
auto newMLPreview = ComputeMLPreview(inputAtTimeStep, timeStep);
if (newMLPreview.IsNotNull())
{
this->m_MLPreviewNode->SetData(newMLPreview);
this->m_MLPreviewNode->SetProperty("binary", mitk::BoolProperty::New(false));
mitk::RenderingModeProperty::Pointer renderingMode = mitk::RenderingModeProperty::New();
renderingMode->SetValue(mitk::RenderingModeProperty::LOOKUPTABLE_LEVELWINDOW_COLOR);
this->m_MLPreviewNode->SetProperty("Image Rendering.Mode", renderingMode);
mitk::LookupTable::Pointer lut = mitk::LookupTable::New();
mitk::LookupTableProperty::Pointer prop = mitk::LookupTableProperty::New(lut);
vtkSmartPointer<vtkLookupTable> lookupTable = vtkSmartPointer<vtkLookupTable>::New();
lookupTable->SetHueRange(1.0, 0.0);
lookupTable->SetSaturationRange(1.0, 1.0);
lookupTable->SetValueRange(1.0, 1.0);
lookupTable->SetTableRange(-1.0, 1.0);
lookupTable->Build();
lut->SetVtkLookupTable(lookupTable);
prop->SetLookupTable(lut);
this->m_MLPreviewNode->SetProperty("LookupTable", prop);
mitk::LevelWindowProperty::Pointer levWinProp = mitk::LevelWindowProperty::New();
mitk::LevelWindow levelwindow;
levelwindow.SetRangeMinMax(0, newMLPreview->GetScalarValueMax());
levWinProp->SetLevelWindow(levelwindow);
this->m_MLPreviewNode->SetProperty("levelwindow", levWinProp);
}
}
if (!m_SelectedLabels.empty())
{
const auto mlPreviewImage = this->GetMLPreview();
if (nullptr != mlPreviewImage)
{
AccessByItk_n(mlPreviewImage, CalculateMergedSimplePreview, (previewImage, timeStep));
}
}
}
template <typename TPixel, unsigned int VImageDimension>
void mitk::AutoMLSegmentationWithPreviewTool::CalculateMergedSimplePreview(const itk::Image<TPixel, VImageDimension>* itkImage, mitk::Image* segmentation, unsigned int timeStep)
{
typedef itk::Image<TPixel, VImageDimension> InputImageType;
typedef itk::Image<mitk::Tool::DefaultSegmentationDataType, VImageDimension> OutputImageType;
typedef itk::BinaryThresholdImageFilter<InputImageType, OutputImageType> FilterType;
typename FilterType::Pointer filter = FilterType::New();
// InputImageType::Pointer itkImage;
typename OutputImageType::Pointer itkBinaryResultImage;
filter->SetInput(itkImage);
filter->SetLowerThreshold(m_SelectedLabels[0]);
filter->SetUpperThreshold(m_SelectedLabels[0]);
filter->SetInsideValue(1);
filter->SetOutsideValue(0);
filter->AddObserver(itk::ProgressEvent(), m_ProgressCommand);
filter->Update();
itkBinaryResultImage = filter->GetOutput();
itkBinaryResultImage->DisconnectPipeline();
// if more than one region id is used compute the union of all given binary regions
for (const auto labelID : m_SelectedLabels)
{
if (labelID != m_SelectedLabels[0])
{
filter->SetLowerThreshold(labelID);
filter->SetUpperThreshold(labelID);
filter->SetInsideValue(1);
filter->SetOutsideValue(0);
filter->Update();
typename OutputImageType::Pointer tempImage = filter->GetOutput();
typename itk::OrImageFilter<OutputImageType, OutputImageType>::Pointer orFilter =
itk::OrImageFilter<OutputImageType, OutputImageType>::New();
orFilter->SetInput1(tempImage);
orFilter->SetInput2(itkBinaryResultImage);
orFilter->AddObserver(itk::ProgressEvent(), m_ProgressCommand);
orFilter->UpdateLargestPossibleRegion();
itkBinaryResultImage = orFilter->GetOutput();
}
}
//----------------------------------------------------------------------------------------------------
segmentation->SetVolume((void*)(itkBinaryResultImage->GetPixelContainer()->GetBufferPointer()), timeStep);
}
diff --git a/Modules/Segmentation/Interactions/mitkAutoMLSegmentationWithPreviewTool.h b/Modules/Segmentation/Interactions/mitkAutoMLSegmentationWithPreviewTool.h
index 94163df1ad..878fd5592c 100644
--- a/Modules/Segmentation/Interactions/mitkAutoMLSegmentationWithPreviewTool.h
+++ b/Modules/Segmentation/Interactions/mitkAutoMLSegmentationWithPreviewTool.h
@@ -1,82 +1,82 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
#ifndef MITK_AUTO_ML_SEGMENTATION_WITH_PREVIEW_TOOL_H
#define MITK_AUTO_ML_SEGMENTATION_WITH_PREVIEW_TOOL_H
#include "mitkAutoSegmentationWithPreviewTool.h"
#include "mitkDataNode.h"
#include "mitkLabelSetImage.h"
#include <MitkSegmentationExports.h>
namespace mitk
{
/**
\brief Base class for any auto segmentation tool that provides a preview of the new segmentation and generates
segmentations with multiple labels.
This tool class implements the basic logic to handle previews of multi label segmentations and
to allow to pick arbitrary labels as selected and merge them to a single segmentation to store this
segmentation as confirmed segmentation.
\ingroup ToolManagerEtAl
\sa mitk::Tool
\sa QmitkInteractiveSegmentation
*/
class MITKSEGMENTATION_EXPORT AutoMLSegmentationWithPreviewTool : public AutoSegmentationWithPreviewTool
{
public:
mitkClassMacro(AutoMLSegmentationWithPreviewTool, AutoSegmentationWithPreviewTool);
void Activated() override;
void Deactivated() override;
using SelectedLabelVectorType = std::vector<Label::PixelType>;
void SetSelectedLabels(const SelectedLabelVectorType& regions);
SelectedLabelVectorType GetSelectedLabels() const;
const LabelSetImage* GetMLPreview() const;
protected:
AutoMLSegmentationWithPreviewTool();
~AutoMLSegmentationWithPreviewTool() = default;
void UpdateCleanUp() override;
- void DoUpdatePreview(const Image* inputAtTimeStep, Image* previewImage, TimeStepType timeStep) override;
+ void DoUpdatePreview(const Image* inputAtTimeStep, const Image* oldSegAtTimeStep, Image* previewImage, TimeStepType timeStep) override;
/** Function to generate the new multi lable preview for a given time step input image.
* The function must be implemented by derived tools.
* This function is called by DoUpdatePreview if needed.
* Reasons are:
* - ML preview does not exist
* - Modify time of tools is newer then of ML preview
* - ML preview was not generated for the current selected timestep of input image or for the current selected timepoint.*/
virtual LabelSetImage::Pointer ComputeMLPreview(const Image* inputAtTimeStep, TimeStepType timeStep) = 0;
private:
/** Function to generate a simple (single lable) preview by merging all labels of the ML preview that are selected and
* copies that single label preview to the passed previewImage.
* This function is called by DoUpdatePreview if needed.
* @param mlPreviewImage Multi label preview that is the source.
* @param previewImage Pointer to the single label preview image that should receive the merged selected labels.
* @timeStep Time step of the previewImage that should be filled.*/
template <typename TPixel, unsigned int VImageDimension>
void CalculateMergedSimplePreview(const itk::Image<TPixel, VImageDimension>* mlImage, mitk::Image* segmentation, unsigned int timeStep);
SelectedLabelVectorType m_SelectedLabels = {};
// holds the multilabel result as a preview image
mitk::DataNode::Pointer m_MLPreviewNode;
TimeStepType m_LastMLTimeStep = 0;
};
}
#endif
diff --git a/Modules/Segmentation/Interactions/mitkAutoSegmentationTool.cpp b/Modules/Segmentation/Interactions/mitkAutoSegmentationTool.cpp
index 647fa8b80d..a206b7c65e 100644
--- a/Modules/Segmentation/Interactions/mitkAutoSegmentationTool.cpp
+++ b/Modules/Segmentation/Interactions/mitkAutoSegmentationTool.cpp
@@ -1,130 +1,130 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
#include "mitkAutoSegmentationTool.h"
#include "mitkImage.h"
#include "mitkToolManager.h"
#include <mitkImageTimeSelector.h>
mitk::AutoSegmentationTool::AutoSegmentationTool() : Tool("dummy"), m_OverwriteExistingSegmentation(false)
{
}
mitk::AutoSegmentationTool::AutoSegmentationTool(const char* interactorType, const us::Module* interactorModule) : Tool(interactorType, interactorModule), m_OverwriteExistingSegmentation(false)
{
}
mitk::AutoSegmentationTool::~AutoSegmentationTool()
{
}
void mitk::AutoSegmentationTool::Activated()
{
Superclass::Activated();
m_NoneOverwriteTargetSegmentationNode = nullptr;
}
void mitk::AutoSegmentationTool::Deactivated()
{
m_NoneOverwriteTargetSegmentationNode = nullptr;
Superclass::Deactivated();
}
const char *mitk::AutoSegmentationTool::GetGroup() const
{
return "autoSegmentation";
}
mitk::Image::ConstPointer mitk::AutoSegmentationTool::GetImageByTimeStep(const mitk::Image* image, unsigned int timestep)
{
if (nullptr == image)
return image;
if (image->GetDimension() != 4)
return image;
mitk::ImageTimeSelector::Pointer imageTimeSelector = mitk::ImageTimeSelector::New();
imageTimeSelector->SetInput(image);
imageTimeSelector->SetTimeNr(static_cast<int>(timestep));
imageTimeSelector->UpdateLargestPossibleRegion();
return imageTimeSelector->GetOutput();
}
mitk::Image::ConstPointer mitk::AutoSegmentationTool::GetImageByTimePoint(const mitk::Image* image, TimePointType timePoint)
{
if (nullptr == image)
return image;
if (!image->GetTimeGeometry()->IsValidTimePoint(timePoint))
return nullptr;
return AutoSegmentationTool::GetImageByTimeStep(image, image->GetTimeGeometry()->TimePointToTimeStep(timePoint));
}
void mitk::AutoSegmentationTool::SetOverwriteExistingSegmentation(bool overwrite)
{
if (m_OverwriteExistingSegmentation != overwrite)
{
m_OverwriteExistingSegmentation = overwrite;
m_NoneOverwriteTargetSegmentationNode = nullptr;
}
}
std::string mitk::AutoSegmentationTool::GetCurrentSegmentationName()
{
- if (m_ToolManager->GetWorkingData(0))
- return m_ToolManager->GetWorkingData(0)->GetName();
+ if (this->GetToolManager()->GetWorkingData(0))
+ return this->GetToolManager()->GetWorkingData(0)->GetName();
else
return "";
}
mitk::DataNode *mitk::AutoSegmentationTool::GetTargetSegmentationNode() const
{
- mitk::DataNode::Pointer segmentationNode = m_ToolManager->GetWorkingData(0);
+ mitk::DataNode::Pointer segmentationNode = this->GetToolManager()->GetWorkingData(0);
if (!m_OverwriteExistingSegmentation)
{
if (m_NoneOverwriteTargetSegmentationNode.IsNull())
{
- mitk::DataNode::Pointer refNode = m_ToolManager->GetReferenceData(0);
+ mitk::DataNode::Pointer refNode = this->GetToolManager()->GetReferenceData(0);
if (refNode.IsNull())
{
// TODO create and use segmentation exceptions instead!!
MITK_ERROR << "No valid reference data!";
return nullptr;
}
std::string nodename = refNode->GetName() + "_" + this->GetName();
mitk::Color color;
color.SetRed(1);
color.SetBlue(0);
color.SetGreen(0);
//create a new segmentation node based on the current segmentation as template
m_NoneOverwriteTargetSegmentationNode = CreateEmptySegmentationNode(dynamic_cast<mitk::Image*>(segmentationNode->GetData()), nodename, color);
}
segmentationNode = m_NoneOverwriteTargetSegmentationNode;
}
return segmentationNode;
}
void mitk::AutoSegmentationTool::EnsureTargetSegmentationNodeInDataStorage() const
{
auto targetNode = this->GetTargetSegmentationNode();
- if (!m_ToolManager->GetDataStorage()->Exists(targetNode))
+ if (!this->GetToolManager()->GetDataStorage()->Exists(targetNode))
{
- m_ToolManager->GetDataStorage()->Add(targetNode, m_ToolManager->GetReferenceData(0));
+ this->GetToolManager()->GetDataStorage()->Add(targetNode, this->GetToolManager()->GetReferenceData(0));
}
}
diff --git a/Modules/Segmentation/Interactions/mitkAutoSegmentationWithPreviewTool.cpp b/Modules/Segmentation/Interactions/mitkAutoSegmentationWithPreviewTool.cpp
index adfa517175..e19770ed6a 100644
--- a/Modules/Segmentation/Interactions/mitkAutoSegmentationWithPreviewTool.cpp
+++ b/Modules/Segmentation/Interactions/mitkAutoSegmentationWithPreviewTool.cpp
@@ -1,523 +1,549 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
#include "mitkAutoSegmentationWithPreviewTool.h"
#include "mitkToolManager.h"
#include "mitkColorProperty.h"
#include "mitkLevelWindowProperty.h"
#include "mitkProperties.h"
#include "mitkDataStorage.h"
#include "mitkRenderingManager.h"
#include <mitkSliceNavigationController.h>
#include "mitkImageAccessByItk.h"
#include "mitkImageCast.h"
#include "mitkImageStatisticsHolder.h"
#include "mitkImageTimeSelector.h"
#include "mitkLabelSetImage.h"
#include "mitkMaskAndCutRoiImageFilter.h"
#include "mitkPadImageFilter.h"
#include "mitkNodePredicateGeometry.h"
#include "mitkSegTool2D.h"
mitk::AutoSegmentationWithPreviewTool::AutoSegmentationWithPreviewTool(bool lazyDynamicPreviews): m_LazyDynamicPreviews(lazyDynamicPreviews)
{
m_ProgressCommand = mitk::ToolCommand::New();
}
mitk::AutoSegmentationWithPreviewTool::AutoSegmentationWithPreviewTool(bool lazyDynamicPreviews, const char* interactorType, const us::Module* interactorModule) : AutoSegmentationTool(interactorType, interactorModule), m_LazyDynamicPreviews(lazyDynamicPreviews)
{
m_ProgressCommand = mitk::ToolCommand::New();
}
mitk::AutoSegmentationWithPreviewTool::~AutoSegmentationWithPreviewTool()
{
}
bool mitk::AutoSegmentationWithPreviewTool::CanHandle(const BaseData* referenceData, const BaseData* workingData) const
{
if (!Superclass::CanHandle(referenceData, workingData))
return false;
if (workingData == nullptr)
return true;
auto* labelSet = dynamic_cast<const LabelSetImage*>(workingData);
if (labelSet != nullptr)
return true;
auto* image = dynamic_cast<const Image*>(workingData);
if (image == nullptr)
return false;
//if it is a normal image and not a label set image is used as working data
//it must have the same pixel type as a label set.
return MakeScalarPixelType< DefaultSegmentationDataType >() == image->GetPixelType();
}
void mitk::AutoSegmentationWithPreviewTool::Activated()
{
Superclass::Activated();
- m_ToolManager->RoiDataChanged +=
+ this->GetToolManager()->RoiDataChanged +=
mitk::MessageDelegate<mitk::AutoSegmentationWithPreviewTool>(this, &mitk::AutoSegmentationWithPreviewTool::OnRoiDataChanged);
- m_ToolManager->SelectedTimePointChanged +=
+ this->GetToolManager()->SelectedTimePointChanged +=
mitk::MessageDelegate<mitk::AutoSegmentationWithPreviewTool>(this, &mitk::AutoSegmentationWithPreviewTool::OnTimePointChanged);
- m_ReferenceDataNode = m_ToolManager->GetReferenceData(0);
+ m_ReferenceDataNode = this->GetToolManager()->GetReferenceData(0);
m_SegmentationInputNode = m_ReferenceDataNode;
m_LastTimePointOfUpdate = mitk::RenderingManager::GetInstance()->GetTimeNavigationController()->GetSelectedTimePoint();
if (m_PreviewSegmentationNode.IsNull())
{
m_PreviewSegmentationNode = DataNode::New();
m_PreviewSegmentationNode->SetProperty("color", ColorProperty::New(0.0, 1.0, 0.0));
m_PreviewSegmentationNode->SetProperty("name", StringProperty::New(std::string(this->GetName())+" preview"));
m_PreviewSegmentationNode->SetProperty("opacity", FloatProperty::New(0.3));
m_PreviewSegmentationNode->SetProperty("binary", BoolProperty::New(true));
m_PreviewSegmentationNode->SetProperty("helper object", BoolProperty::New(true));
}
if (m_SegmentationInputNode.IsNotNull())
{
this->ResetPreviewNode();
this->InitiateToolByInput();
}
else
{
- m_ToolManager->ActivateTool(-1);
+ this->GetToolManager()->ActivateTool(-1);
}
}
void mitk::AutoSegmentationWithPreviewTool::Deactivated()
{
- m_ToolManager->RoiDataChanged -=
+ this->GetToolManager()->RoiDataChanged -=
mitk::MessageDelegate<mitk::AutoSegmentationWithPreviewTool>(this, &mitk::AutoSegmentationWithPreviewTool::OnRoiDataChanged);
- m_ToolManager->SelectedTimePointChanged -=
+ this->GetToolManager()->SelectedTimePointChanged -=
mitk::MessageDelegate<mitk::AutoSegmentationWithPreviewTool>(this, &mitk::AutoSegmentationWithPreviewTool::OnTimePointChanged);
m_SegmentationInputNode = nullptr;
m_ReferenceDataNode = nullptr;
m_WorkingPlaneGeometry = nullptr;
try
{
- if (DataStorage *storage = m_ToolManager->GetDataStorage())
+ if (DataStorage *storage = this->GetToolManager()->GetDataStorage())
{
storage->Remove(m_PreviewSegmentationNode);
RenderingManager::GetInstance()->RequestUpdateAll();
}
}
catch (...)
{
// don't care
}
if (m_PreviewSegmentationNode.IsNotNull())
{
m_PreviewSegmentationNode->SetData(nullptr);
}
Superclass::Deactivated();
}
void mitk::AutoSegmentationWithPreviewTool::ConfirmSegmentation()
{
if (m_LazyDynamicPreviews && m_CreateAllTimeSteps)
{ // The tool should create all time steps but is currently in lazy mode,
// thus ensure that a preview for all time steps is available.
this->UpdatePreview(true);
}
CreateResultSegmentationFromPreview();
RenderingManager::GetInstance()->RequestUpdateAll();
if (!m_KeepActiveAfterAccept)
{
- m_ToolManager->ActivateTool(-1);
+ this->GetToolManager()->ActivateTool(-1);
}
}
void mitk::AutoSegmentationWithPreviewTool::InitiateToolByInput()
{
//default implementation does nothing.
//implement in derived classes to change behavior
}
mitk::Image* mitk::AutoSegmentationWithPreviewTool::GetPreviewSegmentation()
{
if (m_PreviewSegmentationNode.IsNull())
{
return nullptr;
}
return dynamic_cast<Image*>(m_PreviewSegmentationNode->GetData());
}
mitk::DataNode* mitk::AutoSegmentationWithPreviewTool::GetPreviewSegmentationNode()
{
return m_PreviewSegmentationNode;
}
const mitk::Image* mitk::AutoSegmentationWithPreviewTool::GetSegmentationInput() const
{
if (m_SegmentationInputNode.IsNull())
{
return nullptr;
}
return dynamic_cast<const Image*>(m_SegmentationInputNode->GetData());
}
const mitk::Image* mitk::AutoSegmentationWithPreviewTool::GetReferenceData() const
{
if (m_ReferenceDataNode.IsNull())
{
return nullptr;
}
return dynamic_cast<const Image*>(m_ReferenceDataNode->GetData());
}
void mitk::AutoSegmentationWithPreviewTool::ResetPreviewNode()
{
itk::RGBPixel<float> previewColor;
previewColor[0] = 0.0f;
previewColor[1] = 1.0f;
previewColor[2] = 0.0f;
const auto image = this->GetSegmentationInput();
if (nullptr != image)
{
mitk::LabelSetImage::ConstPointer workingImage =
- dynamic_cast<const mitk::LabelSetImage *>(m_ToolManager->GetWorkingData(0)->GetData());
+ dynamic_cast<const mitk::LabelSetImage *>(this->GetToolManager()->GetWorkingData(0)->GetData());
if (workingImage.IsNotNull())
{
auto newPreviewImage = workingImage->Clone();
+ if (this->GetResetsToEmptyPreview())
+ {
+ newPreviewImage->ClearBuffer();
+ }
+
if (newPreviewImage.IsNull())
{
MITK_ERROR << "Cannot create preview helper objects. Unable to clone working image";
return;
}
m_PreviewSegmentationNode->SetData(newPreviewImage);
// Let's paint the feedback node green...
newPreviewImage->GetActiveLabel()->SetColor(previewColor);
newPreviewImage->GetActiveLabelSet()->UpdateLookupTable(newPreviewImage->GetActiveLabel()->GetValue());
}
else
{
- mitk::Image::ConstPointer workingImageBin = dynamic_cast<const mitk::Image*>(m_ToolManager->GetWorkingData(0)->GetData());
+ mitk::Image::ConstPointer workingImageBin = dynamic_cast<const mitk::Image*>(this->GetToolManager()->GetWorkingData(0)->GetData());
if (workingImageBin.IsNotNull())
{
- auto newPreviewImage = workingImageBin->Clone();
+ mitk::Image::Pointer newPreviewImage;
+ if (this->GetResetsToEmptyPreview())
+ {
+ newPreviewImage = mitk::Image::New();
+ newPreviewImage->Initialize(workingImageBin);
+ }
+ else
+ {
+ auto newPreviewImage = workingImageBin->Clone();
+ }
if (newPreviewImage.IsNull())
{
MITK_ERROR << "Cannot create preview helper objects. Unable to clone working image";
return;
}
-
- m_PreviewSegmentationNode->SetData(newPreviewImage->Clone());
+ m_PreviewSegmentationNode->SetData(newPreviewImage);
}
else
{
mitkThrow() << "Tool is an invalid state. Cannot setup preview node. Working data is an unsupported class and should have not been accepted by CanHandle().";
}
}
m_PreviewSegmentationNode->SetColor(previewColor);
m_PreviewSegmentationNode->SetOpacity(0.5);
int layer(50);
m_ReferenceDataNode->GetIntProperty("layer", layer);
m_PreviewSegmentationNode->SetIntProperty("layer", layer + 1);
- if (DataStorage *ds = m_ToolManager->GetDataStorage())
+ if (DataStorage *ds = this->GetToolManager()->GetDataStorage())
{
if (!ds->Exists(m_PreviewSegmentationNode))
ds->Add(m_PreviewSegmentationNode, m_ReferenceDataNode);
}
}
}
template <typename TPixel, unsigned int VImageDimension>
static void ITKSetVolume(const itk::Image<TPixel, VImageDimension> *originalImage,
mitk::Image *segmentation,
unsigned int timeStep)
{
auto constPixelContainer = originalImage->GetPixelContainer();
//have to make a const cast because itk::PixelContainer does not provide a const correct access :(
auto pixelContainer = const_cast<typename itk::Image<TPixel, VImageDimension>::PixelContainer*>(constPixelContainer);
segmentation->SetVolume((void *)pixelContainer->GetBufferPointer(), timeStep);
}
void mitk::AutoSegmentationWithPreviewTool::TransferImageAtTimeStep(const Image* sourceImage, Image* destinationImage, const TimeStepType timeStep)
{
try
{
Image::ConstPointer sourceImageAtTimeStep = this->GetImageByTimeStep(sourceImage, timeStep);
if (sourceImageAtTimeStep->GetPixelType() != destinationImage->GetPixelType())
{
mitkThrow() << "Cannot transfer images. Tool is in an invalid state, source image and destination image do not have the same pixel type. "
<< "Source pixel type: " << sourceImage->GetPixelType().GetTypeAsString()
<< "; destination pixel type: " << destinationImage->GetPixelType().GetTypeAsString();
}
if (!Equal(*(sourceImage->GetGeometry(timeStep)), *(destinationImage->GetGeometry(timeStep)), NODE_PREDICATE_GEOMETRY_DEFAULT_CHECK_COORDINATE_PRECISION, NODE_PREDICATE_GEOMETRY_DEFAULT_CHECK_DIRECTION_PRECISION, false))
{
mitkThrow() << "Cannot transfer images. Tool is in an invalid state, source image and destination image do not have the same geometry.";
}
if (nullptr != this->GetWorkingPlaneGeometry())
{
auto sourceSlice = SegTool2D::GetAffectedImageSliceAs2DImage(this->GetWorkingPlaneGeometry(), sourceImage, timeStep);
SegTool2D::WriteBackSegmentationResult(this->GetTargetSegmentationNode(), m_WorkingPlaneGeometry, sourceSlice, timeStep);
}
else
{ //take care of the full segmentation volume
if (sourceImageAtTimeStep->GetDimension() == 2)
{
AccessFixedDimensionByItk_2(
sourceImageAtTimeStep, ITKSetVolume, 2, destinationImage, timeStep);
}
else
{
AccessFixedDimensionByItk_2(
sourceImageAtTimeStep, ITKSetVolume, 3, destinationImage, timeStep);
}
}
}
catch (...)
{
Tool::ErrorMessage("Error accessing single time steps of the original image. Cannot create segmentation.");
throw;
}
}
void mitk::AutoSegmentationWithPreviewTool::CreateResultSegmentationFromPreview()
{
const auto segInput = this->GetSegmentationInput();
auto previewImage = this->GetPreviewSegmentation();
if (nullptr != segInput && nullptr != previewImage)
{
DataNode::Pointer resultSegmentationNode = GetTargetSegmentationNode();
if (resultSegmentationNode.IsNotNull())
{
const auto timePoint = mitk::RenderingManager::GetInstance()->GetTimeNavigationController()->GetSelectedTimePoint();
auto resultSegmentation = dynamic_cast<Image*>(resultSegmentationNode->GetData());
// REMARK: the following code in this scope assumes that previewImage and resultSegmentation
// are clones of the working image (segmentation provided to the tool). Therefore they have
// the same time geometry.
if (previewImage->GetTimeSteps() != resultSegmentation->GetTimeSteps())
{
mitkThrow() << "Cannot perform threshold. Internal tool state is invalid."
<< " Preview segmentation and segmentation result image have different time geometries.";
}
if (m_CreateAllTimeSteps)
{
for (unsigned int timeStep = 0; timeStep < previewImage->GetTimeSteps(); ++timeStep)
{
this->TransferImageAtTimeStep(previewImage, resultSegmentation, timeStep);
}
}
else
{
const auto timeStep = resultSegmentation->GetTimeGeometry()->TimePointToTimeStep(timePoint);
this->TransferImageAtTimeStep(previewImage, resultSegmentation, timeStep);
}
// since we are maybe working on a smaller image, pad it to the size of the original image
if (m_ReferenceDataNode.GetPointer() != m_SegmentationInputNode.GetPointer())
{
mitk::PadImageFilter::Pointer padFilter = mitk::PadImageFilter::New();
padFilter->SetInput(0, resultSegmentation);
padFilter->SetInput(1, dynamic_cast<mitk::Image*>(m_ReferenceDataNode->GetData()));
padFilter->SetBinaryFilter(true);
padFilter->SetUpperThreshold(1);
padFilter->SetLowerThreshold(1);
padFilter->Update();
resultSegmentationNode->SetData(padFilter->GetOutput());
}
-
- m_ToolManager->SetWorkingData(resultSegmentationNode);
- m_ToolManager->GetWorkingData(0)->Modified();
+ if (m_OverwriteExistingSegmentation)
+ { //if we overwrite the segmentation (and not just store it as a new result
+ //in the data storage) we update also the tool manager state.
+ this->GetToolManager()->SetWorkingData(resultSegmentationNode);
+ this->GetToolManager()->GetWorkingData(0)->Modified();
+ }
this->EnsureTargetSegmentationNodeInDataStorage();
}
}
}
void mitk::AutoSegmentationWithPreviewTool::OnRoiDataChanged()
{
- mitk::DataNode::ConstPointer node = m_ToolManager->GetRoiData(0);
+ mitk::DataNode::ConstPointer node = this->GetToolManager()->GetRoiData(0);
if (node.IsNotNull())
{
mitk::MaskAndCutRoiImageFilter::Pointer roiFilter = mitk::MaskAndCutRoiImageFilter::New();
mitk::Image::Pointer image = dynamic_cast<mitk::Image *>(m_SegmentationInputNode->GetData());
if (image.IsNull())
return;
roiFilter->SetInput(image);
roiFilter->SetRegionOfInterest(node->GetData());
roiFilter->Update();
mitk::DataNode::Pointer tmpNode = mitk::DataNode::New();
tmpNode->SetData(roiFilter->GetOutput());
m_SegmentationInputNode = tmpNode;
}
else
m_SegmentationInputNode = m_ReferenceDataNode;
this->ResetPreviewNode();
this->InitiateToolByInput();
this->UpdatePreview();
}
void mitk::AutoSegmentationWithPreviewTool::OnTimePointChanged()
{
if (m_IsTimePointChangeAware && m_PreviewSegmentationNode.IsNotNull() && m_SegmentationInputNode.IsNotNull())
{
const auto timePoint = mitk::RenderingManager::GetInstance()->GetTimeNavigationController()->GetSelectedTimePoint();
const bool isStaticSegOnDynamicImage = m_PreviewSegmentationNode->GetData()->GetTimeSteps() == 1 && m_SegmentationInputNode->GetData()->GetTimeSteps() > 1;
if (timePoint!=m_LastTimePointOfUpdate && (isStaticSegOnDynamicImage || m_LazyDynamicPreviews))
{ //we only need to update either because we are lazzy
//or because we have a static segmentation with a dynamic image
this->UpdatePreview();
}
}
}
void mitk::AutoSegmentationWithPreviewTool::UpdatePreview(bool ignoreLazyPreviewSetting)
{
const auto inputImage = this->GetSegmentationInput();
auto previewImage = this->GetPreviewSegmentation();
int progress_steps = 200;
+ const auto workingImage = dynamic_cast<const mitk::Image*>(this->GetToolManager()->GetWorkingData(0)->GetData());
+
this->CurrentlyBusy.Send(true);
m_IsUpdating = true;
this->UpdatePrepare();
const auto timePoint = mitk::RenderingManager::GetInstance()->GetTimeNavigationController()->GetSelectedTimePoint();
try
{
if (nullptr != inputImage && nullptr != previewImage)
{
m_ProgressCommand->AddStepsToDo(progress_steps);
if (previewImage->GetTimeSteps() > 1 && (ignoreLazyPreviewSetting || !m_LazyDynamicPreviews))
{
for (unsigned int timeStep = 0; timeStep < previewImage->GetTimeSteps(); ++timeStep)
{
Image::ConstPointer feedBackImage;
+ Image::ConstPointer currentSegImage;
+
auto previewTimePoint = previewImage->GetTimeGeometry()->TimeStepToTimePoint(timeStep);
auto inputTimeStep = inputImage->GetTimeGeometry()->TimePointToTimeStep(previewTimePoint);
if (nullptr != this->GetWorkingPlaneGeometry())
{ //only extract a specific slice defined by the working plane as feedback image.
feedBackImage = SegTool2D::GetAffectedImageSliceAs2DImage(this->GetWorkingPlaneGeometry(), inputImage, inputTimeStep);
+ currentSegImage = SegTool2D::GetAffectedImageSliceAs2DImageByTimePoint(this->GetWorkingPlaneGeometry(), workingImage, previewTimePoint);
}
else
{ //work on the whole feedback image
feedBackImage = this->GetImageByTimeStep(inputImage, inputTimeStep);
+ currentSegImage = this->GetImageByTimePoint(workingImage, previewTimePoint);
}
- this->DoUpdatePreview(feedBackImage, previewImage, timeStep);
+ this->DoUpdatePreview(feedBackImage, currentSegImage, previewImage, timeStep);
}
}
else
{
Image::ConstPointer feedBackImage;
+ Image::ConstPointer currentSegImage;
+
if (nullptr != this->GetWorkingPlaneGeometry())
{
feedBackImage = SegTool2D::GetAffectedImageSliceAs2DImageByTimePoint(this->GetWorkingPlaneGeometry(), inputImage, timePoint);
+ currentSegImage = SegTool2D::GetAffectedImageSliceAs2DImageByTimePoint(this->GetWorkingPlaneGeometry(), workingImage, timePoint);
}
else
{
feedBackImage = this->GetImageByTimePoint(inputImage, timePoint);
+ currentSegImage = this->GetImageByTimePoint(workingImage, timePoint);
}
auto timeStep = previewImage->GetTimeGeometry()->TimePointToTimeStep(timePoint);
- this->DoUpdatePreview(feedBackImage, previewImage, timeStep);
+ this->DoUpdatePreview(feedBackImage, currentSegImage, previewImage, timeStep);
}
RenderingManager::GetInstance()->RequestUpdateAll();
}
}
catch (itk::ExceptionObject & excep)
{
MITK_ERROR << "Exception caught: " << excep.GetDescription();
m_ProgressCommand->SetProgress(progress_steps);
std::string msg = excep.GetDescription();
ErrorMessage.Send(msg);
}
catch (...)
{
m_ProgressCommand->SetProgress(progress_steps);
m_IsUpdating = false;
CurrentlyBusy.Send(false);
throw;
}
this->UpdateCleanUp();
m_LastTimePointOfUpdate = timePoint;
m_ProgressCommand->SetProgress(progress_steps);
m_IsUpdating = false;
CurrentlyBusy.Send(false);
}
bool mitk::AutoSegmentationWithPreviewTool::IsUpdating() const
{
return m_IsUpdating;
}
void mitk::AutoSegmentationWithPreviewTool::UpdatePrepare()
{
// default implementation does nothing
//reimplement in derived classes for special behavior
}
void mitk::AutoSegmentationWithPreviewTool::UpdateCleanUp()
{
// default implementation does nothing
//reimplement in derived classes for special behavior
}
mitk::TimePointType mitk::AutoSegmentationWithPreviewTool::GetLastTimePointOfUpdate() const
{
return m_LastTimePointOfUpdate;
}
diff --git a/Modules/Segmentation/Interactions/mitkAutoSegmentationWithPreviewTool.h b/Modules/Segmentation/Interactions/mitkAutoSegmentationWithPreviewTool.h
index b3cad84572..aabe1c032f 100644
--- a/Modules/Segmentation/Interactions/mitkAutoSegmentationWithPreviewTool.h
+++ b/Modules/Segmentation/Interactions/mitkAutoSegmentationWithPreviewTool.h
@@ -1,169 +1,186 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
#ifndef mitkAutoSegmentationWithPreviewTool_h_Included
#define mitkAutoSegmentationWithPreviewTool_h_Included
#include "mitkAutoSegmentationTool.h"
#include "mitkCommon.h"
#include "mitkDataNode.h"
#include "mitkToolCommand.h"
#include <MitkSegmentationExports.h>
namespace mitk
{
/**
\brief Base class for any auto segmentation tool that provides a preview of the new segmentation.
This tool class implements a lot basic logic to handle auto segmentation tools with preview,
Time point and ROI support. Derived classes will ask to update the segmentation preview if needed
(e.g. because the ROI or the current time point has changed) or because derived tools
indicated the need to update themselves.
This class also takes care to properly transfer a confirmed preview into the segementation
result.
\ingroup ToolManagerEtAl
\sa mitk::Tool
\sa QmitkInteractiveSegmentation
*/
class MITKSEGMENTATION_EXPORT AutoSegmentationWithPreviewTool : public AutoSegmentationTool
{
public:
mitkClassMacro(AutoSegmentationWithPreviewTool, AutoSegmentationTool);
void Activated() override;
void Deactivated() override;
void ConfirmSegmentation();
itkSetMacro(CreateAllTimeSteps, bool);
itkGetMacro(CreateAllTimeSteps, bool);
itkBooleanMacro(CreateAllTimeSteps);
itkSetMacro(KeepActiveAfterAccept, bool);
itkGetMacro(KeepActiveAfterAccept, bool);
itkBooleanMacro(KeepActiveAfterAccept);
itkSetMacro(IsTimePointChangeAware, bool);
itkGetMacro(IsTimePointChangeAware, bool);
itkBooleanMacro(IsTimePointChangeAware);
+ itkSetMacro(ResetsToEmptyPreview, bool);
+ itkGetMacro(ResetsToEmptyPreview, bool);
+ itkBooleanMacro(ResetsToEmptyPreview);
+
bool CanHandle(const BaseData* referenceData, const BaseData* workingData) const override;
/** Triggers the actualization of the preview
* @param ignoreLazyPreviewSetting If set true UpdatePreview will always
* generate the preview for all time steps. If set to false, UpdatePreview
* will regard the setting specified by the constructor.
* To define the update generation for time steps implement DoUpdatePreview.
* To alter what should be done directly before or after the update of the preview,
* reimplement UpdatePrepare() or UpdateCleanUp().*/
void UpdatePreview(bool ignoreLazyPreviewSetting = false);
/** Indicate if currently UpdatePreview is triggered (true) or not (false).*/
bool IsUpdating() const;
protected:
mitk::ToolCommand::Pointer m_ProgressCommand;
/** Member is always called if GetSegmentationInput() has changed
* (e.g. because a new ROI was defined, or on activation) to give derived
* classes the posibility to initiate their state accordingly.
* Reimplement this function to implement special behavior.
*/
virtual void InitiateToolByInput();
+ /** This member function offers derived classes the possibility to alter what should
+ happen directly before the update of the preview is performed. It is called by
+ UpdatePreview. Default implementation does nothing.*/
virtual void UpdatePrepare();
+
+ /** This member function offers derived classes the possibility to alter what should
+ happen directly after the update of the preview is performed. It is called by
+ UpdatePreview. Default implementation does nothing.*/
virtual void UpdateCleanUp();
/** This function does the real work. Here the preview for a given
* input image should be computed and stored in the also passed
* preview image at the passed time step.
+ * It also provides the current/old segmentation at the time point,
+ * which can be used, if the preview depends on the the segmenation so far.
*/
- virtual void DoUpdatePreview(const Image* inputAtTimeStep, Image* previewImage, TimeStepType timeStep) = 0;
+ virtual void DoUpdatePreview(const Image* inputAtTimeStep, const Image* oldSegAtTimeStep, Image* previewImage, TimeStepType timeStep) = 0;
AutoSegmentationWithPreviewTool(bool lazyDynamicPreviews = false); // purposely hidden
AutoSegmentationWithPreviewTool(bool lazyDynamicPreviews, const char* interactorType, const us::Module* interactorModule = nullptr); // purposely hidden
~AutoSegmentationWithPreviewTool() override;
/** Returns the image that contains the preview of the current segmentation.
* Returns null if the node is not set or does not contain an image.*/
Image* GetPreviewSegmentation();
DataNode* GetPreviewSegmentationNode();
/** Returns the input that should be used for any segmentation/preview or tool update.
* It is either the data of ReferenceDataNode itself or a part of it defined by a ROI mask
* provided by the tool manager. Derived classes should regard this as the relevant
* input data for any processing.
* Returns null if the node is not set or does not contain an image.*/
const Image* GetSegmentationInput() const;
/** Returns the image that is provided by the ReferenceDataNode.
* Returns null if the node is not set or does not contain an image.*/
const Image* GetReferenceData() const;
/** Resets the preview node so it is empty and ready to be filled by the tool*/
void ResetPreviewNode();
TimePointType GetLastTimePointOfUpdate() const;
itkSetObjectMacro(WorkingPlaneGeometry, PlaneGeometry);
itkGetConstObjectMacro(WorkingPlaneGeometry, PlaneGeometry);
private:
void TransferImageAtTimeStep(const Image* sourceImage, Image* destinationImage, const TimeStepType timeStep);
void CreateResultSegmentationFromPreview();
void OnRoiDataChanged();
void OnTimePointChanged();
/** Node that containes the preview data generated and managed by this class or derived ones.*/
DataNode::Pointer m_PreviewSegmentationNode;
/** The reference data recieved from ToolManager::GetReferenceData when tool was activated.*/
DataNode::Pointer m_ReferenceDataNode;
/** Node that containes the data that should be used as input for any auto segmentation. It might
* be the same like m_ReferenceDataNode (if no ROI is set) or a sub region (if ROI is set).*/
DataNode::Pointer m_SegmentationInputNode;
/** Indicates if Accepting the threshold should transfer/create the segmentations
of all time steps (true) or only of the currently selected timepoint (false).*/
bool m_CreateAllTimeSteps = false;
/** Indicates if the tool should kept active after accepting the segmentation or not.*/
bool m_KeepActiveAfterAccept = false;
/** Relevant if the working data / preview image has multiple time steps (dynamic segmentations).
* This flag has to be set by derived classes accordingly to there way to generate dynamic previews.
* If LazyDynamicPreview is true, the tool generates only the preview for the current time step.
* Therefore it always has to update the preview if current time point has changed and it has to (re)compute
* all timeframes if ConfirmSegmentation() is called.*/
bool m_LazyDynamicPreviews = false;
bool m_IsTimePointChangeAware = true;
+ /** Controls if ResetPreviewNode generates an empty content (true) or clones the current
+ segmentation (false).*/
+ bool m_ResetsToEmptyPreview = false;
+
TimePointType m_LastTimePointOfUpdate = 0.;
bool m_IsUpdating = false;
/** This variable indicates if for the tool a working plane geometry is defined.
* If a working plane is defined the tool will only work an the slice of the input
* and the segmentation. Thus only the relevant input slice will be passed to
* DoUpdatePreview(...) and only the relevant slice of the preview will be transfered when
* ConfirmSegmentation() is called.*/
PlaneGeometry::Pointer m_WorkingPlaneGeometry;
};
} // namespace
#endif
diff --git a/Modules/Segmentation/Interactions/mitkBinaryThresholdBaseTool.cpp b/Modules/Segmentation/Interactions/mitkBinaryThresholdBaseTool.cpp
index a8ee655db0..40c2a088b6 100644
--- a/Modules/Segmentation/Interactions/mitkBinaryThresholdBaseTool.cpp
+++ b/Modules/Segmentation/Interactions/mitkBinaryThresholdBaseTool.cpp
@@ -1,126 +1,126 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
#include "mitkBinaryThresholdBaseTool.h"
#include "mitkImageAccessByItk.h"
#include "mitkImageCast.h"
#include "mitkImageStatisticsHolder.h"
#include "mitkLabelSetImage.h"
#include <itkBinaryThresholdImageFilter.h>
#include <itkImageRegionIterator.h>
mitk::BinaryThresholdBaseTool::BinaryThresholdBaseTool()
: m_SensibleMinimumThresholdValue(-100),
m_SensibleMaximumThresholdValue(+100),
m_CurrentLowerThresholdValue(1),
m_CurrentUpperThresholdValue(1)
{
}
mitk::BinaryThresholdBaseTool::~BinaryThresholdBaseTool()
{
}
void mitk::BinaryThresholdBaseTool::SetThresholdValues(double lower, double upper)
{
/* If value is not in the min/max range, do nothing. In that case, this
method will be called again with a proper value right after. The only
known case where this happens is with an [0.0, 1.0[ image, where value
could be an epsilon greater than the max. */
if (lower < m_SensibleMinimumThresholdValue
|| lower > m_SensibleMaximumThresholdValue
|| upper < m_SensibleMinimumThresholdValue
|| upper > m_SensibleMaximumThresholdValue)
{
return;
}
m_CurrentLowerThresholdValue = lower;
m_CurrentUpperThresholdValue = upper;
if (nullptr != this->GetPreviewSegmentation())
{
UpdatePreview();
}
}
void mitk::BinaryThresholdBaseTool::InitiateToolByInput()
{
const auto referenceImage = this->GetReferenceData();
if (nullptr != referenceImage)
{
m_SensibleMinimumThresholdValue = std::numeric_limits<ScalarType>::max();
m_SensibleMaximumThresholdValue = std::numeric_limits<ScalarType>::lowest();
Image::StatisticsHolderPointer statistics = referenceImage->GetStatistics();
for (unsigned int ts = 0; ts < referenceImage->GetTimeSteps(); ++ts)
{
m_SensibleMinimumThresholdValue = std::min(m_SensibleMinimumThresholdValue, static_cast<double>(statistics->GetScalarValueMin()));
m_SensibleMaximumThresholdValue = std::max(m_SensibleMaximumThresholdValue, static_cast<double>(statistics->GetScalarValueMax()));
}
if (m_LockedUpperThreshold)
{
m_CurrentLowerThresholdValue = (m_SensibleMaximumThresholdValue + m_SensibleMinimumThresholdValue) / 2.0;
m_CurrentUpperThresholdValue = m_SensibleMaximumThresholdValue;
}
else
{
double range = m_SensibleMaximumThresholdValue - m_SensibleMinimumThresholdValue;
m_CurrentLowerThresholdValue = m_SensibleMinimumThresholdValue + range / 3.0;
m_CurrentUpperThresholdValue = m_SensibleMinimumThresholdValue + 2 * range / 3.0;
}
bool isFloatImage = false;
if ((referenceImage->GetPixelType().GetPixelType() == itk::ImageIOBase::SCALAR) &&
(referenceImage->GetPixelType().GetComponentType() == itk::ImageIOBase::FLOAT ||
referenceImage->GetPixelType().GetComponentType() == itk::ImageIOBase::DOUBLE))
{
isFloatImage = true;
}
IntervalBordersChanged.Send(m_SensibleMinimumThresholdValue, m_SensibleMaximumThresholdValue, isFloatImage);
ThresholdingValuesChanged.Send(m_CurrentLowerThresholdValue, m_CurrentUpperThresholdValue);
}
}
template <typename TPixel, unsigned int VImageDimension>
static void ITKThresholding(const itk::Image<TPixel, VImageDimension> *originalImage,
mitk::Image *segmentation,
double lower,
double upper,
unsigned int timeStep)
{
typedef itk::Image<TPixel, VImageDimension> ImageType;
typedef itk::Image<mitk::Tool::DefaultSegmentationDataType, VImageDimension> SegmentationType;
typedef itk::BinaryThresholdImageFilter<ImageType, SegmentationType> ThresholdFilterType;
typename ThresholdFilterType::Pointer filter = ThresholdFilterType::New();
filter->SetInput(originalImage);
filter->SetLowerThreshold(lower);
filter->SetUpperThreshold(upper);
filter->SetInsideValue(1);
filter->SetOutsideValue(0);
filter->Update();
segmentation->SetVolume((void *)(filter->GetOutput()->GetPixelContainer()->GetBufferPointer()), timeStep);
}
-void mitk::BinaryThresholdBaseTool::DoUpdatePreview(const Image* inputAtTimeStep, Image* previewImage, TimeStepType timeStep)
+void mitk::BinaryThresholdBaseTool::DoUpdatePreview(const Image* inputAtTimeStep, const Image* /*oldSegAtTimeStep*/, Image* previewImage, TimeStepType timeStep)
{
if (nullptr != inputAtTimeStep && nullptr != previewImage)
{
AccessByItk_n(inputAtTimeStep,
ITKThresholding,
(previewImage, m_CurrentLowerThresholdValue, m_CurrentUpperThresholdValue, timeStep));
}
}
diff --git a/Modules/Segmentation/Interactions/mitkBinaryThresholdBaseTool.h b/Modules/Segmentation/Interactions/mitkBinaryThresholdBaseTool.h
index cdc15f18be..7eb15979c4 100644
--- a/Modules/Segmentation/Interactions/mitkBinaryThresholdBaseTool.h
+++ b/Modules/Segmentation/Interactions/mitkBinaryThresholdBaseTool.h
@@ -1,70 +1,70 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
#ifndef mitkBinaryThresholdBaseTool_h_Included
#define mitkBinaryThresholdBaseTool_h_Included
#include "mitkAutoSegmentationWithPreviewTool.h"
#include "mitkCommon.h"
#include "mitkDataNode.h"
#include <MitkSegmentationExports.h>
#include <itkBinaryThresholdImageFilter.h>
#include <itkImage.h>
namespace mitk
{
/**
\brief Base class for binary threshold tools.
\ingroup ToolManagerEtAl
\sa mitk::Tool
\sa QmitkInteractiveSegmentation
*/
class MITKSEGMENTATION_EXPORT BinaryThresholdBaseTool : public AutoSegmentationWithPreviewTool
{
public:
Message3<double, double, bool> IntervalBordersChanged;
Message2<mitk::ScalarType, mitk::ScalarType> ThresholdingValuesChanged;
mitkClassMacro(BinaryThresholdBaseTool, AutoSegmentationWithPreviewTool);
virtual void SetThresholdValues(double lower, double upper);
protected:
BinaryThresholdBaseTool(); // purposely hidden
~BinaryThresholdBaseTool() override;
itkSetMacro(LockedUpperThreshold, bool);
itkGetMacro(LockedUpperThreshold, bool);
itkBooleanMacro(LockedUpperThreshold);
itkGetMacro(SensibleMinimumThresholdValue, ScalarType);
itkGetMacro(SensibleMaximumThresholdValue, ScalarType);
void InitiateToolByInput() override;
- void DoUpdatePreview(const Image* inputAtTimeStep, Image* previewImage, TimeStepType timeStep) override;
+ void DoUpdatePreview(const Image* inputAtTimeStep, const Image* oldSegAtTimeStep, Image* previewImage, TimeStepType timeStep) override;
private:
ScalarType m_SensibleMinimumThresholdValue;
ScalarType m_SensibleMaximumThresholdValue;
ScalarType m_CurrentLowerThresholdValue;
ScalarType m_CurrentUpperThresholdValue;
/** Indicates if the tool should behave like a single threshold tool (true)
or like a upper/lower threshold tool (false)*/
bool m_LockedUpperThreshold = false;
};
} // namespace
#endif
diff --git a/Modules/Segmentation/Interactions/mitkCalculateGrayValueStatisticsTool.cpp b/Modules/Segmentation/Interactions/mitkCalculateGrayValueStatisticsTool.cpp
index 18db43a60a..77eae790c0 100644
--- a/Modules/Segmentation/Interactions/mitkCalculateGrayValueStatisticsTool.cpp
+++ b/Modules/Segmentation/Interactions/mitkCalculateGrayValueStatisticsTool.cpp
@@ -1,332 +1,332 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
#include "mitkCalculateGrayValueStatisticsTool.h"
#include "mitkCalculateGrayValueStatisticsTool.xpm"
#include "mitkImageAccessByItk.h"
#include "mitkImageCast.h"
#include "mitkImageTimeSelector.h"
#include "mitkProgressBar.h"
#include "mitkStatusBar.h"
#include "mitkToolManager.h"
#include <itkCommand.h>
#include <itkHistogram.h>
namespace mitk
{
MITK_TOOL_MACRO(MITKSEGMENTATION_EXPORT, CalculateGrayValueStatisticsTool, "Statistics tool");
}
mitk::CalculateGrayValueStatisticsTool::CalculateGrayValueStatisticsTool()
{
}
mitk::CalculateGrayValueStatisticsTool::~CalculateGrayValueStatisticsTool()
{
}
const char **mitk::CalculateGrayValueStatisticsTool::GetXPM() const
{
return mitkCalculateGrayValueStatisticsTool_xpm;
}
const char *mitk::CalculateGrayValueStatisticsTool::GetName() const
{
return "Statistics";
}
std::string mitk::CalculateGrayValueStatisticsTool::GetErrorMessage()
{
return "No statistics generated for these segmentations:";
}
void mitk::CalculateGrayValueStatisticsTool::StartProcessingAllData()
{
// clear/prepare report
m_CompleteReport.str("");
}
bool mitk::CalculateGrayValueStatisticsTool::ProcessOneWorkingData(DataNode *node)
{
if (node)
{
Image::Pointer image = dynamic_cast<Image *>(node->GetData());
if (image.IsNull())
return false;
- DataNode *referencenode = m_ToolManager->GetReferenceData(0);
+ DataNode *referencenode = this->GetToolManager()->GetReferenceData(0);
if (!referencenode)
return false;
try
{
ProgressBar::GetInstance()->AddStepsToDo(1);
// add to report
std::string nodename("structure");
node->GetName(nodename);
std::string message = "Calculating statistics for ";
message += nodename;
StatusBar::GetInstance()->DisplayText(message.c_str());
Image::Pointer refImage = dynamic_cast<Image *>(referencenode->GetData());
Image::Pointer image = dynamic_cast<Image *>(node->GetData());
m_CompleteReport << "======== Gray value analysis of " << nodename << " ========\n";
if (image.IsNotNull() && refImage.IsNotNull())
{
for (unsigned int timeStep = 0; timeStep < image->GetTimeSteps(); ++timeStep)
{
ImageTimeSelector::Pointer timeSelector = ImageTimeSelector::New();
timeSelector->SetInput(refImage);
timeSelector->SetTimeNr(timeStep);
timeSelector->UpdateLargestPossibleRegion();
Image::Pointer refImage3D = timeSelector->GetOutput();
ImageTimeSelector::Pointer timeSelector2 = ImageTimeSelector::New();
timeSelector2->SetInput(image);
timeSelector2->SetTimeNr(timeStep);
timeSelector2->UpdateLargestPossibleRegion();
Image::Pointer image3D = timeSelector2->GetOutput();
if (image3D.IsNotNull() && refImage3D.IsNotNull())
{
m_CompleteReport << "=== " << nodename << ", time step " << timeStep << " ===\n";
AccessFixedDimensionByItk_2(refImage3D, ITKHistogramming, 3, image3D, m_CompleteReport);
}
}
}
m_CompleteReport << "======== End of analysis for " << nodename << " ===========\n\n\n";
ProgressBar::GetInstance()->Progress();
}
catch (...)
{
return false;
}
}
return true;
}
void mitk::CalculateGrayValueStatisticsTool::FinishProcessingAllData()
{
SegmentationsProcessingTool::FinishProcessingAllData();
// show/send results
StatisticsCompleted.Send();
// MITK_INFO << m_CompleteReport.str() << std::endl;
}
#define ROUND_P(x) ((int)((x) + 0.5))
template <typename TPixel, unsigned int VImageDimension>
void mitk::CalculateGrayValueStatisticsTool::CalculateMinMax(itk::Image<TPixel, VImageDimension> *referenceImage,
Image *segmentation,
TPixel &minimum,
TPixel &maximum)
{
typedef itk::Image<TPixel, VImageDimension> ImageType;
typedef itk::Image<Tool::DefaultSegmentationDataType, VImageDimension> SegmentationType;
typename SegmentationType::Pointer segmentationItk;
CastToItkImage(segmentation, segmentationItk);
typename SegmentationType::RegionType segmentationRegion = segmentationItk->GetLargestPossibleRegion();
segmentationRegion.Crop(referenceImage->GetLargestPossibleRegion());
itk::ImageRegionConstIteratorWithIndex<SegmentationType> segmentationIterator(segmentationItk, segmentationRegion);
itk::ImageRegionConstIteratorWithIndex<ImageType> referenceIterator(referenceImage, segmentationRegion);
segmentationIterator.GoToBegin();
referenceIterator.GoToBegin();
minimum = std::numeric_limits<TPixel>::max();
maximum = std::numeric_limits<TPixel>::min();
while (!segmentationIterator.IsAtEnd())
{
itk::Point<float, 3> pt;
segmentationItk->TransformIndexToPhysicalPoint(segmentationIterator.GetIndex(), pt);
typename ImageType::IndexType ind;
itk::ContinuousIndex<float, 3> contInd;
if (referenceImage->TransformPhysicalPointToContinuousIndex(pt, contInd))
{
for (unsigned int i = 0; i < 3; ++i)
ind[i] = ROUND_P(contInd[i]);
referenceIterator.SetIndex(ind);
if (segmentationIterator.Get() > 0)
{
if (referenceIterator.Get() < minimum)
minimum = referenceIterator.Get();
if (referenceIterator.Get() > maximum)
maximum = referenceIterator.Get();
}
}
++segmentationIterator;
}
}
template <typename TPixel, unsigned int VImageDimension>
void mitk::CalculateGrayValueStatisticsTool::ITKHistogramming(itk::Image<TPixel, VImageDimension> *referenceImage,
Image *segmentation,
std::stringstream &report)
{
typedef itk::Image<TPixel, VImageDimension> ImageType;
typedef itk::Image<Tool::DefaultSegmentationDataType, VImageDimension> SegmentationType;
typename SegmentationType::Pointer segmentationItk;
CastToItkImage(segmentation, segmentationItk);
// generate histogram
typename SegmentationType::RegionType segmentationRegion = segmentationItk->GetLargestPossibleRegion();
segmentationRegion.Crop(referenceImage->GetLargestPossibleRegion());
itk::ImageRegionConstIteratorWithIndex<SegmentationType> segmentationIterator(segmentationItk, segmentationRegion);
itk::ImageRegionConstIteratorWithIndex<ImageType> referenceIterator(referenceImage, segmentationRegion);
segmentationIterator.GoToBegin();
referenceIterator.GoToBegin();
m_ITKHistogram = HistogramType::New();
TPixel minimum = std::numeric_limits<TPixel>::max();
TPixel maximum = std::numeric_limits<TPixel>::min();
CalculateMinMax(referenceImage, segmentation, minimum, maximum);
// initialize the histogram to the range of the cropped region
HistogramType::SizeType size;
#if defined(ITK_USE_REVIEW_STATISTICS)
typedef typename HistogramType::SizeType::ValueType HSizeValueType;
#else
typedef typename HistogramType::SizeType::SizeValueType HSizeValueType;
#endif
size.Fill(static_cast<HSizeValueType>(maximum - minimum + 1));
HistogramType::MeasurementVectorType lowerBound;
HistogramType::MeasurementVectorType upperBound;
lowerBound[0] = minimum;
upperBound[0] = maximum;
m_ITKHistogram->Initialize(size, lowerBound, upperBound);
double mean(0.0);
double sd(0.0);
double voxelCount(0.0);
// iterate through the cropped region add the values to the histogram
while (!segmentationIterator.IsAtEnd())
{
itk::Point<float, 3> pt;
segmentationItk->TransformIndexToPhysicalPoint(segmentationIterator.GetIndex(), pt);
typename ImageType::IndexType ind;
itk::ContinuousIndex<float, 3> contInd;
if (referenceImage->TransformPhysicalPointToContinuousIndex(pt, contInd))
{
for (unsigned int i = 0; i < 3; ++i)
ind[i] = ROUND_P(contInd[i]);
referenceIterator.SetIndex(ind);
if (segmentationIterator.Get() > 0)
{
HistogramType::MeasurementVectorType currentMeasurementVector;
currentMeasurementVector[0] = static_cast<HistogramType::MeasurementType>(referenceIterator.Get());
m_ITKHistogram->IncreaseFrequencyOfMeasurement(currentMeasurementVector, 1);
mean = (mean * (static_cast<double>(voxelCount) /
static_cast<double>(voxelCount + 1))) // 3 points: old center * 2/3 + currentPoint * 1/3;
+ static_cast<double>(referenceIterator.Get()) / static_cast<double>(voxelCount + 1);
voxelCount += 1.0;
}
}
++segmentationIterator;
}
// second pass for SD
segmentationIterator.GoToBegin();
referenceIterator.GoToBegin();
while (!segmentationIterator.IsAtEnd())
{
itk::Point<float, 3> pt;
segmentationItk->TransformIndexToPhysicalPoint(segmentationIterator.GetIndex(), pt);
typename ImageType::IndexType ind;
itk::ContinuousIndex<float, 3> contInd;
if (referenceImage->TransformPhysicalPointToContinuousIndex(pt, contInd))
{
for (unsigned int i = 0; i < 3; ++i)
ind[i] = ROUND_P(contInd[i]);
referenceIterator.SetIndex(ind);
if (segmentationIterator.Get() > 0)
{
sd += ((static_cast<double>(referenceIterator.Get()) - mean) *
(static_cast<double>(referenceIterator.Get()) - mean));
}
}
++segmentationIterator;
}
sd /= static_cast<double>(voxelCount - 1);
sd = sqrt(sd);
// generate quantiles
TPixel histogramQuantileValues[5];
histogramQuantileValues[0] = m_ITKHistogram->Quantile(0, 0.05);
histogramQuantileValues[1] = m_ITKHistogram->Quantile(0, 0.25);
histogramQuantileValues[2] = m_ITKHistogram->Quantile(0, 0.50);
histogramQuantileValues[3] = m_ITKHistogram->Quantile(0, 0.75);
histogramQuantileValues[4] = m_ITKHistogram->Quantile(0, 0.95);
// report histogram values
std::locale C("C");
std::locale originalLocale = report.getloc();
report.imbue(C);
report << " Minimum:" << minimum << "\n 5% quantile: " << histogramQuantileValues[0]
<< "\n 25% quantile: " << histogramQuantileValues[1] << "\n 50% quantile: " << histogramQuantileValues[2]
<< "\n 75% quantile: " << histogramQuantileValues[3] << "\n 95% quantile: " << histogramQuantileValues[4]
<< "\n Maximum: " << maximum << "\n Mean: " << mean << "\n SD: " << sd << "\n";
report.imbue(originalLocale);
}
std::string mitk::CalculateGrayValueStatisticsTool::GetReport() const
{
return m_CompleteReport.str();
}
mitk::CalculateGrayValueStatisticsTool::HistogramType::ConstPointer
mitk::CalculateGrayValueStatisticsTool::GetHistogram()
{
return m_ITKHistogram.GetPointer();
}
diff --git a/Modules/Segmentation/Interactions/mitkCalculateVolumetryTool.cpp b/Modules/Segmentation/Interactions/mitkCalculateVolumetryTool.cpp
index 57e1e69a67..f5b53f6c3a 100644
--- a/Modules/Segmentation/Interactions/mitkCalculateVolumetryTool.cpp
+++ b/Modules/Segmentation/Interactions/mitkCalculateVolumetryTool.cpp
@@ -1,86 +1,86 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
#include "mitkCalculateVolumetryTool.h"
#include "mitkCalculateVolumetryTool.xpm"
#include "mitkProperties.h"
#include "mitkToolManager.h"
#include "mitkVolumeCalculator.h"
namespace mitk
{
MITK_TOOL_MACRO(MITKSEGMENTATION_EXPORT, CalculateVolumetryTool, "Volumetry tool");
}
mitk::CalculateVolumetryTool::CalculateVolumetryTool()
{
}
mitk::CalculateVolumetryTool::~CalculateVolumetryTool()
{
}
const char **mitk::CalculateVolumetryTool::GetXPM() const
{
return mitkCalculateVolumetryTool_xpm;
}
const char *mitk::CalculateVolumetryTool::GetName() const
{
return "Volumetry";
}
std::string mitk::CalculateVolumetryTool::GetErrorMessage()
{
return "Volume could not be calculated for these nodes:";
}
bool mitk::CalculateVolumetryTool::ProcessOneWorkingData(DataNode *node)
{
if (node)
{
Image::Pointer image = dynamic_cast<Image *>(node->GetData());
if (image.IsNull())
return false;
if (image->GetDimension() == 4)
{
Tool::ErrorMessage("Volumetry only valid for timestep 0! Bug #1280");
}
VolumeCalculator::Pointer volumetryFilter = VolumeCalculator::New();
volumetryFilter->SetImage(image);
volumetryFilter->SetThreshold(1); // comparison is >=
try
{
volumetryFilter->ComputeVolume();
float volumeInTimeStep0 = volumetryFilter->GetVolume();
node->SetProperty("volume", FloatProperty::New(volumeInTimeStep0));
}
catch (...)
{
return false;
}
}
return true;
}
void mitk::CalculateVolumetryTool::FinishProcessingAllData()
{
Superclass::FinishProcessingAllData();
- m_ToolManager->NodePropertiesChanged();
+ this->GetToolManager()->NodePropertiesChanged();
}
diff --git a/Modules/Segmentation/Interactions/mitkCreateSurfaceTool.cpp b/Modules/Segmentation/Interactions/mitkCreateSurfaceTool.cpp
index 4fa399745d..0e5bcfbe90 100644
--- a/Modules/Segmentation/Interactions/mitkCreateSurfaceTool.cpp
+++ b/Modules/Segmentation/Interactions/mitkCreateSurfaceTool.cpp
@@ -1,98 +1,98 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
#include "mitkCreateSurfaceTool.h"
#include "mitkCreateSurfaceTool.xpm"
#include "mitkProgressBar.h"
#include "mitkShowSegmentationAsSurface.h"
#include "mitkStatusBar.h"
#include "mitkToolManager.h"
#include "itkCommand.h"
namespace mitk
{
MITK_TOOL_MACRO(MITKSEGMENTATION_EXPORT, CreateSurfaceTool, "Surface creation tool");
}
mitk::CreateSurfaceTool::CreateSurfaceTool()
{
}
mitk::CreateSurfaceTool::~CreateSurfaceTool()
{
}
const char **mitk::CreateSurfaceTool::GetXPM() const
{
return mitkCreateSurfaceTool_xpm;
}
const char *mitk::CreateSurfaceTool::GetName() const
{
return "Surface";
}
std::string mitk::CreateSurfaceTool::GetErrorMessage()
{
return "No surfaces created for these segmentations:";
}
bool mitk::CreateSurfaceTool::ProcessOneWorkingData(DataNode *node)
{
if (node)
{
Image::Pointer image = dynamic_cast<Image *>(node->GetData());
if (image.IsNull())
return false;
try
{
mitk::ShowSegmentationAsSurface::Pointer surfaceFilter = mitk::ShowSegmentationAsSurface::New();
// attach observer to get notified about result
itk::SimpleMemberCommand<CreateSurfaceTool>::Pointer goodCommand =
itk::SimpleMemberCommand<CreateSurfaceTool>::New();
goodCommand->SetCallbackFunction(this, &CreateSurfaceTool::OnSurfaceCalculationDone);
surfaceFilter->AddObserver(mitk::ResultAvailable(), goodCommand);
itk::SimpleMemberCommand<CreateSurfaceTool>::Pointer badCommand =
itk::SimpleMemberCommand<CreateSurfaceTool>::New();
badCommand->SetCallbackFunction(this, &CreateSurfaceTool::OnSurfaceCalculationDone);
surfaceFilter->AddObserver(mitk::ProcessingError(), badCommand);
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_ToolManager->GetDataStorage());
+ surfaceFilter->SetDataStorage(*this->GetToolManager()->GetDataStorage());
ProgressBar::GetInstance()->AddStepsToDo(1);
StatusBar::GetInstance()->DisplayText("Surface creation started in background...");
surfaceFilter->StartAlgorithm();
}
catch (...)
{
return false;
}
}
return true;
}
void mitk::CreateSurfaceTool::OnSurfaceCalculationDone()
{
ProgressBar::GetInstance()->Progress();
- m_ToolManager->NewNodesGenerated();
+ this->GetToolManager()->NewNodesGenerated();
}
diff --git a/Modules/Segmentation/Interactions/mitkFastMarchingBaseTool.cpp b/Modules/Segmentation/Interactions/mitkFastMarchingBaseTool.cpp
index 1ded558ddc..e74291e8a9 100644
--- a/Modules/Segmentation/Interactions/mitkFastMarchingBaseTool.cpp
+++ b/Modules/Segmentation/Interactions/mitkFastMarchingBaseTool.cpp
@@ -1,335 +1,330 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
#include "mitkFastMarchingBaseTool.h"
#include "mitkToolManager.h"
#include "mitkBaseRenderer.h"
#include "mitkInteractionConst.h"
#include "mitkRenderingManager.h"
#include "mitkInteractionPositionEvent.h"
#include "mitkImageAccessByItk.h"
#include "mitkSegTool2D.h"
#include <mitkImageCast.h>
// itk filter
#include "itkBinaryThresholdImageFilter.h"
#include "itkCurvatureAnisotropicDiffusionImageFilter.h"
#include "itkGradientMagnitudeRecursiveGaussianImageFilter.h"
#include "itkSigmoidImageFilter.h"
+#include "itkFastMarchingImageFilter.h"
// us
#include <usGetModuleContext.h>
#include <usModule.h>
#include <usModuleContext.h>
#include <usModuleResource.h>
mitk::FastMarchingBaseTool::FastMarchingBaseTool(unsigned int toolDim)
: AutoSegmentationWithPreviewTool(false, "FastMarchingTool"),
m_LowerThreshold(0),
m_UpperThreshold(200),
m_StoppingValue(100),
m_Sigma(1.0),
m_Alpha(-0.5),
m_Beta(3.0),
m_ToolDimension(toolDim)
{
}
mitk::FastMarchingBaseTool::~FastMarchingBaseTool()
{
}
bool mitk::FastMarchingBaseTool::CanHandle(const BaseData* referenceData, const BaseData* workingData) const
{
if(!Superclass::CanHandle(referenceData, workingData))
return false;
if (referenceData == nullptr)
return false;
auto *image = dynamic_cast<const Image *>(referenceData);
if (image == nullptr)
return false;
if (image->GetDimension() < 3)
return false;
return true;
}
const char **mitk::FastMarchingBaseTool::GetXPM() const
{
return nullptr; // mitkFastMarchingBaseTool_xpm;
}
us::ModuleResource mitk::FastMarchingBaseTool::GetIconResource() const
{
us::Module *module = us::GetModuleContext()->GetModule();
us::ModuleResource resource = module->GetResource("FastMarching_48x48.png");
return resource;
}
us::ModuleResource mitk::FastMarchingBaseTool::GetCursorIconResource() const
{
us::Module* module = us::GetModuleContext()->GetModule();
us::ModuleResource resource = module->GetResource("FastMarching_Cursor_32x32.png");
return resource;
}
void mitk::FastMarchingBaseTool::SetUpperThreshold(double value)
{
m_UpperThreshold = value / 10.0;
}
void mitk::FastMarchingBaseTool::SetLowerThreshold(double value)
{
m_LowerThreshold = value / 10.0;
}
void mitk::FastMarchingBaseTool::SetBeta(double value)
{
if (m_Beta != value)
{
m_Beta = value;
}
}
void mitk::FastMarchingBaseTool::SetSigma(double value)
{
if (m_Sigma != value)
{
if (value > 0.0)
{
m_Sigma = value;
}
}
}
void mitk::FastMarchingBaseTool::SetAlpha(double value)
{
if (m_Alpha != value)
{
m_Alpha = value;
}
}
void mitk::FastMarchingBaseTool::SetStoppingValue(double value)
{
if (m_StoppingValue != value)
{
m_StoppingValue = value;
}
}
void mitk::FastMarchingBaseTool::Activated()
{
Superclass::Activated();
m_SeedsAsPointSet = mitk::PointSet::New();
//ensure that the seed points are visible for all timepoints.
dynamic_cast<ProportionalTimeGeometry*>(m_SeedsAsPointSet->GetTimeGeometry())->SetStepDuration(std::numeric_limits<TimePointType>::max());
m_SeedsAsPointSetNode = mitk::DataNode::New();
m_SeedsAsPointSetNode->SetData(m_SeedsAsPointSet);
m_SeedsAsPointSetNode->SetName(std::string(this->GetName()) + "_PointSet");
m_SeedsAsPointSetNode->SetBoolProperty("helper object", true);
m_SeedsAsPointSetNode->SetColor(0.0, 1.0, 0.0);
m_SeedsAsPointSetNode->SetVisibility(true);
- m_ToolManager->GetDataStorage()->Add(m_SeedsAsPointSetNode, m_ToolManager->GetWorkingData(0));
+ this->GetDataStorage()->Add(m_SeedsAsPointSetNode, this->GetToolManager()->GetWorkingData(0));
}
void mitk::FastMarchingBaseTool::Deactivated()
{
this->ClearSeeds();
- m_ToolManager->GetDataStorage()->Remove(m_SeedsAsPointSetNode);
+ this->GetDataStorage()->Remove(m_SeedsAsPointSetNode);
m_SeedsAsPointSetNode = nullptr;
m_SeedsAsPointSet = nullptr;
Superclass::Deactivated();
}
void mitk::FastMarchingBaseTool::ConnectActionsAndFunctions()
{
CONNECT_FUNCTION("ShiftSecondaryButtonPressed", OnAddPoint);
CONNECT_FUNCTION("ShiftPrimaryButtonPressed", OnAddPoint);
CONNECT_FUNCTION("DeletePoint", OnDelete);
}
void mitk::FastMarchingBaseTool::OnAddPoint(StateMachineAction*, InteractionEvent* interactionEvent)
{
if (!this->IsUpdating() && m_SeedsAsPointSet.IsNotNull())
{
const auto positionEvent = dynamic_cast<mitk::InteractionPositionEvent*>(interactionEvent);
if (positionEvent != nullptr)
{
auto workingPlaneGeometry = positionEvent->GetSender()->GetCurrentWorldPlaneGeometry();
// if click was on another plane and we are in 2D mode we should reset the seeds
if (m_ToolDimension == 2 && ( nullptr == this->GetWorkingPlaneGeometry() || !this->GetWorkingPlaneGeometry()->IsOnPlane(workingPlaneGeometry)))
{
this->ClearSeeds();
this->SetWorkingPlaneGeometry(workingPlaneGeometry->Clone());
}
m_SeedsAsPointSet->InsertPoint(m_SeedsAsPointSet->GetSize(), positionEvent->GetPositionInWorld());
-
- mitk::RenderingManager::GetInstance()->RequestUpdateAll();
-
this->UpdatePreview();
}
}
}
void mitk::FastMarchingBaseTool::OnDelete(StateMachineAction*, InteractionEvent* /*interactionEvent*/)
{
if (!this->IsUpdating() && m_SeedsAsPointSet.IsNotNull())
{
// delete last seed point
if (this->m_SeedsAsPointSet->GetSize() > 0)
{
m_SeedsAsPointSet->RemovePointAtEnd(0);
-
- mitk::RenderingManager::GetInstance()->RequestUpdateAll();
-
this->UpdatePreview();
}
}
}
void mitk::FastMarchingBaseTool::ClearSeeds()
{
if (this->m_SeedsAsPointSet.IsNotNull())
{
// renew pointset
this->m_SeedsAsPointSet = mitk::PointSet::New();
//ensure that the seed points are visible for all timepoints.
dynamic_cast<ProportionalTimeGeometry*>(m_SeedsAsPointSet->GetTimeGeometry())->SetStepDuration(std::numeric_limits<TimePointType>::max());
this->m_SeedsAsPointSetNode->SetData(this->m_SeedsAsPointSet);
}
}
template <typename TPixel, unsigned int VImageDimension>
void mitk::FastMarchingBaseTool::DoITKFastMarching(const itk::Image<TPixel, VImageDimension>* inputImage,
Image* previewImage, unsigned int timeStep, const BaseGeometry* inputGeometry)
{
// typedefs for itk pipeline
typedef itk::Image<TPixel, VImageDimension> InputImageType;
typedef float InternalPixelType;
typedef itk::Image<InternalPixelType, VImageDimension> InternalImageType;
typedef mitk::Tool::DefaultSegmentationDataType OutputPixelType;
typedef itk::Image<OutputPixelType, VImageDimension> OutputImageType;
typedef itk::CurvatureAnisotropicDiffusionImageFilter<InputImageType, InternalImageType> SmoothingFilterType;
typedef itk::GradientMagnitudeRecursiveGaussianImageFilter<InternalImageType, InternalImageType> GradientFilterType;
typedef itk::SigmoidImageFilter<InternalImageType, InternalImageType> SigmoidFilterType;
typedef itk::BinaryThresholdImageFilter<InternalImageType, OutputImageType> ThresholdingFilterType;
typedef itk::FastMarchingImageFilter<InternalImageType, InternalImageType> FastMarchingFilterType;
typedef typename FastMarchingFilterType::NodeContainer NodeContainer;
typedef typename FastMarchingFilterType::NodeType NodeType;
//convert point set seed into trialpoint
typename NodeContainer::Pointer trialPoints = NodeContainer::New();
trialPoints->Initialize();
for (auto pos = m_SeedsAsPointSet->Begin(); pos != m_SeedsAsPointSet->End(); ++pos)
{
mitk::Point3D clickInIndex;
inputGeometry->WorldToIndex(pos->Value(), clickInIndex);
itk::Index<VImageDimension> seedPosition;
for (unsigned int dim = 0; dim < VImageDimension; ++dim)
{
seedPosition[dim] = clickInIndex[dim];
}
NodeType node;
const double seedValue = 0.0;
node.SetValue(seedValue);
node.SetIndex(seedPosition);
trialPoints->InsertElement(trialPoints->Size(), node);
}
// assemble pipeline
auto smoothFilter = SmoothingFilterType::New();
smoothFilter->AddObserver(itk::ProgressEvent(), m_ProgressCommand);
smoothFilter->SetTimeStep(0.05);
smoothFilter->SetNumberOfIterations(2);
smoothFilter->SetConductanceParameter(9.0);
auto gradientMagnitudeFilter = GradientFilterType::New();
gradientMagnitudeFilter->AddObserver(itk::ProgressEvent(), m_ProgressCommand);
gradientMagnitudeFilter->SetSigma(m_Sigma);
auto sigmoidFilter = SigmoidFilterType::New();
sigmoidFilter->AddObserver(itk::ProgressEvent(), m_ProgressCommand);
sigmoidFilter->SetAlpha(m_Alpha);
sigmoidFilter->SetBeta(m_Beta);
sigmoidFilter->SetOutputMinimum(0.0);
sigmoidFilter->SetOutputMaximum(1.0);
auto fastMarchingFilter = FastMarchingFilterType::New();
fastMarchingFilter->AddObserver(itk::ProgressEvent(), m_ProgressCommand);
fastMarchingFilter->SetStoppingValue(m_StoppingValue);
fastMarchingFilter->SetTrialPoints(trialPoints);
auto thresholdFilter = ThresholdingFilterType::New();
thresholdFilter->SetLowerThreshold(m_LowerThreshold);
thresholdFilter->SetUpperThreshold(m_UpperThreshold);
thresholdFilter->SetOutsideValue(0);
thresholdFilter->SetInsideValue(1.0);
// set up pipeline
smoothFilter->SetInput(inputImage);
gradientMagnitudeFilter->SetInput(smoothFilter->GetOutput());
sigmoidFilter->SetInput(gradientMagnitudeFilter->GetOutput());
fastMarchingFilter->SetInput(sigmoidFilter->GetOutput());
thresholdFilter->SetInput(fastMarchingFilter->GetOutput());
thresholdFilter->Update();
if (nullptr == this->GetWorkingPlaneGeometry())
{
previewImage->SetVolume((void*)(thresholdFilter->GetOutput()->GetPixelContainer()->GetBufferPointer()), timeStep);
}
else
{
mitk::Image::Pointer sliceImage = mitk::Image::New();
mitk::CastToMitkImage(thresholdFilter->GetOutput(), sliceImage);
SegTool2D::WriteSliceToVolume(previewImage, this->GetWorkingPlaneGeometry(), sliceImage, timeStep, false);
}
}
-void mitk::FastMarchingBaseTool::DoUpdatePreview(const Image* inputAtTimeStep, Image* previewImage, TimeStepType timeStep)
+void mitk::FastMarchingBaseTool::DoUpdatePreview(const Image* inputAtTimeStep, const Image* /*oldSegAtTimeStep*/, Image* previewImage, TimeStepType timeStep)
{
if (nullptr != inputAtTimeStep && nullptr != previewImage && m_SeedsAsPointSet.IsNotNull() && m_SeedsAsPointSet->GetSize()>0)
{
if (nullptr == this->GetWorkingPlaneGeometry())
{
AccessFixedDimensionByItk_n(inputAtTimeStep, DoITKFastMarching, 3, (previewImage, timeStep, inputAtTimeStep->GetGeometry()));
}
else
{
AccessFixedDimensionByItk_n(inputAtTimeStep, DoITKFastMarching, 2, (previewImage, timeStep, inputAtTimeStep->GetGeometry()));
}
}
}
diff --git a/Modules/Segmentation/Interactions/mitkFastMarchingBaseTool.h b/Modules/Segmentation/Interactions/mitkFastMarchingBaseTool.h
index ebec9fd0b2..68a4c6ffcb 100644
--- a/Modules/Segmentation/Interactions/mitkFastMarchingBaseTool.h
+++ b/Modules/Segmentation/Interactions/mitkFastMarchingBaseTool.h
@@ -1,118 +1,117 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
#ifndef mitkFastMarchingBaseTool_h_Included
#define mitkFastMarchingBaseTool_h_Included
#include "mitkAutoSegmentationWithPreviewTool.h"
#include "mitkDataNode.h"
#include "mitkPointSet.h"
#include "mitkPointSetDataInteractor.h"
#include "mitkToolCommand.h"
#include "itkImage.h"
-#include "itkFastMarchingImageFilter.h"
#include <MitkSegmentationExports.h>
namespace us
{
class ModuleResource;
}
namespace mitk
{
/**
\brief FastMarching semgentation tool base class.
The segmentation is done by setting one or more seed points on the image
and adapting the time range and threshold. The pipeline is:
Smoothing->GradientMagnitude->SigmoidFunction->FastMarching->Threshold
The resulting binary image is seen as a segmentation of an object.
For detailed documentation see ITK Software Guide section 9.3.1 Fast Marching Segmentation.
*/
class MITKSEGMENTATION_EXPORT FastMarchingBaseTool : public AutoSegmentationWithPreviewTool
{
public:
mitkClassMacro(FastMarchingBaseTool, AutoSegmentationWithPreviewTool);
bool CanHandle(const BaseData* referenceData, const BaseData* workingData) const override;
/* icon stuff */
const char **GetXPM() const override;
us::ModuleResource GetCursorIconResource() const override;
us::ModuleResource GetIconResource() const override;
void Activated() override;
void Deactivated() override;
/// \brief Set parameter used in Threshold filter.
void SetUpperThreshold(double);
/// \brief Set parameter used in Threshold filter.
void SetLowerThreshold(double);
/// \brief Set parameter used in Fast Marching filter.
void SetStoppingValue(double);
/// \brief Set parameter used in Gradient Magnitude filter.
void SetSigma(double);
/// \brief Set parameter used in Fast Marching filter.
void SetAlpha(double);
/// \brief Set parameter used in Fast Marching filter.
void SetBeta(double);
/// \brief Clear all seed points.
void ClearSeeds();
protected:
FastMarchingBaseTool(unsigned int toolDim);
~FastMarchingBaseTool() override;
void ConnectActionsAndFunctions() override;
/// \brief Add point action of StateMachine pattern
virtual void OnAddPoint(StateMachineAction*, InteractionEvent* interactionEvent);
/// \brief Delete action of StateMachine pattern
virtual void OnDelete(StateMachineAction*, InteractionEvent* interactionEvent);
- void DoUpdatePreview(const Image* inputAtTimeStep, Image* previewImage, TimeStepType timeStep) override;
+ void DoUpdatePreview(const Image* inputAtTimeStep, const Image* oldSegAtTimeStep, Image* previewImage, TimeStepType timeStep) override;
template <typename TPixel, unsigned int VImageDimension>
void DoITKFastMarching(const itk::Image<TPixel, VImageDimension>* inputImage,
Image* segmentation, unsigned int timeStep, const BaseGeometry* inputGeometry);
float m_LowerThreshold; // used in Threshold filter
float m_UpperThreshold; // used in Threshold filter
float m_StoppingValue; // used in Fast Marching filter
float m_Sigma; // used in GradientMagnitude filter
float m_Alpha; // used in Sigmoid filter
float m_Beta; // used in Sigmoid filter
DataNode::Pointer m_SeedsAsPointSetNode; // used to visualize the seed points
PointSet::Pointer m_SeedsAsPointSet;
private:
/** Indicating if the tool is used in 2D mode (just segment the current slice)
* or 3D mode (segment the whole current volume),*/
unsigned int m_ToolDimension;
};
} // namespace
#endif
diff --git a/Modules/Segmentation/Interactions/mitkFeedbackContourTool.cpp b/Modules/Segmentation/Interactions/mitkFeedbackContourTool.cpp
index c6eb82b51a..e37f014527 100644
--- a/Modules/Segmentation/Interactions/mitkFeedbackContourTool.cpp
+++ b/Modules/Segmentation/Interactions/mitkFeedbackContourTool.cpp
@@ -1,278 +1,278 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
#include "mitkFeedbackContourTool.h"
#include "mitkToolManager.h"
#include "mitkColorProperty.h"
#include "mitkProperties.h"
#include "mitkStringProperty.h"
#include "mitkBaseRenderer.h"
#include "mitkDataStorage.h"
#include "mitkRenderingManager.h"
#include "mitkAbstractTransformGeometry.h"
mitk::FeedbackContourTool::FeedbackContourTool(const char *type) : SegTool2D(type), m_FeedbackContourVisible(false)
{
m_FeedbackContourNode = DataNode::New();
m_FeedbackContourNode->SetProperty("name", StringProperty::New("One of FeedbackContourTool's feedback nodes"));
m_FeedbackContourNode->SetProperty("visible", BoolProperty::New(true));
m_FeedbackContourNode->SetProperty("helper object", BoolProperty::New(true));
m_FeedbackContourNode->SetProperty("layer", IntProperty::New(1000));
m_FeedbackContourNode->SetProperty("contour.project-onto-plane", BoolProperty::New(false));
m_FeedbackContourNode->SetProperty("contour.width", FloatProperty::New(1.0));
// set to max short, max int doesn't work, max value somewhere hardcoded?
m_FeedbackContourNode->SetProperty("layer", IntProperty::New(std::numeric_limits<short>::max()));
m_FeedbackContourNode->SetProperty("fixedLayer", BoolProperty::New(true));
this->InitializeFeedbackContour(true);
SetFeedbackContourColorDefault();
}
mitk::FeedbackContourTool::~FeedbackContourTool()
{
}
void mitk::FeedbackContourTool::SetFeedbackContourColor(float r, float g, float b)
{
m_FeedbackContourNode->SetProperty("contour.color", ColorProperty::New(r, g, b));
}
void mitk::FeedbackContourTool::SetFeedbackContourColorDefault()
{
m_FeedbackContourNode->SetProperty("contour.color", ColorProperty::New(0.0 / 255.0, 255.0 / 255.0, 0.0 / 255.0));
}
void mitk::FeedbackContourTool::Deactivated()
{
Superclass::Deactivated();
- DataStorage *storage = m_ToolManager->GetDataStorage();
+ DataStorage *storage = this->GetToolManager()->GetDataStorage();
if (storage && m_FeedbackContourNode.IsNotNull())
{
storage->Remove(m_FeedbackContourNode);
m_FeedbackContour->Clear();
SetFeedbackContourVisible(false);
}
}
void mitk::FeedbackContourTool::Activated()
{
Superclass::Activated();
this->InitializeFeedbackContour(true);
this->SetFeedbackContourVisible(true);
}
const mitk::ContourModel *mitk::FeedbackContourTool::GetFeedbackContour() const
{
return m_FeedbackContour;
}
void mitk::FeedbackContourTool::InitializeFeedbackContour(bool isClosed)
{
m_FeedbackContour = ContourModel::New();
m_FeedbackContour->SetClosed(isClosed);
auto workingImage = this->GetWorkingData();
if (nullptr != workingImage)
{
m_FeedbackContour->Expand(workingImage->GetTimeSteps());
auto contourTimeGeometry = workingImage->GetTimeGeometry()->Clone();
contourTimeGeometry->ReplaceTimeStepGeometries(m_FeedbackContour->GetGeometry());
m_FeedbackContour->SetTimeGeometry(contourTimeGeometry);
for (unsigned int t = 0; t < m_FeedbackContour->GetTimeSteps(); ++t)
{
m_FeedbackContour->SetClosed(isClosed, t);
}
}
m_FeedbackContourNode->SetData(m_FeedbackContour);
}
void mitk::FeedbackContourTool::ClearsCurrentFeedbackContour(bool isClosed)
{
if (!m_FeedbackContour->GetTimeGeometry()->IsValidTimePoint(this->GetLastTimePointTriggered()))
{
MITK_WARN << "Cannot clear feedback contour at current time step. Feedback contour is in invalid state as its time geometry does not support current selected time point. Invalid time point: " << this->GetLastTimePointTriggered();
return;
}
auto feedbackTimeStep = m_FeedbackContour->GetTimeGeometry()->TimePointToTimeStep(this->GetLastTimePointTriggered());
m_FeedbackContour->Clear(feedbackTimeStep);
m_FeedbackContour->SetClosed(isClosed, feedbackTimeStep);
}
void mitk::FeedbackContourTool::UpdateCurrentFeedbackContour(const ContourModel* sourceModel, TimeStepType sourceTimeStep)
{
if (nullptr == sourceModel)
return;
if (!m_FeedbackContour->GetTimeGeometry()->IsValidTimePoint(this->GetLastTimePointTriggered()))
{
MITK_WARN << "Cannot update feedback contour. Feedback contour is in invalid state as its time geometry does not support current selected time point. Invalid time point: "<<this->GetLastTimePointTriggered();
return;
}
auto feedbackTimeStep = m_FeedbackContour->GetTimeGeometry()->TimePointToTimeStep(this->GetLastTimePointTriggered());
this->UpdateFeedbackContour(sourceModel, feedbackTimeStep, sourceTimeStep);
}
void mitk::FeedbackContourTool::UpdateFeedbackContour(const ContourModel* sourceModel, TimeStepType feedbackTimeStep, TimeStepType sourceTimeStep)
{
if (nullptr == sourceModel)
return;
if (!sourceModel->GetTimeGeometry()->IsValidTimeStep(sourceTimeStep))
{
MITK_WARN << "Cannot update feedback contour. Source contour time geometry does not support passed time step. Invalid time step: " << sourceTimeStep;
return;
}
if (!m_FeedbackContour->GetTimeGeometry()->IsValidTimeStep(feedbackTimeStep))
{
MITK_WARN << "Cannot update feedback contour. Feedback contour time geometry does not support passed time step. Invalid time step: "<<feedbackTimeStep;
return;
}
m_FeedbackContour->UpdateContour(sourceModel, feedbackTimeStep, sourceTimeStep);
}
void mitk::FeedbackContourTool::AddVertexToCurrentFeedbackContour(const Point3D& point)
{
if (!m_FeedbackContour->GetTimeGeometry()->IsValidTimePoint(this->GetLastTimePointTriggered()))
{
MITK_WARN << "Cannot add vertex to feedback contour. Feedback contour is in invalid state as its time geometry does not support current selected time point. Invalid time point: " << this->GetLastTimePointTriggered();
return;
}
auto feedbackTimeStep = m_FeedbackContour->GetTimeGeometry()->TimePointToTimeStep(this->GetLastTimePointTriggered());
this->AddVertexToFeedbackContour(point, feedbackTimeStep);
};
/** Adds a vertex to the feedback contour for the passed time step. If time step is invalid, nothing will be added.*/
void mitk::FeedbackContourTool::AddVertexToFeedbackContour(const Point3D& point, TimeStepType feedbackTimeStep)
{
if (!m_FeedbackContour->GetTimeGeometry()->IsValidTimeStep(feedbackTimeStep))
{
MITK_WARN << "Cannot add vertex to feedback contour. Feedback contour time geometry does not support passed time step. Invalid time step: " << feedbackTimeStep;
return;
}
m_FeedbackContour->AddVertex(point, feedbackTimeStep);
}
void mitk::FeedbackContourTool::SetFeedbackContourVisible(bool visible)
{
if (m_FeedbackContourVisible == visible)
return; // nothing changed
- if (DataStorage *storage = m_ToolManager->GetDataStorage())
+ if (DataStorage *storage = this->GetToolManager()->GetDataStorage())
{
if (visible)
{
// Add the feedback contour node as a derived node of the first working data.
// If there is no working data, the node is added at the top level.
storage->Add(m_FeedbackContourNode, this->GetWorkingDataNode());
}
else
{
storage->Remove(m_FeedbackContourNode);
}
}
m_FeedbackContourVisible = visible;
}
mitk::ContourModel::Pointer mitk::FeedbackContourTool::ProjectContourTo2DSlice(const Image *slice,
const ContourModel *contourIn3D,
bool correctionForIpSegmentation,
bool constrainToInside)
{
return mitk::ContourModelUtils::ProjectContourTo2DSlice(
slice, contourIn3D, correctionForIpSegmentation, constrainToInside);
}
mitk::ContourModel::Pointer mitk::FeedbackContourTool::BackProjectContourFrom2DSlice(const BaseGeometry *sliceGeometry,
const ContourModel *contourIn2D,
bool correctionForIpSegmentation)
{
return mitk::ContourModelUtils::BackProjectContourFrom2DSlice(
sliceGeometry, contourIn2D, correctionForIpSegmentation);
}
void mitk::FeedbackContourTool::WriteBackFeedbackContourAsSegmentationResult(const InteractionPositionEvent* positionEvent, int paintingPixelValue, bool setInvisibleAfterSuccess)
{
if (!positionEvent)
return;
auto workingImage = this->GetWorkingData();
const auto planeGeometry((positionEvent->GetSender()->GetCurrentWorldPlaneGeometry()));
if (!workingImage || !planeGeometry)
return;
const auto* abstractTransformGeometry(
dynamic_cast<const AbstractTransformGeometry*>(positionEvent->GetSender()->GetCurrentWorldPlaneGeometry()));
if (nullptr != abstractTransformGeometry)
return;
Image::Pointer slice = FeedbackContourTool::GetAffectedWorkingSlice(positionEvent);
if (slice.IsNull())
{
MITK_ERROR << "Unable to extract slice." << std::endl;
return;
}
const auto feedbackContour = FeedbackContourTool::GetFeedbackContour();
auto contourTimeStep = positionEvent->GetSender()->GetTimeStep(feedbackContour);
ContourModel::Pointer projectedContour = FeedbackContourTool::ProjectContourTo2DSlice(
slice, feedbackContour, false, false); // false: don't add 0.5 (done by FillContourInSlice)
// false: don't constrain the contour to the image's inside
if (projectedContour.IsNull())
return;
auto activePixelValue = ContourModelUtils::GetActivePixelValue(workingImage);
mitk::ContourModelUtils::FillContourInSlice(
projectedContour, contourTimeStep, slice, workingImage, paintingPixelValue * activePixelValue);
this->WriteBackSegmentationResult(positionEvent, slice);
if (setInvisibleAfterSuccess)
{
this->SetFeedbackContourVisible(false);
}
}
void mitk::FeedbackContourTool::FillContourInSlice(ContourModel *projectedContour,
Image *sliceImage,
int paintingPixelValue)
{
this->FillContourInSlice(projectedContour, 0, sliceImage, paintingPixelValue);
}
void mitk::FeedbackContourTool::FillContourInSlice(ContourModel *projectedContour,
unsigned int timeStep,
Image *sliceImage,
int paintingPixelValue)
{
mitk::ContourModelUtils::FillContourInSlice(projectedContour, timeStep, sliceImage, sliceImage, paintingPixelValue);
}
diff --git a/Modules/Segmentation/Interactions/mitkLiveWireTool2D.cpp b/Modules/Segmentation/Interactions/mitkLiveWireTool2D.cpp
index 5870887320..9ba41907cd 100644
--- a/Modules/Segmentation/Interactions/mitkLiveWireTool2D.cpp
+++ b/Modules/Segmentation/Interactions/mitkLiveWireTool2D.cpp
@@ -1,620 +1,620 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
#include <mitkContourModelUtils.h>
#include <mitkLiveWireTool2D.h>
#include <mitkLiveWireTool2D.xpm>
#include <mitkToolManager.h>
#include <usGetModuleContext.h>
#include <usModuleResource.h>
#include <type_traits>
namespace mitk
{
MITK_TOOL_MACRO(MITKSEGMENTATION_EXPORT, LiveWireTool2D, "LiveWire tool");
}
mitk::LiveWireTool2D::LiveWireTool2D()
: SegTool2D("LiveWireTool"), m_CreateAndUseDynamicCosts(false)
{
}
mitk::LiveWireTool2D::~LiveWireTool2D()
{
this->ClearSegmentation();
}
void mitk::LiveWireTool2D::RemoveHelperObjects()
{
- auto dataStorage = m_ToolManager->GetDataStorage();
+ auto dataStorage = this->GetToolManager()->GetDataStorage();
if (nullptr == dataStorage)
return;
for (const auto &editingContour : m_EditingContours)
dataStorage->Remove(editingContour.first);
for (const auto &workingContour : m_WorkingContours)
dataStorage->Remove(workingContour.first);
if (m_EditingContourNode.IsNotNull())
dataStorage->Remove(m_EditingContourNode);
if (m_LiveWireContourNode.IsNotNull())
dataStorage->Remove(m_LiveWireContourNode);
if (m_ContourNode.IsNotNull())
dataStorage->Remove(m_ContourNode);
mitk::RenderingManager::GetInstance()->RequestUpdateAll();
}
void mitk::LiveWireTool2D::ReleaseHelperObjects()
{
this->RemoveHelperObjects();
m_EditingContours.clear();
m_WorkingContours.clear();
m_EditingContourNode = nullptr;
m_EditingContour = nullptr;
m_LiveWireContourNode = nullptr;
m_LiveWireContour = nullptr;
m_ContourNode = nullptr;
m_Contour = nullptr;
}
void mitk::LiveWireTool2D::ReleaseInteractors()
{
this->EnableContourLiveWireInteraction(false);
m_LiveWireInteractors.clear();
}
void mitk::LiveWireTool2D::ConnectActionsAndFunctions()
{
CONNECT_CONDITION("CheckContourClosed", OnCheckPoint);
CONNECT_FUNCTION("InitObject", OnInitLiveWire);
CONNECT_FUNCTION("AddPoint", OnAddPoint);
CONNECT_FUNCTION("CtrlAddPoint", OnAddPoint);
CONNECT_FUNCTION("MovePoint", OnMouseMoveNoDynamicCosts);
CONNECT_FUNCTION("FinishContour", OnFinish);
CONNECT_FUNCTION("DeletePoint", OnLastSegmentDelete);
CONNECT_FUNCTION("CtrlMovePoint", OnMouseMoved);
}
const char **mitk::LiveWireTool2D::GetXPM() const
{
return mitkLiveWireTool2D_xpm;
}
us::ModuleResource mitk::LiveWireTool2D::GetIconResource() const
{
return us::GetModuleContext()->GetModule()->GetResource("LiveWire_48x48.png");
}
us::ModuleResource mitk::LiveWireTool2D::GetCursorIconResource() const
{
return us::GetModuleContext()->GetModule()->GetResource("LiveWire_Cursor_32x32.png");
}
const char *mitk::LiveWireTool2D::GetName() const
{
return "Live Wire";
}
void mitk::LiveWireTool2D::Activated()
{
Superclass::Activated();
this->ResetToStartState();
this->EnableContourLiveWireInteraction(true);
}
void mitk::LiveWireTool2D::Deactivated()
{
this->ConfirmSegmentation();
Superclass::Deactivated();
}
void mitk::LiveWireTool2D::UpdateLiveWireContour()
{
if (m_Contour.IsNotNull())
{
auto timeGeometry = m_Contour->GetTimeGeometry()->Clone();
m_LiveWireContour = this->m_LiveWireFilter->GetOutput();
m_LiveWireContour->SetTimeGeometry(timeGeometry); //needed because the results of the filter are always from 0 ms to 1 ms and the filter also resets its outputs.
m_LiveWireContourNode->SetData(this->m_LiveWireContour);
}
}
void mitk::LiveWireTool2D::OnTimePointChanged()
{
auto reference = this->GetReferenceData();
if (nullptr == reference || m_PlaneGeometry.IsNull() || m_LiveWireFilter.IsNull() || m_LiveWireContourNode.IsNull())
return;
auto timeStep = reference->GetTimeGeometry()->TimePointToTimeStep(this->GetLastTimePointTriggered());
m_ReferenceDataSlice = GetAffectedImageSliceAs2DImageByTimePoint(m_PlaneGeometry, reference, timeStep);
m_LiveWireFilter->SetInput(m_ReferenceDataSlice);
m_LiveWireFilter->Update();
this->UpdateLiveWireContour();
RenderingManager::GetInstance()->RequestUpdateAll();
};
void mitk::LiveWireTool2D::EnableContourLiveWireInteraction(bool on)
{
for (const auto &interactor : m_LiveWireInteractors)
interactor->EnableInteraction(on);
}
void mitk::LiveWireTool2D::ConfirmSegmentation()
{
auto referenceImage = this->GetReferenceData();
auto workingImage = this->GetWorkingData();
if (nullptr != referenceImage && nullptr != workingImage)
{
std::vector<SliceInformation> sliceInfos;
sliceInfos.reserve(m_WorkingContours.size());
const auto currentTimePoint = mitk::RenderingManager::GetInstance()->GetTimeNavigationController()->GetSelectedTimePoint();
TimeStepType workingImageTimeStep = workingImage->GetTimeGeometry()->TimePointToTimeStep(currentTimePoint);
for (const auto &workingContour : m_WorkingContours)
{
auto contour = dynamic_cast<ContourModel *>(workingContour.first->GetData());
if (nullptr == contour || contour->IsEmpty())
continue;
auto sameSlicePredicate = [&workingContour, workingImageTimeStep](const SliceInformation& si) { return workingContour.second->IsOnPlane(si.plane) && workingImageTimeStep == si.timestep; };
auto finding = std::find_if(sliceInfos.begin(), sliceInfos.end(), sameSlicePredicate);
if (finding == sliceInfos.end())
{
auto workingSlice = this->GetAffectedImageSliceAs2DImage(workingContour.second, workingImage, workingImageTimeStep)->Clone();
sliceInfos.emplace_back(workingSlice, workingContour.second, workingImageTimeStep);
finding = std::prev(sliceInfos.end());
}
//cast const away is OK in this case, because these are all slices created and manipulated
//localy in this function call. And we want to keep the high constness of SliceInformation for
//public interfaces.
auto workingSlice = const_cast<Image*>(finding->slice.GetPointer());
auto projectedContour = ContourModelUtils::ProjectContourTo2DSlice(workingSlice, contour, true, false);
int activePixelValue = ContourModelUtils::GetActivePixelValue(workingImage);
ContourModelUtils::FillContourInSlice(
projectedContour, workingSlice, workingImage, activePixelValue);
}
this->WriteBackSegmentationResults(sliceInfos);
}
this->ClearSegmentation();
}
void mitk::LiveWireTool2D::ClearSegmentation()
{
this->ReleaseHelperObjects();
this->ReleaseInteractors();
this->ResetToStartState();
}
bool mitk::LiveWireTool2D::IsPositionEventInsideImageRegion(mitk::InteractionPositionEvent *positionEvent,
mitk::BaseData *data)
{
bool isPositionEventInsideImageRegion = nullptr != data && data->GetGeometry()->IsInside(positionEvent->GetPositionInWorld());
if (!isPositionEventInsideImageRegion)
MITK_WARN("LiveWireTool2D") << "PositionEvent is outside ImageRegion!";
return isPositionEventInsideImageRegion;
}
mitk::ContourModel::Pointer mitk::LiveWireTool2D::CreateNewContour() const
{
auto workingData = this->GetWorkingData();
if (nullptr == workingData)
{
this->InteractiveSegmentationBugMessage("Cannot create new contour. No valid working data is set. Application is in invalid state.");
mitkThrow() << "Cannot create new contour. No valid working data is set. Application is in invalid state.";
}
auto contour = ContourModel::New();
//generate a time geometry that is always visible as the working contour should always be.
auto contourTimeGeometry = ProportionalTimeGeometry::New();
contourTimeGeometry->SetStepDuration(std::numeric_limits<TimePointType>::max());
contourTimeGeometry->SetTimeStepGeometry(contour->GetTimeGeometry()->GetGeometryForTimeStep(0)->Clone(), 0);
contour->SetTimeGeometry(contourTimeGeometry);
return contour;
}
void mitk::LiveWireTool2D::OnInitLiveWire(StateMachineAction *, InteractionEvent *interactionEvent)
{
auto positionEvent = dynamic_cast<mitk::InteractionPositionEvent *>(interactionEvent);
if (nullptr == positionEvent)
return;
auto workingDataNode = this->GetWorkingDataNode();
if (!IsPositionEventInsideImageRegion(positionEvent, workingDataNode->GetData()))
{
this->ResetToStartState();
return;
}
m_LastEventSender = positionEvent->GetSender();
m_LastEventSlice = m_LastEventSender->GetSlice();
m_Contour = this->CreateNewContour();
m_ContourNode = mitk::DataNode::New();
m_ContourNode->SetData(m_Contour);
m_ContourNode->SetName("working contour node");
m_ContourNode->SetProperty("layer", IntProperty::New(100));
m_ContourNode->AddProperty("fixedLayer", BoolProperty::New(true));
m_ContourNode->SetProperty("helper object", mitk::BoolProperty::New(true));
m_ContourNode->AddProperty("contour.color", ColorProperty::New(1.0f, 1.0f, 0.0f), nullptr, true);
m_ContourNode->AddProperty("contour.points.color", ColorProperty::New(1.0f, 0.0f, 0.1f), nullptr, true);
m_ContourNode->AddProperty("contour.controlpoints.show", BoolProperty::New(true), nullptr, true);
m_LiveWireContour = this->CreateNewContour();
m_LiveWireContourNode = mitk::DataNode::New();
m_LiveWireContourNode->SetData(m_LiveWireContour);
m_LiveWireContourNode->SetName("active livewire node");
m_LiveWireContourNode->SetProperty("layer", IntProperty::New(101));
m_LiveWireContourNode->AddProperty("fixedLayer", BoolProperty::New(true));
m_LiveWireContourNode->SetProperty("helper object", mitk::BoolProperty::New(true));
m_LiveWireContourNode->AddProperty("contour.color", ColorProperty::New(0.1f, 1.0f, 0.1f), nullptr, true);
m_LiveWireContourNode->AddProperty("contour.width", mitk::FloatProperty::New(4.0f), nullptr, true);
m_EditingContour = this->CreateNewContour();
m_EditingContourNode = mitk::DataNode::New();
m_EditingContourNode->SetData(m_EditingContour);
m_EditingContourNode->SetName("editing node");
m_EditingContourNode->SetProperty("layer", IntProperty::New(102));
m_EditingContourNode->AddProperty("fixedLayer", BoolProperty::New(true));
m_EditingContourNode->SetProperty("helper object", mitk::BoolProperty::New(true));
m_EditingContourNode->AddProperty("contour.color", ColorProperty::New(0.1f, 1.0f, 0.1f), nullptr, true);
m_EditingContourNode->AddProperty("contour.points.color", ColorProperty::New(0.0f, 0.0f, 1.0f), nullptr, true);
m_EditingContourNode->AddProperty("contour.width", mitk::FloatProperty::New(4.0f), nullptr, true);
- auto dataStorage = m_ToolManager->GetDataStorage();
+ auto dataStorage = this->GetToolManager()->GetDataStorage();
dataStorage->Add(m_ContourNode, workingDataNode);
dataStorage->Add(m_LiveWireContourNode, workingDataNode);
dataStorage->Add(m_EditingContourNode, workingDataNode);
// Set current slice as input for ImageToLiveWireContourFilter
m_ReferenceDataSlice = this->GetAffectedReferenceSlice(positionEvent);
auto origin = m_ReferenceDataSlice->GetSlicedGeometry()->GetOrigin();
m_ReferenceDataSlice->GetSlicedGeometry()->WorldToIndex(origin, origin);
m_ReferenceDataSlice->GetSlicedGeometry()->IndexToWorld(origin, origin);
m_ReferenceDataSlice->GetSlicedGeometry()->SetOrigin(origin);
m_LiveWireFilter = ImageLiveWireContourModelFilter::New();
m_LiveWireFilter->SetInput(m_ReferenceDataSlice);
// Map click to pixel coordinates
auto click = positionEvent->GetPositionInWorld();
itk::Index<3> idx;
m_ReferenceDataSlice->GetGeometry()->WorldToIndex(click, idx);
// Get the pixel with the highest gradient in a 7x7 region
itk::Index<3> indexWithHighestGradient;
AccessFixedDimensionByItk_2(m_ReferenceDataSlice, FindHighestGradientMagnitudeByITK, 2, idx, indexWithHighestGradient);
click[0] = indexWithHighestGradient[0];
click[1] = indexWithHighestGradient[1];
click[2] = indexWithHighestGradient[2];
m_ReferenceDataSlice->GetGeometry()->IndexToWorld(click, click);
// Set initial start point
m_Contour->AddVertex(click, true);
m_LiveWireFilter->SetStartPoint(click);
// Remember PlaneGeometry to determine if events were triggered in the same plane
m_PlaneGeometry = interactionEvent->GetSender()->GetCurrentWorldPlaneGeometry();
m_CreateAndUseDynamicCosts = true;
mitk::RenderingManager::GetInstance()->RequestUpdate(positionEvent->GetSender()->GetRenderWindow());
}
void mitk::LiveWireTool2D::OnAddPoint(StateMachineAction *, InteractionEvent *interactionEvent)
{
// Complete LiveWire interaction for the last segment. Add current LiveWire contour to
// the finished contour and reset to start a new segment and computation.
auto positionEvent = dynamic_cast<mitk::InteractionPositionEvent *>(interactionEvent);
if (nullptr == positionEvent)
return;
if (m_PlaneGeometry.IsNotNull())
{
// Check if the point is in the correct slice
if (m_PlaneGeometry->DistanceFromPlane(positionEvent->GetPositionInWorld()) > mitk::sqrteps)
return;
}
// Add repulsive points to avoid getting the same path again
std::for_each(m_LiveWireContour->IteratorBegin(), m_LiveWireContour->IteratorEnd(), [this](ContourElement::VertexType *vertex) {
ImageLiveWireContourModelFilter::InternalImageType::IndexType idx;
this->m_ReferenceDataSlice->GetGeometry()->WorldToIndex(vertex->Coordinates, idx);
this->m_LiveWireFilter->AddRepulsivePoint(idx);
});
// Remove duplicate first vertex, it's already contained in m_Contour
m_LiveWireContour->RemoveVertexAt(0);
// Set last point as control point
m_LiveWireContour->SetControlVertexAt(m_LiveWireContour->GetNumberOfVertices() - 1);
// Merge contours
m_Contour->Concatenate(m_LiveWireContour);
// Clear the LiveWire contour and reset the corresponding DataNode
m_LiveWireContour->Clear();
// Set new start point
m_LiveWireFilter->SetStartPoint(positionEvent->GetPositionInWorld());
if (m_CreateAndUseDynamicCosts)
{
// Use dynamic cost map for next update
m_LiveWireFilter->CreateDynamicCostMap(m_Contour);
m_LiveWireFilter->SetUseDynamicCostMap(true);
}
mitk::RenderingManager::GetInstance()->RequestUpdate(positionEvent->GetSender()->GetRenderWindow());
}
void mitk::LiveWireTool2D::OnMouseMoved(StateMachineAction *, InteractionEvent *interactionEvent)
{
// Compute LiveWire segment from last control point to current mouse position
auto positionEvent = dynamic_cast<mitk::InteractionPositionEvent *>(interactionEvent);
if (nullptr == positionEvent)
return;
m_LiveWireFilter->SetEndPoint(positionEvent->GetPositionInWorld());
m_LiveWireFilter->Update();
this->UpdateLiveWireContour();
RenderingManager::GetInstance()->RequestUpdate(positionEvent->GetSender()->GetRenderWindow());
}
void mitk::LiveWireTool2D::OnMouseMoveNoDynamicCosts(StateMachineAction *, InteractionEvent *interactionEvent)
{
m_LiveWireFilter->SetUseDynamicCostMap(false);
this->OnMouseMoved(nullptr, interactionEvent);
m_LiveWireFilter->SetUseDynamicCostMap(true);
}
bool mitk::LiveWireTool2D::OnCheckPoint(const InteractionEvent *interactionEvent)
{
// Check double click on first control point to finish the LiveWire tool
auto positionEvent = dynamic_cast<const mitk::InteractionPositionEvent *>(interactionEvent);
if (nullptr == positionEvent)
return false;
mitk::Point3D click = positionEvent->GetPositionInWorld();
mitk::Point3D first = this->m_Contour->GetVertexAt(0)->Coordinates;
return first.EuclideanDistanceTo(click) < 4.5;
}
void mitk::LiveWireTool2D::OnFinish(StateMachineAction *, InteractionEvent *interactionEvent)
{
// Finish LiveWire tool interaction
auto positionEvent = dynamic_cast<mitk::InteractionPositionEvent *>(interactionEvent);
if (nullptr == positionEvent)
return;
// Remove last control point added by double click
m_Contour->RemoveVertexAt(m_Contour->GetNumberOfVertices() - 1);
// Save contour and corresponding plane geometry to list
this->m_WorkingContours.emplace_back(std::make_pair(m_ContourNode, positionEvent->GetSender()->GetCurrentWorldPlaneGeometry()->Clone()));
this->m_EditingContours.emplace_back(std::make_pair(m_EditingContourNode, positionEvent->GetSender()->GetCurrentWorldPlaneGeometry()->Clone()));
m_LiveWireFilter->SetUseDynamicCostMap(false);
this->FinishTool();
}
void mitk::LiveWireTool2D::FinishTool()
{
auto numberOfTimesteps = static_cast<int>(m_Contour->GetTimeSteps());
for (int i = 0; i <= numberOfTimesteps; ++i)
m_Contour->Close(i);
- m_ToolManager->GetDataStorage()->Remove(m_LiveWireContourNode);
+ this->GetToolManager()->GetDataStorage()->Remove(m_LiveWireContourNode);
m_LiveWireContourNode = nullptr;
m_LiveWireContour = nullptr;
m_ContourInteractor = mitk::ContourModelLiveWireInteractor::New();
m_ContourInteractor->SetDataNode(m_ContourNode);
m_ContourInteractor->LoadStateMachine("ContourModelModificationInteractor.xml", us::GetModuleContext()->GetModule());
m_ContourInteractor->SetEventConfig("ContourModelModificationConfig.xml", us::GetModuleContext()->GetModule());
m_ContourInteractor->SetWorkingImage(this->m_ReferenceDataSlice);
m_ContourInteractor->SetEditingContourModelNode(this->m_EditingContourNode);
m_ContourNode->SetDataInteractor(m_ContourInteractor.GetPointer());
this->m_LiveWireInteractors.push_back(m_ContourInteractor);
}
void mitk::LiveWireTool2D::OnLastSegmentDelete(StateMachineAction *, InteractionEvent *interactionEvent)
{
// If last point of current contour will be removed go to start state and remove nodes
if (m_Contour->GetNumberOfVertices() <= 1)
{
- auto dataStorage = m_ToolManager->GetDataStorage();
+ auto dataStorage = this->GetToolManager()->GetDataStorage();
dataStorage->Remove(m_LiveWireContourNode);
dataStorage->Remove(m_ContourNode);
dataStorage->Remove(m_EditingContourNode);
m_LiveWireContour = this->CreateNewContour();
m_LiveWireContourNode->SetData(m_LiveWireContour);
m_Contour = this->CreateNewContour();
m_ContourNode->SetData(m_Contour);
this->ResetToStartState();
}
else // Remove last segment from contour and reset LiveWire contour
{
m_LiveWireContour = this->CreateNewContour();
m_LiveWireContourNode->SetData(m_LiveWireContour);
auto newContour = this->CreateNewContour();
auto begin = m_Contour->IteratorBegin();
// Iterate from last point to next active point
auto newLast = m_Contour->IteratorBegin() + (m_Contour->GetNumberOfVertices() - 1);
// Go at least one down
if (newLast != begin)
--newLast;
// Search next active control point
while (newLast != begin && !((*newLast)->IsControlPoint))
--newLast;
// Set position of start point for LiveWire filter to coordinates of the new last point
m_LiveWireFilter->SetStartPoint((*newLast)->Coordinates);
auto it = m_Contour->IteratorBegin();
// Fll new Contour
while (it <= newLast)
{
newContour->AddVertex((*it)->Coordinates, (*it)->IsControlPoint);
++it;
}
newContour->SetClosed(m_Contour->IsClosed());
m_ContourNode->SetData(newContour);
m_Contour = newContour;
mitk::RenderingManager::GetInstance()->RequestUpdate(interactionEvent->GetSender()->GetRenderWindow());
}
}
template <typename TPixel, unsigned int VImageDimension>
void mitk::LiveWireTool2D::FindHighestGradientMagnitudeByITK(itk::Image<TPixel, VImageDimension> *inputImage,
itk::Index<3> &index,
itk::Index<3> &returnIndex)
{
typedef itk::Image<TPixel, VImageDimension> InputImageType;
typedef typename InputImageType::IndexType IndexType;
const auto MAX_X = inputImage->GetLargestPossibleRegion().GetSize()[0];
const auto MAX_Y = inputImage->GetLargestPossibleRegion().GetSize()[1];
returnIndex[0] = index[0];
returnIndex[1] = index[1];
returnIndex[2] = 0.0;
double gradientMagnitude = 0.0;
double maxGradientMagnitude = 0.0;
// The size and thus the region of 7x7 is only used to calculate the gradient magnitude in that region,
// not for searching the maximum value.
// Maximum value in each direction for size
typename InputImageType::SizeType size;
size[0] = 7;
size[1] = 7;
// Minimum value in each direction for startRegion
IndexType startRegion;
startRegion[0] = index[0] - 3;
startRegion[1] = index[1] - 3;
if (startRegion[0] < 0)
startRegion[0] = 0;
if (startRegion[1] < 0)
startRegion[1] = 0;
if (MAX_X - index[0] < 7)
startRegion[0] = MAX_X - 7;
if (MAX_Y - index[1] < 7)
startRegion[1] = MAX_Y - 7;
index[0] = startRegion[0] + 3;
index[1] = startRegion[1] + 3;
typename InputImageType::RegionType region;
region.SetSize(size);
region.SetIndex(startRegion);
typedef typename itk::GradientMagnitudeImageFilter<InputImageType, InputImageType> GradientMagnitudeFilterType;
typename GradientMagnitudeFilterType::Pointer gradientFilter = GradientMagnitudeFilterType::New();
gradientFilter->SetInput(inputImage);
gradientFilter->GetOutput()->SetRequestedRegion(region);
gradientFilter->Update();
typename InputImageType::Pointer gradientMagnitudeImage;
gradientMagnitudeImage = gradientFilter->GetOutput();
IndexType currentIndex;
currentIndex[0] = 0;
currentIndex[1] = 0;
// Search max (approximate) gradient magnitude
for (int x = -1; x <= 1; ++x)
{
currentIndex[0] = index[0] + x;
for (int y = -1; y <= 1; ++y)
{
currentIndex[1] = index[1] + y;
gradientMagnitude = gradientMagnitudeImage->GetPixel(currentIndex);
// Check for new max
if (maxGradientMagnitude < gradientMagnitude)
{
maxGradientMagnitude = gradientMagnitude;
returnIndex[0] = currentIndex[0];
returnIndex[1] = currentIndex[1];
returnIndex[2] = 0.0;
}
}
currentIndex[1] = index[1];
}
}
diff --git a/Modules/Segmentation/Interactions/mitkPaintbrushTool.cpp b/Modules/Segmentation/Interactions/mitkPaintbrushTool.cpp
index 54231db23f..080fb76ab2 100644
--- a/Modules/Segmentation/Interactions/mitkPaintbrushTool.cpp
+++ b/Modules/Segmentation/Interactions/mitkPaintbrushTool.cpp
@@ -1,566 +1,566 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
#include "mitkPaintbrushTool.h"
#include "mitkAbstractTransformGeometry.h"
#include "mitkBaseRenderer.h"
#include "mitkToolManager.h"
#include "mitkContourModelUtils.h"
#include "mitkLevelWindowProperty.h"
int mitk::PaintbrushTool::m_Size = 1;
mitk::PaintbrushTool::PaintbrushTool(int paintingPixelValue)
: FeedbackContourTool("PressMoveReleaseWithCTRLInversionAllMouseMoves"),
m_PaintingPixelValue(paintingPixelValue),
m_LastContourSize(0) // other than initial mitk::PaintbrushTool::m_Size (around l. 28)
{
m_MasterContour = ContourModel::New();
m_MasterContour->Initialize();
m_CurrentPlane = nullptr;
m_WorkingNode = DataNode::New();
m_WorkingNode->SetProperty("levelwindow", mitk::LevelWindowProperty::New(mitk::LevelWindow(0, 1)));
m_WorkingNode->SetProperty("binary", mitk::BoolProperty::New(true));
}
mitk::PaintbrushTool::~PaintbrushTool()
{
}
void mitk::PaintbrushTool::ConnectActionsAndFunctions()
{
CONNECT_FUNCTION("PrimaryButtonPressed", OnMousePressed);
CONNECT_FUNCTION("Move", OnPrimaryButtonPressedMoved);
CONNECT_FUNCTION("MouseMove", OnMouseMoved);
CONNECT_FUNCTION("Release", OnMouseReleased);
CONNECT_FUNCTION("InvertLogic", OnInvertLogic);
}
void mitk::PaintbrushTool::Activated()
{
Superclass::Activated();
FeedbackContourTool::SetFeedbackContourVisible(true);
SizeChanged.Send(m_Size);
- m_ToolManager->WorkingDataChanged +=
+ this->GetToolManager()->WorkingDataChanged +=
mitk::MessageDelegate<mitk::PaintbrushTool>(this, &mitk::PaintbrushTool::OnToolManagerWorkingDataModified);
}
void mitk::PaintbrushTool::Deactivated()
{
FeedbackContourTool::SetFeedbackContourVisible(false);
- if (m_ToolManager->GetDataStorage()->Exists(m_WorkingNode))
- m_ToolManager->GetDataStorage()->Remove(m_WorkingNode);
+ if (this->GetToolManager()->GetDataStorage()->Exists(m_WorkingNode))
+ this->GetToolManager()->GetDataStorage()->Remove(m_WorkingNode);
m_WorkingSlice = nullptr;
m_CurrentPlane = nullptr;
- m_ToolManager->WorkingDataChanged -=
+ this->GetToolManager()->WorkingDataChanged -=
mitk::MessageDelegate<mitk::PaintbrushTool>(this, &mitk::PaintbrushTool::OnToolManagerWorkingDataModified);
Superclass::Deactivated();
}
void mitk::PaintbrushTool::SetSize(int value)
{
m_Size = value;
}
mitk::Point2D mitk::PaintbrushTool::upperLeft(mitk::Point2D p)
{
p[0] -= 0.5;
p[1] += 0.5;
return p;
}
void mitk::PaintbrushTool::UpdateContour(const InteractionPositionEvent *positionEvent)
{
// MITK_INFO<<"Update...";
// examine stateEvent and create a contour that matches the pixel mask that we are going to draw
// mitk::InteractionPositionEvent* positionEvent = dynamic_cast<mitk::InteractionPositionEvent*>( interactionEvent );
// const PositionEvent* positionEvent = dynamic_cast<const PositionEvent*>(stateEvent->GetEvent());
if (!positionEvent)
return;
// Get Spacing of current Slice
// mitk::Vector3D vSpacing = m_WorkingSlice->GetSlicedGeometry()->GetPlaneGeometry(0)->GetSpacing();
//
// Draw a contour in Square according to selected brush size
//
int radius = (m_Size) / 2;
float fradius = static_cast<float>(m_Size) / 2.0f;
ContourModel::Pointer contourInImageIndexCoordinates = ContourModel::New();
// estimate center point of the brush ( relative to the pixel the mouse points on )
// -- left upper corner for even sizes,
// -- midpoint for uneven sizes
mitk::Point2D centerCorrection;
centerCorrection.Fill(0);
// even --> correction of [+0.5, +0.5]
bool evenSize = ((m_Size % 2) == 0);
if (evenSize)
{
centerCorrection[0] += 0.5;
centerCorrection[1] += 0.5;
}
// we will compute the control points for the upper left quarter part of a circle contour
std::vector<mitk::Point2D> quarterCycleUpperRight;
std::vector<mitk::Point2D> quarterCycleLowerRight;
std::vector<mitk::Point2D> quarterCycleLowerLeft;
std::vector<mitk::Point2D> quarterCycleUpperLeft;
mitk::Point2D curPoint;
bool curPointIsInside = true;
curPoint[0] = 0;
curPoint[1] = radius;
quarterCycleUpperRight.push_back(upperLeft(curPoint));
// to estimate if a pixel is inside the circle, we need to compare against the 'outer radius'
// i.e. the distance from the midpoint [0,0] to the border of the pixel [0,radius]
// const float outer_radius = static_cast<float>(radius) + 0.5;
while (curPoint[1] > 0)
{
// Move right until pixel is outside circle
float curPointX_squared = 0.0f;
float curPointY_squared = (curPoint[1] - centerCorrection[1]) * (curPoint[1] - centerCorrection[1]);
while (curPointIsInside)
{
// increment posX and chec
curPoint[0]++;
curPointX_squared = (curPoint[0] - centerCorrection[0]) * (curPoint[0] - centerCorrection[0]);
const float len = sqrt(curPointX_squared + curPointY_squared);
if (len > fradius)
{
// found first Pixel in this horizontal line, that is outside the circle
curPointIsInside = false;
}
}
quarterCycleUpperRight.push_back(upperLeft(curPoint));
// Move down until pixel is inside circle
while (!curPointIsInside)
{
// increment posX and chec
curPoint[1]--;
curPointY_squared = (curPoint[1] - centerCorrection[1]) * (curPoint[1] - centerCorrection[1]);
const float len = sqrt(curPointX_squared + curPointY_squared);
if (len <= fradius)
{
// found first Pixel in this horizontal line, that is outside the circle
curPointIsInside = true;
quarterCycleUpperRight.push_back(upperLeft(curPoint));
}
// Quarter cycle is full, when curPoint y position is 0
if (curPoint[1] <= 0)
break;
}
}
// QuarterCycle is full! Now copy quarter cycle to other quarters.
if (!evenSize)
{
std::vector<mitk::Point2D>::const_iterator it = quarterCycleUpperRight.begin();
while (it != quarterCycleUpperRight.end())
{
mitk::Point2D p;
p = *it;
// the contour points in the lower right corner have same position but with negative y values
p[1] *= -1;
quarterCycleLowerRight.push_back(p);
// the contour points in the lower left corner have same position
// but with both x,y negative
p[0] *= -1;
quarterCycleLowerLeft.push_back(p);
// the contour points in the upper left corner have same position
// but with x negative
p[1] *= -1;
quarterCycleUpperLeft.push_back(p);
it++;
}
}
else
{
std::vector<mitk::Point2D>::const_iterator it = quarterCycleUpperRight.begin();
while (it != quarterCycleUpperRight.end())
{
mitk::Point2D p, q;
p = *it;
q = p;
// the contour points in the lower right corner have same position but with negative y values
q[1] *= -1;
// correct for moved offset if size even = the midpoint is not the midpoint of the current pixel
// but its upper rigt corner
q[1] += 1;
quarterCycleLowerRight.push_back(q);
q = p;
// the contour points in the lower left corner have same position
// but with both x,y negative
q[1] = -1.0f * q[1] + 1;
q[0] = -1.0f * q[0] + 1;
quarterCycleLowerLeft.push_back(q);
// the contour points in the upper left corner have same position
// but with x negative
q = p;
q[0] *= -1;
q[0] += 1;
quarterCycleUpperLeft.push_back(q);
it++;
}
}
// fill contour with poins in right ordering, starting with the upperRight block
mitk::Point3D tempPoint;
for (unsigned int i = 0; i < quarterCycleUpperRight.size(); i++)
{
tempPoint[0] = quarterCycleUpperRight[i][0];
tempPoint[1] = quarterCycleUpperRight[i][1];
tempPoint[2] = 0;
contourInImageIndexCoordinates->AddVertex(tempPoint);
}
// the lower right has to be parsed in reverse order
for (int i = quarterCycleLowerRight.size() - 1; i >= 0; i--)
{
tempPoint[0] = quarterCycleLowerRight[i][0];
tempPoint[1] = quarterCycleLowerRight[i][1];
tempPoint[2] = 0;
contourInImageIndexCoordinates->AddVertex(tempPoint);
}
for (unsigned int i = 0; i < quarterCycleLowerLeft.size(); i++)
{
tempPoint[0] = quarterCycleLowerLeft[i][0];
tempPoint[1] = quarterCycleLowerLeft[i][1];
tempPoint[2] = 0;
contourInImageIndexCoordinates->AddVertex(tempPoint);
}
// the upper left also has to be parsed in reverse order
for (int i = quarterCycleUpperLeft.size() - 1; i >= 0; i--)
{
tempPoint[0] = quarterCycleUpperLeft[i][0];
tempPoint[1] = quarterCycleUpperLeft[i][1];
tempPoint[2] = 0;
contourInImageIndexCoordinates->AddVertex(tempPoint);
}
m_MasterContour = contourInImageIndexCoordinates;
}
/**
Just show the contour, get one point as the central point and add surrounding points to the contour.
*/
void mitk::PaintbrushTool::OnMousePressed(StateMachineAction *, InteractionEvent *interactionEvent)
{
if (m_WorkingSlice.IsNull())
return;
auto *positionEvent = dynamic_cast<mitk::InteractionPositionEvent *>(interactionEvent);
if (!positionEvent)
return;
m_WorkingSlice->GetGeometry()->WorldToIndex(positionEvent->GetPositionInWorld(), m_LastPosition);
// create new working node
// a fresh node is needed to only display the actual drawing process for
// the undo function
- if (m_ToolManager->GetDataStorage()->Exists(m_WorkingNode))
- m_ToolManager->GetDataStorage()->Remove(m_WorkingNode);
+ if (this->GetToolManager()->GetDataStorage()->Exists(m_WorkingNode))
+ this->GetToolManager()->GetDataStorage()->Remove(m_WorkingNode);
m_WorkingSlice = nullptr;
m_CurrentPlane = nullptr;
m_WorkingNode = DataNode::New();
m_WorkingNode->SetProperty("levelwindow", mitk::LevelWindowProperty::New(mitk::LevelWindow(0, 1)));
m_WorkingNode->SetProperty("binary", mitk::BoolProperty::New(true));
this->m_WorkingNode->SetVisibility(true);
m_LastEventSender = positionEvent->GetSender();
m_LastEventSlice = m_LastEventSender->GetSlice();
m_MasterContour->SetClosed(true);
this->MouseMoved(interactionEvent, true);
}
void mitk::PaintbrushTool::OnMouseMoved(StateMachineAction *, InteractionEvent *interactionEvent)
{
MouseMoved(interactionEvent, false);
}
void mitk::PaintbrushTool::OnPrimaryButtonPressedMoved(StateMachineAction *, InteractionEvent *interactionEvent)
{
MouseMoved(interactionEvent, true);
}
/**
Insert the point to the feedback contour,finish to build the contour and at the same time the painting function
*/
void mitk::PaintbrushTool::MouseMoved(mitk::InteractionEvent *interactionEvent, bool leftMouseButtonPressed)
{
auto *positionEvent = dynamic_cast<mitk::InteractionPositionEvent *>(interactionEvent);
CheckIfCurrentSliceHasChanged(positionEvent);
if (m_LastContourSize != m_Size)
{
UpdateContour(positionEvent);
m_LastContourSize = m_Size;
}
Point3D worldCoordinates = positionEvent->GetPositionInWorld();
Point3D indexCoordinates;
m_WorkingSlice->GetGeometry()->WorldToIndex(worldCoordinates, indexCoordinates);
// round to nearest voxel center (abort if this hasn't changed)
if (m_Size % 2 == 0) // even
{
indexCoordinates[0] = std::round(indexCoordinates[0]);
indexCoordinates[1] = std::round(indexCoordinates[1]);
}
else // odd
{
indexCoordinates[0] = std::round(indexCoordinates[0]);
indexCoordinates[1] = std::round(indexCoordinates[1]);
}
static Point3D lastPos; // uninitialized: if somebody finds out how this can be initialized in a one-liner, tell me
if (fabs(indexCoordinates[0] - lastPos[0]) > mitk::eps || fabs(indexCoordinates[1] - lastPos[1]) > mitk::eps ||
fabs(indexCoordinates[2] - lastPos[2]) > mitk::eps || leftMouseButtonPressed)
{
lastPos = indexCoordinates;
}
else
{
return;
}
auto contour = ContourModel::New();
contour->SetClosed(true);
auto it = m_MasterContour->Begin();
auto end = m_MasterContour->End();
while (it != end)
{
auto point = (*it)->Coordinates;
point[0] += indexCoordinates[0];
point[1] += indexCoordinates[1];
contour->AddVertex(point);
++it;
}
if (leftMouseButtonPressed)
{
const double dist = indexCoordinates.EuclideanDistanceTo(m_LastPosition);
const double radius = static_cast<double>(m_Size) / 2.0;
- DataNode *workingNode(m_ToolManager->GetWorkingData(0));
+ DataNode *workingNode(this->GetToolManager()->GetWorkingData(0));
auto workingImage = dynamic_cast<Image*>(workingNode->GetData());
int activePixelValue = ContourModelUtils::GetActivePixelValue(workingImage);
// m_PaintingPixelValue only decides whether to paint or erase
mitk::ContourModelUtils::FillContourInSlice(
contour, m_WorkingSlice, workingImage, m_PaintingPixelValue * activePixelValue);
m_WorkingNode->SetData(m_WorkingSlice);
m_WorkingNode->Modified();
// if points are >= radius away draw rectangle to fill empty holes
// in between the 2 points
if (dist > radius)
{
const mitk::Point3D ¤tPos = indexCoordinates;
mitk::Point3D direction;
mitk::Point3D vertex;
mitk::Point3D normal;
direction[0] = indexCoordinates[0] - m_LastPosition[0];
direction[1] = indexCoordinates[1] - m_LastPosition[1];
direction[2] = indexCoordinates[2] - m_LastPosition[2];
direction[0] = direction.GetVnlVector().normalize()[0];
direction[1] = direction.GetVnlVector().normalize()[1];
direction[2] = direction.GetVnlVector().normalize()[2];
// 90 degrees rotation of direction
normal[0] = -1.0 * direction[1];
normal[1] = direction[0];
contour->Clear();
// upper left corner
vertex[0] = m_LastPosition[0] + (normal[0] * radius);
vertex[1] = m_LastPosition[1] + (normal[1] * radius);
contour->AddVertex(vertex);
// upper right corner
vertex[0] = currentPos[0] + (normal[0] * radius);
vertex[1] = currentPos[1] + (normal[1] * radius);
contour->AddVertex(vertex);
// lower right corner
vertex[0] = currentPos[0] - (normal[0] * radius);
vertex[1] = currentPos[1] - (normal[1] * radius);
contour->AddVertex(vertex);
// lower left corner
vertex[0] = m_LastPosition[0] - (normal[0] * radius);
vertex[1] = m_LastPosition[1] - (normal[1] * radius);
contour->AddVertex(vertex);
mitk::ContourModelUtils::FillContourInSlice(contour, m_WorkingSlice, workingImage, m_PaintingPixelValue * activePixelValue);
m_WorkingNode->SetData(m_WorkingSlice);
m_WorkingNode->Modified();
}
}
else
{
// switched from different renderwindow
// no activate hover highlighting. Otherwise undo / redo wont work
this->m_WorkingNode->SetVisibility(false);
}
m_LastPosition = indexCoordinates;
// visualize contour
ContourModel::Pointer tmp =
FeedbackContourTool::BackProjectContourFrom2DSlice(m_WorkingSlice->GetGeometry(), contour);
this->UpdateCurrentFeedbackContour(tmp);
assert(positionEvent->GetSender()->GetRenderWindow());
RenderingManager::GetInstance()->RequestUpdate(positionEvent->GetSender()->GetRenderWindow());
}
void mitk::PaintbrushTool::OnMouseReleased(StateMachineAction *, InteractionEvent *interactionEvent)
{
// When mouse is released write segmentationresult back into image
auto *positionEvent = dynamic_cast<mitk::InteractionPositionEvent *>(interactionEvent);
if (!positionEvent)
return;
this->WriteBackSegmentationResult(positionEvent, m_WorkingSlice->Clone());
// deactivate visibility of helper node
m_WorkingNode->SetVisibility(false);
RenderingManager::GetInstance()->RequestUpdate(positionEvent->GetSender()->GetRenderWindow());
}
/**
Called when the CTRL key is pressed. Will change the painting pixel value from 0 to 1 or from 1 to 0.
*/
void mitk::PaintbrushTool::OnInvertLogic(StateMachineAction *, InteractionEvent *)
{
// Inversion only for 0 and 1 as painting values
if (m_PaintingPixelValue == 1)
{
m_PaintingPixelValue = 0;
FeedbackContourTool::SetFeedbackContourColor(1.0, 0.0, 0.0);
}
else if (m_PaintingPixelValue == 0)
{
m_PaintingPixelValue = 1;
FeedbackContourTool::SetFeedbackContourColorDefault();
}
mitk::RenderingManager::GetInstance()->RequestUpdateAll();
}
void mitk::PaintbrushTool::CheckIfCurrentSliceHasChanged(const InteractionPositionEvent *event)
{
const PlaneGeometry *planeGeometry((event->GetSender()->GetCurrentWorldPlaneGeometry()));
const auto *abstractTransformGeometry(
dynamic_cast<const AbstractTransformGeometry *>(event->GetSender()->GetCurrentWorldPlaneGeometry()));
- DataNode *workingNode(m_ToolManager->GetWorkingData(0));
+ DataNode *workingNode(this->GetToolManager()->GetWorkingData(0));
if (!workingNode)
return;
Image::Pointer image = dynamic_cast<Image *>(workingNode->GetData());
if (!image || !planeGeometry || abstractTransformGeometry)
return;
if (m_CurrentPlane.IsNull() || m_WorkingSlice.IsNull())
{
m_CurrentPlane = planeGeometry;
m_WorkingSlice = SegTool2D::GetAffectedImageSliceAs2DImage(event, image)->Clone();
m_WorkingNode->ReplaceProperty("color", workingNode->GetProperty("color"));
m_WorkingNode->SetData(m_WorkingSlice);
}
else
{
bool isSameSlice(false);
isSameSlice = mitk::MatrixEqualElementWise(planeGeometry->GetIndexToWorldTransform()->GetMatrix(),
m_CurrentPlane->GetIndexToWorldTransform()->GetMatrix());
isSameSlice = mitk::Equal(planeGeometry->GetIndexToWorldTransform()->GetOffset(),
m_CurrentPlane->GetIndexToWorldTransform()->GetOffset());
if (!isSameSlice)
{
- m_ToolManager->GetDataStorage()->Remove(m_WorkingNode);
+ this->GetToolManager()->GetDataStorage()->Remove(m_WorkingNode);
m_CurrentPlane = nullptr;
m_WorkingSlice = nullptr;
m_WorkingNode = nullptr;
m_CurrentPlane = planeGeometry;
m_WorkingSlice = SegTool2D::GetAffectedImageSliceAs2DImage(event, image)->Clone();
m_WorkingNode = mitk::DataNode::New();
m_WorkingNode->SetProperty("levelwindow", mitk::LevelWindowProperty::New(mitk::LevelWindow(0, 1)));
m_WorkingNode->SetProperty("binary", mitk::BoolProperty::New(true));
m_WorkingNode->SetData(m_WorkingSlice);
// So that the paintbrush contour vanished in the previous render window
RenderingManager::GetInstance()->RequestUpdateAll();
}
}
- if (!m_ToolManager->GetDataStorage()->Exists(m_WorkingNode))
+ if (!this->GetToolManager()->GetDataStorage()->Exists(m_WorkingNode))
{
m_WorkingNode->SetProperty("outline binary", mitk::BoolProperty::New(true));
m_WorkingNode->SetProperty("color", workingNode->GetProperty("color"));
m_WorkingNode->SetProperty("name", mitk::StringProperty::New("Paintbrush_Node"));
m_WorkingNode->SetProperty("helper object", mitk::BoolProperty::New(true));
m_WorkingNode->SetProperty("opacity", mitk::FloatProperty::New(0.8));
m_WorkingNode->SetProperty("includeInBoundingBox", mitk::BoolProperty::New(false));
m_WorkingNode->SetVisibility(
false, mitk::BaseRenderer::GetInstance(mitk::BaseRenderer::GetRenderWindowByName("stdmulti.widget3")));
- m_ToolManager->GetDataStorage()->Add(m_WorkingNode);
+ this->GetToolManager()->GetDataStorage()->Add(m_WorkingNode);
}
}
void mitk::PaintbrushTool::OnToolManagerWorkingDataModified()
{
// Here we simply set the current working slice to null. The next time the mouse is moved
// within a renderwindow a new slice will be extracted from the new working data
m_WorkingSlice = nullptr;
}
diff --git a/Modules/Segmentation/Interactions/mitkPickingTool.cpp b/Modules/Segmentation/Interactions/mitkPickingTool.cpp
index e2bfed1ca1..52ab30dfad 100644
--- a/Modules/Segmentation/Interactions/mitkPickingTool.cpp
+++ b/Modules/Segmentation/Interactions/mitkPickingTool.cpp
@@ -1,269 +1,215 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
#include "mitkPickingTool.h"
#include "mitkProperties.h"
#include "mitkToolManager.h"
+#include "mitkInteractionPositionEvent.h"
// us
#include <usGetModuleContext.h>
#include <usModule.h>
#include <usModuleContext.h>
#include <usModuleResource.h>
#include "mitkITKImageImport.h"
#include "mitkImageAccessByItk.h"
#include "mitkImageCast.h"
#include "mitkImageTimeSelector.h"
#include "mitkImageTimeSelector.h"
+#include <itkImage.h>
#include <itkConnectedThresholdImageFilter.h>
#include <mitkLabelSetImage.h>
namespace mitk
{
MITK_TOOL_MACRO(MITKSEGMENTATION_EXPORT, PickingTool, "PickingTool");
}
-mitk::PickingTool::PickingTool() : m_WorkingData(nullptr)
+mitk::PickingTool::PickingTool() : AutoSegmentationWithPreviewTool(false, "PressMoveReleaseAndPointSetting")
{
- m_PointSetNode = mitk::DataNode::New();
- m_PointSetNode->GetPropertyList()->SetProperty("name", mitk::StringProperty::New("Picking_Seedpoint"));
- m_PointSetNode->GetPropertyList()->SetProperty("helper object", mitk::BoolProperty::New(true));
- m_PointSet = mitk::PointSet::New();
- m_PointSetNode->SetData(m_PointSet);
-
- // Watch for point added or modified
- itk::SimpleMemberCommand<PickingTool>::Pointer pointAddedCommand = itk::SimpleMemberCommand<PickingTool>::New();
- pointAddedCommand->SetCallbackFunction(this, &mitk::PickingTool::OnPointAdded);
- m_PointSetAddObserverTag = m_PointSet->AddObserver(mitk::PointSetAddEvent(), pointAddedCommand);
-
- // create new node for picked region
- m_ResultNode = mitk::DataNode::New();
- // set some properties
- m_ResultNode->SetProperty("name", mitk::StringProperty::New("result"));
- m_ResultNode->SetProperty("helper object", mitk::BoolProperty::New(true));
- m_ResultNode->SetProperty("color", mitk::ColorProperty::New(0, 1, 0));
- m_ResultNode->SetProperty("layer", mitk::IntProperty::New(1));
- m_ResultNode->SetProperty("opacity", mitk::FloatProperty::New(0.33f));
+ this->ResetsToEmptyPreviewOn();
}
mitk::PickingTool::~PickingTool()
{
- m_PointSet->RemoveObserver(m_PointSetAddObserverTag);
}
bool mitk::PickingTool::CanHandle(const BaseData* referenceData, const BaseData* workingData) const
{
if (!Superclass::CanHandle(referenceData,workingData))
return false;
auto* image = dynamic_cast<const Image*>(referenceData);
if (image == nullptr)
return false;
- if (image->GetTimeSteps() > 1) //release quickfix for T28248
- return false;
-
return true;
}
const char **mitk::PickingTool::GetXPM() const
{
return nullptr;
}
const char *mitk::PickingTool::GetName() const
{
return "Picking";
}
us::ModuleResource mitk::PickingTool::GetIconResource() const
{
us::Module *module = us::GetModuleContext()->GetModule();
us::ModuleResource resource = module->GetResource("Pick_48x48.png");
return resource;
}
void mitk::PickingTool::Activated()
{
Superclass::Activated();
- DataStorage *dataStorage = this->GetDataStorage();
- m_WorkingData = this->GetWorkingData();
-
- // add to datastorage and enable interaction
- if (!dataStorage->Exists(m_PointSetNode))
- dataStorage->Add(m_PointSetNode, m_WorkingData);
+ m_PointSet = mitk::PointSet::New();
+ //ensure that the seed points are visible for all timepoints.
+ dynamic_cast<ProportionalTimeGeometry*>(m_PointSet->GetTimeGeometry())->SetStepDuration(std::numeric_limits<TimePointType>::max());
- m_SeedPointInteractor = mitk::SinglePointDataInteractor::New();
- m_SeedPointInteractor->LoadStateMachine("PointSet.xml");
- m_SeedPointInteractor->SetEventConfig("PointSetConfig.xml");
- m_SeedPointInteractor->SetDataNode(m_PointSetNode);
+ m_PointSetNode = mitk::DataNode::New();
+ m_PointSetNode->SetData(m_PointSet);
+ m_PointSetNode->SetName(std::string(this->GetName()) + "_PointSet");
+ m_PointSetNode->SetBoolProperty("helper object", true);
+ m_PointSetNode->SetColor(0.0, 1.0, 0.0);
+ m_PointSetNode->SetVisibility(true);
- // now add result to data tree
- dataStorage->Add(m_ResultNode, m_WorkingData);
+ this->GetDataStorage()->Add(m_PointSetNode, this->GetToolManager()->GetWorkingData(0));
}
void mitk::PickingTool::Deactivated()
{
- m_PointSet->Clear();
+ this->ClearSeeds();
+
// remove from data storage and disable interaction
GetDataStorage()->Remove(m_PointSetNode);
- GetDataStorage()->Remove(m_ResultNode);
+ m_PointSetNode = nullptr;
+ m_PointSet = nullptr;
Superclass::Deactivated();
}
-mitk::DataNode *mitk::PickingTool::GetReferenceData()
-{
- return this->m_ToolManager->GetReferenceData(0);
-}
-
-mitk::DataStorage *mitk::PickingTool::GetDataStorage()
+void mitk::PickingTool::ConnectActionsAndFunctions()
{
- return this->m_ToolManager->GetDataStorage();
+ CONNECT_FUNCTION("ShiftSecondaryButtonPressed", OnAddPoint);
+ CONNECT_FUNCTION("ShiftPrimaryButtonPressed", OnAddPoint);
+ CONNECT_FUNCTION("DeletePoint", OnDelete);
}
-mitk::DataNode *mitk::PickingTool::GetWorkingData()
+void mitk::PickingTool::OnAddPoint(StateMachineAction*, InteractionEvent* interactionEvent)
{
- return this->m_ToolManager->GetWorkingData(0);
-}
+ if (!this->IsUpdating() && m_PointSet.IsNotNull())
+ {
+ const auto positionEvent = dynamic_cast<mitk::InteractionPositionEvent*>(interactionEvent);
-mitk::DataNode::Pointer mitk::PickingTool::GetPointSetNode()
-{
- return m_PointSetNode;
+ if (positionEvent != nullptr)
+ {
+ m_PointSet->InsertPoint(m_PointSet->GetSize(), positionEvent->GetPositionInWorld());
+ this->UpdatePreview();
+ }
+ }
}
-void mitk::PickingTool::OnPointAdded()
+void mitk::PickingTool::OnDelete(StateMachineAction*, InteractionEvent* /*interactionEvent*/)
{
- if (m_WorkingData != this->GetWorkingData())
+ if (!this->IsUpdating() && m_PointSet.IsNotNull())
{
- DataStorage *dataStorage = this->GetDataStorage();
-
- if (dataStorage->Exists(m_PointSetNode))
+ // delete last seed point
+ if (this->m_PointSet->GetSize() > 0)
{
- dataStorage->Remove(m_PointSetNode);
- dataStorage->Add(m_PointSetNode, this->GetWorkingData());
- }
+ m_PointSet->RemovePointAtEnd(0);
- if (dataStorage->Exists(m_ResultNode))
- {
- dataStorage->Remove(m_ResultNode);
- dataStorage->Add(m_ResultNode, this->GetWorkingData());
+ this->UpdatePreview();
}
-
- m_WorkingData = this->GetWorkingData();
}
+}
- // Perform region growing/picking
-
- int timeStep =
- mitk::BaseRenderer::GetInstance(mitk::BaseRenderer::GetRenderWindowByName("stdmulti.widget0"))->GetTimeStep();
-
- mitk::PointSet::PointType seedPoint = m_PointSet->GetPointSet(timeStep)->GetPoints()->Begin().Value();
+void mitk::PickingTool::ClearPicks()
+{
+ this->ClearSeeds();
+ this->UpdatePreview();
+}
- // as we want to pick a region from our segmentation image use the working data from ToolManager
- mitk::Image::Pointer orgImage = dynamic_cast<mitk::Image *>(m_ToolManager->GetWorkingData(0)->GetData());
+bool mitk::PickingTool::HasPicks() const
+{
+ return this->m_PointSet.IsNotNull() && this->m_PointSet->GetSize()>0;
+}
- if (orgImage.IsNotNull())
+void mitk::PickingTool::ClearSeeds()
+{
+ if (this->m_PointSet.IsNotNull())
{
- if (orgImage->GetDimension() == 4)
- { // there may be 4D segmentation data even though we currently don't support that
- mitk::ImageTimeSelector::Pointer timeSelector = mitk::ImageTimeSelector::New();
- timeSelector->SetInput(orgImage);
- timeSelector->SetTimeNr(timeStep);
- timeSelector->UpdateLargestPossibleRegion();
- mitk::Image *timedImage = timeSelector->GetOutput();
-
- AccessByItk_2(timedImage, StartRegionGrowing, timedImage->GetGeometry(), seedPoint);
- }
- else if (orgImage->GetDimension() == 3)
- {
- AccessByItk_2(orgImage, StartRegionGrowing, orgImage->GetGeometry(), seedPoint);
- }
- this->m_PointSet->Clear();
+ // renew pointset
+ this->m_PointSet = mitk::PointSet::New();
+ //ensure that the seed points are visible for all timepoints.
+ dynamic_cast<ProportionalTimeGeometry*>(m_PointSet->GetTimeGeometry())->SetStepDuration(std::numeric_limits<TimePointType>::max());
+ this->m_PointSetNode->SetData(this->m_PointSet);
}
}
template <typename TPixel, unsigned int VImageDimension>
-void mitk::PickingTool::StartRegionGrowing(itk::Image<TPixel, VImageDimension> *itkImage,
- mitk::BaseGeometry *imageGeometry,
- mitk::PointSet::PointType seedPoint)
+void DoITKRegionGrowing(const itk::Image<TPixel, VImageDimension>* oldSegImage,
+ mitk::Image* segmentation,
+ const mitk::PointSet* seedPoints,
+ unsigned int timeStep, const mitk::BaseGeometry* inputGeometry)
{
typedef itk::Image<TPixel, VImageDimension> InputImageType;
typedef typename InputImageType::IndexType IndexType;
typedef itk::ConnectedThresholdImageFilter<InputImageType, InputImageType> RegionGrowingFilterType;
typename RegionGrowingFilterType::Pointer regionGrower = RegionGrowingFilterType::New();
// convert world coordinates to image indices
- IndexType seedIndex;
- imageGeometry->WorldToIndex(seedPoint, seedIndex);
+ for (auto pos = seedPoints->Begin(); pos != seedPoints->End(); ++pos)
+ {
+ IndexType seedIndex;
+ inputGeometry->WorldToIndex(pos->Value(), seedIndex);
+ regionGrower->AddSeed(seedIndex);
+ }
// perform region growing in desired segmented region
- regionGrower->SetInput(itkImage);
- regionGrower->AddSeed(seedIndex);
+ regionGrower->SetInput(oldSegImage);
- // TODO: conversion added to silence warning and
- // maintain existing behaviour, should be fixed
- // since it's not correct e.g. for signed char
regionGrower->SetLower(static_cast<typename InputImageType::PixelType>(1));
- regionGrower->SetUpper(static_cast<typename InputImageType::PixelType>(255));
+ regionGrower->SetUpper(std::numeric_limits<typename InputImageType::PixelType>::max());
try
{
regionGrower->Update();
}
catch (const itk::ExceptionObject &)
{
return; // can't work
}
catch (...)
{
return;
}
- // Store result and preview
- mitk::Image::Pointer resultImage = mitk::ImportItkImage(regionGrower->GetOutput(), imageGeometry)->Clone();
- mitk::LabelSetImage::Pointer resultLabelSetImage = mitk::LabelSetImage::New();
- resultLabelSetImage->InitializeByLabeledImage(resultImage);
-
- m_ResultNode->SetData(resultLabelSetImage);
-
- mitk::RenderingManager::GetInstance()->RequestUpdateAll();
+ segmentation->SetVolume((void*)(regionGrower->GetOutput()->GetPixelContainer()->GetBufferPointer()), timeStep);
}
-void mitk::PickingTool::ConfirmSegmentation()
+void mitk::PickingTool::DoUpdatePreview(const Image* /*inputAtTimeStep*/, const Image* oldSegAtTimeStep, Image* previewImage, TimeStepType timeStep)
{
- mitk::DataNode::Pointer newNode = mitk::DataNode::New();
- newNode->SetProperty("name", mitk::StringProperty::New(m_WorkingData->GetName() + "_picked"));
-
- float rgb[3] = {1.0f, 0.0f, 0.0f};
- m_WorkingData->GetColor(rgb);
- newNode->SetProperty("color", mitk::ColorProperty::New(rgb));
-
- float opacity = 1.0f;
- m_WorkingData->GetOpacity(opacity, nullptr);
- newNode->SetProperty("opacity", mitk::FloatProperty::New(opacity));
-
- newNode->SetData(m_ResultNode->GetData());
-
- GetDataStorage()->Add(newNode, this->GetReferenceData());
- m_WorkingData->SetVisibility(false);
-
- m_ResultNode->SetData(nullptr);
-
- mitk::RenderingManager::GetInstance()->RequestUpdateAll();
+ if (nullptr != oldSegAtTimeStep && nullptr != previewImage && m_PointSet.IsNotNull())
+ {
+ AccessFixedDimensionByItk_n(oldSegAtTimeStep, DoITKRegionGrowing, 3, (previewImage, this->m_PointSet, timeStep, oldSegAtTimeStep->GetGeometry()));
+ }
}
diff --git a/Modules/Segmentation/Interactions/mitkPickingTool.h b/Modules/Segmentation/Interactions/mitkPickingTool.h
index a619ecbf3d..dd092dcf28 100644
--- a/Modules/Segmentation/Interactions/mitkPickingTool.h
+++ b/Modules/Segmentation/Interactions/mitkPickingTool.h
@@ -1,95 +1,85 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
#ifndef mitkPickingTool_h_Included
#define mitkPickingTool_h_Included
-#include "itkImage.h"
-#include "mitkAutoSegmentationTool.h"
-#include "mitkCommon.h"
-#include "mitkDataStorage.h"
+#include "mitkAutoSegmentationWithPreviewTool.h"
#include "mitkPointSet.h"
-#include "mitkSinglePointDataInteractor.h"
+
#include <MitkSegmentationExports.h>
namespace us
{
class ModuleResource;
}
namespace mitk
{
/**
\brief Extracts a single region from a segmentation image and creates a new image with same geometry of the input
image.
The region is extracted in 3D space. This is done by performing region growing within the desired region.
Use shift click to add the seed point.
\ingroup ToolManagerEtAl
\sa mitk::Tool
\sa QmitkInteractiveSegmentation
*/
- class MITKSEGMENTATION_EXPORT PickingTool : public AutoSegmentationTool
+ class MITKSEGMENTATION_EXPORT PickingTool : public AutoSegmentationWithPreviewTool
{
public:
- mitkClassMacro(PickingTool, AutoSegmentationTool);
+ mitkClassMacro(PickingTool, AutoSegmentationWithPreviewTool);
itkFactorylessNewMacro(Self);
itkCloneMacro(Self);
- const char **GetXPM() const override;
+ const char **GetXPM() const override;
const char *GetName() const override;
us::ModuleResource GetIconResource() const override;
- void Activated() override;
- void Deactivated() override;
-
bool CanHandle(const BaseData* referenceData, const BaseData* workingData) const override;
- virtual DataNode::Pointer GetPointSetNode();
+ void Activated() override;
+ void Deactivated() override;
- mitk::DataNode *GetReferenceData();
- mitk::DataNode *GetWorkingData();
- mitk::DataStorage *GetDataStorage();
+ /**Clears all picks and updates the preview.*/
+ void ClearPicks();
- void ConfirmSegmentation();
+ bool HasPicks() const;
protected:
PickingTool(); // purposely hidden
~PickingTool() override;
- // Callback for point add event of PointSet
- void OnPointAdded();
+ void ConnectActionsAndFunctions() override;
- // Observer id
- long m_PointSetAddObserverTag;
+ /// \brief Add point action of StateMachine pattern
+ virtual void OnAddPoint(StateMachineAction*, InteractionEvent* interactionEvent);
- mitk::DataNode::Pointer m_ResultNode;
+ /// \brief Delete action of StateMachine pattern
+ virtual void OnDelete(StateMachineAction*, InteractionEvent* interactionEvent);
- // itk regrowing
- template <typename TPixel, unsigned int VImageDimension>
- void StartRegionGrowing(itk::Image<TPixel, VImageDimension> *itkImage,
- mitk::BaseGeometry *imageGeometry,
- mitk::PointSet::PointType seedPoint);
+ /// \brief Clear all seed points.
+ void ClearSeeds();
+
+ void DoUpdatePreview(const Image* inputAtTimeStep, const Image* oldSegAtTimeStep, Image* previewImage, TimeStepType timeStep) override;
// seed point
PointSet::Pointer m_PointSet;
- SinglePointDataInteractor::Pointer m_SeedPointInteractor;
DataNode::Pointer m_PointSetNode;
-
- DataNode *m_WorkingData;
};
} // namespace
#endif
diff --git a/Modules/Segmentation/Interactions/mitkPixelManipulationTool.cpp b/Modules/Segmentation/Interactions/mitkPixelManipulationTool.cpp
index 5a080fe056..1507bbcc3a 100644
--- a/Modules/Segmentation/Interactions/mitkPixelManipulationTool.cpp
+++ b/Modules/Segmentation/Interactions/mitkPixelManipulationTool.cpp
@@ -1,191 +1,191 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
#include "mitkPixelManipulationTool.h"
#include "mitkBoundingObjectToSegmentationFilter.h"
#include "mitkImage.h"
#include "mitkImageAccessByItk.h"
#include "mitkImageCast.h"
#include "mitkProperties.h"
#include "mitkToolManager.h"
#include <itkImageRegionIterator.h>
#include "mitkPixelManipulationTool.xpm"
namespace mitk
{
MITK_TOOL_MACRO(MITKSEGMENTATION_EXPORT, PixelManipulationTool, "Pixel manipulation tool");
}
mitk::PixelManipulationTool::PixelManipulationTool() : Tool("dummy"), m_Value(0), m_FixedValue(false)
{
}
mitk::PixelManipulationTool::~PixelManipulationTool()
{
}
void mitk::PixelManipulationTool::Activated()
{
Superclass::Activated();
- m_ToolManager->RoiDataChanged +=
+ this->GetToolManager()->RoiDataChanged +=
mitk::MessageDelegate<mitk::PixelManipulationTool>(this, &mitk::PixelManipulationTool::OnRoiDataChanged);
- m_OriginalImageNode = m_ToolManager->GetReferenceData(0);
+ m_OriginalImageNode = this->GetToolManager()->GetReferenceData(0);
if (m_OriginalImageNode.IsNotNull())
{
mitk::Image::Pointer image = dynamic_cast<mitk::Image *>(m_OriginalImageNode->GetData());
if (image.IsNotNull())
{
// mitk::ScalarType scalar = image->GetScalarValueMax();
}
}
else
- m_ToolManager->ActivateTool(-1);
+ this->GetToolManager()->ActivateTool(-1);
}
void mitk::PixelManipulationTool::Deactivated()
{
- m_ToolManager->RoiDataChanged -=
+ this->GetToolManager()->RoiDataChanged -=
mitk::MessageDelegate<mitk::PixelManipulationTool>(this, &mitk::PixelManipulationTool::OnRoiDataChanged);
Superclass::Deactivated();
}
const char *mitk::PixelManipulationTool::GetName() const
{
return "pixelmanipulation";
}
const char **mitk::PixelManipulationTool::GetXPM() const
{
return mitkPixelManipulationTool_xpm;
}
void mitk::PixelManipulationTool::OnRoiDataChanged()
{
}
void mitk::PixelManipulationTool::CalculateImage()
{
if (m_OriginalImageNode.IsNotNull())
{
mitk::Image::Pointer image = dynamic_cast<mitk::Image *>(m_OriginalImageNode->GetData());
- mitk::DataNode *maskNode = m_ToolManager->GetRoiData(0);
+ mitk::DataNode *maskNode = this->GetToolManager()->GetRoiData(0);
mitk::Image::Pointer roi = mitk::Image::New();
if (maskNode)
{
auto *boundingObject = dynamic_cast<mitk::BoundingObject *>(maskNode->GetData());
if (boundingObject)
{
mitk::BoundingObjectToSegmentationFilter::Pointer filter = mitk::BoundingObjectToSegmentationFilter::New();
filter->SetBoundingObject(boundingObject);
filter->SetInput(image);
filter->Update();
roi = filter->GetOutput();
}
else
roi = dynamic_cast<mitk::Image *>(maskNode->GetData());
mitk::Image::Pointer newImage = mitk::Image::New();
newImage->Initialize(image);
if (image)
{
AccessByItk_3(image, ITKPixelManipulation, roi, newImage, m_Value);
this->AddImageToDataStorage(newImage);
}
}
}
}
template <typename TPixel, unsigned int VImageDimension>
void mitk::PixelManipulationTool::ITKPixelManipulation(itk::Image<TPixel, VImageDimension> *originalImage,
Image *maskImage,
Image *newImage,
int newValue)
{
typedef itk::Image<TPixel, VImageDimension> itkImageType;
typedef itk::Image<unsigned char, 3> itkMaskType;
typename itkImageType::Pointer itkImage;
typename itkMaskType::Pointer itkMask;
CastToItkImage(newImage, itkImage);
CastToItkImage(maskImage, itkMask);
typedef itk::ImageRegionConstIterator<itkImageType> InputIteratorType;
typedef itk::ImageRegionIterator<itkImageType> OutputIteratorType;
typedef itk::ImageRegionConstIterator<itkMaskType> MaskIteratorType;
MaskIteratorType maskIterator(itkMask, itkMask->GetLargestPossibleRegion());
InputIteratorType inputIterator(originalImage, originalImage->GetLargestPossibleRegion());
OutputIteratorType outputIterator(itkImage, itkImage->GetLargestPossibleRegion());
inputIterator.GoToBegin();
outputIterator.GoToBegin();
maskIterator.GoToBegin();
while (!outputIterator.IsAtEnd())
{
if (maskIterator.Get())
{
if (m_FixedValue)
outputIterator.Set(newValue);
else
outputIterator.Set(inputIterator.Get() + newValue);
}
else
outputIterator.Set(inputIterator.Get());
++inputIterator;
++outputIterator;
++maskIterator;
}
}
void mitk::PixelManipulationTool::AddImageToDataStorage(mitk::Image::Pointer image)
{
if (image.IsNotNull())
{
mitk::DataNode::Pointer node = mitk::DataNode::New();
std::string name = m_OriginalImageNode->GetName();
name.append("_modified");
node->SetName(name);
node->SetProperty("binary", mitk::BoolProperty::New(false));
node->SetData(image);
- if (m_ToolManager)
- m_ToolManager->GetDataStorage()->Add(node, m_OriginalImageNode);
+ if (nullptr != this->GetToolManager())
+ this->GetToolManager()->GetDataStorage()->Add(node, m_OriginalImageNode);
}
}
void mitk::PixelManipulationTool::SetValue(int value)
{
m_Value = value;
}
int mitk::PixelManipulationTool::GetValue()
{
return m_Value;
}
void mitk::PixelManipulationTool::SetFixedValue(int value)
{
m_FixedValue = value;
}
int mitk::PixelManipulationTool::GetFixedValue()
{
return m_FixedValue;
}
diff --git a/Modules/Segmentation/Interactions/mitkRegionGrowingTool.cpp b/Modules/Segmentation/Interactions/mitkRegionGrowingTool.cpp
index 3e2617f963..0fa978346e 100644
--- a/Modules/Segmentation/Interactions/mitkRegionGrowingTool.cpp
+++ b/Modules/Segmentation/Interactions/mitkRegionGrowingTool.cpp
@@ -1,573 +1,573 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
#include "mitkRegionGrowingTool.h"
#include "mitkBaseRenderer.h"
#include "mitkImageToContourModelFilter.h"
#include "mitkRegionGrowingTool.xpm"
#include "mitkRenderingManager.h"
#include "mitkToolManager.h"
// us
#include <usGetModuleContext.h>
#include <usModule.h>
#include <usModuleContext.h>
#include <usModuleResource.h>
// ITK
#include "mitkITKImageImport.h"
#include "mitkImageAccessByItk.h"
#include <itkConnectedComponentImageFilter.h>
#include <itkConnectedThresholdImageFilter.h>
#include <itkNeighborhoodIterator.h>
#include <itkImageDuplicator.h>
#include <limits>
namespace mitk
{
MITK_TOOL_MACRO(MITKSEGMENTATION_EXPORT, RegionGrowingTool, "Region growing tool");
}
#define ROUND(a) ((a) > 0 ? (int)((a) + 0.5) : -(int)(0.5 - (a)))
mitk::RegionGrowingTool::RegionGrowingTool()
: FeedbackContourTool("PressMoveRelease"),
m_SeedValue(0),
m_ScreenYDifference(0),
m_ScreenXDifference(0),
m_MouseDistanceScaleFactor(0.5),
m_PaintingPixelValue(0),
m_FillFeedbackContour(true),
m_ConnectedComponentValue(1)
{
}
mitk::RegionGrowingTool::~RegionGrowingTool()
{
}
void mitk::RegionGrowingTool::ConnectActionsAndFunctions()
{
CONNECT_FUNCTION("PrimaryButtonPressed", OnMousePressed);
CONNECT_FUNCTION("Move", OnMouseMoved);
CONNECT_FUNCTION("Release", OnMouseReleased);
}
const char **mitk::RegionGrowingTool::GetXPM() const
{
return mitkRegionGrowingTool_xpm;
}
us::ModuleResource mitk::RegionGrowingTool::GetIconResource() const
{
us::Module *module = us::GetModuleContext()->GetModule();
us::ModuleResource resource = module->GetResource("RegionGrowing_48x48.png");
return resource;
}
us::ModuleResource mitk::RegionGrowingTool::GetCursorIconResource() const
{
us::Module *module = us::GetModuleContext()->GetModule();
us::ModuleResource resource = module->GetResource("RegionGrowing_Cursor_32x32.png");
return resource;
}
const char *mitk::RegionGrowingTool::GetName() const
{
return "Region Growing";
}
void mitk::RegionGrowingTool::Activated()
{
Superclass::Activated();
}
void mitk::RegionGrowingTool::Deactivated()
{
Superclass::Deactivated();
}
// Get the average pixel value of square/cube with radius=neighborhood around index
template <typename TPixel, unsigned int imageDimension>
void mitk::RegionGrowingTool::GetNeighborhoodAverage(const itk::Image<TPixel, imageDimension> *itkImage,
const itk::Index<imageDimension>& index,
ScalarType *result,
unsigned int neighborhood)
{
// maybe assert that image dimension is only 2 or 3?
auto neighborhoodInt = (int)neighborhood;
TPixel averageValue(0);
unsigned int numberOfPixels = (2 * neighborhood + 1) * (2 * neighborhood + 1);
if (imageDimension == 3)
{
numberOfPixels *= (2 * neighborhood + 1);
}
MITK_DEBUG << "Getting neighborhood of " << numberOfPixels << " pixels around " << index;
itk::Index<imageDimension> currentIndex;
for (int i = (0 - neighborhoodInt); i <= neighborhoodInt; ++i)
{
currentIndex[0] = index[0] + i;
for (int j = (0 - neighborhoodInt); j <= neighborhoodInt; ++j)
{
currentIndex[1] = index[1] + j;
if (imageDimension == 3)
{
for (int k = (0 - neighborhoodInt); k <= neighborhoodInt; ++k)
{
currentIndex[2] = index[2] + k;
if (itkImage->GetLargestPossibleRegion().IsInside(currentIndex))
{
averageValue += itkImage->GetPixel(currentIndex);
}
else
{
numberOfPixels -= 1;
}
}
}
else
{
if (itkImage->GetLargestPossibleRegion().IsInside(currentIndex))
{
averageValue += itkImage->GetPixel(currentIndex);
}
else
{
numberOfPixels -= 1;
}
}
}
}
*result = (ScalarType)averageValue;
*result /= numberOfPixels;
}
// Check whether index lies inside a segmentation
template <typename TPixel, unsigned int imageDimension>
void mitk::RegionGrowingTool::IsInsideSegmentation(const itk::Image<TPixel, imageDimension> *itkImage,
const itk::Index<imageDimension>& index,
bool *result)
{
if (itkImage->GetPixel(index) > 0)
{
*result = true;
}
else
{
*result = false;
}
}
// Do the region growing (i.e. call an ITK filter that does it)
template <typename TPixel, unsigned int imageDimension>
void mitk::RegionGrowingTool::StartRegionGrowing(const itk::Image<TPixel, imageDimension> *inputImage,
const itk::Index<imageDimension>& seedIndex,
const std::array<ScalarType, 2>& thresholds,
mitk::Image::Pointer &outputImage)
{
MITK_DEBUG << "Starting region growing at index " << seedIndex << " with lower threshold " << thresholds[0]
<< " and upper threshold " << thresholds[1];
typedef itk::Image<TPixel, imageDimension> InputImageType;
typedef itk::Image<DefaultSegmentationDataType, imageDimension> OutputImageType;
typedef itk::ConnectedThresholdImageFilter<InputImageType, OutputImageType> RegionGrowingFilterType;
typename RegionGrowingFilterType::Pointer regionGrower = RegionGrowingFilterType::New();
// perform region growing in desired segmented region
regionGrower->SetInput(inputImage);
regionGrower->SetSeed(seedIndex);
regionGrower->SetLower(thresholds[0]);
regionGrower->SetUpper(thresholds[1]);
try
{
regionGrower->Update();
}
catch (...)
{
return; // Should we do something?
}
typename OutputImageType::Pointer resultImage = regionGrower->GetOutput();
// Smooth result: Every pixel is replaced by the majority of the neighborhood
typedef itk::NeighborhoodIterator<OutputImageType> NeighborhoodIteratorType;
typedef itk::ImageRegionIterator<OutputImageType> ImageIteratorType;
typename NeighborhoodIteratorType::RadiusType radius;
radius.Fill(2); // for now, maybe make this something the user can adjust in the preferences?
typedef itk::ImageDuplicator< OutputImageType > DuplicatorType;
typename DuplicatorType::Pointer duplicator = DuplicatorType::New();
duplicator->SetInputImage(resultImage);
duplicator->Update();
typename OutputImageType::Pointer resultDup = duplicator->GetOutput();
NeighborhoodIteratorType neighborhoodIterator(radius, resultDup, resultDup->GetRequestedRegion());
ImageIteratorType imageIterator(resultImage, resultImage->GetRequestedRegion());
for (neighborhoodIterator.GoToBegin(), imageIterator.GoToBegin(); !neighborhoodIterator.IsAtEnd();
++neighborhoodIterator, ++imageIterator)
{
DefaultSegmentationDataType voteYes(0);
DefaultSegmentationDataType voteNo(0);
for (unsigned int i = 0; i < neighborhoodIterator.Size(); ++i)
{
if (neighborhoodIterator.GetPixel(i) > 0)
{
voteYes += 1;
}
else
{
voteNo += 1;
}
}
if (voteYes > voteNo)
{
imageIterator.Set(1);
}
else
{
imageIterator.Set(0);
}
}
if (resultImage.IsNull())
{
MITK_DEBUG << "Region growing result is empty.";
}
// Can potentially have multiple regions, use connected component image filter to label disjunct regions
typedef itk::ConnectedComponentImageFilter<OutputImageType, OutputImageType> ConnectedComponentImageFilterType;
typename ConnectedComponentImageFilterType::Pointer connectedComponentFilter =
ConnectedComponentImageFilterType::New();
connectedComponentFilter->SetInput(resultImage);
connectedComponentFilter->Update();
typename OutputImageType::Pointer resultImageCC = connectedComponentFilter->GetOutput();
m_ConnectedComponentValue = resultImageCC->GetPixel(seedIndex);
outputImage = mitk::GrabItkImageMemory(resultImageCC);
}
template <typename TPixel, unsigned int imageDimension>
void mitk::RegionGrowingTool::CalculateInitialThresholds(const itk::Image<TPixel, imageDimension>*)
{
LevelWindow levelWindow;
- m_ToolManager->GetReferenceData(0)->GetLevelWindow(levelWindow);
+ this->GetToolManager()->GetReferenceData(0)->GetLevelWindow(levelWindow);
m_ThresholdExtrema[0] = static_cast<ScalarType>(std::numeric_limits<TPixel>::lowest());
m_ThresholdExtrema[1] = static_cast<ScalarType>(std::numeric_limits<TPixel>::max());
const ScalarType lowerWindowBound = std::max(m_ThresholdExtrema[0], levelWindow.GetLowerWindowBound());
const ScalarType upperWindowBound = std::min(m_ThresholdExtrema[1], levelWindow.GetUpperWindowBound());
if (m_SeedValue < lowerWindowBound)
{
m_InitialThresholds = { m_ThresholdExtrema[0], lowerWindowBound };
}
else if (m_SeedValue > upperWindowBound)
{
m_InitialThresholds = { upperWindowBound, m_ThresholdExtrema[1] };
}
else
{
const ScalarType range = 0.1 * (upperWindowBound - lowerWindowBound); // 10% of the visible window
m_InitialThresholds[0] = std::min(std::max(lowerWindowBound, m_SeedValue - 0.5 * range), upperWindowBound - range);
m_InitialThresholds[1] = m_InitialThresholds[0] + range;
}
}
void mitk::RegionGrowingTool::OnMousePressed(StateMachineAction *, InteractionEvent *interactionEvent)
{
auto *positionEvent = dynamic_cast<mitk::InteractionPositionEvent *>(interactionEvent);
if (!positionEvent)
return;
m_LastEventSender = positionEvent->GetSender();
m_LastEventSlice = m_LastEventSender->GetSlice();
m_LastScreenPosition = Point2I(positionEvent->GetPointerPositionOnScreen());
// ReferenceSlice is from the underlying image, WorkingSlice from the active segmentation (can be empty)
m_ReferenceSlice = FeedbackContourTool::GetAffectedReferenceSlice(positionEvent);
m_WorkingSlice = FeedbackContourTool::GetAffectedWorkingSlice(positionEvent);
if (m_WorkingSlice.IsNotNull()) // can't do anything without a working slice (i.e. a possibly empty segmentation)
{
// 2. Determine if the user clicked inside or outside of the segmentation/working slice (i.e. the whole volume)
mitk::BaseGeometry::Pointer workingSliceGeometry;
workingSliceGeometry = m_WorkingSlice->GetGeometry();
workingSliceGeometry->WorldToIndex(positionEvent->GetPositionInWorld(), m_SeedPoint);
itk::Index<2> indexInWorkingSlice2D;
indexInWorkingSlice2D[0] = m_SeedPoint[0];
indexInWorkingSlice2D[1] = m_SeedPoint[1];
if (workingSliceGeometry->IsIndexInside(m_SeedPoint))
{
MITK_DEBUG << "OnMousePressed: point " << positionEvent->GetPositionInWorld() << " (index coordinates "
<< m_SeedPoint << ") is inside working slice";
// 3. determine the pixel value under the last click to determine what to do
bool inside(true);
AccessFixedDimensionByItk_2(m_WorkingSlice, IsInsideSegmentation, 2, indexInWorkingSlice2D, &inside);
m_PaintingPixelValue = inside ? 0 : 1;
if (inside)
{
MITK_DEBUG << "Clicked inside segmentation";
// For now, we're doing nothing when the user clicks inside the segmentation. Behaviour can be implemented via
// OnMousePressedInside()
// When you do, be sure to remove the m_PaintingPixelValue check in OnMouseMoved() and OnMouseReleased()
return;
}
else
{
MITK_DEBUG << "Clicked outside of segmentation";
OnMousePressedOutside(nullptr, interactionEvent);
}
}
}
}
// Use this to implement a behaviour for when the user clicks inside a segmentation (for example remove something)
// Old IpPic code is kept as comment for reference
void mitk::RegionGrowingTool::OnMousePressedInside()
{
// mitk::InteractionPositionEvent* positionEvent = dynamic_cast<mitk::InteractionPositionEvent*>( interactionEvent
// );
// //const PositionEvent* positionEvent = dynamic_cast<const PositionEvent*>(stateEvent->GetEvent()); // checked in
// OnMousePressed
// // 3.1.1. Create a skeletonization of the segmentation and try to find a nice cut
// // apply the skeletonization-and-cut algorithm
// // generate contour to remove
// // set m_ReferenceSlice = nullptr so nothing will happen during mouse move
// // remember to fill the contour with 0 in mouserelease
// mitkIpPicDescriptor* segmentationHistory = ipMITKSegmentationCreateGrowerHistory( workingPicSlice,
// m_LastWorkingSeed, nullptr ); // free again
// if (segmentationHistory)
// {
// tCutResult cutContour = ipMITKSegmentationGetCutPoints( workingPicSlice, segmentationHistory,
// initialWorkingOffset ); // tCutResult is a ipSegmentation type
// mitkIpPicFree( segmentationHistory );
// if (cutContour.cutIt)
// {
// int timestep = positionEvent->GetSender()->GetTimeStep();
// // 3.1.2 copy point from float* to mitk::Contour
// ContourModel::Pointer contourInImageIndexCoordinates = ContourModel::New();
// contourInImageIndexCoordinates->Expand(timestep + 1);
// contourInImageIndexCoordinates->SetClosed(true, timestep);
// Point3D newPoint;
// for (int index = 0; index < cutContour.deleteSize; ++index)
// {
// newPoint[0] = cutContour.deleteCurve[ 2 * index + 0 ] - 0.5;//correction is needed because the
// output of the algorithm is center based
// newPoint[1] = cutContour.deleteCurve[ 2 * index + 1 ] - 0.5;//and we want our contour displayed
// corner based.
// newPoint[2] = 0.0;
// contourInImageIndexCoordinates->AddVertex( newPoint, timestep );
// }
// free(cutContour.traceline);
// free(cutContour.deleteCurve); // perhaps visualize this for fun?
// free(cutContour.onGradient);
// ContourModel::Pointer contourInWorldCoordinates = FeedbackContourTool::BackProjectContourFrom2DSlice(
// m_WorkingSlice->GetGeometry(), contourInImageIndexCoordinates, true ); // true: sub 0.5 for
// ipSegmentation correction
// FeedbackContourTool::SetFeedbackContour( contourInWorldCoordinates );
// FeedbackContourTool::SetFeedbackContourVisible(true);
// mitk::RenderingManager::GetInstance()->RequestUpdate( positionEvent->GetSender()->GetRenderWindow() );
// m_FillFeedbackContour = true;
// }
// else
// {
// m_FillFeedbackContour = false;
// }
// }
// else
// {
// m_FillFeedbackContour = false;
// }
// m_ReferenceSlice = nullptr;
// return true;
}
void mitk::RegionGrowingTool::OnMousePressedOutside(StateMachineAction *, InteractionEvent *interactionEvent)
{
auto *positionEvent = dynamic_cast<mitk::InteractionPositionEvent *>(interactionEvent);
if (positionEvent)
{
// Get geometry and indices
mitk::BaseGeometry::Pointer workingSliceGeometry;
workingSliceGeometry = m_WorkingSlice->GetGeometry();
itk::Index<2> indexInWorkingSlice2D;
indexInWorkingSlice2D[0] = m_SeedPoint[0];
indexInWorkingSlice2D[1] = m_SeedPoint[1];
mitk::BaseGeometry::Pointer referenceSliceGeometry;
referenceSliceGeometry =
m_ReferenceSlice->GetGeometry();
itk::Index<3> indexInReferenceSlice;
itk::Index<2> indexInReferenceSlice2D;
referenceSliceGeometry->WorldToIndex(positionEvent->GetPositionInWorld(), indexInReferenceSlice);
indexInReferenceSlice2D[0] = indexInReferenceSlice[0];
indexInReferenceSlice2D[1] = indexInReferenceSlice[1];
// Get seed neighborhood
ScalarType averageValue(0);
AccessFixedDimensionByItk_3(m_ReferenceSlice, GetNeighborhoodAverage, 2, indexInReferenceSlice2D, &averageValue, 1);
m_SeedValue = averageValue;
MITK_DEBUG << "Seed value is " << m_SeedValue;
// Calculate initial thresholds
AccessFixedDimensionByItk(m_ReferenceSlice, CalculateInitialThresholds, 2);
m_Thresholds[0] = m_InitialThresholds[0];
m_Thresholds[1] = m_InitialThresholds[1];
// Perform region growing
mitk::Image::Pointer resultImage = mitk::Image::New();
AccessFixedDimensionByItk_3(
m_ReferenceSlice, StartRegionGrowing, 2, indexInWorkingSlice2D, m_Thresholds, resultImage);
resultImage->SetGeometry(workingSliceGeometry);
// Extract contour
if (resultImage.IsNotNull() && m_ConnectedComponentValue >= 1)
{
float isoOffset = 0.33;
mitk::ImageToContourModelFilter::Pointer contourExtractor = mitk::ImageToContourModelFilter::New();
contourExtractor->SetInput(resultImage);
contourExtractor->SetContourValue(m_ConnectedComponentValue - isoOffset);
contourExtractor->Update();
ContourModel::Pointer resultContour = ContourModel::New();
resultContour = contourExtractor->GetOutput();
// Show contour
if (resultContour.IsNotNull())
{
ContourModel::Pointer resultContourWorld = FeedbackContourTool::BackProjectContourFrom2DSlice(
workingSliceGeometry, FeedbackContourTool::ProjectContourTo2DSlice(m_WorkingSlice, resultContour));
FeedbackContourTool::UpdateCurrentFeedbackContour(resultContourWorld);
FeedbackContourTool::SetFeedbackContourVisible(true);
mitk::RenderingManager::GetInstance()->RequestUpdate(m_LastEventSender->GetRenderWindow());
}
}
}
}
void mitk::RegionGrowingTool::OnMouseMoved(StateMachineAction *, InteractionEvent *interactionEvent)
{
// Until OnMousePressedInside() implements a behaviour, we're just returning here whenever m_PaintingPixelValue is 0,
// i.e. when the user clicked inside the segmentation
if (m_PaintingPixelValue == 0)
{
return;
}
auto *positionEvent = dynamic_cast<mitk::InteractionPositionEvent *>(interactionEvent);
if (m_ReferenceSlice.IsNotNull() && positionEvent)
{
// Get geometry and indices
mitk::BaseGeometry::Pointer workingSliceGeometry;
workingSliceGeometry = m_WorkingSlice->GetGeometry();
itk::Index<2> indexInWorkingSlice2D;
indexInWorkingSlice2D[0] = m_SeedPoint[0];
indexInWorkingSlice2D[1] = m_SeedPoint[1];
m_ScreenYDifference += positionEvent->GetPointerPositionOnScreen()[1] - m_LastScreenPosition[1];
m_ScreenXDifference += positionEvent->GetPointerPositionOnScreen()[0] - m_LastScreenPosition[0];
m_LastScreenPosition = Point2I(positionEvent->GetPointerPositionOnScreen());
// Moving the mouse up and down adjusts the width of the threshold window,
// moving it left and right shifts the threshold window
m_Thresholds[0] = std::min(m_SeedValue, m_InitialThresholds[0] - (m_ScreenYDifference - m_ScreenXDifference) * m_MouseDistanceScaleFactor);
m_Thresholds[1] = std::max(m_SeedValue, m_InitialThresholds[1] + (m_ScreenYDifference + m_ScreenXDifference) * m_MouseDistanceScaleFactor);
// Do not exceed the pixel type extrema of the reference slice, though
m_Thresholds[0] = std::max(m_ThresholdExtrema[0], m_Thresholds[0]);
m_Thresholds[1] = std::min(m_ThresholdExtrema[1], m_Thresholds[1]);
// Perform region growing again and show the result
mitk::Image::Pointer resultImage = mitk::Image::New();
AccessFixedDimensionByItk_3(
m_ReferenceSlice, StartRegionGrowing, 2, indexInWorkingSlice2D, m_Thresholds, resultImage);
resultImage->SetGeometry(workingSliceGeometry);
// Update the contour
if (resultImage.IsNotNull() && m_ConnectedComponentValue >= 1)
{
float isoOffset = 0.33;
mitk::ImageToContourModelFilter::Pointer contourExtractor = mitk::ImageToContourModelFilter::New();
contourExtractor->SetInput(resultImage);
contourExtractor->SetContourValue(m_ConnectedComponentValue - isoOffset);
contourExtractor->Update();
ContourModel::Pointer resultContour = ContourModel::New();
resultContour = contourExtractor->GetOutput();
// Show contour
if (resultContour.IsNotNull())
{
ContourModel::Pointer resultContourWorld = FeedbackContourTool::BackProjectContourFrom2DSlice(
workingSliceGeometry, FeedbackContourTool::ProjectContourTo2DSlice(m_WorkingSlice, resultContour));
FeedbackContourTool::UpdateCurrentFeedbackContour(resultContourWorld);
FeedbackContourTool::SetFeedbackContourVisible(true);
mitk::RenderingManager::GetInstance()->ForceImmediateUpdate(positionEvent->GetSender()->GetRenderWindow());
}
}
}
}
void mitk::RegionGrowingTool::OnMouseReleased(StateMachineAction *, InteractionEvent *interactionEvent)
{
// Until OnMousePressedInside() implements a behaviour, we're just returning here whenever m_PaintingPixelValue is 0,
// i.e. when the user clicked inside the segmentation
if (m_PaintingPixelValue == 0)
{
return;
}
auto *positionEvent = dynamic_cast<mitk::InteractionPositionEvent *>(interactionEvent);
if (m_WorkingSlice.IsNotNull() && m_FillFeedbackContour && positionEvent)
{
this->WriteBackFeedbackContourAsSegmentationResult(positionEvent, m_PaintingPixelValue);
m_ScreenYDifference = 0;
m_ScreenXDifference = 0;
}
}
diff --git a/Modules/Segmentation/Interactions/mitkSegTool2D.cpp b/Modules/Segmentation/Interactions/mitkSegTool2D.cpp
index 67a2b2e8d3..ab3ce6c2a5 100644
--- a/Modules/Segmentation/Interactions/mitkSegTool2D.cpp
+++ b/Modules/Segmentation/Interactions/mitkSegTool2D.cpp
@@ -1,757 +1,757 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
#include "mitkSegTool2D.h"
#include "mitkToolManager.h"
#include "mitkBaseRenderer.h"
#include "mitkDataStorage.h"
#include "mitkPlaneGeometry.h"
// Include of the new ImageExtractor
#include "mitkMorphologicalOperations.h"
#include "mitkPlanarCircle.h"
#include "usGetModuleContext.h"
// Includes for 3DSurfaceInterpolation
#include "mitkImageTimeSelector.h"
#include "mitkImageToContourFilter.h"
#include "mitkSurfaceInterpolationController.h"
// includes for resling and overwriting
#include <mitkExtractSliceFilter.h>
#include <mitkVtkImageOverwrite.h>
#include <vtkImageData.h>
#include <vtkSmartPointer.h>
#include "mitkOperationEvent.h"
#include "mitkUndoController.h"
#include <mitkDiffSliceOperationApplier.h>
#include "mitkAbstractTransformGeometry.h"
#include "mitkLabelSetImage.h"
#include "mitkContourModelUtils.h"
#include "itkImageRegionIterator.h"
#define ROUND(a) ((a) > 0 ? (int)((a) + 0.5) : -(int)(0.5 - (a)))
bool mitk::SegTool2D::m_SurfaceInterpolationEnabled = true;
mitk::SegTool2D::SliceInformation::SliceInformation(const mitk::Image* aSlice, const mitk::PlaneGeometry* aPlane, mitk::TimeStepType aTimestep) :
slice(aSlice), plane(aPlane), timestep(aTimestep)
{
}
mitk::SegTool2D::SegTool2D(const char *type, const us::Module *interactorModule)
: Tool(type, interactorModule), m_Contourmarkername("Position")
{
Tool::m_EventConfig = "DisplayConfigMITKNoCrosshair.xml";
}
mitk::SegTool2D::~SegTool2D()
{
}
bool mitk::SegTool2D::FilterEvents(InteractionEvent *interactionEvent, DataNode *)
{
const auto *positionEvent = dynamic_cast<const InteractionPositionEvent *>(interactionEvent);
bool isValidEvent =
(positionEvent && // Only events of type mitk::InteractionPositionEvent
interactionEvent->GetSender()->GetMapperID() == BaseRenderer::Standard2D // Only events from the 2D renderwindows
);
return isValidEvent;
}
bool mitk::SegTool2D::DetermineAffectedImageSlice(const Image *image,
const PlaneGeometry *plane,
int &affectedDimension,
int &affectedSlice)
{
assert(image);
assert(plane);
// compare normal of plane to the three axis vectors of the image
Vector3D normal = plane->GetNormal();
Vector3D imageNormal0 = image->GetSlicedGeometry()->GetAxisVector(0);
Vector3D imageNormal1 = image->GetSlicedGeometry()->GetAxisVector(1);
Vector3D imageNormal2 = image->GetSlicedGeometry()->GetAxisVector(2);
normal.Normalize();
imageNormal0.Normalize();
imageNormal1.Normalize();
imageNormal2.Normalize();
imageNormal0.SetVnlVector(vnl_cross_3d<ScalarType>(normal.GetVnlVector(), imageNormal0.GetVnlVector()));
imageNormal1.SetVnlVector(vnl_cross_3d<ScalarType>(normal.GetVnlVector(), imageNormal1.GetVnlVector()));
imageNormal2.SetVnlVector(vnl_cross_3d<ScalarType>(normal.GetVnlVector(), imageNormal2.GetVnlVector()));
double eps(0.00001);
// axial
if (imageNormal2.GetNorm() <= eps)
{
affectedDimension = 2;
}
// sagittal
else if (imageNormal1.GetNorm() <= eps)
{
affectedDimension = 1;
}
// frontal
else if (imageNormal0.GetNorm() <= eps)
{
affectedDimension = 0;
}
else
{
affectedDimension = -1; // no idea
return false;
}
// determine slice number in image
BaseGeometry *imageGeometry = image->GetGeometry(0);
Point3D testPoint = imageGeometry->GetCenter();
Point3D projectedPoint;
plane->Project(testPoint, projectedPoint);
Point3D indexPoint;
imageGeometry->WorldToIndex(projectedPoint, indexPoint);
affectedSlice = ROUND(indexPoint[affectedDimension]);
MITK_DEBUG << "indexPoint " << indexPoint << " affectedDimension " << affectedDimension << " affectedSlice "
<< affectedSlice;
// check if this index is still within the image
if (affectedSlice < 0 || affectedSlice >= static_cast<int>(image->GetDimension(affectedDimension)))
return false;
return true;
}
void mitk::SegTool2D::UpdateSurfaceInterpolation(const Image *slice,
const Image *workingImage,
const PlaneGeometry *plane,
bool detectIntersection)
{
std::vector<SliceInformation> slices = { SliceInformation(slice, plane, 0)};
Self::UpdateSurfaceInterpolation(slices, workingImage, detectIntersection);
}
void mitk::SegTool2D::RemoveContourFromInterpolator(const SliceInformation& sliceInfo)
{
mitk::SurfaceInterpolationController::ContourPositionInformation contourInfo;
contourInfo.contourNormal = sliceInfo.plane->GetNormal();
contourInfo.contourPoint = sliceInfo.plane->GetOrigin();
mitk::SurfaceInterpolationController::GetInstance()->RemoveContour(contourInfo);
}
void mitk::SegTool2D::UpdateSurfaceInterpolation(const std::vector<SliceInformation>& sliceInfos,
const Image* workingImage,
bool detectIntersection)
{
if (!m_SurfaceInterpolationEnabled)
return;
//Remark: the ImageTimeSelector is just needed to extract a timestep/channel of
//the image in order to get the image dimension (time dimension and channel dimension
//stripped away). Therfore it is OK to always use time step 0 and channel 0
mitk::ImageTimeSelector::Pointer timeSelector = mitk::ImageTimeSelector::New();
timeSelector->SetInput(workingImage);
timeSelector->SetTimeNr(0);
timeSelector->SetChannelNr(0);
timeSelector->Update();
const auto dimRefImg = timeSelector->GetOutput()->GetDimension();
if (dimRefImg != 3)
return;
std::vector<mitk::Surface::Pointer> contourList;
contourList.reserve(sliceInfos.size());
ImageToContourFilter::Pointer contourExtractor = ImageToContourFilter::New();
std::vector<SliceInformation> relevantSlices = sliceInfos;
if (detectIntersection)
{
relevantSlices.clear();
for (const auto& sliceInfo : sliceInfos)
{
// Test whether there is something to extract or whether the slice just contains intersections of others
mitk::Image::Pointer slice2 = sliceInfo.slice->Clone();
mitk::MorphologicalOperations::Erode(slice2, 2, mitk::MorphologicalOperations::Ball);
contourExtractor->SetInput(slice2);
contourExtractor->Update();
mitk::Surface::Pointer contour = contourExtractor->GetOutput();
if (contour->GetVtkPolyData()->GetNumberOfPoints() == 0)
{
Self::RemoveContourFromInterpolator(sliceInfo);
}
else
{
relevantSlices.push_back(sliceInfo);
}
}
}
if (relevantSlices.empty())
return;
for (const auto& sliceInfo : relevantSlices)
{
contourExtractor->SetInput(sliceInfo.slice);
contourExtractor->Update();
mitk::Surface::Pointer contour = contourExtractor->GetOutput();
if (contour->GetVtkPolyData()->GetNumberOfPoints() == 0)
{
Self::RemoveContourFromInterpolator(sliceInfo);
}
else
{
contour->DisconnectPipeline();
contourList.push_back(contour);
}
}
mitk::SurfaceInterpolationController::GetInstance()->AddNewContours(contourList);
}
mitk::Image::Pointer mitk::SegTool2D::GetAffectedImageSliceAs2DImage(const InteractionPositionEvent *positionEvent, const Image *image, unsigned int component /*= 0*/)
{
if (!positionEvent)
{
return nullptr;
}
assert(positionEvent->GetSender()); // sure, right?
const auto timeStep = positionEvent->GetSender()->GetTimeStep(image); // get the timestep of the visible part (time-wise) of the image
return GetAffectedImageSliceAs2DImage(positionEvent->GetSender()->GetCurrentWorldPlaneGeometry(), image, timeStep, component);
}
mitk::Image::Pointer mitk::SegTool2D::GetAffectedImageSliceAs2DImageByTimePoint(const PlaneGeometry* planeGeometry, const Image* image, TimePointType timePoint, unsigned int component /*= 0*/)
{
if (!image || !planeGeometry)
{
return nullptr;
}
if (!image->GetTimeGeometry()->IsValidTimePoint(timePoint))
return nullptr;
return SegTool2D::GetAffectedImageSliceAs2DImage(planeGeometry, image, image->GetTimeGeometry()->TimePointToTimeStep(timePoint), component);
}
mitk::Image::Pointer mitk::SegTool2D::GetAffectedImageSliceAs2DImage(const PlaneGeometry *planeGeometry, const Image *image, TimeStepType timeStep, unsigned int component /*= 0*/)
{
if (!image || !planeGeometry)
{
return nullptr;
}
// Make sure that for reslicing and overwriting the same alogrithm is used. We can specify the mode of the vtk reslicer
vtkSmartPointer<mitkVtkImageOverwrite> reslice = vtkSmartPointer<mitkVtkImageOverwrite>::New();
// set to false to extract a slice
reslice->SetOverwriteMode(false);
reslice->Modified();
// use ExtractSliceFilter with our specific vtkImageReslice for overwriting and extracting
mitk::ExtractSliceFilter::Pointer extractor = mitk::ExtractSliceFilter::New(reslice);
extractor->SetInput(image);
extractor->SetTimeStep(timeStep);
extractor->SetWorldGeometry(planeGeometry);
extractor->SetVtkOutputRequest(false);
extractor->SetResliceTransformByGeometry(image->GetTimeGeometry()->GetGeometryForTimeStep(timeStep));
// additionally extract the given component
// default is 0; the extractor checks for multi-component images
extractor->SetComponent(component);
extractor->Modified();
extractor->Update();
Image::Pointer slice = extractor->GetOutput();
return slice;
}
mitk::Image::Pointer mitk::SegTool2D::GetAffectedWorkingSlice(const InteractionPositionEvent *positionEvent) const
{
const auto workingNode = this->GetWorkingDataNode();
if (!workingNode)
{
return nullptr;
}
const auto *workingImage = dynamic_cast<Image *>(workingNode->GetData());
if (!workingImage)
{
return nullptr;
}
return GetAffectedImageSliceAs2DImage(positionEvent, workingImage);
}
mitk::Image::Pointer mitk::SegTool2D::GetAffectedReferenceSlice(const InteractionPositionEvent *positionEvent) const
{
DataNode* referenceNode = this->GetReferenceDataNode();
if (!referenceNode)
{
return nullptr;
}
auto *referenceImage = dynamic_cast<Image *>(referenceNode->GetData());
if (!referenceImage)
{
return nullptr;
}
int displayedComponent = 0;
if (referenceNode->GetIntProperty("Image.Displayed Component", displayedComponent))
{
// found the displayed component
return GetAffectedImageSliceAs2DImage(positionEvent, referenceImage, displayedComponent);
}
else
{
return GetAffectedImageSliceAs2DImage(positionEvent, referenceImage);
}
}
mitk::Image::Pointer mitk::SegTool2D::GetAffectedReferenceSlice(const PlaneGeometry* planeGeometry, TimeStepType timeStep) const
{
DataNode* referenceNode = this->GetReferenceDataNode();
if (!referenceNode)
{
return nullptr;
}
auto* referenceImage = dynamic_cast<Image*>(referenceNode->GetData());
if (!referenceImage)
{
return nullptr;
}
int displayedComponent = 0;
if (referenceNode->GetIntProperty("Image.Displayed Component", displayedComponent))
{
// found the displayed component
return GetAffectedImageSliceAs2DImage(planeGeometry, referenceImage, timeStep, displayedComponent);
}
else
{
return GetAffectedImageSliceAs2DImage(planeGeometry, referenceImage, timeStep);
}
}
void mitk::SegTool2D::Activated()
{
Superclass::Activated();
- m_ToolManager->SelectedTimePointChanged +=
+ this->GetToolManager()->SelectedTimePointChanged +=
mitk::MessageDelegate<mitk::SegTool2D>(this, &mitk::SegTool2D::OnTimePointChangedInternal);
m_LastTimePointTriggered = mitk::RenderingManager::GetInstance()->GetTimeNavigationController()->GetSelectedTimePoint();
}
void mitk::SegTool2D::Deactivated()
{
- m_ToolManager->SelectedTimePointChanged -=
+ this->GetToolManager()->SelectedTimePointChanged -=
mitk::MessageDelegate<mitk::SegTool2D>(this, &mitk::SegTool2D::OnTimePointChangedInternal);
Superclass::Deactivated();
}
void mitk::SegTool2D::OnTimePointChangedInternal()
{
if (m_IsTimePointChangeAware && nullptr != this->GetWorkingDataNode())
{
const auto timePoint = mitk::RenderingManager::GetInstance()->GetTimeNavigationController()->GetSelectedTimePoint();
if (timePoint != m_LastTimePointTriggered)
{
m_LastTimePointTriggered = timePoint;
this->OnTimePointChanged();
}
}
}
void mitk::SegTool2D::OnTimePointChanged()
{
//default implementation does nothing
}
mitk::DataNode* mitk::SegTool2D::GetWorkingDataNode() const
{
- if (nullptr != m_ToolManager)
+ if (nullptr != this->GetToolManager())
{
- return m_ToolManager->GetWorkingData(0);
+ return this->GetToolManager()->GetWorkingData(0);
}
return nullptr;
}
mitk::Image* mitk::SegTool2D::GetWorkingData() const
{
auto node = this->GetWorkingDataNode();
if (nullptr != node)
{
return dynamic_cast<Image*>(node->GetData());
}
return nullptr;
}
mitk::DataNode* mitk::SegTool2D::GetReferenceDataNode() const
{
- if (nullptr != m_ToolManager)
+ if (nullptr != this->GetToolManager())
{
- return m_ToolManager->GetReferenceData(0);
+ return this->GetToolManager()->GetReferenceData(0);
}
return nullptr;
}
mitk::Image* mitk::SegTool2D::GetReferenceData() const
{
auto node = this->GetReferenceDataNode();
if (nullptr != node)
{
return dynamic_cast<Image*>(node->GetData());
}
return nullptr;
}
void mitk::SegTool2D::WriteBackSegmentationResult(const InteractionPositionEvent *positionEvent, const Image * segmentationResult)
{
if (!positionEvent)
return;
const PlaneGeometry *planeGeometry((positionEvent->GetSender()->GetCurrentWorldPlaneGeometry()));
const auto *abstractTransformGeometry(
dynamic_cast<const AbstractTransformGeometry *>(positionEvent->GetSender()->GetCurrentWorldPlaneGeometry()));
if (planeGeometry && segmentationResult && !abstractTransformGeometry)
{
const auto workingNode = this->GetWorkingDataNode();
auto *image = dynamic_cast<Image *>(workingNode->GetData());
const auto timeStep = positionEvent->GetSender()->GetTimeStep(image);
this->WriteBackSegmentationResult(planeGeometry, segmentationResult, timeStep);
}
}
void mitk::SegTool2D::WriteBackSegmentationResult(const DataNode* workingNode, const PlaneGeometry* planeGeometry, const Image* segmentationResult, TimeStepType timeStep)
{
if (!planeGeometry || !segmentationResult)
return;
SliceInformation sliceInfo(segmentationResult, const_cast<mitk::PlaneGeometry*>(planeGeometry), timeStep);
Self::WriteBackSegmentationResults(workingNode, { sliceInfo }, true);
}
void mitk::SegTool2D::WriteBackSegmentationResult(const PlaneGeometry *planeGeometry,
const Image * segmentationResult,
TimeStepType timeStep)
{
if (!planeGeometry || !segmentationResult)
return;
SliceInformation sliceInfo(segmentationResult, const_cast<mitk::PlaneGeometry *>(planeGeometry), timeStep);
WriteBackSegmentationResults({ sliceInfo }, true);
}
void mitk::SegTool2D::WriteBackSegmentationResults(const std::vector<SegTool2D::SliceInformation> &sliceList,
bool writeSliceToVolume)
{
if (sliceList.empty())
{
return;
}
if (nullptr == m_LastEventSender)
{
MITK_WARN << "Cannot write tool results. Tool seems to be in an invalid state, as no interaction event was recieved but is expected.";
return;
}
const auto workingNode = this->GetWorkingDataNode();
mitk::SegTool2D::WriteBackSegmentationResults(workingNode, sliceList, writeSliceToVolume);
// the first geometry is needed otherwise restoring the position is not working
const auto* plane3 =
dynamic_cast<const PlaneGeometry*>(dynamic_cast<const mitk::SlicedGeometry3D*>(
m_LastEventSender->GetSliceNavigationController()->GetCurrentGeometry3D())
->GetPlaneGeometry(0));
unsigned int slicePosition = m_LastEventSender->GetSliceNavigationController()->GetSlice()->GetPos();
/* A cleaner solution would be to add a contour marker for each slice info. It currently
does not work as the contour markers expect that the plane is always the plane of slice 0.
Had not the time to do it properly no. Should be solved by T28146*/
this->AddContourmarker(plane3, slicePosition);
}
void mitk::SegTool2D::WriteBackSegmentationResults(const DataNode* workingNode, const std::vector<SliceInformation>& sliceList, bool writeSliceToVolume)
{
if (sliceList.empty())
{
return;
}
if (nullptr == workingNode)
{
mitkThrow() << "Cannot write slice to working node. Working node is invalid.";
}
auto* image = dynamic_cast<Image*>(workingNode->GetData());
if (nullptr == image)
{
mitkThrow() << "Cannot write slice to working node. Working node does not contain an image.";
}
for (const auto& sliceInfo : sliceList)
{
if (writeSliceToVolume && nullptr != sliceInfo.plane && sliceInfo.slice.IsNotNull())
{
mitk::SegTool2D::WriteSliceToVolume(image, sliceInfo, true);
}
}
mitk::SegTool2D::UpdateSurfaceInterpolation(sliceList, image, false);
// also mark its node as modified (T27308). Can be removed if T27307
// is properly solved
if (workingNode != nullptr) workingNode->Modified();
mitk::RenderingManager::GetInstance()->RequestUpdateAll();
}
void mitk::SegTool2D::WriteSliceToVolume(Image* workingImage, const PlaneGeometry* planeGeometry, const Image* slice, TimeStepType timeStep, bool allowUndo)
{
SliceInformation sliceInfo(slice, planeGeometry, timeStep);
WriteSliceToVolume(workingImage, sliceInfo , allowUndo);
}
void mitk::SegTool2D::WriteSliceToVolume(Image* workingImage, const SliceInformation &sliceInfo, bool allowUndo)
{
if (nullptr == workingImage)
{
mitkThrow() << "Cannot write slice to working node. Working node does not contain an image.";
}
DiffSliceOperation* undoOperation = nullptr;
if (allowUndo)
{
/*============= BEGIN undo/redo feature block ========================*/
// Create undo operation by caching the not yet modified slices
mitk::Image::Pointer originalSlice = GetAffectedImageSliceAs2DImage(sliceInfo.plane, workingImage, sliceInfo.timestep);
undoOperation =
new DiffSliceOperation(workingImage,
originalSlice,
dynamic_cast<SlicedGeometry3D*>(originalSlice->GetGeometry()),
sliceInfo.timestep,
sliceInfo.plane);
/*============= END undo/redo feature block ========================*/
}
// Make sure that for reslicing and overwriting the same alogrithm is used. We can specify the mode of the vtk
// reslicer
vtkSmartPointer<mitkVtkImageOverwrite> reslice = vtkSmartPointer<mitkVtkImageOverwrite>::New();
// Set the slice as 'input'
// casting const away is needed and OK as long the OverwriteMode of
// mitkVTKImageOverwrite is true.
// Reason: because then the input slice is not touched but
// used to overwrite the input of the ExtractSliceFilter.
auto noneConstSlice = const_cast<Image*>(sliceInfo.slice.GetPointer());
reslice->SetInputSlice(noneConstSlice->GetVtkImageData());
// set overwrite mode to true to write back to the image volume
reslice->SetOverwriteMode(true);
reslice->Modified();
mitk::ExtractSliceFilter::Pointer extractor = mitk::ExtractSliceFilter::New(reslice);
extractor->SetInput(workingImage);
extractor->SetTimeStep(sliceInfo.timestep);
extractor->SetWorldGeometry(sliceInfo.plane);
extractor->SetVtkOutputRequest(false);
extractor->SetResliceTransformByGeometry(workingImage->GetGeometry(sliceInfo.timestep));
extractor->Modified();
extractor->Update();
// the image was modified within the pipeline, but not marked so
workingImage->Modified();
workingImage->GetVtkImageData()->Modified();
if (allowUndo)
{
/*============= BEGIN undo/redo feature block ========================*/
// specify the redo operation with the edited slice
auto* doOperation =
new DiffSliceOperation(workingImage,
extractor->GetOutput(),
dynamic_cast<SlicedGeometry3D*>(sliceInfo.slice->GetGeometry()),
sliceInfo.timestep,
sliceInfo.plane);
// create an operation event for the undo stack
OperationEvent* undoStackItem =
new OperationEvent(DiffSliceOperationApplier::GetInstance(), doOperation, undoOperation, "Segmentation");
// add it to the undo controller
UndoStackItem::IncCurrObjectEventId();
UndoStackItem::IncCurrGroupEventId();
UndoController::GetCurrentUndoModel()->SetOperationEvent(undoStackItem);
/*============= END undo/redo feature block ========================*/
}
}
void mitk::SegTool2D::SetShowMarkerNodes(bool status)
{
m_ShowMarkerNodes = status;
}
void mitk::SegTool2D::SetEnable3DInterpolation(bool enabled)
{
m_SurfaceInterpolationEnabled = enabled;
}
int mitk::SegTool2D::AddContourmarker(const PlaneGeometry* planeGeometry, unsigned int sliceIndex)
{
if (planeGeometry == nullptr)
return -1;
us::ServiceReference<PlanePositionManagerService> serviceRef =
us::GetModuleContext()->GetServiceReference<PlanePositionManagerService>();
PlanePositionManagerService *service = us::GetModuleContext()->GetService(serviceRef);
unsigned int size = service->GetNumberOfPlanePositions();
unsigned int id = service->AddNewPlanePosition(planeGeometry, sliceIndex);
mitk::PlanarCircle::Pointer contourMarker = mitk::PlanarCircle::New();
mitk::Point2D p1;
planeGeometry->Map(planeGeometry->GetCenter(), p1);
mitk::Point2D p2 = p1;
p2[0] -= planeGeometry->GetSpacing()[0];
p2[1] -= planeGeometry->GetSpacing()[1];
contourMarker->PlaceFigure(p1);
contourMarker->SetCurrentControlPoint(p1);
contourMarker->SetPlaneGeometry(planeGeometry->Clone());
std::stringstream markerStream;
auto workingNode = this->GetWorkingDataNode();
markerStream << m_Contourmarkername;
markerStream << " ";
markerStream << id + 1;
DataNode::Pointer rotatedContourNode = DataNode::New();
rotatedContourNode->SetData(contourMarker);
rotatedContourNode->SetProperty("name", StringProperty::New(markerStream.str()));
rotatedContourNode->SetProperty("isContourMarker", BoolProperty::New(true));
rotatedContourNode->SetBoolProperty("PlanarFigureInitializedWindow", true, m_LastEventSender);
rotatedContourNode->SetProperty("includeInBoundingBox", BoolProperty::New(false));
rotatedContourNode->SetProperty("helper object", mitk::BoolProperty::New(!m_ShowMarkerNodes));
rotatedContourNode->SetProperty("planarfigure.drawcontrolpoints", BoolProperty::New(false));
rotatedContourNode->SetProperty("planarfigure.drawname", BoolProperty::New(false));
rotatedContourNode->SetProperty("planarfigure.drawoutline", BoolProperty::New(false));
rotatedContourNode->SetProperty("planarfigure.drawshadow", BoolProperty::New(false));
if (planeGeometry)
{
if (id == size)
{
- m_ToolManager->GetDataStorage()->Add(rotatedContourNode, workingNode);
+ this->GetToolManager()->GetDataStorage()->Add(rotatedContourNode, workingNode);
}
else
{
mitk::NodePredicateProperty::Pointer isMarker =
mitk::NodePredicateProperty::New("isContourMarker", mitk::BoolProperty::New(true));
mitk::DataStorage::SetOfObjects::ConstPointer markers =
- m_ToolManager->GetDataStorage()->GetDerivations(workingNode, isMarker);
+ this->GetToolManager()->GetDataStorage()->GetDerivations(workingNode, isMarker);
for (auto iter = markers->begin(); iter != markers->end(); ++iter)
{
std::string nodeName = (*iter)->GetName();
unsigned int t = nodeName.find_last_of(" ");
unsigned int markerId = atof(nodeName.substr(t + 1).c_str()) - 1;
if (id == markerId)
{
return id;
}
}
- m_ToolManager->GetDataStorage()->Add(rotatedContourNode, workingNode);
+ this->GetToolManager()->GetDataStorage()->Add(rotatedContourNode, workingNode);
}
}
return id;
}
void mitk::SegTool2D::InteractiveSegmentationBugMessage(const std::string &message) const
{
MITK_ERROR << "********************************************************************************" << std::endl
<< " " << message << std::endl
<< "********************************************************************************" << std::endl
<< " " << std::endl
<< " If your image is rotated or the 2D views don't really contain the patient image, try to press the "
"button next to the image selection. "
<< std::endl
<< " " << std::endl
<< " Please file a BUG REPORT: " << std::endl
<< " https://phabricator.mitk.org/" << std::endl
<< " Contain the following information:" << std::endl
<< " - What image were you working on?" << std::endl
<< " - Which region of the image?" << std::endl
<< " - Which tool did you use?" << std::endl
<< " - What did you do?" << std::endl
<< " - What happened (not)? What did you expect?" << std::endl;
}
void mitk::SegTool2D::WritePreviewOnWorkingImage(
Image *targetSlice, const Image *sourceSlice, const Image *workingImage, int paintingPixelValue)
{
if (nullptr == targetSlice)
{
mitkThrow() << "Cannot write preview on working image. Target slice does not point to a valid instance.";
}
if (nullptr == sourceSlice)
{
mitkThrow() << "Cannot write preview on working image. Source slice does not point to a valid instance.";
}
if (nullptr == workingImage)
{
mitkThrow() << "Cannot write preview on working image. Working image does not point to a valid instance.";
}
auto constVtkSource = sourceSlice->GetVtkImageData();
/*Need to const cast because Vtk interface does not support const correctly.
(or I am not experienced enough to use it correctly)*/
auto nonConstVtkSource = const_cast<vtkImageData*>(constVtkSource);
ContourModelUtils::FillSliceInSlice(nonConstVtkSource, targetSlice->GetVtkImageData(), workingImage, paintingPixelValue, 1.0);
}
diff --git a/Modules/Segmentation/Interactions/mitkSegmentationsProcessingTool.cpp b/Modules/Segmentation/Interactions/mitkSegmentationsProcessingTool.cpp
index 4e6848a45c..96d82261d6 100644
--- a/Modules/Segmentation/Interactions/mitkSegmentationsProcessingTool.cpp
+++ b/Modules/Segmentation/Interactions/mitkSegmentationsProcessingTool.cpp
@@ -1,103 +1,103 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
#include "mitkSegmentationsProcessingTool.h"
#include "mitkProgressBar.h"
#include "mitkToolManager.h"
mitk::SegmentationsProcessingTool::SegmentationsProcessingTool() : Tool("dummy")
{
}
mitk::SegmentationsProcessingTool::~SegmentationsProcessingTool()
{
}
const char *mitk::SegmentationsProcessingTool::GetGroup() const
{
return "segmentationProcessing";
}
void mitk::SegmentationsProcessingTool::Activated()
{
Superclass::Activated();
ProcessAllObjects();
- m_ToolManager->ActivateTool(-1);
+ this->GetToolManager()->ActivateTool(-1);
}
void mitk::SegmentationsProcessingTool::Deactivated()
{
Superclass::Deactivated();
}
void mitk::SegmentationsProcessingTool::ProcessAllObjects()
{
m_FailedNodes.clear();
StartProcessingAllData();
- ToolManager::DataVectorType nodes = m_ToolManager->GetWorkingData();
+ ToolManager::DataVectorType nodes = this->GetToolManager()->GetWorkingData();
ProgressBar::GetInstance()->AddStepsToDo(nodes.size() + 2);
// for all selected nodes
for (auto nodeiter = nodes.begin(); nodeiter != nodes.end(); ++nodeiter)
{
DataNode::Pointer node = *nodeiter;
if (!ProcessOneWorkingData(node))
{
std::string nodeName;
m_FailedNodes += " '";
if (node->GetName(nodeName))
{
m_FailedNodes += nodeName.c_str();
}
else
{
m_FailedNodes += "(no name)";
}
m_FailedNodes += "'";
}
ProgressBar::GetInstance()->Progress();
}
FinishProcessingAllData();
ProgressBar::GetInstance()->Progress(2);
}
void mitk::SegmentationsProcessingTool::StartProcessingAllData()
{
}
bool mitk::SegmentationsProcessingTool::ProcessOneWorkingData(DataNode *)
{
return true;
}
void mitk::SegmentationsProcessingTool::FinishProcessingAllData()
{
SendErrorMessageIfAny();
}
void mitk::SegmentationsProcessingTool::SendErrorMessageIfAny()
{
if (!m_FailedNodes.empty())
{
Tool::ErrorMessage(GetErrorMessage() + m_FailedNodes);
}
}
std::string mitk::SegmentationsProcessingTool::GetErrorMessage()
{
return "Processing of these nodes failed:";
}
diff --git a/Modules/Segmentation/Interactions/mitkSetRegionTool.cpp b/Modules/Segmentation/Interactions/mitkSetRegionTool.cpp
index da8a94ed20..486679ddaf 100644
--- a/Modules/Segmentation/Interactions/mitkSetRegionTool.cpp
+++ b/Modules/Segmentation/Interactions/mitkSetRegionTool.cpp
@@ -1,138 +1,138 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
#include "mitkSetRegionTool.h"
#include "mitkToolManager.h"
#include "mitkBaseRenderer.h"
#include <mitkITKImageImport.h>
#include <mitkImageToContourModelFilter.h>
#include <itkBinaryFillholeImageFilter.h>
#include <itkConnectedThresholdImageFilter.h>
mitk::SetRegionTool::SetRegionTool(int paintingPixelValue)
: FeedbackContourTool("PressMoveRelease"), m_PaintingPixelValue(paintingPixelValue)
{
}
mitk::SetRegionTool::~SetRegionTool()
{
}
void mitk::SetRegionTool::ConnectActionsAndFunctions()
{
CONNECT_FUNCTION("PrimaryButtonPressed", OnMousePressed);
CONNECT_FUNCTION("Release", OnMouseReleased);
CONNECT_FUNCTION("Move", OnMouseMoved);
}
void mitk::SetRegionTool::Activated()
{
Superclass::Activated();
}
void mitk::SetRegionTool::Deactivated()
{
Superclass::Deactivated();
}
void mitk::SetRegionTool::OnMousePressed(StateMachineAction *, InteractionEvent *interactionEvent)
{
auto *positionEvent = dynamic_cast<mitk::InteractionPositionEvent *>(interactionEvent);
if (!positionEvent)
return;
m_LastEventSender = positionEvent->GetSender();
m_LastEventSlice = m_LastEventSender->GetSlice();
// 1. Get the working image
Image::Pointer workingSlice = FeedbackContourTool::GetAffectedWorkingSlice(positionEvent);
if (workingSlice.IsNull())
return; // can't do anything without the segmentation
// if click was outside the image, don't continue
const BaseGeometry *sliceGeometry = workingSlice->GetGeometry();
itk::Index<3> projectedPointIn2D;
sliceGeometry->WorldToIndex(positionEvent->GetPositionInWorld(), projectedPointIn2D);
if (!sliceGeometry->IsIndexInside(projectedPointIn2D))
{
MITK_WARN << "Point outside of segmentation slice." << std::endl;
return; // can't use that as a seed point
}
typedef itk::Image<DefaultSegmentationDataType, 2> InputImageType;
typedef InputImageType::IndexType IndexType;
typedef itk::ConnectedThresholdImageFilter<InputImageType, InputImageType> RegionGrowingFilterType;
RegionGrowingFilterType::Pointer regionGrower = RegionGrowingFilterType::New();
// convert world coordinates to image indices
IndexType seedIndex;
sliceGeometry->WorldToIndex(positionEvent->GetPositionInWorld(), seedIndex);
// perform region growing in desired segmented region
InputImageType::Pointer itkImage = InputImageType::New();
CastToItkImage(workingSlice, itkImage);
regionGrower->SetInput(itkImage);
regionGrower->AddSeed(seedIndex);
InputImageType::PixelType bound = itkImage->GetPixel(seedIndex);
regionGrower->SetLower(bound);
regionGrower->SetUpper(bound);
regionGrower->SetReplaceValue(1);
itk::BinaryFillholeImageFilter<InputImageType>::Pointer fillHolesFilter =
itk::BinaryFillholeImageFilter<InputImageType>::New();
fillHolesFilter->SetInput(regionGrower->GetOutput());
fillHolesFilter->SetForegroundValue(1);
// Store result and preview
mitk::Image::Pointer resultImage = mitk::GrabItkImageMemory(fillHolesFilter->GetOutput());
resultImage->SetGeometry(workingSlice->GetGeometry());
// Get the current working color
- DataNode *workingNode(m_ToolManager->GetWorkingData(0));
+ DataNode *workingNode(this->GetToolManager()->GetWorkingData(0));
if (!workingNode)
return;
mitk::ImageToContourModelFilter::Pointer contourextractor = mitk::ImageToContourModelFilter::New();
contourextractor->SetInput(resultImage);
contourextractor->Update();
mitk::ContourModel::Pointer awesomeContour = contourextractor->GetOutput();
this->UpdateCurrentFeedbackContour(awesomeContour);
FeedbackContourTool::SetFeedbackContourVisible(true);
mitk::RenderingManager::GetInstance()->RequestUpdate(positionEvent->GetSender()->GetRenderWindow());
}
void mitk::SetRegionTool::OnMouseReleased(StateMachineAction *, InteractionEvent *interactionEvent)
{
auto *positionEvent = dynamic_cast<mitk::InteractionPositionEvent *>(interactionEvent);
if (!positionEvent)
return;
assert(positionEvent->GetSender()->GetRenderWindow());
// 1. Hide the feedback contour, find out which slice the user clicked, find out which slice of the toolmanager's
// working image corresponds to that
mitk::RenderingManager::GetInstance()->RequestUpdate(positionEvent->GetSender()->GetRenderWindow());
this->WriteBackFeedbackContourAsSegmentationResult(positionEvent, m_PaintingPixelValue);
}
void mitk::SetRegionTool::OnMouseMoved(mitk::StateMachineAction *, mitk::InteractionEvent *)
{
}
diff --git a/Modules/Segmentation/Interactions/mitkTool.cpp b/Modules/Segmentation/Interactions/mitkTool.cpp
index 5f15bc5dbf..e17746d67a 100644
--- a/Modules/Segmentation/Interactions/mitkTool.cpp
+++ b/Modules/Segmentation/Interactions/mitkTool.cpp
@@ -1,333 +1,348 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
#include "mitkTool.h"
#include <mitkAnatomicalStructureColorPresets.h>
#include "mitkDisplayInteractor.h"
#include "mitkDisplayActionEventBroadcast.h"
#include "mitkImageReadAccessor.h"
#include "mitkImageWriteAccessor.h"
#include "mitkLevelWindowProperty.h"
#include "mitkLookupTableProperty.h"
#include "mitkProperties.h"
#include "mitkVtkResliceInterpolationProperty.h"
#include <mitkDICOMSegmentationPropertyHelper.cpp>
+#include <mitkToolManager.h>
// us
#include <usGetModuleContext.h>
#include <usModuleResource.h>
// itk
#include <itkObjectFactory.h>
mitk::Tool::Tool(const char *type, const us::Module *interactorModule)
: m_EventConfig("DisplayConfigMITK.xml"),
m_ToolManager(nullptr),
m_PredicateImages(NodePredicateDataType::New("Image")), // for reference images
m_PredicateDim3(NodePredicateDimension::New(3, 1)),
m_PredicateDim4(NodePredicateDimension::New(4, 1)),
m_PredicateDimension(mitk::NodePredicateOr::New(m_PredicateDim3, m_PredicateDim4)),
m_PredicateImage3D(NodePredicateAnd::New(m_PredicateImages, m_PredicateDimension)),
m_PredicateBinary(NodePredicateProperty::New("binary", BoolProperty::New(true))),
m_PredicateNotBinary(NodePredicateNot::New(m_PredicateBinary)),
m_PredicateSegmentation(NodePredicateProperty::New("segmentation", BoolProperty::New(true))),
m_PredicateNotSegmentation(NodePredicateNot::New(m_PredicateSegmentation)),
m_PredicateHelper(NodePredicateProperty::New("helper object", BoolProperty::New(true))),
m_PredicateNotHelper(NodePredicateNot::New(m_PredicateHelper)),
m_PredicateImageColorful(NodePredicateAnd::New(m_PredicateNotBinary, m_PredicateNotSegmentation)),
m_PredicateImageColorfulNotHelper(NodePredicateAnd::New(m_PredicateImageColorful, m_PredicateNotHelper)),
m_PredicateReference(NodePredicateAnd::New(m_PredicateImage3D, m_PredicateImageColorfulNotHelper)),
m_IsSegmentationPredicate(
NodePredicateAnd::New(NodePredicateOr::New(m_PredicateBinary, m_PredicateSegmentation), m_PredicateNotHelper)),
m_InteractorType(type),
m_DisplayInteractorConfigs(),
m_InteractorModule(interactorModule)
{
}
mitk::Tool::~Tool()
{
}
bool mitk::Tool::CanHandle(const BaseData* referenceData, const BaseData* /*workingData*/) const
{
if (referenceData == nullptr)
return false;
return true;
}
void mitk::Tool::InitializeStateMachine()
{
if (m_InteractorType.empty())
return;
try
{
auto isThisModule = nullptr == m_InteractorModule;
auto module = isThisModule
? us::GetModuleContext()->GetModule()
: m_InteractorModule;
LoadStateMachine(m_InteractorType + ".xml", module);
SetEventConfig(isThisModule ? "SegmentationToolsConfig.xml" : m_InteractorType + "Config.xml", module);
}
catch (const std::exception &e)
{
MITK_ERROR << "Could not load statemachine pattern " << m_InteractorType << ".xml with exception: " << e.what();
}
}
void mitk::Tool::Notify(InteractionEvent *interactionEvent, bool isHandled)
{
// to use the state machine pattern,
// the event is passed to the state machine interface to be handled
if (!isHandled)
{
this->HandleEvent(interactionEvent, nullptr);
}
}
void mitk::Tool::ConnectActionsAndFunctions()
{
}
bool mitk::Tool::FilterEvents(InteractionEvent *, DataNode *)
{
return true;
}
const char *mitk::Tool::GetGroup() const
{
return "default";
}
void mitk::Tool::SetToolManager(ToolManager *manager)
{
m_ToolManager = manager;
}
+mitk::ToolManager* mitk::Tool::GetToolManager() const
+{
+ return m_ToolManager;
+}
+
+mitk::DataStorage* mitk::Tool::GetDataStorage() const
+{
+ if (nullptr != m_ToolManager)
+ {
+ return m_ToolManager->GetDataStorage();
+ }
+ return nullptr;
+}
+
void mitk::Tool::Activated()
{
// As a legacy solution the display interaction of the new interaction framework is disabled here to avoid conflicts
// with tools
// Note: this only affects InteractionEventObservers (formerly known as Listeners) all DataNode specific interaction
// will still be enabled
m_DisplayInteractorConfigs.clear();
std::vector<us::ServiceReference<InteractionEventObserver>> listEventObserver =
us::GetModuleContext()->GetServiceReferences<InteractionEventObserver>();
for (auto it = listEventObserver.begin(); it != listEventObserver.end(); ++it)
{
auto displayInteractor = dynamic_cast<DisplayInteractor*>(us::GetModuleContext()->GetService<InteractionEventObserver>(*it));
if (displayInteractor != nullptr)
{
// remember the original configuration
m_DisplayInteractorConfigs.insert(std::make_pair(*it, displayInteractor->GetEventConfig()));
// here the alternative configuration is loaded
displayInteractor->SetEventConfig(m_EventConfig.c_str());
}
auto displayActionEventBroadcast = dynamic_cast<DisplayActionEventBroadcast*>(us::GetModuleContext()->GetService<InteractionEventObserver>(*it));
if (displayActionEventBroadcast != nullptr)
{
// remember the original configuration
m_DisplayInteractorConfigs.insert(std::make_pair(*it, displayActionEventBroadcast->GetEventConfig()));
// here the alternative configuration is loaded
displayActionEventBroadcast->SetEventConfig(m_EventConfig.c_str());
}
}
}
void mitk::Tool::Deactivated()
{
// Re-enabling InteractionEventObservers that have been previously disabled for legacy handling of Tools
// in new interaction framework
for (auto it = m_DisplayInteractorConfigs.begin(); it != m_DisplayInteractorConfigs.end(); ++it)
{
if (it->first)
{
auto displayInteractor = static_cast<DisplayInteractor*>(us::GetModuleContext()->GetService<InteractionEventObserver>(it->first));
if (displayInteractor != nullptr)
{
// here the regular configuration is loaded again
displayInteractor->SetEventConfig(it->second);
}
auto displayActionEventBroadcast = dynamic_cast<DisplayActionEventBroadcast*>(us::GetModuleContext()->GetService<InteractionEventObserver>(it->first));
if (displayActionEventBroadcast != nullptr)
{
// here the regular configuration is loaded again
displayActionEventBroadcast->SetEventConfig(it->second);
}
}
}
m_DisplayInteractorConfigs.clear();
}
itk::Object::Pointer mitk::Tool::GetGUI(const std::string &toolkitPrefix, const std::string &toolkitPostfix)
{
itk::Object::Pointer object;
std::string classname = this->GetNameOfClass();
std::string guiClassname = toolkitPrefix + classname + toolkitPostfix;
std::list<itk::LightObject::Pointer> allGUIs = itk::ObjectFactoryBase::CreateAllInstance(guiClassname.c_str());
for (auto iter = allGUIs.begin(); iter != allGUIs.end(); ++iter)
{
if (object.IsNull())
{
object = dynamic_cast<itk::Object *>(iter->GetPointer());
}
else
{
MITK_ERROR << "There is more than one GUI for " << classname << " (several factories claim ability to produce a "
<< guiClassname << " ) " << std::endl;
return nullptr; // people should see and fix this error
}
}
return object;
}
mitk::NodePredicateBase::ConstPointer mitk::Tool::GetReferenceDataPreference() const
{
return m_PredicateReference.GetPointer();
}
mitk::NodePredicateBase::ConstPointer mitk::Tool::GetWorkingDataPreference() const
{
return m_IsSegmentationPredicate.GetPointer();
}
mitk::DataNode::Pointer mitk::Tool::CreateEmptySegmentationNode(const Image *original,
const std::string &organName,
const mitk::Color &color) const
{
// we NEED a reference image for size etc.
if (!original)
return nullptr;
// actually create a new empty segmentation
PixelType pixelType(mitk::MakeScalarPixelType<DefaultSegmentationDataType>());
LabelSetImage::Pointer segmentation = LabelSetImage::New();
if (original->GetDimension() == 2)
{
const unsigned int dimensions[] = {original->GetDimension(0), original->GetDimension(1), 1};
segmentation->Initialize(pixelType, 3, dimensions);
segmentation->AddLayer();
}
else
{
segmentation->Initialize(original);
}
mitk::Label::Pointer label = mitk::Label::New();
label->SetName(organName);
label->SetColor(color);
label->SetValue(1);
segmentation->GetActiveLabelSet()->AddLabel(label);
segmentation->GetActiveLabelSet()->SetActiveLabel(1);
unsigned int byteSize = sizeof(mitk::Label::PixelType);
if (segmentation->GetDimension() < 4)
{
for (unsigned int dim = 0; dim < segmentation->GetDimension(); ++dim)
{
byteSize *= segmentation->GetDimension(dim);
}
mitk::ImageWriteAccessor writeAccess(segmentation.GetPointer(), segmentation->GetVolumeData(0));
memset(writeAccess.GetData(), 0, byteSize);
}
else
{
// if we have a time-resolved image we need to set memory to 0 for each time step
for (unsigned int dim = 0; dim < 3; ++dim)
{
byteSize *= segmentation->GetDimension(dim);
}
for (unsigned int volumeNumber = 0; volumeNumber < segmentation->GetDimension(3); volumeNumber++)
{
mitk::ImageWriteAccessor writeAccess(segmentation.GetPointer(), segmentation->GetVolumeData(volumeNumber));
memset(writeAccess.GetData(), 0, byteSize);
}
}
if (original->GetTimeGeometry())
{
TimeGeometry::Pointer originalGeometry = original->GetTimeGeometry()->Clone();
segmentation->SetTimeGeometry(originalGeometry);
}
else
{
Tool::ErrorMessage("Original image does not have a 'Time sliced geometry'! Cannot create a segmentation.");
return nullptr;
}
return CreateSegmentationNode(segmentation, organName, color);
}
mitk::DataNode::Pointer mitk::Tool::CreateSegmentationNode(Image *image,
const std::string &organName,
const mitk::Color &color) const
{
if (!image)
return nullptr;
// decorate the datatreenode with some properties
DataNode::Pointer segmentationNode = DataNode::New();
segmentationNode->SetData(image);
// name
segmentationNode->SetProperty("name", StringProperty::New(organName));
// visualization properties
segmentationNode->SetProperty("binary", BoolProperty::New(true));
segmentationNode->SetProperty("color", ColorProperty::New(color));
mitk::LookupTable::Pointer lut = mitk::LookupTable::New();
lut->SetType(mitk::LookupTable::MULTILABEL);
mitk::LookupTableProperty::Pointer lutProp = mitk::LookupTableProperty::New();
lutProp->SetLookupTable(lut);
segmentationNode->SetProperty("LookupTable", lutProp);
segmentationNode->SetProperty("texture interpolation", BoolProperty::New(false));
segmentationNode->SetProperty("layer", IntProperty::New(10));
segmentationNode->SetProperty("levelwindow", LevelWindowProperty::New(LevelWindow(0.5, 1)));
segmentationNode->SetProperty("opacity", FloatProperty::New(0.3));
segmentationNode->SetProperty("segmentation", BoolProperty::New(true));
segmentationNode->SetProperty("reslice interpolation",
VtkResliceInterpolationProperty::New()); // otherwise -> segmentation appears in 2
// slices sometimes (only visual effect, not
// different data)
// For MITK-3M3 release, the volume of all segmentations should be shown
segmentationNode->SetProperty("showVolume", BoolProperty::New(true));
return segmentationNode;
}
us::ModuleResource mitk::Tool::GetIconResource() const
{
// Each specific tool should load its own resource. This one will be invalid
return us::ModuleResource();
}
us::ModuleResource mitk::Tool::GetCursorIconResource() const
{
// Each specific tool should load its own resource. This one will be invalid
return us::ModuleResource();
}
diff --git a/Modules/Segmentation/Interactions/mitkTool.h b/Modules/Segmentation/Interactions/mitkTool.h
index ddc998b8d0..c2f6af5a78 100644
--- a/Modules/Segmentation/Interactions/mitkTool.h
+++ b/Modules/Segmentation/Interactions/mitkTool.h
@@ -1,269 +1,275 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
#ifndef mitkTool_h_Included
#define mitkTool_h_Included
#include "itkObjectFactoryBase.h"
#include "itkVersion.h"
#include "mitkCommon.h"
#include "mitkDataNode.h"
#include "mitkEventStateMachine.h"
#include "mitkInteractionEventObserver.h"
#include "mitkLabelSetImage.h"
#include "mitkMessage.h"
#include "mitkNodePredicateAnd.h"
#include "mitkNodePredicateDataType.h"
#include "mitkNodePredicateDimension.h"
#include "mitkNodePredicateNot.h"
#include "mitkNodePredicateOr.h"
#include "mitkNodePredicateProperty.h"
#include "mitkToolEvents.h"
#include "mitkToolFactoryMacro.h"
#include <MitkSegmentationExports.h>
#include <mitkLabel.h>
#include <iostream>
#include <map>
#include <string>
#include <itkObject.h>
#include "usServiceRegistration.h"
namespace us
{
class ModuleResource;
}
namespace mitk
{
class ToolManager;
/**
\brief Base class of all tools used by mitk::ToolManager.
\sa ToolManager
\sa SegTool2D
\ingroup Interaction
\ingroup ToolManagerEtAl
Every tool is a mitk::StateMachine, which can follow any transition pattern that it likes. One important thing to know
is, that
every derived tool should always call SuperClass::Deactivated() at the end of its own implementation of Deactivated,
because mitk::Tool
resets the StateMachine in this method. Only if you are very sure that you covered all possible things that might
happen to your
own tool, you should consider not to reset the StateMachine from time to time.
To learn about the MITK implementation of state machines in general, have a look at \ref InteractionPage.
To derive a non-abstract tool, you inherit from mitk::Tool (or some other base class further down the inheritance
tree), and in your
own parameterless constructor (that is called from the itkFactorylessNewMacro that you use) you pass a StateMachine
pattern name to the superclass.
Names for valid patterns can be found in StateMachine.xml (which might be enhanced by you).
You have to implement at least GetXPM() and GetName() to provide some identification.
Each Tool knows its ToolManager, which can provide the data that the tool should work on.
\warning Only to be instantiated by mitk::ToolManager (because SetToolManager has to be called). All other uses are
unsupported.
$Author$
*/
class MITKSEGMENTATION_EXPORT Tool : public EventStateMachine, public InteractionEventObserver
{
public:
typedef mitk::Label::PixelType DefaultSegmentationDataType;
/**
* \brief To let GUI process new events (e.g. qApp->processEvents() )
*/
Message<> GUIProcessEventsMessage;
/**
* \brief To send error messages (to be shown by some GUI)
*/
Message1<std::string> ErrorMessage;
/**
* \brief To send whether the tool is busy (to be shown by some GUI)
*/
Message1<bool> CurrentlyBusy;
/**
* \brief To send general messages (to be shown by some GUI)
*/
Message1<std::string> GeneralMessage;
mitkClassMacro(Tool, EventStateMachine);
// no New(), there should only be subclasses
/**
\brief Returns an icon in the XPM format.
This icon has to fit into some kind of button in most applications, so make it smaller than 25x25 pixels.
XPM is e.g. supported by The Gimp. But if you open any XPM file in your text editor, you will see that you could
also "draw" it with an editor.
*/
virtual const char **GetXPM() const = 0;
/**
* \brief Returns the path of an icon.
*
* This icon is preferred to the XPM icon.
*/
virtual std::string GetIconPath() const { return ""; }
/**
* \brief Returns the path of a cursor icon.
*
*/
virtual us::ModuleResource GetCursorIconResource() const;
/**
* @brief Returns the tool button icon of the tool wrapped by a usModuleResource
* @return a valid ModuleResource or an invalid if this function
* is not reimplemented
*/
virtual us::ModuleResource GetIconResource() const;
/**
\brief Returns the name of this tool. Make it short!
This name has to fit into some kind of button in most applications, so take some time to think of a good name!
*/
virtual const char *GetName() const = 0;
/**
\brief Name of a group.
You can group several tools by assigning a group name. Graphical tool selectors might use this information to group
tools. (What other reason could there be?)
*/
virtual const char *GetGroup() const;
virtual void InitializeStateMachine();
/**
* \brief Interface for GUI creation.
*
* This is the basic interface for creation of a GUI object belonging to one tool.
*
* Tools that support a GUI (e.g. for display/editing of parameters) should follow some rules:
*
* - A Tool and its GUI are two separate classes
* - There may be several instances of a GUI at the same time.
* - mitk::Tool is toolkit (Qt, wxWidgets, etc.) independent, the GUI part is of course dependent
* - The GUI part inherits both from itk::Object and some GUI toolkit class
* - The GUI class name HAS to be constructed like "toolkitPrefix" tool->GetClassName() + "toolkitPostfix", e.g.
* MyTool -> wxMyToolGUI
* - For each supported toolkit there is a base class for tool GUIs, which contains some convenience methods
* - Tools notify the GUI about changes using ITK events. The GUI must observe interesting events.
* - The GUI base class may convert all ITK events to the GUI toolkit's favoured messaging system (Qt -> signals)
* - Calling methods of a tool by its GUI is done directly.
* In some cases GUIs don't want to be notified by the tool when they cause a change in a tool.
* There is a macro CALL_WITHOUT_NOTICE(method()), which will temporarily disable all notifications during a
* method call.
*/
virtual itk::Object::Pointer GetGUI(const std::string &toolkitPrefix, const std::string &toolkitPostfix);
virtual NodePredicateBase::ConstPointer GetReferenceDataPreference() const;
virtual NodePredicateBase::ConstPointer GetWorkingDataPreference() const;
DataNode::Pointer CreateEmptySegmentationNode(const Image *original,
const std::string &organName,
const mitk::Color &color) const;
DataNode::Pointer CreateSegmentationNode(Image *image, const std::string &organName, const mitk::Color &color) const;
/** Function used to check if a tool can handle the referenceData and (if specified) the working data.
@pre referenceData must be a valid pointer
@param referenceData Pointer to the data that should be checked as valid reference for the tool.
@param workingData Pointer to the data that should be checked as valid working data for this tool.
This parameter can be null if no working data is specified so far.*/
virtual bool CanHandle(const BaseData *referenceData, const BaseData *workingData) const;
protected:
friend class ToolManager;
virtual void SetToolManager(ToolManager *);
+ /** Returns the pointer to the tool manager of the tool. May be null.*/
+ ToolManager* GetToolManager() const;
+
+ /** Returns the data storage provided by the toolmanager. May be null (e.g. if
+ ToolManager is not set).*/
+ mitk::DataStorage* GetDataStorage() const;
void ConnectActionsAndFunctions() override;
/**
\brief Called when the tool gets activated.
Derived tools should call their parents implementation at the beginning of the overriding function.
*/
virtual void Activated();
/**
\brief Called when the tool gets deactivated.
Derived tools should call their parents implementation at the end of the overriding function.
*/
virtual void Deactivated();
/**
\brief Let subclasses change their event configuration.
*/
std::string m_EventConfig;
Tool(const char *, const us::Module *interactorModule = nullptr); // purposely hidden
~Tool() override;
void Notify(InteractionEvent *interactionEvent, bool isHandled) override;
bool FilterEvents(InteractionEvent *, DataNode *) override;
- ToolManager *m_ToolManager;
-
private:
+ ToolManager* m_ToolManager;
+
// for reference data
NodePredicateDataType::Pointer m_PredicateImages;
NodePredicateDimension::Pointer m_PredicateDim3;
NodePredicateDimension::Pointer m_PredicateDim4;
NodePredicateOr::Pointer m_PredicateDimension;
NodePredicateAnd::Pointer m_PredicateImage3D;
NodePredicateProperty::Pointer m_PredicateBinary;
NodePredicateNot::Pointer m_PredicateNotBinary;
NodePredicateProperty::Pointer m_PredicateSegmentation;
NodePredicateNot::Pointer m_PredicateNotSegmentation;
NodePredicateProperty::Pointer m_PredicateHelper;
NodePredicateNot::Pointer m_PredicateNotHelper;
NodePredicateAnd::Pointer m_PredicateImageColorful;
NodePredicateAnd::Pointer m_PredicateImageColorfulNotHelper;
NodePredicateAnd::Pointer m_PredicateReference;
// for working data
NodePredicateAnd::Pointer m_IsSegmentationPredicate;
std::string m_InteractorType;
std::map<us::ServiceReferenceU, EventConfig> m_DisplayInteractorConfigs;
const us::Module *m_InteractorModule;
};
} // namespace
#endif
diff --git a/Modules/Segmentation/Resources/Interactions/PickingTool.xml b/Modules/Segmentation/Resources/Interactions/PickingTool.xml
new file mode 100644
index 0000000000..1baf80a04b
--- /dev/null
+++ b/Modules/Segmentation/Resources/Interactions/PickingTool.xml
@@ -0,0 +1,19 @@
+<statemachine name="FastMarchingTool">
+
+ <state name="neutral" ID="1" startstate="TRUE">
+
+ <transition event_class="MousePressEvent" event_variant="ShiftPrimaryButtonPressed" name="Shift+press" target="neutral" EVENT_ID="3">
+ <action name="ShiftPrimaryButtonPressed" ID="10" />
+ </transition>
+
+ <transition event_class="MousePressEvent" event_variant="ShiftSecondaryButtonPressed" name="Shift+pressRMB" target="neutral" EVENT_ID="2000">
+ <action name="ShiftSecondaryButtonPressed" ID="6000" />
+ </transition>
+
+ <transition event_class="InteractionKeyEvent" event_variant="KeyDelete" name="ENTF" target="neutral" EVENT_ID="12">
+ <action name="DeletePoint" ID="100" />
+ </transition>
+
+ </state>
+
+</statemachine>
\ No newline at end of file
diff --git a/Modules/Segmentation/files.cmake b/Modules/Segmentation/files.cmake
index 68d22a6ccc..cb3c19d915 100644
--- a/Modules/Segmentation/files.cmake
+++ b/Modules/Segmentation/files.cmake
@@ -1,116 +1,117 @@
set(CPP_FILES
Algorithms/mitkCalculateSegmentationVolume.cpp
Algorithms/mitkContourModelSetToImageFilter.cpp
Algorithms/mitkContourSetToPointSetFilter.cpp
Algorithms/mitkContourUtils.cpp
Algorithms/mitkCorrectorAlgorithm.cpp
Algorithms/mitkDiffImageApplier.cpp
Algorithms/mitkDiffSliceOperation.cpp
Algorithms/mitkDiffSliceOperationApplier.cpp
Algorithms/mitkFeatureBasedEdgeDetectionFilter.cpp
Algorithms/mitkImageLiveWireContourModelFilter.cpp
Algorithms/mitkImageToContourFilter.cpp
#Algorithms/mitkImageToContourModelFilter.cpp
Algorithms/mitkImageToLiveWireContourFilter.cpp
Algorithms/mitkManualSegmentationToSurfaceFilter.cpp
Algorithms/mitkOtsuSegmentationFilter.cpp
Algorithms/mitkOverwriteDirectedPlaneImageFilter.cpp
Algorithms/mitkOverwriteSliceImageFilter.cpp
Algorithms/mitkSegmentationObjectFactory.cpp
Algorithms/mitkShapeBasedInterpolationAlgorithm.cpp
Algorithms/mitkShowSegmentationAsSmoothedSurface.cpp
Algorithms/mitkShowSegmentationAsSurface.cpp
Algorithms/mitkVtkImageOverwrite.cpp
Controllers/mitkSegmentationInterpolationController.cpp
Controllers/mitkToolManager.cpp
Controllers/mitkSegmentationModuleActivator.cpp
Controllers/mitkToolManagerProvider.cpp
DataManagement/mitkContour.cpp
DataManagement/mitkContourSet.cpp
DataManagement/mitkExtrudedContour.cpp
Interactions/mitkAdaptiveRegionGrowingTool.cpp
Interactions/mitkAddContourTool.cpp
Interactions/mitkAutoCropTool.cpp
Interactions/mitkAutoSegmentationTool.cpp
Interactions/mitkAutoSegmentationWithPreviewTool.cpp
Interactions/mitkAutoMLSegmentationWithPreviewTool.cpp
Interactions/mitkBinaryThresholdBaseTool.cpp
Interactions/mitkBinaryThresholdTool.cpp
Interactions/mitkBinaryThresholdULTool.cpp
Interactions/mitkCalculateGrayValueStatisticsTool.cpp
Interactions/mitkCalculateVolumetryTool.cpp
Interactions/mitkContourModelInteractor.cpp
Interactions/mitkContourModelLiveWireInteractor.cpp
Interactions/mitkLiveWireTool2D.cpp
Interactions/mitkContourTool.cpp
Interactions/mitkCreateSurfaceTool.cpp
Interactions/mitkDrawPaintbrushTool.cpp
Interactions/mitkErasePaintbrushTool.cpp
Interactions/mitkEraseRegionTool.cpp
Interactions/mitkFastMarchingBaseTool.cpp
Interactions/mitkFastMarchingTool.cpp
Interactions/mitkFastMarchingTool3D.cpp
Interactions/mitkFeedbackContourTool.cpp
Interactions/mitkFillRegionTool.cpp
Interactions/mitkOtsuTool3D.cpp
Interactions/mitkPaintbrushTool.cpp
Interactions/mitkPixelManipulationTool.cpp
Interactions/mitkRegionGrowingTool.cpp
Interactions/mitkSegmentationsProcessingTool.cpp
Interactions/mitkSetRegionTool.cpp
Interactions/mitkSegTool2D.cpp
Interactions/mitkSubtractContourTool.cpp
Interactions/mitkTool.cpp
Interactions/mitkToolCommand.cpp
Interactions/mitkWatershedTool.cpp
Interactions/mitkPickingTool.cpp
Interactions/mitkSegmentationInteractor.cpp #SO
Rendering/mitkContourMapper2D.cpp
Rendering/mitkContourSetMapper2D.cpp
Rendering/mitkContourSetVtkMapper3D.cpp
Rendering/mitkContourVtkMapper3D.cpp
SegmentationUtilities/BooleanOperations/mitkBooleanOperation.cpp
SegmentationUtilities/MorphologicalOperations/mitkMorphologicalOperations.cpp
#Added from ML
Controllers/mitkSliceBasedInterpolationController.cpp
Algorithms/mitkSurfaceStampImageFilter.cpp
)
set(RESOURCE_FILES
Add_48x48.png
Add_Cursor_32x32.png
Erase_48x48.png
Erase_Cursor_32x32.png
FastMarching_48x48.png
FastMarching_Cursor_32x32.png
Fill_48x48.png
Fill_Cursor_32x32.png
LiveWire_48x48.png
LiveWire_Cursor_32x32.png
Otsu_48x48.png
Paint_48x48.png
Paint_Cursor_32x32.png
Pick_48x48.png
RegionGrowing_48x48.png
RegionGrowing_Cursor_32x32.png
Subtract_48x48.png
Subtract_Cursor_32x32.png
Threshold_48x48.png
TwoThresholds_48x48.png
Watershed_48x48.png
Watershed_Cursor_32x32.png
Wipe_48x48.png
Wipe_Cursor_32x32.png
Interactions/dummy.xml
Interactions/LiveWireTool.xml
Interactions/FastMarchingTool.xml
+ Interactions/PickingTool.xml
Interactions/PressMoveRelease.xml
Interactions/PressMoveReleaseAndPointSetting.xml
Interactions/PressMoveReleaseWithCTRLInversion.xml
Interactions/PressMoveReleaseWithCTRLInversionAllMouseMoves.xml
Interactions/SegmentationToolsConfig.xml
Interactions/ContourModelModificationConfig.xml
Interactions/ContourModelModificationInteractor.xml
)
diff --git a/Modules/SegmentationUI/Qmitk/QmitkAutoMLSegmentationToolGUIBase.cpp b/Modules/SegmentationUI/Qmitk/QmitkAutoMLSegmentationToolGUIBase.cpp
index b332866f6f..863e753c08 100644
--- a/Modules/SegmentationUI/Qmitk/QmitkAutoMLSegmentationToolGUIBase.cpp
+++ b/Modules/SegmentationUI/Qmitk/QmitkAutoMLSegmentationToolGUIBase.cpp
@@ -1,95 +1,89 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
#include "QmitkAutoMLSegmentationToolGUIBase.h"
#include "mitkAutoMLSegmentationWithPreviewTool.h"
#include <qboxlayout.h>
QmitkAutoMLSegmentationToolGUIBase::QmitkAutoMLSegmentationToolGUIBase() : QmitkAutoSegmentationToolGUIBase(false)
{
- auto enableOtsuDelegate = [this](bool enabled)
+ auto enableMLSelectedDelegate = [this](bool enabled)
{
bool result = enabled;
auto tool = this->GetConnectedToolAs<mitk::AutoMLSegmentationWithPreviewTool>();
if (nullptr != tool)
{
result = !tool->GetSelectedLabels().empty() && enabled;
}
else
{
result = false;
}
return result;
};
- m_EnableConfirmSegBtnFnc = enableOtsuDelegate;
-}
-
-void QmitkAutoMLSegmentationToolGUIBase::ConnectNewTool(mitk::AutoSegmentationWithPreviewTool* newTool)
-{
- Superclass::ConnectNewTool(newTool);
- this->EnableWidgets(true);
+ m_EnableConfirmSegBtnFnc = enableMLSelectedDelegate;
}
void QmitkAutoMLSegmentationToolGUIBase::InitializeUI(QBoxLayout* mainLayout)
{
m_LabelSelectionList = new QmitkSimpleLabelSetListWidget(this);
m_LabelSelectionList->setObjectName(QString::fromUtf8("m_LabelSelectionList"));
QSizePolicy sizePolicy2(QSizePolicy::Minimum, QSizePolicy::MinimumExpanding);
sizePolicy2.setHorizontalStretch(0);
sizePolicy2.setVerticalStretch(0);
sizePolicy2.setHeightForWidth(m_LabelSelectionList->sizePolicy().hasHeightForWidth());
m_LabelSelectionList->setSizePolicy(sizePolicy2);
m_LabelSelectionList->setMaximumSize(QSize(10000000, 10000000));
mainLayout->addWidget(m_LabelSelectionList);
connect(m_LabelSelectionList, &QmitkSimpleLabelSetListWidget::SelectedLabelsChanged, this, &QmitkAutoMLSegmentationToolGUIBase::OnLabelSelectionChanged);
Superclass::InitializeUI(mainLayout);
}
void QmitkAutoMLSegmentationToolGUIBase::OnLabelSelectionChanged(const QmitkSimpleLabelSetListWidget::LabelVectorType& selectedLabels)
{
auto tool = this->GetConnectedToolAs<mitk::AutoMLSegmentationWithPreviewTool>();
if (nullptr != tool)
{
mitk::AutoMLSegmentationWithPreviewTool::SelectedLabelVectorType labelIDs;
for (const auto& label : selectedLabels)
{
labelIDs.push_back(label->GetValue());
}
tool->SetSelectedLabels(labelIDs);
tool->UpdatePreview();
this->EnableWidgets(true); //used to actualize the ConfirmSeg btn via the delegate;
}
}
void QmitkAutoMLSegmentationToolGUIBase::EnableWidgets(bool enabled)
{
Superclass::EnableWidgets(enabled);
if (nullptr != m_LabelSelectionList)
{
m_LabelSelectionList->setEnabled(enabled);
}
}
void QmitkAutoMLSegmentationToolGUIBase::SetLabelSetPreview(const mitk::LabelSetImage* preview)
{
if (nullptr != m_LabelSelectionList)
{
m_LabelSelectionList->SetLabelSetImage(preview);
}
}
diff --git a/Modules/SegmentationUI/Qmitk/QmitkAutoMLSegmentationToolGUIBase.h b/Modules/SegmentationUI/Qmitk/QmitkAutoMLSegmentationToolGUIBase.h
index 76bf69cea8..e4e48dc867 100644
--- a/Modules/SegmentationUI/Qmitk/QmitkAutoMLSegmentationToolGUIBase.h
+++ b/Modules/SegmentationUI/Qmitk/QmitkAutoMLSegmentationToolGUIBase.h
@@ -1,53 +1,52 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
#ifndef QmitkAutoMLSegmentationToolGUIBase_h_Included
#define QmitkAutoMLSegmentationToolGUIBase_h_Included
#include "QmitkAutoSegmentationToolGUIBase.h"
#include "QmitkSimpleLabelSetListWidget.h"
#include <MitkSegmentationUIExports.h>
/**
\ingroup org_mitk_gui_qt_interactivesegmentation_internal
\brief GUI for tools based on mitk::AutoMLSegmentationWithPreviewTool.
This GUI offers an additional list to select the label that should be confirmed.
*/
class MITKSEGMENTATIONUI_EXPORT QmitkAutoMLSegmentationToolGUIBase : public QmitkAutoSegmentationToolGUIBase
{
Q_OBJECT
public:
mitkClassMacro(QmitkAutoMLSegmentationToolGUIBase, QmitkAutoSegmentationToolGUIBase);
protected slots :
void OnLabelSelectionChanged(const QmitkSimpleLabelSetListWidget::LabelVectorType& selectedLabels);
protected:
QmitkAutoMLSegmentationToolGUIBase();
~QmitkAutoMLSegmentationToolGUIBase() = default;
void InitializeUI(QBoxLayout* mainLayout) override;
- void ConnectNewTool(mitk::AutoSegmentationWithPreviewTool* newTool) override;
void EnableWidgets(bool enabled) override;
void SetLabelSetPreview(const mitk::LabelSetImage* preview);
private:
QmitkSimpleLabelSetListWidget* m_LabelSelectionList = nullptr;
};
#endif
diff --git a/Modules/SegmentationUI/Qmitk/QmitkAutoSegmentationToolGUIBase.cpp b/Modules/SegmentationUI/Qmitk/QmitkAutoSegmentationToolGUIBase.cpp
index 19e7da115e..5ca33cd4e2 100644
--- a/Modules/SegmentationUI/Qmitk/QmitkAutoSegmentationToolGUIBase.cpp
+++ b/Modules/SegmentationUI/Qmitk/QmitkAutoSegmentationToolGUIBase.cpp
@@ -1,155 +1,157 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
#include "QmitkAutoSegmentationToolGUIBase.h"
#include <qcheckbox.h>
#include <qpushbutton.h>
#include <qboxlayout.h>
#include <qlabel.h>
#include <QApplication>
bool DefaultEnableConfirmSegBtnFunction(bool enabled)
{
return enabled;
}
QmitkAutoSegmentationToolGUIBase::QmitkAutoSegmentationToolGUIBase(bool mode2D) : QmitkToolGUI(), m_EnableConfirmSegBtnFnc(DefaultEnableConfirmSegBtnFunction), m_Mode2D(mode2D)
{
connect(this, SIGNAL(NewToolAssociated(mitk::Tool *)), this, SLOT(OnNewToolAssociated(mitk::Tool *)));
}
QmitkAutoSegmentationToolGUIBase::~QmitkAutoSegmentationToolGUIBase()
{
if (m_Tool.IsNotNull())
{
m_Tool->CurrentlyBusy -= mitk::MessageDelegate1<QmitkAutoSegmentationToolGUIBase, bool>(this, &QmitkAutoSegmentationToolGUIBase::BusyStateChanged);
}
}
void QmitkAutoSegmentationToolGUIBase::OnNewToolAssociated(mitk::Tool *tool)
{
if (m_Tool.IsNotNull())
{
this->DisconnectOldTool(m_Tool);
}
m_Tool = dynamic_cast<mitk::AutoSegmentationWithPreviewTool*>(tool);
if (nullptr == m_MainLayout)
{
// create the visible widgets
m_MainLayout = new QVBoxLayout(this);
m_ConfirmSegBtn = new QPushButton("Confirm Segmentation", this);
connect(m_ConfirmSegBtn, SIGNAL(clicked()), this, SLOT(OnAcceptPreview()));
m_CheckProcessAll = new QCheckBox("Process all time steps", this);
m_CheckProcessAll->setChecked(false);
m_CheckProcessAll->setToolTip("Process all time steps of the dynamic segmentation and not just the currently visible time step.");
m_CheckProcessAll->setVisible(!m_Mode2D);
//remark: keept m_CheckProcessAll deactivated in 2D because in this refactoring
//it should be kept to the status quo and it was not clear how interpolation
//would behave. As soon as it is sorted out we can remove that "feature switch"
//or the comment.
m_CheckCreateNew = new QCheckBox("Create as new segmentation", this);
m_CheckCreateNew->setChecked(false);
m_CheckCreateNew->setToolTip("Add the confirmed segmentation as a new segmentation instead of overwriting the currently selected.");
m_CheckCreateNew->setVisible(!m_Mode2D);
//remark: keept m_CheckCreateNew deactivated in 2D because in this refactoring
//it should be kept to the status quo and it was not clear how interpolation
//would behave. As soon as it is sorted out we can remove that "feature switch"
//or the comment.
this->InitializeUI(m_MainLayout);
m_MainLayout->addWidget(m_ConfirmSegBtn);
m_MainLayout->addWidget(m_CheckProcessAll);
m_MainLayout->addWidget(m_CheckCreateNew);
}
if (m_Tool.IsNotNull())
{
this->ConnectNewTool(m_Tool);
}
}
void QmitkAutoSegmentationToolGUIBase::OnAcceptPreview()
{
if (m_Tool.IsNotNull())
{
if (m_CheckCreateNew->isChecked())
{
m_Tool->SetOverwriteExistingSegmentation(false);
}
else
{
m_Tool->SetOverwriteExistingSegmentation(true);
}
m_Tool->SetCreateAllTimeSteps(m_CheckProcessAll->isChecked());
m_ConfirmSegBtn->setEnabled(false);
m_Tool->ConfirmSegmentation();
}
}
void QmitkAutoSegmentationToolGUIBase::DisconnectOldTool(mitk::AutoSegmentationWithPreviewTool* oldTool)
{
oldTool->CurrentlyBusy -= mitk::MessageDelegate1<QmitkAutoSegmentationToolGUIBase, bool>(this, &QmitkAutoSegmentationToolGUIBase::BusyStateChanged);
}
void QmitkAutoSegmentationToolGUIBase::ConnectNewTool(mitk::AutoSegmentationWithPreviewTool* newTool)
{
newTool->CurrentlyBusy +=
mitk::MessageDelegate1<QmitkAutoSegmentationToolGUIBase, bool>(this, &QmitkAutoSegmentationToolGUIBase::BusyStateChanged);
newTool->SetOverwriteExistingSegmentation(true);
m_CheckProcessAll->setVisible(newTool->GetTargetSegmentationNode()->GetData()->GetTimeSteps() > 1);
+
+ this->EnableWidgets(true);
}
void QmitkAutoSegmentationToolGUIBase::InitializeUI(QBoxLayout* /*mainLayout*/)
{
//default implementation does nothing
}
void QmitkAutoSegmentationToolGUIBase::BusyStateChanged(bool isBusy)
{
if (isBusy)
{
QApplication::setOverrideCursor(QCursor(Qt::BusyCursor));
}
else
{
QApplication::restoreOverrideCursor();
}
this->EnableWidgets(!isBusy);
}
void QmitkAutoSegmentationToolGUIBase::EnableWidgets(bool enabled)
{
if (nullptr != m_MainLayout)
{
if (nullptr != m_ConfirmSegBtn)
{
m_ConfirmSegBtn->setEnabled(m_EnableConfirmSegBtnFnc(enabled));
}
if (nullptr != m_CheckProcessAll)
{
m_CheckProcessAll->setEnabled(enabled);
}
if (nullptr != m_CheckCreateNew)
{
m_CheckCreateNew->setEnabled(enabled);
}
}
}
diff --git a/Modules/SegmentationUI/Qmitk/QmitkAutoSegmentationToolGUIBase.h b/Modules/SegmentationUI/Qmitk/QmitkAutoSegmentationToolGUIBase.h
index 6501a2e1b5..2c6eddf881 100644
--- a/Modules/SegmentationUI/Qmitk/QmitkAutoSegmentationToolGUIBase.h
+++ b/Modules/SegmentationUI/Qmitk/QmitkAutoSegmentationToolGUIBase.h
@@ -1,81 +1,93 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
#ifndef QmitkAutoSegmentationToolGUIBase_h_Included
#define QmitkAutoSegmentationToolGUIBase_h_Included
#include "QmitkToolGUI.h"
#include "mitkAutoSegmentationWithPreviewTool.h"
#include <MitkSegmentationUIExports.h>
class QCheckBox;
class QPushButton;
class QBoxLayout;
/**
\ingroup org_mitk_gui_qt_interactivesegmentation_internal
\brief GUI base clase for tools derived from mitk::AutoSegmentationTool.
*/
class MITKSEGMENTATIONUI_EXPORT QmitkAutoSegmentationToolGUIBase : public QmitkToolGUI
{
Q_OBJECT
public:
mitkClassMacro(QmitkAutoSegmentationToolGUIBase, QmitkToolGUI);
itkCloneMacro(Self);
itkGetConstMacro(Mode2D, bool);
protected slots:
void OnNewToolAssociated(mitk::Tool *);
void OnAcceptPreview();
protected:
QmitkAutoSegmentationToolGUIBase(bool mode2D);
~QmitkAutoSegmentationToolGUIBase() override;
virtual void DisconnectOldTool(mitk::AutoSegmentationWithPreviewTool* oldTool);
virtual void ConnectNewTool(mitk::AutoSegmentationWithPreviewTool* newTool);
+
+ /**This method is called by OnNewToolAssociated if the UI is initialized the
+ first time to allow derived classes to introduce own UI code. Overwrite to change.
+ The implementation should ensure that alle widgets needed for the tool UI are
+ properly allocated. If one needs to eecute time (e.g. to connect events between the tool
+ and the UI) each time the tool changes, override the functions ConnectNewTool() and
+ DisconnectOldTool().*/
virtual void InitializeUI(QBoxLayout* mainLayout);
void BusyStateChanged(bool isBusy) override;
using EnableConfirmSegBtnFunctionType = std::function<bool(bool)>;
EnableConfirmSegBtnFunctionType m_EnableConfirmSegBtnFnc;
+ /**This method is used to control/set the enabled state of the tool UI
+ widgets. It is e.g. used if the busy state is changed (see BusyStateChanged).
+ Override the default implmentation, e.g. if a tool adds his own UI elements
+ (normally by overriding InitializeUI()) and wants to control how the widgets
+ are enabled/disabled.*/
virtual void EnableWidgets(bool enabled);
template <class TTool>
TTool* GetConnectedToolAs()
{
return dynamic_cast<TTool*>(m_Tool.GetPointer());
};
private:
QCheckBox* m_CheckProcessAll = nullptr;
QCheckBox* m_CheckCreateNew = nullptr;
QPushButton* m_ConfirmSegBtn = nullptr;
QBoxLayout* m_MainLayout = nullptr;
/**Indicates if the tool is in 2D or 3D mode.*/
bool m_Mode2D;
mitk::AutoSegmentationWithPreviewTool::Pointer m_Tool;
};
#endif
diff --git a/Modules/SegmentationUI/Qmitk/QmitkOtsuTool3DGUI.h b/Modules/SegmentationUI/Qmitk/QmitkOtsuTool3DGUI.h
index f9d87fd615..55b7030ea5 100644
--- a/Modules/SegmentationUI/Qmitk/QmitkOtsuTool3DGUI.h
+++ b/Modules/SegmentationUI/Qmitk/QmitkOtsuTool3DGUI.h
@@ -1,64 +1,64 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
#ifndef QmitkOtsuTool3DGUI_h_Included
#define QmitkOtsuTool3DGUI_h_Included
#include "QmitkAutoMLSegmentationToolGUIBase.h"
#include "ui_QmitkOtsuToolWidgetControls.h"
#include <MitkSegmentationUIExports.h>
/**
\ingroup org_mitk_gui_qt_interactivesegmentation_internal
- \brief GUI for mitk::.
+ \brief GUI for mitk::OtsuTool3D.
\sa mitk::
This GUI shows ...
Last contributor: $Author$
*/
class MITKSEGMENTATIONUI_EXPORT QmitkOtsuTool3DGUI : public QmitkAutoMLSegmentationToolGUIBase
{
Q_OBJECT
public:
mitkClassMacro(QmitkOtsuTool3DGUI, QmitkAutoMLSegmentationToolGUIBase);
itkFactorylessNewMacro(Self);
itkCloneMacro(Self);
protected slots :
void OnPreviewBtnClicked();
void OnRegionSpinboxChanged(int);
private slots:
void OnAdvancedSettingsButtonToggled(bool toggled);
protected:
QmitkOtsuTool3DGUI();
~QmitkOtsuTool3DGUI() = default;
void ConnectNewTool(mitk::AutoSegmentationWithPreviewTool* newTool) override;
void InitializeUI(QBoxLayout* mainLayout) override;
void EnableWidgets(bool enabled) override;
Ui_QmitkOtsuToolWidgetControls m_Controls;
bool m_FirstPreviewComputation = true;
};
#endif
diff --git a/Modules/SegmentationUI/Qmitk/QmitkPickingToolGUI.cpp b/Modules/SegmentationUI/Qmitk/QmitkPickingToolGUI.cpp
index be695b9ae5..a54812842d 100644
--- a/Modules/SegmentationUI/Qmitk/QmitkPickingToolGUI.cpp
+++ b/Modules/SegmentationUI/Qmitk/QmitkPickingToolGUI.cpp
@@ -1,51 +1,74 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
#include "QmitkPickingToolGUI.h"
-#include "QmitkNewSegmentationDialog.h"
-
-#include "mitkBaseRenderer.h"
-#include "mitkStepper.h"
+#include <mitkPickingTool.h>
#include <qlabel.h>
-#include <qlayout.h>
-#include <qpainter.h>
#include <qpushbutton.h>
-#include <qslider.h>
+#include <qboxlayout.h>
MITK_TOOL_GUI_MACRO(MITKSEGMENTATIONUI_EXPORT, QmitkPickingToolGUI, "")
-QmitkPickingToolGUI::QmitkPickingToolGUI() : QmitkToolGUI()
+QmitkPickingToolGUI::QmitkPickingToolGUI() : QmitkAutoSegmentationToolGUIBase(false)
{
- m_Controls.setupUi(this);
+ auto enablePickingDelegate = [this](bool enabled)
+ {
+ bool result = false;
+ auto tool = this->GetConnectedToolAs<mitk::PickingTool>();
+ if (nullptr != tool)
+ {
+ result = enabled && tool->HasPicks();
+ }
- connect(m_Controls.m_ConfirmButton, SIGNAL(clicked()), this, SLOT(OnConfirmSegmentation()));
+ return result;
+ };
- connect(this, SIGNAL(NewToolAssociated(mitk::Tool *)), this, SLOT(OnNewToolAssociated(mitk::Tool *)));
+ m_EnableConfirmSegBtnFnc = enablePickingDelegate;
}
QmitkPickingToolGUI::~QmitkPickingToolGUI()
{
}
-void QmitkPickingToolGUI::OnNewToolAssociated(mitk::Tool *tool)
+void QmitkPickingToolGUI::OnResetPicksClicked()
{
- m_PickingTool = dynamic_cast<mitk::PickingTool *>(tool);
+ auto tool = this->GetConnectedToolAs<mitk::PickingTool>();
+ if (nullptr != tool)
+ {
+ tool->ClearPicks();
+ }
}
-void QmitkPickingToolGUI::OnConfirmSegmentation()
+void QmitkPickingToolGUI::InitializeUI(QBoxLayout* mainLayout)
{
- if (m_PickingTool.IsNotNull())
+ QLabel* label = new QLabel("Press SHIFT and click to pick region(s).\nPress DEL to remove last pick.", this);
+ mainLayout->addWidget(label);
+
+ auto clearButton = new QPushButton("Reset picks",this);
+ connect(clearButton, &QPushButton::clicked, this, &QmitkPickingToolGUI::OnResetPicksClicked);
+ mainLayout->addWidget(clearButton);
+ m_ClearPicksBtn = clearButton;
+
+ Superclass::InitializeUI(mainLayout);
+}
+
+void QmitkPickingToolGUI::EnableWidgets(bool enabled)
+{
+ Superclass::EnableWidgets(enabled);
+
+ if (nullptr != m_ClearPicksBtn)
{
- m_PickingTool->ConfirmSegmentation();
+ m_ClearPicksBtn->setEnabled(enabled);
}
}
+
diff --git a/Modules/SegmentationUI/Qmitk/QmitkPickingToolGUI.h b/Modules/SegmentationUI/Qmitk/QmitkPickingToolGUI.h
index bf8a3b78b5..0a1c65aecb 100644
--- a/Modules/SegmentationUI/Qmitk/QmitkPickingToolGUI.h
+++ b/Modules/SegmentationUI/Qmitk/QmitkPickingToolGUI.h
@@ -1,60 +1,47 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
#ifndef QmitkPickingToolGUI_h_Included
#define QmitkPickingToolGUI_h_Included
-#include "QmitkToolGUI.h"
-#include "mitkPickingTool.h"
-#include "ui_QmitkPickingToolGUIControls.h"
+#include "QmitkAutoSegmentationToolGUIBase.h"
#include <MitkSegmentationUIExports.h>
-class QSlider;
-class QLabel;
-class QFrame;
-class QPushButton;
-#include <QCheckBox>
-
-#include "QmitkStepperAdapter.h"
-
-class QmitkPickingToolGUIControls;
-
/**
\ingroup org_mitk_gui_qt_interactivesegmentation_internal
-\brief GUI for mitk::LiveWireTool.
+\brief GUI for mitk::PickingTool.
\sa mitk::PickingTool
*/
-class MITKSEGMENTATIONUI_EXPORT QmitkPickingToolGUI : public QmitkToolGUI
+class MITKSEGMENTATIONUI_EXPORT QmitkPickingToolGUI : public QmitkAutoSegmentationToolGUIBase
{
Q_OBJECT
public:
- mitkClassMacro(QmitkPickingToolGUI, QmitkToolGUI);
+ mitkClassMacro(QmitkPickingToolGUI, QmitkAutoSegmentationToolGUIBase);
itkFactorylessNewMacro(Self);
itkCloneMacro(Self);
- protected slots :
-
- void OnNewToolAssociated(mitk::Tool *);
-
- void OnConfirmSegmentation();
+protected slots :
+ void OnResetPicksClicked();
protected:
QmitkPickingToolGUI();
~QmitkPickingToolGUI() override;
- Ui::QmitkPickingToolGUIControls m_Controls;
+ void InitializeUI(QBoxLayout* mainLayout) override;
+ void EnableWidgets(bool enabled) override;
- mitk::PickingTool::Pointer m_PickingTool;
+private:
+ QWidget* m_ClearPicksBtn = nullptr;
};
#endif
diff --git a/Modules/SegmentationUI/Qmitk/QmitkPickingToolGUIControls.ui b/Modules/SegmentationUI/Qmitk/QmitkPickingToolGUIControls.ui
deleted file mode 100644
index 02979d04cf..0000000000
--- a/Modules/SegmentationUI/Qmitk/QmitkPickingToolGUIControls.ui
+++ /dev/null
@@ -1,93 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<ui version="4.0">
- <class>QmitkPickingToolGUIControls</class>
- <widget class="QWidget" name="QmitkPickingToolGUIControls">
- <property name="geometry">
- <rect>
- <x>0</x>
- <y>0</y>
- <width>421</width>
- <height>263</height>
- </rect>
- </property>
- <property name="sizePolicy">
- <sizepolicy hsizetype="Ignored" vsizetype="Minimum">
- <horstretch>0</horstretch>
- <verstretch>0</verstretch>
- </sizepolicy>
- </property>
- <property name="minimumSize">
- <size>
- <width>0</width>
- <height>0</height>
- </size>
- </property>
- <property name="windowTitle">
- <string>QmitkPickingToolGUIControls</string>
- </property>
- <property name="toolTip">
- <string>Confirm all previous contour.</string>
- </property>
- <layout class="QVBoxLayout" name="verticalLayout">
- <property name="margin">
- <number>0</number>
- </property>
- <item>
- <layout class="QVBoxLayout" name="verticalLayout_2">
- <item>
- <widget class="QLabel" name="label">
- <property name="maximumSize">
- <size>
- <width>16777215</width>
- <height>20</height>
- </size>
- </property>
- <property name="text">
- <string>Use shift click to pick a single</string>
- </property>
- </widget>
- </item>
- <item>
- <widget class="QLabel" name="label_2">
- <property name="maximumSize">
- <size>
- <width>16777215</width>
- <height>20</height>
- </size>
- </property>
- <property name="text">
- <string>region from the segmentation image.</string>
- </property>
- </widget>
- </item>
- <item>
- <spacer name="verticalSpacer_2">
- <property name="orientation">
- <enum>Qt::Vertical</enum>
- </property>
- <property name="sizeType">
- <enum>QSizePolicy::Fixed</enum>
- </property>
- <property name="sizeHint" stdset="0">
- <size>
- <width>20</width>
- <height>15</height>
- </size>
- </property>
- </spacer>
- </item>
- <item>
- <widget class="QPushButton" name="m_ConfirmButton">
- <property name="text">
- <string>Confirm picked region</string>
- </property>
- </widget>
- </item>
- </layout>
- </item>
- </layout>
- </widget>
- <layoutdefault spacing="6" margin="11"/>
- <resources/>
- <connections/>
-</ui>
diff --git a/Modules/SegmentationUI/files.cmake b/Modules/SegmentationUI/files.cmake
index fb35d7707a..e71eb77792 100644
--- a/Modules/SegmentationUI/files.cmake
+++ b/Modules/SegmentationUI/files.cmake
@@ -1,91 +1,90 @@
set( CPP_FILES
Qmitk/QmitkAdaptiveRegionGrowingToolGUI.cpp
Qmitk/QmitkAutoSegmentationToolGUIBase.cpp
Qmitk/QmitkAutoMLSegmentationToolGUIBase.cpp
Qmitk/QmitkBinaryThresholdToolGUIBase.cpp
Qmitk/QmitkBinaryThresholdToolGUI.cpp
Qmitk/QmitkBinaryThresholdULToolGUI.cpp
Qmitk/QmitkCalculateGrayValueStatisticsToolGUI.cpp
Qmitk/QmitkConfirmSegmentationDialog.cpp
Qmitk/QmitkCopyToClipBoardDialog.cpp
Qmitk/QmitkDrawPaintbrushToolGUI.cpp
Qmitk/QmitkErasePaintbrushToolGUI.cpp
Qmitk/QmitkFastMarchingToolGUIBase.cpp
Qmitk/QmitkFastMarchingTool3DGUI.cpp
Qmitk/QmitkFastMarchingToolGUI.cpp
Qmitk/QmitkLiveWireTool2DGUI.cpp
Qmitk/QmitkNewSegmentationDialog.cpp
Qmitk/QmitkOtsuTool3DGUI.cpp
Qmitk/QmitkPaintbrushToolGUI.cpp
Qmitk/QmitkPickingToolGUI.cpp
Qmitk/QmitkPixelManipulationToolGUI.cpp
Qmitk/QmitkSlicesInterpolator.cpp
Qmitk/QmitkToolGUI.cpp
Qmitk/QmitkToolGUIArea.cpp
Qmitk/QmitkToolSelectionBox.cpp
Qmitk/QmitkWatershedToolGUI.cpp
#Added from ML
Qmitk/QmitkLabelSetWidget.cpp
Qmitk/QmitkSurfaceStampWidget.cpp
Qmitk/QmitkMaskStampWidget.cpp
Qmitk/QmitkSliceBasedInterpolatorWidget.cpp
Qmitk/QmitkSurfaceBasedInterpolatorWidget.cpp
Qmitk/QmitkSearchLabelDialog.cpp
Qmitk/QmitkSimpleLabelSetListWidget.cpp
)
set(MOC_H_FILES
Qmitk/QmitkAdaptiveRegionGrowingToolGUI.h
Qmitk/QmitkAutoSegmentationToolGUIBase.h
Qmitk/QmitkAutoMLSegmentationToolGUIBase.h
Qmitk/QmitkBinaryThresholdToolGUIBase.h
Qmitk/QmitkBinaryThresholdToolGUI.h
Qmitk/QmitkBinaryThresholdULToolGUI.h
Qmitk/QmitkCalculateGrayValueStatisticsToolGUI.h
Qmitk/QmitkConfirmSegmentationDialog.h
Qmitk/QmitkCopyToClipBoardDialog.h
Qmitk/QmitkDrawPaintbrushToolGUI.h
Qmitk/QmitkErasePaintbrushToolGUI.h
Qmitk/QmitkFastMarchingToolGUIBase.h
Qmitk/QmitkFastMarchingTool3DGUI.h
Qmitk/QmitkFastMarchingToolGUI.h
Qmitk/QmitkLiveWireTool2DGUI.h
Qmitk/QmitkNewSegmentationDialog.h
Qmitk/QmitkOtsuTool3DGUI.h
Qmitk/QmitkPaintbrushToolGUI.h
Qmitk/QmitkPickingToolGUI.h
Qmitk/QmitkPixelManipulationToolGUI.h
Qmitk/QmitkSlicesInterpolator.h
Qmitk/QmitkToolGUI.h
Qmitk/QmitkToolGUIArea.h
Qmitk/QmitkToolSelectionBox.h
Qmitk/QmitkWatershedToolGUI.h
#Added from ML
Qmitk/QmitkLabelSetWidget.h
Qmitk/QmitkSurfaceStampWidget.h
Qmitk/QmitkMaskStampWidget.h
Qmitk/QmitkSliceBasedInterpolatorWidget.h
Qmitk/QmitkSurfaceBasedInterpolatorWidget.h
Qmitk/QmitkSearchLabelDialog.h
Qmitk/QmitkSimpleLabelSetListWidget.h
)
set(UI_FILES
Qmitk/QmitkAdaptiveRegionGrowingToolGUIControls.ui
Qmitk/QmitkConfirmSegmentationDialog.ui
Qmitk/QmitkOtsuToolWidgetControls.ui
-Qmitk/QmitkPickingToolGUIControls.ui
Qmitk/QmitkLiveWireTool2DGUIControls.ui
Qmitk/QmitkWatershedToolGUIControls.ui
#Added from ML
Qmitk/QmitkLabelSetWidgetControls.ui
Qmitk/QmitkSurfaceStampWidgetGUIControls.ui
Qmitk/QmitkMaskStampWidgetGUIControls.ui
Qmitk/QmitkSliceBasedInterpolatorWidgetGUIControls.ui
Qmitk/QmitkSurfaceBasedInterpolatorWidgetGUIControls.ui
Qmitk/QmitkSearchLabelDialogGUI.ui
)
set(QRC_FILES
resources/SegmentationUI.qrc
)
diff --git a/Plugins/org.mitk.gui.qt.segmentation/documentation/UserManual/QmitkSegmentation_PickingTool.png b/Plugins/org.mitk.gui.qt.segmentation/documentation/UserManual/QmitkSegmentation_PickingTool.png
index 78ccccd56f..0246c8ecd0 100644
Binary files a/Plugins/org.mitk.gui.qt.segmentation/documentation/UserManual/QmitkSegmentation_PickingTool.png and b/Plugins/org.mitk.gui.qt.segmentation/documentation/UserManual/QmitkSegmentation_PickingTool.png differ