public void LoadMedicalVolumeTest()
{
var dir = TestData.GetFullImagesPath(@"sample_dicom");
var acceptanceTests = new ModerateGeometricAcceptanceTest(string.Empty, string.Empty);
var medicalVolumes = MedIO.LoadAllDicomSeriesInFolderAsync(dir, acceptanceTests).Result;
Assert.AreEqual(1, medicalVolumes.Count);
var medicalVolume = medicalVolumes.First().Volume;
Assert.IsTrue(medicalVolume.Struct.Contours.Any(x => x.StructureSetRoi.RoiName == "Bladder"));
Assert.IsTrue(medicalVolume.Struct.Contours.Any(x => x.StructureSetRoi.RoiName == "Femur_L"));
RtStructWriter.SaveRtStruct(_tempfile, medicalVolume.Struct);
DicomFile file = DicomFile.Open(_tempfile);
var identifiers = medicalVolume.Identifiers.First();
var reloaded = RtStructReader.LoadContours(
file.Dataset,
medicalVolume.Volume.Transform.DicomToData,
identifiers.Series.SeriesInstanceUid,
identifiers.Study.StudyInstanceUid).Item1;
Assert.IsTrue(reloaded.Contours.Any(x => x.StructureSetRoi.RoiName == "Bladder"));
Assert.IsTrue(reloaded.Contours.Any(x => x.StructureSetRoi.RoiName == "Femur_L"));
}
public void LoadImageAndContours()
{
var acceptanceTests = new ModerateGeometricAcceptanceTest(string.Empty, string.Empty);
var medicalVolume = MedIO.LoadAllDicomSeriesInFolderAsync(TestData.GetFullImagesPath(@"sample_dicom"), acceptanceTests).Result.First().Volume;
var volumes = new Dictionary <string, ContourStatistics>()
{
{ "Bladder", new ContourStatistics(95.87, -1000.0, 0) },
{ "Femur_L", new ContourStatistics(205.04, -1000.0, 0) },
};
var readOnlyVolume = new ReadOnlyVolume3D <short>(medicalVolume.Volume);
for (int i = 0; i < medicalVolume.Struct.Contours.Count; i++)
{
var contour = medicalVolume.Struct.Contours[i];
var name = contour.StructureSetRoi.RoiName;
var contourVolume = contour.Contours.ToVolume3D(medicalVolume.Volume);
Console.WriteLine($"Starting checks for contour {name}");
var contourStatistics = ContourStatistics.FromVolumeAndMask(readOnlyVolume, contourVolume);
Assert.AreEqual(volumes[contour.StructureSetRoi.RoiName].SizeInCubicCentimeters, contourStatistics.SizeInCubicCentimeters, 1e-1, $"Size for contour {name}");
Assert.AreEqual(volumes[contour.StructureSetRoi.RoiName].VoxelValueMean, contourStatistics.VoxelValueMean, 1e-1, $"Mean for contour {name}");
Assert.AreEqual(volumes[contour.StructureSetRoi.RoiName].VoxelValueStandardDeviation, contourStatistics.VoxelValueStandardDeviation, 1e-1, $"Std for contour {name}");
}
}
public void LoadAndSaveMedicalVolumeTest()
{
var directory = TestData.GetFullImagesPath("sample_dicom");
var acceptanceTests = new StrictGeometricAcceptanceTest(string.Empty, string.Empty);
var medicalVolume = MedIO.LoadAllDicomSeriesInFolderAsync(directory, acceptanceTests).Result.First().Volume;
Directory.CreateDirectory(_tempFolder);
Console.WriteLine($"Directory created {_tempFolder}");
Volume3D <byte>[] contourVolumes = new Volume3D <byte> [medicalVolume.Struct.Contours.Count];
for (int i = 0; i < medicalVolume.Struct.Contours.Count; i++)
{
contourVolumes[i] = new Volume3D <byte>(
medicalVolume.Volume.DimX,
medicalVolume.Volume.DimY,
medicalVolume.Volume.DimZ,
medicalVolume.Volume.SpacingX,
medicalVolume.Volume.SpacingY,
medicalVolume.Volume.SpacingZ,
medicalVolume.Volume.Origin,
medicalVolume.Volume.Direction);
contourVolumes[i].Fill(medicalVolume.Struct.Contours[i].Contours, (byte)1);
}
// Calculate contours based on masks
var rtContours = new List <RadiotherapyContour>();
for (int i = 0; i < medicalVolume.Struct.Contours.Count; i++)
{
var contour = medicalVolume.Struct.Contours[i];
var contourForAllSlices = GetContoursForAllSlices(contourVolumes[i]);
var rtcontour = new DicomRTContour(
contour.DicomRtContour.ReferencedRoiNumber,
contour.DicomRtContour.RGBColor,
contourForAllSlices);
DicomRTStructureSetROI rtROIstructure = new DicomRTStructureSetROI(
contour.StructureSetRoi.RoiNumber,
contour.StructureSetRoi.RoiName,
string.Empty,
ERoiGenerationAlgorithm.Semiautomatic);
DicomRTObservation observation = new DicomRTObservation(
contour.DicomRtObservation.ReferencedRoiNumber, new DicomPersonNameConverter("Left^Richard^^Dr"), ROIInterpretedType.EXTERNAL);
rtContours.Add(new RadiotherapyContour(rtcontour, rtROIstructure, observation));
}
var rtStructureSet = new RadiotherapyStruct(
medicalVolume.Struct.StructureSet,
medicalVolume.Struct.Patient,
medicalVolume.Struct.Equipment,
medicalVolume.Struct.Study,
medicalVolume.Struct.RTSeries,
rtContours);
MedIO.SaveMedicalVolumeAsync(_tempFolder, new MedicalVolume(
medicalVolume.Volume,
medicalVolume.Identifiers,
medicalVolume.FilePaths,
rtStructureSet)).Wait();
var medicalVolume2 = MedIO.LoadAllDicomSeriesInFolderAsync(_tempFolder, acceptanceTests).Result.First().Volume;
foreach (var radiotherapyContour in medicalVolume2.Struct.Contours.Where(x => x.DicomRtContour.DicomRtContourItems.First().GeometricType == "CLOSED_PLANAR"))
{
var savedContour =
medicalVolume2.Struct.Contours.First(x => x.StructureSetRoi.RoiName == radiotherapyContour.StructureSetRoi.RoiName);
foreach (var contour in radiotherapyContour.Contours)
{
Assert.AreEqual(radiotherapyContour.DicomRtObservation.ROIInterpretedType, ROIInterpretedType.EXTERNAL);
for (int i = 0; i < contour.Value.Count; i++)
{
if (!contour.Value[i].Equals(savedContour.Contours.ContoursForSlice(contour.Key)[i]))
{
Console.WriteLine(radiotherapyContour.StructureSetRoi.RoiName);
Assert.Fail();
}
}
}
}
}
/// <summary>
/// Test Nifti file to DICOM-RT translation.
/// </summary>
/// <param name="niftiFilename">Source Nifti file.</param>
/// <param name="referenceSeries">Reference DICOM series folder.</param>
/// <param name="structureNames">List of structure names for DICOM-RT.</param>
/// <param name="structureColors">List of structure colours for DICOM-RT.</param>
/// <param name="fillHoles">List of fill hole flags for DICOM-RT.</param>
/// <param name="roiInterpretedType">List of roiInterpretedType for DICOM-RT.</param>
/// <param name="debugFolderName">If present, create a full set of debug images.</param>
/// <param name="testVolumesMatch">If true, check the volumes match.</param>
/// <param name="expectedNiftiFilename">Expect volume to match Nifti file.</param>
public static void DoTestNiftiToDicom(
string niftiFilename,
string referenceSeries,
string[] structureNames,
RGBColorOption?[] structureColors,
bool?[] fillHoles,
ROIInterpretedType[] roiInterpretedTypes,
string debugFolderName,
bool testVolumesMatch,
string expectedNiftiFilename)
{
var outputFileName = Path.GetRandomFileName() + ".dcm";
RTConverters.ConvertNiftiToDicom(
niftiFilename,
referenceSeries,
structureNames,
structureColors,
fillHoles,
roiInterpretedTypes,
outputFileName,
"modelX:1",
"manufacturer",
"interpreter");
// Open the newly created DICOM-RT file
var dicomRTFile = DicomFile.Open(outputFileName);
// Get the medical volume from the reference
var acceptanceTests = new ModerateGeometricAcceptanceTest(string.Empty, string.Empty);
var referenceMedicalVolumes = MedIO.LoadAllDicomSeriesInFolderAsync(referenceSeries, acceptanceTests).Result;
Assert.AreEqual(1, referenceMedicalVolumes.Count);
var referenceMedicalVolume = referenceMedicalVolumes.First().Volume;
var referenceIdentifiers = referenceMedicalVolume.Identifiers.First();
// Extract the RTStruct from the DICOM-RT file
var reloaded = RtStructReader.LoadContours(
dicomRTFile.Dataset,
referenceMedicalVolume.Volume.Transform.DicomToData,
referenceIdentifiers.Series.SeriesInstanceUid,
referenceIdentifiers.Study.StudyInstanceUid);
Assert.IsNotNull(reloaded);
var reloadedRTStruct = reloaded.Item1;
Assert.AreEqual(referenceIdentifiers.Patient.Id, reloadedRTStruct.Patient.Id);
Assert.AreEqual(referenceIdentifiers.Study.StudyInstanceUid, reloadedRTStruct.Study.StudyInstanceUid);
Assert.AreEqual(DicomRTSeries.RtModality, reloadedRTStruct.RTSeries.Modality);
// Load the nifti file
var sourceVolume = MedIO.LoadNiftiAsByte(expectedNiftiFilename);
// Split this volume from segment id to a set of mask volumes
var labels = VolumeMetadataMapper.MultiLabelMapping(sourceVolume, structureNames.Length);
// Make tuples of mask volume, color, names, fill holes.
var volumesWithMetadata = VolumeMetadataMapper.MapVolumeMetadata(labels, structureNames, structureColors, fillHoles, roiInterpretedTypes).ToArray();
Assert.AreEqual(structureNames.Length, reloadedRTStruct.Contours.Count);
for (int i = 0; i < reloadedRTStruct.Contours.Count; i++)
{
var contourVolumes = new Volume3D <byte>(
referenceMedicalVolume.Volume.DimX,
referenceMedicalVolume.Volume.DimY,
referenceMedicalVolume.Volume.DimZ,
referenceMedicalVolume.Volume.SpacingX,
referenceMedicalVolume.Volume.SpacingY,
referenceMedicalVolume.Volume.SpacingZ,
referenceMedicalVolume.Volume.Origin,
referenceMedicalVolume.Volume.Direction);
contourVolumes.Fill(reloadedRTStruct.Contours[i].Contours, (byte)1);
var v = volumesWithMetadata[i];
if (!string.IsNullOrWhiteSpace(debugFolderName))
{
for (var z = 0; z < referenceMedicalVolume.Volume.DimZ; z++)
{
var actualFileName = Path.Combine(debugFolderName, "actual", $"slice_{v.name}_{z}.png");
var actualSlice = contourVolumes.Slice(SliceType.Axial, z);
actualSlice.SaveBinaryMaskToPng(actualFileName);
var expectedFileName = Path.Combine(debugFolderName, "expected", $"slice_{v.name}_{z}.png");
var expectedSlice = v.volume.Slice(SliceType.Axial, z);
expectedSlice.SaveBinaryMaskToPng(expectedFileName);
}
}
if (testVolumesMatch)
{
VolumeAssert.AssertVolumesMatch(v.volume, contourVolumes, $"Loaded mask {i}");
}
Assert.AreEqual(v.name, reloadedRTStruct.Contours[i].StructureSetRoi.RoiName, $"Loaded mask name {i}");
var expectedColor = Tuple.Create(v.color.R, v.color.G, v.color.B);
Assert.AreEqual(expectedColor, reloadedRTStruct.Contours[i].DicomRtContour.RGBColor, $"Loaded color {i}");
}
}
