public static IAsyncResult BeginRead(
this DicomFileReader @this,
IByteSource source,
IDicomReaderObserver fileMetaInfo,
IDicomReaderObserver dataset,
AsyncCallback callback,
object state)
{
return(AsyncFactory.ToBegin(@this.ReadAsync(source, fileMetaInfo, dataset), callback, state));
}
public async Task ReadAsync_CompressedImage_RecognizeTransferSyntax()
{
using (var stream = File.OpenRead(@".\Test Data\CT1_J2KI"))
{
var source = new StreamByteSource(stream);
var reader = new DicomFileReader();
var fileMetaInfo = new DicomFileMetaInformation();
var dataset = new DicomDataset();
await
reader.ReadAsync(
source,
new DicomDatasetReaderObserver(fileMetaInfo),
new DicomDatasetReaderObserver(dataset));
var expected = DicomTransferSyntax.JPEG2000Lossy;
var actual = reader.Syntax;
Assert.Equal(expected, actual);
}
}
/// <summary>
/// Asynchronously read a DICOM file from stream.
/// </summary>
/// <param name="stream">Stream to read.</param>
/// <param name="fallbackEncoding">Encoding to use if encoding cannot be obtained from DICOM file.</param>
/// <param name="stop">Stop criterion in dataset.</param>
/// <returns>Awaitable <see cref="DicomFile"/> instance.</returns>
public static async Task<DicomFile> OpenAsync(Stream stream, Encoding fallbackEncoding, Func<ParseState, bool> stop = null)
{
if (fallbackEncoding == null)
{
throw new ArgumentNullException("fallbackEncoding");
}
var df = new DicomFile();
try
{
var source = new StreamByteSource(stream);
var reader = new DicomFileReader();
var result =
await
reader.ReadAsync(
source,
new DicomDatasetReaderObserver(df.FileMetaInfo),
new DicomDatasetReaderObserver(df.Dataset, fallbackEncoding),
stop).ConfigureAwait(false);
if (result == DicomReaderResult.Processing)
{
throw new DicomFileException(df, "Invalid read return state: {state}", result);
}
if (result == DicomReaderResult.Error)
{
return null;
}
df.IsPartial = result == DicomReaderResult.Stopped || result == DicomReaderResult.Suspended;
df.Format = reader.FileFormat;
df.Dataset.InternalTransferSyntax = reader.Syntax;
return df;
}
catch (Exception e)
{
throw new DicomFileException(df, e.Message, e);
}
}
public async Task ReadAsync_CompressedImage_RecognizeTransferSyntax()
{
using (var stream = File.OpenRead(@".\Test Data\CT1_J2KI"))
{
var source = new StreamByteSource(stream);
var reader = new DicomFileReader();
var fileMetaInfo = new DicomFileMetaInformation();
var dataset = new DicomDataset();
await
reader.ReadAsync(
source,
new DicomDatasetReaderObserver(fileMetaInfo),
new DicomDatasetReaderObserver(dataset));
var expected = DicomTransferSyntax.JPEG2000Lossy;
var actual = reader.Syntax;
Assert.Equal(expected, actual);
}
}
/// <summary>
/// Asynchronously read DICOM Directory from stream.
/// </summary>
/// <param name="stream">Stream to read.</param>
/// <param name="fallbackEncoding">Encoding to apply if it cannot be identified from DICOM directory.</param>
/// <param name="stop">Stop criterion in dataset.</param>
/// <returns>Awaitable <see cref="DicomDirectory"/> instance.</returns>
public static new async Task<DicomDirectory> OpenAsync(Stream stream, Encoding fallbackEncoding, Func<ParseState, bool> stop = null)
{
if (fallbackEncoding == null)
{
throw new ArgumentNullException(nameof(fallbackEncoding));
}
var df = new DicomDirectory();
try
{
var source = new StreamByteSource(stream);
var reader = new DicomFileReader();
var dirObserver = new DicomDirectoryReaderObserver(df.Dataset);
var result =
await
reader.ReadAsync(
source,
new DicomDatasetReaderObserver(df.FileMetaInfo),
new DicomReaderMultiObserver(
new DicomDatasetReaderObserver(df.Dataset, fallbackEncoding),
dirObserver),
stop).ConfigureAwait(false);
return FinalizeDicomDirectoryLoad(df, reader, dirObserver, result);
}
catch (Exception e)
{
throw new DicomFileException(df, e.Message, e);
}
}
/// <summary>
/// Asynchronously read DICOM Directory.
/// </summary>
/// <param name="fileName">File name.</param>
/// <param name="fallbackEncoding">Encoding to apply if it cannot be identified from DICOM directory.</param>
/// <param name="stop">Stop criterion in dataset.</param>
/// <returns>Awaitable <see cref="DicomDirectory"/> instance.</returns>
public static new async Task<DicomDirectory> OpenAsync(string fileName, Encoding fallbackEncoding, Func<ParseState, bool> stop = null)
{
if (fallbackEncoding == null)
{
throw new ArgumentNullException("fallbackEncoding");
}
var df = new DicomDirectory();
// reset datasets
df.FileMetaInfo.Clear();
df.Dataset.Clear();
try
{
df.File = IOManager.CreateFileReference(fileName);
using (var source = new FileByteSource(df.File))
{
var reader = new DicomFileReader();
var datasetObserver = new DicomDatasetReaderObserver(df.Dataset, fallbackEncoding);
var dirObserver = new DicomDirectoryReaderObserver(df.Dataset);
var result =
await
reader.ReadAsync(
source,
new DicomDatasetReaderObserver(df.FileMetaInfo),
new DicomReaderMultiObserver(datasetObserver, dirObserver),
stop).ConfigureAwait(false);
if (result == DicomReaderResult.Processing)
{
throw new DicomFileException(df, "Invalid read return state: {state}", result);
}
if (result == DicomReaderResult.Error)
{
return null;
}
df.IsPartial = result == DicomReaderResult.Stopped || result == DicomReaderResult.Suspended;
df.Format = reader.FileFormat;
df.Dataset.InternalTransferSyntax = reader.Syntax;
df._directoryRecordSequence = df.Dataset.Get<DicomSequence>(DicomTag.DirectoryRecordSequence);
df.RootDirectoryRecord = dirObserver.BuildDirectoryRecords();
return df;
}
}
catch (Exception e)
{
throw new DicomFileException(df, e.Message, e);
}
}