/// <summary>
/// Returns a blank grid which encompasses both grid1 and grid2
/// </summary>
/// <param name="grid1"></param>
/// <param name="grid2"></param>
/// <returns></returns>
public GridBasedVoxelDataStructure CreateBlank(IVoxelDataStructure grid1, IVoxelDataStructure grid2)
{
var grid = new GridBasedVoxelDataStructure();
grid.XRange = grid1.XRange.Combine(grid2.XRange);
grid.YRange = grid1.YRange.Combine(grid2.YRange);
grid.ZRange = grid1.ZRange.Combine(grid2.ZRange);
grid.ConstantGridSpacing = true;
grid.GridSpacing = new Utilities.RTMath.Point3d(1, 1, 2);
int lenX = (int)Math.Round((grid.XRange.Length / grid.GridSpacing.X)) + 1;
int lenY = (int)Math.Round((grid.YRange.Length / grid.GridSpacing.Y)) + 1;
int lenZ = (int)Math.Round((grid.ZRange.Length / grid.GridSpacing.Z)) + 1;
grid.XCoords = new float[lenX];
grid.YCoords = new float[lenY];
grid.ZCoords = new float[lenZ];
for (int i = 0; i < lenX; i++)
{
grid.XCoords[i] = (float)(grid.XRange.Minimum + i * grid.GridSpacing.X);
}
for (int j = 0; j < lenY; j++)
{
grid.YCoords[j] = (float)(grid.YRange.Minimum + j * grid.GridSpacing.Y);
}
for (int k = 0; k < lenZ; k++)
{
grid.ZCoords[k] = (float)(grid.ZRange.Minimum + k * grid.GridSpacing.Z);
}
grid.Data = new float[lenX * lenY * lenZ];
return(grid);
}
public void Create(int xWidth, int yWidth, int zWidth, double xSpacing, double ySpacing, double zSpacing)
{
int xRows = (int)(xWidth / xSpacing) + 1;
int yRows = (int)(yWidth / ySpacing) + 1;
int zRows = (int)(zWidth / zSpacing) + 1;
var grid = new GridBasedVoxelDataStructure();
grid.DefaultPhysicalValue = -1000;
grid.ConstantGridSpacing = true;
grid.Data = new float[xRows * yRows * zRows];
grid.XCoords = new float[xRows];
grid.YCoords = new float[yRows];
grid.ZCoords = new float[zRows];
grid.XRange = new Range(-xWidth / 2, xWidth / 2);
grid.YRange = new Range(-yWidth / 2, yWidth / 2);
grid.ZRange = new Range(-zWidth / 2, zWidth / 2);
for (int i = 0; i < grid.XCoords.Length; i++)
{
grid.XCoords[i] = (float)(grid.XRange.Minimum + i * xSpacing);
}
for (int i = 0; i < grid.YCoords.Length; i++)
{
grid.YCoords[i] = (float)(grid.YRange.Minimum + i * ySpacing);
}
for (int i = 0; i < grid.ZCoords.Length; i++)
{
grid.ZCoords[i] = (float)(grid.ZRange.Minimum + i * zSpacing);
}
grid.GridSpacing = new Utilities.RTMath.Point3d(xSpacing, ySpacing, zSpacing);
this.Grid = grid;
this.Grid.Name = "Cube Phantom";
}
public void GridBasedStrctureInterpolation()
{
var grid = GridBasedVoxelDataStructure.CreateNew(10, 10, 10, new Range(0, 10), new Range(0, 10), new Range(0, 10));
grid.ConstantGridSpacing = true;
grid.SetVoxelByCoords(1, 1, 1, 10);
Assert.AreEqual(grid.Interpolate(1, 1, 1).Value, 10);
}
public void Create(int radius, int length, int xSpacing, int ySpacing, int zSpacing)
{
int xRows = (radius * 2) / xSpacing;
int yRows = (radius * 2) / ySpacing;
int zRows = length / zSpacing;
var grid = new GridBasedVoxelDataStructure();
grid.DefaultPhysicalValue = -1000;
grid.ConstantGridSpacing = true;
grid.Data = new float[xRows * yRows * zRows];
grid.XCoords = new float[xRows];
grid.YCoords = new float[yRows];
grid.ZCoords = new float[zRows];
grid.XRange = new Range(-xRows * xSpacing / 2, xRows * xSpacing / 2);
grid.YRange = new Range(-yRows * ySpacing / 2, yRows * ySpacing / 2);
grid.ZRange = new Range(-zRows * zSpacing / 2, zRows * zSpacing / 2);
for (int i = 0; i < grid.XCoords.Length; i++)
{
grid.XCoords[i] = (float)grid.XRange.Minimum + i * xSpacing;
}
for (int i = 0; i < grid.YCoords.Length; i++)
{
grid.YCoords[i] = (float)grid.YRange.Minimum + i * ySpacing;
}
for (int i = 0; i < grid.ZCoords.Length; i++)
{
grid.ZCoords[i] = (float)grid.ZRange.Minimum + i * zSpacing;
}
grid.GridSpacing = new Utilities.RTMath.Point3d();
grid.GridSpacing.X = xSpacing;
grid.GridSpacing.Y = ySpacing;
grid.GridSpacing.Z = zSpacing;
for (int i = 0; i < zRows; i++)
{
for (int j = 0; j < xRows; j++)
{
for (int k = 0; k < yRows; k++)
{
if (grid.XCoords[j] * grid.XCoords[j] + grid.YCoords[k] * grid.YCoords[k] < radius * radius)
{
grid.SetVoxelByIndices(i, j, k, 0);
}
else
{
grid.SetVoxelByIndices(i, j, j, 0);
}
}
}
}
this.Grid = grid;
}
private static void TestAndSetMinAndMax(GridBasedVoxelDataStructure grid, float gamma)
{
if (gamma > grid.MaxVoxel.Value)
{
grid.MaxVoxel.Value = gamma;
}
if (gamma < grid.MinVoxel.Value)
{
grid.MinVoxel.Value = gamma;
}
}
public EgsDoseObject Load(string fileName)
{
EgsDoseObject dose = new EgsDoseObject();
GridBasedVoxelDataStructure grid = new GridBasedVoxelDataStructure();
dose.Name = Path.GetFileName(fileName);
string text = File.ReadAllText(fileName);
string[] numbers = text.Split(new char[] { '\n', ' ', '\t', '\r' }, StringSplitOptions.RemoveEmptyEntries);
int SizeX = Int32.Parse(numbers[0]);
int SizeY = Int32.Parse(numbers[1]);
int SizeZ = Int32.Parse(numbers[2]);
grid.XCoords = new double[SizeX];
grid.YCoords = new double[SizeY];
grid.ZCoords = new double[SizeZ];
grid.Data = new float[SizeX, SizeY, SizeZ];
int offset = 3;
for (int i = 0; i < SizeX; i++)
{
grid.XCoords[i] = 10 * (Double.Parse(numbers[offset + i]) + Double.Parse(numbers[offset + i + 1])) / 2;
}
offset += SizeX + 1;
for (int i = 0; i < SizeY; i++)
{
grid.YCoords[i] = 10 * (Double.Parse(numbers[offset + i]) + Double.Parse(numbers[offset + i + 1])) / 2;
}
offset += SizeY + 1;
for (int i = 0; i < SizeZ; i++)
{
grid.ZCoords[i] = 10 * (Double.Parse(numbers[offset + i]) + Double.Parse(numbers[offset + i + 1])) / 2;
}
offset += SizeZ + 1;
for (int i = 0; i < SizeX * SizeY * SizeZ; i++)
{
int indexX = i % SizeX;
int indexZ = (int)(i / (SizeX * SizeY));
int indexY = (int)(i / SizeX) - indexZ * (SizeY);
grid.Data[indexX, indexY, indexZ] = float.Parse(numbers[offset + i]);
}
foreach (Voxel voxel in grid.Voxels)
{
if (voxel.Value > grid.GlobalMax.Value)
{
grid.GlobalMax = voxel;
}
}
return(dose);
}
public GridBasedVoxelDataStructure Load(DicomFile[] dicomFiles)
{
GridBasedVoxelDataStructure grid = new GridBasedVoxelDataStructure();
DicomFile[] files = SortOnZIncreasing(dicomFiles);
PixelDataInfo DicomHeader = new PixelDataInfo(files[0]);
Point3d size = GetSize(files);
grid.ConstantGridSpacing = true;
grid.GridSpacing = GetSpacing(files);
grid.XCoords = GetCoords(files, (int)size.X, DicomHeader.RowDir.X, DicomHeader.ColDir.X, DicomHeader.ImagePositionPatient.X, 1);
grid.YCoords = GetCoords(files, (int)size.Y, DicomHeader.RowDir.Y, DicomHeader.ColDir.Y, DicomHeader.ImagePositionPatient.Y, 1);
grid.ZCoords = GetCoords(files, (int)size.Z, DicomHeader.RowDir.Z, DicomHeader.ColDir.Z, DicomHeader.ImagePositionPatient.Z, 1);
grid.Data = new float[(int)size.X / 1, (int)size.Y / 1, (int)size.Z / 1];
int currYIndex = 0;
int currZIndex = 0;
int currXIndex = 0;
for (int i = 0; i < files.Length; i++)
{
DicomPixelData dicomPixelData = DicomPixelData.Create(files[i].Dataset);
PixelDataInfo tempHeaderInfo = new PixelDataInfo(files[i]);
for (int j = 0; j < tempHeaderInfo.GridFrameOffsetVector.Length; j++)
{
byte[] framePixelData = dicomPixelData.GetFrame(j).Data;
float[] dataArray = GetDataArray(framePixelData, tempHeaderInfo.BitsAllocated, tempHeaderInfo.PixelRepresentation);
for (int k = 0; k < dataArray.Length; k++)
{
int currRow = k % tempHeaderInfo.Columns;
int currCol = (int)Math.Floor((double)(k / (tempHeaderInfo.Columns)));
currXIndex = (int)Math.Abs(tempHeaderInfo.RowDir.X) * currRow + (int)Math.Abs(tempHeaderInfo.ColDir.X) * currCol
+ (1 - (int)Math.Abs(tempHeaderInfo.RowDir.X) - (int)Math.Abs(tempHeaderInfo.ColDir.X)) * (i + j);;
currYIndex = (int)Math.Abs(tempHeaderInfo.RowDir.Y) * currRow + (int)Math.Abs(tempHeaderInfo.ColDir.Y) * currCol
+ (1 - (int)Math.Abs(tempHeaderInfo.RowDir.Y) - (int)Math.Abs(tempHeaderInfo.ColDir.Y)) * (i + j);;
currZIndex = (int)Math.Abs(tempHeaderInfo.RowDir.Z) * currRow + (int)Math.Abs(tempHeaderInfo.ColDir.Z) * currCol
+ (1 - (int)Math.Abs(tempHeaderInfo.RowDir.Z) - (int)Math.Abs(tempHeaderInfo.ColDir.Z)) * (i + j);
//Rescale back to actual values
dataArray[k] = dataArray[k] * tempHeaderInfo.RescaleSlope + tempHeaderInfo.RescaleSlope;
grid.Data[currXIndex, currYIndex, currZIndex] = dataArray[k];
}
}
}
return(grid);
//setGlobalMax();
}
/// <summary>
/// Returns an empty grid with the same size as the grid
/// </summary>
/// <param name="grid"></param>
/// <returns></returns>
public GridBasedVoxelDataStructure CreateBlank(IVoxelDataStructure g)
{
var grid = (GridBasedVoxelDataStructure)g;
var newGrid = new GridBasedVoxelDataStructure();
newGrid.XRange = new Range(grid.XRange.Minimum, grid.XRange.Maximum);
newGrid.YRange = new Range(grid.YRange.Minimum, grid.YRange.Maximum);
newGrid.ZRange = new Range(grid.ZRange.Minimum, grid.ZRange.Maximum);
newGrid.XCoords = new float[grid.XCoords.Length]; grid.XCoords.CopyTo(newGrid.XCoords, 0);
newGrid.YCoords = new float[grid.YCoords.Length]; grid.YCoords.CopyTo(newGrid.YCoords, 0);
newGrid.ZCoords = new float[grid.ZCoords.Length]; grid.ZCoords.CopyTo(newGrid.ZCoords, 0);
newGrid.Scaling = 1;
newGrid.Data = new float[newGrid.XCoords.Length * newGrid.YCoords.Length * newGrid.ZCoords.Length];
newGrid.ConstantGridSpacing = grid.ConstantGridSpacing;
newGrid.GridSpacing = new Point3d();
grid.GridSpacing.CopyTo(newGrid.GridSpacing);
return(newGrid);
}
public EgsDoseObject Load(string fileName, EgsDoseObject doseObject, IProgress <double> progress)
{
GridBasedVoxelDataStructure grid = new GridBasedVoxelDataStructure();
grid.Name = Path.GetFileName(fileName);
double max = 0;
int SizeX, SizeY, SizeZ;
using (TextReader reader = File.OpenText(fileName))
{
SizeX = (int)ReadDouble(reader);
SizeY = (int)ReadDouble(reader);
SizeZ = (int)ReadDouble(reader);
grid.XCoords = new float[SizeX];
grid.YCoords = new float[SizeY];
grid.ZCoords = new float[SizeZ];
grid.Data = new float[SizeX * SizeY * SizeZ];
fillCoords(grid.XCoords, SizeX, reader);
fillCoords(grid.YCoords, SizeY, reader);
fillCoords(grid.ZCoords, SizeZ, reader);
int Size = SizeX * SizeY * SizeZ;
for (int i = 0; i < Size; i++)
{
int indexX = i % SizeX;
int indexZ = (int)(i / (SizeX * SizeY));
int indexY = (int)(i / SizeX) - indexZ * (SizeY);
float data = ReadFloat(reader);
grid.SetVoxelByIndices(indexX, indexY, indexZ, data);
if (data > grid.MaxVoxel.Value)
{
grid.MaxVoxel.Value = data;
grid.MaxVoxel.Position.X = grid.XCoords[indexX];
grid.MaxVoxel.Position.Y = grid.XCoords[indexY];
grid.MaxVoxel.Position.Z = grid.XCoords[indexZ];
}
if (data < grid.MinVoxel.Value)
{
grid.MinVoxel.Value = data;
grid.MinVoxel.Position.X = grid.XCoords[indexX];
grid.MinVoxel.Position.Y = grid.XCoords[indexY];
grid.MinVoxel.Position.Z = grid.XCoords[indexZ];
}
//only report progress every 5%.
if (i % (Size / 20) == 0)
{
progress.Report(100 * (double)i / (double)(Size));
}
}
}
grid.XRange = new Range((double)grid.XCoords[0], (double)grid.XCoords[grid.XCoords.Length - 1]);
grid.YRange = new Range(grid.YCoords[0], grid.YCoords[grid.YCoords.Length - 1]);
grid.ZRange = new Range(grid.ZCoords[0], grid.ZCoords[grid.ZCoords.Length - 1]);
doseObject.Grid = grid;
doseObject.Grid.ValueUnit = Unit.Egs;
//doseObject.Grid.ComputeMax();
return(doseObject);
}
public GridBasedVoxelDataStructure Load(DicomFile[] dicomFiles, IProgress <double> progress)
{
GridBasedVoxelDataStructure grid = new GridBasedVoxelDataStructure();
DicomFile[] files = SortOnZIncreasing(dicomFiles);
PixelDataInfo DicomHeader = new PixelDataInfo(files[0]);
Point3d size = GetSize(files);
grid.ConstantGridSpacing = true;
grid.GridSpacing = GetSpacing(files);
grid.XCoords = GetCoords(files, (int)size.X, DicomHeader.RowDir.X, DicomHeader.ColDir.X, DicomHeader.ImagePositionPatient.X, 1);
grid.YCoords = GetCoords(files, (int)size.Y, DicomHeader.RowDir.Y, DicomHeader.ColDir.Y, DicomHeader.ImagePositionPatient.Y, 1);
grid.ZCoords = GetCoords(files, (int)size.Z, DicomHeader.RowDir.Z, DicomHeader.ColDir.Z, DicomHeader.ImagePositionPatient.Z, 1);
grid.Data = new float[(int)size.X * (int)size.Y * (int)size.Z];
int currYIndex = 0;
int currZIndex = 0;
int currXIndex = 0;
for (int i = 0; i < files.Length; i++)
{
DicomPixelData dicomPixelData = DicomPixelData.Create(files[i].Dataset);
PixelDataInfo tempHeaderInfo = new PixelDataInfo(files[i]);
for (int j = 0; j < tempHeaderInfo.GridFrameOffsetVector.Length; j++)
{
byte[] framePixelData = dicomPixelData.GetFrame(j).Data;
float[] dataArray = GetDataArray(framePixelData, tempHeaderInfo.BitsAllocated, tempHeaderInfo.PixelRepresentation);
for (int k = 0; k < dataArray.Length; k++)
{
int currRow = k % tempHeaderInfo.Columns;
int currCol = (int)Math.Floor((double)(k / (tempHeaderInfo.Columns)));
currXIndex = (int)Math.Abs(tempHeaderInfo.RowDir.X) * currRow + (int)Math.Abs(tempHeaderInfo.ColDir.X) * currCol
+ (1 - (int)Math.Abs(tempHeaderInfo.RowDir.X) - (int)Math.Abs(tempHeaderInfo.ColDir.X)) * (i + j);;
currYIndex = (int)Math.Abs(tempHeaderInfo.RowDir.Y) * currRow + (int)Math.Abs(tempHeaderInfo.ColDir.Y) * currCol
+ (1 - (int)Math.Abs(tempHeaderInfo.RowDir.Y) - (int)Math.Abs(tempHeaderInfo.ColDir.Y)) * (i + j);;
currZIndex = (int)Math.Abs(tempHeaderInfo.RowDir.Z) * currRow + (int)Math.Abs(tempHeaderInfo.ColDir.Z) * currCol
+ (1 - (int)Math.Abs(tempHeaderInfo.RowDir.Z) - (int)Math.Abs(tempHeaderInfo.ColDir.Z)) * (i + j);
//Rescale back to actual HUs
dataArray[k] = dataArray[k] * tempHeaderInfo.RescaleSlope + tempHeaderInfo.RescaleIntercept;
grid.SetVoxelByIndices(currXIndex, currYIndex, currZIndex, dataArray[k]);
if (dataArray[k] > grid.MaxVoxel.Value)
{
grid.MaxVoxel.Value = dataArray[k];
grid.MaxVoxel.Position.X = grid.XCoords[currXIndex];
grid.MaxVoxel.Position.Y = grid.YCoords[currYIndex];
grid.MaxVoxel.Position.Z = grid.ZCoords[currZIndex];
}
if (dataArray[k] < grid.MinVoxel.Value)
{
grid.MinVoxel.Value = dataArray[k];
grid.MinVoxel.Position.X = grid.XCoords[currXIndex];
grid.MinVoxel.Position.Y = grid.YCoords[currYIndex];
grid.MinVoxel.Position.Z = grid.ZCoords[currZIndex];
}
}
progress.Report(100 * ((((double)j / (double)tempHeaderInfo.GridFrameOffsetVector.Length) / files.Length) + ((double)i / (double)files.Length)));
}
}
grid.XRange = new Range(grid.XCoords[0], grid.XCoords[grid.XCoords.Length - 1]);
grid.YRange = new Range(grid.YCoords[0], grid.YCoords[grid.YCoords.Length - 1]);
grid.ZRange = new Range(grid.ZCoords[0], grid.ZCoords[grid.ZCoords.Length - 1]);
//grid.ComputeMax();
return(grid);
}
