/** ======================================================
*
* Reads a Dicom RT Structure file and produces a 3D mesh
* from the data within. Structure files contain several
* different structures and each of these is turned into
* a separate mesh.
*
* ======================================================= **/
void LoadStructureSet(FileInfo file, string fname)
{
Stopwatch sw = new Stopwatch();
Stopwatch sw2 = new Stopwatch();
Stopwatch swCPU = new Stopwatch();
Stopwatch swMarch = new Stopwatch();
FileStream fs = new FileStream(file.FullName, FileMode.Open, FileAccess.Read);
List <string> objectNames = new List <string>();
int block = 0;
List <Color> colours = new List <Color>();
List <List <float> > ranges = new List <List <float> >();
List <MeshMaker.ModelData> modelData = new List <MeshMaker.ModelData>();
List <List <List <Vector3> > > zData = new List <List <List <Vector3> > >();
List <List <Vector3> > sData = new List <List <Vector3> >();
float zCounter = 0;
float zLast = float.MinValue;
bool zNew = true;
bool singlePoint = false;
Vector3 point = Vector3.zero;
float xMin = float.MaxValue; float xMax = float.MinValue;
float yMin = float.MaxValue; float yMax = float.MinValue;
float zMin = float.MaxValue; float zMax = float.MinValue;
int models = 0;
HashSet <string> sequenceBlocks = FileReader.GetSequenceBlocks();
Dictionary <int, string> nameList = new Dictionary <int, string>();
List <int> structNumbers = new List <int>();
int currentNumber = 0;
bool zDistFound = false;
float zMod = 1;
float zH1 = 0;
float zH2 = 0;
float zState = 0;
sw.Start();
sw2.Start();
//General process of reading the DICOM files:
//0. Some DICOM files seem to contain unknown header information in a non tag format
// To skip past this data, we search for a signpost to normality. In other words
// one of the following tags: "0008,0005" "0008,0016" "0008,0018"
// If none of these can be found we bail after some number of characters, as
// we have no hope of accomplishing anything in the unknown location we are in.
//1. Skip all non relevant tags
// These are of the type - Tag 4 bytes, Length 4 bytes, Data Length bytes
//
//2. Some tags denote sequences or encapsulated data
// There are two main types - Tag 4 bytes, Length 4 bytes, <Data>
// - Tag 4 bytes, Length 4 bytes, <Data>, Tag 4 bytes, Length 4 bytes
// These tags have to be checked carefully as <Data> represents a series of type 1. tags
// Method used here is to skip reading the data portion when a sequence tag is found
// Checked against FileReader.S_1, S_2, etc.
//
//3. The data we actually we want is found using the colour tag: "3006,002A"
// A colour tag is followed by a data tag: "3006,0050" and the pixel data it contains
//
//4. Once the first colour tag is found, each subsequent colour tag becomes a new structure object.
//
//5. Lastly, the file contains a list of names that match the structure objects previously found.
// The tag for these is "3006,0085". The list is in the same order as the structures.
int bailLimit = 500;
bool started = false;
while (fs.Position < fs.Length && fs.Position >= 0)
{
string tag = FileReader.GetNextTag(fs);
int length;
if (!started)
{
if (tag == FileReader.S_SP_1 || tag == FileReader.S_SP_2 || tag == FileReader.S_SP_3)
{
started = true;
length = FileReader.GetNextLength(fs);
fs.Position += length;
continue;
}
else
{
if (fs.Position >= bailLimit)
{
//Failed to load this file
Logger.Log("Failed to load model from file: " + file.FullName);
break;
}
if (tag != "0000,0000")
{
// string tag0 = FileReader.GetNextTag(fs);
// fs.Position -= 4;
// print("Tag: " + tag + " " + tag0);
}
fs.Position -= 3;
bailLimit += 1;
continue;
}
}
if (tag == FileReader.S_ID_0)
{
fs.Position += 4;
length = 2;
currentNumber = FileReader.GetDataIntString(fs, length);
continue;
}
if (tag == FileReader.S_NAME_0)
{
length = FileReader.GetNextLength(fs);
string s = FileReader.GetData(fs, length);
nameList.Add(currentNumber, s);
// print("Added Number/Name: " + currentNumber + ", " + s);
continue;
}
if (tag == FileReader.S_DATA_ID)
{
fs.Position += 4;
length = 2;
int n = FileReader.GetDataIntString(fs, 2);
if (structNumbers.Count <= models)
{
structNumbers.Add(n);
// print("Added Struct Number: " + structNumbers[structNumbers.Count-1]);
}
continue;
}
if (sequenceBlocks.Contains(tag))
{
fs.Position += 4;
continue;
}
if (tag == "FFFF,FFFF")
{
//Blank tag
continue;
}
//A new structure entry denoted by a colour tag (2nd object onwards)
//Mesh for previous structure is created here, and related vars reset.
if (block == 12 && tag == FileReader.S_COL)
{
block = 0;
List <float> values = new List <float>();
values.Add(xMin); values.Add(xMax);
values.Add(yMin); values.Add(yMax);
values.Add(zMin); values.Add(zMax);
ranges.Add(values);
xMin = float.MaxValue; xMax = float.MinValue;
yMin = float.MaxValue; yMax = float.MinValue;
zMin = float.MaxValue; zMax = float.MinValue;
//Create mesh for current model and reset vars for the next
if ((meshRangeOverride != -1 && models == meshRangeOverride) ||
(meshRangeOverride == -1 && models >= meshRangeMin && models <= meshRangeMax))
{
if (drawMesh)
{
if (!singlePoint)
{
modelData.Add(MeshMaker.CreateModelData(zData, ranges[ranges.Count - 1], meshMarcher, models,
colours[colours.Count - 1], swMarch, ""));
}
else
{
modelData.Add(MeshMaker.CreateModelData(point, ""));
}
}
}
zData = new List <List <List <Vector3> > >();
sData = new List <List <Vector3> >();
zNew = true;
zCounter = 0;
singlePoint = false;
models++;
}
//Read colour of structure
if ((block == 0 || block == 11) && tag == FileReader.S_COL)
{
length = FileReader.GetNextLength(fs);
byte[] bytes = new byte[length];
fs.Read(bytes, 0, length);
string s = "";
foreach (byte b in bytes)
{
s += (char)b;
}
// print("Colour found: " + s + " | " + (fs.Position-(8+length)));
string[] ss = s.Split('\\');
Color c = new Color(float.Parse(ss[0]) / 255, float.Parse(ss[1]) / 255, float.Parse(ss[2]) / 255);
if (block == 11)
{
// colours[colours.Count-1] = c;
}
else
{
block = 11;
colours.Add(c);
// print("Colour added: " + s);
}
continue;
}
//Read structure contour data
if ((block == 11 || block == 12) && tag == FileReader.S_DATA)
{
if (block == 11)
{
block = 12;
}
length = FileReader.GetNextLength(fs);
// print("Data found: " + length + " | " + (fs.Position-(8)));
byte[] bytes = new byte[length];
//Read and add points to list
fs.Read(bytes, 0, length);
List <Vector3> points = new List <Vector3>();
float[] p = new float[3];
int pCounter = 0;
string current = "";
foreach (byte b in bytes)
{
char c = (char)b;
if (c == '\\')
{
p[pCounter] = float.Parse(current);
pCounter++;
current = "";
if (pCounter == 3)
{
pCounter = 0;
points.Add(new Vector3(p[0], p[1], p[2]));
p = new float[3];
}
}
else
{
current += c;
}
}
//Add last point
p[pCounter] = float.Parse(current);
points.Add(new Vector3(p[0], p[1], p[2]));
float vz = points[0].z * zMod;
if (vz < zMin)
{
zMin = vz;
}
if (vz > zMax)
{
zMax = vz;
}
//Points are added to lists based on slice and structure data
//There can be multiple structures per slice (i.e. neck and arms)
if (!zNew && vz != zLast)
{
zData.Add(sData);
sData = new List <List <Vector3> >();
sData.Add(points);
zCounter++;
zLast = vz;
if (zState == 0)
{
zH1 = vz;
zState = 1;
}
else if (zState == 1)
{
zH2 = vz;
zState = 2;
}
}
if (points.Count == 1)
{
// print(models + " Single Point: " + points[0]);
singlePoint = true;
point = points[0];
}
if (zNew)
{
zNew = false;
}
for (int i = 0; i < points.Count; i++)
{
Vector3 v = points[i];
if (v.x < xMin)
{
xMin = v.x;
}
if (v.x > xMax)
{
xMax = v.x;
}
if (v.y < yMin)
{
yMin = v.y;
}
if (v.y > yMax)
{
yMax = v.y;
}
}
continue;
}
//Normal Tag
length = FileReader.GetNextLength(fs);
fs.Position += length;
}
for (int i = 0; i < objectNames.Count; i++)
{
print(objectNames[i]);
}
//Could redesign this to remove duplicate code, duplicate is under "if (block == 31 && tag == S_COL)"
List <float> values2 = new List <float>();
values2.Add(xMin); values2.Add(xMax);
values2.Add(yMin); values2.Add(yMax);
values2.Add(zMin); values2.Add(zMax);
ranges.Add(values2);
models++;
print(file.Name + " read: " + colours.Count + " colours, " + models + " models");
//Create mesh for final model
if ((meshRangeOverride != -1 && models == meshRangeOverride) ||
(meshRangeOverride == -1 && models >= meshRangeMin && models <= meshRangeMax))
{
if (drawMesh)
{
if (!singlePoint)
{
modelData.Add(MeshMaker.CreateModelData(zData, ranges[ranges.Count - 1], meshMarcher, models,
colours[colours.Count - 1], swMarch, ""));
}
else
{
modelData.Add(MeshMaker.CreateModelData(point, ""));
}
}
}
bool isoFound = false;
int isoIdx = 0;
for (int i = 0; i < modelData.Count; i++)
{
string s = "Unknown " + i;
if (nameList.ContainsKey(structNumbers[i]))
{
s = nameList[structNumbers[i]];
}
modelData[i].name = s;
string nameLower = s.ToLower();
if (modelData[i].point && !isoFound)
{
if (nameLower.Contains("isocenter") || nameLower.Contains("izocenter") ||
nameLower.Contains("iso center") || nameLower.Contains("izo center") ||
nameLower.Contains("isocentre") || nameLower.Contains("izocentre") ||
nameLower.Contains("iso centre") || nameLower.Contains("izo centre"))
{
isoIdx = i;
isoFound = true;
}
}
}
//Apply z scaling
int zScale = (int)Mathf.Round(Mathf.Abs(zH2 - zH1));
float zScaleF = 1 / (float)zScale;
MeshMaker.zScale = zScale;
print("zScale: " + zScale + ", " + zScaleF + " zH1: " + zH1);
//An alternative to using the expensive collider method of finding mesh surface points for markers
//This method is much faster but needs more work to function correctly.
//Currently the found points do not seem to match the raycast/collider version at all, nor do they seem
//be within the mesh
//Comparing to the rotated and scaled mesh might be an issue
//#TODO
//Issues:
//The position of the cubes that are in line with the isocenter in the original data do not match
//up with the points found by raycasting the final mesh.
/* if (isoFound) {
* Vector3 isoPoint = modelData[isoIdx].pointPosition;
* print("IsoPoint: " + modelData[isoIdx].pointPosition + ", md0.z: " + modelData[0].data[40].Count);
* int zCount = modelData[0].data.Count;
* int isoZ = (int)(isoPoint.z);
* float pxMin = isoPoint.x;
* float pyMin = isoPoint.y;
* bool zFound = false;
* int zIdx = 0;
* for (int i = 0; i < modelData[0].data.Count && !zFound; i++) {
* int sCount = modelData[0].data[i].Count;
* if (sCount > 0) {
* for (int j = 0; j < sCount && !zFound; j++) {
* if (modelData[0].data[i][j].Count > 0) {
* for (int k = 0; k < modelData[0].data[i][j].Count; k++) {
* if (Mathf.Round(modelData[0].data[i][j][k].z) == isoPoint.z) {
* zIdx = i;
* zFound = true;
* break;
* }
* }
* }
* }
* }
* }
*
* GameObject ttp = new GameObject("Cubes");
*
* int zIdx2 = zIdx;
* for (zIdx = 0; zIdx < modelData[0].data.Count; zIdx++) {
*
* int zv = -9000;
* pxMin = isoPoint.x;
* pyMin = isoPoint.y;
* float pxMax = isoPoint.x;
* float pyMax = isoPoint.y;
* HashSet<Vector3> zPoints = new HashSet<Vector3>();
* for (int s = 0; s < modelData[0].data[zIdx].Count; s++) {
* for (int p = 0; p < modelData[0].data[zIdx][s].Count; p++) {
* Vector3 v1 = modelData[0].data[zIdx][s][p];
* if (zv == -9000) { zv = (int)Mathf.Round(v1.z); }
* Vector3 v2;
* if (p < modelData[0].data[zIdx][s].Count - 1) {
* v2 = modelData[0].data[zIdx][s][p+1];
* } else {
* v2 = modelData[0].data[zIdx][s][0];
* }
*
* //Bresenham's Algorithm
* List<Vector3> vox = MeshMaker.VoxelLine(v1,v2,zv);
* foreach (Vector3 v in vox) {
* zPoints.Add(v);
* }
* }
* }
*
* foreach (Vector3 pv in zPoints) {
*
* //Decrease y from -40 to find bCube point
* //Decrease x from -100 to find cCube point
* //Iso: -100, -40, 40
* //b: -100, -70, 40
* //c: -138, -40, 40
*
* if (zIdx == zIdx2) {
* GameObject cube = GameObject.CreatePrimitive(PrimitiveType.Cube);
* cube.transform.position = pv;
* cube.name = pv.ToString();
* cube.transform.parent = ttp.transform;
* }
*
* // if (modelData[0].data[i][j][k] == isoPoint) { bv = true; }
* // float px = Mathf.Round(pv.x);
* // float py = Mathf.Round(pv.y);
* // if (Mathf.Abs(px - isoPoint.x) < 2) {
* // if (px == isoPoint.x) {
* // print("x - ijk: " + i + ", " + j + ", " + k + " | " + pv);
* // if (zIdx == zIdx2) {
* if (pv.x <= isoPoint.x && pv.y == isoPoint.y) {
* pxMin = Mathf.Min(pxMin,pv.x);
* }
* if (pv.x >= isoPoint.x && pv.y == isoPoint.y) {
* pxMax = Mathf.Max(pxMax,pv.x);
* }
* // }
* // if (Mathf.Abs(py - isoPoint.y) < 2) {
* // if (py < isoPoint.y + 2 || py > isoPoint.y - 2) {
* // if (py == isoPoint.y || py == isoPoint.y + 1 ||) {
* // print("y - ijk: " + i + ", " + j + ", " + k + " | " + pv);
* if (pv.y <= isoPoint.y && pv.x == isoPoint.x) {
* pyMin = Mathf.Min(pyMin,pv.y);
* }
* if (pv.y >= isoPoint.y && pv.x == isoPoint.x) {
* pyMax = Mathf.Max(pyMax,pv.y);
* }
* // }
*
* }
*
*
* // if (zIdx == zIdx2) {
* print("zIdx " + zIdx + ", z: " + zv + ", pxMin: " + pxMin + ", pyMin: " + pyMin + ", pxMax: " + pxMax + ", pyMax: " + pyMax + ", width: " + (pxMax - pxMin) + ", height: " + (pyMax - pyMin));
* // UnityEngine.Debug.DrawLine(new Vector3(pxMin, isoPoint.y, isoPoint.z), isoPoint, Color.cyan, 20);
* // UnityEngine.Debug.DrawLine(new Vector3(isoPoint.x, pyMin, isoPoint.z), isoPoint, Color.magenta, 20);
* // }
* }
* // UnityEngine.Debug.LogError("Iso Test");
* // print("ModelData z: " + modelData[0].data.Count);
* // for (int i = 0; i < modelData[0].data.Count; i++) {
* // print("z: " + modelData[0].data[i][0][0].z);
* // }
* // return;
* } */
sw.Stop();
sw2.Start();
for (int i = 0; i < modelData.Count; i++)
{
if (modelData[i].dimensions != null)
{
modelData[i].dimensions[4] *= zScaleF;
modelData[i].dimensions[5] *= zScaleF;
}
if (i == 0)
{
modelData[i] = MeshMaker.MakeMesh(modelData[i], pixels, slicePos);
modelData[i].topName = fname;
modelData[i].zMin = zH1 * zScale;
}
else
{
modelData[i] = MeshMaker.MakeMesh(modelData[i], null, Vector3.zero);
}
}
sw2.Stop();
// FileReader.printStopwatch(sw,"Model Loader - Non Marching: ");
// FileReader.printStopwatch(sw2,"Model Loader - Marching: ");
//Close file
fs.Close();
sw.Reset();
sw.Start();
//Try to notify main thread
while (true)
{
if (FileReader.modelData != null)
{
Thread.Sleep(100);
continue;
}
FileReader.modelData = modelData;
break;
}
sw.Stop();
// FileReader.printStopwatch(sw,"Model Loader - Notify Wait: ");
}
