void
CalculateVolumeStatistic(itk::Image<TPixel, VImageDimension>* itkImage, mitk::Image::Pointer mask, mitk::GIFVolumetricStatistics::FeatureListType & featureList, std::string prefix)
{
typedef itk::Image<TPixel, VImageDimension> ImageType;
typedef itk::Image<int, VImageDimension> MaskType;
typedef itk::LabelStatisticsImageFilter<ImageType, MaskType> FilterType;
typename MaskType::Pointer maskImage = MaskType::New();
mitk::CastToItkImage(mask, maskImage);
typename FilterType::Pointer labelStatisticsImageFilter = FilterType::New();
labelStatisticsImageFilter->SetInput( itkImage );
labelStatisticsImageFilter->SetLabelInput(maskImage);
labelStatisticsImageFilter->Update();
double volume = labelStatisticsImageFilter->GetCount(1);
double voxelVolume = 1;
for (int i = 0; i < (int)(VImageDimension); ++i)
{
volume *= itkImage->GetSpacing()[i];
voxelVolume *= itkImage->GetSpacing()[i];
}
featureList.push_back(std::make_pair(prefix + "Voxel Volume", voxelVolume));
featureList.push_back(std::make_pair(prefix + "Volume (voxel based)", volume));
}
void ComputeMaskedIsophotesInRegion(const TVectorImageType* const image, const Mask* const mask,
const itk::ImageRegion<2>& region, TIsophoteImageType* const outputIsophotes)
{
//Helpers::WriteImageConditional<FloatScalarImageType>(image, "Debug/ComputeMaskedIsophotes.luminance.mha",
// this->DebugImages);
typename TIsophoteImageType::Pointer gradient = TIsophoteImageType::New();
ITKHelpers::InitializeImage(gradient.GetPointer(), image->GetLargestPossibleRegion());
Derivatives::MaskedGradientInRegion(image, mask, region, gradient.GetPointer());
//Helpers::DebugWriteImageConditional<FloatVector2ImageType>(gradient,
// "Debug/ComputeMaskedIsophotes.gradient.mha", this->DebugImages);
//Helpers::Write2DVectorImage(gradient, "Debug/ComputeMaskedIsophotes.gradient.mha");
// Rotate the gradient 90 degrees to obtain isophotes from gradient
typedef itk::UnaryFunctorImageFilter<TIsophoteImageType, TIsophoteImageType,
RotateVectors<typename TIsophoteImageType::PixelType,
typename TIsophoteImageType::PixelType> > FilterType;
typename FilterType::Pointer rotateFilter = FilterType::New();
rotateFilter->SetInput(gradient);
rotateFilter->Update();
//Helpers::DebugWriteImageConditional<FloatVector2ImageType>(rotateFilter->GetOutput(),
// "Debug/ComputeMaskedIsophotes.Isophotes.mha", this->DebugImages);
//Helpers::Write2DVectorImage(rotateFilter->GetOutput(), "Debug/ComputeMaskedIsophotes.Isophotes.mha");
ITKHelpers::CopyRegion(rotateFilter->GetOutput(), outputIsophotes, region, region);
}
void QmitkOdfMaximaExtractionView::TemplatedConvertShCoeffsFromFsl(mitk::Image* mitkImg)
{
typedef itk::FslShCoefficientImageConverter< float, shOrder > FilterType;
typedef mitk::ImageToItk< itk::Image< float, 4 > > CasterType;
CasterType::Pointer caster = CasterType::New();
caster->SetInput(mitkImg);
caster->Update();
typename FilterType::Pointer filter = FilterType::New();
filter->SetInputImage(caster->GetOutput());
filter->GenerateData();
typename FilterType::QballImageType::Pointer itkQbi = filter->GetQballImage();
typename FilterType::CoefficientImageType::Pointer itkCi = filter->GetCoefficientImage();
{
mitk::Image::Pointer img = mitk::Image::New();
img->InitializeByItk( itkCi.GetPointer() );
img->SetVolume( itkCi->GetBufferPointer() );
DataNode::Pointer node = DataNode::New();
node->SetData(img);
node->SetName("FSL_ShCoefficientImage");
GetDataStorage()->Add(node);
}
{
mitk::QBallImage::Pointer img = mitk::QBallImage::New();
img->InitializeByItk( itkQbi.GetPointer() );
img->SetVolume( itkQbi->GetBufferPointer() );
DataNode::Pointer node = DataNode::New();
node->SetData(img);
node->SetName("FSL_QballImage");
GetDataStorage()->Add(node);
}
}
void medResliceViewer::generateOutput(vtkImageReslice* reslicer, QString destType)
{
typedef itk::Image<DATA_TYPE, 3> ImageType;
typedef itk::VTKImageToImageFilter<ImageType> FilterType;
typename FilterType::Pointer filter = FilterType::New();
filter->SetInput(reslicer->GetOutput());
filter->Update();
filter->GetOutput()->Update();
outputData = medAbstractDataFactory::instance()->createSmartPointer(destType);
outputData->setData(filter->GetOutput());
// Apply resampling in pix
if (reformaTlbx->findChild<QComboBox*>("bySpacingOrDimension")->currentText() == "Dimension")
{
applyResamplingPix();
}
typename ImageType::Pointer outputImage = static_cast<itk::Image<DATA_TYPE, 3>*>(outputData->data());
compensateForRadiologicalView<DATA_TYPE>(outputImage);
correctOutputTransform<DATA_TYPE>(outputImage, reslicer->GetResliceAxes());
// Final output image
outputData->setData(outputImage);
medUtilities::setDerivedMetaData(outputData, inputData, "reformatted");
medUtilitiesITK::updateMetadata<ImageType>(outputData);
}
void mitk::CLUtil::itkFillHoleGrayscale(TImageType * image, mitk::Image::Pointer & outimage)
{
typedef itk::GrayscaleFillholeImageFilter<TImageType,TImageType> FilterType;
typename FilterType::Pointer filter = FilterType::New();
filter->SetInput(image);
filter->Update();
mitk::CastToMitkImage(filter->GetOutput(),outimage);
}
void mitk::CLUtil::itkGaussianFilter(TImageType * image, mitk::Image::Pointer & smoothed ,double sigma)
{
typedef itk::DiscreteGaussianImageFilter<TImageType,TImageType> FilterType;
typename FilterType::Pointer filter = FilterType::New();
filter->SetInput(image);
filter->SetVariance(sigma);
filter->Update();
mitk::CastToMitkImage(filter->GetOutput(),smoothed);
}
void BayesianClassifierImageFilterITK::bayesianClassifierImageFilterITK() {
if (!enableProcessing_.get()) {
outport1_.setData(inport1_.getData(), false);
return;
}
typedef itk::Image<T, 3> InputImageType;
typedef itk::Image<uint8_t, 3> OutputImageType;
typedef itk::VectorImage<float, 3> VectorImageType;
typename InputImageType::Pointer p1 = voreenToITK<T>(inport1_.getData());
typedef itk::BayesianClassifierInitializationImageFilter<InputImageType> InitFilterType;
typename InitFilterType::Pointer initializer = InitFilterType::New();
initializer->SetInput(p1);
initializer->SetNumberOfClasses(numberOfClasses_.get());
try
{
initializer->Update();
}
catch (itk::ExceptionObject &e)
{
LERROR(e);
}
//Filter define
typedef itk::BayesianClassifierImageFilter<VectorImageType> FilterType;
typename FilterType::Pointer filter = FilterType::New();
filter->SetInput(0, initializer->GetOutput());
observe(filter.GetPointer());
try
{
filter->Update();
}
catch (itk::ExceptionObject &e)
{
LERROR(e);
}
Volume* outputVolume1 = 0;
outputVolume1 = ITKToVoreenCopy<uint8_t>(filter->GetOutput());
if (outputVolume1) {
transferTransformation(inport1_.getData(), outputVolume1);
outport1_.setData(outputVolume1);
}
else
outport1_.setData(0);
}
void DiscreteGaussianImageFilterITK::discreteGaussianImageFilterITK() {
maximumError_.setVolume(inport1_.getData());
maximumError_.setMinValue<T>(1.0f);
variance_.setVolume(inport1_.getData());
if (!enableProcessing_.get()) {
outport1_.setData(inport1_.getData(), false);
return;
}
typedef itk::Image<T, 3> InputImageType1;
typedef itk::Image<float, 3> OutputImageType1;
typename InputImageType1::Pointer p1 = voreenToITK<T>(inport1_.getData());
//Filter define
typedef itk::DiscreteGaussianImageFilter<InputImageType1, OutputImageType1> FilterType;
typename FilterType::Pointer filter = FilterType::New();
filter->SetInput(p1);
filter->SetInternalNumberOfStreamDivisions(internalNumberOfStreamDivisions_.get());
filter->SetMaximumError(maximumError_.getValue<T>());
filter->SetVariance(variance_.getValue<T>());
filter->SetUseImageSpacing(useImageSpacing_.get());
filter->SetFilterDimensionality(filterDimensionality_.get());
observe(filter.GetPointer());
try
{
filter->Update();
}
catch (itk::ExceptionObject &e)
{
LERROR(e);
}
Volume* outputVolume1 = 0;
outputVolume1 = ITKToVoreenCopy<float>(filter->GetOutput());
if (outputVolume1) {
transferRWM(inport1_.getData(), outputVolume1);
transferTransformation(inport1_.getData(), outputVolume1);
outport1_.setData(outputVolume1);
} else
outport1_.setData(0);
}
void AddOffset(itk::Image<TPixel, VImageDimension>* image, int offset, mitk::Image::Pointer outputImage)
{
typedef itk::Image<TPixel, VImageDimension> ImageType;
typedef itk::ShiftScaleInPlaceImageFilter<ImageType> FilterType;
typename FilterType::Pointer filter = FilterType::New();
filter->SetShift(offset);
filter->SetInput(image);
filter->Update();
mitk::CastToMitkImage(filter->GetOutput(), outputImage);
}
void SignedDanielssonDistanceMapImageFilterITK::signedDanielssonDistanceMapImageFilterITK() {
typedef itk::Image<T, 3> InputImageType1;
typedef itk::Image<T, 3> OutputImageType1;
typedef itk::Image<T, 3> OutputImageType2;
typename InputImageType1::Pointer p1 = voreenToITK<T>(inport1_.getData());
//Filter define
typedef itk::SignedDanielssonDistanceMapImageFilter<InputImageType1, OutputImageType1> FilterType;
typename FilterType::Pointer filter = FilterType::New();
filter->SetInput(p1);
filter->SetInsideIsPositive(insideIsPositive_.get());
filter->SetSquaredDistance(squaredDistance_.get());
filter->SetUseImageSpacing(useImageSpacing_.get());
observe(filter.GetPointer());
try
{
filter->Update();
}
catch (itk::ExceptionObject &e)
{
LERROR(e);
}
Volume* outputVolume1 = 0;
outputVolume1 = ITKToVoreenCopy<T>(filter->GetDistanceMap());
if (outputVolume1) {
transferRWM(inport1_.getData(), outputVolume1);
transferTransformation(inport1_.getData(), outputVolume1);
outport1_.setData(outputVolume1);
} else
outport1_.setData(0);
Volume* outputVolume2 = 0;
outputVolume2 = ITKToVoreenCopy<T>(filter->GetVoronoiMap());
if (outputVolume2) {
transferRWM(inport1_.getData(), outputVolume2);
transferTransformation(inport1_.getData(), outputVolume2);
outport2_.setData(outputVolume2);
} else
outport2_.setData(0);
}
void IntensityWindowingImageFilterITK::intensityWindowingImageFilterITK() {
outputMinimum_.setVolume(inport1_.getData());
outputMaximum_.setVolume(inport1_.getData());
windowMinimum_.setVolume(inport1_.getData());
windowMaximum_.setVolume(inport1_.getData());
if (!enableProcessing_.get()) {
outport1_.setData(inport1_.getData(), false);
return;
}
typedef itk::Image<T, 3> InputImageType1;
typedef itk::Image<T, 3> OutputImageType1;
typename InputImageType1::Pointer p1 = voreenToITK<T>(inport1_.getData());
//Filter define
typedef itk::IntensityWindowingImageFilter<InputImageType1, OutputImageType1> FilterType;
typename FilterType::Pointer filter = FilterType::New();
filter->SetInput(p1);
filter->SetOutputMinimum(outputMinimum_.getValue<T>());
filter->SetOutputMaximum(outputMaximum_.getValue<T>());
filter->SetWindowMinimum(windowMinimum_.getValue<T>());
filter->SetWindowMaximum(windowMaximum_.getValue<T>());
observe(filter.GetPointer());
try
{
filter->Update();
}
catch (itk::ExceptionObject &e)
{
LERROR(e);
}
Volume* outputVolume1 = 0;
outputVolume1 = ITKToVoreenCopy<T>(filter->GetOutput());
if (outputVolume1) {
transferRWM(inport1_.getData(), outputVolume1);
transferTransformation(inport1_.getData(), outputVolume1);
outport1_.setData(outputVolume1);
} else
outport1_.setData(0);
}
void mitk::CLUtil::itkDilateGrayscale(TImageType * image, mitk::Image::Pointer & outimage , unsigned int radius, mitk::CLUtil::MorphologicalDimensions d)
{
typedef itk::BinaryBallStructuringElement<typename TImageType::PixelType, 3> StructureElementType;
typedef itk::GrayscaleDilateImageFilter<TImageType,TImageType,StructureElementType> FilterType;
StructureElementType ball;
itkFitStructuringElement(ball,d, radius);
typename FilterType::Pointer filter = FilterType::New();
filter->SetKernel(ball);
filter->SetInput(image);
filter->Update();
mitk::CastToMitkImage(filter->GetOutput(),outimage);
}
typename ImageType::Pointer convolveImageHelper(
typename ImageType::Pointer image,
typename ImageType::Pointer kernel )
{
enum { Dimension = ImageType::ImageDimension };
if( image.IsNotNull() & kernel.IsNotNull() )
{
typedef itk::ConvolutionImageFilter<ImageType> FilterType;
typename FilterType::Pointer convolutionFilter = FilterType::New();
convolutionFilter->SetInput( image );
convolutionFilter->SetKernelImage( kernel );
convolutionFilter->Update();
return convolutionFilter->GetOutput();
}
return NULL;
}
void mitk::ShImage::Construct() const
{
typedef itk::Image<itk::Vector<float, ( nShOrder * nShOrder + nShOrder + 2)/2 + nShOrder >,3> ImageType;
typedef itk::ShToRgbImageFilter<ImageType, nShOrder> FilterType;
typename FilterType::Pointer filter = FilterType::New();
typename ImageType::Pointer itkvol = ImageType::New();
mitk::CastToItkImage(this, itkvol);
filter->SetInput(itkvol);
filter->Update();
itk::Image<itk::RGBAPixel<unsigned char>,3>::Pointer tmp = filter->GetOutput();
m_RgbImage = mitk::Image::New();
m_RgbImage->InitializeByItk( tmp.GetPointer() );
m_RgbImage->SetVolume( tmp->GetBufferPointer() );
}
int itkFiltersComponentSizeThresholdProcess::updateProcess(medAbstractData* inputData)
{
dtkSmartPointer<medAbstractData> adjustedInputData = inputData;
if (std::is_floating_point<typename InputImageType::PixelType>::value)
{
adjustedInputData = castToOutputType<InputImageType>(inputData);;
}
typename InputImageType::Pointer inputImage = static_cast<InputImageType*>(inputData->data());
typedef itk::ConnectedComponentImageFilter <InputImageType, OutputImageType> ConnectedComponentFilterType;
typename ConnectedComponentFilterType::Pointer connectedComponentFilter = ConnectedComponentFilterType::New();
connectedComponentFilter->SetInput(inputImage);
connectedComponentFilter->Update();
// RELABEL COMPONENTS according to their sizes (0:largest(background))
typedef itk::RelabelComponentImageFilter<OutputImageType, OutputImageType> FilterType;
typename FilterType::Pointer relabelFilter = FilterType::New();
relabelFilter->SetInput(connectedComponentFilter->GetOutput());
relabelFilter->SetMinimumObjectSize(d->minimumSize);
relabelFilter->Update();
// BINARY FILTER
typedef itk::BinaryThresholdImageFilter <OutputImageType, OutputImageType> BinaryThresholdImageFilterType;
typename BinaryThresholdImageFilterType::Pointer thresholdFilter
= BinaryThresholdImageFilterType::New();
thresholdFilter->SetInput(relabelFilter->GetOutput());
thresholdFilter->SetUpperThreshold(0);
thresholdFilter->SetInsideValue(0);
thresholdFilter->SetOutsideValue(1);
thresholdFilter->Update();
itk::CStyleCommand::Pointer callback = itk::CStyleCommand::New();
callback->SetClientData ( ( void * ) this );
callback->SetCallback ( itkFiltersProcessBase::eventCallback );
connectedComponentFilter->AddObserver ( itk::ProgressEvent(), callback );
setOutputData(medAbstractDataFactory::instance()->createSmartPointer(medUtilitiesITK::itkDataImageId<OutputImageType>()));
getOutputData()->setData ( thresholdFilter->GetOutput() );
QString newSeriesDescription = "connectedComponent " + QString::number(d->minimumSize);
medUtilities::setDerivedMetaData(getOutputData(), inputData, newSeriesDescription);
return DTK_SUCCEED;
}
void OtsuThresholdImageFilterITK::otsuThresholdImageFilterITK() {
outsideValue_.setVolume(inport1_.getData());
outsideValue_.setMinValue<T>(0.0001f);
insideValue_.setVolume(inport1_.getData());
insideValue_.setMinValue<T>(0.0001f);
if (!enableProcessing_.get()) {
outport1_.setData(inport1_.getData(), false);
return;
}
typedef itk::Image<T, 3> InputImageType1;
typedef itk::Image<T, 3> OutputImageType1;
typename InputImageType1::Pointer p1 = voreenToITK<T>(inport1_.getData());
//Filter define
typedef itk::OtsuThresholdImageFilter<InputImageType1, OutputImageType1> FilterType;
typename FilterType::Pointer filter = FilterType::New();
filter->SetInput(p1);
filter->SetNumberOfHistogramBins(numberOfHistogramBins_.get());
filter->SetOutsideValue(outsideValue_.getValue<T>());
filter->SetInsideValue(insideValue_.getValue<T>());
observe(filter.GetPointer());
try
{
filter->Update();
}
catch (itk::ExceptionObject &e)
{
LERROR(e);
}
Volume* outputVolume1 = 0;
outputVolume1 = ITKToVoreenCopy<T>(filter->GetOutput());
if (outputVolume1) {
transferRWM(inport1_.getData(), outputVolume1);
transferTransformation(inport1_.getData(), outputVolume1);
outport1_.setData(outputVolume1);
} else
outport1_.setData(0);
}
Volume* ValuedRegionalMaximaImageFilter::applyFilter(const VolumeBase* inputVolume) {
typedef itk::Image<T, 3> InputImageType;
typedef itk::Image<T, 3> OutputImageType;
typename InputImageType::Pointer p = voreenToITK<T>(inputVolume);
typedef itk::ValuedRegionalMaximaImageFilter<InputImageType, OutputImageType> FilterType;
// Create the filter
typename FilterType::Pointer filter = FilterType::New();
filter->SetInput(p);
observe(filter.GetPointer());
// Run the filter
filter->Update();
return ITKToVoreenCopy<T>(filter->GetOutput());
}
typename itk::ShCoefficientImageImporter< float, shOrder >::QballImageType::Pointer TemplatedConvertShCoeffs(mitk::Image* mitkImg, int toolkit, bool noFlip = false)
{
typedef itk::ShCoefficientImageImporter< float, shOrder > FilterType;
typedef mitk::ImageToItk< itk::Image< float, 4 > > CasterType;
CasterType::Pointer caster = CasterType::New();
caster->SetInput(mitkImg);
caster->Update();
itk::Image< float, 4 >::Pointer itkImage = caster->GetOutput();
typename FilterType::Pointer filter = FilterType::New();
if (noFlip)
{
filter->SetInputImage(itkImage);
}
else
{
MITK_INFO << "Flipping image";
itk::FixedArray<bool, 4> flipAxes;
flipAxes[0] = true;
flipAxes[1] = true;
flipAxes[2] = false;
flipAxes[3] = false;
itk::FlipImageFilter< itk::Image< float, 4 > >::Pointer flipper = itk::FlipImageFilter< itk::Image< float, 4 > >::New();
flipper->SetInput(itkImage);
flipper->SetFlipAxes(flipAxes);
flipper->Update();
itk::Image< float, 4 >::Pointer flipped = flipper->GetOutput();
itk::Matrix< double,4,4 > m = itkImage->GetDirection(); m[0][0] *= -1; m[1][1] *= -1;
flipped->SetDirection(m);
itk::Point< float, 4 > o = itkImage->GetOrigin();
o[0] -= (flipped->GetLargestPossibleRegion().GetSize(0)-1);
o[1] -= (flipped->GetLargestPossibleRegion().GetSize(1)-1);
flipped->SetOrigin(o);
filter->SetInputImage(flipped);
}
switch (toolkit)
{
case 0:
filter->SetToolkit(FilterType::FSL);
break;
case 1:
filter->SetToolkit(FilterType::MRTRIX);
break;
default:
filter->SetToolkit(FilterType::FSL);
}
filter->GenerateData();
return filter->GetQballImage();
}
void GradientAnisotropicDiffusionImageFilterITK::gradientAnisotropicDiffusionImageFilterITK() {
if (!enableProcessing_.get()) {
outport1_.setData(inport1_.getData(), false);
return;
}
typedef itk::Image<T, 3> InputImageType1;
typedef itk::Image<T, 3> OutputImageType1;
typename InputImageType1::Pointer p1 = voreenToITK<T>(inport1_.getData());
//Filter define
typedef itk::GradientAnisotropicDiffusionImageFilter<InputImageType1, OutputImageType1> FilterType;
typename FilterType::Pointer filter = FilterType::New();
filter->SetInput(p1);
filter->SetNumberOfIterations(numberOfIterations_.get());
filter->SetTimeStep(timeStep_.get());
filter->SetConductanceParameter(conductanceParameter_.get());
observe(filter.GetPointer());
try
{
filter->Update();
}
catch (itk::ExceptionObject &e)
{
LERROR(e);
}
Volume* outputVolume1 = 0;
outputVolume1 = ITKToVoreenCopy<T>(filter->GetOutput());
if (outputVolume1) {
transferRWM(inport1_.getData(), outputVolume1);
transferTransformation(inport1_.getData(), outputVolume1);
outport1_.setData(outputVolume1);
} else
outport1_.setData(0);
}
void RelabelComponentImageFilterITK::relabelComponentImageFilterITK() {
if (!enableProcessing_.get()) {
outport1_.setData(inport1_.getData(), false);
return;
}
typedef itk::Image<T, 3> InputImageType1;
typedef itk::Image<T, 3> OutputImageType1;
typename InputImageType1::Pointer p1 = voreenToITK<T>(inport1_.getData());
//Filter define
typedef itk::RelabelComponentImageFilter<InputImageType1, OutputImageType1> FilterType;
typename FilterType::Pointer filter = FilterType::New();
filter->SetInput(p1);
filter->SetMinimumObjectSize(minimumObjectSize_.get());
observe(filter.GetPointer());
try
{
filter->Update();
numberOfObjects_.set(filter->GetNumberOfObjects());
originalNumberOfObjects_.set(filter->GetOriginalNumberOfObjects());
}
catch (itk::ExceptionObject &e)
{
LERROR(e);
}
Volume* outputVolume1 = 0;
outputVolume1 = ITKToVoreenCopy<T>(filter->GetOutput());
if (outputVolume1) {
transferRWM(inport1_.getData(), outputVolume1);
transferTransformation(inport1_.getData(), outputVolume1);
outport1_.setData(outputVolume1);
} else
outport1_.setData(0);
}
void GradientRecursiveGaussianImageFilterITK::gradientRecursiveGaussianImageFilterITK() {
if (!enableProcessing_.get()) {
outport1_.setData(inport1_.getData(), false);
return;
}
typedef itk::Image<T, 3> InputImageType1;
typedef itk::Image<itk::CovariantVector<double,3>, 3> OutputImageType1;
typename InputImageType1::Pointer p1 = voreenToITK<T>(inport1_.getData());
//Filter define
typedef itk::GradientRecursiveGaussianImageFilter<InputImageType1> FilterType;
typename FilterType::Pointer filter = FilterType::New();
filter->SetInput(p1);
filter->SetNormalizeAcrossScale(normalizeAcrossScale_.get());
filter->SetUseImageDirection(useImageDirection_.get());
filter->SetSigma(sigma_.get());
observe(filter.GetPointer());
try
{
filter->Update();
}
catch (itk::ExceptionObject &e)
{
LERROR(e);
}
Volume* outputVolume1 = 0;
outputVolume1 = ITKVec3ToVoreenVec3Copy<double>(filter->GetOutput());
if (outputVolume1) {
transferRWM(inport1_.getData(), outputVolume1);
transferTransformation(inport1_.getData(), outputVolume1);
outport1_.setData(outputVolume1);
} else
outport1_.setData(0);
}
void LabelOverlayImageFilterITK::labelOverlayImageFilterITK() {
backgroundValue_.setVolume(inport1_.getData());
typedef itk::Image<T, 3> InputImageType1;
typedef itk::Image<S, 3> InputImageType2;
typedef itk::Image<itk::CovariantVector<uint8_t,3>, 3> OutputImageType1;
typename InputImageType1::Pointer p1 = voreenToITK<T>(inport1_.getData());
typename InputImageType2::Pointer p2 = voreenToITK<S>(inport2_.getData());
//Filter define
typedef itk::LabelOverlayImageFilter<InputImageType1, InputImageType2, OutputImageType1> FilterType;
typename FilterType::Pointer filter = FilterType::New();
filter->SetInput(p1);
filter->SetLabelImage(p2);
filter->SetOpacity(opacity_.get());
filter->SetBackgroundValue(backgroundValue_.getValue<T>());
observe(filter.GetPointer());
try
{
filter->Update();
}
catch (itk::ExceptionObject &e)
{
LERROR(e);
}
Volume* outputVolume1 = 0;
outputVolume1 = ITKVec3ToVoreenVec3Copy<uint8_t>(filter->GetOutput());
if (outputVolume1) {
transferRWM(inport1_.getData(), outputVolume1);
transferTransformation(inport1_.getData(), outputVolume1);
outport1_.setData(outputVolume1);
} else
outport1_.setData(0);
}
void LabelContourImageFilterITK::labelContourImageFilterITK() {
backgroundValue_.setVolume(inport1_.getData());
if (!enableProcessing_.get()) {
outport1_.setData(inport1_.getData(), false);
return;
}
typedef itk::Image<T, 3> InputImageType1;
typedef itk::Image<T, 3> OutputImageType1;
typename InputImageType1::Pointer p1 = voreenToITK<T>(inport1_.getData());
//Filter define
typedef itk::LabelContourImageFilter<InputImageType1, OutputImageType1> FilterType;
typename FilterType::Pointer filter = FilterType::New();
filter->SetInput(p1);
filter->SetFullyConnected(fullyConnected_.get());
filter->SetBackgroundValue(backgroundValue_.getValue<T>());
observe(filter.GetPointer());
try
{
filter->Update();
}
catch (itk::ExceptionObject &e)
{
LERROR(e);
}
Volume* outputVolume1 = 0;
outputVolume1 = ITKToVoreenCopy<T>(filter->GetOutput());
if (outputVolume1) {
transferRWM(inport1_.getData(), outputVolume1);
transferTransformation(inport1_.getData(), outputVolume1);
outport1_.setData(outputVolume1);
} else
outport1_.setData(0);
}
void WatershedImageFilterITK::watershedImageFilterITK() {
if (!enableProcessing_.get()) {
outport1_.setData(inport1_.getData(), false);
return;
}
typedef itk::Image<T, 3> InputImageType1;
typedef itk::Image<VolumeRAM_UInt64, 3> OutputImageType1;
typename InputImageType1::Pointer p1 = voreenToITK<T>(inport1_.getData());
//Filter define
typedef itk::WatershedImageFilter<InputImageType1> FilterType;
typename FilterType::Pointer filter = FilterType::New();
filter->SetInput(p1);
filter->SetLevel(level_.get());
filter->SetThreshold(threshold_.get());
observe(filter.GetPointer());
try
{
filter->Update();
}
catch (itk::ExceptionObject &e)
{
LERROR(e);
}
Volume* outputVolume1 = 0;
outputVolume1 = ITKToVoreenCopy<itk::IdentifierType>(filter->GetOutput());
if (outputVolume1) {
transferTransformation(inport1_.getData(), outputVolume1);
outport1_.setData(outputVolume1);
}
else
outport1_.setData(0);
}
void MaskImageFilterITK::maskImageFilterITK() {
outsideValue_.setVolume(inport1_.getData());
typedef itk::Image<T, 3> InputImageType1;
typedef itk::Image<S, 3> InputImageType2;
typedef itk::Image<T, 3> OutputImageType1;
typename InputImageType1::Pointer p1 = voreenToITK<T>(inport1_.getData());
typename InputImageType2::Pointer p2 = voreenToITK<S>(inport2_.getData());
//Filter define
typedef itk::MaskImageFilter<InputImageType1, InputImageType2, OutputImageType1> FilterType;
typename FilterType::Pointer filter = FilterType::New();
filter->SetInput(p1);
filter->SetMaskImage(p2);
filter->SetOutsideValue(outsideValue_.getValue<T>());
observe(filter.GetPointer());
try
{
filter->Update();
}
catch (itk::ExceptionObject &e)
{
LERROR(e);
}
Volume* outputVolume1 = 0;
outputVolume1 = ITKToVoreenCopy<T>(filter->GetOutput());
if (outputVolume1) {
transferRWM(inport1_.getData(), outputVolume1);
transferTransformation(inport1_.getData(), outputVolume1);
outport1_.setData(outputVolume1);
} else
outport1_.setData(0);
}
void ScalarConnectedComponentImageFilterITK::scalarConnectedComponentImageFilterITK() {
distanceThreshold_.setVolume(inport1_.getData());
distanceThreshold_.setMinValue<T>(0.001f);
if (!enableProcessing_.get()) {
outport1_.setData(inport1_.getData(), false);
return;
}
typedef itk::Image<T, 3> InputImageType1;
typedef itk::Image<T, 3> OutputImageType1;
typename InputImageType1::Pointer p1 = voreenToITK<T>(inport1_.getData());
//Filter define
typedef itk::ScalarConnectedComponentImageFilter<InputImageType1, OutputImageType1> FilterType;
typename FilterType::Pointer filter = FilterType::New();
filter->SetInput(p1);
filter->SetDistanceThreshold(distanceThreshold_.getValue<T>());
observe(filter.GetPointer());
try
{
filter->Update();
}
catch (itk::ExceptionObject &e)
{
LERROR(e);
}
Volume* outputVolume1 = 0;
outputVolume1 = ITKToVoreenCopy<T>(filter->GetOutput());
if (outputVolume1) {
transferRWM(inport1_.getData(), outputVolume1);
transferTransformation(inport1_.getData(), outputVolume1);
outport1_.setData(outputVolume1);
} else
outport1_.setData(0);
}
void MinMaxCurvatureFlowImageFilterITK::minMaxCurvatureFlowImageFilterITK() {
if (!enableProcessing_.get()) {
outport1_.setData(inport1_.getData(), false);
return;
}
typedef itk::Image<T, 3> InputImageType1;
typedef itk::Image<float, 3> OutputImageType1;
typename InputImageType1::Pointer p1 = voreenToITK<T>(inport1_.getData());
//Filter define
typedef itk::MinMaxCurvatureFlowImageFilter<InputImageType1, OutputImageType1> FilterType;
typename FilterType::Pointer filter = FilterType::New();
filter->SetInput(p1);
filter->SetStencilRadius(stencilRadius_.get());
observe(filter.GetPointer());
try
{
filter->Update();
}
catch (itk::ExceptionObject &e)
{
LERROR(e);
}
Volume* outputVolume1 = 0;
outputVolume1 = ITKToVoreenCopy<float>(filter->GetOutput());
if (outputVolume1) {
transferRWM(inport1_.getData(), outputVolume1);
transferTransformation(inport1_.getData(), outputVolume1);
outport1_.setData(outputVolume1);
} else
outport1_.setData(0);
}
void LaplacianSharpeningImageFilterITK::laplacianSharpeningImageFilterITK() {
if (!enableProcessing_.get()) {
outport1_.setData(inport1_.getData(), false);
return;
}
typedef itk::Image<T, 3> InputImageType1;
typedef itk::Image<T, 3> OutputImageType1;
typename InputImageType1::Pointer p1 = voreenToITK<T>(inport1_.getData());
//Filter define
typedef itk::LaplacianSharpeningImageFilter<InputImageType1, OutputImageType1> FilterType;
typename FilterType::Pointer filter = FilterType::New();
filter->SetInput(p1);
filter->SetUseImageSpacing(useImageSpacing_.get());
observe(filter.GetPointer());
try
{
filter->Update();
}
catch (itk::ExceptionObject &e)
{
LERROR(e);
}
Volume* outputVolume1 = 0;
outputVolume1 = ITKToVoreenCopy<T>(filter->GetOutput());
if (outputVolume1) {
transferRWM(inport1_.getData(), outputVolume1);
transferTransformation(inport1_.getData(), outputVolume1);
outport1_.setData(outputVolume1);
} else
outport1_.setData(0);
}
void VotingBinaryIterativeHoleFillingImageFilterITK::votingBinaryIterativeHoleFillingImageFilterITK() {
if (!enableProcessing_.get()) {
outport1_.setData(inport1_.getData(), false);
return;
}
typedef itk::Image<T, 3> InputImageType1;
typedef itk::Image<T, 3> OutputImageType1;
typename InputImageType1::Pointer p1 = voreenToITK<T>(inport1_.getData());
//Filter define
typedef itk::VotingBinaryIterativeHoleFillingImageFilter<InputImageType1> FilterType;
typename FilterType::Pointer filter = FilterType::New();
filter->SetInput(p1);
filter->SetMaximumNumberOfIterations(maximumNumberOfIterations_.get());
observe(filter.GetPointer());
try
{
filter->Update();
}
catch (itk::ExceptionObject &e)
{
LERROR(e);
}
Volume* outputVolume1 = 0;
outputVolume1 = ITKToVoreenCopy<T>(filter->GetOutput());
if (outputVolume1) {
transferRWM(inport1_.getData(), outputVolume1);
transferTransformation(inport1_.getData(), outputVolume1);
outport1_.setData(outputVolume1);
} else
outport1_.setData(0);
}
void mitk::CLUtil::itkClosingBinary(TImageType * sourceImage, mitk::Image::Pointer& resultImage, int factor, MorphologicalDimensions d)
{
typedef TImageType ImageType;
typedef itk::BinaryBallStructuringElement<typename TImageType::PixelType, 3> BallType;
typedef itk::BinaryMorphologicalClosingImageFilter<TImageType, TImageType, BallType> FilterType;
BallType strElem;
itkFitStructuringElement(strElem,d,factor);
typename FilterType::Pointer erodeFilter = FilterType::New();
erodeFilter->SetKernel(strElem);
erodeFilter->SetInput(sourceImage);
erodeFilter->SetForegroundValue(1);
erodeFilter->Update();
mitk::CastToMitkImage(erodeFilter->GetOutput(), resultImage);
}
