private void Vertex()
{
vtkPoints points = vtkPoints.New();
points.InsertNextPoint(0, 0, 0);
vtkVertex vertex = vtkVertex.New();
vertex.GetPointIds().SetId(0, 0);
vtkCellArray vertices = vtkCellArray.New();
vertices.InsertNextCell(vertex);
vtkPolyData polydata = vtkPolyData.New();
polydata.SetPoints(points);
polydata.SetVerts(vertices);
// Visualize
vtkPolyDataMapper mapper = vtkPolyDataMapper.New();
mapper.SetInputConnection(polydata.GetProducerPort());
vtkActor actor = vtkActor.New();
actor.SetMapper(mapper);
actor.GetProperty().SetPointSize(10);
vtkRenderWindow renderWindow = renderWindowControl1.RenderWindow;
vtkRenderer renderer = renderWindow.GetRenderers().GetFirstRenderer();
renderer.SetBackground(0.2, 0.3, 0.4);
// Add the actor to the scene
renderer.AddActor(actor);
}
internal void ApplyTransform(ref vtkTransform transform, string filename)
{
vtkPolyData polydata = vtkPolyData.New();
CreatePolydata(ref polydata);
vtkTransformFilter transformFilter = vtkTransformFilter.New();
#if VTK_MAJOR_VERSION_5
transformFilter.SetInputConnection(polydata.GetProducerPort());
#else
transformFilter.SetInputData(polydata);
#endif
transformFilter.SetTransform(transform);
transformFilter.Update();
vtkXMLPolyDataWriter writer = vtkXMLPolyDataWriter.New();
writer.SetFileName(filename);
#if VTK_MAJOR_VERSION_5
writer.SetInputConnection(transformFilter.GetOutputPort());
#else
writer.SetInputData(transformFilter);
#endif
writer.Write();
}
internal void Write(string filename)
{
vtkPolyData polydata = vtkPolyData.New();
CreatePolydata(ref polydata);
vtkXMLPolyDataWriter writer = vtkXMLPolyDataWriter.New();
writer.SetFileName(filename);
#if VTK_MAJOR_VERSION_5
writer.SetInputConnection(polydata.GetProducerPort());
#else
writer.SetInputData(polydata);
#endif
writer.Write();
}
public void ReadPointIntoObject(RenderWindowControl renderWindowControl, List <nvmPointModel> listPointModel)
{
vtkUnsignedCharArray colors = vtkUnsignedCharArray.New();
colors.SetNumberOfComponents(3);
colors.SetName("Colors");
vtkPoints points = vtkPoints.New();
foreach (var point in listPointModel)
{
colors.InsertNextValue(byte.Parse(point.color.X.ToString(), CultureInfo.InvariantCulture));
colors.InsertNextValue(byte.Parse(point.color.Y.ToString(), CultureInfo.InvariantCulture));
colors.InsertNextValue(byte.Parse(point.color.Z.ToString(), CultureInfo.InvariantCulture));
points.InsertNextPoint(
double.Parse(point.position.X.ToString(), CultureInfo.InvariantCulture),
double.Parse(point.position.Y.ToString(), CultureInfo.InvariantCulture),
double.Parse(point.position.Z.ToString(), CultureInfo.InvariantCulture));
}
vtkPolyData polydata = vtkPolyData.New();
polydata.SetPoints(points);
polydata.GetPointData().SetScalars(colors);
vtkVertexGlyphFilter glyphFilter = vtkVertexGlyphFilter.New();
glyphFilter.SetInputConnection(polydata.GetProducerPort());
// Visualize
vtkPolyDataMapper mapper = vtkPolyDataMapper.New();
mapper.SetInputConnection(glyphFilter.GetOutputPort());
vtkActor actor = vtkActor.New();
actor.SetMapper(mapper);
actor.GetProperty().SetPointSize(2);
// get a reference to the renderwindow of our renderWindowControl1
vtkRenderWindow renderWindow = renderWindowControl.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);
renderer.ResetCamera();
}
private void QuadricDecimation()
{
vtkSphereSource sphereSource = vtkSphereSource.New();
sphereSource.Update();
vtkPolyData input = vtkPolyData.New();
input.ShallowCopy(sphereSource.GetOutput());
Debug.WriteLine("Before decimation" + Environment.NewLine + "------------");
Debug.WriteLine("There are " + input.GetNumberOfPoints() + " points.");
Debug.WriteLine("There are " + input.GetNumberOfPolys() + " polygons.");
vtkQuadricDecimation decimate = vtkQuadricDecimation.New();
#if VTK_MAJOR_VERSION_5
decimate.SetInputConnection(input.GetProducerPort());
#else
decimate.SetInputData(input);
#endif
decimate.Update();
vtkPolyData decimated = vtkPolyData.New();
decimated.ShallowCopy(decimate.GetOutput());
Debug.WriteLine("After decimation" + Environment.NewLine + "------------");
Debug.WriteLine("There are " + decimated.GetNumberOfPoints() + " points.");
Debug.WriteLine("There are " + decimated.GetNumberOfPolys() + " polygons.");
vtkPolyDataMapper inputMapper = vtkPolyDataMapper.New();
#if VTK_MAJOR_VERSION_5
inputMapper.SetInputConnection(input.GetProducerPort());
#else
inputMapper.SetInputData(input);
#endif
vtkActor inputActor = vtkActor.New();
inputActor.SetMapper(inputMapper);
vtkPolyDataMapper decimatedMapper = vtkPolyDataMapper.New();
#if VTK_MAJOR_VERSION_5
decimatedMapper.SetInputConnection(decimated.GetProducerPort());
#else
decimatedMapper.SetInputData(decimated);
#endif
vtkActor decimatedActor = vtkActor.New();
decimatedActor.SetMapper(decimatedMapper);
vtkRenderWindow renderWindow = renderWindowControl1.RenderWindow;
this.Size = new System.Drawing.Size(612, 352);
// Define viewport ranges
// (xmin, ymin, xmax, ymax)
double[] leftViewport = new double[] { 0.0, 0.0, 0.5, 1.0 };
double[] rightViewport = new double[] { 0.5, 0.0, 1.0, 1.0 };
// Setup both renderers
vtkRenderer leftRenderer = vtkRenderer.New();
renderWindow.AddRenderer(leftRenderer);
leftRenderer.SetViewport(leftViewport[0], leftViewport[1], leftViewport[2], leftViewport[3]);
leftRenderer.SetBackground(.6, .5, .4);
vtkRenderer rightRenderer = vtkRenderer.New();
renderWindow.AddRenderer(rightRenderer);
rightRenderer.SetViewport(rightViewport[0], rightViewport[1], rightViewport[2], rightViewport[3]);
rightRenderer.SetBackground(.4, .5, .6);
// Add the sphere to the left and the cube to the right
leftRenderer.AddActor(inputActor);
rightRenderer.AddActor(decimatedActor);
leftRenderer.ResetCamera();
rightRenderer.ResetCamera();
renderWindow.Render();
}
private void ElevationFilter()
{
// Created a grid of points (heigh/terrian map)
vtkPoints points = vtkPoints.New();
uint GridSize = 10;
for (uint x = 0; x < GridSize; x++)
{
for (uint y = 0; y < GridSize; y++)
{
points.InsertNextPoint(x, y, (x + y) / (y + 1));
}
}
double[] bounds = points.GetBounds();
// Add the grid points to a polydata object
vtkPolyData inputPolyData = vtkPolyData.New();
inputPolyData.SetPoints(points);
// Triangulate the grid points
vtkDelaunay2D delaunay = vtkDelaunay2D.New();
#if VTK_MAJOR_VERSION_5
delaunay.SetInput(inputPolyData);
#else
delaunay.SetInputData(inputPolyData);
#endif
delaunay.Update();
vtkElevationFilter elevationFilter = vtkElevationFilter.New();
elevationFilter.SetInputConnection(delaunay.GetOutputPort());
elevationFilter.SetLowPoint(0.0, 0.0, bounds[4]);
elevationFilter.SetHighPoint(0.0, 0.0, bounds[5]);
elevationFilter.Update();
vtkPolyData output = vtkPolyData.New();
output.ShallowCopy(vtkPolyData.SafeDownCast(elevationFilter.GetOutput()));
vtkFloatArray elevation =
vtkFloatArray.SafeDownCast(output.GetPointData().GetArray("Elevation"));
// Create the color map
vtkLookupTable colorLookupTable = vtkLookupTable.New();
colorLookupTable.SetTableRange(bounds[4], bounds[5]);
colorLookupTable.Build();
// Generate the colors for each point based on the color map
vtkUnsignedCharArray colors = vtkUnsignedCharArray.New();
colors.SetNumberOfComponents(3);
colors.SetName("Colors");
for (int i = 0; i < output.GetNumberOfPoints(); i++)
{
double val = elevation.GetValue(i);
Debug.WriteLine("val: " + val);
double[] dcolor = colorLookupTable.GetColor(val);
//Debug.WriteLine("dcolor: "
// + dcolor[0] + " "
// + dcolor[1] + " "
// + dcolor[2]);
byte[] color = new byte[3];
for (int j = 0; j < 3; j++)
{
color[j] = (byte)(255 * dcolor[j]);
}
//Debug.WriteLine("color: "
// + color[0] + " "
// + color[1] + " "
// + color[2]);
colors.InsertNextTuple3(color[0], color[1], color[2]);
}
output.GetPointData().AddArray(colors);
// Visualize
vtkPolyDataMapper mapper = vtkPolyDataMapper.New();
#if VTK_MAJOR_VERSION_5
mapper.SetInputConnection(output.GetProducerPort());
#else
mapper.SetInputData(output);
#endif
vtkActor actor = vtkActor.New();
actor.SetMapper(mapper);
// 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);
}
private void ColoredElevationMap()
{
// Create a grid of points (height/terrian map)
vtkPoints points = vtkPoints.New();
uint GridSize = 20;
double xx, yy, zz;
for (uint x = 0; x < GridSize; x++)
{
for (uint y = 0; y < GridSize; y++)
{
xx = x + vtkMath.Random(-.2, .2);
yy = y + vtkMath.Random(-.2, .2);
zz = vtkMath.Random(-.5, .5);
points.InsertNextPoint(xx, yy, zz);
}
}
// Add the grid points to a polydata object
vtkPolyData inputPolyData = vtkPolyData.New();
inputPolyData.SetPoints(points);
// Triangulate the grid points
vtkDelaunay2D delaunay = vtkDelaunay2D.New();
#if VTK_MAJOR_VERSION_5
delaunay.SetInput(inputPolyData);
#else
delaunay.SetInputData(inputPolyData);
#endif
delaunay.Update();
vtkPolyData outputPolyData = delaunay.GetOutput();
double[] bounds = outputPolyData.GetBounds();
// Find min and max z
double minz = bounds[4];
double maxz = bounds[5];
Debug.WriteLine("minz: " + minz);
Debug.WriteLine("maxz: " + maxz);
// Create the color map
vtkLookupTable colorLookupTable = vtkLookupTable.New();
colorLookupTable.SetTableRange(minz, maxz);
colorLookupTable.Build();
// Generate the colors for each point based on the color map
vtkUnsignedCharArray colors = vtkUnsignedCharArray.New();
colors.SetNumberOfComponents(3);
colors.SetName("Colors");
Debug.WriteLine("There are " + outputPolyData.GetNumberOfPoints()
+ " points.");
#if UNSAFE // fastest way to fill color array
colors.SetNumberOfTuples(outputPolyData.GetNumberOfPoints());
unsafe {
byte *pColor = (byte *)colors.GetPointer(0).ToPointer();
for (int i = 0; i < outputPolyData.GetNumberOfPoints(); i++)
{
double[] p = outputPolyData.GetPoint(i);
double[] dcolor = colorLookupTable.GetColor(p[2]);
Debug.WriteLine("dcolor: "
+ dcolor[0] + " "
+ dcolor[1] + " "
+ dcolor[2]);
byte[] color = new byte[3];
for (uint j = 0; j < 3; j++)
{
color[j] = (byte)(255 * dcolor[j]);
}
Debug.WriteLine("color: "
+ color[0] + " "
+ color[1] + " "
+ color[2]);
*(pColor + 3 * i) = color[0];
*(pColor + 3 * i + 1) = color[1];
*(pColor + 3 * i + 2) = color[2];
}
}
#else
for (int i = 0; i < outputPolyData.GetNumberOfPoints(); i++)
{
double[] p = outputPolyData.GetPoint(i);
double[] dcolor = colorLookupTable.GetColor(p[2]);
Debug.WriteLine("dcolor: "
+ dcolor[0] + " "
+ dcolor[1] + " "
+ dcolor[2]);
byte[] color = new byte[3];
for (uint j = 0; j < 3; j++)
{
color[j] = (byte)(255 * dcolor[j]);
}
Debug.WriteLine("color: "
+ color[0] + " "
+ color[1] + " "
+ color[2]);
colors.InsertNextTuple3(color[0], color[1], color[2]);
//IntPtr pColor = Marshal.AllocHGlobal(Marshal.SizeOf(typeof(byte)) * 3);
//Marshal.Copy(color, 0, pColor, 3);
//colors.InsertNextTupleValue(pColor);
//Marshal.FreeHGlobal(pColor);
}
#endif
outputPolyData.GetPointData().SetScalars(colors);
// Create a mapper and actor
vtkPolyDataMapper mapper = vtkPolyDataMapper.New();
#if VTK_MAJOR_VERSION_5
mapper.SetInputConnection(outputPolyData.GetProducerPort());
#else
mapper.SetInputData(outputPolyData);
#endif
vtkActor actor = vtkActor.New();
actor.SetMapper(mapper);
// 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);
}
private void WeightedTransformFilter()
{
// Use a sphere as a basis of the shape
vtkSphereSource sphere = vtkSphereSource.New();
sphere.SetPhiResolution(40);
sphere.SetThetaResolution(40);
sphere.Update();
vtkPolyData sphereData = sphere.GetOutput();
// Create a data array to hold the weighting coefficients
vtkFloatArray tfarray = vtkFloatArray.New();
int npoints = sphereData.GetNumberOfPoints();
tfarray.SetNumberOfComponents(2);
tfarray.SetNumberOfTuples(npoints);
// Parameterize the sphere along the z axis, and fill the weights
// with (1.0-a, a) to linearly interpolate across the shape
IntPtr pPoint = Marshal.AllocHGlobal(Marshal.SizeOf(typeof(double)) * 3);
double[] point = new double[3];
for (int i = 0; i < npoints; i++)
{
sphereData.GetPoint(i, pPoint);
Marshal.Copy(pPoint, point, 0, 3);
double x = point[0];
double y = point[1];
double z = point[2];
double zn = z + 0.5;
double zn1 = 1.0 - zn;
if (zn > 1.0)
{
zn = 1.0;
}
if (zn1 < 0.0)
{
zn1 = 0.0;
}
tfarray.SetComponent(i, 0, zn1);
tfarray.SetComponent(i, 1, zn);
}
Marshal.FreeHGlobal(pPoint);
// Create field data to hold the array, and bind it to the sphere
vtkFieldData fd = vtkFieldData.New();
tfarray.SetName("weights");
sphereData.GetPointData().AddArray(tfarray);
// Use an ordinary transform to stretch the shape
vtkTransform stretch = vtkTransform.New();
stretch.Scale(1, 1, 3.2);
vtkTransformFilter stretchFilter = vtkTransformFilter.New();
stretchFilter.SetInputConnection(sphereData.GetProducerPort());
stretchFilter.SetTransform(stretch);
// Now, for the weighted transform stuff
vtkWeightedTransformFilter weightedTrans = vtkWeightedTransformFilter.New();
// Create two transforms to interpolate between
vtkTransform identity = vtkTransform.New();
identity.Identity();
vtkTransform rotated = vtkTransform.New();
double rotatedAngle = 45;
rotated.RotateX(rotatedAngle);
weightedTrans.SetNumberOfTransforms(2);
weightedTrans.SetTransform(identity, 0);
weightedTrans.SetTransform(rotated, 1);
// which data array should the filter use ?
weightedTrans.SetWeightArray("weights");
weightedTrans.SetInputConnection(stretchFilter.GetOutputPort());
vtkPolyDataMapper weightedTransMapper = vtkPolyDataMapper.New();
weightedTransMapper.SetInputConnection(weightedTrans.GetOutputPort());
vtkActor weightedTransActor = vtkActor.New();
weightedTransActor.SetMapper(weightedTransMapper);
weightedTransActor.GetProperty().SetDiffuseColor(0.8, 0.8, 0.1);
weightedTransActor.GetProperty().SetRepresentationToSurface();
// 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(weightedTransActor);
renderer.ResetCamera();
renderer.GetActiveCamera().Azimuth(90);
renderer.GetActiveCamera().Dolly(1);
}
private void ReadPlainText()
{
// Path to vtk data must be set as an environment variable
// VTK_DATA_ROOT = "C:\VTK\vtkdata-5.8.0"
vtkTesting test = vtkTesting.New();
string root = test.GetDataRoot();
string filePath = System.IO.Path.Combine(root, @"Data\teapot.xyz");
FileStream fs = null;
StreamReader sr = null;
String sLineBuffer;
String[] sXYZ;
char[] chDelimiter = new char[] { ' ', '\t', ';' };
double[] xyz = new double[3];
vtkPoints points = vtkPoints.New();
int cnt = 0;
try {
// in case file must be open in another application too use "FileShare.ReadWrite"
fs = new FileStream(filePath, FileMode.Open, FileAccess.Read, FileShare.ReadWrite);
sr = new StreamReader(fs);
while (!sr.EndOfStream)
{
sLineBuffer = sr.ReadLine();
cnt++;
sXYZ = sLineBuffer.Split(chDelimiter, StringSplitOptions.RemoveEmptyEntries);
if (sXYZ == null || sXYZ.Length != 3)
{
MessageBox.Show("data seems to be in wrong format at line " + cnt, "Format Exception", MessageBoxButtons.OK);
return;
}
xyz[0] = double.Parse(sXYZ[0], CultureInfo.InvariantCulture);
xyz[1] = double.Parse(sXYZ[1], CultureInfo.InvariantCulture);
xyz[2] = double.Parse(sXYZ[2], CultureInfo.InvariantCulture);
points.InsertNextPoint(xyz[0], xyz[1], xyz[2]);
}
vtkPolyData polydata = vtkPolyData.New();
polydata.SetPoints(points);
vtkVertexGlyphFilter glyphFilter = vtkVertexGlyphFilter.New();
glyphFilter.SetInputConnection(polydata.GetProducerPort());
// Visualize
vtkPolyDataMapper mapper = vtkPolyDataMapper.New();
mapper.SetInputConnection(glyphFilter.GetOutputPort());
vtkActor actor = vtkActor.New();
actor.SetMapper(mapper);
actor.GetProperty().SetPointSize(4);
actor.GetProperty().SetColor(1, 0.5, 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);
}
catch (IOException ex) {
MessageBox.Show(ex.Message, "IOException", MessageBoxButtons.OK);
}
finally {
if (sr != null)
{
sr.Close();
sr.Dispose();
sr = null;
}
}
}
private void FillHoles(string filePath)
{
vtkPolyData input = vtkPolyData.New();
if (filePath == null)
{
GenerateData(ref input);
}
else
{
vtkXMLPolyDataReader reader = vtkXMLPolyDataReader.New();
reader.SetFileName(filePath);
reader.Update();
input.ShallowCopy(reader.GetOutput());
}
vtkFillHolesFilter fillHolesFilter = vtkFillHolesFilter.New();
#if VTK_MAJOR_VERSION_5
fillHolesFilter.SetInputConnection(input.GetProducerPort());
#else
fillHolesFilter.SetInputData(input);
#endif
fillHolesFilter.Update();
// Create a mapper and actor
vtkPolyDataMapper originalMapper = vtkPolyDataMapper.New();
#if VTK_MAJOR_VERSION_5
originalMapper.SetInputConnection(input.GetProducerPort());
#else
originalMapper.SetInputData(input);
#endif
vtkActor originalActor = vtkActor.New();
originalActor.SetMapper(originalMapper);
vtkPolyDataMapper filledMapper = vtkPolyDataMapper.New();
filledMapper.SetInputConnection(fillHolesFilter.GetOutputPort());
vtkActor filledActor = vtkActor.New();
filledActor.SetMapper(filledMapper);
vtkRenderWindow renderWindow = renderWindowControl1.RenderWindow;
this.Size = new System.Drawing.Size(612, 352);
// Define viewport ranges
// (xmin, ymin, xmax, ymax)
double[] leftViewport = new double[] { 0.0, 0.0, 0.5, 1.0 };
double[] rightViewport = new double[] { 0.5, 0.0, 1.0, 1.0 };
// Setup both renderers
vtkRenderer leftRenderer = vtkRenderer.New();
renderWindow.AddRenderer(leftRenderer);
leftRenderer.SetViewport(leftViewport[0], leftViewport[1], leftViewport[2], leftViewport[3]);
leftRenderer.SetBackground(.6, .5, .4);
vtkRenderer rightRenderer = vtkRenderer.New();
renderWindow.AddRenderer(rightRenderer);
rightRenderer.SetViewport(rightViewport[0], rightViewport[1], rightViewport[2], rightViewport[3]);
rightRenderer.SetBackground(.4, .5, .6);
// Add the sphere to the left and the cube to the right
leftRenderer.AddActor(originalActor);
rightRenderer.AddActor(filledActor);
leftRenderer.ResetCamera();
rightRenderer.ResetCamera();
renderWindow.Render();
}
private void RenderXYZColor()
{
FileStream fs = null;
StreamReader sr = null;
String sLineBuffer;
String[] sXYZ;
char[] chDelimiter = new char[] { ' ', '\t', ';' };
double[] xyz = new double[3];
double[] rgb = new double[3];
vtkPoints points = vtkPoints.New();
vtkPoints colors = vtkPoints.New();
int cnt = 0;
try
{
// in case file must be open in another application too use "FileShare.ReadWrite"
fs = new FileStream(m_FileName, FileMode.Open, FileAccess.Read, FileShare.ReadWrite);
sr = new StreamReader(fs);
vtkDoubleArray colorScalor = new vtkDoubleArray();
int n = 1;
while (!sr.EndOfStream)
{
sLineBuffer = sr.ReadLine();
cnt++;
sXYZ = sLineBuffer.Split(chDelimiter, StringSplitOptions.RemoveEmptyEntries);
if (sXYZ == null || sXYZ.Length != 6)
{
MessageBox.Show("data seems to be in wrong format at line " + cnt, "Format Exception", MessageBoxButtons.OK);
return;
}
xyz[0] = double.Parse(sXYZ[0], CultureInfo.InvariantCulture) * 11100;
xyz[1] = double.Parse(sXYZ[1], CultureInfo.InvariantCulture) * 11100;
xyz[2] = double.Parse(sXYZ[2], CultureInfo.InvariantCulture);
rgb[0] = double.Parse(sXYZ[0], CultureInfo.InvariantCulture);
rgb[1] = double.Parse(sXYZ[1], CultureInfo.InvariantCulture);
rgb[2] = double.Parse(sXYZ[2], CultureInfo.InvariantCulture);
points.InsertNextPoint(xyz[0], xyz[1], xyz[2]);
colors.InsertNextPoint(rgb[0], rgb[1], rgb[2]);
colorScalor.InsertNextTuple1(n++);
}
vtkPolyData polydata = vtkPolyData.New();
polydata.SetPoints(points);
polydata.GetPointData().SetScalars(colorScalor); //设置点的Scalar(标量)属性
vtkVertexGlyphFilter glyphFilter = vtkVertexGlyphFilter.New();
glyphFilter.SetInputConnection(polydata.GetProducerPort());
vtkLookupTable lookupTable = new vtkLookupTable();
lookupTable.SetNumberOfColors(n);
// SetSetTableValue(vtkIdType indx, double r, double g, double b, double a);
Random random = new Random();
for (int i = 0; i < n; i++)
{
double[] tmp = colors.GetPoint(i);
double r = tmp[0];
double g = tmp[1];
double b = tmp[2];
lookupTable.SetTableValue(i, r, g, b, 1);
}
// Visualize
vtkPolyDataMapper mapper = vtkPolyDataMapper.New();
mapper.SetInputConnection(glyphFilter.GetOutputPort());
mapper.SetLookupTable(lookupTable);
mapper.SetScalarRange(1, n);
vtkActor actor = vtkActor.New();
actor.SetMapper(mapper);
actor.GetProperty().SetPointSize(1);
//actor.GetProperty().SetColor(1, 0.5, 0);
// add our actor to the renderer
m_Renderer.AddActor(actor);
imgPropList.Add(actor);
m_Renderer.ResetCamera();
//Rerender the screen
m_RenderWindow.Render();
m_Renderer.Render();
}
catch (IOException ex)
{
MessageBox.Show(ex.Message, "IOException", MessageBoxButtons.OK);
}
finally
{
if (sr != null)
{
sr.Close();
sr.Dispose();
sr = null;
}
}
}
