internal OrientationEnumPackage(vtkPolyData polyData, vtkRenderWindow renwin, vtkRenderer mainRenderer)
{
this._renwin = renwin;
this._mainRenderer = mainRenderer;
int oldNumberOfRenderer = renwin.GetNumberOfLayers();
Console.WriteLine(string.Format("oldNumberOfRenderer = {0}", oldNumberOfRenderer));
int newNumberOfRenderer = oldNumberOfRenderer + 1;
mainRenderer.SetLayer(0);
_topRenderer = vtkRenderer.New();
_topRenderer.SetViewport(0, 0, 0.2, 0.2);
_topRenderer.SetLayer(newNumberOfRenderer - 1);
_topRenderer.InteractiveOff();
_xmlPolyDataPackage = new XmlPolyDataPackage(polyData, _topRenderer);
//xmlPolyDataPackage.SetOpacity(0.8);
//xmlPolyDataPackage.Actor.GetProperty().ShadingOn();
//xmlPolyDataPackage.Actor.GetProperty().SetAmbient(0.8);
//xmlPolyDataPackage.SetColor(1, 1, 0.5);
_xmlPolyDataPackage.SetColor(255 / 255.0, 204 / 255.0, 102 / 255.0);
renwin.SetNumberOfLayers(newNumberOfRenderer);
renwin.AddRenderer(_topRenderer);
//_topRenderer.SetActiveCamera(mainRenderer.GetActiveCamera());
}
/// <summary>
/// The main entry method called by the CSharp driver
/// </summary>
/// <param name="argv"></param>
public static void AVEnSightOfficeBin(String [] argv)
{
//Prefix Content is: ""
ren1 = vtkRenderer.New();
renWin = vtkRenderWindow.New();
renWin.AddRenderer((vtkRenderer)ren1);
iren = new vtkRenderWindowInteractor();
iren.SetRenderWindow((vtkRenderWindow)renWin);
// read data[]
//[]
reader = new vtkGenericEnSightReader();
// Make sure all algorithms use the composite data pipeline[]
cdp = new vtkCompositeDataPipeline();
vtkGenericEnSightReader.SetDefaultExecutivePrototype((vtkExecutive)cdp);
reader.SetCaseFileName((string)"" + (VTK_DATA_ROOT.ToString()) + "/Data/EnSight/office_bin.case");
reader.Update();
// to add coverage for vtkOnePieceExtentTranslator[]
translator = new vtkOnePieceExtentTranslator();
vtkStreamingDemandDrivenPipeline.SetExtentTranslator(reader.GetOutputInformation(0), (vtkExtentTranslator)translator);
outline = new vtkStructuredGridOutlineFilter();
// outline SetInputConnection [reader GetOutputPort][]
outline.SetInputData((vtkDataObject)reader.GetOutput().GetBlock((uint)0));
mapOutline = vtkPolyDataMapper.New();
mapOutline.SetInputConnection((vtkAlgorithmOutput)outline.GetOutputPort());
outlineActor = new vtkActor();
outlineActor.SetMapper((vtkMapper)mapOutline);
outlineActor.GetProperty().SetColor((double)0,(double)0,(double)0);
// Create source for streamtubes[]
streamer = new vtkStreamPoints();
// streamer SetInputConnection [reader GetOutputPort][]
streamer.SetInputData((vtkDataObject)reader.GetOutput().GetBlock((uint)0));
streamer.SetStartPosition((double)0.1,(double)2.1,(double)0.5);
streamer.SetMaximumPropagationTime((double)500);
streamer.SetTimeIncrement((double)0.5);
streamer.SetIntegrationDirectionToForward();
cone = new vtkConeSource();
cone.SetResolution((int)8);
cones = new vtkGlyph3D();
cones.SetInputConnection((vtkAlgorithmOutput)streamer.GetOutputPort());
cones.SetSourceConnection(cone.GetOutputPort());
cones.SetScaleFactor((double)0.9);
cones.SetScaleModeToScaleByVector();
mapCones = vtkPolyDataMapper.New();
mapCones.SetInputConnection((vtkAlgorithmOutput)cones.GetOutputPort());
// eval mapCones SetScalarRange [[reader GetOutput] GetScalarRange][]
mapCones.SetScalarRange((double)((vtkDataSet)reader.GetOutput().GetBlock((uint)0)).GetScalarRange()[0],
(double)((vtkDataSet)reader.GetOutput().GetBlock((uint)0)).GetScalarRange()[1]);
conesActor = new vtkActor();
conesActor.SetMapper((vtkMapper)mapCones);
ren1.AddActor((vtkProp)outlineActor);
ren1.AddActor((vtkProp)conesActor);
ren1.SetBackground((double)0.4,(double)0.4,(double)0.5);
renWin.SetSize((int)300,(int)300);
iren.Initialize();
// interact with data[]
vtkGenericEnSightReader.SetDefaultExecutivePrototype(null);
//deleteAllVTKObjects();
}
private void DrawTexturePlane()
{
//load in the texture map
vtkBMPReader bmpReader = vtkBMPReader.New();
bmpReader.SetFileName(@"..\..\Data\masonry.bmp");
vtkTexture atext = vtkTexture.New();
atext.SetInputConnection(bmpReader.GetOutputPort());
atext.InterpolateOn();
//create a plane source and actor
vtkPlaneSource plane = vtkPlaneSource.New();
plane.SetPoint1(0, 0, 0);
vtkPolyDataMapper planeMapper = vtkPolyDataMapper.New();
planeMapper.SetInputConnection(plane.GetOutputPort());
vtkActor planeActor = vtkActor.New();
planeActor.SetMapper(planeMapper);
planeActor.SetTexture(atext);
vtkRenderer renderer = vtkRenderer.New();
vtkRenderWindow renWin = myRenderWindowControl.RenderWindow;
renWin.AddRenderer(renderer);
renderer.AddActor(planeActor);
}
private void button2_Click_1(object sender, EventArgs e)
{
string inscriptionpath = textBox1.Text;
vtkVectorText text = vtkVectorText.New();
text.SetText(inscriptionpath);
//text.GetOutput().GetPoints().GetNumberOfPoints();
//
//vtkLinearExtrusionFilter extrude = vtkLinearExtrusionFilter.New();
//extrude.SetInputConnection(text.GetOutputPort());
//extrude.SetExtrusionTypeToNormalExtrusion();
//extrude.SetVector(0, 0, 1);
//extrude.SetScaleFactor(0.5);
//vtkTriangleFilter triangle = vtkTriangleFilter.New();
//triangle.SetInputConnection(extrude.GetOutputPort());
vtkDataSetMapper mapper = vtkDataSetMapper.New();
mapper.SetInputConnection(text.GetOutputPort());
vtkActor actor = vtkActor.New();
actor.SetMapper(mapper);
actor.GetProperty().SetColor(0.8900, 0.8100, 0.3400);
actor.SetPosition(0, 0, 0);
renderWindow.AddRenderer(renderer);
renderer.AddActor(actor);
renderer.ResetCamera();
renderWindow.GetInteractor().Render();
}
private void DrawSphere(double radius)
{
vtkSphereSource sphereSource = vtkSphereSource.New();
sphereSource.SetThetaResolution(8);
sphereSource.SetPhiResolution(16);
sphereSource.SetRadius(radius);
vtkShrinkPolyData shrink = vtkShrinkPolyData.New();
shrink.SetInputConnection(sphereSource.GetOutputPort());
shrink.SetShrinkFactor(0.9);
vtkPolyDataMapper sphereMapper = vtkPolyDataMapper.New();
//sphereMapper.SetInputConnection(sphereSource.GetOutputPort());
sphereMapper.SetInputConnection(shrink.GetOutputPort());
vtkActor sphereActor = vtkActor.New();
sphereActor.SetMapper(sphereMapper);
sphereActor.GetProperty().SetColor(1, 0, 0);
vtkRenderer sphereRender = vtkRenderer.New();
vtkRenderWindow renWin = myRenderWindowControl.RenderWindow;
renWin.AddRenderer(sphereRender);
sphereRender.AddActor(sphereActor);
sphereRender.SetBackground(0.0, 0.0, 1.0);
}
public WatermarkPackage(vtkRenderWindow renwin, vtkRenderer mainRenderer, vtkImageData maskImage)
{
int oldNumberOfRenderer = renwin.GetNumberOfLayers();
Console.WriteLine(string.Format("oldNumberOfRenderer = {0}", oldNumberOfRenderer));
int newNumberOfRenderer = oldNumberOfRenderer + 1;
mainRenderer.SetLayer(0);
vtkRenderer _topRenderer = vtkRenderer.New();
_topRenderer.SetViewport(0, 0, 1, 1);
_topRenderer.SetLayer(newNumberOfRenderer - 1);
_topRenderer.InteractiveOff();
_topRenderer.GetActiveCamera().ParallelProjectionOn();
mainRenderer.SetLayer(1);
_topRenderer.SetLayer(0);
renwin.SetNumberOfLayers(newNumberOfRenderer);
renwin.AddRenderer(_topRenderer);
// Display the image
_actor = vtkImageActor.New();
_actor.SetInput(maskImage);
_actor.SetOpacity(0.8);
_topRenderer.AddActor(_actor);
_topRenderer.ResetCameraClippingRange();
_topRenderer.ResetCamera();
_topRenderer.GetActiveCamera().Zoom(1.6);
}
/// <summary>
/// Executes the initialize action.
/// </summary>
///
/// <param name="hWnd">The HWND we present to when rendering.</param>
///
/// <seealso cref="M:ActivizWPF.Framework.Native.HwndWrapper.OnInitialize(IntPtr)"/>
protected override void OnInitialize(IntPtr hWnd)
{
try
{
vtkLogoWidget vtkLogoWidget = new vtkLogoWidget();
_renderer = vtkRenderer.New();
_renderWindow = vtkRenderWindow.New();
_renderWindowInteractor = vtkRenderWindowInteractor.New();
vtkInteractorStyleSwitch interactorStyleSwitch = _renderWindowInteractor.GetInteractorStyle() as vtkInteractorStyleSwitch;
if (null != interactorStyleSwitch)
{
interactorStyleSwitch.SetCurrentStyleToTrackballCamera();
}
_renderWindow.SetParentId(hWnd);
_renderWindow.AddRenderer(_renderer);
AttachInteractor();
vtkLogoWidget.Dispose();
}
catch (Exception ex)
{
log.ErrorException("OnInitialize()", ex);
}
}
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();
}
}
private void VRML()
{
// 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\bot2.wrl");
// reader
vtkVRMLImporter importer = vtkVRMLImporter.New();
importer.SetFileName(filePath);
importer.Update();
// get a reference to the renderwindow of our renderWindowControl1
vtkRenderWindow renderWindow = renderWindowControl1.RenderWindow;
renderWindow.AddRenderer(importer.GetRenderer());
renderWindow.Render();
//vtkActorCollection actors = importer.GetRenderer().GetActors();
//actors.InitTraversal();
//vtkActor tmp;
//while(( tmp = actors.GetNextActor()) != null) {
//}
}
private void ReadStlFileDraw()
{
vtkSTLReader stlReader = vtkSTLReader.New();
//stlReader.SetFileName(@"..\..\Data\anchor_hook.stl");
stlReader.SetFileName(@"..\..\Data\42400-IDGH.stl");
vtkShrinkPolyData shrink = vtkShrinkPolyData.New();
shrink.SetInputConnection(stlReader.GetOutputPort());
shrink.SetShrinkFactor(0.85);
vtkPolyDataMapper stlMapper = vtkPolyDataMapper.New();
//stlMapper.SetInputConnection(stlReader.GetOutputPort());
stlMapper.SetInputConnection(shrink.GetOutputPort());
vtkLODActor stlActor = vtkLODActor.New();
stlActor.SetMapper(stlMapper);
stlActor.GetProperty().SetColor((float)Color.Orange.R / 256, (float)Color.Orange.G / 256, (float)Color.Orange.B / 256); //设置actor的颜色
vtkRenderer stlRender = vtkRenderer.New();
vtkRenderWindow renWin = myRenderWindowControl.RenderWindow;
renWin.AddRenderer(stlRender);
stlRender.AddActor(stlActor);
stlRender.SetBackground(1.0, 1.0, 1.0);
}
/// <summary>
/// Event fired when the graph selection is changed
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
void view_SelectionChangedEvt(vtkObject sender, vtkObjectEventArgs e)
{
//Get the selection
vtkDataRepresentation dr = view.GetRepresentation(0);
vtkAnnotationLink al = dr.GetAnnotationLink();
vtkSelection sel = al.GetCurrentSelection();
vtkAbstractArray arr = null;
vtkSelectionNode node = sel.GetNode(0);
if (null != node)
{
arr = node.GetSelectionList();
}
vtkIdTypeArray arr1 = (vtkIdTypeArray)arr;
// Short circuit if nothing is selected...
int numSelected = (int)arr1.GetNumberOfTuples();
if (0 == numSelected)
{
return;
}
vtkStringArray arr2 = ((vtkStringArray)g.GetVertexData().GetAbstractArray("label"));
//get a pseudo random name if more than one are selected
string name = arr2.GetValue(
(int)arr1.GetValue(System.DateTime.Now.Millisecond % numSelected));
//reset the small arrayList
arrListSmall = new System.Collections.ArrayList();
int hops;
try
{
hops = System.Convert.ToInt32(toolStripTextBox3.Text);
}
catch (Exception)
{
hops = 1;
}
toolStripTextBox1.Text = name;
toolStripTextBox1.Invalidate();
this.Update();
//Start the loading graphic and add another renderer on top for the spinning logo
vtkRenderWindow win = this.renderWindowControl1.RenderWindow;
win.AddRenderer(logoRenderer);
win.Render();
this.webBrowser1.Url = new Uri("http://en.wikipedia.org/wiki/" + name.Replace(" ", "_"));
//Start the work
addLinks(g, name, hops);
//Remove the spinning logo after the work is done
win.RemoveRenderer(logoRenderer);
win.Render();
}
static private void init()
{
vtkSTLReader rdr = vtkSTLReader.New();
rdr.SetFileName("BODY-EXTRUDEUR-WADE.stl");
// Créer une géométrie sphérique
/*vtkSphereSource sphere = vtkSphereSource.New();
* sphere.SetRadius(1.0);
* sphere.SetThetaResolution(18);
* sphere.SetPhiResolution(18);*/
// Transforme la géométrie en primitives graphiques (OpenGL dans notre cas)
vtkPolyDataMapper map = vtkPolyDataMapper.New();
map.SetInput(rdr.GetOutput());
// L'acteur représente l'entitée géométrique.
// Il permet de définir sa position, son orientation, sa couleur, etc.
vtkActor aSphere = new vtkActor();
aSphere.SetMapper(map);
aSphere.GetProperty().SetColor(0.8, 0.8, 0.8); // color blue
// Nous créons un renderer qui va faire le rendu de notre entitée.
vtkRenderer ren1 = vtkRenderer.New();
ren1.AddActor(aSphere);
ren1.SetBackground(1, 1, 1); // background color white
// Nous créons une fenêtre de rendu
vtkRenderWindow renWin = vtkRenderWindow.New();
renWin.AddRenderer(ren1);
renWin.SetSize(300, 300);
// Nous créons un interactor qui permet de bouger la caméra.
vtkRenderWindowInteractor iren = new vtkRenderWindowInteractor();
iren.SetRenderWindow(renWin);
// Nous lançons le rendu et l'interaction
renWin.Render();
iren.Start();
////// CLEANUP ///////
rdr.Dispose();
map.Dispose();
aSphere.Dispose();
ren1.Dispose();
renWin.Dispose();
iren.Dispose();
}
/// <summary>
/// Clears the graph and makes a new one
/// </summary>
private void createNewGraph()
{
String lookupValue = toolStripTextBox1.Text;
//clean up any old graph views in the renderer
vtkMutableDirectedGraph g_temp = g;
g = vtkMutableDirectedGraph.New();
if (g_temp != null)
{
g_temp.Dispose();
}
//reset array lists
arrListSmall = new System.Collections.ArrayList();
vtkStringArray label = vtkStringArray.New();
label.SetName("label");
//give the graph a starting point
g.GetVertexData().AddArray(label);
g.AddVertex();
label.InsertNextValue(lookupValue);
arrListSmall.Add(lookupValue);
int hops;
try
{
hops = System.Convert.ToInt32(toolStripTextBox3.Text);
}
catch (Exception)
{
hops = 1;
}
//Start the loading graphic and switch renderers
vtkRenderWindow win = this.renderWindowControl1.RenderWindow;
win.AddRenderer(logoRenderer);
win.Render();
this.webBrowser1.Url = new Uri("http://en.wikipedia.org/wiki/" + lookupValue.Replace(" ", "_"));
//Start the work
addLinks(g, lookupValue, hops);
//Go back to the graph view after the work is done
win.RemoveRenderer(logoRenderer);
//Setup the view properties
view.SetLayoutStrategyToSimple2D();
view.AddRepresentationFromInput(g);
view.SetVertexLabelArrayName("label");
view.VertexLabelVisibilityOn();
view.SetVertexColorArrayName("VertexDegree");
view.ColorVerticesOn();
view.GetRenderer().ResetCamera();
view.Update();
}
// Static void method with same signature as "Main" is always
// file base name:
//
/// <summary>
/// VTK test Main method
/// </summary>
public static void vtkConeSourceTest(string[] args)
{
bool interactive = false;
foreach (string s in args)
{
// -I means "interactive" test -- do not automatically quit:
//
if (s == "-I")
{
interactive = true;
}
}
vtkConeSource source = new vtkConeSource();
vtkMapper mapper = vtkPolyDataMapper.New();
mapper.SetInputConnection(source.GetOutputPort());
vtkActor actor = new vtkActor();
actor.SetMapper(mapper);
vtkRenderer ren1 = vtkRenderer.New();
ren1.AddActor(actor);
ren1.SetBackground(0.1, 0.2, 0.4);
vtkRenderWindow renWin = vtkRenderWindow.New();
renWin.AddRenderer(ren1);
renWin.SetSize(400, 300);
vtkRenderWindowInteractor iren = vtkRenderWindowInteractor.New();
iren.SetRenderWindow(renWin);
iren.Initialize();
Kitware.mummy.Runtime.Methods.Print(false);
Kitware.mummy.Runtime.Methods.PrintWrappedObjectsTable();
if (interactive)
{
iren.Start();
}
ren1.SetRenderWindow(null);
iren.SetRenderWindow(null);
renWin.Dispose();
}
/// <summary>
/// The main entry method called by the CSharp driver
/// </summary>
/// <param name="argv"></param>
public static void AVTestExtrudePiece(String [] argv)
{
//Prefix Content is: ""
disk = new vtkDiskSource();
disk.SetRadialResolution((int)2);
disk.SetCircumferentialResolution((int)9);
clean = new vtkCleanPolyData();
clean.SetInputConnection((vtkAlgorithmOutput)disk.GetOutputPort());
clean.SetTolerance((double)0.01);
piece = new vtkExtractPolyDataPiece();
piece.SetInputConnection((vtkAlgorithmOutput)clean.GetOutputPort());
extrude = new vtkPLinearExtrusionFilter();
extrude.SetInputConnection((vtkAlgorithmOutput)piece.GetOutputPort());
extrude.PieceInvariantOn();
// Create the RenderWindow, Renderer and both Actors[]
//[]
ren1 = vtkRenderer.New();
renWin = vtkRenderWindow.New();
renWin.AddRenderer((vtkRenderer)ren1);
iren = new vtkRenderWindowInteractor();
iren.SetRenderWindow((vtkRenderWindow)renWin);
mapper = vtkPolyDataMapper.New();
mapper.SetInputConnection((vtkAlgorithmOutput)extrude.GetOutputPort());
mapper.SetNumberOfPieces((int)2);
mapper.SetPiece((int)1);
bf = new vtkProperty();
bf.SetColor((double)1,(double)0,(double)0);
actor = new vtkActor();
actor.SetMapper((vtkMapper)mapper);
actor.GetProperty().SetColor((double)1,(double)1,(double)0.8);
actor.SetBackfaceProperty((vtkProperty)bf);
// Add the actors to the renderer, set the background and size[]
//[]
ren1.AddActor((vtkProp)actor);
ren1.SetBackground((double)0.1,(double)0.2,(double)0.4);
renWin.SetSize((int)300,(int)300);
// render the image[]
//[]
cam1 = ren1.GetActiveCamera();
cam1.Azimuth((double)20);
cam1.Elevation((double)40);
ren1.ResetCamera();
cam1.Zoom((double)1.2);
iren.Initialize();
// prevent the tk window from showing up then start the event loop[]
//deleteAllVTKObjects();
}
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>
/// The main entry method called by the CSharp driver
/// </summary>
/// <param name="argv"></param>
public static void AVRectOutline(String [] argv)
{
//Prefix Content is: ""
// create pipeline[]
//[]
reader = new vtkDataSetReader();
reader.SetFileName((string)"" + (VTK_DATA_ROOT.ToString()) + "/Data/RectGrid2.vtk");
reader.Update();
// here to force exact extent[]
elev = new vtkElevationFilter();
elev.SetInputConnection((vtkAlgorithmOutput)reader.GetOutputPort());
outline = new vtkRectilinearGridOutlineFilter();
outline.SetInput((vtkDataObject)elev.GetRectilinearGridOutput());
outlineMapper = vtkPolyDataMapper.New();
outlineMapper.SetInputConnection((vtkAlgorithmOutput)outline.GetOutputPort());
outlineMapper.SetNumberOfPieces((int)2);
outlineMapper.SetPiece((int)1);
outlineActor = new vtkActor();
outlineActor.SetMapper((vtkMapper)outlineMapper);
outlineActor.GetProperty().SetColor((double) 0.0000, 0.0000, 0.0000 );
// Graphics stuff[]
// Create the RenderWindow, Renderer and both Actors[]
//[]
ren1 = vtkRenderer.New();
renWin = vtkRenderWindow.New();
renWin.AddRenderer((vtkRenderer)ren1);
iren = new vtkRenderWindowInteractor();
iren.SetRenderWindow((vtkRenderWindow)renWin);
// Add the actors to the renderer, set the background and size[]
//[]
ren1.AddActor((vtkProp)outlineActor);
ren1.SetBackground((double)1,(double)1,(double)1);
renWin.SetSize((int)400,(int)400);
cam1 = ren1.GetActiveCamera();
cam1.SetClippingRange((double)3.76213,(double)10.712);
cam1.SetFocalPoint((double)-0.0842503,(double)-0.136905,(double)0.610234);
cam1.SetPosition((double)2.53813,(double)2.2678,(double)-5.22172);
cam1.SetViewUp((double)-0.241047,(double)0.930635,(double)0.275343);
iren.Initialize();
// render the image[]
//[]
// prevent the tk window from showing up then start the event loop[]
//deleteAllVTKObjects();
}
/// <summary>
/// The main entry method called by the CSharp driver
/// </summary>
/// <param name="argv"></param>
public static void AVTestExtractVOI(String [] argv)
{
//Prefix Content is: ""
// to mark the origin[]
sphere = new vtkSphereSource();
sphere.SetRadius((double)2.0);
sphereMapper = vtkPolyDataMapper.New();
sphereMapper.SetInputConnection((vtkAlgorithmOutput)sphere.GetOutputPort());
sphereMapper.ImmediateModeRenderingOn();
sphereActor = new vtkActor();
sphereActor.SetMapper((vtkMapper)sphereMapper);
rt = new vtkRTAnalyticSource();
rt.SetWholeExtent((int)-50,(int)50,(int)-50,(int)50,(int)0,(int)0);
voi = new vtkExtractVOI();
voi.SetInputConnection((vtkAlgorithmOutput)rt.GetOutputPort());
voi.SetVOI((int)-11,(int)39,(int)5,(int)45,(int)0,(int)0);
voi.SetSampleRate((int)5,(int)5,(int)1);
// Get rid ambiguous triagulation issues.[]
surf = new vtkDataSetSurfaceFilter();
surf.SetInputConnection((vtkAlgorithmOutput)voi.GetOutputPort());
tris = new vtkTriangleFilter();
tris.SetInputConnection((vtkAlgorithmOutput)surf.GetOutputPort());
mapper = vtkPolyDataMapper.New();
mapper.SetInputConnection((vtkAlgorithmOutput)tris.GetOutputPort());
mapper.ImmediateModeRenderingOn();
mapper.SetScalarRange((double)130,(double)280);
actor = new vtkActor();
actor.SetMapper((vtkMapper)mapper);
ren = vtkRenderer.New();
ren.AddActor((vtkProp)actor);
ren.AddActor((vtkProp)sphereActor);
ren.ResetCamera();
camera = ren.GetActiveCamera();
//$camera SetPosition 68.1939 -23.4323 12.6465[]
//$camera SetViewUp 0.46563 0.882375 0.0678508 []
//$camera SetFocalPoint 3.65707 11.4552 1.83509 []
//$camera SetClippingRange 59.2626 101.825 []
renWin = vtkRenderWindow.New();
renWin.AddRenderer((vtkRenderer)ren);
iren = new vtkRenderWindowInteractor();
iren.SetRenderWindow((vtkRenderWindow)renWin);
iren.Initialize();
//deleteAllVTKObjects();
}
public void Render3D(string folder)
{
reader3D = vtkDICOMImageReader.New();
reader3D.SetDirectoryName(folder);
reader3D.Update();
renderer3D = vtkRenderer.New();
renderWindow3D = vtkRenderWindow.New();
renderWindowControl.Dock = DockStyle.Fill;
panel1.Controls.Add(renderWindowControl);
renderWindow3D = renderWindowControl.RenderWindow;
renderWindow3D.AddRenderer(renderer3D);
Coloring();
}
/// <summary>
/// The main entry method called by the CSharp driver
/// </summary>
/// <param name="argv"></param>
public static void AVTestUnstructuredPieces(String [] argv)
{
//Prefix Content is: ""
math = new vtkMath();
vtkMath.RandomSeed((int)22);
pf = new vtkParallelFactory();
vtkParallelFactory.RegisterFactory((vtkObjectFactory)pf);
pl3d = new vtkMultiBlockPLOT3DReader();
pl3d.SetXYZFileName((string)"" + (VTK_DATA_ROOT.ToString()) + "/Data/combxyz.bin");
pl3d.SetQFileName((string)"" + (VTK_DATA_ROOT.ToString()) + "/Data/combq.bin");
pl3d.SetScalarFunctionNumber((int)100);
dst = new vtkDataSetTriangleFilter();
dst.SetInputData((vtkDataSet)pl3d.GetOutput().GetBlock(0));
extract = new vtkExtractUnstructuredGridPiece();
extract.SetInputConnection((vtkAlgorithmOutput)dst.GetOutputPort());
cf = new vtkContourFilter();
cf.SetInputConnection((vtkAlgorithmOutput)extract.GetOutputPort());
cf.SetValue((int)0,(double)0.24);
pdn = new vtkPolyDataNormals();
pdn.SetInputConnection((vtkAlgorithmOutput)cf.GetOutputPort());
ps = new vtkPieceScalars();
ps.SetInputConnection((vtkAlgorithmOutput)pdn.GetOutputPort());
mapper = vtkPolyDataMapper.New();
mapper.SetInputConnection((vtkAlgorithmOutput)ps.GetOutputPort());
mapper.SetNumberOfPieces((int)3);
actor = new vtkActor();
actor.SetMapper((vtkMapper)mapper);
ren = vtkRenderer.New();
ren.AddActor((vtkProp)actor);
ren.ResetCamera();
camera = ren.GetActiveCamera();
//$camera SetPosition 68.1939 -23.4323 12.6465[]
//$camera SetViewUp 0.46563 0.882375 0.0678508 []
//$camera SetFocalPoint 3.65707 11.4552 1.83509 []
//$camera SetClippingRange 59.2626 101.825 []
renWin = vtkRenderWindow.New();
renWin.AddRenderer((vtkRenderer)ren);
iren = new vtkRenderWindowInteractor();
iren.SetRenderWindow((vtkRenderWindow)renWin);
iren.Initialize();
//deleteAllVTKObjects();
}
///<summary>Entry Point</summary>
static void Main(string[] args)
{
// Create a simple sphere. A pipeline is created.
sphere = vtkSphereSource.New();
sphere.SetThetaResolution(8);
sphere.SetPhiResolution(16);
shrink = vtkShrinkPolyData.New();
shrink.SetInputConnection(sphere.GetOutputPort());
shrink.SetShrinkFactor(0.9);
mapper = vtkPolyDataMapper.New();
mapper.SetInputConnection(shrink.GetOutputPort());
// The actor links the data pipeline to the rendering subsystem
actor = vtkActor.New();
actor.SetMapper(mapper);
actor.GetProperty().SetColor(1, 0, 0);
// Create components of the rendering subsystem
//
ren1 = vtkRenderer.New();
renWin = vtkRenderWindow.New();
renWin.AddRenderer(ren1);
iren = vtkRenderWindowInteractor.New();
iren.SetRenderWindow(renWin);
// Add the actors to the renderer, set the window size
//
ren1.AddViewProp(actor);
renWin.SetSize(250, 250);
renWin.Render();
camera = ren1.GetActiveCamera();
camera.Zoom(1.5);
// render the image and start the event loop
//
renWin.Render();
iren.Initialize();
iren.Start();
deleteAllVTKObjects();
}
public static void ShowPolydata(string airwayPath)
{
if (!File.Exists(airwayPath))
{
MessageBox.Show("文件不存在！");
return;
}
vtkRenderWindow renWin = vtkRenderWindow.New();
renWin.SetSize(600, 600);
vtkRenderWindowInteractor iren = new vtkRenderWindowInteractor();
renWin.SetInteractor(iren);
vtkInteractorStyleTrackballCamera interactorStyle = new vtkInteractorStyleTrackballCamera();
iren.SetInteractorStyle(interactorStyle);
vtkRenderer renderer = vtkRenderer.New();
renderer.GradientBackgroundOn();
renderer.SetBackground(0, 0, 0);
renderer.SetBackground2(0, 0, 1);
renWin.AddRenderer(renderer);
vtkXMLPolyDataReader reader = new vtkXMLPolyDataReader();
reader.SetFileName(airwayPath);
reader.Update();
vtkPolyDataMapper mapper = vtkPolyDataMapper.New();
mapper.ScalarVisibilityOff();
mapper.SetInput(reader.GetOutput());
reader.Dispose();
vtkActor actor = new vtkActor();
actor.SetMapper(mapper);
renderer.AddActor(actor);
renWin.Render();
}
/// <summary>
/// The main entry method called by the CSharp driver
/// </summary>
/// <param name="argv"></param>
public static void AVTestSpherePuzzle(String [] argv)
{
//Prefix Content is: ""
// prevent the tk window from showing up then start the event loop[]
renWin = vtkRenderWindow.New();
// create a rendering window and renderer[]
ren1 = vtkRenderer.New();
renWin.AddRenderer((vtkRenderer)ren1);
renWin.SetSize((int)400,(int)400);
puzzle = new vtkSpherePuzzle();
mapper = vtkPolyDataMapper.New();
mapper.SetInputConnection((vtkAlgorithmOutput)puzzle.GetOutputPort());
actor = new vtkActor();
actor.SetMapper((vtkMapper)mapper);
arrows = new vtkSpherePuzzleArrows();
mapper2 = vtkPolyDataMapper.New();
mapper2.SetInputConnection((vtkAlgorithmOutput)arrows.GetOutputPort());
actor2 = new vtkActor();
actor2.SetMapper((vtkMapper)mapper2);
// Add the actors to the renderer, set the background and size[]
//[]
ren1.AddActor((vtkProp)actor);
ren1.AddActor((vtkProp)actor2);
ren1.SetBackground((double)0.1,(double)0.2,(double)0.4);
LastVal = -1;
//method moved
//method moved
renWin.Render();
cam = ren1.GetActiveCamera();
cam.Elevation((double)-40);
puzzle.MoveHorizontal((int)0,(int)100,(int)0);
puzzle.MoveHorizontal((int)1,(int)100,(int)1);
puzzle.MoveHorizontal((int)2,(int)100,(int)0);
puzzle.MoveVertical((int)2,(int)100,(int)0);
puzzle.MoveVertical((int)1,(int)100,(int)0);
renWin.Render();
//deleteAllVTKObjects();
}
/// <summary>
///
/// <summary>
/// 用体绘制的方法绘制一系列的图像
/// </summary>
/// <param name="format">图像文件的字符串格式</param>
/// <param name="height">一幅图像的高度</param>
/// <param name="width">高度</param>
/// <param name="startIndex">起始index</param>
/// <param name="endIndex">末尾index</param>
/// <param name="r">renderer，如果非空，则将其体绘制结果添加到这里面来</param>
/// example:
/// CuteTools.ShowImageSeries(@"initial/%03d.bmp",64, 64, 0, 62);
public static void ShowImageSeries(string format, int height, int width, int startIndex, int endIndex, vtkRenderer r = null)
{
if (format == null || format.Count() <= 4 || (!format.Substring(format.Count() - 3, 3).Equals("bmp")))
{
Console.WriteLine("image filename is not correct!!");
return;
}
vtkBMPReader reader = vtkBMPReader.New();
reader.SetFilePattern(format);
reader.SetDataExtent(0, height - 1, 0, width - 1, startIndex, endIndex);
reader.SetDataScalarTypeToUnsignedChar();
reader.Update();
vtkVolume vol = vtkVolume.New();
vtkFixedPointVolumeRayCastMapper texMapper = vtkFixedPointVolumeRayCastMapper.New();
texMapper.SetInput(reader.GetOutput());
vol.SetMapper(texMapper);
vtkColorTransferFunction colorTransferFunction = vtkColorTransferFunction.New();
colorTransferFunction.AddRGBPoint(0.0, 0.0, 255.0, 0.0);
//colorTransferFunction.AddRGBPoint(120.0, 0.0, 0.0, 1.0);
//colorTransferFunction.AddRGBPoint(160.0, 1.0, 0.0, 0.0);
//colorTransferFunction.AddRGBPoint(200.0, 0.0, 1.0, 0.0);
colorTransferFunction.AddRGBPoint(255, 0, 0, 1.0);
colorTransferFunction.ClampingOn();
vtkVolumeProperty vpro = vtkVolumeProperty.New();
vtkPiecewiseFunction compositeOpacity = vtkPiecewiseFunction.New();
compositeOpacity.AddPoint(80, 1);
compositeOpacity.AddPoint(120, 0.2);
compositeOpacity.AddPoint(255, 0);
compositeOpacity.ClampingOn();
vpro.SetScalarOpacity(compositeOpacity);
//vpro.SetColor( colorTransferFunction );
vpro.SetInterpolationTypeToLinear();
//vpro.ShadeOn();
vol.SetProperty(vpro);
//画轴距图
vol.SetOrientation(45, 45, 0);
if (r != null)
{
r.AddVolume(vol);
}
else
{
vtkRenderer render = vtkRenderer.New();
render.AddVolume(vol);
render.SetBackground(1, 1, 1);
vtkRenderWindow wnd = vtkRenderWindow.New();
wnd.AddRenderer(render);
vtkRenderWindowInteractor inter = vtkRenderWindowInteractor.New();
inter.SetRenderWindow(wnd);
inter.Initialize();
inter.Start();
}
}
private void Subdivision(string filePath)
{
vtkPolyData originalMesh;
if (filePath != null)
{
vtkXMLPolyDataReader reader = vtkXMLPolyDataReader.New();
reader.SetFileName(filePath);
// Subdivision filters only work on triangles
vtkTriangleFilter triangles = vtkTriangleFilter.New();
triangles.SetInputConnection(reader.GetOutputPort());
triangles.Update();
originalMesh = triangles.GetOutput();
}
else
{
vtkSphereSource sphereSource = vtkSphereSource.New();
sphereSource.Update();
originalMesh = sphereSource.GetOutput();
}
Debug.WriteLine("Before subdivision");
Debug.WriteLine(" There are " + originalMesh.GetNumberOfPoints()
+ " points.");
Debug.WriteLine(" There are " + originalMesh.GetNumberOfPolys()
+ " triangles.");
int numberOfViewports = 3;
vtkRenderWindow renderWindow = renderWindowControl1.RenderWindow;
this.Size = new System.Drawing.Size(200 * numberOfViewports + 12, 252);
this.Text += " - Subdivision";
Random rnd = new Random(2);
int numberOfSubdivisions = 2;
// Create one text property for all
vtkTextProperty textProperty = vtkTextProperty.New();
textProperty.SetFontSize(14);
textProperty.SetJustificationToCentered();
for (int i = 0; i < numberOfViewports; i++)
{
// Note: Here we create a superclass pointer (vtkPolyDataAlgorithm) so that we can easily instantiate different
// types of subdivision filters. Typically you would not want to do this, but rather create the pointer to be the type
// filter you will actually use, e.g.
// <vtkLinearSubdivisionFilter> subdivisionFilter = <vtkLinearSubdivisionFilter>.New();
vtkPolyDataAlgorithm subdivisionFilter;
switch (i)
{
case 0:
subdivisionFilter = vtkLinearSubdivisionFilter.New();
((vtkLinearSubdivisionFilter)subdivisionFilter).SetNumberOfSubdivisions(numberOfSubdivisions);
break;
case 1:
subdivisionFilter = vtkLoopSubdivisionFilter.New();
((vtkLoopSubdivisionFilter)subdivisionFilter).SetNumberOfSubdivisions(numberOfSubdivisions);
break;
case 2:
subdivisionFilter = vtkButterflySubdivisionFilter.New();
((vtkButterflySubdivisionFilter)subdivisionFilter).SetNumberOfSubdivisions(numberOfSubdivisions);
break;
default:
subdivisionFilter = vtkLinearSubdivisionFilter.New();
((vtkLinearSubdivisionFilter)subdivisionFilter).SetNumberOfSubdivisions(numberOfSubdivisions);
break;
}
#if VTK_MAJOR_VERSION_5
subdivisionFilter.SetInputConnection(originalMesh.GetProducerPort());
#else
subdivisionFilter.SetInputData(originalMesh);
#endif
subdivisionFilter.Update();
vtkRenderer renderer = vtkRenderer.New();
renderWindow.AddRenderer(renderer);
renderer.SetViewport((float)i / numberOfViewports, 0, (float)(i + 1) / numberOfViewports, 1);
renderer.SetBackground(.2 + rnd.NextDouble() / 8, .3 + rnd.NextDouble() / 8, .4 + rnd.NextDouble() / 8);
vtkTextMapper textMapper = vtkTextMapper.New();
vtkActor2D textActor = vtkActor2D.New();
textMapper.SetInput(subdivisionFilter.GetClassName());
textMapper.SetTextProperty(textProperty);
textActor.SetMapper(textMapper);
textActor.SetPosition(100, 16);
//Create a mapper and actor
vtkPolyDataMapper mapper = vtkPolyDataMapper.New();
mapper.SetInputConnection(subdivisionFilter.GetOutputPort());
vtkActor actor = vtkActor.New();
actor.SetMapper(mapper);
renderer.AddActor(actor);
renderer.AddActor(textActor);
renderer.ResetCamera();
}
renderWindow.Render();
}
private void GeometricObjectsDemo()
{
// we create a matrix of 3x3 renderer in our renderwindow
// each renderer can be interacted with independently from one another
int rendererSize = 234; // width per renderer
int gridDimensions = 3;
this.Size = new System.Drawing.Size(756, 756);
Random rnd = new Random(2); // for background color variation
List <vtkPolyDataAlgorithm> geometricObjectSources = new List <vtkPolyDataAlgorithm>();
geometricObjectSources.Add(vtkArrowSource.New());
geometricObjectSources.Add(vtkConeSource.New());
geometricObjectSources.Add(vtkCubeSource.New());
geometricObjectSources.Add(vtkCylinderSource.New());
geometricObjectSources.Add(vtkDiskSource.New());
geometricObjectSources.Add(vtkLineSource.New());
geometricObjectSources.Add(vtkRegularPolygonSource.New());
geometricObjectSources.Add(vtkSphereSource.New());
geometricObjectSources.Add(vtkEarthSource.New());
List <vtkRenderer> renderers = new List <vtkRenderer>();
List <vtkPolyDataMapper> mappers = new List <vtkPolyDataMapper>();
List <vtkActor> actors = new List <vtkActor>();
List <vtkTextMapper> textMappers = new List <vtkTextMapper>();
List <vtkActor2D> textActors = new List <vtkActor2D>();
// Create one text property for all
vtkTextProperty textProperty = vtkTextProperty.New();
textProperty.SetFontSize(18);
textProperty.SetJustificationToCentered();
// Create a source, renderer, mapper, and actor
// for each object
for (int i = 0; i < geometricObjectSources.Count; i++)
{
geometricObjectSources[i].Update();
mappers.Add(vtkPolyDataMapper.New());
mappers[i].SetInputConnection(geometricObjectSources[i].GetOutputPort());
actors.Add(vtkActor.New());
actors[i].SetMapper(mappers[i]);
textMappers.Add(vtkTextMapper.New());
textMappers[i].SetInput(geometricObjectSources[i].GetClassName());
textMappers[i].SetTextProperty(textProperty);
textActors.Add(vtkActor2D.New());
textActors[i].SetMapper(textMappers[i]);
textActors[i].SetPosition(rendererSize / 2, 16);
renderers.Add(vtkRenderer.New());
}
// Need a renderer even if there is no actor
for (int i = geometricObjectSources.Count; i < gridDimensions * gridDimensions; i++)
{
renderers.Add(vtkRenderer.New());
}
vtkRenderWindow renderWindow = renderWindowControl1.RenderWindow;
renderWindow.SetSize(rendererSize * gridDimensions, rendererSize * gridDimensions);
for (int row = 0; row < gridDimensions; row++)
{
for (int col = 0; col < gridDimensions; col++)
{
int index = row * gridDimensions + col;
// (xmin, ymin, xmax, ymax)
double[] viewport = new double[] {
(col) * rendererSize / (double)(gridDimensions * rendererSize),
(gridDimensions - (row + 1)) * rendererSize / (double)(gridDimensions * rendererSize),
(col + 1) * rendererSize / (double)(gridDimensions * rendererSize),
(gridDimensions - row) * rendererSize / (double)(gridDimensions * rendererSize)
};
Debug.WriteLine(viewport[0] + " " + viewport[1] + " " + viewport[2] + " " + viewport[3]);
renderWindow.AddRenderer(renderers[index]);
IntPtr pViewport = Marshal.AllocHGlobal(Marshal.SizeOf(typeof(double)) * 4);
Marshal.Copy(viewport, 0, pViewport, 4);
renderers[index].SetViewport(pViewport);
Marshal.FreeHGlobal(pViewport);
if (index > geometricObjectSources.Count - 1)
{
continue;
}
renderers[index].AddActor(actors[index]);
renderers[index].AddActor(textActors[index]);
renderers[index].SetBackground(.2 + rnd.NextDouble() / 8, .3 + rnd.NextDouble() / 8, .4 + rnd.NextDouble() / 8);
}
}
}
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 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();
}
/// <summary>
/// The main entry method called by the CSharp driver
/// </summary>
/// <param name="argv"></param>
public static void AVfieldToPolyData(String [] argv)
{
//Prefix Content is: ""
// This example demonstrates the reading of a field and conversion to PolyData[]
// The output should be the same as polyEx.tcl.[]
// get the interactor ui[]
// Create a reader and write out the field[]
reader = new vtkPolyDataReader();
reader.SetFileName((string)"" + (VTK_DATA_ROOT.ToString()) + "/Data/polyEx.vtk");
ds2do = new vtkDataSetToDataObjectFilter();
ds2do.SetInputConnection((vtkAlgorithmOutput)reader.GetOutputPort());
try
{
channel = new StreamWriter("PolyField.vtk");
tryCatchError = "NOERROR";
}
catch(Exception)
{tryCatchError = "ERROR";}
if(tryCatchError.Equals("NOERROR"))
{
channel.Close();
writer = new vtkDataObjectWriter();
writer.SetInputConnection((vtkAlgorithmOutput)ds2do.GetOutputPort());
writer.SetFileName((string)"PolyField.vtk");
writer.Write();
// create pipeline[]
//[]
dor = new vtkDataObjectReader();
dor.SetFileName((string)"PolyField.vtk");
do2ds = new vtkDataObjectToDataSetFilter();
do2ds.SetInputConnection((vtkAlgorithmOutput)dor.GetOutputPort());
do2ds.SetDataSetTypeToPolyData();
do2ds.SetPointComponent((int)0,(string)"Points",(int)0);
do2ds.SetPointComponent((int)1,(string)"Points",(int)1);
do2ds.SetPointComponent((int)2,(string)"Points",(int)2);
do2ds.SetPolysComponent((string)"Polys",(int)0);
fd2ad = new vtkFieldDataToAttributeDataFilter();
fd2ad.SetInput((vtkDataObject)do2ds.GetPolyDataOutput());
fd2ad.SetInputFieldToDataObjectField();
fd2ad.SetOutputAttributeDataToPointData();
fd2ad.SetScalarComponent((int)0,(string)"my_scalars",(int)0);
mapper = vtkPolyDataMapper.New();
mapper.SetInput((vtkPolyData)fd2ad.GetPolyDataOutput());
mapper.SetScalarRange((double)((vtkDataSet)fd2ad.GetOutput()).GetScalarRange()[0],(double)((vtkDataSet)fd2ad.GetOutput()).GetScalarRange()[1]);
actor = new vtkActor();
actor.SetMapper((vtkMapper)mapper);
// Create the RenderWindow, Renderer and both Actors[]
ren1 = vtkRenderer.New();
renWin = vtkRenderWindow.New();
renWin.AddRenderer((vtkRenderer)ren1);
iren = new vtkRenderWindowInteractor();
iren.SetRenderWindow((vtkRenderWindow)renWin);
ren1.AddActor((vtkProp)actor);
ren1.SetBackground((double)1,(double)1,(double)1);
renWin.SetSize((int)300,(int)300);
ren1.ResetCamera();
cam1 = ren1.GetActiveCamera();
cam1.SetClippingRange((double).348,(double)17.43);
cam1.SetPosition((double)2.92,(double)2.62,(double)-0.836);
cam1.SetViewUp((double)-0.436,(double)-0.067,(double)-0.897);
cam1.Azimuth((double)90);
// render the image[]
//[]
renWin.Render();
File.Delete("PolyField.vtk");
}
// prevent the tk window from showing up then start the event loop[]
//deleteAllVTKObjects();
}
public static void ShowPolydata(string airwayPath, string lesionPath)
{
vtkAppendPolyData appendPolydata = new vtkAppendPolyData();
if (File.Exists(airwayPath))
{
vtkXMLPolyDataReader reader = new vtkXMLPolyDataReader();
reader.SetFileName(airwayPath);
reader.Update();
appendPolydata.AddInput(reader.GetOutput());
reader.Dispose();
}
else
{
MessageBox.Show("airwayPath : " + airwayPath + "文件不存在！");
}
if (File.Exists(lesionPath))
{
vtkXMLPolyDataReader reader = new vtkXMLPolyDataReader();
reader.SetFileName(lesionPath);
reader.Update();
appendPolydata.AddInput(reader.GetOutput());
reader.Dispose();
}
else
{
MessageBox.Show("lesionPath : " + lesionPath + "文件不存在！");
}
vtkRenderWindow renWin = vtkRenderWindow.New();
renWin.SetSize(600, 600);
vtkRenderWindowInteractor iren = new vtkRenderWindowInteractor();
renWin.SetInteractor(iren);
vtkInteractorStyleTrackballCamera interactorStyle = new vtkInteractorStyleTrackballCamera();
iren.SetInteractorStyle(interactorStyle);
vtkRenderer renderer = vtkRenderer.New();
renderer.GradientBackgroundOn();
renderer.SetBackground(0, 0, 0);
renderer.SetBackground2(0, 0, 1);
renWin.AddRenderer(renderer);
vtkPolyDataMapper mapper = vtkPolyDataMapper.New();
mapper.ScalarVisibilityOff();
mapper.SetInput(appendPolydata.GetOutput());
vtkActor actor = new vtkActor();
actor.SetMapper(mapper);
renderer.AddActor(actor);
renderer.Render();
renderer.ResetCamera();
renWin.Render();
//Thread thread = new Thread(new ThreadStart(
// delegate
// {
// iren.Start();
// }));
//thread.Start();
}
/// <summary>
/// The main entry method called by the CSharp driver
/// </summary>
/// <param name="argv"></param>
public static void AVExtractTensors(String [] argv)
{
//Prefix Content is: ""
// create tensor ellipsoids[]
// Create the RenderWindow, Renderer and interactive renderer[]
//[]
ren1 = vtkRenderer.New();
renWin = vtkRenderWindow.New();
renWin.AddRenderer((vtkRenderer)ren1);
iren = new vtkRenderWindowInteractor();
iren.SetRenderWindow((vtkRenderWindow)renWin);
ptLoad = new vtkPointLoad();
ptLoad.SetLoadValue((double)100.0);
ptLoad.SetSampleDimensions((int)30,(int)30,(int)30);
ptLoad.ComputeEffectiveStressOn();
ptLoad.SetModelBounds((double)-10,(double)10,(double)-10,(double)10,(double)-10,(double)10);
extractTensor = new vtkExtractTensorComponents();
extractTensor.SetInputConnection((vtkAlgorithmOutput)ptLoad.GetOutputPort());
extractTensor.ScalarIsEffectiveStress();
extractTensor.ScalarIsComponent();
extractTensor.ExtractScalarsOn();
extractTensor.ExtractVectorsOn();
extractTensor.ExtractNormalsOff();
extractTensor.ExtractTCoordsOn();
contour = new vtkContourFilter();
contour.SetInputConnection((vtkAlgorithmOutput)extractTensor.GetOutputPort());
contour.SetValue((int)0,(double)0);
probe = new vtkProbeFilter();
probe.SetInputConnection((vtkAlgorithmOutput)contour.GetOutputPort());
probe.SetSource((vtkDataObject)ptLoad.GetOutput());
su = new vtkLoopSubdivisionFilter();
su.SetInputConnection((vtkAlgorithmOutput)probe.GetOutputPort());
su.SetNumberOfSubdivisions((int)1);
s1Mapper = vtkPolyDataMapper.New();
s1Mapper.SetInputConnection((vtkAlgorithmOutput)probe.GetOutputPort());
// s1Mapper SetInputConnection [su GetOutputPort][]
s1Actor = new vtkActor();
s1Actor.SetMapper((vtkMapper)s1Mapper);
//[]
// plane for context[]
//[]
g = new vtkImageDataGeometryFilter();
g.SetInputConnection((vtkAlgorithmOutput)ptLoad.GetOutputPort());
g.SetExtent((int)0,(int)100,(int)0,(int)100,(int)0,(int)0);
g.Update();
//for scalar range[]
gm = vtkPolyDataMapper.New();
gm.SetInputConnection((vtkAlgorithmOutput)g.GetOutputPort());
gm.SetScalarRange((double)((vtkDataSet)g.GetOutput()).GetScalarRange()[0],(double)((vtkDataSet)g.GetOutput()).GetScalarRange()[1]);
ga = new vtkActor();
ga.SetMapper((vtkMapper)gm);
s1Mapper.SetScalarRange((double)((vtkDataSet)g.GetOutput()).GetScalarRange()[0],(double)((vtkDataSet)g.GetOutput()).GetScalarRange()[1]);
//[]
// Create outline around data[]
//[]
outline = new vtkOutlineFilter();
outline.SetInputConnection((vtkAlgorithmOutput)ptLoad.GetOutputPort());
outlineMapper = vtkPolyDataMapper.New();
outlineMapper.SetInputConnection((vtkAlgorithmOutput)outline.GetOutputPort());
outlineActor = new vtkActor();
outlineActor.SetMapper((vtkMapper)outlineMapper);
outlineActor.GetProperty().SetColor((double)0,(double)0,(double)0);
//[]
// Create cone indicating application of load[]
//[]
coneSrc = new vtkConeSource();
coneSrc.SetRadius((double).5);
coneSrc.SetHeight((double)2);
coneMap = vtkPolyDataMapper.New();
coneMap.SetInputConnection((vtkAlgorithmOutput)coneSrc.GetOutputPort());
coneActor = new vtkActor();
coneActor.SetMapper((vtkMapper)coneMap);
coneActor.SetPosition((double)0,(double)0,(double)11);
coneActor.RotateY((double)90);
coneActor.GetProperty().SetColor((double)1,(double)0,(double)0);
camera = new vtkCamera();
camera.SetFocalPoint((double)0.113766,(double)-1.13665,(double)-1.01919);
camera.SetPosition((double)-29.4886,(double)-63.1488,(double)26.5807);
camera.SetViewAngle((double)24.4617);
camera.SetViewUp((double)0.17138,(double)0.331163,(double)0.927879);
camera.SetClippingRange((double)1,(double)100);
ren1.AddActor((vtkProp)s1Actor);
ren1.AddActor((vtkProp)outlineActor);
ren1.AddActor((vtkProp)coneActor);
ren1.AddActor((vtkProp)ga);
ren1.SetBackground((double)1.0,(double)1.0,(double)1.0);
ren1.SetActiveCamera((vtkCamera)camera);
renWin.SetSize((int)300,(int)300);
renWin.Render();
// prevent the tk window from showing up then start the event loop[]
//deleteAllVTKObjects();
}
private void Triangulate()
{
vtkRegularPolygonSource polygonSource = vtkRegularPolygonSource.New();
polygonSource.Update();
vtkTriangleFilter triangleFilter = vtkTriangleFilter.New();
#if VTK_MAJOR_VERSION_5
triangleFilter.SetInputConnection(polygonSource.GetOutputPort());
#else
triangleFilter.SetInputData(polygonSource);
#endif
triangleFilter.Update();
vtkPolyDataMapper inputMapper = vtkPolyDataMapper.New();
#if VTK_MAJOR_VERSION_5
inputMapper.SetInputConnection(polygonSource.GetOutputPort());
#else
inputMapper.SetInputData(polygonSource);
#endif
vtkActor inputActor = vtkActor.New();
inputActor.SetMapper(inputMapper);
inputActor.GetProperty().SetRepresentationToWireframe();
vtkPolyDataMapper triangleMapper = vtkPolyDataMapper.New();
#if VTK_MAJOR_VERSION_5
triangleMapper.SetInputConnection(triangleFilter.GetOutputPort());
#else
triangleMapper.SetInputData(triangleFilter);
#endif
vtkActor triangleActor = vtkActor.New();
triangleActor.SetMapper(triangleMapper);
triangleActor.GetProperty().SetRepresentationToWireframe();
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(triangleActor);
leftRenderer.ResetCamera();
rightRenderer.ResetCamera();
renderWindow.Render();
}
/// <summary>
/// The main entry method called by the CSharp driver
/// </summary>
/// <param name="argv"></param>
public static void AVfieldToRGrid(String [] argv)
{
//Prefix Content is: ""
//# Generate a rectilinear grid from a field.[]
//#[]
// get the interactor ui[]
// Create a reader and write out the field[]
reader = new vtkDataSetReader();
reader.SetFileName((string)"" + (VTK_DATA_ROOT.ToString()) + "/Data/RectGrid2.vtk");
ds2do = new vtkDataSetToDataObjectFilter();
ds2do.SetInputConnection((vtkAlgorithmOutput)reader.GetOutputPort());
try
{
channel = new StreamWriter("RGridField.vtk");
tryCatchError = "NOERROR";
}
catch(Exception)
{tryCatchError = "ERROR";}
if(tryCatchError.Equals("NOERROR"))
{
channel.Close();
writer = new vtkDataObjectWriter();
writer.SetInputConnection((vtkAlgorithmOutput)ds2do.GetOutputPort());
writer.SetFileName((string)"RGridField.vtk");
writer.Write();
// Read the field[]
//[]
dor = new vtkDataObjectReader();
dor.SetFileName((string)"RGridField.vtk");
do2ds = new vtkDataObjectToDataSetFilter();
do2ds.SetInputConnection((vtkAlgorithmOutput)dor.GetOutputPort());
do2ds.SetDataSetTypeToRectilinearGrid();
do2ds.SetDimensionsComponent((string)"Dimensions",(int)0);
do2ds.SetPointComponent((int)0,(string)"XCoordinates",(int)0);
do2ds.SetPointComponent((int)1,(string)"YCoordinates",(int)0);
do2ds.SetPointComponent((int)2,(string)"ZCoordinates",(int)0);
fd2ad = new vtkFieldDataToAttributeDataFilter();
fd2ad.SetInput((vtkDataObject)do2ds.GetRectilinearGridOutput());
fd2ad.SetInputFieldToDataObjectField();
fd2ad.SetOutputAttributeDataToPointData();
fd2ad.SetVectorComponent((int)0,(string)"vectors",(int)0);
fd2ad.SetVectorComponent((int)1,(string)"vectors",(int)1);
fd2ad.SetVectorComponent((int)2,(string)"vectors",(int)2);
fd2ad.SetScalarComponent((int)0,(string)"scalars",(int)0);
fd2ad.Update();
// create pipeline[]
//[]
plane = new vtkRectilinearGridGeometryFilter();
plane.SetInput((vtkDataObject)fd2ad.GetRectilinearGridOutput());
plane.SetExtent((int)0,(int)100,(int)0,(int)100,(int)15,(int)15);
warper = new vtkWarpVector();
warper.SetInputConnection((vtkAlgorithmOutput)plane.GetOutputPort());
warper.SetScaleFactor((double)0.05);
planeMapper = new vtkDataSetMapper();
planeMapper.SetInputConnection((vtkAlgorithmOutput)warper.GetOutputPort());
planeMapper.SetScalarRange((double)0.197813,(double)0.710419);
planeActor = new vtkActor();
planeActor.SetMapper((vtkMapper)planeMapper);
cutPlane = new vtkPlane();
cutPlane.SetOrigin(fd2ad.GetOutput().GetCenter()[0],fd2ad.GetOutput().GetCenter()[1],fd2ad.GetOutput().GetCenter()[2]);
cutPlane.SetNormal((double)1,(double)0,(double)0);
planeCut = new vtkCutter();
planeCut.SetInput((vtkDataObject)fd2ad.GetRectilinearGridOutput());
planeCut.SetCutFunction((vtkImplicitFunction)cutPlane);
cutMapper = new vtkDataSetMapper();
cutMapper.SetInputConnection((vtkAlgorithmOutput)planeCut.GetOutputPort());
cutMapper.SetScalarRange(
(double)((vtkDataSet)fd2ad.GetOutput()).GetPointData().GetScalars().GetRange()[0],
(double)((vtkDataSet)fd2ad.GetOutput()).GetPointData().GetScalars().GetRange()[1]);
cutActor = new vtkActor();
cutActor.SetMapper((vtkMapper)cutMapper);
iso = new vtkContourFilter();
iso.SetInput((vtkDataObject)fd2ad.GetRectilinearGridOutput());
iso.SetValue((int)0,(double)0.7);
normals = new vtkPolyDataNormals();
normals.SetInputConnection((vtkAlgorithmOutput)iso.GetOutputPort());
normals.SetFeatureAngle((double)45);
isoMapper = vtkPolyDataMapper.New();
isoMapper.SetInputConnection((vtkAlgorithmOutput)normals.GetOutputPort());
isoMapper.ScalarVisibilityOff();
isoActor = new vtkActor();
isoActor.SetMapper((vtkMapper)isoMapper);
isoActor.GetProperty().SetColor((double) 1.0000, 0.8941, 0.7686 );
isoActor.GetProperty().SetRepresentationToWireframe();
streamer = new vtkStreamLine();
streamer.SetInputConnection((vtkAlgorithmOutput)fd2ad.GetOutputPort());
streamer.SetStartPosition((double)-1.2,(double)-0.1,(double)1.3);
streamer.SetMaximumPropagationTime((double)500);
streamer.SetStepLength((double)0.05);
streamer.SetIntegrationStepLength((double)0.05);
streamer.SetIntegrationDirectionToIntegrateBothDirections();
streamTube = new vtkTubeFilter();
streamTube.SetInputConnection((vtkAlgorithmOutput)streamer.GetOutputPort());
streamTube.SetRadius((double)0.025);
streamTube.SetNumberOfSides((int)6);
streamTube.SetVaryRadiusToVaryRadiusByVector();
mapStreamTube = vtkPolyDataMapper.New();
mapStreamTube.SetInputConnection((vtkAlgorithmOutput)streamTube.GetOutputPort());
mapStreamTube.SetScalarRange(
(double)((vtkDataSet)fd2ad.GetOutput()).GetPointData().GetScalars().GetRange()[0],
(double)((vtkDataSet)fd2ad.GetOutput()).GetPointData().GetScalars().GetRange()[1]);
streamTubeActor = new vtkActor();
streamTubeActor.SetMapper((vtkMapper)mapStreamTube);
streamTubeActor.GetProperty().BackfaceCullingOn();
outline = new vtkOutlineFilter();
outline.SetInput((vtkDataObject)fd2ad.GetRectilinearGridOutput());
outlineMapper = vtkPolyDataMapper.New();
outlineMapper.SetInputConnection((vtkAlgorithmOutput)outline.GetOutputPort());
outlineActor = new vtkActor();
outlineActor.SetMapper((vtkMapper)outlineMapper);
outlineActor.GetProperty().SetColor((double) 0.0000, 0.0000, 0.0000 );
// Graphics stuff[]
// Create the RenderWindow, Renderer and both Actors[]
//[]
ren1 = vtkRenderer.New();
renWin = vtkRenderWindow.New();
renWin.AddRenderer((vtkRenderer)ren1);
iren = new vtkRenderWindowInteractor();
iren.SetRenderWindow((vtkRenderWindow)renWin);
// Add the actors to the renderer, set the background and size[]
//[]
ren1.AddActor((vtkProp)outlineActor);
ren1.AddActor((vtkProp)planeActor);
ren1.AddActor((vtkProp)cutActor);
ren1.AddActor((vtkProp)isoActor);
ren1.AddActor((vtkProp)streamTubeActor);
ren1.SetBackground((double)1,(double)1,(double)1);
renWin.SetSize((int)300,(int)300);
ren1.GetActiveCamera().SetPosition((double)0.0390893,(double)0.184813,(double)-3.94026);
ren1.GetActiveCamera().SetFocalPoint((double)-0.00578326,(double)0,(double)0.701967);
ren1.GetActiveCamera().SetViewAngle((double)30);
ren1.GetActiveCamera().SetViewUp((double)0.00850257,(double)0.999169,(double)0.0398605);
ren1.GetActiveCamera().SetClippingRange((double)3.08127,(double)6.62716);
iren.Initialize();
// render the image[]
//[]
File.Delete("RGridField.vtk");
}
// prevent the tk window from showing up then start the event loop[]
//deleteAllVTKObjects();
}
/// <summary>
/// The main entry method called by the CSharp driver
/// </summary>
/// <param name="argv"></param>
public static void AVtextureThreshold(String [] argv)
{
//Prefix Content is: ""
// Create the RenderWindow, Renderer and both Actors[]
//[]
ren1 = vtkRenderer.New();
renWin = vtkRenderWindow.New();
renWin.AddRenderer((vtkRenderer)ren1);
iren = new vtkRenderWindowInteractor();
iren.SetRenderWindow((vtkRenderWindow)renWin);
// read data[]
//[]
pl3d = new vtkMultiBlockPLOT3DReader();
pl3d.SetXYZFileName((string)"" + (VTK_DATA_ROOT.ToString()) + "/Data/bluntfinxyz.bin");
pl3d.SetQFileName((string)"" + (VTK_DATA_ROOT.ToString()) + "/Data/bluntfinq.bin");
pl3d.SetScalarFunctionNumber((int)100);
pl3d.SetVectorFunctionNumber((int)202);
pl3d.Update();
// wall[]
//[]
wall = new vtkStructuredGridGeometryFilter();
wall.SetInputData(pl3d.GetOutput().GetBlock(0));
wall.SetExtent((int)0,(int)100,(int)0,(int)0,(int)0,(int)100);
wallMap = vtkPolyDataMapper.New();
wallMap.SetInputConnection((vtkAlgorithmOutput)wall.GetOutputPort());
wallMap.ScalarVisibilityOff();
wallActor = new vtkActor();
wallActor.SetMapper((vtkMapper)wallMap);
wallActor.GetProperty().SetColor((double)0.8,(double)0.8,(double)0.8);
// fin[]
// []
fin = new vtkStructuredGridGeometryFilter();
fin.SetInputData(pl3d.GetOutput().GetBlock(0));
fin.SetExtent((int)0,(int)100,(int)0,(int)100,(int)0,(int)0);
finMap = vtkPolyDataMapper.New();
finMap.SetInputConnection((vtkAlgorithmOutput)fin.GetOutputPort());
finMap.ScalarVisibilityOff();
finActor = new vtkActor();
finActor.SetMapper((vtkMapper)finMap);
finActor.GetProperty().SetColor((double)0.8,(double)0.8,(double)0.8);
// planes to threshold[]
tmap = new vtkStructuredPointsReader();
tmap.SetFileName((string)"" + (VTK_DATA_ROOT.ToString()) + "/Data/texThres2.vtk");
texture = new vtkTexture();
texture.SetInputConnection((vtkAlgorithmOutput)tmap.GetOutputPort());
texture.InterpolateOff();
texture.RepeatOff();
plane1 = new vtkStructuredGridGeometryFilter();
plane1.SetInputData(pl3d.GetOutput().GetBlock(0));
plane1.SetExtent((int)10,(int)10,(int)0,(int)100,(int)0,(int)100);
thresh1 = new vtkThresholdTextureCoords();
thresh1.SetInputConnection((vtkAlgorithmOutput)plane1.GetOutputPort());
thresh1.ThresholdByUpper((double)1.5);
plane1Map = new vtkDataSetMapper();
plane1Map.SetInputConnection((vtkAlgorithmOutput)thresh1.GetOutputPort());
plane1Map.SetScalarRange((double)((vtkDataSet)pl3d.GetOutput().GetBlock(0)).GetScalarRange()[0],
(double)((vtkDataSet)pl3d.GetOutput().GetBlock(0)).GetScalarRange()[1]);
plane1Actor = new vtkActor();
plane1Actor.SetMapper((vtkMapper)plane1Map);
plane1Actor.SetTexture((vtkTexture)texture);
plane1Actor.GetProperty().SetOpacity((double)0.999);
plane2 = new vtkStructuredGridGeometryFilter();
plane2.SetInputData(pl3d.GetOutput().GetBlock(0));
plane2.SetExtent((int)30,(int)30,(int)0,(int)100,(int)0,(int)100);
thresh2 = new vtkThresholdTextureCoords();
thresh2.SetInputConnection((vtkAlgorithmOutput)plane2.GetOutputPort());
thresh2.ThresholdByLower((double)1.5);
plane2Map = new vtkDataSetMapper();
plane2Map.SetInputConnection((vtkAlgorithmOutput)thresh2.GetOutputPort());
plane2Map.SetScalarRange((double)((vtkDataSet)pl3d.GetOutput().GetBlock(0)).GetScalarRange()[0],
(double)((vtkDataSet)pl3d.GetOutput().GetBlock(0)).GetScalarRange()[1]);
plane2Actor = new vtkActor();
plane2Actor.SetMapper((vtkMapper)plane2Map);
plane2Actor.SetTexture((vtkTexture)texture);
plane2Actor.GetProperty().SetOpacity((double)0.999);
plane3 = new vtkStructuredGridGeometryFilter();
plane3.SetInputData(pl3d.GetOutput().GetBlock(0));
plane3.SetExtent((int)35,(int)35,(int)0,(int)100,(int)0,(int)100);
thresh3 = new vtkThresholdTextureCoords();
thresh3.SetInputConnection((vtkAlgorithmOutput)plane3.GetOutputPort());
thresh3.ThresholdBetween((double)1.5,(double)1.8);
plane3Map = new vtkDataSetMapper();
plane3Map.SetInputConnection((vtkAlgorithmOutput)thresh3.GetOutputPort());
plane3Map.SetScalarRange((double)((vtkDataSet)pl3d.GetOutput().GetBlock(0)).GetScalarRange()[0],
(double)((vtkDataSet)pl3d.GetOutput().GetBlock(0)).GetScalarRange()[1]);
plane3Actor = new vtkActor();
plane3Actor.SetMapper((vtkMapper)plane3Map);
plane3Actor.SetTexture((vtkTexture)texture);
plane3Actor.GetProperty().SetOpacity((double)0.999);
// outline[]
outline = new vtkStructuredGridOutlineFilter();
outline.SetInputData(pl3d.GetOutput().GetBlock(0));
outlineMapper = vtkPolyDataMapper.New();
outlineMapper.SetInputConnection((vtkAlgorithmOutput)outline.GetOutputPort());
outlineActor = new vtkActor();
outlineActor.SetMapper((vtkMapper)outlineMapper);
outlineProp = outlineActor.GetProperty();
outlineProp.SetColor((double)0,(double)0,(double)0);
// Add the actors to the renderer, set the background and size[]
//[]
ren1.AddActor((vtkProp)outlineActor);
ren1.AddActor((vtkProp)wallActor);
ren1.AddActor((vtkProp)finActor);
ren1.AddActor((vtkProp)plane1Actor);
ren1.AddActor((vtkProp)plane2Actor);
ren1.AddActor((vtkProp)plane3Actor);
ren1.SetBackground((double)1,(double)1,(double)1);
renWin.SetSize((int)256,(int)256);
cam1 = new vtkCamera();
cam1.SetClippingRange((double)1.51176,(double)75.5879);
cam1.SetFocalPoint((double)2.33749,(double)2.96739,(double)3.61023);
cam1.SetPosition((double)10.8787,(double)5.27346,(double)15.8687);
cam1.SetViewAngle((double)30);
cam1.SetViewUp((double)-0.0610856,(double)0.987798,(double)-0.143262);
ren1.SetActiveCamera((vtkCamera)cam1);
iren.Initialize();
// render the image[]
//[]
// prevent the tk window from showing up then start the event loop[]
//deleteAllVTKObjects();
}
static void ReadSupport(string Spath)
{
vtkJPEGReader reader = vtkJPEGReader.New();
reader.SetFileName(Spath);
reader.Update();
// Visualize
_ImageViewer = vtkImageViewer2.New();
_ImageViewer.SetInputConnection(reader.GetOutputPort());
_SliceStatusMapper = vtkTextMapper.New();
_SliceStatusMapper.SetInputConnection(reader.GetOutputPort());
vtkActor2D sliceStatusActor = vtkActor2D.New();
sliceStatusActor.SetMapper(_SliceStatusMapper);
vtkRenderWindow renderWindow = vtkRenderWindow.New();
//Display in full screen
renderWindow.SetFullScreen(1);
vtkInteractorStyleImage interactorStyle = vtkInteractorStyleImage.New();
renderWindow.GetRenderers().InitTraversal();
vtkRenderer ren;
while ((ren = renderWindow.GetRenderers().GetNextItem()) != null)
{
renderWindow.AddRenderer(ren);
}
_ImageViewer.SetRenderWindow(renderWindow);
_ImageViewer.GetRenderer().AddActor2D(sliceStatusActor);
_ImageViewer.SetSlice(_SupportSlice);
iren = vtkRenderWindowInteractor.New();
iren.SetRenderWindow(renderWindow);
renderWindow.Render();
_ColorLevel = 60;
_ImageViewer.SetColorLevel(_BlackLevel);
_ImageViewer.Render();
Down(_period, 170);
Backward(_period, 1);
for (int i = 0; i < _SupportLayers; i++)
{
System.Threading.Thread.Sleep(_layertime); // delay
Backward(_period, 1);
}
_ImageViewer.SetColorLevel(_BlackLevel);
_ImageViewer.Render();
Forward(_period, _MovedLayers);
Console.WriteLine(_MovedLayers);
if (reader != null)
{
reader.Dispose();
}
if (_ImageViewer != null)
{
_ImageViewer.Dispose();
}
if (_SliceStatusMapper != null)
{
_SliceStatusMapper.Dispose();
}
if (sliceStatusActor != null)
{
sliceStatusActor.Dispose();
}
if (renderWindow != null)
{
renderWindow.Dispose();
}
if (interactorStyle != null)
{
interactorStyle.Dispose();
}
if (ren != null)
{
ren.Dispose();
}
if (iren != null)
{
iren.Dispose();
}
}
static void PrintImage(string Ipath)
{
vtkDICOMImageReader reader = vtkDICOMImageReader.New();
reader.SetDirectoryName(Ipath);
reader.Update();
X = reader.GetWidth();
Y = reader.GetHeight();
Z = reader.GetPixelSpacing();
Console.WriteLine(X * Z[0]);
Console.WriteLine(Y * Z[1]);
Console.WriteLine(Z[2]);
// Visualize
_ImageViewer = vtkImageViewer2.New();
_ImageViewer.SetInputConnection(reader.GetOutputPort());
// Get range of slices (min is the first index, max is the last index)
_ImageViewer.GetSliceRange(ref _MinSlice, ref _MaxSlice);
Console.WriteLine(_MinSlice);
Console.WriteLine(_MaxSlice);
_SliceStatusMapper = vtkTextMapper.New();
_SliceStatusMapper.SetInputConnection(reader.GetOutputPort());
vtkActor2D sliceStatusActor = vtkActor2D.New();
sliceStatusActor.SetMapper(_SliceStatusMapper);
vtkRenderWindow renderWindow = vtkRenderWindow.New();
//Display in full screen
renderWindow.SetFullScreen(1);
vtkInteractorStyleImage interactorStyle = vtkInteractorStyleImage.New();
renderWindow.GetRenderers().InitTraversal();
vtkRenderer ren;
while ((ren = renderWindow.GetRenderers().GetNextItem()) != null)
{
renderWindow.AddRenderer(ren);
}
_ImageViewer.SetRenderWindow(renderWindow);
_ImageViewer.GetRenderer().AddActor2D(sliceStatusActor);
_ImageViewer.SetSlice(_Slice);
_ColorLevel = 500;
_ImageViewer.SetColorLevel(_BlackLevel);
_ImageViewer.Render();
Down(_period, 62);
Backward(_period, 1);
_ImageViewer.SetColorLevel(_ColorLevel);
_ImageViewer.Render();
System.Threading.Thread.Sleep(_layertime); // delay
iren = vtkRenderWindowInteractor.New();
iren.SetRenderWindow(renderWindow);
renderWindow.Render();
//Start Timer
InitTimer();
iren.Start();
if (reader != null)
{
reader.Dispose();
}
if (_ImageViewer != null)
{
_ImageViewer.Dispose();
}
if (_SliceStatusMapper != null)
{
_SliceStatusMapper.Dispose();
}
if (sliceStatusActor != null)
{
sliceStatusActor.Dispose();
}
if (renderWindow != null)
{
renderWindow.Dispose();
}
if (interactorStyle != null)
{
interactorStyle.Dispose();
}
if (ren != null)
{
ren.Dispose();
}
if (iren != null)
{
iren.Dispose();
}
}
/// <summary>
/// The main entry method called by the CSharp driver
/// </summary>
/// <param name="argv"></param>
public static void AVpolyConn(String [] argv)
{
//Prefix Content is: ""
// Create the RenderWindow, Renderer and both Actors[]
//[]
ren1 = vtkRenderer.New();
renWin = vtkRenderWindow.New();
renWin.AddRenderer((vtkRenderer)ren1);
iren = new vtkRenderWindowInteractor();
iren.SetRenderWindow((vtkRenderWindow)renWin);
// read data[]
//[]
pl3d = new vtkMultiBlockPLOT3DReader();
pl3d.SetXYZFileName((string)"" + (VTK_DATA_ROOT.ToString()) + "/Data/combxyz.bin");
pl3d.SetQFileName((string)"" + (VTK_DATA_ROOT.ToString()) + "/Data/combq.bin");
pl3d.SetScalarFunctionNumber((int)100);
pl3d.SetVectorFunctionNumber((int)202);
pl3d.Update();
// planes to connect[]
plane1 = new vtkStructuredGridGeometryFilter();
plane1.SetInputData((vtkDataSet)pl3d.GetOutput().GetBlock(0));
plane1.SetExtent((int)20,(int)20,(int)0,(int)100,(int)0,(int)100);
conn = new vtkPolyDataConnectivityFilter();
conn.SetInputConnection((vtkAlgorithmOutput)plane1.GetOutputPort());
conn.ScalarConnectivityOn();
conn.SetScalarRange((double)0.19,(double)0.25);
plane1Map = vtkPolyDataMapper.New();
plane1Map.SetInputConnection((vtkAlgorithmOutput)conn.GetOutputPort());
plane1Map.SetScalarRange((double)((vtkDataSet)pl3d.GetOutput().GetBlock(0)).GetScalarRange()[0],
(double)((vtkDataSet)pl3d.GetOutput().GetBlock(0)).GetScalarRange()[1]);
plane1Actor = new vtkActor();
plane1Actor.SetMapper((vtkMapper)plane1Map);
plane1Actor.GetProperty().SetOpacity((double)0.999);
// outline[]
outline = new vtkStructuredGridOutlineFilter();
outline.SetInputData((vtkDataSet)pl3d.GetOutput().GetBlock(0));
outlineMapper = vtkPolyDataMapper.New();
outlineMapper.SetInputConnection((vtkAlgorithmOutput)outline.GetOutputPort());
outlineActor = new vtkActor();
outlineActor.SetMapper((vtkMapper)outlineMapper);
outlineProp = outlineActor.GetProperty();
outlineProp.SetColor((double)0,(double)0,(double)0);
// Add the actors to the renderer, set the background and size[]
//[]
ren1.AddActor((vtkProp)outlineActor);
ren1.AddActor((vtkProp)plane1Actor);
ren1.SetBackground((double)1,(double)1,(double)1);
renWin.SetSize((int)300,(int)300);
cam1 = new vtkCamera();
cam1.SetClippingRange((double)14.29,(double)63.53);
cam1.SetFocalPoint((double)8.58522,(double)1.58266,(double)30.6486);
cam1.SetPosition((double)37.6808,(double)-20.1298,(double)35.4016);
cam1.SetViewAngle((double)30);
cam1.SetViewUp((double)-0.0566235,(double)0.140504,(double)0.98846);
ren1.SetActiveCamera((vtkCamera)cam1);
iren.Initialize();
// render the image[]
//[]
// prevent the tk window from showing up then start the event loop[]
//deleteAllVTKObjects();
}
/// <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();
}
/// <summary>
/// An example that does not use a Windows Form
/// </summary>
/// <param name="argv"></param>
public static void Main(String[] argv)
{
// This example demonstrates the use of vtkCubeAxesActor2D to indicate the
// position in space that the camera is currently viewing.
// The vtkCubeAxesActor2D draws axes on the bounding box of the data set and
// labels the axes with x-y-z coordinates.
//
// First we include the VTK Tcl packages which will make available
// all of the vtk commands to Tcl
//
// Create a vtkBYUReader and read in a data set.
//
fohe = vtkBYUReader.New();
fohe.SetGeometryFileName("../../../teapot.g");
// Create a vtkPolyDataNormals filter to calculate the normals of the data set.
normals = vtkPolyDataNormals.New();
normals.SetInputConnection(fohe.GetOutputPort());
// Set up the associated mapper and actor.
foheMapper = vtkPolyDataMapper.New();
foheMapper.SetInputConnection(normals.GetOutputPort());
foheActor = vtkLODActor.New();
foheActor.SetMapper(foheMapper);
// Create a vtkOutlineFilter to draw the bounding box of the data set. Also
// create the associated mapper and actor.
outline = vtkOutlineFilter.New();
outline.SetInputConnection(normals.GetOutputPort());
mapOutline = vtkPolyDataMapper.New();
mapOutline.SetInputConnection(outline.GetOutputPort());
outlineActor = vtkActor.New();
outlineActor.SetMapper(mapOutline);
outlineActor.GetProperty().SetColor(0, 0, 0);
// Create a vtkCamera, and set the camera parameters.
camera = vtkCamera.New();
camera.SetClippingRange(1.60187, 20.0842);
camera.SetFocalPoint(0.21406, 1.5, 0);
camera.SetPosition(8.3761, 4.94858, 4.12505);
camera.SetViewUp(0.180325, 0.549245, -0.815974);
// Create a vtkLight, and set the light parameters.
light = vtkLight.New();
light.SetFocalPoint(0.21406, 1.5, 0);
light.SetPosition(8.3761, 4.94858, 4.12505);
// Create the Renderers. Assign them the appropriate viewport coordinates,
// active camera, and light.
ren1 = vtkRenderer.New();
ren1.SetViewport(0, 0, 0.5, 1.0);
ren1.SetActiveCamera(camera);
ren1.AddLight(light);
ren2 = vtkRenderer.New();
ren2.SetViewport(0.5, 0, 1.0, 1.0);
ren2.SetActiveCamera(camera);
ren2.AddLight(light);
// Create the RenderWindow and RenderWindowInteractor.
renWin = vtkRenderWindow.New();
renWin.AddRenderer(ren1);
renWin.AddRenderer(ren2);
renWin.SetWindowName("VTK - Cube Axes");
renWin.SetSize(600, 300);
iren = vtkRenderWindowInteractor.New();
iren.SetRenderWindow(renWin);
// Add the actors to the renderer, and set the background.
ren1.AddViewProp(foheActor);
ren1.AddViewProp(outlineActor);
ren2.AddViewProp(foheActor);
ren2.AddViewProp(outlineActor);
ren1.SetBackground(0.1, 0.2, 0.4);
ren2.SetBackground(0.1, 0.2, 0.4);
// Create a text property for both cube axes
tprop = vtkTextProperty.New();
tprop.SetColor(1, 1, 1);
tprop.ShadowOn();
// Create a vtkCubeAxesActor2D. Use the outer edges of the bounding box to
// draw the axes. Add the actor to the renderer.
axes = vtkCubeAxesActor2D.New();
axes.SetInput(normals.GetOutput());
axes.SetCamera(ren1.GetActiveCamera());
axes.SetLabelFormat("%6.4g");
axes.SetFlyModeToOuterEdges();
axes.SetFontFactor(0.8);
axes.SetAxisTitleTextProperty(tprop);
axes.SetAxisLabelTextProperty(tprop);
ren1.AddViewProp(axes);
// Create a vtkCubeAxesActor2D. Use the closest vertex to the camera to
// determine where to draw the axes. Add the actor to the renderer.
axes2 = vtkCubeAxesActor2D.New();
axes2.SetViewProp(foheActor);
axes2.SetCamera(ren2.GetActiveCamera());
axes2.SetLabelFormat("%6.4g");
axes2.SetFlyModeToClosestTriad();
axes2.SetFontFactor(0.8);
axes2.ScalingOff();
axes2.SetAxisTitleTextProperty(tprop);
axes2.SetAxisLabelTextProperty(tprop);
ren2.AddViewProp(axes2);
// Render
renWin.Render();
// Set the user method (bound to key 'u')
iren.Initialize();
iren.Start();
// Set up a check for aborting rendering.
renWin.AbortCheckEvt += new vtkObject.vtkObjectEventHandler(TkCheckAbort);
//Clean Up
deleteAllVTKObjects();
}
/// <summary>
/// The main entry method called by the CSharp driver
/// </summary>
/// <param name="argv"></param>
public static void AVlabeledContours(String [] argv)
{
//Prefix Content is: ""
// demonstrate labeling of contour with scalar value[]
// Create the RenderWindow, Renderer and both Actors[]
//[]
ren1 = vtkRenderer.New();
renWin = vtkRenderWindow.New();
renWin.SetMultiSamples(0);
renWin.AddRenderer((vtkRenderer)ren1);
iren = new vtkRenderWindowInteractor();
iren.SetRenderWindow((vtkRenderWindow)renWin);
// Read a slice and contour it[]
v16 = new vtkVolume16Reader();
v16.SetDataDimensions((int)64,(int)64);
v16.GetOutput().SetOrigin((double)0.0,(double)0.0,(double)0.0);
v16.SetDataByteOrderToLittleEndian();
v16.SetFilePrefix((string)"" + (VTK_DATA_ROOT.ToString()) + "/Data/headsq/quarter");
v16.SetImageRange((int)45,(int)45);
v16.SetDataSpacing((double)3.2,(double)3.2,(double)1.5);
iso = new vtkContourFilter();
iso.SetInputConnection((vtkAlgorithmOutput)v16.GetOutputPort());
iso.GenerateValues((int)6,(double)500,(double)1150);
iso.Update();
numPts = iso.GetOutput().GetNumberOfPoints();
isoMapper = vtkPolyDataMapper.New();
isoMapper.SetInputConnection((vtkAlgorithmOutput)iso.GetOutputPort());
isoMapper.ScalarVisibilityOn();
isoMapper.SetScalarRange((double)((vtkDataSet)iso.GetOutput()).GetScalarRange()[0],(double)((vtkDataSet)iso.GetOutput()).GetScalarRange()[1]);
isoActor = new vtkActor();
isoActor.SetMapper((vtkMapper)isoMapper);
// Subsample the points and label them[]
mask = new vtkMaskPoints();
mask.SetInputConnection((vtkAlgorithmOutput)iso.GetOutputPort());
mask.SetOnRatio((int)(numPts/50));
mask.SetMaximumNumberOfPoints((int)50);
mask.RandomModeOn();
// Create labels for points - only show visible points[]
visPts = new vtkSelectVisiblePoints();
visPts.SetInputConnection((vtkAlgorithmOutput)mask.GetOutputPort());
visPts.SetRenderer((vtkRenderer)ren1);
ldm = new vtkLabeledDataMapper();
ldm.SetInputConnection((vtkAlgorithmOutput)mask.GetOutputPort());
// ldm SetLabelFormat "%g"[]
ldm.SetLabelModeToLabelScalars();
tprop = ldm.GetLabelTextProperty();
tprop.SetFontFamilyToArial();
tprop.SetFontSize((int)10);
tprop.SetColor((double)1,(double)0,(double)0);
contourLabels = new vtkActor2D();
contourLabels.SetMapper((vtkMapper2D)ldm);
// Add the actors to the renderer, set the background and size[]
//[]
ren1.AddActor2D((vtkProp)isoActor);
ren1.AddActor2D((vtkProp)contourLabels);
ren1.SetBackground((double)1,(double)1,(double)1);
renWin.SetSize((int)500,(int)500);
renWin.Render();
ren1.GetActiveCamera().Zoom((double)1.5);
// render the image[]
//[]
// prevent the tk window from showing up then start the event loop[]
//deleteAllVTKObjects();
}
public static int Main(string[] args)
{
vtkTesting testHelper = vtkTesting.New();
for (int cc = 0; cc < args.Length; cc++)
{
//testHelper.AddArguments(argc,const_cast<const char **>(argv));
//System.Console.Write( "args: " + args[cc] + "\n" );
testHelper.AddArgument(args[cc]);
}
if (testHelper.IsFlagSpecified("-D") != 0)
{
string VTK_DATA_ROOT = vtkGDCMTesting.GetVTKDataRoot();
if (VTK_DATA_ROOT != null)
{
//System.Console.Write( "VTK_DATA_ROOT: " + VTK_DATA_ROOT + "\n" );
testHelper.SetDataRoot(VTK_DATA_ROOT);
testHelper.AddArgument("-D");
testHelper.AddArgument(VTK_DATA_ROOT);
}
}
string dataRoot = testHelper.GetDataRoot();
string filename = dataRoot;
filename += "/Data/mr.001";
vtkDirectory dir = vtkDirectory.New();
if (dir.FileIsDirectory(dataRoot) == 0)
{
filename = vtkGDCMTesting.GetGDCMDataRoot() + "/test.acr";
}
//System.Console.Write( "dataRoot: " + dataRoot + "\n" );
System.Console.Write("filename being used is: " + filename + "\n");
vtkGDCMImageReader reader = vtkGDCMImageReader.New();
vtkStringArray array = vtkStringArray.New();
array.InsertNextValue(filename);
reader.SetFileNames(array);
reader.Update();
System.Console.Write(reader.GetOutput());
vtkRenderWindowInteractor iren = vtkRenderWindowInteractor.New();
vtkRenderer ren1 = vtkRenderer.New();
vtkRenderWindow renWin = vtkRenderWindow.New();
renWin.AddRenderer(ren1);
vtkImageActor actor = vtkImageActor.New();
vtkImageMapToWindowLevelColors coronalColors = vtkImageMapToWindowLevelColors.New();
coronalColors.SetInput(reader.GetOutput());
actor.SetInput(coronalColors.GetOutput());
ren1.AddActor(actor);
iren.SetRenderWindow(renWin);
iren.Initialize();
renWin.Render();
int retVal = testHelper.IsInteractiveModeSpecified();
if (retVal != 0)
{
iren.Start();
}
return(0);
}
/// <summary>
/// The main entry method called by the CSharp driver
/// </summary>
/// <param name="argv"></param>
public static void AVLineIntersectQuadraticCells(String [] argv)
{
//Prefix Content is: ""
// Contour every quadratic cell type[]
// Create a scene with one of each cell type.[]
// QuadraticEdge[]
edgePoints = new vtkPoints();
edgePoints.SetNumberOfPoints((int)3);
edgePoints.InsertPoint((int)0,(double)0,(double)0,(double)0);
edgePoints.InsertPoint((int)1,(double)1.0,(double)0,(double)0);
edgePoints.InsertPoint((int)2,(double)0.5,(double)0.25,(double)0);
edgeScalars = new vtkFloatArray();
edgeScalars.SetNumberOfTuples((int)3);
edgeScalars.InsertValue((int)0,(float)0.0);
edgeScalars.InsertValue((int)1,(float)0.0);
edgeScalars.InsertValue((int)2,(float)0.9);
aEdge = new vtkQuadraticEdge();
aEdge.GetPointIds().SetId((int)0,(int)0);
aEdge.GetPointIds().SetId((int)1,(int)1);
aEdge.GetPointIds().SetId((int)2,(int)2);
aEdgeGrid = new vtkUnstructuredGrid();
aEdgeGrid.Allocate((int)1,(int)1);
aEdgeGrid.InsertNextCell((int)aEdge.GetCellType(),(vtkIdList)aEdge.GetPointIds());
aEdgeGrid.SetPoints((vtkPoints)edgePoints);
aEdgeGrid.GetPointData().SetScalars((vtkDataArray)edgeScalars);
aEdgeMapper = new vtkDataSetMapper();
aEdgeMapper.SetInputData((vtkDataSet)aEdgeGrid);
aEdgeMapper.ScalarVisibilityOff();
aEdgeActor = new vtkActor();
aEdgeActor.SetMapper((vtkMapper)aEdgeMapper);
aEdgeActor.GetProperty().SetRepresentationToWireframe();
aEdgeActor.GetProperty().SetAmbient((double)1.0);
// Quadratic triangle[]
triPoints = new vtkPoints();
triPoints.SetNumberOfPoints((int)6);
triPoints.InsertPoint((int)0,(double)0.0,(double)0.0,(double)0.0);
triPoints.InsertPoint((int)1,(double)1.0,(double)0.0,(double)0.0);
triPoints.InsertPoint((int)2,(double)0.5,(double)0.8,(double)0.0);
triPoints.InsertPoint((int)3,(double)0.5,(double)0.0,(double)0.0);
triPoints.InsertPoint((int)4,(double)0.75,(double)0.4,(double)0.0);
triPoints.InsertPoint((int)5,(double)0.25,(double)0.4,(double)0.0);
triScalars = new vtkFloatArray();
triScalars.SetNumberOfTuples((int)6);
triScalars.InsertValue((int)0,(float)0.0);
triScalars.InsertValue((int)1,(float)0.0);
triScalars.InsertValue((int)2,(float)0.0);
triScalars.InsertValue((int)3,(float)1.0);
triScalars.InsertValue((int)4,(float)0.0);
triScalars.InsertValue((int)5,(float)0.0);
aTri = new vtkQuadraticTriangle();
aTri.GetPointIds().SetId((int)0,(int)0);
aTri.GetPointIds().SetId((int)1,(int)1);
aTri.GetPointIds().SetId((int)2,(int)2);
aTri.GetPointIds().SetId((int)3,(int)3);
aTri.GetPointIds().SetId((int)4,(int)4);
aTri.GetPointIds().SetId((int)5,(int)5);
aTriGrid = new vtkUnstructuredGrid();
aTriGrid.Allocate((int)1,(int)1);
aTriGrid.InsertNextCell((int)aTri.GetCellType(),(vtkIdList)aTri.GetPointIds());
aTriGrid.SetPoints((vtkPoints)triPoints);
aTriGrid.GetPointData().SetScalars((vtkDataArray)triScalars);
aTriMapper = new vtkDataSetMapper();
aTriMapper.SetInputData((vtkDataSet)aTriGrid);
aTriMapper.ScalarVisibilityOff();
aTriActor = new vtkActor();
aTriActor.SetMapper((vtkMapper)aTriMapper);
aTriActor.GetProperty().SetRepresentationToWireframe();
aTriActor.GetProperty().SetAmbient((double)1.0);
// Quadratic quadrilateral[]
quadPoints = new vtkPoints();
quadPoints.SetNumberOfPoints((int)8);
quadPoints.InsertPoint((int)0,(double)0.0,(double)0.0,(double)0.0);
quadPoints.InsertPoint((int)1,(double)1.0,(double)0.0,(double)0.0);
quadPoints.InsertPoint((int)2,(double)1.0,(double)1.0,(double)0.0);
quadPoints.InsertPoint((int)3,(double)0.0,(double)1.0,(double)0.0);
quadPoints.InsertPoint((int)4,(double)0.5,(double)0.0,(double)0.0);
quadPoints.InsertPoint((int)5,(double)1.0,(double)0.5,(double)0.0);
quadPoints.InsertPoint((int)6,(double)0.5,(double)1.0,(double)0.0);
quadPoints.InsertPoint((int)7,(double)0.0,(double)0.5,(double)0.0);
quadScalars = new vtkFloatArray();
quadScalars.SetNumberOfTuples((int)8);
quadScalars.InsertValue((int)0,(float)0.0);
quadScalars.InsertValue((int)1,(float)0.0);
quadScalars.InsertValue((int)2,(float)1.0);
quadScalars.InsertValue((int)3,(float)1.0);
quadScalars.InsertValue((int)4,(float)1.0);
quadScalars.InsertValue((int)5,(float)0.0);
quadScalars.InsertValue((int)6,(float)0.0);
quadScalars.InsertValue((int)7,(float)0.0);
aQuad = new vtkQuadraticQuad();
aQuad.GetPointIds().SetId((int)0,(int)0);
aQuad.GetPointIds().SetId((int)1,(int)1);
aQuad.GetPointIds().SetId((int)2,(int)2);
aQuad.GetPointIds().SetId((int)3,(int)3);
aQuad.GetPointIds().SetId((int)4,(int)4);
aQuad.GetPointIds().SetId((int)5,(int)5);
aQuad.GetPointIds().SetId((int)6,(int)6);
aQuad.GetPointIds().SetId((int)7,(int)7);
aQuadGrid = new vtkUnstructuredGrid();
aQuadGrid.Allocate((int)1,(int)1);
aQuadGrid.InsertNextCell((int)aQuad.GetCellType(),(vtkIdList)aQuad.GetPointIds());
aQuadGrid.SetPoints((vtkPoints)quadPoints);
aQuadGrid.GetPointData().SetScalars((vtkDataArray)quadScalars);
aQuadMapper = new vtkDataSetMapper();
aQuadMapper.SetInputData((vtkDataSet)aQuadGrid);
aQuadMapper.ScalarVisibilityOff();
aQuadActor = new vtkActor();
aQuadActor.SetMapper((vtkMapper)aQuadMapper);
aQuadActor.GetProperty().SetRepresentationToWireframe();
aQuadActor.GetProperty().SetAmbient((double)1.0);
// Quadratic tetrahedron[]
tetPoints = new vtkPoints();
tetPoints.SetNumberOfPoints((int)10);
tetPoints.InsertPoint((int)0,(double)0.0,(double)0.0,(double)0.0);
tetPoints.InsertPoint((int)1,(double)1.0,(double)0.0,(double)0.0);
tetPoints.InsertPoint((int)2,(double)0.5,(double)0.8,(double)0.0);
tetPoints.InsertPoint((int)3,(double)0.5,(double)0.4,(double)1.0);
tetPoints.InsertPoint((int)4,(double)0.5,(double)0.0,(double)0.0);
tetPoints.InsertPoint((int)5,(double)0.75,(double)0.4,(double)0.0);
tetPoints.InsertPoint((int)6,(double)0.25,(double)0.4,(double)0.0);
tetPoints.InsertPoint((int)7,(double)0.25,(double)0.2,(double)0.5);
tetPoints.InsertPoint((int)8,(double)0.75,(double)0.2,(double)0.5);
tetPoints.InsertPoint((int)9,(double)0.50,(double)0.6,(double)0.5);
tetScalars = new vtkFloatArray();
tetScalars.SetNumberOfTuples((int)10);
tetScalars.InsertValue((int)0,(float)1.0);
tetScalars.InsertValue((int)1,(float)1.0);
tetScalars.InsertValue((int)2,(float)1.0);
tetScalars.InsertValue((int)3,(float)1.0);
tetScalars.InsertValue((int)4,(float)0.0);
tetScalars.InsertValue((int)5,(float)0.0);
tetScalars.InsertValue((int)6,(float)0.0);
tetScalars.InsertValue((int)7,(float)0.0);
tetScalars.InsertValue((int)8,(float)0.0);
tetScalars.InsertValue((int)9,(float)0.0);
aTet = new vtkQuadraticTetra();
aTet.GetPointIds().SetId((int)0,(int)0);
aTet.GetPointIds().SetId((int)1,(int)1);
aTet.GetPointIds().SetId((int)2,(int)2);
aTet.GetPointIds().SetId((int)3,(int)3);
aTet.GetPointIds().SetId((int)4,(int)4);
aTet.GetPointIds().SetId((int)5,(int)5);
aTet.GetPointIds().SetId((int)6,(int)6);
aTet.GetPointIds().SetId((int)7,(int)7);
aTet.GetPointIds().SetId((int)8,(int)8);
aTet.GetPointIds().SetId((int)9,(int)9);
aTetGrid = new vtkUnstructuredGrid();
aTetGrid.Allocate((int)1,(int)1);
aTetGrid.InsertNextCell((int)aTet.GetCellType(),(vtkIdList)aTet.GetPointIds());
aTetGrid.SetPoints((vtkPoints)tetPoints);
aTetGrid.GetPointData().SetScalars((vtkDataArray)tetScalars);
aTetMapper = new vtkDataSetMapper();
aTetMapper.SetInputData((vtkDataSet)aTetGrid);
aTetMapper.ScalarVisibilityOff();
aTetActor = new vtkActor();
aTetActor.SetMapper((vtkMapper)aTetMapper);
aTetActor.GetProperty().SetRepresentationToWireframe();
aTetActor.GetProperty().SetAmbient((double)1.0);
// Quadratic hexahedron[]
hexPoints = new vtkPoints();
hexPoints.SetNumberOfPoints((int)20);
hexPoints.InsertPoint((int)0,(double)0,(double)0,(double)0);
hexPoints.InsertPoint((int)1,(double)1,(double)0,(double)0);
hexPoints.InsertPoint((int)2,(double)1,(double)1,(double)0);
hexPoints.InsertPoint((int)3,(double)0,(double)1,(double)0);
hexPoints.InsertPoint((int)4,(double)0,(double)0,(double)1);
hexPoints.InsertPoint((int)5,(double)1,(double)0,(double)1);
hexPoints.InsertPoint((int)6,(double)1,(double)1,(double)1);
hexPoints.InsertPoint((int)7,(double)0,(double)1,(double)1);
hexPoints.InsertPoint((int)8,(double)0.5,(double)0,(double)0);
hexPoints.InsertPoint((int)9,(double)1,(double)0.5,(double)0);
hexPoints.InsertPoint((int)10,(double)0.5,(double)1,(double)0);
hexPoints.InsertPoint((int)11,(double)0,(double)0.5,(double)0);
hexPoints.InsertPoint((int)12,(double)0.5,(double)0,(double)1);
hexPoints.InsertPoint((int)13,(double)1,(double)0.5,(double)1);
hexPoints.InsertPoint((int)14,(double)0.5,(double)1,(double)1);
hexPoints.InsertPoint((int)15,(double)0,(double)0.5,(double)1);
hexPoints.InsertPoint((int)16,(double)0,(double)0,(double)0.5);
hexPoints.InsertPoint((int)17,(double)1,(double)0,(double)0.5);
hexPoints.InsertPoint((int)18,(double)1,(double)1,(double)0.5);
hexPoints.InsertPoint((int)19,(double)0,(double)1,(double)0.5);
hexScalars = new vtkFloatArray();
hexScalars.SetNumberOfTuples((int)20);
hexScalars.InsertValue((int)0,(float)1.0);
hexScalars.InsertValue((int)1,(float)1.0);
hexScalars.InsertValue((int)2,(float)1.0);
hexScalars.InsertValue((int)3,(float)1.0);
hexScalars.InsertValue((int)4,(float)1.0);
hexScalars.InsertValue((int)5,(float)1.0);
hexScalars.InsertValue((int)6,(float)1.0);
hexScalars.InsertValue((int)7,(float)1.0);
hexScalars.InsertValue((int)8,(float)0.0);
hexScalars.InsertValue((int)9,(float)0.0);
hexScalars.InsertValue((int)10,(float)0.0);
hexScalars.InsertValue((int)11,(float)0.0);
hexScalars.InsertValue((int)12,(float)0.0);
hexScalars.InsertValue((int)13,(float)0.0);
hexScalars.InsertValue((int)14,(float)0.0);
hexScalars.InsertValue((int)15,(float)0.0);
hexScalars.InsertValue((int)16,(float)0.0);
hexScalars.InsertValue((int)17,(float)0.0);
hexScalars.InsertValue((int)18,(float)0.0);
hexScalars.InsertValue((int)19,(float)0.0);
aHex = new vtkQuadraticHexahedron();
aHex.GetPointIds().SetId((int)0,(int)0);
aHex.GetPointIds().SetId((int)1,(int)1);
aHex.GetPointIds().SetId((int)2,(int)2);
aHex.GetPointIds().SetId((int)3,(int)3);
aHex.GetPointIds().SetId((int)4,(int)4);
aHex.GetPointIds().SetId((int)5,(int)5);
aHex.GetPointIds().SetId((int)6,(int)6);
aHex.GetPointIds().SetId((int)7,(int)7);
aHex.GetPointIds().SetId((int)8,(int)8);
aHex.GetPointIds().SetId((int)9,(int)9);
aHex.GetPointIds().SetId((int)10,(int)10);
aHex.GetPointIds().SetId((int)11,(int)11);
aHex.GetPointIds().SetId((int)12,(int)12);
aHex.GetPointIds().SetId((int)13,(int)13);
aHex.GetPointIds().SetId((int)14,(int)14);
aHex.GetPointIds().SetId((int)15,(int)15);
aHex.GetPointIds().SetId((int)16,(int)16);
aHex.GetPointIds().SetId((int)17,(int)17);
aHex.GetPointIds().SetId((int)18,(int)18);
aHex.GetPointIds().SetId((int)19,(int)19);
aHexGrid = new vtkUnstructuredGrid();
aHexGrid.Allocate((int)1,(int)1);
aHexGrid.InsertNextCell((int)aHex.GetCellType(),(vtkIdList)aHex.GetPointIds());
aHexGrid.SetPoints((vtkPoints)hexPoints);
aHexGrid.GetPointData().SetScalars((vtkDataArray)hexScalars);
aHexMapper = new vtkDataSetMapper();
aHexMapper.SetInputData((vtkDataSet)aHexGrid);
aHexMapper.ScalarVisibilityOff();
aHexActor = new vtkActor();
aHexActor.SetMapper((vtkMapper)aHexMapper);
aHexActor.GetProperty().SetRepresentationToWireframe();
aHexActor.GetProperty().SetAmbient((double)1.0);
// Quadratic wedge[]
wedgePoints = new vtkPoints();
wedgePoints.SetNumberOfPoints((int)15);
wedgePoints.InsertPoint((int)0,(double)0,(double)0,(double)0);
wedgePoints.InsertPoint((int)1,(double)1,(double)0,(double)0);
wedgePoints.InsertPoint((int)2,(double)0,(double)1,(double)0);
wedgePoints.InsertPoint((int)3,(double)0,(double)0,(double)1);
wedgePoints.InsertPoint((int)4,(double)1,(double)0,(double)1);
wedgePoints.InsertPoint((int)5,(double)0,(double)1,(double)1);
wedgePoints.InsertPoint((int)6,(double)0.5,(double)0,(double)0);
wedgePoints.InsertPoint((int)7,(double)0.5,(double)0.5,(double)0);
wedgePoints.InsertPoint((int)8,(double)0,(double)0.5,(double)0);
wedgePoints.InsertPoint((int)9,(double)0.5,(double)0,(double)1);
wedgePoints.InsertPoint((int)10,(double)0.5,(double)0.5,(double)1);
wedgePoints.InsertPoint((int)11,(double)0,(double)0.5,(double)1);
wedgePoints.InsertPoint((int)12,(double)0,(double)0,(double)0.5);
wedgePoints.InsertPoint((int)13,(double)1,(double)0,(double)0.5);
wedgePoints.InsertPoint((int)14,(double)0,(double)1,(double)0.5);
wedgeScalars = new vtkFloatArray();
wedgeScalars.SetNumberOfTuples((int)15);
wedgeScalars.InsertValue((int)0,(float)1.0);
wedgeScalars.InsertValue((int)1,(float)1.0);
wedgeScalars.InsertValue((int)2,(float)1.0);
wedgeScalars.InsertValue((int)3,(float)1.0);
wedgeScalars.InsertValue((int)4,(float)1.0);
wedgeScalars.InsertValue((int)5,(float)1.0);
wedgeScalars.InsertValue((int)6,(float)1.0);
wedgeScalars.InsertValue((int)7,(float)1.0);
wedgeScalars.InsertValue((int)8,(float)0.0);
wedgeScalars.InsertValue((int)9,(float)0.0);
wedgeScalars.InsertValue((int)10,(float)0.0);
wedgeScalars.InsertValue((int)11,(float)0.0);
wedgeScalars.InsertValue((int)12,(float)0.0);
wedgeScalars.InsertValue((int)13,(float)0.0);
wedgeScalars.InsertValue((int)14,(float)0.0);
aWedge = new vtkQuadraticWedge();
aWedge.GetPointIds().SetId((int)0,(int)0);
aWedge.GetPointIds().SetId((int)1,(int)1);
aWedge.GetPointIds().SetId((int)2,(int)2);
aWedge.GetPointIds().SetId((int)3,(int)3);
aWedge.GetPointIds().SetId((int)4,(int)4);
aWedge.GetPointIds().SetId((int)5,(int)5);
aWedge.GetPointIds().SetId((int)6,(int)6);
aWedge.GetPointIds().SetId((int)7,(int)7);
aWedge.GetPointIds().SetId((int)8,(int)8);
aWedge.GetPointIds().SetId((int)9,(int)9);
aWedge.GetPointIds().SetId((int)10,(int)10);
aWedge.GetPointIds().SetId((int)11,(int)11);
aWedge.GetPointIds().SetId((int)12,(int)12);
aWedge.GetPointIds().SetId((int)13,(int)13);
aWedge.GetPointIds().SetId((int)14,(int)14);
aWedgeGrid = new vtkUnstructuredGrid();
aWedgeGrid.Allocate((int)1,(int)1);
aWedgeGrid.InsertNextCell((int)aWedge.GetCellType(),(vtkIdList)aWedge.GetPointIds());
aWedgeGrid.SetPoints((vtkPoints)wedgePoints);
aWedgeGrid.GetPointData().SetScalars((vtkDataArray)wedgeScalars);
wedgeContours = new vtkClipDataSet();
wedgeContours.SetInputData((vtkDataObject)aWedgeGrid);
wedgeContours.SetValue((double)0.5);
aWedgeContourMapper = new vtkDataSetMapper();
aWedgeContourMapper.SetInputConnection((vtkAlgorithmOutput)wedgeContours.GetOutputPort());
aWedgeContourMapper.ScalarVisibilityOff();
aWedgeMapper = new vtkDataSetMapper();
aWedgeMapper.SetInputData((vtkDataSet)aWedgeGrid);
aWedgeMapper.ScalarVisibilityOff();
aWedgeActor = new vtkActor();
aWedgeActor.SetMapper((vtkMapper)aWedgeMapper);
aWedgeActor.GetProperty().SetRepresentationToWireframe();
aWedgeActor.GetProperty().SetAmbient((double)1.0);
aWedgeContourActor = new vtkActor();
aWedgeContourActor.SetMapper((vtkMapper)aWedgeContourMapper);
aWedgeContourActor.GetProperty().SetAmbient((double)1.0);
// Quadratic pyramid[]
pyraPoints = new vtkPoints();
pyraPoints.SetNumberOfPoints((int)13);
pyraPoints.InsertPoint((int)0,(double)0,(double)0,(double)0);
pyraPoints.InsertPoint((int)1,(double)1,(double)0,(double)0);
pyraPoints.InsertPoint((int)2,(double)1,(double)1,(double)0);
pyraPoints.InsertPoint((int)3,(double)0,(double)1,(double)0);
pyraPoints.InsertPoint((int)4,(double)0,(double)0,(double)1);
pyraPoints.InsertPoint((int)5,(double)0.5,(double)0,(double)0);
pyraPoints.InsertPoint((int)6,(double)1,(double)0.5,(double)0);
pyraPoints.InsertPoint((int)7,(double)0.5,(double)1,(double)0);
pyraPoints.InsertPoint((int)8,(double)0,(double)0.5,(double)0);
pyraPoints.InsertPoint((int)9,(double)0,(double)0,(double)0.5);
pyraPoints.InsertPoint((int)10,(double)0.5,(double)0,(double)0.5);
pyraPoints.InsertPoint((int)11,(double)0.5,(double)0.5,(double)0.5);
pyraPoints.InsertPoint((int)12,(double)0,(double)0.5,(double)0.5);
pyraScalars = new vtkFloatArray();
pyraScalars.SetNumberOfTuples((int)13);
pyraScalars.InsertValue((int)0,(float)1.0);
pyraScalars.InsertValue((int)1,(float)1.0);
pyraScalars.InsertValue((int)2,(float)1.0);
pyraScalars.InsertValue((int)3,(float)1.0);
pyraScalars.InsertValue((int)4,(float)1.0);
pyraScalars.InsertValue((int)5,(float)1.0);
pyraScalars.InsertValue((int)6,(float)1.0);
pyraScalars.InsertValue((int)7,(float)1.0);
pyraScalars.InsertValue((int)8,(float)0.0);
pyraScalars.InsertValue((int)9,(float)0.0);
pyraScalars.InsertValue((int)10,(float)0.0);
pyraScalars.InsertValue((int)11,(float)0.0);
pyraScalars.InsertValue((int)12,(float)0.0);
aPyramid = new vtkQuadraticPyramid();
aPyramid.GetPointIds().SetId((int)0,(int)0);
aPyramid.GetPointIds().SetId((int)1,(int)1);
aPyramid.GetPointIds().SetId((int)2,(int)2);
aPyramid.GetPointIds().SetId((int)3,(int)3);
aPyramid.GetPointIds().SetId((int)4,(int)4);
aPyramid.GetPointIds().SetId((int)5,(int)5);
aPyramid.GetPointIds().SetId((int)6,(int)6);
aPyramid.GetPointIds().SetId((int)7,(int)7);
aPyramid.GetPointIds().SetId((int)8,(int)8);
aPyramid.GetPointIds().SetId((int)9,(int)9);
aPyramid.GetPointIds().SetId((int)10,(int)10);
aPyramid.GetPointIds().SetId((int)11,(int)11);
aPyramid.GetPointIds().SetId((int)12,(int)12);
aPyramidGrid = new vtkUnstructuredGrid();
aPyramidGrid.Allocate((int)1,(int)1);
aPyramidGrid.InsertNextCell((int)aPyramid.GetCellType(),(vtkIdList)aPyramid.GetPointIds());
aPyramidGrid.SetPoints((vtkPoints)pyraPoints);
aPyramidGrid.GetPointData().SetScalars((vtkDataArray)pyraScalars);
pyraContours = new vtkClipDataSet();
pyraContours.SetInputData((vtkDataObject)aPyramidGrid);
pyraContours.SetValue((double)0.5);
aPyramidContourMapper = new vtkDataSetMapper();
aPyramidContourMapper.SetInputConnection((vtkAlgorithmOutput)pyraContours.GetOutputPort());
aPyramidContourMapper.ScalarVisibilityOff();
aPyramidMapper = new vtkDataSetMapper();
aPyramidMapper.SetInputData((vtkDataSet)aPyramidGrid);
aPyramidMapper.ScalarVisibilityOff();
aPyramidActor = new vtkActor();
aPyramidActor.SetMapper((vtkMapper)aPyramidMapper);
aPyramidActor.GetProperty().SetRepresentationToWireframe();
aPyramidActor.GetProperty().SetAmbient((double)1.0);
aPyramidContourActor = new vtkActor();
aPyramidContourActor.SetMapper((vtkMapper)aPyramidContourMapper);
aPyramidContourActor.GetProperty().SetAmbient((double)1.0);
// Create the rendering related stuff.[]
// Since some of our actors are a single vertex, we need to remove all[]
// cullers so the single vertex actors will render[]
ren1 = vtkRenderer.New();
ren1.GetCullers().RemoveAllItems();
renWin = vtkRenderWindow.New();
renWin.SetMultiSamples(0);
renWin.AddRenderer((vtkRenderer)ren1);
iren = new vtkRenderWindowInteractor();
iren.SetRenderWindow((vtkRenderWindow)renWin);
ren1.SetBackground((double).1,(double).2,(double).3);
renWin.SetSize((int)400,(int)200);
// specify properties[]
ren1.AddActor((vtkProp)aEdgeActor);
ren1.AddActor((vtkProp)aTriActor);
ren1.AddActor((vtkProp)aQuadActor);
ren1.AddActor((vtkProp)aTetActor);
ren1.AddActor((vtkProp)aHexActor);
ren1.AddActor((vtkProp)aWedgeActor);
ren1.AddActor((vtkProp)aPyramidActor);
// places everyone!![]
aTriActor.AddPosition((double)2,(double)0,(double)0);
aQuadActor.AddPosition((double)4,(double)0,(double)0);
aTetActor.AddPosition((double)6,(double)0,(double)0);
aHexActor.AddPosition((double)8,(double)0,(double)0);
aWedgeActor.AddPosition((double)10,(double)0,(double)0);
aPyramidActor.AddPosition((double)12,(double)0,(double)0);
BuildBackdrop(-1, 15, -1, 4, -1, 2, .1);
ren1.AddActor((vtkProp)base1);
base1.GetProperty().SetDiffuseColor((double).2,(double).2,(double).2);
ren1.AddActor((vtkProp)left);
left.GetProperty().SetDiffuseColor((double).2,(double).2,(double).2);
ren1.AddActor((vtkProp)back);
back.GetProperty().SetDiffuseColor((double).2,(double).2,(double).2);
ren1.ResetCamera();
ren1.GetActiveCamera().Dolly((double)2.5);
ren1.ResetCameraClippingRange();
renWin.Render();
// create a little scorecard above each of the cells. These are displayed[]
// if a ray cast hits the cell, otherwise they are not shown.[]
pm = new vtkPlaneSource();
pm.SetXResolution((int)1);
pm.SetYResolution((int)1);
pmapper = vtkPolyDataMapper.New();
pmapper.SetInputConnection((vtkAlgorithmOutput)pm.GetOutputPort());
// now try intersecting rays with the cell[]
cellPicker = new vtkCellPicker();
edgeCheck = new vtkActor();
edgeCheck.SetMapper((vtkMapper)pmapper);
edgeCheck.AddPosition((double)0.5,(double)2.5,(double)0);
cellPicker.Pick((double)87,(double)71,(double)0,(vtkRenderer)ren1);
if ((cellPicker.GetCellId()) != -1)
{
ren1.AddActor((vtkProp)edgeCheck);
}
triCheck = new vtkActor();
triCheck.SetMapper((vtkMapper)pmapper);
triCheck.AddPosition((double)2.5,(double)2.5,(double)0);
cellPicker.Pick((double)139,(double)72,(double)0,(vtkRenderer)ren1);
if ((cellPicker.GetCellId()) != -1)
{
ren1.AddActor((vtkProp)triCheck);
}
quadCheck = new vtkActor();
quadCheck.SetMapper((vtkMapper)pmapper);
quadCheck.AddPosition((double)4.5,(double)2.5,(double)0);
cellPicker.Pick((double)192,(double)78,(double)0,(vtkRenderer)ren1);
if ((cellPicker.GetCellId()) != -1)
{
ren1.AddActor((vtkProp)quadCheck);
}
tetCheck = new vtkActor();
tetCheck.SetMapper((vtkMapper)pmapper);
tetCheck.AddPosition((double)6.5,(double)2.5,(double)0);
cellPicker.Pick((double)233,(double)70,(double)0,(vtkRenderer)ren1);
if ((cellPicker.GetCellId()) != -1)
{
ren1.AddActor((vtkProp)tetCheck);
}
hexCheck = new vtkActor();
hexCheck.SetMapper((vtkMapper)pmapper);
hexCheck.AddPosition((double)8.5,(double)2.5,(double)0);
cellPicker.Pick((double)287,(double)80,(double)0,(vtkRenderer)ren1);
if ((cellPicker.GetCellId()) != -1)
{
ren1.AddActor((vtkProp)hexCheck);
}
wedgeCheck = new vtkActor();
wedgeCheck.SetMapper((vtkMapper)pmapper);
wedgeCheck.AddPosition((double)10.5,(double)2.5,(double)0);
cellPicker.Pick((double)287,(double)80,(double)0,(vtkRenderer)ren1);
if ((cellPicker.GetCellId()) != -1)
{
ren1.AddActor((vtkProp)wedgeCheck);
}
pyraCheck = new vtkActor();
pyraCheck.SetMapper((vtkMapper)pmapper);
pyraCheck.AddPosition((double)12.5,(double)2.5,(double)0);
cellPicker.Pick((double)287,(double)80,(double)0,(vtkRenderer)ren1);
if ((cellPicker.GetCellId()) != -1)
{
ren1.AddActor((vtkProp)pyraCheck);
}
// render the image[]
//[]
iren.Initialize();
//deleteAllVTKObjects();
}
/// <summary>
/// The main entry method called by the CSharp driver
/// </summary>
/// <param name="argv"></param>
public static void AVEnSightRectGridASCII(String [] argv)
{
//Prefix Content is: ""
VTK_VARY_RADIUS_BY_VECTOR = 2;
// create pipeline[]
//[]
reader = new vtkGenericEnSightReader();
// Make sure all algorithms use the composite data pipeline[]
cdp = new vtkCompositeDataPipeline();
vtkGenericEnSightReader.SetDefaultExecutivePrototype((vtkExecutive)cdp);
reader.SetCaseFileName((string)"" + (VTK_DATA_ROOT.ToString()) + "/Data/EnSight/RectGrid_ascii.case");
reader.Update();
toRectilinearGrid = new vtkCastToConcrete();
// toRectilinearGrid SetInputConnection [reader GetOutputPort] []
toRectilinearGrid.SetInput((vtkDataObject)reader.GetOutput().GetBlock((uint)0));
plane = new vtkRectilinearGridGeometryFilter();
plane.SetInput((vtkDataObject)toRectilinearGrid.GetRectilinearGridOutput());
plane.SetExtent((int)0,(int)100,(int)0,(int)100,(int)15,(int)15);
tri = new vtkTriangleFilter();
tri.SetInputConnection((vtkAlgorithmOutput)plane.GetOutputPort());
warper = new vtkWarpVector();
warper.SetInputConnection((vtkAlgorithmOutput)tri.GetOutputPort());
warper.SetScaleFactor((double)0.05);
planeMapper = new vtkDataSetMapper();
planeMapper.SetInputConnection((vtkAlgorithmOutput)warper.GetOutputPort());
planeMapper.SetScalarRange((double)0.197813,(double)0.710419);
planeActor = new vtkActor();
planeActor.SetMapper((vtkMapper)planeMapper);
cutPlane = new vtkPlane();
// eval cutPlane SetOrigin [[reader GetOutput] GetCenter][]
cutPlane.SetOrigin((double)((vtkDataSet)reader.GetOutput().GetBlock((uint)0)).GetCenter()[0], (double)((vtkDataSet)reader.GetOutput().GetBlock((uint)0)).GetCenter()[1], (double)((vtkDataSet)reader.GetOutput().GetBlock((uint)0)).GetCenter()[2]);
cutPlane.SetNormal((double)1,(double)0,(double)0);
planeCut = new vtkCutter();
planeCut.SetInput((vtkDataObject)toRectilinearGrid.GetRectilinearGridOutput());
planeCut.SetCutFunction((vtkImplicitFunction)cutPlane);
cutMapper = new vtkDataSetMapper();
cutMapper.SetInputConnection((vtkAlgorithmOutput)planeCut.GetOutputPort());
cutMapper.SetScalarRange((double)((vtkDataSet)((vtkMultiBlockDataSet)reader.GetOutput()).GetBlock((uint)0)).GetPointData().GetScalars().GetRange()[0], (double)((vtkDataSet)((vtkMultiBlockDataSet)reader.GetOutput()).GetBlock((uint)0)).GetPointData().GetScalars().GetRange()[1]);
cutActor = new vtkActor();
cutActor.SetMapper((vtkMapper)cutMapper);
iso = new vtkContourFilter();
iso.SetInput((vtkDataObject)toRectilinearGrid.GetRectilinearGridOutput());
iso.SetValue((int)0,(double)0.7);
normals = new vtkPolyDataNormals();
normals.SetInputConnection((vtkAlgorithmOutput)iso.GetOutputPort());
normals.SetFeatureAngle((double)45);
isoMapper = vtkPolyDataMapper.New();
isoMapper.SetInputConnection((vtkAlgorithmOutput)normals.GetOutputPort());
isoMapper.ScalarVisibilityOff();
isoActor = new vtkActor();
isoActor.SetMapper((vtkMapper)isoMapper);
isoActor.GetProperty().SetColor((double) 1.0000, 0.8941, 0.7686 );
isoActor.GetProperty().SetRepresentationToWireframe();
streamer = new vtkStreamLine();
// streamer SetInputConnection [reader GetOutputPort][]
streamer.SetInput((vtkDataObject)reader.GetOutput().GetBlock((uint)0));
streamer.SetStartPosition((double)-1.2,(double)-0.1,(double)1.3);
streamer.SetMaximumPropagationTime((double)500);
streamer.SetStepLength((double)0.05);
streamer.SetIntegrationStepLength((double)0.05);
streamer.SetIntegrationDirectionToIntegrateBothDirections();
streamTube = new vtkTubeFilter();
streamTube.SetInputConnection((vtkAlgorithmOutput)streamer.GetOutputPort());
streamTube.SetRadius((double)0.025);
streamTube.SetNumberOfSides((int)6);
streamTube.SetVaryRadius((int)VTK_VARY_RADIUS_BY_VECTOR);
mapStreamTube = vtkPolyDataMapper.New();
mapStreamTube.SetInputConnection((vtkAlgorithmOutput)streamTube.GetOutputPort());
mapStreamTube.SetScalarRange((double)((vtkDataSet)reader.GetOutput().GetBlock((uint)0)).GetPointData().GetScalars().GetRange()[0], (double)((vtkDataSet)reader.GetOutput().GetBlock((uint)0)).GetPointData().GetScalars().GetRange()[1]);
// [[[[reader GetOutput] GetPointData] GetScalars] GetRange][]
streamTubeActor = new vtkActor();
streamTubeActor.SetMapper((vtkMapper)mapStreamTube);
streamTubeActor.GetProperty().BackfaceCullingOn();
outline = new vtkOutlineFilter();
outline.SetInput((vtkDataObject)toRectilinearGrid.GetRectilinearGridOutput());
outlineMapper = vtkPolyDataMapper.New();
outlineMapper.SetInputConnection((vtkAlgorithmOutput)outline.GetOutputPort());
outlineActor = new vtkActor();
outlineActor.SetMapper((vtkMapper)outlineMapper);
outlineActor.GetProperty().SetColor((double) 0.0000, 0.0000, 0.0000 );
// Graphics stuff[]
// Create the RenderWindow, Renderer and both Actors[]
//[]
ren1 = vtkRenderer.New();
renWin = vtkRenderWindow.New();
renWin.AddRenderer((vtkRenderer)ren1);
iren = new vtkRenderWindowInteractor();
iren.SetRenderWindow((vtkRenderWindow)renWin);
// Add the actors to the renderer, set the background and size[]
//[]
ren1.AddActor((vtkProp)outlineActor);
ren1.AddActor((vtkProp)planeActor);
ren1.AddActor((vtkProp)cutActor);
ren1.AddActor((vtkProp)isoActor);
ren1.AddActor((vtkProp)streamTubeActor);
ren1.SetBackground((double)1,(double)1,(double)1);
renWin.SetSize((int)400,(int)400);
cam1 = ren1.GetActiveCamera();
cam1.SetClippingRange((double)3.76213,(double)10.712);
cam1.SetFocalPoint((double)-0.0842503,(double)-0.136905,(double)0.610234);
cam1.SetPosition((double)2.53813,(double)2.2678,(double)-5.22172);
cam1.SetViewUp((double)-0.241047,(double)0.930635,(double)0.275343);
iren.Initialize();
// render the image[]
//[]
// prevent the tk window from showing up then start the event loop[]
vtkGenericEnSightReader.SetDefaultExecutivePrototype(null);
//deleteAllVTKObjects();
}
static void Main(string[] args)
{
//
// Next we create an instance of vtkConeSource and set some of its
// properties. The instance of vtkConeSource "cone" is part of a visualization
// pipeline (it is a source process object); it produces data (output type is
// vtkPolyData) which other filters may process.
//
vtkConeSource cone = new vtkConeSource();
cone.SetHeight( 3.0f );
cone.SetRadius( 1.0f );
cone.SetResolution( 10 );
//
// In this example we terminate the pipeline with a mapper process object.
// (Intermediate filters such as vtkShrinkPolyData could be inserted in
// between the source and the mapper.) We create an instance of
// vtkPolyDataMapper to map the polygonal data into graphics primitives. We
// connect the output of the cone souece to the input of this mapper.
//
vtkPolyDataMapper coneMapper = new vtkPolyDataMapper();
coneMapper.SetInput( cone.GetOutput() );
//
// Create an actor to represent the cone. The actor orchestrates rendering of
// the mapper's graphics primitives. An actor also refers to properties via a
// vtkProperty instance, and includes an internal transformation matrix. We
// set this actor's mapper to be coneMapper which we created above.
//
vtkActor coneActor = new vtkActor();
coneActor.SetMapper( coneMapper );
//
// Create the Renderer and assign actors to it. A renderer is like a
// viewport. It is part or all of a window on the screen and it is
// responsible for drawing the actors it has. We also set the background
// color here
//
vtkRenderer ren1 = new vtkRenderer();
ren1.AddActor( coneActor );
ren1.SetBackground( 0.1f, 0.2f, 0.4f );
//
// Finally we create the render window which will show up on the screen
// We put our renderer into the render window using AddRenderer. We also
// set the size to be 300 pixels by 300
//
vtkRenderWindow renWin = new vtkRenderWindow();
renWin.AddRenderer( ren1 );
renWin.SetSize( 300, 300 );
vtkRenderWindowInteractor iren = new vtkRenderWindowInteractor();
iren.SetRenderWindow(renWin);
vtkInteractorStyleTrackballCamera style =
new vtkInteractorStyleTrackballCamera();
iren.SetInteractorStyle(style);
vtkBoxWidget boxWidget = new vtkBoxWidget();
boxWidget.SetInteractor(iren);
boxWidget.SetPlaceFactor(1.25f);
boxWidget.SetProp3D(coneActor);
boxWidget.PlaceWidget();
boxWidget.AddObserver((uint) EventIds.InteractionEvent,
new vtkDotNetCallback(myCallback));
boxWidget.On();
iren.Initialize();
iren.Start();
vtkWin32OpenGLRenderWindow win32win =
vtkWin32OpenGLRenderWindow.SafeDownCast(renWin);
if ( null != win32win ) win32win.Clean();
}
int build3DViewFull()
{
Kitware.VTK.RenderWindowControl rw = new Kitware.VTK.RenderWindowControl();
vtkRenderWindow _renwin = rw.RenderWindow;
vtkRenderer _render = _renwin.GetRenderers().GetFirstRenderer();
_renwin.AddRenderer(_render);
vtkRenderWindowInteractor iren = new vtkRenderWindowInteractor();
iren.SetRenderWindow(_renwin);
// 新建文件读取对象，常见的有vtkBMPReader、vtkDICOMImageReader、vtkJPEGReader等
vtkJPEGReader jpegReader = new vtkJPEGReader();
// 不同的reader需要设置的参数是不同的 因此本例仅适合jpegreader
jpegReader.SetFilePrefix("C:/Users/DawnWind/Desktop/000/"); // 要打开的路径
jpegReader.SetFilePattern("%s%d.jpg"); // 图片文件名格式，此处为 0.jpg 1.jpg ...
jpegReader.SetDataByteOrderToLittleEndian();
jpegReader.SetDataSpacing(1, 1, 1.4); // 设置图片中像素比，我理解得不清楚，具体请百度之
jpegReader.SetFileNameSliceSpacing(1);
jpegReader.SetDataExtent(0, 209, 0, 209, 0, 29);
// 这里因为在000文件夹里面有0.jpg ~ 29.jpg，所以设置为 0，29
// 每张图片的长宽为210 * 210 因此设置为0，209
jpegReader.Update();
// update这里要注意一下，对于VTK在默认情况下是在最后操作时候才一次性刷新
// 也就是说如果没有自动刷新的话，在一些中间过程中是无法获得到数据的，因为没update进去
vtkContourFilter skinExtractor = new vtkContourFilter();
skinExtractor.SetInputConnection(jpegReader.GetOutputPort());
skinExtractor.SetValue(200, 100); //值越大，保留的部分越少。
//重新计算法向量
vtkPolyDataNormals skinNormals = new vtkPolyDataNormals();
skinNormals.SetInputConnection(skinExtractor.GetOutputPort());
skinNormals.SetFeatureAngle(60.0);
//Specify the angle that defines a sharp edge.
//If the difference in angle across neighboring polygons is greater than this value,
//the shared edge is considered "sharp".
//create triangle strips and/or poly-lines 为了更快的显示速度
vtkStripper skinStripper = new vtkStripper();
skinStripper.SetInputConnection(skinNormals.GetOutputPort());
vtkPolyDataMapper skinMapper = new vtkPainterPolyDataMapper();
skinMapper.SetInputConnection(skinStripper.GetOutputPort());
skinMapper.ScalarVisibilityOff(); //这样不会带颜色
vtkActor skin = new vtkActor();
skin.SetMapper(skinMapper);
// An outline provides context around the data.
// 一个围绕在物体的立体框，可以先忽略
/*
* vtkOutlineFilter> outlineData =
* vtkOutlineFilter>::New();
* outlineData.SetInputConnection(dicomReader.GetOutputPort());
*
* vtkPolyDataMapper> mapOutline =
* vtkPolyDataMapper>::New();
* mapOutline.SetInputConnection(outlineData.GetOutputPort());
*
* vtkActor> outline =
* vtkActor>::New();
* outline.SetMapper(mapOutline);
* outline.GetProperty().SetColor(0,0,0);
*
* aRenderer.AddActor(outline);
*/
// It is convenient to create an initial view of the data. The FocalPoint
// and Position form a vector direction. Later on (ResetCamera() method)
// this vector is used to position the camera to look at the data in
// this direction.
vtkCamera aCamera = new vtkCamera();
aCamera.SetViewUp(0, 0, -1);
aCamera.SetPosition(0, 1, 0);
aCamera.SetFocalPoint(0, 0, 0);
aCamera.ComputeViewPlaneNormal();
aCamera.Azimuth(30.0);
aCamera.Elevation(30.0);
// Actors are added to the renderer. An initial camera view is created.
// The Dolly() method moves the camera towards the FocalPoint,
// thereby enlarging the image.
_render.AddActor(skin);
_render.SetActiveCamera(aCamera);
_render.ResetCamera();
aCamera.Dolly(1.5);
// Set a background color for the renderer and set the size of the
// render window (expressed in pixels).
_render.SetBackground(.2, .3, .4);
_renwin.SetSize(640, 480);
// Note that when camera movement occurs (as it does in the Dolly()
// method), the clipping planes often need adjusting. Clipping planes
// consist of two planes: near and far along the view direction. The
// near plane clips out objects in front of the plane; the far plane
// clips out objects behind the plane. This way only what is drawn
// between the planes is actually rendered.
_render.ResetCameraClippingRange();
// Initialize the event loop and then start it.
iren.Initialize();
iren.Start();
return(0);
}
/// <summary>
/// The main entry method called by the CSharp driver
/// </summary>
/// <param name="argv"></param>
public static void AVTestCellDerivs(String [] argv)
{
//Prefix Content is: ""
// Demonstrates vtkCellDerivatives for all cell types[]
//[]
// get the interactor ui[]
ren1 = vtkRenderer.New();
renWin = vtkRenderWindow.New();
renWin.AddRenderer((vtkRenderer)ren1);
iren = new vtkRenderWindowInteractor();
iren.SetRenderWindow((vtkRenderWindow)renWin);
// create a scene with one of each cell type[]
// Voxel[]
voxelPoints = new vtkPoints();
voxelPoints.SetNumberOfPoints((int)8);
voxelPoints.InsertPoint((int)0,(double)0,(double)0,(double)0);
voxelPoints.InsertPoint((int)1,(double)1,(double)0,(double)0);
voxelPoints.InsertPoint((int)2,(double)0,(double)1,(double)0);
voxelPoints.InsertPoint((int)3,(double)1,(double)1,(double)0);
voxelPoints.InsertPoint((int)4,(double)0,(double)0,(double)1);
voxelPoints.InsertPoint((int)5,(double)1,(double)0,(double)1);
voxelPoints.InsertPoint((int)6,(double)0,(double)1,(double)1);
voxelPoints.InsertPoint((int)7,(double)1,(double)1,(double)1);
aVoxel = new vtkVoxel();
aVoxel.GetPointIds().SetId((int)0,(int)0);
aVoxel.GetPointIds().SetId((int)1,(int)1);
aVoxel.GetPointIds().SetId((int)2,(int)2);
aVoxel.GetPointIds().SetId((int)3,(int)3);
aVoxel.GetPointIds().SetId((int)4,(int)4);
aVoxel.GetPointIds().SetId((int)5,(int)5);
aVoxel.GetPointIds().SetId((int)6,(int)6);
aVoxel.GetPointIds().SetId((int)7,(int)7);
aVoxelGrid = new vtkUnstructuredGrid();
aVoxelGrid.Allocate((int)1,(int)1);
aVoxelGrid.InsertNextCell((int)aVoxel.GetCellType(),(vtkIdList)aVoxel.GetPointIds());
aVoxelGrid.SetPoints((vtkPoints)voxelPoints);
aVoxelMapper = new vtkDataSetMapper();
aVoxelMapper.SetInput((vtkDataSet)aVoxelGrid);
aVoxelActor = new vtkActor();
aVoxelActor.SetMapper((vtkMapper)aVoxelMapper);
aVoxelActor.GetProperty().BackfaceCullingOn();
// Hexahedron[]
hexahedronPoints = new vtkPoints();
hexahedronPoints.SetNumberOfPoints((int)8);
hexahedronPoints.InsertPoint((int)0,(double)0,(double)0,(double)0);
hexahedronPoints.InsertPoint((int)1,(double)1,(double)0,(double)0);
hexahedronPoints.InsertPoint((int)2,(double)1,(double)1,(double)0);
hexahedronPoints.InsertPoint((int)3,(double)0,(double)1,(double)0);
hexahedronPoints.InsertPoint((int)4,(double)0,(double)0,(double)1);
hexahedronPoints.InsertPoint((int)5,(double)1,(double)0,(double)1);
hexahedronPoints.InsertPoint((int)6,(double)1,(double)1,(double)1);
hexahedronPoints.InsertPoint((int)7,(double)0,(double)1,(double)1);
aHexahedron = new vtkHexahedron();
aHexahedron.GetPointIds().SetId((int)0,(int)0);
aHexahedron.GetPointIds().SetId((int)1,(int)1);
aHexahedron.GetPointIds().SetId((int)2,(int)2);
aHexahedron.GetPointIds().SetId((int)3,(int)3);
aHexahedron.GetPointIds().SetId((int)4,(int)4);
aHexahedron.GetPointIds().SetId((int)5,(int)5);
aHexahedron.GetPointIds().SetId((int)6,(int)6);
aHexahedron.GetPointIds().SetId((int)7,(int)7);
aHexahedronGrid = new vtkUnstructuredGrid();
aHexahedronGrid.Allocate((int)1,(int)1);
aHexahedronGrid.InsertNextCell((int)aHexahedron.GetCellType(),(vtkIdList)aHexahedron.GetPointIds());
aHexahedronGrid.SetPoints((vtkPoints)hexahedronPoints);
aHexahedronMapper = new vtkDataSetMapper();
aHexahedronMapper.SetInput((vtkDataSet)aHexahedronGrid);
aHexahedronActor = new vtkActor();
aHexahedronActor.SetMapper((vtkMapper)aHexahedronMapper);
aHexahedronActor.AddPosition((double)2,(double)0,(double)0);
aHexahedronActor.GetProperty().BackfaceCullingOn();
// Tetra[]
tetraPoints = new vtkPoints();
tetraPoints.SetNumberOfPoints((int)4);
tetraPoints.InsertPoint((int)0,(double)0,(double)0,(double)0);
tetraPoints.InsertPoint((int)1,(double)1,(double)0,(double)0);
tetraPoints.InsertPoint((int)2,(double)0,(double)1,(double)0);
tetraPoints.InsertPoint((int)3,(double)1,(double)1,(double)1);
aTetra = new vtkTetra();
aTetra.GetPointIds().SetId((int)0,(int)0);
aTetra.GetPointIds().SetId((int)1,(int)1);
aTetra.GetPointIds().SetId((int)2,(int)2);
aTetra.GetPointIds().SetId((int)3,(int)3);
aTetraGrid = new vtkUnstructuredGrid();
aTetraGrid.Allocate((int)1,(int)1);
aTetraGrid.InsertNextCell((int)aTetra.GetCellType(),(vtkIdList)aTetra.GetPointIds());
aTetraGrid.SetPoints((vtkPoints)tetraPoints);
aTetraMapper = new vtkDataSetMapper();
aTetraMapper.SetInput((vtkDataSet)aTetraGrid);
aTetraActor = new vtkActor();
aTetraActor.SetMapper((vtkMapper)aTetraMapper);
aTetraActor.AddPosition((double)4,(double)0,(double)0);
aTetraActor.GetProperty().BackfaceCullingOn();
// Wedge[]
wedgePoints = new vtkPoints();
wedgePoints.SetNumberOfPoints((int)6);
wedgePoints.InsertPoint((int)0,(double)0,(double)1,(double)0);
wedgePoints.InsertPoint((int)1,(double)0,(double)0,(double)0);
wedgePoints.InsertPoint((int)2,(double)0,(double).5,(double).5);
wedgePoints.InsertPoint((int)3,(double)1,(double)1,(double)0);
wedgePoints.InsertPoint((int)4,(double)1,(double)0,(double)0);
wedgePoints.InsertPoint((int)5,(double)1,(double).5,(double).5);
aWedge = new vtkWedge();
aWedge.GetPointIds().SetId((int)0,(int)0);
aWedge.GetPointIds().SetId((int)1,(int)1);
aWedge.GetPointIds().SetId((int)2,(int)2);
aWedge.GetPointIds().SetId((int)3,(int)3);
aWedge.GetPointIds().SetId((int)4,(int)4);
aWedge.GetPointIds().SetId((int)5,(int)5);
aWedgeGrid = new vtkUnstructuredGrid();
aWedgeGrid.Allocate((int)1,(int)1);
aWedgeGrid.InsertNextCell((int)aWedge.GetCellType(),(vtkIdList)aWedge.GetPointIds());
aWedgeGrid.SetPoints((vtkPoints)wedgePoints);
aWedgeMapper = new vtkDataSetMapper();
aWedgeMapper.SetInput((vtkDataSet)aWedgeGrid);
aWedgeActor = new vtkActor();
aWedgeActor.SetMapper((vtkMapper)aWedgeMapper);
aWedgeActor.AddPosition((double)6,(double)0,(double)0);
aWedgeActor.GetProperty().BackfaceCullingOn();
// Pyramid[]
pyramidPoints = new vtkPoints();
pyramidPoints.SetNumberOfPoints((int)5);
pyramidPoints.InsertPoint((int)0,(double)0,(double)0,(double)0);
pyramidPoints.InsertPoint((int)1,(double)1,(double)0,(double)0);
pyramidPoints.InsertPoint((int)2,(double)1,(double)1,(double)0);
pyramidPoints.InsertPoint((int)3,(double)0,(double)1,(double)0);
pyramidPoints.InsertPoint((int)4,(double).5,(double).5,(double)1);
aPyramid = new vtkPyramid();
aPyramid.GetPointIds().SetId((int)0,(int)0);
aPyramid.GetPointIds().SetId((int)1,(int)1);
aPyramid.GetPointIds().SetId((int)2,(int)2);
aPyramid.GetPointIds().SetId((int)3,(int)3);
aPyramid.GetPointIds().SetId((int)4,(int)4);
aPyramidGrid = new vtkUnstructuredGrid();
aPyramidGrid.Allocate((int)1,(int)1);
aPyramidGrid.InsertNextCell((int)aPyramid.GetCellType(),(vtkIdList)aPyramid.GetPointIds());
aPyramidGrid.SetPoints((vtkPoints)pyramidPoints);
aPyramidMapper = new vtkDataSetMapper();
aPyramidMapper.SetInput((vtkDataSet)aPyramidGrid);
aPyramidActor = new vtkActor();
aPyramidActor.SetMapper((vtkMapper)aPyramidMapper);
aPyramidActor.AddPosition((double)8,(double)0,(double)0);
aPyramidActor.GetProperty().BackfaceCullingOn();
// Pixel[]
pixelPoints = new vtkPoints();
pixelPoints.SetNumberOfPoints((int)4);
pixelPoints.InsertPoint((int)0,(double)0,(double)0,(double)0);
pixelPoints.InsertPoint((int)1,(double)1,(double)0,(double)0);
pixelPoints.InsertPoint((int)2,(double)0,(double)1,(double)0);
pixelPoints.InsertPoint((int)3,(double)1,(double)1,(double)0);
aPixel = new vtkPixel();
aPixel.GetPointIds().SetId((int)0,(int)0);
aPixel.GetPointIds().SetId((int)1,(int)1);
aPixel.GetPointIds().SetId((int)2,(int)2);
aPixel.GetPointIds().SetId((int)3,(int)3);
aPixelGrid = new vtkUnstructuredGrid();
aPixelGrid.Allocate((int)1,(int)1);
aPixelGrid.InsertNextCell((int)aPixel.GetCellType(),(vtkIdList)aPixel.GetPointIds());
aPixelGrid.SetPoints((vtkPoints)pixelPoints);
aPixelMapper = new vtkDataSetMapper();
aPixelMapper.SetInput((vtkDataSet)aPixelGrid);
aPixelActor = new vtkActor();
aPixelActor.SetMapper((vtkMapper)aPixelMapper);
aPixelActor.AddPosition((double)0,(double)0,(double)2);
aPixelActor.GetProperty().BackfaceCullingOn();
// Quad[]
quadPoints = new vtkPoints();
quadPoints.SetNumberOfPoints((int)4);
quadPoints.InsertPoint((int)0,(double)0,(double)0,(double)0);
quadPoints.InsertPoint((int)1,(double)1,(double)0,(double)0);
quadPoints.InsertPoint((int)2,(double)1,(double)1,(double)0);
quadPoints.InsertPoint((int)3,(double)0,(double)1,(double)0);
aQuad = new vtkQuad();
aQuad.GetPointIds().SetId((int)0,(int)0);
aQuad.GetPointIds().SetId((int)1,(int)1);
aQuad.GetPointIds().SetId((int)2,(int)2);
aQuad.GetPointIds().SetId((int)3,(int)3);
aQuadGrid = new vtkUnstructuredGrid();
aQuadGrid.Allocate((int)1,(int)1);
aQuadGrid.InsertNextCell((int)aQuad.GetCellType(),(vtkIdList)aQuad.GetPointIds());
aQuadGrid.SetPoints((vtkPoints)quadPoints);
aQuadMapper = new vtkDataSetMapper();
aQuadMapper.SetInput((vtkDataSet)aQuadGrid);
aQuadActor = new vtkActor();
aQuadActor.SetMapper((vtkMapper)aQuadMapper);
aQuadActor.AddPosition((double)2,(double)0,(double)2);
aQuadActor.GetProperty().BackfaceCullingOn();
// Triangle[]
trianglePoints = new vtkPoints();
trianglePoints.SetNumberOfPoints((int)3);
trianglePoints.InsertPoint((int)0,(double)0,(double)0,(double)0);
trianglePoints.InsertPoint((int)1,(double)1,(double)0,(double)0);
trianglePoints.InsertPoint((int)2,(double).5,(double).5,(double)0);
triangleTCoords = new vtkFloatArray();
triangleTCoords.SetNumberOfComponents((int)2);
triangleTCoords.SetNumberOfTuples((int)3);
triangleTCoords.InsertTuple2((int)0,(double)1,(double)1);
triangleTCoords.InsertTuple2((int)1,(double)2,(double)2);
triangleTCoords.InsertTuple2((int)2,(double)3,(double)3);
aTriangle = new vtkTriangle();
aTriangle.GetPointIds().SetId((int)0,(int)0);
aTriangle.GetPointIds().SetId((int)1,(int)1);
aTriangle.GetPointIds().SetId((int)2,(int)2);
aTriangleGrid = new vtkUnstructuredGrid();
aTriangleGrid.Allocate((int)1,(int)1);
aTriangleGrid.InsertNextCell((int)aTriangle.GetCellType(),(vtkIdList)aTriangle.GetPointIds());
aTriangleGrid.SetPoints((vtkPoints)trianglePoints);
aTriangleGrid.GetPointData().SetTCoords((vtkDataArray)triangleTCoords);
aTriangleMapper = new vtkDataSetMapper();
aTriangleMapper.SetInput((vtkDataSet)aTriangleGrid);
aTriangleActor = new vtkActor();
aTriangleActor.SetMapper((vtkMapper)aTriangleMapper);
aTriangleActor.AddPosition((double)4,(double)0,(double)2);
aTriangleActor.GetProperty().BackfaceCullingOn();
// Polygon[]
polygonPoints = new vtkPoints();
polygonPoints.SetNumberOfPoints((int)4);
polygonPoints.InsertPoint((int)0,(double)0,(double)0,(double)0);
polygonPoints.InsertPoint((int)1,(double)1,(double)0,(double)0);
polygonPoints.InsertPoint((int)2,(double)1,(double)1,(double)0);
polygonPoints.InsertPoint((int)3,(double)0,(double)1,(double)0);
aPolygon = new vtkPolygon();
aPolygon.GetPointIds().SetNumberOfIds((int)4);
aPolygon.GetPointIds().SetId((int)0,(int)0);
aPolygon.GetPointIds().SetId((int)1,(int)1);
aPolygon.GetPointIds().SetId((int)2,(int)2);
aPolygon.GetPointIds().SetId((int)3,(int)3);
aPolygonGrid = new vtkUnstructuredGrid();
aPolygonGrid.Allocate((int)1,(int)1);
aPolygonGrid.InsertNextCell((int)aPolygon.GetCellType(),(vtkIdList)aPolygon.GetPointIds());
aPolygonGrid.SetPoints((vtkPoints)polygonPoints);
aPolygonMapper = new vtkDataSetMapper();
aPolygonMapper.SetInput((vtkDataSet)aPolygonGrid);
aPolygonActor = new vtkActor();
aPolygonActor.SetMapper((vtkMapper)aPolygonMapper);
aPolygonActor.AddPosition((double)6,(double)0,(double)2);
aPolygonActor.GetProperty().BackfaceCullingOn();
// Triangle strip[]
triangleStripPoints = new vtkPoints();
triangleStripPoints.SetNumberOfPoints((int)5);
triangleStripPoints.InsertPoint((int)0,(double)0,(double)1,(double)0);
triangleStripPoints.InsertPoint((int)1,(double)0,(double)0,(double)0);
triangleStripPoints.InsertPoint((int)2,(double)1,(double)1,(double)0);
triangleStripPoints.InsertPoint((int)3,(double)1,(double)0,(double)0);
triangleStripPoints.InsertPoint((int)4,(double)2,(double)1,(double)0);
triangleStripTCoords = new vtkFloatArray();
triangleStripTCoords.SetNumberOfComponents((int)2);
triangleStripTCoords.SetNumberOfTuples((int)3);
triangleStripTCoords.InsertTuple2((int)0,(double)1,(double)1);
triangleStripTCoords.InsertTuple2((int)1,(double)2,(double)2);
triangleStripTCoords.InsertTuple2((int)2,(double)3,(double)3);
triangleStripTCoords.InsertTuple2((int)3,(double)4,(double)4);
triangleStripTCoords.InsertTuple2((int)4,(double)5,(double)5);
aTriangleStrip = new vtkTriangleStrip();
aTriangleStrip.GetPointIds().SetNumberOfIds((int)5);
aTriangleStrip.GetPointIds().SetId((int)0,(int)0);
aTriangleStrip.GetPointIds().SetId((int)1,(int)1);
aTriangleStrip.GetPointIds().SetId((int)2,(int)2);
aTriangleStrip.GetPointIds().SetId((int)3,(int)3);
aTriangleStrip.GetPointIds().SetId((int)4,(int)4);
aTriangleStripGrid = new vtkUnstructuredGrid();
aTriangleStripGrid.Allocate((int)1,(int)1);
aTriangleStripGrid.InsertNextCell((int)aTriangleStrip.GetCellType(),(vtkIdList)aTriangleStrip.GetPointIds());
aTriangleStripGrid.SetPoints((vtkPoints)triangleStripPoints);
aTriangleStripGrid.GetPointData().SetTCoords((vtkDataArray)triangleStripTCoords);
aTriangleStripMapper = new vtkDataSetMapper();
aTriangleStripMapper.SetInput((vtkDataSet)aTriangleStripGrid);
aTriangleStripActor = new vtkActor();
aTriangleStripActor.SetMapper((vtkMapper)aTriangleStripMapper);
aTriangleStripActor.AddPosition((double)8,(double)0,(double)2);
aTriangleStripActor.GetProperty().BackfaceCullingOn();
// Line[]
linePoints = new vtkPoints();
linePoints.SetNumberOfPoints((int)2);
linePoints.InsertPoint((int)0,(double)0,(double)0,(double)0);
linePoints.InsertPoint((int)1,(double)1,(double)1,(double)0);
aLine = new vtkLine();
aLine.GetPointIds().SetId((int)0,(int)0);
aLine.GetPointIds().SetId((int)1,(int)1);
aLineGrid = new vtkUnstructuredGrid();
aLineGrid.Allocate((int)1,(int)1);
aLineGrid.InsertNextCell((int)aLine.GetCellType(),(vtkIdList)aLine.GetPointIds());
aLineGrid.SetPoints((vtkPoints)linePoints);
aLineMapper = new vtkDataSetMapper();
aLineMapper.SetInput((vtkDataSet)aLineGrid);
aLineActor = new vtkActor();
aLineActor.SetMapper((vtkMapper)aLineMapper);
aLineActor.AddPosition((double)0,(double)0,(double)4);
aLineActor.GetProperty().BackfaceCullingOn();
// Polyline[]
polyLinePoints = new vtkPoints();
polyLinePoints.SetNumberOfPoints((int)3);
polyLinePoints.InsertPoint((int)0,(double)0,(double)0,(double)0);
polyLinePoints.InsertPoint((int)1,(double)1,(double)1,(double)0);
polyLinePoints.InsertPoint((int)2,(double)1,(double)0,(double)0);
aPolyLine = new vtkPolyLine();
aPolyLine.GetPointIds().SetNumberOfIds((int)3);
aPolyLine.GetPointIds().SetId((int)0,(int)0);
aPolyLine.GetPointIds().SetId((int)1,(int)1);
aPolyLine.GetPointIds().SetId((int)2,(int)2);
aPolyLineGrid = new vtkUnstructuredGrid();
aPolyLineGrid.Allocate((int)1,(int)1);
aPolyLineGrid.InsertNextCell((int)aPolyLine.GetCellType(),(vtkIdList)aPolyLine.GetPointIds());
aPolyLineGrid.SetPoints((vtkPoints)polyLinePoints);
aPolyLineMapper = new vtkDataSetMapper();
aPolyLineMapper.SetInput((vtkDataSet)aPolyLineGrid);
aPolyLineActor = new vtkActor();
aPolyLineActor.SetMapper((vtkMapper)aPolyLineMapper);
aPolyLineActor.AddPosition((double)2,(double)0,(double)4);
aPolyLineActor.GetProperty().BackfaceCullingOn();
// Vertex[]
vertexPoints = new vtkPoints();
vertexPoints.SetNumberOfPoints((int)1);
vertexPoints.InsertPoint((int)0,(double)0,(double)0,(double)0);
aVertex = new vtkVertex();
aVertex.GetPointIds().SetId((int)0,(int)0);
aVertexGrid = new vtkUnstructuredGrid();
aVertexGrid.Allocate((int)1,(int)1);
aVertexGrid.InsertNextCell((int)aVertex.GetCellType(),(vtkIdList)aVertex.GetPointIds());
aVertexGrid.SetPoints((vtkPoints)vertexPoints);
aVertexMapper = new vtkDataSetMapper();
aVertexMapper.SetInput((vtkDataSet)aVertexGrid);
aVertexActor = new vtkActor();
aVertexActor.SetMapper((vtkMapper)aVertexMapper);
aVertexActor.AddPosition((double)0,(double)0,(double)6);
aVertexActor.GetProperty().BackfaceCullingOn();
// Polyvertex[]
polyVertexPoints = new vtkPoints();
polyVertexPoints.SetNumberOfPoints((int)3);
polyVertexPoints.InsertPoint((int)0,(double)0,(double)0,(double)0);
polyVertexPoints.InsertPoint((int)1,(double)1,(double)0,(double)0);
polyVertexPoints.InsertPoint((int)2,(double)1,(double)1,(double)0);
aPolyVertex = new vtkPolyVertex();
aPolyVertex.GetPointIds().SetNumberOfIds((int)3);
aPolyVertex.GetPointIds().SetId((int)0,(int)0);
aPolyVertex.GetPointIds().SetId((int)1,(int)1);
aPolyVertex.GetPointIds().SetId((int)2,(int)2);
aPolyVertexGrid = new vtkUnstructuredGrid();
aPolyVertexGrid.Allocate((int)1,(int)1);
aPolyVertexGrid.InsertNextCell((int)aPolyVertex.GetCellType(),(vtkIdList)aPolyVertex.GetPointIds());
aPolyVertexGrid.SetPoints((vtkPoints)polyVertexPoints);
aPolyVertexMapper = new vtkDataSetMapper();
aPolyVertexMapper.SetInput((vtkDataSet)aPolyVertexGrid);
aPolyVertexActor = new vtkActor();
aPolyVertexActor.SetMapper((vtkMapper)aPolyVertexMapper);
aPolyVertexActor.AddPosition((double)2,(double)0,(double)6);
aPolyVertexActor.GetProperty().BackfaceCullingOn();
// Pentagonal prism[]
pentaPoints = new vtkPoints();
pentaPoints.SetNumberOfPoints((int)10);
pentaPoints.InsertPoint((int)0,(double)0.25,(double)0.0,(double)0.0);
pentaPoints.InsertPoint((int)1,(double)0.75,(double)0.0,(double)0.0);
pentaPoints.InsertPoint((int)2,(double)1.0,(double)0.5,(double)0.0);
pentaPoints.InsertPoint((int)3,(double)0.5,(double)1.0,(double)0.0);
pentaPoints.InsertPoint((int)4,(double)0.0,(double)0.5,(double)0.0);
pentaPoints.InsertPoint((int)5,(double)0.25,(double)0.0,(double)1.0);
pentaPoints.InsertPoint((int)6,(double)0.75,(double)0.0,(double)1.0);
pentaPoints.InsertPoint((int)7,(double)1.0,(double)0.5,(double)1.0);
pentaPoints.InsertPoint((int)8,(double)0.5,(double)1.0,(double)1.0);
pentaPoints.InsertPoint((int)9,(double)0.0,(double)0.5,(double)1.0);
aPenta = new vtkPentagonalPrism();
aPenta.GetPointIds().SetId((int)0,(int)0);
aPenta.GetPointIds().SetId((int)1,(int)1);
aPenta.GetPointIds().SetId((int)2,(int)2);
aPenta.GetPointIds().SetId((int)3,(int)3);
aPenta.GetPointIds().SetId((int)4,(int)4);
aPenta.GetPointIds().SetId((int)5,(int)5);
aPenta.GetPointIds().SetId((int)6,(int)6);
aPenta.GetPointIds().SetId((int)7,(int)7);
aPenta.GetPointIds().SetId((int)8,(int)8);
aPenta.GetPointIds().SetId((int)9,(int)9);
aPentaGrid = new vtkUnstructuredGrid();
aPentaGrid.Allocate((int)1,(int)1);
aPentaGrid.InsertNextCell((int)aPenta.GetCellType(),(vtkIdList)aPenta.GetPointIds());
aPentaGrid.SetPoints((vtkPoints)pentaPoints);
aPentaMapper = new vtkDataSetMapper();
aPentaMapper.SetInput((vtkDataSet)aPentaGrid);
aPentaActor = new vtkActor();
aPentaActor.SetMapper((vtkMapper)aPentaMapper);
aPentaActor.AddPosition((double)10,(double)0,(double)0);
aPentaActor.GetProperty().BackfaceCullingOn();
// Hexagonal prism[]
hexaPoints = new vtkPoints();
hexaPoints.SetNumberOfPoints((int)12);
hexaPoints.InsertPoint((int)0,(double)0.0,(double)0.0,(double)0.0);
hexaPoints.InsertPoint((int)1,(double)0.5,(double)0.0,(double)0.0);
hexaPoints.InsertPoint((int)2,(double)1.0,(double)0.5,(double)0.0);
hexaPoints.InsertPoint((int)3,(double)1.0,(double)1.0,(double)0.0);
hexaPoints.InsertPoint((int)4,(double)0.5,(double)1.0,(double)0.0);
hexaPoints.InsertPoint((int)5,(double)0.0,(double)0.5,(double)0.0);
hexaPoints.InsertPoint((int)6,(double)0.0,(double)0.0,(double)1.0);
hexaPoints.InsertPoint((int)7,(double)0.5,(double)0.0,(double)1.0);
hexaPoints.InsertPoint((int)8,(double)1.0,(double)0.5,(double)1.0);
hexaPoints.InsertPoint((int)9,(double)1.0,(double)1.0,(double)1.0);
hexaPoints.InsertPoint((int)10,(double)0.5,(double)1.0,(double)1.0);
hexaPoints.InsertPoint((int)11,(double)0.0,(double)0.5,(double)1.0);
aHexa = new vtkHexagonalPrism();
aHexa.GetPointIds().SetId((int)0,(int)0);
aHexa.GetPointIds().SetId((int)1,(int)1);
aHexa.GetPointIds().SetId((int)2,(int)2);
aHexa.GetPointIds().SetId((int)3,(int)3);
aHexa.GetPointIds().SetId((int)4,(int)4);
aHexa.GetPointIds().SetId((int)5,(int)5);
aHexa.GetPointIds().SetId((int)6,(int)6);
aHexa.GetPointIds().SetId((int)7,(int)7);
aHexa.GetPointIds().SetId((int)8,(int)8);
aHexa.GetPointIds().SetId((int)9,(int)9);
aHexa.GetPointIds().SetId((int)10,(int)10);
aHexa.GetPointIds().SetId((int)11,(int)11);
aHexaGrid = new vtkUnstructuredGrid();
aHexaGrid.Allocate((int)1,(int)1);
aHexaGrid.InsertNextCell((int)aHexa.GetCellType(),(vtkIdList)aHexa.GetPointIds());
aHexaGrid.SetPoints((vtkPoints)hexaPoints);
aHexaMapper = new vtkDataSetMapper();
aHexaMapper.SetInput((vtkDataSet)aHexaGrid);
aHexaActor = new vtkActor();
aHexaActor.SetMapper((vtkMapper)aHexaMapper);
aHexaActor.AddPosition((double)12,(double)0,(double)0);
aHexaActor.GetProperty().BackfaceCullingOn();
ren1.SetBackground((double)1,(double)1,(double)1);
ren1.AddActor((vtkProp)aVoxelActor);
aVoxelActor.GetProperty().SetDiffuseColor((double)1,(double)0,(double)0);
ren1.AddActor((vtkProp)aHexahedronActor);
aHexahedronActor.GetProperty().SetDiffuseColor((double)1,(double)1,(double)0);
ren1.AddActor((vtkProp)aTetraActor);
aTetraActor.GetProperty().SetDiffuseColor((double)0,(double)1,(double)0);
ren1.AddActor((vtkProp)aWedgeActor);
aWedgeActor.GetProperty().SetDiffuseColor((double)0,(double)1,(double)1);
ren1.AddActor((vtkProp)aPyramidActor);
aPyramidActor.GetProperty().SetDiffuseColor((double)1,(double)0,(double)1);
ren1.AddActor((vtkProp)aPixelActor);
aPixelActor.GetProperty().SetDiffuseColor((double)0,(double)1,(double)1);
ren1.AddActor((vtkProp)aQuadActor);
aQuadActor.GetProperty().SetDiffuseColor((double)1,(double)0,(double)1);
ren1.AddActor((vtkProp)aTriangleActor);
aTriangleActor.GetProperty().SetDiffuseColor((double).3,(double)1,(double).5);
ren1.AddActor((vtkProp)aPolygonActor);
aPolygonActor.GetProperty().SetDiffuseColor((double)1,(double).4,(double).5);
ren1.AddActor((vtkProp)aTriangleStripActor);
aTriangleStripActor.GetProperty().SetDiffuseColor((double).3,(double).7,(double)1);
ren1.AddActor((vtkProp)aLineActor);
aLineActor.GetProperty().SetDiffuseColor((double).2,(double)1,(double)1);
ren1.AddActor((vtkProp)aPolyLineActor);
aPolyLineActor.GetProperty().SetDiffuseColor((double)1,(double)1,(double)1);
ren1.AddActor((vtkProp)aVertexActor);
aVertexActor.GetProperty().SetDiffuseColor((double)1,(double)1,(double)1);
ren1.AddActor((vtkProp)aPolyVertexActor);
aPolyVertexActor.GetProperty().SetDiffuseColor((double)1,(double)1,(double)1);
ren1.AddActor((vtkProp)aPentaActor);
aPentaActor.GetProperty().SetDiffuseColor((double)1,(double)1,(double)0);
ren1.AddActor((vtkProp)aHexaActor);
aHexaActor.GetProperty().SetDiffuseColor((double)1,(double)1,(double)0);
//[]
// get the cell center of each type and put a glyph there[]
//[]
ball = new vtkSphereSource();
ball.SetRadius((double).2);
bool tryWorked = false;
aVoxelScalars = new vtkFloatArray();
N = aVoxelGrid.GetNumberOfPoints();
aVoxelScalar = new vtkFloatArray();
aVoxelScalar.SetNumberOfTuples((int)N);
aVoxelScalar.SetNumberOfComponents(1);
i = 0;
while((i) < N)
{
aVoxelScalar.SetValue(i,0);
i = i + 1;
}
aVoxelScalar.SetValue(0,4);
aVoxelGrid.GetPointData().SetScalars(aVoxelScalar);
aHexahedronScalars = new vtkFloatArray();
N = aHexahedronGrid.GetNumberOfPoints();
aHexahedronScalar = new vtkFloatArray();
aHexahedronScalar.SetNumberOfTuples((int)N);
aHexahedronScalar.SetNumberOfComponents(1);
i = 0;
while((i) < N)
{
aHexahedronScalar.SetValue(i,0);
i = i + 1;
}
aHexahedronScalar.SetValue(0,4);
aHexahedronGrid.GetPointData().SetScalars(aHexahedronScalar);
aWedgeScalars = new vtkFloatArray();
N = aWedgeGrid.GetNumberOfPoints();
aWedgeScalar = new vtkFloatArray();
aWedgeScalar.SetNumberOfTuples((int)N);
aWedgeScalar.SetNumberOfComponents(1);
i = 0;
while((i) < N)
{
aWedgeScalar.SetValue(i,0);
i = i + 1;
}
aWedgeScalar.SetValue(0,4);
aWedgeGrid.GetPointData().SetScalars(aWedgeScalar);
aPyramidScalars = new vtkFloatArray();
N = aPyramidGrid.GetNumberOfPoints();
aPyramidScalar = new vtkFloatArray();
aPyramidScalar.SetNumberOfTuples((int)N);
aPyramidScalar.SetNumberOfComponents(1);
i = 0;
while((i) < N)
{
aPyramidScalar.SetValue(i,0);
i = i + 1;
}
aPyramidScalar.SetValue(0,4);
aPyramidGrid.GetPointData().SetScalars(aPyramidScalar);
aTetraScalars = new vtkFloatArray();
N = aTetraGrid.GetNumberOfPoints();
aTetraScalar = new vtkFloatArray();
aTetraScalar.SetNumberOfTuples((int)N);
aTetraScalar.SetNumberOfComponents(1);
i = 0;
while((i) < N)
{
aTetraScalar.SetValue(i,0);
i = i + 1;
}
aTetraScalar.SetValue(0,4);
aTetraGrid.GetPointData().SetScalars(aTetraScalar);
aQuadScalars = new vtkFloatArray();
N = aQuadGrid.GetNumberOfPoints();
aQuadScalar = new vtkFloatArray();
aQuadScalar.SetNumberOfTuples((int)N);
aQuadScalar.SetNumberOfComponents(1);
i = 0;
while((i) < N)
{
aQuadScalar.SetValue(i,0);
i = i + 1;
}
aQuadScalar.SetValue(0,4);
aQuadGrid.GetPointData().SetScalars(aQuadScalar);
aTriangleScalars = new vtkFloatArray();
N = aTriangleGrid.GetNumberOfPoints();
aTriangleScalar = new vtkFloatArray();
aTriangleScalar.SetNumberOfTuples((int)N);
aTriangleScalar.SetNumberOfComponents(1);
i = 0;
while((i) < N)
{
aTriangleScalar.SetValue(i,0);
i = i + 1;
}
aTriangleScalar.SetValue(0,4);
aTriangleGrid.GetPointData().SetScalars(aTriangleScalar);
aTriangleStripScalars = new vtkFloatArray();
N = aTriangleStripGrid.GetNumberOfPoints();
aTriangleStripScalar = new vtkFloatArray();
aTriangleStripScalar.SetNumberOfTuples((int)N);
aTriangleStripScalar.SetNumberOfComponents(1);
i = 0;
while((i) < N)
{
aTriangleStripScalar.SetValue(i,0);
i = i + 1;
}
aTriangleStripScalar.SetValue(0,4);
aTriangleStripGrid.GetPointData().SetScalars(aTriangleStripScalar);
aLineScalars = new vtkFloatArray();
N = aLineGrid.GetNumberOfPoints();
aLineScalar = new vtkFloatArray();
aLineScalar.SetNumberOfTuples((int)N);
aLineScalar.SetNumberOfComponents(1);
i = 0;
while((i) < N)
{
aLineScalar.SetValue(i,0);
i = i + 1;
}
aLineScalar.SetValue(0,4);
aLineGrid.GetPointData().SetScalars(aLineScalar);
aPolyLineScalars = new vtkFloatArray();
N = aPolyLineGrid.GetNumberOfPoints();
aPolyLineScalar = new vtkFloatArray();
aPolyLineScalar.SetNumberOfTuples((int)N);
aPolyLineScalar.SetNumberOfComponents(1);
i = 0;
while((i) < N)
{
aPolyLineScalar.SetValue(i,0);
i = i + 1;
}
aPolyLineScalar.SetValue(0,4);
aPolyLineGrid.GetPointData().SetScalars(aPolyLineScalar);
aVertexScalars = new vtkFloatArray();
N = aVertexGrid.GetNumberOfPoints();
aVertexScalar = new vtkFloatArray();
aVertexScalar.SetNumberOfTuples((int)N);
aVertexScalar.SetNumberOfComponents(1);
i = 0;
while((i) < N)
{
aVertexScalar.SetValue(i,0);
i = i + 1;
}
aVertexScalar.SetValue(0,4);
aVertexGrid.GetPointData().SetScalars(aVertexScalar);
aPolyVertexScalars = new vtkFloatArray();
N = aPolyVertexGrid.GetNumberOfPoints();
aPolyVertexScalar = new vtkFloatArray();
aPolyVertexScalar.SetNumberOfTuples((int)N);
aPolyVertexScalar.SetNumberOfComponents(1);
i = 0;
while((i) < N)
{
aPolyVertexScalar.SetValue(i,0);
i = i + 1;
}
aPolyVertexScalar.SetValue(0,4);
aPolyVertexGrid.GetPointData().SetScalars(aPolyVertexScalar);
aPixelScalars = new vtkFloatArray();
N = aPixelGrid.GetNumberOfPoints();
aPixelScalar = new vtkFloatArray();
aPixelScalar.SetNumberOfTuples((int)N);
aPixelScalar.SetNumberOfComponents(1);
i = 0;
while((i) < N)
{
aPixelScalar.SetValue(i,0);
i = i + 1;
}
aPixelScalar.SetValue(0,4);
aPixelGrid.GetPointData().SetScalars(aPixelScalar);
aPolygonScalars = new vtkFloatArray();
N = aPolygonGrid.GetNumberOfPoints();
aPolygonScalar = new vtkFloatArray();
aPolygonScalar.SetNumberOfTuples((int)N);
aPolygonScalar.SetNumberOfComponents(1);
i = 0;
while((i) < N)
{
aPolygonScalar.SetValue(i,0);
i = i + 1;
}
aPolygonScalar.SetValue(0,4);
aPolygonGrid.GetPointData().SetScalars(aPolygonScalar);
aPentaScalars = new vtkFloatArray();
N = aPentaGrid.GetNumberOfPoints();
aPentaScalar = new vtkFloatArray();
aPentaScalar.SetNumberOfTuples((int)N);
aPentaScalar.SetNumberOfComponents(1);
i = 0;
while((i) < N)
{
aPentaScalar.SetValue(i,0);
i = i + 1;
}
aPentaScalar.SetValue(0,4);
aPentaGrid.GetPointData().SetScalars(aPentaScalar);
aHexaScalars = new vtkFloatArray();
N = aHexaGrid.GetNumberOfPoints();
aHexaScalar = new vtkFloatArray();
aHexaScalar.SetNumberOfTuples((int)N);
aHexaScalar.SetNumberOfComponents(1);
i = 0;
while((i) < N)
{
aHexaScalar.SetValue(i,0);
i = i + 1;
}
aHexaScalar.SetValue(0,4);
aHexaGrid.GetPointData().SetScalars(aHexaScalar);
// write to the temp directory if possible, otherwise use .[]
dir = ".";
dir = TclToCsScriptTestDriver.GetTempDirectory();
aVoxelderivs = new vtkCellDerivatives();
aVoxelderivs.SetInput(aVoxelGrid);
aVoxelderivs.SetVectorModeToComputeGradient();
FileName = dir;
FileName += "/aVoxel";
FileName += ".vtk";
// make sure the directory is writeable first[]
tryWorked = false;
try
{
channel = new StreamWriter("" + (dir.ToString()) + "/test.tmp");
tryWorked = true;
}
catch(Exception)
{
tryWorked = false;
}
if(tryWorked)
{
channel.Close();
File.Delete("" + (dir.ToString()) + "/test.tmp");
aVoxelWriter = new vtkUnstructuredGridWriter();
aVoxelWriter.SetInputConnection(aVoxelderivs.GetOutputPort());
aVoxelWriter.SetFileName(FileName);
aVoxelWriter.Write();
// delete the file[]
File.Delete("FileName");
}
aVoxelCenters = new vtkCellCenters();
aVoxelCenters.SetInputConnection(aVoxelderivs.GetOutputPort());
aVoxelCenters.VertexCellsOn();
aVoxelhog = new vtkHedgeHog();
aVoxelhog.SetInputConnection(aVoxelCenters.GetOutputPort());
aVoxelmapHog = vtkPolyDataMapper.New();
aVoxelmapHog.SetInputConnection(aVoxelhog.GetOutputPort());
aVoxelmapHog.SetScalarModeToUseCellData();
aVoxelmapHog.ScalarVisibilityOff();
aVoxelhogActor = new vtkActor();
aVoxelhogActor.SetMapper(aVoxelmapHog);
aVoxelhogActor.GetProperty().SetColor(0,1,0);
aVoxelGlyph3D = new vtkGlyph3D();
aVoxelGlyph3D.SetInputConnection(aVoxelCenters.GetOutputPort());
aVoxelGlyph3D.SetSource(ball.GetOutput());
aVoxelCentersMapper = vtkPolyDataMapper.New();
aVoxelCentersMapper.SetInputConnection(aVoxelGlyph3D.GetOutputPort());
aVoxelCentersActor = new vtkActor();
aVoxelCentersActor.SetMapper(aVoxelCentersMapper);
aVoxelhogActor.SetPosition(aVoxelActor.GetPosition()[0],aVoxelActor.GetPosition()[1],aVoxelActor.GetPosition()[2]);
ren1.AddActor((vtkProp)aVoxelhogActor);
aVoxelhogActor.GetProperty().SetRepresentationToWireframe();
aHexahedronderivs = new vtkCellDerivatives();
aHexahedronderivs.SetInput(aHexahedronGrid);
aHexahedronderivs.SetVectorModeToComputeGradient();
FileName = dir;
FileName += "/aHexahedron";
FileName += ".vtk";
// make sure the directory is writeable first[]
tryWorked = false;
try
{
channel = new StreamWriter("" + (dir.ToString()) + "/test.tmp");
tryWorked = true;
}
catch(Exception)
{
tryWorked = false;
}
if(tryWorked)
{
channel.Close();
File.Delete("" + (dir.ToString()) + "/test.tmp");
aHexahedronWriter = new vtkUnstructuredGridWriter();
aHexahedronWriter.SetInputConnection(aHexahedronderivs.GetOutputPort());
aHexahedronWriter.SetFileName(FileName);
aHexahedronWriter.Write();
// delete the file[]
File.Delete("FileName");
}
aHexahedronCenters = new vtkCellCenters();
aHexahedronCenters.SetInputConnection(aHexahedronderivs.GetOutputPort());
aHexahedronCenters.VertexCellsOn();
aHexahedronhog = new vtkHedgeHog();
aHexahedronhog.SetInputConnection(aHexahedronCenters.GetOutputPort());
aHexahedronmapHog = vtkPolyDataMapper.New();
aHexahedronmapHog.SetInputConnection(aHexahedronhog.GetOutputPort());
aHexahedronmapHog.SetScalarModeToUseCellData();
aHexahedronmapHog.ScalarVisibilityOff();
aHexahedronhogActor = new vtkActor();
aHexahedronhogActor.SetMapper(aHexahedronmapHog);
aHexahedronhogActor.GetProperty().SetColor(0,1,0);
aHexahedronGlyph3D = new vtkGlyph3D();
aHexahedronGlyph3D.SetInputConnection(aHexahedronCenters.GetOutputPort());
aHexahedronGlyph3D.SetSource(ball.GetOutput());
aHexahedronCentersMapper = vtkPolyDataMapper.New();
aHexahedronCentersMapper.SetInputConnection(aHexahedronGlyph3D.GetOutputPort());
aHexahedronCentersActor = new vtkActor();
aHexahedronCentersActor.SetMapper(aHexahedronCentersMapper);
aHexahedronhogActor.SetPosition(aHexahedronActor.GetPosition()[0],aHexahedronActor.GetPosition()[1],aHexahedronActor.GetPosition()[2]);
ren1.AddActor((vtkProp)aHexahedronhogActor);
aHexahedronhogActor.GetProperty().SetRepresentationToWireframe();
aWedgederivs = new vtkCellDerivatives();
aWedgederivs.SetInput(aWedgeGrid);
aWedgederivs.SetVectorModeToComputeGradient();
FileName = dir;
FileName += "/aWedge";
FileName += ".vtk";
// make sure the directory is writeable first[]
tryWorked = false;
try
{
channel = new StreamWriter("" + (dir.ToString()) + "/test.tmp");
tryWorked = true;
}
catch(Exception)
{
tryWorked = false;
}
if(tryWorked)
{
channel.Close();
File.Delete("" + (dir.ToString()) + "/test.tmp");
aWedgeWriter = new vtkUnstructuredGridWriter();
aWedgeWriter.SetInputConnection(aWedgederivs.GetOutputPort());
aWedgeWriter.SetFileName(FileName);
aWedgeWriter.Write();
// delete the file[]
File.Delete("FileName");
}
aWedgeCenters = new vtkCellCenters();
aWedgeCenters.SetInputConnection(aWedgederivs.GetOutputPort());
aWedgeCenters.VertexCellsOn();
aWedgehog = new vtkHedgeHog();
aWedgehog.SetInputConnection(aWedgeCenters.GetOutputPort());
aWedgemapHog = vtkPolyDataMapper.New();
aWedgemapHog.SetInputConnection(aWedgehog.GetOutputPort());
aWedgemapHog.SetScalarModeToUseCellData();
aWedgemapHog.ScalarVisibilityOff();
aWedgehogActor = new vtkActor();
aWedgehogActor.SetMapper(aWedgemapHog);
aWedgehogActor.GetProperty().SetColor(0,1,0);
aWedgeGlyph3D = new vtkGlyph3D();
aWedgeGlyph3D.SetInputConnection(aWedgeCenters.GetOutputPort());
aWedgeGlyph3D.SetSource(ball.GetOutput());
aWedgeCentersMapper = vtkPolyDataMapper.New();
aWedgeCentersMapper.SetInputConnection(aWedgeGlyph3D.GetOutputPort());
aWedgeCentersActor = new vtkActor();
aWedgeCentersActor.SetMapper(aWedgeCentersMapper);
aWedgehogActor.SetPosition(aWedgeActor.GetPosition()[0],aWedgeActor.GetPosition()[1],aWedgeActor.GetPosition()[2]);
ren1.AddActor((vtkProp)aWedgehogActor);
aWedgehogActor.GetProperty().SetRepresentationToWireframe();
aPyramidderivs = new vtkCellDerivatives();
aPyramidderivs.SetInput(aPyramidGrid);
aPyramidderivs.SetVectorModeToComputeGradient();
FileName = dir;
FileName += "/aPyramid";
FileName += ".vtk";
// make sure the directory is writeable first[]
tryWorked = false;
try
{
channel = new StreamWriter("" + (dir.ToString()) + "/test.tmp");
tryWorked = true;
}
catch(Exception)
{
tryWorked = false;
}
if(tryWorked)
{
channel.Close();
File.Delete("" + (dir.ToString()) + "/test.tmp");
aPyramidWriter = new vtkUnstructuredGridWriter();
aPyramidWriter.SetInputConnection(aPyramidderivs.GetOutputPort());
aPyramidWriter.SetFileName(FileName);
aPyramidWriter.Write();
// delete the file[]
File.Delete("FileName");
}
aPyramidCenters = new vtkCellCenters();
aPyramidCenters.SetInputConnection(aPyramidderivs.GetOutputPort());
aPyramidCenters.VertexCellsOn();
aPyramidhog = new vtkHedgeHog();
aPyramidhog.SetInputConnection(aPyramidCenters.GetOutputPort());
aPyramidmapHog = vtkPolyDataMapper.New();
aPyramidmapHog.SetInputConnection(aPyramidhog.GetOutputPort());
aPyramidmapHog.SetScalarModeToUseCellData();
aPyramidmapHog.ScalarVisibilityOff();
aPyramidhogActor = new vtkActor();
aPyramidhogActor.SetMapper(aPyramidmapHog);
aPyramidhogActor.GetProperty().SetColor(0,1,0);
aPyramidGlyph3D = new vtkGlyph3D();
aPyramidGlyph3D.SetInputConnection(aPyramidCenters.GetOutputPort());
aPyramidGlyph3D.SetSource(ball.GetOutput());
aPyramidCentersMapper = vtkPolyDataMapper.New();
aPyramidCentersMapper.SetInputConnection(aPyramidGlyph3D.GetOutputPort());
aPyramidCentersActor = new vtkActor();
aPyramidCentersActor.SetMapper(aPyramidCentersMapper);
aPyramidhogActor.SetPosition(aPyramidActor.GetPosition()[0],aPyramidActor.GetPosition()[1],aPyramidActor.GetPosition()[2]);
ren1.AddActor((vtkProp)aPyramidhogActor);
aPyramidhogActor.GetProperty().SetRepresentationToWireframe();
aTetraderivs = new vtkCellDerivatives();
aTetraderivs.SetInput(aTetraGrid);
aTetraderivs.SetVectorModeToComputeGradient();
FileName = dir;
FileName += "/aTetra";
FileName += ".vtk";
// make sure the directory is writeable first[]
tryWorked = false;
try
{
channel = new StreamWriter("" + (dir.ToString()) + "/test.tmp");
tryWorked = true;
}
catch(Exception)
{
tryWorked = false;
}
if(tryWorked)
{
channel.Close();
File.Delete("" + (dir.ToString()) + "/test.tmp");
aTetraWriter = new vtkUnstructuredGridWriter();
aTetraWriter.SetInputConnection(aTetraderivs.GetOutputPort());
aTetraWriter.SetFileName(FileName);
aTetraWriter.Write();
// delete the file[]
File.Delete("FileName");
}
aTetraCenters = new vtkCellCenters();
aTetraCenters.SetInputConnection(aTetraderivs.GetOutputPort());
aTetraCenters.VertexCellsOn();
aTetrahog = new vtkHedgeHog();
aTetrahog.SetInputConnection(aTetraCenters.GetOutputPort());
aTetramapHog = vtkPolyDataMapper.New();
aTetramapHog.SetInputConnection(aTetrahog.GetOutputPort());
aTetramapHog.SetScalarModeToUseCellData();
aTetramapHog.ScalarVisibilityOff();
aTetrahogActor = new vtkActor();
aTetrahogActor.SetMapper(aTetramapHog);
aTetrahogActor.GetProperty().SetColor(0,1,0);
aTetraGlyph3D = new vtkGlyph3D();
aTetraGlyph3D.SetInputConnection(aTetraCenters.GetOutputPort());
aTetraGlyph3D.SetSource(ball.GetOutput());
aTetraCentersMapper = vtkPolyDataMapper.New();
aTetraCentersMapper.SetInputConnection(aTetraGlyph3D.GetOutputPort());
aTetraCentersActor = new vtkActor();
aTetraCentersActor.SetMapper(aTetraCentersMapper);
aTetrahogActor.SetPosition(aTetraActor.GetPosition()[0],aTetraActor.GetPosition()[1],aTetraActor.GetPosition()[2]);
ren1.AddActor((vtkProp)aTetrahogActor);
aTetrahogActor.GetProperty().SetRepresentationToWireframe();
aQuadderivs = new vtkCellDerivatives();
aQuadderivs.SetInput(aQuadGrid);
aQuadderivs.SetVectorModeToComputeGradient();
FileName = dir;
FileName += "/aQuad";
FileName += ".vtk";
// make sure the directory is writeable first[]
tryWorked = false;
try
{
channel = new StreamWriter("" + (dir.ToString()) + "/test.tmp");
tryWorked = true;
}
catch(Exception)
{
tryWorked = false;
}
if(tryWorked)
{
channel.Close();
File.Delete("" + (dir.ToString()) + "/test.tmp");
aQuadWriter = new vtkUnstructuredGridWriter();
aQuadWriter.SetInputConnection(aQuadderivs.GetOutputPort());
aQuadWriter.SetFileName(FileName);
aQuadWriter.Write();
// delete the file[]
File.Delete("FileName");
}
aQuadCenters = new vtkCellCenters();
aQuadCenters.SetInputConnection(aQuadderivs.GetOutputPort());
aQuadCenters.VertexCellsOn();
aQuadhog = new vtkHedgeHog();
aQuadhog.SetInputConnection(aQuadCenters.GetOutputPort());
aQuadmapHog = vtkPolyDataMapper.New();
aQuadmapHog.SetInputConnection(aQuadhog.GetOutputPort());
aQuadmapHog.SetScalarModeToUseCellData();
aQuadmapHog.ScalarVisibilityOff();
aQuadhogActor = new vtkActor();
aQuadhogActor.SetMapper(aQuadmapHog);
aQuadhogActor.GetProperty().SetColor(0,1,0);
aQuadGlyph3D = new vtkGlyph3D();
aQuadGlyph3D.SetInputConnection(aQuadCenters.GetOutputPort());
aQuadGlyph3D.SetSource(ball.GetOutput());
aQuadCentersMapper = vtkPolyDataMapper.New();
aQuadCentersMapper.SetInputConnection(aQuadGlyph3D.GetOutputPort());
aQuadCentersActor = new vtkActor();
aQuadCentersActor.SetMapper(aQuadCentersMapper);
aQuadhogActor.SetPosition(aQuadActor.GetPosition()[0],aQuadActor.GetPosition()[1],aQuadActor.GetPosition()[2]);
ren1.AddActor((vtkProp)aQuadhogActor);
aQuadhogActor.GetProperty().SetRepresentationToWireframe();
aTrianglederivs = new vtkCellDerivatives();
aTrianglederivs.SetInput(aTriangleGrid);
aTrianglederivs.SetVectorModeToComputeGradient();
FileName = dir;
FileName += "/aTriangle";
FileName += ".vtk";
// make sure the directory is writeable first[]
tryWorked = false;
try
{
channel = new StreamWriter("" + (dir.ToString()) + "/test.tmp");
tryWorked = true;
}
catch(Exception)
{
tryWorked = false;
}
if(tryWorked)
{
channel.Close();
File.Delete("" + (dir.ToString()) + "/test.tmp");
aTriangleWriter = new vtkUnstructuredGridWriter();
aTriangleWriter.SetInputConnection(aTrianglederivs.GetOutputPort());
aTriangleWriter.SetFileName(FileName);
aTriangleWriter.Write();
// delete the file[]
File.Delete("FileName");
}
aTriangleCenters = new vtkCellCenters();
aTriangleCenters.SetInputConnection(aTrianglederivs.GetOutputPort());
aTriangleCenters.VertexCellsOn();
aTrianglehog = new vtkHedgeHog();
aTrianglehog.SetInputConnection(aTriangleCenters.GetOutputPort());
aTrianglemapHog = vtkPolyDataMapper.New();
aTrianglemapHog.SetInputConnection(aTrianglehog.GetOutputPort());
aTrianglemapHog.SetScalarModeToUseCellData();
aTrianglemapHog.ScalarVisibilityOff();
aTrianglehogActor = new vtkActor();
aTrianglehogActor.SetMapper(aTrianglemapHog);
aTrianglehogActor.GetProperty().SetColor(0,1,0);
aTriangleGlyph3D = new vtkGlyph3D();
aTriangleGlyph3D.SetInputConnection(aTriangleCenters.GetOutputPort());
aTriangleGlyph3D.SetSource(ball.GetOutput());
aTriangleCentersMapper = vtkPolyDataMapper.New();
aTriangleCentersMapper.SetInputConnection(aTriangleGlyph3D.GetOutputPort());
aTriangleCentersActor = new vtkActor();
aTriangleCentersActor.SetMapper(aTriangleCentersMapper);
aTrianglehogActor.SetPosition(aTriangleActor.GetPosition()[0],aTriangleActor.GetPosition()[1],aTriangleActor.GetPosition()[2]);
ren1.AddActor((vtkProp)aTrianglehogActor);
aTrianglehogActor.GetProperty().SetRepresentationToWireframe();
aTriangleStripderivs = new vtkCellDerivatives();
aTriangleStripderivs.SetInput(aTriangleStripGrid);
aTriangleStripderivs.SetVectorModeToComputeGradient();
FileName = dir;
FileName += "/aTriangleStrip";
FileName += ".vtk";
// make sure the directory is writeable first[]
tryWorked = false;
try
{
channel = new StreamWriter("" + (dir.ToString()) + "/test.tmp");
tryWorked = true;
}
catch(Exception)
{
tryWorked = false;
}
if(tryWorked)
{
channel.Close();
File.Delete("" + (dir.ToString()) + "/test.tmp");
aTriangleStripWriter = new vtkUnstructuredGridWriter();
aTriangleStripWriter.SetInputConnection(aTriangleStripderivs.GetOutputPort());
aTriangleStripWriter.SetFileName(FileName);
aTriangleStripWriter.Write();
// delete the file[]
File.Delete("FileName");
}
aTriangleStripCenters = new vtkCellCenters();
aTriangleStripCenters.SetInputConnection(aTriangleStripderivs.GetOutputPort());
aTriangleStripCenters.VertexCellsOn();
aTriangleStriphog = new vtkHedgeHog();
aTriangleStriphog.SetInputConnection(aTriangleStripCenters.GetOutputPort());
aTriangleStripmapHog = vtkPolyDataMapper.New();
aTriangleStripmapHog.SetInputConnection(aTriangleStriphog.GetOutputPort());
aTriangleStripmapHog.SetScalarModeToUseCellData();
aTriangleStripmapHog.ScalarVisibilityOff();
aTriangleStriphogActor = new vtkActor();
aTriangleStriphogActor.SetMapper(aTriangleStripmapHog);
aTriangleStriphogActor.GetProperty().SetColor(0,1,0);
aTriangleStripGlyph3D = new vtkGlyph3D();
aTriangleStripGlyph3D.SetInputConnection(aTriangleStripCenters.GetOutputPort());
aTriangleStripGlyph3D.SetSource(ball.GetOutput());
aTriangleStripCentersMapper = vtkPolyDataMapper.New();
aTriangleStripCentersMapper.SetInputConnection(aTriangleStripGlyph3D.GetOutputPort());
aTriangleStripCentersActor = new vtkActor();
aTriangleStripCentersActor.SetMapper(aTriangleStripCentersMapper);
aTriangleStriphogActor.SetPosition(aTriangleStripActor.GetPosition()[0],aTriangleStripActor.GetPosition()[1],aTriangleStripActor.GetPosition()[2]);
ren1.AddActor((vtkProp)aTriangleStriphogActor);
aTriangleStriphogActor.GetProperty().SetRepresentationToWireframe();
aLinederivs = new vtkCellDerivatives();
aLinederivs.SetInput(aLineGrid);
aLinederivs.SetVectorModeToComputeGradient();
FileName = dir;
FileName += "/aLine";
FileName += ".vtk";
// make sure the directory is writeable first[]
tryWorked = false;
try
{
channel = new StreamWriter("" + (dir.ToString()) + "/test.tmp");
tryWorked = true;
}
catch(Exception)
{
tryWorked = false;
}
if(tryWorked)
{
channel.Close();
File.Delete("" + (dir.ToString()) + "/test.tmp");
aLineWriter = new vtkUnstructuredGridWriter();
aLineWriter.SetInputConnection(aLinederivs.GetOutputPort());
aLineWriter.SetFileName(FileName);
aLineWriter.Write();
// delete the file[]
File.Delete("FileName");
}
aLineCenters = new vtkCellCenters();
aLineCenters.SetInputConnection(aLinederivs.GetOutputPort());
aLineCenters.VertexCellsOn();
aLinehog = new vtkHedgeHog();
aLinehog.SetInputConnection(aLineCenters.GetOutputPort());
aLinemapHog = vtkPolyDataMapper.New();
aLinemapHog.SetInputConnection(aLinehog.GetOutputPort());
aLinemapHog.SetScalarModeToUseCellData();
aLinemapHog.ScalarVisibilityOff();
aLinehogActor = new vtkActor();
aLinehogActor.SetMapper(aLinemapHog);
aLinehogActor.GetProperty().SetColor(0,1,0);
aLineGlyph3D = new vtkGlyph3D();
aLineGlyph3D.SetInputConnection(aLineCenters.GetOutputPort());
aLineGlyph3D.SetSource(ball.GetOutput());
aLineCentersMapper = vtkPolyDataMapper.New();
aLineCentersMapper.SetInputConnection(aLineGlyph3D.GetOutputPort());
aLineCentersActor = new vtkActor();
aLineCentersActor.SetMapper(aLineCentersMapper);
aLinehogActor.SetPosition(aLineActor.GetPosition()[0],aLineActor.GetPosition()[1],aLineActor.GetPosition()[2]);
ren1.AddActor((vtkProp)aLinehogActor);
aLinehogActor.GetProperty().SetRepresentationToWireframe();
aPolyLinederivs = new vtkCellDerivatives();
aPolyLinederivs.SetInput(aPolyLineGrid);
aPolyLinederivs.SetVectorModeToComputeGradient();
FileName = dir;
FileName += "/aPolyLine";
FileName += ".vtk";
// make sure the directory is writeable first[]
tryWorked = false;
try
{
channel = new StreamWriter("" + (dir.ToString()) + "/test.tmp");
tryWorked = true;
}
catch(Exception)
{
tryWorked = false;
}
if(tryWorked)
{
channel.Close();
File.Delete("" + (dir.ToString()) + "/test.tmp");
aPolyLineWriter = new vtkUnstructuredGridWriter();
aPolyLineWriter.SetInputConnection(aPolyLinederivs.GetOutputPort());
aPolyLineWriter.SetFileName(FileName);
aPolyLineWriter.Write();
// delete the file[]
File.Delete("FileName");
}
aPolyLineCenters = new vtkCellCenters();
aPolyLineCenters.SetInputConnection(aPolyLinederivs.GetOutputPort());
aPolyLineCenters.VertexCellsOn();
aPolyLinehog = new vtkHedgeHog();
aPolyLinehog.SetInputConnection(aPolyLineCenters.GetOutputPort());
aPolyLinemapHog = vtkPolyDataMapper.New();
aPolyLinemapHog.SetInputConnection(aPolyLinehog.GetOutputPort());
aPolyLinemapHog.SetScalarModeToUseCellData();
aPolyLinemapHog.ScalarVisibilityOff();
aPolyLinehogActor = new vtkActor();
aPolyLinehogActor.SetMapper(aPolyLinemapHog);
aPolyLinehogActor.GetProperty().SetColor(0,1,0);
aPolyLineGlyph3D = new vtkGlyph3D();
aPolyLineGlyph3D.SetInputConnection(aPolyLineCenters.GetOutputPort());
aPolyLineGlyph3D.SetSource(ball.GetOutput());
aPolyLineCentersMapper = vtkPolyDataMapper.New();
aPolyLineCentersMapper.SetInputConnection(aPolyLineGlyph3D.GetOutputPort());
aPolyLineCentersActor = new vtkActor();
aPolyLineCentersActor.SetMapper(aPolyLineCentersMapper);
aPolyLinehogActor.SetPosition(aPolyLineActor.GetPosition()[0],aPolyLineActor.GetPosition()[1],aPolyLineActor.GetPosition()[2]);
ren1.AddActor((vtkProp)aPolyLinehogActor);
aPolyLinehogActor.GetProperty().SetRepresentationToWireframe();
aVertexderivs = new vtkCellDerivatives();
aVertexderivs.SetInput(aVertexGrid);
aVertexderivs.SetVectorModeToComputeGradient();
FileName = dir;
FileName += "/aVertex";
FileName += ".vtk";
// make sure the directory is writeable first[]
tryWorked = false;
try
{
channel = new StreamWriter("" + (dir.ToString()) + "/test.tmp");
tryWorked = true;
}
catch(Exception)
{
tryWorked = false;
}
if(tryWorked)
{
channel.Close();
File.Delete("" + (dir.ToString()) + "/test.tmp");
aVertexWriter = new vtkUnstructuredGridWriter();
aVertexWriter.SetInputConnection(aVertexderivs.GetOutputPort());
aVertexWriter.SetFileName(FileName);
aVertexWriter.Write();
// delete the file[]
File.Delete("FileName");
}
aVertexCenters = new vtkCellCenters();
aVertexCenters.SetInputConnection(aVertexderivs.GetOutputPort());
aVertexCenters.VertexCellsOn();
aVertexhog = new vtkHedgeHog();
aVertexhog.SetInputConnection(aVertexCenters.GetOutputPort());
aVertexmapHog = vtkPolyDataMapper.New();
aVertexmapHog.SetInputConnection(aVertexhog.GetOutputPort());
aVertexmapHog.SetScalarModeToUseCellData();
aVertexmapHog.ScalarVisibilityOff();
aVertexhogActor = new vtkActor();
aVertexhogActor.SetMapper(aVertexmapHog);
aVertexhogActor.GetProperty().SetColor(0,1,0);
aVertexGlyph3D = new vtkGlyph3D();
aVertexGlyph3D.SetInputConnection(aVertexCenters.GetOutputPort());
aVertexGlyph3D.SetSource(ball.GetOutput());
aVertexCentersMapper = vtkPolyDataMapper.New();
aVertexCentersMapper.SetInputConnection(aVertexGlyph3D.GetOutputPort());
aVertexCentersActor = new vtkActor();
aVertexCentersActor.SetMapper(aVertexCentersMapper);
aVertexhogActor.SetPosition(aVertexActor.GetPosition()[0],aVertexActor.GetPosition()[1],aVertexActor.GetPosition()[2]);
ren1.AddActor((vtkProp)aVertexhogActor);
aVertexhogActor.GetProperty().SetRepresentationToWireframe();
aPolyVertexderivs = new vtkCellDerivatives();
aPolyVertexderivs.SetInput(aPolyVertexGrid);
aPolyVertexderivs.SetVectorModeToComputeGradient();
FileName = dir;
FileName += "/aPolyVertex";
FileName += ".vtk";
// make sure the directory is writeable first[]
tryWorked = false;
try
{
channel = new StreamWriter("" + (dir.ToString()) + "/test.tmp");
tryWorked = true;
}
catch(Exception)
{
tryWorked = false;
}
if(tryWorked)
{
channel.Close();
File.Delete("" + (dir.ToString()) + "/test.tmp");
aPolyVertexWriter = new vtkUnstructuredGridWriter();
aPolyVertexWriter.SetInputConnection(aPolyVertexderivs.GetOutputPort());
aPolyVertexWriter.SetFileName(FileName);
aPolyVertexWriter.Write();
// delete the file[]
File.Delete("FileName");
}
aPolyVertexCenters = new vtkCellCenters();
aPolyVertexCenters.SetInputConnection(aPolyVertexderivs.GetOutputPort());
aPolyVertexCenters.VertexCellsOn();
aPolyVertexhog = new vtkHedgeHog();
aPolyVertexhog.SetInputConnection(aPolyVertexCenters.GetOutputPort());
aPolyVertexmapHog = vtkPolyDataMapper.New();
aPolyVertexmapHog.SetInputConnection(aPolyVertexhog.GetOutputPort());
aPolyVertexmapHog.SetScalarModeToUseCellData();
aPolyVertexmapHog.ScalarVisibilityOff();
aPolyVertexhogActor = new vtkActor();
aPolyVertexhogActor.SetMapper(aPolyVertexmapHog);
aPolyVertexhogActor.GetProperty().SetColor(0,1,0);
aPolyVertexGlyph3D = new vtkGlyph3D();
aPolyVertexGlyph3D.SetInputConnection(aPolyVertexCenters.GetOutputPort());
aPolyVertexGlyph3D.SetSource(ball.GetOutput());
aPolyVertexCentersMapper = vtkPolyDataMapper.New();
aPolyVertexCentersMapper.SetInputConnection(aPolyVertexGlyph3D.GetOutputPort());
aPolyVertexCentersActor = new vtkActor();
aPolyVertexCentersActor.SetMapper(aPolyVertexCentersMapper);
aPolyVertexhogActor.SetPosition(aPolyVertexActor.GetPosition()[0],aPolyVertexActor.GetPosition()[1],aPolyVertexActor.GetPosition()[2]);
ren1.AddActor((vtkProp)aPolyVertexhogActor);
aPolyVertexhogActor.GetProperty().SetRepresentationToWireframe();
aPixelderivs = new vtkCellDerivatives();
aPixelderivs.SetInput(aPixelGrid);
aPixelderivs.SetVectorModeToComputeGradient();
FileName = dir;
FileName += "/aPixel";
FileName += ".vtk";
// make sure the directory is writeable first[]
tryWorked = false;
try
{
channel = new StreamWriter("" + (dir.ToString()) + "/test.tmp");
tryWorked = true;
}
catch(Exception)
{
tryWorked = false;
}
if(tryWorked)
{
channel.Close();
File.Delete("" + (dir.ToString()) + "/test.tmp");
aPixelWriter = new vtkUnstructuredGridWriter();
aPixelWriter.SetInputConnection(aPixelderivs.GetOutputPort());
aPixelWriter.SetFileName(FileName);
aPixelWriter.Write();
// delete the file[]
File.Delete("FileName");
}
aPixelCenters = new vtkCellCenters();
aPixelCenters.SetInputConnection(aPixelderivs.GetOutputPort());
aPixelCenters.VertexCellsOn();
aPixelhog = new vtkHedgeHog();
aPixelhog.SetInputConnection(aPixelCenters.GetOutputPort());
aPixelmapHog = vtkPolyDataMapper.New();
aPixelmapHog.SetInputConnection(aPixelhog.GetOutputPort());
aPixelmapHog.SetScalarModeToUseCellData();
aPixelmapHog.ScalarVisibilityOff();
aPixelhogActor = new vtkActor();
aPixelhogActor.SetMapper(aPixelmapHog);
aPixelhogActor.GetProperty().SetColor(0,1,0);
aPixelGlyph3D = new vtkGlyph3D();
aPixelGlyph3D.SetInputConnection(aPixelCenters.GetOutputPort());
aPixelGlyph3D.SetSource(ball.GetOutput());
aPixelCentersMapper = vtkPolyDataMapper.New();
aPixelCentersMapper.SetInputConnection(aPixelGlyph3D.GetOutputPort());
aPixelCentersActor = new vtkActor();
aPixelCentersActor.SetMapper(aPixelCentersMapper);
aPixelhogActor.SetPosition(aPixelActor.GetPosition()[0],aPixelActor.GetPosition()[1],aPixelActor.GetPosition()[2]);
ren1.AddActor((vtkProp)aPixelhogActor);
aPixelhogActor.GetProperty().SetRepresentationToWireframe();
aPolygonderivs = new vtkCellDerivatives();
aPolygonderivs.SetInput(aPolygonGrid);
aPolygonderivs.SetVectorModeToComputeGradient();
FileName = dir;
FileName += "/aPolygon";
FileName += ".vtk";
// make sure the directory is writeable first[]
tryWorked = false;
try
{
channel = new StreamWriter("" + (dir.ToString()) + "/test.tmp");
tryWorked = true;
}
catch(Exception)
{
tryWorked = false;
}
if(tryWorked)
{
channel.Close();
File.Delete("" + (dir.ToString()) + "/test.tmp");
aPolygonWriter = new vtkUnstructuredGridWriter();
aPolygonWriter.SetInputConnection(aPolygonderivs.GetOutputPort());
aPolygonWriter.SetFileName(FileName);
aPolygonWriter.Write();
// delete the file[]
File.Delete("FileName");
}
aPolygonCenters = new vtkCellCenters();
aPolygonCenters.SetInputConnection(aPolygonderivs.GetOutputPort());
aPolygonCenters.VertexCellsOn();
aPolygonhog = new vtkHedgeHog();
aPolygonhog.SetInputConnection(aPolygonCenters.GetOutputPort());
aPolygonmapHog = vtkPolyDataMapper.New();
aPolygonmapHog.SetInputConnection(aPolygonhog.GetOutputPort());
aPolygonmapHog.SetScalarModeToUseCellData();
aPolygonmapHog.ScalarVisibilityOff();
aPolygonhogActor = new vtkActor();
aPolygonhogActor.SetMapper(aPolygonmapHog);
aPolygonhogActor.GetProperty().SetColor(0,1,0);
aPolygonGlyph3D = new vtkGlyph3D();
aPolygonGlyph3D.SetInputConnection(aPolygonCenters.GetOutputPort());
aPolygonGlyph3D.SetSource(ball.GetOutput());
aPolygonCentersMapper = vtkPolyDataMapper.New();
aPolygonCentersMapper.SetInputConnection(aPolygonGlyph3D.GetOutputPort());
aPolygonCentersActor = new vtkActor();
aPolygonCentersActor.SetMapper(aPolygonCentersMapper);
aPolygonhogActor.SetPosition(aPolygonActor.GetPosition()[0],aPolygonActor.GetPosition()[1],aPolygonActor.GetPosition()[2]);
ren1.AddActor((vtkProp)aPolygonhogActor);
aPolygonhogActor.GetProperty().SetRepresentationToWireframe();
aPentaderivs = new vtkCellDerivatives();
aPentaderivs.SetInput(aPentaGrid);
aPentaderivs.SetVectorModeToComputeGradient();
FileName = dir;
FileName += "/aPenta";
FileName += ".vtk";
// make sure the directory is writeable first[]
tryWorked = false;
try
{
channel = new StreamWriter("" + (dir.ToString()) + "/test.tmp");
tryWorked = true;
}
catch(Exception)
{
tryWorked = false;
}
if(tryWorked)
{
channel.Close();
File.Delete("" + (dir.ToString()) + "/test.tmp");
aPentaWriter = new vtkUnstructuredGridWriter();
aPentaWriter.SetInputConnection(aPentaderivs.GetOutputPort());
aPentaWriter.SetFileName(FileName);
aPentaWriter.Write();
// delete the file[]
File.Delete("FileName");
}
aPentaCenters = new vtkCellCenters();
aPentaCenters.SetInputConnection(aPentaderivs.GetOutputPort());
aPentaCenters.VertexCellsOn();
aPentahog = new vtkHedgeHog();
aPentahog.SetInputConnection(aPentaCenters.GetOutputPort());
aPentamapHog = vtkPolyDataMapper.New();
aPentamapHog.SetInputConnection(aPentahog.GetOutputPort());
aPentamapHog.SetScalarModeToUseCellData();
aPentamapHog.ScalarVisibilityOff();
aPentahogActor = new vtkActor();
aPentahogActor.SetMapper(aPentamapHog);
aPentahogActor.GetProperty().SetColor(0,1,0);
aPentaGlyph3D = new vtkGlyph3D();
aPentaGlyph3D.SetInputConnection(aPentaCenters.GetOutputPort());
aPentaGlyph3D.SetSource(ball.GetOutput());
aPentaCentersMapper = vtkPolyDataMapper.New();
aPentaCentersMapper.SetInputConnection(aPentaGlyph3D.GetOutputPort());
aPentaCentersActor = new vtkActor();
aPentaCentersActor.SetMapper(aPentaCentersMapper);
aPentahogActor.SetPosition(aPentaActor.GetPosition()[0],aPentaActor.GetPosition()[1],aPentaActor.GetPosition()[2]);
ren1.AddActor((vtkProp)aPentahogActor);
aPentahogActor.GetProperty().SetRepresentationToWireframe();
aHexaderivs = new vtkCellDerivatives();
aHexaderivs.SetInput(aHexaGrid);
aHexaderivs.SetVectorModeToComputeGradient();
FileName = dir;
FileName += "/aHexa";
FileName += ".vtk";
// make sure the directory is writeable first[]
tryWorked = false;
try
{
channel = new StreamWriter("" + (dir.ToString()) + "/test.tmp");
tryWorked = true;
}
catch(Exception)
{
tryWorked = false;
}
if(tryWorked)
{
channel.Close();
File.Delete("" + (dir.ToString()) + "/test.tmp");
aHexaWriter = new vtkUnstructuredGridWriter();
aHexaWriter.SetInputConnection(aHexaderivs.GetOutputPort());
aHexaWriter.SetFileName(FileName);
aHexaWriter.Write();
// delete the file[]
File.Delete("FileName");
}
aHexaCenters = new vtkCellCenters();
aHexaCenters.SetInputConnection(aHexaderivs.GetOutputPort());
aHexaCenters.VertexCellsOn();
aHexahog = new vtkHedgeHog();
aHexahog.SetInputConnection(aHexaCenters.GetOutputPort());
aHexamapHog = vtkPolyDataMapper.New();
aHexamapHog.SetInputConnection(aHexahog.GetOutputPort());
aHexamapHog.SetScalarModeToUseCellData();
aHexamapHog.ScalarVisibilityOff();
aHexahogActor = new vtkActor();
aHexahogActor.SetMapper(aHexamapHog);
aHexahogActor.GetProperty().SetColor(0,1,0);
aHexaGlyph3D = new vtkGlyph3D();
aHexaGlyph3D.SetInputConnection(aHexaCenters.GetOutputPort());
aHexaGlyph3D.SetSource(ball.GetOutput());
aHexaCentersMapper = vtkPolyDataMapper.New();
aHexaCentersMapper.SetInputConnection(aHexaGlyph3D.GetOutputPort());
aHexaCentersActor = new vtkActor();
aHexaCentersActor.SetMapper(aHexaCentersMapper);
aHexahogActor.SetPosition(aHexaActor.GetPosition()[0],aHexaActor.GetPosition()[1],aHexaActor.GetPosition()[2]);
ren1.AddActor((vtkProp)aHexahogActor);
aHexahogActor.GetProperty().SetRepresentationToWireframe();
ren1.ResetCamera();
ren1.GetActiveCamera().Azimuth((double)30);
ren1.GetActiveCamera().Elevation((double)20);
ren1.GetActiveCamera().Dolly((double)3.0);
ren1.ResetCameraClippingRange();
renWin.SetSize((int)300,(int)150);
renWin.Render();
// render the image[]
//[]
iren.Initialize();
//deleteAllVTKObjects();
}
/// <summary>
/// The main entry method called by the CSharp driver
/// </summary>
/// <param name="argv"></param>
public static void AVTenEllip(String [] argv)
{
//Prefix Content is: ""
// create tensor ellipsoids[]
// Create the RenderWindow, Renderer and interactive renderer[]
//[]
ren1 = vtkRenderer.New();
renWin = vtkRenderWindow.New();
renWin.SetMultiSamples(0);
renWin.AddRenderer((vtkRenderer)ren1);
iren = new vtkRenderWindowInteractor();
iren.SetRenderWindow((vtkRenderWindow)renWin);
//[]
// Create tensor ellipsoids[]
//[]
// generate tensors[]
ptLoad = new vtkPointLoad();
ptLoad.SetLoadValue((double)100.0);
ptLoad.SetSampleDimensions((int)6,(int)6,(int)6);
ptLoad.ComputeEffectiveStressOn();
ptLoad.SetModelBounds((double)-10,(double)10,(double)-10,(double)10,(double)-10,(double)10);
// extract plane of data[]
plane = new vtkImageDataGeometryFilter();
plane.SetInputConnection((vtkAlgorithmOutput)ptLoad.GetOutputPort());
plane.SetExtent((int)2,(int)2,(int)0,(int)99,(int)0,(int)99);
// Generate ellipsoids[]
sphere = new vtkSphereSource();
sphere.SetThetaResolution((int)8);
sphere.SetPhiResolution((int)8);
ellipsoids = new vtkTensorGlyph();
ellipsoids.SetInputConnection((vtkAlgorithmOutput)ptLoad.GetOutputPort());
ellipsoids.SetSourceConnection((vtkAlgorithmOutput)sphere.GetOutputPort());
ellipsoids.SetScaleFactor((double)10);
ellipsoids.ClampScalingOn();
ellipNormals = new vtkPolyDataNormals();
ellipNormals.SetInputConnection((vtkAlgorithmOutput)ellipsoids.GetOutputPort());
// Map contour[]
lut = new vtkLogLookupTable();
lut.SetHueRange((double).6667,(double)0.0);
ellipMapper = vtkPolyDataMapper.New();
ellipMapper.SetInputConnection((vtkAlgorithmOutput)ellipNormals.GetOutputPort());
ellipMapper.SetLookupTable((vtkScalarsToColors)lut);
plane.Update();
//force update for scalar range[]
ellipMapper.SetScalarRange((double)((vtkDataSet)plane.GetOutput()).GetScalarRange()[0],(double)((vtkDataSet)plane.GetOutput()).GetScalarRange()[1]);
ellipActor = new vtkActor();
ellipActor.SetMapper((vtkMapper)ellipMapper);
//[]
// Create outline around data[]
//[]
outline = new vtkOutlineFilter();
outline.SetInputConnection((vtkAlgorithmOutput)ptLoad.GetOutputPort());
outlineMapper = vtkPolyDataMapper.New();
outlineMapper.SetInputConnection((vtkAlgorithmOutput)outline.GetOutputPort());
outlineActor = new vtkActor();
outlineActor.SetMapper((vtkMapper)outlineMapper);
outlineActor.GetProperty().SetColor((double)0,(double)0,(double)0);
//[]
// Create cone indicating application of load[]
//[]
coneSrc = new vtkConeSource();
coneSrc.SetRadius((double).5);
coneSrc.SetHeight((double)2);
coneMap = vtkPolyDataMapper.New();
coneMap.SetInputConnection((vtkAlgorithmOutput)coneSrc.GetOutputPort());
coneActor = new vtkActor();
coneActor.SetMapper((vtkMapper)coneMap);
coneActor.SetPosition((double)0,(double)0,(double)11);
coneActor.RotateY((double)90);
coneActor.GetProperty().SetColor((double)1,(double)0,(double)0);
camera = new vtkCamera();
camera.SetFocalPoint((double)0.113766,(double)-1.13665,(double)-1.01919);
camera.SetPosition((double)-29.4886,(double)-63.1488,(double)26.5807);
camera.SetViewAngle((double)24.4617);
camera.SetViewUp((double)0.17138,(double)0.331163,(double)0.927879);
camera.SetClippingRange((double)1,(double)100);
ren1.AddActor((vtkProp)ellipActor);
ren1.AddActor((vtkProp)outlineActor);
ren1.AddActor((vtkProp)coneActor);
ren1.SetBackground((double)1.0,(double)1.0,(double)1.0);
ren1.SetActiveCamera((vtkCamera)camera);
renWin.SetSize((int)400,(int)400);
renWin.Render();
// prevent the tk window from showing up then start the event loop[]
//deleteAllVTKObjects();
}
/// <summary>
/// The main entry method called by the CSharp driver
/// </summary>
/// <param name="argv"></param>
public static void AVstreamTracer(String [] argv)
{
//Prefix Content is: ""
ren1 = vtkRenderer.New();
renWin = vtkRenderWindow.New();
// this test has some wireframe geometry
// Make sure multisampling is disabled to avoid generating multiple
// regression images
// renWin SetMultiSamples 0
renWin.AddRenderer((vtkRenderer)ren1);
iren = new vtkRenderWindowInteractor();
iren.SetRenderWindow((vtkRenderWindow)renWin);
// read data[]
//[]
reader = new vtkStructuredGridReader();
reader.SetFileName((string)"" + (VTK_DATA_ROOT.ToString()) + "/Data/office.binary.vtk");
reader.Update();
//force a read to occur[]
outline = new vtkStructuredGridOutlineFilter();
outline.SetInputConnection((vtkAlgorithmOutput)reader.GetOutputPort());
mapOutline = vtkPolyDataMapper.New();
mapOutline.SetInputConnection((vtkAlgorithmOutput)outline.GetOutputPort());
outlineActor = new vtkActor();
outlineActor.SetMapper((vtkMapper)mapOutline);
outlineActor.GetProperty().SetColor((double)0,(double)0,(double)0);
rk = new vtkRungeKutta45();
// Create source for streamtubes[]
streamer = new vtkStreamTracer();
streamer.SetInputConnection((vtkAlgorithmOutput)reader.GetOutputPort());
streamer.SetStartPosition((double)0.1,(double)2.1,(double)0.5);
streamer.SetMaximumPropagation((double)500);
streamer.SetIntegrationStepUnit(2);
streamer.SetMinimumIntegrationStep((double)0.1);
streamer.SetMaximumIntegrationStep((double)1.0);
streamer.SetInitialIntegrationStep((double)0.2);
streamer.SetIntegrationDirection((int)0);
streamer.SetIntegrator((vtkInitialValueProblemSolver)rk);
streamer.SetRotationScale((double)0.5);
streamer.SetMaximumError((double)1.0e-8);
aa = new vtkAssignAttribute();
aa.SetInputConnection((vtkAlgorithmOutput)streamer.GetOutputPort());
aa.Assign((string)"Normals",(string)"NORMALS",(string)"POINT_DATA");
rf1 = new vtkRibbonFilter();
rf1.SetInputConnection((vtkAlgorithmOutput)aa.GetOutputPort());
rf1.SetWidth((double)0.1);
rf1.VaryWidthOff();
mapStream = vtkPolyDataMapper.New();
mapStream.SetInputConnection((vtkAlgorithmOutput)rf1.GetOutputPort());
mapStream.SetScalarRange((double)((vtkDataSet)reader.GetOutput()).GetScalarRange()[0],(double)((vtkDataSet)reader.GetOutput()).GetScalarRange()[1]);
streamActor = new vtkActor();
streamActor.SetMapper((vtkMapper)mapStream);
ren1.AddActor((vtkProp)outlineActor);
ren1.AddActor((vtkProp)streamActor);
ren1.SetBackground((double)0.4,(double)0.4,(double)0.5);
cam = ren1.GetActiveCamera();
cam.SetPosition((double)-2.35599,(double)-3.35001,(double)4.59236);
cam.SetFocalPoint((double)2.255,(double)2.255,(double)1.28413);
cam.SetViewUp((double)0.311311,(double)0.279912,(double)0.908149);
cam.SetClippingRange((double)1.12294,(double)16.6226);
renWin.SetSize((int)300,(int)200);
iren.Initialize();
// interact with data[]
//deleteAllVTKObjects();
}
/// <summary>
/// The main entry method called by the CSharp driver
/// </summary>
/// <param name="argv"></param>
public static void AVcombStreamers2(String [] argv)
{
//Prefix Content is: ""
// Create the RenderWindow, Renderer and both Actors[]
//[]
ren1 = vtkRenderer.New();
renWin = vtkRenderWindow.New();
renWin.AddRenderer((vtkRenderer)ren1);
iren = new vtkRenderWindowInteractor();
iren.SetRenderWindow((vtkRenderWindow)renWin);
// create pipeline[]
//[]
pl3d = new vtkPLOT3DReader();
pl3d.SetXYZFileName((string)"" + (VTK_DATA_ROOT.ToString()) + "/Data/combxyz.bin");
pl3d.SetQFileName((string)"" + (VTK_DATA_ROOT.ToString()) + "/Data/combq.bin");
pl3d.SetScalarFunctionNumber((int)100);
pl3d.SetVectorFunctionNumber((int)202);
pl3d.Update();
ps = new vtkPlaneSource();
ps.SetXResolution((int)4);
ps.SetYResolution((int)4);
ps.SetOrigin((double)2,(double)-2,(double)26);
ps.SetPoint1((double)2,(double)2,(double)26);
ps.SetPoint2((double)2,(double)-2,(double)32);
psMapper = vtkPolyDataMapper.New();
psMapper.SetInputConnection((vtkAlgorithmOutput)ps.GetOutputPort());
psActor = new vtkActor();
psActor.SetMapper((vtkMapper)psMapper);
psActor.GetProperty().SetRepresentationToWireframe();
streamer = new vtkDashedStreamLine();
streamer.SetInputConnection((vtkAlgorithmOutput)pl3d.GetOutputPort());
streamer.SetSource((vtkDataSet)ps.GetOutput());
streamer.SetMaximumPropagationTime((double)100);
streamer.SetIntegrationStepLength((double).2);
streamer.SetStepLength((double).001);
streamer.SetNumberOfThreads((int)1);
streamer.SetIntegrationDirectionToForward();
streamMapper = vtkPolyDataMapper.New();
streamMapper.SetInputConnection((vtkAlgorithmOutput)streamer.GetOutputPort());
streamMapper.SetScalarRange(
(double)((vtkDataSet)pl3d.GetOutput()).GetScalarRange()[0],
(double)((vtkDataSet)pl3d.GetOutput()).GetScalarRange()[1]);
streamline = new vtkActor();
streamline.SetMapper((vtkMapper)streamMapper);
outline = new vtkStructuredGridOutlineFilter();
outline.SetInputConnection((vtkAlgorithmOutput)pl3d.GetOutputPort());
outlineMapper = vtkPolyDataMapper.New();
outlineMapper.SetInputConnection((vtkAlgorithmOutput)outline.GetOutputPort());
outlineActor = new vtkActor();
outlineActor.SetMapper((vtkMapper)outlineMapper);
// Add the actors to the renderer, set the background and size[]
//[]
ren1.AddActor((vtkProp)psActor);
ren1.AddActor((vtkProp)outlineActor);
ren1.AddActor((vtkProp)streamline);
ren1.SetBackground((double)1,(double)1,(double)1);
renWin.SetSize((int)300,(int)300);
ren1.SetBackground((double)0.1,(double)0.2,(double)0.4);
cam1 = ren1.GetActiveCamera();
cam1.SetClippingRange((double)3.95297,(double)50);
cam1.SetFocalPoint((double)9.71821,(double)0.458166,(double)29.3999);
cam1.SetPosition((double)2.7439,(double)-37.3196,(double)38.7167);
cam1.SetViewUp((double)-0.16123,(double)0.264271,(double)0.950876);
// render the image[]
//[]
renWin.Render();
// prevent the tk window from showing up then start the event loop[]
//deleteAllVTKObjects();
}
static void Main(string[] args)
{
// create a sphere source, mapper, and actor
vtkSphereSource sphere = new vtkSphereSource();
vtkPolyDataMapper sphereMapper = new vtkPolyDataMapper();
sphereMapper.SetInputConnection(sphere.GetOutputPort());
vtkPolyDataMapper.GlobalImmediateModeRenderingOn();
vtkLODActor sphereActor = new vtkLODActor();
sphereActor.SetMapper(sphereMapper);
// create the spikes by glyphing the sphere with a cone. Create the
// mapper and actor for the glyphs.
vtkConeSource cone = new vtkConeSource();
vtkGlyph3D glyph = new vtkGlyph3D();
glyph.SetInputConnection(sphere.GetOutputPort());
glyph.SetSource(cone.GetOutput());
glyph.SetVectorModeToUseNormal();
glyph.SetScaleModeToScaleByVector();
glyph.SetScaleFactor(0.25);
vtkPolyDataMapper spikeMapper = new vtkPolyDataMapper();
spikeMapper.SetInputConnection(glyph.GetOutputPort());
vtkLODActor spikeActor = new vtkLODActor();
spikeActor.SetMapper(spikeMapper);
// Create a text mapper and actor to display the results of picking.
vtkTextMapper textMapper = new vtkTextMapper();
vtkTextProperty tprop = textMapper.GetTextProperty();
tprop.SetFontFamilyToArial();
tprop.SetFontSize(10);
tprop.BoldOn();
tprop.ShadowOn();
tprop.SetColor(1, 0, 0);
vtkActor2D textActor = new vtkActor2D();
textActor.VisibilityOff();
textActor.SetMapper(textMapper);
// Create a cell picker.
vtkCellPicker picker = new vtkCellPicker();
PickData pd = new PickData();
pd.textActor = textActor;
pd.textMapper = textMapper;
vtkDotNetCallback cb = new vtkDotNetCallback(pd.annotatePickCallback);
// Now at the end of the pick event call the above function.
picker.AddObserver((uint) EventIds.EndPickEvent, cb);
// Create the Renderer, RenderWindow, etc. and set the Picker.
vtkRenderer ren = new vtkRenderer();
vtkRenderWindow renWin = new vtkRenderWindow();
renWin.AddRenderer(ren);
vtkRenderWindowInteractor iren = new vtkRenderWindowInteractor();
iren.SetRenderWindow(renWin);
iren.SetPicker(picker);
// Add the actors to the renderer, set the background and size
ren.AddActor2D(textActor);
ren.AddActor(sphereActor);
ren.AddActor(spikeActor);
ren.SetBackground(1, 1, 1);
renWin.SetSize(300, 300);
// Get the camera and zoom in closer to the image.
ren.ResetCamera();
vtkCamera cam1 = ren.GetActiveCamera();
cam1.Zoom(1.4);
iren.Initialize();
// Initially pick the cell at this location.
picker.Pick(85, 126, 0, ren);
renWin.Render();
iren.Start();
vtkWin32OpenGLRenderWindow win32win =
vtkWin32OpenGLRenderWindow.SafeDownCast(renWin);
if (null != win32win) win32win.Clean();
}
private void DrawBuildUGrid()
{
//# This example shows how to manually construct unstructured grids
//# using C#. Unstructured grids require explicit point and cell
//# representations, so every point and cell must be created, and then
//# added to the vtkUnstructuredGrid instance.
//# Create several unstructured grids each containing a cell of a
//# different type.
//create voxel
vtkPoints voxelPoints = vtkPoints.New();
voxelPoints.SetNumberOfPoints(8);
voxelPoints.InsertPoint(0, 0, 0, 0);
voxelPoints.InsertPoint(1, 1, 0, 0);
voxelPoints.InsertPoint(2, 0, 1, 0);
voxelPoints.InsertPoint(3, 1, 1, 0);
voxelPoints.InsertPoint(4, 0, 0, 1);
voxelPoints.InsertPoint(5, 1, 0, 1);
voxelPoints.InsertPoint(6, 0, 1, 1);
voxelPoints.InsertPoint(7, 1, 1, 1);
vtkVoxel aVoxel = vtkVoxel.New();
aVoxel.GetPointIds().SetId(0, 0);
aVoxel.GetPointIds().SetId(1, 1);
aVoxel.GetPointIds().SetId(2, 2);
aVoxel.GetPointIds().SetId(3, 3);
aVoxel.GetPointIds().SetId(4, 4);
aVoxel.GetPointIds().SetId(5, 5);
aVoxel.GetPointIds().SetId(6, 6);
aVoxel.GetPointIds().SetId(7, 7);
vtkUnstructuredGrid aVoxelGrid = vtkUnstructuredGrid.New();
aVoxelGrid.Allocate(1, 1);
aVoxelGrid.InsertNextCell(aVoxel.GetCellType(), aVoxel.GetPointIds());
aVoxelGrid.SetPoints(voxelPoints);
vtkDataSetMapper aVoxelMapper = vtkDataSetMapper.New();
aVoxelMapper.SetInputData(aVoxelGrid);
vtkActor aVoxelActor = vtkActor.New();
aVoxelActor.SetMapper(aVoxelMapper);
aVoxelActor.GetProperty().SetDiffuseColor(1, 0, 0);
//create Hexahedron
vtkPoints hexahedronPoints = new vtkPoints();
hexahedronPoints.SetNumberOfPoints(8);
hexahedronPoints.InsertPoint(0, 0, 0, 0);
hexahedronPoints.InsertPoint(1, 1, 0, 0);
hexahedronPoints.InsertPoint(2, 1, 1, 0);
hexahedronPoints.InsertPoint(3, 0, 1, 0);
hexahedronPoints.InsertPoint(4, 0, 0, 1);
hexahedronPoints.InsertPoint(5, 1, 0, 1);
hexahedronPoints.InsertPoint(6, 1, 1, 1);
hexahedronPoints.InsertPoint(7, 0, 1, 1);
vtkHexahedron aHexahedron = new vtkHexahedron();
aHexahedron.GetPointIds().SetId(0, 0);
aHexahedron.GetPointIds().SetId(1, 1);
aHexahedron.GetPointIds().SetId(2, 2);
aHexahedron.GetPointIds().SetId(3, 3);
aHexahedron.GetPointIds().SetId(4, 4);
aHexahedron.GetPointIds().SetId(5, 5);
aHexahedron.GetPointIds().SetId(6, 6);
aHexahedron.GetPointIds().SetId(7, 7);
vtkUnstructuredGrid aHexahedronGrid = new vtkUnstructuredGrid();
aHexahedronGrid.Allocate(1, 1);
aHexahedronGrid.InsertNextCell(aHexahedron.GetCellType(), aHexahedron.GetPointIds());
aHexahedronGrid.SetPoints(hexahedronPoints);
vtkDataSetMapper aHexahedronMapper = new vtkDataSetMapper();
aHexahedronMapper.SetInputData(aHexahedronGrid);
vtkActor aHexahedronActor = new vtkActor();
aHexahedronActor.SetMapper(aHexahedronMapper);
aHexahedronActor.AddPosition(2, 0, 0);
aHexahedronActor.GetProperty().SetDiffuseColor(1, 1, 0);
vtkRenderer render = vtkRenderer.New();
vtkRenderWindow renWin = myRenderWindowControl.RenderWindow;
renWin.AddRenderer(render);
render.SetBackground(0, 0, 1);
render.AddActor(aVoxelActor);
render.AddActor(aHexahedronActor);
}
/// <summary>
/// The main entry method called by the CSharp driver
/// </summary>
/// <param name="argv"></param>
public static void AVfieldToUGrid(String [] argv)
{
//Prefix Content is: ""
// Read a field representing unstructured grid and display it (similar to blow.tcl)[]
// create a reader and write out field daya[]
reader = new vtkUnstructuredGridReader();
reader.SetFileName((string)"" + (VTK_DATA_ROOT.ToString()) + "/Data/blow.vtk");
reader.SetScalarsName((string)"thickness9");
reader.SetVectorsName((string)"displacement9");
ds2do = new vtkDataSetToDataObjectFilter();
ds2do.SetInputConnection((vtkAlgorithmOutput)reader.GetOutputPort());
// we must be able to write here[]
try
{
channel = new StreamWriter("UGridField.vtk");
tryCatchError = "NOERROR";
}
catch(Exception)
{tryCatchError = "ERROR";}
if (tryCatchError.Equals("NOERROR"))
{
channel.Close();
write = new vtkDataObjectWriter();
write.SetInputConnection((vtkAlgorithmOutput)ds2do.GetOutputPort());
write.SetFileName((string)"UGridField.vtk");
write.Write();
// Read the field and convert to unstructured grid.[]
dor = new vtkDataObjectReader();
dor.SetFileName((string)"UGridField.vtk");
do2ds = new vtkDataObjectToDataSetFilter();
do2ds.SetInputConnection((vtkAlgorithmOutput)dor.GetOutputPort());
do2ds.SetDataSetTypeToUnstructuredGrid();
do2ds.SetPointComponent((int)0,(string)"Points",(int)0);
do2ds.SetPointComponent((int)1,(string)"Points",(int)1);
do2ds.SetPointComponent((int)2,(string)"Points",(int)2);
do2ds.SetCellTypeComponent((string)"CellTypes",(int)0);
do2ds.SetCellConnectivityComponent((string)"Cells",(int)0);
fd2ad = new vtkFieldDataToAttributeDataFilter();
fd2ad.SetInput((vtkDataObject)do2ds.GetUnstructuredGridOutput());
fd2ad.SetInputFieldToDataObjectField();
fd2ad.SetOutputAttributeDataToPointData();
fd2ad.SetVectorComponent((int)0,(string)"displacement9",(int)0);
fd2ad.SetVectorComponent((int)1,(string)"displacement9",(int)1);
fd2ad.SetVectorComponent((int)2,(string)"displacement9",(int)2);
fd2ad.SetScalarComponent((int)0,(string)"thickness9",(int)0);
// Now start visualizing[]
warp = new vtkWarpVector();
warp.SetInput((vtkDataObject)fd2ad.GetUnstructuredGridOutput());
// extract mold from mesh using connectivity[]
connect = new vtkConnectivityFilter();
connect.SetInputConnection((vtkAlgorithmOutput)warp.GetOutputPort());
connect.SetExtractionModeToSpecifiedRegions();
connect.AddSpecifiedRegion((int)0);
connect.AddSpecifiedRegion((int)1);
moldMapper = new vtkDataSetMapper();
moldMapper.SetInputConnection((vtkAlgorithmOutput)connect.GetOutputPort());
moldMapper.ScalarVisibilityOff();
moldActor = new vtkActor();
moldActor.SetMapper((vtkMapper)moldMapper);
moldActor.GetProperty().SetColor((double).2,(double).2,(double).2);
moldActor.GetProperty().SetRepresentationToWireframe();
// extract parison from mesh using connectivity[]
connect2 = new vtkConnectivityFilter();
connect2.SetInputConnection((vtkAlgorithmOutput)warp.GetOutputPort());
connect2.SetExtractionModeToSpecifiedRegions();
connect2.AddSpecifiedRegion((int)2);
parison = new vtkGeometryFilter();
parison.SetInputConnection((vtkAlgorithmOutput)connect2.GetOutputPort());
normals2 = new vtkPolyDataNormals();
normals2.SetInputConnection((vtkAlgorithmOutput)parison.GetOutputPort());
normals2.SetFeatureAngle((double)60);
lut = new vtkLookupTable();
lut.SetHueRange((double)0.0,(double)0.66667);
parisonMapper = vtkPolyDataMapper.New();
parisonMapper.SetInputConnection((vtkAlgorithmOutput)normals2.GetOutputPort());
parisonMapper.SetLookupTable((vtkScalarsToColors)lut);
parisonMapper.SetScalarRange((double)0.12,(double)1.0);
parisonActor = new vtkActor();
parisonActor.SetMapper((vtkMapper)parisonMapper);
cf = new vtkContourFilter();
cf.SetInputConnection((vtkAlgorithmOutput)connect2.GetOutputPort());
cf.SetValue((int)0,(double).5);
contourMapper = vtkPolyDataMapper.New();
contourMapper.SetInputConnection((vtkAlgorithmOutput)cf.GetOutputPort());
contours = new vtkActor();
contours.SetMapper((vtkMapper)contourMapper);
// Create graphics stuff[]
ren1 = vtkRenderer.New();
renWin = vtkRenderWindow.New();
renWin.AddRenderer((vtkRenderer)ren1);
iren = new vtkRenderWindowInteractor();
iren.SetRenderWindow((vtkRenderWindow)renWin);
// Add the actors to the renderer, set the background and size[]
ren1.AddActor((vtkProp)moldActor);
ren1.AddActor((vtkProp)parisonActor);
ren1.AddActor((vtkProp)contours);
ren1.ResetCamera();
ren1.GetActiveCamera().Azimuth((double)60);
ren1.GetActiveCamera().Roll((double)-90);
ren1.GetActiveCamera().Dolly((double)2);
ren1.ResetCameraClippingRange();
ren1.SetBackground((double)1,(double)1,(double)1);
renWin.SetSize((int)375,(int)200);
iren.Initialize();
}
// prevent the tk window from showing up then start the event loop[]
//deleteAllVTKObjects();
}
/// <summary>
/// The main entry method called by the CSharp driver
/// </summary>
/// <param name="argv"></param>
public static void AVofficeStreamPoints(String [] argv)
{
//Prefix Content is: ""
ren1 = vtkRenderer.New();
renWin = vtkRenderWindow.New();
renWin.AddRenderer((vtkRenderer)ren1);
iren = new vtkRenderWindowInteractor();
iren.SetRenderWindow((vtkRenderWindow)renWin);
// read data[]
//[]
reader = new vtkStructuredGridReader();
reader.SetFileName((string)"" + (VTK_DATA_ROOT.ToString()) + "/Data/office.binary.vtk");
reader.Update();
//force a read to occur[]
// to add coverage for vtkOnePieceExtentTranslator[]
translator = new vtkOnePieceExtentTranslator();
vtkStreamingDemandDrivenPipeline.SetExtentTranslator(reader.GetOutputInformation(0), (vtkExtentTranslator)translator);
length = reader.GetOutput().GetLength();
maxVelocity = reader.GetOutput().GetPointData().GetVectors().GetMaxNorm();
maxTime = 35.0*length/maxVelocity;
table1 = new vtkStructuredGridGeometryFilter();
table1.SetInputConnection((vtkAlgorithmOutput)reader.GetOutputPort());
table1.SetExtent((int)11,(int)15,(int)7,(int)9,(int)8,(int)8);
mapTable1 = vtkPolyDataMapper.New();
mapTable1.SetInputConnection((vtkAlgorithmOutput)table1.GetOutputPort());
mapTable1.ScalarVisibilityOff();
table1Actor = new vtkActor();
table1Actor.SetMapper((vtkMapper)mapTable1);
table1Actor.GetProperty().SetColor((double).59,(double).427,(double).392);
table2 = new vtkStructuredGridGeometryFilter();
table2.SetInputConnection((vtkAlgorithmOutput)reader.GetOutputPort());
table2.SetExtent((int)11,(int)15,(int)10,(int)12,(int)8,(int)8);
mapTable2 = vtkPolyDataMapper.New();
mapTable2.SetInputConnection((vtkAlgorithmOutput)table2.GetOutputPort());
mapTable2.ScalarVisibilityOff();
table2Actor = new vtkActor();
table2Actor.SetMapper((vtkMapper)mapTable2);
table2Actor.GetProperty().SetColor((double).59,(double).427,(double).392);
FilingCabinet1 = new vtkStructuredGridGeometryFilter();
FilingCabinet1.SetInputConnection((vtkAlgorithmOutput)reader.GetOutputPort());
FilingCabinet1.SetExtent((int)15,(int)15,(int)7,(int)9,(int)0,(int)8);
mapFilingCabinet1 = vtkPolyDataMapper.New();
mapFilingCabinet1.SetInputConnection((vtkAlgorithmOutput)FilingCabinet1.GetOutputPort());
mapFilingCabinet1.ScalarVisibilityOff();
FilingCabinet1Actor = new vtkActor();
FilingCabinet1Actor.SetMapper((vtkMapper)mapFilingCabinet1);
FilingCabinet1Actor.GetProperty().SetColor((double).8,(double).8,(double).6);
FilingCabinet2 = new vtkStructuredGridGeometryFilter();
FilingCabinet2.SetInputConnection((vtkAlgorithmOutput)reader.GetOutputPort());
FilingCabinet2.SetExtent((int)15,(int)15,(int)10,(int)12,(int)0,(int)8);
mapFilingCabinet2 = vtkPolyDataMapper.New();
mapFilingCabinet2.SetInputConnection((vtkAlgorithmOutput)FilingCabinet2.GetOutputPort());
mapFilingCabinet2.ScalarVisibilityOff();
FilingCabinet2Actor = new vtkActor();
FilingCabinet2Actor.SetMapper((vtkMapper)mapFilingCabinet2);
FilingCabinet2Actor.GetProperty().SetColor((double).8,(double).8,(double).6);
bookshelf1Top = new vtkStructuredGridGeometryFilter();
bookshelf1Top.SetInputConnection((vtkAlgorithmOutput)reader.GetOutputPort());
bookshelf1Top.SetExtent((int)13,(int)13,(int)0,(int)4,(int)0,(int)11);
mapBookshelf1Top = vtkPolyDataMapper.New();
mapBookshelf1Top.SetInputConnection((vtkAlgorithmOutput)bookshelf1Top.GetOutputPort());
mapBookshelf1Top.ScalarVisibilityOff();
bookshelf1TopActor = new vtkActor();
bookshelf1TopActor.SetMapper((vtkMapper)mapBookshelf1Top);
bookshelf1TopActor.GetProperty().SetColor((double).8,(double).8,(double).6);
bookshelf1Bottom = new vtkStructuredGridGeometryFilter();
bookshelf1Bottom.SetInputConnection((vtkAlgorithmOutput)reader.GetOutputPort());
bookshelf1Bottom.SetExtent((int)20,(int)20,(int)0,(int)4,(int)0,(int)11);
mapBookshelf1Bottom = vtkPolyDataMapper.New();
mapBookshelf1Bottom.SetInputConnection((vtkAlgorithmOutput)bookshelf1Bottom.GetOutputPort());
mapBookshelf1Bottom.ScalarVisibilityOff();
bookshelf1BottomActor = new vtkActor();
bookshelf1BottomActor.SetMapper((vtkMapper)mapBookshelf1Bottom);
bookshelf1BottomActor.GetProperty().SetColor((double).8,(double).8,(double).6);
bookshelf1Front = new vtkStructuredGridGeometryFilter();
bookshelf1Front.SetInputConnection((vtkAlgorithmOutput)reader.GetOutputPort());
bookshelf1Front.SetExtent((int)13,(int)20,(int)0,(int)0,(int)0,(int)11);
mapBookshelf1Front = vtkPolyDataMapper.New();
mapBookshelf1Front.SetInputConnection((vtkAlgorithmOutput)bookshelf1Front.GetOutputPort());
mapBookshelf1Front.ScalarVisibilityOff();
bookshelf1FrontActor = new vtkActor();
bookshelf1FrontActor.SetMapper((vtkMapper)mapBookshelf1Front);
bookshelf1FrontActor.GetProperty().SetColor((double).8,(double).8,(double).6);
bookshelf1Back = new vtkStructuredGridGeometryFilter();
bookshelf1Back.SetInputConnection((vtkAlgorithmOutput)reader.GetOutputPort());
bookshelf1Back.SetExtent((int)13,(int)20,(int)4,(int)4,(int)0,(int)11);
mapBookshelf1Back = vtkPolyDataMapper.New();
mapBookshelf1Back.SetInputConnection((vtkAlgorithmOutput)bookshelf1Back.GetOutputPort());
mapBookshelf1Back.ScalarVisibilityOff();
bookshelf1BackActor = new vtkActor();
bookshelf1BackActor.SetMapper((vtkMapper)mapBookshelf1Back);
bookshelf1BackActor.GetProperty().SetColor((double).8,(double).8,(double).6);
bookshelf1LHS = new vtkStructuredGridGeometryFilter();
bookshelf1LHS.SetInputConnection((vtkAlgorithmOutput)reader.GetOutputPort());
bookshelf1LHS.SetExtent((int)13,(int)20,(int)0,(int)4,(int)0,(int)0);
mapBookshelf1LHS = vtkPolyDataMapper.New();
mapBookshelf1LHS.SetInputConnection((vtkAlgorithmOutput)bookshelf1LHS.GetOutputPort());
mapBookshelf1LHS.ScalarVisibilityOff();
bookshelf1LHSActor = new vtkActor();
bookshelf1LHSActor.SetMapper((vtkMapper)mapBookshelf1LHS);
bookshelf1LHSActor.GetProperty().SetColor((double).8,(double).8,(double).6);
bookshelf1RHS = new vtkStructuredGridGeometryFilter();
bookshelf1RHS.SetInputConnection((vtkAlgorithmOutput)reader.GetOutputPort());
bookshelf1RHS.SetExtent((int)13,(int)20,(int)0,(int)4,(int)11,(int)11);
mapBookshelf1RHS = vtkPolyDataMapper.New();
mapBookshelf1RHS.SetInputConnection((vtkAlgorithmOutput)bookshelf1RHS.GetOutputPort());
mapBookshelf1RHS.ScalarVisibilityOff();
bookshelf1RHSActor = new vtkActor();
bookshelf1RHSActor.SetMapper((vtkMapper)mapBookshelf1RHS);
bookshelf1RHSActor.GetProperty().SetColor((double).8,(double).8,(double).6);
bookshelf2Top = new vtkStructuredGridGeometryFilter();
bookshelf2Top.SetInputConnection((vtkAlgorithmOutput)reader.GetOutputPort());
bookshelf2Top.SetExtent((int)13,(int)13,(int)15,(int)19,(int)0,(int)11);
mapBookshelf2Top = vtkPolyDataMapper.New();
mapBookshelf2Top.SetInputConnection((vtkAlgorithmOutput)bookshelf2Top.GetOutputPort());
mapBookshelf2Top.ScalarVisibilityOff();
bookshelf2TopActor = new vtkActor();
bookshelf2TopActor.SetMapper((vtkMapper)mapBookshelf2Top);
bookshelf2TopActor.GetProperty().SetColor((double).8,(double).8,(double).6);
bookshelf2Bottom = new vtkStructuredGridGeometryFilter();
bookshelf2Bottom.SetInputConnection((vtkAlgorithmOutput)reader.GetOutputPort());
bookshelf2Bottom.SetExtent((int)20,(int)20,(int)15,(int)19,(int)0,(int)11);
mapBookshelf2Bottom = vtkPolyDataMapper.New();
mapBookshelf2Bottom.SetInputConnection((vtkAlgorithmOutput)bookshelf2Bottom.GetOutputPort());
mapBookshelf2Bottom.ScalarVisibilityOff();
bookshelf2BottomActor = new vtkActor();
bookshelf2BottomActor.SetMapper((vtkMapper)mapBookshelf2Bottom);
bookshelf2BottomActor.GetProperty().SetColor((double).8,(double).8,(double).6);
bookshelf2Front = new vtkStructuredGridGeometryFilter();
bookshelf2Front.SetInputConnection((vtkAlgorithmOutput)reader.GetOutputPort());
bookshelf2Front.SetExtent((int)13,(int)20,(int)15,(int)15,(int)0,(int)11);
mapBookshelf2Front = vtkPolyDataMapper.New();
mapBookshelf2Front.SetInputConnection((vtkAlgorithmOutput)bookshelf2Front.GetOutputPort());
mapBookshelf2Front.ScalarVisibilityOff();
bookshelf2FrontActor = new vtkActor();
bookshelf2FrontActor.SetMapper((vtkMapper)mapBookshelf2Front);
bookshelf2FrontActor.GetProperty().SetColor((double).8,(double).8,(double).6);
bookshelf2Back = new vtkStructuredGridGeometryFilter();
bookshelf2Back.SetInputConnection((vtkAlgorithmOutput)reader.GetOutputPort());
bookshelf2Back.SetExtent((int)13,(int)20,(int)19,(int)19,(int)0,(int)11);
mapBookshelf2Back = vtkPolyDataMapper.New();
mapBookshelf2Back.SetInputConnection((vtkAlgorithmOutput)bookshelf2Back.GetOutputPort());
mapBookshelf2Back.ScalarVisibilityOff();
bookshelf2BackActor = new vtkActor();
bookshelf2BackActor.SetMapper((vtkMapper)mapBookshelf2Back);
bookshelf2BackActor.GetProperty().SetColor((double).8,(double).8,(double).6);
bookshelf2LHS = new vtkStructuredGridGeometryFilter();
bookshelf2LHS.SetInputConnection((vtkAlgorithmOutput)reader.GetOutputPort());
bookshelf2LHS.SetExtent((int)13,(int)20,(int)15,(int)19,(int)0,(int)0);
mapBookshelf2LHS = vtkPolyDataMapper.New();
mapBookshelf2LHS.SetInputConnection((vtkAlgorithmOutput)bookshelf2LHS.GetOutputPort());
mapBookshelf2LHS.ScalarVisibilityOff();
bookshelf2LHSActor = new vtkActor();
bookshelf2LHSActor.SetMapper((vtkMapper)mapBookshelf2LHS);
bookshelf2LHSActor.GetProperty().SetColor((double).8,(double).8,(double).6);
bookshelf2RHS = new vtkStructuredGridGeometryFilter();
bookshelf2RHS.SetInputConnection((vtkAlgorithmOutput)reader.GetOutputPort());
bookshelf2RHS.SetExtent((int)13,(int)20,(int)15,(int)19,(int)11,(int)11);
mapBookshelf2RHS = vtkPolyDataMapper.New();
mapBookshelf2RHS.SetInputConnection((vtkAlgorithmOutput)bookshelf2RHS.GetOutputPort());
mapBookshelf2RHS.ScalarVisibilityOff();
bookshelf2RHSActor = new vtkActor();
bookshelf2RHSActor.SetMapper((vtkMapper)mapBookshelf2RHS);
bookshelf2RHSActor.GetProperty().SetColor((double).8,(double).8,(double).6);
window = new vtkStructuredGridGeometryFilter();
window.SetInputConnection((vtkAlgorithmOutput)reader.GetOutputPort());
window.SetExtent((int)20,(int)20,(int)6,(int)13,(int)10,(int)13);
mapWindow = vtkPolyDataMapper.New();
mapWindow.SetInputConnection((vtkAlgorithmOutput)window.GetOutputPort());
mapWindow.ScalarVisibilityOff();
windowActor = new vtkActor();
windowActor.SetMapper((vtkMapper)mapWindow);
windowActor.GetProperty().SetColor((double).3,(double).3,(double).5);
outlet = new vtkStructuredGridGeometryFilter();
outlet.SetInputConnection((vtkAlgorithmOutput)reader.GetOutputPort());
outlet.SetExtent((int)0,(int)0,(int)9,(int)10,(int)14,(int)16);
mapOutlet = vtkPolyDataMapper.New();
mapOutlet.SetInputConnection((vtkAlgorithmOutput)outlet.GetOutputPort());
mapOutlet.ScalarVisibilityOff();
outletActor = new vtkActor();
outletActor.SetMapper((vtkMapper)mapOutlet);
outletActor.GetProperty().SetColor((double)0,(double)0,(double)0);
inlet = new vtkStructuredGridGeometryFilter();
inlet.SetInputConnection((vtkAlgorithmOutput)reader.GetOutputPort());
inlet.SetExtent((int)0,(int)0,(int)9,(int)10,(int)0,(int)6);
mapInlet = vtkPolyDataMapper.New();
mapInlet.SetInputConnection((vtkAlgorithmOutput)inlet.GetOutputPort());
mapInlet.ScalarVisibilityOff();
inletActor = new vtkActor();
inletActor.SetMapper((vtkMapper)mapInlet);
inletActor.GetProperty().SetColor((double)0,(double)0,(double)0);
outline = new vtkStructuredGridOutlineFilter();
outline.SetInputConnection((vtkAlgorithmOutput)reader.GetOutputPort());
mapOutline = vtkPolyDataMapper.New();
mapOutline.SetInputConnection((vtkAlgorithmOutput)outline.GetOutputPort());
outlineActor = new vtkActor();
outlineActor.SetMapper((vtkMapper)mapOutline);
outlineActor.GetProperty().SetColor((double)0,(double)0,(double)0);
// Create source for streamtubes[]
streamer = new vtkStreamPoints();
streamer.SetInputConnection((vtkAlgorithmOutput)reader.GetOutputPort());
streamer.SetStartPosition((double)0.1,(double)2.1,(double)0.5);
streamer.SetMaximumPropagationTime((double)500);
streamer.SetTimeIncrement((double)0.5);
streamer.SetIntegrationDirectionToForward();
cone = new vtkConeSource();
cone.SetResolution((int)8);
cones = new vtkGlyph3D();
cones.SetInputConnection((vtkAlgorithmOutput)streamer.GetOutputPort());
cones.SetSourceConnection(cone.GetOutputPort());
cones.SetScaleFactor((double)0.5);
cones.SetScaleModeToScaleByVector();
mapCones = vtkPolyDataMapper.New();
mapCones.SetInputConnection((vtkAlgorithmOutput)cones.GetOutputPort());
mapCones.SetScalarRange((double)((vtkDataSet)reader.GetOutput()).GetScalarRange()[0],(double)((vtkDataSet)reader.GetOutput()).GetScalarRange()[1]);
conesActor = new vtkActor();
conesActor.SetMapper((vtkMapper)mapCones);
ren1.AddActor((vtkProp)table1Actor);
ren1.AddActor((vtkProp)table2Actor);
ren1.AddActor((vtkProp)FilingCabinet1Actor);
ren1.AddActor((vtkProp)FilingCabinet2Actor);
ren1.AddActor((vtkProp)bookshelf1TopActor);
ren1.AddActor((vtkProp)bookshelf1BottomActor);
ren1.AddActor((vtkProp)bookshelf1FrontActor);
ren1.AddActor((vtkProp)bookshelf1BackActor);
ren1.AddActor((vtkProp)bookshelf1LHSActor);
ren1.AddActor((vtkProp)bookshelf1RHSActor);
ren1.AddActor((vtkProp)bookshelf2TopActor);
ren1.AddActor((vtkProp)bookshelf2BottomActor);
ren1.AddActor((vtkProp)bookshelf2FrontActor);
ren1.AddActor((vtkProp)bookshelf2BackActor);
ren1.AddActor((vtkProp)bookshelf2LHSActor);
ren1.AddActor((vtkProp)bookshelf2RHSActor);
ren1.AddActor((vtkProp)windowActor);
ren1.AddActor((vtkProp)outletActor);
ren1.AddActor((vtkProp)inletActor);
ren1.AddActor((vtkProp)outlineActor);
ren1.AddActor((vtkProp)conesActor);
ren1.SetBackground((double)0.4,(double)0.4,(double)0.5);
aCamera = new vtkCamera();
aCamera.SetClippingRange((double)0.7724,(double)39);
aCamera.SetFocalPoint((double)1.14798,(double)3.08416,(double)2.47187);
aCamera.SetPosition((double)-2.64683,(double)-3.55525,(double)3.55848);
aCamera.SetViewUp((double)0.0511273,(double)0.132773,(double)0.989827);
aCamera.SetViewAngle((double)15.5033);
ren1.SetActiveCamera((vtkCamera)aCamera);
renWin.SetSize((int)500,(int)300);
iren.Initialize();
// interact with data[]
//deleteAllVTKObjects();
}
private void WindowedSincPolyDataFilter()
{
vtkSphereSource sphereSource = vtkSphereSource.New();
sphereSource.Update();
vtkWindowedSincPolyDataFilter smoother = vtkWindowedSincPolyDataFilter.New();
smoother.SetInputConnection(sphereSource.GetOutputPort());
smoother.SetNumberOfIterations(15);
smoother.BoundarySmoothingOff();
smoother.FeatureEdgeSmoothingOff();
smoother.SetFeatureAngle(120.0);
smoother.SetPassBand(.001);
smoother.NonManifoldSmoothingOn();
smoother.NormalizeCoordinatesOn();
smoother.Update();
vtkPolyDataMapper smoothedMapper = vtkPolyDataMapper.New();
#if VTK_MAJOR_VERSION_5
smoothedMapper.SetInputConnection(smoother.GetOutputPort());
#else
smoothedMapper.SetInputData(smoother);
#endif
vtkActor smoothedActor = vtkActor.New();
smoothedActor.SetMapper(smoothedMapper);
vtkPolyDataMapper inputMapper = vtkPolyDataMapper.New();
#if VTK_MAJOR_VERSION_5
inputMapper.SetInputConnection(sphereSource.GetOutputPort());
#else
inputMapper.SetInputData(sphereSource);
#endif
vtkActor inputActor = vtkActor.New();
inputActor.SetMapper(inputMapper);
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(smoothedActor);
leftRenderer.ResetCamera();
rightRenderer.ResetCamera();
renderWindow.Render();
}
/// <summary>
/// The main entry method called by the CSharp driver
/// </summary>
/// <param name="argv"></param>
public static void AVTestPolyDataPieces(String [] argv)
{
//Prefix Content is: ""
math = new vtkMath();
vtkMath.RandomSeed((int)22);
pf = new vtkParallelFactory();
vtkParallelFactory.RegisterFactory((vtkObjectFactory)pf);
sphere = new vtkSphereSource();
sphere.SetPhiResolution((int)32);
sphere.SetThetaResolution((int)32);
extract = new vtkExtractPolyDataPiece();
extract.SetInputConnection((vtkAlgorithmOutput)sphere.GetOutputPort());
normals = new vtkPolyDataNormals();
normals.SetInputConnection((vtkAlgorithmOutput)extract.GetOutputPort());
ps = new vtkPieceScalars();
ps.SetInputConnection((vtkAlgorithmOutput)normals.GetOutputPort());
mapper = vtkPolyDataMapper.New();
mapper.SetInputConnection((vtkAlgorithmOutput)ps.GetOutputPort());
mapper.SetNumberOfPieces((int)2);
actor = new vtkActor();
actor.SetMapper((vtkMapper)mapper);
sphere2 = new vtkSphereSource();
sphere2.SetPhiResolution((int)32);
sphere2.SetThetaResolution((int)32);
extract2 = new vtkExtractPolyDataPiece();
extract2.SetInputConnection((vtkAlgorithmOutput)sphere2.GetOutputPort());
mapper2 = vtkPolyDataMapper.New();
mapper2.SetInputConnection((vtkAlgorithmOutput)extract2.GetOutputPort());
mapper2.SetNumberOfPieces((int)2);
mapper2.SetPiece((int)1);
mapper2.SetScalarRange((double)0,(double)4);
mapper2.SetScalarModeToUseCellFieldData();
mapper2.SetColorModeToMapScalars();
mapper2.ColorByArrayComponent((string)"vtkGhostLevels",(int)0);
mapper2.SetGhostLevel((int)4);
// check the pipeline size[]
extract2.UpdateInformation();
psize = new vtkPipelineSize();
if ((psize.GetEstimatedSize((vtkAlgorithm)extract2,(int)0,(int)0)) > 100)
{
//puts skipedputs ['stderr', '"ERROR: Pipeline Size increased"']
}
if ((psize.GetNumberOfSubPieces((uint)10,(vtkPolyDataMapper)mapper2)) != 2)
{
//puts skipedputs ['stderr', '"ERROR: Number of sub pieces changed"']
}
actor2 = new vtkActor();
actor2.SetMapper((vtkMapper)mapper2);
actor2.SetPosition((double)1.5,(double)0,(double)0);
sphere3 = new vtkSphereSource();
sphere3.SetPhiResolution((int)32);
sphere3.SetThetaResolution((int)32);
extract3 = new vtkExtractPolyDataPiece();
extract3.SetInputConnection((vtkAlgorithmOutput)sphere3.GetOutputPort());
ps3 = new vtkPieceScalars();
ps3.SetInputConnection((vtkAlgorithmOutput)extract3.GetOutputPort());
mapper3 = vtkPolyDataMapper.New();
mapper3.SetInputConnection((vtkAlgorithmOutput)ps3.GetOutputPort());
mapper3.SetNumberOfSubPieces((int)8);
mapper3.SetScalarRange((double)0,(double)8);
actor3 = new vtkActor();
actor3.SetMapper((vtkMapper)mapper3);
actor3.SetPosition((double)0,(double)-1.5,(double)0);
sphere4 = new vtkSphereSource();
sphere4.SetPhiResolution((int)32);
sphere4.SetThetaResolution((int)32);
extract4 = new vtkExtractPolyDataPiece();
extract4.SetInputConnection((vtkAlgorithmOutput)sphere4.GetOutputPort());
ps4 = new vtkPieceScalars();
ps4.RandomModeOn();
ps4.SetScalarModeToCellData();
ps4.SetInputConnection((vtkAlgorithmOutput)extract4.GetOutputPort());
mapper4 = vtkPolyDataMapper.New();
mapper4.SetInputConnection((vtkAlgorithmOutput)ps4.GetOutputPort());
mapper4.SetNumberOfSubPieces((int)8);
mapper4.SetScalarRange((double)0,(double)8);
actor4 = new vtkActor();
actor4.SetMapper((vtkMapper)mapper4);
actor4.SetPosition((double)1.5,(double)-1.5,(double)0);
ren = vtkRenderer.New();
ren.AddActor((vtkProp)actor);
ren.AddActor((vtkProp)actor2);
ren.AddActor((vtkProp)actor3);
ren.AddActor((vtkProp)actor4);
renWin = vtkRenderWindow.New();
renWin.AddRenderer((vtkRenderer)ren);
iren = new vtkRenderWindowInteractor();
iren.SetRenderWindow((vtkRenderWindow)renWin);
iren.Initialize();
//deleteAllVTKObjects();
}
/// <summary>
/// The main entry method called by the CSharp driver
/// </summary>
/// <param name="argv"></param>
public static void AVMatrixToTransform(String [] argv)
{
//Prefix Content is: ""
// This example demonstrates how to use a matrix in place of a transfrom[]
// via vtkMatrixToLinearTransform and vtkMatrixToHomogeneousTransform.[]
// create a rendering window[]
renWin = vtkRenderWindow.New();
renWin.SetSize((int)600,(int)300);
// set up first set of polydata[]
p1 = new vtkPlaneSource();
p1.SetOrigin((double)0.5,(double)0.508,(double)-0.5);
p1.SetPoint1((double)-0.5,(double)0.508,(double)-0.5);
p1.SetPoint2((double)0.5,(double)0.508,(double)0.5);
p1.SetXResolution((int)5);
p1.SetYResolution((int)5);
p2 = new vtkPlaneSource();
p2.SetOrigin((double)-0.508,(double)0.5,(double)-0.5);
p2.SetPoint1((double)-0.508,(double)-0.5,(double)-0.5);
p2.SetPoint2((double)-0.508,(double)0.5,(double)0.5);
p2.SetXResolution((int)5);
p2.SetYResolution((int)5);
p3 = new vtkPlaneSource();
p3.SetOrigin((double)-0.5,(double)-0.508,(double)-0.5);
p3.SetPoint1((double)0.5,(double)-0.508,(double)-0.5);
p3.SetPoint2((double)-0.5,(double)-0.508,(double)0.5);
p3.SetXResolution((int)5);
p3.SetYResolution((int)5);
p4 = new vtkPlaneSource();
p4.SetOrigin((double)0.508,(double)-0.5,(double)-0.5);
p4.SetPoint1((double)0.508,(double)0.5,(double)-0.5);
p4.SetPoint2((double)0.508,(double)-0.5,(double)0.5);
p4.SetXResolution((int)5);
p4.SetYResolution((int)5);
p5 = new vtkPlaneSource();
p5.SetOrigin((double)0.5,(double)0.5,(double)-0.508);
p5.SetPoint1((double)0.5,(double)-0.5,(double)-0.508);
p5.SetPoint2((double)-0.5,(double)0.5,(double)-0.508);
p5.SetXResolution((int)5);
p5.SetYResolution((int)5);
p6 = new vtkPlaneSource();
p6.SetOrigin((double)0.5,(double)0.5,(double)0.508);
p6.SetPoint1((double)-0.5,(double)0.5,(double)0.508);
p6.SetPoint2((double)0.5,(double)-0.5,(double)0.508);
p6.SetXResolution((int)5);
p6.SetYResolution((int)5);
// append together[]
ap = new vtkAppendPolyData();
ap.AddInputConnection(p1.GetOutputPort());
ap.AddInputConnection(p2.GetOutputPort());
ap.AddInputConnection(p3.GetOutputPort());
ap.AddInputConnection(p4.GetOutputPort());
ap.AddInputConnection(p5.GetOutputPort());
ap.AddInputConnection(p6.GetOutputPort());
//--------------------------[]
// linear transform matrix[]
t1 = new vtkMatrixToLinearTransform();
m1 = new vtkMatrix4x4();
t1.SetInput((vtkMatrix4x4)m1);
m1.SetElement((int)0,(int)0,(double)1.127631);
m1.SetElement((int)0,(int)1,(double)0.205212);
m1.SetElement((int)0,(int)2,(double)-0.355438);
m1.SetElement((int)1,(int)0,(double)0.000000);
m1.SetElement((int)1,(int)1,(double)0.692820);
m1.SetElement((int)1,(int)2,(double)0.400000);
m1.SetElement((int)2,(int)0,(double)0.200000);
m1.SetElement((int)2,(int)1,(double)-0.469846);
m1.SetElement((int)2,(int)2,(double)0.813798);
f11 = new vtkTransformPolyDataFilter();
f11.SetInputConnection((vtkAlgorithmOutput)ap.GetOutputPort());
f11.SetTransform((vtkAbstractTransform)t1);
m11 = new vtkDataSetMapper();
m11.SetInputConnection((vtkAlgorithmOutput)f11.GetOutputPort());
a11 = new vtkActor();
a11.SetMapper((vtkMapper)m11);
a11.GetProperty().SetColor((double)1,(double)0,(double)0);
a11.GetProperty().SetRepresentationToWireframe();
ren11 = vtkRenderer.New();
ren11.SetViewport((double)0.0,(double)0.5,(double)0.25,(double)1.0);
ren11.ResetCamera((double)-0.5,(double)0.5,(double)-0.5,(double)0.5,(double)-1,(double)1);
ren11.AddActor((vtkProp)a11);
renWin.AddRenderer((vtkRenderer)ren11);
// inverse identity transform[]
f12 = new vtkTransformPolyDataFilter();
f12.SetInputConnection((vtkAlgorithmOutput)ap.GetOutputPort());
f12.SetTransform((vtkAbstractTransform)t1.GetInverse());
m12 = new vtkDataSetMapper();
m12.SetInputConnection((vtkAlgorithmOutput)f12.GetOutputPort());
a12 = new vtkActor();
a12.SetMapper((vtkMapper)m12);
a12.GetProperty().SetColor((double)0.9,(double)0.9,(double)0);
a12.GetProperty().SetRepresentationToWireframe();
ren12 = vtkRenderer.New();
ren12.SetViewport((double)0.0,(double)0.0,(double)0.25,(double)0.5);
ren12.ResetCamera((double)-0.5,(double)0.5,(double)-0.5,(double)0.5,(double)-1,(double)1);
ren12.AddActor((vtkProp)a12);
renWin.AddRenderer((vtkRenderer)ren12);
//--------------------------[]
// perspective transform matrix[]
m2 = new vtkMatrix4x4();
m2.SetElement((int)3,(int)0,(double)-0.11);
m2.SetElement((int)3,(int)1,(double)0.3);
m2.SetElement((int)3,(int)2,(double)0.2);
t2 = new vtkMatrixToHomogeneousTransform();
t2.SetInput((vtkMatrix4x4)m2);
f21 = new vtkTransformPolyDataFilter();
f21.SetInputConnection((vtkAlgorithmOutput)ap.GetOutputPort());
f21.SetTransform((vtkAbstractTransform)t2);
m21 = new vtkDataSetMapper();
m21.SetInputConnection((vtkAlgorithmOutput)f21.GetOutputPort());
a21 = new vtkActor();
a21.SetMapper((vtkMapper)m21);
a21.GetProperty().SetColor((double)1,(double)0,(double)0);
a21.GetProperty().SetRepresentationToWireframe();
ren21 = vtkRenderer.New();
ren21.SetViewport((double)0.25,(double)0.5,(double)0.50,(double)1.0);
ren21.ResetCamera((double)-0.5,(double)0.5,(double)-0.5,(double)0.5,(double)-1,(double)1);
ren21.AddActor((vtkProp)a21);
renWin.AddRenderer((vtkRenderer)ren21);
// inverse linear transform[]
f22 = new vtkTransformPolyDataFilter();
f22.SetInputConnection((vtkAlgorithmOutput)ap.GetOutputPort());
f22.SetTransform((vtkAbstractTransform)t2.GetInverse());
m22 = new vtkDataSetMapper();
m22.SetInputConnection((vtkAlgorithmOutput)f22.GetOutputPort());
a22 = new vtkActor();
a22.SetMapper((vtkMapper)m22);
a22.GetProperty().SetColor((double)0.9,(double)0.9,(double)0);
a22.GetProperty().SetRepresentationToWireframe();
ren22 = vtkRenderer.New();
ren22.SetViewport((double)0.25,(double)0.0,(double)0.50,(double)0.5);
ren22.ResetCamera((double)-0.5,(double)0.5,(double)-0.5,(double)0.5,(double)-1,(double)1);
ren22.AddActor((vtkProp)a22);
renWin.AddRenderer((vtkRenderer)ren22);
//--------------------------[]
// linear concatenation - should end up with identity here[]
t3 = new vtkTransform();
t3.Concatenate((vtkLinearTransform)t1);
t3.Concatenate((vtkLinearTransform)t1.GetInverse());
f31 = new vtkTransformPolyDataFilter();
f31.SetInputConnection((vtkAlgorithmOutput)ap.GetOutputPort());
f31.SetTransform((vtkAbstractTransform)t3);
m31 = new vtkDataSetMapper();
m31.SetInputConnection((vtkAlgorithmOutput)f31.GetOutputPort());
a31 = new vtkActor();
a31.SetMapper((vtkMapper)m31);
a31.GetProperty().SetColor((double)1,(double)0,(double)0);
a31.GetProperty().SetRepresentationToWireframe();
ren31 = vtkRenderer.New();
ren31.SetViewport((double)0.50,(double)0.5,(double)0.75,(double)1.0);
ren31.ResetCamera((double)-0.5,(double)0.5,(double)-0.5,(double)0.5,(double)-1,(double)1);
ren31.AddActor((vtkProp)a31);
renWin.AddRenderer((vtkRenderer)ren31);
// inverse linear transform[]
f32 = new vtkTransformPolyDataFilter();
f32.SetInputConnection((vtkAlgorithmOutput)ap.GetOutputPort());
f32.SetTransform((vtkAbstractTransform)t3.GetInverse());
m32 = new vtkDataSetMapper();
m32.SetInputConnection((vtkAlgorithmOutput)f32.GetOutputPort());
a32 = new vtkActor();
a32.SetMapper((vtkMapper)m32);
a32.GetProperty().SetColor((double)0.9,(double)0.9,(double)0);
a32.GetProperty().SetRepresentationToWireframe();
ren32 = vtkRenderer.New();
ren32.SetViewport((double)0.5,(double)0.0,(double)0.75,(double)0.5);
ren32.ResetCamera((double)-0.5,(double)0.5,(double)-0.5,(double)0.5,(double)-1,(double)1);
ren32.AddActor((vtkProp)a32);
renWin.AddRenderer((vtkRenderer)ren32);
//--------------------------[]
// perspective transform concatenation[]
t4 = new vtkPerspectiveTransform();
t4.Concatenate((vtkHomogeneousTransform)t1);
t4.Concatenate((vtkHomogeneousTransform)t2);
t4.Concatenate((vtkHomogeneousTransform)t3);
f41 = new vtkTransformPolyDataFilter();
f41.SetInputConnection((vtkAlgorithmOutput)ap.GetOutputPort());
f41.SetTransform((vtkAbstractTransform)t4);
m41 = new vtkDataSetMapper();
m41.SetInputConnection((vtkAlgorithmOutput)f41.GetOutputPort());
a41 = new vtkActor();
a41.SetMapper((vtkMapper)m41);
a41.GetProperty().SetColor((double)1,(double)0,(double)0);
a41.GetProperty().SetRepresentationToWireframe();
ren41 = vtkRenderer.New();
ren41.SetViewport((double)0.75,(double)0.5,(double)1.0,(double)1.0);
ren41.ResetCamera((double)-0.5,(double)0.5,(double)-0.5,(double)0.5,(double)-1,(double)1);
ren41.AddActor((vtkProp)a41);
renWin.AddRenderer((vtkRenderer)ren41);
// inverse of transform concatenation[]
f42 = new vtkTransformPolyDataFilter();
f42.SetInputConnection((vtkAlgorithmOutput)ap.GetOutputPort());
f42.SetTransform((vtkAbstractTransform)t4.GetInverse());
m42 = new vtkDataSetMapper();
m42.SetInputConnection((vtkAlgorithmOutput)f42.GetOutputPort());
a42 = new vtkActor();
a42.SetMapper((vtkMapper)m42);
a42.GetProperty().SetColor((double)0.9,(double)0.9,(double)0);
a42.GetProperty().SetRepresentationToWireframe();
ren42 = vtkRenderer.New();
ren42.SetViewport((double)0.75,(double)0.0,(double)1.0,(double)0.5);
ren42.ResetCamera((double)-0.5,(double)0.5,(double)-0.5,(double)0.5,(double)-1,(double)1);
ren42.AddActor((vtkProp)a42);
renWin.AddRenderer((vtkRenderer)ren42);
renWin.Render();
//deleteAllVTKObjects();
}
private void ParametricObjectsDemo()
{
// we create a matrix of 4x4 renderer in our renderwindow
// each renderer can be interacted with independently from one another
int rendererSize = 189; // width per renderer
int gridDimensions = 4;
this.Size = new System.Drawing.Size(756, 756);
Random rnd = new Random(2);
List <vtkParametricFunction> parametricObjects = new List <vtkParametricFunction>();
parametricObjects.Add(vtkParametricBoy.New());
parametricObjects.Add(vtkParametricConicSpiral.New());
parametricObjects.Add(vtkParametricCrossCap.New());
parametricObjects.Add(vtkParametricDini.New());
vtkParametricEllipsoid ellipsoid = vtkParametricEllipsoid.New();
ellipsoid.SetXRadius(0.5);
ellipsoid.SetYRadius(2.0);
parametricObjects.Add(ellipsoid);
parametricObjects.Add(vtkParametricEnneper.New());
parametricObjects.Add(vtkParametricFigure8Klein.New());
parametricObjects.Add(vtkParametricKlein.New());
parametricObjects.Add(vtkParametricMobius.New());
vtkParametricRandomHills randomHills = vtkParametricRandomHills.New();
randomHills.AllowRandomGenerationOff();
parametricObjects.Add(randomHills);
parametricObjects.Add(vtkParametricRoman.New());
vtkParametricSuperEllipsoid superEllipsoid = vtkParametricSuperEllipsoid.New();
superEllipsoid.SetN1(.50);
superEllipsoid.SetN2(.1);
parametricObjects.Add(superEllipsoid);
vtkParametricSuperToroid superToroid = vtkParametricSuperToroid.New();
superToroid.SetN1(0.2);
superToroid.SetN2(3.0);
parametricObjects.Add(superToroid);
parametricObjects.Add(vtkParametricTorus.New());
vtkParametricSpline spline = vtkParametricSpline.New();
vtkPoints inputPoints = vtkPoints.New();
vtkMath.RandomSeed(8775070);
for (int p = 0; p < 10; p++)
{
double x = vtkMath.Random(0.0, 1.0);
double y = vtkMath.Random(0.0, 1.0);
double z = vtkMath.Random(0.0, 1.0);
inputPoints.InsertNextPoint(x, y, z);
}
spline.SetPoints(inputPoints);
parametricObjects.Add(spline);
List <vtkParametricFunctionSource> parametricFunctionSources = new List <vtkParametricFunctionSource>();
List <vtkRenderer> renderers = new List <vtkRenderer>();
List <vtkPolyDataMapper> mappers = new List <vtkPolyDataMapper>();
List <vtkActor> actors = new List <vtkActor>();
List <vtkTextMapper> textMappers = new List <vtkTextMapper>();
List <vtkActor2D> textActors = new List <vtkActor2D>();
// Create one text property for all
vtkTextProperty textProperty = vtkTextProperty.New();
textProperty.SetFontSize(12);
textProperty.SetJustificationToCentered();
// Create a source, renderer, mapper, and actor
// for each object
for (int i = 0; i < parametricObjects.Count; i++)
{
parametricFunctionSources.Add(vtkParametricFunctionSource.New());
parametricFunctionSources[i].SetParametricFunction(parametricObjects[i]);
parametricFunctionSources[i].Update();
mappers.Add(vtkPolyDataMapper.New());
mappers[i].SetInputConnection(parametricFunctionSources[i].GetOutputPort());
actors.Add(vtkActor.New());
actors[i].SetMapper(mappers[i]);
textMappers.Add(vtkTextMapper.New());
textMappers[i].SetInput(parametricObjects[i].GetClassName());
textMappers[i].SetTextProperty(textProperty);
textActors.Add(vtkActor2D.New());
textActors[i].SetMapper(textMappers[i]);
textActors[i].SetPosition(rendererSize / 2, 16);
renderers.Add(vtkRenderer.New());
}
// Need a renderer even if there is no actor
for (int i = parametricObjects.Count; i < gridDimensions * gridDimensions; i++)
{
renderers.Add(vtkRenderer.New());
}
vtkRenderWindow renderWindow = renderWindowControl1.RenderWindow;
renderWindow.SetSize(rendererSize * gridDimensions, rendererSize * gridDimensions);
for (int row = 0; row < gridDimensions; row++)
{
for (int col = 0; col < gridDimensions; col++)
{
int index = row * gridDimensions + col;
// (xmin, ymin, xmax, ymax)
double[] viewport = new double[] {
(col) * rendererSize / (double)(gridDimensions * rendererSize),
(gridDimensions - (row + 1)) * rendererSize / (double)(gridDimensions * rendererSize),
(col + 1) * rendererSize / (double)(gridDimensions * rendererSize),
(gridDimensions - row) * rendererSize / (double)(gridDimensions * rendererSize)
};
//Debug.WriteLine(viewport[0] + " " + viewport[1] + " " + viewport[2] + " " + viewport[3]);
renderWindow.AddRenderer(renderers[index]);
IntPtr pViewport = Marshal.AllocHGlobal(Marshal.SizeOf(typeof(double)) * 4);
Marshal.Copy(viewport, 0, pViewport, 4);
renderers[index].SetViewport(pViewport);
Marshal.FreeHGlobal(pViewport);
if (index > parametricObjects.Count - 1)
{
continue;
}
renderers[index].AddActor(actors[index]);
renderers[index].AddActor(textActors[index]);
renderers[index].SetBackground(.2 + rnd.NextDouble() / 8, .3 + rnd.NextDouble() / 8, .4 + rnd.NextDouble() / 8);
renderers[index].ResetCamera();
renderers[index].GetActiveCamera().Azimuth(30);
renderers[index].GetActiveCamera().Elevation(-50);
renderers[index].GetActiveCamera().Pitch(-2);
renderers[index].ResetCameraClippingRange();
}
}
}
/// <summary>
/// The main entry method called by the CSharp driver
/// </summary>
/// <param name="argv"></param>
public static void AVpickCells(String [] argv)
{
//Prefix Content is: ""
ren1 = vtkRenderer.New();
renWin = vtkRenderWindow.New();
renWin.AddRenderer((vtkRenderer)ren1);
iren = new vtkRenderWindowInteractor();
iren.SetRenderWindow((vtkRenderWindow)renWin);
// create a scene with one of each cell type[]
// Voxel[]
voxelPoints = new vtkPoints();
voxelPoints.SetNumberOfPoints((int)8);
voxelPoints.InsertPoint((int)0,(double)0,(double)0,(double)0);
voxelPoints.InsertPoint((int)1,(double)1,(double)0,(double)0);
voxelPoints.InsertPoint((int)2,(double)0,(double)1,(double)0);
voxelPoints.InsertPoint((int)3,(double)1,(double)1,(double)0);
voxelPoints.InsertPoint((int)4,(double)0,(double)0,(double)1);
voxelPoints.InsertPoint((int)5,(double)1,(double)0,(double)1);
voxelPoints.InsertPoint((int)6,(double)0,(double)1,(double)1);
voxelPoints.InsertPoint((int)7,(double)1,(double)1,(double)1);
aVoxel = new vtkVoxel();
aVoxel.GetPointIds().SetId((int)0,(int)0);
aVoxel.GetPointIds().SetId((int)1,(int)1);
aVoxel.GetPointIds().SetId((int)2,(int)2);
aVoxel.GetPointIds().SetId((int)3,(int)3);
aVoxel.GetPointIds().SetId((int)4,(int)4);
aVoxel.GetPointIds().SetId((int)5,(int)5);
aVoxel.GetPointIds().SetId((int)6,(int)6);
aVoxel.GetPointIds().SetId((int)7,(int)7);
aVoxelGrid = new vtkUnstructuredGrid();
aVoxelGrid.Allocate((int)1,(int)1);
aVoxelGrid.InsertNextCell((int)aVoxel.GetCellType(),(vtkIdList)aVoxel.GetPointIds());
aVoxelGrid.SetPoints((vtkPoints)voxelPoints);
aVoxelMapper = new vtkDataSetMapper();
aVoxelMapper.SetInput((vtkDataSet)aVoxelGrid);
aVoxelActor = new vtkActor();
aVoxelActor.SetMapper((vtkMapper)aVoxelMapper);
aVoxelActor.GetProperty().BackfaceCullingOn();
// Hexahedron[]
hexahedronPoints = new vtkPoints();
hexahedronPoints.SetNumberOfPoints((int)8);
hexahedronPoints.InsertPoint((int)0,(double)0,(double)0,(double)0);
hexahedronPoints.InsertPoint((int)1,(double)1,(double)0,(double)0);
hexahedronPoints.InsertPoint((int)2,(double)1,(double)1,(double)0);
hexahedronPoints.InsertPoint((int)3,(double)0,(double)1,(double)0);
hexahedronPoints.InsertPoint((int)4,(double)0,(double)0,(double)1);
hexahedronPoints.InsertPoint((int)5,(double)1,(double)0,(double)1);
hexahedronPoints.InsertPoint((int)6,(double)1,(double)1,(double)1);
hexahedronPoints.InsertPoint((int)7,(double)0,(double)1,(double)1);
aHexahedron = new vtkHexahedron();
aHexahedron.GetPointIds().SetId((int)0,(int)0);
aHexahedron.GetPointIds().SetId((int)1,(int)1);
aHexahedron.GetPointIds().SetId((int)2,(int)2);
aHexahedron.GetPointIds().SetId((int)3,(int)3);
aHexahedron.GetPointIds().SetId((int)4,(int)4);
aHexahedron.GetPointIds().SetId((int)5,(int)5);
aHexahedron.GetPointIds().SetId((int)6,(int)6);
aHexahedron.GetPointIds().SetId((int)7,(int)7);
aHexahedronGrid = new vtkUnstructuredGrid();
aHexahedronGrid.Allocate((int)1,(int)1);
aHexahedronGrid.InsertNextCell((int)aHexahedron.GetCellType(),(vtkIdList)aHexahedron.GetPointIds());
aHexahedronGrid.SetPoints((vtkPoints)hexahedronPoints);
aHexahedronMapper = new vtkDataSetMapper();
aHexahedronMapper.SetInput((vtkDataSet)aHexahedronGrid);
aHexahedronActor = new vtkActor();
aHexahedronActor.SetMapper((vtkMapper)aHexahedronMapper);
aHexahedronActor.AddPosition((double)2,(double)0,(double)0);
aHexahedronActor.GetProperty().BackfaceCullingOn();
// Tetra[]
tetraPoints = new vtkPoints();
tetraPoints.SetNumberOfPoints((int)4);
tetraPoints.InsertPoint((int)0,(double)0,(double)0,(double)0);
tetraPoints.InsertPoint((int)1,(double)1,(double)0,(double)0);
tetraPoints.InsertPoint((int)2,(double).5,(double)1,(double)0);
tetraPoints.InsertPoint((int)3,(double).5,(double).5,(double)1);
aTetra = new vtkTetra();
aTetra.GetPointIds().SetId((int)0,(int)0);
aTetra.GetPointIds().SetId((int)1,(int)1);
aTetra.GetPointIds().SetId((int)2,(int)2);
aTetra.GetPointIds().SetId((int)3,(int)3);
aTetraGrid = new vtkUnstructuredGrid();
aTetraGrid.Allocate((int)1,(int)1);
aTetraGrid.InsertNextCell((int)aTetra.GetCellType(),(vtkIdList)aTetra.GetPointIds());
aTetraGrid.SetPoints((vtkPoints)tetraPoints);
aTetraMapper = new vtkDataSetMapper();
aTetraMapper.SetInput((vtkDataSet)aTetraGrid);
aTetraActor = new vtkActor();
aTetraActor.SetMapper((vtkMapper)aTetraMapper);
aTetraActor.AddPosition((double)4,(double)0,(double)0);
aTetraActor.GetProperty().BackfaceCullingOn();
// Wedge[]
wedgePoints = new vtkPoints();
wedgePoints.SetNumberOfPoints((int)6);
wedgePoints.InsertPoint((int)0,(double)0,(double)1,(double)0);
wedgePoints.InsertPoint((int)1,(double)0,(double)0,(double)0);
wedgePoints.InsertPoint((int)2,(double)0,(double).5,(double).5);
wedgePoints.InsertPoint((int)3,(double)1,(double)1,(double)0);
wedgePoints.InsertPoint((int)4,(double)1,(double)0,(double)0);
wedgePoints.InsertPoint((int)5,(double)1,(double).5,(double).5);
aWedge = new vtkWedge();
aWedge.GetPointIds().SetId((int)0,(int)0);
aWedge.GetPointIds().SetId((int)1,(int)1);
aWedge.GetPointIds().SetId((int)2,(int)2);
aWedge.GetPointIds().SetId((int)3,(int)3);
aWedge.GetPointIds().SetId((int)4,(int)4);
aWedge.GetPointIds().SetId((int)5,(int)5);
aWedgeGrid = new vtkUnstructuredGrid();
aWedgeGrid.Allocate((int)1,(int)1);
aWedgeGrid.InsertNextCell((int)aWedge.GetCellType(),(vtkIdList)aWedge.GetPointIds());
aWedgeGrid.SetPoints((vtkPoints)wedgePoints);
aWedgeMapper = new vtkDataSetMapper();
aWedgeMapper.SetInput((vtkDataSet)aWedgeGrid);
aWedgeActor = new vtkActor();
aWedgeActor.SetMapper((vtkMapper)aWedgeMapper);
aWedgeActor.AddPosition((double)6,(double)0,(double)0);
aWedgeActor.GetProperty().BackfaceCullingOn();
// Pyramid[]
pyramidPoints = new vtkPoints();
pyramidPoints.SetNumberOfPoints((int)5);
pyramidPoints.InsertPoint((int)0,(double)0,(double)0,(double)0);
pyramidPoints.InsertPoint((int)1,(double)1,(double)0,(double)0);
pyramidPoints.InsertPoint((int)2,(double)1,(double)1,(double)0);
pyramidPoints.InsertPoint((int)3,(double)0,(double)1,(double)0);
pyramidPoints.InsertPoint((int)4,(double).5,(double).5,(double)1);
aPyramid = new vtkPyramid();
aPyramid.GetPointIds().SetId((int)0,(int)0);
aPyramid.GetPointIds().SetId((int)1,(int)1);
aPyramid.GetPointIds().SetId((int)2,(int)2);
aPyramid.GetPointIds().SetId((int)3,(int)3);
aPyramid.GetPointIds().SetId((int)4,(int)4);
aPyramidGrid = new vtkUnstructuredGrid();
aPyramidGrid.Allocate((int)1,(int)1);
aPyramidGrid.InsertNextCell((int)aPyramid.GetCellType(),(vtkIdList)aPyramid.GetPointIds());
aPyramidGrid.SetPoints((vtkPoints)pyramidPoints);
aPyramidMapper = new vtkDataSetMapper();
aPyramidMapper.SetInput((vtkDataSet)aPyramidGrid);
aPyramidActor = new vtkActor();
aPyramidActor.SetMapper((vtkMapper)aPyramidMapper);
aPyramidActor.AddPosition((double)8,(double)0,(double)0);
aPyramidActor.GetProperty().BackfaceCullingOn();
// Pixel[]
pixelPoints = new vtkPoints();
pixelPoints.SetNumberOfPoints((int)4);
pixelPoints.InsertPoint((int)0,(double)0,(double)0,(double)0);
pixelPoints.InsertPoint((int)1,(double)1,(double)0,(double)0);
pixelPoints.InsertPoint((int)2,(double)0,(double)1,(double)0);
pixelPoints.InsertPoint((int)3,(double)1,(double)1,(double)0);
aPixel = new vtkPixel();
aPixel.GetPointIds().SetId((int)0,(int)0);
aPixel.GetPointIds().SetId((int)1,(int)1);
aPixel.GetPointIds().SetId((int)2,(int)2);
aPixel.GetPointIds().SetId((int)3,(int)3);
aPixelGrid = new vtkUnstructuredGrid();
aPixelGrid.Allocate((int)1,(int)1);
aPixelGrid.InsertNextCell((int)aPixel.GetCellType(),(vtkIdList)aPixel.GetPointIds());
aPixelGrid.SetPoints((vtkPoints)pixelPoints);
aPixelMapper = new vtkDataSetMapper();
aPixelMapper.SetInput((vtkDataSet)aPixelGrid);
aPixelActor = new vtkActor();
aPixelActor.SetMapper((vtkMapper)aPixelMapper);
aPixelActor.AddPosition((double)0,(double)0,(double)2);
aPixelActor.GetProperty().BackfaceCullingOn();
// Quad[]
quadPoints = new vtkPoints();
quadPoints.SetNumberOfPoints((int)4);
quadPoints.InsertPoint((int)0,(double)0,(double)0,(double)0);
quadPoints.InsertPoint((int)1,(double)1,(double)0,(double)0);
quadPoints.InsertPoint((int)2,(double)1,(double)1,(double)0);
quadPoints.InsertPoint((int)3,(double)0,(double)1,(double)0);
aQuad = new vtkQuad();
aQuad.GetPointIds().SetId((int)0,(int)0);
aQuad.GetPointIds().SetId((int)1,(int)1);
aQuad.GetPointIds().SetId((int)2,(int)2);
aQuad.GetPointIds().SetId((int)3,(int)3);
aQuadGrid = new vtkUnstructuredGrid();
aQuadGrid.Allocate((int)1,(int)1);
aQuadGrid.InsertNextCell((int)aQuad.GetCellType(),(vtkIdList)aQuad.GetPointIds());
aQuadGrid.SetPoints((vtkPoints)quadPoints);
aQuadMapper = new vtkDataSetMapper();
aQuadMapper.SetInput((vtkDataSet)aQuadGrid);
aQuadActor = new vtkActor();
aQuadActor.SetMapper((vtkMapper)aQuadMapper);
aQuadActor.AddPosition((double)2,(double)0,(double)2);
aQuadActor.GetProperty().BackfaceCullingOn();
// Triangle[]
trianglePoints = new vtkPoints();
trianglePoints.SetNumberOfPoints((int)3);
trianglePoints.InsertPoint((int)0,(double)0,(double)0,(double)0);
trianglePoints.InsertPoint((int)1,(double)1,(double)0,(double)0);
trianglePoints.InsertPoint((int)2,(double).5,(double).5,(double)0);
aTriangle = new vtkTriangle();
aTriangle.GetPointIds().SetId((int)0,(int)0);
aTriangle.GetPointIds().SetId((int)1,(int)1);
aTriangle.GetPointIds().SetId((int)2,(int)2);
aTriangleGrid = new vtkUnstructuredGrid();
aTriangleGrid.Allocate((int)1,(int)1);
aTriangleGrid.InsertNextCell((int)aTriangle.GetCellType(),(vtkIdList)aTriangle.GetPointIds());
aTriangleGrid.SetPoints((vtkPoints)trianglePoints);
aTriangleMapper = new vtkDataSetMapper();
aTriangleMapper.SetInput((vtkDataSet)aTriangleGrid);
aTriangleActor = new vtkActor();
aTriangleActor.SetMapper((vtkMapper)aTriangleMapper);
aTriangleActor.AddPosition((double)4,(double)0,(double)2);
aTriangleActor.GetProperty().BackfaceCullingOn();
// Polygon[]
polygonPoints = new vtkPoints();
polygonPoints.SetNumberOfPoints((int)4);
polygonPoints.InsertPoint((int)0,(double)0,(double)0,(double)0);
polygonPoints.InsertPoint((int)1,(double)1,(double)0,(double)0);
polygonPoints.InsertPoint((int)2,(double)1,(double)1,(double)0);
polygonPoints.InsertPoint((int)3,(double)0,(double)1,(double)0);
aPolygon = new vtkPolygon();
aPolygon.GetPointIds().SetNumberOfIds((int)4);
aPolygon.GetPointIds().SetId((int)0,(int)0);
aPolygon.GetPointIds().SetId((int)1,(int)1);
aPolygon.GetPointIds().SetId((int)2,(int)2);
aPolygon.GetPointIds().SetId((int)3,(int)3);
aPolygonGrid = new vtkUnstructuredGrid();
aPolygonGrid.Allocate((int)1,(int)1);
aPolygonGrid.InsertNextCell((int)aPolygon.GetCellType(),(vtkIdList)aPolygon.GetPointIds());
aPolygonGrid.SetPoints((vtkPoints)polygonPoints);
aPolygonMapper = new vtkDataSetMapper();
aPolygonMapper.SetInput((vtkDataSet)aPolygonGrid);
aPolygonActor = new vtkActor();
aPolygonActor.SetMapper((vtkMapper)aPolygonMapper);
aPolygonActor.AddPosition((double)6,(double)0,(double)2);
aPolygonActor.GetProperty().BackfaceCullingOn();
// Triangle Strip[]
triangleStripPoints = new vtkPoints();
triangleStripPoints.SetNumberOfPoints((int)5);
triangleStripPoints.InsertPoint((int)0,(double)0,(double)1,(double)0);
triangleStripPoints.InsertPoint((int)1,(double)0,(double)0,(double)0);
triangleStripPoints.InsertPoint((int)2,(double)1,(double)1,(double)0);
triangleStripPoints.InsertPoint((int)3,(double)1,(double)0,(double)0);
triangleStripPoints.InsertPoint((int)4,(double)2,(double)1,(double)0);
aTriangleStrip = new vtkTriangleStrip();
aTriangleStrip.GetPointIds().SetNumberOfIds((int)5);
aTriangleStrip.GetPointIds().SetId((int)0,(int)0);
aTriangleStrip.GetPointIds().SetId((int)1,(int)1);
aTriangleStrip.GetPointIds().SetId((int)2,(int)2);
aTriangleStrip.GetPointIds().SetId((int)3,(int)3);
aTriangleStrip.GetPointIds().SetId((int)4,(int)4);
aTriangleStripGrid = new vtkUnstructuredGrid();
aTriangleStripGrid.Allocate((int)1,(int)1);
aTriangleStripGrid.InsertNextCell((int)aTriangleStrip.GetCellType(),(vtkIdList)aTriangleStrip.GetPointIds());
aTriangleStripGrid.SetPoints((vtkPoints)triangleStripPoints);
aTriangleStripMapper = new vtkDataSetMapper();
aTriangleStripMapper.SetInput((vtkDataSet)aTriangleStripGrid);
aTriangleStripActor = new vtkActor();
aTriangleStripActor.SetMapper((vtkMapper)aTriangleStripMapper);
aTriangleStripActor.AddPosition((double)8,(double)0,(double)2);
aTriangleStripActor.GetProperty().BackfaceCullingOn();
// Line[]
linePoints = new vtkPoints();
linePoints.SetNumberOfPoints((int)2);
linePoints.InsertPoint((int)0,(double)0,(double)0,(double)0);
linePoints.InsertPoint((int)1,(double)1,(double)1,(double)0);
aLine = new vtkLine();
aLine.GetPointIds().SetId((int)0,(int)0);
aLine.GetPointIds().SetId((int)1,(int)1);
aLineGrid = new vtkUnstructuredGrid();
aLineGrid.Allocate((int)1,(int)1);
aLineGrid.InsertNextCell((int)aLine.GetCellType(),(vtkIdList)aLine.GetPointIds());
aLineGrid.SetPoints((vtkPoints)linePoints);
aLineMapper = new vtkDataSetMapper();
aLineMapper.SetInput((vtkDataSet)aLineGrid);
aLineActor = new vtkActor();
aLineActor.SetMapper((vtkMapper)aLineMapper);
aLineActor.AddPosition((double)0,(double)0,(double)4);
aLineActor.GetProperty().BackfaceCullingOn();
// Poly line[]
polyLinePoints = new vtkPoints();
polyLinePoints.SetNumberOfPoints((int)3);
polyLinePoints.InsertPoint((int)0,(double)0,(double)0,(double)0);
polyLinePoints.InsertPoint((int)1,(double)1,(double)1,(double)0);
polyLinePoints.InsertPoint((int)2,(double)1,(double)0,(double)0);
aPolyLine = new vtkPolyLine();
aPolyLine.GetPointIds().SetNumberOfIds((int)3);
aPolyLine.GetPointIds().SetId((int)0,(int)0);
aPolyLine.GetPointIds().SetId((int)1,(int)1);
aPolyLine.GetPointIds().SetId((int)2,(int)2);
aPolyLineGrid = new vtkUnstructuredGrid();
aPolyLineGrid.Allocate((int)1,(int)1);
aPolyLineGrid.InsertNextCell((int)aPolyLine.GetCellType(),(vtkIdList)aPolyLine.GetPointIds());
aPolyLineGrid.SetPoints((vtkPoints)polyLinePoints);
aPolyLineMapper = new vtkDataSetMapper();
aPolyLineMapper.SetInput((vtkDataSet)aPolyLineGrid);
aPolyLineActor = new vtkActor();
aPolyLineActor.SetMapper((vtkMapper)aPolyLineMapper);
aPolyLineActor.AddPosition((double)2,(double)0,(double)4);
aPolyLineActor.GetProperty().BackfaceCullingOn();
// Vertex[]
vertexPoints = new vtkPoints();
vertexPoints.SetNumberOfPoints((int)1);
vertexPoints.InsertPoint((int)0,(double)0,(double)0,(double)0);
aVertex = new vtkVertex();
aVertex.GetPointIds().SetId((int)0,(int)0);
aVertexGrid = new vtkUnstructuredGrid();
aVertexGrid.Allocate((int)1,(int)1);
aVertexGrid.InsertNextCell((int)aVertex.GetCellType(),(vtkIdList)aVertex.GetPointIds());
aVertexGrid.SetPoints((vtkPoints)vertexPoints);
aVertexMapper = new vtkDataSetMapper();
aVertexMapper.SetInput((vtkDataSet)aVertexGrid);
aVertexActor = new vtkActor();
aVertexActor.SetMapper((vtkMapper)aVertexMapper);
aVertexActor.AddPosition((double)0,(double)0,(double)6);
aVertexActor.GetProperty().BackfaceCullingOn();
// Poly Vertex[]
polyVertexPoints = new vtkPoints();
polyVertexPoints.SetNumberOfPoints((int)3);
polyVertexPoints.InsertPoint((int)0,(double)0,(double)0,(double)0);
polyVertexPoints.InsertPoint((int)1,(double)1,(double)0,(double)0);
polyVertexPoints.InsertPoint((int)2,(double)1,(double)1,(double)0);
aPolyVertex = new vtkPolyVertex();
aPolyVertex.GetPointIds().SetNumberOfIds((int)3);
aPolyVertex.GetPointIds().SetId((int)0,(int)0);
aPolyVertex.GetPointIds().SetId((int)1,(int)1);
aPolyVertex.GetPointIds().SetId((int)2,(int)2);
aPolyVertexGrid = new vtkUnstructuredGrid();
aPolyVertexGrid.Allocate((int)1,(int)1);
aPolyVertexGrid.InsertNextCell((int)aPolyVertex.GetCellType(),(vtkIdList)aPolyVertex.GetPointIds());
aPolyVertexGrid.SetPoints((vtkPoints)polyVertexPoints);
aPolyVertexMapper = new vtkDataSetMapper();
aPolyVertexMapper.SetInput((vtkDataSet)aPolyVertexGrid);
aPolyVertexActor = new vtkActor();
aPolyVertexActor.SetMapper((vtkMapper)aPolyVertexMapper);
aPolyVertexActor.AddPosition((double)2,(double)0,(double)6);
aPolyVertexActor.GetProperty().BackfaceCullingOn();
// Pentagonal prism[]
pentaPoints = new vtkPoints();
pentaPoints.SetNumberOfPoints((int)10);
pentaPoints.InsertPoint((int)0,(double)0.25,(double)0.0,(double)0.0);
pentaPoints.InsertPoint((int)1,(double)0.75,(double)0.0,(double)0.0);
pentaPoints.InsertPoint((int)2,(double)1.0,(double)0.5,(double)0.0);
pentaPoints.InsertPoint((int)3,(double)0.5,(double)1.0,(double)0.0);
pentaPoints.InsertPoint((int)4,(double)0.0,(double)0.5,(double)0.0);
pentaPoints.InsertPoint((int)5,(double)0.25,(double)0.0,(double)1.0);
pentaPoints.InsertPoint((int)6,(double)0.75,(double)0.0,(double)1.0);
pentaPoints.InsertPoint((int)7,(double)1.0,(double)0.5,(double)1.0);
pentaPoints.InsertPoint((int)8,(double)0.5,(double)1.0,(double)1.0);
pentaPoints.InsertPoint((int)9,(double)0.0,(double)0.5,(double)1.0);
aPenta = new vtkPentagonalPrism();
aPenta.GetPointIds().SetId((int)0,(int)0);
aPenta.GetPointIds().SetId((int)1,(int)1);
aPenta.GetPointIds().SetId((int)2,(int)2);
aPenta.GetPointIds().SetId((int)3,(int)3);
aPenta.GetPointIds().SetId((int)4,(int)4);
aPenta.GetPointIds().SetId((int)5,(int)5);
aPenta.GetPointIds().SetId((int)6,(int)6);
aPenta.GetPointIds().SetId((int)7,(int)7);
aPenta.GetPointIds().SetId((int)8,(int)8);
aPenta.GetPointIds().SetId((int)9,(int)9);
aPentaGrid = new vtkUnstructuredGrid();
aPentaGrid.Allocate((int)1,(int)1);
aPentaGrid.InsertNextCell((int)aPenta.GetCellType(),(vtkIdList)aPenta.GetPointIds());
aPentaGrid.SetPoints((vtkPoints)pentaPoints);
aPentaMapper = new vtkDataSetMapper();
aPentaMapper.SetInput((vtkDataSet)aPentaGrid);
aPentaActor = new vtkActor();
aPentaActor.SetMapper((vtkMapper)aPentaMapper);
aPentaActor.AddPosition((double)10,(double)0,(double)0);
aPentaActor.GetProperty().BackfaceCullingOn();
// Hexagonal prism[]
hexaPoints = new vtkPoints();
hexaPoints.SetNumberOfPoints((int)12);
hexaPoints.InsertPoint((int)0,(double)0.0,(double)0.0,(double)0.0);
hexaPoints.InsertPoint((int)1,(double)0.5,(double)0.0,(double)0.0);
hexaPoints.InsertPoint((int)2,(double)1.0,(double)0.5,(double)0.0);
hexaPoints.InsertPoint((int)3,(double)1.0,(double)1.0,(double)0.0);
hexaPoints.InsertPoint((int)4,(double)0.5,(double)1.0,(double)0.0);
hexaPoints.InsertPoint((int)5,(double)0.0,(double)0.5,(double)0.0);
hexaPoints.InsertPoint((int)6,(double)0.0,(double)0.0,(double)1.0);
hexaPoints.InsertPoint((int)7,(double)0.5,(double)0.0,(double)1.0);
hexaPoints.InsertPoint((int)8,(double)1.0,(double)0.5,(double)1.0);
hexaPoints.InsertPoint((int)9,(double)1.0,(double)1.0,(double)1.0);
hexaPoints.InsertPoint((int)10,(double)0.5,(double)1.0,(double)1.0);
hexaPoints.InsertPoint((int)11,(double)0.0,(double)0.5,(double)1.0);
aHexa = new vtkHexagonalPrism();
aHexa.GetPointIds().SetId((int)0,(int)0);
aHexa.GetPointIds().SetId((int)1,(int)1);
aHexa.GetPointIds().SetId((int)2,(int)2);
aHexa.GetPointIds().SetId((int)3,(int)3);
aHexa.GetPointIds().SetId((int)4,(int)4);
aHexa.GetPointIds().SetId((int)5,(int)5);
aHexa.GetPointIds().SetId((int)6,(int)6);
aHexa.GetPointIds().SetId((int)7,(int)7);
aHexa.GetPointIds().SetId((int)8,(int)8);
aHexa.GetPointIds().SetId((int)9,(int)9);
aHexa.GetPointIds().SetId((int)10,(int)10);
aHexa.GetPointIds().SetId((int)11,(int)11);
aHexaGrid = new vtkUnstructuredGrid();
aHexaGrid.Allocate((int)1,(int)1);
aHexaGrid.InsertNextCell((int)aHexa.GetCellType(),(vtkIdList)aHexa.GetPointIds());
aHexaGrid.SetPoints((vtkPoints)hexaPoints);
aHexaMapper = new vtkDataSetMapper();
aHexaMapper.SetInput((vtkDataSet)aHexaGrid);
aHexaActor = new vtkActor();
aHexaActor.SetMapper((vtkMapper)aHexaMapper);
aHexaActor.AddPosition((double)12,(double)0,(double)0);
aHexaActor.GetProperty().BackfaceCullingOn();
ren1.SetBackground((double).1,(double).2,(double).4);
ren1.AddActor((vtkProp)aVoxelActor);
aVoxelActor.GetProperty().SetDiffuseColor((double)1,(double)0,(double)0);
ren1.AddActor((vtkProp)aHexahedronActor);
aHexahedronActor.GetProperty().SetDiffuseColor((double)1,(double)1,(double)0);
ren1.AddActor((vtkProp)aTetraActor);
aTetraActor.GetProperty().SetDiffuseColor((double)0,(double)1,(double)0);
ren1.AddActor((vtkProp)aWedgeActor);
aWedgeActor.GetProperty().SetDiffuseColor((double)0,(double)1,(double)1);
ren1.AddActor((vtkProp)aPyramidActor);
aPyramidActor.GetProperty().SetDiffuseColor((double)1,(double)0,(double)1);
ren1.AddActor((vtkProp)aPixelActor);
aPixelActor.GetProperty().SetDiffuseColor((double)0,(double)1,(double)1);
ren1.AddActor((vtkProp)aQuadActor);
aQuadActor.GetProperty().SetDiffuseColor((double)1,(double)0,(double)1);
ren1.AddActor((vtkProp)aTriangleActor);
aTriangleActor.GetProperty().SetDiffuseColor((double).3,(double)1,(double).5);
ren1.AddActor((vtkProp)aPolygonActor);
aPolygonActor.GetProperty().SetDiffuseColor((double)1,(double).4,(double).5);
ren1.AddActor((vtkProp)aTriangleStripActor);
aTriangleStripActor.GetProperty().SetDiffuseColor((double).3,(double).7,(double)1);
ren1.AddActor((vtkProp)aLineActor);
aLineActor.GetProperty().SetDiffuseColor((double).2,(double)1,(double)1);
ren1.AddActor((vtkProp)aPolyLineActor);
aPolyLineActor.GetProperty().SetDiffuseColor((double)1,(double)1,(double)1);
ren1.AddActor((vtkProp)aVertexActor);
aVertexActor.GetProperty().SetDiffuseColor((double)1,(double)1,(double)1);
ren1.AddActor((vtkProp)aPolyVertexActor);
aPolyVertexActor.GetProperty().SetDiffuseColor((double)1,(double)1,(double)1);
ren1.AddActor((vtkProp)aPentaActor);
aPentaActor.GetProperty().SetDiffuseColor((double).2,(double).4,(double).7);
ren1.AddActor((vtkProp)aHexaActor);
aHexaActor.GetProperty().SetDiffuseColor((double).7,(double).5,(double)1);
ren1.ResetCamera();
ren1.GetActiveCamera().Azimuth((double)30);
ren1.GetActiveCamera().Elevation((double)20);
ren1.GetActiveCamera().Dolly((double)1.25);
ren1.ResetCameraClippingRange();
renWin.Render();
cellPicker = new vtkCellPicker();
pointPicker = new vtkPointPicker();
worldPicker = new vtkWorldPointPicker();
cellCount = 0;
pointCount = 0;
ren1.IsInViewport((int)0,(int)0);
x = 0;
while((x) <= 265)
{
y = 100;
while((y) <= 200)
{
cellPicker.Pick((double)x,(double)y,(double)0,(vtkRenderer)ren1);
pointPicker.Pick((double)x,(double)y,(double)0,(vtkRenderer)ren1);
worldPicker.Pick((double)x,(double)y,(double)0,(vtkRenderer)ren1);
if ((cellPicker.GetCellId()) != -1)
{
cellCount = cellCount + 1;
}
if ((pointPicker.GetPointId()) != -1)
{
pointCount = pointCount + 1;
}
y = y + 6;
}
x = x + 6;
}
// render the image[]
//[]
iren.Initialize();
//deleteAllVTKObjects();
}
/// <summary>
/// The main entry method called by the CSharp driver
/// </summary>
/// <param name="argv"></param>
public static void AVmergeFilter(String [] argv)
{
//Prefix Content is: ""
// Create the RenderWindow, Renderer and both Actors[]
//[]
ren1 = vtkRenderer.New();
ren2 = vtkRenderer.New();
renWin = vtkRenderWindow.New();
renWin.AddRenderer((vtkRenderer)ren1);
renWin.AddRenderer((vtkRenderer)ren2);
iren = new vtkRenderWindowInteractor();
iren.SetRenderWindow((vtkRenderWindow)renWin);
// create pipeline[]
//[]
pl3d = new vtkPLOT3DReader();
pl3d.SetXYZFileName((string)"" + (VTK_DATA_ROOT.ToString()) + "/Data/combxyz.bin");
pl3d.SetQFileName((string)"" + (VTK_DATA_ROOT.ToString()) + "/Data/combq.bin");
pl3d.SetScalarFunctionNumber((int)110);
pl3d.SetVectorFunctionNumber((int)202);
pl3d.Update();
probeLine = new vtkLineSource();
probeLine.SetPoint1((double)1,(double)1,(double)29);
probeLine.SetPoint2((double)16.5,(double)5,(double)31.7693);
probeLine.SetResolution((int)500);
probe = new vtkProbeFilter();
probe.SetInputConnection((vtkAlgorithmOutput)probeLine.GetOutputPort());
probe.SetSource((vtkDataObject)pl3d.GetOutput());
probeTube = new vtkTubeFilter();
probeTube.SetInput((vtkDataObject)probe.GetPolyDataOutput());
probeTube.SetNumberOfSides((int)5);
probeTube.SetRadius((double).05);
probeMapper = vtkPolyDataMapper.New();
probeMapper.SetInputConnection((vtkAlgorithmOutput)probeTube.GetOutputPort());
probeMapper.SetScalarRange((double)((vtkDataSet)pl3d.GetOutput()).GetScalarRange()[0],
(double)((vtkDataSet)pl3d.GetOutput()).GetScalarRange()[1]);
probeActor = new vtkActor();
probeActor.SetMapper((vtkMapper)probeMapper);
displayLine = new vtkLineSource();
displayLine.SetPoint1((double)0,(double)0,(double)0);
displayLine.SetPoint2((double)1,(double)0,(double)0);
displayLine.SetResolution((int)probeLine.GetResolution());
displayMerge = new vtkMergeFilter();
displayMerge.SetGeometry((vtkDataSet)displayLine.GetOutput());
displayMerge.SetScalars((vtkDataSet)probe.GetPolyDataOutput());
displayWarp = new vtkWarpScalar();
displayWarp.SetInput((vtkDataObject)displayMerge.GetPolyDataOutput());
displayWarp.SetNormal((double)0,(double)1,(double)0);
displayWarp.SetScaleFactor((double).000001);
displayMapper = vtkPolyDataMapper.New();
displayMapper.SetInput((vtkPolyData)displayWarp.GetPolyDataOutput());
displayMapper.SetScalarRange((double)((vtkDataSet)pl3d.GetOutput()).GetScalarRange()[0],
(double)((vtkDataSet)pl3d.GetOutput()).GetScalarRange()[1]);
displayActor = new vtkActor();
displayActor.SetMapper((vtkMapper)displayMapper);
outline = new vtkStructuredGridOutlineFilter();
outline.SetInputConnection((vtkAlgorithmOutput)pl3d.GetOutputPort());
outlineMapper = vtkPolyDataMapper.New();
outlineMapper.SetInputConnection((vtkAlgorithmOutput)outline.GetOutputPort());
outlineActor = new vtkActor();
outlineActor.SetMapper((vtkMapper)outlineMapper);
outlineActor.GetProperty().SetColor((double)0,(double)0,(double)0);
ren1.AddActor((vtkProp)outlineActor);
ren1.AddActor((vtkProp)probeActor);
ren1.SetBackground((double)1,(double)1,(double)1);
ren1.SetViewport((double)0,(double).25,(double)1,(double)1);
ren2.AddActor((vtkProp)displayActor);
ren2.SetBackground((double)0,(double)0,(double)0);
ren2.SetViewport((double)0,(double)0,(double)1,(double).25);
renWin.SetSize((int)300,(int)300);
ren1.ResetCamera();
cam1 = ren1.GetActiveCamera();
cam1.SetClippingRange((double)3.95297,(double)50);
cam1.SetFocalPoint((double)8.88908,(double)0.595038,(double)29.3342);
cam1.SetPosition((double)9.9,(double)-26,(double)41);
cam1.SetViewUp((double)0.060772,(double)-0.319905,(double)0.945498);
ren2.ResetCamera();
cam2 = ren2.GetActiveCamera();
cam2.ParallelProjectionOn();
cam2.SetParallelScale((double).15);
iren.Initialize();
// render the image[]
//[]
// prevent the tk window from showing up then start the event loop[]
//deleteAllVTKObjects();
}
/// <summary>
/// The main entry method called by the CSharp driver
/// </summary>
/// <param name="argv"></param>
public static void AVcursor3D(String [] argv)
{
//Prefix Content is: ""
// This little example shows how a cursor can be created in []
// image viewers, and renderers. The standard TkImageViewerWidget and[]
// TkRenderWidget bindings are used. There is a new binding:[]
// middle button in the image viewer sets the position of the cursor. []
// First we include the VTK Tcl packages which will make available []
// all of the vtk commands to Tcl[]
// Global values[]
CURSOR_X = 20;
CURSOR_Y = 20;
CURSOR_Z = 20;
IMAGE_MAG_X = 4;
IMAGE_MAG_Y = 4;
IMAGE_MAG_Z = 1;
// Pipeline stuff[]
reader = new vtkSLCReader();
reader.SetFileName((string)"" + (VTK_DATA_ROOT.ToString()) + "/Data/neghip.slc");
// Cursor stuff[]
magnify = new vtkImageMagnify();
magnify.SetInputConnection((vtkAlgorithmOutput)reader.GetOutputPort());
magnify.SetMagnificationFactors((int)IMAGE_MAG_X,(int)IMAGE_MAG_Y,(int)IMAGE_MAG_Z);
image_cursor = new vtkImageCursor3D();
image_cursor.SetInputConnection((vtkAlgorithmOutput)magnify.GetOutputPort());
image_cursor.SetCursorPosition((double)CURSOR_X*IMAGE_MAG_X,(double)CURSOR_Y*IMAGE_MAG_Y,(double)CURSOR_Z*IMAGE_MAG_Z);
image_cursor.SetCursorValue((double)255);
image_cursor.SetCursorRadius((int)50*IMAGE_MAG_X);
axes = new vtkAxes();
axes.SymmetricOn();
axes.SetOrigin((double)CURSOR_X,(double)CURSOR_Y,(double)CURSOR_Z);
axes.SetScaleFactor((double)50.0);
axes_mapper = vtkPolyDataMapper.New();
axes_mapper.SetInputConnection((vtkAlgorithmOutput)axes.GetOutputPort());
axesActor = new vtkActor();
axesActor.SetMapper((vtkMapper)axes_mapper);
axesActor.GetProperty().SetAmbient((double)0.5);
// Image viewer stuff[]
viewer = new vtkImageViewer();
viewer.SetInputConnection((vtkAlgorithmOutput)image_cursor.GetOutputPort());
viewer.SetZSlice((int)CURSOR_Z*IMAGE_MAG_Z);
viewer.SetColorWindow((double)256);
viewer.SetColorLevel((double)128);
//method moved
//method moved
//method moved
// Create transfer functions for opacity and color[]
opacity_transfer_function = new vtkPiecewiseFunction();
opacity_transfer_function.AddPoint((double)20,(double)0.0);
opacity_transfer_function.AddPoint((double)255,(double)0.2);
color_transfer_function = new vtkColorTransferFunction();
color_transfer_function.AddRGBPoint((double)0,(double)0,(double)0,(double)0);
color_transfer_function.AddRGBPoint((double)64,(double)1,(double)0,(double)0);
color_transfer_function.AddRGBPoint((double)128,(double)0,(double)0,(double)1);
color_transfer_function.AddRGBPoint((double)192,(double)0,(double)1,(double)0);
color_transfer_function.AddRGBPoint((double)255,(double)0,(double).2,(double)0);
// Create properties, mappers, volume actors, and ray cast function[]
volume_property = new vtkVolumeProperty();
volume_property.SetColor((vtkColorTransferFunction)color_transfer_function);
volume_property.SetScalarOpacity((vtkPiecewiseFunction)opacity_transfer_function);
composite_function = new vtkVolumeRayCastCompositeFunction();
volume_mapper = new vtkVolumeRayCastMapper();
volume_mapper.SetInputConnection((vtkAlgorithmOutput)reader.GetOutputPort());
volume_mapper.SetVolumeRayCastFunction((vtkVolumeRayCastFunction)composite_function);
volume = new vtkVolume();
volume.SetMapper((vtkAbstractVolumeMapper)volume_mapper);
volume.SetProperty((vtkVolumeProperty)volume_property);
// Create outline[]
outline = new vtkOutlineFilter();
outline.SetInputConnection((vtkAlgorithmOutput)reader.GetOutputPort());
outline_mapper = vtkPolyDataMapper.New();
outline_mapper.SetInputConnection((vtkAlgorithmOutput)outline.GetOutputPort());
outlineActor = new vtkActor();
outlineActor.SetMapper((vtkMapper)outline_mapper);
outlineActor.GetProperty().SetColor((double)1,(double)1,(double)1);
// Create the renderer[]
ren1 = vtkRenderer.New();
ren1.AddActor((vtkProp)axesActor);
ren1.AddVolume((vtkProp)volume);
ren1.SetBackground((double)0.1,(double)0.2,(double)0.4);
renWin2 = vtkRenderWindow.New();
renWin2.AddRenderer((vtkRenderer)ren1);
renWin2.SetSize((int)256,(int)256);
// Create the GUI: two renderer widgets and a quit button[]
//tk window skipped..
// Set the window manager (wm command) so that it registers a[]
// command to handle the WM_DELETE_WINDOW protocal request. This[]
// request is triggered when the widget is closed using the standard[]
// window manager icons or buttons. In this case the exit callback[]
// will be called and it will free up any objects we created then exit[]
// the application.[]
// Help label, frame and quit button[]
//tk window skipped..
//tk window skipped..
//tk window skipped..
//deleteAllVTKObjects();
}
