public DicomItem ReplaceUID(DicomDataset oldds, List <TagOrIndex> path, DicomItem item)
{
var element = (item as DicomElement);
if (element == null)
{
throw new InvalidOperationException($"ReplaceUID can not handle type: {item.GetType()}");
}
if (element.ValueRepresentation != DicomVR.UI)
{
throw new ArgumentOutOfRangeException($"Tag: {element.Tag} is marked as U but VR is: {element.ValueRepresentation}");
}
string rep;
DicomUID uid;
var old = element.Get <string>();
if (ReplacedUIDs.ContainsKey(old))
{
rep = ReplacedUIDs[old];
uid = new DicomUID(rep, "Anonymized UID", DicomUidType.Unknown);
}
else
{
uid = DicomUIDGenerator.GenerateDerivedFromUUID();
rep = uid.UID;
ReplacedUIDs[old] = rep;
}
return(new DicomUniqueIdentifier(element.Tag, uid));
}
public DicomItem ReplaceUID(DicomDataset oldds, IReadOnlyList <TagOrIndex> path, DicomItem item)
{
item = item ?? throw new ArgumentNullException(nameof(item));
#pragma warning disable CA1508 // Avoid dead conditional code
if (!(item is DicomElement element))
#pragma warning restore CA1508 // Avoid dead conditional code
{
throw new InvalidOperationException($"ReplaceUID can not handle type: {item.GetType()}");
}
if (element.ValueRepresentation != DicomVR.UI)
{
throw new ArgumentOutOfRangeException($"Tag: {element.Tag} is marked as U but VR is: {element.ValueRepresentation}");
}
string rep;
DicomUID uid;
var old = element.Get <string>();
if (ReplacedUIDs.ContainsKey(old))
{
rep = ReplacedUIDs[old];
uid = new DicomUID(rep, "Anonymized UID", DicomUidType.Unknown);
}
else
{
uid = DicomUIDGenerator.GenerateDerivedFromUUID();
rep = uid.UID;
ReplacedUIDs[old] = rep;
}
return(new DicomUniqueIdentifier(element.Tag, uid));
}
public async Task RetrieveMetadata_Instance_DicomDataset()
{
var studyUid = DicomUIDGenerator.GenerateDerivedFromUUID();
var seriesUid = DicomUIDGenerator.GenerateDerivedFromUUID();
var instanceUid = DicomUIDGenerator.GenerateDerivedFromUUID();
var response = new HttpResponseMessage
{
StatusCode = HttpStatusCode.OK,
Content = _fixture.GenerateInstancesAsJson(2, studyUid, seriesUid),
};
Mock <HttpMessageHandler> handlerMock;
HttpClient httpClient;
GenerateHttpClient(response, out handlerMock, out httpClient);
var wado = new WadoService(httpClient);
var instance = await wado.RetrieveMetadata <string>(studyUid.UID, seriesUid.UID, instanceUid.UID);
Assert.IsType <string>(instance);
handlerMock.Protected().Verify(
"SendAsync",
Times.Exactly(1),
ItExpr.Is <HttpRequestMessage>(req =>
req.Method == HttpMethod.Get &&
req.RequestUri.ToString().Equals($"{BaseUri}studies/{studyUid.UID}/series/{seriesUid.UID}/instances/{instanceUid.UID}/metadata") &&
req.Headers.Accept.First().MediaType.Equals(DicomFileGeneratorFixture.MimeApplicationDicomJson)),
ItExpr.IsAny <CancellationToken>());
}
public static DicomDataset BuildZooDataset()
{
var target = new DicomDataset
{
new DicomPersonName(DicomTag.PatientName, new[] { "Anna^Pelle", null, "Olle^Jöns^Pyjamas" }),
{ DicomTag.SOPClassUID, DicomUID.RTPlanStorage },
{ DicomTag.SOPInstanceUID, DicomUIDGenerator.GenerateDerivedFromUUID() },
{ DicomTag.SeriesInstanceUID, new DicomUID[] { } },
{ DicomTag.DoseType, "HEJ" },
{ DicomTag.ControlPointSequence, (DicomSequence[])null }
};
List <DicomDataset> beams = new[] { 1, 2, 3 }.Select(beamNumber =>
{
var beam = new DicomDataset
{
{ DicomTag.BeamNumber, beamNumber },
{ DicomTag.BeamName, $"Beam #{beamNumber}" }
};
return(beam);
}).ToList();
beams.Insert(1, null);
target.Add(DicomTag.BeamSequence, beams.ToArray());
return(target);
}
public async Task Retrieve_Series_BadUids()
{
var httpClient = new HttpClient();
var wado = new WadoService(httpClient, new Uri("http://dummy/api/"));
await Assert.ThrowsAsync <ArgumentNullException>(async() =>
{
await foreach (var instance in wado.Retrieve(null, seriesInstanceUid: null))
{
}
});
await Assert.ThrowsAsync <DicomValidationException>(async() =>
{
await foreach (var instance in wado.Retrieve("bad uid", seriesInstanceUid: null))
{
}
});
await Assert.ThrowsAsync <ArgumentNullException>(async() =>
{
await foreach (var instance in
wado.Retrieve(DicomUIDGenerator.GenerateDerivedFromUUID().UID, seriesInstanceUid: null))
{
}
});
await Assert.ThrowsAsync <DicomValidationException>(async() =>
{
await foreach (var instance in
wado.Retrieve(DicomUIDGenerator.GenerateDerivedFromUUID().UID, seriesInstanceUid: "bad uid"))
{
}
});
}
public async Task OnCGetRequestAsync_ImmediateSuccess_ShouldRespond()
{
var port = Ports.GetNext();
using (DicomServer.Create <ImmediateSuccessAsyncDicomCGetProvider>(port, logger: _logger.IncludePrefix("DicomServer")))
{
var client = new Client.DicomClient("127.0.0.1", port, false, "SCU", "ANY-SCP")
{
Logger = _logger.IncludePrefix(typeof(DicomClient).Name)
};
DicomCGetResponse response = null;
DicomRequest.OnTimeoutEventArgs timeout = null;
var studyInstanceUID = DicomUIDGenerator.GenerateDerivedFromUUID().ToString();
var request = new DicomCGetRequest(studyInstanceUID)
{
OnResponseReceived = (req, res) => response = res,
OnTimeout = (sender, args) => timeout = args
};
await client.AddRequestAsync(request).ConfigureAwait(false);
await client.SendAsync().ConfigureAwait(false);
Assert.NotNull(response);
Assert.Equal(DicomStatus.Success, response.Status);
Assert.Null(timeout);
}
}
public async Task SearchForStudies_AllStudies()
{
var studyUid = DicomUIDGenerator.GenerateDerivedFromUUID();
var response = new HttpResponseMessage
{
StatusCode = HttpStatusCode.OK,
Content = _fixture.GenerateInstancesAsJson(1, studyUid),
};
Mock <HttpMessageHandler> handlerMock;
HttpClient httpClient;
GenerateHttpClient(response, out handlerMock, out httpClient);
var qido = new QidoService(httpClient);
var count = 0;
await foreach (var instance in qido.SearchForStudies())
{
count++;
Assert.IsType <string>(instance);
}
Assert.Equal(1, count);
handlerMock.Protected().Verify(
"SendAsync",
Times.Exactly(1),
ItExpr.Is <HttpRequestMessage>(req =>
req.Method == HttpMethod.Get &&
req.RequestUri.ToString().StartsWith($"{BaseUri}studies/")),
ItExpr.IsAny <CancellationToken>());
}
public async Task Store_HandlesResponses(HttpStatusCode status, string message)
{
var studyInstanceUid = DicomUIDGenerator.GenerateDerivedFromUUID();
var instances = _fixture.GenerateDicomFiles(3, studyInstanceUid);
var response = new HttpResponseMessage
{
StatusCode = status,
Content = new StringContent(message)
};
Mock <HttpMessageHandler> handlerMock;
HttpClient httpClient;
GenerateHttpClient(response, out handlerMock, out httpClient);
var service = new StowService(httpClient, _logger.Object);
var dicomWebResponse = await service.Store(instances);
Assert.IsType <DicomWebResponse <string> >(dicomWebResponse);
Assert.Equal(message, dicomWebResponse.Result);
Assert.Equal(status, dicomWebResponse.StatusCode);
handlerMock.Protected().Verify(
"SendAsync",
Times.Exactly(1),
ItExpr.Is <HttpRequestMessage>(req =>
req.Method == HttpMethod.Post &&
req.Content is MultipartContent &&
req.RequestUri.ToString().Equals($"{BaseUri}studies/")),
ItExpr.IsAny <CancellationToken>());
}
public async Task RetrieveMetadata_Series_DicomDataset()
{
var studyUid = DicomUIDGenerator.GenerateDerivedFromUUID();
var seriesUid = DicomUIDGenerator.GenerateDerivedFromUUID();
var response = new HttpResponseMessage
{
StatusCode = HttpStatusCode.OK,
Content = _fixture.GenerateInstancesAsJson(2, studyUid, seriesUid),
};
Mock <HttpMessageHandler> handlerMock;
HttpClient httpClient;
GenerateHttpClient(response, out handlerMock, out httpClient);
var wado = new WadoService(httpClient, new Uri("http://dummy/api/"));
var count = 0;
await foreach (var instance in wado.RetrieveMetadata <DicomDataset>(studyUid.UID, seriesUid.UID))
{
count++;
Assert.IsType <DicomDataset>(instance);
}
Assert.Equal(2, count);
handlerMock.Protected().Verify(
"SendAsync",
Times.Exactly(1),
ItExpr.Is <HttpRequestMessage>(req =>
req.Method == HttpMethod.Get &&
req.Headers.Accept.First().MediaType.Equals(DicomFileGeneratorFixture.MimeApplicationDicomJson)),
ItExpr.IsAny <CancellationToken>());
}
public async Task RetrieveMetadata_Instance_HandleEmptyDataWithHttpOk()
{
var studyUid = DicomUIDGenerator.GenerateDerivedFromUUID();
var seriesUid = DicomUIDGenerator.GenerateDerivedFromUUID();
var instanceUid = DicomUIDGenerator.GenerateDerivedFromUUID();
var response = new HttpResponseMessage
{
StatusCode = HttpStatusCode.OK,
Content = new StringContent("")
};
Mock <HttpMessageHandler> handlerMock;
HttpClient httpClient;
GenerateHttpClient(response, out handlerMock, out httpClient);
var wado = new WadoService(httpClient, new Uri("http://dummy/api/"));
var result = await wado.RetrieveMetadata <string>(studyUid.UID, seriesUid.UID, instanceUid.UID);
Assert.Null(result);
handlerMock.Protected().Verify(
"SendAsync",
Times.Exactly(1),
ItExpr.Is <HttpRequestMessage>(req =>
req.Method == HttpMethod.Get &&
req.Headers.Accept.First().MediaType.Equals(DicomFileGeneratorFixture.MimeApplicationDicomJson)),
ItExpr.IsAny <CancellationToken>());
}
public async Task Retrieve_Bulkdata_WithCustomTransferSyntax(string transferSyntaxUid)
{
var transferSyntax = transferSyntaxUid != null?DicomTransferSyntax.Parse(transferSyntaxUid) : null;
var studyUid = DicomUIDGenerator.GenerateDerivedFromUUID();
var seriesUid = DicomUIDGenerator.GenerateDerivedFromUUID();
var instanceUid = DicomUIDGenerator.GenerateDerivedFromUUID();
var response = new HttpResponseMessage
{
StatusCode = HttpStatusCode.OK,
Content = _fixture.GenerateByteData(),
};
Mock <HttpMessageHandler> handlerMock;
HttpClient httpClient;
GenerateHttpClient(response, out handlerMock, out httpClient);
var wado = new WadoService(httpClient, new Uri("http://dummy/api/"));
await wado.Retrieve(studyUid.UID, seriesUid.UID, instanceUid.UID, DicomTag.PixelData, transferSyntaxes : transferSyntax);
handlerMock.Protected().Verify(
"SendAsync",
Times.Exactly(1),
ItExpr.Is <HttpRequestMessage>(req =>
req.Method == HttpMethod.Get &&
req.Headers.Accept.First().Parameters.Any(
p => p.Value.Contains(transferSyntaxUid ?? MimeMappings.MimeTypeMappings[MimeType.Dicom]))),
ItExpr.IsAny <CancellationToken>());
}
public async Task Retrieve_Instance_HandleNullDataWithHttpOk()
{
var studyUid = DicomUIDGenerator.GenerateDerivedFromUUID();
var seriesUid = DicomUIDGenerator.GenerateDerivedFromUUID();
var instanceUid = DicomUIDGenerator.GenerateDerivedFromUUID();
var response = new HttpResponseMessage
{
StatusCode = HttpStatusCode.OK,
Content = null
};
Mock <HttpMessageHandler> handlerMock;
HttpClient httpClient;
GenerateHttpClient(response, out handlerMock, out httpClient);
var wado = new WadoService(httpClient, new Uri("http://dummy/api/"));
var result = await wado.Retrieve(studyUid.UID, seriesUid.UID, instanceUid.UID);
Assert.Null(result);
handlerMock.Protected().Verify(
"SendAsync",
Times.Exactly(1),
ItExpr.Is <HttpRequestMessage>(req =>
req.Method == HttpMethod.Get &&
req.Headers.Accept.First().Parameters.Any(
p => p.Value.Contains(MimeMappings.MimeTypeMappings[MimeType.Dicom]))),
ItExpr.IsAny <CancellationToken>());
}
public async Task RetrieveMetadata_Instance_BadUids()
{
var httpClient = new HttpClient();
var wado = new WadoService(httpClient, new Uri("http://dummy/api/"));
await Assert.ThrowsAsync <ArgumentNullException>(async() =>
{
await wado.RetrieveMetadata <string>(null, seriesInstanceUid: null, sopInstanceUid: null);
});
await Assert.ThrowsAsync <DicomValidationException>(async() =>
{
await wado.RetrieveMetadata <string>("bad uid", seriesInstanceUid: null, sopInstanceUid: null);
});
await Assert.ThrowsAsync <ArgumentNullException>(async() =>
{
await wado.RetrieveMetadata <string>(DicomUIDGenerator.GenerateDerivedFromUUID().UID, seriesInstanceUid: null, sopInstanceUid: null);
});
await Assert.ThrowsAsync <DicomValidationException>(async() =>
{
await wado.RetrieveMetadata <string>(DicomUIDGenerator.GenerateDerivedFromUUID().UID, seriesInstanceUid: "bad id", sopInstanceUid: "bad id");
});
await Assert.ThrowsAsync <ArgumentNullException>(async() =>
{
await wado.RetrieveMetadata <string>(DicomUIDGenerator.GenerateDerivedFromUUID().UID, seriesInstanceUid: DicomUIDGenerator.GenerateDerivedFromUUID().UID, sopInstanceUid: null);
});
await Assert.ThrowsAsync <DicomValidationException>(async() =>
{
await wado.RetrieveMetadata <string>(DicomUIDGenerator.GenerateDerivedFromUUID().UID, seriesInstanceUid: DicomUIDGenerator.GenerateDerivedFromUUID().UID, sopInstanceUid: "bad id");
});
}
public async Task Store_HandlesSendAsyncFailures()
{
var studyInstanceUid = DicomUIDGenerator.GenerateDerivedFromUUID();
var instances = _fixture.GenerateDicomFiles(1, studyInstanceUid);
var handlerMock = new Mock <HttpMessageHandler>();
handlerMock
.Protected()
.Setup <Task <HttpResponseMessage> >(
"SendAsync",
ItExpr.IsAny <HttpRequestMessage>(),
ItExpr.IsAny <CancellationToken>())
.Throws(new Exception("unknown"));
var httpClient = new HttpClient(handlerMock.Object)
{
BaseAddress = new Uri(BaseUri)
};
var service = new StowService(httpClient, _logger.Object);
var exception = await Assert.ThrowsAsync <DicomWebClientException>(async() => await service.Store(instances));
Assert.Null(exception.StatusCode);
}
private static DicomDataset GenerateDicomDataset(DicomUID studyUid, DicomUID seriesUid, DicomUID instanceUid, DicomTransferSyntax transferSynx)
{
if (seriesUid == null)
{
seriesUid = DicomUIDGenerator.GenerateDerivedFromUUID();
}
if (instanceUid == null)
{
instanceUid = DicomUIDGenerator.GenerateDerivedFromUUID();
}
if (transferSynx == null)
{
transferSynx = DicomTransferSyntax.ExplicitVRLittleEndian;
}
var dicomDataset = new DicomDataset(transferSynx ?? DicomTransferSyntax.ExplicitVRLittleEndian);
dicomDataset.Add(DicomTag.PatientID, "TEST");
dicomDataset.Add(DicomTag.SOPClassUID, DicomUID.CTImageStorage);
dicomDataset.Add(DicomTag.StudyInstanceUID, studyUid);
dicomDataset.Add(DicomTag.SeriesInstanceUID, seriesUid);
dicomDataset.Add(DicomTag.SOPInstanceUID, instanceUid);
return(dicomDataset);
}
public async Task Retrieve_Instance_BadUids()
{
var httpClient = GetHttpClient();
var wado = new WadoService(httpClient);
await Assert.ThrowsAsync <ArgumentNullException>(async() =>
{
await wado.Retrieve(null, seriesInstanceUid: null, sopInstanceUid: null);
});
await Assert.ThrowsAsync <DicomValidationException>(async() =>
{
await wado.Retrieve("bad uid", seriesInstanceUid: null, sopInstanceUid: null);
});
await Assert.ThrowsAsync <ArgumentNullException>(async() =>
{
await wado.Retrieve(DicomUIDGenerator.GenerateDerivedFromUUID().UID, seriesInstanceUid: null, sopInstanceUid: null);
});
await Assert.ThrowsAsync <DicomValidationException>(async() =>
{
await wado.Retrieve(DicomUIDGenerator.GenerateDerivedFromUUID().UID, seriesInstanceUid: "bad id", sopInstanceUid: null);
});
await Assert.ThrowsAsync <ArgumentNullException>(async() =>
{
await wado.Retrieve(DicomUIDGenerator.GenerateDerivedFromUUID().UID, seriesInstanceUid: DicomUIDGenerator.GenerateDerivedFromUUID().UID, sopInstanceUid: null);
});
await Assert.ThrowsAsync <DicomValidationException>(async() =>
{
await wado.Retrieve(DicomUIDGenerator.GenerateDerivedFromUUID().UID, seriesInstanceUid: DicomUIDGenerator.GenerateDerivedFromUUID().UID, sopInstanceUid: "bad uid");
});
}
public async Task Retrieve_Instance_WithCustomTransferSyntax(string transferSyntaxUid)
{
var transferSyntax = transferSyntaxUid != null?DicomTransferSyntax.Parse(transferSyntaxUid) : null;
var studyUid = DicomUIDGenerator.GenerateDerivedFromUUID();
var seriesUid = DicomUIDGenerator.GenerateDerivedFromUUID();
var instanceUid = DicomUIDGenerator.GenerateDerivedFromUUID();
var response = new HttpResponseMessage
{
StatusCode = HttpStatusCode.OK,
Content = await _fixture.GenerateInstances(2, studyUid, seriesUid, instanceUid, transferSynx : transferSyntax),
};
Mock <HttpMessageHandler> handlerMock;
HttpClient httpClient;
GenerateHttpClient(response, out handlerMock, out httpClient);
var wado = new WadoService(httpClient);
await wado.Retrieve(studyUid.UID, seriesUid.UID, instanceUid.UID, transferSyntax);
handlerMock.Protected().Verify(
"SendAsync",
Times.Exactly(1),
ItExpr.Is <HttpRequestMessage>(req =>
req.Method == HttpMethod.Get &&
req.RequestUri.ToString().Equals($"{BaseUri}studies/{studyUid.UID}/series/{seriesUid.UID}/instances/{instanceUid.UID}/") &&
req.Headers.Accept.First().Parameters.Any(
p => p.Value.Contains(transferSyntaxUid ?? MimeMappings.MimeTypeMappings[MimeType.Dicom]))),
ItExpr.IsAny <CancellationToken>());
}
public async Task RetrieveMetadata_Series_BadUids()
{
var httpClient = GetHttpClient();
var wado = new WadoService(httpClient);
await Assert.ThrowsAsync <ArgumentNullException>(async() =>
{
await foreach (var instance in wado.RetrieveMetadata <string>(null, seriesInstanceUid: null))
{
}
});
await Assert.ThrowsAsync <DicomValidationException>(async() =>
{
await foreach (var instance in wado.RetrieveMetadata <string>("bad uid", seriesInstanceUid: null))
{
}
});
await Assert.ThrowsAsync <ArgumentNullException>(async() =>
{
await foreach (var instance in wado.RetrieveMetadata <string>(DicomUIDGenerator.GenerateDerivedFromUUID().UID, seriesInstanceUid: null))
{
}
});
await Assert.ThrowsAsync <DicomValidationException>(async() =>
{
await foreach (var instance in wado.RetrieveMetadata <string>(DicomUIDGenerator.GenerateDerivedFromUUID().UID, seriesInstanceUid: "bad uid"))
{
}
});
}
/// <summary>
/// Construct new film session from scratch
/// </summary>
/// <param name="sopClassUID">Film session SOP Class UID</param>
/// <param name="sopInstance">Film session SOP instance UID</param>
/// <param name="isColor">Color images?</param>
public FilmSession(DicomUID sopClassUID, DicomUID sopInstance = null, bool isColor = false)
{
InternalTransferSyntax = DicomTransferSyntax.ExplicitVRLittleEndian;
if (sopClassUID == null)
{
throw new ArgumentNullException(nameof(sopClassUID));
}
SOPClassUID = sopClassUID;
if (sopInstance == null || sopInstance.UID == string.Empty)
{
#if NET35
SOPInstanceUID = DicomUID.Generate();
#else
SOPInstanceUID = DicomUIDGenerator.GenerateDerivedFromUUID();
#endif
}
else
{
SOPInstanceUID = sopInstance;
}
Add(DicomTag.SOPClassUID, SOPClassUID);
Add(DicomTag.SOPInstanceUID, SOPInstanceUID);
BasicFilmBoxes = new List <FilmBox>();
PresentationLuts = new List <PresentationLut>();
IsColor = isColor;
}
public async Task OnCGetRequestAsync_Pending_ShouldRespond()
{
var port = Ports.GetNext();
using (DicomServerFactory.Create <PendingAsyncDicomCGetProvider>(port, logger: _logger.IncludePrefix("DicomServer")))
{
var client = DicomClientFactory.Create("127.0.0.1", port, false, "SCU", "ANY-SCP");
client.Logger = _logger.IncludePrefix(typeof(DicomClient).Name);
var responses = new ConcurrentQueue <DicomCGetResponse>();
DicomRequest.OnTimeoutEventArgs timeout = null;
var studyInstanceUID = DicomUIDGenerator.GenerateDerivedFromUUID().ToString();
var request = new DicomCGetRequest(studyInstanceUID)
{
OnResponseReceived = (req, res) => responses.Enqueue(res),
OnTimeout = (sender, args) => timeout = args
};
await client.AddRequestAsync(request).ConfigureAwait(false);
await client.SendAsync().ConfigureAwait(false);
Assert.Collection(
responses,
response1 => Assert.Equal(DicomStatus.Pending, response1.Status),
response2 => Assert.Equal(DicomStatus.Pending, response2.Status),
response3 => Assert.Equal(DicomStatus.Success, response3.Status)
);
Assert.Null(timeout);
}
}
public void DicomValidation_AddInvalidData()
{
var ds = new DicomDataset();
var invalidUid = "1.2.315.6666.008965..19187632.1";
// trying to add this invalidUid should throw exception
Assert.Throws <DicomValidationException>(() => ds.Add(DicomTag.StudyInstanceUID, invalidUid));
ds.AutoValidate = false;
// if AutoValidate is turned off, the invalidUid should be able to be added
ds.Add(DicomTag.StudyInstanceUID, invalidUid);
Assert.Equal(invalidUid, ds.GetSingleValue <string>(DicomTag.StudyInstanceUID));
var tmpFile = Path.GetTempFileName();
ds.Add(DicomTag.SOPClassUID, DicomUID.SecondaryCaptureImageStorage);
ds.Add(DicomTag.SOPInstanceUID, DicomUIDGenerator.GenerateDerivedFromUUID().UID);
// save this invalid dicomdataset
(new DicomFile(ds)).Save(tmpFile);
// reading of this invalid dicomdataset should be possible
var dsFile = DicomFile.Open(tmpFile);
Assert.Equal(invalidUid, dsFile.Dataset.GetSingleValue <string>(DicomTag.StudyInstanceUID));
// but the validation should still work
Assert.Throws <DicomValidationException>(() => dsFile.Dataset.Validate());
IOHelper.DeleteIfExists(tmpFile);
}
public void ConvertGuidToUuidInteger_Iso9834Sample()
{
// Sample value of ISO/IEC 9834-8, paragraph 8 and wiki.ihe.net
var sampleValue = new Guid("f81d4fae-7dec-11d0-a765-00a0c91e6bf6");
string actual = DicomUIDGenerator.ConvertGuidToUuidInteger(ref sampleValue);
Assert.Equal("2.25.329800735698586629295641978511506172918", actual);
}
public void ConvertGuidToUuidInteger_RoundTripConversion()
{
var expected = new Guid("11223344-5566-7788-9900-aabbccddeeff");
string converted = DicomUIDGenerator.ConvertGuidToUuidInteger(ref expected);
var actual = ConvertDicomUidToGuid(converted);
Assert.Equal(expected, actual);
}
public void Generate_MultipleInParallel_AllValuesUnique()
{
const int n = 100000;
var uids = new string[n];
Parallel.For(0, n, i => { uids[i] = DicomUIDGenerator.GenerateDerivedFromUUID().UID; });
Assert.Equal(n, uids.Distinct().Count());
}
public void ConvertGuidToUuidInteger_RoundTripConversionEmpty()
{
var expected = new Guid();
string converted = DicomUIDGenerator.ConvertGuidToUuidInteger(ref expected);
var actual = ConvertDicomUidToGuid(converted);
Assert.Equal(expected, actual);
}
public void GenerateDerivedFromUUID_MultipleValues_AllValuesContainOnlyDigitsAndDecimalDots()
{
for (var i = 0; i < 1000; ++i)
{
var uid = DicomUIDGenerator.GenerateDerivedFromUUID();
var invalids = Regex.Replace(uid.UID, @"[0-9\.]", "");
Assert.Equal(0, invalids.Length);
}
}
public void DicomEncoding_AppliedToMultipleNestedDatasetsWithDifferentEncodingsOnWriting()
{
// now the actual unit-test
var encoding1 = Encoding.GetEncoding("SHIFT_JIS");
var encoding2 = Encoding.UTF8;
var tag = DicomTag.AdditionalPatientHistory;
const string expected = "YamadaTarou山田太郎ﾔﾏﾀﾞﾀﾛｳ";
var dataset = new DicomDataset
{
{ DicomTag.SOPClassUID, DicomUID.SecondaryCaptureImageStorage },
{ DicomTag.SOPInstanceUID, DicomUIDGenerator.GenerateDerivedFromUUID() },
{ tag, "SuperDataset" },
{ DicomTag.SpecificCharacterSet, DicomEncoding.GetCharset(encoding1) },
{ DicomTag.ReferencedInstanceSequence,
new DicomDataset
{
{ DicomTag.SpecificCharacterSet, DicomEncoding.GetCharset(encoding2) },
{ tag, expected } // this value is supposed to be encoded in UTF8
},
new DicomDataset
{
{ tag, expected } // this value is supposed to be encoded like the parent dataset in SHIFT_JIS
} }
};
var memStream = new MemoryStream();
new DicomFile(dataset).Save(memStream);
memStream.Position = 0;
var bytesOfStream = memStream.ToArray();
// there should be the name encoded in SHIFT_JIS
var expectedBytes1 = encoding1.GetBytes(expected);
Assert.True(bytesOfStream.ContainsSequence(expectedBytes1));
// there should also be the name encoded in UTF8
var expectedBytes2 = encoding2.GetBytes(expected);
Assert.True(bytesOfStream.ContainsSequence(expectedBytes2));
// but there should never be a fallback to default-encoding
var notexpectedBytes = DicomEncoding.Default.GetBytes(expected);
Assert.False(bytesOfStream.ContainsSequence(notexpectedBytes));
memStream.Position = 0;
var readDataset = DicomFile.Open(memStream);
var readValue1 = readDataset.Dataset.GetSequence(DicomTag.ReferencedInstanceSequence).First().GetSingleValue <string>(tag);
Assert.Equal(expected, readValue1);
var readValue2 = readDataset.Dataset.GetSequence(DicomTag.ReferencedInstanceSequence).Last().GetSingleValue <string>(tag);
Assert.Equal(expected, readValue2);
}
public void Generate_SourceUidKnown_ReturnsMappedDestinationUid()
{
var source = DicomUIDGenerator.GenerateDerivedFromUUID();
var generator = new DicomUIDGenerator();
var expected = generator.Generate(source);
var actual = generator.Generate(source);
Assert.Equal(expected, actual);
}
public async Task Store_ShallThrowIfNoFilesMatchStudyInstanceUid()
{
var studyInstanceUid = DicomUIDGenerator.GenerateDerivedFromUUID();
var instances = _fixture.GenerateDicomFiles(3, studyInstanceUid);
var httpClient = new HttpClient();
var service = new StowService(httpClient, _logger.Object);
var otherStudyInstanceUid = "1.2.3.4.5";
await Assert.ThrowsAsync <ArgumentException>(async() => await service.Store(otherStudyInstanceUid, instances));
}
public void FrameGeometry_CalculateLocalizer_ObliqueIntersecting()
{
var frameofreferenceuid = DicomUIDGenerator.GenerateDerivedFromUUID();
var source = new DicomDataset();
source.AddOrUpdate(DicomTag.ImagePositionPatient, 0.0m, 0.0m, 0.0m);
source.AddOrUpdate(DicomTag.ImageOrientationPatient, 1.0m, 0.0m, 0.0m, 0.0m, 1.0m, 0.0m);
source.AddOrUpdate(DicomTag.PixelSpacing, 0.5m, 0.5m);
source.AddOrUpdate(DicomTag.Rows, (ushort)500);
source.AddOrUpdate(DicomTag.Columns, (ushort)500);
source.AddOrUpdate(DicomTag.FrameOfReferenceUID, frameofreferenceuid);
var destination = new DicomDataset();
destination.AddOrUpdate(DicomTag.ImagePositionPatient, 50.0m, 100.0m, -50.0m);
destination.AddOrUpdate(DicomTag.ImageOrientationPatient, 1.0m, 0.0m, 0.0m, 0.0m, 0.70710678m, 0.70710678m);
destination.AddOrUpdate(DicomTag.PixelSpacing, 0.25m, 0.25m);
destination.AddOrUpdate(DicomTag.Rows, (ushort)600);
destination.AddOrUpdate(DicomTag.Columns, (ushort)600);
destination.AddOrUpdate(DicomTag.FrameOfReferenceUID, frameofreferenceuid);
// CalculateIntersectionLocalizer
var sourcegeometry = new FrameGeometry(source);
var destinationgeometry = new FrameGeometry(destination);
Assert.True(ImageLocalizer.CanDrawLocalizer(sourcegeometry, destinationgeometry));
Assert.False(ImageLocalizer.CanDrawLocalizer(sourcegeometry, sourcegeometry));
var ok = ImageLocalizer.CalcualteIntersectionLocalizer(sourcegeometry, destinationgeometry, out var startPoint, out var endPoint);
Assert.True(ok);
Assert.Equal(new Point2(800, 283), startPoint);
Assert.Equal(new Point2(-200, 283), endPoint);
ok = ImageLocalizer.CalcualteIntersectionLocalizer(destinationgeometry, sourcegeometry, out startPoint, out endPoint);
Assert.True(ok);
Assert.Equal(new Point2(400, 300), startPoint);
Assert.Equal(new Point2(100, 300), endPoint);
// calculateProjectionLocalizer
ImageLocalizer.CalcualteProjectionLocalizer(source, destination, out var points);
Assert.Equal(4, points.Count);
Assert.Equal(new Point2(-200, -141), points[0]);
Assert.Equal(new Point2(796, -141), points[1]);
Assert.Equal(new Point2(796, 563), points[2]);
Assert.Equal(new Point2(-200, 563), points[3]);
ImageLocalizer.CalcualteProjectionLocalizer(destination, source, out points);
Assert.Equal(4, points.Count);
Assert.Equal(new Point2(100, 200), points[0]);
Assert.Equal(new Point2(398, 200), points[1]);
Assert.Equal(new Point2(398, 411), points[2]);
Assert.Equal(new Point2(100, 411), points[3]);
}
