public static void SaveData(int ratio, string filename) { try { SimplePointFile.OpenWriteFile(filename); var color = PolyData.GetPointData().GetScalars(); for (var i = 0; i < ImageHeight; i += ratio) { for (var j = 0; j < ImageWidth; j += ratio) { var data = PolyData.GetPoint(i * ImageWidth + j); var c = color.GetComponent(i * ImageWidth + j, 0); SimplePointFile.Writeline(new[] { data[0] / ratio, data[1] / ratio, data[2], c, c, c }); } } } catch (Exception) { } finally { SimplePointFile.CloseWriteFile(); } }
private static void NullPoint() { vtkPoints points = vtkPoints.New(); points.InsertNextPoint(1, 1, 1); points.InsertNextPoint(2, 2, 2); points.InsertNextPoint(3, 3, 3); vtkPolyData polydata = vtkPolyData.New(); polydata.SetPoints(points); vtkFloatArray floatArray = vtkFloatArray.New(); floatArray.SetNumberOfValues(3); floatArray.SetNumberOfComponents(1); floatArray.SetName("FloatArray"); for (int i = 0; i < 3; i++) { floatArray.SetValue(i, 2); } polydata.GetPointData().AddArray(floatArray); vtkIntArray intArray = vtkIntArray.New(); intArray.SetNumberOfValues(3); intArray.SetNumberOfComponents(1); intArray.SetName("IntArray"); for (int i = 0; i < 3; i++) { intArray.SetValue(i, 2); } polydata.GetPointData().AddArray(intArray); Console.WriteLine("PointIdx x y z " + "floatArray" + " " + "intArray"); Console.WriteLine("----------------------------------------"); for (int i = 0; i < 3; i++) { double[] p = polydata.GetPoint(i); vtkFloatArray pointsFloatArray = vtkFloatArray.SafeDownCast(polydata.GetPointData().GetArray("FloatArray")); vtkIntArray pointsIntArray = vtkIntArray.SafeDownCast(polydata.GetPointData().GetArray("IntArray")); Console.WriteLine(" " + i + " " + p[0] + " " + p[1] + " " + p[2] + " " + pointsFloatArray.GetValue(i) + " " + pointsIntArray.GetValue(i)); } polydata.GetPointData().NullPoint(1); polydata.Modified(); Console.WriteLine(""); for (int i = 0; i < 3; i++) { double[] p = polydata.GetPoint(i); vtkFloatArray pointsFloatArray = vtkFloatArray.SafeDownCast(polydata.GetPointData().GetArray("FloatArray")); vtkIntArray pointsIntArray = vtkIntArray.SafeDownCast(polydata.GetPointData().GetArray("IntArray")); Console.WriteLine(" " + i + " " + p[0] + " " + p[1] + " " + p[2] + " " + pointsFloatArray.GetValue(i) + " " + pointsIntArray.GetValue(i)); } }
public static void GetRectData(vtkPolyData data, Rectangle rect) { var points = vtkPoints.New(); var colorArray = vtkUnsignedCharArray.New(); colorArray.SetNumberOfComponents(3); RectImageData = vtkImageData.New(); RectImageData.SetExtent(0, rect.Size.Width - 1, 0, rect.Size.Height - 1, 0, 0); RectImageData.SetNumberOfScalarComponents(1); RectImageData.SetScalarTypeToUnsignedChar(); for (var i = rect.Top; i < rect.Bottom; i++) { for (var j = rect.Left; j < rect.Right; j++) { double[] p = data.GetPoint(i * ImageWidth + j); points.InsertNextPoint(j - rect.Left, i - rect.Top, p[2]); double[] c = data.GetPointData().GetScalars().GetTuple3(i * ImageWidth + j); colorArray.InsertNextTuple3(c[0], c[1], c[2]); RectImageData.SetScalarComponentFromDouble(j - rect.Left, i - rect.Top, 0, 0, c[0]); } } RectPolyData = vtkPolyData.New(); RectPolyData.SetPoints(points); RectPolyData.GetPointData().SetScalars(colorArray); RectPolyData.Update(); }
public static void SaveRectData(string filename, vtkPolyData polyData, Rectangle rect) { try { SimplePointFile.OpenWriteFile(filename); var color = polyData.GetPointData().GetScalars(); for (var i = 0; i < rect.Height; i++) { for (var j = 0; j < rect.Width; j++) { var data = polyData.GetPoint(i * rect.Width + j); var c = color.GetComponent(i * rect.Width + j, 0); SimplePointFile.Writeline(new[] { data[0], data[1], data[2], c, c, c }); } } } catch (Exception) { } finally { SimplePointFile.CloseWriteFile(); } }
public static void SetHSectionPoints(Rectangle rect) { HZArray = vtkFloatArray.New(); HZArray.SetName("HZArray"); HZArray.SetNumberOfComponents(1); HArray = vtkFloatArray.New(); HArray.SetName("HArray"); HArray.SetNumberOfComponents(1); HSectionNum = rect.Height / 2; for (var i = 0; i < rect.Width; ++i) { HArray.InsertNextTuple1(i); HZArray.InsertNextTuple1(RectPolyData.GetPoint(HSectionNum * rect.Width + i)[2]); } }
public static List <double[]> ReadPolyDataPoints(this vtkPolyData polyData) { List <double[]> ret = new List <double[]>(); for (int i = 0; i < polyData.GetNumberOfPoints(); ++i) { ret.Add(polyData.GetPoint(i)); } return(ret); }
public static void SetColorByHeight(vtkPolyData data, Rectangle rect) { double zmin = data.GetPoint(0)[2]; double zmax = zmin; for (int i = 0; i < rect.Width * rect.Height; i++) { double z = data.GetPoint(i)[2]; if (z < zmin) { zmin = z; } if (z > zmax) { zmax = z; } } //Console.WriteLine("Zmin:" + zmin + " Zmax:" + zmax); vtkColorTransferFunction colorFunction = vtkColorTransferFunction.New(); colorFunction.AddRGBPoint(zmin, 0, 0, 1); colorFunction.AddRGBPoint(zmax, 1, 0, 0); //Console.WriteLine("Color:" + colorFunction.GetColor(0)[0] + " " // + colorFunction.GetColor(0)[1] + " " // + colorFunction.GetColor(0)[2]); for (int i = 0; i < rect.Width * rect.Height; i++) { double z = data.GetPoint(i)[2]; double[] c = colorFunction.GetColor(z); data.GetPointData().GetScalars().SetTuple3(i, c[0] * 255, c[1] * 255, c[2] * 255); } data.Modified(); }
private void PolyDataGetPoint() { // Create a sphere vtkSphereSource sphereSource = vtkSphereSource.New(); sphereSource.Update(); vtkPolyData polydata = sphereSource.GetOutput(); // Write all of the coordinates of the points in the vtkPolyData to the console. for (int i = 0; i < polydata.GetNumberOfPoints(); i++) { double[] p = polydata.GetPoint(i); // This is identical to: // double[] p = polydata.GetPoints().GetPoint(i); Console.WriteLine("Point " + i + " : (" + p[0] + " " + p[1] + " " + p[2] + ")"); } }
public static void SetMedianFilter(ref vtkPolyData polyData, Rectangle rect) { var image = vtkImageData.New(); image.SetExtent(0, rect.Width - 1, 0, rect.Height - 1, 0, 0); image.SetNumberOfScalarComponents(1); image.SetScalarTypeToDouble(); for (int i = 0; i < rect.Width * rect.Height; i++) { double[] d = polyData.GetPoint(i); image.SetScalarComponentFromDouble(i % rect.Width, i / rect.Width, 0, 0, d[2]); } image.Update(); var cast = vtkImageCast.New(); cast.SetInput(image); cast.SetOutputScalarTypeToUnsignedChar(); cast.Update(); var w = vtkBMPWriter.New(); w.SetInput(cast.GetOutput()); w.SetFileName("imgcastbyheight_beforefilter.bmp"); w.Update(); var medianFilter = vtkImageGaussianSmooth.New(); medianFilter.SetInput(image); medianFilter.SetDimensionality(2); medianFilter.SetRadiusFactor(10); medianFilter.SetStandardDeviation(3); medianFilter.Update(); //var medianFilter = vtkImageHybridMedian2D.New(); //medianFilter.SetInput(image); //medianFilter.Update(); var cast2 = vtkImageCast.New(); cast2.SetInput(medianFilter.GetOutput()); cast2.SetOutputScalarTypeToUnsignedChar(); cast2.Update(); var w2 = vtkBMPWriter.New(); w2.SetInput(cast2.GetOutput()); w2.SetFileName("imgcastbyheight_afterfilter.bmp"); w2.Update(); for (int i = 0; i < rect.Height; i++) { for (int j = 0; j < rect.Width; j++) { double d = medianFilter.GetOutput().GetScalarComponentAsFloat(j, i, 0, 0); polyData.GetPoints().SetPoint(i * rect.Width + j, j, i, (int)d); } } polyData.Update(); }
/// <summary> /// Generates a Unity Mesh from a vtkPolyData. /// </summary> /// <param name="pd">The vtk poly data.</param> /// <returns>The Unity Mesh (without colors).</returns> private static Mesh PolyDataToMesh(vtkPolyData pd) { if (pd == null) { Debug.LogWarning("No PolyData passed!"); return null; } var numVertices = pd.GetNumberOfPoints(); if (numVertices == 0) { Debug.LogWarning("No vertices to convert!"); return null; } var mesh = new Mesh(); // Points / Vertices var vertices = new Vector3[numVertices]; for (var i = 0; i < numVertices; ++i) { var pnt = pd.GetPoint(i); // Flip z-up to y-up vertices[i] = new Vector3(-(float) pnt[0], (float) pnt[2], (float) pnt[1]); } mesh.vertices = vertices; // Normals var vtkNormals = pd.GetPointData().GetNormals(); if (vtkNormals != null) { var numNormals = vtkNormals.GetNumberOfTuples(); var normals = new Vector3[numNormals]; for (var i = 0; i < numNormals; i++) { var normal = vtkNormals.GetTuple3(i); // flip normals ? normals[i] = new Vector3(-(float) normal[0], -(float) normal[1], -(float) normal[2]); } mesh.normals = normals; } else { Debug.Log("No Normals!"); } // Texture coordinates var vtkTexCoords = pd.GetPointData().GetTCoords(); if (vtkTexCoords != null) { var numCoords = vtkTexCoords.GetNumberOfTuples(); var uvs = new Vector2[numCoords]; for (var i = 0; i < numCoords; ++i) { var texCoords = vtkTexCoords.GetTuple2(i); uvs[i] = new Vector2((float) texCoords[0], (float) texCoords[1]); } mesh.uv = uvs; } // Triangles / Cells var numTriangles = pd.GetNumberOfPolys(); var polys = pd.GetPolys(); if (polys.GetNumberOfCells() > 0) { var triangles = new int[numTriangles*3]; var prim = 0; var pts = vtkIdList.New(); polys.InitTraversal(); while (polys.GetNextCell(pts) != 0) { for (var i = 0; i < pts.GetNumberOfIds(); ++i) triangles[prim*3 + i] = pts.GetId(i); ++prim; } mesh.SetTriangles(triangles, 0); //Mesh.RecalculateNormals(); mesh.RecalculateBounds(); return mesh; } // Lines var lines = pd.GetLines(); if (lines.GetNumberOfCells() > 0) { var idList = new ArrayList(); var pts = vtkIdList.New(); lines.InitTraversal(); while (lines.GetNextCell(pts) != 0) { for (var i = 0; i < pts.GetNumberOfIds() - 1; ++i) { idList.Add(pts.GetId(i)); idList.Add(pts.GetId(i + 1)); } } mesh.SetIndices(idList.ToArray(typeof (int)) as int[], MeshTopology.Lines, 0); mesh.RecalculateBounds(); return mesh; } // Points var points = pd.GetVerts(); var numPointCells = points.GetNumberOfCells(); if (numPointCells > 0) { var idList = new ArrayList(); var pts = vtkIdList.New(); points.InitTraversal(); while (points.GetNextCell(pts) != 0) { for (int i = 0; i < pts.GetNumberOfIds(); ++i) { idList.Add(pts.GetId(i)); } } mesh.SetIndices(idList.ToArray(typeof (int)) as int[], MeshTopology.Points, 0); mesh.RecalculateBounds(); } return mesh; }
private void ColoredElevationMap() { // Create a grid of points (height/terrian map) vtkPoints points = vtkPoints.New(); uint GridSize = 20; double xx, yy, zz; for (uint x = 0; x < GridSize; x++) { for (uint y = 0; y < GridSize; y++) { xx = x + vtkMath.Random(-.2, .2); yy = y + vtkMath.Random(-.2, .2); zz = vtkMath.Random(-.5, .5); points.InsertNextPoint(xx, yy, zz); } } // Add the grid points to a polydata object vtkPolyData inputPolyData = vtkPolyData.New(); inputPolyData.SetPoints(points); // Triangulate the grid points vtkDelaunay2D delaunay = vtkDelaunay2D.New(); #if VTK_MAJOR_VERSION_5 delaunay.SetInput(inputPolyData); #else delaunay.SetInputData(inputPolyData); #endif delaunay.Update(); vtkPolyData outputPolyData = delaunay.GetOutput(); double[] bounds = outputPolyData.GetBounds(); // Find min and max z double minz = bounds[4]; double maxz = bounds[5]; Debug.WriteLine("minz: " + minz); Debug.WriteLine("maxz: " + maxz); // Create the color map vtkLookupTable colorLookupTable = vtkLookupTable.New(); colorLookupTable.SetTableRange(minz, maxz); colorLookupTable.Build(); // Generate the colors for each point based on the color map vtkUnsignedCharArray colors = vtkUnsignedCharArray.New(); colors.SetNumberOfComponents(3); colors.SetName("Colors"); Debug.WriteLine("There are " + outputPolyData.GetNumberOfPoints() + " points."); #if UNSAFE // fastest way to fill color array colors.SetNumberOfTuples(outputPolyData.GetNumberOfPoints()); unsafe { byte *pColor = (byte *)colors.GetPointer(0).ToPointer(); for (int i = 0; i < outputPolyData.GetNumberOfPoints(); i++) { double[] p = outputPolyData.GetPoint(i); double[] dcolor = colorLookupTable.GetColor(p[2]); Debug.WriteLine("dcolor: " + dcolor[0] + " " + dcolor[1] + " " + dcolor[2]); byte[] color = new byte[3]; for (uint j = 0; j < 3; j++) { color[j] = (byte)(255 * dcolor[j]); } Debug.WriteLine("color: " + color[0] + " " + color[1] + " " + color[2]); *(pColor + 3 * i) = color[0]; *(pColor + 3 * i + 1) = color[1]; *(pColor + 3 * i + 2) = color[2]; } } #else for (int i = 0; i < outputPolyData.GetNumberOfPoints(); i++) { double[] p = outputPolyData.GetPoint(i); double[] dcolor = colorLookupTable.GetColor(p[2]); Debug.WriteLine("dcolor: " + dcolor[0] + " " + dcolor[1] + " " + dcolor[2]); byte[] color = new byte[3]; for (uint j = 0; j < 3; j++) { color[j] = (byte)(255 * dcolor[j]); } Debug.WriteLine("color: " + color[0] + " " + color[1] + " " + color[2]); colors.InsertNextTuple3(color[0], color[1], color[2]); //IntPtr pColor = Marshal.AllocHGlobal(Marshal.SizeOf(typeof(byte)) * 3); //Marshal.Copy(color, 0, pColor, 3); //colors.InsertNextTupleValue(pColor); //Marshal.FreeHGlobal(pColor); } #endif outputPolyData.GetPointData().SetScalars(colors); // Create a mapper and actor vtkPolyDataMapper mapper = vtkPolyDataMapper.New(); #if VTK_MAJOR_VERSION_5 mapper.SetInputConnection(outputPolyData.GetProducerPort()); #else mapper.SetInputData(outputPolyData); #endif vtkActor actor = vtkActor.New(); actor.SetMapper(mapper); // get a reference to the renderwindow of our renderWindowControl1 vtkRenderWindow renderWindow = renderWindowControl1.RenderWindow; // renderer vtkRenderer renderer = renderWindow.GetRenderers().GetFirstRenderer(); // set background color renderer.SetBackground(0.2, 0.3, 0.4); // add our actor to the renderer renderer.AddActor(actor); }
private void WeightedTransformFilter() { // Use a sphere as a basis of the shape vtkSphereSource sphere = vtkSphereSource.New(); sphere.SetPhiResolution(40); sphere.SetThetaResolution(40); sphere.Update(); vtkPolyData sphereData = sphere.GetOutput(); // Create a data array to hold the weighting coefficients vtkFloatArray tfarray = vtkFloatArray.New(); int npoints = sphereData.GetNumberOfPoints(); tfarray.SetNumberOfComponents(2); tfarray.SetNumberOfTuples(npoints); // Parameterize the sphere along the z axis, and fill the weights // with (1.0-a, a) to linearly interpolate across the shape IntPtr pPoint = Marshal.AllocHGlobal(Marshal.SizeOf(typeof(double)) * 3); double[] point = new double[3]; for (int i = 0; i < npoints; i++) { sphereData.GetPoint(i, pPoint); Marshal.Copy(pPoint, point, 0, 3); double x = point[0]; double y = point[1]; double z = point[2]; double zn = z + 0.5; double zn1 = 1.0 - zn; if (zn > 1.0) { zn = 1.0; } if (zn1 < 0.0) { zn1 = 0.0; } tfarray.SetComponent(i, 0, zn1); tfarray.SetComponent(i, 1, zn); } Marshal.FreeHGlobal(pPoint); // Create field data to hold the array, and bind it to the sphere vtkFieldData fd = vtkFieldData.New(); tfarray.SetName("weights"); sphereData.GetPointData().AddArray(tfarray); // Use an ordinary transform to stretch the shape vtkTransform stretch = vtkTransform.New(); stretch.Scale(1, 1, 3.2); vtkTransformFilter stretchFilter = vtkTransformFilter.New(); stretchFilter.SetInputConnection(sphereData.GetProducerPort()); stretchFilter.SetTransform(stretch); // Now, for the weighted transform stuff vtkWeightedTransformFilter weightedTrans = vtkWeightedTransformFilter.New(); // Create two transforms to interpolate between vtkTransform identity = vtkTransform.New(); identity.Identity(); vtkTransform rotated = vtkTransform.New(); double rotatedAngle = 45; rotated.RotateX(rotatedAngle); weightedTrans.SetNumberOfTransforms(2); weightedTrans.SetTransform(identity, 0); weightedTrans.SetTransform(rotated, 1); // which data array should the filter use ? weightedTrans.SetWeightArray("weights"); weightedTrans.SetInputConnection(stretchFilter.GetOutputPort()); vtkPolyDataMapper weightedTransMapper = vtkPolyDataMapper.New(); weightedTransMapper.SetInputConnection(weightedTrans.GetOutputPort()); vtkActor weightedTransActor = vtkActor.New(); weightedTransActor.SetMapper(weightedTransMapper); weightedTransActor.GetProperty().SetDiffuseColor(0.8, 0.8, 0.1); weightedTransActor.GetProperty().SetRepresentationToSurface(); // get a reference to the renderwindow of our renderWindowControl1 vtkRenderWindow renderWindow = renderWindowControl1.RenderWindow; // renderer vtkRenderer renderer = renderWindow.GetRenderers().GetFirstRenderer(); // set background color renderer.SetBackground(0.2, 0.3, 0.4); // add our actor to the renderer renderer.AddActor(weightedTransActor); renderer.ResetCamera(); renderer.GetActiveCamera().Azimuth(90); renderer.GetActiveCamera().Dolly(1); }
public bool Read_Poly_Data_File(string filename) { //Initalize VTK Reader vtkXMLPolyDataReader reader = new vtkXMLPolyDataReader(); reader.SetFileName(filename); reader.Update(); vtkPolyData polydata = reader.GetOutput(); if (polydata == null) { Console.ForegroundColor = ConsoleColor.Red; Console.WriteLine("Invalid Poly data Input"); return(false); } // Read Point Coordinates int numPoints = (int)polydata.GetNumberOfPoints(); List <Vector3d> point_dat = new List <Vector3d>(); if (numPoints != 0) { double[] pt; for (int i = 0; i < numPoints; i++) { pt = polydata.GetPoint(i); point_dat.Add(new Vector3d((float)pt[0], (float)pt[1], (float)pt[2])); } if (this.vertex_data.ContainsKey("vertices")) { this.vertex_data["vertices"] = point_dat; } else { this.vertex_data.Add("vertices", point_dat); } Console.WriteLine("All points read in correctly!"); } else { Console.ForegroundColor = ConsoleColor.Red; Console.WriteLine("---------------No Points existent"); } // Read Point Indices int numpolydatacells = (int)polydata.GetNumberOfCells(); vtkCell polydataCell; vtkIdList pts; if (numpolydatacells != 0) { int counter = 0; cells.SetNumberOfCells(numpolydatacells); for (int i = 0; i < numpolydatacells; i++) { polydataCell = polydata.GetCell(i); int numCellPoints = (int)polydataCell.GetNumberOfPoints(); cells.InsertNextCell(polydataCell); Vector3 trianglePoints = new Vector3(); if (numCellPoints == 3) { pts = polydataCell.GetPointIds(); int one = (int)pts.GetId(0); int two = (int)pts.GetId(1); int three = (int)pts.GetId(2); //this.Get_Triangle(counter, pts); trianglePoints = new Vector3(one, two, three); counter++; } triangleList.Add(trianglePoints); } } else { Console.ForegroundColor = ConsoleColor.Red; Console.WriteLine("---------------No Triangles existent"); } // Read point data vtkPointData pointData = polydata.GetPointData(); // Load point attributes this.Load_Point_Attributes(pointData); return(true); }
private void SelectAreaClick(vtkObject sender, vtkObjectEventArgs e) { int[] clickPos = Inter.GetEventPosition(); vtkAreaPicker picker = vtkAreaPicker.New(); picker.AreaPick(clickPos[0], clickPos[1], clickPos[0] + 100, clickPos[1] + 100, Viewport); if (picker.GetActor() != null) { vtkPlanes Boundary = picker.GetFrustum(); vtkExtractGeometry Box = vtkExtractGeometry.New(); Box.SetImplicitFunction(Boundary); Box.SetInput(picker.GetActor().GetMapper().GetInput()); vtkVertexGlyphFilter glyphFilter = vtkVertexGlyphFilter.New(); glyphFilter.SetInputConnection(Box.GetOutputPort()); glyphFilter.Update(); vtkPolyData selected = glyphFilter.GetOutput(); vtkPoints points = vtkPoints.New(); vtkUnstructuredGrid grid = vtkUnstructuredGrid.New(); for (int i = 0; i < selected.GetNumberOfPoints(); i++) { points.InsertNextPoint(selected.GetPoint(i)[0], selected.GetPoint(i)[1], selected.GetPoint(i)[2]); } grid.SetPoints(points); vtkSphereSource sphere = vtkSphereSource.New(); sphere.SetPhiResolution(6); sphere.SetThetaResolution(6); sphere.SetRadius(0.1); vtkGlyph3D glyph3D = vtkGlyph3D.New(); glyph3D.SetInput(grid); glyph3D.SetSourceConnection(sphere.GetOutputPort()); vtkPolyDataMapper mapper = vtkPolyDataMapper.New(); mapper.SetInputConnection(glyph3D.GetOutputPort()); //double[] P = new double[3]; //bool selected = false; //vtkPoints points = Faces.GetPoints(); //double[] ClickedPoint = PointPicker.GetActor().GetMapper().GetInput().GetPoint(PointPicker.GetPointId()); //for (int i = 0; i < points.GetNumberOfPoints(); i++) //{ // if (Math.Abs(points.GetPoint(i)[0] - ClickedPoint[0]) < 1e-6 && // Math.Abs(points.GetPoint(i)[1] - ClickedPoint[1]) < 1e-6 && // Math.Abs(points.GetPoint(i)[2] - ClickedPoint[2]) < 1e-6) // { // selected = true; // P = points.GetPoint(i); // break; // } //} // //if (selected == true) //{ // SelectionPoints.InsertNextPoint(P[0], P[1], P[2]); // // SelectionGlyph = vtkGlyph3D.New(); // SelectionGlyph.SetInput(SelectionPolyData); // SelectionGlyph.SetSourceConnection(SelectionSphere.GetOutputPort()); // SelectionMapper.SetInputConnection(SelectionGlyph.GetOutputPort()); // // // Refresh Viewport // Refresh(); //} } }