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