/// <summary>
/// Create a copy of the specified DICOM file with requested transfer syntax.
/// </summary>
/// <param name="file">DICOM file to copy.</param>
/// <param name="syntax">Requested transfer syntax for the created DICOM file.</param>
/// <param name="parameters">Codec parameters.</param>
/// <returns>DICOM file with modified transfer syntax.</returns>
public static DicomFile ChangeTransferSyntax(
this DicomFile file,
DicomTransferSyntax syntax,
DicomCodecParams parameters = null)
{
var transcoder = new DicomTranscoder(file.FileMetaInfo.TransferSyntax, syntax, parameters, parameters);
return transcoder.Transcode(file);
}
internal DicomPresentationContext(byte pcid, DicomUID abstractSyntax, DicomTransferSyntax transferSyntax, DicomPresentationContextResult result) {
_pcid = pcid;
_result = result;
_abstract = abstractSyntax;
_transferSyntaxes = new List<DicomTransferSyntax>();
_transferSyntaxes.Add(transferSyntax);
}
/// <summary>
/// Create a copy of the specified DICOM dataset with requested transfer syntax.
/// </summary>
/// <param name="dataset">DICOM dataset to copy.</param>
/// <param name="syntax">Requested transfer syntax for the created DICOM dataset.</param>
/// <param name="parameters">Codec parameters.</param>
/// <returns>DICOM dataset with modified transfer syntax.</returns>
public static DicomDataset ChangeTransferSyntax(
this DicomDataset dataset,
DicomTransferSyntax syntax,
DicomCodecParams parameters = null)
{
var transcoder = new DicomTranscoder(dataset.InternalTransferSyntax, syntax, parameters, parameters);
return transcoder.Transcode(dataset);
}
/// <summary>
/// Create a copy of the specified DICOM file with requested transfer syntax.
/// </summary>
/// <param name="file">DICOM file to copy.</param>
/// <param name="syntax">Requested transfer syntax for the created DICOM file.</param>
/// <param name="parameters">Codec parameters.</param>
/// <returns>DICOM file with modified transfer syntax.</returns>
public static DicomFile Clone(
this DicomFile file,
DicomTransferSyntax syntax,
DicomCodecParams parameters = null)
{
var transcoder = new DicomTranscoder(file.FileMetaInfo.TransferSyntax, syntax, null, parameters);
return(transcoder.Transcode(file));
}
public static DicomDataset ChangeTransferSyntax(
this DicomDataset dataset,
DicomTransferSyntax syntax,
DicomCodecParams parameters = null)
{
DicomTranscoder transcoder = new DicomTranscoder(dataset.InternalTransferSyntax, syntax);
transcoder.InputCodecParams = parameters;
transcoder.OutputCodecParams = parameters;
return transcoder.Transcode(dataset);
}
public static IDicomCodec GetCodec(DicomTransferSyntax syntax)
{
IDicomCodec codec = null;
if (!_codecs.TryGetValue(syntax, out codec))
{
throw new DicomCodecException("No codec registered for tranfer syntax: {0}", syntax);
}
return(codec);
}
public static DicomFile ChangeTransferSyntax(
this DicomFile file,
DicomTransferSyntax syntax,
DicomCodecParams parameters = null)
{
DicomTranscoder transcoder = new DicomTranscoder(file.FileMetaInfo.TransferSyntax, syntax);
transcoder.InputCodecParams = parameters;
transcoder.OutputCodecParams = parameters;
return transcoder.Transcode(file);
}
public void UnregisterUnregistersTransferSyntax()
{
var uid = new DicomUID("0", "testing", DicomUidType.TransferSyntax);
DicomTransferSyntax.Register(uid);
Assert.NotNull(DicomTransferSyntax.Query(uid));
DicomTransferSyntax.Unregister(uid);
Assert.Null(DicomTransferSyntax.Query(uid));
}
/// <summary>
/// Finds the Presentation Context with the specified Abstract Syntax and Transfer Syntax.
/// </summary>
/// <param name="abstractSyntax">Abstract Syntax</param>
/// <param name="transferSyntax">Transfer Syntax</param>
/// <returns>Presentation Context ID</returns>
public byte FindAbstractSyntaxWithTransferSyntax(DicomUID abstractSyntax, DicomTransferSyntax trasferSyntax)
{
foreach (DcmPresContext ctx in _presContexts.Values)
{
if (ctx.AbstractSyntax == abstractSyntax && ctx.HasTransfer(trasferSyntax))
{
return(ctx.ID);
}
}
return(0);
}
/// <summary>
/// Initializes an instance of <see cref="DicomTranscoder"/>.
/// </summary>
/// <param name="inputSyntax">Input transfer syntax.</param>
/// <param name="outputSyntax">Output transfer syntax.</param>
/// <param name="inputCodecParams">Input codec parameters.</param>
/// <param name="outputCodecParams">Output codec parameters.</param>
public DicomTranscoder(
DicomTransferSyntax inputSyntax,
DicomTransferSyntax outputSyntax,
DicomCodecParams inputCodecParams = null,
DicomCodecParams outputCodecParams = null)
{
InputSyntax = inputSyntax;
OutputSyntax = outputSyntax;
InputCodecParams = inputCodecParams ?? DefaultInputCodecParams(inputSyntax);
OutputCodecParams = outputCodecParams;
}
private static void WalkDataset(
IByteTarget target,
DicomTransferSyntax syntax,
DicomDataset dataset,
DicomWriteOptions options)
{
var writer = new DicomWriter(syntax, options, target);
var walker = new DicomDatasetWalker(dataset);
walker.Walk(writer);
}
private static Task WalkDatasetAsync(
IByteTarget target,
DicomTransferSyntax syntax,
DicomDataset dataset,
DicomWriteOptions options)
{
var writer = new DicomWriter(syntax, options, target);
var walker = new DicomDatasetWalker(dataset);
return(walker.WalkAsync(writer));
}
public void RegisterHandlesMultipleRegistrations()
{
var uid = new DicomUID("0", "testing", DicomUidType.TransferSyntax);
// should not matter if 2 instances are same.
Assert.NotNull(DicomTransferSyntax.Register(uid));
Assert.NotNull(DicomTransferSyntax.Register(uid));
// just to be sure
DicomTransferSyntax.Unregister(uid);
}
public void SetResult_TwoArguments_AcceptedTransferSyntaxOnlyRequiredOnAcceptNullOtherwise(
DicomPresentationContextResult result,
DicomTransferSyntax acceptedSyntax)
{
var context = new DicomPresentationContext(0x01, DicomUID.Verification);
context.SetResult(result, acceptedSyntax);
Assert.Equal(result == DicomPresentationContextResult.Accept ? acceptedSyntax : null,
context.AcceptedTransferSyntax);
}
public void GivenSupported16bitTransferSyntax_WhenRetrievingFrameAndAskingForConversion_ReturnedFileHasExpectedTransferSyntax(
DicomTransferSyntax tsFrom,
DicomTransferSyntax tsTo,
PhotometricInterpretation photometricInterpretation)
{
DicomFile dicomFile = StreamAndStoredFileFromDataset(photometricInterpretation, false, tsFrom).Result.dicomFile;
dicomFile.Dataset.ToInstanceIdentifier();
_transcoder.TranscodeFrame(dicomFile, 1, tsTo.UID.UID);
}
public static void RegisterCodec(DicomTransferSyntax ts, Type type)
{
if (_codecs == null)
{
_codecs = new Dictionary <DicomTransferSyntax, Type>();
}
if (type.IsDefined(typeof(DicomCodecAttribute), false))
{
_codecs.Add(ts, type);
}
}
/// <summary>
/// Initializes an instance of <see cref="DicomTranscoder"/>.
/// </summary>
/// <param name="inputSyntax">Input transfer syntax.</param>
/// <param name="outputSyntax">Output transfer syntax.</param>
/// <param name="inputCodecParams">Input codec parameters.</param>
/// <param name="outputCodecParams">Output codec parameters.</param>
public DicomTranscoder(
DicomTransferSyntax inputSyntax,
DicomTransferSyntax outputSyntax,
DicomCodecParams inputCodecParams = null,
DicomCodecParams outputCodecParams = null)
{
InputSyntax = inputSyntax;
OutputSyntax = outputSyntax;
InputCodecParams = inputCodecParams;
OutputCodecParams = outputCodecParams;
}
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 DcmDataset ToDataset(DicomTransferSyntax ts)
{
DcmDataset dataset = new DcmDataset(ts);
if (QueryRetrieveLevel != DcmQueryRetrieveLevel.Worklist)
{
dataset.AddElementWithValue(DicomTags.QueryRetrieveLevel, QueryRetrieveLevel.ToString().ToUpper());
}
dataset.SaveDicomFields(this);
AdditionalMembers(dataset);
return(dataset);
}
public bool ChangeTransferSyntax(DicomTransferSyntax newTransferSyntax)
{
try
{
DicomFile = DicomFile.ChangeTransferSyntax(newTransferSyntax);
return(true);
}
catch (Exception)
{
return(false);
}
}
internal DicomPresentationContext(
byte pcid,
DicomUID abstractSyntax,
DicomTransferSyntax transferSyntax,
DicomPresentationContextResult result)
{
_pcid = pcid;
_result = result;
_abstract = abstractSyntax;
_transferSyntaxes = new List <DicomTransferSyntax>();
_transferSyntaxes.Add(transferSyntax);
}
public void UnregisterHandleMultipleUnregistrations()
{
var uid = new DicomUID("0", "testing", DicomUidType.TransferSyntax);
DicomTransferSyntax.Register(uid);
Assert.NotNull(DicomTransferSyntax.Query(uid));
Assert.True(DicomTransferSyntax.Unregister(uid));
Assert.Null(DicomTransferSyntax.Query(uid));
Assert.False(DicomTransferSyntax.Unregister(uid));
Assert.Null(DicomTransferSyntax.Query(uid));
}
public void QueryReturnsRegisteredTransferSyntax()
{
var uid = new DicomUID("0", "testing", DicomUidType.TransferSyntax);
DicomTransferSyntax.Register(uid);
var ts = DicomTransferSyntax.Query(uid);
Assert.NotNull(ts);
Assert.Equal(uid, ts.UID);
DicomTransferSyntax.Unregister(uid);
}
private DicomDataset Decode(DicomDataset oldDataset, DicomTransferSyntax outSyntax, IDicomCodec codec, DicomCodecParams parameters)
{
DicomPixelData oldPixelData = DicomPixelData.Create(oldDataset, false);
DicomDataset newDataset = oldDataset.Clone();
newDataset.InternalTransferSyntax = outSyntax;
DicomPixelData newPixelData = DicomPixelData.Create(newDataset, true);
codec.Decode(oldPixelData, newPixelData, parameters);
return(newDataset);
}
public async Task GivenSupported16bitTransferSyntax_WhenRetrievingFileAndAskingForConversion_ReturnedFileHasExpectedTransferSyntax(
DicomTransferSyntax tsFrom,
DicomTransferSyntax tsTo,
PhotometricInterpretation photometricInterpretation)
{
(DicomFile dicomFile, Stream stream) = await StreamAndStoredFileFromDataset(photometricInterpretation, false, tsFrom);
dicomFile.Dataset.ToInstanceIdentifier();
Stream transcodedFile = await _transcoder.TranscodeFileAsync(stream, tsTo.UID.UID);
ValidateTransferSyntax(tsTo, transcodedFile);
}
/// <summary>
/// Initializes an instance of <see cref="DicomTranscoder"/>.
/// </summary>
/// <param name="inputSyntax">Input transfer syntax.</param>
/// <param name="outputSyntax">Output transfer syntax.</param>
/// <param name="inputCodecParams">Input codec parameters.</param>
/// <param name="outputCodecParams">Output codec parameters.</param>
public DicomTranscoder(
DicomTransferSyntax inputSyntax,
DicomTransferSyntax outputSyntax,
DicomCodecParams inputCodecParams = null,
DicomCodecParams outputCodecParams = null)
{
InputSyntax = inputSyntax;
OutputSyntax = outputSyntax;
InputCodecParams = inputCodecParams ?? DefaultInputCodecParams(inputSyntax);
OutputCodecParams = outputCodecParams;
_inputCodec = new Lazy <IDicomCodec>(() => InitializeCodec(InputSyntax));
_outputCodec = new Lazy <IDicomCodec>(() => InitializeCodec(OutputSyntax));
}
protected void GenerateTestFiles_SingleStudy_SingleSeries_WithTransferSyntax_WithNInstances(
string testCaseName,
DicomTransferSyntax transferSyntax,
int instanceCount)
{
var destPath = Path.Combine(ApplicationEntryDirectory, testCaseName);
var instancesGenerated = dicomFileGenerator.SetPatient(testCaseName)
.GenerateNewStudy()
.SetStudyDateTime(DateTime.Now)
.GenerateNewSeries()
.Save(destPath, testCaseName, transferSyntax, instanceCount);
FileSetPaths.Add(testCaseName, new List <TestInstanceInfo>(instancesGenerated));
}
/// <summary>
/// returns dicomFile in the content type given by finalContentType in a HttpResponseMessage.
/// If content type is dicom, transfer syntax must be set to the given transferSyntax parameter.
/// </summary>
/// <param name="dicomFile"></param>
/// <param name="finalContentType"></param>
/// <param name="transferSyntax"></param>
/// <returns></returns>
private HttpResponseMessage ReturnImageAsHttpResponse(DicomFile dicomFile, string finalContentType, string transferSyntax)
{
MediaTypeHeaderValue header = null;
Stream streamContent = null;
if (finalContentType == JpegImageContentType)
{
var image = new DicomImage(dicomFile.Dataset);
Bitmap bmp = image.RenderImage(0).As <Bitmap>();
//When an image/jpeg MIME type is returned, the image shall be encoded using the JPEG baseline lossy 8
//bit Huffman encoded non-hierarchical non-sequential process ISO/IEC 10918.
//TODO Is it the case with default Jpeg format from Bitmap?
header = new MediaTypeHeaderValue(JpegImageContentType);
streamContent = new MemoryStream();
bmp.Save(streamContent, ImageFormat.Jpeg);
streamContent.Seek(0, SeekOrigin.Begin);
}
else if (finalContentType == AppDicomContentType)
{
//By default, the transfer syntax shall be
//"Explicit VR Little Endian".
//Note: This implies that retrieved images are sent un-compressed by default.
DicomTransferSyntax requestedTransferSyntax = DicomTransferSyntax.ExplicitVRLittleEndian;
if (transferSyntax != null)
{
requestedTransferSyntax = GetTransferSyntaxFromString(transferSyntax);
}
bool transferSyntaxIsTheSameAsSourceFile =
dicomFile.FileMetaInfo.TransferSyntax == requestedTransferSyntax;
//we only change transfer syntax if we need to
DicomFile dicomFileToStream = !transferSyntaxIsTheSameAsSourceFile?dicomFile.Clone(requestedTransferSyntax) : dicomFile;
header = new MediaTypeHeaderValue(AppDicomContentType);
streamContent = new MemoryStream();
dicomFileToStream.Save(streamContent);
streamContent.Seek(0, SeekOrigin.Begin);
}
var result = new HttpResponseMessage(HttpStatusCode.OK)
{
Content = new StreamContent(streamContent)
};
result.Content.Headers.ContentType = header;
return(result);
}
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));
}
static public DicomDataset Compress(this DicomDataset original, DicomTransferSyntax dicomTransferSyntax, IDicomCodec codec, DicomCodecParams jpegParams)
{
DicomDataset dataset = new DicomDataset(dicomTransferSyntax);
original.CopyTo(dataset);
DicomPixelData pixelData = DicomPixelData.Create(dataset, true);
DicomPixelData pixelDataSource = DicomPixelData.Create(original, false);
codec.Encode(pixelDataSource, pixelData, jpegParams);
return(dataset);
}
public void LookupReturnsAdHocTransferSyntax()
{
var uid = new DicomUID("0", "testing", DicomUidType.TransferSyntax);
var ts = DicomTransferSyntax.Lookup(uid);
Assert.NotNull(ts);
Assert.Equal(uid, ts.UID);
// Lookup must not auto-register, as it is invoked from DicomServer.
// auto-registration may cause DoS by sending crafted transfer syntaxes repeatedly,
// which causes internal static dictionary to hold all the transfer syntaxes.
Assert.Null(DicomTransferSyntax.Query(uid));
}
public static IDcmCodec GetCodec(DicomTransferSyntax ts)
{
if (_codecs == null)
{
RegisterCodecs();
}
Type cType;
if (_codecs.TryGetValue(ts, out cType))
{
return((IDcmCodec)Activator.CreateInstance(cType));
}
throw new DicomCodecException("No registered codec for transfer syntax!");
}
public static bool HasCodec(DicomTransferSyntax ts)
{
if (ts == DicomTransferSyntax.ImplicitVRLittleEndian ||
ts == DicomTransferSyntax.ExplicitVRLittleEndian ||
ts == DicomTransferSyntax.ExplicitVRBigEndian)
{
return(true);
}
if (_codecs == null)
{
return(false);
}
return(_codecs.ContainsKey(ts));
}
public IList <TestInstanceInfo> Save(string destDir, string filenamePrefix, DicomTransferSyntax transferSyntax, int instancesToGenerate = 1, string sopClassUid = "1.2.840.10008.5.1.4.1.1.11.1")
{
Console.Write("Generating test files.");
if (!Directory.Exists(destDir))
{
Directory.CreateDirectory(destDir);
}
var dataset = new DicomDataset();
baseDataset.CopyTo(dataset);
dataset.AddOrUpdate(DicomTag.SOPClassUID, sopClassUid);
var dicomFile = new DicomFile(dataset);
if (transferSyntax != dicomFile.Dataset.InternalTransferSyntax)
{
var transcoder = new DicomTranscoder(dicomFile.Dataset.InternalTransferSyntax, transferSyntax, outputCodecParams: new DicomJpegParams()
{
Quality = 100, ConvertColorspaceToRGB = true
});
dicomFile = transcoder.Transcode(dicomFile);
}
var instancesCreated = new List <TestInstanceInfo>();
for (int i = 0; i < instancesToGenerate; i++)
{
Console.Write(".");
var sopInstanceUid = DicomUIDGenerator.GenerateDerivedFromUUID();
var filePath = Path.Combine(destDir, $"{filenamePrefix}-{i:00000}.dcm");
dicomFile.Dataset.AddOrUpdate(DicomTag.SOPInstanceUID, sopInstanceUid);
dicomFile.FileMetaInfo.AddOrUpdate(DicomTag.MediaStorageSOPInstanceUID, sopInstanceUid);
dicomFile.FileMetaInfo.AddOrUpdate(DicomTag.MediaStorageSOPClassUID, sopClassUid);
dicomFile.Clone().Save(filePath);
instancesCreated.Add(new TestInstanceInfo
{
PatientId = dicomFile.Dataset.GetSingleValue <string>(DicomTag.PatientID),
StudyInstanceUid = dicomFile.Dataset.GetSingleValue <string>(DicomTag.StudyInstanceUID),
SeriesInstanceUid = dicomFile.Dataset.GetSingleValue <string>(DicomTag.SeriesInstanceUID),
SopInstanceUid = dicomFile.Dataset.GetSingleValue <string>(DicomTag.SOPInstanceUID),
FilePath = filePath
});
}
Console.WriteLine(".");
return(instancesCreated);
}
/// <summary>
/// Initializes a new instance of the <see cref="DicomPresentationContext"/> class.
/// </summary>
/// <param name="pcid">
/// The presentation context ID.
/// </param>
/// <param name="abstractSyntax">
/// The abstract syntax associated with the presentation context.
/// </param>
/// <param name="transferSyntax">
/// Accepted transfer syntax.
/// </param>
/// <param name="result">
/// Result of presentation context negotiation.
/// </param>
internal DicomPresentationContext(
byte pcid,
DicomUID abstractSyntax,
DicomTransferSyntax transferSyntax,
DicomPresentationContextResult result)
{
ID = pcid;
Result = result;
AbstractSyntax = abstractSyntax;
_transferSyntaxes = new List <DicomTransferSyntax> {
transferSyntax
};
UserRole = null;
ProviderRole = null;
}
/// <summary>
/// Asynchronously read DICOM file object.
/// </summary>
/// <param name="source">Byte source to read.</param>
/// <param name="fileMetaInfo">Reader observer for file meta information.</param>
/// <param name="dataset">Reader observer for dataset.</param>
/// <param name="stop">Stop criterion in dataset.</param>
/// <returns>Awaitable reader result.</returns>
public async Task <DicomReaderResult> ReadAsync(
IByteSource source,
IDicomReaderObserver fileMetaInfo,
IDicomReaderObserver dataset,
Func <ParseState, bool> stop = null)
{
var parse = await ParseAsync(source, fileMetaInfo, dataset, stop).ConfigureAwait(false);
lock (_locker)
{
FileFormat = parse.Item2;
Syntax = parse.Item3;
}
return(parse.Item1);
}
/// <summary>
/// Create baisc film box for specified film session
/// </summary>
/// <param name="filmSession">Film session instance</param>
/// <param name="sopInstance">Basic film box SOP Instance UID</param>
public FilmBox(FilmSession filmSession, DicomUID sopInstance, DicomTransferSyntax transferSyntax)
: base()
{
this.InternalTransferSyntax = transferSyntax;
_filmSession = filmSession;
if (sopInstance == null || sopInstance.UID == string.Empty)
{
SOPInstanceUID = DicomUID.Generate();
}
else
{
SOPInstanceUID = sopInstance;
}
this.Add(DicomTag.SOPClassUID, SOPClassUID);
this.Add(DicomTag.SOPInstanceUID, SOPInstanceUID);
BasicImageBoxes = new List<ImageBox>();
}
public static IDicomCodec GetCodec(DicomTransferSyntax syntax) {
IDicomCodec codec = null;
if (!_codecs.TryGetValue(syntax, out codec))
throw new DicomCodecException("No codec registered for tranfer syntax: {0}", syntax);
return codec;
}
public DicomTranscoder(DicomTransferSyntax input, DicomTransferSyntax output) {
InputSyntax = input;
OutputSyntax = output;
}
private DicomDataset Decode(DicomDataset oldDataset, DicomTransferSyntax outSyntax, IDicomCodec codec, DicomCodecParams parameters) {
DicomPixelData oldPixelData = DicomPixelData.Create(oldDataset, false);
DicomDataset newDataset = oldDataset.Clone();
newDataset.InternalTransferSyntax = outSyntax;
DicomPixelData newPixelData = DicomPixelData.Create(newDataset, true);
codec.Decode(oldPixelData, newPixelData, parameters);
ProcessOverlays(oldDataset, newDataset);
newDataset.RecalculateGroupLengths(false);
return newDataset;
}
private DicomDataset Encode(DicomDataset oldDataset, DicomTransferSyntax inSyntax, IDicomCodec codec, DicomCodecParams parameters) {
DicomPixelData oldPixelData = DicomPixelData.Create(oldDataset, false);
DicomDataset newDataset = oldDataset.Clone();
newDataset.InternalTransferSyntax = codec.TransferSyntax;
DicomPixelData newPixelData = DicomPixelData.Create(newDataset, true);
codec.Encode(oldPixelData, newPixelData, parameters);
if (codec.TransferSyntax.IsLossy && newPixelData.NumberOfFrames > 0) {
newDataset.Add(new DicomCodeString(DicomTag.LossyImageCompression, "01"));
List<string> methods = new List<string>();
if (newDataset.Contains(DicomTag.LossyImageCompressionMethod))
methods.AddRange(newDataset.Get<string[]>(DicomTag.LossyImageCompressionMethod));
methods.Add(codec.TransferSyntax.LossyCompressionMethod);
newDataset.Add(new DicomCodeString(DicomTag.LossyImageCompressionMethod, methods.ToArray()));
double oldSize = oldPixelData.GetFrame(0).Size;
double newSize = newPixelData.GetFrame(0).Size;
string ratio = String.Format("{0:0.000}", oldSize / newSize);
newDataset.Add(new DicomDecimalString(DicomTag.LossyImageCompressionRatio, ratio));
}
ProcessOverlays(oldDataset, newDataset);
newDataset.RecalculateGroupLengths(false);
return newDataset;
}
/// <summary>
/// Compares a list of transfer syntaxes accepted by the SCP against the list of transfer syntaxes proposed by the SCU. Sets the presentation
/// context <c>Result</c> to <c>DicomPresentationContextResult.Accept</c> if an accepted transfer syntax is found. If no accepted transfer
/// syntax is found, the presentation context <c>Result</c> is set to <c>DicomPresentationContextResult.RejectTransferSyntaxesNotSupported</c>.
/// </summary>
/// <param name="acceptedTransferSyntaxes">Transfer syntaxes that the SCP accepts for the proposed abstract syntax.</param>
/// <param name="scpPriority">If set to <c>true</c>, transfer syntaxes will be accepted in the order specified by <paramref name="acceptedTransferSyntaxes"/>. If set to <c>false</c>, transfer syntaxes will be accepted in the order proposed by the SCU.</param>
/// <returns>Returns <c>true</c> if an accepted transfer syntax was found. Returns <c>false</c> if no accepted transfer syntax was found.</returns>
public bool AcceptTransferSyntaxes(DicomTransferSyntax[] acceptedTransferSyntaxes, bool scpPriority = false)
{
if (Result == DicomPresentationContextResult.Accept) return true;
if (scpPriority)
{
// let the SCP decide which syntax that it would prefer
foreach (DicomTransferSyntax ts in acceptedTransferSyntaxes)
{
if (ts != null && HasTransferSyntax(ts))
{
SetResult(DicomPresentationContextResult.Accept, ts);
return true;
}
}
}
else
{
// accept syntaxes in the order that the SCU proposed them
foreach (DicomTransferSyntax ts in _transferSyntaxes)
{
if (acceptedTransferSyntaxes.Contains(ts))
{
SetResult(DicomPresentationContextResult.Accept, ts);
return true;
}
}
}
SetResult(DicomPresentationContextResult.RejectTransferSyntaxesNotSupported);
return false;
}
public void GetCodec_KnownTransferSyntax_ShouldReturnCodecObject(DicomTransferSyntax transferSyntax, string expected)
{
var codec = TranscoderManager.GetCodec(transferSyntax);
var actual = codec.Name;
Assert.Equal(expected, actual);
}
public void AddTransferSyntax(DicomTransferSyntax ts)
{
if (ts != null && !_transferSyntaxes.Contains(ts)) _transferSyntaxes.Add(ts);
}
public void RemoveTransferSyntax(DicomTransferSyntax ts)
{
if (ts != null && _transferSyntaxes.Contains(ts)) _transferSyntaxes.Remove(ts);
}
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 static async Task<Tuple<DicomReaderResult, DicomFileFormat, DicomTransferSyntax>> DoParseAsync(
IByteSource source,
IDicomReaderObserver fileMetasetInfoObserver,
IDicomReaderObserver datasetObserver,
Func<ParseState, bool> stop,
DicomTransferSyntax syntax,
DicomFileFormat fileFormat)
{
string code = null, uid = null;
var obs = new DicomReaderCallbackObserver();
if (fileFormat != DicomFileFormat.DICOM3)
{
obs.Add(
DicomTag.RecognitionCodeRETIRED,
(sender, ea) =>
{
try
{
code = Encoding.UTF8.GetString(ea.Data.Data, 0, ea.Data.Data.Length);
}
catch
{
}
});
}
obs.Add(
DicomTag.TransferSyntaxUID,
(sender, ea) =>
{
try
{
uid = Encoding.UTF8.GetString(ea.Data.Data, 0, ea.Data.Data.Length);
}
catch
{
}
});
var reader = new DicomReader { IsExplicitVR = syntax.IsExplicitVR, IsDeflated = false };
DicomReaderResult result;
if (fileFormat == DicomFileFormat.DICOM3NoFileMetaInfo)
{
result =
await
reader.ReadAsync(source, new DicomReaderMultiObserver(obs, datasetObserver), stop).ConfigureAwait(false);
UpdateFileFormatAndSyntax(code, uid, ref fileFormat, ref syntax);
}
else
{
if (
await
reader.ReadAsync(
source,
new DicomReaderMultiObserver(obs, fileMetasetInfoObserver),
FileMetaInfoStopCriterion).ConfigureAwait(false) != DicomReaderResult.Stopped)
{
throw new DicomReaderException("DICOM File Meta Info ended prematurely");
}
UpdateFileFormatAndSyntax(code, uid, ref fileFormat, ref syntax);
// rewind to last marker (start of previous tag)... ugly because
// it requires knowledge of how the parser is implemented
source.Rewind();
source.Endian = syntax.Endian;
reader.IsExplicitVR = syntax.IsExplicitVR;
reader.IsDeflated = syntax.IsDeflate;
result = await reader.ReadAsync(source, datasetObserver, stop).ConfigureAwait(false);
}
return Tuple.Create(result, fileFormat, syntax);
}
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.UTF8.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.UTF8.GetString(ea.Data.Data, 0, ea.Data.Data.Length);
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.UTF8.GetString(ea.Data.Data, 0, ea.Data.Data.Length);
_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();
}
}
}
private void ChangeSyntax(DicomTransferSyntax syntax, DicomCodecParams param = null)
{
var file = _file.ChangeTransferSyntax(syntax, param);
OpenFile(file);
}
/// <summary>
/// Sets the <c>Result</c> and <c>AcceptedTransferSyntax</c> of this presentation context.
///
/// The preferred method of accepting presentation contexts is to call one of the <c>AcceptTransferSyntaxes</c> methods.
/// </summary>
/// <param name="result">Result status to return for this proposed presentation context.</param>
/// <param name="acceptedTransferSyntax">Accepted transfer syntax for this proposed presentation context.</param>
public void SetResult(DicomPresentationContextResult result, DicomTransferSyntax acceptedTransferSyntax)
{
_transferSyntaxes.Clear();
_transferSyntaxes.Add(acceptedTransferSyntax);
_result = result;
}
/// <summary>
/// Read DICOM file object.
/// </summary>
/// <param name="source">Byte source to read.</param>
/// <param name="fileMetaInfo">Reader observer for file meta information.</param>
/// <param name="dataset">Reader observer for dataset.</param>
/// <param name="stop">Stop criterion in dataset.</param>
/// <returns>Reader result.</returns>
public DicomReaderResult Read(
IByteSource source,
IDicomReaderObserver fileMetaInfo,
IDicomReaderObserver dataset,
Func<ParseState, bool> stop = null)
{
var parse = Parse(source, fileMetaInfo, dataset, stop);
lock (this.locker)
{
this.fileFormat = parse.Format;
this.syntax = parse.Syntax;
}
return parse.Result;
}
public DicomWriter(DicomTransferSyntax syntax, DicomWriteOptions options, IByteTarget target)
{
_syntax = syntax;
_options = options ?? DicomWriteOptions.Default;
_target = target;
}
/// <summary>
/// If necessary, update dataset syntax and group lengths.
/// </summary>
/// <param name="syntax">Transfer syntax.</param>
/// <param name="dataset">DICOM dataset.</param>
/// <param name="options">Writer options.</param>
private static void UpdateDatasetGroupLengths(
DicomTransferSyntax syntax,
DicomDataset dataset,
DicomWriteOptions options)
{
if (options.KeepGroupLengths)
{
// update transfer syntax and recalculate existing group lengths
dataset.InternalTransferSyntax = syntax;
dataset.RecalculateGroupLengths(false);
}
else
{
// remove group lengths as suggested in PS 3.5 7.2
//
// 2. It is recommended that Group Length elements be removed during storage or transfer
// in order to avoid the risk of inconsistencies arising during coercion of data
// element values and changes in transfer syntax.
dataset.RemoveGroupLengths();
}
}
public bool HasTransferSyntax(DicomTransferSyntax ts)
{
return _transferSyntaxes.Contains(ts);
}
public ParseResult(DicomReaderResult result, DicomFileFormat format, DicomTransferSyntax syntax)
{
this.Result = result;
this.Format = format;
this.Syntax = syntax;
}
public DicomFileReader() {
_reader = new DicomReader();
_fileFormat = DicomFileFormat.Unknown;
_syntax = DicomTransferSyntax.ExplicitVRLittleEndian;
}
/// <summary>
/// Asynchronously read DICOM file object.
/// </summary>
/// <param name="source">Byte source to read.</param>
/// <param name="fileMetaInfo">Reader observer for file meta information.</param>
/// <param name="dataset">Reader observer for dataset.</param>
/// <param name="stop">Stop criterion in dataset.</param>
/// <returns>Awaitable reader result.</returns>
public async Task<DicomReaderResult> ReadAsync(
IByteSource source,
IDicomReaderObserver fileMetaInfo,
IDicomReaderObserver dataset,
Func<ParseState, bool> stop = null)
{
var parse = await ParseAsync(source, fileMetaInfo, dataset, stop).ConfigureAwait(false);
lock (this.locker)
{
this.fileFormat = parse.Item2;
this.syntax = parse.Item3;
}
return parse.Item1;
}
/// <summary>
/// Initializes a new instance of <see cref="DicomFileReader"/>.
/// </summary>
public DicomFileReader()
{
this.fileFormat = DicomFileFormat.Unknown;
this.syntax = null;
this.locker = new object();
}
public DicomWriteLengthCalculator(DicomTransferSyntax syntax, DicomWriteOptions options) {
_syntax = syntax;
_options = options;
}
private static void Preprocess(
IByteSource source,
ref DicomFileFormat fileFormat,
ref DicomTransferSyntax syntax)
{
// 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)
{
fileFormat = @group == 0x0002
? DicomFileFormat.DICOM3NoPreamble
: DicomFileFormat.DICOM3NoFileMetaInfo;
}
var element = source.GetUInt16();
var tag = new DicomTag(@group, element);
// test for explicit VR
var vrt = Encoding.UTF8.GetBytes(tag.DictionaryEntry.ValueRepresentations[0].Code);
var vrs = source.GetBytes(2);
if (vrt[0] != vrs[0] || vrt[1] != vrs[1])
{
// implicit VR
syntax = syntax.Endian == Endian.Little
? DicomTransferSyntax.ImplicitVRLittleEndian
: DicomTransferSyntax.ImplicitVRBigEndian;
}
source.Rewind();
}
while (fileFormat == DicomFileFormat.Unknown);
if (fileFormat == DicomFileFormat.Unknown)
{
throw new DicomReaderException("Attempted to read invalid DICOM file");
}
// Adopt transfer syntax endianess to byte source.
source.Endian = syntax.Endian;
}
