/// <summary>
/// Converts 3D byte array to vtkImageData.
/// </summary>
/// <param name="data">Input array.</param>
/// <param name="dims">Input array dimensions. Give the begin and end extent for each dimension.</param>
/// <returns>Converted array.</returns>
public static vtkImageData byteToVTK1D(byte[] data, int[] dims)
{
int h = dims[1] - dims[0] + 1;
int w = dims[3] - dims[2] + 1;
int d = dims[5] - dims[4] + 1;
//Create VTK data for putput
vtkImageData vtkdata = vtkImageData.New();
//Character array for conversion
vtkUnsignedCharArray charArray = vtkUnsignedCharArray.New();
//Pin byte array
GCHandle pinnedArray = GCHandle.Alloc(data, GCHandleType.Pinned);
//Set character array input
charArray.SetArray(pinnedArray.AddrOfPinnedObject(), h * w * d, 1);
//Set vtkdata properties and connect array
//Data from char array
vtkdata.GetPointData().SetScalars(charArray);
//Number of scalars/pixel
vtkdata.SetNumberOfScalarComponents(1);
//Set data extent
vtkdata.SetExtent(dims[0], dims[1], dims[2], dims[3], dims[4], dims[5]);
//Scalar type
vtkdata.SetScalarTypeToUnsignedChar();
vtkdata.Update();
return(vtkdata);
}
public static void GetRectData(vtkPolyData data, Rectangle rect)
{
var points = vtkPoints.New();
var colorArray = vtkUnsignedCharArray.New();
colorArray.SetNumberOfComponents(3);
RectImageData = vtkImageData.New();
RectImageData.SetExtent(0, rect.Size.Width - 1, 0, rect.Size.Height - 1, 0, 0);
RectImageData.SetNumberOfScalarComponents(1);
RectImageData.SetScalarTypeToUnsignedChar();
for (var i = rect.Top; i < rect.Bottom; i++)
{
for (var j = rect.Left; j < rect.Right; j++)
{
double[] p = data.GetPoint(i * ImageWidth + j);
points.InsertNextPoint(j - rect.Left, i - rect.Top, p[2]);
double[] c = data.GetPointData().GetScalars().GetTuple3(i * ImageWidth + j);
colorArray.InsertNextTuple3(c[0], c[1], c[2]);
RectImageData.SetScalarComponentFromDouble(j - rect.Left, i - rect.Top, 0, 0, c[0]);
}
}
RectPolyData = vtkPolyData.New();
RectPolyData.SetPoints(points);
RectPolyData.GetPointData().SetScalars(colorArray);
RectPolyData.Update();
}
public static void ReadDataFromFile(string filename)
{
try
{
SimplePointFile.GetImageInfo(filename);
ImageWidth = SimplePointFile.ImageWidth;
ImageHeight = SimplePointFile.ImageHeight;
//Console.WriteLine("ImageWidth:" + ImageWidth);
//Console.WriteLine("ImageHeight:" + ImageHeight);
var points = vtkPoints.New();
var colorArray = vtkUnsignedCharArray.New();
colorArray.SetNumberOfComponents(3);
ImageData = vtkImageData.New();
ImageData.SetExtent(0, ImageWidth - 1, 0, ImageHeight - 1, 0, 0);
ImageData.SetNumberOfScalarComponents(1);
ImageData.SetScalarTypeToUnsignedChar();
SimplePointFile.OpenReadFile(filename);
double[] data;
while ((data = SimplePointFile.ReadLine()) != null)
{
points.InsertNextPoint(data[0], data[1], data[2]);
colorArray.InsertNextTuple3(data[3], data[4], data[5]);
ImageData.SetScalarComponentFromDouble((int)data[0], (int)data[1], 0, 0, data[3]);
}
PolyData = vtkPolyData.New();
PolyData.SetPoints(points);
PolyData.GetPointData().SetScalars(colorArray);
PolyData.Update();
//Console.WriteLine("PolyData & ImageData Load.");
}
catch (Exception e)
{
MessageBox.Show(e.Message);
}
finally
{
SimplePointFile.CloseReadFile();
}
}
private void Window_Activated(object sender, EventArgs e)
{
// 一定要先 vtkformhost.Child = vtkControl;下面三条顺序不能乱 否则报错 切记！
vtkformhost.Child = vtkControl;
vtkRenderWindow renWin = vtkControl.RenderWindow;
vtkRenderer aRenderer = renWin.GetRenderers().GetFirstRenderer();
renWin.AddRenderer(aRenderer);
Marshal.Copy(ys1, 0, temp128, imgLine * imgPixel * imgNum);
temp.SetArray(temp128, imgLine * imgPixel * imgNum, 1);
testimgdata.SetDimensions(imgLine, imgPixel, imgNum);
testimgdata.SetSpacing(1, 1, 4);
testimgdata.SetScalarTypeToUnsignedChar();
testimgdata.SetNumberOfScalarComponents(1);
testimgdata.AllocateScalars();
testimgdata.GetPointData().SetScalars(temp);
testimgdata.Modified();
VtkSetColor();
VtkSetOpacity();
volumeProperty.SetColor(colorTransferFunction);
volumeProperty.SetScalarOpacity(opacityTransferFunction);
volumeProperty.ShadeOn();
volumeProperty.SetInterpolationTypeToLinear();
volumeMapper.SetVolumeRayCastFunction(compositeFunction);
volumeMapper.SetInput(testimgdata);
volume.SetMapper(volumeMapper);
volume.SetProperty(volumeProperty);
aCamera.SetViewUp(0, -1, 0);
aCamera.SetPosition(-1, 0, 1);
aCamera.ComputeViewPlaneNormal();
aRenderer.AddVolume(volume);
aRenderer.SetBackground(0, 0, 0.6);
aRenderer.SetActiveCamera(aCamera);
aRenderer.ResetCamera();
renWin.SetSize(800, 800);
renWin.Render();
}
/// <summary>
/// Load image files into vtkImageData.
/// </summary>
/// <param name="path">Path to images.</param>
/// <param name="extension">Image extension.</param>
/// <returns></returns>
public static vtkImageData VTKLoader(string path, string extension)
{
/*DEPRECATED!!*/
//Output
vtkImageData data = vtkImageData.New();
//Get files from path
DirectoryInfo d = new DirectoryInfo(@path);
FileInfo[] files = d.GetFiles();
vtkStringArray allfiles = vtkStringArray.New();
//Iterate over files and read image data
foreach (FileInfo file in files)
{
//Fullfile
string fullfile = Path.Combine(path, file.Name);
allfiles.InsertNextValue(fullfile);
}
if (extension == ".png")
{
vtkPNGReader reader = vtkPNGReader.New();
reader.SetFileNames(allfiles);
reader.Update();
data = reader.GetOutput();
reader.Dispose();
}
if (extension == ".jpg")
{
vtkJPEGReader reader = vtkJPEGReader.New();
reader.SetFileNames(allfiles);
reader.Update();
data = reader.GetOutput();
reader.Dispose();
}
if (extension == ".bmp")
{
vtkBMPReader reader = vtkBMPReader.New();
reader.SetFileNames(allfiles);
reader.Update();
data = reader.GetOutput();
reader.Dispose();
}
data.SetScalarTypeToUnsignedChar();
data.Update();
return(data);
}
private void GreedyTerrainDecimation()
{
// Create an image
vtkImageData image = vtkImageData.New();
image.SetDimensions(3, 3, 1);
image.SetNumberOfScalarComponents(1);
image.SetScalarTypeToUnsignedChar();
int[] dims = image.GetDimensions();
unsafe {
for (int i = 0; i < dims[0]; i++)
{
for (int j = 0; j < dims[1]; j++)
{
byte *ptr = (byte *)image.GetScalarPointer(i, j, 0);
* ptr = (byte)vtkMath.Round(vtkMath.Random(0, 1));
}
}
}
vtkGreedyTerrainDecimation decimation = vtkGreedyTerrainDecimation.New();
decimation.SetInputConnection(image.GetProducerPort());
decimation.Update();
vtkPolyDataMapper mapper = vtkPolyDataMapper.New();
mapper.SetInputConnection(decimation.GetOutputPort());
// actor
vtkActor actor = vtkActor.New();
actor.SetMapper(mapper);
actor.GetProperty().SetInterpolationToFlat();
actor.GetProperty().EdgeVisibilityOn();
actor.GetProperty().SetEdgeColor(1, 0, 0);
// get a reference to the renderwindow of our renderWindowControl1
vtkRenderWindow renderWindow = renderWindowControl1.RenderWindow;
// renderer
vtkRenderer renderer = renderWindow.GetRenderers().GetFirstRenderer();
// set background color
renderer.SetBackground(0.2, 0.3, 0.4);
// add our actor to the renderer
renderer.AddActor(actor);
}
//把fyGrid转为vtkImageData
private vtkImageData ConvertfyGrid2vtkImageData(ExGrid Grid)
{
vtkImageData ImageData = vtkImageData.New();
ImageData.SetScalarTypeToUnsignedChar();
ImageData.SetNumberOfScalarComponents(1);
ImageData.SetDimensions(Grid.ICount, Grid.JCount, Grid.KCount);
ImageData.SetSpacing(1, 1, 1);
ImageData.AllocateScalars();
byte[] data = new byte[Grid.CellCount];
for (int i = 0; i < Grid.CellCount; i++)
{
data[i] = (byte)Grid.GetCell(i).Value;
}
System.Runtime.InteropServices.Marshal.Copy(data, 0, (IntPtr)ImageData.GetScalarPointer(), data.Length);
return(ImageData);
}
/// <summary>
/// Converts 3D byte array to vtkImageData.
/// </summary>
/// <param name="data">Input array.</param>
/// <param name="orientation">Data orientation as a list of axes (0-2)</param>
/// <returns>Converted array.</returns>
public static vtkImageData byteToVTK(byte[,,] data, int[] orientation = null)
{
//Get input dimensions
int[] dims = new int[] { data.GetLength(0), data.GetLength(1), data.GetLength(2) };
//Create VTK data for putput
vtkImageData vtkdata = vtkImageData.New();
//Character array for conversion
vtkUnsignedCharArray charArray = vtkUnsignedCharArray.New();
//Pin byte array
GCHandle pinnedArray = GCHandle.Alloc(data, GCHandleType.Pinned);
//Set character array input
charArray.SetArray(pinnedArray.AddrOfPinnedObject(), dims[0] * dims[1] * dims[2], 1);
//Set vtkdata properties and connect array
//Data from char array
vtkdata.GetPointData().SetScalars(charArray);
//Number of scalars/pixel
vtkdata.SetNumberOfScalarComponents(1);
//Data extent, 1st and last axis are swapped from the char array
//Data is converted back to original orientation
vtkdata.SetExtent(0, dims[2] - 1, 0, dims[1] - 1, 0, dims[0] - 1);
//Scalar type
vtkdata.SetScalarTypeToUnsignedChar();
vtkdata.SetSpacing(1.0, 1.0, 1.0);
vtkdata.Update();
pinnedArray.Free();
//Return vtk data
if (orientation == null)
{
return(vtkdata);
}
else
{
vtkImagePermute permuter = vtkImagePermute.New();
permuter.SetInput(vtkdata);
permuter.SetFilteredAxes(orientation[0], orientation[1], orientation[2]);
permuter.Update();
return(permuter.GetOutput());
}
}
/// <summary>
/// Calculates mean and standard deviation images from volume-of-interest. Obsolete.
/// </summary>
/// <param name="output"></param>
/// <param name="mu"></param>
/// <param name="std"></param>
/// <param name="input"></param>
/// <param name="depth"></param>
/// <param name="threshold"></param>
public static void get_voi_mu_std(out vtkImageData output, out double[,] mu, out double[,] std, vtkImageData input, int depth, double threshold = 70.0)
{
//Get data extent
int[] dims = input.GetExtent();
int h = dims[1] - dims[0] + 1;
int w = dims[3] - dims[2] + 1;
int d = dims[5] - dims[4] + 1;
//Compute strides
int stridew = 1;
int strideh = w;
int strided = h * w;
byte[] bytedata = DataTypes.vtkToByte(input);
byte[] voidata = new byte[bytedata.Length];
double[,] _mu = new double[h, w];
double[,] _std = new double[h, w];
//Get voi indices
Parallel.For(24, h - 24, (int y) =>
{
Parallel.For(24, w - 24, (int x) =>
{
int start = d - 1;
int stop = 0;
//Compute mean
for (int z = d - 1; z > 0; z -= 1)
{
int pos = z * strided + y * strideh + x * stridew;
double val = (double)bytedata[pos];
if (val >= threshold)
{
start = z;
stop = Math.Max(z - depth, 0);
//Compute mean and std
for (int zz = start; zz > stop; zz -= 1)
{
int newpos = zz * strided + y * strideh + x * stridew;
double newval = (double)bytedata[newpos];
voidata[newpos] = (byte)newval;
_mu[y, x] = newval / (double)depth;
}
for (int zz = start; zz > stop; zz -= 1)
{
int newpos = zz * strided + y * strideh + x * stridew;
double newval = (double)bytedata[newpos];
_std[y, x] += ((double)newval - _mu[y, x]) * ((double)newval - _mu[y, x]);
}
_std[y, x] = Math.Pow(_std[y, x] / (depth - 1), 0.5);
break;
}
}
});
});
mu = _mu;
std = _std;
output = vtkImageData.New();
//Copy voi data to input array
vtkUnsignedCharArray charArray = vtkUnsignedCharArray.New();
//Pin byte array
GCHandle pinnedArray = GCHandle.Alloc(voidata, GCHandleType.Pinned);
//Set character array input
charArray.SetArray(pinnedArray.AddrOfPinnedObject(), h * w * d, 1);
//Set vtkdata properties and connect array
//Data from char array
output.GetPointData().SetScalars(charArray);
//Number of scalars/pixel
output.SetNumberOfScalarComponents(1);
//Data extent, 1st and last axis are swapped from the char array
//Data is converted back to original orientation
output.SetExtent(dims[0], dims[1], dims[2], dims[3], dims[4], dims[5]);
//Scalar type
output.SetScalarTypeToUnsignedChar();
output.Update();
}
private static vtkImageData CreateVtkVolume(Volume volume)
{
var vtkVolume = new vtkImageData();
vtkVolume.RegisterVtkErrorEvents();
vtkVolume.SetDimensions(volume.ArrayDimensions.Width, volume.ArrayDimensions.Height, volume.ArrayDimensions.Depth);
vtkVolume.SetOrigin(0, 0, 0);
vtkVolume.SetSpacing(volume.VoxelSpacing.X, volume.VoxelSpacing.Y, volume.VoxelSpacing.Z);
if (volume.BitsPerVoxel == 16)
{
if (!volume.Signed)
{
using (var array = new vtkUnsignedShortArray())
{
array.SetArray((ushort[]) volume.Array, (VtkIdType) volume.ArrayLength, 1);
vtkVolume.SetScalarTypeToUnsignedShort();
vtkVolume.GetPointData().SetScalars(array);
}
}
else
{
using (var array = new vtkShortArray())
{
array.SetArray((short[]) volume.Array, (VtkIdType) volume.ArrayLength, 1);
vtkVolume.SetScalarTypeToShort();
vtkVolume.GetPointData().SetScalars(array);
}
}
}
else if (volume.BitsPerVoxel == 8)
{
if (!volume.Signed)
{
using (var array = new vtkUnsignedCharArray())
{
array.SetArray((byte[]) volume.Array, (VtkIdType) volume.ArrayLength, 1);
vtkVolume.SetScalarTypeToUnsignedChar();
vtkVolume.GetPointData().SetScalars(array);
}
}
else
{
using (var array = new vtkSignedCharArray())
{
array.SetArray((sbyte[]) volume.Array, (VtkIdType) volume.ArrayLength, 1);
vtkVolume.SetScalarTypeToSignedChar();
vtkVolume.GetPointData().SetScalars(array);
}
}
}
else
{
throw new NotSupportedException("Unsupported volume scalar type.");
}
// This call is necessary to ensure vtkImageData data's info is correct (e.g. updates WholeExtent values)
vtkVolume.UpdateInformation();
return vtkVolume;
}
private static vtkImageData CreateVtkVolume(Volume volume)
{
var vtkVolume = new vtkImageData();
vtkVolume.RegisterVtkErrorEvents();
vtkVolume.SetDimensions(volume.ArrayDimensions.Width, volume.ArrayDimensions.Height, volume.ArrayDimensions.Depth);
vtkVolume.SetOrigin(0, 0, 0);
vtkVolume.SetSpacing(volume.VoxelSpacing.X, volume.VoxelSpacing.Y, volume.VoxelSpacing.Z);
if (volume.BitsPerVoxel == 16)
{
if (!volume.Signed)
{
using (var array = new vtkUnsignedShortArray())
{
array.SetArray((ushort[])volume.Array, (VtkIdType)volume.ArrayLength, 1);
vtkVolume.SetScalarTypeToUnsignedShort();
vtkVolume.GetPointData().SetScalars(array);
}
}
else
{
using (var array = new vtkShortArray())
{
array.SetArray((short[])volume.Array, (VtkIdType)volume.ArrayLength, 1);
vtkVolume.SetScalarTypeToShort();
vtkVolume.GetPointData().SetScalars(array);
}
}
}
else if (volume.BitsPerVoxel == 8)
{
if (!volume.Signed)
{
using (var array = new vtkUnsignedCharArray())
{
array.SetArray((byte[])volume.Array, (VtkIdType)volume.ArrayLength, 1);
vtkVolume.SetScalarTypeToUnsignedChar();
vtkVolume.GetPointData().SetScalars(array);
}
}
else
{
using (var array = new vtkSignedCharArray())
{
array.SetArray((sbyte[])volume.Array, (VtkIdType)volume.ArrayLength, 1);
vtkVolume.SetScalarTypeToSignedChar();
vtkVolume.GetPointData().SetScalars(array);
}
}
}
else
{
throw new NotSupportedException("Unsupported volume scalar type.");
}
// This call is necessary to ensure vtkImageData data's info is correct (e.g. updates WholeExtent values)
vtkVolume.UpdateInformation();
return(vtkVolume);
}