public void WriteDecimalString()
{
var ds = new DecimalString();
ds.DData_ = Enumerable.Range(1, 15000).Select(i => ((double)i) + 0.005).ToList();
ds.Tag = new Tag("00082130");
byte[] written;
var settings = DICOMWriteSettings.Default();
using (var ms = new MemoryStream())
{
using (var dw = new DICOMBinaryWriter(ms))
{
DICOMElementWriter.Write(dw, DICOMWriteSettings.Default(), ds);
}
written = ms.ToArray();
}
using (var dr = new DICOMBinaryReader(written))
{
var read = DICOMElementReader.ReadElementImplicitLittleEndian(dr) as DecimalString;
CollectionAssert.AreEqual(ds.DData_, read.Data_);
}
}
public static void Write(DICOMBinaryWriter dw, VR vr, DICOMWriteSettings settings, int length)
{
var lengthBytes = BitConverter.GetBytes(length);
if (settings.TransferSyntax != TransferSyntax.IMPLICIT_VR_LITTLE_ENDIAN)
{
//Length byte size depends on VR Encoding
switch (VRDictionary.GetEncodingFromVR(vr))
{
case VREncoding.ExplicitLong:
dw.WriteNullBytes(2);
lengthBytes = BitConverter.GetBytes(length);
break;
case VREncoding.ExplicitShort:
lengthBytes = BitConverter.GetBytes((ushort) length);
if (length > 65536) { throw new ArgumentOutOfRangeException("Length is greater than allowed for explicit VR syntax. Try using implicit VR"); }
break;
case VREncoding.Implicit:
lengthBytes = BitConverter.GetBytes(length);
break;
}
}
if (settings.TransferSyntax == TransferSyntax.EXPLICIT_VR_BIG_ENDIAN)
{
Array.Reverse(lengthBytes);
}
dw.Write(lengthBytes);
}
public static void WriteLittleEndian(DICOMBinaryWriter dw, VR vr, DICOMWriteSettings settings,
IDICOMElement toWrite)
{
byte[] data = DataComposer.GetDataLittleEndian(toWrite);
LengthWriter.Write(dw, vr, settings, data != null ? data.Length : 0);
dw.Write(data != null ? data : new byte[0]);
}
public static void WriteBigEndian(DICOMBinaryWriter dw, DICOMWriteSettings settings, IDICOMElement toWrite)
{
DICOMTagWriter.WriteBigEndian(dw, toWrite.Tag);
VR vr = VRDictionary.GetVRFromType(toWrite);
VRWriter.WriteVR(dw, settings, vr);
DataWriter.WriteBigEndian(dw, vr, settings, toWrite);
}
/// <summary>
/// Splits the DICOM object into chunks that are within the max PDU size
/// </summary>
/// <param name="dicomObject"> the DICOM objec to be split</param>
/// <param name="maxPduSize">the max length (in bytes) for a PDU</param>
/// <param name="asc">the association that the file will be sent</param>
/// <returns></returns>
public static List<byte[]> GetChunks(DICOMObject dicomObject, int maxPduSize, PresentationContext pc)
{
byte[] dicomBytes;
using (var stream = new MemoryStream())
{
using (var dw = new DICOMBinaryWriter(stream))
{
var tx = TransferSyntaxHelper.GetSyntax(pc.TransferSyntaxes.First());
DICOMObjectWriter.WriteSameSyntax(dw,
new DICOMWriteSettings
{
TransferSyntax = tx,
DoWriteIndefiniteSequences = false
}, dicomObject);
dicomBytes = stream.ToArray();
}
}
var split = new List<byte[]>();
int i = 0;
while (i < dicomBytes.Length)
{
int toTake = dicomBytes.Length >= (maxPduSize - 6) ? maxPduSize - 6 : dicomBytes.Length;
byte[] fragment = dicomBytes.Skip(i).Take(toTake).ToArray();
i += fragment.Length;
split.Add(fragment);
}
return split;
}
public PDataTF(DICOMObject dicom, bool isLastItem, bool isCommandObject, PresentationContext context)
: this()
{
byte[] data;
using (var stream = new MemoryStream())
{
using (var dw = new DICOMBinaryWriter(stream))
{
var settings = new DICOMWriteSettings();
settings.TransferSyntax = isCommandObject
? TransferSyntax.IMPLICIT_VR_LITTLE_ENDIAN
: TransferSyntaxHelper.GetSyntax(context.TransferSyntaxes[0]);
DICOMObjectWriter.Write(dw, settings, dicom);
data = stream.ToArray();
}
}
var frag = new PDVItemFragment();
frag.Data = data;
frag.IsLastItem = isLastItem;
frag.IsCommandObject = isCommandObject;
var item = new PDVItem();
item.Fragment = frag;
item.PresentationContextID = context.Id;
Items.Add(item);
}
public static void Write(DICOMBinaryWriter dw, VR vr, DICOMWriteSettings settings, int length)
{
var lengthBytes = BitConverter.GetBytes(length);
if (settings.TransferSyntax != TransferSyntax.IMPLICIT_VR_LITTLE_ENDIAN)
{
switch (VRDictionary.GetEncodingFromVR(vr))
{
case VREncoding.ExplicitLong:
dw.WriteNullBytes(2);
lengthBytes = BitConverter.GetBytes(length);
break;
case VREncoding.ExplicitShort:
lengthBytes = BitConverter.GetBytes((ushort)length);
if (length > 65536)
{
throw new ArgumentOutOfRangeException(
"Length is greater than allowed for explicit VR syntax. Try using implicit VR");
}
break;
case VREncoding.Implicit:
lengthBytes = BitConverter.GetBytes(length);
break;
}
}
if (settings.TransferSyntax == TransferSyntax.EXPLICIT_VR_BIG_ENDIAN)
{
Array.Reverse(lengthBytes);
}
dw.Write(lengthBytes);
}
public static void Write(DICOMBinaryWriter dw, VR vr, DICOMWriteSettings settings, int length)
{
var lengthBytes = BitConverter.GetBytes(length);
if (settings.TransferSyntax != TransferSyntax.IMPLICIT_VR_LITTLE_ENDIAN)
{
//Length byte size depends on VR Encoding
switch (VRDictionary.GetEncodingFromVR(vr))
{
case VREncoding.ExplicitLong:
dw.WriteNullBytes(2);
lengthBytes = BitConverter.GetBytes(length);
break;
case VREncoding.ExplicitShort:
lengthBytes = BitConverter.GetBytes((ushort) length);
break;
case VREncoding.Implicit:
lengthBytes = BitConverter.GetBytes(length);
break;
}
}
if (settings.TransferSyntax == TransferSyntax.EXPLICIT_VR_BIG_ENDIAN)
{
Array.Reverse(lengthBytes);
}
dw.Write(lengthBytes);
}
public static void WriteMaxLength(DICOMBinaryWriter dw, int length)
{
dw.Write((byte) ItemType.MAXIMUM_LENGTH);
dw.WriteNullBytes(1); // Reserved Null Byte
LengthWriter.WriteBigEndian(dw, 4, 2);
LengthWriter.WriteBigEndian(dw, length, 4);
}
public static void WriteLittleEndian(DICOMBinaryWriter dw, VR vr, DICOMWriteSettings settings, int length)
{
byte[] lengthBytes = new byte[0];
if (!(settings.TransferSyntax == TransferSyntax.IMPLICIT_VR_LITTLE_ENDIAN))
{
switch (VRDictionary.GetEncodingFromVR(vr))
{
case VREncoding.ExplicitLong:
dw.WriteNullBytes(2);
lengthBytes = BitConverter.GetBytes(length);
break;
case VREncoding.ExplicitShort:
lengthBytes = BitConverter.GetBytes((short)length);
break;
case VREncoding.Implicit:
lengthBytes = BitConverter.GetBytes(length);
break;
}
}
else
{
lengthBytes =BitConverter.GetBytes(length);
}
dw.Write(lengthBytes);
}
public static void Write(DICOMBinaryWriter dw, DICOMIOSettings settings, DICOMObject d,
bool isSequenceItem = false)
{
if (!isSequenceItem)
{
TransferSyntaxHelper.SetSyntax(d, settings.TransferSyntax);
}
for (var i = 0; i < d.Elements.Count; i++)
{
var el = d.Elements[i];
var currentSettings = IsFileMetaGroup(el) ? settings.GetFileMetaSettings() : settings;
if (GroupWriter.IsGroupHeader(el))
{
var skip = GroupWriter.WriteGroup(dw, currentSettings, d, el);
i += skip;
}
else
{
_logger.LogInformation($"Writing element ${el.Tag.CompleteID}");
try
{
DICOMElementWriter.Write(dw, currentSettings, el);
}
catch (Exception e)
{
_logger.LogError($"Error writing : ${el.Tag.CompleteID}\n{e}");
throw e;
}
}
}
}
public static void WriteBigEndian(DICOMBinaryWriter dw, DICOMWriteSettings settings, IDICOMElement toWrite)
{
DICOMTagWriter.WriteBigEndian(dw, toWrite.Tag);
VR vr = VRDictionary.GetVRFromType(toWrite);
VRWriter.WriteVR(dw, settings, vr);
}
public static void Write(DICOMBinaryWriter dw, VR vr, DICOMWriteSettings settings, int length)
{
var lengthBytes = new byte[0];
if (!(settings.TransferSyntax == TransferSyntax.IMPLICIT_VR_LITTLE_ENDIAN))
{
switch (VRDictionary.GetEncodingFromVR(vr))
{
case VREncoding.ExplicitLong:
dw.WriteNullBytes(2);
lengthBytes = BitConverter.GetBytes(length);
break;
case VREncoding.ExplicitShort:
lengthBytes = BitConverter.GetBytes((ushort)length);
break;
case VREncoding.Implicit:
lengthBytes = BitConverter.GetBytes(length);
break;
}
}
else if (settings.TransferSyntax == TransferSyntax.EXPLICIT_VR_BIG_ENDIAN)
{
lengthBytes = BitConverter.GetBytes(length);
lengthBytes.Reverse();
}
else
{
//Explicit VR Little Endian
lengthBytes = BitConverter.GetBytes(length);
}
dw.Write(lengthBytes);
}
public static void WriteLittleEndian(DICOMBinaryWriter dw, VR vr, DICOMWriteSettings settings,
IDICOMElement toWrite)
{
byte[] data = DataComposer.GetDataLittleEndian(toWrite);
LengthWriter.Write(dw, vr, settings, data != null ? data.Length : 0);
dw.Write(data != null ? data : new byte[0]);
}
private static void WriteIndefiniteLength(DICOMWriteSettings settings, DICOMBinaryWriter dw)
{
if (!(settings.TransferSyntax == TransferSyntax.IMPLICIT_VR_LITTLE_ENDIAN))
{
dw.WriteNullBytes(2);
}
dw.Write(new byte[] {0xFF, 0xFF, 0xFF, 0xFF});
}
public static void WriteVR(DICOMBinaryWriter dw, DICOMWriteSettings settings, VR vr)
{
if (!(settings.TransferSyntax == TransferSyntax.IMPLICIT_VR_LITTLE_ENDIAN))
{
string abbreviation = VRDictionary.GetAbbreviationFromVR(vr);
dw.Write(abbreviation);
}
}
public static void WriteVR(DICOMBinaryWriter dw, DICOMWriteSettings settings, VR vr)
{
if (settings.TransferSyntax != TransferSyntax.IMPLICIT_VR_LITTLE_ENDIAN)
{
string abbreviation = VRDictionary.GetAbbreviationFromVR(vr);
dw.Write(abbreviation);
}
}
private static void WriteIndefiniteLength(DICOMWriteSettings settings, DICOMBinaryWriter dw)
{
if (!(settings.TransferSyntax == TransferSyntax.IMPLICIT_VR_LITTLE_ENDIAN))
{
dw.WriteNullBytes(2);
}
dw.Write(new byte[] { 0xFF, 0xFF, 0xFF, 0xFF });
}
public static void WriteBigEndian(DICOMBinaryWriter dw, VR vr, DICOMIOSettings settings,
IDICOMElement toWrite)
{
var data = DataComposer.GetDataBigEndian(toWrite, settings.StringEncoding);
LengthWriter.Write(dw, vr, settings, data != null ? data.Length : 0);
dw.Write(data != null ? data : new byte[0]);
}
public static void Write(string filePath, DICOMWriteSettings settings, DICOMObject toWrite)
{
using (DICOMBinaryWriter dw = new DICOMBinaryWriter(filePath))
{
DICOMPreambleWriter.Write(dw);
TransferSyntaxHelper.SetSyntax(toWrite, settings.TransferSyntax);
DICOMObjectWriter.WriteObjectLittleEndian(dw, settings, toWrite);
}
}
private static void WritePDVFragmentMessageHeader(DICOMBinaryWriter dw, PDVItemFragment frag)
{
var bits = new BitArray(8);
bits.Set(0, frag.IsCommandObject);
bits.Set(1, frag.IsLastItem);
var bytes = new byte[1];
bits.CopyTo(bytes, 0);
dw.Write(bytes[0]);
}
public static void WriteVR(DICOMBinaryWriter dw, DICOMWriteSettings settings, IDICOMElement toWrite)
{
if (!(settings.TransferSyntax == TransferSyntax.IMPLICIT_VR_LITTLE_ENDIAN))
{
VR vr = VRDictionary.GetVRFromType(toWrite);
string abbreviation = VRDictionary.GetAbbreviationFromVR(vr);
dw.Write(abbreviation);
}
}
public static void WriteLittleEndian(string filePath, DICOMWriteSettings settings, DICOMObject toWrite)
{
using (DICOMBinaryWriter dw = new DICOMBinaryWriter(filePath))
{
DICOMPreambleWriter.Write(dw);
TransferSyntaxHelper.SetSyntax(toWrite, settings.TransferSyntax);
DICOMObjectWriter.WriteObjectLittleEndian(dw, settings, toWrite);
}
}
/// <summary>
/// Write DICOM file out (bytes) to a specified stream
/// </summary>
/// <param name="stream">the stream to which to write the file</param>
/// <param name="settings">the write settings</param>
/// <param name="toWrite">the object to write</param>
public static void Write(Stream stream, DICOMWriteSettings settings, DICOMObject toWrite)
{
settings = settings ?? DICOMWriteSettings.Default();
using (var dw = new DICOMBinaryWriter(stream))
{
DICOMPreambleWriter.Write(dw);
TransferSyntaxHelper.SetSyntax(toWrite, settings.TransferSyntax);
DICOMObjectWriter.Write(dw, settings, toWrite);
}
}
/// <summary>
/// Write DICOM file out (bytes) to a specified stream
/// </summary>
/// <param name="stream">the stream to which to write the file</param>
/// <param name="settings">the write settings</param>
/// <param name="toWrite">the object to write</param>
public static void Write(Stream stream, DICOMWriteSettings settings, DICOMObject toWrite)
{
settings = settings ?? DICOMWriteSettings.Default();
using (var dw = new DICOMBinaryWriter(stream))
{
DICOMPreambleWriter.Write(dw);
TransferSyntaxHelper.SetSyntax(toWrite, settings.TransferSyntax);
DICOMObjectWriter.Write(dw, settings, toWrite);
}
}
public static int WriteGroup(DICOMBinaryWriter dw, DICOMWriteSettings settings, DICOMObject d, IDICOMElement el)
{
byte[] groupBytes = WriteGroupBytes(d, settings, el.Tag.Group);
int length = groupBytes.Length;
var ul = el as UnsignedLong;
ul.SetData((uint) length);
DICOMElementWriter.Write(dw, settings, ul);
dw.Write(groupBytes);
return d.Elements.Where(elm => elm.Tag.Group == ul.Tag.Group).ToList().Count - 1;
}
private static void WriteUIDItem(DICOMBinaryWriter dw, ItemType iType, string uid)
{
if (!string.IsNullOrEmpty(uid))
{
dw.Write((byte) iType);
dw.WriteNullBytes(1); // Reserved Null Byte
LengthWriter.WriteBigEndian(dw, uid.Length, 2);
dw.Write(uid);
}
}
public static void Write(DICOMBinaryWriter dw, DICOMWriteSettings settings, IDICOMElement el)
{
if (settings.TransferSyntax == TransferSyntax.EXPLICIT_VR_BIG_ENDIAN)
{
WriteBigEndian(dw, settings, el);
}
else
{
WriteLittleEndian(dw, settings, el);
}
}
public static void Write(DICOMBinaryWriter dw, DICOMWriteSettings settings, IDICOMElement el)
{
if (settings.TransferSyntax == TransferSyntax.EXPLICIT_VR_BIG_ENDIAN)
{
WriteBigEndian(dw, settings, el);
}
else
{
WriteLittleEndian(dw, settings, el);
}
}
public static int WriteGroupLittleEndian(DICOMBinaryWriter dw, DICOMWriteSettings settings, DICOMObject d, IDICOMElement el)
{
byte[] groupBytes = WriteGroupBytesLittleEndian(d, settings, el.Tag.Group);
int length = groupBytes.Length;
UnsignedLong ul = el as UnsignedLong;
ul.SetData((uint)length);
DICOMElementWriter.WriteLittleEndian(dw, settings, ul);
dw.Write(groupBytes);
return(d.Elements.Where(elm => elm.Tag.Group == ul.Tag.Group).ToList().Count - 1);
}
public static void WriteAsyncOperations(DICOMBinaryWriter dw, AsyncOperations ao)
{
if (ao != null)
{
dw.Write((byte) ItemType.ASYNCHRONOUS_OPERATIONS_WINDOW);
dw.WriteNullBytes(1); // Reserved Null Byte
LengthWriter.WriteBigEndian(dw, 4, 2);
LengthWriter.WriteBigEndian(dw, ao.MaxInvokeOperations, 2);
LengthWriter.WriteBigEndian(dw, ao.MaxPerformOperations, 2);
}
}
public static int WriteGroup(DICOMBinaryWriter dw, DICOMIOSettings settings, DICOMObject d, IDICOMElement el)
{
var groupBytes = WriteGroupBytes(d, settings, el.Tag.Group);
var length = groupBytes.Length;
var ul = el as UnsignedLong;
ul.SetData((uint)length);
DICOMElementWriter.Write(dw, settings, ul);
dw.Write(groupBytes);
return(d.Elements.Where(elm => elm.Tag.Group == ul.Tag.Group).ToList().Count - 1);
}
public static void WriteLittleEndian(DICOMBinaryWriter dw, int length, int numberOfBytes)
{
byte[] lengthBytes = new byte[0];
switch (numberOfBytes)
{
case 2: lengthBytes = BitConverter.GetBytes((short)length);
break;
case 4: lengthBytes = BitConverter.GetBytes(length);
break;
}
dw.Write(lengthBytes);
}
public static void WriteBigEndian(DICOMBinaryWriter dw, int length, int numberOfBytes)
{
byte[] lengthBytes = new byte[0];
switch (numberOfBytes)
{
case 2: lengthBytes = BitConverter.GetBytes((short)length).Reverse().ToArray();
break;
case 4: lengthBytes = BitConverter.GetBytes(length).Reverse().ToArray();
break;
}
dw.Write(lengthBytes);
}
public static void WriteBigEndian(DICOMBinaryWriter dw, int length, int numberOfBytes)
{
var lengthBytes = new byte[0];
switch (numberOfBytes)
{
case 2:
lengthBytes = BitConverter.GetBytes((ushort) length).Reverse().ToArray();
break;
case 4:
lengthBytes = BitConverter.GetBytes(length).Reverse().ToArray();
break;
}
dw.Write(lengthBytes);
}
public static void WriteLittleEndian(DICOMBinaryWriter dw, DICOMWriteSettings settings, IDICOMElement toWrite)
{
VR vr = VRDictionary.GetVRFromType(toWrite);
if (vr == VR.Sequence)
{
SequenceWriter.WriteLittleEndian(dw, settings, toWrite);
}
else
{
DICOMTagWriter.WriteLittleEndian(dw, toWrite.Tag);
VRWriter.WriteVR(dw, settings, vr);
DataWriter.WriteLittleEndian(dw, vr, settings, toWrite);
}
}
public static void WriteBigEndian(DICOMBinaryWriter dw, int length, int numberOfBytes)
{
byte[] lengthBytes=null;
switch (numberOfBytes)
{
case 2:
lengthBytes = BitConverter.GetBytes((ushort) length);
break;
case 4:
lengthBytes = BitConverter.GetBytes(length);
break;
}
Array.Reverse(lengthBytes);
dw.Write(lengthBytes);
}
public static void WriteLittleEndian(DICOMBinaryWriter dw, DICOMWriteSettings settings, IDICOMElement toWrite)
{
VR vr = VRDictionary.GetVRFromType(toWrite);
if (vr == VR.Sequence)
{
SequenceWriter.WriteLittleEndian(dw, settings, toWrite);
}
else
{
DICOMTagWriter.WriteLittleEndian(dw, toWrite.Tag);
VRWriter.WriteVR(dw, settings, vr);
DataWriter.WriteLittleEndian(dw, vr, settings, toWrite);
}
}
public static void WriteLittleEndian(DICOMBinaryWriter dw, int length, int numberOfBytes)
{
var lengthBytes = new byte[0];
switch (numberOfBytes)
{
case 2:
lengthBytes = BitConverter.GetBytes((short)length);
break;
case 4:
lengthBytes = BitConverter.GetBytes(length);
break;
}
dw.Write(lengthBytes);
}
public byte[] Write()
{
var written = new byte[0];
var stream = new MemoryStream();
using (var dw = new DICOMBinaryWriter(stream))
{
dw.Write((byte)PDUType.A_ABORT);
dw.WriteNullBytes(1); //Reserved Null byte
LengthWriter.WriteBigEndian(dw, 4, 4);
dw.WriteNullBytes(2); //Reserved Null bytes
dw.Write((byte)Source);
dw.Write((byte)Reason);
written = stream.ToArray();
}
return written;
}
public static void WritePDVItem(DICOMBinaryWriter dw, PDVItem pdv)
{
//Write fragment first so we have length
var fragment = new byte[0];
using (var stream = new MemoryStream())
{
using (var fragDw = new DICOMBinaryWriter(stream))
{
WritePDVFragment(fragDw, pdv.Fragment);
fragment = stream.ToArray();
}
}
LengthWriter.WriteBigEndian(dw, fragment.Length + 1, 4);
dw.Write((byte) pdv.PresentationContextID);
dw.Write(fragment);
}
public static void WriteObjectLittleEndian(DICOMBinaryWriter dw, DICOMWriteSettings settings, DICOMObject d)
{
for (int i = 0; i < d.Elements.Count; i++)
{
IDICOMElement el = d.Elements[i];
DICOMWriteSettings currentSettings = IsFileMetaGroup(el) ? settings.GetFileMetaSettings() : settings;
if (GroupWriter.IsGroupHeader(el))
{
int skip = GroupWriter.WriteGroupLittleEndian(dw, currentSettings, d, el);
i += skip;
}
else
{
DICOMElementWriter.WriteLittleEndian(dw, currentSettings, el);
}
}
}
public static byte[] WriteItemsLittleEndian(DICOMWriteSettings settings, List <DICOMObject> items)
{
byte[] allItemBytes;
using (var stream = new MemoryStream())
{
using (var itemDw = new DICOMBinaryWriter(stream))
{
foreach (var d in items)
{
WriteItemLittleEndian(itemDw, settings, d);
}
}
allItemBytes = stream.ToArray();
}
return(allItemBytes);
}
public byte[] Write()
{
var written = new byte[0];
using (var stream = new MemoryStream())
{
using (var dw = new DICOMBinaryWriter(stream))
{
dw.Write((byte)PDUType.A_ASSOC_ACCEPT);
dw.WriteNullBytes(1); //Reserved Null byte
byte[] body = WriteBody();
LengthWriter.WriteBigEndian(dw, body.Length, 4);
dw.Write(body);
written = stream.ToArray();
}
}
return written;
}
/// <summary>
/// Ignores the rule of writing metadata in explicit VR little endian and instead writes all elements with the same passed in syntax
/// Used in PData writing
/// </summary>
/// <param name="dw"></param>
/// <param name="settings"></param>
/// <param name="d"></param>
/// <param name="isSequenceItem"></param>
public static void WriteSameSyntax(DICOMBinaryWriter dw, DICOMIOSettings settings, DICOMObject d,
bool isSequenceItem = false)
{
for (var i = 0; i < d.Elements.Count; i++)
{
var el = d.Elements[i];
if (GroupWriter.IsGroupHeader(el))
{
var skip = GroupWriter.WriteGroup(dw, settings, d, el);
i += skip;
}
else
{
DICOMElementWriter.Write(dw, settings, el);
}
}
}
public byte[] Write()
{
var written = new byte[0];
using (var stream = new MemoryStream())
{
using (var dw = new DICOMBinaryWriter(stream))
{
dw.Write((byte) PDUType.P_DATA_TRANSFER);
dw.WriteNullBytes(1); //Reserved Null byte
byte[] items = WriteItems();
LengthWriter.WriteBigEndian(dw, items.Length, 4);
dw.Write(items);
written = stream.ToArray();
}
}
return written;
}
public static byte[] WriteItemsLittleEndian(DICOMWriteSettings settings, List<DICOMObject> items)
{
byte[] allItemBytes;
using (var stream = new MemoryStream())
{
using (var itemDw = new DICOMBinaryWriter(stream))
{
foreach (DICOMObject d in items)
{
WriteItemLittleEndian(itemDw, settings, d);
}
}
allItemBytes = stream.ToArray();
}
return allItemBytes;
}
public static void WriteObjectLittleEndian(DICOMBinaryWriter dw, DICOMWriteSettings settings, DICOMObject d)
{
for (int i = 0; i < d.Elements.Count; i++)
{
IDICOMElement el = d.Elements[i];
DICOMWriteSettings currentSettings = IsFileMetaGroup(el) ? settings.GetFileMetaSettings() : settings;
if (GroupWriter.IsGroupHeader(el))
{
int skip = GroupWriter.WriteGroupLittleEndian(dw, currentSettings, d, el);
i += skip;
}
else
{
DICOMElementWriter.WriteLittleEndian(dw, currentSettings, el);
}
}
}
public static void Write(DICOMBinaryWriter dw, DICOMWriteSettings settings, DICOMObject d)
{
for (int i = 0; i < d.Elements.Count; i++)
{
IDICOMElement el = d.Elements[i];
TransferSyntaxHelper.SetSyntax(d,settings.TransferSyntax);
DICOMWriteSettings currentSettings = IsFileMetaGroup(el) ? settings.GetFileMetaSettings() : settings;
if (GroupWriter.IsGroupHeader(el))
{
int skip = GroupWriter.WriteGroup(dw, currentSettings, d, el);
i += skip;
}
else
{
DICOMElementWriter.Write(dw, currentSettings, el);
}
}
}
public static void WriteLittleEndian(DICOMBinaryWriter dw, DICOMWriteSettings settings, IDICOMElement toWrite)
{
var s = toWrite as Sequence;
DICOMTagWriter.WriteLittleEndian(dw, toWrite.Tag);
VRWriter.WriteVR(dw, settings, VR.Sequence);
if (settings.DoWriteIndefiniteSequences)
{
WriteIndefiniteLength(settings, dw);
SequenceItemWriter.WriteItemsLittleEndian(dw, settings, s.Items);
WriteEndOfSequenceLittleEndian(dw);
}
else
{
byte[] itemsBytes = SequenceItemWriter.WriteItemsLittleEndian(settings, s.Items);
LengthWriter.Write(dw, VR.Sequence, settings, itemsBytes.Length);
dw.Write(itemsBytes);
}
}
public static void WriteLittleEndian(DICOMBinaryWriter dw, DICOMWriteSettings settings, IDICOMElement toWrite)
{
Sequence s = toWrite as Sequence;
DICOMTagWriter.WriteLittleEndian(dw, toWrite.Tag);
VRWriter.WriteVR(dw, settings, VR.Sequence);
if (settings.DoWriteIndefiniteSequences)
{
WriteIndefiniteLength(settings, dw);
SequenceItemWriter.WriteItemsLittleEndian(dw, settings, s.Items);
WriteEndOfSequenceLittleEndian(dw);
}
else
{
byte[] itemsBytes = SequenceItemWriter.WriteItemsLittleEndian(settings, s.Items);
LengthWriter.Write(dw, VR.Sequence, settings, itemsBytes.Length);
dw.Write(itemsBytes);
}
}
/// <summary>
/// Ignores the rule of writing metadata in explicit VR little endian and instead writes all elements with the passed in syntax
/// </summary>
/// <param name="dw"></param>
/// <param name="settings"></param>
/// <param name="d"></param>
/// <param name="isSequenceItem"></param>
public static void WriteSameSyntax(DICOMBinaryWriter dw, DICOMWriteSettings settings, DICOMObject d, bool isSequenceItem = false)
{
for (int i = 0; i < d.Elements.Count; i++)
{
IDICOMElement el = d.Elements[i];
if (!isSequenceItem)
{
TransferSyntaxHelper.SetSyntax(d, settings.TransferSyntax);
}
if (GroupWriter.IsGroupHeader(el))
{
int skip = GroupWriter.WriteGroup(dw, settings, d, el);
i += skip;
}
else
{
DICOMElementWriter.Write(dw, settings, el);
}
}
}
public static void WriteItemLittleEndian(DICOMBinaryWriter dw, DICOMWriteSettings settings, DICOMObject d)
{
DICOMTagWriter.WriteLittleEndian(dw, TagHelper.Item);
using (var stream = new MemoryStream())
{
using (var itemDw = new DICOMBinaryWriter(stream))
{
DICOMObjectWriter.Write(itemDw, settings, d, true);
if (!settings.DoWriteIndefiniteSequences)
{
LengthWriter.Write(dw, VR.Null, settings, (int)stream.Length);
dw.Write(stream.ToArray());
}
else
{
WriteIndefiniteLittleEndian(dw, stream.ToArray());
}
}
}
}
public static byte[] WriteGroupBytes(DICOMObject d, DICOMIOSettings settings, string groupId)
{
var groupElements = d.Elements.Where(el => el.Tag.Group == groupId).ToList();
byte[] groupBytes;
using (var stream = new MemoryStream())
{
using (var groupDW = new DICOMBinaryWriter(stream))
{
foreach (var el in groupElements)
{
if (!IsGroupHeader(el))
{
DICOMElementWriter.Write(groupDW, settings, el);
}
}
}
groupBytes = stream.ToArray();
}
return(groupBytes);
}
private static byte[] WriteGroupBytesLittleEndian(DICOMObject d, DICOMWriteSettings settings, string groupID)
{
List <IDICOMElement> groupElements = d.Elements.Where(el => el.Tag.Group == groupID).ToList();
byte[] groupBytes;
using (MemoryStream stream = new MemoryStream())
{
using (DICOMBinaryWriter groupDW = new DICOMBinaryWriter(stream))
{
foreach (IDICOMElement el in groupElements)
{
if (!IsGroupHeader(el))
{
DICOMElementWriter.WriteLittleEndian(groupDW, settings, el);
}
}
}
groupBytes = stream.ToArray();
}
return(groupBytes);
}
public static void Write(DICOMBinaryWriter dw, DICOMWriteSettings settings, DICOMObject d,
bool isSequenceItem = false)
{
for (var i = 0; i < d.Elements.Count; i++)
{
var el = d.Elements[i];
if (!isSequenceItem)
{
TransferSyntaxHelper.SetSyntax(d, settings.TransferSyntax);
}
var currentSettings = IsFileMetaGroup(el) ? settings.GetFileMetaSettings() : settings;
if (GroupWriter.IsGroupHeader(el))
{
var skip = GroupWriter.WriteGroup(dw, currentSettings, d, el);
i += skip;
}
else
{
DICOMElementWriter.Write(dw, currentSettings, el);
}
}
}
private static void WriteEndOfSequenceBigEndian(DICOMBinaryWriter dw)
{
dw.Write(_endOfSequence_BE);
}
private static void WriteEndOfSequenceLittleEndian(DICOMBinaryWriter dw)
{
dw.Write(_endOfSequence_LE);
}
public static void WriteItemsLittleEndian(DICOMBinaryWriter dw, DICOMWriteSettings settings,
List <DICOMObject> items)
{
dw.Write(WriteItemsLittleEndian(settings, items));
}
private static void WriteIndefiniteLittleEndian(DICOMBinaryWriter dw, byte[] itemBytes)
{
dw.Write(new byte[] { 0xFF, 0xFF, 0xFF, 0xFF });
dw.Write(itemBytes);
dw.Write(_endOfSequenceItem_LE);
}
