private static void RemoveParameter(ref sitk.ParameterMap map, string key)
{
if (map.ContainsKey(key))
{
map.Remove(key);
}
}
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>
/// Add transform bending energy penalty to parameter file.
/// </summary>
/// <param name="paramMap">parameter file</param>
/// <param name="metricWeight0">weight of metric 0</param>
/// <param name="metricWeight1">weight of metric 1</param>
/// <returns>parameter file with penalty</returns>
public static sitk.ParameterMap AddBendingEnergyPenaltyToParamMap(sitk.ParameterMap paramMap, int metricWeight0 = 1, int metricWeight1 = 1)
{
paramMap = RemovePenaltyTerm(paramMap);
ChangeOrAddParamIfNotExist(ref paramMap, "Registration", GetVectorString("MultiMetricMultiResolutionRegistration"));
ChangeOrAddParamIfNotExist(ref paramMap, "Metric", GetVectorString("AdvancedMeanSquares", "TransformBendingEnergyPenalty"));
ChangeOrAddParamIfNotExist(ref paramMap, "Metric0Weight", GetVectorString(metricWeight0.ToString()));
ChangeOrAddParamIfNotExist(ref paramMap, "Metric1Weight", GetVectorString(metricWeight1.ToString()));
return(paramMap);
}
public EditParametersForm(string parameterFilename)
{
InitializeComponent();
filename = parameterFilename;
sitk.ElastixImageFilter elx = new sitk.ElastixImageFilter();
Parametermap = elx.ReadParameterFile(filename);
elx.Dispose();
}
/// <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>
/// Change or add a parameter (if param does not exist) to parameter map.
/// </summary>
/// <param name="paramMap">reference to parameter map</param>
/// <param name="key">parameter key</param>
/// <param name="value">values as a vector of strings</param>
public static void ChangeOrAddParamIfNotExist(ref sitk.ParameterMap paramMap, string key, sitk.VectorString value)
{
if (paramMap.ContainsKey(key))
{
paramMap[key] = value;
}
else
{
paramMap.Add(key, value);
}
}
/// <summary>
/// Remove Penalties fromparameter file if one exist.
/// </summary>
/// <param name="paramMap"></param>
/// <returns></returns>
public static sitk.ParameterMap RemovePenaltyTerm(sitk.ParameterMap paramMap)
{
ChangeOrAddParamIfNotExist(ref paramMap, "Registration", GetVectorString("MultiResolutionRegistration"));
ChangeOrAddParamIfNotExist(ref paramMap, "Metric", GetVectorString("AdvancedMeanSquares"));
RemoveParameter(ref paramMap, "Metric0Weight");
RemoveParameter(ref paramMap, "Metric1Weight");
RemoveParameter(ref paramMap, "LinearityConditionWeight");
RemoveParameter(ref paramMap, "UseLinearityCondition");
RemoveParameter(ref paramMap, "OrthonormalityConditionWeight");
RemoveParameter(ref paramMap, "UseOrthonormalityCondition");
RemoveParameter(ref paramMap, "PropernessConditionWeight");
RemoveParameter(ref paramMap, "UsePropernessCondition");
return(paramMap);
}
/// <summary>
/// Add transform rigidity penalty term to parameter file.
/// If linearity, orthonormality and properness conditions are set to smaller than zero, they will be deactivated.
/// </summary>
/// <param name="paramMap">reference to parameter map</param>
/// <param name="metricWeight0">weight of metric 0</param>
/// <param name="metricWeight1">weight of metric 1</param>
/// <param name="linearityConditionWeight">linearity condition weight (if set to smaller zero, it will not be calculated)</param>
/// <param name="orthonormalityConditionWeight">orthonormality condition weight (if set to smaller zero, it will not be calculated)</param>
/// <param name="propernessConditionWeight">properness condition weight (if set to smaller zero, it will not be calculated)</param>
/// <returns></returns>
public static sitk.ParameterMap AddTransformRigidityPenaltyToParamMap(sitk.ParameterMap paramMap,
int metricWeight0 = 1,
int metricWeight1 = 1,
int linearityConditionWeight = 1,
int orthonormalityConditionWeight = 1,
int propernessConditionWeight = 1)
{
paramMap = RemovePenaltyTerm(paramMap);
ChangeOrAddParamIfNotExist(ref paramMap, "Registration", GetVectorString("MultiMetricMultiResolutionRegistration"));
ChangeOrAddParamIfNotExist(ref paramMap, "Metric", GetVectorString("AdvancedMeanSquares", "TransformRigidityPenalty"));
ChangeOrAddParamIfNotExist(ref paramMap, "Metric0Weight", GetVectorString(metricWeight0.ToString()));
ChangeOrAddParamIfNotExist(ref paramMap, "Metric1Weight", GetVectorString(metricWeight1.ToString()));
if (linearityConditionWeight > 0)
{
ChangeOrAddParamIfNotExist(ref paramMap, "LinearityConditionWeight", GetVectorString(linearityConditionWeight.ToString()));
}
else
{
ChangeOrAddParamIfNotExist(ref paramMap, "UseLinearityCondition", GetVectorString("false"));
}
if (orthonormalityConditionWeight > 0)
{
ChangeOrAddParamIfNotExist(ref paramMap, "OrthonormalityConditionWeight", GetVectorString(orthonormalityConditionWeight.ToString()));
}
else
{
ChangeOrAddParamIfNotExist(ref paramMap, "UseOrthonormalityCondition", GetVectorString("false"));
}
if (propernessConditionWeight > 0)
{
ChangeOrAddParamIfNotExist(ref paramMap, "PropernessConditionWeight", GetVectorString(propernessConditionWeight.ToString()));
}
else
{
ChangeOrAddParamIfNotExist(ref paramMap, "UsePropernessCondition", GetVectorString("false"));
}
return(paramMap);
}
/// <summary>
/// Get default parameter map from elastix image filter for registration type.
/// </summary>
/// <param name="registrationType">registration type</param>
/// <returns>default params</returns>
private static sitk.ParameterMap GetDefaultRigidParameterMap(RegistrationDefaultParameters registrationType)
{
using (sitk.ElastixImageFilter elastix = new sitk.ElastixImageFilter())
{
sitk.ParameterMap map = elastix.GetDefaultParameterMap(registrationType.ToString());
ChangeOrAddParamIfNotExist(ref map, "Interpolator", GetVectorString("BSplineInterpolator"));
ChangeOrAddParamIfNotExist(ref map, "ResampleInterpolator", GetVectorString("FinalBSplineInterpolator"));
ChangeOrAddParamIfNotExist(ref map, "FixedImagePyramid", GetVectorString("FixedRecursiveImagePyramid"));
ChangeOrAddParamIfNotExist(ref map, "MovingImagePyramid", GetVectorString("MovingRecursiveImagePyramid"));
ChangeOrAddParamIfNotExist(ref map, "AutomaticTransformInitialization", GetVectorString("true"));
ChangeOrAddParamIfNotExist(ref map, "NumberOfResolutions", GetVectorString("8"));
ChangeOrAddParamIfNotExist(ref map, "MaximumNumberOfIterations", GetVectorString("1024"));
ChangeOrAddParamIfNotExist(ref map, "NumberOfSpatialSamples", GetVectorString("4096"));
ChangeOrAddParamIfNotExist(ref map, "NumberOfSamplesForExactGradient", GetVectorString("4096"));
ChangeOrAddParamIfNotExist(ref map, "ImageSampler", GetVectorString("Random"));
ChangeOrAddParamIfNotExist(ref map, "BSplineInterpolationOrder", GetVectorString("1"));
ChangeOrAddParamIfNotExist(ref map, "FinalBSplineInterpolationOrder", GetVectorString("3"));
ChangeOrAddParamIfNotExist(ref map, "Metric", GetVectorString("AdvancedMeanSquares"));
return(map);
}
}
/// <summary>
/// Create default non rigid parameter map.
/// </summary>
/// <returns>default paramerets</returns>
private static sitk.ParameterMap GetDefaultNonRigidParameterMap()
{
sitk.ParameterMap paramMap = new sitk.ParameterMap();
paramMap.Add("FixedInternalImagePixelType", GetVectorString("float"));
paramMap.Add("MovingInternalImagePixelType", GetVectorString("float"));
paramMap.Add("FixedImageDimension", GetVectorString("2"));
paramMap.Add("MovingImageDimension", GetVectorString("2"));
paramMap.Add("UseDirectionCosines", GetVectorString("true"));
paramMap.Add("Registration", GetVectorString("MultiResolutionRegistration"));
paramMap.Add("Interpolator", GetVectorString("BSplineInterpolator"));
paramMap.Add("ResampleInterpolator", GetVectorString("FinalBSplineInterpolator"));
paramMap.Add("Resampler", GetVectorString("DefaultResampler"));
paramMap.Add("FixedImagePyramid", GetVectorString("FixedRecursiveImagePyramid"));
paramMap.Add("MovingImagePyramid", GetVectorString("MovingRecursiveImagePyramid"));
paramMap.Add("Optimizer", GetVectorString("AdaptiveStochasticGradientDescent"));
paramMap.Add("Transform", GetVectorString("BSplineTransform"));
paramMap.Add("Metric", GetVectorString("AdvancedMeanSquares"));
paramMap.Add("FinalGridSpacingInPhysicalUnits", GetVectorString("16"));
paramMap.Add("GridSpacingSchedule", GetVectorString("5.0", "5.0", "4.0", "4.0", "3.0", "3.0", "2.0", "2.0", "1.0", "1.0"));
paramMap.Add("HowToCombineTransforms", GetVectorString("Compose"));
paramMap.Add("ErodeMask", GetVectorString("false"));
paramMap.Add("NumberOfResolutions", GetVectorString("5"));
paramMap.Add("MaximumNumberOfIterations", GetVectorString("1024"));
paramMap.Add("NumberOfSpatialSamples", GetVectorString("4096"));
paramMap.Add("NumberOfSamplesForExactGradient", GetVectorString("4096"));
paramMap.Add("NewSamplesEveryIteration", GetVectorString("true"));
paramMap.Add("ImageSampler", GetVectorString("Random"));
paramMap.Add("BSplineInterpolationOrder", GetVectorString("1"));
paramMap.Add("FinalBSplineInterpolationOrder", GetVectorString("3"));
paramMap.Add("DefaultPixelValue", GetVectorString("255.0"));
paramMap.Add("WriteResultImage", GetVectorString("true"));
paramMap.Add("ResultImagePixelType", GetVectorString("short"));
paramMap.Add("ResultImageFormat", GetVectorString("mhd"));
return(paramMap);
}
public static sitk.ParameterMap AddDistancePreservingRigidityPenaltyToParamMap(sitk.ParameterMap paramMap)
{
paramMap = RemovePenaltyTerm(paramMap);
// todo add segmentation in registration class
ChangeOrAddParamIfNotExist(ref paramMap, "Registration", GetVectorString("MultiMetricMultiResolutionRegistration"));
ChangeOrAddParamIfNotExist(ref paramMap, "Metric", GetVectorString("AdvancedMeanSquares", "DistancePreservingRigidityPenalty"));
return(paramMap);
}
/// <summary>
/// Get a default parameter map for a specific registration type.
/// </summary>
/// <param name="type">registration type</param>
/// <returns>sitk parameter map</returns>
public static sitk.ParameterMap GetDefaultParameterMap(RegistrationDefaultParameters type)
{
if ((int)type < 4)
{
// rigid registration types
if (type == RegistrationDefaultParameters.similarity)
{
sitk.ParameterMap parameterMap = GetDefaultRigidParameterMap(RegistrationDefaultParameters.translation);
parameterMap["Transform"][0] = "SimilarityTransform";
return(parameterMap);
}
else
{
return(GetDefaultRigidParameterMap(type));
}
}
else
{
// non rigid registration types
if (type == RegistrationDefaultParameters.spline ||
type == RegistrationDefaultParameters.bspline ||
type == RegistrationDefaultParameters.nonrigid)
{
return(GetDefaultNonRigidParameterMap());
}
else
{
sitk.ParameterMap parameterMap = GetDefaultNonRigidParameterMap();
if (type == RegistrationDefaultParameters.diffusion)
{
parameterMap["Transform"][0] = "BSplineTransformWithDiffusion";
// default parameters for bspline diffusion registration
parameterMap.Add("FinalGridSpacing", GetVectorString("8.0", "8.0", "8.0"));
parameterMap.Add("UpsampleGridOption", GetVectorString("true"));
parameterMap.Add("FilterPattern", GetVectorString("1"));
parameterMap.Add("DiffusionEachNIterations", GetVectorString("1"));
parameterMap.Add("AfterIterations", GetVectorString("50", "100"));
parameterMap.Add("HowManyIterations", GetVectorString("1", "5", "10"));
parameterMap.Add("NumberOfDiffusionIterations", GetVectorString("1"));
parameterMap.Add("Radius", GetVectorString("1"));
parameterMap.Add("ThresholdBool", GetVectorString("true"));
parameterMap.Add("ThresholdHU", GetVectorString("150"));
parameterMap.Add("GrayValueImageAlsoBasedOnFixedImage", GetVectorString("true"));
//parameterMap.Add("UseFixedSegmentation", GetVectorString("false"));
//parameterMap.Add("FixedSegmentationFileName", GetVectorString("filename"));
parameterMap.Add("UseMovingSegmentation", GetVectorString("false"));
parameterMap.Add("MovingSegmentationFileName", GetVectorString("filename"));
return(parameterMap);
}
else if (type == RegistrationDefaultParameters.recursive)
{
parameterMap["Transform"][0] = "RecursiveBSplineTransform";
parameterMap.Add("PassiveEdgeWidth", GetVectorString("0"));
return(parameterMap);
}
else
{
return(parameterMap);
}
}
}
}
public EditParametersForm(sitk.ParameterMap map)
{
InitializeComponent();
Parametermap = map;
}
protected RegInitialization(RegistrationParameters parameters)
{
this.registrationParameters = parameters;
this.parameterMap = parameters.ParamMapToUse;
}
/// <summary>
/// Set parameter map to default.
/// </summary>
/// <param name="type"></param>
/// <param name="numberOfResolutions"></param>
public virtual void SetDefaultParameterMap(RegistrationDefaultParameters type, uint numberOfResolutions)
{
parameterMap = elastix.GetDefaultParameterMap(type.ToString(), numberOfResolutions);
}