You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
939 lines
34 KiB
939 lines
34 KiB
// using System;
|
|
// using System.Collections.Generic;
|
|
// using System.Globalization;
|
|
// using System.IO;
|
|
// using System.Linq;
|
|
//
|
|
// namespace DICOMCoverter
|
|
// {
|
|
// public enum TypeOfDicomFile
|
|
// {
|
|
// NotDicom,
|
|
// Dicom3File,
|
|
// DicomOldTypeFile,
|
|
// DicomUnknownTransferSyntax
|
|
// };
|
|
//
|
|
// public class DicomDecoder
|
|
// {
|
|
// #region 定义变量与初始化
|
|
//
|
|
// private const uint PIXEL_REPRESENTATION = 0x00280103;
|
|
// private const uint TRANSFER_SYNTAX_UID = 0x00020010;
|
|
// private const uint MODALITY = 0x00080060;
|
|
// private const uint SLICE_THICKNESS = 0x00180050;
|
|
// private const uint SLICE_SPACING = 0x00180088;
|
|
// private const uint SAMPLES_PER_PIXEL = 0x00280002;
|
|
// private const uint PHOTOMETRIC_INTERPRETATION = 0x00280004;
|
|
// private const uint PLANAR_CONFIGURATION = 0x00280006;
|
|
// private const uint NUMBER_OF_FRAMES = 0x00280008;
|
|
// private const uint ROWS = 0x00280010;
|
|
// private const uint COLUMNS = 0x00280011;
|
|
// private const uint PIXEL_SPACING = 0x00280030;
|
|
// private const uint BITS_ALLOCATED = 0x00280100;
|
|
// private const uint WINDOW_CENTER = 0x00281050;
|
|
// private const uint WINDOW_WIDTH = 0x00281051;
|
|
// private const uint RESCALE_INTERCEPT = 0x00281052;
|
|
// private const uint RESCALE_SLOPE = 0x00281053;
|
|
// private const uint RED_PALETTE = 0x00281201;
|
|
// private const uint GREEN_PALETTE = 0x00281202;
|
|
// private const uint BLUE_PALETTE = 0x00281203;
|
|
// private const uint ICON_IMAGE_SEQUENCE = 0x00880200;
|
|
// private const uint PIXEL_DATA = 0x7FE00010;
|
|
//
|
|
// private const string ITEM = "FFFEE000";
|
|
// private const string ITEM_DELIMITATION = "FFFEE00D";
|
|
// private const string SEQUENCE_DELIMITATION = "FFFEE0DD";
|
|
//
|
|
// private const int
|
|
// AE = 0x4145,
|
|
// AS = 0x4153,
|
|
// AT = 0x4154,
|
|
// CS = 0x4353,
|
|
// DA = 0x4441,
|
|
// DS = 0x4453,
|
|
// DT = 0x4454,
|
|
// FD = 0x4644,
|
|
// FL = 0x464C,
|
|
// IS = 0x4953,
|
|
// LO = 0x4C4F,
|
|
// LT = 0x4C54,
|
|
// PN = 0x504E,
|
|
// SH = 0x5348,
|
|
// SL = 0x534C,
|
|
// SS = 0x5353,
|
|
// ST = 0x5354,
|
|
// TM = 0x544D,
|
|
// UI = 0x5549,
|
|
// UL = 0x554C,
|
|
// US = 0x5553,
|
|
// UT = 0x5554,
|
|
// OB = 0x4F42,
|
|
// OW = 0x4F57,
|
|
// SQ = 0x5351,
|
|
// UN = 0x554E,
|
|
// QQ = 0x3F3F,
|
|
// RT = 0x5254;
|
|
//
|
|
// private const int ID_OFFSET = 128; //location of "DICM"
|
|
// private const int IMPLICIT_VR = 0x2D2D; // '--'
|
|
// private const String DICM = "DICM";
|
|
//
|
|
// public int bitsAllocated;
|
|
// public int width;
|
|
// public int height;
|
|
// public int offset;
|
|
// public int nImages;
|
|
// public int samplesPerPixel;
|
|
// public double pixelDepth = 1.0;
|
|
// public double pixelWidth = 1.0;
|
|
// public double pixelHeight = 1.0;
|
|
// public string unit;
|
|
// public double windowCentre, windowWidth;
|
|
// public bool signedImage;
|
|
// public TypeOfDicomFile typeofDicomFile;
|
|
// public List<string> dicomInfo;
|
|
// public bool dicmFound; // "DICM" found at offset 128
|
|
//
|
|
// private DicomDictionary dic;
|
|
// private BinaryReader file;
|
|
// private String dicomFileName;
|
|
//
|
|
// /// <summary>
|
|
// /// Photometric Interpretation有以下几种类型：
|
|
// ///Monochrome2 一般的灰度图像都采用这种，Pixel值越大，图像就越白。
|
|
// ///Monochrome1 只有部分CR, DR图像使用，Pixel值越大，图像就越黑。
|
|
// /// </summary>
|
|
// private String photoInterpretation;
|
|
//
|
|
// private bool littleEndian = true;
|
|
// private bool oddLocations; // one or more tags at odd locations
|
|
// private bool bigEndianTransferSyntax = false;
|
|
// private bool inSequence;
|
|
// private bool widthTagFound;
|
|
// private bool heightTagFound;
|
|
// private bool pixelDataTagFound;
|
|
// private int location = 0;
|
|
// private int elementLength;
|
|
// private int vr; // Value Representation
|
|
// private int min8 = Byte.MinValue;
|
|
// private int max8 = Byte.MaxValue;
|
|
// private int min16 = short.MinValue;
|
|
// private int max16 = ushort.MaxValue;
|
|
// private int pixelRepresentation;
|
|
// private double rescaleIntercept;
|
|
// private double rescaleSlope;
|
|
// private byte[] reds;
|
|
// private byte[] greens;
|
|
// private byte[] blues;
|
|
// private byte[] vrLetters = new byte[2];
|
|
// private List<byte> pixels8;
|
|
// private List<byte> pixels24; // 8 bits bit depth, 3 samples per pixel
|
|
// private List<ushort> pixels16;
|
|
// private List<int> pixels16Int;
|
|
//
|
|
// public DicomDecoder()
|
|
// {
|
|
// dic = new DicomDictionary();
|
|
// signedImage = false;
|
|
// dicomInfo = new List<string>();
|
|
// InitializeDicom();
|
|
// }
|
|
//
|
|
// private void InitializeDicom()
|
|
// {
|
|
// bitsAllocated = 0;
|
|
// width = 1;
|
|
// height = 1;
|
|
// offset = 1;
|
|
// nImages = 1;
|
|
// samplesPerPixel = 1;
|
|
// photoInterpretation = "";
|
|
// unit = "mm";
|
|
// windowCentre = 0;
|
|
// windowWidth = 0;
|
|
// signedImage = false;
|
|
// widthTagFound = false;
|
|
// heightTagFound = false;
|
|
// pixelDataTagFound = false;
|
|
// rescaleIntercept = 0.0; // Default value
|
|
// rescaleSlope = 1.0; // Default value
|
|
// typeofDicomFile = TypeOfDicomFile.NotDicom;
|
|
// }
|
|
//
|
|
// #endregion 定义变量与初始化
|
|
//
|
|
// //public string DicomFileName
|
|
// //{
|
|
// // set
|
|
// // {
|
|
// // dicomFileName = value;
|
|
// // InitializeDicom();
|
|
//
|
|
// // // Thanks to CodeProject member Alphons van der Heijden for
|
|
// // // suggesting to add this - FileAccess.Read (July 2010)
|
|
// // file = new BinaryReader(File.Open(dicomFileName, FileMode.Open, FileAccess.Read));
|
|
// // location = 0; // Reset the location
|
|
// // dicomInfo.Clear();
|
|
// // try
|
|
// // {
|
|
// // bool readResult = ReadFileInfo();
|
|
// // if (readResult && widthTagFound && heightTagFound && pixelDataTagFound)
|
|
// // {
|
|
// // ReadPixels();
|
|
// // if (dicmFound == true)
|
|
// // typeofDicomFile = TypeOfDicomFile.Dicom3File;
|
|
// // else
|
|
// // typeofDicomFile = TypeOfDicomFile.DicomOldTypeFile;
|
|
// // }
|
|
// // }
|
|
// // catch
|
|
// // {
|
|
// // // Nothing here
|
|
// // }
|
|
// // finally
|
|
// // {
|
|
// // file.Close();
|
|
// // }
|
|
// // }
|
|
// //}
|
|
//
|
|
// /// <summary>
|
|
// ///读取dicom文件及操作
|
|
// ///<famenum>取图片第几帧</famenum>
|
|
// /// </summary>
|
|
// public void ReadDicomFile(string path, int famenum = 1)
|
|
// {
|
|
// file = new BinaryReader(File.Open(path, FileMode.Open, FileAccess.Read));
|
|
// location = 0; // Reset the location
|
|
// dicomInfo.Clear();
|
|
// try
|
|
// {
|
|
// //读Tag信息
|
|
// bool readResult = ReadFileInfo();
|
|
// //图片宽高及图像数据都已读到
|
|
// if (readResult && widthTagFound && heightTagFound && pixelDataTagFound)
|
|
// {
|
|
// ////存在多帧图像
|
|
// //if (nImages > 1)
|
|
// //{
|
|
// // for (int i = 1; i < nImages; i++)
|
|
// // {
|
|
// // ReadPixels(i);
|
|
// // }
|
|
// //}
|
|
// //else {
|
|
// // //读取图片数据
|
|
// // ReadPixels();
|
|
// //}
|
|
//
|
|
// ReadPixels();
|
|
//
|
|
// if (dicmFound == true)
|
|
// typeofDicomFile = TypeOfDicomFile.Dicom3File;
|
|
// else
|
|
// typeofDicomFile = TypeOfDicomFile.DicomOldTypeFile;
|
|
// }
|
|
// }
|
|
// catch (Exception ex)
|
|
// {
|
|
// // Nothing here
|
|
// }
|
|
// finally
|
|
// {
|
|
// file.Close();
|
|
// }
|
|
// }
|
|
//
|
|
// private void BuildImage()
|
|
// {
|
|
// }
|
|
//
|
|
// public void GetPixels8(ref List<byte> pixels)
|
|
// {
|
|
// pixels = pixels8;
|
|
// }
|
|
//
|
|
// public void GetPixels16(ref List<ushort> pixels)
|
|
// {
|
|
// pixels = pixels16;
|
|
// }
|
|
//
|
|
// public void GetPixels24(ref List<byte> pixels)
|
|
// {
|
|
// pixels = pixels24;
|
|
// }
|
|
//
|
|
// private String GetString(int length)
|
|
// {
|
|
// byte[] buf = new byte[length];
|
|
// file.BaseStream.Position = location;
|
|
// int count = file.Read(buf, 0, length);
|
|
// location += length;
|
|
// string s = System.Text.ASCIIEncoding.ASCII.GetString(buf);
|
|
// return s;
|
|
// }
|
|
//
|
|
// private byte GetByte() // Changed return type to byte
|
|
// {
|
|
// file.BaseStream.Position = location;
|
|
// byte b = file.ReadByte();
|
|
// ++location;
|
|
// return b;
|
|
// }
|
|
//
|
|
// private ushort GetShort() // Changed return type to ushort
|
|
// {
|
|
// byte b0 = GetByte();
|
|
// byte b1 = GetByte();
|
|
// ushort s;
|
|
// if (littleEndian)
|
|
// s = Convert.ToUInt16((b1 << 8) + b0);
|
|
// else
|
|
// s = Convert.ToUInt16((b0 << 8) + b1);
|
|
// return s;
|
|
// }
|
|
//
|
|
// private int GetInt()
|
|
// {
|
|
// byte b0 = GetByte();
|
|
// byte b1 = GetByte();
|
|
// byte b2 = GetByte();
|
|
// byte b3 = GetByte();
|
|
// int i;
|
|
// if (littleEndian)
|
|
// i = (b3 << 24) + (b2 << 16) + (b1 << 8) + b0;
|
|
// else
|
|
// i = (b0 << 24) + (b1 << 16) + (b2 << 8) + b3;
|
|
// return i;
|
|
// }
|
|
//
|
|
// private double GetDouble()
|
|
// {
|
|
// byte b0 = GetByte();
|
|
// byte b1 = GetByte();
|
|
// byte b2 = GetByte();
|
|
// byte b3 = GetByte();
|
|
// byte b4 = GetByte();
|
|
// byte b5 = GetByte();
|
|
// byte b6 = GetByte();
|
|
// byte b7 = GetByte();
|
|
//
|
|
// long res = 0;
|
|
// if (littleEndian)
|
|
// {
|
|
// res += b0;
|
|
// res += (((long)b1) << 8);
|
|
// res += (((long)b2) << 16);
|
|
// res += (((long)b3) << 24);
|
|
// res += (((long)b4) << 32);
|
|
// res += (((long)b5) << 40);
|
|
// res += (((long)b6) << 48);
|
|
// res += (((long)b7) << 56);
|
|
// }
|
|
// else
|
|
// {
|
|
// res += b7;
|
|
// res += (((long)b6) << 8);
|
|
// res += (((long)b5) << 16);
|
|
// res += (((long)b4) << 24);
|
|
// res += (((long)b3) << 32);
|
|
// res += (((long)b2) << 40);
|
|
// res += (((long)b1) << 48);
|
|
// res += (((long)b0) << 56);
|
|
// }
|
|
//
|
|
// double d = Convert.ToDouble(res, new CultureInfo("en-US"));
|
|
// return d;
|
|
// }
|
|
//
|
|
// private float GetFloat()
|
|
// {
|
|
// byte b0 = GetByte();
|
|
// byte b1 = GetByte();
|
|
// byte b2 = GetByte();
|
|
// byte b3 = GetByte();
|
|
//
|
|
// int res = 0;
|
|
//
|
|
// if (littleEndian)
|
|
// {
|
|
// res += b0;
|
|
// res += (((int)b1) << 8);
|
|
// res += (((int)b2) << 16);
|
|
// res += (((int)b3) << 24);
|
|
// }
|
|
// else
|
|
// {
|
|
// res += b3;
|
|
// res += (((int)b2) << 8);
|
|
// res += (((int)b1) << 16);
|
|
// res += (((int)b0) << 24);
|
|
// }
|
|
//
|
|
// float f1;
|
|
// f1 = Convert.ToSingle(res, new CultureInfo("en-US"));
|
|
// return f1;
|
|
// }
|
|
//
|
|
// private byte[] GetLut(int length)
|
|
// {
|
|
// if ((length & 1) != 0) // odd
|
|
// {
|
|
// String dummy = GetString(length);
|
|
// return null;
|
|
// }
|
|
//
|
|
// length /= 2;
|
|
// byte[] lut = new byte[length];
|
|
// for (int i = 0; i < length; ++i)
|
|
// lut[i] = Convert.ToByte(GetShort() >> 8);
|
|
// return lut;
|
|
// }
|
|
//
|
|
// private int GetLength()
|
|
// {
|
|
// byte b0 = GetByte();
|
|
// byte b1 = GetByte();
|
|
// byte b2 = GetByte();
|
|
// byte b3 = GetByte();
|
|
//
|
|
// // Cannot know whether the VR is implicit or explicit without the
|
|
// // complete Dicom Data Dictionary.
|
|
// vr = (b0 << 8) + b1;
|
|
//
|
|
// switch (vr)
|
|
// {
|
|
// case OB:
|
|
// case OW:
|
|
// case SQ:
|
|
// case UN:
|
|
// case UT:
|
|
// // Explicit VR with 32-bit length if other two bytes are zero
|
|
// if ((b2 == 0) || (b3 == 0)) return GetInt();
|
|
// // Implicit VR with 32-bit length
|
|
// vr = IMPLICIT_VR;
|
|
// if (littleEndian)
|
|
// return ((b3 << 24) + (b2 << 16) + (b1 << 8) + b0);
|
|
// else
|
|
// return ((b0 << 24) + (b1 << 16) + (b2 << 8) + b3);
|
|
// // break; // Not necessary
|
|
// case AE:
|
|
// case AS:
|
|
// case AT:
|
|
// case CS:
|
|
// case DA:
|
|
// case DS:
|
|
// case DT:
|
|
// case FD:
|
|
// case FL:
|
|
// case IS:
|
|
// case LO:
|
|
// case LT:
|
|
// case PN:
|
|
// case SH:
|
|
// case SL:
|
|
// case SS:
|
|
// case ST:
|
|
// case TM:
|
|
// case UI:
|
|
// case UL:
|
|
// case US:
|
|
// case QQ:
|
|
// case RT:
|
|
// // Explicit vr with 16-bit length
|
|
// if (littleEndian)
|
|
// return ((b3 << 8) + b2);
|
|
// else
|
|
// return ((b2 << 8) + b3);
|
|
//
|
|
// default:
|
|
// // Implicit VR with 32-bit length...
|
|
// vr = IMPLICIT_VR;
|
|
// if (littleEndian)
|
|
// return ((b3 << 24) + (b2 << 16) + (b1 << 8) + b0);
|
|
// else
|
|
// return ((b0 << 24) + (b1 << 16) + (b2 << 8) + b3);
|
|
// }
|
|
// }
|
|
//
|
|
// private int GetNextTag()
|
|
// {
|
|
// int groupWord = GetShort();
|
|
// if (groupWord == 0x0800 && bigEndianTransferSyntax)
|
|
// {
|
|
// littleEndian = false;
|
|
// groupWord = 0x0008;
|
|
// }
|
|
// int elementWord = GetShort();
|
|
// int tag = groupWord << 16 | elementWord;
|
|
//
|
|
// elementLength = GetLength();
|
|
//
|
|
// // Hack to read some GE files
|
|
// if (elementLength == 13 && !oddLocations)
|
|
// elementLength = 10;
|
|
//
|
|
// // "Undefined" element length.
|
|
// // This is a sort of bracket that encloses a sequence of elements.
|
|
// if (elementLength == -1)
|
|
// {
|
|
// elementLength = 0;
|
|
// inSequence = true;
|
|
// }
|
|
// return tag;
|
|
// }
|
|
//
|
|
// private String GetHeaderInfo(int tag, String value)
|
|
// {
|
|
// string str = tag.ToString("X8");
|
|
// if (str == ITEM_DELIMITATION || str == SEQUENCE_DELIMITATION)
|
|
// {
|
|
// inSequence = false;
|
|
// return null;
|
|
// }
|
|
//
|
|
// string id = null;
|
|
//
|
|
// if (dic.dict.ContainsKey(str))
|
|
// {
|
|
// id = dic.dict[str];
|
|
// if (id != null)
|
|
// {
|
|
// if (vr == IMPLICIT_VR)
|
|
// vr = (id[0] << 8) + id[1];
|
|
// id = id.Substring(2);
|
|
// }
|
|
// }
|
|
//
|
|
// if (str == ITEM)
|
|
// return (id != null ? id : ":null");
|
|
// if (value != null)
|
|
// return id + ": " + value;
|
|
//
|
|
// switch (vr)
|
|
// {
|
|
// case FD:
|
|
// for (int i = 0; i < elementLength; ++i)
|
|
// GetByte();
|
|
// break;
|
|
//
|
|
// case FL:
|
|
// for (int i = 0; i < elementLength; i++)
|
|
// GetByte();
|
|
// break;
|
|
//
|
|
// case AE:
|
|
// case AS:
|
|
// case AT:
|
|
// case CS:
|
|
// case DA:
|
|
// case DS:
|
|
// case DT:
|
|
// case IS:
|
|
// case LO:
|
|
// case LT:
|
|
// case PN:
|
|
// case SH:
|
|
// case ST:
|
|
// case TM:
|
|
// case UI:
|
|
// value = GetString(elementLength);
|
|
// break;
|
|
//
|
|
// case US:
|
|
// if (elementLength == 2)
|
|
// value = Convert.ToString(GetShort());
|
|
// else
|
|
// {
|
|
// value = "";
|
|
// int n = elementLength / 2;
|
|
// for (int i = 0; i < n; i++)
|
|
// value += Convert.ToString(GetShort()) + " ";
|
|
// }
|
|
// break;
|
|
//
|
|
// case IMPLICIT_VR:
|
|
// value = GetString(elementLength);
|
|
// if (elementLength > 44)
|
|
// value = null;
|
|
// break;
|
|
//
|
|
// case SQ:
|
|
// value = "";
|
|
// bool privateTag = ((tag >> 16) & 1) != 0;
|
|
// if (tag != ICON_IMAGE_SEQUENCE && !privateTag)
|
|
// break;
|
|
// goto default;
|
|
// default:
|
|
// location += elementLength;
|
|
// value = "";
|
|
// break;
|
|
// }
|
|
//
|
|
// if (value != null && id == null && value != "")
|
|
// return "---: " + value;
|
|
// else if (id == null)
|
|
// return null;
|
|
// else
|
|
// return id + ": " + value;
|
|
// }
|
|
//
|
|
// private void AddInfo(int tag, string value)
|
|
// {
|
|
// string info = GetHeaderInfo(tag, value);
|
|
//
|
|
// string str = tag.ToString("X");
|
|
// string strPadded = str.PadLeft(8, '0');
|
|
// string strInfo;
|
|
// if (inSequence && info != null && vr != SQ)
|
|
// info = ">" + info;
|
|
// if (info != null && str != ITEM)
|
|
// {
|
|
// if (info.Contains("---"))
|
|
// strInfo = info.Replace("---", "Private Tag");
|
|
// else
|
|
// strInfo = info;
|
|
//
|
|
// dicomInfo.Add(strPadded + "//" + strInfo);
|
|
// }
|
|
// }
|
|
//
|
|
// private void AddInfo(int tag, int value)
|
|
// {
|
|
// AddInfo(tag, Convert.ToString(value));
|
|
// }
|
|
//
|
|
// private void GetSpatialScale(String scale)
|
|
// {
|
|
// double xscale = 0, yscale = 0;
|
|
// int i = scale.IndexOf('\\');
|
|
// if (i == 1) // Aug 2012, Fixed an issue found while opening some images
|
|
// {
|
|
// yscale = Convert.ToDouble(scale.Substring(0, i), new CultureInfo("en-US"));
|
|
// xscale = Convert.ToDouble(scale.Substring(i + 1), new CultureInfo("en-US"));
|
|
// }
|
|
// if (xscale != 0.0 && yscale != 0.0)
|
|
// {
|
|
// pixelWidth = xscale;
|
|
// pixelHeight = yscale;
|
|
// unit = "mm";
|
|
// }
|
|
// }
|
|
//
|
|
// /// <summary>
|
|
// /// 读取Tag信息
|
|
// /// </summary>
|
|
// /// <returns></returns>
|
|
// public bool ReadFileInfo()
|
|
// {
|
|
// long skipCount = Convert.ToInt32(ID_OFFSET);
|
|
// bitsAllocated = 16;
|
|
//
|
|
// file.BaseStream.Seek(skipCount, SeekOrigin.Begin);
|
|
// location += ID_OFFSET;
|
|
//
|
|
// if (GetString(4) != DICM)
|
|
// {
|
|
// // This is for reading older DICOM files (Before 3.0)
|
|
// // Seek from the beginning of the file
|
|
// file.BaseStream.Seek(0, SeekOrigin.Begin);
|
|
// location = 0;
|
|
//
|
|
// // Older DICOM files do not have the preamble and prefix
|
|
// dicmFound = false;
|
|
//
|
|
// // Continue reading further.
|
|
// // See whether the width, height and pixel data tags
|
|
// // are present. If these tags are present, then it we conclude that this is a
|
|
// // DICOM file, because all DICOM files should have at least these three tags.
|
|
// // Otherwise, it is not a DICOM file.
|
|
// }
|
|
// else
|
|
// {
|
|
// // We have a DICOM 3.0 file
|
|
// dicmFound = true;
|
|
// }
|
|
//
|
|
// bool decodingTags = true;
|
|
// samplesPerPixel = 1;
|
|
// int planarConfiguration = 0;
|
|
// photoInterpretation = "";
|
|
// string modality;
|
|
//
|
|
// while (decodingTags)
|
|
// {
|
|
// int tag = GetNextTag();
|
|
// if ((location & 1) != 0)
|
|
// oddLocations = true;
|
|
//
|
|
// if (inSequence)
|
|
// {
|
|
// AddInfo(tag, null);
|
|
// continue;
|
|
// }
|
|
//
|
|
// string s;
|
|
// switch (tag)
|
|
// {
|
|
// case (int)(TRANSFER_SYNTAX_UID):
|
|
// s = GetString(elementLength);
|
|
// AddInfo(tag, s);
|
|
// //if (s.IndexOf("1.2.4") > -1 || s.IndexOf("1.2.5") > -1)
|
|
// //{
|
|
// // file.Close();
|
|
// // typeofDicomFile = TypeOfDicomFile.DicomUnknownTransferSyntax;
|
|
// // // Return gracefully indicating that this type of
|
|
// // // Transfer Syntax cannot be handled
|
|
// // return false;
|
|
// //}
|
|
// if (s.IndexOf("1.2.840.10008.1.2.2") >= 0)
|
|
// bigEndianTransferSyntax = true;
|
|
// break;
|
|
//
|
|
// case (int)MODALITY:
|
|
// modality = GetString(elementLength);
|
|
// AddInfo(tag, modality);
|
|
// break;
|
|
//
|
|
// case (int)(NUMBER_OF_FRAMES):
|
|
// s = GetString(elementLength);
|
|
// AddInfo(tag, s);
|
|
// double frames = Convert.ToDouble(s, new CultureInfo("en-US"));
|
|
// if (frames > 1.0)
|
|
// nImages = (int)frames;
|
|
// break;
|
|
//
|
|
// case (int)(SAMPLES_PER_PIXEL):
|
|
// samplesPerPixel = GetShort();
|
|
// AddInfo(tag, samplesPerPixel);
|
|
// break;
|
|
//
|
|
// case (int)(PHOTOMETRIC_INTERPRETATION):
|
|
// photoInterpretation = GetString(elementLength);
|
|
// photoInterpretation = photoInterpretation.Trim();
|
|
// AddInfo(tag, photoInterpretation);
|
|
// break;
|
|
//
|
|
// case (int)(PLANAR_CONFIGURATION):
|
|
// planarConfiguration = GetShort();
|
|
// AddInfo(tag, planarConfiguration);
|
|
// break;
|
|
//
|
|
// case (int)(ROWS):
|
|
// height = GetShort();
|
|
// AddInfo(tag, height);
|
|
// heightTagFound = true;
|
|
// break;
|
|
//
|
|
// case (int)(COLUMNS):
|
|
// width = GetShort();
|
|
// AddInfo(tag, width);
|
|
// widthTagFound = true;
|
|
// break;
|
|
//
|
|
// case (int)(PIXEL_SPACING):
|
|
// String scale = GetString(elementLength);
|
|
// GetSpatialScale(scale);
|
|
// AddInfo(tag, scale);
|
|
// break;
|
|
//
|
|
// case (int)(SLICE_THICKNESS):
|
|
// case (int)(SLICE_SPACING):
|
|
// String spacing = GetString(elementLength);
|
|
// pixelDepth = Convert.ToDouble(spacing, new CultureInfo("en-US"));
|
|
// AddInfo(tag, spacing);
|
|
// break;
|
|
//
|
|
// case (int)(BITS_ALLOCATED):
|
|
// bitsAllocated = GetShort();
|
|
// AddInfo(tag, bitsAllocated);
|
|
// break;
|
|
//
|
|
// case (int)(PIXEL_REPRESENTATION):
|
|
// pixelRepresentation = GetShort();
|
|
// AddInfo(tag, pixelRepresentation);
|
|
// break;
|
|
//
|
|
// case (int)(WINDOW_CENTER):
|
|
// String center = GetString(elementLength);
|
|
// int index = center.IndexOf('\\');
|
|
// if (index != -1) center = center.Substring(index + 1);
|
|
// windowCentre = Convert.ToDouble(center, new CultureInfo("en-US"));
|
|
// AddInfo(tag, center);
|
|
// break;
|
|
//
|
|
// case (int)(WINDOW_WIDTH):
|
|
// String widthS = GetString(elementLength);
|
|
// index = widthS.IndexOf('\\');
|
|
// if (index != -1) widthS = widthS.Substring(index + 1);
|
|
// windowWidth = Convert.ToDouble(widthS, new CultureInfo("en-US"));
|
|
// AddInfo(tag, widthS);
|
|
// break;
|
|
//
|
|
// case (int)(RESCALE_INTERCEPT):
|
|
// String intercept = GetString(elementLength);
|
|
// rescaleIntercept = Convert.ToDouble(intercept, new CultureInfo("en-US"));
|
|
// AddInfo(tag, intercept);
|
|
// break;
|
|
//
|
|
// case (int)(RESCALE_SLOPE):
|
|
// String slop = GetString(elementLength);
|
|
// rescaleSlope = Convert.ToDouble(slop, new CultureInfo("en-US"));
|
|
// AddInfo(tag, slop);
|
|
// break;
|
|
//
|
|
// case (int)(RED_PALETTE):
|
|
// reds = GetLut(elementLength);
|
|
// AddInfo(tag, elementLength / 2);
|
|
// break;
|
|
//
|
|
// case (int)(GREEN_PALETTE):
|
|
// greens = GetLut(elementLength);
|
|
// AddInfo(tag, elementLength / 2);
|
|
// break;
|
|
//
|
|
// case (int)(BLUE_PALETTE):
|
|
// blues = GetLut(elementLength);
|
|
// AddInfo(tag, elementLength / 2);
|
|
// break;
|
|
//
|
|
// case (int)(PIXEL_DATA):
|
|
// // Start of image data...
|
|
// if (elementLength != 0)
|
|
// {
|
|
// offset = location;
|
|
// AddInfo(tag, location);
|
|
// decodingTags = false;
|
|
// }
|
|
// else
|
|
// AddInfo(tag, null);
|
|
// pixelDataTagFound = true;
|
|
// break;
|
|
// //case Convert.ToInt64(ITEM, 16):
|
|
//
|
|
// // break;
|
|
// default:
|
|
// AddInfo(tag, null);
|
|
// break;
|
|
// }
|
|
// }
|
|
// return true;
|
|
// }
|
|
//
|
|
// /// <summary>
|
|
// /// 读取图片信息(从1 开始)
|
|
// /// <famenum>取图片第几帧</famenum>
|
|
// /// </summary>
|
|
// private void ReadPixels(int famenum = 1)
|
|
// {
|
|
// //if (famenum > 1)
|
|
// //{
|
|
// // //默认offset就是第一帧的位置
|
|
// // offset = width * height * (famenum - 1);
|
|
// //}
|
|
//
|
|
// if (samplesPerPixel == 1 && bitsAllocated == 8)
|
|
// {
|
|
// if (pixels8 != null)
|
|
// pixels8.Clear();
|
|
// pixels8 = new List<byte>();
|
|
// int numPixels = width * height;
|
|
// byte[] buf = new byte[numPixels];
|
|
//
|
|
// file.BaseStream.Position = offset;
|
|
// file.Read(buf, 0, numPixels);
|
|
//
|
|
// for (int i = 0; i < numPixels; ++i)
|
|
// {
|
|
// int pixVal = (int)(buf[i] * rescaleSlope + rescaleIntercept);
|
|
//
|
|
// if (photoInterpretation == "MONOCHROME1")
|
|
// pixVal = max8 - pixVal;
|
|
//
|
|
// pixels8.Add((byte)(pixelRepresentation == 1 ? pixVal : (pixVal - min8)));
|
|
// }
|
|
// }
|
|
//
|
|
// if (samplesPerPixel == 1 && bitsAllocated == 16)
|
|
// {
|
|
// if (pixels16 != null)
|
|
// pixels16.Clear();
|
|
// if (pixels16Int != null)
|
|
// pixels16Int.Clear();
|
|
//
|
|
// pixels16 = new List<ushort>();
|
|
// pixels16Int = new List<int>();
|
|
// int numPixels = width * height;
|
|
// byte[] bufByte = new byte[numPixels * 2];
|
|
// byte[] signedData = new byte[2];
|
|
// file.BaseStream.Position = offset;
|
|
// file.Read(bufByte, 0, numPixels * 2);
|
|
// ushort unsignedS;
|
|
// int i, i1, pixVal;
|
|
// byte b0, b1;
|
|
//
|
|
// for (i = 0; i < numPixels; ++i)
|
|
// {
|
|
// i1 = i * 2;
|
|
// b0 = bufByte[i1];
|
|
// b1 = bufByte[i1 + 1];
|
|
// unsignedS = Convert.ToUInt16((b1 << 8) + b0);
|
|
// if (pixelRepresentation == 0) // Unsigned
|
|
// {
|
|
// pixVal = (int)(unsignedS * rescaleSlope + rescaleIntercept);
|
|
// if (photoInterpretation == "MONOCHROME1")
|
|
// pixVal = max16 - pixVal;
|
|
// }
|
|
// else // Pixel representation is 1, indicating a 2s complement image
|
|
// {
|
|
// signedData[0] = b0;
|
|
// signedData[1] = b1;
|
|
// short sVal = System.BitConverter.ToInt16(signedData, 0);
|
|
//
|
|
// // Need to consider rescale slope and intercepts to compute the final pixel value
|
|
// pixVal = (int)(sVal * rescaleSlope + rescaleIntercept);
|
|
// if (photoInterpretation == "MONOCHROME1")
|
|
// pixVal = max16 - pixVal;
|
|
// }
|
|
// pixels16Int.Add(pixVal);
|
|
// }
|
|
//
|
|
// int minPixVal = pixels16Int.Min();
|
|
// signedImage = false;
|
|
// if (minPixVal < 0) signedImage = true;
|
|
//
|
|
// // Use the above pixel data to populate the list pixels16
|
|
// foreach (int pixel in pixels16Int)
|
|
// {
|
|
// // We internally convert all 16-bit images to the range 0 - 65535
|
|
// if (signedImage)
|
|
// pixels16.Add((ushort)(pixel - min16));
|
|
// else
|
|
// pixels16.Add((ushort)(pixel));
|
|
// }
|
|
//
|
|
// pixels16Int.Clear();
|
|
// }
|
|
//
|
|
// // 30 July 2010 - to account for Ultrasound images
|
|
// if (samplesPerPixel == 3 && bitsAllocated == 8)
|
|
// {
|
|
// signedImage = false;
|
|
// if (pixels24 != null)
|
|
// pixels24.Clear();
|
|
// pixels24 = new List<byte>();
|
|
// int numPixels = width * height;
|
|
// int numBytes = numPixels * samplesPerPixel;
|
|
// byte[] buf = new byte[numBytes];
|
|
// file.BaseStream.Position = offset;
|
|
// file.Read(buf, 0, numBytes);
|
|
//
|
|
// for (int i = 0; i < numBytes; ++i)
|
|
// {
|
|
// pixels24.Add(buf[i]);
|
|
// }
|
|
// }
|
|
// }
|
|
// }
|
|
// } |