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();
}
