internal override void WriteData(SwappableBinaryWriter bw, ILogger logger, TransferSyntax transferSyntax)
{
bw.Write(Encoding.ASCII.GetBytes(data));
if ((length & 1) > 0) //pad it to even
{
bw.Write(padChar);
}
}
internal void Write(SwappableBinaryWriter bw, ILogger logger, TransferSyntax transferSyntax)
{
//Group/Element
bw.Write(group);
bw.Write(elem);
// Group 0 is always little-endian implicit vr, group 2 is always little-endian explicit vr
if ((transferSyntax.ExplicitVR && group != 0) || group == 2)
{
//Shortcut write OB always for image data, even if it's a sequence
if (Group == 0x7FE0 && Elem == 0x0010)
{
bw.Write(DICOMElementOB.vrshort);
}
else
{
bw.Write(VRShort);
}
if (VR == "UT" || VR == "UN" || VR == "OB" || VR == "OW" || VR == "SQ")
{
//2 reserved bytes
bw.Write((short)0);
//4 Length
if (Group == 0x7FE0 && Elem == 0x0010 && VR == "SQ")
{
bw.Write((uint)0xFFFFFFFF);
}
else
{
bw.Write(GetDataLength(true));
}
}
else
{
//2 Length
bw.Write((ushort)GetDataLength(true));
}
}
else
{
//4 Length
if (Group == 0x7FE0 && Elem == 0x0010 && VR == "SQ")
{
bw.Write((uint)0xFFFFFFFF);
}
else
{
bw.Write(GetDataLength(false));
}
}
this.WriteData(bw, logger, transferSyntax);
}
internal override void WriteData(SwappableBinaryWriter bw, ILogger logger, TransferSyntax transferSyntax)
{
if (data is ushort)
{
bw.Write((ushort)data);
}
else
{
foreach (ushort de in (ushort[])data)
{
bw.Write(de);
}
}
}
internal void WriteData(SwappableBinaryWriter bw, ILogger logger, TransferSyntax transferSyntax)
{
if (IsEncapsulatedImage)
{
//Encapsulated image... just write out the raw image data. this may or may not be correct...
bw.Write(EncapsulatedImageData);
}
else
{
//Normal sequence
//header already written, just write the contents of your elements
foreach (DICOMElement elem in Elements)
{
//Store write position for later possible use
elem.WritePosition = bw.BaseStream.Position;
//Have the element write itself out.
elem.Write(bw, logger, transferSyntax);
}
}
}
internal override void WriteData(SwappableBinaryWriter bw, ILogger logger, TransferSyntax transferSyntax)
{
//Covered by PS 3.5, Chapter 7.5 (pg. 42-45)
foreach (SQItem item in Items)
{
//write FFFE,E000 item header
bw.Write((ushort)0xFFFE);
bw.Write((ushort)0xE000);
bw.Write(item.GetLength(transferSyntax.ExplicitVR));
//write your contents!
item.WriteData(bw, logger, transferSyntax);
}
if (group == 0x7FE0 && elem == 0x0010)
{
//Image data, so it's encapsulated... Write the SQ ender old school style.
bw.Write((ushort)0xFFFE);
bw.Write((ushort)0xE0DD);
bw.Write((uint)0);
}
}
/// <summary>
/// Writes the contents of the DICOMData structure to a stream in a given set of pre- and post-header transfer syntaxes.
/// </summary>
/// <param name="stream">The stream to write the data to.</param>
/// <param name="logger">Logger to use while writing out the file.</param>
/// <param name="transferSyntax">The transfer syntax to use for writing out fields (other than group 2, which has special behavior).</param>
/// <param name="isNetworkTransfer">For network transfers, you should never send group 2.</param>
/// <returns>Returns <c>true</c> if writing was successful, or <c>false</c> if an error was encountered.</returns>
public bool WriteStream(Stream stream, ILogger logger, TransferSyntax transferSyntax, bool isNetworkTransfer)
{
// Decompress/compress as needed to match the accepted transfer syntax.
if (transferSyntax != this.TransferSyntax)
{
this.ChangeTransferSyntax(transferSyntax);
}
//Go through stream, make sure it has group lengths...
//RxIMP: Optimize this to make it not recalc unless it has to!
ushort lastGroup = 0xFFFF;
uint sizeTally = 0;
Dictionary <ushort, uint> sizesTemp = new Dictionary <ushort, uint>();
foreach (DICOMElement elem in Elements.Values)
{
if (elem.Group != lastGroup)
{
if (lastGroup != 0xFFFF)
{
//write out new group length tag!
sizesTemp[lastGroup] = sizeTally;
//this[(uint) lastGroup << 16].Data = sizeTally;
sizeTally = 0;
}
lastGroup = elem.Group;
}
if (elem.Elem != 0)
{
// Group 2 is always explicit VR, if it's even sent (not for network transfers.)
sizeTally += elem.GetLength(elem.Group == 2 ? true : transferSyntax.ExplicitVR);
}
}
//grab last group tag
if (lastGroup != 0xFFFF)
{
sizesTemp[lastGroup] = sizeTally;
}
//Write out group lengths
foreach (ushort group in sizesTemp.Keys)
{
this[(uint)group << 16].Data = sizesTemp[group];
}
SwappableBinaryWriter bw = new SwappableBinaryWriter(stream);
if (transferSyntax.MSBSwap)
{
bw.ToggleSwapped();
}
bool inGroup2 = false;
//Start writing tags!
foreach (DICOMElement elem in Elements.Values)
{
//If we're moving in and out of group 2, change MSB swap as needed -- group 2 should always be little endian
if (inGroup2 != (elem.Group == 2))
{
if (transferSyntax.MSBSwap)
{
bw.ToggleSwapped();
}
inGroup2 = (elem.Group == 2);
}
//Store write position for later possible use
elem.WritePosition = stream.Position;
// Network transfers don't send group 2.
if (elem.Group != 2 || !isNetworkTransfer)
{
//Have the element write itself out.
elem.Write(bw, logger, transferSyntax);
}
}
return(true);
}
internal override void WriteData(SwappableBinaryWriter bw, ILogger logger, TransferSyntax transferSyntax)
{
bw.Write(data);
}
internal override void WriteData(SwappableBinaryWriter bw, ILogger logger, TransferSyntax transferSyntax)
{
// Make sure to follow the UID rules
bw.Write(Uid.UidToBytes(this.data));
}
abstract internal void WriteData(SwappableBinaryWriter bw, ILogger logger, TransferSyntax transferSyntax);
internal override void WriteData(SwappableBinaryWriter bw, ILogger logger, TransferSyntax transferSyntax)
{
bw.Write(encapgroup);
bw.Write(encapelem);
}
