public void Apply(DcmAssociate associate)
{
foreach (DcmPresContext pc in associate.GetPresentationContexts())
{
if (pc.Result == DcmPresContextResult.Proposed)
{
if (AbstractSyntaxes.Contains(pc.AbstractSyntax.UID))
{
IList <DicomTransferSyntax> txs = pc.GetTransfers();
for (int i = 0; i < txs.Count; i++)
{
if (TransferSyntaxes.Contains(txs[i].UID.UID))
{
if (!DicomUID.IsImageStorage(pc.AbstractSyntax) && DicomTransferSyntax.IsImageCompression(txs[i]))
{
continue;
}
pc.SetResult(DcmPresContextResult.Accept, txs[i]);
break;
}
}
if (pc.Result != DcmPresContextResult.Accept)
{
pc.SetResult(DcmPresContextResult.RejectTransferSyntaxesNotSupported);
}
}
else
{
pc.SetResult(DcmPresContextResult.RejectAbstractSyntaxNotSupported);
}
}
}
}
private void _sendImage(PSImage image, Stream outputStream, BinaryWriter writer)
{
var transferSyntax = TransferSyntaxes.Lookup(image.TransferSyntaxID);
if (transferSyntax.Compression != DICOMSharp.Data.Compression.CompressionInfo.None)
{
// Need to decompress
var data = new DICOMData();
data.ParseFile(PSUtils.GetParsedFilePath(image.Path), true, PSUtils.GetLogger());
data.Uncompress();
var memStream = new MemoryStream();
data.WriteToStreamAsPart10File(memStream, PSUtils.GetLogger());
writer.Write((UInt32)(memStream.Length + 4));
memStream.Position = 0;
memStream.CopyTo(outputStream);
}
else
{
// Write the file out directly.
var fileInfo = new FileInfo(PSUtils.GetParsedFilePath(image.Path));
var size = fileInfo.Length;
writer.Write((UInt32)(size + 4));
fileInfo.OpenRead().CopyTo(outputStream);
}
}
/// <summary>
/// Class constructor.
/// </summary>
public HliScp()
{
// set up the default transfer syntax support
_transferSyntaxes = new TransferSyntaxes(IMPLICIT_VR_LITTLE_ENDIAN,
EXPLICIT_VR_LITTLE_ENDIAN,
EXPLICIT_VR_BIG_ENDIAN);
// set up the default sop class support
_sopClasses = new SopClasses(VERIFICATION_SOP_CLASS_UID);
}
/// <summary>
/// Add a single transfer syntax to the list.
/// </summary>
/// <param name="transferSyntax">Transfer Syntax UID.</param>
public void AddTransferSyntax(System.String transferSyntax)
{
// first check if the class has been instantiated
if (_transferSyntaxes == null)
{
_transferSyntaxes = new TransferSyntaxes();
}
// Add the transfer syntax
_transferSyntaxes.Add(transferSyntax);
}
private TaskInfo SendStudy(string studyInstanceUid, string aeTarget)
{
var taskInfo = new TaskInfo()
{
Token = new CancellationTokenSource()
};
taskInfo.Task = Task.Run(() =>
{
taskInfo.Token.Token.ThrowIfCancellationRequested();
this._logger.Log(LogLevel.Info, "Sending study to " + aeTarget + ": " + studyInstanceUid);
var remoteAe = this._db.GetEntity(aeTarget);
if (remoteAe == null)
{
this._logger.Log(LogLevel.Error, "Unknown send target AE: " + aeTarget);
return;
}
var images = this._db.FetchStudyImages(studyInstanceUid);
taskInfo.ProgressCount = 0;
taskInfo.ProgressTotal = images.Count;
TaskCompletionSource <bool> source = new TaskCompletionSource <bool>();
var sender = new DICOMSender(this._logger, aeTarget + "/" + studyInstanceUid, this._settings.VerboseLogging);
sender.SCUFinished += (DICOMSCU scu, bool success) =>
{
source.SetResult(success);
};
sender.SendUpdate += (DICOMSender senderx, ushort remaining, ushort completed, ushort warned, ushort failed) =>
{
taskInfo.ProgressCount = completed + warned + failed;
};
sender.Send(this.GetHostingAE(), remoteAe, images.Select(image => new SendableImage
{
FilePath = _db.FixImagePath(image.Path),
AbstractSyntax = AbstractSyntaxes.Lookup(image.SOPClassID),
TransferSyntax = TransferSyntaxes.Lookup(image.TransferSyntaxID)
}));
source.Task.Wait();
this._logger.Log(LogLevel.Info, "Done sending study to " + aeTarget + ": " + studyInstanceUid);
}, taskInfo.Token.Token);
return(taskInfo);
}
/// <summary>
/// Class constructor.
/// </summary>
/// <param name="parentActor">Parent Actor Name - (containing actor).</param>
/// <param name="actorName">Destination Actor Name.</param>
/// <param name="storageCommitmentScu">Boolean indicating if this is a Storage Commitment SCU or not.</param>
public DicomClient(BaseActor parentActor, ActorName actorName, bool storageCommitmentScu) : base(parentActor, actorName)
{
if (storageCommitmentScu == true)
{
_scu = new DicomStorageCommitmentScu(this);
}
else
{
_scu = new DicomScu(this);
}
// set up the default transfer syntaxes proposed
_transferSyntaxes = new TransferSyntaxes(HliScp.IMPLICIT_VR_LITTLE_ENDIAN,
HliScp.EXPLICIT_VR_LITTLE_ENDIAN,
HliScp.EXPLICIT_VR_BIG_ENDIAN);
}
private System.String[] MergeTransferSyntaxes(System.String[] inTransferSyntaxes)
{
// save all the input transfer syntaxes
TransferSyntaxes localTransferSyntaxes = new TransferSyntaxes();
for (int i = 0; i < inTransferSyntaxes.Length; i++)
{
localTransferSyntaxes.Add(inTransferSyntaxes[i]);
}
// add any from the proposed client transfer syntaxes that are not in the input list
if (_transferSyntaxes != null)
{
for (int i = 0; i < _transferSyntaxes.Length(); i++)
{
bool found = false;
for (int j = 0; j < inTransferSyntaxes.Length; j++)
{
if (_transferSyntaxes.Get(i) == inTransferSyntaxes[j])
{
found = true;
break;
}
}
if (found == false)
{
localTransferSyntaxes.Add(_transferSyntaxes.Get(i));
}
}
}
// copy them to the merged list
System.String[] mergedTransferSyntaxes = new System.String[localTransferSyntaxes.Length()];
for (int i = 0; i < localTransferSyntaxes.Length(); i++)
{
mergedTransferSyntaxes[i] = localTransferSyntaxes.Get(i);
}
return(mergedTransferSyntaxes);
}
internal void ParsePacket(SwappableBinaryReader dataSource, int itemLength)
{
long startOffset = dataSource.BaseStream.Position;
ContextID = dataSource.ReadByte();
byte reserved = dataSource.ReadByte();
Result = (PresentationResult)dataSource.ReadByte();
reserved = dataSource.ReadByte();
while (dataSource.BaseStream.Position - startOffset < itemLength)
{
//read sub-item
byte subItemType = dataSource.ReadByte();
byte subItemReserved = dataSource.ReadByte();
ushort subItemLength = dataSource.ReadUInt16();
if (subItemType == 0x30)
{
string rawSyntax = Uid.UidRawToString(dataSource.ReadBytes(subItemLength));
AbstractSyntaxSpecified = AbstractSyntaxes.Lookup(rawSyntax);
}
else if (subItemType == 0x40)
{
string rawSyntax = Uid.UidRawToString(dataSource.ReadBytes(subItemLength));
TransferSyntax syntax = TransferSyntaxes.Lookup(rawSyntax);
if (syntax != null)
{
TransferSyntaxesProposed.Add(syntax);
}
}
else
{
//no idea what it is, or we don't care
dataSource.ReadBytes(itemLength);
}
}
}
internal bool ParseStream(Stream stream, TransferSyntax transferSyntax, bool allowSyntaxChanges, bool loadImageData, ILogger logger)
{
SwappableBinaryReader sr = new SwappableBinaryReader(stream);
long readPosition = stream.Position;
bool inGroup2 = false;
if (transferSyntax.MSBSwap) //this should be applicable...
{
sr.ToggleSwapped();
}
TransferSyntax parsedSyntax = null;
while (readPosition + 8 < stream.Length)
{
//Read in group/element info
ushort group = sr.ReadUInt16();
ushort elem = sr.ReadUInt16();
//Leaving the header?
if (inGroup2 != (group == 2))
{
if (transferSyntax.MSBSwap)
{
sr.ToggleSwapped();
}
inGroup2 = (group == 2);
}
//Stop loading if we're at image data and not supposed to read it
var skipData = !loadImageData && group == 0x7FE0 && elem == 0x0010;
//Make element
uint outLen;
DICOMElement nelem;
try
{
nelem = DICOMElement.Parse(group, elem, logger, transferSyntax, sr, null, skipData, out outLen);
}
catch (Exception e)
{
logger.Log(LogLevel.Error, "Exception in DICOMElement.Parse: " + e.ToString());
return(false);
}
//Debugging:
//Console.WriteLine(nelem.Dump());
//Store reading position in case it's useful later
nelem.ReadPosition = readPosition;
//Store element in lookup array
Elements[nelem.Tag] = nelem;
//Store transfer syntax change for after the header
if (nelem.Tag == DICOMTags.TransferSyntaxUID)
{
parsedSyntax = TransferSyntaxes.Lookup((string)nelem.Data);
if (allowSyntaxChanges)
{
transferSyntax = parsedSyntax;
}
}
//update read position pointer
readPosition = stream.Position;
}
//Store whatever TS we ended up with
TransferSyntax = (parsedSyntax != null) ? parsedSyntax : transferSyntax;
return(true);
}
/// <summary>
/// Clear the current transfer syntax list - reset contents to empty.
/// </summary>
public void ClearTransferSyntaxes()
{
_transferSyntaxes = null;
}
static Uid()
{
//force abstract and transfer syntaxes to init to poulate the masterlookup
AbstractSyntaxes.Init();
TransferSyntaxes.Init();
}
public bool Supports(DicomTransferSyntax tx)
{
return(TransferSyntaxes.Contains(tx.UID.UID));
}
