/// <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.");
}
/// <summary>
/// Execute transformation of rgb image.
/// </summary>
public void Execute()
{
string outputDir = ReadWriteUtils.GetOutputDirectory(registrationParameters, registrationParameters.Iteration);
if (Directory.Exists(outputDir))
{
Directory.CreateDirectory(outputDir);
}
// split rgb channels
sitk.VectorIndexSelectionCastImageFilter rgbVector = new sitk.VectorIndexSelectionCastImageFilter();
sitk.Image redChannel = rgbVector.Execute(movingImage, 0, sitk.PixelIDValueEnum.sitkFloat32);
sitk.Image greenChannel = rgbVector.Execute(movingImage, 1, sitk.PixelIDValueEnum.sitkFloat32);
sitk.Image blueChannel = rgbVector.Execute(movingImage, 2, sitk.PixelIDValueEnum.sitkFloat32);
foreach (var parameter in parameterMaps[0])
{
parameter["DefaultPixelValue"][0] = "255.0";
parameter["ResultImagePixelType"][0] = "short";
if (parameter.ContainsKey("UseBinaryFormatForTransformationParameters"))
{
parameter.Remove("UseBinaryFormatForTransformationParameters");
}
if (interpolationOrder != -1)
{
parameter["FinalBSplineInterpolationOrder"][0] = interpolationOrder.ToString();
}
else
{
parameter["FinalBSplineInterpolationOrder"][0] = "3";
}
if (parameter["Transform"][0] == "SimilarityTransform" ||
registrationParameters.RegistrationDefaultParams == RegistrationDefaultParameters.similarity)
{
sitk.VectorString vec = new sitk.VectorString();
vec.Add((registrationParameters.LargestImageWidth / 2).ToString()); // fixed image width / 2
vec.Add((registrationParameters.LargestImageHeight / 2).ToString()); // fixed image height / 2
parameter.Add("CenterOfRotationPoint", vec);
}
}
// initialize transformix
transformix.SetOutputDirectory(outputDir);
transformix.SetTransformParameterMap(parameterMaps.First()[0]);
// add further transform parameters
if (parameterMaps[0].Count > 1)
{
for (int i = 1; i < parameterMaps[0].Count; i++)
{
var vectorParameterMap = parameterMaps[0][i];
transformix.AddTransformParameterMap(vectorParameterMap);
}
}
transformix.ComputeDeformationFieldOn();
transformix.LogToFileOn();
if (registrationParameters.ComputeJaccobian)
{
transformix.ComputeSpatialJacobianOn();
transformix.ComputeDeterminantOfSpatialJacobianOn();
}
transformix.PrintParameterMap();
// red
transformix.SetMovingImage(redChannel);
sitk.Image resultRedChannel = transformix.Execute();
resultRedChannel = TransformationUtils.InterpolateImage(resultRedChannel, sitk.InterpolatorEnum.sitkBSplineResamplerOrder3, sitk.PixelIDValueEnum.sitkUInt8);
//ReadWriteUtils.WriteSitkImageWithPreCast(resultRedChannel, registrationParameters.OutputDirectory + "\\red_channel.png");
// green
transformix.SetMovingImage(greenChannel);
sitk.Image resultGreenChannel = transformix.Execute();
resultGreenChannel = TransformationUtils.InterpolateImage(resultGreenChannel, sitk.InterpolatorEnum.sitkBSplineResamplerOrder3, sitk.PixelIDValueEnum.sitkUInt8);
//ReadWriteUtils.WriteSitkImageWithPreCast(resultGreenChannel, registrationParameters.OutputDirectory + "\\green_channel.png");
// blue
transformix.SetMovingImage(blueChannel);
sitk.Image resultBlueChannel = transformix.Execute();
resultBlueChannel = TransformationUtils.InterpolateImage(resultBlueChannel, sitk.InterpolatorEnum.sitkBSplineResamplerOrder3, sitk.PixelIDValueEnum.sitkUInt8);
//ReadWriteUtils.WriteSitkImageWithPreCast(resultBlueChannel, registrationParameters.OutputDirectory + "\\blue_channel.png");
// compose image channels
sitk.VectorOfImage vectorImages = new sitk.VectorOfImage();
vectorImages.Add(resultRedChannel);
vectorImages.Add(resultGreenChannel);
vectorImages.Add(resultBlueChannel);
sitk.ComposeImageFilter composeImageFilter = new sitk.ComposeImageFilter();
sitk.Image composedImage = composeImageFilter.Execute(vectorImages);
if (registrationParameters.Type == RegistrationType.NonRigid)
{
transformedImage = TransformationUtils.InterpolateImage(composedImage, sitk.InterpolatorEnum.sitkBSplineResamplerOrder5, composedImage.GetPixelID());
}
else
{
transformedImage = composedImage;
}
transformedImage = composedImage;
// interpolation of output image (needs to be improved -> currently theres a little loss in quality)
// possible solution: interpolate grayscale images and compose afterwards
/*sitk.ExpandImageFilter expandImageFilter = new sitk.ExpandImageFilter();
* expandImageFilter.SetInterpolator(sitk.InterpolatorEnum.sitkLinear);
* transformedImage = expandImageFilter.Execute(composedImage);*/
//transformedImage = composedImage;
}
/// <summary>
/// Write <see cref="MimicItemTable"/> table to ROM.
/// </summary>
/// <param name="table">Table</param>
public void WriteMimicItemTable(MimicItemTable table)
{
var addr = this["ITEM_OVERRIDE_ENTRIES"];
ReadWriteUtils.WriteToROM((int)addr, table.Build());
}