void mitk::ImageLiveWireContourModelFilter::ItkPreProcessImage (const itk::Image<TPixel, VImageDimension>* inputImage) { typedef itk::Image< TPixel, VImageDimension > InputImageType; typedef itk::CastImageFilter< InputImageType, InternalImageType > CastFilterType; typename CastFilterType::Pointer castFilter = CastFilterType::New(); castFilter->SetInput(inputImage); castFilter->Update(); m_InternalImage = castFilter->GetOutput(); m_CostFunction->SetImage( m_InternalImage ); m_ShortestPathFilter->SetInput( m_InternalImage ); }
dtkSmartPointer<medAbstractData> itkFiltersComponentSizeThresholdProcess::castToOutputType(medAbstractData* inputData) { //we will later label the image so we don't care about precision. typedef itk::CastImageFilter< InputImageType, OutputImageType > CastFilterType; typename CastFilterType::Pointer caster = CastFilterType::New(); typename InputImageType::Pointer im = static_cast<InputImageType*>(inputData->data()); caster->SetInput(im); caster->Update(); dtkSmartPointer<medAbstractData> outputData = medAbstractDataFactory::instance()->createSmartPointer(medUtilitiesITK::itkDataImageId<OutputImageType>()); outputData->setData(caster->GetOutput()); return outputData; }
void mitk::ModelSignalImageGenerator::DoPrepareMask(itk::Image<TPixel, VDim>* image) { m_InternalMask = dynamic_cast<InternalMaskType*>(image); if (m_InternalMask.IsNull()) { MITK_INFO << "Parameter Fit Generator. Need to cast mask for parameter fit."; typedef itk::Image<TPixel, VDim> InputImageType; typedef itk::CastImageFilter< InputImageType, InternalMaskType > CastFilterType; typename CastFilterType::Pointer spImageCaster = CastFilterType::New(); spImageCaster->SetInput(image); m_InternalMask = spImageCaster->GetOutput(); spImageCaster->Update(); } }
void RTDoseReader::MultiplyGridScaling(itk::Image<TPixel, VImageDimension>* image, float gridscale) { typedef itk::Image<Float32, VImageDimension> OutputImageType; typedef itk::Image<TPixel, VImageDimension> InputImageType; typedef itk::CastImageFilter<InputImageType, OutputImageType> CastFilterType; typedef itk::ShiftScaleImageFilter<OutputImageType, OutputImageType> ScaleFilterType; typename CastFilterType::Pointer castFilter = CastFilterType::New(); typename ScaleFilterType::Pointer scaleFilter = ScaleFilterType::New(); castFilter->SetInput(image); scaleFilter->SetInput(castFilter->GetOutput()); scaleFilter->SetScale(gridscale); scaleFilter->Update(); typename OutputImageType::Pointer scaledOutput = scaleFilter->GetOutput(); this->scaledDoseImage = mitk::Image::New(); mitk::CastToMitkImage(scaledOutput, this->scaledDoseImage); }
void DemonsRegistration::GenerateData2(const itk::Image<TPixel, VImageDimension>* itkImage1) { typedef typename itk::Image< TPixel, VImageDimension > FixedImageType; typedef typename itk::Image< TPixel, VImageDimension > MovingImageType; typedef float InternalPixelType; typedef typename itk::Image< InternalPixelType, VImageDimension > InternalImageType; typedef typename itk::CastImageFilter< FixedImageType, InternalImageType > FixedImageCasterType; typedef typename itk::CastImageFilter< MovingImageType, InternalImageType > MovingImageCasterType; typedef typename itk::Image< InternalPixelType, VImageDimension > InternalImageType; typedef typename itk::Vector< float, VImageDimension > VectorPixelType; typedef typename itk::Image< VectorPixelType, VImageDimension > DeformationFieldType; typedef typename itk::DemonsRegistrationFilter< InternalImageType, InternalImageType, DeformationFieldType> RegistrationFilterType; typedef typename itk::WarpImageFilter< MovingImageType, MovingImageType, DeformationFieldType > WarperType; typedef typename itk::LinearInterpolateImageFunction< MovingImageType, double > InterpolatorType; typedef TPixel OutputPixelType; typedef typename itk::Image< OutputPixelType, VImageDimension > OutputImageType; typedef typename itk::CastImageFilter< MovingImageType, OutputImageType > CastFilterType; typedef typename itk::ImageFileWriter< OutputImageType > WriterType; typedef typename itk::ImageFileWriter< DeformationFieldType > FieldWriterType; typename FixedImageType::Pointer fixedImage = FixedImageType::New(); mitk::CastToItkImage(m_ReferenceImage, fixedImage); typename MovingImageType::ConstPointer movingImage = itkImage1; if (fixedImage.IsNotNull() && movingImage.IsNotNull()) { typename RegistrationFilterType::Pointer filter = RegistrationFilterType::New(); this->AddStepsToDo(4); typename itk::ReceptorMemberCommand<DemonsRegistration>::Pointer command = itk::ReceptorMemberCommand<DemonsRegistration>::New(); command->SetCallbackFunction(this, &DemonsRegistration::SetProgress); filter->AddObserver( itk::IterationEvent(), command ); typename FixedImageCasterType::Pointer fixedImageCaster = FixedImageCasterType::New(); fixedImageCaster->SetInput(fixedImage); filter->SetFixedImage( fixedImageCaster->GetOutput() ); typename MovingImageCasterType::Pointer movingImageCaster = MovingImageCasterType::New(); movingImageCaster->SetInput(movingImage); filter->SetMovingImage(movingImageCaster->GetOutput()); filter->SetNumberOfIterations( m_Iterations ); filter->SetStandardDeviations( m_StandardDeviation ); filter->Update(); typename WarperType::Pointer warper = WarperType::New(); typename InterpolatorType::Pointer interpolator = InterpolatorType::New(); warper->SetInput( movingImage ); warper->SetInterpolator( interpolator ); warper->SetOutputSpacing( fixedImage->GetSpacing() ); warper->SetOutputOrigin( fixedImage->GetOrigin() ); warper->SetOutputDirection( fixedImage->GetDirection()); warper->SetDisplacementField( filter->GetOutput() ); warper->Update(); Image::Pointer outputImage = this->GetOutput(); mitk::CastToMitkImage( warper->GetOutput(), outputImage ); typename WriterType::Pointer writer = WriterType::New(); typename CastFilterType::Pointer caster = CastFilterType::New(); writer->SetFileName( m_ResultName ); caster->SetInput( warper->GetOutput() ); writer->SetInput( caster->GetOutput() ); if(m_SaveResult) { writer->Update(); } if (VImageDimension == 2) { typedef DeformationFieldType VectorImage2DType; typedef typename DeformationFieldType::PixelType Vector2DType; typename VectorImage2DType::ConstPointer vectorImage2D = filter->GetOutput(); typename VectorImage2DType::RegionType region2D = vectorImage2D->GetBufferedRegion(); typename VectorImage2DType::IndexType index2D = region2D.GetIndex(); typename VectorImage2DType::SizeType size2D = region2D.GetSize(); typedef typename itk::Vector< float, 3 > Vector3DType; typedef typename itk::Image< Vector3DType, 3 > VectorImage3DType; typedef typename itk::ImageFileWriter< VectorImage3DType > WriterType; typename WriterType::Pointer writer3D = WriterType::New(); typename VectorImage3DType::Pointer vectorImage3D = VectorImage3DType::New(); typename VectorImage3DType::RegionType region3D; typename VectorImage3DType::IndexType index3D; typename VectorImage3DType::SizeType size3D; index3D[0] = index2D[0]; index3D[1] = index2D[1]; index3D[2] = 0; size3D[0] = size2D[0]; size3D[1] = size2D[1]; size3D[2] = 1; region3D.SetSize( size3D ); region3D.SetIndex( index3D ); typename VectorImage2DType::SpacingType spacing2D = vectorImage2D->GetSpacing(); typename VectorImage3DType::SpacingType spacing3D; spacing3D[0] = spacing2D[0]; spacing3D[1] = spacing2D[1]; spacing3D[2] = 1.0; vectorImage3D->SetSpacing( spacing3D ); vectorImage3D->SetRegions( region3D ); vectorImage3D->Allocate(); typedef typename itk::ImageRegionConstIterator< VectorImage2DType > Iterator2DType; typedef typename itk::ImageRegionIterator< VectorImage3DType > Iterator3DType; Iterator2DType it2( vectorImage2D, region2D ); Iterator3DType it3( vectorImage3D, region3D ); it2.GoToBegin(); it3.GoToBegin(); Vector2DType vector2D; Vector3DType vector3D; vector3D[2] = 0; // set Z component to zero. while( !it2.IsAtEnd() ) { vector2D = it2.Get(); vector3D[0] = vector2D[0]; vector3D[1] = vector2D[1]; it3.Set( vector3D ); ++it2; ++it3; } writer3D->SetInput( vectorImage3D ); m_DeformationField = vectorImage3D; writer3D->SetFileName( m_FieldName ); try { if(m_SaveField) { writer3D->Update(); } } catch( itk::ExceptionObject & excp ) { MITK_ERROR << excp << std::endl; } } else { typename FieldWriterType::Pointer fieldwriter = FieldWriterType::New(); fieldwriter->SetFileName(m_FieldName); fieldwriter->SetInput( filter->GetOutput() ); m_DeformationField = (itk::Image<itk::Vector<float, 3>,3> *)(filter->GetOutput()); if(m_SaveField) { fieldwriter->Update(); } } this->SetRemainingProgress(4); } }
void PartialVolumeAnalysisClusteringCalculator::InternalQuantify( const itk::Image< TPixel, VImageDimension > *image, mitk::Image::Pointer clusteredImage, double* retval, mitk::Image::Pointer mask ) const { typedef itk::Image< TPixel, VImageDimension > ImageType; typedef itk::Image< float, VImageDimension > ProbImageType; typedef itk::Image< unsigned char, VImageDimension > MaskImageType; typedef mitk::ImageToItk<ProbImageType> CastFilterType; typename CastFilterType::Pointer castFilter = CastFilterType::New(); castFilter->SetInput( clusteredImage ); castFilter->Update(); typename ProbImageType::Pointer clusterImage = castFilter->GetOutput(); typename MaskImageType::Pointer itkmask = 0; if(mask.IsNotNull()) { typedef mitk::ImageToItk<MaskImageType> CastFilterType2; typename CastFilterType2::Pointer castFilter2 = CastFilterType2::New(); castFilter2->SetInput( mask ); castFilter2->Update(); itkmask = castFilter2->GetOutput(); } else { itkmask = MaskImageType::New(); itkmask->SetSpacing( clusterImage->GetSpacing() ); // Set the image spacing itkmask->SetOrigin( clusterImage->GetOrigin() ); // Set the image origin itkmask->SetDirection( clusterImage->GetDirection() ); // Set the image direction itkmask->SetRegions( clusterImage->GetLargestPossibleRegion() ); itkmask->Allocate(); itkmask->FillBuffer(1); } itk::ImageRegionConstIterator<ImageType> itimage(image, image->GetLargestPossibleRegion()); itk::ImageRegionConstIterator<ProbImageType> itprob(clusterImage, clusterImage->GetLargestPossibleRegion()); itk::ImageRegionConstIterator<MaskImageType> itmask(itkmask, itkmask->GetLargestPossibleRegion()); itimage.GoToBegin(); itprob.GoToBegin(); itmask.GoToBegin(); double totalProb = 0; double measurement = 0; double error = 0; while( !itimage.IsAtEnd() && !itprob.IsAtEnd() && !itmask.IsAtEnd() ) { double valImag = itimage.Get(); double valProb = itprob.Get(); double valMask = itmask.Get(); typename ProbImageType::PixelType prop = valProb * valMask; totalProb += prop; measurement += valImag * prop; error += valImag * valImag * prop; ++itimage; ++itprob; ++itmask; } measurement = measurement / totalProb; error = error / totalProb; retval[0] = measurement; retval[1] = sqrt( error - measurement*measurement ); }
void PartialVolumeAnalysisClusteringCalculator::InternalGenerateRGB( HelperStructRGBChannels *rgbin, mitk::Image::Pointer retval ) const { typedef itk::Image< float, VImageDimension > ProbImageType; typedef itk::Image< typename itk::RGBAPixel<unsigned char>, VImageDimension > RGBImageType; typedef mitk::ImageToItk<ProbImageType> CastFilterType; typename CastFilterType::Pointer castFilter = CastFilterType::New(); castFilter->SetInput( rgbin->r ); castFilter->Update(); typename ProbImageType::Pointer r = castFilter->GetOutput(); castFilter = CastFilterType::New(); castFilter->SetInput( rgbin->g ); castFilter->Update(); typename ProbImageType::Pointer g = castFilter->GetOutput(); typename RGBImageType::Pointer rgb = RGBImageType::New(); rgb->SetSpacing( g->GetSpacing() ); // Set the image spacing rgb->SetOrigin( g->GetOrigin() ); // Set the image origin rgb->SetDirection( g->GetDirection() ); // Set the image direction rgb->SetRegions( g->GetLargestPossibleRegion() ); rgb->Allocate(); itk::ImageRegionConstIterator<ProbImageType> itr(r, r->GetLargestPossibleRegion()); itk::ImageRegionConstIterator<ProbImageType> itg(g, g->GetLargestPossibleRegion()); itk::ImageRegionIterator<RGBImageType> itrgb(rgb, rgb->GetLargestPossibleRegion()); itr.GoToBegin(); itg.GoToBegin(); float maxr = 0; float maxg = 0; while( !itr.IsAtEnd() ) { typename ProbImageType::PixelType pr = itr.Get(); typename ProbImageType::PixelType pg = itg.Get(); if(pr > maxr) { maxr = pr; } if(pg > maxg) { maxg = pg; } ++itr; ++itg; } itr.GoToBegin(); itg.GoToBegin(); itrgb.GoToBegin(); while( !itr.IsAtEnd() ) { typename ProbImageType::PixelType pr = itr.Get(); typename ProbImageType::PixelType pg = itg.Get(); typename RGBImageType::PixelType prgb; float valr = (pr/maxr)*255.0f; float valg = (pg/maxg)*255.0f; float alpha = valr>valg ? valr : valg; prgb.Set(valr, valg, 0.0f, alpha); itrgb.Set(prgb); ++itr; ++itg; ++itrgb; } retval->InitializeByItk(rgb.GetPointer()); retval->SetVolume(rgb->GetBufferPointer()); }
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; }