/// <summary>
/// Save the file as a DICOM Part 10 format file.
/// </summary>
/// <param name="options">The options to use when saving the file.</param>
/// <param name="iStream">The <see cref="Stream"/> to Save the DICOM file to.</param>
/// <returns></returns>
public bool Save(Stream iStream, DicomWriteOptions options)
{
if (iStream == null)
{
throw new ArgumentNullException("iStream");
}
// Original code has seek() here, but there may be use cases where
// a user wants to add the file into a stream (that may contain other data)
// and the seek would cause the method to not support that.
byte[] prefix = new byte[128];
iStream.Write(prefix, 0, 128);
iStream.WriteByte((byte)'D');
iStream.WriteByte((byte)'I');
iStream.WriteByte((byte)'C');
iStream.WriteByte((byte)'M');
DicomStreamWriter dsw = new DicomStreamWriter(iStream);
dsw.Write(TransferSyntax.ExplicitVrLittleEndian,
MetaInfo, options | DicomWriteOptions.CalculateGroupLengths);
MetaInfoFileLength = iStream.Position;
dsw.Write(TransferSyntax, DataSet, options);
iStream.Flush();
return(true);
}
/// <summary>
/// Saves a DICOM file
/// </summary>
/// <param name="file">Filename</param>
/// <param name="options">DICOM write options</param>
public void Save(String file, DicomWriteOptions options)
{
string dir = Path.GetDirectoryName(file);
if (!Directory.Exists(dir))
{
Directory.CreateDirectory(dir);
}
using (FileStream fs = File.Create(file)) {
fs.Seek(128, SeekOrigin.Begin);
fs.WriteByte((byte)'D');
fs.WriteByte((byte)'I');
fs.WriteByte((byte)'C');
fs.WriteByte((byte)'M');
DicomStreamWriter dsw = new DicomStreamWriter(fs);
dsw.Write(_metainfo, options | DicomWriteOptions.CalculateGroupLengths);
if (_dataset != null)
{
dsw.Write(_dataset, options);
}
fs.Close();
}
}
public void OBAttributeOddLengthTests()
{
using(var ms = new MemoryStream())
{
var writer = new DicomStreamWriter(ms);
var ds = new DicomAttributeCollection();
var rawdata = new byte[] {0x0, 0x1, 0x2};
ds[DicomTags.EncapsulatedDocument].Values = rawdata;
writer.Write(TransferSyntax.ImplicitVrLittleEndian, ds, DicomWriteOptions.Default);
ms.Position = 0;
var output = ms.ToArray();
var expectedOutput = new byte[]
{
0x42, 0x00, 0x11, 0x00,
0x04, 0x00, 0x00, 0x00,
0x0, 0x1, 0x2, 0x0 /* pad */
};
Assert.AreEqual(output, expectedOutput);
}
}
internal void WriteArray(DicomStreamWriter writer, ReadOnlySpan <T> value)
{
var valueLength = Unsafe.SizeOf <T>() * value.Length;
writer.WriteVRWithDefinedValueLength(this, valueLength, out _);
writer.DataWriter.Write(value);
}
public void WriteValue(DicomStreamWriter writer, List <T> value)
{
using (var itemEnumerator = value.GetEnumerator())
{
writer.WriteSequenceItems(_serializer.Serialize, itemEnumerator);
}
}
public void WriteValues(DicomStreamWriter writer, string[] values)
{
if (values.Any(value => value.Contains('\\')))
{
throw new ArgumentException("value may not contain \\", nameof(values));
}
WriteEntireValue(writer, string.Join('\\', values));
}
public void WriteValues(DicomStreamWriter writer, DicomTag[] values)
{
writer.WriteVRWithDefinedValueLength(this, 4 * values.Length, out _);
foreach (var value in values)
{
value.WriteTo(writer.DataWriter);
}
}
/// <summary>
/// Saves a DICOM file in the isolated storage area
/// </summary>
/// <param name="file">Filename</param>
/// <param name="options">DICOM write options</param>
/// <param name="useIsoStore">Save in isolated storage</param>
public void Save(string file, DicomWriteOptions options, bool useIsoStore = false)
{
if (useIsoStore)
{
using (var store = IsolatedStorageFile.GetUserStoreForApplication())
{
string dir = Path.GetDirectoryName(file);
if (dir != null && !store.DirectoryExists(dir))
{
store.CreateDirectory(dir);
}
var fs = store.CreateFile(file);
fs.Seek(128, SeekOrigin.Begin);
fs.WriteByte((byte)'D');
fs.WriteByte((byte)'I');
fs.WriteByte((byte)'C');
fs.WriteByte((byte)'M');
DicomStreamWriter dsw = new DicomStreamWriter(fs);
dsw.Write(_metainfo, options | DicomWriteOptions.CalculateGroupLengths);
if (_dataset != null)
{
dsw.Write(_dataset, options);
}
fs.Close();
}
}
else
{
// expand to full path
file = Path.GetFullPath(file);
string dir = Path.GetDirectoryName(file);
if (!Directory.Exists(dir))
{
Directory.CreateDirectory(dir);
}
using (FileStream fs = File.Create(file))
{
fs.Seek(128, SeekOrigin.Begin);
fs.WriteByte((byte)'D');
fs.WriteByte((byte)'I');
fs.WriteByte((byte)'C');
fs.WriteByte((byte)'M');
DicomStreamWriter dsw = new DicomStreamWriter(fs);
dsw.Write(_metainfo, options | DicomWriteOptions.CalculateGroupLengths);
if (_dataset != null)
{
dsw.Write(_dataset, options);
}
fs.Close();
}
}
}
internal void ConvertAndWriteValues <T2>(DicomStreamWriter writer, Func <T2, T> convert, T2[] values)
{
var convertedValues = new T[values.Length];
for (var i = 0; i < values.Length; i++)
{
convertedValues[i] = convert(values[i]);
}
WriteValues(writer, convertedValues);
}
private static MemoryStream CreateNonPart10Stream(DicomAttributeCollection dataSet)
{
var memoryStream = new MemoryStream();
var streamWriter = new DicomStreamWriter(memoryStream);
streamWriter.TransferSyntax = TransferSyntax.ImplicitVrLittleEndian;
streamWriter.Write(TransferSyntax.ImplicitVrLittleEndian, dataSet, DicomWriteOptions.None);
memoryStream.Position = 0;
return(memoryStream);
}
internal void ConvertAndWriteValues <T>(DicomStreamWriter writer, Func <T, NumberFormatInfo, string> convert, T[] values)
{
var stringValues = new string[values.Length];
for (var i = 0; i < values.Length; i++)
{
stringValues[i] = convert(values[i], NumberFormatInfo.InvariantInfo);
}
WriteValues(writer, stringValues);
}
internal void WriteEntireValue(DicomStreamWriter writer, string value)
{
var bytes = Encoding.ASCII.GetBytes(value);
writer.WriteVRWithDefinedValueLength(this, bytes.Length, out bool pad);
writer.Output.WriteBytes(bytes);
if (pad)
{
writer.Output.WriteByte((byte)' ');
}
}
public void WriteValue(DicomStreamWriter writer, Array value)
{
if (value is byte[] bytes)
{
DicomVR.OB.WriteValue(writer, bytes);
}
else if (value is ushort[] words)
{
DicomVR.OW.WriteValue(writer, words);
}
else
{
throw new ArgumentException("value is not byte[] or ushort[]");
}
}
/// <summary>
/// Saves a DICOM file to a MemoryStream
/// </summary>
/// <param name="options">DICOM write options.</param>
/// <returns></returns>
public MemoryStream Save(DicomWriteOptions options)
{
MemoryStream ms = new MemoryStream();
ms.Seek(128, SeekOrigin.Begin);
ms.WriteByte((byte)'D');
ms.WriteByte((byte)'I');
ms.WriteByte((byte)'C');
ms.WriteByte((byte)'M');
DicomStreamWriter dsw = new DicomStreamWriter(ms);
dsw.Write(_metainfo, options | DicomWriteOptions.CalculateGroupLengths);
if (_dataset != null)
{
dsw.Write(_dataset, options);
}
return(ms);
}
public void TextAttributeEvenLengthTests()
{
using (var ms = new MemoryStream())
{
var writer = new DicomStreamWriter(ms);
var ds = new DicomAttributeCollection();
ds[DicomTags.PatientId].Values = "PatientID0";
writer.Write(TransferSyntax.ImplicitVrLittleEndian, ds, DicomWriteOptions.Default);
ms.Position = 0;
var output = ms.ToArray();
var expectedOutput = new byte[]
{
0x10, 0x00, 0x20, 0x00,
0x0A, 0x00, 0x00, 0x00,
0x50, 0x61, 0x74, 0x69, 0x65, 0x6E, 0x74, 0x49, 0x44, 0x30 /*PatientID0*/
};
Assert.AreEqual(output, expectedOutput);
}
}
public AuditQueryMessageParticipantObject(string sopClassUid, DicomAttributeCollection msg)
{
ParticipantObjectTypeCode = ParticipantObjectTypeCodeEnum.SystemObject;
ParticipantObjectTypeCodeRole = ParticipantObjectTypeCodeRoleEnum.Report;
ParticipantObjectIdTypeCodedValue = ParticipantObjectIDTypeCode.ClassUID;
ParticipantObjectId = sopClassUid;
ParticipantObjectDetail = new ParticipantObjectDetail()
{
type = "TransferSyntax",
value = System.Text.Encoding.ASCII.GetBytes(TransferSyntax.ExplicitVrLittleEndianUid)
};
MemoryStream ms = new MemoryStream();
DicomStreamWriter writer = new DicomStreamWriter(ms)
{
TransferSyntax = TransferSyntax.ExplicitVrLittleEndian
};
writer.Write(TransferSyntax.ExplicitVrLittleEndian, msg, DicomWriteOptions.Default);
ParticipantObjectQuery = ms.ToArray();
ParticipantObjectDetailString = CreateDetailsString(msg);
}
public void OBAttributeOddLengthTests()
{
using (var ms = new MemoryStream())
{
var writer = new DicomStreamWriter(ms);
var ds = new DicomAttributeCollection();
var rawdata = new byte[] { 0x0, 0x1, 0x2 };
ds[DicomTags.EncapsulatedDocument].Values = rawdata;
writer.Write(TransferSyntax.ImplicitVrLittleEndian, ds, DicomWriteOptions.Default);
ms.Position = 0;
var output = ms.ToArray();
var expectedOutput = new byte[]
{
0x42, 0x00, 0x11, 0x00,
0x04, 0x00, 0x00, 0x00,
0x0, 0x1, 0x2, 0x0 /* pad */
};
Assert.AreEqual(output, expectedOutput);
}
}
public void WriteSingleValue(DicomStreamWriter writer, T value)
{
writer.WriteVRWithDefinedValueLength(this, Unsafe.SizeOf <T>(), out _);
writer.DataWriter.Write(value);
}
void IMultiValue <int> .WriteValues(DicomStreamWriter writer, int[] values) => ConvertAndWriteValues(writer, Convert.ToString, values);
void IMultiValue <T> .WriteSingleValue(DicomStreamWriter writer, T value) => ConvertAndWriteSingleValue(writer, ToString, value);
void IMultiValue <byte> .WriteValues(DicomStreamWriter writer, byte[] values) => ConvertAndWriteValues(writer, Convert.ToString, values);
void IMultiValue <int> .WriteSingleValue(DicomStreamWriter writer, int value) => ConvertAndWriteSingleValue(writer, o => (ushort)o, value);
void IMultiValue <T> .WriteValues(DicomStreamWriter writer, T[] values) => ConvertAndWriteValues(writer, ToString, values);
public void WriteSingleValue(DicomStreamWriter writer, DicomTag value)
{
writer.WriteVRWithDefinedValueLength(this, 4, out _);
value.WriteTo(writer.DataWriter);
}
void IMultiValue <byte> .WriteSingleValue(DicomStreamWriter writer, byte value) => ConvertAndWriteSingleValue(writer, Convert.ToString, value);
public void WriteValues(DicomStreamWriter writer, T[] values) => WriteArray(writer, values);
public virtual void WriteValue(DicomStreamWriter writer, T[] value) => WriteArray(writer, value);
public void WriteSingleValue(DicomStreamWriter writer, string value) => WriteEntireValue(writer, value);
public void TextAttributeEvenLengthTests()
{
using (var ms = new MemoryStream())
{
var writer = new DicomStreamWriter(ms);
var ds = new DicomAttributeCollection();
ds[DicomTags.PatientId].Values = "PatientID0";
writer.Write(TransferSyntax.ImplicitVrLittleEndian, ds, DicomWriteOptions.Default);
ms.Position = 0;
var output = ms.ToArray();
var expectedOutput = new byte[]
{
0x10, 0x00, 0x20, 0x00,
0x0A, 0x00, 0x00, 0x00,
0x50, 0x61,0x74,0x69,0x65,0x6E,0x74,0x49,0x44,0x30 /*PatientID0*/
};
Assert.AreEqual(output, expectedOutput);
}
}
internal void ConvertAndWriteSingleValue <T>(DicomStreamWriter writer, Func <T, NumberFormatInfo, string> convert, T value)
{
var stringValue = convert(value, NumberFormatInfo.InvariantInfo);
WriteSingleValue(writer, stringValue);
}
protected void ConvertAndWriteSingleValue <T2>(DicomStreamWriter writer, Func <T2, T> convert, T2 value)
{
var convertedValue = convert(value);
WriteSingleValue(writer, convertedValue);
}
void IMultiValue <int> .WriteValues(DicomStreamWriter writer, int[] values) => ConvertAndWriteValues(writer, o => (ushort)o, values);
