diff --git a/Modules/ContourModel/Algorithms/mitkContourModelUtils.cpp b/Modules/ContourModel/Algorithms/mitkContourModelUtils.cpp
index 6ba5a6e95a..730183f65e 100755
--- a/Modules/ContourModel/Algorithms/mitkContourModelUtils.cpp
+++ b/Modules/ContourModel/Algorithms/mitkContourModelUtils.cpp
@@ -1,292 +1,292 @@
/*============================================================================
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 <mitkContourModelToSurfaceFilter.h>
#include <mitkLabelSetImage.h>
#include <mitkSurface.h>
#include <vtkImageStencil.h>
#include <vtkPointData.h>
#include <vtkPolyData.h>
#include <vtkPolyDataToImageStencil.h>
mitk::ContourModelUtils::ContourModelUtils()
{
}
mitk::ContourModelUtils::~ContourModelUtils()
{
}
mitk::ContourModel::Pointer mitk::ContourModelUtils::ProjectContourTo2DSlice(
const Image *slice, const ContourModel *contourIn3D)
{
if (nullptr == slice || nullptr == contourIn3D)
return nullptr;
auto projectedContour = ContourModel::New();
projectedContour->Initialize(*contourIn3D);
auto sliceGeometry = slice->GetGeometry();
const auto numberOfTimesteps = static_cast<TimeStepType>(contourIn3D->GetTimeSteps());
for (std::remove_const_t<decltype(numberOfTimesteps)> t = 0; t < numberOfTimesteps; ++t)
{
auto iter = contourIn3D->Begin(t);
auto end = contourIn3D->End(t);
while (iter != end)
{
const auto ¤tPointIn3D = (*iter)->Coordinates;
Point3D projectedPointIn2D;
projectedPointIn2D.Fill(0.0);
sliceGeometry->WorldToIndex(currentPointIn3D, projectedPointIn2D);
projectedContour->AddVertex(projectedPointIn2D, t);
++iter;
}
}
return projectedContour;
}
mitk::ContourModel::Pointer mitk::ContourModelUtils::BackProjectContourFrom2DSlice(
const BaseGeometry *sliceGeometry, const ContourModel *contourIn2D)
{
if (nullptr == sliceGeometry || nullptr == contourIn2D)
return nullptr;
auto worldContour = ContourModel::New();
worldContour->Initialize(*contourIn2D);
const auto numberOfTimesteps = static_cast<TimeStepType>(contourIn2D->GetTimeSteps());
for (std::remove_const_t<decltype(numberOfTimesteps)> t = 0; t < numberOfTimesteps; ++t)
{
auto iter = contourIn2D->Begin(t);
auto end = contourIn2D->End(t);
while (iter != end)
{
const auto ¤tPointIn2D = (*iter)->Coordinates;
Point3D worldPointIn3D;
worldPointIn3D.Fill(0.0);
sliceGeometry->IndexToWorld(currentPointIn2D, worldPointIn3D);
worldContour->AddVertex(worldPointIn3D, t);
++iter;
}
}
return worldContour;
}
void mitk::ContourModelUtils::FillContourInSlice2(
const ContourModel* projectedContour, Image* sliceImage, int paintingPixelValue)
{
FillContourInSlice2(projectedContour, 0, sliceImage, paintingPixelValue);
}
void mitk::ContourModelUtils::FillContourInSlice2(
const ContourModel* projectedContour, TimeStepType contourTimeStep, Image* sliceImage, int paintingPixelValue)
{
if (nullptr == projectedContour)
{
mitkThrow() << "Cannot fill contour in slice. Passed contour is invalid";
}
if (nullptr == sliceImage)
{
mitkThrow() << "Cannot fill contour in slice. Passed slice is invalid";
}
auto contourModelFilter = mitk::ContourModelToSurfaceFilter::New();
contourModelFilter->SetInput(projectedContour);
contourModelFilter->Update();
auto surface = mitk::Surface::New();
surface = contourModelFilter->GetOutput();
if (nullptr == surface->GetVtkPolyData(contourTimeStep))
{
MITK_WARN << "Could not create surface from contour model.";
return;
}
auto surface2D = vtkSmartPointer<vtkPolyData>::New();
surface2D->SetPoints(surface->GetVtkPolyData(contourTimeStep)->GetPoints());
surface2D->SetLines(surface->GetVtkPolyData(contourTimeStep)->GetLines());
auto polyDataToImageStencil = vtkSmartPointer<vtkPolyDataToImageStencil>::New();
// Set a minimal tolerance, so that clipped pixels will be added to contour as well.
polyDataToImageStencil->SetTolerance(mitk::eps);
polyDataToImageStencil->SetInputData(surface2D);
polyDataToImageStencil->Update();
auto imageStencil = vtkSmartPointer<vtkImageStencil>::New();
imageStencil->SetInputData(sliceImage->GetVtkImageData());
imageStencil->SetStencilConnection(polyDataToImageStencil->GetOutputPort());
imageStencil->ReverseStencilOn();
imageStencil->SetBackgroundValue(paintingPixelValue);
imageStencil->Update();
vtkSmartPointer<vtkImageData> filledImage = imageStencil->GetOutput();
sliceImage->SetVolume(filledImage->GetScalarPointer());
}
void mitk::ContourModelUtils::FillContourInSlice(
const ContourModel *projectedContour, Image *sliceImage, const Image* workingImage, int paintingPixelValue)
{
FillContourInSlice(projectedContour, 0, sliceImage, workingImage, paintingPixelValue);
}
void mitk::ContourModelUtils::FillContourInSlice(
const ContourModel *projectedContour, TimeStepType contourTimeStep, Image *sliceImage, const Image* workingImage, int paintingPixelValue)
{
if (nullptr == projectedContour)
{
mitkThrow() << "Cannot fill contour in slice. Passed contour is invalid";
}
if (nullptr == sliceImage)
{
mitkThrow() << "Cannot fill contour in slice. Passed slice is invalid";
}
auto contourModelFilter = mitk::ContourModelToSurfaceFilter::New();
contourModelFilter->SetInput(projectedContour);
contourModelFilter->Update();
auto surface = mitk::Surface::New();
surface = contourModelFilter->GetOutput();
if (nullptr == surface->GetVtkPolyData(contourTimeStep))
{
MITK_WARN << "Could not create surface from contour model.";
return;
}
auto surface2D = vtkSmartPointer<vtkPolyData>::New();
surface2D->SetPoints(surface->GetVtkPolyData(contourTimeStep)->GetPoints());
surface2D->SetLines(surface->GetVtkPolyData(contourTimeStep)->GetLines());
auto image = vtkSmartPointer<vtkImageData>::New();
image->DeepCopy(sliceImage->GetVtkImageData());
const double FOREGROUND_VALUE = 255.0;
const double BACKGROUND_VALUE = 0.0;
const vtkIdType count = image->GetNumberOfPoints();
for (std::remove_const_t<decltype(count)> i = 0; i < count; ++i)
image->GetPointData()->GetScalars()->SetTuple1(i, FOREGROUND_VALUE);
auto polyDataToImageStencil = vtkSmartPointer<vtkPolyDataToImageStencil>::New();
// Set a minimal tolerance, so that clipped pixels will be added to contour as well.
polyDataToImageStencil->SetTolerance(mitk::eps);
polyDataToImageStencil->SetInputData(surface2D);
polyDataToImageStencil->Update();
auto imageStencil = vtkSmartPointer<vtkImageStencil>::New();
imageStencil->SetInputData(image);
imageStencil->SetStencilConnection(polyDataToImageStencil->GetOutputPort());
imageStencil->ReverseStencilOff();
imageStencil->SetBackgroundValue(BACKGROUND_VALUE);
imageStencil->Update();
vtkSmartPointer<vtkImageData> filledImage = imageStencil->GetOutput();
vtkSmartPointer<vtkImageData> resultImage = sliceImage->GetVtkImageData();
FillSliceInSlice(filledImage, resultImage, workingImage, paintingPixelValue);
sliceImage->SetVolume(resultImage->GetScalarPointer());
}
void mitk::ContourModelUtils::FillSliceInSlice(
vtkSmartPointer<vtkImageData> filledImage, vtkSmartPointer<vtkImageData> resultImage, const Image* image, int paintingPixelValue, double fillForegroundThreshold)
{
auto labelImage = dynamic_cast<const LabelSetImage *>(image);
const auto numberOfPoints = filledImage->GetNumberOfPoints();
if (nullptr == labelImage)
{
for (std::remove_const_t<decltype(numberOfPoints)> i = 0; i < numberOfPoints; ++i)
{
if (fillForegroundThreshold <= filledImage->GetPointData()->GetScalars()->GetTuple1(i))
resultImage->GetPointData()->GetScalars()->SetTuple1(i, paintingPixelValue);
}
}
else
{
- if (paintingPixelValue != LabelSetImage::UnlabeledValue)
+ if (paintingPixelValue != LabelSetImage::UNLABELED_VALUE)
{
for (std::remove_const_t<decltype(numberOfPoints)> i = 0; i < numberOfPoints; ++i)
{
const auto filledValue = filledImage->GetPointData()->GetScalars()->GetTuple1(i);
if (fillForegroundThreshold <= filledValue)
{
const auto existingValue = resultImage->GetPointData()->GetScalars()->GetTuple1(i);
if (!labelImage->IsLabelLocked(existingValue))
resultImage->GetPointData()->GetScalars()->SetTuple1(i, paintingPixelValue);
}
}
}
else
{
const auto activePixelValue = labelImage->GetActiveLabel()->GetValue();
for (std::remove_const_t<decltype(numberOfPoints)> i = 0; i < numberOfPoints; ++i)
{
if (fillForegroundThreshold <= filledImage->GetPointData()->GetScalars()->GetTuple1(i))
{
if (resultImage->GetPointData()->GetScalars()->GetTuple1(i) == activePixelValue)
resultImage->GetPointData()->GetScalars()->SetTuple1(i, paintingPixelValue);
}
}
}
}
}
mitk::ContourModel::Pointer mitk::ContourModelUtils::MoveZerothContourTimeStep(const ContourModel *contour, TimeStepType t)
{
if (nullptr == contour)
return nullptr;
auto resultContour = ContourModel::New();
resultContour->Expand(t + 1);
std::for_each(contour->Begin(), contour->End(), [&resultContour, t](ContourElement::VertexType *vertex) {
resultContour->AddVertex(*vertex, t);
});
return resultContour;
}
int mitk::ContourModelUtils::GetActivePixelValue(const Image* workingImage)
{
auto labelSetImage = dynamic_cast<const LabelSetImage*>(workingImage);
int activePixelValue = 1;
if (nullptr != labelSetImage)
{
activePixelValue = labelSetImage->GetActiveLabel()->GetValue();
}
return activePixelValue;
}
diff --git a/Modules/Multilabel/autoload/DICOMSegIO/mitkDICOMSegmentationIO.cpp b/Modules/Multilabel/autoload/DICOMSegIO/mitkDICOMSegmentationIO.cpp
index 2d635fb7de..91e7b9e84a 100644
--- a/Modules/Multilabel/autoload/DICOMSegIO/mitkDICOMSegmentationIO.cpp
+++ b/Modules/Multilabel/autoload/DICOMSegIO/mitkDICOMSegmentationIO.cpp
@@ -1,697 +1,697 @@
/*============================================================================
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 __mitkDICOMSegmentationIO__cpp
#define __mitkDICOMSegmentationIO__cpp
#include "mitkDICOMSegmentationIO.h"
#include "mitkDICOMSegIOMimeTypes.h"
#include "mitkDICOMSegmentationConstants.h"
#include <mitkDICOMDCMTKTagScanner.h>
#include <mitkDICOMIOHelper.h>
#include <mitkDICOMProperty.h>
#include <mitkIDICOMTagsOfInterest.h>
#include <mitkImageAccessByItk.h>
#include <mitkImageCast.h>
#include <mitkLocaleSwitch.h>
#include <mitkPropertyNameHelper.h>
// itk
#include <itkThresholdImageFilter.h>
// dcmqi
#include <dcmqi/ImageSEGConverter.h>
// us
#include <usGetModuleContext.h>
#include <usModuleContext.h>
namespace mitk
{
DICOMSegmentationIO::DICOMSegmentationIO()
: AbstractFileIO(LabelSetImage::GetStaticNameOfClass(),
mitk::MitkDICOMSEGIOMimeTypes::DICOMSEG_MIMETYPE_NAME(),
"DICOM Segmentation")
{
AbstractFileWriter::SetRanking(10);
AbstractFileReader::SetRanking(10);
this->RegisterService();
}
std::vector<mitk::DICOMTagPath> DICOMSegmentationIO::GetDICOMTagsOfInterest()
{
std::vector<mitk::DICOMTagPath> result;
result.emplace_back(DICOMSegmentationConstants::SEGMENT_SEQUENCE_PATH());
result.emplace_back(DICOMSegmentationConstants::SEGMENT_NUMBER_PATH());
result.emplace_back(DICOMSegmentationConstants::SEGMENT_LABEL_PATH());
result.emplace_back(DICOMSegmentationConstants::SEGMENT_ALGORITHM_TYPE_PATH());
result.emplace_back(DICOMSegmentationConstants::ANATOMIC_REGION_SEQUENCE_PATH());
result.emplace_back(DICOMSegmentationConstants::ANATOMIC_REGION_CODE_VALUE_PATH());
result.emplace_back(DICOMSegmentationConstants::ANATOMIC_REGION_CODE_SCHEME_PATH());
result.emplace_back(DICOMSegmentationConstants::ANATOMIC_REGION_CODE_MEANING_PATH());
result.emplace_back(DICOMSegmentationConstants::SEGMENTED_PROPERTY_CATEGORY_SEQUENCE_PATH());
result.emplace_back(DICOMSegmentationConstants::SEGMENT_CATEGORY_CODE_VALUE_PATH());
result.emplace_back(DICOMSegmentationConstants::SEGMENT_CATEGORY_CODE_SCHEME_PATH());
result.emplace_back(DICOMSegmentationConstants::SEGMENT_CATEGORY_CODE_MEANING_PATH());
result.emplace_back(DICOMSegmentationConstants::SEGMENTED_PROPERTY_TYPE_SEQUENCE_PATH());
result.emplace_back(DICOMSegmentationConstants::SEGMENT_TYPE_CODE_VALUE_PATH());
result.emplace_back(DICOMSegmentationConstants::SEGMENT_TYPE_CODE_SCHEME_PATH());
result.emplace_back(DICOMSegmentationConstants::SEGMENT_TYPE_CODE_MEANING_PATH());
result.emplace_back(DICOMSegmentationConstants::SEGMENTED_PROPERTY_MODIFIER_SEQUENCE_PATH());
result.emplace_back(DICOMSegmentationConstants::SEGMENT_MODIFIER_CODE_VALUE_PATH());
result.emplace_back(DICOMSegmentationConstants::SEGMENT_MODIFIER_CODE_SCHEME_PATH());
result.emplace_back(DICOMSegmentationConstants::SEGMENT_MODIFIER_CODE_MEANING_PATH());
return result;
}
IFileIO::ConfidenceLevel DICOMSegmentationIO::GetWriterConfidenceLevel() const
{
if (AbstractFileIO::GetWriterConfidenceLevel() == Unsupported)
return Unsupported;
// Check if the input file is a segmentation
const LabelSetImage *input = dynamic_cast<const LabelSetImage *>(this->GetInput());
if (input)
{
if ((input->GetDimension() != 3))
{
MITK_INFO << "DICOM segmentation writer is tested only with 3D images, sorry.";
return Unsupported;
}
// Check if input file has dicom information for the referenced image (original DICOM image, e.g. CT) Still necessary, see write()
mitk::StringLookupTableProperty::Pointer dicomFilesProp =
dynamic_cast<mitk::StringLookupTableProperty *>(input->GetProperty("referenceFiles").GetPointer());
if (dicomFilesProp.IsNotNull())
return Supported;
}
return Unsupported;
}
void DICOMSegmentationIO::Write()
{
ValidateOutputLocation();
mitk::LocaleSwitch localeSwitch("C");
LocalFile localFile(this);
const std::string path = localFile.GetFileName();
auto input = dynamic_cast<const LabelSetImage *>(this->GetInput());
if (input == nullptr)
mitkThrow() << "Cannot write non-image data";
// Get DICOM information from referenced image
vector<std::unique_ptr<DcmDataset>> dcmDatasetsSourceImage;
std::unique_ptr<DcmFileFormat> readFileFormat(new DcmFileFormat());
try
{
// TODO: Generate dcmdataset witk DICOM tags from property list; ATM the source are the filepaths from the
// property list
mitk::StringLookupTableProperty::Pointer filesProp =
dynamic_cast<mitk::StringLookupTableProperty *>(input->GetProperty("referenceFiles").GetPointer());
if (filesProp.IsNull())
{
mitkThrow() << "No property with dicom file path.";
return;
}
StringLookupTable filesLut = filesProp->GetValue();
const StringLookupTable::LookupTableType &lookUpTableMap = filesLut.GetLookupTable();
for (const auto &it : lookUpTableMap)
{
const char *fileName = (it.second).c_str();
if (readFileFormat->loadFile(fileName, EXS_Unknown).good())
{
std::unique_ptr<DcmDataset> readDCMDataset(readFileFormat->getAndRemoveDataset());
dcmDatasetsSourceImage.push_back(std::move(readDCMDataset));
}
}
}
catch (const std::exception &e)
{
MITK_ERROR << "An error occurred while getting the dicom informations: " << e.what() << endl;
return;
}
// Iterate over all layers. For each a dcm file will be generated
for (unsigned int layer = 0; layer < input->GetNumberOfLayers(); ++layer)
{
vector<itkInternalImageType::Pointer> segmentations;
try
{
// Hack: Remove the const attribute to switch between the layer images. Normally you could get the different
// layer images by input->GetLayerImage(layer)
mitk::LabelSetImage *mitkLayerImage = const_cast<mitk::LabelSetImage *>(input);
mitkLayerImage->SetActiveLayer(layer);
// Cast mitk layer image to itk
ImageToItk<itkInputImageType>::Pointer imageToItkFilter = ImageToItk<itkInputImageType>::New();
imageToItkFilter->SetInput(mitkLayerImage);
// Cast from original itk type to dcmqi input itk image type
typedef itk::CastImageFilter<itkInputImageType, itkInternalImageType> castItkImageFilterType;
castItkImageFilterType::Pointer castFilter = castItkImageFilterType::New();
castFilter->SetInput(imageToItkFilter->GetOutput());
castFilter->Update();
itkInternalImageType::Pointer itkLabelImage = castFilter->GetOutput();
itkLabelImage->DisconnectPipeline();
// Iterate over all labels. For each label a segmentation image will be created
auto labelSet = input->GetConstLabelsByValue(input->GetLabelValuesByGroup(layer));
for (const auto label : labelSet)
{
// Thresold over the image with the given label value
itk::ThresholdImageFilter<itkInternalImageType>::Pointer thresholdFilter =
itk::ThresholdImageFilter<itkInternalImageType>::New();
thresholdFilter->SetInput(itkLabelImage);
thresholdFilter->ThresholdOutside(label->GetValue(), label->GetValue());
thresholdFilter->SetOutsideValue(0);
thresholdFilter->Update();
itkInternalImageType::Pointer segmentImage = thresholdFilter->GetOutput();
segmentImage->DisconnectPipeline();
segmentations.push_back(segmentImage);
}
}
catch (const itk::ExceptionObject &e)
{
MITK_ERROR << e.GetDescription() << endl;
return;
}
// Create segmentation meta information
const std::string tmpMetaInfoFile = this->CreateMetaDataJsonFile(layer);
MITK_INFO << "Writing image: " << path << std::endl;
try
{
//TODO is there a better way? Interface expects a vector of raw pointer.
vector<DcmDataset*> rawVecDataset;
for (const auto& dcmDataSet : dcmDatasetsSourceImage)
rawVecDataset.push_back(dcmDataSet.get());
// Convert itk segmentation images to dicom image
std::unique_ptr<dcmqi::ImageSEGConverter> converter = std::make_unique<dcmqi::ImageSEGConverter>();
std::unique_ptr<DcmDataset> result(converter->itkimage2dcmSegmentation(rawVecDataset, segmentations, tmpMetaInfoFile, false));
// Write dicom file
DcmFileFormat dcmFileFormat(result.get());
std::string filePath = path.substr(0, path.find_last_of("."));
// If there is more than one layer, we have to write more than 1 dicom file
if (input->GetNumberOfLayers() != 1)
filePath = filePath + std::to_string(layer) + ".dcm";
else
filePath = filePath + ".dcm";
dcmFileFormat.saveFile(filePath.c_str(), EXS_LittleEndianExplicit);
}
catch (const std::exception &e)
{
MITK_ERROR << "An error occurred during writing the DICOM Seg: " << e.what() << endl;
return;
}
} // Write a dcm file for the next layer
}
IFileIO::ConfidenceLevel DICOMSegmentationIO::GetReaderConfidenceLevel() const
{
if (AbstractFileIO::GetReaderConfidenceLevel() == Unsupported)
return Unsupported;
const std::string fileName = this->GetLocalFileName();
DcmFileFormat dcmFileFormat;
OFCondition status = dcmFileFormat.loadFile(fileName.c_str());
if (status.bad())
return Unsupported;
OFString modality;
if (dcmFileFormat.getDataset()->findAndGetOFString(DCM_Modality, modality).good())
{
if (modality.compare("SEG") == 0)
return Supported;
else
return Unsupported;
}
return Unsupported;
}
std::vector<BaseData::Pointer> DICOMSegmentationIO::DoRead()
{
mitk::LocaleSwitch localeSwitch("C");
LabelSetImage::Pointer labelSetImage;
std::vector<BaseData::Pointer> result;
const std::string path = this->GetLocalFileName();
MITK_INFO << "loading " << path << std::endl;
if (path.empty())
mitkThrow() << "Empty filename in mitk::ItkImageIO ";
try
{
// Get the dcm data set from file path
DcmFileFormat dcmFileFormat;
OFCondition status = dcmFileFormat.loadFile(path.c_str());
if (status.bad())
mitkThrow() << "Can't read the input file!";
DcmDataset *dataSet = dcmFileFormat.getDataset();
if (dataSet == nullptr)
mitkThrow() << "Can't read data from input file!";
//=============================== dcmqi part ====================================
// Read the DICOM SEG images (segItkImages) and DICOM tags (metaInfo)
std::unique_ptr<dcmqi::ImageSEGConverter> converter = std::make_unique<dcmqi::ImageSEGConverter>();
pair<map<unsigned, itkInternalImageType::Pointer>, string> dcmqiOutput =
converter->dcmSegmentation2itkimage(dataSet);
map<unsigned, itkInternalImageType::Pointer> segItkImages = dcmqiOutput.first;
dcmqi::JSONSegmentationMetaInformationHandler metaInfo(dcmqiOutput.second.c_str());
metaInfo.read();
MITK_INFO << "Input " << metaInfo.getJSONOutputAsString();
//===============================================================================
// Get the label information from segment attributes for each itk image
vector<map<unsigned, dcmqi::SegmentAttributes *>>::const_iterator segmentIter =
metaInfo.segmentsAttributesMappingList.begin();
// For each itk image add a layer to the LabelSetImage output
for (auto &element : segItkImages)
{
// Get the labeled image and cast it to mitkImage
typedef itk::CastImageFilter<itkInternalImageType, itkInputImageType> castItkImageFilterType;
castItkImageFilterType::Pointer castFilter = castItkImageFilterType::New();
castFilter->SetInput(element.second);
castFilter->Update();
Image::Pointer layerImage;
CastToMitkImage(castFilter->GetOutput(), layerImage);
// Get pixel value of the label
itkInternalImageType::ValueType segValue = 1;
typedef itk::ImageRegionIterator<const itkInternalImageType> IteratorType;
// Iterate over the image to find the pixel value of the label
IteratorType iter(element.second, element.second->GetLargestPossibleRegion());
iter.GoToBegin();
while (!iter.IsAtEnd())
{
itkInputImageType::PixelType value = iter.Get();
- if (value != LabelSetImage::UnlabeledValue)
+ if (value != LabelSetImage::UNLABELED_VALUE)
{
segValue = value;
break;
}
++iter;
}
// Get Segment information map
map<unsigned, dcmqi::SegmentAttributes *> segmentMap = (*segmentIter);
map<unsigned, dcmqi::SegmentAttributes *>::const_iterator segmentMapIter = (*segmentIter).begin();
dcmqi::SegmentAttributes *segmentAttribute = (*segmentMapIter).second;
OFString labelName;
if (segmentAttribute->getSegmentedPropertyTypeCodeSequence() != nullptr)
{
segmentAttribute->getSegmentedPropertyTypeCodeSequence()->getCodeMeaning(labelName);
if (segmentAttribute->getSegmentedPropertyTypeModifierCodeSequence() != nullptr)
{
OFString modifier;
segmentAttribute->getSegmentedPropertyTypeModifierCodeSequence()->getCodeMeaning(modifier);
labelName.append(" (").append(modifier).append(")");
}
}
else
{
labelName = std::to_string(segmentAttribute->getLabelID()).c_str();
if (labelName.empty())
labelName = "Unnamed";
}
float tmp[3] = { 0.0, 0.0, 0.0 };
if (segmentAttribute->getRecommendedDisplayRGBValue() != nullptr)
{
tmp[0] = segmentAttribute->getRecommendedDisplayRGBValue()[0] / 255.0;
tmp[1] = segmentAttribute->getRecommendedDisplayRGBValue()[1] / 255.0;
tmp[2] = segmentAttribute->getRecommendedDisplayRGBValue()[2] / 255.0;
}
Label *newLabel = nullptr;
// If labelSetImage do not exists (first image)
if (labelSetImage.IsNull())
{
// Initialize the labelSetImage with the read image
labelSetImage = LabelSetImage::New();
labelSetImage->InitializeByLabeledImage(layerImage);
// Already a label was generated, so set the information to this
newLabel = labelSetImage->GetActiveLabel();
newLabel->SetName(labelName.c_str());
newLabel->SetColor(Color(tmp));
newLabel->SetValue(segValue);
}
else
{
// Add a new layer to the labelSetImage. Background label is set automatically
labelSetImage->AddLayer(layerImage);
// Add new label
newLabel = new Label;
newLabel->SetName(labelName.c_str());
newLabel->SetColor(Color(tmp));
newLabel->SetValue(segValue);
labelSetImage->AddLabel(newLabel, labelSetImage->GetActiveLayer());
}
// Add some more label properties
this->SetLabelProperties(newLabel, segmentAttribute);
++segmentIter;
}
labelSetImage->SetAllLabelsVisible(true);
// Add some general DICOM Segmentation properties
mitk::IDICOMTagsOfInterest *toiSrv = DICOMIOHelper::GetTagsOfInterestService();
auto tagsOfInterest = toiSrv->GetTagsOfInterest();
DICOMTagPathList tagsOfInterestList;
for (const auto &tag : tagsOfInterest)
{
tagsOfInterestList.push_back(tag.first);
}
mitk::DICOMDCMTKTagScanner::Pointer scanner = mitk::DICOMDCMTKTagScanner::New();
scanner->SetInputFiles({ GetInputLocation() });
scanner->AddTagPaths(tagsOfInterestList);
scanner->Scan();
mitk::DICOMDatasetAccessingImageFrameList frames = scanner->GetFrameInfoList();
if (frames.empty())
{
MITK_ERROR << "Error reading the DICOM Seg file" << std::endl;
return result;
}
auto findings = DICOMIOHelper::ExtractPathsOfInterest(tagsOfInterestList, frames);
DICOMIOHelper::SetProperties(labelSetImage, findings);
// Set active layer to the first layer of the labelset image
if (labelSetImage->GetNumberOfLayers() > 1 && labelSetImage->GetActiveLayer() != 0)
labelSetImage->SetActiveLayer(0);
}
catch (const std::exception &e)
{
MITK_ERROR << "An error occurred while reading the DICOM Seg file: " << e.what();
return result;
}
catch (...)
{
MITK_ERROR << "An error occurred in dcmqi while reading the DICOM Seg file";
return result;
}
result.push_back(labelSetImage.GetPointer());
return result;
}
const std::string mitk::DICOMSegmentationIO::CreateMetaDataJsonFile(int layer)
{
const mitk::LabelSetImage *image = dynamic_cast<const mitk::LabelSetImage *>(this->GetInput());
const std::string output;
dcmqi::JSONSegmentationMetaInformationHandler handler;
// 1. Metadata attributes that will be listed in the resulting DICOM SEG object
std::string contentCreatorName;
if (!image->GetPropertyList()->GetStringProperty(GeneratePropertyNameForDICOMTag(0x0070, 0x0084).c_str(),
contentCreatorName))
contentCreatorName = "MITK";
handler.setContentCreatorName(contentCreatorName);
std::string clinicalTrailSeriesId;
if (!image->GetPropertyList()->GetStringProperty(GeneratePropertyNameForDICOMTag(0x0012, 0x0071).c_str(),
clinicalTrailSeriesId))
clinicalTrailSeriesId = "Session 1";
handler.setClinicalTrialSeriesID(clinicalTrailSeriesId);
std::string clinicalTrialTimePointID;
if (!image->GetPropertyList()->GetStringProperty(GeneratePropertyNameForDICOMTag(0x0012, 0x0050).c_str(),
clinicalTrialTimePointID))
clinicalTrialTimePointID = "0";
handler.setClinicalTrialTimePointID(clinicalTrialTimePointID);
std::string clinicalTrialCoordinatingCenterName = "";
if (!image->GetPropertyList()->GetStringProperty(GeneratePropertyNameForDICOMTag(0x0012, 0x0060).c_str(),
clinicalTrialCoordinatingCenterName))
clinicalTrialCoordinatingCenterName = "Unknown";
handler.setClinicalTrialCoordinatingCenterName(clinicalTrialCoordinatingCenterName);
std::string seriesDescription;
if (!image->GetPropertyList()->GetStringProperty("name", seriesDescription))
seriesDescription = "MITK Segmentation";
handler.setSeriesDescription(seriesDescription);
handler.setSeriesNumber("0" + std::to_string(layer));
handler.setInstanceNumber("1");
handler.setBodyPartExamined("");
auto labelSet = image->GetConstLabelsByValue(image->GetLabelValuesByGroup(layer));
for (const auto label : labelSet)
{
if (label != nullptr)
{
TemporoSpatialStringProperty *segmentNumberProp = dynamic_cast<mitk::TemporoSpatialStringProperty *>(label->GetProperty(
mitk::DICOMTagPathToPropertyName(DICOMSegmentationConstants::SEGMENT_NUMBER_PATH()).c_str()));
TemporoSpatialStringProperty *segmentLabelProp = dynamic_cast<mitk::TemporoSpatialStringProperty *>(label->GetProperty(
mitk::DICOMTagPathToPropertyName(DICOMSegmentationConstants::SEGMENT_LABEL_PATH()).c_str()));
TemporoSpatialStringProperty *algorithmTypeProp = dynamic_cast<mitk::TemporoSpatialStringProperty *>(label->GetProperty(
mitk::DICOMTagPathToPropertyName(DICOMSegmentationConstants::SEGMENT_ALGORITHM_TYPE_PATH()).c_str()));
TemporoSpatialStringProperty *segmentCategoryCodeValueProp = dynamic_cast<mitk::TemporoSpatialStringProperty *>(label->GetProperty(
mitk::DICOMTagPathToPropertyName(DICOMSegmentationConstants::SEGMENT_CATEGORY_CODE_VALUE_PATH()).c_str()));
TemporoSpatialStringProperty *segmentCategoryCodeSchemeProp = dynamic_cast<mitk::TemporoSpatialStringProperty *>(label->GetProperty(
mitk::DICOMTagPathToPropertyName(DICOMSegmentationConstants::SEGMENT_CATEGORY_CODE_SCHEME_PATH()).c_str()));
TemporoSpatialStringProperty *segmentCategoryCodeMeaningProp = dynamic_cast<mitk::TemporoSpatialStringProperty *>(label->GetProperty(
mitk::DICOMTagPathToPropertyName(DICOMSegmentationConstants::SEGMENT_CATEGORY_CODE_MEANING_PATH()).c_str()));
TemporoSpatialStringProperty *segmentTypeCodeValueProp = dynamic_cast<mitk::TemporoSpatialStringProperty *>(label->GetProperty(
mitk::DICOMTagPathToPropertyName(DICOMSegmentationConstants::SEGMENT_TYPE_CODE_VALUE_PATH()).c_str()));
TemporoSpatialStringProperty *segmentTypeCodeSchemeProp = dynamic_cast<mitk::TemporoSpatialStringProperty *>(label->GetProperty(
mitk::DICOMTagPathToPropertyName(DICOMSegmentationConstants::SEGMENT_TYPE_CODE_SCHEME_PATH()).c_str()));
TemporoSpatialStringProperty *segmentTypeCodeMeaningProp = dynamic_cast<mitk::TemporoSpatialStringProperty *>(label->GetProperty(
mitk::DICOMTagPathToPropertyName(DICOMSegmentationConstants::SEGMENT_TYPE_CODE_MEANING_PATH()).c_str()));
TemporoSpatialStringProperty *segmentModifierCodeValueProp = dynamic_cast<mitk::TemporoSpatialStringProperty *>(label->GetProperty(
mitk::DICOMTagPathToPropertyName(DICOMSegmentationConstants::SEGMENT_MODIFIER_CODE_VALUE_PATH()).c_str()));
TemporoSpatialStringProperty *segmentModifierCodeSchemeProp = dynamic_cast<mitk::TemporoSpatialStringProperty *>(label->GetProperty(
mitk::DICOMTagPathToPropertyName(DICOMSegmentationConstants::SEGMENT_MODIFIER_CODE_SCHEME_PATH()).c_str()));
TemporoSpatialStringProperty *segmentModifierCodeMeaningProp = dynamic_cast<mitk::TemporoSpatialStringProperty *>(label->GetProperty(
mitk::DICOMTagPathToPropertyName(DICOMSegmentationConstants::SEGMENT_MODIFIER_CODE_MEANING_PATH()).c_str()));
dcmqi::SegmentAttributes *segmentAttribute = nullptr;
if (segmentNumberProp->GetValue() == "")
{
MITK_ERROR << "Something went wrong with the label ID.";
}
else
{
int labelId = std::stoi(segmentNumberProp->GetValue());
segmentAttribute = handler.createAndGetNewSegment(labelId);
}
if (segmentAttribute != nullptr)
{
segmentAttribute->setSegmentLabel(segmentLabelProp->GetValueAsString());
segmentAttribute->setSegmentDescription(segmentLabelProp->GetValueAsString());
segmentAttribute->setSegmentAlgorithmType(algorithmTypeProp->GetValueAsString());
segmentAttribute->setSegmentAlgorithmName("MITK Segmentation");
if (segmentCategoryCodeValueProp != nullptr && segmentCategoryCodeSchemeProp != nullptr &&
segmentCategoryCodeMeaningProp != nullptr)
segmentAttribute->setSegmentedPropertyCategoryCodeSequence(
segmentCategoryCodeValueProp->GetValueAsString(),
segmentCategoryCodeSchemeProp->GetValueAsString(),
segmentCategoryCodeMeaningProp->GetValueAsString());
else
// some default values
segmentAttribute->setSegmentedPropertyCategoryCodeSequence(
"M-01000", "SRT", "Morphologically Altered Structure");
if (segmentTypeCodeValueProp != nullptr && segmentTypeCodeSchemeProp != nullptr &&
segmentTypeCodeMeaningProp != nullptr)
{
segmentAttribute->setSegmentedPropertyTypeCodeSequence(segmentTypeCodeValueProp->GetValueAsString(),
segmentTypeCodeSchemeProp->GetValueAsString(),
segmentTypeCodeMeaningProp->GetValueAsString());
handler.setBodyPartExamined(segmentTypeCodeMeaningProp->GetValueAsString());
}
else
{
// some default values
segmentAttribute->setSegmentedPropertyTypeCodeSequence("M-03000", "SRT", "Mass");
handler.setBodyPartExamined("Mass");
}
if (segmentModifierCodeValueProp != nullptr && segmentModifierCodeSchemeProp != nullptr &&
segmentModifierCodeMeaningProp != nullptr)
segmentAttribute->setSegmentedPropertyTypeModifierCodeSequence(
segmentModifierCodeValueProp->GetValueAsString(),
segmentModifierCodeSchemeProp->GetValueAsString(),
segmentModifierCodeMeaningProp->GetValueAsString());
Color color = label->GetColor();
segmentAttribute->setRecommendedDisplayRGBValue(color[0] * 255, color[1] * 255, color[2] * 255);
}
}
}
return handler.getJSONOutputAsString();
}
void mitk::DICOMSegmentationIO::SetLabelProperties(mitk::Label *label, dcmqi::SegmentAttributes *segmentAttribute)
{
// Segment Number:Identification number of the segment.The value of Segment Number(0062, 0004) shall be unique
// within the Segmentation instance in which it is created
label->SetProperty(DICOMTagPathToPropertyName(DICOMSegmentationConstants::SEGMENT_NUMBER_PATH()).c_str(),
TemporoSpatialStringProperty::New(std::to_string(label->GetValue())));
// Segment Label: User-defined label identifying this segment.
label->SetProperty(DICOMTagPathToPropertyName(DICOMSegmentationConstants::SEGMENT_LABEL_PATH()).c_str(),
TemporoSpatialStringProperty::New(label->GetName()));
// Segment Algorithm Type: Type of algorithm used to generate the segment.
if (!segmentAttribute->getSegmentAlgorithmType().empty())
label->SetProperty(DICOMTagPathToPropertyName(DICOMSegmentationConstants::SEGMENT_ALGORITHM_TYPE_PATH()).c_str(),
TemporoSpatialStringProperty::New(segmentAttribute->getSegmentAlgorithmType()));
// Add Segmented Property Category Code Sequence tags
auto categoryCodeSequence = segmentAttribute->getSegmentedPropertyCategoryCodeSequence();
if (categoryCodeSequence != nullptr)
{
OFString codeValue; // (0008,0100) Code Value
categoryCodeSequence->getCodeValue(codeValue);
label->SetProperty(
DICOMTagPathToPropertyName(DICOMSegmentationConstants::SEGMENT_CATEGORY_CODE_VALUE_PATH()).c_str(),
TemporoSpatialStringProperty::New(codeValue.c_str()));
OFString codeScheme; // (0008,0102) Coding Scheme Designator
categoryCodeSequence->getCodingSchemeDesignator(codeScheme);
label->SetProperty(
DICOMTagPathToPropertyName(DICOMSegmentationConstants::SEGMENT_CATEGORY_CODE_SCHEME_PATH()).c_str(),
TemporoSpatialStringProperty::New(codeScheme.c_str()));
OFString codeMeaning; // (0008,0104) Code Meaning
categoryCodeSequence->getCodeMeaning(codeMeaning);
label->SetProperty(
DICOMTagPathToPropertyName(DICOMSegmentationConstants::SEGMENT_CATEGORY_CODE_MEANING_PATH()).c_str(),
TemporoSpatialStringProperty::New(codeMeaning.c_str()));
}
// Add Segmented Property Type Code Sequence tags
auto typeCodeSequence = segmentAttribute->getSegmentedPropertyTypeCodeSequence();
if (typeCodeSequence != nullptr)
{
OFString codeValue; // (0008,0100) Code Value
typeCodeSequence->getCodeValue(codeValue);
label->SetProperty(DICOMTagPathToPropertyName(DICOMSegmentationConstants::SEGMENT_TYPE_CODE_VALUE_PATH()).c_str(),
TemporoSpatialStringProperty::New(codeValue.c_str()));
OFString codeScheme; // (0008,0102) Coding Scheme Designator
typeCodeSequence->getCodingSchemeDesignator(codeScheme);
label->SetProperty(
DICOMTagPathToPropertyName(DICOMSegmentationConstants::SEGMENT_TYPE_CODE_SCHEME_PATH()).c_str(),
TemporoSpatialStringProperty::New(codeScheme.c_str()));
OFString codeMeaning; // (0008,0104) Code Meaning
typeCodeSequence->getCodeMeaning(codeMeaning);
label->SetProperty(
DICOMTagPathToPropertyName(DICOMSegmentationConstants::SEGMENT_TYPE_CODE_MEANING_PATH()).c_str(),
TemporoSpatialStringProperty::New(codeMeaning.c_str()));
}
// Add Segmented Property Type Modifier Code Sequence tags
auto modifierCodeSequence = segmentAttribute->getSegmentedPropertyTypeModifierCodeSequence();
if (modifierCodeSequence != nullptr)
{
OFString codeValue; // (0008,0100) Code Value
modifierCodeSequence->getCodeValue(codeValue);
label->SetProperty(
DICOMTagPathToPropertyName(DICOMSegmentationConstants::SEGMENT_MODIFIER_CODE_VALUE_PATH()).c_str(),
TemporoSpatialStringProperty::New(codeValue.c_str()));
OFString codeScheme; // (0008,0102) Coding Scheme Designator
modifierCodeSequence->getCodingSchemeDesignator(codeScheme);
label->SetProperty(
DICOMTagPathToPropertyName(DICOMSegmentationConstants::SEGMENT_MODIFIER_CODE_SCHEME_PATH()).c_str(),
TemporoSpatialStringProperty::New(codeScheme.c_str()));
OFString codeMeaning; // (0008,0104) Code Meaning
modifierCodeSequence->getCodeMeaning(codeMeaning);
label->SetProperty(
DICOMTagPathToPropertyName(DICOMSegmentationConstants::SEGMENT_MODIFIER_CODE_MEANING_PATH()).c_str(),
TemporoSpatialStringProperty::New(codeMeaning.c_str()));
}
// Add Atomic RegionSequence tags
auto atomicRegionSequence = segmentAttribute->getAnatomicRegionSequence();
if (atomicRegionSequence != nullptr)
{
OFString codeValue; // (0008,0100) Code Value
atomicRegionSequence->getCodeValue(codeValue);
label->SetProperty(
DICOMTagPathToPropertyName(DICOMSegmentationConstants::ANATOMIC_REGION_CODE_VALUE_PATH()).c_str(),
TemporoSpatialStringProperty::New(codeValue.c_str()));
OFString codeScheme; // (0008,0102) Coding Scheme Designator
atomicRegionSequence->getCodingSchemeDesignator(codeScheme);
label->SetProperty(
DICOMTagPathToPropertyName(DICOMSegmentationConstants::ANATOMIC_REGION_CODE_SCHEME_PATH()).c_str(),
TemporoSpatialStringProperty::New(codeScheme.c_str()));
OFString codeMeaning; // (0008,0104) Code Meaning
atomicRegionSequence->getCodeMeaning(codeMeaning);
label->SetProperty(
DICOMTagPathToPropertyName(DICOMSegmentationConstants::ANATOMIC_REGION_CODE_MEANING_PATH()).c_str(),
TemporoSpatialStringProperty::New(codeMeaning.c_str()));
}
}
DICOMSegmentationIO *DICOMSegmentationIO::IOClone() const { return new DICOMSegmentationIO(*this); }
} // namespace
#endif //__mitkDICOMSegmentationIO__cpp
diff --git a/Modules/Multilabel/autoload/IO/mitkLegacyLabelSetImageIO.cpp b/Modules/Multilabel/autoload/IO/mitkLegacyLabelSetImageIO.cpp
index 8c2a7ce107..4ca16f7ed5 100644
--- a/Modules/Multilabel/autoload/IO/mitkLegacyLabelSetImageIO.cpp
+++ b/Modules/Multilabel/autoload/IO/mitkLegacyLabelSetImageIO.cpp
@@ -1,273 +1,273 @@
/*============================================================================
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 __mitkLabelSetImageWriter__cpp
#define __mitkLabelSetImageWriter__cpp
#include "mitkLegacyLabelSetImageIO.h"
#include "mitkBasePropertySerializer.h"
#include "mitkMultilabelIOMimeTypes.h"
#include "mitkImageAccessByItk.h"
#include "mitkMultiLabelIOHelper.h"
#include "mitkLabelSetImageConverter.h"
#include <mitkLocaleSwitch.h>
#include <mitkArbitraryTimeGeometry.h>
#include <mitkIPropertyPersistence.h>
#include <mitkCoreServices.h>
#include <mitkItkImageIO.h>
#include <mitkUIDManipulator.h>
// itk
#include "itkImageFileReader.h"
#include "itkImageFileWriter.h"
#include "itkMetaDataDictionary.h"
#include "itkMetaDataObject.h"
#include "itkNrrdImageIO.h"
#include <tinyxml2.h>
namespace mitk
{
const constexpr char* const OPTION_NAME_MULTI_LAYER = "Multi layer handling";
const constexpr char* const OPTION_NAME_MULTI_LAYER_ADAPT = "Adapt label values";
const constexpr char* const OPTION_NAME_MULTI_LAYER_SPLIT = "Split layers";
LegacyLabelSetImageIO::LegacyLabelSetImageIO()
: AbstractFileReader(MitkMultilabelIOMimeTypes::LEGACYLABELSET_MIMETYPE(), "MITK LabelSetImage (legacy)")
{
this->InitializeDefaultMetaDataKeys();
AbstractFileReader::SetRanking(10);
IFileIO::Options options;
std::vector<std::string> multiLayerStrategy;
multiLayerStrategy.push_back(OPTION_NAME_MULTI_LAYER_ADAPT);
multiLayerStrategy.push_back(OPTION_NAME_MULTI_LAYER_SPLIT);
options[OPTION_NAME_MULTI_LAYER] = multiLayerStrategy;
this->SetDefaultOptions(options);
this->RegisterService();
}
IFileIO::ConfidenceLevel LegacyLabelSetImageIO::GetConfidenceLevel() const
{
if (AbstractFileReader::GetConfidenceLevel() == Unsupported)
return Unsupported;
const std::string fileName = this->GetLocalFileName();
itk::NrrdImageIO::Pointer io = itk::NrrdImageIO::New();
io->SetFileName(fileName);
io->ReadImageInformation();
itk::MetaDataDictionary imgMetaDataDictionary = io->GetMetaDataDictionary();
std::string value("");
itk::ExposeMetaData<std::string>(imgMetaDataDictionary, "modality", value);
if (value.compare("org.mitk.image.multilabel") == 0)
{
return Supported;
}
else
return Unsupported;
}
std::vector<mitk::LabelSetImage::LabelVectorType> ExtractLabelSetsFromMetaData(const itk::MetaDataDictionary& dictionary)
{
std::vector<mitk::LabelSetImage::LabelVectorType> result;
// get labels and add them as properties to the image
char keybuffer[256];
unsigned int numberOfLayers = MultiLabelIOHelper::GetIntByKey(dictionary, "layers");
std::string _xmlStr;
mitk::Label::Pointer label;
for (unsigned int layerIdx = 0; layerIdx < numberOfLayers; layerIdx++)
{
sprintf(keybuffer, "layer_%03u", layerIdx);
int numberOfLabels = MultiLabelIOHelper::GetIntByKey(dictionary, keybuffer);
mitk::LabelSetImage::LabelVectorType labelSet;
for (int labelIdx = 0; labelIdx < numberOfLabels; labelIdx++)
{
tinyxml2::XMLDocument doc;
sprintf(keybuffer, "label_%03u_%05d", layerIdx, labelIdx);
_xmlStr = MultiLabelIOHelper::GetStringByKey(dictionary, keybuffer);
doc.Parse(_xmlStr.c_str(), _xmlStr.size());
auto* labelElem = doc.FirstChildElement("Label");
if (labelElem == nullptr)
mitkThrow() << "Error parsing NRRD header for mitk::LabelSetImage IO";
label = mitk::MultiLabelIOHelper::LoadLabelFromXMLDocument(labelElem);
- if (label->GetValue() != mitk::LabelSetImage::UnlabeledValue)
+ if (label->GetValue() != mitk::LabelSetImage::UNLABELED_VALUE)
{
labelSet.push_back(label);
}
else
{
MITK_INFO << "Multi label image contains a label specification for unlabeled pixels. This legacy information is ignored.";
}
}
result.push_back(labelSet);
}
return result;
}
std::vector<BaseData::Pointer> LegacyLabelSetImageIO::DoRead()
{
itk::NrrdImageIO::Pointer nrrdImageIO = itk::NrrdImageIO::New();
std::vector<BaseData::Pointer> result;
auto rawimage = ItkImageIO::LoadRawMitkImageFromImageIO(nrrdImageIO, this->GetLocalFileName());
const itk::MetaDataDictionary& dictionary = nrrdImageIO->GetMetaDataDictionary();
std::vector<Image::Pointer> groupImages = { rawimage };
if (rawimage->GetChannelDescriptor().GetPixelType().GetPixelType() == itk::IOPixelEnum::VECTOR)
{
groupImages = SplitVectorImage(rawimage);
}
auto labelsets = ExtractLabelSetsFromMetaData(dictionary);
if (labelsets.size() != groupImages.size())
{
mitkThrow() << "Loaded data is in an invalid state. Number of extracted layer images and labels sets does not match. Found layer images: " << groupImages.size() << "; found labelsets: " << labelsets.size();
}
auto props = ItkImageIO::ExtractMetaDataAsPropertyList(nrrdImageIO->GetMetaDataDictionary(), this->GetMimeType()->GetName(), this->m_DefaultMetaDataKeys);
const Options userOptions = this->GetOptions();
const auto multiLayerStrategy = userOptions.find(OPTION_NAME_MULTI_LAYER)->second.ToString();
if (multiLayerStrategy == OPTION_NAME_MULTI_LAYER_SPLIT)
{ //just split layers in different multi label images
auto labelSetIterator = labelsets.begin();
for (auto image : groupImages)
{
auto output = ConvertImageToLabelSetImage(image);
output->ReplaceGroupLabels(0, *labelSetIterator);
//meta data handling
for (auto& [name, prop] : *(props->GetMap()))
{
output->SetProperty(name, prop->Clone()); //need to clone to avoid that all outputs pointing to the same prop instances.
}
// Handle UID
//Remark if we split the legacy label set into distinct layer images, the outputs should have new IDs. So we don't get the old one.
result.push_back(output.GetPointer());
labelSetIterator++;
}
}
else
{ //Avoid label id collision.
- LabelSetImage::LabelValueType maxValue = LabelSetImage::UnlabeledValue;
+ LabelSetImage::LabelValueType maxValue = LabelSetImage::UNLABELED_VALUE;
auto imageIterator = groupImages.begin();
std::vector<mitk::LabelSetImage::LabelVectorType> adaptedLabelSets;
for (auto labelset : labelsets)
{
const auto setValues = LabelSetImage::ExtractLabelValuesFromLabelVector(labelset);
//generate mapping table;
std::vector<std::pair<Label::PixelType, Label::PixelType> > labelMapping;
for (auto vIter = setValues.crbegin(); vIter != setValues.crend(); vIter++)
{ //have to use reverse loop because TransferLabelContent (used to adapt content in the same image; see below)
//would potentially corrupt otherwise the content due to "value collision between old values still present
//and already adapted values. By going from highest value to lowest, we avoid that.
- if (LabelSetImage::UnlabeledValue != *vIter)
+ if (LabelSetImage::UNLABELED_VALUE != *vIter)
labelMapping.push_back({*vIter, *vIter + maxValue});
}
- if (LabelSetImage::UnlabeledValue != maxValue)
+ if (LabelSetImage::UNLABELED_VALUE != maxValue)
{
//adapt labelset
auto mappedLabelSet = GenerateLabelSetWithMappedValues(LabelSetImage::ConvertLabelVectorConst(labelset), labelMapping);
adaptedLabelSets.emplace_back(mappedLabelSet);
//adapt image (it is an inplace operation. the image instance stays the same.
- TransferLabelContent(*imageIterator, *imageIterator, LabelSetImage::ConvertLabelVectorConst(mappedLabelSet), LabelSetImage::UnlabeledValue, LabelSetImage::UnlabeledValue,
+ TransferLabelContent(*imageIterator, *imageIterator, LabelSetImage::ConvertLabelVectorConst(mappedLabelSet), LabelSetImage::UNLABELED_VALUE, LabelSetImage::UNLABELED_VALUE,
false, labelMapping, MultiLabelSegmentation::MergeStyle::Replace, MultiLabelSegmentation::OverwriteStyle::IgnoreLocks);
}
else
{
adaptedLabelSets.emplace_back(labelset);
}
const auto maxFinding = std::max_element(setValues.begin(), setValues.end());
if (maxFinding != setValues.end())
{
const auto setMaxValue = *(maxFinding);
maxValue += setMaxValue;
}
imageIterator++;
}
auto output = ConvertImageVectorToLabelSetImage(groupImages, rawimage->GetTimeGeometry());
LabelSetImage::GroupIndexType id = 0;
for (auto labelset : adaptedLabelSets)
{
output->ReplaceGroupLabels(id, labelset);
id++;
}
//meta data handling
for (auto& [name, prop] : *(props->GetMap()))
{
output->SetProperty(name, prop->Clone()); //need to clone to avoid that all outputs pointing to the same prop instances.
}
// Handle UID
if (dictionary.HasKey(PROPERTY_KEY_UID))
{
itk::MetaDataObject<std::string>::ConstPointer uidData = dynamic_cast<const itk::MetaDataObject<std::string>*>(dictionary.Get(PROPERTY_KEY_UID));
if (uidData.IsNotNull())
{
mitk::UIDManipulator uidManipulator(output);
uidManipulator.SetUID(uidData->GetMetaDataObjectValue());
}
}
result.push_back(output.GetPointer());
}
MITK_INFO << "...finished!";
return result;
}
LegacyLabelSetImageIO *LegacyLabelSetImageIO::Clone() const { return new LegacyLabelSetImageIO(*this); }
void LegacyLabelSetImageIO::InitializeDefaultMetaDataKeys()
{
this->m_DefaultMetaDataKeys.push_back("NRRD.space");
this->m_DefaultMetaDataKeys.push_back("NRRD.kinds");
this->m_DefaultMetaDataKeys.push_back(PROPERTY_NAME_TIMEGEOMETRY_TYPE);
this->m_DefaultMetaDataKeys.push_back(PROPERTY_NAME_TIMEGEOMETRY_TIMEPOINTS);
this->m_DefaultMetaDataKeys.push_back("ITK.InputFilterName");
this->m_DefaultMetaDataKeys.push_back("label.");
this->m_DefaultMetaDataKeys.push_back("layer.");
this->m_DefaultMetaDataKeys.push_back("layers");
this->m_DefaultMetaDataKeys.push_back("modality");
this->m_DefaultMetaDataKeys.push_back("org.mitk.label.");
this->m_DefaultMetaDataKeys.push_back("MITK.IO.");
}
} // namespace
#endif //__mitkLabelSetImageWriter__cpp
diff --git a/Modules/Multilabel/mitkLabel.h b/Modules/Multilabel/mitkLabel.h
index f6b474deef..3a3b963f67 100644
--- a/Modules/Multilabel/mitkLabel.h
+++ b/Modules/Multilabel/mitkLabel.h
@@ -1,110 +1,113 @@
/*============================================================================
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 mitkLabel_h
#define mitkLabel_h
#include "MitkMultilabelExports.h"
#include <mitkColorProperty.h>
#include <mitkPropertyList.h>
#include <mitkPoint.h>
#include <mitkVector.h>
namespace mitk
{
//##
//##Documentation
//## @brief A data structure describing a label.
//## @ingroup Data
//##
class MITKMULTILABEL_EXPORT Label : public PropertyList
{
public:
mitkClassMacro(Label, mitk::PropertyList);
typedef unsigned short PixelType;
itkNewMacro(Self);
mitkNewMacro2Param(Self, PixelType, const std::string&);
/// The maximum value a label can get: Since the value is of type unsigned short MAX_LABEL_VALUE = 65535
static const PixelType MAX_LABEL_VALUE;
+ //** Value indicating pixels that are not labeled at all.*/
+ const static PixelType UNLABELED_VALUE = 0;
+
void SetLocked(bool locked);
bool GetLocked() const;
void SetVisible(bool visible);
bool GetVisible() const;
void SetOpacity(float opacity);
float GetOpacity() const;
void SetName(const std::string &name);
std::string GetName() const;
void SetCenterOfMassIndex(const mitk::Point3D ¢er);
mitk::Point3D GetCenterOfMassIndex() const;
void SetCenterOfMassCoordinates(const mitk::Point3D ¢er);
mitk::Point3D GetCenterOfMassCoordinates() const;
void SetColor(const mitk::Color &);
const mitk::Color &GetColor() const;
void SetValue(PixelType pixelValue);
PixelType GetValue() const;
void SetLayer(unsigned int layer);
unsigned int GetLayer() const;
void SetProperty(const std::string &propertyKey, BaseProperty *property, const std::string &contextName = "", bool fallBackOnDefaultContext = false) override;
using itk::Object::Modified;
void Modified() { Superclass::Modified(); }
Label();
Label(PixelType value, const std::string& name);
~Label() override;
protected:
void PrintSelf(std::ostream &os, itk::Indent indent) const override;
Label(const Label &other);
private:
itk::LightObject::Pointer InternalClone() const override;
};
using LabelVector = std::vector<Label::Pointer>;
using ConstLabelVector = std::vector<Label::ConstPointer>;
/**
* @brief Equal A function comparing two labels for beeing equal in data
*
* @ingroup MITKTestingAPI
*
* Following aspects are tested for equality:
* - Lebel equality via Equal-PropetyList
*
* @param rightHandSide An image to be compared
* @param leftHandSide An image to be compared
* @param eps Tolarence for comparison. You can use mitk::eps in most cases.
* @param verbose Flag indicating if the user wants detailed console output or not.
* @return true, if all subsequent comparisons are true, false otherwise
*/
MITKMULTILABEL_EXPORT bool Equal(const mitk::Label &leftHandSide,
const mitk::Label &rightHandSide,
ScalarType eps,
bool verbose);
} // namespace mitk
#endif
diff --git a/Modules/Multilabel/mitkLabelSetImage.cpp b/Modules/Multilabel/mitkLabelSetImage.cpp
index 238b20e504..8c4ab330b5 100644
--- a/Modules/Multilabel/mitkLabelSetImage.cpp
+++ b/Modules/Multilabel/mitkLabelSetImage.cpp
@@ -1,1677 +1,1677 @@
/*============================================================================
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 "mitkLabelSetImage.h"
#include "mitkImageAccessByItk.h"
#include "mitkImageCast.h"
#include "mitkImagePixelReadAccessor.h"
#include "mitkImagePixelWriteAccessor.h"
#include "mitkInteractionConst.h"
#include "mitkLookupTableProperty.h"
#include "mitkPadImageFilter.h"
#include "mitkRenderingManager.h"
#include "mitkDICOMSegmentationPropertyHelper.h"
#include "mitkDICOMQIPropertyHelper.h"
#include <vtkCell.h>
#include <vtkTransform.h>
#include <vtkTransformPolyDataFilter.h>
#include <itkImageRegionIterator.h>
#include <itkQuadEdgeMesh.h>
#include <itkTriangleMeshToBinaryImageFilter.h>
#include <itkLabelGeometryImageFilter.h>
#include <itkCommand.h>
#include <itkBinaryFunctorImageFilter.h>
namespace mitk
{
template <typename ImageType>
void ClearBufferProcessing(ImageType* itkImage)
{
itkImage->FillBuffer(0);
}
void ClearImageBuffer(mitk::Image* image)
{
if (image->GetDimension() == 4)
{ //remark: this extra branch was added, because LabelSetImage instances can be
//dynamic (4D), but AccessByItk by support only supports 2D and 3D.
//The option to change the CMake default dimensions for AccessByItk was
//dropped (for details see discussion in T28756)
AccessFixedDimensionByItk(image, ClearBufferProcessing, 4);
}
else
{
AccessByItk(image, ClearBufferProcessing);
}
}
}
mitk::LabelSetImage::LabelSetImage()
: mitk::Image(), m_UnlabeledLabelLock(false), m_ActiveLayer(0), m_activeLayerInvalid(false), m_ActiveLabelValue(0)
{
m_LookupTable = mitk::LookupTable::New();
m_LookupTable->SetType(mitk::LookupTable::MULTILABEL);
// Add some DICOM Tags as properties to segmentation image
DICOMSegmentationPropertyHelper::DeriveDICOMSegmentationProperties(this);
}
mitk::LabelSetImage::LabelSetImage(const mitk::LabelSetImage &other)
: Image(other),
m_UnlabeledLabelLock(other.m_UnlabeledLabelLock),
m_ActiveLayer(other.GetActiveLayer()),
m_activeLayerInvalid(false),
m_LookupTable(other.m_LookupTable->Clone()),
m_ActiveLabelValue(other.m_ActiveLabelValue)
{
GroupIndexType i = 0;
for (auto groupImage : other.m_LayerContainer)
{
this->AddLayer(groupImage->Clone(), other.GetConstLabelsByValue(other.GetLabelValuesByGroup(i)));
i++;
}
m_Groups = other.m_Groups;
// Add some DICOM Tags as properties to segmentation image
DICOMSegmentationPropertyHelper::DeriveDICOMSegmentationProperties(this);
}
void mitk::LabelSetImage::Initialize(const mitk::Image *other)
{
mitk::PixelType pixelType(mitk::MakeScalarPixelType<LabelSetImage::PixelType>());
if (other->GetDimension() == 2)
{
const unsigned int dimensions[] = {other->GetDimension(0), other->GetDimension(1), 1};
Superclass::Initialize(pixelType, 3, dimensions);
}
else
{
Superclass::Initialize(pixelType, other->GetDimension(), other->GetDimensions());
}
auto originalGeometry = other->GetTimeGeometry()->Clone();
this->SetTimeGeometry(originalGeometry);
// initialize image memory to zero
ClearImageBuffer(this);
// Transfer some general DICOM properties from the source image to derived image (e.g. Patient information,...)
DICOMQIPropertyHelper::DeriveDICOMSourceProperties(other, this);
// Add a inital LabelSet ans corresponding image data to the stack
if (this->GetNumberOfLayers() == 0)
{
AddLayer();
}
}
mitk::LabelSetImage::~LabelSetImage()
{
for (auto [value, label] : m_LabelMap)
{
this->ReleaseLabel(label);
}
m_LabelMap.clear();
}
mitk::Image *mitk::LabelSetImage::GetLayerImage(unsigned int layer)
{
return m_LayerContainer[layer];
}
const mitk::Image *mitk::LabelSetImage::GetLayerImage(unsigned int layer) const
{
return m_LayerContainer[layer];
}
unsigned int mitk::LabelSetImage::GetActiveLayer() const
{
if (m_LayerContainer.size() == 0) mitkThrow() << "Cannot return active layer index. No layer is available.";
return m_ActiveLayer;
}
unsigned int mitk::LabelSetImage::GetNumberOfLayers() const
{
return m_LayerContainer.size();
}
void mitk::LabelSetImage::RemoveGroup(GroupIndexType indexToDelete)
{
if (!this->ExistGroup(indexToDelete)) mitkThrow() << "Cannot remove group. Group does not exist. Invalid group index: "<<indexToDelete;
const auto activeIndex = GetActiveLayer();
auto newActiveIndex = activeIndex;
auto newActiveIndexBeforeDeletion = activeIndex;
//determin new active group index (afte the group will be removed);
if (indexToDelete < activeIndex)
{ //lower the index because position in m_LayerContainer etc has changed
newActiveIndex = activeIndex-1;
}
else if (indexToDelete == activeIndex)
{
if (this->GetNumberOfLayers() == 1)
{ //last layer is about to be deleted
newActiveIndex = 0;
}
else
{
//we have to add/substract one more because we have not removed the layer yet, thus the group count is to 1 high.
newActiveIndex = indexToDelete+1 < GetNumberOfLayers() ? indexToDelete : GetNumberOfLayers() - 2;
newActiveIndexBeforeDeletion = indexToDelete + 1 < GetNumberOfLayers() ? indexToDelete+1 : indexToDelete -1;
}
}
if (activeIndex == indexToDelete)
{
// we are deleting the active layer, it should not be copied back into the vector
m_activeLayerInvalid = true;
//copy the image content of the upcoming new active layer;
SetActiveLayer(newActiveIndexBeforeDeletion);
}
auto relevantLabels = m_GroupToLabelMap[indexToDelete];
// remove labels of group
for (auto labelValue : relevantLabels)
{
auto label = m_LabelMap[labelValue];
this->ReleaseLabel(label);
m_LabelToGroupMap.erase(labelValue);
m_LabelMap.erase(labelValue);
this->m_LabelRemovedMessage.Send(labelValue);
}
// remove the group entries in the maps and the image.
m_Groups.erase(m_Groups.begin() + indexToDelete);
m_GroupToLabelMap.erase(m_GroupToLabelMap.begin() + indexToDelete);
m_LayerContainer.erase(m_LayerContainer.begin() + indexToDelete);
//update old indeces in m_GroupToLabelMap to new layer indices
for (auto& element : m_LabelToGroupMap)
{
if (element.second > indexToDelete) element.second = element.second -1;
}
//correct active layer index
m_ActiveLayer = newActiveIndex;
this->m_LabelsChangedMessage.Send(relevantLabels);
this->m_GroupRemovedMessage.Send(indexToDelete);
this->Modified();
}
mitk::LabelSetImage::LabelValueVectorType mitk::LabelSetImage::ExtractLabelValuesFromLabelVector(const LabelVectorType& labels)
{
LabelValueVectorType result;
for (auto label : labels)
{
result.emplace_back(label->GetValue());
}
return result;
}
mitk::LabelSetImage::LabelValueVectorType mitk::LabelSetImage::ExtractLabelValuesFromLabelVector(const ConstLabelVectorType& labels)
{
LabelValueVectorType result;
for (auto label : labels)
{
result.emplace_back(label->GetValue());
}
return result;
}
mitk::LabelSetImage::ConstLabelVectorType mitk::LabelSetImage::ConvertLabelVectorConst(const LabelVectorType& labels)
{
ConstLabelVectorType result(labels.begin(), labels.end());
return result;
};
const mitk::LabelSetImage::LabelValueVectorType mitk::LabelSetImage::GetAllLabelValues() const
{
LabelValueVectorType result;
for (auto [value, label] : m_LabelMap)
{
result.emplace_back(value);
}
return result;
}
mitk::LabelSetImage::LabelValueVectorType mitk::LabelSetImage::GetUsedLabelValues() const
{
- LabelValueVectorType result = { UnlabeledValue };
+ LabelValueVectorType result = { UNLABELED_VALUE };
for (auto [value, label] : m_LabelMap)
{
result.emplace_back(value);
}
return result;
}
mitk::LabelSetImage::GroupIndexType mitk::LabelSetImage::AddLayer(ConstLabelVector labels)
{
mitk::Image::Pointer newImage = mitk::Image::New();
newImage->Initialize(this->GetPixelType(),
this->GetDimension(),
this->GetDimensions(),
this->GetImageDescriptor()->GetNumberOfChannels());
newImage->SetTimeGeometry(this->GetTimeGeometry()->Clone());
ClearImageBuffer(newImage);
return this->AddLayer(newImage, labels);
}
mitk::LabelSetImage::GroupIndexType mitk::LabelSetImage::AddLayer(mitk::Image::Pointer layerImage, ConstLabelVector labels)
{
GroupIndexType newGroupID = m_Groups.size();
// push a new working image for the new layer
m_LayerContainer.push_back(layerImage);
m_Groups.push_back("");
m_GroupToLabelMap.push_back({});
for (auto label : labels)
{
if (m_LabelMap.end() != m_LabelMap.find(label->GetValue()))
{
mitkThrow() << "Cannot add layer. Labels that should be added with layer use at least one label value that is already in use. Conflicted label value: " << label->GetValue();
}
auto labelClone = label->Clone();
DICOMSegmentationPropertyHelper::SetDICOMSegmentProperties(labelClone);
this->AddLabelToMap(labelClone->GetValue(), labelClone, newGroupID);
this->RegisterLabel(labelClone);
}
this->Modified();
this->m_GroupAddedMessage.Send(newGroupID);
return newGroupID;
}
void mitk::LabelSetImage::ReplaceGroupLabels(const GroupIndexType groupID, const ConstLabelVectorType& labelSet)
{
if (m_LayerContainer.size() <= groupID)
{
mitkThrow() << "Trying to replace labels of non-exising group. Invalid group id: "<<groupID;
}
//remove old group labels
auto oldLabels = this->m_GroupToLabelMap[groupID];
for (auto labelID : oldLabels)
{
this->RemoveLabelFromMap(labelID);
this->m_LabelRemovedMessage.Send(labelID);
}
this->m_LabelsChangedMessage.Send(oldLabels);
this->m_GroupModifiedMessage.Send(groupID);
//add new labels to group
for (auto label : labelSet)
{
this->AddLabel(label->Clone(), groupID, true, false);
}
}
void mitk::LabelSetImage::ReplaceGroupLabels(const GroupIndexType groupID, const LabelVectorType& labelSet)
{
return ReplaceGroupLabels(groupID, ConvertLabelVectorConst(labelSet));
}
mitk::Image* mitk::LabelSetImage::GetGroupImage(GroupIndexType groupID)
{
if (!this->ExistGroup(groupID)) mitkThrow() << "Error, cannot return group image. Group ID is invalid. Invalid ID: " << groupID;
return groupID == this->GetActiveLayer() ? this : m_LayerContainer[groupID];
}
const mitk::Image* mitk::LabelSetImage::GetGroupImage(GroupIndexType groupID) const
{
if (!this->ExistGroup(groupID)) mitkThrow() << "Error, cannot return group image. Group ID is invalid. Invalid ID: " << groupID;
return groupID == this->GetActiveLayer() ? this : m_LayerContainer[groupID].GetPointer();
}
void mitk::LabelSetImage::SetActiveLayer(unsigned int layer)
{
try
{
if (4 == this->GetDimension())
{
if ((layer != GetActiveLayer() || m_activeLayerInvalid) && (layer < this->GetNumberOfLayers()))
{
BeforeChangeLayerEvent.Send();
if (m_activeLayerInvalid)
{
// We should not write the invalid layer back to the vector
m_activeLayerInvalid = false;
}
else
{
AccessFixedDimensionByItk_n(this, ImageToLayerContainerProcessing, 4, (GetActiveLayer()));
}
m_ActiveLayer = layer;
AccessFixedDimensionByItk_n(this, LayerContainerToImageProcessing, 4, (GetActiveLayer()));
AfterChangeLayerEvent.Send();
}
}
else
{
if ((layer != GetActiveLayer() || m_activeLayerInvalid) && (layer < this->GetNumberOfLayers()))
{
BeforeChangeLayerEvent.Send();
if (m_activeLayerInvalid)
{
// We should not write the invalid layer back to the vector
m_activeLayerInvalid = false;
}
else
{
AccessByItk_1(this, ImageToLayerContainerProcessing, GetActiveLayer());
}
m_ActiveLayer = layer;
AccessByItk_1(this, LayerContainerToImageProcessing, GetActiveLayer());
AfterChangeLayerEvent.Send();
}
}
}
catch (itk::ExceptionObject &e)
{
mitkThrow() << e.GetDescription();
}
this->Modified();
}
void mitk::LabelSetImage::SetActiveLabel(LabelValueType label)
{
m_ActiveLabelValue = label;
- if (label != UnlabeledValue)
+ if (label != UNLABELED_VALUE)
{
auto groupID = this->GetGroupIndexOfLabel(label);
if (groupID!=this->GetActiveLayer()) this->SetActiveLayer(groupID);
}
Modified();
}
void mitk::LabelSetImage::ClearBuffer()
{
try
{
ClearImageBuffer(this);
this->Modified();
}
catch (itk::ExceptionObject &e)
{
mitkThrow() << e.GetDescription();
}
}
bool mitk::LabelSetImage::ExistLabelSet(unsigned int layer) const
{
return layer < m_LayerContainer.size();
}
void mitk::LabelSetImage::MergeLabel(PixelType pixelValue, PixelType sourcePixelValue, unsigned int layer)
{
try
{
AccessByItk_2(this, MergeLabelProcessing, pixelValue, sourcePixelValue);
}
catch (itk::ExceptionObject &e)
{
mitkThrow() << e.GetDescription();
}
this->SetActiveLabel(pixelValue);
this->m_LabelModifiedMessage.Send(sourcePixelValue);
this->m_LabelModifiedMessage.Send(pixelValue);
this->m_LabelsChangedMessage.Send({ sourcePixelValue, pixelValue });
Modified();
}
void mitk::LabelSetImage::MergeLabels(PixelType pixelValue, const std::vector<PixelType>& vectorOfSourcePixelValues, unsigned int layer)
{
try
{
for (unsigned int idx = 0; idx < vectorOfSourcePixelValues.size(); idx++)
{
AccessByItk_2(this, MergeLabelProcessing, pixelValue, vectorOfSourcePixelValues[idx]);
this->m_LabelModifiedMessage.Send(vectorOfSourcePixelValues[idx]);
}
}
catch (itk::ExceptionObject &e)
{
mitkThrow() << e.GetDescription();
}
this->SetActiveLabel(pixelValue);
this->m_LabelModifiedMessage.Send(pixelValue);
auto modifiedValues = vectorOfSourcePixelValues;
modifiedValues.push_back(pixelValue);
this->m_LabelsChangedMessage.Send(modifiedValues);
Modified();
}
void mitk::LabelSetImage::RemoveLabel(LabelValueType pixelValue)
{
if (m_LabelMap.find(pixelValue) == m_LabelMap.end()) return;
auto groupID = this->GetGroupIndexOfLabel(pixelValue);
//first erase the pixel content (also triggers a LabelModified event)
this->EraseLabel(pixelValue);
this->RemoveLabelFromMap(pixelValue);
if (m_ActiveLabelValue == pixelValue)
{
this->SetActiveLabel(0);
}
this->m_LabelRemovedMessage.Send(pixelValue);
this->m_LabelsChangedMessage.Send({ pixelValue });
this->m_GroupModifiedMessage.Send(groupID);
}
void mitk::LabelSetImage::RemoveLabelFromMap(LabelValueType pixelValue)
{
if (m_LabelMap.find(pixelValue) == m_LabelMap.end()) mitkThrow()<<"Invalid state of of instance. RemoveLabelFromMap was called for unkown label id. invalid label id: "<<pixelValue;
auto groupID = this->GetGroupIndexOfLabel(pixelValue);
this->ReleaseLabel(m_LabelMap[pixelValue]);
//now remove the label entry itself
m_LabelMap.erase(pixelValue);
m_LabelToGroupMap.erase(pixelValue);
auto labelsInGroup = m_GroupToLabelMap[groupID];
labelsInGroup.erase(std::remove(labelsInGroup.begin(), labelsInGroup.end(), pixelValue), labelsInGroup.end());
m_GroupToLabelMap[groupID] = labelsInGroup;
}
void mitk::LabelSetImage::RemoveLabels(const LabelValueVectorType& vectorOfLabelPixelValues)
{
for (const auto labelValue : vectorOfLabelPixelValues)
{
this->RemoveLabel(labelValue);
}
this->m_LabelsChangedMessage.Send(vectorOfLabelPixelValues);
}
void mitk::LabelSetImage::EraseLabel(PixelType pixelValue)
{
try
{
auto groupID = this->GetGroupIndexOfLabel(pixelValue);
mitk::Image* groupImage = this->GetActiveLayer() != groupID
? this->GetLayerImage(groupID)
: this;
if (4 == this->GetDimension())
{
AccessFixedDimensionByItk_1(groupImage, EraseLabelProcessing, 4, pixelValue);
}
else
{
AccessByItk_1(groupImage, EraseLabelProcessing, pixelValue);
}
}
catch (const itk::ExceptionObject& e)
{
mitkThrow() << e.GetDescription();
}
this->m_LabelModifiedMessage.Send(pixelValue);
this->m_LabelsChangedMessage.Send({ pixelValue });
Modified();
}
void mitk::LabelSetImage::EraseLabels(const std::vector<PixelType>& VectorOfLabelPixelValues)
{
for (unsigned int idx = 0; idx < VectorOfLabelPixelValues.size(); idx++)
{
this->EraseLabel(VectorOfLabelPixelValues[idx]);
}
}
mitk::LabelSetImage::LabelValueType mitk::LabelSetImage::GetUnusedLabelValue() const
{
auto usedValues = this->GetUsedLabelValues();
return usedValues.back() + 1;
}
mitk::Label* mitk::LabelSetImage::AddLabel(mitk::Label* label, GroupIndexType groupID, bool addAsClone, bool correctLabelValue)
{
unsigned int max_size = mitk::Label::MAX_LABEL_VALUE + 1;
if (m_LayerContainer.size() >= max_size)
return nullptr;
mitk::Label::Pointer newLabel = addAsClone ? label->Clone() : Label::Pointer(label);
auto pixelValue = newLabel->GetValue();
auto usedValues = this->GetUsedLabelValues();
auto finding = std::find(usedValues.begin(), usedValues.end(), pixelValue);
if (!usedValues.empty() && usedValues.end() != finding)
{
if (correctLabelValue)
{
pixelValue = this->GetUnusedLabelValue();
newLabel->SetValue(pixelValue);
}
else
{
mitkThrow() << "Cannot add label due to conflicting label value that already exists in the MultiLabelSegmentation. Conflicting label value: " << pixelValue;
}
}
// add DICOM information of the label
DICOMSegmentationPropertyHelper::SetDICOMSegmentProperties(newLabel);
this->AddLabelToMap(pixelValue, newLabel, groupID);
this->RegisterLabel(newLabel);
m_LabelAddedMessage.Send(newLabel->GetValue());
m_ActiveLabelValue = newLabel->GetValue();
this->Modified();
return newLabel;
}
mitk::Label* mitk::LabelSetImage::AddLabel(const std::string& name, const mitk::Color& color, GroupIndexType groupID)
{
mitk::Label::Pointer newLabel = mitk::Label::New();
newLabel->SetName(name);
newLabel->SetColor(color);
return AddLabel(newLabel,groupID,false);
}
void mitk::LabelSetImage::RenameLabel(PixelType pixelValue, const std::string& name, const mitk::Color& color)
{
mitk::Label* label = GetLabel(pixelValue);
label->SetName(name);
label->SetColor(color);
this->UpdateLookupTable(pixelValue);
// change DICOM information of the label
DICOMSegmentationPropertyHelper::SetDICOMSegmentProperties(label);
}
mitk::Label *mitk::LabelSetImage::GetActiveLabel()
{
- if (m_ActiveLabelValue == UnlabeledValue) return nullptr;
+ if (m_ActiveLabelValue == UNLABELED_VALUE) return nullptr;
auto finding = m_LabelMap.find(m_ActiveLabelValue);
return finding == m_LabelMap.end() ? nullptr : finding->second;
}
const mitk::Label* mitk::LabelSetImage::GetActiveLabel() const
{
- if (m_ActiveLabelValue == UnlabeledValue) return nullptr;
+ if (m_ActiveLabelValue == UNLABELED_VALUE) return nullptr;
auto finding = m_LabelMap.find(m_ActiveLabelValue);
return finding == m_LabelMap.end() ? nullptr : finding->second;
}
void mitk::LabelSetImage::UpdateCenterOfMass(PixelType pixelValue)
{
this->UpdateCenterOfMass(pixelValue, this->GetGroupIndexOfLabel(pixelValue));
}
void mitk::LabelSetImage::SetLookupTable(mitk::LookupTable* lut)
{
m_LookupTable = lut;
this->Modified();
}
void mitk::LabelSetImage::UpdateLookupTable(PixelType pixelValue)
{
const mitk::Color& color = this->GetLabel(pixelValue)->GetColor();
double rgba[4];
m_LookupTable->GetTableValue(static_cast<int>(pixelValue), rgba);
rgba[0] = color.GetRed();
rgba[1] = color.GetGreen();
rgba[2] = color.GetBlue();
if (GetLabel(pixelValue)->GetVisible())
rgba[3] = GetLabel(pixelValue)->GetOpacity();
else
rgba[3] = 0.0;
m_LookupTable->SetTableValue(static_cast<int>(pixelValue), rgba);
}
void mitk::LabelSetImage::UpdateCenterOfMass(PixelType pixelValue, unsigned int layer)
{
if (4 == this->GetDimension())
{
AccessFixedDimensionByItk_1(this, CalculateCenterOfMassProcessing, 4, pixelValue);
}
else
{
AccessByItk_1(this, CalculateCenterOfMassProcessing, pixelValue);
}
}
unsigned int mitk::LabelSetImage::GetNumberOfLabels(unsigned int layer) const
{
return m_GroupToLabelMap[layer].size();
}
unsigned int mitk::LabelSetImage::GetTotalNumberOfLabels() const
{
return m_LabelMap.size();
}
void mitk::LabelSetImage::MaskStamp(mitk::Image *mask, bool forceOverwrite)
{
try
{
mitk::PadImageFilter::Pointer padImageFilter = mitk::PadImageFilter::New();
padImageFilter->SetInput(0, mask);
padImageFilter->SetInput(1, this);
padImageFilter->SetPadConstant(0);
padImageFilter->SetBinaryFilter(false);
padImageFilter->SetLowerThreshold(0);
padImageFilter->SetUpperThreshold(1);
padImageFilter->Update();
mitk::Image::Pointer paddedMask = padImageFilter->GetOutput();
if (paddedMask.IsNull())
return;
AccessByItk_2(this, MaskStampProcessing, paddedMask, forceOverwrite);
}
catch (...)
{
mitkThrow() << "Could not stamp the provided mask on the selected label.";
}
}
mitk::Image::Pointer mitk::LabelSetImage::CreateLabelMask(PixelType index)
{
if (!this->ExistLabel(index)) mitkThrow() << "Error, cannot return label mask. Label ID is invalid. Invalid ID: " << index;
auto mask = mitk::Image::New();
// mask->Initialize(this) does not work here if this label set image has a single slice,
// since the mask would be automatically flattened to a 2-d image, whereas we expect the
// original dimension of this label set image. Hence, initialize the mask more explicitly:
mask->Initialize(this->GetPixelType(), this->GetDimension(), this->GetDimensions());
mask->SetTimeGeometry(this->GetTimeGeometry()->Clone());
ClearImageBuffer(mask);
const auto groupID = this->GetGroupIndexOfLabel(index);
auto destinationLabel = this->GetLabel(index)->Clone();
destinationLabel->SetValue(1);
TransferLabelContent(this->GetGroupImage(groupID), mask.GetPointer(),
{destinationLabel},
- LabelSetImage::UnlabeledValue, LabelSetImage::UnlabeledValue, false,
+ LabelSetImage::UNLABELED_VALUE, LabelSetImage::UNLABELED_VALUE, false,
{ { index, destinationLabel->GetValue()}}, MultiLabelSegmentation::MergeStyle::Replace, MultiLabelSegmentation::OverwriteStyle::IgnoreLocks);
return mask;
}
void mitk::LabelSetImage::InitializeByLabeledImage(mitk::Image::Pointer image)
{
if (image.IsNull() || image->IsEmpty() || !image->IsInitialized())
mitkThrow() << "Invalid labeled image.";
try
{
this->Initialize(image);
unsigned int byteSize = sizeof(LabelSetImage::PixelType);
for (unsigned int dim = 0; dim < image->GetDimension(); ++dim)
{
byteSize *= image->GetDimension(dim);
}
mitk::ImageWriteAccessor *accessor = new mitk::ImageWriteAccessor(static_cast<mitk::Image *>(this));
memset(accessor->GetData(), 0, byteSize);
delete accessor;
auto geometry = image->GetTimeGeometry()->Clone();
this->SetTimeGeometry(geometry);
if (image->GetDimension() == 3)
{
AccessTwoImagesFixedDimensionByItk(this, image, InitializeByLabeledImageProcessing, 3);
}
else if (image->GetDimension() == 4)
{
AccessTwoImagesFixedDimensionByItk(this, image, InitializeByLabeledImageProcessing, 4);
}
else
{
mitkThrow() << image->GetDimension() << "-dimensional label set images not yet supported";
}
}
catch (Exception e)
{
mitkReThrow(e) << "Could not intialize by provided labeled image.";
}
catch (...)
{
mitkThrow() << "Could not intialize by provided labeled image due to unkown error.";
}
this->Modified();
}
template <typename LabelSetImageType, typename ImageType>
void mitk::LabelSetImage::InitializeByLabeledImageProcessing(LabelSetImageType *labelSetImage, ImageType *image)
{
typedef itk::ImageRegionConstIteratorWithIndex<ImageType> SourceIteratorType;
typedef itk::ImageRegionIterator<LabelSetImageType> TargetIteratorType;
TargetIteratorType targetIter(labelSetImage, labelSetImage->GetRequestedRegion());
targetIter.GoToBegin();
SourceIteratorType sourceIter(image, image->GetRequestedRegion());
sourceIter.GoToBegin();
while (!sourceIter.IsAtEnd())
{
const auto originalSourceValue = sourceIter.Get();
const auto sourceValue = static_cast<PixelType>(originalSourceValue);
if (originalSourceValue > mitk::Label::MAX_LABEL_VALUE)
{
mitkThrow() << "Cannot initialize MultiLabelSegmentation by image. Image contains a pixel value that exceeds the label value range. Invalid pixel value:" << originalSourceValue;
}
targetIter.Set(sourceValue);
- if (LabelSetImage::UnlabeledValue!=sourceValue && !this->ExistLabel(sourceValue))
+ if (LabelSetImage::UNLABELED_VALUE!=sourceValue && !this->ExistLabel(sourceValue))
{
if (this->GetTotalNumberOfLabels() >= mitk::Label::MAX_LABEL_VALUE)
{
mitkThrow() << "Cannot initialize MultiLabelSegmentation by image. Image contains to many labels.";
}
std::stringstream name;
name << "object-" << sourceValue;
double rgba[4];
this->GetLookupTable()->GetTableValue(sourceValue, rgba);
mitk::Color color;
color.SetRed(rgba[0]);
color.SetGreen(rgba[1]);
color.SetBlue(rgba[2]);
auto label = mitk::Label::New();
label->SetName(name.str().c_str());
label->SetColor(color);
label->SetOpacity(rgba[3]);
label->SetValue(sourceValue);
this->AddLabel(label,0,false);
}
++sourceIter;
++targetIter;
}
}
template <typename ImageType>
void mitk::LabelSetImage::MaskStampProcessing(ImageType *itkImage, mitk::Image *mask, bool forceOverwrite)
{
typename ImageType::Pointer itkMask;
mitk::CastToItkImage(mask, itkMask);
typedef itk::ImageRegionConstIterator<ImageType> SourceIteratorType;
typedef itk::ImageRegionIterator<ImageType> TargetIteratorType;
SourceIteratorType sourceIter(itkMask, itkMask->GetLargestPossibleRegion());
sourceIter.GoToBegin();
TargetIteratorType targetIter(itkImage, itkImage->GetLargestPossibleRegion());
targetIter.GoToBegin();
const auto activeLabel = this->GetActiveLabel()->GetValue();
while (!sourceIter.IsAtEnd())
{
PixelType sourceValue = sourceIter.Get();
PixelType targetValue = targetIter.Get();
- if ((sourceValue != UnlabeledValue) &&
+ if ((sourceValue != UNLABELED_VALUE) &&
(forceOverwrite || !this->IsLabelLocked(targetValue))) // skip unlabeled pixels and locked labels
{
targetIter.Set(activeLabel);
}
++sourceIter;
++targetIter;
}
this->Modified();
}
template <typename ImageType>
void mitk::LabelSetImage::CalculateCenterOfMassProcessing(ImageType *itkImage, LabelValueType pixelValue)
{
if (ImageType::GetImageDimension() != 3)
{
return;
}
auto labelGeometryFilter = itk::LabelGeometryImageFilter<ImageType>::New();
labelGeometryFilter->SetInput(itkImage);
labelGeometryFilter->Update();
auto centroid = labelGeometryFilter->GetCentroid(pixelValue);
mitk::Point3D pos;
pos[0] = centroid[0];
pos[1] = centroid[1];
pos[2] = centroid[2];
this->GetLabel(pixelValue)->SetCenterOfMassIndex(pos);
this->GetSlicedGeometry()->IndexToWorld(pos, pos);
this->GetLabel(pixelValue)->SetCenterOfMassCoordinates(pos);
}
template <typename TPixel, unsigned int VImageDimension>
void mitk::LabelSetImage::LayerContainerToImageProcessing(itk::Image<TPixel, VImageDimension> *target,
unsigned int layer)
{
typedef itk::Image<TPixel, VImageDimension> ImageType;
typename ImageType::Pointer itkSource;
// mitk::CastToItkImage(m_LayerContainer[layer], itkSource);
itkSource = ImageToItkImage<TPixel, VImageDimension>(m_LayerContainer[layer]);
typedef itk::ImageRegionConstIterator<ImageType> SourceIteratorType;
typedef itk::ImageRegionIterator<ImageType> TargetIteratorType;
SourceIteratorType sourceIter(itkSource, itkSource->GetLargestPossibleRegion());
sourceIter.GoToBegin();
TargetIteratorType targetIter(target, target->GetLargestPossibleRegion());
targetIter.GoToBegin();
while (!sourceIter.IsAtEnd())
{
targetIter.Set(sourceIter.Get());
++sourceIter;
++targetIter;
}
}
template <typename TPixel, unsigned int VImageDimension>
void mitk::LabelSetImage::ImageToLayerContainerProcessing(itk::Image<TPixel, VImageDimension> *source,
unsigned int layer) const
{
typedef itk::Image<TPixel, VImageDimension> ImageType;
typename ImageType::Pointer itkTarget;
// mitk::CastToItkImage(m_LayerContainer[layer], itkTarget);
itkTarget = ImageToItkImage<TPixel, VImageDimension>(m_LayerContainer[layer]);
typedef itk::ImageRegionConstIterator<ImageType> SourceIteratorType;
typedef itk::ImageRegionIterator<ImageType> TargetIteratorType;
SourceIteratorType sourceIter(source, source->GetLargestPossibleRegion());
sourceIter.GoToBegin();
TargetIteratorType targetIter(itkTarget, itkTarget->GetLargestPossibleRegion());
targetIter.GoToBegin();
while (!sourceIter.IsAtEnd())
{
targetIter.Set(sourceIter.Get());
++sourceIter;
++targetIter;
}
}
template <typename ImageType>
void mitk::LabelSetImage::EraseLabelProcessing(ImageType *itkImage, PixelType pixelValue)
{
typedef itk::ImageRegionIterator<ImageType> IteratorType;
IteratorType iter(itkImage, itkImage->GetLargestPossibleRegion());
iter.GoToBegin();
while (!iter.IsAtEnd())
{
PixelType value = iter.Get();
if (value == pixelValue)
{
iter.Set(0);
}
++iter;
}
}
template <typename ImageType>
void mitk::LabelSetImage::MergeLabelProcessing(ImageType *itkImage, PixelType pixelValue, PixelType index)
{
typedef itk::ImageRegionIterator<ImageType> IteratorType;
IteratorType iter(itkImage, itkImage->GetLargestPossibleRegion());
iter.GoToBegin();
while (!iter.IsAtEnd())
{
if (iter.Get() == index)
{
iter.Set(pixelValue);
}
++iter;
}
}
void mitk::LabelSetImage::AddLabelToMap(LabelValueType labelValue, mitk::Label* label, GroupIndexType groupID)
{
if (m_LabelMap.find(labelValue)!=m_LabelMap.end())
mitkThrow() << "Segmentation is in an invalid state: Label value collision. A label was added with a LabelValue already in use. LabelValue: " << labelValue;
if (!this->ExistGroup(groupID))
mitkThrow() << "Cannot add label. Defined group is unkown. Invalid group index: " << groupID;
m_LabelMap[labelValue] = label;
m_LabelToGroupMap[labelValue] = groupID;
auto groupFinding = std::find(m_GroupToLabelMap[groupID].begin(), m_GroupToLabelMap[groupID].end(), labelValue);
if (groupFinding == m_GroupToLabelMap[groupID].end())
{
m_GroupToLabelMap[groupID].push_back(labelValue);
}
}
void mitk::LabelSetImage::RegisterLabel(mitk::Label* label)
{
UpdateLookupTable(label->GetValue());
auto command = itk::MemberCommand<LabelSetImage>::New();
command->SetCallbackFunction(this, &LabelSetImage::OnLabelModified);
label->AddObserver(itk::ModifiedEvent(), command);
}
void mitk::LabelSetImage::ReleaseLabel(Label* label)
{
if (nullptr == label) mitkThrow() << "Invalid call of ReleaseLabel with a nullptr.";
label->RemoveAllObservers();
}
void mitk::LabelSetImage::ApplyToLabels(const LabelValueVectorType& values, std::function<void(Label*)>&& lambda)
{
auto labels = this->GetLabelsByValue(values);
std::for_each(labels.begin(), labels.end(), lambda);
m_LabelsChangedMessage.Send(values);
}
void mitk::LabelSetImage::VisitLabels(const LabelValueVectorType& values, std::function<void(const Label*)>&& lambda) const
{
auto labels = this->GetConstLabelsByValue(values);
std::for_each(labels.begin(), labels.end(), lambda);
}
void mitk::LabelSetImage::OnLabelModified(const Object* sender, const itk::EventObject&)
{
auto label = dynamic_cast<const Label*>(sender);
if (nullptr == label)
mitkThrow() << "LabelSet is in wrong state. LabelModified event is not send by a label instance.";
Superclass::Modified();
this->m_LabelModifiedMessage.Send(label->GetValue());
}
bool mitk::LabelSetImage::ExistLabel(LabelValueType value) const
{
auto finding = m_LabelMap.find(value);
return m_LabelMap.end() != finding;
}
bool mitk::LabelSetImage::ExistLabel(LabelValueType value, GroupIndexType groupIndex) const
{
auto finding = m_LabelToGroupMap.find(value);
if (m_LabelToGroupMap.end() != finding)
{
return finding->second == groupIndex;
}
return false;
}
bool mitk::LabelSetImage::ExistGroup(GroupIndexType index) const
{
return index < m_LayerContainer.size();
}
bool mitk::LabelSetImage::IsLabelInGroup(LabelValueType value) const
{
GroupIndexType dummy;
return this->IsLabelInGroup(value, dummy);
}
bool mitk::LabelSetImage::IsLabelInGroup(LabelValueType value, GroupIndexType& groupIndex) const
{
auto finding = m_LabelToGroupMap.find(value);
if (m_LabelToGroupMap.end() != finding)
{
groupIndex = finding->second;
return true;
}
return false;
}
mitk::LabelSetImage::GroupIndexType mitk::LabelSetImage::GetGroupIndexOfLabel(LabelValueType value) const
{
auto finding = m_LabelToGroupMap.find(value);
if (m_LabelToGroupMap.end() == finding)
{
mitkThrow()<< "Cannot deduce group index. Passed label value does not exist. Value: "<< value;
}
return finding->second;
}
const mitk::Label* mitk::LabelSetImage::GetLabel(LabelValueType value) const
{
auto finding = m_LabelMap.find(value);
if (m_LabelMap.end() != finding)
{
return finding->second;
}
return nullptr;
};
mitk::Label* mitk::LabelSetImage::GetLabel(LabelValueType value)
{
auto finding = m_LabelMap.find(value);
if (m_LabelMap.end() != finding)
{
return finding->second;
}
return nullptr;
};
bool mitk::LabelSetImage::IsLabelLocked(LabelValueType value) const
{
- if (value == UnlabeledValue)
+ if (value == UNLABELED_VALUE)
{
return m_UnlabeledLabelLock;
}
const auto label = this->GetLabel(value);
return label->GetLocked();
}
const mitk::LabelSetImage::ConstLabelVectorType mitk::LabelSetImage::GetLabels() const
{
ConstLabelVectorType result;
for (auto [value, label] : m_LabelMap)
{
result.emplace_back(label);
}
return result;
}
const mitk::LabelSetImage::LabelVectorType mitk::LabelSetImage::GetLabels()
{
LabelVectorType result;
for (auto [value, label] : m_LabelMap)
{
result.emplace_back(label);
}
return result;
}
const mitk::LabelSetImage::LabelVectorType mitk::LabelSetImage::GetLabelsByValue(const LabelValueVectorType& labelValues, bool ignoreMissing)
{
LabelVectorType result;
for (const auto& labelValue : labelValues)
{
auto* label = this->GetLabel(labelValue);
if (label != nullptr)
{
result.emplace_back(label);
}
else if (!ignoreMissing) mitkThrow() << "Error cannot get labels by Value. At least one passed value is unknown. Unknown value: " << labelValue;
}
return result;
}
const mitk::LabelSetImage::ConstLabelVectorType mitk::LabelSetImage::GetConstLabelsByValue(const LabelValueVectorType& labelValues, bool ignoreMissing) const
{
ConstLabelVectorType result;
for (const auto& labelValue : labelValues)
{
const auto* label = this->GetLabel(labelValue);
if (label != nullptr)
{
result.emplace_back(label);
}
else if (!ignoreMissing) mitkThrow() << "Error cannot get labels by Value. At least one passed value is unknown. Unknown value: " << labelValue;
}
return result;
}
const mitk::LabelSetImage::LabelValueVectorType mitk::LabelSetImage::GetLabelValuesByGroup(GroupIndexType index) const
{
if (!this->ExistGroup(index))
mitkThrow() << "Cannot get labels of an invalid group. Invalid group index: " << index;
return m_GroupToLabelMap[index];
}
const mitk::LabelSetImage::LabelValueVectorType mitk::LabelSetImage::GetLabelValuesByName(GroupIndexType index, std::string_view name) const
{
LabelValueVectorType result;
auto searchName = [&result, name](const Label* l) { if(l->GetName() == name) result.push_back(l->GetValue()); };
this->VisitLabels(this->GetLabelValuesByGroup(index), searchName);
return result;
}
std::vector<std::string> mitk::LabelSetImage::GetLabelClassNames() const
{
std::set<std::string> names;
auto searchName = [&names](const Label* l) { names.emplace(l->GetName()); };
this->VisitLabels(this->GetAllLabelValues(), searchName);
return std::vector<std::string>(names.begin(), names.end());
}
std::vector<std::string> mitk::LabelSetImage::GetLabelClassNamesByGroup(GroupIndexType index) const
{
std::set<std::string> names;
auto searchName = [&names](const Label* l) { names.emplace(l->GetName()); };
this->VisitLabels(this->GetLabelValuesByGroup(index), searchName);
return std::vector<std::string>(names.begin(), names.end());
}
void mitk::LabelSetImage::SetAllLabelsVisible(bool visible)
{
auto setVisibility = [visible](Label* l) { l->SetVisible(visible); };
this->ApplyToLabels(this->GetAllLabelValues(), setVisibility);
}
void mitk::LabelSetImage::SetAllLabelsVisibleByGroup(GroupIndexType group, bool visible)
{
auto setVisibility = [visible](Label* l) { l->SetVisible(visible); };
this->ApplyToLabels(this->GetLabelValuesByGroup(group), setVisibility);
}
void mitk::LabelSetImage::SetAllLabelsVisibleByName(GroupIndexType group, std::string_view name, bool visible)
{
auto setVisibility = [visible](Label* l) { l->SetVisible(visible); };
this->ApplyToLabels(this->GetLabelValuesByName(group, name), setVisibility);
}
void mitk::LabelSetImage::SetAllLabelsLocked(bool locked)
{
auto setLock = [locked](Label* l) { l->SetLocked(locked); };
this->ApplyToLabels(this->GetAllLabelValues(), setLock);
}
void mitk::LabelSetImage::SetAllLabelsLockedByGroup(GroupIndexType group, bool locked)
{
auto setLock = [locked](Label* l) { l->SetLocked(locked); };
this->ApplyToLabels(this->GetLabelValuesByGroup(group), setLock);
}
void mitk::LabelSetImage::SetAllLabelsLockedByName(GroupIndexType group, std::string_view name, bool locked)
{
auto setLock = [locked](Label* l) { l->SetLocked(locked); };
this->ApplyToLabels(this->GetLabelValuesByName(group, name), setLock);
}
bool mitk::Equal(const mitk::LabelSetImage &leftHandSide,
const mitk::LabelSetImage &rightHandSide,
ScalarType eps,
bool verbose)
{
bool returnValue = true;
/* LabelSetImage members */
MITK_INFO(verbose) << "--- LabelSetImage Equal ---";
// m_LookupTable;
const mitk::LookupTable* lhsLUT = leftHandSide.GetLookupTable();
const mitk::LookupTable* rhsLUT = rightHandSide.GetLookupTable();
returnValue = *lhsLUT == *rhsLUT;
if (!returnValue)
{
MITK_INFO(verbose) << "Lookup tabels not equal.";
return returnValue;
;
}
// number layers
returnValue = leftHandSide.GetNumberOfLayers() == rightHandSide.GetNumberOfLayers();
if (!returnValue)
{
MITK_INFO(verbose) << "Number of layers not equal.";
return false;
}
// total number labels
returnValue = leftHandSide.GetTotalNumberOfLabels() == rightHandSide.GetTotalNumberOfLabels();
if (!returnValue)
{
MITK_INFO(verbose) << "Total number of labels not equal.";
return false;
}
// active layer
returnValue = leftHandSide.GetActiveLayer() == rightHandSide.GetActiveLayer();
if (!returnValue)
{
MITK_INFO(verbose) << "Active layer not equal.";
return false;
}
if (4 == leftHandSide.GetDimension())
{
MITK_INFO(verbose) << "Can not compare image data for 4D images - skipping check.";
}
else
{
// working image data
returnValue = mitk::Equal((const mitk::Image &)leftHandSide, (const mitk::Image &)rightHandSide, eps, verbose);
if (!returnValue)
{
MITK_INFO(verbose) << "Working image data not equal.";
return false;
}
}
if (leftHandSide.GetTotalNumberOfLabels() != rightHandSide.GetTotalNumberOfLabels())
{
MITK_INFO(verbose) << "Number of labels are not equal.";
return false;
}
for (unsigned int layerIndex = 0; layerIndex < leftHandSide.GetNumberOfLayers(); layerIndex++)
{
if (4 == leftHandSide.GetDimension())
{
MITK_INFO(verbose) << "Can not compare image data for 4D images - skipping check.";
}
else
{
// layer image data
returnValue =
mitk::Equal(*leftHandSide.GetGroupImage(layerIndex), *rightHandSide.GetGroupImage(layerIndex), eps, verbose);
if (!returnValue)
{
MITK_INFO(verbose) << "Layer image data not equal.";
return false;
}
}
// label data
auto leftLabelsInGroup = leftHandSide.GetLabelValuesByGroup(layerIndex);
auto rightLabelsInGroup = rightHandSide.GetLabelValuesByGroup(layerIndex);
if (leftLabelsInGroup.size()!=rightLabelsInGroup.size())
{
MITK_INFO(verbose) << "Number of layer labels is not equal. Invalid layer:" <<layerIndex;
return false;
}
for (ConstLabelVector::size_type index = 0; index < leftLabelsInGroup.size(); ++index)
{
if (!mitk::Equal(*(leftHandSide.GetLabel(leftLabelsInGroup[index])), *(rightHandSide.GetLabel(rightLabelsInGroup[index])),eps,verbose))
{
MITK_INFO(verbose) << "At least one label in layer is not equal. Invalid layer:" << layerIndex;
return false;
}
}
}
return returnValue;
}
bool mitk::Equal(const mitk::LabelSetImage::ConstLabelVectorType& leftHandSide,
const mitk::LabelSetImage::ConstLabelVectorType& rightHandSide, ScalarType eps, bool verbose)
{
bool returnValue = true;
// container size;
returnValue = leftHandSide.size() == rightHandSide.size();
if (!returnValue)
{
MITK_INFO(verbose) << "Number of labels not equal.";
return returnValue;
;
}
// m_LabelContainer;
auto lhsit = leftHandSide.begin();
auto rhsit = rightHandSide.begin();
for (; lhsit != leftHandSide.end(); ++lhsit, ++rhsit)
{
returnValue = mitk::Equal(**rhsit, **lhsit,eps,verbose);
if (!returnValue)
{
MITK_INFO(verbose) << "Label in label container not equal.";
return returnValue;
;
}
}
return returnValue;
}
/**Helper function to convert a vector of labels into a label map
* @pre every label in the vector has a unique value.*/
using ConstLabelMapType = std::map<mitk::LabelSetImage::LabelValueType, mitk::Label::ConstPointer>;
ConstLabelMapType ConvertLabelVectorToMap(const mitk::ConstLabelVector& labelV)
{
ConstLabelMapType result;
for (auto label : labelV)
{
const auto value = label->GetValue();
auto finding = result.find(value);
if (finding != result.end()) mitkThrow() << "Operation failed. Cannot convert label vector into label map, because at least one label value is not unique. Violating label value: " << value;
result.insert(std::make_pair(value, label));
}
return result;
}
/** Functor class that implements the label transfer and is used in conjunction with the itk::BinaryFunctorImageFilter.
* For details regarding the usage of the filter and the functor patterns, please see info of itk::BinaryFunctorImageFilter.
*/
template <class TDestinationPixel, class TSourcePixel, class TOutputpixel>
class LabelTransferFunctor
{
public:
LabelTransferFunctor() {};
LabelTransferFunctor(const ConstLabelMapType& destinationLabels, mitk::Label::PixelType sourceBackground,
mitk::Label::PixelType destinationBackground, bool destinationBackgroundLocked,
mitk::Label::PixelType sourceLabel, mitk::Label::PixelType newDestinationLabel, mitk::MultiLabelSegmentation::MergeStyle mergeStyle,
mitk::MultiLabelSegmentation::OverwriteStyle overwriteStyle) :
m_DestinationLabels(destinationLabels), m_SourceBackground(sourceBackground),
m_DestinationBackground(destinationBackground), m_DestinationBackgroundLocked(destinationBackgroundLocked),
m_SourceLabel(sourceLabel), m_NewDestinationLabel(newDestinationLabel), m_MergeStyle(mergeStyle), m_OverwriteStyle(overwriteStyle)
{
};
~LabelTransferFunctor() {};
bool operator!=(const LabelTransferFunctor& other)const
{
return !(*this == other);
}
bool operator==(const LabelTransferFunctor& other) const
{
return this->m_SourceBackground == other.m_SourceBackground &&
this->m_DestinationBackground == other.m_DestinationBackground &&
this->m_DestinationBackgroundLocked == other.m_DestinationBackgroundLocked &&
this->m_SourceLabel == other.m_SourceLabel &&
this->m_NewDestinationLabel == other.m_NewDestinationLabel &&
this->m_MergeStyle == other.m_MergeStyle &&
this->m_OverwriteStyle == other.m_OverwriteStyle &&
this->m_DestinationLabels == other.m_DestinationLabels;
}
LabelTransferFunctor& operator=(const LabelTransferFunctor& other)
{
this->m_DestinationLabels = other.m_DestinationLabels;
this->m_SourceBackground = other.m_SourceBackground;
this->m_DestinationBackground = other.m_DestinationBackground;
this->m_DestinationBackgroundLocked = other.m_DestinationBackgroundLocked;
this->m_SourceLabel = other.m_SourceLabel;
this->m_NewDestinationLabel = other.m_NewDestinationLabel;
this->m_MergeStyle = other.m_MergeStyle;
this->m_OverwriteStyle = other.m_OverwriteStyle;
return *this;
}
inline TOutputpixel operator()(const TDestinationPixel& existingDestinationValue, const TSourcePixel& existingSourceValue)
{
if (existingSourceValue == this->m_SourceLabel)
{
if (mitk::MultiLabelSegmentation::OverwriteStyle::IgnoreLocks == this->m_OverwriteStyle)
{
return this->m_NewDestinationLabel;
}
else
{
if (existingDestinationValue == m_DestinationBackground)
{
if (!m_DestinationBackgroundLocked)
{
return this->m_NewDestinationLabel;
}
}
else
{
auto labelFinding = this->m_DestinationLabels.find(existingDestinationValue);
if (labelFinding==this->m_DestinationLabels.end() || !labelFinding->second->GetLocked())
{
return this->m_NewDestinationLabel;
}
}
}
}
else if (mitk::MultiLabelSegmentation::MergeStyle::Replace == this->m_MergeStyle
&& existingSourceValue == this->m_SourceBackground
&& existingDestinationValue == this->m_NewDestinationLabel
&& (mitk::MultiLabelSegmentation::OverwriteStyle::IgnoreLocks == this->m_OverwriteStyle
|| !this->m_DestinationBackgroundLocked))
{
return this->m_DestinationBackground;
}
return existingDestinationValue;
}
private:
ConstLabelMapType m_DestinationLabels;
mitk::Label::PixelType m_SourceBackground = 0;
mitk::Label::PixelType m_DestinationBackground = 0;
bool m_DestinationBackgroundLocked = false;
mitk::Label::PixelType m_SourceLabel = 1;
mitk::Label::PixelType m_NewDestinationLabel = 1;
mitk::MultiLabelSegmentation::MergeStyle m_MergeStyle = mitk::MultiLabelSegmentation::MergeStyle::Replace;
mitk::MultiLabelSegmentation::OverwriteStyle m_OverwriteStyle = mitk::MultiLabelSegmentation::OverwriteStyle::RegardLocks;
};
/**Helper function used by TransferLabelContentAtTimeStep to allow the templating over different image dimensions in conjunction of AccessFixedPixelTypeByItk_n.*/
template<unsigned int VImageDimension>
void TransferLabelContentAtTimeStepHelper(const itk::Image<mitk::Label::PixelType, VImageDimension>* itkSourceImage, mitk::Image* destinationImage,
const mitk::ConstLabelVector& destinationLabels, mitk::Label::PixelType sourceBackground, mitk::Label::PixelType destinationBackground,
bool destinationBackgroundLocked, mitk::Label::PixelType sourceLabel, mitk::Label::PixelType newDestinationLabel, mitk::MultiLabelSegmentation::MergeStyle mergeStyle, mitk::MultiLabelSegmentation::OverwriteStyle overwriteStyle)
{
typedef itk::Image<mitk::Label::PixelType, VImageDimension> ContentImageType;
typename ContentImageType::Pointer itkDestinationImage;
mitk::CastToItkImage(destinationImage, itkDestinationImage);
auto sourceRegion = itkSourceImage->GetLargestPossibleRegion();
auto relevantRegion = itkDestinationImage->GetLargestPossibleRegion();
bool overlapping = relevantRegion.Crop(sourceRegion);
if (!overlapping)
{
mitkThrow() << "Invalid call of TransferLabelContentAtTimeStep; sourceImage and destinationImage seem to have no overlapping image region.";
}
typedef LabelTransferFunctor <mitk::Label::PixelType, mitk::Label::PixelType, mitk::Label::PixelType> LabelTransferFunctorType;
typedef itk::BinaryFunctorImageFilter<ContentImageType, ContentImageType, ContentImageType, LabelTransferFunctorType> FilterType;
LabelTransferFunctorType transferFunctor(ConvertLabelVectorToMap(destinationLabels), sourceBackground, destinationBackground,
destinationBackgroundLocked, sourceLabel, newDestinationLabel, mergeStyle, overwriteStyle);
auto transferFilter = FilterType::New();
transferFilter->SetFunctor(transferFunctor);
transferFilter->InPlaceOn();
transferFilter->SetInput1(itkDestinationImage);
transferFilter->SetInput2(itkSourceImage);
transferFilter->GetOutput()->SetRequestedRegion(relevantRegion);
transferFilter->Update();
}
void mitk::TransferLabelContentAtTimeStep(
const Image* sourceImage, Image* destinationImage, const mitk::ConstLabelVector& destinationLabels, const TimeStepType timeStep, mitk::Label::PixelType sourceBackground,
mitk::Label::PixelType destinationBackground, bool destinationBackgroundLocked, LabelValueMappingVector labelMapping,
MultiLabelSegmentation::MergeStyle mergeStyle, MultiLabelSegmentation::OverwriteStyle overwriteStlye)
{
if (nullptr == sourceImage)
{
mitkThrow() << "Invalid call of TransferLabelContentAtTimeStep; sourceImage must not be null.";
}
if (nullptr == destinationImage)
{
mitkThrow() << "Invalid call of TransferLabelContentAtTimeStep; destinationImage must not be null.";
}
if (sourceImage == destinationImage && labelMapping.size() > 1)
{
MITK_DEBUG << "Warning. Using TransferLabelContentAtTimeStep or TransferLabelContent with equal source and destination and more then on label to transfer, can lead to wrong results. Please see documentation and verify that the usage is OK.";
}
Image::ConstPointer sourceImageAtTimeStep = SelectImageByTimeStep(sourceImage, timeStep);
Image::Pointer destinationImageAtTimeStep = SelectImageByTimeStep(destinationImage, timeStep);
if (nullptr == sourceImageAtTimeStep)
{
mitkThrow() << "Invalid call of TransferLabelContentAtTimeStep; sourceImage does not have the requested time step: " << timeStep;
}
if (nullptr == destinationImageAtTimeStep)
{
mitkThrow() << "Invalid call of TransferLabelContentAtTimeStep; destinationImage does not have the requested time step: " << timeStep;
}
auto destLabelMap = ConvertLabelVectorToMap(destinationLabels);
for (const auto& [sourceLabel, newDestinationLabel] : labelMapping)
{
- if (LabelSetImage::UnlabeledValue!=newDestinationLabel && destLabelMap.end() == destLabelMap.find(newDestinationLabel))
+ if (LabelSetImage::UNLABELED_VALUE!=newDestinationLabel && destLabelMap.end() == destLabelMap.find(newDestinationLabel))
{
mitkThrow() << "Invalid call of TransferLabelContentAtTimeStep. Defined destination label does not exist in destinationImage. newDestinationLabel: " << newDestinationLabel;
}
AccessFixedPixelTypeByItk_n(sourceImageAtTimeStep, TransferLabelContentAtTimeStepHelper, (Label::PixelType), (destinationImageAtTimeStep, destinationLabels, sourceBackground, destinationBackground, destinationBackgroundLocked, sourceLabel, newDestinationLabel, mergeStyle, overwriteStlye));
}
destinationImage->Modified();
}
void mitk::TransferLabelContent(
const Image* sourceImage, Image* destinationImage, const mitk::ConstLabelVector& destinationLabels, mitk::Label::PixelType sourceBackground,
mitk::Label::PixelType destinationBackground, bool destinationBackgroundLocked, LabelValueMappingVector labelMapping,
MultiLabelSegmentation::MergeStyle mergeStyle, MultiLabelSegmentation::OverwriteStyle overwriteStlye)
{
if (nullptr == sourceImage)
{
mitkThrow() << "Invalid call of TransferLabelContent; sourceImage must not be null.";
}
if (nullptr == destinationImage)
{
mitkThrow() << "Invalid call of TransferLabelContent; destinationImage must not be null.";
}
const auto sourceTimeStepCount = sourceImage->GetTimeGeometry()->CountTimeSteps();
if (sourceTimeStepCount != destinationImage->GetTimeGeometry()->CountTimeSteps())
{
mitkThrow() << "Invalid call of TransferLabelContent; mismatch between images in number of time steps.";
}
for (mitk::TimeStepType i = 0; i < sourceTimeStepCount; ++i)
{
TransferLabelContentAtTimeStep(sourceImage, destinationImage, destinationLabels, i, sourceBackground,
destinationBackground, destinationBackgroundLocked, labelMapping, mergeStyle, overwriteStlye);
}
}
void mitk::TransferLabelContentAtTimeStep(
const LabelSetImage* sourceImage, LabelSetImage* destinationImage, const TimeStepType timeStep,
LabelValueMappingVector labelMapping,
MultiLabelSegmentation::MergeStyle mergeStyle, MultiLabelSegmentation::OverwriteStyle overwriteStlye)
{
if (nullptr == sourceImage)
{
mitkThrow() << "Invalid call of TransferLabelContentAtTimeStep; sourceImage must not be null.";
}
auto destinationLabels = destinationImage->GetConstLabelsByValue(destinationImage->GetLabelValuesByGroup(destinationImage->GetActiveLayer()));
for (const auto& mappingElement : labelMapping)
{
- if (LabelSetImage::UnlabeledValue != mappingElement.first && !sourceImage->ExistLabel(mappingElement.first, sourceImage->GetActiveLayer()))
+ if (LabelSetImage::UNLABELED_VALUE != mappingElement.first && !sourceImage->ExistLabel(mappingElement.first, sourceImage->GetActiveLayer()))
{
mitkThrow() << "Invalid call of TransferLabelContentAtTimeStep. Defined source label does not exist in sourceImage. SourceLabel: " << mappingElement.first;
}
}
- TransferLabelContentAtTimeStep(sourceImage, destinationImage, destinationLabels, timeStep, LabelSetImage::UnlabeledValue, LabelSetImage::UnlabeledValue, destinationImage->GetUnlabeledLabelLock(),
+ TransferLabelContentAtTimeStep(sourceImage, destinationImage, destinationLabels, timeStep, LabelSetImage::UNLABELED_VALUE, LabelSetImage::UNLABELED_VALUE, destinationImage->GetUnlabeledLabelLock(),
labelMapping, mergeStyle, overwriteStlye);
}
void mitk::TransferLabelContent(
const LabelSetImage* sourceImage, LabelSetImage* destinationImage,
LabelValueMappingVector labelMapping,
MultiLabelSegmentation::MergeStyle mergeStyle, MultiLabelSegmentation::OverwriteStyle overwriteStlye)
{
if (nullptr == sourceImage)
{
mitkThrow() << "Invalid call of TransferLabelContent; sourceImage must not be null.";
}
if (nullptr == destinationImage)
{
mitkThrow() << "Invalid call of TransferLabelContent; destinationImage must not be null.";
}
const auto sourceTimeStepCount = sourceImage->GetTimeGeometry()->CountTimeSteps();
if (sourceTimeStepCount != destinationImage->GetTimeGeometry()->CountTimeSteps())
{
mitkThrow() << "Invalid call of TransferLabelContent; images have no equal number of time steps.";
}
for (mitk::TimeStepType i = 0; i < sourceTimeStepCount; ++i)
{
TransferLabelContentAtTimeStep(sourceImage, destinationImage, i, labelMapping, mergeStyle, overwriteStlye);
}
}
diff --git a/Modules/Multilabel/mitkLabelSetImage.h b/Modules/Multilabel/mitkLabelSetImage.h
index 1e0a34eaaa..f3d2fce757 100644
--- a/Modules/Multilabel/mitkLabelSetImage.h
+++ b/Modules/Multilabel/mitkLabelSetImage.h
@@ -1,718 +1,717 @@
/*============================================================================
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 mitkLabelSetImage_h
#define mitkLabelSetImage_h
#include <mitkImage.h>
#include <mitkLabel.h>
#include <mitkMessage.h>
#include <mitkLookupTable.h>
#include <MitkMultilabelExports.h>
namespace mitk
{
//##Documentation
//## @brief LabelSetImage class for handling labels and layers in a segmentation session.
//##
//## Handles operations for adding, removing, erasing and editing labels and layers.
//## @ingroup Data
-
class MITKMULTILABEL_EXPORT LabelSetImage : public Image
{
public:
mitkClassMacro(LabelSetImage, Image);
itkNewMacro(Self);
typedef mitk::Label::PixelType PixelType;
/**
* \brief BeforeChangeLayerEvent (e.g. used for GUI integration)
* As soon as active labelset should be changed, the signal emits.
* Emitted by SetActiveLayer(int layer);
*/
Message<> BeforeChangeLayerEvent;
/**
* \brief AfterchangeLayerEvent (e.g. used for GUI integration)
* As soon as active labelset was changed, the signal emits.
* Emitted by SetActiveLayer(int layer);
*/
Message<> AfterChangeLayerEvent;
///////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////
// FUTURE MultiLabelSegmentation:
// Section that already contains declarations used in the new class.
// So this part of the interface will stay after refactoring towards
// the new MultiLabelSegmentation class (see T28524). This section was introduced
// because some of the planned features are already urgently needed.
///////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////
using GroupIndexType = std::size_t;
using LabelValueType = mitk::Label::PixelType;
- const static LabelValueType UnlabeledValue = 0;
+ const static LabelValueType UNLABELED_VALUE = 0;
using ConstLabelVectorType = ConstLabelVector;
using LabelVectorType = LabelVector;
using LabelValueVectorType = std::vector<LabelValueType>;
/** \brief Adds a label instance to a group of the multi label image.
* @remark By default, if the pixel value of the label is already used in the image, the label
* will get a new none conflicting value assigned. This can be controlled by correctLabelValue.
* @param label Instance of an label that should be added or used as template
* @param groupID The id of the group the label should be added to.
* @param addAsClone Flag that controls, if the passed instance should be added (false; the image will then take ownership,
* be aware that e.g. event observers will be added)
* a clone of the instance (true).
* @param correctLabelValue Flag that controls, if the value of the passed label should be correct, if this value is already used in
* the multi label image. True: Conflicting values will be corrected, be assigning a none conflicting value. False: If the value is conflicting
* an exception will be thrown.
* @return Instance of the label as it was added to the label set.
* @pre label must point to a valid instance.
* @pre If correctLabelValue==false, label value must be non conflicting.
* @pre groupID must indicate an existing group.
*/
mitk::Label* AddLabel(mitk::Label* label, GroupIndexType groupID, bool addAsClone = true, bool correctLabelValue = true);
/** \brief Adds a new label to a group of the image by providing name and color.
* @param name (Class) name of the label instance that should be added.
* @param color Color of the new label sinstance.
* @param groupID The id of the group the label should be added to.
* @return Instance of the label as it was added to the label set.
* @pre groupID must indicate an existing group.
*/
mitk::Label* AddLabel(const std::string& name, const Color& color, GroupIndexType groupID);
/** \brief
*/
void RenameLabel(LabelValueType labelValue, const std::string&, const Color&);
/**
* @brief Removes the label with the given value.
* The label is removed from the labelset and
- * the pixel with the value of the label are set to UnlabeledValue.
+ * the pixel with the value of the label are set to UNLABELED_VALUE.
* @param labelValue the pixel value of the label to be removed
*/
void RemoveLabel(LabelValueType labelValue);
/**
* @brief Removes labels from the mitk::MultiLabelSegmentation.
* If a label value does not exist, it will be ignored.
* @param vectorOfLabelPixelValues a list of labels to be removed
*/
void RemoveLabels(const LabelValueVectorType& vectorOfLabelPixelValues);
/**
* @brief Removes a whole group including all its labels.
* @remark with removing a group all groups with greater index will be reindexed to
* close the gap. Hence externaly stored spatial group indices may become invalid.
* @param group Group index of the spatial group that should be removed. If the spatial group does not exist, an
* exception will be raised.
* @pre group index must be valid.
*/
void RemoveGroup(GroupIndexType group);
/** \brief Returns true if the value exists in the MultiLabelSegmentation instance*/
bool ExistLabel(LabelValueType value) const;
/**
* @brief Checks if a label belongs in a certain spatial group
* @param value the label value
* @param groupIndex Indexp of the spacial group which should be checked for the label
* @return true if the label exists otherwise false
*/
bool ExistLabel(LabelValueType value, GroupIndexType groupIndex) const;
/**
* @brief Returns true if the spatial group exists in the MultiLabelSegmentation instance.
*
* @param index Group index of the group that should be checked for existance.
*/
bool ExistGroup(GroupIndexType index) const;
bool IsLabelInGroup(LabelValueType value) const;
bool IsLabelInGroup(LabelValueType value, GroupIndexType& groupIndex) const;
/** Returns the group id of the based label value.
* @pre label value must exists.
*/
GroupIndexType GetGroupIndexOfLabel(LabelValueType value) const;
/**
* @brief Returns the mitk::Label with the given value.
* @param value the pixel value of the label
* @return the mitk::Label if available otherwise nullptr
*/
const mitk::Label* GetLabel(LabelValueType value) const;
mitk::Label* GetLabel(LabelValueType value);
/** Returns the lock state of the label (including UnlabeledLabel value).
@pre Requested label does exist.*/
bool IsLabelLocked(LabelValueType value) const;
/** Returns a vector with all labels currently defined in the MultiLabelSegmentation
instance.*/
const ConstLabelVectorType GetLabels() const;
const LabelVectorType GetLabels();
const LabelVectorType GetLabelsByValue(const LabelValueVectorType& labelValues, bool ignoreMissing = true);
const ConstLabelVectorType GetConstLabelsByValue(const LabelValueVectorType& labelValues, bool ignoreMissing = false) const;
static LabelValueVectorType ExtractLabelValuesFromLabelVector(const ConstLabelVectorType& labels);
static LabelValueVectorType ExtractLabelValuesFromLabelVector(const LabelVectorType& labels);
static ConstLabelVectorType ConvertLabelVectorConst(const LabelVectorType& labels);
const LabelValueVectorType GetAllLabelValues() const;
/**
* @brief Returns a vector of all label values located on the specified group.
* @param index the index of the group for which the vector of labels should be retrieved.
* If an invalid index is passed an exception will be raised.
* @return the respective vector of label values.
* @pre group index must exist.
*/
const LabelValueVectorType GetLabelValuesByGroup(GroupIndexType index) const;
/**
* @brief Returns a vector of all label values located on the specified group having a certain name.
* @param index the index of the group for which the vector of labels should be retrieved.
* If an invalid index is passed an exception will be raised.
* @param name Name of the label instances one is looking for.
* @return the respective vector of label values.
* @pre group index must exist.
*/
const LabelValueVectorType GetLabelValuesByName(GroupIndexType index, std::string_view name) const;
std::vector<std::string> GetLabelClassNames() const;
std::vector<std::string> GetLabelClassNamesByGroup(GroupIndexType index) const;
/** Helper that returns an unused label value, that could be used e.g. if one wants to define a label externally
before adding it.
@return A label value currently not in use.
@remark is no unused label value can be provided an exception will be thrown.*/
LabelValueType GetUnusedLabelValue() const;
itkGetConstMacro(UnlabeledLabelLock, bool);
itkSetMacro(UnlabeledLabelLock, bool);
itkBooleanMacro(UnlabeledLabelLock);
/** \brief
*/
void SetAllLabelsVisible(bool visible);
void SetAllLabelsVisibleByGroup(GroupIndexType group, bool visible);
void SetAllLabelsVisibleByName(GroupIndexType group, std::string_view name, bool visible);
/** \brief
*/
void SetAllLabelsLocked(bool locked);
void SetAllLabelsLockedByGroup(GroupIndexType group, bool locked);
void SetAllLabelsLockedByName(GroupIndexType group, std::string_view name, bool locked);
/**
* \brief Replaces the labels of a group with a given vector of labels.
*
* @remark The passed label instances will be cloned before added to ensure clear ownership
* of the new labels.
* @remark The pixel content of the old labels will not be removed.
* \param groupID The index of the group that should have its labels replaced
* \param newLabels The vector of new labels
* @pre Group that shuold be replaced must exist.
* Qpre new label values must not be used in other groups.
*/
void ReplaceGroupLabels(const GroupIndexType groupID, const ConstLabelVectorType& newLabels);
void ReplaceGroupLabels(const GroupIndexType groupID, const LabelVectorType& newLabels);
/** Returns the pointer to the image that containes the labeling of the indicate group.
*@pre groupID must reference an existing group.*/
mitk::Image* GetGroupImage(GroupIndexType groupID);
/** Returns the pointer to the image that containes the labeling of the indicate group.
*@pre groupID must reference an existing group.*/
const mitk::Image* GetGroupImage(GroupIndexType groupID) const;
////////////////////////////////////////////////////////////////////
//Message slots that allow to react to changes in an instance
using LabelEventType = Message1<LabelValueType>;
using LabelsEventType = Message1<LabelValueVectorType>;
using GroupEventType = Message1<GroupIndexType>;
/**
* \brief LabelAdded is emitted whenever a new label has been added.
*
* Observers should register to this event by calling this->AddLabelAddedListener(myObject,
* MyObject::MyMethod).
* After registering, myObject->MyMethod() will be called every time a new label has been added to the MultiLabelSegmentation.
* Observers should unregister by calling this->RemoveLabelAddedListener(myObject, MyObject::MyMethod).
* The registered method will be called with the label value of the added label.
* @remark the usage of the message object is thread safe.
*/
mitkNewMessage1Macro(LabelAdded, LabelValueType);
/**
* \brief LabelModified is emitted whenever a label has been modified.
*
* A label is modified if either its pixel content was changed, its spatial group or the label instance
* information.
* If you just want to get notified at the end of a MultiLabelSegmentation instance manipulation in the
* case that at least one label was modified (e.g. to avoid getting a signal for each label
* individually), use LabelsChanged instead.
* Observers should register to this event by calling this->AddLabelModifiedListener(myObject,
* MyObject::MyMethod).
* After registering, myObject->MyMethod() will be called every time a new label has been added to the MultiLabelSegmentation.
* Observers should unregister by calling this->RemoveLabelModifiedListener(myObject, MyObject::MyMethod).
* The registered method will be called with the label value of the modified label.
* @remark the usage of the message object is thread safe.
*/
mitkNewMessage1Macro(LabelModified, LabelValueType);
/**
* \brief LabelRemoved is emitted whenever a label has been removed.
*
* Observers should register to this event by calling this->AddLabelRemovedListener(myObject,
* MyObject::MyMethod).
* After registering, myObject->MyMethod() will be called every time a new label has been added to the MultiLabelSegmentation.
* Observers should unregister by calling this->RemoveLabelRemovedListener(myObject, MyObject::MyMethod).
* The registered method will be called with the label value of the removed label.*
* @remark the usage of the message object is thread safe.
*/
mitkNewMessage1Macro(LabelRemoved, LabelValueType);
/**
* \brief LabelsChanged is emitted when labels are changed (added, removed, modified).
*
* In difference to the other label events LabelsChanged is send only *one time* after the modification of the
* MultiLableImage instance is finished. So e.g. even if 4 labels are changed by a merge operation, this event will
* only be sent once (compared to LabelRemoved or LabelModified).
* Observers should register to this event by calling myMultiLabelSegmentation->AddLabelsChangedListener(myObject,
* MyObject::MyMethod).
* After registering, myObject->MyMethod() will be called every time a new label has been removed from the MultiLabelSegmentation.
* Observers should unregister by calling myMultiLabelSegmentation->RemoveLabelsChangedListener(myObject,
* MyObject::MyMethod).
* The registered method will be called with the vector of label values of the modified labels.*
* @remark the usage of the message object is thread safe.
*/
mitkNewMessage1Macro(LabelsChanged, LabelValueVectorType);
/**
* \brief GroupAdded is emitted whenever a new group has been added.
*
* Observers should register to this event by calling this->AddGroupAddedListener(myObject,
* MyObject::MyMethod).
* After registering, myObject->MyMethod() will be called every time a new group has been added to the MultiLabelSegmentation.
* Observers should unregister by calling this->RemoveGroupAddedListener(myObject, MyObject::MyMethod).
* The registered method will be called with the group index of the added group.
* @remark the usage of the message object is thread safe.
*/
mitkNewMessage1Macro(GroupAdded, GroupIndexType);
/**
* \brief GroupModified is emitted whenever a group has been modified.
*
* A group is modified if the set of labels associated with it are changed or the group's meta data.
* Observers should register to this event by calling this->AddGroupModifiedListener(myObject,
* MyObject::MyMethod).
* After registering, myObject->MyMethod() will be called every time a new label has been added to the MultiLabelSegmentation.
* Observers should unregister by calling this->RemoveGroupModifiedListener(myObject, MyObject::MyMethod).
* The registered method will be called with the group index of the added group.
* @remark the usage of the message object is thread safe.
*/
mitkNewMessage1Macro(GroupModified, GroupIndexType);
/**
* \brief GroupRemoved is emitted whenever a label has been removed.
*
* Observers should register to this event by calling this->AddGroupRemovedListener(myObject,
* MyObject::MyMethod).
* After registering, myObject->MyMethod() will be called every time a new label has been added to the MultiLabelSegmentation.
* Observers should unregister by calling this->RemoveGroupRemovedListener(myObject, MyObject::MyMethod).
* The registered method will be called with the group index of the removed group.*
* @remark the usage of the message object is thread safe.
*/
mitkNewMessage1Macro(GroupRemoved, GroupIndexType);
protected:
void OnLabelModified(const Object* sender, const itk::EventObject&);
/** Helper to ensure that the maps are correctly populated for a new label instance.*/
void AddLabelToMap(LabelValueType labelValue, Label* label, GroupIndexType groupID);
void RemoveLabelFromMap(LabelValueType labelValue);
/** Helper to ensure label events are correctly connected and lookup table is updated for a new label instance.*/
void RegisterLabel(Label* label);
/** Helper to ensure label events are unregistered.*/
void ReleaseLabel(Label* label);
void ApplyToLabels(const LabelValueVectorType& values, std::function<void(Label*)>&& lambda);
void VisitLabels(const LabelValueVectorType& values, std::function<void(const Label*)>&& lambda) const;
using LabelMapType = std::map<LabelValueType, Label::Pointer>;
LabelMapType m_LabelMap;
using GroupNameVectorType = std::vector<std::string>;
GroupNameVectorType m_Groups;
/**This type is internally used to track which label is currently
* associated with which layer.*/
using GroupToLabelMapType = std::vector<LabelValueVectorType>;
GroupToLabelMapType m_GroupToLabelMap;
using LabelToGroupMapType = std::map<LabelValueType, GroupIndexType>;
LabelToGroupMapType m_LabelToGroupMap;
LookupTable::Pointer m_LookupTable;
LabelValueType m_ActiveLabelValue;
private:
/** Indicates if the MultiLabelSegmentation allows to overwrite unlabeled pixels in normal pixel manipulation operations (e.g. TransferLabelConent).*/
bool m_UnlabeledLabelLock;
public:
/**
* \brief */
void UpdateCenterOfMass(PixelType pixelValue);
itkGetModifiableObjectMacro(LookupTable, mitk::LookupTable);
/** \brief
*/
void SetLookupTable(LookupTable* lut);
void UpdateLookupTable(PixelType pixelValue);
///////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////
// END FUTURE MultiLabelSegmentation
///////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////
/**
* @brief Initialize an empty mitk::LabelSetImage using the information
* of an mitk::Image
* @param image the image which is used for initializing the mitk::LabelSetImage
*/
using mitk::Image::Initialize;
void Initialize(const mitk::Image *image) override;
/**
* \brief */
void ClearBuffer();
/**
* @brief Merges the mitk::Label with a given target value with the active label
*
* @param pixelValue the value of the label that should be the new merged label
* @param sourcePixelValue the value of the label that should be merged into the specified one
* @param layer the layer in which the merge should be performed
*/
void MergeLabel(PixelType pixelValue, PixelType sourcePixelValue, unsigned int layer = 0);
/**
* @brief Merges a list of mitk::Labels with the mitk::Label that has a specific value
*
* @param pixelValue the value of the label that should be the new merged label
* @param vectorOfSourcePixelValues the list of label values that should be merge into the specified one
* @param layer the layer in which the merge should be performed
*/
void MergeLabels(PixelType pixelValue, const std::vector<PixelType>& vectorOfSourcePixelValues, unsigned int layer = 0);
/**
* \brief */
void UpdateCenterOfMass(PixelType pixelValue, unsigned int layer);
/**
* @brief Erases the label with the given value from the labelset image.
* The label itself will not be erased from the respective mitk::LabelSet. In order to
* remove the label itself use mitk::LabelSetImage::RemoveLabels()
* @param pixelValue the pixel value of the label that will be erased from the labelset image
*/
void EraseLabel(PixelType pixelValue);
/**
* @brief Erases a list of labels with the given values from the labelset image.
* @param VectorOfLabelPixelValues the list of pixel values of the labels
* that will be erased from the labelset image
*/
void EraseLabels(const std::vector<PixelType> &VectorOfLabelPixelValues);
/**
* \brief Returns true if the labelset exists*/
//[[deprecated("Will be removed with T28524")]]
DEPRECATED(bool ExistLabelSet(unsigned int layer) const);
/**
* @brief Gets the ID of the currently active layer
* @return the ID of the active layer
* @pre at least on group must exist.
*/
unsigned int GetActiveLayer() const;
/** \brief
*/
Label* GetActiveLabel();
/** \brief
*/
const Label* GetActiveLabel() const;
/**
* @brief Get the number of all existing mitk::Labels for a given layer
* @param layer the layer ID for which the active mitk::Labels should be retrieved
* @return the number of all existing mitk::Labels for the given layer
*/
unsigned int GetNumberOfLabels(unsigned int layer) const;
/**
* @brief Returns the number of all labels summed up across all layers
* @return the overall number of labels across all layers
*/
unsigned int GetTotalNumberOfLabels() const;
/**
* \brief */
mitk::Image::Pointer CreateLabelMask(PixelType index);
/**
* @brief Initialize a new mitk::LabelSetImage by a given image.
* For all distinct pixel values of the parameter image new labels will
* be created. If the number of distinct pixel values exceeds mitk::Label::MAX_LABEL_VALUE
* an excption will be raised.
* @param image the image which is used for initialization
*/
void InitializeByLabeledImage(mitk::Image::Pointer image);
/**
* \brief */
void MaskStamp(mitk::Image *mask, bool forceOverwrite);
/**
* \brief */
void SetActiveLayer(unsigned int layer);
void SetActiveLabel(LabelValueType label);
/**
* \brief */
unsigned int GetNumberOfLayers() const;
/**
* \brief Adds a new layer to the LabelSetImage. The new layer will be set as the active one.
* \param labelSet a labelset that will be added to the new layer if provided
* \return the layer ID of the new layer
*/
GroupIndexType AddLayer(ConstLabelVector labels = {});
/**
* \brief Adds a layer based on a provided mitk::Image.
* \param layerImage is added to the vector of label images
* \param labels labels that will be cloned and added to the new layer if provided
* \return the layer ID of the new layer
*/
GroupIndexType AddLayer(mitk::Image::Pointer layerImage, ConstLabelVector labels = {});
/**
* \brief */
mitk::Image *GetLayerImage(unsigned int layer);
const mitk::Image *GetLayerImage(unsigned int layer) const;
protected:
mitkCloneMacro(Self);
LabelSetImage();
LabelSetImage(const LabelSetImage &other);
~LabelSetImage() override;
template <typename TPixel, unsigned int VImageDimension>
void LayerContainerToImageProcessing(itk::Image<TPixel, VImageDimension> *source, unsigned int layer);
template <typename TPixel, unsigned int VImageDimension>
void ImageToLayerContainerProcessing(itk::Image<TPixel, VImageDimension> *source, unsigned int layer) const;
template <typename ImageType>
void CalculateCenterOfMassProcessing(ImageType *input, LabelValueType index);
template <typename ImageType>
void EraseLabelProcessing(ImageType *input, PixelType index);
template <typename ImageType>
void MergeLabelProcessing(ImageType *input, PixelType pixelValue, PixelType index);
template <typename ImageType>
void MaskStampProcessing(ImageType *input, mitk::Image *mask, bool forceOverwrite);
template <typename LabelSetImageType, typename ImageType>
void InitializeByLabeledImageProcessing(LabelSetImageType *input, ImageType *other);
/** helper needed for ensuring unique values.
returns a sorted list of all labels (including the value for Unlabeled pixels..*/
LabelValueVectorType GetUsedLabelValues() const;
std::vector<Image::Pointer> m_LayerContainer;
int m_ActiveLayer;
bool m_activeLayerInvalid;
};
/**
* @brief Equal A function comparing two label set images for beeing equal in meta- and imagedata
*
* @ingroup MITKTestingAPI
*
* Following aspects are tested for equality:
* - LabelSetImage members
* - working image data
* - layer image data
* - labels in label set
*
* @param rightHandSide An image to be compared
* @param leftHandSide An image to be compared
* @param eps Tolerance for comparison. You can use mitk::eps in most cases.
* @param verbose Flag indicating if the user wants detailed console output or not.
* @return true, if all subsequent comparisons are true, false otherwise
*/
MITKMULTILABEL_EXPORT bool Equal(const mitk::LabelSetImage &leftHandSide,
const mitk::LabelSetImage &rightHandSide,
ScalarType eps,
bool verbose);
/**
* @brief Equal A function comparing two vectors of labels for beeing equal in data
*
* @ingroup MITKTestingAPI
*
* Following aspects are tested for equality:
* - Labels in vector
*
* @param rightHandSide An vector of labels to be compared
* @param leftHandSide An vector of labels to be compared
* @param eps Tolarence for comparison. You can use mitk::eps in most cases.
* @param verbose Flag indicating if the user wants detailed console output or not.
* @return true, if all subsequent comparisons are true, false otherwise
*/
MITKMULTILABEL_EXPORT bool Equal(const mitk::LabelSetImage::ConstLabelVectorType& leftHandSide,
const mitk::LabelSetImage::ConstLabelVectorType& rightHandSide,
ScalarType eps,
bool verbose);
/** temporery namespace that is used until the new class MultiLabelSegmentation is
introduced. It allows to already introduce/use some upcoming definitions, while
refactoring code.*/
namespace MultiLabelSegmentation
{
enum class MergeStyle
{
Replace, //The old label content of a label value will be replaced by its new label content.
//Therefore pixels that are labeled might become unlabeled again.
//(This means that a lock of the value is also ignored).
Merge //The union of old and new label content will be generated.
};
enum class OverwriteStyle
{
RegardLocks, //Locked labels in the same spatial group will not be overwritten/changed.
IgnoreLocks //Label locks in the same spatial group will be ignored, so these labels might be changed.
};
}
using LabelValueMappingVector = std::vector < std::pair<Label::PixelType, Label::PixelType> >;
/**Helper function that transfers pixels of the specified source label from source image to the destination image by using
a specified destination label for a specific timestep. Function processes the whole image volume of the specified time step.
@remark in its current implementation the function only transfers contents of the active layer of the passed LabelSetImages.
@remark the function assumes that it is only called with source and destination image of same geometry.
@remark CAUTION: The function is not save if sourceImage and destinationImage are the same instance and more than one label is transferred,
because the changes are made in-place for performance reasons in multiple passes. If a mapped value A equals an "old value"
that occurs later in the mapping, one ends up with a wrong transfer, as a pixel would be first mapped to A and then later again, because
it is also an "old" value in the mapping table.
@param sourceImage Pointer to the LabelSetImage which active layer should be used as source for the transfer.
@param destinationImage Pointer to the LabelSetImage which active layer should be used as destination for the transfer.
@param labelMapping Map that encodes the mappings of all label pixel transfers that should be done. First element is the
label in the source image. The second element is the label that transferred pixels should become in the destination image.
The order in which the labels will be transfered is the same order of elements in the labelMapping.
If you use a heterogeneous label mapping (e.g. (1,2); so changing the label while transfering), keep in mind that
for the MergeStyle and OverwriteStyle only the destination label (second element) is relevant (e.g. what should be
altered with MergeStyle Replace).
@param mergeStyle indicates how the transfer should be done (merge or replace). For more details see documentation of
MultiLabelSegmentation::MergeStyle.
@param overwriteStlye indicates if label locks in the destination image should be regarded or not. For more details see
documentation of MultiLabelSegmentation::OverwriteStyle.
@param timeStep indicate the time step that should be transferred.
@pre sourceImage and destinationImage must be valid
@pre sourceImage and destinationImage must contain the indicated timeStep
@pre sourceImage must contain all indicated sourceLabels in its active layer.
@pre destinationImage must contain all indicated destinationLabels in its active layer.*/
MITKMULTILABEL_EXPORT void TransferLabelContentAtTimeStep(const LabelSetImage* sourceImage, LabelSetImage* destinationImage,
const TimeStepType timeStep, LabelValueMappingVector labelMapping = { {1,1} },
MultiLabelSegmentation::MergeStyle mergeStyle = MultiLabelSegmentation::MergeStyle::Replace,
MultiLabelSegmentation::OverwriteStyle overwriteStlye = MultiLabelSegmentation::OverwriteStyle::RegardLocks);
/**Helper function that transfers pixels of the specified source label from source image to the destination image by using
a specified destination label. Function processes the whole image volume for all time steps.
For more details please see TransferLabelContentAtTimeStep for LabelSetImages.
@sa TransferLabelContentAtTimeStep*/
MITKMULTILABEL_EXPORT void TransferLabelContent(const LabelSetImage* sourceImage, LabelSetImage* destinationImage, LabelValueMappingVector labelMapping = { {1,1} },
MultiLabelSegmentation::MergeStyle mergeStyle = MultiLabelSegmentation::MergeStyle::Replace,
MultiLabelSegmentation::OverwriteStyle overwriteStlye = MultiLabelSegmentation::OverwriteStyle::RegardLocks);
/**Helper function that transfers pixels of the specified source label from source image to the destination image by using
a specified destination label for a specific timestep. Function processes the whole image volume of the specified time step.
@remark the function assumes that it is only called with source and destination image of same geometry.
@remark CAUTION: The function is not save, if sourceImage and destinationImage are the same instance and you transfer more then one
label, because the changes are made inplace for performance reasons but not in one pass. If a mapped value A equals a "old value"
that is later in the mapping, one ends up with a wrong transfer, as a pixel would be first mapped to A and then latter again, because
it is also an "old" value in the mapping table.
@param sourceImage Pointer to the image that should be used as source for the transfer.
@param destinationImage Pointer to the image that should be used as destination for the transfer.
@param destinationLabelVector Reference to the vector of labels (incl. lock states) in the destination image. Unkown pixel
values in the destinationImage will be assumed to be unlocked.
@param sourceBackground Value indicating the background in the source image.
@param destinationBackground Value indicating the background in the destination image.
@param destinationBackgroundLocked Value indicating the lock state of the background in the destination image.
@param labelMapping Map that encodes the mappings of all label pixel transfers that should be done. First element is the
label in the source image. The second element is the label that transferred pixels should become in the destination image.
The order in which the labels will be transfered is the same order of elements in the labelMapping.
If you use a heterogeneous label mapping (e.g. (1,2); so changing the label while transfering), keep in mind that
for the MergeStyle and OverwriteStyle only the destination label (second element) is relevant (e.g. what should be
altered with MergeStyle Replace).
@param mergeStyle indicates how the transfer should be done (merge or replace). For more details see documentation of
MultiLabelSegmentation::MergeStyle.
@param overwriteStlye indicates if label locks in the destination image should be regarded or not. For more details see
documentation of MultiLabelSegmentation::OverwriteStyle.
@param timeStep indicate the time step that should be transferred.
@pre sourceImage, destinationImage and destinationLabelVector must be valid
@pre sourceImage and destinationImage must contain the indicated timeStep
@pre destinationLabelVector must contain all indicated destinationLabels for mapping.*/
MITKMULTILABEL_EXPORT void TransferLabelContentAtTimeStep(const Image* sourceImage, Image* destinationImage, const mitk::ConstLabelVector& destinationLabelVector,
- const TimeStepType timeStep, mitk::Label::PixelType sourceBackground = LabelSetImage::UnlabeledValue,
- mitk::Label::PixelType destinationBackground = LabelSetImage::UnlabeledValue,
+ const TimeStepType timeStep, mitk::Label::PixelType sourceBackground = LabelSetImage::UNLABELED_VALUE,
+ mitk::Label::PixelType destinationBackground = LabelSetImage::UNLABELED_VALUE,
bool destinationBackgroundLocked = false,
LabelValueMappingVector labelMapping = { {1,1} },
MultiLabelSegmentation::MergeStyle mergeStyle = MultiLabelSegmentation::MergeStyle::Replace,
MultiLabelSegmentation::OverwriteStyle overwriteStlye = MultiLabelSegmentation::OverwriteStyle::RegardLocks);
/**Helper function that transfers pixels of the specified source label from source image to the destination image by using
a specified destination label. Function processes the whole image volume for all time steps.
For more details please see TransferLabelContentAtTimeStep.
@sa TransferLabelContentAtTimeStep*/
MITKMULTILABEL_EXPORT void TransferLabelContent(const Image* sourceImage, Image* destinationImage, const mitk::ConstLabelVector& destinationLabelVector,
- mitk::Label::PixelType sourceBackground = LabelSetImage::UnlabeledValue,
- mitk::Label::PixelType destinationBackground = LabelSetImage::UnlabeledValue,
+ mitk::Label::PixelType sourceBackground = LabelSetImage::UNLABELED_VALUE,
+ mitk::Label::PixelType destinationBackground = LabelSetImage::UNLABELED_VALUE,
bool destinationBackgroundLocked = false,
LabelValueMappingVector labelMapping = { {1,1} },
MultiLabelSegmentation::MergeStyle mergeStyle = MultiLabelSegmentation::MergeStyle::Replace,
MultiLabelSegmentation::OverwriteStyle overwriteStlye = MultiLabelSegmentation::OverwriteStyle::RegardLocks);
} // namespace mitk
#endif
diff --git a/Modules/Multilabel/mitkLabelSetImageSurfaceStampFilter.cpp b/Modules/Multilabel/mitkLabelSetImageSurfaceStampFilter.cpp
index b99b1f928c..4bcf1430d9 100644
--- a/Modules/Multilabel/mitkLabelSetImageSurfaceStampFilter.cpp
+++ b/Modules/Multilabel/mitkLabelSetImageSurfaceStampFilter.cpp
@@ -1,108 +1,108 @@
/*============================================================================
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 "mitkLabelSetImageSurfaceStampFilter.h"
#include "mitkImageAccessByItk.h"
#include "mitkImageCast.h"
#include <mitkLabelSetImage.h>
#include <mitkLabelSetImage.h>
#include <mitkSurface.h>
#include <mitkSurfaceToImageFilter.h>
mitk::LabelSetImageSurfaceStampFilter::LabelSetImageSurfaceStampFilter() : m_ForceOverwrite(false)
{
this->SetNumberOfIndexedInputs(1);
this->SetNumberOfRequiredInputs(1);
}
mitk::LabelSetImageSurfaceStampFilter::~LabelSetImageSurfaceStampFilter()
{
}
void mitk::LabelSetImageSurfaceStampFilter::GenerateData()
{
// GenerateOutputInformation();
this->SetNthOutput(0, this->GetInput(0));
mitk::Image::Pointer inputImage = this->GetInput(0);
if (m_Surface.IsNull())
{
MITK_ERROR << "Input surface is nullptr.";
return;
}
mitk::SurfaceToImageFilter::Pointer surfaceToImageFilter = mitk::SurfaceToImageFilter::New();
surfaceToImageFilter->MakeOutputBinaryOn();
surfaceToImageFilter->SetInput(m_Surface);
surfaceToImageFilter->SetImage(inputImage);
surfaceToImageFilter->Update();
mitk::Image::Pointer resultImage = surfaceToImageFilter->GetOutput();
AccessByItk_1(inputImage, ItkImageProcessing, resultImage);
inputImage->DisconnectPipeline();
}
template <typename TPixel, unsigned int VImageDimension>
void mitk::LabelSetImageSurfaceStampFilter::ItkImageProcessing(itk::Image<TPixel, VImageDimension> *itkImage,
mitk::Image::Pointer resultImage)
{
typedef itk::Image<TPixel, VImageDimension> ImageType;
mitk::LabelSetImage::Pointer LabelSetInputImage = dynamic_cast<LabelSetImage *>(GetInput());
try
{
typename ImageType::Pointer itkResultImage = ImageType::New();
mitk::CastToItkImage(resultImage, itkResultImage);
typedef itk::ImageRegionConstIterator<ImageType> SourceIteratorType;
typedef itk::ImageRegionIterator<ImageType> TargetIteratorType;
SourceIteratorType sourceIter(itkResultImage, itkResultImage->GetLargestPossibleRegion());
sourceIter.GoToBegin();
TargetIteratorType targetIter(itkImage, itkImage->GetLargestPossibleRegion());
targetIter.GoToBegin();
int activeLabel = LabelSetInputImage->GetActiveLabel()->GetValue();
while (!sourceIter.IsAtEnd())
{
auto sourceValue = static_cast<int>(sourceIter.Get());
auto targetValue = static_cast<int>(targetIter.Get());
- if ((sourceValue != LabelSetImage::UnlabeledValue) &&
+ if ((sourceValue != LabelSetImage::UNLABELED_VALUE) &&
(m_ForceOverwrite ||
!LabelSetInputImage->GetLabel(targetValue)->GetLocked())) // skip unlabled pixels and locked labels
{
targetIter.Set(activeLabel);
}
++sourceIter;
++targetIter;
}
}
catch (itk::ExceptionObject &e)
{
mitkThrow() << e.GetDescription();
}
this->Modified();
}
void mitk::LabelSetImageSurfaceStampFilter::GenerateOutputInformation()
{
mitk::Image::Pointer inputImage = (mitk::Image *)this->GetInput();
mitk::Image::Pointer output = this->GetOutput();
itkDebugMacro(<< "GenerateOutputInformation()");
if (inputImage.IsNull())
return;
}
diff --git a/Modules/Multilabel/mitkMultiLabelIOHelper.cpp b/Modules/Multilabel/mitkMultiLabelIOHelper.cpp
index 10a9b8e9e3..ed0a404377 100644
--- a/Modules/Multilabel/mitkMultiLabelIOHelper.cpp
+++ b/Modules/Multilabel/mitkMultiLabelIOHelper.cpp
@@ -1,440 +1,440 @@
/*============================================================================
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 "mitkMultiLabelIOHelper.h"
#include "mitkLabelSetImage.h"
#include <mitkBasePropertySerializer.h>
#include "itkMetaDataDictionary.h"
#include "itkMetaDataObject.h"
#include <tinyxml2.h>
namespace
{
std::string EnsureExtension(const std::string& filename)
{
const std::string extension = ".lsetp";
if (filename.size() < extension.size() || std::string::npos == filename.find(extension, filename.size() - extension.size()))
return filename + extension;
return filename;
}
}
bool mitk::MultiLabelIOHelper::SaveLabelSetImagePreset(const std::string &presetFilename,
const mitk::LabelSetImage *inputImage)
{
const auto filename = EnsureExtension(presetFilename);
tinyxml2::XMLDocument xmlDocument;
xmlDocument.InsertEndChild(xmlDocument.NewDeclaration());
auto *rootElement = xmlDocument.NewElement("LabelSetImagePreset");
rootElement->SetAttribute("layers", inputImage->GetNumberOfLayers());
xmlDocument.InsertEndChild(rootElement);
for (unsigned int layerIndex = 0; layerIndex < inputImage->GetNumberOfLayers(); layerIndex++)
{
auto *layerElement = xmlDocument.NewElement("Layer");
layerElement->SetAttribute("index", layerIndex);
layerElement->SetAttribute("labels", inputImage->GetNumberOfLabels(layerIndex));
rootElement->InsertEndChild(layerElement);
auto labelsInGroup = inputImage->GetConstLabelsByValue(inputImage->GetLabelValuesByGroup(layerIndex));
for (const auto label : labelsInGroup)
layerElement->InsertEndChild(MultiLabelIOHelper::GetLabelAsXMLElement(xmlDocument, label));
}
return tinyxml2::XML_SUCCESS == xmlDocument.SaveFile(filename.c_str());
}
bool mitk::MultiLabelIOHelper::LoadLabelSetImagePreset(const std::string &presetFilename,
mitk::LabelSetImage *inputImage)
{
if (nullptr == inputImage)
return false;
const auto filename = EnsureExtension(presetFilename);
tinyxml2::XMLDocument xmlDocument;
if (tinyxml2::XML_SUCCESS != xmlDocument.LoadFile(filename.c_str()))
{
MITK_WARN << "Label set preset file \"" << filename << "\" does not exist or cannot be opened";
return false;
}
auto *rootElement = xmlDocument.FirstChildElement("LabelSetImagePreset");
if (nullptr == rootElement)
{
MITK_WARN << "Not a valid Label set preset";
return false;
}
auto activeLayerBackup = inputImage->GetActiveLayer();
int numberOfLayers = 0;
rootElement->QueryIntAttribute("layers", &numberOfLayers);
auto* layerElement = rootElement->FirstChildElement("Layer");
if (nullptr == layerElement)
{
MITK_WARN << "Label set preset does not contain any layers";
return false;
}
for (int layerIndex = 0; layerIndex < numberOfLayers; layerIndex++)
{
int numberOfLabels = 0;
layerElement->QueryIntAttribute("labels", &numberOfLabels);
if (!inputImage->ExistGroup(layerIndex))
{
while (!inputImage->ExistGroup(layerIndex))
{
inputImage->AddLayer();
}
}
auto *labelElement = layerElement->FirstChildElement("Label");
if (nullptr == labelElement)
continue;
for (int labelIndex = 0; labelIndex < numberOfLabels; labelIndex++)
{
auto label = mitk::MultiLabelIOHelper::LoadLabelFromXMLDocument(labelElement);
const auto labelValue = label->GetValue();
- if (LabelSetImage::UnlabeledValue != labelValue)
+ if (LabelSetImage::UNLABELED_VALUE != labelValue)
{
if (inputImage->ExistLabel(labelValue))
{
// Override existing label with label from preset
auto alreadyExistingLabel = inputImage->GetLabel(labelValue);
alreadyExistingLabel->ConcatenatePropertyList(label);
inputImage->UpdateLookupTable(labelValue);
}
else
{
inputImage->AddLabel(label, layerIndex, false);
}
}
labelElement = labelElement->NextSiblingElement("Label");
if (nullptr == labelElement)
continue;
}
layerElement = layerElement->NextSiblingElement("Layer");
if (nullptr == layerElement)
continue;
}
inputImage->SetActiveLayer(activeLayerBackup);
return true;
}
tinyxml2::XMLElement *mitk::MultiLabelIOHelper::GetLabelAsXMLElement(tinyxml2::XMLDocument &doc, const Label *label)
{
auto *labelElem = doc.NewElement("Label");
if (nullptr != label)
{
// add XML contents
const PropertyList::PropertyMap* propmap = label->GetMap();
for (auto iter = propmap->begin(); iter != propmap->end(); ++iter)
{
std::string key = iter->first;
const BaseProperty* property = iter->second;
auto* element = PropertyToXMLElement(doc, key, property);
if (element)
labelElem->InsertEndChild(element);
}
}
return labelElem;
}
mitk::Label::Pointer mitk::MultiLabelIOHelper::LoadLabelFromXMLDocument(const tinyxml2::XMLElement *labelElem)
{
// reread
auto *propElem = labelElem->FirstChildElement("property");
std::string name;
mitk::BaseProperty::Pointer prop;
mitk::Label::Pointer label = mitk::Label::New();
while (propElem)
{
MultiLabelIOHelper::PropertyFromXMLElement(name, prop, propElem);
label->SetProperty(name, prop);
propElem = propElem->NextSiblingElement("property");
}
return label.GetPointer();
}
tinyxml2::XMLElement *mitk::MultiLabelIOHelper::PropertyToXMLElement(tinyxml2::XMLDocument &doc, const std::string &key, const BaseProperty *property)
{
auto *keyelement = doc.NewElement("property");
keyelement->SetAttribute("key", key.c_str());
keyelement->SetAttribute("type", property->GetNameOfClass());
// construct name of serializer class
std::string serializername(property->GetNameOfClass());
serializername += "Serializer";
std::list<itk::LightObject::Pointer> allSerializers =
itk::ObjectFactoryBase::CreateAllInstance(serializername.c_str());
if (allSerializers.size() < 1)
MITK_ERROR << "No serializer found for " << property->GetNameOfClass() << ". Skipping object";
if (allSerializers.size() > 1)
MITK_WARN << "Multiple serializers found for " << property->GetNameOfClass() << "Using arbitrarily the first one.";
for (auto iter = allSerializers.begin(); iter != allSerializers.end();
++iter)
{
if (auto *serializer = dynamic_cast<BasePropertySerializer *>(iter->GetPointer()))
{
serializer->SetProperty(property);
try
{
auto *valueelement = serializer->Serialize(doc);
if (valueelement)
keyelement->InsertEndChild(valueelement);
}
catch (std::exception &e)
{
MITK_ERROR << "Serializer " << serializer->GetNameOfClass() << " failed: " << e.what();
}
break;
}
}
return keyelement;
}
bool mitk::MultiLabelIOHelper::PropertyFromXMLElement(std::string &key,
mitk::BaseProperty::Pointer &prop,
const tinyxml2::XMLElement *elem)
{
const char* typeC = elem->Attribute("type");
std::string type = nullptr != typeC
? typeC
: "";
const char* keyC = elem->Attribute("key");
key = nullptr != keyC
? keyC
: "";
// construct name of serializer class
std::string serializername(type);
serializername += "Serializer";
std::list<itk::LightObject::Pointer> allSerializers =
itk::ObjectFactoryBase::CreateAllInstance(serializername.c_str());
if (allSerializers.size() < 1)
MITK_ERROR << "No serializer found for " << type << ". Skipping object";
if (allSerializers.size() > 1)
MITK_WARN << "Multiple deserializers found for " << type << "Using arbitrarily the first one.";
for (auto iter = allSerializers.begin(); iter != allSerializers.end();
++iter)
{
if (auto *serializer = dynamic_cast<BasePropertySerializer *>(iter->GetPointer()))
{
try
{
prop = serializer->Deserialize(elem->FirstChildElement());
}
catch (std::exception &e)
{
MITK_ERROR << "Deserializer " << serializer->GetNameOfClass() << " failed: " << e.what();
return false;
}
break;
}
}
if (prop.IsNull())
return false;
return true;
}
int mitk::MultiLabelIOHelper::GetIntByKey(const itk::MetaDataDictionary& dic, const std::string& str)
{
std::vector<std::string> imgMetaKeys = dic.GetKeys();
std::vector<std::string>::const_iterator itKey = imgMetaKeys.begin();
std::string metaString("");
for (; itKey != imgMetaKeys.end(); itKey++)
{
itk::ExposeMetaData<std::string>(dic, *itKey, metaString);
if (itKey->find(str.c_str()) != std::string::npos)
{
return atoi(metaString.c_str());
}
}
return 0;
}
std::string mitk::MultiLabelIOHelper::GetStringByKey(const itk::MetaDataDictionary& dic, const std::string& str)
{
std::vector<std::string> imgMetaKeys = dic.GetKeys();
std::vector<std::string>::const_iterator itKey = imgMetaKeys.begin();
std::string metaString("");
for (; itKey != imgMetaKeys.end(); itKey++)
{
itk::ExposeMetaData<std::string>(dic, *itKey, metaString);
if (itKey->find(str.c_str()) != std::string::npos)
{
return metaString;
}
}
return metaString;
}
nlohmann::json mitk::MultiLabelIOHelper::SerializeMultLabelGroupsToJSON(const mitk::LabelSetImage* inputImage)
{
if (nullptr == inputImage)
{
mitkThrow() << "Invalid call of SerializeMultLabelGroupsToJSON. Passed image pointer is null.";
}
nlohmann::json result;
for (LabelSetImage::GroupIndexType i = 0; i < inputImage->GetNumberOfLayers(); i++)
{
nlohmann::json jgroup;
nlohmann::json jlabels;
for (const auto& label : inputImage->GetConstLabelsByValue(inputImage->GetLabelValuesByGroup(i)))
{
jlabels.emplace_back(SerializeLabelToJSON(label));
}
jgroup["labels"] = jlabels;
result.emplace_back(jgroup);
}
return result;
};
std::vector<mitk::LabelVector> mitk::MultiLabelIOHelper::DeserializeMultiLabelGroupsFromJSON(const nlohmann::json& listOfLabelSets)
{
std::vector<LabelVector> result;
for (const auto& jlabelset : listOfLabelSets)
{
LabelVector labelSet;
if (jlabelset.find("labels") != jlabelset.end())
{
auto jlabels = jlabelset["labels"];
for (const auto& jlabel : jlabels)
{
labelSet.push_back(DeserializeLabelFromJSON(jlabel));
}
}
result.emplace_back(labelSet);
}
return result;
}
nlohmann::json mitk::MultiLabelIOHelper::SerializeLabelToJSON(const Label* label)
{
if (nullptr == label)
{
mitkThrow() << "Invalid call of GetLabelAsJSON. Passed label pointer is null.";
}
nlohmann::json j;
j["name"] = label->GetName();
j["value"] = label->GetValue();
nlohmann::json jcolor;
jcolor["type"] = "ColorProperty";
jcolor["value"] = {label->GetColor().GetRed(), label->GetColor().GetGreen(), label->GetColor().GetBlue() };
j["color"] = jcolor;
j["locked"] = label->GetLocked();
j["opacity"] = label->GetOpacity();
j["visible"] = label->GetVisible();
return j;
};
template<typename TValueType> bool GetValueFromJson(const nlohmann::json& labelJson, const std::string& key, TValueType& value)
{
if (labelJson.find(key) != labelJson.end())
{
try
{
value = labelJson[key].get<TValueType>();
return true;
}
catch (...)
{
MITK_ERROR << "Unable to read label information from json. Value has wrong type. Failed key: " << key << "; invalid value: " << labelJson[key].dump();
throw;
}
}
return false;
}
mitk::Label::Pointer mitk::MultiLabelIOHelper::DeserializeLabelFromJSON(const nlohmann::json& labelJson)
{
Label::Pointer resultLabel = Label::New();
std::string name = "Unkown label name";
GetValueFromJson(labelJson, "name", name);
resultLabel->SetName(name);
Label::PixelType value = 1;
GetValueFromJson(labelJson, "value", value);
resultLabel->SetValue(value);
if (labelJson.find("color") != labelJson.end())
{
auto jcolor = labelJson["color"]["value"];
Color color;
color.SetRed(jcolor[0].get<float>());
color.SetGreen(jcolor[1].get<float>());
color.SetBlue(jcolor[2].get<float>());
resultLabel->SetColor(color);
}
bool locked = false;
if (GetValueFromJson(labelJson, "locked", locked))
resultLabel->SetLocked(locked);
float opacity = 1.;
if (GetValueFromJson(labelJson, "opacity", opacity))
resultLabel->SetOpacity(opacity);
bool visible = true;
if (GetValueFromJson(labelJson, "visible", visible))
resultLabel->SetVisible(visible);
return resultLabel;
}
diff --git a/Modules/Segmentation/Interactions/mitkCloseRegionTool.cpp b/Modules/Segmentation/Interactions/mitkCloseRegionTool.cpp
index 73c00146ee..4e6abe5178 100644
--- a/Modules/Segmentation/Interactions/mitkCloseRegionTool.cpp
+++ b/Modules/Segmentation/Interactions/mitkCloseRegionTool.cpp
@@ -1,119 +1,119 @@
/*============================================================================
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 "mitkCloseRegionTool.h"
// us
#include <usGetModuleContext.h>
#include <usModule.h>
#include <usModuleContext.h>
#include <usModuleResource.h>
#include <mitkImageAccessByItk.h>
#include <itkBinaryFillholeImageFilter.h>
#include <itkConnectedThresholdImageFilter.h>
namespace mitk
{
MITK_TOOL_MACRO(MITKSEGMENTATION_EXPORT, CloseRegionTool, "Close tool");
}
const char **mitk::CloseRegionTool::GetXPM() const
{
return nullptr;
}
us::ModuleResource mitk::CloseRegionTool::GetIconResource() const
{
us::Module *module = us::GetModuleContext()->GetModule();
us::ModuleResource resource = module->GetResource("Close.svg");
return resource;
}
us::ModuleResource mitk::CloseRegionTool::GetCursorIconResource() const
{
us::Module *module = us::GetModuleContext()->GetModule();
us::ModuleResource resource = module->GetResource("Close_Cursor.svg");
return resource;
}
const char *mitk::CloseRegionTool::GetName() const
{
return "Close";
}
template <typename TPixel, unsigned int VImageDimension>
void DoITKRegionClosing(const itk::Image<TPixel, VImageDimension>* oldSegImage,
mitk::Image::Pointer& filledRegionImage, itk::Index<VImageDimension> seedIndex, mitk::Label::PixelType& seedLabel)
{
typedef itk::Image<TPixel, VImageDimension> InputImageType;
typedef itk::Image<mitk::Label::PixelType, VImageDimension> OutputImageType;
typedef itk::ConnectedThresholdImageFilter<InputImageType, OutputImageType> RegionGrowingFilterType;
using FillHoleFilter = itk::BinaryFillholeImageFilter<OutputImageType>;
seedLabel = oldSegImage->GetPixel(seedIndex);
typename OutputImageType::Pointer itkResultImage;
filledRegionImage = nullptr;
try
{
auto regionGrower = RegionGrowingFilterType::New();
regionGrower->SetInput(oldSegImage);
regionGrower->SetReplaceValue(1);
regionGrower->AddSeed(seedIndex);
regionGrower->SetLower(seedLabel);
regionGrower->SetUpper(seedLabel);
auto filler = FillHoleFilter::New();
filler->SetInput(regionGrower->GetOutput());
filler->SetForegroundValue(1);
filler->Update();
itkResultImage = filler->GetOutput();
}
catch (const itk::ExceptionObject&)
{
return; // can't work
}
catch (...)
{
return;
}
mitk::CastToMitkImage(itkResultImage, filledRegionImage);
}
mitk::Image::Pointer mitk::CloseRegionTool::GenerateFillImage(const Image* workingSlice, Point3D seedPoint, mitk::Label::PixelType& seedLabelValue) const
{
itk::Index<2> seedIndex;
workingSlice->GetGeometry()->WorldToIndex(seedPoint, seedIndex);
Image::Pointer fillImage;
AccessFixedDimensionByItk_n(workingSlice, DoITKRegionClosing, 2, (fillImage, seedIndex, seedLabelValue));
- if (seedLabelValue == LabelSetImage::UnlabeledValue)
+ if (seedLabelValue == LabelSetImage::UNLABELED_VALUE)
{
return nullptr;
}
return fillImage;
}
void mitk::CloseRegionTool::PrepareFilling(const Image* /*workingSlice*/, Point3D /*seedPoint*/)
{
m_FillLabelValue = m_SeedLabelValue;
m_MergeStyle = MultiLabelSegmentation::MergeStyle::Merge;
};
diff --git a/Modules/Segmentation/Interactions/mitkEraseRegionTool.cpp b/Modules/Segmentation/Interactions/mitkEraseRegionTool.cpp
index 65fa667b0c..2ce18ddc49 100644
--- a/Modules/Segmentation/Interactions/mitkEraseRegionTool.cpp
+++ b/Modules/Segmentation/Interactions/mitkEraseRegionTool.cpp
@@ -1,87 +1,87 @@
/*============================================================================
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 "mitkEraseRegionTool.h"
#include "mitkEraseRegionTool.xpm"
#include <mitkImagePixelReadAccessor.h>
#include <mitkImageGenerator.h>
#include <mitkImageAccessByItk.h>
// us
#include <usGetModuleContext.h>
#include <usModule.h>
#include <usModuleContext.h>
#include <usModuleResource.h>
namespace mitk
{
MITK_TOOL_MACRO(MITKSEGMENTATION_EXPORT, EraseRegionTool, "Erase tool");
}
const char **mitk::EraseRegionTool::GetXPM() const
{
return mitkEraseRegionTool_xpm;
}
us::ModuleResource mitk::EraseRegionTool::GetIconResource() const
{
us::Module *module = us::GetModuleContext()->GetModule();
us::ModuleResource resource = module->GetResource("Erase.svg");
return resource;
}
us::ModuleResource mitk::EraseRegionTool::GetCursorIconResource() const
{
us::Module *module = us::GetModuleContext()->GetModule();
us::ModuleResource resource = module->GetResource("Erase_Cursor.svg");
return resource;
}
const char *mitk::EraseRegionTool::GetName() const
{
return "Erase";
}
template <typename TPixel, unsigned int VImageDimension>
void DoFillImage(itk::Image<TPixel, VImageDimension>* image)
{
image->FillBuffer(1);
};
mitk::Image::Pointer mitk::EraseRegionTool::GenerateFillImage(const Image* workingSlice, Point3D seedPoint, mitk::Label::PixelType& seedLabelValue) const
{
itk::Index<2> seedIndex;
workingSlice->GetGeometry()->WorldToIndex(seedPoint, seedIndex);
using AccessorType = ImagePixelReadAccessor<Label::PixelType, 2>;
AccessorType accessor(workingSlice);
seedLabelValue = accessor.GetPixelByIndex(seedIndex);
Image::Pointer fillImage;
- if ( seedLabelValue == LabelSetImage::UnlabeledValue)
+ if ( seedLabelValue == LabelSetImage::UNLABELED_VALUE)
{ //clicked on background remove everything which is not locked.
fillImage = workingSlice->Clone();
AccessByItk(fillImage, DoFillImage);
}
else
{
fillImage = Superclass::GenerateFillImage(workingSlice, seedPoint, seedLabelValue);
}
return fillImage;
}
void mitk::EraseRegionTool::PrepareFilling(const Image* /*workingSlice*/, Point3D /*seedPoint*/)
{
- m_FillLabelValue = LabelSetImage::UnlabeledValue;
+ m_FillLabelValue = LabelSetImage::UNLABELED_VALUE;
};
diff --git a/Modules/Segmentation/Interactions/mitkFillRegionBaseTool.cpp b/Modules/Segmentation/Interactions/mitkFillRegionBaseTool.cpp
index c7326d1c79..2bf51465fc 100644
--- a/Modules/Segmentation/Interactions/mitkFillRegionBaseTool.cpp
+++ b/Modules/Segmentation/Interactions/mitkFillRegionBaseTool.cpp
@@ -1,146 +1,146 @@
/*============================================================================
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 "mitkFillRegionBaseTool.h"
#include "mitkToolManager.h"
#include "mitkBaseRenderer.h"
#include "mitkDataStorage.h"
#include "mitkITKImageImport.h"
#include "mitkImageAccessByItk.h"
#include "mitkRenderingManager.h"
#include <itkConnectedThresholdImageFilter.h>
mitk::FillRegionBaseTool::FillRegionBaseTool() : SegTool2D("MouseReleaseOnly")
{
}
mitk::FillRegionBaseTool::~FillRegionBaseTool()
{
}
void mitk::FillRegionBaseTool::ConnectActionsAndFunctions()
{
CONNECT_FUNCTION("Release", OnClick);
}
template <typename TPixel, unsigned int VImageDimension>
void DoITKRegionGrowing(const itk::Image<TPixel, VImageDimension>* oldSegImage,
mitk::Image::Pointer& filledRegionImage, itk::Index<VImageDimension> seedIndex, mitk::Label::PixelType& seedLabel )
{
typedef itk::Image<TPixel, VImageDimension> InputImageType;
typedef itk::Image<mitk::Label::PixelType, VImageDimension> OutputImageType;
typedef itk::ConnectedThresholdImageFilter<InputImageType, OutputImageType> RegionGrowingFilterType;
seedLabel = oldSegImage->GetPixel(seedIndex);
typename OutputImageType::Pointer itkResultImage;
filledRegionImage = nullptr;
try
{
typename RegionGrowingFilterType::Pointer regionGrower = RegionGrowingFilterType::New();
regionGrower->SetInput(oldSegImage);
regionGrower->SetReplaceValue(1);
regionGrower->AddSeed(seedIndex);
regionGrower->SetLower(seedLabel);
regionGrower->SetUpper(seedLabel);
regionGrower->Update();
itkResultImage = regionGrower->GetOutput();
}
catch (const itk::ExceptionObject&)
{
return; // can't work
}
catch (...)
{
return;
}
mitk::CastToMitkImage(itkResultImage, filledRegionImage);
}
void mitk::FillRegionBaseTool::OnClick(StateMachineAction*, InteractionEvent* interactionEvent)
{
auto positionEvent = dynamic_cast<mitk::InteractionPositionEvent*>(interactionEvent);
if (nullptr == positionEvent)
return;
auto labelSetImage = dynamic_cast<const LabelSetImage*>(this->GetWorkingData());
if (nullptr == labelSetImage)
{
return;
}
if (!IsPositionEventInsideImageRegion(positionEvent, labelSetImage))
{
return;
}
m_LastEventSender = positionEvent->GetSender();
m_LastEventSlice = m_LastEventSender->GetSlice();
auto workingSlice = this->GetAffectedWorkingSlice(positionEvent);
auto click = positionEvent->GetPositionInWorld();
m_SeedLabelValue = 0;
auto fillImage = this->GenerateFillImage(workingSlice, click, m_SeedLabelValue);
if (fillImage.IsNull())
{
return; //nothing to fill;
}
if (labelSetImage->IsLabelLocked(m_SeedLabelValue) && m_SeedLabelValue!=labelSetImage->GetActiveLabel()->GetValue())
{
ErrorMessage.Send("Label of selected region is locked. Tool operation has no effect.");
return;
}
this->PrepareFilling(workingSlice, click);
//as fill region tools should always allow to manipulate active label
//(that is what the user expects/knows when using tools so far:
//the active label can always be changed even if locked)
//we realize that by cloning the relevant label set and changing the lock state
//this fillLabelSet is used for the transfer.
auto activeLabelClone = labelSetImage->GetActiveLabel()->Clone();
if (nullptr != activeLabelClone)
{
activeLabelClone->SetLocked(false);
}
- TransferLabelContentAtTimeStep(fillImage, workingSlice, { activeLabelClone }, 0, LabelSetImage::UnlabeledValue, LabelSetImage::UnlabeledValue, false, { {1, m_FillLabelValue} }, m_MergeStyle);
+ TransferLabelContentAtTimeStep(fillImage, workingSlice, { activeLabelClone }, 0, LabelSetImage::UNLABELED_VALUE, LabelSetImage::UNLABELED_VALUE, false, { {1, m_FillLabelValue} }, m_MergeStyle);
this->WriteBackSegmentationResult(positionEvent, workingSlice);
mitk::RenderingManager::GetInstance()->RequestUpdate(positionEvent->GetSender()->GetRenderWindow());
}
mitk::Image::Pointer mitk::FillRegionBaseTool::GenerateFillImage(const Image* workingSlice, Point3D seedPoint, mitk::Label::PixelType& seedLabelValue) const
{
itk::Index<2> seedIndex;
workingSlice->GetGeometry()->WorldToIndex(seedPoint, seedIndex);
Image::Pointer fillImage;
AccessFixedDimensionByItk_n(workingSlice, DoITKRegionGrowing, 2, (fillImage, seedIndex, seedLabelValue));
return fillImage;
}
diff --git a/Modules/Segmentation/Interactions/mitkPaintbrushTool.cpp b/Modules/Segmentation/Interactions/mitkPaintbrushTool.cpp
index 528be87fe1..eca164fb35 100644
--- a/Modules/Segmentation/Interactions/mitkPaintbrushTool.cpp
+++ b/Modules/Segmentation/Interactions/mitkPaintbrushTool.cpp
@@ -1,611 +1,611 @@
/*============================================================================
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"
#include "mitkImageWriteAccessor.h"
int mitk::PaintbrushTool::m_Size = 1;
mitk::PaintbrushTool::PaintbrushTool(bool startWithFillMode)
: FeedbackContourTool("PressMoveReleaseWithCTRLInversionAllMouseMoves"),
m_FillMode(startWithFillMode),
m_LastContourSize(0) // other than initial mitk::PaintbrushTool::m_Size (around l. 28)
{
m_MasterContour = ContourModel::New();
m_MasterContour->Initialize();
m_CurrentPlane = nullptr;
}
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();
SizeChanged.Send(m_Size);
this->GetToolManager()->WorkingDataChanged +=
mitk::MessageDelegate<mitk::PaintbrushTool>(this, &mitk::PaintbrushTool::OnToolManagerWorkingDataModified);
m_PaintingNode = DataNode::New();
m_PaintingNode->SetProperty("levelwindow", mitk::LevelWindowProperty::New(mitk::LevelWindow(0, m_InternalFillValue)));
m_PaintingNode->SetProperty("binary", mitk::BoolProperty::New(true));
m_PaintingNode->SetProperty("outline binary", mitk::BoolProperty::New(true));
m_PaintingNode->SetProperty("name", mitk::StringProperty::New("Paintbrush_Node"));
m_PaintingNode->SetProperty("helper object", mitk::BoolProperty::New(true));
m_PaintingNode->SetProperty("opacity", mitk::FloatProperty::New(0.8));
m_PaintingNode->SetProperty("includeInBoundingBox", mitk::BoolProperty::New(false));
auto allRenderWindows = BaseRenderer::GetAll3DRenderWindows();
for (auto mapit = allRenderWindows.begin(); mapit != allRenderWindows.end(); ++mapit)
{
m_PaintingNode->SetVisibility(false, mapit->second);
}
this->UpdateFeedbackColor();
FeedbackContourTool::SetFeedbackContourVisible(true);
this->GetToolManager()->GetDataStorage()->Add(m_PaintingNode);
}
void mitk::PaintbrushTool::Deactivated()
{
FeedbackContourTool::SetFeedbackContourVisible(false);
if (this->GetToolManager()->GetDataStorage()->Exists(m_PaintingNode))
this->GetToolManager()->GetDataStorage()->Remove(m_PaintingNode);
m_WorkingSlice = nullptr;
m_PaintingSlice = nullptr;
m_CurrentPlane = nullptr;
m_PaintingNode = nullptr;
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;
}
void mitk::PaintbrushTool::OnMousePressed(StateMachineAction *, InteractionEvent *interactionEvent)
{
if (m_WorkingSlice.IsNull())
return;
auto* positionEvent = dynamic_cast<mitk::InteractionPositionEvent*>(interactionEvent);
if (!positionEvent)
return;
this->ResetWorkingSlice(positionEvent);
m_WorkingSlice->GetGeometry()->WorldToIndex(positionEvent->GetPositionInWorld(), m_LastPosition);
this->m_PaintingNode->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);
bool newSlice = CheckIfCurrentSliceHasChanged(positionEvent);
if (newSlice)
{
this->ResetWorkingSlice(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)
{
ContourModelUtils::FillContourInSlice2(contour, m_PaintingSlice, m_InternalFillValue);
const double dist = indexCoordinates.EuclideanDistanceTo(m_LastPosition);
const double radius = static_cast<double>(m_Size) / 2.0;
// 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];
auto gapContour = ContourModel::New();
// upper left corner
vertex[0] = m_LastPosition[0] + (normal[0] * radius);
vertex[1] = m_LastPosition[1] + (normal[1] * radius);
gapContour->AddVertex(vertex);
// upper right corner
vertex[0] = currentPos[0] + (normal[0] * radius);
vertex[1] = currentPos[1] + (normal[1] * radius);
gapContour->AddVertex(vertex);
// lower right corner
vertex[0] = currentPos[0] - (normal[0] * radius);
vertex[1] = currentPos[1] - (normal[1] * radius);
gapContour->AddVertex(vertex);
// lower left corner
vertex[0] = m_LastPosition[0] - (normal[0] * radius);
vertex[1] = m_LastPosition[1] - (normal[1] * radius);
gapContour->AddVertex(vertex);
ContourModelUtils::FillContourInSlice2(gapContour, m_PaintingSlice, m_InternalFillValue);
}
}
else
{
// switched from different renderwindow
// no activate hover highlighting. Otherwise undo / redo wont work
this->m_PaintingNode->SetVisibility(false);
}
m_LastPosition = indexCoordinates;
// visualize contour
ContourModel::Pointer tmp =
FeedbackContourTool::BackProjectContourFrom2DSlice(m_WorkingSlice->GetGeometry(), contour);
this->UpdateCurrentFeedbackContour(tmp);
if (newSlice)
{
RenderingManager::GetInstance()->RequestUpdateAll();
}
else
{
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;
DataNode* workingNode(this->GetToolManager()->GetWorkingData(0));
auto workingImage = dynamic_cast<LabelSetImage*>(workingNode->GetData());
Label::PixelType activePixelValue = ContourModelUtils::GetActivePixelValue(workingImage);
if (!m_FillMode)
{
- activePixelValue = LabelSetImage::UnlabeledValue;
+ activePixelValue = LabelSetImage::UNLABELED_VALUE;
}
//as paintbrush tools should always allow to manipulate active label
//(that is what the user expects/knows when using tools so far:
//the active label can always be changed even if locked)
//we realize that by cloning the relevant label set and changing the lock state
//this fillLabelSet is used for the transfer.
auto activeLabelClone = workingImage->GetActiveLabel()->Clone();
if (nullptr != activeLabelClone)
{
activeLabelClone->SetLocked(false);
}
- TransferLabelContentAtTimeStep(m_PaintingSlice, m_WorkingSlice, { activeLabelClone }, 0, LabelSetImage::UnlabeledValue, LabelSetImage::UnlabeledValue, false, { {m_InternalFillValue, activePixelValue} }, mitk::MultiLabelSegmentation::MergeStyle::Merge);
+ TransferLabelContentAtTimeStep(m_PaintingSlice, m_WorkingSlice, { activeLabelClone }, 0, LabelSetImage::UNLABELED_VALUE, LabelSetImage::UNLABELED_VALUE, false, { {m_InternalFillValue, activePixelValue} }, mitk::MultiLabelSegmentation::MergeStyle::Merge);
this->WriteBackSegmentationResult(positionEvent, m_WorkingSlice->Clone());
// deactivate visibility of helper node
m_PaintingNode->SetVisibility(false);
m_PaintingNode->SetData(nullptr);
m_PaintingSlice = nullptr;
m_WorkingSlice = nullptr;
RenderingManager::GetInstance()->RequestUpdateAll();
}
void mitk::PaintbrushTool::UpdateFeedbackColor()
{
mitk::Color currentColor;
if (m_FillMode)
{
FeedbackContourTool::SetFeedbackContourColorDefault();
currentColor.Set(0.0, 1.0, 0.);
}
else
{
FeedbackContourTool::SetFeedbackContourColor(1.0, 0.0, 0.0);
currentColor.Set(1.0, 0.0, 0.);
}
if (m_PaintingNode.IsNotNull())
{
m_PaintingNode->SetProperty("color", mitk::ColorProperty::New(currentColor[0], currentColor[1], currentColor[2]));
}
}
/**
Called when the CTRL key is pressed.
*/
void mitk::PaintbrushTool::OnInvertLogic(StateMachineAction *, InteractionEvent *)
{
m_FillMode = !m_FillMode;
UpdateFeedbackColor();
mitk::RenderingManager::GetInstance()->RequestUpdateAll();
}
bool mitk::PaintbrushTool::CheckIfCurrentSliceHasChanged(const InteractionPositionEvent *event)
{
const PlaneGeometry* planeGeometry((event->GetSender()->GetCurrentWorldPlaneGeometry()));
const auto* abstractTransformGeometry(
dynamic_cast<const AbstractTransformGeometry *>(event->GetSender()->GetCurrentWorldPlaneGeometry()));
if (nullptr == planeGeometry || nullptr != abstractTransformGeometry)
{
return false;
}
bool newPlane = false;
if (m_CurrentPlane.IsNull() || m_WorkingSlice.IsNull()
//or not the same slice
|| !mitk::MatrixEqualElementWise(planeGeometry->GetIndexToWorldTransform()->GetMatrix(),
m_CurrentPlane->GetIndexToWorldTransform()->GetMatrix())
|| !mitk::Equal(planeGeometry->GetIndexToWorldTransform()->GetOffset(),
m_CurrentPlane->GetIndexToWorldTransform()->GetOffset()))
{
m_CurrentPlane = planeGeometry;
newPlane = true;
}
return newPlane;
}
void mitk::PaintbrushTool::ResetWorkingSlice(const InteractionPositionEvent* event)
{
const PlaneGeometry* planeGeometry((event->GetSender()->GetCurrentWorldPlaneGeometry()));
const auto* abstractTransformGeometry(
dynamic_cast<const AbstractTransformGeometry*>(event->GetSender()->GetCurrentWorldPlaneGeometry()));
if (nullptr == planeGeometry || nullptr != abstractTransformGeometry)
{
return;
}
m_WorkingSlice = nullptr;
m_PaintingSlice = nullptr;
m_PaintingNode->SetData(nullptr);
DataNode* workingNode = this->GetToolManager()->GetWorkingData(0);
if (nullptr == workingNode)
{
return;
}
Image::Pointer image = dynamic_cast<Image*>(workingNode->GetData());
if (nullptr == image)
{
return;
}
m_WorkingSlice = SegTool2D::GetAffectedImageSliceAs2DImage(event, image)->Clone();
m_PaintingSlice = Image::New();
m_PaintingSlice->Initialize(m_WorkingSlice);
unsigned int byteSize = m_PaintingSlice->GetPixelType().GetSize();
for (unsigned int dim = 0; dim < m_PaintingSlice->GetDimension(); ++dim)
{
byteSize *= m_PaintingSlice->GetDimension(dim);
}
mitk::ImageWriteAccessor writeAccess(m_PaintingSlice.GetPointer(), m_PaintingSlice->GetVolumeData(0));
memset(writeAccess.GetData(), 0, byteSize);
m_PaintingNode->SetData(m_PaintingSlice);
}
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;
m_PaintingSlice = nullptr;
}
diff --git a/Modules/Segmentation/Interactions/mitkPickingTool.cpp b/Modules/Segmentation/Interactions/mitkPickingTool.cpp
index 6478b66ed6..f544ad8b7b 100644
--- a/Modules/Segmentation/Interactions/mitkPickingTool.cpp
+++ b/Modules/Segmentation/Interactions/mitkPickingTool.cpp
@@ -1,259 +1,259 @@
/*============================================================================
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 <itkImage.h>
#include <itkConnectedThresholdImageFilter.h>
#include <itkOrImageFilter.h>
#include <mitkLabelSetImage.h>
namespace mitk
{
MITK_TOOL_MACRO(MITKSEGMENTATION_EXPORT, PickingTool, "PickingTool");
}
mitk::PickingTool::PickingTool() : SegWithPreviewTool(false, "PressMoveReleaseAndPointSetting")
{
this->ResetsToEmptyPreviewOn();
}
mitk::PickingTool::~PickingTool()
{
}
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("Picking.svg");
return resource;
}
void mitk::PickingTool::Activated()
{
Superclass::Activated();
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_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);
this->GetDataStorage()->Add(m_PointSetNode, this->GetToolManager()->GetWorkingData(0));
}
void mitk::PickingTool::Deactivated()
{
this->ClearSeeds();
// remove from data storage and disable interaction
GetDataStorage()->Remove(m_PointSetNode);
m_PointSetNode = nullptr;
m_PointSet = nullptr;
Superclass::Deactivated();
}
void mitk::PickingTool::ConnectActionsAndFunctions()
{
CONNECT_FUNCTION("ShiftSecondaryButtonPressed", OnAddPoint);
CONNECT_FUNCTION("ShiftPrimaryButtonPressed", OnAddPoint);
CONNECT_FUNCTION("DeletePoint", OnDelete);
}
void mitk::PickingTool::OnAddPoint(StateMachineAction*, InteractionEvent* interactionEvent)
{
if (!this->IsUpdating() && m_PointSet.IsNotNull())
{
const auto positionEvent = dynamic_cast<mitk::InteractionPositionEvent*>(interactionEvent);
if (positionEvent != nullptr)
{
m_PointSet->InsertPoint(m_PointSet->GetSize(), positionEvent->GetPositionInWorld());
this->UpdatePreview();
}
}
}
void mitk::PickingTool::OnDelete(StateMachineAction*, InteractionEvent* /*interactionEvent*/)
{
if (!this->IsUpdating() && m_PointSet.IsNotNull())
{
// delete last seed point
if (this->m_PointSet->GetSize() > 0)
{
m_PointSet->RemovePointAtEnd(0);
this->UpdatePreview();
}
}
}
void mitk::PickingTool::ClearPicks()
{
this->ClearSeeds();
this->UpdatePreview();
}
bool mitk::PickingTool::HasPicks() const
{
return this->m_PointSet.IsNotNull() && this->m_PointSet->GetSize()>0;
}
void mitk::PickingTool::ClearSeeds()
{
if (this->m_PointSet.IsNotNull())
{
// 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 DoITKRegionGrowing(const itk::Image<TPixel, VImageDimension>* oldSegImage,
mitk::Image* segmentation,
const mitk::PointSet* seedPoints,
unsigned int timeStep, const mitk::BaseGeometry* inputGeometry, const mitk::Label::PixelType outputValue,
const mitk::Label::PixelType backgroundValue,
bool& emptyTimeStep)
{
typedef itk::Image<TPixel, VImageDimension> InputImageType;
typedef itk::Image<mitk::Label::PixelType, VImageDimension> OutputImageType;
typedef typename InputImageType::IndexType IndexType;
typedef itk::ConnectedThresholdImageFilter<InputImageType, OutputImageType> RegionGrowingFilterType;
using IndexMapType = std::map < mitk::Label::PixelType, std::vector<IndexType> >;
IndexMapType indexMap;
// convert world coordinates to image indices
for (auto pos = seedPoints->Begin(); pos != seedPoints->End(); ++pos)
{
IndexType seedIndex;
inputGeometry->WorldToIndex(pos->Value(), seedIndex);
const auto selectedLabel = oldSegImage->GetPixel(seedIndex);
if (selectedLabel != backgroundValue)
{
indexMap[selectedLabel].push_back(seedIndex);
}
}
typename OutputImageType::Pointer itkResultImage;
try
{
bool first = true;
typename RegionGrowingFilterType::Pointer regionGrower = RegionGrowingFilterType::New();
regionGrower->SetInput(oldSegImage);
regionGrower->SetReplaceValue(outputValue);
for (const auto& [label, indeces] : indexMap)
{
// perform region growing in desired segmented region
regionGrower->ClearSeeds();
for (const auto& index : indeces)
{
regionGrower->AddSeed(index);
}
regionGrower->SetLower(label);
regionGrower->SetUpper(label);
regionGrower->Update();
if (first)
{
itkResultImage = regionGrower->GetOutput();
}
else
{
typename itk::OrImageFilter<OutputImageType, OutputImageType>::Pointer orFilter =
itk::OrImageFilter<OutputImageType, OutputImageType>::New();
orFilter->SetInput1(regionGrower->GetOutput());
orFilter->SetInput2(itkResultImage);
orFilter->Update();
itkResultImage = orFilter->GetOutput();
}
first = false;
itkResultImage->DisconnectPipeline();
}
}
catch (const itk::ExceptionObject&)
{
return; // can't work
}
catch (...)
{
return;
}
if (itkResultImage.IsNotNull())
{
segmentation->SetVolume((void*)(itkResultImage->GetPixelContainer()->GetBufferPointer()),timeStep);
}
emptyTimeStep = itkResultImage.IsNull();
}
void mitk::PickingTool::DoUpdatePreview(const Image* /*inputAtTimeStep*/, const Image* oldSegAtTimeStep, LabelSetImage* previewImage, TimeStepType timeStep)
{
if (nullptr != oldSegAtTimeStep && nullptr != previewImage && m_PointSet.IsNotNull())
{
bool emptyTimeStep = true;
if (this->HasPicks())
{
const auto activeValue = this->GetActiveLabelValueOfPreview();
this->SetSelectedLabels({activeValue});
- AccessFixedDimensionByItk_n(oldSegAtTimeStep, DoITKRegionGrowing, 3, (previewImage, this->m_PointSet, timeStep, oldSegAtTimeStep->GetGeometry(), activeValue, mitk::LabelSetImage::UnlabeledValue, emptyTimeStep));
+ AccessFixedDimensionByItk_n(oldSegAtTimeStep, DoITKRegionGrowing, 3, (previewImage, this->m_PointSet, timeStep, oldSegAtTimeStep->GetGeometry(), activeValue, mitk::LabelSetImage::UNLABELED_VALUE, emptyTimeStep));
}
if (emptyTimeStep)
{
this->ResetPreviewContentAtTimeStep(timeStep);
}
}
}
diff --git a/Modules/Segmentation/Interactions/mitkSegTool2D.cpp b/Modules/Segmentation/Interactions/mitkSegTool2D.cpp
index 16e31e9cea..d0063c907d 100644
--- a/Modules/Segmentation/Interactions/mitkSegTool2D.cpp
+++ b/Modules/Segmentation/Interactions/mitkSegTool2D.cpp
@@ -1,795 +1,795 @@
/*============================================================================
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 <mitkTimeNavigationController.h>
#include "mitkImageAccessByItk.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>
#include <vtkAbstractArray.h>
#include <vtkFieldData.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 = "DisplayConfigBlockLMB.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;
}
// coronal
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::UpdateAllSurfaceInterpolations(const LabelSetImage *workingImage,
TimeStepType timeStep,
const PlaneGeometry *plane,
bool detectIntersection)
{
if (nullptr == workingImage) mitkThrow() << "Cannot update surface interpolation. Invalid working image passed.";
if (nullptr == plane) mitkThrow() << "Cannot update surface interpolation. Invalid plane passed.";
auto affectedLabels = mitk::SurfaceInterpolationController::GetInstance()->GetAffectedLabels(workingImage, timeStep, plane);
for (auto affectedLabel : affectedLabels)
{
auto groupID = workingImage->GetGroupIndexOfLabel(affectedLabel);
auto slice = GetAffectedImageSliceAs2DImage(plane, workingImage->GetGroupImage(groupID), timeStep);
std::vector<SliceInformation> slices = { SliceInformation(slice, plane, timeStep) };
Self::UpdateSurfaceInterpolation(slices, workingImage, detectIntersection, affectedLabel, true);
}
if(!affectedLabels.empty()) mitk::SurfaceInterpolationController::GetInstance()->Modified();
}
void mitk::SegTool2D::RemoveContourFromInterpolator(const SliceInformation& sliceInfo, LabelSetImage::LabelValueType labelValue)
{
mitk::SurfaceInterpolationController::ContourPositionInformation contourInfo;
contourInfo.LabelValue = labelValue;
contourInfo.TimeStep = sliceInfo.timestep;
contourInfo.Plane = sliceInfo.plane;
mitk::SurfaceInterpolationController::GetInstance()->RemoveContour(contourInfo, true);
}
template <typename ImageType>
void ClearBufferProcessing(ImageType* itkImage)
{
itkImage->FillBuffer(0);
}
void mitk::SegTool2D::UpdateSurfaceInterpolation(const std::vector<SliceInformation>& sliceInfos,
const Image* workingImage,
bool detectIntersection,
mitk::Label::PixelType activeLabelValue, bool silent)
{
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
//Remark we cannot just errode the clone of sliceInfo.slice, because Erode currently only
//works on pixel value 1. But we need to erode active label. Therefore we use TransferLabelContent
//as workarround.
//If MorphologicalOperations::Erode is supports user defined pixel values, the workarround
//can be removed.
//Workarround starts
mitk::Image::Pointer slice2 = Image::New();
slice2->Initialize(sliceInfo.slice);
AccessByItk(slice2, ClearBufferProcessing);
LabelSetImage::LabelValueType erodeValue = 1;
auto label = Label::New(erodeValue, "");
- TransferLabelContent(sliceInfo.slice, slice2, { label }, LabelSetImage::UnlabeledValue, LabelSetImage::UnlabeledValue, false, { {activeLabelValue, erodeValue} });
+ TransferLabelContent(sliceInfo.slice, slice2, { label }, LabelSetImage::UNLABELED_VALUE, LabelSetImage::UNLABELED_VALUE, false, { {activeLabelValue, erodeValue} });
//Workarround ends
mitk::MorphologicalOperations::Erode(slice2, 2, mitk::MorphologicalOperations::Ball);
contourExtractor->SetInput(slice2);
contourExtractor->SetContourValue(erodeValue);
contourExtractor->Update();
mitk::Surface::Pointer contour = contourExtractor->GetOutput();
if (contour->GetVtkPolyData()->GetNumberOfPoints() == 0)
{
Self::RemoveContourFromInterpolator(sliceInfo, activeLabelValue);
}
else
{
relevantSlices.push_back(sliceInfo);
}
}
}
SurfaceInterpolationController::CPIVector cpis;
for (const auto& sliceInfo : relevantSlices)
{
contourExtractor->SetInput(sliceInfo.slice);
contourExtractor->SetContourValue(activeLabelValue);
contourExtractor->Update();
mitk::Surface::Pointer contour = contourExtractor->GetOutput();
if (contour->GetVtkPolyData()->GetNumberOfPoints() == 0)
{
Self::RemoveContourFromInterpolator(sliceInfo, activeLabelValue);
}
else
{
cpis.emplace_back(contour, sliceInfo.plane->Clone(), activeLabelValue, sliceInfo.timestep);
}
}
//this call is relevant even if cpis is empty to ensure SurfaceInterpolationController::Modified is triggered if silent==false;
mitk::SurfaceInterpolationController::GetInstance()->AddNewContours(cpis, false, silent);
}
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();
this->GetToolManager()->SelectedTimePointChanged +=
mitk::MessageDelegate<mitk::SegTool2D>(this, &mitk::SegTool2D::OnTimePointChangedInternal);
m_LastTimePointTriggered = mitk::RenderingManager::GetInstance()->GetTimeNavigationController()->GetSelectedTimePoint();
}
void mitk::SegTool2D::Deactivated()
{
this->GetToolManager()->SelectedTimePointChanged -=
mitk::MessageDelegate<mitk::SegTool2D>(this, &mitk::SegTool2D::OnTimePointChangedInternal);
Superclass::Deactivated();
}
void mitk::SegTool2D::OnTimePointChangedInternal()
{
if (m_IsTimePointChangeAware && nullptr != this->GetWorkingDataNode())
{
const TimePointType 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 != this->GetToolManager())
{
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 != this->GetToolManager())
{
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;
if(m_LastEventSender == nullptr)
{
return;
}
unsigned int currentSlicePosition = m_LastEventSender->GetSliceNavigationController()->GetStepper()->GetPos();
SliceInformation sliceInfo(segmentationResult, const_cast<mitk::PlaneGeometry *>(planeGeometry), timeStep);
sliceInfo.slicePosition = currentSlicePosition;
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();
// 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));
const unsigned int slicePosition = m_LastEventSender->GetSliceNavigationController()->GetStepper()->GetPos();
mitk::SegTool2D::WriteBackSegmentationResults(workingNode, sliceList, writeSliceToVolume);
/* 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());
mitk::Label::PixelType activeLabelValue = 0;
try{
auto labelSetImage = dynamic_cast<mitk::LabelSetImage*>(workingNode->GetData());
activeLabelValue = labelSetImage->GetActiveLabel()->GetValue();
}
catch(...)
{
mitkThrow() << "Working node does not contain labelSetImage.";
}
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())
{
SegTool2D::WriteSliceToVolume(image, sliceInfo, true);
}
}
SegTool2D::UpdateSurfaceInterpolation(sliceList, image, false, activeLabelValue);
// 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);
contourMarker->SetPlaneGeometry(planeGeometry->Clone());
contourMarker->PlaceFigure(p1);
contourMarker->SetCurrentControlPoint(p1);
contourMarker->SetProperty("initiallyplaced", mitk::BoolProperty::New(true));
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)
{
this->GetToolManager()->GetDataStorage()->Add(rotatedContourNode, workingNode);
}
else
{
mitk::NodePredicateProperty::Pointer isMarker =
mitk::NodePredicateProperty::New("isContourMarker", mitk::BoolProperty::New(true));
mitk::DataStorage::SetOfObjects::ConstPointer markers =
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;
}
}
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;
}
bool mitk::SegTool2D::IsPositionEventInsideImageRegion(mitk::InteractionPositionEvent* positionEvent,
const mitk::BaseData* data)
{
bool isPositionEventInsideImageRegion =
nullptr != data && data->GetGeometry()->IsInside(positionEvent->GetPositionInWorld());
if (!isPositionEventInsideImageRegion)
MITK_WARN("EditableContourTool") << "PositionEvent is outside ImageRegion!";
return isPositionEventInsideImageRegion;
}
diff --git a/Modules/Segmentation/Interactions/mitkSegWithPreviewTool.cpp b/Modules/Segmentation/Interactions/mitkSegWithPreviewTool.cpp
index baea11dc30..3e7aa8d51c 100644
--- a/Modules/Segmentation/Interactions/mitkSegWithPreviewTool.cpp
+++ b/Modules/Segmentation/Interactions/mitkSegWithPreviewTool.cpp
@@ -1,840 +1,840 @@
/*============================================================================
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 "mitkSegWithPreviewTool.h"
#include "mitkToolManager.h"
#include "mitkColorProperty.h"
#include "mitkProperties.h"
#include "mitkDataStorage.h"
#include "mitkRenderingManager.h"
#include <mitkTimeNavigationController.h>
#include "mitkImageAccessByItk.h"
#include "mitkImageCast.h"
#include "mitkLabelSetImage.h"
#include "mitkMaskAndCutRoiImageFilter.h"
#include "mitkPadImageFilter.h"
#include "mitkNodePredicateGeometry.h"
#include "mitkSegTool2D.h"
mitk::SegWithPreviewTool::SegWithPreviewTool(bool lazyDynamicPreviews): Tool("dummy"), m_LazyDynamicPreviews(lazyDynamicPreviews)
{
m_ProgressCommand = ToolCommand::New();
}
mitk::SegWithPreviewTool::SegWithPreviewTool(bool lazyDynamicPreviews, const char* interactorType, const us::Module* interactorModule) : Tool(interactorType, interactorModule), m_LazyDynamicPreviews(lazyDynamicPreviews)
{
m_ProgressCommand = ToolCommand::New();
}
mitk::SegWithPreviewTool::~SegWithPreviewTool()
{
}
void mitk::SegWithPreviewTool::SetMergeStyle(MultiLabelSegmentation::MergeStyle mergeStyle)
{
m_MergeStyle = mergeStyle;
this->Modified();
}
void mitk::SegWithPreviewTool::SetOverwriteStyle(MultiLabelSegmentation::OverwriteStyle overwriteStyle)
{
m_OverwriteStyle = overwriteStyle;
this->Modified();
}
void mitk::SegWithPreviewTool::SetLabelTransferScope(LabelTransferScope labelTransferScope)
{
m_LabelTransferScope = labelTransferScope;
this->Modified();
}
void mitk::SegWithPreviewTool::SetLabelTransferMode(LabelTransferMode labelTransferMode)
{
m_LabelTransferMode = labelTransferMode;
this->Modified();
}
void mitk::SegWithPreviewTool::SetSelectedLabels(const SelectedLabelVectorType& labelsToTransfer)
{
m_SelectedLabels = labelsToTransfer;
this->Modified();
}
bool mitk::SegWithPreviewTool::CanHandle(const BaseData* referenceData, const BaseData* workingData) const
{
if (!Superclass::CanHandle(referenceData, workingData))
return false;
if (workingData == nullptr)
return false;
auto* referenceImage = dynamic_cast<const Image*>(referenceData);
if (referenceImage == nullptr)
return false;
auto* labelSet = dynamic_cast<const LabelSetImage*>(workingData);
if (labelSet != nullptr)
return true;
auto* workingImage = dynamic_cast<const Image*>(workingData);
if (workingImage == nullptr)
return false;
// If the working image is a normal image and not a label set image
// it must have the same pixel type as a label set.
return MakeScalarPixelType< DefaultSegmentationDataType >() == workingImage->GetPixelType();
}
void mitk::SegWithPreviewTool::Activated()
{
Superclass::Activated();
this->GetToolManager()->RoiDataChanged +=
MessageDelegate<SegWithPreviewTool>(this, &SegWithPreviewTool::OnRoiDataChanged);
this->GetToolManager()->SelectedTimePointChanged +=
MessageDelegate<SegWithPreviewTool>(this, &SegWithPreviewTool::OnTimePointChanged);
m_ReferenceDataNode = this->GetToolManager()->GetReferenceData(0);
m_SegmentationInputNode = m_ReferenceDataNode;
m_LastTimePointOfUpdate = 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
{
this->GetToolManager()->ActivateTool(-1);
}
}
void mitk::SegWithPreviewTool::Deactivated()
{
this->GetToolManager()->RoiDataChanged -=
MessageDelegate<SegWithPreviewTool>(this, &SegWithPreviewTool::OnRoiDataChanged);
this->GetToolManager()->SelectedTimePointChanged -=
MessageDelegate<SegWithPreviewTool>(this, &SegWithPreviewTool::OnTimePointChanged);
m_SegmentationInputNode = nullptr;
m_ReferenceDataNode = nullptr;
m_WorkingPlaneGeometry = nullptr;
try
{
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::SegWithPreviewTool::ConfirmSegmentation()
{
bool labelChanged = this->EnsureUpToDateUserDefinedActiveLabel();
if ((m_LazyDynamicPreviews && m_CreateAllTimeSteps) || labelChanged)
{ // 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)
{
this->GetToolManager()->ActivateTool(-1);
}
this->ConfirmCleanUp();
}
void mitk::SegWithPreviewTool::InitiateToolByInput()
{
//default implementation does nothing.
//implement in derived classes to change behavior
}
mitk::LabelSetImage* mitk::SegWithPreviewTool::GetPreviewSegmentation()
{
if (m_PreviewSegmentationNode.IsNull())
{
return nullptr;
}
return dynamic_cast<LabelSetImage*>(m_PreviewSegmentationNode->GetData());
}
const mitk::LabelSetImage* mitk::SegWithPreviewTool::GetPreviewSegmentation() const
{
if (m_PreviewSegmentationNode.IsNull())
{
return nullptr;
}
return dynamic_cast<LabelSetImage*>(m_PreviewSegmentationNode->GetData());
}
mitk::DataNode* mitk::SegWithPreviewTool::GetPreviewSegmentationNode()
{
return m_PreviewSegmentationNode;
}
const mitk::Image* mitk::SegWithPreviewTool::GetSegmentationInput() const
{
if (m_SegmentationInputNode.IsNull())
{
return nullptr;
}
return dynamic_cast<const Image*>(m_SegmentationInputNode->GetData());
}
const mitk::Image* mitk::SegWithPreviewTool::GetReferenceData() const
{
if (m_ReferenceDataNode.IsNull())
{
return nullptr;
}
return dynamic_cast<const Image*>(m_ReferenceDataNode->GetData());
}
template <typename ImageType>
void ClearBufferProcessing(ImageType* itkImage)
{
itkImage->FillBuffer(0);
}
void mitk::SegWithPreviewTool::ResetPreviewContentAtTimeStep(unsigned int timeStep)
{
auto previewImage = GetImageByTimeStep(this->GetPreviewSegmentation(), timeStep);
if (nullptr != previewImage)
{
AccessByItk(previewImage, ClearBufferProcessing);
}
}
void mitk::SegWithPreviewTool::ResetPreviewContent()
{
auto previewImage = this->GetPreviewSegmentation();
if (nullptr != previewImage)
{
auto castedPreviewImage =
dynamic_cast<LabelSetImage*>(previewImage);
if (nullptr == castedPreviewImage) mitkThrow() << "Application is on wrong state / invalid tool implementation. Preview image should always be of type LabelSetImage now.";
castedPreviewImage->ClearBuffer();
}
}
void mitk::SegWithPreviewTool::ResetPreviewNode()
{
if (m_IsUpdating)
{
mitkThrow() << "Used tool is implemented incorrectly. ResetPreviewNode is called while preview update is ongoing. Check implementation!";
}
itk::RGBPixel<float> previewColor;
previewColor[0] = 0.0f;
previewColor[1] = 1.0f;
previewColor[2] = 0.0f;
const auto image = this->GetSegmentationInput();
if (nullptr != image)
{
LabelSetImage::ConstPointer workingImage =
dynamic_cast<const 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);
if (newPreviewImage->GetNumberOfLayers() == 0)
{
newPreviewImage->AddLayer();
newPreviewImage->SetActiveLayer(0);
}
auto* activeLabel = newPreviewImage->GetActiveLabel();
if (nullptr == activeLabel)
{
activeLabel = newPreviewImage->AddLabel("toolresult", previewColor, newPreviewImage->GetActiveLayer());
newPreviewImage->UpdateLookupTable(activeLabel->GetValue());
}
else if (m_UseSpecialPreviewColor)
{
// Let's paint the feedback node green...
activeLabel->SetColor(previewColor);
newPreviewImage->UpdateLookupTable(activeLabel->GetValue());
}
activeLabel->SetVisible(true);
}
else
{
Image::ConstPointer workingImageBin = dynamic_cast<const Image*>(this->GetToolManager()->GetWorkingData(0)->GetData());
if (workingImageBin.IsNotNull())
{
Image::Pointer newPreviewImage;
if (this->GetResetsToEmptyPreview())
{
newPreviewImage = 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);
}
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 = this->GetToolManager()->GetDataStorage())
{
if (!ds->Exists(m_PreviewSegmentationNode))
ds->Add(m_PreviewSegmentationNode, m_ReferenceDataNode);
}
}
}
mitk::SegWithPreviewTool::LabelMappingType mitk::SegWithPreviewTool::GetLabelMapping() const
{
LabelSetImage::LabelValueType offset = 0;
if (LabelTransferMode::AddLabel == m_LabelTransferMode && LabelTransferScope::ActiveLabel!=m_LabelTransferScope)
{
//If we are not just working on active label and transfer mode is add, we need to compute an offset for adding the
//preview labels instat of just mapping them to existing segmentation labels.
const auto segmentation = this->GetTargetSegmentation();
if (nullptr == segmentation)
mitkThrow() << "Invalid state of SegWithPreviewTool. Cannot GetLabelMapping if no target segmentation is set.";
auto labels = segmentation->GetLabels();
auto maxLabelIter = std::max_element(std::begin(labels), std::end(labels), [](const Label::Pointer& a, const Label::Pointer& b) {
return a->GetValue() < b->GetValue();
});
if (maxLabelIter != labels.end())
{
offset = maxLabelIter->GetPointer()->GetValue();
}
}
LabelMappingType labelMapping = {};
switch (this->m_LabelTransferScope)
{
case LabelTransferScope::SelectedLabels:
{
for (auto label : this->m_SelectedLabels)
{
labelMapping.push_back({label, label + offset});
}
}
break;
case LabelTransferScope::AllLabels:
{
const auto labelValues = this->GetPreviewSegmentation()->GetLabelValuesByGroup(this->GetPreviewSegmentation()->GetActiveLayer());
for (auto labelValue : labelValues)
{
labelMapping.push_back({ labelValue, labelValue + offset});
}
}
break;
default:
{
if (m_SelectedLabels.empty())
mitkThrow() << "Failed to generate label transfer mapping. Tool is in an invalid state, as "
"LabelTransferScope==ActiveLabel but no label is indicated as selected label. Check "
"implementation of derived tool class.";
if (m_SelectedLabels.size() > 1)
mitkThrow() << "Failed to generate label transfer mapping. Tool is in an invalid state, as "
"LabelTransferScope==ActiveLabel but more then one selected label is indicated."
"Should be only one. Check implementation of derived tool class.";
labelMapping.push_back({m_SelectedLabels.front(), this->GetUserDefinedActiveLabel()});
}
break;
}
return labelMapping;
}
void mitk::SegWithPreviewTool::TransferImageAtTimeStep(const Image* sourceImage, Image* destinationImage, const TimeStepType timeStep, const LabelMappingType& labelMapping)
{
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);
auto resultSlice =
SegTool2D::GetAffectedImageSliceAs2DImage(this->GetWorkingPlaneGeometry(), destinationImage, timeStep)->Clone();
auto destLSImage = dynamic_cast<LabelSetImage *>(destinationImage);
//We need to transfer explictly to a copy of the current working image to ensure that labelMapping is done and things
//like merge style, overwrite style and locks are regarded.
TransferLabelContentAtTimeStep(sourceSlice,
resultSlice,
destLSImage->GetConstLabelsByValue(destLSImage->GetLabelValuesByGroup(destLSImage->GetActiveLayer())),
timeStep,
0,
0,
destLSImage->GetUnlabeledLabelLock(),
labelMapping,
m_MergeStyle,
m_OverwriteStyle);
//We use WriteBackSegmentationResult to ensure undo/redo is supported also by derived tools of this class.
SegTool2D::WriteBackSegmentationResult(this->GetTargetSegmentationNode(), m_WorkingPlaneGeometry, resultSlice, timeStep);
}
else
{ //take care of the full segmentation volume
auto sourceLSImage = dynamic_cast<const LabelSetImage*>(sourceImage);
auto destLSImage = dynamic_cast<LabelSetImage*>(destinationImage);
TransferLabelContentAtTimeStep(sourceLSImage, destLSImage, timeStep, labelMapping, m_MergeStyle, m_OverwriteStyle);
}
}
catch (mitk::Exception& e)
{
Tool::ErrorMessage(e.GetDescription());
mitkReThrow(e);
}
}
void mitk::SegWithPreviewTool::CreateResultSegmentationFromPreview()
{
const auto segInput = this->GetSegmentationInput();
auto previewImage = this->GetPreviewSegmentation();
if (nullptr != segInput && nullptr != previewImage)
{
DataNode::Pointer resultSegmentationNode = GetTargetSegmentationNode();
if (resultSegmentationNode.IsNotNull())
{
const TimePointType timePoint = 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 referenceImage (segmentation provided to the tool). Therefore they have
// the same time geometry.
if (previewImage->GetTimeSteps() != resultSegmentation->GetTimeSteps())
{
mitkThrow() << "Cannot confirm/transfer segmentation. Internal tool state is invalid."
<< " Preview segmentation and segmentation result image have different time geometries.";
}
auto labelMapping = this->GetLabelMapping();
this->PreparePreviewToResultTransfer(labelMapping);
if (m_CreateAllTimeSteps)
{
for (unsigned int timeStep = 0; timeStep < previewImage->GetTimeSteps(); ++timeStep)
{
this->TransferImageAtTimeStep(previewImage, resultSegmentation, timeStep, labelMapping);
}
}
else
{
const auto timeStep = resultSegmentation->GetTimeGeometry()->TimePointToTimeStep(timePoint);
this->TransferImageAtTimeStep(previewImage, resultSegmentation, timeStep, labelMapping);
}
// since we are maybe working on a smaller referenceImage, pad it to the size of the original referenceImage
if (m_ReferenceDataNode.GetPointer() != m_SegmentationInputNode.GetPointer())
{
PadImageFilter::Pointer padFilter = PadImageFilter::New();
padFilter->SetInput(0, resultSegmentation);
padFilter->SetInput(1, dynamic_cast<Image*>(m_ReferenceDataNode->GetData()));
padFilter->SetBinaryFilter(true);
padFilter->SetUpperThreshold(1);
padFilter->SetLowerThreshold(1);
padFilter->Update();
resultSegmentationNode->SetData(padFilter->GetOutput());
}
this->EnsureTargetSegmentationNodeInDataStorage();
}
}
}
void mitk::SegWithPreviewTool::OnRoiDataChanged()
{
DataNode::ConstPointer node = this->GetToolManager()->GetRoiData(0);
if (node.IsNotNull())
{
MaskAndCutRoiImageFilter::Pointer roiFilter = MaskAndCutRoiImageFilter::New();
Image::Pointer image = dynamic_cast<Image *>(m_SegmentationInputNode->GetData());
if (image.IsNull())
return;
roiFilter->SetInput(image);
roiFilter->SetRegionOfInterest(node->GetData());
roiFilter->Update();
DataNode::Pointer tmpNode = DataNode::New();
tmpNode->SetData(roiFilter->GetOutput());
m_SegmentationInputNode = tmpNode;
}
else
m_SegmentationInputNode = m_ReferenceDataNode;
this->ResetPreviewNode();
this->InitiateToolByInput();
this->UpdatePreview();
}
void mitk::SegWithPreviewTool::OnTimePointChanged()
{
if (m_IsTimePointChangeAware && m_PreviewSegmentationNode.IsNotNull() && m_SegmentationInputNode.IsNotNull())
{
const TimePointType timePoint = 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 referenceImage
this->UpdatePreview();
}
}
}
bool mitk::SegWithPreviewTool::EnsureUpToDateUserDefinedActiveLabel()
{
bool labelChanged = true;
const auto workingImage = dynamic_cast<const Image*>(this->GetToolManager()->GetWorkingData(0)->GetData());
if (const auto& labelSetImage = dynamic_cast<const LabelSetImage*>(workingImage))
{
// this is a fix for T28131 / T28986, which should be refactored if T28524 is being worked on
auto newLabel = labelSetImage->GetActiveLabel()->GetValue();
labelChanged = newLabel != m_UserDefinedActiveLabel;
m_UserDefinedActiveLabel = newLabel;
}
else
{
m_UserDefinedActiveLabel = 1;
labelChanged = false;
}
return labelChanged;
}
void mitk::SegWithPreviewTool::UpdatePreview(bool ignoreLazyPreviewSetting)
{
const auto inputImage = this->GetSegmentationInput();
auto previewImage = this->GetPreviewSegmentation();
int progress_steps = 200;
const auto workingImage = dynamic_cast<const Image*>(this->GetToolManager()->GetWorkingData(0)->GetData());
this->EnsureUpToDateUserDefinedActiveLabel();
this->CurrentlyBusy.Send(true);
m_IsUpdating = true;
this->UpdatePrepare();
const TimePointType timePoint = 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 referenceImage.
feedBackImage = SegTool2D::GetAffectedImageSliceAs2DImage(this->GetWorkingPlaneGeometry(), inputImage, inputTimeStep);
currentSegImage = SegTool2D::GetAffectedImageSliceAs2DImageByTimePoint(this->GetWorkingPlaneGeometry(), workingImage, previewTimePoint);
}
else
{ //work on the whole feedback referenceImage
feedBackImage = this->GetImageByTimeStep(inputImage, inputTimeStep);
currentSegImage = this->GetImageByTimePoint(workingImage, previewTimePoint);
}
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, 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::SegWithPreviewTool::IsUpdating() const
{
return m_IsUpdating;
}
void mitk::SegWithPreviewTool::UpdatePrepare()
{
// default implementation does nothing
//reimplement in derived classes for special behavior
}
void mitk::SegWithPreviewTool::UpdateCleanUp()
{
// default implementation does nothing
//reimplement in derived classes for special behavior
}
void mitk::SegWithPreviewTool::ConfirmCleanUp()
{
// default implementation does nothing
// reimplement in derived classes for special behavior
}
void mitk::SegWithPreviewTool::TransferLabelInformation(const LabelMappingType& labelMapping,
const mitk::LabelSetImage* source, mitk::LabelSetImage* target)
{
for (const auto& [sourceLabel, targetLabel] : labelMapping)
{
- if (LabelSetImage::UnlabeledValue != sourceLabel &&
- LabelSetImage::UnlabeledValue != targetLabel &&
+ if (LabelSetImage::UNLABELED_VALUE != sourceLabel &&
+ LabelSetImage::UNLABELED_VALUE != targetLabel &&
!target->ExistLabel(targetLabel, target->GetActiveLayer()))
{
if (!source->ExistLabel(sourceLabel, source->GetActiveLayer()))
{
mitkThrow() << "Cannot prepare segmentation for preview transfer. Preview seems invalid as label is missing. Missing label: " << sourceLabel;
}
auto clonedLabel = source->GetLabel(sourceLabel)->Clone();
clonedLabel->SetValue(targetLabel);
target->AddLabel(clonedLabel,target->GetActiveLayer(), false, false);
}
}
}
void mitk::SegWithPreviewTool::PreparePreviewToResultTransfer(const LabelMappingType& labelMapping)
{
DataNode::Pointer resultSegmentationNode = GetTargetSegmentationNode();
if (resultSegmentationNode.IsNotNull())
{
auto resultSegmentation = dynamic_cast<LabelSetImage*>(resultSegmentationNode->GetData());
if (nullptr == resultSegmentation)
{
mitkThrow() << "Cannot prepare segmentation for preview transfer. Tool is in invalid state as segmentation is not existing or of right type";
}
auto preview = this->GetPreviewSegmentation();
TransferLabelInformation(labelMapping, preview, resultSegmentation);
}
}
mitk::TimePointType mitk::SegWithPreviewTool::GetLastTimePointOfUpdate() const
{
return m_LastTimePointOfUpdate;
}
mitk::LabelSetImage::LabelValueType mitk::SegWithPreviewTool::GetActiveLabelValueOfPreview() const
{
const auto previewImage = this->GetPreviewSegmentation();
const auto activeLabel = previewImage->GetActiveLabel();
if (nullptr == activeLabel)
mitkThrow() << this->GetNameOfClass() <<" is in an invalid state, as "
"preview has no active label indicated. Check "
"implementation of the class.";
return activeLabel->GetValue();
}
const char* mitk::SegWithPreviewTool::GetGroup() const
{
return "autoSegmentation";
}
mitk::Image::ConstPointer mitk::SegWithPreviewTool::GetImageByTimeStep(const mitk::Image* image, TimeStepType timestep)
{
return SelectImageByTimeStep(image, timestep);
}
mitk::Image::Pointer mitk::SegWithPreviewTool::GetImageByTimeStep(mitk::Image* image, TimeStepType timestep)
{
return SelectImageByTimeStep(image, timestep);
}
mitk::Image::ConstPointer mitk::SegWithPreviewTool::GetImageByTimePoint(const mitk::Image* image, TimePointType timePoint)
{
return SelectImageByTimePoint(image, timePoint);
}
void mitk::SegWithPreviewTool::EnsureTargetSegmentationNodeInDataStorage() const
{
auto targetNode = this->GetTargetSegmentationNode();
auto dataStorage = this->GetToolManager()->GetDataStorage();
if (!dataStorage->Exists(targetNode))
{
dataStorage->Add(targetNode, this->GetToolManager()->GetReferenceData(0));
}
}
std::string mitk::SegWithPreviewTool::GetCurrentSegmentationName()
{
auto workingData = this->GetToolManager()->GetWorkingData(0);
return nullptr != workingData
? workingData->GetName()
: "";
}
mitk::DataNode* mitk::SegWithPreviewTool::GetTargetSegmentationNode() const
{
return this->GetToolManager()->GetWorkingData(0);
}
mitk::LabelSetImage* mitk::SegWithPreviewTool::GetTargetSegmentation() const
{
auto node = this->GetTargetSegmentationNode();
if (nullptr == node)
return nullptr;
return dynamic_cast<LabelSetImage*>(node->GetData());
}
void mitk::SegWithPreviewTool::TransferLabelSetImageContent(const LabelSetImage* source, LabelSetImage* target, TimeStepType timeStep)
{
mitk::ImageReadAccessor newMitkImgAcc(source);
LabelMappingType labelMapping;
const auto labelValues = source->GetLabelValuesByGroup(source->GetActiveLayer());
for (const auto& labelValue : labelValues)
{
labelMapping.push_back({ labelValue,labelValue });
}
TransferLabelInformation(labelMapping, source, target);
target->SetVolume(newMitkImgAcc.GetData(), timeStep);
}
diff --git a/Modules/SegmentationUI/Qmitk/QmitkMultiLabelTreeModel.cpp b/Modules/SegmentationUI/Qmitk/QmitkMultiLabelTreeModel.cpp
index e5a4cc1618..9783a7dfbd 100644
--- a/Modules/SegmentationUI/Qmitk/QmitkMultiLabelTreeModel.cpp
+++ b/Modules/SegmentationUI/Qmitk/QmitkMultiLabelTreeModel.cpp
@@ -1,1021 +1,1021 @@
/*============================================================================
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 "QmitkMultiLabelTreeModel.h"
#include "mitkRenderingManager.h"
#include "QmitkStyleManager.h"
class QmitkMultiLabelSegTreeItem
{
public:
enum class ItemType
{
Group,
Label,
Instance
};
QmitkMultiLabelSegTreeItem()
{
};
explicit QmitkMultiLabelSegTreeItem(ItemType type, QmitkMultiLabelSegTreeItem* parentItem,
mitk::Label* label = nullptr, std::string className = ""): m_parentItem(parentItem), m_ItemType(type), m_Label(label), m_ClassName(className)
{
};
~QmitkMultiLabelSegTreeItem()
{
for (auto item : m_childItems)
{
delete item;
}
};
void AppendChild(QmitkMultiLabelSegTreeItem* child)
{
m_childItems.push_back(child);
};
void RemoveChild(std::size_t row)
{
if (row < m_childItems.size())
{
delete m_childItems[row];
m_childItems.erase(m_childItems.begin() + row);
}
};
int Row() const
{
if (m_parentItem)
{
auto finding = std::find(m_parentItem->m_childItems.begin(), m_parentItem->m_childItems.end(), this);
if (finding != m_parentItem->m_childItems.end())
{
return std::distance(m_parentItem->m_childItems.begin(), finding);
}
}
return 0;
};
QmitkMultiLabelSegTreeItem* ParentItem()
{
return m_parentItem;
};
const QmitkMultiLabelSegTreeItem* ParentItem() const
{
return m_parentItem;
};
const QmitkMultiLabelSegTreeItem* NextSibblingItem() const
{
if (m_parentItem)
{
const std::vector<QmitkMultiLabelSegTreeItem*>::size_type row = this->Row();
if (row + 1 < m_parentItem->m_childItems.size())
return m_parentItem->m_childItems[row+1];
}
return nullptr;
};
const QmitkMultiLabelSegTreeItem* PrevSibblingItem() const
{
if (m_parentItem)
{
const std::vector<QmitkMultiLabelSegTreeItem*>::size_type row = this->Row();
if (row > 0)
return m_parentItem->m_childItems[row-1];
}
return nullptr;
};
const QmitkMultiLabelSegTreeItem* RootItem() const
{
auto item = this;
while (item->m_parentItem != nullptr)
{
item = item->m_parentItem;
}
return item;
};
std::size_t GetGroupID() const
{
auto root = this->RootItem();
auto item = this;
if (root == this) return 0;
while (root != item->m_parentItem)
{
item = item->m_parentItem;
}
auto iter = std::find(root->m_childItems.begin(), root->m_childItems.end(), item);
if (root->m_childItems.end() == iter) mitkThrow() << "Invalid internal state of QmitkMultiLabelTreeModel. Root does not have an currentItem as child that has root as parent.";
return std::distance(root->m_childItems.begin(), iter);
}
bool HandleAsInstance() const
{
return (ItemType::Instance == m_ItemType) || ((ItemType::Label == m_ItemType) && (m_childItems.size() == 1));
}
mitk::Label* GetLabel() const
{
if (ItemType::Instance == m_ItemType)
{
return m_Label;
}
if (ItemType::Label == m_ItemType)
{
if (m_childItems.empty()) mitkThrow() << "Invalid internal state of QmitkMultiLabelTreeModel. Internal label currentItem has no instance currentItem.";
return m_childItems[0]->GetLabel();
}
return nullptr;
};
mitk::LabelSetImage::LabelValueType GetLabelValue() const
{
auto label = this->GetLabel();
if (nullptr == label)
{
mitkThrow() << "Invalid internal state of QmitkMultiLabelTreeModel. Called GetLabelValue on an group currentItem.";
}
return label->GetValue();
};
/** returns a vector containing all label values of referenced by this item or its child items.*/
std::vector< mitk::LabelSetImage::LabelValueType> GetLabelsInSubTree() const
{
if (this->m_ItemType == ItemType::Instance)
{
return { this->GetLabelValue() };
}
std::vector< mitk::LabelSetImage::LabelValueType> result;
for (const auto child : this->m_childItems)
{
auto childresult = child->GetLabelsInSubTree();
result.reserve(result.size() + childresult.size());
result.insert(result.end(), childresult.begin(), childresult.end());
}
return result;
}
std::vector<QmitkMultiLabelSegTreeItem*> m_childItems;
QmitkMultiLabelSegTreeItem* m_parentItem = nullptr;
ItemType m_ItemType = ItemType::Group;
mitk::Label::Pointer m_Label;
std::string m_ClassName;
};
QModelIndex GetIndexByItem(const QmitkMultiLabelSegTreeItem* start, const QmitkMultiLabelTreeModel* model)
{
QModelIndex parentIndex = QModelIndex();
if (nullptr != start->m_parentItem)
{
parentIndex = GetIndexByItem(start->m_parentItem, model);
}
else
{
return parentIndex;
}
return model->index(start->Row(), 0, parentIndex);
}
QmitkMultiLabelSegTreeItem* GetGroupItem(QmitkMultiLabelTreeModel::GroupIndexType groupIndex, QmitkMultiLabelSegTreeItem* root)
{
if (nullptr != root && groupIndex < root->m_childItems.size())
{
return root->m_childItems[groupIndex];
}
return nullptr;
}
QmitkMultiLabelSegTreeItem* GetInstanceItem(QmitkMultiLabelTreeModel::LabelValueType labelValue, QmitkMultiLabelSegTreeItem* root)
{
QmitkMultiLabelSegTreeItem* result = nullptr;
for (auto item : root->m_childItems)
{
result = GetInstanceItem(labelValue, item);
if (nullptr != result) return result;
}
if (root->m_ItemType == QmitkMultiLabelSegTreeItem::ItemType::Instance && root->GetLabelValue() == labelValue)
{
return root;
}
return nullptr;
}
const QmitkMultiLabelSegTreeItem* GetFirstInstanceLikeItem(const QmitkMultiLabelSegTreeItem* startItem)
{
const QmitkMultiLabelSegTreeItem* result = nullptr;
if (nullptr != startItem)
{
if (startItem->HandleAsInstance())
{
result = startItem;
}
else if (!startItem->m_childItems.empty())
{
result = GetFirstInstanceLikeItem(startItem->m_childItems.front());
}
}
return result;
}
QmitkMultiLabelSegTreeItem* GetLabelItemInGroup(const std::string& labelName, QmitkMultiLabelSegTreeItem* group)
{
if (nullptr != group)
{
auto predicate = [labelName](const QmitkMultiLabelSegTreeItem* item) { return labelName == item->m_ClassName; };
auto finding = std::find_if(group->m_childItems.begin(), group->m_childItems.end(), predicate);
if (group->m_childItems.end() != finding)
{
return *finding;
}
}
return nullptr;
}
QmitkMultiLabelTreeModel::QmitkMultiLabelTreeModel(QObject *parent) : QAbstractItemModel(parent)
, m_Observed(false)
{
m_RootItem = std::make_unique<QmitkMultiLabelSegTreeItem>();
}
QmitkMultiLabelTreeModel ::~QmitkMultiLabelTreeModel()
{
this->SetSegmentation(nullptr);
};
int QmitkMultiLabelTreeModel::columnCount(const QModelIndex& /*parent*/) const
{
return 4;
}
int QmitkMultiLabelTreeModel::rowCount(const QModelIndex &parent) const
{
if (parent.column() > 0)
return 0;
if (m_Segmentation.IsNull())
return 0;
QmitkMultiLabelSegTreeItem* parentItem = m_RootItem.get();
if (parent.isValid())
parentItem = static_cast<QmitkMultiLabelSegTreeItem *>(parent.internalPointer());
if (parentItem->HandleAsInstance())
{
return 0;
}
return parentItem->m_childItems.size();
}
QVariant QmitkMultiLabelTreeModel::data(const QModelIndex &index, int role) const
{
if (!index.isValid())
return QVariant();
auto item = static_cast<QmitkMultiLabelSegTreeItem*>(index.internalPointer());
if (!item)
return QVariant();
if (role == Qt::DisplayRole||role == Qt::EditRole)
{
if (TableColumns::NAME_COL == index.column())
{
switch (item->m_ItemType)
{
case QmitkMultiLabelSegTreeItem::ItemType::Group:
return QVariant(QString("Group %1").arg(item->GetGroupID()));
case QmitkMultiLabelSegTreeItem::ItemType::Label:
{
auto label = item->GetLabel();
if (nullptr == label)
mitkThrow() << "Invalid internal state. QmitkMultiLabelTreeModel currentItem is refering to a label that does not exist.";
QString name = QString::fromStdString(label->GetName());
if (!item->HandleAsInstance())
name = name + QString(" (%1 instances)").arg(item->m_childItems.size());
return QVariant(name);
}
case QmitkMultiLabelSegTreeItem::ItemType::Instance:
{
auto label = item->GetLabel();
if (nullptr == label)
mitkThrow() << "Invalid internal state. QmitkMultiLabelTreeModel currentItem is refering to a label that does not exist.";
return QVariant(QString::fromStdString(label->GetName()) + QString(" [%1]").arg(item->GetLabelValue()));
}
}
}
else
{
if (item->HandleAsInstance())
{
auto label = item->GetLabel();
if (TableColumns::LOCKED_COL == index.column())
{
return QVariant(label->GetLocked());
}
else if (TableColumns::COLOR_COL == index.column())
{
return QVariant(QColor(label->GetColor().GetRed() * 255, label->GetColor().GetGreen() * 255, label->GetColor().GetBlue() * 255));
}
else if (TableColumns::VISIBLE_COL == index.column())
{
return QVariant(label->GetVisible());
}
}
}
}
else if (role == ItemModelRole::LabelDataRole)
{
auto label = item->GetLabel();
if (nullptr!=label) return QVariant::fromValue<void*>(label);
}
else if (role == ItemModelRole::LabelValueRole)
{
auto label = item->GetLabel();
if (nullptr != label) return QVariant(label->GetValue());
}
else if (role == ItemModelRole::LabelInstanceDataRole)
{
if (item->HandleAsInstance())
{
auto label = item->GetLabel();
return QVariant::fromValue<void*>(label);
}
}
else if (role == ItemModelRole::LabelInstanceValueRole)
{
if (item->HandleAsInstance())
{
auto label = item->GetLabel();
return QVariant(label->GetValue());
}
}
else if (role == ItemModelRole::GroupIDRole)
{
QVariant v;
v.setValue(item->GetGroupID());
return v;
}
return QVariant();
}
mitk::Color QtToMitk(const QColor& color)
{
mitk::Color mitkColor;
mitkColor.SetRed(color.red() / 255.0f);
mitkColor.SetGreen(color.green() / 255.0f);
mitkColor.SetBlue(color.blue() / 255.0f);
return mitkColor;
}
bool QmitkMultiLabelTreeModel::setData(const QModelIndex& index, const QVariant& value, int role)
{
if (!index.isValid())
return false;
auto item = static_cast<QmitkMultiLabelSegTreeItem*>(index.internalPointer());
if (!item)
return false;
if (role == Qt::EditRole)
{
if (TableColumns::NAME_COL != index.column())
{
if (item->HandleAsInstance())
{
auto label = item->GetLabel();
if (TableColumns::LOCKED_COL == index.column())
{
label->SetLocked(value.toBool());
}
else if (TableColumns::COLOR_COL == index.column())
{
label->SetColor(QtToMitk(value.value<QColor>()));
}
else if (TableColumns::VISIBLE_COL == index.column())
{
label->SetVisible(value.toBool());
}
auto groupID = m_Segmentation->GetGroupIndexOfLabel(label->GetValue());
m_Segmentation->UpdateLookupTable(label->GetValue());
m_Segmentation->Modified();
mitk::RenderingManager::GetInstance()->RequestUpdateAll();
}
else
{
}
return true;
}
}
return false;
}
QModelIndex QmitkMultiLabelTreeModel::index(int row, int column, const QModelIndex &parent) const
{
if (!hasIndex(row, column, parent))
return QModelIndex();
auto parentItem = m_RootItem.get();
if (parent.isValid())
parentItem = static_cast<QmitkMultiLabelSegTreeItem *>(parent.internalPointer());
QmitkMultiLabelSegTreeItem *childItem = parentItem->m_childItems[row];
if (childItem)
return createIndex(row, column, childItem);
else
return QModelIndex();
}
QModelIndex QmitkMultiLabelTreeModel::indexOfLabel(mitk::Label::PixelType labelValue) const
{
- if (labelValue == mitk::LabelSetImage::UnlabeledValue) return QModelIndex();
+ if (labelValue == mitk::LabelSetImage::UNLABELED_VALUE) return QModelIndex();
auto relevantItem = GetInstanceItem(labelValue, this->m_RootItem.get());
if (nullptr == relevantItem)
return QModelIndex();
auto labelItem = relevantItem->ParentItem();
if (labelItem->m_childItems.size() == 1)
{ //was the only instance of the label, therefor return the label item instat.
relevantItem = labelItem;
}
return GetIndexByItem(relevantItem, this);
}
QModelIndex QmitkMultiLabelTreeModel::indexOfGroup(mitk::LabelSetImage::GroupIndexType groupIndex) const
{
auto relevantItem = GetGroupItem(groupIndex, this->m_RootItem.get());
if (nullptr == relevantItem) QModelIndex();
return GetIndexByItem(relevantItem, this);
}
QModelIndex QmitkMultiLabelTreeModel::parent(const QModelIndex &child) const
{
if (!child.isValid())
return QModelIndex();
QmitkMultiLabelSegTreeItem *childItem = static_cast<QmitkMultiLabelSegTreeItem *>(child.internalPointer());
QmitkMultiLabelSegTreeItem *parentItem = childItem->ParentItem();
if (parentItem == m_RootItem.get())
return QModelIndex();
return createIndex(parentItem->Row(), 0, parentItem);
}
QModelIndex QmitkMultiLabelTreeModel::ClosestLabelInstanceIndex(const QModelIndex& currentIndex) const
{
if (!currentIndex.isValid()) return QModelIndex();
auto currentItem = static_cast<const QmitkMultiLabelSegTreeItem*>(currentIndex.internalPointer());
if (!currentItem) return QModelIndex();
if (currentItem->RootItem() != this->m_RootItem.get()) mitkThrow() << "Invalid call. Passed currentIndex does not seem to be a valid index of this model. It is either outdated or from another model.";
const QmitkMultiLabelSegTreeItem* resultItem = nullptr;
auto searchItem = currentItem;
const auto rootItem = currentItem->RootItem();
while (searchItem != rootItem)
{
const auto* sibling = searchItem;
while (sibling != nullptr)
{
sibling = sibling->NextSibblingItem();
resultItem = GetFirstInstanceLikeItem(sibling);
if (nullptr != resultItem)
break;
}
if (nullptr != resultItem)
break;
// No next closest label instance on this level -> check for closest before
sibling = searchItem;
while (sibling != nullptr)
{
sibling = sibling->PrevSibblingItem();
resultItem = GetFirstInstanceLikeItem(sibling);
if (nullptr != resultItem)
break;
}
if (nullptr != resultItem)
break;
// No closest label instance before current on this level -> moeve one level up
searchItem = searchItem->ParentItem();
}
if (nullptr == resultItem)
return QModelIndex();
return GetIndexByItem(resultItem, this);
}
QModelIndex QmitkMultiLabelTreeModel::FirstLabelInstanceIndex(const QModelIndex& currentIndex) const
{
const QmitkMultiLabelSegTreeItem* currentItem = nullptr;
if (!currentIndex.isValid())
{
currentItem = this->m_RootItem.get();
}
else
{
currentItem = static_cast<const QmitkMultiLabelSegTreeItem*>(currentIndex.internalPointer());
}
if (!currentItem) return QModelIndex();
if (currentItem->RootItem() != this->m_RootItem.get()) mitkThrow() << "Invalid call. Passed currentIndex does not seem to be a valid index of this model. It is either outdated or from another model.";
const QmitkMultiLabelSegTreeItem* resultItem = nullptr;
resultItem = GetFirstInstanceLikeItem(currentItem);
if (nullptr == resultItem)
return QModelIndex();
return GetIndexByItem(resultItem, this);
}
///** Returns the index to the next node in the tree that behaves like an instance (label node with only one instance
//or instance node). If current index is at the end, an invalid index is returned.*/
//QModelIndex QmitkMultiLabelTreeModel::PrevLabelInstanceIndex(const QModelIndex& currentIndex) const;
std::vector <QmitkMultiLabelTreeModel::LabelValueType> QmitkMultiLabelTreeModel::GetLabelsInSubTree(const QModelIndex& currentIndex) const
{
const QmitkMultiLabelSegTreeItem* currentItem = nullptr;
if (!currentIndex.isValid())
{
currentItem = this->m_RootItem.get();
}
else
{
currentItem = static_cast<const QmitkMultiLabelSegTreeItem*>(currentIndex.internalPointer());
}
if (!currentItem) return {};
return currentItem->GetLabelsInSubTree();
}
std::vector <QmitkMultiLabelTreeModel::LabelValueType> QmitkMultiLabelTreeModel::GetLabelInstancesOfSameLabelClass(const QModelIndex& currentIndex) const
{
const QmitkMultiLabelSegTreeItem* currentItem = nullptr;
if (currentIndex.isValid())
{
currentItem = static_cast<const QmitkMultiLabelSegTreeItem*>(currentIndex.internalPointer());
}
if (!currentItem)
return {};
if (QmitkMultiLabelSegTreeItem::ItemType::Group == currentItem->m_ItemType)
return {};
if (QmitkMultiLabelSegTreeItem::ItemType::Instance == currentItem->m_ItemType)
currentItem = currentItem->ParentItem();
return currentItem->GetLabelsInSubTree();
}
Qt::ItemFlags QmitkMultiLabelTreeModel::flags(const QModelIndex &index) const
{
if (!index.isValid())
return Qt::NoItemFlags;
if (!index.isValid())
return Qt::NoItemFlags;
auto item = static_cast<QmitkMultiLabelSegTreeItem*>(index.internalPointer());
if (!item)
return Qt::NoItemFlags;
if (TableColumns::NAME_COL != index.column())
{
if (item->HandleAsInstance() &&
((TableColumns::VISIBLE_COL == index.column() && m_AllowVisibilityModification) ||
(TableColumns::COLOR_COL == index.column() && m_AllowVisibilityModification) || //m_AllowVisibilityModification controls visibility and color
(TableColumns::LOCKED_COL == index.column() && m_AllowLockModification)))
{
return Qt::ItemIsEnabled | Qt::ItemIsEditable;
}
else
{
return Qt::ItemIsEnabled;
}
}
else
{
if (item->HandleAsInstance())
{
return Qt::ItemIsEnabled | Qt::ItemIsSelectable;
}
else
{
return Qt::ItemIsEnabled;
}
}
return Qt::NoItemFlags;
}
QVariant QmitkMultiLabelTreeModel::headerData(int section, Qt::Orientation orientation, int role) const
{
if ((Qt::DisplayRole == role) && (Qt::Horizontal == orientation))
{
if (TableColumns::NAME_COL == section)
{
return "Name";
}
else if (TableColumns::LOCKED_COL == section)
{
return "Locked";
}
else if (TableColumns::COLOR_COL == section)
{
return "Color";
}
else if (TableColumns::VISIBLE_COL == section)
{
return "Visibility";
}
}
return QVariant();
}
const mitk::LabelSetImage* QmitkMultiLabelTreeModel::GetSegmentation() const
{
return m_Segmentation;
}
void QmitkMultiLabelTreeModel::SetSegmentation(mitk::LabelSetImage* segmentation)
{
if (m_Segmentation != segmentation)
{
this->RemoveObserver();
this->m_Segmentation = segmentation;
this->AddObserver();
this->UpdateInternalTree();
}
}
/**Helper function that adds a labek into the item tree. Passes back the new created instance iten*/
QmitkMultiLabelSegTreeItem* AddLabelToGroupTree(mitk::Label* label, QmitkMultiLabelSegTreeItem* groupItem, bool& newLabelItemCreated)
{
if (nullptr == groupItem) return nullptr;
if (nullptr == label) return nullptr;
newLabelItemCreated = false;
std::set<std::string> labelNames;
for (auto labelItem : groupItem->m_childItems)
{
labelNames.emplace(labelItem->GetLabel()->GetName());
}
QmitkMultiLabelSegTreeItem* labelItem = nullptr;
auto finding = labelNames.find(label->GetName());
if (finding != labelNames.end())
{ //other label with same name exists
labelItem = groupItem->m_childItems[std::distance(labelNames.begin(), finding)];
}
else
{
newLabelItemCreated = true;
labelItem = new QmitkMultiLabelSegTreeItem(QmitkMultiLabelSegTreeItem::ItemType::Label, groupItem, nullptr, label->GetName());
auto predicate = [label](const std::string& name) { return name > label->GetName(); };
auto insertFinding = std::find_if(labelNames.begin(), labelNames.end(), predicate);
groupItem->m_childItems.insert(groupItem->m_childItems.begin() + std::distance(labelNames.begin(), insertFinding), labelItem);
}
auto instanceItem = new QmitkMultiLabelSegTreeItem(QmitkMultiLabelSegTreeItem::ItemType::Instance, labelItem, label);
auto predicate = [label](const QmitkMultiLabelSegTreeItem* item) { return item->GetLabelValue() > label->GetValue(); };
auto insertFinding = std::find_if(labelItem->m_childItems.begin(), labelItem->m_childItems.end(), predicate);
labelItem->m_childItems.insert(labelItem->m_childItems.begin() + std::distance(labelItem->m_childItems.begin(), insertFinding), instanceItem);
return instanceItem;
}
void QmitkMultiLabelTreeModel::GenerateInternalGroupTree(unsigned int groupID, QmitkMultiLabelSegTreeItem* groupItem)
{
auto labels = m_Segmentation->GetLabelsByValue(m_Segmentation->GetLabelValuesByGroup(groupID));
for (auto& label : labels)
{
- if (label->GetValue()== mitk::LabelSetImage::UnlabeledValue) continue;
+ if (label->GetValue()== mitk::LabelSetImage::UNLABELED_VALUE) continue;
bool newItemCreated = false;
AddLabelToGroupTree(label, groupItem, newItemCreated);
}
}
QmitkMultiLabelSegTreeItem* QmitkMultiLabelTreeModel::GenerateInternalTree()
{
auto rootItem = new QmitkMultiLabelSegTreeItem();
if (m_Segmentation.IsNotNull())
{
for (unsigned int groupID = 0; groupID < m_Segmentation->GetNumberOfLayers(); ++groupID)
{
auto groupItem = new QmitkMultiLabelSegTreeItem(QmitkMultiLabelSegTreeItem::ItemType::Group, rootItem);
rootItem->AppendChild(groupItem);
GenerateInternalGroupTree(groupID, groupItem);
}
}
return rootItem;
}
void QmitkMultiLabelTreeModel::UpdateInternalTree()
{
emit beginResetModel();
auto newTree = this->GenerateInternalTree();
this->m_RootItem.reset(newTree);
emit endResetModel();
emit modelChanged();
}
void QmitkMultiLabelTreeModel::AddObserver()
{
if (this->m_Segmentation.IsNotNull())
{
if (m_Observed)
{
MITK_DEBUG << "Invalid observer state in QmitkMultiLabelTreeModel. There is already a registered observer. Internal logic is not correct. May be an old observer was not removed.";
}
this->m_Segmentation->AddLabelAddedListener(mitk::MessageDelegate1<QmitkMultiLabelTreeModel, LabelValueType>(
this, &QmitkMultiLabelTreeModel::OnLabelAdded));
this->m_Segmentation->AddLabelModifiedListener(mitk::MessageDelegate1<QmitkMultiLabelTreeModel, LabelValueType>(
this, &QmitkMultiLabelTreeModel::OnLabelModified));
this->m_Segmentation->AddLabelRemovedListener(mitk::MessageDelegate1<QmitkMultiLabelTreeModel, LabelValueType>(
this, &QmitkMultiLabelTreeModel::OnLabelRemoved));
this->m_Segmentation->AddGroupAddedListener(mitk::MessageDelegate1<QmitkMultiLabelTreeModel, GroupIndexType>(
this, &QmitkMultiLabelTreeModel::OnGroupAdded));
this->m_Segmentation->AddGroupModifiedListener(mitk::MessageDelegate1<QmitkMultiLabelTreeModel, GroupIndexType>(
this, &QmitkMultiLabelTreeModel::OnGroupModified));
this->m_Segmentation->AddGroupRemovedListener(mitk::MessageDelegate1<QmitkMultiLabelTreeModel, GroupIndexType>(
this, &QmitkMultiLabelTreeModel::OnGroupRemoved));
m_Observed = true;
}
}
void QmitkMultiLabelTreeModel::RemoveObserver()
{
if (this->m_Segmentation.IsNotNull())
{
this->m_Segmentation->RemoveLabelAddedListener(mitk::MessageDelegate1<QmitkMultiLabelTreeModel, LabelValueType>(
this, &QmitkMultiLabelTreeModel::OnLabelAdded));
this->m_Segmentation->RemoveLabelModifiedListener(mitk::MessageDelegate1<QmitkMultiLabelTreeModel, LabelValueType>(
this, &QmitkMultiLabelTreeModel::OnLabelModified));
this->m_Segmentation->RemoveLabelRemovedListener(mitk::MessageDelegate1<QmitkMultiLabelTreeModel, LabelValueType>(
this, &QmitkMultiLabelTreeModel::OnLabelRemoved));
this->m_Segmentation->RemoveGroupAddedListener(mitk::MessageDelegate1<QmitkMultiLabelTreeModel, GroupIndexType>(
this, &QmitkMultiLabelTreeModel::OnGroupAdded));
this->m_Segmentation->RemoveGroupModifiedListener(mitk::MessageDelegate1<QmitkMultiLabelTreeModel, GroupIndexType>(
this, &QmitkMultiLabelTreeModel::OnGroupModified));
this->m_Segmentation->RemoveGroupRemovedListener(mitk::MessageDelegate1<QmitkMultiLabelTreeModel, GroupIndexType>(
this, &QmitkMultiLabelTreeModel::OnGroupRemoved));
}
m_Observed = false;
}
void QmitkMultiLabelTreeModel::OnLabelAdded(LabelValueType labelValue)
{
GroupIndexType groupIndex = 0;
if (m_Segmentation->IsLabelInGroup(labelValue, groupIndex))
{
auto label = m_Segmentation->GetLabel(labelValue);
if (nullptr == label) mitkThrow() << "Invalid internal state. Segmentation signaled the addition of an label that does not exist in the segmentation. Invalid label value:" << labelValue;
- if (labelValue == mitk::LabelSetImage::UnlabeledValue) return;
+ if (labelValue == mitk::LabelSetImage::UNLABELED_VALUE) return;
auto groupItem = GetGroupItem(groupIndex, this->m_RootItem.get());
bool newLabelCreated = false;
auto instanceItem = AddLabelToGroupTree(label, groupItem, newLabelCreated);
if (newLabelCreated)
{
if (groupItem->m_childItems.size() == 1)
{ //first label added
auto groupIndex = GetIndexByItem(groupItem, this);
emit dataChanged(groupIndex, groupIndex);
this->beginInsertRows(groupIndex, instanceItem->ParentItem()->Row(), instanceItem->ParentItem()->Row());
this->endInsertRows();
}
else
{ //whole new label level added to group item
auto groupIndex = GetIndexByItem(groupItem, this);
this->beginInsertRows(groupIndex, instanceItem->ParentItem()->Row(), instanceItem->ParentItem()->Row());
this->endInsertRows();
}
}
else
{
if (instanceItem->ParentItem()->m_childItems.size() < 3)
{ //second instance item was added, so label item will now able to colapse
// -> the whole label node has to be updated.
auto labelIndex = GetIndexByItem(instanceItem->ParentItem(), this);
emit dataChanged(labelIndex, labelIndex);
this->beginInsertRows(labelIndex, 0, instanceItem->ParentItem()->m_childItems.size()-1);
this->endInsertRows();
}
else
{
// instance item was added to existing label item with multiple instances
//-> just notify the row insertion
auto labelIndex = GetIndexByItem(instanceItem->ParentItem(), this);
this->beginInsertRows(labelIndex, instanceItem->Row(), instanceItem->Row());
this->endInsertRows();
}
}
}
else
{
mitkThrow() << "Group less labels are not supported in the current implementation.";
}
}
void QmitkMultiLabelTreeModel::OnLabelModified(LabelValueType labelValue)
{
- if (labelValue == mitk::LabelSetImage::UnlabeledValue) return;
+ if (labelValue == mitk::LabelSetImage::UNLABELED_VALUE) return;
auto instanceItem = GetInstanceItem(labelValue, this->m_RootItem.get());
if (nullptr == instanceItem)
{
mitkThrow() << "Internal invalid state. QmitkMultiLabelTreeModel recieved a LabelModified signal for a label that is not represented in the model. Invalid label: " << labelValue;
}
auto labelItem = instanceItem->ParentItem();
if (labelItem->m_ClassName == instanceItem->GetLabel()->GetName())
{ //only the state of the label changed, but not its position in the model tree.
auto index = GetIndexByItem(labelItem, this);
emit dataChanged(index, index);
}
else
{ //the name of the label changed and thus its place in the model tree, delete the current item and add a new one
this->OnLabelRemoved(labelValue);
this->OnLabelAdded(labelValue);
}
}
void QmitkMultiLabelTreeModel::OnLabelRemoved(LabelValueType labelValue)
{
- if (labelValue == mitk::LabelSetImage::UnlabeledValue) return;
+ if (labelValue == mitk::LabelSetImage::UNLABELED_VALUE) return;
auto instanceItem = GetInstanceItem(labelValue, this->m_RootItem.get());
if (nullptr == instanceItem) mitkThrow() << "Internal invalid state. QmitkMultiLabelTreeModel recieved a LabelRemoved signal for a label that is not represented in the model. Invalid label: " << labelValue;
auto labelItem = instanceItem->ParentItem();
if (labelItem->m_childItems.size() > 2)
{
auto labelIndex = GetIndexByItem(labelItem, this);
this->beginRemoveRows(labelIndex, instanceItem->Row(), instanceItem->Row());
labelItem->RemoveChild(instanceItem->Row());
this->endRemoveRows();
}
else if (labelItem->m_childItems.size() == 2)
{ //After removal only one label is left -> the whole label node is about to be changed (no instances are shown any more).
auto labelIndex = GetIndexByItem(labelItem, this);
this->beginRemoveRows(labelIndex, instanceItem->Row(), instanceItem->Row());
labelItem->RemoveChild(instanceItem->Row());
this->endRemoveRows();
emit dataChanged(labelIndex, labelIndex);
}
else
{ //was the only instance of the label, therefor also remove the label node from the tree.
auto groupItem = labelItem->ParentItem();
auto groupIndex = GetIndexByItem(groupItem, this);
this->beginRemoveRows(groupIndex, labelItem->Row(), labelItem->Row());
groupItem->RemoveChild(labelItem->Row());
this->endRemoveRows();
}
}
void QmitkMultiLabelTreeModel::OnGroupAdded(GroupIndexType groupIndex)
{
if (m_ShowGroups)
{
this->beginInsertRows(QModelIndex(), groupIndex, groupIndex);
auto rootItem = m_RootItem.get();
auto groupItem = new QmitkMultiLabelSegTreeItem(QmitkMultiLabelSegTreeItem::ItemType::Group, rootItem);
rootItem->AppendChild(groupItem);
this->GenerateInternalGroupTree(groupIndex, groupItem);
this->endInsertRows();
}
}
void QmitkMultiLabelTreeModel::OnGroupModified(GroupIndexType /*groupIndex*/)
{
//currently not needed
}
void QmitkMultiLabelTreeModel::OnGroupRemoved(GroupIndexType groupIndex)
{
if (m_ShowGroups)
{
this->beginRemoveRows(QModelIndex(), groupIndex, groupIndex);
auto root = m_RootItem.get();
root->RemoveChild(groupIndex);
this->endRemoveRows();
}
}
void QmitkMultiLabelTreeModel::SetAllowVisibilityModification(bool vmod)
{
m_AllowVisibilityModification = vmod;
}
bool QmitkMultiLabelTreeModel::GetAllowVisibilityModification() const
{
return m_AllowVisibilityModification;
}
void QmitkMultiLabelTreeModel::SetAllowLockModification(bool lmod)
{
m_AllowLockModification = lmod;
}
bool QmitkMultiLabelTreeModel::GetAllowLockModification() const
{
return m_AllowLockModification;
}
diff --git a/Modules/SegmentationUI/Qmitk/QmitkSlicesInterpolator.cpp b/Modules/SegmentationUI/Qmitk/QmitkSlicesInterpolator.cpp
index 377ed78a94..f3fac46d68 100644
--- a/Modules/SegmentationUI/Qmitk/QmitkSlicesInterpolator.cpp
+++ b/Modules/SegmentationUI/Qmitk/QmitkSlicesInterpolator.cpp
@@ -1,1474 +1,1474 @@
/*============================================================================
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 "QmitkSlicesInterpolator.h"
#include "QmitkRenderWindow.h"
#include "QmitkRenderWindowWidget.h"
#include "mitkApplyDiffImageOperation.h"
#include "mitkColorProperty.h"
#include "mitkCoreObjectFactory.h"
#include "mitkDiffImageApplier.h"
#include "mitkInteractionConst.h"
#include "mitkLevelWindowProperty.h"
#include "mitkOperationEvent.h"
#include "mitkProgressBar.h"
#include "mitkProperties.h"
#include "mitkRenderingManager.h"
#include "mitkSegTool2D.h"
#include "mitkSliceNavigationController.h"
#include "mitkSurfaceToImageFilter.h"
#include <mitkTimeNavigationController.h>
#include "mitkToolManager.h"
#include "mitkUndoController.h"
#include <mitkExtractSliceFilter.h>
#include <mitkPlanarCircle.h>
#include <mitkImageReadAccessor.h>
#include <mitkImageTimeSelector.h>
#include <mitkImageWriteAccessor.h>
#include <mitkPlaneProposer.h>
#include <mitkUnstructuredGridClusteringFilter.h>
#include <mitkVtkImageOverwrite.h>
#include <mitkShapeBasedInterpolationAlgorithm.h>
#include <itkCommand.h>
#include <mitkImageToContourFilter.h>
#include <mitkImagePixelReadAccessor.h>
// Includes for the merge operation
#include "mitkImageToContourFilter.h"
#include <mitkLabelSetImage.h>
#include <QCheckBox>
#include <QCursor>
#include <QMenu>
#include <QMessageBox>
#include <QPushButton>
#include <QVBoxLayout>
#include <vtkDoubleArray.h>
#include <vtkFieldData.h>
#include <vtkPolyVertex.h>
#include <vtkUnstructuredGrid.h>
#include <vtkPolyData.h>
#include <array>
#include <atomic>
#include <thread>
#include <vector>
namespace
{
template <typename T = mitk::BaseData>
itk::SmartPointer<T> GetData(const mitk::DataNode* dataNode)
{
return nullptr != dataNode
? dynamic_cast<T*>(dataNode->GetData())
: nullptr;
}
}
float SURFACE_COLOR_RGB[3] = {0.49f, 1.0f, 0.16f};
const QmitkSlicesInterpolator::ActionToSliceDimensionMapType QmitkSlicesInterpolator::CreateActionToSlicer(const QList<QmitkRenderWindow*>& windows)
{
std::map<QAction *, mitk::SliceNavigationController *> actionToSliceDimension;
for (auto* window : windows)
{
std::string windowName;
auto renderWindowWidget = dynamic_cast<QmitkRenderWindowWidget*>(window->parentWidget());
if (renderWindowWidget)
{
windowName = renderWindowWidget->GetCornerAnnotationText();
}
else
{
windowName = window->GetRenderer()->GetName();
}
auto slicer = window->GetSliceNavigationController();
actionToSliceDimension[new QAction(QString::fromStdString(windowName), nullptr)] = slicer;
}
return actionToSliceDimension;
}
mitk::Image::Pointer ExtractSliceFromImage(mitk::Image* image,
const mitk::PlaneGeometry * contourPlane,
unsigned int timeStep)
{
vtkSmartPointer<mitkVtkImageOverwrite> reslice = vtkSmartPointer<mitkVtkImageOverwrite>::New();
// set to false to extract a slice
reslice->SetOverwriteMode(false);
reslice->Modified();
mitk::ExtractSliceFilter::Pointer extractor = mitk::ExtractSliceFilter::New(reslice);
extractor->SetInput(image);
extractor->SetTimeStep(timeStep);
extractor->SetWorldGeometry(contourPlane);
extractor->SetVtkOutputRequest(false);
extractor->SetResliceTransformByGeometry(image->GetTimeGeometry()->GetGeometryForTimeStep(timeStep));
extractor->Update();
mitk::Image::Pointer slice = extractor->GetOutput();
return slice;
}
QmitkSlicesInterpolator::QmitkSlicesInterpolator(QWidget *parent, const char * /*name*/)
: QWidget(parent),
m_Interpolator(mitk::SegmentationInterpolationController::New()),
m_SurfaceInterpolator(mitk::SurfaceInterpolationController::GetInstance()),
m_ToolManager(nullptr),
m_Initialized(false),
m_LastSNC(nullptr),
m_LastSliceIndex(0),
m_2DInterpolationEnabled(false),
m_3DInterpolationEnabled(false),
m_CurrentActiveLabelValue(0),
m_FirstRun(true)
{
m_GroupBoxEnableExclusiveInterpolationMode = new QGroupBox("Interpolation", this);
QVBoxLayout *vboxLayout = new QVBoxLayout(m_GroupBoxEnableExclusiveInterpolationMode);
m_EdgeDetector = mitk::FeatureBasedEdgeDetectionFilter::New();
m_PointScorer = mitk::PointCloudScoringFilter::New();
m_CmbInterpolation = new QComboBox(m_GroupBoxEnableExclusiveInterpolationMode);
m_CmbInterpolation->addItem("Disabled");
m_CmbInterpolation->addItem("2-Dimensional");
m_CmbInterpolation->addItem("3-Dimensional");
vboxLayout->addWidget(m_CmbInterpolation);
m_BtnApply2D = new QPushButton("Confirm for single slice", m_GroupBoxEnableExclusiveInterpolationMode);
vboxLayout->addWidget(m_BtnApply2D);
m_BtnApplyForAllSlices2D = new QPushButton("Confirm for all slices", m_GroupBoxEnableExclusiveInterpolationMode);
vboxLayout->addWidget(m_BtnApplyForAllSlices2D);
m_BtnApply3D = new QPushButton("Confirm", m_GroupBoxEnableExclusiveInterpolationMode);
vboxLayout->addWidget(m_BtnApply3D);
m_BtnReinit3DInterpolation = new QPushButton("Reinit Interpolation", m_GroupBoxEnableExclusiveInterpolationMode);
vboxLayout->addWidget(m_BtnReinit3DInterpolation);
m_ChkShowPositionNodes = new QCheckBox("Show Position Nodes", m_GroupBoxEnableExclusiveInterpolationMode);
vboxLayout->addWidget(m_ChkShowPositionNodes);
this->HideAllInterpolationControls();
connect(m_CmbInterpolation, SIGNAL(currentIndexChanged(int)), this, SLOT(OnInterpolationMethodChanged(int)));
connect(m_BtnApply2D, SIGNAL(clicked()), this, SLOT(OnAcceptInterpolationClicked()));
connect(m_BtnApplyForAllSlices2D, SIGNAL(clicked()), this, SLOT(OnAcceptAllInterpolationsClicked()));
connect(m_BtnApply3D, SIGNAL(clicked()), this, SLOT(OnAccept3DInterpolationClicked()));
connect(m_BtnReinit3DInterpolation, SIGNAL(clicked()), this, SLOT(OnReinit3DInterpolation()));
connect(m_ChkShowPositionNodes, SIGNAL(toggled(bool)), this, SLOT(OnShowMarkers(bool)));
connect(m_ChkShowPositionNodes, SIGNAL(toggled(bool)), this, SIGNAL(SignalShowMarkerNodes(bool)));
QHBoxLayout *layout = new QHBoxLayout(this);
layout->addWidget(m_GroupBoxEnableExclusiveInterpolationMode);
this->setLayout(layout);
itk::ReceptorMemberCommand<QmitkSlicesInterpolator>::Pointer command =
itk::ReceptorMemberCommand<QmitkSlicesInterpolator>::New();
command->SetCallbackFunction(this, &QmitkSlicesInterpolator::OnInterpolationInfoChanged);
InterpolationInfoChangedObserverTag = m_Interpolator->AddObserver(itk::ModifiedEvent(), command);
itk::ReceptorMemberCommand<QmitkSlicesInterpolator>::Pointer command2 =
itk::ReceptorMemberCommand<QmitkSlicesInterpolator>::New();
command2->SetCallbackFunction(this, &QmitkSlicesInterpolator::OnSurfaceInterpolationInfoChanged);
SurfaceInterpolationInfoChangedObserverTag = m_SurfaceInterpolator->AddObserver(itk::ModifiedEvent(), command2);
auto command3 = itk::ReceptorMemberCommand<QmitkSlicesInterpolator>::New();
command3->SetCallbackFunction(this, &QmitkSlicesInterpolator::OnInterpolationAborted);
InterpolationAbortedObserverTag = m_Interpolator->AddObserver(itk::AbortEvent(), command3);
// feedback node and its visualization properties
m_FeedbackNode = mitk::DataNode::New();
mitk::CoreObjectFactory::GetInstance()->SetDefaultProperties(m_FeedbackNode);
m_FeedbackNode->SetProperty("binary", mitk::BoolProperty::New(true));
m_FeedbackNode->SetProperty("outline binary", mitk::BoolProperty::New(true));
m_FeedbackNode->SetProperty("color", mitk::ColorProperty::New(255.0, 255.0, 0.0));
m_FeedbackNode->SetProperty("texture interpolation", mitk::BoolProperty::New(false));
m_FeedbackNode->SetProperty("layer", mitk::IntProperty::New(20));
m_FeedbackNode->SetProperty("levelwindow", mitk::LevelWindowProperty::New(mitk::LevelWindow(0, 1)));
m_FeedbackNode->SetProperty("name", mitk::StringProperty::New("Interpolation feedback"));
m_FeedbackNode->SetProperty("opacity", mitk::FloatProperty::New(0.8));
m_FeedbackNode->SetProperty("helper object", mitk::BoolProperty::New(true));
m_InterpolatedSurfaceNode = mitk::DataNode::New();
m_InterpolatedSurfaceNode->SetProperty("color", mitk::ColorProperty::New(SURFACE_COLOR_RGB));
m_InterpolatedSurfaceNode->SetProperty("name", mitk::StringProperty::New("Surface Interpolation feedback"));
m_InterpolatedSurfaceNode->SetProperty("opacity", mitk::FloatProperty::New(0.5));
m_InterpolatedSurfaceNode->SetProperty("line width", mitk::FloatProperty::New(4.0f));
m_InterpolatedSurfaceNode->SetProperty("includeInBoundingBox", mitk::BoolProperty::New(false));
m_InterpolatedSurfaceNode->SetProperty("helper object", mitk::BoolProperty::New(true));
m_InterpolatedSurfaceNode->SetVisibility(false);
QWidget::setContentsMargins(0, 0, 0, 0);
if (QWidget::layout() != nullptr)
{
QWidget::layout()->setContentsMargins(0, 0, 0, 0);
}
// For running 3D Interpolation in background
// create a QFuture and a QFutureWatcher
connect(&m_Watcher, SIGNAL(started()), this, SLOT(StartUpdateInterpolationTimer()));
connect(&m_Watcher, SIGNAL(finished()), this, SLOT(OnSurfaceInterpolationFinished()));
connect(&m_Watcher, SIGNAL(finished()), this, SLOT(StopUpdateInterpolationTimer()));
m_Timer = new QTimer(this);
connect(m_Timer, SIGNAL(timeout()), this, SLOT(ChangeSurfaceColor()));
}
void QmitkSlicesInterpolator::SetDataStorage(mitk::DataStorage::Pointer storage)
{
if (m_DataStorage == storage)
{
return;
}
if (m_DataStorage.IsNotNull())
{
m_DataStorage->RemoveNodeEvent.RemoveListener(
mitk::MessageDelegate1<QmitkSlicesInterpolator, const mitk::DataNode*>(this, &QmitkSlicesInterpolator::NodeRemoved)
);
}
m_DataStorage = storage;
m_SurfaceInterpolator->SetDataStorage(storage);
if (m_DataStorage.IsNotNull())
{
m_DataStorage->RemoveNodeEvent.AddListener(
mitk::MessageDelegate1<QmitkSlicesInterpolator, const mitk::DataNode*>(this, &QmitkSlicesInterpolator::NodeRemoved)
);
}
}
void QmitkSlicesInterpolator::SetActiveLabelValue(mitk::LabelSetImage::LabelValueType labelValue)
{
bool changedValue = labelValue != this->m_CurrentActiveLabelValue;
this->m_CurrentActiveLabelValue = labelValue;
if (changedValue) this->OnActiveLabelChanged(labelValue);
};
mitk::DataStorage *QmitkSlicesInterpolator::GetDataStorage()
{
if (m_DataStorage.IsNotNull())
{
return m_DataStorage;
}
else
{
return nullptr;
}
}
void QmitkSlicesInterpolator::InitializeWindow(QmitkRenderWindow* window)
{
auto slicer = window->GetSliceNavigationController();
if (slicer == nullptr)
{
MITK_WARN << "Tried setting up interpolation for a render window that does not have a slice navigation controller set";
return;
}
// Has to be initialized
m_LastSNC = slicer;
itk::MemberCommand<QmitkSlicesInterpolator>::Pointer deleteCommand =
itk::MemberCommand<QmitkSlicesInterpolator>::New();
deleteCommand->SetCallbackFunction(this, &QmitkSlicesInterpolator::OnSliceNavigationControllerDeleted);
m_ControllerToDeleteObserverTag[slicer] = slicer->AddObserver(itk::DeleteEvent(), deleteCommand);
itk::MemberCommand<QmitkSlicesInterpolator>::Pointer sliceChangedCommand =
itk::MemberCommand<QmitkSlicesInterpolator>::New();
sliceChangedCommand->SetCallbackFunction(this, &QmitkSlicesInterpolator::OnSliceChanged);
m_ControllerToSliceObserverTag[slicer] = slicer->AddObserver(mitk::SliceNavigationController::GeometrySliceEvent(nullptr, 0), sliceChangedCommand);
}
void QmitkSlicesInterpolator::Initialize(mitk::ToolManager *toolManager,
const QList<QmitkRenderWindow*>& windows)
{
Q_ASSERT(!windows.empty());
if (m_Initialized)
{
// remove old observers
this->Uninitialize();
}
m_ToolManager = toolManager;
if (m_ToolManager)
{
// set enabled only if a segmentation is selected
mitk::DataNode *node = m_ToolManager->GetWorkingData(0);
QWidget::setEnabled(node != nullptr);
// react whenever the set of selected segmentation changes
m_ToolManager->WorkingDataChanged +=
mitk::MessageDelegate<QmitkSlicesInterpolator>(this, &QmitkSlicesInterpolator::OnToolManagerWorkingDataModified);
m_ToolManager->ReferenceDataChanged += mitk::MessageDelegate<QmitkSlicesInterpolator>(
this, &QmitkSlicesInterpolator::OnToolManagerReferenceDataModified);
auto* timeNavigationController = mitk::RenderingManager::GetInstance()->GetTimeNavigationController();
itk::MemberCommand<QmitkSlicesInterpolator>::Pointer timeChangedCommand =
itk::MemberCommand<QmitkSlicesInterpolator>::New();
timeChangedCommand->SetCallbackFunction(this, &QmitkSlicesInterpolator::OnTimeChanged);
m_ControllerToTimeObserverTag =
timeNavigationController->AddObserver(mitk::TimeNavigationController::TimeEvent(0), timeChangedCommand);
m_TimePoint = timeNavigationController->GetSelectedTimePoint();
// connect to the slice navigation controller. after each change, call the interpolator
for (auto* window : windows)
{
this->InitializeWindow(window);
}
m_ActionToSlicerMap = CreateActionToSlicer(windows);
}
m_Initialized = true;
}
void QmitkSlicesInterpolator::Uninitialize()
{
if (m_ToolManager.IsNotNull())
{
m_ToolManager->WorkingDataChanged -=
mitk::MessageDelegate<QmitkSlicesInterpolator>(this, &QmitkSlicesInterpolator::OnToolManagerWorkingDataModified);
m_ToolManager->ReferenceDataChanged -= mitk::MessageDelegate<QmitkSlicesInterpolator>(
this, &QmitkSlicesInterpolator::OnToolManagerReferenceDataModified);
}
auto* timeNavigationController = mitk::RenderingManager::GetInstance()->GetTimeNavigationController();
timeNavigationController->RemoveObserver(m_ControllerToTimeObserverTag);
for (auto* slicer : m_ControllerToSliceObserverTag.keys())
{
slicer->RemoveObserver(m_ControllerToDeleteObserverTag.take(slicer));
slicer->RemoveObserver(m_ControllerToSliceObserverTag.take(slicer));
}
m_ActionToSlicerMap.clear();
m_ToolManager = nullptr;
m_Initialized = false;
}
QmitkSlicesInterpolator::~QmitkSlicesInterpolator()
{
if (m_Initialized)
{
// remove old observers
this->Uninitialize();
}
WaitForFutures();
if (m_DataStorage.IsNotNull())
{
m_DataStorage->RemoveNodeEvent.RemoveListener(
mitk::MessageDelegate1<QmitkSlicesInterpolator, const mitk::DataNode*>(this, &QmitkSlicesInterpolator::NodeRemoved)
);
if (m_DataStorage->Exists(m_InterpolatedSurfaceNode))
m_DataStorage->Remove(m_InterpolatedSurfaceNode);
}
// remove observer
m_Interpolator->RemoveObserver(InterpolationAbortedObserverTag);
m_Interpolator->RemoveObserver(InterpolationInfoChangedObserverTag);
m_SurfaceInterpolator->RemoveObserver(SurfaceInterpolationInfoChangedObserverTag);
m_SurfaceInterpolator->SetCurrentInterpolationSession(nullptr);
delete m_Timer;
}
/**
External enableization...
*/
void QmitkSlicesInterpolator::setEnabled(bool enable)
{
QWidget::setEnabled(enable);
// Set the gui elements of the different interpolation modi enabled
if (enable)
{
if (m_2DInterpolationEnabled)
{
this->Show2DInterpolationControls(true);
m_Interpolator->Activate2DInterpolation(true);
}
else if (m_3DInterpolationEnabled)
{
this->Show3DInterpolationControls(true);
this->Show3DInterpolationResult(true);
}
}
// Set all gui elements of the interpolation disabled
else
{
this->HideAllInterpolationControls();
this->Show3DInterpolationResult(false);
}
}
void QmitkSlicesInterpolator::On2DInterpolationEnabled(bool status)
{
OnInterpolationActivated(status);
m_Interpolator->Activate2DInterpolation(status);
}
void QmitkSlicesInterpolator::On3DInterpolationEnabled(bool status)
{
On3DInterpolationActivated(status);
}
void QmitkSlicesInterpolator::OnInterpolationDisabled(bool status)
{
if (status)
{
OnInterpolationActivated(!status);
On3DInterpolationActivated(!status);
this->Show3DInterpolationResult(false);
}
}
void QmitkSlicesInterpolator::HideAllInterpolationControls()
{
this->Show2DInterpolationControls(false);
this->Show3DInterpolationControls(false);
}
void QmitkSlicesInterpolator::Show2DInterpolationControls(bool show)
{
m_BtnApply2D->setVisible(show);
m_BtnApplyForAllSlices2D->setVisible(show);
}
void QmitkSlicesInterpolator::Show3DInterpolationControls(bool show)
{
m_BtnApply3D->setVisible(show);
m_ChkShowPositionNodes->setVisible(show);
m_BtnReinit3DInterpolation->setVisible(show);
}
void QmitkSlicesInterpolator::OnInterpolationMethodChanged(int index)
{
switch (index)
{
case 0: // Disabled
m_GroupBoxEnableExclusiveInterpolationMode->setTitle("Interpolation");
this->HideAllInterpolationControls();
this->OnInterpolationActivated(false);
this->On3DInterpolationActivated(false);
this->Show3DInterpolationResult(false);
m_Interpolator->Activate2DInterpolation(false);
break;
case 1: // 2D
m_GroupBoxEnableExclusiveInterpolationMode->setTitle("Interpolation (Enabled)");
this->HideAllInterpolationControls();
this->Show2DInterpolationControls(true);
this->OnInterpolationActivated(true);
this->On3DInterpolationActivated(false);
this->Show3DInterpolationResult(false);
m_Interpolator->Activate2DInterpolation(true);
break;
case 2: // 3D
m_GroupBoxEnableExclusiveInterpolationMode->setTitle("Interpolation (Enabled)");
this->HideAllInterpolationControls();
this->Show3DInterpolationControls(true);
this->OnInterpolationActivated(false);
this->On3DInterpolationActivated(true);
m_Interpolator->Activate2DInterpolation(false);
break;
default:
MITK_ERROR << "Unknown interpolation method!";
m_CmbInterpolation->setCurrentIndex(0);
break;
}
}
void QmitkSlicesInterpolator::OnShowMarkers(bool state)
{
mitk::DataStorage::SetOfObjects::ConstPointer allContourMarkers =
m_DataStorage->GetSubset(mitk::NodePredicateProperty::New("isContourMarker", mitk::BoolProperty::New(true)));
for (mitk::DataStorage::SetOfObjects::ConstIterator it = allContourMarkers->Begin(); it != allContourMarkers->End();
++it)
{
it->Value()->SetProperty("helper object", mitk::BoolProperty::New(!state));
}
}
void QmitkSlicesInterpolator::OnToolManagerWorkingDataModified()
{
if (m_ToolManager->GetWorkingData(0) != nullptr)
{
m_Segmentation = dynamic_cast<mitk::Image *>(m_ToolManager->GetWorkingData(0)->GetData());
m_BtnReinit3DInterpolation->setEnabled(true);
}
else
{
// If no workingdata is set, remove the interpolation feedback
this->GetDataStorage()->Remove(m_FeedbackNode);
m_FeedbackNode->SetData(nullptr);
this->GetDataStorage()->Remove(m_InterpolatedSurfaceNode);
m_InterpolatedSurfaceNode->SetData(nullptr);
m_BtnReinit3DInterpolation->setEnabled(false);
m_CmbInterpolation->setCurrentIndex(0);
return;
}
// Updating the current selected segmentation for the 3D interpolation
this->SetCurrentContourListID();
if (m_2DInterpolationEnabled)
{
OnInterpolationActivated(true); // re-initialize if needed
}
}
void QmitkSlicesInterpolator::OnToolManagerReferenceDataModified()
{
}
void QmitkSlicesInterpolator::OnTimeChanged(itk::Object *sender, const itk::EventObject &e)
{
if (!dynamic_cast<const mitk::TimeNavigationController::TimeEvent*>(&e))
{
return;
}
const auto* timeNavigationController = dynamic_cast<mitk::TimeNavigationController*>(sender);
if (nullptr == timeNavigationController)
{
return;
}
bool timeChanged = m_TimePoint != timeNavigationController->GetSelectedTimePoint();
m_TimePoint = timeNavigationController->GetSelectedTimePoint();
if (m_Watcher.isRunning())
m_Watcher.waitForFinished();
if (timeChanged)
{
if (m_3DInterpolationEnabled)
{
m_InterpolatedSurfaceNode->SetData(nullptr);
}
m_SurfaceInterpolator->Modified();
}
if (nullptr == m_LastSNC)
{
return;
}
if (TranslateAndInterpolateChangedSlice(m_LastSNC->GetCreatedWorldGeometry()))
{
m_LastSNC->GetRenderer()->RequestUpdate();
}
}
void QmitkSlicesInterpolator::OnSliceChanged(itk::Object *sender, const itk::EventObject &e)
{
if (!dynamic_cast<const mitk::SliceNavigationController::GeometrySliceEvent*>(&e))
{
return;
}
auto sliceNavigationController = dynamic_cast<mitk::SliceNavigationController*>(sender);
if (nullptr == sliceNavigationController)
{
return;
}
if(m_2DInterpolationEnabled)
{
this->On2DInterpolationEnabled(m_2DInterpolationEnabled);
}
if (TranslateAndInterpolateChangedSlice(e, sliceNavigationController))
{
sliceNavigationController->GetRenderer()->RequestUpdate();
}
}
bool QmitkSlicesInterpolator::TranslateAndInterpolateChangedSlice(const itk::EventObject& e,
mitk::SliceNavigationController* sliceNavigationController)
{
const mitk::SliceNavigationController::GeometrySliceEvent* event =
dynamic_cast<const mitk::SliceNavigationController::GeometrySliceEvent*>(&e);
mitk::TimeGeometry* timeGeometry = event->GetTimeGeometry();
m_LastSNC = sliceNavigationController;
return this->TranslateAndInterpolateChangedSlice(timeGeometry);
}
bool QmitkSlicesInterpolator::TranslateAndInterpolateChangedSlice(const mitk::TimeGeometry* timeGeometry)
{
if (!m_2DInterpolationEnabled)
{
return false;
}
if (nullptr == timeGeometry)
{
return false;
}
if (!timeGeometry->IsValidTimePoint(m_TimePoint))
{
return false;
}
mitk::SlicedGeometry3D* slicedGeometry =
dynamic_cast<mitk::SlicedGeometry3D*>(timeGeometry->GetGeometryForTimePoint(m_TimePoint).GetPointer());
if (nullptr == slicedGeometry)
{
return false;
}
mitk::PlaneGeometry* plane = dynamic_cast<mitk::PlaneGeometry*>(slicedGeometry->GetPlaneGeometry(m_LastSNC->GetStepper()->GetPos()));
if (nullptr == plane)
{
return false;
}
this->Interpolate(plane);
return true;
}
void QmitkSlicesInterpolator::Interpolate(mitk::PlaneGeometry *plane)
{
if (nullptr == m_ToolManager)
{
return;
}
mitk::DataNode* node = m_ToolManager->GetWorkingData(0);
if (nullptr == node)
{
return;
}
m_Segmentation = dynamic_cast<mitk::Image*>(node->GetData());
if (nullptr == m_Segmentation)
{
return;
}
if (!m_Segmentation->GetTimeGeometry()->IsValidTimePoint(m_TimePoint))
{
MITK_WARN << "Cannot interpolate WorkingImage. Passed time point is not within the time bounds of WorkingImage. "
"Time point: "
<< m_TimePoint;
return;
}
const auto timeStep = m_Segmentation->GetTimeGeometry()->TimePointToTimeStep(m_TimePoint);
int clickedSliceDimension = -1;
int clickedSliceIndex = -1;
// calculate real slice position, i.e. slice of the image
mitk::SegTool2D::DetermineAffectedImageSlice(m_Segmentation, plane, clickedSliceDimension, clickedSliceIndex);
mitk::Image::Pointer interpolation =
m_Interpolator->Interpolate(clickedSliceDimension, clickedSliceIndex, plane, timeStep);
m_FeedbackNode->SetData(interpolation);
// maybe just have a variable that stores the active label color.
if (m_ToolManager)
{
auto* workingNode = m_ToolManager->GetWorkingData(0);
if (workingNode != nullptr)
{
auto* activeLabel = dynamic_cast<mitk::LabelSetImage*>(workingNode->GetData())->GetActiveLabel();
if (nullptr != activeLabel)
{
auto activeColor = activeLabel->GetColor();
m_FeedbackNode->SetProperty("color", mitk::ColorProperty::New(activeColor));
}
}
}
m_LastSliceIndex = clickedSliceIndex;
}
void QmitkSlicesInterpolator::OnSurfaceInterpolationFinished()
{
mitk::DataNode *workingNode = m_ToolManager->GetWorkingData(0);
if (workingNode && workingNode->GetData())
{
const auto segmentation = dynamic_cast<mitk::LabelSetImage*>(workingNode->GetData());
if (segmentation == nullptr)
{
MITK_ERROR << "Run3DInterpolation triggered with no MultiLabelSegmentation as working data.";
return;
}
mitk::Surface::Pointer interpolatedSurface = m_SurfaceInterpolator->GetInterpolationResult(segmentation, m_CurrentActiveLabelValue, segmentation->GetTimeGeometry()->TimePointToTimeStep(m_TimePoint));
if (interpolatedSurface.IsNotNull())
{
m_BtnApply3D->setEnabled(true);;
m_InterpolatedSurfaceNode->SetData(interpolatedSurface);
this->Show3DInterpolationResult(true);
if (!m_DataStorage->Exists(m_InterpolatedSurfaceNode))
{
m_DataStorage->Add(m_InterpolatedSurfaceNode);
}
}
else
{
m_BtnApply3D->setEnabled(false);
if (m_DataStorage->Exists(m_InterpolatedSurfaceNode))
{
this->Show3DInterpolationResult(false);
}
}
}
m_BtnReinit3DInterpolation->setEnabled(true);
for (auto* slicer : m_ControllerToSliceObserverTag.keys())
{
slicer->GetRenderer()->RequestUpdate();
}
}
void QmitkSlicesInterpolator::OnAcceptInterpolationClicked()
{
auto* workingNode = m_ToolManager->GetWorkingData(0);
auto* planeGeometry = m_LastSNC->GetCurrentPlaneGeometry();
auto* interpolatedPreview = dynamic_cast<mitk::Image*>(m_FeedbackNode->GetData());
if (nullptr == workingNode || nullptr == interpolatedPreview)
return;
auto* segmentationImage = dynamic_cast<mitk::LabelSetImage*>(workingNode->GetData());
if (nullptr == segmentationImage)
return;
if (!segmentationImage->GetTimeGeometry()->IsValidTimePoint(m_TimePoint))
{
MITK_WARN << "Cannot accept interpolation. Time point selected by SliceNavigationController is not within the "
"time bounds of segmentation. Time point: "
<< m_TimePoint;
return;
}
const auto timeStep = segmentationImage->GetTimeGeometry()->TimePointToTimeStep(m_TimePoint);
auto interpolatedSlice = mitk::SegTool2D::GetAffectedImageSliceAs2DImage(planeGeometry, segmentationImage, timeStep)->Clone();
auto activeValue = segmentationImage->GetActiveLabel()->GetValue();
mitk::TransferLabelContentAtTimeStep(
interpolatedPreview,
interpolatedSlice,
segmentationImage->GetConstLabelsByValue(segmentationImage->GetLabelValuesByGroup(segmentationImage->GetActiveLayer())),
timeStep,
0,
- mitk::LabelSetImage::UnlabeledValue,
+ mitk::LabelSetImage::UNLABELED_VALUE,
false,
- { {0, mitk::LabelSetImage::UnlabeledValue}, {1, activeValue} }
+ { {0, mitk::LabelSetImage::UNLABELED_VALUE}, {1, activeValue} }
);
mitk::SegTool2D::WriteBackSegmentationResult(workingNode, planeGeometry, interpolatedSlice, timeStep);
m_FeedbackNode->SetData(nullptr);
}
void QmitkSlicesInterpolator::AcceptAllInterpolations(mitk::SliceNavigationController *slicer)
{
/*
* What exactly is done here:
* 1. We create an empty diff image for the current segmentation
* 2. All interpolated slices are written into the diff image
* 3. Then the diffimage is applied to the original segmentation
*/
if (m_Segmentation)
{
mitk::Image::Pointer segmentation3D = m_Segmentation;
unsigned int timeStep = 0;
if (4 == m_Segmentation->GetDimension())
{
const auto* geometry = m_Segmentation->GetTimeGeometry();
if (!geometry->IsValidTimePoint(m_TimePoint))
{
MITK_WARN << "Cannot accept all interpolations. Time point selected by passed SliceNavigationController is not "
"within the time bounds of segmentation. Time point: "
<< m_TimePoint;
return;
}
mitk::Image::Pointer activeLabelImage;
try
{
auto labelSetImage = dynamic_cast<mitk::LabelSetImage *>(m_Segmentation);
activeLabelImage = labelSetImage->CreateLabelMask(labelSetImage->GetActiveLabel()->GetValue());
}
catch (const std::exception& e)
{
MITK_ERROR << e.what() << " | NO LABELSETIMAGE IN WORKING NODE\n";
}
m_Interpolator->SetSegmentationVolume(activeLabelImage);
timeStep = geometry->TimePointToTimeStep(m_TimePoint);
auto timeSelector = mitk::ImageTimeSelector::New();
timeSelector->SetInput(m_Segmentation);
timeSelector->SetTimeNr(timeStep);
timeSelector->Update();
segmentation3D = timeSelector->GetOutput();
}
// Create an empty diff image for the undo operation
auto diffImage = mitk::Image::New();
diffImage->Initialize(segmentation3D);
// Create scope for ImageWriteAccessor so that the accessor is destroyed right after use
{
mitk::ImageWriteAccessor accessor(diffImage);
// Set all pixels to zero
auto pixelType = mitk::MakeScalarPixelType<mitk::Tool::DefaultSegmentationDataType>();
// For legacy purpose support former pixel type of segmentations (before multilabel)
if (itk::IOComponentEnum::UCHAR == m_Segmentation->GetImageDescriptor()->GetChannelDescriptor().GetPixelType().GetComponentType())
pixelType = mitk::MakeScalarPixelType<unsigned char>();
memset(accessor.GetData(), 0, pixelType.GetSize() * diffImage->GetDimension(0) * diffImage->GetDimension(1) * diffImage->GetDimension(2));
}
// Since we need to shift the plane it must be clone so that the original plane isn't altered
auto slicedGeometry = m_Segmentation->GetSlicedGeometry();
auto planeGeometry = slicer->GetCurrentPlaneGeometry()->Clone();
int sliceDimension = -1;
int sliceIndex = -1;
mitk::SegTool2D::DetermineAffectedImageSlice(m_Segmentation, planeGeometry, sliceDimension, sliceIndex);
const auto numSlices = m_Segmentation->GetDimension(sliceDimension);
mitk::ProgressBar::GetInstance()->AddStepsToDo(numSlices);
std::atomic_uint totalChangedSlices;
// Reuse interpolation algorithm instance for each slice to cache boundary calculations
auto algorithm = mitk::ShapeBasedInterpolationAlgorithm::New();
// Distribute slice interpolations to multiple threads
const auto numThreads = std::min(std::thread::hardware_concurrency(), numSlices);
std::vector<std::vector<unsigned int>> sliceIndices(numThreads);
for (std::remove_const_t<decltype(numSlices)> sliceIndex = 0; sliceIndex < numSlices; ++sliceIndex)
sliceIndices[sliceIndex % numThreads].push_back(sliceIndex);
std::vector<std::thread> threads;
threads.reserve(numThreads);
// This lambda will be executed by the threads
auto interpolate = [=, &interpolator = m_Interpolator, &totalChangedSlices](unsigned int threadIndex)
{
auto clonedPlaneGeometry = planeGeometry->Clone();
auto origin = clonedPlaneGeometry->GetOrigin();
// Go through the sliced indices
for (auto sliceIndex : sliceIndices[threadIndex])
{
slicedGeometry->WorldToIndex(origin, origin);
origin[sliceDimension] = sliceIndex;
slicedGeometry->IndexToWorld(origin, origin);
clonedPlaneGeometry->SetOrigin(origin);
auto interpolation = interpolator->Interpolate(sliceDimension, sliceIndex, clonedPlaneGeometry, timeStep, algorithm);
if (interpolation.IsNotNull())
{
// Setting up the reslicing pipeline which allows us to write the interpolation results back into the image volume
auto reslicer = vtkSmartPointer<mitkVtkImageOverwrite>::New();
// Set overwrite mode to true to write back to the image volume
reslicer->SetInputSlice(interpolation->GetSliceData()->GetVtkImageAccessor(interpolation)->GetVtkImageData());
reslicer->SetOverwriteMode(true);
reslicer->Modified();
auto diffSliceWriter = mitk::ExtractSliceFilter::New(reslicer);
diffSliceWriter->SetInput(diffImage);
diffSliceWriter->SetTimeStep(0);
diffSliceWriter->SetWorldGeometry(clonedPlaneGeometry);
diffSliceWriter->SetVtkOutputRequest(true);
diffSliceWriter->SetResliceTransformByGeometry(diffImage->GetTimeGeometry()->GetGeometryForTimeStep(0));
diffSliceWriter->Modified();
diffSliceWriter->Update();
++totalChangedSlices;
}
mitk::ProgressBar::GetInstance()->Progress();
}
};
m_Interpolator->EnableSliceImageCache();
// Do the interpolation here.
for (size_t threadIndex = 0; threadIndex < numThreads; ++threadIndex)
{
interpolate(threadIndex);
}
m_Interpolator->DisableSliceImageCache();
const mitk::Label::PixelType newDestinationLabel = dynamic_cast<mitk::LabelSetImage *>(m_Segmentation)->GetActiveLabel()->GetValue();
// Do and Undo Operations
if (totalChangedSlices > 0)
{
// Create do/undo operations
auto* doOp = new mitk::ApplyDiffImageOperation(mitk::OpTEST, m_Segmentation, diffImage, timeStep);
auto* undoOp = new mitk::ApplyDiffImageOperation(mitk::OpTEST, m_Segmentation, diffImage, timeStep);
undoOp->SetFactor(-1.0);
auto comment = "Confirm all interpolations (" + std::to_string(totalChangedSlices) + ")";
auto* undoStackItem = new mitk::OperationEvent(mitk::DiffImageApplier::GetInstanceForUndo(), doOp, undoOp, comment);
mitk::OperationEvent::IncCurrGroupEventId();
mitk::OperationEvent::IncCurrObjectEventId();
mitk::UndoController::GetCurrentUndoModel()->SetOperationEvent(undoStackItem);
mitk::DiffImageApplier::GetInstanceForUndo()->SetDestinationLabel(newDestinationLabel);
// Apply the changes to the original image
mitk::DiffImageApplier::GetInstanceForUndo()->ExecuteOperation(doOp);
}
m_FeedbackNode->SetData(nullptr);
}
mitk::RenderingManager::GetInstance()->RequestUpdateAll();
}
void QmitkSlicesInterpolator::FinishInterpolation(mitk::SliceNavigationController *slicer)
{
// this redirect is for calling from outside
if (slicer == nullptr)
OnAcceptAllInterpolationsClicked();
else
AcceptAllInterpolations(slicer);
}
void QmitkSlicesInterpolator::OnAcceptAllInterpolationsClicked()
{
QMenu orientationPopup(this);
for (auto it = m_ActionToSlicerMap.begin(); it != m_ActionToSlicerMap.end(); ++it)
{
orientationPopup.addAction(it->first);
}
connect(&orientationPopup, SIGNAL(triggered(QAction *)), this, SLOT(OnAcceptAllPopupActivated(QAction *)));
orientationPopup.exec(QCursor::pos());
}
void QmitkSlicesInterpolator::OnAccept3DInterpolationClicked()
{
auto referenceImage = GetData<mitk::Image>(m_ToolManager->GetReferenceData(0));
auto* segmentationDataNode = m_ToolManager->GetWorkingData(0);
auto labelSetImage = dynamic_cast<mitk::LabelSetImage*>(segmentationDataNode->GetData());
auto activeLabelColor = labelSetImage->GetActiveLabel()->GetColor();
std::string activeLabelName = labelSetImage->GetActiveLabel()->GetName();
auto segmentation = GetData<mitk::Image>(segmentationDataNode);
if (referenceImage.IsNull() || segmentation.IsNull())
return;
const auto* segmentationGeometry = segmentation->GetTimeGeometry();
if (!referenceImage->GetTimeGeometry()->IsValidTimePoint(m_TimePoint) ||
!segmentationGeometry->IsValidTimePoint(m_TimePoint))
{
MITK_WARN << "Cannot accept interpolation. Current time point is not within the time bounds of the patient image and segmentation.";
return;
}
auto interpolatedSurface = GetData<mitk::Surface>(m_InterpolatedSurfaceNode);
if (interpolatedSurface.IsNull())
return;
auto surfaceToImageFilter = mitk::SurfaceToImageFilter::New();
surfaceToImageFilter->SetImage(referenceImage);
surfaceToImageFilter->SetMakeOutputBinary(true);
surfaceToImageFilter->SetUShortBinaryPixelType(itk::IOComponentEnum::USHORT == segmentation->GetPixelType().GetComponentType());
surfaceToImageFilter->SetInput(interpolatedSurface);
surfaceToImageFilter->Update();
mitk::Image::Pointer interpolatedSegmentation = surfaceToImageFilter->GetOutput();
auto timeStep = segmentationGeometry->TimePointToTimeStep(m_TimePoint);
const mitk::Label::PixelType newDestinationLabel = labelSetImage->GetActiveLabel()->GetValue();
TransferLabelContentAtTimeStep(
interpolatedSegmentation,
labelSetImage,
labelSetImage->GetConstLabelsByValue(labelSetImage->GetLabelValuesByGroup(labelSetImage->GetActiveLayer())),
timeStep,
0,
0,
false,
{{1, newDestinationLabel}},
mitk::MultiLabelSegmentation::MergeStyle::Merge,
mitk::MultiLabelSegmentation::OverwriteStyle::RegardLocks);
this->Show3DInterpolationResult(false);
std::string name = segmentationDataNode->GetName() + " 3D-interpolation - " + activeLabelName;
mitk::TimeBounds timeBounds;
if (1 < interpolatedSurface->GetTimeSteps())
{
name += "_t" + std::to_string(timeStep);
auto* polyData = vtkPolyData::New();
polyData->DeepCopy(interpolatedSurface->GetVtkPolyData(timeStep));
auto surface = mitk::Surface::New();
surface->SetVtkPolyData(polyData);
interpolatedSurface = surface;
timeBounds = segmentationGeometry->GetTimeBounds(timeStep);
}
else
{
timeBounds = segmentationGeometry->GetTimeBounds(0);
}
auto* surfaceGeometry = static_cast<mitk::ProportionalTimeGeometry*>(interpolatedSurface->GetTimeGeometry());
surfaceGeometry->SetFirstTimePoint(timeBounds[0]);
surfaceGeometry->SetStepDuration(timeBounds[1] - timeBounds[0]);
// Typical file formats for surfaces do not save any time-related information. As a workaround at least for MITK scene files, we have the
// possibility to seralize this information as properties.
interpolatedSurface->SetProperty("ProportionalTimeGeometry.FirstTimePoint", mitk::FloatProperty::New(surfaceGeometry->GetFirstTimePoint()));
interpolatedSurface->SetProperty("ProportionalTimeGeometry.StepDuration", mitk::FloatProperty::New(surfaceGeometry->GetStepDuration()));
auto interpolatedSurfaceDataNode = mitk::DataNode::New();
interpolatedSurfaceDataNode->SetData(interpolatedSurface);
interpolatedSurfaceDataNode->SetName(name);
interpolatedSurfaceDataNode->SetOpacity(0.7f);
interpolatedSurfaceDataNode->SetColor(activeLabelColor);
m_DataStorage->Add(interpolatedSurfaceDataNode, segmentationDataNode);
}
void QmitkSlicesInterpolator::OnReinit3DInterpolation()
{
// Step 1. Load from the isContourPlaneGeometry nodes the contourNodes.
mitk::NodePredicateProperty::Pointer pred =
mitk::NodePredicateProperty::New("isContourPlaneGeometry", mitk::BoolProperty::New(true));
mitk::DataStorage::SetOfObjects::ConstPointer contourNodes =
m_DataStorage->GetDerivations(m_ToolManager->GetWorkingData(0), pred);
if (contourNodes->Size() != 0)
{
if (m_ToolManager->GetWorkingData(0) != nullptr)
{
try
{
auto labelSetImage = dynamic_cast<mitk::LabelSetImage *>(m_ToolManager->GetWorkingData(0)->GetData());
if (!labelSetImage->GetTimeGeometry()->IsValidTimePoint(m_TimePoint))
{
MITK_ERROR << "Invalid time point requested for interpolation pipeline.";
return;
}
mitk::SurfaceInterpolationController::CPIVector newCPIs;
// Adding label and timeStep information for the contourNodes.
for (auto it = contourNodes->Begin(); it != contourNodes->End(); ++it)
{
auto contourNode = it->Value();
auto labelID = dynamic_cast<mitk::UShortProperty *>(contourNode->GetProperty("labelID"))->GetValue();
auto timeStep = dynamic_cast<mitk::IntProperty *>(contourNode->GetProperty("timeStep"))->GetValue();
auto planeGeometry = dynamic_cast<mitk::PlanarFigure *>(contourNode->GetData())->GetPlaneGeometry();
auto groupID = labelSetImage->GetGroupIndexOfLabel(labelID);
auto sliceImage = ExtractSliceFromImage(labelSetImage->GetGroupImage(groupID), planeGeometry, timeStep);
mitk::ImageToContourFilter::Pointer contourExtractor = mitk::ImageToContourFilter::New();
contourExtractor->SetInput(sliceImage);
contourExtractor->SetContourValue(labelID);
contourExtractor->Update();
mitk::Surface::Pointer contour = contourExtractor->GetOutput();
if (contour->GetVtkPolyData()->GetNumberOfPoints() == 0)
continue;
contour->DisconnectPipeline();
newCPIs.emplace_back(contour, planeGeometry->Clone(),labelID,timeStep);
}
m_SurfaceInterpolator->CompleteReinitialization(newCPIs);
}
catch(const std::exception& e)
{
MITK_ERROR << "Exception thrown casting toolmanager working data to labelsetImage";
}
}
}
else
{
m_BtnApply3D->setEnabled(false);
QMessageBox errorInfo;
errorInfo.setWindowTitle("Reinitialize surface interpolation");
errorInfo.setIcon(QMessageBox::Information);
errorInfo.setText("No contours available for the selected segmentation!");
errorInfo.exec();
}
}
void QmitkSlicesInterpolator::OnAcceptAllPopupActivated(QAction *action)
{
try
{
auto iter = m_ActionToSlicerMap.find(action);
if (iter != m_ActionToSlicerMap.end())
{
mitk::SliceNavigationController *slicer = iter->second;
this->AcceptAllInterpolations(slicer);
}
}
catch (...)
{
/* Showing message box with possible memory error */
QMessageBox errorInfo;
errorInfo.setWindowTitle("Interpolation Process");
errorInfo.setIcon(QMessageBox::Critical);
errorInfo.setText("An error occurred during interpolation. Possible cause: Not enough memory!");
errorInfo.exec();
std::cerr << "Ill construction in " __FILE__ " l. " << __LINE__ << std::endl;
}
}
void QmitkSlicesInterpolator::OnInterpolationActivated(bool on)
{
m_2DInterpolationEnabled = on;
try
{
if (m_DataStorage.IsNotNull())
{
if (on && !m_DataStorage->Exists(m_FeedbackNode))
{
m_DataStorage->Add(m_FeedbackNode);
}
}
}
catch (...)
{
// don't care (double add/remove)
}
if (m_ToolManager)
{
mitk::DataNode *workingNode = m_ToolManager->GetWorkingData(0);
mitk::DataNode *referenceNode = m_ToolManager->GetReferenceData(0);
QWidget::setEnabled(workingNode != nullptr);
m_BtnApply2D->setEnabled(on);
m_FeedbackNode->SetVisibility(on);
if (!on)
{
mitk::RenderingManager::GetInstance()->RequestUpdateAll();
return;
}
if (workingNode)
{
auto labelSetImage = dynamic_cast<mitk::LabelSetImage *>(workingNode->GetData());
if (nullptr == labelSetImage)
{
MITK_ERROR << "NO LABELSETIMAGE IN WORKING NODE\n";
mitk::RenderingManager::GetInstance()->RequestUpdateAll();
return;
}
const auto* activeLabel = labelSetImage->GetActiveLabel();
const auto* segmentation = dynamic_cast<mitk::Image*>(workingNode->GetData());
if (nullptr != activeLabel && nullptr != segmentation)
{
auto activeLabelImage = labelSetImage->CreateLabelMask(activeLabel->GetValue());
m_Interpolator->SetSegmentationVolume(activeLabelImage);
if (referenceNode)
{
mitk::Image *referenceImage = dynamic_cast<mitk::Image *>(referenceNode->GetData());
m_Interpolator->SetReferenceVolume(referenceImage); // may be nullptr
}
}
}
}
this->UpdateVisibleSuggestion();
}
void QmitkSlicesInterpolator::Run3DInterpolation()
{
auto workingNode = m_ToolManager->GetWorkingData(0);
if (workingNode == nullptr)
{
MITK_ERROR << "Run3DInterpolation triggered with no working data set.";
return;
}
const auto segmentation = dynamic_cast<mitk::LabelSetImage*>(workingNode->GetData());
if (segmentation == nullptr)
{
MITK_ERROR << "Run3DInterpolation triggered with no MultiLabelSegmentation as working data.";
return;
}
m_SurfaceInterpolator->Interpolate(segmentation,m_CurrentActiveLabelValue,segmentation->GetTimeGeometry()->TimePointToTimeStep(m_TimePoint));
}
void QmitkSlicesInterpolator::StartUpdateInterpolationTimer()
{
m_Timer->start(500);
}
void QmitkSlicesInterpolator::StopUpdateInterpolationTimer()
{
if(m_ToolManager)
{
const auto* workingNode = m_ToolManager->GetWorkingData(0);
const auto activeColor = dynamic_cast<mitk::LabelSetImage*>(workingNode->GetData())->GetActiveLabel()->GetColor();
m_InterpolatedSurfaceNode->SetProperty("color", mitk::ColorProperty::New(activeColor));
}
m_Timer->stop();
}
void QmitkSlicesInterpolator::ChangeSurfaceColor()
{
float currentColor[3];
m_InterpolatedSurfaceNode->GetColor(currentColor);
m_InterpolatedSurfaceNode->SetProperty("color", mitk::ColorProperty::New(SURFACE_COLOR_RGB));
m_InterpolatedSurfaceNode->Update();
mitk::RenderingManager::GetInstance()->RequestUpdateAll(mitk::RenderingManager::REQUEST_UPDATE_3DWINDOWS);
}
void QmitkSlicesInterpolator::On3DInterpolationActivated(bool on)
{
m_3DInterpolationEnabled = on;
try
{
// this->PrepareInputsFor3DInterpolation();
m_SurfaceInterpolator->Modified();
}
catch (...)
{
MITK_ERROR << "Error with 3D surface interpolation!";
}
mitk::RenderingManager::GetInstance()->RequestUpdateAll();
}
void QmitkSlicesInterpolator::EnableInterpolation(bool on)
{
// only to be called from the outside world
// just a redirection to OnInterpolationActivated
OnInterpolationActivated(on);
}
void QmitkSlicesInterpolator::Enable3DInterpolation(bool on)
{
// only to be called from the outside world
// just a redirection to OnInterpolationActivated
this->On3DInterpolationActivated(on);
}
void QmitkSlicesInterpolator::UpdateVisibleSuggestion()
{
mitk::RenderingManager::GetInstance()->RequestUpdateAll();
}
void QmitkSlicesInterpolator::OnInterpolationInfoChanged(const itk::EventObject & /*e*/)
{
// something (e.g. undo) changed the interpolation info, we should refresh our display
this->UpdateVisibleSuggestion();
}
void QmitkSlicesInterpolator::OnInterpolationAborted(const itk::EventObject& /*e*/)
{
m_CmbInterpolation->setCurrentIndex(0);
m_FeedbackNode->SetData(nullptr);
}
void QmitkSlicesInterpolator::OnSurfaceInterpolationInfoChanged(const itk::EventObject & /*e*/)
{
if (m_Watcher.isRunning())
m_Watcher.waitForFinished();
if (m_3DInterpolationEnabled)
{
m_InterpolatedSurfaceNode->SetData(nullptr);
m_Future = QtConcurrent::run(this, &QmitkSlicesInterpolator::Run3DInterpolation);
m_Watcher.setFuture(m_Future);
}
}
void QmitkSlicesInterpolator::SetCurrentContourListID()
{
// New ContourList = hide current interpolation
Show3DInterpolationResult(false);
if (m_DataStorage.IsNotNull() && m_ToolManager && m_LastSNC)
{
mitk::DataNode *workingNode = m_ToolManager->GetWorkingData(0);
if (workingNode)
{
QWidget::setEnabled(true);
// In case the time is not valid use 0 to access the time geometry of the working node
unsigned int time_position = 0;
if (!workingNode->GetData()->GetTimeGeometry()->IsValidTimePoint(m_TimePoint))
{
MITK_WARN << "Cannot accept interpolation. Time point selected by SliceNavigationController is not within the time bounds of WorkingImage. Time point: " << m_TimePoint;
return;
}
m_SurfaceInterpolator->SetDistanceImageVolume(50000);
auto segmentationImage = dynamic_cast<mitk::LabelSetImage *>(workingNode->GetData());
m_SurfaceInterpolator->SetCurrentInterpolationSession(segmentationImage);
}
else
{
QWidget::setEnabled(false);
}
}
}
void QmitkSlicesInterpolator::Show3DInterpolationResult(bool status)
{
if (m_InterpolatedSurfaceNode.IsNotNull())
m_InterpolatedSurfaceNode->SetVisibility(status);
mitk::RenderingManager::GetInstance()->RequestUpdateAll();
}
void QmitkSlicesInterpolator::OnActiveLabelChanged(mitk::Label::PixelType)
{
m_FeedbackNode->SetData(nullptr);
m_InterpolatedSurfaceNode->SetData(nullptr);
if (m_Watcher.isRunning())
m_Watcher.waitForFinished();
if (m_3DInterpolationEnabled)
{
m_SurfaceInterpolator->Modified();
}
if (m_2DInterpolationEnabled)
{
m_FeedbackNode->SetData(nullptr);
this->OnInterpolationActivated(true);
m_LastSNC->SendSlice();
}
mitk::RenderingManager::GetInstance()->RequestUpdateAll();
this->UpdateVisibleSuggestion();
}
void QmitkSlicesInterpolator::CheckSupportedImageDimension()
{
if (m_ToolManager->GetWorkingData(0))
{
m_Segmentation = dynamic_cast<mitk::Image *>(m_ToolManager->GetWorkingData(0)->GetData());
if (m_3DInterpolationEnabled && m_Segmentation && ((m_Segmentation->GetDimension() != 3) || (m_Segmentation->GetDimension() != 4)) )
{
QMessageBox info;
info.setWindowTitle("3D Interpolation Process");
info.setIcon(QMessageBox::Information);
info.setText("3D Interpolation is only supported for 3D/4D images at the moment!");
info.exec();
m_CmbInterpolation->setCurrentIndex(0);
}
}
}
void QmitkSlicesInterpolator::OnSliceNavigationControllerDeleted(const itk::Object *sender,
const itk::EventObject & /*e*/)
{
// Don't know how to avoid const_cast here?!
mitk::SliceNavigationController *slicer =
dynamic_cast<mitk::SliceNavigationController *>(const_cast<itk::Object *>(sender));
if (slicer)
{
m_ControllerToSliceObserverTag.remove(slicer);
m_ControllerToDeleteObserverTag.remove(slicer);
}
}
void QmitkSlicesInterpolator::WaitForFutures()
{
if (m_Watcher.isRunning())
{
m_Watcher.waitForFinished();
}
if (m_PlaneWatcher.isRunning())
{
m_PlaneWatcher.waitForFinished();
}
}
void QmitkSlicesInterpolator::NodeRemoved(const mitk::DataNode* node)
{
if ((m_ToolManager && m_ToolManager->GetWorkingData(0) == node) ||
node == m_FeedbackNode ||
node == m_InterpolatedSurfaceNode)
{
WaitForFutures();
}
}
diff --git a/Plugins/org.mitk.gui.qt.segmentation/src/internal/QmitkAutocropLabelSetImageAction.cpp b/Plugins/org.mitk.gui.qt.segmentation/src/internal/QmitkAutocropLabelSetImageAction.cpp
index cb629c9a9a..6ab7e63f0f 100644
--- a/Plugins/org.mitk.gui.qt.segmentation/src/internal/QmitkAutocropLabelSetImageAction.cpp
+++ b/Plugins/org.mitk.gui.qt.segmentation/src/internal/QmitkAutocropLabelSetImageAction.cpp
@@ -1,301 +1,301 @@
/*============================================================================
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 "QmitkAutocropLabelSetImageAction.h"
#include <mitkImagePixelReadAccessor.h>
#include <mitkImageTimeSelector.h>
#include <mitkLabelSetImage.h>
#include <mitkRenderingManager.h>
namespace
{
// Iterate over all layers, time steps, and dimensions of a LabelSetImage to
// determine the overall minimum and maximum indices of labeled pixels.
//
// Returns false if the input image is empty, minIndex and maxIndex contain
// valid indices otherwise.
//
// Throws an mitk::Exception if read access was denied.
//
bool DetermineMinimumAndMaximumIndicesOfNonBackgroundPixels(mitk::LabelSetImage::Pointer labelSetImage, itk::Index<3>& minIndex, itk::Index<3>& maxIndex)
{
// We need a time selector to handle 3d+t images. It is not used for 3d images, though.
auto timeSelector = mitk::ImageTimeSelector::New();
timeSelector->SetInput(labelSetImage);
- const auto background = mitk::LabelSetImage::UnlabeledValue;
+ const auto background = mitk::LabelSetImage::UNLABELED_VALUE;
const auto numLayers = labelSetImage->GetNumberOfLayers();
const auto numTimeSteps = labelSetImage->GetTimeSteps();
const itk::Index<3> dim = {
labelSetImage->GetDimension(0),
labelSetImage->GetDimension(1),
labelSetImage->GetDimension(2)
};
maxIndex = { 0, 0, 0 };
minIndex = dim;
itk::Index<3> index;
bool labelSetImageIsEmpty = true;
for (std::remove_const_t<decltype(numLayers)> layer = 0; layer < numLayers; ++layer)
{
labelSetImage->SetActiveLayer(layer);
for (std::remove_const_t<decltype(numTimeSteps)> timeStep = 0; timeStep < numTimeSteps; ++timeStep)
{
const mitk::Image* image = nullptr;
if (numTimeSteps > 1)
{
timeSelector->SetTimeNr(timeStep);
timeSelector->Update();
image = timeSelector->GetOutput();
}
else
{
image = labelSetImage;
}
mitk::ImagePixelReadAccessor<mitk::LabelSetImage::PixelType, 3> pixelReader(image);
bool imageIsEmpty = true;
for (index[2] = 0; index[2] < dim[2]; ++index[2])
{
for (index[1] = 0; index[1] < dim[1]; ++index[1])
{
for (index[0] = 0; index[0] < dim[0]; ++index[0])
{
if (background != pixelReader.GetPixelByIndex(index))
{
imageIsEmpty = false;
minIndex = {
std::min(minIndex[0], index[0]),
std::min(minIndex[1], index[1]),
std::min(minIndex[2], index[2])
};
break;
}
}
}
}
if (imageIsEmpty)
continue;
maxIndex = {
std::max(maxIndex[0], minIndex[0]),
std::max(maxIndex[1], minIndex[1]),
std::max(maxIndex[2], minIndex[2])
};
for (index[2] = dim[2] - 1; index[2] >= 0; --index[2])
{
for (index[1] = dim[1] - 1; index[1] >= 0; --index[1])
{
for (index[0] = dim[0] - 1; index[0] >= 0; --index[0])
{
if (background != pixelReader.GetPixelByIndex(index))
{
maxIndex = {
std::max(maxIndex[0], index[0]),
std::max(maxIndex[1], index[1]),
std::max(maxIndex[2], index[2])
};
break;
}
}
}
}
if (!imageIsEmpty)
labelSetImageIsEmpty = false;
}
}
return !labelSetImageIsEmpty;
}
// Crop a LabelSetImage. Labels in the cropped LabelSetImage will still have
// their original properties like names and colors.
//
// Returns a cropped LabelSetImage.
//
// Throws an mitk::Exception if read access was denied.
//
mitk::LabelSetImage::Pointer Crop(mitk::LabelSetImage::Pointer labelSetImage, const itk::Index<3>& minIndex, const itk::Index<3>& maxIndex)
{
// We need a time selector to handle 3d+t images. It is not used for 3d images, though.
auto timeSelector = mitk::ImageTimeSelector::New();
timeSelector->SetInput(labelSetImage);
const auto numLayers = labelSetImage->GetNumberOfLayers();
const auto numTimeSteps = labelSetImage->GetTimeSteps();
const itk::Index<3> croppedDim = {
1 + maxIndex[0] - minIndex[0],
1 + maxIndex[1] - minIndex[1],
1 + maxIndex[2] - minIndex[2]
};
const auto numPixels = croppedDim[0] * croppedDim[1] * croppedDim[2];
mitk::BaseGeometry::BoundsArrayType croppedBounds;
croppedBounds[0] = 0;
croppedBounds[1] = croppedDim[0];
croppedBounds[2] = 0;
croppedBounds[3] = croppedDim[1];
croppedBounds[4] = 0;
croppedBounds[5] = croppedDim[2];
// Clone and adapt the original TimeGeometry to the cropped region
auto croppedTimeGeometry = labelSetImage->GetTimeGeometry()->Clone();
for (std::remove_const_t<decltype(numTimeSteps)> timeStep = 0; timeStep < numTimeSteps; ++timeStep)
{
auto geometry = croppedTimeGeometry->GetGeometryForTimeStep(timeStep);
mitk::Point3D croppedOrigin;
geometry->IndexToWorld(minIndex, croppedOrigin);
geometry->SetOrigin(croppedOrigin);
geometry->SetBounds(croppedBounds);
}
auto croppedLabelSetImage = mitk::LabelSetImage::New();
croppedLabelSetImage->Initialize(mitk::MakeScalarPixelType<mitk::LabelSetImage::PixelType>(), *croppedTimeGeometry);
// Create cropped image volumes for all time steps in all layers
for (std::remove_const_t<decltype(numLayers)> layer = 0; layer < numLayers; ++layer)
{
labelSetImage->SetActiveLayer(layer);
auto groupID = croppedLabelSetImage->AddLayer();
croppedLabelSetImage->SetActiveLayer(groupID);
for (std::remove_const_t<decltype(numTimeSteps)> timeStep = 0; timeStep < numTimeSteps; ++timeStep)
{
const mitk::Image* image = nullptr;
if (numTimeSteps > 1)
{
timeSelector->SetTimeNr(timeStep);
timeSelector->Update();
image = timeSelector->GetOutput();
}
else
{
image = labelSetImage;
}
mitk::ImagePixelReadAccessor<mitk::LabelSetImage::PixelType, 3> pixelReader(image);
auto* croppedVolume = new mitk::LabelSetImage::PixelType[numPixels];
itk::Index<3> croppedIndex;
itk::Index<3> index;
for (croppedIndex[2] = 0; croppedIndex[2] < croppedDim[2]; ++croppedIndex[2])
{
for (croppedIndex[1] = 0; croppedIndex[1] < croppedDim[1]; ++croppedIndex[1])
{
for (croppedIndex[0] = 0; croppedIndex[0] < croppedDim[0]; ++croppedIndex[0])
{
index[0] = croppedIndex[0] + minIndex[0];
index[1] = croppedIndex[1] + minIndex[1];
index[2] = croppedIndex[2] + minIndex[2];
const auto& pixel = pixelReader.GetPixelByIndex(index);
croppedVolume[croppedIndex[2] * croppedDim[1] * croppedDim[0] + croppedIndex[1] * croppedDim[0] + croppedIndex[0]] = pixel;
}
}
}
croppedLabelSetImage->SetImportVolume(croppedVolume, timeStep, 0, mitk::Image::ReferenceMemory);
croppedLabelSetImage->ReplaceGroupLabels(layer, labelSetImage->GetConstLabelsByValue(labelSetImage->GetLabelValuesByGroup(layer)));
}
}
return croppedLabelSetImage;
}
}
QmitkAutocropLabelSetImageAction::QmitkAutocropLabelSetImageAction()
{
}
QmitkAutocropLabelSetImageAction::~QmitkAutocropLabelSetImageAction()
{
}
void QmitkAutocropLabelSetImageAction::Run(const QList<mitk::DataNode::Pointer>& selectedNodes)
{
for (const auto& dataNode : selectedNodes)
{
mitk::LabelSetImage::Pointer labelSetImage = dynamic_cast<mitk::LabelSetImage*>(dataNode->GetData());
if (labelSetImage.IsNull())
continue;
// Backup currently active layer as we need to restore it later
auto activeLayer = labelSetImage->GetActiveLayer();
mitk::LabelSetImage::Pointer croppedLabelSetImage;
itk::Index<3> minIndex;
itk::Index<3> maxIndex;
try
{
if (!DetermineMinimumAndMaximumIndicesOfNonBackgroundPixels(labelSetImage, minIndex, maxIndex))
{
MITK_WARN << "Autocrop was skipped: Image \"" << dataNode->GetName() << "\" is empty.";
labelSetImage->SetActiveLayer(activeLayer); // Restore the originally active layer
return;
}
croppedLabelSetImage = Crop(labelSetImage, minIndex, maxIndex);
}
catch (const mitk::Exception&)
{
MITK_ERROR << "Autocrop was aborted: Image read access to \"" << dataNode->GetName() << "\" was denied.";
labelSetImage->SetActiveLayer(activeLayer); // Restore the originally active layer
return;
}
// Restore the originally active layer in the cropped LabelSetImage
croppedLabelSetImage->SetActiveLayer(activeLayer);
// Override the original LabelSetImage with the cropped LabelSetImage
dataNode->SetData(croppedLabelSetImage);
// If we cropped a single LabelSetImage, reinit the views to give a visible feedback to the user
if (1 == selectedNodes.size())
mitk::RenderingManager::GetInstance()->InitializeViews(croppedLabelSetImage->GetTimeGeometry());
}
}
void QmitkAutocropLabelSetImageAction::SetSmoothed(bool)
{
}
void QmitkAutocropLabelSetImageAction::SetDecimated(bool)
{
}
void QmitkAutocropLabelSetImageAction::SetDataStorage(mitk::DataStorage*)
{
}
void QmitkAutocropLabelSetImageAction::SetFunctionality(berry::QtViewPart*)
{
}