CMatrix4x4 GlobalAdaptation::adaptation(bool itkAmoeba) { unsigned int numberOfParameters; if (mode_ == "rotation") numberOfParameters = 3; else if (mode_ == "rotation+scaling") numberOfParameters = 4; else if (mode_ == "rotation+translation") numberOfParameters = 6; vector<double> p; if (!itkAmoeba) { // can only be used with rotation double mean1 = -0.00924, std1 = 0.057, mean2 = -0.0022, std2 = 0.0615, mean3 = 0.0140, std3 = 0.0427; OptimizerType::BoundSelectionType boundSelect(3); boundSelect.Fill( 2 ); OptimizerType::BoundValueType upperBound(3); upperBound[0] = mean1+3*std1; upperBound[1] = mean2+3*std2; upperBound[2] = mean3+3*std3; OptimizerType::BoundValueType lowerBound(3); lowerBound[0] = mean1-3*std1; lowerBound[1] = mean2-3*std2; lowerBound[2] = mean3-3*std3; FoncteurGlobalAdaptation* f = new FoncteurGlobalAdaptation(image_,mesh_->getListTrianglesBarycentre(),numberOfParameters); f->setPointRotation(pointRotation_); OptimizerType::ParametersType pInit(3); pInit.Fill(0.0); OptimizerType::Pointer LBFGSBOptimizer = OptimizerType::New(); LBFGSBOptimizer->SetCostFunction(f); LBFGSBOptimizer->SetBoundSelection( boundSelect ); LBFGSBOptimizer->SetUpperBound( upperBound ); LBFGSBOptimizer->SetLowerBound( lowerBound ); LBFGSBOptimizer->SetCostFunctionConvergenceFactor( 1.e7 ); LBFGSBOptimizer->SetProjectedGradientTolerance( 1e-35); LBFGSBOptimizer->SetMaximumNumberOfIterations( 250 ); LBFGSBOptimizer->SetMaximumNumberOfEvaluations( 250 ); LBFGSBOptimizer->SetMaximumNumberOfCorrections( 7 ); LBFGSBOptimizer->SetInitialPosition(pInit); try { LBFGSBOptimizer->StartOptimization(); } catch ( std::bad_alloc & err ) { cerr << "BadAlloc caught !" << (char*)err.what() << endl; } catch( itk::ExceptionObject & err ) { cerr << "ExceptionObject caught !" << err << endl; } OptimizerType::ParametersType pFinal = LBFGSBOptimizer->GetCurrentPosition(); cout << LBFGSBOptimizer->GetStopConditionDescription() << endl; for (int i=0; i<pFinal.size(); i++) p.push_back(pFinal[i]); } else { // Utilisation de la méthode du Simplex implémentée dans la librairie ITK itk::AmoebaOptimizer::Pointer optimizer = itk::AmoebaOptimizer::New(); SCRegion* region = new SCRegion(); int *sizeDesired = new int[3]; double *spacingDesired = new double[3]; sizeDesired[0] = 61; sizeDesired[1] = 61; sizeDesired[2] = 81; spacingDesired[0] = 1; spacingDesired[1] = 1; spacingDesired[2] = 1; region->setSize(sizeDesired); region->setSpacing(spacingDesired); region->setOrigin(pointRotation_[0],pointRotation_[1],pointRotation_[2]); region->setNormal(normal_mesh_[0],normal_mesh_[1],normal_mesh_[2]); region->setFactor(image_->getTypeImageFactor()); region->build2DGaussian(1.5); FoncteurGlobalAdaptation* f = new FoncteurGlobalAdaptation(image_,mesh_->getListTrianglesBarycentre(),numberOfParameters); f->setPointRotation(pointRotation_); f->setGaussianRegion(region); optimizer->SetCostFunction(f); optimizer->SetOptimizeWithRestarts(false); optimizer->SetMaximumNumberOfIterations(250); optimizer->AutomaticInitialSimplexOn(); ParametersType pInit, pFinal; //pInit.SetSize(6); double* init = new double[numberOfParameters]; for (int i=0; i<numberOfParameters; i++) init[i] = 0.0; if (mode_ == "rotation+scaling") init[3] = 1.0; pInit.SetData(init,numberOfParameters,false); optimizer->SetFunctionConvergenceTolerance(1.0e-4); optimizer->SetParametersConvergenceTolerance(1.0e-8); optimizer->SetInitialPosition(pInit); try { optimizer->StartOptimization(); } catch ( std::bad_alloc & err ) { cerr << "BadAlloc caught !" << (char*)err.what() << endl; } catch( itk::ExceptionObject & err ) { cerr << "ExceptionObject caught !" << err << endl; } //cout << optimizer->GetStopConditionDescription() << endl << optimizer->GetValue() << endl; pFinal = optimizer->GetCurrentPosition(); for (int i=0; i<pFinal.size(); i++) p.push_back(pFinal[i]); } /*cout << "Affichage des resultats..." << endl; for (int i=0; i<p.size(); i++) cout << i << " " << p[i] << endl << endl;*/ CMatrix4x4 transformation; double mean1 = 0.0044, std1 = 0.0868, mean2 = -0.0107, std2 = 0.1170, mean3 = 0.0110, std3 = 0.1495; double factor = 2.7; if (p[0]<=mean1+factor*std1 && p[0]>=mean1-factor*std1 && p[1]<=mean2+factor*std2 && p[1]>=mean2-factor*std2 && p[2]<=mean3+factor*std3 && p[2]>=mean3-factor*std3) { transformation[0] = cos(p[0])*cos(p[1]), transformation[4] = -cos(p[2])*sin(p[1]) + sin(p[2])*sin(p[0])*cos(p[1]), transformation[8] = sin(p[2])*sin(p[1]) + cos(p[2])*sin(p[0])*cos(p[1]), transformation[1] = cos(p[0])*sin(p[1]), transformation[5] = cos(p[2])*cos(p[1]) + sin(p[2])*sin(p[0])*sin(p[1]), transformation[9] = -sin(p[2])*cos(p[1]) + cos(p[2])*sin(p[0])*sin(p[1]), transformation[2] = -sin(p[0]), transformation[6] = sin(p[2])*cos(p[0]), transformation[10] = cos(p[2])*cos(p[0]); if (mode_ == "rotation+translation") { transformation[12] = p[3], transformation[13] = p[4], transformation[14] = p[5]; } if (mode_ == "rotation+scaling") { transformation[0] *= p[3]; transformation[5] *= p[3]; transformation[10] *= p[3]; } //cout << transformation << endl; mesh_->transform(transformation,pointRotation_); badOrientation_ = false; } else { /*if (verbose_) { cout << "Rotations : " << endl; cout << mean1-factor*std1 << " <= " << p[0] << " <= " << mean1+factor*std1 << endl; cout << mean2-factor*std2 << " <= " << p[1] << " <= " << mean2+factor*std2 << endl; cout << mean3-factor*std3 << " <= " << p[2] << " <= " << mean3+factor*std3 << endl; cout << "Rotation Index Error :"; if (p[0]>=mean1+factor*std1 || p[0]<=mean1-factor*std1) cout << " 0"; if (p[1]>=mean2+factor*std2 || p[1]<=mean2-factor*std2) cout << " 1"; if (p[2]>=mean3+factor*std3 || p[2]<=mean3-factor*std3) cout << " 2"; cout << endl; }//*/ badOrientation_ = true; } return transformation; }
// perform B-spline registration for 2D image void runBspline2D(StringVector& args) { typedef itk::BSplineTransform<double, 2, 3> TransformType; typedef itk::LBFGSOptimizer OptimizerType; typedef itk::MeanSquaresImageToImageMetric<RealImage2, RealImage2> MetricType; typedef itk:: LinearInterpolateImageFunction<RealImage2, double> InterpolatorType; typedef itk::ImageRegistrationMethod<RealImage2, RealImage2> RegistrationType; MetricType::Pointer metric = MetricType::New(); OptimizerType::Pointer optimizer = OptimizerType::New(); InterpolatorType::Pointer interpolator = InterpolatorType::New(); RegistrationType::Pointer registration = RegistrationType::New(); // The old registration framework has problems with multi-threading // For now, we set the number of threads to 1 registration->SetNumberOfThreads(1); registration->SetMetric( metric ); registration->SetOptimizer( optimizer ); registration->SetInterpolator( interpolator ); TransformType::Pointer transform = TransformType::New(); registration->SetTransform( transform ); ImageIO<RealImage2> io; // Create the synthetic images RealImage2::Pointer fixedImage = io.ReadImage(args[0]); RealImage2::Pointer movingImage = io.ReadImage(args[1]); // Setup the registration registration->SetFixedImage( fixedImage ); registration->SetMovingImage( movingImage); RealImage2::RegionType fixedRegion = fixedImage->GetBufferedRegion(); registration->SetFixedImageRegion( fixedRegion ); TransformType::PhysicalDimensionsType fixedPhysicalDimensions; TransformType::MeshSizeType meshSize; for( unsigned int i=0; i < 2; i++ ) { fixedPhysicalDimensions[i] = fixedImage->GetSpacing()[i] * static_cast<double>( fixedImage->GetLargestPossibleRegion().GetSize()[i] - 1 ); } unsigned int numberOfGridNodesInOneDimension = 18; meshSize.Fill( numberOfGridNodesInOneDimension - 3 ); transform->SetTransformDomainOrigin( fixedImage->GetOrigin() ); transform->SetTransformDomainPhysicalDimensions( fixedPhysicalDimensions ); transform->SetTransformDomainMeshSize( meshSize ); transform->SetTransformDomainDirection( fixedImage->GetDirection() ); typedef TransformType::ParametersType ParametersType; const unsigned int numberOfParameters = transform->GetNumberOfParameters(); ParametersType parameters( numberOfParameters ); parameters.Fill( 0.0 ); transform->SetParameters( parameters ); // We now pass the parameters of the current transform as the initial // parameters to be used when the registration process starts. registration->SetInitialTransformParameters( transform->GetParameters() ); std::cout << "Intial Parameters = " << std::endl; std::cout << transform->GetParameters() << std::endl; // Next we set the parameters of the LBFGS Optimizer. optimizer->SetGradientConvergenceTolerance( 0.005 ); optimizer->SetLineSearchAccuracy( 0.9 ); optimizer->SetDefaultStepLength( .1 ); optimizer->TraceOn(); optimizer->SetMaximumNumberOfFunctionEvaluations( 1000 ); std::cout << std::endl << "Starting Registration" << std::endl; try { registration->Update(); std::cout << "Optimizer stop condition = " << registration->GetOptimizer()->GetStopConditionDescription() << std::endl; } catch( itk::ExceptionObject & err ) { std::cerr << "ExceptionObject caught !" << std::endl; std::cerr << err << std::endl; return; } OptimizerType::ParametersType finalParameters = registration->GetLastTransformParameters(); std::cout << "Last Transform Parameters" << std::endl; std::cout << finalParameters << std::endl; transform->SetParameters( finalParameters ); typedef itk::ResampleImageFilter<RealImage2, RealImage2> ResampleFilterType; ResampleFilterType::Pointer resample = ResampleFilterType::New(); resample->SetTransform( transform ); resample->SetInput( movingImage ); resample->SetSize( fixedImage->GetLargestPossibleRegion().GetSize() ); resample->SetOutputOrigin( fixedImage->GetOrigin() ); resample->SetOutputSpacing( fixedImage->GetSpacing() ); resample->SetOutputDirection( fixedImage->GetDirection() ); resample->SetDefaultPixelValue( 100 ); resample->Update(); io.WriteImage(args[2], resample->GetOutput()); }
void BSplineRegistration::GenerateData2( itk::Image<TPixel, VImageDimension>* itkImage1) { std::cout << "start bspline registration" << std::endl; // Typedefs typedef typename itk::Image< TPixel, VImageDimension > InternalImageType; typedef typename itk::Vector< float, VImageDimension > VectorPixelType; typedef typename itk::Image< VectorPixelType, VImageDimension > DeformationFieldType; typedef itk::BSplineDeformableTransform< double, VImageDimension, 3 > TransformType; typedef typename TransformType::ParametersType ParametersType; //typedef itk::LBFGSOptimizer OptimizerType; typedef itk::SingleValuedNonLinearOptimizer OptimizerType; //typedef itk::SingleValuedCostFunction MetricType; typedef itk::MattesMutualInformationImageToImageMetric< InternalImageType, InternalImageType > MetricType; typedef itk::MeanSquaresImageToImageMetric< InternalImageType, InternalImageType > MetricTypeMS; typedef itk::LinearInterpolateImageFunction< InternalImageType, double > InterpolatorType; typedef itk::ImageRegistrationMethod< InternalImageType, InternalImageType > RegistrationType; typedef typename itk::WarpImageFilter< InternalImageType, InternalImageType, DeformationFieldType > WarperType; typedef typename TransformType::SpacingType SpacingType; typedef typename TransformType::OriginType OriginType; typedef itk::ResampleImageFilter< InternalImageType, InternalImageType > ResampleFilterType; typedef itk::Image< TPixel, VImageDimension > OutputImageType; // Sample new image with the same image type as the fixed image typedef itk::CastImageFilter< InternalImageType, InternalImageType > CastFilterType; typedef itk::Vector< float, VImageDimension > VectorType; typedef itk::Image< VectorType, VImageDimension > DeformationFieldType; typedef itk::BSplineDeformableTransformInitializer < TransformType, InternalImageType > InitializerType; typename InterpolatorType::Pointer interpolator = InterpolatorType::New(); typename RegistrationType::Pointer registration = RegistrationType::New(); typename InitializerType::Pointer initializer = InitializerType::New(); typename TransformType::Pointer transform = TransformType::New(); if(m_Metric==0 || m_Metric==1) { typename MetricType::Pointer metric = MetricType::New(); metric->SetNumberOfHistogramBins( 32); metric->SetNumberOfSpatialSamples(90000); registration->SetMetric( metric ); } else{ typename MetricTypeMS::Pointer metric = MetricTypeMS::New(); registration->SetMetric( metric ); } typename OptimizerFactory::Pointer optFac = OptimizerFactory::New(); optFac->SetOptimizerParameters(m_OptimizerParameters); optFac->SetNumberOfTransformParameters(transform->GetNumberOfParameters()); OptimizerType::Pointer optimizer = optFac->GetOptimizer(); optimizer->AddObserver(itk::AnyEvent(), m_Observer); //typedef mitk::MetricFactory <TPixel, VImageDimension> MetricFactoryType; //typename MetricFactoryType::Pointer metricFac = MetricFactoryType::New(); //metricFac->SetMetricParameters(m_MetricParameters); ////MetricType::Pointer metric = metricFac->GetMetric(); typename InternalImageType::Pointer fixedImage = InternalImageType::New(); mitk::CastToItkImage(m_ReferenceImage, fixedImage); typename InternalImageType::Pointer movingImage = itkImage1; typename InternalImageType::RegionType fixedRegion = fixedImage->GetBufferedRegion(); typename InternalImageType::RegionType movingRegion = movingImage->GetBufferedRegion(); if(m_MatchHistograms) { typedef itk::RescaleIntensityImageFilter<InternalImageType,InternalImageType> FilterType; typedef itk::HistogramMatchingImageFilter<InternalImageType,InternalImageType> HEFilterType; typename FilterType::Pointer inputRescaleFilter = FilterType::New(); typename FilterType::Pointer referenceRescaleFilter = FilterType::New(); referenceRescaleFilter->SetInput(fixedImage); inputRescaleFilter->SetInput(movingImage); TPixel desiredMinimum = 0; TPixel desiredMaximum = 255; referenceRescaleFilter->SetOutputMinimum( desiredMinimum ); referenceRescaleFilter->SetOutputMaximum( desiredMaximum ); referenceRescaleFilter->UpdateLargestPossibleRegion(); inputRescaleFilter->SetOutputMinimum( desiredMinimum ); inputRescaleFilter->SetOutputMaximum( desiredMaximum ); inputRescaleFilter->UpdateLargestPossibleRegion(); // Histogram match the images typename HEFilterType::Pointer intensityEqualizeFilter = HEFilterType::New(); intensityEqualizeFilter->SetReferenceImage( inputRescaleFilter->GetOutput() ); intensityEqualizeFilter->SetInput( referenceRescaleFilter->GetOutput() ); intensityEqualizeFilter->SetNumberOfHistogramLevels( 64 ); intensityEqualizeFilter->SetNumberOfMatchPoints( 12 ); intensityEqualizeFilter->ThresholdAtMeanIntensityOn(); intensityEqualizeFilter->Update(); //fixedImage = referenceRescaleFilter->GetOutput(); //movingImage = IntensityEqualizeFilter->GetOutput(); fixedImage = intensityEqualizeFilter->GetOutput(); movingImage = inputRescaleFilter->GetOutput(); } // registration->SetOptimizer( optimizer ); registration->SetInterpolator( interpolator ); registration->SetFixedImage( fixedImage ); registration->SetMovingImage( movingImage ); registration->SetFixedImageRegion(fixedRegion ); initializer->SetTransform(transform); initializer->SetImage(fixedImage); initializer->SetNumberOfGridNodesInsideTheImage( m_NumberOfGridPoints ); initializer->InitializeTransform(); registration->SetTransform( transform ); const unsigned int numberOfParameters = transform->GetNumberOfParameters(); typename itk::BSplineDeformableTransform< double, VImageDimension, 3 >::ParametersType parameters; parameters.set_size(numberOfParameters); parameters.Fill( 0.0 ); transform->SetParameters( parameters ); // We now pass the parameters of the current transform as the initial // parameters to be used when the registration process starts. registration->SetInitialTransformParameters( transform->GetParameters() ); std::cout << "Intial Parameters = " << std::endl; std::cout << transform->GetParameters() << std::endl; std::cout << std::endl << "Starting Registration" << std::endl; try { double tstart(clock()); registration->StartRegistration(); double time = clock() - tstart; time = time / CLOCKS_PER_SEC; MITK_INFO << "Registration time: " << time; } catch( itk::ExceptionObject & err ) { std::cerr << "ExceptionObject caught !" << std::endl; std::cerr << err << std::endl; } typename OptimizerType::ParametersType finalParameters = registration->GetLastTransformParameters(); std::cout << "Last Transform Parameters" << std::endl; std::cout << finalParameters << std::endl; transform->SetParameters( finalParameters ); /* ResampleFilterType::Pointer resampler = ResampleFilterType::New(); resampler->SetTransform( transform ); resampler->SetInput( movingImage ); resampler->SetSize( fixedImage->GetLargestPossibleRegion().GetSize() ); resampler->SetOutputOrigin( fixedImage->GetOrigin() ); resampler->SetOutputSpacing( fixedImage->GetSpacing() ); resampler->SetOutputDirection( fixedImage->GetDirection() ); resampler->SetDefaultPixelValue( 100 ); resampler->SetInterpolator( interpolator); resampler->Update();*/ // Generate deformation field typename DeformationFieldType::Pointer field = DeformationFieldType::New(); field->SetRegions( movingRegion ); field->SetOrigin( movingImage->GetOrigin() ); field->SetSpacing( movingImage->GetSpacing() ); field->SetDirection( movingImage->GetDirection() ); field->Allocate(); typedef itk::ImageRegionIterator< DeformationFieldType > FieldIterator; FieldIterator fi( field, movingRegion ); fi.GoToBegin(); typename TransformType::InputPointType fixedPoint; typename TransformType::OutputPointType movingPoint; typename DeformationFieldType::IndexType index; VectorType displacement; while( ! fi.IsAtEnd() ) { index = fi.GetIndex(); field->TransformIndexToPhysicalPoint( index, fixedPoint ); movingPoint = transform->TransformPoint( fixedPoint ); displacement = movingPoint - fixedPoint; fi.Set( displacement ); ++fi; } // Use the deformation field to warp the moving image typename WarperType::Pointer warper = WarperType::New(); warper->SetInput( movingImage ); warper->SetInterpolator( interpolator ); warper->SetOutputSpacing( movingImage->GetSpacing() ); warper->SetOutputOrigin( movingImage->GetOrigin() ); warper->SetOutputDirection( movingImage->GetDirection() ); warper->SetDeformationField( field ); warper->Update(); typename InternalImageType::Pointer result = warper->GetOutput(); if(m_UpdateInputImage) { Image::Pointer outputImage = this->GetOutput(); mitk::CastToMitkImage( result, outputImage ); } // Save the deformationfield resulting from the registration if(m_SaveDeformationField) { typedef itk::ImageFileWriter< DeformationFieldType > FieldWriterType; typename FieldWriterType::Pointer fieldWriter = FieldWriterType::New(); fieldWriter->SetInput( field ); fieldWriter->SetFileName( m_DeformationFileName ); try { fieldWriter->Update(); } catch( itk::ExceptionObject & excp ) { std::cerr << "Exception thrown " << std::endl; std::cerr << excp << std::endl; //return EXIT_FAILURE; } } }
void MutualInformationRegistration::updateRegistration() { if(!isReady()) return; convertVolumes(); //typedef itk::RegularStepGradientDescentOptimizer OptimizerType; typedef itk::VersorRigid3DTransformOptimizer OptimizerType; typedef OptimizerType::ScalesType OptimizerScalesType; typedef itk::LinearInterpolateImageFunction< InternalImageType, double > InterpolatorType; typedef itk::MattesMutualInformationImageToImageMetric< InternalImageType, InternalImageType > MetricType; typedef itk::MultiResolutionImageRegistrationMethod< InternalImageType, InternalImageType > RegistrationType; typedef itk::MultiResolutionPyramidImageFilter< InternalImageType, InternalImageType > FixedImagePyramidType; typedef itk::MultiResolutionPyramidImageFilter< InternalImageType, InternalImageType > MovingImagePyramidType; OptimizerType::Pointer optimizer = OptimizerType::New(); InterpolatorType::Pointer interpolator = InterpolatorType::New(); RegistrationType::Pointer registration = RegistrationType::New(); MetricType::Pointer metric = MetricType::New(); FixedImagePyramidType::Pointer fixedImagePyramid = FixedImagePyramidType::New(); MovingImagePyramidType::Pointer movingImagePyramid = MovingImagePyramidType::New(); registration->SetOptimizer(optimizer); registration->SetTransform(transform_); registration->SetInterpolator(interpolator); registration->SetMetric(metric); registration->SetFixedImagePyramid(fixedImagePyramid); registration->SetMovingImagePyramid(movingImagePyramid); OptimizerScalesType optimizerScales( transform_->GetNumberOfParameters() ); float rotScale = 1.0 / 1000.0f; optimizerScales[0] = 1.0f; optimizerScales[1] = 1.0f; optimizerScales[2] = 1.0f; optimizerScales[3] = rotScale; optimizerScales[4] = rotScale; optimizerScales[5] = rotScale; optimizer->SetScales( optimizerScales ); optimizer->SetMaximumStepLength(0.2); optimizer->SetMinimumStepLength(0.0001); InternalImageType::Pointer fixed = voreenToITK<float>(fixedVolumeFloat_); InternalImageType::Pointer moving = voreenToITK<float>(movingVolumeFloat_); registration->SetFixedImage(fixed); registration->SetMovingImage(moving); registration->SetFixedImageRegion( fixed->GetBufferedRegion() ); registration->SetInitialTransformParameters( transform_->GetParameters() ); metric->SetNumberOfHistogramBins(numHistogramBins_.get()); size_t numVoxels = hmul(fixedVolumeFloat_->getDimensions()); metric->SetNumberOfSpatialSamples(numVoxels * numSamples_.get()); metric->ReinitializeSeed( 76926294 ); //// Define whether to calculate the metric derivative by explicitly //// computing the derivatives of the joint PDF with respect to the Transform //// parameters, or doing it by progressively accumulating contributions from //// each bin in the joint PDF. metric->SetUseExplicitPDFDerivatives(explicitPDF_.get()); optimizer->SetNumberOfIterations(numIterations_.get()); optimizer->SetRelaxationFactor(relaxationFactor_.get()); // Create the Command observer and register it with the optimizer. CommandIterationUpdate::Pointer observer = CommandIterationUpdate::New(); optimizer->AddObserver( itk::IterationEvent(), observer ); typedef RegistrationInterfaceCommand<RegistrationType> CommandType; CommandType::Pointer command = CommandType::New(); registration->AddObserver( itk::IterationEvent(), command ); registration->SetNumberOfLevels(numLevels_.get()); try { registration->StartRegistration(); std::cout << "Optimizer stop condition: " << registration->GetOptimizer()->GetStopConditionDescription() << std::endl; } catch( itk::ExceptionObject & err ) { std::cout << "ExceptionObject caught !" << std::endl; std::cout << err << std::endl; //return EXIT_FAILURE; } ParametersType finalParameters = registration->GetLastTransformParameters(); transform_->SetParameters(finalParameters); unsigned int numberOfIterations = optimizer->GetCurrentIteration(); double bestValue = optimizer->GetValue(); // Print out results std::cout << "Result = " << std::endl; std::cout << " Versor " << finalParameters[0] << " " << finalParameters[1] << " " << finalParameters[2] << std::endl; std::cout << " Translation " << finalParameters[1] << " " << finalParameters[4] << " " << finalParameters[5] << std::endl; std::cout << " Iterations = " << numberOfIterations << std::endl; std::cout << " Metric value = " << bestValue << std::endl; invalidate(INVALID_RESULT); }
RealImage::Pointer bsplineRegistration(RealImage::Pointer srcImg, RealImage::Pointer dstImg) { const unsigned int SpaceDimension = ImageDimension; const unsigned int SplineOrder = 3; typedef double CoordinateRepType; typedef itk::BSplineTransform<CoordinateRepType, SpaceDimension, SplineOrder> TransformType; typedef itk::LBFGSOptimizer OptimizerType; typedef itk::MeanSquaresImageToImageMetric<ImageType, ImageType> MetricType; typedef itk::LinearInterpolateImageFunction<ImageType, double> InterpolatorType; typedef itk::ImageRegistrationMethod<ImageType, ImageType> RegistrationType; MetricType::Pointer metric = MetricType::New(); OptimizerType::Pointer optimizer = OptimizerType::New(); InterpolatorType::Pointer interpolator = InterpolatorType::New(); RegistrationType::Pointer registration = RegistrationType::New(); // The old registration framework has problems with multi-threading // For now, we set the number of threads to 1 // registration->SetNumberOfThreads(1); registration->SetMetric( metric ); registration->SetOptimizer( optimizer ); registration->SetInterpolator( interpolator ); TransformType::Pointer transform = TransformType::New(); registration->SetTransform( transform ); // Setup the registration registration->SetFixedImage( dstImg ); registration->SetMovingImage( srcImg); ImageType::RegionType fixedRegion = srcImg->GetBufferedRegion(); registration->SetFixedImageRegion( fixedRegion ); // Here we define the parameters of the BSplineDeformableTransform grid. We // arbitrarily decide to use a grid with $5 \times 5$ nodes within the image. // The reader should note that the BSpline computation requires a // finite support region ( 1 grid node at the lower borders and 2 // grid nodes at upper borders). Therefore in this example, we set // the grid size to be $8 \times 8$ and place the grid origin such that // grid node (1,1) coincides with the first pixel in the fixed image. TransformType::PhysicalDimensionsType fixedPhysicalDimensions; TransformType::MeshSizeType meshSize; for (unsigned int i=0; i < ImageDimension; i++) { fixedPhysicalDimensions[i] = dstImg->GetSpacing()[i] * static_cast<double>(dstImg->GetLargestPossibleRegion().GetSize()[i] - 1 ); meshSize[i] = dstImg->GetLargestPossibleRegion().GetSize()[i] / 8 - SplineOrder; } // unsigned int numberOfGridNodesInOneDimension = 15; // meshSize.Fill( numberOfGridNodesInOneDimension - SplineOrder ); transform->SetTransformDomainOrigin( dstImg->GetOrigin() ); transform->SetTransformDomainPhysicalDimensions( fixedPhysicalDimensions ); transform->SetTransformDomainMeshSize( meshSize ); transform->SetTransformDomainDirection( dstImg->GetDirection() ); typedef TransformType::ParametersType ParametersType; const unsigned int numberOfParameters = transform->GetNumberOfParameters(); ParametersType parameters( numberOfParameters ); parameters.Fill( 0.0 ); transform->SetParameters( parameters ); // We now pass the parameters of the current transform as the initial // parameters to be used when the registration process starts. registration->SetInitialTransformParameters( transform->GetParameters() ); std::cout << "Intial Parameters = " << std::endl; std::cout << transform->GetParameters() << std::endl; // Next we set the parameters of the LBFGS Optimizer. optimizer->SetGradientConvergenceTolerance(0.1); optimizer->SetLineSearchAccuracy(0.09); optimizer->SetDefaultStepLength(.1); optimizer->TraceOn(); optimizer->SetMaximumNumberOfFunctionEvaluations(1000); std::cout << std::endl << "Starting Registration" << std::endl; try { registration->Update(); std::cout << "Optimizer stop condition = " << registration->GetOptimizer()->GetStopConditionDescription() << std::endl; } catch (itk::ExceptionObject & err) { std::cerr << "ExceptionObject caught !" << std::endl; std::cerr << err << std::endl; return RealImage::Pointer(); } OptimizerType::ParametersType finalParameters = registration->GetLastTransformParameters(); std::cout << "Last Transform Parameters" << std::endl; std::cout << finalParameters << std::endl; transform->SetParameters( finalParameters ); typedef itk::ResampleImageFilter<ImageType, ImageType> ResampleFilterType; ResampleFilterType::Pointer resample = ResampleFilterType::New(); resample->SetTransform( transform ); resample->SetInput( srcImg ); resample->SetSize( dstImg->GetLargestPossibleRegion().GetSize() ); resample->SetOutputOrigin( dstImg->GetOrigin() ); resample->SetOutputSpacing( dstImg->GetSpacing() ); resample->SetOutputDirection( dstImg->GetDirection() ); resample->SetDefaultPixelValue( 100 ); resample->Update(); return resample->GetOutput(); }
typename TImage::Pointer modelBasedImageToImageRegistration(std::string referenceFilename, std::string targetFilename, typename TStatisticalModelType::Pointer model, std::string outputDfFilename, unsigned numberOfIterations){ typedef itk::ImageFileReader<TImage> ImageReaderType; typedef itk::InterpolatingStatisticalDeformationModelTransform<TRepresenter, double, VImageDimension> TransformType; typedef itk::LBFGSOptimizer OptimizerType; typedef itk::ImageRegistrationMethod<TImage, TImage> RegistrationFilterType; typedef itk::WarpImageFilter< TImage, TImage, TVectorImage > WarperType; typedef itk::LinearInterpolateImageFunction< TImage, double > InterpolatorType; typename ImageReaderType::Pointer referenceReader = ImageReaderType::New(); referenceReader->SetFileName(referenceFilename.c_str()); referenceReader->Update(); typename TImage::Pointer referenceImage = referenceReader->GetOutput(); referenceImage->Update(); typename ImageReaderType::Pointer targetReader = ImageReaderType::New(); targetReader->SetFileName(targetFilename.c_str()); targetReader->Update(); typename TImage::Pointer targetImage = targetReader->GetOutput(); targetImage->Update(); // do the fitting typename TransformType::Pointer transform = TransformType::New(); transform->SetStatisticalModel(model); transform->SetIdentity(); // Setting up the fitting OptimizerType::Pointer optimizer = OptimizerType::New(); optimizer->MinimizeOn(); optimizer->SetMaximumNumberOfFunctionEvaluations(numberOfIterations); typedef IterationStatusObserver ObserverType; ObserverType::Pointer observer = ObserverType::New(); optimizer->AddObserver( itk::IterationEvent(), observer ); typename TMetricType::Pointer metric = TMetricType::New(); typename InterpolatorType::Pointer interpolator = InterpolatorType::New(); typename RegistrationFilterType::Pointer registration = RegistrationFilterType::New(); registration->SetInitialTransformParameters(transform->GetParameters()); registration->SetMetric(metric); registration->SetOptimizer( optimizer ); registration->SetTransform( transform ); registration->SetInterpolator( interpolator ); registration->SetFixedImage( targetImage ); registration->SetFixedImageRegion(targetImage->GetBufferedRegion() ); registration->SetMovingImage( referenceImage ); try { std::cout << "Performing registration... " << std::flush; registration->Update(); std::cout << "[done]" << std::endl; } catch ( itk::ExceptionObject& o ) { std::cout << "caught exception " << o << std::endl; } typename TVectorImage::Pointer df = model->DrawSample(transform->GetCoefficients()); // write deformation field if(outputDfFilename.size()>0){ typename itk::ImageFileWriter<TVectorImage>::Pointer df_writer = itk::ImageFileWriter<TVectorImage>::New(); df_writer->SetFileName(outputDfFilename); df_writer->SetInput(df); df_writer->Update(); } // warp reference std::cout << "Warping reference... " << std::flush; typename WarperType::Pointer warper = WarperType::New(); warper->SetInput(referenceImage ); warper->SetInterpolator( interpolator ); warper->SetOutputSpacing( targetImage->GetSpacing() ); warper->SetOutputOrigin( targetImage->GetOrigin() ); warper->SetOutputDirection( targetImage->GetDirection() ); warper->SetDisplacementField( df ); warper->Update(); std::cout << "[done]" << std::endl; return warper->GetOutput(); }
void QAngioSubstractionExtension::computeAutomateSingleImage() { QApplication::setOverrideCursor(Qt::WaitCursor); const unsigned int Dimension = 2; typedef Volume::ItkPixelType PixelType; typedef itk::Image< PixelType, Dimension > FixedImageType; typedef itk::Image< PixelType, Dimension > MovingImageType; typedef float InternalPixelType; typedef itk::Image< InternalPixelType, Dimension > InternalImageType; typedef itk::TranslationTransform< double, Dimension > TransformType; typedef itk::GradientDescentOptimizer OptimizerType; typedef itk::LinearInterpolateImageFunction< InternalImageType, double > InterpolatorType; typedef itk::ImageRegistrationMethod< InternalImageType, InternalImageType > RegistrationType; typedef itk::MutualInformationImageToImageMetric< InternalImageType, InternalImageType > MetricType; TransformType::Pointer transform = TransformType::New(); OptimizerType::Pointer optimizer = OptimizerType::New(); InterpolatorType::Pointer interpolator = InterpolatorType::New(); RegistrationType::Pointer registration = RegistrationType::New(); registration->SetOptimizer(optimizer); registration->SetTransform(transform); registration->SetInterpolator(interpolator); MetricType::Pointer metric = MetricType::New(); registration->SetMetric(metric); metric->SetFixedImageStandardDeviation(0.4); metric->SetMovingImageStandardDeviation(0.4); metric->SetNumberOfSpatialSamples(50); typedef itk::ExtractImageFilter< Volume::ItkImageType, FixedImageType > FilterType; FilterType::Pointer extractFixedImageFilter = FilterType::New(); Volume::ItkImageType::RegionType inputRegion = m_mainVolume->getItkData()->GetLargestPossibleRegion(); Volume::ItkImageType::SizeType size = inputRegion.GetSize(); //Dividim la mida per dos per tal de quedar-nos només amb la part central // ja que si no ens registre el background size[0] = size[0] / 2; size[1] = size[1] / 2; size[2] = 0; Volume::ItkImageType::IndexType start = inputRegion.GetIndex(); const unsigned int sliceReference = m_imageSelectorSpinBox->value(); //comencem a un quart de la imatge start[0] = size[0] / 2; start[1] = size[1] / 2; start[2] = sliceReference; Volume::ItkImageType::RegionType desiredRegion; desiredRegion.SetSize(size); desiredRegion.SetIndex(start); extractFixedImageFilter->SetExtractionRegion(desiredRegion); extractFixedImageFilter->SetInput(m_mainVolume->getItkData()); extractFixedImageFilter->Update(); FilterType::Pointer extractMovingImageFilter = FilterType::New(); Volume::ItkImageType::IndexType startMoving = inputRegion.GetIndex(); const unsigned int sliceNumber = m_2DView_1->getViewer()->getCurrentSlice(); startMoving[0] = size[0] / 2; startMoving[1] = size[1] / 2; startMoving[2] = sliceNumber; Volume::ItkImageType::RegionType desiredMovingRegion; desiredMovingRegion.SetSize(size); desiredMovingRegion.SetIndex(startMoving); extractMovingImageFilter->SetExtractionRegion(desiredMovingRegion); extractMovingImageFilter->SetInput(m_mainVolume->getItkData()); extractMovingImageFilter->Update(); typedef itk::NormalizeImageFilter< FixedImageType, InternalImageType > FixedNormalizeFilterType; typedef itk::NormalizeImageFilter< MovingImageType, InternalImageType > MovingNormalizeFilterType; FixedNormalizeFilterType::Pointer fixedNormalizer = FixedNormalizeFilterType::New(); MovingNormalizeFilterType::Pointer movingNormalizer = MovingNormalizeFilterType::New(); typedef itk::DiscreteGaussianImageFilter< InternalImageType, InternalImageType > GaussianFilterType; GaussianFilterType::Pointer fixedSmoother = GaussianFilterType::New(); GaussianFilterType::Pointer movingSmoother = GaussianFilterType::New(); fixedSmoother->SetVariance(2.0); movingSmoother->SetVariance(2.0); fixedNormalizer->SetInput(extractFixedImageFilter->GetOutput()); movingNormalizer->SetInput(extractMovingImageFilter->GetOutput()); fixedSmoother->SetInput(fixedNormalizer->GetOutput()); movingSmoother->SetInput(movingNormalizer->GetOutput()); registration->SetFixedImage(fixedSmoother->GetOutput()); registration->SetMovingImage(movingSmoother->GetOutput()); fixedNormalizer->Update(); registration->SetFixedImageRegion( fixedNormalizer->GetOutput()->GetBufferedRegion()); typedef RegistrationType::ParametersType ParametersType; ParametersType initialParameters(transform->GetNumberOfParameters()); initialParameters[0] = 0.0; // Initial offset in mm along X initialParameters[1] = 0.0; // Initial offset in mm along Y registration->SetInitialTransformParameters(initialParameters); optimizer->SetLearningRate(20.0); optimizer->SetNumberOfIterations(200); optimizer->MaximizeOn(); try { registration->Update(); } catch(itk::ExceptionObject & err) { std::cout << "ExceptionObject caught !" << std::endl; std::cout << err << std::endl; return; } ParametersType finalParameters = registration->GetLastTransformParameters(); double TranslationAlongX = finalParameters[0]; double TranslationAlongY = finalParameters[1]; // Print out results // DEBUG_LOG(QString("Result = ")); DEBUG_LOG(QString(" Translation X = %1").arg(TranslationAlongX)); DEBUG_LOG(QString(" Translation Y = %1").arg(TranslationAlongY)); DEBUG_LOG(QString(" Iterations = %1").arg(optimizer->GetCurrentIteration())); DEBUG_LOG(QString(" Metric value = %1").arg(optimizer->GetValue())); double spacing[3]; m_mainVolume->getSpacing(spacing); DEBUG_LOG(QString(" Translation X (in px) = %1").arg(TranslationAlongX / spacing[0])); DEBUG_LOG(QString(" Translation Y (in px) = %1").arg(TranslationAlongY / spacing[1])); //Actualitzem les dades de la transdifference tool m_toolManager->triggerTool("TransDifferenceTool"); TransDifferenceTool* tdTool = static_cast<TransDifferenceTool*> (m_2DView_2->getViewer()->getToolProxy()->getTool("TransDifferenceTool")); if(m_tdToolData == 0){ m_tdToolData = static_cast<TransDifferenceToolData*> (tdTool->getToolData()); } if(m_tdToolData->getInputVolume() != m_mainVolume){ m_tdToolData->setInputVolume(m_mainVolume); } tdTool->setSingleDifferenceImage(TranslationAlongX / spacing[0],TranslationAlongY / spacing[1]); m_toolManager->triggerTool("SlicingTool"); /* typedef itk::Image< PixelType, Dimension > FixedImageType; typedef itk::Image< PixelType, Dimension > MovingImageType; typedef itk::TranslationTransform< double, Dimension > TransformType; typedef itk::RegularStepGradientDescentOptimizer OptimizerType; typedef itk::MattesMutualInformationImageToImageMetric< FixedImageType, MovingImageType > MetricType; typedef itk:: LinearInterpolateImageFunction< MovingImageType, double > InterpolatorType; typedef itk::ImageRegistrationMethod< FixedImageType, MovingImageType > RegistrationType; MetricType::Pointer metric = MetricType::New(); TransformType::Pointer transform = TransformType::New(); OptimizerType::Pointer optimizer = OptimizerType::New(); InterpolatorType::Pointer interpolator = InterpolatorType::New(); RegistrationType::Pointer registration = RegistrationType::New(); registration->SetMetric(metric); registration->SetOptimizer(optimizer); registration->SetTransform(transform); registration->SetInterpolator(interpolator); metric->SetNumberOfHistogramBins(50); metric->SetNumberOfSpatialSamples(10000); typedef itk::ExtractImageFilter< Volume::ItkImageType, FixedImageType > FilterType; FilterType::Pointer extractFixedImageFilter = FilterType::New(); Volume::ItkImageType::RegionType inputRegion = m_mainVolume->getItkData()->GetLargestPossibleRegion(); Volume::ItkImageType::SizeType size = inputRegion.GetSize(); //Dividim la mida per dos per tal de quedar-nos només amb la part central // ja que si no ens registre el background size[0] = size[0] / 2; size[1] = size[1] / 2; size[2] = 0; Volume::ItkImageType::IndexType start = inputRegion.GetIndex(); const unsigned int sliceReference = m_imageSelectorSpinBox->value(); //comencem a un quart de la imatge start[0] = size[0] / 2; start[1] = size[1] / 2; start[2] = sliceReference; Volume::ItkImageType::RegionType desiredRegion; desiredRegion.SetSize(size); desiredRegion.SetIndex(start); extractFixedImageFilter->SetExtractionRegion(desiredRegion); extractFixedImageFilter->SetInput(m_mainVolume->getItkData()); extractFixedImageFilter->Update(); FilterType::Pointer extractMovingImageFilter = FilterType::New(); Volume::ItkImageType::IndexType startMoving = inputRegion.GetIndex(); const unsigned int sliceNumber = m_2DView_1->getViewer()->getCurrentSlice(); startMoving[0] = size[0] / 2; startMoving[1] = size[1] / 2; startMoving[2] = sliceNumber; Volume::ItkImageType::RegionType desiredMovingRegion; desiredMovingRegion.SetSize(size); desiredMovingRegion.SetIndex(startMoving); extractMovingImageFilter->SetExtractionRegion(desiredMovingRegion); extractMovingImageFilter->SetInput(m_mainVolume->getItkData()); extractMovingImageFilter->Update(); registration->SetFixedImage(extractFixedImageFilter->GetOutput()); registration->SetMovingImage(extractMovingImageFilter->GetOutput()); typedef RegistrationType::ParametersType ParametersType; ParametersType initialParameters(transform->GetNumberOfParameters()); //Potser seria millor posar la transformada que té actualment initialParameters[0] = 0.0; // Initial offset in mm along X initialParameters[1] = 0.0; // Initial offset in mm along Y registration->SetInitialTransformParameters(initialParameters); optimizer->SetMaximumStepLength(4.00); optimizer->SetMinimumStepLength(0.005); optimizer->SetNumberOfIterations(200); try { registration->StartRegistration(); } catch(itk::ExceptionObject & err) { DEBUG_LOG(QString("ExceptionObject caught !")); std::cout<<err<<std::endl; return; } ParametersType finalParameters = registration->GetLastTransformParameters(); const double TranslationAlongX = finalParameters[0]; const double TranslationAlongY = finalParameters[1]; const unsigned int numberOfIterations = optimizer->GetCurrentIteration(); const double bestValue = optimizer->GetValue(); DEBUG_LOG(QString("Result = ")); DEBUG_LOG(QString(" Translation X = %1").arg(TranslationAlongX)); DEBUG_LOG(QString(" Translation Y = %1").arg(TranslationAlongY)); DEBUG_LOG(QString(" Iterations = %1").arg(numberOfIterations)); DEBUG_LOG(QString(" Metric value = %1").arg(bestValue)); typedef unsigned char OutputPixelType; typedef itk::Image< OutputPixelType, Dimension > OutputImageType; typedef itk::RescaleIntensityImageFilter< FixedImageType, FixedImageType > RescaleFilterType; typedef itk::ResampleImageFilter< FixedImageType, FixedImageType > ResampleFilterType; typedef itk::CastImageFilter< FixedImageType, OutputImageType > CastFilterType; typedef itk::ImageFileWriter< OutputImageType > WriterType; WriterType::Pointer writer = WriterType::New(); CastFilterType::Pointer caster = CastFilterType::New(); ResampleFilterType::Pointer resample = ResampleFilterType::New(); RescaleFilterType::Pointer rescaler = RescaleFilterType::New(); rescaler->SetOutputMinimum(0); rescaler->SetOutputMaximum(255); TransformType::Pointer finalTransform = TransformType::New(); finalTransform->SetParameters(finalParameters); resample->SetTransform(finalTransform); resample->SetSize(extractMovingImageFilter->GetOutput()->GetLargestPossibleRegion().GetSize()); resample->SetOutputOrigin(extractMovingImageFilter->GetOutput()->GetOrigin()); resample->SetOutputSpacing(extractMovingImageFilter->GetOutput()->GetSpacing()); resample->SetDefaultPixelValue(100); writer->SetFileName("prova.jpg"); rescaler->SetInput(extractMovingImageFilter->GetOutput()); resample->SetInput(rescaler->GetOutput()); caster->SetInput(resample->GetOutput()); writer->SetInput(caster->GetOutput()); writer->Update(); */ QApplication::restoreOverrideCursor(); }