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]); }