public PixelData(byte[] data, Constants.EncodeType encType, bool isLittleEndian, string vr, bool isEncapsulated)
{
this.encType = encType;
this.IsLittleEndian = isLittleEndian;
this.VR = vr;
if (isEncapsulated)
{
//Encapsulated Pixel Data
this.Format = FrameDataFormat.ENCAPSULATED;
this.Fragments = FindFragments(data);
this.ByteData = data;
}
else
{
//Native Pixel Data
this.Format = FrameDataFormat.NATIVE;
this.ByteData = data;
}
}
/// <summary>
/// This method writes the length of the DICOM object to the binary writer
/// </summary>
/// <param name="b">The Binary writer to write the bytes to</param>
/// <param name="encType">The encoding type of the VR</param>
/// <param name="length">The integer length of the byte data</param>
/// <param name="isLittleEndian">A boolean that indicates whether or not the bytes are written in little or big endian.</param>
public static void WriteLength(BinaryWriter b, Constants.EncodeType encType, int length, bool isLittleEndian)
{
switch (encType)
{
default:
byte[] lengthBytes = BitConverter.GetBytes(length);
if (!isLittleEndian) { lengthBytes = ArrayHelper.ReverseArray(lengthBytes); }
b.Write(lengthBytes[0]);
b.Write(lengthBytes[1]);
b.Write(lengthBytes[2]);
b.Write(lengthBytes[3]);
break;
case Constants.EncodeType.EXPLICIT_2:
short shortLength = (short)length;
lengthBytes = BitConverter.GetBytes(length);
if (!isLittleEndian) { lengthBytes = ArrayHelper.ReverseArray(lengthBytes); }
b.Write(lengthBytes[0]);
b.Write(lengthBytes[1]);
break;
}
}
/// <summary>
/// This method determines the encoding type of the VR of the next DICOM object in a Binary reader.
/// </summary>
/// <param name="r">The Binary reader containing the bytes of a DICOM object</param>
/// <param name="vr">The two letter representation of the VR of the DICOM object</param>
/// <param name="dataLength">The lenght of the data in this DICOM object</param>
/// <param name="encType">The encoding type of the VR in this DICOM object</param>
/// <param name="isLittleEndian">A boolean that indicates whether or not the bytes are written in little or big endian.</param>
private static void GetEncoding(BinaryReader r, out string vr, out int dataLength, out Constants.EncodeType encType, bool isLittleEndian)
{
byte[] vrBytes = new byte[4];
r.Read(vrBytes, 0, 4);
System.Text.ASCIIEncoding enc = new System.Text.ASCIIEncoding();
string possibleVR = enc.GetString(vrBytes).Substring(0, 2);
//Check to see if the dicom object is explicit or implicit vr
//Start out as implicit and change if neccessary
encType = Constants.EncodeType.IMPLICIT;
vr = "";
foreach (string s in vrs)
{
if (s.Contains(possibleVR))
{
//Encoding is Explicit VR with 2 byte length
encType = Constants.EncodeType.EXPLICIT_2;
vr = possibleVR;
foreach (string st in longVrs)
{
if (st.Contains(possibleVR))
{
//Encoding is Explicit VR with 4 byte length
encType = Constants.EncodeType.EXPLICIT_4;
break;
}
}
}
}
//Based on encoding type pull the length attribute
dataLength = 0;
switch (encType)
{
case Constants.EncodeType.IMPLICIT:
//Check for indefinite length
if (Helper.ArrayHelper.isEqualArray(vrBytes, Constants.INDEFINITE_LENGTH))
{
if (string.IsNullOrEmpty(vr))
{
vr = "SQ";
}
dataLength = GetIndefiniteLength(r, isLittleEndian);
}
else
{
if (!isLittleEndian) { vrBytes = ArrayHelper.ReverseArray(vrBytes); }
dataLength = BitConverter.ToInt32(vrBytes, 0);
}
break;
case Constants.EncodeType.EXPLICIT_2:
//Read last 2 bytes as length
byte[] vrBytesEnd = new byte[] { vrBytes[2], vrBytes[3] };
if (!isLittleEndian) { vrBytesEnd = ArrayHelper.ReverseArray(vrBytesEnd); }
dataLength = BitConverter.ToInt16(vrBytesEnd, 0);
break;
case Constants.EncodeType.EXPLICIT_4:
//Read next four bytes as length
r.Read(vrBytes, 0, 4);
//Check for indefinite length
if (Helper.ArrayHelper.isEqualArray(vrBytes, Constants.INDEFINITE_LENGTH))
{
if (string.IsNullOrEmpty(vr))
{
vr = "SQ";
}
dataLength = GetIndefiniteLength(r, isLittleEndian);
}
else
{
if (!isLittleEndian) { vrBytes = ArrayHelper.ReverseArray(vrBytes); }
dataLength = BitConverter.ToInt32(vrBytes, 0);
}
break;
}
}
private static DICOMElement CreateVRObject(string vr, Constants.EncodeType encType, byte[] data, Tag t, bool isLittleEndian, bool isIndefinite)
{
switch (vr)
{
case "CS":
CodeString cs = new CodeString();
cs.ByteData = data;
cs.EncodeType = encType;
cs.IsLittleEndian = isLittleEndian;
cs.Tag = t;
return cs;
case "SH":
ShortString sh = new ShortString();
sh.ByteData = data;
sh.EncodeType = encType;
sh.IsLittleEndian = isLittleEndian;
sh.Tag = t;
return sh;
case "LO":
LongString lo = new LongString();
lo.ByteData = data;
lo.EncodeType = encType;
lo.IsLittleEndian = isLittleEndian;
lo.Tag = t;
return lo;
case "ST":
ShortText st = new ShortText();
st.ByteData = data;
st.EncodeType = encType;
st.IsLittleEndian = isLittleEndian;
st.Tag = t;
return st;
case "LT":
LongText lt = new LongText();
lt.ByteData = data;
lt.EncodeType = encType;
lt.IsLittleEndian = isLittleEndian;
lt.Tag = t;
return lt;
case "UT":
UnlimitedText ut = new UnlimitedText();
ut.ByteData = data;
ut.EncodeType = encType;
ut.IsLittleEndian = isLittleEndian;
ut.Tag = t;
return ut;
case "AE":
ApplicationEntity ae = new ApplicationEntity();
ae.ByteData = data;
ae.EncodeType = encType;
ae.IsLittleEndian = isLittleEndian;
ae.Tag = t;
return ae;
case "PN":
PersonsName pn = new PersonsName();
pn.ByteData = data;
pn.EncodeType = encType;
pn.IsLittleEndian = isLittleEndian;
pn.Tag = t;
return pn;
case "UI":
UniqueIdentifier ui = new UniqueIdentifier();
ui.ByteData = data;
ui.EncodeType = encType;
ui.IsLittleEndian = isLittleEndian;
ui.Tag = t;
return ui;
case "DA":
DateVR da = new DateVR();
da.ByteData = data;
da.EncodeType = encType;
da.IsLittleEndian = isLittleEndian;
da.Tag = t;
return da;
case "TM":
TimeVR tm = new TimeVR();
tm.ByteData = data;
tm.EncodeType = encType;
tm.IsLittleEndian = isLittleEndian;
tm.Tag = t;
return tm;
case "DT":
DateTimeVR dt = new DateTimeVR();
dt.ByteData = data;
dt.EncodeType = encType;
dt.IsLittleEndian = isLittleEndian;
dt.Tag = t;
return dt;
case "AS":
AgeString aSt = new AgeString();
aSt.ByteData = data;
aSt.EncodeType = encType;
aSt.IsLittleEndian = isLittleEndian;
aSt.Tag = t;
return aSt;
case "IS":
IntegerString iSt = new IntegerString();
iSt.ByteData = data;
iSt.EncodeType = encType;
iSt.IsLittleEndian = isLittleEndian;
iSt.Tag = t;
return iSt;
case "DS":
DecimalString ds = new DecimalString();
ds.ByteData = data;
ds.EncodeType = encType;
ds.IsLittleEndian = isLittleEndian;
ds.Tag = t;
return ds;
case "SS":
SignedShort ss = new SignedShort();
ss.ByteData = data;
ss.EncodeType = encType;
ss.IsLittleEndian = isLittleEndian;
ss.Tag = t;
return ss;
case "US":
UnsignedShort us = new UnsignedShort();
us.ByteData = data;
us.EncodeType = encType;
us.IsLittleEndian = isLittleEndian;
us.Tag = t;
return us;
case "SL":
SignedLong sl = new SignedLong();
sl.ByteData = data;
sl.EncodeType = encType;
sl.IsLittleEndian = isLittleEndian;
sl.Tag = t;
return sl;
case "UL":
UnsignedLong ul = new UnsignedLong();
ul.ByteData = data;
ul.EncodeType = encType;
ul.IsLittleEndian = isLittleEndian;
ul.Tag = t;
return ul;
case "AT":
AttributeTag at = new AttributeTag();
at.ByteData = data;
at.EncodeType = encType;
at.IsLittleEndian = isLittleEndian;
at.Tag = t;
return at;
case "FL":
FloatingPointSingle fl = new FloatingPointSingle();
fl.ByteData = data;
fl.EncodeType = encType;
fl.IsLittleEndian = isLittleEndian;
fl.Tag = t;
return fl;
case "FD":
FloatingPointDouble fd = new FloatingPointDouble();
fd.ByteData = data;
fd.EncodeType = encType;
fd.IsLittleEndian = isLittleEndian;
fd.Tag = t;
return fd;
case "OB":
if (t.Id == TagHelper.PIXEL_DATA)
{
PixelData fd1 = new PixelData(data, encType, isLittleEndian, "OB", isIndefinite);
fd1.Format = isIndefinite ? FrameDataFormat.ENCAPSULATED : FrameDataFormat.NATIVE;
fd1.EncodeType = encType;
fd1.IsLittleEndian = isLittleEndian;
fd1.Tag = t;
return fd1;
}
else
{
OtherByteString ob = new OtherByteString();
ob.ByteData = data;
ob.EncodeType = encType;
ob.IsLittleEndian = isLittleEndian;
ob.Tag = t;
return ob;
}
case "OW":
if (t.Id == TagHelper.PIXEL_DATA)
{
PixelData fd2 = new PixelData(data, encType, isLittleEndian, "OW", isIndefinite);
fd2.Format = isIndefinite ? FrameDataFormat.ENCAPSULATED : FrameDataFormat.NATIVE;
fd2.EncodeType = encType;
fd2.IsLittleEndian = isLittleEndian;
fd2.Tag = t;
return fd2;
}
else
{
OtherWordString ow = new OtherWordString();
ow.ByteData = data;
ow.EncodeType = encType;
ow.IsLittleEndian = isLittleEndian;
ow.Tag = t;
return ow;
}
case "OF":
OtherFloatString of = new OtherFloatString();
of.ByteData = data;
of.EncodeType = encType;
of.IsLittleEndian = isLittleEndian;
of.Tag = t;
return of;
case "SQ":
Sequence s = new Sequence();
s.ByteData = data;
s.EncodeType = encType;
s.IsLittleEndian = isLittleEndian;
s.Tag = t;
s.ReadChildren();
return s;
default:
//Case for unknown VR
DICOMElement dOb = new DICOMElement();
dOb.ByteData = data;
dOb.EncodeType = encType;
dOb.IsLittleEndian = isLittleEndian;
dOb.Tag = t;
return dOb;
}
}
/// <summary>
/// This method writes the two letter ASCII characters (in byte form) of the passed in VR to the
/// binary writer.
/// </summary>
/// <param name="b">The Binary writer to write the bytes to</param>
/// <param name="vr">The two letter string VR to write</param>
/// <param name="encType">The encoding type of this VR</param>
public static void WriteVR(BinaryWriter b, string vr, Constants.EncodeType encType)
{
System.Text.ASCIIEncoding ascii = new System.Text.ASCIIEncoding();
switch (encType)
{
case Constants.EncodeType.IMPLICIT:
return;
case Constants.EncodeType.EXPLICIT_2:
b.Write(ascii.GetBytes(vr)[0]);
b.Write(ascii.GetBytes(vr)[1]);
return;
case Constants.EncodeType.EXPLICIT_4:
b.Write(ascii.GetBytes(vr)[0]);
b.Write(ascii.GetBytes(vr)[1]);
b.Write((byte)0x00);
b.Write((byte)0x00);
return;
}
}
