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; } }