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 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>()); }
protected override DicomDataset GetMediaDataset(DicomDataset data, DicomMediaProperties mediaInfo) { if (mediaInfo.MediaType != MediaType) { throw new InvalidOperationException(string.Format("Invalid media type. Supported media type is:{0} and provided media type is:{1}", MediaType, mediaInfo.MediaType)); } if (!string.IsNullOrWhiteSpace(mediaInfo.TransferSyntax) && mediaInfo.TransferSyntax != "*") { var transfer = DicomTransferSyntax.Parse(mediaInfo.TransferSyntax); if (transfer == data.InternalTransferSyntax) { return(data); } var ds = data.Clone(transfer); ds.AddOrUpdate(DicomTag.TransferSyntaxUID, transfer.UID.UID); return(ds); } else { return(base.GetMediaDataset(data, mediaInfo)); } }
public void CanParseUnkownTransferSyntax() { var ts = DicomTransferSyntax.Parse("1.2.3.4.5.6.7.8.9.0"); Assert.Equal(Endian.Little, ts.Endian); Assert.False(ts.IsRetired); Assert.True(ts.IsExplicitVR); Assert.True(ts.IsEncapsulated); Assert.Equal("Unknown", ts.UID.Name); Assert.Equal(DicomUidType.TransferSyntax, ts.UID.Type); Assert.Equal("1.2.3.4.5.6.7.8.9.0", ts.UID.UID); }
public Stream TranscodeFrame(DicomFile dicomFile, int frameIndex, string requestedTransferSyntax) { EnsureArg.IsNotNull(dicomFile, nameof(dicomFile)); EnsureArg.IsNotEmptyOrWhiteSpace(requestedTransferSyntax, nameof(requestedTransferSyntax)); DicomDataset dataset = dicomFile.Dataset; // Validate requested frame index exists in file. dicomFile.GetPixelDataAndValidateFrames(new[] { frameIndex }); var parsedDicomTransferSyntax = DicomTransferSyntax.Parse(requestedTransferSyntax); IByteBuffer resultByteBuffer = TranscodeFrame(dataset, frameIndex, parsedDicomTransferSyntax); return(_recyclableMemoryStreamManager.GetStream("RetrieveDicomResourceHandler.GetFrameAsDicomData", resultByteBuffer.Data, 0, resultByteBuffer.Data.Length)); }
public static void ValidateTransferSyntax(string requestedTransferSyntax, bool originalTransferSyntaxRequested = false) { if (!originalTransferSyntaxRequested && !string.IsNullOrEmpty(requestedTransferSyntax)) { try { DicomTransferSyntax transferSyntax = DicomTransferSyntax.Parse(requestedTransferSyntax); if (transferSyntax?.UID == null || transferSyntax.UID.Name == UnknownDicomTransferSyntaxName) { throw new BadRequestException(DicomCoreResource.InvalidTransferSyntaxValue); } } catch (DicomDataException) { throw new BadRequestException(DicomCoreResource.InvalidTransferSyntaxValue); } } }
private void ParsePreamble(IByteSource source, object state) { try { if (!source.Require(132, ParsePreamble, state)) { return; } _source.Skip(128); if (_source.GetUInt8() != 'D' || _source.GetUInt8() != 'I' || _source.GetUInt8() != 'C' || _source.GetUInt8() != 'M') { throw new DicomReaderException("Invalid preamble found in DICOM file parser"); } DicomReaderCallbackObserver obs = new DicomReaderCallbackObserver(); obs.Add(DicomTag.TransferSyntaxUID, delegate(object sender, DicomReaderEventArgs ea) { try { string uid = Encoding.ASCII.GetString(ea.Data.Data); _syntax = DicomTransferSyntax.Parse(uid); } catch { } }); _source.Endian = _syntax.Endian; _reader.IsExplicitVR = _syntax.IsExplicitVR; _reader.BeginRead(_source, new DicomReaderMultiObserver(obs, _fmiObserver), FileMetaInfoStopTag, OnFileMetaInfoParseComplete, null); } catch (Exception e) { if (_exception == null) { _exception = e; } _result = DicomReaderResult.Error; } finally { if (_result != DicomReaderResult.Processing && _result != DicomReaderResult.Suspended) { _async.Set(); } } }
public async Task <Stream> TranscodeFileAsync(Stream stream, string requestedTransferSyntax) { EnsureArg.IsNotNull(stream, nameof(stream)); EnsureArg.IsNotEmptyOrWhiteSpace(requestedTransferSyntax, nameof(requestedTransferSyntax)); var parsedDicomTransferSyntax = DicomTransferSyntax.Parse(requestedTransferSyntax); DicomFile dicomFile; try { dicomFile = await DicomFile.OpenAsync(stream, FileReadOption.ReadLargeOnDemand); } catch (DicomFileException) { throw; } stream.Seek(0, SeekOrigin.Begin); return(await TranscodeFileAsync(dicomFile, parsedDicomTransferSyntax)); }
private static void UpdateFileFormatAndSyntax( string code, string uid, ref DicomFileFormat fileFormat, ref DicomTransferSyntax syntax) { if (code != null) { if (code == "ACR-NEMA 1.0") { fileFormat = DicomFileFormat.ACRNEMA1; } else if (code == "ACR-NEMA 2.0") { fileFormat = DicomFileFormat.ACRNEMA2; } } if (uid != null) { syntax = DicomTransferSyntax.Parse(uid); } }
private void ValidateOptions(string rootUrl, string transferSyntaxes, out Uri rootUri, out List <DicomTransferSyntax> dicomTransferSyntaxes) { Guard.Against.NullOrWhiteSpace(rootUrl, nameof(rootUrl)); Guard.Against.NullOrWhiteSpace(transferSyntaxes, nameof(transferSyntaxes)); _logger.LogInformation("Checking arguments..."); rootUri = new Uri(rootUrl); rootUri = rootUri.EnsureUriEndsWithSlash(); dicomTransferSyntaxes = new List <DicomTransferSyntax>(); var transferSyntaxArray = transferSyntaxes.Split(','); foreach (var uid in transferSyntaxArray) { var uidData = DicomUID.Parse(uid, type: DicomUidType.TransferSyntax); if (uidData.Name.Equals("Unknown") && uidData.UID != "*") { throw new ArgumentException($"Invalid transfer syntax: {uid}"); } dicomTransferSyntaxes.Add(DicomTransferSyntax.Parse(uidData.UID)); } }
public void ConvertToXml( ) { var testDir = Path.Combine(TestDirPath, "convertToXml"); var xmlConverter = new XmlDicomConverter( ) { WriteInlineBinary = true }; Directory.CreateDirectory(testDir); //DicomDataset sourceDS = Helper.GetDicomDataset ( 10 ).Clone ( DicomTransferSyntax.ExplicitVRLittleEndian ) ; foreach (string file in Directory.GetFiles(DicomHelpers.GetSampleImagesFolder( ))) { string fullPath = Path.Combine(testDir, Path.GetFileName(file)); DicomDataset sourceDS = DicomFile.Open(file).Dataset; var sourceXmlDicom = xmlConverter.Convert(sourceDS); System.IO.File.WriteAllText(fullPath + ".xml", sourceXmlDicom); DicomDataset targetDs = xmlConverter.Convert(sourceXmlDicom); var dsF = new DicomFile(targetDs); dsF.FileMetaInfo.TransferSyntax = DicomTransferSyntax.Parse(targetDs.GetSingleValueOrDefault(DicomTag.TransferSyntaxUID, targetDs.InternalTransferSyntax.ToString( ))); dsF.Save(fullPath + ".gen.dcm"); var destXmlDicom = xmlConverter.Convert(targetDs); System.IO.File.WriteAllText(fullPath + ".gen.xml", destXmlDicom); //private tags with private creator will cause this to fail //VR for OW change to OB Assert.AreEqual(sourceXmlDicom, destXmlDicom); } }
public static DicomFile GenerateDicomFile( string studyInstanceUid, string seriesInstanceUid, string sopInstanceUid, string sopClassUid, int rows, int cols, TestFileBitDepth bitDepth, string transferSyntax, bool encode, int frames = 1, string photometricInterpretation = null) { DicomTransferSyntax initialTs = DicomTransferSyntax.ExplicitVRLittleEndian; if (!encode) { initialTs = DicomTransferSyntax.Parse(transferSyntax); } var rand = new Random(); var dicomFile = new DicomFile( new DicomDataset(initialTs) { { DicomTag.StudyInstanceUID, studyInstanceUid ?? TestUidGenerator.Generate() }, { DicomTag.SeriesInstanceUID, seriesInstanceUid ?? TestUidGenerator.Generate() }, { DicomTag.SOPInstanceUID, sopInstanceUid ?? TestUidGenerator.Generate() }, { DicomTag.SOPClassUID, sopClassUid ?? TestUidGenerator.Generate() }, { DicomTag.Rows, (ushort)rows }, { DicomTag.Columns, (ushort)cols }, { DicomTag.PhotometricInterpretation, photometricInterpretation ?? PhotometricInterpretation.Monochrome2.Value }, { DicomTag.BitsAllocated, (ushort)bitDepth }, { DicomTag.WindowWidth, ((bitDepth == TestFileBitDepth.EightBit) ? "256" : "65536") }, { DicomTag.WindowCenter, ((bitDepth == TestFileBitDepth.EightBit) ? "128" : "32768") }, { DicomTag.AccessionNumber, rand.Next(11111111, 19999999) }, { DicomTag.PatientID, TestUidGenerator.Generate() }, }); var pixelData = DicomPixelData.Create(dicomFile.Dataset, true); pixelData.SamplesPerPixel = 1; pixelData.BitsStored = (ushort)bitDepth; pixelData.HighBit = (ushort)(bitDepth - 1); pixelData.PixelRepresentation = PixelRepresentation.Unsigned; for (int i = 0; i < frames; i++) { var buffer = new MemoryByteBuffer( (bitDepth == TestFileBitDepth.SixteenBit) ? GetBytesFor16BitImage(rows, cols, i) : GetBytesFor8BitImage(rows, cols, i)); pixelData.AddFrame(buffer); } if (encode && transferSyntax != DicomTransferSyntax.ExplicitVRLittleEndian.UID.UID) { var transcoder = new DicomTranscoder( dicomFile.Dataset.InternalTransferSyntax, DicomTransferSyntax.Parse(transferSyntax)); dicomFile = transcoder.Transcode(dicomFile); } return(dicomFile); }
Task IDicomServiceProvider.OnReceiveAssociationRequestAsync(DicomAssociation association) { //var taskInfo = $"task: connection: {((DICOMConnection)(base.UserState)).name}"; var fromConnection = _connectionFinder.GetDicomConnectionToLocalAETitle(_profileStorage.Current, association.CalledAE); if (fromConnection == null) { //We have an inbound Association.CalledAE that we aren't configured for logger.Log(LogLevel.Warning, $"There is no connection defined where the LocalAETitle matches the Association.CalledAE: {Association.CalledAE}"); return(SendAssociationRejectAsync(DicomRejectResult.Permanent, DicomRejectSource.ServiceUser, DicomRejectReason.CalledAENotRecognized)); } //load possible and accepted transfer syntaxes into profile if not populated bool add = false; if (((DICOMConnection)(base.UserState)).AcceptedImageTransferSyntaxUIDs == null) { ((DICOMConnection)(base.UserState)).AcceptedImageTransferSyntaxUIDs = new List <string>(); } if (((DICOMConnection)(base.UserState)).PossibleImageTransferSyntaxUIDs == null) { ((DICOMConnection)(base.UserState)).PossibleImageTransferSyntaxUIDs = new List <string>(); } if (((DICOMConnection)(base.UserState)).AcceptedImageTransferSyntaxUIDs.Count == 0) { add = true; } ((DICOMConnection)(base.UserState)).PossibleImageTransferSyntaxUIDs.Clear(); foreach (var dicomTransferSyntax in AcceptedImageTransferSyntaxes) { logger.Log(LogLevel.Information, $"Possible AcceptedImageTransferSyntaxes UID:{dicomTransferSyntax.UID} Endian:{dicomTransferSyntax.Endian} IsDeflate:{dicomTransferSyntax.IsDeflate} IsEncapsulated:{dicomTransferSyntax.IsEncapsulated} IsExplicitVR:{dicomTransferSyntax.IsExplicitVR} IsLossy:{dicomTransferSyntax.IsLossy} IsRetired:{dicomTransferSyntax.IsRetired} LossyCompressionMethod:{dicomTransferSyntax.LossyCompressionMethod} SwapPixelData:{dicomTransferSyntax.SwapPixelData}"); if (!((DICOMConnection)(base.UserState)).AcceptedImageTransferSyntaxUIDs.Exists(e => e.Equals(dicomTransferSyntax.UID.ToString()))) { if (add == true) { ((DICOMConnection)(base.UserState)).AcceptedImageTransferSyntaxUIDs.Add(dicomTransferSyntax.UID .ToString()); } else { logger.Log(LogLevel.Warning, $"Not configured in DICOMConnection.AcceptedImageTransferSyntaxUIDs!! UID:{dicomTransferSyntax.UID}"); } } ((DICOMConnection)(base.UserState)).PossibleImageTransferSyntaxUIDs.Add(dicomTransferSyntax.UID .ToString()); } //load AcceptedImageTransferSyntaxes from profile now we are populated one way or another var newAcceptedImageTransferSyntaxes = new List <DicomTransferSyntax>(); string uidnumber = ""; foreach (var item in ((DICOMConnection)(base.UserState)).AcceptedImageTransferSyntaxUIDs) { try { uidnumber = item.Substring(item.LastIndexOf("[") + 1).TrimEnd(']'); //,item.IndexOf("]")-1 var transfersyntax = DicomTransferSyntax.Parse(uidnumber); newAcceptedImageTransferSyntaxes.Add(transfersyntax); } catch (Exception) { logger.Log(LogLevel.Critical, $"Unable to parse DICOMConnection.AcceptedImageTransferSyntaxUID: {uidnumber}"); } } AcceptedImageTransferSyntaxes = newAcceptedImageTransferSyntaxes.ToArray(); foreach (var pc in association.PresentationContexts) { if (pc.AbstractSyntax == DicomUID.Verification) { pc.AcceptTransferSyntaxes(AcceptedTransferSyntaxes); } else if (pc.AbstractSyntax.StorageCategory != DicomStorageCategory.None) { if (((DICOMConnection)(base.UserState)).AcceptedImageTransferSyntaxUIDs == null || ((DICOMConnection)(base.UserState)).AcceptedImageTransferSyntaxUIDs.Count == 0) { } pc.AcceptTransferSyntaxes(AcceptedImageTransferSyntaxes); } } return(SendAssociationAcceptAsync(association)); }
private void ReadElement ( DicomDataset ds, XElement element, DicomTag tag, DicomVR dicomVr, int level ) { if (dicomVr == DicomVR.PN) { string personNameValue = ""; foreach (var personNameElementValue in element.Elements( ).OrderBy(n => n.Attribute(Constants.ATTRIBUTE_NUMBER))) { foreach (var personNameComponent in personNameElementValue.Elements( )) { if (personNameComponent.Name == Utilities.PersonNameComponents.PN_COMP_ALPHABETIC || personNameComponent.Name == Utilities.PersonNameComponents.PN_COMP_IDEOGRAPHIC || personNameComponent.Name == Utilities.PersonNameComponents.PN_COMP_PHONETIC) { personNameValue = UpdatePersonName(personNameValue, personNameComponent, Utilities.PersonNameParts.PN_Family); personNameValue = UpdatePersonName(personNameValue, personNameComponent, Utilities.PersonNameParts.PN_Given); personNameValue = UpdatePersonName(personNameValue, personNameComponent, Utilities.PersonNameParts.PN_Midlle); personNameValue = UpdatePersonName(personNameValue, personNameComponent, Utilities.PersonNameParts.PN_Prefix); personNameValue = UpdatePersonName(personNameValue, personNameComponent, Utilities.PersonNameParts.PN_Suffix, true); personNameValue = personNameValue.TrimEnd('^'); // extra cleanup personNameValue += "="; } } personNameValue = personNameValue.TrimEnd('='); personNameValue += "\\"; } personNameValue = personNameValue.TrimEnd('\\'); ds.AddOrUpdate <string> (dicomVr, tag, personNameValue); } else if (Utilities.IsBinaryVR(dicomVr)) { var dataElement = element.Elements( ).OfType <XElement> ( ).FirstOrDefault( ); if (null != dataElement) { Dicom.IO.Buffer.IByteBuffer data; if (dataElement.Name == Constants.ELEMENT_BULKDATA) { string uri = dataElement.Attribute(Constants.ATTRIBUTE_BULKDATAURI).Value; data = new Dicom.IO.Buffer.BulkDataUriByteBuffer(uri); } else { var base64 = System.Convert.FromBase64String(dataElement.Value); data = new Dicom.IO.Buffer.MemoryByteBuffer(base64); } if (tag == DicomTag.PixelData && level == 0) { var pixelData = DicomPixelData.Create(ds, true); //2nd parameter is true since we are adding new data here pixelData.AddFrame(data); } else { ds.AddOrUpdate <Dicom.IO.Buffer.IByteBuffer> (dicomVr, tag, data); } } } else { var values = ReadValue(element); if (tag == DicomTag.TransferSyntaxUID) { TransferSyntax = DicomTransferSyntax.Parse(values.FirstOrDefault( )); } ds.AddOrUpdate <string> (dicomVr, tag, values.ToArray( )); } }
private void ParsePreamble(IByteSource source, object state) { try { if (!source.Require(132, ParsePreamble, state)) { return; } // mark file origin _source.Mark(); // test for DICM preamble _source.Skip(128); if (_source.GetUInt8() == 'D' && _source.GetUInt8() == 'I' && _source.GetUInt8() == 'C' && _source.GetUInt8() == 'M') { _fileFormat = DicomFileFormat.DICOM3; } // test for incorrect syntax in file meta info do { if (_fileFormat == DicomFileFormat.DICOM3) { // move milestone to after preamble _source.Mark(); } else { // rewind to origin milestone _source.Rewind(); } // test for file meta info var group = _source.GetUInt16(); if (group > 0x00ff) { _source.Endian = Endian.Big; _syntax = DicomTransferSyntax.ExplicitVRBigEndian; group = Endian.Swap(group); } if (group > 0x00ff) { // invalid starting tag _fileFormat = DicomFileFormat.Unknown; _source.Rewind(); break; } if (_fileFormat == DicomFileFormat.Unknown) { if (group == 0x0002) { _fileFormat = DicomFileFormat.DICOM3NoPreamble; } else { _fileFormat = DicomFileFormat.DICOM3NoFileMetaInfo; } } var element = _source.GetUInt16(); var tag = new DicomTag(group, element); // test for explicit VR var vrt = Encoding.ASCII.GetBytes(tag.DictionaryEntry.ValueRepresentations[0].Code); var vrs = _source.GetBytes(2); if (vrt[0] != vrs[0] || vrt[1] != vrs[1]) { // implicit VR if (_syntax.Endian == Endian.Little) { _syntax = DicomTransferSyntax.ImplicitVRLittleEndian; } else { _syntax = DicomTransferSyntax.ImplicitVRBigEndian; } } _source.Rewind(); } while (_fileFormat == DicomFileFormat.Unknown); if (_fileFormat == DicomFileFormat.Unknown) { throw new DicomReaderException("Attempted to read invalid DICOM file"); } var obs = new DicomReaderCallbackObserver(); if (_fileFormat != DicomFileFormat.DICOM3) { obs.Add(DicomTag.RecognitionCodeRETIRED, (object sender, DicomReaderEventArgs ea) => { try { string code = Encoding.ASCII.GetString(ea.Data.Data); if (code == "ACR-NEMA 1.0") { _fileFormat = DicomFileFormat.ACRNEMA1; } else if (code == "ACR-NEMA 2.0") { _fileFormat = DicomFileFormat.ACRNEMA2; } } catch { } }); } obs.Add(DicomTag.TransferSyntaxUID, (object sender, DicomReaderEventArgs ea) => { try { string uid = Encoding.ASCII.GetString(ea.Data.Data); _syntax = DicomTransferSyntax.Parse(uid); } catch { } }); _source.Endian = _syntax.Endian; _reader.IsExplicitVR = _syntax.IsExplicitVR; if (_fileFormat == DicomFileFormat.DICOM3NoFileMetaInfo) { _reader.BeginRead(_source, new DicomReaderMultiObserver(obs, _dataObserver), null, OnDatasetParseComplete, null); } else { _reader.BeginRead(_source, new DicomReaderMultiObserver(obs, _fmiObserver), FileMetaInfoStopTag, OnFileMetaInfoParseComplete, null); } } catch (Exception e) { if (_exception == null) { _exception = e; } _result = DicomReaderResult.Error; } finally { if (_result != DicomReaderResult.Processing && _result != DicomReaderResult.Suspended) { _async.Set(); } } }
/// <summary> /// Reads A-ASSOCIATE-RQ from PDU buffer /// </summary> /// <param name="raw">PDU buffer</param> public void Read(RawPDU raw) { uint l = raw.Length - 6; raw.ReadUInt16("Version"); raw.SkipBytes("Reserved", 2); _assoc.CalledAE = raw.ReadString("Called AE", 16); _assoc.CallingAE = raw.ReadString("Calling AE", 16); raw.SkipBytes("Reserved", 32); l -= 2 + 2 + 16 + 16 + 32; while (l > 0) { byte type = raw.ReadByte("Item-Type"); raw.SkipBytes("Reserved", 1); ushort il = raw.ReadUInt16("Item-Length"); l -= 4 + (uint)il; if (type == 0x10) { // Application Context raw.SkipBytes("Application Context", il); } else if (type == 0x20) { // Presentation Context byte id = raw.ReadByte("Presentation Context ID"); raw.SkipBytes("Reserved", 3); il -= 4; while (il > 0) { byte pt = raw.ReadByte("Presentation Context Item-Type"); raw.SkipBytes("Reserved", 1); ushort pl = raw.ReadUInt16("Presentation Context Item-Length"); string sx = raw.ReadString("Presentation Context Syntax UID", pl); if (pt == 0x30) { var pc = new DicomPresentationContext(id, DicomUID.Parse(sx)); _assoc.PresentationContexts.Add(pc); } else if (pt == 0x40) { var pc = _assoc.PresentationContexts[id]; pc.AddTransferSyntax(DicomTransferSyntax.Parse(sx)); } il -= (ushort)(4 + pl); } } else if (type == 0x50) { // User Information while (il > 0) { byte ut = raw.ReadByte("User Information Item-Type"); raw.SkipBytes("Reserved", 1); ushort ul = raw.ReadUInt16("User Information Item-Length"); il -= (ushort)(4 + ul); if (ut == 0x51) { _assoc.MaximumPDULength = raw.ReadUInt32("Max PDU Length"); } else if (ut == 0x52) { _assoc.RemoteImplemetationClassUID = new DicomUID(raw.ReadString("Implementation Class UID", ul), "Implementation Class UID", DicomUidType.Unknown); } else if (ut == 0x55) { _assoc.RemoteImplementationVersion = raw.ReadString("Implementation Version", ul); } else if (ut == 0x53) { _assoc.MaxAsyncOpsInvoked = raw.ReadUInt16("Asynchronous Operations Invoked"); _assoc.MaxAsyncOpsPerformed = raw.ReadUInt16("Asynchronous Operations Performed"); } else if (ut == 0x54) { raw.SkipBytes("SCU/SCP Role Selection", ul); /* * ushort rsul = raw.ReadUInt16(); * if ((rsul + 4) != ul) { * throw new DicomNetworkException("SCU/SCP role selection length (" + ul + " bytes) does not match uid length (" + rsul + " + 4 bytes)"); * } * raw.ReadChars(rsul); // Abstract Syntax * raw.ReadByte(); // SCU role * raw.ReadByte(); // SCP role */ } else { //Debug.Log.Error("Unhandled user item: 0x{0:x2} ({1} + 4 bytes)", ut, ul); raw.SkipBytes("Unhandled User Item", ul); } } } } }
public async Task <IReadOnlyCollection <Stream> > GetFramesResourceAsync(Stream stream, IEnumerable <int> frames, bool originalTransferSyntaxRequested, string requestedRepresentation) { EnsureArg.IsNotNull(stream, nameof(stream)); EnsureArg.IsNotNull(frames, nameof(frames)); DicomFile dicomFile = await DicomFile.OpenAsync(stream); // Validate requested frame index exists in file and retrieve the pixel data associated with the file. DicomPixelData pixelData = dicomFile.GetPixelDataAndValidateFrames(frames); if (!originalTransferSyntaxRequested && !dicomFile.Dataset.InternalTransferSyntax.Equals(DicomTransferSyntax.Parse(requestedRepresentation))) { return(frames.Select(frame => new LazyTransformReadOnlyStream <DicomFile>( dicomFile, df => _transcoder.TranscodeFrame(df, frame, requestedRepresentation))) .ToArray()); } else { return(frames.Select( frame => new LazyTransformReadOnlyStream <DicomFile>( dicomFile, df => GetFrameAsDicomData(pixelData, frame))) .ToArray()); } }
/// <summary> /// Reads A-ASSOCIATE-AC from PDU buffer /// </summary> /// <param name="raw">PDU buffer</param> public void Read(RawPDU raw) { // reset async ops in case remote end does not negotiate _assoc.MaxAsyncOpsInvoked = 1; _assoc.MaxAsyncOpsPerformed = 1; uint l = raw.Length - 6; ushort c = 0; raw.ReadUInt16("Version"); raw.SkipBytes("Reserved", 2); raw.SkipBytes("Reserved", 16); raw.SkipBytes("Reserved", 16); raw.SkipBytes("Reserved", 32); l -= 68; while (l > 0) { byte type = raw.ReadByte("Item-Type"); l -= 1; if (type == 0x10) { // Application Context raw.SkipBytes("Reserved", 1); c = raw.ReadUInt16("Item-Length"); raw.SkipBytes("Value", (int)c); l -= 3 + (uint)c; } else if (type == 0x21) { // Presentation Context raw.ReadByte("Reserved"); ushort pl = raw.ReadUInt16("Presentation Context Item-Length"); byte id = raw.ReadByte("Presentation Context ID"); raw.ReadByte("Reserved"); byte res = raw.ReadByte("Presentation Context Result/Reason"); raw.ReadByte("Reserved"); l -= (uint)pl + 3; pl -= 4; // Presentation Context Transfer Syntax raw.ReadByte("Presentation Context Item-Type (0x40)"); raw.ReadByte("Reserved"); ushort tl = raw.ReadUInt16("Presentation Context Item-Length"); string tx = raw.ReadString("Presentation Context Syntax UID", tl); pl -= (ushort)(tl + 4); _assoc.PresentationContexts[id].SetResult((DicomPresentationContextResult)res, DicomTransferSyntax.Parse(tx)); } else if (type == 0x50) { // User Information raw.ReadByte("Reserved"); ushort il = raw.ReadUInt16("User Information Item-Length"); l -= (uint)(il + 3); while (il > 0) { byte ut = raw.ReadByte("User Item-Type"); raw.ReadByte("Reserved"); ushort ul = raw.ReadUInt16("User Item-Length"); il -= (ushort)(ul + 4); if (ut == 0x51) { _assoc.MaximumPDULength = raw.ReadUInt32("Max PDU Length"); } else if (ut == 0x52) { _assoc.RemoteImplemetationClassUID = DicomUID.Parse(raw.ReadString("Implementation Class UID", ul)); } else if (ut == 0x53) { _assoc.MaxAsyncOpsInvoked = raw.ReadUInt16("Asynchronous Operations Invoked"); _assoc.MaxAsyncOpsPerformed = raw.ReadUInt16("Asynchronous Operations Performed"); } else if (ut == 0x55) { _assoc.RemoteImplementationVersion = raw.ReadString("Implementation Version", ul); } else { raw.SkipBytes("User Item Value", (int)ul); } } } else { raw.SkipBytes("Reserved", 1); ushort il = raw.ReadUInt16("User Item-Length"); raw.SkipBytes("Unknown User Item", il); l -= (uint)(il + 3); } } }
/// <summary> /// Reads A-ASSOCIATE-RQ from PDU buffer /// </summary> /// <param name="raw">PDU buffer</param> public void Read(RawPDU raw) { var l = raw.Length - 6; raw.ReadUInt16("Version"); raw.SkipBytes("Reserved", 2); _assoc.CalledAE = raw.ReadString("Called AE", 16); _assoc.CallingAE = raw.ReadString("Calling AE", 16); raw.SkipBytes("Reserved", 32); l -= 2 + 2 + 16 + 16 + 32; while (l > 0) { var type = raw.ReadByte("Item-Type"); raw.SkipBytes("Reserved", 1); var il = raw.ReadUInt16("Item-Length"); l -= 4 + (uint)il; if (type == 0x10) { // Application Context raw.SkipBytes("Application Context", il); } else if (type == 0x20) { // Presentation Context var id = raw.ReadByte("Presentation Context ID"); raw.SkipBytes("Reserved", 3); il -= 4; while (il > 0) { var pt = raw.ReadByte("Presentation Context Item-Type"); raw.SkipBytes("Reserved", 1); var pl = raw.ReadUInt16("Presentation Context Item-Length"); var sx = raw.ReadString("Presentation Context Syntax UID", pl); if (pt == 0x30) { var pc = new DicomPresentationContext(id, DicomUID.Parse(sx)); _assoc.PresentationContexts.Add(pc); } else if (pt == 0x40) { var pc = _assoc.PresentationContexts[id]; pc.AddTransferSyntax(DicomTransferSyntax.Parse(sx)); } il -= (ushort)(4 + pl); } } else if (type == 0x50) { // User Information while (il > 0) { var ut = raw.ReadByte("User Information Item-Type"); raw.SkipBytes("Reserved", 1); var ul = raw.ReadUInt16("User Information Item-Length"); il -= (ushort)(4 + ul); if (ut == 0x51) { _assoc.MaximumPDULength = raw.ReadUInt32("Max PDU Length"); } else if (ut == 0x52) { _assoc.RemoteImplementationClassUID = new DicomUID( raw.ReadString("Implementation Class UID", ul), "Implementation Class UID", DicomUidType.Unknown); } else if (ut == 0x55) { _assoc.RemoteImplementationVersion = raw.ReadString("Implementation Version", ul); } else if (ut == 0x53) { _assoc.MaxAsyncOpsInvoked = raw.ReadUInt16("Asynchronous Operations Invoked"); _assoc.MaxAsyncOpsPerformed = raw.ReadUInt16("Asynchronous Operations Performed"); } else if (ut == 0x54) { var asul = raw.ReadUInt16("Abstract Syntax Item-Length"); var syntax = raw.ReadString("Abstract Syntax UID", asul); var userRole = raw.ReadByte("SCU role"); var providerRole = raw.ReadByte("SCP role"); var pc = _assoc.PresentationContexts.FirstOrDefault( context => context.AbstractSyntax.UID.Equals(syntax)); if (pc != null) { pc.UserRole = userRole == 0x01; pc.ProviderRole = providerRole == 0x01; } } else if (ut == 0x56) { _assoc.ExtendedNegotiations.Add(DicomExtendedNegotiation.Create(raw, ul)); } else { #if !NET35 if (HandlePDUBytes != null) { HandlePDUBytes(raw.ReadBytes("Unhandled User Item", ul)); } else { raw.SkipBytes("Unhandled User Item", ul); } #else raw.SkipBytes("Unhandled User Item", ul); #endif } } } } }
/// <summary> /// Reads A-ASSOCIATE-AC from PDU buffer /// </summary> /// <param name="raw">PDU buffer</param> public void Read(RawPDU raw) { // reset async ops in case remote end does not negotiate _assoc.MaxAsyncOpsInvoked = 1; _assoc.MaxAsyncOpsPerformed = 1; var l = raw.Length - 6; raw.ReadUInt16("Version"); raw.SkipBytes("Reserved", 2); raw.SkipBytes("Reserved", 16); raw.SkipBytes("Reserved", 16); raw.SkipBytes("Reserved", 32); l -= 68; while (l > 0) { var type = raw.ReadByte("Item-Type"); l -= 1; if (type == 0x10) { // Application Context raw.SkipBytes("Reserved", 1); var c = raw.ReadUInt16("Item-Length"); raw.SkipBytes("Value", c); l -= 3 + (uint)c; } else if (type == 0x21) { // Presentation Context raw.ReadByte("Reserved"); var pl = raw.ReadUInt16("Presentation Context Item-Length"); var id = raw.ReadByte("Presentation Context ID"); raw.ReadByte("Reserved"); var res = raw.ReadByte("Presentation Context Result/Reason"); raw.ReadByte("Reserved"); l -= (uint)pl + 3; pl -= 4; if ((DicomPresentationContextResult)res == DicomPresentationContextResult.Accept) { // Presentation Context Transfer Syntax raw.ReadByte("Presentation Context Item-Type (0x40)"); raw.ReadByte("Reserved"); var tl = raw.ReadUInt16("Presentation Context Item-Length"); var tx = raw.ReadString("Presentation Context Syntax UID", tl); pl -= (ushort)(tl + 4); _assoc.PresentationContexts[id].SetResult( (DicomPresentationContextResult)res, DicomTransferSyntax.Parse(tx)); } else { raw.SkipBytes("Rejected Presentation Context", pl); _assoc.PresentationContexts[id].SetResult((DicomPresentationContextResult)res); } } else if (type == 0x50) { // User Information raw.ReadByte("Reserved"); var il = raw.ReadUInt16("User Information Item-Length"); l -= (uint)(il + 3); while (il > 0) { var ut = raw.ReadByte("User Item-Type"); raw.ReadByte("Reserved"); var ul = raw.ReadUInt16("User Item-Length"); il -= (ushort)(ul + 4); if (ut == 0x51) { _assoc.MaximumPDULength = raw.ReadUInt32("Max PDU Length"); } else if (ut == 0x52) { _assoc.RemoteImplementationClassUID = DicomUID.Parse(raw.ReadString("Implementation Class UID", ul)); } else if (ut == 0x53) { _assoc.MaxAsyncOpsInvoked = raw.ReadUInt16("Asynchronous Operations Invoked"); _assoc.MaxAsyncOpsPerformed = raw.ReadUInt16("Asynchronous Operations Performed"); } else if (ut == 0x54) { var asul = raw.ReadUInt16("Abstract Syntax Item-Length"); var syntax = raw.ReadString("Abstract Syntax UID", asul); var userRole = raw.ReadByte("SCU role"); var providerRole = raw.ReadByte("SCP role"); var pc = _assoc.PresentationContexts.FirstOrDefault( context => context.AbstractSyntax.UID.Equals(syntax)); if (pc != null) { pc.UserRole = userRole == 0x01; pc.ProviderRole = providerRole == 0x01; } } else if (ut == 0x55) { _assoc.RemoteImplementationVersion = raw.ReadString("Implementation Version", ul); } else if (ut == 0x56) { _assoc.ExtendedNegotiations.Add(DicomExtendedNegotiation.Create(raw, ul)); } else { raw.SkipBytes("User Item Value", ul); } } } else { raw.SkipBytes("Reserved", 1); var il = raw.ReadUInt16("User Item-Length"); raw.SkipBytes("Unknown User Item", il); l -= (uint)(il + 3); } } }
public void CanParseKnownTransferSyntax() { var ts = DicomTransferSyntax.Parse("1.2.840.10008.1.2"); Assert.Same(DicomTransferSyntax.ImplicitVRLittleEndian, ts); }