public void AddFile_AnonymizedSeries_AllFilesAddedToSameStudySeriesNode()
{
var dicomFiles = GetDicomFilesFromZip(TestData.Resolve("abd1.zip"));
// Anonymize all files
var anonymizer = new DicomAnonymizer();
foreach (var dicomFile in dicomFiles)
{
anonymizer.AnonymizeInPlace(dicomFile);
}
// Create DICOM directory
var dicomDir = new DicomDirectory();
foreach (var dicomFile in dicomFiles)
{
var entry = dicomDir.AddFile(dicomFile);
Assert.Equal(dicomFile.Dataset.GetSingleValue <string>(DicomTag.SOPInstanceUID), entry.InstanceRecord.GetSingleValue <string>(DicomTag.ReferencedSOPInstanceUIDInFile));
Assert.Equal(dicomFile.Dataset.GetSingleValue <string>(DicomTag.SeriesInstanceUID), entry.SeriesRecord.GetSingleValue <string>(DicomTag.SeriesInstanceUID));
Assert.Equal(dicomFile.Dataset.GetSingleValue <string>(DicomTag.StudyInstanceUID), entry.StudyRecord.GetSingleValue <string>(DicomTag.StudyInstanceUID));
}
var imageNodes = dicomDir.RootDirectoryRecord.LowerLevelDirectoryRecord.LowerLevelDirectoryRecord
.LowerLevelDirectoryRecordCollection;
Assert.Equal(dicomFiles.Count, imageNodes.Count());
}
public void AddFile_AnonymizedSeries_AllFilesAddedToSameStudySeriesNode()
{
var dicomFiles = GetDicomFilesFromWebZip(
"https://www.creatis.insa-lyon.fr/~jpr/PUBLIC/gdcm/gdcmSampleData/Philips_Medical_Images/mr711-mr712/abd1.zip");
// Anonymize all files
var anonymizer = new DicomAnonymizer();
foreach (var dicomFile in dicomFiles)
{
anonymizer.AnonymizeInPlace(dicomFile);
}
// Create DICOM directory
var dicomDir = new DicomDirectory();
foreach (var dicomFile in dicomFiles)
{
dicomDir.AddFile(dicomFile);
}
var imageNodes = dicomDir.RootDirectoryRecord.LowerLevelDirectoryRecord.LowerLevelDirectoryRecord
.LowerLevelDirectoryRecordCollection;
Assert.Equal(dicomFiles.Count, imageNodes.Count());
}
public void AddFile_AnonymizedSeries_AllFilesAddedToSameStudySeriesNode()
{
var dicomFiles = GetDicomFilesFromWebZip(
"https://www.creatis.insa-lyon.fr/~jpr/PUBLIC/gdcm/gdcmSampleData/Philips_Medical_Images/mr711-mr712/abd1.zip");
// Anonymize all files
var anonymizer = new DicomAnonymizer();
foreach (var dicomFile in dicomFiles)
{
anonymizer.AnonymizeInPlace(dicomFile);
}
// Create DICOM directory
var dicomDir = new DicomDirectory();
foreach (var dicomFile in dicomFiles)
{
var entry = dicomDir.AddFile(dicomFile);
Assert.Equal(dicomFile.Dataset.GetSingleValue <string>(DicomTag.SOPInstanceUID), entry.InstanceRecord.GetSingleValue <string>(DicomTag.ReferencedSOPInstanceUIDInFile));
Assert.Equal(dicomFile.Dataset.GetSingleValue <string>(DicomTag.SeriesInstanceUID), entry.SeriesRecord.GetSingleValue <string>(DicomTag.SeriesInstanceUID));
Assert.Equal(dicomFile.Dataset.GetSingleValue <string>(DicomTag.StudyInstanceUID), entry.StudyRecord.GetSingleValue <string>(DicomTag.StudyInstanceUID));
}
var imageNodes = dicomDir.RootDirectoryRecord.LowerLevelDirectoryRecord.LowerLevelDirectoryRecord
.LowerLevelDirectoryRecordCollection;
Assert.Equal(dicomFiles.Count, imageNodes.Count());
}
public void AddFile_AnonymizedSeries_AllFilesAddedToDifferentPatientNodes()
{
var dicomFiles = GetDicomFilesFromZip(TestData.Resolve("abd1.zip"));
// Anonymize all files
var patname = "Pat^Name";
var patname2 = "Pat^^Name^^";
var patname3 = "PAT Name";
var patname4 = "Name^Pat";
var anonymizer = new DicomAnonymizer();
foreach (var dicomFile in dicomFiles)
{
anonymizer.AnonymizeInPlace(dicomFile);
dicomFile.Dataset.AddOrUpdate(DicomTag.PatientName, patname);
}
// the name of the first image is slightly different
dicomFiles.First().Dataset.AddOrUpdate(DicomTag.PatientName, patname2);
dicomFiles.ElementAt(1).Dataset.AddOrUpdate(DicomTag.PatientName, patname3);
dicomFiles.ElementAt(2).Dataset.AddOrUpdate(DicomTag.PatientName, patname4);
// Create DICOM directory
var dicomDir = new DicomDirectory();
foreach (var dicomFile in dicomFiles)
{
var entry = dicomDir.AddFile(dicomFile);
Assert.Equal(dicomFile.Dataset.GetSingleValue <string>(DicomTag.SOPInstanceUID), entry.InstanceRecord.GetSingleValue <string>(DicomTag.ReferencedSOPInstanceUIDInFile));
Assert.Equal(dicomFile.Dataset.GetSingleValue <string>(DicomTag.SeriesInstanceUID), entry.SeriesRecord.GetSingleValue <string>(DicomTag.SeriesInstanceUID));
Assert.Equal(dicomFile.Dataset.GetSingleValue <string>(DicomTag.StudyInstanceUID), entry.StudyRecord.GetSingleValue <string>(DicomTag.StudyInstanceUID));
}
// there shall be only one patient record
Assert.Equal(4, dicomDir.RootDirectoryRecordCollection.Count());
}
protected virtual void RegisterAnonymizer( )
{
string enableAnonymizer = CloudConfigurationManager.GetSetting("app:enableAnonymizer");
bool enable = true;
if (!bool.TryParse(enableAnonymizer, out enable) || enable)
{
string anonymizerOptions = CloudConfigurationManager.GetSetting("app:anonymizerOptions");
var options = DicomAnonymizer.SecurityProfileOptions.BasicProfile |
DicomAnonymizer.SecurityProfileOptions.RetainUIDs |
DicomAnonymizer.SecurityProfileOptions.RetainLongFullDates |
DicomAnonymizer.SecurityProfileOptions.RetainPatientChars;
if (!string.IsNullOrWhiteSpace(anonymizerOptions))
{
options = (DicomAnonymizer.SecurityProfileOptions)Enum.Parse(typeof(DicomAnonymizer.SecurityProfileOptions), anonymizerOptions, true);
}
var anonymizer = new DicomAnonymizer(DicomAnonymizer.SecurityProfile.LoadProfile(null, options));
anonymizer.Profile.PatientName = "Dcloud^Anonymized";
anonymizer.Profile.PatientID = "Dcloud.Anonymized";
RemoveAnonymizerTag(anonymizer, DicomTag.PatientName);
RemoveAnonymizerTag(anonymizer, DicomTag.PatientID);
PublisherSubscriberFactory.Instance.Subscribe <WebStoreDatasetProcessingMessage>(this, (message) =>
{
var queryParams = message.Request.Request.RequestUri.ParseQueryString( );
anonymizer.AnonymizeInPlace(message.Dataset);
if (null != queryParams)
{
foreach (var queryKey in queryParams.OfType <String>())
{
uint tag;
if (string.IsNullOrWhiteSpace(queryKey))
{
continue;
}
if (uint.TryParse(queryKey, System.Globalization.NumberStyles.HexNumber, null, out tag))
{
message.Dataset.AddOrUpdate(tag, queryParams[queryKey]);
}
}
}
});
}
}
public void AnonymizeInPlace_Dataset_PatientDataEmpty()
{
var dataset = DicomFile.Open(TestData.Resolve("CT1_J2KI")).Dataset;
var anonymizer = new DicomAnonymizer();
anonymizer.AnonymizeInPlace(dataset);
Assert.Empty(dataset.GetValues <string>(DicomTag.PatientName));
Assert.Empty(dataset.GetValues <string>(DicomTag.PatientID));
Assert.Empty(dataset.GetValues <string>(DicomTag.PatientSex));
}
public void AnonymizeInPlace_File_SopInstanceUidTransferredToMetaInfo()
{
var file = DicomFile.Open(TestData.Resolve("CT1_J2KI"));
var old = file.Dataset.GetSingleValue <DicomUID>(DicomTag.SOPInstanceUID);
var anonymizer = new DicomAnonymizer();
anonymizer.AnonymizeInPlace(file);
var expected = file.Dataset.GetSingleValue <DicomUID>(DicomTag.SOPInstanceUID);
var actual = file.FileMetaInfo.MediaStorageSOPInstanceUID;
Assert.NotEqual(expected, old);
Assert.Equal(expected, actual);
}
public void AnonymizeInPlace_File_ImplementationVersionNameMaintained()
{
var file = DicomFile.Open(TestData.Resolve("CT1_J2KI"));
var expected = file.FileMetaInfo.ImplementationVersionName;
Assert.False(string.IsNullOrEmpty(expected));
var anonymizer = new DicomAnonymizer();
anonymizer.AnonymizeInPlace(file);
var actual = file.FileMetaInfo.ImplementationVersionName;
Assert.Equal(expected, actual);
}
public void AnonymizeWithoutException()
{
var dataset = new DicomDataset(DicomTransferSyntax.ExplicitVRLittleEndian);
dataset.Add(new DicomDecimalString(new DicomTag(0x01F1, 0x1033, new DicomPrivateCreator("ELSCINT1")), "0.8"));
var _anonymizer = new DicomAnonymizer(DicomAnonymizer.SecurityProfile.LoadProfile(null, (DicomAnonymizer.SecurityProfileOptions) 15));
var ex = Record.Exception(
() =>
_anonymizer.AnonymizeInPlace(dataset)
);
Assert.Null(ex);
}
public void AnonymizeInPlace_RemovableSequence_ShouldBeRemoved()
{
const string fileName = "GH610.dcm";
var tag = DicomTag.OriginalAttributesSequence;
var dataset = DicomFile.Open($"./Test Data/{fileName}").Dataset;
Assert.True(dataset.Contains(tag));
var anonymizer = new DicomAnonymizer();
anonymizer.AnonymizeInPlace(dataset);
Assert.False(dataset.Contains(tag));
}
public void AnonymizeInPlace_SeriesDate_ShouldBeRemoved()
{
const string fileName = "CT1_J2KI";
var tag = DicomTag.SeriesDate;
var dataset = DicomFile.Open($"./Test Data/{fileName}").Dataset;
Assert.True(dataset.GetSingleValue <string>(tag).Length > 0);
var anonymizer = new DicomAnonymizer();
anonymizer.AnonymizeInPlace(dataset);
var contains = dataset.Contains(tag);
Assert.False(contains);
}
// Use this for initialization
private void Start()
{
#if UNITY_EDITOR
using (var stream =
new MemoryStream(UnityEditor.AssetDatabase.LoadAssetAtPath <TextAsset>("Assets/fo-dicom/Demo/Images/image_dfl.bytes")
.bytes))
#else
using (var stream = File.OpenRead("E:/Data/DICOM/CT-MONO2-8-abdo.dcm"))
#endif
{
var file = DicomFile.Open(stream);
var anonymizer = new DicomAnonymizer();
anonymizer.AnonymizeInPlace(file);
_dump = file.WriteToString();
_texture = new DicomImage(file.Dataset).RenderImage().AsTexture2D();
}
}
public void AnonymizeInPlace_StudyDate_ShouldBeEmpty()
{
const string fileName = "CT1_J2KI";
var tag = DicomTag.StudyDate;
var dataset = DicomFile.Open($"./Test Data/{fileName}").Dataset;
Assert.True(dataset.GetSingleValue <string>(tag).Length > 0);
var anonymizer = new DicomAnonymizer();
anonymizer.AnonymizeInPlace(dataset);
var expected = Array.Empty <string>();
var actual = dataset.GetValues <string>(tag);
Assert.Equal(expected, actual);
}
public void AnonymizeInPlace_SequenceToKeep_NestedDatasetsShouldBeParsed()
{
const string fileName = "GH610.dcm";
var tagRoiContourSeq = DicomTag.ROIContourSequence;
var tagContourSeq = DicomTag.ContourSequence;
var tagContourImgSeq = DicomTag.ContourImageSequence;
var generatedUid1 = DicomUIDGenerator.GenerateDerivedFromUUID();
var generatedUid2 = DicomUIDGenerator.GenerateDerivedFromUUID();
var dataset = DicomFile.Open($"./Test Data/{fileName}").Dataset;
dataset.Add(new DicomSequence(tagRoiContourSeq, new DicomDataset(
new DicomSequence(tagContourSeq, new DicomDataset(
new DicomSequence(tagContourImgSeq,
new DicomDataset(
new DicomUniqueIdentifier(DicomTag.ReferencedSOPInstanceUID, generatedUid1.UID),
new DicomIntegerString(DicomTag.ReferencedFrameNumber, 1)
),
new DicomDataset(
new DicomUniqueIdentifier(DicomTag.ReferencedSOPInstanceUID, generatedUid2.UID),
new DicomIntegerString(DicomTag.ReferencedFrameNumber, 2)
)
))
))
));
var anonymizer = new DicomAnonymizer();
anonymizer.AnonymizeInPlace(dataset);
Assert.True(dataset.Contains(tagRoiContourSeq));
var sequence1 = dataset.GetSequence(tagRoiContourSeq);
var sequence2 = sequence1.Items[0].GetSequence(tagContourSeq);
var sequence3 = sequence2.Items[0].GetSequence(tagContourImgSeq);
Assert.NotEqual(sequence3.Items[0].GetSingleValue <DicomUID>(DicomTag.ReferencedSOPInstanceUID), sequence3.Items[1].GetSingleValue <DicomUID>(DicomTag.ReferencedSOPInstanceUID));
Assert.NotEqual(generatedUid1, sequence3.Items[0].GetSingleValue <DicomUID>(DicomTag.ReferencedSOPInstanceUID));
Assert.NotEqual(generatedUid2, sequence3.Items[1].GetSingleValue <DicomUID>(DicomTag.ReferencedSOPInstanceUID));
Assert.Equal(1, sequence3.Items[0].GetSingleValue <int>(DicomTag.ReferencedFrameNumber));
Assert.Equal(2, sequence3.Items[1].GetSingleValue <int>(DicomTag.ReferencedFrameNumber));
}
public void AnonymizeInPlace_ClearableSequence_ShouldBeCleared()
{
const string fileName = "GH610.dcm";
var tag = DicomTag.PersonIdentificationCodeSequence;
var dataset = DicomFile.Open($"./Test Data/{fileName}").Dataset;
dataset.Add(new DicomSequence(tag,
new DicomDataset(new DicomLongString(DicomTag.CodeMeaning, "SOME MEANING"))));
var anonymizer = new DicomAnonymizer();
anonymizer.AnonymizeInPlace(dataset);
Assert.True(dataset.Contains(tag));
var sequence = dataset.GetSequence(tag);
Assert.Equal(0, sequence.Items.Count);
}
public dicomInfoTools(DicomFile file, bool anonymize)
{
if (anonymize)
{
var anonymizer = new DicomAnonymizer();
anonymizer.AnonymizeInPlace(file);
}
dateFormat = "dd.MM.yyyy";
timeFormat = "HH:mm:ss";
if (file.Dataset.Contains(DicomTag.Columns))
{
imageWidth = file.Dataset.Get <int>(DicomTag.Columns);
//Debug.Log($"Image Width found in dataset: {imageWidth}.");
}
else
{
imageWidth = 512;
Debug.Log($"Image Width NOT found in dataset. Defaulting to: {imageWidth}.");
}
imageTransferSyntax = file.Dataset.InternalTransferSyntax.UID.ToString();
if (file.Dataset.Contains(DicomTag.Rows))
{
imageHeight = file.Dataset.Get <int>(DicomTag.Rows);
//Debug.Log($"Image Height found in dataset: {imageHeight}.");
}
else
{
imageHeight = 512;
Debug.Log($"Image Height NOT found in dataset. Defaulting to: {imageHeight}.");
}
if (file.Dataset.Contains(DicomTag.RescaleSlope))
{
imageRescaleSlope = file.Dataset.Get <int>(DicomTag.RescaleSlope);
//Debug.Log($"Image Rescale Slope found in dataset: {imageRescaleSlope}.");
}
else
{
imageRescaleSlope = 1;
Debug.Log($"Image Rescale Slope NOT found in dataset. Defaulting to: {imageRescaleSlope}.");
}
if (file.Dataset.Contains(DicomTag.RescaleIntercept))
{
imageRescaleIntercept = file.Dataset.Get <int>(DicomTag.RescaleIntercept);
//Debug.Log($"Image Rescale Intercept found in dataset: {imageRescaleIntercept}.");
}
else
{
imageRescaleIntercept = -1024;
Debug.Log($"Image Rescale Intercept NOT found in dataset. Defaulting to: {imageRescaleIntercept}.");
}
if (file.Dataset.Contains(DicomTag.WindowWidth))
{
imageWindowWidth = file.Dataset.Get <int>(DicomTag.WindowWidth);
//Debug.Log($"Image Window Width found in dataset: {imageWindowWidth}.");
}
else
{
imageWindowWidth = 300;
Debug.Log($"Image Window Width NOT found in dataset. Defaulting to: {imageWindowWidth}.");
}
if (file.Dataset.Contains(DicomTag.WindowCenter))
{
imageWindowCenter = file.Dataset.Get <int>(DicomTag.WindowCenter);
//Debug.Log($"Image Window Center found in dataset: {imageWindowCenter}.");
}
else
{
imageWindowCenter = 100;
Debug.Log($"Image Window Center NOT found in dataset. Defaulting to: {imageWindowCenter}.");
}
if (file.Dataset.Contains(DicomTag.ImageOrientationPatient))
{
imageOrientationPatient = file.Dataset.Get <double[]>(DicomTag.ImageOrientationPatient);
//Debug.Log($"Image Orientation of Patient found in dataset: {imageOrientationPatient}.");
}
else
{
imageOrientationPatient = null;
Debug.Log($"Image Orientation of Patient NOT found in dataset. Defaulting to: {imageOrientationPatient}.");
}
if (file.Dataset.Contains(DicomTag.PatientID))
{
var id = file.Dataset.Get <string>(DicomTag.PatientID, "N/A");
int num;
bool isParsable = Int32.TryParse(id, out num);
if (isParsable)
{
patientId = num;
}
else
{
patientId = 0;
}
}
else
{
patientId = 0;
}
if (file.Dataset.Contains(DicomTag.PatientAge))
{
var age = file.Dataset.Get <string>(DicomTag.PatientAge, "N/A");
age = age.Substring(0, 3);
int num;
bool isParsable = Int32.TryParse(age, out num);
if (isParsable)
{
patientAge = num;
}
else
{
patientAge = 0;
}
}
else
{
patientAge = 0;
}
if (file.Dataset.Contains(DicomTag.PatientSex))
{
patientSex = file.Dataset.Get <string>(DicomTag.PatientSex, "N/A");
}
else
{
patientSex = "N/A";
}
if (file.Dataset.Contains(DicomTag.PatientName))
{
patientName = file.Dataset.Get <string>(DicomTag.PatientName, "N/A");
}
else
{
patientName = "N/A";
}
if (file.Dataset.Contains(DicomTag.PatientBirthDate))
{
var date = file.Dataset.Get <string>(DicomTag.PatientBirthDate, "N/A");
string format = "yyyyMMdd";
bool isFormattable = DateTime.TryParseExact(date, format, CultureInfo.InvariantCulture, DateTimeStyles.None, out DateTime newDate);
if (isFormattable)
{
patientBd = newDate;
//Debug.Log($"{date} converts to {patientBd.ToString(dateFormat)}.");
}
else
{
patientBd = DateTime.MinValue;
//Debug.Log($"{date} is not in the correct format.");
}
}
else
{
patientBd = DateTime.MinValue;
}
if (file.Dataset.Contains(DicomTag.StudyID))
{
var id = file.Dataset.Get <string>(DicomTag.StudyID, "N/A");
int num;
bool isParsable = Int32.TryParse(id, out num);
if (isParsable)
{
studyId = num;
}
else
{
studyId = 0;
}
}
else
{
studyId = 0;
}
if (file.Dataset.Contains(DicomTag.StudyDate))
{
var date = file.Dataset.Get <string>(DicomTag.StudyDate, "N/A");
string format = "yyyyMMdd";
bool isFormattable = DateTime.TryParseExact(date, format, CultureInfo.InvariantCulture, DateTimeStyles.None, out DateTime newDate);
if (isFormattable)
{
studyDate = newDate;
//Debug.Log($"{date} converts to {studyDate.ToString(dateFormat)}.");
}
else
{
studyDate = DateTime.MinValue;
//Debug.Log($"{date} is not in the correct format.");
}
}
else
{
studyDate = DateTime.MinValue;
}
if (file.Dataset.Contains(DicomTag.StudyTime))
{
var time = file.Dataset.Get <string>(DicomTag.StudyTime, "N/A");
string format = "HHmmss.ffffff";
bool isFormattable = DateTime.TryParseExact(time, format, CultureInfo.InvariantCulture, DateTimeStyles.None, out DateTime newTime);
if (isFormattable)
{
studyTime = newTime;
//Debug.Log($"{time} converts to {newTime.ToString(timeFormat)}.");
}
else
{
studyTime = DateTime.MinValue;
//Debug.Log($"{time} is not in the correct format.");
}
}
else
{
studyTime = DateTime.MinValue;
}
if (file.Dataset.Contains(DicomTag.StudyDescription))
{
studyDescription = file.Dataset.Get <string>(DicomTag.StudyDescription, "N/A");
//Debug.Log(studyDescription.Length);
studyDescription = studyDescription.Remove(studyDescription.Length - 1);
//Debug.Log(studyDescription.Length);
}
else
{
studyDescription = "N/A";
}
if (file.Dataset.Contains(DicomTag.SeriesDescription))
{
studySeriesDescription = file.Dataset.Get <string>(DicomTag.SeriesDescription, "N/A");
}
else
{
studySeriesDescription = "N/A";
}
if (file.Dataset.Contains(DicomTag.ProtocolName))
{
studyProtocolName = file.Dataset.Get <string>(DicomTag.ProtocolName, "N/A");
}
else
{
studyProtocolName = "N/A";
}
if (file.Dataset.Contains(DicomTag.SliceThickness))
{
var thickness = file.Dataset.Get <string>(DicomTag.SliceThickness, "N/A");
float num;
bool isParsable = Single.TryParse(thickness, out num);
if (isParsable)
{
studySliceThickness = num;
}
else
{
studySliceThickness = 0f;
}
}
else
{
studySliceThickness = 0f;
}
if (file.Dataset.Contains(DicomTag.ReferringPhysicianName))
{
studyDoctorName = file.Dataset.Get <string>(DicomTag.ReferringPhysicianName, "N/A");
}
else
{
studyDoctorName = "N/A";
}
if (file.Dataset.Contains(DicomTag.Modality))
{
modality = file.Dataset.Get <string>(DicomTag.Modality, "N/A");
}
else
{
modality = "N/A";
}
if (file.Dataset.Contains(DicomTag.Manufacturer))
{
modalityManufacturer = file.Dataset.Get <string>(DicomTag.Manufacturer, "N/A");
}
else
{
modalityManufacturer = "N/A";
}
orientationPatient = GetPatientOrientationString(imageOrientationPatient);
//Debug.Log($"Patient orientation: {orientationPatient}");
GetDicomInfoString();
//Debug.Log($"Image frame width: {imageWidth} pixels and frame height: {imageHeight} pixels.");
//Debug.Log($"Image Transfer Syntax: {imageTransferSyntax.ToString()}. Applying Decompression Transfer Syntax: {defaultDicomTransferSyntax.ToString()}");
//Debug.Log($"Image Rescale Slope: {imageRescaleSlope} and Rescale Intercept: {imageRescaleIntercept}");
}
