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::OtsuTool3D::CalculatePreview(itk::Image<TPixel, VImageDimension> *itkImage, std::vector<int> regionIDs) { typedef itk::Image<TPixel, VImageDimension> InputImageType; typedef itk::Image<mitk::Tool::DefaultSegmentationDataType, VImageDimension> OutputImageType; typedef itk::BinaryThresholdImageFilter<InputImageType, OutputImageType> FilterType; typename FilterType::Pointer filter = FilterType::New(); // InputImageType::Pointer itkImage; typename OutputImageType::Pointer itkBinaryTempImage1; typename OutputImageType::Pointer itkBinaryTempImage2; typename OutputImageType::Pointer itkBinaryResultImage; // mitk::Image::Pointer multiLabelSegmentation = dynamic_cast<mitk::Image*>(m_MultiLabelResultNode->GetData()); // mitk::CastToItkImage(multiLabelSegmentation, itkImage); filter->SetInput(itkImage); filter->SetLowerThreshold(regionIDs[0]); filter->SetUpperThreshold(regionIDs[0]); filter->SetInsideValue(1); filter->SetOutsideValue(0); filter->Update(); itkBinaryTempImage2 = filter->GetOutput(); typename itk::OrImageFilter<OutputImageType, OutputImageType>::Pointer orFilter = itk::OrImageFilter<OutputImageType, OutputImageType>::New(); // if more than one region id is used compute the union of all given binary regions for (std::vector<int>::iterator it = regionIDs.begin(); it != regionIDs.end(); ++it) { filter->SetLowerThreshold(*it); filter->SetUpperThreshold(*it); filter->SetInsideValue(1); filter->SetOutsideValue(0); filter->Update(); itkBinaryTempImage1 = filter->GetOutput(); orFilter->SetInput1(itkBinaryTempImage1); orFilter->SetInput2(itkBinaryTempImage2); orFilter->UpdateLargestPossibleRegion(); itkBinaryResultImage = orFilter->GetOutput(); itkBinaryTempImage2 = itkBinaryResultImage; } //---------------------------------------------------------------------------------------------------- mitk::Image::Pointer binarySegmentation; mitk::CastToMitkImage(itkBinaryResultImage, binarySegmentation); m_BinaryPreviewNode->SetData(binarySegmentation); m_BinaryPreviewNode->SetVisibility(true); m_BinaryPreviewNode->SetProperty("outline binary", mitk::BoolProperty::New(false)); mitk::RenderingManager::GetInstance()->RequestUpdateAll(); }
void DoubleThresholdImageFilterITK::doubleThresholdImageFilterITK() { insideValue_.setVolume(inport1_.getData()); outsideValue_.setVolume(inport1_.getData()); threshold1_.setVolume(inport1_.getData()); threshold2_.setVolume(inport1_.getData()); threshold3_.setVolume(inport1_.getData()); threshold4_.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::DoubleThresholdImageFilter<InputImageType1, OutputImageType1> FilterType; typename FilterType::Pointer filter = FilterType::New(); filter->SetInput(p1); filter->SetInsideValue(insideValue_.getValue<T>()); filter->SetOutsideValue(outsideValue_.getValue<T>()); filter->SetThreshold1(threshold1_.getValue<T>()); filter->SetThreshold2(threshold2_.getValue<T>()); filter->SetThreshold3(threshold3_.getValue<T>()); filter->SetThreshold4(threshold4_.getValue<T>()); filter->SetFullyConnected(fullyConnected_.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 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 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 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 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 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 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 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); }
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 NarrowBandThresholdSegmentationLevelSetImageFilterITK::narrowBandThresholdSegmentationLevelSetImageFilterITK() { 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::NarrowBandThresholdSegmentationLevelSetImageFilter<InputImageType1, InputImageType2> FilterType; typename FilterType::Pointer filter = FilterType::New(); filter->SetInput(p1); filter->SetFeatureImage(p2); filter->SetPropagationScaling(propagationScaling_.get()); filter->SetCurvatureScaling(curvatureScaling_.get()); filter->SetAdvectionScaling(advectionScaling_.get()); filter->SetMaximumRMSError(maximumRMSError_.get()); filter->SetNumberOfIterations(numberOfIterations_.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 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 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 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 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 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 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); }
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 GrayscaleGrindPeakImageFilterITK::grayscaleGrindPeakImageFilterITK() { 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::GrayscaleGrindPeakImageFilter<InputImageType1, OutputImageType1> FilterType; typename FilterType::Pointer filter = FilterType::New(); filter->SetInput(p1); filter->SetFullyConnected(fullyConnected_.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 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 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 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() ); }
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; }
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 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); }
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()); }
medAbstractJob::medJobExitStatus medItkErodeImageProcess::_run() { typedef itk::Image<inputType, 3> ImageType; typename ImageType::Pointer in = dynamic_cast<ImageType *>((itk::Object*)(this->input()->data())); if(in.IsNotNull()) { typedef itk::BinaryBallStructuringElement<inputType, 3> KernelType; typedef itk::GrayscaleErodeImageFilter<ImageType, ImageType, KernelType> FilterType; typename FilterType::Pointer filter = FilterType::New(); m_filter = filter; KernelType kernel; kernel.SetRadius(this->kernelRadius()->value()); kernel.CreateStructuringElement(); filter->SetKernel(kernel); filter->SetInput(in); itk::CStyleCommand::Pointer callback = itk::CStyleCommand::New(); callback->SetClientData((void*)this); callback->SetCallback(medItkErodeImageProcess::eventCallback); filter->AddObserver(itk::ProgressEvent(), callback); try { filter->Update(); } catch(itk::ProcessAborted &e) { return medAbstractJob::MED_JOB_EXIT_CANCELLED; } medAbstractImageData *out= dynamic_cast<medAbstractImageData *>(medAbstractDataFactory::instance()->create(this->input()->identifier())); out->setData(filter->GetOutput()); this->setOutput(out); return medAbstractJob::MED_JOB_EXIT_SUCCESS; } return medAbstractJob::MED_JOB_EXIT_FAILURE; }
typename TInputImage::Pointer SegmentationIntensityAndTextureImages<TInputImage>::getTextureImage() { typedef itk::ScalarToTextureRLImageFilter<ImageType,ImageType> FilterType; typename FilterType::Pointer textureFilter = FilterType::New(); textureFilter->SetInput(inputImage); textureFilter->SetTextureFeature(8); typename FilterType::RegionSizeType size; size.Fill(13); textureFilter->SetRegionSize(size); textureFilter->Update(); typename RescaleFilterType::Pointer normalizeFilter = RescaleFilterType::New(); normalizeFilter->SetOutputMaximum(255); normalizeFilter->SetOutputMinimum(0); normalizeFilter->SetInput(textureFilter->GetOutput()); normalizeFilter->Update(); return normalizeFilter->GetOutput(); }