internal override uint CalculateWriteLength(DicomTransferSyntax syntax, DicomWriteOptions options) {
uint length = 4 + 4;
length += Dataset.CalculateWriteLength(syntax, options & ~DicomWriteOptions.CalculateGroupLengths);
if (!Flags.IsSet(options, DicomWriteOptions.ExplicitLengthSequenceItem))
length += 4 + 4; // Sequence Item Delimitation Item
return length;
}
internal DcmPresContext(byte pcid, DicomUID abstractSyntax, DicomTransferSyntax transferSyntax, DcmPresContextResult result) {
_pcid = pcid;
_result = result;
_abstract = abstractSyntax;
_transfers = new List<DicomTransferSyntax>();
_transfers.Add(transferSyntax);
}
public DcmPixelData(DcmDataset dataset) {
_transferSyntax = dataset.InternalTransferSyntax;
_lossy = dataset.GetString(DicomTags.LossyImageCompression, "00") != "00";
_lossyMethod = dataset.GetString(DicomTags.LossyImageCompressionMethod, String.Empty);
_lossyRatio = dataset.GetString(DicomTags.LossyImageCompressionRatio, String.Empty);
_frames = dataset.GetInt32(DicomTags.NumberOfFrames, 1);
_width = dataset.GetUInt16(DicomTags.Columns, 0);
_height = dataset.GetUInt16(DicomTags.Rows, 0);
_bitsStored = dataset.GetUInt16(DicomTags.BitsStored, 0);
_bitsAllocated = dataset.GetUInt16(DicomTags.BitsAllocated, 0);
_highBit = dataset.GetUInt16(DicomTags.HighBit, (ushort)(_bitsStored - 1));
_samplesPerPixel = dataset.GetUInt16(DicomTags.SamplesPerPixel, 0);
_pixelRepresentation = dataset.GetUInt16(DicomTags.PixelRepresentation, 0);
_planarConfiguration = dataset.GetUInt16(DicomTags.PlanarConfiguration, 0);
_photometricInterpretation = dataset.GetString(DicomTags.PhotometricInterpretation, String.Empty);
_rescaleSlope = dataset.GetDouble(DicomTags.RescaleSlope, 1.0);
_rescaleIntercept = dataset.GetDouble(DicomTags.RescaleIntercept, 0.0);
_pixelDataItem = dataset.GetItem(DicomTags.PixelData);
_hasPixelPadding = dataset.Contains(DicomTags.PixelPaddingValue);
if (_hasPixelPadding) {
DcmElement elem = dataset.GetElement(DicomTags.PixelPaddingValue);
if (elem is DcmUnsignedShort)
_pixelPaddingValue = (elem as DcmUnsignedShort).GetValue();
else if (elem is DcmSignedShort) {
_pixelPaddingValue = (elem as DcmSignedShort).GetValue();
} else
_pixelPaddingValue = MinimumDataValue;
}
}
public DcmDataset(long streamPosition, uint lengthInStream, DicomTransferSyntax transferSyntax)
{
_streamPosition = streamPosition;
_streamLength = lengthInStream;
_transferSyntax = transferSyntax;
_items = new SortedList<DicomTag, DcmItem>(new DicomTagComparer());
}
public static bool HasCodec(DicomTransferSyntax ts) {
if (ts == DicomTransferSyntax.ImplicitVRLittleEndian ||
ts == DicomTransferSyntax.ExplicitVRLittleEndian ||
ts == DicomTransferSyntax.ExplicitVRBigEndian)
return true;
if (_codecs == null)
return false;
return _codecs.ContainsKey(ts);
}
public static IDcmCodec GetCodec(DicomTransferSyntax ts) {
if (_codecs == null)
RegisterCodecs();
Type cType;
if (_codecs.TryGetValue(ts, out cType)) {
return (IDcmCodec)Activator.CreateInstance(cType);
}
throw new DicomCodecException("No registered codec for transfer syntax!");
}
internal override uint CalculateWriteLength(DicomTransferSyntax syntax, DicomWriteOptions options)
{
uint length = 4 + 4;
length += Dataset.CalculateWriteLength(syntax, options & ~DicomWriteOptions.CalculateGroupLengths);
if (!Flags.IsSet(options, DicomWriteOptions.ExplicitLengthSequenceItem))
{
length += 4 + 4; // Sequence Item Delimitation Item
}
return(length);
}
public override uint CalculateWriteLength(DicomTransferSyntax syntax, DicomWriteOptions options)
{
uint length = 0;
length += 4; // element tag
if (syntax.IsExplicitVR) {
length += 2; // vr
length += 6; // length
} else {
length += 4; // length
}
foreach (DcmItemSequenceItem item in SequenceItems) {
length += item.CalculateWriteLength(syntax, options);
}
if (!Flags.IsSet(options, DicomWriteOptions.ExplicitLengthSequence))
length += 4 + 4; // Sequence Delimitation Item
return length;
}
public DcmPixelData(DicomTransferSyntax ts, DcmPixelData old) {
_transferSyntax = ts;
_lossy = old.IsLossy;
_lossyMethod = old.LossyCompressionMethod;
_lossyRatio = old._lossyRatio;
_frames = 0;
_width = old.ImageWidth;
_height = old.ImageHeight;
_highBit = old.HighBit;
_bitsStored = old.BitsStored;
_bitsAllocated = old.BitsAllocated;
_samplesPerPixel = old.SamplesPerPixel;
_pixelRepresentation = old.PixelRepresentation;
_planarConfiguration = old.PlanarConfiguration;
_photometricInterpretation = old.PhotometricInterpretation;
_rescaleSlope = old.RescaleSlope;
_rescaleIntercept = old.RescaleIntercept;
_pixelPaddingValue = old.PixelPaddingValue;
CreatePixelDataItem();
}
public DcmPixelData(DicomTransferSyntax ts, DcmPixelData old)
{
_transferSyntax = ts;
_lossy = old.IsLossy;
_lossyMethod = old.LossyCompressionMethod;
_lossyRatio = old._lossyRatio;
_frames = 0;
_width = old.ImageWidth;
_height = old.ImageHeight;
_highBit = old.HighBit;
_bitsStored = old.BitsStored;
_bitsAllocated = old.BitsAllocated;
_samplesPerPixel = old.SamplesPerPixel;
_pixelRepresentation = old.PixelRepresentation;
_planarConfiguration = old.PlanarConfiguration;
_photometricInterpretation = old.PhotometricInterpretation;
_rescaleSlope = old.RescaleSlope;
_rescaleIntercept = old.RescaleIntercept;
_pixelPaddingValue = old.PixelPaddingValue;
CreatePixelDataItem();
}
public DcmPixelData(DcmDataset dataset)
{
_transferSyntax = dataset.InternalTransferSyntax;
_lossy = dataset.GetString(DicomTags.LossyImageCompression, "00") != "00";
_lossyMethod = dataset.GetString(DicomTags.LossyImageCompressionMethod, String.Empty);
_lossyRatio = dataset.GetString(DicomTags.LossyImageCompressionRatio, String.Empty);
_frames = dataset.GetInt32(DicomTags.NumberOfFrames, 1);
_width = dataset.GetUInt16(DicomTags.Columns, 0);
_height = dataset.GetUInt16(DicomTags.Rows, 0);
_bitsStored = dataset.GetUInt16(DicomTags.BitsStored, 0);
_bitsAllocated = dataset.GetUInt16(DicomTags.BitsAllocated, 0);
_highBit = dataset.GetUInt16(DicomTags.HighBit, (ushort)(_bitsStored - 1));
_samplesPerPixel = dataset.GetUInt16(DicomTags.SamplesPerPixel, 0);
_pixelRepresentation = dataset.GetUInt16(DicomTags.PixelRepresentation, 0);
_planarConfiguration = dataset.GetUInt16(DicomTags.PlanarConfiguration, 0);
_photometricInterpretation = dataset.GetString(DicomTags.PhotometricInterpretation, String.Empty);
_rescaleSlope = dataset.GetDouble(DicomTags.RescaleSlope, 1.0);
_rescaleIntercept = dataset.GetDouble(DicomTags.RescaleIntercept, 0.0);
_pixelDataItem = dataset.GetItem(DicomTags.PixelData);
_hasPixelPadding = dataset.Contains(DicomTags.PixelPaddingValue);
if (_hasPixelPadding)
{
DcmElement elem = dataset.GetElement(DicomTags.PixelPaddingValue);
if (elem is DcmUnsignedShort && elem.GetVM() > 0)
{
_pixelPaddingValue = (elem as DcmUnsignedShort).GetValue();
}
else if (elem is DcmSignedShort && elem.GetVM() > 0)
{
_pixelPaddingValue = (elem as DcmSignedShort).GetValue();
}
else
{
_pixelPaddingValue = MinimumDataValue;
}
}
}
internal override uint CalculateWriteLength(DicomTransferSyntax syntax, DicomWriteOptions options)
{
uint length = 0;
length += 4; // element tag
if (syntax.IsExplicitVR)
{
length += 2; // vr
length += 6; // length
}
else
{
length += 4; // length
}
foreach (DcmItemSequenceItem item in SequenceItems)
{
length += item.CalculateWriteLength(syntax, options);
}
if (!Flags.IsSet(options, DicomWriteOptions.ExplicitLengthSequence))
{
length += 4 + 4; // Sequence Delimitation Item
}
return(length);
}
public DcmDataset(DicomTransferSyntax transferSyntax)
{
_transferSyntax = transferSyntax;
_items = new SortedList<DicomTag, DcmItem>(new DicomTagComparer());
}
public void ChangeTransferSyntax(DicomTransferSyntax newTransferSyntax, DcmCodecParameters parameters)
{
DicomTransferSyntax oldTransferSyntax = InternalTransferSyntax;
if (oldTransferSyntax == newTransferSyntax)
return;
if (oldTransferSyntax.IsEncapsulated && newTransferSyntax.IsEncapsulated) {
ChangeTransferSyntax(DicomTransferSyntax.ExplicitVRLittleEndian, parameters);
oldTransferSyntax = DicomTransferSyntax.ExplicitVRLittleEndian;
}
if (Contains(DicomTags.PixelData)) {
DcmPixelData oldPixelData = new DcmPixelData(this);
DcmPixelData newPixelData = new DcmPixelData(newTransferSyntax, oldPixelData);
if (oldTransferSyntax.IsEncapsulated) {
IDcmCodec codec = DicomCodec.GetCodec(oldTransferSyntax);
codec.Decode(this, oldPixelData, newPixelData, parameters);
}
else if (newTransferSyntax.IsEncapsulated) {
IDcmCodec codec = DicomCodec.GetCodec(newTransferSyntax);
codec.Encode(this, oldPixelData, newPixelData, parameters);
}
else {
for (int i = 0; i < oldPixelData.NumberOfFrames; i++) {
byte[] data = oldPixelData.GetFrameDataU8(i);
newPixelData.AddFrame(data);
}
}
newPixelData.UpdateDataset(this);
}
SetInternalTransferSyntax(newTransferSyntax);
}
/// <summary>
/// Changes transfer syntax of dataset and updates file meta information
/// </summary>
/// <param name="ts">New transfer syntax</param>
/// <param name="parameters">Encode/Decode params</param>
public void ChangeTransferSytnax(DicomTransferSyntax ts, DcmCodecParameters parameters) {
Dataset.ChangeTransferSyntax(ts, parameters);
FileMetaInfo.TransferSyntax = ts;
}
public void AddTransfer(DicomTransferSyntax ts)
{
if (!_transfers.Contains(ts))
_transfers.Add(ts);
}
/// <summary>
/// Removes a Transfer Syntax from the specified Presentation Context.
/// </summary>
/// <param name="pcid">Presentation Context ID</param>
/// <param name="ts">Transfer Syntax</param>
public void RemoveTransferSyntax(byte pcid, DicomTransferSyntax ts)
{
GetPresentationContext(pcid).RemoveTransfer(ts);
}
public void AddPresentationContext(byte pcid, DicomUID abstractSyntax, DicomTransferSyntax transferSyntax, DcmPresContextResult result)
{
_presContexts.Add(pcid, new DcmPresContext(pcid, abstractSyntax, transferSyntax, result));
}
public static bool IsImageCompression(DicomTransferSyntax tx) {
return tx != DicomTransferSyntax.ImplicitVRLittleEndian &&
tx != DicomTransferSyntax.ExplicitVRLittleEndian &&
tx != DicomTransferSyntax.ExplicitVRBigEndian &&
tx != DicomTransferSyntax.DeflatedExplicitVRLittleEndian;
}
public DcmPixelData(DicomTransferSyntax ts)
{
_transferSyntax = ts;
CreatePixelDataItem();
}
private DicomReadStatus ParseSequenceItemDataset(DicomTransferSyntax syntax, long len, out DcmDataset dataset, DicomReadOptions options)
{
long pos = _stream.Position;
dataset = new DcmDataset(pos, (uint)len, syntax);
Stream stream = (len != UndefinedLength) ? new SegmentStream(_stream, _stream.Position, _len) : _stream;
DicomStreamReader idsr = new DicomStreamReader(stream);
idsr.Dataset = dataset;
idsr.Encoding = _encoding;
if (len != UndefinedLength)
idsr.PositionOffset = dataset.StreamPosition;
DicomReadStatus status = idsr.Read(null, options);
if (status != DicomReadStatus.Success) {
_stream.Seek(pos, SeekOrigin.Begin);
dataset = null;
}
else {
if (len == UndefinedLength) {
// rewind delimitation item tag
_stream.Seek(-4, SeekOrigin.Current);
len = _stream.Position - pos;
}
_remain -= len;
_bytes += len;
_read += len;
}
return status;
}
private DicomReadStatus InsertSequenceItem(DicomReadOptions options)
{
if (_tag.Equals(DicomTags.Item)) {
if (_len != UndefinedLength && _len > _remain)
return NeedMoreData(_len);
if (_sds.Count > _sqs.Count)
_sds.Pop();
DcmItemSequenceItem si = new DcmItemSequenceItem(_pos, _len);
if (_len != UndefinedLength || (_stream.CanSeek && Flags.IsSet(options, DicomReadOptions.AllowSeekingForContext))) {
if (_len == UndefinedLength)
options |= DicomReadOptions.SequenceItemOnly;
DcmDataset ds = null;
DicomReadStatus status = ParseSequenceItemDataset(TransferSyntax, _len, out ds, options);
if (status != DicomReadStatus.Success) {
Dicom.Debug.Log.Warn("Unknown error while attempting to read sequence item. Trying again with alternate encodings.");
DicomTransferSyntax[] syntaxes = null;
if (TransferSyntax == DicomTransferSyntax.ExplicitVRBigEndian)
syntaxes = new DicomTransferSyntax[] { DicomTransferSyntax.ImplicitVRLittleEndian, DicomTransferSyntax.ExplicitVRLittleEndian };
else if (TransferSyntax.IsExplicitVR)
syntaxes = new DicomTransferSyntax[] { DicomTransferSyntax.ImplicitVRLittleEndian, DicomTransferSyntax.ExplicitVRBigEndian };
else
syntaxes = new DicomTransferSyntax[] { DicomTransferSyntax.ExplicitVRLittleEndian, DicomTransferSyntax.ExplicitVRBigEndian };
foreach (DicomTransferSyntax tx in syntaxes) {
status = ParseSequenceItemDataset(tx, _len, out ds, options);
if (status == DicomReadStatus.Success)
break;
}
}
if (status != DicomReadStatus.Success)
return DicomReadStatus.UnknownError;
si.Dataset = ds;
if (_len == UndefinedLength) {
if (8 > _remain) {
// need more data?
_sds.Push(ds);
}
else {
// skip delimitation item
_stream.Seek(8, SeekOrigin.Current);
_remain -= 8;
_bytes += 8;
_read += 8;
}
}
}
else {
DcmDataset ds = new DcmDataset(_pos + 8, _len, TransferSyntax);
_sds.Push(ds);
}
_sqs.Peek().AddSequenceItem(si);
}
else if (_tag == DicomTags.ItemDelimitationItem) {
if (_sds.Count == _sqs.Count)
_sds.Pop();
}
else if (_tag == DicomTags.SequenceDelimitationItem) {
if (_sds.Count == _sqs.Count)
_sds.Pop();
_sqs.Pop();
}
return DicomReadStatus.Success;
}
protected DcmJpegCodec(DicomTransferSyntax transferSyntax, DcmJpegParameters defaultParameters = null)
{
_transferSyntax = transferSyntax;
_defaultParameters = defaultParameters ?? new DcmJpegParameters();
}
internal override uint CalculateWriteLength(DicomTransferSyntax syntax, DicomWriteOptions options)
{
uint length = 0;
length += 4; // element tag
if (syntax.IsExplicitVR)
{
length += 2; // vr
length += 6; // length
}
else
{
length += 4; // length
}
length += 4 + 4; // offset tag
if (Flags.IsSet(options, DicomWriteOptions.WriteFragmentOffsetTable) && _table != null)
length += (uint)(_table.Count * 4);
foreach (ByteBuffer bb in _fragments)
{
length += 4; // item tag
length += 4; // fragment length
length += (uint)bb.Length;
}
return length;
}
/// <summary>
/// Changes transfer syntax of dataset and updates file meta information
/// </summary>
/// <param name="ts">New transfer syntax</param>
/// <param name="parameters">Encode/Decode params</param>
public void ChangeTransferSytnax(DicomTransferSyntax ts, DcmCodecParameters parameters)
{
Dataset.ChangeTransferSyntax(ts, parameters);
FileMetaInfo.TransferSyntax = ts;
}
public void RemoveTransfer(DicomTransferSyntax ts)
{
if (_transfers.Contains(ts))
_transfers.Remove(ts);
}
public abstract uint CalculateWriteLength(DicomTransferSyntax syntax, DicomWriteOptions options);
public abstract uint CalculateWriteLength(DicomTransferSyntax syntax, DicomWriteOptions options);
internal void SetInternalTransferSyntax(DicomTransferSyntax ts)
{
_transferSyntax = ts;
foreach (DcmItem item in _items.Values) {
if (item is DcmElement) {
item.Endian = ts.Endian;
}
else if (item is DcmFragmentSequence) {
item.Endian = ts.Endian;
}
else if (item is DcmItemSequence) {
DcmItemSequence sq = item as DcmItemSequence;
sq.Endian = ts.Endian;
foreach (DcmItemSequenceItem si in sq.SequenceItems) {
si.Dataset.SetInternalTransferSyntax(ts);
}
}
}
}
/// <summary>
/// Finds the Presentation Context with the specified Abstract Syntax and Transfer Syntax.
/// </summary>
/// <param name="abstractSyntax">Abstract Syntax</param>
/// <param name="transferSyntax">Transfer Syntax</param>
/// <returns>Presentation Context ID</returns>
public byte FindAcceptedAbstractSyntaxWithTransferSyntax(DicomUID abstractSyntax, DicomTransferSyntax trasferSyntax)
{
foreach (DcmPresContext ctx in _presContexts.Values) {
if (ctx.Result == DcmPresContextResult.Accept && ctx.AbstractSyntax == abstractSyntax && ctx.HasTransfer(trasferSyntax))
return ctx.ID;
}
return 0;
}
public uint CalculateGroupWriteLength(ushort group, DicomTransferSyntax syntax, DicomWriteOptions options)
{
uint length = 0;
foreach (DcmItem item in _items.Values) {
if (item.Tag.Group < group || item.Tag.Element == 0x0000)
continue;
if (item.Tag.Group > group)
return length;
length += item.CalculateWriteLength(syntax, options);
}
return length;
}
public void SetAcceptedTransferSyntax(byte pcid, DicomTransferSyntax ts)
{
GetPresentationContext(pcid).ClearTransfers();
GetPresentationContext(pcid).AddTransfer(ts);
}
public uint CalculateWriteLength(DicomTransferSyntax syntax, DicomWriteOptions options)
{
uint length = 0;
ushort group = 0xffff;
foreach (DcmItem item in _items.Values) {
if (item.Tag.Element == 0x0000)
continue;
if (item.Tag.Group != group) {
group = item.Tag.Group;
if (Flags.IsSet(options, DicomWriteOptions.CalculateGroupLengths)) {
if (syntax.IsExplicitVR)
length += 4 + 2 + 2 + 4;
else
length += 4 + 4 + 4;
}
}
length += item.CalculateWriteLength(syntax, options);
}
return length;
}
public bool HasTransfer(DicomTransferSyntax ts)
{
return _transfers.Contains(ts);
}
/// <summary>
/// Write dataset to stream
/// </summary>
/// <param name="dataset">Dataset</param>
/// <param name="options">DICOM write options</param>
/// <returns>Status code</returns>
public DicomWriteStatus Write(DcmDataset dataset, DicomWriteOptions options)
{
TransferSyntax = dataset.InternalTransferSyntax;
dataset.SelectByteOrder(_syntax.Endian);
foreach (DcmItem item in dataset.Elements) {
if (item.Tag.Element == 0x0000)
continue;
if (Flags.IsSet(options, DicomWriteOptions.CalculateGroupLengths)
&& item.Tag.Group != _group && item.Tag.Group <= 0x7fe0)
{
_group = item.Tag.Group;
_writer.Write((ushort)_group);
_writer.Write((ushort)0x0000);
if (_syntax.IsExplicitVR) {
_writer.Write((byte)'U');
_writer.Write((byte)'L');
_writer.Write((ushort)4);
} else {
_writer.Write((uint)4);
}
_writer.Write((uint)dataset.CalculateGroupWriteLength(_group, _syntax, options));
}
_writer.Write((ushort)item.Tag.Group);
_writer.Write((ushort)item.Tag.Element);
if (_syntax.IsExplicitVR) {
_writer.Write((byte)item.VR.VR[0]);
_writer.Write((byte)item.VR.VR[1]);
}
if (item is DcmItemSequence) {
DcmItemSequence sq = item as DcmItemSequence;
if (_syntax.IsExplicitVR)
_writer.Write((ushort)0x0000);
if (Flags.IsSet(options, DicomWriteOptions.ExplicitLengthSequence) || (item.Tag.IsPrivate && !_syntax.IsExplicitVR)) {
int hl = _syntax.IsExplicitVR ? 12 : 8;
_writer.Write((uint)sq.CalculateWriteLength(_syntax, options & ~DicomWriteOptions.CalculateGroupLengths) - (uint)hl);
} else {
_writer.Write((uint)UndefinedLength);
}
foreach (DcmItemSequenceItem ids in sq.SequenceItems) {
ids.Dataset.ChangeTransferSyntax(dataset.InternalTransferSyntax, null);
_writer.Write((ushort)DicomTags.Item.Group);
_writer.Write((ushort)DicomTags.Item.Element);
if (Flags.IsSet(options, DicomWriteOptions.ExplicitLengthSequenceItem)) {
_writer.Write((uint)ids.CalculateWriteLength(_syntax, options & ~DicomWriteOptions.CalculateGroupLengths) - (uint)8);
} else {
_writer.Write((uint)UndefinedLength);
}
Write(ids.Dataset, options & ~DicomWriteOptions.CalculateGroupLengths);
if (!Flags.IsSet(options, DicomWriteOptions.ExplicitLengthSequenceItem)) {
_writer.Write((ushort)DicomTags.ItemDelimitationItem.Group);
_writer.Write((ushort)DicomTags.ItemDelimitationItem.Element);
_writer.Write((uint)0x00000000);
}
}
if (!Flags.IsSet(options, DicomWriteOptions.ExplicitLengthSequence) && !(item.Tag.IsPrivate && !_syntax.IsExplicitVR)) {
_writer.Write((ushort)DicomTags.SequenceDelimitationItem.Group);
_writer.Write((ushort)DicomTags.SequenceDelimitationItem.Element);
_writer.Write((uint)0x00000000);
}
}
else if (item is DcmFragmentSequence) {
DcmFragmentSequence fs = item as DcmFragmentSequence;
if (_syntax.IsExplicitVR)
_writer.Write((ushort)0x0000);
_writer.Write((uint)UndefinedLength);
_writer.Write((ushort)DicomTags.Item.Group);
_writer.Write((ushort)DicomTags.Item.Element);
if (Flags.IsSet(options, DicomWriteOptions.WriteFragmentOffsetTable) && fs.HasOffsetTable) {
_writer.Write((uint)fs.OffsetTableBuffer.Length);
fs.OffsetTableBuffer.CopyTo(_writer.BaseStream);
} else {
_writer.Write((uint)0x00000000);
}
foreach (ByteBuffer bb in fs.Fragments) {
_writer.Write((ushort)DicomTags.Item.Group);
_writer.Write((ushort)DicomTags.Item.Element);
_writer.Write((uint)bb.Length);
bb.CopyTo(_writer.BaseStream);
}
_writer.Write((ushort)DicomTags.SequenceDelimitationItem.Group);
_writer.Write((ushort)DicomTags.SequenceDelimitationItem.Element);
_writer.Write((uint)0x00000000);
}
else {
DcmElement de = item as DcmElement;
if (_syntax.IsExplicitVR) {
if (de.VR.Is16BitLengthField) {
_writer.Write((ushort)de.Length);
} else {
_writer.Write((ushort)0x0000);
_writer.Write((uint)de.Length);
}
} else {
_writer.Write((uint)de.Length);
}
de.ByteBuffer.CopyTo(_writer.BaseStream);
}
}
return DicomWriteStatus.Success;
}
public void SetResult(DcmPresContextResult result, DicomTransferSyntax acceptedTs)
{
_transfers.Clear();
_transfers.Add(acceptedTs);
_result = result;
}
public static void RegisterCodec(DicomTransferSyntax ts, Type type) {
if (_codecs == null)
_codecs = new Dictionary<DicomTransferSyntax, Type>();
if (type.IsDefined(typeof(DicomCodecAttribute), false))
_codecs.Add(ts, type);
}
