public Image WybierzPrzekroj(Image obraz3d, int numerPrzekroju)
{
int numberSlices = (int)obraz3d.GetDepth();
if (numberSlices < numerPrzekroju)
{
return obraz3d;
}
else
{
SliceImageFilter sliceFilter = new SliceImageFilter();
sliceFilter.SetStart(new VectorInt32(new[] { 1, 1, numerPrzekroju }));
sliceFilter.SetStop(new VectorInt32(new[] { 512, 512, numerPrzekroju + 1 }));
var obraz2d = sliceFilter.Execute(obraz3d);
sliceFilter.Dispose();
return obraz2d;
}
}
/// <summary>
/// Only for debug / evaluation use.
/// </summary>
/// <param name="fixedMask"></param>
/// <param name="movingMask"></param>
private void CalculateMetrics(sitk.Image fixedMask, sitk.Image movingMask)
{
if (fixedMask != null && movingMask != null)
{
sitk.LabelOverlapMeasuresImageFilter overlapFilter = VisualizationEvaluationUtils.GetOverlapImageFilter(fixedMask, movingMask);
if (overlapFilter != null)
{
double diceCoef = overlapFilter.GetDiceCoefficient();
double falseNegative = overlapFilter.GetFalseNegativeError();
double falsePositive = overlapFilter.GetFalsePositiveError();
double jaccard = overlapFilter.GetJaccardCoefficient();
double meanOverlap = overlapFilter.GetMeanOverlap();
double unionOverlap = overlapFilter.GetUnionOverlap();
string dice = diceCoef.ToString("0.##");
string jacc = jaccard.ToString("0.##");
string negPos = string.Format("{0} / {1}", falseNegative.ToString("0.##"), falsePositive.ToString("0.##"));
Console.WriteLine("### Metrics ###");
Console.WriteLine("Dice: " + dice);
Console.WriteLine("Jaccard: " + jacc);
Console.WriteLine("False negative / false positive: " + negPos);
}
}
}
/// <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>
/// Retrieve mask for a given filename.
/// </summary>
/// <param name="filename">filename</param>
/// <returns>mask of given image</returns>
private sitk.Image GetMask(string filename, bool isFixed)
{
if (isFixed && _parameters.UseFixedMaskFromDisk)
{
sitk.Image img = ReadWriteUtils.ReadITKImageFromFile(_parameters.FixedMaskFromDisk);
return(img);
}
else if (!isFixed && _parameters.UseMovingMasksFromDisk)
{
sitk.Image img = ReadWriteUtils.ReadITKImageFromFile(_parameters.MovingMasksFromDisk.FirstOrDefault());
return(img);
}
else
{
if (_parameters.UseInnerStructuresSegmentation)
{
// segmentation of the inner structures of the particle
return(GetInnerStructureMask(filename));
}
else
{
// segmentation of the whole particle
return(GetWholeParticleMask(filename));
}
}
}
public MultipleParameterFileRegistration(sitk.Image fixedImage, sitk.Image movingImage, RegistrationParameters parameters) : base(parameters)
{
this.fixedImage = ImageUtils.CastImageToFloat32(fixedImage);
this.movingImage = ImageUtils.CastImageToFloat32(movingImage);
elastix = new sitk.ElastixImageFilter();
for (int i = 0; i < parameters.ParameterFiles.Count; i++)
{
if (i == 0)
{
elastix.SetParameterMap(elastix.ReadParameterFile(parameters.ParameterFiles[i]));
}
else
{
elastix.AddParameterMap(elastix.ReadParameterFile(parameters.ParameterFiles[i]));
}
}
// set output dir
outputDirectory = Path.Combine(registrationParameters.OutputDirectory, "multiple_" + DateTime.Now.ToShortDateString());
if (!Directory.Exists(outputDirectory))
{
Directory.CreateDirectory(outputDirectory);
}
elastix.SetOutputDirectory(outputDirectory);
//elastix.SetLogFileName(Path.Combine(outputDirectory, registrationParameters.ElastixLogFileName));
elastix.LogToFileOn();
}
/// <summary>
/// Create a checkerboard image of two corresponding images.
/// </summary>
/// <param name="fImg01">image 1</param>
/// <param name="fImg02">image 2</param>
/// <param name="size">grid size of the checker boar</param>
/// <returns>checker board image</returns>
public static sitk.Image GetCheckerBoardV2(string fImg01, string fImg02, uint size = 0)
{
sitk.Image img01 = ReadWriteUtils.ReadITKImageFromFile(fImg01);
sitk.Image img02 = ReadWriteUtils.ReadITKImageFromFile(fImg02);
uint width = img01.GetWidth() > img02.GetWidth() ? img01.GetWidth() : img02.GetWidth();
uint height = img01.GetHeight() > img02.GetHeight() ? img01.GetHeight() : img02.GetHeight();
sitk.Image reference = ImageUtils.ResizeImage(img01, width, height);
sitk.Image transformed = ImageUtils.ResizeImage(img02, width, height);
sitk.CheckerBoardImageFilter checkerBoard = new sitk.CheckerBoardImageFilter();
uint lx = size;
uint ly = width / (height / size);
if (size != 0)
{
sitk.VectorUInt32 vec = new sitk.VectorUInt32();
vec.Add(ly);
vec.Add(lx);
checkerBoard.SetCheckerPattern(vec);
}
sitk.Image result = checkerBoard.Execute(reference, transformed);
img01.Dispose();
img02.Dispose();
reference.Dispose();
transformed.Dispose();
return(result);
}
public static sitk.Image GetCheckerBoard(sitk.Image img01, sitk.Image img02, uint size = 0)
{
uint width = img01.GetWidth() > img02.GetWidth() ? img01.GetWidth() : img02.GetWidth();
uint height = img01.GetHeight() > img02.GetHeight() ? img01.GetHeight() : img02.GetHeight();
//Console.WriteLine(string.Format("width: Img01 [{0}] - Img02 [{1}]", img01.GetWidth(), img02.GetWidth()));
//Console.WriteLine(string.Format("height: Img01 [{0}] - Img02 [{1}]", img01.GetHeight(), img02.GetHeight()));
//Console.WriteLine(string.Format("pixel type: Img01 [{0}] - Img02 [{1}]", img01.GetPixelIDTypeAsString(), img02.GetPixelIDTypeAsString()));
sitk.Image reference = ImageUtils.ResizeImage(img01, width, height, sitk.PixelIDValueEnum.sitkFloat32);
sitk.Image transformed = ImageUtils.ResizeImage(img02, width, height, sitk.PixelIDValueEnum.sitkFloat32);
sitk.CheckerBoardImageFilter checkerBoard = new sitk.CheckerBoardImageFilter();
if (size != 0)
{
sitk.VectorUInt32 vec = new sitk.VectorUInt32();
vec.Add(size);
vec.Add(size);
checkerBoard.SetCheckerPattern(vec);
}
sitk.Image temp = checkerBoard.Execute(reference, transformed);
sitk.CastImageFilter castImageFilter = new sitk.CastImageFilter();
castImageFilter.SetOutputPixelType(sitk.PixelIDValueEnum.sitkUInt8);
sitk.Image result = castImageFilter.Execute(temp);
temp.Dispose();
return(result);
}
/// <summary>
/// Non rigid registration specific options. Uses masking options.
/// </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 List <sitk.VectorOfParameterMap> PerformNonRigidRegistration(sitk.Image refImage, sitk.Image movImage,
sitk.Image fixedMask, sitk.Image movingMask, string imageFilename)
{
List <sitk.VectorOfParameterMap> resultMap = new List <sitk.VectorOfParameterMap>();
switch (_parameters.NonRigidOptions)
{
case MaskedNonRigidRegistrationOptions.None:
resultMap.Add(DefaultNonRigidRegistration(refImage, movImage, fixedMask, movingMask, imageFilename));
break;
case MaskedNonRigidRegistrationOptions.BsplineWithPenaltyTerm:
resultMap.Add(NonRigidRegistrationWithPenalty(refImage, movImage, null, null, imageFilename));
break;
case MaskedNonRigidRegistrationOptions.BsplineWithPenaltyTermAndCoefficientMap:
resultMap.Add(NonRigidRegistrationWithPenalty(refImage, movImage, fixedMask, null, imageFilename));
break;
case MaskedNonRigidRegistrationOptions.ComposeIndependantRegistrations:
throw new NotImplementedException();
case MaskedNonRigidRegistrationOptions.DiffuseRegistration:
resultMap.Add(BSplineWithDiffusion(refImage, movImage, imageFilename));
break;
default:
throw new NotImplementedException("Registration option does not exist.");
}
return(resultMap);
}
public Image WybierzPrzekroj(Image obraz3d, int przekrojMin, int PrzekrojMax)
{
int numberSlices = (int)obraz3d.GetDepth();
if (numberSlices < przekrojMin)
{
return(obraz3d);
}
else
{
Image obraz2d = new Image();
if (przekrojMin < PrzekrojMax)
{
if (PrzekrojMax - 1 > numberSlices)
{
PrzekrojMax = numberSlices;
}
SliceImageFilter sliceFilter = new SliceImageFilter();
sliceFilter.SetStart(new VectorInt32(new[] { 1, 1, przekrojMin }));
sliceFilter.SetStop(new VectorInt32(new[] { 512, 512, PrzekrojMax }));
obraz2d = sliceFilter.Execute(obraz3d);
sliceFilter.Dispose();
}
return(obraz2d);
}
}
public static sitk.Image ReadImage(string fileName)
{
sitk.ImageFileReader imageFileReader = new sitk.ImageFileReader();
imageFileReader.SetFileName(fileName);
sitk.Image image = imageFileReader.Execute();
return(image);
}
private sitk.VectorOfParameterMap InvertTransformParameters(string parameterFilename)
{
sitk.Image fixedImage = ReadWriteUtils.ReadITKImageFromFile(registrationParameters.FixedImageFilename, sitk.PixelIDValueEnum.sitkFloat32);
sitk.ElastixImageFilter elastix = null;
try
{
// elastix manual 6.1.6: DisplacementMagnitudePenalty
elastix = new sitk.ElastixImageFilter();
elastix.SetInitialTransformParameterFileName(parameterFilename);
elastix.SetParameterMap(sitk.SimpleITK.GetDefaultParameterMap("rigid"));
elastix.SetFixedImage(fixedImage);
elastix.SetMovingImage(fixedImage);
elastix.SetParameter("HowToCombineTransforms", "Compose");
elastix.SetParameter("Metric", "DisplacementMagnitudePenalty");
elastix.SetParameter("NumberOfResolutions", "1");
elastix.Execute();
return(elastix.GetTransformParameterMap());
/*sitk.TransformixImageFilter transformix = new sitk.TransformixImageFilter();
* transformix.SetTransformParameterMap(elastix.GetTransformParameterMap());
* transformix.SetTransformParameter("InitialTransformParametersFileName", "NoInitialTransform");
* transformix.Execute();*/
}
catch (Exception ex)
{
Console.WriteLine(ex);
return(null);
} finally
{
elastix.Dispose();
fixedImage.Dispose();
}
}
/// <summary>
/// Resize image depending on a reference image.
/// </summary>
/// <param name="toResize">image</param>
/// <param name="referenceImage">reference image</param>
/// <returns>resampled image</returns>
public static sitk.Image ResizeImage(sitk.Image toResize, sitk.Image referenceImage)
{
if (toResize.GetWidth() == referenceImage.GetWidth() && toResize.GetHeight() == referenceImage.GetHeight())
{
return(toResize);
}
uint width = toResize.GetWidth() < referenceImage.GetWidth() ? referenceImage.GetWidth() : toResize.GetWidth();
uint height = toResize.GetHeight() < referenceImage.GetHeight() ? referenceImage.GetHeight() : toResize.GetHeight();
sitk.VectorUInt32 vec = new sitk.VectorUInt32();
vec.Add(width);
vec.Add(height);
sitk.ResampleImageFilter resampleFilter = new sitk.ResampleImageFilter();
resampleFilter.SetSize(vec);
resampleFilter.SetOutputOrigin(toResize.GetOrigin());
resampleFilter.SetOutputDirection(toResize.GetDirection());
resampleFilter.SetOutputSpacing(toResize.GetSpacing());
resampleFilter.SetOutputPixelType(referenceImage.GetPixelID());
resampleFilter.SetDefaultPixelValue(255.0);
sitk.Image resultImage = resampleFilter.Execute(toResize);
return(resultImage);
}
/// <summary>
/// Write ITK image to file.
/// </summary>
/// <param name="img">image</param>
/// <param name="outputFileName">output filename</param>
public static void WriteSitkImage(sitk.Image img, string outputFileName)
{
sitk.ImageFileWriter writer = new sitk.ImageFileWriter();
writer.SetFileName(outputFileName);
writer.Execute(img);
writer.Dispose();
}
public RigidRegistration(sitk.Image fixedImage, sitk.Image movingImage, RegistrationParameters parameters) : base(parameters)
{
this.fixedImage = ImageUtils.CastImageToFloat32(fixedImage);
this.movingImage = ImageUtils.CastImageToFloat32(movingImage);
this.registrationParameters = parameters;
elastix = new sitk.ElastixImageFilter();
if (parameterMap == null)
{
parameterMap = RegistrationUtils.GetDefaultParameterMap(parameters.RegistrationDefaultParams);
}
// set output dir
outputDirectory = Path.Combine(registrationParameters.OutputDirectory, registrationParameters.Iteration.ToString());
if (!Directory.Exists(outputDirectory))
{
Directory.CreateDirectory(outputDirectory);
}
elastix.SetOutputDirectory(outputDirectory);
//elastix.SetLogFileName(Path.Combine(outputDirectory, registrationParameters.ElastixLogFileName));
elastix.LogToFileOn();
//base.SetGeneralParameters();
}
/// <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>
/// 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>
/// Convert ITK image to openCV image.
/// </summary>
/// <typeparam name="T">color space / type</typeparam>
/// <typeparam name="D">pixel datatype</typeparam>
/// <param name="image">itk image</param>
/// <returns>opencv image</returns>
public static Image <T, D> ConvertSitkImageToOpenCv <T, D>(sitk.Image image) where T : struct, IColor where D : new()
{
string filename = Path.GetTempPath() + "\\temp_image.png";
WriteSitkImage(image, filename);
return(ReadOpenCVImageFromFile <T, D>(filename));
}
public TransformRGB(sitk.Image movingImage, List <sitk.VectorOfParameterMap> parameterMaps, RegistrationParameters parameters)
{
this.movingImage = movingImage;
this.parameterMaps = parameterMaps;
this.registrationParameters = parameters;
transformix = new sitk.TransformixImageFilter();
}
private sitk.VectorOfParameterMap BSplineWithDiffusion(sitk.Image refImage, sitk.Image movImage, string imageFilename)
{
string coefficientMapFilename = GetInnerStructureSegmentationsAsCoefficientMap(imageFilename);
_parameters.CoefficientMapFilename = coefficientMapFilename;
return(DefaultNonRigidRegistration(refImage, movImage, null, null, imageFilename));
}
/// <summary>
/// Binarize image by a lower and upper threshold.
/// </summary>
/// <param name="img">image</param>
/// <param name="lowerT">lower threshold</param>
/// <param name="upperT">upper threshold</param>
/// <returns></returns>
public static sitk.Image Binarize(sitk.Image img, int lowerT = 127, int upperT = 255)
{
sitk.BinaryThresholdImageFilter binaryFilter1 = new sitk.BinaryThresholdImageFilter();
binaryFilter1.SetLowerThreshold(lowerT);
binaryFilter1.SetUpperThreshold(upperT);
binaryFilter1.SetInsideValue(1);
binaryFilter1.SetOutsideValue(0);
return(binaryFilter1.Execute(img));
}
/// <summary>
/// Resample image output pixel type.
/// </summary>
/// <param name="img">image</param>
/// <param name="pixelIDValue">output pixel type</param>
/// <returns>sitk image</returns>
public static sitk.Image ResampleImage(sitk.Image img, sitk.PixelIDValueEnum pixelIDValue)
{
sitk.ResampleImageFilter resampleImageFilter = new sitk.ResampleImageFilter();
resampleImageFilter.SetOutputPixelType(pixelIDValue);
resampleImageFilter.SetOutputOrigin(img.GetOrigin());
resampleImageFilter.SetOutputDirection(img.GetDirection());
resampleImageFilter.SetOutputSpacing(img.GetSpacing());
return(resampleImageFilter.Execute(img));
}
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>
/// Transform a pointset for given transform parameters.
/// </summary>
/// <param name="transformParameters">transform params</param>
/// <param name="parameters">registration params</param>
/// <returns>filename of transformed point set</returns>
public static string TransfromPointSet(List <sitk.VectorOfParameterMap> transformParameters, RegistrationParameters parameters, string movingImageName = null)
{
sitk.TransformixImageFilter transformix = null;
try
{
transformix = new sitk.TransformixImageFilter();
transformix.SetTransformParameterMap(transformParameters.First());
transformix.LogToConsoleOn();
transformix.LogToFileOn();
transformix.SetLogFileName("transformix.log");
//transformix.SetLogToFile(true);
if (transformParameters.Count > 1)
{
for (int i = 1; i < transformParameters.Count; i++)
{
var vectorParameterMap = transformParameters[i];
foreach (var paramMap in vectorParameterMap.AsEnumerable())
{
transformix.AddTransformParameterMap(paramMap);
}
}
}
if (parameters.Type == RegistrationType.Rigid)
{
transformix.SetFixedPointSetFileName(parameters.FixedImagePointSetFilename);
}
else
{
transformix.SetFixedPointSetFileName(parameters.MovingImagePointSetFilename);
}
transformix.SetOutputDirectory(ReadWriteUtils.GetOutputDirectory(parameters));
//transformix.SetTransformParameter(0, "UseBinaryFormatForTransformationParameters", "true" );
var par = transformix.GetTransformParameter(0, "TransformParameters");
if (movingImageName != null)
{
sitk.Image movImg = ReadWriteUtils.ReadITKImageFromFile(movingImageName, sitk.PixelIDValueEnum.sitkFloat32);
transformix.SetMovingImage(movImg);
}
sitk.Image image = transformix.Execute();
string output = ReadWriteUtils.GetOutputDirectory(parameters) + "\\outputpoints.txt";
image.Dispose();
return(output);
}
catch (Exception ex)
{
Console.WriteLine(ex);
return(null);
} finally
{
transformix.Dispose();
}
}
/// <summary>
/// Write transformed image to disk.
/// </summary>
/// <param name="imagename">image filename</param>
public void WriteTransformedImage(string imagename)
{
sitk.CastImageFilter castImageFilter = new sitk.CastImageFilter();
castImageFilter.SetOutputPixelType(sitk.PixelIDValueEnum.sitkVectorUInt8);
sitk.Image temp = castImageFilter.Execute(transformedImage);
sitk.ImageFileWriter writer = new sitk.ImageFileWriter();
writer.SetFileName(Path.Combine(registrationParameters.OutputDirectory, imagename));
writer.Execute(temp);
}
/// <summary>
/// Write transformed file to disk.
/// </summary>
/// <param name="imagename">filename</param>
public static void WriteTransformedImage(sitk.Image img, string fullFilename)
{
sitk.CastImageFilter castImageFilter = new sitk.CastImageFilter();
castImageFilter.SetOutputPixelType(sitk.PixelIDValueEnum.sitkVectorUInt8);
sitk.Image temp = castImageFilter.Execute(img);
sitk.ImageFileWriter writer = new sitk.ImageFileWriter();
writer.SetFileName(fullFilename);
writer.Execute(temp);
}
public Image wczytajObraz(string sciezka)
{
ImageFileReader r = new ImageFileReader();
r.SetFileName(sciezka);
r.SetOutputPixelType(itk.simple.PixelIDValueEnum.sitkInt16);
var image = r.Execute();
nazwaObrazu = Path.GetFileName(r.GetFileName());
obraz = image;
return obraz;
}
/// <summary>
///
/// </summary>
/// <param name="refImage"></param>
/// <param name="movImage"></param>
/// <param name="fixedMask"></param>
/// <param name="movingMask"></param>
/// <param name="imageFilename"></param>
/// <returns></returns>
private sitk.VectorOfParameterMap NonRigidRegistrationWithPenalty(sitk.Image refImage, sitk.Image movImage,
sitk.Image fixedMask, sitk.Image movingMask, string imageFilename)
{
// coef map
string coefficientMapFilename = GetInnerStructureSegmentationsAsCoefficientMap(imageFilename);
_parameters.CoefficientMapFilename = coefficientMapFilename;
return(DefaultNonRigidRegistration(refImage, movImage, fixedMask, movImage, imageFilename));
}
/// <summary>
/// Create a displacement field image by the transformation parameters.
/// (Save as .mhd afterwards)
/// </summary>
/// <param name="image">image</param>
/// <param name="transform">transform parameters</param>
/// <returns>displacement field image</returns>
public static sitk.Image GetDisplacementFieldFromTransformation(sitk.Image image, sitk.Transform transform)
{
sitk.TransformToDisplacementFieldFilter filter = new sitk.TransformToDisplacementFieldFilter();
filter.SetReferenceImage(image);
filter.SetOutputPixelType(sitk.PixelIDValueEnum.sitkUInt8);
filter.SetOutputOrigin(image.GetOrigin());
filter.SetOutputDirection(image.GetDirection());
filter.SetOutputSpacing(image.GetSpacing());
return(filter.Execute(transform));
}
private static sitk.LabelOverlapMeasuresImageFilter GetOverlapImageFilter(string mask01iFn, string mask02iFn)
{
sitk.LabelOverlapMeasuresImageFilter overlapFilter;
sitk.Image sImg01 = ReadWriteUtils.ReadITKImageFromFile(mask01iFn);
sitk.Image sImg02 = ReadWriteUtils.ReadITKImageFromFile(mask02iFn);
overlapFilter = VisualizationEvaluationUtils.GetOverlapImageFilter(sImg01, sImg02);
sImg01.Dispose();
sImg02.Dispose();
return(overlapFilter);
}
/// <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());
}
}
public void zapiszObraz(Image obraz1)
{
try {
ImageFileWriter writer = new ImageFileWriter();
string sciezka = Directory.GetCurrentDirectory();
string pathString = Path.Combine(sciezka, "Wyniki");
Random r = new Random();
string e = r.Next(1,100).ToString();
string nazwaPliku1 = "segmentacja" + "_" + e+".dcm";
if (Directory.Exists(pathString) == false)
{
Directory.CreateDirectory(pathString);
}
pathString = Path.Combine(pathString, nazwaPliku1);
// writer.SetFileName(p);
writer.Execute(obraz1, pathString, false);
}
catch
{
throw new Exception("Blad podczas zapisu");
}
}
public Bitmap konwertujObraz(Image obraz1, int przekroj = 0)
{
uint r = obraz1.GetWidth();
// VectorUInt32 w = new VectorUInt32(new[] { r, 512, 4 + 1 });
VectorInt32 start = new VectorInt32(new[]{ 0, 0, 0 });
VectorInt32 size1 = new VectorInt32(new[]{ 512, 512, 1 });
obraz1 = WybierzPrzekroj(obraz1, przekroj);
IntensityWindowingImageFilter normalize = new IntensityWindowingImageFilter();
normalize.SetOutputMinimum(0);
normalize.SetOutputMaximum(255);
obraz1 = normalize.Execute(obraz1);
PixelIDValueEnum u = PixelIDValueEnum.sitkFloat32;
int len = 1;
Image input= SimpleITK.Cast(obraz1, u);
VectorUInt32 size = input.GetSize();
for (int dim = 0; dim < input.GetDimension(); dim++)
{
len *= (int)size[dim];
}
IntPtr buffer = input.GetBufferAsFloat();
float bufferPtr = (float)buffer.ToInt32();
float[] bufferAsArray = new float[len];
float[,] newData = new float[size[0], size[1]];
Marshal.Copy(buffer, bufferAsArray, 0, len);
obrazBitmap = new Bitmap(Convert.ToInt32(size[0]), Convert.ToInt32(size[1]));
for (int j = 0; j < size[1]; j++)
{
for (int i = 0; i < size[0]; i++)
{
var bur = bufferAsArray[j * size[1] + i];
System.Drawing.Color newColor = System.Drawing.Color.FromArgb((int)bur, 0, 0, 0);
obrazBitmap.SetPixel(j, i, newColor);
}
}
Color s= obrazBitmap.GetPixel(34, 56);
return obrazBitmap;
}
public Image WybierzPrzekroj(Image obraz3d, int przekrojMin, int PrzekrojMax)
{
int numberSlices = (int)obraz3d.GetDepth();
if (numberSlices < przekrojMin)
{
return obraz3d;
}
else
{
Image obraz2d = new Image();
if (przekrojMin < PrzekrojMax)
{
if (PrzekrojMax-1 > numberSlices)
{
PrzekrojMax = numberSlices;
}
SliceImageFilter sliceFilter = new SliceImageFilter();
sliceFilter.SetStart(new VectorInt32(new[] { 1, 1, przekrojMin }));
sliceFilter.SetStop(new VectorInt32(new[] { 512, 512, PrzekrojMax }));
obraz2d = sliceFilter.Execute(obraz3d);
sliceFilter.Dispose();
}
return obraz2d;
}
}
