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