/// <summary>
/// Start transformation process.
/// </summary>
public void StartTransformation()
{
sitk.VectorOfParameterMap parameterMaps = PrepareTransformationParameters();
foreach (string imageFilename in TransformImages)
{
using (sitk.Image img = ReadWriteUtils.ReadITKImageFromFile(imageFilename))
{
List <sitk.Image> channels = TransformationUtils.SplitColorChannels(img);
List <sitk.Image> transformedChannels = new List <sitk.Image>();
foreach (sitk.Image channel in channels)
{
transformedChannels.Add(ExecuteTransform(parameterMaps, channel));
channel.Dispose();
}
sitk.VectorOfImage vectorImages = new sitk.VectorOfImage();
foreach (sitk.Image tChannel in transformedChannels)
{
vectorImages.Add(TransformationUtils.InterpolateImage(tChannel, GetInterpolatorEnum(), sitk.PixelIDValueEnum.sitkUInt8));
}
sitk.ComposeImageFilter composeImageFilter = new sitk.ComposeImageFilter();
sitk.Image composedImage = composeImageFilter.Execute(vectorImages);
TransformationUtils.WriteTransformedImage(composedImage, ApplicationContext.OutputPath + "\\" + Path.GetFileNameWithoutExtension(imageFilename) + "_transformed.png");
}
}
}
/// <summary>
/// Add vector of parameter maps to transformix.
/// </summary>
/// <param name="vectorOfParametermap">vector of parameter maps</param>
public void AddVectorOfParameterMap(sitk.VectorOfParameterMap vectorOfParametermap)
{
foreach (sitk.ParameterMap map in vectorOfParametermap.AsEnumerable())
{
transformix = transformix.AddTransformParameterMap(map);
}
}
public static List <sitk.VectorOfParameterMap> PerformMultipleRigidRegistrationForComponents(
string fixedSegmentedMask,
string movingSegmentedMask,
int numberOfComposedTransformations,
RegistrationParameters parameters)
{
// created corresponding masks
Image <Gray, byte> fixedSegments = new Image <Gray, byte>(fixedSegmentedMask);
Image <Gray, byte> movingSegments = new Image <Gray, byte>(movingSegmentedMask);
VectorOfVectorOfPoint contoursFixed = new VectorOfVectorOfPoint();
VectorOfVectorOfPoint contoursMoving = new VectorOfVectorOfPoint();
CvInvoke.FindContours(fixedSegments, contoursFixed, null, Emgu.CV.CvEnum.RetrType.Ccomp, Emgu.CV.CvEnum.ChainApproxMethod.ChainApproxSimple);
CvInvoke.FindContours(movingSegments, contoursMoving, null, Emgu.CV.CvEnum.RetrType.Ccomp, Emgu.CV.CvEnum.ChainApproxMethod.ChainApproxSimple);
// retireve dict with contour index and area size ordered by size
Dictionary <int, double> contoursFixedDict = GetContourAreaDict(ref contoursFixed);
Dictionary <int, double> contoursMovingDict = GetContourAreaDict(ref contoursMoving);
List <Tuple <string, string> > filenameOfMaskComponents = new List <Tuple <string, string> >();
for (int i = 0; i <= numberOfComposedTransformations; i++)
{
var contourFixed = contoursFixed[contoursFixedDict.ElementAt(i).Key];
var contourMoving = contoursMoving[contoursMovingDict.ElementAt(i).Key];
Image <Gray, byte> maskFixed = new Image <Gray, byte>(fixedSegments.Width, fixedSegments.Height, new Gray(0.0));
Image <Gray, byte> maskMoving = new Image <Gray, byte>(movingSegments.Width, movingSegments.Height, new Gray(0.0));
CvInvoke.DrawContours(maskFixed, contourFixed, -1, new MCvScalar(255.0), thickness: -1);
CvInvoke.DrawContours(maskMoving, contourMoving, -1, new MCvScalar(255.0), thickness: -1);
string filenameFixed = Path.GetTempPath() + "\\fixed_0" + i + ".png";
string filenameMoving = Path.GetTempPath() + "\\moving_0" + i + ".png";
maskFixed.Save(filenameFixed);
maskMoving.Save(filenameMoving);
Tuple <string, string> temp = new Tuple <string, string>(filenameFixed, filenameMoving);
filenameOfMaskComponents.Add(temp);
}
sitk.ParameterMap map = GetDefaultParameterMap(parameters.RegistrationDefaultParams);
List <sitk.VectorOfParameterMap> list = new List <sitk.VectorOfParameterMap>();
foreach (Tuple <string, string> tuple in filenameOfMaskComponents)
{
sitk.Image img01 = ReadWriteUtils.ReadITKImageFromFile(tuple.Item1);
sitk.Image img02 = ReadWriteUtils.ReadITKImageFromFile(tuple.Item2);
parameters.ParamMapToUse = map;
RigidRegistration reg = new RigidRegistration(img01, img02, parameters);
reg.Execute();
sitk.VectorOfParameterMap toAdd = new sitk.VectorOfParameterMap(reg.GetTransformationParameterMap());
list.Add(toAdd);
reg.Dispose();
}
return(list);
}
/// <summary>
/// Componentwise rigid registration.
/// Each corresponding masked components will be registrated discretly.
/// Transformation parameters will be composed befor image is transformed.
/// </summary>
/// <param name="fixedMask">reference mask</param>
/// <param name="movingMask">template mask</param>
/// <param name="v">number of corresponding components</param>
/// <param name="filename">moving image filename</param>
/// <returns></returns>
private List <sitk.VectorOfParameterMap> ComponentWiseRigidRegistration(sitk.Image fixedMask, sitk.Image movingMask, int v, string filename)
{
// convert from sitk to opencv
var fixedImage = ReadWriteUtils.ConvertSitkImageToOpenCv <Gray, byte>(fixedMask);
var movingImage = ReadWriteUtils.ConvertSitkImageToOpenCv <Gray, byte>(movingMask);
// find contours
VectorOfVectorOfPoint contoursFixed = new VectorOfVectorOfPoint();
VectorOfVectorOfPoint contoursMoving = new VectorOfVectorOfPoint();
CvInvoke.FindContours(fixedImage, contoursFixed, null, Emgu.CV.CvEnum.RetrType.Ccomp, Emgu.CV.CvEnum.ChainApproxMethod.ChainApproxSimple);
CvInvoke.FindContours(movingImage, contoursMoving, null, Emgu.CV.CvEnum.RetrType.Ccomp, Emgu.CV.CvEnum.ChainApproxMethod.ChainApproxSimple);
// retireve dict with contour index and area size ordered by size
var contoursFixedDict = RegistrationUtils.GetContourAreaDict(ref contoursFixed).OrderByDescending(it => it.Value);
var contoursMovingDict = RegistrationUtils.GetContourAreaDict(ref contoursMoving).OrderByDescending(it => it.Value);
List <Tuple <string, string> > filenameOfMaskComponents = new List <Tuple <string, string> >();
for (int i = 1; i < v; i++)
{
var contourFixed = contoursFixed[contoursFixedDict.ElementAt(i).Key].ToArray();
var contourMoving = contoursMoving[contoursMovingDict.ElementAt(i).Key].ToArray();
Image <Gray, byte> maskFixed = new Image <Gray, byte>(fixedImage.Width, fixedImage.Height, new Gray(0.0));
Image <Gray, byte> maskMoving = new Image <Gray, byte>(movingImage.Width, movingImage.Height, new Gray(0.0));
maskFixed.Draw(contourFixed, new Gray(255.0), -1);
maskMoving.Draw(contourMoving, new Gray(255.0), -1);
//CvInvoke.DrawContours(maskFixed, contourFixed, -1, new MCvScalar(255.0), thickness: -1);
//CvInvoke.DrawContours(maskMoving, contourMoving, -1, new MCvScalar(255.0), thickness: -1);
string filenameFixed = Path.GetTempPath() + "\\fixed_0" + i + ".png";
string filenameMoving = Path.GetTempPath() + "\\moving_0" + i + ".png";
maskFixed.Save(filenameFixed);
maskMoving.Save(filenameMoving);
Tuple <string, string> temp = new Tuple <string, string>(filenameFixed, filenameMoving);
filenameOfMaskComponents.Add(temp);
}
sitk.ParameterMap map = RegistrationUtils.GetDefaultParameterMap(_parameters.RegistrationDefaultParams);
List <sitk.VectorOfParameterMap> list = new List <sitk.VectorOfParameterMap>();
foreach (Tuple <string, string> tuple in filenameOfMaskComponents)
{
sitk.Image img01 = ReadWriteUtils.ReadITKImageFromFile(tuple.Item1, sitk.PixelIDValueEnum.sitkUInt8);
sitk.Image img02 = ReadWriteUtils.ReadITKImageFromFile(tuple.Item2, sitk.PixelIDValueEnum.sitkUInt8);
_parameters.ParamMapToUse = map;
RigidRegistration reg = new RigidRegistration(img01, img02, _parameters);
reg.Execute();
sitk.VectorOfParameterMap toAdd = new sitk.VectorOfParameterMap(reg.GetTransformationParameterMap());
list.Add(toAdd);
reg.Dispose();
}
return(list);
}
/// <summary>
/// Execute actual transformation.
/// </summary>
/// <param name="parameterMaps">parameter maps</param>
/// <param name="channel">image channel as grayscale image</param>
/// <returns></returns>
private sitk.Image ExecuteTransform(sitk.VectorOfParameterMap parameterMaps, sitk.Image channel)
{
using (sitk.TransformixImageFilter transformix = new sitk.TransformixImageFilter())
{
transformix.SetTransformParameterMap(parameterMaps);
transformix.SetMovingImage(channel);
transformix.SetLogToConsole(true);
transformix.SetOutputDirectory(ApplicationContext.OutputPath);
return(transformix.Execute());
}
}
/// <summary>
/// Prepare transformation parameters and set initial transform if more than one parameter file.
/// </summary>
/// <returns>transformation parameter maps</returns>
private sitk.VectorOfParameterMap PrepareTransformationParameters()
{
sitk.VectorOfParameterMap resultMap = new sitk.VectorOfParameterMap();
using (sitk.TransformixImageFilter transformix = new sitk.TransformixImageFilter())
{
foreach (string parameterFilename in TransformParameters)
{
resultMap.Add(transformix.ReadParameterFile(parameterFilename));
}
}
// TODO: modify list
return(resultMap);
}
/// <summary>
/// Calculate a composite transform for a list of vector parameter maps.
/// </summary>
/// <param name="movingImage">moving image</param>
/// <param name="parameterMaps">list of vector of parameter maps</param>
/// <param name="parameters">registration params</param>
/// <param name="filename">filename of the result image</param>
public static void WriteCompositeTransformForMovingImage(
sitk.Image movingImage,
List <sitk.VectorOfParameterMap> parameterMaps,
RegistrationParameters parameters,
string filename)
{
sitk.VectorOfParameterMap initialTransform = parameterMaps.First();
parameterMaps.Remove(initialTransform);
TransformRGB transform = new TransformRGB(movingImage, parameterMaps, parameters);
foreach (sitk.VectorOfParameterMap vectorOfMaps in parameterMaps)
{
transform.AddVectorOfParameterMap(vectorOfMaps);
}
transform.Execute();
transform.WriteTransformedImage(filename);
}
/// <summary>
/// Runs the actual registration process with default settings.
/// </summary>
/// <param name="refImage">reference image</param>
/// <param name="movImage">template image</param>
/// <param name="fixedMask">fixed mask</param>
/// <param name="movingMask">moving mask</param>
/// <param name="imageFilename">filename of moving image</param>
/// <returns></returns>
private sitk.VectorOfParameterMap DefaultRigidRegistration(sitk.Image refImage, sitk.Image movImage, sitk.Image fixedMask, sitk.Image movingMask, string imageFilename)
{
RigidRegistration regRigid = new RigidRegistration(refImage, movImage, _parameters);
// set fixed mask if defined
if (fixedMask != null)
{
regRigid.SetFixedMask(fixedMask);
}
// set moving mask if defined
if (movingMask != null)
{
regRigid.SetMovingMask(movingMask);
}
ExecuteRegistration(regRigid);
sitk.VectorOfParameterMap transformparams = regRigid.GetTransformationParameterMap();
regRigid.Dispose();
return(transformparams);
}
/// <summary>
/// Run actual registration process for a default non rigid registration.
/// </summary>
/// <param name="refImage">reference image</param>
/// <param name="movImage">moving image</param>
/// <param name="fixedMask">fixed mask</param>
/// <param name="movingMask">moving mask</param>
/// <param name="imageFilename">filename of moving image</param>
/// <returns></returns>
private sitk.VectorOfParameterMap DefaultNonRigidRegistration(sitk.Image refImage, sitk.Image movImage,
sitk.Image fixedMask, sitk.Image movingMask, string imageFilename)
{
NonRigidRegistration nonRigidRegistration = new NonRigidRegistration(refImage, movImage, _parameters);
if (fixedMask != null)
{
//fixedMask = ImageUtils.Binarize(fixedMask);
nonRigidRegistration.SetFixedMask(fixedMask);
}
if (movingMask != null)
{
//movingMask = ImageUtils.Binarize(movingMask);
nonRigidRegistration.SetMovingMask(movingMask);
}
ExecuteRegistration(nonRigidRegistration);
sitk.VectorOfParameterMap transformparams = nonRigidRegistration.GetTransformationParameterMap();
nonRigidRegistration.Dispose();
return(transformparams);
}
/// <summary>
/// Perform registration with multiple parameter files.
/// </summary>
/// <param name="refImage"></param>
/// <param name="movImage"></param>
/// <param name="fixedMask"></param>
/// <param name="movingMask"></param>
/// <param name="movingImageFilename"></param>
/// <returns></returns>
private List <sitk.VectorOfParameterMap> PerformMultipleParamFilesRegistration(sitk.Image refImage, sitk.Image movImage, sitk.Image fixedMask, sitk.Image movingMask, string movingImageFilename)
{
MultipleParameterFileRegistration regRigid = null;
if (_parameters.RigidOptions == MaskedRigidRegistrationOptions.BinaryRegistrationWholeTissue ||
_parameters.RigidOptions == MaskedRigidRegistrationOptions.BinaryRegistrationInnerStructures)
{
_parameters.IsBinaryTransform = true;
regRigid = new MultipleParameterFileRegistration(fixedMask, movingMask, _parameters);
}
else
{
regRigid = new MultipleParameterFileRegistration(refImage, movImage, _parameters);
// set fixed mask if defined
if (fixedMask != null)
{
regRigid.SetFixedMask(fixedMask);
}
// set moving mask if defined
if (movingMask != null)
{
regRigid.SetMovingMask(movingMask);
}
}
ExecuteRegistration(regRigid);
sitk.VectorOfParameterMap transformparams = regRigid.GetTransformationParameterMap();
regRigid.Dispose();
List <sitk.VectorOfParameterMap> resultList = new List <sitk.VectorOfParameterMap>();
resultList.Add(transformparams);
return(resultList);
}
