/// <summary>
/// Write transformed image and deformation field to disk
/// </summary>
/// <param name="filename"></param>
/// <param name="transformparams"></param>
private void WriteTransform(string filename, List <sitk.VectorOfParameterMap> transformparams)
{
string resultFilename = ReadWriteUtils.GetOutputDirectory(_parameters) + "\\" + Path.GetFileNameWithoutExtension(filename) + ".png";
// add transform parameter map to registration parameters
if (_parameters.TransformationParameterMap.ContainsKey(resultFilename))
{
_parameters.TransformationParameterMap.Remove(resultFilename);
}
_parameters.TransformationParameterMap.Add(resultFilename, transformparams);
// read moving image from file
sitk.Image movingImageToTransform = ReadWriteUtils.ReadITKImageFromFile(filename, sitk.PixelIDValueEnum.sitkVectorUInt8);
// initialize transform instance
TransformRGB trans = new TransformRGB(movingImageToTransform, transformparams, _parameters);
if (_parameters.IsBinaryTransform)
{
// for binary reg set interpolation order to zero
trans.SetInterpolationOrder(0);
}
trans.Execute();
trans.WriteTransformedImage(resultFilename);
// write deformation field
sitk.Image deformationField = trans.GetDeformationField();
string filenameDeformationField = ReadWriteUtils.GetOutputDirectory(_parameters, _parameters.Iteration) + "\\deformationField.mhd";
ReadWriteUtils.WriteSitkImage(deformationField, filenameDeformationField);
trans.Dispose();
movingImageToTransform.Dispose();
}
/// <summary>
/// Get the coefficient map of inner structures of tissue for the transform rigidity penalty term.
/// </summary>
/// <param name="filename">image filename</param>
/// <returns>return coefficient map filename</returns>
private string GetInnerStructureSegmentationsAsCoefficientMap(string filename)
{
InnerTissueSegmentation innerSegImage = GetInnerStructureSegmentation(filename);
string filenameCoefficientMap = ReadWriteUtils.GetOutputDirectory(_parameters, _parameters.Iteration) + Constants.cCoefficientFilename;
ReadWriteUtils.WriteUMatToFile(filenameCoefficientMap, innerSegImage.GetOutput().FirstOrDefault());
innerSegImage.Dispose();
// rescale image
sitk.Image img = ReadWriteUtils.ReadITKImageFromFile(filenameCoefficientMap);
sitk.CastImageFilter castFilter = new sitk.CastImageFilter();
castFilter.SetOutputPixelType(sitk.PixelIDValueEnum.sitkFloat32);
img = castFilter.Execute(img);
sitk.RescaleIntensityImageFilter filter = new sitk.RescaleIntensityImageFilter();
filter.SetOutputMinimum(0.0);
filter.SetOutputMaximum(1.0);
sitk.Image coefficientMap = filter.Execute(img);
// save as mhd
filenameCoefficientMap = ReadWriteUtils.GetOutputDirectory(_parameters, _parameters.Iteration) + Constants.cCoefficientFilename;
ReadWriteUtils.WriteSitkImage(coefficientMap, filenameCoefficientMap);
coefficientMap.Dispose();
return(filenameCoefficientMap);
}
/// <summary>
/// Add moving / template mask if necessary and start registration.
/// </summary>
/// <param name="refImage">reference image</param>
/// <param name="movImage">template image</param>
/// <param name="fixedMask">fixd mask (can be null)</param>
/// <param name="movingImageFilename">filename of the template image</param>
/// <returns></returns>
private List <sitk.VectorOfParameterMap> PerformRegistration(sitk.Image refImage, sitk.Image movImage, sitk.Image fixedMask, string movingImageFilename)
{
sitk.Image movingMask = null;
if (_parameters.UseMovingMask ||
_parameters.RigidOptions == MaskedRigidRegistrationOptions.BinaryRegistrationInnerStructures ||
_parameters.RigidOptions == MaskedRigidRegistrationOptions.BinaryRegistrationWholeTissue ||
_parameters.RigidOptions == MaskedRigidRegistrationOptions.ComponentwiseRegistration)
{
movingMask = GetMask(movingImageFilename, false);
ReadWriteUtils.WriteSitkImage(movingMask, _parameters.OutputDirectory + "\\moving_mask.png");
}
if (_parameters.Type == RegistrationType.Multiple)
{
return(PerformMultipleParamFilesRegistration(refImage, movImage, fixedMask, movingMask, movingImageFilename));
}
else if (_parameters.Type == RegistrationType.Rigid)
{
// do rigid registration
return(PerformRigidRegistration(refImage, movImage, fixedMask, movingMask, movingImageFilename));
}
else
{
// do non rigid registration
return(PerformNonRigidRegistration(refImage, movImage, fixedMask, movingMask, movingImageFilename));
}
}
/// <summary>
/// Run registration with the predecessor of the current image as fixed image.
/// </summary>
/// <param name="imageStack">image stack as list of filenames</param>
private void RunRegistrationPreviousOrder(List <string> imageStack)
{
// TO CHECK
for (int i = 1; i < imageStack.Count; i++)
{
Stopwatch stopWatch = new Stopwatch();
string elapsed;
_parameters.Iteration = i - 1;
_parameters.FixedImageFilename = imageStack[_parameters.Iteration];
_worker.ReportProgress(0, "Load reference image...");
// load and resize fixed / reference image
sitk.Image referenceImage = LoadAndResizeImage(_parameters.FixedImageFilename, _parameters.FixedImageFilename);
// set mask if defined in parameters
sitk.Image fixedMask = null;
if (_parameters.UseFixedMask)
{
stopWatch.Start();
fixedMask = GetMask(_parameters.FixedImageFilename, true);
ReadWriteUtils.WriteSitkImage(fixedMask, _parameters.OutputDirectory + "\\fixed_mask.png");
stopWatch.Stop();
elapsed = string.Format("[{0}m {1}s]", stopWatch.Elapsed.Minutes, stopWatch.Elapsed.Seconds);
_worker.ReportProgress(0, string.Format("Created fixed mask (Elapsed time: {0}) ..."));
}
_worker.ReportProgress(0, "Load template image...");
// load and resize moving / template image
sitk.Image templateImage = LoadAndResizeImage(imageStack[i], imageStack[i]);
_worker.ReportProgress(0, "Start registration.");
stopWatch.Reset();
stopWatch.Start();
// start actual registration
List <sitk.VectorOfParameterMap> transformparams = PerformRegistration(referenceImage, templateImage, fixedMask, imageStack[i]);
stopWatch.Stop();
elapsed = string.Format("[{0}m {1}s]", stopWatch.Elapsed.Minutes, stopWatch.Elapsed.Seconds);
_worker.ReportProgress((99 / imageStack.Count) / 2, string.Format("Registration done (Elapsed time: {0}). Writing transform file...", elapsed));
stopWatch.Reset();
stopWatch.Start();
// transform moving image according to the transformation parameters
WriteTransform(imageStack[i], transformparams);
stopWatch.Stop();
elapsed = string.Format("[{0}m {1}s]", stopWatch.Elapsed.Minutes, stopWatch.Elapsed.Seconds);
_worker.ReportProgress((99 / imageStack.Count) / 2, string.Format("Transformed image was written to output directory. (Elaspsed time: {0})", elapsed));
}
_worker.ReportProgress(100, "Registration done.");
}
private void buttonDiffImage_Click(object sender, EventArgs e)
{
Cursor.Current = Cursors.WaitCursor;
string fixedImageFilename = registrationParameters.FixedImageFilename;
string movingImageFilename = comboBoxMovingImage.SelectedValue.ToString();
// read images
var img01 = ReadWriteUtils.ReadITKImageFromFile(fixedImageFilename);
var img02 = ReadWriteUtils.ReadITKImageFromFile(movingImageFilename);
var difference = VisualizationEvaluationUtils.GetTotalDifferenceImage(img01, img02);
ReadWriteUtils.WriteSitkImage(difference, registrationParameters.OutputDirectory + "\\difference.png");
img01.Dispose();
img02.Dispose();
difference.Dispose();
Cursor.Current = Cursors.Default;
}
private void buttonCheckerBoard_Click(object sender, EventArgs e)
{
Cursor.Current = Cursors.WaitCursor;
string fixedImageFilename = registrationParameters.FixedImageFilename;
string movingImageFilename = comboBoxMovingImage.SelectedValue.ToString();
uint size = (uint)numericUpDownCheckerSize.Value;
// read images
//var img01 = ReadWriteUtils.ReadITKImageFromFile(fixedImageFilename);
//var img02 = ReadWriteUtils.ReadITKImageFromFile(movingImageFilename);
var checkerboard = VisualizationEvaluationUtils.GetCheckerBoardV2(fixedImageFilename, movingImageFilename, size);
ReadWriteUtils.WriteSitkImage(checkerboard, registrationParameters.OutputDirectory + "\\checkerboard.png");
//img01.Dispose();
//img02.Dispose();
checkerboard.Dispose();
Cursor.Current = Cursors.Default;
}
/// <summary>
/// Load and resize image depending on the width and height of the largest image in stack.
/// </summary>
/// <param name="filename">filename of the image to load</param>
/// <param name="writeFilename">output filename if image should be written back to disk</param>
/// <returns>simpleitk image</returns>
private sitk.Image LoadAndResizeImage(string filename, string writeFilename = null)
{
sitk.Image refImage = ReadWriteUtils.ReadITKImageFromFile(filename, sitk.PixelIDValueEnum.sitkVectorUInt8);
if (refImage.GetWidth() == _parameters.LargestImageWidth && refImage.GetHeight() == _parameters.LargestImageHeight)
{
return(refImage);
}
else
{
sitk.Image refResized = ImageUtils.ResizeImage(refImage, _parameters.LargestImageWidth, _parameters.LargestImageHeight);
// write image if output filename is defined
if (writeFilename != null)
{
ReadWriteUtils.WriteSitkImage(refResized, Path.Combine(_parameters.OutputDirectory, Path.GetFileName(writeFilename)));
}
return(refResized);
}
}
/// <summary>
/// Run registration with fixed image as first or last image in stack.
/// </summary>
/// <param name="imageStack">image stack as list of filenames</param>
/// <param name="firstAsReference">flag to specify if first or last image is taken as reference image</param>
private void RunRegistrationFirstOrLastInStackOrder(List <string> imageStack, bool firstAsReference)
{
Stopwatch stopWatch = new Stopwatch();
string elapsed;
// set fixed image filename
if (firstAsReference)
{
_parameters.FixedImageFilename = imageStack.First();
}
else
{
_parameters.FixedImageFilename = imageStack.Last();
}
_worker.ReportProgress(0, "Load reference image...");
// load fixed / reference image once and resize
sitk.Image referenceImage = LoadAndResizeImage(_parameters.FixedImageFilename);
// set fixed mask if defined in parameters
sitk.Image fixedMask = null;
if (_parameters.UseFixedMask ||
_parameters.RigidOptions == MaskedRigidRegistrationOptions.BinaryRegistrationInnerStructures ||
_parameters.RigidOptions == MaskedRigidRegistrationOptions.BinaryRegistrationWholeTissue ||
_parameters.RigidOptions == MaskedRigidRegistrationOptions.ComponentwiseRegistration)
{
stopWatch.Start();
fixedMask = GetMask(_parameters.FixedImageFilename, true);
ReadWriteUtils.WriteSitkImage(fixedMask, _parameters.OutputDirectory + "\\fixed_mask.png");
elapsed = string.Format("[{0}m {1}s]", stopWatch.Elapsed.Minutes, stopWatch.Elapsed.Seconds);
_worker.ReportProgress(0, string.Format("Created fixed mask (Elapsed time: {0}) ...", elapsed));
}
int i = 0;
foreach (string filename in imageStack)
{
_parameters.Iteration = i++;
if (filename == _parameters.FixedImageFilename)
{
continue;
}
_worker.ReportProgress(0, "Load template image...");
// load and resize moving / template image
sitk.Image templateImage = LoadAndResizeImage(filename, filename);
_worker.ReportProgress(0, "Start registration.");
stopWatch.Reset();
stopWatch.Start();
// start actual registration
List <sitk.VectorOfParameterMap> transformparams = PerformRegistration(referenceImage, templateImage, fixedMask, filename);
stopWatch.Stop();
elapsed = string.Format("[{0}m {1}s]", stopWatch.Elapsed.Minutes, stopWatch.Elapsed.Seconds);
_worker.ReportProgress((99 / imageStack.Count) / 2, string.Format("Registration done (Elapsed time: {0}). Writing transform file...", elapsed));
// transform moving image according to the transformation parameters
stopWatch.Reset();
stopWatch.Start();
WriteTransform(filename, transformparams);
stopWatch.Stop();
elapsed = string.Format("[{0}m {1}s]", stopWatch.Elapsed.Minutes, stopWatch.Elapsed.Seconds);
_worker.ReportProgress((99 / imageStack.Count) / 2, string.Format("Transformed image was written to output directory. (Elaspsed time: {0})", elapsed));
}
_worker.ReportProgress(100, "Registration done.");
}
