private void renderScene()
{
vtkCamera camera;
if (toShow != null)
{
this.geometryPoints();
vtkPolyData polydata = vtkPolyData.New();
polydata.SetPoints(pontosVTK);
vtkDelaunay2D del = vtkDelaunay2D.New();
del.AddInput(polydata);
vtkPolyDataMapper mapMesh = vtkPolyDataMapper.New();
mapMesh.SetInput(del.GetOutput());
vtkActor meshActor = vtkActor.New();
meshActor.SetMapper(mapMesh);
meshActor.GetProperty().SetColor(0.5d, 0.5d, 0d);
windowVTK.AddRenderer(rendererVTK);
rendererVTK.AddActor(meshActor);
windowVTK.Render();
rendererVTK.Render();
meshActor.Render(rendererVTK, mapMesh);
camera = rendererVTK.GetActiveCamera();
camera.Zoom(1.0d);
rendererVTK.ResetCamera();
}
}
static public vtkAlgorithmOutput calcRestriction(CompontData data)
{
//calculation::RayTracing rayTracing(this);
Restriction rest = (Restriction)data.restriction;
if (rest == null)
{
return(null);
}
// 调后台生成光线
TBTfront.Ant ant = new TBTfront.Ant();
List <TBTfront.CompontParam> list_data = new List <TBTfront.CompontParam>();
list_data.Add(rest);
list_data.Add(data);
List <TBTfront.RayLineCluster> rayline_list = new List <TBTfront.RayLineCluster>();
RayLineCluster rayline_cluster = new RayLineCluster();
CalcOption opt = new CalcOption();
opt.is_ign_non_intersection = true;
opt.is_ign_restriction = true;
ant.clacLight(list_data, rayline_cluster, rayline_list, opt);
rayline_cluster = rayline_list[2];
vtkPoints points = vtkPoints.New();
foreach (var ray in rayline_cluster.ray_cluster)
{
points.InsertNextPoint(ray.start_point.x,
ray.start_point.y,
ray.start_point.z);
}
vtkPolyData polyData = vtkPolyData.New();
polyData.SetPoints(points);
vtkDelaunay2D delaunay = vtkDelaunay2D.New();
delaunay.SetInput(polyData);
delaunay.Update();
return(delaunay.GetOutputPort());
}
private void Window_Loaded(object sender, RoutedEventArgs e)
{
vtkPoints points = vtkPoints.New();
int GridSize = 10;
for (int x = 0; x < GridSize; x++)
{
for (int y = 0; y < GridSize; y++)
{
points.InsertNextPoint(x, y, (x + y) / (y + 1));
}
}
// Add the grid points to a polydata object
vtkPolyData polydata = vtkPolyData.New();
polydata.SetPoints(points);
// Triangulate the grid points
vtkDelaunay2D delaunay = vtkDelaunay2D.New();
delaunay.SetInput(polydata);
delaunay.Update();
vtkPlaneSource plane = vtkPlaneSource.New();
//Read the image data from a file
vtkJPEGReader reader = vtkJPEGReader.New();
reader.SetFileName("C:\\Users\\georg\\Desktop\\texture.jpg");
//Create texture object
vtkTexture texture = vtkTexture.New();
texture.SetInputConnection(reader.GetOutputPort());
//Map texture coordinates
vtkTextureMapToPlane map_to_plane = vtkTextureMapToPlane.New();
map_to_plane.SetInputConnection(plane.GetOutputPort());
map_to_plane.SetInputConnection(delaunay.GetOutputPort());
//Create mapper and set the mapped texture as input
vtkPolyDataMapper mapper = vtkPolyDataMapper.New();
mapper.SetInputConnection(map_to_plane.GetOutputPort());
//Create actor and set the mapper and the texture
vtkActor actor = vtkActor.New();
actor.SetMapper(mapper);
actor.SetTexture(texture);
vtkRenderer renderer = vtkRenderer.New();
renderer.AddActor(actor);
RenderControl1.RenderWindow.AddRenderer(renderer);
}
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);
}
/// <summary>
/// Entry Point
/// </summary>
/// <param name="argv"></param>
public static void Main(String[] argv)
{
// This example demonstrates how to use 2D Delaunay triangulation.
// We create a fancy image of a 2D Delaunay triangulation. Points are
// randomly generated.
// first we load in the standard vtk packages into tcl
// Generate some random points
math = vtkMath.New();
points = vtkPoints.New();
for(int i = 0; i < 50; i++)
{
points.InsertPoint(i, vtkMath.Random(0, 1), vtkMath.Random(0, 1), 0.0);
}
// Create a polydata with the points we just created.
profile = vtkPolyData.New();
profile.SetPoints(points);
// Perform a 2D Delaunay triangulation on them.
del = vtkDelaunay2D.New();
del.SetInput(profile);
del.SetTolerance(0.001);
mapMesh = vtkPolyDataMapper.New();
mapMesh.SetInputConnection(del.GetOutputPort());
meshActor = vtkActor.New();
meshActor.SetMapper(mapMesh);
meshActor.GetProperty().SetColor(.1, .2, .4);
// We will now create a nice looking mesh by wrapping the edges in tubes,
// and putting fat spheres at the points.
extract = vtkExtractEdges.New();
extract.SetInputConnection(del.GetOutputPort());
tubes = vtkTubeFilter.New();
tubes.SetInputConnection(extract.GetOutputPort());
tubes.SetRadius(0.01);
tubes.SetNumberOfSides(6);
mapEdges = vtkPolyDataMapper.New();
mapEdges.SetInputConnection(tubes.GetOutputPort());
edgeActor = vtkActor.New();
edgeActor.SetMapper(mapEdges);
edgeActor.GetProperty().SetColor(0.2000, 0.6300, 0.7900);
edgeActor.GetProperty().SetSpecularColor(1, 1, 1);
edgeActor.GetProperty().SetSpecular(0.3);
edgeActor.GetProperty().SetSpecularPower(20);
edgeActor.GetProperty().SetAmbient(0.2);
edgeActor.GetProperty().SetDiffuse(0.8);
ball = vtkSphereSource.New();
ball.SetRadius(0.025);
ball.SetThetaResolution(12);
ball.SetPhiResolution(12);
balls = vtkGlyph3D.New();
balls.SetInputConnection(del.GetOutputPort());
balls.SetSourceConnection(ball.GetOutputPort());
mapBalls = vtkPolyDataMapper.New();
mapBalls.SetInputConnection(balls.GetOutputPort());
ballActor = vtkActor.New();
ballActor.SetMapper(mapBalls);
ballActor.GetProperty().SetColor(1.0000, 0.4118, 0.7059);
ballActor.GetProperty().SetSpecularColor(1, 1, 1);
ballActor.GetProperty().SetSpecular(0.3);
ballActor.GetProperty().SetSpecularPower(20);
ballActor.GetProperty().SetAmbient(0.2);
ballActor.GetProperty().SetDiffuse(0.8);
// Create graphics objects
// Create the rendering window, renderer, and interactive renderer
ren1 = vtkRenderer.New();
renWin = vtkRenderWindow.New();
renWin.AddRenderer(ren1);
iren = vtkRenderWindowInteractor.New();
iren.SetRenderWindow(renWin);
// Add the actors to the renderer, set the background and size
ren1.AddActor(ballActor);
ren1.AddActor(edgeActor);
ren1.SetBackground(1, 1, 1);
renWin.SetSize(150, 150);
// render the image
ren1.ResetCamera();
ren1.GetActiveCamera().Zoom(1.5);
iren.Initialize();
iren.Start();
// Clean Up
deleteAllVTKObjects();
}
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);
}
