TransformMatrixType GetVoxelSpaceToRASPhysicalSpaceMatrix(typename ImageType::Pointer image) { // Generate intermediate terms vnl_matrix<double> m_dir, m_ras_matrix; vnl_diag_matrix<double> m_scale, m_lps_to_ras; vnl_vector<double> v_origin, v_ras_offset; // Compute the matrix m_dir = image->GetDirection().GetVnlMatrix(); m_scale.set(image->GetSpacing().GetVnlVector()); m_lps_to_ras.set(vnl_vector<double>(ImageType::ImageDimension, 1.0)); m_lps_to_ras[0] = -1; m_lps_to_ras[1] = -1; m_ras_matrix = m_lps_to_ras * m_dir * m_scale; // Compute the vector v_origin = image->GetOrigin().GetVnlVector(); v_ras_offset = m_lps_to_ras * v_origin; // Create the larger matrix TransformMatrixType mat; vnl_vector<double> vcol(ImageType::ImageDimension+1, 1.0); vcol.update(v_ras_offset); mat.SetIdentity(); mat.GetVnlMatrix().update(m_ras_matrix); mat.GetVnlMatrix().set_column(ImageType::ImageDimension, vcol); return mat; }
void operator()(Parameters& params) { typedef typename ::itk::Image< PIXELTYPE, 3 > ImageType; const typename ImageType::Pointer itkImage = ::fwItkIO::itkImageFactory< ImageType >(params.i_image); typename ::itk::ResampleImageFilter<ImageType, ImageType>::Pointer resampler = ::itk::ResampleImageFilter<ImageType, ImageType>::New(); typename ::itk::MinimumMaximumImageCalculator< ImageType >::Pointer minCalculator = ::itk::MinimumMaximumImageCalculator< ImageType >::New(); minCalculator->SetImage(itkImage); minCalculator->ComputeMinimum(); resampler->SetDefaultPixelValue(minCalculator->GetMinimum()); resampler->SetTransform(params.i_trf.GetPointer()); resampler->SetInput(itkImage); typename ImageType::SizeType size = itkImage->GetLargestPossibleRegion().GetSize(); typename ImageType::PointType origin = itkImage->GetOrigin(); typename ImageType::SpacingType spacing = itkImage->GetSpacing(); typename ImageType::DirectionType direction = itkImage->GetDirection(); SLM_ASSERT("Input spacing can't be null along any axis", spacing[0] > 0 && spacing[1] > 0 && spacing[2] > 0); if(params.i_targetImage) { for(std::uint8_t i = 0; i < 3; ++i) { // ITK uses unsigned long to store sizes. size[i] = static_cast<typename ImageType::SizeType::SizeValueType>(params.i_targetImage->getSize()[i]); origin[i] = params.i_targetImage->getOrigin()[i]; spacing[i] = params.i_targetImage->getSpacing()[i]; SLM_ASSERT("Output spacing can't be null along any axis.", spacing[i] > 0); } } resampler->SetSize(size); resampler->SetOutputOrigin(origin); resampler->SetOutputDirection(direction); resampler->SetOutputSpacing(spacing); resampler->Update(); typename ImageType::Pointer outputImage = resampler->GetOutput(); ::fwItkIO::itkImageToFwDataImage(outputImage, params.o_image); }
template <class ImagePixelType, class MaskPixelType> int update() { typedef itk::Image<ImagePixelType, 3> ImageType; typedef itk::Image<MaskPixelType, 3> MaskType; if ( !input ||!input->data() || !mask ||!mask->data()) return EXIT_FAILURE; typedef itk::MaskImageFilter< ImageType, MaskType> MaskFilterType; typename MaskFilterType::Pointer maskFilter = MaskFilterType::New(); typename ImageType::Pointer imgInput = dynamic_cast<ImageType *> ( ( itk::Object* ) ( input->data() )) ; typename MaskType::Pointer maskInput = dynamic_cast<MaskType *> ( ( itk::Object* ) ( mask->data() )) ; try { maskInput->SetOrigin(imgInput->GetOrigin()); maskInput->SetSpacing(imgInput->GetSpacing()); maskFilter->SetInput(imgInput); maskFilter->SetMaskingValue(maskBackgroundValue); maskFilter->SetMaskImage(maskInput); //Outside values set to the lowest reachable value typedef itk::MinimumMaximumImageCalculator <ImageType> ImageCalculatorFilterType; typename ImageCalculatorFilterType::Pointer imageCalculatorFilter = ImageCalculatorFilterType::New (); imageCalculatorFilter->SetImage(imgInput); imageCalculatorFilter->ComputeMinimum(); maskFilter->SetOutsideValue(std::min(double(imageCalculatorFilter->GetMinimum()), 0.0)); maskFilter->Update(); output->setData(maskFilter->GetOutput()); } catch( itk::ExceptionObject & err ) { std::cerr << "ExceptionObject caught in medMaskApplication!" << std::endl; std::cerr << err << std::endl; return EXIT_FAILURE; } medUtilities::setDerivedMetaData(output, input, "masked"); return EXIT_SUCCESS; }
template <class inputType, unsigned int Dimension> medAbstractJob::medJobExitStatus medItkBiasCorrectionProcess::N4BiasCorrectionCore() { medJobExitStatus eRes = medAbstractJob::MED_JOB_EXIT_SUCCESS; typedef itk::Image<inputType, Dimension > ImageType; typedef itk::Image <float, Dimension> OutputImageType; typedef itk::Image<unsigned char, Dimension> MaskImageType; typedef itk::N4BiasFieldCorrectionImageFilter<OutputImageType, MaskImageType, OutputImageType> BiasFilter; typedef itk::ConstantPadImageFilter<OutputImageType, OutputImageType> PadderType; typedef itk::ConstantPadImageFilter<MaskImageType, MaskImageType> MaskPadderType; typedef itk::ShrinkImageFilter<OutputImageType, OutputImageType> ShrinkerType; typedef itk::ShrinkImageFilter<MaskImageType, MaskImageType> MaskShrinkerType; typedef itk::BSplineControlPointImageFilter<typename BiasFilter::BiasFieldControlPointLatticeType, typename BiasFilter::ScalarImageType> BSplinerType; typedef itk::ExpImageFilter<OutputImageType, OutputImageType> ExpFilterType; typedef itk::DivideImageFilter<OutputImageType, OutputImageType, OutputImageType> DividerType; typedef itk::ExtractImageFilter<OutputImageType, OutputImageType> CropperType; unsigned int uiThreadNb = static_cast<unsigned int>(m_poUIThreadNb->value()); unsigned int uiShrinkFactors = static_cast<unsigned int>(m_poUIShrinkFactors->value()); unsigned int uiSplineOrder = static_cast<unsigned int>(m_poUISplineOrder->value()); float fWienerFilterNoise = static_cast<float>(m_poFWienerFilterNoise->value()); float fbfFWHM = static_cast<float>(m_poFbfFWHM->value()); float fConvergenceThreshold = static_cast<float>(m_poFConvergenceThreshold->value()); float fSplineDistance = static_cast<float>(m_poFSplineDistance->value()); float fProgression = 0; QStringList oListValue = m_poSMaxIterations->value().split("x"); std::vector<unsigned int> oMaxNumbersIterationsVector(oListValue.size()); std::vector<float> oInitialMeshResolutionVect(Dimension); for (int i=0; i<oMaxNumbersIterationsVector.size(); ++i) { oMaxNumbersIterationsVector[i] = (unsigned int)oListValue[i].toInt(); } oInitialMeshResolutionVect[0] = static_cast<float>(m_poFInitialMeshResolutionVect1->value()); oInitialMeshResolutionVect[1] = static_cast<float>(m_poFInitialMeshResolutionVect2->value()); oInitialMeshResolutionVect[2] = static_cast<float>(m_poFInitialMeshResolutionVect3->value()); typename ImageType::Pointer image = dynamic_cast<ImageType *>((itk::Object*)(this->input()->data())); typedef itk::CastImageFilter <ImageType, OutputImageType> CastFilterType; typename CastFilterType::Pointer castFilter = CastFilterType::New(); castFilter->SetInput(image); /********************************************************************************/ /***************************** PREPARING STARTING *******************************/ /********************************************************************************/ /*** 0 ******************* Create filter and accessories ******************/ ABORT_CHECKING(m_bAborting); typename BiasFilter::Pointer filter = BiasFilter::New(); typename BiasFilter::ArrayType oNumberOfControlPointsArray; m_filter = filter; /*** 1 ******************* Read input image *******************************/ ABORT_CHECKING(m_bAborting); fProgression = 1; updateProgression(fProgression); /*** 2 ******************* Creating Otsu mask *****************************/ ABORT_CHECKING(m_bAborting); itk::TimeProbe timer; timer.Start(); typename MaskImageType::Pointer maskImage = ITK_NULLPTR; typedef itk::OtsuThresholdImageFilter<OutputImageType, MaskImageType> ThresholderType; typename ThresholderType::Pointer otsu = ThresholderType::New(); m_filter = otsu; otsu->SetInput(castFilter->GetOutput()); otsu->SetNumberOfHistogramBins(200); otsu->SetInsideValue(0); otsu->SetOutsideValue(1); otsu->SetNumberOfThreads(uiThreadNb); otsu->Update(); updateProgression(fProgression); maskImage = otsu->GetOutput(); /*** 3A *************** Set Maximum number of Iterations for the filter ***/ ABORT_CHECKING(m_bAborting); typename BiasFilter::VariableSizeArrayType itkTabMaximumIterations; itkTabMaximumIterations.SetSize(oMaxNumbersIterationsVector.size()); for (int i = 0; i < oMaxNumbersIterationsVector.size(); ++i) { itkTabMaximumIterations[i] = oMaxNumbersIterationsVector[i]; } filter->SetMaximumNumberOfIterations(itkTabMaximumIterations); /*** 3B *************** Set Fitting Levels for the filter *****************/ typename BiasFilter::ArrayType oFittingLevelsTab; oFittingLevelsTab.Fill(oMaxNumbersIterationsVector.size()); filter->SetNumberOfFittingLevels(oFittingLevelsTab); updateProgression(fProgression); /*** 4 ******************* Save image's index, size, origine **************/ ABORT_CHECKING(m_bAborting); typename ImageType::IndexType oImageIndex = image->GetLargestPossibleRegion().GetIndex(); typename ImageType::SizeType oImageSize = image->GetLargestPossibleRegion().GetSize(); typename ImageType::PointType newOrigin = image->GetOrigin(); typename OutputImageType::Pointer outImage = castFilter->GetOutput(); if (fSplineDistance > 0) { /*** 5 ******************* Compute number of control points **************/ ABORT_CHECKING(m_bAborting); itk::SizeValueType lowerBound[3]; itk::SizeValueType upperBound[3]; for (unsigned int i = 0; i < 3; i++) { float domain = static_cast<float>(image->GetLargestPossibleRegion().GetSize()[i] - 1) * image->GetSpacing()[i]; unsigned int numberOfSpans = static_cast<unsigned int>(std::ceil(domain / fSplineDistance)); unsigned long extraPadding = static_cast<unsigned long>((numberOfSpans * fSplineDistance - domain) / image->GetSpacing()[i] + 0.5); lowerBound[i] = static_cast<unsigned long>(0.5 * extraPadding); upperBound[i] = extraPadding - lowerBound[i]; newOrigin[i] -= (static_cast<float>(lowerBound[i]) * image->GetSpacing()[i]); oNumberOfControlPointsArray[i] = numberOfSpans + filter->GetSplineOrder(); } updateProgression(fProgression); /*** 6 ******************* Padder ****************************************/ ABORT_CHECKING(m_bAborting); typename PadderType::Pointer imagePadder = PadderType::New(); m_filter = imagePadder; imagePadder->SetInput(castFilter->GetOutput()); imagePadder->SetPadLowerBound(lowerBound); imagePadder->SetPadUpperBound(upperBound); imagePadder->SetConstant(0); imagePadder->SetNumberOfThreads(uiThreadNb); imagePadder->Update(); updateProgression(fProgression); outImage = imagePadder->GetOutput(); /*** 7 ******************** Handle the mask image *************************/ ABORT_CHECKING(m_bAborting); typename MaskPadderType::Pointer maskPadder = MaskPadderType::New(); m_filter = maskPadder; maskPadder->SetInput(maskImage); maskPadder->SetPadLowerBound(lowerBound); maskPadder->SetPadUpperBound(upperBound); maskPadder->SetConstant(0); maskPadder->SetNumberOfThreads(uiThreadNb); maskPadder->Update(); updateProgression(fProgression); maskImage = maskPadder->GetOutput(); /*** 8 ******************** SetNumber Of Control Points *******************/ ABORT_CHECKING(m_bAborting); filter->SetNumberOfControlPoints(oNumberOfControlPointsArray); } else if (oInitialMeshResolutionVect.size() == 3) { /*** 9 ******************** SetNumber Of Control Points alternative *******/ ABORT_CHECKING(m_bAborting); for (unsigned i = 0; i < 3; i++) { oNumberOfControlPointsArray[i] = static_cast<unsigned int>(oInitialMeshResolutionVect[i]) + filter->GetSplineOrder(); } filter->SetNumberOfControlPoints(oNumberOfControlPointsArray); updateProgression(fProgression, 3); } else { fProgression = 0; updateProgression(fProgression); std::cout << "No BSpline distance and Mesh Resolution is ignored because not 3 dimensions" << std::endl; } /*** 10 ******************* Shrinker image ********************************/ ABORT_CHECKING(m_bAborting); typename ShrinkerType::Pointer imageShrinker = ShrinkerType::New(); m_filter = imageShrinker; imageShrinker->SetInput(outImage); /*** 11 ******************* Shrinker mask *********************************/ ABORT_CHECKING(m_bAborting); typename MaskShrinkerType::Pointer maskShrinker = MaskShrinkerType::New(); m_filter = maskShrinker; maskShrinker->SetInput(maskImage); /*** 12 ******************* Shrink mask and image *************************/ ABORT_CHECKING(m_bAborting); imageShrinker->SetShrinkFactors(uiShrinkFactors); maskShrinker->SetShrinkFactors(uiShrinkFactors); imageShrinker->SetNumberOfThreads(uiThreadNb); maskShrinker->SetNumberOfThreads(uiThreadNb); imageShrinker->Update(); updateProgression(fProgression); maskShrinker->Update(); updateProgression(fProgression); /*** 13 ******************* Filter setings ********************************/ ABORT_CHECKING(m_bAborting); filter->SetSplineOrder(uiSplineOrder); filter->SetWienerFilterNoise(fWienerFilterNoise); filter->SetBiasFieldFullWidthAtHalfMaximum(fbfFWHM); filter->SetConvergenceThreshold(fConvergenceThreshold); filter->SetInput(imageShrinker->GetOutput()); filter->SetMaskImage(maskShrinker->GetOutput()); /*** 14 ******************* Apply filter **********************************/ ABORT_CHECKING(m_bAborting); try { filter->SetNumberOfThreads(uiThreadNb); filter->Update(); updateProgression(fProgression, 5); } catch (itk::ExceptionObject & err) { std::cerr << "ExceptionObject caught !" << std::endl; std::cerr << err << std::endl; eRes = medAbstractJob::MED_JOB_EXIT_FAILURE; return eRes; } /** * Reconstruct the bias field at full image resolution. Divide * the original input image by the bias field to get the final * corrected image. */ ABORT_CHECKING(m_bAborting); typename BSplinerType::Pointer bspliner = BSplinerType::New(); m_filter = bspliner; bspliner->SetInput(filter->GetLogBiasFieldControlPointLattice()); bspliner->SetSplineOrder(filter->GetSplineOrder()); bspliner->SetSize(image->GetLargestPossibleRegion().GetSize()); bspliner->SetOrigin(newOrigin); bspliner->SetDirection(image->GetDirection()); bspliner->SetSpacing(image->GetSpacing()); bspliner->SetNumberOfThreads(uiThreadNb); bspliner->Update(); updateProgression(fProgression); /*********************** Logarithm phase ***************************/ ABORT_CHECKING(m_bAborting); typename OutputImageType::Pointer logField = OutputImageType::New(); logField->SetOrigin(image->GetOrigin()); logField->SetSpacing(image->GetSpacing()); logField->SetRegions(image->GetLargestPossibleRegion()); logField->SetDirection(image->GetDirection()); logField->Allocate(); itk::ImageRegionIterator<typename BiasFilter::ScalarImageType> IB(bspliner->GetOutput(), bspliner->GetOutput()->GetLargestPossibleRegion()); itk::ImageRegionIterator<OutputImageType> IF(logField, logField->GetLargestPossibleRegion()); for (IB.GoToBegin(), IF.GoToBegin(); !IB.IsAtEnd(); ++IB, ++IF) { IF.Set(IB.Get()[0]); } /*********************** Exponential phase *************************/ ABORT_CHECKING(m_bAborting); typename ExpFilterType::Pointer expFilter = ExpFilterType::New(); m_filter = expFilter; expFilter->SetInput(logField); expFilter->SetNumberOfThreads(uiThreadNb); expFilter->Update(); updateProgression(fProgression); /************************ Dividing phase ***************************/ ABORT_CHECKING(m_bAborting); typename DividerType::Pointer divider = DividerType::New(); m_filter = divider; divider->SetInput1(castFilter->GetOutput()); divider->SetInput2(expFilter->GetOutput()); divider->SetNumberOfThreads(uiThreadNb); divider->Update(); updateProgression(fProgression); /******************** Prepare cropping phase ***********************/ ABORT_CHECKING(m_bAborting); typename ImageType::RegionType inputRegion; inputRegion.SetIndex(oImageIndex); inputRegion.SetSize(oImageSize); /************************ Cropping phase ***************************/ ABORT_CHECKING(m_bAborting); typename CropperType::Pointer cropper = CropperType::New(); m_filter = cropper; cropper->SetInput(divider->GetOutput()); cropper->SetExtractionRegion(inputRegion); cropper->SetDirectionCollapseToSubmatrix(); cropper->SetNumberOfThreads(uiThreadNb); cropper->Update(); updateProgression(fProgression); /********************** Write output image *************************/ ABORT_CHECKING(m_bAborting); medAbstractImageData *out = qobject_cast<medAbstractImageData *>(medAbstractDataFactory::instance()->create("itkDataImageFloat3")); out->setData(cropper->GetOutput()); this->setOutput(out); m_filter = 0; return eRes; }