private void OnCompletePreamble(IByteTarget target, object state) { // recalculate FMI group length as required by standard _fileMetaInfo.RecalculateGroupLengths(); DicomWriter writer = new DicomWriter(DicomTransferSyntax.ExplicitVRLittleEndian, _options, _target); DicomDatasetWalker walker = new DicomDatasetWalker(_fileMetaInfo); walker.BeginWalk(writer, OnCompleteFileMetaInfo, walker); }
/// <summary> /// Write DICOM file preamble. /// </summary> /// <param name="target">Byte target subject to writing.</param> private static Task WritePreambleAsync(IByteTarget target) { var preamble = new byte[132]; preamble[128] = (byte)'D'; preamble[129] = (byte)'I'; preamble[130] = (byte)'C'; preamble[131] = (byte)'M'; return target.WriteAsync(preamble, 0, 132); }
public static IAsyncResult BeginWrite( this DicomFileWriter @this, IByteTarget target, DicomFileMetaInformation fileMetaInfo, DicomDataset dataset, AsyncCallback callback, object state) { return AsyncFactory.ToBegin(@this.WriteAsync(target, fileMetaInfo, dataset), callback, state); }
/// <summary> /// Write DICOM file preamble. /// </summary> /// <param name="target">Byte target subject to writing.</param> private static void WritePreamble(IByteTarget target) { var preamble = new byte[132]; preamble[128] = (byte)'D'; preamble[129] = (byte)'I'; preamble[130] = (byte)'C'; preamble[131] = (byte)'M'; target.Write(preamble, 0, 132); }
/// <summary> /// Write DICOM file meta information. /// </summary> /// <param name="target">Byte target subject to writing.</param> /// <param name="fileMetaInfo">File meta information.</param> /// <param name="options">Writer options.</param> private static void WriteFileMetaInfo( IByteTarget target, DicomDataset fileMetaInfo, DicomWriteOptions options) { // recalculate FMI group length as required by standard fileMetaInfo.RecalculateGroupLengths(); var writer = new DicomWriter(DicomTransferSyntax.ExplicitVRLittleEndian, options, target); var walker = new DicomDatasetWalker(fileMetaInfo); walker.Walk(writer); }
public void writeToTarget(IByteTarget target, IByteBuffer buff) { foreach (IByteBuffer buffer in Buffers) { if (buffer is StreamByteBuffer || buffer is FileByteBuffer || buffer is PInvokeByteBuffer) { buffer.writeToTarget(target, buff); } else { target.Write(buffer.Data, 0, buffer.Size); } } }
public void writeToTarget(IByteTarget _target, IByteBuffer buffer) { int count = 0; byte[] copyBuff = new byte[1024 * 1024]; Stream.Position = Position; while (count + 1024 * 1024 < Size) { Stream.Read(copyBuff, 0, 1024 * 1024); count += 1024 * 1024; _target.Write(copyBuff, 0, 1024 * 1024); } Stream.Read(copyBuff, 0, (int)(Size - count)); _target.Write(copyBuff, 0, (uint)(Size - count)); }
private static void WriteBuffer(IByteTarget target, IByteBuffer buffer, uint largeObjectSize) { uint offset = 0; uint remainingSize = buffer.Size; while (remainingSize > largeObjectSize) { byte[] range = GetBufferRange(buffer, offset, (int)largeObjectSize); target.Write(range, 0, largeObjectSize); offset += largeObjectSize; remainingSize -= largeObjectSize; } byte[] endRange = GetBufferRange(buffer, offset, (int)remainingSize); target.Write(endRange, 0, remainingSize); }
private static void WriteBuffer(IByteTarget target, IByteBuffer buffer, uint largeObjectSize) { var offset = 0; var remainingSize = buffer.Size; while (remainingSize > largeObjectSize) { var range = buffer.GetByteRange(offset, (int)largeObjectSize); target.Write(range, 0, largeObjectSize); offset += (int)largeObjectSize; remainingSize -= largeObjectSize; } target.Write(buffer.GetByteRange(offset, (int)remainingSize), 0, remainingSize); }
private static async Task WriteBufferAsync(IByteTarget target, IByteBuffer buffer, uint largeObjectSize) { var offset = 0; var remainingSize = buffer.Size; while (remainingSize > largeObjectSize) { var range = buffer.GetByteRange(offset, (int)largeObjectSize); await target.WriteAsync(range, 0, largeObjectSize).ConfigureAwait(false); offset += (int)largeObjectSize; remainingSize -= largeObjectSize; } target.Write(buffer.GetByteRange(offset, (int)remainingSize), 0, remainingSize); }
public IAsyncResult BeginWrite(IByteTarget target, DicomFileMetaInformation fileMetaInfo, DicomDataset dataset, AsyncCallback callback, object state) { _target = target; _fileMetaInfo = fileMetaInfo; _dataset = dataset; _async = new EventAsyncResult(callback, state); byte[] preamble = new byte[132]; preamble[128] = (byte)'D'; preamble[129] = (byte)'I'; preamble[130] = (byte)'C'; preamble[131] = (byte)'M'; _target.Write(preamble, 0, 132, OnCompletePreamble, null); return _async; }
public IAsyncResult BeginWrite(IByteTarget target, DicomFileMetaInformation fileMetaInfo, DicomDataset dataset, AsyncCallback callback, object state) { _target = target; _fileMetaInfo = fileMetaInfo; _dataset = dataset; _async = new EventAsyncResult(callback, state); byte[] preamble = new byte[132]; preamble[128] = (byte)'D'; preamble[129] = (byte)'I'; preamble[130] = (byte)'C'; preamble[131] = (byte)'M'; _target.Write(preamble, 0, 132, OnCompletePreamble, null); return(_async); }
//直接写入target,避免调用 public byte[] Data 占用内存 public void writeToTarget(IByteTarget target) { foreach (IByteBuffer buffer in Buffers) { if (buffer is PInvokeByteBuffer) { var pb = buffer as PInvokeByteBuffer; var rowBuffer = new byte[pb.RowBufferSize]; for (int i = 0; i < pb.Height; i++) { pb.GetByteRange(i, rowBuffer); target.Write(rowBuffer, 0, (uint)rowBuffer.Length); } rowBuffer = null; } else { var data = buffer.Data; target.Write(data, 0, (uint)data.Length); } } }
/// <summary> /// Write DICOM Part 10 object to <paramref name="target"/> asynchronously. /// </summary> /// <param name="target">Byte target subject to writing.</param> /// <param name="fileMetaInfo">File meta information.</param> /// <param name="dataset">Dataset.</param> /// <returns>Awaitable <see cref="Task"/>.</returns> public async Task WriteAsync(IByteTarget target, DicomFileMetaInformation fileMetaInfo, DicomDataset dataset) { await WritePreambleAsync(target).ConfigureAwait(false); await WriteFileMetaInfoAsync(target, fileMetaInfo, _options).ConfigureAwait(false); await WriteDatasetAsync(target, fileMetaInfo.TransferSyntax, dataset, _options).ConfigureAwait(false); }
private void OnEndWriteBuffer(IByteTarget target, object state) { _callback(); }
public void Write(IByteTarget target, DicomFileMetaInformation fileMetaInfo, DicomDataset dataset) { EndWrite(BeginWrite(target, fileMetaInfo, dataset, null, null)); }
public void writeToTarget(IByteTarget target) { throw new NotImplementedException(); }
public DicomWriter(DicomTransferSyntax syntax, DicomWriteOptions options, IByteTarget target) { _syntax = syntax; _options = new DicomWriteOptions(); _target = target; }
/// <summary> /// Write DICOM dataset. /// </summary> /// <param name="target">Byte target subject to writing.</param> /// <param name="syntax">Transfer syntax applicable to dataset.</param> /// <param name="dataset">Dataset.</param> /// <param name="options">Writer options.</param> private static async Task WriteDatasetAsync( IByteTarget target, DicomTransferSyntax syntax, DicomDataset dataset, DicomWriteOptions options) { UpdateDatasetGroupLengths(syntax, dataset, options); if (syntax.IsDeflate) { using (var uncompressed = new MemoryStream()) { var temp = new StreamByteTarget(uncompressed); await WalkDatasetAsync(temp, syntax, dataset, options).ConfigureAwait(false); uncompressed.Seek(0, SeekOrigin.Begin); using (var compressed = new MemoryStream()) using (var compressor = new DeflateStream(compressed, CompressionMode.Compress)) { uncompressed.CopyTo(compressor); target.Write(compressed.ToArray(), 0, (uint)compressed.Length); } } } else { await WalkDatasetAsync(target, syntax, dataset, options).ConfigureAwait(false); } }
private void OnCompletePreamble(IByteTarget target, object state) { DicomWriter writer = new DicomWriter(DicomTransferSyntax.ExplicitVRLittleEndian, _options, _target); DicomDatasetWalker walker = new DicomDatasetWalker(_fileMetaInfo); walker.BeginWalk(writer, OnCompleteFileMetaInfo, walker); }
/// <summary> /// Write DICOM dataset. /// </summary> /// <param name="target">Byte target subject to writing.</param> /// <param name="syntax">Transfer syntax applicable to dataset.</param> /// <param name="dataset">Dataset.</param> /// <param name="options">Writer options.</param> private static void WriteDataset( IByteTarget target, DicomTransferSyntax syntax, DicomDataset dataset, DicomWriteOptions options) { UpdateDatasetGroupLengths(syntax, dataset, options); if (syntax.IsDeflate) { #if NET35 throw new NotSupportedException("Deflated datasets not supported in Unity."); #else using (var uncompressed = new MemoryStream()) { var temp = new StreamByteTarget(uncompressed); WalkDataset(temp, syntax, dataset, options); uncompressed.Seek(0, SeekOrigin.Begin); using (var compressed = new MemoryStream()) using (var compressor = new DeflateStream(compressed, CompressionMode.Compress)) { uncompressed.CopyTo(compressor); target.Write(compressed.ToArray(), 0, (uint)compressed.Length); } } #endif } else { WalkDataset(target, syntax, dataset, options); } }
public DicomWriter(DicomTransferSyntax syntax, DicomWriteOptions options, IByteTarget target) { _syntax = syntax; _options = options ?? DicomWriteOptions.Default; _target = target; }
/// <summary> /// Write DICOM Part 10 object to <paramref name="target"/> asynchronously. /// </summary> /// <param name="target">Byte target subject to writing.</param> /// <param name="fileMetaInfo">File meta information.</param> /// <param name="dataset">Dataset.</param> /// <returns>Awaitable <see cref="Task"/>.</returns> public async Task WriteAsync(IByteTarget target, DicomFileMetaInformation fileMetaInfo, DicomDataset dataset) { await WritePreambleAsync(target).ConfigureAwait(false); await WriteFileMetaInfoAsync(target, fileMetaInfo, this.options).ConfigureAwait(false); await WriteDatasetAsync(target, fileMetaInfo.TransferSyntax, dataset, this.options).ConfigureAwait(false); }
/// <summary> /// Write DICOM Part 10 object to <paramref name="target"/>. /// </summary> /// <param name="target">Byte target subject to writing.</param> /// <param name="fileMetaInfo">File meta information.</param> /// <param name="dataset">Dataset.</param> public void Write(IByteTarget target, DicomFileMetaInformation fileMetaInfo, DicomDataset dataset) { WritePreamble(target); WriteFileMetaInfo(target, fileMetaInfo, this.options); WriteDataset(target, fileMetaInfo.TransferSyntax, dataset, this.options); }
/// <summary> /// Write DICOM dataset. /// </summary> /// <param name="target">Byte target subject to writing.</param> /// <param name="syntax">Transfer syntax applicable to dataset.</param> /// <param name="dataset">Dataset.</param> /// <param name="options">Writer options.</param> private static Task WriteDatasetAsync( IByteTarget target, DicomTransferSyntax syntax, DicomDataset dataset, DicomWriteOptions options) { UpdateDatasetGroupLengths(syntax, dataset, options); var writer = new DicomWriter(syntax, options, target); var walker = new DicomDatasetWalker(dataset); return walker.WalkAsync(writer); }
public void writeToTarget(IByteTarget target, IByteBuffer buffer) { throw new System.NotImplementedException(); }
/// <summary> /// Initializes an instance of <see cref="DicomWriter"/>. /// </summary> /// <param name="syntax">Writer transfer syntax.</param> /// <param name="options">Writer options.</param> /// <param name="target">Target to which to write the DICOM object.</param> public DicomWriter(DicomTransferSyntax syntax, DicomWriteOptions options, IByteTarget target) { _syntax = syntax; _options = options ?? DicomWriteOptions.Default; _target = target; }
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 WriteBufferAsync(IByteTarget target, IByteBuffer buffer, CancellationToken cancellationToken) => buffer.CopyToStreamAsync(target.AsWritableStream(), cancellationToken);
private static void WriteBuffer(IByteTarget target, IByteBuffer buffer) => buffer.CopyToStream(target.AsWritableStream());